# pdb.set_trace()
word_ids, W_list = process_data.getWordsVect(W)
# use static train or not
static_falg = args.static_flag
# use shuffer the data or not
shuffer_falg = args.shuffer_flag
#交叉验证
results = []
for index in tqdm(range(10)):
#打调试断点
# pdb.set_trace()
# train_x, train_y, test_x, test_y = process_data.get_train_test_data1(W,revs,index,sentence_max_len,default_values=0.0,vec_size=300)
train_x, train_y, test_x, test_y = process_data.get_train_test_data2(
word_ids, revs, index, sentence_max_len)
# step3 create TextCNN model
text_cnn = TextCNN(W_list, shuffer_falg, static_falg, filter_numbers,
filter_sizes, sentence_max_len, embedding_size,
args.learnrate, args.epochs, args.batch_size,
args.dropout_pro)
# step4 start train
text_cnn.train(train_x, train_y)
# step5 validataion
accur, loss = text_cnn.validataion(test_x, test_y)
#
results.append(accur)
print('cv {} accur is :{:.3f} loss is {:.3f}'.format(
index + 1, accur, loss))
text_cnn.close()
print('last accuracy is {}'.format(np.mean(results)))
# 2.Data preprocessing: Sequence padding
print("start padding....")
testX2 = pad_sequences(testX, maxlen=FLAGS.sentence_len,
value=0.) # padding to max length
print("end padding...")
# 3.create session.
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
graph = tf.Graph().as_default()
global sess
global textCNN
with graph:
sess = tf.Session(config=config)
# 4.Instantiate Model
textCNN = TextCNN(filter_sizes, FLAGS.num_filters, FLAGS.num_classes,
FLAGS.learning_rate, FLAGS.batch_size, FLAGS.decay_steps,
FLAGS.decay_rate, FLAGS.sentence_len, vocab_size,
FLAGS.embed_size, FLAGS.is_training)
saver = tf.train.Saver()
if os.path.exists(FLAGS.ckpt_dir + "checkpoint"):
print("Restoring Variables from Checkpoint")
saver.restore(sess, tf.train.latest_checkpoint(FLAGS.ckpt_dir))
else:
print("Can't find the checkpoint.going to stop")
#return
# 5.feed data, to get logits
number_of_training_data = len(testX2)
print("number_of_training_data:", number_of_training_data)
#index = 0
#predict_target_file_f = codecs.open(FLAGS.predict_target_file, 'a', 'utf8')
def main(_):
# 1.load data with vocabulary of words and labels
vocabulary_word2index, vocabulary_index2word = create_voabulary(
simple='simple',
word2vec_model_path=FLAGS.word2vec_model_path,
name_scope="cnn2")
vocab_size = len(vocabulary_word2index)
vocabulary_word2index_label, vocabulary_index2word_label = create_voabulary_label(
name_scope="cnn2")
questionid_question_lists = load_final_test_data(FLAGS.predict_source_file)
test = load_data_predict(vocabulary_word2index,
vocabulary_word2index_label,
questionid_question_lists)
testX = []
question_id_list = []
for tuple in test:
question_id, question_string_list = tuple
question_id_list.append(question_id)
testX.append(question_string_list)
# 2.Data preprocessing: Sequence padding
print("start padding....")
testX2 = pad_sequences(testX, maxlen=FLAGS.sentence_len,
value=0.) # padding to max length
print("end padding...")
# 3.create session.
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
# 4.Instantiate Model
textCNN = TextCNN(filter_sizes, FLAGS.num_filters, FLAGS.num_classes,
FLAGS.learning_rate, FLAGS.batch_size,
FLAGS.decay_steps, FLAGS.decay_rate,
FLAGS.sentence_len, vocab_size, FLAGS.embed_size,
FLAGS.is_training)
saver = tf.train.Saver()
if os.path.exists(FLAGS.ckpt_dir + "checkpoint"):
print("Restoring Variables from Checkpoint")
saver.restore(sess, tf.train.latest_checkpoint(FLAGS.ckpt_dir))
else:
print("Can't find the checkpoint.going to stop")
return
# 5.feed data, to get logits
number_of_training_data = len(testX2)
print("number_of_training_data:", number_of_training_data)
index = 0
predict_target_file_f = codecs.open(FLAGS.predict_target_file, 'a',
'utf8')
for start, end in zip(
range(0, number_of_training_data, FLAGS.batch_size),
range(FLAGS.batch_size, number_of_training_data + 1,
FLAGS.batch_size)):
logits = sess.run(textCNN.logits,
feed_dict={
textCNN.input_x: testX2[start:end],
textCNN.dropout_keep_prob: 1
}) #'shape of logits:', ( 1, 1999)
# 6. get lable using logtis
predicted_labels = get_label_using_logits(
logits[0], vocabulary_index2word_label)
# 7. write question id and labels to file system.
write_question_id_with_labels(question_id_list[index],
predicted_labels,
predict_target_file_f)
index = index + 1
predict_target_file_f.close()
def create_model(self):
model = TextCNN(config=self.config,
vocab_size=self.train_data_obj.vocab_size)
return model
def main(_):
trainX, trainY, testX, testY = None, None, None, None
word2vec_model = gensim.models.KeyedVectors.load_word2vec_format(
FLAGS.word2vec_model_path, binary=False)
# word2vec_index2word = word2vec_model.index2word
# vocab_size = len(word2vec_index2word)
num_classes = FLAGS.num_classes
review, sentiment = load_data_for_text_cnn(data_path +
"labeledTrainData.tsv",
word2vec_model,
is_training=True)
trainX, trainY = review[0:int(len(review) *
FLAGS.rate_data_train)], sentiment[0:int(
len(review) * FLAGS.rate_data_train)]
testX, testY = review[int(len(review) *
FLAGS.rate_data_train):len(review)], sentiment[
int(len(review) *
FLAGS.rate_data_train):len(review)]
#print some message for debug purpose
print("length of training data:", len(trainX),
";length of validation data:", len(testX))
print("trainX[0]:", trainX[0])
print("trainY[0]:", trainY[0])
train_y_short = get_target_label_short(trainY[0])
print("train_y_short:", train_y_short)
#2.create session.
# config=tf.ConfigProto()
# config.gpu_options.allow_growth=True
# with tf.Session(config=config) as sess:
with tf.Session() as sess:
#Instantiate Model
textCNN = TextCNN(filter_sizes,
FLAGS.num_filters,
num_classes,
FLAGS.learning_rate,
FLAGS.batch_size,
FLAGS.decay_steps,
FLAGS.decay_rate,
FLAGS.sentence_len,
FLAGS.vocab_size,
FLAGS.embed_size,
is_training=True)
#Initialize Save
saver = tf.train.Saver()
if os.path.exists(FLAGS.ckpt_dir + "checkpoint"):
print("Restoring Variables from Checkpoint.")
saver.restore(sess, tf.train.latest_checkpoint(FLAGS.ckpt_dir))
#for i in range(3): #decay learning rate if necessary.
# print(i,"Going to decay learning rate by half.")
# sess.run(textCNN.learning_rate_decay_half_op)
else:
print('Initializing Variables')
sess.run(tf.global_variables_initializer())
if FLAGS.use_embedding: #load pre-trained word embedding
assign_pretrained_word_embedding(sess, textCNN, word2vec_model)
curr_epoch = sess.run(textCNN.epoch_step)
#3.feed data & training
number_of_training_data = len(trainX)
batch_size = FLAGS.batch_size
iteration = 0
for epoch in range(curr_epoch, FLAGS.num_epochs):
loss, counter = 0.0, 0
for start, end in zip(
range(0, number_of_training_data, batch_size),
range(batch_size, number_of_training_data, batch_size)):
iteration = iteration + 1
if epoch == 0 and counter == 0:
print("trainX[start:end]:", trainX[start:end])
feed_dict = {
textCNN.input_x: trainX[start:end],
textCNN.dropout_keep_prob: 0.5,
textCNN.iter: iteration,
textCNN.tst: not FLAGS.is_training
}
feed_dict[textCNN.input_y] = trainY[start:end]
curr_loss, lr, _, _ = sess.run([
textCNN.loss_val, textCNN.learning_rate,
textCNN.update_ema, textCNN.train_op
], feed_dict)
loss, counter = loss + curr_loss, counter + 1
if counter % 50 == 0:
print(
"Epoch %d\tBatch %d\tTrain Loss:%.3f\tLearning rate:%.5f"
% (epoch, counter, loss / float(counter), lr))
########################################################################################################
if start % (2000 *
FLAGS.batch_size) == 0: # eval every 3000 steps.
eval_loss, f1_score, precision, recall = do_eval(
sess, textCNN, testX, testY, iteration)
print(
"Epoch %d Validation Loss:%.3f\tF1 Score:%.3f\tPrecision:%.3f\tRecall:%.3f"
% (epoch, eval_loss, f1_score, precision, recall))
# save model to checkpoint
save_path = FLAGS.ckpt_dir + "model.ckpt"
saver.save(sess, save_path, global_step=epoch)
########################################################################################################
#epoch increment
print("going to increment epoch counter....")
sess.run(textCNN.epoch_increment)
# 4.validation
print(epoch, FLAGS.validate_every,
(epoch % FLAGS.validate_every == 0))
if epoch % FLAGS.validate_every == 0:
eval_loss, f1_score, precision, recall = do_eval(
sess, textCNN, testX, testY, iteration)
print(
"Epoch %d Validation Loss:%.3f\tF1 Score:%.3f\tPrecision:%.3f\tRecall:%.3f"
% (epoch, eval_loss, f1_score, precision, recall))
#save model to checkpoint
save_path = FLAGS.ckpt_dir + "model.ckpt"
saver.save(sess, save_path, global_step=epoch)
# 5.最后在测试集上做测试，并报告测试准确率 Test
test_loss, _, _, _ = do_eval(sess, textCNN, testX, testY, iteration)
print("Test Loss:%.3f" % (test_loss))
pass
# print("Vocabulary Size: {:d}".format(len(vocab_processor.vocabulary_)))
# print("Train/Dev split: {:d}/{:d}".format(len(y_train), len(y_dev)))
# Training
# ==================================================
with tf.Graph().as_default():
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default():
cnn = TextCNN(
feature_size=x_train.shape[1],
num_classes=FLAGS.n_class,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
l2_reg_lambda=FLAGS.l2_reg_lambda)
# Define Training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(1e-3)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step)
# Keep track of gradient values and sparsity (optional)
grad_summaries = []
for g, v in grads_and_vars:
if g is not None:
grad_hist_summary = tf.histogram_summary("{}/grad/hist".format(v.name), g)
sparsity_summary = tf.scalar_summary("{}/grad/sparsity".format(v.name), tf.nn.zero_fraction(g))
train_data_wrapper = data_util.DataWrapper(x_train, y_train, istrain=True)
valid_data_wrapper = data_util.DataWrapper(x_valid, y_valid, istrain=True)
test_data_wrapper = data_util.DataWrapper(x_valid, y_valid, istrain=False)
print('---> build model')
# Built model and start training
# ==================================================
with tf.Graph().as_default(), tf.device('/gpu:2'):
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
session = tf.Session(config=session_conf)
with session.as_default():
text_cnn = TextCNN(embedding_dim=embedding_dimension,
sequence_length=max_document_length,
label_size=2,
vocabulary_size=vocabulary_size,
filter_sizes=FLAGS.filter_sizes,
num_filters=FLAGS.num_filters,
embedding_trainable=False,
l2_reg_lambda=FLAGS.l2_reg_lambda)
# Define global training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(
learning_rate=text_cnn.learning_rate)
# train_op = optimizer.minimize(text_cnn.loss, global_step=global_step)
grads_and_vars = optimizer.compute_gradients(
text_cnn.loss
) # Compute gradients of `loss` for the variables in `var_list`.
# some other operation to grads_and_vars, eg. cap the gradient
# ...
train_op = optimizer.apply_gradients(
# print("Vocabulary Size: {:d}".format(len(vocab_processor.vocabulary_)))
# print("Train/Dev split: {:d}/{:d}".format(len(y_train), len(y_dev)))
# Training
# ==================================================
with tf.Graph().as_default():
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default():
cnn = TextCNN(sequence_length=x_train.shape[1],
num_classes=FLAGS.n_class,
vocab_size=len(vocab_processor.vocabulary_),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int,
FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
l2_reg_lambda=FLAGS.l2_reg_lambda)
# Define Training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(1e-3)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
# Keep track of gradient values and sparsity (optional)
grad_summaries = []
for g, v in grads_and_vars:
if g is not None: