def train_epoch(self, train_set, valid_data, epoch, shuffle=True):
if shuffle:
random.shuffle(train_set)
train_set = batchnize_dataset(train_set, self.cfg.batch_size)
num_batches = len(train_set)
prog = Progbar(target=num_batches)
for i, batch_data in enumerate(train_set):
feed_dict = self._get_feed_dict(
batch_data,
emb_keep_prob=self.cfg["emb_keep_prob"],
rnn_keep_prob=self.cfg["rnn_keep_prob"],
attn_keep_prob=self.cfg["attn_keep_prob"],
is_train=True,
lr=self.cfg["lr"])
_, train_loss, summary = self.sess.run(
[self.train_op, self.loss, self.summary], feed_dict=feed_dict)
cur_step = (epoch - 1) * num_batches + (i + 1)
prog.update(i + 1, [("Global Step", int(cur_step)),
("Train Loss", train_loss)])
self.train_writer.add_summary(summary, cur_step)
if i % 100 == 0:
valid_feed_dict = self._get_feed_dict(valid_data)
valid_summary = self.sess.run(self.summary,
feed_dict=valid_feed_dict)
self.test_writer.add_summary(valid_summary, cur_step)
def play_with_model(mode):
# build tf flags
tf_config = create_configurations()
# process dataset
if not os.path.exists(tf_config["save_dir"]) or not os.listdir(
tf_config["save_dir"]):
sys.stdout.write(
"No preprocessed dataset found, create from {} raw data...\n".
format(tf_config["dataset_name"]))
sys.stdout.flush()
process_europarl(tf_config)
# create configurations
sys.stdout.write("Load configurations...\n")
sys.stdout.flush()
config = Config(tf_config)
if mode == "train":
# prepare training dataset batches
sys.stdout.write("Load dataset and create batches...\n")
sys.stdout.flush()
train_batches, test_batches = batchnize_dataset(
tf_config["dataset"], config.batch_size, config.target_dict)
# build model and start training
sys.stdout.write("Building model...\n")
sys.stdout.flush()
seq2seq_model = SequenceToSequence(config, mode="train")
seq2seq_model.train(train_batches, test_batches, epochs=config.epochs)
elif mode == "decode":
# build model and start training
sys.stdout.write("Building model...\n")
sys.stdout.flush()
seq2seq_model = SequenceToSequence(config, mode="decode")
seq2seq_model.restore_last_session()
sys.stdout.write("> ")
sys.stdout.flush()
top_n = False # if beam search, return all decoded results or just the first one
source_language = "french" if tf_config["fr_to_en"] else "english"
sentence = sys.stdin.readline()
sent_ids = sentence_to_ids(sentence, config.source_dict,
source_language, tf_config["lower"],
tf_config["keep_number"])
while sentence:
predict_ids = seq2seq_model.inference(sent_ids)
response = ids_to_sentence(
predict_ids, config.rev_target_dict,
config.target_dict)[0] # batch_size == 1
print(response)
if top_n:
print("\n".join(response))
else:
print(response[0])
sys.stdout.write("> ")
sys.stdout.flush()
sentence = sys.stdin.readline()
sent_ids = sentence_to_ids(sentence, config.source_dict,
source_language, tf_config["lower"],
tf_config["keep_number"])
else:
raise ValueError(
"ERROR: Unknown mode name {}, support modes: (train | decode)".
format(mode))
def read_dataset_helper(self, file_dict, dataset_name): dataset = dict() print(len(file_dict['train'])) print(len(file_dict['dev'])) print(len(file_dict['test'])) train_set = batchnize_dataset(file_dict['train'], self.config["batch_size"], shuffle=True) # used for computing validate loss valid_data = batchnize_dataset(file_dict['dev'], batch_size=1000, shuffle=True)[0] # used for computing validate accuracy, precision, recall and F1 scores valid_set = batchnize_dataset(file_dict['dev'], self.config["batch_size"], shuffle=False) # used for computing test accuracy, precision, recall and F1 scores test_set = batchnize_dataset(file_dict['test'], self.config["batch_size"], shuffle=False) dataset["train_set"] = train_set dataset["dev_data"] = valid_data dataset["dev_set"] = valid_set dataset["test_set"] = test_set return dataset
tf.flags.DEFINE_string("summary_path", "ckpt/media/summary/",
"path to save summaries")
tf.flags.DEFINE_string("model_name", "multi_attention_model", "models name")
# convert parameters to dict
config = tf.flags.FLAGS.flag_values_dict()
# create dataset from raw data files
if not os.path.exists(config["save_path"]) or not os.listdir(
config["save_path"]):
process_data(config)
print("Load datasets...")
train_data = load_dataset(config["train_set"])
valid_set = batchnize_dataset(config["dev_set"],
config["batch_size"],
shuffle=False)
test_set = batchnize_dataset(config["test_set"],
config["batch_size"],
shuffle=False)
valid_data = batchnize_dataset(config["dev_set"], shuffle=False)
print("Build models...")
model = SequenceLabelModel(config)
model.train(train_data, valid_data, valid_set, test_set)
print("Inference...")
sentences = [
"alors une nuit le DIZAINE MOIS UNITE MILLE UNITE",
"dans un hôtel à XVILLE dans le centre ville"
]
from models.blstm_cnn_crf_model import SequenceLabelModel
from utils import batchnize_dataset
from configs.conll_pos_blstm_cnn_crf_cfg import create_configuration
print("Build configurations...")
config = create_configuration()
print("Load datasets...")
# used for training
train_set = batchnize_dataset(config["train_set"],
config["batch_size"],
shuffle=True)
# used for computing validate loss
valid_data = batchnize_dataset(config["dev_set"],
batch_size=1000,
shuffle=True)[0]
# used for computing validate accuracy, precision, recall and F1 scores
valid_set = batchnize_dataset(config["dev_set"],
config["batch_size"],
shuffle=False)
# used for computing test accuracy, precision, recall and F1 scores
test_set = batchnize_dataset(config["test_set"],
config["batch_size"],
shuffle=False)
print("Build models...")
model = SequenceLabelModel(config)
model.train(train_set, valid_data, valid_set, test_set)
print("Inference...")
sentences = ["EU rejects German call to boycott British lamb ."]