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()
