# conda 전체 환경 → environment.yml
conda env export -n myenv > myenv_environment.yml

# pip 패키지만 → requirements.txt
conda run -n myenv pip list --format=freeze > myenv_requirements.txt

기존 환경 가져오기 (import)

# environment.yml로 conda 환경 생성
conda env create -f myenv_environment.yml

# 이미 만든 환경에 pip 패키지만 설치할 때
conda activate myenv
pip install -r myenv_requirements.txt

같은 계산을 중간 결과를 저장해 두고, 같은 계산을 반복하지 않는다.

머신러닝 실험에서는 다음 항목에서 사용될 수 있고, 이런것들이 매번 반복되면 매우 비효율적이다.

• 데이터 로딩
• 임베딩 계산
• cross-validation 결과
• hyperparameter 평가 결과

중요성

다음의 문제 상황에 cache를 적용 해 볼 수 있다.

cache 없는 경우:

• 파라미터 하나 바꿀 때마다
• 임베딩 다시 계산
• retrieval 다시 수행
• Cross Validation 다시 수행

이로 인해서, 실험 하나 돌리는 데 몇 시간~며칠이 소요된다.

또한,

• 실험 재현 어려움
• 튜닝/ablation 불가능

cache의 기본 철학

“변하지 않는 것은 무조건 저장하고 재사용한다.” 일반적으로:

• 하이퍼파라미터에 따라 바뀌는 것 → cache ❌
• 데이터/모델/설정이 같으면 결과 동일 → cache ⭕

Cache 적용

(1) 데이터 split

• train / val / test 인덱스
• Stratified CV fold 인덱스

  splits/
  ├── train_idx.npy
  ├── val_idx.npy
  └── cv_folds.pkl

(2) 전처리 결과

• 토큰화 결과
• 정규화된 feature
• 필터링된 데이터

(3) 임베딩 / 특징 벡터 (가장 중요)

• encoder가 같으면 항상 동일
• 계산 비용 큼

  embeddings/
  ├── encoderA.npy
  ├── encoderB.npy

  (4) hyperparameter 실험 결과

• 각 설정 → validation score
• grid / random search 결과

tuning_results.csv

Cache 설계 핵심 패턴

• Key = “결과에 영향을 주는 설정” 이기 때문에, Cache 파일 이름이나 key에는 반드시 포함하고, 이름만으로 뭘로 만든 건지 알 수 있어야 함
• dataset : 이름
• split : seed
• encoder: 이름
• 주요 : hyperparameter

예:

cache/
 ├── embed_pubhealth_encoder=bge_base.npy
 ├── retr_pubhealth_encoder=bge_base_top100.pkl

가장 단순한 cache 코드 패턴

이 패턴으로 실험 속도 체감이 완전 달라진 것을 알 수 있음

import os
import pickle

def load_or_compute(path, compute_fn):
    if os.path.exists(path):
        with open(path, "rb") as f:
            return pickle.load(f)
    else:
        result = compute_fn()
        with open(path, "wb") as f:
            pickle.dump(result, f)
        return result


#사용 예:

embeddings = load_or_compute(
    "cache/embeddings_encoderA.pkl",
    lambda: compute_embeddings(data, encoderA)
)

Hyperparameter Tuning + Cache 조합

튜닝할 때는: 중간 결과를 cache, 점수 계산만 반복 튜닝 비용이 N배 → 1배 + α

예:

• 임베딩: cache
• retrieval: cache
• scoring만 반복

  embedding (1회)
  → retrieval (1회)
  → scoring (N회)

Cache vs 재현성

(논문 관점)

Cache를 잘 쓰면:

• 동일 실험 완전 재현 가능
• seed 고정 가능
• 실험 로그 명확

주의사항 ⚠️

하면 안되는 것

• 설정을 바꾸었는데 cache 재사용
• 파일 이름에 seed/encoder 안 넣음
• cache 무효화 기준 없음

해결 방안:

• 설정 hash 사용
• config 기반 key 생성

Stratified(계층화)는 데이터 클래스 비율은 그대로 유지하면서 데이터를 나누는 방법이다. 보통, train / validation / test 분할이나 cross-validation에서 사용한다.

중요성

문제 상황

전체 데이터 100개이면서, 클래스 분포가 아래와 같다면,

• Class A: 90개
• Class B: 10개

이걸 random split으로 아무생각 없이 분할하면, train에는 B가 거의 없고 validation에는 B가 아예 없을 수도 있다.

그래서,

• 모델이 B를 전혀 못 배우거나,
• 평가 결과가 완전히 왜곡된다 !

핵심 아이디어

Strified는 각 분할(train/val/test)에서 클래스 비율을 전체 데이터와 최대한 동일하게 유지하자는 것이 메인 아이디어 이다.

특히 불균형 데이터에서 필수적으로 적용이 필요하다 !

위의 예시에 그대로 적용한다면, 데이터 split은 각각 다음과 같이 적용되어야 한다.

• train: A 90%, B 10%
• validation: A 90%, B 10%
• test: A 90%, B 10%

Stratified를 쓰나?

• 분류 문제(classification)
• 클래스 불균형이 있는 데이터
• 성능 비교가 중요한 실험 (논문, 벤치마크)
• ❗ 회귀(regression)에는 타깃이 연속값이기때문에 stratify 기준이 애매해져 보통은 사용하지 않음

코드 예제

①: Stratified Train/Test Split

scikit-learn
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    stratify=y,      # 핵심
    random_state=42
)

stratify=y로 설정하여, train/test 모두에서 y의 클래스 비율을 유지할 수 있다.

②: Stratified K-Fold (교차검증)

각 fold마다 클래스 비율 동일하게 설정할 수 있다.

from sklearn.model_selection import StratifiedKFold

skf = StratifiedKFold(
    n_splits=5,
    shuffle=True,
    random_state=42
)

for train_idx, val_idx in skf.split(X, y):
    X_train, X_val = X[train_idx], X[val_idx]
    y_train, y_val = y[train_idx], y[val_idx]

Grid Search + Stratified (실전 활용)

분류 문제에서 하이퍼파라미터 튜닝을 수행할 때는 Stratified CV(cross validation)가 각 검증 분할에서 클래스 비율을 유지하기 위해 표준처럼 사용된다.

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression

grid = GridSearchCV(
    LogisticRegression(),
    param_grid={"C": [0.1, 1.0, 10.0]},
    cv=StratifiedKFold(n_splits=5),
    scoring="accuracy"
)

grid.fit(X_train, y_train)

앞서 말했듯이, 모델의 성능은 하이퍼파라미터(hyperparameters)에 따라서 크게 달라진다. 머신러닝과 딥러닝에서 가장 대표적인 튜닝방법들을 소개한다.

Hyperparameter 운영 원칙

• 튜닝은 train/validation dataset 에서만 수행
• test set은 최종 평가에만 사용
• 탐색 범위와 방법을 명확히 기록
• 과도한 튜닝은 과적합으로 보일 수 있음

1. Grid Search (격자 탐색)

• 미리 정의한 하이퍼파라미터 후보 값들의 모든 조합을 전부 실험하는 방식.
• 가장 단순하고 확실한 방법

예시

learning rate ∈ {0.001, 0.01, 0.1} batch size ∈ {16, 32} → 총 3 × 2 = 6가지 조합

장점

구현이 단순하고 직관적 재현성이 높음 논문에서 가장 많이 사용됨

단점

파라미터 수가 많아질수록 계산 비용 급증 불필요한 조합까지 모두 실험

언제 사용?

파라미터 수가 적을 때 (1~3개) 탐색 범위가 작을 때

2. Random Search (무작위 탐색)

정의된 범위 내에서 무작위로 하이퍼파라미터 조합을 샘플링해 평가. Grid search의 효율적인 대안.

특징

Grid Search보다 효율적인 경우가 많음 제한된 횟수만 실험 가능

장점

고차원 파라미터 공간에서 효율적 계산 예산을 직접 제어 가능

단점

최적 조합을 보장하지 않음 결과 변동성 존재

언제 사용?

파라미터가 많을 때 계산 자원이 제한적일 때

3. Sequential / Heuristic Tuning

한 번에 하나의 파라미터만 조정하며 점진적으로 좋은 값을 찾음. 현실적으로 가장 많이 사용됨

예시

learning rate 고정 → batch size 탐색 batch size 고정 → dropout 탐색

장점

구현과 해석이 매우 쉬움 실무와 논문에서 가장 흔히 사용됨

단점

전역 최적해를 놓칠 수 있음 파라미터 간 상호작용 고려 어려움

언제 사용?

빠른 실험이 필요할 때 탐색 공간이 비교적 명확할 때

4. Bayesian Optimization

이전 실험 결과를 바탕으로 다음에 시도할 파라미터를 확률적으로 선택함. 고급·고비용 상황용

대표 기법

Gaussian Process Tree-structured Parzen Estimator (TPE)

장점

실험 횟수 대비 효율적 고비용 모델에 적합

단점

구현 복잡 작은 문제에는 과한 경우도 있음

언제 사용?

실험 비용이 매우 클 때 파라미터 공간이 넓을 때

5. Hyperband / Early Stopping 기반 탐색

성능이 낮은 설정은 조기에 중단하고, 유망한 설정에만 자원을 집중하는 방식.

장점

계산 자원 절약 대규모 실험에 적합

단점

구현 및 설정 복잡 결과 해석이 어려울 수 있음

머신러닝 모델을 학습 할 때, 여러 값들을 설정한다. 이 설정값들은 파라미터와 하이퍼파라미터 두 종류로 나눌 수 있다.

• 하이퍼파라미터(hyperparameter) : 사람이 미리 정해주는 값
• 파라미터(parameter) : 학습을 통해 자동으로 배우는 값

Parameter vs Hyperparameter

파라미터(parameter)

• 모델이 데이터로부터 직접 학습하는 값
• 학습 과정에서 자동으로 업데이트됨

  학습 결과물

  예시

• 선형 회귀의 가중치(weight)
• 신경망의 가중치와 편향
• 임베딩 벡터 값

하이퍼파라미터 (hyperparameter)

• 학습 이전에 사람이 설정하는 값
• 학습 과정에서 자동으로 바뀌지 않음
• 모델이 어떻게 학습할지를 결정

  학습 규칙

  예시

• 학습 관련
  • learning rate
  • batch size
  • optimizer 종류 (SGD, Adam 등)
  • epoch 수
• 모델 구조 관련
  • 레이어 수
  • 히든 유닛 수
  • dropout 비율
• 선택 / 추론 관련
  • threshold
  • temperature

하이퍼파라미터의 중요성

같은 모델과 데이터를 사용해도, 하이퍼파라미터에 따라 결과가 완전히 달라지기 때문이다.

예를 들어:

• learning rate가 너무 크면 → 발산
• 너무 작으면 → 학습이 매우 느림
• batch size가 크면 → 안정적이지만 일반화가 떨어질 수 있음

  하이퍼파라미터는 모델의 성능, 안정성, 학습 속도에 영향을 준다.

하이퍼파라미터를 정하는 방법

하이퍼파라미터는 모델을 학습할 때 자동으로 결정되지 않아서, 다음 방법들을 사용해 hyperparameter tuning 과정을 거친다.

• 경험 기반 설정
• Grid Search
• Random Search
• Bayesian Optimization

전체 파이프라인을 고정하고, 제안하는 요소를 하나씩 제거하거나 단순화하여 성능 변화를 확인

방법

공통 규칙$^★$

1. 한 번에 한 가지만 바꾸기 (나머지 고정)
2. Full 모델이 항상 포함돼야 한다
3. 성능뿐 아니라 비용(시간/메모리)도 같이 분석하여 설득력 증가

1) 구성요소 제거 ablation (leave-one-out)

각 요소가 “필수인지” 보여주는 정석적인 방법 만약 제안 방법이 A+B+C 라면:

• Full: A+B+C
• w/o A: B+C
• w/o B: A+C
• w/o C: A+B

2) 단계별 단순화 ablation (progressive build-up)

특정 부분을 더하여 +x%, 그 다음은 +y%”가 되어, 기여가 명확히 보여줌. 기본 → 점차적으로 추가하여 쌓는방식:

• Base: 기존 baseline
• Base + A
• Base + A + B
• Base + A + B + C (Full)

3) 대체(교체) ablation

“왜 이 설계가 좋은지”를 보여줄 수 있음 제안하는 모듈의 선택지를 교체:

• scoring 함수: cosine / dot / learned / heuristic로 교체
• tie-break 규칙: on/off로 교체

4) 하이퍼파라미터 민감도(sensitivity)

“우리 방법 튜닝에 과하게 의존하지 않음”을 보여줌 모델이 특정 값에만 의존하는지 확인:

• alpha, beta, tempertature, threshold, weight 등
• 보통 각 파라미터 후보는 2~5개 정도로 바꾸어보고, 한 그래프 내에서 표현

5) 데이터/상황별 ablation (slice analysis)

해석성이 높아져 논문의 완성도가 높아짐. 전체 평균만 분석한 것이 아니라, “어느 부분에서 좋아지는지” 알 수 있음:

• input 길이: short, medium, long
• input/case 난이도, 카테고리
• model 종류별
• noisy 포함 여부

설계 및 구현

보통 “처음 설계할 때부터 ablation을 염두하고 모듈화”하고, 구현은 “full pipeline에 옵션으로 끄고 켜는(on/off) 방식”으로, 개별적인 것이 아니라 설계 + 구현을 함께 하는 구조

이상적인 방법 (대부분)

설계

• 파이프라인을 모듈 단위로 쪼갬

  • Query
  • Retrieval
  • Encoder
  • Reranking
  • Selection

• 각 모듈은 독립적으로 교체할 수 있도록 인터페이스 고정

일반적인 구현 방식$^*$

full pipeline은 하나로 보며, flag / config로 분기함.

full_pipeline(
  use_encoder_ensemble = True,
  use_rerank = True,
  use_weighting = True
)

Ablation은:

• w/o rerank → use_rerank=False
• w/o ensemble → use_encoder_ensemble=False
• simple rerank → rerank_mode="cosine"

“full 코드 + 수정본 여러 개” (거의 ❌)

• 코드 중복
• 버그 위험
• 재현 불가
• reviewer 질문 대응 불가

해당 내용을 논문에 작성한다면,

“We disable component X while keeping the rest identical.”

이미 full pipeline이 있다면?

보통:

코드 “수정”보다는 “옵션 추가”.

1. full pipeline을 기준선으로 둠
2. 각 구성요소에 bypass 경로 추가
   • rerank skip
   • encoder single로 고정
3. scoring/selection 단계에서 대체 로직만 추가

구현 체크리스트 (일반적인 기준)

Ablation이 용이한 파이프라인:

• 각 단계가 함수/클래스로 분리돼 있음
• 입력/출력 형태가 고정돼 있음
• 내부 state 공유 없음
• scoring / selection이 분리돼 있음
• config 파일 or argparse로 제어 가능

논문 작성 문구

• 예시

All ablation studies are conducted by disabling or replacing individual components in the full pipeline, while keeping the rest of the system unchanged.

We implement ablation settings by selectively bypassing specific modules within the same implementation to ensure consistent experimental conditions.

비교 실험 기본 원칙 (Reviewer 시점)

비교 실험헤서 reviewer가 보는건 이 성능 차이가 정말 제안하는 방법덕분인가? 인지이다. 그래서 다른 부분들은 최대한 고정하고 비교하고 싶은 요소만 최소한으로 바꾸어 비교한다.

일반적인 방법

“부분 교체 방식” (가장 정석)

내가 파이프라인을 구현한 상태라면, 제안하는 방법에 기존(비교군) 방법을 넣어 해당 부분만 변경한다.

예시

RAG 파이프라인을 기준으로 삼는다면, RAG는 보통 query를 통해 retriever가 관련 있는 문서를 검색해온다. 이 후, 선택된 문서를 통해 정답을 생성한다. 이 과정에서 기존 query의 reformulation, 검색된 문서를 pooling, reranking방법 적용, reader(답변 생성) 등을 적용하여 더 나은 답변을 도출하도록 한다. 만약, reranking 부분만 교체하고 싶다면 아래에서 reranking 방법만 교체한다.

Query
 → Query
 → Retrieval (same retriever)
 → Reranking / Selection Method
 → Answer / Evaluation

이 구조에서:

• Query 동일
• Retriever (FAISS 동일)
  • encoder 교체
    • Baseline: Bert
    • Prior work A : RoBerta
    • Prior work B : T5
• Top-K 동일
• Reranking 동일
  • Ours: Ourproposed method

그러면 review는 encoder 만 교체했다고 알 수 있다.

전체 파이프라인 비교

전체 파이프라인을 고치는 것은 주의해야할 부분이다. 비교대상이 아래와 같은 시스템 레벨 논문이라면,

• “End-to-end RAG framework”
• “Joint retrieval + generation optimization”

각 논문에서 제안한 다음 사항등을 유지해야한다.

• 동일 세팅
• 동일 데이터셋
• 동일 metrics

그러나 이런 경우에는

• retriever가 달라서 그런 거 아닐지
• encoder 차이 여부

Related Work 문단 작성

작성한 Related work는 비교 실험으로 이어진다.

• 예시 문장 :

  Unlike prior approaches that rely on a single, fixed encoder for document ranking, our method considers multiple encoder representations during the document selection process.

주의할 점!

❌ 다른 사람의 논문 결과를 숫자 그대로 가져와서는 안된다. 왜냐하면, 아래와 같은 이슈로 reviewer에게 공격당할 수 있으며, “This is not comparable.” !

• dataset split 다름
• retriever 다름
• metric 정의 다름

❌ baseline을 약하게 잡기 비교할 수 있는 baseline을 잘 구성하여 넣는다 예를 들면, BM25사용이 당연한 것인데, 왜 비교군을 들어가지 않았는지 질문을 할 수 있다.

$$ f'(x) = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h} $$

함수 $f(x) = x^2$에 대해: $$ \frac{df}{dx} = 2x $$ $x=3$일 때: $$ \frac{df}{dx}\bigg|_{x=3} = 2 \cdot 3 = 6 $$

import torch

# 1변수 함수: f(x) = x^2
x = torch.tensor(3.0, requires_grad=True)
y = x ** 2

# 미분 계산
y.backward()
print(f"f(x) = x^2, x=3일 때")
print(f"df/dx = {x.grad}")  # 2*3 = 6

Partial derivative

다변수 함수 $f(x, y)$에서 $x$에 대한 편미분: $$ \frac{\partial f}{\partial x} = \lim_{h \to 0} \frac{f(x+h, y) - f(x, y)}{h} $$ $y$는 상수로 취급합니다.

함수 $f(x, y) = x^2 + 3xy + y^2$에 대해: $$ \frac{\partial f}{\partial x} = 2x + 3y $$ $$ \frac{\partial f}{\partial y} = 3x + 2y $$

$(x, y) = (2, 3)$일 때: $$ \frac{\partial f}{\partial x}\bigg|{(2,3)} = 2(2) + 3(3) = 13 $$ $$ \frac{\partial f}{\partial y}\bigg|{(2,3)} = 3(2) + 2(3) = 12 $$

# 2변수 함수: f(x, y) = x^2 + 3xy + y^2
x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(3.0, requires_grad=True)

z = x**2 + 3*x*y + y**2

# 편미분 계산
z.backward()

print(f"\nf(x,y) = x^2 + 3xy + y^2, x=2, y=3일 때")
print(f"∂f/∂x = {x.grad}")  # 2x + 3y = 2*2 + 3*3 = 13
print(f"∂f/∂y = {y.grad}")  # 3x + 2y = 3*2 + 2*3 = 12

Gradient

$n$변수 함수 $f(x_1, x_2, \ldots, x_n)$의 그래디언트는 모든 편미분을 벡터로 모은 것: $$ \nabla f = \begin{bmatrix} \frac{\partial f}{\partial x_1} \ \frac{\partial f}{\partial x_2} \ \vdots \ \frac{\partial f}{\partial x_n} \end{bmatrix} $$

그래디언트는 함수가 가장 빠르게 증가하는 방향을 나타냄

함수 $f(x_1, x_2, x_3) = x_1^2 + 2x_2^2 + 3x_3^2$에 대해: $$ \nabla f = \begin{bmatrix} \frac{\partial f}{\partial x_1} \ \frac{\partial f}{\partial x_2} \ \frac{\partial f}{\partial x_3} \end{bmatrix} = \begin{bmatrix} 2x_1 \ 4x_2 \ 6x_3 \end{bmatrix} $$

$(x_1, x_2, x_3) = (1, 2, 3)$일 때: $$ \nabla f\bigg|_{(1,2,3)} = \begin{bmatrix} 2(1) \ 4(2) \ 6(3) \end{bmatrix} = \begin{bmatrix} 2 \ 8 \ 18 \end{bmatrix} $$

# 다변수 함수의 그래디언트
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# f(x1, x2, x3) = x1^2 + 2*x2^2 + 3*x3^2
f = x[0]**2 + 2*x[1]**2 + 3*x[2]**2

f.backward()

print(f"\nf(x) = x1^2 + 2*x2^2 + 3*x3^2")
print(f"Gradient ∇f = {x.grad}")  # [2*x1, 4*x2, 6*x3] = [2, 8, 18]

Application

• requires_grad=True: 이 텐서에 대해 그래디언트를 계산하겠다는 표시
• .backward(): 자동 미분 수행
• .grad: 계산된 그래디언트 확인
• Gradient는 모든 편미분을 모은 벡터로, 함수가 가장 빠르게 증가하는 방향을 나타냄

import torch

# 신경망 파라미터 최적화 예제
# f(w, b) = (w*x - y)^2 (손실 함수)

w = torch.tensor(0.5, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)

# 데이터
x = torch.tensor(2.0)
y_true = torch.tensor(5.0)

# Forward pass
y_pred = w * x + b
loss = (y_pred - y_true) ** 2

# Backward pass (그래디언트 계산)
loss.backward()

print(f"\n최적화 예제:")
print(f"예측값: {y_pred.item()}")
print(f"손실: {loss.item()}")
print(f"∂L/∂w = {w.grad}")
print(f"∂L/∂b = {b.grad}")

# 그래디언트를 이용한 파라미터 업데이트
learning_rate = 0.01
with torch.no_grad():
    w -= learning_rate * w.grad
    b -= learning_rate * b.grad

print(f"업데이트된 w: {w.item()}")
print(f"업데이트된 b: {b.item()}")

PyTorch의 텐서(tensor) 연산을 위한 핵심 모듈

차원별 구조

(자료 : https://wikidocs.net/233963)

스칼라 (0차원 텐서)

• 단일 숫자 값

  import torch
  

scalar = torch.tensor(3.14) print(scalar.shape) # torch.Size([]) print(scalar.dim()) # 0

### Vector (1차원 텐서)
- 숫자들의 1차원 배열

```python
vector = torch.tensor([1, 2, 3, 4])
print(vector.shape)  # torch.Size([4])
print(vector.dim())  # 1

Matrix (2차원 텐서)

• 숫자들의 2차원 배열

matrix = torch.tensor([[1, 2, 3], [4, 5, 6]]) print(matrix.shape) # torch.Size([2, 3]) print(matrix.dim()) # 2

### Tensor (3차원 이상)
- 더 높은 차원의 배열
- 이미지, 비디오 데이터 등

```python
tensor_3d = torch.randn(2, 3, 4)  # (배치, 높이, 너비)
print(tensor_3d.shape)  # torch.Size([2, 3, 4])

주요 연산

Vector 연산

v1 = torch.tensor([1.0, 2.0, 3.0])
v2 = torch.tensor([4.0, 5.0, 6.0])

# 내적 (dot product)
dot = torch.dot(v1, v2)  # 1*4 + 2*5 + 3*6 = 32

# 원소별 곱셈
elementwise = v1 * v2  # [4, 10, 18]

Matrix 연산

A = torch.tensor([[1.0, 2.0],
                  [3.0, 4.0]])
B = torch.tensor([[5.0, 6.0],
                  [7.0, 8.0]])

# 행렬 곱셈
C = torch.mm(A, B)
# 또는 C = A @ B

# 전치 (transpose)
A_T = A.T

Applications

이러한 구조를 통해 딥러닝에서 효율적인 수치 계산과 자동 미분이 가능함

• Scala (0 dim) : 손실값(loss), 학습률(learning rate) 등
• Vector (1 dim) : 단일 데이터 샘플의 특징(feature), 편향(bias)
• matrix (2 dim) : 가중치(weights), 배치 데이터(batch)
• Tensor (3+ dim) : 이미지(height×width×channel), 배치 이미지(batch×height×width×channel)

• 가장 중요

  import random, numpy as np, torch
  

def set_seed(seed): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed)

torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

- 고정해야 하는 것:
  - weight init
  - data shuffle
  - client sampling
  - augmentation


# Dataset split 고정
- 매번 새로 생성 ❌
```python
random_split(dataset, [train, test])

generator = torch.Generator().manual_seed(seed)
random_split(dataset, [train, test], generator=generator)

• split 결과를 파일로 저장
• train.txt / test.txt 식으로 고정

DataLoader 설정

DataLoader(
    dataset,
    shuffle=True,
    worker_init_fn=seed_worker,
    generator=g
)

def seed_worker(worker_id):
    worker_seed = torch.initial_seed() % 2**32
    np.random.seed(worker_seed)
    random.seed(worker_seed)

• num_workers > 0 이면 꼭 필요함

CUDA deterministic 모드

torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

모델 초기화 방식 고정

• ❌

  model = Net()  # 내부에서 random init

• ⭕ seed 먼저 설정하면,

  set_seed(seed)
  model = Net()

환경 고정

• 예시 OS: Ubuntu 22.04 Python: 3.10 PyTorch: 2.1.0 CUDA: 12.1 GPU: RTX 3090

pip freeze > requirements.txt

코드 버전 고정

git commit -m "exp alpha=1 seed=44"

실험 로그로 저장

• config 저장

  {
  "seed": 44,
  "alpha": 1,
  "rounds": 1000
  }

• argparse dump

  json.dump(vars(args), f)

linux 서버 구축하고 사용하고 있었는데, GUI로는 너무 느려서 VS Code와 Cursor로 ssh remote 연결해서 사용하기로했다

기본적으로 사용 방법이 같아서, 동일하게 실행해서 editor만 본인이 원하는 대로 설정하면 된다!

Server 설정 (Ubuntu 24.04)

1. openssh-server 설치
2. ssh 서비스 실행
3. 계정 생성
4. SSH 키 등록(안해도 실행되긴 했음)
5. 방화벽에서 22번 허용

OpenSSH 설치 및 실행

sudo apt update
sudo apt install -y openssh-server

SSH 서비스 상태 확인

• 실행 상태 확인

  sudo systemctl status ssh

• disable(red color)로 되어 있으면, 아래 명령어 실행

sudo systemctl enable ssh
sudo systemctl start ssh
# sudo systemctl restart ssh

IP & Hostname 확인

ip a
# 또는
hostname -I

Server 계정(account) 확인

whoami
# 또는
cat /etc/passwd

• 필요하면 새로 추가

  sudo adduser yourname
  sudo usermod -aG sudo yourname

ufw 확인

sudo ufw allow ssh
sudo ufw allow 22/tcp
sudo ufw reload
# sudo systemctl restart ssh

• 만약에 포트가 안열려 있거나 하면 아래 내용 확인

  ss -ntl | grep :22

  LISTEN 0 128 0.0.0.0:22 # port가 열려 있는 경우

Client(Local) 설정

Server 연결상태 확인

• cmd 에서

  ping 192.168.205.69

VS Code 설정 (Cursor동일)

1. Extensions → Remote - SSH 검색해서 설치
2. F1 → Remote-SSH: Connect to Host 선택 후,
3. blank에 아래 내용 입력:

   server_account@192.168.0.IP 

4. 연결되면, password 입력
5. 나중에 연결 설정 수정할 때 nano ~/.ssh/config로 들어가서, 필요시 수정

   Host lab-server
    HostName {192.168.0.IP}
    User {server_account}
    IdentityFile ~/.ssh/id_ed25519

Encoder는 어떤 정보를 압축 하거나, 변형하여 특정 형태로 만들어 내는 것을 말함 ML에서는 다양한 Encoder가 있고, Bi-Encoder와 Cross-Encoder 가 있음

Bi-encoder

1단계:

• 질문과 문서를 각각 따로 인코딩 질문 → [0.2, 0.8, 0.1, ...] 벡터1 문서A → [0.3, 0.7, 0.2, ...] 벡터2 문서B → [0.9, 0.1, 0.5, ...] 벡터3 문서C → [0.25, 0.75, 0.15, ...] 벡터4

2단계:

• 인코딩(임베딩)한 내용을 기반으로 코사인 유사도 계산 질문 vs A = 0.85 질문 vs B = 0.32 질문 vs C = 0.78

결과

• A > C > B 순위
• 문서 A, B, C의 벡터를 미리 만들어 두고 새로운 질문만 인코딩 하여 비교 가능

Cross-encoder

1단계

• 질문과 답을 쌍(pair)으로 함께 입력 입력1: [CLS] 질문 A [SEP] 답변 A → 0.92점 입력2: [CLS] 질문 A [SEP] 답변 B → 0.05점 입력3: [CLS] 질문 A [SEP] 답변 C → 0.81점

결과

• A > C > B 순위 장점: "파이썬"과 "Python", "파일 읽기"와 "open() 함수" 등의 단어의 관계를 직접 비교하며 판단해서 더 정확함 단점: 매번 3번 인코딩해야 함. 문서가 100만개면 100만번 새로 인코딩하여 연산

BPE, WordPiece, Unigram(=SentencePiece Unigram) 세 가지 토크나이저를 같은 코퍼스, 같은 문장으로 비교

Python 예제

• BPE vs WordPiece vs Unigram 비교

from tokenizers import Tokenizer, models, trainers, pre_tokenizers

# --------------------------
# 1. 샘플 코퍼스 준비
# --------------------------
corpus = [
    "Machine learning is fascinating.",
    "Deep learning models improve with data.",
    "Large language models are powerful.",
    "Tokenization affects model performance."
]

# ==========================
# 2. BPE Tokenizer
# ==========================
bpe_tokenizer = Tokenizer(models.BPE())
bpe_tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()

bpe_trainer = trainers.BpeTrainer(
    vocab_size=60,
    special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]"]
)
bpe_tokenizer.train_from_iterator(corpus, bpe_trainer)

# ==========================
# 3. WordPiece Tokenizer
# ==========================
wp_tokenizer = Tokenizer(models.WordPiece(unk_token="[UNK]"))
wp_tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()

wp_trainer = trainers.WordPieceTrainer(
    vocab_size=60,
    special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]"]
)
wp_tokenizer.train_from_iterator(corpus, wp_trainer)

# ==========================
# 4. Unigram Tokenizer (SentencePiece Unigram)
# ==========================
uni_tokenizer = Tokenizer(models.Unigram())
uni_tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()

uni_trainer = trainers.UnigramTrainer(
    vocab_size=60,
    special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]"]
)
uni_tokenizer.train_from_iterator(corpus, uni_trainer)

# --------------------------
# 5. 비교 문장
# --------------------------
text = "Tokenization improves language models"

print("=== BPE ===")
print(bpe_tokenizer.encode(text).tokens)

print("\n=== WordPiece ===")
print(wp_tokenizer.encode(text).tokens)

print("\n=== Unigram ===")
print(uni_tokenizer.encode(text).tokens)

결과

=== BPE ===
['To', 'k', 'en', 'i', 'z', 'at', 'i', 'o', 'n', 'i', 'm', 'p', 'r', 'o', 'v', 'e', 's', 'l', 'an', 'g', 'u', 'age', 'models']

=== WordPiece ===
['T', '##o', '##k', '##e', '##n', '##i', '##z', '##at', '##i', '##o', '##n', 'i', '##m', '##p', '##r', '##o', '##v', '##e', '##s', 'l', '##a', '##n', '##g', '##u', '##a', '##g', '##e', 'model', '##s']

=== Unigram ===
['T', 'o', 'k', 'e', 'ni', 'z', 'ati', 'o', 'n', 'i', 'm', 'p', 'r', 'o', 'v', 'e', 's', 'l', 'a', 'ng', 'u', 'a', 'g', 'e', 'model', 's']

세 방식 비교표

핵심 비교 요약

Tokenization 비교

BPE

자주 등장하는 쌍을 계속 합쳐 나감

Token | ization | im | prove | s | language | models

WordPiece

접두사 ##로 “중간 조각” 표시

Token | ##ization | im | ##proves | language | models

Unigram

여러 후보 중 가장 확률 높은 조합을 선택

Token | ization | impro | ves | language | models

Tokenizer 결과 요약

1) BPE 결과

['To', 'k', 'en', 'i', 'z', 'at', ...]

✔ 자주 등장하는 문자 쌍만 병합됨 ✔ 코퍼스가 너무 작아서 대부분 문자 단위 토큰 ✔ 단어 내부에서 빈번한 조합만 조금씩 합쳐짐 → BPE의 본질: 통계적으로 자주 나오는 조합부터 합친다

2) WordPiece 결과

['T', '##o', '##k', '##e', '##n', ...]

✔ 대부분 문자 단위 ✔ WordPiece는 “OOV를 피하도록” 가장 작은 단위로 나누는 경향 ✔ 뒤에 붙은 ##는 이전 토큰의 연속(subword) → WordPiece의 본질: 안정적이고 규칙적인 분해, 항상 단어 시작/중간 구분 유지

3) Unigram 결과 의미

['T', 'o', 'k', 'e', 'ni', 'z', 'ati', ...]

✔ 확률 기반 선택 모델 → 가장 가능성이 높은 subword 선택 ✔ 그래서 문자 단위 + 2~3글자 subword가 섞여 있음 ✔ 다양한 분해 후보 중 “전체 문장의 우도를 최대로 만드는 조합” 선택 → Unigram의 본질: 확률적으로 가장 자연스러운 분해 선택 (가장 flexible)

요약

• BPE는 자주 나오는 조합을 합치고,
• WordPiece는 규칙적으로 글자를 잘게 나누고,
• Unigram은 확률적으로 가장 자연스러운 subword를 선택한다.

Text(input) : "인공지능은 정말 재미있어요!"

• max_length: 15글자
• tokens: 약 8-12개 (모델마다 상이)

K-fold 교차 검증은 모델의 일반화 성능을 신뢰성 있게 측정하는 중요한 표준 도구

머신러닝에서 데이터셋을 K개의 하위 집합(폴드)으로 나누어 반복적으로 학습과 평가를 수행하는 대표적인 검증 기법이다. 전체 데이터를 K개로 나눈 뒤, 각 폴드가 한 번씩 검증 세트로 사용되고 나머지 폴드는 학습 세트로 사용되어 총 K번의 학습-검증이 이루어짐

K-Fold 구조와 과정

• 주어진 전체 데이터가 K개로 고르게 분할
• 반복적으로, 한 폴드를 검증 세트로, 나머지 K-1개 폴드를 학습 세트로 사용
• 각 반복(iteration)마다 모델이 학습되고 평가
• 마지막에는 K번 평가 결과의 평균이 최종 모델의 성능 지표로 활용

주요 특징과 활용

• 데이터가 적거나 불균형한 경우에도 일반적인 검증보다 더 신뢰성 있게 모델 성능을 평가할 수 있음
• K 값은 데이터 크기와 상황에 따라 정하며, 일반적으로 5~10을 많이 사용
• 불균형 데이터셋에는 계층적 분할(Stratified K-Fold)을 적용해 폴드별 클래스 분포를 일정하게 할 수 있음

예시 코드 (Python, scikit-learn)

• 이 코드는 데이터를 5개 폴드로 섞어서 분할하고, 각 폴드마다 학습 및 평가를 반복

  from sklearn.model_selection import KFold
  

kf = KFold(n_splits=5, shuffle=True, random_state=42) for train_idx, test_idx in kf.split(X): X_train, X_test = X[train_idx], X[test_idx] y_train, y_test = y[train_idx], y[test_idx] # 모델 학습 및 평가

Macro, macro는 기본적으로 실제 대비 예측을 어떻게 헀는지 평가를 위한 지표들로,

• Macro는 라벨끼리 모아서 성능을 평가한 후, n개의 라벨이 얻은 예측값(T or P)를 계산 라벨별 메트릭(P, R, F1, A)을 평균 낸 것
• Micro는 라벨을 구분하지 않고 전체 예측한 값(T or P)를 모두 모아서 메트릭(P, R, F1, A)로 계산한 것
• Label-wise 평가는 라벨로만 예측한 값에 대해 메트릭(P, R, F1,A)를 계산한것

Micro Metrics (마이크로 메트릭)

• 정의: 모든 토큰을 하나로 합쳐서 계산
• 토큰 예시:

  문장: "John Smith lives in New York"
  토큰: ["John", "Smith", "lives", "in", "New", "York"]
  라벨: ["B-PERSON", "I-PERSON", "O", "O", "B-LOCATION", "I-LOCATION"]
  예측: ["B-PERSON", "I-PERSON", "O", "O", "B-LOCATION", "I-LOCATION"]
  실제: ["B-PERSON", "I-PERSON", "O", "O", "B-LOCATION", "I-LOCATION"]
  

→ 모든 엔티티 토큰(B-PERSON, I-PERSON, B-LOCATION, I-LOCATION)을 합쳐서 전체적으로 TP/FP/FN을 계산

- **계산 방식**: 전체 TP, FP, FN을 합산 후 계산
- **특징**: 
  - 빈도가 높은 클래스(예: O)의 영향이 큼
  - 전체적인 모델 성능을 반영
  - 데이터 불균형에 민감
- **용도**: 전체적인 모델 성능 평가
- **공식**:

Micro Precision = 전체 TP / (전체 TP + 전체 FP) Micro Recall = 전체 TP / (전체 TP + 전체 FN) Micro F1 = 2 × (Micro Precision × Micro Recall) / (Micro Precision + Micro Recall)

### Macro Metrics (매크로 메트릭)
- **정의**: 각 클래스별로 계산한 후 평균
- **토큰 예시**:

문장: "John Smith lives in New York" 토큰: ["John", "Smith", "lives", "in", "New", "York"] 라벨: ["B-PERSON", "I-PERSON", "O", "O", "B-LOCATION", "I-LOCATION"]

예측: ["B-PERSON", "I-PERSON", "O", "O", "B-LOCATION", "I-LOCATION"] 실제: ["B-PERSON", "I-PERSON", "O", "O", "B-LOCATION", "I-LOCATION"]

→ 각 라벨별로 개별 계산: B-PERSON: TP=1, FP=0, FN=0 → F1=1.0 I-PERSON: TP=1, FP=0, FN=0 → F1=1.0
B-LOCATION: TP=1, FP=0, FN=0 → F1=1.0 I-LOCATION: TP=1, FP=0, FN=0 → F1=1.0 O: TP=2, FP=0, FN=0 → F1=1.0

→ Macro F1 = (1.0 + 1.0 + 1.0 + 1.0 + 1.0) / 5 = 1.0

- **계산 방식**: 클래스별 Precision/Recall/F1의 평균
- **특징**:
  - 모든 클래스에 동일한 가중치
  - 클래스 불균형에 덜 민감
  - 소수 클래스의 성능도 동일하게 반영
- **용도**: 클래스 불균형 상황에서 공정한 평가
- **공식**:

Macro Precision = (P1 + P2 + ... + Pn) / n Macro Recall = (R1 + R2 + ... + Rn) / n Macro F1 = (F1_1 + F1_2 + ... + F1_n) / n

NER 측정 방법

Token-level F1: 각 토큰(단어)별로 라벨이 맞는지 확인 Entity-level F1: 전체 엔티티 단위로 완전히 맞는지 확인

예시

문장: "김철수는 서울에서 삼성전자에 다닌다"

정답 라벨:

김철수는 → B-PER I-PER O
서울에서 → B-LOC O
삼성전자에 → B-ORG I-ORG O
다닌다 → O

모델 예측:

김철수는 → B-PER O O        # "김철수" 중 "철수"를 놓침
서울에서 → B-LOC O         # "서울" 정확히 맞춤
삼성전자에 → B-ORG I-ORG O   # "삼성전자" 정확히 맞춤
다닌다 → O

점수 계산 비교

Token-level F1 계산

• 전체 토큰: 8개
• 맞은 토큰: 6개 (김, 서울, 삼성, 전자, 나머지 O들)
• 정확도가 높게 나옴 (75%)

Entity-level F1 계산

• 전체 엔티티: 3개 (김철수, 서울, 삼성전자)
• 완전히 맞은 엔티티: 2개 (서울, 삼성전자만)
• 정확도가 낮게 나옴 (67%)

설명

Token-level은 부분적으로라도 맞으면 점수를 줌

• "김철수" 중 "김"만 맞춰도 1점
• 실제로는 이름을 제대로 인식 못했는데 점수가 나옴

Entity-level은 엔티티 전체가 완벽해야 점수를 줌

• "김철수" 전체를 다 맞춰야만 1점
• 실제 사용 시나리오와 더 가까움

지표별 활용

Token-level F1

• 모델 학습 과정에서 세밀한 성능 분석
• 토큰 단위 정확도가 중요한 연구

**Entity-level F1

• 실제 서비스에서 사용할 때 (PII 마스킹, 정보 추출 등)
• 엔티티를 완전히 찾아야 하는 실용적인 평가

지표별 수식

Token-level F1 각 토큰별로 TP, FP, FN을 계산:

Precision = TP / (TP + FP)
Recall = TP / (TP + FN)
F1 = 2 × (Precision × Recall) / (Precision + Recall)

Entity-level F1 전체 엔티티 span으로 TP, FP, FN 계산:

Precision = 정확히 맞춘 엔티티 수 / 예측한 엔티티 수
Recall = 정확히 맞춘 엔티티 수 / 실제 엔티티 수
F1 = 2 × (Precision × Recall) / (Precision + Recall)

📊 실제 성능 차이

Entity-level이 더 엄격해서 점수가 낮게 나오는 게 일반적 보통 같은 모델이라도:

• Token-level F1: 85-95%
• Entity-level F1: 75-85%

BIO Tagging은 개체명 인식(NER)이나 시퀀스 라벨링에서 개체의 시작과 내부를 구분해 문장의 구조를 기계가 이해할 수 있도록 도와주는 방법

개념

자연어 처리(NLP)에서 토큰 단위로 개체(entity)의 범위를 표시하는 대표적인 방식 이름 그대로 B–I–O 세 가지 태그를 사용

개체

텍스트 안에서 특정한 의미적 범주로 구분되는 단위 BIO 태그에서 객체란 NER이 식별하려는 엔티티 클래스(개체)

• 사람 이름(Person)
• 조직(Organization)
• 지명(Location)
• 날짜/시간(Time)
• 기타 도메인 특화 엔티티 (예: 질병명, 약품명, 법률 용어 등)

태그

B (Begin):

• 개체의 시작을 의미
• 예를 들어, "뉴욕"이라는 지명이 나오면 "뉴"는 B-LOC으로 태깅

I (Inside):

• 개체의 내부(계속 이어지는 부분)를 의미
• "뉴욕"의 "욕"은 I-LOC으로 태깅

O (Outside):

• 어떤 개체에도 속하지 않는 일반 단어를 의미

예시 문장:

• "나는 뉴욕에 갔다"
• 토큰별 BIO 태깅:
  • 나는 → O
  • 뉴 → B-LOC
  • 욕 → I-LOC
  • 에 → O
  • 갔다 → O

정리

개념

• 모델이 예측한 값과 실제 정답 사이의 차이를 수치고 계산하는 함수
• 값이 작을수록 모델이 예측을 잘 했다는 의미이며,
• 이 값을 최소화하도록 학습하는 것을 최적화(=optimization)라고 함

카테고리별 Loss function

카테고리별 Loss function 요약

• 회귀: MSE, MAE, Huber, Log-Cosh
• 분류: Cross Entropy, NLL, Hinge, Focal, Label Smoothing
• 임베딩: Cosine, Contrastive, Triplet, InfoNCE
• 검출·세그멘테이션: IoU, Dice, Tversky, GIoU/DIoU/CIoU

1. 회귀 (Regression)

(1) Mean Squared Error (MSE)

$$ L_{\text{MSE}} = \frac{1}{n}\sum_{i=1}^n (y_i - \hat{y}_i)^2 $$

• 연속값 예측 기본 손실, 이상치에 민감.

(2) Mean Absolute Error (MAE)

$$ L_{\text{MAE}} = \frac{1}{n}\sum_{i=1}^n |y_i - \hat{y}_i| $$

• 이상치에 강건, gradient 일정.

(3) Huber Loss (Smooth L1)

$$ L_\delta(y, \hat{y}) = \begin{cases} \frac{1}{2}(y-\hat{y})^2, & |y-\hat{y}| \leq \delta \ \delta |y-\hat{y}| - \tfrac{1}{2}\delta^2, & \text{otherwise} \end{cases} $$

• 작은 오차는 MSE, 큰 오차는 MAE처럼 동작.

(4) Log-Cosh Loss

$$ L(y, \hat{y}) = \sum_{i=1}^n \log\left(\cosh(\hat{y}_i - y_i)\right) $$

• MSE와 비슷하지만 이상치에 덜 민감.

2. 분류 (Classification)

(1) Cross Entropy Loss

$$ L_{\text{CE}} = - \sum_{i=1}^C y_i \log(\hat{p}_i) $$

• 가장 널리 쓰이는 분류 손실. Softmax와 함께 사용.

(2) Negative Log Likelihood (NLL)

$$ L_{\text{NLL}} = - \log \hat{p}(y) $$

• 단일 정답 클래스의 확률을 직접 penalize. (Softmax+NLL = CE)

(3) Hinge Loss

$$ L_{\text{hinge}} = \sum_{i=1}^n \max(0, 1 - y_i \hat{y}_i) $$

• 마진 기반 학습 (SVM에서 사용).

(4) Focal Loss

$$ L_{\text{FL}} = - \alpha (1 - \hat{p}_t)^\gamma \log(\hat{p}_t) $$

• 어려운 샘플에 집중, 클래스 불균형 대응.
• $p_t = \hat{p}(y)$.

(5) Label Smoothing Cross Entropy

$$ L = - \sum_{i=1}^C \big( (1-\epsilon) y_i + \tfrac{\epsilon}{C} \big) \log(\hat{p}_i) $$

• 모델의 과도한 확신 방지.

3. 임베딩 / Metric Learning

(1) Cosine Embedding Loss

$$ L = \begin{cases} 1 - \cos(x_1, x_2), & y = 1 \ \max(0, \cos(x_1, x_2) - m), & y = -1 \end{cases} $$

• 같은 쌍(positive)은 가깝게, 다른 쌍(negative)은 멀게.

(2) Contrastive Loss

$$ L = (1-y) \frac{1}{2} D^2 + y \frac{1}{2} \max(0, m-D)^2 $$

• $D = |x_1 - x_2|$, $y=0$ 같은 클래스, $y=1$ 다른 클래스.

(3) Triplet Loss

$$ L = \max(0, d(a,p) - d(a,n) + \alpha) $$

• Anchor–Positive는 가깝게, Anchor–Negative는 멀게.

(4) InfoNCE Loss

$$ L = - \log \frac{\exp(\text{sim}(x, x^+)/\tau)}{\sum_{j=1}^N \exp(\text{sim}(x, x_j)/\tau)} $$

• Contrastive Learning에서 자주 사용, 여러 negative 대비 positive를 구분.

4. 객체 검출 · 세그멘테이션 (Detection & Segmentation)

(1) IoU Loss (Jaccard Loss)

$$ L_{\text{IoU}} = 1 - \frac{|y \cap \hat{y}|}{|y \cup \hat{y}|} $$

• 박스/영역 겹침을 최적화.

(2) Dice Loss

$$ L_{\text{Dice}} = 1 - \frac{2|y \cap \hat{y}|}{|y| + |\hat{y}|} $$

• class imbalance에 강건.

(3) Tversky Loss

$$ L = 1 - \frac{|y \cap \hat{y}|}{|y \cap \hat{y}| + \alpha |y \setminus \hat{y}| + \beta |\hat{y} \setminus y|} $$

• FP/ FN 비중 조절 가능 (Dice의 일반화).

(4) GIoU / DIoU / CIoU Loss

(Detection bounding box 용 개선된 IoU)

$$ L_{\text{GIoU}} = 1 - IoU + \frac{|C - (A \cup B)|}{|C|} $$

• $C$: 두 박스를 포함하는 최소 영역.
• 위치 정렬과 수렴 속도를 개선.

－ NER은 문장에서 사람, 장소, 조직, 시간, 숫자 등 의미 있는 단위(개체, Entity)를 찾아내고 분류하는 작업 － "이 문장 속에서 중요한 이름이나 값은 뭐지?"를 기계가 알아보게 하는 것

예시

문장: － **"스티브 잡스는 1976년에 애플을 공동 창업했다."**

NER 결과:

• 스티브 잡스 → PER (사람, Person)
• 1976년 → DATE (날짜/시간, Date)
• 애플 → ORG (조직, Organization)

대표적인 태그 세트

NER 시스템은 보통 사전 정의된 개체 유형을 예측한다. 예:

• PER : 인물(Person)
• LOC : 위치(Location)
• ORG : 조직(Organization)
• DATE : 날짜(Date)
• TIME : 시간(Time)
• MONEY : 금액(Money)
• PERCENT : 퍼센트(Percent)

데이터셋에 따라 더 세분화되기도 하고, 단순히 PER/LOC/ORG만 쓰는 경우도 있다.

어떻게 작동할까?

NER은 보통 시퀀스 라벨링(sequence labeling) 문제로 다룹니다. 즉, 문장을 토큰 단위로 쪼개서 각 토큰에 BIO 같은 라벨을 붙이는 방식이에요.

1. 입력 문장을 토큰화 (예: "스티브", "잡스", "는", ...)
2. 각 토큰에 대해 B-PER, I-PER, O, B-ORG 등 라벨을 예측
3. 연속된 토큰을 합쳐 하나의 개체로 인식

NER 모델

NER은 전통적으로 CRF(Conditional Random Field) 같은 통계적 모델을 썼지만, 최근에는 딥러닝 기반이 많이 쓰인다:

• BiLSTM-CRF : 양방향 LSTM + CRF
• BERT 기반 NER : 사전학습 언어모델을 fine-tuning
• GPT 계열 모델 : instruction 기반으로 NER 수행 가능

응용 분야

• 챗봇 : 사용자 입력에서 이름/날짜/장소 추출
• 검색엔진 : 쿼리에서 중요한 개체 뽑아 검색 개선
• 문서 요약 : 문서 속 인물, 사건, 날짜 자동 추출
• 의료/법률 텍스트 분석 : 질병명, 약품명, 법률명 등 인식