🧠 STEP 4: 活性化関数

ニューラルネットワークに「非線形性」を与える重要な関数を理解しよう

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

活性化関数とは何か？なぜ必要なのか？
シグモイド関数（Sigmoid）とtanh関数
ReLU（現在最も人気の活性化関数）
Leaky ReLU、ELU（ReLUの改良版）
Softmax関数（多クラス分類用）
活性化関数の選び方

🎯 1. 活性化関数とは何か？

1-1. 活性化関数の基本

活性化関数（Activation Function）とは、ニューラルネットワークの各ニューロン（ユニット）で出力を変換する関数です。

💡 例え話：スイッチの感度調整

STEP 2で学んだステップ関数は、「0か1のスイッチ」のようなものでした。
しかし、現実世界ではもっと柔軟な判断が必要です。

例えば、「天気が良ければ買い物に行く」という判断も、
実際には「すごく良い → 絶対行く」「まあまあ → たぶん行く」「微妙 → 迷う」のようにグラデーションがあります。

活性化関数は、このグラデーション（連続的な変化）を表現するためのものです。

1-2. なぜ活性化関数が必要なのか？

活性化関数がなければ、ニューラルネットワークは非常に限られた問題しか解けません。

❌ 活性化関数がない場合の問題

活性化関数がないと、どんなに層を重ねても単純な線形変換にしかなりません。

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

【活性化関数がない場合】

第1層: y₁ = W₁・x
第2層: y₂ = W₂・y₁ = W₂・W₁・x
第3層: y₃ = W₃・y₂ = W₃・W₂・W₁・x

↓ 結局…

y₃ = (W₃・W₂・W₁)・x = W・x

→ どんなに層を重ねても、1つの行列Wとの掛け算と同じ！
→ XORのような非線形問題は解けない！

【活性化関数がある場合】

第1層: y₁ = f(W₁・x)        ← 活性化関数fを適用
第2層: y₂ = f(W₂・y₁)       ← 活性化関数fを適用
第3層: y₃ = f(W₃・y₂)       ← 活性化関数fを適用

→ 非線形な変換が何度も行われる
→ 複雑なパターンを表現できる！

🎯 活性化関数の3つの役割

非線形性を導入：直線では表せない複雑なパターンを学習可能にする
出力を適切な範囲に制限：数値が無限に大きくなる（爆発する）のを防ぐ
勾配の伝播を助ける：学習を効率的に進められるようにする

1-3. 活性化関数の位置

活性化関数は、各層の重み付き和の計算の後に適用されます。

【1つのニューロンでの計算の流れ】

ステップ1：重み付き和を計算
─────────────────────────────
z = w₁x₁ + w₂x₂ + … + b

ステップ2：活性化関数を適用
─────────────────────────────
a = f(z)    ← この f が活性化関数！

ステップ3：次の層へ出力
─────────────────────────────
この a が次の層の入力になる

📊 2. ステップ関数（復習と問題点）

2-1. ステップ関数の復習

STEP 2で学んだステップ関数は、最も単純な活性化関数です。

📐 ステップ関数の定義

step(x) = 1 （x > 0 のとき）
step(x) = 0 （x ≤ 0 のとき）

入力が0より大きければ1、そうでなければ0を出力します。

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

【ステップ関数のグラフ】

出力
  1 ┤          ●━━━━━━━━━━━━
    │          │
    │          │
    │          │
  0 ┤━━━━━━━━━━○
    │
    └──────────┼──────────→ 入力
              0

特徴：
・出力は0か1の2値のみ
・x=0で急激に切り替わる（不連続）
・スイッチのON/OFFのような動作

2-2. ステップ関数の問題点

❌ ステップ関数の3つの問題点

問題1：微分ができない

x=0の点で不連続（ジャンプ）しているため、その点で微分ができません。
ニューラルネットワークの学習では微分が必要なため、これは大きな問題です。

問題2：勾配がほとんど0

x≠0のところでは勾配（傾き）が0です。
勾配が0だと、重みの更新ができず、学習が進みません。

問題3：柔軟性がない

出力が0か1しかないため、「80%の確率で猫」のような柔軟な表現ができません。

💡 より良い活性化関数が必要！

ステップ関数の問題を解決するために、様々な活性化関数が開発されました。
これから、代表的な活性化関数を順番に学んでいきましょう。

📈 3. シグモイド関数（Sigmoid）

3-1. シグモイド関数とは？

シグモイド関数（Sigmoid Function）は、ステップ関数をなめらかにした関数です。
「S字カーブ」を描くことから、シグモイド（S字型）と呼ばれます。

📐 シグモイド関数の定義

σ(x) = 1 / (1 + e^-x)

eはネイピア数（約2.718）で、数学の重要な定数です。
e^-xはeの-x乗を意味します。

出力範囲：0 〜 1（0より大きく1より小さい値）

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

【シグモイド関数のグラフ】

出力
  1 ┤                    ╭━━━━━━
    │                 ╱
    │              ╱
0.5 ┤          ╱
    │       ╱
    │    ╱
  0 ┤━━━╯
    │
    └──────────┼──────────→ 入力
              0

特徴：
・出力は0〜1の連続的な値
・なめらかなS字カーブ
・x=0のとき、出力は0.5
・どこでも微分可能

3-2. シグモイド関数の値を計算してみよう

📊 具体的な計算例

x = 0 のとき：

σ(0) = 1 / (1 + e⁰) = 1 / (1 + 1) = 1/2 = 0.5

x = 2 のとき：

σ(2) = 1 / (1 + e⁻²) = 1 / (1 + 0.135) ≈ 0.88

x = -2 のとき：

σ(-2) = 1 / (1 + e²) = 1 / (1 + 7.39) ≈ 0.12

x = 10 のとき：

σ(10) ≈ 0.9999（ほぼ1）

3-3. Pythonで実装してみよう

📝 コードの解説

import numpy as np

NumPy（数値計算ライブラリ）を読み込みます。expなどの数学関数が使えます。

def sigmoid(x):

「sigmoid」という名前の関数を定義します。xは入力値です。

return 1 / (1 + np.exp(-x))

シグモイド関数の計算式そのものです。
np.exp(-x)は e^-x を計算します。

import numpy as np

def sigmoid(x):
    “””シグモイド関数”””
    return 1 / (1 + np.exp(-x))

# いろいろな値で試してみる
print(f”sigmoid(0) = {sigmoid(0):.4f}”)      # 中心
print(f”sigmoid(1) = {sigmoid(1):.4f}”)      # 正の値
print(f”sigmoid(-1) = {sigmoid(-1):.4f}”)    # 負の値
print(f”sigmoid(5) = {sigmoid(5):.4f}”)      # 大きい正の値
print(f”sigmoid(-5) = {sigmoid(-5):.4f}”)    # 大きい負の値
print(f”sigmoid(10) = {sigmoid(10):.6f}”)    # 非常に大きい正の値

実行結果：

sigmoid(0) = 0.5000
sigmoid(1) = 0.7311
sigmoid(-1) = 0.2689
sigmoid(5) = 0.9933
sigmoid(-5) = 0.0067
sigmoid(10) = 0.999955

3-4. シグモイド関数のメリットとデメリット

メリット ✅	デメリット ❌
なめらかで微分可能	勾配消失問題がある
出力が0〜1（確率として解釈可能）	出力が0中心でない
古典的で理解しやすい	計算コストが高い（exp計算）

3-5. 勾配消失問題とは？

⚠️ 勾配消失問題（Vanishing Gradient Problem）

シグモイド関数の最大の問題点は、入力の絶対値が大きいと勾配がほぼ0になることです。

【シグモイド関数の勾配（微分値）】

入力    出力        勾配（傾き）
────    ────        ──────────
x=-10   ≈ 0.00      ≈ 0.00     ← 勾配がほぼ0！
x=-5    ≈ 0.01      ≈ 0.01
x=0     = 0.50      = 0.25     ← 最大（でも0.25しかない）
x=5     ≈ 0.99      ≈ 0.01
x=10    ≈ 1.00      ≈ 0.00     ← 勾配がほぼ0！

💡 なぜ勾配消失が問題なのか？

ニューラルネットワークの学習では、誤差逆伝播法を使って重みを更新します。
このとき、勾配（傾き）を層から層へ掛け算で伝えていきます。

深い層への勾配 = 勾配₁ × 勾配₂ × 勾配₃ × …

もし各層の勾配が0.1だとすると：

5層後: 0.1 × 0.1 × 0.1 × 0.1 × 0.1 = 0.00001

→ 勾配が消えてしまい、浅い層の重みが更新されない！
→ 深いネットワークの学習が困難になる！

📉 4. tanh関数（ハイパボリックタンジェント）

4-1. tanh関数とは？

tanh関数（ハイパボリックタンジェント）は、シグモイド関数を-1〜1の範囲に拡張したものです。

📐 tanh関数の定義

tanh(x) = (e^x – e^-x) / (e^x + e^-x)

または、シグモイド関数を使って表すと：

tanh(x) = 2・sigmoid(2x) – 1

出力範囲：-1 〜 1

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

【tanh関数のグラフ】

出力
  1 ┤                    ╭━━━━━━
    │                 ╱
    │              ╱
  0 ┤━━━━━━━━━╱━━━━━━━━━━→ 入力
    │          ╱
    │       ╱
 -1 ┤━━━━━━╯
    │
    └──────────┼──────────
              0

特徴：
・出力は-1〜1の連続的な値
・x=0のとき、出力は0（ゼロ中心）
・シグモイドより勾配が大きい

4-2. Pythonで実装

import numpy as np

def tanh(x):
    “””tanh関数（NumPyの組み込み関数を使用）”””
    return np.tanh(x)

# いろいろな値で試してみる
print(f”tanh(0) = {tanh(0):.4f}”)      # 中心
print(f”tanh(1) = {tanh(1):.4f}”)      # 正の値
print(f”tanh(-1) = {tanh(-1):.4f}”)    # 負の値
print(f”tanh(2) = {tanh(2):.4f}”)      # 大きい正の値
print(f”tanh(-2) = {tanh(-2):.4f}”)    # 大きい負の値

実行結果：

tanh(0) = 0.0000
tanh(1) = 0.7616
tanh(-1) = -0.7616
tanh(2) = 0.9640
tanh(-2) = -0.9640

4-3. シグモイドとtanhの比較

項目	シグモイド	tanh
出力範囲	0 〜 1	-1 〜 1
中心値	0.5	0（ゼロ中心）✅
勾配消失	あり	あり（やや軽減）
主な用途	出力層（二値分類）	隠れ層（RNN内部）

💡 tanhの利点：ゼロ中心（Zero-centered）

tanhは出力が0を中心に分布するため、次の層への入力も0を中心とした値になります。
これにより、学習が安定し、収束が速くなります。

シグモイドは出力が常に正（0〜1）なので、次の層への入力が偏ってしまいます。

⚡ 5. ReLU（Rectified Linear Unit）

5-1. ReLUとは？

ReLU（Rectified Linear Unit）は、現在最も人気のある活性化関数です。
2012年のAlexNetの成功以降、ディープラーニングの標準となりました。

📐 ReLU関数の定義

ReLU(x) = max(0, x)

つまり：
・x > 0 のとき → xをそのまま出力
・x ≤ 0 のとき → 0を出力

出力範囲：0 〜 ∞（上限なし）

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

【ReLU関数のグラフ】

出力
  3 ┤                        ╱
    │                      ╱
  2 ┤                    ╱
    │                  ╱
  1 ┤                ╱
    │              ╱
  0 ┤━━━━━━━━━━━━╱━━━━━━━━━→ 入力
    │
    └──────────┼──────────
              0

特徴：
・負の入力 → 0
・正の入力 → そのまま
・計算が超シンプル！（max関数のみ）

5-2. ReLUの計算例

📊 具体的な計算例

ReLU(-5) = max(0, -5) = 0
ReLU(-1) = max(0, -1) = 0
ReLU(0) = max(0, 0) = 0
ReLU(1) = max(0, 1) = 1
ReLU(5) = max(0, 5) = 5
ReLU(100) = max(0, 100) = 100

→ 負の値は0に、正の値はそのまま！

5-3. Pythonで実装

📝 コードの解説

np.maximum(0, x)

0とxを比較して、大きい方を返します。
これだけでReLUが実装できます！非常にシンプルです。

import numpy as np

def relu(x):
    “””ReLU関数”””
    return np.maximum(0, x)

# いろいろな値で試してみる
print(f”ReLU(-5) = {relu(-5)}”)
print(f”ReLU(-1) = {relu(-1)}”)
print(f”ReLU(0) = {relu(0)}”)
print(f”ReLU(1) = {relu(1)}”)
print(f”ReLU(5) = {relu(5)}”)

# 配列でも使える
x = np.array([-3, -1, 0, 1, 3])
print(f”\nReLU({x}) = {relu(x)}”)

実行結果：

ReLU(-5) = 0
ReLU(-1) = 0
ReLU(0) = 0
ReLU(1) = 1
ReLU(5) = 5

ReLU([-3 -1  0  1  3]) = [0 0 0 1 3]

5-4. なぜReLUが人気なのか？

メリット ✅	デメリット ❌
計算が超高速（max関数のみ）	Dying ReLU問題
勾配消失問題を解決（正の領域で勾配=1）	負の入力で勾配が0
スパース性（多くのニューロンが0を出力）	出力が0中心でない
深いネットワークで効果的	–

📊 計算速度の比較

シグモイド：1 / (1 + exp(-x)) → 割り算、足し算、指数関数
tanh：(exp(x) – exp(-x)) / (exp(x) + exp(-x)) → 指数関数×4、割り算
ReLU：max(0, x) → 比較のみ！

→ ReLUはシグモイドの10倍以上速いと言われています

5-5. Dying ReLU問題

⚠️ Dying ReLU問題とは？

ReLUには「死んだニューロン（Dead Neuron）」が発生する問題があります。

【Dying ReLU問題の発生メカニズム】

1. 重みの更新により、ニューロンへの入力が常に負になる

2. ReLU(負の値) = 0 が常に出力される

3. 出力が0なので、このニューロンからの勾配も0

4. 勾配が0なので、重みが更新されない

5. 永遠に「死んだ」状態が続く 💀

【どれくらい発生するか？】
・大きな学習率を使うと発生しやすい
・一般的に10〜40%のニューロンが「死ぬ」ことがある

🎯 迷ったらReLUを使う！

Dying ReLU問題はあるものの、それを補って余りある利点があります。
隠れ層の活性化関数で迷ったら、まずReLUを使うのが定石です。
問題が発生したら、次に紹介する改良版を試しましょう。

🔧 6. ReLUの改良版

Dying ReLU問題を解決するために、いくつかの改良版が提案されています。

6-1. Leaky ReLU（リーキーレル）

📐 Leaky ReLUの定義

Leaky ReLU(x) = x （x > 0 のとき）
Leaky ReLU(x) = 0.01 × x （x ≤ 0 のとき）

ポイント：負の領域でもわずかな傾き（0.01）を持たせる
→ 「少し漏れる（Leaky）」という意味

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

【Leaky ReLUのグラフ】

出力
  2 ┤                    ╱
    │                  ╱
  1 ┤                ╱
    │              ╱
  0 ┤════════════╱═══════→ 入力
    │          ╱
    │        ╱   ← 負の領域でも小さな傾き（0.01）がある
-0.1┤      ╱
    └──────┼──────────
          0

→ 負の入力でも勾配が0にならない！
→ Dying ReLU問題を軽減

import numpy as np

def leaky_relu(x, alpha=0.01):
    “””Leaky ReLU関数”””
    return np.where(x > 0, x, alpha * x)

# 比較
print(“=== ReLUとLeaky ReLUの比較 ===”)
print(f”ReLU(-2) = {relu(-2)}”)
print(f”Leaky ReLU(-2) = {leaky_relu(-2)}”)
print()
print(f”ReLU(-10) = {relu(-10)}”)
print(f”Leaky ReLU(-10) = {leaky_relu(-10)}”)

実行結果：

=== ReLUとLeaky ReLUの比較 ===
ReLU(-2) = 0
Leaky ReLU(-2) = -0.02

ReLU(-10) = 0
Leaky ReLU(-10) = -0.1

6-2. ELU（Exponential Linear Unit）

📐 ELUの定義

ELU(x) = x （x > 0 のとき）
ELU(x) = α × (e^x – 1) （x ≤ 0 のとき）

特徴：
・負の領域でなめらかな曲線を描く
・平均出力が0に近づく（ゼロ中心に近い）
・Leaky ReLUより高性能な場合が多い

import numpy as np

def elu(x, alpha=1.0):
    “””ELU関数”””
    return np.where(x > 0, x, alpha * (np.exp(x) – 1))

print(“=== ELUの出力 ===”)
print(f”ELU(-2) = {elu(-2):.4f}”)
print(f”ELU(-1) = {elu(-1):.4f}”)
print(f”ELU(0) = {elu(0):.4f}”)
print(f”ELU(1) = {elu(1):.4f}”)
print(f”ELU(2) = {elu(2):.4f}”)

実行結果：

=== ELUの出力 ===
ELU(-2) = -0.8647
ELU(-1) = -0.6321
ELU(0) = 0.0000
ELU(1) = 1.0000
ELU(2) = 2.0000

6-3. 活性化関数の比較表

関数	出力範囲	計算速度	勾配消失	主な用途
Sigmoid	0 〜 1	遅い	あり	出力層（二値分類）
tanh	-1 〜 1	遅い	あり	RNN（隠れ層）
ReLU	0 〜 ∞	速い ⭐	なし ⭐	隠れ層（デフォルト）
Leaky ReLU	-∞ 〜 ∞	速い	なし	ReLU改良
ELU	-α 〜 ∞	やや遅い	なし	高性能が必要

🎲 7. Softmax関数

7-1. Softmaxとは？

Softmax関数は、多クラス分類の出力層で使われる特殊な活性化関数です。
複数の出力を「確率分布」に変換します。

📐 Softmax関数の定義

Softmax(x_i) = e^x_i / Σ(e^x_j)

特徴：

すべての出力の合計が1になる
各出力を確率として解釈できる
最も大きい入力に対応する出力が最も大きくなる

7-2. Softmaxの動作を理解する

🐱 具体例：画像が「猫」「犬」「鳥」のどれか？

ステップ1：ニューラルネットワークの生の出力

猫のスコア: 2.5
犬のスコア: 1.2
鳥のスコア: 0.3

→ このままでは「どれくらい自信があるか」がわかりにくい

ステップ2：Softmaxを適用

猫の確率: 0.76（76%）
犬の確率: 0.20（20%）
鳥の確率: 0.04（4%）
合計: 1.00（100%）

→ 確率として解釈できる！「76%の自信で猫」

7-3. Pythonで実装

📝 コードの解説

c = np.max(x)

入力の最大値を取得。オーバーフロー対策のために使用。
（e¹⁰⁰⁰などの巨大な数を避けるため）

exp_x = np.exp(x – c)

各要素から最大値を引いてからexp。これでオーバーフローを防ぐ。

sum_exp_x = np.sum(exp_x)

expの合計を計算。

y = exp_x / sum_exp_x

各要素を合計で割って、合計が1になるようにする。

import numpy as np

def softmax(x):
    “””Softmax関数（オーバーフロー対策付き）”””
    c = np.max(x)           # 最大値を取得（オーバーフロー対策）
    exp_x = np.exp(x – c)   # 最大値を引いてからexp
    sum_exp_x = np.sum(exp_x)
    y = exp_x / sum_exp_x
    return y

# 3クラス分類の例（猫、犬、鳥）
scores = np.array([2.5, 1.2, 0.3])
probabilities = softmax(scores)

print(“=== Softmaxの動作 ===”)
print(f”入力スコア: {scores}”)
print(f”Softmax出力: {probabilities}”)
print(f”合計: {np.sum(probabilities):.4f}”)
print()
print(“=== 解釈 ===”)
labels = [“猫”, “犬”, “鳥”]
for label, prob in zip(labels, probabilities):
    print(f”{label}: {prob:.1%}”)

print(f”\n予測: {labels[np.argmax(probabilities)]}”)

実行結果：

=== Softmaxの動作 ===
入力スコア: [2.5 1.2 0.3]
Softmax出力: [0.75858099 0.20664137 0.03477764]
合計: 1.0000

=== 解釈 ===
猫: 75.9%
犬: 20.7%
鳥: 3.5%

予測: 猫

💡 Softmaxの使いどころ

多クラス分類の出力層で使用（3クラス以上）
二値分類（2クラス）の場合はSigmoidを使用
回帰問題では使わない（活性化関数なしで線形出力）

🎯 8. 活性化関数の選び方

8-1. 隠れ層の活性化関数

🧭 隠れ層の選択ガイド

基本：ReLU

迷ったらReLUを使う！ほとんどの場合でうまく機能します。

Dying ReLU問題が発生したら：Leaky ReLU または ELU

多くのニューロンが0を出力し続ける場合に試す。

RNN（LSTM/GRU）の内部：tanh

RNNの内部構造ではtanhが使われることが多い（ゼロ中心のため）。

8-2. 出力層の活性化関数

🧭 出力層の選択ガイド（問題タイプ別）

二値分類（2クラス）：Sigmoid

例：スパム判定（スパム or 非スパム）、病気診断（陽性 or 陰性）
出力：0〜1の値（確率として解釈）

多クラス分類（3クラス以上）：Softmax

例：画像分類（猫 or 犬 or 鳥 or …）、手書き数字認識（0〜9）
出力：各クラスの確率（合計1）

回帰：活性化関数なし（恒等関数）

例：株価予測、温度予測
出力：任意の実数値

8-3. まとめチャート

【活性化関数の選択チャート】

┌─────────────────────────────────────────────┐
│ Q1: どの層で使う？                          │
└────────────────┬────────────────────────────┘
                 │
    ┌────────────┼────────────┐
    ↓            ↓            ↓
 隠れ層        出力層        出力層
                (分類)        (回帰)
    │            │            │
    ↓            ↓            ↓
  ReLU      Q2:何クラス？   活性化関数なし
 (基本)          │           (線形出力)
                 │
        ┌────────┴────────┐
        ↓                 ↓
     2クラス          3クラス以上
        ↓                 ↓
    Sigmoid           Softmax

🎨 実例：画像分類（CNN）の場合

入力層 → [ReLU] → [ReLU] → [ReLU] → [Softmax] → 出力
　　　　　 ↑ ↑ ↑ ↑
　　　　　隠れ層隠れ層隠れ層出力層

隠れ層はすべてReLU、出力層はSoftmax（多クラス分類）

📝 STEP 4 のまとめ

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

活性化関数は、ニューラルネットワークに非線形性を与える重要な関数
Sigmoidは0〜1の出力、tanhは-1〜1の出力
ReLUは現在最も人気があり、隠れ層のデフォルト選択
Leaky ReLU、ELUはReLUの改良版で、Dying ReLU問題を解決
Softmaxは多クラス分類の出力層で使用（確率分布に変換）
勾配消失問題はSigmoid/tanhで発生、ReLUで解決

💡 覚えておきたいポイント

活性化関数の選択は、ニューラルネットワークの性能を大きく左右します。

基本ルール：
・隠れ層 → ReLU
・出力層 → 問題に応じて（二値分類=Sigmoid、多クラス=Softmax、回帰=なし）

次のSTEP 5では、損失関数を学び、
ニューラルネットワークが「何を学習するか」を理解しましょう！

📝 練習問題

問題1 やさしい

活性化関数の役割

活性化関数がない場合、どうなりますか？最も適切なものを選んでください。

A. ニューラルネットワークが全く学習できなくなる
B. どんなに層を重ねても線形変換にしかならない
C. 計算速度が劇的に向上する
D. 精度が大幅に向上する

正解：B

なぜBが正解なのか？

活性化関数がないと、各層の計算は単純な行列の掛け算になります。
行列の掛け算を何回繰り返しても、結果は1つの行列との掛け算と同じです。

y = W₃ × W₂ × W₁ × x
  = (W₃ × W₂ × W₁) × x
  = W × x

→ 結局、1層のネットワークと同じ！
→ XORのような非線形問題は解けない

他の選択肢の解説：

Aが不正確な理由：学習自体は可能ですが、表現力が線形に限られるため、複雑な問題は解けません。

C、Dが間違いの理由：活性化関数がないことは計算上はシンプルですが、これはメリットではなくデメリットです。非線形な問題が解けなくなります。

問題2 やさしい

ReLU関数の計算

ReLU(-3)、ReLU(0)、ReLU(5)の値はそれぞれいくつですか？

A. -3, 0, 5
B. 0, 0, 5
C. -3, 0, 0
D. 0, 1, 5

正解：B

ReLUの計算方法

ReLU(x) = max(0, x) なので、0とxを比較して大きい方を返します。

ReLU(-3) = max(0, -3) = 0   ← 0の方が大きい
ReLU(0) = max(0, 0) = 0     ← 同じなので0
ReLU(5) = max(0, 5) = 5     ← 5の方が大きい

ReLUの覚え方：

負の値 → 0を出力（切り捨て）
0 → 0を出力
正の値 → そのまま出力

他の選択肢の解説：

Aが間違い：負の値をそのまま出力するのはLeaky ReLUの特徴です。ReLUは負の値を0にします。

Dが間違い：ReLU(0)は0です。1にはなりません。ステップ関数と混同しないように注意。

問題3 ふつう

活性化関数の選択

画像を「猫」「犬」「鳥」の3クラスに分類する問題で、
出力層の活性化関数として最も適切なものを選んでください。

A. ReLU
B. Sigmoid
C. Softmax
D. 活性化関数なし

正解：C

なぜSoftmaxなのか？

3クラス以上の多クラス分類では、Softmaxを使います。

Softmaxの特徴：

出力の合計が1になる（確率分布）
各クラスの確率として解釈できる
例：猫70%、犬20%、鳥10% → 合計100%

他の選択肢の解説：

Aが間違い：ReLUは隠れ層で使用します。出力層には使いません。

Bが間違い：Sigmoidは二値分類（2クラス）で使用します。
例：スパム判定（スパム or 非スパム）、病気診断（陽性 or 陰性）

Dが間違い：活性化関数なし（線形出力）は回帰問題で使用します。
例：株価予測、温度予測

覚え方：

二値分類（2クラス）→ Sigmoid
多クラス分類（3クラス以上）→ Softmax
回帰 → 活性化関数なし

問題4 むずかしい

勾配消失問題

次のうち、勾配消失問題が起こりやすい活性化関数を選んでください。

A. ReLU
B. Leaky ReLU
C. Sigmoid
D. ELU

正解：C

勾配消失問題とは？

深いネットワークで、勾配（傾き）が層を伝わるうちにどんどん小さくなり、ほぼ0になってしまう問題です。
勾配が0になると、重みが更新されず、学習が進みません。

なぜSigmoidで起こるのか？

【Sigmoidの勾配の特徴】

・入力が0付近のとき：勾配 ≈ 0.25（最大）
・入力の絶対値が大きいとき：勾配 ≈ 0

【深いネットワークでの問題】

5層のネットワークで、各層の勾配が0.1だとすると：

浅い層への勾配 = 0.1 × 0.1 × 0.1 × 0.1 × 0.1
              = 0.00001

→ 勾配がほぼ消失！
→ 浅い層の重みが更新されない！

他の選択肢の解説：

A、B、DはReLU系の活性化関数です。
これらは正の領域で勾配が1なので、勾配消失問題が起こりにくいです。

【ReLU系の勾配】

・正の入力：勾配 = 1（常に1！消えない）
・負の入力：勾配 = 0（ReLU）または小さな値（Leaky ReLU、ELU）

重要な学び：

これがReLUが人気の最大の理由です。
ReLUの登場により、深いネットワーク（ディープラーニング）の学習が実用的になりました！

📝

学習メモ

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

📋 過去のメモ一覧 ▼