1
# 传统 RAG
2
rag_output = generator.generate(question, retrieved_docs)
3

4
# Toolformer
5
toolformer_output = model.decide_and_execute_tools(question)
6
# 模型自己决定：是否调用工具、调用什么工具、传入什么参数

1
class Toolformer:
2
    """自监督工具学习框架"""
3

4
    def __init__(self, model, tools):
5
        self.model = model
6
        self.tools = tools
7

8
    def train(self, corpus):
9
        """
10
        三个阶段的自监督训练
11
        """
12
        # 阶段 1: 采样 API 调用
13
        api_calls = self.sample_api_calls(corpus)
14

15
        # 阶段 2: 执行 API 调用
16
        executed = self.execute_api_calls(api_calls)
17

18
        # 阶段 3: 过滤有效调用
19
        filtered = self.filter_successful(executed)
20

21
        # 微调
22
        self.fine_tune(filtered)

1
class APISampler:
2
    """采样 API 调用"""
3

4
    def __init__(self, model, tools):
5
        self.model = model
6
        self.tools = tools
7

8
    def sample_api_calls(self, text):
9
        """
10
        让模型决定在什么位置调用什么 API
11
        """
12
        api_calls = []
13

14
        # 在每个 token 位置决定是否调用 API
15
        for position in range(len(text)):
16
            # 构造上下文
17
            context = text[:position]
18

19
            # 让模型决定
20
            action = self.model.decide(
21
                context,
22
                available_tools=list(self.tools.keys())
23
            )
24

25
            if action["type"] == "api_call":
26
                api_calls.append({
27
                    "position": position,
28
                    "tool": action["tool"],
29
                    "arguments": action["args"]
30
                })
31

32
        return api_calls

1
class APIExecutor:
2
    """执行 API 调用"""
3

4
    def __init__(self, tools):
5
        self.tools = tools
6

7
    def execute(self, api_call):
8
        """
9
        执行单个 API 调用
10
        """
11
        tool_name = api_call["tool"]
12
        args = api_call["arguments"]
13

14
        if tool_name == "calculator":
15
            result = eval(args["expression"])
16
        elif tool_name == "search":
17
            result = search_engine.query(args["query"])
18
        elif tool_name == "translator":
19
            result = translator.translate(
20
                text=args["text"],
21
                target_lang=args["target_lang"]
22
            )
23
        elif tool_name == "calendar":
24
            result = calendar.get_current_date()
25

26
        return {
27
            "status": "success",
28
            "result": result,
29
            "api_response": str(result)
30
        }

1
class APIFilter:
2
    """过滤有效 API 调用"""
3

4
    def __init__(self):
5
        self.pass_count = 0
6
        self.total_count = 0
7

8
    def is_helpful(self, original_text, api_call, response):
9
        """
10
        判断 API 调用是否有价值
11
        """
12
        # 1. API 调用必须成功执行
13
        if response["status"] != "success":
14
            return False
15

16
        # 2. 响应不能太长
17
        if len(response["result"]) > 500:
18
            return False
19

20
        # 3. 响应不能是错误信息
21
        if self.is_error(response["result"]):
22
            return False
23

24
        # 4. 调用应该是有用的（增加信息或修正错误）
25
        helpful = self.check_helpfulness(
26
            original_text,
27
            api_call,
28
            response["result"]
29
        )
30

31
        return helpful

1
TOOLS = {
2
    # 计算器：精确算术运算
3
    "calculator": {
4
        "description": "Evaluate mathematical expressions",
5
        "parameters": {
6
            "expression": "string"  # 如 "2 + 2"
7
        }
8
    },
9

10
    # 搜索引擎：实时信息查询
11
    "search": {
12
        "description": "Search the web for information",
13
        "parameters": {
14
            "query": "string"
15
        }
16
    },
17

18
    # 翻译系统：语言翻译
19
    "translator": {
20
        "description": "Translate text between languages",
21
        "parameters": {
22
            "text": "string",
23
            "source_lang": "string",
24
            "target_lang": "string"
25
        }
26
    },
27

28
    # 日历系统：获取日期
29
    "calendar": {
30
        "description": "Get current date and time",
31
        "parameters": {}
32
    },
33

34
    # 问答系统：百科知识
35
    "question_answer": {
36
        "description": "Answer factual questions",
37
        "parameters": {
38
            "question": "string"
39
        }
40
    }
41
}

1
# Toolformer 调用示例
2

3
input_text = "What is 1234 * 5678?"
4

5
# Toolformer 决策：
6
# 1. 需要计算 -> 调用 calculator
7
# 2. 构造调用
8
api_call = {
9
    "tool": "calculator",
10
    "arguments": {"expression": "1234 * 5678"}
11
}
12

13
# 执行
14
result = execute(api_call)  # "7006652"
15

16
# 生成最终回答
17
output = "1234 × 5678 = 7,006,652"

1
# Toolformer 65B vs GPT-3 175B
2

3
comparison = {
4
    "Toolformer 65B": {
5
        "arithmetic": "95%",  # 几乎完美
6
        "factual_qa": "72%",   # 略低
7
        "translation": "85%"   # 相当
8
    },
9
    "GPT-3 175B": {
10
        "arithmetic": "60%",   # 经常算错
11
        "factual_qa": "75%",   # 略高
12
        "translation": "83%"   # 相当
13
    }
14
}
15

16
# 结论：Toolformer 用更少参数在算术上超过 GPT-3