写一个pytorch 版本全连接神经网络

### 回答1：

import torch
import torch.nn as nn class NeuralNet(nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNet, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, num_classes)

def forward(self, x):
out = self.fc1(x)
out = self.relu(out)
out = self.fc2(out)
return out

# 定义模型参数
input_size = 784
hidden_size = 500
num_classes = 10

# 实例化全连接神经网络
model = NeuralNet(input_size, hidden_size, num_classes)

### 回答2：
以下是一个简单的PyTorch版本的全连接神经网络：

import torch
import torch.nn as nn

class FullyConnectedNet(nn.Module):
    def __init__(self, input_size, hidden_sizes, output_size):
        super(FullyConnectedNet, self).__init__()
        
        # 定义输入层到隐藏层之间的线性变换
        self.input_to_hidden = nn.Linear(input_size, hidden_sizes[0])
        
        # 定义隐藏层到隐藏层之间的线性变换
        self.hidden_layers = nn.ModuleList()
        for i in range(1, len(hidden_sizes)):
            self.hidden_layers.append(nn.Linear(hidden_sizes[i-1], hidden_sizes[i]))
        
        # 定义隐藏层到输出层之间的线性变换
        self.hidden_to_output = nn.Linear(hidden_sizes[-1], output_size)
        
    def forward(self, x):
        x = torch.relu(self.input_to_hidden(x))  # 使用ReLU作为激活函数
        
        for hidden_layer in self.hidden_layers:
            x = torch.relu(hidden_layer(x))
        
        x = self.hidden_to_output(x)
        return x

以上代码定义了一个名为 `FullyConnectedNet` 的全连接神经网络类，构造函数接受输入层、隐藏层和输出层的大小作为参数。网络的前向传播方法 `forward` 应用线性变换和ReLU激活函数来计算输出。

该神经网络包含一个输入层到第一个隐藏层之间的线性变换（`input_to_hidden`），以及可变数量的隐藏层到隐藏层之间的线性变换（`hidden_layers`），最后是最后一个隐藏层到输出层之间的线性变换（`hidden_to_output`）。

在 `forward` 方法中，输入 `x` 经过输入到隐藏层的线性变换和ReLU激活函数，然后遍历所有隐藏层的线性变换和ReLU激活函数。最后，输出是通过最后一个隐藏层到输出层的线性变换计算得到的。

这只是一个简单的全连接神经网络示例，可以根据实际问题进行修改和扩展。

### 回答3：
好的，下面是一个使用PyTorch编写的全连接神经网络的示例代码：

import torch
import torch.nn as nn

# 定义全连接神经网络类
class Net(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Net, 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 = 20
output_size = 5

# 创建模型实例
model = Net(input_size, hidden_size, output_size)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 随机梯度下降优化器

# 准备输入数据
input_data = torch.randn(100, input_size) # 100个样本
target = torch.empty(100, dtype=torch.long).random_(output_size) # 随机生成目标值

# 训练模型
for epoch in range(100):
    optimizer.zero_grad()
    output = model(input_data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()
    if (epoch+1) % 10 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, 100, loss.item()))

# 使用训练好的模型进行预测
test_data = torch.randn(1, input_size) # 一个测试样本
with torch.no_grad():
    pred = model(test_data)
    _, predicted = torch.max(pred.data, 1)
    print('Predicted class:', predicted.item())

这个代码定义了一个具有1个隐藏层的全连接神经网络，其中输入层有10个节点，隐藏层有20个节点，输出层有5个节点。模型使用ReLU激活函数，并使用交叉熵损失函数进行训练。在训练过程中，使用随机梯度下降优化器对模型参数进行更新。最后，使用训练好的模型对一个测试样本进行预测，并输出预测结果的类别。