def train_and_eval(self): # pylint: disable=too-many-locals
"""Train and evaluate the model."""
# train related
g_train = tf.Graph()
with g_train.as_default():
logging.info("Compiling train model ...")
train_model = self.build(utils.TRAIN)
# eval related
g_eval = tf.Graph()
with g_eval.as_default():
logging.info("Compiling eval model ...")
eval_model = self.build(utils.EVAL)
eval_model.sess = tf.Session(config=self.session_conf,
graph=g_eval)
eval_model.saver = tf.train.Saver()
# start train
with g_train.as_default():
# Supervisor
with tf.name_scope("train"):
global_step = tf.train.get_or_create_global_step()
train_op = self.get_train_op(train_model.loss_op, global_step)
checkpoint_dir = get_checkpoint_dir(self.config)
# scaffold
scaffold = self.get_scaffold(utils.TRAIN, global_step,
train_model.iterator.initializer)
with tf.train.MonitoredTrainingSession(
checkpoint_dir=checkpoint_dir,
scaffold=scaffold,
save_checkpoint_steps=self.save_checkpoint_steps,
config=self.session_conf) as sess:
# Training loop. For each batch...
train_data_size = self.config['data']['train_data_size']
num_batch = math.ceil(train_data_size * self.num_epochs /
self.batch_size)
num_batch_per_epoch = math.ceil(train_data_size /
self.batch_size)
logging.info("Total data size: {}, batch num: {}, "
"batch num per epoch: {}".format(
train_data_size, num_batch,
num_batch_per_epoch))
for i in range(0, num_batch):
if i % self.save_checkpoint_steps == 0 and i != 0:
self.eval_or_infer_core(eval_model, utils.EVAL)
_, _, out_loss = sess.run(
[train_op, global_step, train_model.loss_op])
if i % self.print_every == 0 or i == num_batch - 1 or (
i + 1
) % num_batch_per_epoch == 0 or i % num_batch_per_epoch == 0:
logging.info(
"Training for epoch {}: [ {:.2%} ] loss is {:g}"
.format(int(i / num_batch_per_epoch),
(i % num_batch_per_epoch) /
num_batch_per_epoch, out_loss))
eval_model.sess.close()
def _freq_feat_graph(feat_name, **kwargs):
winlen = kwargs.get('winlen')
winstep = kwargs.get('winstep')
feature_size = kwargs.get('feature_size')
sr = kwargs.get('sr') #pylint: disable=invalid-name
nfft = kwargs.get('nfft')
del nfft
assert feat_name in ('fbank', 'spec')
params = speech_ops.speech_params(
sr=sr,
bins=feature_size,
add_delta_deltas=False,
audio_frame_length=winlen,
audio_frame_step=winstep)
graph = None
if feat_name == 'fbank':
# get session
if feat_name not in _global_sess:
graph = tf.Graph()
#pylint: disable=not-context-manager
with graph.as_default():
# fbank
filepath = tf.placeholder(dtype=tf.string, shape=[], name='wavpath')
waveforms, sample_rate = speech_ops.read_wav(filepath, params)
del sample_rate
fbank = speech_ops.extract_feature(waveforms, params)
# shape must be [T, D, C]
feat = tf.identity(fbank, name=feat_name)
elif feat_name == 'spec':
# magnitude spec
if feat_name not in _global_sess:
graph = tf.Graph()
#pylint: disable=not-context-manager
with graph.as_default():
filepath = tf.placeholder(dtype=tf.string, shape=[], name='wavpath')
waveforms, sample_rate = speech_ops.read_wav(filepath, params)
spec = py_x_ops.spectrum(
waveforms[:, 0],
tf.cast(sample_rate, tf.dtypes.float32),
output_type=1) #output_type: 1, power spec; 2 log power spec
spec = tf.sqrt(spec)
# shape must be [T, D, C]
spec = tf.expand_dims(spec, -1)
feat = tf.identity(spec, name=feat_name)
else:
raise ValueError(f"Not support freq feat: {feat_name}.")
return graph, (_get_out_tensor_name('wavpath',
0), _get_out_tensor_name(feat_name, 0))
def transfer_bert_model(bert_model_dir, output_bert_model):
graph = tf.Graph()
max_seq_len = 512
num_labels = 2
use_one_hot_embeddings = False
with graph.as_default():
with tf.Session() as sess:
input_ids = tf.placeholder(tf.int32, (None, None), 'input_ids')
input_mask = tf.placeholder(tf.int32, (None, None), 'input_mask')
segment_ids = tf.placeholder(tf.int32, (None, None), 'segment_ids')
bert_config = modeling.BertConfig.from_json_file(os.path.join(bert_model_dir, 'bert_config.json'))
model = modeling.BertModel(
config=bert_config,
is_training=False,
input_ids=input_ids,
input_mask=input_mask,
token_type_ids=segment_ids,
use_one_hot_embeddings=use_one_hot_embeddings)
all_encoder_layers = model.get_all_encoder_layers()
input_x_bert_cls = model.get_pooled_output()
for idx, layer in enumerate(all_encoder_layers):
layer = tf.identity(layer, "encoder_layers_" + str(idx))
print("layer:", layer)
input_x_bert_cls = tf.identity(input_x_bert_cls, "input_x_bert_cls")
print("input_x_bert_cls", input_x_bert_cls)
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, bert_model_dir + "/bert_model.ckpt")
saver.save(sess, output_bert_model)
def test_jieba_cut_op_no_file(self):
''' test jieba '''
graph = tf.Graph()
with graph.as_default():
sentence_in = tf.placeholder(dtype=tf.string,
shape=[None],
name="sentence_in")
sentence_out = self.build_op_no_file(sentence_in)
shape_op = tf.shape(sentence_out)
with self.cached_session(use_gpu=False, force_gpu=False) as sess:
# self.assertShapeEqual(tf.shape(sentence_in), tf.shape(sentence_out))
sentence_out_res = test_one(sess, sentence_out,
{sentence_in: ["我爱北京天安门"]})
self.assertEqual("我 爱 北京 天安门",
sentence_out_res[0].decode("utf-8"))
sentence_out_res = test_one(sess, sentence_out,
{sentence_in: ["吉林省长春药店"]})
self.assertEqual("吉林省 长春 药店",
sentence_out_res[0].decode("utf-8"))
sentence_out_res, shape_res = test_one(
sess, [sentence_out, shape_op],
{sentence_in: ["吉林省长春药店", "南京市长江大桥"]})
self.assertEqual(
"吉林省 长春 药店\n南京市 长江大桥", "\n".join([
one_sen.decode("utf-8") for one_sen in sentence_out_res
]))
logging.info(f"shape: {shape_res}")
self.assertAllEqual(shape_res, [2])
def test_export_model(self):
export_path_base = self.config["solver"]["service"]["model_path"]
model_version = self.config["solver"]["service"]["model_version"]
export_path = os.path.join(
tf.compat.as_bytes(export_path_base), tf.compat.as_bytes(model_version))
export_path = os.path.abspath(export_path)
if not os.path.exists(export_path):
self.solver.export_model()
old_paths = [
"tools/cppjieba/dict/jieba.dict.utf8",
"tools/cppjieba/dict/hmm_model.utf8", "tools/cppjieba/dict/idf.utf8",
"tools/cppjieba/dict/stop_words.utf8",
"tools/cppjieba/dict/user.dict.utf8"
]
old_args = [str(self.main_root.joinpath(p)) for p in old_paths]
edit_pb_txt(old_args, export_path.decode("utf-8"))
graph = tf.Graph()
with self.session(graph) as sess:
tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING],
export_path)
input_sentence_tensor = graph.get_operation_by_name(
"input_sentence").outputs[0]
score_tensor = graph.get_operation_by_name("score").outputs[0]
score = sess.run(
score_tensor, feed_dict={input_sentence_tensor: ["你好呀北京"]})
logging.info("score: {}".format(score))
def load_graph_session_from_ckpt(ckpt_path, sess_config, print_op=False):
"""load graph and session from checkpoint file"""
graph = tf.Graph()
with graph.as_default(): #pylint: disable=not-context-manager
sess = get_session(sess_config)
with sess.as_default(): #pylint: disable=not-context-manager
# Load the saved meta graph and restore variables
saver = tf.train.import_meta_graph("{}.meta".format(ckpt_path))
saver.restore(sess, ckpt_path)
if print_op:
print_ops(graph, prefix='load_graph_session_from_ckpt')
return graph, sess
def export_model(self):
"""Export a model to tensorflow SavedModel."""
mode = utils.INFER
graph = tf.Graph()
with graph.as_default():
infer_model = self.build_export_model()
infer_model.sess = tf.Session(config=self.session_conf)
infer_model.saver = tf.train.Saver()
model_path = self.get_model_path(mode)
infer_model.saver.restore(infer_model.sess, save_path=model_path)
to_saved_model(self.config, infer_model.sess, infer_model.export_inputs,
infer_model.output_dict)
def test_all(self):
# train and eval
solver = RawNLUJointSolver(self.config)
solver.train_and_eval()
model_path = solver.get_generated_model_path()
self.assertNotEqual(model_path, None)
# infer
solver.first_eval = True
solver.infer()
intent_res_file = self.config["solver"]["postproc"][0].get(
"res_file", "")
slots_res_file = self.config["solver"]["postproc"][1].get(
"res_file", "")
self.assertTrue(os.path.exists(intent_res_file))
self.assertTrue(os.path.exists(slots_res_file))
# export model
solver.export_model()
export_path_base = self.config["solver"]["service"]["model_path"]
model_version = self.config["solver"]["service"]["model_version"]
export_path = os.path.join(tf.compat.as_bytes(export_path_base),
tf.compat.as_bytes(model_version))
export_path = os.path.abspath(export_path)
logging.info("Load exported model from: {}".format(export_path))
# load the model and run
graph = tf.Graph()
with graph.as_default(): # pylint: disable=not-context-manager
with self.cached_session(use_gpu=False, force_gpu=False) as sess:
tf.saved_model.loader.load(
sess, [tf.saved_model.tag_constants.SERVING], export_path)
input_sentence_tensor = graph.get_operation_by_name(
"input_sentence").outputs[0]
intent_score_tensor = graph.get_operation_by_name(
"intent_score").outputs[0]
slots_score_tensor = graph.get_operation_by_name(
"slots_score").outputs[0]
score = sess.run([intent_score_tensor, slots_score_tensor],
feed_dict={
input_sentence_tensor:
["I am happy in the KFC"]
})
logging.info("score: {}".format(score))
def add_delta_delta(feat, feat_size, order=2):
''' add delta detla '''
feat_name = 'delta_delta'
graph = None
# get session
if feat_name not in _global_sess:
graph = tf.Graph()
#pylint: disable=not-context-manager
with graph.as_default():
fbank = tf.placeholder(
dtype=tf.float32, shape=[None, feat_size, 1], name='fbank')
feat_with_delta_delta = speech_ops.delta_delta(fbank, order=order)
feat_with_delta_delta = tf.identity(feat_with_delta_delta, name=feat_name)
sess = _get_session(feat_name, graph)
feat = sess.run(
_get_out_tensor_name(feat_name, 0), feed_dict={'fbank:0': feat})
return feat
def load_graph_session_from_saved_model(saved_model_dir,
sess_config,
print_op=False):
"""Load graph session from SavedModel"""
if not tf.saved_model.maybe_saved_model_directory(saved_model_dir):
raise ValueError("Not a saved model dir: {}".format(saved_model_dir))
logging.info('saved model dir : {}'.format(saved_model_dir))
graph = tf.Graph()
with graph.as_default(): #pylint: disable=not-context-manager
sess = get_session(sess_config)
with sess.as_default(): #pylint: disable=not-context-manager
tf.saved_model.loader.load(sess,
[tf.saved_model.tag_constants.SERVING],
saved_model_dir)
if print_op:
print_ops(graph, prefix='load_graph_session_from_saved_model')
return graph, sess
def init_session(self, model, gpu_str):
# The config for CPU usage
config = tf.ConfigProto()
if not gpu_str:
config.gpu_options.visible_device_list = '' # pylint: disable=no-member
else:
config.gpu_options.visible_device_list = gpu_str # pylint: disable=no-member
config.gpu_options.allow_growth = True # pylint: disable=no-member
#check model dir
if os.path.isdir(model):
self._graph = tf.Graph()
if tf.saved_model.maybe_saved_model_directory(model):
#saved model
logging.info('saved model dir: {}'.format(model))
self._sess = tf.Session(graph=self._graph, config=config)
tf.saved_model.loader.load(
self._sess, [tf.saved_model.tag_constants.SERVING], model)
else:
#checkpoint
self._sess = tf.Session(graph=self._graph,
config=tf.ConfigProto(
allow_soft_placement=True,
log_device_placement=True))
ckpt_path = tf.train.latest_checkpoint(model)
# self._graph, self._sess = utils.load_graph_session_from_ckpt(ckpt_path)
model = ckpt_path + '.meta'
logging.info("meta : {}".format(model))
saver = tf.train.import_meta_graph(model)
saver.restore(self._sess, ckpt_path)
else:
if not os.path.exists(model):
logging.info('{}, is not exist'.format(model))
logging.info("frozen_graph : {} not exist".format(model))
sys.exit(0)
#frozen graph pb
frozen_graph = model
logging.info('frozen graph pb : {}'.format(frozen_graph))
self._graph = utils.load_frozen_graph(frozen_graph)
self._sess = tf.Session(graph=self._graph, config=config)
def test_all(self):
# train and eval
solver = RawS2SSolver(self.config)
solver.train_and_eval()
model_path = solver.get_generated_model_path()
self.assertNotEqual(model_path, None)
# infer
solver.first_eval = True
solver.infer()
res_file = self.config["solver"]["postproc"].get("res_file", "")
self.assertTrue(os.path.exists(res_file))
# export model
solver.export_model()
export_path_base = self.config["solver"]["service"]["model_path"]
model_version = self.config["solver"]["service"]["model_version"]
export_path = os.path.join(tf.compat.as_bytes(export_path_base),
tf.compat.as_bytes(model_version))
export_path = os.path.abspath(export_path)
logging.info("Load exported model from: {}".format(export_path))
# load the model and run
graph = tf.Graph()
with graph.as_default(): # pylint: disable=not-context-manager
with self.cached_session(use_gpu=False, force_gpu=False) as sess:
tf.saved_model.loader.load(
sess, [tf.saved_model.tag_constants.SERVING], export_path)
input_sentence_tensor = graph.get_operation_by_name(
"input_sentence").outputs[0]
preds_tensor = graph.get_operation_by_name("preds").outputs[0]
preds = sess.run(
preds_tensor,
feed_dict={
input_sentence_tensor:
[" vice president walter "
"mondale was released"]
})
logging.info("preds: {}".format(preds))
def load_frozen_graph(frozen_graph_filename, print_op=False):
"""load a graph from protocol buffer file"""
# We load the protobuf file from the disk and parse it to retrieve the
# unserialized graph_def
with tf.gfile.GFile(frozen_graph_filename, "rb") as in_f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(in_f.read())
# Then, we import the graph_def into a new Graph and returns it
with tf.Graph().as_default() as graph: #pylint: disable=not-context-manager
# The name var will prefix every op/nodes in your graph
# Since we load everything in a new graph, this is not needed
tf.import_graph_def(graph_def,
input_map=None,
return_elements=None,
name="",
op_dict=None,
producer_op_list=None)
if print_op:
print_ops(graph, prefix='load_frozen_graph')
return graph
def load_wav(wavpath, sr=8000):
'''
audio:
np.float32, shape [None], sample in [-1, 1], using librosa.load
np.int16, shape [None], sample in [-32768, 32767], using scipy.io.wavfile
np.float32, shape[None, audio_channel], sample int [-1, 1], using tf.DecodeWav
return
sr: sample rate
audio: [-1, 1], same to tf.DecodeWav
'''
#from scipy.io import wavfile
#sample_rate, audio = wavfile.read(wavpath)
#samples, sample_rate = librosa.load(wavpath, sr=sr)
feat_name = 'load_wav'
graph = None
# get session
if feat_name not in _global_sess:
graph = tf.Graph()
with graph.as_default():
params = speech_ops.speech_params(sr=sr, audio_desired_samples=-1)
t_wavpath = tf.placeholder(dtype=tf.string, name="wavpath")
t_audio, t_sample_rate = speech_ops.read_wav(t_wavpath, params)
t_audio = tf.identity(t_audio, name="audio")
t_sample_rate = tf.identity(t_sample_rate, name="sample_rate")
sess = _get_session(feat_name, graph)
audio, sample_rate = sess.run([
_get_out_tensor_name('audio', 0),
_get_out_tensor_name('sample_rate', 0)
],
feed_dict={"wavpath:0": wavpath})
audio = audio[:, 0]
assert sample_rate == sr, 'sampling rate must be {}Hz, get {}Hz'.format(
sr, sample_rate)
return sample_rate, audio
def infer(self, **kwargs): # pylint: disable=unused-argument, arguments-differ
"""Make a inference."""
mode = utils.INFER
graph = tf.Graph()
with graph.as_default():
self.eval_or_infer_once(mode)
def eval(self):
"""Evaluate the model."""
mode = utils.EVAL
graph = tf.Graph()
with graph.as_default():
self.eval_or_infer_once(mode)
