ニューラルネットワークアルゴリズムを使用した C# での手書き数字認識

デモをダウンロード - 2.77 MB (元のアドレス)

手書き文字認識.zip

ソースコードをダウンロード - 70.64 KB (元のアドレス)

nn手書き文字ソース.zip

導入

これは、Mike O'Neill による素晴らしい記事「手書き数字の認識のためのニューラルネットワーク」に基づいて、人工ニューラルネットワークを使用して手書き数字の認識を実装する例です。過去数年間に多くのシステムや分類アルゴリズムが提案されてきましたが、手書き認識はパターン認識において依然として困難なタスクです。 Mike O'Neill のプログラムは、ニューラルネットワークアルゴリズム、特にニューラルネットワークの畳み込み部分による一般的な手書き認識について学習したいプログラマーにとって優れた例です。このプログラムは MFC/C++ で書かれているので、慣れていない人にとっては少し難しいです。そこで、いくつかのプログラムを C# で書き直すことにしました。私のプログラムは良い結果を達成しましたが、まだ優れているわけではありません (収束速度、エラー率などの点で)。しかし、これはプログラムの基本に過ぎず、目的はニューラルネットワークの理解を助けることなので、少し乱雑で再構築する必要があります。私はこれをライブラリとして再構築しようとしています。これにより、INI ファイルを通じてパラメータを柔軟かつ簡単に変更できるようになります。いつか望み通りの結果が達成できることを願っています。

文字検出

パターン検出と文字候補検出は、私のプログラムで直面しなければならない最も重要な問題の 1 つです。実際、私は Mike のプログラムを別のプログラミング言語で再実装したいだけでなく、文書画像内の文字を認識したいと思っています。インターネットで見つけた非常に優れた物体検出アルゴリズムを提案する研究がいくつかありますが、私のような趣味のプロジェクトには複雑すぎます。娘に絵を教えているときに発見した方法がこの問題を解決しました。もちろん、まだ制限はありますが、最初のテストでは期待を上回る結果となりました。通常、文字候補の検出は、行検出、単語検出、文字検出に分かれており、それぞれ異なるアルゴリズムが使用されます。私のアプローチはこれとは少し異なります。検出には同じアルゴリズムが使用されます:

公共 静的矩形 GetPatternRectangeBoundary
    (ビットマップ オリジナル、 int colorIndex、 int hStep、 int vStep、bool bTopStart)

同様に：

公共 静的リスト<Rectangle> パターンRectangeBoundaryList
    (ビットマップオリジナル、 int colorIndex、 int hStep、 int vStep、
    bool bTopStart、 int widthMin、 int heightMin)

パラメータ hStep (水平ステップ) と vStep (垂直ステップ) を変更することで、行、単語、または文字を簡単に検出できます。 bTopStart を true または false に変更することで、長方形の境界を上から下、左から右に検出することもできます。長方形は widthMin と d によって制約されます。私のアルゴリズムの最大の利点は、同じ行にない単語や文字列を検出できることです。

文字候補の認識は次のように実現できます。

パブリックvoid パターン認識スレッド(ビットマップ ビットマップ)
     {
         _originalBitmap = ビットマップ;
         _rowList == nullの場合
         {
             _rowList = AForge.Imaging.Image.パターン矩形境界リスト
     (_originalBitmap、255、30、1、 true 、5、5);
             _irowインデックス = 0; 
 
         }
         foreach(_rowList内の四角形 rowRect )
         {
             _currentRow = AForge.Imaging.ImageResize.ImageCrop
     (_originalBitmap、行Rect);
             _iwordIndex == 0 の場合
             {
                 _currentWordsList = AForge.Imaging.Image.PatternRectangeBoundaryList
         (_currentRow、255、20、10、 false 、5、5);
             } 
 
             foreach ( _currentWordsList内のRectangle wordRect)
             {
                 _currentWord = AForge.Imaging.ImageResize.ImageCrop
         (_currentRow、wordRect);
                _iwordインデックス++;
                 _icharIndex == 0 の場合
                 {
                     _現在の文字リスト =
         AForge.Imaging.Image.PatternRectangeBoundaryList
         (_currentWord, 255, 1, 1, false , 5, 5);
                 } 
 
                 foreach ( _currentCharsList内の四角形 charRect)
                 {
                     _currentChar = AForge.Imaging.ImageResize.ImageCrop
         (_currentWord、charRect);
                    _icharインデックス++;
                     ビットマップ bmptemp = AForge.Imaging.ImageResize.FixedSize
         (_currentChar, 21, 21);
                     bmptemp = AForge.Imaging.Image.CreateColorPad
         (bmptemp、色.白、4、4);
                     bmptemp = AForge.Imaging.Image.CreateIndexedGrayScaleBitmap
             (bmptemp);
                     byte[] graybytes = AForge.Imaging.Image.GrayscaletoBytes(bmptemp);
                     パターン認識スレッド(graybytes);
                     m_bitmaps.Add (bmptemp) ;
                 }
                 文字列 s = " \n" ;
                 _form.Invoke(_form._DelegateAddObject、新しいオブジェクト[] { 1、s });
                       _icharIndex ==_ currentCharsList.Countの場合
                       {
                       _icharインデックス =0;
                       }
              }
              If(_iwordIndex==__ currentWordsList.Count )の場合
              {
                       _iwordインデックス=0;
              }
         }

文字認識

元のプログラムの畳み込みニューラルネットワーク (CNN) には、基本的に入力層を含めて 5 つの層があります。畳み込みアーキテクチャの詳細については、Mike と Simard 博士の論文「ビジュアルドキュメント分析のための畳み込みニューラルネットワークの最新技術」で説明されています。この畳み込みネットワークの全体的なスキームは、単純な特徴を高解像度で抽出し、それをより低い解像度の複雑な特徴に変換することです。より低い解像度を生成する最も簡単な方法は、サブレイヤーを 2 倍にサブサンプリングすることです。これは、畳み込みカーネルのサイズの参照を提供します。カーネルの幅は、1 つのユニット (奇数サイズ) を中心として選択され、情報が失われない程度のオーバーラップ (1 つのユニットに対して 3 のオーバーラップは小さすぎます) があり、冗長になりすぎません (7 のオーバーラップは大きすぎます。5 のオーバーラップでは 70% を超えるオーバーラップが実現されます)。したがって、このネットワークでは畳み込みカーネルのサイズとして 5 を選択します。入力をパディングする（特徴セルが境界の中央にくるように入力を大きくする）と、パフォーマンスは大幅に向上しません。したがって、パディングは使用されず、サブサンプリングのためにカーネルサイズは 5 に設定され、各畳み込み層は特徴サイズを n から (n-3)/2 に縮小します。 MNIST の初期入力画像サイズは 28x28 なので、2 回目の畳み込み後に生成される整数サイズはおよそ 29x29 になります。 2 層の畳み込みの後、5x5 の特徴サイズは 3 層目の畳み込みには小さすぎます。 Simard 博士はまた、最初のレイヤーの機能が 5 つ未満の場合、パフォーマンスが低下し、5 つを超えてもパフォーマンスは向上しないことを強調しました (Mike は 6 つを使用しました)。同様に、2 番目のレイヤーでは、50 個未満の機能ではパフォーマンスが低下しましたが、それ以上 (100 個) の機能では改善は見られませんでした。ニューラルネットワークの概要は次のとおりです。

レイヤー #0: MNIST データベースからの手書き文字のグレースケール画像。29 x 29 ピクセルにパディングされています。入力層には 29x29 = 841 個のニューロンがあります。

レイヤー #1: 6 つの特徴マップを持つ畳み込みレイヤーです。ニューロンは 13×13×6 = 1014 個、重みは (5×5+1)×6 = 156 個、レイヤー #1 から前のレイヤーへの接続は 1014×26 = 26364 個あります。

レイヤー 2: 50 個の特徴マップを持つ畳み込みレイヤーです。ニューロンは 5x5x50 = 1250 個、重みは (5x5 + 1)x6x50 = 7800 個、レイヤー #2 から前のレイヤーへの接続は 1250x(5x5x6 + 1) = 188750 個あります。

(Mike の記事にある 32500 の接続ではありません)。

レイヤー #3: 100 ユニットを持つ完全接続レイヤーです。ニューロンは 100 個、重みは 100 x (1250 + 1) = 125100 個、接続は 100 x 1251 = 125100 個あります。

レイヤー #4: 最も大きく、10 個のニューロン、10×(100+1)=1010 個の重み、10×101=1010 個の接続を備えています。

バックプロパゲーション

バックプロパゲーションは、最後のレイヤーから始めて最後のレイヤーに到達するまで前進し、各レイヤーでの重みの変化を更新するプロセスです。

標準的なバックプロパゲーションでは、各重みは次の式に従って更新されます。

（１）

ここで、eta は「学習率」であり、通常は 0.0005 のような小さな数値で、トレーニング中に徐々に減少します。ただし、収束が遅いため、このプログラムでは標準的なバックプロパゲーションは使用されません。代わりに、LeCun 博士が論文「Efficient BackProp」で提案した「Randomized Diagonal Levenberg-Marquardt」と呼ばれる 2 次手法が適用されます。Mike は、これは標準的なバックプロパゲーションと同じではないと述べていますが、この理論は私のような初心者がコードをより簡単に理解するのに役立つはずです。

Levenberg-Marquardt 法では、rw は次のように計算されます。

二乗コスト関数が次の通りであると仮定します。

勾配は次のようになります。

ヘッセン人は以下の規則に従います。

ヘッセ行列の簡略化された近似はヤコビ行列であり、これは N×O 次元の半行列です。

ニューラルネットワークでヘッセ行列の対角成分を計算するためのバックプロパゲーション手順はよく知られています。ネットワーク内の各層には次のものがあると仮定します。

（７）

ガウス-ニュートン近似（|'(y)を含む項を削除）を使用すると、次の式が得られます。

（８）

（9）

同様に：

ランダム対角レーベンバーグ・マルカート法

実際、完全なヘッセ行列情報を使用する手法 (Levenberg-Marquardt、Gaus-Newton など) は、ランダムモードではなくバッチモードでトレーニングされた非常に小さなネットワークにのみ適用できます。レベンバーグ・マルカートアルゴリズムのランダムパターンを得るために、ルカン博士は、各パラメータに関する2次導関数の推定値を操作してヘッセ行列の対角線を計算するというアイデアを提案しました。瞬間的な2次微分は、式(7,8,9)に示すように、逆伝播法によって得ることができる。これらの運用推定値があれば、それを使用して各パラメータの個別の学習率を計算できます。

ここでeはグローバル学習率であり、

は、h ki に関する対角2次微分の演算推定値です。 m は、2 次導関数が小さい場合 (つまり、最適化がエラー関数の平坦な部分で行われる場合) に hki がドリフトするのを防ぐパラメーターです。 2 次導関数は、トレーニングセットのサブセット (トレーニングセットの 500 個のランダムパターン / 60000 個のパターン) で計算できます。これらは非常にゆっくりと変化するため、数サイクルごとに再推定するだけで済みます。元のプログラムでは、対角ヘッセ行列はサイクルごとに再推定されます。

以下は C# の 2 次導関数計算関数です。

パブリックvoid BackpropagateSecondDerivatives(DErrorsList d2Err_wrt_dXn /* in */,
                                                    DErrorsList d2Err_wrt_dXnm1 /*出力*/)
 {
    // 名前 (NeuralNetwork クラスから継承)
    // 注意: ここでは2次微分（1次微分ではない）を扱っていますが、
    // しかし、1階微分があるのとほぼ同じ表記法を使用します
    // 同じです。そうでないと、ASCII 表示が誤解を招くことになります。 我々は
    // 簡略化のため、"d2Err_wrt_dXn" のように 2 つの "2" の代わりに "2" を使用します。
    // 2次微分を使うことを強調するだけです
    //
    // Errはニューラルネットワーク全体の出力誤差です
    // Xn は n 番目の層の出力ベクトルです
    // Xnm1は前の層の出力ベクトルです
    // Wn は n 番目の層の重みのベクトルです
    // Ynはn番目の層の活性化値です。
    // つまり、squeeze関数を適用する前の入力の加重合計です
    // F は圧縮関数です: Xn = F(Yn)
    // F'はスクイーズ関数の導関数である
    // 簡単に言うと、F = tanh の場合、F'(Yn) = 1-Xn^2 となり、
    // 入力を知らなくても出力から導関数を計算できる
  
整数ii,jj;
    uint kk;
 intインデックス;
ダブル 出力;
ダブルdTemp; 
  
    var d2Err_wrt_dYn = 新しい DErrorsList( m_Neurons.Count );
    //
    // std::vector< double > d2Err_wrt_dWn( m_Weights.size ( ), 0.0 );
    //ゼロに初期化することが重要です
    //////////////////////////////////////////////////
    //
    ///// デザインのトレードオフ：レビュー!!
    //
    // この命名規則はNNLayer::Backpropagate()と同一であることに注意してください
    // 関数と同じ推論、つまりこの関数から派生した関数
    // BackpropagateSecondDerivatives() 関数
    //
    // 配列 "d2Err_wrt_dWn" には STL ベクトルを使用します (コーディングを簡単にするため)
    // は、レイヤー内の現在のモードのエラー重みの 2 次微分です。 しかし、
    // 多くの重みを持つレイヤー (完全に接続されたレイヤーなど) には、多くの重みもあります。 ポイント
    // 大きなメモリブロックを割り当てる場合、STLベクトルクラスアロケータは非常に愚かで、多くのページエラーを引き起こします。
    // 表面的なエラーが発生し、アプリケーション全体の実行時間が遅くなります。 
  
    // この問題を解決するために、通常のC配列を使用しようとしました。
    // ヒープから必要なスペースを取得し、関数の最後で [] を削除します。
    // ただし、これによりページフォールトエラーの数は同じになり、
    // パフォーマンスは向上しません。 
  
    // そこで、スタック (つまりヒープではない) に通常の C 配列を割り当ててみました。
    // もちろん、 double d2Err_wrt_dWn[m_Weights.size ( )];と書くことはできません。
    // コンパイラは、配列サイズに対してコンパイル時の既知の定数値を要求するためです。
    // この必要性を回避するために、_alloca 関数を使用してスタック上にメモリを割り当てます。
    // これを実行すると、スタックが過剰に使用され、スタック オーバーフローの問題が発生する可能性があるという欠点があります。
    // それが「レビュー」という名前が付けられた理由です
 
  
ダブル[] d2Err_wrt_dWn = 新しいダブル[ m_Weights.Count ];
 (ii = 0; ii < m_Weights.Count ; ++ii)の場合
    {
        d2Err_wrt_dWn[ii] = 0.0;
    }
    // 計算 d2Err_wrt_dYn = ( F'(Yn) )^2 *
    // dErr_wrt_Xn (ここで、dErr_wrt_Xn は実際には 2 次導関数です) 
  
 (ii = 0; ii < m_Neurons.Count ; ++ii)の場合
    {
出力= m_Neurons[ii] .output ;
        dTemp = m_sigmoid.DSIGMOID(出力);
        d2Err_wrt_dYn.Add (d2Err_wrt_dXn[ii] * dTemp * dTemp) ;
    }
    // d2Err_wrt_Wn = (Xnm1)^2 * d2Err_wrt_Yn を計算します
    // (ここで、dE2rr_wrt_Yn は実際には 2 次導関数です)
    // この層の各ニューロンを前の層を介して接続します
    // リストし、対応する重みの差を更新します
  
    ii = 0;
    foreach (NNNeuron nit in m_Neurons)
    {
        foreach (NNConnection は nit.m_Connectionsにあります)
        {
            試す
            {
                 kk = (uint)cit.NeuronIndex;
                (kk == 0xffffffff)の場合
                {
出力= 1.0;
                    // これは暗黙的な接続です。暗黙的なニューロンは「1」を出力します。
                }
それ以外 
                {
出力= m_pPrevLayer.m_Neurons[( int )kk] .output ;
                } 
  
                // ASSERT( (*cit).WeightIndex < d2Err_wrt_dWn.size () );
                // d2Err_wrt_dWnをCスタイルに変更すると
                // 配列の後では、 size ()関数は機能しません
 
                d2Err_wrt_dWn[cit.WeightIndex] = d2Err_wrt_dYn[ii] *出力*出力;
            }
            catch (例外例)
            { 
  
           }
        } 
  
        ii++;
    }
    // d2Err_wrt_Xnm1 = (Wn)^2 * d2Err_wrt_dYn を計算します
    // (ここで、d2Err_wrt_dYn は最初の 2 次導関数です)。
    // d2Err_wrt_Xn として d2Err_wrt_Xnm1 が必要です
    // 2次微分の逆伝播の入力値
    // 次の（つまり前のスペース）レイヤーの場合
    // この層の各ニューロンについて
  
    ii = 0;
    foreach (NNNeuron nit in m_Neurons)
    {
        foreach (NNConnection は nit.m_Connectionsにあります)
        {
            試す
            {
                ニューロンインデックス
                (kk != 0xffffffff) の場合
                {
        // 定数出力「1」を表す ULONG_MAX は除外します。
        // 仮想バイアスニューロン。バイアスニューロンを実際に訓練することはできないため
  
                    nIndex = ( int )kk;
                    dTemp = m_Weights[( int )cit.WeightIndex].value;
                    d2Err_wrt_dXnm1[nIndex] += d2Err_wrt_dYn[ii] * dTemp * dTemp;
                }
            }
            catch (例外例)
            {
戻る;
            }
        } 
  
        ii++; // ii はニューロン反復子を追跡します
    }
古い値と新しい値を二重に保持します。 
  
    //***、dErr_wrt_dW を使用して対角レイヤーを更新します
    // ニューロンの重み。設計上、この機能は
    // そして、多くの（約500パターン）にわたる反復は
    // 単一のスレッドがニューラルネットワークをロックしている間に呼び出し、
    // したがって、別のスレッドが Hessian の値を変更することはできません。
    // しかし、これは簡単に実行できるので、
    // アトミックな比較と交換の操作。つまり、別のスレッドが
    // おそらく2次導関数の逆伝播中、およびヘッセ行列
    // 少し動くかもしれない
  
 ( jj = 0; jj < m_Weights.Count ; ++jj)の場合
    {
        古い値 = m_Weights[jj].diagHessian;
        新しい値 = 古い値 + d2Err_wrt_dWn[jj];
        m_Weights[jj].diagHessian = 新しい値;
    }
 }
 //////////////////////////////////////////////////////////////////

トレーニングと実験

MFC/C++ と C# の間には互換性がないにもかかわらず、私のプログラムは元のプログラムと似ています。 MNIST データベースを使用して、ネットワークは 60,000 のトレーニングセットパターンのうち 291 件の誤認を実行しました。つまり、エラー率はわずか 0.485% です。しかし、10,000 パターンのうち 136 個が誤認され、エラー率は 1.36% でした。結果は基本テストほど良くはありませんが、自分の手書き文字セットで実験するには十分です。入力画像はまず上から下に向かって文字グループに分割され、次に各グループ内の文字が左から右に向かって検出され、29x29 ピクセルにサイズ変更されて、ニューラルネットワークシステムによって認識されます。このソリューションは私の基本的な要件を満たしており、手書きの数字も正しく認識できます。使いやすさを向上させるために、AForge.Net の画像処理ライブラリに検出機能を追加しました。しかし、これは余暇にプログラミングしただけなので、修正が必要なバグがたくさんあると思います。時間の経過によるバックプロパゲーションがその一例です。各エポックでは約 3800 秒のトレーニング時間がかかりますが、実際には 2400 秒しかかかりません。 (私のコンピューターは Intel Pentium Dual-Core E6500 プロセッサを使用しています)。マイクのプログラムと比べると、かなり遅いです。また、手書き文字のより優れたデータベースを作成したり、他の人と協力して実験を継続したり、自分のアルゴリズムを使用して実際のアプリケーションを開発したりしたいと考えています。

オリジナルリンク: https://www.codeproject.com/Articles/143059/Neural-Network-for-Recognition-of-Handwritten-Di

著者: Vietdungiitb

[この記事は51CTOコラムニスト「雲家コミュニティ」によるオリジナル記事です。転載の許可を得るには51CTOを通じて原作者に連絡してください]

この著者の他の記事を読むにはここをクリックしてください

<<: 2018年に人工知能がビジネスに及ぼす10のインパクト

>>: ブロックチェーン投資の10大リスクポイント。これらを理解していないなら投資しないでください！