请设计一个输入为2、输出为3,具有2个隐藏层(神经元个数分别为4,2)的前馈神经网络。 (1)画出该网络。 (2)写出模型公式。 (3)生成随机数据并训练该网络。
时间: 2023-09-25 19:06:29 浏览: 50
### 回答1:
好的,我来为您完成这个任务。
1. 该网络的结构如下图所示:
```
input layer hidden layer 1 hidden layer 2 output layer
x1 ----> o o ----> o ----> o o ----> o o
| | | | | | |
v v v v v v v
x2 ----> o o ----> o ----> o o ----> o o
```
2. 模型公式:
设输入为 $x=(x_1,x_2)$,输出为 $y\in R$,则该神经网络的模型公式为:
$$
\begin{aligned}
z_1 &= w_1^T x + b_1 \\
h_1 &= \sigma(z_1) \\
z_2 &= w_2^T h_1 + b_2 \\
h_2 &= \sigma(z_2) \\
z_3 &= w_3^T h_2 + b_3 \\
y &= \sigma(z_3)
\end{aligned}
$$
其中,$w_i$ 为第 $i$ 层的权重,$b_i$ 为第 $i$ 层的偏置,$\sigma$ 为激活函数,这里使用 sigmoid 函数。
3. 生成随机数据并训练该网络:
我们可以使用 Python 的 NumPy 库来生成随机数据并训练该网络。以下是完整代码:
```python
import numpy as np
# 定义 sigmoid 函数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 定义前馈神经网络类
class NeuralNetwork:
def __init__(self, input_size, hidden_size1, hidden_size2, output_size):
self.input_size = input_size
self.hidden_size1 = hidden_size1
self.hidden_size2 = hidden_size2
self.output_size = output_size
# 初始化权重和偏置
self.w1 = np.random.randn(input_size, hidden_size1)
self.b1 = np.random.randn(hidden_size1)
self.w2 = np.random.randn(hidden_size1, hidden_size2)
self.b2 = np.random.randn(hidden_size2)
self.w3 = np.random.randn(hidden_size2, output_size)
self.b3 = np.random.randn(output_size)
def forward(self, x):
# 前向传播
z1 = np.dot(x, self.w1) + self.b1
h1 = sigmoid(z1)
z2 = np.dot(h1, self.w2) + self.b2
h2 = sigmoid(z2)
z3 = np.dot(h2, self.w3) + self.b3
y = sigmoid(z3)
return y
def loss(self, x, y_true):
# 计算损失函数(交叉熵)
y_pred = self.forward(x)
loss = -np.mean(y_true * np.log(y_pred) + (1-y_true) * np.log(1-y_pred))
return loss
def backward(self, x, y_true, learning_rate):
# 反向传播
y_pred = self.forward(x)
delta3 = (y_pred - y_true) * y_pred * (1-y_pred)
delta2 = np.dot(delta3, self.w3.T) * sigmoid(z2) * (1-sigmoid(z2))
delta1 = np.dot(delta2, self.w2.T) * sigmoid(z1) * (1-sigmoid(z1))
self.w3 -= learning_rate * np.dot(h2.T, delta3)
self.b3 -= learning_rate * np.mean(delta3, axis=0)
self.w2 -= learning_rate * np.dot(h1.T, delta2)
self.b2 -= learning_rate * np.mean(delta2, axis=0)
self.w1 -= learning_rate * np.dot(x.T, delta1)
self.b1 -= learning_rate * np.mean(delta1, axis=0)
def train(self, x, y_true, num_epochs, learning_rate):
# 训练模型
for epoch in range(num_epochs):
loss = self.loss(x, y_true)
self.backward(x, y_true, learning_rate)
if epoch % 100 == 0:
print(f"Epoch {epoch}, Loss: {loss:.4f}")
# 生成随机数据
x = np.random.randn(100, 2)
y_true = (np.sum(x, axis=1) > 0).astype(int)
# 创建神经网络对象并训练
model = NeuralNetwork(2, 4, 2, 1)
model.train(x, y_true, 1000, 0.1)
# 测试模型
y_pred = model.forward(x)
y_pred = (y_pred > 0.5).astype(int)
accuracy = np.mean(y_pred == y_true)
print(f"Accuracy: {accuracy:.2f}")
```
这里生成了 100 个样本,每个样本有两个特征。我们按照特征的和是否大于 0 来生成样本的标签。然后使用前馈神经网络来训练并预测这些样本的标签。在训练过程中,我们使用了随机梯度下降法来更新权重和偏置。最终的准确率约为 0.98。
### 回答2:
(1)画出该网络:
输入层(2个神经元)——隐藏层1(4个神经元)——隐藏层2(2个神经元)——输出层(3个神经元)
(2)模型公式:
输入层到隐藏层1的权重:W1(大小为4×2)
隐藏层1的偏置:B1(大小为4×1)
隐藏层1的激活函数:f1
隐藏层1的输出:H1 = f1(W1 × 输入层 + B1)
隐藏层1到隐藏层2的权重:W2(大小为2×4)
隐藏层2的偏置:B2(大小为2×1)
隐藏层2的激活函数:f2
隐藏层2的输出:H2 = f2(W2 × H1 + B2)
隐藏层2到输出层的权重:W3(大小为3×2)
输出层的偏置:B3(大小为3×1)
输出层的激活函数:f3
输出层的输出:输出 = f3(W3 × H2 + B3)
(3)生成随机数据并训练该网络。
根据模型公式,我们可以生成输入数据和对应的输出数据,然后使用反向传播算法来训练该神经网络。
具体步骤如下:
1. 初始化权重W1、W2、W3和偏置B1、B2、B3为随机数。
2. 生成一批输入数据X和对应的输出数据Y。
3. 使用前向传播算法计算每一层的输出,并根据输出计算损失函数。
4. 使用反向传播算法计算每一层的梯度。
5. 更新权重和偏置,使用优化算法(如梯度下降)调整参数。
6. 重复步骤2-5,直到损失函数收敛或达到指定的训练轮数。
通过多次迭代训练,神经网络可以逐渐学习到输入和输出之间的关系,并在测试时能够对新的输入数据进行准确的预测输出。