專欄中《零神經(jīng)網(wǎng)絡(luò)實(shí)戰(zhàn)》系列持續(xù)更新介紹神經(jīng)元怎么工作，最后使用python從0到1不調(diào)用任何依賴神經(jīng)網(wǎng)絡(luò)框架（不使用tensorflow等框架)來實(shí)現(xiàn)神經(jīng)網(wǎng)絡(luò)，梯度下降、反向傳播、卷積神經(jīng)網(wǎng)絡(luò)CNN、循環(huán)神經(jīng)網(wǎng)絡(luò)RNN。從0基礎(chǔ)角度進(jìn)行神經(jīng)網(wǎng)絡(luò)實(shí)戰(zhàn)。
上一篇：零基礎(chǔ)神經(jīng)網(wǎng)絡(luò)實(shí)戰(zhàn)(1)：單個(gè)神經(jīng)元+隨機(jī)梯度下降學(xué)習(xí)邏輯與規(guī)則
作者：司南牧

實(shí)例介紹反向傳播，為何說深度學(xué)習(xí)離不開反向傳播？

之前介紹了單個(gè)神經(jīng)元如何利用隨機(jī)梯度下降自己調(diào)節(jié)權(quán)重。深度學(xué)習(xí)指的是數(shù)以百千層的層數(shù)很深的神經(jīng)網(wǎng)絡(luò)，每層又有數(shù)以百千個(gè)神經(jīng)元。那么深度學(xué)習(xí)是否也可以使用這種形式的梯度下降來進(jìn)行調(diào)節(jié)權(quán)重呢？答：很難。為什么？主要原因是太深了。為何“深”用梯度下降解會(huì)有問題呢？主要是因?yàn)殒準(zhǔn)椒▌t導(dǎo)致計(jì)算損失函數(shù)對(duì)前面層權(quán)重的導(dǎo)數(shù)時(shí)，損失函數(shù)對(duì)后面層權(quán)重的導(dǎo)數(shù)總是被重復(fù)計(jì)算，反向傳播就是將那些計(jì)算的值保存減少重復(fù)計(jì)算。不明白？那這篇文章就看對(duì)了。接下來將解釋這個(gè)重復(fù)計(jì)算過程。反向傳播就是梯度下降中的求導(dǎo)環(huán)節(jié)，它從后往前計(jì)算導(dǎo)數(shù)重復(fù)利用計(jì)算過的導(dǎo)數(shù)而已。。梯度下降不懂或者神經(jīng)網(wǎng)絡(luò)不懂請(qǐng)先閱讀這個(gè)文章單個(gè)神經(jīng)元+隨機(jī)梯度下降學(xué)習(xí)邏輯與規(guī)則。

文章結(jié)構(gòu)：

1. 為何要使用反向傳播？
2. 反向傳播優(yōu)化神經(jīng)網(wǎng)絡(luò)權(quán)重參數(shù)實(shí)踐。

為何要使用反向傳播？

我們用一個(gè)最簡單的三層神經(jīng)網(wǎng)絡(luò)（無激活函數(shù)）來進(jìn)行解釋為何需要使用反向傳播，所使用的三層神經(jīng)網(wǎng)絡(luò)如下所示：

這里我們有三個(gè)要優(yōu)化的參數(shù)：w1,w2,w3。

我們先用傳統(tǒng)的梯度下降方法來看看哪些地方重復(fù)計(jì)算了，而反向傳播就是將這些重復(fù)計(jì)算的地方計(jì)算結(jié)果保存，并且向前面層傳播這個(gè)值以減少運(yùn)算復(fù)雜度。 梯度下降需要先得求損失函數(shù)對(duì)w1,w2,w3的導(dǎo)數(shù)，然后根據(jù)導(dǎo)數(shù)來不斷迭代更新w1,w2,w3的值。

第1層：求損失函數(shù)L(w1,w2,w3)對(duì)w1的導(dǎo)數(shù)（更規(guī)范的講是偏導(dǎo)數(shù)）。

我們先看看損失函數(shù)L(w1,w2,w3)和w1之間的關(guān)系是什么。

$$L(w1,w2,w3)=1/2 (e-/hat e )^2$$
e=w3 * z
z=w2 * y
y=w1 * x

所以這是個(gè)復(fù)合函數(shù)的求導(dǎo)。根據(jù)高中學(xué)習(xí)到的復(fù)合函數(shù)求導(dǎo)法則（也是大家可能經(jīng)常聽到的鏈?zhǔn)椒▌t），復(fù)合函數(shù)求導(dǎo)等于各級(jí)復(fù)合函數(shù)導(dǎo)數(shù)的乘積，也就是這樣

第2層：求損失函數(shù)L(w1,w2,w3)對(duì)w2的導(dǎo)數(shù)。
我們再看看損失函數(shù)L(w1,w2,w3)和w2之間的關(guān)系是什么。

$$L(w1,w2,w3)=1/2 (e-/hat e )^2$$
e=w3 * z
z=w2 * y

根據(jù)復(fù)合函數(shù)求導(dǎo)可得：

第3層：求損失函數(shù)L(w1,w2,w3)對(duì)w3的導(dǎo)數(shù)。
我們再看看損失函數(shù)L(w1,w2,w3)和w3之間的關(guān)系是什么。

$$L(w1,w2,w3)=1/2 (e-/hat e )^2$$
e=w3 * z

根據(jù)復(fù)合函數(shù)求導(dǎo)可得：

我們將這三層的損失函數(shù)對(duì)相應(yīng)層權(quán)重導(dǎo)數(shù)列在一起看看哪兒重復(fù)計(jì)算了：

我們再看看這個(gè)圖：

所搭建的最簡單的三層神經(jīng)網(wǎng)絡(luò)

你會(huì)發(fā)現(xiàn)，如果將損失函數(shù)也看做是一層的話。即我們認(rèn)為e->L(w1,w2,w3)這也算一層。

找規(guī)律：

反向傳播過程理解

前面我們提到了可以從后面往前面計(jì)算，將公共部分的導(dǎo)數(shù)往前傳。這只是解決了求導(dǎo)問題，那怎么進(jìn)行參數(shù)更新呢？答：參數(shù)更新跟梯度下降完全一樣，都是這個(gè)公式。反向傳播就是梯度下降中的求導(dǎo)環(huán)節(jié)，它重復(fù)利用計(jì)算過的導(dǎo)數(shù)而已。

我們看看反向傳播版的使用梯度下降進(jìn)行參數(shù)更新是怎樣的。

損失函數(shù)L(w1,w2,w3)是這樣：$$L(w1,w2,w3)=1/2 (e-/hat e )^2$$

其他的幾層函數(shù)如下所示：

第3層：e=w3 * z
第2層：z=w2 * y
第1層：y=w1 * x

在這篇文章“單個(gè)神經(jīng)元+隨機(jī)梯度下降學(xué)習(xí)邏輯與規(guī)則”介紹了，權(quán)重更新是一個(gè)不斷猜（迭代更新）的過程。下一次權(quán)重值 = 本次權(quán)重值 - 學(xué)習(xí)率* 損失函數(shù)對(duì)該權(quán)重的導(dǎo)數(shù)。定義學(xué)習(xí)率為α. 接下來我們只需要知道怎么利用后面層數(shù)傳遞過來的值來求“損失函數(shù)對(duì)當(dāng)前層權(quán)重wi的導(dǎo)數(shù)”即可。

則各層網(wǎng)絡(luò)更新權(quán)重的步驟為如下所示：

1.更新第3層權(quán)重參數(shù)w3.

2.更新第2層權(quán)重參數(shù)w2

3.更新第1層權(quán)重參數(shù)w1.

所以，將上面3步用偽代碼寫可以寫成下面這樣。

終于可以告別可怕的公式了，越難的東西你堅(jiān)持了，你的不可替代性就越強(qiáng)。加油你不是一個(gè)人在奮斗。

反向傳播實(shí)踐

我們將上面的偽代碼轉(zhuǎn)成Python代碼。我們希望這個(gè)神經(jīng)網(wǎng)絡(luò)能自己學(xué)習(xí)到的功能是輸入x輸出的e=-x.

我們提供訓(xùn)練集數(shù)據(jù)（我們只有兩條數(shù)據(jù)）：

重復(fù)訓(xùn)練次數(shù)epoch = 160。

好開工實(shí)現(xiàn)它。

# -*- coding: UTF-8 -*-
"""
@author 知乎：@Ai醬
"""
class NeuralNetwork:

    def __init__(self):
        self.LEARNING_RATE = 0.05 # 設(shè)置學(xué)習(xí)率
        # 初始化網(wǎng)絡(luò)各層權(quán)重（權(quán)重的初試值也會(huì)影響神經(jīng)網(wǎng)絡(luò)是否收斂）
        # 博主試了下權(quán)重初始值都為0.2333是不行的
        self.w3 = -0.52133
        self.w2 = -0.233
        self.w1 = 0.2333
        self.data = [1, -1] # 輸入數(shù)據(jù)
        self.label= [-1, 1]

    def train(self):
        epoch = 160
        for _ in range(epoch):
            # 逐個(gè)樣本進(jìn)行訓(xùn)練模型
            for i in range(len(self.data)):
                x = self.data[i]
                e_real = self.label[i]

                self.y = self.w1 * x #計(jì)算第1層輸出
                self.z = self.w2 * self.y # 計(jì)算第2層輸出
                self.e = self.w3 * self.z # 計(jì)算第3層輸出

                # 開始反向傳播優(yōu)化權(quán)重
                self.result3 = self.e - e_real
                self.w3 = self.w3 - self.LEARNING_RATE * self.result3 * self.z

                self.result2 = self.result3 * self.w3
                self.w2 = self.w2 - self.LEARNING_RATE * self.result2 * self.y

                self.w1 = self.w1 - self.LEARNING_RATE * self.result2 * self.w2 * x

    def predict(self,x):
        self.y = self.w1 * x #計(jì)算第1層輸出
        self.z = self.w2 * self.y # 計(jì)算第2層輸出
        self.e = self.w3 * self.z # 計(jì)算第3層輸出
        return 1 if self.e>0 else -1
nn = NeuralNetwork()
nn.train()
print(1,',',nn.predict(1))
print(-1,',',nn.predict(-1))
'''
輸出:
1 , -1
-1 , 1
'''

如何檢驗(yàn)反向傳播是否寫對(duì)？

手動(dòng)推導(dǎo)，人工判斷

前面提到了反向傳播本質(zhì)是梯度下降，那么關(guān)鍵在于導(dǎo)數(shù)必須對(duì)。我們現(xiàn)在網(wǎng)絡(luò)比較小可以直接手動(dòng)計(jì)算導(dǎo)數(shù)比對(duì)代碼中對(duì)各權(quán)重導(dǎo)數(shù)是否求對(duì)。

比如上面代碼中三個(gè)參數(shù)的導(dǎo)數(shù)將代碼中的result*展開表示就是：

dw3 = (self.e - e_real) * self.z
    = (self.e - e_real) * self.w2 * self.y
    =  (self.e - e_real) * self.w2 * self.w1 * x
    = (self. w3 * self.w2 * self.w1 * x - e_real) * self.w2 * self.w1 * x

dw2 = (self.e - e_real) * self.w3* self.y
    = (self.e - e_real) * self.w3* self.w1 * x
    = (self. w3 * self.w2 * self.w1 * x - e_real) * self.w3* self.w1 * x

dw3 =  self.result3 * self.z
    = (self.e - e_real) * self.w2 * self.w1 * x
    = (self. w3 * self.w2 * self.w1 * x - e_real)* self.w2 * self.w1 * x

而損失函數(shù)展開可以表示為： $$L(w1,w2,w3) = 1/2 (w3 * w2 * w1 * x - /hat e)^2$$

對(duì)各權(quán)重參數(shù)求導(dǎo)為：

$${dL}/ {dw3} = (w3 * w2 * w1 * x - /hat e) * w2 * w1$$

$${dL}/ {dw2} = (w3 * w2 * w1 * x - /hat e) * w3 * w1$$

$${dL}/ {dw1} = (w3 * w2 * w1 * x - /hat e) * w3 * w2$$

可以發(fā)現(xiàn)我們代碼展開，與我們實(shí)際的公式求導(dǎo)是一致的證明我們代碼是正確的。

但是，一旦層數(shù)很深，那么我們就不能這么做了

我們需要用代碼自動(dòng)判斷是否反向傳播寫對(duì)了。

代碼自動(dòng)判斷反向傳播的導(dǎo)函數(shù)是否正確

這個(gè)和手工判斷方法類似。反向傳播是否正確，關(guān)鍵在于dL/dwi是否計(jì)算正確。根據(jù)高中學(xué)過的導(dǎo)數(shù)的定義,對(duì)于位于點(diǎn)θ的導(dǎo)數(shù)有：

$$f'(/theta) = /lim_{/epsilon/to 0} {f(/theta + /epsilon) + f(/theta - /epsilon) } /{2/epsilon}$$

所以我們可以看反向傳播求的導(dǎo)函數(shù)值和用導(dǎo)數(shù)定義求的導(dǎo)函數(shù)值是否接近。

即我們需要讓代碼判斷這個(gè)式子是否成立：$${dL}/ {dwi} /approx {L(wi+ 10^{-4}) - L(wi- 10^{-4})} /{2* 10^{-4}}$$

左邊的dL/dwi是反向傳播求得，右邊是導(dǎo)數(shù)定義求的導(dǎo)數(shù)值。這兩個(gè)導(dǎo)數(shù)應(yīng)當(dāng)大致相同。

實(shí)踐：程序自動(dòng)檢驗(yàn)導(dǎo)函數(shù)是否正確：

新增了一個(gè)梯度檢驗(yàn)函數(shù)check_gradient()，如下所示：

# -*- coding: UTF-8 -*-
"""
@author 知乎：@Ai醬
"""
class NeuralNetwork:

    def __init__(self):
        self.LEARNING_RATE = 0.05 # 設(shè)置學(xué)習(xí)率
        # 初始化網(wǎng)絡(luò)各層權(quán)重（權(quán)重的初試值也會(huì)影響神經(jīng)網(wǎng)絡(luò)是否收斂）
        # 博主試了下權(quán)重初始值都為0.2333是不行的
        self.w3 = -0.52133
        self.w2 = -0.233
        self.w1 = 0.2333

        self.data = [1, -1] # 輸入數(shù)據(jù)
        self.label= [-1, 1]
    def L(self,w1,w2,w3,x,e_real):
        '''
        損失函數(shù) return 1/2 * (e - e_real)^2
        '''
        return 0.5*(w1*w2*w3*x - e_real)**2

    def train(self):
        epoch = 160
        for _ in range(epoch):
            # 逐個(gè)樣本進(jìn)行訓(xùn)練模型
            for i in range(len(self.data)):
                x = self.data[i]
                e_real = self.label[i]

                self.y = self.w1 * x #計(jì)算第1層輸出
                self.z = self.w2 * self.y # 計(jì)算第2層輸出
                self.e = self.w3 * self.z # 計(jì)算第3層輸出

                # 開始反向傳播優(yōu)化權(quán)重
                self.result3 = self.e - e_real
                self.w3 = self.w3 - self.LEARNING_RATE * self.result3 * self.z

                self.result2 = self.result3 * self.w3
                self.w2 = self.w2 - self.LEARNING_RATE * self.result2 * self.y

                self.w1 = self.w1 - self.LEARNING_RATE * self.result2 * self.w2 * x
                self.check_gradient(x,e_real)

    def check_gradient(self,x,e_real):
        # 反向傳播所求得的損失函數(shù)對(duì)各權(quán)重的導(dǎo)數(shù)
        dw3 = self.result3 * self.z
        dw2 = self.result2 * self.y
        dw1 = self.result2 * self.w2 * x

        # 使用定義求損失函數(shù)對(duì)各權(quán)重的導(dǎo)數(shù)
        epsilon = 10**-4 # epsilon為10的4次方
        # 求損失函數(shù)在w3處的左極限和右極限
        lim_dw3_right = self.L(self.w1, self.w2, self.w3+epsilon, x, e_real)
        lim_dw3_left = self.L(self.w1, self.w2, self.w3-epsilon, x, e_real)
        # 利用左右極限求導(dǎo)
        lim_dw3 = (lim_dw3_right - lim_dw3_left)/(2*epsilon)

        lim_dw2_right = self.L(self.w1, self.w2+epsilon, self.w3, x, e_real)
        lim_dw2_left = self.L(self.w1, self.w2-epsilon, self.w3, x, e_real)
        lim_dw2 = (lim_dw2_right - lim_dw2_left)/(2*epsilon)

        lim_dw1_right = self.L(self.w1+epsilon, self.w2, self.w3, x, e_real)
        lim_dw1_left = self.L(self.w1-epsilon, self.w2, self.w3, x, e_real)
        lim_dw1 = (lim_dw1_right - lim_dw1_left)/(2*epsilon)

        # 比對(duì)反向傳播求的導(dǎo)數(shù)和用定義求的導(dǎo)數(shù)是否接近
        print("dl/dw3反向傳播求得：%f,定義求得%f"%(dw3,lim_dw3))
        print("dl/dw2反向傳播求得：%f,定義求得%f"%(dw2,lim_dw2))
        print("dl/dw1反向傳播求得：%f,定義求得%f"%(dw1,lim_dw1))

    def predict(self,x):
        self.y = self.w1 * x #計(jì)算第1層輸出
        self.z = self.w2 * self.y # 計(jì)算第2層輸出
        self.e = self.w3 * self.z # 計(jì)算第3層輸出
        return 1 if self.e>0 else -1
nn = NeuralNetwork()
nn.train()
print(1,',',nn.predict(1))
print(-1,',',nn.predict(-1))
'''
輸出:
dl/dw1反向傳播求得：-0.026729,定義求得-0.026727
dl/dw3反向傳播求得：0.003970,定義求得0.004164
dl/dw2反向傳播求得：-0.032617,定義求得-0.033257
dl/dw1反向傳播求得：-0.027502,定義求得-0.027499
dl/dw3反向傳播求得：0.004164,定義求得0.004367
dl/dw2反向傳播求得：-0.033272,定義求得-0.033932
dl/dw1反向傳播求得：-0.028291,定義求得-0.028288
dl/dw3反向傳播求得：0.004367,定義求得0.004579
dl/dw2反向傳播求得：-0.033947,定義求得-0.034625
dl/dw1反向傳播求得：-0.029097,定義求得-0.029094
... ...
1 , -1
-1 , 1
'''

可以發(fā)現(xiàn)反向傳播求得損失函數(shù)對(duì)各參數(shù)求得的導(dǎo)數(shù)和我們用高中學(xué)的定義法求導(dǎo)數(shù)，兩者基本一致，證明我們反向傳播求得的導(dǎo)數(shù)沒有問題。

附上上面的易讀版代碼的github代碼下載地址：從本質(zhì)如何理解機(jī)器學(xué)習(xí)？

框架化反向傳播

每個(gè)程序員都有一個(gè)寫框架的夢想，不如我們將前面的代碼寫個(gè)類似TensorFlow這種框架的反向傳播簡單框架吧。附上框架版的代碼github下載地址：https://github.com/varyshare/newbie_neural_network_practice/blob/master/backpropagation/backpropagation_framework.py

# -*- coding: utf-8 -*-
"""
框架化反向傳播編程
@author: 知乎@Ai醬
"""

import random
class Layer(object):
    '''
    本文中，一層只有一個(gè)神經(jīng)元，一個(gè)神經(jīng)元只有一個(gè)輸入一個(gè)輸出
    '''
    def __init__(self,layer_index):
        '''
        layer_index: 第幾層
        '''
        self.layer_index = layer_index
        # 初始化權(quán)重[0,1] - 0.5 = [-0.5,0.5]保證初始化有正有負(fù)
        self.w = random.random() - 0.5 
        # 當(dāng)前層的輸出
        self.output = 0
        
    def forward(self,input_var):
        '''
        前向傳播：對(duì)輸入進(jìn)行運(yùn)算，并將結(jié)果保存
        input_var: 當(dāng)前層的輸入
        '''
        self.input = input_var
        self.output = self.w * self.input
        
    
    def backward(self, public_value):
        '''
        反向傳播：計(jì)算上層也會(huì)使用的導(dǎo)數(shù)值并保存
        假設(shè)當(dāng)前層的計(jì)算規(guī)則是這樣output = f(input)，
        而 input == 前一層的輸出，
        因此，根據(jù)鏈?zhǔn)椒▌t損失函數(shù)對(duì)上一層權(quán)重的導(dǎo)數(shù) = 后面層傳過來的公共導(dǎo)數(shù)* f'(input) * 前一層的導(dǎo)數(shù)
        也就是說，后面層傳過來的公共導(dǎo)數(shù)值* f'(input) 是需要往前傳的公用的導(dǎo)數(shù)值。
        由于本層中對(duì)輸入做的運(yùn)算為：output = f(input) = w*input
        所以, f'(input) = w.
        public_value: 后面?zhèn)鬟^來的公共導(dǎo)數(shù)值
        '''
        # 當(dāng)前層要傳給前面層的公共導(dǎo)數(shù)值 = 后面?zhèn)鬟^來的公共導(dǎo)數(shù)值 * f'(input)
        self.public_value = public_value * self.w
        # 損失函數(shù)對(duì)當(dāng)前層參數(shù)w的導(dǎo)數(shù) = 后面?zhèn)鬟^來的公共導(dǎo)數(shù)值 * f'(input) * doutput/dw
        self.w_grad = self.public_value * self.input
    
    def upate(self, learning_rate):
        '''
        利用梯度下降更新參數(shù)w
        參數(shù)迭代更新規(guī)則（梯度下降）： w = w - 學(xué)習(xí)率*損失函數(shù)對(duì)w的導(dǎo)數(shù)
        learning_rate: 學(xué)習(xí)率
        '''
        self.w = self.w - learning_rate * self.w_grad
    
    def display(self):
        print('layer',self.layer_index,'w:',self.w)

class Network(object):
    def __init__(self,layers_num):
        '''
        構(gòu)造網(wǎng)絡(luò)
        layers_num: 網(wǎng)絡(luò)層數(shù)
        '''
        self.layers = []
        # 向網(wǎng)絡(luò)添加層
        for i in range(layers_num):
            self.layers.append(Layer(i+1))#層編號(hào)從1開始
    
    def predict(self, sample):
        '''
        sample: 樣本輸入
        return 最后一層的輸出
        '''
        output = sample
        for layer in self.layers:
            layer.forward(output)
            output = layer.output
        return 1 if output>0 else -1
    
    def calc_gradient(self, label):
        '''
        從后往前計(jì)算損失函數(shù)對(duì)各層的導(dǎo)數(shù)
        '''
        # 計(jì)算最后一層的導(dǎo)數(shù)
        last_layer = self.layers[-1]
        # 由于損失函數(shù)=0.5*(last_layer.output - label)^2
        # 由于backward中的public_value = 輸出對(duì)輸入的導(dǎo)數(shù)
        # 對(duì)于損失函數(shù)其輸入是last_layer.output，損失函數(shù)對(duì)該輸入的導(dǎo)數(shù)=last_layer.output - label
        # 所以 最后一層的backward的public_value = last_layer.output - label
        last_layer.backward(last_layer.output - label)
        public_value = last_layer.public_value
        for layer in self.layers:
            layer.backward(public_value) # 計(jì)算損失函數(shù)對(duì)該層參數(shù)的導(dǎo)數(shù)
            public_value= layer.public_value
            
    def update_weights(self, learning_rate):
        '''
        更新各層權(quán)重
        '''
        for layer in self.layers:
            layer.upate(learning_rate)
        
    
    def train_one_sample(self, label, sample, learning_rate):
        self.predict(sample) # 前向傳播，使得各層的輸入都有值
        self.calc_gradient(label) # 計(jì)算各層導(dǎo)數(shù)
        self.update_weights(learning_rate) # 更新各層參數(shù)
        
    def train(self, labels, data_set, learning_rate, epoch):
        '''
        訓(xùn)練神經(jīng)網(wǎng)絡(luò)
        labels: 樣本標(biāo)簽
        data_set: 輸入樣本們
        learning_rate: 學(xué)習(xí)率
        epoch: 同樣的樣本反復(fù)訓(xùn)練的次數(shù)
        '''
        for _ in range(epoch):# 同樣數(shù)據(jù)反復(fù)訓(xùn)練epoch次保證權(quán)重收斂
            for i in range(len(labels)):#逐樣本更新權(quán)重
                self.train_one_sample(labels[i], data_set[i], learning_rate)

nn = Network(3)
data_set = [1,-1]
labels   = [-1,1]
learning_rate = 0.05
epoch = 160
nn.train(labels,data_set,learning_rate,epoch)
print(nn.predict(1)) # 輸出 -1
print(nn.predict(-1)) # 輸出 1

歡迎關(guān)注我的知乎專欄適合初學(xué)者的機(jī)器學(xué)習(xí)神經(jīng)網(wǎng)絡(luò)理論到實(shí)踐。
上一篇為零基礎(chǔ)神經(jīng)網(wǎng)絡(luò)實(shí)戰(zhàn)(1)：單個(gè)神經(jīng)元+隨機(jī)梯度下降學(xué)習(xí)邏輯與規(guī)則
下一篇為適合初學(xué)者的神經(jīng)網(wǎng)絡(luò)理論到實(shí)踐(3):打破概念束縛：強(qiáng)化學(xué)習(xí)是個(gè)啥？

審核編輯：符乾江