def finetune(self, model, summary):
"""Finetune the given model on a "dataset" produced from chunks of the given summary.
Args:
model (BertForMaskedLM): a BERT for masked language modeling torch model
summary (str): the summary to finetune on
"""
model.train()
all_inputs = self.prepare_finetuning_data(summary)
input_batches = batch_data(all_inputs, self.finetune_batch_size)
no_decay = ["bias", "LayerNorm.weight"]
optimizer_grouped_parameters = [
{
"params": [
p for n, p in model.named_parameters()
if not any(nd in n for nd in no_decay)
],
"weight_decay":
1e-2,
},
{
"params": [
p for n, p in model.named_parameters()
if any(nd in n for nd in no_decay)
],
"weight_decay":
0.0,
},
]
optimizer = AdamW(optimizer_grouped_parameters,
lr=self.learning_rate,
eps=1e-8)
scheduler = get_linear_schedule_with_warmup(
optimizer,
num_warmup_steps=self.warmup_steps,
num_training_steps=len(input_batches) * self.finetune_epochs,
)
for epoch in range(self.finetune_epochs):
for input_batch in input_batches:
input_ids, attention_mask, token_type_ids, labels = get_input_tensors(
input_batch,
device=self.device,
tokenizer=self.model_tokenizer,
)
model.zero_grad()
optimizer.zero_grad()
loss, _ = model(
input_ids=input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
masked_lm_labels=labels,
)
loss.backward()
optimizer.step()
scheduler.step()
model.eval()
def mask_and_infer(self,
model,
docs,
doc_summaries,
loading_bar=True,
sep=None):
"""Run the given model on masked versions of the provided doc_summaries and collect model
output
Args:
model (BertForMaskedLM): a BERT for masked language modeling torch model
docs (List[str]): A list of input documents
doc_summaries (List[List[str]]): A list of summaries for every input document
loading_bar (bool): whether or not to use a tqdm loading bar to show progress
sep (str): Separator between the inference help (summary) and a sentence from the doc
Returns:
all_outputs (List[List[List[Dict[int, str]]]]): for each doc, for each summary for the
doc, for each input sequence for the summary, we have a dict mapping indices to
model predictions
all_answers (List[List[List[Dict[int, str]]]]): for each doc, for each summary for the
doc, for each input sequence for the summary, we have a dict mapping indices to
original tokens
"""
# Prepare inputs
all_inputs, all_answers = [], []
for doc, summaries in zip(docs, doc_summaries):
doc_inputs, doc_answers = [], []
for summary in summaries:
summary_inputs, summary_answers = self.get_inference_inputs(
doc, summary, sep)
doc_inputs.append(summary_inputs)
doc_answers.append(summary_answers)
all_inputs.append(doc_inputs)
all_answers.append(doc_answers)
# Run inference in batches
inputs_per_summary_per_doc = [[
len(inputs) for inputs in summary_input
] for summary_input in all_inputs]
collapsed_inputs = sum(sum(all_inputs, []), [])
batched_inputs = batch_data(collapsed_inputs,
self.inference_batch_size)
iterator = tqdm.tqdm(batched_inputs, disable=not loading_bar)
batched_outputs = [
self.run_inference_batch(model, batch) for batch in iterator
]
collapsed_outputs = sum(batched_outputs, [])
# Regroup outputs
i = 0
all_outputs = []
for inputs_per_summary in inputs_per_summary_per_doc:
doc_outputs = []
for num_inputs in inputs_per_summary:
doc_outputs.append(collapsed_outputs[i:i + num_inputs])
i += num_inputs
all_outputs.append(doc_outputs)
return all_outputs, all_answers
def discriminator_evaluate(self, query, target, batch_size=16):
"""Evaluate classification accuracy of discriminator for given inputs.
# Arguments
* `query` - the input images to perform facial recognition on
* `target` - the "known" faces that the queried images are compared to
* `batch_size` - the number of images to put in each batch, defaults to 16
"""
if self.device:
# compute in batches
accuracies = []
minibatches = utils.batch_data(query, target, batch_size=batch_size)
for idx, batch in enumerate(minibatches):
# collect batch and send to CUDA
batch_queries, batch_targets = batch
batch_queries = batch_queries.to(self.device)
batch_targets = batch_targets.to(self.device)
# get embeddings
target_embeddings = self.forward(batch_targets)
query_embeddings = self.forward(batch_queries)
# find distances between embeddings
target_embeddings = torch.unsqueeze(target_embeddings, 1)
query_embeddings = torch.unsqueeze(query_embeddings, 0)
distances = torch.norm(target_embeddings - query_embeddings, dim=2)
# classify queried images
classifications = torch.argmin(distances, dim=0) + (idx * batch_size)
id_range = torch.Tensor(
[(idx * batch_size) + i for i in range(batch_size)]
).to(self.device)
accuracies.append(sum(classifications == id_range) / batch_size)
# return batch to CPU
batch_queries = batch_queries.to(torch.device("cpu"))
batch_targets = batch_targets.to(torch.device("cpu"))
return sum(accuracies) / len(accuracies)
else:
# get embeddings
target_embeddings = self.forward(target)
query_embeddings = self.forward(query)
# find distances between embeddings
target_embeddings = torch.unsqueeze(target_embeddings, 1)
query_embeddings = torch.unsqueeze(query_embeddings, 0)
distances = torch.norm(target_embeddings - query_embeddings, dim=2)
# classify queried images and return accuracy
num_queries = query.shape[0]
classifications = torch.argmin(distances, dim=0)
accuracy = (
sum(classifications == torch.Tensor([i for i in range(num_queries)]))
/ num_queries
)
return accuracy
def extract_features(basenet, data_path):
"""
extract features from all fold of all sets for the CFCMC classifier
:param basenet:
:param data_path:
:return:
"""
sets = ['train', 'valid', 'test']
classes = [
'01_TUMOR', '02_STROMA', '03_COMPLEX', '04_LYMPHO', '05_DEBRIS',
'06_MUCOSA', '07_ADIPOSE', '08_EMPTY'
]
# create folders for features
for k in range(1, 11):
for set_name in sets:
for cl in classes:
path = os.path.join(data_path, f"{basenet}_features",
f"{k}_fold", set_name, cl)
if not os.path.exists(path):
os.makedirs(path)
for k in range(1, 11):
model = get_model_for_feature_extraction(kfold=k,
basenet=basenet,
pathbase=pathbase)
# par_model = multi_gpu_model(model, gpus=2)
for set_name in sets:
for cl in classes:
print(
f"Extracting from {k} fold from {set_name} set from class {cl}"
)
save_path = os.path.join(data_path, f"{basenet}_features",
f"{k}_fold", set_name, cl)
batches = utils.batch_data(
os.path.join(data_path, f"{k}_fold", set_name, cl), 16)
images = []
for id, files in enumerate(batches):
print("Detecting batches... " +
str(round((id * 100) / len(batches), 2)) + " %",
end="\r")
images = [skimage.io.imread(x) for x in files]
features = model.predict(np.array(images) / 255,
batch_size=16)
for _idx, feat in enumerate(features):
file_name = os.path.splitext(
os.path.basename(files[_idx]))[0]
save_file_path = os.path.join(save_path,
file_name + ".csv")
np.savetxt(save_file_path,
features[_idx],
delimiter=",")
K.clear_session()
del model
gc.collect()
def test_model():
# source_batch, target_batch = next(batch_data(X_test, y_test, batch_size))
print("测试")
acc_track = []
sum_test_conf = []
for batch_i, (source_batch, target_batch) in enumerate(
batch_data(X_test, y_test, batch_size)):
dec_input = np.zeros((len(source_batch), 1)) + char2numY['<GO>']
for i in range(y_seq_length):
batch_logits = sess.run(logits,
feed_dict={
inputs: source_batch,
dec_inputs: dec_input
})
prediction = batch_logits[:, -1].argmax(axis=-1)
dec_input = np.hstack([dec_input, prediction[:, None]])
acc_track.append(dec_input[:, 1:] == target_batch[:, 1:])
y_true = target_batch[:, 1:].flatten()
y_pred = dec_input[:, 1:].flatten()
sum_test_conf.append(
confusion_matrix(y_true,
y_pred,
labels=range(len(char2numY) - 1)))
sum_test_conf = np.mean(np.array(sum_test_conf, dtype=np.float32),
axis=0)
acc_avg, acc, sensitivity, specificity, PPV = evaluate_metrics(
sum_test_conf)
print('Average Accuracy is: {:>6.4f} on test set'.format(acc_avg))
info = ""
for index_ in range(n_classes):
print(
"\t{} rhythm -> Sensitivity: {:1.4f}, Specificity : {:1.4f}, Precision (PPV) : {:1.4f}, Accuracy : {:1.4f}"
.format(classes[index_], sensitivity[index_],
specificity[index_], PPV[index_], acc[index_]))
strings = "{:1.4f} {:1.4f} {:1.4f} {:1.4f}".format(
sensitivity[index_], specificity[index_], PPV[index_],
acc[index_])
info += strings
results.append(info)
print(
"\t Average -> Sensitivity: {:1.4f}, Specificity : {:1.4f}, Precision (PPV) : {:1.4f}, Accuracy : {:1.4f}"
.format(np.mean(sensitivity), np.mean(specificity), np.mean(PPV),
np.mean(acc)))
return acc_avg, acc, sensitivity, specificity, PPV
def test_model():
print('测试')
acc_track = []
sum_test_conf = []
for batch_i, (source_batch, target_batch) in enumerate(batch_data(X_test, y_test, batch_size)):
# dec_input = np.zeros((len(source_batch), 1)) + char2numY['<GO>']
batch_logits = sess.run(infer_logits,
feed_dict={
inputs: source_batch,
})
y_pred = batch_logits.argmax(axis=-1)
y_true = target_batch[:, 1:-1]
acc_track.append(y_pred == y_true)
# print('测试集预测值：', y_pred)
# print('测试集真实值：', y_true)
y_pred = y_pred.flatten()
y_true = y_true.flatten()
sum_test_conf.append(confusion_matrix(y_true, y_pred, labels=range(len(char2numY)-2)))
sum_test_conf = np.mean(np.array(sum_test_conf, dtype=np.float32), axis=0)
acc_avg, acc, sensitivity, specificity, PPV = evaluate_metrics(sum_test_conf)
print("Average Accuracy is: {:>6.4f} on test set\n".format(acc_avg))
info = ''
for index_ in range(n_classes):
print('\t {} rhythm -> Sensitivity(recall): {:1.4f}, Specificity: {:1.4f}, Precision(PPV): {:1.4f}, Accuracy: {:1.4f}'.format(
classes[index_],
sensitivity[index_],
specificity[index_],
PPV[index_],
acc[index_]
))
strings = "{:1.4f} {:1.4f} {:1.4f} {:1.4f}".format(sensitivity[index_], specificity[index_], PPV[index_], acc[index_])
info += strings
print('\n Average -> Sensitivity: {:1.4f}, Specificity: {:1.4f}, Precision: {:1.4f}, Accuracy: {:1.4f}'.format(
np.mean(sensitivity),
np.mean(specificity),
np.mean(PPV),
np.mean(acc)
))
results.append(info)
return acc_avg, acc, sensitivity, specificity, PPV
def evaluate(self, inputs, correct_classes, batch_size=16):
"""Evaluate classification accuracy of GAN for given inputs.
# Arguments
* `inputs` - a set of images of faces
* `correct_classes` - the correct IDs of every face
* `batch_size` - the number of images to put in each batch, defaults to 16
"""
# set model to eval mode
self.generator.eval()
if self.device:
# compute in batches
accuracies = []
minibatches = utils.batch_data(
inputs, correct_classes, batch_size=batch_size
)
for batch in minibatches:
# collect batch and send to CUDA
batch_inputs, batch_correct_classes = batch
batch_inputs = batch_inputs.to(self.device)
batch_correct_classes = batch_correct_classes.to(self.device)
# calculate classification accuracy
batch_outputs = self.forward(batch_inputs)
batch_output_classes = torch.argmin(batch_outputs, dim=1)
accuracies.append(
sum(batch_output_classes == batch_correct_classes)
/ len(batch_correct_classes)
)
# return batch to CPU
batch_inputs = batch_inputs.to(torch.device("cpu"))
batch_correct_classes = batch_correct_classes.to(torch.device("cpu"))
return sum(accuracies) / len(accuracies)
else:
# forward propagation
batch_outputs = self.forward(inputs)
# calculate classification accuracy
output_classes = torch.argmin(batch_outputs, dim=1)
accuracy = sum(output_classes == correct_classes) / len(correct_classes)
return accuracy
if dataset in ['protein', 'cora', 'citeseer', 'pubmed']:
train = sp.hstack([train, feats]).tolil()
print ae.summary()
# Specify some hyperparameters
epochs = 50
train_batch_size = 8
val_batch_size = 256
print('\nFitting autoencoder model...\n')
dummy = np.empty(shape=(adj.shape[0], 1))
y_true = dummy.copy()
mask = dummy.copy()
train_data = generate_data(adj, train, feats, y_true, mask, shuffle=True)
batch_data = batch_data(train_data, train_batch_size)
num_iters_per_train_epoch = adj.shape[0] / train_batch_size
for e in xrange(epochs):
print('\nEpoch {:d}/{:d}'.format(e + 1, epochs))
print('Learning rate: {:6f}'.format(K.eval(ae.optimizer.lr)))
curr_iter = 0
train_loss = []
for batch_adj, batch_train, batch_f, dummy_y, dummy_m in batch_data:
# Each iteration/loop is a batch of train_batch_size samples
if dataset in ['conflict', 'metabolic']:
batch_adj = StandardScaler().fit_transform(batch_adj)
res = ae.train_on_batch([batch_adj], [batch_train, batch_f])
else:
res = ae.train_on_batch([batch_adj], [batch_train])
train_loss.append(res)
curr_iter += 1
optim_g = g_opt.apply_gradients(optim_gen)
optim_dis = d_opt.compute_gradients(dis_loss, var_list=d_var_list)
optim_d = d_opt.apply_gradients(optim_dis)
# the optim operation
sample_gen = generator(x_place, reuse=True)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver(max_to_keep=1)
for epoch in range(train_epoch):
for idx in range(batch_idx):
start = time.time()
figs, labels = batch_data(idx)
feed_dict = {x_place: labels, y_place: figs}
sess.run(optim_d, feed_dict=feed_dict)
for i in range(1):
sess.run(optim_g, feed_dict=feed_dict)
gen_value, dis_value, l1_value = sess.run(
[gen_loss, dis_loss, gen_l1], feed_dict=feed_dict)
# compute cost time
end = time.time()
single_time = (end - start) / 60
total_time = single_time * train_epoch * batch_idx
remain_time = total_time - epoch * batch_idx * single_time - idx * single_time
with open(options.conll_dev, 'r') as conllFP:
devData = list(utils.read_conll(conllFP, parser.c2i))
conll_sentences = []
for sentence in devData:
conll_sentence = [
entry for entry in sentence
if isinstance(entry, utils.ConllEntry)
]
conll_sentences.append(conll_sentence)
with open("Results.txt", "a") as results:
results.write("Epoch\tUAS\tLAS\n")
sentences, train_batches = utils.batch_data(options.conll_train, c2i,
options.batch_tokens)
batches = len(train_batches)
highestScore = options.highest_score
tsId = 0
for epoch in range(options.last_epoch, options.epochs):
print("Starting epoch ", epoch + 1)
random.shuffle(train_batches)
for idx, mini_batch in enumerate(train_batches):
t_step = (epoch * batches) + idx + 1
if (t_step % 5000 == 0):
parser.Train(sentences, mini_batch, t_step, True)
else:
parser.Train(sentences, mini_batch, t_step)
crf=utils.loadModel('ckpts/crf.pkl')
print(crf)
predictTags=crf.test(devWordLists)
else:
crf=CRFModel()
crf.train(trainWordLists,trainTagLists)
utils.saveModel('ckpts/crf.pkl',crf)
predictTags=crf.test(devWordLists)
accuracy=metric.accuracy(predictTags,devTagList)
print('accuracy: ',accuracy)
#BiLSTM模型训练
print('BiLSTM************************')
if os.path.exists('ckpts/bilstm.pkl'):
model=utils.loadModel('ckpts/bilstm.pkl')
devWordLists, devTagList = utils.create('dev.txt', make_vocab=False)
devDatas = utils.batch_data(devWordLists, devTagList, word2id, tag2id)
id2tag = dict((id, tag) for tag, id in tag2id.items())
predictTags = []
while 1:
try:
x, y = devDatas.__next__()
predictScores = model(torch.LongTensor(x))
scores = torch.argmax(predictScores, dim=2, )
for i in range(len(scores)):
predictTag = []
for j in range(len(y[i])):
predictTag.append(id2tag[int(scores[i][j])])
predictTags.append(predictTag)
except:
break
acc = metric.accuracy(predictTags, devTagList)
if __name__ == "__main__":
d_worlds = 64
n_worlds = 32
batch_size = 32
n_epochs = 30
language = led_parser.propositional_language()
parser = led_parser.Parser(language)
n_symbols = len(language.symbols)
cell = Sat3Cell(n_symbols, d_worlds, n_worlds, batch_size)
encoder = TreeNets(cell, n_worlds, batch_size)
PWN = PossibleWorldsNet(parser, encoder, n_worlds, d_worlds)
optimizer = tf.keras.optimizers.Adam()
for i in range(n_epochs):
print(i)
for A, B, y in utils.batch_data(utils.read_data('../Logical_Entailment/temp/train.txt'), batch_size):
loss, grads, p = compute_step(PWN, A, B, y)
gradients = zip(grads, PWN.trainable_variables)
optimizer.apply_gradients(gradients)
logging.info('loss: {}'.format(tf.reduce_mean(loss)))
for A, B, y in utils.batch_data(utils.read_data('../Logical_Entailment/temp/validate.txt'), batch_size):
acc = np.mean([accuracy(y, PWN(A, B))])
logging.info('accuracy: {}'.format(acc))
def train(args):
max_time = args.max_time # defaule 9
epochs = args.epochs # 1000
batch_size = args.batch_size # 20
num_units = args.num_units # 128
bidirectional = args.bidirectional
n_oversampling = args.n_oversample
checkpoint_dir = args.checkpoint_dir
result_dir = args.result_dir
ckpt_name = args.ckpt_name
test_steps = args.test_steps
classes = args.classes # ['N', 'S','V']
filename = args.data_dir
use_SE = args.use_SE
X_train, y_train, X_test, y_test, n_classes, char2numY, input_depth, y_seq_length\
= data_process(max_time, n_oversampling, classes, filename)
my_model = model()
inputs, targets, dec_inputs = my_model.model_input(max_time=max_time,
input_depth=input_depth)
logits, infer_logits = my_model.Attention_seq2seq(num_units=num_units,
batch_size=batch_size,
char2numY=char2numY,
inputs=inputs,
dec_inputs=dec_inputs,
n_channels=10,
input_depth=input_depth,
max_time=max_time,
bidirectional=bidirectional,
use_SE=use_SE)
with tf.variable_scope("optimization", reuse=tf.AUTO_REUSE):
vars = tf.trainable_variables()
beta = 0.001
lossL2 = tf.add_n([tf.nn.l2_loss(v) for v in vars if 'bias' not in v.name]) * beta
loss = tf.contrib.seq2seq.sequence_loss(logits, targets, tf.ones([batch_size, y_seq_length]))
# optimizer
loss = tf.reduce_mean(loss + lossL2)
optimizer = tf.train.RMSPropOptimizer(1e-3).minimize(loss)
results = []
def test_model():
print('测试')
acc_track = []
sum_test_conf = []
for batch_i, (source_batch, target_batch) in enumerate(batch_data(X_test, y_test, batch_size)):
# dec_input = np.zeros((len(source_batch), 1)) + char2numY['<GO>']
batch_logits = sess.run(infer_logits,
feed_dict={
inputs: source_batch,
})
y_pred = batch_logits.argmax(axis=-1)
y_true = target_batch[:, 1:-1]
acc_track.append(y_pred == y_true)
# print('测试集预测值：', y_pred)
# print('测试集真实值：', y_true)
y_pred = y_pred.flatten()
y_true = y_true.flatten()
sum_test_conf.append(confusion_matrix(y_true, y_pred, labels=range(len(char2numY)-2)))
sum_test_conf = np.mean(np.array(sum_test_conf, dtype=np.float32), axis=0)
acc_avg, acc, sensitivity, specificity, PPV = evaluate_metrics(sum_test_conf)
print("Average Accuracy is: {:>6.4f} on test set\n".format(acc_avg))
info = ''
for index_ in range(n_classes):
print('\t {} rhythm -> Sensitivity(recall): {:1.4f}, Specificity: {:1.4f}, Precision(PPV): {:1.4f}, Accuracy: {:1.4f}'.format(
classes[index_],
sensitivity[index_],
specificity[index_],
PPV[index_],
acc[index_]
))
strings = "{:1.4f} {:1.4f} {:1.4f} {:1.4f}".format(sensitivity[index_], specificity[index_], PPV[index_], acc[index_])
info += strings
print('\n Average -> Sensitivity: {:1.4f}, Specificity: {:1.4f}, Precision: {:1.4f}, Accuracy: {:1.4f}'.format(
np.mean(sensitivity),
np.mean(specificity),
np.mean(PPV),
np.mean(acc)
))
results.append(info)
return acc_avg, acc, sensitivity, specificity, PPV
def count_pramaters():
print('# of params:', np.sum([np.prod(v.get_shape().as_list()) for v in tf.trainable_variables()]))
count_pramaters()
mkdir(result_dir)
mkdir(checkpoint_dir)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
saver = tf.train.Saver()
print(str(datetime.now()))
pre_acc_avg = 0.0
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
ckpt_name = os.path.basename(ckpt.model_checkpoint_path)
saver.restore(sess, tf.train.latest_checkpoint(checkpoint_dir))
test_model()
else:
losses = []
loss_track = []
for epoch_i in range(epochs):
start_time = time.time()
train_acc = []
for batch_i, (source_batch, target_batch) in enumerate(batch_data(X_train, y_train, batch_size)):
_, batch_loss, batch_logits = sess.run([optimizer, loss, logits],
feed_dict = {
inputs: source_batch,
dec_inputs: target_batch[:, :-2],
targets: target_batch[:, 1:-1]
})
loss_track.append(batch_loss)
train_acc.append(batch_logits.argmax(axis=-1) == target_batch[:, 1:-1])
# print('训练预测', batch_logits.argmax(axis=-1))
# print('训练真实值', target_batch[:, 1:-1])
accuracy = np.mean(train_acc)
print('Epoch {:3} Loss:{:>6.3f} Accuracy:{:>6.4f} Epoch duration:{:>6.3f}'.format(
epoch_i,
sum(loss_track)/len(loss_track),
accuracy,
time.time() - start_time
))
losses.append(sum(loss_track) / len(loss_track))
if (epoch_i + 1) % test_steps == 0:
acc_avg, acc, sensitivity, specificity, PPV = test_model() # 输出测试结果
print("loss:{:.4f} after {} epochs (batch_size={})".format(loss_track[-1], epoch_i + 1, batch_size))
save_path = os.path.join(checkpoint_dir, ckpt_name)
saver.save(sess, save_path)
print("Model saved in path:%s" % save_path)
with open(os.path.join(result_dir, "loss.txt"), mode="w") as f: # 保存loss
for l in losses:
f.write(str(l) + "\n")
with open(os.path.join(result_dir, "infos.txt"), mode='w') as f: # 保存每一次测结果
for info in results:
f.write(info + "\n")
print(str(datetime.now()))
def run_program(args):
max_time = args.max_time # defaule 9
epochs = args.epochs # 1000
batch_size = args.batch_size # 20
num_units = args.num_units # 128
bidirectional = args.bidirectional
use_Embedding = args.use_Embedding # 是否对输出进行Embedding，否的话进行标准化输入
use_SE = args.use_SE
n_oversampling = args.n_oversample
checkpoint_dir = args.checkpoint_dir
ckpt_name = args.ckpt_name
test_steps = args.test_steps
classes = args.classes # ['N', 'S','V']
filename = args.data_dir
result_dir = args.result_dir # 用于保存每次结果
print(use_Embedding,
"==============++++++++++++++++++++++=+++++++++++++++++")
X_train, y_train, X_test, y_test, n_classes, char2numY, input_depth, y_seq_length \
= data_process(max_time, n_oversampling, classes, filename, use_Embedding)
# Placeholders
inputs = tf.placeholder(tf.float32, [None, max_time, input_depth],
name='inputs')
targets = tf.placeholder(tf.int32, (None, None), 'targets')
dec_inputs = tf.placeholder(tf.int32, (None, None), 'output')
logits = build_network(inputs,
dec_inputs,
char2numY,
n_channels=10,
input_depth=input_depth,
num_units=num_units,
max_time=max_time,
bidirectional=bidirectional,
use_Embedding=use_Embedding,
use_SE=use_SE)
with tf.variable_scope("optimization", reuse=tf.AUTO_REUSE):
# with tf.name_scope("optimization"):
# Loss function
vars = tf.trainable_variables()
beta = 0.001
lossL2 = tf.add_n(
[tf.nn.l2_loss(v) for v in vars if 'bias' not in v.name]) * beta
loss = tf.contrib.seq2seq.sequence_loss(
logits, targets, tf.ones([batch_size, y_seq_length]))
# Optimizer
loss = tf.reduce_mean(loss + lossL2)
optimizer = tf.train.RMSPropOptimizer(1e-3).minimize(loss)
results = []
def test_model():
# source_batch, target_batch = next(batch_data(X_test, y_test, batch_size))
print("测试")
acc_track = []
sum_test_conf = []
for batch_i, (source_batch, target_batch) in enumerate(
batch_data(X_test, y_test, batch_size)):
dec_input = np.zeros((len(source_batch), 1)) + char2numY['<GO>']
for i in range(y_seq_length):
batch_logits = sess.run(logits,
feed_dict={
inputs: source_batch,
dec_inputs: dec_input
})
prediction = batch_logits[:, -1].argmax(axis=-1)
dec_input = np.hstack([dec_input, prediction[:, None]])
acc_track.append(dec_input[:, 1:] == target_batch[:, 1:])
y_true = target_batch[:, 1:].flatten()
y_pred = dec_input[:, 1:].flatten()
sum_test_conf.append(
confusion_matrix(y_true,
y_pred,
labels=range(len(char2numY) - 1)))
sum_test_conf = np.mean(np.array(sum_test_conf, dtype=np.float32),
axis=0)
acc_avg, acc, sensitivity, specificity, PPV = evaluate_metrics(
sum_test_conf)
print('Average Accuracy is: {:>6.4f} on test set'.format(acc_avg))
info = ""
for index_ in range(n_classes):
print(
"\t{} rhythm -> Sensitivity: {:1.4f}, Specificity : {:1.4f}, Precision (PPV) : {:1.4f}, Accuracy : {:1.4f}"
.format(classes[index_], sensitivity[index_],
specificity[index_], PPV[index_], acc[index_]))
strings = "{:1.4f} {:1.4f} {:1.4f} {:1.4f}".format(
sensitivity[index_], specificity[index_], PPV[index_],
acc[index_])
info += strings
results.append(info)
print(
"\t Average -> Sensitivity: {:1.4f}, Specificity : {:1.4f}, Precision (PPV) : {:1.4f}, Accuracy : {:1.4f}"
.format(np.mean(sensitivity), np.mean(specificity), np.mean(PPV),
np.mean(acc)))
return acc_avg, acc, sensitivity, specificity, PPV
def count_prameters():
print(
'# of Params: ',
np.sum([
np.prod(v.get_shape().as_list())
for v in tf.trainable_variables()
]))
count_prameters()
mkdir(result_dir)
mkdir(checkpoint_dir)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
saver = tf.train.Saver()
print(str(datetime.now()))
pre_acc_avg = 0.0
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
# # Restore
ckpt_name = os.path.basename(ckpt.model_checkpoint_path)
# saver.restore(session, os.path.join(checkpoint_dir, ckpt_name))
saver.restore(sess, tf.train.latest_checkpoint(checkpoint_dir))
# or 'load meta graph' and restore weights
# saver = tf.train.import_meta_graph(ckpt_name+".meta")
# saver.restore(session,tf.train.latest_checkpoint(checkpoint_dir))
test_model()
else:
losses = []
loss_track = []
for epoch_i in range(epochs):
start_time = time.time()
train_acc = []
for batch_i, (source_batch, target_batch) in enumerate(
batch_data(X_train, y_train, batch_size)):
_, batch_loss, batch_logits = sess.run(
[optimizer, loss, logits],
feed_dict={
inputs: source_batch,
dec_inputs: target_batch[:, :-1],
targets: target_batch[:, 1:]
})
loss_track.append(batch_loss)
train_acc.append(
batch_logits.argmax(axis=-1) == target_batch[:, 1:])
accuracy = np.mean(train_acc)
print(
'Epoch {:3} Loss: {:>6.3f} Accuracy: {:>6.4f} Epoch duration: {:>6.3f}s'
.format(epoch_i,
sum(loss_track) / len(loss_track), accuracy,
time.time() - start_time))
losses.append(sum(loss_track) / len(loss_track))
if epoch_i % test_steps == 0:
acc_avg, acc, sensitivity, specificity, PPV = test_model()
print('loss {:.4f} after {} epochs (batch_size={})'.format(
loss_track[-1], epoch_i + 1, batch_size))
save_path = os.path.join(checkpoint_dir, ckpt_name)
saver.save(sess, save_path)
print("Model saved in path: %s" % save_path)
with open(os.path.join(result_dir, "loss.txt"),
mode="w") as f: # 保存loss
for l in losses:
f.write(str(l) + "\n")
with open(os.path.join(result_dir, "infos.txt"),
mode='w') as f: # 保存每一次测结果
for info in results:
f.write(info + "\n")
print(str(datetime.now()))
