📄 Toolformer: Language Models Can Teach Themselves to Use Tools

📋 메타 정보

• 저자: Timo Schick, Jane Dwivedi-Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, Thomas Scialom
• 기관: Meta AI Research, Universitat Pompeu Fabra (Roberto Dessi)
• 발표처: NeurIPS 2023 (Oral Presentation)
• 연도: 2023 (arXiv: 2023년 2월 9일)
• arXiv: https://arxiv.org/abs/2302.04761
• OpenReview: https://openreview.net/forum?id=Yacmpz84TH
• NeurIPS Proceedings: https://proceedings.neurips.cc/paper_files/paper/2023/hash/d842425e4bf79ba039352da0f658a906-Abstract-Conference.html

---

🎯 한줄 요약

자기지도학습(Self-supervised Learning) 방식으로 언어 모델이 스스로 외부 API 도구(계산기, 검색엔진, QA 시스템 등)를 언제, 어떻게 사용할지 학습하여, 6.7B 모델로도 175B GPT-3를 능가하는 성능을 달성한 최초의 범용적 도구 학습 연구.

---

🔍 연구 배경 및 동기

기존 문제점

1. LLM의 역설적 한계: 대규모 언어 모델(LLM)은 few-shot 학습에서 뛰어난 능력을 보이지만, 역설적으로 단순한 산술 연산이나 사실 검색(factual lookup)에서는 훨씬 작고 단순한 특화 모델보다 성능이 떨어짐
2. 기존 도구 사용 방식의 한계:
   • 대량의 인간 감독(human supervision) 필요
   • 특정 태스크에 맞춤화된 few-shot 프롬프팅 방식
   • 어떤 도구를 사용해야 하는지 사전에 알고 있어야 함
3. 스케일 의존성: 계산이나 번역 같은 작업을 LLM이 수행하려면 매우 큰 규모의 모델이 필요

왜 이 연구가 필요한가

• 도구 사용을 통해 작은 모델로도 큰 모델 수준의 성능 달성 가능
• 인간 감독 없이 자율적으로 도구 사용법 학습
• 다양한 도구를 상황에 맞게 선택적으로 활용하는 범용적 접근법 필요

핵심 설계 원칙 (저자 인용)

“도구 사용은 대량의 인간 주석 없이 자기지도 방식으로 학습되어야 한다. 이는 비용 문제뿐만 아니라, 인간이 유용하다고 생각하는 것과 모델이 유용하다고 판단하는 것이 다를 수 있기 때문이다.”

“LM은 일반성을 잃지 않아야 하며, 언제 어떤 도구를 어떻게 사용할지 스스로 결정할 수 있어야 한다.”

---

💡 핵심 아이디어

자기지도 학습 기반 도구 사용

Toolformer의 핵심은 언어 모델이 스스로 API 호출을 생성하고, 이 중 유용한 것만 필터링하여 학습하는 것이다.

주요 개념

1. API 호출 표현 (API Call Representation)

[API_name(input) → output]

• 특수 토큰 [와 ]로 API 호출의 시작과 끝을 표시
• API 호출은 튜플 형태: (API 이름, 입력 파라미터)
• 입력과 출력 모두 텍스트 시퀀스로 표현
• 실제 구현에서는 [, ], ->를 각각 <API>, </API>, →로 사용

예시:

"From this, we have 10 - 5 minutes = [Calculator(10 - 5) → 5] 5 minutes."
"The capital of France is [QA(What is the capital of France?) → Paris] Paris."

2. 5가지 통합 도구

도구	설명	용도	사용 비율 (LAMA)
Calculator	수학 연산 수행	산술 계산	98% (Math)
Q&A System	Atlas 기반 질의응답	사실 확인	98.1% (LAMA)
Wikipedia Search	위키피디아 검색	정보 검색	QA 태스크
Machine Translation	기계 번역	다국어 처리	MLQA
Calendar	날짜/시간 정보	시간 관련 질의	TempLAMA

3. 유용성 기반 필터링 (Fitness Score) ⭐ 핵심 기여

• API 호출이 미래 토큰 예측에 도움이 되는지 평가
• Perplexity(혼란도) 감소를 기준으로 유용한 API 호출만 선별
• 논문의 가장 중요한 기여: 모델에게 실제로 도움이 되는 API 호출만 학습 데이터에 포함

---

🏗️ 아키텍처 / 방법론

기본 모델 및 데이터

• Base Model: GPT-J (6.7B parameters) – EleutherAI
• 학습 데이터: CCNet (Common Crawl의 정제된 버전)의 부분집합

전체 파이프라인 (4단계)

┌─────────────────────────────────────────────────────────────────┐
│                    Toolformer Training Pipeline                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Step 1: Sampling                                               │
│  ┌─────────────┐    ┌──────────────┐    ┌─────────────────┐    │
│  │  CCNet      │ -> │ Few-shot     │ -> │ Candidate API   │    │
│  │  Dataset C  │    │ Prompting    │    │ Calls Generated │    │
│  └─────────────┘    └──────────────┘    └─────────────────┘    │
│                                                                  │
│  Step 2: Executing                                              │
│  ┌─────────────────┐    ┌────────────────────────────────┐     │
│  │ Candidate APIs  │ -> │ Execute APIs & Get Results     │     │
│  └─────────────────┘    └────────────────────────────────┘     │
│                                                                  │
│  Step 3: Filtering                                              │
│  ┌─────────────────┐    ┌────────────────────────────────┐     │
│  │ API + Results   │ -> │ Filter by Loss Reduction       │     │
│  │                 │    │ (L⁻ - L⁺ ≥ τ_f)               │     │
│  └─────────────────┘    └────────────────────────────────┘     │
│                           ↓                                     │
│                    ┌────────────────┐                          │
│                    │ Augmented      │                          │
│                    │ Dataset C*     │                          │
│                    └────────────────┘                          │
│                           ↓                                     │
│  Step 4: Fine-tuning                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │           GPT-J Fine-tuned on C* → Toolformer           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Step 1: API 호출 샘플링 (Sampling)

과정

1. CCNet 데이터셋에서 텍스트 추출
2. 각 도구별 휴리스틱으로 관련 텍스트 필터링
3. Few-shot 프롬프팅으로 API 호출 후보 생성

위치 샘플링 메커니즘

• 각 위치에서 API 호출 시작 토큰의 확률 계산
• 임계값(τ_s) 이상인 위치들을 후보로 선정
• 각 위치에서 최대 m개의 API 호출 생성

휴리스틱 예시 (Calculator)

# Calculator 도구용 텍스트 선별 조건
def is_calculator_relevant(text, window_size=100):
    # 100 토큰 윈도우 내 3개 이상의 숫자 포함
    # AND "=", "equals", "equal to", "total of", "average of" 등 포함
    return (count_numbers(text, window_size) >= 3 and
            contains_math_keywords(text))

Few-shot 프롬프트 예시

Input: The population of Tokyo is approximately 14 million people.
Output: The population of Tokyo is approximately [QA(What is the population of Tokyo?) → 14 million] 14 million people.

Input: Calculate the total: 15 + 27 = 42
Output: Calculate the total: 15 + 27 = [Calculator(15 + 27) → 42] 42

Step 2: API 실행 (Executing)

생성된 모든 API 호출을 실제로 실행하여 결과 획득

def execute_api_call(api_name, input_params):
    if api_name == "Calculator":
        return eval_math_expression(input_params)
    elif api_name == "QA":
        return qa_system.answer(input_params)  # Atlas 기반
    elif api_name == "WikiSearch":
        return wikipedia.search(input_params)
    elif api_name == "MT":
        return translation_system.translate(input_params)
    elif api_name == "Calendar":
        return get_current_date()

Step 3: 필터링 (Filtering) ⭐ 핵심 기여

핵심 수식: Loss 기반 필터링

L^+ = \sum_{j=i}^{n} w_j \cdot \log P(x_j | x_1, \ldots, x_{i-1}, c, r) L^- = \min(L^-_{\text{empty}}, L^-_{\text{no\_result}})

필터링 조건: L^- - L^+ \geq \tau_f

여기서:
– L+: API 호출과 결과를 포함했을 때의 손실
– L-_empty: API 호출 없을 때의 손실
– L-_no_result: API 호출은 있지만 결과가 없을 때의 손실
– τ_f: 필터링 임계값
– w_j: 위치 기반 가중치 (API 호출 위치에 가까울수록 높음)

직관적 해석

“빈 문자열이나 API 결과 없이도 다음 단어 예측이 가능하다면, 그 API 호출은 불필요하다. 오직 모델에게 실제로 도움이 되는 API 호출만 학습 데이터에 포함한다.”

Pseudo Code

def filter_api_calls(text, api_call, result, threshold=τ_f):
    # L+: API 호출 + 결과 포함 시 손실
    L_plus = compute_loss(text_with_api_and_result)

    # L-_empty: API 호출 없을 때 손실
    L_minus_empty = compute_loss(text_without_api)

    # L-_no_result: API 호출만 있고 결과 없을 때 손실
    L_minus_no_result = compute_loss(text_with_api_no_result)

    # L-는 둘 중 최소값
    L_minus = min(L_minus_empty, L_minus_no_result)

    # 필터링 조건: 손실 감소가 임계값 이상이면 유지
    return (L_minus - L_plus) >= threshold

Step 4: 파인튜닝 (Fine-tuning)

학습 설정

하이퍼파라미터	값
베이스 모델	GPT-J (6.7B)
배치 크기	128 (effective)
학습률	1e-5
웜업	처음 10% linear warmup
최대 시퀀스 길이	1,024
API당 최대 예시 수	25,000
데이터셋	CCNet 부분집합 (API 호출로 augmented)

추론(Inference) 방식

• API 토큰이 상위 10개 확률 토큰에 포함되면 API 호출 시작
• 입력당 최대 1개의 API 호출로 제한
• Zero-shot 설정, Greedy decoding 사용

---

📊 실험 및 결과

평가 데이터셋

카테고리	데이터셋	설명
LAMA	SQuAD, GoogleRE, T-REx	사실 완성 태스크
Math	ASDiv, SVAMP, MAWPS	수학 문제 풀이
QA	Web Questions, Natural Questions, TriviaQA	질의응답
Language Modeling	WikiText, CCNet subset	언어 모델링
Multilingual QA	MLQA	다국어 질의응답
Temporal	TempLAMA	시간 관련 추론

비교 모델 구성

모델	설명
GPT-J	기본 GPT-J, 미세조정 없음
GPT-J + CC	CCNet으로 미세조정, API 호출 없음
Toolformer	CCNet + API 호출로 미세조정
Toolformer (disabled)	Toolformer와 동일, 추론 시 API 비활성화

주요 결과

LAMA 벤치마크 성능

• Toolformer는 QA 도구를 98.1% 케이스에서 사용
• 0.7%만 다른 도구 사용, 1.2%는 도구 미사용
• 동일 크기의 모든 베이스라인을 명확히 능가
• GPT-3 (175B)와 경쟁적인 성능 달성

수학 벤치마크 성능 (ASDiv 등)

• Calculator 도구를 98%의 샘플에서 사용
• OPT (66B)와 GPT-3 (175B)를 큰 차이로 능가
• 베이스라인 대비 각각 11.7, 5.2, 18.6 포인트 향상

Question Answering (WebQ, NQ, TriviaQA)

• Wikipedia Search API를 사용해 99.3% 정확도 달성
• GPT-J 기반 모델들 대비 우수
• 단, GPT-3 (175B)에는 미달 (검색 엔진의 단순성과 상호작용 불가 때문)

모델 크기별 도구 사용 능력

모델 크기	도구 사용 효과
124M	효과 없음
355M	미미한 효과
775M	도구 사용 능력 emergence
1.6B+	명확한 성능 향상

핵심 발견: 도구 사용 능력은 약 775M 파라미터에서 출현(emerge)함

언어 모델링 성능 유지

• WikiText와 CCNet subset에서 perplexity 평가
• Toolformer가 기존 언어 모델링 능력을 손상시키지 않음

---

💪 강점 및 기여

1. 자기지도 학습 (Self-Supervised Learning)

• 인간 감독 최소화: 각 API당 소수의 demonstration만 필요
• 자동 데이터 생성: 모델이 스스로 학습 데이터 생성 및 필터링

2. 범용성 (Generalizability)

• 단일 모델이 다양한 도구를 상황에 맞게 선택
• 특정 태스크에 종속되지 않는 범용적 접근

3. 효율성 (Efficiency)

• 6.7B 모델로 175B 모델 성능 달성
• 도구 사용을 통한 compute-performance trade-off 개선

4. 확장성 (Extensibility)

• 새로운 도구 추가가 용이
• 텍스트 기반 API 인터페이스로 다양한 도구 통합 가능

5. 언어 능력 보존

• 도구 사용 학습 후에도 기존 언어 모델링 능력 유지

6. 방법론적 혁신 (Fitness Score)

• 논문의 가장 중요한 기여: 손실 감소 기반 API 호출 필터링
• 모델 관점에서 유용한 도구 사용 패턴만 학습

---

⚠️ 한계점 및 향후 연구

주요 한계점

1. 도구 체이닝 불가 (No Tool Chaining)

불가능한 예시:
[Search(query)] → result → [Calculator(result)]

• API 호출이 독립적으로 생성되어 체이닝 불가
• 한 도구의 출력을 다른 도구의 입력으로 사용할 수 없음

2. 인터랙티브 모드 부재

• 검색 결과 브라우징 불가
• 쿼리 수정/개선 불가
• 여러 검색 결과 중 선택 불가

3. 입력 민감성 (Input Sensitivity)

• 정확한 문구(wording)에 따라 도구 사용 결정이 달라질 수 있음

4. 비용 인식 부재

• API 호출의 계산 비용을 고려하지 않음
• 비용 대비 효용 최적화 미지원

5. 모델 크기 제약

• 최소 775M 파라미터 이상에서만 효과적
• 더 작은 모델에서는 도구 사용 능력 부재

6. 일반화 한계

• 학습 시 접한 도구에 국한된 사용 경향
• 새로운 도구로의 일반화 미검증

7. 언어별 성능 차이

• CCNet 미세조정이 일부 언어에서 성능 저하 유발

향후 연구 방향 (저자 인터뷰 기반)

1. 다단계 도구 호출 (Multi-step Tool Calling)

“다음 명백한 단계는 여러 도구와 여러 단계의 호출을 갖는 것이다.” – Thomas Scialom

2. 긴 문맥 처리를 위한 도구 활용

• Transformer의 컨텍스트 윈도우 한계(4K-8K 토큰)를 도구로 극복

3. 모델 자체를 도구로 사용 (Self-Reasoning)

“모델 자체를 도구로 삼아 추론 모드에서 자기 자신을 호출하는 것에 관심이 있다.” – Timo Schick

4. 인터랙티브 도구 사용

• 검색 결과 탐색 및 쿼리 개선 지원

---

🔗 관련 논문

직접 관련 연구 (선행)

논문	연도	특징
TALM (Parisi et al.)	2022	Toolformer와 가장 유사, 자기지도 목적함수 사용, 다운스트림 미세조정 설정 탐구
WebGPT (Nakano et al.)	2021	웹 브라우징을 통한 질의응답
LaMDA (Thoppilan et al.)	2022	대화형 AI의 도구 사용
PAL (Gao et al.)	2022	Program-Aided Language Models

후속 연구 및 관련 연구

논문	연도	특징
ReAct	2023 (ICLR)	Thought-Act-Observe 사이클, Zero-shot 프롬프트 기반
Gorilla	2024 (NeurIPS)	1,600+ API 호출 지원, LLaMA 기반 미세조정, 할루시네이션 감소
ToolLLM/ToolBench (Qin et al.)	2023	16,000+ API 스케일업, DFSDT 추론 전략
HuggingGPT (Shen et al.)	2023	HuggingFace 모델 오케스트레이션
Chameleon (Lu et al.)	2023	Plug-and-Play 도구 조합
ToolkenGPT	2023	도구를 토큰으로 표현하는 접근
ART	2023	자동 다단계 추론 및 도구 사용

분류 체계

카테고리	논문
Fine-tuning 기반	Toolformer, TALM, Gorilla, ToolRL, ToolkenGPT
Tuning-free (Zero-shot)	ReAct, ToolAlpaca
RAG 증강	Gorilla (retrieval-augmented), ToolLLM

---

💻 실무 적용 포인트

구현 시 고려사항

1. API 호출 형식 정의

# API 호출 토큰 정의
SPECIAL_TOKENS = {
    "api_start": "[",
    "api_end": "]",
    "result_sep": "→"
}

# 예시 포맷
def format_api_call(api_name, input_text, result=None):
    if result:
        return f"[{api_name}({input_text}) → {result}]"
    return f"[{api_name}({input_text})]"

2. 새로운 도구 추가 가이드

1. Few-shot Prompt 작성: 해당 API의 사용 예시 5-10개 작성
2. 데이터 샘플링: 코퍼스에서 API 호출 삽입 위치 샘플링
3. 필터링: 손실 감소 기준으로 유용한 API 호출만 선별
4. 미세조정: 선별된 데이터로 모델 학습

3. 필터링 임계값 설정

# 논문에서 제안한 기본값
FILTER_THRESHOLD = 1.0  # τ_f

def should_keep_api_call(L_minus, L_plus, threshold=FILTER_THRESHOLD):
    return (L_minus - L_plus) >= threshold

4. 도구별 휴리스틱 구현

TOOL_HEURISTICS = {
    "Calculator": {
        "min_numbers": 3,
        "window_size": 100,
        "keywords": ["=", "equals", "equal to", "total of", "average of"]
    },
    "QA": {
        "question_words": ["who", "what", "when", "where", "why", "how"]
    },
    # ... 기타 도구
}

5. 추론 시 API 호출 처리

def inference_with_tools(model, prompt, tools):
    generated = model.generate(prompt)

    # API 호출 토큰 감지 (상위 10개 확률 토큰에 포함 시)
    if "[" in generated:
        api_call = extract_api_call(generated)
        result = execute_tool(api_call, tools)

        # 결과 삽입 후 계속 생성
        generated = generated.replace(
            f"[{api_call}]",
            f"[{api_call} → {result}]"
        )
        generated += model.continue_generation(generated)

    return generated

오픈소스 구현체

• lucidrains/toolformer-pytorch: https://github.com/lucidrains/toolformer-pytorch
• conceptofmind/toolformer: https://github.com/conceptofmind/toolformer

프로덕션 적용 시 주의점

1. 최소 모델 크기: 775M 파라미터 이상 필요 (도구 사용 능력 발현 임계점)
2. API 레이턴시: 외부 API 호출로 인한 응답 지연 고려
3. 에러 핸들링: API 실패 시 fallback 전략 필요
4. 비용 관리: API 호출 횟수 및 비용 모니터링
5. 캐싱: 동일 쿼리에 대한 결과 캐싱으로 효율성 향상
6. 토큰 설계: 기존 토크나이저와 충돌하지 않는 특수 토큰 선정

현대 에이전트 프레임워크와의 연결

• LangChain: ReAct 패턴 구현, 도구 통합
• MetaGPT: 다중 에이전트 도구 사용
• Toolformer의 아이디어가 현대 LLM 에이전트의 Function Calling 기초가 됨

---

🏷️ Tags

#AIAgent #ToolUse #SelfSupervised #LLM #MetaAI #NeurIPS2023 #APIIntegration #LanguageModel #GPT-J #ZeroShot #ToolLearning #Toolformer #FunctionCalling #Calculator #Search #QA #FineTuning #DataAugmentation #LossFiltering

---

📚 References

1. Schick, T., et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. NeurIPS 2023.
2. arXiv: https://arxiv.org/abs/2302.04761
3. OpenReview: https://openreview.net/forum?id=Yacmpz84TH
4. Meta AI Publication: https://ai.meta.com/research/publications/toolformer-language-models-can-teach-themselves-to-use-tools/