手写实现单层神经网络

发表于 | 更新于: | 分类于 | | 阅读次数:

使用python手写实现单层神经网络[本质上学习logistic 回归的系数]。单层：有参数的一层；输入不算网络层。

网络用途

或者说应用场景：使用单层神经网络来识别一张图片是否是猫咪。

网络架构

单层神经网络:

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

处理过程：

  • X –> linear —> sigmoid —> $\hat{y}$

数学表示

训练集: $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)})$

成本函数：

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

最后通过反向传播算法，计算参数$W$ 和 $b$ 。

模型定义

模型定义步骤

  1. 定义模型结构（如输入向量的特征数目）
  2. 初始化模型参数；
  3. 循环：
    • 前向传播，计算loss；
    • 反向传播，计算梯度；
    • 梯度下降，更新参数；

代码实现

辅助函数

1
2
3
4
5
6
7
8
9
10
11
12
def sigmoid(z):
    """
    激活函数
    Arguments:
    z -- 标量或者是numpy array类型

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

参数初始化

权重系数$W$和$b$ 全都初始化为0.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def initialize_with_zeros(dim):
    """
    网络参数w 和 b 的初始化；
    
    Argument:
    dim -- 表示权重系数w的维度[这里表示输入层的数据维度]---单层网络；
    
    Returns:
    w -- 初始化向量 shape (dim, 1)
    b -- 初始化标量 
    """
    w = np.zeros((dim, 1))#dim表示输入层X的维度，1表示本层只有一个神经元
    b = 0

    return w, b

前向传播和反向传播

由于网络为单层神经网络，前向传播过程和反向传播过程比较简单，所以整合到一起。直接计算出相应的成本函数和相应的系数梯度。

前向传播过程

训练集: $$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)})$

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

反向传播过程

假设输入数据维度为2；权重系数维度是2.

反向传播的计算图:

以输入维度为2，权重系数w为2维，举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def propagate(w, b, X, Y):
    """
    实现前向传播和反向传播过程

    Arguments:
    w -- 权重系数，numpy array，size (num_px * num_px * 3, 1)
    b -- 偏置，标量
    X -- 输入的测试数据，shape (num_px * num_px * 3, 样本数m)
    Y -- 测试数据的标签向量 ( 0 不是猫, 1 猫) ，size (1, m) 

    Return:
    cost -- logistic 回归的成本函数值
    dw -- 成本函数关于参数w的梯度值
    db -- 成本函数关于参数w的梯度值
    """
    
    m = X.shape[1] # 获取样本数

    # 前向传播过程
    Z = np.dot(w.T, X) + b
    A = sigmoid(Z) #计算激活函数
    cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))  # 计算成本函数
    
    # 反向传播过程计算梯度
    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) # 成本函数
    assert(cost.shape == ())
    
    grads = {"dw": dw,
             "db": db}
    
    return grads, cost

参数优化

参数更新过程–使用梯度下降算法；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def optimize(w,b,X,y,num_iters,learning_rate,print_cost=True):
    """
    参数优化过程
    :param w: 系数矩阵
    :param b: 偏置
    :param X: 测试集
    :param y: 测试集标签
    :param num_iters: 迭代次数
    :param learning_rate: 学习率
    :param print_cost: 是否打印输出cost变化;每100次打印输出一次
    :return:
    - params: 更新后的参数
    - grads: 梯度计算值
    - costs：cost变化过程；每100次为一个记录值
    """
    costs = []

    for i in range(num_iters):
        grads, cost = propagate(w, b, X, y)
        dw = grads['dw']
        db = grads['db']
        #参数更新
        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阈值作比较，得出类别标签。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def predict(w,b,X):
    """
    给定一张图片预测分类标签
    :param w: 训练后的权重w参数 (n_px * n_px * 3, 1)
    :param b: 训练后的偏置b参数
    :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

函数整合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def model(X_train, y_train, X_test, y_test, num_iters=2000, learning_rate=0.05, print_cost=True):
    """
    将所有的函数整合到一起形成一个完整的模型
    :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: 迭代次数
    :param learning_rate: 学习率
    :param print_cost: 是否打印输出cost成本函数值
    :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；

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

输出结果变化：

1
2
3
4
5
6
7
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. 向量化运算能大大提高运算效率；编码实现时最好不要使用for-loop 循环；
  2. 理解网络运算过程时，画一个运算图很很大程度上帮助理解；
  3. 编码实现时，注意变量的shape变化是否正确！

完整代码：>>点我

您的支持就是我更新的最大动力!谢谢!