【吴恩达深度学习编程作业】1.3浅层神经网络——单隐藏层的平面数据分类

灰太狼 2022-12-13 01:20 171阅读 0赞

第二次跟着 [带有一个隐藏层的平面数据分类][Link 1] 把作业代码码了一遍，感觉思路更加清晰了。今天刚刚填报了国家保研系统中的基本信息，最近的学习状态很差，是时候沉下心来认真学习了。

## main.py ##

# 搭建一个单隐藏层的神经网络
    
    import numpy as np
    import matplotlib.pyplot as plt
    import sklearn      # 为数据挖掘和数据分析提供的简单高效的工具
    import sklearn.datasets
    import sklearn.linear_model
    from Deep_Learning.testCases import *       # 提供一些测试示例来评估函数的正确性
    from Deep_Learning.planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets    # 提供在本实例中使用的各种有用的功能
    
    np.random.seed(1)   # 设置一个固定的随机种子，以保证接下来的步骤中我们的结果是一致的
    
    # 加载和查看数据集
    # 将一个花的图案的2类数据集加载到变量X和Y中
    X, Y = load_planar_dataset()
    # 可视化数据集
    plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)  # 绘制散点图
    plt.show()
    
    # 数据看起来是由红色（y=0）和蓝色（y=1）的数据点的组成的花朵，我们的目标是建立一个模型适应这些数据
    # 我们已有X（一个numpy的矩阵，包含这些数据点的数值），Y：（一个numpy的向量，对应着的是X的标签【0|1】（红色：0，蓝色：1））
    
    shape_X = X.shape
    shape_Y = Y.shape
    m = Y.shape[1]  # 训练集里面的数量
    print("X的维度为：" + str(shape_X))
    print("Y的维度为：" + str(shape_Y))
    print("数据集里面的数据有：" + str(m))
    
    
    # 训练数据集上的逻辑回归分类器
    clf = sklearn.linear_model.LogisticRegressionCV()
    clf.fit(X.T, Y.T)
    
    # 绘制逻辑分类器的分类
    plot_decision_boundary(lambda x: clf.predict(x), X, np.squeeze(Y))  # 绘制决策边界
    plt.title("Logistic Regression")    # 图标题
    LR_predictions = clf.predict(X.T)   # 预测结果
    plt.show()
    print("逻辑回归的准确性：%d" % float((np.dot(Y, LR_predictions)
          + np.dot(1 - Y, 1 - LR_predictions))
          / float(Y.size) * 100) + "%"
          + "(正确标记的数据点所占的百分比)")
    # 准确性只有47%原因是数据集不是线性可分的，所以逻辑回归表现不佳，以下开始正式构建神经网络
    
    
    # 定义神经网络的结构
    def layer_sizes(X, Y):
        """ :param X: -输入数据集，维度为（输入的数量，训练/测试的数量） :param Y: -标签，维度为（输出的数量，训练/测试数量） :return: n_x: -输入层的数量 n_h: -隐藏层的数量 n_y: -输出层的数量 """
        n_x = X.shape[0]    # 输入层的数量
        n_h = 4     # 隐藏层，设置为4
        n_y = Y.shape[0]    # 输出层
        return (n_x, n_h, n_y)
    
    # 测试layer_sizes
    print("========================测试layer_sizes===========================")
    X_asses, Y_asses = layer_sizes_test_case()
    (n_x, n_h, n_y) = layer_sizes(X_asses, Y_asses)
    print("输入层的节点数量为：n_x = " + str(n_x))
    print("隐藏层的节点数量为：n_h = " + str(n_h))
    print("输出层的节点数量为：n_y = " + str(n_y))
    
    
    # 初始化模型的参数
    def initialize_parameters(n_x, n_h, n_y):
        """ :param n_x: -输入层节点的数量 :param n_h: -隐藏层节点的数量 :param n_y: -输出层节点的数量 :return: parameters -包含参数的字典 W1 -权重矩阵，维度为（n_h, n_x） b1 -偏向量，维度为（n_h, 1） W2 -权重矩阵，维度为（n_y, n_h） b2 -偏向量，维度为（n_y, 1） """
        np.random.seed(2)   # 指定一个随机种子
        W1 = np.random.rand(n_h, n_x) * 0.01
        b1 = np.zeros(shape=(n_h, 1))
        W2 = np.random.rand(n_y, n_h) * 0.01
        b2 = np.zeros(shape=(n_y, 1))
    
        # 使用断言确保数据格式的正确性
        assert (W1.shape == (n_h, n_x))
        assert (b1.shape == (n_h, 1))
        assert (W2.shape == (n_y, n_h))
        assert (b2.shape == (n_y, 1))
    
        parameters = { "W1": W1,
                      "b1": b1,
                      "W2": W2,
                      "b2": b2}
    
        return parameters
    
    # 测试initialize_parameters
    print("=====================测试initialize_parameters=========================")
    n_x, n_h, n_y = initialize_parameters_test_case()
    parameters = initialize_parameters(n_x, n_h, n_y)
    print("W1 = " + str(parameters["W1"]))
    print("b1 = " + str(parameters["b1"]))
    print("W2 = " + str(parameters["W2"]))
    print("b2 = " + str(parameters["b2"]))
    
    
    # 实现前向传播
    def forword_propagation(X, parameters):
        """ :param X: -维度为（n_x, m）的输入数据 :param parameters: -初始化函数（initialize_parameters）的输出 :return: A2 -使用sigmoid函数计算的第二次激活后的数值 cache -包含“Z1”,“A1”，“Z2”，“A2”的字典类型变量 """
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
        # 前向传播计算A2
        Z1 = np.dot(W1, X) + b1
        A1 = np.tanh(Z1)
        Z2 = np.dot(W2, A1) + b2
        A2 = sigmoid(Z2)
        assert (A2.shape == (1, X.shape[1]))
        cache = { "Z1": Z1,
                 "A1": A1,
                 "Z2": Z2,
                 "A2": A2
                 }
        return (A2, cache)
    
    # 测试forword_propagation
    print("=======================测试forword_propagation=====================")
    X_asses, parameters = forward_propagation_test_case()
    A2, cache = forword_propagation(X_asses, parameters)
    print(np.mean(cache["Z1"]), np.mean(cache["A1"]), np.mean(cache["Z2"]), np.mean(cache["A2"]))
    
    
    # 计算损失
    # 计算交叉熵损失
    # logprobs = np.multiply(np.log(A2), Y)
    # cost = -np.sum(logprobs) # 不需要使用循环就可以直接计算
    # 构建计算成本函数
    def compute_cost(A2, Y, parameters):
        """ :param A2: -使用sigmoid函数计算的第二次激活后的数值 :param Y: -"True"标签向量，维度为（1，数量） :param parameters: -一个包含W1,b1,W2,b2的字典类型的变量 :return: cost -交叉熵成本 """
        m = Y.shape[1]
        W1 = parameters["W1"]
        W2 = parameters["W2"]
    
        # 计算成本
        logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))
        np.seterr(divide='ignore', invalid='ignore')    # 忽略除以0的情况，消除警告
        cost = - np.sum(logprobs) / m
        cost = float(np.squeeze(cost))
    
        assert (isinstance(cost, float))
    
        return cost
    
    # 测试compute_cost
    print("========================测试compute_cost======================")
    A2, Y_asses, parameters = compute_cost_test_case()
    print("cost = " + str(compute_cost(A2, Y_asses, parameters)))
    
    
    # 反向传播
    def backward_propagation(parameters, cache, X, Y):
        """ :param parameters: -包含我们的参数的一个字典类型的变量 :param cache: -包含"Z1","A1","Z2","A2"的字典类型的变量 :param X: -输入数据，维度为（2，数量） :param Y: -"True"标签向量，维度为（1，数量） :return:grads -包含W和b的导数一个字典类型的变量 """
        m = X.shape[1]
    
        W1 = parameters["W1"]
        W2 = parameters["W2"]
        A1 = cache["A1"]
        A2 = cache["A2"]
    
        dZ2 = A2 - Y
        dW2 = (1 / m) * np.dot(dZ2, A1.T)
        db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
        dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))   # 激活函数为tanh，其导数为1-a^2
        dW1 = (1 / m) * np.dot(dZ1, X.T)
        db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)
        grads = { "dW1": dW1,
                 "db1": db1,
                 "dW2": dW2,
                 "db2": db2}
        return grads
    
    # 测试backward_propagation
    print("=======================测试backward_propagation======================")
    parameters, cache, X_asses, Y_asses = backward_propagation_test_case()
    grads = backward_propagation(parameters, cache, X_asses, Y_asses)
    print("dW1 = " + str(grads["dW1"]))
    print("db1 = " + str(grads["db1"]))
    print("dW2 = " + str(grads["dW2"]))
    print("db2 = " + str(grads["db2"]))
    
    
    # 更新参数
    def update_parameters(parameters, grads, learning_rate=1.2):
        """ 使用梯度下降更新规则更新参数 :param parameters: -包含参数的字典类型的变量 :param grads: -包含导数值的字典类型的变量 :param learning_rate: -学习速率 :return: parameters -包含更新参数的字典类型的变量 """
        W1, W2 = parameters["W1"], parameters["W2"]
        b1, b2 = parameters["b1"], parameters["b2"]
    
        dW1, dW2 = grads["dW1"], grads["dW2"]
        db1, db2 = grads["db1"], grads["db2"]
    
        W1 = W1 - learning_rate * dW1
        b1 = b1 - learning_rate * db1
        W2 = W2 - learning_rate * dW2
        b2 = b2 - learning_rate * db2
    
        parameters = { "W1": W1,
                      "b1": b1,
                      "W2": W2,
                      "b2": b2}
    
        return parameters
    
    # 测试update_parameters
    print("======================测试update_parameters======================")
    parameters, grads, = update_parameters_test_case()
    parameters = update_parameters(parameters, grads)
    print("W1 = " + str(parameters["W1"]))
    print("b1 = " + str(parameters["b1"]))
    print("W2 = " + str(parameters["W2"]))
    print("b2 = " + str(parameters["b2"]))
    
    
    # 将所有的函数整合到一个model中
    def nn_model(X, Y, n_h, num_iterations, print_cost=False):
        """ :param X: -数据集，维度为（2，示例数） :param Y: -标签，维度为（1，示例数） :param n_h: -隐藏层的数量 :param num_iterations: -梯度下降循环中的迭代次数 :param print_cost: -如果为True，则每1000次迭代打印一次成本数值 :return: parameters -模型学习的参数，它们可以用来进行预测 """
        np.random.seed(3)   # 指定随机种子
        n_x = layer_sizes(X, Y)[0]
        n_y = layer_sizes(X, Y)[2]
    
        parameters = initialize_parameters(n_x, n_h, n_y)
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
    
        for i in range(num_iterations):
            A2, cache = forword_propagation(X, parameters)
            cost = compute_cost(A2, Y, parameters)
            grads = backward_propagation(parameters, cache, X, Y)
            parameters = update_parameters(parameters, grads, learning_rate=1.2)
    
            if print_cost:
                if i % 1000 == 0:
                    print("第", i, "次循环，成本为：" + str(cost))
    
        return parameters
    
    # 测试nn_model
    print("====================测试nn_model=======================")
    X_asses, Y_asses = nn_model_test_case()
    parameters = nn_model(X_asses, Y_asses, 4, num_iterations=10000, print_cost=False)
    print("W1 = " + str(parameters["W1"]))
    print("b1 = " + str(parameters["b1"]))
    print("W2 = " + str(parameters["W2"]))
    print("b2 = " + str(parameters["b2"]))
    
    
    # 使用前向传播预测结果
    def predict(parameters, X):
        """ 使用学习的参数，为X中的每一个示例预测一个类 :param parameters: -包含参数的字典类型的变量 :param X: -输入数据（n_x, m） :return: predictions -模型预测的向量（红色：0|蓝色：1） """
        A2, cache = forword_propagation(X, parameters)
        predictions = np.round(A2)      # round函数近似取值
        return predictions
    
    # 测试predict
    print("=======================测试predict======================")
    parameters, X_asses = predict_test_case()
    predictions = predict(parameters, X_asses)
    print("预测的平均值 = " + str(np.mean(predictions)))
    
    
    # 正式运行
    parameters = nn_model(X, Y, n_h=4, num_iterations=10000, print_cost=True)
    
    # 绘制边界
    plot_decision_boundary(lambda x: predict(parameters, x.T), X, np.squeeze(Y))
    plt.title("Decision Boundary for hidden layer size " + str(4))
    
    predictions = predict(parameters, X)
    print('准确率：%d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')
    plt.show()
    
    
    # 更改隐藏层节点数量，以上测试中隐藏层节点数为4
    plt.figure(figsize=(16, 32))
    hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50]    # 隐藏层数量
    for i, n_h in enumerate(hidden_layer_sizes):
    
        plt.subplot(3, 3, i + 1)
        plt.title('Hidden Layer of size %d' % n_h)
        parameters = nn_model(X, Y, n_h, num_iterations=5000)
        plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
        predictions = predict(parameters, X)
        accuracy = float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100)
        print("隐藏层的节点数量：{}，准确率{}%".format(n_h, accuracy))
    plt.show()
    # 较大的模型（具有更多隐藏单元）能够更好地适应训练集，直到最终的最大模型过度拟合数据。
    # 最好的隐藏层大小似乎在n_h = 5附近，这里的值似乎很适合数据，而且不会引起过度拟合。

## planar\_utils.py ##

import matplotlib.pyplot as plt
    import numpy as np
    import sklearn
    import sklearn.datasets
    import sklearn.linear_model
    
    def plot_decision_boundary(model, X, y):
        # Set min and max values and give it some padding
        x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
        y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
        h = 0.01
        # Generate a grid of points with distance h between them
        xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
        # Predict the function value for the whole grid
        Z = model(np.c_[xx.ravel(), yy.ravel()])
        Z = Z.reshape(xx.shape)
        # Plot the contour and training examples
        plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
        plt.ylabel('x2')
        plt.xlabel('x1')
        plt.scatter(X[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral)
    
    
    def sigmoid(x):
        """ 当x是一个非常小的负数时，exp(-x)会过大，导致溢出，下面进行优化： 原式分子分母同乘exp(x)这个很小的数，可以防止数据溢出 """
        # if x >= 0:
        # s = 1.0 / (1 + np.exp(-x))
        # else:
        # s = np.exp(x) / (1 + np.exp(x))
        s = 1 / (1 + np.exp(-x))
        return s
    
    def load_planar_dataset():
        np.random.seed(1)
        m = 400 # number of examples
        N = int(m/2) # number of points per class
        D = 2 # dimensionality
        X = np.zeros((m,D)) # data matrix where each row is a single example
        Y = np.zeros((m,1), dtype='uint8') # labels vector (0 for red, 1 for blue)
        a = 4 # maximum ray of the flower
    
        for j in range(2):
            ix = range(N*j,N*(j+1))
            t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
            r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
            X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
            Y[ix] = j
    
        X = X.T
        Y = Y.T
    
        return X, Y
    
    def load_extra_datasets():  
        N = 200
        noisy_circles = sklearn.datasets.make_circles(n_samples=N, factor=.5, noise=.3)
        noisy_moons = sklearn.datasets.make_moons(n_samples=N, noise=.2)
        blobs = sklearn.datasets.make_blobs(n_samples=N, random_state=5, n_features=2, centers=6)
        gaussian_quantiles = sklearn.datasets.make_gaussian_quantiles(mean=None, cov=0.5, n_samples=N, n_features=2, n_classes=2, shuffle=True, random_state=None)
        no_structure = np.random.rand(N, 2), np.random.rand(N, 2)
    
        return noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure

## testCases.py ##

#-*- coding: UTF-8 -*-
    """ # WANGZHE12 """
    import numpy as np
    
    def layer_sizes_test_case():
        np.random.seed(1)
        X_assess = np.random.randn(5, 3)
        Y_assess = np.random.randn(2, 3)
        return X_assess, Y_assess
    
    def initialize_parameters_test_case():
        n_x, n_h, n_y = 2, 4, 1
        return n_x, n_h, n_y
    
    def forward_propagation_test_case():
        np.random.seed(1)
        X_assess = np.random.randn(2, 3)
    
        parameters = { 'W1': np.array([[-0.00416758, -0.00056267],
            [-0.02136196,  0.01640271],
            [-0.01793436, -0.00841747],
            [ 0.00502881, -0.01245288]]),
         'W2': np.array([[-0.01057952, -0.00909008,  0.00551454,  0.02292208]]),
         'b1': np.array([[ 0.],
            [ 0.],
            [ 0.],
            [ 0.]]),
         'b2': np.array([[ 0.]])}
    
        return X_assess, parameters
    
    def compute_cost_test_case():
        np.random.seed(1)
        Y_assess = np.random.randn(1, 3)
        parameters = { 'W1': np.array([[-0.00416758, -0.00056267],
            [-0.02136196,  0.01640271],
            [-0.01793436, -0.00841747],
            [ 0.00502881, -0.01245288]]),
         'W2': np.array([[-0.01057952, -0.00909008,  0.00551454,  0.02292208]]),
         'b1': np.array([[ 0.],
            [ 0.],
            [ 0.],
            [ 0.]]),
         'b2': np.array([[ 0.]])}
    
        a2 = (np.array([[ 0.5002307 ,  0.49985831,  0.50023963]]))
    
        return a2, Y_assess, parameters
    
    def backward_propagation_test_case():
        np.random.seed(1)
        X_assess = np.random.randn(2, 3)
        Y_assess = np.random.randn(1, 3)
        parameters = { 'W1': np.array([[-0.00416758, -0.00056267],
            [-0.02136196,  0.01640271],
            [-0.01793436, -0.00841747],
            [ 0.00502881, -0.01245288]]),
         'W2': np.array([[-0.01057952, -0.00909008,  0.00551454,  0.02292208]]),
         'b1': np.array([[ 0.],
            [ 0.],
            [ 0.],
            [ 0.]]),
         'b2': np.array([[ 0.]])}
    
        cache = { 'A1': np.array([[-0.00616578,  0.0020626 ,  0.00349619],
             [-0.05225116,  0.02725659, -0.02646251],
             [-0.02009721,  0.0036869 ,  0.02883756],
             [ 0.02152675, -0.01385234,  0.02599885]]),
      'A2': np.array([[ 0.5002307 ,  0.49985831,  0.50023963]]),
      'Z1': np.array([[-0.00616586,  0.0020626 ,  0.0034962 ],
             [-0.05229879,  0.02726335, -0.02646869],
             [-0.02009991,  0.00368692,  0.02884556],
             [ 0.02153007, -0.01385322,  0.02600471]]),
      'Z2': np.array([[ 0.00092281, -0.00056678,  0.00095853]])}
        return parameters, cache, X_assess, Y_assess
    
    def update_parameters_test_case():
        parameters = { 'W1': np.array([[-0.00615039,  0.0169021 ],
            [-0.02311792,  0.03137121],
            [-0.0169217 , -0.01752545],
            [ 0.00935436, -0.05018221]]),
     'W2': np.array([[-0.0104319 , -0.04019007,  0.01607211,  0.04440255]]),
     'b1': np.array([[ -8.97523455e-07],
            [  8.15562092e-06],
            [  6.04810633e-07],
            [ -2.54560700e-06]]),
     'b2': np.array([[  9.14954378e-05]])}
    
        grads = { 'dW1': np.array([[ 0.00023322, -0.00205423],
            [ 0.00082222, -0.00700776],
            [-0.00031831,  0.0028636 ],
            [-0.00092857,  0.00809933]]),
     'dW2': np.array([[ -1.75740039e-05,   3.70231337e-03,  -1.25683095e-03,
              -2.55715317e-03]]),
     'db1': np.array([[  1.05570087e-07],
            [ -3.81814487e-06],
            [ -1.90155145e-07],
            [  5.46467802e-07]]),
     'db2': np.array([[ -1.08923140e-05]])}
        return parameters, grads
    
    def nn_model_test_case():
        np.random.seed(1)
        X_assess = np.random.randn(2, 3)
        Y_assess = np.random.randn(1, 3)
        return X_assess, Y_assess
    
    def predict_test_case():
        np.random.seed(1)
        X_assess = np.random.randn(2, 3)
        parameters = { 'W1': np.array([[-0.00615039,  0.0169021 ],
            [-0.02311792,  0.03137121],
            [-0.0169217 , -0.01752545],
            [ 0.00935436, -0.05018221]]),
         'W2': np.array([[-0.0104319 , -0.04019007,  0.01607211,  0.04440255]]),
         'b1': np.array([[ -8.97523455e-07],
            [  8.15562092e-06],
            [  6.04810633e-07],
            [ -2.54560700e-06]]),
         'b2': np.array([[  9.14954378e-05]])}
        return parameters, X_assess

## 运行结果 ##

X的维度为：(2, 400)
    Y的维度为：(1, 400)
    数据集里面的数据有：400
    F:\Python\lib\site-packages\sklearn\utils\validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().
      return f(**kwargs)
    逻辑回归的准确性：47%(正确标记的数据点所占的百分比)
    ========================测试layer_sizes===========================
    输入层的节点数量为：n_x = 5
    隐藏层的节点数量为：n_h = 4
    输出层的节点数量为：n_y = 2
    =====================测试initialize_parameters=========================
    W1 = [[0.00435995 0.00025926]
     [0.00549662 0.00435322]
     [0.00420368 0.00330335]
     [0.00204649 0.00619271]]
    b1 = [[0.]
     [0.]
     [0.]
     [0.]]
    W2 = [[0.00299655 0.00266827 0.00621134 0.00529142]]
    b2 = [[0.]]
    =======================测试forword_propagation=====================
    -0.0004997557777419913 -0.0004969633532317802 0.0004381874509591466 0.500109546852431
    ========================测试compute_cost======================
    cost = 0.6929198937761266
    =======================测试backward_propagation======================
    dW1 = [[ 0.01018708 -0.00708701]
     [ 0.00873447 -0.0060768 ]
     [-0.00530847  0.00369379]
     [-0.02206365  0.01535126]]
    db1 = [[-0.00069728]
     [-0.00060606]
     [ 0.000364  ]
     [ 0.00151207]]
    dW2 = [[ 0.00363613  0.03153604  0.01162914 -0.01318316]]
    db2 = [[0.06589489]]
    ======================测试update_parameters======================
    W1 = [[-0.00643025  0.01936718]
     [-0.02410458  0.03978052]
     [-0.01653973 -0.02096177]
     [ 0.01046864 -0.05990141]]
    b1 = [[-1.02420756e-06]
     [ 1.27373948e-05]
     [ 8.32996807e-07]
     [-3.20136836e-06]]
    W2 = [[-0.01041081 -0.04463285  0.01758031  0.04747113]]
    b2 = [[0.00010457]]
    ====================测试nn_model=======================
    G:\Project\PYTHON\Demo01\Deep_Learning\planar_utils.py:33: RuntimeWarning: overflow encountered in exp
      s = 1 / (1 + np.exp(-x))
    W1 = [[ 7.52965472 -1.24309301]
     [ 4.21291395 -5.31399817]
     [ 7.52966135 -1.2431499 ]
     [ 4.21397291 -5.31333161]]
    b1 = [[-3.79468532]
     [-2.32838083]
     [-3.79485646]
     [-2.3283009 ]]
    W2 = [[6006.88570125 6032.88338564 6007.41279754 6032.66790904]]
    b2 = [[-53.17690741]]
    =======================测试predict======================
    预测的平均值 = 0.6666666666666666
    第 0 次循环，成本为：0.6931586620054873
    第 1000 次循环，成本为：0.289307766073059
    第 2000 次循环，成本为：0.2738595561686524
    第 3000 次循环，成本为：0.238115797061788
    第 4000 次循环，成本为：0.22810205919496226
    第 5000 次循环，成本为：0.22331808633565126
    第 6000 次循环，成本为：0.220192917928194
    第 7000 次循环，成本为：0.21786964182913665
    第 8000 次循环，成本为：0.21603567135242685
    第 9000 次循环，成本为：0.21863707045894862
    准确率：90%
    隐藏层的节点数量：1，准确率67.5%
    隐藏层的节点数量：2，准确率67.25%
    隐藏层的节点数量：3，准确率90.75%
    隐藏层的节点数量：4，准确率90.75%
    隐藏层的节点数量：5，准确率91.25%
    隐藏层的节点数量：20，准确率90.0%
    隐藏层的节点数量：50，准确率91.0%

## 依次显示的图片 ##

**原始数据集：**  
![原始数据集][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center]  
**简单逻辑回归分类：**![简单逻辑回归分类][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 1]  
**四个隐藏层的神经网络分类结果：**  
![四个隐藏层的神经网络分类][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 2]  
**不同隐藏层的神经网络分类结果：**  
![不同隐藏层的神经网络分类结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 3]

## 目前仍然存在的问题： ##

*  sigmoid函数需要优化

> RuntimeWarning: overflow encountered in exp s = 1 / (1 + np.exp(-x))

*  代码存在警告，但可以正常运行

> DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n\_samples, ), for example using ravel(). return f(\*\*kwargs)

[Link 1]: https://blog.csdn.net/u013733326/article/details/79702148
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/e4d9655b81144709a0e977e9cd8177d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/5597a1f0a55848d8b45c6b097929fa93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/8ba2d9e97ab142748d97fa9cd763556a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/b589b38a99df44a9bf0f631a5298872e.png