构建一个全连接网络，网络中只允许存在Linear层(层数不得超过5)，可以调节的超参数为learning_rate和epoch(eopch不得超过50)。使用FashionMNIST数据集训练并测试网络的精度，将最优(在测试集上的精度)的模型保存为model.pth文件，

构建一个全连接神经网络（也称为多层感知机，MLP）仅包含线性层的情况，我们可以按照以下步骤进行：

1. 导入必要的库：

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision.datasets import FashionMNIST
from torchvision.transforms import ToTensor

2. 定义网络结构：

class LinearNet(nn.Module):
    def __init__(self, input_dim, num_classes=10, max_layers=5):
        super(LinearNet, self).__init__()
        layers = [nn.Linear(input_dim, hidden_size) for _ in range(max_layers - 1)]
        layers.append(nn.Linear(hidden_size, num_classes)) # 最后一层是输出层
        self.layers = nn.Sequential(*layers)

    def forward(self, x):
        return self.layers(x)

这里假设隐层大小`hidden_size`未指定，可以根据需要设置。

3. 设置超参数：

input_dim = 784 # FashionMNIST每张图片的像素数
num_classes = 10
max_epochs = 50
learning_rate = 0.001

4. 加载和预处理数据：

train_dataset = FashionMNIST(root='./data', train=True, transform=ToTensor(), download=True)
test_dataset = FashionMNIST(root='./data', train=False, transform=ToTensor())

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

5. 训练网络：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = LinearNet(input_dim).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)

best_accuracy = 0
for epoch in range(max_epochs):
    net.train()
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = net(inputs.to(device))
        loss = criterion(outputs, labels.to(device))
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

    net.eval()
    with torch.no_grad():
        correct = 0
        total = 0
        for inputs, labels in test_loader:
            outputs = net(inputs.to(device))
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels.to(device)).sum().item()

    accuracy = 100 * correct / total
    print(f'Epoch {epoch+1}/{max_epochs}, Loss: {running_loss / len(train_loader):.4f}, Accuracy: {accuracy:.2f}%')

    if accuracy > best_accuracy:
        best_accuracy = accuracy
        torch.save(net.state_dict(), 'model.pth')

在这个过程中，网络会在每个epoch结束后在测试集上计算精度，并检查是否达到最佳性能。如果找到更好的模型，就将其权重保存到'model.pth'文件中。