ディープラーニング: オートエンコーダの基礎と種類

ディープラーニングが私たちの社会に大きな影響を与えようとしていることは明らかです。 Mobibit の創設者兼 CEO である Pramod Chandrayan 氏は最近、codeburst.io にオートエンコーダーの基礎と種類を紹介し、コード例を提供する記事を公開しました。

[[204722]]

前回の記事「ディープラーニングとは何か、なぜなのか?」(https://goo.gl/Ka3YoF) に引き続き、今日はディープラーニングのアーキテクチャの種類を詳しく見ていき、オートエンコーダについて詳しく説明します。

人間の脳がディープラーニングマシンと連携すると、次のようになります。

ディープネットワークの謎を解く前に、まずディープラーニングを定義しましょう。私の理解では：

ディープラーニングは、相互に通信する複数の抽象レイヤーがあり、各レイヤーが前のレイヤーと深く接続され、前のレイヤーからの出力に基づいて決定を下す高度な機械学習手法です。

Investopedia ではディープラーニングを次のように定義しています。

ディープラーニングは、人工知能 (AI) の分野における機械学習のサブセットであり、ネットワークのような構造を持ち、非構造化データやラベルなしデータから教師なしで学習することができます。ディープニューラルラーニングまたはディープニューラルネットワークとも呼ばれます。

今日は、教師なし関連ネットワークがどのように機能するかを詳しく見ていきます。

UPN: 教師なし事前学習ネットワーク

この教師なし学習ネットワークはさらに以下のように分類できる。

オートエンコーダ
ディープビリーフネットワーク（DBN）
生成的敵対ネットワーク (GAN)

オートエンコーダは、入力層、隠し層 (エンコード層)、デコード層の 3 つの層を持つニューラルネットワークです。ネットワークの目標は、入力を再構築して、その隠れ層がその入力の適切な表現を学習することです。

オートエンコーダニューラルネットワークは、バックプロパゲーションを適用してターゲット値を入力値と等しく設定する、教師なし機械学習アルゴリズムです。オートエンコーダのトレーニングの目的は、入力を出力にコピーすることです。内部的には、入力を特徴付けるために使用されるコードを記述する隠しレイヤーがあります。

オートエンコーダの目的は関数h(x)≈xを学習することです。言い換えれば、出力 x^ が入力 x とほぼ等しくなるように近似恒等関数を学習します。オートエンコーダはニューラルネットワークのファミリーに属しますが、PCA (主成分分析) とも密接に関連しています。

オートエンコーダに関する重要な事実:

これはPCAに似た教師なし機械学習アルゴリズムである。
PCAと同じ目的関数を最小化する
それはニューラルネットワークです
このニューラルネットワークの目標出力は入力である

オートエンコーダは PCA に似ていますが、PCA よりもはるかに柔軟性があります。エンコード処理中、オートエンコーダは線形変換と非線形変換の両方を表すことができますが、PCA は線形変換のみを実行できます。オートエンコーダのネットワーク表現形式により、ディープラーニングネットワークを構築するためのレイヤーとして使用できます。

オートエンコーダの種類:

ノイズ除去オートエンコーダ
スパースオートエンコーダ
変分オートエンコーダ (VAE)
収縮オートエンコーダ (CAE)

A. ノイズ除去オートエンコーダ

これは最も基本的なタイプのオートエンコーダーであり、破損した入力をランダムに部分的に採用して恒等関数リスクを解決し、オートエンコーダーが回復またはノイズ除去を実行する必要があります。

このテクニックを使用すると、入力を適切に表現できます。適切な表現とは、破損した入力から確実に取得でき、対応するノイズのない入力を復元するために使用できる表現です。

ノイズ除去オートエンコーダの背後にある考え方は単純です。隠れ層に、より堅牢な特徴を発見させ、単にアイデンティティを学習することを防ぐため、破損したバージョンから入力を再構築するようにオートエンコーダをトレーニングします。

入力に適用されるノイズの量はパーセンテージで表されます。一般的には 30% または 0.3 が適切ですが、データが非常に少ない場合は、ノイズをさらに追加することを検討してください。

スタック型ノイズ除去オートエンコーダー (SDA):

これは、レイヤー上で教師なし事前トレーニングメカニズムを使用するノイズ除去オートエンコーダーです。レイヤーが事前トレーニングされて、前のレイヤーの入力に対して特徴選択と特徴抽出が実行された後、教師あり微調整フェーズが続きます。 SDA は、多くのノイズ除去オートエンコーダーを融合したものです。最初の k 層がトレーニングされると、下の層に基づいてコードまたは潜在表現を計算できるため、k+1 番目の層をトレーニングできます。

すべてのレイヤーが事前トレーニングされると、ネットワークは微調整と呼ばれる段階に入ります。ここでは、教師あり学習メカニズムを使用して微調整を行い、教師ありタスクの予測誤差を最小限に抑えます。次に、多層パーセプトロンをトレーニングするのと同じ方法で、ネットワーク全体をトレーニングします。この段階では、各オートエンコーダのエンコード部分のみを考慮します。この段階は監督されており、今後はターゲットクラスをトレーニングに使用します。

コード例によるSDAの説明

このセクションは deeplearning.net (ディープラーニングを理解したい人にとって素晴らしいリファレンス) からの抜粋です。ここでは、スタックされたノイズ除去オートエンコーダーが例を使用してわかりやすく説明されています。

スタックされたノイズ除去オートエンコーダーは、2 つの方法で考えることができます。1 つ目はオートエンコーダーのリストとして、2 つ目は多層パーセプトロン (MLP) としてです。事前トレーニング中は、モデルをオートエンコーダーのリストとして扱い、各オートエンコーダーを個別にトレーニングする最初のアプローチを使用しました。 2 番目のトレーニングフェーズでは、2 番目のアプローチを使用します。これら 2 つのアプローチは次の理由で関連しています。

オートエンコーダのシグモイド層と MLP はパラメータを共有します。

MLP の中間層によって計算された潜在表現は、オートエンコーダへの入力として使用されます。

クラスSdA(オブジェクト):  
 「スタック型ノイズ除去オートエンコーダクラス (SdA)」  
スタック型ノイズ除去オートエンコーダモデルは、複数の 
 dAの層`i`の隠れ層は、  
層 `i+1` の dA。最初の層 dA は入力として次の入力を受け取ります。  
 SdA であり、最後の dA の隠れ層が出力を表します。  
事前学習後、SdAは通常のMLPとして扱われることに注意してください。  
 dA は重みを初期化するためにのみ使用されます。  
 「」
デフ__init__(  
自己、  
 numpy_rng、  
 theano_rng =なし、  
 n_ins = 784 、  
隠しレイヤーのサイズ= [500, 500],  
 n_outs = 10 、  
破損レベル= [0.1, 0.1]  
 ):  
 """ このクラスは、可変数のレイヤーをサポートするために作成されています。
 :type numpy_rng: numpy.random.RandomState
 :param numpy_rng: 初期値を生成するために使用されるnumpy乱数ジェネレータ 
重み 
 :type theano_rng: theano.tensor.shared_randomstreams.RandomStreams  
 :param theano_rng: Theano乱数ジェネレータ。Noneが指定された場合は 
 `rng` から抽出されたシードに基づいて生成される 
 :type n_ins: int
 :param n_ins: sdAへの入力の次元 
 :type hidden_layers_sizes: intのリスト 
 :param hidden_layers_sizes: 中間層のサイズ。  
少なくとも1つの値 
 :type n_outs: int  
 :param n_outs: ネットワークの出力の次元 
 :type corruption_levels: float のリスト 
 :param corruption_levels: それぞれに使用する破損の量 
層 
 「」  
自己.シグモイドレイヤー= []
自己.dA_レイヤー= []  
自己パラメータ= []  
 self.n_layers = len (隠しレイヤーのサイズ)  
 self.n_layers > 0 をアサートする
そうでない場合 theano_rng:
 theano_rng =ランダムストリーム(numpy_rng.randint(2**30))  
 # データにシンボリック変数を割り当てる 
 self.x = T .matrix('x') # データはラスタライズされた画像として表示されます 
 self.y = T .ivector('y') # ラベルは1次元ベクトルとして表されます 
 # [int] ラベル

self.sigmoid_layers はシグモイド層を MLP の形式で保存し、self.dA_layers はその MLP 層に関連付けられたノイズ除去オートエンコーダーを保存します。次に、n_layers のシグモイド層と n_layers のノイズ除去オートエンコーダを構築します。ここで、n_layers はモデルの深さです。多層パーセプトロンで導入されたHiddenLayerクラスを使用しますが、1つの変更点があります。tanh非線形性をロジスティック関数に置き換えます。

シグモイド層を連鎖させて MLP を構築し、各オートエンコーダのエンコード部分が対応するシグモイド層と重み行列とバイアスを共有するようにオートエンコーダを構築しました。

 i が範囲内(self.n_layers)の場合:  
 # シグモイド層を構築する 
 # 入力のサイズは隠れユニットの数か 
 # 下のレイヤー、または最初のレイヤーの場合は入力サイズ 
 i == 0 の場合:  
入力サイズ= n_ins    
それ以外：  
入力サイズ=隠しレイヤーのサイズ[i - 1]  
 # この層への入力は、隠れ層の活性化か 
 # 下のレイヤー、または最初のレイヤーにいる場合はSdAの入力 
 # レイヤー 
 i == 0 の場合:  
レイヤー入力=自己.x  
それ以外：  
レイヤー入力=自己.シグモイドレイヤー[-1].出力 
 sigmoid_layer = HiddenLayer ( rng = numpy_rng 、  
入力=レイヤー入力、  
 n_in =入力サイズ、  
 n_out =隠しレイヤーのサイズ[i],  
活性化= T .nnet.sigmoid)  
 # レイヤーをレイヤーリストに追加します 
 self.sigmoid_layers.append(シグモイドレイヤー)  
 # それはおそらく哲学的な質問です...
 # ただし、ここでは、
 # sigmoid_layersはStackedDAAのパラメータです
# dAの目に見えるバイアスは、それらのパラメータです 
 # dA だが SdA ではない 
 self.params.extend(シグモイドレイヤー.params)  
 # これと重みを共有するノイズ除去オートエンコーダを構築します 
 # レイヤー 
 dA dA_layer = dA( numpy_rng numpy_rng = numpy_rng,  
 theano_rng theano_rng =theano_rng、  
入力=レイヤー入力、  
 n_visible =入力サイズ、  
 n_hidden =隠しレイヤーのサイズ[i],  
 W =シグモイド層.W、  
 bhid =シグモイド層.b)  
 self.dA_layers.append(dA_layer)

ここで、このシグモイド層の上にロジスティック層を追加するだけで、MLP が完成します。 Logistic Regression を使用して MNIST 数字を分類するで紹介された LogisticRegression クラスを使用します。

 # MLPの上にロジスティックレイヤーを追加する必要があります 
 self.logLayer =ロジスティック回帰(  
入力=自己.シグモイドレイヤー[-1].出力、
 n_in =隠しレイヤーのサイズ[-1],  
 n_out = n_outs    
 ）
自己のパラメータを拡張します(自己のログレイヤーのパラメータ)  
 # 微調整の1ステップを実装する関数を構築する 
 # トレーニングの第2フェーズのコストを計算します。  
 # 負の対数尤度として定義される 
自己self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)
 # モデルパラメータに関する勾配を計算する
# エラーの数を示すシンボリック変数 
 # self.x と self.y によって与えられたミニバッチ 
自己self.errors = self.logLayer.errors(self.y)

SdA クラスは、レイヤー内のノイズ除去オートエンコーダのトレーニング関数を生成するメソッドも提供します。これらはリストとして返されます。要素 i は、i 番目のレイヤーに対応する dA をトレーニングするための手順を実装する関数です。

事前トレーニング関数を定義します(self、train_set_x、batch_size):  
 ''' 関数のリストを生成し、それぞれが1つの関数を実装する。  
同じインデックスを持つレイヤーに対応する dA をトレーニングするステップ。  
この関数はミニバッチインデックスを入力として必要とし、訓練するために 
 dAの場合は、対応する関数を呼び出し、反復するだけです。
すべてのミニバッチインデックス。
 :type train_set_x: theano.tensor.TensorType  
 :param train_set_x: 使用されるすべてのデータポイントを含む共有変数 
 dAのトレーニング用 
 :type バッチサイズ: int  
 :param batch_size: [ミニ]バッチのサイズ
:type 学習率: float  
 :param learning_rate: トレーニング中に使用される学習率。  
 dA層
'''  
 # [ミニ]バッチのインデックス 
 index = T .lscalar('index') # ミニバッチのインデックス

トレーニング中に損傷レベルまたは学習率を変更するには、それらを Theano 変数に関連付けます。

 corruption_level = T .scalar('corruption') # 使用する破損の割合 
 learning_rate = T .scalar('lr') # 使用する学習率 
 # `index` を指定してバッチを開始します 
 batch_begin =インデックス* batch_size  
 # `index` で指定されたバッチの終了 
バッチ終了=バッチ開始+ バッチサイズ 
事前トレーニングfns = []
 self.dA_layers 内の dA の場合:  
 # コストと更新リストを取得する 
コスト、更新= dA.get_cost_updates (corruption_level、  
学習率 
 # theano関数をコンパイルする 
 fn = theano.function (  
入力=[  
索引、  
 theano.In(破損レベル、値= 0 .2)、  
 theano.In(学習率、値= 0 .1)  
 ]、  
出力=コスト、  
アップデートアップデート=アップデート、  
与えられたもの= {  
 self.x: train_set_x[バッチ開始:バッチ終了]  
 }  
 ）  
 # 関数のリストに `fn` を追加します 
 pretrain_fns.append(fn)  
 pretrain_fnsを返す

これで、どの pretrain_fns[i] 関数も、オプションで corruption (破損レベル) または lr (学習率) を含むインデックスパラメータを受け取ることができるようになりました。これらのパラメータ名は、Theano 変数が構築されたときに付けられた名前であり、Python 変数の名前 (learning_rate または corruption_level) ではないことに注意してください。これは、Theano を使用するときに留意しておくべき重要な点です。同様に、微調整時に必要な関数（train_fn、valid_score、test_score）を構築するためのメソッドも構築しました。

 def build_finetune_functions(self、データセット、バッチサイズ、学習率):  
 '''1ステップを実装する関数`train`を生成します 
微調整、エラーを計算する関数「validate」  
検証セットからのバッチと関数「test」  
テストセットからバッチのエラーを計算する 
 :type データセット: theano.tensor.TensorType のペアのリスト
:param datasets: すべてのデータセットを含むリストです。  
には3つのペア「train」が含まれている必要があります。  
 `valid`、`test` の順で、各ペアは 
 2つのTheano変数で構成され、1つは 
データポイント用とラベル用 
 :type バッチサイズ: int  
 :param batch_size: ミニバッチのサイズ
:type 学習率: float
 :param learning_rate: 微調整段階で使用される学習率 
 '''  
 (train_set_x, train_set_y) = データセット[0]  
 (valid_set_x, valid_set_y) = データセット[1]  
 (test_set_x, test_set_y) = データセット[2]  
 # トレーニング、検証、テストのミニバッチの数を計算します 
 n_valid_batches = valid_set_x .get_value(借用= True ).shape[0]  
 n_valid_batches //= バッチサイズ 
 n_test_batches = test_set_x .get_value(借用= True ).shape[0]  
 n_test_batches //= バッチサイズ 
 index = T .lscalar('index') # [ミニ]バッチのインデックス 
 # モデルパラメータに関する勾配を計算する 
 gparams = T .grad(self.finetune_cost, self.params)  
 # 微調整更新のリストを計算する 
アップデート= [  
 (param、param - gparam * 学習率)  
 param、gparam は zip(self.params, gparams) 内 
 ]  
 train_fn = theano.function (  
入力= [インデックス],  
出力= self.finetune_cost 、  
アップデートアップデート=アップデート、  
与えられたもの= {  
自己.x: トレーニングセットx[
インデックス * バッチサイズ: (インデックス + 1) * バッチサイズ 
 ]、  
 self.y: トレーニングセットy[  
インデックス * バッチサイズ: (インデックス + 1) * バッチサイズ 
 ]  
 },  
 ）  
 test_score_i = theano .function(  
 [索引]、  
自己エラー、  
与えられたもの= {  
自己.x: テストセットx[  
インデックス * バッチサイズ: (インデックス + 1) * バッチサイズ 
 ]、  
 self.y: テストセットy[  
インデックス * バッチサイズ: (インデックス + 1) * バッチサイズ 
 ]  
 },  
 ）  
 valid_score_i = theano .function(  
 [索引]、  
自己エラー、  
与えられたもの= {  
自己.x: 有効なセットx[  
インデックス * バッチサイズ: (インデックス + 1) * バッチサイズ 
 ]、  
自己.y: 有効な_set_y[  
インデックス * バッチサイズ: (インデックス + 1) * バッチサイズ 
 ]  
 },  
 ）  
 # 検証セット全体をスキャンする関数を作成する 
有効なスコアを定義する():  
 [iが範囲内(n_valid_batches)の場合、valid_score_i(i)] を返します。  
 # テストセット全体をスキャンする関数を作成する 
テストスコア()を定義します:
 [test_score_i(i) を i が範囲内(n_test_batches)] の場合に返す 
 train_fn、valid_score、test_scoreを返す

valid_score と test_score は Theano 関数ではなく、それぞれ検証セット全体とテストセット全体をループして、これらのセットの損失のリストを生成する Python 関数であることに注意してください。

要約する

次の数行のコードは、スタックされたノイズ除去オートエンコーダを構築します。

 numpy numpy_rng = numpy.random.RandomState(89677)  
 print('... モデルを構築しています')  
 # スタックされたノイズ除去オートエンコーダクラスを構築する 
 sda = SdA (  
 numpy_rng numpy_rng = numpy_rng、  
 n_ins = 28 * 28、  
隠しレイヤーのサイズ= [1000, 1000, 1000],  
 n_outs = 10    
 ）

ネットワークは、レイヤーごとの事前トレーニングとそれに続く微調整の 2 段階でトレーニングされます。

事前トレーニング段階では、ネットワークのすべてのレイヤーをループします。各レイヤーでは、SGD ステップを実装するコンパイル済み関数を使用して重みを最適化し、そのレイヤーの再構築コストを削減します。この関数は、pretraining_epochs に従って、トレーニングセットに対して固定数のエポックを実行します。

 #########################
 # モデルの事前トレーニング #  
 #########################  
 print('...事前トレーニング関数を取得しています')  
 pretraining_fns = sda.pretraining_functions ( train_set_x train_set_x =train_set_x,
 batch_size batch_size =バッチサイズ)  
 print('... モデルの事前トレーニング')  
 start_time = timeit.default_timer () です。  
 ## レイヤーごとに事前トレーニングする 
破損レベル= [.1, .2, .3]  
 i が範囲内(sda.n_layers)の場合:  
 # 事前トレーニングエポックを実行する 
範囲内のエポックの場合(pretraining_epochs):
 # トレーニングセットを実行する
c = []
 batch_indexが範囲内(n_train_batches)の場合:
 c.append(pretraining_fns[i](インデックス= batch_index ,  
腐敗=腐敗レベル[i],  
 lr = pretrain_lr ))  
 print('事前トレーニング層 %i、エポック %d、コスト %f' % (i, epoch, numpy.mean(c, dtype = 'float64' )))  
 end_time = timeit .default_timer()
 print(('ファイル'の事前トレーニングコード+
 os.path.split(__file__)[1] +
 ' %.2fm 実行' % ((end_time - start_time) / 60.))、ファイル= sys.stderr )

ここでの微調整サイクルは、多層パーセプトロンの微調整プロセスと非常によく似ています。唯一の違いは、build_finetune_functions によって指定された関数を使用することです。

コードの実行

ユーザーは、次の Python CLI を呼び出してコードを実行できます。

 Python コード/SdA.py

デフォルトでは、コードはバッチサイズ 1 で各レイヤーに対して 15 回の事前トレーニングエポックを実行します。第 1 層のダメージレベルは 0.1、第 2 層は 0.2、第 3 層は 0.3 です。事前トレーニングの学習率は 0.001、微調整の学習率は 0.1 です。事前トレーニングには 585.01 分かかり、エポックあたり平均 13 分でした。微調整には 36 エポックと 444.2 分かかり、1 エポックあたり平均 12.34 分でした。 *** の検証スコアは 1.39%、テストスコアは 1.3% です。これらの結果は、シングルスレッド GotoBLAS を搭載した Intel Xeon E5430 @ 2.66GHz CPU を搭載したマシンで取得されました。

原文: https://codeburst.io/deep-learning-types-and-autoencoders-a40ee6754663

[この記事は51CTOコラム「Machine Heart」、WeChatパブリックアカウント「Machine Heart（id:almosthuman2014）」によるオリジナル翻訳です]

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

<<: 王の英雄を見極める – PM の機械学習初心者の旅

>>: ディープラーニングにおける多体問題の解決方法