Exemplo n.º 1
0
def get_setting(args):
    kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
    path = os.path.join(args.data_folder)
    if args.dataset == 'mnist':
        num_class = 10
        train_loader = torch.utils.data.DataLoader(datasets.MNIST(
            path,
            train=True,
            download=True,
            transform=transforms.Compose([
                transforms.ToTensor(),
                transforms.Normalize((0.1307, ), (0.3081, ))
            ])),
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        test_loader = torch.utils.data.DataLoader(
            datasets.MNIST(path,
                           train=False,
                           transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307, ), (0.3081, ))
                           ])),
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)
    elif args.dataset == 'smallNORB':
        num_class = 5
        train_loader = torch.utils.data.DataLoader(smallNORB(
            path,
            train=True,
            download=True,
            transform=transforms.Compose([
                transforms.Resize(48),
                transforms.RandomCrop(32),
                transforms.ColorJitter(brightness=32. / 255, contrast=0.5),
                transforms.ToTensor()
            ])),
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        test_loader = torch.utils.data.DataLoader(
            smallNORB(path,
                      train=False,
                      transform=transforms.Compose([
                          transforms.Resize(48),
                          transforms.CenterCrop(32),
                          transforms.ToTensor()
                      ])),
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)
    else:
        raise NameError('Undefined dataset {}'.format(args.dataset))
    return num_class, train_loader, test_loader
Exemplo n.º 2
0
def get_setting(args):
    kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
    path = os.path.join(args.data_folder, args.dataset)

    if args.dataset == 'mnist':
        num_class = 10
        train_loader = torch.utils.data.DataLoader(datasets.MNIST(
            path,
            train=True,
            download=True,
            transform=transforms.Compose([
                transforms.ToTensor(),
                transforms.Normalize((0.1307, ), (0.3081, ))
            ])),
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        test_loader = torch.utils.data.DataLoader(
            datasets.MNIST(path,
                           train=False,
                           transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307, ), (0.3081, ))
                           ])),
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)
    elif args.dataset == 'smallNORB':
        num_class = 5
        train_loader = torch.utils.data.DataLoader(smallNORB(
            path,
            train=True,
            download=True,
            transform=transforms.Compose([
                transforms.Resize(48),
                transforms.RandomCrop(32),
                transforms.ColorJitter(brightness=32. / 255, contrast=0.5),
                transforms.ToTensor()
            ])),
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        test_loader = torch.utils.data.DataLoader(
            smallNORB(path,
                      train=False,
                      transform=transforms.Compose([
                          transforms.Resize(48),
                          transforms.CenterCrop(32),
                          transforms.ToTensor()
                      ])),
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)
    elif args.dataset == 'gtrsb':
        num_class = 43

        full_dataset = GTRSB(path,
                             download=True,
                             transform=transforms.Compose([
                                 transforms.Grayscale(),
                                 transforms.Resize(
                                     (48, 48), interpolation=Image.LANCZOS),
                                 transforms.ToTensor()
                             ]))
        train_size = 39209
        val_size = 12630
        print(f"Train Size: {str(train_size)}")
        print(f"Val Size: {str(val_size)}")

        train_dataset, val_dataset = torch.utils.data.random_split(
            full_dataset, [train_size, val_size])

        train_loader = torch.utils.data.DataLoader(train_dataset,
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        val_loader = torch.utils.data.DataLoader(
            val_dataset,
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)

    else:
        raise NameError('Undefined dataset {}'.format(args.dataset))
    return num_class, train_loader, val_loader
Exemplo n.º 3
0
     logger = util.statNothing()
 elif args.dataset[:5] == 'MNIST':
     train_dataset = datasets.MNIST(root='../../data/',
                                    train=True,
                                    transform=transforms.ToTensor(),
                                    download=True)
     test_dataset = datasets.MNIST(root='../../data/',
                                   train=False,
                                   transform=transforms.ToTensor())
     logger = util.statClassification(args)
 elif args.dataset == 'smallNORB':  # transforms.Resize(48),
     train_dataset = smallNORB('../../data/smallnorb/',
                               train=True,
                               download=True,
                               transform=transforms.Compose([
                                   transforms.RandomCrop(64),
                                   transforms.ColorJitter(brightness=32. /
                                                          255,
                                                          contrast=0.5),
                                   transforms.ToTensor()
                               ]))
     test_dataset = smallNORB('../../data/smallnorb/',
                              train=False,
                              transform=transforms.Compose([
                                  transforms.CenterCrop(64),
                                  transforms.ToTensor()
                              ]))
 elif args.dataset == 'msra':
     train_dataset = MARAHandDataset('../../data/cvpr15_MSRAHandGestureDB',
                                     'train', 2)
     #train_dataset.test()
     test_dataset = MARAHandDataset('../../data/cvpr15_MSRAHandGestureDB',
Exemplo n.º 4
0
def get_setting(args):
    kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
    path = os.path.join(args.data_folder, args.dataset)
    if args.dataset == 'mnist':
        num_class = 10
        train_loader = torch.utils.data.DataLoader(
            datasets.MNIST(path, train=True, download=True,
                           transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307,), (0.3081,))
                           ])),
            batch_size=args.batch_size, shuffle=True, **kwargs)
        test_loader = torch.utils.data.DataLoader(
            datasets.MNIST(path, train=False,
                           transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307,), (0.3081,))
                           ])),
            batch_size=args.test_batch_size, shuffle=True, **kwargs)
    elif args.dataset == 'smallNORB':
        num_class = 5
        train_loader = torch.utils.data.DataLoader(
            smallNORB(path, train=True, download=True,
                      transform=transforms.Compose([
                          transforms.Resize(48),
                          transforms.RandomCrop(32),
                          transforms.ColorJitter(brightness=32./255, contrast=0.5),
                          transforms.ToTensor()
                      ])),
            batch_size=args.batch_size, shuffle=True, **kwargs)
        test_loader = torch.utils.data.DataLoader(
            smallNORB(path, train=False,
                      transform=transforms.Compose([
                          transforms.Resize(48),
                          transforms.CenterCrop(32),
                          transforms.ToTensor()
                      ])),
            batch_size=args.test_batch_size, shuffle=True, **kwargs)
    elif args.dataset == "KTH":
        print("Preparing KTH data...")
        print("train batch size: ", args.batch_size)
        print("test batch size: ", args.test_batch_size)

        train_data = prepareDataset("/Volumes/E_128/train")
        test_data = prepareDataset("/Volumes/E_128/test")
        num_class = 6

        # train
        classes={
            "handwaving": 0,
            "handclapping": 1,
            "boxing": 2,
            "walking": 3,
            "running": 4,
            "jogging": 5
        }

        action_dataset_train = ActionDataset(train_data, classes, transforms=transforms.Compose([
                          transforms.Resize(48),
                          transforms.RandomCrop(32),
                          transforms.ColorJitter(brightness=32./255, contrast=0.5),
                          transforms.ToTensor()
                      ]))

        train_loader = torch.utils.data.DataLoader(action_dataset_train, batch_size=args.batch_size,
                                                   shuffle=True, **kwargs)

        action_dataset_test = ActionDataset(test_data, classes, transforms=transforms.Compose([
            transforms.Resize(48),
            transforms.RandomCrop(32),
            transforms.ToTensor()
        ]))

        test_loader = torch.utils.data.DataLoader(action_dataset_test, batch_size=args.test_batch_size,
                                                  shuffle=True, **kwargs)
    else:
        raise NameError('Undefined dataset {}'.format(args.dataset))
    return num_class, train_loader, test_loader
Exemplo n.º 5
0
def get_setting(args):
    kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
    path = os.path.join(args.data_folder, args.dataset)

    # normalize = transforms.Normalize(mean=[x/255.0 for x in [125.3, 123.0, 113.9]],
    #                                     std=[x/255.0 for x in [63.0, 62.1, 66.7]])
    transform_train = transforms.Compose([
        transforms.Grayscale(num_output_channels=1),
        transforms.RandomCrop(28, padding='valid'),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor()
    ])

    transform_test = transforms.Compose(
        [transforms.Grayscale(num_output_channels=1),
         transforms.ToTensor()])

    if args.dataset == 'mnist':
        num_class = 10
        train_loader = torch.utils.data.DataLoader(datasets.MNIST(
            path,
            train=True,
            download=True,
            transform=transforms.Compose([
                transforms.ToTensor(),
                transforms.Normalize((0.1307, ), (0.3081, ))
            ])),
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        test_loader = torch.utils.data.DataLoader(
            datasets.MNIST(path,
                           train=False,
                           transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307, ), (0.3081, ))
                           ])),
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)
    elif args.dataset == 'smallNORB':
        num_class = 5
        train_loader = torch.utils.data.DataLoader(smallNORB(
            path,
            train=True,
            download=True,
            transform=transforms.Compose([
                transforms.Resize(48),
                transforms.RandomCrop(32),
                transforms.ColorJitter(brightness=32. / 255, contrast=0.5),
                transforms.ToTensor()
            ])),
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        test_loader = torch.utils.data.DataLoader(
            smallNORB(path,
                      train=False,
                      transform=transforms.Compose([
                          transforms.Resize(48),
                          transforms.CenterCrop(32),
                          transforms.ToTensor()
                      ])),
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)

    elif args.dataset == 'cifar10':
        num_class = 10
        train_loader = torch.utils.data.DataLoader(datasets.CIFAR10(
            path,
            train=True,
            download=True,
            transform=transforms.Compose([
                transforms.Grayscale(num_output_channels=1),
                transforms.RandomCrop(32),
                transforms.ToTensor()
            ])),
                                                   batch_size=args.batch_size,
                                                   shuffle=True,
                                                   **kwargs)
        test_loader = torch.utils.data.DataLoader(
            datasets.CIFAR10(path,
                             train=False,
                             transform=transforms.Compose([
                                 transforms.Grayscale(num_output_channels=1),
                                 transforms.ToTensor()
                             ])),
            batch_size=args.test_batch_size,
            shuffle=True,
            **kwargs)
    else:
        raise NameError('Undefined dataset {}'.format(args.dataset))
    return num_class, train_loader, test_loader