難易度：★★★★★（正直、激ムズです！初学者の方は、読み飛ばしても大丈夫です）
💡第2章では、第1章で整えた環境と基礎をふまえ、いよいよディープラーニングの心臓部である「誤差逆伝播」と「自動微分」に切り込みます。
ニューラルネットがどのように学習し、どのようにパラメータを更新していくのか？
PyTorchの autograd の仕組みや、計算グラフを通じた勾配の伝播など、生成系AIにも不可欠な内部動作を丁寧に解説していきます。
🔜 次の第3章では、実際にシンプルなニューラルネットワークを構築し、MNIST手書き数字データを分類する一連の学習プロセスを体験します。この章ではディープラーニングの中身を数学的に解説しているため、正直難しいです。読み飛ばしたり、次の第3章で試してみてから戻ってくるのでも大丈夫です。
次の第3章までいくと、実データを用いたモデルの定義・学習・評価を通じて、深層学習の「一通りの流れ」が体感できる実践編です。
目次
4. 誤差逆伝播法（Backpropagation）と自動微分（autograd）
ディープラーニングを支える中心技術の1つが、誤差逆伝播法（バックプロパゲーション）です。
そして、PyTorchなどの深層学習フレームワークでは、計算グラフと自動微分（autograd）を用いて、この誤差逆伝播の計算を自動化しています。
4.1. 誤差逆伝播とは？
4.1.1. 順伝播と逆伝播
- 順伝播 (Forward pass)
入力から出力へ計算を進める工程。例えば、ニューラルネットワークの入力層 → 隠れ層 → 出力層と信号が流れていき、最終的に損失(L)を得ます。 - 逆伝播 (Backward pass)
出力側（損失）から逆向きに勾配（微分）を計算し、各層のパラメータ（重み・バイアス）を勾配降下法で更新する工程。\( w \leftarrow w – \eta \,\frac{\partial L}{\partial w} \)
というの式を用い、学習率ηだけパラメータを修正して誤差を減らしていきます。
4.1.2. 逆伝播フローのイメージ
下図は、誤差逆伝播の概念図（多層ニューラルネットを例に）です。
- 順伝播:
入力を順に変換し、出力を得る。 - 損失関数で誤差を計算:
出力と正解ラベルを比べて、スカラー値の損失(L)を算出。 - 誤差逆伝播:
損失を各層のパラメータに対して微分し、勾配(gradient)を得る。 - 勾配降下法:
勾配に基づき、重みやバイアスを修正 。 - 反復:
データセット全体に対して何度も繰り返すことで、誤差が徐々に減少し、モデルが最適化されていく。
以下では、計算グラフ (Computation Graph) と 自動微分 (autograd) を、なるべく直感的にイメージしやすいよう補足説明を加えながら解説します。（それでも、めちゃくちゃ難しいので、今後勉強を進めていった後で、戻ってくることをお勧めします。）
4.2. 計算グラフと自動微分 (autograd)
4.2.1. 計算グラフ(Computation Graph)とは？
直感で捉える計算グラフ
- 順伝播（forward pass）では、「入力データ（テンソル）」が、いくつもの「中間演算」（行列積、活性化関数など）を順番に通りながら変換されていき、最終的に「損失（Loss）」という評価値にたどり着きます。
- 左から右へ: 順伝播は、「入力」から「中間演算」いくつも通って最終的に「損失(Loss)」へ到達する一連の流れです。
- パイプラインや地図のよう:
- イメージとしては、パイプラインが何本も合流・分岐して、最終的に１本の配管（損失）に集約するようなものです。
- または、「入力から損失までの経路」を道路地図に例えることもできます。どの道（演算）を通って最終地点に至るかをノードとエッジで示します。
実際のディープラーニングでは、例えば「行列積 → 活性化関数 → 行列積 → 活性化関数 → …」といった具合に、層がどんどん重なり合います。これをすべて個別に微分するのは大変ですが、計算グラフを裏で構築しておくことで、後からまとめて「ここはこう微分すればいい」とわかるようになっているのです。
(A) 順伝播時の動き
- 入力 → 演算 → 演算… → 最後の損失(L)
各演算が実行されるたび、「どのテンソルを元に、このテンソルが生まれたか」をPyTorchが覚えています。 - 例えば、 以下の一つ一つのステップを、PyTorchはノード（中間のテンソル）とエッジ（各演算）で関連づけて記録します。
ここで W は「入力 x を変換するためのルール（線形変換）」として使われます。このように入力ベクトルを別の形に変える仕組みを数学では「写像（しゃぞう）」と呼びますが、かんたんに言えば「x を目的に合わせて変形するフィルター」のようなものです。
W は順伝播の計算中では“その時点では固定された値”として使われますが、モデルの学習においては「損失を減らすために少しずつ変えていく対象」でもあります。つまり、順伝播では「今の W を使って計算」し、逆伝播では「W をより良くするための方向」を勾配により見つけます。
具体例のイメージ
x_data W b
│ │ │
│ │ ▼
│ └───▶[ × ] ← 行列積（W・x）
│ │
└────────────▶[ + ] ← バイアス加算（+ b）
│
[σ(⋅)] ← 活性化関数（ReLU, Sigmoidなど）
│
[ Loss ] ← 損失関数（例：MSE, CrossEntropy）
- ノード =
x_data,W,b, 中間テンソルたち - エッジ = 各演算（乗算, 加算, 活性化, …）
(B) 逆伝播時の動き
- 損失 (Loss) から逆向きにたどる
- 逆伝播は、「損失関数の出力が、どのパラメータや中間演算にどのように影響されるか（=偏微分）」を、連鎖律（Chain Rule）（以下参照）を用いて順に計算していく工程です。
- 水路を逆流するイメージ
- 順伝播では、入力から水を流して最終地点（損失）に到達しました。逆伝播では、その水を逆方向にたどりながら、「どの水路（演算）が損失にどれだけ寄与したか」を追跡するような感覚です。
- 結果として得られるもの
- 各パラメータ（重みやバイアス）に対して、損失を小さくするための方向と量を表す勾配（偏微分値）が得られます。
- PyTorchでは、この勾配が
.grad属性に格納され、次のステップ（パラメータ更新）で「どれだけ、どの方向に変更すれば損失が下がるか」が分かるようになります。 - つまり逆伝播の目的は、「Wをどれだけ・どの方向に変えれば損失が減るか」を知ることです。
- そして、順伝播で使われ、逆伝播で調整されるW（重み）こそが、モデルが“学習”によって改善されていく核心です。
具体例のイメージ
x_data W b
│ │ │
│ │ ▼
│ └──────▶[ × ] ← 【順伝播】z = W・x_data（線形変換：行列積）
│ │ z は x_data と W の積（内積ベクトル）
└──────────────────────▶[ + ] ← 【順伝播】z = W・x + b（バイアス加算）
▲ → z はパラメータ W と b の両方の関数
[ σ(⋅) ] ← 【順伝播】a = σ(z)
▲ → a は活性化関数（ReLUやSigmoidなど）を通した非線形出力
[ ŷ ] ← 【順伝播】ŷ = f(a)
▲ → モデルの最終出力。クラス分類なら softmax の出力
[ Loss ] ← 【順伝播】L = Loss(ŷ, y_true)
→ 真の正解ラベル y_true とのズレ（誤差）を数値化する
──────────────────────────────────────────────
【逆伝播：パラメータに勾配（∂L/∂パラメータ）を伝える流れ】
∂L/∂ŷ ← 損失関数の出力に対する微分（例：CrossEntropy の場合は ∂L/∂ŷ = ŷ - y_true）
∂L/∂a = ∂L/∂ŷ × ∂ŷ/∂a
= ∂L/∂ŷ × σ'(z)
→ a = σ(z) であるため、連鎖律を使って逆伝播する
→ σ'(z) は ReLU なら 0 or 1、Sigmoid なら s(z)(1 - s(z))
∂L/∂z = ∂L/∂a × ∂a/∂z = ∂L/∂a × 1
→ z = W・x + b なので、z は W・x や b に直接依存している（加算なので係数は1）
∂L/∂W = ∂L/∂z × ∂z/∂W = ∂L/∂z × x_data^T
→ W は行列として x_data をかけて z を生成するため、入力 x_data が関与
∂L/∂b = ∂L/∂z × ∂z/∂b = ∂L/∂z
→ b は z にそのまま加えられるため、勾配はそのまま流れる
【結果】
→ すべてのパラメータ（W, b）について、「このパラメータを少し変えたら損失がどれだけ変わるか」
という勾配が計算され、SGD などの最適化手法で更新される。
各ノードにおける微分の意味：
∂L/∂ŷ: 出力と正解ラベルとの差から得られる損失の微分（損失関数の出力）∂L/∂a: 活性化関数の入力に対する勾配（σの導関数をかける）∂L/∂z: 線形和z = Wx + bに対する勾配∂L/∂W,∂L/∂x: 行列積の勾配（連鎖律を使って計算）
順伝播と逆伝播の計算グラフ
連鎖律（Chain Rule）とは ＋ 今回の例では
連鎖律（Chain Rule）は、複数の関数がつながっているときに、入力の変化が出力にどう影響するかを求めるルールです。
例えば、x → u → v → y という関数があるとき、「xが変わるとyはどう変わるか？」は、それぞれの関数の影響を掛け合わせて
\(\frac{dy}{dx} = \frac{dy}{dv} \cdot \frac{dv}{du} \cdot \frac{du}{dx}
\)
と求めます。
深層学習の逆伝播では、これを使って「損失が各パラメータにどう影響するか」を計算しています。
4.2.2. PyTorchのautograd
(A) requires_grad=True で追跡対象に
- テンソルを
w = torch.tensor(1.0, requires_grad=True)のように定義すると、PyTorchは「このwを使う演算はすべて計算グラフの一員だな」とみなします。 - 勾配は「学習対象（最適化の対象）のパラメータ」だけが持ちます。勾配は、今のパラメータが損失にどれくらい影響を与えやすいか（変化させたときに損失がどれだけ増減するか）を示し、損失を小さくするために、“どのパラメータをどれだけ動かすべきか”を教えてくれます。
PyTorchでは.requires_grad=Trueを指定したテンソルだけが、.gradに勾配を持てます。 - 順伝播中、「
wとxの乗算」「バイアス加算」「活性化関数」「最終損失との比較」など、あらゆる演算を繋いで「これがlossに至るルートだ」と内部に記録します。
(B) loss.backward() が逆伝播を自動実行
- ユーザーが計算式(逆伝播アルゴリズム)を書く必要は一切なし。
- 単に
loss.backward()と呼べば、PyTorchが計算グラフを後ろから前へ駆け上がり、自動的に逆伝播を行ってくれます。PyTorch は、順伝播（forward）で構築された「計算グラフ」をもとに、損失（loss）から逆向きに各演算の微分を計算します。これは、「連鎖律（Chain Rule）」という数学的なルールを使って、 - \(\frac{\partial \mathrm{loss}}{\partial w},\quad \frac{\partial \mathrm{loss}}{\partial b},\quad \ldots\)
- のように連鎖律で微分を計算し、それぞれのパラメータが損失に与える影響（勾配）を求めていく処理です。 そして、求めた勾配は、各パラメータ（
w,bなど）の 属性.gradに自動的に格納されます。
(C) 大規模モデルでも実装がシンプル
- CNN（画像認識などに使われる畳み込みニューラルネットワーク）やRNN（自然言語処理などに使われる再帰型ニューラルネットワーク）、Transformer（ChatGPTなどのLLM（大規模言語モデルなどに使われる））など深層かつ複雑なネットワークを手書きで微分するのは非現実的。
- autogradなら、どんなに層が多くても「順伝播（モデル定義）＋損失計算＋
loss.backward()」で誤差逆伝播が回るので、実装を大幅に簡略化できるのです。
4.2.3. さらに直感的なアナロジー
- 料理のレシピ
- 順伝播: 食材(パラメータ)を混ぜ合わせ、調理して最終料理(損失)を作る。
- 逆伝播: 出来上がった料理(損失)を食べ比べし、「塩をもう少し増やした方がいい」「水分を減らすべき」など、各材料(パラメータ)をどう変えれば味(誤差)が良くなるかを逆向きに探る。
- PyTorchはレシピ(計算グラフ)を裏で記録し、料理を舌で味見(損失評価)してから一気に「どの材料をどう増減すればベストか」まとめて教えてくれるイメージ。
- 交通地図・道順
- 順伝播: 「入力(出発点)から出力(目的地=損失)まで何本もの道(演算)を通り、どうルートを選ぶか」を正確に記録している。
- 逆伝播: 行き止まりにならないよう、地図を逆走しながら「どこで曲がれば最適か」「どの道路が時間をロスしているか」を計算して、最短経路(最小損失に至る勾配)を見つける。
こうしたアナロジーは、あくまでイメージではありますが、計算グラフと自動微分の「順伝播→逆伝播」という2段構えの流れを頭に思い浮かべるのに役立ちます。
4.2.4. まとめ (4.2 節)
- 計算グラフ (Computation Graph)
- ディープラーニングにおける順伝播を、ノード(テンソル)とエッジ(演算)で表した構造。
- 「入力 → 演算 → 演算 … → 損失」に至るすべての経路を把握し、後で逆向きに微分を計算するのが狙い。
- 順伝播時
- PyTorchが演算の履歴を保存し、どのテンソルがどの演算に使われたかをグラフ化して裏で管理。
requires_grad=Trueのテンソルが関係する演算はすべて追跡対象。
- 逆伝播時
loss.backward()を呼ぶと、計算グラフを後ろ(損失)から前(各パラメータ)へたどって連鎖律で微分を計算。- 各パラメータの
.gradという属性の勾配の値が更新され、誤差逆伝播(バックプロパゲーション)が完了する。
- PyTorchのautograd
- 順伝播と損失計算を定義するだけで、大規模ネットワークでも自動的に勾配を計算してくれる仕組み。
- 手書きで複雑な微分式を書く必要がなく、開発効率を飛躍的に向上。
- 直感的アナロジー
- 料理の味見や交通地図の逆走といったイメージで考えると、「出力(損失)から逆向きにどこをどう調整すれば良いかを教えてくれる」という感覚が掴みやすい。
これが計算グラフと自動微分の本質です。
この仕組みによって、私たちは「順伝播を書く → .backward() で一気に逆伝播」するというシンプルなコードで、大規模かつ複雑なディープラーニングモデルを動かすことができるようになっています。
4.3. コード例: 超シンプルな回帰モデルで見る誤差逆伝播
以下に、y=2x というルールのデータを学習する最小限のサンプルコードを示します。
コード内の各行にコメントを付け、実際にどんな操作が行われるかを丁寧に解説します。
# -*- coding: utf-8 -*-
# ↑ このファイルをUTF-8エンコーディングとして扱う指定（日本語コメント対応）
# ▼=========================================
# ライブラリのインポート
# ==========================================
import torch # PyTorch本体（テンソル計算・自動微分などの機能を提供）
import torch.nn as nn # ニューラルネットワーク関連の便利モジュール（損失関数など）
import torch.optim as optim # 最適化アルゴリズム（SGDなど）を使うためのモジュール
# ▼=========================================
# 学習対象のパラメータ（重み・バイアス）を定義
# ==========================================
# torch.tensor(..., requires_grad=True) とすることで、
# このテンソルに対して自動微分を行うようPyTorchに指示する。
# つまり、計算グラフにこの変数が登場したら、その演算履歴を記録し、勾配計算できるようになる。
w = torch.tensor(1.0, requires_grad=True) # 重みw（スカラー: shape=()、初期値1.0）
b = torch.tensor(0.0, requires_grad=True) # バイアスb（スカラー: shape=()、初期値0.0）
# ▼=========================================
# モデル（順伝播）の定義
# ==========================================
# 単純な線形モデル: y = w * x + b
# PyTorchでは、この関数の中で行われた演算が「ノード」として記録され、
# 自動的に計算グラフが構築される（動的計算グラフ）
def simple_model(x):
# xはshape=(4,)の1次元テンソル（入力バッチ：データ4つ）
# wはスカラー、bもスカラーなので、要素ごとに w*x[i] + b を計算する
return w * x + b # 出力もshape=(4,)の1次元テンソル
# ▼=========================================
# 損失関数とOptimizerの定義
# ==========================================
# nn.MSELoss()：平均二乗誤差（Mean Squared Error）を損失関数として利用。
# 出力と正解の差を2乗して平均した値が返る。 shape=(4,) → スカラーに
loss_fn = nn.MSELoss()
# PyTorchのoptimモジュールからSGD（確率的勾配降下法）を使って、
# パラメータ w と b を更新するように設定します。
# lr（learning rate, 学習率）は 0.01 に指定しています。
# 学習率は、パラメータをどれだけ更新するかの大きさを決める超パラメータです。
optimizer = optim.SGD([w, b], lr=0.01)
# ▼=========================================
# 学習データの作成
# ==========================================
# 入力xと正解yのデータ。y = 2 * x という関係にあるシンプルな直線。
x_data = torch.tensor([1.0, 2.0, 3.0, 4.0]) # shape=(4,) の1次元テンソル（入力4件）
y_data = torch.tensor([2.0, 4.0, 6.0, 8.0]) # shape=(4,) の1次元テンソル（正解）
# ▼=========================================
# 学習ループ
# ==========================================
# エポック：データ全体を何回繰り返して学習するか
num_epochs = 10
# forループで学習を繰り返す
for epoch in range(num_epochs):
# -----------------------
# (A) 順伝播 (Forward pass)
# -----------------------
# モデルに入力データ（x_data）を入れて予測値（y_pred）を得る
# y_pred: shape=(4,) の予測値ベクトル
y_pred = simple_model(x_data)
# -----------------------
# (B) 損失計算
# -----------------------
# 出力（予測値）と正解ラベルの差を計算し、損失（スカラー）を出す
loss = loss_fn(y_pred, y_data)
# -----------------------
# (C) 勾配の初期化
# -----------------------
# optimizer.zero_grad() は、パラメータ w, b に蓄積された勾配 (.grad) をリセットします。
# なぜ必要かというと、PyTorchではデフォルトで「勾配が加算方式」で記録されていくためです。
# 前のイテレーション（学習ステップ）での勾配が残ったままだと、意図しない更新になってしまう恐れがあります。
optimizer.zero_grad()
# -----------------------
# (D) 逆伝播 (Backward pass)
# -----------------------
# 学習データ（x）をモデルに入力すると、モデルは予測値（y_pred）を出力する。
# この予測値と正解ラベル（y_true）を比べて、「どれだけ間違っていたか」を数値化したものが Loss（損失）。
# つまり、Lossは「その学習データに対して、モデルの予測がどれだけズレているか」を表す。
#
# loss.backward() を呼ぶと、PyTorch は計算グラフをたどって、
# 各パラメータが損失にどれだけ影響を与えているか（= ∂Loss/∂パラメータ）を自動で計算する。
# つまり、「損失を最小化するには、どの方向に各パラメータを更新すべきか」が分かるようになる。
#
# ▶ 勾配の計算結果（∂L/∂w や ∂L/∂b）は、それぞれ w や b の .grad 属性に自動的に格納される。
#
# たとえば：
# - w = torch.tensor(1.0, requires_grad=True) は shape=() のスカラーテンソル（単一の値）
# - b = torch.tensor(0.0, requires_grad=True) も同様に shape=()
#
# → それぞれに対応して、
# - w.grad には ∂loss/∂w の計算結果（スカラーテンソル: shape=()）が入る
# - b.grad には ∂loss/∂b の計算結果（スカラーテンソル: shape=()）が入る
#
# つまり、w と w.grad は「**同じメモリ空間上にあるペア**」のようなもので、
# 勾配情報は w 本体の中に「.gradという属性」として保持される。
#
# 実際に勾配を確認すると以下のようなイメージになる：
# print(w) → tensor(1.2345, requires_grad=True)
# print(w.grad) → tensor(0.5678) ← ∂L/∂w の具体的な値
#
# 💡注意：
# この .grad は累積される仕組みなので、毎回 zero_grad() でリセットが必要。
loss.backward()
# loss.backward() は、各パラメータが損失にどれだけ影響しているか（＝勾配）を自動で計算する関数です。
# -----------------------
# (E) パラメータの更新
# -----------------------
# optimizer.step() により、学習率×勾配を使って w, b を更新
optimizer.step()
# -----------------------
# (F) 学習の進捗を表示
# -----------------------
print(f"Epoch {epoch+1}/{num_epochs} | Loss={loss.item():.4f} | w={w.item():.4f}, b={b.item():.4f}")
💡補足で図的にまとめると：
w = tensor(1.0, requires_grad=True)
│
├──演算に参加（例: y = w * x + b）
│
└──loss.backward() 実行後に…
↓
w.grad = ∂L/∂w ← 勾配がここに格納される（形状: shape=()）このように、勾配（gradient）は元の変数に紐づいた .grad 属性の中に保持されるので、「wの微分値はw.gradの中にある」と覚えておくと非常に便利です。
コードのポイント
wとbにrequires_grad=True- PyTorchがこれらのテンソルを勾配計算の対象とみなし、順伝播時に計算グラフを構築します。
- 順伝播 (
simple_model)- \(y = w \cdot x + b\) という演算が計算グラフに登録される。
loss.backward()loss(スカラー)を元に逆伝播が実行され、w.gradやb.gradに勾配が代入される。
optimizer.step()- 勾配をもとにSGDがパラメータを更新。たとえば 、以下など
\(w \leftarrow w – 0.01 \times \frac{\partial L}{\partial w}\)
- 勾配をもとにSGDがパラメータを更新。たとえば 、以下など
初期値では w=1.0 ですが、数エポック学習すると w が2.0付近に収束し、 b も0に近づいていくのが観察できるはずです（理想的には y=2x+0）。
4.4. より深い層では？
実際のニューラルネットワークは、畳み込み層(Conv2d)、バッチ正規化(BatchNorm)、再帰層(RNN/Transformer) など多くのレイヤーを持ちます。
しかし、このサンプルのように
- 順伝播で出力と損失を計算
loss.backward()で逆伝播（勾配計算）optimizer.step()でパラメータ更新
という仕組みは基本的に同じです。
4.5. 誤差逆伝播フロー (図解)
下図は、多層ネットワークでの誤差逆伝播の流れを概念的に描いたものです（入力層→隠れ層→出力層）。
- 順伝播:
入力層から隠れ層を経て出力層まで信号が伝わり、予測結果(クラス確率など)を計算。 - 損失計算:
出力を正解と比較し、スカラー値の誤差(L)を得る。 - 逆伝播:
出力層から隠れ層へ、連鎖律を使って微分値(勾配)を逆方向に伝える。各層の重み(w)やバイアス(b)に対する勾配を算出。 - 勾配降下:
求めた勾配でパラメータを少しずつ修正し、誤差が減る方向へモデルを更新する。 - 繰り返し:
多数の学習サンプルを通して上記工程を反復し、モデルが最適化される。
4.6. 医療データへの応用
- 画像診断（X線、CT、MRIなど）:
畳み込みニューラルネット(CNN)で画像から特徴を抽出し、誤差逆伝播によってフィルタが自動的に学習される。 - テキスト処理（電子カルテ、文献）:
文字列をベクトル化し、RNNやTransformerを使って時系列処理。誤差逆伝播で単語埋め込みやAttention機構の重みが最適化される。 - 音声分析（心音、呼吸音）:
音声信号をスペクトログラムなどに変換してCNN/RNNで解析。誤差逆伝播によりモデルが音響的特徴を捉える。
いずれのケースでも自動微分(autograd) が支えており、複雑な誤差逆伝播アルゴリズムをユーザーが手書きしなくても済むため、大規模モデルや大量データにも柔軟に対応できます。
4.7. まとめ
- 誤差逆伝播法（Backpropagation）
- ディープラーニングの学習を支える中核的アルゴリズム。
- 損失(誤差)を出力層から逆向きに伝えながら、各層の重みに対する勾配を計算・更新。
- 自動微分(autograd)と計算グラフ
- PyTorchは計算グラフを自動構築し、
loss.backward()で連鎖律を適用して勾配を求める。 - 利用者は順伝播（モデル定義と損失計算）を書くのみでOK。
- PyTorchは計算グラフを自動構築し、
- 学習フロー
- 順伝播 (forward)
- 損失 (loss) 計算
- 逆伝播 (
loss.backward()) - パラメータ更新 (
optimizer.step()) - 勾配リセット (
optimizer.zero_grad())
- 実装のシンプルさ
- フレームワークのおかげで、誤差逆伝播の数式を自分で書く必要がない。
- 大規模ネットワークでも同じ仕組みで学習できる。
- 医療AIへの影響
- 異種データ(画像, テキスト, 音声等)を扱う複雑なニューラルネットでも短期間で開発可能。
- 大量の医療データからモデルが特徴を自動学習し、高精度な診断支援や文書要約が実現。
上記のように、誤差逆伝播と自動微分はディープラーニングの核となる要素です。
出力から逆向きに勾配を伝えるというアイデアと、フレームワークが計算グラフを管理して一気に微分するという仕組みが組み合わさり、私たちは複雑なニューラルネットを短いコードで高速に学習させられるわけです。医療を含む幅広い分野での大規模AI活用を支える、まさに基盤技術といえます。
🔜 次の第3章では、実際にシンプルなニューラルネットワークを構築し、MNIST手書き数字データを分類する一連の学習プロセスを体験します。
実データを用いたモデルの定義・学習・評価を通じて、深層学習の「一通りの流れ」が体感できる実践編です。
コメント