【从零学Python】什么时候调用forward()函数、图片预处理、return中的if...else...

1.什么时候调用forward()函数
因为Module类是nn模块里提供的一个模型构造类,是所有神经网络模块的基类,我们可以继承它来定义我们想要的模型。

import torch
from torch import nn
 
class MLP(nn.Module):
    # 声明带有模型参数的层,这里声明了两个全连接层
    def __init__(self, **kwargs):
        # 调用MLP父类Module的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数
        super(MLP, self).__init__(**kwargs)
        self.hidden = nn.Linear(784, 256) # 隐藏层
        self.act = nn.ReLU()
        self.output = nn.Linear(256, 10)  # 输出层
 
    # 定义模型的前向计算,即如何根据输入x计算返回所需要的模型输出
    def forward(self, x):
        a = self.act(self.hidden(x))
        return self.output(a)
 
X = torch.rand(2, 784)
net = MLP()
print(net)
net(X)
    为什么会调用forward()呢,是因为Module中定义了__call__()函数,该函数调用了forward()函数,当执行net(x)的时候,会自动调用__call__()函数。也就是说只要进入了Module就会自动执行forward()函数。

2.图片预处理

import transforms as T
trans = [T.RandomResize(min_size, max_size)]# 将图片随机缩放
        if hflip_prob > 0:  #hflip_prob 随机水平翻转的概率
            trans.append(T.RandomHorizontalFlip(hflip_prob))# 随机翻转,添加新的对象到列表末尾
        trans.extend([#在已存在的列表中添加新的列表内容
            T.RandomCrop(crop_size),# 随机裁剪
            T.ToTensor(),
            T.Normalize(mean=mean, std=std),#标准化处理:减均值,除以标准差
        ])

        self.transforms = T.Compose(trans)#将多种变换组合在一起,即将多种预处理方法打包到transforms中
  1. 在return中的if…else…语句
def get_transform(train):#train为true的话
    base_size = 520
    crop_size = 480
    # 如果train为True的话,返回SegmentationPresetTrain(base_size, crop_size),否则返回SegmentationPresetEval(base_size)
    return SegmentationPresetTrain(base_size, crop_size) if train else SegmentationPresetEval(base_size)#后者是验证集的图片大小

4.torchvision.transforms.functional 中与图像预处理相关的函数

from torchvision.transforms import functional as F
image = F.resize(image, size)  # 将图像的最小边长缩放到size大小
img = F.pad(img, (0, 0, padw, padh), fill=fill)#(0, 0, padw, padh)分别表示左、上、右、下的填充宽度;
  • 3
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,以下是使用PyTorch框架实现MNIST数据集分类的示例代码: ```python import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision import datasets, transforms # 定义超参数 BATCH_SIZE = 64 EPOCHS = 10 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 加载数据集并进行预处理 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_set = datasets.MNIST('./data', train=True, download=True, transform=transform) test_set = datasets.MNIST('./data', train=False, download=True, transform=transform) train_loader = torch.utils.data.DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True) test_loader = torch.utils.data.DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=False) # 定义模型结构 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 10, kernel_size=5) self.conv2 = nn.Conv2d(10, 20, kernel_size=5) self.fc1 = nn.Linear(320, 50) self.fc2 = nn.Linear(50, 10) def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2(x), 2)) x = x.view(-1, 320) x = F.relu(self.fc1(x)) x = self.fc2(x) return F.log_softmax(x, dim=1) # 实例化模型并将其移动到GPU上(如果有的话) model = Net().to(DEVICE) # 定义优化器和损失函数 optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) criterion = nn.CrossEntropyLoss() # 训练过程 def train(model, device, train_loader, optimizer, epoch): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() if batch_idx % 100 == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item())) # 测试过程 def test(model, device, test_loader): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) output = model(data) test_loss += criterion(output, target).item() # 将一批的损失相加 pred = output.argmax(dim=1, keepdim=True) # 找到概率最大的下标 correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) print('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset))) # 开始训练和测试 for epoch in range(1, EPOCHS + 1): train(model, DEVICE, train_loader, optimizer, epoch) test(model, DEVICE, test_loader) ``` 这个示例代码使用了两个卷积层和两个全连接层,可以在MNIST数据集上达到约99%的准确率。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值