def __init__(self, seed): self.log_file = utils.set_logger("./train.log") self.device = utils.get_device() self.batch_size = 16 self.epoches = 10 self.lr = 5e-6 self.bert_model = bert_model self.bert_tokenizer = bert_tokenizer # self.train_text_json = r"dataset/training/training.en-en.data" # self.train_label_json = r"dataset/training/training.en-en.gold" # self.valid_text_json = r"dataset/dev/multilingual/dev.en-en.data" # self.valid_label_json = r"dataset/dev/multilingual/dev.en-en.gold" self.train_fold = r"dataset/training" self.dev_fold = r"dataset/dev/multilingual" self.test_fold = r"dataset/test" self.trial_fold = r"dataset/trial" self.seed = seed self.num_class = 2 # self.dropout = -0.2 self.in_features = 768 self.loss_result = None self.warm_ratio = 0.1 self.model_dir = "End2endXLMRoBertaNet_v2_{}".format(self.seed) utils.setup_seed(seed)
def main(): args = parse_args() if args.seed != None: setup_seed(args.seed) configs = Config.fromfile(args.config) if args.work_dir != None: configs.work_dir = args.work_dir mmcv.mkdir_or_exist(configs.work_dir) timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime()) log_file = osp.join(configs.work_dir, '{}.log'.format(timestamp)) logger = create_logger(log_file=log_file) logger.info(configs.text) dataset_config = configs.data train_dataset = eval('datasets.{}.build_dataset'.format(dataset_config.train.type)) \ (dataset_config) train_loader = DataLoader(train_dataset, batch_size=dataset_config.batch, shuffle=True, num_workers=dataset_config.num_workers) valid_dataset = eval('datasets.{}.build_dataset'.format(dataset_config.valid.type)) \ (dataset_config, is_training=False) valid_loader = DataLoader(valid_dataset, batch_size=dataset_config.batch, shuffle=False, num_workers=dataset_config.num_workers) model = eval('models.{}.build_model'.format(configs.model.name))(configs) model = torch.nn.DataParallel(model, device_ids=configs.gpu_group).cuda() train_model(configs, model, train_loader, valid_loader)
def main(config): logger = config.get_logger('train') # selece gpus devices = config.init_obj('GPUtil', GPUtil) devices_str = ','.join(map(str, devices)) os.environ['CUDA_VISIBLE_DEVICES'] = devices_str logger.info('Use gpus: {}'.format(devices_str)) # fix random seeds for reproducibility if config['seed'] is not None: setup_seed(config['seed']) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False # load and split data into trainset and validset by valid_split fullset = config.init_obj('dataset', dataset) trainset, ph1 = random_split( fullset, config['dataset']['valid_split']) # placeholder validset = config.init_obj('valid_dataset', dataset) validset, ph2 = random_split(validset, config['valid_dataset']['valid_split']) # fullset = config.init_obj('dataset', dataset) # trainset, validset = random_split(fullset, config['dataset']['valid_split']) trainloader = config.init_obj('dataloader', dataloader, trainset) if validset is None: validloader = None else: validloader = config.init_obj('dataloader', dataloader, validset) # build model architecture, then print to console model = config.init_obj('model', module_model) # logger.info(model) # get function handles of loss and metrics criterion = config.init_obj('loss', module_loss) metrics = [getattr(module_metric, met) for met in config['metrics']] # build optimizer, learning rate scheduler. delete every lines containing lr_scheduler for disabling scheduler trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = config.init_obj('optimizer', torch.optim, trainable_params) lr_scheduler = config.init_obj('lr_scheduler', torch.optim.lr_scheduler, optimizer) trainer = Trainer(model, criterion, metrics, optimizer, config=config, trainloader=trainloader, validloader=validloader, lr_scheduler=lr_scheduler) trainer.train()
def train(**kwargs): setup_seed(2020) model_param = default_config() model_param = parse_kwargs(model_param, kwargs) # load training data train_data = ehr.EHR("dataset/EHR", "train") # load validation data val_data = ehr.EHR("dataset/EHR", "val") # use data model to update model_param data_model_param = parse_data_model(train_data) model_param.update(data_model_param) # init model model = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, verbose=1, n_iter_no_change=10, random_state=10) train_feat, train_label = train_data.get_feat_data() print("Start Training.") model.fit(train_feat, train_label) print("Training Finished.") # eval on test set # load test data test_data = ehr.EHR("dataset/EHR", "test") test_feat, test_label = test_data.get_feat_data() test_metric, test_log, test_result = evaluate_clf(model, test_feat, test_label, top_k_list=[3, 5, 10]) print("[Test] {}: {}".format(now(), test_log)) print("Training Done.")
def main(args): # for fast training. torch.backends.cudnn.benchmark = True setup_seed(args.seed) # create directories if not exist. create_folder(args.save_root_dir, args.version, args.model_save_path) create_folder(args.save_root_dir, args.version, args.sample_path) create_folder(args.save_root_dir, args.version, args.log_path) create_folder(args.save_root_dir, args.version, args.val_result_path) create_folder(args.save_root_dir, args.version, args.test_result_path) if args.mode == 'train': loaders = Munch(ref=get_train_loader(root=args.train_img_dir, img_size=args.image_size, resize_size=args.resize_size, batch_size=args.train_batch_size, shuffle=args.shuffle, num_workers=args.num_workers, drop_last=args.drop_last), val=get_test_loader(root=args.val_img_dir, batch_size=args.val_batch_size, shuffle=True, num_workers=args.num_workers)) trainer = Trainer(loaders, args) trainer.train() elif args.mode == 'test': loaders = Munch(tes=get_test_loader(root=args.test_img_dir, img_size=args.test_img_size, batch_size=args.val_batch_size, shuffle=True, num_workers=args.num_workers)) tester = Tester(loaders, args) tester.test() else: raise NotImplementedError('Mode [{}] is not found'.format(args.mode))
def main(): setup_seed(2) # show_result(use_lda=False) # nets = [ClassificationAlexNet(n_labels) for _ in range(n_clusters)] train_transform = transforms.Compose([ transforms.Resize((int(size * 1.25), int(size * 1.25))), transforms.RandomRotation(15), transforms.CenterCrop(size), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transform = transforms.Compose([ transforms.Resize((size, size)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # datasets = [Cub2011Cluster(root=dataset_directory, cluster_id=i, train=True, transform=train_transform) # for i in range(n_clusters)] # # datasets = [Cub2011(root=dataset_directory train=True, transform=transform) # # for i in range(n_clusters)] # datasets_len = [len(dataset) for dataset in datasets] # data_loaders = [DataLoader(dataset, shuffle=True, batch_size=batch_size) for dataset in datasets] train_set = Cub2011(root=dataset_directory, train=True, transform=train_transform) train_loader = DataLoader(train_set, shuffle=True, batch_size=batch_size) test_set = Cub2011Cluster(root=dataset_directory, train=False, transform=test_transform) test_loader = DataLoader(test_set, shuffle=True, batch_size=batch_size) val_set = Cub2011(root=dataset_directory, train=True, transform=test_transform) val_loader = DataLoader(val_set, shuffle=True, batch_size=batch_size) cluster_net = ClusterAlexNet() nets = [ClassificationAlexNet(n_labels) for i in range(n_clusters)] # nets = [nn.DataParallel(net) for net in nets] if torch.cuda.is_available(): nets = [net.cuda() for net in nets] criterion = nn.CrossEntropyLoss() def train_with_clustering(epoch): max_dataset_len = max(datasets_len) for dataset_len, data_loader, net in zip(datasets_len, data_loaders, nets): optimizer = torch.optim.SGD(net.parameters(), lr=lr) adjust_learning_rate(optimizer, epoch) train_loss, total, correct = 0, 0, 0 for _ in range(0, max_dataset_len, dataset_len): for batch_id, (x, y) in enumerate(data_loader): if torch.cuda.is_available(): x, y = x.cuda(), y.cuda() y_ = net(x) loss = criterion(y_, y) train_loss += loss.item() optimizer.zero_grad() loss.backward() optimizer.step() total += y.shape[0] correct += (y_.argmax(dim=1) == y).sum().cpu().item() print("Epoch:{}, {}/{},train loss:{},train acc:{}".format( epoch, batch_size * (batch_id + 1), dataset_len, train_loss / (batch_id + 1), correct / total)) def train_jointly(epoch): optimizer = torch.optim.SGD([{ 'params': net.parameters() } for net in nets], lr=lr, momentum=0.9, weight_decay=1e-3) # adjust_learning_rate(optimizer, epoch) correct, total, train_loss = 0, 0, 0 for batch_id, (x, y) in enumerate(train_loader): if torch.cuda.is_available(): x, y = x.cuda(), y.cuda() # c_s = [] # z_s = [] # for net in nets: # z = net(x) # z_s.append(z) # c_s.append(z.max(dim=1).values) # (n,6) # c = torch.stack(c_s, dim=1) # (n,6,1) # a = F.softmax(c, dim=1).unsqueeze(-1) # z1 = torch.stack(z_s, dim=1) # (n, 200) # z = (a * z1).sum(1) # z = z1.sum(1) z = nets[0](x) loss = criterion(z, y) optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() # (n) y_ = z.argmax(1) correct += (y_ == y).sum().cpu().item() total += y.shape[0] print("Epoch:{},train batch:{}/{}, loss:{} ,acc:{}".format( epoch, batch_id, len(train_loader), train_loss / (batch_id + 1), correct / total)) def val_with_clustering(epoch): global best_val_acc correct, total = 0, 0 with torch.no_grad(): for batch_id, (x, y) in enumerate(val_loader): if torch.cuda.is_available(): x, y = x.cuda(), y.cuda() # c_s = [] z_s = [] for net in nets: z = net(x) z_s.append(z) # c_s.append(z.max(dim=1).values) # (n,6) # c = torch.stack(c_s, dim=1) # (n,6,1) # a = F.softmax(c, dim=1).unsqueeze(-1) z1 = torch.stack(z_s, dim=1) # z = (a * z1).sum(1) z = z1.sum(1) y_ = z.argmax(1) correct += (y_ == y).sum().cpu().item() total += y.shape[0] print("Epoch:{}, val batch:{}/{},acc:{}".format( epoch, batch_id, len(val_loader), correct / total)) acc = correct / total best_val_acc = max(best_val_acc, acc) print("Epoch:{},val acc:{}(best:{})".format(epoch, acc, best_val_acc)) def test_with_clustering(epoch, directory): global best_test_acc correct, total = 0, 0 with torch.no_grad(): for batch_id, (x, y) in enumerate(test_loader): if torch.cuda.is_available(): x, y = x.cuda(), y.cuda() # c_s = [] z_s = [] # for net in nets: # z = net(x) # z_s.append(z) # c_s.append(z.max(dim=1).values) # (n,6) # c = torch.stack(c_s, dim=1) # (n,6,1) # a = F.softmax(c, dim=1).unsqueeze(-1) # z1 = torch.stack(z_s, dim=1) # z = (a * z1).sum(1) # z = z1.sum(1) z = nets[0](x) y_ = z.argmax(1) correct += (y_ == y).sum().cpu().item() total += y.shape[0] print("Epoch:{},test batch:{}/{},acc:{}".format( epoch, batch_id, len(test_loader), correct / total)) acc = correct / total is_best = False if acc > best_test_acc: is_best = True best_test_acc = acc # 保存模型 save_checkpoint( { 'epoch': epoch, 'state_dict': [net.state_dict() for net in nets] }, directory, is_best) print("Epoch:{},test acc:{}(best:{})".format(epoch, acc, best_test_acc)) # def test(epoch): # with open('lda.pickle', 'rb') as f: # lda = pickle.load(f) # with open('kmean.pickle', 'rb') as f: # kmean = pickle.load(f) # for batch_id, (x, y) in enumerate(test_loader): # x, y = x.cuda(), y.cuda() # features = cluster_net(x) # features = lda.transform(features) # cluster_ids = kmean.fit_predict(features) # print(cluster_ids) start = 0 has_joint_checkpoint = exist_checkpoint(train_jointly_directory) # if not has_joint_checkpoint: # print("Start train dependently") # # 这里需要专家网络首先单独训练30轮 # state = load_checkpoint_1(train_dependently_directory) # if state is not None: # start = state['epoch'] + 1 # for net, state_dict in zip(nets, state['state_dict']): # net.load_state_dict(state_dict) # for epoch in range(start, 30): # train_with_clustering(epoch) # # val_with_clustering(epoch) # test_with_clustering(epoch, train_dependently_directory) # 需要专家网络放在一起进行训练 print("Start train jointly") if has_joint_checkpoint: state = load_checkpoint_1(train_jointly_directory) start = state['epoch'] + 1 for net, state_dict in zip(nets, state['state_dict']): net.load_state_dict(state_dict) for epoch in range(start, n_epochs): train_jointly(epoch) # val_with_clustering(epoch) test_with_clustering(epoch, train_jointly_directory)
import dataset import math from utils import save_checkpoint, setup_seed import torch import os import logging import nni from nni.utils import merge_parameter from config import return_args, args import numpy as np from image import load_data warnings.filterwarnings('ignore') import time setup_seed(args.seed) logger = logging.getLogger('mnist_AutoML') def main(args): if args['dataset'] == 'ShanghaiA': train_file = './npydata/ShanghaiA_train.npy' test_file = './npydata/ShanghaiA_test.npy' elif args['dataset'] == 'ShanghaiB': train_file = './npydata/ShanghaiB_train.npy' test_file = './npydata/ShanghaiB_test.npy' elif args['dataset'] == 'UCF_QNRF': train_file = './npydata/qnrf_train.npy' test_file = './npydata/qnrf_test.npy' elif args['dataset'] == 'JHU':
import sklearn.preprocessing as preprocessing from scipy.stats import entropy from sklearn.metrics import confusion_matrix import time import itertools import sys import utils from termcolor import cprint import argparse parser = argparse.ArgumentParser() parser.add_argument('--c', default='./config/sun_gzsl.yaml', help='config yaml') config_path = parser.parse_args().c opts=utils.load_yaml(config_path) utils.setup_seed(opts.random_seed) data = utils.DATA_LOADER(opts) logger=None if opts.zsl: model_save_path = './results/' + opts.zsl_model_path else: model_save_path = './results/' + opts.gzsl_model_path if not os.path.exists('./results'): os.mkdir('results') if opts.zsl: logger = utils.Logger('./results/' + opts.zsl_model_path + '/result.log') if not os.path.exists('./results/' + opts.zsl_model_path): os.mkdir('./results/' + opts.zsl_model_path)
parser.add_argument('--lr', default=0.00025, type=float) parser.add_argument('--finetune_bert', default=False, type=bool) parser.add_argument('--bert_lr', default=0.00001, type=float) parser.add_argument('--resume_optimizer', default=False, type=bool) parser.add_argument('--max_instr_len', default=540, type=int, help='Max instruction token num.') parser.add_argument('--max_sentence_num', default=40, type=int, help='Max number of sentences in instruction.') parser.add_argument('--max_route_len', default=55, type=int, help='Max trajectory length.') parser.add_argument('--max_t_v_len', default=60, type=int, help='Max length of the concatenation of sentence embeddings and trajectory embeddings.') parser.add_argument('--hidden_dim', default=256, type=int) parser.add_argument('--exp_name', default='experiments', type=str, help='Name of the experiment. It decides where to store samples and models') parser.add_argument('--exp_number', default=None, type=str) opts = parser.parse_args() setup_seed(opts.seed) def main(opts): if opts.exp_number is not None: opts.exp_name = opts.exp_name + '_' + opts.exp_number opts.dataset = 'datasets/%s' % opts.dataset tb_logger = set_tb_logger('{}/{}'.format(opts.log_dir, opts.model), opts.exp_name, opts.resume) best_SPD, best_TC = float("inf"), 0.0 # Load data if opts.model == 'vlntrans': opts.max_instr_len = 512 vocab_file = "%s/vocab/vlntrans_vocab.txt" % opts.dataset tokenizer = tx.data.BERTTokenizer(pretrained_model_name='bert-base-uncased', hparams={'vocab_file': vocab_file})
def __init__(self, args, options='', timestamp=True): # parse default and custom cli options for opt in options: args.add_argument(*opt.flags, default=None, type=opt.type) args = args.parse_args() if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device self.bert_config_path = None if args.resume: self.resume = Path(args.resume) self.cfg_fname = self.resume.parent / 'config.json' self.bert_config_path = str(self.resume.parent / 'BertConfig.json') else: msg_no_cfg = "Configuration file need to be specified. Add '-c config.json', for example." assert args.config is not None, msg_no_cfg self.resume = None self.cfg_fname = 'config' / Path(args.config) # load config file and apply custom cli options config = read_json(self.cfg_fname) self._config = _update_config(config, options, args) # set save_dir where trained model and log will be saved. self.base_save_dir = Path(self.config['trainer']['save_dir']) self.exper_name = self.config['processor']['args']['data_name'] + \ '_' + self.config['arch']['type'] timestamp = datetime.now().strftime( r'%m%d_%H%M%S') if timestamp else '' self._save_dir = self.base_save_dir / 'models' / self.exper_name / timestamp self._log_dir = self.base_save_dir / 'log' / self.exper_name / timestamp self.log_dir.mkdir(parents=True, exist_ok=True) # configure logging module setup_logging(self.log_dir) self.log_levels = { 0: logging.WARNING, 1: logging.INFO, 2: logging.DEBUG } setup_seed(self._config['seed']) self.debug_mode = args.debug if "debug" in args else False self.all = args.all if "all" in args else False self.reset = args.reset if "reset" in args else False self.search_mode = args.searchMode if "searchMode" in args else "disable" self.gradient_accumulation_steps = self.config['trainer'][ 'gradient_accumulation_steps'] if self.search_mode != 'disable': self.config['trainer']['tensorboardX'] = False if self.all: self.config["data_loader"]["args"]["validation_split"] = 0.0 if self.debug_mode: self.config["trainer"]["epochs"] = 2
# Initialize base model print("======Initialize base DNN model======") model.mode = "BaseModel" for epoch in range(init_epochs): train_epoch(model, train_loader, test_loader, optimizer, criterion, epoch) print("=======Initialize theta matrix=======") # Initialize the Theta matrix y_noisy, y_pred = get_predict_label(model, train_loader) model.confusion = confusion_matrix(y_noisy, y_pred) print("======Starting to EM steps======") for epoch in range(init_epochs, epochs): estimate_prob, predict_prob = e_step(model, train_loader) m_step(model, train_loader, test_loader, estimate_prob, epoch) # Save estimated Q matrix plt.matshow(model.confusion.numpy()) plt.colorbar() plt.savefig("./imgs/nlnn_Q.png") if __name__ == "__main__": setup_seed() # train_basednn_v1(epochs=30) # 0.943 # train_basednn_v2(epochs=30) # 0.977 # train_bottomupdnn_v1(epochs=35, init_epochs=10) # 0.975 # train_bottomupdnn_v2(epochs=30, init_epochs=10) # 0.947 train_nlnn(epochs=30, init_epochs=10) # 0.947
import opt import torch import numpy as np from DFCN import DFCN from utils import setup_seed from sklearn.decomposition import PCA from load_data import LoadDataset, load_graph, construct_graph from train import Train, acc_reuslt, nmi_result, f1_result, ari_result setup_seed(opt.args.seed) print("network setting…") if opt.args.name == 'usps': opt.args.k = 5 opt.args.n_clusters = 10 opt.args.n_input = 30 elif opt.args.name == 'hhar': opt.args.k = 5 opt.args.n_clusters = 6 opt.args.n_input = 50 elif opt.args.name == 'reut': opt.args.k = 5 opt.args.n_clusters = 4 opt.args.n_input = 100 elif opt.args.name == 'acm': opt.args.k = None opt.args.n_clusters = 3 opt.args.n_input = 100 elif opt.args.name == 'dblp': opt.args.k = None
import torch.utils.data as data import torch.optim as optim from torchvision import datasets, transforms import os import ast import argparse from utils import setup_seed from attackers import fgsm_attack, pgd_attack # ======== fix data type ======== torch.set_default_tensor_type(torch.FloatTensor) # ======== fix seed ============= setup_seed(666) # ======== options ============== parser = argparse.ArgumentParser(description='Attack Deep Neural Networks') # -------- file param. -------------- parser.add_argument('--data_dir', type=str, default='/media/Disk1/KunFang/data/CIFAR10/', help='file path for data') parser.add_argument('--dataset', type=str, default='CIFAR10', help='data set name') parser.add_argument('--model', type=str, default='vgg16',
def train(**kwargs): setup_seed(2020) model_param = default_config() model_param = parse_kwargs(model_param, kwargs) # load hard maps if model_param["hard_ratio"] > 0: model_param["hard_map"] = np.load("dataset/hard_dise.npy", allow_pickle=True).item() # load training data train_data = ehr.EHR("dataset/EHR", "train") train_data_loader = DataLoader(train_data, model_param["batch_size"], shuffle=True, num_workers=0, collate_fn=collate_fn) # load validation data val_data = ehr.EHR("dataset/EHR", "val") val_data_loader = DataLoader(val_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) # use data model to update model_param data_model_param = parse_data_model(train_data) model_param.update(data_model_param) use_gpu = model_param["use_gpu"] # init model gnn = HGNN_DSD(**model_param) if kwargs["w2v"] is not None: # load w2v data gnn.load_symp_embed(kwargs["w2v"]) early_stopper = EarlyStopping(patience=model_param["early_stop"], larger_better=True) if use_gpu: gnn.cuda() print("Model Inited.") # optimizer = torch.optim.Adam(gnn.parameters(),lr=model_param["lr"],weight_decay=model_param["weight_decay"]) optimizer = torch.optim.Adam(gnn.parameters(), lr=model_param["lr"], weight_decay=0) # init sampler for netative sampling during training. dsd_sampler = DSD_sampler("dataset/EHR") print("D-S-D Sampler Inited.") for epoch in range(model_param["num_epoch"]): total_loss = 0 gnn.train() for idx, (feat, dise) in enumerate(train_data_loader): pred, pred_neg, emb_user, emb_dise, neg_emb_dise = gnn.forward( feat, dise, dsd_sampler) bpr_loss = create_bpr_loss(pred, pred_neg) l2_loss = create_l2_loss(emb_user, emb_dise, neg_emb_dise) loss = bpr_loss + model_param["weight_decay"] * l2_loss # loss = bpr_loss optimizer.zero_grad() loss.backward() optimizer.step() total_loss += bpr_loss.item() # print(idx,total_loss) print("{} Epoch {}/{}: train loss: {:.6f}".format( now(), epoch + 1, model_param["num_epoch"], total_loss)) # do evaluation on recall and ndcg metric_result, eval_log, eval_result = evaluate( gnn, val_data_loader, dsd_sampler, [5]) print("{} Epoch {}/{}: [Val] {}".format(now(), epoch + 1, model_param["num_epoch"], eval_log)) early_stopper(metric_result["ndcg_5"], gnn, "gnn_dsd") if early_stopper.early_stop: print("[Early Stop] {} Epoch {}/{}: {}".format( now(), epoch + 1, model_param["num_epoch"], eval_log)) break # eval on test set # load test data test_data = ehr.EHR("dataset/EHR", "test") test_data_loader = DataLoader(test_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) test_metric, test_log, test_result = evaluate(gnn, test_data_loader, dsd_sampler, top_k_list=[1, 3, 5, 10]) print("[Test] {}: {}".format(now(), test_log)) print("Training Done.")
dist1, dist2 = ChamferDistanceFunction.apply(pcs1, pcs2) # (B, N), (B, M) dist1 = torch.mean(torch.sqrt(dist1)) dist2 = torch.mean(torch.sqrt(dist2)) return (dist1 + dist2) / 2 class EarthMoverDistance(nn.Module): def __init__(self, eps=0.005, max_iter=3000): super(EarthMoverDistance, self).__init__() self.eps = eps self.max_iter = max_iter def forward(self, pcs1, pcs2): dist, _ = emdFunction.apply(pcs1, pcs2, self.eps, self.max_iter) return torch.sqrt(dist).mean() if __name__ == '__main__': from utils import setup_seed setup_seed(20) pcs1 = torch.rand(10, 1024, 3) pcs2 = torch.rand(10, 1024, 3) cd_loss = ChamferDistance() print(cd_loss(pcs1, pcs2)) emd_loss = EarthMoverDistance() print(emd_loss(pcs1, pcs2))
if not os.path.exists(config.log_path): os.makedirs(config.log_path) ISOTIMEFORMAT = '%m%d-%H%M%S' timestamp = str(datetime.datetime.now().strftime(ISOTIMEFORMAT)) loglogs = '_'.join( (config.data, model_list[config.model].__name__, sampler_list[config.sampler].__name__, str(config.sample_size), str(config.pool_size), str(config.sample_num), timestamp)) log_file_name = os.path.join(config.log_path, loglogs) logger = utils.get_logger(log_file_name) logger.info(config) logger.info([s.__name__ for s in sampler_list]) logger.info([m.__name__ for m in model_list]) if config.fix_seed: utils.setup_seed(config.seed) m = main(config, logger) # print('ndcg@5,10,50, ', m['item_ndcg'][[4,9,49]]) logger.info('Eval_Res : NDCG@5,10,50 %.6f, %.6f, %.6f' % (m['item_ndcg'][4], m['item_ndcg'][9], m['item_ndcg'][49])) logger.info( 'Eval_Res : RECALL@5,10,50 %.6f, %.6f, %.6f' % (m['item_recall'][4], m['item_recall'][9], m['item_recall'][49])) logger.info("Finish") svmat_name = log_file_name + '.mat' scipy.io.savemat(svmat_name, m)
args.test_dir = os.path.join(args.data_dir, "test") args.ckpt_dir = os.path.join(args.target_dir_name, args.ckpt_dir) args.log_dir = os.path.join(args.target_dir_name, args.log_dir) args.board_dir = os.path.join(args.target_dir_name, args.board_dir) args.done_dir = os.path.join(args.target_dir_name, "done") args.commandline_file = os.path.join(args.target_dir_name, args.commandline_file) if __name__ == '__main__': writer = SummaryWriter(log_dir = args.board_dir) if args.use_saved_args: with open(args.commandline_file, "r") as f: args.__dict__ = json.load(f) else: pass os.makedirs(args.log_dir, exist_ok = True) os.system("cp *.py " + args.target_dir_name) logger = construct_log(args) setup_seed(seed = args.seed) model = MODEL(args, logger, writer) if args.valid: losses, accs, diss, pred_diss = model.valid_stage1(False, args.max_epoch_stage1) else: model.train() model.save_log()
def train(**kwargs): setup_seed(2020) model_param = default_config() model_param = parse_kwargs(model_param, kwargs) dataset_name = model_param["dataset"] # load hard maps if model_param["hard_ratio"] > 0: model_param["hard_map"] = np.load("dataset/hard_dise.npy", allow_pickle=True).item() # load training data train_data = ehr.EHR("dataset/{}".format(dataset_name), "train") train_data_loader = DataLoader(train_data, model_param["batch_size"], shuffle=True, num_workers=0, collate_fn=collate_fn) # load validation data val_data = ehr.EHR("dataset/{}".format(dataset_name), "val") val_data_loader = DataLoader(val_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) # use data model to update model_param data_model_param = parse_data_model(train_data) model_param.update(data_model_param) use_gpu = model_param["use_gpu"] # init model gnn = HGNN(**model_param) if kwargs["w2v"] is not None: if os.path.exists(kwargs["w2v"]): # load w2v data gnn.load_symp_embed(kwargs["w2v"]) else: from gensim.models import Word2Vec # build word2vec embeddings filename = "./dataset/EHR/train/data.txt" fin = open(filename, "r") corpus = [] for line in fin.readlines(): corpus.append(line.strip().split()[2:]) # learn word2vec model start_time = time.time() w2v_model = Word2Vec(corpus, size=64, window=3, min_count=1, workers=4, sg=1) w2v_model.save("./ckpt/w2v") print("word2vec training done, costs {} secs.".format(time.time() - start_time)) early_stopper = EarlyStopping(patience=model_param["early_stop"], larger_better=True) if use_gpu: gnn.cuda() print("Model Inited.") # optimizer = torch.optim.Adam(gnn.parameters(),lr=model_param["lr"],weight_decay=model_param["weight_decay"]) optimizer = torch.optim.Adam(gnn.parameters(), lr=model_param["lr"], weight_decay=0) # init sampler for netative sampling during training. dsd_sampler = DSD_sampler("dataset/{}".format(dataset_name)) print("D-S-D Sampler Inited.") for epoch in range(model_param["num_epoch"]): total_loss = 0 gnn.train() for idx, (feat, dise) in enumerate(train_data_loader): pred, pred_neg, emb_user, emb_dise, neg_emb_dise = gnn.forward( feat, dise, dsd_sampler) bpr_loss = create_bpr_loss(pred, pred_neg) l2_loss = create_l2_loss(emb_user, emb_dise, neg_emb_dise) loss = bpr_loss + model_param["weight_decay"] * l2_loss # loss = bpr_loss optimizer.zero_grad() loss.backward() optimizer.step() total_loss += bpr_loss.item() # print(idx,total_loss) print("{} Epoch {}/{}: train loss: {:.6f}".format( now(), epoch + 1, model_param["num_epoch"], total_loss)) # do evaluation on recall and ndcg metric_result, eval_log, eval_result = evaluate( gnn, val_data_loader, dsd_sampler, [5]) print("{} Epoch {}/{}: [Val] {}".format(now(), epoch + 1, model_param["num_epoch"], eval_log)) early_stopper(metric_result["ndcg_5"], gnn, "gnn") if early_stopper.early_stop: print("[Early Stop] {} Epoch {}/{}: {}".format( now(), epoch + 1, model_param["num_epoch"], eval_log)) break # eval on test set # load test data test_data = ehr.EHR("dataset/{}".format(dataset_name), "test") test_data_loader = DataLoader(test_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) test_metric, test_log, test_result = evaluate(gnn, test_data_loader, dsd_sampler, top_k_list=[1, 3, 5, 10]) print("[Test] {}: {}".format(now(), test_log)) print("Training Done.")
parser.add_argument('--log', type=str, default='log.txt', help="text file to save training logs") parser.add_argument('--train', type=str, default='train.txt', help="text file to save train logs") parser.add_argument('--eval', type=str, default='eval.txt', help="text file to save evaluation logs") parser.add_argument('--start_epoch', type=int, default=0, help="flag to set the starting epoch for training") parser.add_argument('--end_epoch', type=int, default=500, help="flag to indicate the final epoch of training") parser.add_argument('--unet_model', type=str, default="UNet", help="model") FLAGS = parser.parse_args() if __name__ == '__main__': setup_seed(78) train(FLAGS) # test(FLAGS)
def train_embedding(args): setup_seed(2333) ckpt_root = os.path.join('./ckpt', args.dataset) os.makedirs(ckpt_root, exist_ok=True) data_root = os.path.join(args.folder, args.dataset) from datasets import EmbeddingDataset source_set = EmbeddingDataset(data_root, args.img_size, 'train') source_loader = DataLoader(source_set, num_workers=4, batch_size=64, shuffle=True) test_set = EmbeddingDataset(data_root, args.img_size, 'val') test_loader = DataLoader(test_set, num_workers=4, batch_size=32, shuffle=False) if args.dataset == 'cub': num_classes = 100 elif args.dataset == 'tieredimagenet': num_classes = 351 else: num_classes = 64 from models.resnet12 import resnet12 model = resnet12(num_classes).to(args.device) model = model.to(args.device) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=1e-4) from torch.optim.lr_scheduler import StepLR scheduler = StepLR(optimizer, step_size=30, gamma=0.1) criterion = nn.CrossEntropyLoss() best_acc = 0.0 for epoch in range(120): model.train() scheduler.step(epoch) loss_list = [] train_acc_list = [] for images, labels in tqdm(source_loader, ncols=0): preds = model(images.to(args.device)) loss = criterion(preds, labels.to(args.device)) optimizer.zero_grad() loss.backward() optimizer.step() loss_list.append(loss.item()) train_acc_list.append( preds.max(1)[1].cpu().eq(labels).float().mean().item()) acc = [] model.eval() for images, labels in test_loader: preds = model(images.to(args.device)).detach().cpu() preds = torch.argmax(preds, 1).reshape(-1) labels = labels.reshape(-1) acc += (preds == labels).tolist() acc = np.mean(acc) print('Epoch:{} Train-loss:{} Train-acc:{} Valid-acc:{}'.format( epoch, str(np.mean(loss_list))[:6], str(np.mean(train_acc_list))[:6], str(acc)[:6])) if acc > best_acc: best_acc = acc save_path = os.path.join(ckpt_root, "res12_epoch{}.pth.tar".format(epoch)) torch.save(model.state_dict(), save_path) torch.save(model.state_dict(), os.path.join(ckpt_root, 'res12_best.pth.tar'))
def train(**kwargs): setup_seed(2020) model_param = default_config() model_param = parse_kwargs(model_param, kwargs) # load training data train_data = ehr.EHR("dataset/EHR", "train") train_data_loader = DataLoader(train_data, model_param["batch_size"], shuffle=True, num_workers=0, collate_fn=collate_fn) # init model data_model_param = parse_data_model(train_data) model_param.update(data_model_param) use_gpu = model_param["use_gpu"] gnn = HGNN_SDS(**model_param) if model_param["w2v"] is not None: # load w2v data gnn.load_symp_embed(model_param["w2v"]) if use_gpu: gnn.cuda() print("Model Inited.") sds_sampler = SDS_sampler("dataset/EHR") # load pmi ss mat symp2symp_mat = sp.load_npz(os.path.join("dataset/EHR", "pmi_ss_mat.npz")) symp2symp_mat.setdiag(0) # total number of symptoms num_total_batch = gnn.num_symp // model_param["batch_size"] all_symp_index = np.arange(1, gnn.num_symp + 1) lambda_hard_r = lambda epoch: epoch * model_param[ "hard_ratio"] / model_param["num_epoch"] # build hard map and pos map symp2symp_hard_map = [0] symp2symp_pos_map = [0] for k in all_symp_index: symp2symp_b_ar = symp2symp_mat[k].toarray().flatten() max_index = np.argmax(symp2symp_b_ar) if max_index == 0: symp2symp_pos_map.append(np.random.randint(1, k)) symp2symp_hard_map.append(np.random.randint(1, k)) else: symp2symp_pos_map.append(max_index) symp2symp_b_ar[max_index] = -1 max_2nd_index = np.argmax(symp2symp_b_ar) if max_2nd_index == 0: symp2symp_hard_map.append(np.random.randint(1, k)) else: symp2symp_hard_map.append(max_2nd_index) symp2symp_hard_map = np.array(symp2symp_hard_map) symp2symp_pos_map = np.array(symp2symp_pos_map) print("Pos / Hard symptom map Inited.") optimizer = torch.optim.Adam(gnn.parameters(), lr=model_param["lr"], weight_decay=model_param["lr"]) last_total_loss = 1e10 for epoch in range(model_param["num_epoch"]): total_loss = 0 gnn.train() np.random.shuffle(all_symp_index) hard_ratio = lambda_hard_r(epoch) for idx in range(num_total_batch): batch_symp = all_symp_index[idx * model_param["batch_size"]:(idx + 1) * model_param["batch_size"]] # get pos symp and neg symp pos_symp = symp2symp_pos_map[batch_symp] # sample neg neg_symp = np.random.randint(1, gnn.num_symp, model_param["batch_size"]) # cope with overlapping in pos and neg symps overlap_index = (neg_symp == pos_symp) overlap_symp = neg_symp[overlap_index] neg_symp[overlap_index] = symp2symp_hard_map[overlap_symp] if hard_ratio > 0: num_hard = int(hard_ratio * model_param["batch_size"]) neg_symp[:num_hard] = symp2symp_hard_map[neg_symp[:num_hard]] batch_symp_ts = torch.LongTensor(batch_symp) pos_symp_ts = torch.LongTensor(pos_symp) neg_symp_ts = torch.LongTensor(neg_symp) if model_param["use_gpu"]: batch_symp_ts = batch_symp_ts.cuda() pos_symp_ts = pos_symp_ts.cuda() neg_symp_ts = neg_symp_ts.cuda() # forward batch symp batch_symp_data = sds_sampler(batch_symp, 1, 20) symp_emb = gnn.forward(batch_symp_ts, batch_symp_data) pos_symp_data = sds_sampler(pos_symp, 1, 20) pos_emb = gnn.forward(pos_symp_ts, pos_symp_data) neg_symp_data = sds_sampler(neg_symp, 1, 20) neg_emb = gnn.forward(neg_symp_ts, neg_symp_data) # create loss scores = symp_emb.mul(pos_emb).sum(1) - symp_emb.mul(neg_emb).sum( 1) + 1.0 scores[scores < 0] = 0 loss = scores.mean() optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() print("{} Epoch {}/{}: train loss: {:.6f}".format( now(), epoch + 1, model_param["num_epoch"], total_loss)) if total_loss - last_total_loss > 0: print("Loss stops to decrease, converge.") break last_total_loss = total_loss # save model torch.save(gnn.state_dict(), "./ckpt/sds_gnn.pt") print("Model saved.")
def test(args): setup_seed(2333) import warnings warnings.filterwarnings('ignore') if args.dataset == 'cub': num_classes = 100 elif args.dataset == 'tieredimagenet': num_classes = 351 else: num_classes = 64 if args.resume is not None: from models.resnet12 import resnet12 model = resnet12(num_classes).to(args.device) state_dict = torch.load(args.resume) model.load_state_dict(state_dict) model.to(args.device) model.eval() ici = ICI(classifier=args.classifier, num_class=args.num_test_ways, step=args.step, reduce=args.embed, d=args.dim) data_root = os.path.join(args.folder, args.dataset) dataset = DataSet(data_root, 'test', args.img_size) sampler = CategoriesSampler(dataset.label, args.num_batches, args.num_test_ways, (args.num_shots, 15, args.unlabel)) testloader = DataLoader(dataset, batch_sampler=sampler, shuffle=False, num_workers=0, pin_memory=True) k = args.num_shots * args.num_test_ways loader = tqdm(testloader, ncols=0) iterations = math.ceil(args.unlabel/args.step) + \ 2 if args.unlabel != 0 else math.ceil(15/args.step) + 2 acc_list = [[] for _ in range(iterations)] for data, indicator in loader: targets = torch.arange(args.num_test_ways).repeat( args.num_shots + 15 + args.unlabel).long()[ indicator[:args.num_test_ways * (args.num_shots + 15 + args.unlabel)] != 0] data = data[indicator != 0].to(args.device) train_inputs = data[:k] train_targets = targets[:k].cpu().numpy() test_inputs = data[k:k + 15 * args.num_test_ways] test_targets = targets[k:k + 15 * args.num_test_ways].cpu().numpy() train_embeddings = get_embedding(model, train_inputs, args.device) ici.fit(train_embeddings, train_targets) test_embeddings = get_embedding(model, test_inputs, args.device) if args.unlabel != 0: unlabel_inputs = data[k + 15 * args.num_test_ways:] unlabel_embeddings = get_embedding(model, unlabel_inputs, args.device) else: unlabel_embeddings = None acc = ici.predict(test_embeddings, unlabel_embeddings, True, test_targets) for i in range(min(iterations - 1, len(acc))): acc_list[i].append(acc[i]) acc_list[-1].append(acc[-1]) mean_list = [] ci_list = [] for item in acc_list: mean, ci = mean_confidence_interval(item) mean_list.append(mean) ci_list.append(ci) print("Test Acc Mean{}".format(' '.join( [str(i * 100)[:5] for i in mean_list]))) print("Test Acc ci{}".format(' '.join([str(i * 100)[:5] for i in ci_list])))
sta = torch.from_numpy(sta).cuda() x = self.net(fea, sta) return np.squeeze(x.data.detach().cpu().numpy()) def save(self,temp): temp = 'EP_'+str(self.epoch)+'_'+temp+'.pth' path = osp.join(self.cfg.EXP.PATH, temp) if (not self.cfg.TRAIN.USE_GPU) or (len(self.cfg.TRAIN.GPU_ID) == 1): to_saved_weight = self.net.state_dict() else: to_saved_weight = self.net.module.state_dict() toSave = { 'weights': to_saved_weight, 'epoch': self.epoch, 'batch': self.batch, 'bestacc': self.bestacc } torch.save(toSave, path) print('Model Saved!') if __name__ == "__main__": utils.setup_seed(cfg.SEED) #cfg.TRAIN.RESUME = True cfg.TRAIN.RESUME_PATH = '/opt/disk/zzy/project/DRL_lane/DRL_Code_TuSimple/DRL_Lane_Pytorch/exp/20-04-19-23-36_TuSimpleLane/EP_62_HitRat0.86465.pth' cfg.EXP.PATH = cfg.EXP.PATH+'_VAL_VIS' MyTrainer = trainer(cfg) acc = MyTrainer.val() print()
import os import numpy as np import time from utils import adjust_learning_rate, setup_seed from model import PSNet from dataset import CrowdCountingDataset # %matplotlib inline ################################################################################ # configuration ################################################################################ # set random seed for reproducibility manualSeed = 1 # manualSeed = random.randint(1, 10000) # use if you want new results # print("Random Seed: ", manualSeed) setup_seed(manualSeed) # choose to run on cpu or cuda device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # create a directory to store the model if not os.path.isdir('Checkpoint'): os.mkdir('Checkpoint') os.mkdir('Checkpoint/models') ################################################################################ # train PSNet model to generate density map ################################################################################ def train(): """ train model """
def train(**kwargs): w2v_model_name = "./ckpt/w2v" if os.path.exists(w2v_model_name): print("load word2vec model from", w2v_model_name) # load model directly w2v_model = Word2Vec.load(w2v_model_name) else: # load data filename = "./dataset/EHR/train/data.txt" fin = open(filename, "r") corpus = [] for line in fin.readlines(): corpus.append(line.strip().split()[2:]) # learn word2vec model start_time = time.time() w2v_model = Word2Vec(corpus, size=64, window=3, min_count=1, workers=4, sg=1) w2v_model.save("./ckpt/w2v") print("training done, costs {} secs.".format(time.time() - start_time)) # start training and testing the MLP model setup_seed(2020) model_param = default_config() model_param = parse_kwargs(model_param, kwargs) # load training data train_data = ehr.EHR("dataset/EHR", "train") train_data_loader = DataLoader(train_data, model_param["batch_size"], shuffle=True, num_workers=0, collate_fn=collate_fn) # load validation data val_data = ehr.EHR("dataset/EHR", "val") val_data_loader = DataLoader(val_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) # use data model to update model_param data_model_param = parse_data_model(train_data) model_param.update(data_model_param) use_gpu = model_param["use_gpu"] # let's build a MLP for prediction model_param["w2v_model"] = w2v_model model = MLP(**model_param) early_stopper = EarlyStopping(patience=model_param["early_stop"], larger_better=True) if model_param["use_gpu"]: model.cuda() print("Model Inited.") optimizer = torch.optim.Adam(model.parameters(), lr=model_param["lr"], weight_decay=kwargs["weight_decay"]) for epoch in range(model_param["num_epoch"]): total_loss = 0 model.train() for idx, (feat, dise) in enumerate(train_data_loader): pred = model.forward(feat) if model_param["use_gpu"]: label = torch.LongTensor(dise).cuda() else: label = torch.LongTensor(dise) # label is [1,2,3...,27] loss = F.cross_entropy(pred, label - 1) # multi-class xent loss optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() print("{} Epoch {}/{}: train loss: {:.6f}".format( now(), epoch + 1, model_param["num_epoch"], total_loss)) # do evaluation on recall and ndcg metric_result, eval_log, eval_result = evaluate_clf( model, val_data_loader, [5]) print("{} Epoch {}/{}: [Val] {}".format(now(), epoch + 1, model_param["num_epoch"], eval_log)) early_stopper(metric_result["ndcg_5"], model, "med2vec") if early_stopper.early_stop: print("[Early Stop] {} Epoch {}/{}: {}".format( now(), epoch + 1, model_param["num_epoch"], eval_log)) break # eval on test set # load test data test_data = ehr.EHR("dataset/EHR", "test") test_data_loader = DataLoader(test_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) test_metric, test_log, test_result = evaluate_clf(model, test_data_loader, top_k_list=[1, 3, 5, 10]) print("[Test] {}: {}".format(now(), test_log)) print("Training Done.") pass
def main(args): since = time.time() print(args) #set seed args.seed = utils.setup_seed(args.seed) utils.make_deterministic(args.seed) #setup the directory to save the experiment log and trained models log_dir = utils.setup_savedir(prefix=args.saveprefix, basedir=args.saveroot, args=args, append_args=args.saveargs) #save args utils.save_args(log_dir, args) #setup device device = utils.setup_device(args.gpu) #setup dataset and dataloaders dataset_dict = setup_dataset(args) dataloader_dict = setup_dataloader(args, dataset_dict) #setup backbone cnn num_classes = dataset_dict["train"].num_classes model = setup_backbone(args.backbone, pretrained=args.backbone_pretrained, num_classes=num_classes) #resume model if needed if args.resume is not None: model = utils.resume_model(model, args.resume, state_dict_key="model") #setup loss criterion = torch.nn.CrossEntropyLoss().to(device) if args.loss_balanced: print("using balanced loss") #if this optin is true, weight the loss inversely proportional to class frequency weight = torch.FloatTensor(dataset_dict["train"].inverse_label_freq) criterion = torch.nn.CrossEntropyLoss(weight=weight).to(device) #setup optimizer if args.optimizer == "adam": optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, amsgrad=True) elif args.optimizer == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) else: raise NotImplementedError() if args.resume_optimizer is not None: optimizer = utils.resume_model(optimizer, args.resume_optimizer, state_dict_key="optimizer") lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, patience=args.patience, factor=args.step_facter, verbose=True) #main training log = {} log["git"] = utils.check_gitstatus() log["timestamp"] = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") log["train"] = [] log["val"] = [] log["lr"] = [] log_save_path = os.path.join(log_dir, "log.json") utils.save_json(log, log_save_path) valacc = 0 best_val_acc = 0 bestmodel = model for epoch in range(args.epochs): print("epoch: %d --start from 0 and at most end at %d" % (epoch, args.epochs - 1)) loss, acc = train_one_epoch(dataloader_dict["train"], model, criterion, optimizer, accuracy=accuracy, device=device, print_freq=args.print_freq) log["train"].append({'epoch': epoch, "loss": loss, "acc": acc}) valloss, valacc = evaluate(dataloader_dict["val"], model, criterion, accuracy=accuracy, device=device) log["val"].append({'epoch': epoch, "loss": valloss, "acc": valacc}) lr_scheduler.step(valloss) #if this is the best model so far, keep it on cpu and save it if valacc > best_val_acc: best_val_acc = valacc log["best_epoch"] = epoch log["best_acc"] = best_val_acc bestmodel = deepcopy(model) bestmodel.cpu() if args.savemodel: save_path = os.path.join(log_dir, "bestmodel.pth") utils.save_checkpoint(save_path, bestmodel, key="model") save_path = os.path.join(log_dir, "bestmodel_optimizer.pth") utils.save_checkpoint(save_path, optimizer, key="optimizer") utils.save_json(log, log_save_path) max_lr_now = max([group['lr'] for group in optimizer.param_groups]) log["lr"].append(max_lr_now) if max_lr_now < args.lr_min: break #use the best model to evaluate on test set print("test started") loss, acc = evaluate(dataloader_dict["test"], bestmodel, criterion, accuracy=accuracy, device=device) log["test"] = {"loss": loss, "acc": acc} time_elapsed = time.time() - since log["time_elapsed"] = time_elapsed #save the final log utils.save_json(log, log_save_path)
import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader from apex import amp import albumentations as A import timm from sklearn.model_selection import StratifiedKFold from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix from torchsampler import ImbalancedDatasetSampler from utils.mixup import mixup_data, mixup_criterion from utils.loss.smooth import LabelSmoothingLoss from utils import make_file_path, setup_seed, Log modelpath, plotpath, outpath, starttime, basepath = make_file_path(__file__) setup_seed(seed) logger = print if "outpath" not in locals() else Log(locals()["outpath"]) logger(starttime) image_dir = f"./data/train256" dfs = [] for i, label in enumerate(sorted(os.listdir(image_dir))): # os.mkdir(os.path.join("./data/train256", label)) # for f in os.listdir(os.path.join(image_dir, label)): # img = Image.open(os.path.join(image_dir, label, f)).convert("RGB").resize((256, 256)) # img.save(os.path.join("./data/train256", label, f.replace("jpg", "png"))) df = pd.DataFrame({"image": [os.path.join(image_dir, label, f) for f in os.listdir(os.path.join(image_dir, label))]}) df["label_name"] = label df["label"] = i dfs.append(df) df = pd.concat(dfs).reset_index(drop = True)
help = 'the path of loading the generator') parser.add_argument('--env', type = str, \ default = 'PAGAN_crop_3', help = 'the name of env of visdom') parser.add_argument('--is_training', type = bool, \ default = False, help = 'train or test') return parser.parse_args() if __name__ == '__main__': # makeDir() # moveFiles() # moveFiles_test() opt = args() setup_seed(opt.manual_Seed) torch.backends.cudnn.benchmark = True if opt.ngpu > 1: device = torch.device('cuda' if torch.cuda.is_available else 'cpu') else: device = torch.device('cuda:0' if torch.cuda.is_available else 'cpu') if not os.path.exists(opt.model_dir): os.makedirs(opt.model_dir) if not os.path.exists(opt.train_img_dir): os.makedirs(opt.train_img_dir) if not os.path.exists(opt.test_img_dir): os.makedirs(opt.test_img_dir) if not os.path.exists(opt.val_img_dir): os.makedirs(opt.val_img_dir) if opt.is_training == True: gan = PAGAN()
def train(**kwargs): setup_seed(2020) model_param = default_config() model_param = parse_kwargs(model_param, kwargs) # load training data train_data = ehr.EHR("dataset/EHR", "train") train_data_loader = DataLoader(train_data, model_param["batch_size"], shuffle=True, num_workers=0, collate_fn=collate_fn) # load validation data val_data = ehr.EHR("dataset/EHR", "val") val_data_loader = DataLoader(val_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) # use data model to update model_param data_model_param = parse_data_model(train_data) model_param.update(data_model_param) use_gpu = model_param["use_gpu"] # init model model = TextCNN(**model_param) early_stopper = EarlyStopping(patience=model_param["early_stop"], larger_better=True) if model_param["use_gpu"]: model.cuda() print("Model Inited.") optimizer = torch.optim.Adam(model.parameters(), lr=model_param["lr"], weight_decay=0) for epoch in range(model_param["num_epoch"]): total_loss = 0 model.train() for idx, (feat, dise) in enumerate(train_data_loader): pred = model.forward(feat) if model_param["use_gpu"]: label = torch.LongTensor(dise).cuda() else: label = torch.LongTensor(dise) # label is [1,2,3...,27] loss = F.cross_entropy(pred, label - 1) # multi-class xent loss optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() print("{} Epoch {}/{}: train loss: {:.6f}".format( now(), epoch + 1, model_param["num_epoch"], total_loss)) # do evaluation on recall and ndcg metric_result, eval_log, eval_result = evaluate_clf( model, val_data_loader, [5]) print("{} Epoch {}/{}: [Val] {}".format(now(), epoch + 1, model_param["num_epoch"], eval_log)) early_stopper(metric_result["ndcg_5"], model, "textcnn") if early_stopper.early_stop: print("[Early Stop] {} Epoch {}/{}: {}".format( now(), epoch + 1, model_param["num_epoch"], eval_log)) break # eval on test set # load test data test_data = ehr.EHR("dataset/EHR", "test") test_data_loader = DataLoader(test_data, model_param["batch_size"], shuffle=False, num_workers=0, collate_fn=collate_fn) test_metric, test_log, test_result = evaluate_clf(model, test_data_loader, top_k_list=[1, 3, 5, 10]) print("[Test] {}: {}".format(now(), test_log)) print("Training Done.")
parser.add_argument('--output_dir', default='./exp_5shot/proto_exp1', type=str) parser.add_argument('--load', default='./exp_5shot/proto_exp1/best_model.pth.tar', type=str) parser.add_argument('--cnn', default='WideResNet', type=str) parser.add_argument('--batch', default=2000, type=int) parser.add_argument('--way', default=5, type=int) parser.add_argument('--shot', default=5, type=int) parser.add_argument('--query', default=15, type=int) parser.add_argument('--data_root', default='../dataset', type=str) parser.add_argument('--test_seed', default=111, type=int) args = parser.parse_args() os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id log_file_path = os.path.join(args.output_dir, 'test_log.txt') log(log_file_path, str(vars(args))) setup_seed(args.test_seed) test_set = BirdsDataset(root=args.data_root, mode='test') test_sampler = CategoriesSampler(test_set.label, args.batch, args.way, args.shot + args.query) test_loader = DataLoader(dataset=test_set, batch_sampler=test_sampler, num_workers=4, pin_memory=True) if args.cnn == 'WideResNet': import network.wideresnet as wideresnet base_net = wideresnet.WideResNet().cuda() else: print('No implementation!') exit()