1) LLMOps/AI 운영(서비스화·운영자동화) 쪽 유사 사업 2026년도 공공AX 프로젝트 사업 신규과제 모집 공고 (진행중)

기간: 2026-02-11 ~ 2026-03-16 링크: https://www.nipa.kr/home/2-2/16471 성격: 공공영역 AI 도입/운영, MLOps·LLMOps 구조 제안에 잘 맞음 2026년도 AI 응용제품 신속 상용화 지원사업 (Type2: AI 민생 프로젝트) (예정)

기간: 2026-03-02 ~ 2026-03-16 링크: https://www.nipa.kr/home/2-2/16475 성격: 모델을 제품/서비스로 빠르게 상용화하는 트랙 2026년 AI바우처 지원사업 공급기업 POOL 모집 공고 (진행중)

기간: 2026-02-10 ~ 2026-02-24 링크: https://www.nipa.kr/home/2-2/16469 성격: AI 솔루션 공급기업 등록(LLM 서비스 운영기업에게 중요) 2026년도 중소기업 클라우드 서비스 보급·확산 사업 공급기업 모집 (진행중)

기간: 2026-02-13 ~ 2026-03-20 링크: https://www.nipa.kr/home/2-2/16474 성격: LLM 서비스 운영 인프라(클라우드, 운영체계) 연계에 유리 2026년도 AI·디지털 비즈니스 파트너십 특화 프로그램 참여기업 모집 (진행중)

기간: 2026-02-05 ~ 2026-03-05 링크: https://www.nipa.kr/home/2-2/16463 2) CVOps/제조 비전·영상분석 쪽 유사 사업 [경기] 스마트공장 구축 및 컨설팅·제조AI 지원사업 (진행중)

기간: 2026-02-10 ~ 2026-03-20 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000118448 [강원] 강원형 스마트공장(기초단계) 구축지원사업 (예정)

기간: 2026-03-03 ~ 2026-03-23 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000118437 [울산] AI기반 PoC 실증 지원사업(지역특화 제조데이터 활성화) (진행중)

기간: 2025-11-19 ~ 2026-02-28 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000116436 중소제조 특화 Multi AI Agent 개발(R&D) (예정)

기간: 2026-03-01 ~ 2026-03-31 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000116030 제조AI특화 스마트공장(자율형공장 AI트랙) (예정)

기간: 2026-03-01 ~ 2026-04-30 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000115998 민군경 AI 기반 해양영상 융복합 분석기술개발 (마감, 유사도 높음)

기간: 2026-01-26 ~ 2026-02-19 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000117465

1.1 학습 목표

1.1.1 GPT-3 등장

• 하나의 모델로 다양한 업무를 하려는 흐름
• Pretrain → Transfer
• Few-shot / Zero-shot

1.1.2 Transformer의 중요성

• RNN/LSTM의 한계를 Attention으로 해결

1.1.3 NLP의 핵심 난제

• 순서가 의미를 바꿈
• 단어 하나 변화가 의미 및 라벨을 뒤집음 (ex: “안”)
• 토큰화와 OOV(사전에 없는 단어)가 실무 난이도를 크게 좌우

1.1.4 기초 수식

• 언어 모델 확률(체인 룰)
• 내적 = 유사도
• softmax가 확률이 되는 이유

1.2 GPT-3

1.2.1 GPT-3 방향성

• Task마다 모델을 새로 만들고 라벨을 많이 모아 학습하는 방식은 비용이 큼
• 큰 모델을 미리 학습(Pretrain)해두고, 적은 예시(Few-shot) 또는 예시 없이(Zero-shot) 다양한 Task를 수행하게 하려는 방향

1.2.2 GPT-3 핵심 동기

• Transformer가 번역에서 성공 → “Transformer 구조로 더 잘할 수 없을까?”
• Task 및 Domain이 바뀌면 성능이 떨어지는 문제
• 다양한 데이터로 미리 학습하면 새로운 Task 적응이 쉬워진다로 개념 발전

1.3 Transformer 핵심

• Attention
• Positional Encoding

1.3.1 Self-Attention

• 문장 안의 각 토큰이 문장 내 다른 토큰들을 참고해서 자기 표현을 업데이트

토큰 i의 새 표현 = (토큰 1을 보는 비율)*v1
               + (토큰 2를 보는 비율)*v2
               + ...
               + (토큰 n을 보는 비율)*vn

1.3.2 Positional Encoding

• Transformer는 구조적으로 순서 정보가 자동으로 들어가지 않음
• 토큰 위치 정보를 숫자 벡터로 추가해서 순서를 인지하게 만들어야 함

1.4 데이터 관점 비교

1.4.1 Tabular vs Vision vs NLP

1.5 토큰화

1.5.1 토큰화란

• 문장을 모델이 먹을 수 있는 단위로 쪼개고 각 조각을 숫자로 바꾸는 과정

1.5.2 토큰화 단위

• Character

  • 예: 나는 → [나, 는]
  • 장점: OOV 거의 없음
  • 단점: 길이 폭증, 의미 단위가 약함

• Space

  • 예: I love apples → [I, love, apples]
  • 장점: 단순함
  • 단점: “tokenization!” vs “tokenization” 같은 변형에 취약, 한국어는 공백이 의미 단위와 안 맞는 경우가 많음

• Punctuation

  • 구두점 기준 분리
  • 장점: 일부 개선
  • 단점: 근본 해결은 아님

• Subword

  • 예: unbelievable → [un, believe, able]
  • OOV를 크게 줄이면서 길이 폭증도 완화
  • 대표: GPT 계열(BPE), BERT 계열(WordPiece)

1.6 언어 모델

• 문장을 확률로 모델링

1.6.1 문장 확률

• 체인 룰(Chain Rule)로 분해
• 문장을 단어들의 나열로 보면 길이 (T)인 문장은 다음처럼 표현 가능

$$ (W_1, W_2, \ldots, W_T) $$

• 문장 전체 결합확률은 체인 룰로 다음처럼 분해

$$ P(W_1, W_2, \ldots, W_T) = \prod_{t=1}^{T} P(W_t \mid W_{<t}) $$

• 여기서 (W_{<t})는 “(t)번째 단어 이전까지의 모든 단어들”을 의미

  • $$P(W_1)$$ : 첫 단어가 나올 확률
  • $$P(W_2 \mid W_1)$$ : 첫 단어가 주어졌을 때 두 번째 단어 확률
  • $$P(W_3 \mid W_1, W_2)$$ : 앞의 두 단어가 주어졌을 때 세 번째 단어 확률
  • $$P(W_T \mid W_1, \ldots, W_{T-1})$$ : 이전 단어들이 주어졌을 때 마지막 단어 확률

• 언어 모델은 한 문장을 한 번에 통째로 외우는 게 아님

• 즉, “지금까지 단어들이 주어졌을 때 다음 단어 확률”을 반복적으로 예측하고 그 확률들을 곱해서 문장 전체 확률을 구성

1.7 평가 지표

• 왜 번역/생성은 “정답률(Accuracy)”로 끝나지 않나

• 번역/요약/생성 태스크는 정답이 한 가지로 고정되지 않음

• 같은 의미라도 표현이 여러 가지가 가능하므로, “정확히 일치”만 보는 정답률로는 평가가 어려움

• 따라서 BLEU/ROUGE 같은 자동 평가 지표가 등장

1.7.1 핵심 지표 정리

• BLEU

  • 핵심: n-gram precision(겹치는 조각 비율) + brevity penalty(짧은 번역 패널티)
  • 장점: 자동 평가 가능
  • 한계: 의미가 같아도 표현이 다르면 낮게 나올 수 있음

• ROUGE

  • 요약에서 많이 사용
  • 성격: recall에 가까움(참고 요약의 내용이 얼마나 포함됐나)
  • 대표: ROUGE-N, ROUGE-L

• METEOR

  • 정렬(alignment) 관점이 강하고, 어간(stemming), 동의어 등을 고려(세부는 설정/버전에 따라 차이)

• Human Evaluation

  • 여전히 중요
  • 기준 예시: Adequacy(의미), Fluency(자연스러움)
  • pairwise 비교(둘 중 더 좋은 것 선택)가 안정적

1.8 트랜스포머 이전: RNN/LSTM 인코더-디코더(Seq2Seq)

• “문맥(context)을 하나로 요약하고 싶다” → 인코더-디코더 구조가 자연스럽게 등장

1.8.1 RNN 구조(시간축으로 펼침)

x1 -> [RNN] -> h1
            -> (다음으로 전달)
x2 -> [RNN] -> h2
x3 -> [RNN] -> h3
...

• (x_t): t번째 입력(토큰 임베딩)
• (h_t): t번째 은닉 상태(문맥 누적 정보)

1.8.2 인코더-디코더(번역) 개념

(Encoder)  한국어 토큰들 -> h1,h2,...,hT -> (context 요약)
(Decoder)  context + 이전 출력 -> 다음 단어 생성 -> ...

• 인코더: 입력 문장을 읽고 표현을 만듦
• 디코더: 인코더 요약(context) + 이전 출력 토큰을 바탕으로 다음 토큰 생성

1.8.3 한계가 생기는 이유

• 정보 병목(Bottleneck): 긴 문장을 하나의 context 벡터로 압축 → 앞부분 정보 손실
• 순차 처리의 한계: 병렬화가 어려움
• 장기 의존성 문제: 멀리 떨어진 정보 연결이 어렵고 학습이 불안정(대표: vanishing gradient)

1.9 Attention

• 어느 단어(토큰)에 더 집중할지 학습하여 중요한 정보에 더 큰 가중치를 주는 메커니즘

• 강의 요지

  • “I do not like …”에서 핵심은 not
  • 번역은 단어 정렬(alignment)이 중요 (한국어 앞 단어가 영어 뒤로 갈 수도 있음)

1.9.1 디코더-인코더 Attention 직관(Seq2Seq Attention)

• 디코더가 출력 토큰 하나(시점 (j))를 만들 때,
• 인코더의 모든 상태 ((h_1, \ldots, h_T)) 중 어디를 얼마나 참고할지(가중치)를 계산한다.

(1) 유사도 점수(score) 계산

$$ \text{score}_{j,i} = \mathrm{similarity}(\mathbf{s}_j, \mathbf{h}_i) $$

(2) softmax로 가중치(attention weight) 만들기

$$ \alpha_{j,i} = \frac{\exp(\text{score}{j,i})} {\sum{k=1}^{T}\exp(\text{score}_{j,k})} $$

(3) 가중합으로 컨텍스트 벡터(context vector) 만들기

$$ \mathbf{c}j = \sum{i=1}^{T} \alpha_{j,i},\mathbf{h}_i $$

기호 의미

• $$\mathbf{s}_j$$ : 디코더의 (j)번째 상태(hidden state)

• $$\mathbf{h}_i$$ : 인코더의 (i)번째 상태(hidden state)

• $$\alpha_{j,i}$$ : (j)번째 출력 생성 시 (i)번째 입력을 얼마나 참고할지 나타내는 가중치

  • $$\sum_{i=1}^{T}\alpha_{j,i} = 1$$

• $$\mathbf{c}_j$$ : 디코더 (j)시점의 컨텍스트 벡터(입력 정보를 정렬+요약해서 제공)

1.9.2 전사본 표현 교정(중요)

• 핵심 흐름은 동일: 유사도 점수 → softmax → 가중합
• 다만 실제 구현은 여러 변형이 존재한다.

(1) 전통 Seq2Seq Attention의 대표 변형

• Dot-product(내적 기반)

$$ \mathrm{similarity}(\mathbf{s}_j, \mathbf{h}_i) = \mathbf{s}_j^{\top}\mathbf{h}_i $$

• Additive(Bahdanau, MLP 기반)

$$ \mathrm{similarity}(\mathbf{s}_j, \mathbf{h}_i) = \mathbf{v}^{\top}\tanh(W_s\mathbf{s}_j + W_h\mathbf{h}_i) $$

(2) 트랜스포머 Attention과의 연결

• 트랜스포머는 같은 아이디어를 (Q, K, V)로 재구성해 효율적으로 만든 형태다.

$$ \mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V $$

1.10 선형대수 기초

• 목표

수식을 봤을 때 “아 유사도구나 / 아 확률로 바꾸는구나”를 즉시 캐치하기

1.10.1 벡터/행렬/전치(Transpose)

• 벡터(열벡터)

$$ \mathbf{h} \in \mathbb{R}^{d \times 1} $$

• 전치(Transpose)

$$ \mathbf{h}^{\top} \in \mathbb{R}^{1 \times d} $$

• 내적(Dot product): 결과는 스칼라

$$ \mathbf{h}^{\top}\mathbf{g} \in \mathbb{R} $$

1.10.2 내적이 왜 “유사도” 느낌인가?

(1) 코사인 유사도에 내적이 포함됨

$$ \cos(\theta) = \frac{\mathbf{a}^{\top}\mathbf{b}}{\lVert \mathbf{a}\rVert,\lVert \mathbf{b}\rVert} $$

• 방향이 비슷할수록 값이 커짐
• 정규화하면 내적이 곧 “방향 유사도”처럼 동작

(2) 거리(distance) 전개에도 내적이 등장

$$ \lVert \mathbf{x}-\mathbf{y}\rVert^{2} = \mathbf{x}^{\top}\mathbf{x} - 2\mathbf{x}^{\top}\mathbf{y} + \mathbf{y}^{\top}\mathbf{y} $$

• $$\mathbf{x}^{\top}\mathbf{y}$$ 가 커질수록(더 비슷할수록) 거리는 작아지는 구조
• 그래서 내적은 “유사도”로 자주 쓰인다

1.10.3 softmax가 왜 “확률”이 되나?

• softmax 정의

$$ \mathrm{softmax}(z_i) = \frac{e^{z_i}}{\sum_{k} e^{z_k}} $$

• 항상 0보다 큼
• 전체 합이 1
• 미분이 깔끔해 학습에 유리

✅ 실무 팁(수치 안정성)

$$ \mathrm{softmax}(\mathbf{z})i = \frac{e^{z_i - \max(\mathbf{z})}}{\sum{k} e^{z_k - \max(\mathbf{z})}} $$

• overflow 방지를 위해 보통 (\max(\mathbf{z}))를 빼고 계산
• 정규화 구조 때문에 결과 확률은 동일하게 유지된다

1.11 트랜스포머로 돌아오기: 왜 GPT/BERT가 여기서 나왔나?

• 트랜스포머는 RNN의 순차 처리를 버리고, Attention으로 문장 내 관계를 한 번에 계산할 수 있게 만든 구조

1.11.1 트랜스포머 Attention 블록(자체완결)

입력 X (토큰 임베딩 + 포지션)  [n x d]

Q = XWq
K = XWk
V = XWv

A = softmax( QK^T / sqrt(dk) )   [n x n]  // 토큰-토큰 관계표
출력 = A V                        [n x d]

• (A): 토큰-토큰 관계(어느 토큰이 어느 토큰을 얼마나 참고하는지)

1.11.2 Multi-Head가 왜 필요?

• 한 번의 관계표만으로는 관계의 종류를 다양하게 담기 어려움
• 여러 헤드가 서로 다른 관점(문법/의미/지시어/장거리 의존 등)으로 관계를 학습

1.12 GPT vs BERT: 같은 트랜스포머지만 목표가 다르다

1.12.1 전사본 표현 교정(중요)

• 트랜스포머도 임베딩 레이어(토큰 ID → 벡터)는 반드시 존재
• 다만 word2vec처럼 임베딩을 따로 만들고 고정하기보다,
• 모델 학습 과정에서 임베딩까지 end-to-end로 같이 최적화하는 경우가 일반적 → “임베딩을 따로 튜닝하는 비중이 줄었다”로 이해하면 자연스럽다

아래는 네가 준 내용을 강의 흐름 그대로 유지하면서, Velog에서 수식이 절대 안 깨지게 $$ ... $$로 통일하고, ASCII/표/shape 추적/핵심 교정까지 “교재” 톤으로 완성한 최종본이야. (원문에 있던 [ ] 수식 표기, 괄호/슬래시/루트 표기 흔들림, 인덱스 표기 혼동을 전부 정리했어.)

2. Transformer

1) Transformer

1.1 트랜스포머는 “인코더-디코더” 구조

• 입력 문장(소스)을 Encoder가 이해(표현 벡터로 변환)
• 출력 문장(타겟)을 Decoder가 생성(한 토큰씩)

슬라이드의 큰 흐름은 다음처럼 잡으면 된다.

Input (token + position)
 -> Encoder blocks (self-attention + FFN)
 -> Decoder blocks (masked self-attention + cross-attention + FFN)
 -> Linear + Softmax
 -> Output tokens

1.2 트랜스포머가 RNN보다 유리했던 이유

• 병렬 처리 가능: 토큰을 순차적으로 처리하지 않고, 한 번에 행렬 연산으로 처리
• 번역 태스크에서 성능(BLEU)과 효율이 강점으로 제시됨
• 이후 BERT/GPT가 트랜스포머 블록을 채택하면서 “사전학습 → 적응”의 표준이 됨

2) Positional Encoding

2.1 왜 필요한가?

• RNN은 입력이 x1 → x2 → x3 ... 순서대로 들어오므로 순서 정보가 구조에 내장
• 트랜스포머는 병렬 처리로 토큰을 동시에 다루므로, 그냥 두면 토큰의 위치를 모름
• 그래서 토큰 임베딩에 위치 정보를 더해 순서를 주입한다

입력 단계(개념)

token ids -> Embedding(d_model)
          -> + PositionalEncoding(d_model)
          -> Encoder/Decoder blocks

2.2 “그럼 위치를 숫자로 주면 되지 않나?”가 왜 위험한가

(A) 그냥 0,1,2,3… 더하기

• 값 스케일이 커지며 학습 안정성(초기 분포, 스케일)이 흔들릴 수 있음

(B) 0~1 정규화 (예: 0, 0.33, 0.66, 1)

• 문장 길이가 바뀌면 같은 “2번째 토큰”도 값이 바뀜 → 같은 위치가 일관된 의미를 갖기 어려움

(C) 원-핫/이진 벡터

• 길이에 무관하게 같은 위치에 같은 벡터를 할당 가능
• 하지만 위치 간 상대 거리/기하학적 관계를 표현하기가 까다로움(왜곡 가능)

2.3 Sinusoidal Positional Encoding (원 논문 정석)

• 짝수 차원에는 sin, 홀수 차원에는 cos를 번갈아 사용

$$ PE(pos, 2i) = \sin\left(\frac{pos}{10000^{\frac{2i}{d_{model}}}}\right) $$

$$ PE(pos, 2i+1) = \cos\left(\frac{pos}{10000^{\frac{2i}{d_{model}}}}\right) $$

직관(강의 흐름 정리)

• sin/cos 범위는 대략 ([-1, 1]) → 스케일 폭주 방지
• 차원마다 주파수가 달라서 짧은/긴 거리 관계를 다양한 해상도로 표현
• “위치 변화가 벡터를 회전시키는 것처럼” 이해해도 직관적으로 도움이 됨

2.4 (실전) Positional Encoding 구현 예시 (이해용)

import numpy as np

def positional_encoding(max_len: int, d_model: int) -> np.ndarray:
    pos = np.arange(max_len)[:, None]              # (max_len, 1)
    i = np.arange(d_model)[None, :]                # (1, d_model)

    angle_rates = 1 / (10000 ** (2 * (i // 2) / d_model))
    angles = pos * angle_rates                     # (max_len, d_model)

    pe = np.zeros_like(angles)
    pe[:, 0::2] = np.sin(angles[:, 0::2])          # even
    pe[:, 1::2] = np.cos(angles[:, 1::2])          # odd
    return pe                                      # (max_len, d_model)

3) Self-Attention / Scaled Dot-Product Attention

3.1 Q, K, V를 한 문장으로

• Query(Q): “지금 내가 무엇을 찾고 싶은가?”
• Key(K): “각 토큰이 어떤 특징을 갖고 있어 매칭 기준이 되는가?”
• Value(V): “매칭되면 실제로 가져올 정보(내용)는 무엇인가?”

요약하면, 관계의 기준(Q/K)과 실제 내용(V)을 분리하면 표현력이 좋아진다는 흐름이다.

3.2 수식(정석)

$$ \mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V $$

“Scaled(/sqrt(d_k))”의 의미 (중요)

• 내적 (QK^\top)는 차원 (d_k)가 커질수록 값의 분산이 커지기 쉬움
• 그대로 softmax에 넣으면 값이 과도하게 커져 softmax가 포화(거의 0/1) → 학습 불안정
• 그래서 (\sqrt{d_k})로 나눠 스케일을 안정화한다

3.3 차원(shape) 추적 (구현 실수 방지 핵심)

시퀀스 길이 (L), 모델 차원 (d_{model}), 헤드 차원 (d_k, d_v)

강의의 “(3×4)·(4×2)=(3×2)” 감각은 맞지만, 실제로는 X와 W의 shape를 일관되게 유지하는 게 핵심이다.

4) Masked Self-Attention (왜 디코더에서만 마스크?)

4.1 이유: 생성(Autoregressive)은 “미래 토큰”을 보면 안 됨

• 디코더는 다음 단어를 예측해야 함
• 예: I love you에서 love를 예측할 때, 미래 토큰 you를 보면 치팅
• 그래서 디코더 self-attention에는 look-ahead mask(상삼각 마스크)를 적용한다

마스크 직관

허용: 과거/현재
금지: 미래

t=2일 때 볼 수 있는 범위: [1..2]

4.2 구현 관점(핵심)

• 마스크로 가려지는 위치의 score에 매우 작은 값을 더함(실제로는 (-\infty)에 가까운 값)
• softmax를 거치면 해당 확률이 거의 0이 되어 영향이 사라짐

5) Multi-Head Attention (왜 헤드를 여러 개 쓰나?)

5.1 직관(강의 흐름)

• 어떤 헤드는 주어-동사 관계를 강하게 보고
• 어떤 헤드는 지시어/대명사 관계를 보고
• 어떤 헤드는 구문 패턴을 본다 → 한 가지 attention만으로 모든 관계를 잡기 어렵기 때문에 여러 관점(헤드)으로 본다

5.2 수식(정석)

$$ \mathrm{head}_i = \mathrm{Attention}(QW_i^Q,; KW_i^K,; VW_i^V) $$

$$ \mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head}_1, \ldots, \mathrm{head}_h)W^O $$

5.3 차원 설계 (Residual을 위한 “차원 맞추기”)

• residual add를 하려면 입력/출력 차원이 같아야 함
• 보통 (d_{model})을 헤드 수 (h)로 나눔

$$ d_k = d_v = \frac{d_{model}}{h} $$

• 각 헤드 출력 concat → 다시 ((L, d_{model}))로 돌아와 residual add 가능

6) Skip Connection + Layer Normalization (Add & Norm)

슬라이드에서도 “성능 향상: Skip / LayerNorm”을 따로 강조한다.

6.1 Residual(Skip) Connection

• 목적: 깊은 네트워크에서 그라디언트 흐름 개선 + 학습 안정화

$$ y = x + \mathrm{SubLayer}(x) $$

6.2 LayerNorm (BatchNorm과 차이)

• BatchNorm: 배치 통계에 의존 → 배치 작으면 불안정
• LayerNorm: 토큰(샘플) 내부 feature 차원 기준 정규화 → 배치 크기에 덜 민감

7) Encoder/Decoder 블록 전체 흐름 한 장 요약

7.1 Encoder (한 층)

X
 -> Multi-Head Self-Attention
 -> Add & Norm (Residual + LayerNorm)
 -> Feed Forward
 -> Add & Norm

7.2 Decoder (한 층)

Y (shifted right)
 -> Masked Multi-Head Self-Attention
 -> Add & Norm
 -> Encoder-Decoder Attention (Q: decoder, K/V: encoder)
 -> Add & Norm
 -> Feed Forward
 -> Add & Norm

8) (다음 챕터 대비) GPT vs BERT에서 어디가 달라지나?

• BERT: Encoder-only (양방향 문맥 이해)
• GPT: Decoder-only (masked self-attention 기반, 다음 토큰 생성)

따라서 이번 파트의 “Positional Encoding, (Masked) Multi-Head Attention, LayerNorm, Residual”은 그대로 GPT/BERT 이해의 기반이 된다.

아래는 네 원문을 강의 흐름 그대로 유지하면서, Velog에서 수식이 깨지지 않도록 전부 $$ ... $$로 통일하고, 표/ASCII/shape 추적/단계별 정리까지 “교재” 톤으로 완성한 최종본이야. 그대로 복붙하면 돼.

3. Transformer for Computer Vision (ViT, DETR)

0) 이 강의에서 얻어야 하는 것 (학습 목표)

1. 왜 비전에서 트랜스포머를 쓰려 했는지
2. ViT 핵심 아이디어: 이미지를 토큰 시퀀스로 바꿔 Transformer Encoder에 넣기
3. DETR 핵심 아이디어: Detection을 집합(set) 예측으로 바꾸고 NMS 제거
4. 두 모델 모두에서 Positional Encoding/Embedding이 왜 필수인지
5. 면접/실무에서 말할 수 있게: 장점·단점·언제 쓰는지

1) 도입: “NLP에서 되면 CV에서도 되지 않을까?” + CNN의 Inductive Bias

1.1 CNN이 강한 이유(Inductive Bias)

CNN은 이미지에 맞는 “가정”이 구조적으로 들어가 있어서, 비교적 적은 데이터에서도 잘 학습되는 경향이 있습니다.

• 가정 1: 지역성(Locality) 가까운 픽셀들이 의미를 만든다 → 작은 커널로도 잘 배움
• 가정 2: 가중치 공유(Weight Sharing) 같은 패턴(엣지 등)은 위치가 달라도 같은 필터로 잡힌다
• 가정 3: Translation Equivariance 물체가 이동하면 feature map도 같이 이동 (완전한 invariance는 pooling/구조 설계로 얻는 경우가 많음)

1.2 CNN의 취약점(강의 예시를 정확히 정리)

강의의 “눈/코/입 위치가 이상해도 얼굴로 인식” 요지는 다음처럼 정리하면 더 정확합니다.

• CNN은 국소 패턴은 매우 잘 잡지만,
• 전역 관계(눈-코-입의 상대 위치)를 “자동으로 강제”하진 않음
• 따라서 데이터/학습 조건에 따라 부분만 맞으면 전체를 맞다고 착각하는 문제가 생길 수 있음

2) ViT (Vision Transformer) — “이미지를 토큰으로 만든다”

핵심 문장: 이미지를 패치로 쪼개서, 각 패치를 토큰처럼 만들어 Transformer Encoder에 입력한다.

2.1 ViT 전체 흐름 (Step-by-step)

Step 1) Patchify: 이미지를 P×P 패치로 쪼갠다

• 입력 이미지:

$$ X \in \mathbb{R}^{H \times W \times C} $$

• 패치 크기: (P \times P)
• 패치 개수:

$$ N = \frac{H}{P}\cdot \frac{W}{P} $$

• 각 패치를 펼치기(flatten):

$$ x_{p,i} \in \mathbb{R}^{P^2\cdot C} $$

✅ shape 추적(예시)

• 이미지: (224\times224\times3)
• 패치: (16\times16)
• 패치 개수: (N=(224/16)^2=14^2=196)
• 패치 벡터 차원: (16^2\cdot3=768)

Step 2) Linear Projection: 패치를 D차원 토큰으로 바꾼다

• 학습 가능한 선형 변환(프로젝션):

$$ z_i = x_{p,i}W_E + b,\quad z_i \in \mathbb{R}^{D} $$

• 행렬 차원:

$$ W_E \in \mathbb{R}^{(P^2C)\times D} $$

Step 3) [CLS] 토큰 붙이기 + Positional Embedding 더하기

• 분류를 위해 맨 앞에 [CLS] 토큰 추가:

$$ Z_0 = [z_{\text{cls}};; z_1;; \dots;; z_N] $$

• 위치 정보를 잃기 때문에 Positional Embedding을 더함:

$$ Z = Z_0 + E_{\text{pos}} $$

여기서

$$ E_{\text{pos}} \in \mathbb{R}^{(N+1)\times D} $$

Step 4) Transformer Encoder 통과

• 표준 Encoder 블록(MHSA + FFN + Residual + LayerNorm)을 (L)번 반복

Step 5) MLP Head로 분류

• 마지막 층 출력에서 [CLS] 위치 벡터를 뽑아 분류:

$$ \hat{y} = \mathrm{MLP}(Z^{(L)}_{\text{cls}}) $$

2.2 (중요) ViT는 왜 큰 데이터가 필요했나?

강의의 “그냥 쓰면 훈련이 잘 안 된다”는 말을 원인-결과로 정확히 정리하면:

• CNN은 이미지에 맞는 inductive bias(지역성/공유/계층)가 있어서 상대적으로 적은 데이터에서도 안정적으로 학습되는 편
• 초기 ViT는 그 bias가 약해서 “무슨 패턴을 우선 배워야 하는지”를 데이터에서 더 많이 배워야 했음
• 그래서 논문에서 대규모 데이터로 pretrain 후 fine-tune을 강조(JFT-300M 등)

2.3 ViT 시각화 결과(강의 포인트 3가지)

1. Embedding filter가 low-level 패턴을 학습

• CNN 1층이 엣지/텍스처를 배우듯, ViT 초기 층에서도 유사 패턴이 나타남

2. Positional embedding 이후 공간 구조가 드러남

• 위치 정보가 들어가면서 “가까운 패치끼리 비슷하게 보는 경향” 같은 구조가 관찰

3. Layer가 깊어질수록 attention distance가 커짐

• 초기층은 근처 패치, 후반층은 먼 패치까지 보며 CNN의 receptive field가 넓어지는 느낌과 유사한 현상

2.4 ViT 한 장 요약(면접용)

• 한 줄: “이미지를 패치 토큰 시퀀스로 바꿔 Transformer Encoder로 분류한다.”
• 장점: 전역 관계를 MHSA로 직접 모델링
• 단점(초기 ViT 관점): CNN bias가 약해 큰 데이터/사전학습 의존도가 큼

3) DETR — “Detection을 Set Prediction으로 바꿔 NMS 제거”

강의에서 “DETI”처럼 들린 건 DETR이 맞습니다. (End-to-End Object Detection with Transformers, ECCV 2020)

3.1 기존 Detection의 골칫거리: 후보 박스가 많아 NMS 필요

• 앵커/후보가 많아 같은 물체에 박스가 여러 개 겹쳐 나옴
• 그래서 후처리로 NMS(Non-Maximum Suppression)로 중복 제거

3.2 DETR의 핵심 아이디어 (Step-by-step)

Step 1) Backbone(CNN)으로 feature map 추출

• ViT처럼 처음부터 패치 토큰화하는 게 아니라,
• CNN으로 feature map을 뽑고 Transformer에 입력

예:

$$ F \in \mathbb{R}^{H' \times W' \times C'} $$

Step 2) feature map을 시퀀스로 펼치고(Flatten), 2D Positional Encoding 추가

• Flatten 후 시퀀스 길이:

$$ L = H'\cdot W' $$

• 펼친 형태(개념):

$$ X \in \mathbb{R}^{L \times C'} $$

• 2D 위치 정보를 유지하기 위해 positional encoding을 더함:

$$ X \leftarrow X + E_{\text{pos}} $$

Step 3) Transformer Encoder로 전역 컨텍스트 통합

• Encoder가 이미지 전체 정보를 통합한 표현을 만든다

Step 4) Decoder에 “Object Queries”를 넣는다 (DETR 감성 핵심)

• 고정 개수 (N_q)개의 학습 가능한 query 벡터

$$ Q \in \mathbb{R}^{N_q \times d_{model}} $$

• 각 query가 “하나의 물체 슬롯”처럼 동작하도록 학습된다

Step 5) 각 query 출력에서 (클래스, 박스) 예측

• 각 query마다 출력:

  • class logits: (K) classes + no-object
  • box: ((c_x, c_y, w, h)) (보통 정규화)

3.3 no-object 클래스는 왜 필요?

고정 개수 query를 쓰면, 이미지에 물체가 2개여도 query는 예를 들어 100개일 수 있습니다.

• 남는 query들은 “아무 물체도 담당하지 않음”이어야 함
• 그래서 no-object 클래스가 필요하다

3.4 NMS를 없애는 핵심 장치: Bipartite Matching + Hungarian Algorithm

핵심 목표

“각 GT(정답 물체)에 예측 query를 1개씩만 매칭하자.” → 그러면 같은 물체를 여러 query가 중복 예측하는 학습이 줄어듦 → NMS 의존이 감소

Step-by-step

1. 예측 (N_q)개와 GT (N_{gt})개의 비용(cost) 행렬 구성
2. 비용 합이 최소가 되는 1:1 매칭을 찾음 (Hungarian Algorithm)
3. 그 매칭 결과로 loss를 계산하고 학습

3.5 DETR Loss를 “직관”으로 이해하기

보통 손실은 다음 두 덩어리로 이해하면 충분합니다.

• Class loss: 각 query가 어떤 클래스인지(or no-object인지)

• Box loss: 박스 좌표가 얼마나 맞는지

  • L1 loss
  • IoU 계열 손실(GIoU 등)을 함께 쓰는 경우가 많음

헝가리안 매칭은 “loss를 최소화하는 1:1 매칭을 고르는 과정”으로 이해하면 정확합니다.

4) ViT vs DETR vs CNN 한 번에 정리

4. Transformer for Time Series (Informer 중심)

0) 이 파트 한 줄 목표

시계열 예측은 입력 길이 (L)이 매우 길어지기 쉬워서 Self-Attention 비용이 $(O($$L^2$$))$ 로 폭증한다. Informer(AAAI 2021) 는 이를 줄이기 위해 중요한 Query만 골라 계산하는 ProbSparse Attention으로 효율을 높여 Long Sequence Forecasting을 가능하게 하려는 모델이다.

1) 용어/발화 오류 교정 (강의 이해 필수)

✅ 중요한 정정 1 — 샘플링 예시 숫자

강의에서 “30초 + 100kHz → 3000개 입력”이라고 했다면 수치가 어긋나 있어요.

• 100kHz = 초당 100,000 샘플
• 30초면:

$$ L = 30 \times 100{,}000 = 3{,}000{,}000 $$

즉 3,000,000개가 맞습니다. “3000개”라는 발화는 실제 의도가 100Hz(초당 100샘플) 정도였을 가능성이 큽니다.

2) 왜 시계열은 Transformer가 힘든가? (핵심 논리 Step-by-step)

Step 1) 시계열은 입력 길이 (L)이 매우 길어지기 쉽다

• 자연어 문장은 보통 수십~수백 토큰
• 센서/로그/계측 데이터는 초당 샘플이 누적되어 수천~수백만 포인트까지 늘어남

Step 2) Self-Attention은 (L\times L) 어텐션 행렬이 생긴다

기본 self-attention은 다음을 계산한다.

$$ A = \mathrm{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right) $$

여기서 (A)의 shape는:

$$ A \in \mathbb{R}^{L \times L} $$

Step 3) 그래서 계산/메모리가 (O(L^2))로 증가한다

예를 들어 (L=3000)이면,

$$ L^2 = 3000 \times 3000 = 9{,}000{,}000 $$

어텐션 행렬만 900만 원소가 된다. 여기에 레이어 수, 헤드 수, 배치 크기까지 곱해지면 시계열에서는 큰 부담이 된다.

3) Informer 핵심 아이디어: “모든 Query를 다 계산하지 말자”

강의의 직관은 다음으로 요약할 수 있다.

3.1 Lazy Query vs Active Query

• Lazy Query: 모든 Key에 대한 attention 분포가 거의 균등(평평) → 계산해도 얻는 정보가 적다
• Active Query: 특정 Key에 attention이 강하게 몰림 → 중요한 상호작용이므로 계산 가치가 크다

Lazy:   [0.02 0.02 0.02 0.02 ...]  (거의 균등)
Active: [0.60 0.20 0.10 0.05 ...]  (특정 키에 집중)

4) ProbSparse Attention: “Active Query만 뽑아서 계산”

4.1 핵심 아이디어

• 전체 Query 중에서 상위 (u)개(활성 Query)만 골라 attention을 계산
• 나머지는 근사/생략하여 비용을 줄인다

강의에서 “Top 6 query” 같은 표현은 보통 다음을 의미한다.

• 전체 Query 중 상위 (u)개만 attention 계산
• (u)는 고정 숫자일 수도 있고, 길이 (L)에 따라 정해질 수도 있음(설계/실험에 따라)

✅ 중요한 정정 2 — “uniform처럼 만들자”가 아니라 “uniform에서 멀수록 중요”

강의에서 “uniform(1/Lk)처럼 만들도록 loss를 준다”처럼 들렸다면 오해가 생길 수 있어요. 이 파트는 보통 아래 흐름으로 이해하는 게 자연스럽습니다.

1. 어떤 Query의 attention 분포가 uniform에 가까우면 (lazy) 정보량이 적다
2. uniform에서 멀수록 (active) 특정 Key에 집중하므로 중요하다
3. 따라서 uniform에서 많이 벗어난 Query를 골라 계산한다

즉 결론은:

“uniform처럼 만들자”가 아니라 “uniform에서 많이 벗어난(active) Query를 골라 계산하자” 가 핵심입니다.

5) Informer 예측 구조: Encoder–Decoder 입력 구성

시계열 예측에서는 디코더 입력을 다음처럼 구성하는 방식이 흔합니다.

5.1 Encoder input / Decoder input

• Encoder input ((X_{enc})): 과거 관측 시계열(긴 구간)

• Decoder input: 두 부분으로 구성

  1. 과거 끝부분 일부(known tail): 실제 관측값 일부를 넣어 시작점을 제공
  2. 미래 구간 placeholder: 예측할 길이만큼 0 또는 마스크 값으로 자리만 확보

5.2 전체 흐름(그림)

flowchart LR
  A[Past series X_enc] --> Enc[Encoder]
  B[Known tail tokens] --> DecIn[Decoder input]
  C[Future placeholders (zeros/mask)] --> DecIn
  Enc --> Dec[Decoder]
  DecIn --> Dec
  Dec --> Yhat[Forecast Y_hat]
  Ytrue[Ground truth future] --> Loss
  Yhat --> Loss

5.3 학습은 어떻게 진행되나?

• 디코더 출력 (\hat{Y})를 실제 미래 (Y)와 비교해 loss(MSE 등)를 최소화하도록 학습

예:

$$ \mathcal{L} = \frac{1}{T}\sum_{t=1}^{T} (Y_t - \hat{Y}_t)^2 $$

핵심은 “긴 시퀀스를 다 보는 대신, 계산할 attention을 줄여 효율을 확보”하는 방향입니다.

6) 차원(shape) 추적 (구현 시 실수 방지)

시퀀스 길이 (L), 모델 차원 (d_{model}), 헤드 차원 (d_k)

Informer는 여기서 모든 Query에 대해 $(L\times L)$ 계산을 하지 않도록 줄이는 게 핵심이다.

5 BERT & GPT

5.1 이 교재 사용법

1. [타임라인 ↔ 슬라이드]로 “지금 강의가 어느 페이지인지” 먼저 잡습니다.
2. 각 파트는 아래 순서로 공부하면 가장 안정적으로 이해가 됩니다.

• 정확 용어/정의(발화 오류 교정 포함)
• 핵심 직관(그림/표로 요약)
• 수식(슬라이드/논문식 형태로 정확 표기 + 의미 해설)
• 면접/실무 답변 템플릿(15초 요약)

5.2 강의 음성 TXT ↔ 슬라이드 싱크 맵 (PDF 페이지 기준)

5.3 강의에서 자주 헷갈린 용어/표현 정정 표

5.4 Part A. 왜 BERT/GPT가 폭발했나 (p2–p4)

5.4.1 강의 핵심 논리 (Step-by-step)

Step 1) NLP는 입력 데이터 (X)가 매우 많다

• 웹/문서/댓글/로그 등 텍스트는 무한히 쌓인다(강의 요지)

Step 2) 하지만 레이블 (Y)를 만들기 어렵다

• 번역/요약/NLI 등은

  • “정답의 정의” 자체가 애매하거나
  • 사람마다 기준이 달라 합의(투표/다수결/가이드라인)가 필요

Step 3) 결론: “레이블 없이도 학습되는 과제”로 먼저 크게 학습한다

• Self-supervised(자기지도) 과제(MLM/다음토큰예측)로 표현을 먼저 학습
• 이후 필요한 태스크에 소량 레이블로 적응(파인튜닝/프롬프트)

5.4.2 (p4) “NLP vs Bio/CV”가 말하는 진짜 포인트

5.5 Part B. Pretrain → Finetune / Transfer / Few-shot·Zero-shot (p5–p10)

5.5.1 (p5) CV 예시로 이해하는 “프리트레인–파인튜닝”

강의의 “로우레벨/하이레벨 필터”를 NLP로 대응하면:

• 로우레벨: 기본 문법/표현/일반 문맥 패턴(범용)
• 하이레벨: 특정 태스크(감성/QA/NER/분류)에 맞는 결정 경계(특화)

파라미터 고정(Freeze) 직관

[Pretrained Backbone]
Layer1  (freeze)  <- 범용 패턴
Layer2  (freeze)
Layer3  (train)   <- 타겟 태스크에 맞게 조정
Head    (train)   <- 태스크 출력층

실무 팁: 데이터가 적을수록 “하단 레이어 freeze + 상단만 학습”이 안정적인 출발점입니다.

5.5.2 (p6) Transfer learning vs Finetuning 정리

5.5.3 (p7) Few-shot / One-shot / Zero-shot (NLP 프롬프트로 정확 대응)

정의(시험/면접)

• Zero-shot: 예시 0개
• One-shot: 예시 1개
• Few-shot: 예시 (k)개

NLP 구현(강의 “번역 원샷”을 정확 프롬프트로)

[예시(1-shot)]
한국어: 나는 배고프다
영어: I am hungry

[문제]
한국어: 오늘 날씨가 좋다
영어:

핵심:

• 파라미터 업데이트(gradient update) 없이
• 프롬프트(지시 + 예시 + 질의)만으로 조건부 생성을 수행

5.5.4 (p8–p10) Domain/러닝 패러다임 혼동 방지(필수 2개)

(1) Domain이란?

도메인 (D)는 보통 데이터가 생성/샘플링되는 분포(환경)를 의미합니다.

(2) Transfer vs (In-context) Zero/Few-shot을 가르는 가장 쉬운 기준

• Transfer(파인튜닝 포함): 타겟 데이터로 파라미터 업데이트 있음
• Zero/Few-shot(in-context): 프롬프트에 예시가 있을 뿐 파라미터 업데이트 없음

5.6 Part C. GPT-1 (p11–p19) — Generative Pre-Training + Fine-tuning

5.6.1 (p11) GPT-1 큰 그림

• GPT = Generative Pre-Training
• 철학: (1) LM으로 먼저 크게 학습 → (2) 태스크별로 약간만 맞춤

flowchart LR
  A[Large unlabeled text] --> B[Stage 1: LM Pretraining]
  B --> C[Transformer Decoder (shared)]
  D[Labeled dataset per task] --> E[Stage 2: Supervised fine-tuning]
  C --> E
  E --> F[Downstream performance]

5.6.2 (p14) Stage 1: Causal Language Modeling 수식(정확 표기)

토큰 시퀀스를 (U=(u_1,\dots,u_n))라 할 때, GPT의 언어모델은 과거 토큰만 조건으로 다음 토큰을 예측합니다.

(1) 최대화 관점(로그우도)

[ \max_{\theta}\ \sum_{i=1}^{n}\log P(u_i \mid u_{<i};\theta) ]

(2) 손실(최소화) 관점(음의 로그우도)

[ L_{\text{LM}}(\theta) =====================

-\sum_{i=1}^{n}\log P(u_i \mid u_{<i};\theta) ]

강의의 “레프트-투-라이트(미래 못 봄)”는 (u_{<i})만 쓰는 조건부 확률을 뜻합니다.

5.6.3 (p15) Stage 2: Supervised Fine-tuning + LM 보조항

타겟 태스크 데이터 (C)가 ((x,y)) 쌍의 집합일 때:

(1) 태스크 손실(예: 분류)

[ L_{\text{task}}(\theta) =======================

-\sum_{(x,y)\in C}\log P(y\mid x;\theta) ]

(2) 최종 손실(슬라이드의 (\lambda) 결합을 “손실 형태로” 정확히)

[ L(\theta) =========

L_{\text{task}}(\theta) + \lambda\ L_{\text{LM}}(\theta) ]

• (\lambda)가 작은 이유(강의 의도):

  • 태스크 성능에 집중하되
  • LM 일반성(표현)을 조금 유지해 과적합 완화에 도움

5.6.4 (p16) “입력 구조만 바꾸면 다양한 태스크에 적용”의 의미

모델(디코더 트랜스포머)은 그대로 두고, 태스크 입력을 텍스트 시퀀스로 ‘포맷팅’합니다.

5.6.5 (p17–p19) Ablation 요지(강의 포인트 유지)

• 프리트레인(LM) + 파인튜닝 조합이 성능에 기여
• 모델 깊이/규모 증가가 성능을 밀어올림
• LSTM 대비 Transformer가 여러 태스크에서 더 강한 경향

5.7 Part D. BERT (p20–p35) — Bidirectional Encoder + MLM(+NSP)

5.7.1 (p21–p23) GPT vs BERT 구조 차이(핵심 1줄)

• GPT: Decoder + Causal(미래 마스킹) → 생성에 유리
• BERT: Encoder + Bidirectional(좌/우 문맥) → 이해/표현학습에 유리

GPT (Causal):
t3는 (t1,t2)만 봄, (t4,t5)는 마스킹

BERT (Bidirectional):
t3는 (t1,t2,t4,t5) 모두 볼 수 있음
(단, MLM에서는 일부 토큰이 [MASK]로 가려짐)

5.7.2 (p24–p26) Pretrain 1: Masked Language Model(MLM)

목적

입력 토큰 일부를 가리고, 가려진 토큰을 맞추며 양방향 문맥 표현을 학습합니다.

마스크 위치 집합을 (M)이라 할 때:

[ L_{\text{MLM}}(\theta) ======================

-\sum_{i\in M}\log P(x_i \mid x_{\backslash M};\theta) ]

80/10/10 규칙(강의 싱크 강함)

마스크 후보로 뽑힌 토큰(보통 전체의 15% 내외)에 대해:

• 80% → [MASK]로 치환
• 10% → 랜덤 토큰으로 치환
• 10% → 원래 토큰 유지

이유

• 파인튜닝/추론에서는 [MASK]가 없을 수 있으므로 [MASK]에만 과적응하는 것을 방지

5.7.3 (p27) Pretrain 2: Next Sentence Prediction(NSP)

두 문장 A, B가 주어졌을 때:

• IsNext: 실제 코퍼스에서 A 다음에 B가 이어짐
• NotNext: B를 다른 문서/문맥에서 랜덤 샘플

목표는: [ L_{\text{NSP}}(\theta) ======================

-\sum \log P(\text{label} \mid A,B;\theta) ]

강의 기준에서는 NSP를 핵심 구성으로 설명하므로 그대로 따라가면 됩니다.

5.7.4 (p28) BERT 입력 임베딩 3종 합(시험 단골)

토큰 위치 (i)에서 최종 입력 임베딩:

[ \mathbf{e}_i ============

\mathbf{e}^{token}_i + \mathbf{e}^{pos}_i + \mathbf{e}^{segment}_i ]

• (\mathbf{e}^{token}): 토큰 의미(서브워드)
• (\mathbf{e}^{pos}): 위치 정보
• (\mathbf{e}^{segment}): 문장 A/B 구분(문장쌍 입력)

5.7.5 (p29) Fine-tuning 패턴 2가지(문장 단위 vs 토큰 단위)

(1) Sequence-level(문장/문장쌍 분류)

• [CLS] 출력 벡터 (\mathbf{h}_{CLS}) → 분류기 → label

[ \hat{y}=\text{softmax}(W\mathbf{h}_{CLS}+b) ]

(2) Token-level / Span-level

• NER: 각 토큰 벡터 (\mathbf{h}_i)에 분류기
• SQuAD(QA): start/end 위치 예측

SQuAD 스팬 점수화(강의의 dot product를 수식으로 정리)

[ \text{score}{start}(i)=\mathbf{h}*i^\top \mathbf{s},\quad \text{score}{end}(i)=\mathbf{h}i^\top \mathbf{e} ] [ P(start=i)=\text{softmax}(\text{score}{start}),\quad P(end=i)=\text{softmax}(\text{score}*{end}) ]

5.7.6 (p30–p33) 벤치마크가 의미하는 것(강의 흐름 유지)

5.7.7 (p34–p35) Ablation 해석(강의 요지 그대로)

• 당시 설정에서는 MLM/NSP가 성능에 기여
• 특히 MLM이 “문맥 표현”을 강하게 밀어줌

5.8 Part E. GPT-2 (p36–p44) — 더 큰 데이터 + BPE + Zero-shot

5.8.1 (p36–p38) GPT-2가 강조한 3가지

1. 더 큰 데이터(WebText 등)로 LM 학습
2. 스케일(모델/데이터) 증가
3. 파인튜닝 없이도(혹은 최소화) zero-shot 성능을 보여줄 수 있다

5.8.2 (p39–p43) BPE(Byte Pair Encoding) — 완전 정리

왜 필요한가?

• 단어 단위 토크나이징은 OOV(사전에 없는 단어)가 빈번
• 서브워드(BPE/WordPiece 등)를 쓰면 “처음 보는 단어”도 분해/조합 가능

BPE 알고리즘(정확 Step-by-step)

1. 초기 vocabulary를 문자(또는 바이트) 단위로 시작
2. 말뭉치에서 가장 빈번한 연속 pair를 찾음
3. 그 pair를 merge하여 하나의 토큰으로 추가
4. 목표 vocab 크기까지 반복

강의의 “트위터 이모지” 맥락은, byte-level 계열 토크나이징이 특수문자/이모지 처리에 유리하다는 직관으로 이해하면 됩니다.

5.8.3 (p36–p44) Zero-shot 프롬프트화(강의 요지)

• 분류 문제도 “라벨을 출력 토큰으로 생성”하는 형태로 바꿔서 수행 가능
• 즉, 헤드(softmax classifier)를 학습하지 않고 프롬프트로 태스크를 기술

5.9 Part F. GPT-3 (p45–p49) — 스케일 + In-context learning

5.9.1 (p45) GPT-3 핵심 메시지(강의 표현 그대로)

• GPT-2 철학을 확장: 더 큰 모델 + 더 큰 데이터 → 더 강한 일반화
• 프롬프트에 예시를 넣어 zero/one/few-shot 수행
• 중요한 포인트: gradient update 없이(학습 없이) 추론에서 해결

5.9.2 In-context learning 흐름(도식)

flowchart LR
  A[Instruction: task description] --> M[Pretrained GPT]
  B[Examples: (x1->y1)...(xk->yk)] --> M
  C[Query: x?] --> M
  M --> D[Generated answer y?]

5.9.3 (p49) 강의 요약을 “한 줄”로

• BERT: 문장을 “이해/표현”하는 데 강한 인코더
• GPT: 문장을 “생성/연속 예측”하는 데 강한 디코더

5.10 Part G. 실무/연구 동향 (강의 위에 최소 확장)

5.10.1 PEFT(예: LoRA) — “가볍게 적응시키는 파인튜닝”

• 대형 모델 전체를 업데이트하면 비용/메모리가 큼
• 그래서 일부 저랭크 어댑터만 학습해 빠르게 적응
• 대표: LoRA (arXiv:2106.09685)

면접용 한 줄

• “요즘은 full fine-tuning 대신 LoRA 같은 PEFT로 비용을 줄이고 빠르게 도메인 적응한다.”

5.10.2 RAG — “모르는 지식은 검색으로 보강”

• 모델 파라미터에 지식을 ‘다’ 넣기보다 검색으로 관련 문서(근거)를 가져와 생성에 결합
• 대표 개념 정리로 널리 인용되는 축: RAG (arXiv:2005.11401)

면접용 한 줄

• “최신/사내 지식과 근거가 필요하면 RAG로 문서를 붙여 환각을 줄인다.”

5.11 Part H. (시험/면접 대비) 15초 답변 템플릿 6개

5.11.1 왜 프리트레인이 필요한가?

“자연어는 입력 데이터는 많지만 레이블이 만들기 어려워서, 자기지도 과제로 대규모 사전학습을 하고 소량의 레이블로 다운스트림 태스크에 적응시키는 프리트레인–파인튜닝 전략이 강해졌습니다.”

5.11.2 GPT와 BERT의 구조 차이?

“GPT는 디코더 기반 causal LM이라 과거만 보고 다음 토큰을 생성하고, BERT는 인코더 기반 양방향 self-attention으로 좌우 문맥을 함께 보며 표현을 학습합니다.”

5.11.3 GPT-1의 2-stage는?

“1단계에서 언레이블 텍스트로 LM을 프리트레인하고, 2단계에서 태스크 레이블로 파인튜닝하며 필요하면 LM 손실을 (\lambda)로 섞어 일반성을 유지합니다.”

5.11.4 BERT의 MLM 80/10/10 이유?

“추론 때 [MASK]가 없으므로 [MASK]에 과적응하지 않게 랜덤/원토큰을 섞어 견고한 문맥 표현을 학습합니다.”

5.11.5 Zero-shot/Few-shot의 핵심?

“파라미터 업데이트 없이, 프롬프트에 지시문과 예시를 넣어 조건부 생성으로 태스크를 수행하는 방식입니다.”

5.11.6 요즘 현업 파인튜닝/운영 흐름?

“대형 모델은 LoRA 같은 PEFT로 일부만 학습해 비용을 줄이고, 최신 지식/근거가 필요하면 RAG로 검색 문서를 결합합니다.”

5.12 Part I. 연습문제 + 채점 기준

5.12.1 개념 퀴즈 8문항

1. (p4) 자연어에서 “레이블링이 어렵다”는 말이 의미하는 두 가지를 쓰시오.
2. (p5) 프리트레인–파인튜닝에서 freeze를 하는 이유를 데이터 크기 관점에서 설명하시오.
3. (p7) zero-shot과 transfer learning을 구분하는 가장 쉬운 기준은?
4. (p14) GPT의 Causal LM은 어떤 조건부 확률을 최대화하는가?
5. (p15) (L=L_{\text{task}}+\lambda L_{\text{LM}})에서 (\lambda)를 작게 두는 직관은?
6. (p28) BERT 입력 임베딩 3종과 역할을 각각 쓰시오.
7. (p29) SQuAD에서 start/end를 예측하는 점수화는 어떤 형태인가?
8. (p39–p43) BPE가 OOV를 줄이는 원리를 2~3줄로 설명하시오.

5.12.2 채점 기준(핵심만)

• 3번: 파라미터 업데이트 유무를 말하면 정답
• 5번: “태스크에 집중하면서도 LM 일반성을 조금 유지(과적합 완화)”면 정답
• 7번: “각 토큰 벡터와 start/end 벡터의 dot product(선형 점수) 후 softmax”면 정답

6. Hugging Face Library

아래는 네가 정리해둔 실습 코드를 교재형으로 “형식/수식(표기)/코드(실행가능)”까지 통일해서, 앞뒤 흐름이 끊기지 않게 다시 엮은 최종본이야. (마지막에 바로 실행 가능한 .ipynb / .py 파일도 같이 줌)

6.1 이 장의 목표

6.1.1 우리가 “정확히” 하려는 것

1. pipeline()으로 즉시 추론(inference) 하기
2. AutoTokenizer로 토큰화 → id 변환 → 텐서 입력 흐름 이해하기
3. datasets.load_dataset()로 TSV/JSON 데이터 로드하기
4. map()으로 전처리(예: HTML unescape) 하기
5. PyTorch로 학습 루프(training loop) + scheduler까지 최소 단위로 돌려보기

6.2 실습 준비

6.2.1 설치(로컬/코랩 공통)

pip install -U transformers datasets accelerate torch tqdm

6.2.2 디바이스 선택(공통)

• GPU가 있으면 cuda, 없으면 cpu

import torch
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

6.3 Pipeline 빠른 시작

6.3.1 Pipeline이 해주는 일(한 줄 정의)

pipeline(task)는 내부적으로 아래를 자동으로 묶어준다.

[ \text{pipeline} = \text{Tokenizer} \circ \text{Model} \circ \text{PostProcess} ]

즉, 토크나이징 → 모델 forward → 후처리(확률/디코딩) 까지 “한 방”에 처리한다.

6.3.2 (실습 1) fill-mask

from transformers import pipeline

unmasker = pipeline("fill-mask")
unmasker("This course will teach you all about <mask> models", top_k=2)

핵심 포인트

• 문장 안에 <mask>를 넣으면, pipeline이 해당 모델의 mask 토큰으로 맞춰서 처리한다.
• 재현성을 올리려면 모델을 명시하는 게 좋다:

unmasker = pipeline("fill-mask", model="bert-base-uncased")

6.3.3 (실습 2) sentiment-analysis (docx 텍스트 코드 반영)

from transformers import AutoTokenizer, pipeline

model_name = "klue/roberta-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
classifier = pipeline("sentiment-analysis", model=model_name, tokenizer=tokenizer)

classifier("이 강의 진짜 도움 많이 됐어요!")

6.4 Tokenizer → id → Model 입력

6.4.1 토크나이저의 역할(정확 정의)

텍스트 (x)가 들어오면, 모델이 먹을 수 있는 텐서 묶음으로 변환한다.

[ x ;\rightarrow; {\text{input_ids},;\text{attention_mask},;\text{token_type_ids(optional)}} ]

• input_ids: 토큰 id 시퀀스
• attention_mask: 패딩(0) vs 실제 토큰(1)
• token_type_ids: 문장쌍(A/B) 구분(BERT류에서 주로 사용)

6.4.2 (실습 3) docx 이미지 예시 그대로 + 실패 라인 유지

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)

sequence = "I've been waiting for a HuggingFace course my whole life."

tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
input_ids = torch.tensor(ids)

# This line will fail.
model(input_ids)

왜 실패하나? (원인 “정확히”)

대부분의 Transformer 모델 입력은 배치 차원(batch dimension) 을 기대한다.

• 지금 input_ids shape: [ (seq_len,) ]
• 모델이 기대하는 기본 shape: [ (batch,;seq_len) ]

6.4.3 Fix(실행되게 만들기): 배치 차원 추가

input_ids = torch.tensor([ids])   # (batch, seq_len)
model(input_ids)

6.4.4 실무/실습에서 “정석”(추천): tokenizer가 바로 텐서 만들게 하기

이게 제일 덜 틀리고, attention_mask도 자동으로 들어가서 안정적이다.

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)

sequence = "I've been waiting for a HuggingFace course my whole life."

inputs = tokenizer(sequence, return_tensors="pt")  # dict of tensors
outputs = model(**inputs)

logits = outputs.logits                    # (batch, num_labels)
pred = logits.argmax(dim=-1).item()

print("pred:", pred, "label:", model.config.id2label[pred])

출력 텐서 shape(시험/디버깅 핵심)

• 분류 모델이면:

[ \text{logits shape} = (batch,;num_labels) ]

6.5 Tokenizer 내부 구조(backend_tokenizer) + normalizer

6.5.1 왜 보나?

• “토큰화가 내부에서 어떻게 동작하는지”를 실제로 확인하는 용도
• 특히 normalize_str는 악센트/특수문자 정규화 같은 전처리 감각을 잡기 좋다.

6.5.2 (실습 4) backend_tokenizer + normalizer

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
print(type(tokenizer.backend_tokenizer))

print(tokenizer.backend_tokenizer.normalizer.normalize_str("Héllò hôw are ü?"))

6.6 Datasets 로드

6.6.1 TSV 로드(drugsCom 예시)

from datasets import load_dataset

data_files = {"train": "drugsComTrain_raw.tsv", "test": "drugsComTest_raw.tsv"}
drug_dataset = load_dataset("csv", data_files=data_files, delimiter="\t")

빠른 확인

drug_dataset["train"]["condition"][:3]

6.6.2 JSON 로드(SQuAD_it 예시)

from datasets import load_dataset

data_files = {"train": "SQuAD_it-train.json", "test": "SQuAD_it-test.json"}
squad_it_dataset = load_dataset("json", data_files=data_files, field="data")

샘플 1개 확인:

squad_it_dataset["train"][0]

6.6.3 단일 JSON 로드(일반형)

from datasets import load_dataset
load_dataset("json", data_files="myfile.json")

6.7 map()으로 전처리(HTML unescape)

6.7.1 목적

리뷰 텍스트에 &, " 같은 HTML 엔티티가 남아있으면 모델 입력이 지저분해진다. html.unescape로 정리한다.

6.7.2 (실습 5) batched map 적용

import html

new_drug_dataset = drug_dataset.map(
    lambda x: {"review": [html.unescape(o) for o in x["review"]]},
    batched=True,
)
new_drug_dataset

핵심 포인트

• batched=True면 x["review"]가 리스트 단위로 들어오므로, 리스트를 리턴해야 한다.

• 실무에서는 이후에 보통:

  • remove_columns
  • rename_column("label", "labels")
  • set_format("torch") 같은 정리 루틴이 붙는다.

6.8 Training loop (tqdm) + Scheduler

6.8.1 학습 루프가 하는 일(정확 구조)

각 스텝에서:

1. 배치 텐서를 디바이스로 이동
2. forward: ( \hat{y} = f_\theta(x) )
3. loss 계산 (보통 Cross Entropy)
4. backward: ( \nabla_\theta L )
5. optimizer step
6. scheduler step
7. grad reset

분류의 표준 loss는:

[ L = -\sum_{c} y_c \log(\text{softmax}(\text{logits})_c) ]

6.8.2 (실습 6) 진행바 포함 training loop (네 코드 흐름 그대로)

from tqdm import tqdm

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

6.8.3 (실습 7) get_scheduler로 LR Scheduler 만들기

from transformers import get_scheduler

num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)
print(num_training_steps)

linear 스케줄 직관

• 학습이 진행될수록 LR을 선형으로 줄이는 형태
• warmup을 쓰면 초반엔 LR을 점점 올린 뒤, 이후 감소

6.9 실습에서 제일 많이 터지는 오류 TOP 6 (바로 해결형)

1. 배치 차원 누락

   • 해결: torch.tensor([ids]) 또는 tokenizer(..., return_tensors="pt")

2. attention_mask 없음

   • 해결: 수동 입력 말고 tokenizer() 출력 dict 사용

3. 모델/토크나이저 mismatch

   • 해결: 같은 checkpoint로 둘 다 로드

4. fill-mask에서 마스크 토큰 혼동

   • 해결: pipeline에는 <mask> 쓰면 안전, 직접이면 tokenizer.mask_token 확인

5. datasets.map에서 batched 처리 실수

   • 해결: batched면 리스트를 리턴해야 함

6. GPU 사용 시 device 인자 미지정

   • 해결: pipeline은 device=0, torch는 .to(device)

6.10 바로 실행 가능한 파일

• Download the Notebook
• Download the Python script

원하면 다음 단계로 HuggingFace실습.docx 이미지들을 “이미지 번호별 → 코드 셀로 정렬 → 중복 제거 → 실행 순서로 재배치” 해서, docx 전체를 1개의 완성 노트북으로 합치는 버전도 바로 만들어줄게.

title: 한국 바다낚시 완전정리 – 1~12월 서해·남해·동해 / 원투·메탈·다운샷·선상 기준 tags: [바다낚시, 원투낚시, 메탈지그, 다운샷, 선상낚시, 서해, 남해, 동해, 물때, 월별정리]

한국 바다낚시 연간 정리

(1~12월 / 서해·남해·동해 / 원투·메탈·다운샷·선상 기준)

대한민국은 4계절 뚜렷하고 3면이 바다인 미친(?) 나라다.
그래서 “언제, 어느 바다(서해/남해/동해), 어떤 낚시(원투/메탈/다운샷/선상)로, 어떤 물고기를, 어느 물때에 노려야 하는지” 를 한 번에 볼 수 있게 정리했다.

⚠️ 이 정리는 찌낚시(찌·카고·구멍찌 등) 를 전부 제외하고
원투 / 메탈루어 / 다운샷 / 선상 네 가지만 기준으로 한다.

1. 이 글에서 다루는 낚시 스타일

• 원투낚시

  • 갯바위, 방파제, 방조제, 해변(서프)
  • 타깃: 광어, 도다리, 도다리, 우럭, 장어, 고등어, 전갱이, 전어 등

• 메탈 루어 낚시

  • 메탈지그, 스틱베이트, 다이빙펜슬, 탑워터 등
  • 타깃: 삼치, 방어/부시리, 고등어, 전갱이, 농어, 광어 등

• 다운샷 루어 낚시

  • 바닥 찍고 살살 끌어오는 스타일
  • 타깃: 광어, 도다리, 우럭, 노래미, 무늬오징어(응용) 등

• 선상 낚시

  • 선상 지깅, 캐스팅, 다운샷, 타이러버, 에깅 등
  • 타깃: 광어, 도다리, 우럭, 방어/부시리, 삼치, 참돔, 한치, 갈치, 주꾸미·갑오징어 등

2. 연중 시즌 흐름 & 물때 기본 감각

2-1. 연중 대략 흐름

• 1~3월 (겨울 끝 / 초봄)

  • 수온 낮음 → 우럭·볼락·노래미·광어 일부 위주
  • 선상: 광어 다운샷, 우럭지깅, 동해 대구

• 4~6월 (봄 ~ 초여름)

  • 도다리·광어 산란 시즌(3~4월 피크) → 다운샷/원투 메인
  • 농어, 고등어, 전갱이 슬슬 붙기 시작

• 7~9월 (여름 ~ 초가을)

  • 고등어, 전갱이, 전어, 학공치, 갈치, 한치, 무늬오징어 등 회유성 어종 폭발
  • 동해/남해: 삼치·부시리(방어급) 메탈·지깅·캐스팅 시즌

• 10~12월 (가을 ~ 초겨울)

  • 광어·도다리·우럭·볼락 활성
  • 남해/제주/부산·거제 외해 기준
    방어·부시리 빅게임 11~2월 피크

2-2. 물때 기본 룰 (대략적인 가이드)

• 광어·도다리·우럭 (다운샷/원투)

  • 3~7물 : 조류 적당 → 채비 컨트롤 + 입질 둘 다 괜찮은 구간

• 삼치·방어·부시리·고등어·전갱이 (메탈/선상)

  • 5~8물 : 조류가 어느 정도 흘러야 떼가 붙고 활성도 좋음
  • 너무 사리(9~10물)면 채비 컨트롤이 빡세니, 포인트/수심 보고 선택

• 주꾸미·갑오징어 (특히 서해)

  • 25물 정도의 약중조류
  • 에기 컨트롤 편하고, 초보도 하기 쉬운 구간

• 볼락·노래미·장어 (원투/루어)

  • 조류가 너무 세지 않은 14물, 810물
  • 야간에 물 흐름 살짝 있는 정도가 이상적

3. 서해 – 1~12월 / 원투·메탈·다운샷·선상 정리

기준: 인천·시화방조제·대부도·충남·군산·격포 등 서해 전역 공통적인 패턴을
“월별 + 기법 + 어종 + 물때” 로 요약한 표.

3-1. 서해 월별 한눈에 보기

4. 남해 – 1~12월 / 원투·메탈·다운샷·선상 정리

기준: 부산·거제·통영·여수·완도 등 남해 전역 공통 패턴.
어종 다양성 미친 지역이라 필요 이상으로 다 잡히는 곳.

4-1. 남해 월별 한눈에 보기

5. 동해 – 1~12월 / 원투·메탈·다운샷·선상 정리

기준: 포항·울산·삼척·속초 등 동해 전역 공통 패턴.
특징: 수심이 빠르게 깊어지고, 삼치·부시리·대구 등 “동해스러운” 어종이 강함.

5-1. 동해 월별 한눈에 보기

6. 이 표를 실제로 활용하는 방법

6-1. 타깃 어종 먼저 고르기

예를 들어,

• “12월 방어·부시리 + 광어” 가 목표라면
  → 남해(부산·거제·통영) & 제주 외해, 동해 남부 외해 위주
  → 위 표에서 남해/동해 11~2월 줄 집중 체크

• “4월 도다리 위주 + 광어 서브”
  → 서해·남해 전역 도다리 산란기 / 다운샷·원투 위주
  → 서해/남해 3~4월 줄만 골라 보면 일정이 바로 나온다.

6-2. 내가 좋아하는 낚시 기법만 필터링하기

• 글에서 다루는 기법:
  • 원투 / 메탈 / 다운샷 / 선상
• 본인이 실제로 즐기는 1~2개만 고르면 됨
  • 예: “메탈 + 선상”만 보는 식으로, 나머지 열은 그냥 참고용

6-3. 물때 고르는 기준 요약

• 삼치·방어·부시리·고등어·전갱이(메탈/지깅)
  → 5~8물: 조류가 어느 정도 흘러줘야 활성도 Good

• 광어·도다리·우럭(다운샷/원투)
  → 3~7물: 바닥 찍기 편하고 입질 잘 들어오는 구간

• 장어·볼락·노래미
  → 14물 또는 810물: 너무 세지 않은 느린 조류 + 야간

• 주꾸미·갑오징어
  → 2~5물: 에기 컨트롤 쉬운 구간

7. 마무리 – “직장인 모드”로 낚시 계획 세우기

1. 월 & 어종 선택

   • “언제 시간이 비는지” → 가능한 월 체크
   • 그 달에 잘 나오는 어종을 표에서 먼저 고른다.

2. 지역 선택 (서해 vs 남해 vs 동해)

   • 거리, 숙소, 이동시간 고려
   • 방어·부시리면 남해/제주·동해,
     도다리·광어면 서해/남해,
     삼치·부시리 메탈이면 동해/남해 쪽으로 좁힌다.

3. 기법 선택

   • 원투 / 메탈 / 다운샷 / 선상 중에서
     이번 출조의 “컨셉”을 하나 정한다.

4. 물때 & 세부 일정

   • 위 표의 추천 물때 (대부분 3~8물 사이)에서
     본인 스케줄 가능한 날을 골라서 맞춘다.
   • 마지막으로 기상(바람·파고), 최근 조황, 금어기만 한 번 더 체크하면
     실패 확률을 꽤 많이 줄일 수 있다.

이 글은 “찌낚시를 제외하고, 원투·메탈·다운샷·선상만으로 한국 바다 1년을 정리한 캘린더”라고 보면 된다.
필요하면 다음 글에서

• “삼치/방어/광어만 따로 뽑은 전용 캘린더”
• “월별·바다별 추천 포인트 예시(포항 뜬방, 오륙도, 조도 등)”

같은 식으로 더 파고들 수 있다.

• Deployment(+HPA)

  • 성격: 상시 처리(큐 워커, 이벤트 소비).
  • 요구: at-least-once 전제, 재시도/내구성, 수평 확장.
  • 의미: 종료코드 143(TERM)은 롤링 등 “정상”일 확률↑ → 알림에서 노이즈 제거.

• Job

  • 성격: 끝이 있는 배치(백필, 리인덱스, 마이그). 완료 후 자원 0.
  • 핵심: completions/parallelism로 작업량·동시성 제어, Indexed로 샤딩/추적.
  • 정책: 실패 분류(podFailurePolicy), TTL 청소로 누적 방지.

• CronJob

  • 성격: 스케줄러(백업, 청소, 리포트).
  • 핵심: 겹침 방지(concurrencyPolicy) + 놓친 스케줄 보전(startingDeadlineSeconds) + 타임존.
  • 정책: 성공/실패 히스토리 제한 + TTL로 “작업 쓰레기” 제어.

2) 필수 파라미터의 “의미”

• concurrencyPolicy (Forbid/Replace/Allow)

  • 재진입 불가 작업이면 Forbid(중복 처리 차단), 최신만 중요하면 Replace.

• startingDeadlineSeconds

  • 컨트롤플레인/스케줄 지연 시 놓친 실행을 보전. 없으면 통째로 건너뜀.

• completionMode: Indexed (Job)

  • 각 완료 인덱스를 고유 샤드로 간주 → 누가 무엇을 처리했는지 추적 가능.

• backoffLimit / activeDeadlineSeconds

  • 재시도 한계/전체 시간 한계로 무한 재시도·좀비 작업 방지.

• ttlSecondsAfterFinished

  • 완료 리소스 자동 정리(운영 디폴트로 활성 가정).

• resources(requests/limits)

  • OOM/Evict 예방의 1순위. 긴 작업은 체크포인트로 재시작 가능 설계.

• topologySpreadConstraints / priorityClassName

  • 배치 분산/중요도 보장(노드 한쪽 치우침·자원 쟁탈 완화).

• timeZone (CronJob)

  • 운영 타임존과 스케줄 혼선 제거(Asia/Seoul 명시).

3) 장애/운영 인사이트

• 중복 실행의 진짜 비용: 재처리·데이터 이중 반영·다운스트림 폭발 → CronJob 겹침 방지가 가장 빠른 보험.
• 스케줄 유실의 진짜 원인: 컨트롤플레인 이벤트 로스·스케줄 지연 → startingDeadlineSeconds로 회복 탄력 확보.
• 배치 실패의 분류 필요성: OOM/스케줄 불가/일시적 디스크압박 등 원인별 대응이 달라짐 → podFailurePolicy로 즉시 Fail/무시/재시도 분기.
• 운영 쓰레기 누적: Job/CronJob은 기본적으로 잔해가 남음 → TTL/HistoryLimit로 SRE 위생 유지.

4) 종료코드의 해석과 앱 행동

• 0: 정상 완료(Completed).

• 143(=128+SIGTERM): 롤링/스케일다운/드레인 등 정상 시나리오에서 흔함.

  • 대응: 배포 이벤트가 있는 윈도우에선 알림 제외(노이즈 컷).

• 137(=128+SIGKILL): Grace 초과 또는 OOMKilled.

  • 대응: terminationGracePeriodSeconds 상향 + preStop 훅으로 우아한 종료, 또는 리소스 증설/메모리 튜닝.

• 앱 관점 가이드

  • SIGTERM 핸들러: 현재 작업 체크포인트/재큐 → Deployment 워커는 exit 0로 빠르게 교체; Job 워커는 미완료면 non-zero로 재시도 유도(단, 안전 재큐 시 0 허용).
  • 블로킹 호출: 타임아웃·주기적 TERM 체크 필수.

5) 관측성 최소 셋

• 라벨/추적키: jobId, commitSha, shardIndex(Indexed) → 문제 재현·영향도 파악 단축.

• 진행률/하트비트: 장시간 작업은 하트비트 파일/키 + 커맨드형 liveness로 “멈춤”을 신호화.

• 메트릭: 완료/실패/재시도 카운트, 실행시간 히스토그램(또는 로그 집계라도).

• 알림 룰:

  • 롤링 중 143은 정상으로 취급(윈도우 제한).
  • OOMKilled는 항상 경고/심각.

6) Redis로 직접 at-least-once 큐 만들 때의 본질

• 수신/확인 분리: BRPOPLPUSH queue → inprogress로 유실 방지(워커 크래시 시 inprogress 스캔).

• 하트비트: 처리 중 task:<id>.lastBeat 갱신 → Reaper CronJob이 타임아웃 항목을 원 큐로 복원.

• 종료 시맨틱:

  • Deployment 워커: 재큐 후 0(교체 신속).
  • Job 워커: 미완료면 non-zero로 컨트롤러 재시도.

7) GitOps에서 안전장치의 위치

• 폴더 = 네임스페이스 바인딩(하드코딩 금지, 파이프라인에서 주입).
• 공통 패치로 기본 가드 주입: ttlSecondsAfterFinished, backoffLimit, activeDeadlineSeconds(Kustomize/Helm).
• 드리프트 억제: kubectl diff / server-side apply / prune.
• HistoryLimit로 컨트롤러 히스토리 관리(관측성 + 청결 균형).

현업에서 가장 효과 큰 5가지

1. CronJob 겹침 방지 안 하면 데이터 이중처리 난리 난다.
2. startingDeadlineSeconds 없으면 스케줄 유실이 “조용히” 지나간다.
3. Job Indexed는 대규모 배치 추적/리트라이 단위의 사실상 표준.
4. TTL + HistoryLimit로 잡 잔해를 자동 청소하라.
5. 143은 정상, 137은 위험 신호—알림 룰을 분리하라.

• 블로그 글1

1인칭 슈팅을 만들거고 TPS 형식으로 만들어 볼 것.

그러기 위해선 마우스의 좌표를 받아서 회전하게끔 수정.

edit에서 회전을 담당할 Mouse X, Y를 설정

만약 Use Controller Rotation Pitch를 활성화하면 아래와 같이, 플레이어가 이상하게 회전한다.

일반적인 TPS게임이면 회전하는 것은 맞는데 위로 볼 때, 캐릭터가 저런식으로 회전하는 것이 아니라 카메라가 그 쪽을 주시하고, 조준하는 총만 위로 올리는 개념이여야 한다. 플레이어 자체가 움직이진 않는다.

그럼 다시 Pawn의 Use Controller Rotation Pitch를 비활성화하고,

Spring Arm을 보면 Pawn Control Rotation을 사용하겠다는 옵션이 있다.

활성화를 해주고, 그럼 플레이어 자체가 회전하는 것이 아니라, 카메라가 플레이어의 회전 값에 맞춰 회전하게 된다.

아래의 코드를 Player 안에다 입력 코드를 작성했는데, 틀린 방법은 아니다. 하지만 만약 플레이어의 코드량이 많아진다거나 아니면 특정 상황에 따라서 행동이 바뀌기를 원하면 플레이어에서 제어하기 보다는 플레이어의 입력을 케어하는 코드이기 때문에, Player Controller에다 넣는 것도 하나의 방법이다.

Player Controller로 이전한 코드

그리고, Jump를 구현해야 한다고 하면 다른 엔진의 경우는 물리공식을 이용하는 등 직접 구현해야 되겠지만, 이 Movement Component에 다양한 기능이 들어가 있다. 언리얼 엔진의 슈팅 게임에 맞춰져있는 엔진이라서 Jump라던지 기어가는 거라던지 기본적인 동작에 대한 함수가 미리 만들어져있다.

예시

-블로그 글 2

BP_PlayerController 생성

Blueprint Class - Player Controller - BP_PlayerController 생성

• BP_Player에 있던 액션맵핑 다 옮겨줌

Rookiss

• 정수의 원리

  얌얌코딩

• 변수, cout, debug 복습

  혼자 공부하는 C언어

• 다양한 파일 입출력 함수

정수란

• 정수는 소수점이 없는 수로, 양수, 음수, 0을 포함
• 컴퓨터는 정수를 2진수(Binary)로 변환하여 저장하고 처리
• ex) 10진수 5 → 2진수 00000101 (8비트 기준)

정수의 표현 방식

• 부호화 크기 방식
  • MSB(가장 왼쪽 비트)를 부호 비트로 사용
    • 0: 양수, 1: 음수
  • 나머지 비트는 크기 정보
  • +0과 -0이 중복 표현됨 → 비효율적, 실사용 거의 없음
• 1의 보수
  • 모든 비트를 반전시켜 음수 표현
    • 예: 5 → 00000101, 5 → 11111010
  • 여전히 +0, 0이 존재함 → 사용 잘 안 함
• 2의 보수
  • 현재 컴퓨터에서 표준으로 사용하는 음수 표현 방식
  • 방법:
    • 숫자의 이진수를 반전 (1의 보수)
    • 거기에 +1을 더함
  • 예:5 = 00000101반전 → 11111010+1 → 11111011 → 5
  • 장점:
    • +0, 0이 하나로 통합
    • 덧셈/뺄셈 연산 회로를 하나로 통합 가능 → 효율성 ↑

데이터 타입과 저장 범위

• signed: 부호 있음 → 음수 + 양수

• unsigned: 양수만 → 더 넓은 양의 값 표현 가능

• 타입 변환 시 손실 발생 가능 → 주의 필요

  • 예: int → short → 상위 비트 손실

    타입	크기(Byte)	Signed 범위	Unsigned 범위
    char	1	-128 ~ 127	0 ~ 255
    short	2	-32,768 ~ 32,767	0 ~ 65,535
    int	4	-2,147,483,648 ~ 2,147,483,647	0 ~ 4,294,967,295
    long long	8	-9경 ~ 9경 (±9,223,372조)	0 ~ 18,446경

진법과 변환

• 2진수 16진수는 4비트 단위로 나뉘어져 있어 매우 친화적

  • 2진수 4자리 = 16진수 1자리

    진법	설명	코드 표현
    2진수 (BIN)	컴퓨터 내부 기본 표현	0b1100
    10진수 (DEC)	사람이 일상 사용하는 표현	기본 숫자
    16진수 (HEX)	디버깅/주소 표현에 유용	0xF
    8진수 (OCT)	예전 시스템에서 사용	거의 사용 안 함

정수 연산

• 덧셈

| A | B | A+B | Carry |
| --- | --- | --- | --- |
| 0 | 0 | 0 | 0 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 (올림 발생) |
- 예: `5 + 3`
    - `5`: `00000101`
    - `3`: `00000011`
    - 결과: `00001000` → `8`

• 뺄셈
  • 뺄셈은 2의 보수 덧셈으로 처리
  • 예: 5 - 3 = 5 + (-3)
    • 3의 2의 보수: 11111101
    • 5 = 00000101
    • 결과 = 00000010 → 2
• 오버플로우
  • 표현 가능한 최대값을 초과
    • 예: 2147483647 + 1 → 2147483648
• 언더플로우
  • 표현 가능한 최소값보다 작음
    • 예: 2147483648 - 1 → 2147483647

메모리에 저장되는 방식

• 리틀 엔디안
  • 하위 바이트(LSB)부터 메모리에 저장
  • 예: 0x12345678 → 메모리: 78 56 34 12
  • 인텔 아키텍처에서 기본
• 빅 엔디안
  • 상위 바이트(MSB)부터 저장
  • 네트워크 통신 프로토콜에서 많이 사용

CODE

#include <iostream>
using namespace std;

// 정수의 원리
// 비트  0,1 데이터의 최소 단위
// 바이트
// 1 바이트 -> 8bit
// 컴퓨터는 전기 신호로 숫자를 만들어줌
// 최상위 비트는 -를 담당함
// 1바이트의 가장 큰 값을 01111111 : 127
// 11111111 = 1

// 복습
int hp;
// 데이터 범위
short mp;

// 진법
// 0,1,2,3,4,5,6,7,8,9 -> 10 (1과 0으로 표현) 조합하면서 무한대 숫자를 만들 수 있음\
// 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F 16 진법
// why? 16 진법
// 2진법과 궁합이 잘맞음
// 

int main()
{
    hp = 0xFF/*306189112*/;

    mp = /*(short)*/hp;    // 값을 꺼내옴 // 다른 숫자가 나옴 범위 밖의 숫자가 날아감
                    // 형변환이 필요함            
    cout << hp;

    return 0;
}

문제 1

• 1주 동안 운동 횟수를 입력 받고
• 칭찬 메시지 출력

입력 예시

5

출력 예시

멋지군요!! 칭찬합니다

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    if (a)
    {
        cout << "멋지군요!! 칭찬합니다" << endl;
    }

    return 0;
}

문제 2

• 숫자 하나를 입력 받음
• 입력 받은 숫자를 그대로 출력
• 뒤에 입력하셨군요 라는 글씨 출력

입력 예시

3

출력 예시

3 입력하셨군요

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    cout << a << " 입력하셨군요" << endl;

    return 0;
}

문제 3

• 숫자를 하나 입력 받음
• 숫자를 세번 출력
• cin과 cout만 이용

입력 예시

3

출력 예시

3 3 3

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    cout << a << " " << a << " " << a << endl;

    return 0;
}

문제 4

• 숫자 3개를 변수 a,b,c이 입력 받음
• a 3번 출력, b 3번 출력, c 3번 출력

입력 예시

3 5 9

출력 예시

333
555
999

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b, c;
    cin >> a >> b >> c;

    cout << a << "" << a << "" << a << endl;
    cout << b << "" << b << "" << b << endl;
    cout << c << "" << c << "" << c << endl;

    return 0;
}

문제 5

• 숫자 2개 입력 받음
• 앞 숫자 - 뒷 숫자의 차를 구해서 출력

입력 예시

30 10

출력 예시

두 숫자의 차는 20 입니다.

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    cout << "두 숫자의 차는 " << a - b << " 입니다." << endl;

    return 0;
}

문제 6

• 숫자 두개 입력 받고 덧셈, 곱셈, 나눗셈 출력

입력 예시

5 2

출력 예시

5 + 2 = 7
5 * 2 = 10
5 / 2 = 2

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    cout << a << "+" << b << "=" <<a + b << endl;
    cout << a << "*" << b << "=" <<a * b << endl;
    cout << a << "/" << b << "=" <<a / b << endl;

    return 0;
}

문제 7

• 변수 a,b에 숫자를 입력 받음
• 변수 a가 b보다 크면 a가 b보다 크다
• 그렇지 않으면 b가 a보다 같거나 크다를 출력

입력 예시

4 3

출력 예시

a가 b보다 크다

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    if (a > b)
    {
        cout << "a가 b보다 크다" << endl;
    }
    else
    {
        cout << "b가 a보다 같거나 크다" << endl;

    }

    return 0;
}

문제 8

• 숫자 2개를 입력
• 둘 중 큰 수를 4번 출력

입력 예시

3 5

출력 예시

5555

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    if (a > b)
    {
        cout << a << a << a << a << endl;
    }
    else if(b > a)
    {
        cout << b << b << b << b << endl;

    }
    else
    {

    }

    return 0;
}

문제 9

• 숫자 1개를 변수 a에 입력 받음
• 5를 입력함
• a++을 수행하면 6이 됨

입력 예시

5

출력 예시

5를 입력함
a++을 수행하면 6이 됩니다

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    cout << a << " 를 입력함" << endl;
    a++;
    cout << "a++을 수행하면 " << a << "이 됩니다" << endl;

    return 0;
}

문제 10

• 숫자 1개를 변수 input에 입력
• 숫자가 3보다 크면 1을 더하고 출력
• 그렇지 않으면 1을 빼고 출력

입력 예시

5

출력 예시

6

풀이

#include <iostream>
using namespace std;

int main()
{

    int input;
    cin >> input;

    if (input > 3)
    {
        input++;
        cout << input << endl;
    }
    else if (input <= 3)
    {
        input--;
        cout << input << endl;
    }

    return 0;
}

문제 11

• 숫자 1개를 변수 num에 입력
• 숫자가 양수라면

###
###
###

• 숫자가 음수라면

$$$
$$$
$$$

• 숫자가 0이면 출력하지 않음

입력 예시

3

출력 예시

###
###
###

풀이

#include <iostream>
using namespace std;

int main()
{

    int num;
    cin >> num;

    if (num > 0)
    {
        cout << "###" << endl;
        cout << "###" << endl;
        cout << "###" << endl;
    }
    else if (num < 0)
    {
        cout << "$$$" << endl;
        cout << "$$$" << endl;
        cout << "$$$" << endl;
    }
    else
    {

    }

    return 0;
}

문제 12

• 숫자 3개 입력
• 세 수의 합이 세 수의 곱보다 같거나 행운의 수 출력
• 아니면 소소한 수

입력 예시

1 2 3

출력 예시

행운의 수

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b, c;
    cin >> a >> b >> c;

    if ((a + b + c) >= (a * b * c))
    {
        cout << "행운의 수" << endl;
    }
    else
    {
        cout << "소소한 수" << endl;
    }

    return 0;
}

1-1. [Quiz] 함수의 주된 사용 목적은 무엇일까요?

① 코드 실행 속도 향상

② 변수 선언 없이 사용

③ 코드 재사용성 및 관리 용이성 증대

④ 컴파일 오류 방지

1-2. [Quiz] 함수의 반환 타입이나 매개변수 목록에 'void' 키워드를 사용하는 것은 무엇을 의미할까요?

① 매개변수나 반환값이 임시 메모리에 저장된다

② 함수가 아무런 매개변수를 받지 않거나, 아무런 값을 반환하지 않는다

③ 함수가 전역 변수만 사용한다

④ 함수 실행 중 오류가 발생할 수 있다

1-3. [Quiz] 함수 내에서 선언된 지역 변수는 프로그램 실행 중 주로 메모리의 어느 영역에 할당될까요?

① 힙 (Heap)

② 코드 섹션 (Code section)

③ 스택 (Stack)

④ 데이터 섹션 (Data section)

1-4. 함수 선언(Declaration)과 정의(Definition)의 차이로 옳은 것은?

① 선언은 .cpp에, 정의는 .h에 작성한다

② 선언은 실제 구현을 포함하고, 정의는 시그니처만 가진다

③ 선언은 시그니처만(세미콜론으로 끝), 정의는 실제 구현({} 안에 코드)

④ 선언 없이 정의만 있으면 컴파일이 더 빠르다

1-5. 함수 오버로딩이 성립하는 조건으로 옳은 것은?

① 함수 이름만 같으면 된다

② 매개변수 개수나 타입이 달라야 한다

③ 반환 타입만 다르면 된다

④ 같은 .cpp 파일에 있어야 한다

1-6. C++에서 함수 호출 전에 선언이 먼저 있어야 하는 이유는?

① 실행 속도를 높이기 위해

② C++는 위에서 아래로 분석하므로, 호출 시점에 해당 함수의 존재를 알아야 함

③ 메모리 절약을 위해

④ 링커가 연결하기 위해

1-7. 전역 변수와 지역 변수의 차이로 옳은 것은?

① 전역 변수는 스택에, 지역 변수는 Data 영역에 저장된다

② 전역 변수는 Data 영역·프로그램 전체 유효, 지역 변수는 스택·함수 내 유효

③ 지역 변수는 함수 종료 후에도 값이 유지된다

④ 전역 변수를 사용하는 것이 항상 권장된다

Part 2. 객관식 (Step 2~3: 스택, 스택 프레임)

2-1. 스택 메모리의 특징으로 옳은 것은?

① FIFO(선입선출) 구조이다

② LIFO(후입선출) 구조이며, 가장 나중에 호출된 함수가 먼저 종료된다

③ 프로그램 종료 시까지 데이터가 유지된다

④ 힙보다 크기가 크다

2-2. 스택 오버플로우가 발생하는 주된 원인은?

① 전역 변수를 너무 많이 사용할 때

② 재귀 함수의 종료 조건 누락 등으로 스택 프레임이 무한히 쌓일 때

③ 지역 변수를 선언할 때

④ #include를 많이 할 때

2-3. 스택 프레임에 포함되지 않는 것은?

① 매개변수

② 반환 주소

③ 지역 변수

④ 전역 변수

2-4. 다음 코드의 출력 결과는?

void AddHp(int hp, int value) { hp += value; }
int main() {
    int hp = 100;
    AddHp(hp, 20);
    cout << hp << endl;
}

① 120

② 100

③ 20

④ 컴파일 에러

2-5. 다음 코드의 출력 결과는?

int Test(int& a) { a += 10; return a; }
int main() {
    int x = 5;
    Test(x);
    cout << x << endl;
}

① 5

② 15

③ 10

④ 컴파일 에러

2-6. 복사 전달(Call by Value)과 참조 전달(Call by Reference)의 차이로 옳은 것은?

① 복사 전달은 원본을 수정할 수 있고, 참조 전달은 불가능하다

② 복사 전달은 값만 복사되어 원본 영향 없음, 참조 전달은 원본 직접 수정 가능

③ 참조 전달은 int a 형태로 받는다

④ 복사 전달이 항상 더 빠르다

Part 3. 객관식 (Step 4: 디버깅)

3-1. [Quiz] 디버깅 시 '중단점(Breakpoint)'을 설정하는 주된 목적은 무엇일까요?

① 프로그램의 전체 실행 시간을 측정하기 위해

② 특정 코드 줄에서 프로그램 실행을 일시 중지시키기 위해

③ 코드의 문법 오류를 자동으로 수정하기 위해

④ 다른 함수를 호출하는 것을 방지하기 위해

3-2. Visual Studio에서 브레이크포인트를 설정/해제하는 단축키는?

① F5

② F9

③ F10

④ F11

3-3. F10(Step Over)과 F11(Step Into)의 차이로 옳은 것은?

① F10은 함수 내부로 진입하고, F11은 그렇지 않다

② F10은 현재 줄만 실행하고 함수 안으로 들어가지 않음, F11은 함수 내부로 진입

③ F10은 프로그램을 종료하고, F11은 재시작한다

④ 둘은 동일하다

3-4. 호출 스택(Call Stack) 창의 역할로 옳은 것은?

① 변수 값을 수정한다

② 현재까지 호출된 함수들의 순서를 추적한다

③ 컴파일 에러를 표시한다

④ 실행 속도를 측정한다

3-5. 조건부 브레이크포인트의 용도로 옳은 것은?

① 모든 줄에서 멈춘다

② 특정 조건(예: hp <= 0)이 만족될 때만 정지한다

③ 컴파일 시점에만 작동한다

④ 링킹 오류를 수정한다

3-6. 조사식(Watch) 창에서 할 수 있는 것은?

① 소스 코드를 수정한다

② 변수나 수식(hp + 200 등)을 등록해 실시간으로 값 추적

③ 브레이크포인트를 자동 설정한다

④ 실행 파일을 생성한다

Part 4. 객관식 (Step 5~6: TextRPG, 파일 분할)

4-1. [Quiz] C++에서 코드를 여러 파일로 분할할 때, 헤더 파일(.h 또는 .hpp)의 주된 역할은 무엇일까요?

① 함수의 실제 구현 내용을 담는다

② 전역 변수나 상수 값을 저장한다

③ 다른 파일에서 사용할 함수나 변수 등의 선언을 제공한다

④ 프로그램 실행에 필요한 라이브러리를 모두 포함시킨다

4-2. TextRPG의 게임 흐름 순서로 옳은 것은?

① main → EnterBattle → EnterField → SelectPlayer

② main → EnterField → EnterLobby → CreateRandomMonster

③ main → EnterLobby → SelectPlayer → EnterField → CreateRandomMonster → EnterBattle

④ main → CreateRandomMonster → EnterBattle → EnterLobby

4-3. extern int GTest;의 의미로 옳은 것은?

① GTest 메모리를 이 파일에서 정의한다

② GTest는 다른 파일에서 정의되어 있다고 선언한다

③ GTest를 반드시 사용해야 한다

④ GTest를 삭제한다

4-4. #pragma once의 역할은?

① 컴파일 속도를 높인다

② 헤더 파일이 중복으로 포함되지 않도록 한다

③ extern을 대체한다

④ 링킹을 수행한다

4-5. 컴파일·링킹 흐름 순서로 옳은 것은?

① 링킹 → 전처리 → 컴파일 → 어셈블

② 전처리 → 컴파일 → 어셈블 → 링킹

③ 컴파일 → 링킹 → 전처리 → 어셈블

④ 어셈블 → 링킹 → 컴파일 → 전처리

4-6. 'LNK: 확인할 수 없는 외부 기호' 에러의 원인은?

① #include 누락

② 선언만 있고 정의(구현)가 없음

③ #pragma once 누락

④ 매개변수 타입 불일치

1-1. CPU에 대한 설명으로 옳은 것은?

① CPU는 데이터를 영구적으로 저장할 수 있다.

② CPU는 연산 속도가 느리지만 기억력이 좋다.

③ CPU는 연산을 담당하며, 기억력이 짧아 RAM을 활용한다.

④ CPU 쿨러는 전원 공급을 담당한다.

1-2. RAM의 4가지 영역 중 '함수 호출 정보'가 저장되는 영역은?

① Code (Text)

② Data

③ Heap

④ Stack

1-3. SSD/HDD에 대한 설명으로 옳지 않은 것은?

① 전원이 꺼져도 데이터가 유지된다.

② SSD는 RAM보다 접근 속도가 빠르다.

③ 게임 설치 파일은 SSD에 저장된다.

④ 프로그램 실행 시 SSD에서 RAM으로 복사(로드)된다.

1-4. 컴파일에 대한 설명으로 옳은 것은?

① 컴파일은 프로그래밍 언어 코드를 기계어로 번역하는 과정이다.

② 컴파일러 없이도 CPU가 직접 C++ 코드를 이해할 수 있다.

③ 세미콜론을 생략해도 컴파일이 성공한다.

④ 컴파일과 빌드는 서로 다른 과정이다.

1-5. 프로그램의 핵심 요소가 아닌 것은?

① 데이터

② 로직

③ CPU

④ (없음 - ①②가 핵심)

1-6. [Quiz] 컴퓨터의 핵심 부품인 CPU와 RAM의 주된 역할 관계는 무엇인가?

① CPU는 데이터를 저장하고, RAM은 복잡한 계산을 처리한다.

② CPU는 명령을 계산/실행하고, RAM은 데이터를 일시적으로 저장한다.

③ CPU는 프로그램을 영구 저장하고, RAM은 전원을 공급한다.

④ CPU는 화면에 결과만 출력하고, RAM은 모든 입력을 관리한다.

Part 2. 객관식 (Step 4~9: 변수, 타입, main, maxHp)

2-1. 변수 사용 3단계가 아닌 것은?

① 할당 (공간 확보)

② 쓰기 (값 넣기)

③ 읽기 (값 꺼내기)

④ 삭제 (메모리 해제)

2-2. hp = 50;에서 =의 의미로 옳은 것은?

① 양쪽이 같다.

② 오른쪽 값을 왼쪽 변수에 대입한다.

③ 50을 비교한다.

④ hp와 50을 교환한다.

2-3. int 타입의 바이트 크기는?

① 1

② 2

③ 4

④ 8

2-4. 전역 변수에 대한 설명으로 옳은 것은?

① main() 안에 선언한다.

② Stack 영역에 할당된다.

③ main() 밖에 선언하며 Data 영역에 할당된다.

④ 함수 내부에서만 사용 가능하다.

2-5. maxHp를 사용해 HP를 복구할 때 올바른 코드는?

① hp = 100;

② hp = maxHp;

③ maxHp = hp;

④ hp == maxHp;

2-6. [Quiz] 프로그래밍에서 '변수(Variable)'를 사용하는 가장 중요한 이유는 무엇인가?

① 코드의 줄 수를 줄여서 프로그램을 짧게 만들려고

② 메모리 공간에 이름을 붙여 데이터를 편리하게 저장하고 사용하려고

③ 프로그램 실행 속도를 무조건 빠르게 만들려고

④ 컴퓨터의 운영체제를 설치하기 위해

Part 3. 객관식 (Step 10~11: 정수·비트, 데이터 타입)

3-1. 1바이트는 몇 비트인가?

① 4

② 8

③ 16

④ 32

3-2. 2의 보수로 -43을 구하는 방법은? (43이 주어졌을 때)

① 비트 반전

② 비트 반전 후 +1

③ -1 후 비트 반전

④ 그대로 - 부호 붙이기

3-3. 0xFF의 10진수 값은?

① 15

② 16

③ 255

④ 256

3-4. char 타입으로 'A'의 ASCII 값을 출력하려면?

① cout << ch;

② cout << (int)ch;

③ cout << int(ch);

④ ②, ③ 모두 가능

3-5. float 리터럴을 사용할 때 필요한 접미사는?

① L

② f

③ d

④ u

3-6. [Quiz] 정수형 변수(char, short, int, long long)의 크기가 1바이트, 2바이트 등으로 다른 주된 이유와 결과는 무엇인가?

① 크기가 클수록 변수의 이름을 더 길게 지을 수 있다.

② 크기에 따라 사용할 수 있는 연산자의 종류가 달라진다.

③ 크기가 클수록 더 넓은 범위의 정수를 표현하고 저장할 수 있다.

④ 크기가 작을수록 음수는 저장할 수 없게 된다.

Part 4. 객관식 (Step 12~13: 연산자, 비교·논리)

4-1. 10 % 3의 결과는?

① 0

② 1

③ 3

④ 3.333

4-2. a = hp++; 실행 후, a에 들어가는 값은?

① hp 증가 후의 값

② hp 증가 전의 값

③ 0

④ 정의되지 않음

4-3. 8 << 1의 결과는?

① 4

② 8

③ 16

④ 64

4-4. &&와 ||의 우선순위 중 더 높은 것은?

① ||

② &&

③ 같음

④ 상황에 따라 다름

4-5. 100 * (2 + 5) / 2의 결과는?

① 350

② 202

③ 3500

④ 45

4-6. [Quiz] 두 개 이상의 조건이 '모두 참(True)'이어야만 결과가 참이 되는 논리 연산자는 무엇인가?

① NOT 연산자 (!)

② AND 연산자 (&&)

③ OR 연산자 (||)

④ XOR 연산자 (^)

Part 5. 객관식 (Step 14~16: 조건문, 반복문)

5-1. switch-case에서 break를 생략하면?

① 컴파일 에러

② fall-through (다음 case까지 실행)

③ 해당 case만 실행

④ 무한 루프

5-2. for (int i = 0; i < 5; i++)에서 반복 횟수는?

① 4회

② 5회

③ 6회

④ 무한

5-3. continue의 역할은?

① 반복문을 즉시 종료

② 현재 반복 건너뛰고 다음 반복으로

③ break와 동일

④ 조건식을 건너뜀

5-4. switch-case와 if-else if를 선택할 때, switch-case가 적합한 경우는?

① 범위 비교 (예: hp <= 30)

② 정수 값 하나로 분기

③ 복잡한 논리식

④ 문자열 비교

5-5. rand() % 3의 결과 범위는?

① 0 ~ 2

② 1 ~ 3

③ 0 ~ 3

④ 0 ~ 대략 3만

5-6. [Quiz] 프로그램이 실행될 때, 특정 조건에 따라 코드의 실행 경로를 여러 갈래로 '나누어' 처리하게 만드는 문법 구조를 무엇이라고 하는가?

① 반복문 (Loop)

② 산술 연산 (Arithmetic Operation)

③ 분기문 (Branching Statement)

④ 변수 선언 (Variable Declaration)

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

  문제 13

• 풀이

  문제 14

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이