def main(_=[]): """Main function. """ with tf.Graph().as_default(): g2p_model = G2PModel(FLAGS.model) if FLAGS.train: g2p_params = TrainingParams(FLAGS) g2p_model.prepare_data(FLAGS.train, FLAGS.valid, FLAGS.test) if (not FLAGS.model or not os.path.exists(os.path.join(FLAGS.model, "model.data-00000-of-00001")) or FLAGS.reinit): g2p_model.create_train_model(g2p_params) else: g2p_model.load_train_model(g2p_params) g2p_model.train() else: g2p_model.load_decode_model() if FLAGS.decode: decode_lines = codecs.open(FLAGS.decode, "r", "utf-8").readlines() output_file = None if FLAGS.output: output_file = codecs.open(FLAGS.output, "w", "utf-8") g2p_model.decode(decode_lines, output_file) elif FLAGS.interactive: g2p_model.interactive() elif FLAGS.evaluate: test_lines = codecs.open(FLAGS.evaluate, "r", "utf-8").readlines() g2p_model.evaluate(test_lines)
def main(): """Main function. """ if FLAGS.train: train_dic, valid_dic, test_dic =\ data_utils.split_dictionary(FLAGS.train, FLAGS.valid, FLAGS.test) g2p_model = G2PModel(train_dic, valid_dic, test_dic) g2p_model.train() else: g2p_model = G2PModel(PATH_G2P) if FLAGS.decode: g2p_model.decode() elif FLAGS.interactive: g2p_model.interactive() elif FLAGS.evaluate: g2p_model.evaluate()
def test_evaluate(self): model_dir = os.path.abspath("tests/models/decode") gt_path = os.path.abspath("tests/data/toydict.test") params = Params(model_dir, gt_path) params.hparams = g2p_trainer_utils.load_params(model_dir) g2p_model = G2PModel(params, test_path=gt_path) g2p_model.evaluate() correct, errors = g2p_model.calc_errors(gt_path) self.assertAlmostEqual(float(errors)/(correct+errors), 1.000, places=3)
def main(_=[]): """Main function. """ tf.logging.set_verbosity(tf.logging.INFO) file_path = FLAGS.train or FLAGS.decode or FLAGS.evaluate test_path = FLAGS.decode or FLAGS.evaluate or FLAGS.test if not FLAGS.model_dir: raise RuntimeError("Model directory not specified.") if FLAGS.reinit and os.path.exists(FLAGS.model_dir): shutil.rmtree(FLAGS.model_dir) if not os.path.exists(FLAGS.model_dir): os.makedirs(FLAGS.model_dir) params = Params(FLAGS.model_dir, file_path, flags=FLAGS) if FLAGS.train: g2p_trainer_utils.save_params(FLAGS.model_dir, params.hparams) g2p_model = G2PModel(params, train_path=FLAGS.train, dev_path=FLAGS.valid, test_path=test_path, cleanup=FLAGS.cleanup, p2g_mode=FLAGS.p2g) g2p_model.train() else: params.hparams = g2p_trainer_utils.load_params(FLAGS.model_dir) g2p_model = G2PModel(params, test_path=test_path, p2g_mode=FLAGS.p2g) if FLAGS.freeze: g2p_model.freeze() elif FLAGS.interactive: g2p_model.interactive() elif FLAGS.decode: g2p_model.decode(output_file_path=FLAGS.output) elif FLAGS.evaluate: g2p_model.evaluate()
def test_train(self): model_dir = os.path.abspath("tests/models/train") if not os.path.exists(model_dir): os.makedirs(model_dir) train_path = os.path.abspath("tests/data/toydict.train") dev_path = os.path.abspath("tests/data/toydict.test") params = Params(model_dir, train_path) g2p_model = G2PModel(params, file_path=train_path, is_training=True) g2p_model.prepare_datafiles(train_path=train_path, dev_path=dev_path) g2p_model.train() shutil.rmtree(model_dir)
def test_evaluate(self): model_dir = os.path.abspath("tests/models/decode") gt_path = os.path.abspath("tests/data/toydict.test") params = Params(model_dir, gt_path) g2p_model = G2PModel(params, file_path=gt_path, is_training=False) estimator, decode_hp, g2p_gt_map = g2p_model.evaluate() correct, errors = g2p.calc_errors(g2p_gt_map, estimator, gt_path, decode_hp) self.assertAlmostEqual(float(errors) / (correct + errors), 1.000, places=3)
def test_train(self): model_dir = os.path.abspath("tests/models/train") if not os.path.exists(model_dir): os.makedirs(model_dir) train_path = os.path.abspath("tests/data/toydict.train") dev_path = os.path.abspath("tests/data/toydict.test") params = Params(model_dir, train_path) g2p_trainer_utils.save_params(model_dir, params.hparams) g2p_model = G2PModel(params, train_path=train_path, dev_path=dev_path, test_path=dev_path) g2p_model.train() shutil.rmtree(model_dir)
def test_decode(self): model_dir = os.path.abspath("tests/models/decode") decode_file_path = os.path.abspath("tests/data/toydict.graphemes") output_file_path = os.path.abspath("tests/models/decode/decode_output.txt") params = Params(model_dir, decode_file_path) params.hparams = g2p_trainer_utils.load_params(model_dir) g2p_model = G2PModel(params, test_path=decode_file_path) g2p_model.decode(output_file_path=output_file_path) out_lines = open(output_file_path).readlines() self.assertEqual(out_lines[0].strip(), u"") self.assertEqual(out_lines[1].strip(), u"") self.assertEqual(out_lines[2].strip(), u"") os.remove(output_file_path)
def test_decode(self): model_dir = os.path.abspath("tests/models/decode") decode_file_path = os.path.abspath("tests/data/toydict.graphemes") output_file_path = os.path.abspath( "tests/models/decode/decode_output.txt") params = Params(model_dir, decode_file_path) g2p_model = G2PModel(params, file_path=decode_file_path, is_training=False) g2p_model.decode(output_file_path=output_file_path) out_lines = open(output_file_path).readlines() self.assertEqual(out_lines[0].strip(), u"C B C A C B") self.assertEqual(out_lines[1].strip(), u"C B C A C B") self.assertEqual(out_lines[2].strip(), u"A")
def main(_=[]): """Main function. """ tf.logging.set_verbosity(tf.logging.INFO) file_path = FLAGS.train or FLAGS.decode or FLAGS.evaluate if not FLAGS.model_dir: raise RuntimeError("Model directory not specified.") if FLAGS.reinit and os.path.exists(FLAGS.model_dir): shutil.rmtree(FLAGS.model_dir) if not os.path.exists(FLAGS.model_dir): os.makedirs(FLAGS.model_dir) params = Params(FLAGS.model_dir, file_path, flags=FLAGS) if FLAGS.train: g2p_model = G2PModel(params, file_path, is_training=True) g2p_model.prepare_datafiles(train_path=FLAGS.train, dev_path=FLAGS.valid) g2p_model.train() else: g2p_model = G2PModel(params, file_path, is_training=False) if FLAGS.freeze: g2p_model.freeze() elif FLAGS.interactive: g2p_model.interactive() elif FLAGS.decode: g2p_model.decode(output_file_path=FLAGS.output) elif FLAGS.evaluate: g2p_model.evaluate()
def main(_=[]): """Main function. """ if FLAGS.train: with tf.Graph().as_default(): g2p_model = G2PModel(FLAGS.model) g2p_params = TrainingParams(FLAGS) g2p_model.train(g2p_params, FLAGS.train, FLAGS.valid, FLAGS.test) else: with tf.Graph().as_default(): g2p_model = G2PModel(FLAGS.model) if FLAGS.decode: decode_lines = codecs.open(FLAGS.decode, "r", "utf-8").readlines() output_file = None if FLAGS.output: output_file = codecs.open(FLAGS.output, "w", "utf-8") g2p_model.decode(decode_lines, output_file) elif FLAGS.interactive: g2p_model.interactive() elif FLAGS.evaluate: test_lines = codecs.open(FLAGS.evaluate, "r", "utf-8").readlines() g2p_model.evaluate(test_lines)
import sys import os from g2p_seq2seq import g2p import g2p_seq2seq.g2p_trainer_utils as g2p_trainer_utils from g2p_seq2seq.g2p import G2PModel from g2p_seq2seq.params import Params from flask import Flask, jsonify from flask import request, url_for from flask_api import FlaskAPI, status, exceptions app = FlaskAPI(__name__) params = Params("g2p-seq2seq", '') params.hparams = g2p_trainer_utils.load_params("g2p-seq2seq") model = G2PModel(params) model.inputs = [] # initialization model._G2PModel__prepare_interactive_model() @app.route("/", methods=['POST']) def notes_list(): wordObtained = str(request.data.get('text', '')) output = model.decode_word(wordObtained) if (not output): return "" else: return output[0] @app.route("/", methods=["GET"])
def path_leaf(path): head, tail = ntpath.split(path) return tail or ntpath.basename(head) MODELDIR = "g2p-seq2seq-model" DATADIR = g.DICTDIRTXT #decode_file_path = os.path.abspath("/home/mike/SR_Py/helperScripts/Dictionary(Auto)/Thing.txt") output_file_path = g.DICTDIR # print(model_dir) # params = Params(model_dir, decode_file_path) # params.hparams = g2p_trainer_utils.load_params(model_dir) # g2p_model = G2PModel(params, test_path=decode_file_path) # g2p_model.decode(output_file_path=output_file_path) clear_dir(output_file_path) filesIn = glob.glob(DATADIR + "/*") for filenameIn in filesIn: filesOut = filenameIn.split('.')[0] fileOut = path_leaf(filesOut) input = filenameIn output = os.path.join(output_file_path, fileOut + ".dic") params = Params(MODELDIR, input) params.hparams = g2p_trainer_utils.load_params(MODELDIR) g2p_model = G2PModel(params, test_path=input) g2p_model.decode(output_file_path=output)
def __init__(self, path_to_model): assert( os.path.isdir(path_to_model) ) self.model = G2PModel(path_to_model) self.model.load_decode_model()
import sys import os from g2p_seq2seq import g2p import g2p_seq2seq.g2p_trainer_utils as g2p_trainer_utils from g2p_seq2seq.g2p import G2PModel from g2p_seq2seq.params import Params print("hello") model_dir = os.path.abspath("models/g2p-seq2seq") gt_path = os.path.abspath("data/toydict.test") params = Params(model_dir, gt_path) params.hparams = g2p_trainer_utils.load_params(model_dir) g2p_model = G2PModel(params, test_path=gt_path) g2p_model.decode_word("hello")
import nltk.data import json import re import inflect from StringIO import StringIO reload(sys) sys.setdefaultencoding('utf8') lotr = open("books/lotr.txt", "r") tokenizer = nltk.data.load('tokenizers/punkt/english.pickle') sentences = tokenizer.tokenize(unicode(lotr.read())) iengine = inflect.engine() g2p_model = G2PModel('g2p-seq2seq-cmudict') g2p_model.load_decode_model() def is_number(s): try: f = int(s) return True except: return False def sentence_to_phoneme(sentence): words = [] for word in re.split('\W+', sentence): if word == '':
def getModel(model): g2p_model = G2PModel(model) g2p_model.load_decode_model() return g2p_model