深度学习神经网络代码模板

model文件

import torch
from torch import nn

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        # 在这里定义你的模型结构
        self.flatten = nn.Flatten()
        self.linear = nn.Linear(784, 10)
    
    def forward(self, x):
        x = self.flatten(x)
        x = self.linear(x)
        return x

train文件

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from model import MyModel

# 定义超参数
batch_size = 256
learning_rate = 0.1
num_epochs = 10

# 加载数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transforms.ToTensor())

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

# 创建模型实例
model = MyModel()

# 定义损失函数和优化器
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 训练过程
for epoch in range(num_epochs):
    model.train()
    for images, labels in train_loader:
        # 前向传播
        outputs = model(images)
        loss = loss_fn(outputs, labels)
        
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    # 在测试集上评估模型性能
    model.eval()
    with torch.no_grad():
        total_correct = 0
        total_samples = 0
        for images, labels in test_loader:
            outputs = model(images)
            _, predicted = torch.max(outputs, dim=1)
            total_samples += labels.size(0)
            total_correct += (predicted == labels).sum().item()
        
        accuracy = total_correct / total_samples
    
    # 打印每个 epoch 的损失和准确率
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}, Accuracy: {accuracy:.4f}')

在这个模板中，model.py 文件用于定义神经网络模型的结构，包括 init 和 forward 函数。train.py 文件用于加载数据集，创建模型实例，定义损失函数和优化器，并执行训练过程。在训练过程中，通过循环遍历每个 epoch 和每个批次，执行前向传播、计算损失、反向传播和参数更新。然后在测试集上评估模型的性能，并打印每个 epoch 的损失和准确率。

你可以根据自己的需求修改模型结构、超参数和数据集的加载方式等。

dataset.py

import torch
from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self, data, targets, transform=None):
        self.data = data
        self.targets = targets
        self.transform = transform
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, index):
        x = self.data[index]
        y = self.targets[index]
        
        if self.transform:
            x = self.transform(x)
        
        return x, y

在这个模板中，MyDataset 类继承自 torch.utils.data.Dataset。你可以根据自己的数据格式和需求进行修改。

这个示例中，init 方法接受数据和目标作为输入，并可以选择性地传入数据的转换函数 transform。len 方法返回数据集的长度，getitem 方法根据索引返回单个样本。

你需要根据自己的数据集格式和数据预处理的需求，修改 init 方法、len 方法和 getitem 方法的实现。

使用时，你可以在 train.py 或其他代码文件中导入 MyDataset 类，并创建数据集实例，然后传递给 DataLoader 以进行数据加载和批处理。

from dataset import MyDataset
from torch.utils.data import DataLoader

# 加载数据
train_dataset = MyDataset(train_data, train_targets, transform=train_transform)
test_dataset = MyDataset(test_data, test_targets, transform=test_transform)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

上述代码中的 train_data、train_targets、test_data 和 test_targets 是示例数据，你需要根据自己的实际情况替换它们。另外，如果你需要进行数据预处理，可以在 MyDataset 类的 init 方法中添加预处理的代码或者将预处理逻辑放在外部的 transform 函数中。