def test_gpt2standin(self): with testing_utils.tempdir() as tmpdir: # we need to build the dict file hf_bpe_opt = self._get_dict_opt('bytelevelbpe') slow_bytelevel_bpe_opt = self._get_dict_opt('slow_bytelevel_bpe') dict_file = os.path.join(tmpdir, "dict") pp = build_dict.setup_args() pp.set_defaults(**hf_bpe_opt) pp.set_defaults(task='babi') popt = pp.parse_args([]) popt['dict_file'] = dict_file build_dict.build_dict(popt) hf_bpe_opt['dict_file'] = dict_file hf_bpe = DictionaryAgent(hf_bpe_opt) slow_bytelevel_bpe_opt['dict_file'] = dict_file slow_bytelevel_bpe = DictionaryAgent(slow_bytelevel_bpe_opt) self._run_test(slow_bytelevel_bpe, hf_bpe) slow_bytelevel_bpe_opt['bpe_add_prefix_space'] = True slow_bytelevel_bpe = DictionaryAgent(slow_bytelevel_bpe_opt) self._run_prefix_space_test(slow_bytelevel_bpe)
def verify_batch_lengths(defaults): with testing_utils.capture_output() as _, testing_utils.tempdir() as tmpdir: # Get processed act from agent parser = train_setup_args() defaults['model_file'] = os.path.join(tmpdir, 'model') defaults['dict_file'] = os.path.join(tmpdir, 'model.dict') parser.set_defaults(**defaults) opt = parser.parse_args() build_dict(opt) agent = create_agent(opt) world_data = create_task(opt, agent) batch_sort_acts = [] # first epoch while len(batch_sort_acts) < 900/50: world_data.parley() batch_sort_acts.append(world_data.acts[0]) teacher = world_data.world.get_agents()[0] teacher.reset_data() # second epoch while len(batch_sort_acts) < 1800/50: world_data.parley() batch_sort_acts.append(world_data.acts[0]) world_data.shutdown() field = defaults['batch_sort_field'] lengths = [[ep_length(b[field]) for b in bb if field in b] for bb in batch_sort_acts[:-2]] # exclude last batch # verify batch lengths for batch_lens in lengths: self.assertLessEqual(max(batch_lens) - min(batch_lens), max_range, 'PytorchDataTeacher batching does not give ' 'batches with similar sized examples, when ' 'sorting by `{}` field.'.format( defaults['batch_sort_field']))
def verify_batch_lengths(defaults): f = io.StringIO() with redirect_stdout(f): # Get processed act from agent parser = train_setup_args() set_model_file(defaults) parser.set_defaults(**defaults) opt = parser.parse_args() build_dict(opt) agent = create_agent(opt) world_data = create_task(opt, agent) batch_sort_acts = [] # first epoch while len(batch_sort_acts) < 900 / 50: world_data.parley() batch_sort_acts.append(world_data.acts[0]) teacher = world_data.world.get_agents()[0] teacher.reset_data() # second epoch while len(batch_sort_acts) < 1800 / 50: world_data.parley() batch_sort_acts.append(world_data.acts[0]) field = defaults['batch_sort_field'] lengths = [[ep_length(b[field]) for b in bb if field in b] for bb in batch_sort_acts[:-2]] # exclude last batch # verify batch lengths for batch_lens in lengths: self.assertLessEqual( max(batch_lens) - min(batch_lens), max_range, 'PytorchDataTeacher batching does not give ' 'batches with similar sized examples, when ' 'sorting by `{}` field.'.format( defaults['batch_sort_field']))
def __init__(self, opt): if isinstance(opt, ParlaiParser): print( '[ Deprecated Warning: TrainLoop should be passed opt not Parser ]' ) opt = opt.parse_args() # Possibly load from checkpoint if opt['load_from_checkpoint'] and opt.get( 'model_file') and os.path.isfile(opt['model_file'] + '.checkpoint'): opt['init_model'] = opt['model_file'] + '.checkpoint' # Possibly build a dictionary (not all models do this). if opt['dict_build_first'] and 'dict_file' in opt: # If data built via pytorch data teacher, we need to load prebuilt dict if opt.get('pytorch_teacher_task'): opt['dict_file'] = get_pyt_dict_file(opt) elif opt['dict_file'] is None and opt.get('model_file'): opt['dict_file'] = opt['model_file'] + '.dict' print("[ building dictionary first... ]") build_dict(opt, skip_if_built=True) # Create model and assign it to the specified task self.agent = create_agent(opt) self.world = create_task(opt, self.agent) self.train_time = Timer() self.validate_time = Timer() self.log_time = Timer() self.save_time = Timer() print('[ training... ]') self.parleys = 0 self.max_num_epochs = opt[ 'num_epochs'] if opt['num_epochs'] > 0 else float('inf') self.max_train_time = opt['max_train_time'] if opt['max_train_time'] > 0 \ else float('inf') self.log_every_n_secs = opt['log_every_n_secs'] if opt['log_every_n_secs'] > 0 \ else float('inf') self.val_every_n_secs = \ opt['validation_every_n_secs'] if opt['validation_every_n_secs'] > 0 \ else float('inf') self.save_every_n_secs = opt['save_every_n_secs'] if opt['save_every_n_secs'] \ > 0 else float('inf') self.val_every_n_epochs = \ opt['validation_every_n_epochs'] if opt['validation_every_n_epochs'] > 0 \ else float('inf') self.last_valid_epoch = 0 self.valid_optim = 1 if opt['validation_metric_mode'] == 'max' else -1 self.best_valid = None if opt.get('model_file') and os.path.isfile(opt['model_file'] + '.best_valid'): with open(opt['model_file'] + ".best_valid", 'r') as f: x = f.readline() self.best_valid = float(x) f.close() self.impatience = 0 self.saved = False self.valid_world = None self.opt = opt if opt['tensorboard_log'] is True: self.writer = TensorboardLogger(opt)
def get_teacher_act(defaults, teacher_processed=False, agent_to=None): parser = train_setup_args() parser.set_defaults(**defaults) opt = parser.parse_args([]) build_dict(opt) teacher = create_task_agent_from_taskname(opt)[0] agent = create_agent(opt) act = teacher.act() if teacher_processed: return act, agent return agent.observe(act), agent
def _distributed_train_model(self, opt): with testing_utils.tempdir() as tmpdir: if 'model_file' not in opt: opt['model_file'] = os.path.join(tmpdir, 'model') if 'dict_file' not in opt: opt['dict_file'] = os.path.join(tmpdir, 'model.dict') parser = mp_train.setup_args() popt = _forced_parse(parser, opt) # we need a prebuilt dictionary parser = build_dict.setup_args() build_dict.build_dict(popt) valid, test = mp_train.launch_and_train(popt, 31337) return (valid, test)
def _distributed_train_model(self, **overrides): opt = {**self.base_config, **overrides} with testing_utils.tempdir() as tmpdir: if 'model_file' not in opt: opt['model_file'] = os.path.join(tmpdir, 'model') if 'dict_file' not in opt: opt['dict_file'] = os.path.join(tmpdir, 'model.dict') parser = mp_train.setup_args() popt = parser.parse_kwargs(**opt) # we need a prebuilt dictionary parser = build_dict.setup_args() build_dict.build_dict(popt) valid, test = mp_train.launch_and_train(popt) return (valid, test)
def build_smoother_dict(): def setup_args(): parser = ParlaiParser(add_model_args=True, add_parlai_args=True) parser.set_defaults( task='tasks.convai2smoother.agents:BothOriginalTeacher', # dict_initpath='../../tmp/dict/init_receiver.dict', datatype='train', dict_lower=True, dict_file='../../tmp/dict/smoother_origin.dict', dict_tokenizer='split', dict_language='english', dict_include_valid=True, dict_maxexs=-1) return parser parser = setup_args() opt = parser.parse_args(args=[]) # %% build_dict(opt)
def _distributed_train_model(self, opt): with testing_utils.tempdir() as tmpdir: if 'model_file' not in opt: opt['model_file'] = os.path.join(tmpdir, 'model') if 'dict_file' not in opt: opt['dict_file'] = os.path.join(tmpdir, 'model.dict') parser = mp_train.setup_args() # TODO: Kill this after dictionaries build correctly popt = self._forced_parse(parser, opt) # we need a prebuilt dictionary parser = build_dict.setup_args() build_dict.build_dict(popt) valid, test = mp_train.launch_and_train(popt, 31338) dist.destroy_process_group() return (valid, test)
def get_acts_epochs_1_and_2(defaults): parser.set_defaults(**defaults) opt = parser.parse_args() build_dict(opt) agent = create_agent(opt) world_data = create_task(opt, agent) acts_epoch_1 = [] acts_epoch_2 = [] while not world_data.epoch_done(): world_data.parley() acts_epoch_1.append(world_data.acts[0]) world_data.reset() while not world_data.epoch_done(): world_data.parley() acts_epoch_2.append(world_data.acts[0]) acts_epoch_1 = [bb for b in acts_epoch_1 for bb in b] acts_epoch_1 = sorted([b for b in acts_epoch_1 if 'text' in b], key=lambda x: x.get('text')) acts_epoch_2 = [bb for b in acts_epoch_2 for bb in b] acts_epoch_2 = sorted([b for b in acts_epoch_2 if 'text' in b], key=lambda x: x.get('text')) return acts_epoch_1, acts_epoch_2
def _distributed_train_model(self, opt): # we have to delay our import to here, because the set_spawn_method call # inside multiprocessing_train will break the multithreading tests, even # when we skip the test. import parlai.scripts.multiprocessing_train as mp_train with testing_utils.capture_output() as output: with testing_utils.tempdir() as tmpdir: if 'model_file' not in opt: opt['model_file'] = os.path.join(tmpdir, 'model') if 'dict_file' not in opt: opt['dict_file'] = os.path.join(tmpdir, 'model.dict') parser = mp_train.setup_args() popt = _forced_parse(parser, opt) # we need a prebuilt dictionary parser = build_dict.setup_args() build_dict.build_dict(popt) valid, test = mp_train.launch_and_train(popt, 31337) return (output.getvalue(), valid, test)
def build_transmitter_dict(): def setup_args(): parser = ParlaiParser(add_model_args=True, add_parlai_args=True) parser.set_defaults( task='tasks.convai2transmitter.agents:BothTeacher', dict_initpath='../../tmp/dict/init_transmitter.dict', datatype='train', dict_lower=True, dict_file='../../tmp/dict/convai2_self_seq2seq_model.dict', dict_nulltoken=SpecialToken.pad, dict_starttoken=SpecialToken.start, dict_endtoken=SpecialToken.end, dict_unktoken=SpecialToken.unk, dict_tokenizer='split', dict_language='english', dict_include_valid=True, dict_minfreq=2, dict_maxexs=-1) return parser parser = setup_args() opt = parser.parse_args(args=[]) # %% build_dict(opt)
def __init__(self, opt): # if python is called from a non-interactive shell, like a bash script, # it will by-default ignore SIGINTs, and KeyboardInterrupt exceptions are # not produced. This line brings them back signal.signal(signal.SIGINT, signal.default_int_handler) # Possibly load from checkpoint trainstats_suffix = '.trainstats' # we might load training statistics from here if ( opt['load_from_checkpoint'] and opt.get('model_file') and PathManager.exists(opt['model_file'] + '.checkpoint') ): opt['init_model'] = opt['model_file'] + '.checkpoint' trainstats_suffix = '.checkpoint.trainstats' # Possibly build a dictionary (not all models do this). if not (opt.get('dict_file') or opt.get('model_file')): raise RuntimeError( 'WARNING: For train_model, please specify either a ' 'model_file or dict_file.' ) if 'dict_file' in opt: if opt['dict_file'] is None and opt.get('model_file'): opt['dict_file'] = opt['model_file'] + '.dict' logging.info("building dictionary first...") build_dict(opt, skip_if_built=True) # Create model and assign it to the specified task self.agent = create_agent(opt) self.agent.opt.log() self.world = create_task(opt, self.agent) # set up timers self.train_time = Timer() self.validate_time = Timer() self.log_time = Timer() self.save_time = Timer() self.parleys = 0 self._train_steps = 0 self._last_log_steps = 0 self.update_freq = opt.get('update_freq', 1) self.max_num_epochs = _num_else_inf(opt, 'num_epochs', distributed_warn=True) self.max_train_time = _num_else_inf( opt, 'max_train_time', distributed_warn=True ) self.max_train_steps = _num_else_inf(opt, 'max_train_steps') self.log_every_n_secs = _num_else_inf( opt, 'log_every_n_secs', distributed_warn=True ) self.log_every_n_steps = _num_else_inf(opt, 'log_every_n_steps') self.val_every_n_secs = _num_else_inf( opt, 'validation_every_n_secs', distributed_warn=True ) self.val_every_n_epochs = _num_else_inf( opt, 'validation_every_n_epochs', distributed_warn=True ) self.val_every_n_steps = _num_else_inf(opt, 'validation_every_n_steps') self.save_every_n_secs = _num_else_inf( opt, 'save_every_n_secs', distributed_warn=True ) # smart defaults for --validation-metric-mode if opt['validation_metric'] in {'loss', 'ppl', 'mean_rank'}: opt['validation_metric_mode'] = 'min' elif opt['validation_metric'] in {'accuracy', 'hits@1', 'hits@5', 'f1', 'bleu'}: opt['validation_metric_mode'] = 'max' if opt.get('validation_metric_mode') is None: opt['validation_metric_mode'] = 'max' self.last_valid_epoch = 0 self._last_valid_steps = 0 self.valid_optim = 1 if opt['validation_metric_mode'] == 'max' else -1 self.train_reports = [] self.valid_reports = [] self.final_valid_report = {} self.final_test_report = {} self.final_extra_valid_report = {} self.best_valid = None self.impatience = 0 self.saved = False self.valid_worlds = None self.opt = opt # we may have been preempted, make sure we note that amount self._preempted_epochs = 0.0 if opt.get('model_file') and PathManager.exists( opt['model_file'] + trainstats_suffix ): # looks like we were preempted. make sure we load up our total # training stats, etc with PathManager.open(opt['model_file'] + trainstats_suffix) as ts: obj = json.load(ts) self.parleys = obj.get('parleys', 0) self._preempted_epochs = obj.get('total_epochs', 0) self.train_time.total = obj.get('train_time', 0) self._train_steps = obj.get('train_steps', 0) self.impatience = obj.get('impatience', 0) self.valid_reports = obj.get('valid_reports', []) if self.valid_reports: self.last_valid_epoch = self.valid_reports[-1].get( 'total_epochs', 0.0 ) self.train_reports = obj.get('train_reports', []) if 'best_valid' in obj: self.best_valid = obj['best_valid'] else: # old method if opt.get('model_file') and PathManager.exists( opt['model_file'] + '.best_valid' ): with PathManager.open( opt['model_file'] + ".best_valid", 'r' ) as f: x = f.readline() self.best_valid = float(x) f.close() if opt['tensorboard_log'] and is_primary_worker(): self.tb_logger = TensorboardLogger(opt) if opt['wandb_log'] and is_primary_worker(): model = self.agent.model if hasattr(self.agent, 'model') else None self.wb_logger = WandbLogger(opt, model)
def __init__(self, opt): # if python is called from a non-interactive shell, like a bash script, # it will by-default ignore SIGINTs, and KeyboardInterrupt exceptions are # not produced. This line brings them back signal.signal(signal.SIGINT, signal.default_int_handler) if isinstance(opt, ParlaiParser): print( '[ Deprecated Warning: TrainLoop should be passed opt not Parser ]' ) opt = opt.parse_args() # Possibly load from checkpoint trainstats_suffix = '.trainstats' # we might load training statistics from here if opt['load_from_checkpoint'] and opt.get( 'model_file') and os.path.isfile(opt['model_file'] + '.checkpoint'): opt['init_model'] = opt['model_file'] + '.checkpoint' trainstats_suffix = '.checkpoint.trainstats' # Possibly build a dictionary (not all models do this). if opt['dict_build_first'] and 'dict_file' in opt: # If data built via pytorch data teacher, we need to load prebuilt dict if opt.get('pytorch_teacher_task'): opt['dict_file'] = get_pyt_dict_file(opt) elif opt['dict_file'] is None and opt.get('model_file'): opt['dict_file'] = opt['model_file'] + '.dict' print("[ building dictionary first... ]") build_dict(opt, skip_if_built=True) # Create model and assign it to the specified task self.agent = create_agent(opt) #specify model such as seq2seq self.world = create_task(opt, self.agent) # bacthworld or other world # set up timers self.train_time = Timer() self.validate_time = Timer() self.log_time = Timer() self.save_time = Timer() print('[ training... ]') self.parleys = 0 self.max_num_epochs = opt[ 'num_epochs'] if opt['num_epochs'] > 0 else float('inf') self.max_train_time = opt['max_train_time'] if opt['max_train_time'] > 0 \ else float('inf') self.log_every_n_secs = opt['log_every_n_secs'] if opt['log_every_n_secs'] > 0 \ else float('inf') self.val_every_n_secs = \ opt['validation_every_n_secs'] if opt['validation_every_n_secs'] > 0 \ else float('inf') self.save_every_n_secs = opt['save_every_n_secs'] if opt['save_every_n_secs'] \ > 0 else float('inf') self.val_every_n_epochs = \ opt['validation_every_n_epochs'] if opt['validation_every_n_epochs'] > 0 \ else float('inf') # smart defaults for --validation-metric-mode if opt['validation_metric'] in {'loss', 'ppl', 'mean_rank'}: opt['validation_metric_mode'] = 'min' elif opt['validation_metric'] in { 'accuracy', 'hits@1', 'hits@5', 'f1', 'bleu' }: opt['validation_metric_mode'] = 'max' if opt.get('validation_metric_mode') is None: opt['validation_metric_mode'] = 'max' self.last_valid_epoch = 0 self.valid_optim = 1 if opt['validation_metric_mode'] == 'max' else -1 self.best_valid = None if opt.get('model_file') and os.path.isfile(opt['model_file'] + '.best_valid'): with open(opt['model_file'] + ".best_valid", 'r') as f: x = f.readline() self.best_valid = float(x) f.close() self.impatience = 0 self.saved = False self.valid_world = None self.opt = opt # we may have been preempted, make sure we note that amount self._preempted_epochs = 0.0 if (opt.get('model_file') and os.path.isfile(opt['model_file'] + trainstats_suffix)): # looks like we were preempted. make sure we load up our total # training stats, etc with open(opt['model_file'] + trainstats_suffix) as ts: obj = json.load(ts) self._preempted_epochs = obj.get('total_epochs', 0) self.train_time.total = obj.get('train_time', 0) self.impatience = obj.get('impatience', 0) if opt['tensorboard_log'] is True: self.writer = TensorboardLogger(opt)
def build_data(opt): if not opt.get('model', False): opt['model'] = 'repeat_label' preprocess = opt.get('pytorch_preprocess', True) opt['dict_file'] = get_pyt_dict_file(opt) dictionary = None if 'dict_maxexs' in opt: # Note: only build dictionary if dict loop args specified dictionary = build_dict(opt, skip_if_built=True) agent = create_agent(opt) # If build teacher not specified, we are simply looking for the file if not opt.get('pytorch_teacher_task', None): df = opt.get('pytorch_datapath') # check if the user set a datafile if not df: raise Exception( 'Tried to find data but `--pytorch-datapath` is not set') # check if the user provided the already built file if 'pytorch' not in df: df += '.pytorch' + (agent.getID() if opt.get( 'pytorch_preprocess', True) else '') if not os.path.isfile(df): raise Exception('Tried to find data but it is not built, please' 'specify `--pytorch-teacher-task`') else: return df ordered_opt = copy.deepcopy(opt) # we use streaming to build the data dt = opt['datatype'].split(':')[0] ordered_opt['datatype'] = dt + ':ordered:stream' ordered_opt['numthreads'] = 1 ordered_opt['batchsize'] = 1 ordered_opt['task'] = ordered_opt['pytorch_teacher_task'] ordered_opt.pop('pytorch_teacher_dataset') ordered_opt['no_cuda'] = True world_data = create_task(ordered_opt, agent) teacher = world_data.agents[0] agent = world_data.agents[1] datapath = os.path.join( opt.get('datapath', '.'), '{}_pyt_data'.format(ordered_opt['task'].replace(':', '_')), dt) if preprocess: datapath += '_{}_preprocess'.format(agent.getID().replace(':', '_')) if os.path.isdir(datapath) and 'data_length' in os.listdir(datapath): # Data already built print("[ pytorch data already built, at {}. ]".format(datapath)) return datapath print('----------\n[ setting up pytorch data, saving to {}/ ]\n----------'. format(datapath)) os.makedirs(datapath, exist_ok=True) num_eps = 0 num_exs = 0 current = [] episode_done = False include_labels = opt.get('pytorch_include_labels', True) context_length = opt.get('pytorch_context_length', -1) context = deque(maxlen=context_length if context_length > 0 else None) total_exs = world_data.num_examples() pbar = tqdm.tqdm(total=total_exs, unit='ex', unit_scale=True, desc='Building pytorch data') idx_to_char = [] cumulative_char_len = 0 # pass examples to dictionary with open(os.path.join(datapath, 'data'), 'w') as pytorch_data: while num_exs < total_exs: while not episode_done: action = teacher.act() current.append(action) episode_done = action.get('episode_done', False) # build separate episodes for ex in current: context.append(ex.get('text', '')) if len(context) > 1: ex['text'] = '\n'.join(context) ex['episode_done'] = True labels = ex.get('labels', ex.get('eval_labels', None)) if labels is not None and include_labels: context.append(random.choice(labels)) # generate observation from new example if preprocess: ex = agent.observe(ex) ex.pop('label_candidates', '') ex['preprocessed'] = True num_eps += 1 num_exs += 1 pbar.update(1) ex_len = pytorch_data.write( json.dumps(make_serializable(ex)) + "\n") idx_to_char.append(cumulative_char_len) cumulative_char_len += ex_len # reset episode_done = False current.clear() context.clear() pbar.close() with open(os.path.join(datapath, 'char_index'), 'w') as char_index: json.dump(idx_to_char, char_index) with open(os.path.join(datapath, 'data_length'), 'w') as pytorch_data_len: pytorch_data_len.write( json.dumps({ 'num_eps': num_eps, 'num_exs': num_exs })) if dictionary: dictionary.save(get_pyt_dict_file(opt), sort=True) print('[ pytorch data built. ]') return datapath
def _build_dict(opt): build_dict(opt)
def __init__(self, opt): signal.signal(signal.SIGINT, signal.default_int_handler) if isinstance(opt, ParlaiParser): opt = opt.parse_args() # Possibly load from checkpoint trainstats_suffix = '.trainstats' if (opt.get('model_file') and isfile(opt['model_file'] + '.checkpoint')): opt['init_model'] = opt['model_file'] + '.checkpoint' trainstats_suffix = '.checkpoint.trainstats' else: pass # TODO for testing only # raise RuntimeError('WARNING: Reinforcement learning' # ' must be initialized by a model.checkpoint ' # 'file and {} does not exist.'.format( # opt['model_file'] + '.checkpoint')) # Possibly build a dictionary (not all models do this). if (opt['dict_build_first'] and not (opt.get('dict_file') or opt.get('model_file'))): raise RuntimeError('WARNING: For train_model, ' 'please specify either a ' 'model_file or dict_file.') if opt['dict_build_first'] and 'dict_file' in opt: if opt.get('pytorch_teacher_task'): opt['dict_file'] = get_pyt_dict_file(opt) elif opt['dict_file'] is None and opt.get('model_file'): opt['dict_file'] = opt['model_file'] + '.dict' print("[ building dictionary first... ]") build_dict(opt, skip_if_built=True) # Create model and assign it to the specified task self.agent = create_agent(opt) # Freeze the model for the static dialogue partner static_agent = copy.deepcopy(self.agent) self.agent.id = ACTIVE static_agent.id = STATIC freeze_agent(static_agent) self.world = create_task(opt, self.agent, static_agent) # set up timers self.train_time = Timer() self.validate_time = Timer() self.log_time = Timer() self.save_time = Timer() print('[ training... ]') self.parleys = 0 self.max_num_epochs = (opt['num_epochs'] if opt['num_epochs'] > 0 else float('inf')) self.max_train_time = (opt['max_train_time'] if opt['max_train_time'] > 0 else float('inf')) self.log_every_n_secs = (opt['log_every_n_secs'] if opt['log_every_n_secs'] > 0 else float('inf')) self.val_every_n_secs = (opt['validation_every_n_secs'] if opt['validation_every_n_secs'] > 0 else float('inf')) self.save_every_n_secs = (opt['save_every_n_secs'] if opt['save_every_n_secs'] > 0 else float('inf')) self.val_every_n_epochs = (opt['validation_every_n_epochs'] if opt['validation_every_n_epochs'] > 0 else float('inf')) # smart defaults for --validation-metric-mode if opt['validation_metric'] in {'loss', 'ppl', 'mean_rank'}: opt['validation_metric_mode'] = 'min' elif opt['validation_metric'] in { 'accuracy', 'hits@1', 'hits@5', 'f1', 'bleu' }: opt['validation_metric_mode'] = 'max' if opt.get('validation_metric_mode') is None: opt['validation_metric_mode'] = 'max' self.last_valid_epoch = 0 self.valid_optim = (1 if opt['validation_metric_mode'] == 'max' else -1) self.valid_reports = [] self.best_valid = None if (opt.get('model_file') and isfile(opt['model_file'] + '.best_valid')): with open(opt['model_file'] + ".best_valid", 'r') as f: x = f.readline() self.best_valid = float(x) f.close() self.impatience = 0 self.saved = False self.valid_world = None self.opt = opt # we may have been preempted, make sure we note that amount self._preempted_epochs = 0.0 if (opt.get('model_file') and isfile(opt['model_file'] + trainstats_suffix)): # looks like we were preempted. make sure we load up our total # training stats, etc with open(opt['model_file'] + trainstats_suffix) as ts: obj = json.load(ts) self._preempted_epochs = obj.get('total_epochs', 0) self.train_time.total = obj.get('train_time', 0) self.impatience = obj.get('impatience', 0) self.valid_reports = obj.get('valid_reports', []) if opt['tensorboard_log'] is True: self.writer = TensorboardLogger(opt)
#!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. """ Generates a dictionary file from the training data. For more documentation, see `parlai.scripts.build_dict`. """ from parlai.scripts.build_dict import setup_args, build_dict if __name__ == '__main__': parser = setup_args() opt = parser.parse_args() build_dict(opt)