#一.准备阶段#1.导入库文件# 导入numpy库并简写为np，用于高效的数值计算import numpy as np# 导入matplotlib的pyplot模块并简写为plt，用于数据可视化与绘图import matplotlib.pyplot as plt# 从testCases模块中导入所有测试用例，用于后续验证代码逻辑from testCases import *# 导入sklearn（scikit-learn）库，提供常用的机器学习算法与工具import sklearn# 导入sklearn中的datasets模块，用于加载内置的示例数据集import sklearn.datasets# 导入sklearn中的linear_model模块，提供线性回归等线性模型算法import sklearn.linear_model# 从planar_utils模块导入自定义工具函数，包括决策边界绘制、Sigmoid函数及数据集加载等from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets# 设置魔法命令，使matplotlib生成的图表能够直接在Jupyter Notebook中内联显示%matplotlib inline# 设置随机数种子为1，确保每次运行代码时生成的随机结果保持一致，便于复现和调试np.random.seed(1)#2.加载一维平面数据X, Y = load_planar_dataset()#3.定义神经网络结构def layer_size(X,Y):    n_x = X.shape[0]    n_h = 4    n_y = Y.shape[0]    return n_x,n_h,n_y#4.随机初始化参数def initialize_parameters(n_x,n_h,n_y):    # 设置随机种子，确保每次运行结果一致，方便调试    np.random.seed(2)    #初始化第一层权重矩阵(乘以0.01让初始值较小,避免梯度消失/爆炸）    W1=np.random.randn(n_h,n_x)*0.01    #初始化第一层偏置向量（初始化为 0）    b1 = np.zeros((n_h,1))    W2=np.random.randn(n_y,n_h)*0.01    b2 = np.zeros((n_y,1))    parameters = {        'W1':W1,        'b1':b1,        'W2':W2,        'b2':b2    }    return parameters#二.主体训练部分#1.前向传播def forward_propagation(X,parameters):   #~~~~~~~~~~~~不需要Y    #获取参数    W2 = parameters['W2']    b2 = parameters['b2']    W1 = parameters['W1']    b1 = parameters['b1']    #正向传播计算    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#求cost成本函数def compute_costs(X,Y,A2):    m = X.shape[1]  #求样本数量    costs=(-1/m)*np.sum(np.multiply(Y,np.log(A2))+np.multiply((1-Y),np.log(1-A2)))  #求交叉熵损失函数        #np.squeeze()专门用来“挤压”掉那些大小为 1 的维度        #如果costs的形状是[[17]]（形状为(1,1)）,np.squeeze会把它变成纯数字17。     costs = np.squeeze(costs)    assert(isinstance(costs, float))    return costs#2.反向传播计算梯度def backward_propagation(X,Y,cache,parameters):     m = X.shape[1]    W2 = parameters['W2']    b2 = parameters['b2']    W1 = parameters['W1']    b1 = parameters['b1']    A1 = cache['A1']    Z1 = cache['Z1']    A2 = cache['A2']    Z2 = cache['Z2']    #反向传播求梯度    dZ2 = A2-Y    dW2 = np.dot(dZ2,A1.T)/m    db2 = np.sum(dZ2,axis = 1,keepdims = True)/m    dZ1 = np.dot(W2.T,dZ2)*(1-np.power(A1,2))     dW1 = np.dot(dZ1,X.T)/m    db1 = np.sum(dZ1,axis = 1,keepdims = True)/m    grads = {        'dW2':dW2,        'db2':db2,        'dW1':dW1,        'db1':db1,    }    return grads#3.更新参数def update_paramegters(grabs,parameters,learning_rate = 1.2):    dW2 = grabs['dW2']    db2 = grabs['db2']    dW1 = grabs['dW1']    db1 = grabs['db1']    parameters['W2'] -= learning_rate*dW2    parameters['b2'] -= learning_rate*db2    parameters['W1'] -= learning_rate*dW1    parameters['b1'] -= learning_rate*db1    return parameters#三.模型集成def nn_model(X,Y,n_h,num_iterations = 10000,print_cost=True):    np.random.seed(3)  #设置随机种子，确保每次运行结果一致    #0.定义神经网络结构    n_x,n_h,n_y = layer_size(X,Y)    #1.随机初始化参数    parameters = initialize_parameters(n_x,n_h,n_y)    for i in range(num_iterations):      #for循环重复迭代训练进行反复梯度下降    #2.前向传播计算cost成本        A2,cache = forward_propagation(X,parameters)        costs = compute_costs(X,Y,A2)    #3.反向传播计算梯度        grads = backward_propagation(X,Y,cache,parameters)    #4.更新参数        parameters = update_parameters(grads,parameters,learning_rate = 1.2)        #打印costs        if print_cost and i % 1000 == 0:            print(f'{i} costs is :{costs}')    return parameters#四.预测def predict(parameters,X):    A2,cache = forward_propagation(X,parameters)    predictions = (A2>0.5)    return predictions# 新建一个单隐藏层模型，隐藏层维度为n_h = 4parameters = nn_model(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)# 画个决策边界plot_decision_boundary(lambda x: predict(parameters, x.T), X,Y.reshape(X[0,:].shape))plt.title("Decision Boundary for hidden layer size " + str(4))plt.show()