def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_src = open(args.s_dset_path).readlines() txt_tar = [] for i in range(len(args.t_dset_path)): tmp = open(args.t_dset_path[i]).readlines() txt_tar.extend(tmp) txt_test = txt_tar.copy() if args.trte == 'val': dsize = len(txt_src) tr_size = int(0.9*dsize) print(dsize, tr_size, dsize - tr_size) tr_txt, te_txt = torch.utils.data.random_split(txt_src, [tr_size, dsize - tr_size]) else: tr_txt = txt_src te_txt = txt_src dsets['source_tr'] = ImageList(tr_txt, transform=image_train()) dset_loaders['source_tr'] = DataLoader(dsets['source_tr'], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets['source_te'] = ImageList(te_txt, transform=image_test()) dset_loaders['source_te'] = DataLoader(dsets['source_te'], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets['target'] = ImageList_idx(txt_tar, transform=image_train()) dset_loaders['target'] = DataLoader(dsets['target'], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets['test'] = ImageList(txt_test, transform=image_test()) dset_loaders['test'] = DataLoader(dsets['test'], batch_size=train_bs*2, shuffle=False, num_workers=args.worker, drop_last=False) return dset_loaders
def get_mnist(train): """Get MNIST dataset loader.""" # image pre-processing pre_process = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=params.dataset_mean, std=params.dataset_std) ]) if train: source_list = '/data/mnist/mnist_train.txt' mnist_data_loader = torch.utils.data.DataLoader( ImageList(open(source_list).readlines(), transform=pre_process, mode='L'), batch_size=params.batch_size, shuffle=True, num_workers=0, drop_last=True) else: test_list = '/data/mnist/mnist_test.txt' mnist_data_loader = torch.utils.data.DataLoader( ImageList(open(test_list).readlines(), transform=pre_process, mode='L'), batch_size=params.batch_size, shuffle=True, num_workers=0, drop_last=True) return mnist_data_loader
def data_load(args, txt_src, txt_tgt): train_transform = torchvision.transforms.Compose([ torchvision.transforms.Resize((256, 256)), torchvision.transforms.RandomCrop(224), torchvision.transforms.RandomHorizontalFlip(), torchvision.transforms.ToTensor(), torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) test_transform = torchvision.transforms.Compose([ torchvision.transforms.Resize((256, 256)), torchvision.transforms.CenterCrop(224), torchvision.transforms.ToTensor(), torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) dsets = {} dsets["source"] = ImageList(txt_src, transform=train_transform) dsets["target"] = ImageList_twice(txt_tgt, transform=[train_transform, train_transform]) txt_test = open(args.test_dset_path).readlines() dsets["test"] = ImageList(txt_test, transform=test_transform) dset_loaders = {} dset_loaders["source"] = torch.utils.data.DataLoader(dsets["source"], batch_size=args.batch_size, shuffle=True, num_workers=args.worker, drop_last=True) dset_loaders["target"] = torch.utils.data.DataLoader(dsets["target"], batch_size=args.batch_size, shuffle=True, num_workers=args.worker, drop_last=True) dset_loaders["test"] = torch.utils.data.DataLoader(dsets["test"], batch_size=args.batch_size*3, shuffle=False, num_workers=args.worker, drop_last=False) return dset_loaders
def get_dsets_loader_imagenet(mode='test', data_batch_size=16): prep_dict = {} dsets = {} dset_loaders = {} config = {} prep_dict["train_set1"] = trans_train_resize_imagenet() prep_dict["database"] = trans_train_resize_imagenet() prep_dict["test"] = trans_train_resize_imagenet() config["data"] = {"database": {"list_path": "../data/imagenet/database.txt", "batch_size": data_batch_size}, \ "test": {"list_path": "../data/imagenet/test.txt", "batch_size": data_batch_size}} data_config = config["data"] dsets["test"] = ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"]) dsets["database"] = ImageList(open(data_config["database"]["list_path"]).readlines(), \ transform=prep_dict["database"]) dset_loaders["test"] = util_data.DataLoader(dsets["test"], \ batch_size=data_config["test"]["batch_size"], \ shuffle=False, num_workers=16) dset_loaders["database"] = util_data.DataLoader(dsets["database"], \ batch_size=data_config["database"]["batch_size"], \ shuffle=False, num_workers=16) return dsets, dset_loaders
def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_src = open(args.s_dset_path).readlines() txt_tar = open(args.t_dset_path).readlines() txt_test = open(args.test_dset_path).readlines() if args.trte == "val": dsize = len(txt_src) tr_size = int(0.7*dsize) print(dsize, tr_size, dsize - tr_size) tr_txt, te_txt = torch.utils.data.random_split(txt_src, [tr_size, dsize - tr_size]) else: tr_txt = txt_src te_txt = txt_src dsets["source_tr"] = ImageList(tr_txt, transform=image_train()) dset_loaders["source_tr"] = DataLoader(dsets["source_tr"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["source_te"] = ImageList(te_txt, transform=image_test()) dset_loaders["source_te"] = DataLoader(dsets["source_te"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["target"] = ImageList_idx(txt_tar, transform=image_train()) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["test"] = ImageList(txt_test, transform=image_test()) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=train_bs*3, shuffle=False, num_workers=args.worker, drop_last=False) return dset_loaders
def predict(config): ## set pre-process prep_dict = {} prep_config = config["prep"] if prep_config["test_10crop"]: prep_dict["database"] = prep.image_test_10crop( \ resize_size=prep_config["resize_size"], \ crop_size=prep_config["crop_size"]) prep_dict["test"] = prep.image_test_10crop( \ resize_size=prep_config["resize_size"], \ crop_size=prep_config["crop_size"]) else: prep_dict["database"] = prep.image_test( \ resize_size=prep_config["resize_size"], \ crop_size=prep_config["crop_size"]) prep_dict["test"] = prep.image_test( \ resize_size=prep_config["resize_size"], \ crop_size=prep_config["crop_size"]) ## prepare data dsets = {} dset_loaders = {} data_config = config["data"] if prep_config["test_10crop"]: for i in range(10): dsets["database"+str(i)] = ImageList(open(data_config["database"]["list_path"]).readlines(), \ transform=prep_dict["database"]["val"+str(i)]) dset_loaders["database"+str(i)] = util_data.DataLoader(dsets["database"+str(i)], \ batch_size=data_config["database"]["batch_size"], \ shuffle=False, num_workers=4) dsets["test"+str(i)] = ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"]["val"+str(i)]) dset_loaders["test"+str(i)] = util_data.DataLoader(dsets["test"+str(i)], \ batch_size=data_config["test"]["batch_size"], \ shuffle=False, num_workers=4) else: dsets["database"] = ImageList(open(data_config["database"]["list_path"]).readlines(), \ transform=prep_dict["database"]) dset_loaders["database"] = util_data.DataLoader(dsets["database"], \ batch_size=data_config["database"]["batch_size"], \ shuffle=False, num_workers=4) dsets["test"] = ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"]) dset_loaders["test"] = util_data.DataLoader(dsets["test"], \ batch_size=data_config["test"]["batch_size"], \ shuffle=False, num_workers=4) ## set base network base_network = torch.load(config["snapshot_path"]) use_gpu = torch.cuda.is_available() if use_gpu: base_network = base_network.cuda() database_codes, database_labels = code_predict(dset_loaders, base_network, "database", test_10crop=prep_config["test_10crop"], gpu=use_gpu) test_codes, test_labels = code_predict(dset_loaders, base_network, "test", test_10crop=prep_config["test_10crop"], gpu=use_gpu) return {"database_code":database_codes.numpy(), "database_labels":database_labels.numpy(), \ "test_code":test_codes.numpy(), "test_labels":test_labels.numpy()}
def run(config,path): ## set pre-process prep_dict = {} prep_config = config["prep"] prep_dict["source"] = prep.image_train(**config["prep"]['params']) prep_dict["target"] = prep.image_train(**config["prep"]['params']) if prep_config["test_10crop"]: prep_dict["test"] = prep.image_test_10crop(**config["prep"]['params']) else: prep_dict["test"] = prep.image_test(**config["prep"]['params']) ## prepare data dsets = {} dset_loaders = {} data_config = config["data"] train_bs = 34 test_bs = 34 dsets["source"] = ImageList(open(data_config["source"]["list_path"]).readlines(), \ transform=prep_dict["source"]) dset_loaders["source"] = DataLoader(dsets["source"], batch_size=train_bs, \ shuffle=True, num_workers=0, drop_last=True) dsets["target"] = ImageList(open(data_config["target"]["list_path"]).readlines(), \ transform=prep_dict["target"]) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, \ shuffle=True, num_workers=0, drop_last=True) dset_loaders["test1"] = DataLoader(dsets["target"], batch_size=train_bs, \ shuffle=False, num_workers=1, drop_last=False) if prep_config["test_10crop"]: for i in range(10): dsets["test"] = [ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"][i]) for i in range(10)] dset_loaders["test"] = [DataLoader(dset, batch_size=test_bs, \ shuffle=False, num_workers=0) for dset in dsets['test']] else: dsets["test"] = ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"]) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=test_bs, \ shuffle=False, num_workers=0) n_class = config["network"]["params"]["class_num"] # for p in [499,999,1499,1999,2499,2999]: # PATH = path + '/'+ str(p) + '_model.pth.tar' # # model = load_model(PATH) # base_network = model.cuda() # fun1(dset_loaders, base_network, n_class) PATH = path+'/2999_model.pth.tar' model = load_model(PATH) base_network = model.cuda() # homo_cl = train_homo_cl(dset_loaders, base_network) fun1(dset_loaders, base_network, n_class, dsets)
def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_src = open(args.s_dset_path).readlines() txt_test = open(args.test_dset_path).readlines() if not args.da == 'uda': label_map_s = {} for i in range(len(args.src_classes)): label_map_s[args.src_classes[i]] = i new_src = [] for i in range(len(txt_src)): rec = txt_src[i] reci = rec.strip().split(' ') if int(reci[1]) in args.src_classes: line = reci[0] + ' ' + str(label_map_s[int(reci[1])]) + '\n' new_src.append(line) txt_src = new_src.copy() new_tar = [] for i in range(len(txt_test)): rec = txt_test[i] reci = rec.strip().split(' ') if int(reci[1]) in args.tar_classes: if int(reci[1]) in args.src_classes: line = reci[0] + ' ' + str(label_map_s[int(reci[1])]) + '\n' new_tar.append(line) else: line = reci[0] + ' ' + str(len(label_map_s)) + '\n' new_tar.append(line) txt_test = new_tar.copy() if args.trte == "val": dsize = len(txt_src) tr_size = int(0.9*dsize) # print(dsize, tr_size, dsize - tr_size) tr_txt, te_txt = torch.utils.data.random_split(txt_src, [tr_size, dsize - tr_size]) else: dsize = len(txt_src) tr_size = int(0.9*dsize) _, te_txt = torch.utils.data.random_split(txt_src, [tr_size, dsize - tr_size]) tr_txt = txt_src dsets["source_tr"] = ImageList(tr_txt, transform=image_train()) dset_loaders["source_tr"] = DataLoader(dsets["source_tr"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["source_te"] = ImageList(te_txt, transform=image_test()) dset_loaders["source_te"] = DataLoader(dsets["source_te"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["test"] = ImageList(txt_test, transform=image_test()) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=train_bs*2, shuffle=True, num_workers=args.worker, drop_last=False) return dset_loaders
def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_src = open(args.s_dset_path).readlines() txt_tar = open(args.t_dset_path).readlines() txt_test = open(args.test_dset_path).readlines() count = np.zeros(args.class_num) tr_txt = [] te_txt = [] for i in range(len(txt_src)): line = txt_src[i] reci = line.strip().split(' ') if count[int(reci[1])] < 3: count[int(reci[1])] += 1 te_txt.append(line) else: tr_txt.append(line) dsets["source_tr"] = ImageList(tr_txt, transform=image_train()) dset_loaders["source_tr"] = DataLoader(dsets["source_tr"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["source_te"] = ImageList(te_txt, transform=image_test()) dset_loaders["source_te"] = DataLoader(dsets["source_te"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["target"] = ImageList_idx(txt_tar, transform=image_train()) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["target_te"] = ImageList(txt_tar, transform=image_test()) dset_loaders["target_te"] = DataLoader(dsets["target_te"], batch_size=train_bs, shuffle=False, num_workers=args.worker, drop_last=False) dsets["test"] = ImageList(txt_test, transform=image_test()) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=train_bs * 2, shuffle=False, num_workers=args.worker, drop_last=False) return dset_loaders
def get_train_dsets(config): # prepare dataset for hashnet training import os import torchvision.datasets as dset from data_list import ImageList ## set pre-process prep_dict = {} job_dataset = config["dataset"] prep_dict["train_set1"] = get_trans(job_dataset=job_dataset, mode='test') prep_dict["train_set2"] = get_trans(job_dataset=job_dataset, mode='test') dsets = {} data_config = config["data"] if 'cifar10' in config["dataset"]: # cifar10 for 32*32, cifar10resize for 224*224 if 'cifar100' in job_dataset: root = '../data/cifar100' if not os.path.exists(root): os.mkdir(root) dsets['train_set1'] = dset.CIFAR100(root=root, train=True, transform=prep_dict["train_set1"], download=True) dsets['train_set2'] = dset.CIFAR100(root=root, train=True, transform=prep_dict["train_set2"], download=True) else: root = '../data/cifar10' if not os.path.exists(root): os.mkdir(root) dsets['train_set1'] = dset.CIFAR10(root=root, train=True, transform=prep_dict["train_set1"], download=True) dsets['train_set2'] = dset.CIFAR10(root=root, train=True, transform=prep_dict["train_set2"], download=True) elif config["dataset"] == 'mnist': root = '../data/mnist' if not os.path.exists(root): os.mkdir(root) dsets["train_set1"] = dset.MNIST(root=root, train=True, transform=prep_dict["train_set1"], download=True) dsets["train_set2"] = dset.MNIST(root=root, train=True, transform=prep_dict["train_set2"], download=True) elif config["dataset"] == 'fashion_mnist': root = '../data/fashion_mnist' if not os.path.exists(root): os.mkdir(root) dsets["train_set1"] = dset.FashionMNIST(root=root, train=True, transform=prep_dict["train_set1"], download=True) dsets["train_set2"] = dset.FashionMNIST(root=root, train=True, transform=prep_dict["train_set2"], download=True) else: dsets['train_set1'] = ImageList(open(data_config["train_set1"]["list_path"]).readlines(), \ transform=prep_dict["train_set1"]) dsets['train_set2'] = ImageList(open(data_config["train_set2"]["list_path"]).readlines(), \ transform=prep_dict["train_set2"]) return dsets
def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_tar = open(args.t_dset_path).readlines() txt_test = open(args.test_dset_path).readlines() dsets["target"] = ImageList(txt_tar, transform=image_train(), cfg=args, balance_sample=False) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["test"] = ImageList(txt_test, transform=image_test(), cfg=args, balance_sample=False) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=train_bs * 3, shuffle=False, num_workers=args.worker, drop_last=False) return dset_loaders, txt_tar
def get_svhn(train): # image pre-processing # pre_process = transforms.Compose([transforms.ToTensor(), # transforms.Normalize( # mean=params.dataset_mean, # std=params.dataset_std)]) # # dataset and data loader # svhn_dataset = svhn(root=params.data_root, # train=train, # transform=pre_process, # download=True) # svhn_data_loader = torch.utils.data.DataLoader( # dataset=svhn_dataset, # batch_size=params.batch_size, # shuffle=True) # return svhn_data_loader pre_process = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=params.dataset_mean, std=params.dataset_std) ]) if train: source_list = '/data/svhn/svhn_train.txt' svhn_data_loader = torch.utils.data.DataLoader( ImageList(open(source_list).readlines(), transform=pre_process, mode='L'), batch_size=params.batch_size, shuffle=True, num_workers=0, drop_last=True) else: test_list = '/data/svhn/svhn_test.txt' svhn_data_loader = torch.utils.data.DataLoader( ImageList(open(test_list).readlines(), transform=pre_process, mode='L'), batch_size=params.batch_size, shuffle=True, num_workers=0, drop_last=True) return svhn_data_loader
def get_label_list(target_list, predict_network_path, feature_network_path, class_num, resize_size, crop_size, batch_size, use_gpu, opt): # done with debugging, works fine """ Return the target list with pesudolabel :param target_list: list conatinging all target file path and a wrong label :param predict_network: network to perdict label for target image :param resize_size: :param crop_size: :param batch_size: :return: """ label_list = [] # net_config = predict_network_name # predict_network = net_config["name"](**net_config["params"]) # if use_gpu: # predict_network = predict_network.cuda() netF = models._netF(opt) netC = models._netC(opt, class_num) netF.load_state_dict(torch.load(feature_network_path)) netC.load_state_dict(torch.load(predict_network_path)) if use_gpu: netF.cuda() netC.cuda() mean = np.array([0.44, 0.44, 0.44]) std = np.array([0.19, 0.19, 0.19]) transform_target = transforms.Compose([ transforms.Resize(resize_size), transforms.ToTensor(), transforms.Normalize(mean, std) ]) dsets_tar = ImageList(target_list, transform=transform_target) dset_loaders_tar = util_data.DataLoader(dsets_tar, batch_size=batch_size, shuffle=True, num_workers=4) len_train_target = len(dset_loaders_tar) iter_target = iter(dset_loaders_tar) count = 0 for i in range(len_train_target): input_tar, label_tar = iter_target.next() if use_gpu: input_tar, label_tar = Variable(input_tar).cuda(), Variable( label_tar).cuda() else: input_tar, label_tar = Variable(input_tar), Variable(label_tar) predict_score = netC(netF(input_tar)) # _, predict_score = predict_network(input_tar) _, predict_label = torch.max(predict_score, 1) for num in range(len(predict_label.cpu())): label_list.append(target_list[count][:-2]) label_list[count] = label_list[count] + str( predict_label[num].cpu().numpy()) + "\n" count += 1 return label_list
def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_src = open(args.s_dset_path).readlines() txt_test = open(args.test_dset_path).readlines() if args.trte == "val": dsize = len(txt_src) tr_size = int(0.9 * dsize) tr_txt, te_txt = torch.utils.data.random_split(txt_src, [tr_size, dsize - tr_size]) elif args.trte == "stratified": cls_dict = getClassDict(txt_src) val_sample_cls_dict = getSampleDict(cls_dict, 0.1) te_txt = [] for k in val_sample_cls_dict.keys(): te_txt.extend(val_sample_cls_dict[k]) tr_txt = list(set(txt_src) - set(te_txt)) else: dsize = len(txt_src) tr_size = int(0.8 * dsize) _, te_txt = torch.utils.data.random_split(txt_src, [tr_size, dsize - tr_size]) tr_txt = txt_src # training set if args.source_balanced: # balanced sampler of source train dsets["source_tr"] = ImageList(tr_txt, transform=image_train(), cfg=args, balance_sample=True) else: dsets["source_tr"] = ImageList(tr_txt, transform=image_train(), cfg=args, balance_sample=False) dset_loaders["source_tr"] = DataLoader(dsets["source_tr"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) # validation set dsets["source_te"] = ImageList(te_txt, transform=image_test(), cfg=args, balance_sample=False) dset_loaders["source_te"] = DataLoader(dsets["source_te"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) # test set dsets["test"] = ImageList(txt_test, transform=image_test(), cfg=args, balance_sample=False) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=train_bs * 2, shuffle=True, num_workers=args.worker, drop_last=False) return dset_loaders
def run(config, model): ## set pre-process prep_dict = {} prep_config = config["prep"] prep_dict["source"] = prep.image_train(**config["prep"]['params']) prep_dict["target"] = prep.image_train(**config["prep"]['params']) if prep_config["test_10crop"]: prep_dict["test"] = prep.image_test_10crop(**config["prep"]['params']) else: prep_dict["test"] = prep.image_test(**config["prep"]['params']) ## prepare data dsets = {} dset_loaders = {} data_config = config["data"] train_bs = 34 test_bs = 34 dsets["source"] = ImageList(open(data_config["source"]["list_path"]).readlines(), \ transform=prep_dict["source"]) dset_loaders["source"] = DataLoader(dsets["source"], batch_size=train_bs, \ shuffle=True, num_workers=0, drop_last=False) dsets["target"] = ImageList(open(data_config["target"]["list_path"]).readlines(), \ transform=prep_dict["target"]) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, \ shuffle=True, num_workers=0, drop_last=False) if prep_config["test_10crop"]: for i in range(10): dsets["test"] = [ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"][i]) for i in range(10)] dset_loaders["test"] = [DataLoader(dset, batch_size=test_bs, \ shuffle=False, num_workers=0) for dset in dsets['test']] else: dsets["test"] = ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"]) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=test_bs, \ shuffle=False, num_workers=0) n_class = config["network"]["params"]["class_num"] model.train(False) temp_acc = image_classification_test(dset_loaders, model, n_class=n_class) log_str = "precision: {:.5f}".format(temp_acc) print(log_str)
def get_label_list(args, target_list, feature_network_path, predict_network_path, num_layer, resize_size, crop_size, batch_size, use_gpu): """ Return the target list with pesudolabel :param target_list: list conatinging all target file path and a wrong label :param predict_network: network to perdict label for target image :param resize_size: :param crop_size: :param batch_size: :return: """ option = 'resnet' + args.resnet G = ResBase(option) F1 = ResClassifier(num_layer=num_layer) G.load_state_dict(torch.load(feature_network_path)) F1.load_state_dict(torch.load(predict_network_path)) if use_gpu: G.cuda() F1.cuda() G.eval() F1.eval() label_list = [] dsets_tar = ImageList(target_list, transform=prep.image_train(resize_size=resize_size, crop_size=crop_size)) dset_loaders_tar = util_data.DataLoader(dsets_tar, batch_size=batch_size, shuffle=False, num_workers=4) len_train_target = len(dset_loaders_tar) iter_target = iter(dset_loaders_tar) count = 0 for i in range(len_train_target): input_tar, label_tar = iter_target.next() if use_gpu: input_tar, label_tar = Variable(input_tar).cuda(), Variable( label_tar).cuda() else: input_tar, label_tar = Variable(input_tar), Variable(label_tar) tar_feature = G(input_tar) predict_score = F1(tar_feature) _, pre_lab = torch.max(predict_score, 1) predict_label = pre_lab.detach() for num in range(len(predict_label.cpu())): if target_list[count][-3] == ' ': ind = -2 else: ind = -3 label_list.append(target_list[count][:ind]) label_list[count] = label_list[count] + str( predict_label[num].cpu().numpy()) + "\n" count += 1 return label_list
def get_dsets(job_dataset): # get the dsets for extract code # or can be used to softmax training with the dsets['train'] import torchvision.datasets as dset dsets = {} trans_test = get_trans(job_dataset=job_dataset, mode='test') trans_train = get_trans(job_dataset=job_dataset, mode='train') if job_dataset == 'mnist': root = '../data/mnist' dsets['test'] = dset.MNIST(root=root, train=False, transform=trans_test, download=True) dsets['database'] = dset.MNIST(root=root, train=True, transform=trans_test, download=True) dsets['train'] = dset.MNIST(root=root, train=True, transform=trans_train, download=True) if 'cifar10' in job_dataset: if 'cifar100' in job_dataset: root = '../data/cifar100' dsets['test'] = dset.CIFAR100(root=root, train=False, transform=trans_test, download=True) dsets['database'] = dset.CIFAR100(root=root, train=True, transform=trans_test, download=True) dsets['train'] = dset.CIFAR100(root=root, train=True, transform=trans_train, download=True) else: root = '../data/cifar10' dsets['test'] = dset.CIFAR10(root=root, train=False, transform=trans_test, download=True) dsets['database'] = dset.CIFAR10(root=root, train=True, transform=trans_test, download=True) dsets['train'] = dset.CIFAR10(root=root, train=True, transform=trans_train, download=True) if job_dataset == 'fashion_mnist': root = '../data/fashion_mnist' dsets['test'] = dset.FashionMNIST(root=root, train=False, transform=trans_test, download=True) dsets['database'] = dset.FashionMNIST(root=root, train=True, transform=trans_test, download=True) dsets['train'] = dset.FashionMNIST(root=root, train=True, transform=trans_train, download=True) if 'imagenet' in job_dataset or 'nus_wide' in job_dataset or 'places365' in job_dataset: # load data file from path from publicVariables import data_list_path dsets["test"] = ImageList(open(data_list_path[job_dataset]["test"]).readlines(), \ transform=trans_test) dsets["database"] = ImageList(open(data_list_path[job_dataset]["database"]).readlines(), \ transform=trans_test) dsets["train"] = ImageList(open(data_list_path[job_dataset]["database"]).readlines(), \ transform=trans_train) return dsets
def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_tar = open(args.t_dset_path).readlines() txt_test = open(args.test_dset_path).readlines() if not args.da == 'uda': label_map_s = {} for i in range(len(args.src_classes)): label_map_s[args.src_classes[i]] = i new_tar = [] for i in range(len(txt_tar)): rec = txt_tar[i] reci = rec.strip().split(' ') if int(reci[1]) in args.tar_classes: if int(reci[1]) in args.src_classes: line = reci[0] + ' ' + str(label_map_s[int( reci[1])]) + '\n' new_tar.append(line) else: line = reci[0] + ' ' + str(len(label_map_s)) + '\n' new_tar.append(line) txt_tar = new_tar.copy() txt_test = txt_tar.copy() dsets["target"] = ImageList(txt_tar, transform=image_test()) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["test"] = ImageList(txt_test, transform=image_test()) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=train_bs * 3, shuffle=False, num_workers=args.worker, drop_last=False) return dset_loaders
def save(config, model, save_name): ## set pre-process prep_dict = {} prep_config = config["prep"] prep_dict["source"] = prep.image_train(**config["prep"]['params']) prep_dict["target"] = prep.image_train(**config["prep"]['params']) if prep_config["test_10crop"]: prep_dict["test"] = prep.image_test_10crop(**config["prep"]['params']) else: prep_dict["test"] = prep.image_test(**config["prep"]['params']) ## prepare data dsets = {} dset_loaders = {} data_config = config["data"] train_bs = 34 test_bs = 34 dsets["source"] = ImageList(open(data_config["source"]["list_path"]).readlines(), \ transform=prep_dict["source"]) dset_loaders["source"] = DataLoader(dsets["source"], batch_size=train_bs, \ shuffle=True, num_workers=0, drop_last=False) dsets["target"] = ImageList(open(data_config["target"]["list_path"]).readlines(), \ transform=prep_dict["target"]) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, \ shuffle=True, num_workers=0, drop_last=False) if prep_config["test_10crop"]: for i in range(10): dsets["test"] = [ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"][i]) for i in range(10)] dset_loaders["test"] = [DataLoader(dset, batch_size=test_bs, \ shuffle=False, num_workers=0) for dset in dsets['test']] else: dsets["test"] = ImageList(open(data_config["test"]["list_path"]).readlines(), \ transform=prep_dict["test"]) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=test_bs, \ shuffle=False, num_workers=0) n_class = config["network"]["params"]["class_num"] model.train(False) save_feature(dset_loaders, model, './snapshot/model/', save_name)
def load_ori_dsets(job_dataset): # Load the original dsets that have no transforms dsets = {} if job_dataset == 'mnist': import torchvision.datasets as dset root = '../../../../data/mnist' dsets["test"] = dset.MNIST(root=root, train=False, download=True) dsets["database"] = dset.MNIST(root=root, train=True, download=True) dsets["train"] = dsets["database"] if job_dataset == 'cifar10': import torchvision.datasets as dset root = '../../../../data/cifar10/pytorch_path' dsets['test'] = dset.CIFAR10(root=root, train=False, download=True) dsets['database'] = dset.CIFAR10(root=root, train=True, download=True) dsets["train"] = dsets["database"] if job_dataset == 'fashion_mnist': import torchvision.datasets as dset root = '../../../../data/mnist' dsets["test"] = dset.FashionMNIST(root=root, train=False, download=True) dsets["database"] = dset.FashionMNIST(root=root, train=True, download=True) dsets["train"] = dsets["database"] if 'imagenet' in job_dataset: dsets["train"] = ImageList( open('../data/imagenet/train.txt').readlines()) dsets["test"] = ImageList( open('../data/imagenet/test.txt').readlines()) dsets["database"] = ImageList( open('../data/imagenet/database.txt').readlines()) if job_dataset == 'places365': import torchvision.datasets as dset dsets["database"] = ImageList( open("../data/places365_standard/database.txt").readlines()) dsets['test'] = ImageList( open("../data/places365_standard/val.txt").readlines()) return dsets
def get_dataloader(image_dir): img_size = 299 mean = [0.5] * 3 std = [0.5] * 3 normalize_transform = Normalize(mean, std) infer = open(os.path.join(image_dir, "infer_dir.txt")).readlines() inferset = ImageList(infer, normalize_transform, img_size) dataloader = DataLoader(inferset, batch_size=1) return dataloader
def get_dataloader(args): image_dir = args.image_dir train = open(os.path.join(image_dir, "train_dir.txt")).readlines() val = open(os.path.join(image_dir, "val_dir.txt")).readlines() test = open(os.path.join(image_dir, "test_dir.txt")).readlines() img_size = 299 mean = [0.5] * 3 std = [0.5] * 3 normalize_transform = Normalize(mean, std) trainset = ImageList(train, normalize_transform, img_size) valset = ImageList(val, normalize_transform, img_size) testset = ImageList(test, normalize_transform, img_size) dataloader = dict() for split in ["train", "val", "test"]: dataloader[split] = DataLoader(eval(split + "set"), batch_size=1, shuffle=True) return dataloader
def perform_operation(file_path): torch.no_grad() e_net.eval() a_net.eval() s_net.eval() fusion.eval() imDataset = ImageList(crop_size=args.IM_SIZE, path=file_path, img_path=args.img_path, NUM_CLASS=args.NUM_CLASS, phase='test', transform=prep.image_test(crop_size=args.IM_SIZE), target_transform=prep.land_transform(img_size=args.IM_SIZE)) imDataLoader = torch.utils.data.DataLoader(imDataset, batch_size=args.Test_BATCH, num_workers=0) pbar = tqdm(total=len(imDataLoader)) for batch_Idx, data in enumerate(imDataLoader): datablob, datalb, pos_para = data datablob = torch.autograd.Variable(datablob).cuda() y_lb = torch.autograd.Variable(datalb).view(datalb.size(0), -1).cuda() pos_para = torch.autograd.Variable(pos_para).cuda() pred_global = e_net(datablob) feat_data = e_net.predict_BN(datablob) pred_att_map, pred_conf = a_net(feat_data) slice_feat_data = prep_model_input(pred_att_map, pos_para) pred_local = s_net(slice_feat_data) cls_pred = fusion(pred_global + pred_local) cls_pred = cls_pred.data.cpu().float() y_lb = y_lb.data.cpu().float() if batch_Idx == 0: all_output = cls_pred all_label = y_lb else: all_output = torch.cat((all_output, cls_pred), 0) all_label = torch.cat((all_label, y_lb), 0) pbar.update() pbar.close() all_acc_scr = get_acc(all_output, all_label) all_f1_score = get_f1(all_output, all_label) print('f1 score: ', str(all_f1_score.numpy().tolist())) print('average f1 score: ', str(all_f1_score.mean().numpy().tolist())) print('acc score: ', str(all_acc_scr.numpy().tolist())) print('average acc score: ', str(all_acc_scr.mean().numpy().tolist()))
def data_load(args): ## prepare data dsets = {} dset_loaders = {} train_bs = args.batch_size txt_src = open(args.s_dset_path).readlines() txt_tar = [] for i in range(len(args.t_dset_path)): tmp = open(args.t_dset_path[i]).readlines() txt_tar.extend(tmp) txt_test = txt_tar.copy() dsets["target"] = ImageList_idx(txt_tar, transform=image_train()) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, shuffle=True, num_workers=args.worker, drop_last=False) dsets["test"] = ImageList(txt_test, transform=image_test()) dset_loaders["test"] = DataLoader(dsets["test"], batch_size=train_bs*2, shuffle=False, num_workers=args.worker, drop_last=False) return dset_loaders
def get_label_list(target_list, predict_network_name, resize_size, crop_size, batch_size, use_gpu): # done with debugging, works fine """ Return the target list with pesudolabel :param target_list: list conatinging all target file path and a wrong label :param predict_network: network to perdict label for target image :param resize_size: :param crop_size: :param batch_size: :return: """ label_list = [] net_config = predict_network_name predict_network = net_config["name"](**net_config["params"]) if use_gpu: predict_network = predict_network.cuda() dsets_tar = ImageList(target_list, transform=prep.image_train(resize_size=resize_size, crop_size=crop_size)) dset_loaders_tar = util_data.DataLoader(dsets_tar, batch_size=batch_size, shuffle=True, num_workers=4) len_train_target = len(dset_loaders_tar) iter_target = iter(dset_loaders_tar) count = 0 for i in range(len_train_target): input_tar, label_tar = iter_target.next() if use_gpu: input_tar, label_tar = Variable(input_tar).cuda(), Variable( label_tar).cuda() else: input_tar, label_tar = Variable(input_tar), Variable(label_tar) _, predict_score = predict_network(input_tar) _, predict_label = torch.max(predict_score, 1) for num in range(len(predict_label.cpu())): label_list.append(target_list[count][:-2]) label_list[count] = label_list[count] + str( predict_label[num].cpu().numpy()) + "\n" count += 1 return label_list
def get_label_list(target_list, predict_network, resize_size, crop_size, batch_size, use_gpu): """ Return the target list with pesudolabel :param target_list: list conatinging all target file path and a wrong label :param predict_network: network to perdict label for target image :param resize_size: :param crop_size: :param batch_size: :return: """ label_list = [] dsets_tar = ImageList(target_list, transform=prep.image_train(resize_size=resize_size, crop_size=crop_size)) dset_loaders_tar = util_data.DataLoader(dsets_tar, batch_size=batch_size, shuffle=False, num_workers=4) len_train_target = len(dset_loaders_tar) iter_target = iter(dset_loaders_tar) count = 0 for i in range(len_train_target): input_tar, label_tar = iter_target.next() if use_gpu: input_tar, label_tar = Variable(input_tar).cuda(), Variable( label_tar).cuda() else: input_tar, label_tar = Variable(input_tar), Variable(label_tar) _, predict_score = predict_network(input_tar) _, predict_label = torch.max(predict_score, 1) for num in range(len(predict_label.cpu())): if target_list[count][-3] == ' ': ind = -2 else: ind = -3 label_list.append(target_list[count][:ind]) label_list[count] = label_list[count] + str( predict_label[num].cpu().numpy()) + "\n" print(label_list[count]) count += 1 return label_list
def get_label_list(target_list, predict_network, resize_size, crop_size, batch_size): """ Return the target list with pesudolabel :param target_list: list conatinging all target file path and a wrong label :param predict_network: network to perdict label for target image :param resize_size: :param crop_size: :param batch_size: :return: """ label_list = [] dsets_tar = ImageList(target_list, transform=prep.image_train(resize_size=resize_size, crop_size=crop_size)) dset_loaders_tar = util_data.DataLoader(dsets_tar, batch_size=batch_size, shuffle=True, num_workers=4) len_train_target = len(dset_loaders_tar) iter_target = iter(dset_loaders_tar) for i in range(len_train_target): input_tar, label_tar = iter_target.next() predict_score = predict_network(input_tar)[1] label = np.argsort(-predict_score)[0] label_list.append(target_list[i][:-2]) label_list[i] = label_list[i] + str(label) + "\n" return label_list
def main(config): ## set loss criterion use_gpu = torch.cuda.is_available() au_weight = torch.from_numpy(np.loadtxt(config.train_path_prefix + '_weight.txt')) if use_gpu: au_weight = au_weight.float().cuda() else: au_weight = au_weight.float() ## prepare data dsets = {} dset_loaders = {} dsets['train'] = ImageList(crop_size=config.crop_size, path=config.train_path_prefix, transform=prep.image_train(crop_size=config.crop_size), target_transform=prep.land_transform(img_size=config.crop_size, flip_reflect=np.loadtxt( config.flip_reflect))) dset_loaders['train'] = util_data.DataLoader(dsets['train'], batch_size=config.train_batch_size, shuffle=True, num_workers=config.num_workers) dsets['test'] = ImageList(crop_size=config.crop_size, path=config.test_path_prefix, phase='test', transform=prep.image_test(crop_size=config.crop_size), target_transform=prep.land_transform(img_size=config.crop_size, flip_reflect=np.loadtxt( config.flip_reflect)) ) dset_loaders['test'] = util_data.DataLoader(dsets['test'], batch_size=config.eval_batch_size, shuffle=False, num_workers=config.num_workers) ## set network modules region_learning = network.network_dict[config.region_learning](input_dim=3, unit_dim = config.unit_dim) align_net = network.network_dict[config.align_net](crop_size=config.crop_size, map_size=config.map_size, au_num=config.au_num, land_num=config.land_num, input_dim=config.unit_dim*8, fill_coeff=config.fill_coeff) local_attention_refine = network.network_dict[config.local_attention_refine](au_num=config.au_num, unit_dim=config.unit_dim) local_au_net = network.network_dict[config.local_au_net](au_num=config.au_num, input_dim=config.unit_dim*8, unit_dim=config.unit_dim) global_au_feat = network.network_dict[config.global_au_feat](input_dim=config.unit_dim*8, unit_dim=config.unit_dim) au_net = network.network_dict[config.au_net](au_num=config.au_num, input_dim = 12000, unit_dim = config.unit_dim) if config.start_epoch > 0: print('resuming model from epoch %d' %(config.start_epoch)) region_learning.load_state_dict(torch.load( config.write_path_prefix + config.run_name + '/region_learning_' + str(config.start_epoch) + '.pth')) align_net.load_state_dict(torch.load( config.write_path_prefix + config.run_name + '/align_net_' + str(config.start_epoch) + '.pth')) local_attention_refine.load_state_dict(torch.load( config.write_path_prefix + config.run_name + '/local_attention_refine_' + str(config.start_epoch) + '.pth')) local_au_net.load_state_dict(torch.load( config.write_path_prefix + config.run_name + '/local_au_net_' + str(config.start_epoch) + '.pth')) global_au_feat.load_state_dict(torch.load( config.write_path_prefix + config.run_name + '/global_au_feat_' + str(config.start_epoch) + '.pth')) au_net.load_state_dict(torch.load( config.write_path_prefix + config.run_name + '/au_net_' + str(config.start_epoch) + '.pth')) if use_gpu: region_learning = region_learning.cuda() align_net = align_net.cuda() local_attention_refine = local_attention_refine.cuda() local_au_net = local_au_net.cuda() global_au_feat = global_au_feat.cuda() au_net = au_net.cuda() print(region_learning) print(align_net) print(local_attention_refine) print(local_au_net) print(global_au_feat) print(au_net) ## collect parameters region_learning_parameter_list = [{'params': filter(lambda p: p.requires_grad, region_learning.parameters()), 'lr': 1}] align_net_parameter_list = [ {'params': filter(lambda p: p.requires_grad, align_net.parameters()), 'lr': 1}] local_attention_refine_parameter_list = [ {'params': filter(lambda p: p.requires_grad, local_attention_refine.parameters()), 'lr': 1}] local_au_net_parameter_list = [ {'params': filter(lambda p: p.requires_grad, local_au_net.parameters()), 'lr': 1}] global_au_feat_parameter_list = [ {'params': filter(lambda p: p.requires_grad, global_au_feat.parameters()), 'lr': 1}] au_net_parameter_list = [ {'params': filter(lambda p: p.requires_grad, au_net.parameters()), 'lr': 1}] ## set optimizer optimizer = optim_dict[config.optimizer_type](itertools.chain(region_learning_parameter_list, align_net_parameter_list, local_attention_refine_parameter_list, local_au_net_parameter_list, global_au_feat_parameter_list, au_net_parameter_list), lr=1.0, momentum=config.momentum, weight_decay=config.weight_decay, nesterov=config.use_nesterov) param_lr = [] for param_group in optimizer.param_groups: param_lr.append(param_group['lr']) lr_scheduler = lr_schedule.schedule_dict[config.lr_type] if not os.path.exists(config.write_path_prefix + config.run_name): os.makedirs(config.write_path_prefix + config.run_name) if not os.path.exists(config.write_res_prefix + config.run_name): os.makedirs(config.write_res_prefix + config.run_name) res_file = open( config.write_res_prefix + config.run_name + '/AU_pred_' + str(config.start_epoch) + '.txt', 'w') ## train count = 0 for epoch in range(config.start_epoch, config.n_epochs + 1): if epoch > config.start_epoch: print('taking snapshot ...') torch.save(region_learning.state_dict(), config.write_path_prefix + config.run_name + '/region_learning_' + str(epoch) + '.pth') torch.save(align_net.state_dict(), config.write_path_prefix + config.run_name + '/align_net_' + str(epoch) + '.pth') torch.save(local_attention_refine.state_dict(), config.write_path_prefix + config.run_name + '/local_attention_refine_' + str(epoch) + '.pth') torch.save(local_au_net.state_dict(), config.write_path_prefix + config.run_name + '/local_au_net_' + str(epoch) + '.pth') torch.save(global_au_feat.state_dict(), config.write_path_prefix + config.run_name + '/global_au_feat_' + str(epoch) + '.pth') torch.save(au_net.state_dict(), config.write_path_prefix + config.run_name + '/au_net_' + str(epoch) + '.pth') # eval in the train if epoch > config.start_epoch: print('testing ...') region_learning.train(False) align_net.train(False) local_attention_refine.train(False) local_au_net.train(False) global_au_feat.train(False) au_net.train(False) local_f1score_arr, local_acc_arr, f1score_arr, acc_arr, mean_error, failure_rate = AU_detection_evalv2( dset_loaders['test'], region_learning, align_net, local_attention_refine, local_au_net, global_au_feat, au_net, use_gpu=use_gpu) print('epoch =%d, local f1 score mean=%f, local accuracy mean=%f, ' 'f1 score mean=%f, accuracy mean=%f, mean error=%f, failure rate=%f' % (epoch, local_f1score_arr.mean(), local_acc_arr.mean(), f1score_arr.mean(), acc_arr.mean(), mean_error, failure_rate)) print('%d\t%f\t%f\t%f\t%f\t%f\t%f' % (epoch, local_f1score_arr.mean(), local_acc_arr.mean(), f1score_arr.mean(), acc_arr.mean(), mean_error, failure_rate), file=res_file) region_learning.train(True) align_net.train(True) local_attention_refine.train(True) local_au_net.train(True) global_au_feat.train(True) au_net.train(True) if epoch >= config.n_epochs: break for i, batch in enumerate(dset_loaders['train']): if i % config.display == 0 and count > 0: print('[epoch = %d][iter = %d][total_loss = %f][loss_au_softmax = %f][loss_au_dice = %f]' '[loss_local_au_softmax = %f][loss_local_au_dice = %f]' '[loss_land = %f]' % (epoch, i, total_loss.data.cpu().numpy(), loss_au_softmax.data.cpu().numpy(), loss_au_dice.data.cpu().numpy(), loss_local_au_softmax.data.cpu().numpy(), loss_local_au_dice.data.cpu().numpy(), loss_land.data.cpu().numpy())) print('learning rate = %f %f %f %f %f %f' % (optimizer.param_groups[0]['lr'], optimizer.param_groups[1]['lr'], optimizer.param_groups[2]['lr'], optimizer.param_groups[3]['lr'], optimizer.param_groups[4]['lr'], optimizer.param_groups[5]['lr'])) print('the number of training iterations is %d' % (count)) input, land, biocular, au = batch if use_gpu: input, land, biocular, au = input.cuda(), land.float().cuda(), \ biocular.float().cuda(), au.long().cuda() else: au = au.long() optimizer = lr_scheduler(param_lr, optimizer, epoch, config.gamma, config.stepsize, config.init_lr) optimizer.zero_grad() region_feat = region_learning(input) align_feat, align_output, aus_map = align_net(region_feat) if use_gpu: aus_map = aus_map.cuda() output_aus_map = local_attention_refine(aus_map.detach()) local_au_out_feat, local_aus_output = local_au_net(region_feat, output_aus_map) global_au_out_feat = global_au_feat(region_feat) concat_au_feat = torch.cat((align_feat, global_au_out_feat, local_au_out_feat.detach()), 1) aus_output = au_net(concat_au_feat) loss_au_softmax = au_softmax_loss(aus_output, au, weight=au_weight) loss_au_dice = au_dice_loss(aus_output, au, weight=au_weight) loss_au = loss_au_softmax + loss_au_dice loss_local_au_softmax = au_softmax_loss(local_aus_output, au, weight=au_weight) loss_local_au_dice = au_dice_loss(local_aus_output, au, weight=au_weight) loss_local_au = loss_local_au_softmax + loss_local_au_dice loss_land = landmark_loss(align_output, land, biocular) total_loss = config.lambda_au * (loss_au + loss_local_au) + \ config.lambda_land * loss_land total_loss.backward() optimizer.step() count = count + 1 res_file.close()
def train(config): ## set pre-process prep_dict = {} prep_config = config["prep"] prep_dict["source"] = prep.image_train(**config["prep"]['params']) prep_dict["target"] = prep.image_train(**config["prep"]['params']) if prep_config["test_10crop"]: prep_dict["test"] = prep.image_test_10crop(**config["prep"]['params']) else: prep_dict["test"] = prep.image_test(**config["prep"]['params']) ## prepare data dsets = {} dset_loaders = {} data_config = config["data"] train_bs = data_config["source"]["batch_size"] test_bs = data_config["test"]["batch_size"] dsets["source"] = ImageList(open(data_config["source"]["list_path"]).readlines(), \ transform=prep_dict["source"]) dset_loaders["source"] = DataLoader(dsets["source"], batch_size=train_bs, \ shuffle=True, num_workers=4, drop_last=True) dsets["target"] = ImageList(open(data_config["target"]["list_path"]).readlines(), \ transform=prep_dict["target"]) dset_loaders["target"] = DataLoader(dsets["target"], batch_size=train_bs, \ shuffle=True, num_workers=4, drop_last=True) # if prep_config["test_10crop"]: # for i in range(10): # dsets["test"] = [ImageList(open(data_config["test"]["list_path"]).readlines(), \ # transform=prep_dict["test"][i]) for i in range(10)] # dset_loaders["test"] = [DataLoader(dset, batch_size=test_bs, \ # shuffle=False, num_workers=4) for dset in dsets['test']] # else: # dsets["test"] = ImageList(open(data_config["test"]["list_path"]).readlines(), \ # transform=prep_dict["test"]) # dset_loaders["test"] = DataLoader(dsets["test"], batch_size=test_bs, \ # shuffle=False, num_workers=4) class_num = config["network"]["params"]["class_num"] ## set base network net_config = config["network"] base_network = net_config["name"](**net_config["params"]) base_network = base_network.cuda() ## add additional network for some methods if config["loss"]["random"]: random_layer = network.RandomLayer( [base_network.output_num(), class_num], config["loss"]["random_dim"]) ad_net = network.AdversarialNetwork(config["loss"]["random_dim"], 1024) else: random_layer = None ad_net = network.AdversarialNetwork( base_network.output_num() * class_num, 1024) if config["loss"]["random"]: random_layer.cuda() ad_net = ad_net.cuda() parameter_list = base_network.get_parameters() + ad_net.get_parameters() ## set optimizer optimizer_config = config["optimizer"] optimizer = optimizer_config["type"](parameter_list, \ **(optimizer_config["optim_params"])) param_lr = [] for param_group in optimizer.param_groups: param_lr.append(param_group["lr"]) schedule_param = optimizer_config["lr_param"] lr_scheduler = lr_schedule.schedule_dict[optimizer_config["lr_type"]] gpus = config['gpu'].split(',') if len(gpus) > 1: ad_net = nn.DataParallel(ad_net, device_ids=[int(i) for i in gpus]) base_network = nn.DataParallel(base_network, device_ids=[int(i) for i in gpus]) ## train len_train_source = len(dset_loaders["source"]) len_train_target = len(dset_loaders["target"]) transfer_loss_value = classifier_loss_value = total_loss_value = 0.0 best_acc = 0.0 for i in range(config["num_iterations"]): # if i % config["test_interval"] == config["test_interval"] - 1: # base_network.train(False) # temp_acc = image_classification_test(dset_loaders, \ # base_network, test_10crop=prep_config["test_10crop"]) # temp_model = nn.Sequential(base_network) # if temp_acc > best_acc: # best_acc = temp_acc # best_model = temp_model # log_str = "iter: {:05d}, precision: {:.5f}".format(i, temp_acc) # config["out_file"].write(log_str+"\n") # config["out_file"].flush() # print(log_str) if i % config["snapshot_interval"] == 0: torch.save(nn.Sequential(base_network), osp.join(config["output_path"], \ "iter_{:05d}_model.pth.tar".format(i))) loss_params = config["loss"] ## train one iter base_network.train(True) ad_net.train(True) optimizer = lr_scheduler(optimizer, i, **schedule_param) optimizer.zero_grad() if i % len_train_source == 0: iter_source = iter(dset_loaders["source"]) if i % len_train_target == 0: iter_target = iter(dset_loaders["target"]) inputs_source, labels_source = iter_source.next() inputs_target, labels_target = iter_target.next() inputs_source, inputs_target, labels_source = inputs_source.cuda( ), inputs_target.cuda(), labels_source.cuda() features_source, outputs_source = base_network(inputs_source) features_target, outputs_target = base_network(inputs_target) features = torch.cat((features_source, features_target), dim=0) outputs = torch.cat((outputs_source, outputs_target), dim=0) softmax_out = nn.Softmax(dim=1)(outputs) if config['method'] == 'CDAN+E': entropy = loss.Entropy(softmax_out) transfer_loss = loss.CDAN([features, softmax_out], ad_net, entropy, network.calc_coeff(i), random_layer) elif config['method'] == 'CDAN': transfer_loss = loss.CDAN([features, softmax_out], ad_net, None, None, random_layer) elif config['method'] == 'DANN': transfer_loss = loss.DANN(features, ad_net) else: raise ValueError('Method cannot be recognized.') classifier_loss = nn.CrossEntropyLoss()(outputs_source, labels_source) if i % 10 == 0: print('iter: ', i, 'classifier_loss: ', classifier_loss.data, 'transfer_loss: ', transfer_loss.data) total_loss = loss_params["trade_off"] * transfer_loss + classifier_loss total_loss.backward() optimizer.step() torch.save(best_model, osp.join(config["output_path"], "best_model.pth.tar")) return best_acc
from data_list import ImageList import pre_process as prep from resnet import make_resnet50_base model_path = 'resnet50-base.pth' cnn = make_resnet50_base() cnn.load_state_dict(torch.load(model_path)) for param in cnn.parameters(): param.requires_grad = False cnn.cuda() cnn.eval() infile = open('S_features.csv', 'a') TEST_LIST = 'WEB_3D3_2.txt' prep_test = prep.image_test(resize_size=256, crop_size=224) dsets_test = ImageList(open(TEST_LIST).readlines(), shape=(256, 256), transform=prep_test, train=False) loaders_test = util_data.DataLoader(dsets_test, batch_size=512, shuffle=False, num_workers=16, pin_memory=True) for batch_id, batch in enumerate(loaders_test, 1): print(str(batch_id)) data, label = batch data = data.cuda() features = cnn(data) now = features.cpu().data.numpy() np.savetxt(infile, now, delimiter=',') torch.cuda.empty_cache()