【问题标题】:While running pytorch i got an error 'TypeError: object of type'CatsAndDogsDataset' has no len()' and I want to know how to fix it在运行 pytorch 时出现错误“TypeError: object of type'CatsAndDogsDataset' has no len()' 我想知道如何解决它
【发布时间】:2021-07-16 16:40:51
【问题描述】:

运行 pytorch 时出现错误 我使用 ResNet 训练人工智能,并为该数据集编写了自己的自定义数据集。从 ResnNet 加载数据集后,通过人工智能学习分别设置训练数据和测试数据。但是即使我运行它,也发生了错误,但我不知道发生了什么样的问题。 接下来附上我的ResNet.py代码和我自己的数据集CustomDataset.py代码。

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import transforms, datasets, models
    from customDataset import CatsAndDogsDataset
    
    USE_CUDA = torch.cuda.is_available()
    DEVICE = torch.device("cuda" if USE_CUDA else "cpu")
    
    EPOCHS = 3
    BATCH_SIZE = 10
    
    dataset = CatsAndDogsDataset(csv_file = 'cats_dogs.csv', root_dir = 'cats_dogs_resized',transform = transforms.ToTensor())
    
    train_set, test_set = torch.utils.data.random_split(dataset, [28,4])
    train_loader = DataLoader(dataset=train_set, batch_size=BATCH_SIZE, shuffle=True)
    test_loader = DataLoader(dataset=test_set, batch_size=BATCH_SIZE, shuffle=True)
    
    class BasicBlock(nn.Module):
    def __init__(self, in_planes, planes, stride=1):
    super(BasicBlock, self).__init__()
    self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3,stride=stride, padding=1, bias=False)
    self.bn1 = nn.BatchNorm2d(planes)
    self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,stride=1, padding=1, bias=False)
    self.bn2 = nn.BatchNorm2d(planes)
    
    self.shortcut = nn.Sequential()
    if stride != 1 or in_planes != planes:
    self.shortcut = nn.Sequential(nn.Conv2d(in_planes, planes,kernel_size=1, stride=stride, bias=False),
    nn.BatchNorm2d(planes))
    
    def forward(self, x):
    out = F.relu(self.bn1(self.conv1(x)))
    out = self.bn2(self.conv2(out))
    out += self.shortcut(x)
    out = F.relu(out)
    return out
    
    class ResNet(nn.Module):
    def __init__(self, num_classes=10):
    super(ResNet, self).__init__()
    self.in_planes = 16
    
    self.conv1 = nn.Conv2d(3, 16, kernel_size=3,stride=1, padding=1, bias=False)
    self.bn1 = nn.BatchNorm2d(16)
    self.layer1 = self._make_layer(16, 2, stride=1)
    self.layer2 = self._make_layer(32, 2, stride=2)
    self.layer3 = self._make_layer(64, 2, stride=2)
    self.linear = nn.Linear(64, num_classes)
    
    def _make_layer(self, planes, num_blocks, stride):
    strides = [stride] + [1] * (num_blocks - 1)
    layers = []
    for stride in strides:
    layers.append(BasicBlock(self.in_planes, planes, stride))
    self.in_planes = planes
    return nn.Sequential(*layers)
    
    def forward(self, x):
    out = F.relu(self.bn1(self.conv1(x)))
    out = self.layer1(out)
    out = self.layer2(out)
    out = self.layer3(out)
    out = F.avg_pool2d(out, 8)
    out = out.view(out.size(0), -1)
    out = self.linear(out)
    return out
    
    
    model = ResNet().to(DEVICE)
    optimizer = optim.SGD(model.parameters(), lr=0.1,momentum=0.9, weight_decay=0.0005)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1)
    
    print(model)
    
    
    def train(model, 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 = F.cross_entropy(output, target)
    loss.backward()
    optimizer.step()
    
    
    def evaluate(model, 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 += F.cross_entropy(output, target,reduction='sum').item()
    
    pred = output.max(1, keepdim=True)[1]
    correct += pred.eq(target.view_as(pred)).sum().item()
    
    test_loss /= length(test_loader.dataset)
    test_accuracy = 100. * correct / length(test_loader.dataset)
    return test_loss, test_accuracy
    
    
    
    for epoch in range(1, EPOCHS + 1):
    scheduler.step()
    train(model, train_loader, optimizer, epoch)
    test_loss, test_accuracy = evaluate(model, test_loader)
    
    print('[{}] Test Loss: {:.4f}, Accuracy: {:.2f}%'.format(
    epoch, test_loss, test_accuracy))


import os
import pandas as pd
import torch
from torch.utils.data import Dataset
from skimage import io

    class CatsAndDogsDataset(Dataset):
    def __init__(self, csv_file, root_dir, transform=None):
    self.annotations = pd.read_csv(csv_file)
    self.root_dir = root_dir
    self.transform = transform
    
    def __length__(self):
    return length(self.annotations)
    
    def __getitem__(self, index):
    img_path = os.path.join(self.root_dir, self.annotations.iloc[index, 0])
    image = io.imread(img_path)
    y_label = torch.tensor(int(self.annotations.iloc[index, 1]))
    
    if self.transform:
    image = self.transform(image)
    
    return (image, ylabel)

这样,如果我写代码然后运行它 TypeError:“CatsAndDogsDataset”类型的对象没有 len() 我想知道为什么我不能拥有 len()。另外,运行Backend.ai而不是pycharm的结果出现了错误,但是错误内容是

无法验证数据集的大小

如果总和(长度)!= 长度(数据集): 它是raise ValueError(“输入长度的总和不等于输入数据集的长度!”)。 出现错误。有解决方法吗?请帮帮我

【问题讨论】:

    标签: pytorch resnet


    【解决方案1】:

    您需要为您的自定义数据集定义函数__len__(您目前似乎错误地定义为__length__)。

    This documentation 提供详细信息。相关摘录:

    torch.utils.data.Dataset 是表示数据集的抽象类。 您的自定义数据集应继承 Dataset 并覆盖以下内容 方法:

    • __len__ 以便 len(dataset) 返回数据集的大小。
    • __getitem__ 支持索引,以便dataset[i] 可用于获取第 i 个样本。

    【讨论】:

    • 但是我把length_改成了len,还是重复了同样的错误。
    猜你喜欢
    • 2021-10-05
    • 1970-01-01
    • 2022-09-23
    • 2020-08-25
    • 2014-02-26
    • 1970-01-01
    • 2020-04-23
    • 1970-01-01
    • 2021-08-22
    相关资源
    最近更新 更多