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)