def main(args): conf: MainConf = init_everything(MainConf(), args, add_nn=False) zlog(f"** Run with {conf.to_json()}") # -- if conf.input_table_file: with zopen(conf.input_table_file) as fd: s = fd.read() table = eval(s) mm = table[conf.name] # read the table from file else: mm = globals()[conf.name] # -- workers = Worker.get_gpu_workers([int(z) for z in conf.gpus], ncore=int(conf.ncore)) # -- x = TuneDriver(conf.tune_conf, workers, conf.name, extra_info=mm) task_iter = [ MyTask(gid, conf.name, sel_idxes, [a[i] for a, i in zip(mm, sel_idxes)], conf.task_conf) for gid, sel_idxes in enumerate( iter_arg_choices(mm, repeat=conf.repeat, shuffle=conf.shuffle, max_num=conf.max_count)) ] x.main(task_iter)
def main(args): # conf conf: ZOverallConf = init_everything(ZOverallConf(), args) # task t_center = TaskCenter(conf.tconf) # data d_center = DataCenter(conf.dconf, specified_wset=["test"]) # load vocab t_center.load_vocabs(t_center.conf.vocab_load_dir) # prepare datasets t_center.prepare_datasets(d_center.get_datasets()) # build model model = ZModel(conf.mconf) t_center.build_mods(model) model.finish_sr() # note: build sr before possible loading in testing!! # run r_center = RunCenter(conf.rconf, model, t_center, d_center) if conf.rconf.model_load_name != "": r_center.load(conf.rconf.model_load_name) else: zwarn("No model to load, Debugging mode??") res = r_center.do_test() zlog(f"zzzztestfinal: {res}") # -- zlog("The end of Testing.")
def main(*args): conf: TrainConf = init_everything(TrainConf(), args) # -- reader = conf.train.get_reader() inputs = yield_sents(reader) extractor = RuleTargetExtractor.train(inputs, conf.econf) # save zlog(f"Save extractor to {conf.save_name}") default_json_serializer.to_file(extractor.to_json(), conf.save_name)
def main(args): conf: OverallConf = init_everything(OverallConf(), args) dconf, tconf = conf.dconf, conf.tconf # data from .train import prepare_train_data train_streamers, dev_streamers, test_streamer, _ = prepare_train_data(dconf) extra_streamers = dev_streamers if test_streamer is None else dev_streamers + [test_streamer] # vocab vpack = ZsfpVocabPackage.build_from_stream(dconf, MultiCatStreamer(train_streamers), MultiCatStreamer(extra_streamers)) vpack.save(dconf.dict_dir) zlog("The end of Building.")
def main(analyzer: str, *args): conf = MainConf() a_res = Analyzer.try_load_and_lookup(analyzer) one_conf, one_type = a_res.conf, a_res.T conf.aconf = one_conf() # -- conf = init_everything(conf, args) zlog(f"Ready to analyze with {analyzer}.") # -- ana: Analyzer = one_type(conf.aconf) ana.main()
def main(*args): conf: MainConf2 = init_everything(MainConf2(), args) # -- # first read aux ones aux_insts = list(conf.aux.get_reader()) aux_index = MyIndexer2(conf) num_aux_sent = 0 for sent in yield_sents(aux_insts): num_aux_sent += 1 fix_words(sent) aux_index.put(sent) zlog( f"Read from {conf.aux.input_path}: insts={len(aux_insts)}, sents={num_aux_sent}, len(index)={len(aux_index)}" ) # -- # then read input input_insts = list(conf.input.get_reader()) output_sents = [] num_input_sent = 0 num_reset_sent = 0 num_hit_sent = 0 cc_status = Counter() for sent in yield_sents(input_insts): num_input_sent += 1 fix_words(sent) # -- trg_sent, trg_status = aux_index.query(sent) cc_status[trg_status] += 1 if trg_sent is not None: num_hit_sent += 1 # note: currently we replace upos & tree_dep upos_vals, head_vals, deplab_vals = \ trg_sent.seq_upos.vals, trg_sent.tree_dep.seq_head.vals, trg_sent.tree_dep.seq_label.vals sent.build_uposes(upos_vals) sent.build_dep_tree(head_vals, deplab_vals) output_sents.append(sent) else: zlog(f"Miss sent: {sent.seq_word}") if not conf.output_sent_and_discard_nonhit: output_sents.append(sent) # -- zlog( f"Read from {conf.input.input_path}: insts={len(input_insts)}, sents={num_input_sent}, (out-sent-{len(output_sents)})" f"reset={num_reset_sent}({num_reset_sent/num_input_sent:.4f}) hit={num_hit_sent}({num_hit_sent/num_input_sent:.4f})" ) zlog(f"Query status: {cc_status}") # write with conf.output.get_writer() as writer: if conf.output_sent_and_discard_nonhit: writer.write_insts(output_sents) else: # write the original insts writer.write_insts(input_insts)
def main(args): # conf conf: ZOverallConf = init_everything(ZOverallConf(), args) # task t_center = TaskCenter(conf.tconf) # data d_center = DataCenter(conf.dconf) # build vocab: no try loading here!! t_center.build_vocabs(d_center) # save vocab t_center.save_vocabs(t_center.conf.vocab_save_dir) # -- zlog("The end of Building.")
def main(annotators: str, *args): # find annotators conf = MainConf() all_confs, all_ann_types = [], [] for ann_ss in annotators.split(","): if len(ann_ss) == 0: continue # ignore empty t_res, ann_ss_real = Annotator.try_load_and_lookup(ann_ss, ret_name=True) one_conf_type, one_ann_type = t_res.conf, t_res.T one_conf = one_conf_type() all_confs.append(one_conf) all_ann_types.append(one_ann_type) assert not hasattr(conf, ann_ss_real) setattr(conf, ann_ss_real, one_conf) # add conf # -- conf = init_everything(conf, args) zlog(f"Ready to annotate with {annotators}: {conf.R} {conf.W}") # init all annotators all_anns: List[Annotator] = [ at(cc) for cc, at in zip(all_confs, all_ann_types) ] # -- reader, writer = conf.R.get_reader(), conf.W.get_writer() # ===== def _process(_batch: List): for ann in all_anns: ann.annotate(_batch) writer.write_insts(_batch) # ===== with BK.no_grad_env(): # note: decoding mode!! c, c2 = 0, 0 cur_insts = [] for one in reader: # input one c += 1 cur_insts.append(one) # process? if len(cur_insts) >= conf.ann_batch_size: _process(cur_insts) cur_insts.clear() c2 += 1 if c2 % conf.report_batch_interval == 0: zlog(f"Annotate roughly: inst={c},batch={c2}") # remaining ones if len(cur_insts) > 0: _process(cur_insts) zlog(f"Annotate Finish: processed {c} insts.")
def main(args): # conf conf: ZOverallConf = init_everything(ZOverallConf(), args) # task t_center = TaskCenter(conf.tconf) # data d_center = DataCenter(conf.dconf, specified_wset=[]) # nothing to load here! # load vocab t_center.load_vocabs(t_center.conf.vocab_load_dir) # prepare datasets t_center.prepare_datasets(d_center.get_datasets()) # build model model = ZModel(conf.mconf) t_center.build_mods(model) model.finish_sr() # note: build sr before possible loading in testing!! # run r_center = RunCenter(conf.rconf, model, t_center, d_center) if conf.rconf.model_load_name != "": r_center.load(conf.rconf.model_load_name) else: zwarn("No model to load, Debugging mode??") # ===== cc = Counter() BATCH_LINE = os.environ.get('ZMSP_BATCH_LINE', 1000) # 1000 sents once time test_dataset = ZDataset(d_center.conf.testM, 'testM', 'decode', _no_load=True) # use testM for other options! for lines in yield_lines(sys.stdin, BATCH_LINE): insts = [Sent.create(one.split()) for one in lines] # note: simply split as sentence!! test_dataset.set_insts(insts) # directly set it! cc["sent"] += len(insts) if cc["sent"] % 50000 == 0: zlog(f"Decode for {cc}") # -- t_center.prepare_datasets([test_dataset]) # re-prepare!! for ibatch in test_dataset.yield_batches(loop=False): one_res = model.predict_on_batch(ibatch) # -- for inst in insts: sys.stdout.write( json.dumps(inst.to_json(), ensure_ascii=False) + "\n") # ===== zlog(f"The end of Decoding: {cc}")
def prepare_test(args): conf: OverallConf = init_everything(OverallConf(), args) dconf, tconf = conf.dconf, conf.tconf # vocab vpack = ZmtlVocabPackage.build_by_reading(dconf) # prepare data test_streamer = dconf.R.get_reader(input_path=dconf.test) # model model = build_model(conf, vpack=vpack) if dconf.model_load_name != "": model.load(dconf.model_load_name, strict=dconf.model_load_strict) else: zwarn("No model to load, Debugging mode??") # ===== # augment with extra embeddings extra_embed_files = dconf.test_extra_pretrain_wv_files model_emb = model.get_emb() if model_emb is not None: _embedder = model_emb.eg.get_embedder("word") if len(extra_embed_files ) > 0 and _embedder is not None: # has extra_emb and need_emb # get embeddings extra_embedding = WordVectors.load(extra_embed_files[0]) extra_embedding.merge_others([ WordVectors.load(one_file) for one_file in extra_embed_files[1:] ]) # get extra dictionary (only those words hit in extra-embed) extra_vocab = SimpleVocab.build_by_static(get_extra_hit_words( test_streamer, extra_embedding, vpack.get_voc("word")), pre_list=None, post_list=None) # give them to the model new_vocab = aug_words_and_embs(_embedder, vpack.get_voc("word"), extra_vocab, extra_embedding, aug_scale=dconf.pretrain_scale) vpack.put_voc("word", new_vocab) # ===== # No Cache!! test_inst_preparer = model.get_inst_preper(False) test_iter, _ = batch_stream( index_stream(test_streamer, vpack, False, False, test_inst_preparer), tconf, False) return conf, model, vpack, test_iter
def main(*args): conf: MainConf = init_everything(MainConf(), args) # -- # first read them all src_sents, trg_sents = list(yield_sents(conf.src_input.get_reader())), \ list(yield_sents(conf.trg_input.get_reader())) assert len(src_sents) == len(trg_sents) cc = Counter() conv = Converter(conf) # -- outputs = [] for src_sent, trg_sent in zip(src_sents, trg_sents): res = conv.convert(src_sent, trg_sent, cc) outputs.append(res) zlog("Stat:") OtherHelper.printd(cc) # -- with conf.output.get_writer() as writer: writer.write_insts(outputs)
def main(args): conf: OverallConf = init_everything(OverallConf(), args) dconf, tconf = conf.dconf, conf.tconf # data train_streamers, dev_streamers, test_streamer, dev_golds = prepare_train_data(dconf) # vocab if tconf.no_build_dict: # read vpack = ZmtlVocabPackage.build_by_reading(dconf) else: # include dev/test only for convenience of including words hit in pre-trained embeddings extra_streamers = dev_streamers if test_streamer is None else dev_streamers + [test_streamer] vpack = ZmtlVocabPackage.build_from_stream(dconf, MultiCatStreamer(train_streamers), MultiCatStreamer(extra_streamers)) vpack.save(dconf.dict_dir) # model model = build_model(conf, vpack=vpack) train_inst_preparer = model.get_inst_preper(True) test_inst_preparer = model.get_inst_preper(False) # actual streams prepared_train_streamers = [ train_prep_stream(index_stream(z, vpack, tconf.train_use_cache, tconf.cache_shuffle_times, train_inst_preparer), tconf) for z in train_streamers] if len(prepared_train_streamers) > 1: # ms_train ms_budgets = [ScheduledValue(f"ms_budget{i}", c) for i,c in enumerate(dconf.get_ms_train_budgets())] joined_train_streamer = MultiJoinStreamer(prepared_train_streamers, dconf.ms_stop_idx, ratios=ms_budgets) else: ms_budgets = [] joined_train_streamer = prepared_train_streamers[0] train_iter, train_batch_f = batch_stream(joined_train_streamer, tconf, True) dev_iters = [batch_stream(index_stream( z, vpack, tconf.dev_use_cache, 0, test_inst_preparer), tconf, False)[0] for z in dev_streamers] # training runner tr = ZmtlTrainingRunner.create(model, train_iter, train_batch_f, conf, dev_iters, [dconf.output+f".dev{i}" for i in range(len(dev_golds))], dev_golds) for mv in ms_budgets: # add them for scheduling! tr.add_scheduled_value(mv) # load? if tconf.load_model: # tr.load(dconf.model_load_name, tconf.load_process, load_strict=dconf.model_load_strict) tr.load(dconf.model_load_name, tconf.load_process) # go tr.run() zlog("The end of Training.")
def main(args): # conf conf: ZOverallConf = init_everything(ZOverallConf(), args) # task t_center = TaskCenter(conf.tconf) enc = t_center.tasks['enc'] # data d_center = DataCenter(conf.dconf) for dataset in d_center.get_datasets(): enc.prepare_dataset(dataset) vv = SimpleVocab.build_by_static([]) vv2 = SimpleVocab.build_by_static([]) for item in dataset.items: vv.feed_one(item._batch_len) vv2.feed_one(sum(len(z) for z in item.sents) + 1) vv.build_sort(lambda w, i, c: w) vv2.build_sort(lambda w, i, c: w) zlog( f"#== For {dataset} (subword):\n{vv.get_info_table().to_string()}") zlog(f"#== For {dataset} (word):\n{vv2.get_info_table().to_string()}") # -- zlog("The end of Building.")
def main(evaluator: str, *args): # find evaluator conf = MainConf() e_res = Evaluator.try_load_and_lookup(evaluator) one_conf, one_type = e_res.conf, e_res.T conf.econf = one_conf() # -- conf = init_everything(conf, args) zlog(f"Ready to evaluate with {evaluator}: {conf.gold} {conf.pred}") # -- gold_insts = list(conf.gold.get_reader()) pred_insts = list(conf.pred.get_reader()) evaler: Evaluator = one_type(conf.econf) res = evaler.eval(gold_insts, pred_insts) if conf.result_file: with zopen(conf.result_file, 'a') as fd: # note: here we use append mode fd.write( f"# Eval with {args}:\n{res.get_brief_str()}\n{res.get_detailed_str()}\n" ) zlog(f"Eval on {conf.gold} vs. {conf.pred}; RESULT = {res}") if conf.print_details: zlog(f"#-- details:\n{res.get_detailed_str()}")
def main(args): # conf conf: ZOverallConf = init_everything(ZOverallConf(), args) # task t_center = TaskCenter(conf.tconf) # data d_center = DataCenter(conf.dconf) # build/load vocab: try loading here, and save new built ones! _tcf = t_center.conf t_center.build_vocabs(d_center, try_load_vdir=(None if _tcf.vocab_force_rebuild else _tcf.vocab_load_dir), save_vdir=_tcf.vocab_save_dir) # prepare datasets t_center.prepare_datasets(d_center.get_datasets()) # build model model = ZModel(conf.mconf) t_center.build_mods(model) # run r_center = RunCenter(conf.rconf, model, t_center, d_center) if conf.rconf.train_preload_model: r_center.load(conf.rconf.train_preload_model) model.finish_sr() # note: build sr after possible loading in training!! r_center.do_train() # -- zlog("The end of Training.")
def main(*args): conf: MainConf = init_everything(MainConf(), args) # -- word_map_f = { "PTB": lambda x: re.sub("-LRB-", "(", re.sub("-RRB-", ")", x)), }.get(conf.word_map, lambda x: x) convert_f = None if conf.convert_f == "" else globals()[conf.convert_f] # -- # first read aux ones aux_insts = list(conf.aux.get_reader()) aux_index = MyIndexer(conf) num_aux_sent = 0 for sent in yield_sents(aux_insts): num_aux_sent += 1 aux_index.put(sent) zlog( f"Read from {conf.aux.input_path}: insts={len(aux_insts)}, sents={num_aux_sent}, len(index)={len(aux_index)}" ) # then read input input_insts = list(conf.input.get_reader()) output_sents = [] num_input_sent = 0 num_rebuild_sent = 0 num_reset_sent = 0 num_hit_sent = 0 for sent in yield_sents(input_insts): num_input_sent += 1 # -- new_word_vals = [word_map_f(w) for w in sent.seq_word.vals] if new_word_vals != sent.seq_word.vals: num_rebuild_sent += 1 sent.build_words(new_word_vals) # -- trg_sent = aux_index.query(sent) # -- debug # if trg_sent is None: # breakpoint() # trg_sent = aux_index.query(sent) # -- if trg_sent is not None: num_hit_sent += 1 # -- # note: currently we replace upos & tree_dep upos_vals, head_vals, deplab_vals = \ trg_sent.seq_upos.vals, trg_sent.tree_dep.seq_head.vals, trg_sent.tree_dep.seq_label.vals if convert_f is not None: upos_vals, head_vals, deplab_vals = convert_f( upos_vals, head_vals, deplab_vals) # -- if conf.change_words and sent.seq_word.vals != trg_sent.seq_word.vals: num_reset_sent += 1 sent.seq_word.set_vals(trg_sent.seq_word.vals) # reset it! # -- sent.build_uposes(upos_vals) sent.build_dep_tree(head_vals, deplab_vals) # -- output_sents.append(sent) else: zlog(f"Miss sent: {sent.seq_word}") if not conf.output_sent_and_discard_nonhit: output_sents.append(sent) zlog( f"Read from {conf.input.input_path}: insts={len(input_insts)}, sents={num_input_sent}, (out-sent-{len(output_sents)})" f"rebuild={num_rebuild_sent}({num_rebuild_sent/num_input_sent:.4f}), " f"reset={num_reset_sent}({num_reset_sent/num_input_sent:.4f}) hit={num_hit_sent}({num_hit_sent/num_input_sent:.4f})" ) # write with conf.output.get_writer() as writer: if conf.output_sent_and_discard_nonhit: writer.write_insts(output_sents) else: # write the original insts writer.write_insts(input_insts)
def main(*args): conf: MainConf = init_everything(MainConf(), args) # -- cons_lex = LexConstrainer(conf.lex_conf) cons_fe = FEConstrainer(conf.fe_conf) # -- # some confs lex_use_fn_style = conf.lex_conf.use_fn_style # -- # first try to read frame file if conf.frame_file: assert lex_use_fn_style, "Otherwise do not provide 'frame_file'!!s" external_frames = default_json_serializer.from_file(conf.frame_file) for fname, fv in external_frames.items(): # LU for lu in fv["lexUnit"]: lu_name = lu["name"] cons_lex.add(cons_lex.lu2feat(lu_name), fname, c=0) # no count now, only add entry lu_name2 = LexConstrainer.norm_lu(lu_name) if lu_name2 != lu_name: # also add normed name! cons_lex.add(cons_lex.lu2feat(lu_name2), fname, c=0) # FE for fe in fv["FE"]: fe_name = fe["name"] cons_fe.add(fname, fe_name, c=0) # again no count here! zlog( f"Read from {conf.frame_file}: LU={cons_lex.summary()}, FE={cons_fe.summary()}" ) # -- # then read data! if conf.train.input_path: reader = conf.train.get_reader() for sent in yield_sents(reader): for frame in sent.get_frames(conf.lex_conf.cons_ftag): frame_name = frame.type # LU feats = [] if lex_use_fn_style: # then directly use the stored one!! lu_name = frame.info.get("luName") feats.append(cons_lex.lu2feat(lu_name)) lu_name2 = LexConstrainer.norm_lu(lu_name) if lu_name2 != lu_name: feats.append(cons_lex.lu2feat(lu_name2)) # also add the plain one!! widx, wlen = frame.mention.get_span() feat = cons_lex.span2feat(frame.sent, widx, wlen) feats.append(feat) # -- for feat in feats: cons_lex.add(feat, frame_name, c=1) # FE for alink in frame.args: cons_fe.add(frame_name, alink.role, c=1) zlog( f"Read from {conf.train.input_path}: LU={cons_lex.summary()}, FE={cons_fe.summary()}" ) # -- # summary and save cons_lex.save(conf.lex_save_name) cons_fe.save(conf.fe_save_name)
def main(tconf: MyTaskConf, args): conf = MainConf() conf.task_conf = tconf conf: MainConf = init_everything(conf, args, add_nn=False) zlog(f"** Run with {conf.to_json()}") # -- if conf.tune_table_file: with zopen(conf.tune_table_file) as fd: s = fd.read() table = eval(s) mm = table.get(conf.tune_name) # read the table from file else: mm = globals().get(conf.tune_name) # -- if mm is not None: # if we can read it! # note: if tuning, we want it to be quiet conf.task_conf.quite = True # -- workers = te.Worker.get_gpu_workers([int(z) for z in conf.gpus], ncore=int(conf.ncore)) x = te.TuneDriver(conf.tune_conf, workers, conf.tune_name, extra_info=mm) task_iter = [] # -- all_runs = enumerate( te.iter_arg_choices(mm, repeat=conf.repeat, shuffle=conf.shuffle, max_num=conf.max_count)) if not conf.repeat: all_runs = list(all_runs) orig_all_runs = list(all_runs) else: orig_all_runs = None if len(conf.task_sels) > 0: assert not conf.repeat and not conf.shuffle _sels = [int(z) for z in conf.task_sels] all_runs = list(all_runs) zlog(f"Select {len(_sels)}/{len(all_runs)}: {_sels}") all_runs = [all_runs[z] for z in _sels] # -- if not conf.repeat: _max_gid = 0 if len(orig_all_runs) == 0 else max( z[0] for z in orig_all_runs) _padn = len(str(_max_gid)) _pads = f"%0{_padn}d" else: _pads = "%d" # -- for gid, sel_idxes in all_runs: # note: override run_dir!! s_gid = _pads % gid one = conf.task_conf.make_task( run_dir=f"run_{conf.tune_name}_{s_gid}", _id_str=f"{s_gid}:{sel_idxes}", _train_extras=" ".join([a[i] for a, i in zip(mm, sel_idxes)])) task_iter.append(one) x.main(task_iter) else: # otherwise single run assert not conf.tune_name task = conf.task_conf.make_task() # no setting here!! task.execute( f"CUDA_VISIBLE_DEVICES={','.join(conf.gpus)} OMP_NUM_THREADS={conf.ncore} MKL_NUM_THREADS={conf.ncore}" )
def main(*args): conf: RunConf = init_everything(RunConf(), args, add_utils=False, add_nn=False) # ===== # get paths RUN_DIR = conf.run_dir if RUN_DIR: mkdir_p(RUN_DIR, raise_error=True) os.chdir(RUN_DIR) # change to it!! SRC_DIR = zglob1(conf.src_dir, check_prefix="..", check_iter=10) VOC_DIR = zglob1(conf.voc_dir, check_prefix="..", check_iter=10) DATA_DIR = zglob1(conf.dataset.data_dir, check_prefix="..", check_iter=10) zlog( f"RUN with RUN={RUN_DIR}, SRC={SRC_DIR}, VOC={VOC_DIR}, DATA={DATA_DIR}" ) # ===== # modes dataset_choice = conf.dataset._choice is_pb, is_fn = [dataset_choice.startswith(z) for z in ["pb", "fn"]] assert is_pb or is_fn # ===== # options # -- # base ones base_opt = "conf_output:_conf" # eval if is_pb: base_opt += f" eval_conf:pb" elif is_fn: base_opt += f" dict_frame_file:{DATA_DIR}/{conf.dataset.frame_file}" base_opt += f" eval_conf:fn eval_conf.frame_file:{DATA_DIR}/{conf.dataset.frame_file}" # eval # -- # ===== # modeling if conf.use_word_input: base_opt += " ec_word.dim:300 ec_word.drop_rate:0.2 ec_word.init_from_pretrain:1 ec_word.rare_unk_thr:2" # word # base_opt += " ec_posi.dim:512" # posi? # base_opt += " ec_char.dim:50 ec_char.init_scale:5." # char? if conf.use_bert_input: base_opt += " ec_bert.dim:768 bert_model:bert-base-cased bert_output_layers:7,8,9" # bert features? base_opt += " eproj_dim:512" # -- if conf.use_rel_posi: base_opt += " enc_conf.enc_att.n_layers:2 enc_conf.enc_att.use_posi:0 enc_conf.clip_dist:16" # enc1 else: base_opt += " enc_conf.enc_att.n_layers:2 enc_conf.enc_att.use_posi:1 enc_conf.clip_dist:0" # enc1 # base_opt += " enc_conf.enc_tatt.n_layers:2 enc_conf.enc_tatt.use_posi:1" # enc1 # base_opt += " enc_conf.enc_rnn.n_layers:1 enc_conf.enc_hidden:1024" # enc1 # -- # frame base_opt += " loss_evt:0.5 pred_evt:1" # with evts base_opt += " evt_conf.cand_label_smoothing:0.05 evt_conf.label_smoothing:0.1" # label smooth base_opt += " evt_conf.lookup_conf.use_emb:0" # no adding frame embeddings? base_opt += " evt_conf.span_conf.sconf.hid_nlayer:1" # pred scorer? if conf.assume_frame: # no need for the evt module!! base_opt += " loss_evt:0 pred_evt:0 eval_conf.weight_frame:0." elif conf.assume_trg: # no need for cand, but still need to identify frame types base_opt += " evt_conf.loss_cand:0. evt_conf.loss_use_posi:1 evt_conf.pred_use_posi:1" # use-posi for evt base_opt += " evt_conf.pred_addition_non_score:-100000." # NEGINF-non if is_fn: # further use cons for fn base_opt += f" evt_cons_lex_file:{VOC_DIR}/cons_lex_{dataset_choice}.json evt_conf.pred_use_cons:1 evt_conf.pred_use_lu:1 evt_conf.loss_use_cons:0 evt_conf.loss_use_lu:0" # cons & use-lu for evt else: # evt_conf -> direct base_opt += " evt_conf.loss_cand:1.0 evt_conf.loss_lab:1.0" # loss_cand base_opt += " evt_conf.span_train_sample_rate:1.0 evt_conf.span_topk_rate:1.0 evt_conf.span_train_sample:1" # some rates # -- if is_pb: # lab is aux for pb base_opt += " evt_conf.loss_lab:0.5 evt_conf.pred_score_prune:0. evt_conf.pred_addition_non_score:-100000." elif is_fn: # lab is essential for fn base_opt += " loss_evt:1 evt_conf.loss_cand:0.5 evt_conf.span_train_sample_rate:0.33 evt_conf.span_topk_rate:0.4 evt_conf.span_train_sample:1" # -- if conf.no_frame_label: base_opt += " evt_conf.loss_lab:0. evt_conf.pred_score_prune:0. evt_conf.pred_addition_non_score:-100000." # -- # arg base_opt += " arg_use_finput:0" base_opt += f" fenc_conf.enc_att.n_layers:8 fenc_conf.clip_dist:{16 if conf.use_rel_posi else 0}" # fenc # base_opt += " fenc_conf.enc_tatt.n_layers:6" # fenc # base_opt += " fenc_conf.enc_rnn.n_layers:3 fenc_conf.enc_hidden:1024" # enc1 base_opt += " loss_arg:1. pred_arg:1" # with args base_opt += " arg_conf.label_smoothing:0.1" # label smooth if conf.arg_mode in ["span", "head"]: # arg_conf -> direct base_opt += " arg_conf.loss_cand:0.5" # loss_cand # base_opt+=" arg_conf.span_train_sample_rate:0.33 arg_conf.span_topk_rate:0.4" # some rates base_opt += " arg_conf.span_topk_rate:1. arg_conf.span_topk_count:10 arg_conf.span_train_sample:0" # some rates base_opt += " arg_conf.loss_weight_non:1." # less penalizing this? base_opt += " arg_conf.pp_check_more:1" # check non-overlapping if conf.arg_mode == "span": base_opt += " arg_conf.max_width:30 arg_conf.softhead_topk:5 arg_conf.pred_non_overlapping:1" # span elif conf.arg_mode == "head": base_opt += " arg_conf.core_span_mode:shead arg_conf.max_width:1" # head # extender base_opt += " arg_conf.loss_ext:0.5 arg_conf.pred_ext:1 arg_conf.ext_use_finput:0" base_opt += f" arg_conf.ext_conf.eenc_conf.enc_att.n_layers:1 arg_conf.ext_conf.eenc_conf.enc_att.aconf.clip_dist:{16 if conf.use_rel_posi else 0}" else: raise NotImplementedError() elif conf.arg_mode == "soft": base_opt += " arg_conf:soft" base_opt += " arg_conf.loss_ext:0.5 arg_conf.pred_ext:1 arg_conf.ext_use_finput:0" base_opt += f" arg_conf.ext_conf.eenc_conf.enc_att.n_layers:1 arg_conf.ext_conf.eenc_conf.enc_att.aconf.clip_dist:{16 if conf.use_rel_posi else 0}" base_opt += " arg_conf.pp_check_more:1" elif conf.arg_mode in ["anchor", "anchor2"]: base_opt += " arg_conf:anchor" if conf.arg_mode == "anchor2": # yet another head mode! base_opt += " arg_conf.core_span_mode:shead" base_opt += " arg_conf.loss_ext:0.5 arg_conf.pred_ext:1 arg_conf.ext_use_finput:0" base_opt += f" arg_conf.ext_conf.eenc_conf.enc_att.n_layers:1 arg_conf.ext_conf.eenc_conf.enc_att.aconf.clip_dist:{16 if conf.use_rel_posi else 0}" base_opt += " arg_conf.pp_check_more:1" elif conf.arg_mode in ["seq", "seq0"]: # arg_conf -> seq base_opt += " arg_conf:seq arg_conf.seq_scheme:BIO" # use seq mode! base_opt += " arg_conf.loss_weight_non:1." # less penalizing this? # -- if conf.arg_mode == "seq": base_opt += " arg_conf.beam_k:150 arg_conf.use_bigram:0 arg_conf.pred_use_seq_cons:1" # viterbi with constraints if conf.arg_seq_mod == "crf": # crf-mode base_opt += " arg_conf.loss_mode:crf arg_conf.use_bigram:1 arg_conf.local_normalize:0" elif conf.arg_mode == "seq0": # greedy mode: no crf and no viterbi base_opt += " arg_conf.pred_use_seq_cons:0 arg_conf.loss_mode:mle arg_conf.use_bigram:0 arg_conf.local_normalize:1" else: raise NotImplementedError() else: raise NotImplementedError() # -- # ===== # training base_opt += " ema_decay:0. ema_update_step:1" # ema if 1: UPE = 1000 # 1000 update as one epoch base_opt += " lrate.val:0.0002 anneal_times:10 anneal_patience:10 lrate.m:0.75" base_opt += f" valid_ufreq:{UPE} valid_epoch:0 max_uidx:{UPE*150} lrate_warmup_uidx:{8*UPE} lrate_decrease_alpha:0." if conf.use_rel_posi: base_opt += " train_count_mode:ftok train_batch_size:4096 accu_batch:1" # actually bs=bs*accu base_opt += " test_count_mode:ftok test_batch_size:2048" else: base_opt += " train_count_mode:ftok train_batch_size:4096 accu_batch:1" # actually bs=bs*accu base_opt += " test_count_mode:ftok test_batch_size:2048" base_opt += " df_hdrop:0.2" # general dropout else: # possibly for rnn base_opt += " lrate.val:0.002 anneal_times:10 anneal_patience:10" base_opt += " train_count_mode:frame max_eidx:100 train_batch_size:32" base_opt += " df_hdrop:0.33" # general dropout if is_pb: base_opt += " train_skip_noevt_rate:0.0" elif is_fn: base_opt += " train_skip_noevt_rate:1.0" # skip sents where no targets! # data base_opt += " " + conf.dataset.get_data_str(DATA_DIR, conf.do_ms_train) base_opt += f" pretrain_wv_file:{VOC_DIR}/hits_{dataset_choice}.vec pretrain_scale:10." # filtered pretrain file # nn base_opt += f" nn.device:0 nn.random_seed:9347{conf.cur_run} nn.random_cuda_seed:9349{conf.cur_run}" # ===== # note: base_opt is only for training!! _L_PRE = conf.log_prefix DEBUG_OPTION = "-m pdb" if conf.debug else "" TRAIN_CMD = f"CUDA_VISIBLE_DEVICES={conf.rgpu} PYTHONPATH={SRC_DIR}:$PYTHONPATH python3 {DEBUG_OPTION} -m msp2.tasks.zsfp.main.train {base_opt} log_file:{_L_PRE}_train {conf.train_extras}" # -- TEST_CMD = f"CUDA_VISIBLE_DEVICES={conf.rgpu} PYTHONPATH={SRC_DIR}:$PYTHONPATH python3 {DEBUG_OPTION} -m msp2.tasks.zsfp.main.test {conf.conf_output} log_file:{_L_PRE}_test {conf.test_extras}" # -- if conf.do_train: system(TRAIN_CMD, pp=True) # -- if conf.do_test: system(TEST_CMD, pp=True) # -- if conf.do_test_all: for tfile in conf.dataset.all_dt_files: _TMP_CMD = f"CUDA_VISIBLE_DEVICES={conf.rgpu} PYTHONPATH={SRC_DIR}:$PYTHONPATH python3 {DEBUG_OPTION} -m msp2.tasks.zsfp.main.test {conf.conf_output} test:{DATA_DIR}/{tfile} output:{conf.out_prefix}.{tfile} log_file:{_L_PRE}.{tfile} test_extra_pretrain_wv_files:{VOC_DIR}/hits_{dataset_choice}.vec {conf.test_extras}" system(_TMP_CMD, pp=True)