🧠 STEP 5: 損失関数の理解

ニューラルネットワークが「何を学習するか」を決める重要な関数を理解しよう

📋 このステップで学ぶこと

損失関数とは何か？なぜ必要なのか？
平均二乗誤差（MSE）：回帰問題の損失関数
交差エントロピー誤差：分類問題の損失関数
二値分類と多クラス分類の違い
損失関数の選び方

🎯 1. 損失関数とは何か？

1-1. 損失関数の基本

損失関数（Loss Function）とは、予測値と正解値がどれだけ離れているかを数値化する関数です。
「誤差関数」「コスト関数」とも呼ばれます。

🎯 例え話：テストの採点

学校のテストを考えてみましょう。

正解：先生が用意した模範解答
予測：あなたが書いた解答
損失：模範解答との「ずれ」（減点）

テストの点数が低い（損失が大きい）と、勉強法を見直しますよね？
ニューラルネットワークも同じで、損失を見て「重み」を調整します。

1-2. なぜ損失関数が必要なのか？

ニューラルネットワークの学習は、「損失を最小化する」ことです。
損失関数がなければ、「何を改善すべきか」がわかりません。

【ニューラルネットワークの学習サイクル】

1. 入力データを受け取る
      ↓
2. 予測を行う（順伝播）
      ↓
3. 損失関数で「予測と正解のずれ」を計算  ← ここ！
      ↓
4. 損失を減らす方向に重みを更新（逆伝播）
      ↓
5. 1に戻って繰り返し

→ 損失関数は「学習の羅針盤」のようなもの

🎯 損失関数の3つの役割

誤差の定量化：予測がどれだけ間違っているかを「数値」で表す
学習の指標：何を最小化すべきかを明確にする
重みの更新方向を決定：損失を減らす方向に重みを調整

1-3. 損失関数の選び方で結果が変わる

💡 重要：損失関数が違えば、学習結果も変わる！

例えば、同じデータでも：
・MSE（平均二乗誤差）を使う → 大きな誤差を特に嫌う
・MAE（平均絶対誤差）を使う → すべての誤差を平等に扱う

問題の種類に合った損失関数を選ぶことが重要です。

📐 2. 平均二乗誤差（MSE）

2-1. MSEとは？

平均二乗誤差（Mean Squared Error: MSE）は、回帰問題で最もよく使われる損失関数です。

📐 MSEの式

MSE = (1/n) × Σ(正解値 – 予測値)²

記号の意味：

n：データの数
Σ：合計を取る
(正解値 – 予測値)²：誤差の2乗

2-2. MSEの計算手順

MSEは3つのステップで計算します。

【MSEの計算手順】

ステップ1：各データの誤差を計算
─────────────────────────────
誤差 = 正解値 – 予測値

ステップ2：誤差を2乗する
─────────────────────────────
誤差² = (正解値 – 予測値)²

ステップ3：平均を取る
─────────────────────────────
MSE = (誤差²の合計) ÷ データ数

2-3. 具体例で理解しよう

🏠 例：住宅価格の予測

3軒の住宅価格を予測したとします。

住宅	正解価格	予測価格	誤差	誤差²
A	100万円	110万円	-10	100
B	200万円	190万円	+10	100
C	300万円	320万円	-20	400

📊 MSEの計算

誤差²の合計 = 100 + 100 + 400 = 600
データ数 = 3
MSE = 600 ÷ 3 = 200

→ 平均的に「200万円²」の誤差があることを意味します

2-4. なぜ「2乗」するのか？

💡 誤差を2乗する3つの理由

理由1：正負を消す

誤差には「+10万円」「-10万円」のように正負があります。
そのまま足すと相殺されてしまいます（+10 + (-10) = 0）。
2乗すれば、どちらも正の値になります（100 + 100 = 200）。

理由2：大きな誤差を重視する

2乗すると、大きな誤差はさらに大きくなります。
誤差10 → 100、誤差20 → 400（4倍ではなく、実質2倍の重み）
→ 大きな間違いを特に嫌うようになります。

理由3：微分しやすい

2乗関数は微分が簡単（勾配降下法で使いやすい）。

2-5. Pythonで実装してみよう

📝 コードの解説

def mean_squared_error(y_true, y_pred):

MSEを計算する関数を定義。y_trueは正解値、y_predは予測値。

(y_true – y_pred) ** 2

各データの誤差を2乗。**2は「2乗」を意味する。

np.mean(…)

平均を計算。これで「平均二乗誤差」の完成。

import numpy as np

def mean_squared_error(y_true, y_pred):
    “””平均二乗誤差（MSE）を計算する関数”””
    return np.mean((y_true – y_pred) ** 2)

# ===== 例1: 完璧な予測 =====
y_true = np.array([100, 200, 300])  # 正解価格
y_pred = np.array([100, 200, 300])  # 予測価格（完璧に一致）
mse = mean_squared_error(y_true, y_pred)
print(f”例1（完璧な予測）: MSE = {mse}”)

# ===== 例2: 少しずれた予測 =====
y_true = np.array([100, 200, 300])
y_pred = np.array([110, 190, 320])  # 少しずれている
mse = mean_squared_error(y_true, y_pred)
print(f”例2（少しずれ）: MSE = {mse}”)

# ===== 例3: 大きくずれた予測 =====
y_true = np.array([100, 200, 300])
y_pred = np.array([150, 250, 350])  # 50ずつずれている
mse = mean_squared_error(y_true, y_pred)
print(f”例3（大きくずれ）: MSE = {mse}”)

実行結果：

例1（完璧な予測）: MSE = 0.0
例2（少しずれ）: MSE = 200.0
例3（大きくずれ）: MSE = 2500.0

2-6. RMSE（平均二乗誤差平方根）

MSEの問題点は、単位が「元データの2乗」になることです。
これを解決するのがRMSE（Root Mean Squared Error）です。

📊 RMSE = √MSE

上の例2の場合：
MSE = 200
RMSE = √200 ≈ 14.1万円

→ 「平均的に14.1万円ずれている」と解釈できます。
→ 元のデータと同じ単位なので、直感的にわかりやすい！

import numpy as np

def rmse(y_true, y_pred):
    “””平均二乗誤差平方根（RMSE）”””
    mse = np.mean((y_true – y_pred) ** 2)
    return np.sqrt(mse)  # 平方根を取る

y_true = np.array([100, 200, 300])
y_pred = np.array([110, 190, 320])

print(f”MSE = {mean_squared_error(y_true, y_pred)}”)
print(f”RMSE = {rmse(y_true, y_pred):.1f}万円”)

実行結果：

MSE = 200.0
RMSE = 14.1万円

🎲 3. 交差エントロピー誤差（Cross-Entropy）

3-1. なぜ分類問題にはMSEを使わないのか？

分類問題では、出力は確率として解釈されます。
確率の誤差を測るには、MSEより交差エントロピーの方が適切です。

⚠️ 分類問題でMSEを使うと問題が起きる

例：正解が「猫（1）」、予測確率が0.9の場合

MSE = (1 – 0.9)² = 0.01 ← 小さな損失

例：正解が「猫（1）」、予測確率が0.1の場合

MSE = (1 – 0.1)² = 0.81 ← それほど大きくない

→ 「自信を持って間違えた」場合のペナルティが十分に大きくない！

3-2. 交差エントロピーとは？

交差エントロピー（Cross-Entropy）は、2つの確率分布の違いを測る指標です。

💡 直感的な理解

「正解の確率分布」と「予測の確率分布」がどれだけ似ているかを測ります。

完璧な予測：交差エントロピー = 0（最小）
間違った予測：交差エントロピーが大きくなる
自信を持って間違えた：交差エントロピーが非常に大きくなる

→ 「間違いに厳しい」損失関数です！

3-3. 対数（log）の意味

交差エントロピーでは対数（log）を使います。なぜでしょうか？

【対数（log）の特徴】

log(1) = 0        ← 確率1（完璧）なら損失0
log(0.5) ≈ -0.69  ← 半々なら中程度の損失
log(0.1) ≈ -2.3   ← 確率低いと大きな損失
log(0.01) ≈ -4.6  ← 確率すごく低いと非常に大きな損失
log(0) = -∞       ← 確率0なら無限大の損失！

→ 確率が低くなるほど、損失が急激に増加する！
→ 「自信を持って間違えた」場合に大きなペナルティ

以下の図は横スクロールできます。

【-log(x)のグラフ】

損失
  5 ┤●
    │ ╲
  4 ┤  ╲
    │   ╲
  3 ┤    ╲
    │     ╲
  2 ┤      ╲
    │       ╲
  1 ┤        ╲
    │         ╲━━━━━
  0 ┤              ╲━━●
    └──┬──┬──┬──┬──┬──→ 確率
      0  0.2 0.4 0.6 0.8 1.0

確率が高い → 損失が小さい（正しい予測）
確率が低い → 損失が大きい（間違った予測）

3-4. 二値分類の交差エントロピー（Binary Cross-Entropy）

二値分類（2クラス）で使う交差エントロピーです。

📐 二値交差エントロピーの式

BCE = -[y × log(p) + (1-y) × log(1-p)]

記号の意味：

y：正解ラベル（0または1）
p：予測確率（0〜1）
log：自然対数

3-5. 計算例で理解しよう

📊 例：猫（y=1）か犬（y=0）かの分類

ケース1：正解が猫（y=1）、予測確率90%（p=0.9）

BCE = -[1 × log(0.9) + 0 × log(0.1)]
= -log(0.9)
≈ 0.105（小さい損失 ✅）

ケース2：正解が猫（y=1）、予測確率50%（p=0.5）

BCE = -[1 × log(0.5) + 0 × log(0.5)]
= -log(0.5)
≈ 0.693（中程度の損失）

ケース3：正解が猫（y=1）、予測確率10%（p=0.1）

BCE = -[1 × log(0.1) + 0 × log(0.9)]
= -log(0.1)
≈ 2.303（大きな損失 ❌）

3-6. Pythonで実装（二値分類）

📝 コードの解説

epsilon = 1e-15

非常に小さな値。log(0)は無限大になるのを防ぐため。

np.clip(y_pred, epsilon, 1 – epsilon)

予測値をepsilon〜(1-epsilon)の範囲に制限。

-np.mean(y_true * np.log(y_pred) + …)

交差エントロピーの式をそのまま実装。

import numpy as np

def binary_cross_entropy(y_true, y_pred):
    “””二値交差エントロピーを計算する関数”””
    # log(0)を避けるため、小さな値を使う
    epsilon = 1e-15
    y_pred = np.clip(y_pred, epsilon, 1 – epsilon)
    
    # 交差エントロピーの計算
    bce = -np.mean(y_true * np.log(y_pred) + (1 – y_true) * np.log(1 – y_pred))
    return bce

# 正解は「猫」（y=1）
y_true = np.array([1])

print(“=== 二値交差エントロピーの計算 ===”)
print(“正解：猫（y=1）”)
print()

# ケース1: 90%の確率で猫と予測
y_pred = np.array([0.9])
print(f”予測確率 90%: BCE = {binary_cross_entropy(y_true, y_pred):.3f}”)

# ケース2: 50%の確率で猫と予測
y_pred = np.array([0.5])
print(f”予測確率 50%: BCE = {binary_cross_entropy(y_true, y_pred):.3f}”)

# ケース3: 10%の確率で猫と予測（間違い）
y_pred = np.array([0.1])
print(f”予測確率 10%: BCE = {binary_cross_entropy(y_true, y_pred):.3f}”)

実行結果：

=== 二値交差エントロピーの計算 ===
正解：猫（y=1）

予測確率 90%: BCE = 0.105
予測確率 50%: BCE = 0.693
予測確率 10%: BCE = 2.303

💡 ポイント：間違えるほど損失が急増！

予測確率90% → 損失0.105
予測確率50% → 損失0.693（約6.6倍）
予測確率10% → 損失2.303（約22倍）

→ 「自信を持って間違えた」場合に厳しいペナルティ！
→ これにより、モデルは正しいクラスの確率を高めることを学習します。

3-7. 多クラス分類の交差エントロピー（Categorical Cross-Entropy）

多クラス分類（3クラス以上）で使う交差エントロピーです。

📐 カテゴリカル交差エントロピーの式

CCE = -Σ y_i × log(p_i)

記号の意味：

y_i：正解ラベル（one-hotエンコーディング）
p_i：各クラスの予測確率
Σ：すべてのクラスで合計

3-8. One-hotエンコーディングとは？

📖 One-hotエンコーディング

正解クラスだけ1、それ以外は0で表す方法です。

【3クラス分類（猫、犬、鳥）の場合】

正解が「猫」→ [1, 0, 0]
正解が「犬」→ [0, 1, 0]
正解が「鳥」→ [0, 0, 1]

【10クラス分類（手書き数字0〜9）の場合】

正解が「3」→ [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
              ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
              0 1 2 3 4 5 6 7 8 9

3-9. 計算例（多クラス分類）

📊 例：3クラス分類（猫、犬、鳥）

正解：猫 → y = [1, 0, 0]

ケース1：自信を持って正解

予測：[0.8, 0.15, 0.05]（猫80%、犬15%、鳥5%）

CCE = -[1×log(0.8) + 0×log(0.15) + 0×log(0.05)]
= -log(0.8) ≈ 0.223

ケース2：自信を持って間違い

予測：[0.1, 0.8, 0.1]（猫10%、犬80%、鳥10%）

CCE = -[1×log(0.1) + 0×log(0.8) + 0×log(0.1)]
= -log(0.1) ≈ 2.303

3-10. Pythonで実装（多クラス分類）

import numpy as np

def categorical_cross_entropy(y_true, y_pred):
    “””カテゴリカル交差エントロピーを計算する関数”””
    epsilon = 1e-15
    y_pred = np.clip(y_pred, epsilon, 1 – epsilon)
    return -np.sum(y_true * np.log(y_pred))

# 正解は「猫」（one-hot: [1, 0, 0]）
y_true = np.array([1, 0, 0])

print(“=== カテゴリカル交差エントロピーの計算 ===”)
print(“正解：猫”)
print(“クラス：[猫, 犬, 鳥]”)
print()

# ケース1: 自信を持って正解
y_pred1 = np.array([0.8, 0.15, 0.05])
print(f”予測 [0.8, 0.15, 0.05]: CCE = {categorical_cross_entropy(y_true, y_pred1):.3f}”)

# ケース2: やや自信がない
y_pred2 = np.array([0.5, 0.3, 0.2])
print(f”予測 [0.5, 0.3, 0.2]: CCE = {categorical_cross_entropy(y_true, y_pred2):.3f}”)

# ケース3: 自信を持って間違い
y_pred3 = np.array([0.1, 0.8, 0.1])
print(f”予測 [0.1, 0.8, 0.1]: CCE = {categorical_cross_entropy(y_true, y_pred3):.3f}”)

実行結果：

=== カテゴリカル交差エントロピーの計算 ===
正解：猫
クラス：[猫, 犬, 鳥]

予測 [0.8, 0.15, 0.05]: CCE = 0.223
予測 [0.5, 0.3, 0.2]: CCE = 0.693
予測 [0.1, 0.8, 0.1]: CCE = 2.303

🔄 4. 二値分類と多クラス分類の比較

4-1. 二値分類（Binary Classification）

🔵 2つのクラスに分類する問題

例：

スパムメール判定（スパム / 正常）
病気診断（陽性 / 陰性）
画像分類（猫 / 犬）

設定：

出力層：1ユニット（Sigmoid活性化）
損失関数：Binary Cross-Entropy
出力：0〜1の1つの値（確率）

4-2. 多クラス分類（Multi-Class Classification）

🌈 3つ以上のクラスに分類する問題

例：

手書き数字認識（0〜9の10クラス）
動物分類（猫、犬、鳥、馬、…）
感情分析（喜び、怒り、悲しみ、…）

設定：

出力層：クラス数のユニット（Softmax活性化）
損失関数：Categorical Cross-Entropy
出力：各クラスの確率（合計1）

4-3. 比較表

項目	二値分類	多クラス分類
クラス数	2つ	3つ以上
出力層ユニット数	1	クラス数
活性化関数	Sigmoid	Softmax
損失関数	Binary CE	Categorical CE
出力の形式	0〜1の1つの値	各クラスの確率（合計1）

4-4. 図で理解する

以下の図は横スクロールできます。

【二値分類の出力】

入力 → [隠れ層] → [出力層: 1ユニット] → Sigmoid → 0.8
                                                    ↓
                                            「80%の確率で猫」
                                            (50%以上なら猫と判定)

【多クラス分類の出力】

入力 → [隠れ層] → [出力層: 3ユニット] → Softmax → [0.7, 0.2, 0.1]
                                                        ↓
                                                「猫70%, 犬20%, 鳥10%」
                                                (最大の猫と判定)

🎯 5. 損失関数の選び方

5-1. 問題タイプ別の選択ガイド

🧭 損失関数の選択フローチャート

Q: 何を予測する問題ですか？

A1: 連続的な数値（価格、温度など）
→ 回帰問題 → MSE（またはMAE、RMSE）

A2: カテゴリ（クラス）
→ 分類問題 → Q2へ

Q2: クラス数はいくつ？

2クラス → Binary Cross-Entropy（出力層：Sigmoid）
3クラス以上 → Categorical Cross-Entropy（出力層：Softmax）

5-2. TensorFlow/Kerasでの設定例

📝 問題タイプ別の設定

以下は、TensorFlow/Kerasで各問題タイプを設定する例です。
（詳しい使い方はSTEP 6以降で学習します）

以下のコードは横スクロールできます。

# ===== 回帰問題（住宅価格予測など）=====
model.compile(
    optimizer=’adam’,
    loss=’mse’  # または ‘mean_squared_error’
)
# 出力層: Dense(1)  ← 活性化関数なし

# ===== 二値分類（スパム判定など）=====
model.compile(
    optimizer=’adam’,
    loss=’binary_crossentropy’
)
# 出力層: Dense(1, activation=’sigmoid’)

# ===== 多クラス分類（手書き数字認識など）=====
model.compile(
    optimizer=’adam’,
    loss=’categorical_crossentropy’
)
# 出力層: Dense(10, activation=’softmax’)  ← クラス数分のユニット

5-3. まとめチャート

【損失関数・活性化関数の組み合わせ】

┌─────────────┬─────────────────┬────────────────────┐
│ 問題タイプ  │ 出力層          │ 損失関数           │
├─────────────┼─────────────────┼────────────────────┤
│ 回帰        │ Dense(1)        │ MSE                │
│             │ 活性化なし      │                    │
├─────────────┼─────────────────┼────────────────────┤
│ 二値分類    │ Dense(1)        │ Binary CE          │
│             │ Sigmoid         │                    │
├─────────────┼─────────────────┼────────────────────┤
│ 多クラス分類│ Dense(クラス数) │ Categorical CE     │
│             │ Softmax         │                    │
└─────────────┴─────────────────┴────────────────────┘

💡 覚えておくべきポイント

問題タイプで決まる：回帰か分類か、何クラスか
出力層と損失関数はセット：活性化関数と損失関数は対応している
標準的な組み合わせを使う：特別な理由がない限り、上記の組み合わせを使用

📝 STEP 5 のまとめ

✅ このステップで学んだこと

損失関数は、予測値と正解値の誤差を定量化する関数
MSE（平均二乗誤差）は回帰問題で使用、大きな誤差を重視
交差エントロピーは分類問題で使用、間違いに厳しいペナルティ
二値分類：Sigmoid + Binary Cross-Entropy
多クラス分類：Softmax + Categorical Cross-Entropy
損失関数の選択は問題タイプで決まる

💡 重要ポイント

損失関数は、ニューラルネットワークが「何を学習するか」を決める重要な要素です。

基本ルール：
・回帰 → MSE
・二値分類（2クラス）→ Binary Cross-Entropy
・多クラス分類（3クラス以上）→ Categorical Cross-Entropy

次のSTEP 6では、TensorFlow/Kerasのインストールと環境構築を学び、
実際にディープラーニングモデルを動かす準備をしましょう！

📝 練習問題

問題1 やさしい

損失関数の役割

損失関数の説明として正しいものを選んでください。

A. 活性化関数の一種である
B. 予測値と正解値の誤差を定量化する
C. データを正規化する関数である
D. 重みの初期値を決める関数である

正解：B

なぜBが正解なのか？

損失関数は、予測値と正解値がどれだけ離れているかを数値化する関数です。
この「誤差」を基に、ニューラルネットワークは重みを調整して学習します。

他の選択肢の解説：

Aが間違い：活性化関数（Sigmoid、ReLUなど）と損失関数は全く別のものです。
・活性化関数：各ニューロンの出力を変換
・損失関数：予測全体の誤差を計算

Cが間違い：データの正規化は前処理の一部であり、損失関数とは関係ありません。

Dが間違い：重みの初期値を決めるのは「重みの初期化」であり、損失関数とは別です。

問題2 やさしい

MSEの適用

次の問題のうち、MSE（平均二乗誤差）を使うのに最も適切なものを選んでください。

A. メール分類（スパム / 正常）
B. 住宅価格の予測
C. 手書き数字認識（0〜9）
D. 動物分類（猫、犬、鳥）

正解：B

なぜBが正解なのか？

MSE（平均二乗誤差）は回帰問題で使用します。
回帰問題とは、連続的な数値を予測する問題です。

住宅価格（100万円、200万円、…）は連続的な数値なので、MSEが適切です。

他の選択肢の解説：

A、C、Dはすべて「分類問題」です。分類問題には交差エントロピーを使います。

A（メール分類）：2クラス → Binary Cross-Entropy
C（手書き数字）：10クラス → Categorical Cross-Entropy
D（動物分類）：3クラス → Categorical Cross-Entropy

見分け方のコツ：

・「〜の値を予測」→ 回帰問題 → MSE
・「〜に分類」「〜かどうか判定」→ 分類問題 → Cross-Entropy

問題3 ふつう

損失関数と活性化関数の組み合わせ

3クラス分類（猫、犬、鳥）を行う場合、出力層の設定として正しいものを選んでください。

A. Dense(1, activation=’sigmoid’) + ‘binary_crossentropy’
B. Dense(3, activation=’softmax’) + ‘categorical_crossentropy’
C. Dense(3, activation=’relu’) + ‘mse’
D. Dense(1) + ‘mse’

正解：B

なぜBが正解なのか？

3クラス分類は多クラス分類なので、以下の設定が必要です：

出力層のユニット数：クラス数（3）
活性化関数：Softmax（各クラスの確率を出力）
損失関数：Categorical Cross-Entropy

他の選択肢の解説：

Aが間違い：これは二値分類（2クラス）の設定です。
出力が1ユニットなので、「猫か猫でないか」しか判定できません。

Cが間違い：ReLUは隠れ層で使う活性化関数です。
出力層の分類問題では使いません。また、MSEは回帰問題用です。

Dが間違い：これは回帰問題の設定です。
分類問題には使えません。

覚え方：

二値分類 → Dense(1) + Sigmoid + Binary CE
多クラス → Dense(クラス数) + Softmax + Categorical CE
回帰 → Dense(1) + なし + MSE

問題4 むずかしい

交差エントロピーの理解

二値分類で、正解が1（猫）のとき、以下の予測のうち最も損失が大きいものを選んでください。

A. 予測確率 = 0.9
B. 予測確率 = 0.7
C. 予測確率 = 0.5
D. 予測確率 = 0.1

正解：D

なぜDが最も損失が大きいのか？

交差エントロピーでは、正解クラスの予測確率が低いほど損失が大きくなります。
正解が1（猫）なのに、予測確率が0.1（10%）ということは、
「90%の確率で猫ではない」と自信を持って間違えている状態です。

各選択肢の損失を計算：

正解が1（猫）の場合の損失 = -log(予測確率)

A: -log(0.9) ≈ 0.105 ← 小さい（正しい予測）
B: -log(0.7) ≈ 0.357
C: -log(0.5) ≈ 0.693
D: -log(0.1) ≈ 2.303 ← 大きい（間違った予測）

グラフで理解：

損失
2.5 ┤●D
    │
2.0 ┤
    │
1.5 ┤
    │
1.0 ┤
    │   ●C
0.5 ┤  ●B
    │ ●A
0.0 ┤─────────────→ 予測確率
    0.1 0.5 0.7 0.9

→ 予測確率が低いほど、損失が急激に増加！

なぜこの特性が重要か？

「間違いに厳しい」ことで、モデルは正しいクラスの確率を高めることを強く学習します。
MSEでは損失が0.81（= (1-0.1)²）ですが、交差エントロピーでは2.303と、
約2.8倍のペナルティが課されます。
これが分類問題で交差エントロピーが適している理由です。

📝

学習メモ

ディープラーニング基礎 - Step 5

📋 過去のメモ一覧 ▼