def get_val_dataset(p, transform=None, to_neighbors_dataset=False, to_similarity_dataset=False, use_negatives=False, use_simpred=False): # Base dataset if p['val_db_name'] == 'cifar-10': from data.cifar import CIFAR10 dataset = CIFAR10(train=False, transform=transform, download=True) elif p['val_db_name'] == 'cifar-20': from data.cifar import CIFAR20 dataset = CIFAR20(train=False, transform=transform, download=True) elif p['val_db_name'] == 'stl-10': from data.stl import STL10 dataset = STL10(split='test', transform=transform, download=True) elif p['train_db_name'] in [ 'impact_kb', 'impact_full_balanced', 'impact_full_imbalanced', 'hdi_balanced', 'hdi_imbalanced', 'tobacco3482', 'rvl-cdip', 'wpi_demo' ]: from data.imagefolderwrapper import ImageFolderWrapper root = MyPath.db_root_dir(p['train_db_name']) dataset = ImageFolderWrapper(root, split="test", transform=transform) elif p['val_db_name'] == 'imagenet': from data.imagenet import ImageNet dataset = ImageNet(split='val', transform=transform) elif p['val_db_name'] in ['imagenet_50', 'imagenet_100', 'imagenet_200']: from data.imagenet import ImageNetSubset subset_file = './data/imagenet_subsets/%s.txt' % (p['val_db_name']) dataset = ImageNetSubset(subset_file=subset_file, split='val', transform=transform) else: raise ValueError('Invalid validation dataset {}'.format( p['val_db_name'])) # Wrap into other dataset (__getitem__ changes) if to_neighbors_dataset: # Dataset returns an image and one of its nearest neighbors. from data.custom_dataset import NeighborsDataset knn_indices = np.load(p['topk_neighbors_val_path']) if use_negatives: kfn_indices = np.load(p['topk_furthest_val_path']) else: kfn_indices = None dataset = NeighborsDataset(dataset, knn_indices, kfn_indices, use_simpred, 5, 5) # Only use 5 elif to_similarity_dataset: # Dataset returns an image and another random image. from data.custom_dataset import SimilarityDataset dataset = SimilarityDataset(dataset) return dataset
def get_val_dataset(p, transform=None, to_neighbors_dataset=False): # Base dataset if p['val_db_name'] == 'cifar-10': from data.cifar import CIFAR10 dataset = CIFAR10(train=False, transform=transform, download=True) elif p['val_db_name'] == 'cifar-20': from data.cifar import CIFAR20 dataset = CIFAR20(train=False, transform=transform, download=True) elif p['val_db_name'] == 'stl-10': from data.stl import STL10 dataset = STL10(split='test', transform=transform, download=True) elif p['val_db_name'] == 'imagenet': from data.imagenet import ImageNet dataset = ImageNet(split='val', transform=transform) elif p['val_db_name'] in ['imagenet_50', 'imagenet_100', 'imagenet_200']: from data.imagenet import ImageNetSubset subset_file = './data/imagenet_subsets/%s.txt' %(p['val_db_name']) dataset = ImageNetSubset(subset_file=subset_file, split='val', transform=transform) else: raise ValueError('Invalid validation dataset {}'.format(p['val_db_name'])) # Wrap into other dataset (__getitem__ changes) if to_neighbors_dataset: # Dataset returns an image and one of its nearest neighbors. from data.custom_dataset import NeighborsDataset indices = np.load(p['topk_neighbors_val_path']) dataset = NeighborsDataset(dataset, indices, 5) # Only use 5 return dataset
def get_datasets(dataset_name, noise_type, noise_rate): if (dataset_name == "MNIST"): train_dataset = MNIST(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) test_dataset = MNIST(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) elif (dataset_name == "CIFAR10"): train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) elif (dataset_name == "CIFAR100"): train_dataset = CIFAR100(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) test_dataset = CIFAR100(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) # elif(dataset_name == "Clothes1M"): # train_dataset, test_dataset = return train_dataset, test_dataset
def main(): parser = argparse.ArgumentParser() parser.add_argument("--config", default="./config/craft/example.yaml") parser.add_argument("--gpu", default="0", type=str) args = parser.parse_args() config, _, config_name = load_config(args.config) train_transform = train_transform = transforms.Compose([transforms.ToTensor()]) train_data = CIFAR10(config["dataset_dir"], transform=train_transform, train=True) train_loader = DataLoader(train_data, **config["loader"]) os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu gpu = torch.cuda.current_device() print("Set GPU to: {}".format(args.gpu)) model = resnet18() model = model.cuda(gpu) adv_ckpt = torch.load(config["adv_model_path"], map_location="cuda:{}".format(gpu)) model.load_state_dict(adv_ckpt) print( "Load training state from the checkpoint {}:".format(config["adv_model_path"]) ) if config["normalization_layer"] is not None: normalization_layer = NormalizeByChannelMeanStd(**config["normalization_layer"]) normalization_layer = normalization_layer.cuda(gpu) print("Add a normalization layer: {} before model".format(normalization_layer)) model = nn.Sequential(normalization_layer, model) pgd_config = config["pgd"] print("Set PGD attacker: {}.".format(pgd_config)) max_pixel = pgd_config.pop("max_pixel") for k, v in pgd_config.items(): if k == "eps" or k == "alpha": pgd_config[k] = v / max_pixel attacker = PGD(model, **pgd_config) attacker.set_return_type("int") perturbed_img = torch.zeros((len(train_data), *config["size"]), dtype=torch.uint8) target = torch.zeros(len(train_data)) i = 0 for item in tqdm(train_loader): # Adversarially perturb image. Note that torchattacks will automatically # move `img` and `target` to the gpu where the attacker.model is located. img = attacker(item["img"], item["target"]) perturbed_img[i : i + len(img), :, :, :] = img.permute(0, 2, 3, 1).detach() target[i : i + len(item["target"])] = item["target"] i += img.shape[0] if not os.path.exists(config["adv_dataset_dir"]): os.makedirs(config["adv_dataset_dir"]) adv_data_path = os.path.join( config["adv_dataset_dir"], "{}.npz".format(config_name) ) np.savez(adv_data_path, data=perturbed_img.numpy(), targets=target.numpy()) print("Save the adversarially perturbed dataset to {}".format(adv_data_path))
def get_train_dataset(p, transform, to_augmented_dataset=False, to_neighbors_dataset=False, split=None): # Base dataset if p['train_db_name'] == 'cifar-10': from data.cifar import CIFAR10 dataset = CIFAR10(train=True, transform=transform, download=True) elif p['train_db_name'] == 'cifar-20': from data.cifar import CIFAR20 dataset = CIFAR20(train=True, transform=transform, download=True) elif p['train_db_name'] == 'stl-10': from data.stl import STL10 dataset = STL10(split=split, transform=transform, download=True) elif p['train_db_name'] == 'imagenet': from data.imagenet import ImageNet dataset = ImageNet(split='train', transform=transform) elif p['train_db_name'] in ['imagenet_50', 'imagenet_100', 'imagenet_200']: from data.imagenet import ImageNetSubset subset_file = './data/imagenet_subsets/%s.txt' % (p['train_db_name']) dataset = ImageNetSubset(subset_file=subset_file, split='train', transform=transform) #Added by Johan elif p['train_db_name'] == 'tabledb': from data.tabledb import TableDB dataset = TableDB(split='train', transform=transform) #Added by Johan elif p['train_db_name'] == 'tablestrdb': from data.tablestrdb import TableStrDB dataset = TableStrDB(split='train', transform=transform) else: raise ValueError('Invalid train dataset {}'.format(p['train_db_name'])) # Wrap into other dataset (__getitem__ changes) if to_augmented_dataset: # Dataset returns an image and an augmentation of that image. from data.custom_dataset import AugmentedDataset dataset = AugmentedDataset(dataset) if to_neighbors_dataset: # Dataset returns an image and one of its nearest neighbors. from data.custom_dataset import NeighborsDataset indices = np.load(p['topk_neighbors_train_path']) dataset = NeighborsDataset(dataset, indices, p['num_neighbors']) return dataset
def build_CIFAR(args,transform_train=None,valTrain=False): if transform_train is None: transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465),(0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465),(0.2023, 0.1994, 0.2010)), ]) train_dataset = CIFAR10(root='./data/', download=True, type='train', transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate, small=True ) val_dataset = CIFAR10(root='./data/', download=True, type='validation', transform=transform_train if valTrain else transform_test, noise_type='clean', noise_rate=0 ) test_dataset = CIFAR10(root='./data/', download=True, type='test', transform=transform_test, noise_type='clean', noise_rate=0 ) return train_dataset,val_dataset,test_dataset
def get_train_dataset(p, transform, to_augmented_dataset=False, to_neighbors_dataset=False, split=None): # Base dataset if p['train_db_name'] == 'cifar-10': from data.cifar import CIFAR10 dataset = CIFAR10(train=True, transform=transform, download=True) elif p['train_db_name'] == 'cifar-20': from data.cifar import CIFAR20 dataset = CIFAR20(train=True, transform=transform, download=True) elif p['train_db_name'] == 'stl-10': from data.stl import STL10 dataset = STL10(split=split, transform=transform, download=True) elif p['train_db_name'] == 'imagenet': from data.imagenet import ImageNet dataset = ImageNet(split='train', transform=transform) elif p['train_db_name'] in ['imagenet_50', 'imagenet_100', 'imagenet_200']: from data.imagenet import ImageNetSubset subset_file = './data/imagenet_subsets/%s.txt' %(p['train_db_name']) dataset = ImageNetSubset(subset_file=subset_file, split='train', transform=transform) elif p['train_db_name'] == 'celeb-a': import torchvision from data.celeba import CelebADataset # dataset = torchvision.datasets.CelebA(r'E:\datasets\celeb-a', 'train') dataset = CelebADataset('train', target_type=p['db_targets'], attr_index=p['attr_index'], transform=transform) elif p['train_db_name'] == 'birds-200-2011': from data.birds200 import Birds200_2011 dataset = Birds200_2011(is_train=True, targets_type=p['db_targets'], transform=transform) else: raise ValueError('Invalid train dataset {}'.format(p['train_db_name'])) # Wrap into other dataset (__getitem__ changes) if to_augmented_dataset: # Dataset returns an image and an augmentation of that image. from data.custom_dataset import AugmentedDataset dataset = AugmentedDataset(dataset) if to_neighbors_dataset: # Dataset returns an image and one of its nearest neighbors. from data.custom_dataset import NeighborsDataset indices = np.load(p['topk_neighbors_train_path']) dataset = NeighborsDataset(dataset, indices, p['num_neighbors']) return dataset
def main(): use_cuda = torch.cuda.is_available() global best_acc # load dataset if args.dataset == 'cifar10': print(f"Using {args.dataset}") num_classes = 10 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)), ]) train_dataset = CIFAR10(root='/home/kanchanaranasinghe/data/cifar', download=True, train=True, transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='/home/kanchanaranasinghe/data/cifar', download=True, train=False, transform=transform_test, noise_type=args.noise_type, noise_rate=args.noise_rate) elif args.dataset == 'cifar100': print(f"Using {args.dataset}") num_classes = 100 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)) ]) train_dataset = CIFAR100(root='/home/kanchanaranasinghe/data/cifar', download=True, train=True, transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR100(root='/home/kanchanaranasinghe/data/cifar', download=True, train=False, transform=transform_test, noise_type=args.noise_type, noise_rate=args.noise_rate) else: raise NotImplementedError(f"invalid dataset: {args.dataset}") testloader = torch.utils.data.DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2) trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=2) # Model if args.resume is not None: # Load checkpoint. print(f'==> Resuming from checkpoint: {args.resume}') checkpoint = torch.load(f"{args.resume}") net = checkpoint['net'] best_acc = checkpoint['acc'] start_epoch = checkpoint['epoch'] + 1 torch.set_rng_state(checkpoint['rng_state']) else: print(f'==> Building model.. (Default : {args.model})') start_epoch = 0 if args.model == "resnet18": net = ResNet18(num_classes) elif args.model == "resnet34": net = ResNet34(num_classes) else: raise NotImplementedError(f"Invalid model: {args.model}") result_folder = f"checkpoint/{args.sess}" log_name = f"{result_folder}/{args.model}_{args.sess}.csv" if use_cuda: net.cuda() net = torch.nn.DataParallel(net) print('Using', torch.cuda.device_count(), 'GPUs.') cudnn.benchmark = True print('Using CUDA..') if args.ce: print(f"Using CE loss") criterion = CrossEntropyLoss() else: print(f"Using Truncated loss") criterion = TruncatedLoss(trainset_size=len(train_dataset)).cuda() if args.opl: print(f"Using OP loss") aux_criterion = OrthogonalProjectionLoss() else: aux_criterion = None optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=args.decay) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.schedule, gamma=args.gamma) if not os.path.exists(log_name): with open(log_name, 'w') as logfile: log_writer = csv.writer(logfile, delimiter=',') log_writer.writerow( ['epoch', 'train loss', 'train acc', 'test loss', 'test acc']) for epoch in range(start_epoch, args.epochs): train_loss, train_acc = train(epoch, trainloader, net, criterion, optimizer, aux_criterion, args) test_loss, test_acc = test(epoch, testloader, net, criterion) with open(log_name, 'a') as logfile: log_writer = csv.writer(logfile, delimiter=',') log_writer.writerow( [epoch, train_loss, train_acc, test_loss, test_acc]) scheduler.step()
def main(): parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--result_dir', type=str, help='dir to save result txt files', default='results/') parser.add_argument('--noise_rate', type=float, help='corruption rate, should be less than 1', default=0.5) parser.add_argument('--forget_rate', type=float, help='forget rate', default=None) parser.add_argument('--noise_type', type=str, help='[pairflip, symmetric]', default='symmetric') parser.add_argument( '--num_gradual', type=int, default=10, help= 'how many epochs for linear drop rate, can be 5, 10, 15. This parameter is equal to Tk for R(T) in Co-teaching paper.' ) parser.add_argument( '--exponent', type=float, default=1, help= 'exponent of the forget rate, can be 0.5, 1, 2. This parameter is equal to c in Tc for R(T) in Co-teaching paper.' ) parser.add_argument('--top_bn', action='store_true') parser.add_argument('--dataset', type=str, help='mnist, cifar10, or cifar100', default='mnist') parser.add_argument('--n_epoch', type=int, default=10) parser.add_argument('--seed', type=int, default=1) parser.add_argument('--print_freq', type=int, default=50) parser.add_argument('--num_workers', type=int, default=4, help='how many subprocesses to use for data loading') parser.add_argument('--num_iter_per_epoch', type=int, default=400) parser.add_argument('--epoch_decay_start', type=int, default=80) parser.add_argument('--eps', type=float, default=9.9) parser.add_argument('--batch-size', type=int, default=1000, metavar='N', help='input batch size for training (default: 256)') parser.add_argument('--test-batch-size', type=int, default=4000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--lr', type=float, default=0.005, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument( '--log-interval', type=int, default=100, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--save-model', action='store_true', default=False, help='For Saving the current Model') args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) batch_size = args.batch_size if args.dataset == 'mnist': input_channel = 1 num_classes = 10 args.top_bn = False args.epoch_decay_start = 80 args.n_epoch = 200 train_dataset = MNIST(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = MNIST(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 args.top_bn = False args.epoch_decay_start = 80 args.n_epoch = 200 train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar100': input_channel = 3 num_classes = 100 args.top_bn = False args.epoch_decay_start = 100 args.n_epoch = 200 train_dataset = CIFAR100(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR100(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.forget_rate is None: forget_rate = args.noise_rate else: forget_rate = args.forget_rate noise_or_not = train_dataset.noise_or_not # Data Loader (Input Pipeline) print('loading dataset...') train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) # Define models #print('building model...') #cnn1 = CNN(input_channel=input_channel, n_outputs=num_classes+1) #cnn1.cuda() #print(cnn1.parameters) use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") cnn1 = Net().to(device) #cnn1=nn.DataParallel(cnn1,device_ids=[0,1,2,3]).cuda() #print(model.parameters) #optimizer1 = torch.optim.SGD(cnn1.parameters(), lr=learning_rate) #optimizer = torch.optim.Adam(cnn1.parameters(), lr=args.lr) optimizer = torch.optim.SGD(cnn1.parameters(), lr=args.lr, momentum=args.momentum) #optimizer = nn.DataParallel(optimizer, device_ids=[0,1,2,3]) acc = [] loss = [] loss_pure = [] loss_corrupt = [] out = [] for epoch in range(1, args.n_epoch + 1): l1, out10 = train(args, cnn1, device, train_loader, optimizer, epoch, eps=args.eps, nums=num_classes) loss.append(l1) out.append(out10) acc.append(test(args, cnn1, device, test_loader, num_classes)) name = "raw " + str(args.dataset) + " " + str(args.noise_type) + " " + str( args.noise_rate) + " " + str(args.eps) np.save(name + " acc.npy", acc) np.save(name + " loss.npy", loss)
])) transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) trainset = CIFAR10(root=args.dataset_root, train=True, download=True, transform=transform_train) trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2) trainset = CIFAR10(root=args.dataset_root, train=True, download=True, transform=transform_twice) trainloader_twice = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2) testset = CIFAR10(root=args.dataset_root,
def main(): print("===Setup running===") parser = argparse.ArgumentParser() parser.add_argument("--config", default="./config/poison_train.yaml") parser.add_argument("--gpu", default="0", type=str) args = parser.parse_args() config, _, _ = load_config(args.config) print("===Prepare data===") bd_config = config["backdoor"] print("Load backdoor config:\n{}".format(bd_config)) bd_transform = CLBD(bd_config["clbd"]["trigger_path"]) target_label = bd_config["target_label"] poison_ratio = bd_config["poison_ratio"] train_transform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]), ]) test_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]), ]) print("Load dataset from: {}".format(config["dataset_dir"])) clean_train_data = CIFAR10(config["dataset_dir"], train_transform, train=True) poison_train_idx = gen_poison_idx(clean_train_data, target_label, poison_ratio=poison_ratio) print("Load the adversarially perturbed dataset from: {}".format( config["adv_dataset_path"])) poison_train_data = CleanLabelDataset( clean_train_data, config["adv_dataset_path"], bd_transform, poison_train_idx, target_label, ) poison_train_loader = DataLoader(poison_train_data, **config["loader"], shuffle=True) clean_test_data = CIFAR10(config["dataset_dir"], test_transform, train=False) poison_test_idx = gen_poison_idx(clean_test_data, target_label) poison_test_data = CleanLabelDataset( clean_test_data, config["adv_dataset_path"], bd_transform, poison_test_idx, target_label, ) clean_test_loader = DataLoader(clean_test_data, **config["loader"]) poison_test_loader = DataLoader(poison_test_data, **config["loader"]) os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu gpu = torch.cuda.current_device() print("Set gpu to: {}".format(args.gpu)) model = resnet18() model = model.cuda(gpu) criterion = nn.CrossEntropyLoss() criterion = criterion.cuda(gpu) optimizer = torch.optim.SGD(model.parameters(), **config["optimizer"]["SGD"]) scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, **config["lr_scheduler"]["multi_step"]) for epoch in range(config["num_epochs"]): print("===Epoch: {}/{}===".format(epoch + 1, config["num_epochs"])) print("Poison training...") poison_train(model, poison_train_loader, criterion, optimizer) print("Test model on clean data...") test(model, clean_test_loader, criterion) print("Test model on poison data...") test(model, poison_test_loader, criterion) scheduler.step() print("Adjust learning rate to {}".format( optimizer.param_groups[0]["lr"]))
def main(): parser = argparse.ArgumentParser( description='PyTorch Gambler\'s Loss Runner') parser.add_argument('--result_dir', type=str, help='directory to save result txt files', default='results') parser.add_argument('--gpu', type=int, help='gpu index', default=0) parser.add_argument('--noise_rate', type=float, help='corruption rate, should be less than 1', default=0.5) parser.add_argument('--noise_type', type=str, help='[pairflip, symmetric]', default='symmetric') parser.add_argument('--dataset', type=str, help='mnist, cifar10, or imdb', default='mnist') parser.add_argument('--n_epoch', type=int, default=10) parser.add_argument('--seed', type=int, default=1) parser.add_argument('--num_workers', type=int, default=4, help='how many subprocesses to use for data loading') parser.add_argument('--epoch_decay_start', type=int, default=80) parser.add_argument('--load_model', type=str, default="") parser.add_argument('--batch_size', type=int, default=128, metavar='N', help='input batch size for training (default: 128)') parser.add_argument( '--log-interval', type=int, default=100, metavar='N', help= 'how many batches to wait before logging training status (default: 100)' ) parser.add_argument('--lr', type=float, default=0.001, metavar='LR', help='learning rate (default: 0.001)') parser.add_argument('--start_method', type=int, help='number of epochs before starting method', default=0) # label smoothing args parser.add_argument('--smoothing', type=float, default=1.0, help='smoothing parameter (default: 1)') parser.add_argument('--optimal_smoothing', action='store_true', default=False) parser.add_argument('--scale_lr', type=float, default=0.0, help='exponent to scale learning rate by') parser.add_argument('--method', type=str, help='[nll, smoothing, fsmoothing]', default="nll") args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) if args.dataset == 'mnist': input_channel = 1 num_classes = 10 train_dataset = MNIST(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = MNIST(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) print('loading dataset...') train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transform_test, noise_type=args.noise_type, noise_rate=args.noise_rate) print('loading dataset...') train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) use_cuda = torch.cuda.is_available() device = torch.device("cuda:{}".format(args.gpu) if ( use_cuda and args.gpu >= 0) else "cpu") print("using {}".format(device)) args.lr *= ((0.9 / (args.smoothing - 0.1))**args.scale_lr) print("learning rate scaled to {}".format(args.lr)) print('building model...') if args.dataset == 'mnist': model = cnns.CNN_basic(num_classes=num_classes).to(device) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.9) if args.dataset == 'cifar10': model = resnet.ResNet18().to(device) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.9) test_accs = [] train_losses = [] test_losses = [] out = [] if args.optimal_smoothing: clean_rate = 1 - args.noise_rate args.smoothing = (1 - (2 * clean_rate) + clean_rate * clean_rate * num_classes) / (num_classes - 1) print("Using smoothing parameter {:.2f} for clean rate {:.2f}".format( args.smoothing, clean_rate)) name = "{}_{}_{}_{:.2f}_{:.2f}_{}".format(args.dataset, args.method, args.noise_type, args.smoothing, args.noise_rate, args.seed) if not os.path.exists(args.result_dir): os.system('mkdir -p %s' % args.result_dir) for epoch in range(1, args.n_epoch + 1): for param_group in optimizer.param_groups: print(epoch, param_group['lr']) print(name) train_loss = train(args, model, device, train_loader, optimizer, epoch, num_classes=num_classes, use_method=(epoch >= args.start_method), text=(args.dataset == 'imdb')) train_losses.append(train_loss) test_acc, test_loss = test(args, model, device, test_loader, num_classes, text=(args.dataset == 'imdb')) test_accs.append(test_acc) test_losses.append(test_loss) save_data = { "command": " ".join(sys.argv), "train_loss": train_losses, "test_loss": test_losses, "test_acc": test_accs } save_file = args.result_dir + "/" + name + ".json" json.dump(save_data, open(save_file, 'w'))
def main(): parser = argparse.ArgumentParser( description='PyTorch Gambler\'s Loss Runner') parser.add_argument( '--result_dir', type=str, help='directory to save result txt files', default='results') parser.add_argument( '--noise_rate', type=float, help='corruption rate, should be less than 1', default=0.5) parser.add_argument( '--noise_type', type=str, help='[pairflip, symmetric]', default='symmetric') parser.add_argument( '--dataset', type=str, help='mnist, cifar10, or imdb', default='mnist') parser.add_argument('--n_epoch', type=int, default=10) parser.add_argument('--seed', type=int, default=1) parser.add_argument( '--num_workers', type=int, default=4, help='how many subprocesses to use for data loading') parser.add_argument('--epoch_decay_start', type=int, default=80) parser.add_argument('--load_model', type=str, default="") parser.add_argument( '--batch_size', type=int, default=128, metavar='N', help='input batch size for training (default: 128)') parser.add_argument( '--log-interval', type=int, default=100, metavar='N', help='how many batches to wait before logging training status (default: 100)' ) parser.add_argument( '--lr', type=float, default=0.001, metavar='LR', help='learning rate (default: 0.001)') parser.add_argument( '--early_stopping', action='store_true', default=False, help='enables early stopping criterion for only symmetric datasets') parser.add_argument('--eps', type=float, help='set lambda for lambda type \'gmblers\' only', default=1000.0) parser.add_argument( '--lambda_type', type=str, help='[nll, euc, mid, exp, gmblers]', default="euc") parser.add_argument( '--start_gamblers', type=int, help='number of epochs before starting gamblers', default=0) args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) if args.dataset == 'mnist': input_channel = 1 num_classes = 10 train_dataset = MNIST( root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = MNIST( root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) print('loading dataset...') train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader( dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 train_dataset = CIFAR10( root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10( root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) print('loading dataset...') train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader( dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) if args.dataset == 'imdb': num_classes = 2 embedding_length = 300 hidden_size = 256 print('loading dataset...') TEXT, vocab_size, word_embeddings, train_loader, valid_iter, test_loader = load_data.load_dataset( rate=args.noise_rate, batch_size=args.batch_size) use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") print("using {}".format(device)) print('building model...') if args.dataset == 'mnist': model = CNN_basic(num_classes=num_classes + 1).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) if args.dataset == 'cifar10': model = CNN_small(num_classes=num_classes + 1).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) if args.dataset == 'imdb': model = LSTMClassifier(args.batch_size, num_classes + 1, hidden_size, vocab_size, embedding_length, word_embeddings).to(device) optimizer = LaProp(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr) acc = [] loss = [] out = [] eee = 1 - args.noise_rate criteria = (-1) * (eee * np.log(eee) + (1 - eee) * np.log( (1 - eee) / (args.eps - 1))) name = str(args.dataset) + "_" + str(args.noise_type) + "_" + str( args.noise_rate) + "_" + str(args.eps) + "_" + str(args.seed) if not os.path.exists(args.result_dir): os.system('mkdir -p %s' % args.result_dir) for epoch in range(1, args.n_epoch + 1): l1 = train( args, model, device, train_loader, optimizer, epoch, num_classes=num_classes, use_gamblers=(epoch >= args.start_gamblers), text=(args.dataset == 'imdb')) loss.append(l1) acc.append(test(args, model, device, test_loader, num_classes, text=(args.dataset == 'imdb'))) if l1 < criteria and epoch >= args.start_gamblers and args.early_stopping: print('epoch: {}, loss fulfilled early stopping criteria: {} < {}'.format(epoch, l1, criteria)) break torch.save({ 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'loss': loss, 'test_acc': acc }, args.result_dir + "/" + name + "_model.npy") print(name) np.save(args.result_dir + "/" + name + "_acc.npy", acc) np.save(args.result_dir + "/" + name + "_loss.npy", loss)
def get_dataset(args): ### color augmentation ### color_jitter = transforms.ColorJitter(0.8 * args.color_jitter_strength, 0.8 * args.color_jitter_strength, 0.8 * args.color_jitter_strength, 0.2 * args.color_jitter_strength) rnd_color_jitter = transforms.RandomApply([color_jitter], p=0.8) rnd_gray = transforms.RandomGrayscale(p=0.2) learning_type = args.train_type if args.dataset == 'cifar-10': if learning_type == 'contrastive': transform_train = transforms.Compose([ rnd_color_jitter, rnd_gray, transforms.RandomHorizontalFlip(), transforms.RandomResizedCrop(32), transforms.ToTensor(), ]) transform_test = transform_train elif learning_type == 'linear_eval': transform_train = transforms.Compose([ rnd_color_jitter, rnd_gray, transforms.RandomHorizontalFlip(), transforms.RandomResizedCrop(32), transforms.ToTensor(), ]) transform_test = transforms.Compose([ transforms.ToTensor(), ]) elif learning_type == 'test': transform_train = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.RandomResizedCrop(32), transforms.ToTensor(), ]) transform_test = transforms.Compose([ transforms.ToTensor(), ]) else: assert ('wrong learning type') train_dst = CIFAR10(root='./Data', train=True, download=True, transform=transform_train, contrastive_learning=learning_type) val_dst = CIFAR10(root='./Data', train=False, download=True, transform=transform_test, contrastive_learning=learning_type) if learning_type == 'contrastive': train_sampler = torch.utils.data.distributed.DistributedSampler( train_dst, num_replicas=args.ngpu, rank=args.local_rank, ) train_loader = torch.utils.data.DataLoader( train_dst, batch_size=args.batch_size, num_workers=4, pin_memory=False, shuffle=(train_sampler is None), sampler=train_sampler, ) val_loader = torch.utils.data.DataLoader( val_dst, batch_size=100, num_workers=4, pin_memory=False, shuffle=False, ) return train_loader, train_dst, val_loader, val_dst, train_sampler else: train_loader = torch.utils.data.DataLoader( train_dst, batch_size=args.batch_size, shuffle=True, num_workers=4) val_batch = 100 val_loader = torch.utils.data.DataLoader(val_dst, batch_size=val_batch, shuffle=False, num_workers=4) return train_loader, train_dst, val_loader, val_dst if args.dataset == 'cifar-100': if learning_type == 'contrastive': transform_train = transforms.Compose([ rnd_color_jitter, rnd_gray, transforms.RandomHorizontalFlip(), transforms.RandomResizedCrop(32), transforms.ToTensor() ]) transform_test = transform_train elif learning_type == 'linear_eval': transform_train = transforms.Compose([ rnd_color_jitter, rnd_gray, transforms.RandomHorizontalFlip(), transforms.RandomResizedCrop(32), transforms.ToTensor() ]) transform_test = transforms.Compose([transforms.ToTensor()]) elif learning_type == 'test': transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor() ]) transform_test = transforms.Compose([transforms.ToTensor()]) else: assert ('wrong learning type') train_dst = CIFAR100(root='./Data', train=True, download=True, transform=transform_train, contrastive_learning=learning_type) val_dst = CIFAR100(root='./Data', train=False, download=True, transform=transform_test, contrastive_learning=learning_type) if learning_type == 'contrastive': train_sampler = torch.utils.data.distributed.DistributedSampler( train_dst, num_replicas=args.ngpu, rank=args.local_rank, ) train_loader = torch.utils.data.DataLoader( train_dst, batch_size=args.batch_size, num_workers=4, pin_memory=True, shuffle=(train_sampler is None), sampler=train_sampler, ) val_loader = torch.utils.data.DataLoader( val_dst, batch_size=100, num_workers=4, pin_memory=True, ) return train_loader, train_dst, val_loader, val_dst, train_sampler else: train_loader = torch.utils.data.DataLoader( train_dst, batch_size=args.batch_size, shuffle=True, num_workers=4) val_loader = torch.utils.data.DataLoader(val_dst, batch_size=100, shuffle=False, num_workers=4) return train_loader, train_dst, val_loader, val_dst
print('==> Preparing data..') transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) trainset = CIFAR10(root='./data', train=True, download=True, transform=transform_train, noise_type="clean") trainloader = torch.utils.data.DataLoader(trainset, batch_size=args.bs, shuffle=False, num_workers=16, drop_last=True) testset = CIFAR10(root='./data', train=False, download=True, transform=transform_test, noise_type="clean") testloader = torch.utils.data.DataLoader(testset, batch_size=100,
download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 init_epoch = 20 args.epoch_decay_start = 80 filter_outlier = True # args.n_epoch = 200 train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar100': input_channel = 3 num_classes = 100 init_epoch = 5 args.epoch_decay_start = 100
input_channel = 3 num_classes = 10 init_epoch = 20 args.epoch_decay_start = 80 filter_outlier = True args.model_type = "cnn" # args.n_epoch = 200 transform1 = torchvision.transforms.Compose([ # torchvision.transforms.RandomHorizontalFlip(), # torchvision.transforms.RandomCrop(32, 4), torchvision.transforms.ToTensor(), ]) train_dataset = CIFAR10(root='./../Co-correcting_plus/data/cifar10/', download=False, train=True, transform=transform1, noise_type=args.noise_type, noise_rate=args.noise_rate ) test_dataset = CIFAR10(root='./../Co-correcting_plus/data/cifar10/', download=False, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate ) if args.dataset == 'cifar100': input_channel = 3 num_classes = 100
def get_val_dataset(p, transform=None, to_neighbors_dataset=False, to_neighbors_strangers_dataset=False, to_teachers_dataset=False): # Base dataset if p['val_db_name'] in ['cifar-10', 'cifar-10-d', 'cifar-10-f']: from data.cifar import CIFAR10 dataset = CIFAR10(train=False, transform=transform, download=True) elif p['val_db_name'] in ['cifar-20', 'cifar-20-d', 'cifar-20-f']: from data.cifar import CIFAR20 dataset = CIFAR20(train=False, transform=transform, download=False) elif p['val_db_name'] in ['stl-10', 'stl-10-d', 'stl-10-f']: from data.stl import STL10 dataset = STL10(split='test', transform=transform, download=False) elif 'pascal-pretrained' in p['train_db_name'] or p[ 'train_db_name'] == 'pascal-large-batches' or p[ 'train_db_name'] == 'pascal-retrain': from data.pascal_voc import PASCALVOC dataset = PASCALVOC(transform=transform) elif 'cub' in p['val_db_name']: from data.cub import CUB dataset = CUB(train=False, transform=transform) elif 'imagenet_' in p['val_db_name']: from data.imagenet import ImageNetSubset subset_name = p['val_db_name'].replace('-d', '').replace( '-f', '').replace('-0', '').replace('-1', '').replace('-2', '') subset_file = './data/imagenet_subsets/%s.txt' % (subset_name) dataset = ImageNetSubset(subset_file=subset_file, split='val', transform=transform) elif 'imagenet' in p['val_db_name']: from data.imagenet import ImageNet dataset = ImageNet(split='train', transform=transform) else: raise ValueError('Invalid validation dataset {}'.format( p['val_db_name'])) # Wrap into other dataset (__getitem__ changes) if to_neighbors_dataset: # Dataset returns an image and one of its nearest neighbors. from data.custom_dataset import NeighborsDataset indices = np.load(p['topk_neighbors_val_path']) dataset = NeighborsDataset(dataset, indices, 5) # Only use 5 if to_neighbors_strangers_dataset: from data.custom_dataset import SCANFDataset neighbor_indices = np.load(p['topk_neighbors_val_path']) stranger_indices = np.load(p['topk_strangers_val_path']) dataset = SCANFDataset(dataset, neighbor_indices, stranger_indices, 5, 5) if to_teachers_dataset: from data.custom_dataset import TeachersDataset dataset = TeachersDataset(dataset, p['cluster_preds_path']) return dataset
def main(): parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--result_dir', type=str, help='dir to save result txt files', default='results/') parser.add_argument('--noise_rate', type=float, help='corruption rate, should be less than 1', default=0.5) parser.add_argument('--forget_rate', type=float, help='forget rate', default=None) parser.add_argument('--noise_type', type=str, help='[pairflip, symmetric]', default='symmetric') parser.add_argument( '--num_gradual', type=int, default=10, help= 'how many epochs for linear drop rate, can be 5, 10, 15. This parameter is equal to Tk for R(T) in Co-teaching paper.' ) parser.add_argument( '--exponent', type=float, default=1, help= 'exponent of the forget rate, can be 0.5, 1, 2. This parameter is equal to c in Tc for R(T) in Co-teaching paper.' ) parser.add_argument('--top_bn', action='store_true') parser.add_argument('--dataset', type=str, help='mnist, cifar10, or cifar100', default='mnist') parser.add_argument('--n_epoch', type=int, default=200) parser.add_argument('--seed', type=int, default=1) parser.add_argument('--print_freq', type=int, default=50) parser.add_argument('--num_workers', type=int, default=4, help='how many subprocesses to use for data loading') parser.add_argument('--num_iter_per_epoch', type=int, default=400) parser.add_argument('--epoch_decay_start', type=int, default=80) parser.add_argument('--eps', type=float, default=9.3) parser.add_argument('--batch-size', type=int, default=600, metavar='N', help='input batch size for training (default: 256)') parser.add_argument('--test-batch-size', type=int, default=4000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--lr', type=float, default=0.005, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument( '--log-interval', type=int, default=100, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--save-model', action='store_true', default=False, help='For Saving the current Model') args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) batch_size = args.batch_size if args.dataset == 'mnist': input_channel = 1 num_classes = 10 args.top_bn = False args.epoch_decay_start = 80 args.n_epoch = 200 train_dataset = MNIST(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = MNIST(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 args.top_bn = False args.epoch_decay_start = 80 args.n_epoch = 200 train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar100': input_channel = 3 num_classes = 100 args.top_bn = False args.epoch_decay_start = 100 args.n_epoch = 200 train_dataset = CIFAR100(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR100(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.forget_rate is None: forget_rate = args.noise_rate else: forget_rate = args.forget_rate noise_or_not = train_dataset.noise_or_not # Data Loader (Input Pipeline) print('loading dataset...') train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) # Define models print('building model...') cnn1 = CNN(input_channel=input_channel, n_outputs=num_classes + 1) cnn1.cuda() print(cnn1.parameters) #optimizer1 = torch.optim.SGD(cnn1.parameters(), lr=learning_rate) optimizer = torch.optim.SGD(cnn1.parameters(), lr=args.lr, momentum=args.momentum) use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") save_dir = args.result_dir + '/' + args.dataset + '/new_loss/' if not os.path.exists(save_dir): os.system('mkdir -p %s' % save_dir) model_str = args.dataset + '_new_loss_' + args.noise_type + '_' + str( args.noise_rate) + '_' + str(args.eps) + ' ' nowTime = datetime.datetime.now().strftime('%Y-%m-%d-%H:%M:%S') txtfile = save_dir + "/" + model_str + nowTime + ".txt" if os.path.exists(txtfile): os.system('mv %s %s' % (txtfile, txtfile + ".bak-%s" % nowTime)) acc = [] loss = [] loss_pure = [] loss_corrupt = [] for epoch in range(1, args.n_epoch + 1): # if epoch<20: # loss.append(train(args, model, device, train_loader, optimizer, epoch, eps=9.5)) # else: # loss.append(train(args, model, device, train_loader, optimizer, epoch, eps=5)) #loss.append(train(args, model, device, train_loader, optimizer, epoch, eps=9.3)) l1 = train(args, cnn1, device, train_loader, optimizer, epoch, eps=args.eps) loss.append(l1) acc.append(test(args, cnn1, device, test_loader)) with open(txtfile, "a") as myfile: myfile.write(str(int(epoch)) + ': ' + str(acc[-1]) + "\n") name = str(args.dataset) + " " + str(args.noise_type) + " " + str( args.noise_rate) np.save(name + "acc.npy", acc) np.save(name + "loss.npy", loss)
beta_plan[i] = opt.mom2 rate_schedule = np.ones(opt.n_epoch) * opt.forget_rate rate_schedule[:opt.num_gradual] = np.linspace( 0, opt.forget_rate**opt.exponent, opt.num_gradual) return alpha_plan, beta_plan, rate_schedule def adjust_learning_rate(optimizer, epoch, alpha_plan, beta_plan): for param_group in optimizer.param_groups: param_group['lr'] = alpha_plan[epoch] param_group['betas'] = (beta_plan[epoch], 0.999) print_configuration(opt) data = CIFAR10(noise_rate=opt.noise_rate) train_loader = torch.utils.data.DataLoader(dataset=data, batch_size=128, drop_last=True, shuffle=True) test_data = CIFAR10(train=False) test_loader = torch.utils.data.DataLoader(dataset=test_data, batch_size=128) cnn1 = CNN().cuda() optimizer1 = torch.optim.Adam(cnn1.parameters(), lr=opt.learning_rate) cnn2 = CNN().cuda() optimizer2 = torch.optim.Adam(cnn2.parameters(), lr=opt.learning_rate) if opt.load:
def main(): parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--result_dir', type=str, help='dir to save result txt files', default='results/') parser.add_argument('--noise_rate', type=float, help='corruption rate, should be less than 1', default=0.5) parser.add_argument('--forget_rate', type=float, help='forget rate', default=None) parser.add_argument('--noise_type', type=str, help='[pairflip, symmetric]', default='symmetric') parser.add_argument( '--num_gradual', type=int, default=10, help= 'how many epochs for linear drop rate, can be 5, 10, 15. This parameter is equal to Tk for R(T) in Co-teaching paper.' ) parser.add_argument( '--exponent', type=float, default=1, help= 'exponent of the forget rate, can be 0.5, 1, 2. This parameter is equal to c in Tc for R(T) in Co-teaching paper.' ) parser.add_argument('--top_bn', action='store_true') parser.add_argument('--dataset', type=str, help='mnist, cifar10, or cifar100', default='mnist') parser.add_argument('--n_epoch', type=int, default=10) parser.add_argument('--seed', type=int, default=1) parser.add_argument('--print_freq', type=int, default=50) parser.add_argument('--num_workers', type=int, default=4, help='how many subprocesses to use for data loading') parser.add_argument('--num_iter_per_epoch', type=int, default=400) parser.add_argument('--epoch_decay_start', type=int, default=80) parser.add_argument('--eps', type=float, default=9.9) parser.add_argument('--batch-size', type=int, default=1000, metavar='N', help='input batch size for training (default: 256)') parser.add_argument('--test-batch-size', type=int, default=4000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--lr', type=float, default=0.005, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument( '--log-interval', type=int, default=100, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--save-model', action='store_true', default=False, help='For Saving the current Model') args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) batch_size = args.batch_size if args.dataset == 'mnist': input_channel = 1 num_classes = 10 args.top_bn = False args.epoch_decay_start = 80 args.n_epoch = 200 train_dataset = MNIST(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) train_size = int(0.9 * len(train_dataset)) valid_size = len(train_dataset) - train_size train_dataset, valid_dataset = random_split(train_dataset, [train_size, valid_size]) test_dataset = MNIST(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 args.top_bn = False args.epoch_decay_start = 80 args.n_epoch = 200 train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar100': input_channel = 3 num_classes = 100 args.top_bn = False args.epoch_decay_start = 100 args.n_epoch = 200 train_dataset = CIFAR100(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR100(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) if args.forget_rate is None: forget_rate = args.noise_rate else: forget_rate = args.forget_rate #noise_or_not = train_dataset.noise_or_not print('loading dataset...') train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) valid_loader = torch.utils.data.DataLoader(dataset=valid_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") cnn1 = Net().to(device) optimizer = torch.optim.SGD(cnn1.parameters(), lr=args.lr, momentum=args.momentum) acc = [] loss = [] loss_pure = [] loss_corrupt = [] out = [] eee = 1 - args.noise_rate criteria = (-1) * (eee * np.log(eee) + (1 - eee) * np.log( (1 - eee) / (args.eps - 1))) last = float("inf") count = 0 for epoch in range(1, 101): l1, out10 = train(args, cnn1, device, train_loader, optimizer, epoch, eps=args.eps, nums=num_classes) cur, out101 = train(args, cnn1, device, valid_loader, optimizer, epoch, eps=args.eps, nums=num_classes) #if cur>last: # count+=1 #else: # last=cur # count=0 #if count >= 4: # break; loss.append(cur) out.append(out10) acc.append(test(args, cnn1, device, test_loader, num_classes)) name = str(args.dataset) + " " + str(args.noise_type) + " " + str( args.noise_rate) + " " + str(args.eps) + " " + str(args.seed) np.save("vl_" + name + " acc.npy", acc) np.save("vl_" + name + " loss.npy", loss)
def main(): if not torch.cuda.is_available(): logging.info('no gpu device available') sys.exit(1) np.random.seed(args.seed) torch.cuda.set_device(args.gpu) cudnn.benchmark = True torch.manual_seed(args.seed) cudnn.enabled = True torch.cuda.manual_seed(args.seed) logging.info('gpu device = %d' % args.gpu) logging.info("args = %s", args) criterion = nn.CrossEntropyLoss() criterion = criterion.cuda() model = Network(args.init_channels, CIFAR_CLASSES, args.layers, criterion, args.greedy, args.l2) model = model.cuda() logging.info("param size = %fMB", utils.count_parameters_in_MB(model)) optimizer = torch.optim.SGD(model.parameters(), args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) train_transform, valid_transform = utils._data_transforms_cifar10(args) # train_data = dset.CIFAR10(root=args.data, train=True, download=True, transform=train_transform) train_data = CIFAR10(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type='symmetric', noise_rate=0.2, noise_ratio=args.train_portion) num_train = len(train_data) indices = list(range(num_train)) split = int(np.floor(args.train_portion * num_train)) train_queue = torch.utils.data.DataLoader( train_data, batch_size=args.batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler(indices[:split]), pin_memory=True, num_workers=2) valid_queue = torch.utils.data.DataLoader( train_data, batch_size=args.batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler( indices[split:num_train]), pin_memory=True, num_workers=2) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, float(args.epochs), eta_min=args.learning_rate_min) architect = Architect(model, args) for epoch in range(args.epochs): scheduler.step() lr = scheduler.get_lr()[0] # lr = scheduler.get_lr() log_value("lr", lr, epoch) logging.info('epoch %d lr %e', epoch, lr) genotype = model.genotype() logging.info('genotype = %s', genotype) # training start_time = time.time() train_acc, train_obj, alphas_time, forward_time, backward_time = train( train_queue, valid_queue, model, architect, criterion, optimizer, lr) end_time = time.time() logging.info("train time %f", end_time - start_time) logging.info("alphas_time %f ", alphas_time) logging.info("forward_time %f", forward_time) logging.info("backward_time %f", backward_time) log_value('train_acc', train_acc, epoch) logging.info('train_acc %f', train_acc) # validation start_time2 = time.time() valid_acc, valid_obj = infer(valid_queue, model, criterion) end_time2 = time.time() logging.info("inference time %f", end_time2 - start_time2) log_value('valid_acc', valid_acc, epoch) logging.info('valid_acc %f', valid_acc) logging.info('alphas_normal = %s', model.alphas_normal) logging.info('alphas_reduce = %s', model.alphas_reduce) utils.save(model, os.path.join(args.save, 'weights.pt'))
def main(): parser = argparse.ArgumentParser( description='PyTorch Gambler\'s Loss Runner') parser.add_argument('--result_dir', type=str, help='directory to save result txt files', default='results') parser.add_argument('--noise_rate', type=float, help='corruption rate, should be less than 1', default=0.5) parser.add_argument('--noise_type', type=str, help='[pairflip, symmetric]', default='symmetric') parser.add_argument('--dataset', type=str, help='mnist, cifar10, or imdb', default='mnist') parser.add_argument('--n_epoch', type=int, default=10) parser.add_argument('--seed', type=int, default=1) parser.add_argument('--num_workers', type=int, default=4, help='how many subprocesses to use for data loading') parser.add_argument('--epoch_decay_start', type=int, default=80) parser.add_argument('--load_model', type=str, default="") parser.add_argument('--model', type=str, default='default') parser.add_argument('--batch_size', type=int, default=128, metavar='N', help='input batch size for training (default: 128)') parser.add_argument( '--log-interval', type=int, default=100, metavar='N', help= 'how many batches to wait before logging training status (default: 100)' ) parser.add_argument('--lr', type=float, default=0.001, metavar='LR', help='learning rate (default: 0.001)') parser.add_argument('--eps', type=float, help='set lambda for lambda type \'gmblers\' only', default=1000.0) parser.add_argument('--lambda_type', type=str, help='[nll, euc, mid, exp, gmblers]', default="euc") parser.add_argument('--start_gamblers', type=int, help='number of epochs before starting gamblers', default=0) # label smoothing args parser.add_argument('--smoothing', type=float, default=1.0, help='smoothing parameter (default: 1)') args = parser.parse_args() args.use_scheduler = False torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) if args.dataset == 'mnist': input_channel = 1 num_classes = 10 train_dataset = MNIST(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = MNIST(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate) print('loading dataset...') train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transform_test, noise_type=args.noise_type, noise_rate=args.noise_rate) print('loading dataset...') train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) if args.dataset == 'cifar100': input_channel = 3 num_classes = 100 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) train_dataset = CIFAR100(root='./data/', download=True, train=True, transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR100(root='./data/', download=True, train=False, transform=transform_test, noise_type=args.noise_type, noise_rate=args.noise_rate) print('loading dataset...') train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=True, shuffle=False) if args.dataset == 'imdb': num_classes = 2 embedding_length = 300 hidden_size = 256 print('loading dataset...') TEXT, vocab_size, word_embeddings, train_loader, valid_iter, test_loader = load_data.load_dataset( rate=args.noise_rate, batch_size=args.batch_size) use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") print("using {}".format(device)) print('building model...') if args.dataset == 'mnist': model = CNN_basic(num_classes=num_classes).to(device) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) if args.dataset == 'cifar10': if args.model == 'small': model = CNN_small(num_classes=num_classes).to(device) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) else: model = resnet.ResNet18(num_classes=num_classes).to(device) change_lr = lambda epoch: 0.1 if epoch >= 50 else 1.0 optimizer = LaProp(filter(lambda p: p.requires_grad, model.parameters()), lr=4e-4) scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=change_lr) args.use_scheduler = True if args.dataset == 'cifar100': if args.model == 'small': model = CNN_small(num_classes=num_classes).to(device) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) else: model = resnet.ResNet18(num_classes=num_classes).to(device) change_lr = lambda epoch: 0.1 if epoch >= 50 else 1.0 optimizer = LaProp(filter(lambda p: p.requires_grad, model.parameters()), lr=4e-4) scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=change_lr) args.use_scheduler = True if args.dataset == 'imdb': model = LSTMClassifier(args.batch_size, num_classes, hidden_size, vocab_size, embedding_length, word_embeddings).to(device) optimizer = LaProp(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr) test_accs = [] train_losses = [] test_losses = [] out = [] name = "{}_{}_{:.2f}_{:.2f}_{}_{}".format(args.dataset, args.noise_type, args.smoothing, args.noise_rate, args.eps, args.seed) if not os.path.exists(args.result_dir): os.system('mkdir -p %s' % args.result_dir) save_file = args.result_dir + "/" + name + ".json" if os.path.exists(save_file): print('case processed') exit() for epoch in range(1, args.n_epoch + 1): for param_group in optimizer.param_groups: print(epoch, param_group['lr']) print(name) train_loss = train(args, model, device, train_loader, optimizer, epoch, num_classes=num_classes, use_gamblers=(epoch >= args.start_gamblers), text=(args.dataset == 'imdb')) train_losses.append(train_loss) test_acc, test_loss = test(args, model, device, test_loader, num_classes, text=(args.dataset == 'imdb')) test_accs.append(test_acc) test_losses.append(test_loss) if (args.use_scheduler): scheduler.step() # torch.save({ # 'model_state_dict': model.state_dict(), # 'optimizer_state_dict': optimizer.state_dict(), # 'loss': loss, # 'test_acc': acc # }, args.result_dir + "/" + name + "_model.npy") save_data = { "train_loss": train_losses, "test_loss": test_losses, "test_acc": test_accs } json.dump(save_data, open(save_file, 'w'))
def main(): use_cuda = torch.cuda.is_available() global best_acc # load dataset if args.dataset == 'cifar10': num_classes = 10 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)), ]) train_dataset = CIFAR10(root='../data/', download=True, train=True, transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR10(root='../data/', download=True, train=False, transform=transform_test, noise_type=args.noise_type, noise_rate=args.noise_rate) if args.dataset == 'cifar100': num_classes = 100 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)) ]) train_dataset = CIFAR100(root='../data/', download=True, train=True, transform=transform_train, noise_type=args.noise_type, noise_rate=args.noise_rate) test_dataset = CIFAR100(root='../data/', download=True, train=False, transform=transform_test, noise_type=args.noise_type, noise_rate=args.noise_rate) testloader = torch.utils.data.DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=4) trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=4) # Model if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isdir( 'checkpoint'), 'Error: no checkpoint directory found!' checkpoint = torch.load('./checkpoint/ckpt.t7.' + args.sess) net = checkpoint['net'] best_acc = checkpoint['acc'] start_epoch = checkpoint['epoch'] + 1 torch.set_rng_state(checkpoint['rng_state']) else: print('==> Building model.. (Default : ResNet32)') start_epoch = 0 if args.model_type == "resnet32": from models.resnet32 import ResNet32 net = ResNet32(num_classes=num_classes) elif args.model_type == "resent18": from models.resnet_imselar import resnet18 net = resnet18(num_classes=num_classes) else: net = ResNet34(num_classes) result_folder = './results/' if not os.path.exists(result_folder): os.makedirs(result_folder) logname = result_folder + net.__class__.__name__ + \ '_' + args.sess + '.csv' if use_cuda: net.cuda() # net = torch.nn.DataParallel(net) # print('Using', torch.cuda.device_count(), 'GPUs.') cudnn.benchmark = True print('Using CUDA..') criterion = TruncatedLoss(trainset_size=len(train_dataset)).cuda() optimizer = optim.SGD(net.params(), lr=args.lr, momentum=0.9, weight_decay=args.decay) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.schedule, gamma=args.gamma) if not os.path.exists(logname): with open(logname, 'w') as logfile: logwriter = csv.writer(logfile, delimiter=',') logwriter.writerow( ['epoch', 'train loss', 'train acc', 'test loss', 'test acc']) for epoch in range(start_epoch, args.epochs): train_loss, train_acc = train(epoch, trainloader, net, criterion, optimizer) test_loss, test_acc = test(epoch, testloader, net, criterion) with open(logname, 'a') as logfile: logwriter = csv.writer(logfile, delimiter=',') logwriter.writerow( [epoch, train_loss, train_acc, test_loss, test_acc]) scheduler.step()
def get_datasets(dataset_name, noise_type=None, noise_rate=None): val_dataset = None if (dataset_name == "MNIST"): train_dataset = MNIST(root='./data/', download=True, train=True, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) test_dataset = MNIST(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) elif (dataset_name == "CIFAR10"): train_dataset = CIFAR10(root='./data/', download=True, train=True, transform=get_transform(), noise_type=noise_type, noise_rate=noise_rate) test_dataset = CIFAR10(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) elif (dataset_name == "CIFAR100"): train_dataset = CIFAR100(root='./data/', download=True, train=True, transform=get_transform(), noise_type=noise_type, noise_rate=noise_rate) test_dataset = CIFAR100(root='./data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=noise_type, noise_rate=noise_rate) elif (dataset_name == "Clothes1M"): img_sz = 224 train_dataset = Clothing(data_dir='../clothing1M/', train=True, val=False, test=False, transform=clothing_transform(img_sz)) val_dataset = Clothing(data_dir='../clothing1M/', train=False, val=True, test=False, transform=clothing_transform(img_sz)) test_dataset = Clothing(data_dir='../clothing1M/', train=False, val=False, test=True, transform=clothing_transform(img_sz)) elif (dataset_name == "Food101N"): img_sz = 224 train_dataset = Food101N(data_dir='../Food-101N_release/', train=True, val=False, test=False, transform=food_transform(img_sz)) val_dataset = Food101N(data_dir='../Food-101N_release/', train=False, val=True, test=False, transform=food_transform(img_sz)) test_dataset = Food101N(data_dir='../Food-101N_release/', train=False, val=False, test=True, transform=food_transform(img_sz)) return train_dataset, val_dataset, test_dataset
noise_rate=args.noise_rate) if args.dataset == 'cifar10': input_channel = 3 num_classes = 10 args.top_bn = False args.epoch_decay_start = 80 args.n_epoch = 250 train_dataset = CIFAR10( root='/home/cgn/data/', download=True, train=True, # transform=transforms.ToTensor(), transform=transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), # transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]), noise_type=args.noise_type, noise_rate=args.noise_rate, fn=args.fn, # path to noisy labels train_mask_dir=args.train_mask_dir, # path to train mask ) test_dataset = CIFAR10( root='/home/cgn/data/', download=True, train=False, transform=transforms.ToTensor(), noise_type=args.noise_type, noise_rate=args.noise_rate,