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,
