使用PyTorch/TensorFlow搭建简单全连接神经网络_神经网络

网络结构概述

我们的全连接神经网络（fully connected neural network，fcnn）由以下部分构成：

输入层：接收数据特征向量（例如，长度为 10 的向量）。
隐藏层：通过一个全连接层将输入进行非线性映射，通常会使用激活函数（如 relu）来增加模型的表达能力。
输出层：根据具体任务输出预测结果，例如回归任务输出单个连续值。

这种结构虽然简单，但能帮助我们理解前向传播、反向传播及梯度下降等基本概念。

1. 使用 pytorch 构建网络

pytorch 提供了灵活的动态计算图和简洁的 api，非常适合快速原型开发。下面是一个完整示例：

import torch
import torch.nn as nn
import torch.optim as optim
 
# 定义一个简单的全连接神经网络
class simplefcnn(nn.module):
    def __init__(self, input_size, hidden_size, output_size):
        super(simplefcnn, self).__init__()
        self.fc1 = nn.linear(input_size, hidden_size)  # 输入层到隐藏层
        self.relu = nn.relu()                           # 激活函数
        self.fc2 = nn.linear(hidden_size, output_size)  # 隐藏层到输出层
 
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out
 
# 超参数设置
input_size = 10      # 输入特征数量
hidden_size = 5      # 隐藏层节点数
output_size = 1      # 输出节点数
learning_rate = 0.001
num_epochs = 100
 
# 实例化模型、定义损失函数和优化器
model = simplefcnn(input_size, hidden_size, output_size)
criterion = nn.mseloss()  # 均方误差损失，用于回归问题
optimizer = optim.adam(model.parameters(), lr=learning_rate)
 
# 构造一些模拟数据
x_train = torch.randn(100, input_size)
y_train = torch.randn(100, output_size)
 
# 训练模型
for epoch in range(num_epochs):
    outputs = model(x_train)
    loss = criterion(outputs, y_train)
 
    optimizer.zero_grad()  # 梯度清零
    loss.backward()        # 反向传播
    optimizer.step()       # 更新参数
 
    if (epoch + 1) % 10 == 0:
        print(f'epoch [{epoch + 1}/{num_epochs}], loss: {loss.item():.4f}')

解析：

模型定义：我们创建了一个继承自 nn.module 的类 simplefcnn，其中 nn.linear 用于构建全连接层，nn.relu 作为激活函数。
训练循环：每个 epoch 中，我们计算模型输出与真实标签之间的均方误差（mse），然后利用 optimizer 对参数进行梯度下降更新。

2. 使用 tensorflow 构建网络

tensorflow 通过 keras 接口提供了直观且高层次的 api 来搭建模型，适合快速搭建原型。下面是使用 tensorflow 的示例代码：

import tensorflow as tf
from tensorflow.keras.models import sequential
from tensorflow.keras.layers import dense
 
# 超参数设置
input_size = 10      # 输入特征数量
hidden_size = 5      # 隐藏层节点数
output_size = 1      # 输出节点数
learning_rate = 0.001
num_epochs = 100
batch_size = 10
 
# 构建顺序模型
model = sequential([
    dense(hidden_size, activation='relu', input_shape=(input_size,)),  # 输入层到隐藏层
    dense(output_size)                                                 # 输出层
])
 
# 编译模型：指定优化器和损失函数（这里依然使用均方误差）
model.compile(optimizer=tf.keras.optimizers.adam(learning_rate=learning_rate),
              loss='mse')
 
# 构造一些模拟数据
import numpy as np
x_train = np.random.randn(100, input_size)
y_train = np.random.randn(100, output_size)
 
# 训练模型
history = model.fit(x_train, y_train, epochs=num_epochs, batch_size=batch_size, verbose=2)

解析：