def __init__(self, timed_session, configs, policy='random', max_chats_per_config=10, db='trials.pkl'): """A parameterized rulebased bot that can optimize its parameters. Args: timed_session (bool) configs (list(tuple)): each config is a tuple of numbers/strings policy (str): exploration strategy max_chats_per_config (int) db (str): path to dump evaluation results """ super(ConfigurableRulebasedSystem, self).__init__(timed_session) self.configs = configs self.policy = policy self.max_chats_per_config = max_chats_per_config # Save evaluation results of each config self.db = db if os.path.exists(self.db): self.trials = read_pickle(self.db) else: self.trials = defaultdict(dict) # The web server can update trials with multiple threads self.lock = Lock()
def __init__(self, schema, learned_lex, stop_words=None, lexicon_path=None): self.schema = schema # if True, lexicon uses learned system self.learned_lex = learned_lex self.entities = set() self.word_counts = defaultdict( int) # Counts of words that show up in entities self.lexicon = defaultdict( list) # Mapping from string -> list of (entity, type) with open(stop_words, 'r') as fin: self.stop_words = set([x.strip() for x in fin.read().split()][:1000]) self.stop_words.update([ 'one', '1', 'two', '2', 'three', '3', 'four', '4', 'five', '5', 'six', '6', 'seven', '7', 'eight', '8', 'nine', '9', 'ten', '10' ]) self.load_entities() if not lexicon_path or not os.path.exists(lexicon_path): self.compute_synonyms() print 'Created lexicon: %d phrases mapping to %d entities, %f entities per phrase' % ( len(self.lexicon), len(self.entities), sum([len(x) for x in self.lexicon.values()]) / float(len(self.lexicon))) if lexicon_path is not None: print 'Dump lexicon to {}'.format(lexicon_path) write_pickle(self.lexicon, lexicon_path) else: print 'Load lexicon from {}'.format(lexicon_path) self.lexicon = read_pickle(lexicon_path)
def __init__(self, schema, lexicon, model_path, fact_check, decoding, timed_session=False, consecutive_entity=True, realizer=None): super(NeuralSystem, self).__init__() self.schema = schema self.lexicon = lexicon self.timed_session = timed_session self.consecutive_entity = consecutive_entity # Load arguments args_path = os.path.join(model_path, 'config.json') config = read_json(args_path) config['batch_size'] = 1 config['gpu'] = 0 # Don't need GPU for batch_size=1 config['decoding'] = decoding args = argparse.Namespace(**config) mappings_path = os.path.join(model_path, 'vocab.pkl') mappings = read_pickle(mappings_path) vocab = mappings['vocab'] # TODO: different models have the same key now args.dropout = 0 logstats.add_args('model_args', args) model = build_model(schema, mappings, args) # Tensorflow config if args.gpu == 0: print 'GPU is disabled' config = tf.ConfigProto(device_count = {'GPU': 0}) else: gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction = 0.5, allow_growth=True) config = tf.ConfigProto(device_count = {'GPU': 1}, gpu_options=gpu_options) # NOTE: need to close the session when done tf_session = tf.Session(config=config) tf.initialize_all_variables().run(session=tf_session) # Load TF model parameters ckpt = tf.train.get_checkpoint_state(model_path+'-best') assert ckpt, 'No checkpoint found' assert ckpt.model_checkpoint_path, 'No model path found in checkpoint' saver = tf.train.Saver() saver.restore(tf_session, ckpt.model_checkpoint_path) self.model_name = args.model if self.model_name == 'attn-copy-encdec': args.entity_target_form = 'graph' copy = True else: copy = False preprocessor = Preprocessor(schema, lexicon, args.entity_encoding_form, args.entity_decoding_form, args.entity_target_form, args.prepend) textint_map = TextIntMap(vocab, mappings['entity'], preprocessor) Env = namedtuple('Env', ['model', 'tf_session', 'preprocessor', 'vocab', 'copy', 'textint_map', 'stop_symbol', 'remove_symbols', 'max_len', 'evaluator', 'prepend', 'consecutive_entity', 'realizer']) self.env = Env(model, tf_session, preprocessor, mappings['vocab'], copy, textint_map, stop_symbol=vocab.to_ind(markers.EOS), remove_symbols=map(vocab.to_ind, (markers.EOS, markers.PAD)), max_len=20, evaluator=FactEvaluator() if fact_check else None, prepend=args.prepend, consecutive_entity=self.consecutive_entity, realizer=realizer)
def __init__(self, schema, price_tracker, retriever, model_path, mappings, timed_session=False): super(NeuralRankerSystem, self).__init__() self.schema = schema self.price_tracker = price_tracker self.timed_session = timed_session # Load arguments args_path = os.path.join(model_path, 'config.json') config = read_json(args_path) # TODO: handle this properly config['batch_size'] = 1 config['pretrained_wordvec'] = None args = argparse.Namespace(**config) mappings_path = os.path.join(mappings, 'vocab.pkl') mappings = read_pickle(mappings_path) vocab = mappings['vocab'] logstats.add_args('model_args', args) model = build_model(schema, mappings, None, args) # Tensorflow config if args.gpu == 0: print 'GPU is disabled' config = tf.ConfigProto(device_count = {'GPU': 0}) else: gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction = 0.5, allow_growth=True) config = tf.ConfigProto(device_count = {'GPU': 1}, gpu_options=gpu_options) os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # NOTE: need to close the session when done tf_session = tf.Session(config=config) tf_session.run(tf.global_variables_initializer()) # Load TF model parameters ckpt = tf.train.get_checkpoint_state(model_path+'-best') assert ckpt, 'No checkpoint found' assert ckpt.model_checkpoint_path, 'No model path found in checkpoint' saver = tf.train.Saver() saver.restore(tf_session, ckpt.model_checkpoint_path) preprocessor = Preprocessor(schema, price_tracker, 'canonical', 'canonical', 'canonical') textint_map = TextIntMap(vocab, preprocessor) int_markers = SpecialSymbols(*[mappings['vocab'].to_ind(m) for m in markers]) model_config = {'retrieve': True} batcher = DialogueBatcherFactory.get_dialogue_batcher(model_config, int_markers=int_markers, slot_filling=False, kb_pad=mappings['kb_vocab'].to_ind(markers.PAD)) StreamingDialogue.textint_map = textint_map StreamingDialogue.num_context = args.num_context StreamingDialogue.mappings = mappings Env = namedtuple('Env', ['ranker', 'retriever', 'tf_session', 'preprocessor', 'mappings', 'textint_map', 'batcher']) self.env = Env(model, retriever, tf_session, preprocessor, mappings, textint_map, batcher)
def create_batches(self, split_type): raw_data = read_pickle("data/{}_batches.pkl".format(split_type)) data = [] for example in raw_data: source_tokens = example[0] source_indexes = [self.vocab.word_to_ind[st] for st in source_tokens] source = basic_variable(source_indexes) target_tokens = example[1] target_indexes = [self.vocab.word_to_ind[tt] for tt in target_tokens] target = basic_variable(target_indexes) data.append((source, target)) return data
def create_batches(self, name, dialogues, batch_size, add_ground_truth=True): if not os.path.isdir(self.cache): os.makedirs(self.cache) cache_file = os.path.join(self.cache, '%s_batches.pkl' % name) if (not os.path.exists(cache_file)) or self.ignore_cache: if self.retriever is not None: for dialogue in dialogues: k = (dialogue.uuid, dialogue.role) # candidates: list of list containing num_candidates responses for each turn of the dialogue # None candidates means that it is not the agent's speaking turn if k in self.cached_candidates: candidates = self.cached_candidates[k] else: candidates = self.retriever.retrieve_candidates( dialogue, json_dict=False) #if self.slot_filling: # for turn_candidates in candidates: # if turn_candidates: # for c in turn_candidates: # if 'response' in c: # c['response'] = Preprocessor._mark_slots(c['response']) # #print c['response'] #candidates = [c if c else self.retriever.empty_candidates for c in candidates] dialogue.add_candidates(candidates, add_ground_truth=add_ground_truth) self.retriever.report_search_time() for dialogue in dialogues: dialogue.convert_to_int() dialogue_batches = self.create_dialogue_batches( dialogues, batch_size) print 'Write %d batches to cache %s' % (len(dialogue_batches), cache_file) start_time = time.time() write_pickle(dialogue_batches, cache_file) print '[%d s]' % (time.time() - start_time) else: start_time = time.time() dialogue_batches = read_pickle(cache_file) print 'Read %d batches from cache %s' % (len(dialogue_batches), cache_file) print '[%d s]' % (time.time() - start_time) return dialogue_batches
def load_mappings(self, model_type, mappings_path, schema, preprocessor): vocab_path = os.path.join(mappings_path, 'vocab.pkl') if not os.path.exists(vocab_path): print 'Vocab not found at', vocab_path mappings = create_mappings(self.dialogues['train'], schema, preprocessor.entity_forms.values()) write_pickle(mappings, vocab_path) print('Wrote mappings to {}.'.format(vocab_path)) else: print 'Loading vocab from', vocab_path mappings = read_pickle(vocab_path) for k, v in mappings.iteritems(): print k, v.size mappings = make_model_mappings(model_type, mappings) return mappings
def create_batches(self, name, dialogues, batch_size): if not os.path.isdir(self.cache): os.makedirs(self.cache) cache_file = os.path.join(self.cache, '%s_batches.pkl' % name) if (not os.path.exists(cache_file)) or self.ignore_cache: for dialogue in dialogues: dialogue.convert_to_int() dialogue_batches = self.create_dialogue_batches(dialogues, batch_size) print 'Write %d batches to cache %s' % (len(dialogue_batches), cache_file) start_time = time.time() write_pickle(dialogue_batches, cache_file) print '[%d s]' % (time.time() - start_time) else: start_time = time.time() dialogue_batches = read_pickle(cache_file) print 'Read %d batches from cache %s' % (len(dialogue_batches), cache_file) print '[%d s]' % (time.time() - start_time) return dialogue_batches
def create_trie(self, batches, path): if path is None: return None def seq_iter(batches): for batch in batches: for b in batch['batch_seq']: targets = b['targets'] for target in targets: yield target if not os.path.exists(path): trie = Trie() print 'Build prefix trie of length', trie.max_prefix_len start_time = time.time() trie.build_trie(seq_iter(batches)) print '[%d s]' % (time.time() - start_time) print 'Write trie to', path write_pickle(trie, path) else: print 'Read trie from', path trie = read_pickle(path) return trie
def from_pickle(cls, path): templates = read_pickle(path) return cls(templates)
def __init__(self, schema, price_tracker, model_path, mappings_path, decoding, index=None, num_candidates=20, retriever_context_len=2, timed_session=False): super(NeuralSystem, self).__init__() self.schema = schema self.price_tracker = price_tracker self.timed_session = timed_session # Load arguments args_path = os.path.join(model_path, 'config.json') config = read_json(args_path) config['batch_size'] = 1 config['gpu'] = 0 # Don't need GPU for batch_size=1 config['decoding'] = decoding config['pretrained_wordvec'] = None args = argparse.Namespace(**config) vocab_path = os.path.join(mappings_path, 'vocab.pkl') mappings = read_pickle(vocab_path) vocab = mappings['vocab'] # TODO: different models have the same key now args.dropout = 0 logstats.add_args('model_args', args) model = build_model(schema, mappings, None, args) # Tensorflow config if args.gpu == 0: print 'GPU is disabled' config = tf.ConfigProto(device_count={'GPU': 0}) else: gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5, allow_growth=True) config = tf.ConfigProto(device_count={'GPU': 1}, gpu_options=gpu_options) # NOTE: need to close the session when done tf_session = tf.Session(config=config) tf.initialize_all_variables().run(session=tf_session) # Load TF model parameters ckpt = tf.train.get_checkpoint_state(model_path + '-best') assert ckpt, 'No checkpoint found' assert ckpt.model_checkpoint_path, 'No model path found in checkpoint' saver = tf.train.Saver() saver.restore(tf_session, ckpt.model_checkpoint_path) # Model config tells data generator which batcher to use model_config = {} if args.retrieve or args.model in ('ir', 'selector'): model_config['retrieve'] = True if args.predict_price: model_config['price'] = True self.model_name = args.model preprocessor = Preprocessor(schema, price_tracker, args.entity_encoding_form, args.entity_decoding_form, args.entity_target_form) textint_map = TextIntMap(vocab, preprocessor) int_markers = SpecialSymbols( *[mappings['vocab'].to_ind(m) for m in markers]) dialogue_batcher = DialogueBatcherFactory.get_dialogue_batcher( model_config, int_markers=int_markers, slot_filling=False, kb_pad=mappings['kb_vocab'].to_ind(markers.PAD)) # Retriever if args.model == 'selector': retriever = Retriever(index, context_size=retriever_context_len, num_candidates=num_candidates) else: retriever = None #TODO: class variable is not a good way to do this Dialogue.mappings = mappings Dialogue.textint_map = textint_map Dialogue.preprocessor = preprocessor Dialogue.num_context = args.num_context Env = namedtuple('Env', [ 'model', 'tf_session', 'preprocessor', 'vocab', 'textint_map', 'stop_symbol', 'remove_symbols', 'max_len', 'dialogue_batcher', 'retriever' ]) self.env = Env(model, tf_session, preprocessor, mappings['vocab'], textint_map, stop_symbol=vocab.to_ind(markers.EOS), remove_symbols=map(vocab.to_ind, (markers.EOS, markers.PAD)), max_len=20, dialogue_batcher=dialogue_batcher, retriever=retriever)
if not os.path.isdir(args.checkpoint): os.makedirs(args.checkpoint) config_path = os.path.join(args.checkpoint, 'config.json') write_json(vars(args), config_path) model_args = args ckpt = None # Load vocab vocab_path = 'data/persona_vocab.pkl' if not os.path.exists(vocab_path): print 'Vocab not found at', vocab_path vocab = None args.ignore_cache = True else: print 'Loading vocab from', vocab_path vocab = read_pickle(vocab_path) # schema = Schema(model_args.schema_path, None) # train_batches = DialogueBatcher(vocab, "train") # val_batches = DialogueBatcher(vocab, "valid") if cuda.is_available(): print 'Using GPU' encoder = encoder.cuda() decoder = decoder.cuda() else: print 'GPU is disabled' # for d, n in data_generator.num_examples.iteritems(): # logstats.add('data', d, 'num_dialogues', n)
def from_pickle(cls, path): data = read_pickle(path) return cls(**data)
def from_pickle(cls, path): data = read_pickle(path) return cls(data['model'], data['actions'])
def from_pickle(cls, path): templates = read_pickle(path) return cls(templates=templates, finalized=True)
def __init__(self, model_path): self.model = read_pickle(model_path)
os.makedirs(args.checkpoint) config_path = os.path.join(args.checkpoint, 'config.json') write_json(vars(args), config_path) model_args = args ckpt = None # Load vocab # TODO: put this in DataGenerator vocab_path = os.path.join(model_args.mappings, 'vocab.pkl') if not os.path.exists(vocab_path): print 'Vocab not found at', vocab_path mappings = None args.ignore_cache = True else: print 'Load vocab from', vocab_path mappings = read_pickle(vocab_path) for k, v in mappings.iteritems(): print k, v.size schema = Schema(model_args.schema_path, None) data_generator = get_data_generator(args, model_args, mappings, schema) for d, n in data_generator.num_examples.iteritems(): logstats.add('data', d, 'num_dialogues', n) # Save mappings if not mappings: mappings = data_generator.mappings vocab_path = os.path.join(args.mappings, 'vocab.pkl') write_pickle(mappings, vocab_path)