使用python手写实现单层神经网络[本质上学习logistic 回归的系数]。单层：有参数的一层；输入不算网络层。
网络用途
或者说应用场景：使用单层神经网络来识别一张图片是否是猫咪的图片。
数学表示
给定一张图片$X$ 送到网络中，判断这张图片是否是猫咪的照片？
网络架构
单层神经网络:
- 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)} = wTx{(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$ 。
模型定义
模型定义步骤
- 定义模型结构（如输入向量的特征数目）
- 初始化模型参数；
- 循环：
- 前向传播，计算loss；
- 反向传播，计算梯度；
- 梯度下降，更新参数；
代码实现
辅助函数
def sigmoid(z):
"""
激活函数
Arguments:
z -- 标量或者是numpy array类型
Return:
s -- sigmoid(z)
"""
s = 1/(1+np.exp(-z))
return s
参数初始化
权重系数$W$和$b$ 全都初始化为0.
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)} = wTx{(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维，举例：
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
参数优化
参数更新过程--使用梯度下降算法；
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阈值作比较，得出类别标签。
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
函数整合
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；
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%
小结
- 向量化运算能大大提高运算效率；编码实现时最好不要使用for-loop 循环；
- 理解网络运算过程时，画一个运算图很很大程度上帮助理解；
- 编码实现时，注意变量的shape变化是否正确！
完整代码：>>点我
