숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 가지고 있는지 아닌지를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다. 두 숫자 카드에 같은 수가 적혀있는 경우는 없다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 가지고 있는 숫자 카드인지 아닌지를 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 가지고 있으면 1을, 아니면 0을 공백으로 구분해 출력한다.

제한사항

• 시간 제한: 2초
• 메모리 제한: 256MB

입출력 예

예제 입력 1

5
6 3 2 10 -10
8
10 9 -5 2 3 4 5 -10

예제 출력 1

1 0 0 1 1 0 0 1

문제 유형 분류

• 자료구조
• 탐색 (Search)
• 해시셋 / 이진 탐색

시간 복잡도 + 공간복잡도 추정

• N, M ≤ 500,000 → O(N x M) 불가능
• 효율적인 탐색 필요

해시셋(set) 사용 시

• 입력 저장: O(N)
• 탐색 M번: O(1) 평균 → 총 O(N + M)
• 공간복잡도: O(N) (카드 저장용)

이진 탐색 사용 시 (정렬 필요)

• 정렬: O(N log N)
• 탐색 M번: O(M log N)

총 O(N log N + M log N)

둘 다 충분히 시간 내 가능 (2초 제한)

적합한 알고리즘 / 자료구조

• 해시셋 (set) 또는 이진 탐색 (Binary Search)

  → 둘 중 set이 가장 간단하고 빠름

  (문제에서 중복 없는 카드라고 했기 때문에 set에 적합)

필요한 라이브러리

• sys.stdin.readline (입력 빠르게 받기 위해)
• 또는 bisect (이진 탐색 방식 선택 시)

최악의 경우 시뮬레이션

• N = M = 500,000일 때
  • set 사용 시: 약 100만 연산 (충분히 처리 가능)
  • list + in: O(N x M) → 시간 초과 발생

접근 방법

1. 숫자 카드를 set에 저장
2. M개의 숫자 각각에 대해 in 연산
3. 결과를 리스트로 저장하고 출력

최종 코드

import sys

# 입력 빠르게
input = sys.stdin.readline

# 입력 처리
N = int(input())
cards = set(map(int, input().split()))
M = int(input())
queries = list(map(int, input().split()))

# 탐색
result = []
for num in queries:
    if num in cards:
        result.append('1')
    else:
        result.append('0')

# 출력
print(' '.join(result))

추가 팁 / 주의사항 / 많이 실수하는 점

• input() 대신 sys.stdin.readline() 사용해야 시간 초과 방지 가능
• 출력은 join으로 처리해야 시간 절약됨 (print(…, end=’ ‘)보다 빠름)
• list로 탐색하면 시간 초과 (in이 O(N)임)
• Python3는 set 탐색이 평균 O(1)이라 매우 적합

N x N개의 수가 N x N 크기의 표에 채워져 있다. (x1, y1)부터 (x2, y2)까지 합을 구하는 프로그램을 작성하시오. (x, y)는 x행 y열을 의미한다.

예를 들어, N = 4이고, 표가 아래와 같이 채워져 있는 경우를 살펴보자.

여기서 (2, 2)부터 (3, 4)까지 합을 구하면 3+4+5+4+5+6 = 27이고, (4, 4)부터 (4, 4)까지 합을 구하면 7이다.

표에 채워져 있는 수와 합을 구하는 연산이 주어졌을 때, 이를 처리하는 프로그램을 작성하시오.

입력

첫째 줄에 표의 크기 N과 합을 구해야하는 횟수 M이 주어진다. (1 ≤ N ≤ 1024, 1 ≤ M ≤ 100,000) 둘째 줄부터 N개의 줄에는 표에 채워져 있는 수가 1행부터 차례대로 주어진다. 다음 M개의 줄에는 네 개의 정수 x1, y1, x2, y2가 주어지며, (x1, y1)부터 (x2, y2)의 합을 구해 출력해야 한다. 표에 채워져 있는 수는 1,000보다 작거나 같은 자연수이다. (x1 ≤ x2, y1 ≤ y2)

출력

총 M줄에 걸쳐 (x1, y1)부터 (x2, y2)까지 합을 구해 출력한다.

제한사항

시간 제한: 1초

메모리 제한: 256MB

입출력 예

예제 입력 1

4 3
1 2 3 4
2 3 4 5
3 4 5 6
4 5 6 7
2 2 3 4
3 4 3 4 
1 1 4 4

예제 출력 1

27
6
64

예제 입력 2

2 4
1 2
3 4
1 1 1 1
1 2 1 2
2 1 2 1
2 2 2 2

예제 출력 2

1
2
3
4

문제 유형 분류

• 누적합 (2차원 Prefix Sum)
• 구간 합 처리
• 구현

시간 복잡도 + 공간복잡도 추정

• 표 생성: O(N$^2$)
• 2차원 누적합 배열 생성: O(N$^2$)
• 각 쿼리 처리: O(1) (누적합 이용 시)
• 총 쿼리 수: 최대 100,000 → 브루트포스로 하면 시간 초과 발생

총 시간 복잡도 : O(N$^2$ + M)

공간 복잡도: O(N$^2$)

적합한 알고리즘 / 자료구조

• 2차원 누적합(Prefix Sum)
• 일반 리스트 arr와 누적합 배열 prefix_sum 2개 사용

필요한 라이브러리

import sys
input = sys.stdin.readline

시간 초과 방지를 위해 빠른 입력 함수 사용

최악의 경우 시뮬레이션

• N = 1024, M = 100000일 때
  • 단순하게 브루트포스로 각 영역의 합을 직접 더하면 O(N$^2$ * M) → 최악 1000억 연산 → 시간 초과
  • 2차원 누적합으로 변환 시 → O(M) 쿼리 처리 가능

접근 방법

1. 입력을 받고 arr이라는 2차원 배열을 만든다.
2. 2차원 누적합 배열 prefix_sum을 만든다.
   • prefix_sum[i][j] = arr[1][1]부터 arr[i][j]까지의 합
   • prefix_sum[i][j] = prefix_sum[i-1][j] + prefix_sum[i][j-1] - prefix_sum[i-1][j-1] + arr[i][j]
3. 쿼리 (x1, y1, x2, y2)에 대해 합을 구하는 공식 사용

S = prefix[x2][y2]
    - prefix[x1-1][y2]
    - prefix[x2][y1-1]
    + prefix[x1-1][y1-1]

1. 쿼리마다 위 공식을 써서 답을 출력한다.

최종 코드

import sys
input = sys.stdin.readline

n, m = map(int, input().split())
arr = [[0] * (n+1)] # 1-based index를 위해 padding

for _ in range(n):
    arr.append([0] + list(map(int, input().split())))

# 누적합 배열 생성
prefix = [ [0] * (n + 1) for _ in range(n + 1) ]

for i in range(1, n + 1):
    for j in range(1, n + 1):
        prefix[i][j] = prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1] + arr[i][j]

# 쿼리 처리
for _ in range(m):
    x1, y1, x2, y2 = map(int, input().split())
    res = prefix[x2][y2] - prefix[x1-1][y2] - prefix[x2][y1-1] + prefix[x1-1][y1-1]
    print(res)

import sys
input = sys.stdin.readline

n, m = map(int, input().splut())
arr = [[0] * (n+1)]
'''
첫 번째 줄이 4 3일 경우

arr = [[0] * (n+1)] 해석
n = 4이니까 n + 1 = 5
즉, arr = [[0, 0, 0, 0, 0]]
"0번째 행을 dummy로 채워넣기"
'''

for _ in range(n):
    arr.append([0] + list(map(int, input().split())))
'''
다음 입력이 주어진다면
1 2 3 4
2 3 4 5
3 4 5 6
4 5 6 7

arr = 
[[0, 0, 0, 0, 0],
 [0, 1, 2, 3, 4],
 [0, 2, 3, 4, 5],
 [0, 3, 4, 5, 6],
 [0, 4, 5, 6, 7]]
'''

for i in range(1, n + 1):
    for j in range(1, n + 1):
        prefix[i][j] = prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1] + arr[i][j]
'''
arr =
  j→   1   2   3   4
i↓  -----------------
1  |  1   2   3   4
2  |  2   3   4   5
3  |  3   4   5   6
4  |  4   5   6   7

prefix[2][3]을 계산한다고 해보자.
우리가 원하는 영역
(1, 1) (1, 2) (1, 3)
(2, 1) (2, 2) (2, 3)
6칸의 합을 구하고 싶음

prefix[2][3] = 
        prefix[1][3] <- 위쪽 누적합
    + prefix[2][2] <- 왼쪽 누적합
    - prefix[1][2] <- 겹치는 영역 제거
    + arr[2][3]    <- 현재 셀 값 더함

prefix[1][3]: (1, 1) ~ (1, 3) -> 1 + 2 + 3 = 6
prefix[2][2]: (1, 1) ~ (2, 2) -> 1 + 2 + 2 + 3 = 8
prefix[1][2]: (1, 1) ~ (1, 2) -> 1 + 2 = 3
arr[2][3]:                    -> 4

prefix[2][3] = 6 + 8 - 3 + 4 = 15
'''

추가 팁 / 주의사항 / 많이 실수하는 점

왜 0-based가 아닌 1-based로 arr과 prefix_sum 배열을 만드는가?

2차원 누적합(Prefix Sum) 공식을 단순화하기 위해 사용

0-based index를 쓴다면 (0, 0)좌표도 실제 데이터로 사용해야 하지만 prefix[x1-1][y2] 또는 prefix[x1-1][y1-1]에서 -1이 나오면 인덱스 에러가 남 → if x1 == 0일 때는 별도 처리, 예외처리 코드를 매번 넣어줘야 함

누적합 공식은 어떻게 유도되었는가?

1. 한 번에 직접 더한다면?

    total = 0
    for i in range(x1, x2+1):
        for j in range(y1, y2+1):
            total += arr[i][j]

   시간복잡도: O((x2 - x1 + 1) * (y2 - y1 + 1))

   최악의 경우 1024 x 1024 = 1,048,576번 덧셈

   쿼리 100,000개면 1000억번 연산 = 터짐

2. 미리 계산해두는 방식 필요

   한 번만 전체를 훑고, 쿼리마다 바로 결과를 꺼내자

   이걸 가능하게 하려면 직사각형을 부분 합들로 나누는 방식이 수학적으로 가장 효율적

    prefix[i][j] = (1,1) ~ (i,j)의 합

   이걸 만들 때 전체를 매번 더하면 O(N²),

   하지만 부분을 누적하면서 만들면 O(1)씩 누적 가능

3. 왜 “가로 + 세로 - 겹침 + 자기” 구조인가?

        j
    i  ┌─────────────┐
       │             │
       │             │  ← prefix[i][j] (전체)
       │             │
       └─────────────┘

   • prefix[i-1][j]: 위쪽 전체

   • prefix[i][j-1]: 왼쪽 전체

   • prefix[i-1][j-1]: 위+왼쪽 겹침 (빼줘야 함)

   • arr[i][j]: 현재 셀

     방식	시간 복잡도	설명
     직접 더하기	O(N²)	쿼리마다 전체 계산
     누적합 사용	O(1)	덧셈 4번이면 끝

     덧셈 연산의 중복을 없애고 사전 계산한 값으로 한 번에 즉시 꺼내기 위해

   • 이 계산을 하면 최대 100,000개 쿼리도 즉시 처리 가능

   • 공식이 덧셈/뺄셈만으로 계산 가능해서 CPU에 부담 없음

   • 겹치는 영역만 잘 제거해주면 여러 방향으로 응용 가능 (3차원도 가능)

수 N개가 주어졌을 때, i번째 수부터 j번째 수까지 합을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N과 합을 구해야 하는 횟수 M이 주어진다. 둘째 줄에는 N개의 수가 주어진다. 수는 1,000보다 작거나 같은 자연수이다. 셋째 줄부터 M개의 줄에는 합을 구해야 하는 구간 i와 j가 주어진다.

출력

총 M개의 줄에 입력으로 주어진 i번째 수부터 j번째 수까지 합을 출력한다.

제한사항

• 1 ≤ N ≤ 100,000
• 1 ≤ M ≤ 100,000
• 1 ≤ i ≤ j ≤ N
• 시간 제한: 1초
• 메모리 제한 256MB

입출력 예

예제 입력 1

5 3
5 4 3 2 1
1 3
2 4
5 5

예제 출력 1

12
9
1

문제 유형 분류

• 누적합(Prefix Sum)
• 구간 합(Query)
• 자료구조 기초

시간 복잡도 + 공간복잡도 추정

• 수의 개수 N, 질의 수 M: 최대 100,000 → O(N + M) 알고리즘 필요
• 브루트포스로 구간합을 직접 계산하면 → O(M x N) → 시간 초과
• 누적합(Prefix Sum) 활용 시
  • 전처리: O(N)
  • 쿼리 응답: O(1)
• 총 시간복잡도 = O(N + M)
• 공간 복잡도: O(N) (누적합 저장용 배열)

적합한 알고리즘 / 자료구조

• 누적합 배열
• 배열 인덱스 주의 (1-based / 0-based)

필요한 라이브러리

• sys.stdin.readline → 빠른 입력 처리
• itertools.accumulate (선택)

최악의 경우 시뮬레이션

N = 100_000
M = 100_000
누적합 → O(N) = 1e5
M번 쿼리 → O(M) = 1e5
→ 총 연산량 약 200,000 → 1초 내 가능 (충분)

접근 방법

1. 누적합 배열 생성
   • prefix_sum[i] = A[1] + A[2] + ... + A[i]
2. i부터 j까지의 구간합 = prefix_sum[j] - prefix_sum[i-1]
3. 입력은 1-based이므로 prefix_sum[0] = 0으로 설정

최종 코드

import sys
input = sys.stdin.readline

# 입력 처리
n, m = map(int, input().split())
nums = list(map(int, input().split()))

# 누적합 배열 생성 (prefix_sum[0] = 0)
prefix_sum = [0]
for num in nums:
    prefix_sum.append(prefix_sum[-1] + num)

# 질의 처리
for _ in range(m):
    i, j = map(int, input().split())
    print(prefix_sum[j] - prefix_sum[i - 1])

주의사항

• 인덱스 착각 (1-based인데 0-based로 처리함)
• 입력이 너무 많을 때 input() 대신 sys.stdin.readline() 안 씀 → 시간 초과

딥러닝 기반 이미지 객체 탐지 분야로 첫 프로젝트를 시작하게 됐습니다.

처음엔 막막함 그 자체였습니다. 어디서부터 시작해야 할지, 어떤 모델을 써야 할지, 하나부터 열까지 전부 낯설고 두려웠습니다. 이 글에는 그 막막함을 시작으로 얽힌 매듭을 하나씩 풀어가며 문제를 정리한 과정이 담겨있습니다.

혹시나 저처럼 어떻게 시작해야할지 몰라서 막막한 분들이 있다면 도움이 되는 글이었으면 좋겠습니다. 진지하게 읽어주셔도 좋고, 가볍게 재미로 흘려보셔도 괜찮습니다.

데이터 이전에, 맥락부터

가장 먼저 마주한 건 이 프로젝트가 다루는 “경구 약제”라는 특수한 도메인이었습니다. 단순히 모델을 돌리기보다는 이 도메인을 제대로 이해하고, 데이터가 담고 있는 특성을 먼저 파악하는 것이 우선이라는 생각이 들었습니다.

이미지 처리나 객체 탐지에 대한 전문적인 딥러닝 지식이 부족했고, 어떤 모델이 적합할지조차 명확하지 않은 상태였습니다. 그렇기 때문에 초기 전략을 비슷한 도메인과 유사한 태스크를 어떻게 접근했는지를 먼저 탐색하고 이해하는 데에 집중하는 것으로 잡았습니다.

첫째로, 다양한 객체 탐지 모델을 리서치하고, 각각의 모델이 어떤 구조적 특성과 장단점을 갖는지 비교 분석 했습니다. 특히 이번 프로젝트에 사용할 Google Colab T4 환경에서 실험 가능한 자원과 시간 제약을 고려해 현실적으로 여러 번 실험할 수 있는 가벼운 구조인지, 성능을 위해 어느 정도 리소스를 투자해야 하는 모델인지 등을 검토해봤습니다.

또한, 실제로 경구 약제와 유사한 도메인에서 객체 탐지를 진행한 사례들을 찾아보고자 했습니다. 어떤 기준으로 모델을 선택했는지, 중요하게 본 요소는 무엇이고 어떤 이슈가 있었는지, 정확도를 위해 어떤 전략을 사용했는지를 중심으로 봤습니다.

최고의 레시피를 찾아

모델 리서치하는 과정에서 다양한 논문을 참고했습니다. 가장 먼저 대표적인 one-stage detection 방식인 YOLO 시리즈[10][11]와, two-stage detection 방식의 Faster R-CNN[12] 같은 object detection 모델들을 중심으로 살펴보며 구조적 차이와 성능 특성을 비교했습니다. 그리고 약제와 같은 특수 도메인에서 활용된 fine-grained classification, OCR 기반 인식, prompt tuning, 멀티모달 융합 등 다양한 방식들을 제안한 논문들까지 추가로 참고했습니다.

One-state detection 모델은 이미지를 한 번에 처리해 객체의 위치와 클래스를 동시에 예측하는 방식으로 YOLO 시리즈와 SSD가 있습니다. 빠르고 가벼워서 실시간 처리에 적합하다는 장점이 있습니다.

Two-stage detection 모델은 이미지 내에서 Region Proposal을 뽑고 그 영역에 대해 정밀한 분류와 박스 조정을 수행하는 방식입니다. Faster R-CNN이 그 예이며 정확도는 높지만 연산량이 많고 속도가 느려 실시간 처리에는 적합하지 않습니다.

추가로 본 논문 중 가장 유의 깊게 봤던 건 OCR 기반 접근 [7]이었습니다. 약제에 새겨진 각인을 탐지하고 인식하는 구조가 생각보다 정교하게 발전했다는 걸 알았고 유사한 약제에 대해 각인 정보를 추가로 조합하면 좋은 예측 성능을 낼 수 있을 거라고 생각했습니다.

ViT 기반의 Visual Prompt Tuning 논문 [8]에서는 데이터가 부족한 클래스에 대해 few-shot 방식으로 대처합니다. 클래스가 많고 데이터가 한정적일수록 클래스 불균형이 더 심할거라고 생각해서 불균형 해소 방법을 염두해두고 있었지만 oversampling이나 class-weight 외에 few-shot 방식으로 해결할 수도 있다는 걸 처음 알았습니다.

Multimodal Pill ID 리뷰 [9]에서는 단순히 이미지를 넣는 방식이 아니라 색상·형태·각인 정보를 각각 따로 처리하고 최종적으로 종합 판단하는 방식이 소개됐습니다. 이미 데이터셋을 다 본 지금 관점에서 보자면, JSON 파일에 이러한 정보들이 세분화되어 담겨있었기 때문에 좋은 실험 방법이었다고 생각됩니다.

그 외에도 Pill-ID, Fine-grained Attenion 기반 모델 [5] 등을 참고했지만 처음 접하는 내용들이 너무나도 많았기 때문에(Transformer 등) ‘경구 약제 객체 탐지 task를 실험할 수 있는 방법이 정말 무궁무진하구나’라고만 생각하고 가볍게 봤습니다. 몇 없는 지식으로 여러 정보를 머릿속에 담자니 더 보다간 과부화만 올 것 같았습니다.

이 외로 비슷한 테스크의 자료들을 참고했습니다. 여러 참고 자료들이 있었고 YOLO 기반 객체 탐지에 OCR과 분류 모델을 결합한 파이프라인 [1], AI Hub에서 제공하는 ResNet 기반 Baseline [2]등 저희 테스크에 맞는 자료들도 존재했습니다. 하지만 세부적으로 어떤 실험을 거쳤고 왜 최종 모델로 선정했는지 등은 알 수 없어 참고용으로만 확인했습니다. [3][4]

최종적으로 저희 팀은 YOLOv8n를 실험의 baseline으로 선택했습니다. 처음에는 구조가 가볍고 실험 반복하기 적합하다는 점에서 YOLOv8n를 기준으로 삼았고 이후에는 성능 향상과 최신 구조 반영을 위해 YOLOv11을 실험했습니다. 또한 비교군으로 Faster R-CNN, YOLO + OCR 조합, ResNet + YOLOv8 연계 구조도 함께 테스트했습니다.

본격적으로

저희 팀의 프로젝트 목표는 두 가지였습니다. 첫째, 이 테스크 전용 Kaggle 리더보드에서 가능한 한 높은 점수를 기록하는 것. 둘째, 실제 경구 약제를 정확하게 탐지하고 분류할 수 있는 모델을 만드는 것이었습니다.

이 두 가지를 위해 실험 전략을 짰습니다. 먼저, 다양한 객체 탐지 모델을 폭넓게 실험해본 뒤, 가장 성능이 우수한 모델을 선정합니다. 그리고 해당 모델의 구조를 분석해 성능을 더 끌어올릴 수 있는 모든 요소(하이퍼파라미터, 증강, 학습 기법, 후처리 방식 등)을 적극적으로 조정하고 개선했습니다.

시행착오를 겪으며

하지만 실험은 항상 뜻대로 흘러가지 않았습니다. 프로젝트는 2주 간 진행됐고, 많은 시행착오가 발생했습니다.

1. 데이터 정제에 소요된 과도한 시간 초기 데이터셋에는 이미지 누락, 바운딩 박스 오류, 라벨 누락 등 여러 문제가 있었고, 수작업으로 보완하며 JSON 파일을 새로 생성하는 데만 약 2일이 소요됐습니다. 특히 약제의 앞면과 뒷면이 동일한 클래스로 처리되어 있어 시각적으로는 완전히 다른 두 이미지를 같은 클래스로 다뤄야 한다는 문제는 끝내 해결하지 못했습니다. 프로젝트가 끝날 무렵 AI Hub에서 누락된 이미지를 포함한 데이터셋을 다시 받을 수 있다는 걸 알아 이 또한 진행했지만 라벨 오류를 정제하는 데 여전히 많은 시간을 쏟아야 했습니다.

   바운딩 박스 오류 예시 ↑ 클래스 오분류 예시 ↑

2. 다양한 실험에도 불변하는 성능 데이터셋을 정제한 후 여러 모델(YOLOv8/v11, Faster R-CNN)을 실험한 결과, Kaggle 리더보드에는 거의 동일한 점수(0.99532)가 반복됐습니다. 이를 해결하기 위해 다양한 방식의 augmentation을 시도했습니다. 모듈을 통한 강한 증강/약한 증강, 알약 누끼를 따서 검은 배경 위에 유사 알약을 배치한 synthetic 이미지 생성, 오분류 사례 중심의 배경 포토샵 자동화, crop & collage 방식 등. 학습 구조도 크기(s/m/l)와 loss function(focal loss), 하이퍼파라미터까지 다양하게 조정했지만 점수는 변하지 않았습니다.

   synthetic 이미지 생성 예시 ↑ 강한 증강 예시 ↑ . 원인을 찾기 위해 여러 방법을 시도해보다가 훈련 이미지와 테스트 이미지 간의 유사도 분석을 해봤습니다. SSIM을 사용해 두 이미지 간의 시각적 유사도를 비교했고 그 결과 전체 테스트셋의 80% 이상이 SSIM 1.0으로 훈련 이미지와 일치한다는 사실을 발견했습니다. 결국 나중에서야 데이터 누수 문제가 근본 원인이라는 것을 알게 됐습니다. 또한 테스트셋 내 일부 이미지에는 라벨 오류까지 포함돼 있었기 때문에, 점수 자체가 실제 모델의 일반화 성능을 반영하지 못한다는 문제도 있었습니다.

3. 증강이 성능을 떨어뜨렸던 이유 augmentation 강도를 높일수록 오히려 성능이 저하되는 현상도 겪었습니다. 처음에는 일반화 실패라고 생각했지만, 실제로는 데이터 누수와 테스트셋 특성이 원인이었습니다. 훈련 데이터와 테스트 데이터가 대부분 동일한 환경(조명, 배경, 각도 등)에서 촬영된 유사한 이미지들이었기 때문에 훈련 이미지를 과하게 변형하면 오히려 테스트셋과 괴리감이 생겨 성능이 떨어졌습니다. 결국 이 프로젝트에서는 일반화보다 ‘훈련셋과 최대한 유사한 이미지’를 그대로 보여주는 쪽이 더 높은 점수를 내는 구조였고, 증강이 실제로 도움이 되지 않았던 셈입니다.

4. 사소한 실수가 성능 저하로 이어짐 모델 학습 시 원본 이미지의 입력 해상도를 설정할 때 (height, width) 대신 (width, height)로 잘못 기입하여 성능이 저하되는 실수도 있었습니다.

5. 클래스 불균형 문제의 한계 전체 클래스 수는 많은 반면 클래스별 이미지 수가 매우 적어 불균형 문제가 심각했습니다. 한 이미지에 여러 알약이 담겨 있는 데이터셋 특성상 클래스 균형을 고려한 학습이 구조적으로 어려웠고, train/val 분리도 제대로 수행하지 못했습니다. 임의로 증강한 데이터를 validation set으로 사용했습니다. 클래스 불균형에 대해서는, 오버샘플링이나 focal loss를 적용하는 것, 증강 외에도 rare class에 대해 few-shot 학습 구조나 prototype 기반 분류기를 도입해보거나, class-aware sampling 전략으로 학습 배치를 조정하는 등 여러 시도를 해보면 좋았겠다는 아쉬움이 남는 것 같습니다.

6. 실험 코드 관리의 어려움 첫 프로젝트였기에 실험을 반복할수록 코드가 복잡해지고 비효율적으로 정리되지 않는 문제가 발생했습니다. 실험별 버전을 체계적으로 기록하지 못했고, git을 적극적으로 활용하지 않아 비슷한 코드를 계속 반복해서 작성해야 했던 비효율성이 컸습니다. 다음 프로젝트에서는 실험 단위별 버전 관리와 코드 구조화에 더 신경써보려고 합니다.

성능 평가 결과

YOLOv8n 모델은 mAP@50 기준 0.993, 추론 속도 98FPS라는 우수한 성능을 보였습니다.

Faster R-CNN은 높은 정확도를 가질 것이라는 기대와는 다르게 mAP@50-95가 0.807로 다소 낮은 성능을 보였습니다. NMS 튜닝 부족, rare class에 대한 적응 실패, 연산량이 많아 충분히 학습을 돌리지 못한 점 등이 복합적으로 작용한 결과라고 판단했습니다. 또한 mAP@50 대비 mAP@50-95가 급격히 낮아지는 건 과적합의 명확한 신호였습니다.

실제로 다양한 실험에서도 과적합 문제가 계속 나타났습니다. focal loss, EMA, label smoothing 등의 학습 기법을 적용해봤고, 다양한 증강 기법도 시도했지만 성능에는 거의 영향을 주지 못했습니다.

OCR도 실험의 주요 요소였습니다. EasyOCR과 Tesserack 두 가지 엔진을 활용해 한글과 영문 인식 성능을 비교해봤고, EasyOCR이 평균 인식률 98% 이상으로 우수한 결과를 보였습니다. 그러나 실제 약제명과의 일치율은 기대에 미치지 못했습니다. 텍스트 인식 자체는 잘 되지만 회전된 이미지, 배경 노이즈, 저조도 환경 등에서 인식률이 급격히 떨어졌고, 약제명은 단순 문자열이 아니라 정제된 형태소 기반 이름이라 후처리 없이 활용하기엔 어려움이 컸습니다.

잘 예측한 예 (BSP)

예측하지 못한 예 (No Text)

YOLO와 ResNet을 결합한 two-stage 실험도 진행했습니다. YOLO가 객체를 탐지하고, cropped 이미지를 ResNet18이 분류하는 구조였는데, YOLOv8n 대비 약 0.0065의 성능 상승이 있었고, cascade 방식에 비해 연산량이 적고 효율적이었습니다. 하지만 성능 변화가 미미했고, 이후 소수 클래스에 대한 보완을 임베딩 기반이나 트랜스포머 계열 분류기로 확장해보았다면 더 좋은 실험 방법이 됐을 것 같습니다.

하지만 주어진 테스트셋의 심각한 누수 문제로 인해 모든 수치 성능은 일반화 적용에 신뢰하기 어려운 면이 있었습니다. 그래서 라벨이 없는 외부 이미지 12장을 대상으로 정성 평가를 진행했습니다. 그 결과, 강한 증강으로 학습한 대형 모델인 YOLOv11이 더 많은 객체를 정확히 탐지했고, 약한 증강만 한 작은 모델보다 일반화 성능이 좋다는 걸 있었습니다.

마치며

첫 프로젝트를 진행하면서는 ‘아 이번 프로젝트 망했네. 어떻게 수습할까?’라는 생각 뿐이었습니다. 하나도 내 뜻대로 되는 게 없었고, 순조롭게 흘러가지 않았고, 결과도 엉망인 것처럼 느껴졌습니다. 하지만 되돌아보니 그만큼 많이 배우고 성장한 시간이었습니다.

무엇보다 가장 어려웠던 점은 실험을 반복하는 과정에서 Git이나 폴더 구조를 체계적으로 정리하지 못했던 점입니다. 실험을 거듭할수록 코드는 점점 복잡해지는데, 나중에 어떤 코드가 어떤 실험을 위한 것인지 혼란스러워졌습니다. 구조화된 실험 관리의 중요성을 절실히 느꼈습니다.

그리고 두 번째로 어려웠던 건, 어떤 시도가 성능에 어떤 영향을 주는지에 대한 판단이 부족했다는 점입니다. 다양한 요소를 건드려보긴 했지만, 무엇이 진짜 중요한지 감을 잡지 못하고 시간만 빠르게 흘러갔던 순간들이 많았습니다. 특히 점수가 높게 나올 때도 이유를 명확히 파악하지 못한 채 마냥 좋아했던 건 아쉬움으로 남습니다.

세 번째로, 실엄의 정량적 결과를 체계적으로 기록하지 못했던 점입니다. 실험마다 어떤 학습기법을 사용했고 어떤 후처리를 적용했는지에 대한 로그가 누락되거나 불완전한 경우가 많았습니다. 나중에 어떤 방식이 효과적이었는지 되짚어보기 쉽지 않았습니다.

마지막으로, 프로젝트 초반에 설정한 리더보드 점수 높이는 것과 탐지 정확도 극대화하는 두 가지 목표에만 집착하다 보니 모델의 일반화 성능을 고려한 폭넓은 실험은 오히려 놓치게 됐습니다. 다양한 증강 기법이나 모델 조합은 실험했지만, 결과적으로는 리더보드 점수에 영향을 주지 않는 실험은 생략하게 됐고 이게 오히려 실험의 깊이를 얕게 만든 원인이기도 했습니다.

다음 프로젝트에서는 전처리, 학습, 후처리 각 단계마다 중간 점검과 검증 단계를 명확히 두고 Git을 통해 실험 버전을 정리하며 각 실험의 전략과 결과, 적용한 학습기법과 후처리 내용 등을 자세히 기록하고 사전 조사 내용을 실험 설계에 적극적으로 반영하면 좋을 것 같다는 생각을 했습니다.

이번 프로젝트는 성능 좋은 모델을 만드는 경험 뿐만 아니라 하나의 프로젝트를 처음부터 끝까지 어떻게 이끌고 기록하며 마무리할 수 있을지 연습하는 시간이었다고 생각합니다. 매듭 묶인 실을 처음 풀어보니 이렇게도 건들여보고 저렇게도 건들여봐서 실이 엉망진창이 되고 엉성하게 풀렸다는 느낌을 지울 수 없는 다사다난한 첫 프로젝트였지만 ‘뭐라도 하면 풀리긴 풀리는구나..’ 싶었습니다. 이 글을 읽는 분들께 조금이나마 도움이 되었기를 바랍니다. 읽어주셔서 감사합니다.

최종 코드는 아래 GitHub에서 확인하실 수 있습니다. https://github.com/Team-Epoch-4/Project

매일 아침 9시에 학교에서 측정한 온도가 어떤 정수의 수열로 주어졌을 때, 연속적인 며칠 동안의 온도의 합이 가장 큰 값을 알아보고자 한다.

예를 들어, 아래와 같이 10일 간의 온도가 주어졌을 떄,

3 -2 -4 -9 0 3 7 13 8 -3

모든 연속적인 이틀간의 온도의 합은 아래와 같다.

이때, 온도의 합이 가장 큰 값은 21이다.

또 다른 예로 위와 같은 온도가 주어졌을 때, 모든 연속적인 5일 간의 온도의 합은 아래와 같으며,

이때, 온도의 합이 가장 큰 값은 31이다.

매일 측정한 온도가 정수의 수열로 주어졌을 때, 연속적인 며칠 동안의 온도의 합이 가장 큰 값을 계산하는 프로그램을 작성하시오.

입력

첫째 줄에는 두 개의 정수 N과 K가 한 개의 공백을 사이에 두고 순서대로 주어진다. 첫 번째 정수 N은 온도를 측정한 전체 날짜의 수이다. N은 2 이상 100,000 이하이다. 두 번째 정수 K는 합을 구하기 위한 연속적인 날짜의 수이다. K는 1과 N 사이의 정수이다. 둘째 줄에는 매일 측정한 온도를 나타내는 N개의 정수가 빈칸을 사이에 두고 주어진다. 이 수들은 모두 -100 이상 100 이하이다.

출력

첫째 줄에는 입력되는 온도의 수열에서 연속적인 K일의 온도의 합이 최대가 되는 값을 출력한다.

제한사항

• 시간 제한: 1초
• 메모리 제한: 128MB

입출력 예

예제 입력 1

10 2
3 -2 -4 -9 0 3 7 13 8 -3

예제 출력 1

21

예제 입력 2

10 5
3 -2 -4 -9 0 3 7 13 8 -3

예제 출력 2

31

문제 유형 분류

• 슬라이딩 윈도우
• 누적합 (prefix sum) (보조 방식)
• 최댓값 계산

시간 복잡도 + 공간복잡도 추정

• 시간복잡도: O(N)
  • 슬라이딩 윈도우로 처음에 K개 더한 뒤, 한 칸씩 이동하면서 O(1)씩 갱신
• 공간복잡도: O(N) (입력 저장 배열만 사용)

적합한 알고리즘 / 자료구조

• 슬라이딩 윈도우

필요한 라이브러리

• 없음 (기본 함수로 충분)

최악의 경우 시뮬레이션

접근 방법

1. N, K, 온도 수열 입력받기
2. 초기 구간 합 (sum(temp[0:K])) 계산
3. 인덱스 i=K부터 N-1까지 슬라이딩 윈도우로 갱신
   • current_sum = current_sum + temp[i] - temp[i-K]
   • max_sum = max(max_sum, current_sum)
4. 최댓값 출력

최종 코드

# 입력
N, K = map(int, input().split())
temps = list(map(int, input().split()))

# 초기 합 (0번째 ~ K-1번째)
current_sum = sum(temps[:K])
max_sum = current_sum

# 슬라이딩 윈도우: 한 칸씩 옮기면서 최대합 찾기
for i in range(K, N):
    current_sum = current_sum + temps[i] - temps[i - K]
    max_sum = max(max_sum, current_sum)

# 출력
print(max_sum)

주의사항

• sum() 매번 쓰면 시간복잡도 O(N·K) → 시간 초과
• 인덱스 범위 초과 주의 (e.g., temps[i-K])

도현이는 바구니를 총 N개 가지고 있고, 각각의 바구니에는 1번부터 N번까지 번호가 순서대로 적혀져 있다. 바구니는 일렬로 놓여져 있고, 가장 왼쪽 바구니를 1번째 바구니, 그 다음 바구니를 2번째 바구니, …, 가장 오른쪽 바구니를 N번째 바구니라고 부른다.

도현이는 앞으로 M번 바구니의 순서를 역순으로 만들려고 한다. 도현이는 한 번 순서를 역순으로 바꿀 때, 순서를 역순으로 만들 범위를 정하고, 그 범위에 들어있는 바구니의 순서를 역순으로 만든다.

바구니의 순서를 어떻게 바꿀지 주어졌을 때, M번 바구니의 순서를 역순으로 만든 다음, 바구니에 적혀있는 번호를 가장 왼쪽 바구니부터 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 N(1 ≤ N ≤ 100)과 M(1 ≤ M ≤ 100)이 주어진다.

둘째 줄부터 M개의 줄에는 바구니의 순서를 역순으로 만드는 방법이 주어진다. 방법은 i j로 나타내고, 왼쪽으로부터 i번째 바구니부터 j번째 바구니의 순서를 역순으로 만든다는 뜻이다. (1 ≤ i ≤ j ≤ N)

도현이는 입력으로 주어진 순서대로 바구니의 순서를 바꾼다.

출력

모든 순서를 바꾼 다음에, 가장 왼쪽에 있는 바구니부터 바구니에 적혀있는 순서를 공백으로 구분해 출력한다.

제한사항

입출력 예

예제 입력 1

5 4
1 2
3 4
1 4
2 2

문제 유형 분류

• 리스트 인덱싱
• 슬라이싱 + reverse
• 시뮬레이션

시간 복잡도 + 공간복잡도 추정

• 시간복잡도
  • 각 연산 O(k), 최악 M=100, K=100 → O(M·K) = O(10,000) 수준 → 매우 작음
• 공간복잡도: O(N) → 바구니 상태 저장 리스트

적합한 알고리즘 / 자료구조

• 리스트(list)
• 슬라이싱(list[i:j])
• reversed() or [::-1]

필요한 라이브러리

• 없음 (기본 input(), 리스트 연산만 사용)

최악의 경우 시뮬레이션

접근 방법

1. 바구니 초기 상태 = [1, 2, …, N] 생성
2. M개의 연산에 대해
   • 입력 i, j를 받아 → 리스트는 0-based 인덱스이므로 i-1 ~ j
   • baskets[i-1:j] = reversed(baskets[i-1:j])
3. 마지막 바구니 상태 출력

최종 코드

# 입력
N, M = map(int, input().split())

# 초기 바구니 상태: [1, 2, ..., N]
baskets = list(range(1, N + 1))

# M번의 역순 명령 처리
for _ in range(M):
    i, j = map(int, input().split())
    baskets[i-1:j] = reversed(baskets[i-1:j])  # 슬라이싱은 [start:end+1]

# 출력
print(*baskets)

주의할 점

• 리스트 인덱스는 0-based, 입력은 1-based → 꼭 i-1, j로 처리
• reversed()는 iterator → 다시 리스트에 할당 시 list(…) 또는 슬라이싱으로 덮어써야 함
• print(*baskets)는 요소를 공백 구분해 출력

"OOXXOXXOOO"와 같은 OX퀴즈의 결과가 있다. O는 문제를 맞은 것이고, X는 문제를 틀린 것이다. 문제를 맞은 경우 그 문제의 점수는 그 문제까지 연속된 O의 개수가 된다. 예를 들어, 10번 문제의 점수는 3이 된다.

"OOXXOXXOOO"의 점수는 1+2+0+0+1+0+0+1+2+3 = 10점이다.

OX퀴즈의 결과가 주어졌을 때, 점수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고, 길이가 0보다 크고 80보다 작은 문자열이 주어진다. 문자열은 O와 X만으로 이루어져 있다.

출력

각 테스트 케이스마다 점수를 출력한다.

제한사항

입출력 예

예제 입력 1

5
OOXXOXXOOO
OOXXOOXXOO
OXOXOXOXOXOXOX
OOOOOOOOOO
OOOOXOOOOXOOOOX

예제 출력 1

10
9
7
55
30

문제 유형 분류

• 문자열 처리
• 시뮬레이션
• 누적 합 (accumulation)

시간 복잡도 + 공간복잡도 추정

• 시간복잡도: O(N) (문자열 길이 N ≤ 80, 최대 T=100이면 총 8000 → 매우 작음)
• 공간복잡도: O(1) (문자열 하나씩 처리하며 누적)

적합한 알고리즘 / 자료구조

• for 루프 + 카운터 변수

필요한 라이브러리

• 불필요 (표준 input(), print() 만으로 충분)

최악의 경우 시뮬레이션

접근 방법

1. 테스트 케이스 개수 T 입력
2. 각 문자열 s에 대해
   • score = 0, streak = 0
   • 각 문자 c가 0이면 streak += 1, score += streak
   • c가 X면 streak = 0
3. 점수 출력

최종 코드

T = int(input())

for _ in range(T):
    s = input()
    score = 0
    streak = 0
    for c in s:
        if c == 'O':
            streak += 1
            score += streak
        else:
            streak = 0
    print(score)

빠른 입력 처리 버전 (sys.stdin, map() 사용)

import sys

T = int(sys.stdin.readline())

for _ in range(T):
    line = sys.stdin.readline().strip()
    score = 0
    streak = 0
    for c in line:
        if c == 'O':
            streak += 1
            score += streak
        else:
            streak = 0
    print(score)

세준이는 기말고사를 망쳤다. 세준이는 점수를 조작해서 집에 가져가기로 했다. 일단 세준이는 자기 점수 중에서 최댓값을 골랐다. 이 값을 M이라고 한다. 그리고 나서 모든 점수를 점수/M*100으로 고쳤다.

예를 들어, 세준이의 최고점이 70이고, 수학점수가 50이었으면 수학점수는 50/70*100이 되어 71.43점이 된다.

세준이의 성정을 위의 방법대로 새로 계산했을 때, 새로운 평균을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 시험 본 과목의 개수 N이 주어진다. 이 값은 1000보다 작거나 같다. 둘째 줄에 세준이의 현재 성적이 주어진다. 이 값은 100보다 작거나 같은 음이 아닌 정수이고, 적어도 하나의 값은 0보다 크다.

출력

첫째 줄에 새로운 평균을 출력한다. 실제 정답과 출력값의 절대오차 또는 상대오차가 $10^{-2}$이하이면 정답이다.

제한사항

입출력 예

예제 입력 1

3
40 80 60

예제 출력 1

75.0

예제 입력 2

3
10 20 30

예제 출력 2

66.666667

문제 유형 분류

• 리스트 계산
• 정규화 (Normalization)
• 평균 계산 (평균 = 합계 / 개수)
• 실수 오차 처리 (출력 오차 제한 조건 포함)

시간 복잡도 + 공간복잡도 추정

• 시간복잡도

  • max(scores) → O(N)

  • 조정된 점수 리스트 생성 → O(N)

  • sum() → O(N)

    총 O(N)

• 공간복잡도: O(N) → 점수 리스트 저장

적합한 알고리즘 / 자료구조

• max(), sum(), 리스트 컴프리헨션

필요한 라이브러리

• 기본 input(), map(), max(), sum() 사용
• round() 또는 format() 함수로 소수점 제어 가능

최악의 경우 시뮬레이션

접근 방법

1. 점수 개수 N을 입력받음
2. 점수 리스트 scores 입력받음
3. max_score = max(scores) 계산
4. new_scores = [(score / max_score) * 100 for score in scores]
5. 평균 = sum(new_scores) / N
6. 출력 (소수점 6자리 이상 보여주기)

최종 코드

# 입력
N = int(input())
scores = list(map(int, input().split()))

# 최댓값
max_score = max(scores)

# 점수 조정
new_scores = [(score / max_score) * 100 for score in scores]

# 평균 계산
average = sum(new_scores) / N

# 출력
print(round(average, 6))

9개의 서로 다른 자연수가 주어질 때, 이들 중 최댓값을 찾고 그 최댓값이 몇 번째 수인지를 구하는 프로그램을 작성하시오.

예를 들어, 서로 다른 9개의 자연수

3, 29, 38, 12, 57, 74, 40, 85, 61

이 주어지면, 이들 중 최댓값은 85이고, 이 값은 8번째 수이다.

입력

첫째 줄부터 아홉 번째 줄까지 한 줄에 하나의 자연수가 주어진다. 주어지는 자연수는 100보다 작다.

출력

첫째 줄에 최댓값을 출력하고, 둘째 줄에 최댓값이 몇 번째 수인지를 출력한다.

제한사항

입출력 예

예제 입력 1

3
29
38
12
57
74
40
85
61

예제 출력 1

85
8

문제 유형 분류

• 배열/리스트 처리
• 순차 탐색 (시퀀스 순회)
• 최댓값 및 인덱스 추출

시간 복잡도 + 공간복잡도 추정

• 시간복잡도: O(9) → 입력된 9개 숫자만 순회
• 공간복잡도: O(9) → 리스트에 저장

적합한 알고리즘 / 자료구조

• 리스트(list)
• max() 함수, index() 함수

필요한 라이브러리

• 없음 (input(), max(), index()만 사용)

최악의 경우 시뮬레이션

• 입력이 무작위로 주어져도 최댓값을 찾는 데는 한 번의 순회면 충분함

접근 방법

1. 9개의 수를 리스트에 저장
2. max()로 최댓값 찾기
3. list.index(max_value) + 1로 위치 찾기 (1-based index)
4. 출력

최종 코드

# 입력 받기
numbers = [int(input()) for _ in range(9)]

# 최댓값 찾기
max_value = max(numbers)

# 위치 찾기 (1부터 시작)
position = numbers.index(max_value) + 1

# 출력
print(max_value)
print(position)

enumerate 사용

# 입력 받기
numbers = [int(input()) for _ in range(9)]

# 초기값 설정
max_value = -1
max_index = -1

# enumerate로 인덱스와 값 동시에 순회
for idx, num in enumerate(numbers):
    if num > max_value:
        max_value = num
        max_index = idx  # 0-based index

# 출력 (문제는 1-based index 요구)
print(max_value)
print(max_index + 1)

조건 검증

• “서로 다른” 자연수라는 조건이 있지만, 로직상 크게 영향을 미치지 않음 (단, 동일한 최대값이 여러 개일 경우엔 index()가 가장 먼저 나오는 인덱스 반환)

세 개의 자연수 A, B, C가 주어질 때 A x B x C를 계산한 결과에 0부터 9까지 각각의 숫자가 몇 번씩 쓰였는지를 구하는 프로그램을 작성하시오.

예를 들어 A = 150, B = 266, C = 427이라면 A x B x C = 150 x 266 x 427 = 17037300이 되고, 계산한 결과 17037300에는 0이 3번, 1이 1번, 3이 2번, 7이 2번 쓰였다.

입력

첫째 줄에 A, 둘째 줄에 B, 셋째 줄에 C가 주어진다. A, B, C는 모두 100보다 크거나 같고, 1,000보다 작은 자연수이다.

출력

첫째줄에는 A x B x C의 결과에 0이 몇 번 쓰였는지 출력한다. 마찬가지로 둘째 줄부터 열 번째 줄까지 A x B x C의 결과에 1부터 9까지의 숫자가 각각 몇 번 쓰였는지 차례로 한 줄에 하나씩 출력한다.

제한사항

입출력 예

예제 입력 1

150
266
427

예제 출력 1

3
1
0
2
0
0
0
2
0
0

문제 유형 분류

• 문자열 처리
• 시뮬레이션
• 빈도수 세기 (카운팅)

시간 복잡도 + 공간복잡도 추정

• 시간복잡도
  • 곱셈은 O(1), 문자열 변환은 O(N) (N은 숫자 자릿수, 최대 10자리 이하)
  • 전체적으로 O(N)
• 공간복잡도
  • O(10) → 0~9까지 개수를 저장하는 리스트

적합한 알고리즘 / 자료구조

• 문자열 반환(str())
• 리스트 인덱싱
• count() 함수 or for문으로 직접 카운팅

필요한 라이브러리

• 표준 입력 함수 (input()), 별도 외부 라이브러리 불필요

최악의 경우 시뮬레이션

• A = B = C = 999 → 결과는 약 9자리 숫자
• 충분히 문자열로 변환해 처리 가능

접근 방법

1. A, B, C 입력 받기
2. A × B × C 계산
3. 결과를 문자열로 변환
4. 0부터 9까지 순회하면서 .count(str(i)) 또는 직접 카운팅
5. 각 숫자별 등장 횟수 출력

최종 코드

# 입력
A = int(input())
B = int(input())
C = int(input())

# 곱셈 결과
result = A * B * C

# 문자열로 변환
result_str = str(result)

# 0~9 숫자 카운트
for i in range(10):
    print(result_str.count(str(i)))

추가 팁

• collections.Counter로도 가능하지만 이 문제에서는 단순한 리스트와 문자열 메서드로 충분함
• 출력 순서에 주의 (0부터 9까지 순서대로)

나코더 기장 재민이는 동아리 회식을 준비하기 위해서 장부를 관리하는 중이다.

재현이는 재민이를 도와서 돈을 관리하는 중인데, 애석하게도 항상 정신없는 재현이는 돈을 실수로 잘못 부르는 사고를 치기 일쑤였다.

재현이는 잘못된 수를 부를 때마다 0을 외쳐서, 가장 최근에 재민이가 쓴 수를 지우게 시킨다.

재민이는 이렇게 모든 수를 받아 적은 후 그 수의 합을 알고 싶어 한다. 재민이를 도와주자!

제한사항

입출력 예

입력

첫 번째 줄에 정수 K가 주어진다. (1 ≤ K ≤ 100,000)

이후 K개의 줄에 정수가 1개씩 주어진다. 정수는 0에서 1,000,000 사이의 값을 가지며, 정수가 “0”일 경우에는 가장 최근에 쓴 수를 지우고, 아닐 경우 해당 수를 쓴다.

정수가 “0”일 경우에 지울 수 있는 수가 있음을 보장할 수 있다.

출력

재민이가 최종적으로 적어 낸 수의 합을 출력한다. 최종적으로 적어낸 수의 합은 $2^{31}-1$보다 작거나 같은 정수이다.

문제 유형 분류

• 자료구조
• 스택 (stack)
• 시뮬레이션

시간 복잡도 + 공간 복잡도 추정

• 시간 복잡도: O(K)
  • 각 입력마다 push 또는 pop 연산을 한 번씩만 수행
• 공간 복잡도: O(K)
  • 최악의 경우 모든 숫자를 저장해야 하므로 K개 저장

적합한 알고리즘 / 자료구조

• 스택 사용
  • 0이 나오면 가장 최근 값을 지워야 하므로 후입선출 구조(LIFO)인 스택이 적절하다

필요한 라이브러리

• 별도의 외부 라이브러리 불필요
• list를 스택처럼 사용 (append, pop)

최악의 경우 시뮬레이션

• K = 100,000, 모든 수가 1이거나 1,000,000이라면 총합 최대는 1,000,000 * 100,000 = 100,000,000,000이지만 문제 조건에서는 결과 $2^{31} - 1$ 이하로 제한되어 안전한 입력만 주어짐

접근 방법

1. 입력 받은 숫자를 순서대로 처리
2. 0이면 스택에서 pop
3. 0이 아니면 스택에 push
4. 반복 종료 후 스택의 모든 숫자 합산

최종 코드

K = int(input())
stack = []

for _ in range(K):
    num = int(input())
    if num == 0:
        stack.pop()
    else:
        stack.append(num)

print(sum(stack))

괄호 문자열(Parenthesis String, PS)은 두 개의 괄호 기호인 ‘(’ 와 ‘)’ 만으로 구성되어 있는 문자열이다.

그 중에서 괄호의 모양이 바르게 구성된 문자열을 올바른 괄호 문자열(Valid PS, VPS)이라고 부른다. 한 쌍의 괄호 기호로 된 “( )” 문자열은 기본 VPS 이라고 부른다.

만일 x 가 VPS 라면 이것을 하나의 괄호에 넣은 새로운 문자열 “(x)”도 VPS 가 된다. 그리고 두 VPS x 와 y를 접합(concatenation)시킨 새로운 문자열 xy도 VPS 가 된다. 예를 들어 “(())()”와 “((()))” 는 VPS 이지만 “(()(”, “(())()))” , 그리고 “(()” 는 모두 VPS 가 아닌 문자열이다.

여러분은 입력으로 주어진 괄호 문자열이 VPS 인지 아닌지를 판단해서 그 결과를 YES 와 NO 로 나타내어야 한다.

제한사항

입출력 예

입력

입력 데이터는 표준 입력을 사용한다. 입력은 T개의 테스트 데이터로 주어진다. 입력의 첫 번째 줄에는 입력 데이터의 수를 나타내는 정수 T가 주어진다. 각 테스트 데이터의 첫째 줄에는 괄호 문자열이 한 줄에 주어진다. 하나의 괄호 문자열의 길이는 2 이상 50 이하이다.

6
(())())
(((()())()
(()())((()))
((()()(()))(((())))()
()()()()(()()())()
(()((())()(

출력

출력은 표준 출력을 사용한다. 만일 입력 괄호 문자열이 올바른 괄호 문자열(VPS)이면 “YES”, 아니면 “NO”를 한 줄에 하나씩 차례대로 출력해야 한다.

NO
NO
YES
NO
YES
NO

문제 유형 분류

• 자료구조: 스택(Stack)
• 문자열 처리
• 시뮬레이션 / 괄호 검증

시간 복잡도 + 공간복잡도 추정

• 시간 복잡도 : O(N) (N = 괄호 문자열 길이, 최대 50)
• 공간 복잡도 : O(N) (스택 사용 시 최대 길이만큼 쌓일 수 있음)

적합한 알고리즘 / 자료구조

• 스택 : 여는 괄호 (가 나오면 push, 닫는 괄호 )가 나오면 pop
• 대안 : 스택 없이 count(+)를 쓰는 방식도 가능 ((이면 +1, )이면 -1)

필요한 라이브러리

• 별도 라이브러리 필요 없음 (기본 list로 스택 구현 가능)

최악의 경우 시뮬레이션

• 모든 문자가 닫는 괄호 )로 시작하거나 여는 괄호로 끝날 경우, 스택이 계속 쌓이거나 비어있지 않음
• 스택이 중간에 비었는데 )가 나오면 → 잘못된 VPS
• 마지막에 스택이 남아있으면 → 잘못된 VPS
• () ) () () ( ()

접근 방법

1. 문자열을 왼쪽부터 한 글자씩 순화
2. 여는 괄호 (이면 스택에 push
3. 닫는 괄호 )이면
   • 스택이 비었으면 VPS 아님 → NO
   • 아니면 스택에서 pop
4. 순회가 끝난 후
   • 스택이 비어 있으면 VPS → YES
   • 비어 있지 않으면 VPS 아님 → NO

최종 코드

T = int(input())
for _ in range(T):
    s = input()
    stack = []
    is_vps = True

    for char in s:
        if char == '(':
            stack.append(char)
        else:  # char == ')'
            if not stack:
                is_vps = False
                break
            stack.pop()

    if stack:
        is_vps = False

    print("YES" if is_vps else "NO")

대안 코드 (카운터 방식, 스택 없이)

T = int(input())
for _ in range(T):
    s = input()
    count = 0
    is_vps = True

    for char in s:
        if char == '(':
            count += 1
        else:
            count -= 1
        if count < 0:
            is_vps = False
            break

    if count != 0:
        is_vps = False

    print("YES" if is_vps else "NO")

동전 1

n가지 종류의 동전이 있습니다. 각각의 동전이 나타내는 가치는 다르며, 이 동전들을 적당히 사용해서 그 가치의 합이 k원이 되도록 하는 경우의 수를 구하는 프로그램을 작성하세요.

각각의 동전은 몇 개라도 사용할 수 있으며, 사용한 동전의 구성이 같은데 순서만 다른 것은 같은 경우로 취급합니다.

입력 형식

1. 첫째 줄에 두 개의 정수 n과 k가 주어집니다.
   • n: 동전의 종류 개수 (1 ≤ n ≤ 100)
   • k: 만들어야 하는 금액 (1 ≤ k ≤ 10,000)
2. 다음 n개의 줄에는 각각의 동전의 가치가 주어집니다.
   • 각 동전의 가치는 100,000보다 작거나 같은 자연수입니다.

출력 형식

1. 첫째 줄에 경우의 수를 출력합니다.
   • 경우의 수는 2^31보다 작습니다.

입출력 예

예제 입력 1

3 10
1
2
5

예제 출력 1

10

문제 유형 분류

• 전형적인 동전 조합의 수를 구하는 동적 계획법(DP) 문제
• 중복 순서는 허용하지 않으므로 조합(combination)을 구하는 문제
• 각 동전은 무한히 사용할 수 있으므로 완전 탐색보다는 DP로 누적해서 처리

시간 복잡도 + 공간복잡도 추정

• 시간복잡도: $O(n * k)$

  (각 동전에 대해 1원부터 k원까지 반복)

• 공간복잡도: $O(k)$

  (1차원 dp 배열 사용)

적합한 알고리즘 / 자료구조

• DP (Dynamic Programming)
• dp[i]: i원을 만드는 경우의 수

필요한 라이브러리

최악의 경우 시뮬레이션

접근 방법

1. dp[0] = 1로 초기화

   • 0원을 만드는 경우는 “동전을 하나도 사용하지 않는 방법” 1가지

2. 각 동전에 대해

    for coin in coins:
        for i in range(coin, k + 1):
            dp[i] += dp[i - coin]

   • 현재 금액 i원을 만들기 위해 coin을 추가했을 때, i - coin원을 만들 수 있는 경우의 수를 더함.

   • dp[i] += dp[i - coin]

     → i - coin원을 만들 수 있다면 거기에 coin을 하나 더해서 i원을 만들 수 있다는 의미

   • 동전 종류를 바깥 루프로 돌면 순서가 다른 구성은 중복으로 세지 않게 됩니다.

최종 코드

Ver 1

n, k = map(int, input().split())
coins = [int(input()) for _ in range(n)]

dp = [0] * (k + 1)
dp[0] = 1  # 0원을 만드는 경우는 1가지

for coin in coins:
    for i in range(coin, k + 1):
        dp[i] += dp[i - coin]

print(dp[k])

Ver 2

def count_coin_cases(n, k, coins):
    dp = [0] * (k + 1)
    dp[0] = 1  # 0원을 만드는 경우는 1가지 (아무 동전도 사용하지 않음)

    for coin in coins:
        for j in range(coin, k + 1):
            dp[j] += dp[j - coin]  # 현재 동전을 사용하는 경우의 수 추가

    return dp[k]  # k원을 만드는 모든 경우의 수 반환

# 입력 처리
n, k = map(int, input().split())
coins = [int(input()) for _ in range(n)]

print(count_coin_cases(n, k, coins))

선물을 직접 전하기 힘들 떄 카카오톡 선물하기 기능을 이용해 축하 선물을 보낼 수 있습니다. 당신의 친구들이 이번 달까지 선물을 주고받은 기록을 바탕으로 다음 달에 누가 선물을 많이 받을지 예측하려고 합니다.

• 두 사람이 선물을 주고받은 기록이 있다면, 이번 달까지 두 사람 사이에 더 많은 선물을 준 사람이 다음 달에 선물을 하나 받습니다.

  • 예를 들어 A가 B에게 선물을 5번 줬고, B가 A에게 선물을 3번 줬다면 다음 달엔 A가 B에게 선물을 하나 받습니다.

• 두 사람이 선물을 주고받은 기록이 하나도 없거나 주고받은 수가 같다면, 선물 지수가 더 큰 사람이 선물 지수가 더 작은 사람에게 선물을 하나 받습니다.

  • 선물 지수는 이번 달까지 자신이 친구들에게 준 선물의 수에서 받은 선물의 수를 뺀 값입니다.
  • 예를 들어 A가 친구들에게 준 선물이 3개고 받은 선물이 10개라면 A의 선물 지수는 -7입니다. B가 친구들에게 준 선물이 3개고 받은 선물이 2개라면 B의 선물 지수는 1입니다. 만약 A와 B가 선물을 주고받은 적이 없거나 정확히 같은 수로 선물을 주고받았다면, 다음 달엔 B가 A에게 선물을 하나 받습니다.
  • 만약 두 사람의 선물 지수도 같다면 다음 달에 선물을 주고받지 않습니다.

위에서 설명한 규칙대로 다음 달에 선물을 주고받을 때, 당신은 선물을 가장 많이 받을 친구가 받을 선물의 수를 알고 싶습니다.

친구들의 이름을 담은 1차원 문자열 배열 friends 이번 달까지 친구들이 주고받은 선물 기록을 담은 1차원 문자열 배열 gifts가 매개변수로 주어집니다. 이때, 다음달에 가장 많은 선물을 받는 친구가 받을 선물의 수를 return 하도록 soluttion 함수를 완성해 주세요.

제한사항

• 2 <= friends의 길이 = 친구들의 수 <= 50
  • friends의 원소는 친구의 이름을 의미하는 알파벳 소문자로 이루어진 길이가 10 이하인 문자열입니다.
  • 이름이 같은 친구는 없습니다.
• 1 <= gifts의 길이 <= 10,000
  • gifts의 원소는 A B 형태의 문자열입니다. A는 선물을 준 친구의 이름을 B는 선물을 받은 친구의 이름을 의미하며 공백 하나로 구분됩니다.
  • A와 B는 friends의 원소이며 A와 B가 같은 이름인 경우는 존재하지 않습니다.

입출력 예

입출력 예 # 1

주고받은 선물과 선물 지수를 표로 나타내면 다음과 같습니다.

muzi는 선물을 더 많이 줬던 frodo에게서 선물을 하나 받습니다. ryan은 선물을 더 많이 줬던 muzi에게서 선물을 하나 받고, 선물을 주고받지 않았던 neo보다 선물 지수가 커 선물을 하나 받습니다. frodo는 선물을 더 많이 줬던 ryan에게 선물을 하나 받습니다. neo는 선물을 더 많이 줬던 muzi에게서 선물을 하나 받고, 선물을 주고받지 않았던 frodo보다 선물 지수가 커 선물을 하나 받습니다.

다음달에 가장 선물을 많이 받는 사람은 ryan과 neo이고 2개의 선물을 받습니다. 따라서 2를 return 해야 합니다.

입출력 예 # 2

주고받은 선물과 선물 지수를 표로 나타내면 다음과 같습니다.

alessandro가 선물을 더 많이 줬던 joy, brad, conan에게서 선물을 3개 받습니다. 선물을 하나씩 주고받은 david보다 선물 지수가 커 선물을 하나 받습니다. david는 선물을 주고받지 않았던 joy, brad, conan보다 선물 지수가 커 다음 달에 선물을 3개 받습니다. joy, brad, conan은 선물을 받지 못합니다.

다음달에 가장 선물을 많이 받는 사람은 alessandro이고 4개의 선물을 받습니다. 따라서 4를 return 해야 합니다.

입출력 예 #3

a와 b, a와 c, b와 c 사이에 서로 선물을 주고받은 수도 같고 세 사람의 선물 지수도 0으로 같아 다음 달엔 아무도 선물을 받지 못합니다. 따라서 0을 return 해야 합니다.

문제 유형 분류

시뮬레이션 문제 규칙에 따라 상태를 계산하고 그 결과를 판단하는 조건 기반 시뮬레이션 유형

시간복잡도 생각

friends: 최대 50명 gifts: 최대 10,000건

모든 친구 쌍을 비교해도 50 x 50 = 2500회 → 충분히 가능

$O(N^2)$ 시뮬레이션 구조로 구현해도 무방함

적합한 알고리즘 / 자료구조

[1] 필요한 구조

• 이름 → 인덱스 매핑: 친구 이름을 리스트 index로 매핑 (dict)
• 선물 주고받은 기록: 2차원 배열 (gifts[i][j] = i가 j에게 준 수)
• 선물 지수 계산: 주고받은 총합 저장 (준 선물 수, 받은 선물 수)
• 다음달 받을 선물 개수 계산: 2중 루프

[2] 핵심 자료구조

• gift_table[i][j]: i가 j에게 준 선물 수
• gift_score[i]: 선물 지수 = 준 선물 - 받은 선물
• next_received[i]: 다음 달 받을 선물 수
• 경계값 / 예외 케이스 고민
  • 선물 주고받은 적 없는 친구 쌍
  • 선물 횟수가 같음
  • 선물 지수가 같음
  • 받은 선물 수가 0일 수도 있음
  • 선물 지수가 음수일 수도 있음 → 조건문에 이런 케이스를 반드시 명시해줘야 함

시간복잡도 + 공간복잡도 추정

필요한 라이브러리

기본 내장 라이브러리로 충분 (딕셔너리, 리스트만 사용)

최악의 경우 시뮬레이션

• 50명의 친구가 모두 서로 선물을 주고받는 경우
• gift 배열이 10,000개인 경우
• 선물 지수/선물 기록이 모두 동일한 경우

→ 이 모든 경우에서도 로직이 잘 작동해야 함

정리된 접근 방법

• 이름 → 인덱스 매핑

name_to_idx = {name: i for i, name in enumerate(friends)}

• 선물 주고받기 기록 저장 (2차원 배열)

gift_table = [[0]*n for _ in range(n)]

# 부연 설명
gift_table = [
   [0, 0, 0, 0],  # 0번째 친구가 다른 친구들에게 준 선물 수
   [0, 0, 0, 0],  # 1번째 친구가 ...
   [0, 0, 0, 0],
   [0, 0, 0, 0]
]

• 선물 지수 계산 (준 개수 - 받은 개수)

send = [0]*n
receive = [0]*n

• 모든 친구 쌍을 비교해서 다음 달 받을 선물 계산

for i in range(n):
    for j in range(n):
        if i == j: continue
            ...

• 최종적으로 next_receive[i] 중 max 값 반환

최종 코드

def solution(friends, gifts):
    n = len(friends)
    name_to_idx = {name: i for i, name in enumerate(friends)}

    # 선물 기록용 2차원 배열: gift_table[i][j] = i가 j에게 준 선물 수
    gift_table = [[0]*n for _ in range(n)]

    # 준 선물 수, 받은 선물 수
    send = [0]*n
    receive = [0]*n

    # 1. 선물 주고받기 기록 저장
    for g in gifts:
        giver, receiver = g.split()
        i = name_to_idx[giver]
        j = name_to_idx[receiver]

        gift_table[i][j] += 1
        send[i] += 1
        receive[j] += 1

    # 2. 선물 지수 계산
    gift_score = [send[i] - receive[i] for i in range(n)]

    # 3. 다음 달 받을 선물 수 계산
    next_received = [0]*n

    for i in range(n):
        for j in range(n):
            if i == j:
                continue
            # 선물을 더 많이 준 사람이 있으면
            if gift_table[i][j] > gift_table[j][i]:
                next_received[i] += 1
            # 주고받은 횟수가 같을 경우 → 선물 지수 비교
            elif gift_table[i][j] == gift_table[j][i]:
                if gift_score[i] > gift_score[j]:
                    next_received[i] += 1

    return max(next_received)

머쓱이는 태어난 지 6개월 된 조카를 돌보고 있습니다. 조카는 아직 "aya", "ye", "woo", "ma" 네 가지 발음을 최대 한 번씩 사용해 조합한(이어붙인) 발음밖에 하지 못합니다. 문자열 배열 babbling이 매개변수로 주어질 때, 머쓱이의 조카가 발음할 수 있는 단어의 개수를 return하도록 solution 함수를 완성해 주세요

제한사항

• 1 <= babbling의 길이 <= 100
• 1 <= babbling[i]의 길이 <= 15
• babbling의 각 문자열에서 "aya", "ye", "woo", "ma"가 한 번씩만 등장합니다.
  • 즉, 각 문자열의 가능한 모든 부분 문자열 중에서 "aya", "ye", "woo", "ma"가 한 번씩만 등장합니다.
• 문자열은 알파벳 소문자로만 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 # 1

• ["aya", "yee", "u", "maa", "wyeoo"]에서 발음할 수 있는 것은 "aya"뿐입니다. 따라서 1을 return합니다.

입출력 예 #2

• ["ayaye", "uuuma", "ye", "yemawoo", "ayaa"]에서 발음할 수 있는 것은 "aya" + "ye" = "ayaye", "ye", "ye" + "ma" + "woo" = "yemawoo"로 3개입니다. 따라서 3을 return합니다.

유의사항

• 네 가지를 붙여 만들 수 있는 발음 이외에는 어떤 발음도 할 수 없는 것으로 규정합니다. 예를 들어 "woowo"는 "woo"는 발음할 수 있지만 "wo"를 발음할 수 없기 때문에 할 수 없는 발음입니다.

문제 특징

• 각각 한 번씩만 사용 가능하므로 네 단어들로만 이루어져있으며 중복 없이 구성되어야 함

사고 흐름

• 문자열 안에 제한된 단어만 허용 : 부분 문자열 검사 (in) or replace
• 중복 사용 금지 : 사용 횟수 추적 또는 replace 후 검증
• 이어붙인 형태만 허용 : 완전히 치환 후 빈 문자열인지 확인

접근 방식

• 방법 1 : 문자열 치환 + 검증
  1. "aya", "ye", "woo", "ma"를 하나씩 replace()로 제거
  2. 모든 단어를 제거한 뒤 남은 문자열이 ""이면 → 유효한 단어
  3. 단, "ayaaya"처럼 같은 단어 두 번 쓰면 제거되긴 해도 유효하지 않음 → 이를 검출해야 함
• 방법 2 : 정규 표현식 (정규식) 사용 • '^(aya|ye|woo|ma){1,4}$' 패턴과 일치하는 문자열만 허용 • 단, 중복 단어 방지는 추가 로직 필요함

  알고리즘

• 문자열 처리
• Set 활용
• 정규 표현식

시간 복잡도

babbling의 길이를 n, 각 문자열의 최대 길이를 l이라고 할 때, 전체 시간복잡도는 O(n × l)

(방법 3 : O(k)(k < l, k는 실제로 검사하게 되는 평균적인 문자 수))

코드

방법 1: 문자열 치환(replace) + 중복 방지

def solution(babbling):
    valid = ["aya", "ye", "woo", "ma"]
    count = 0

    for word in babbling:
        temp = word
        for v in valid:
            temp = temp.replace(v, " ")
        # 중복 방지를 위해 한 단어가 두 번 연속 사용된 경우 제거
        if all(word.count(v*2) == 0 for v in valid) and temp.strip() == "":
            count += 1

    return count

방법 2: 정규 표현식 (re 모듈) + 중복 방지

import re

def solution(babbling):
    valid = ["aya", "ye", "woo", "ma"]
    count = 0

    for word in babbling:
        # 정규식으로 전체가 valid 단어들로만 구성되어 있는지 확인
        if re.fullmatch(r"(aya|ye|woo|ma)+", word):
            # 중복 단어 사용 방지
            is_duplicate = any(v * 2 in word for v in valid)
            if not is_duplicate:
                count += 1

    return count

방법 3: 시간복잡도 개선 (replace 방식 기반)

def solution(babbling):
    valid = ["aya", "ye", "woo", "ma"]
    count = 0

    for word in babbling:
        # 1. 길이 초과 시 즉시 탈락
        if len(word) > 10:
            continue

        # 2. 중복된 단어가 연속된 경우 탈락
        if any(v*2 in word for v in valid):
            continue

        # 3. 유효 단어만 replace하고 나머지 문자가 남으면 탈락
        temp = word
        for v in valid:
            temp = temp.replace(v, " ")
        if temp.strip() == "":
            count += 1

    return count

큰 종이를 1 x 1 크기로 자르려고 합니다. 예를 들어 2 x 2 크기의 종이를 1 x 1 크기로 자르려면 최소 가위질 세 번이 필요합니다.

정수 M, N이 매개변수로 주어질 때, M x N 크기의 종이를 최소로 가위질 해야하는 횟수를 return 하도록 solution 함수를 완성해보세요.

제한사항

• 0 < M, N < 100
• 종이를 겹쳐서 자를 수 없습니다.

입출력 예

문제 특징

• 겹쳐서 자를 수 없음
• 가위질 횟수 최소
• M x N 크기의 종이를 1 x 1로 자름

-> 최소한의 연산으로 M x N 개의 조각을 만들자

접근 방식

• 가위질을 한 번 할 때마다 조각 수가 1개 늘어남
• 처음 1개에서 시작해서 M x N개가 되려면 몇 번 늘려야 하나?

-> M x N - 1

문제 유형

수학적 사고 / 그리디 / 패턴 인식

시간 복잡도

O(1)

코드

def solution(M, N):
    return M * N - 1

Variational Autoencoder(VAE)는 입력 데이터의 변형을 생성하는 데 사용되는 생성 모델로 일반적인 오토인코더와 마찬가지로 인코더와 디코더로 구성되어 있습니다.

하지만 VAE는 잠재 공간(latent space)을 연속적이고 확률적인 방식으로 모델링하여 원본 입력을 정확히 재구성할 뿐만 아니라 원본과 유사한 새로운 데이터를 생성할 수 있습니다.

💡 잠재 공간(Latent Space)

잠재 공간은 입력 데이터의 중요한 특성을 압축하여 표현하는 저차원 공간입니다.

예를 들어, 28x28 픽셀의 흑백 이미지 (MNIST 데이터셋)는 784차원의 벡터로 표현되지만 실제로 의미 있는 정보는 그보다 훨씩 적은 차원에 존재합니다.

VAE는 이러한 유의미한 정보를 잠재 공간에 효과적으로 압축하여 표현합니다.

💡 VAE와 일반 오토인코더의 차이점

일반 오토인코더는 입력 데이터를 압축하고 재구성하는 데 중점을 두며 잠재 공간을 고정된 벡터로 표현합니다.

반면 VAE는 잠재 공간을 확률 분포로 모델링하여 새로운 데이터를 생성할 수 있는 능력을 갖추고 있습니다.

또한 VAE는 재구성 손실 외에도 Kullback-Leibler(KL) 발산을 손실 함수에 포함시켜 잠재 공간의 분포가 사전에 정의된 분포와 유사하도록 학습합니다.

💡 Reparameterization Trick

VAE는 잠재 공간에서 샘플링을 통해 데이터를 생성하지만 이 과정은 미분 가능하지 않음 문제가 발생합니다.

이를 해결하기 위해 Reparameterization Trick을 사용해 샘플링 과정을 미분 가능하게 만들어 모델의 학습이 가능하도록 합니다.

💡 수식 분석

1️⃣ 잠재 변수 모델에서의 추론

관측된 데이터 $x$와 잠재 변수 $z$를 가지는 확률 모델 $p(x, z)$를 고려합니다.

우리의 목표 주어진 $x$에 대한 잠재 변수의 사후 분포 $p(z|x)$를 추정하는 것

발생하는 문제

$p(z|x) = \frac{p(x, z)}{p(x)} = \frac{p(x, z)}{\int p(x, z) , dz}$ 이 사후 분포는 분모의 적분 계산이 어려워 직접 계산이 불가능함

2️⃣ 변분 추론 : 근사 분포 $q(z)$ 도입

사후 분포 $p(z|x)$를 직접 계산하는 대신 이를 근사하기 위해 $q(z)$라는 변분 분포를 도입함

이때 $q(z)$는 $p(z|x)$와 유사하도록 선택돼야 하며 두 분포간의 유사성은 Kullback-Leibler(KL) 발산으로 측정됨

$D_{KL}(q(z) | p(z|x)) = \int q(z) \log \frac{q(z)}{p(z|x)} , dz$

KL 발산을 최소화하는 것은 $q(z)$가 $p(z|x)$에 가까워지도록 함

3️⃣ ELBO 유도 : Jensen의 부등식 활용

$\log p(x) = \log \int p(x, z) , dz = \log \int q(z) \frac{p(x, z)}{q(z)} , dz$

여기서 Jensen의 부등식을 적용하면

$\log p(x) \geq \int q(z) \log \frac{p(x, z)}{q(z)} , dz = \mathbb{E}_{q(z)}\left[\log \frac{p(x, z)}{q(z)}\right]$

이 우변이 바로 ELBO(Evidence Lower Bound)입니다.

4️⃣ ELBO의 대안적 표현

ELBO는 다음과 같이 재구성 손실과 정규화 항으로 분해될 수 있습니다.

$\mathbb{E}{q(z)}[\log p(x|z)] - D{KL}(q(z) | p(z)) $

첫 번째 항: 재구성 손실, 잠재 변수 $z$로부터 원래 데이터 $x$를 얼마나 잘 복원하는지

두 번째 항: 정규화 항, 근사 분포 $q(z)$가 사전 분포 $p(z)$와 얼마나 유사한지 측정

5️⃣ ELBO와 증거 $log\ p(x)$의 관계

ELBO는 $log\ p(x)$의 하한이며 그 차이는 KL 발산으로 표현됨

$\log p(x) = \text{ELBO} + D_{KL}(q(z) | p(z|x))$

따라서 ELBO를 최대화하는 것은 KL 발산을 최소화하는 것과 동등하며 이는 $q(z)$가 $p(z|x)$에 가까워지도록 함

💡 VAE의 활용 분야

VAE는 이미지 생성 외에도 다양한 인공지능 분야에서 활용됩니다.

예를 들어 이상 탐지, 노이즈 제거, 데이터 압축, 신약 개발 등에서 사용되며 복잡한 데이터의 잠재 구조를 학습하고 새로운 데이터를 생성하는 데 강력한 도구로 자리 잡고 있습니다.

• Ultralytics YOLOv8 공식 문서
• YOLOv8 모델 발표 블로그
• YOLO 리뷰 논문 (arXiv:2304.00501)
• What is YOLOv8 논문 (arXiv:2408.15857)

💡 YOLOv8 개요 및 역사

1️⃣ YOLO 시리즈 개요

YOLOv5부터는 공식 논문이 없고 Ultralytics에서 개발 및 유지보수중

2️⃣ YOLOv8 주요 특징 요약

Anchor-free 방식 채택 기존 YOLOv5는 anchor 기반이었지만 YOLOv8은 anchor 없이 중심점 예측을 사용해 더 단순하고 일반화된 구조 사용

모듈 개선:C2f 구조 도입 기존 C3 모듈보다 더 경량화되고 연산 효율이 좋은 C2f(Concat-to-fuse) 모듈을 도입해 파라미터 수 감소 + 성능 향상

모델 통합 지원 단일 프레임워크에서 Object Detection, Instance Segmentation, Classification까지 모두 지원

기존 YOLOv5 대비 성능 향상 속도와 정확도 모두 향상됐으며 특히 작은 모델(YOLOv8n)에서도 높은 mAP 유지

3️⃣ 모델 라인업 (크기별)

💡 YOLOv8 구조 및 동작 원리

'Backbone -> Neck -> Head' 형태를 따르되 각 구성 요소에 다양한 개선이 이루어짐

1️⃣ 전체 구조

[입력 이미지]
↓
[Backbone: CSPDarknet with C2f]
↓
[Neck: FPN-like 구조 (PANeck)]
↓
[Head: Anchor-Free Detection Head]
↓
[출력: class, bbox(x, y, w, h), objectness]

2️⃣ Backbone: C2f 모듈 기반 경량 구조

• 기존 YOLOv5의 C3 모듈 -> C2f(Concat-to-fuse)로 대체
• 목적 : feature reuse + 연산 감소
• 구조 :
  • 병렬 conv -> concat -> bottleneck (CSP 스타일)
  • 파라미터 수 감소 + 정확도 유지/향상

Input → Conv → Bottleneck Blocks (split path) → Concat → Conv → Output

3️⃣ Neck : FPN + PAN 구조 (Multi-Scale Feature)

• 고해상도(low-level) + 저해상도(high-level) feature를 통합
• upsample + concat -> detection 성능 향상
• 이름은 따로 명시되지 않았지만 PANet 유사 구조

4️⃣ Detection Head (예측부)

Anchor-Free 방식

• 중심점 기반 예측 (center-based point regression)

• Anchor 설정 및 prior box가 필요 없음

• 더욱 단순화된 출력 구조

    [batch, grid_h, grid_w, (num_classes + 4 + 1)]
     → 4: [x_center, y_center, width, height]
     → 1: objectness
     → num_classes: softmax 또는 sigmoid

5️⃣ NMS 방식

• 기존 : class-agnostic NMS
• YOLOv8 : class-aware NMS로 개선
  • 서로 다른 클래스 간에는 겹쳐도 제거되지 않음
• 옵션으로 Dious-NMS, Soft-NMS 도입 가능

(파라미터 개수)

💡 YOLOv8 학습 및 추론 과정

다양한 태스크(Object Detection, Classification, Segmentation)를 하나의 프레임워크에서 지원하며 학습 및 추론 과정에서도 직관적이고 유연하게 설계됨

1️⃣ 데이터 전처리 및 입력

    기본 입력 해상도 : 640 x 640
    입력 형식 : [batch_size, 3, H, W]
    전처리 내용 :
        이미지 리사이징 (비율 유지)
        Padding (Letterbox 방식)
        정규화 (0~1 스케일)
        채널 순서 변환 (HWC -> CHW)

2️⃣ 데이터 증강(Augmentation)

기본 제공되는 증강 기법

-> Albumentations 또는 cv2 기반으로 추가 커스터마이징 가능

3️⃣ 손실 함수(Loss)

다양한 손실 항 조합

-> Loss는 각 항의 가중치를 조절해 전체 Loss로 통합

4️⃣ Optimizer 및 Learning Rate Scheduler

    기본 설정
    Optimizer : SGD or AdamW
    초기 Learning : 0.01(SGD), 0.001(AdamW)
    Scheduler : Cosine Annealing, Linear Decay 또는 사용자 정의

5️⃣ 추론(Inference) 파이프라인

입력 이미지
  ↓
전처리 및 크기 조정 (letterbox)
  ↓
모델 추론 (feature 추출 + head 예측)
  ↓
NMS 후 최종 bbox/class 반환
  ↓
원본 이미지 좌표로 bbox 재조정

추론 속도 : YOLOv8n 기준 30~100 FPS 이상 가능 (GPU 기준) 출력 형식 : bbox 좌표 [x1, y1, x2, y2], class index + confidence

💡 YOLOv8 성능 및 벤치마크

다양한 크기(n, s, m, l, x)의 모델 제공, 정확도와 추론 속도에서 균형 잡힌 성능을 보여줌 anchor-free 방식 도입 이후 YOLOv5 대비 성능 향상, 실시간 및 고정밀 작업 모두에서 우수한 효율을 보임

1️⃣ 성능 지표 (COCO val2017 기준)

2️⃣ 다른 모델과 비교 (YOLOv5, YOLOv7, Faster R-CNN 등)

→ YOLOv8은 속도와 정확도 양면에서 매우 강력한 실시간 탐지 최적화 모델

3️⃣ 특징별 장단점 요약

4️⃣ 실제 활용 환경에서 성능

💡 실제 활용 사례 및 확장성

단순한 객체 탐지를 넘어 다양한 컴퓨터 비전 작업에 활용될 수 있도록 설계됨 특히 Ultralytics 팀은 Detection 외에도 Classification, Instance Segmentation, Object Tracking까지 통합 지원함

1️⃣ 지원 태스크

2️⃣ 주요 실무 활용 사례

다양한 edge-device에서도 실행 가능해 실시간 응용 분야에 최적화됨

3️⃣ 확장 및 배포 방식

Ultralytics API

• from ultralytics import YOLO 만으로 모든 태스크 실행
• 추론 결과 : .boxes, .masks, .probs 등 다양한 출력 제공

ONNX / TensorRT / OpenVINO 내보내기

yolo export model=yolov8n.pt format=onnx

Edge 환경 최적화

• fp16, int8로 양자화
• ncnn, tflite, coreml 등 모바일 변환 가능

4️⃣ 커스텀 데이터셋 적용

Ultralytics에서는 다양한 형식의 데이터셋을 지원

# data.yaml 예시
train: ../images/train
val: ../images/val

nc: 3
names: ['pill', 'capsule', 'tablet']

참고 링크 [Ultralytics 공식 튜토리얼] (https://docs.ultralytics.com/ko/) [YOLOv8 Python API] (https://docs.ultralytics.com/ko/modes/predict/#inference-sources)

💡 분석 논문 요약 및 비판적 고찰

1️⃣ 분석 논문 요약

논문 1 : "What is YOLOv8?"

• YOLOv8의 구조 (C2f, anchor-free head 등) 분석
• YOLOv5 대비 정확도/속도 향상 정량 비교
• Instance Segmentation 확장 구조 분석
• 다양한 태스크에서의 성능 벤치마크

YOLOv8은 구조적으로 YOLO 시리즈의 단순성과 실용성을 유지하면서도 성능 향상을 달성한 "engineering-optimized model" 논문 링크

논문 2 : "A Comprehensive Review of YOLO Architectures in Computer Vision"

• YOLOv1부터 YOLOv8까지의 진화 과정 서술
• 각 버전별 핵심 기술 변화 정리
• YOLOv8이 anchor-free로 전환된 이유에 대한 설명
• 기타 YOLO 기반 파생 모델(NAS, RT-DETR 등)과 비교

사용자 중심으로 진화한 최신 YOLO 논문 링크

2️⃣ YOLOv8의 한계점

3️⃣ 비판적 고찰

• 편리함 vs. 제어력
  • Ultralytics YOLO는 CLI, Python API로 매우 쉽고 빠르지만
  • 세밀한 연구 목적이나 구조 실험에는 한계가 있을 수 있음

• anchor-free의 과장된 장점?

  • anchor-free 방식이 항상 모든 상황에서 좋다고 단정할 수 없음
  • 작은 객체나 밀집된 환경에서 성능이 불안정할 수 있음

• 결론:
  YOLOv8은 실용성과 속도를 최적화한 최신 모델이며 실무에 적합한 반면 연구 실험에는 구조 분석과 튜닝 측면에서 다소 제한이 있을 수 있음

4️⃣ 실무 적용 시 요약 팁

• 빠른 추론: YOLOv8n/s
• 정확도 중시: YOLOv8m/l/x
• segmentation: yolov8s-seg.pt 등 별도 모델 사용
• 작은 객체 위주 작업: 입력 해상도 증가 or hybrid 모델 검토

논문 : Focal Loss for Dense Object Detection 저자 : Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, Piotr Dollár
출처 : ICCV 2017, Facebook AI Research (FAIR) 논문 링크 : https://arxiv.org/pdf/1708.02002

💡 문제 정의 및 연구 동기

1️⃣ 객체 탐지(Object Detection)의 두 가지 접근 방식

객체 탐지기는 입력 이미지에서 객체의 위치(Bounding Box)와 클래스(Label)를 예측하는 모델

Two-stage Detector

    대표 모델 : R-CNN, Fast R-CNN, Faster R-CNN
    1단계 : 후보 영역(Region Proposal) 생성
    2단계 : 각 영역에 대해 분류 및 박스 회귀 수행
    장점 : 높은 정확도
    단점 : 속도가 느림

One-stage Detector

    대표 모델 : YOLO, SSD
    전체 이미지를 grid처럼 나누어 **한 번에 객체 탐지**
    장점 : 매우 빠름
    단점 : 정확도는 two-stage에 비해 낮음

2️⃣ One-stage Detector의 한계 : 클래스 불균형

수많은 앵커(anchor)에 대해 대부분이 배경(background) 이기 때문에 문제 발생

    양성 샘플(positive) : 실제 객체를 포함한 anchor (매우 적음)
    음성 샘플(negative) : 객체가 없는 anchor (매우 많음)

발생하는 문제점 훈련 손실(loss)의 대부분이 easy negative에 의해 지배됨 모델이 모든 영역을 배경으로 분류하는 보수적 학습을 하게 됨 정확한 객체 탐지가 어려워짐

3️⃣ 연구 목표

❓ “왜 one-stage detector는 two-stage보다 정확도가 낮은가?”

결론

    원인은 모델 구조가 아니라 훈련 과정에서의 클래스 불균형임
    해결책은 손실 함수 자체에 존재

따라서 기존 cross-entropy 손실의 한계를 분석하고 새로운 손실 함수인 Focal Loss를 제안하여 One-stage 모델인 RetinaNet을 통해 정확도와 속도의 균형을 달성하고자 함

💡 Focal Loss 정의 및 직관

1️⃣ 클래스 불균형 문제 : Cross Entropy

객체 탐지에서 수많은 negative anchor는 모델 학습에 방해가 됨

기존 Cross Entropy 손실 수식 : $CE(p_t) = -log(p_t)$

• $p_t$ : 예측 확률이 정답 클래스일 경우의 확률(정답 클래스가 1이고 모델이 0.95확률로 예측했다면 0.95)

문제점 이미 정확하게 분류된 쉬운 예제도 높은 loss를 유발 negative anchor가 많으므로 전체 loss에서 지배적

2️⃣ Focal 수식

Focal Loss는 Cross Entropy에 modulating factor $(1 - p_t)^\gamma$ 를 곱하여 easy sample의 loss를 줄임

$FL(p_t) = -α_t * (1 - p_t)^γ * log(p_t)$

• $p_t$ : 정답 클래스일 확률
• $\gamma$ : 조절 계수 (focusing parameter), 일반적으로 2 사용
• $α_t$ : 클래스 불균형을 보정하는 weight factor (optional)

3️⃣ 직관 요약

쉬운 샘플은 무시하고 어려운 샘플에 집중하도록 유도

4️⃣ γ (gamma)의 영향 실험

γ가 0일 때 -> 일반 cross-entropy γ가 높을 때 -> easy 예제 무시 비율 증가

일반적으로 γ = 2가 best 결과를 보임

5️⃣ α (alpha) balancin

클래스 불균형을 보정하는 weight positive class에 α = 0.25, negative class에 1 - α = 0.75 사용 (기존 class-balanced CE 손실과 유사한 개념)

6️⃣ Focal Loss의 핵심 효과

    easy negative가 loss에서 차지하는 비중을 줄임
    학습 효율을 높이고 모델이 진짜 객체(positive anchor)에 집중하게 만듦
    따라서 one-stage detector에서도 높은 정확도 가능하게 만듦

💡 RetinaNet 구조 분석

1️⃣ One-stage Detector의 재정의

    Backbone : ResNet-50 또는 ResNet-101
    Feature Extractor : FPN (Feature Pyramid Network)
    Head Subnet : Classification Subnet(anchor 클래스 예측), Regression Subnet(bbox 예측)

2️⃣ Feature Pyramid Network (FPN)

객체 탐지는 다양한 크기의 객체에 대응해야 하므로 멀티스케일 feature map 필요

FPN 구조

ResNet의 중간 feature (C3, C4, C5 등)를 상향 전파해 고해상도 정보 보존 상향(feature upsampling) + 측면 연결(lateral connection)을 통해 P3 ~ P7 pyramid 생성

3️⃣ Subnet 구조 (Head)

각 FPN 레벨(P3~P7)에 대해 동일한 구조의 Subnet 2개를 적용

🔧 Classification Subnet

• 4개의 3x3 Conv + ReLU
• 1개의 3x3 Conv -> $A \times C$ 출력 (A : anchor 수, C : 클래스 수)

🔧 Regression Subnet

• 4개의 3x3 Conv + ReLU
• 1개의 3x3 Conv -> $A \times 4$ 출력 (x, y, w, h)

4️⃣ Anchor 설정

각 FPN level마다 anchor box를 미리 정의해 다중 객체 탐지 수행

5️⃣ 장점

FPN으로 멀티 스케일 탐지 강화 Head subnet은 매우 얕고 공유 구조를 사용 -> 속도 향상 Focal Loss로 인해 정확도 문제까지 해결

💡 실험 설정 및 성능 비교 결과

1️⃣ 실험 환경 및 세부 설정

🔧 모델 학습 설정

🔧 하이퍼파라미터

• Focal Loss의 γ (gamma): 2
• α (alpha): 0.25 (positive anchor에 적용)

2️⃣ Focal Loss 효과 실험

Focal Loss의 γ 값을 변경하면서 어떻게 정확도(AP) 가 달라지는지 실험

3️⃣ RetinaNet vs Faster R-CNN vs SSD

RetinaNet은 Faster R-CNN보다 정확도 높고 SSD보다 성능-속도 균형이 우수 특히 AP50, AP75뿐 아니라 **소형 객체(AP_S), 중형 객체(AP_M), 대형 객체(AP_L) 모두에서 강함

4️⃣ RetinaNet의 학습 안정성

Focal Loss를 사용한 RetinaNet은 overfitting 없이 학습이 안정적 CE Loss만 썼을 때는 easy negative에 빠르게 overfit

Focal Loss + FPN + 간결한 서브넷 구조 = 속도·정확도 균형

💡 결론 및 영향력 요약

1️⃣ 실제 영향력

2️⃣ 한계 및 향후 과제

이 논문은 이후 anchor-free 객체 탐지기의 출현에도 영향을 주었으며 Dense prediction 문제 해결을 위한 출발점 역할을 함

https://arxiv.org/abs/1411.4038

논문 요약

기존 이미지 분류용 CNN을 픽셀 단위 의미론적 분할(Semantic Segmentation)에 맞게 완전히 컨볼루션 층으로만 재설계한 구조입니다.

핵심 아이디어

1️⃣ 기존 CNN의 Fully Connected 층을 1x1 Convolution으로 대체해 입력 크기에 관계없이 공간적 특성을 유지하며 dense한 픽셀별 예측이 가능하도록 합니다.

2️⃣ 깊은 네트워크를 통해 축소된 저해상도 feature map을 Transposed Convolution으로 원래 해상도로 업샘플링하여 픽셀 단위의 class score map을 생성합니다.

특징

중간 해상도의 feature map을 활용하는 skip connection을 도입해 coarse한 예측의 공간적 세부 정보를 보완함으로써 더 정밀한 분할 결과를 얻습니다.

sliding window 방식의 비효율성을 극복하며 입력의 크기에 구애받지 않고 end-to-end로 학습 가능한 semantic segmentation으로 평가받습니다.

개념 설명

1️⃣ Semantic Segmentation

이미지의 모든 픽셀에 대해 클래스(label)를 예측하는 문제 기존의 CNN의 한계를 넘어 픽셀 단위로 의미를 해석하는 최초의 완전한 컨볼루션 구조를 제공한 모델

2️⃣ Sliding Window vs FCN

Sliding Window 이미지 내의 작은 고정 크기 영역(patch)을 하나씩 잘라내어 각 패치마다 CNN을 따로 적용해 분류하는 전통적 방법

고정 크기의 윈도우를 이미지 위에서 일정한 간격으로 이동시키며 각 위치에서 모델을 적용하여 객체나 패턴을 탐지하는 방식입니다. 중복 계산이 많고 비효율적이며 고정된 입력 크기를 요구하고 객체 경계가 부정확할 수 있습니다.

FCN 입력 이미지의 각 픽셀에 대해 예측을 수행하는 방식

전체 이미지를 한 번에 처리하며 중복 계산을 줄이고 다양한 크기의 입력을 처리할 수 있으며 픽셀 단위의 정밀한 예측이 가능합니다.

출처: https://medium.com/ai-quest/convolutional-implementation-of-the-sliding-window-algorithm-db93a49f99a0

3️⃣ FC Layer -> 1x1 Conv

FC Layer의 한계

기존 CNN에서는 마지막에 flatten -> FC layer로 클래스 벡터를 출력하게 됩니다. 이렇게 되면 위치 정보는 다 사라지고 "무엇이 있는가"만 예측할 수 있게 됩니다.

1x1 Convolution으로 대체

FC layer는 사실상 전 채널에 가중치를 곱해 하나의 벡터로 만드는 연산입니다. 이걸 공간을 유지한 채로 적용하기 위해 1x1 convolution으로 대체했습니다.

이렇게 변경한 덕분에 모든 위치에 대해 동시에 예측(dense prediction) 가능하고 각 픽셀에 대해 어떤 클래스인지 판단할 수 있게 됐습니다.

Dense prediction이란? 입력 이미지의 각 픽셀 위치마다 출력(예측)을 생성하는 문제 구조 출력이 이미지와 같은 해상도를 갖고 공간적으로 조밀하게 구성되는 예측 방식

4️⃣ Transposed Convolution

VGG-16은 conv+pool을 반복하여 해상도를 축소합니다. (예: 224x224 -> 112 -> 56 - 28 -> 14 -> 7) -> 최대 32배 감소 (stride=32)

이때 축소된 해상도를 복원하기 위해 Transposed Convolution을 사용하게 됩니다. 이는 축소된 feature map을 다시 upsampling해서 원래 해상도로 복원하는 역할입니다. 학습 가능한 가중치를 갖는 업샘플링이므로 단순 보간(Bilinear)보다 표현력이 높습니다.

Bilinear Interpolation이란? 비학습 업샘플링 방식입니다. 계산 속도가 빠르다는 장점이 있지만 디테일 복원이 불가하고 경계가 흐릿하게 표현되고 표현력이 제한된다는 치명적인 단점이 존재합니다.

Transposed Convolution 방식 작은 feature map을 입력받아 커널을 "거꾸로 적용"해 더 큰 출력(feature map)을 생성하는 연산입니다.

출력 크기 $$\boxed{ O = S \cdot (I - 1) + K - 2P }$$

출력 해상도 = Stride(입력 해상도 - 1) + 커널 - 2 x 패딩

작동 방식 1️⃣ Zero Insertion (Zero Padding between pixels) 입력 feature map의 픽셀 사이에 0을 삽입해 크기를 확장합니다. (예: stride=2이면 픽셀 사이에 1칸씩 0을 삽입)

2️⃣ Normal Convolution 적용 확장된 입력에 일반 convolution처럼 커널을 sliding합니다.

padding = 1, stride = 2를 준 Transposed Convolution 작동 방식

출처: https://github.com/vdumoulin/conv_arithmetic?tab=readme-ov-file

Transposed인 이유

nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, output_padding)

이때 내부 weight의 shape은

(out_channels, in_channels, kernel_size, kernel_size)

-> 일반 conv와 in/out_channels 순서가 바뀌어 있습니다.

커널 내부 값들의 형태나 패턴이 정해져있는가? X 모든 커널 값들은 일반 Convolution처럼 랜덤 초기화되고 학습 과정에서 최적화됩니다.

1) 보통 Xavier, He, Kaiming 초기화로 랜덤하게 초기화됨 2) 학습 초기에는 불규칙한 값들로 채워져 있음 3) 학습이 진행되면서 업샘플링에 적합한 방향성 있는 패턴을 자동으로 학습

5️⃣ FCN-32s, FCN-16s, FCN-8s 구조와 Skip Connection

FCN-32s

Input (e.g. 224×224 RGB)
 ↓
VGG-16 conv layers → 마지막 feature map: 7×7×512
 ↓
1×1 conv (num_classes) → score map: 7×7×21
 ↓
Transposed Conv (stride=32, kernel=64) → 224×224 복원
 ↓
Pixel-wise Softmax

특징

• Skip connection 없음
• 한 번에 coarse한 feature를 32배 upsampling
• 가장 간단한 구조지만 출력이 흐릿함

FCN-16s

Input
 ↓
VGG-16 conv layers
 ↓
pool5 → 1×1 conv → score map (7×7)
 ↓
Transposed Conv (stride=2) → 14×14
 + element-wise sum with pool4 (1/16 해상도)
 ↓
Transposed Conv (stride=16) → 224×224

특징

• skip connection 1개: pool4 사용
• pool5의 coarse 정보 + pool4의 finer 정보 결합
• 출력 경계가 더 정밀해짐

FCN-8s

Input
 ↓
VGG-16 conv layers
 ↓
pool5 → 1×1 conv → score map (7×7)
 ↓
Transposed Conv (stride=2) → 14×14
 + element-wise sum with pool4
 ↓
Transposed Conv (stride=2) → 28×28
 + element-wise sum with pool3
 ↓
Transposed Conv (stride=8) → 224×224

특징

• skip connection 2개: pool4, pool3 사용
• shallow feature 활용해 위치 정보/경계 보정
• 가장 정밀한 FCN 구조

6️⃣ 평가 지표(IoU)

$$\text{IoU} = \frac{\text{TP}}{\text{TP} + \text{FP} + \text{FN}}$$

여러 클래스가 있을 경우 클래스별 IoU를 구한 뒤 평균을 냅니다. $$\text{mIoU} = \frac{1}{C} \sum_{i=1}^{C} \text{IoU}_i$$

• 객체가 많은 클래스와 적은 클래스 모두 동일하게 반영되므로 클래스 불균형에 덜 민감합니다.

7️⃣ FCN의 한계

1️⃣ 출력 해상도가 낮음 (coarse prediction) FCN의 기본 구조는 VGG와 같은 classification backbone을 기반으로 합니다. 따라서 Conv + Pooling이 반복되어 입력 대비 32배나 축소된 coarse feature map이 생성됩니다. 이 작은 feature map을 Transposed Convolution으로 upsampling하지만 결과적으로 픽셀 단위의 예측이 부정확하거나 경계가 흐릿하게 보입니다.

2️⃣ 객체 경계 불명확 (blurred boundaries) 깊은 레이어일수록 의미는 강하지만 위치 정보는 약해집니다. (semantic-rich, spatial-poor) FCN은 low-level feature의 위치 정보가 부족하므로 객체 경계(sharp edge) 표현이 부족합니다. 특히 얇은 객체나 경계가 중요한 경우(예: 의료영상, 도로 차선)에 치명적입니다.

3️⃣ skip connection의 단순 결합 단순한 Element-wise sum으로 결합하므로 shallow와 deep feature 간의 의미 불일치 또는 정보 손실이 발생합니다. 이에 대해서는 이후 U-Net처럼 concat 후 conv로 보완하는 방식으로 발전됐습니다.

4️⃣ 모양 다양성(object shape variation)에 취약 FCN은 고정된 필터와 고정 receptive field를 기반으로 하기 때문에 다양한 크기/형태의 객체에 적응력이 부족하다는 단점이 있습니다. 이에 대해서는 이후 DeepLab의 ASPP(Atrous Spatial Pyramid Pooling) 등 멀티스케일 대응 방식으로 발전됐습니다.

5️⃣ 인스턴스 구분 불가(instance-unaware) 픽셀에 class는 부여하지만 동일 클래스 내 다른 객체 구분은 할 수 없습니다. 이에 대해서는 Mask R-CNN, Panoptic Segmentation을 통해 객체까지 구분할 수 있게끔 발전됐습니다.

8️⃣ FCN 코드 구현

FCN 공통 기반 (VGG-16 Feature Extractor)

import torch
import torch.nn as nn
import torchvision.models as models

class VGGBackbone(nn.Module):
    def __init__(self, pretrained=True):
        super().__init__()
        vgg = models.vgg16(pretrained=pretrained)
        features = list(vgg.features.children())
        self.stage1 = nn.Sequential(*features[:5])     # relu1_2
        self.stage2 = nn.Sequential(*features[5:10])   # relu2_2
        self.stage3 = nn.Sequential(*features[10:17])  # relu3_3
        self.stage4 = nn.Sequential(*features[17:24])  # relu4_3
        self.stage5 = nn.Sequential(*features[24:31])  # relu5_3
    def forward(self, x):
        x1 = self.stage1(x)
        x2 = self.stage2(x1)
        x3 = self.stage3(x2)
        x4 = self.stage4(x3)
        x5 = self.stage5(x4)

return x3, x4, x5  # skip용으로 3, 4, 5단계 반환

FCN-32s

class FCN32s(nn.Module):
    def __init__(self, num_classes):
        super().__init__()
        self.backbone = VGGBackbone()
        self.classifier = nn.Conv2d(512, num_classes, kernel_size=1)
        self.upsample = nn.ConvTranspose2d(
        num_classes, num_classes, kernel_size=64, stride=32,
        padding=16, bias=False
        )

    def forward(self, x):
        _, _, x5 = self.backbone(x)
        score = self.classifier(x5)
        upsampled = self.upsample(score)
        return upsampled

FCN-16s (skip from pool4)

class FCN16s(nn.Module):
    def __init__(self, num_classes):
        super().__init__()
        self.backbone = VGGBackbone()
        self.score_pool4 = nn.Conv2d(512, num_classes, kernel_size=1)
        self.score_final = nn.Conv2d(512, num_classes, kernel_size=1)
        self.upsample2x = nn.ConvTranspose2d(num_classes, num_classes, 4, stride=2, padding=1, bias=False)
        self.upsample32x = nn.ConvTranspose2d(num_classes, num_classes, 32, stride=16, padding=8, bias=False)

    def forward(self, x):
        _, x4, x5 = self.backbone(x)
        score = self.score_final(x5)
        upscore2 = self.upsample2x(score)
        score_pool4 = self.score_pool4(x4)
        fuse = upscore2 + score_pool4
        out = self.upsample32x(fuse)
        return out

FCN-8s (skip from pool3)

class FCN8s(nn.Module):
def __init__(self, num_classes):
    super().__init__()
    self.backbone = VGGBackbone()
    self.score_pool3 = nn.Conv2d(256, num_classes, kernel_size=1)
    self.score_pool4 = nn.Conv2d(512, num_classes, kernel_size=1)
    self.score_final = nn.Conv2d(512, num_classes, kernel_size=1)
    self.upsample2x = nn.ConvTranspose2d(num_classes, num_classes, 4, stride=2, padding=1, bias=False)
    self.upsample4x = nn.ConvTranspose2d(num_classes, num_classes, 4, stride=2, padding=1, bias=False)
    self.upsample8x = nn.ConvTranspose2d(num_classes, num_classes, 16, stride=8, padding=4, bias=False)

def forward(self, x):
    x3, x4, x5 = self.backbone(x)
    score = self.score_final(x5)
    score = self.upsample2x(score)
    score += self.score_pool4(x4)
    score = self.upsample4x(score)
    score += self.score_pool3(x3)
    out = self.upsample8x(score)

    return out