使用python手寫實現(xiàn)單層神經網絡[本質上學習logistic 回歸的系數(shù)]懊亡。單層：有參數(shù)的一層楣责；輸入不算網絡層遏餐。

網絡用途

或者說應用場景：使用單層神經網絡來識別一張圖片是否是貓咪的圖片慨削。

數(shù)學表示

給定一張圖片$X$ 送到網絡中友驮，判斷這張圖片是否是貓咪的照片旨涝？

網絡架構

單層神經網絡:

• X(input)---> Output($\hat{y}$)

處理過程：

• X --> linear ---> sigmoid ---> $\hat{y}$

數(shù)學表示

訓練集: $X = [x^{(1)},x{(2)},...,x^{(i)},....,x{(m)}]$ ;對應標簽:$Y=[y^{(1)},y{(2)},...,y^{(i)},...,y{(m)}]$ ;

對于訓練集中的每張照片$x^{(i)}$ 的處理過程：

$z^{(i)} = w^Tx{(i)}+b$

$\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})$

$L(a^{(i)},y{(i)}) = -y^{(i)}log(a{(i)})-(1-y^{{(i)})log(1-a}{(i)})$

成本函數(shù)：

$J = \frac{1}{m} \sum_{i=1}^{m} L(a^{(i)},y{(i)})$

最后通過反向傳播算法蹬屹，計算參數(shù)$W$ 和 $b$ 。

模型定義

模型定義步驟

1. 定義模型結構（如輸入向量的特征數(shù)目）
2. 初始化模型參數(shù)；
3. 循環(huán)：
   • 前向傳播慨默，計算loss贩耐；
   • 反向傳播，計算梯度厦取；
   • 梯度下降潮太，更新參數(shù)；

代碼實現(xiàn)

輔助函數(shù)

def sigmoid(z):
    """
    激活函數(shù)
    Arguments:
    z -- 標量或者是numpy array類型

    Return:
    s -- sigmoid(z)
    """
    s = 1/(1+np.exp(-z))
    
    return s

參數(shù)初始化

權重系數(shù)$W$和$b$ 全都初始化為0.

def initialize_with_zeros(dim):
    """
    網絡參數(shù)w 和 b 的初始化虾攻；
    
    Argument:
    dim -- 表示權重系數(shù)w的維度[這里表示輸入層的數(shù)據維度]---單層網絡铡买；
    
    Returns:
    w -- 初始化向量 shape (dim, 1)
    b -- 初始化標量 
    """
    w = np.zeros((dim, 1))#dim表示輸入層X的維度，1表示本層只有一個神經元
    b = 0

    return w, b

前向傳播和反向傳播

由于網絡為單層神經網絡霎箍，前向傳播過程和反向傳播過程比較簡單奇钞，所以整合到一起。直接計算出相應的成本函數(shù)和相應的系數(shù)梯度朋沮。

前向傳播過程

訓練集: $$X = [x^{(1)},x{(2)},...,x^{(i)},....,x{(m)}]$$ ;對應標簽:$$Y=[y^{(1)},y{(2)},...,y^{(i)},...,y{(m)}] $$;

對于訓練集中的每張照片$x^{(i)}$ 的處理過程：

$z^{(i)} = w^Tx{(i)}+b$

$\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})$

$L(a^{(i)},y{(i)}) = -y^{(i)}log(a{(i)})-(1-y^{{(i)})log(1-a}{(i)})$

成本函數(shù)：$J = \frac{1}{m} \sum_{i=1}^{m} L(a^{(i)},y{(i)})$

反向傳播過程

假設輸入數(shù)據維度為2蛇券；權重系數(shù)維度是2.

反向傳播的計算圖:

image

以輸入維度為2，權重系數(shù)w為2維樊拓，舉例：

image

def propagate(w, b, X, Y):
    """
    實現(xiàn)前向傳播和反向傳播過程

    Arguments:
    w -- 權重系數(shù)纠亚，numpy array，size (num_px * num_px * 3, 1)
    b -- 偏置筋夏，標量
    X -- 輸入的測試數(shù)據蒂胞，shape (num_px * num_px * 3, 樣本數(shù)m)
    Y -- 測試數(shù)據的標簽向量 ( 0 不是貓, 1 貓) ，size (1, m) 

    Return:
    cost -- logistic 回歸的成本函數(shù)值
    dw -- 成本函數(shù)關于參數(shù)w的梯度值
    db -- 成本函數(shù)關于參數(shù)w的梯度值
    """
    
    m = X.shape[1] # 獲取樣本數(shù)

    # 前向傳播過程
    Z = np.dot(w.T, X) + b
    A = sigmoid(Z) #計算激活函數(shù)
    cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))  # 計算成本函數(shù)
    
    # 反向傳播過程計算梯度
    dw = 1 / m * np.dot(X, (A - Y).T) # 向量
    db = 1 / m * np.sum(A - Y)
    assert(dw.shape == w.shape)
    assert(db.dtype == float)
    cost = np.squeeze(cost) # 成本函數(shù)
    assert(cost.shape == ())
    
    grads = {"dw": dw,
             "db": db}
    
    return grads, cost

參數(shù)優(yōu)化

參數(shù)更新過程--使用梯度下降算法条篷；

def optimize(w,b,X,y,num_iters,learning_rate,print_cost=True):
    """
    參數(shù)優(yōu)化過程
    :param w: 系數(shù)矩陣
    :param b: 偏置
    :param X: 測試集
    :param y: 測試集標簽
    :param num_iters: 迭代次數(shù)
    :param learning_rate: 學習率
    :param print_cost: 是否打印輸出cost變化;每100次打印輸出一次
    :return:
    - params: 更新后的參數(shù)
    - grads: 梯度計算值
    - costs：cost變化過程骗随；每100次為一個記錄值
    """
    costs = []

    for i in range(num_iters):
        grads, cost = propagate(w, b, X, y)
        dw = grads['dw']
        db = grads['db']
        #參數(shù)更新
        w = w - learning_rate * dw
        b = b - learning_rate * db

        if i % 100 == 0:#添加到costs
            costs.append(cost)
        if print_cost and i % 100 == 0: # 打印輸出
            print("Cost after iteration {}:{}".format(i, cost))

        params = {'w': w,
                  'b': b}

    return params, grads, costs

模型預測

輸入測試集，輸出測試標簽.

運算過程：做一次前向傳播赴叹，得到輸出鸿染；再對輸出和threshold閾值作比較，得出類別標簽乞巧。

def predict(w,b,X):
    """
    給定一張圖片預測分類標簽
    :param w: 訓練后的權重w參數(shù) (n_px * n_px * 3, 1)
    :param b: 訓練后的偏置b參數(shù)
    :param X: 測試圖片 (n_px * n_px * 3, m)
    :return: 分類標簽yHat
    """
    m = X.shape[1]
    yHat = np.zeros((1, m))
    assert (w.shape == (X.shape[0], 1))
    yHat = sigmoid(np.dot(w.T, X) + b) # 前向傳播過程

    # 確定預測的分類標簽 threshold為0.5
    for i in range(m):
        if yHat[0, i] > 0.5:
            yHat[0, i] = 1
        else:
            yHat[0, i] = 0

    return yHat

函數(shù)整合

def model(X_train, y_train, X_test, y_test, num_iters=2000, learning_rate=0.05, print_cost=True):
    """
    將所有的函數(shù)整合到一起形成一個完整的模型
    :param X_train: 訓練集 (n_px*n_px*3, m)
    :param y_train: 訓練集標簽 (1, m)
    :param X_test: 測試集 (n_px*n_px*3, n)
    :param y_test: 測試集標簽 (1, n)
    :param num_iters: 迭代次數(shù)
    :param learning_rate: 學習率
    :param print_cost: 是否打印輸出cost成本函數(shù)值
    :return:
    - d: 模型信息字典
    """
    w, b = initialize_with_zeros(X_train.shape[0])

    params, grads, costs = optimize(w, b, X_train, y_train, num_iters, learning_rate, print_cost)

    w = params['w']
    b = params['b']

    yHat_train = predict(w, b, X_train)
    yHat_test = predict(w, b, X_test)

    print("Accuracy on Training set:{:.2f}%".format(100*np.mean(y_train == yHat_train)))
    print("Accuracy on Test set:{:.2f}%".format(100*np.mean(y_test == yHat_test)))

    d = {
        'costs': costs,
        'yHat_train': yHat_train,
        'yHat_test': yHat_test,
        'w': w,
        'b': b,
        'learning_rate': learning_rate,
        'num_iters': num_iters
    }

    return d

測試：500次迭代涨椒、學習率為0.001；

d = model(X_train,y_train,X_test,y_test,num_iters=500,learning_rate=0.001)

輸出結果變化：

Cost after iteration 0:0.6931471805599453
Cost after iteration 100:0.5912894260003537
Cost after iteration 200:0.5557961107127088
Cost after iteration 300:0.5289765131562365
Cost after iteration 400:0.5068812917435517
Accuracy on Training set:77.51%
Accuracy on Test set:56.00%

小結

1. 向量化運算能大大提高運算效率绽媒；編碼實現(xiàn)時最好不要使用for-loop 循環(huán)蚕冬；
2. 理解網絡運算過程時，畫一個運算圖很很大程度上幫助理解是辕；
3. 編碼實現(xiàn)時囤热，注意變量的shape變化是否正確！

完整代碼：>>點我