dhlee-note

Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity 논문 리뷰

dhlee-note — Fri, 9 Jan 2026 14:53:13 +0900

본 논문은 2025년 Stanford 대학교에서 발표한 "Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity" 논문 입니다. 한국어로 번역하면 "언어적 샘플링: 모드 붕괴를 완화하고 LLM 다양성을 확보하는 방법" 입니다. 제목에서 알 수 있듯이 LLM 답변의 다양성이 감소되는 문제에 대한 원인과 학습 없이 이를 해결하는 방법에 대한 내용에 담고 있습니다.

Paper: https://arxiv.org/abs/2510.01171

Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity

Post-training alignment often reduces LLM diversity, leading to a phenomenon known as mode collapse. Unlike prior work that attributes this effect to algorithmic limitations, we identify a fundamental, pervasive data-level driver: typicality bias in prefer

arxiv.org

Website: https://www.verbalized-sampling.com

Verbalized Sampling

Mitigate Mode Collapse and Unlock LLM Diversity

www.verbalized-sampling.com

Blog: https://simonucl.notion.site/verbalized-sampling

Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity | Notion

Jiayi Zhang*¹, Simon Yu*¹, Derek Chong*², Anthony Sicilia³,

simonucl.notion.site

Code: https://github.com/CHATS-lab/verbalized-sampling

GitHub - CHATS-lab/verbalized-sampling: Verbalized Sampling, a training-free prompting strategy to mitigate mode collapse in LLM

Verbalized Sampling, a training-free prompting strategy to mitigate mode collapse in LLMs by requesting responses with probabilities. Achieves 2-3x diversity improvement while maintaining quality. ...

github.com

연구 배경 및 목적

대규모 언어모델(LLM)은 사전학습 단계에서는 다양한 표현을 생성할 수 있지만, RLHF와 같은 사후 정렬(post-training alignment)을 거치면서 출력이 몇 가지 전형적인 답변으로 수렴하는 모드 붕괴(mode collapse) 문제가 발생한다. 이는 창의적 글쓰기, 사회적 시뮬레이션, 설문·합성 데이터 생성 등 다양성이 핵심인 과제의 성능을 구조적으로 제한한다.

기존 연구는 주로 보상모델의 한계나 최적화 알고리즘 문제로 원인을 설명해 왔다. 본 논문의 목적은 다음 두 가지이다.

모드 붕괴의 근본 원인이 알고리즘이 아니라 ‘선호 데이터 자체’에 있음을 규명
추가 학습 없이(inference-time) 모드 붕괴를 완화할 수 있는 실용적 방법 제안

제안 방안

(1) 핵심 원인: Typicality Bias

저자들은 인간 선호 데이터에 전형성 편향(typicality bias)이 존재한다고 주장한다. 이는 인지심리학에서 잘 알려진 현상으로, 인간 평가자는 익숙하고, 예측 가능하며, 처리하기 쉬운(textually fluent) 응답을 더 좋은 답변으로 평가하는 경향이 있다.

이를 수식화하면, 실제 과제 품질과 무관하게 베이스 모델에서 확률이 높은(전형적인) 응답이 보상에서 유리해진다. 이 효과는 보상모델이 완벽해도 제거되지 않는다.

(2) 이론적 결과

RLHF 목적함수에 typicality bias가 포함되면, 최적 정책은 베이스 모델 분포를 온도 감소(샤프닝)한 형태가 된다.
특히 여러 답변이 동일하게 ‘정답’인 상황(창의적 과제)에서는 전형성 편향이 사실상의 타이브레이커로 작동해 단일 모드로 수렴한다.

(3) 해결책: Verbalized Sampling (VS)

저자들은 학습을 바꾸지 않고 프롬프트 자체를 바꾸는 방법을 제안한다.

기존: “커피에 대한 농담 하나 말해줘”
VS: “커피에 대한 농담 5개와 각 농담의 확률을 함께 제시해줘”

이렇게 하면 모델은 단일 답변의 최빈값(mode)이 아니라, 사전학습 중 학습한 분포 자체를 ‘설명하도록’ 강제된다. 저자들은 이를 분포 수준 프롬프트(distribution-level prompt)라고 부른다.

실험

저자들은 VS를 다양한 과제와 모델에서 평가했다.

실험 과제

창의적 글쓰기: 시, 이야기, 농담
대화 시뮬레이션: 기부 설득 대화
Open-ended QA: 정답이 여러 개인 질문
합성 데이터 생성: 수학 문제 생성 후 downstream 성능

비교 방법

여러 프롬프트 방식으로 비교를 했다. 실제 실험에서 사용된 전체 프롬프트는 논문의 Appendix I.2에 나와있다.

Direct prompting
Chain-of-Thought
리스트 생성
멀티턴 프롬프트
VS (Standard / CoT / Multi 변형)

평가 방법

1. 창의적 글쓰기 (Creative Writing: 시·이야기·농담)

(1) 다양성(Diversity) 평가

두 가지 축으로 측정합니다.

의미적 다양성 (Semantic Diversity)
- 각 응답을 임베딩(예: OpenAI text-embedding-3-small)으로 변환
- 모든 응답 쌍의 평균 코사인 유사도 $ \bar{s} $ 계산
- $\text{Diversity} = 1 - \bar{s}$ (백분율로 보고)
- 음수 유사도는 0으로 클리핑
어휘적 다양성 (Lexical Diversity)
- ROUGE-L 사용
  $$ \mathrm{ROUGE}\text{-}L =
  \frac{(1+\beta^2)\,\frac{\mathrm{LCS}(c,r)}{|c|}\,\frac{\mathrm{LCS}(c,r)}{|r|}}
  {\frac{\mathrm{LCS}(c,r)}{|r|}+\beta^2 \frac{\mathrm{LCS}(c,r)}{|c|}} $$
- 점수가 낮을수록 다양성이 높음

(2) 품질(Quality) 평가

LLM 심판 평가 사용
- 시/이야기: Creative Writing v3 루브릭
- 농담: HumorBench 루브릭
심판 모델: Claude-3.7-Sonnet

(3) 인간 평가(Human Study)

Prolific 참여자 사용
4점 Likert 척도(매우 유사 ↔ 매우 상이)
과제별 다양성 정의(플롯·스타일·펀치라인 등) 제공
평가자 간 일치도(ICC) 보고

2. 대화 시뮬레이션 (Dialogue Simulation: 설득 대화)
(1) 행동 결과 정합성 (Donation Amount)

KS 검정(Kolmogorov–Smirnov test)→ 모델 분포 vs 인간 분포
L1 거리→ 각 대화별 기부 금액 차이

(2) 언어적 정합성 (Linguistic Alignment)

Distinct-1 / 2 / 3: n-그램 다양성
의미적 다양성: 대화 내 응답 임베딩 기반
가독성(Readability): Flesch–Kincaid Grade Level

3. 오픈엔디드 QA (Enumerative Open-Ended QA)

다수의 정답이 존재하는 질문(예: “미국 주 이름 말해줘”)에 대한 평가입니다.

KL Divergence
- 생성된 답변 분포 vs 사전학습 코퍼스(RedPajama) 기준 분포
- 낮을수록 이상적
Coverage-N
- N개 샘플 중 서로 다른 정답의 비율
Precision
- 생성된 답변 중 정답 비율
- 다양성 증가가 정확도를 해치지 않는지 확인

4. 합성 데이터 생성 (Synthetic Data Generation)

(1) 간접 평가 (Downstream Performance)

LLM으로 생성한 수학 문제 1,000개로 소형 모델 SFT
평가 벤치마크
- MATH500
- OlympiadBench
- Minerva Math
지표: 정답 정확도(Accuracy)

→ 합성 데이터의 “좋음/나쁨”을 후속 성능 향상 여부로 판단

5. 통계적 검증

대부분의 비교에서 단측 t-test 수행
유의수준: p < 0.05 / 0.01 / 0.001 표기

결과

(1) 다양성 - Figure 4, 7

VS는 창의적 글쓰기에서 다양성을 1.6–2.1배 향상
정렬 단계가 깊어질수록(특히 RLHF 이후) 기존 프롬프트는 급격히 붕괴, VS는 베이스 모델 다양성의 약 67% 유지

(2) 품질 및 정확성 - Figure 4, 9

다양성 증가에도 불구하고 품질 저하 없음
Open-ended QA에서 정확도는 거의 동일, 분포는 훨씬 현실적

(3) 인간 유사성 - Figure 8

대화 시뮬레이션에서 VS는 기부 금액 분포와 언어 스타일 모두 인간 분포에 더 근접
일부 대형 모델은 전용 파인튜닝 모델과 동등하거나 상회

(4) 확장 효과 - Figure 4, Table 4

모델이 클수록 VS 효과가 더 큼
합성 데이터 다양성 증가 → 수학 다운스트림 성능 유의미한 개선

결론

이 논문은 모드 붕괴를 “학습이 잘못되었다”는 문제가 아니라, “인간 선호 데이터의 구조적 편향” 문제로 재정의한다. 이를 통해 다음을 보여준다.

모드 붕괴는 피하기 어려운 데이터 수준 현상
정렬된 모델도 잠재적으로는 여전히 풍부한 다양성을 내재
Verbalized Sampling은 추가 학습 없이 이 다양성을 실질적으로 회복
품질·안전성을 해치지 않으면서 다양성–품질 트레이드오프를 개선

결과적으로 본 연구는 LLM 정렬의 한계를 설명하는 새로운 이론적 렌즈와, 현업에서 즉시 활용 가능한 간단하지만 강력한 추론 시점 해법을 동시에 제공한다.

ROUGE 스코어: 요약/생성 모델 평가 지표

dhlee-note — Tue, 9 Dec 2025 11:10:17 +0900

텍스트 요약이나 생성 모델을 평가할 때 가장 자주 등장하는 지표가 ROUGE(Recall-Oriented Understudy for Gisting Evaluation)입니다. 이름 그대로 “정답(레퍼런스)과 비교했을 때 얼마나 잘 겹치는가”를 n-그램(연속된 단어/토큰 묶음) 기반으로 측정합니다. 직관적이고 구현이 쉬워 널리 쓰이지만, 해석을 잘못하면 성능을 과대/과소평가하기도 합니다.

ROUGE는 무엇을 측정하나?

ROUGE는 기본적으로 모델 출력(candidate) 과 사람이 만든 정답 요약(reference) 사이의 겹침(overlap) 을 측정합니다.

겹침이 많다 → 정답과 비슷한 표현을 많이 썼다
겹침이 적다 → 정답과 표현이 다르거나, 핵심을 놓쳤을 수 있다

즉 ROUGE는 “의미가 맞는가”보다는 “표현이 얼마나 비슷한가”에 더 가깝습니다.

가장 많이 쓰는 ROUGE 종류

1) ROUGE-1

단어(토큰) 1개짜리 n-그램 겹침
핵심 단어를 얼마나 포함했는지에 민감
요약 품질을 “대략적으로” 보기 좋지만, 문장 구조나 흐름은 잘 못 봅니다.

2) ROUGE-2

2-그램(연속된 두 단어/토큰) 겹침
ROUGE-1보다 문장/표현의 유사성을 더 엄격히 봄
하지만 한 단어만 달라도 2-그램이 깨져 점수가 크게 흔들릴 수 있습니다.

3) ROUGE-L

최장 공통 부분수열(LCS) 기반
단어가 완전히 연속되지 않아도, 순서가 비슷하면 점수가 나옵니다.
요약에서 “문장 흐름/순서”를 어느 정도 반영하고 싶을 때 자주 씁니다.

수식 설명

후보 요약(모델 출력): $ C $
참조 요약(정답): $ R $
$ G_n(T) $: 텍스트 T에서의 모든 n-그램 멀티셋(multiset)
$ \text{count}_{G}(g) $: 멀티셋 G에서 n-그램 g의 등장 횟수
중복 등장(같은 n-그램 여러 번)은 카운트로 반영됩니다.

1) ROUGE-1 / ROUGE-2

ROUGE-1은 n=1 (유니그램), ROUGE-2는 n=2 (바이그램)일 뿐 구조는 같습니다.

(1) 겹치는 n-그램 수(클리핑된 overlap)

$$ \text{Overlap}_n(C,R)
= \sum_{g \in G_n(R)} \min\big(\text{count}_{G_n(C)}(g),\ \text{count}_{G_n(R)}(g)\big) $$

핵심은 $ \min(\cdot) $ “클리핑(clipping)”입니다.

후보가 어떤 n-그램을 과도하게 반복해도, 참조에 있는 횟수 이상으로는 겹침으로 인정되지 않습니다.

(2) Recall / Precision / F1

$$ \text{ROUGE-}n_{\text{recall}} = \frac{\text{Overlap}_n(C,R)}{\sum_{g \in G_n(R)} \text{count}_{G_n(R)}(g)} $$

$$ \text{ROUGE-}n_{\text{precision}} = \frac{\text{Overlap}_n(C,R)}{\sum_{g \in G_n(C)} \text{count}_{G_n(C)}(g)} $$

$$ \text{ROUGE-}n_{F1} = \frac{2 \cdot \text{ROUGE-}n_{\text{precision}} \cdot \text{ROUGE-}n_{\text{recall}}}{\text{ROUGE-}n_{\text{precision}} + \text{ROUGE-}n_{\text{recall}}} $$

ROUGE-1: 위 식에서 n=1
ROUGE-2: 위 식에서 n=2

실무/논문에서 “ROUGE-1/2”라고만 쓰면 보통 F1을 의미하는 경우가 많지만, 반드시 표기(Recall/Precision/F1)를 확인하는 것이 좋습니다.

2) ROUGE-L (LCS: 최장 공통 부분수열 기반)

ROUGE-L은 n-그램 대신, 두 시퀀스(단어/토큰)의 최장 공통 부분수열 길이를 사용합니다.

$ LCS(C,R) $: C와 R의 최장 공통 부분수열(Longest Common Subsequence)
$ \text{LCS_len}(C,R) $: 그 길이

(1) Recall / Precision

$$ R_{LCS} = \frac{\text{LCS_len}(C,R)}{|R|}
\qquad
P_{LCS} = \frac{\text{LCS_len}(C,R)}{|C|} $$

여기서 |R|, |C|는 각각 토큰(또는 단어) 길이입니다.

(2) F-Measure (일반화된 $ F_\beta $)

ROUGE-L은 흔히 $ \beta $를 사용해 Recall을 더 강조한 $ F_\beta $ 형태로 결합합니다.

$$ \text{ROUGE-L}
= F_{\beta}
= \frac{(1+\beta^2)\, P_{LCS}\, R_{LCS}}{R_{LCS} + \beta^2 P_{LCS}} $$

$ \beta > 1 $이면 Recall 비중이 더 커집니다.

어떤 구현은 $ \beta = \frac{P_{LCS}}{R_{LCS}} $ 같은 내부 규칙을 쓰거나, 고정값(예: 1.2)을 쓰는 등 라이브러리/설정에 따라 다를 수 있습니다. 따라서 사용한 구현체의 정의를 확인해야 합니다.

트리(Tree)와 그래프(Graph)의 차이점 비교

dhlee-note — Sun, 7 Dec 2025 18:39:31 +0900

트리(Tree)와 그래프(Graph)는 모두 정점(Vertex)과 간선(Edge)으로 구성된 자료구조이지만, 구조적 규칙과 사용 목적에 큰 차이점이 있습니다. 크게 5가지로 구분해서 살펴보겠습니다.

1. 구조적 제약의 존재 여부

트리: 제약이 많은 구조
- 반드시 하나의 루트(root)가 존재함
- 사이클이 존재할 수 없음
- 부모는 하나만 가질 수 있음
- 연결 구조가 계층적(hierarchical)
그래프: 제약이 거의 없는 구조
- 루트가 존재할 필요 없음
- 사이클이 있을 수도 있고 없을 수도 있음
- 한 정점에 여러 부모 또는 여러 간선 연결 가능
- 구조가 네트워크 형태로 자유로움

2. 연결 방향

트리
- 보통 방향성이 있는 구조(부모 → 자식)로 취급됨
그래프
- 방향 그래프(Directed) 또는 무방향 그래프(Undirected) 모두 가능함

3. 경로의 유일성

트리
- 두 정점 사이의 경로는 항상 하나뿐임
그래프
- 두 정점 사이에 여러 경로가 존재할 수 있음
- 심지어 사이클로 인해 무한히 순환할 수도 있음

4. 정점·간선 수의 관계

트리
- 항상 간선 수 = 정점 수 - 1
그래프
- 정점 수에 대해 간선 수에는 제한이 없음
- 적어도 0개부터
- 최대 N(N-1)개(방향 그래프 기준)까지 가능

5. 사용 목적

트리: 계층 구조 표현에 적합
- 파일 시스템
- 조직도
- 이진 탐색 트리(BST)
- 힙(Heap)
- 트라이(Trie)
그래프: 복잡한 관계를 표현하는 데 사용
- 네트워크 연결
- SNS 친구 관계
- 지도 경로 탐색
- 최단 거리 알고리즘
- 추천 시스템

정리하면 다음과 같습니다.

	트리(Tree)	그래프(Graph)
사이클	없음	있을 수 있음
루트	반드시 존재	없어도 됨
부모 관계	부모 1개	여러 개 가능
목적	계층 구조 표현	복잡한 연결 관계 표현
경로 수	두 정점 간 경로 1개	여러 개 가능
간선 수	N-1	제약 없음

그래프(Graph) 자료구조 개념 정리 + Python 구현

dhlee-note — Sun, 7 Dec 2025 18:27:00 +0900

그래프(Graph)는 현실 세계의 다양한 관계를 표현할 수 있는 강력한 자료구조입니다.

SNS 친구 관계, 도로 지도, 네트워크 연결 구조 등 우리 주변의 수많은 시스템이 그래프로 모델링될 수 있습니다.

오늘은 그래프의 개념과 핵심 용어, 그리고 간단한 예제를 중심으로 그래프에 대해서 설명하겠습니다.

그래프(Graph)란 무엇인가?

그래프는 노드(Node, 정점 Vertex)와 간선(Edge)으로 구성된 자료구조입니다.

트리가 계층 구조를 표현하는 것이라면, 그래프는 복잡한 연결 관계를 표현하기 위한 구조입니다.

그래프는 다음과 같은 특징을 가집니다.

노드와 노드가 간선으로 연결되어 있음
순환(Cycle)이 존재할 수 있음
데이터 간의 관계를 표현하는 데 매우 적합함
방향성이 있을 수도 있고 없을 수도 있음

그래프의 기본 용어

그래프를 이해하기 위해 자주 등장하는 용어들을 먼저 정리해보겠습니다.

정점(Vertex): 그래프에서 점을 의미합니다.
간선(Edge): 정점과 정점을 연결하는 선입니다.
인접(Adjacency): 두 정점이 간선으로 직접 연결되어 있는 관계입니다.
차수(Degree): 정점에 연결된 간선의 개수입니다.
무방향 그래프: 연결된 간선 수
방향 그래프: 진입 차수(In-degree) / 진출 차수(Out-degree)
경로(Path): 정점을 따라 이동하는 흐름입니다.
사이클(Cycle): 시작 정점과 끝 정점이 동일한 순환 구조입니다.

그래프의 종류

그래프는 여러 형태로 구분될 수 있습니다.

1. 무방향 그래프(Undirected Graph): 간선에 방향이 없는 그래프입니다.

A — B — C

2. 방향 그래프(Directed Graph): 간선이 특정 방향을 가지는 그래프입니다.

A → B → C

3. 가중치 그래프(Weighted Graph): 간선에 비용(Weight)이 있는 그래프입니다.

A —5— B —7— C

4. 연결 그래프 / 비연결 그래프: 모든 정점이 이어져 있으면 연결 그래프입니다.

5. 사이클 존재 여부

사이클이 있는 그래프
무사이클 그래프(DAG, Directed Acyclic Graph)

그래프 구현 방식

그래프는 컴퓨터에서 보통 두 가지 방식으로 표현합니다.

1. 인접 리스트(Adjacency List)

각 정점에 연결된 정점들의 목록을 저장합니다.

메모리 효율이 좋고, 대부분의 알고리즘에서 많이 사용됩니다.

2. 인접 행렬(Adjacency Matrix)

정점 수 N일 때 N×N 행렬로 연결 여부를 저장합니다.

정점 수가 많을수록 메모리 사용량이 커지지만, 두 정점의 연결 여부를 O(1)에 확인할 수 있습니다.

파이썬(Python) 예제 코드

1. 인접 리스트 예제

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D'],
    'C': ['A'],
    'D': ['B']
}

2. 그래프 탐색: DFS & BFS

# DFS
def dfs(graph, start, visited=None):
    if visited is None:
        visited = []
    visited.append(start)
    for node in graph[start]:
        if node not in visited:
            dfs(graph, node, visited)
    return visited

# BFS
from collections import deque

def bfs(graph, start):
    visited = []
    queue = deque([start])
    
    while queue:
        node = queue.popleft()
        if node not in visited:
            visited.append(node)
            queue.extend(graph[node])
    return visited


print("DFS:", dfs(graph, 'A'))
print("BFS:", bfs(graph, 'A'))

DFS: ['A', 'B', 'D', 'C']
BFS: ['A', 'B', 'C', 'D']

그래프는 경로 찾기, 최단 거리 계산, 사이클 탐지 등 다양한 알고리즘의 기반이 되는 자료구조입니다. 특히 DFS(깊이 우선 탐색)와 BFS(너비 우선 탐색)은 그래프 문제 해결의 핵심이므로 반드시 익혀두어야 합니다. 또한 직접 그림을 그려보며 정점과 간선의 연결 관계를 시각적으로 이해하면 학습 속도를 크게 높일 수 있습니다. 그래프는 문제 난이도와 유형이 매우 다양하기 때문에 기초 개념을 탄탄하게 다져두는 것이 중요합니다.

그래프는 현실 세계의 복잡한 관계를 그대로 표현할 수 있는 강력한 구조입니다. 방향성, 가중치, 사이클 여부 등 다양한 조건을 통해 문제를 정의할 수 있으며, 이를 잘 이해하면 최단 경로 알고리즘, 네트워크 분석, 경로 탐색 문제 등 여러 분야의 문제를 자연스럽게 해결할 수 있습니다. 자료구조와 알고리즘의 핵심 개념이니 꾸준히 연습과 예제를 통해 익혀두는 것을 추천드립니다.

트리(Tree) 자료구조 개념 정리 + Python 구현

dhlee-note — Sun, 7 Dec 2025 18:16:04 +0900

자료구조를 공부할 때 반드시 등장하는 구조가 바로 트리(Tree)입니다. 트리는 계층 구조를 표현하기 위해 사용되며, 그래프의 한 형태이기도 합니다. 파일 시스템, 데이터베이스 인덱스, 조직도 등 여러 곳에서 활용되는 매우 중요한 개념입니다. 오늘은 트리의 핵심 개념과 기본 용어, 그리고 대표적인 예제를 중심으로 설명해보겠습니다.

트리(Tree)란 무엇인가?

트리는 노드(Node)와 간선(Edge)으로 이루어진 비선형 자료구조입니다.

일반적인 배열이나 연결 리스트처럼 순차적으로 이어지는 구조가 아니라, 계층적이며 부모-자식 관계를 가진 구조입니다.

트리는 다음과 같은 특징을 가집니다.

하나의 최상위 노드를 루트(root)라고 부릅니다.
각 노드는 0개 이상의 자식 노드를 가질 수 있습니다.
사이클이 존재하지 않습니다.
계층 구조를 표현할 때 적합합니다.

기본 용어 정리

트리를 이해하기 위해서는 몇 가지 기본 용어를 알아야 합니다.

루트(Root): 트리의 가장 위에 위치한 노드입니다.
부모(Parent) / 자식(Child): 노드는 하나의 부모를 가지며, 여러 개의 자식을 가질 수 있습니다.
형제(Sibling): 같은 부모를 가진 노드들입니다.
리프(Leaf): 자식이 없는 노드입니다. 트리의 끝에 위치합니다.
서브트리(Subtree): 트리의 일부가 또 하나의 트리 형태를 이루는 구조입니다.
높이(Height): 트리의 최대 깊이를 의미합니다.

시각적으로 살펴보면 다음과 같습니다.

        A (Root)
       / \
      B   C
     / \   \
    D   E   F (Leaf)

트리의 중요성

트리는 여러 알고리즘과 구조의 기반이 됩니다.

이진 탐색 트리(Binary Search Tree)
힙(Heap)
트라이(Trie)
AVL 트리, 레드-블랙 트리
B-Tree, B+Tree (DB 인덱스 제작)

또한 실제 사용 예는 다음과 같습니다.

운영체제의 파일 시스템
회사의 조직도
HTML 태그의 DOM 구조
데이터베이스의 검색 및 정렬 구조

트리의 종류

트리는 다양한 형태로 확장될 수 있습니다.

이진 트리(Binary Tree): 각 노드가 최대 두 개의 자식을 가지는 트리입니다.
이진 탐색 트리(BST): 왼쪽 자식 < 부모 < 오른쪽 자식 규칙을 따르는 트리입니다.
균형 이진 트리(AVL, Red-Black Tree): 트리가 한쪽으로 치우치지 않도록 자동으로 균형을 맞추는 구조입니다.
힙(Heap): 최댓값 또는 최솟값을 빠르게 찾기 위한 완전 이진 트리입니다.
트라이(Trie): 문자열 탐색을 위해 특화된 트리 구조입니다.

파이썬(Python) 예제 코드

아래는 가장 기본적인 트리 구조를 표현하는 간단한 예제입니다.

class Node:
    def __init__(self, value):
        self.value = value
        self.children = []

    def add_child(self, node):
        self.children.append(node)


# 트리 구성 예시
root = Node("A")
node_b = Node("B")
node_c = Node("C")
node_d = Node("D")
node_e = Node("E")

root.add_child(node_b)
root.add_child(node_c)
node_b.add_child(node_d)
node_b.add_child(node_e)

# 출력 예시 (단순 구조 출력)
def print_tree(node, level=0):
    print("  " * level + node.value)
    for child in node.children:
        print_tree(child, level + 1)

print_tree(root)

A
  B
    D
    E
  C

트리를 학습할 때는 몇 가지 중요한 포인트를 함께 기억하는 것이 좋습니다. 트리는 재귀(Recursion) 개념과 깊게 연결되어 있기 때문에, 재귀 호출 방식에 익숙해질수록 트리 구조를 이해하기가 훨씬 쉽습니다. 또한 DFS(깊이 우선 탐색), BFS(너비 우선 탐색)과 같은 탐색 기법을 함께 공부하면 트리의 동작 방식을 보다 명확하게 파악할 수 있습니다. 무엇보다도 직접 트리를 손으로 그려보며 구조를 시각적으로 이해하는 학습법이 큰 도움이 됩니다.

트리는 자료구조의 기초이자 다양한 알고리즘의 기반이 되는 매우 중요한 구조입니다. 계층적 데이터를 표현할 때 널리 사용되며, 코딩 테스트나 개발 실무에서도 자주 등장합니다. 트리를 잘 이해하면 검색, 탐색, 정렬 구조가 동작하는 원리까지 자연스럽게 익힐 수 있어 이후의 알고리즘 학습에도 크게 도움이 됩니다.

퀵 정렬(Quick Sort) 개념 및 동작 과정 + Python 예제 코드

dhlee-note — Sun, 7 Dec 2025 18:03:19 +0900

정렬 알고리즘 중 가장 자주 언급되는 방식이 바로 퀵 정렬(Quick Sort)입니다. 평균적으로 매우 빠른 성능을 보이며, 분할 정복(Divide and Conquer) 전략을 기반으로 동작하는 대표적인 알고리즘입니다.

퀵 정렬(Quick Sort)이란?

퀵 정렬은 피벗(Pivot) 이라고 불리는 기준 값을 중심으로 데이터를 두 그룹으로 나누고, 그 그룹에 대해 재귀적으로 정렬을 수행하는 알고리즘입니다.

퀵 정렬은 다음과 같은 특징을 가지고 있습니다.

평균 시간 복잡도: O(n log n)
최악 시간 복잡도: O(n²) (피벗을 잘못 선택할 경우)
제자리(in-place) 정렬로 추가적인 메모리가 많이 필요하지 않음
실제 개발 환경에서 매우 많이 사용되는 효율적인 정렬 기법

동작 방식

퀵 정렬의 핵심 개념은 다음 세 가지입니다.

1) 피벗(Pivot) 선택

배열에서 하나의 값을 피벗으로 선택합니다.

가장 쉬운 방법은 첫 번째 값 또는 마지막 값을 피벗으로 사용하는 것입니다.

2) 분할(Partition)

피벗을 기준으로 피벗보다 작은 값과 피벗보다 큰 값으로 배열을 나눕니다.

3) 재귀 호출

피벗을 기준으로 분리된 두 부분 배열을 각각 다시 퀵 정렬합니다.

이 과정을 반복하면 전체 배열이 정렬됩니다.

동작 예시

[5, 3, 8, 4, 2, 7, 1, 6]

1단계: 피벗 선택

여기서는 첫 번째 값 5를 피벗으로 선택합니다.

2단계: 피벗보다 작은 값 / 큰 값 분리

작은 값: [3, 4, 2, 1]
큰 값: [8, 7, 6]

정리하면 다음과 같습니다.

[작은 값들] + [피벗] + [큰 값들]
[3, 4, 2, 1] + [5] + [8, 7, 6]

3단계: 재귀적으로 정렬

각 부분 배열에 다시 퀵 정렬을 적용합니다.

파이썬(Python) 예제 코드

아래는 가장 기본적인 방식의 퀵 정렬 예제 코드입니다.

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    
    pivot = arr[0]
    left = [x for x in arr[1:] if x < pivot]
    right = [x for x in arr[1:] if x >= pivot]
    
    return quick_sort(left) + [pivot] + quick_sort(right)

data = [5, 3, 8, 4, 2, 7, 1, 6]
print(quick_sort(data))

[1, 2, 3, 4, 5, 6, 7, 8]

퀵 정렬을 잘 사용하기 위한 팁

피벗 선택 전략이 성능에 큰 영향을 미칩니다.

보톤 중앙값(median) 선택, 무작위 피벗(random pivot) 선택 등이 자주 사용됩니다.

데이터가 거의 정렬된 경우에는 퀵 정렬의 성능이 떨어질 수 있습니다.

이럴 때는 삽입 정렬과 혼합한 하이브리드 방식이 좋습니다.

코딩 테스트에서 자주 사용하는 Python 내장 함수 및 라이브러리

dhlee-note — Sun, 7 Dec 2025 17:52:48 +0900

1. collection.Counter

collection.Counter는 파이썬에서 해시 가능한 객체들의 개수를 세어 딕셔너리 형태로 저장하는 컬렉션 클래스입니다. 각 요소는 키가 되고 그 요소의 출현 횟수가 값이 됩니다.

from collections import Counter

# 리스트, 문자열 또는 다른 이터러블 객체를 Counter에 전달합니다.
data = ['사과', '바나나', '사과', '오렌지', '바나나', '사과']

# Counter 객체 생성
count = Counter(data)

# 결과 출력
print(count)

# 특정 요소의 개수 확인
print(f"'사과'의 개수: {count['사과']}")

Counter({'사과': 3, '바나나': 2, '오렌지': 1})
'사과'의 개수: 3

2. sort와 sorted

list.sort(): 리스트 객체 자체를 제자리에서 정렬하며(in-place), 반환 값은 None입니다. 원본 리스트의 순서가 바뀝니다.
sorted(): 이터러블한 객체를 정렬한 후 새로운 정렬된 리스트를 반환합니다. 원본 객체는 변경되지 않습니다.

fruits = ['grape', 'blueberry', 'apple', 'banana']

# list.sort() (제자리 정렬)
fruits.sort()
print(f"sort() 후: {fruits}")

# sorted() (새로운 리스트 반환)
data = (5, 2, 8, 1, 9)
sorted_data = sorted(data)
print(f"sorted() 후 (원본 튜플): {data}")
print(f"sorted() 후 (새 리스트): {sorted_data}")

3. lamba

lambda는 한 줄로 간단한 함수를 정의할 때 사용되는 익명 함수 생성 키워드입니다. sort나 sorted의 key 매개변수와 함께 자주 사용됩니다.

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

# lambda를 사용하여 나이(튜플의 세 번째 요소, 인덱스 2) 기준 정렬
# sorted 함수는 key 매개변수에 함수를 받아 각 요소에 적용한 후 그 반환값으로 정렬합니다.
sorted_students = sorted(students, key=lambda student: student[2])

print(f"나이 기준 정렬: {sorted_students}")

4. functools.cmp_to_key

functools.cmp_to_key는 두 개의 인자를 받아 비교 결과를 반환하는 기존 스타일의 비교 함수(comparator, 예: a > b이면 양수 반환)를 최신 파이썬의 key 매개변수가 요구하는 함수로 변환해 줍니다. 파이썬 3에서 비교 함수가 key 함수로 대체되면서 하위 호환성을 위해 제공됩니다.

import functools

def compare_len(a, b):
    """
    문자열 길이를 기준으로 비교하는 함수
    a가 b보다 길면 양수, 같으면 0, 짧으면 음수 반환
    """
    if len(a) < len(b):
        return -1
    elif len(a) > len(b):
        return 1
    else:
        return 0

words = ['apple', 'kiwi', 'banana', 'fig']

# cmp_to_key를 사용하여 비교 함수를 key 함수로 변환
sorted_words = sorted(words, key=functools.cmp_to_key(compare_len))

print(f"길이 기준 정렬 (cmp_to_key 사용): {sorted_words}")

# 참고: 동일한 기능을 key=len 으로 더 간단하게 구현할 수 있습니다.
sorted_words_simple = sorted(words, key=len)
print(f"길이 기준 정렬 (key=len 사용): {sorted_words_simple}")

5. zip

zip은 여러 개의 이터러블 객체들을 인자로 받아 각 이터러블의 동일한 인덱스에 있는 요소들을 묶어 튜플 형태로 반환하는 이터레이터를 생성합니다. 길이가 가장 짧은 이터러블의 길이에 맞춰 요소 묶기가 종료됩니다.

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
jobs = ['Engineer', 'Manager', 'Designer', 'CEO'] # 더 긴 리스트

# zip으로 묶기 (가장 짧은 리스트인 ages 기준 3개만 묶임)
zipped_data = zip(names, ages, jobs)

# zip 객체는 이터레이터이므로 리스트로 변환하여 확인
print(f"zip 결과: {list(zipped_data)}")

# zip 결과로 딕셔너리 만들기
names_short = ['Alice', 'Bob']
ages_short = [25, 30]
print(f"zip으로 딕셔너리 생성: {dict(zip(names_short, ages_short))}")

6. map

map은 첫 번째 인자로 함수를, 두 번째 인자로 이터러블 객체를 받아 해당 이터러블의 모든 요소에 함수를 적용한 결과들을 반환하는 이터레이터를 생성합니다.

# 각 숫자를 제곱하는 함수
def square(n):
    return n * n

numbers = [1, 2, 3, 4, 5]

# map 함수 사용: 리스트의 모든 요소에 square 함수 적용
mapped_data = map(square, numbers)

# map 객체는 이터레이터이므로 리스트로 변환하여 확인
print(f"map 결과 (제곱): {list(mapped_data)}")

# lambda를 사용하여 간단한 변환도 가능
string_numbers = ['10', '20', '30']
# 각 문자열을 정수로 변환
int_numbers = list(map(lambda s: int(s) + 1, string_numbers))
print(f"map 결과 (문자열->정수+1): {int_numbers}")

7. min, max

min: 전달된 인자들 또는 이터러블 객체 내에서 가장 작은(최소) 값을 반환합니다. 문자열이나 사용자 정의 객체의 경우, 사전 순서나 정의된 비교 기준에 따라 동작하며, key 매개변수를 사용해 비교 기준을 지정할 수 있습니다.

# 여러 개의 인자 중에서 최솟값 찾기
result_args = min(10, 5, 20, 3, 50)
print(f"인자 중 최솟값: {result_args}")

# 리스트(이터러블)에서 최솟값 찾기
numbers =
result_list = min(numbers)
print(f"리스트 내 최솟값: {result_list}")

# key 매개변수 사용 (문자열 길이 기준 최솟값)
words = ['apple', 'fig', 'banana', 'kiwi']
# 길이가 가장 짧은 'fig' 또는 'kiwi' 중 사전순으로 빠른 'fig' 반환
result_key = min(words, key=len)
print(f"길이 기준 최솟값: {result_key}")

max: 전달된 인자들 또는 이터러블 객체 내에서 가장 큰(최대) 값을 반환합니다. min 함수와 마찬가지로 key 매개변수를 사용하여 비교 기준을 지정할 수 있습니다.

# 여러 개의 인자 중에서 최댓값 찾기
result_args = max(10, 5, 20, 3, 50)
print(f"인자 중 최댓값: {result_args}")

# 리스트(이터러블)에서 최댓값 찾기
numbers =
result_list = max(numbers)
print(f"리스트 내 최댓값: {result_list}")

# key 매개변수 사용 (문자열 길이 기준 최댓값)
words = ['apple', 'fig', 'banana', 'kiwi']
# 길이가 가장 긴 'banana' 반환
result_key = max(words, key=len)
print(f"길이 기준 최댓값: {result_key}")

8. 조합 문제: itertools.permutations

itertools.permutations는 이터러블(예: 리스트, 문자열)에서 r개의 항목을 선택하여 가능한 모든 순서쌍(순열)을 생성하는 이터레이터를 반환합니다. 순서가 중요할 때(예: 비밀번호 경우의 수 계산 등) 사용되며, r을 지정하지 않으면 이터러블의 모든 요소를 사용한 순열을 만듭니다.

import itertools

# 리스트에서 3개의 요소를 사용하여 모든 순열 생성
data = [1, 2, 3]
all_permutations = itertools.permutations(data)

print(f"모든 순열 (r=None): {list(all_permutations)}")

print("-" * 20)

# 리스트에서 2개의 요소를 선택하여 순열 생성
data_chars = ['A', 'B', 'C', 'D']
permutations_r2 = itertools.permutations(data_chars, 2)

print(f"2개 선택 순열 (r=2): {list(permutations_r2)}")

모든 순열 (r=None): [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
--------------------
2개 선택 순열 (r=2): [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'A'), ('B', 'C'), ('B', 'D'), ('C', 'A'), ('C', 'B'), ('C', 'D'), ('D', 'A'), ('D', 'B'), ('D', 'C')]

9. 큐 문제: collection.deque의 append, popleft

collections.deque는 양방향에서 빠르게 추가 및 제거가 가능한 자료구조입니다. append와 popleft 메서드를 통해 덱의 양쪽 끝을 효율적으로 관리할 수 있습니다.

append: deque의 오른쪽 끝(rear)에 새로운 요소를 추가합니다. 일반 리스트의 append()와 동일하게 동작하며, O(1) 시간 복잡도를 가집니다.
popleft: deque의 왼쪽 끝(front)에 있는 요소를 제거하고 해당 요소를 반환합니다. 이 작업 역시 O(1) 시간 복잡도를 가지므로, 선입선출(FIFO) 큐를 구현할 때 매우 효율적입니다.

from collections import deque

# deque 객체 생성
dq = deque()

print(f"초기 덱: {dq}")

# append 예시: 오른쪽에 요소 추가
dq.append('A')
dq.append('B')
dq.append('C')
print(f"append 후 덱: {dq}")

# popleft 예시: 왼쪽에서 요소 제거 및 반환
item1 = dq.popleft()
print(f"popleft로 제거된 항목: {item1}")
print(f"popleft 후 덱: {dq}")

item2 = dq.popleft()
print(f"popleft로 제거된 항목: {item2}")
print(f"popleft 후 덱: {dq}")

초기 덱: deque([])
append 후 덱: deque(['A', 'B', 'C'])
popleft로 제거된 항목: A
popleft 후 덱: deque(['B', 'C'])
popleft로 제거된 항목: B
popleft 후 덱: deque(['C'])

10. any와 all

any와 all은 파이썬의 내장 함수로, 이터러블(iterable) 객체의 요소들이 특정 조건을 만족하는지 여부를 확인할 때 사용됩니다.

any: 이터러블 내의 최소한 하나의 요소라도 참(True)으로 평가되면 True를 반환하며, 모든 요소가 거짓일 때만 False를 반환합니다.

# 숫자 리스트 (0은 False로 평가됨)
numbers =

# 0이 아닌 값이 하나라도 있으므로 True 반환
result_any_true = any(numbers)
print(f"any({numbers}): {result_any_true}")

# 모든 요소가 0 또는 빈 값인 경우 (모두 False)
empty_list =
result_any_false = any(empty_list)
print(f"any({empty_list}): {result_any_false}")

# 조건식을 map/제너레이터와 함께 사용
# 10보다 큰 수가 하나라도 있는지 확인
result_condition = any(num > 10 for num in numbers)
print(f"any(num > 10 for num in numbers): {result_condition}")

all: 이터러블 내의 모든 요소가 참(True)으로 평가될 때만 True를 반환하며, 하나의 요소라도 거짓이면 False를 반환합니다.

# 예시 코드

# 모든 요소가 참인 리스트
true_list =
result_all_true = all(true_list)
print(f"all({true_list}): {result_all_true}")

# 하나라도 거짓(False)인 요소가 있는 리스트
mixed_list = [True, False, True, True]
result_all_false = all(mixed_list)
print(f"all({mixed_list}): {result_all_false}")

# 조건식을 map/제너레이터와 함께 사용
# 모든 수가 5보다 큰지 확인
numbers =
result_condition = all(num > 5 for num in numbers)
print(f"all(num > 5 for num in numbers): {result_condition}")

11. 최소 힙 문제: heapq의 heapify, heappop, heappush

heapq 모듈은 파이썬에서 힙(heap) 자료구조, 특히 최소 힙(min-heap)을 구현할 때 사용되는 표준 라이브러리입니다. heapify, heappush, heappop은 힙의 핵심 연산을 수행하는 함수입니다.

heapify: 기존에 요소들이 들어있는 일반 리스트를 인플레이스(in-place) 방식으로 최소 힙 구조로 변환합니다. O(n) 시간 복잡도로 리스트를 힙 속성이 만족되도록 재정렬합니다.
heappush: 힙에 새로운 요소를 효율적으로 삽입합니다. 삽입 후에도 힙 속성을 유지하도록 자동으로 요소를 재배치하며, O(log n) 시간 복잡도를 가집니다.
heappop: 힙에서 가장 작은(최소) 요소를 제거하고 반환합니다. 루트(root) 노드를 제거한 후, 나머지 요소들을 재정렬하여 힙 속성을 유지하며, O(log n) 시간 복잡도를 가집니다.

import heapq

# 1. heapify 예시: 일반 리스트를 힙으로 변환
data =
heapq.heapify(data)
print(f"heapify 후 힙: {data}")

# 2. heappush 예시: 새로운 요소 삽입
heapq.heappush(data, 1)
print(f"heappush(1) 후 힙: {data}")
heapq.heappush(data, 100)
print(f"heappush(100) 후 힙: {data}")

# 3. heappop 예시: 가장 작은 요소 제거 및 반환
min_item1 = heapq.heappop(data)
print(f"heappop으로 제거된 최소값: {min_item1}")
print(f"heappop 후 힙: {data}")

min_item2 = heapq.heappop(data)
print(f"heappop으로 제거된 최소값: {min_item2}")
print(f"heappop 후 힙: {data}")

heapify 후 힙: [1, 2, 4, 8, 3, 9, 7]
heappush(1) 후 힙: [1, 1, 4, 8, 3, 9, 7, 2]
heappush(100) 후 힙: [1, 1, 4, 8, 3, 9, 7, 2, 100]
heappop으로 제거된 최소값: 1
heappop 후 힙: [1, 2, 4, 8, 3, 9, 7, 100]
heappop으로 제거된 최소값: 1
heappop 후 힙: [2, 3, 4, 8, 100, 9, 7]

LangChain Expression Language(LCEL) 사용 방법 및 예시

dhlee-note — Sun, 7 Dec 2025 17:49:42 +0900

LangChain Expression Language(LCEL)은 LangChain에서 여러 컴포넌트(prompt, LLM, 파서, 후처리 함수 등)를 “파이프(pipe)” 형태로 간결하게 연결해 주는 표현 방식입니다. 2023년 하반기부터 LangChain에서 체인(chain) 구성 방식에서 LCEL을 활용하는 경향이 커지고 있습니다.

이번 포스팅에서는 LCEL의 주요 개념과 예제에 대해서 정리해보도록 하겠습니다.

주요 개념

Runnable: 입력(input)을 받아 출력(output)을 내는 구성 요소
RunnableSequence: 여러 Runnable을 직렬(sequence) 로 연결한 것
RunnableLambda: 단순한 Python 함수를 Runnable로 감싸서 파이프에서 쓸 수 있게 함
RunnableParallel: 여러 Runnable을 병렬(parallel)으로 실행하고, 결과를 병합(예: 딕셔너리 구조)해서 넘김
RunnablePassthrough: 현재 입력 값을 “넘겨주는(pass through)” 역할. 병렬 구조에서 입력을 일부 다음 단계에서도 쓰고 싶을 때 유용
| 연산자 (파이프): Runnable들을 직렬(sequence)로 연결. 입력 → 컴포넌트1 → 컴포넌트2 → … → 출력 흐름이 생김
invoke / batch / stream
- invoke(input) : 단일 입력에 대해 동기(synchronous) 실행
- batch([input1, input2, …]) : 여러 입력을 한 번에 처리
- stream(input) : 출력이 길거나 점진적으로 생성되는 경우 청크 단위로 결과 반환

예제 및 실행 결과

Runnable

LCEL에서 모든 구성 요소는 Runnable 인터페이스를 따릅니다.

아래 예제 코드에 등장하는 prompt, llm, parser 모두 Runnable입니다.

from dotenv import load_dotenv
import os
import openai

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Runnable 예시: Prompt, LLM, Parser 모두 Runnable
prompt = ChatPromptTemplate.from_template("Translate to English: {text}")
llm = ChatOpenAI(model="gpt-3.5-turbo")
parser = StrOutputParser()

# 체인 구성
chain = prompt | llm | parser

print(chain.invoke({"text": "안녕하세요"}))

Hello

RunnableSequence

RunnableSequence는 여러 Runnable을 직렬(sequence) 로 연결하는 방법을 코드로 직접 정의하는 방식입니다.
보통은 a | b | c 같은 파이프(|) 연산자를 더 자주 쓰지만, 내부적으로는 RunnableSequence를 생성합니다.

위의 예제 코드를 RunnableSequence로 변경하면 아래와 같습니다.

from dotenv import load_dotenv
import os
import openai

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.runnables import RunnableSequence

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Runnable 예시: Prompt, LLM, Parser 모두 Runnable
prompt = ChatPromptTemplate.from_template("Translate to English: {text}")
llm = ChatOpenAI(model="gpt-3.5-turbo")
parser = StrOutputParser()

# RunnableSequence로 체인 구성
chain = RunnableSequence(first=prompt, last=llm | parser)

# 실행
print(chain.invoke({"text": "안녕하세요"}))

Hello

RunnableLambda

직접 만든 Python 함수를 LCEL 파이프라인에 포함하려면 RunnableLambda를 씁니다.

일반 Python 함수를 체인 속에 넣을 때 유용합니다.

from langchain_core.runnables import RunnableLambda

# 간단한 함수
def double_number(x: int) -> int:
    return x * 2

# Runnable로 감싸기
double = RunnableLambda(double_number)

print(double.invoke(5))

RunnableParallel

여러 Runnable을 동시에 실행하고, 결과를 딕셔너리 형태로 모아줍니다.

입력값을 동시에 여러 방식으로 가공하고 싶을 때 사용합니다.

from langchain_core.runnables import RunnableParallel, RunnableLambda

# 간단한 Runnable 두 개
add_one = RunnableLambda(lambda x: x + 1)
square = RunnableLambda(lambda x: x * x)

# 병렬 실행: 같은 입력 x에 대해 add_one과 square 동시에 실행
parallel = RunnableParallel({
    "plus_one": add_one,
    "squared": square
})

print(parallel.invoke(3))

{'plus_one': 4, 'squared': 9}

RunnableParallel를 사용하지 않고 병렬적으로 사용하는 방법도 있습니다.

from langchain_core.runnables import RunnableParallel, RunnableLambda

# 간단한 Runnable 두 개
add_one = RunnableLambda(lambda x: x + 1)
square = RunnableLambda(lambda x: x * x)

# 병렬 실행: 같은 입력 x에 대해 add_one과 square 동시에 실행
parallel = {
    "plus_one": add_one,
    "squared": square
}

print(parallel.invoke(3))

RunnablePassthrough

입력 dict 전체를 출력으로 보존합니다.
특히 병렬 실행할 때, 원본 입력을 결과에 같이 포함시키고 싶을 때 자주 사용합니다.

from langchain_core.runnables import RunnablePassthrough, RunnableParallel, RunnableLambda

# 입력값을 두 배로 만드는 Runnable
double = RunnableLambda(lambda x: x * 2)

# 원본 입력과 가공된 값을 모두 반환
chain = RunnableParallel({
    "original": RunnablePassthrough(),
    "doubled": double
})

print(chain.invoke(7))

주의 사항

입출력 형태(shape) 주의
각 Runnable이 어떤 입력을 받고 어떤 출력을 내는지 명확히 해야 downstream 에러를 줄일 수 있습니다.
타입 힌트나 input_schema, output_schema를 활용하면 안정성이 높아집니다.
병렬 작업 시 비용/지연 고려
병렬 실행은 네트워크 호출 수를 늘리므로 latency 증가나 rate limit 문제를 유발할 수 있습니다.
스트리밍 지원 여부 확인
.stream()/.astream() 사용 시, 모델이 스트리밍을 지원하는지 확인해야 합니다.
비동기 실행
서버 환경에서는 .ainvoke(), .abatch() 같은 비동기 메서드를 적극 활용하는 것이 좋습니다.
디버깅 & 추적
간단히는 RunnableLambda(lambda x: print(x) or x) 같은 방식으로 중간 출력 로깅이 가능합니다.
본격적인 추적은 LangSmith 같은 툴과 연동해 각 단계의 입력/출력을 살펴보는 것이 좋습니다.
조건 분기 / Fallback
LCEL은 조건에 따라 다른 체인을 실행하거나, 실패 시 대체 경로(fallback)를 두는 방식도 지원합니다.
(예: 입력이 영어면 그대로 출력, 아니면 번역 LLM 호출)
버전 호환성
LCEL API는 langchain-core 버전별로 일부 차이가 있을 수 있으므로, 공식 문서의 Cheat Sheet 를 반드시 참고하세요.

베이지안 정리(Bayes' theorem)

dhlee-note — Sun, 7 Dec 2025 17:38:05 +0900

베이지안 정리(Bayes' theorem)는 사전 확률(prior)을 관찰된 데이터 정보를 반영해 사후 확률(posterior)로 갱신하는 규칙입니다.

$$ P(A\mid B)=\frac{P(B\mid A)P(A)}{P(B)} $$

$ P(A \mid B) $: 사건 B가 일어났다는 정보를 알고 있을 때, A가 일어났을 확률(사후 확률)
$ P(B \mid A) $: A가 참일 때 B가 관측될 가능도(우도, likelihood)
$ P(A) $: 관측하기 전에 A가 일어날 것으로 믿는 A에 대한 사전 확률(prior)
$ P(B) $: B가 관측될 전체 확률로, 사후 확률이 전체적으로 1이 되도록 만드는 역할을 함(evidence, 정규화 상수)

예제

어떤 질병의 발병률(사전 확률)은 1% (=0.01)이며, 검사 특성은 다음과 같습니다.

민감도(sensitivity): 질병이 있으면 양성 → $ P(+ \mid \text{Disease}) = 0.99 $
위양성률(false positive rate): 질병이 없는데 양성 → $ P(+ \mid \text{No\ Disease}) = 0.05 $

우리가 알고 싶은 값은 $ P(\text{Disease} \mid +) $ 입니다.

즉, 검사에서 양성이 나왔을 때 실제로 질병일 확률을 알아내야 합니다.

1. 베이지안 정리 적용

베이지안 정리에 따르면, 다은과 같습니다.

$$ P(\text{Disease} \mid +)= \frac{P(+ \mid \text{Disease}) \, P(\text{Disease})}{P(+)} $$

사전 확률(prior): $ P(\text{Disease}) = 0.01 $
우도(likelihood): $ P(+ \mid \text{Disease}) = 0.99 $

2. Evidence 계산: 양성이 나올 전체 확률 P(+)

양성(+)이 나올 수 있는 경우는 두 가지 입니다.

질병이 있는데 양성: $ 0.01 \times 0.99 $
질병이 없는데 양성(위양성): $ 0.99 \times 0.05 $

따라서 전체 양성 확률은 다음과 같습니다.

$$ P(+) = 0.01 \cdot 0.99 + 0.99 \cdot 0.05 $$

여기서 두 번째 항이 더 큰 이유는 질병이 없을 확률(99%)이 매우 높기 때문입니다.

즉, 희귀한 질병에서는 위양성이 전체 결과에 큰 비중을 차지합니다.

3. 사후 확률 계산

이제 베이지안 정리에 대입을 합니다.

$$ P(\text{Disease}\mid +) = \frac{0.99 \times 0.01}{0.01 \times 0.99 + 0.99 \times 0.05} $$

수치를 정리하면 다음과 같습니다.

분자: 0.0099
Evidence: 약 0.0594

따라서, 검사에서 양성이 나왔을 때 실제 질병일 확률은 약 16.7% 입니다.

$$ P(\text{Disease}\mid +) \approx \frac{0.0099}{0.0594} \approx 0.1667 $$

즉, “99% 정확한 검사”라고 해도, 질병의 발병률이 매우 낮다면 양성 결과가 나온 사람의 대부분은 실제 환자가 아닐 수 있습니다.

이는 베이지안 정리가 실생활에서 왜 중요한지를 잘 보여주는 대표적인 사례입니다.

주성분 분석(PCA, Principal Component Analysis)

dhlee-note — Tue, 2 Dec 2025 15:00:33 +0900

데이터 분석과 머신러닝을 하다 보면 공통적으로 마주치는 문제가 있습니다.
바로 차원의 저주(Curse of Dimensionality)입니다.
특징(Feature)의 수가 많아질수록 모델의 계산 복잡도는 증가하고, 시각화와 해석 또한 어려워집니다.

이 문제를 해결하는 대표적인 방법이 바로 주성분 분석(PCA, Principal Component Analysis)입니다.
PCA는 원본 데이터의 정보를 최대한 유지하면서 차원을 축소해 주는 강력한 기법으로, 데이터 전처리와 탐색적 분석 과정에서 매우 자주 활용됩니다.

PCA란?

PCA는 고차원 데이터를 보다 적은 차원으로 투영(projection)하여 데이터의 분산을 가장 크게 보존하는 새로운 축(주성분, Principal Components)을 찾는 방법입니다.

쉽게 말해:

원본 특징들이 서로 상관관계가 있다면 → PCA는 이를 서로 직교하는(orthogonal) 새 축으로 변환한다.
변환된 축을 따라 데이터를 재표현하면 → 더 적은 차원으로도 데이터 특성을 잘 유지할 수 있다.

즉, 정보 손실은 최소화하면서 차원을 최대한 줄이는 방법입니다.

PCA의 장점

데이터 압축
차원이 매우 큰 데이터(예: 이미지, 유전자 데이터)를 다룰 때 유리합니다.
적은 개수의 특징만으로도 전체 데이터를 효과적으로 표현할 수 있습니다.
시각화
고차원 데이터를 2D, 3D 공간으로 축소하면 데이터의 구조를 시각적으로 이해하기 쉬워집니다.
예: MNIST 숫자 이미지 → PCA 적용 → 2D 산점도 시각화
노이즈 제거
분산이 거의 없는 성분들은 실제 정보보다는 노이즈일 가능성이 높습니다.
이를 제거하면 더 명확한 패턴을 얻을 수 있습니다.
모델 학습 성능 향상
고차원 데이터는 과적합을 유발하기 쉽습니다.
PCA로 차원을 줄이면 모델의 일반화 성능이 향상되는 경우가 많습니다.

PCA의 동작 과정

1. 데이터 표준화

특징의 스케일이 다르면 PCA 결과가 왜곡될 수 있으므로 평균 0, 분산 1로 표준화합니다.

2. 공분산 행렬 계산

특징 간 상관관계를 나타내는 공분산 행렬을 만듭니다.

3. 고유값(Eigenvalue)과 고유벡터(Eigenvector) 계산

고유값: 해당 성분이 설명하는 ‘분산의 크기’
고유벡터: 새로운 좌표축(주성분)

4. 고유값이 큰 순으로 주성분을 정렬

분산을 많이 보존하는 축부터 선택합니다.

5. 선택된 주성분으로 데이터 변환

원본 데이터를 주성분 축으로 투영하여 새로운 표현을 얻습니다.

PCA 결과 해석 방법

1. 설명 분산 비율(Explained Variance Ratio)

각 주성분이 데이터의 변동성을 얼마나 설명하는지 보여줍니다.

주성분	설명 분산 비율
PC1	70%
PC2	20%
PC3	5%

→ PC1 + PC2 만으로 전체 정보의 90%를 설명할 수 있다는 의미입니다.

2. Scree Plot (스크리 플롯)

고유값을 큰 순서대로 표시한 그래프입니다.
일반적으로 그래프에서 꺾이는 지점(Elbow Point)까지의 성분을 선택합니다.

PCA 예제 (Python, Scikit-Learn)

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# 1. 데이터 로드
data = load_iris()
X = data.data

# 2. 표준화
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. PCA 변환 (2차원)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# 4. 시각화
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=data.target)
plt.xlabel("PC1")
plt.ylabel("PC2")
plt.title("PCA on Iris Dataset")
plt.show()

PCA의 한계점

1. 선형성 가정

PCA는 선형 관계만 고려합니다.
비선형 구조는 제대로 포착하지 못합니다.
→ 대안: Kernel PCA, t-SNE, UMAP

2. 해석이 어려움

주성분은 원본 특징의 선형 조합이기 때문에 “PC1 값이 높다는 건 어떤 의미인가?” 같은 질문에 명확히 답하기 어렵습니다.

3. 스케일에 민감

표준화를 하지 않으면 PCA 결과가 크게 왜곡됩니다.

PCA 활용 사례

데이터 차원이 너무 크고 시각화가 필요할 때
상관관계가 높은 변수가 많을 때
노이즈를 줄이고 데이터 패턴을 더 선명하게 보고 싶을 때
모델 학습 속도를 높이거나 과적합을 줄이고 싶을 때

딥러닝이나 이미지 분석에서도 PCA는 전처리 또는 특징 추출 단계에서 널리 사용됩니다.

PCA는 단순하면서도 매우 강력한 차원 축소 기법입니다.
데이터의 구조를 파악하고, 모델의 성능을 높이고, 시각화와 노이즈 제거까지 가능한 다재다능한 도구죠.

차원이 많은 데이터를 다루고 있다면, PCA를 한 번 적용해 보는 것만으로도 새로운 통찰을 얻을 수 있을 것입니다.

dhlee-note

Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity 논문 리뷰

연구 배경 및 목적

관련 연구

제안 방안

실험

결과

결론

ROUGE 스코어: 요약/생성 모델 평가 지표

트리(Tree)와 그래프(Graph)의 차이점 비교

그래프(Graph) 자료구조 개념 정리 + Python 구현

그래프(Graph)란 무엇인가?

그래프의 기본 용어

그래프의 종류

그래프 구현 방식

파이썬(Python) 예제 코드

트리(Tree) 자료구조 개념 정리 + Python 구현

트리(Tree)란 무엇인가?

기본 용어 정리

트리의 중요성

트리의 종류

파이썬(Python) 예제 코드

퀵 정렬(Quick Sort) 개념 및 동작 과정 + Python 예제 코드

퀵 정렬(Quick Sort)이란?

동작 방식

동작 예시

파이썬(Python) 예제 코드

퀵 정렬을 잘 사용하기 위한 팁

코딩 테스트에서 자주 사용하는 Python 내장 함수 및 라이브러리

LangChain Expression Language(LCEL) 사용 방법 및 예시

주요 개념

예제 및 실행 결과

주의 사항

베이지안 정리(Bayes' theorem)

주성분 분석(PCA, Principal Component Analysis)

PCA란?

PCA의 장점

PCA의 동작 과정

PCA 결과 해석 방법

PCA 예제 (Python, Scikit-Learn)

PCA의 한계점

PCA 활용 사례