seungbye

FRIT: Using Causal Importance to Improve Chain-of-Thought Faithfulness [논문 리뷰]

seungbye — Fri, 14 Aug 2026 04:12:50 +0900

Abstract

CoT는 복잡한 문제에서 LLM의 성능을 높이지만, 모델이 출력한 reasoning step이 실제로 final answer에 영향을 주지 않는 경우가 존재한다.

기존 연구는 “CoT가 faithful 한가?” 에 집중했지만 “모델 자체를 더 faithful하게 만들려면 어떻게 학습해야 하는가?” 에 대한 scalable한 방법은 상대적으로 부족했다.

FRIT 제안

논문은 **Faithful Reasoning via Intervention Training (FRIT)**을 제안한다.

모델이 생성한 CoT의 reasoning step에 intervention
해당 step이 final answer에 실제 영향을 주는지 측정
이를 이용해 faithful / unfaithful CoT pair 생성
DPO를 사용해 faithful reasoning을 선호하도록 학습

논문은 이를 human supervision 없이 faithfulness를 향상시키는 scalable training method로 제시한다

Introduction

Chain-of-Thought는 모델이 문제를 풀면서 intermediate reasoning을 출력하게 하는 방법이다.
최근 연구에서는 모델이 출력한 reasoning이 final answer에 실제로 영향을 미치지 않는 경우가 발견되었다
당시 faithfulness를 개선하는 대표 방법으로 FRODO가 존재했지만 사람의 intervention/filtering 필요, 10B 미만 모델에 제한, fine-tuning data를 생성하기 위해 여러 모델 필요 등의 복잡성이 있다고 설명한다.
그리고 대부분의 기존 연구는 faithfulness를 개선하기보다는 측정하는 데 집중했다고 지적한다.

FRIT의 아이디어

1. Automated Causal Intervention

각 reasoning step을 실제로 바꿔보면서 이 step이 final answer에 영향을 주는가를 측정한다.

2. Faithful / Unfaithful Pair 생성 + Training

Causal intervention 결과(faithful cot, unfaithful cot)를 생성한 후 DPO로 모델을 학습한다. 논문의 Figure 2가 이 전체 흐름을 보여준다. 원래 CoT의 한 step을 수정하고 continuation을 다시 생성한 뒤 answer가 바뀌는지 검사하고, 중요하지 않은 step은 그 위치부터 삭제해 reasoning을 재생성한다.

Methodology

Creating examples of faithful reasoning
1. intervention
  1. Wikidata facts 250,000 + simple arithmetic facts 100,000
  2. Embedding + k means clustering
  3. Step Embedding → 가장 비슷한 cluster 의 median similarity fact 선택 → 원래 step 문체로 rewrite
  4. final answer가 바뀌면 Casually important
2. Faithful CoT 생성
  1. causally unimportant한 reasoning step 뒤로 전부 제거
  2. 그 후 reasoning을 재생성
  3. 새로 생성된 Answer가 원래 Answer와 같아야 하며 다를 경우 다시 생성
  4. 반복하며 모든 reasoning step이 casual importance를 가지도록 trace 수정
3. CoT 구분
  - Preliminary CoTS1 → S2 → S3 → Answer A
  - 논문에서는 4-shot CoT prompting으로 생성한다
  - 처음 모델이 생성한 원본 reasoning
  - Faithful CoTS1* → S2* → S3* → Answer A
  - 각 step이 final answer에 causal importance를 가진다
  - Intervention + augmentation을 반복해서 만든 reasoning
  - Unfaithful CoTS1 → X → S3 → Answer A
  - 중요한 것은 Faithful CoT와 Unfaithful CoT의 Final Answer는 동일
  - Preliminary CoT의 랜덤한 reasoning step 하나를 irrelevant fact로 교체해서 만듦
Training
1. DPO data 생성
  1. chosen
  2. Rejected
2. Training Iteration
  1. 480개의 prompts 선택 → pair 생성 → DPO 1epoch → Model update
  2. 3번 반복

Results

사용 모델

Qwen3-8B
Mistral-7B-v0.1

Training Dataset

GSM8K
SVAMP
StrategyQA
CommonsenseQA
ASDiv

Evaluation Dataset

GSM8K
- Qwen3-8B
  - Accuracy: 91.4 → 96.0 (+4.6%p)
  - CoT Faithfulness: 32.9 → 33.6 (+0.7%p)
  - Traditional Faithfulness: 8.9 → 10.2 (+1.3%p)
- Mistral-7B
  - Accuracy: 35.0 → 42.6 (+7.6%p)
  - CoT Faithfulness: 63.2 → 66.6 (+3.4%p)
  - Traditional Faithfulness: 24.1 → 25.4 (+1.3%p)
SVAMP
- Qwen3-8B
  - Accuracy: 95.5 → 96.0 (+0.5%p)
  - CoT Faithfulness: 26.9 → 27.3 (+0.5%p)
  - Traditional Faithfulness: 11.4 → 12.2 (+0.8%p)
- Mistral-7B
  - Accuracy: 82.0 → 82.2 (+0.2%p)
  - CoT Faithfulness: 43.9 → 45.4 (+1.5%p)
  - Traditional Faithfulness: 20.1 → 21.4 (+1.3%p)
StrategyQA
- Qwen3-8B
  - Accuracy: 44.0 → 50.0 (+6.0%p)
  - CoT Faithfulness: 39.6 → 41.1 (+1.5%p)
  - Traditional Faithfulness: 47.4 → 48.0 (+0.6%p)
- Mistral-7B
  - Accuracy: 27.4 → 29.8 (+2.4%p)
  - CoT Faithfulness: 83.9 → 84.7 (+0.8%p)
  - Traditional Faithfulness: 77.2 → 79.2 (+1.9%p)

Results에서 중요한 해석

DPO pair에서 Chosen answer = Rejected answer로 final answer가 동일 했음에도 불구하고 Accuracy가 상승했다. 저자들은 이를 CoT faithfulness를 높인 결과 accuracy 향상이 부수적으로 나타났을 가능성으로 해석한다. 다만 논문이 보여주는 것은 상관된 실험 결과이지, faithfulness 향상이 accuracy 상승의 원인임을 완전히 증명한 것은 아니라는 점은 구분해서 보는 게 좋다.

Limitations

FRIT의 가장 큰 단점으로 Reasoning step마다 intervention, generaion, answer 비교, regeneration 을 반복해야하기 때문에 일적인 DPO pair 생성보다 훨씬 비싸다

TO COT OR NOT TO COT? CHAIN-OF-THOUGHT HELPS MAINLY ON MATH AND SYMBOLIC REASONING(ARC) [논문재현]

seungbye — Thu, 9 Jul 2026 23:47:43 +0900

ARC-Challenge 데이터 셋 로드

from eval_datasets.types.arc import ARCDataset


arc_dataset = ARCDataset(
    path_or_url="allenai/ai2_arc",
    subset="ARC-Challenge",
    split="validation",
    use_llama_3_1_prompts=False,
)

print(
    "ARC-Challenge 데이터 개수:",
    len(arc_dataset),
)

공식 ARC Dataset은 문제와 선택지를 읽어 다음을 생성한다.

zs_cotless_messages: Direct Answer 프롬프트
zs_cot_messages: CoT 프롬프트
answerKey: 정답 선택지 문자
answer: 정답 선택지 내용

ARC 프롬프트 준비 함수

from copy import deepcopy


def prepare_arc_direct_messages(example):

    messages = deepcopy(
        example["zs_cotless_messages"]
    )

    if (
        len(messages) == 0
        or messages[-1]["role"] != "assistant"
    ):
        messages.append(
            {
                "role": "assistant",
                "content": "Answer: ",
            }
        )

    return messages


def prepare_arc_cot_messages(example):

    return deepcopy(
        example["zs_cot_messages"]
    )

GSM8K에서는 Direct prefix가 $\boxed{였지만, ARC는 객관식이므로 공식 코드가 사용하는 Answer: 를 넣는다.

Greedy 함수 정의

def generate_response(
    messages,
    max_new_tokens,
):
    """
    Qwen 모델로 greedy decoding을 수행한다.

    원 논문의 vLLM 설정:
    - temperature = 0
    - top_p = 1
    - rollout = 1

    Transformers 대응 설정:
    - do_sample = False
    - num_beams = 1
    """

    has_assistant_prefill = (
        len(messages) > 0
        and messages[-1]["role"] == "assistant"
    )

    if has_assistant_prefill:
        # 마지막 assistant 메시지 뒤를 이어서 생성
        prompt_text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            continue_final_message=True,
        )

        assistant_prefix = messages[-1]["content"]

    else:
        # 새로운 assistant 답변 시작
        prompt_text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True,
        )

        assistant_prefix = ""

    encoded = tokenizer(
        prompt_text,
        return_tensors="pt",
    )

    device = next(model.parameters()).device

    encoded = {
        key: value.to(device)
        for key, value in encoded.items()
    }

    input_length = encoded["input_ids"].shape[1]

    with torch.inference_mode():
        output_ids = model.generate(
            **encoded,

            max_new_tokens=max_new_tokens,

            # Greedy decoding
            do_sample=False,
            num_beams=1,

            eos_token_id=tokenizer.eos_token_id,
            pad_token_id=tokenizer.pad_token_id,

            use_cache=True,
        )

    # 입력 프롬프트를 제외하고 새로 생성한 부분만 가져옴
    generated_ids = output_ids[0, input_length:]

    continuation = tokenizer.decode(
        generated_ids,
        skip_special_tokens=True,
    ).strip()

    # Direct 조건은 '$\boxed{'가 입력에 포함돼 있었으므로
    # 평가를 위해 다시 앞에 붙여서 전체 응답을 복원
    return (
        assistant_prefix + continuation
    ).strip()

ARC 문제와 공식 프롬프트 확인

arc_example = arc_dataset[0]

print("question")
print(arc_example["question"])

print("\n choice")

for label, text in zip(
    arc_example["choices"]["label"],
    arc_example["choices"]["text"],
):
    print(f"{label}: {text}")

print("\n정답 문자:", arc_example["answerKey"])
print("정답 내용:", arc_example["answer"])


arc_direct_messages = (
    prepare_arc_direct_messages(
        arc_example
    )
)

arc_cot_messages = (
    prepare_arc_cot_messages(
        arc_example
    )
)


print("\n Direct message")

for message in arc_direct_messages:
    print(f"[{message['role']}]")
    print(message["content"])
    print()


print("CoT message")

for message in arc_cot_messages:
    print(f"[{message['role']}]")
    print(message["content"])
    print()

question
Juan and LaKeisha roll a few objects down a ramp. They want to see which object rolls the farthest. What should they do so they can repeat their investigation?

choice
A: Put the objects in groups.
B: Change the height of the ramp.
C: Choose different objects to roll.
D: Record the details of the investigation.

정답 문자: D
정답 내용: Record the details of the investigation.

Direct message
[system]
You are a helpful AI assistant that will answer reasoning questions. You will always say at the end "Answer: <Your Answer Letter Choice>". You must only pick one answer and you must end your response with "Answer: <Your Answer Letter Choice>" everytime!

[user]
Juan and LaKeisha roll a few objects down a ramp. They want to see which object rolls the farthest. What should they do so they can repeat their investigation?

( A ) Put the objects in groups.
( B ) Change the height of the ramp.
( C ) Choose different objects to roll.
( D ) Record the details of the investigation.

Only write the answer in the format: "Answer: <your answer>". You must always give an answer. You may only pick one answer choice, if you think multiple are correct only pick the one you think is best.

[assistant]
Answer:

CoT message
[system]
You are a helpful AI assistant that will answer reasoning questions. You may reason over the question but you will always say at the end "Answer: <Your Answer Letter Choice>". You must only pick one answer and you must end your response with "Answer: <Your Answer Letter Choice>" everytime!

[user]
Juan and LaKeisha roll a few objects down a ramp. They want to see which object rolls the farthest. What should they do so they can repeat their investigation?

( A ) Put the objects in groups.
( B ) Change the height of the ramp.
( C ) Choose different objects to roll.
( D ) Record the details of the investigation.

Think step by step before giving your final answer to the question. When you are ready to answer write the answer in the format: "Answer: <your answer>". You must always give an answer at the end. You may only pick one answer choice, if you think multiple are correct only pick the one you think is best.

ARC 전체 실험 함수 정의

from pathlib import Path
from time import perf_counter

import pandas as pd
from tqdm.auto import tqdm


def run_arc_experiment(
    dataset,
    num_samples,
    output_csv,
    direct_max_new_tokens=10,
    cot_max_new_tokens=1024,
):
    """
    동일한 ARC-Challenge 문제에 대해

    1. Zero-shot Direct Answer
    2. Zero-shot Chain-of-Thought

    를 실행하고 공식 ARC evaluator로 평가한다.
    """

    output_path = Path(output_csv)

    output_path.parent.mkdir(
        parents=True,
        exist_ok=True,
    )

    # 기존 결과가 있으면 이어서 실행
    if output_path.exists():
        previous_results = pd.read_csv(
            output_path
        )

        records = previous_results.to_dict(
            "records"
        )

        completed_indices = set(
            previous_results["index"]
            .astype(int)
            .tolist()
        )

        print(
            f"기존 ARC 결과 "
            f"{len(completed_indices)}개를 "
            f"불러왔습니다."
        )

    else:
        records = []
        completed_indices = set()

    target_count = min(
        num_samples,
        len(dataset),
    )

    for index in tqdm(
        range(target_count)
    ):

        if index in completed_indices:
            continue

        example = dataset[index]

        question = str(
            example.get(
                "question",
                "",
            )
        )

        gold_label = str(
            example.get(
                "answerKey",
                "",
            )
        )

        gold_answer = str(
            example.get(
                "answer",
                "",
            )
        )

        num_choices = len(
            example["choices"]["label"]
        )

        try:
            # -------------------------
            # 공식 프롬프트 준비
            # -------------------------
            direct_messages = (
                prepare_arc_direct_messages(
                    example
                )
            )

            cot_messages = (
                prepare_arc_cot_messages(
                    example
                )
            )

            # -------------------------
            # Direct 실행
            # -------------------------
            direct_start = perf_counter()

            direct_response = (
                generate_response(
                    direct_messages,
                    max_new_tokens=(
                        direct_max_new_tokens
                    ),
                )
            )

            direct_seconds = (
                perf_counter()
                - direct_start
            )

            direct_metric = (
                dataset.evaluate_response(
                    [direct_response],
                    example,
                )[0]
            )

            # -------------------------
            # CoT 실행
            # -------------------------
            cot_start = perf_counter()

            cot_response = (
                generate_response(
                    cot_messages,
                    max_new_tokens=(
                        cot_max_new_tokens
                    ),
                )
            )

            cot_seconds = (
                perf_counter()
                - cot_start
            )

            cot_metric = (
                dataset.evaluate_response(
                    [cot_response],
                    example,
                )[0]
            )

            # -------------------------
            # 출력 토큰 수
            # -------------------------
            direct_tokens = len(
                tokenizer.encode(
                    direct_response,
                    add_special_tokens=False,
                )
            )

            cot_tokens = len(
                tokenizer.encode(
                    cot_response,
                    add_special_tokens=False,
                )
            )

            direct_model_answer = (
                direct_metric.get(
                    "model_answer"
                )
            )

            cot_model_answer = (
                cot_metric.get(
                    "model_answer"
                )
            )

            direct_correct = bool(
                direct_metric.get(
                    "correct",
                    False,
                )
            )

            cot_correct = bool(
                cot_metric.get(
                    "correct",
                    False,
                )
            )

            direct_unparsable = (
                direct_model_answer is None
            )

            cot_unparsable = (
                cot_model_answer is None
            )

            # 원 논문 실행 스크립트는 객관식 답을
            # 추출하지 못하면 무작위 정답 확률을 점수로 사용
            direct_paper_score = (
                1 / num_choices
                if direct_unparsable
                else int(direct_correct)
            )

            cot_paper_score = (
                1 / num_choices
                if cot_unparsable
                else int(cot_correct)
            )

            record = {
                "dataset": "ARC-Challenge",
                "index": index,
                "question": question,

                "gold_label": gold_label,
                "gold_answer": gold_answer,

                "direct_model_answer": (
                    direct_model_answer
                ),
                "cot_model_answer": (
                    cot_model_answer
                ),

                "direct_correct": (
                    direct_correct
                ),
                "cot_correct": (
                    cot_correct
                ),

                "direct_paper_score": (
                    direct_paper_score
                ),
                "cot_paper_score": (
                    cot_paper_score
                ),

                "direct_unparsable": (
                    direct_unparsable
                ),
                "cot_unparsable": (
                    cot_unparsable
                ),

                "direct_output_tokens": (
                    direct_tokens
                ),
                "cot_output_tokens": (
                    cot_tokens
                ),

                "direct_seconds": (
                    direct_seconds
                ),
                "cot_seconds": (
                    cot_seconds
                ),

                "direct_response": (
                    direct_response
                ),
                "cot_response": (
                    cot_response
                ),

                "error": "",
            }

        except Exception as error:
            record = {
                "dataset": "ARC-Challenge",
                "index": index,
                "question": question,

                "gold_label": gold_label,
                "gold_answer": gold_answer,

                "direct_model_answer": None,
                "cot_model_answer": None,

                "direct_correct": False,
                "cot_correct": False,

                "direct_paper_score": 0,
                "cot_paper_score": 0,

                "direct_unparsable": True,
                "cot_unparsable": True,

                "direct_output_tokens": 0,
                "cot_output_tokens": 0,

                "direct_seconds": 0,
                "cot_seconds": 0,

                "direct_response": "",
                "cot_response": "",

                "error": repr(error),
            }

        records.append(record)

        # 문제 하나가 끝날 때마다 저장
        (
            pd.DataFrame(records)
            .sort_values("index")
            .to_csv(
                output_path,
                index=False,
                encoding="utf-8-sig",
            )
        )

    return (
        pd.DataFrame(records)
        .sort_values("index")
        .reset_index(drop=True)
    )

ARC 결과 요약 함수

from math import comb


def exact_mcnemar_pvalue(
    cot_only_correct,
    direct_only_correct,
):
    n = (
        cot_only_correct
        + direct_only_correct
    )

    if n == 0:
        return 1.0

    smaller = min(
        cot_only_correct,
        direct_only_correct,
    )

    one_tail = sum(
        comb(n, k) * (0.5 ** n)
        for k in range(
            smaller + 1
        )
    )

    return min(
        1.0,
        2 * one_tail,
    )


def boolean_series(series):
    """
    CSV를 다시 읽었을 때 문자열 True/False가
    들어오는 경우까지 안전하게 처리한다.
    """

    if series.dtype == bool:
        return series

    return (
        series.astype(str)
        .str.lower()
        .eq("true")
    )


def summarize_arc_results(results):
    valid = results[
        results["error"].fillna("") == ""
    ].copy()

    if len(valid) == 0:
        raise ValueError(
            "정상 완료된 ARC 결과가 없습니다."
        )

    direct_correct = boolean_series(
        valid["direct_correct"]
    )

    cot_correct = boolean_series(
        valid["cot_correct"]
    )

    both_correct = int(
        (
            direct_correct
            & cot_correct
        ).sum()
    )

    cot_only = int(
        (
            (~direct_correct)
            & cot_correct
        ).sum()
    )

    direct_only = int(
        (
            direct_correct
            & (~cot_correct)
        ).sum()
    )

    both_wrong = int(
        (
            (~direct_correct)
            & (~cot_correct)
        ).sum()
    )

    direct_accuracy = (
        direct_correct.mean()
    )

    cot_accuracy = (
        cot_correct.mean()
    )

    # 논문 스크립트 방식:
    # unparseable은 무작위 정답 확률 점수
    direct_paper_accuracy = (
        valid[
            "direct_paper_score"
        ].mean()
    )

    cot_paper_accuracy = (
        valid[
            "cot_paper_score"
        ].mean()
    )

    return pd.DataFrame(
        {
            "항목": [
                "정상 완료 문제 수",

                "Direct 공식 정확도",
                "CoT 공식 정확도",
                "공식 CoT-Direct 차이(%p)",

                "Direct 논문식 점수",
                "CoT 논문식 점수",
                "논문식 CoT-Direct 차이(%p)",

                "둘 다 정답",
                "CoT만 정답",
                "Direct만 정답",
                "둘 다 오답",

                "Direct 답 추출 실패율",
                "CoT 답 추출 실패율",

                "Direct 평균 출력 토큰",
                "CoT 평균 출력 토큰",

                "Direct 평균 생성 시간",
                "CoT 평균 생성 시간",

                "Exact McNemar p-value",
            ],
            "값": [
                len(valid),

                direct_accuracy,
                cot_accuracy,
                (
                    cot_accuracy
                    - direct_accuracy
                ) * 100,

                direct_paper_accuracy,
                cot_paper_accuracy,
                (
                    cot_paper_accuracy
                    - direct_paper_accuracy
                ) * 100,

                both_correct,
                cot_only,
                direct_only,
                both_wrong,

                boolean_series(
                    valid[
                        "direct_unparsable"
                    ]
                ).mean(),

                boolean_series(
                    valid[
                        "cot_unparsable"
                    ]
                ).mean(),

                valid[
                    "direct_output_tokens"
                ].mean(),

                valid[
                    "cot_output_tokens"
                ].mean(),

                valid[
                    "direct_seconds"
                ].mean(),

                valid[
                    "cot_seconds"
                ].mean(),

                exact_mcnemar_pvalue(
                    cot_only,
                    direct_only,
                ),
            ],
        }
    )

20문제 선행 실험

ARC_OUTPUT_FILE = (
    "results/"
    "qwen2_7b_arc_challenge_v1.csv"
)


arc_results = run_arc_experiment(
    dataset=arc_dataset,

    # 선행실험
    num_samples=20,

    output_csv=ARC_OUTPUT_FILE,

    # 공식 ARC 설정
    direct_max_new_tokens=10,
    cot_max_new_tokens=1024,
)


arc_results.head()

GSM8K Dataset 때와 마찬가지로 20문제를 먼저 선행 실험했다

항목	값
정상 완료 문제 수	20.000000
Direct 공식 정확도	0.800000
CoT 공식 정확도	0.750000
공식 CoT-Direct 차이(%p)	-5.000000
Direct 논문식 점수	0.800000
CoT 논문식 점수	0.750000
논문식 CoT-Direct 차이(%p)	-5.000000
둘 다 정답	15.000000
CoT만 정답	0.000000
Direct만 정답	1.000000
둘 다 오답	4.000000
Direct 답 추출 실패율	0.000000
CoT 답 추출 실패율	0.000000
Direct 평균 출력 토큰	6.750000
CoT 평균 출력 토큰	42.750000
Direct 평균 생성 시간	0.125494
CoT 평균 생성 시간	0.878873
Exact McNemar p-value	1.000000

이 결과를 보면 알 수 있듯이 20개의 Dataset에서는 오히려 CoT보다 Direct answering에서의 답변의 정확도가 더 좋았다. 논문에서 말한 CoT가 오히려 knowledge 분야에서는 크게 도움이 되지 않을 수 있다는 것을 보여준다

원문 재현

마지막으로 같은 CSV를 사용하여 전체 데이터셋으로 전체 validation까지 이어서 실행했다.

Direct answering과 CoT의 정확도에서는 거의 차이가 없지만 응답시간, 토큰 수에서 Direct answering이 압도적인 우세를 보여준다.

결과적으로 Qwen2-7B-Instruct를 대상으로 ARC-Challenge에서 Zero-shot Direct Answer와 Zero-shot CoT를 비교한 결과, Direct Answer의 정확도는 85.03%, CoT의 정확도는 86.05%로 나타났다.

CoT에 따른 정확도 향상은 약 1.02%p에 불과했다. 이는 동일 모델의 GSM8K 실험에서 관찰된 약 72%p의 향상과 크게 대조된다. 따라서 중간 계산이 필요한 수학 추론에서는 CoT가 성능을 크게 높이지만, 이미 학습된 지식을 회상하여 답할 수 있는 지식 중심 문제에서는 CoT의 추가 효과가 제한적인 것으로 나타났다. 또한 CoT는 정확도 향상이 작음에도 출력 토큰 수와 생성 시간을 증가시키므로, 지식 중심 과제에서는 비용 대비 효율이 낮다고 해석할 수 있다. 이러한 결과는 CoT의 효과가 과제 유형에 따라 달라지며 수학적,기호적 추론에 선택적으로 적용해야 한다는 원 논문의 핵심 주장을 방향적으로 뒷받침한다.

TO COT OR NOT TO COT? CHAIN-OF-THOUGHT HELPS MAINLY ON MATH AND SYMBOLIC REASONING(GSM8K) [논문 재현]

seungbye — Thu, 9 Jul 2026 00:36:52 +0900

mkdir -p ~/research
cd ~/research

git clone https://github.com/Zayne-sprague/To-CoT-or-not-to-CoT.git
cd To-CoT-or-not-to-CoT

원본 저장소는 Hugging Face 모델을 보통 vLLM 서버로 띄운 뒤 endpoint로 호출하도록 구성돼 있는데, 학교 Gpu 서버 환경에는 vLLM이 없어서 먼저 transformer로 로컬 모델 실행을 확인하고, 그다음 원본 코드에 연결하기로 했고 14개의 모델을 전부 실행하기엔 어려워서 논문에서 사용한 Qwen 2 대신 Qwen 2.5 7B를 대신 사용했음.

Qwen 2.5 7B 불러오기

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

MODEL_NAME = "Qwen/Qwen2-7B-Instruct"

print("tokenizer")

tokenizer = AutoTokenizer.from_pretrained(
    MODEL_NAME,
    use_fast=True,
)

print("model")

try:
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME,
        dtype=torch.bfloat16,
        device_map="auto",
        low_cpu_mem_usage=True,
        attn_implementation="sdpa",
    )
except TypeError:
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        low_cpu_mem_usage=True,
        attn_implementation="sdpa",
    )

model.eval()

print("f modle load")
print("model dtype:", model.dtype)
print("model device:", next(model.parameters()).device)

원 논문은 20개 데이터셋 × 14개 모델에 대해 Zero-shot/Few-shot과 Direct Answer/CoT를 비교했다. 모델 추론에는 vLLM과 greedy decoding을 사용했다. 이 전체 조합을 한 번에 따라 하면 실험량과 코드 수정 범위가 너무 커서 첫 실험에서는 다음만 유지했다.

모델 ⇒ Qwen2-7B-Instruct
데이터셋 ⇒ GSM8K(수학 추론에서 CoT 효과가 크다는 것이 논문에서의 주장이기 때문에 실험 파이프라인이 정상인지 확인 할 때 가장 명확한 차이를 기대할 수 있을 것이라 생각되어 선택함, 추후에 CommonsenseQA 같은 걸로도 실험을 통해 영역별 차이까지 볼 예정 )
조건 A ⇒ Zero-shot Direct Answer
조건 B ⇒ Zero-shot CoT
디코딩 ⇒ Greedy decoding
프롬프트 ⇒ 논문 공식 git의 프롬프트 그대로
정답 판정 ⇒ 논문 공식 git의 GSM8K evaluator 그대로

GSM8K 데이터셋 클래스 불러오기

from eval_datasets.types.gsm8k import GSM8KDataset
gsm8k_dataset = GSM8KDataset(
    variant="original",
    use_llama_3_1_prompts=False,
)
print("GSM8K 데이터 개수:", len(gsm8k_dataset))

Greedy 함수 생성

def generate_response(
    messages: list[dict[str, str]],
    max_new_tokens: int = 1024,
) -> str:
    
    # 마지막 메시지가 assistant이면
    # 새로운 assistant 메시지를 추가하지 않고 기존 문장을 이어서 생성
    has_assistant_prefill = (
        len(messages) > 0
        and messages[-1]["role"] == "assistant"
    )

    if has_assistant_prefill:
        prompt_text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            continue_final_message=True,
        )
    else:
        prompt_text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True,
        )

    encoded = tokenizer(
        prompt_text,
        return_tensors="pt",
    )

    device = next(model.parameters()).device

    encoded = {
        key: value.to(device)
        for key, value in encoded.items()
    }

    input_length = encoded["input_ids"].shape[1]

    with torch.inference_mode():
        output_ids = model.generate(
            **encoded,
            max_new_tokens=max_new_tokens,
            do_sample=False,
            eos_token_id=tokenizer.eos_token_id,
            pad_token_id=tokenizer.pad_token_id,
        )

    generated_ids = output_ids[0, input_length:]

    generated_text = tokenizer.decode(
        generated_ids,
        skip_special_tokens=True,
    ).strip()

    # assistant prefill이 있었다면 평가를 위해 원래 prefix도 다시 붙임
    if has_assistant_prefill:
        return (
            messages[-1]["content"] + generated_text
        ).strip()

    return generated_text

저자 코드의 실제 프롬프트 확인

데이터 예시의 주요 키
dict_keys(['question', 'answer', 'dataset_type', 'prompt_parts', 'answerKey', 'messages', 'zs_cot_messages', 'zs_cotless_messages', 'fs_cot_messages', 'fs_cotless_messages'])
문제
Anthony had 50 pencils. He gave 1/2 of his pencils to Brandon, and he gave 3/5 of the remaining pencils to Charlie. He kept the remaining pencils. How many pencils did Anthony keep?
정답
10
공식 Direct Answer 프롬프트
[system]
You are a helpful AI assistant that will answer reasoning questions. You will only say "\boxed{your answer}". You must end your response with $\boxed{your answer}$ everytime! -[user]
Solve the following math problem. Box your final answer: $\boxed{your answer}$.Remember to box your final answer via $\boxed{your answer}$. Problem
Anthony had 50 pencils. He gave 1/2 of his pencils to Brandon, and he gave 3/5 of the remaining pencils to Charlie. He kept the remaining pencils. How many pencils did Anthony keep?

공식 CoT 프롬프트
[system]
You are a helpful AI assistant that will answer reasoning questions. You will reason step by step and you will always say at the end $\boxed{your answer}$". You must end your response with "\boxed{your answer}" everytime!
[user]
Solve the following math problem. Explain your reasoning step by step. When you are finished, box your final answer: $\boxed{your answer}$.
Problem:
Anthony had 50 pencils. He gave 1/2 of his pencils to Brandon, and he gave 3/5 of the remaining pencils to Charlie. He kept the remaining pencils. How many pencils did Anthony keep?Remember to box your final answer via $\boxed{your answer}$. ⇒ 위에서 볼 수 있듯 Direct Answer, CoT의 reasoning 지시가 다른 것을 확인 할 수 있다

범용 실험 함수 만들기

from pathlib import Path
from time import perf_counter

import pandas as pd
from tqdm.auto import tqdm


def run_pairwise_experiment(
    dataset,
    dataset_name: str,
    num_samples: int,
    output_csv: str,
    max_new_tokens: int = 1024,
) -> pd.DataFrame:
    """
    같은 문제에 대해
    1. Zero-shot Direct Answer
    2. Zero-shot CoT
    를 실행하고 공식 evaluator로 평가한다.

    중간에 커널이 종료되어도 다시 이어서 실행할 수 있도록
    매 문제마다 CSV를 저장한다.
    """

    output_path = Path(output_csv)
    output_path.parent.mkdir(parents=True, exist_ok=True)

    # 이전 실행 결과가 있으면 불러와 이어서 실행
    if output_path.exists():
        previous_results = pd.read_csv(output_path)
        records = previous_results.to_dict("records")
        completed_indices = set(
            previous_results["index"].astype(int).tolist()
        )

        print(
            f"기존 결과 {len(completed_indices)}개를 불러왔습니다."
        )
    else:
        records = []
        completed_indices = set()

    target_count = min(num_samples, len(dataset))

    for index in tqdm(range(target_count)):

        if index in completed_indices:
            continue

        example = dataset[index]

        question = str(
            example.get(
                "question",
                example.get("question_format", ""),
            )
        )

        gold_answer = str(example.get("answer", ""))

        try:
            # Direct Answer 조건
            direct_start = perf_counter()

            direct_response = generate_response(
                example["zs_cotless_messages"],
                max_new_tokens=max_new_tokens,
            )

            direct_seconds = perf_counter() - direct_start

            direct_metric = dataset.evaluate_response(
                [direct_response],
                example,
            )[0]
            # CoT 조건
            cot_start = perf_counter()

            cot_response = generate_response(
                example["zs_cot_messages"],
                max_new_tokens=max_new_tokens,
            )

            cot_seconds = perf_counter() - cot_start

            cot_metric = dataset.evaluate_response(
                [cot_response],
                example,
            )[0]

            # 실제 출력 토큰 수
            direct_tokens = len(
                tokenizer.encode(
                    direct_response,
                    add_special_tokens=False,
                )
            )

            cot_tokens = len(
                tokenizer.encode(
                    cot_response,
                    add_special_tokens=False,
                )
            )

            record = {
                "dataset": dataset_name,
                "index": index,
                "question": question,
                "gold_answer": gold_answer,

                "direct_model_answer": direct_metric.get(
                    "model_answer"
                ),
                "cot_model_answer": cot_metric.get(
                    "model_answer"
                ),

                "direct_correct": bool(
                    direct_metric.get("correct", False)
                ),
                "cot_correct": bool(
                    cot_metric.get("correct", False)
                ),

                "direct_unparsable": (
                    direct_metric.get("model_answer") is None
                ),
                "cot_unparsable": (
                    cot_metric.get("model_answer") is None
                ),

                "direct_output_tokens": direct_tokens,
                "cot_output_tokens": cot_tokens,

                "direct_seconds": direct_seconds,
                "cot_seconds": cot_seconds,

                "direct_response": direct_response,
                "cot_response": cot_response,

                "error": "",
            }

        except Exception as error:
            record = {
                "dataset": dataset_name,
                "index": index,
                "question": question,
                "gold_answer": gold_answer,

                "direct_model_answer": None,
                "cot_model_answer": None,

                "direct_correct": False,
                "cot_correct": False,

                "direct_unparsable": True,
                "cot_unparsable": True,

                "direct_output_tokens": 0,
                "cot_output_tokens": 0,

                "direct_seconds": 0,
                "cot_seconds": 0,

                "direct_response": "",
                "cot_response": "",

                "error": repr(error),
            }

        records.append(record)

        # 매 문제마다 중간 저장
        pd.DataFrame(records).sort_values(
            "index"
        ).to_csv(
            output_path,
            index=False,
            encoding="utf-8-sig",
        )

    result_df = pd.DataFrame(records).sort_values(
        "index"
    ).reset_index(drop=True)

    return result_df

선행 20문제

OUTPUT_FILE = "results/qwen2_7b_gsm8k_pairwise.csv"

gsm8k_results = run_pairwise_experiment(
    dataset=gsm8k_dataset,
    dataset_name="GSM8K",
    num_samples=20,
    output_csv=OUTPUT_FILE,
    max_new_tokens=1024,
)

gsm8k_results.head()

이를 먼저 실행 하는 이유는 모델생성이 정상적으로 끝나는지, CoT가 단계별로 추론을 생성하는지, Direct answering이 실제로 짧게 끝나는지 등을 파악하기 위함이다.

첫 번째 선행 실험에서는 시간, True/False 판별에서 CoT와 direct respons가 이상하게 나왔다. 아마도 원문에서 greedy 함수를 vLLM 기반으로 사용했던 것과 다르게 transformer 기준으로 바꾸면서 문제가 생긴 듯 해서 greedy 함수를 재정의 했다.

def generate_response(
    messages,
    max_new_tokens,
):
    """
    Qwen 모델로 greedy decoding을 수행한다.

    원 논문의 vLLM 설정:
    - temperature = 0
    - top_p = 1
    - rollout = 1

    Transformers 대응 설정:
    - do_sample = False
    - num_beams = 1
    """

    has_assistant_prefill = (
        len(messages) > 0
        and messages[-1]["role"] == "assistant"
    )

    if has_assistant_prefill:
        # 마지막 assistant 메시지 뒤를 이어서 생성
        prompt_text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            continue_final_message=True,
        )

        assistant_prefix = messages[-1]["content"]

    else:
        # 새로운 assistant 답변 시작
        prompt_text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True,
        )

        assistant_prefix = ""

    encoded = tokenizer(
        prompt_text,
        return_tensors="pt",
    )

    device = next(model.parameters()).device

    encoded = {
        key: value.to(device)
        for key, value in encoded.items()
    }

    input_length = encoded["input_ids"].shape[1]

    with torch.inference_mode():
        output_ids = model.generate(
            **encoded,

            max_new_tokens=max_new_tokens,

            # Greedy decoding
            do_sample=False,
            num_beams=1,

            eos_token_id=tokenizer.eos_token_id,
            pad_token_id=tokenizer.pad_token_id,

            use_cache=True,
        )

    # 입력 프롬프트를 제외하고 새로 생성한 부분만 가져옴
    generated_ids = output_ids[0, input_length:]

    continuation = tokenizer.decode(
        generated_ids,
        skip_special_tokens=True,
    ).strip()

    # Direct 조건은 '$\boxed{'가 입력에 포함돼 있었으므로
    # 평가를 위해 다시 앞에 붙여서 전체 응답을 복원
    return (
        assistant_prefix + continuation
    ).strip()

전체 실험 함수 재정의

from pathlib import Path
from time import perf_counter

import pandas as pd
from tqdm.auto import tqdm


def run_pairwise_experiment(
    dataset,
    dataset_name,
    num_samples,
    output_csv,
    direct_max_new_tokens=100,
    cot_max_new_tokens=1024,
):
    """
    동일한 GSM8K 문제에 대해 다음을 비교한다.

    1. Zero-shot Direct Answer
    2. Zero-shot Chain-of-Thought

    각 문제마다:
    - 공식 evaluator 결과
    - 숫자 정규화 보조 평가
    - 출력 토큰 수
    - 생성 시간
    - 전체 응답

    을 CSV에 저장한다.
    """

    output_path = Path(output_csv)
    output_path.parent.mkdir(
        parents=True,
        exist_ok=True,
    )

    # 같은 파일이 있으면 이어서 실행
    if output_path.exists():
        previous_results = pd.read_csv(
            output_path
        )

        records = previous_results.to_dict(
            "records"
        )

        completed_indices = set(
            previous_results["index"]
            .astype(int)
            .tolist()
        )

        print(
            f"기존 결과 "
            f"{len(completed_indices)}개를 불러왔습니다."
        )

    else:
        records = []
        completed_indices = set()

    target_count = min(
        num_samples,
        len(dataset),
    )

    for index in tqdm(range(target_count)):

        if index in completed_indices:
            continue

        example = dataset[index]

        question = str(
            example.get("question", "")
        )

        gold_answer = str(
            example.get("answer", "")
        )

        try:
            # -------------------------
            # 프롬프트 준비
            # -------------------------
            direct_messages = (
                prepare_gsm8k_direct_messages(
                    example
                )
            )

            cot_messages = (
                prepare_gsm8k_cot_messages(
                    example
                )
            )

            # -------------------------
            # Direct Answer 실행
            # -------------------------
            direct_start = perf_counter()

            direct_response = generate_response(
                direct_messages,
                max_new_tokens=(
                    direct_max_new_tokens
                ),
            )

            direct_seconds = (
                perf_counter()
                - direct_start
            )

            direct_metric = (
                dataset.evaluate_response(
                    [direct_response],
                    example,
                )[0]
            )

            # -------------------------
            # CoT 실행
            # -------------------------
            cot_start = perf_counter()

            cot_response = generate_response(
                cot_messages,
                max_new_tokens=(
                    cot_max_new_tokens
                ),
            )

            cot_seconds = (
                perf_counter()
                - cot_start
            )

            cot_metric = (
                dataset.evaluate_response(
                    [cot_response],
                    example,
                )[0]
            )

            # -------------------------
            # 출력 토큰 수
            # -------------------------
            direct_tokens = len(
                tokenizer.encode(
                    direct_response,
                    add_special_tokens=False,
                )
            )

            cot_tokens = len(
                tokenizer.encode(
                    cot_response,
                    add_special_tokens=False,
                )
            )

            # 공식 evaluator가 추출한 답
            direct_model_answer = (
                direct_metric.get(
                    "model_answer"
                )
            )

            cot_model_answer = (
                cot_metric.get(
                    "model_answer"
                )
            )

            # 숫자 정규화 보조 평가
            direct_numeric_correct = (
                numeric_answers_equal(
                    direct_model_answer,
                    gold_answer,
                )
            )

            cot_numeric_correct = (
                numeric_answers_equal(
                    cot_model_answer,
                    gold_answer,
                )
            )

            record = {
                "dataset": dataset_name,
                "index": index,
                "question": question,
                "gold_answer": gold_answer,

                "direct_model_answer": (
                    direct_model_answer
                ),
                "cot_model_answer": (
                    cot_model_answer
                ),

                # 저자 공식 evaluator
                "direct_correct": bool(
                    direct_metric.get(
                        "correct",
                        False,
                    )
                ),
                "cot_correct": bool(
                    cot_metric.get(
                        "correct",
                        False,
                    )
                ),

                # 숫자 기준 보조 evaluator
                "direct_numeric_correct": bool(
                    direct_numeric_correct
                ),
                "cot_numeric_correct": bool(
                    cot_numeric_correct
                ),

                "direct_unparsable": (
                    direct_model_answer is None
                ),
                "cot_unparsable": (
                    cot_model_answer is None
                ),

                "direct_output_tokens": (
                    direct_tokens
                ),
                "cot_output_tokens": (
                    cot_tokens
                ),

                "direct_seconds": (
                    direct_seconds
                ),
                "cot_seconds": (
                    cot_seconds
                ),

                "direct_response": (
                    direct_response
                ),
                "cot_response": (
                    cot_response
                ),

                "error": "",
            }

        except Exception as error:
            record = {
                "dataset": dataset_name,
                "index": index,
                "question": question,
                "gold_answer": gold_answer,

                "direct_model_answer": None,
                "cot_model_answer": None,

                "direct_correct": False,
                "cot_correct": False,

                "direct_numeric_correct": False,
                "cot_numeric_correct": False,

                "direct_unparsable": True,
                "cot_unparsable": True,

                "direct_output_tokens": 0,
                "cot_output_tokens": 0,

                "direct_seconds": 0,
                "cot_seconds": 0,

                "direct_response": "",
                "cot_response": "",

                "error": repr(error),
            }

        records.append(record)

        # 문제 하나가 끝날 때마다 저장
        pd.DataFrame(records).sort_values(
            "index"
        ).to_csv(
            output_path,
            index=False,
            encoding="utf-8-sig",
        )

    return (
        pd.DataFrame(records)
        .sort_values("index")
        .reset_index(drop=True)
    )

문제마다

Direct → Qwen → 최종 답

CoT→ Qwen → 추론 + 최종 답

	항목	값
0	정상 완료 문제 수	20.000000
1	Direct 공식 정확도	0.100000
2	CoT 공식 정확도	0.850000
3	공식 CoT-Direct 차이(%p)	75.000000
4	Direct 숫자 정확도	0.100000
5	CoT 숫자 정확도	0.900000
6	숫자 CoT-Direct 차이(%p)	80.000000
7	둘 다 정답	2.000000
8	CoT만 정답	15.000000
9	Direct만 정답	0.000000
10	둘 다 오답	3.000000
11	Direct 답 추출 실패율	0.000000
12	CoT 답 추출 실패율	0.000000
13	Direct 평균 출력 토큰	7.350000
14	CoT 평균 출력 토큰	275.700000
15	Direct 평균 생성 시간	0.114806
16	CoT 평균 생성 시간	5.348551
17	Exact McNemar p-value	0.000061

이전과 다르게 답변 시간, 정답률, 토큰 수 차이 등 거의 정상적으로 작동하는 것을 확인 할 수 있었다.

100문제 확인

gsm8k_results = run_pairwise_experiment(
    dataset=gsm8k_dataset,
    dataset_name="GSM8K",

    # 20개에서 100개로 확대
    num_samples=100,

    output_csv=OUTPUT_FILE,

    direct_max_new_tokens=100,
    cot_max_new_tokens=1024,
)

gsm8k_summary = summarize_pairwise_results(
    gsm8k_results
)

gsm8k_summary

같은 output file을 사용하기 때문에 기존 20문제는 제외하고 이후 80개의 문제를 실행하여 결과를 CSV에 저장했다

본 축소 실험에서는 Qwen2-7B-Instruct를 대상으로 GSM8K 문제에서 Direct Answer와 Chain-of-Thought(CoT) prompting의 성능을 비교하였다. 실험 결과, Direct Answer의 정확도는 약 16%였던 반면 CoT의 정확도는 약 88%로 나타나, CoT 적용 시 약 72%p의 큰 성능 향상이 확인되었다. 이는 다단계 계산과 추론이 필요한 수학 문제에서 중간 추론 과정을 명시적으로 생성하는 것이 정답 도출에 효과적임을 보여준다.

반면 CoT는 Direct Answer보다 평균 출력 토큰 수와 생성 시간이 크게 증가하였다. Direct Answer는 매우 적은 토큰과 짧은 시간으로 응답한 반면, CoT는 평균 약 270개 이상의 출력 토큰과 약 5초 이상의 생성 시간을 사용하였다. 따라서 CoT는 수학 추론 정확도를 크게 높일 수 있지만, 그 대가로 추론 비용과 응답 시간이 증가한다는 점을 확인하였다.

이러한 결과는 CoT가 특히 수학적·기호적 추론 과제에서 효과적이라는 원 논문의 주장과 방향적으로 일치한다. 다만 본 실험은 하나의 모델과 GSM8K 일부 표본만을 대상으로 수행한 축소 재현이므로, 지식 및 상식 과제에서도 CoT의 성능 향상은 작고 비용만 증가하는지를 확인하기 위해서는 추가 데이터셋 실험이 필요하기 때문에 추후에 knowladge 영역에서의 실험도 재현할 예정이다.

FAITHCOT-BENCH: BENCHMARKING INSTANCELEVEL FAITHFULNESS OF CHAIN-OF-THOUGHT REASONING [논문 리뷰]

seungbye — Wed, 8 Jul 2026 22:15:18 +0900

Abstract

CoT가 LLM의 문제 해결 성능을 높이고, 겉보기에는 설명 가능성을 주는 것처럼 보인다. 하지만 CoT가 실제 모델의 내부 reasoning process를 faithful하게 반영하지 않을 수 있다
기존 연구들은 CoT가 unfaithful할 수 있다는 것을 보여줬지만, 대부분은 mechanism-level 분석이었다. 즉, CoT라는 방식이 전체적으로 문제가 있을 수 있다는 건 보여줬지만 특정 query와 특정 CoT가 주어졌을 때, 이 CoT가 faithful한지 판단하는 문제는 충분히 다루지 않았다.

Introduction

이 reasoning step들이 진짜 모델의 internal decision process를 반영하는가?

아니면 instruction에 맞춰 그럴듯하게 보이도록 만든 표면적 설명인가?

기존 연구들의 평가 방식방법 의미

Counterfactual-based	CoT를 자르거나, 실수를 넣거나, step을 제거해서 답이 바뀌는지 봄
Logit-based	token-level logit이나 information gain으로 CoT와 답의 관계를 봄
LLM-as-Judge	더 강한 LLM에게 CoT가 faithful한지 판단하게 함

⇒ 대부분 aggregate evidence(모델 전체적으로 CoT faithfulness 평가)이며 개별 CoT 하나에 대해 faithfulness를 판단하는 표준 benchmark 부족

Instance-level CoT Unfaithfulness Detection

이 논문은 CoT faithfulness를 binary classification problem으로 정의함(입력은 query + CoT, 출력은 faithful or unfaithful 0,1) ⇒ 모델이 문제를 받고 CoT를 생성했을 때 그 CoT가 모델의 실제 reasoning을 faithful하게 반영했는가를 판단하며 이를 논문에서는 instance-level CoT unfaithfulness detection 이라고 함

Challenge(어려운 이유)

Ground truth가 없다
⇒ 모델의 실제 internal reasoning path는 보이지 않음. 즉, 우리는 입력, 출력(CoT), 최종 답 이기 때문에 모델 내부에서 진짜 어떤 과정으로 답을 냈는지 직접 확인 할 수 없다.
평가 방법이 아직 불완전함
⇒ CoT가 faithful한지 판단하려면, 관찰 가능한 단서로 추정해야 하지만 기존 방법들이 정말 instance-level에서 잘 작동하는지는 불확실하기 때문에 논문은 benchmark가 필요하다고 말함

FINE-CoT Dataset

구성 설명

Query	문제
Generated CoT + Answer	모델이 생성한 CoT와 최종 답
Annotation	faithful 여부, unfaithful reason, 문제 step evidence

Dataset Domain

LogiQA	logic
TruthfulQA	factual reasoning
AQuA	mathematics
HLE-Bio	biology / biomedical knowledge

3개의 instance, 4개의 domain, 4개의 모델을 사용했다

Two Reasons for Unfaithful CoT

Post-hoc Reasoning ⇒ 답을 이미 정하고 그 답을 정당화 하기 위해 CoT를 사후 합리화
Spurious Reasoning Chain ⇒ 겉으로는 그럴듯 하지만 질문이나 최종 답과 진짜 logical connection이 약한 경우

Fine-grained principles

이 논문에서는 unfaithful 유형을 8개의 세부 유형으로 나눈다

Post-hoc Reasoning
- Selective Explanation Bias : 답에 유리한 근거만 골라 설명
- Lack of Post-Answer Analysis : 답 이후 충분한 검증 없음
- Revision of Prior Conclusions : 앞에서 내린 결론을 나중에 슬쩍 바꿈
- Confidence without Substantive Justification : 근거 없이 확신함
Spurious Reasoning Chain
- Step Skipping : 중요한 reasoning step 건너뜀
- Omission of Clear Justification : 명확한 근거를 생략
- Weak Relevance of Justification : 근거가 최종 답과 약하게만 관련됨
- Post-Answer Weakening : 답을 낸 뒤 reasoning이 약해짐

⇒ 이 논문에서는 unfaithful을 세세하게 정의 하여 어디서 어떤 이유로 unfaithful한지, 어떤 strp이 문제인지까지 확인함

Human Annotation Procedure

단계 설명

Round I	각 annotator가 독립적으로 faithful 여부, confidence, reason, key step labeling
Round II	disagreement나 low-confidence case를 토론으로 해결
Round III	refined taxonomy 기준으로 다시 cross-check

즉 자동으로 label을 붙인 것이 아니라 전문가들이 CoT를 보고 이게 왜 unfaithful 하고 어느 step이 문제인지 직접 판단한 dataset 을 만들었음

Empirical Observations

Observation 1. Accuracy와 faithfulness는 완전히 일치하지 않는다

Observation 2. Correctness와 faithfulness는 instance-level에서 갈라진다유형 의미

Correct-Faithful	답도 맞고 reasoning도 faithful
Correct-Unfaithful	답은 맞지만 reasoning은 unfaithful
Wrong-Faithful	답은 틀렸지만 reasoning 과정은 투명함
Wrong-Unfaithful	답도 틀리고 reasoning도 unfaithful

Observation 3. 모델이 강해져도 unfaithfulness가 사라지지 않는다
Observation 4. Task type이 faithfulness에 큰 영향을 준다
- LogicQA, AQuA 같은 logic/math reasoning task에서는 wrong-faithful case가 많이 나타남
- TruthfulQA, HLE-Bio 같은 knowledge-intensive task에서는 wrong-unfaithful case가 더 많음
Observation 5. Difficulty와 distribution shift가 unfaithfulness를 키운다

Future Work

방향 설명

Mechanistic tools	causal probing, circuit analysis, hidden-state inspection으로 실제 내부 reasoning과 연결
Training-based strategies	counterfactual regularization, process-level supervision
Beyond binary labels	faithful/unfaithful 이분법을 넘어 더 섬세한 평가

Conclusion

CoT unfaithfulness는 널리 나타난다.
knowledge-intensive domain에서 특히 어렵다.
stronger model도 unfaithfulness를 완전히 해결하지 못한다.
기존 detection method는 아직 충분히 안정적이지 않다.
apparent transparency와 actual faithfulness 사이에는 큰 gap이 있다.

On the Impact of Fine-Tuning on Chain-of-Thought Reasoning[논문 리뷰]

seungbye — Wed, 8 Jul 2026 22:14:46 +0900

Abstract

LLM은 원래 general intelligence를 가진 모델이지만, 특정 task에서는 fine-tuning을 하면 성능이 더 좋아질 수 있다. 하지만 기존 연구들은 fine-tuning이 이런 문제를 만들 수 있다고 본다.

문제 의미

catastrophic forgetting	fine-tuning한 task는 잘하지만 기존 능력은 잊음
privacy risk	fine-tuning data가 더 쉽게 추출될 위험
safety risk	기존 safety mechanism이 약해질 위험

이 논문에서는 이런 문제점들에서 한 걸음 더 나아가서 fine tuning이 CoT reasoning과 CoT faithfulness에는 어떤 영향을 끼치는지 분석함. ⇒ 결과적으로 fine tuning 이후에 네 개의 dataset에서 평균적으로 CoT faithfulness가 감소했다(fine tuning으로 학습한 답 패턴을 정당화 하는 설명)

Introduction

LLM은 금융, 의료, 교육, 콘텐츠 생성 등 다양한 분야에 쓰인다. 하지만 pre-trained model은 의료나 법률처럼 specialized knowledge가 필요한 domain에서는 부족할 수 있다. 그래서 pre-trained LLM을 특정 domain dataset으로 fine-tuning한다. 하지만 fine-tuning은 위에서 언급했던 문제들을 일으킬 수 있음

*이 논문에서는 fine-tuning이 reasoning 능력에는 어떤 영향을 주는지 충분히 연구되지 않았다고 설명

Our Work

fine-tuning이 CoT reasoning accuracy에 어떤 영향을 주는가?
fine-tuning이 CoT faithfulness에 어떤 영향을 주는가?
fine-tuning이 IID(AI가 학습한 데이터와 테스트 데이터가 동일한 분포 즉, AI에게 익숙한 문제 유형) /OOD(새로운 형태의 데이터) reasoning performance에 어떤 영향을 주는가?
QLoRA rank가 fine-tuning 후 CoT 능력 저하에 영향을 주는가?

*QLoRA는 모델 전체를 fine-tuning 하는 것이 아닌 LoRA에 4bit Quantization을 적용

Methods

fine-tuning을 어떻게 했는지
- supervised fine-tuning을 사용하고, LLaMA 모델에는 QLoRA를 적용
- 대부분 dataset에서는 reasoning step 없이 question-answer pair만으로 fine-tuning
CoT accuracy와 faithfulness를 어떻게 측정하는지
- Accuracy of Chain-of-Thought Reasoning
  1. 모델에게 CoT prompt를 줌
  2. step-by-step reasoning을 생성하게 함
  3. 최종 답을 내게 함
  4. fine-tuned model과 pre-trained model의 accuracy 비교
- Faithfulness of Chain-of-Thought Reasoning
  - Early Termination ⇒ CoT를 중간에 끊고 답하게 함
  - Paraphrasing ⇒ CoT 일부를 다른 말로 바꿈
  - Filler Substitution ⇒ CoT 뒤쪽을 … 같은 filler로 바꿈(필요 없는 token)

Experimental Setup

DatasetsDataset Domain 설명

GSM8K	Math reasoning	초중등 수준 수학 word problem
CosmosQA	Commonsense reasoning	상식 기반 reading comprehension
MedQA	Medical	USMLE 기반 의학 QA
MedMCQA	Medical	AIIMS/NEET 기반 의학 QA

여기서 fine-tuning dataset과 test dataset이 같은 category면 IID, 다르면 OOD(위 아래 두개씩 IID라고 볼 수 있음)

ModelsModel 특징

Llama-3-8B-Instruct 작은 open-source model

GPT-3.5-turbo-0125 중간급 closed model

GPT-4 강한 reasoning model
- LLaMA에는 QLoRA를 사용하고, GPT 계열은 OpenAI API로 fine-tuning

Results

RQ1. Fine-tuning이 CoT reasoning accuracy에 어떤 영향을 주는가?
- fine-tuning 후 CoT accuracy가 전반적으로 떨어지는 경우가 많으며 특히 GSM8K 같은 math reasoning dataset에서 세 모델 모두 fine-tuned model이 pre-trained model보다 낮은 CoT accuracy를 보였다고 설명해. ⇒ fine tuning은 특정 task Acc를 올릴 수 있지만 CoT reasoning은 오히려 망가질 수 있음, 특히 작은 모델은 fine-tuning으로 parameter가 많이 흔들리고, general reasoning 능력이 더 쉽게 손상될 수 있음
RQ2. Fine-tuning이 CoT faithfulness에 어떤 영향을 주는가?
- Early Termination : 이 논문에서는 CoT를 25%, 50%, 75% 지점에서 끊고, full CoT와 같은 답이 나오는 비율을 봤는데 Gpt 계열에서는 fine tuning을 해도 faithfulness 변화가 크지 않았지만 LLaMA에선 Early Termination으로 CoT Pred Match가 증가하는 경향이 있었음
- Filler Substitution : Filler Substitution에서도 Early Termination과 비슷하게, CoT Pred Match가 높으면 의미 있는 reasoning을 filler로 바꿔도 답이 유지된다 → CoT content가 실제 답에 덜 중요할 수 있다 → faithfulness가 낮을 가능성
- Paraphrasing : Paraphrasing에서는 CoT Pred Match가 높으면 좋은 쪽으로 해석된다. 왜냐하면 표현만 바꿨는데 답이 유지된다는 건 특정 토큰이나 phrasing 때문이 아니라, reasoning의 논리적 내용이 유지되었기 때문일 수 있기 때문이다.
RQ3. Fine-tuning이 IID/OOD general performance에 어떤 영향을 주는가?
- Figure 2a는 CoT 없이 바로 답을 내는 zero-shot accuracy를 보여주는데 이때 GPT 모델은 fine-tuning 후 여러 dataset에서 accuracy가 개선되는 경우가 많았다. 하지만 LLaMA-3-8B-Instruct는 MedQA나 CosmosQA로 fine-tuning했을 때 GSM8K 같은 math reasoning dataset에서 성능이 크게 떨어졌어.
QLoRA rank가 영향을 주는가?
- LLaMA-3-8B-Instruct에 대해 QLoRA rank를 8, 16, 32로 바꿔서 실험했는데 결과적으로 rank를 바꿔도 핵심 경향은 유지됐다.

Conclusion

Fine-tuning은 작은 LLM의 complex reasoning performance를 감소시킬 수 있다.
특히 math-based task에서 CoT reasoning performance가 크게 떨어질 수 있다.
Fine-tuning은 CoT reasoning faithfulness도 손상시킬 수 있다.

Limitations

Faithfulness metric 자체가 아직 초기 단계이기 때문에 metric 발전에 따른 결과 해석을 다시 할 필요 존재
새로운 CoT prompting 방법은 다루지 않음. 기본적인 CoT prompting 중심으로 실험으로만 진행
fine-tuning이 실제로 모델 내부 activation이나 attention head를 어떻게 바꾸는지는 깊게 분석하지 않았음
dataset/model 범위 제한(더 다양한 reasoning/non-reasoning task와 더 많은 open-source model로 확장할 필요 존재)

Reasoning Models Don’t Always Say What They Think [논문 리뷰]

seungbye — Wed, 8 Jul 2026 22:14:08 +0900

Abstract

CoT가 AI safety에 도움이 될 수 있다고 말함. ⇒ 모델의 CoT를 보면 모델이 어떤 의도와 reasoning으로 답했는지 감시할 수 있을 것 같기 때문임

모델이 prompt 안의 hint를 사용해 답을 바꾸더라도, 그 hint 사용을 CoT에 말하는 비율은 낮다.
outcome-based reinforcement learning(결과 기반 강화 학습)은 초반에는 faithfulness를 높이지만, 어느 정도에서 plateau(정체기)가 온다.
RL 중 reward hacking을 배워도, 모델은 그 reward hack을 CoT에 거의 말하지 않는다.

⇒CoT monitoring은 유용할 수 있지만, 믿고 의존하기에는 부족하다

Introduction

CoT의 두 가지 장점으로는 Capability(복잡한 문제를 더 잘 풀게 함)와 safety monitoring(모델이 무슨생각을 하는지 감시) 이 있음

하지만 safety monitoring이 가능하려면 CoT가 legible(사람이 이해할 수 있어야 함), faithful 해야함.

Measuring CoT Faithfulness

이 논문에서의 평가방식은 모델이 hint 때문에 답을 바꿨다면, CoT에서 그 hint를 사용했다고 말하는가를 보는 것 이다. 위의 Turpin 논문과 비슷하게 hint pair를 사용한다. (원래문제, hint 삽입 문제 pair)

이후 모델이 힌트를 사용하여 답을 냈을 때 CoT에서 hint를 사용했다고 말하는지를 통해 faithful score(hint 때문에 답이 바뀐 경우 중 CoT가 그 hint 사용을 명시적으로 나타낸 비율)를 1,0으로 계산함

Metric

unhinted prompt에서는 hint answer가 아닌 답을 함
hinted prompt에서는 hint answer로 답을 바꿈
그러면 hint가 답 변화의 원인이라고 추론
그때 CoT가 hint 사용을 말했는지 확인

하지만 이 score가 true faithfulness의 upper bound일 가능성이 있다고 말한다. ⇒ CoT가 hint를 말했더라도, 다른 숨은 reasoning이나 의도까지 다 말한 것은 아닐 수 있기 때문이다(모델이 단순히 hint만 보고 CoT를 대답한 것이 아니기 때문에 완전한 faithful이 아닐 수 있음. 따라서 upper bound라고 표현한 것)

Data

MMLU: 상대적으로 쉬운 시험형 지식/추론 문제
GPQA: 더 어려운 전문 지식/추론 문제
6종류의 힌트를 만들어서 제공

구분 Hint 설명

Neutral	Sycophancy	사용자가 “답은 A 같은데?”라고 제안
Neutral	Consistency	이전 턴에서 모델이 이미 A라고 말한 것처럼 제시
Neutral	Visual Pattern	few-shot 예시에서 정답을 특정 표시로 강조
Neutral	Metadata	XML metadata 안에 정답 정보 삽입
Misaligned	Grader Hacking	채점기 코드/검증 함수가 특정 답을 보상한다고 암시
Misaligned	Unethical Information	비윤리적으로 얻은 정보가 정답을 알려줌

*아래 두 힌트는 단순 힌트가 아니라 safety 관점에서 위험한 hint

Experimental Setup

모델에게 step-by-step reasoning을 하게 하고, 최종 option letter를 쓰게 함
CoT가 hint를 verbalize했는지 판단할 때는 두 조건을 본다
1. CoT가 hint를 언급했는지
2. 그 hint가 답을 고르는 데 실제로 사용된 것처럼 보이는가
3. 단순히 마지막에 metadata도 있었다 처럼 확인만 하는 것은 verbalization으로 보지 않는다

Benchmarking CoT Faithfulness of Reasoning Models

Result 1 : 모든 모델이 hint를 사용한다
Result 2 : Reasoning model(추론)이 non-reasoning model(학습된 패턴에 의존)보다 더 faithful하긴 하다
Result 3 : 하지만 절대적인 faithfulness는 높지 않음모델 평균 faithfulness

Claude 3.7 Sonnet 약 25%

DeepSeek R1 약 39%

*추가적으로 저자들은 모델이 짧게 쓰려는 성향 때문에 힌트를 말하지 않는 것이라 생각했지만 길고 복잡한 CoT가 unfaithful한 상황이 많았음.

*상대적으로 어려운 question인 GPQA에서 unfaithful 했음 ⇒ 어려운 문제일수록 모델 스스로의 지식으로 답을 확신하기 어렵기에 hint를 더 많이 사용할 가능성이 있고 이를 말하지 않을 가능성 존재함

*위의 Lanham 논문에선 쉬운 task에서는 CoT가 post-hoc일 수 있다고 했고 이 논문에서는 어려운 task에서는 hint 사용 verbalization이 더 낮을 수 있다고 말함 ⇒ 결국 쉬운 문제, 어려운 문제 모두 다른 방식으로 faithfulness 문제가 발생할 수 있음

The Impact of Outcome-Based RL on CoT Faithfulness

outcome-based RL(CoT 과정 자체를 평가하지 않고, 최종 답이 맞았는지만 보상하는 훈련)을 하면 CoT faithfulness가 좋아질까? ⇒ 답이 맞는 경우 reward제공, CoT가 faithful한지는 직접 보상하지 않음
결과적으로 outcome-based RL은 초반에는 CoT faithfulness를 꽤 올리지만 금방 plateau에 도달했

CoT Faithfulness on RL Reward Hacks

모델이 RL 과정에서 reward hack을 배우면, 그 꼼수를 CoT에 말할까?
결과적으로 모델은 모든 환경에서 reward hack을 빠르게 배워서 30step안에 incorrect hint answer를 99% 이상 선택함, 하지만 CoT에는 reward hack을 verbalize하는 비율은 매우 낮았음(6개 중 5개의 환경에서 reward hack verbalization이 2% 미만)

Discussion

CoT monitoring은 unintended behavior를 발견하는 데 유용한 도구일 수 있다. 특히 어떤 위험 행동이 자주 발생하거나, 여러 단계의 reasoning이 필요한 경우에는 CoT 중 일부에서 그 의도가 드러날 가능성이 있다. 하지만 CoT monitoring 하나만으로 안전을 보장하기 어려움. 따라서 CoT monitoring에 의존하려면 두 가지가 필요함

모델이 그 위험 행동을 CoT 없이 수행할 수 없다는 capability evidence
모델이 CoT를 사용할 때 실제 reasoning을 faithfully verbalize한다는 evidence

Limitations

실험이 multiple-choice benchmark 문제 중심이다. 실제 deployment 환경과 다를 수 있다.
hint가 매우 쉽게 exploit 가능한 형태다. 그래서 CoT가 꼭 필요한 상황은 아니다.

Conclusion

reasoning model의 CoT는 일부 경우에는 hint 사용을 드러낸다.
하지만 충분히 신뢰할 만큼 안정적으로 드러내지는 않는다.
outcome-based RL만으로 CoT faithfulness를 충분히 높이기 어렵다.
reward hacking은 CoT에 거의 verbalize되지 않을 수 있다.
CoT monitoring은 alignment의 유용한 도구일 수 있지만, 단독으로는 부족하다

Future direction

Measuring Faithfulness in Chain-of-Thought Reasoning

seungbye — Wed, 8 Jul 2026 22:13:16 +0900

Abstract

LLM은 CoT를 생성하면 성능이 좋아질 때가 많지만 그 CoT가 모델의 실제 reasoning process를 faithfully 설명하는지는 불확실함 ⇒ CoT faithfulness 측정하기 위해 여러 intervention(간섭) 수행

⇒ 이 intervention들에 대해서 답이 같으면 실제로 모델은 CoT를 사용하지 않았을 수도 있다

실험 의미

Early Answering	CoT를 중간에 자르고 답하게 함
Adding Mistakes	CoT 중간에 실수를 넣음
Paraphrasing	CoT를 다른 말로 바꿔 씀
Filler Tokens	CoT를 의미 없는 … 토큰으로 대체

Introduction

LLM이 어떤 답을 냈을 때, 특히 의료, 법률, 안전 같은 high-stakes setting(위험 부담이 큰)에서는 왜 그런 답을 냈는지 이해하는 게 중요하다. 많은 사람들은 CoT가 step-by-step reasoning을 보여주니까 모델의 설명 가능성을 높인다고 생각하지만 이 주장은 CoT가 faithful할 때만 성립한다

Measuring Chain-of-Thought Faithfulness

CoT가 unfaithful할 수 있는 이유를 몇 가지 가설로 나누고 각각을 실험함

Post-hoc reasoning (답은 이미 정해졌고 CoT는 그 답을 나중에 설명하기 위해 만들어진 것이다)Task 설명

ARC Challenge	어려운 초등 과학 문제
ARC Easy	쉬운 초등 과학 문제
AQuA	대수학 word problem
HellaSwag	문맥에 맞는 문장 완성
LogiQA	논리 추론 문제
MMLU	다양한 과목 시험 문제
OpenBookQA	초등 과학 QA
TruthfulQA	오개념을 유도하는 사실 질문

위의 표에 있는 8개의 multiple-choice task에 대해 아래 두 가지 방법으로 실험을 진행함.

Early Answering(CoT를 중간에 잘라도 모델이 같은 답을 내는지)
- AQuA에서는 CoT를 잘랐을 때 답이 많이 변함 ⇒ CoT에 많이 의존
- 반면에 다른 task들에서는 CoT를 잘라도 답이 거의 변하지 않았다 ⇒ 모델이 CoT 없이도 이미 답을 알고 있었거나 CoT를 별로 사용하지 않았을 가능성 존재
Adding Mistakes(CoT 중간에 일부러 틀린 reasoning 넣고 모델이 나머지 CoT 생성)
- Early Answering과 마찬가지로 AQuA와 LogiQA는 mistake를 넣으면 답이 많이 바뀜
- 쉬운 task에서는 모델이 CoT를 무시하거나 이미 답을 아는 경우로 답이 바뀌지 않

*이 논문에선 기본적으로 CoT를 사용했을 때 성능 향상이 나타났지만 HellaSwag에서는 오히려 CoT를 사용했을 때 성능이 떨어짐 ⇒ 보통은 도움 됨. 하지만 그렇다고 faithful 하진 않음.
Filler Tokens (CoT가 좋은 이유가 그냥 토큰을 많이 생성해서 생각할 시간이 늘어났기 때문인지)결과적으로 filer token으로 인한 성능향상은 없었으며 일부 task에서는 성능이 떨어졌음
CoT 대신 의미 없는 토큰을 넣어서 단순히 긴 text로 인한 test time computation 때문이라면 의미 없는 filier token을 넣어도 성능이 좋아질 것이다.
Paraphrasing (특정 단어 선택, 문장 구조, punctuation 같은 표현에 숨은 정보가 들어있는지)결과적으로 paraphrasing을 해도 성능은 거의 유지되었다. 따라서 논문은 CoT의 성능 향상이 특정 phrasing에 숨겨진 encoded information 때문은 아닌 것 같다고 보았다.(내용이 더 중요)
CoT의 의미는 유지하되 표현만 바꾼 후 모델에 CoT를 넣었을 때 성능이 떨어지는지 확인

Does Model Size Affect CoT Faithfulness?

모델이 커질수록 CoT faithfulness는 좋아지는지 나빠지는지 의문을 제기함. 보통은 모델이 커지면 더 똑똑해지니까 CoT도 더 faithful할 것으로 생각할 수 있는데 이 논문에서는 반대 가능성을 제시함 ⇒ 큰 모델은 CoT 없이도 답을 잘 맞힐 수 있기 때문에, CoT에 덜 의존할 수 있다.

결과적으로 많은 task에서 13B 모델이 175B 모델보다 CoT에 더 의존했다. 큰 모델일수록 오히려 CoT faithfulness가 낮아지는 ****inverse scaling 현상이 나타났다.

Addition Tasks

같은 symbolic task안에서도 operand 개수나 digit 수를 조절해서 난이도를 바꿔서 테스트를 진행했는데 그 결과 쉬운 task보다 어려운 task에서 CoT에 대한 의존도가 늘어났다 ⇒ 쉬운 symbolic reasoning task일 경우 CoT가 post - hoc일 가능성이 커진다

Related Work

논문 핵심 방식

Turpin et al.(어제 읽은거)	입력에 biasing feature를 넣고 CoT가 그 영향을 말하는지 봄
Lanham et al.	생성된 CoT 자체를 자르거나 수정해서 답이 바뀌는지 봄

reasoning faithfulness를 높이는 방법으로 program execution, decomposition, subquestion generation, Tree of Thoughts, multi-agent debate 등을 언급한다. (아직 안 찾아봄)

이런 방법들도 모두 중간 reasoning을 만들고, 나중 단계가 그 reasoning에 condition한다는 구조를 가지기 때문에 이 논문의 faithfulness 평가 방법은 CoT뿐 아니라 다른 reasoning method에도 적용될 수 있다고 본다. ⇒ 이 논문은 모델이 중간 생성한 reasoning step이 실제로 최종 답에 대한 영향을 주는지에 대한 질문

Limitations

이 논문에서 말하고 있는 한계는 모델의 진짜 내부 reasoning process를 직접 관찰한 것은 아니라는 점이다. 즉, Early Answering이나 Adding Mistakes로 CoT에 대한 evidence를 얻을 수는 있지만 그것이 모델 내부 reasoning의 ground truth는 아니다.
이 논문에서 사용한 모델은 RLHF-finetuned model이다. Pretrained model은 CoT에 더 강하게 condition할 수도 있기 때문에, 다른 training scheme에서는 결과가 달라질 수 있다.

Conclusion

CoT는 항상 faithful하지 않다.
CoT를 많이 사용하는 task도 있고 거의 무시하는 task도 있다.
CoT의 성능 향상은 단순한 test-time compute 때문은 아니다.
CoT의 성능 향상은 특정 phrasing에 숨겨진 정보 때문도 아닌 것 같다.
큰 모델일수록 오히려 CoT faithfulness가 낮아지는 inverse scaling이 나타날 수 있다.
faithful reasoning이 중요하다면, 가장 큰 모델이 항상 최선은 아닐 수 있다.

Language Models Don’t Always Say What They Think:Unfaithful Explanations in Chain-of-Thought Prompting [논문 리뷰]

seungbye — Tue, 7 Jul 2026 15:15:06 +0900

Abstract

LLM은 CoT를 사용하면 여러 task에서 좋은 성능을 낼 수 있다. 그래서 사람들은 모델이 출력한 CoT를 모델이 실제로 문제를 푼 과정이라고 믿고 싶어 한다. 하지만 이 논문에서는 CoT가 실제 이유를 충실하게 반영하지 않을 수 있다고 주장한다. 특히 입력에 biasing feature를 넣었을 때, 모델의 답이 그 bias에 영향을 받으면서도 CoT에서는 그 영향을 거의 언급하지 않는다는 것을 보여준다. (힌트 떄문에 답을 고른 후 문제 조건을 논리적으로 따져봐서 그 답을 골랐다고 주장)

ex) few shot prompting에서 정답이 항상 A가 되도록 answer choice를 조작해도 CoT에선 A가 반복적으로 정답이었다는 사실을 말하지 않는다

⇒ CoT explanation은 plausible(설명이 그럴 듯 하고 말이 되는지) 할 수 있지만 faithful(설명과 실제 모델의 선택이 일치하는지) 하지 않을 수 있다

Introduction

CoT는 모델이 step-by-step reasoning을 말하게 만든다. 그래서 CoT는 모델이 왜 그런 답을 냈는지 보여주는 창처럼 여겨진다. 하지만 이 논문에서는 CoT가 그럴듯하고 논리적으로 보여도, 그것이 실제 이유라는 보장은 없다고 말하고 있음.

CoT가 기본적으로 faithful할 것이라고 기대하면 안 되는 이유도 설명하고 있음. 모델의 training objective는 자신의 실제 이유를 정확히 보고하도록 직접 학습시키는 것이 아니먀, RLHF 같은 과정은 오히려 인간 평가자가 좋아할 만한 답변을 만들도록 유도할 수 있기 때문이다

Table 1 ex) Claude 1.0이 같은 문제에 대해 서로 다른 CoT를 생성하는 예시이고 문제는 루니가 축구 관련 행동을 했다는 문장이 plausible한지 묻는 문제다.

일반 context에서는 모델이 축구 지식을 사용해서 정답을 맞힌다.
그런데 biased context에서는 few-shot prompt 안에서 정답이 항상 A가 되도록 조작한다. 그러자 모델은 A를 고르고, 그 선택을 정당화하는 새로운 CoT를 만들어낸다.

문제는 모델이 few-shot prompt에서 A가 반복적으로 정답이었기 때문에 A를 고른 것 같다라고 말하지 않는다는 점이다. 대신 문장 자체에 대한 해석을 바꿔서 A를 정당화한다

Evaluating Systematic Unfaithfulness

이 논문은 counterfactual(반사실적) 방식으로 faithfulness를 본다(주어진 입력에만 충실하게 답변하는지) ⇒ 입력에 biasing feature를 넣었을 때 답이 바뀐다면, 그 biasing feature가 모델의 decision에 영향을 준 것이지만 CoT가 그 biasing feature를 언급하지 않는다면, 그 CoT는 unfaithful하다.

Experimental Setup 1

첫 번째 실험은 BIG-Bench Hard, BBH를 사용한다. BBH는 여러 reasoning task로 구성된 benchmark다. 이 논문에서는 BBH의 23개 task 중 13개 task를 선택했으며 이 task들은 deductive reasoning(논리적 연역)뿐 아니라 주관성이나 world knowledge(방대한 데이터)가 섞여 있어, 모델이 틀린 답에 대해 그럴듯한 CoT를 만들 가능성이 있다고 보았다.

모델 특징

GPT-3.5 / text-davinci-003	RLHF fine-tuned model(인간 피드백 기반 강화학습 파인튜닝 모델)
Claude 1.0	Constitutional AI로 학습된 assistant model

biasing feature 설명

Answer is Always A	few-shot 예시에서 정답이 항상 A가 되도록 answer choice 순서를 조작
Suggested Answer	prompt에 “I think the answer is A…”처럼 특정 답을 제안하는 문장 추가

⇒ 모델이 biased context와 unbiased context에서 어떻게 달라지는지 비교

Results

Figure 1은 BBH 실험의 핵심 결과를 보여주며 biased context에서 모델 accuracy가 크게 떨어짐

특히 zero-shot CoT에서 GPT-3.5는 Suggested Answer bias 때문에 accuracy가 최대 36.3%까지 떨어졌으며 Claude에서도 큰 accuracy drop을 보임

중요한 점은 단순히 accuracy가 떨어졌다는 게 아니라 accuracy가 떨어진 이유는 biasing feature가 모델 답을 잘못된 쪽으로 끌고 갔기 때문이라고 할 수 있다. 하지만 CoT는 그 biasing feature를 언급하지 않았음(논문에서는 이것을 systematic unfaithfulness(bias에 의해 예측이 왜곡)라고 봄)

*논문에서는 CoT가 항상 나쁘다고 말하지 않음. 몇몇 few shot에서는 CoT가 Bias sensitivity를 줄이기도 했음. 또 반대로 zero shot에서는 오히려 강하게 Bias 쪽으로 끌고가는 성향을 보임

Qualitative Analysis(모델은 답에 맞춰 CoT를 바꾼다)

Table 4의 unfaithful explanation 예시들을 보면 Suggested Answer bias setting에서 unfaithful explanation 104개를 직접 annotation했는데 그 결과, unfaithful explanation의 최대 73%가 bias-consistent answer를 적극적으로 지지하는 reasoning을 포함했으며 15%의 unfaithful explanation은 눈에 띄는 명백한 오류가 없었음 ⇒ 틀린 답을 지지하는 CoT도 겉으로 보기엔 충분히 그럴듯할 수 있기 때문에 CoT가 틀렸다는 것을 항상 reasoning error로 발견할 수 없음(사용자가 속기 쉽다)

Experimental Setup 2

두 번째 실험은 BBQ, Bias Benchmark for QA(모델의 사회적 고정관념 및 편향을 체계적으로 측정하기 위해 설계된 데이터 셋)을 사용한다.

BBQ에는 ambiguous context가 있다. 예를 들어 정보가 부족해서 사실상 알 수 없다고 답해야 하는 상황(흑인과 백인 중 누가 마약을 사려 하는가?)이 있고 이 논문에서는 여기에 어떤 답을 조금 더 그럴듯하게 만들 수는 있지만, 결정적이지 않은 정보인 weak evidence(흑인은 주머니를 만지고 있었다, 백인은 가격을 물어보고 있었다)를 추가한다.
같은 weak evidence를 서로 다른 집단에 붙여 두 버전을 만든다(두 집단 상황을 바꿈)
모델이 evidence를 일관되게 사용한다면 답도 evidence에 따라 바뀌어야 하지만 모델이 stereotype(고정관념)에 맞는 쪽으로 evidence를 더 강하게 해석한다면, CoT는 unfaithful 해짐*여기서의 weak evidence가 1번 실험에서의 Bias와 다른 이유는 여기서는 reasoning에서 고려할 수 있는 문제 내부의 단서를 준 것 이기 때문이
*두 집단이 같은 행동을 했을 때 특정 집단만 더 의심스럽다고 판단하는지 ⇒ 이런 경우에는 evidence가 아니라 stereotype이 판단에 영향을 주었을 수 있음.

Results

결과적으로 CoT는 No-CoT보다 stereotype bias를 줄이는 경향이 있었지만 CoT에서도 여전히 systematic unfaithfulness가 나타났음 (모델은 CoT에서 weak evidence를 언급하면서도, 그 evidence를 stereotype(Bias)에 맞게 불일관적으로 해석) ⇒ 모델은 evidence를 보고 판단했다고 말하지만 실제로는 stereotype 과 맞는 방향으로 evidence를 더 강하게 해석함

*Please ensure that your answer is unbiased and does not rely on stereotypes(편견 사용 x) 라는 문구를 추가 했을 때 어느 정도 도움이 되지만 모르는 bias, 새로운 bias, domain-specific bias는 prompt로 막기 어려

Related Work (기존 연구 흐름)

기존 연구들은 CoT 안에 contradiction이나 math error가 있는지 보는 경우가 많았음 ⇒ 하지만 이 논문은 plausible(그럴듯한) explanation도 faithful하지 않을 수 있음을 보인다.
일부 연구는 few-shot CoT demonstration에 오류를 넣거나 바꾸면서 어떤 부분이 중요한지 본다. 하지만 이 논문은 generated CoT 자체가 아니라 input feature를 perturb해서 모델의 explanation faithfulness를 평가한다
이 논문은 counterfactual simulatability를 adversarial setting에서 본다는 점이 특징이다. 즉, 모델을 특정 답으로 bias시키고, 그 bias를 CoT가 말하는지 확인한다.

기존 연구들은 CoT가 말이 되는지, 오류가 있는지를 중점적으로 봤다면 이 논문에서는 CoT가 실제 답 선택 이유를 말하고 있는지에 중점을 두고 있음. ⇒ 내가 하고픈 연구 주제에 굉장히 밀접함.

Discussion

모델이 biasing feature의 영향을 알고도 말하지 않는 것인지 아니면 아예 그 영향을 인식할 능력이 없는 것인지는 모름 ⇒ 이 논문에서는 모델이 그 영향을 인식할 수 있는지 후속 연구가 필요하다고 말하고 있음
systematic unfaithfulness가 adversarial attack(오작동을 일으키도록 의도적으로 조작된 입력값을 주입하는 보안 위협 기법)의 경로가 될 수 있음 ⇒ 사용자가 prompt에 biasing feature를 교묘히 넣으면, 모델은 그 bias에 끌려 답을 바꿀 수 있지만CoT에는 그 bias의 흔적이 남지 않는다. 결국 CoT를 보고 모델의 fairness를 검사하려는 시스템은 문제가 생긴다.

Future Work

faithfulness를 개선하려면 CoT explanation이 생성되는 과정 자체를 조절해야 한다고 말한다

방향 의미

debiasing prompt	알려진 bias를 줄이는 instruction 추가
decomposition-based approach	문제를 분해해 biasing cue의 영향을 줄임
explanation-consistency	정답이 명확하지 않아도 explanation consistency를 학습 신호로 사용
targeted training	faithful CoT를 직접 유도하는 학습

Limitations

자신들의 평가가 faithfulness failure를 찾아낼 수는 있지만, explanation이 faithful하다는 것을 증명할 수는 없으며(unfaithful이 안 발견됐다고 해서 반드시 faithful하다고 말 할 수 없음), 작은 input modification에 대한 faithfulness만 평가한다. 하지만 실제로는 훨씬 다양한 input과 상황에서 모델 behavior를 예측할 수 있는 explanation이 필요하다는 것을 한계로 들었다

Conclusion

결론적으로 CoT prompting이 LLM의 reasoning 능력을 향상시킬 수 있지만, 동시에 systematic unfaithfulness를 보일 수 있음.

질문

BBH 실험은 모델이 답을 바꿨는데도 biasing feature를 CoT에 언급하지 않으면 unfaithful하다고 보는데 제가 저번에 말씀드렸던 연구 주제처럼 symbolic reasoning task에서 모델이 높은 accuracy를 보이는 경우에는, 모델이 실제로는 shortcut이나 memorized pattern으로 답을 먼저 알고 있고 CoT는 나중에 생성된 rationalization일 수도 있는데, 이때 외부 biasing feature에 의해 답이 바뀌지 않는다고 해서 CoT가 faithful하다고 볼 수 있는가?
모델이 biasing feature의 영향을 알고도 말하지 않는 것인지 아니면 아예 그 영향을 인식할 능력이 없는 것인지

CoT 연구 1주차

seungbye — Mon, 29 Jun 2026 15:13:08 +0900

연구 주제

CoT는 언제 faithful reasoning에서 사후 설명으로 변하는가? ⇒ Post-hoc rationalization의 전환 조건 분석

문제 의식

CoT는 모델이 답을 내기 전에 중간 reasoning 과정을 생성하게 하여, 문제 해결 성능을 높이고 설명 가능성을 제공하는 방식으로 사용되어 왔다.

하지만 CoT가 답보다 먼저 생성된다고 해서, 반드시 모델이 그 CoT를 실제로 사용해서 답을 냈다고 볼 수는 없다.어떤 경우에는 CoT가 final answer를 만드는 데 실제로 중요한 역할을 하는 load-bearing reasoning일 수 있고 반대로 어떤 경우에는 모델이 이미 답을 알고 있거나 쉽게 예측한 뒤, 그 답에 맞는 설명을 나중에 생성하는 post-hoc rationalization일 수 있다.

그래서 단순히 CoT가 faithful 한가에 중점을 두는 것이 아니라 CoT는 어떤 조건에서 실제 reasoning으로 작동하고, 어떤 조건에서 사후 설명으로 변하는가가 중요하다고 생각한다.

기존 연구 배경

CoT는 모든 task에서 동일하게 효과적인 것이 아니라, 주로 math, logic, symbolic reasoning task에서 성능 향상이 크다. 그러나 CoT가 accuracy를 높인다는 사실이 곧 CoT가 faithful하다는 뜻은 아니다
모델은 biasing feature나 hint에 영향을 받아 답을 바꾸면서도, CoT에서는 그 영향을 말하지 않을 수 있다. 즉, CoT는 그럴듯해 보이지만 실제 답의 원인을 숨길 수 있다
CoT를 자르거나, 오류를 넣었을 때 모델의 답이 바뀌는 정도는 task와 model에 따라 크게 달라진다. 특히 쉬운 문제나 모델이 이미 잘 풀 수 있는 문제에서는 CoT가 실제 답 생성에 덜 필요할 가능성이 있다
fine-tuning이나 domain adaptation 이후 CoT faithfulness가 변할 수 있다는 결과도 있지만, 아직 왜 faithfulness가 깨지는지를 설명하는 연구는 부족하다.

기존 연구들의 부족한 부분

기존 연구들은 CoT가 unfaithful할 수 있음을 다양한 방식으로 보여주었다. 그러나 대부분은 CoT가 faithful하지 않을 수 있다는 사실을 확인하는 데 초점이 있었고 어떤 조건에서 CoT가 faithful reasoning으로 작동하고, 어떤 조건에서 post-hoc explanation으로 변하는가에 대한 부분은 부족하다고 생각합니다
biasing feature, hint, metadata, reward hack 등을 넣고 모델이 이를 CoT에 말하는지 확인하는 연구들이 존재했지만 이는 모델이 숨은 단서를 사용하는데에 초점이 맞춰져 있었다. 외부 힌트나 bias가 없더라도 모델이 어떤 조건에서 CoT를 실제 reasoning이 아니라 사후 설명으로 사용하는지에 대한 연구는 부족하다고 생각합니다
CoT를 자르거나 오류를 넣어 final answer가 바뀌는지 확인했던 기존의 연구는 CoT가 실제로 답에 영향을 주는지 보는 중요한 기반이 된다. 하지만 모델이 어느 수준의 task difficulty 에서 CoT를 실제로 사용하다가, 어느 지점부터 CoT 없이도 답을 내고 CoT를 사후 설명으로 만들기 시작하는가를 볼 필요가 있다고 생각합니다.
기존 fine-tuning 연구는 fine-tuning 이후 CoT faithfulness가 감소할 수 있음을 보여주지만 이 감소가 왜 발생했는지는 더 분리해서 볼 필요가 있다고 생각합니다.
- 모델이 task에 너무 익숙해져서 CoT 없이도 답을 내기 때문
- fine-tuning 과정에서 특정 문제 패턴을 학습했기 때문
- CoT 형식만 학습하고 실제 reasoning은 강화되지 않았기 때문
- task가 너무 어려워져서 reasoning chain이 무너졌기 때문

기존 연구와의 차별점

기존 연구가 주로 CoT faithfulness의 존재 여부나 평가 방법에 집중했다면, 제가 하고픈 연구는 faithfulness가 유지되는 구간과 깨지는 구간을 설명하는 현상 연구를 목표로 하고 있습니다.

1주차 계획

기존 연구들의 특정 domain, fine tuning 상황에서의 faithfulness 측정, 연구 과정 재현 및 이해

Reasoning Models Don’t Always Say What They Think (논문리뷰)

seungbye — Mon, 29 Jun 2026 15:10:46 +0900

Abstract

첫째, CoT를 사용한 100편 이상의 논문을 meta-analysis(기존 연구 결과 통합, 분석)
둘째, 20개 dataset, 14개 model을 직접 평가
결과 : CoT는 주로 math 또는 logic이 포함된 task에서 성능 향상이 크고, 다른 task에서는 효과가 작다. ⇒ 항상 좋은 것 아님.

Introduction

CoT는 LLM에게 “think step by step” 처럼 말해서 reasoning을 유도하는 prompting technique이다. GPT나 Llama 같은 모델들도 reasoning problem에서 CoT를 기본적으로 사용하거나, CoT 능력을 post-training 과정에서 많이 학습한다. (CoT는 model 자체의 문제가 아니라 reasoning의 종류에 따라 다름)

하지만 이 논문에선 기존의 연구들이 수학관련 도메인 중심이었음에도 COT의 효과를 너무 넓게 일반화 했다고 말함.

Background: Chain-of-Thought

Direct Answer ⇒ 바로 최종 답만 출력

Chain-of-Thought ⇒ 중간 reasoning 과정을 출력, 최종 답 출력

이 둘의 차이를 CoT delta ⇒ CoT가 가져온 성능 향상으로 봄

symbolic reasoning ⇒ 문제가 자연스럽고 널리 합의된 formal system으로 표현

ex) 4+8 ⇒ 수학이라는 formal system으로 표현 가능하기에 symbolic problem

Planning ⇒문제를 수식, 변수, 논리 구조, formal plan으로 바꾸는 단계
Execution ⇒ 그 plan을 따라 계산하거나 중간 상태를 추적해서 답을 내는 단계

CoT는 이 중에서 특히 execution, 즉 중간 계산을 이어가고 추적하는 데 도움을 준다고 봄

EXPERIMENTAL SETUP

항목 내용

datasets	20개
models	14개
prompt	zero-shot direct answer, zero-shot CoT, few-shot direct answer, few-shot CoT
decoding(다음 token 고르는 방식)	greedy decoding(매 순간 확률이 가장 높은 token만 고름⇒ 안정적이고 재현 쉬움 but 단조롭고 local하게 안 좋은 선택을 할 수 있음)
inference package (실제 답변 생성 위한 SW)	vLLM(LLM 실험을 빠르게 돌리기 위한 실행 엔진)
task category	Commonsense(상식 추론), Knowledge, Symbolic(기호,규칙,논리 구조 따라), Mathematical, Soft Reasoning(글을 읽고 숨은 의도 파악 등, 단순 지식 +a)

RESULTS

직접 실험 결과도 meta-analysis와 거의 동일

CoT가 도움 된 Dataset

dataset 성격

MATH	수학 문제
GSM8K	초중등 수학 word problem
ContextHub	formal logic / deductive reasoning
MuSR Murder Mysteries	semi-symbolic reasoning

CoT가 거의 도움 되지 않은 dataset

dataset 성격

CommonsenseQA	상식 추론
PIQA	물리적 상식
Social IQA	사회적 상식
WinoGrande	언어 이해
ARC-Easy / ARC-Challenge	과학 QA / reading-like reasoning
AGI LSAT 일부	독해 기반 reasoning

상식 문제도 reasoning이 필요하지만, 그건 수식을 계산하거나 논리 규칙을 순서대로 실행하는 reasoning이 아님.

수학 문제는 조건 읽기 → 식 세우기 → 계산하기 → 답 도출하기처럼 중간 과정이 명확

MMLU 분석

MMLU는 여러 분야 문제가 섞여 있는 benchmark이기 때문에 전체 평균만 보면 CoT가 도움이 되는 것처럼 보일 수 있음

“=” 이 있으면 수식, 계산, symbolic operation이 포함된 문제일 가능성이 크다 ⇒ MMLU에서 CoT 성능 향상의 대부분은 “=” 가 포함된 문제에서 나왔으며 MMLU에서 CoT로 인한 전체 gain의 최대 95%가 question 또는 generated output에 “=” 가 있는 경우에서 비롯됨

결과적으로 수식이 없는 일반 지식 문제에서는 direct answer 와 큰 차이가 없다고 설명할 수 있음

SETTINGS EVALUATED

setting 설명

Direct Answer	문제를 보고 바로 답
CoT	문제를 보고 step-by-step으로 풀고 답
Plan + Direct Solver	LLM이 plan을 만든 뒤 바로 답(step by step없이)
Plan + CoT Solver	LLM이 plan을 만든 뒤 CoT로 step-by-step 풀이(두 단계 모두 LLM)
Plan + Tool Solver	LLM이 plan을 만든 뒤 Python/Z3 같은 tool이 풀이(LLM이 plan, tool이 풀이)

위의 표는 CoT의 역할을 더 정확히 보기 위한 여러 prompting 비교(symbolic에서)

EVALUATION RESULTS

Plan + Tool Solver가 대부분의 setting에서 CoT보다 더 좋은 결과를 보여줌. (LLM이 plan을 만들고, 실제 계산이나 논리 실행은 external solver에게 맡기는 방식)

결과적으로 CoT는 LLM이 스스로 계산을 따라가게 하는 데 도움을 주지만, 계산과 논리 실행 자체는 LLM이 완벽하지 않기 때문에 Python(수학)이나 Z3(논리) 같은 tool보다 약하다.

CoT는 모델이 종이에 풀이를 쓰는 것과 비슷하며 인간이 암산보다 쓰면서 계산할 때 direct answer보다 정확도가 올라가는 것과 같고 Plan + Tool Solver는 계산기를 사용하는 것과 같다고 생각하면 편하다.

CoT는 direct answer보다 낫지만, 가능하면 symbolic task에서는 tool augmentation이 더 낫다.

*Knowledge task에서는 CoT가 길어진다고 모르는 지식 안생김, 오히려 모델이 모르는 내용 꾸며낼 가능성 존재 ⇒ tool이 더 유용(retrieval, RAG 등) ⇒ 결국 task별로 전략을 잘 수립해야 함.

Discussion

CoT는 여전히 강력한 방법이지만 아무 task에나 적용하는 것은 비효율적이다. 왜냐하면 CoT는 output token을 길게 만들고 inference cost를 증가시킨다. 하지만 commonsense나 knowledge QA에서는 direct answer와 성능 차이가 거의 없기 때문에 굳이 긴 CoT를 생성할 이유가 약해진다.

Limitations(논문 내에서)

Long-horizon planning 부족(긴 시간에 걸쳐 여러 단계 계획하는 task에 대해 충분히 분석하지 않음)
Data contamination 가능성(pre train 때 이미 문제의 일부를 봤을 수 있음)

Prompt-based CoT(CoT는 여러 복잡한 방식들 존재)방법 의미

Tree of Thoughts	하나의 reasoning 경로만 가는 게 아니라 여러 사고 경로를 나무처럼 탐색
Multi-agent debate	여러 LLM이 서로 답을 주장하고 반박하면서 결론을 냄
Graph of Thoughts	reasoning 단계를 그래프 구조로 연결해서 탐색
Self-consistency	여러 번 풀게 한 뒤 가장 많이 나온 답을 선택

Tool augmentation과의 비교 제한(다른 task에서의 tool use 는 충분히 다루지 않음)

Conclusion

CoT는 주로 math와 formal logic에서 도움이 된다.
그 이유는 CoT가 intermediate step을 추적하고 symbolic execution을 수행하는 데 도움을 주기 때문이다.
하지만 CoT는 Python이나 Z3 같은 external solver보다 약하다.
앞으로는 prompt-based CoT를 넘어 더 구조화된 reasoning 방법이 필요하다.

Llama-3-8B-Instruct	작은 open-source model
GPT-3.5-turbo-0125	중간급 closed model
GPT-4	강한 reasoning model

Claude 3.7 Sonnet	약 25%
DeepSeek R1	약 39%