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)