ディープラーニング 04-CNN クラシック モデル

導入

畳み込みニューラル ネットワーク (CNN) は、深層学習において非常に重要なネットワーク構造であり、画像、テキスト、音声などのさまざまな種類のデータを処理できます。以下は CNN の上位 4 つの古典的なモデルです。

1. ルネット-5

LeNet-5 は、1998 年に Yann LeCun らによって提案され、手書き数字認識への適用に成功した最初の畳み込みニューラル ネットワークでした。これは、2 つの畳み込み層、2 つのプーリング層、3 つの完全接続層を含む 7 層のニューラル ネットワークで構成されています。このうち、畳み込み層は画像の特徴を抽出し、プーリング層は特徴マップの次元を削減し、全結合層は特徴を対応するカテゴリにマッピングします。

LeNet-5 の主な特徴は、シグモイド活性化関数の使用、平均プーリング、畳み込み層後のゼロ パディングがないことです。手書き数字認識や顔認識などの分野で広く利用されています。

2. アレックスネット

AlexNet は、2012 年に Alex Krizhevsky らによって提案されました。これは、大規模な画像認識タスクで重要な結果を達成した最初の畳み込みニューラル ネットワークです。これは、5 つの畳み込み層、3 つの全結合層、および ReLU 活性化関数、最大プーリング、ドロップアウト テクノロジーを使用する 1 つの Softmax 出力層で構成されます。

AlexNet の主な特徴は、GPU 加速トレーニング、データ強化、ランダム化ドロップアウトなどのテクノロジーの使用であり、モデルの汎化能力と堅牢性が大幅に向上します。ImageNetの大規模画像認識コンペティションにおいて他機種を大きく上回る優秀な成績を収めました。

3. VGGネット

VGGNet は、2014 年に Karen Simonyan と Andrew Zisserman によって提案されました。これは、16 または 19 層からなる非常に深い畳み込みニューラル ネットワークです。VGGNet の各畳み込み層は 3x3 畳み込みカーネルと ReLU アクティベーション関数を使用しているため、ネットワーク構造が非常に明確で理解しやすくなっています。

VGGNet の主な特徴は、より深いネットワーク構造、小さな畳み込みカーネル、および少数のパラメーターの使用であり、これによりモデルの特徴抽出機能がさらに向上します。ImageNet コンペティションでも非常に良い成績を収めました。

4. GoogLeNet

GoogLeNet は、2014 年に Google チームによって提案されました。これは、22 層からなる非常に深い畳み込みニューラル ネットワークです。ネットワークの深さを維持しながらパラメータの数を削減できるインセプション モジュールと呼ばれる構造を使用します。

GoogLeNet の主な特徴は、インセプション モジュール、1x1 コンボリューション カーネル、およびグローバル平均プーリング テクノロジの使用であり、これによりモデルの計算の複雑さが大幅に軽減されます。ImageNet コンペティションで非常に良い成績を収め、他の分野でも広く使用されています。

CNNのレビュー

CNN のいくつかの機能 (ローカル認識、パラメーター共有、プーリング) を確認してみましょう。

地元の認識

人間の外界の認識は一般に、局所的なものから全体的なものへ、一面的なものから包括的なものへと変化するのと同様に、機械が画像を認識する場合、画像全体をピクセルごとにニューラルネットワークに接続する必要はありません。画像はローカルであり周辺でもあります。ピクセルは密接に接続されていますが、遠く離れたピクセル間の相関は弱いため、ローカル接続モードを使用できます (画像をブロック単位で接続し、画像のパラメーターを大幅に削減できます)。モデル)、次の図に示すように:

パラメータ（重み）の共有

すべての自然画像 (人物、風景、建物など) には独自の固有の特性があります。つまり、画像のある部分の統計的特性は他の部分に似ています。これは、このパートで学習した特徴を別のパートでも使用でき、同じ学習した特徴を使用できることも意味します。したがって、ローカル接続では、隠れ層の各ニューロンがローカル画像の重みパラメータ (たとえば、5×5) を接続し、これらの重みパラメータが他の残りのニューロンと共有されます。多くのニューロンをトレーニングする必要がありますか? トレーニングする必要があるパラメーターは、このローカル画像の権限パラメーター (たとえば、5×5) であり、これはコンボリューション カーネルのサイズです。これにより、トレーニング パラメーターが大幅に削減されます。以下に示すように

コンボリューション カーネルの重みは、各コンボリューション カーネルのパラメータを指します。これらのパラメータは、入力データに対してコンボリューション演算を実行するときに、各位置のピクセルの重み付き合計を実行するために使用されます。畳み込みニューラル ネットワークでは、同じ層内のすべての畳み込みカーネルの重みが共有されます。これは、異なる位置にある各畳み込みカーネルの重みが同じであることを意味します。重みを共有すると、モデル内で学習する必要があるパラメータの数が減り、それによってモデルの複雑さが軽減されると同時に、重みの共有によってモデルがより安定し、過学習を避けてください。共有重みは、同じ畳み込みカーネルを使用して入力データに対して畳み込み演算を実行することによって実装されます。

プーリング

モデル ネットワークが深化し続けるにつれて、コンボリューション カーネルの数はますます増え、トレーニングすべきパラメータは依然として多く、さらに、コンボリューション カーネルによって抽出された特徴を使用した直接トレーニングでは、過学習が発生する傾向があります。画像から特徴を抽出するために畳み込みが使用されるのは、画像が「静的」な属性を持っているためであるため、代表的な特徴を抽出する (最大値や平均値などの集計統計を実行する) のは自然な考え方です。この集約操作はプーリングと呼ばれ、以下に示すように、プーリング プロセスは通常、特徴マッピング プロセス (特徴次元削減) とも呼ばれます。

ルネット-5

概要
LeNet5 は 1994 年に誕生した最も初期の畳み込みニューラル ネットワークの 1 つで、Yann LeCun によって完成され、深層学習分野の発展を促進しました。当時、モデルのトレーニングに役立つ GPU はなく、CPU 速度さえも非常に遅かったため、LeNet5 は、畳み込み、パラメーター共有、プーリングなどの操作を使用して、賢明な設計によって特徴を抽出し、多大なコンピューティング コストを回避しました。このネットワークは、最近の多数のニューラル ネットワーク アーキテクチャの出発点でもあり、この分野に多くのインスピレーションをもたらしました。
LeNet5 のネットワーク構造図は以下の通りです

LeNet5 は 7 層の CNN (入力層を除く) で構成されています 上図の入力元画像サイズは 32×32 ピクセルです 畳み込み層は Ci、サブサンプリングは層 (プーリング、プーリング) ) は Si で表され、全結合層は Fi で表されます。以下に、その機能と回路図の上にある数字の意味をレイヤーごとに紹介します。

C1層（畳み込み層）：6@28×28

この層は 6 つのコンボリューション カーネルを使用し、各コンボリューション カーネルのサイズは 5×5 であるため、6 つの特徴マップが得られます。
(1) 特徴マップのサイズ
各コンボリューションカーネル (5×5) が元の入力画像 (32×32) と畳み込み演算されるため、得られる特徴マップのサイズは (32-5+1) ×( 32-5+ 1) = 28x28 の
コンボリューション プロセスを次の図に示します (下の図はデモンストレーションのためのみ 4*4 です): コン

ボリューション カーネルと入力画像は、コンボリューション カーネルのサイズに応じて領域ごとに照合されます。エッジ コンボリューション カーネルは範囲外に出ることができず、マッチングは 1 回しかできないため、入力画像のサイズは小さくなります。上図に示すように、マッチング計算後のサイズは Cr×Cc=(Ir-Kr) となります。 +1)×(Ic-Kc+1)。ここで、Cr、Cc、Ir、Ic、Kr、Kc はそれぞれ、畳み込み結果画像、入力画像、畳み込みカーネルの行サイズと列サイズを表します。
このうち、Cr は結果の行、Cc は結果列の列を表します
(2) パラメータの数 パラメータ
(重み)の共有により、同じコンボリューションカーネルの各ニューロンは同じパラメータを使用します。パラメータは (5×5+1)×6= 156 です。5×5 は畳み込みカーネル パラメータ、1 はバイアス パラメータです。 (3) 畳み込み後の画像サイズは 28×28 なので、各特徴マップは 28×28 になります
。
ニューロンの場合、各畳み込みカーネル パラメーターは (5×5+1)×6 であるため、この層の接続数は (5×5+1)×6×28×28=122304 となります。

S2層（ダウンサンプリング層、プーリング層とも呼ばれる）：6@14×14

(1) 特徴マップのサイズ
この層は主にプーリングまたは特徴マッピング (特徴の次元削減) に使用され、プーリング単位は 2×2 であるため、プーリング後の 6 つの特徴マップのサイズは 14×14 になります。この記事の冒頭で述べたプーリング操作を振り返ると、プーリング単位間に重複はなく、新しい特徴量はプーリング領域で統計を集計した後に取得されるため、2×2 プーリング後は 2 行ごとに 2 行ごとに特徴量が出ると画像サイズが半分になるので、畳み込み後の28×28画像は2×2プーリングすると14×14になります。
この層の計算プロセスは次のとおりです。2×2 ユニットの値を加算し、トレーニング パラメーター w とバイアス パラメーター b を乗算します (各特徴マップは同じ w と b を共有します)。シグモイド値 (S 関数: 0-1 間隔) を単位の対応する値として受け取ります。畳み込み演算とプーリングの概念図は以下のとおりです:

(2) パラメータの数S2 層の各特徴マップは同じ 2 つのパラメータ w と b を共有するため、
2×6=12 個のパラメータが必要です
(3) 接続数
サンプリング後の画像サイズは 14×14 なので、S2 層の各特徴マップには 14×14 個のニューロンがあり、各プーリング ユニットの接続数は 2×2+1 (1 はオフセット) となります。層内の接続数は (2×2+1)×14×14×6 = 5880

C3層（畳み込み層）：16@10×10

C3 層には 16 個のコンボリューション カーネルがあり、コンボリューション テンプレートのサイズは 5×5 です。
(1) 特徴マップのサイズ
C1 層の解析と同様に、C3 層の特徴マップのサイズは、(14-5+1) × (14-5+1) = 10 × 10 (2)必要な
パラメータの数は、
C3 と S2 は完全に接続されているわけではなく、部分的に接続されていることに注意してください。C3 から S2 に 3 層で接続されているもの、4 層で接続されているもの、さらには 6 層で接続されているものもあります。このようにして、より多くの特徴が抽出されます。接続規則は次のとおりです。たとえば、最初の列は、

C3 層の 0 番目の特徴マップが S2 層の 0 番目、1 番目、および 2 番目の特徴マップにのみ接続されていることを示します。計算プロセスは次のとおりです: 3 つの畳み込みテンプレートを使用して、 S2 層の 3 つの特徴マップとそれぞれ接続します。特徴マップは畳み込みされ、畳み込み結果が加算および合計され、さらにオフセットが加えられ、シグモイドが取得されて畳み込み後に対応する特徴マップが取得されます。他の列も同様です (畳み込みテンプレートが 3 つある列、4 つある列、6 つある列もあります)。したがって、層 C3 のパラメータの数は、(5×5×3+1)×6 + (5×5×4+1)×9 +5×5×6+1 = 1516 となります。

(3) 接続数：
畳み込み後の特徴マップのサイズは 10×10、パラメータ数は 1516 なので、接続数は 1516×10×10= 151600

S4 (ダウンサンプリング層、プーリング層とも呼ばれます): 16@5×5

(1) 特徴マップのサイズ
S2 の解析と同様に、プーリングユニットのサイズは 2×2 であるため、この層には C3 と同様に合計 16 個の特徴マップがあり、各特徴マップのサイズは 5×5 になります。
(2) パラメータ数
S2 の計算と同様に必要なパラメータ数は 16×2 = 32
(3) 接続数 接続
数は (2×2+1)×5×5×16 = 2000

C5層（畳み込み層）：120

(1) 特徴マップのサイズ
この層には 120 個のコンボリューション カーネルがあり、各コンボリューション カーネルのサイズは 5×5 のままであるため、120 個の特徴マップがあります。S4 層のサイズは 5 × 5 であり、この層のコンボリューション カーネル サイズも 5 × 5 であるため、特徴マップのサイズは (5-5+1) × (5-5+1) = 1 × 1 となります。 。このように、レイヤーが完全に接続された状態になりますが、これは単なる偶然であり、元の入力画像が比較的大きい場合、レイヤーは完全に接続されていません。
(2) パラメータ数
先ほどの解析と同様に、この層のパラメータ数は 120×(5×5×16+1) = 48120
(3) 接続数
この層の特徴マップのサイズは正確に 1×1 なので、接続数は 48120×1×1=48120 となります。

F6層（全結合層）：84

1) 特徴マップ サイズ
F6 レイヤーには 84 ユニットがあります。この数値を選択した理由は、次の図に示すように、7×12 ビットマップに対応する出力レイヤーの設計によるものです。-1 は白、1 は白を意味しますblack 。各シンボルのビットマップの黒と白がコードに対応します。

この層には 84 個の特徴マップがあり、特徴マップのサイズは C5 と同じ 1×1 で、C5 層と完全に接続されています。
(2) パラメータ数
全結合なので、パラメータ数は(120+1)×84=10164となります。古典的なニューラル ネットワークと同様に、F6 レイヤーは入力ベクトルと重みベクトルの間のドット積を計算し、バイアスを追加して、それをシグモイド関数に渡して結果を取得します。
(3) コネクション数
フルコネクションのため、コネクション数はパラメータ数と同じ 10164 となります。

OUTPUTレイヤー（出力レイヤー）：10

出力層も、それぞれ 0 ～ 9 の数字を表す合計 10 個のノードを持つ全結合層です。i 番目のノードの値が 0 であれば、ネットワーク識別の結果が番号 i であることを意味します。
(1) 特徴マップサイズ
この層は放射基底関数 (RBF) ネットワーク接続方式を採用しており、前層の入力を x 、RBF の出力を y とすると、RBF 出力の計算方法は、上記 Wij となります。

式 値は、0 ～ 9 の範囲の i と、0 ～ 7×12-1 の値を取る j のビットマップ エンコードによって決定されます。RBF 出力値が 0 に近づくほど、現在のネットワーク入力の認識結果は文字 i に近づきます。

(2) パラメータ数
フルコネクションなのでパラメータ数は84×10=840
(3) コネクション数
フルコネクションなのでコネクション数はパラメータも 840 です。

上記の紹介を通じて、LeNet ネットワークの各層の構造、機能マップのサイズ、パラメーターの数、接続の数、その他の情報について学習しました。次の図は、番号 3 を識別するプロセスです。上記の紹介に従って、各層の機能を 1 つずつ説明します。

プログラミングの実装

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
import numpy as np
#开启tensorflow支持numpy函数，astype是numpy的函数
from tensorflow.python.ops.numpy_ops import np_config
np_config.enable_numpy_behavior()
# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
ori_x_test1=x_test

# 将图像从28*28转换成32*32
x_train = tf.pad(x_train, [[0,0], [2,2], [2,2]], mode='constant')
x_test = tf.pad(x_test, [[0,0], [2,2], [2,2]], mode='constant')

# 将像素值缩放到0-1之间
x_train, x_test = x_train.astype('float32') / 255.0, x_test.astype('float32') / 255.0

# 定义Lenet-5模型
model = models.Sequential([
    # 第一层卷积层，6个卷积核，大小为5*5，使用sigmoid激活函数
    layers.Conv2D(6, (5, 5), activation='relu', input_shape=(32, 32, 1)),
    # 第一层池化层，大小为2*2
    layers.MaxPooling2D((2, 2)),
    # 第二层卷积层，16个卷积核，大小为5*5，使用sigmoid激活函数
    layers.Conv2D(16, (5, 5), activation='relu'),
    # 第二层池化层，大小为2*2
    layers.MaxPooling2D((2, 2)),
    # 第三层卷积层，120个卷积核，大小为5*5，使用sigmoid激活函数
    layers.Conv2D(120, (5, 5), activation='relu'),
    # 将卷积层的输出拉平
    layers.Flatten(),
    # 第一层全连接层，84个节点，使用sigmoid激活函数
    layers.Dense(84, activation='relu'),
    # 输出层，共10个节点，对应0-9十个数字，使用softmax激活函数
    layers.Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])



#取出其中一个测试数据进行测试
testdata = ori_x_test1[100]
testdata = testdata.reshape(-1,28,28)
testdata = tf.pad(testdata, [[0,0], [2,2], [2,2]], mode='constant')
testdata=testdata.reshape(-1, 32, 32, 1)
# 将像素值缩放到0-1之间
testdata = testdata.astype('float32') / 255.0
predictions = model.predict(testdata)
print("预测结果：", np.argmax(predictions))

# 绘制第10个测试数据的图形
plt.imshow(ori_x_test1[100], cmap=plt.cm.binary)
plt.show()

出力:
テスト損失: 0.03826029598712921
テスト精度: 0.9879999756813049
予測結果: 6

参考:https://my.oschina.net/u/876354/blog/1632862

アレックスネット

2012 年、Alex Krizhevsky と Ilya Sutskever は、トロント大学の Geoff Hinton の研究室で深層畳み込みニューラル ネットワーク AlexNet を設計し、2012 ImageNet LSVRC チャンピオンシップで優勝し、その精度率は 2 位 (トップ 5 エラー率 15.3%) を大きく上回りました。 、2位は26.2％）と大きな反響を呼びました。AlexNet は、歴史的に重要なネットワーク構造であると言えます。それまで、深層学習は長い間沈黙していました。2012 年の AlexNet の誕生以来、その後の ImageNet チャンピオンはすべて畳み込みニューラル ネットワーク (CNN) を使用してきました。そして層ますます深くなり、CNN が画像認識と分類の中核となるアルゴリズム モデルとなり、ディープ ラーニングの爆発的な普及をもたらしています。
このブログの以前の記事では、畳み込みニューラル ネットワーク (CNN) の技術原則 (Dahua 畳み込みニューラル ネットワーク) を紹介し、畳み込みニューラル ネットワーク (CNN) の 3 つの重要な特性 (Dahua CNN クラシック モデル: LeNet) についても確認しました。興味のある学生はリンクを開いてもう一度確認してください。ここでは CNN の基礎知識の紹介を繰り返しません。以下では、まず AlexNet の特徴を紹介し、次に AlexNet のネットワーク構造を層ごとに分解して分析します。

AlexNetモデルの特徴

AlexNet の成功は、主に次のようなこのモデル設計の特性に関連しています。

• 非線形活性化関数：ReLUを使用
• 過学習を防ぐ方法: ドロップアウト、データ拡張
• その他: マルチ GPU 実装、LRN 正規化層の使用

1. ReLU 活性化関数を使用する
従来のニューラル ネットワークでは、励起関数として Sigmoid や Tanh などの非線形関数が一般的に使用されていましたが、勾配分散や勾配飽和が発生しやすい傾向がありました。シグモイド関数を例にとると、入力値が非常に大きいか非常に小さい場合、これらのニューロンの勾配は 0 に近くなります (勾配飽和現象)。入力の初期値が大きい場合、バックプロパゲーション中に勾配を乗算する必要があります。最後のシグモイド導関数により、勾配がますます小さくなり、ネットワークの学習が困難になります。(詳細については、ブログの記事「深層学習でよく使用される励起関数」を参照してください)。
AlexNet では、ReLU (Rectified Linear Units) 励起関数が使用されます。この関数の公式は次のとおりです: f (x)=max (0,x). 入力信号 < 0 の場合、出力は 0 です。 > 0 の場合、次の図に示すように、出力は入力と等しくなります。

ReLU を使用して Sigmoid/tanh を置き換えます。ReLU は線形で導関数が常に 1 であるため、計算量が大幅に削減され、次の図に示すように Sigmoid/tanh よりも収束速度が大幅に速くなります

。

ニューラル ネットワークはデータによってフィードされるという見方がありますが、学習データを増やし、学習用に大量のデータを提供できれば、過学習を回避し、ネットワークの構造をさらに拡大し深化させることができるため、アルゴリズムの精度を効果的に向上させることができます。トレーニング データが制限されている場合、トレーニング データを迅速に拡張するために、いくつかの変換を通じて既存のトレーニング データ セットからいくつかの新しいデータを生成できます。
その中で、画像データを変形する最も単純かつ一般的な方法は、次の図に示すように、画像の水平反転、ランダムなトリミング、変換変換、元の画像からの色と照明の変換です。 トレーニング中に、AlexNet は次のようなデータ拡張を実行します。

この処理:
(1) ランダム クロップ。256×256 の画像を 224×224 にランダムにクロップしてから水平に反転します。これは、サンプル数を ((256-224)^2)×2=2048 増やすことに相当します。 (2)テスト
中、左上、右上、左下、右下、中央をそれぞれ 5 回トリミングし、反転して合計 10 カットを実行し、結果を平均しました。著者は、ランダムなトリミングが行われない場合、大規模なネットワークは基本的に過適合になる、
(3) RGB 空間に対して PCA (主成分分析) を実行し、次に主成分に対して (0, 0.1) ガウス摂動を作成する、つまり, 色と照明を変更したところ、さらに1%エラー率が下がりました。

3. オーバーラッププーリング.
一般的なプーリングはオーバーラップしません. 以下の図に示すように、プーリング領域のウィンドウ サイズはステップ サイズと同じです:

AlexNet で使用されるプーリングはオーバーラップすることができます。各移動のサイズはプーリング ウィンドウの長さよりも小さくなります。AlexNet のプーリング サイズは 3×3 の正方形で、各プーリングの移動ステップ サイズは 2 であるため、重複が生じます。重複プーリングにより過剰適合を回避でき、この戦略によりトップ 5 エラー率 0.3% が達成されました。
4. Local Response Normalization（略してLRN）
神経生物学には「側方抑制」（側方抑制）と呼ばれる概念があり、活性化されたニューロンが隣接するニューロンを抑制することを意味します。正規化の目的は「抑制」です。ローカル正規化は、ローカル抑制を実現するために「サイド抑制」の考え方を利用します。特にReLUを使用する場合、ReLUの応答結果は無制限であるため、この「サイド抑制」は非常に役立ちます(非常に大きくなる可能性があるため)、正規化が必要です。局所正規化を使用するスキームは、一般化能力を高めるのに役立ちます。
LRN の式は次のとおりです。中心となるアイデアは、正規化に隣接するデータを使用することです。この戦略により、トップ 5 のエラー率 1.2% が達成されます。

5. ドロップアウト
ドロップアウトは主に過学習を防ぐために導入されます。ニューラル ネットワークでは、ドロップアウトはニューラル ネットワーク自体の構造を変更することによって実現されます。ある層のニューロンについては、定義された確率でニューロンが 0 に設定されます。このニューロンは、ニューラル ネットワークと同様に、順方向および逆方向の伝播には関与しません。入力層と出力層のニューロン数を変更せずに、ネットワーク内の を削除し、ニューラル ネットワークの学習方法に従ってパラメーターを更新します。次の反復では、トレーニングが終了するまで、いくつかのニューロンがランダムに削除されます (0 に設定されます)。
Dropout は AlexNet における大きな革新とみなされるべきであり、「ニューラル ネットワークの父」ヒントンがスピーチで長い間 Dropout を使用したほどです。ドロップアウトはモデルの組み合わせとしても見ることができます。毎回生成されるネットワーク構造は異なります。複数のモデルを組み合わせることで、過学習を効果的に軽減できます。ドロップアウトは、モデルの組み合わせ (平均化と同様) 効果を達成するのに必要なトレーニング時間は 2 倍だけで、非常に効率的です。
以下の図に示すように:

6. マルチ GPU トレーニング
AlexNet はトレーニングに GTX580 GPU を使用しました。単一の GTX 580 GPU には 3 GB のメモリしかないため、その上でトレーニングされるネットワークの最大サイズが制限されるため、その半分のメモリを配置しました。コア (またはニューロン) は、並列コンピューティングのためにネットワークを 2 つの GPU に分散し、AlexNet のトレーニングを大幅に高速化します。

AlexNet ネットワーク構造のレイヤーごとの分析

以下の図は AlexNet のネットワーク構造図です:

AlexNet のネットワーク構造は合計 8 層あり、最初の 5 層は畳み込み層、次の 3 層は全結合層で、最後の全結合層の出力が渡されます。クラス ラベルの 1000 個の分布に対応する 1000 方向のソフトマックス層に変換します。
AlexNet はトレーニングに 2 つの GPU を使用するため、ネットワーク構造図は 2 つの部分で構成されます: 1 つの GPU はグラフの上の層を実行し、もう 1 つの GPU はグラフの下の層を実行します。2 つの GPU は特定の層でのみ通信します。たとえば、2 番目、4 番目、および 5 番目の畳み込み層のカーネルは、同じ GPU 上の前の層のカーネル特徴マップにのみ接続され、3 番目の畳み込み層は 2 番目の層のすべてのカーネル特徴マップに接続され、全結合層 のニューロンは、前の層のすべてのニューロンに接続されています。

AlexNet 構造は、以下でレイヤーごとに分析されます。

第1層（畳み込み層）

この層の処理の流れは、Convolution→ReLU→Pooling→Normalization となり、フローチャートは以下のようになります:

(1) Convolution
入力の元の画像サイズは 224×224×3 (RGB 画像) . トレーニング時は227×227×3に前処理されます。この層では、96 個の 11×11×3 コンボリューション カーネルがコンボリューション計算に使用され、新しいピクセルが生成されます。2 つの GPU が並列演算に使用されるため、ネットワーク構造図の上部と下部がそれぞれ 48 個のコンボリューション カーネルの演算を担当します。
コンボリューション カーネルは、画像に沿って x 軸および y 軸方向に特定のステップ サイズで移動してコンボリューションを計算し、新しい特徴マップを生成します。そのサイズは、floor ((img_size - filter_size)/stride) です。 +1 = new_feture_size、floor は切り捨てを意味し、img_size は画像サイズ、filter_size はカーネル サイズ、stride はステップ サイズ、new_feture_size は畳み込み後の特徴マップのサイズです。この式は、画像サイズから畳み込みを引いたものを意味します。カーネル サイズをステップ サイズで割った値にカーネル サイズを加算した値。減算されたカーネル サイズ ピクセルは、生成された 1 つのピクセルに対応し、その結果が畳み込み後の特徴マップのサイズになります。
AlexNetにおけるこの層の畳み込み移動ステップサイズは4ピクセルであり、畳み込みカーネルの移動計算後に生成される特徴マップのサイズは(227-11)/4+1=55、つまり55×55となる。
(2)
ReLU 畳み込み後の 55×55 ピクセル レイヤーを ReLU ユニットで処理して活性化ピクセル レイヤーを生成しますが、そのサイズは 55×55×48 ピクセル レイヤー データ 2 セットのままです。
(3) RuLU をプーリングした後のピクセル層
に対してプーリング操作が行われます。プーリング操作のサイズは 3×3、ステップ サイズは 2 です。この場合、プールされたイメージのサイズは (55-3)/2+ となります。 1=27 、つまりプール後のピクセルのサイズは 27×27×96
(4) 正規化
次に、プールされたピクセル レイヤーが正規化されます。正規化操作のサイズは 5x5 です。正規化されたピクセル サイズは変更されず、依然として 27x27x96 です。これらの 96 ピクセル レイヤーは、48 ピクセル レイヤーの 2 つのセットに分割され、それぞれが操作されます別の GPU。

第2層（畳み込み層）

この層も第 1 層と同様に、畳み込み→ReLU→プーリング→正規化という処理の流れになります。フローチャートは次のとおりです: (1) 畳み込み第 2 層の入力データ

が
出力最初のレイヤーの 27×27×96 ピクセル レイヤー (27×27×48 ピクセル レイヤーの 2 つのグループに分割され、操作のために 2 つの異なる GPU に配置されます) その後の処理を容易にするために、上下左右のエッジここに各ピクセルレイヤーの 2 ピクセル（0 で埋められます）、つまり画像のサイズは (27+2+2) × (27+2+2) になります。2層目のコンボリューションカーネルサイズは5×5、移動ステップは1ピクセル、1層目の点(1)の計算式と同じ、コンボリューションカーネル計算後のピクセル層サイズは となります。 (27+2+2-5)/1+1=27、つまり畳み込み後のサイズは27×27となります。
この層は 256 個の 5×5×48 コンボリューション カーネルを使用し、これも 2 つのグループに分割され、各グループは 128 で、コンボリューション演算用に 2 つの GPU に割り当てられます。結果として、27×27×128 ボリュームの 2 つのグループが作成されます。ピクセルレイヤー。
(2) ReLU
これらのピクセル層は ReLU ユニットによって処理され、活性化ピクセル層が生成されます。サイズは依然として 27×27×128 ピクセル層の 2 セットです。
(3)
次に、プーリング操作によってプーリングが処理されます。プーリング操作のサイズは 3×3、ステップ サイズは 2 です。プーリング後の画像のサイズは、(57-3)/2+1=13 になります。最終的なピクセル サイズは 13×13×128 ピクセル レイヤーの 2 つのグループ
(4) 正規
化されてから正規化されます 正規化操作のスケールは 5×5 です 正規化されたピクセル レイヤーのスケールは 13× 2 セットです13×128ピクセルレイヤーはそれぞれ2つのGPUで動作します。

第3層（畳み込み層）

第 3 層の処理の流れは、畳み込み→ReLU

(1)
畳み込みの第 3 層の入力データは、第 2 層が出力した 13×13×128 ピクセルのレイヤーを 2 グループとし、以降の処理を容易にするため、各ピクセルをレイヤー 上下左右の端を1ピクセルで塗りつぶし、塗りつぶすと(13+1+1)×(13+1+1)×128となり、2つのGPUに分散して動作します。
この層の各 GPU には 192 個のコンボリューション カーネルがあり、各コンボリューション カーネルのサイズは 3×3×256 です。したがって、各 GPU のコンボリューション カーネルは、2 セットの 13×13×128 ピクセル レイヤーのすべてのデータに対してコンボリューション演算を実行できます。この層の構造図に示すように、2 つの GPU は点線で交差して接続されています。これは、各 GPU が前の層のすべての GPU からの入力を処理することを意味します。
この畳み込み層のステップ サイズは 1 ピクセルで、畳み込み演算後のサイズは (13+1+1-3)/1+1=13、つまり合計 13×13×192 回の畳み込みがあります。各 GPU にカーネルがあり、2 つの GPU には合計 13×13×384 の畳み込みピクセル レイヤーがあります。(2) ReLU 畳み込み後のピクセル層を ReLU ユニットで処理して活性化ピクセル層を生成しますが、サイズは 13×13×192 ピクセル層を 2 グループとし、2 つの GPU に割り当てて処理します
。

第4層（畳み込み層）

第 3 層と同様に、第 4 層の処理フローは次のとおりです。 畳み込み -> ReLU

1)
畳み込みの第 4 層の入力データは、第 3 層によって出力された 13×13×192 ピクセル層の 2 つのグループです。以降の処理を容易にするため、各ピクセルレイヤーの上下左右の端を1ピクセルで塗りつぶし、塗り潰しサイズは(13+1+1)×(13+1+)となります。 1)×192、2 つの GPU 間で分散され、演算を実行します。
この層の各 GPU には 192 個のコンボリューション カーネルがあり、各コンボリューション カーネルのサイズは 3×3×192 です (第 3 層とは異なり、第 4 層の GPU 間、つまり GPU 間に点線の接続はありません)彼らの間にはコミュニケーションはありません）。畳み込みの移動ステップ サイズは 1 ピクセル、畳み込み演算後のサイズは (13+1+1-3)/1+1=13 で、各 GPU には 13×13×192 個の畳み込みカーネルがあります。 GPU コンボリューションにより、13×13×384 ピクセル レイヤーが生成されます。
(2)
ReLU 畳み込み後のピクセル層を ReLU ユニットで処理して活性化ピクセル層を生成しますが、サイズは 13×13×192 ピクセル層を 2 グループとし、2 つの GPU に割り当てて処理します。

第5層（畳み込み層）

第 5 層の処理の流れは、 Convolution → ReLU → Pooling

(1)
Convolution の第 5 層の入力データは、第 4 層が出力した 13×13×192 ピクセル層の 2 グループです。後の処理を容易にするため、各ピクセルレイヤーの上下左右の端を1ピクセルで塗りつぶし、塗りつぶしサイズは(13+1+1)×(13+1+1)となる ピクセルレイヤーデータ 2セット2 つの異なる GPU に送信され、計算が実行されます。
この層の各 GPU には 128 個のコンボリューション カーネルがあります。各コンボリューション カーネルのサイズは 3×3×192 です。コンボリューションのステップ サイズは 1 ピクセルです。コンボリューション後のサイズは (13+1 +1-3)/1+ です1=13、各 GPU には 13×13×128 のコンボリューション カーネルがあり、2 つの GPU はコンボリューション後に 13×13×256 ピクセル レイヤーを生成します。
(2)
ReLU畳み込み後のピクセル層をReLUユニットで処理して活性化ピクセル層を生成するが、サイズは13×13×128ピクセル層を2グループとし、それぞれ2つのGPUで処理する。
(3) プーリング
13×13×128 ピクセル レイヤーの 2 つのグループを 2 つの異なる GPU でそれぞれ実行し、プーリング操作のサイズは 3×3、ステップ サイズは 2、プールされた画像のサイズは ( 13- 3)/2+1=6、つまり、プール後のピクセルのサイズは、6×6×128 ピクセル レイヤー データ 2 セット、合計 6×6×256 ピクセル レイヤー データになります。

第6層（全結合層）

第 6 層の処理の流れは、畳み込み (全結合) –> ReLU –> ドロップアウト

(1) 畳み込み (全結合)
第 6 層の入力データは、サイズ 6×6 の第 5 層の出力です。 ×256。この層には合計 4096 個のコンボリューション カーネルがあり、各コンボリューション カーネルのサイズは 6×6×256 であり、コンボリューション カーネルのサイズは処理対象の特徴マップ (入力) のサイズとまったく同じであるため、つまり、コンボリューション カーネル内の各コンボリューション カーネルの係数には、特徴マップ (入力) サイズの 1 つのピクセル値のみが乗算され、1 対 1 に対応するため、この層は全結合層と呼ばれます。畳み込みカーネルと特徴マップは同じサイズなので、畳み込み演算後の値は 1 つだけとなり、畳み込み後のピクセル層のサイズは 4096×1×1、つまり 4096 個のニューロンになります。
(2)
ReLUの4096個の演算結果は、ReLU活性化機能により4096個の値を生成します。
(3) ドロップアウト
し、ドロップアウト操作を通じて 4096 個の結果値を出力します。

レイヤ 7 (完全に接続されたレイヤ)

第7層の処理フローは全結合→ReLU→ドロップアウトとなり、第

6層が出力した4096個のデータは第7層のニューロン4096個と全結合し、ReLUで処理されて4096個のデータが生成され、ドロップアウト処理後、4096個のデータが出力されます。

レイヤ 8 (完全に接続されたレイヤ)

第8層の処理フローは全結合、

第7層が出力した4096個のデータが第8層のニューロン1000個と全結合、学習後、予測結果である浮動小数点値1000個が出力される。

上は、AlexNet ネットワーク構造図のレイヤーごとの分析です。非常に複雑に見えます。これは、よりすっきりと見える簡略化された図です。前の紹介を通じて、AlexNet の特徴と革新性がわかります

。主に以下のようなものです。

プログラミングの実装

imagenet データ セットをダウンロードする
Keras が提供する keras.datasets モジュールを使用して、ImageNet データ セットを直接ロードできます。ただし、ImageNet データセットは非常に大きく、数百万の高解像度画像が含まれているため、通常は分散コンピューティングの使用または GPU でのトレーニングが必要であることに注意してください。

CIFAR-10 データ セットは、一般的に使用される画像分類データ セットで、10 カテゴリの画像が含まれています。各カテゴリには 6,000 枚の 32x32 ピクセルのカラー画像が含まれており、合計 60,000 枚の画像が含まれており、そのうち 50,000 枚がトレーニングに使用され、10,000 枚がテストに使用されます。これら 10 のカテゴリは次のとおりです。

0. 飛行機
1. 自動車
2. 鳥
3. 猫（cat）
4. 鹿（deer）
5. 犬
6. 蛙
7. 馬
8. 船（ship）
9. トラック

各画像のラベルは 0 ～ 9 の整数で、上記の 10 個のカテゴリのいずれかに対応します。したがって、これらのラベルを使用して画像分類モデルをトレーニングおよびテストできます。
次のコードを使用して、この小さなサンプル データセットを読み込むことができます。

from tensorflow.keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
print(x_train.shape)

実行後、ログにダウンロード プロセスが記録されます。ダウンロードは非常に遅いです。パス
https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
を手動でダウンロードして名前を変更できます。それを cifar-10-batches-py.tar.gz にアップロードし、~/.keras/datasets ディレクトリにアップロードします (解凍する必要はありません)。プログラムはファイルをオフラインで解凍します。ウィンドウの下に、 : C:\Users\your user. keras\datasets を

再度実行して
(50000, 32, 32, 3)を出力し
、100 個のイメージをランダムにロードして効果を確認します。

# 随机选择100张图片进行显示
indices = np.random.choice(len(x_train), size=100, replace=False)
images = x_train[indices]
labels = y_train[indices]

# 绘制图片
fig = plt.figure(figsize=(10, 10))
for i in range(10):
    for j in range(10):
        index = i * 10 + j
        ax = fig.add_subplot(10, 10, index + 1)
        ax.imshow(images[index])
        ax.set_xticks([])
        ax.set_yticks([])
        ax.set_title(labels[index][0])
plt.show()

表示

データ セットには合計 60,000 個の画像が含まれており、形式は 32 32 で、計算には Alexnet モデルを使用するため、画像を 224 224 に変換する必要があり、RGB チャネルの数は 3 で、各ピクセルは次のように変換する必要があります。 float32 を使用すると、GPU が大量のメモリを占有し、メモリ問題が発生します。オーバーフローには
ビデオ メモリ = 60000 224 224 3 4＞＝３０ＧＢが必要となる
ため、増分トレーニングが必要です

import tensorflow as tf
from tensorflow.keras.datasets import cifar10
from tensorflow.python.ops.numpy_ops import np_config
np_config.enable_numpy_behavior()
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
"""
在Python中，我们可以使用TensorFlow或Keras等深度学习框架来加载CIFAR-10数据集。为了有效地处理大量图像数据，我们可以使用生成器函数和yield语句来逐批加载数据。
生成器函数是一个Python函数，它使用yield语句来产生一个序列的值。当函数执行到yield语句时，它会将当前的值返回给调用者，并暂停函数的执行。当函数再次被调用时，它会从上一次暂停的位置继续执行，并返回下一个值。
"""
def cifar10_generator(x, y, batch_size):
    """
    CIFAR-10 data generator.
    """
    while True:
        for i in range(0, len(x), batch_size):
            x_batch = x[i:i+batch_size]
            y_batch = y[i:i+batch_size]
            x_batch = tf.image.resize_with_pad(x_batch, target_height=224, target_width=224)
            x_batch = x_batch.astype('float32') / 255.0
            yield x_batch, y_batch

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

def alexnet(input_shape, num_classes):
    model = tf.keras.Sequential([
        Conv2D(96, (11,11), strides=(4,4), activation='relu', input_shape=input_shape),
        MaxPooling2D(pool_size=(3,3), strides=(2,2)),
        Conv2D(256, (5,5), strides=(1,1), padding='same', activation='relu'),
        MaxPooling2D(pool_size=(3,3), strides=(2,2)),
        Conv2D(384, (3,3), strides=(1,1), padding='same', activation='relu'),
        Conv2D(384, (3,3), strides=(1,1), padding='same', activation='relu'),
        Conv2D(256, (3,3), strides=(1,1), padding='same', activation='relu'),
        MaxPooling2D(pool_size=(3,3), strides=(2,2)),
        Flatten(),
        Dense(4096, activation='relu'),
        Dropout(0.5),
        Dense(4096, activation='relu'),
        Dropout(0.5),
        Dense(num_classes, activation='softmax')
    ])
    return model

# 定义一些超参数
batch_size = 256
epochs = 5
learning_rate = 0.001

# 定义生成器
train_generator = cifar10_generator(x_train, y_train, batch_size)
test_generator = cifar10_generator(x_test, y_test, batch_size)

# 定义模型
input_shape = (224,224,3)
num_classes = 10
model = alexnet(input_shape, num_classes)

# 编译模型
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# 定义 ModelCheckpoint 回调函数
checkpoint = tf.keras.callbacks.ModelCheckpoint('./AlexNet.h5', save_best_only=True, save_weights_only=False, monitor='val_loss')

# 训练模型
model.fit(train_generator,
          epochs=epochs,
          steps_per_epoch=len(x_train)//batch_size,
          validation_data=test_generator,
          validation_steps=len(x_test)//batch_size,
          callbacks=[checkpoint]
          )
test_loss, test_acc = model.evaluate(test_generator, y_test)
print('Test accuracy:', test_acc)

予測結果と表示イメージ

# 在这里添加您的识别代码
model = tf.keras.models.load_model('./AlexNet.h5')
srcImage=x_test[105]
p_test=np.array([srcImage])
p_test = tf.image.resize_with_pad(p_test, target_height=224, target_width=224)
p_test = p_test.astype('float32') / 255.0
predictions = model.predict(p_test)
print("识别结果为：" + str(np.argmax(predictions)))
# 绘制第10个测试数据的图形
plt.imshow(srcImage, cmap=plt.cm.binary)
plt.show()

出力: 1

参考:https://my.oschina.net/u/876354/blog/1633143

VGGネット

2014 年、オックスフォード大学コンピューター ビジョン グループ (ビジュアル ジオメトリー グループ) と Google DeepMind の研究者は、新しい深層畳み込みニューラル ネットワーク VGGNet を開発し、ILSVRC2014 競争分類プロジェクトで 2 位を獲得しました (1 位は、これも提案された GoogLeNet でした)。同年）、ポジショニングプロジェクトで1位にランクされました。
VGGNet は、畳み込みニューラル ネットワークの深さとそのパフォーマンスの関係を調査し、16 ～ 19 層の深層畳み込みニューラル ネットワークの構築に成功し、ネットワークの深さが増すとネットワークの最終パフォーマンスに一定の影響を与える可能性があることを証明しました。速度が大幅に低下し、拡張性が非常に高く、他の画像データへの移行の汎化能力も非常に優れています。これまでのところ、VGG は画像の特徴を抽出するために依然として使用されています。
VGGNet は AlexNet の深化バージョンとみなすことができ、畳み込み層と全結合層の 2 つの部分で構成されます。

VGGの特徴

まずはVGG の構造図を見てみましょう

1. 構造はシンプルです
VGG は 5 層の畳み込み層、3 層の全結合層、ソフトマックス出力層で構成されています Max-pooling (最大化プーリング) が使用されていますすべての隠れ層 活性化ユニットはすべて ReLU 関数を使用します。
2. 小さな畳み込みカーネルと複数の畳み込みサブレイヤー
VGG は、より大きな畳み込みカーネルを備えた 1 つの畳み込み層の代わりに、より小さな畳み込みカーネル (3x3) を備えた複数の畳み込み層を使用します。より多くの非線形マッピングが実行されるため、ネットワークのフィッティング/表現能力を高めることができます。
小さな畳み込みカーネルは VGG の重要な機能です。VGG は AlexNet のネットワーク構造を模倣していますが、AlexNet のより大きな畳み込みカーネル サイズ (7x7 など) を使用せず、畳み込みカーネルのサイズ (3x3) を削減します。同じパフォーマンスを達成するために畳み込みサブレイヤーの数を増やします (VGG: 1 から 4 の畳み込みサブレイヤー、AlexNet: 1 サブレイヤー)。
VGG の著者は、2 つの 3x3 畳み込みを積み重ねることによって得られる受容野サイズは 5x5 畳み込みに相当し、3 つの 3x3 畳み込みを積み重ねることによって得られる受容野サイズは 7x7 畳み込みに相当すると考えています。これにより、次の図に示すように、非線形マッピングが増加し、パラメータも削減される可能性があります (たとえば、7x7 のパラメータは 49、3 つの 3x3 のパラメータは 27)。 3. AlexNet の 3x3 プールと比較して、小規模な

プーリング
カーネル プーリング コア、VGG はすべて 2x2 プーリング コアを使用します。
4. チャンネル数が多い
VGG ネットワークの第 1 層のチャンネル数は 64 ですが、以降の各層は 2 倍の最大 512 チャンネルとなり、チャンネル数の増加により、より多くの情報を抽出できるようになります。
5. 階層の深化と特徴マップの拡大
コンボリューションカーネルはチャネル数の拡大に重点を置き、プーリングは幅と高さの削減に重点を置くため、計算量の増加を抑えながらモデルアーキテクチャをより深く、より広くすることができます。
6. コンボリューションへの全結合（テストフェーズ）
これも VGG の特徴ですが、ネットワークテストフェーズでは、トレーニングフェーズで全結合した 3 つを 3 つのコンボリューションに置き換えます。完全に接続された制限があるため、任意の幅または高さの入力を受け入れることができます。これはテスト段階で重要です。
このセクションの最初の図に示すように、入力イメージは 224x224x3 です。次の 3 つのレイヤーがすべて完全に接続されている場合、テスト段階では、次の完全に接続されたレイヤーを満たすために、すべてのテスト イメージを 224x224x3 にスケールすることしかできません。投入量が必要なため、テスト作業の実行が不便になります。
「畳み込みに完全に接続」については、置換プロセスは次のとおりです。

たとえば、7x7x512 層を 4096 個のニューロンの層と完全に接続する必要がある場合、チャネル番号 4096 と7x7x512 層上の 1x1 のコンボリューション カーネル。
この「完全に畳み込みに接続する」というアイデアは、VGG 作者が OverFeat の実用的なアイデアを参照していることです。たとえば、下の図は、OverFeat が完全に畳み込みに接続されたものを置き換えた後、任意の解像度 (画像全体) でボリュームを計算できるため、元の画像を再スケールする必要がないという利点があります。

VGG ネットワーク構造

下の図は、論文「Very Deep Convolutional Networks for Large-Scale Image Recognition」(非常に深い畳み込みネットワークに基づく大規模画像認識) の VGG ネットワーク構造です。以下に示すように、VGG はこの論文で提案されました。

この論文では、A、A-LRN、B、C、D、E の 6 つのネットワーク構造がテストに使用されました。これら 6 つのネットワーク構造は類似しており、5 層の畳み込み層と 3 層の全結合層で構成されています。違いは、各畳み込み層のサブ層の数が異なり、A から E まで増加し (サブ層の数は 1 から 4 まで)、ネットワークの合計の深さは 11 から 19 層になります (追加された層は太字で示されています)。表内の畳み込み層パラメータは「conv⟨受容野サイズ - チャネル数」で表されます。たとえば con3-128 は、3x3 畳み込みカーネルを使用することを意味し、チャネル数は128. 簡潔にするために、ReLU アクティベーション関数は表には示されていません。
このうち、ネットワーク構造 D は有名な VGG16、ネットワーク構造 E は有名な VGG19 です。

ネットワーク構造 D (VGG16) を例に、処理プロセスを次のように紹介します。上の表と下の図を比較してください。図内の数値の変化に注目してください。VGG16 の処理プロセスを理解するのに役立ちます。 1. 224x224x3 の画像を入力します

。2 つの畳み込み + ReLU に 64 個の 3x3 畳み込みカーネルが使用された後、畳み込みサイズは 224x224x64 になります。
2. 最大プーリング (最大化プーリング) を実行し、プーリング ユニット サイズは 2x2 になります (効果は画像サイズは半分になります)、プーリング後のサイズは 112x112x64 になります。
3. 2 つの畳み込み + ReLU の 128 個の 3x3 畳み込みカーネルの後、サイズは 112x112x128 になります。 4. 2x2
最大プーリングの後、サイズは 56x56x128 になります。 5.
256 個の 3x3 畳み込みカーネルがキュービックに使用された後、サイズは 112x112x128 になります。畳み込み + ReLU、サイズは 56x56x256 になります
6. 2x2 最大プーリングが使用され、サイズは 28x28x256 になります
7. 512 個の 3x3 畳み込みカーネルが 3 次畳み込み + ReLU に使用され、サイズは 28x28x512 になります
8. 2x2 最大プーリングを実行し、サイズは 14x14x512 になります
9 512 個の 3x3 コンボリューション カーネルで 3 つのコンボリューション + ReLU を実行すると、サイズは 14x14x512 になります。
10. 2x2 最大プーリングを実行すると、サイズは 7x7x512 になります。
11. 1x1x4096 の 2 つのレイヤーと 1x1x1000 の 1 つのレイヤー (合計 3 レイヤー) でフル接続 + ReLU を実行します。
12. ソフトマックスで 1000 件の予測結果を出力

以上がVGG16(ネットワーク構造D)の各レイヤの処理プロセスですが、A、A-LRN、B、C、E、その他のネットワーク構造でも同様の処理プロセスとなります。例): 上記のプロセスから、

VGG ネットワーク構造は非常に単純で、小さな畳み込みカーネル、小さなプーリング カーネル、および ReLU で構成されていることがわかります。簡略化した図は次のとおりです (VGG16 を例にします):

6 つのネットワーク構造 A、A-LRN、B、C、D、および E の深さは 11 層から 19 層に増加しましたが、パラメータの量は増加しました。これは、基本的に小さなコンボリューション カーネル (3x3、パラメータ 9 つだけ) が使用されているためです。この 6 つの構造のパラメータ数 (数百万) は、ネットワーク内で主にパラメータが集中しているためです。ネットワーク全体の接続層。

著者は、A、A-LRN、B、C、D、および E の 6 つのネットワーク構造の単一スケール評価を実施しました。エラー率の結果は次のとおりです。 上の表から、次のことがわかります。 LRN 層 (A

-
LRN )
にパフォーマンスの向上なし VGG 著者はネットワーク A-LRN を通じて、AlexNet が使用する LRN 層 (ローカル応答正規化、ローカル応答正規化) がパフォーマンスを向上させないことを発見したため、LRN 層は表示されませんでした。ネットワークの他のグループでも。
2. 深さが増すにつれて、分類パフォーマンスは徐々に向上します (A、B、C、D、E)。11
層 A から 19 層 E まで、ネットワークの深さが増すにつれて、top1 と top5 のエラー率は大幅に減少します。
3. 複数の小さな畳み込みカーネルは、単一の大きな畳み込みカーネルよりも優れたパフォーマンスを発揮します (B)
VGG の作成者は B を使用して実験を行い、実験グループに含まれていない浅いネットワークと比較しました。浅いネットワークは conv5x5 を使用して 2 つのコンポーネントを置き換えましたB.conv3x3 の結果は、複数の小さなコンボリューション カーネルが 1 つの大きなコンボリューション カーネルよりも優れていることを示しています。

最後にまとめます:
1. 深さを増やすことでパフォーマンスを効果的に向上させることができます;
2. 最良のモデル: 最初から最後まで 3x3 の畳み込みと 2x2 のプーリングのみを備えた VGG16 はシンプルで美しいです;
3. 畳み込みは完全な畳み込みを置き換えることができます接続が可能で、さまざまなサイズの写真に適応できます

プログラミングの実装

現在、image-net から ILSVRC2014 データセットをダウンロードするには登録が必要で承認も必要なので面倒ですが、ILSVRC2017 版は Alibaba Cloud Tianchi データセット上でダウンロードできます (ログインには DingTalk または Alipay の実名認証を使用できます)。多くの大規模なデータ セットに直接ログインできます。ダウンロード)、アドレス: https://tianchi.aliyun.com/dataset/92252、ダウンロード imagenet_object_localization_patched2019 (1).tar.gz、データ セットのサイズは 155 GB です
。大きすぎるので、ここではまだ cifar10 を使用しています。

VGGNet と AlexNet は両方ともディープ ニューラル ネットワーク モデルであり、VGGNet は AlexNet よりも深いため、より多くのコンピューティング リソースとトレーニング時間が必要になります。具体的には、VGGNet には 16 または 19 のレイヤーがありますが、AlexNet には 8 レイヤーしかありません。これは、VGGNet がより多くのパラメーターとデータを処理する必要があり、より長いトレーニング時間が必要になることを意味します。さらに、VGGNet はより小さなコンボリューション カーネルを使用するため、より多くの計算が必要になります。したがって、VGGNet トレーニングが AlexNet よりもはるかに遅いのは正常です。

import tensorflow as tf
from tensorflow.keras.datasets import cifar10
from tensorflow.python.ops.numpy_ops import np_config
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.models import Sequential

np_config.enable_numpy_behavior()
(x_train, y_train), (x_test, y_test) = cifar10.load_data()


def cifar10_generator(x, y, batch_size):
    while True:
        for i in range(0, len(x), batch_size):
            x_batch = x[i:i+batch_size]
            y_batch = y[i:i+batch_size]
            x_batch = tf.image.resize_with_pad(x_batch, target_height=224, target_width=224)
            x_batch = x_batch.astype('float32') / 255.0
            yield x_batch, y_batch


def vggnet(input_shape, num_classes):
    # 定义VGGNet
    model = Sequential([
        # 第一层卷积和池化
        Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=input_shape),
        Conv2D(64, (3, 3), activation='relu', padding='same'),
        MaxPooling2D((2, 2)),

        # 第二层卷积和池化
        Conv2D(128, (3, 3), activation='relu', padding='same'),
        Conv2D(128, (3, 3), activation='relu', padding='same'),
        MaxPooling2D((2, 2)),

        # 第三层卷积和池化
        Conv2D(256, (3, 3), activation='relu', padding='same'),
        Conv2D(256, (3, 3), activation='relu', padding='same'),
        Conv2D(256, (3, 3), activation='relu', padding='same'),
        MaxPooling2D((2, 2)),

        # 第四层卷积和池化
        Conv2D(512, (3, 3), activation='relu', padding='same'),
        Conv2D(512, (3, 3), activation='relu', padding='same'),
        Conv2D(512, (3, 3), activation='relu', padding='same'),
        MaxPooling2D((2, 2)),

        # 第五层卷积和池化
        Conv2D(512, (3, 3), activation='relu', padding='same'),
        Conv2D(512, (3, 3), activation='relu', padding='same'),
        Conv2D(512, (3, 3), activation='relu', padding='same'),
        MaxPooling2D((2, 2)),

        # 将输出的特征图展平，并连接全连接层
        Flatten(),
        Dense(4096, activation='relu'),
        Dense(4096, activation='relu'),
        Dense(10, activation='softmax')
    ])

    return model

# 定义一些超参数
batch_size = 128
epochs = 5
learning_rate = 0.001

# 定义生成器
train_generator = cifar10_generator(x_train, y_train, batch_size)
test_generator = cifar10_generator(x_test, y_test, batch_size)

# 定义模型
input_shape = (224,224,3)
num_classes = 10
model = vggnet(input_shape, num_classes)
model.summary()
# 编译模型
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# 定义 ModelCheckpoint 回调函数
checkpoint = tf.keras.callbacks.ModelCheckpoint('./VGGNet.h5', save_best_only=True, save_weights_only=False, monitor='val_loss')

# 训练模型
model.fit(train_generator,
          epochs=epochs,
          steps_per_epoch=len(x_train)//batch_size,
          validation_data=test_generator,
          validation_steps=len(x_test)//batch_size,
          callbacks=[checkpoint]
          )
test_loss, test_acc = model.evaluate(test_generator, y_test)
print('Test accuracy:', test_acc)

参考:https://my.oschina.net/u/876354/blog/1634322

GoogLeNet

2014 年、GoogLeNet と VGG は、その年の ImageNet Challenge (ILSVRC14) の 2 つのヒーローでした。GoogLeNet が 1 位、VGG が 2 位を獲得しました。これら 2 種類のモデル構造の共通の特徴は、より深いことです。VGG は LeNet と AlexNet のフレームワーク構造をいくつか継承していますが、GoogLeNet はネットワーク構造においてより大胆な試みを行っています。深さはわずか 22 層ですが、そのサイズは AlexNet や VGG よりもはるかに小さいです。GoogleNet には 500 万のパラメータがあり、AlexNet には 500 万のパラメータがありますパラメータは GoogleNet の 12 倍、VGGNet のパラメータは AlexNet の 3 倍です。したがって、メモリやコンピューティング リソースが限られている場合は、GoogleNet の方が良い選択肢です。モデルの結果から判断すると、GoogLeNet のパフォーマンスは互角です。より良い。

豆知識: GoogLeNet は Google が開発したディープ ネットワーク構造です。なぜ「GoogleNet」ではなく「GoogLeNet」なのでしょうか? 「LeNet」に敬意を表して「GoogLeNet」と名付けられたそうです。

では、GoogLeNet はどのようにしてパフォーマンスをさらに向上させるのでしょうか?
一般に、ネットワークのパフォーマンスを向上させる最も直接的な方法は、ネットワークの深さと幅を増やすことです。深さとはネットワーク層の数を指し、幅はニューロンの数を指します。しかし、この方法には、
(1) パラメータが多すぎるため、学習データセットが限られていると過学習が起こりやすい (
2) ネットワークが大きくなりパラメータが増えるほど、計算量が増加し、適用の難しさ;
(3) ) ネットワークが深くなるほど、勾配の分散の問題が発生しやすく (勾配は奥に進むにつれて消滅する傾向がある)、モデルの最適化が困難になります。
したがって、「深層学習」は実際には「深層パラメータ調整」であると冗談を言う人もいます。
これらの問題を解決するには、ネットワークの深さと幅を増やしながらパラメータを削減するのが当然ですが、パラメータを削減するには、フル接続をスパース接続に変更することを考えるのが自然です。ただし、実装面では、ほとんどのハードウェアが密行列計算用に最適化されているため、フル接続からスパース接続に変更しても実際の計算量はそれほど向上しません。計算時間が非常に長く、短縮することが困難。

では、密行列の高い計算パフォーマンスを利用しながら、ネットワーク構造のスパース性を維持する方法はあるのでしょうか? 大量の文献は、疎行列をより密な部分行列にクラスタリングして計算パフォーマンスを向上させることができることを示しています。人間の脳がニューロンの繰り返しの蓄積と見なされるのと同じように、GoogLeNet チームは、インセプション ネットワーク構造を提案しました。 a 「基本ニューロン」構造は、スパースで高いコンピューティング性能のネットワーク構造を構築するために使用されます。
[ここで質問です] インセプションとは何ですか?
Inception は、V1、V2、V3、V4 などの複数のバージョンの開発を経て、常に改善されていますので、以下で順に紹介していきます。

インセプション V1

高密度データを生成できる疎ネットワーク構造を設計することにより、ニューラル ネットワークのパフォーマンスを向上させるだけでなく、コンピューティング リソースの使用効率も確保できます。Google は、オリジナルのインセプションの基本構造を提案しました。

この構造は、CNN で一般的に使用される畳み込み (1x1、3x3、5x5) とプーリング演算 (3x3) をスタックします (畳み込みとプーリング後のサイズは同じで、チャネルは Plus)。一方ではネットワークの幅が広がり、他方ではネットワークの拡張への適応性も高まります。
ネットワークの畳み込み層のネットワークは入力のあらゆる詳細情報を抽出でき、5x5 フィルターも受信層の入力の大部分をカバーできます。プーリング操作を実行して、スペース サイズを削減し、オーバーフィッティングを減らすこともできます。これらの層の上では、各畳み込み層の後に ReLU 操作が実行され、ネットワークの非線形特性が向上します。
ただし、オリジナル バージョンの Inception では、すべてのコンボリューション カーネルが前の層のすべての出力に対して実行され、5x5 コンボリューション カーネルに必要な計算量が多すぎるため、非常に分厚い特徴マップが生成されます。この場合、1x1 コンボリューション カーネルは、3x3 の前、5x5 の前、最大プーリングの後に追加され、特徴マップの厚さを減らします。これは、次の図に示すように、Inception v1 の

ネットワーク構造も形成します。1x1 コンボリューション カーネル?
1x1 畳み込みの主な目的は次元を削減することであり、線形活性化 (ReLU) を修正するためにも使用されます。たとえば、前の層の出力は 100x100x128 ですが、256 チャネル (ストライド = 1、パッド = 2) の 5x5 畳み込み層を通過した後の出力データは 100x100x256 となり、畳み込み層のパラメーターは 128x5x5x256= 819200 となります。前の層の出力が最初に 32 チャネルの 1x1 畳み込み層を通過し、次に 256 個の出力を持つ 5x5 畳み込み層を通過した場合、出力データは依然として 100x100x256 ですが、畳み込みパラメータの量は 128x1x1x32 に減少します。 + 32x5x5x256= 204800、約4倍の減少です。

Inception に基づく GoogLeNet のネットワーク構造は次のとおりです (全 22 層) 上図を

説明すると、
(1) GoogLeNet は追加や変更を容易にするためにモジュール構造 (Inception 構造) を採用しています、
(2) 最終的にネットワークは全結合層の代わりに平均プーリング (Average pooling) を採用していますが、これは NIN (Network in Network) に由来するアイデアで、これにより精度が 0.6% 向上することがわかりました。ただし、実際には出力の柔軟な調整を容易にするために、実際には最後に全結合層が追加されました
(3) 全結合層は削除されましたが、ネットワーク内ではドロップアウトが引き続き使用されました
(4) 勾配の消失を回避するため、ネットワーク 2 つの追加の補助ソフトマックスが順方向伝導勾配 (補助分類器) 用に追加されます。補助分類器は分類に中間層の出力を使用し、最終的な分類結果に小さい重み (0.3) を追加します。これはモデル融合と同等であり、ネットワークにバックプロパゲーション勾配を追加します。信号は追加の正則化も提供します。ネットワーク全体のトレーニングに非常に有益です。実際のテストでは、これら 2 つの追加のソフトマックスは削除されます。

GoogLeNet ネットワーク構造図の詳細は次のとおりです。

注: 上の表の「#3x3 Reduce」および「#5x5 Reduce」は、3x3 および 5x5 畳み込み演算の前に使用される 1x1 畳み込みの数を示します。

GoogLeNet ネットワーク構造の詳細なリストは次のように分析されます。
0. 入力
元の入力画像は 224x224x3 で、すべてゼロ平均前処理が行われています (画像の各ピクセルから平均値が減算されます)。
1. 最初の層 (畳み込み層) は、
7x7 畳み込みカーネル (スライディング ステップ サイズ 2、パディング 3)、64 チャネルを使用し、出力は 112x112x64 です。畳み込み後、ReLU 演算が実行され、3x3 の最大プーリング (ステップ サイズ 2
) 、出力は ((112 - 3+1)/2)+1=56、つまり 56x56x64 となり、ReLU 演算 2 を実行します。 2 番目の層 (畳み込み層) は 3x3 畳み込みカーネルを使用します (スライディング ステップ サイズは
1
) 、パディングは 1)、192 チャネル、出力は 56x56x192、畳み込みと ReLU 演算後、
3x3 最大プーリング (ステップ サイズは 2)、出力は ((56 - 3+1)/2)+1=28、つまりは 28x28x192 であり、その後 ReLU 演算
3a を実行し、3 番目の層 (インセプション 3a 層) が
4 つのブランチに分割され、処理に異なるスケールの畳み込みカーネルが使用されます
(1) 64 個の 1x1 畳み込みカーネル、その後 RuLU、出力 28x28x64
(2) 3x3 コンボリューション カーネルの前に次元削減として使用される 96 個の 1x1 コンボリューション カーネルが 28x28x96 になり、ReLU 計算を実行してから 128 個の 3x3 コンボリューション (パディングは 1) を実行し、出力 28x28x128 (3) 16 1x1 コンボリューション カーネル、次元
として5x5 コンボリューション カーネル前のリダクションは 28x28x16 になります。ReLU 計算後、32 の 5x5 コンボリューションが実行され (パディングは 2)、出力は 28x28x32 になります。
(4) プール層は 3x3 カーネル (パディングは 1) を使用し、28x28x192 を出力し、32 回の 1x1 畳み込みを実行して 28x28x32 を出力します。
4 つの結果を接続し、出力結果の 4 つの部分の 3 番目の次元を並列化します。つまり、64+128+32+32=256、最終出力は 28x28x256 になります。 3b、第 3 層 (インセプション 3b 層) (1
)
128 1x1 ボリューム コンボリューション カーネル、次に RuLU、出力 28x28x128
(2) 128 個の 1x1 コンボリューション カーネル、3x3 コンボリューション カーネルの前の次元削減として、28x28x128 になり、ReLU を実行し、その後 192 個の 3x3 コンボリューションを実行 (パディングは 1)、出力 28x28x192 (3
) 5x5 コンボリューション カーネルの前に次元削減として使用される 32 個の 1x1 コンボリューション カーネルは、28x28x32 になります。ReLU 計算を実行した後、96 個の 5x5 コンボリューション (パディングは 2) が実行され、出力は 3x3 カーネルを使用して 28x28x96 ( 4 ) のプール層になります
(パディングは 1)、28x28x256 を出力し、その後 64 回の 1x1 畳み込みを実行して 28x28x64 を出力します。
4 つの結果を接続し、4 つの出力結果の 3 番目の次元を並列に接続すると、128+192+96+64=480 となり、最終出力は 28x28x480 になります。

第 4 層 (4a、4b、4c、4d、4e)、第 5 層 (5a、5b)... は 3a および 3b と同様であるため、ここでは繰り返しません。

GoogLeNet の実験結果から判断すると、その効果は明ら​​かであり、MSRA、VGG などのモデルよりもエラー率が低く、比較結果は次の表に示されています。

インセプション V2

GoogLeNet はその優れたパフォーマンスにより多くの研究者によって研究され、使用されてきたため、GoogLeNet チームはそれをさらに調査および改良し、GoogLeNet のアップグレード バージョンを作成しました。
GoogLeNet の設計本来の目的は正確で高速であることですが、単純にネットワークを積み重ねるだけで精度は向上しますが、計算効率の大幅な低下につながるため、ネットワークの表現力を上げずにいかにネットワークの表現力を向上させるかが課題となります。計算量が多すぎると問題になりました。
Inception V2 バージョンの解決策は、Inception の内部計算ロジックを変更し、比較的特殊な「畳み込み」計算構造を提案することです。

1. コンボリューション分解 (畳み込みの因数分解)
コンボリューション カーネルのサイズが大きいほど、受容野は大きくなりますが、生成されるパラメーターも多くなります。たとえば、5x5 コンボリューション カーネルには 25 個のパラメーターがあり、3x3 コンボリューション カーネルには 25 個のパラメーターがあります。パラメータは 9 つあり、前者は後者の 25/9=2.78 倍です。したがって、GoogLeNet チームは、以下に示すように、単一の 5x5 畳み込み層を 2 つの連続する 3x3 畳み込み層で構成される小規模なネットワークに置き換えることができることを提案しました。これにより、受容野の範囲を維持しながらパラメーターの数が削減されます

。表現力の低下？多くの実験により、それが発現の損失を引き起こさないことが示されています。
大きなコンボリューション カーネルは、一連の 3x3 コンボリューション カーネルで完全に置き換えることができることがわかります。GoogLeNet チームは、下の図に示すように、3x3 コンボリューションを 3 つの 3x1 コンボリューションで置き換える nx1 コンボリューション カーネルを検討しました。したがって、任意の nxn コンボリューションは、

1xn コンボリューションとそれに続く nx1 コンボリューションで置き換えることができます。GoogLeNet チームは、ネットワークの初期段階でこの分解を使用する効果は良くなく、中程度のサイズの特徴マップで使用すると効果が高まることを発見しました (特徴マップのサイズは 12 ～ 20 が推奨されます)。

2. 特徴マップのサイズを小さくする
一般に、画像のサイズを小さくしたい場合は、

最初にプーリングを行ってからインセプション コンボリューションを実行する方法、または最初にインセプション コンボリューションを実行してからプーリングを実行する方法があります。ただし、プーリング（プーリング）の1番目の方法（左図）では特徴表現がボトルネック（特徴の損失）に遭遇し、2番目の方法（右図）は通常の削減ではありますが、計算量が非常に多くなります。特徴表現を維持しつつ計算量を削減するため、ネットワーク構成を下図のように変更し、並列モジュールを2つ使用して計算量を削減します（畳み込み、プーリングを並列実行し、 Inception V2 は GoogLeNet の改良版を作成するために使用され

、ネットワーク構造図は次のとおりです。

注: 上の表の図 5 は進化のない Inception を指し、図 6 は Inception の小規模な畳み込みバージョン (5x5 コンボリューション カーネルの代わりに 3x3 コンボリューション カーネルを使用) を指し、図 7 は Inception の非対称バージョン (1xn を使用) を指します。 nxn コンボリューション カーネルの代わりに nx1 コンボリューション カーネル)。

実験の結果、次の表に示すように、モデルの結果は古い GoogleNet と比較して大幅に改善されました。

インセプション V3

Inception V3 の最も重要な改良点の 1 つは因数分解であり、これは 7x7 を 2 つの 1 次元畳み込み (1x7、7x1) に分解し、同じことが 3x3 (1x3、3x1) にも当てはまります。この利点は計算を高速化するだけでなく、また、1 つの畳み込みを 2 つの畳み込みに分割すると、ネットワークの深さがさらに増し、ネットワークの非線形性が増加します (追加の層ごとに ReLU が実行されます)。
さらに、ネットワーク入力が 224x224 から 299x299 に変更されました。

インセプション V4

Inception V4 は、Inception モジュールと残留接続の組み合わせを研究します。ResNet 構造により、ネットワークの深さが大幅に深まり、トレーニング速度が大幅に向上し、パフォーマンスも向上します (ResNet の技術原理の紹介については、このブログの以前の記事「Dahua Deep Residual Network ResNet」を参照してください)。
Inception V4 は主に残留接続を使用して V3 構造を改善し、その結果、Inception-ResNet-v1、Inception-ResNet-v2、および Inception-v4 ネットワークが形成されます。
ResNet の残りの構造は次のとおりです。

この構造を Inception と組み合わせると、次の図になります。

20 個の同様のモジュールの組み合わせにより、Inception-ResNet は次のように構築されます。

プログラミングの実装

その後の追加

参考:https://my.oschina.net/u/876354/blog/1637819