python用numpy写有一个隐藏层的神经网络函数，输入层有两个节点，输出层有一个节点

下面是一个使用 Numpy 实现单隐藏层神经网络的 Python 函数，输入层有两个节点，输出层有一个节点：

import numpy as np

def neural_network(X, Y, hidden_layer_size, num_iterations, learning_rate):
    # 初始化参数
    n_x = X.shape[0] # 输入层大小
    n_h = hidden_layer_size # 隐藏层大小
    n_y = Y.shape[0] # 输出层大小
    
    W1 = np.random.randn(n_h, n_x) * 0.01 # 隐藏层参数
    b1 = np.zeros((n_h, 1)) # 隐藏层偏置
    W2 = np.random.randn(n_y, n_h) * 0.01 # 输出层参数
    b2 = np.zeros((n_y, 1)) # 输出层偏置
    
    # 迭代训练
    for i in range(num_iterations):
        # 前向传播
        Z1 = np.dot(W1, X) + b1
        A1 = np.tanh(Z1)
        Z2 = np.dot(W2, A1) + b2
        A2 = 1 / (1 + np.exp(-Z2))
        
        # 计算损失
        cost = -np.sum(Y * np.log(A2) + (1 - Y) * np.log(1 - A2)) / m
        
        # 反向传播
        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
        
        # 更新参数
        W1 = W1 - learning_rate * dW1
        b1 = b1 - learning_rate * db1
        W2 = W2 - learning_rate * dW2
        b2 = b2 - learning_rate * db2
        
        # 每迭代 100 次输出一次损失
        if i % 100 == 0:
            print("Iteration %d, cost: %f" % (i, cost))
    
    # 返回训练好的参数
    return {"W1": W1, "b1": b1, "W2": W2, "b2": b2}

这个函数接受四个参数：

- `X`：输入数据，一个 $(n_x, m)$ 的矩阵，其中 $n_x$ 是输入层大小，$m$ 是样本数。
- `Y`：输出数据，一个 $(n_y, m)$ 的矩阵，其中 $n_y$ 是输出层大小。
- `hidden_layer_size`：隐藏层大小。
- `num_iterations`：迭代次数。
- `learning_rate`：学习率。

函数的返回值是一个字典，包含训练好的参数。

这个函数使用了 tanh 激活函数和交叉熵损失函数。在训练过程中，它输出每 100 次迭代的损失值。