学習中にニューロンを活性化する関数：高速収束の鍵は？

はじめに

前回の記事では、単純な多層パーセプトロン(MLP)ニューラルネットワークを取引における近似器（強化学習）として検討しました。その際、活性化関数の特性には特に注目せず、一般的な双曲線正接シグモイドを使用しました。また別の記事では、広く用いられているADAMアルゴリズムの能力について議論し、独立した集団型のグローバル最適化手法であるADAMmに改良しました。

本記事では、ニューラルネットワークをデータ補間（教師あり学習）の観点から考察し、ニューロン活性化関数の特性に焦点を当てます。ニューラルネットワークに組み込まれたADAM最適化アルゴリズム（通常の使用法に従って）を使用し、活性化関数およびその導関数が最適化アルゴリズムの収束速度に与える影響を研究します。

川を想像してください。多くの支流を持つその通常の状態では、水は自由に流れ、複雑な流れや渦を作り出します。しかし、水門や堰のシステムを作り始めたらどうなるでしょうか。水の流れを制御し、適切な方向に導き、流れの強さを調整できるようになります。ニューラルネットワークにおける活性化関数も同様の役割を果たします。どの信号を通すか、どの信号を遅らせるか、あるいは弱めるかを決定するのです。活性化関数がなければ、ニューラルネットワークは単なる線形変換の集合に過ぎません。

活性化関数はニューラルネットワークの動作に動的な性質を加え、データの微妙なニュアンスを捉えることを可能にします。たとえば顔認識タスクでは、活性化関数によって眉のアーチや顎の形状などの小さな特徴を検知できます。適切な活性化関数の選択は、ニューラルネットワークがさまざまなタスクでどのように機能するかに影響します。ある特徴量は学習初期の段階で明確で理解しやすい信号を提供します。別の特徴量はネットワークがより微細なパターンを学習する後期段階で有用です。また、不要な情報を抑制し、重要な特徴量のみを強調する役割を果たすものもあります。

活性化関数の特性を知らなければ、ニューラルネットワークは単純な課題でつまずいたり、重要な詳細を見落としたりし始める可能性があります。活性化関数の主な目的は、ニューラルネットワークに非線形性を導入し、出力値を正規化することです。

本記事の目的は、異なる活性化関数の使用に関連する問題点を明らかにし、誤差を最小化しつつ例点を補間する際のニューラルネットワークの精度に与える影響を検証することです。また、活性化関数が実際に収束速度に影響を与えるのか、それともこれは使用する最適化アルゴリズムの性質によるものなのかを明らかにします。参照アルゴリズムとして、確率的要素を用いた改良版集団ADAMmを使用し、MLPに組み込まれたADAM（従来の使用法）でテストをおこないます。後者は直感的には有利に思えます。なぜなら、活性化関数の導関数を通じて適合度関数の勾配に直接アクセスできるからです。一方、集団型の確率的ADAMmは導関数へのアクセスがなく、最適化問題の表面について全く情報を持たないためです。これらの結果を見て結論を導きます。

本記事は探索的な性格を持ち、物語は実験の順序に沿って進行します。

ADAM内蔵MLPニューラルネットワークの実装

図1：MLPニューラルネットワークとその学習の概略図

本研究をおこなうにあたり、MQL5言語に組み込まれた特殊な行列演算機能を使わずに、単純で透明性の高いMLPニューラルネットワークコードを用意しました。これにより、ニューラルネットワークのロジックで何が起こっているのかを明確に理解でき、特定の結果が何に依存しているのかを把握することが可能になります。

ここでは、内蔵ADAM (Adaptive Moment Estimation)最適化アルゴリズムを備えたMLPを実装します。ニューラルネットワークの実装の一部を表すクラスと構造体を用い、主要な構成要素であるニューロン、ニューロン層、重みを定義します。

1. C_Neuroは、ニューラルネットワークの基本単位であるニューロンを表します。

• C_Neuron()はコンストラクタであり、最適化アルゴリズムで使用する「m」と「v」プロパティの値をゼロに初期化します。
• out：活性化関数を適用した後のニューロンの出力値
• delta：学習中に勾配を計算する際に使用される誤差デルタ
• bias：ニューロン入力に加算されるバイアス値
• mとv：ADAM最適化法で使用するバイアスの一次および二次モーメント

2. S_NeuronLayer構造体は、ニューロンの層を表します。C_Neuron n []は、ニューラルネットワーク層内のニューロン配列です。

ニューロン間の重みを格納する際には、単純な二次元配列ではなく、オブジェクト指向アプローチを使用します。これはC_Weightクラスに基づいており、接続の重み自体だけでなく、ADAMアルゴリズムで使用する一次および二次モーメントといった最適化パラメータも保持します。データ構造は階層的に配置されており、S_WeightsLayerがS_WeightsLayerR構造体の配列を含み、さらにそれぞれがC_Weightオブジェクトの配列を含む形になっています。この構造により、明確なインデックスチェーンを通じてネットワーク内の任意の重みに簡単にアクセスできます。

たとえば、層0の最初のニューロンと次の層の2番目のニューロンの接続重みを参照する場合、表記「wL [0].nOnL [1].nOnR [2].w」を使用します。ここで、最初のインデックスは隣接する層のペアを示し、2番目は左側の層のニューロンを示し、3番目は右側の層のニューロンを示します。

//——————————————————————————————————————————————————————————————————————————————
// Neuron class
class C_Neuron
{
  public:
  C_Neuron ()
  {
    m = 0.0;
    v = 0.0;
  }
  double out;   // Neuron output after the activation function
  double delta; // Error delta
  double bias;  // Bias
  double m;     // First moment of displacement
  double v;     // Second moment of displacement
};
//——————————————————————————————————————————————————————————————————————————————

//——————————————————————————————————————————————————————————————————————————————
// Structure of the neuron layer
struct S_NeuronLayer
{
    C_Neuron n []; // neurons in the layer
};
//——————————————————————————————————————————————————————————————————————————————

//——————————————————————————————————————————————————————————————————————————————
// Weight class
class C_Weight
{
  public:
  C_Weight ()
  {
    w = 0.0;
    m = 0.0;
    v = 0.0;
  }

  double w; // Weight
  double m; // First moment
  double v; // Second moment
};
//——————————————————————————————————————————————————————————————————————————————

//——————————————————————————————————————————————————————————————————————————————
//Weight structure for neurons on the right
struct S_WeightsLayerR
{
    C_Weight nOnR [];
};
//——————————————————————————————————————————————————————————————————————————————

//——————————————————————————————————————————————————————————————————————————————
//Weight structure for neurons on the left
struct S_WeightsLayer
{
    S_WeightsLayerR nOnL [];
};
//——————————————————————————————————————————————————————————————————————————————

C_MLPaCクラスは、MLPの基本機能を実装しており、ADAM最適化アルゴリズムを用いた順伝播とバックプロパゲーション（誤差逆伝播）学習をおこなうことができます。その主な機能を以下に示します。

• ネットワークは、入力層 -> 隠れ層 -> 出力層という順次の層で構成されます。
• 各層のニューロンは、次の層のすべてのニューロンと接続されています（全結合ネットワーク）。

• Init：与えられた構成でネットワークを作成するメソッド
• ImportWeightsおよびExportWeights：ネットワークの重みを読み込み・保存する関数
• ForwProp：順伝播（入力データに対するネットワークの応答を取得する）
• BackProp：バックプロパゲーションに基づくネットワーク学習メソッド

• alpha (0.001)：ネットワークの学習速度を制御する
• beta1 (0.9)およびbeta2 (0.999)：ネットワークが安定して学習するのを助けるパラメータ
• epsilon (1e-8)：ゼロ除算を防ぐための小さな値

• BackPropは各層のサイズ(layersSize)に関する情報を保持する
• 全ニューロン(nL)およびそれらの間の重み(wL)を含む
• 重みの総数(wC)や層の数(nLC)も追跡する
• actFunc：選択された活性化関数を使用する
  

本質的に、このクラスはニューラルネットワークの「脳」に相当し、入力データを受け取り、ニューロンと重みのシステムを通して処理し、結果を生成し、自らの誤りから学習することで、予測精度を徐々に向上させることができます。

//+-----------------------------------------------------------------------------------------+
//| Multilayer Perceptron (MLP) class                                                       |
//| Implements forward pass through a fully connected neural network and training using the |
//| backpropagation of error by ADAM optimization algorithm                                 |
//| Architecture: Lin -> L1 -> L2 -> ... Ln -> Lout                                         |
//+-----------------------------------------------------------------------------------------+
class C_MLPa
{
  public: //--------------------------------------------------------------------
  ~C_MLPa ()
  {
    delete actFunc;
  }
  C_MLPa ()
  {
    alpha   = 0.001;   // Training speed
    beta1   = 0.9;     // Decay ratio for the first moment
    beta2   = 0.999;   // Decay ratio for the second moment
    epsilon = 1e-8;    // Small constant for numerical stability
  }

  // Network initialization with the given configuration, Returns the total number of weights in the network, or 0 in case of an error
  int    Init          (int &layerConfig [], int actFuncType, int seed);
  bool   ImportWeights (double &weights []);  // Import weights
  bool   ExportWeights (double &weights []);  // Export weights

  // Forward pass through the network
  void   ForwProp (double &inLayer  [],  // input values
                   double &outLayer []); // output layer values

  // Error backpropagation with ADAM optimization algorithm
  void   BackProp (double &errors []);

  // Get the total number of weights in the network
  int    GetWcount () { return wC; }

  // ADAM optimization parameters 
  double alpha;          // Training speed
  double beta1;          // Decay ratio for the first moment
  double beta2;          // Decay ratio for the second moment
  double epsilon;        // Small constant for numerical stability

  int layersSize    [];  // Size of each layer (number of neurons)
  S_NeuronLayer  nL [];  // Layers of neurons, example of access: nLayers [].n [].a
  S_WeightsLayer wL [];  // Layers of weights between layers of neurons, example of access: wLayers [].nOnLeft [].nOnRight [].w

  private: //-------------------------------------------------------------------
  int            wC;       // Total number of weights in the network (including biases)
  int            nLC;      // Total number of neuron layers (including input and output ones)
  int            wLC;      // Total number of weight layers (between neuron layers)
  int            t;        // Iteration counter
  C_Base_ActFunc *actFunc; // Activation functions and their derivatives
};
//——————————————————————————————————————————————————————————————————————————————

Initメソッドは、多層パーセプトロンの構造を初期化します。各層のニューロン数を設定し、活性化関数を選択し、ニューロンの初期重みを生成します。ネットワーク構成の妥当性をチェックし、必要な総重み数を返すか、エラーが発生した場合は0を返します。

パラメータは次のとおりです。

• layerConfig []：各ネットワーク層におけるニューロン数を格納した配列
• actFuncType：ニューラルネットワークで使用する活性化関数の種類（例：シグモイド）
• seed：重みを初期化する際の乱数生成器を初期化するためのシードで、再現可能な結果を得ることができる

動作の流れ

1. 渡されたlayerConfig配列に基づいて層の数を決定します。
2. 層の数が少なくとも2であること、各層に正のニューロン数が含まれていることを確認します。エラーが発生した場合はメッセージを表示して実行を終了します。
3. 層のサイズをlayersSize配列にコピーし、ニューロンおよび重みを格納する配列を初期化します。
4. 層間のニューロンを接続するために必要な総重み数を計算します。
5. さらに、Xavier法を用いて重みを初期化します。これにより、理論的に勾配消失や勾配爆発の問題を回避できます。
6. 渡された活性化関数の種類に応じて、対応する活性化関数オブジェクトを生成します。
7. ADAMアルゴリズムで使用するイテレーションカウンタをゼロに初期化します。
   

//+----------------------------------------------------------------------------+
//| Initialize the network                                                     |
//| layerConfig - array with the number of neurons in each layer               |
//| Returns the total number of weights needed, or 0 in case of an error       |
//+----------------------------------------------------------------------------+
int C_MLPa::Init (int &layerConfig [], int actFuncType, int seed)
{
  nLC = ArraySize (layerConfig);

  if (nLC < 2)
  {
    Print ("Network configuration error! Less than 2 layers!");
    return 0;
  }

  // Check configuration
  for (int i = 0; i < nLC; i++)
  {
    if (layerConfig [i] <= 0)
    {
      Print ("Network configuration error! Layer #" + string (i + 1) + " contains 0 neurons!");
      return 0;
    }
  }

  wLC = nLC - 1;
  ArrayCopy (layersSize, layerConfig, 0, 0, WHOLE_ARRAY);

  // Initialize neuron layers
  ArrayResize (nL, nLC);
  for (int i = 0; i < nLC; i++)
  {
    ArrayResize (nL [i].n, layersSize [i]);
  }

  // Initialize weight layers
  ArrayResize (wL, wLC);
  for (int w = 0; w < wLC; w++)
  {
    ArrayResize (wL [w].nOnL, layersSize [w]);
    for (int n = 0; n < layersSize [w]; n++)
    {
      ArrayResize (wL [w].nOnL [n].nOnR, layersSize [w + 1]);
    }
  }

  // Calculate the total number of weights
  wC = 0;
  for (int i = 0; i < nLC - 1; i++) wC += layersSize [i] * layersSize [i + 1] + layersSize [i + 1];

  // Initialize weights
  double weights [];  ArrayResize (weights, wC);

  srand (seed);
  
  //Xavier: U(-√(6/(n₁+n₂)), √(6/(n₁+n₂)))
  double n = sqrt (6.0 / (layersSize [0] + layersSize [nLC - 1]));
  for (int i = 0; i < wC; i++)
  {
    weights [i] = (2.0 * n) * (rand () / 32767.0) - n;
  }

  ImportWeights (weights);

  switch (actFuncType)
  {
    case eActACON:      actFunc = new C_ActACON      (); break;
    case eActAlgSigm:   actFunc = new C_ActAlgSigm   (); break;
    case eActBentIdent: actFunc = new C_ActBentIdent (); break;
    case eActRatSigm:   actFunc = new C_ActRatSigm   (); break;
    case eActSiLU:      actFunc = new C_ActSiLU      (); break;
    case eActSoftPlus:  actFunc = new C_ActSoftPlus  (); break;
    default:            actFunc = new C_ActTanh      (); break;
  }

  t = 0;
  return wC;
}
//——————————————————————————————————————————————————————————————————————————————

次に、ImportWeightsとExportWeightsの2つのメソッドを見ていきましょう。これらのメソッドは、多層パーセプトロンの重みとバイアスをインポートおよびエクスポートするために設計されています。ImportWeightsは、weights配列からニューラルネットワーク構造に重みとバイアスを読み込む役割を担います。

まず、渡されたweights配列のサイズがwC変数に格納された重みの数と一致するかを確認します。サイズが一致しない場合、メソッドはエラーを示すfalseを返します。

wCNT変数は、weights配列内の現在のインデックスを追跡するために使用されます。
層およびニューロンをループ処理します。

• 最初の層は入力層であり、重みや外側のループは、各層を順に処理します。入力層（インデックス0）は重みやバイアスを持たないため、2層目（インデックス1）から開始します。
• 内側のループは、現在の層の各ニューロンを順に処理します。
• 各ニューロンに対して、biasの値をweights配列から設定し、wCNTカウンタをインクリメントします。
• さらに入れ子のループで、前の層のすべてのニューロンを順に処理し、現在の層のニューロンと前の層のニューロンを接続する重みを設定します。

ExportWeights：このメソッドは、ニューラルネットワーク構造からweights配列へ重みとバイアスをエクスポートする役割を担います。メソッドのロジックはImportWeightsと類似しています。これら両方のメソッドにより、ネットワーククラスに関連して外部プログラムに重みとバイアスを保存することが可能となり、学習済みネットワークを将来使用することや、集団型などの外部最適化アルゴリズムを利用することも可能になります。

//+----------------------------------------------------------------------------+
//| Import network weights and biases                                          |
//+----------------------------------------------------------------------------+
bool C_MLPa::ImportWeights (double &weights [])
{
  if (ArraySize (weights) != wC) return false;

  int wCNT = 0;

  for (int ln = 1; ln < nLC; ln++)
  {
    for (int n = 0; n < layersSize [ln]; n++)
    {
      nL [ln].n [n].bias = weights [wCNT++];

      for (int w = 0; w < layersSize [ln - 1]; w++)
      {
        wL [ln - 1].nOnL [w].nOnR [n].w = weights [wCNT++];
      }
    }
  }

  return true;
}
//——————————————————————————————————————————————————————————————————————————————

//+----------------------------------------------------------------------------+
//| Export network weights and biases                                          |
//+----------------------------------------------------------------------------+
bool C_MLPa::ExportWeights (double &weights [])
{
  ArrayResize (weights, wC);

  int wCNT = 0;

  for (int ln = 1; ln < nLC; ln++)
  {
    for (int n = 0; n < layersSize [ln]; n++)
    {
      weights [wCNT++] = nL [ln].n [n].bias;

      for (int w = 0; w < layersSize [ln - 1]; w++)
      {
        weights [wCNT++] = wL [ln - 1].nOnL [w].nOnR [n].w;
      }
    }
  }

  return true;
}
//——————————————————————————————————————————————————————————————————————————————

ForwPropメソッド（順伝播）は、多層パーセプトロンの入力層から出力層までの全ての層の値を順に計算します。入力値を受け取り、隠れ層を通して処理し、出力値を生成します。パラメータは次のとおりです。

• inLayer []：ニューラルネットワークの入力値を格納する配列（図1では緑色で示されています）
• outLayer []：処理後に出力層の値が設定される配列（図1では黄色で示されています）
  

メソッドは、入力層ニューロンの活性化値を、inLayer配列から対応するニューロンにコピーすることで初期化します。

隠れ層および出力層の処理：

• 外側のループは、入力層（インデックス0）を除いたすべての層（インデックス1から）を順に反復します。
• 内側のループは、現在の層の各ニューロンを順に処理します。
• 各ニューロンについて、重み付き入力の総和を計算します。
• まず、ニューロンにバイアスを加えます。
• ネストされたループで前の層の全ニューロンを反復し、前の層のニューロンの出力値と対応する重みの積をvalに加えます。
• 総和を計算した後、活性化関数をvalに適用し、その結果を現在の層のニューロンの出力値として格納します。

//+----------------------------------------------------------------------------+
//| Direct network pass                                                        |
//| Calculate the values of all layers sequentially from input to output       |
//+----------------------------------------------------------------------------+
void C_MLPa::ForwProp (double &inLayer  [],  // input values
                       double &outLayer [])  // output layer values
{
  double val;

  // Set the input layer activation values
  for (int n = 0; n < layersSize [0]; n++)
  {
    nL [0].n [n].out = inLayer [n];
  }

  // Handle hidden and output layers
  for (int ln = 1; ln < nLC; ln++)
  {
    for (int n = 0; n < layersSize [ln]; n++)
    {
      val = nL [ln].n [n].bias;

      for (int w = 0; w < layersSize [ln - 1]; w++)
      {
        val += nL [ln - 1].n [w].out * wL [ln - 1].nOnL [w].nOnR [n].w;
      }

      nL [ln].n [n].out = actFunc.Activ (val); // Apply activation function
    }
  }

  // Set the output layer values
  for (int n = 0; n < layersSize [nLC - 1]; n++) outLayer [n] = nL [nLC - 1].n [n].out;
}
//——————————————————————————————————————————————————————————————————————————————

BackPropメソッドは、多層パーセプトロンにおけるバックプロパゲーションを実装します。ADAM最適化アルゴリズムを用いて、出力層から入力層に向かってすべての層の重みとバイアスを更新します。動作の流れ

t変数は反復回数を追跡するためにインクリメントされ、ADAMの計算式で使用されます。

全層のデルタ計算

• 外側のループは、出力層から入力層に向かって層を逆順に反復します。
• 内側のループは、現在の層の各ニューロンを順に処理します。
• 現在の層が出力層の場合、デルタは誤差(errors[nCurr])と出力ニューロンの活性化関数の導関数の積として計算されます。
• 隠れ層の場合、デルタは次の層のデルタと対応する重みの積の合計として計算されます。
• その後、デルタを活性化関数の導関数で調整し、その結果をnL[ln].n[nCurr].deltaに格納します。

• 外側のループは、入力層を除く全層を順に処理します。
• 各ニューロンについて、バイアスのモーメントmとvをbeta1およびbeta2パラメータを用いて更新します。
• その後、補正されたモーメントm_hatとv_hatを計算します。
• 最後に、補正されたモーメントを用いてバイアスを更新します。

• 外側のループは、すべての重み層を順に処理します。
• 内側のループは、現在の層および次の層のニューロンを順に処理します。
• 各重みについて勾配を計算し、それを用いてmとvのモーメントを更新します。
• m_hatとv_hatの補正後のモーメントを用いて、重みを更新します。

//+----------------------------------------------------------------------------+
//| Backward network pass                                                      |
//| Update the weights and biases of all layers from output to input           |
//+----------------------------------------------------------------------------+
void C_MLPa::BackProp (double &errors [])
{
  t++;  // Increase the iteration counter

  double delta;     // current neuron delta
  double deltaNext; // delta of the neuron in the next layer connected to the current neuron
  double out;       // neuron value after applying the activation function
  double deriv;     // derivative
  double w;         // weight for connecting the current neuron to the neuron of the next layer

  // 1. Calculating deltas for all layers ----------------------------------------
  for (int ln = nLC - 1; ln > 0; ln--)                  // walk through layers in reverse order from output to input
  {
    for (int nCurr = 0; nCurr < layersSize [ln]; nCurr++)        // iterate through the neurons of the current layer
    {
      if (ln == nLC - 1)
      {
        delta = errors [nCurr] * actFunc.Deriv (nL [ln].n [nCurr].out);
      }
      else
      {
        delta = 0.0;

        // Sum the products of the deltas of the next layer by the corresponding weights
        for (int nNext = 0; nNext < layersSize [ln + 1]; nNext++) // pass the neurons of the next layer in the usual order
        {
          deltaNext = nL [ln + 1].n [nNext].delta;
          w         = wL [ln].nOnL [nCurr].nOnR [nNext].w;
          delta    += deltaNext * w;
        }
      }

      // Delta considering the derivative of the sigmoid
      out   = nL [ln].n [nCurr].out;
      deriv = actFunc.Deriv (out);
      nL [ln].n [nCurr].delta = delta * deriv;
    }
  }

  // 2. Update biases using ADAM ------------------------------
  for (int ln = 1; ln < nLC; ln++)
  {
    for (int nCurr = 0; nCurr < layersSize [ln]; nCurr++)
    {
      delta = nL [ln].n [nCurr].delta;

      // Update displacement moments
      nL [ln].n [nCurr].m = beta1 * nL [ln].n [nCurr].m + (1.0 - beta1) * delta;
      nL [ln].n [nCurr].v = beta2 * nL [ln].n [nCurr].v + (1.0 - beta2) * delta * delta;

      // Adjust displacement moments
      double m_hat = nL [ln].n [nCurr].m / (1.0 - pow (beta1, t));
      double v_hat = nL [ln].n [nCurr].v / (1.0 - pow (beta2, t));

      // Update bias
      nL [ln].n [nCurr].bias += alpha * m_hat / (sqrt (v_hat) + epsilon);
    }
  }

  // 3. Update weights using ADAM ---------------------------------
  for (int lw = 0; lw < wLC; lw++)
  {
    for (int nCurr = 0; nCurr < layersSize [lw]; nCurr++)
    {
      for (int nNext = 0; nNext < layersSize [lw + 1]; nNext++)
      {
        deltaNext = nL [lw + 1].n [nNext].delta;
        out       = nL [lw].n [nCurr].out;
        double gradient = deltaNext * out;

        // Update moments for weights
        wL [lw].nOnL [nCurr].nOnR [nNext].m = beta1 * wL [lw].nOnL [nCurr].nOnR [nNext].m + (1.0 - beta1) * gradient;
        wL [lw].nOnL [nCurr].nOnR [nNext].v = beta2 * wL [lw].nOnL [nCurr].nOnR [nNext].v + (1.0 - beta2) * gradient * gradient;

        // Adjust weight moments
        double m_hat = wL [lw].nOnL [nCurr].nOnR [nNext].m / (1.0 - pow (beta1, t));
        double v_hat = wL [lw].nOnL [nCurr].nOnR [nNext].v / (1.0 - pow (beta2, t));

        // Update weight
        wL [lw].nOnL [nCurr].nOnR [nNext].w += alpha * m_hat / (sqrt (v_hat) + epsilon);
      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

活性化関数を描画するためのスタンド用コード

このスタンドは、ニューラルネットワークで使用されるさまざまな活性化関数の正しい動作をテストし、それらをグラフの形で表示するために設計されています。得られた画像は、後の章でそれらの見た目を視覚的に評価するために使用されます。コード自体はシンプルで、詳細な説明は不要です。

#include <Graphics\Graphic.mqh>
#include <Math\AOs\NeuroNets\MLPa.mqh>

#define SIZE_X 750
#define SIZE_Y 200

//--- input parameters
input E_Act ACT = eActTanh;
input int   CNT = 10000;

//——————————————————————————————————————————————————————————————————————————————
void OnStart ()
{
  ObjectDelete (ChartID (), "Test");
  double activ [];
  double deriv [];

  //----------------------------------------------------------------------------
  C_Base_ActFunc *act;
  switch (ACT)
  {
    default:            act = new C_ActTanh      (); break;
    case eActAlgSigm:   act = new C_ActAlgSigm   (); break;
    case eActRatSigm:   act = new C_ActRatSigm   (); break;
    
    case eActSoftPlus:  act = new C_ActSoftPlus  (); break;
    case eActBentIdent: act = new C_ActBentIdent (); break;
    case eActSiLU:      act = new C_ActSiLU      (); break;
    
    case eActACON:      act = new C_ActACON      (); break;
    case eActSnake:     act = new C_ActSnake     (); break;
    case eActSERF:      act = new C_ActSERF      (); break;
  }
  
  //----------------------------------------------------------------------------
  ActFuncTest (act, activ, deriv, CNT, -10, 10);
  
  //----------------------------------------------------------------------------
  CGraphic gr_test;
  gr_test.Create (0, "Test", 0, 0, 20, SIZE_X, SIZE_Y + 20);
  gr_test.YAxis ().Name (act.GetFuncName () + ": Value");
  gr_test.YAxis ().NameSize (13);
  gr_test.HistorySymbolSize (10);
  gr_test.CurveAdd (activ, ColorToARGB (clrRed,  255), CURVE_LINES, "activ");
  gr_test.CurveAdd (deriv, ColorToARGB (clrBlue, 255), CURVE_LINES, "deriv");
  gr_test.CurvePlotAll ();
  gr_test.Redraw (true);
  gr_test.Update ();
  
  //----------------------------------------------------------------------------
  delete act;
}
//——————————————————————————————————————————————————————————————————————————————

//——————————————————————————————————————————————————————————————————————————————
void ActFuncTest (C_Base_ActFunc &act, double &arrayAct [], double &arrayDer [], int testCount, double min, double max)
{
  Print (act.GetFuncName (), " [", min, "; ", max, "]");
  Print (act.Activ (min), " ", act.Activ (0), " ", act.Activ (max));
  Print (act.Deriv (min), " ", act.Deriv (0), " ", act.Deriv (max));

  ArrayResize (arrayAct, testCount);
  ArrayResize (arrayDer, testCount);
  double x    = 0.0;
  double step = (max - min) / testCount;
  
  for (int i = 0; i < testCount; i++)
  {
    x = min + step * i;

    arrayAct [i] = act.Activ (x);
    arrayDer [i] = act.Deriv (x);
  }
}
//——————————————————————————————————————————————————————————————————————————————

活性化関数クラスのコード

ニューラルネットワークでは、さまざまな種類のニューロン活性化関数が使用されています。私は、よく知られている双曲線正接関数(tanh)だけでなく、Snake活性化関数のようなあまり知られていない関数も含め、見た目や特性が非常に似ている関数は除外した上で、いくつかの関数を選定いたしました。これらの活性化関数は、便宜上次の三つのグループに分類することができます。

1. シグモイド関数
2. 非線形スイッチ関数
3. 周期関数

ニューロンの活性化関数を表す基底クラスとしてC_Base_ActFuncを実装します。このクラスには、 活性化を計算するためのActiv関数と、導関数を計算するためのDeriv関数という2つの仮想関数が含まれます。また、GetFuncName()メソッドは、protectedメンバ変数funcNameに格納された活性化関数の名称を返します。このクラスは、具体的な活性化関数を実装するための継承用クラスとして設計されています。活性化関数オブジェクトを生成することで、if文やswitch文を何度も使用する必要がなくなり、計算を高速化することができます。

//——————————————————————————————————————————————————————————————————————————————
// Base class of the neuron activation function
class C_Base_ActFunc
{
  public:
  virtual double Activ (double inp) = 0; // Virtual activation function
  virtual double Deriv (double inp) = 0; // Virtual derivative function
  string         GetFuncName () {return funcName;}
  protected:
  string funcName;
};
//——————————————————————————————————————————————————————————————————————————————

C_ActTanhは、双曲線正接活性化関数およびその導関数を実装し、C_Base_ActFunc基底クラスを継承します。クラスのコンストラクタでは、活性化関数名をfuncName変数にActTanhとして設定します。以下が活性化メソッドです。

• Activ(double x)メソッドは、式「f(x) = 2 / (1 + exp ( − 2  ⋅  (x)) − 1.」を用いて双曲線正接活性化関数の値を計算します。この式により、入力値xは−1から1の範囲に変換されます。

• Deriv(double x)メソッドは、活性化関数の導関数を計算します。双曲線正接関数の導関数は式「f′(x) = 1 − (f (x)) ^ 2」で表されます。ここで、f(x)は現在の入力値xに対して計算された活性化関数の値です。 この導関数は、入力値に対して関数の値がどの程度変化するか、すなわち関数の変化率を示します。

//——————————————————————————————————————————————————————————————————————————————
// Hyperbolic tangent
class C_ActTanh : public C_Base_ActFunc
{
  public:
  C_ActTanh () {funcName = "ActTanh";}

  double Activ (double x)
  {
    return 2.0 / (1.0 + exp (-2 * (x))) - 1.0;
  }

  double Deriv (double x)
  {
    //1 - (f(x))^2
    double fx = Activ (x);
    return 1.0 - fx * fx;
  }
};
//——————————————————————————————————————————————————————————————————————————————

図2：双曲線正接とその導関数

C_ActAlgSigmクラスは、C_ActTanhクラスと同様に、活性化関数として代数的シグモイド関数を実装します。

//——————————————————————————————————————————————————————————————————————————————
// Algebraic sigmoid
class C_ActAlgSigm : public C_Base_ActFunc
{
  public:
  C_ActAlgSigm () {funcName = "ActAlgSigm";}

  double Activ (double x)
  {
    return x / sqrt (1.0 + x * x);
  }

  double Deriv (double x)
  {
    // (1 / sqrt (1 + x * x))^3
    double d = 1.0 / sqrt (1.0 + x * x);
    return d * d * d;
  }
};
//——————————————————————————————————————————————————————————————————————————————

図3：代数的シグモイドとその導関数

C_ActRatSigmクラスは、有理型シグモイド関数を活性化関数として実装し、その計算および導関数を求めるメソッドを備えています。

//——————————————————————————————————————————————————————————————————————————————
// Rational sigmoid
class C_ActRatSigm : public C_Base_ActFunc
{
  public:
  C_ActRatSigm () {funcName = "ActRatSigm";}

  double Activ (double x)
  {
    return x / (1.0 + fabs (x));
  }

  double Deriv (double x)
  {
    //1 / (1 + abs (x))^2
    double d = 1.0 + fabs (x);
    return 1.0 / (d * d);
  }
};
//——————————————————————————————————————————————————————————————————————————————

図4：有理型シグモイドとその導関数

C_ActSoftPlusクラスは、Softplus活性化関数とその導関数を実装します。

//——————————————————————————————————————————————————————————————————————————————
// Softplus
class C_ActSoftPlus : public C_Base_ActFunc
{
  public:
  C_ActSoftPlus () {funcName = "ActSoftPlus";}

  double Activ (double x)
  {
    return log (1.0 + exp (x));
  }

  double Deriv (double x)
  {
    return 1.0 / (1.0 + exp (-x));
  }
};
//——————————————————————————————————————————————————————————————————————————————

図5：SoftPlus関数とその導関数

C_ActBentIdentクラスは、Bent Identity活性化関数とその導関数を実装します。

//——————————————————————————————————————————————————————————————————————————————
// Bent Identity
class C_ActBentIdent : public C_Base_ActFunc
{
  public:
  C_ActBentIdent () {funcName = "ActBentIdent";}

  double Activ (double x)
  {
    return (sqrt (x * x + 1.0) - 1.0) / 2.0 + x;
  }

  double Deriv (double x)
  {
    return x / (2.0 * sqrt (x * x + 1.0)) + 1.0;
  }
};
//——————————————————————————————————————————————————————————————————————————————

図6：Bent Identity関数とその導関数

C_ActSiLUクラスは、SiLU活性化関数とその導関数の実装を提供します。

//——————————————————————————————————————————————————————————————————————————————
// SiLU (Swish)
class C_ActSiLU : public C_Base_ActFunc
{
  public:
  C_ActSiLU () {funcName = "ActSiLU";}

  double Activ (double x)
  {
    return x / (1.0 + exp (-x));
  }

  double Deriv (double x)
  {
    if (x == 0.0) return 0.5;

    // f(x) + (f(x)*(1 - f(x)))/ x
    double fx = Activ (x);
    return fx + (fx * (1.0 - fx)) / x;
  }
};
//——————————————————————————————————————————————————————————————————————————————

図7：SiLU関数とその導関数

C_ActACONは、ACON活性化関数とその導関数を実装します。

//——————————————————————————————————————————————————————————————————————————————
// ACON
class C_ActACON : public C_Base_ActFunc
{
  public:
  C_ActACON () {funcName = "ActACON";}

  double Activ (double x)
  {
    return (x * cos (x) + sin (x)) / (1.0 + fabs (x));
  }

  double Deriv (double x)
  {
    if (x == 0.0) return 2.0;

    //[2 * cos(x) - x * sin(x)] / [|x| + 1] - x * (sin(x) + x * cos(x)) / [|x| * ((|x| + 1)²)]
    double sinX   = sin  (x);
    double cosX   = cos  (x);
    double fabsX  = fabs (x);
    double fabsXp = fabsX + 1.0;

    // Divide the equation into two parts
    double part1 = (2.0 * cosX - x * sinX) / fabsXp;
    double part2 = -x * (sinX + x * cosX) / (fabsX * fabsXp * fabsXp);
    return part1 + part2;
  }
};
//——————————————————————————————————————————————————————————————————————————————

図8：ACON関数とその導関数

C_ActSERFクラスは、SERF活性化関数とその導関数を実装します。

//——————————————————————————————————————————————————————————————————————————————
// SERF (sigmoid-weighted exponential straightening function)
class C_ActSERF : public C_Base_ActFunc
{
  public:
  C_ActSERF ()
  {
    alpha    = 0.5;
    funcName = "ActSERF";
  }

  double Activ (double x)
  {
    double sigmoid = 1.0 / (1.0 + exp (-alpha * x));

    if (x >= 0) return sigmoid * x;
    else return sigmoid * (exp (x) - 1.0);
  }

  double Deriv (double x)
  {
    double sigmoid = 1.0 / (1.0 + exp (-alpha * x));
    double sigmoidDeriv = alpha * sigmoid * (1.0 - sigmoid);
    double e = exp (x);
    if (x >= 0) return sigmoid + x * sigmoidDeriv;
    else return sigmoid * e + (e - 1.0) * sigmoidDeriv;
  }

  private:
  double alpha;
};
//——————————————————————————————————————————————————————————————————————————————

図9：SERF関数とその導関数

C_ActSNAKEクラスは、SNAKE活性化関数とその導関数を実装します。

//——————————————————————————————————————————————————————————————————————————————
// Snake (periodic activation function)
class C_ActSnake : public C_Base_ActFunc
{
  public:
  C_ActSnake ()
  {
    frequency = 1;
    funcName  = "ActSnake";
  }

  double Activ (double x)
  {
    double sinx = sin (frequency * x);
    return x + sinx * sinx;
  }

  double Deriv (double x)
  {
    double fx = frequency * x;
    return 1.0 + 2.0 * sin (fx) * cos (fx) * frequency;
  }

  private:
  double frequency;
};
//——————————————————————————————————————————————————————————————————————————————

図10：SNAKE関数とその導関数

活性化関数のテスト

ここでは、異なる活性化関数を用いた場合に、MLPネットワークがどのように学習されるかを確認します。活性化関数の複雑さが最適化アルゴリズムに与える影響は、1-1-1構成（1入力・1中間層・1出力）のMLPを用い、単一の学習例（1つの入力値と1つの目標値）で明確に示すことができます。

一見すると、このような単純な課題がなぜ興味深いのか疑問に思われるかもしれません。しかし、ここには重要な方法論上のポイントがあります。単一のデータ点のみを使用することで、活性化関数自体の複雑さおよびその最適化への影響を切り離して検証することが可能になります。大規模なデータセットを用いる場合、学習にはデータの分布、サンプル間の相互依存関係、そしてそれらが活性化関数を通過する際の影響など、多くの要因が関与します。単一の点を用いることにより、これらの外的要因を取り除き、最適化アルゴリズムが特定の活性化関数を扱う難易度にのみ焦点を当てることができます。

注目すべき点は、補間された関数の単一点を通過するニューラルネットワークには、無限に多くの重みの組み合わせが存在し得るということです。これは一見信じがたいかもしれませんが、単純な関係式「in * w + b = out」から導かれます。ここで、inはネットワークの入力、wは重み、bはバイアス、outは出力を表します（1-1構成の場合）。

この構成自体には問題はありませんが、もう1層追加した1-1-1構成にすると、事情が大きく変わります。この場合、最適化アルゴリズムにとって、最も単純な問題でさえ非自明となります。なぜなら、解探索空間が大幅に複雑化し、中間層とその活性化関数を介して、適切な重みの組み合わせを見つけ出す必要があるためです。この複雑さこそが、異なる最適化アルゴリズムが、各種活性化関数のもとでどの程度効率的に重み調整をおこなえるかを評価するうえで有効な基準となります。

以下に、ADAMアルゴリズムの古典的実装および集団型ADAMmによる結果を示します。いずれのアルゴリズムも10,000回の反復を実施しています。集団型アルゴリズムの場合は、集団の存在を考慮しつつ、ニューラルネットワークの総計算回数が同等となるよう調整しました。出力結果には、擬似乱数生成器のシード値（問題のある学習過程を再現するため）、最良の結果を得た反復回数、1000の倍数となるエポック時点での結果が表示されています。

重みの初期化には、ADAMではXavier法による乱数、ADAMmでは[-10, 10]の範囲の乱数を使用しました。複数のシードでテストをおこない、最悪の結果を選定しています。重み探索は、最大反復回数に到達するか、または誤差が0.000001未満に減少する時点で終了しました。

シグモイド活性化関数の結果の表

SiLU型活性化関数の結果表

周期的活性化関数の結果の表

ここまでの結果から、古典的な勾配法ADAMと集団型ADAMmにおける活性化関数の複雑さについて、いくつかの予備的な結論を導くことができます。通常のADAMは、活性化関数の勾配に関する直接的な情報を持っています。つまり、最急降下の方向を文字通り知っているにもかかわらず、この一見非常に単純な課題をうまく扱うことができませんでした。ADAMにとって最も単純で扱いやすかった関数はACONでした。この関数に対してのみ、ADAMは一貫して誤差を最小化することができました。一方で、SiLUのような関数はADAMにとって問題となり、誤差が減少しないどころか急激に増加する結果となりました。これは明らかに、ADAMが重みやバイアスに対する境界条件を持たないために、誤った方向に最適化を進めてしまい、重みが増大したことを示しています。その結果、重み値は抑制されることなく自由に発散し、まるで活性化関数の導関数という「風」に吹き飛ばされるかのように振る舞いました。

さらに、層内のニューロン数を増やすとこの問題はより深刻になります。なぜなら、各ニューロンは前の層の出力に対応する重みとの積の総和を入力として受け取るため、その総和が非常に大きくなり、指数関数の計算が正しくおこなえない状況が発生するためです。

一方で、集団型ADAMmにとっては、これらのどの活性化関数も問題とはなりませんでした。すべての関数において安定的に収束し、わずかに1000回を超える反復が必要となった関数もありましたが、全体として一貫した動作を示しました。

活性化関数クラス、MLPおよびADAMの改良

ニューラルネットワーク内で重みが発散してしまう問題を修正するために、活性化関数クラスに変更を加えます。この変更により、各関数の出力範囲（境界）を追跡できるようになり、ニューロンに渡される入力値の総和が過剰に大きくなることを防ぎ、さらに重みおよびバイアス値そのものの範囲を制限できるようになります。

具体的には、基底クラスにGetBoundUpおよびGetBoundLoメソッドを追加します。これらのメソッドは、それぞれ対応する活性化関数の上限値と下限値を取得するためのインターフェースを提供し、他のクラスや関数が許容範囲に関する情報へアクセスできるようにします。

以下に、基底クラスおよび双曲線正接活性化関数クラスに一部変更を加えたコード例を示します。他の活性化関数クラスについても同様に、それぞれの関数特性に応じた境界値を設定して実装します。

//——————————————————————————————————————————————————————————————————————————————
// Base class of the neuron activation function
class C_Base_ActFunc
{
  public:
  double         GetBoundUp  () { return boundUp;}
  double         GetBoundLo  () { return boundLo;}
  protected:
  double boundUp;  // upper bound of the input range
  double boundLo;  // lower bound of the input range
};
//——————————————————————————————————————————————————————————————————————————————

//——————————————————————————————————————————————————————————————————————————————
// Hyperbolic tangent
class C_ActTanh : public C_Base_ActFunc
{
  public:
  C_ActTanh ()
  {
    boundUp  =  6.0;
    boundLo  = -6.0;
  }
};
//——————————————————————————————————————————————————————————————————————————————

ニューロンの活性化関数に値を入力する前に、合計値(sum)が指定された境界を超えないようにするための検証処理を、MLPの順伝播メソッドに追加します。この検証によって、合計値が設定された範囲を超えて増加することを防止します。境界値を超えて合計を大きくすることには意味がなく、むしろ非効率です。さらに、この仕組みにより、層内に多数のニューロンを持つネットワーク構成において、合計計算の途中で早期に処理を打ち切ることが可能になります。これにより、計算速度を大幅に向上させることができます。

上限チェック：次のコードスニペットは、合計値が設定された上限を超えていないかを確認する処理を示しています。もし現在の合計値が上限を超えた場合、その値を上限値に固定し、ループの実行を終了します。下限値についても同様の方法でチェックをおこないます。

//+----------------------------------------------------------------------------+
//| Direct network pass                                                        |
//| Calculate the values of all layers sequentially from input to output       |
//+----------------------------------------------------------------------------+
void C_MLPa::ForwProp (double &inLayer  [],  // input values
                       double &outLayer [])  // output layer values
{
  double val;

  // Set the input layer activation values
  for (int n = 0; n < layersSize [0]; n++)
  {
    nL [0].n [n].out = inLayer [n];
  }

  // Handle hidden and output layers
  for (int ln = 1; ln < nLC; ln++)
  {
    for (int n = 0; n < layersSize [ln]; n++)
    {
      val = nL [ln].n [n].bias;

      for (int w = 0; w < layersSize [ln - 1]; w++)
      {
        val += nL [ln - 1].n [w].out * wL [ln - 1].nOnL [w].nOnR [n].w;

        if (val >  actFunc.GetBoundUp ())
        {
          val =  actFunc.GetBoundUp ();
          break;
        }
        if (val < actFunc.GetBoundLo ())
        {
          val = actFunc.GetBoundLo ();
          break;
        }
      }

      nL [ln].n [n].out = actFunc.Activ (val); // Apply activation function
    }
  }

  // Set the output layer values
  for (int n = 0; n < layersSize [nLC - 1]; n++) outLayer [n] = nL [nLC - 1].n [n].out;
}
//——————————————————————————————————————————————————————————————————————————————

次に、境界の検証コードをバックプロパゲーションメソッドに追加します。これらの追加処理は、与えられた境界から逆の境界へバイアスおよび重みの値を反射させるロジックを実装します。値が許容範囲を外れないようにすることが必要であり、重みやバイアスの制御不能な増減を防ぎます。

単純に境界で値を切り捨てるだけでは、学習が停滞してしまいます。重みが単純に境界に当たってしまい、重みを変更できなくなるためです。まさにそのような状況を防ぐために、値の切り捨てではなく反射を実装しています。これにより、重みやバイアスを調整する際に、「再活性化」や一種の「振動」を与えることが可能になります。

//+----------------------------------------------------------------------------+
//| Backward network pass                                                      |
//| Update the weights and biases of all layers from output to input           |
//+----------------------------------------------------------------------------+
void C_MLPa::BackProp (double &errors [])
{
  t++;  // Increase the iteration counter

  double delta;     // current neuron delta
  double deltaNext; // delta of the neuron in the next layer connected to the current neuron
  double out;       // neuron value after applying the activation function
  double deriv;     // derivative
  double w;         // weight for connecting the current neuron to the neuron of the next layer
  double bias;      // bias

  // 1. Calculating deltas for all layers ----------------------------------------
  for (int ln = nLC - 1; ln > 0; ln--)                  // walk through layers in reverse order from output to input
  {
    for (int nCurr = 0; nCurr < layersSize [ln]; nCurr++)        // iterate through the neurons of the current layer
    {
      if (ln == nLC - 1)
      {
        delta = errors [nCurr] * actFunc.Deriv (nL [ln].n [nCurr].out);
      }
      else
      {
        delta = 0.0;

        // Sum the products of the deltas of the next layer by the corresponding weights
        for (int nNext = 0; nNext < layersSize [ln + 1]; nNext++) // pass the neurons of the next layer in the usual order
        {
          deltaNext = nL [ln + 1].n [nNext].delta;
          w         = wL [ln].nOnL [nCurr].nOnR [nNext].w;
          delta    += deltaNext * w;
        }
      }

      // Delta considering the derivative of the sigmoid
      out   = nL [ln].n [nCurr].out;
      deriv = actFunc.Deriv (out);
      nL [ln].n [nCurr].delta = delta * deriv;
    }
  }

  // 2. Update biases using ADAM ------------------------------
  for (int ln = 1; ln < nLC; ln++)
  {
    for (int nCurr = 0; nCurr < layersSize [ln]; nCurr++)
    {
      delta = nL [ln].n [nCurr].delta;

      // Update displacement moments
      nL [ln].n [nCurr].m = beta1 * nL [ln].n [nCurr].m + (1.0 - beta1) * delta;
      nL [ln].n [nCurr].v = beta2 * nL [ln].n [nCurr].v + (1.0 - beta2) * delta * delta;

      // Adjust displacement moments
      double m_hat = nL [ln].n [nCurr].m / (1.0 - pow (beta1, t));
      double v_hat = nL [ln].n [nCurr].v / (1.0 - pow (beta2, t));

      // Update bias
      nL [ln].n [nCurr].bias += alpha * m_hat / (sqrt (v_hat) + epsilon);
      bias = nL [ln].n [nCurr].bias;

      if (bias < actFunc.GetBoundLo ())
      {
        nL [ln].n [nCurr].bias = actFunc.GetBoundUp () - (actFunc.GetBoundLo () - bias);  // reflect from the bottom border 
      }
      else
        if (bias > actFunc.GetBoundUp ())
        {
          nL [ln].n [nCurr].bias = actFunc.GetBoundLo () + (bias - actFunc.GetBoundUp ());  // reflect from the upper border
        }
    }
  }

  // 3. Update weights using ADAM ---------------------------------
  for (int lw = 0; lw < wLC; lw++)
  {
    for (int nCurr = 0; nCurr < layersSize [lw]; nCurr++)
    {
      for (int nNext = 0; nNext < layersSize [lw + 1]; nNext++)
      {
        deltaNext = nL [lw + 1].n [nNext].delta;
        out       = nL [lw].n [nCurr].out;
        double gradient = deltaNext * out;

        // Update moments for weights
        wL [lw].nOnL [nCurr].nOnR [nNext].m = beta1 * wL [lw].nOnL [nCurr].nOnR [nNext].m + (1.0 - beta1) * gradient;
        wL [lw].nOnL [nCurr].nOnR [nNext].v = beta2 * wL [lw].nOnL [nCurr].nOnR [nNext].v + (1.0 - beta2) * gradient * gradient;

        // Adjust weight moments
        double m_hat = wL [lw].nOnL [nCurr].nOnR [nNext].m / (1.0 - pow (beta1, t));
        double v_hat = wL [lw].nOnL [nCurr].nOnR [nNext].v / (1.0 - pow (beta2, t));

        // Update weight
        wL [lw].nOnL [nCurr].nOnR [nNext].w += alpha * m_hat / (sqrt (v_hat) + epsilon);
        w = wL [lw].nOnL [nCurr].nOnR [nNext].w;

        if (w < actFunc.GetBoundLo ())
        {
          wL [lw].nOnL [nCurr].nOnR [nNext].w = actFunc.GetBoundUp () - (actFunc.GetBoundLo () - w);  // reflect from the lower border
        }
        else
          if (w > actFunc.GetBoundUp ())
          {
            wL [lw].nOnL [nCurr].nOnR [nNext].w = actFunc.GetBoundLo () + (w - actFunc.GetBoundUp ());  // reflect from the upper border
          }
      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

では、先ほどと同じテストを繰り返し、得られた結果を確認します。現在は、重みの発散はなく、学習中に誤差が雪崩のように増大することもありません。

シグモイド活性化関数の結果の表

SiLU型活性化関数の結果表

周期的活性化関数の結果の表

まとめ

では、研究をまとめましょう。実験の趣旨を改めて振り返ります。私たちは、同じ論理に基づく2つの最適化アルゴリズムを用いましたが、根本的に異なる方法で動作します。1つ目（従来のADAM）は、ニューラルネットワーク内部から動作する組み込みのオプティマイザで、活性化関数や内部構造全体に直接アクセスできます。まるで詳細な地図を持ったナビゲータのようです。2つ目（集団型ADAMm）は、ニューラルネットワークを「ブラックボックス」として扱う外部オプティマイザで、内部構造やタスクの詳細情報は持たず、星や大まかな方向を頼りに進む旅行者のようです。

両方のアルゴリズムの対象として同じニューラルネットワークを使用しました。これは非常に重要です。なぜなら、特定の活性化関数で問題が発生した場合、その原因がニューラルネットワーク自体ではなく、最適化アルゴリズムがこれらの関数とどのように相互作用するかにあると確信できるからです。

この実験の構成により、異なる最適化アプローチにおける活性化関数の性能を明確に観察できます。重要なのは、ネットワークの一般化能力や新しいデータでの性能は意図的に考慮していない点です。私たちの目的は、活性化関数と最適化アルゴリズムの相互作用、その互換性および効率を研究することです。

このアプローチにより、外的要因の影響を排除した上で、異なる最適化戦略が異なる活性化関数に対してどのように動作するかを明確に把握できます。実験結果は、時には「盲目的な」外部オプティマイザが、ネットワーク構造の全情報を持つアルゴリズムよりも効率的である場合があることを示しています。

すべての活性化関数において、外部ADAMmは高速かつ安定的に収束し、活性化関数の特性がそれほど重要ではないことを示唆しています。一方で、従来型の組み込みADAMは深刻な問題に直面しました。

次に、各活性化関数における組み込みADAMの挙動を確認し、以下の結論にまとめます。

1. 問題のある関数（停滞または収束が遅い）

• TanH（双曲線正接）
• AlgSigm（代数的シグモイド）
• SERF（シグモイド加重指数直線化）
• Snake（周期関数）

2. 成功したケース（収束）

• RatSigm（有理シグモイド）、シグモイド関数の中で最良
  
• SoftPlus
• BentIdent
  
• SiLU (Swish)、第2グループのベスト
  
• ACON（適応関数）、周期関数の中で最良
  

3. パターン

古典的なシグモイド関数（TanH、AlgSigm）は停滞の問題を示します。より現代的な適応関数（ACON、SiLU）はより良い収束を示します。周期関数の中では、ACONは収束しますが、Snakeは停滞します。

このように、本研究は、重みの制御、活性化関数の境界、学習プロセスを一つの相互接続されたシステムに統合する、ニューラルネットワーク最適化の包括的アプローチを展開します。主な革新は、各活性化関数が自身の境界を定義できるGetBoundUpおよびGetBoundLoメソッドの導入であり、これを用いてネットワークの重みを管理します。この仕組みは、境界に達した際の合計値の早期終了システムと補完的に機能し、大規模ネットワークでの冗長な計算を防ぐだけでなく、活性化関数適用前に値を制御することも可能にします。

特に重要な要素は重み反射メカニズムで、従来のプルーニングや正規化とは異なり、重みが限界に達した際に「揺さぶる」ことで学習の停滞を防ぎます。この解決策により、重大な状況下でも重みを変更可能とし、学習プロセスの連続性を確保します。これらの要素の統合により、学習の柔軟性を損なわずに重みの発散を防ぐ効果的な仕組みが構築され、異なる活性化関数に対応する場合にも重要です。この統合アプローチは、単に重み制御の問題を解決するだけでなく、学習中のニューラルネットワーク構成要素の相互作用理解にも新たな視点を開きます。

本研究は、ADAMがニューラルネットワーク学習に無用であることを示すものではなく、特定の活性化関数に対する挙動に注目しています。おそらく、大規模ニューラルネットワークにおいては（現代的な勾配降下法の類似アルゴリズムを除き）他に代替手段が存在しない可能性があります。これは、ADAM（バックプロパゲーションを用いた現代的最適化アルゴリズムの代表）における効率性の検討や、大規模ネットワークにおける活性化関数の選択がネットワークの一般化能力や新規データでの安定性に与える影響の研究の次の課題となり得ます。

記事で使用されているプログラム