?? 作者：韓信子@ShowMeAI
?? 深度學習實戰系列：https://www.showmeai.tech/tutorials/42
?? TensorFlow實戰系列: https://www.showmeai.tech/tutorials/43
?? 本文地址：https://www.showmeai.tech/article-detail/290
?? 宣告：著作權所有，轉載請聯系平臺與作者并注明出處
?? 收藏ShowMeAI查看更多精彩內容

深度學習是機器學習的一類演算法，它應用各種結構的神經網路解決問題（深度學習中的『深度』指的是我們會通過深層次的神經網路構建強大的學習器），模仿人類獲得某些型別知識的方式，與傳統機器學習模型相比，神經網路有更靈活的結構設計，更強的學習能力，能支撐更大量級的資料學習，因此廣泛參考于各種業務中，

神經網路是簡化人腦的學習思考程序構建的結構，它是一個連接單元（神經元）的連接堆疊結構，我們設計這些單元，希望它們能在一定程度上模仿大腦中的突觸，將信號傳遞給其他神經元，就像相互連接的腦細胞一樣，可以在更多的時間里學習和做出決定，如下是簡單的神經網路拆解圖，

深度學習與神經網路有很多不同的結構和應用，想要系統學習這部分知識的同學，可以查看ShowMeAI制作的下列教程：

深度學習教程 | 吳恩達專項課程 · 全套筆記解讀

自然語言處理教程 | 斯坦福CS224n課程 · 課程帶學與全套筆記解讀

深度學習與計算機視覺教程：斯坦福CS231n · 全套筆記解讀

ShowMeAI 將在本文中，全面圖解展示使用 Python 構建神經網路的程序，覆寫TensorFlow建模、可視化網路、模型預測結果歸因與解釋，

文中講解到的板塊和對應的實作 Python 代碼，可以很容易地遷移應用于其他類似情況（復制、粘貼、運行），我們對代碼做了詳盡的注釋講解，

全文的總體內容結構包括：

環境設定與TensorFlow工具庫簡介
神經網路分解、輸入、輸出、隱藏層、激活函式
使用深度神經網路進行深度學習
進行模型設計（基于TensorFlow）
可視化神經網路
模型訓練和測驗
模型可解釋性

?? 環境設定

目前主流的神經網路工具庫有2個：TensorFlow https://www.tensorflow.org/（由 Google 開發）和 PyTorch https://pytorch.org/ （由 Facebook 開發），他們有很多相似之處，功能也都很全面，但總體來說前者更適合生產，而后者更適合構建快速原型，

這兩個庫都可以利用 GPU 的強大矩陣運算功能去加速神經網路的訓練和預估，這對于處理大型資料集（如文本語料庫或影像庫）非常有用，而其對應的開發社區也有著豐富的資源，不管你解決何種問題，總可以找到相關的參考資料，

本篇內容使用到的是 TensorFlow 工具庫，

對于本篇使用到的工具，ShowMeAI制作了快捷即查即用的工具速查表手冊，大家可以在下述位置獲得：

TensorFlow速查手冊

Matplotlib速查手冊

我們先在終端通過 pip install 命令安裝 TensorFlow，

pip install tensorflow

現在我們可以在 Notebook 上匯入 TensorFlow Keras 并開始編碼：

# 匯入所需的工具庫
# tensorflow建模
from tensorflow.keras import models, layers, utils, backend as K
# 可視化
import matplotlib.pyplot as plt
# 特征重要度與模型歸因分析
import shap

?? 神經網路拆解

神經網路的結構拆解的詳細內容，推薦大家查看ShowMeAI的教程 ?? 深度學習教程 | 吳恩達專項課程 · 全套筆記解讀下述文章：

深度學習教程 | 神經網路基礎

深度學習教程 | 淺層神經網路

深度學習教程 | 深層神經網路

人工神經網路由若干層組成（每一層有獨立的輸入和輸出維度），這些層可以分組為：

輸入層 ：負責將輸入向量傳遞給神經網路，如果我們有一個包含 3 個特征的矩陣（形狀 N x 3），則該層將 3 個數字作為輸入，并將相同的 3 個數字傳遞給下一層，
隱藏層 ：代表中間節點，它們對數字進行多次變換以提高最終結果的準確性，輸出由神經元的數量定義，
輸出層 ：回傳神經網路最終輸出的如果我們進行簡單的二元分類或回歸，輸出層應該只有 1 個神經元（因此它只回傳 1 個數字），在具有 5 個不同類別的多類別分類的情況下，輸出層應有 5 個神經元，

最簡單的神經網路形式是感知器，一個只有一層的模型，與線性回歸/邏輯回歸模型非常相似，

舉個例子：假設我們有一個包含 N 行、3 個特征和 1 個目標變數（二分類，取值0或1）的資料集，如下圖所示：

實際上，資料在輸入神經網路之前應該進行幅度縮放，我們這里舉例的輸入資料直接用了0-1之間的值，類似其他機器學習模型，我們使用輸入X去預測輸出y：

而當我們提到『訓練模型』時，我們指的是尋找最佳引數，使得模型預測的結果能最準確地預估目標值，

這里的最佳引數，在不同的情形下，有不同的解釋：

在線性回歸中，是找到最佳權重w

在基于樹的模型（比如隨機森林）中，它是找到最佳分裂點

如下的感知器中，我們希望找到最佳的W（w1，w2，w3）

我們有一些權重初始化方法，在這里我們采用最簡單的隨機初始化，然后隨著學習的進行調整優化引數，如下圖，我們將權重 w 全部初始化為 1：

接下來我們要進行一個簡單的計算來對結果進行預估，下面的操作類似于單個神經網路的計算，f(WX+b)，其中f函式叫做激活函式，

激活函式是非線性的映射函式，使得神經網路具備強大的非線性擬合學習能力，如下是一些激活函式示意圖（當然，實際我們可能會更多地使用ReLU等激活函式），

激活函式詳細講解可以參考ShowMeAI的文章 深度學習教程 | 淺層神經網路，

加入我們采用上面的階躍激活函式，那簡單的計算程序如下：

我們得到了感知器的輸出，這是一個單層神經網路，它接受一些輸入并回傳 1 個輸出，現在模型的訓練將繼續通過將輸出與目標進行比較，計算誤差并優化權重，一遍又一遍地重復整個程序，

總結一下，這就是最簡單的神經元，簡化的結構表示如下：

?? 深度神經網路

可以說所有深度學習模型都是神經網路，但并非所有神經網路都是深度學習模型，一般來說，『深度』學習適用于演算法至少有 2 個隱藏層（因此總共 4 層，包括輸入和輸出），

關于深度神經網路的詳細知識，大家可以閱讀學習ShowMeAI的文章 ?? 深度學習教程 | 深層神經網路，

想象一下在中間層添加3個和剛才一樣的神經元：由于每個節點（加權和和激活函式）都回傳一個值，我們將得到具有 3 個輸出的 隱藏層，

接下來我們使用這 3 個輸出作為 第2個隱藏層 的輸入，第2個隱藏層也同樣計算得到 3 個結果值，最后，我們將添加一個 輸出層 （僅 1 個節點），用它的結果作為我們模型的最終預測，如下圖所示

注意，這些中間層可以具有不同數量的神經元，使用不同的激活函式，每個神經元計算都會有對應的權重，因此添加的層數越多，可訓練引數的數量就越大，

完整的神經網路全貌如下圖所示：

我們剛才是以口語化的方式來敘述整個神經網路的結構和計算程序的，但實際有一些細節點，包括：

偏置項bias：在每個神經元內部，輸入和權重的線性組合也包括一個偏差，類似于線性方程中的常數，因此神經元的完整公式是

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5863fdcf08fe4020afec88162f6cc684~tplv-k3u1fbpfcp-zoom-1.image" referrerpolicy="no-referrer">

反向傳播：在訓練期間，模型通過將誤差傳播回節點并更新引數（權重和偏差）來學習以最小化損失，

梯度下降：用于訓練神經網路的優化演算法，通過在最陡下降方向上重復步驟來找到損失函式的區域最小值，

?? 模型搭建

我們使用 TensorFlow 的 high level API（也就是 tensorflow.keras）來快速搭建神經網路，

ShowMeAI制作了快捷即查即用的 Tensorflow 工具速查表手冊，大家可以在下述位置獲得：

Tensorflow速查手冊

我們先搭建剛才提到的最簡單的感知器結果，它是一個只有一個 Dense 層的模型， Dense層是最基本的層結構，是一個全連接的結構，

model = models.Sequential(name="Perceptron", 
    layers=[    
        layers.Dense(             # 全連接層
          name="dense",
          input_dim=3,        # 輸入維度為3
          units=1,            # 1個節點
          activation='linear' # 激活函式（這里是線性函式）
    )
    ])
model.summary()

model.summary操作可以輸出網路的結構和引數等資訊，當前情況下，我們只有 4 個（3 個權重和 1 個偏置項），所以它非常精簡，

要說明一點的是，如果我們這里要使用階躍函式作為激活函式，我們需要自己定義（目前Tensorflow中的激活函式不包含這個我們臨時設定的函式）

import tensorflow as tf
# 定義激活函式
def binary_step_activation(x):
    # 如果x>0回傳1否則回傳0 
    return K.switch(x>0, tf.math.divide(x,x), tf.math.multiply(x,0))

# 構建模型
model = models.Sequential(name="Perceptron", layers=[
      layers.Dense(             
          name="dense",
          input_dim=3,        
          units=1,            
          activation=binary_step_activation
      )
])

如果我們從感知器轉延展到深度神經網路，大家可能會冒出來一些問題，比如：

? 應該設定多少層？

這是一個沒有標準答案的問題，隱層的加入對于模型的學習能力提升有幫助，可以擬合更復雜的非線性情況，但也可能會導致過擬合（當然我們可以通過 Dropout 等技術來緩解過擬合，關于 Dropout，大家可以閱讀學習ShowMeAI的文章 ?? 深度學習教程 | 深度學習的實用層面，
一般來說，簡單的問題我們會用很少的層數（不超過3個隱層），復雜的問題我們使用的層數更多

下圖是層數和學習能力的一個示意圖，

? 應該設定多少個神經元？

這個有不同的設定方法，一個常用的設定方式是 (輸入維度 + 輸出維度)/2 ，

? 選用什么激活函式？

激活函式有很多選擇，其中沒有哪一個一定好于另外一個，最常用的是 ReLU ，一個分段線性函式，僅在輸出為正時才回傳，
注意，在輸出層必須具有與任務輸出兼容的激活，例如，linear函式適用于回歸問題，而 Sigmoid/softmax 經常用于分類，

我們來解決一個二分類問題，它有 N 個輸入特征和 1 個二進制目標變數，

n_features = 10

model = models.Sequential(name="DeepNN", layers=[
    # 第1個隱層
    layers.Dense(name="h1", input_dim=n_features,
                 units=int(round((n_features+1)/2)), 
                 activation='relu'),
    layers.Dropout(name="drop1", rate=0.2),
    
    # 第2個隱層
    layers.Dense(name="h2", units=int(round((n_features+1)/4)), 
                 activation='relu'),
    layers.Dropout(name="drop2", rate=0.2),
    
    # 第3層
    layers.Dense(name="output", units=1, activation='sigmoid')
])
model.summary()

除了這種漢堡包式地堆疊神經網路層次構建網路的 Sequential 方法，tensorflow.keras 還有函式式編程結構，它可用于構建具有多個輸入/輸出的更復雜的模型，函式式編程介面相對 Sequential 有兩個主要區別：

需要指定輸入層，而在 Sequential 類中它隱含在第一個 Dense 層的輸入維度中，
每一層可以直接應用于其他層的輸出，形如： output = layer(...)(input)

我們用函式式方式重寫上面的網路，代碼如下：

# 感知器
inputs = layers.Input(name="input", shape=(3,))
outputs = layers.Dense(name="output", units=1, 
                       activation='linear')(inputs)
model = models.Model(inputs=inputs, outputs=outputs, 
                     name="Perceptron")

# 深層神經網路
# 輸入層
inputs = layers.Input(name="input", shape=(n_features,))

# 隱層1
h1 = layers.Dense(name="h1", units=int(round((n_features+1)/2)), activation='relu')(inputs)
h1 = layers.Dropout(name="drop1", rate=0.2)(h1)

# 隱層2
h2 = layers.Dense(name="h2", units=int(round((n_features+1)/4)), activation='relu')(h1)
h2 = layers.Dropout(name="drop2", rate=0.2)(h2)

# 輸出層
outputs = layers.Dense(name="output", units=1, activation='sigmoid')(h2)

# 完整的模型
model = models.Model(inputs=inputs, outputs=outputs, name="DeepNN")

?? 神經網路結構可視化

這個部分是工具部分，我們希望通過一段代碼把多層的神經網路的大致結構繪制出來，當然，這里的結構只是一個簡單的資訊呈現，如果大家要深入理解神經網路的權重和激活函式等繪制，可以看ShowMeAI 后續的深入教程，

完整的代碼如下：

'''
抽取tensorflow.keras模型中的每層資訊
'''
def utils_nn_config(model):
    lst_layers = []
    if "Sequential" in str(model): #-> Sequential不顯示輸入層
        layer = model.layers[0]
        lst_layers.append({"name":"input", "in":int(layer.input.shape[-1]), "neurons":0, 
                           "out":int(layer.input.shape[-1]), "activation":None,
                           "params":0, "bias":0})
    for layer in model.layers:
        try:
            dic_layer = {"name":layer.name, "in":int(layer.input.shape[-1]), "neurons":layer.units, 
                         "out":int(layer.output.shape[-1]), "activation":layer.get_config()["activation"],
                         "params":layer.get_weights()[0], "bias":layer.get_weights()[1]}
        except:
            dic_layer = {"name":layer.name, "in":int(layer.input.shape[-1]), "neurons":0, 
                         "out":int(layer.output.shape[-1]), "activation":None,
                         "params":0, "bias":0}
        lst_layers.append(dic_layer)
    return lst_layers



'''
繪制神經網路的草圖
'''
def visualize_nn(model, description=False, figsize=(10,8)):
    # 獲取層次資訊
    lst_layers = utils_nn_config(model)
    layer_sizes = [layer["out"] for layer in lst_layers]
    
    # 繪圖設定
    fig = plt.figure(figsize=figsize)
    ax = fig.gca()
    ax.set(title=model.name)
    ax.axis('off')
    left, right, bottom, top = 0.1, 0.9, 0.1, 0.9
    x_space = (right-left) / float(len(layer_sizes)-1)
    y_space = (top-bottom) / float(max(layer_sizes))
    p = 0.025
    
    # 中間節點
    for i,n in enumerate(layer_sizes):
        top_on_layer = y_space*(n-1)/2.0 + (top+bottom)/2.0
        layer = lst_layers[i]
        color = "green" if i in [0, len(layer_sizes)-1] else "blue"
        color = "red" if (layer['neurons'] == 0) and (i > 0) else color
        
        ## 添加資訊說明
        if (description is True):
            d = i if i == 0 else i-0.5
            if layer['activation'] is None:
                plt.text(x=left+d*x_space, y=top, fontsize=10, color=color, s=layer["name"].upper())
            else:
                plt.text(x=left+d*x_space, y=top, fontsize=10, color=color, s=layer["name"].upper())
                plt.text(x=left+d*x_space, y=top-p, fontsize=10, color=color, s=layer['activation']+" (")
                plt.text(x=left+d*x_space, y=top-2*p, fontsize=10, color=color, s="Σ"+str(layer['in'])+"[X*w]+b")
                out = " Y"  if i == len(layer_sizes)-1 else " out"
                plt.text(x=left+d*x_space, y=top-3*p, fontsize=10, color=color, s=") = "+str(layer['neurons'])+out)
        
        ## 遍歷
        for m in range(n):
            color = "limegreen" if color == "green" else color
            circle = plt.Circle(xy=(left+i*x_space, top_on_layer-m*y_space-4*p), radius=y_space/4.0, color=color, ec='k', zorder=4)
            ax.add_artist(circle)
            
            ## 添加文本說明
            if i == 0:
                plt.text(x=left-4*p, y=top_on_layer-m*y_space-4*p, fontsize=10, s=r'$X_{'+str(m+1)+'}$')
            elif i == len(layer_sizes)-1:
                plt.text(x=right+4*p, y=top_on_layer-m*y_space-4*p, fontsize=10, s=r'$y_{'+str(m+1)+'}$')
            else:
                plt.text(x=left+i*x_space+p, y=top_on_layer-m*y_space+(y_space/8.+0.01*y_space)-4*p, fontsize=10, s=r'$H_{'+str(m+1)+'}$')
    
    # 添加鏈接箭頭等
    for i, (n_a, n_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        layer = lst_layers[i+1]
        color = "green" if i == len(layer_sizes)-2 else "blue"
        color = "red" if layer['neurons'] == 0 else color
        layer_top_a = y_space*(n_a-1)/2. + (top+bottom)/2. -4*p
        layer_top_b = y_space*(n_b-1)/2. + (top+bottom)/2. -4*p
        for m in range(n_a):
            for o in range(n_b):
                line = plt.Line2D([i*x_space+left, (i+1)*x_space+left], 
                                  [layer_top_a-m*y_space, layer_top_b-o*y_space], 
                                  c=color, alpha=0.5)
                if layer['activation'] is None:
                    if o == m:
                        ax.add_artist(line)
                else:
                    ax.add_artist(line)
    plt.show()

我們在之前的 2 個模型上嘗試一下，首先是感知器：

visualize_nn(model, description=True, figsize=(10,8))

然后是深度神經網路：

當然，TensorFlow 本身也提供了一個繪制模型結構的方法，它不是像上述示例圖一樣的簡單形式呈現，而是輸出更多的模型層次資訊，下面是我們對深度模型呼叫 plot_model 的結果，

utils.plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)

同時也會生成名為model.png的圖片保存在你本地筆記本電腦上，

?? 訓練和測驗評估

下一步是訓練我們前面構建的深度學習模型，在 tensorflow.keras 中，我們需要先對模型『編譯』，或者換句話說，我們需要定義訓練程序中的一些細節，比如優化器Optimizer、損失函式Loss和評估準則Metrics，其中：

最常用的優化器是 Adam，它是一種用于梯度下降的替換優化演算法（自適應優化器中較好的），關于不同的優化演算法，大家可以閱讀學習ShowMeAI的文章 ?? 深度學習教程 | 神經網路優化演算法，
針對二分類問題，我們一般是用 （二元）交叉熵損失，它將每個預測概率與實際類輸出進行比較，關于損失函式，大家可以閱讀ShowMeAI的文章 ?? 深度學習與CV教程(3) | 損失函式與最優化，
評估指標，我們同時監控 Accuracy 和 F1-score，這是一個結合了 Precision 和 Recall 的綜合指標，關于評估準則，大家可以閱讀ShowMeAI的文章 ?? 圖解機器學習 | 模型評估方法與準則，

詳細的編譯代碼如下：

# 定義評估準則
def Recall(y_true, y_pred):
    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
    recall = true_positives / (possible_positives + K.epsilon())
    return recall

def Precision(y_true, y_pred):
    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
    precision = true_positives / (predicted_positives + K.epsilon())
    return precision

def F1(y_true, y_pred):
    precision = Precision(y_true, y_pred)
    recall = Recall(y_true, y_pred)
    return 2*((precision*recall)/(precision+recall+K.epsilon()))
    
# 編譯神經網路
model.compile(optimizer='adam', loss='binary_crossentropy', 
              metrics=['accuracy',F1])

我們當前是分類問題，如果是回歸問題，我們可以選用 MAE 為損失，將 R方作為度量，參考代碼如下：

# 定義R方評估準則
def R2(y, y_hat):
    ss_res =  K.sum(K.square(y - y_hat)) 
    ss_tot = K.sum(K.square(y - K.mean(y))) 
    return ( 1 - ss_res/(ss_tot + K.epsilon()) )
    
# 編譯神經網路
model.compile(optimizer='adam', loss='mean_absolute_error', 
              metrics=[R2])

神經網路的訓練，大部分時候，不是一次性把資料都送入模型學習的（因為資料量非常大，通常GPU不足以容納這種規模的資料，同時全量資料也容易陷入區域最低點）

關于評估準則，大家可以閱讀ShowMeAI的文章 ?? 深度學習教程 | 神經網路優化演算法

我們通常會采用一個批次一個批次資料訓練的方式，因此在開始訓練之前，我們還需要確定 Epochs 和 Batches：其中Epochs代表全量資料迭代的次數，Batches代表單個批次資料樣本的數量，

總的資料會拆分為若干批次（每個batch的樣本數量越大，您需要的記憶體空間越多），反向傳播和引數更在每批資料上都會進行，一個Epoch是對整個訓練集的一次遍歷，

如果我們手頭有 100 個樣本且batch大小為 20，則需要 5 個batch才能完成 1 個 epoch，batch大小盡量選擇為2的倍數（常見：32、64、128、256），因為計算機通常以 2 的冪來組織記憶體，

在訓練程序中，理想的狀態是隨著一輪一輪的資料迭代，評估指標在不斷改進，損失在逐步減少，不過這個結果只表明在訓練集資料上我們在學習，但在新資料上是否有同樣的效果并不好確定，因此我們會保留一部分資料（20%左右）用于驗證評估，

我們用代碼來做說明，我們在這里簡單地生成隨機資料構建特征資料X和標簽資料y，例如

import numpy as np
X = np.random.rand(1000,10)
y = np.random.choice([1,0], size=1000)

那我們可以基于下述方式對資料進行訓練和評估

# 訓練和評估
training = model.fit(x=X, y=y, batch_size=32, epochs=100, shuffle=True, verbose=0, validation_split=0.2)

# 繪制評估指標
metrics = [k for k in training.history.keys() if ("loss" not in k) and ("val" not in k)]    
fig, ax = plt.subplots(nrows=1, ncols=2, sharey=True, figsize=(15,3))
       
# 訓練階段 
ax[0].set(title="Training")    
ax11 = ax[0].twinx()    
ax[0].plot(training.history['loss'], color='black')    ax[0].set_xlabel('Epochs')    
ax[0].set_ylabel('Loss', color='black')    
for metric in metrics:        
    ax11.plot(training.history[metric], label=metric)    ax11.set_ylabel("Score", color='steelblue')    
ax11.legend()
        
# 驗證集評估階段
ax[1].set(title="Validation")    
ax22 = ax[1].twinx()    
ax[1].plot(training.history['val_loss'], color='black')    ax[1].set_xlabel('Epochs')    
ax[1].set_ylabel('Loss', color='black')    
for metric in metrics:          
    ax22.plot(training.history['val_'+metric], label=metric)    ax22.set_ylabel("Score", color="steelblue")    
plt.show()

得到的結果圖如下所示（下2幅圖分別為分類和回歸場景下的訓練集與驗證集的loss和評估準則指標）：

?? 模型可解釋性

實際生產程序中，神經網路效果可能很好，但我們實際是不太方向直接把它當做一個黑盒來用的，我們希望對模型做一些可解釋性分析，能部分地理解我們的模型，

我們在這里會用到一個模型可解釋性工具 ?? Shap ，用它和神經網路搭配對模型做一些解釋，

具體說來，對于每個樣本的預測，我們結合shap都能夠估計每個特征對模型預測結果的貢獻，進而部分解釋問模型的問題『為什么預測這是 1 而不是 0？』（二分類場景），

參考代碼如下：

'''
使用shap構建解釋器
:parameter
    :param model: model instance (after fitting)
    :param X_names: list
    :param X_instance: array of size n x 1 (n,)
    :param X_train: array - if None the model is simple machine learning, if not None then it's a deep learning model
    :param task: string - "classification", "regression"
    :param top: num - top features to display
:return
    dtf with explanations
'''
def explainer_shap(model, X_names, X_instance, X_train=None, task="classification", top=10):
    # 構建解釋器
    # 機器學習（樹模型）
    if X_train is None:
        explainer = shap.TreeExplainer(model)
        shap_values = explainer.shap_values(X_instance)
    # 深度學習（神經網路）
    else:
        explainer = shap.DeepExplainer(model, data=https://www.cnblogs.com/showmeai/archive/2022/08/09/X_train[:100])
        shap_values = explainer.shap_values(X_instance.reshape(1,-1))[0].reshape(-1)

    # 繪圖
    # 分類場景
    if task =="classification":
        shap.decision_plot(explainer.expected_value, shap_values, link='logit', feature_order='importance',
                           features=X_instance, feature_names=X_names, feature_display_range=slice(-1,-top-1,-1))
    # 回歸場景
    else:
        shap.waterfall_plot(explainer.expected_value[0], shap_values, 
                            features=X_instance, feature_names=X_names, max_display=top)

shap實際上是一個很有效的工具，大家在上述代碼也可以看到，實際它可以應用在機器學習模型（如線性回歸、隨機森林）上，也可以應用在神經網路上，從代碼中可以看出，如果 X_train 引數為 None，會選擇機器學習模型進行解釋，否則使用深度學習進行解釋分析，

我們在Titanic分類問題和房價預估回歸問題上進行測驗：（對應的這兩個案例大家可以在ShowMeAI后續的文章中找到）

i = 1explainer_shap(model, 
               X_names=list_feature_names, 
               X_instance=X[i], 
               X_train=X, 
               task="classification", # 分類任務
               top=10)

上圖中，Titanic問題中，預測為『Survived』主要因素是變數 Sex_male = 0，即乘客是女性，

上圖中，在房價預估的回歸問題中，影響最大的因素是房屋的面積，

參考資料

?? 深度學習教程 | 吳恩達專項課程 · 全套筆記解讀: https://www.showmeai.tech/tutorials/35
?? 自然語言處理教程 | 斯坦福CS224n課程 · 課程帶學與全套筆記解讀: https://www.showmeai.tech/tutorials/36
?? 深度學習與計算機視覺教程：斯坦福CS231n · 全套筆記解讀: https://www.showmeai.tech/tutorials/37
?? 深度學習教程 | 神經網路基礎: https://www.showmeai.tech/article-detail/213
?? 深度學習教程 | 淺層神經網路: https://www.showmeai.tech/article-detail/214
?? 深度學習教程 | 深層神經網路: https://www.showmeai.tech/article-detail/215
?? 深度學習教程 | 深度學習的實用層面: https://www.showmeai.tech/article-detail/216
?? 深度學習教程 | 神經網路優化演算法: https://www.showmeai.tech/article-detail/217
?? 深度學習與CV教程 | 損失函式與最優化: https://www.showmeai.tech/article-detail/262
?? 圖解機器學習 | 模型評估方法與準則: https://www.showmeai.tech/article-detail/186
?? TensorFlow速查手冊: https://www.showmeai.tech/article-detail/109
?? Matplotlib速查手冊: https://www.showmeai.tech/article-detail/103

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/501369.html

標籤：其他

上一篇：全自動化機器學習建模！效果吊打初級煉丹師！ ?

下一篇：羨慕 Excel 的高級選擇與文本框顏色呈現？Pandas 也可以擁有！！ ?

爆肝萬字，終于搞定這篇?神經網路搭建全全全流程！學不會你來找我~