def run_(
is_inter=False,
debug=False,
keyword="",
net="",
fewshot=False,
augment=False,
shot=50,
unlabeled_shot=50,
autoaugment=False,
data="cifar",
pretrained=False,
dim=512,
seed=0,
cutout=False,
random_erase=False,
):
global netG, netZ, Zs_real, neigh, aug_param, criterion, aug_param_test
manual_seed(seed)
FULL_PATH = keyword
data_dir = '../../data'
cifar_dir_cs = '/cs/dataset/CIFAR/'
if data == "cifar":
classes = 100
aug_param = aug_param_test = get_cifar100_param()
if not fewshot:
train_labeled_dataset = torchvision.datasets.CIFAR100(
root=data_dir, train=True, download=True)
train_unlabeled_dataset = torchvision.datasets.CIFAR100(
root=data_dir, train=False, download=True)
test_data = train_unlabeled_dataset
else:
print("=> Fewshot")
# train_labeled_dataset, train_unlabeled_dataset = get_cifar100_small(cifar_dir_small, shot)
train_labeled_dataset, train_unlabeled_dataset, _, test_data = get_cifar100(
cifar_dir_cs, n_labeled=shot, n_unlabled=unlabeled_shot)
if data == "cub":
classes = 200
aug_param = aug_param_test = get_cub_param()
split_file = None
if fewshot:
samples_per_class = int(shot)
split_file = 'train_test_split_{}.txt'.format(samples_per_class)
train_labeled_dataset = Cub2011(root=f"../../data/{data}",
train=True,
split_file=split_file)
train_unlabeled_dataset = Cub2011(root=f"../../data/{data}",
train=False,
split_file=split_file)
test_data = Cub2011(root=f"../../data/{data}", train=False)
noise_projection = keyword.__contains__("proj")
print(f" noise_projection={noise_projection}")
# netG = _netG(dim, aug_param['rand_crop'], 3, noise_projection)
if data == 'cub':
netG = DCGAN_G(dim, aug_param['image_size'], 3, noise_projection,
noise_projection)
elif data == 'cifar':
netG = _netG(dim, aug_param['image_size'], 3, noise_projection,
noise_projection)
data_to_save = test_data
if keyword != "":
set_seed(seed)
if "tr_" in FULL_PATH:
netZ = _netZ(
dim,
len(train_labeled_dataset) + len(train_unlabeled_dataset) +
len(test_data), classes, None)
# netZ = _netZ(dim, len(train_labeled_dataset) +len(train_unlabeled_dataset), classes, None)
else:
netZ = _netZ(dim, len(train_labeled_dataset), classes, None)
# netZ = _netZ(dim, train_data_size +len(test_data)+ len(train_unlabeled_dataset), classes, None)
print(f"=> Loading model from {FULL_PATH}")
_, netG = load_saved_model(f'{FULL_PATH}/netG_nag', netG)
epoch, netZ = load_saved_model(f'{FULL_PATH}/netZ_nag', netZ)
# _, netG = load_saved_model(f'{PATH}/runs2/nets_{rn}/netG_nag', netG)
# epoch, netZ = load_saved_model(f'{PATH}/runs2/nets_{rn}/netZ_nag', netZ)
netZ = netZ.cuda()
netG = netG.cuda()
print(f"=> Embedding size = {len(netZ.emb.weight)}")
if epoch > 0:
print(f"=> Loaded successfully! epoch:{epoch}")
else:
raise Exception("=> No checkpoint to resume")
Zs_real = netZ.emb.weight.data.detach().cpu().numpy()
train_data_loader = get_loader_with_idx(train_labeled_dataset,
batch_size=100,
augment=augment,
shuffle=True,
offset_idx=0,
offset_label=0,
autoaugment=autoaugment,
**aug_param,
cutout=cutout,
random_erase=random_erase)
netZ.eval()
save_reals = True
if save_reals:
# save_inter_imgs_in_npz(netZ,netG,"fid")
# save_dataset_in_npz(test_data,"fid",name=name)
save_dataset_in_npz(test_data, "fid")
else:
# for i, (idx, inputs, _) in enumerate(train_data_loader):
# inputs = inputs.cuda()
# targets = validate_loader_consistency(netZ, idx)
# normalize = transforms.Normalize(mean=aug_param['mean'], std=aug_param['std'])
# transform_train_np = transforms.Compose([
# # RandomPadandCrop(32),
# # RandomFlip(),
# ToTensor(),
# normalize,
# ])
# Zs_real = netZ.emb.weight.data
# if is_inter:
# # z = Zs_real_numpy[idx]
# z = Zs_real[idx]
# z_knn_idx = np.array([random.sample(netZ.label2idx[x], 1) for x in targets])
# ratios = list(np.linspace(0.1, 0.4, 4))
# rnd_ratio = random.sample(ratios, 1)[0]
# z = z.float().cuda()
# z_knn = Zs_real[z_knn_idx[:, 0]] # * 0.9 + Zs_real[z_knn_idx[:, 1]] * 0.1
# inter_z = slerp_torch(rnd_ratio, z.unsqueeze(0), z_knn.cuda().float().unsqueeze(0))
# # inter_z_slerp = interpolate_points(z, z_knn.float(), 10, print_mode=False, slerp=True)
# # inter_z = interpolate_points(z,z_knn.float(),10,print_mode=False,slerp=False)
# # targets = torch.tensor(targets).long().cuda()
# # targets = targets.repeat(10)
#
# code = get_code(idx)
# generated_img = netG(inter_z.squeeze().cuda(), code)
# try:
# imgs = torch.stack([normalize((img)) for img in generated_img.detach().cpu()])
# except:
# imgs = torch.stack([normalize((img)) for img in generated_img])
# save_inter_imgs(netZ, netG, "fid")
save_inter_imgs_in_npz(netZ, netG, keyword.split("/")[-1])
def run_eval_(is_inter=False,
debug=False,
keyword="",
epochs=200,
d="",
fewshot=False,
augment=False,
shot=50,
unlabeled_shot=50,
autoaugment=False,
loss_method="ce",
data="cifar",
pretrained=False,
dim=512,
seed=0,
cutout=False,
random_erase=False,
lerp=False):
global netG, netZ, Zs_real, neigh, aug_param, criterion, aug_param_test
manual_seed(seed)
title = f"{d}_{keyword}"
if fewshot:
title = title + "_fewshot"
if is_inter:
title = title + "_inter"
dir = "eval"
if not os.path.isdir(dir):
os.mkdir(dir)
logger = Logger(os.path.join(f'{dir}/', f'{title}_log.txt'), title=title)
logger.set_names(
["valid_acc@1", "valid_acc@5", "test_acc@1", "test_acc@5"])
PATH = os.getcwd()
data_dir = '../../data'
cifar_dir_cs = '/cs/dataset/CIFAR/'
if data == "cifar":
classes = 100
lr = 0.1
batch_size = 128
WD = 5e-4
aug_param = aug_param_test = get_cifar100_param()
if not fewshot:
train_labeled_dataset = torchvision.datasets.CIFAR100(
root=data_dir, train=True, download=True)
train_unlabeled_dataset = torchvision.datasets.CIFAR100(
root=data_dir, train=False, download=True)
test_data = train_unlabeled_dataset
else:
print("=> Fewshot")
# train_labeled_dataset, train_unlabeled_dataset = get_cifar100_small(cifar_dir_small, shot)
train_labeled_dataset, train_unlabeled_dataset, _, test_data = get_cifar100(
cifar_dir_cs, n_labeled=shot, n_unlabled=unlabeled_shot)
if data == "cifar-10":
classes = 10
lr = 0.1
batch_size = 128
WD = 5e-4
aug_param = aug_param_test = get_cifar10_param()
if not fewshot:
train_labeled_dataset = torchvision.datasets.CIFAR10(root=data_dir,
train=True,
download=True)
train_unlabeled_dataset = torchvision.datasets.CIFAR10(
root=data_dir, train=False, download=True)
test_data = train_unlabeled_dataset
else:
print("=> Fewshot")
train_labeled_dataset, train_unlabeled_dataset, _, test_data = get_cifar10(
cifar_dir_cs, n_labeled=shot, n_unlabled=unlabeled_shot)
if data == "cub":
classes = 200
batch_size = 16
lr = 0.001
WD = 1e-5
aug_param = aug_param_test = get_cub_param()
split_file = None
if fewshot:
samples_per_class = int(shot)
split_file = 'train_test_split_{}.txt'.format(samples_per_class)
train_labeled_dataset = Cub2011(root=f"../../data/{data}",
train=True,
split_file=split_file)
train_unlabeled_dataset = Cub2011(root=f"../../data/{data}",
train=False,
split_file=split_file)
test_data = Cub2011(root=f"../../data/{data}", train=False)
if data == "stl":
print("STL-10")
classes = 10
WD = 4e-4
batch_size = 32
lr = 2e-3
aug_param = get_train_n_unlabled_stl_param()
aug_param_test = get_test_stl_param()
train_labeled_dataset = torchvision.datasets.STL10(
root=f"../../data/{data}", split='train', download=True)
train_unlabeled_dataset = test_data = torchvision.datasets.STL10(
root=f"../../data/{data}", split='unlabeled', download=True)
train_data_size = len(train_labeled_dataset)
print(f"train_labeled_dataset size:{train_data_size}")
print(f"test_data size:{len(test_data)}")
print(f"transductive data size:{len(train_unlabeled_dataset)}")
# netZ.set_label2idx()
noise_projection = keyword.__contains__("proj")
print(f" noise_projection={noise_projection}")
# netG = _netG(dim, aug_param['rand_crop'], 3, noise_projection)
if data == 'cub':
netG = DCGAN_G(dim, aug_param['image_size'], 3, noise_projection,
noise_projection)
print(
f"G: {dim}, {aug_param['image_size']}, 3, {noise_projection},{noise_projection}"
)
elif data == 'stl':
netG = DCGAN_G_small(dim, aug_param['image_size'], 3, noise_projection,
noise_projection)
elif 'cifar' in data:
netG = _netG(dim, aug_param['image_size'], 3, noise_projection,
noise_projection)
paths = list()
print(f"{PATH}")
dirs = [d for d in glob.glob(PATH)]
print(dirs)
for dir in dirs:
for f in glob.iglob(f"{dir}/runs/{keyword}*log.txt"):
fname = f.split("/")[-1]
tmp = fname.split("_")
name = '_'.join(tmp[:-1])
# if is_model_classifier:
# if "classifier" in name or "cnn" in name:
paths.append(name)
# else:
# paths.append(name)
scores_test_acc1_fewshot = dict()
scores_test_acc5_fewshot = dict()
set_seed(seed)
print(f"=> Total runs: {len(paths)}\n{paths}")
for rn in paths:
classifier = get_classifier(classes, d, pretrained)
if "tr_" in rn:
print("=> Transductive mode")
netZ = _netZ(
dim, train_data_size + len(train_unlabeled_dataset) +
len(test_data), classes, None)
# netZ = _netZ(dim, train_data_size +len(test_data), classes, None)
else:
print("=> No Transductive")
netZ = _netZ(dim, train_data_size, classes, None)
# netZ = _netZ(dim, train_data_size +len(test_data)+ len(train_unlabeled_dataset), classes, None)
try:
print(f"=> Loading model from {rn}")
_, netG = load_saved_model(f'runs/nets_{rn}/netG_nag', netG)
epoch, netZ = load_saved_model(f'runs/nets_{rn}/netZ_nag', netZ)
netZ = netZ.cuda()
netG = netG.cuda()
print(f"=> Embedding size = {len(netZ.emb.weight)}")
print(' => Total params: %.2fM' %
(sum(p.numel() for p in netZ.parameters()) / 1000000.0))
print(' => Total params: %.2fM' %
(sum(p.numel() for p in netG.parameters()) / 1000000.0))
if epoch > 0:
print(f"=> Loaded successfully! epoch:{epoch}")
else:
print("=> No checkpoint to resume")
except Exception as e:
print(f"=> Failed resume job!\n {e}")
Zs_real = netZ.emb.weight.data.detach().cpu().numpy()
optimizer = optim.SGD(classifier.parameters(),
lr,
momentum=0.9,
weight_decay=WD,
nesterov=True)
print("=> Train new classifier")
if loss_method == "cosine":
criterion = nn.CosineEmbeddingLoss().cuda()
else:
criterion = nn.CrossEntropyLoss().cuda()
num_gpus = torch.cuda.device_count()
if num_gpus > 1:
print(f"=> Using {num_gpus} GPUs")
classifier = nn.DataParallel(classifier).cuda()
cudnn.benchmark = True
else:
classifier = maybe_cuda(classifier)
print(' => Total params: %.2fM' %
(sum(p.numel() for p in classifier.parameters()) / 1000000.0))
print(f"=> {d} Training model")
print(f"=> Training Epochs = {str(epochs)}")
print(f"=> Initial Learning Rate = {str(lr)}")
generic_train_classifier(classifier,
optimizer,
train_labeled_dataset,
criterion=criterion,
batch_size=batch_size,
is_inter=is_inter,
num_epochs=epochs,
augment=augment,
fewshot=fewshot,
autoaugment=autoaugment,
test_data=test_data,
loss_method=loss_method,
n_classes=classes,
aug_param=aug_param,
aug_param_test=aug_param_test,
shot=shot,
cutout=cutout,
random_erase=random_erase,
is_lerp=lerp)
print("=> Done training classifier")
valid_acc_1, valid_acc_5 = accuracy(classifier,
train_labeled_dataset,
batch_size=batch_size,
aug_param=aug_param_test)
test_acc_1, test_acc_5 = accuracy(classifier,
test_data,
batch_size=batch_size,
aug_param=aug_param_test)
print('train_acc accuracy@1', valid_acc_1)
print('train_acc accuracy@5', valid_acc_5)
print('test accuracy@1', test_acc_1)
print('test accuracy@5', test_acc_5)
scores_test_acc1_fewshot[seed] = test_acc_1
scores_test_acc5_fewshot[seed] = test_acc_5
logger.append([valid_acc_1, valid_acc_5, test_acc_1, test_acc_5])
w = csv.writer(open(f"eval_{rn}_shot_{shot}_acc1.csv", "w+"))
for key, val in scores_test_acc1_fewshot.items():
w.writerow([rn, key, val])
w = csv.writer(open(f"eval_{rn}_shot_{shot}_acc5.csv", "w+"))
for key, val in scores_test_acc5_fewshot.items():
w.writerow([rn, key, val])
logger.close()
if args.dataset == 'cifar10':
trainset = torchvision.datasets.CIFAR10(
root='./data',
train=True,
download=True,
transform=torchvision.transforms.ToTensor())
elif args.dataset == 'cub':
transform = torchvision.transforms.Compose([
torchvision.transforms.Resize([224, 224],
interpolation=PIL.Image.BICUBIC),
torchvision.transforms.ToTensor()
])
trainset = Cub2011(root='./data', train=True, transform=transform)
trainset.class_to_idx = range(200)
elif args.dataset == 'cars':
transform = torchvision.transforms.Compose([
torchvision.transforms.Resize([224, 224],
interpolation=PIL.Image.BICUBIC),
torchvision.transforms.ToTensor()
])
trainset = torchvision.datasets.ImageFolder(
root='data/stanford-cars/car_data/car_data/train/',
transform=transform)
elif args.dataset == 'dogs':
def run_eval_generic(seed=17, epochs=200, d="", fewshot=False, augment=False, autoaugment=False, data="", shot=0,
unlabeled_shot=None,
resume=False, pretrained=False, batch_size=128, cutout=False, random_erase=False):
global classifier
dir = "baselines_aug"
if not os.path.isdir(dir):
os.mkdir(dir)
name = f"{data}_{d}_baseline_"
if not shot is None:
name = name + f"shot{shot}"
if not autoaugment is None:
name = name + "_aug"
logger = Logger(os.path.join(f"{dir}/", f'{d}_log.txt'), title=name)
logger.set_names(["valid_acc@1", "valid_acc@5", "test_acc@1", "test_acc@5"])
data_dir = '../../data'
cifar_dir_cs = '/cs/dataset/CIFAR/'
aug_param = aug_param_test = None
if data == "cifar":
classes = 100
# batch_size = 128
lr = 0.1
WD = 5e-4
if not fewshot:
train_labeled_dataset = torchvision.datasets.CIFAR100(root=data_dir, train=True, download=True)
train_unlabeled_dataset = torchvision.datasets.CIFAR100(root=data_dir, train=False, download=True)
test_data = train_unlabeled_dataset
else:
print("=> Fewshot")
# train_labeled_dataset, train_unlabeled_dataset = get_cifar100_small(cifar_dir_small, shot)
train_labeled_dataset, train_unlabeled_dataset, _, test_data = get_cifar100(cifar_dir_cs, n_labeled=shot,
n_unlabled=unlabeled_shot)
# test_data = torchvision.datasets.CIFAR100(root=data_dir, train=False, download=True)
print(f"train_labeled_dataset size:{len(train_labeled_dataset)}")
print(f"test_data size:{len(test_data)}")
if data == "cifar-10":
classes = 10
lr = 0.1
WD = 5e-4
aug_param = get_cifar10_param()
if not fewshot:
train_labeled_dataset = torchvision.datasets.CIFAR10(root=data_dir, train=True, download=True)
train_unlabeled_dataset = torchvision.datasets.CIFAR10(root=data_dir, train=False, download=True)
test_data = train_unlabeled_dataset
else:
print("=> Fewshot")
train_labeled_dataset, train_unlabeled_dataset, _, test_data = get_cifar10(cifar_dir_cs, n_labeled=shot,
n_unlabled=unlabeled_shot)
print(f"train_labeled_dataset size:{len(train_labeled_dataset)}")
print(f"test_data size:{len(test_data)}")
if data == "cub":
print("CUB-200")
classes = 200
# batch_size = 16
lr = 0.001
WD = 1e-5
aug_param = aug_param_test = get_cub_param()
split_file = None
if fewshot:
samples_per_class = int(shot)
split_file = 'train_test_split_{}.txt'.format(samples_per_class)
train_labeled_dataset = Cub2011(root=f"../../data/{data}", train=True, split_file=split_file)
test_data = Cub2011(root=f"../../data/{data}", train=False)
print(f"train_labeled_dataset size:{len(train_labeled_dataset)},{train_labeled_dataset.data.shape}")
print(f"test_data size:{len(test_data)},{test_data.data.shape}")
if data == "stl":
print("STL-10")
classes = 10
WD = 4e-4
# batch_size = 128
lr = 2e-3
aug_param = get_train_n_unlabled_stl_param()
aug_param_test = get_test_stl_param()
train_labeled_dataset = torchvision.datasets.STL10(root=f"../../data/{data}", split='train', download=True)
# train_unlabeled_dataset = torchvision.datasets.STL10(root=f"../../data/{data}", split='unlabeled', download=True)
test_data = torchvision.datasets.STL10(root=f"../../data/{data}", split='test', download=True)
print(f"train_labeled_dataset size:{len(train_labeled_dataset)},{train_labeled_dataset.data.shape}")
print(f"test_data size:{len(test_data)},{test_data.data.shape}")
scores_test_acc1_fewshot = dict()
scores_test_acc5_fewshot = dict()
# offset_idx = len(train_labeled_dataset)
print(f"{data} num classes: {classes}")
random.seed(seed)
torch.manual_seed(seed)
np.random.seed(seed)
start_epoch = 0
if resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!'
checkpoint = torch.load(f'./checkpoint/{name}_{seed}_ckpt.t7')
classifier = checkpoint['net']
best_acc = checkpoint['acc']
start_epoch = checkpoint['epoch'] + 1
rng_state = checkpoint['rng_state']
torch.set_rng_state(rng_state)
print(f"=> Model loaded start_epoch{start_epoch}, acc={best_acc}")
else:
classifier = get_classifier(classes, d, pretrained)
criterion = nn.CrossEntropyLoss().cuda()
num_gpus = torch.cuda.device_count()
if num_gpus > 1:
classifier = nn.DataParallel(classifier).cuda()
else:
classifier = classifier.cuda()
optimizer = optim.SGD(classifier.parameters(), lr, momentum=0.9, weight_decay=WD, nesterov=True)
cudnn.benchmark = True
print(' => Total params: %.2fM' % (sum(p.numel() for p in classifier.parameters()) / 1000000.0))
print(f"=> {d} Training model")
print(f"=> Training Epochs = {str(epochs)}")
print(f"=> Initial Learning Rate = {str(lr)}")
# criterion = maybe_cuda(criterion)
# optimizer = optim.Adam(classifier.parameters(), lr=1e-3)
train_linear_classifier(classifier, criterion, optimizer, seed=seed, name=name,
train_labeled_dataset=train_labeled_dataset,
batch_size=batch_size,
num_epochs=epochs,
fewshot=fewshot,
augment=augment, autoaugment=autoaugment, aug_param=aug_param, test_data=test_data,
start_epoch=start_epoch, cutout=cutout, random_erase=random_erase, shot=shot)
acc_1_valid, acc_5_valid = accuracy(classifier, train_labeled_dataset, batch_size=batch_size, aug_param=aug_param)
fewshot_acc_1_test, fewshot_acc_5_test = accuracy(classifier, test_data, batch_size=batch_size,
aug_param=aug_param_test)
print('fewshot_acc_1_valid accuracy@1', acc_1_valid)
print('fewshot_acc_5_valid accuracy@1', acc_5_valid)
print('fewshot_acc_1_test accuracy@1', fewshot_acc_1_test)
print('fewshot_acc_5_test accuracy@5', fewshot_acc_5_test)
logger.append([acc_1_valid, acc_5_valid, fewshot_acc_1_test, fewshot_acc_5_test])
scores_test_acc1_fewshot[seed] = fewshot_acc_1_test
scores_test_acc5_fewshot[seed] = fewshot_acc_5_test
w = csv.writer(open(f"baseline_shot_{shot}_acc1.csv", "w+"))
for key, val in scores_test_acc1_fewshot.items():
w.writerow([key, val])
w = csv.writer(open(f"baseline_shot_{shot}_acc5.csv", "w+"))
for key, val in scores_test_acc5_fewshot.items():
w.writerow([key, val])
logger.close()
def main():
global netG, netZ, Zs_real, aug_param, criterion, aug_param_test
global best_acc
print(args)
if args.data == 'cifar10':
print("cifar10")
aug_param = aug_param_test = get_cifar10_param()
root = '/cs/dataset/CIFAR/'
classes = 10
batch_size = min(args.batch_size, 128)
normalize = transforms.Normalize(mean=aug_param['mean'],
std=aug_param['std'])
image_size = 32
transform_train = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomCrop(image_size, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
# RandomPadandCrop(32),
# RandomFlip(),
# ToTensor(),
normalize,
])
transform_val = transforms.Compose([transforms.ToTensor(), normalize])
train_labeled_set, train_unlabeled_set, val_set, test_set = get_cifar10(
root,
args.n_labeled,
args.n_unlabeled,
transform_train=transform_train,
transform_val=transform_val)
elif args.data == 'cifar':
aug_param = aug_param_test = get_cifar100_param()
root = '/cs/dataset/CIFAR/'
classes = 100
batch_size = min(args.batch_size, 128)
normalize = transforms.Normalize(mean=aug_param['mean'],
std=aug_param['std'])
image_size = 32
transform_train = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomCrop(image_size, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
# RandomPadandCrop(32),
# RandomFlip(),
# ToTensor(),
normalize,
])
transform_val = transforms.Compose([transforms.ToTensor(), normalize])
train_labeled_set, train_unlabeled_set, val_set, test_set = get_cifar100(
root,
args.n_labeled,
args.n_unlabeled,
transform_train=transform_train,
transform_val=transform_val)
elif args.data == 'cub':
split_file = None
samples_per_class = int(args.n_labeled)
split_file = f'train_test_split_{samples_per_class}.txt'
# train_repeats = 30 // samples_per_class
classes = 200
aug_param = get_cub_param()
image_size = aug_param['rand_crop']
print(aug_param)
normalize = transforms.Normalize(mean=aug_param['mean'],
std=aug_param['std'])
transform_train = transforms.Compose([
transforms.RandomResizedCrop(aug_param['rand_crop'],
scale=(0.875, 1.)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.ToTensor(), normalize
])
transform_val = transforms.Compose([
transforms.Resize(aug_param['image_size']),
transforms.CenterCrop(aug_param['rand_crop']),
transforms.ToTensor(), normalize
])
batch_size = min(args.batch_size, 32)
train_labeled_set = Cub2011(root=f"../data/{args.data}",
train=True,
split_file=split_file,
transform=transform_train)
train_unlabeled_set = Cub2011(
root=f"../data/{args.data}",
train=False,
split_file="train_test_split_30.txt",
transform=TransformTwice(transform_train))
test_set = Cub2011(root=f"../data/{args.data}",
train=False,
transform=transform_val)
train_data_size = len(train_labeled_set)
print(f"train_data size:{train_data_size}")
print(f"test_data size:{len(test_set)}")
print(f"train_unlabeled_set data size:{len(train_unlabeled_set)}")
labeled_trainloader_2 = data.DataLoader(train_labeled_set,
batch_size=batch_size,
shuffle=True,
num_workers=0,
drop_last=True)
labeled_trainloader = get_loader_with_idx(train_labeled_set,
**aug_param,
batch_size=batch_size,
augment=None,
drop_last=True)
# unlabeled_trainloader = data.DataLoader(train_unlabeled_set, batch_size=args.batch_size, shuffle=True, num_workers=0, drop_last=True)
offset_ = len(train_labeled_set)
# offset_ += len(test_set) # Uncommenet for transdutive mode
unlabeled_trainloader = get_loader_with_idx(train_unlabeled_set,
**aug_param,
batch_size=batch_size,
augment=None,
drop_last=True,
offset_idx=offset_)
# val_loader = data.DataLoader(val_set, batch_size=args.batch_size, shuffle=False, num_workers=0)
test_loader = data.DataLoader(test_set,
batch_size=args.batch_size,
shuffle=False,
num_workers=0)
if not os.path.isdir(args.out):
mkdir_p(args.out)
# Model
def create_model(ema=False):
# print("==> creating WRN-28-2")
# classifier = WideResNet2(num_classes=100)
print("==> creating resnet50")
classifier = get_classifier(classes, "resnet50", True)
num_gpus = torch.cuda.device_count()
if num_gpus > 1:
print(f"=> Using {num_gpus} GPUs")
classifier = nn.DataParallel(classifier.cuda(),
device_ids=list(
range(num_gpus))).cuda()
cudnn.benchmark = True
else:
classifier = classifier.cuda()
if ema:
for param in classifier.parameters():
param.detach_()
return classifier
classifier = create_model()
ema_classifier = create_model(ema=True)
# Loading pretrained glico_model
keyword = args.keyword
print(' Total params: %.2fM' %
(sum(p.numel() for p in classifier.parameters()) / 1000000.0))
train_criterion = SemiLoss()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(classifier.parameters(), lr=args.lr)
ema_optimizer = WeightEMA(classifier, ema_classifier, alpha=args.ema_decay)
start_epoch = 0
# Resume
title = 'cifar-10'
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isfile(
args.resume), 'Error: no checkpoint directory found!'
args.out = os.path.dirname(args.resume)
checkpoint = torch.load(args.resume)
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
classifier.load_state_dict(checkpoint['state_dict'])
ema_classifier.load_state_dict(checkpoint['ema_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(args.out, 'log.txt'),
title=title,
resume=True)
else:
logger = Logger(os.path.join(args.out, 'log.txt'), title=title)
logger.set_names([
'Train Loss', 'Train Loss X', 'Train Loss U', 'Valid Loss',
'Valid Acc.', 'Test Loss', 'Test Acc.'
])
step = 0
test_accs = []
# Train and val
for epoch in range(start_epoch, args.epochs):
print('\nEpoch: [%d | %d] LR: %f' %
(epoch + 1, args.epochs, state['lr']))
train_loss, train_loss_x, train_loss_u = train(
labeled_trainloader, unlabeled_trainloader, classifier, optimizer,
ema_optimizer, train_criterion, epoch, use_cuda, normalize,
classes)
_, train_acc = validate(labeled_trainloader_2,
ema_classifier,
criterion,
epoch,
use_cuda,
mode='Train Stats')
val_loss, val_acc = validate(test_loader,
ema_classifier,
criterion,
epoch,
use_cuda,
mode='Valid Stats')
test_loss, test_acc = validate(test_loader,
ema_classifier,
criterion,
epoch,
use_cuda,
mode='Test Stats ')
step = args.val_iteration * (epoch + 1)
# append logger file
logger.append([
train_loss, train_loss_x, train_loss_u, val_loss, val_acc,
test_loss, test_acc
])
# save classifier
is_best = val_acc > best_acc
best_acc = max(val_acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': classifier.state_dict(),
'ema_state_dict': ema_classifier.state_dict(),
'acc': val_acc,
'best_acc': best_acc,
'optimizer': optimizer.state_dict(),
}, is_best)
test_accs.append(test_acc)
logger.close()
print('Best acc:')
print(best_acc)
print('Mean acc:')
print(np.mean(test_accs[-20:]))
def run_eval_gan(epochs=200,
d="wideresnet",
fewshot=False,
augment=False,
shot=50,
unlabeled_shot=1,
data="cifar",
pretrained=False,
seed=0):
global aug_param, criterion, aug_param_test, batch_size
manual_seed(seed)
title = f"GAN_{d}"
if fewshot:
title = title + "_fewshot"
dir = "eval"
if not os.path.isdir(dir):
os.mkdir(dir)
data_dir = '../../data'
cifar_dir_cs = '/cs/dataset/CIFAR/'
if data == "cifar":
classes = 100
lr = 0.1
batch_size = 128
WD = 5e-4
aug_param = aug_param_test = get_cifar_param()
if not fewshot:
train_labeled_dataset = torchvision.datasets.CIFAR100(
root=data_dir, train=True, download=True)
train_unlabeled_dataset = torchvision.datasets.CIFAR100(
root=data_dir, train=False, download=True)
test_data = train_unlabeled_dataset
else:
print("=> Fewshot")
# train_labeled_dataset, train_unlabeled_dataset = get_cifar100_small(cifar_dir_small, shot)
train_labeled_dataset, train_unlabeled_dataset, _, test_data = get_cifar100(
cifar_dir_cs, n_labeled=shot, n_unlabled=unlabeled_shot)
if data == "cub":
classes = 200
batch_size = 16
lr = 0.001
WD = 1e-5
aug_param = aug_param_test = get_cub_param()
split_file = None
if fewshot:
samples_per_class = int(shot)
split_file = 'train_test_split_{}.txt'.format(samples_per_class)
train_labeled_dataset = Cub2011(root=f"../../data/{data}",
train=True,
split_file=split_file)
train_unlabeled_dataset = Cub2011(root=f"../../data/{data}",
train=False,
split_file=split_file)
test_data = Cub2011(root=f"../../data/{data}", train=False)
train_data_size = len(train_labeled_dataset)
print(f"train_labeled_dataset size:{train_data_size}")
print(f"test_data size:{len(test_data)}")
print(f"transductive data size:{len(train_unlabeled_dataset)}")
set_seed(seed)
generator = Generator()
discriminator = Discriminator()
classifier = get_classifier(classes, d, pretrained)
epoch = 180
generator, _ = load_model(epoch, generator, discriminator)
generator = generator.cuda()
optimizer = optim.SGD(classifier.parameters(),
lr,
momentum=0.9,
weight_decay=WD,
nesterov=True)
print("=> Train new classifier")
criterion = nn.CrossEntropyLoss().cuda()
num_gpus = torch.cuda.device_count()
if num_gpus > 1:
print(f"=> Using {num_gpus} GPUs")
classifier = nn.DataParallel(classifier).cuda()
# cudnn.benchmark = True
else:
classifier = classifier.cuda()
print(' => Total params: %.2fM' %
(sum(p.numel() for p in classifier.parameters()) / 1000000.0))
print(f"=> {d} Training model")
print(f"=> Training Epochs = {str(epochs)}")
print(f"=> Initial Learning Rate = {str(lr)}")
generic_train_classifier(generator,
classifier,
optimizer,
train_labeled_dataset,
batch_size=batch_size,
num_epochs=epochs,
augment=augment,
fewshot=fewshot,
test_data=test_data,
n_classes=classes,
aug_param=aug_param,
aug_param_test=aug_param_test,
shot=shot)
print("=> Done training classifier")
valid_acc_1, valid_acc_5 = accuracy(classifier,
train_labeled_dataset,
batch_size=batch_size,
aug_param=aug_param_test)
test_acc_1, test_acc_5 = accuracy(classifier,
test_data,
batch_size=batch_size,
aug_param=aug_param_test)
print('train_acc accuracy@1', valid_acc_1)
print('train_acc accuracy@5', valid_acc_5)
print('test accuracy@1', test_acc_1)
print('test accuracy@5', test_acc_5)
train_labeled_dataset = torchvision.datasets.CIFAR100(root=data_dir,
train=True,
download=True)
train_unlabeled_dataset = torchvision.datasets.CIFAR100(root=data_dir,
train=False,
download=True)
if dataset == 'cub':
split_file = None
if args.fewshot:
samples_per_class = int(args.shot)
split_file = 'train_test_split_{}.txt'.format(samples_per_class)
# train_repeats = 30 // samples_per_class
classes = 200
batch_size = min(args.batch_size, 32)
train_labeled_dataset = Cub2011(
root=f"/cs/labs/daphna/idan.azuri/data/cub",
train=True,
split_file=split_file)
train_unlabeled_dataset = Cub2011(
root=f"/cs/labs/daphna/idan.azuri/data/cub",
train=False,
split_file=split_file)
test_dataset = []
if dataset == "stl":
print("STL-10")
classes = 10
batch_size = min(args.batch_size, 32)
train_labeled_dataset = torchvision.datasets.STL10(
root=f"../../data/{dataset}", split='train', download=True)
train_unlabeled_dataset = torchvision.datasets.STL10(
root=f"../../data/{dataset}", split='unlabeled', download=True)
train_unlabeled_dataset = torch.utils.data.Subset(train_unlabeled_dataset,
testset = torchvision.datasets.CIFAR10(
root='../data',
train=False,
download=False,
transform=torchvision.transforms.ToTensor())
elif cfg['dataset'] == 'cub':
transform = torchvision.transforms.Compose([
torchvision.transforms.Resize([224, 224],
interpolation=PIL.Image.BICUBIC),
torchvision.transforms.ToTensor()
])
trainset = Cub2011(root='../data', train=True, transform=transform)
trainset.class_to_idx = range(200)
testset = Cub2011(root='../data', train=False, transform=transform)
elif cfg['dataset'] == 'cars':
transform = torchvision.transforms.Compose([
torchvision.transforms.Resize([224, 224],
interpolation=PIL.Image.BICUBIC),
torchvision.transforms.ToTensor()
])
trainset = torchvision.datasets.ImageFolder(
root='../data/stanford-cars/car_data/car_data/train/',
transform=transform)
testset = torchvision.datasets.ImageFolder(