Dropout

輟學是一種流行的神經網絡正則化技術。深層神經網絡特別容易過度擬合。

現在讓我們看看輟學是什麼以及它是如何運作的。

用深度學習的先驅之一傑弗里·辛頓（Geoffrey Hinton）的話來說，「如果你有一個深度神經網絡，而且它並不過分合適，那麼你可能應該使用一個更大的網絡，並使用輟學」。

輟學是一種技術，在每次梯度下降疊代過程中，我們會丟棄一組隨機選擇的節點。這意味著我們隨機忽略一些節點，就好像它們不存在一樣。

每一個神經元以q的機率保持，以1-q的機率隨機下降。在神經網絡中，每一層的q值可能不同。對於隱藏層，值爲0.5，對於輸入層，值爲0，可以很好地處理各種任務。

在評估和預測期間，不使用輟學。每個神經元的輸出乘以q，這樣到下一層的輸入具有相同的期望值。

輟學背後的想法是這樣的，在一個沒有輟學規則化的神經網絡中，神經元之間會產生相互依賴關係，從而導致過度擬合。

Implementation trick

在TensorFlow和Pytorch等庫中，通過將隨機選擇的神經元的輸出保持爲0來實現輟學。也就是說，雖然神經元存在，但其輸出被覆蓋爲0。

Early Stopping

我們使用一種叫做梯度下降的疊代算法訓練神經網絡。

提前停止的想法是直觀的;當錯誤開始增加時，我們停止訓練。這裡，所謂誤差，是指在驗證數據上測量的誤差，它是用於調整超參數的訓練數據的一部分。在這種情況下，超參數是停止條件。

Data Augmentation

通過使用現有數據並對其應用某些轉換來增加我們擁有的數據量或增加它的過程。所使用的確切轉換取決於我們打算完成的任務。此外，幫助神經網絡的轉換依賴於它的結構。

例如，在許多計算機視覺任務中，例如對象分類，一種有效的數據增強技術是添加新的數據點，這些數據點是原始數據的裁剪或翻譯版本。

當計算機接受圖像作爲輸入時，它接受一個像素值數組。假設整個圖像左移15像素。我們在不同的方向上應用了許多不同的移位，結果得到了一個比原始數據集大很多倍的擴展數據集。

Transfer Learning

接受預先訓練的模型並用我們自己的數據集「微調」模型的過程稱爲轉移學習。有幾種方法可以做到這一點;

• 我們在一個大數據集上訓練預先訓練的模型。然後，我們移除網絡的最後一層，並將其替換爲具有隨機權重的新層。

• 然後凍結所有其他層的權重，並正常訓練網絡。在這裡凍結圖層並不會改變梯度下降或優化過程中的權重。

這背後的概念是，預先訓練的模型將充當特徵提取器，只有最後一層將在當前任務上進行訓練。

Computational Graphs

反向傳播通過使用計算圖在諸如Tensorflow、Torch、Theano等深度學習框架中實現。更重要的是，理解計算圖上的反向傳播結合了幾種不同的算法及其變化，如時間反向傳播和具有共享權重的反向傳播。一旦所有東西都轉換成計算圖，它們仍然是相同的算法，只是計算圖上的反向傳播。

What is Computational Graph

計算圖被定義爲節點對應於數學運算的有向圖。計算圖是表示和計算數學表達式的一種方法。

例如，這裡有一個簡單的數學方程&負;

$$p = x+y$$

我們可以畫出上述方程的計算圖如下。

上面的計算圖有一個加法節點（帶有「+」符號的節點），它有兩個輸入變量x和y以及一個輸出變量q。

讓我們再舉一個稍微複雜一點的例子。我們有以下方程式。

$$g = \left (x+y \right ) \ast z $$

上面的方程由下面的計算圖表示。

Computational Graphs and Backpropagation

計算圖和反向傳播都是神經網絡深度學習的重要核心概念。

Forward Pass

正向傳遞是計算圖表示的數學表達式的值的計算過程。執行forward pass意味著我們將變量的值從左（輸入）向右（輸出所在）正向傳遞。

讓我們考慮一個例子，給出所有輸入的一些值。假設，爲所有輸入提供以下值。

$$x=1, y=3, z=−3$$

通過將這些值賦給輸入，我們可以執行前向傳遞，並爲每個節點上的輸出獲取以下值。

首先，我們使用x=1和y=3的值，得到p=4。

然後我們用p=4和z=-3得到g=-12。我們從左到右，向前走。

Objectives of Backward Pass

在反向過程中，我們的目的是計算每個輸入相對於最終輸出的梯度。這些梯度對於利用梯度下降訓練神經網絡是必不可少的。

例如，我們需要以下漸變。

Desired gradients

$$\frac{\partial x}{\partial f}, \frac{\partial y}{\partial f}, \frac{\partial z}{\partial f}$$

Backward pass (backpropagation)

我們通過找到最終輸出相對於最終輸出（本身）的導數來開始反向傳遞。因此，它將導致恆等式推導，並且該值等於1。

$$\frac{\partial g}{\partial g} = 1$$

我們的計算圖如下所示;

接下來，我們將通過「*」操作執行反向傳遞。我們將計算p和z的梯度，因爲g=p*z，我們知道&;

$$\frac{\partial g}{\partial z} = p$$

$$\frac{\partial g}{\partial p} = z$$

我們已經知道了z和p的值。因此，我們得到&負;

$$\frac{\partial g}{\partial z} = p = 4$$

and

$$\frac{\partial g}{\partial p} = z = -3$$

我們要計算x和y的梯度;

$$\frac{\partial g}{\partial x}, \frac{\partial g}{\partial y}$$

然而，我們想有效地做到這一點（儘管x和g在這個圖中只相差兩個跳，但假設它們彼此之間確實很遠）。爲了有效地計算這些值，我們將使用微分鏈規則。根據鏈式法則，我們有&;

$$\frac{\partial g}{\partial x}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial x}$$

$$\frac{\partial g}{\partial y}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial y}$$

但是我們已經知道dg/dp=-3，dp/dx和dp/dy很容易，因爲p直接依賴於x和y;

$$p=x+y\Rightarrow \frac{\partial x}{\partial p} = 1, \frac{\partial y}{\partial p} = 1$$

因此，我們得到&負;

$$\frac{\partial g} {\partial f} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial x} = \left ( -3 \right ).1 = -3$$

另外，對於輸入y&負;

$$\frac{\partial g} {\partial y} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial y} = \left ( -3 \right ).1 = -3$$

反向執行此操作的主要原因是，當我們必須計算x處的梯度時，我們只使用已計算的值和dq/dx（節點輸出相對於同一節點輸入的導數）。我們使用本地信息來計算全局值。

Steps for training a neural network

按照以下步驟訓練神經網絡&負;

• 對於數據集中的數據點x，我們用x作爲輸入進行正向傳遞，並計算出成本c作爲輸出。

• 我們從c開始反向傳遞，並計算圖中所有節點的梯度。這包括表示神經網絡權重的節點。

• 然後我們通過做W=W-學習率*梯度來更新權重。

• 我們重複此過程，直到滿足停止標準。

Python Deep Learning - Applications

深度學習在計算機視覺、語言翻譯、圖像字幕、音頻轉錄、分子生物學、語音識別、自然語言處理、自動駕駛汽車、腦瘤檢測、實時語音翻譯、音樂創作、自動遊戲播放等應用中取得了良好的效果。

深度學習是繼機器學習之後的又一個更先進的實現方式。目前，它正朝著成爲一個行業標準的方向發展，在處理原始的非結構化數據時，它有望成爲遊戲規則的改變者。

深度學習是目前解決各種現實問題的最佳解決方案之一。開發人員正在開發人工智慧程序，而不是使用以前給定的規則，從示例中學習解決複雜任務。隨著深度學習被許多數據科學家所使用，深度神經網絡正在提供更加精確的結果。

其思想是通過增加每個網絡的訓練層數量來開發深層神經網絡;機器學習更多的數據，直到儘可能精確。開發人員可以使用深度學習技術來實現複雜的機器學習任務，並訓練人工智慧網絡具有高水平的感知識別能力。

深度學習在計算機視覺中很受歡迎。這裡所完成的任務之一是圖像分類，其中給定的輸入圖像被分類爲貓、狗等，或者被分類爲最能描述圖像的類或標籤。作爲人類，我們很早就學會了如何完成這項任務，並且擁有快速識別模式、從先前的知識中歸納、適應不同圖像環境的技能。

Libraries and Frameworks

在本章中，我們將把深入學習與不同的庫和框架聯繫起來。

Deep learning and Theano

如果我們想開始編碼一個深層神經網絡，最好我們有一個不同的框架，比如Theano、TensorFlow、Keras、PyTorch等，是如何工作的。

Theano是python庫，它提供了一組函數，用於構建在我們的機器上快速訓練的深層網絡。

Theano是在加拿大蒙特婁大學（University of Montreal）由一位深度網絡先驅Yoshua Bengio領導下開發的。

它允許我們定義和計算帶有向量和矩陣的數學表達式，這些向量和矩陣是數字的矩形陣列。

從技術上講，神經網絡和輸入數據都可以表示爲矩陣，所有標準的網絡操作都可以重新定義爲矩陣操作。這一點很重要，因爲計算機可以很快地執行矩陣運算。

我們可以並行處理多個矩陣值，如果我們用這種底層結構構建一個神經網絡，我們就可以用一台帶有GPU的機器在一個合理的時間窗內訓練龐大的網絡。

然而，如果我們使用天網，我們必須從頭開始建立深網。庫沒有提供創建特定類型的deep net的完整功能。

相反，我們必須對深網的各個方面進行編碼，比如模型、層、激活、訓練方法和任何防止過度擬合的特殊方法。

不過，好消息是，Theano允許在矢量化函數之上構建我們的實現，從而爲我們提供一個高度優化的解決方案。

還有許多其他庫擴展了ano的功能。TensorFlow和Keras可以與ano一起用作後端。

Deep Learning with TensorFlow

Googles TensorFlow是一個python庫。該圖書館是建設商業級深度學習應用的絕佳選擇。

TensorFlow源於另一個圖書館DistFeedge V2，它是Google Brain項目的一部分。該庫旨在擴展機器學習的可移植性，以便研究模型可以應用於商業級應用。

與Theano庫非常相似，tensor flow是基於計算圖的，其中一個節點表示持久數據或數學運算，而邊表示節點之間的數據流，這是一個多維數組或tensor;因此，TensorFlow的名稱是

一個操作或一組操作的輸出作爲下一個操作的輸入。

儘管TensorFlow是爲神經網絡設計的，但它也適用於其他可以將計算建模爲數據流圖的網絡。

TensorFlow還使用了一些來自Theano的特性，如公共和子表達式消除、自微分、共享和符號變量。

利用卷積網、自動編碼器、RNTN、RNN、RBM、DBM/MLP等張量流可以構造不同類型的深網。

但是，TensorFlow中不支持超參數配置。對於此功能，我們可以使用Keras。

Deep Learning and Keras

Keras是一個強大的易於使用的Python庫，用於開發和評估深度學習模型。

它有一個極簡的設計，允許我們建立一個網絡一層一層，訓練它，並運行它。

它封裝了高效的數值計算庫Theano和TensorFlow，允許我們用幾行代碼定義和訓練神經網絡模型。

它是一個高級的神經網絡API，有助於深度學習和人工智慧的廣泛應用。它運行在許多較低級別的庫之上，包括TensorFlow、Theano等。Keras代碼是可移植的;我們可以在Keras中實現一個神經網絡，使用ano或TensorFlow作爲後端，代碼沒有任何變化。

Python Deep Learning - Implementations

在這個深度學習的實現中，我們的目標是預測某家銀行的客戶流失或客戶流失數據-哪些客戶可能離開此銀行服務。使用的數據集相對較小，包含10000行14列。我們正在使用Anaconda發行版，以及Theano、TensorFlow和Keras等框架。路緣石建在Tensorflow和Theano的頂部，Tensorflow和Theano作爲路緣石的後端。

# Artificial Neural Network
# Installing Theano
pip install --upgrade theano

# Installing Tensorflow
pip install –upgrade tensorflow

# Installing Keras
pip install --upgrade keras

Step 1: Data preprocessing

In[]:

# Importing the libraries
   import numpy as np
   import matplotlib.pyplot as plt
   import pandas as pd
 
# Importing the database
   dataset = pd.read_csv('Churn_Modelling.csv')

Step 2

我們創建數據集特徵和目標變量的矩陣，即列14，標記爲「Exited」。

數據的初始外觀如下所示;

In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X

Output

Step 3

Y

Output

array([1, 0, 1, ..., 1, 1, 0], dtype = int64)

Step 4

我們通過對字符串變量進行編碼使分析更簡單。我們使用ScikitLearn函數「LabelEncoder」自動對列中的不同標籤進行編碼，其值介於0到n_classes-1之間。

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder() 
X[:,1] = labelencoder_X_1.fit_transform(X[:,1]) 
labelencoder_X_2 = LabelEncoder() 
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
X

Output

在上述輸出中，國家名稱替換爲0、1和2;男性和女性替換爲0和1。

Step 5

標記編碼數據

我們使用相同的ScikitLearn庫和另一個名爲onehotecoder的函數來傳遞創建虛擬變量的列號。

onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X

現在，前兩列代表國家，第四列代表性別。

Output

我們總是將數據分爲訓練和測試兩部分，對訓練數據進行模型訓練，然後對測試數據進行模型精度檢驗，這有助於評估模型的效率。

Step 6

我們使用ScikitLearn的train_test_split函數將數據分成訓練集和測試集。我們把列車與測試的比例保持在80:20。

#Splitting the dataset into the Training set and the Test Set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)

有些變量的值以千爲單位，而有些變量的值以十或一爲單位。我們對數據進行縮放，使其更具代表性。

Step 7

在這段代碼中，我們使用StandardScaler函數擬合和轉換訓練數據。我們將縮放標準化，以便使用相同的擬合方法轉換/縮放測試數據。

# Feature Scaling

fromsklearn.preprocessing import StandardScaler 
sc = StandardScaler() 
X_train = sc.fit_transform(X_train) 
X_test = sc.transform(X_test)

Output

The data is now scaled properly. Finally, we are done with our data pre-processing. Now,we will start with our model.

Step 8

We import the required Modules here. We need the Sequential module for initializing the neural network and the dense module to add the hidden layers.

# Importing the Keras libraries and packages 
import keras 
from keras.models import Sequential 
from keras.layers import Dense

Step 9

我們將模型命名爲分類器，因爲我們的目標是對客戶流失進行分類。然後使用順序模塊進行初始化。

#Initializing Neural Network 
classifier = Sequential()

Step 10

我們使用密集函數逐個添加隱藏層。在下面的代碼中，我們將看到許多參數。

我們的第一個參數是輸出。這是我們添加到該層的節點數。init是隨機梯度下降的初始化。在神經網絡中，我們給每個節點分配權重。在初始化時，權值應該接近於零，我們使用均勻函數隨機初始化權值。因爲模型不知道輸入變量的數目，所以只需要第一層輸入參數。這裡輸入變量的總數是11。在第二層，模型自動從第一個隱藏層知道輸入變量的數量。

執行以下代碼行以添加輸入層和第一個隱藏層−

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu', input_dim = 11))

執行以下代碼行以添加第二個隱藏層−

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu'))

執行以下代碼行以添加輸出層−

classifier.add(Dense(units = 1, kernel_initializer = 'uniform', 
activation = 'sigmoid'))

Step 11

編制人工神經網絡

到目前爲止，我們已經在分類器中添加了多個層。我們現在將使用compile方法編譯它們。在最終編譯控制中添加的參數完成了神經網絡。因此，在這一步中我們需要小心。

以下是對論點的簡要解釋。

The Forward Propagation Algorithm

在本節中，我們將學習如何編寫代碼來爲一個簡單的神經網絡進行正向傳播（預測）&負;

每個數據點都是客戶。第一個輸入是他們有多少帳戶，第二個輸入是他們有多少孩子。該模型將預測用戶在下一年進行多少交易。

輸入數據作爲輸入數據預加載，權重在稱爲權重的字典中。隱藏層中第一個節點的權重數組分別爲權重['node_0']，隱藏層中第二個節點的權重數組分別爲權重['node_1']。

輸入到輸出節點的權重以權重形式提供。

The Rectified Linear Activation Function

「激活功能」是在每個節點工作的功能。它將節點的輸入轉換爲一些輸出。

校正線性激活函數（稱爲ReLU）廣泛應用於高性能網絡。此函數將單個數字作爲輸入，如果輸入爲負，則返回0;如果輸入爲正，則輸入爲輸出。

下面是一些例子;

• relu(4) = 4
• relu(-2) = 0

我們填寫relu（）函數的定義−

• We use the max() function to calculate the value for the output of relu().
• We apply the relu() function to node_0_input to calculate node_0_output.
• We apply the relu() function to node_1_input to calculate node_1_output.

import numpy as np
input_data = np.array([-1, 2])
weights = {
   'node_0': np.array([3, 3]),
   'node_1': np.array([1, 5]),
   'output': np.array([2, -1])
}
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = np.tanh(node_0_input)
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = np.tanh(node_1_input)
hidden_layer_output = np.array(node_0_output, node_1_output)
output =(hidden_layer_output * weights['output']).sum()
print(output)

def relu(input):
   '''Define your relu activation function here'''
   # Calculate the value for the output of the relu function: output
   output = max(input,0)
      # Return the value just calculated
   return(output)
# Calculate node 0 value: node_0_output
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = relu(node_0_input)

# Calculate node 1 value: node_1_output
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = relu(node_1_input)

# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])

# Calculate model output (do not apply relu)
odel_output = (hidden_layer_outputs * weights['output']).sum()
print(model_output)# Print model output

Output

0.9950547536867305
-3

Applying the network to many Observations/rows of data

在本節中，我們將學習如何定義名爲predict_with_network（）的函數。此函數將生成多個數據觀測的預測，從上述網絡獲取作爲輸入數據。正在使用上述網絡中給定的權重。relu（）函數定義也正在使用。

讓我們定義一個名爲predict_with_network（）的函數，它接受兩個參數-input_data_row和weights-並從網絡返回一個預測作爲輸出。

我們計算每個節點的輸入和輸出值，將它們存儲爲：node_0_輸入、node_0_輸出、node_1_輸入和node_1_輸出。

爲了計算節點的輸入值，我們將相關數組相乘並計算它們的和。

要計算節點的輸出值，我們將relu（）函數應用於節點的輸入值。我們使用「for循環」來疊代輸入的數據;

我們還使用predict_with_network（）爲input_data-input_data行的每一行生成預測。我們還將每個預測附加到結果中。

# Define predict_with_network()
def predict_with_network(input_data_row, weights):
   # Calculate node 0 value
   node_0_input = (input_data_row * weights['node_0']).sum()
   node_0_output = relu(node_0_input)
   
   # Calculate node 1 value
   node_1_input = (input_data_row * weights['node_1']).sum()
   node_1_output = relu(node_1_input)
   
   # Put node values into array: hidden_layer_outputs
   hidden_layer_outputs = np.array([node_0_output, node_1_output])
   
   # Calculate model output
   input_to_final_layer = (hidden_layer_outputs*weights['output']).sum()
   model_output = relu(input_to_final_layer)
# Return model output
   return(model_output)

# Create empty list to store prediction results
results = []
for input_data_row in input_data:
   # Append prediction to results
   results.append(predict_with_network(input_data_row, weights))
print(results)# Print results

Output

[0, 12]

這裡我們使用relu函數，其中relu（26）=26，relu（-13）=0，依此類推。

Deep multi-layer neural networks

在這裡，我們編寫代碼來做兩個隱藏層的神經網絡的正向傳播。每個隱藏層有兩個節點。輸入數據已預加載爲輸入數據。第一個隱藏層中的節點稱爲node_0_0和node_0_1。

它們的權重分別預加載爲權重['node_0_0']和權重['node_0_1']。

第二個隱藏層中的節點稱爲node_1_0和node_1_1。它們的權重分別預加載爲權重['node_1_0']和權重['node_1_1']。

然後，我們使用預先加載爲權重['output']的權重從隱藏節點創建模型輸出。

我們使用節點的權重和給定的輸入數據計算節點的輸入。然後應用relu（）函數獲取node_0_0_輸出。

我們對node_0_1_輸入執行上述操作，以獲取node_0_1_輸出。

我們使用節點的權重和第一個隱藏層的輸出計算節點的輸入。然後我們應用relu（）函數來獲取node_1_0_輸出。

我們對node_1_1_1_輸入執行上述操作，以獲得node_1_1_1_輸出。

我們使用權重[「output」]和來自第二隱藏層hidden_1_outputs數組的輸出計算模型_輸出。我們不對該輸出應用relu（）函數。