pytorch实现特殊的Module-Sqeuential三种写法

PyTorch中的nn.Sequential是一个特殊的模块，它允许我们按顺序组合多个模块。在本文中，我们将介绍三种不同的方法来使用nn.Sequential，并提供两个示例。

方法1：使用列表

第一种方法是使用列表来定义nn.Sequential。在这种方法中，我们将每个模块作为列表的一个元素，并将它们按顺序排列。以下是一个示例：

import torch.nn as nn

model = nn.Sequential([
    nn.Linear(784, 500),
    nn.ReLU(),
    nn.Linear(500, 10)
])

在这个示例中，我们定义了一个名为model的nn.Sequential模块，其中包含一个线性层、一个ReLU激活函数和另一个线性层。这些模块按照它们在列表中的顺序排列。

方法2：使用有序字典

第二种方法是使用有序字典来定义nn.Sequential。在这种方法中，我们将每个模块作为有序字典的一个键值对，并将它们按顺序排列。以下是一个示例：

import torch.nn as nn
from collections import OrderedDict

model = nn.Sequential(OrderedDict([
    ('fc1', nn.Linear(784, 500)),
    ('relu1', nn.ReLU()),
    ('fc2', nn.Linear(500, 10))
]))

在这个示例中，我们定义了一个名为model的nn.Sequential模块，其中包含一个名为fc1的线性层、一个名为relu1的ReLU激活函数和另一个名为fc2的线性层。这些模块按照它们在有序字典中的顺序排列。

方法3：使用函数

第三种方法是使用函数来定义nn.Sequential。在这种方法中，我们定义一个函数，该函数接受一个模块列表作为参数，并返回一个nn.Sequential模块。以下是一个示例：

import torch.nn as nn

def make_model():
    layers = [
        nn.Linear(784, 500),
        nn.ReLU(),
        nn.Linear(500, 10)
    ]
    return nn.Sequential(*layers)

model = make_model()

在这个示例中，我们定义了一个名为make_model的函数，该函数返回一个nn.Sequential模块。我们将模块列表作为参数传递给函数，并使用*运算符将它们解包为单独的参数。然后，我们将返回的nn.Sequential模块赋值给名为model的变量。

示例1：使用nn.Sequential进行手写数字识别

以下是一个使用nn.Sequential进行手写数字识别的示例：

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms

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

# 加载数据集
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=100, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)

# 定义模型
model = nn.Sequential(
    nn.Linear(784, 500),
    nn.ReLU(),
    nn.Linear(500, 10)
)

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

# 训练模型
total_step = len(train_loader)
for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        images = images.reshape(-1, 28*28)

        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, 10, i+1, total_step, loss.item()))

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.reshape(-1, 28*28)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total))

在这个示例中，我们首先加载了MNIST数据集。然后，我们定义了一个名为model的nn.Sequential模块，并定义了一个名为criterion的损失函数和一个名为optimizer的优化器。然后，我们使用训练数据对模型进行了训练，并在每个epoch结束时输出损失值。最后，我们使用测试数据对模型进行了测试，并输出了模型的准确率。

示例2：使用nn.Sequential进行猫狗分类

以下是一个使用nn.Sequential进行猫狗分类的示例：

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import torchvision.models as models

# 加载数据集
train_dataset = dsets.ImageFolder(root='./data/train', transform=transforms.Compose([
    transforms.Resize(224),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
]))
test_dataset = dsets.ImageFolder(root='./data/test', transform=transforms.Compose([
    transforms.Resize(224),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
]))
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=100, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)

# 加载预训练模型
model = models.resnet18(pretrained=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2)

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

# 训练模型
total_step = len(train_loader)
for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, 10, i+1, total_step, loss.item()))

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the model on the test images: {} %'.format(100 * correct / total))

在这个示例中，我们首先加载了猫狗分类数据集。然后，我们加载了一个预训练的ResNet18模型，并将其输出层替换为一个名为fc的线性层。然后，我们定义了一个名为criterion的损失函数和一个名为optimizer的优化器。然后，我们使用训练数据对模型进行了训练，并在每个epoch结束时输出损失值。最后，我们使用测试数据对模型进行了测试，并输出了模型的准确率。