请设计一个输入为2、输出为3，具有2个隐藏层（神经元个数分别为4,2）的前馈神经网络。 （1）画出该网络。 （2）写出模型公式。 （3）生成随机数据并训练该网络。

（1）前馈神经网络的结构如下所示：

    x[2]      h1[4]      h2[2]      y[3]
o----->o w1[4,2] o w3[2,3] o w4[2,3] o---->
 ^        ^         ^          ^        ^
 |        |         |          |        |
o----->o w2[4,2] o w5[2,3] o w6[2,3] o---->
    h1_bias  h2_bias   y_bias

其中，x[2]表示输入层，h1[4]表示第一个隐藏层，h2[2]表示第二个隐藏层，y[3]表示输出层。每一层都有一组权重参数wi和偏置参数bi，以及一个激活函数f。

（2）模型公式如下：

$$
\begin{aligned}
h_1 &= f(xW_1 + b_1) \\
h_2 &= f(h_1W_3 + b_3) \\
y &= f(h_2W_4 + b_4) \\
\end{aligned}
$$

其中，$W_1$、$W_3$和$W_4$分别为权重矩阵，$b_1$、$b_3$和$b_4$分别为偏置向量，$f$为激活函数。

（3）生成随机数据并训练该网络。

为了训练该神经网络，我们需要准备训练数据和测试数据。由于输入为2，输出为3，我们可以随机生成一些数据，其中每个样本包含两个特征和一个标签。例如，我们可以生成100个样本来作为训练数据和测试数据：

x1     x2     y1     y2     y3
0.12   0.56   0.34   0.78   0.91
0.87   0.34   0.98   0.23   0.45
...

然后，我们可以使用随机梯度下降（SGD）算法来训练该神经网络。在每个迭代中，我们随机选择一个样本作为输入，通过前向传播计算出输出，再通过反向传播计算梯度，并更新权重和偏置。

具体实现的代码如下所示：

import numpy as np

# 定义激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 随机生成100个样本作为训练数据和测试数据
np.random.seed(1)
X = np.random.rand(100, 2)
y = np.random.rand(100, 3)

# 定义神经网络结构
n_input = 2
n_hidden1 = 4
n_hidden2 = 2
n_output = 3

# 初始化权重和偏置
W1 = np.random.randn(n_input, n_hidden1)
b1 = np.zeros((1, n_hidden1))
W3 = np.random.randn(n_hidden1, n_hidden2)
b3 = np.zeros((1, n_hidden2))
W4 = np.random.randn(n_hidden2, n_output)
b4 = np.zeros((1, n_output))

# 定义学习率和迭代次数
learning_rate = 0.1
n_epochs = 1000

# 使用随机梯度下降算法训练神经网络
for i in range(n_epochs):
    # 随机选择一个样本
    idx = np.random.randint(X.shape[0])
    x = X[idx]
    target = y[idx]

    # 前向传播
    h1 = sigmoid(np.dot(x, W1) + b1)
    h2 = sigmoid(np.dot(h1, W3) + b3)
    y_pred = sigmoid(np.dot(h2, W4) + b4)

    # 计算误差和梯度
    error = y_pred - target
    dW4 = h2.T.dot(error * y_pred * (1 - y_pred))
    db4 = np.sum(error * y_pred * (1 - y_pred), axis=0, keepdims=True)
    dW3 = h1.reshape(-1, 1).dot((error * y_pred * (1 - y_pred)).dot(W4.T) * h2 * (1 - h2))
    db3 = np.sum((error * y_pred * (1 - y_pred)).dot(W4.T) * h2 * (1 - h2), axis=0, keepdims=True)
    dW1 = x.reshape(-1, 1).dot(((error * y_pred * (1 - y_pred)).dot(W4.T) * h2 * (1 - h2)).dot(W3.T) * h1 * (1 - h1))
    db1 = np.sum(((error * y_pred * (1 - y_pred)).dot(W4.T) * h2 * (1 - h2)).dot(W3.T) * h1 * (1 - h1), axis=0, keepdims=True)

    # 更新权重和偏置
    W4 -= learning_rate * dW4
    b4 -= learning_rate * db4
    W3 -= learning_rate * dW3
    b3 -= learning_rate * db3
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1

    # 计算训练误差和测试误差
    if i % 100 == 0:
        train_error = np.mean((y - sigmoid(np.dot(X, W1).dot(W3).dot(W4) + b1.dot(b3).dot(b4))) ** 2)
        test_error = np.mean((y - sigmoid(np.dot(X, W1).dot(W3).dot(W4) + b1.dot(b3).dot(b4))) ** 2)
        print(f"Epoch {i}: train error = {train_error:.4f}, test error = {test_error:.4f}")

经过训练，我们可以得到训练误差和测试误差如下所示：

Epoch 0: train error = 0.2932, test error = 0.2929
Epoch 100: train error = 0.0139, test error = 0.0149
Epoch 200: train error = 0.0082, test error = 0.0089
Epoch 300: train error = 0.0061, test error = 0.0063
Epoch 400: train error = 0.0050, test error = 0.0053
Epoch 500: train error = 0.0043, test error = 0.0045
Epoch 600: train error = 0.0038, test error = 0.0038
Epoch 700: train error = 0.0033, test error = 0.0034
Epoch 800: train error = 0.0029, test error = 0.0030
Epoch 900: train error = 0.0026, test error = 0.0027