3
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

【AppleのLLM Foundation Models】で thinking モードをつくる

3
Posted at

オンデバイスLLMの推論精度を2倍に

ソースコード: DeepThinkKit

小型LLMの限界を突破したい

Apple Foundation Models は軽量なモデルです。
単純な質問には十分でオンデバイス推論に優れています。
クラウド不要。APIキー不要。遅延ゼロ。月額無料。素晴らしい。

ところが複雑な推論を解かせると、途破綻します。

Q: "Johnは時速4kmで歩いている。1時間後にMikeが時速6kmで追いかけた。
    Johnが出発して何時間後に追いつく?"

A: "2/3時間後です"

間違っています。 しかも自信満々に。正解は3時間後です。

FoudationModelsはChatGPTやGeminiと比べて、数百分の一の大きさのモデルです。
ChatGPTなどのサービスは、thinkingモードで深い思考過程を経て結論を出します。
それらに比べると、FoundationModelは物足りなく感じます。

もともと用途が違うのです。
小型LLMと大規模LLMサービスは、積み木とヴィデオゲームくらい違います。

小魚群れて大魚を成す

積み木も組み合わせることで複雑な遊びもできます。
FoundationModelsの推論を組み合わせて、thinkingモードを擬似的に作れないかというのが本記事のテーマです。

ChatGPTなどのthinkingモードは、モデルの答えを次の推論の入力にして、思考を深くしていく仕組みだと推測します。

FoudantionModelsでもこれを真似てみました。

「たくさん考えれば賢くなる」仮説

ChatGPTの「o1」モデルが注目を集めた時、世界中の開発者が同じことを考えました。

「思考の連鎖(Chain of Thought)を外部パイプラインとして組めば、小さなモデルでも推論能力を底上げできるのでは?」

そこで、7種類の「考え方のフレームワーク」を設計しました。

Direct(直接):       質問 → 回答                     1回の推論
Sequential(逐次):   分析 → 回答                     2回
CritiqueLoop(批評): 回答 → 批評 → 修正              3回
Rethink(再考):      言い換え → 回答 → 検証           3回
BranchMerge(分岐):  分析 → 3並列回答 → 統合         6回
SelfConsistency:      3独立回答 → 多数決              3回
StepByStep:           3独立回答 → 多数決(別方式)     3回

人間で言えば、Directは「即答」、Sequentialは「考えてから答える」、CritiqueLoopは「答えてから見直す」、BranchMergeは「3人に聞いて統合する」。

推論回数が多いほど、より深く考えているはず。直感的にはそう思える。

この直感は、完全に裏切られた。

ステップを増やすほど馬鹿になる

10問のベンチマークを用意しました。条件分岐、変数追跡、カードのスワップなど、「1回で解くと間違えやすい」問題ばかりです。

全パイプラインの成績を並べた瞬間、目を疑いました。

パイプライン 推論回数 正答率
Direct 1回 40%
Sequential 2回 70%
CritiqueLoop 3回 50%
Rethink 3回 70%
StepByStep 3回 60%
BranchMerge 6回 50%

6回も推論するBranchMergeが、何もしないDirectと同じ50%。

なぜか。

エラーは雪だるまのように膨らむ

小さなモデルの1回の推論には、そこそこのエラー率があリマス。問題は、パイプラインの各段階が前段階の出力に依存していること。

1段階目が間違えると、2段階目はその間違いを前提に推論する。3段階目は、間違いの上に間違いを重ねる。6段階のBranchMergeでは、Analyze(分析)段階が立てた誤った前提が、3つの並列ブランチすべてに伝染し、Merge(統合)段階がそれをもっともらしく1つにまとめ上げ、もっともらしい不正解が完成する。

ステップを増やすことは「考えを深める」のではなく「間違える機会を増やす」ことでした。

グラフにすると、推論回数と正答率の関係は右肩下がりの曲線を描く。唯一の例外が、2回の推論。

2段階のスイートスポット

データは「2段階が最適」と叫んでいました。

では、その貴重な2回で何をすべきか? 3つの戦略を同じ条件で比較しました。

Sequential:    分析 → 解答        「考えてから解く」
CritiqueLoop:  解答 → 批評+修正   「解いてから直す」
Rethink:       解答 → 独立検証     「解いてから他人にチェックしてもらう」

自分で自分をチェックすると、何が起きるか

CritiqueLoop(解いてから直す)は、直感的には最も合理的に見える。人間のコードレビューと同じ発想です。

しかし、ベンチマークの結果は残酷でした。

Q: "農夫が羊を17匹持っている。9匹以外が全部逃げた。何匹残っている?"

[Solve]    17 - 9 = 8匹。
[Critique] 計算を確認。17 - 9 = 8。問題なし。
[Final]    答え:8匹

                        ← 正解は9匹

「all but 9(9匹を除いて全部)」は「9匹が残る」という意味だ。Solve段階が問題文を誤読し、Critique段階はそれを素通りさせました。

これは確証バイアス。間違った答えを目の前に置かれると、人間もAIも、それが正しい理由を探してしまう。

「他人の目」がバイアスを破る

Rethinkパイプラインは異なるアプローチを取った。

Solve段階とVerify段階で完全に独立したセッションを使う。Verify段階はSolveの思考過程を一切見ない。問題文と最終的な回答だけを受け取り、自分でゼロから解き直す。

[Solve]   17 - 9 = 8。答え:8
[Verify]  問題をゼロから解く。
          「all but 9」= 9匹が残る。
          提案された8は間違い。答え:9 ✓

同じモデル、同じパラメータ。なのに、新鮮なセッションで問題文だけを見せると正しく読み取れる。Solveの思考過程という「先入観」がないからです。

これは論文の査読プロセスと同じ構造です。著者(Solve)と査読者(Verify)は独立していなければ意味がない。

セッション分離 ── 見えない壁を壊す

2段階が最適だとわかった。独立検証が最も効果的だとわかった。だが、もう1つ重要な発見がありました。

マルチターンセッション(同一セッション内の会話)は、独立セッションに劣ります。

初期実装のSequentialパイプラインでは、1つのLanguageModelSessionで2ターン分の会話を行っていました。

// 旧: 1つのセッションで会話
let session = LanguageModelSession(instructions: "...")
let think = session.respond(to: "まず分析して")  // Turn 1
let solve = session.respond(to: "次に解答して")  // Turn 2

これを、各段階で別々のセッションに変更しました。

// 新: 段階ごとに独立セッション
let think = provider.generate(system: "分析者", user: "問題を分析して")
let solve = provider.generate(system: "解答者", user: "問題文 + 分析結果の要約")

この変更だけで正答率が60%から70%に改善しました。

原因は「コンテキスト汚染」です。

マルチターンセッションでは、Think段階の冗長な出力がセッションのコンテキスト窓に残り続ける。Apple Intelligenceモデルのコンテキスト窓は約1,200文字。Thinkの出力が500文字を食えば、Solveに残されたスペースは700文字しかありません。窮屈な部屋で考えるようなものです。

独立セッションでは、Solve段階はThinkの要約だけを受け取ります。広い部屋で、必要な情報だけを手元に置いて考えられます。

一語の追加が精度を変える

パイプライン構造の最適化が一段落した後、次のポイントはプロンプトです。

反復回数を数え間違える問題

Q: "7から始めて、偶数なら2で割り、奇数なら2倍にする。6回繰り返すと?"

正解: 7→14→7→14→7→14→7(答え:7)

全パイプライン共通の回答: 14(5回で止まる)

どのパイプラインでも、「6回繰り返す」指示を5回で打ち切る。

「紙に書け」と言えばいい

システムプロンプトに1行追加しました。

追加: "After EACH step, write State: [current values]."

モデルに「State: 14」「Iteration 3:」とテキストとして明示的に書かせることで、暗黙のカウントを排除しました。

結果:この問題の正答率が**0%から100%**になりました。

小さなモデルは「頭の中で状態を保持する」のが苦手です。ですが「紙に書く」ことはできる。生成したテキスト自体が、モデルにとっての外部メモリになります。

「まずアプローチを考えろ」── 追いつき算の突破

ベンチマークの正答率は90%に達した。しかし、冒頭の追いつき算はまだ解けませんでした。

Q: "太郎は時速4km、次郎は1時間後に時速6kmで追いかける。何時間後に追いつく?"
A: "4 ÷ 6 = 2/3時間後"  ← 不正解。太郎がまだ歩いていることを無視

ベンチマーク問題との違いは明白です。ベンチマークは「Step 1: 2倍にしろ、Step 2: 10より大きければ...」と手順が明示されています。追いつき算は自分で解法を見つける必要があります。

「相対速度を使う」という概念に、モデルが自力で辿り着けない。

一語の追加

追加前: "Think carefully before answering."
追加後: "Before solving, first identify what approach, formula, or concept is needed."

この一文を加えた結果──

[Solve]
1. 太郎の距離: 4km/h × 1h = 4km
2. 次郎との速度差: 6 - 4 = 2km/h   ← 相対速度を特定!
3. 追いつく時間: 4km ÷ 2km/h = 2h
4. 太郎の出発から: 1 + 2 = 3時間後 ✓

正解。 「まずアプローチを特定せよ」という指示が、モデルに「速度差」という概念を引き出させました。

「考えろ」では漠然としすぎる。「何を使って考えるか、まず決めろ」と言えば、モデルは道具箱から正しい道具を選べることがあります。

削ぎ落としの設計

全ての実験を経て、7つのパイプラインは3つに集約されました。

Direct:    単純な質問(1回のLLM呼び出し、高速)
Rethink:   推論が必要な質問(2回、高精度)
Verified:  制約充足問題(LLMで条件抽出 → 決定論的ソルバー)

Rethinkパイプラインの最終形は、驚くほどシンプルです。

Stage 1 [独立セッションA]:
  「アプローチを特定し、ステップごとに状態を記録しながら解け」

Stage 2 [独立セッションB]:
  「この下書きをレビューして改善せよ」
  → 拒否された場合のみ Stage 1 の出力を採用

普段は2回のLLM呼び出しで完結します。モデルの再学習は不要。推論時間は約2倍になりますが、精度は2倍以上になりました。


1語が推論経路を変える

記事で書いた改善は、すべて実機ベンチマークで検証しました。
その過程で、記事執筆時には見えなかった新しい問題が3つ浮上しました。

「ステップ」がシミュレーションを誘発する

追いつき算をベンチマークに追加して回したところ、モデルが96ステップの逐次シミュレーションに突入しました。

Step 1: t=1, John=4km, Mike=0km. State: [4, 0]
Step 2: t=2, John=8km, Mike=6km. State: [8, 6]
Step 3: t=3, John=12km, Mike=12km. State: [12, 12]
...
Step 96: ...(文脈窓オーバーフロー)

「After EACH step, write State」と書くと、小モデルは「step = シミュレーション上の各時刻」と解釈する。追いつき算は方程式 4t = 6(t-1) で一発で解けるのに、1時間ずつ追いかけ始めてしまう。

修正前: "Then solve step by step. After EACH step, write State: [current values]."
修正後: "Solve using equations when possible. Write State: [values] after each reasoning step."

「step by step」を「equations when possible」に変えました。たった3語の変更で、モデルは方程式を立てるようになり、96ステップのシミュレーションは消えました。

+1変換エラー ── 正しく解いて間違える

方程式を立てるようになっても、新しい失敗パターンが現れました。

[Solve]
  Let t = time after Mike starts
  4(t+1) = 6t → t = 2         ← 代数は完璧
  Answer: 2 hours after John left  ← 変換を忘れている!

t=2 は「Mike出発から2時間」であり、質問の「John出発から何時間後」に答えるには 1+2=3 とすべきだ。方程式も代数も正しいのに、最後の1行で変数の意味を取り違える。

5回テストした結果、同じ問題を3つのパターンで間違えました。

パターン 方程式 代数 解釈 最終答
正解 4t = 6(t-1) t=3 正しい 3 ✓
+1忘れ 4(t+1) = 6t t=2 John出発からと誤報告 2 ✗
方程式逆 6t = 4(t-1) t=-2 追いつけないと結論 -2 ✗

同じプロンプトで毎回違う間違い方をする。 これは記事冒頭で書いた「5回聞くと5回とも違う間違い」の再現です。

対策として、Verify段階のプロンプトに1文追加しました。

修正前: "Check this draft for errors."
修正後: "Check this draft for errors. Verify the final answer directly addresses what the question asked."

「最終回答が質問に直接答えているか確認せよ」──この1文で、Verifyが「質問はJohn出発からだが、回答はMike出発からの時間になっている」と気づける可能性を作りました。

安全弁のジレンマ

しかし、Verifyが+1を修正して「3」に直しても、安全弁がそれを却下していました。

// 旧ロジック
let answerChanged = solveAnswer != verifyAnswer
if answerChanged { finalRaw = solveRaw }  // Solveの"2"に戻る

この安全弁は「Verifyが正解を壊すのを防ぐ」ために導入しました。だが同時に「Verifyが誤答を直すのも防ぐ」副作用がありました。

Verifyは現在「レビューモード」(既存の回答をチェックして修正する)で動いています。ゼロから再解するのではなく、Solveの出力を見てエラーだけを直す方式。この方式なら、Verifyの修正を信頼してよい。

// 新ロジック
if isRefusal { finalRaw = solveRaw }  // 拒否時のみSolveを使う
else { finalRaw = verifyRaw }         // それ以外はVerifyを信頼

再テスト結果

修正後、追いつき算を含むベンチマークを実機で実行しました。

問題 期待 修正前 修正後
cond-5step 7 7 ✓ 7 ✓
evenodd-6 7 7 ✓ 7 ✓
2var 21 21 ✓ 21 ✓
price-4step $56 $56 ✓ $56 ✓
catchup (EN) 3 — 3 ✓
catchup (JP) 3 — 3 ✓

既存問題にリグレッションなし。追いつき算は英語・日本語ともに正解を出せるようになりました。ただし非決定性は残っており、常に正解するとは限らない。3回中2回正解、1回は方程式を逆に立てるような結果になります。

これが小さなモデルの現実です。100%の精度は得られない。しかし、40%を70%以上に引き上げることはできました。


第9章:「解かせない」という選択 ── 汎用方程式ソルバー

Mac上でのベンチマークは改善しました。だがiPhoneで同じテストを走らせると、追いつき算は3回中3回不正解でした。

Macのモデルは instruct_3b です。iPhoneも同じ3Bモデルですが、RAMの制約でより強い量子化が適用されています。結果として方程式の立式と代数計算の精度が落ちます。

ここで発想を転換。モデルに方程式を解かせるのをやめました。

モデルの仕事を「数値の抽出」に限定する

CSPソルバーで実証済みの戦略を応用します。

Before: LLM が方程式を立てる → LLM が解く → LLM が解釈する(3段階でエラー)
After:  LLM は数値を抽出するだけ → Swift が方程式を立てて解く → LLM は結果を説明する

@Generable を使い、モデルには問題文から数値と役割だけを抽出させます。

@Generable
struct WordProblemExtraction: Codable, Sendable {
    @Guide(description: "All numerical values from the problem with their roles")
    var values: [TaggedValue]
}

@Generable
struct TaggedValue: Codable, Sendable {
    @Guide(description: "Role: speed, time, delay, distance, count, price, rate, age, or weight")
    var role: String
    @Guide(description: "The numerical value")
    var value: Double
}

追いつき算に対して、モデルが返すのはこれだけです。

{"values": [{"role": "speed", "value": 4}, {"role": "speed", "value": 6}, {"role": "time", "value": 1}]}

3つの数字を取り出すだけ。これなら量子化が強いiPhoneモデルでも確実にできます。

ソルバーがパターンマッチで判断する

抽出された値の組み合わせを、ソルバーがパターンマッチする。

2つの速度 + 1つの時間 → 追いつき算 → t = speed_fast × delay ÷ (speed_fast - speed_slow)
パターン不一致 → nil → CSPソルバーにフォールバック → それも失敗 → LLMが直接回答

キーワードで問題種類を判定するのではなく、抽出結果のパターンで判断する。追いつき算の問題だと知る必要はない。「速度が2つと時間が1つある」ことだけわかればいい。

新しい問題パターン(仕事率、混合、年齢算など)の追加は、ソルバーにパターンを1つ足すだけでよい。キーワードリストの変更は不要だ。

結果

LLM (Rethink) 決定論的 (Verified)
モデルの仕事 方程式の立式+解法+解釈 3つの数値抽出だけ
正答率 (Mac) ~60% 100%
正答率 (iPhone) ~0% 100% (抽出成功時)
Solve時間 3-5秒 0.0秒

Solveステージの所要時間が0.0秒になっています。方程式を解くのはSwiftコードだから、推論は不要です。

「モデルに何をさせないか」が、モデルの能力を最大化する鍵でした。


計算の先へ ── 推論の多様性を測る

ベンチマークをここで見直しました。14問中12問が数値計算。しかし人間の「考える力」は計算だけではありません。

認知バイアスをテストする

Q: "A bat and a ball cost $1.10 in total.
    The bat costs $1.00 more than the ball.
    How much does the ball cost?"

直感的な答えは$0.10。でも正解は$0.05。これは人間でも多くが間違える認知バイアスの問題です。

バット = ボール + $1.00。バット + ボール = $1.10。
$0.10と答えると、バットは$1.10になり合計$1.20。計算が合わない。

読解力をテストする

Q: "A farmer has 17 sheep. All but 9 run away.
    How many sheep does the farmer still have?"

「17 - 9 = 8」と計算してしまうのが典型的な間違い。「all but 9(9匹以外が全部)」は「9匹が残る」という意味です。

空間推論をテストする

Q: "You are facing north. You turn right. Then you turn right again.
    What direction are you now facing?"

北 → 右 → 東 → 右 → 南。暗算ではなく、空間的な状態追跡が必要です。

論理的妥当性をテストする

Q: "All roses are flowers. Some flowers fade quickly.
    Does it follow that some roses fade quickly?"

直感的には「はい」と答えたくなる。でも論理的には「いいえ」。「花の中で早く萎れるもの」がバラを含むかどうかは前提からは導けません。

これらの問題は、いずれも数値計算ではなく思考のプロセスそのものをテストします。ステップバイステップの計算能力とは異なる認知能力──読解、空間認識、論理的推論、バイアスへの抵抗──を測定します。


パイプラインでは超えられないもの

ここまで成功の話をしてきました。だが、正直に失敗も記録しておきます。

ハルシネーション

実在する人物について聞くと、モデルは自信満々にデタラメを語ります。

Web検索を組み合わせれば正しい情報を取得できる場合もあります。でも、検索結果が見つからなかった時、モデルは「わかりません」と言う代わりに物語を創作します。

「知らないなら正直に言って」というプロンプトを追加しても、改善は限定的。小さなモデルは「自分が知らないこと」を知ることが、最も苦手です。

概念の壁

カップのスワップ問題では、全パイプラインが同じ間違いをしました。

Q: "コインがカップAの下。A⇔C交換、B⇔D交換(両方空)、A⇔D交換、B⇔C交換"
正解: B    全パイプラインの回答: C

「空のカップ同士を交換しても何も起きない」──この概念をモデルが理解していない。何回独立にセッションを立てても、同じ概念的エラーを繰り返します。

パイプラインで修正できるのは「ランダムなエラー」(計算ミス、数え間違い)。モデルが概念自体を持っていない「体系的エラー」には無力。


小さなAIの正しい使い方

この実験で得られた8つの原則。

1. 層は最小限に

ステップを増やすほど精度は落ちる。2段階がスイートスポット。

2. セッションは独立に

マルチターンはコンテキスト汚染を起こす。各段階に新しいセッションを。

3. 検証は「他人の目」で

自己批評は確証バイアスに陥る。検証者には問題と結論だけを渡す。

4. 「何で考えるか」を先に決めさせる

「考えろ」では漠然としすぎる。「アプローチを特定せよ」で正しい道具が選ばれる。

5. 「ステップ」の解釈を制御

「step by step」は小モデルにシミュレーションを誘発する。「方程式を使え」で推論経路が変わる。

6. 検証者の修正を信頼すること

安全弁は「正解を守る」と同時に「修正を潰す」。レビューモードなら検証者を信頼すべき。

7. モデルにさせないことを選ぶ

方程式を「解かせない」だけで正答率が0%から100%になりました。モデルの仕事を抽出に限定し、計算はプログラムに任せる。

8. 限界を知る

ランダムエラーは直せる。体系的エラーは直せない。知識の壁はモデルサイズの壁。そして非決定性は消えない──同じ問題を3回解けば、3回のうち1回は違う間違い方をする。


Foundation Modelsは、ChatGPTの代替にはなリマ戦。知識量も、創造性も、言語の豊かさも、桁が違います。

ですが、「正しく考える力」は、外部フレームワークである程度補えます。 2段階の独立セッションと、たった数語のプロンプト修正で、追いつき算が解けるようになりました。

そして何より面白かったのは、実験が直感に反する結果の連続だったこと。

  • ステップを増やせば賢くなる → 逆。エラーが蓄積する
  • 自分で見直せば精度が上がる → 逆。確証バイアスに陥る
  • 多数決で安定する → 逆。同じ間違いを3回繰り返す
  • 丁寧に手順を踏ませれば良い → 逆。シミュレーション暴走する
  • 安全弁は正解を守る → 半分正しく、半分間違い。修正も潰す

正解は、最もシンプルな構造の中にありました。

「一度解いて、別の自分にチェックしてもらう。」

論文の査読、コードレビュー、ダブルチェック──人間が何百年も前から実践してきた知恵が、3Bパラメータの小さなAIにもそのまま通用しました。

小さなAIは、人間と同じ方法で、少しだけ賢くなれる。

🐣


最新のAI機能を使ったアプリやサービスを最速で試作したい。
そんなご要望にお応えします。
ご相談はこちらまで。
rockyshikoku@gmail.com

Twitter
Medium
GitHub

3
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
3
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?