Resnet18_by_paddlepaddle带你入门神经网络搭建

import warnings
warnings.filterwarnings('ignore')

import paddleimport paddle.nn as nnimport paddle.nn.functional as Fimport paddle.optimizer as optimimport paddle.vision.transforms as Timport paddle.vision.datasets as Dfrom paddle.io import DataLoader

# ResNet-18 模型定义# 这里使用python的class来进行基模块的定义，这个基模块会在后面搭建模型时使用class BasicBlock(nn.Layer):
    expansion = 1

    def __init__(self, in_channels, out_channels, stride=1, downsample=None):
        # in_channels为输入大小, out_channels输出大小, stride为卷积步长, downsample为下采样
        super(BasicBlock, self).__init__()# 继承一下自己
        self.conv1 = nn.Conv2D(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias_attr=False)        # Conv2D是paddle框架中封装好的对二位数据进行卷积的方法，和torch的封装结构一致，都封装在nn类中
        # 这是第一个卷积层，卷积核大小为3*3,步长为1，padding为1，不使用bias（偏置）
        self.bn1 = nn.BatchNorm2D(out_channels)        # 这是第一个BatchNorm层，对刚刚卷积后的数据进行批量归一化，out_channels为输出大小
        self.relu = nn.ReLU()        # 这是Relu激活函数，归一化后进入Relu激活函数，进行线性向非线性的变换
        self.conv2 = nn.Conv2D(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias_attr=False)
        self.bn2 = nn.BatchNorm2D(out_channels)
        self.downsample = downsample
        self.stride = stride    def forward(self, x):# 在这里定义前向传播
        identity = x
        
        out = self.conv1(x)# 先定义一个值做个卷积
        out = self.bn1(out)# 然后做个归一化
        out = self.relu(out)# 再经过一次激活函数

        out = self.conv2(out)# 接着卷积
        out = self.bn2(out)# 继续归一化

        if self.downsample is not None:# 在这里和进行对齐，避免无法进行残差链接
            identity = self.downsample(x)

        out += identity# 残差链接，这里直接将上次的计算结果作为残差链接上来
        out = self.relu(out)        return out

class ResNet(nn.Layer):
    def __init__(self, block, layer_configs, num_classes=1000):# block是一个可更换的基模块，这里我们用的是上面声明的BasicBlock
        # layer_configs是一个列表，指定每个残差块组的块数量配置
        super(ResNet, self).__init__()
        self.in_channels = 64
        self.conv1 = nn.Conv2D(3, 64, kernel_size=7, stride=2, padding=3, bias_attr=False)
        self.bn1 = nn.BatchNorm2D(64)
        self.relu = nn.ReLU()
        self.maxpool = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)        
        # 构建残差块组
        self.layer1 = self._make_layer(block, 64, layer_configs[0])  # 第一个残差块组
        self.layer2 = self._make_layer(block, 128, layer_configs[1], stride=2)  # 第二个残差块组，步长为2
        self.layer3 = self._make_layer(block, 256, layer_configs[2], stride=2)  # 第三个残差块组，步长为2
        self.layer4 = self._make_layer(block, 512, layer_configs[3], stride=2)  # 第四个残差块组，步长为2
        
        self.avgpool = nn.AdaptiveAvgPool2D((1, 1))
        self.fc = nn.Linear(512 * block.expansion, num_classes) 
    def _make_layer(self, block, out_channels, num_blocks, stride=1):
        # 构建一个残差块组，包含多个残差块
        # num_blocks: 残差块的数量
        downsample = None
        # 判断是否需要下采样
        if stride != 1 or self.in_channels != out_channels * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2D(self.in_channels, out_channels * block.expansion, kernel_size=1, stride=stride, bias_attr=False),
                nn.BatchNorm2D(out_channels * block.expansion),
            )
 
        layers = []
        layers.append(block(self.in_channels, out_channels, stride, downsample))
        self.in_channels = out_channels * block.expansion        # 添加剩余的残差块，这些块不需要进行下采样
        for _ in range(1, num_blocks):
            layers.append(block(self.in_channels, out_channels)) 
        return nn.Sequential(*layers)    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = paddle.flatten(x, 1)
        x = self.fc(x)        return x

def ResNet18(num_classes = 10):
    return ResNet(BasicBlock, [2, 2, 2, 2],num_classes=num_classes)# 在这里声明ResNet18，列表是每层的块数量，num_classes是分类的类别数# 可以试试更改模块数量，这样也可以说是改了模型

# 如果想用本地数据集进行训练，就注释掉这段代码，使用下一个方框内的代码# 由于Cifar10数据集是使用API接口下载的，犹如数据集官方可能更新API，该段代码可能报错# 如果该段代码报错，请注释掉该段代码，阅读下个方框使用本地数据集进行测试# 数据预处理和加载transform = T.Compose([
    T.Resize((224, 224)),# 这个Resize其实是不合理的，因为Cifar10的图像是3*32*32，这里Resize为224*224，这样会导致信息有损
    # 但是ResNet本来就是设计为224x224大小的，修改这里的Resize大小需要同时修改ResNet的结构，本文为使Paddle的原生Resnet18,故不做更改
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

train_dataset = D.Cifar10(mode='train', transform=transform)
val_dataset = D.Cifar10(mode='test', transform=transform)

train_loader = DataLoader(train_dataset, batch_size=500, shuffle=True, drop_last=True)
val_loader = DataLoader(val_dataset, batch_size=500, shuffle=False)# 模型、损失函数和优化器device = paddle.set_device('gpu' if paddle.is_compiled_with_cuda() else 'cpu')
model = ResNet18(num_classes=10)
model = model.to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(parameters=model.parameters(), learning_rate=0.001)'''
print('该代码框已屏蔽')# 这行代码用于标记这个框的代码是否有运行
'''

'''
# 如果要训练自己的数据集，就注释掉上面训练Cifar10的代码；
# 注意，这段代码要求数据集的结构是 一个文件夹下有多个子文件夹，每个子文件夹的名称是标签，文件夹中的图片的训练图像
# 这个文件的格式也是ImageNet的格式
# 同时，这里还直接按读取到的子文件夹数量重新定义了ResNet18模型，可以不更改或不允许上面定义模型的代码

# 在运行该段代码前，请解压data文件夹中的压缩包并修改路径到你的路径
import os
from PIL import Image
import paddle
import paddle.nn as nn
import paddle.optimizer as optim
import paddle.vision.transforms as T
from paddle.io import DataLoader, Dataset
from paddle.vision.models import resnet18

# 自定义数据集类
class CustomDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.classes = sorted(os.listdir(root_dir))
        self.class_to_idx = {cls_name: i for i, cls_name in enumerate(self.classes)}
        self.images = []
        self.labels = []

        for cls_name in self.classes:
            cls_dir = os.path.join(root_dir, cls_name)
            for img_name in os.listdir(cls_dir):
                img_path = os.path.join(cls_dir, img_name)
                self.images.append(img_path)
                self.labels.append(self.class_to_idx[cls_name])

    def __len__(self):
        return len(self.images)

    def __getitem__(self, idx):
        img_path = self.images[idx]
        label = self.labels[idx]
        image = Image.open(img_path).convert('RGB')

        if self.transform:
            image = self.transform(image)

        return image, label


# 数据预处理和加载
transform = T.Compose([
    T.Resize((224, 224)),
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# 这里是训练集和验证集的路径，按你的路径进行修改，这里的 “./”为从当前文件所处文件夹路径开始向下寻找，具体参考python的路径操作
train_dataset = CustomDataset(root_dir='./data/data303405/Training', transform=transform)
val_dataset = CustomDataset(root_dir='./data/data303405/Testing', transform=transform)

train_loader = DataLoader(train_dataset, batch_size=100, shuffle=True, drop_last=True)
val_loader = DataLoader(val_dataset, batch_size=100, shuffle=False)

# 模型、损失函数和优化器
device = paddle.set_device('gpu' if paddle.is_compiled_with_cuda() else 'cpu')
num_classes = len(train_dataset.classes)  # 根据数据集的类别数调整模型输出类别数
model = ResNet18(num_classes=num_classes)
model = model.to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(parameters=model.parameters(), learning_rate=0.001)
#使用Adam优化器，初始学习率设置为0.001，也有很多其他优化器可以使用的，详细参考我都另一个项目或自行上网搜索

# 训练和验证代码可以继续使用之前的代码
'''print("该代码框已屏蔽")# 这行代码用于标记这个框的代码是否有运行

# 训练循环num_epochs = 20 # 初始设置为20轮，可根据需求设置for epoch in range(num_epochs):
    model.train()    for batch_id, (data, label) in enumerate(train_loader):
        data, label = data.to(device), label.to(device)
        optimizer.clear_grad()
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()        if batch_id % 100 == 0:            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{batch_id}/{len(train_loader)}], Loss: {loss.item():.4f}')    # 验证
    model.eval()
    correct = 0
    total = 0
    with paddle.no_grad():        for data, label in val_loader:
            data, label = data.to(device), label.to(device)
            output = model(data)
            _, predicted = paddle.topk(output, k=1)
            total += label.shape[0]
            correct += (predicted.squeeze() == label).astype('int32').sum().item()

    accuracy = correct / total    print(f'Validation Accuracy: {accuracy:.4f}')# 保存模型

paddle.save(model.state_dict(), 'resnet18_cifar10.pdparams')# 保存一下权重