【手把手系列之一】手写实现单层神经网络

def sigmoid(z):
    """
    激活函数
    Arguments:
    z -- 标量或者是numpy array类型

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

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

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

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

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%