def get_model(model_file=os.path.join(args.result_dir, 'mimic-kg-gp.ckpt')):
dataset = data_loader.DataBowl(args, phase='valid')
args.vocab = dataset.vocab
args.relation = dataset.relation
net, _ = model.FCModel(args), model.Loss()
net = _cuda(net)
net.load_state_dict(torch.load(model_file))
return net
def main():
dataset = data_loader.DataBowl(args, phase='train')
train_loader = DataLoader(dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
dataset = data_loader.DataBowl(args, phase='valid')
valid_loader = DataLoader(dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
args.vocab = dataset.vocab
args.relation = dataset.relation
# net, loss = model.Net(args), model.Loss()
net, loss = model.FCModel(args), model.Loss()
net = _cuda(net, 0)
loss = _cuda(loss, 0)
parameters_all = []
for p in net.parameters():
parameters_all.append(p)
optimizer = torch.optim.Adam(parameters_all, args.lr)
best_auc = [0, 0, 0, 0, 0, 0]
cui_con_dict = {}
if args.phase == 'train':
for epoch in range(args.epochs):
train(train_loader, net, loss, epoch, optimizer, best_auc)
best_auc, cui_con_dict = test(valid_loader, net, loss, epoch,
best_auc, 'valid', cui_con_dict)
print args.words
if 1:
cons_dir = '../result/cons/{:s}/{:d}'.format(
args.model, args.predict_day)
py_op.mkdir(cons_dir)
num = len(os.listdir(cons_dir))
py_op.mywritejson(os.path.join(cons_dir, '{:d}.json'.format(num)),
cui_con_dict)
# break
print 'best auc', best_auc
auc = best_auc[0]
with open('../result/log.txt', 'a') as f:
f.write('#model {:s} #auc {:3.4f}\n'.format(args.model, auc))
elif args.phase == 'test':
net.load_state_dict(torch.load(args.resume))
test(valid_loader, net, loss, 0, best_auc, 'valid', cui_con_dict)
def get_training_configs():
X = np.random.rand(10, 100)
Y = np.random.rand(10, 10)
net = model.FCModel(n_in_features=X.shape[1], n_out_features=Y.shape[1])
params = {
'n_epoch': 100,
'lr': 1e-3,
'beta': 0,
'batch_size': 8,
}
weight = np.array([1, 1, 1, 1, 1, 10., 3., 5., 2., 2.])
return net, X, Y, params, weight
def get_model(model_file, use_kg):
dataset = data_loader.DataBowl(args, phase='valid')
args.vocab = dataset.vocab
args.relation = dataset.relation
net, _ = model.FCModel(args, use_kg), model.Loss()
net = _cuda(net)
# return net
try:
net.load_state_dict(torch.load(model_file))
except:
# print(os.path.exists(model_file))
d = torch.load(model_file, map_location=torch.device('cpu'))
for k, v in d.items():
d[k] = v.cpu()
# print(k, type(v))
net.load_state_dict(d)
return net
def cross_validation_loop(X, Y, leave_out=5):
assert 1 <= leave_out <= 5 and type(leave_out) == int
n_features = X.shape[1]
n_targets = Y.shape[1]
assert len(X) == len(Y)
averaged_scores = {
'MSE': np.zeros((n_targets, )),
'feature_grad': np.zeros((n_targets, n_features)),
'feature_grad_abs': np.zeros((n_targets, n_features))
}
cross_validation_times = len(X) // leave_out
for i in range(cross_validation_times):
print("Leave %d out [%d/%d]" %
(leave_out, i + 1, cross_validation_times))
test_indices = [m for m in range(i * leave_out, (i + 1) * leave_out)]
train_indices = [i for i in range(len(X)) if i not in test_indices]
X_train = X[train_indices, :]
Y_train = Y[train_indices, :]
X_test = X[test_indices, :]
Y_test = Y[test_indices, :]
net = model.FCModel(n_in_features=X.shape[1],
n_out_features=Y.shape[1])
device = 'cuda:0' if torch.cuda.is_available() else "cpu"
net = net.to(device)
params = {
'n_epoch': 200,
'lr': 1e-2,
'beta': 0,
'batch_size': 8,
}
train.fit(net, X_train, Y_train, params, verbose=False)
scores = train.score(net, X_test, Y_test)
for k, v in scores.items():
averaged_scores[k] += scores[k] / cross_validation_times
return averaged_scores
def permutation_loop(X, Y, permutation_times=10):
n_features = X.shape[1]
n_targets = Y.shape[1]
assert len(X) == len(Y)
permutation_scores = {'performance_gain': np.zeros((n_targets, ))}
for i in range(permutation_times):
print("Permutation [%d/%d]" % (i + 1, permutation_times))
X_train, X_test, Y_train, Y_test = sklearn.model_selection.train_test_split(
X, Y, test_size=0.25)
net = model.FCModel(n_in_features=X.shape[1],
n_out_features=Y.shape[1])
device = 'cuda:0' if torch.cuda.is_available() else "cpu"
net = net.to(device)
params = {
'n_epoch': 200,
'lr': 1e-2,
'beta': 0,
'batch_size': 8,
}
train.fit(net, X_train, Y_train, params, verbose=False)
scores_on_original = train.score(net, X_test, Y_test)
perm_indices = np.arange(len(Y))
np.random.shuffle(perm_indices)
Y_shuffled = Y[perm_indices].copy()
X_train, X_test, Y_shuffled_train, Y_shuffled_test = sklearn.model_selection.train_test_split(
X, Y_shuffled, test_size=0.25)
train.fit(net, X_train, Y_shuffled_train, params, verbose=False)
scores_on_shuffled = train.score(net, X_test, Y_shuffled_test)
permutation_scores["performance_gain"] += (
scores_on_shuffled["MSE"] -
scores_on_original["MSE"]) * (1 / permutation_times)
return permutation_scores