def main():
batch_size = 64
test_batch_size = 64
lr = 0.1
momentum = 0.9
epochs = 100
epoch_step = 30
weight_decay = 1e-4
teacher_pretrained_path = "{}/dan_resnet50_amazon_2_webcam.pth".format(save_dir)
student_pretrained = False
device = torch.device("cuda")
webcam = os.path.expanduser("~/datasets/webcam/images")
amazon = os.path.expanduser("~/datasets/amazon/images")
dslr = os.path.expanduser("~/datasets/dslr/images")
train_loader_source = DA_datasets.office_loader(amazon, batch_size, 0)
train_loader_target = DA_datasets.office_loader(webcam, batch_size, 0)
testloader_target = DA_datasets.office_test_loader(webcam, test_batch_size, 0)
logger = VisdomLogger(port=10999)
logger = LoggerForSacred(logger)
teacher_model = DAN_model.DANNet_ResNet(ResNet.resnet50, True)
student_model = DAN_model.DANNet_ResNet(ResNet.resnet34, student_pretrained)
if teacher_pretrained_path != "":
teacher_model.load_state_dict(torch.load(teacher_pretrained_path))
if torch.cuda.device_count() > 1:
teacher_model = torch.nn.DataParallel(teacher_model).to(device)
student_model = torch.nn.DataParallel(student_model).to(device)
distiller_model = od_distiller.Distiller_DAN(teacher_model, student_model)
if torch.cuda.device_count() > 1:
distiller_model = torch.nn.DataParallel(distiller_model).to(device)
if torch.cuda.device_count() > 1:
optimizer = torch.optim.SGD(list(student_model.parameters()) + list(distiller_model.module.Connectors.parameters()),
lr, momentum=momentum, weight_decay=weight_decay, nesterov=True)
else:
optimizer = torch.optim.SGD(list(student_model.parameters()) + list(distiller_model.Connectors.parameters()),
lr, momentum=momentum, weight_decay=weight_decay, nesterov=True)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, epoch_step)
od_kd_without_label(epochs, teacher_model, student_model, distiller_model, optimizer, train_loader_target,
testloader_target, device, logger=logger, scheduler=scheduler)
def main():
cuda = torch.device("cuda")
batch_size = 1
lr = 0.1
momentum = 0.9
frcnn_extra = FasterRCNN_prepare("vgg16", batch_size)
frcnn_extra.forward()
fasterRCNN = vgg16(frcnn_extra.imdb_train.classes,
pretrained=False,
class_agnostic=frcnn_extra.class_agnostic)
fasterRCNN.create_architecture()
params = []
for key, value in dict(fasterRCNN.named_parameters()).items():
if value.requires_grad:
if 'bias' in key:
params += [{'params': [value], 'lr': lr * (cfg.TRAIN.DOUBLE_BIAS + 1), \
'weight_decay': cfg.TRAIN.BIAS_DECAY and cfg.TRAIN.WEIGHT_DECAY or 0}]
else:
params += [{
'params': [value],
'lr': lr,
'weight_decay': cfg.TRAIN.WEIGHT_DECAY
}]
optimizer = torch.optim.SGD(params, momentum=momentum, lr=lr)
fasterRCNN = fasterRCNN.to(cuda)
zero_initializer = functools.partial(torch.nn.init.constant_, val=0)
logger = VisdomLogger(port=10999)
logger = LoggerForSacred(logger)
epochs = 10
target_prune_rate = 0.5
remove_ratio = 0.5
pgp_fasterRCNN(epochs,
target_prune_rate,
remove_ratio,
molchanov_weight_criterion_frcnn,
cuda=cuda,
model=fasterRCNN,
initializer_fn=zero_initializer,
optimizer=optimizer,
logger=logger,
model_adapter=VGGRCNNAdapter(),
frcnn_extra=frcnn_extra,
is_break=True)
def exp_kd_da_grl_alt(init_lr_da, init_lr_kd, momentum, weight_decay, device,
epochs, batch_size, init_beta, end_beta, T, alpha, gamma,
batch_norm, is_cst, resize_digits, is_scheduler_da,
is_scheduler_kd, scheduler_kd_fn, scheduler_kd_steps,
scheduler_kd_gamma, dataset_name, source_dataset_path,
target_dataset_paths, dan_model_func, teacher_net_func,
dan_model_func_student, student_net_func,
student_pretrained, is_debug, _run):
source_dataloader, targets_dataloader, targets_testloader = DA_datasets.get_source_m_target_loader(
dataset_name,
source_dataset_path,
target_dataset_paths,
batch_size,
0,
drop_last=True,
resize=resize_digits)
teacher_models = []
for p in target_dataset_paths:
teacher_models.append(
dan_model_func(teacher_net_func, True,
source_dataloader.dataset.num_classes).to(device))
if student_net_func == Lenet.LeNet or student_net_func == Lenet.MTDA_ITA_classifier:
student_model = dan_model_func_student(
student_net_func,
student_pretrained,
source_dataloader.dataset.num_classes,
input_size=resize_digits).to(device)
else:
student_model = dan_model_func_student(
student_net_func, student_pretrained,
source_dataloader.dataset.num_classes).to(device)
if torch.cuda.device_count() > 1:
for i, tm in enumerate(teacher_models):
teacher_models[i] = nn.DataParallel(tm).to(device)
student_model = nn.DataParallel(student_model).to(device)
logger = LoggerForSacred(None, ex)
growth_rate = torch.zeros(1)
if init_beta != 0.0:
growth_rate = torch.log(torch.FloatTensor(
[end_beta / init_beta])) / torch.FloatTensor([epochs])
optimizer_das = []
for tm in teacher_models:
optimizer_das.append(
torch.optim.SGD(tm.parameters(),
init_lr_da,
momentum=momentum,
weight_decay=weight_decay))
optimizer_kd = torch.optim.SGD(student_model.parameters(),
init_lr_kd,
momentum=momentum,
weight_decay=weight_decay)
scheduler_kd = None
if scheduler_kd_fn is not None:
scheduler_kd = scheduler_kd_fn(optimizer_kd, scheduler_kd_steps,
scheduler_kd_gamma)
if dataset_name != "Digits" and dataset_name != "Digits_no_split":
source_name_1 = get_sub_dataset_name(dataset_name, source_dataset_path)
else:
source_name_1 = source_dataset_path
save_name = "best_{}_{}_and_2{}_kd_da_alt.p".format(
_run._id, source_name_1, "the_rest")
best_student_acc = kd_da_grl_alt_multi_target_cst_fac.grl_multi_target_hinton_alt(
init_lr_da,
init_lr_kd,
device,
epochs,
T,
alpha,
gamma,
growth_rate,
init_beta,
source_dataloader,
targets_dataloader,
targets_testloader,
optimizer_das,
optimizer_kd,
teacher_models,
student_model,
logger=logger,
is_scheduler_da=is_scheduler_da,
is_scheduler_kd=is_scheduler_kd,
scheduler_kd=None,
scheduler_da=None,
is_debug=is_debug,
run=_run,
save_name=save_name,
batch_norm=batch_norm,
is_cst=is_cst)
conf_path = "{}/{}_{}.json".format("all_confs", _run._id, best_student_acc)
with open(conf_path, 'w') as cf:
json.dump(_run.config, cf, default=custom_json_dumper)
#send_email(_run, best_student_acc, os.uname()[1])
return best_student_acc
def main():
a = os.path.expanduser('~/datasets/amazon/images')
w = os.path.expanduser('~/datasets/webcam/images')
d = os.path.expanduser('~/datasets/dslr/images')
Ar = os.path.expanduser('~/datasets/OfficeHome/Art')
Cl = os.path.expanduser('~/datasets/OfficeHome/Clipart')
Pr = os.path.expanduser('~/datasets/OfficeHome/Product')
Rw = os.path.expanduser('~/datasets/OfficeHome/RealWorld')
i = os.path.expanduser('~/datasets/image-clef/i')
p = os.path.expanduser('~/datasets/image-clef/p')
c = os.path.expanduser('~/datasets/image-clef/c')
is_debug = False
batch_size = 16
device = torch.device("cuda")
student_net_func = AlexNet.alexnet
dan_model_func_student = DANN_GRL.DANN_GRL_Alexnet
dataset_name = "Office31"
source_dataset_path = w
target_dataset_paths = [a, d]
resize_digits = 28
is_btda = False
finished_model_path = "best_48_webcam_and_2the_rest_kd_da_alt.p"
source_dataloader, targets_dataloader, targets_testloader = DA_datasets.get_source_m_target_loader(
dataset_name,
source_dataset_path,
target_dataset_paths,
batch_size,
0,
drop_last=True,
resize=resize_digits)
begin_pretrained = True
if student_net_func == LeNet.LeNet:
begin_model = dan_model_func_student(
student_net_func,
begin_pretrained,
source_dataloader.dataset.num_classes,
input_size=resize_digits).to(device)
else:
begin_model = dan_model_func_student(
student_net_func, begin_pretrained,
source_dataloader.dataset.num_classes).to(device)
logger = LoggerForSacred(None, None, True)
if is_btda:
finished_model = BTDA_Alexnet.Alex_Model_Office31()
finished_model.load_state_dict(torch.load(finished_model_path))
finished_model = finished_model.to(device)
finished_model.eval()
else:
if finished_model_path.endswith('p'):
finished_model = torch.load(finished_model_path).to(device)
else:
finished_model = dan_model_func_student(
student_net_func, begin_pretrained,
source_dataloader.dataset.num_classes)
finished_model.load_state_dict(torch.load(finished_model_path))
finished_model = finished_model.to(device)
finished_model.eval()
s_name = get_sub_dataset_name(dataset_name, source_dataset_path)
for i, tloader in enumerate(targets_testloader):
acc = eval(begin_model, device, tloader, False)
p_name = get_sub_dataset_name(dataset_name, target_dataset_paths[i])
print("b_model_from{}_2_{}_acc:{}".format(s_name, p_name, acc))
transform=transform_test)
testloader = torch.utils.data.DataLoader(testset,
batch_size=test_batch_size,
shuffle=False,
num_workers=0)
model_pgp = alexnet().to(cuda)
epochs = 170
prune_rate = 0.05
remove_ratio = 0.5
optimizer_pgp = optim.SGD(model_pgp.parameters(), lr=lr, momentum=momentum)
zero_initializer = functools.partial(torch.nn.init.constant_, val=0)
logger = VisdomLogger(port=10999)
logger = LoggerForSacred(logger)
if not os.path.exists("temp_target.p"):
loss_acc, model_architecture = pgp.pgp(epochs,
prune_rate,
remove_ratio,
testloader,
gng_criterion,
cuda=cuda,
model=model_pgp,
train_loader=trainloader,
train_ratio=1,
prune_once=False,
initializer_fn=zero_initializer,
optimizer=optimizer_pgp,
def main():
batch_size = 32
test_batch_size = 32
webcam = os.path.expanduser("~/datasets/webcam/images")
amazon = os.path.expanduser("~/datasets/amazon/images")
dslr = os.path.expanduser("~/datasets/dslr/images")
is_debug = False
epochs = 400
init_lr_da = 0.001
init_lr_kd = 0.001
momentum = 0.9
weight_decay = 5e-4
device = torch.device("cuda")
T = 20
alpha = 0.3
init_beta = 0.1
end_beta = 0.9
student_pretrained = True
if torch.cuda.device_count() > 1:
teacher_model = nn.DataParallel(
DAN_model.DANNet_ResNet(ResNet.resnet50, True)).to(device)
student_model = nn.DataParallel(
DAN_model.DANNet_ResNet(ResNet.resnet34,
student_pretrained)).to(device)
else:
teacher_model = DAN_model.DANNet_ResNet(ResNet.resnet50,
True).to(device)
student_model = DAN_model.DANNet_ResNet(ResNet.resnet34,
student_pretrained).to(device)
growth_rate = torch.log(torch.FloatTensor(
[end_beta / init_beta])) / torch.FloatTensor([epochs])
optimizer_da = torch.optim.SGD(list(teacher_model.parameters()) +
list(student_model.parameters()),
init_lr_da,
momentum=momentum,
weight_decay=weight_decay)
optimizer_kd = torch.optim.SGD(list(teacher_model.parameters()) +
list(student_model.parameters()),
init_lr_kd,
momentum=momentum,
weight_decay=weight_decay)
source_dataloader = DA_datasets.office_loader(amazon, batch_size, 1)
target_dataloader = DA_datasets.office_loader(webcam, batch_size, 1)
target_testloader = DA_datasets.office_test_loader(webcam, test_batch_size,
1)
logger = LoggerForSacred(None, None, True)
grl_multi_target_hinton_alt(init_lr_da,
device,
epochs,
T,
alpha,
growth_rate,
init_beta,
source_dataloader,
target_dataloader,
target_testloader,
optimizer_da,
optimizer_kd,
teacher_model,
student_model,
logger=logger,
scheduler=None,
is_debug=False)