Leaky ReLU（リーキーReLU）とは？ニューラルネットワークを改善する活性化関数を徹底解説

ディープラーニング（深層学習）でニューラルネットワークを作るとき、活性化関数という重要な要素があります。

その中でもReLU（Rectified Linear Unit）は、シンプルで高速なため、現在最も人気のある活性化関数です。でも、ReLUには致命的な弱点があるんです。

それが「Dying ReLU問題」

学習中に一部のニューロン（神経細胞のようなもの）が完全に機能しなくなり、「死んでしまう」現象が起きることがあります。

そこで登場したのがLeaky ReLU（リーキーReLU）です。

Leaky ReLUは、ReLUの弱点を改善した活性化関数で、ニューロンが死なないように工夫されています。この記事では、Leaky ReLUの仕組みや使い方について、初心者の方にも分かるように詳しく解説していきます。

スポンサーリンク

活性化関数とは？基礎から理解する

ニューラルネットワークの基本

まず、ニューラルネットワークの仕組みを簡単におさらいしましょう。

ニューロン（ノード）の計算：

入力 → 重み付き和 → 活性化関数 → 出力

ステップ1：重み付き和を計算

z = w₁x₁ + w₂x₂ + w₃x₃ + ... + b

各入力に重みをかけて合計し、バイアスを加えます。

ステップ2：活性化関数を適用

出力 = f(z)

計算結果zに活性化関数を適用して、最終的な出力を得ます。

活性化関数の役割

なぜ活性化関数が必要なのか？

活性化関数がないと、ニューラルネットワークは単なる線形変換（掛け算と足し算）の繰り返しになってしまいます。

活性化関数がない場合：

  • どれだけ層を深くしても、単純な線形変換にしかならない
  • 複雑なパターンを学習できない
  • 「深層」学習の意味がなくなる

活性化関数がある場合：

  • 非線形性を導入できる
  • 複雑な関数を近似できる
  • 画像認識や自然言語処理などの難しい問題を解決できる

つまり、活性化関数は「賢さ」を生み出す重要な要素なんです。

主な活性化関数

代表的な活性化関数：

1. シグモイド関数

f(x) = 1 / (1 + e^(-x))
  • 出力が0から1の範囲
  • 古くから使われている
  • 勾配消失問題がある

2. tanh（双曲線正接）

f(x) = tanh(x)
  • 出力が-1から1の範囲
  • シグモイドより性能が良い
  • 勾配消失問題がある

3. ReLU（Rectified Linear Unit）

f(x) = max(0, x)
  • 現在最も人気
  • 計算が高速
  • Dying ReLU問題がある

4. Leaky ReLU（本記事のテーマ）

f(x) = max(αx, x)  (αは小さな定数、通常0.01)
  • ReLUの改良版
  • Dying ReLU問題を解決

ReLUとその問題点

Leaky ReLUを理解するには、まずReLUを知る必要があります。

ReLUの仕組み

ReLU（Rectified Linear Unit）は、非常にシンプルな活性化関数です。

数式：

f(x) = max(0, x)

動作：

  • xが正の値 → そのまま出力
  • xが負の値 → 0を出力

グラフ：

出力
  |
  |      /
  |     /
  |    /
  |   /
  |__/_________ 入力
  0

負の値はすべて0になり、正の値はそのまま通過します。

ReLUの利点

ReLUが人気な理由は、たくさんあります。

1. 計算が超高速

  • max(0, x)という単純な比較だけ
  • 複雑な指数関数や三角関数が不要
  • GPUで並列処理しやすい

2. 勾配消失問題を軽減

  • シグモイドやtanhと違い、正の領域では勾配が1
  • 深いネットワークでも学習が進む

3. スパース性（疎性）

  • 約半分のニューロンが0を出力
  • 効率的な表現が可能

4. 生物学的な妥当性

  • 実際の脳神経細胞の動作に似ている

ReLUの致命的な問題：Dying ReLU

しかし、ReLUには深刻な弱点があります。

Dying ReLU問題とは？

学習中に一部のニューロンが完全に機能しなくなる現象です。

具体的に何が起こる？

  1. あるニューロンへの入力が常に負になる
  2. ReLUの出力は常に0
  3. 勾配も常に0になる
  4. 重みが更新されない
  5. ニューロンが「死んだ」状態になる

例：

入力が常に-5になるニューロン
↓
ReLU(-5) = 0  （常に0を出力）
↓
勾配 = 0      （学習できない）
↓
重みが永遠に更新されない
↓
ニューロンが死んだ！

どれくらい深刻？

研究によると、学習後のネットワークで40〜50%のニューロンが死んでいることもあります。つまり、半分のニューロンが無駄になっているんです。

なぜ起こる？

原因1：学習率が高すぎる

  • 重みの更新が大きすぎる
  • ニューロンの出力が負の領域に飛んでしまう

原因2：初期値が悪い

  • 重みの初期値が不適切
  • 最初から負の領域にいる

原因3：バッチの偏り

  • 特定のバッチで大きな勾配が発生
  • 重みが大きく動いて負の領域に行く

この問題を解決するために、Leaky ReLUが開発されました。

Leaky ReLU：解決策の登場

Leaky ReLUの仕組み

Leaky ReLU（リーキーReLU）は、ReLUの改良版です。

数式：

f(x) = max(αx, x)

または

f(x) = {
    x     (x > 0のとき)
    αx    (x ≤ 0のとき)
}

パラメータα：

  • 小さな正の定数（通常0.01）
  • 「リーク係数」や「負の勾配」と呼ばれる

動作：

  • xが正の値 → そのまま出力（ReLUと同じ）
  • xが負の値 → αxを出力（0ではなく、小さな負の値）

グラフ：

出力
  |
  |      /
  |     /
  |    /
  |   /
 /|__/_________ 入力
/  0

負の領域でもわずかに傾いているのがポイントです。

ReLUとの違い

ReLU：

f(-5) = 0
f(-2) = 0
f(0) = 0
f(2) = 2
f(5) = 5

Leaky ReLU（α=0.01の場合）：

f(-5) = -0.05   ← 負でも0にならない！
f(-2) = -0.02   ← 負でも0にならない！
f(0) = 0
f(2) = 2
f(5) = 5

負の値でも完全に0にならないので、勾配が流れ続けます。

なぜ「Leaky（漏れる）」？

「Leaky」は英語で「漏れる」という意味です。

ReLUでは負の値を完全に遮断していましたが、Leaky ReLUでは少しだけ漏れる（leak）ようにしています。

この「漏れ」が、ニューロンを生き続けさせる鍵なんです。

Dying ReLU問題の解決

Leaky ReLUの場合：

入力が-5になるニューロン
↓
Leaky ReLU(-5) = -0.05  （わずかに負の値を出力）
↓
勾配 = 0.01             （小さいけど勾配がある！）
↓
重みが少しずつ更新される
↓
ニューロンは生き続ける！

負の領域でも勾配が0にならないため、学習が止まりません。

Leaky ReLUの数学的な詳細

数式の表現

基本形：

f(x) = max(αx, x)

条件分岐での表現：

f(x) = {
    x     (x ≥ 0)
    αx    (x < 0)
}

統一的な表現：

f(x) = max(0, x) + α × min(0, x)

どの表現も同じ意味です。

αの値

典型的な値：

  • α = 0.01（最も一般的）
  • α = 0.001（より小さなリーク）
  • α = 0.1（やや大きなリーク）
  • α = 0.2（さらに大きなリーク）

α = 0の場合：
通常のReLUと同じになります。

αが大きい場合：
負の値の影響が強くなります。

導関数（勾配）

機械学習では、勾配が重要です。

Leaky ReLUの導関数：

f'(x) = {
    1     (x > 0)
    α     (x ≤ 0)
}

意味：

  • 正の領域：勾配は1
  • 負の領域：勾配はα（例：0.01）

ReLUの導関数（比較）：

f'(x) = {
    1     (x > 0)
    0     (x ≤ 0)  ← ここが問題！
}

Leaky ReLUは負の領域でも勾配が0にならないので、バックプロパゲーション（誤差逆伝播）で勾配が流れ続けます。

逆伝播の計算

ニューラルネットワークの学習では、勾配を逆向きに伝える必要があります。

順伝播（Forward）：

z = 重み付き和
a = Leaky_ReLU(z)

逆伝播（Backward）：

勾配 = 上流からの勾配 × Leaky_ReLU'(z)

if z > 0:
    勾配 = 上流からの勾配 × 1
else:
    勾配 = 上流からの勾配 × α

αが小さくても、勾配が0にならないことが重要です。

Leaky ReLUの実装

実際にプログラムで実装してみましょう。

Pythonでの基本実装

NumPyを使った実装：

import numpy as np

def leaky_relu(x, alpha=0.01):
    """
    Leaky ReLU活性化関数

    引数:
        x: 入力（スカラーまたは配列）
        alpha: リーク係数（デフォルト: 0.01）

    戻り値:
        活性化後の値
    """
    return np.maximum(alpha * x, x)

# 使用例
x = np.array([-2, -1, 0, 1, 2])
output = leaky_relu(x)
print(f"入力: {x}")
print(f"出力: {output}")
# 出力: [-0.02 -0.01  0.    1.    2.  ]

導関数の実装：

def leaky_relu_derivative(x, alpha=0.01):
    """
    Leaky ReLUの導関数

    引数:
        x: 入力
        alpha: リーク係数

    戻り値:
        導関数の値
    """
    grad = np.ones_like(x)
    grad[x < 0] = alpha
    return grad

# 使用例
x = np.array([-2, -1, 0, 1, 2])
grad = leaky_relu_derivative(x)
print(f"入力: {x}")
print(f"勾配: {grad}")
# 出力: [0.01 0.01 1.   1.   1.  ]

TensorFlow / Kerasでの使用

Keras（TensorFlow 2.x）での実装：

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# モデルの構築
model = keras.Sequential([
    layers.Dense(128, input_shape=(784,)),
    layers.LeakyReLU(alpha=0.01),  # Leaky ReLU層

    layers.Dense(64),
    layers.LeakyReLU(alpha=0.01),

    layers.Dense(10),
    layers.Softmax()
])

model.summary()

関数として使う：

import tensorflow as tf

x = tf.constant([-2.0, -1.0, 0.0, 1.0, 2.0])
output = tf.nn.leaky_relu(x, alpha=0.01)

print(output.numpy())
# [-0.02 -0.01  0.    1.    2.  ]

PyTorchでの使用

PyTorchでの実装：

import torch
import torch.nn as nn

# モデルの構築
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.leaky_relu1 = nn.LeakyReLU(negative_slope=0.01)

        self.fc2 = nn.Linear(128, 64)
        self.leaky_relu2 = nn.LeakyReLU(negative_slope=0.01)

        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.leaky_relu1(x)

        x = self.fc2(x)
        x = self.leaky_relu2(x)

        x = self.fc3(x)
        return x

model = MyModel()

関数として使う：

import torch
import torch.nn.functional as F

x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
output = F.leaky_relu(x, negative_slope=0.01)

print(output)
# tensor([-0.0200, -0.0100,  0.0000,  1.0000,  2.0000])

可視化

Leaky ReLUの動作を可視化してみましょう。

import numpy as np
import matplotlib.pyplot as plt

# 入力の範囲
x = np.linspace(-5, 5, 100)

# ReLU
relu = np.maximum(0, x)

# Leaky ReLU（α=0.01）
leaky_relu_01 = np.maximum(0.01 * x, x)

# Leaky ReLU（α=0.2）
leaky_relu_02 = np.maximum(0.2 * x, x)

# プロット
plt.figure(figsize=(10, 6))
plt.plot(x, relu, label='ReLU', linewidth=2)
plt.plot(x, leaky_relu_01, label='Leaky ReLU (α=0.01)', linewidth=2)
plt.plot(x, leaky_relu_02, label='Leaky ReLU (α=0.2)', linewidth=2)

plt.xlabel('入力 x', fontsize=12)
plt.ylabel('出力 f(x)', fontsize=12)
plt.title('活性化関数の比較', fontsize=14)
plt.legend(fontsize=10)
plt.grid(True, alpha=0.3)
plt.axhline(y=0, color='k', linewidth=0.5)
plt.axvline(x=0, color='k', linewidth=0.5)

plt.tight_layout()
plt.show()

このグラフを見ると、Leaky ReLUが負の領域でも傾いていることが分かります。

Leaky ReLUのメリット

1. Dying ReLU問題の解決

最大のメリット

ニューロンが死ななくなります。

効果：

  • すべてのニューロンが学習に参加できる
  • ネットワークの表現力を最大限に活用
  • 学習の安定性が向上

2. 学習の高速化

勾配の流れが良い

負の領域でも勾配が流れるため、学習が速く進みます。

特に効果的な場面：

  • 深いネットワーク
  • 複雑なタスク
  • データが偏っている場合

3. ReLUとほぼ同じ計算コスト

実装がシンプル

ReLUに比べて、ほんのわずかな計算が増えるだけです。

# ReLU
output = max(0, x)

# Leaky ReLU
output = max(0.01 * x, x)

計算コストの増加はごくわずかです。

4. 汎用性が高い

様々なタスクで有効

  • 画像認識
  • 自然言語処理
  • 音声認識
  • 時系列予測

どの分野でもReLUの代わりに使えます。

5. 実装が容易

主要なフレームワークで標準サポート

  • TensorFlow / Keras
  • PyTorch
  • Chainer
  • MXNet

すぐに使えます。

Leaky ReLUのデメリット

良いことばかりではありません。いくつかの課題もあります。

1. ハイパーパラメータαの選択

問題：
αの値をどう決めるか悩む

典型的な値：

  • 0.01（最も一般的）
  • 0.001〜0.3の範囲で実験

対策：

  • デフォルトの0.01から始める
  • 必要に応じてハイパーパラメータ探索

2. 理論的な根拠が弱い

問題：
「なぜα=0.01が良いのか」の理論的説明が不十分

実情：

  • 経験的に良い結果が出ることが分かっている
  • 数学的な最適性の保証はない

3. 常にReLUより良いわけではない

問題：
場合によってはReLUの方が性能が良いことも

理由：

  • タスクやデータによる
  • スパース性がReLUの方が高い

対策：

  • 両方試して比較する
  • クロスバリデーションで評価

4. 負の出力値

問題：
出力が負になることがある

影響：

  • 一部の応用では負の値が問題になる可能性
  • ただし、ほとんどの場合は問題ない

他の活性化関数との比較

Leaky ReLU以外にも、様々な活性化関数があります。

PReLU（Parametric ReLU）

PReLUとは？

Leaky ReLUのαを学習可能なパラメータにしたものです。

数式：

f(x) = max(αx, x)

ただし、αは学習で最適化される

メリット：

  • データに応じて最適なαが自動的に決まる
  • Leaky ReLUより柔軟

デメリット：

  • パラメータ数が増える
  • 過学習のリスクがわずかに増加

PyTorchでの使用：

import torch.nn as nn

layer = nn.PReLU(init=0.25)  # αの初期値

ELU（Exponential Linear Unit）

ELUとは？

負の領域で指数関数を使う活性化関数です。

数式：

f(x) = {
    x                 (x > 0)
    α(e^x - 1)        (x ≤ 0)
}

特徴：

  • 負の領域が滑らか
  • 平均がほぼ0に近づく
  • 学習が速い

デメリット：

  • 指数関数の計算コストが高い

使用例：

import tensorflow as tf

output = tf.nn.elu(x, alpha=1.0)

SELU（Scaled ELU）

SELUとは？

ELUをスケーリングした活性化関数です。

特徴：

  • 自己正規化の性質を持つ
  • 深いネットワークで効果的
  • 特定の初期化と組み合わせて使う

RReLU（Randomized ReLU）

RReLUとは？

学習時にαをランダムに選ぶ活性化関数です。

特徴：

  • 正則化効果がある
  • 過学習を防ぐ

Swish / SiLU

Swishとは？

GoogleのAutoMLで発見された活性化関数です。

数式：

f(x) = x × sigmoid(x)

特徴：

  • 滑らかで微分可能
  • 一部のタスクでReLUより高性能

比較表

活性化関数負の領域計算コスト学習速度Dying問題
ReLU0低速いあり
Leaky ReLUαx低速いなし
PReLUαx（学習）低速いなし
ELUα(e^x-1)中とても速いなし
SELUスケール版ELU中とても速いなし
Swishx×sigmoid(x)高速いなし

実践的な使い方とヒント

いつLeaky ReLUを使うべきか？

Leaky ReLUが特に有効な場合：

1. 深いネットワーク

  • 層数が多い（10層以上）
  • 勾配の流れが重要

2. Dying ReLU問題が発生

  • ReLUで学習がうまくいかない
  • ニューロンの死亡率が高い

3. 学習が不安定

  • 損失関数が振動する
  • 収束が遅い

4. 小さなデータセット

  • データ数が少ない
  • 過学習しやすい状況

ReLUで十分な場合：

  • 浅いネットワーク（数層程度）
  • データが十分にある
  • すでにReLUで良い結果が出ている

α値の選び方

デフォルト値から始める：

alpha = 0.01  # 最も一般的

調整が必要な場合：

α=0.001（小さなリーク）：

  • ReLUに近い動作
  • スパース性を保ちたい場合

α=0.1〜0.3（大きなリーク）：

  • 負の値の影響を大きくしたい
  • 特定のタスクで有効な場合がある

ハイパーパラメータ探索：

alpha_values = [0.001, 0.01, 0.1, 0.2, 0.3]

for alpha in alpha_values:
    model = build_model(alpha=alpha)
    score = evaluate(model)
    print(f"α={alpha}: スコア={score}")

他の技術との組み合わせ

Batch Normalization

Batch NormalizationとLeaky ReLUを組み合わせると、効果的です。

import tensorflow as tf
from tensorflow.keras import layers

model = tf.keras.Sequential([
    layers.Dense(128),
    layers.BatchNormalization(),  # 正規化
    layers.LeakyReLU(alpha=0.01),  # 活性化

    layers.Dense(64),
    layers.BatchNormalization(),
    layers.LeakyReLU(alpha=0.01),
])

順序の推奨：

Dense → BatchNorm → LeakyReLU

Dropout

Dropoutと組み合わせて過学習を防ぎます。

model = tf.keras.Sequential([
    layers.Dense(128),
    layers.LeakyReLU(alpha=0.01),
    layers.Dropout(0.5),  # 50%のニューロンをドロップ

    layers.Dense(64),
    layers.LeakyReLU(alpha=0.01),
    layers.Dropout(0.3),
])

初期化の重要性

Leaky ReLUを使う場合、重みの初期化も重要です。

He初期化（Heの初期化）：

ReLU系の活性化関数には、He初期化が推奨されます。

from tensorflow.keras import layers, initializers

layer = layers.Dense(
    128,
    kernel_initializer=initializers.HeNormal()
)

数式：

重み ∼ N(0, sqrt(2 / n_in))

n_in: 入力ユニット数

デバッグのヒント

学習がうまくいかない場合：

1. 勾配の確認

# TensorFlowの場合
@tf.function
def check_gradients(x, y):
    with tf.GradientTape() as tape:
        predictions = model(x, training=True)
        loss = loss_fn(y, predictions)

    gradients = tape.gradient(loss, model.trainable_variables)

    for var, grad in zip(model.trainable_variables, gradients):
        if grad is not None:
            print(f"{var.name}: 勾配の範囲 [{tf.reduce_min(grad):.6f}, {tf.reduce_max(grad):.6f}]")

2. 活性化の分布を確認

# 各層の出力をチェック
activations = get_layer_outputs(model, x)
for i, act in enumerate(activations):
    print(f"層{i}: 平均={act.mean():.4f}, 標準偏差={act.std():.4f}")

3. Dying ReLU問題の確認

def count_dead_neurons(model, x):
    """死んだニューロンの数を数える"""
    activations = get_layer_outputs(model, x)

    for i, act in enumerate(activations):
        dead = (act == 0).all(axis=0).sum()
        total = act.shape[1]
        ratio = dead / total * 100
        print(f"層{i}: {dead}/{total} ({ratio:.1f}%) のニューロンが死んでいます")

実例：MNISTでの性能比較

実際にLeaky ReLUの効果を確認してみましょう。

実験設定

データセット：
MNIST（手書き数字認識）

比較する活性化関数：

  1. ReLU
  2. Leaky ReLU（α=0.01）
  3. Leaky ReLU（α=0.1）

コード例

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib.pyplot as plt

# データの準備
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 784).astype('float32') / 255
x_test = x_test.reshape(-1, 784).astype('float32') / 255

def create_model(activation='relu', alpha=0.01):
    """
    モデルを作成する関数

    引数:
        activation: 'relu' または 'leaky_relu'
        alpha: Leaky ReLUのαパラメータ
    """
    model = keras.Sequential([
        layers.Dense(512, input_shape=(784,), kernel_initializer='he_normal'),
        layers.LeakyReLU(alpha=alpha) if activation == 'leaky_relu' else layers.ReLU(),
        layers.Dropout(0.2),

        layers.Dense(256, kernel_initializer='he_normal'),
        layers.LeakyReLU(alpha=alpha) if activation == 'leaky_relu' else layers.ReLU(),
        layers.Dropout(0.2),

        layers.Dense(128, kernel_initializer='he_normal'),
        layers.LeakyReLU(alpha=alpha) if activation == 'leaky_relu' else layers.ReLU(),

        layers.Dense(10, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

# 各モデルを訓練
models = {
    'ReLU': create_model('relu'),
    'Leaky ReLU (α=0.01)': create_model('leaky_relu', alpha=0.01),
    'Leaky ReLU (α=0.1)': create_model('leaky_relu', alpha=0.1)
}

histories = {}

for name, model in models.items():
    print(f"\n{'='*50}")
    print(f"訓練: {name}")
    print('='*50)

    history = model.fit(
        x_train, y_train,
        batch_size=128,
        epochs=10,
        validation_split=0.1,
        verbose=1
    )

    histories[name] = history

    # テストデータで評価
    test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
    print(f"\nテスト精度: {test_acc:.4f}")

# 結果の可視化
plt.figure(figsize=(12, 5))

# 訓練精度のプロット
plt.subplot(1, 2, 1)
for name, history in histories.items():
    plt.plot(history.history['accuracy'], label=name)
plt.xlabel('エポック')
plt.ylabel('訓練精度')
plt.title('訓練精度の比較')
plt.legend()
plt.grid(True, alpha=0.3)

# 検証精度のプロット
plt.subplot(1, 2, 2)
for name, history in histories.items():
    plt.plot(history.history['val_accuracy'], label=name)
plt.xlabel('エポック')
plt.ylabel('検証精度')
plt.title('検証精度の比較')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

期待される結果

典型的な結果：

活性化関数テスト精度収束速度安定性
ReLU98.2%速い中
Leaky ReLU (0.01)98.4%やや速い高
Leaky ReLU (0.1)98.3%やや速い高

観察ポイント：

  • Leaky ReLUはわずかに精度が高い
  • 学習曲線が滑らか
  • より安定して収束する

まとめ：Leaky ReLUは実用的な改良版

Leaky ReLU（リーキーReLU）は、ReLUの弱点を克服した実用的な活性化関数です。

この記事のポイント：

  • Leaky ReLUの定義：負の値を完全に0にせず、わずかに漏らす（leak）活性化関数
  • 数式：f(x) = max(αx, x)、通常α=0.01
  • Dying ReLU問題：ReLUではニューロンが死ぬことがある深刻な問題
  • 解決策：Leaky ReLUは負の領域でも勾配が流れるため、ニューロンが死なない
  • メリット：学習の安定性向上、Dying ReLU問題の解決、計算コストはほぼ同じ
  • デメリット：ハイパーパラメータαの選択、常にReLUより良いわけではない
  • 実装：TensorFlow、PyTorchで簡単に使える
  • 使用場面：深いネットワーク、Dying ReLU問題が発生する場合、学習が不安定な場合
  • α値：デフォルト0.01から始め、必要に応じて調整
  • 他の選択肢：PReLU、ELU、SELUなどもある

ディープラーニングでニューラルネットワークを構築するとき、活性化関数の選択は重要です。

ReLUは素晴らしい活性化関数ですが、Dying ReLU問題という致命的な弱点があります。Leaky ReLUは、この問題を非常にシンプルな方法で解決しています。

実装も簡単で、計算コストもほとんど増えません。ReLUで問題が起きたら、まずLeaky ReLUを試してみることをおすすめします。

深層学習の世界では、小さな改良が大きな違いを生むことがあります。Leaky ReLUは、その好例といえるでしょう。

Youtube

神話・歴史・伝承の解説チャンネル

スポンサーリンク

コメント

タイトルとURLをコピーしました