DeepLearningのコード（WideResNet）を実装しようと思い、自作のデータセットによる学習を試みているのですが、損失の計算時にエラーが出ます。  
実装をメインとしており、自作データで学習をすることが目標で、アルゴリズムそのものの理解ができておらず、至らぬ点がありますが、ご教示ください。よろしくお願いいたします。  
コメントアウトなどを削除したため、エラー文のlineと実際のエラー箇所が異なっています。

'''エラー文'''

```

    Traceback (most recent call last):
      File "train_mydata.py", line 350, in <module>
        main()
      File "train_mydata.py", line 196, in main
        train(train_loader, model, criterion, optimizer, scheduler, epoch)
      File "train_mydata.py", line 227, in train
        loss = criterion(output, target)
      File "/home/name/.local/lib/python3.8/site-packages/torch/nn/modules/module.py", line 1110, in _call_impl
        return forward_call(*input, **kwargs)
      File "/home/name/.local/lib/python3.8/site-packages/torch/nn/modules/loss.py", line 1163, in forward
        return F.cross_entropy(input, target, weight=self.weight,
      File "/home/name/.local/lib/python3.8/site-packages/torch/nn/functional.py", line 2996, in cross_entropy
        return torch._C._nn.cross_entropy_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index, label_smoothing)
    ValueError: Expected input batch_size (256) to match target batch_size (16).
    
```

'''コードとエラー箇所'''

```

    import argparse
    import os
    import shutil
    import time
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.nn.parallel
    import torch.backends.cudnn as cudnn
    import torch.optim
    import torch.utils.data
    import torchvision.transforms as transforms
    import torchvision.datasets as datasets
    from torch.autograd import Variable
    
    from wideresnet import WideResNet
    
    # used for logging to TensorBoard
    from tensorboard_logger import configure, log_value
     
    parser = argparse.ArgumentParser(description='PyTorch WideResNet Training')
    parser.add_argument('--dataset', default='mydata', type=str,
                        help='dataset (cifar10 [default] or cifar100)')
    parser.add_argument('--epochs', default=200, type=int,
                        help='number of total epochs to run')
    parser.add_argument('--start-epoch', default=0, type=int,
                        help='manual epoch number (useful on restarts)')
    parser.add_argument('-b', '--batch-size', default=16, type=int,
                        help='mini-batch size (default: 128)')
    parser.add_argument('--lr', '--learning-rate', default=0.1, type=float,
                        help='initial learning rate')
    parser.add_argument('--momentum', default=0.9, type=float, help='momentum')
    parser.add_argument('--nesterov', default=True, type=bool, help='nesterov momentum')
    parser.add_argument('--weight-decay', '--wd', default=5e-4, type=float,
                        help='weight decay (default: 5e-4)')
    parser.add_argument('--print-freq', '-p', default=10, type=int,
                        help='print frequency (default: 10)')
    parser.add_argument('--layers', default=28, type=int,
                        help='total number of layers (default: 28)')
    parser.add_argument('--widen-factor', default=10, type=int,
                        help='widen factor (default: 10)')
    parser.add_argument('--droprate', default=0, type=float,
                        help='dropout probability (default: 0.0)')
    parser.add_argument('--no-augment', dest='augment', action='store_false',
                        help='whether to use standard augmentation (default: True)')
    parser.add_argument('--resume', default='', type=str,
                        help='path to latest checkpoint (default: none)')
    parser.add_argument('--name', default='WideResNet-28-10', type=str,
                        help='name of experiment')
    parser.add_argument('--tensorboard',
                        help='Log progress to TensorBoard', action='store_true')
    parser.set_defaults(augment=True)
    
    best_prec1 = 0
    
    def main():
        global args, best_prec1
        args = parser.parse_args()
        if args.tensorboard: configure("runs/%s"%(args.name))
    
        # Data loading code
    
        normal_mean = (0.5, 0.5, 0.5)
        normal_std = (0.5, 0.5, 0.5)
    
        if args.augment:
            transform_train = transforms.Compose([
            transforms.RandomHorizontalFlip(),
            transforms.RandomCrop(size=150,
                                  padding=int(150*0.125),
                                  padding_mode='reflect'),
            transforms.ToTensor(),
            transforms.Normalize(mean=normal_mean,
                                 std=normal_std)
        ])
    
        transform_test = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize(mean=normal_mean,
                                 std=normal_std)
        ])
    
     
        train_dataset = datasets.ImageFolder(
                            root = "./mydata/500mydata",
                            transform = transform_train
                            )
        test_dataset = datasets.ImageFolder(
                            root = "./mydata/test1",
                            transform = transform_test
                            )
            
        kwargs = {'num_workers': 1, 'pin_memory': False}
    
        
        
        train_loader = DataLoader(
            train_dataset,
            batch_size=args.batch_size,
            sampler=RandomSampler(train_dataset),
            num_workers=1,
            drop_last=True)
    
        test_loader = DataLoader(
            test_dataset,
            batch_size=args.batch_size,
            sampler=SequentialSampler(test_dataset),
            num_workers=1)
    
        # create model
        model = WideResNet(args.layers,args.widen_factor, dropRate=args.droprate)
    
        # get the number of model parameters
        print('Number of model parameters: {}'.format(
            sum([p.data.nelement() for p in model.parameters()])))
    
        # for training on multiple GPUs.
        # Use CUDA_VISIBLE_DEVICES=0,1 to specify which GPUs to use
        # model = torch.nn.DataParallel(model).cuda()
        model = model.cuda()
    
        # optionally resume from a checkpoint
        if args.resume:
            if os.path.isfile(args.resume):
                print("=> loading checkpoint '{}'".format(args.resume))
                checkpoint = torch.load(args.resume)
                args.start_epoch = checkpoint['epoch']
                best_prec1 = checkpoint['best_prec1']
                model.load_state_dict(checkpoint['state_dict'])
                print("=> loaded checkpoint '{}' (epoch {})"
                      .format(args.resume, checkpoint['epoch']))
            else:
                print("=> no checkpoint found at '{}'".format(args.resume))
    
        cudnn.benchmark = True
    
        # define loss function (criterion) and optimizer
        criterion = nn.CrossEntropyLoss().cuda()
        optimizer = torch.optim.SGD(model.parameters(), args.lr,
                                    momentum=args.momentum, nesterov = args.nesterov,
                                    weight_decay=args.weight_decay)
    
        # cosine learning rate
        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, len(train_loader)*args.epochs)
    
        for epoch in range(args.start_epoch, args.epochs):
            # train for one epoch
            train(train_loader, model, criterion, optimizer, scheduler, epoch)
    
            # evaluate on validation set
            prec1 = validate(test_loader, model, criterion, epoch)
    
            # remember best prec@1 and save checkpoint
            is_best = prec1 > best_prec1
            best_prec1 = max(prec1, best_prec1)
            save_checkpoint({
                'epoch': epoch + 1,
                'state_dict': model.state_dict(),
                'best_prec1': best_prec1,
            }, is_best)
        print('Best accuracy: ', best_prec1)
    
    def train(train_loader, model, criterion, optimizer, scheduler, epoch):
        """Train for one epoch on the training set"""
        batch_time = AverageMeter()
        losses = AverageMeter()
        top1 = AverageMeter()
    
        # switch to train mode
        model.train()
    
        end = time.time()
        for i, (input, target) in enumerate(train_loader):
            target = target.cuda(non_blocking=True)
            input = input.cuda(non_blocking=True)
    
            # compute output
            output = model(input)
            loss = criterion(output, target)
    
            # measure accuracy and record loss
            prec1 = accuracy(output.data, target, topk=(1,))[0]
            losses.update(loss.data.item(), input.size(0))
            top1.update(prec1.item(), input.size(0))
    
            # compute gradient and do SGD step
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            scheduler.step()
    
            # measure elapsed time
            batch_time.update(time.time() - end)
            end = time.time()
    
            if i % args.print_freq == 0:
                print('Epoch: [{0}][{1}/{2}]\t'
                      'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
                      'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
                      'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
                          epoch, i, len(train_loader), batch_time=batch_time,
                          loss=losses, top1=top1))
        # log to TensorBoard
        if args.tensorboard:
            log_value('train_loss', losses.avg, epoch)
            log_value('train_acc', top1.avg, epoch)
    
    def validate(test_loader, model, criterion, epoch):
        """Perform validation on the validation set"""
        batch_time = AverageMeter()
        losses = AverageMeter()
        top1 = AverageMeter()
    
        # switch to evaluate mode
        model.eval()
    
        end = time.time()
        for i, (input, target) in enumerate(test_loader):
            target = target.cuda(non_blocking=True)
            input = input.cuda(non_blocking=True)
    
            # compute output
            with torch.no_grad():
                output = model(input)
            loss = criterion(output, target)
    
            # measure accuracy and record loss
            prec1 = accuracy(output.data, target, topk=(1,))[0]
            losses.update(loss.data.item(), input.size(0))
            top1.update(prec1.item(), input.size(0))
    
            # measure elapsed time
            batch_time.update(time.time() - end)
            end = time.time()
    
            if i % args.print_freq == 0:
                print('Test: [{0}/{1}]\t'
                      'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
                      'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
                      'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
                          i, len(test_loader), batch_time=batch_time, loss=losses,
                          top1=top1))
    
        print(' * Prec@1 {top1.avg:.3f}'.format(top1=top1))
        # log to TensorBoard
        if args.tensorboard:
            log_value('test_loss', losses.avg, epoch)
            log_value('test_acc', top1.avg, epoch)
        return top1.avg
    
    
    def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
        """Saves checkpoint to disk"""
        directory = "runs/%s/"%(args.name)
        if not os.path.exists(directory):
            os.makedirs(directory)
        filename = directory + filename
        torch.save(state, filename)
        if is_best:
            shutil.copyfile(filename, 'runs/%s/'%(args.name) + 'model_best.pth.tar')
    
    class AverageMeter(object):
        """Computes and stores the average and current value"""
        def __init__(self):
            self.reset()
    
        def reset(self):
            self.val = 0
            self.avg = 0
            self.sum = 0
            self.count = 0
    
        def update(self, val, n=1):
            self.val = val
            self.sum += val * n
            self.count += n
            self.avg = self.sum / self.count
    
    def accuracy(output, target, topk=(1,)):
        """Computes the precision@k for the specified values of k"""
        maxk = max(topk)
        batch_size = target.size(0)
    
        _, pred = output.topk(maxk, 1, True, True)
        pred = pred.t()
        correct = pred.eq(target.view(1, -1).expand_as(pred))
    
        res = []
        for k in topk:
            correct_k = correct[:k].view(-1).float().sum(0)
            res.append(correct_k.mul_(100.0 / batch_size))
        return res
    
    if __name__ == '__main__':
        main()
    
```
CC BY-SA 4.0
2022-06-23T05:51:14.973
89542
2022-06-23T05:55:11.583
2022-06-23T05:55:11.583
53193
53193
question
python 深層学習 pytorch
ValueError: Expected input batch_size (256) to match target batch_size (16).のエラー