AIの学習は、霧のかかった山を降りていく作業である

0. 読む前に — 地図の現在地

F1 から F5 まで来ながら、LLM が何か、Transformer は何をしたのか、attention がどう回っているのか、そして embedding が単語をベクトルにどう変えるのかまで、感覚はつかんでもらえたと思います。ここまでは 「もう作られたモデルが動く仕組み」 の話でした。

今回は方向が少し違います。そのモデルが最初どうやって作られるのか。 つまり「学習 (training) というのが実際に何をする作業なのか」という話です。

ブログ・YouTube・ニュース記事で「モデルを学習させた」「このモデルは数十兆トークンで学習された」「fine-tuning で性能を引き上げた」みたいな表現がずっと出てきますよね。ところが「学習って何?」と聞かれると答えが出てこないケースが多いです。私もそうでした。「データを入れて回すと勝手に賢くなるんじゃないの?」程度で蓋をして過ごしていましたから。

この記事で終わらせたいのは一つだけです。「モデルの学習」が魔法ではなく「予測を外さないようにパラメータを少しずつ直すこと」 という感覚をつけること。ここまで来ると、これから技術記事を読むときに「loss が下がる」「gradient が流れる」「learning rate を下げる」といった表現が、もうブラックボックスに見えなくなるはずです。

数式はほとんど出てきません。代わりに比喩を 3 つずっと回して使います。霧のかかった山を降りる、弓の射的の練習、スープの味の調整。この 3 つでこの記事の全部が説明されます。

1. 「モデルを学習させる」という言葉がなぜ魔法のように聞こえるのか

初めてこの表現を聞いたとき、ちょっと変じゃないですか。学習といえば、人が本を読んだり先生から教わったりする場面を思い浮かべるわけで。ところがコンピュータに学習させる? 誰が教えるの? 何を学ぶの? 頭の中に具体的な絵が描けません。

ここで誤解が一つあります。「学習」という言葉のせいで「モデルが教科書を読んで理解する」ようなイメージが湧くのですが、実際に起きていることはそれとだいぶ違います。人間の学習と重なる部分もあるけど、ずっとシンプルな作業です。

感覚的に一番近い比喩が 弓の射的の練習 です。最初に弓を持ったとき、矢は的の近くにも届きません。左にそれたら「ああ、今度は腕を少し右寄りに」と言いながら次の矢を射ます。また右にそれたら「じゃあ逆にしよう」と。数千回射っているうちに、ある瞬間から的の中心によく当たるようになります。

モデルの学習もこれなんです。本当に。

• モデルが何かを 予測 します。(矢を射る)
• 正解とどれくらい違うかを 測ります。(的の中心からどれくらい外れたかを見る)
• 外れないように 姿勢を直します。(腕を少しひねる)
• これを 数百万回繰り返します。

それで終わりです。「学習」という単語が入ると何か哲学的で神秘的な感じがするのですが、実際に回っているのは 「予測を外さないように少しずつ直す」 というとてもシンプルなループです。

一つだけ大事な違い。人間は「腕を何度ひねるか」を感覚でやります。モデルはこれを 数字で やります。「左にそれた」ではなく、「このパラメータを 0.0003 大きくして、あのパラメータを 0.0007 小さくして」という感じです。その代わりにこの数字の調整を、数十億個のパラメータに対して同時にやります。人間の弓と違うのは 規模と精度 だけで、原理は同じです。

2. 学習 = 予測をだんだん外さないようにする過程

一行で整理します。

学習とは、モデルの予測が正解に近づいていくように、内部のパラメータを少しずつ直していく過程である。

ここで核心の単語 2 つが「予測」と「パラメータ」です。

予測 とは何か。LLM なら「この文の次に来る単語」を予測します。画像分類モデルなら「この写真が猫か犬か」を予測しますし、翻訳モデルなら「この日本語の文を英語にすると何になるか」を予測します。どんなモデルでも中を覗くと 入力を受け取って出力を出す関数 です。

パラメータ は F3 で見てもらったあの数字たちです。ディープラーニングのモデルの中には重み (weight) とバイアス (bias) という数字が数百万〜数千億個入っています。この数字たちが「ここまで学んだすべて」です。パラメータが変わるとモデルは違う予測をします。

つまり学習はこのパラメータの値を 「もっといい値に少しずつ動かしていく作業」 です。最初は全部ランダムです。だから最初のモデルは何を言っても滅茶苦茶です。学習が進むにつれてパラメータがだんだん「いい場所」に移っていきます。学習が終わるとその場所で止まります。

ここで「いい場所ってなに?」という問いが自然に湧きますよね。それを決めるにはまず 「どれくらい良いか / どれくらい悪いか」を数字で測る方法 が必要です。それが次のセクションに出てくる loss です。

3. 予測がどれくらい外れたかを測る — Loss Function

弓の比喩を続けます。矢が的の中心からどれくらい離れたかを測らないといけないですよね。この「どれくらい外したか」を表す数値が loss (損失) です。

Loss の基本アイデアはこうです。

• 正解と予測が 完全に同じなら loss は 0 に近い
• 予測が 少し外れたら loss は小さい正の数
• 予測が 大きく外れたら loss は大きい正の数

つまり loss は「自分がどれくらい下手か」の点数 です。学習のゴールは単純になります。loss をできるだけ小さくするパラメータ値 を見つけること。

たとえば「次の単語を当てる」問題を解いているとしますね。文が「私はご飯を食べ」と与えられて、次の単語を予測しないといけない。正解は「た」です。モデルが「た」に確率 0.01、「る」に確率 0.7、「ない」に確率 0.2、残りの単語に残りの確率を配分したとします。正解に確率をあまり与えなかった。Loss が高く出ます。

学習が進んで同じ文で今度はモデルが「た」に確率 0.85 を与えたとします。Loss がぐっと下がります。正解に自信を持って当てたから。

Loss の具体的な数式は問題によって違います。回帰の問題 (数字の予測) では Mean Squared Error (MSE) を使います。分類の問題では Cross-Entropy Loss を使います。LLM は cross-entropy 系列です。数式は飛ばしていいんですが、共通点はこれです。

loss = f(正解, 予測)

正解と予測の間の「距離」みたいなものをひとつの数字に絞り出す関数だ、という点だけ覚えておいてください。

ここで大事な感覚ひとつ。loss はパラメータの関数 です。パラメータを変えると予測が変わって、予測が変わると loss が変わりますよね。なので数学的に見ると「パラメータの値たちを入力に取って loss という数字を出す大きな関数」が一つあるわけです。学習はこの関数の 最小値 を見つける仕事です。

ところがこの関数が数十億次元です。パラメータが数十億個ですから。頭に描けない超高次元の空間の中で「一番低い場所」を探さないといけないわけです。不可能に見えるでしょう。実際に完璧な最小値は見つけられません。代わりに 「十分に低い場所」 を見つける方法があります。それが gradient descent です。

4. パラメータをどの方向に直せば損失が減るか — Gradient

このセクションがこの記事の核心のひとつです。gradient という言葉がここで初めて出てきます。

Gradient は「傾き」という意味です。数学では微分と一緒に出てくる概念で。でも私たちは数式なしで感覚でいきます。

スープの味の調整 の比喩を使ってみますね。スープを煮ていて、味が合いません。薄すぎる。塩を入れないといけないのですが、どれくらい入れたらいいか分かりません。なのでこうやります。

1. 塩を 0.1g 入れてみます。
2. 味を見ます。さっきより美味しくなったか、逆に微妙になったか?
3. 美味しくなったら同じ方向にもう少し。微妙なら逆方向 (減らす)。

これを繰り返すと、少しずつ味がよくなっていきます。ここで「塩を 0.1g 追加したとき、味がよくなるか悪くなるか」を把握するのが gradient を求める作業 です。簡単に言うと 「このパラメータをちょっと上げたら loss が減ったか増えたか」 を測ることです。

Gradient をパラメータ1個だけでなく、すべてのパラメータに対して 求めます。「塩をちょっと上げたときの loss の変化」「醤油をちょっと上げたときの loss の変化」「砂糖をちょっと上げたときの loss の変化」…。各材料 (パラメータ) 別に別々に計算します。その結果が「材料別にどれくらい、どの方向に調整すれば味がよくなるか」が書かれた大きな表です。

この表が、まさに gradient です。数十億のパラメータがあれば、数十億の数字が入ったベクトルです。それぞれの数字は 「このパラメータをちょっと大きくすると loss がどれくらい変わるか」 を教えてくれます。

• gradient が 正 なら → パラメータを大きくすると loss が大きくなる → なので 減らす べき
• gradient が 負 なら → パラメータを大きくすると loss が小さくなる → なので 大きくする べき
• gradient が 0 近く なら → このパラメータは今影響がほぼない → ほぼそのまま

この方向情報を使って各パラメータを gradient の反対方向 にほんの少しずつ動かすと、loss が少しずつ落ちます。この作業を繰り返すのが学習です。

ここで一つ疑問。「数十億個のパラメータ一つひとつに対して少しずつ上げてみて loss を測るなら、数十億回計算しないといけないんじゃないの?」と。そうなんです。そうやると高すぎる。なので backpropagation という賢い方法を使います。それはセクション 7 で扱います。

5. それで、霧のかかった山を降りる比喩

さあここでこの記事の一番有名な比喩が出てきます。教科書にも出るし、YouTube の動画でも必ず出てくる比喩です。

あなたが霧のかかった山の頂上にいるとしましょう。視界が 3m しかありません。上も下も見えない。それでもどうにかして山の下 (麓) まで降りないといけない。

どうしますか?

方法は一つです。足元の傾き を感じるんです。足でそっと周りを踏んでみると「こっちが少し下りだな」という感覚が来ます。その方向に 一歩 踏み出す。一歩踏み出したら、またもう一度足元を感じる。今度も「こっちが下り」を見つけて、また一歩。ずっと繰り返します。

時間は少しかかりますが、これで麓にたどり着きます。頂上から一度も麓を見下ろせなかったのに、その瞬間その瞬間、足元の傾きだけ見て下り方向に一歩ずつ行けば 麓まで行くんです。

これが gradient descent です。名前そのまま「gradient (傾き) に沿って descent (降りる)」です。

• 山の地形 = loss 関数 (パラメータが作る風景)
• 足元の傾き = gradient (loss がどの方向に上がっているか)
• 下り方向 = gradient の反対方向 (loss が下がるほう)
• 一歩 = パラメータをその方向にちょっと動かすこと
• 麓 = loss が最小になる場所

面白いのは、霧のせいで全体の地形がどうなっているか分からない ということです。山が V 字渓谷なのか、U 字盆地なのか、あちこちに凹みがあるデコボコの地形なのか分からない。でも降りていけるんです。瞬間瞬間の足元の情報さえあればいいから。

これが gradient descent の力です。全体の絵が分からなくても、いまこの場所の傾きさえ分かれば動ける。 パラメータが数十億次元という超高次元空間の loss の風景でも、同じ原理で動きます。私たちの頭ではその空間を想像することはできませんが、「いまこの場所の gradient」さえ計算できれば、一歩踏み出すことはできるわけです。

一つだけ欠点があります。偽の底 にはまることがあるという点です。山を降りていく途中に小さな水たまりがあったりしますよね。四方が下りじゃなくて、この水たまりの中では下りが見当たらない地点。これを local minimum と呼びます。gradient descent はここにはまると出られません。幸いディープラーニングでは local minimum の問題が思ったほど深刻ではないことが実験的に分かっていて、実務では大きく心配しません。これはこの記事の範囲を超えるので、「そういう問題があるんだな」くらい知って通り過ぎてください。

6. Learning rate — 一歩の大きさ

霧のかかった山の比喩には大事な変数が一つ隠れています。一歩をどれくらい大きく踏み出すか。

• 大きく 踏み出すと → 隣の谷に跳び越えたり、反対側の斜面に乗ってしまったり。空振り。
• 小さく 踏み出すと → 一生降りても麓の近くに行けない。カメの速度。

この一歩の大きさが learning rate です。機械学習で一番大事な hyperparameter のひとつです。(hyperparameter は「学習そのものが決める値」ではなく「私たちが先に決めてあげる値」です。)

Learning rate が大きすぎると loss が 発散 します。下がっていたのがいきなり跳ね上がり、また下がってまた跳ね上がり。学習が壊れます。小さすぎると loss がほぼ下がりません。何時間回しても進展がない。

ちょうどいい値を見つけるのは実験でやります。1e-3、1e-4、1e-5 みたいな数字を切り替えながら、「この値で一番よく降りるな」という場所を探すんです。最近は Adam や AdamW みたいなオプティマイザが learning rate を自動で少しずつ調整してくれるので楽になりましたが。それでも初期値は人が決めてあげる必要があります。

もう一つ面白いのが learning rate schedule です。学習の初期には大きな歩幅でざっくり方向を取り、後半には小さな歩幅で精密に調整する戦略。たとえば「最初の 10% 区間は learning rate を徐々に上げて (warmup)、残りの区間は徐々に落とす (cosine decay)」みたいに。山を降りるときも最初は大股で降りて、麓の近くになったらそろそろと歩くのと同じ発想です。

Learning rate の感覚は実務でけっこう役立ちます。Fine-tuning をするとき「learning rate を上げすぎたら元のモデルが学んだことを全部忘れた」という話をよく聞きますよね。それはまさに大股で元の場所を離れてしまったわけです。「大きな歩幅は探索にいい、小さな歩幅は精密な調整にいい」という感覚さえあれば、後でモデルをチューニングするときに迷うことが減ります。

7. Backpropagation — 深いネットワークでどのパラメータをどれだけ直すのか

ここで多くの初心者が詰まる単語、backpropagation (逆伝播) が出てきます。名前は仰々しいですが、感覚はシンプルです。

問題状況から見ましょう。ニューラルネットワークは層 (layer) が複数積まれていますよね。入力が 1 層を通過して 2 層に行き、2 層を通過して 3 層に行き…。最後の層で予測が出て、loss が計算されます。

さあ「loss を減らすために各パラメータをどう直したらいいか」を知りたいわけです。ところが 1 層にあるパラメータが loss に影響を与える経路はとても遠い。1 層 → 2 層 → 3 層 → … → 最後の層 → 予測 → loss。この長い経路を通りながら影響を与えます。

1 層のパラメータをちょっと変えると loss がどれくらい変わるでしょうか。直接計算するなら、この長い経路を全部たどらないといけません。層が 100 個なら 100 回たどる。パラメータが数十億個なら、これを数十億回繰り返す? 計算が爆発します。

そこで 逆から計算する賢い方法 が使われます。それが backpropagation です。

責任を逆方向に分けて送る という比喩を使ってみます。プロジェクトが失敗したとしましょう。最終成果物がダメだった。「誰のせいでこうなった?」を追跡しないといけないとしたらどうしますか。

1. 最終結果 から出発します。「成果物がどれくらい悪かったか」(= loss) がまずあります。
2. その直前の段階の担当者たちに責任を 割合で分けて 渡します。「今回の失敗で A チームが 60%、B チームが 30%、C チームが 10% 寄与した」みたいに。
3. 各チームは受け取った責任をまた 自分のチームのメンバーに割合で分けて 渡します。A チームの中で「A-1 が 70%、A-2 が 20%、A-3 が 10%」。
4. これを最後の段階まで逆にずっと降ろしていきます。最初に動いた 1 層の作業者まで。

各個人は「自分が今回の失敗にこれくらい寄与した」という自分の分の責任点をもらいます。この点がまさにその人の gradient です。「次は君はこの方向にこのくらい直してくれ」という信号です。

この方法の核心は 一度逆方向にずっと降ろせば、すべてのパラメータの gradient が同時に計算される という点です。数十億個をそれぞれ別々に計算する必要はなく、1 度の backward pass で全部得られる。数学的には chain rule (連鎖律) という微分の規則を活用したものです。数式なしで感覚だけ持って行ってもらえば大丈夫です。

整理するとこうなります。

• Forward pass (前進): 入力 → 1 層 → 2 層 → … → 予測 → loss 計算
• Backward pass (逆伝播): loss → … → 2 層 → 1 層。各パラメータの gradient が出てくる

Forward で「どれくらい外したか」を測り、backward で「誰のせいか」を分けて送る、というわけです。この 2 段階が学習の基本呼吸です。

Backpropagation は 1986 年頃に有名になって、ディープラーニングが爆発的に成長した 2010 年代以降、GPU の並列演算と結合して「深いネットワークも効率的に学習できる」ようにした決定的な部品です。PyTorch・TensorFlow のようなフレームワークは、この backward 計算を 自動微分 (autograd) として提供しています。ユーザーが forward pass だけ書けば、backward は自動で処理されるわけです。おかげで実務者たちが微分の数式を手で解く必要がなくなりました。

8. 学習 loop — 3 段階の繰り返し

さあここまで出てきた部品たちをひとつの繰り返しループに編んでみます。実際に学習が回る仕組みです。

while 学習がまだ終わっていないなら:
    1. Forward pass: 入力 → モデル → 予測
    2. Loss 計算: 予測 vs 正解 → loss という数字ひとつ
    3. Backward pass: すべてのパラメータの gradient を計算
    4. パラメータ更新: パラメータ -= learning_rate × gradient

この 4 段階が1周です。この1周を1回回すのを 1 step あるいは 1 iteration と呼びます。データ全体を一度ずっと見切るのを 1 epoch と呼びます。

GPT-3 のようなモデルは数千億個のパラメータを数兆個のトークンで学習します。step の数で言うと、数十万〜数百万 step くらい回ります。1 step でこの 4 段階が毎回繰り返されるわけです。

この絵を頭に浮かべれば学習への理解が一気にしまります。「予測 → どれくらい外したか測る → どの方向に直すか決める → ほんの少し直す」 を、モデルが止まるまで繰り返す。このループ以外の魔法はありません。データが多いほど、パラメータが多いほど、このループをたくさん回すほど、モデルがもっと上手になります。

人でいうと 「矢を1本射て、的を見て、姿勢をちょっと直して、また1本射て」 を一日中やるようなものです。違いはコンピュータが一度に数千本を同時に射って数千回調整する点。そして疲れない点。

9. 一度に1個ずつ? それともまとめて? — SGD, mini-batch, batch

ここで実務感覚をもう一つ渡します。「1 step でデータをどれくらい見て gradient を求めるか」という選択肢です。

3 つの方法があります。

1. Batch Gradient Descent (全体)
– データ全体を使って gradient を計算してから1度更新。
– 正確な gradient の方向が得られるが、1 step で膨大な計算コスト。
– 料理の比喩:「今日準備したすべてのスープを全部味見した後に1度にまとめて味を調整する」です。正確だけど時間がかかる。

2. Stochastic Gradient Descent (SGD, 1 個ずつ)
– データ1個だけ使って gradient を計算して更新。これを繰り返す。
– 速いが gradient がデコボコ (データ1個が全体を代表できないから)。
– 料理の比喩:「スープ一さじだけ取って食べてすぐ塩を入れる」です。速いけど、運が悪いと変な方向に行く。

3. Mini-batch Gradient Descent (まとめ)
– データ数十〜数千個 (= mini-batch) を使って gradient を計算して更新。
– 正確さと速度の妥協点。
– 料理の比喩:「スープを3〜4さじ取って味見して、平均的に判断してから味を調整する」です。実務の標準。

実際には mini-batch がほぼ無条件で標準 です。batch size はたいてい 32、64、128、256、1024 くらいの値です。LLM 学習では batch size が百万トークン単位になる場合もあります。GPU の並列演算をぎりぎりまで使い切れるサイズを選ぶわけです。

Batch size も hyperparameter です。大きいと gradient が安定しますが GPU メモリをたくさん食います。小さいと軽いけど gradient のノイズが大きい。実務では「GPU メモリの許容最大値の近く」を選ぶことが多いです。

そして面白い事実ひとつ。SGD の「ノイズ」が学習に役立つことも あります。Gradient がデコボコしていれば local minimum のような小さな水たまりから弾き出されやすい。安定しすぎた gradient はむしろ狭い盆地に閉じ込められるリスクがあるんです。こういう微妙なトレードオフが、モデル学習に付く面白さのひとつです。

10. なぜ学習にそんなにお金がかかるのか — GPU・データ・時間

ここで AI 産業の経済学の話をちょっとしてみます。

ニュースで「GPT-3 の学習に数百万ドルかかった」「GPT-4 の学習費用は 1 億ドル推定」のような記事を見たことがあると思います。なぜそんなに高いのか気になっていたら、ここまで読んだ内容で答えられます。

学習コスト = (パラメータ数) × (データ量) × (学習 step 数) × (1 step あたりの計算量)

これが全部計算量に直結します。計算量は GPU 時間に変わり、GPU 時間はお金に変わります。

• パラメータが多いほど → forward・backward が重くなります。
• データが多いほど → 1 epoch が長くなります。
• 学習を長く回すほど → GPU 時間が増えます。

GPT-3 (1,750 億パラメータ) の学習には、Nvidia V100 基準で約 355 年分の GPU 時間がかかったと推定されます。これを数千枚を同時に使って数週間〜数ヶ月で終わらせるわけです。当時のクラウド GPU の価格に換算すると数百万〜数千万ドル。GPT-4 は公開された数字はありませんが、規模がさらに大きいと知られています。

このコスト構造が AI 産業の地図を決めます。

第一に、超大型モデルを学習できる組織が限られます。 OpenAI、Anthropic、Google、Meta、xAI、Mistral、DeepSeek のような会社たちです。スタートアップが最初から大型モデルを学習するのは難しい。

第二に、学習は高いけど推論 (inference) はずっと安い。 学習はパラメータを数百万回更新する重い作業なのに、推論は「固定したパラメータで1回 forward pass を回すだけ」ですから。学習と推論の費用比率は極端です。なので 「学習は巨大企業が、推論はみんなが」 という構造になります。API の利用料は基本的に推論のコストです。

第三に、pre-training と fine-tuning の分離が有利です。 大きなモデルを1回学習しておいて、会社ごとに用途に合わせて 小さく追加学習 させる構造が経済的。これは次のセクションでもっと見ます。

このコスト感覚があると、ニュース記事を読むときにずっと解像度が上がります。「OpenAI が新しいデータセンターに数十億ドル投資」のような見出しを見たとき、そのお金がどこに行くのか (GPU、電気、冷却、建物) が絵として浮かぶんです。AI 産業がなぜ電力・半導体・国際政治のイシューと絡むのかも、同じ理由です。

11. Fine-tuning は学習の縮小版

実務で実際によくやる学習のパターンがこれです。pre-training + fine-tuning という 2 段階。

Pre-training (事前学習) は超大型モデルをとんでもないデータで最初から学習するもの。数兆個のトークン、数十万 step、数千枚の GPU。OpenAI・Anthropic のような組織がやっていることです。この段階でモデルは「言語全般の統計とパターン」を吸収します。文法、常識、論理構造、いろんなドメインの知識まで。結果物は汎用的に使える「基本モデル」です。

Fine-tuning (ファインチューニング) はこの基本モデルの上で 特定の用途に合わせて 追加で学習するもの。データはずっと少ないです (数千〜数十万サンプルくらい)。学習 step もずっと短い。Learning rate も小さく取ります (元の学習したものを失わないように)。

構造を絵で見るとこうなります。

汎用基本モデル (pre-trained)
    ↓ 金融ドメインのデータで fine-tune
金融専用モデル

汎用基本モデル (pre-trained)
    ↓ 医療 QA データで fine-tune
医療 QA モデル

汎用基本モデル (pre-trained)
    ↓ 特定の会社の文書で fine-tune
社内専用モデル

Fine-tuning はコストが相対的に少なめです。会社が GPU 数枚だけあれば可能な水準です。Meta の LLaMA、Mistral、DeepSeek のようなオープンモデルが公開されてから、「誰でも基本モデルを取ってきて自分の用途に fine-tune する」エコシステムが大きくなりました。2026 年時点では LoRA (Low-Rank Adaptation) のような技法のおかげで fine-tuning のコストがさらに下がりました。モデル全体のパラメータを直さず、ごく小さな追加パラメータだけ 学習させる方式です。GPU 1 枚でも数十 GB のモデルを fine-tune できるようになりました。

実務感覚で理解するなら、pre-training は小・中・高の 12 年の公教育、fine-tuning は職務研修 2 週間 みたいなものです。12 年の基礎がもうあるので、2 週間の研修でも特定の業務がそこそこできるようになる、というわけです。この構造が AI 活用を民主化しました。OpenAI でなくても、自分のデータで使える専用モデルを作れるようになったんです。

ただ fine-tuning が万能ではありません。とんちんかんなデータを入れると、むしろ元あった性能が壊れます。「学習されたものが多い」と「この用途に合う」は別の問題です。なので実務では Fine-tuning するのか、RAG (Retrieval-Augmented Generation) で十分か、プロンプトエンジニアリングだけで解決するか を先に判断します。コストが低い側から試してみる順番です。(RAG は後で M1 の回で扱います。)

12. Inference = 学習が終わった後、実際に使う段階

学習が終わったモデルを実際に使う段階が inference (推論) です。

違いを一文で整理するとこうなります。

• 学習 (training): パラメータを 変える 段階。Forward pass + backward pass + 更新。
• 推論 (inference): パラメータを 固定して 使う段階。Forward pass だけ。

推論の段階では backward pass がありません。Gradient を計算しません。Loss も計算しない。ただ入力を入れて forward pass を1回回して出力を受け取るだけです。

なので推論は ずっと安くて速い です。計算量が学習の 1/3 水準です (forward だけすればいいから)。メモリも少なく使います (gradient の保存所が要らないから)。だから学習は数千万ドルかかっても、推論は1回に数セント水準で可能なわけです。

私たちが ChatGPT・Claude・Gemini を使うときにやっているのは全部 inference です。新しい質問を投げるたびに 新しいパラメータを学習するのではなく、すでに学習されたパラメータで forward を1回回している んです。API の費用がトークン数に比例する理由もここにあります。トークンが多いほど forward pass が長くなって、長くなるほど計算量が増えますから。

ここで実務的な感覚をもう一つ。「モデルが会話を覚えているように見えるけど、実は学習は起きていない」 という点です。ChatGPT と会話しながら「私の好みを学んでいってるな」と感じるときがあるでしょう。ところがほとんどは 「会話の履歴をプロンプトにくっつけて入れているだけ」 です。パラメータは皆さんとの会話中に変わらない。次のセッションを始めるとその記憶は消えます。(Memory 機能が別にあるサービスは、会話の内容を要約して別の保存所に保存する方式です。パラメータの学習ではありません。)

この区別が大事な理由は、「モデルがずっと勉強している」 という錯覚を取り払ってくれるからです。LLM は学習が終わった時点のパラメータで凍りついています。それ以降の世界の情報は知りません (これを「knowledge cutoff」と呼びます)。新しい情報を教えるには、もう一度学習させる (お金・時間)、あるいはプロンプトに一緒に入れる (RAG のような方式)、どちらかを選ばないといけません。パラメータは永遠に固定、追加情報は入力として入れる。 この感覚が実務でずっと使われます。

---

締めの一文

学習とは、予測が外れないようにパラメータを少しずつ直す繰り返しである。 Loss でどれくらい外したか測り、gradient でどの方向に直すか決め、learning rate だけ一歩動かし、この作業を数百万回繰り返す。霧のかかった山で足元の傾きだけ見て一歩ずつ降りていく作業。あなたが使っている ChatGPT・Claude は、この過程を数ヶ月かけて終わらせた後、パラメータが固定された状態です。いま私たちが見ている「賢さ」は、数千万回の小さな一歩が積み重なった結果物です。

次の読みもの

• B1 — AI Agent は何が違うのか [準備中]
• M1 — Retrieval Layer がなぜ必要か [準備中]

シリーズのはじめから: F1 — LLM とは何か · F2 — Transformer · F3 — ディープラーニングがただ大きな計算である理由 · F4 — Attention 解説 · F5 — Embedding とは何か

よくある質問 (FAQ)

Q1. 学習と推論 (inference) は同じ GPU で動きますか?

基本的にはどちらも GPU で動きます。ただし学習は forward + backward + パラメータ更新までしないといけないので、メモリと計算量がずっと大きいです。推論は forward だけすればいいのでずっと軽い。なので学習用 GPU (NVIDIA H100・H200 など高スペック) と推論用 GPU (T4・L4・A10 のような相対的に安いモデル) を分けて使う場合が多いです。実務的に、推論のコストは学習コストの数百〜数千分の一の水準です。

Q2. Gradient descent が local minimum にはまったらどうするんですか?

古典的には大きな問題と見なされていましたが、ディープラーニングでは思ったほど深刻ではないことが実験的に分かっています。理由はいろいろありますが、核心は 高次元空間ではほとんどの臨界点が local minimum ではなく saddle point (片方は下り、もう片方は上りの地点) だという点です。Saddle point は gradient が適当に抜けられます。その上に SGD のノイズが小さな水たまりからモデルを弾き出すこともあります。実務で local minimum の問題で学習が詰まったという話はあまり出てきません。もっと大きな問題は learning rate の設定、gradient vanishing・explosion、データ品質などの方です。

Q3. ChatGPT と会話しながらモデルがだんだん賢くなっている気がするんですが、学習が起きているんですか?

ほとんどの場合 いいえ。会話の途中でパラメータは変わりません。「だんだん賢くなっている気がする」感じは プロンプトに会話の履歴が一緒に入っているから です。たとえば皆さんが自分の好みを 10 回話したなら、11 回目の質問には前の 10 回の会話がプロンプトにくっついて一緒に入力されるわけです。パラメータはそのままで、入力が豊かになっただけ。OpenAI の ChatGPT Memory 機能や Claude の Projects 機能は、会話の履歴を要約して別の保存所に保管し、次の会話にくっつける方式です。パラメータを更新する本物の学習は、定期的に会社側で実施されて、新しいバージョンのモデルとしてリリースされます (例: GPT-4 → GPT-4 Turbo → GPT-4.1 → …)。このサイクルは普通、数ヶ月単位です。

---

ニュースレターのご案内

毎週月曜日、AI・LLM・エージェント関連の実務整理を一通ずつお届けします。AIのしくみ地図シリーズは、ここで先に公開されます。こういう技術解説を落ち着いて積み上げていきたい方は、ぜひ購読してください。

ニュースレター登録(無料・30秒)

---

シリーズのご案内 (AIのしくみ地図 20編)

Foundations (F シリーズ):
– F1: LLM とは何か
– F2: Transformer は何をしたのか
– F3: ディープラーニングがただ大きな計算である理由
– F4: Attention Is All You Need 解説
– F5: Embedding とは何か
– F6: モデル学習 gradient descent (現在の記事)

Building Blocks (B シリーズ):
– B1: AI Agent は何が違うのか
– B2: Tool Use と Function Calling
– B3: Memory 設計
– … (以下20編まで)

Mechanisms (M シリーズ):
– M1: Retrieval Layer (RAG)
– M2: Fine-tuning vs RAG の判断基準
– …

---

著者: バイブコーディング テイラー(Lovable公式アンバサダー)
運営: テイラーの隠れ家(shuntailor.net)

ソースリスト

• テイラー知識百科事典 — AIのしくみ地図カテゴリ（本シリーズ20編全編）
• AIのしくみ地図 エントリーマップ — 全体構造 + 3つの読み方
• “Attention Is All You Need” (Vaswani et al., 2017)
• Anthropic · OpenAI · Google 公式ドキュメント
• mathbullet (YouTube) / Jay Alammar “Illustrated Transformer” / 3Blue1Brown — 易しい解説のリファレンス

---

著者: バイブコーディング テイラー (VibeCoding Tailor) — Lovable公式アンバサダー. AI·バイブコーディング専門メディアshuntailor.net運営.
本シリーズ「AIのしくみ地図」20編は、ウィキの蓄積と公式論文・公式ドキュメントを根拠に整理した体系的学習カリキュラムです。