def do_stat(insts): cc = Counter() voc = SimpleVocab.build_empty() for sent in yield_sents(insts): cc["sent"] += 1 cc["tok"] += len(sent) cc["tok_pair"] += len(sent)**2 _tree = sent.tree_dep _deplabs = _tree.seq_label.vals _slen = len(sent) for i0 in range(_slen): for i1 in range(_slen): if abs(i0 - i1) > 5: continue path1, path2 = _tree.get_path(i0, i1) labs1, labs2 = sorted( [[_deplabs[z].split(":")[0] for z in path1], [_deplabs[z].split(":")[0] for z in path2]]) _len = len(labs1) + len(labs2) # if _len<=0 or _len>2 or "punct" in labs1 or "punct" in labs2: if _len != 2 or "punct" in labs1 or "punct" in labs2: continue _k = (tuple(labs1), tuple(labs2)) voc.feed_one(_k) # -- zlog(cc) voc.build_sort() d = voc.get_info_table() print(d[:100].to_string())
def main(args): conf = MainConf() conf.update_from_args(args) # input with zopen(conf.input) as fd: lines = list(fd) if conf.skip_blank: lines = [z for z in lines if str.isspace(z)] # shuffle? origin_len = len(lines) if conf.shuffle_times > 0 or conf.shuffle: _t = max(1, conf.shuffle_times) # at least once! _gen = Random.get_generator('') for _ in range(_t): _gen.shuffle(lines) # sample? final_size = int(0.999 + (conf.rate * origin_len if conf.rate <= 1. else conf.rate)) out_lines = lines[:final_size] # output if conf.output: with zopen(conf.output, 'w') as fd2: for line in out_lines: fd2.write(line) # -- zlog( f"Sample({conf.rate}) {conf.input}=>{conf.output}: {origin_len}=>{len(out_lines)}" )
def __init__(self, conf: MySRLConf, vocab_evt: SimpleVocab, vocab_arg: SimpleVocab, **kwargs): super().__init__(conf, **kwargs) conf: MySRLConf = self.conf self.vocab_evt = vocab_evt self.vocab_arg = vocab_arg # -- self.vocab_bio_arg = None self.pred_cons_mat = None if conf.arg_use_bio: self.vocab_bio_arg = SeqVocab(vocab_arg) # simply BIO vocab zlog(f"Use BIO vocab for srl: {self.vocab_bio_arg}") if conf.arg_pred_use_seq_cons: _m = self.vocab_bio_arg.get_allowed_transitions() self.pred_cons_mat = (1. - BK.input_real(_m)) * Constants.REAL_PRAC_MIN # [L, L] zlog(f"Further use BIO constraints for decoding: {self.pred_cons_mat.shape}") helper_vocab_arg = self.vocab_bio_arg else: helper_vocab_arg = self.vocab_arg # -- self.helper = MySRLHelper(conf, self.vocab_evt, helper_vocab_arg) # -- # predicate self.evt_node = SingleIdecNode(conf.evt_conf, ndim=conf.isize, nlab=(2 if conf.binary_evt else len(vocab_evt))) # argument self.arg_node = PairwiseIdecNode(conf.arg_conf, ndim=conf.isize, nlab=len(helper_vocab_arg))
def main(output_prefix, *input_files): # input all_sents = [] for f in input_files: one_reader = ReaderGetterConf().get_reader(input_path=f) one_insts = list(one_reader) all_sents.append([z for z in yield_sents(one_insts)]) zlog(f"Read from {f}: {len(all_sents[-1])} sents") # align sent_map = OrderedDict() for fidx, sents in enumerate(all_sents): for sent in sents: doc_id = sent.info.get("doc_id", "UNK") if doc_id.split("/", 1)[0] == "ontonotes": doc_id = doc_id.split("/", 1)[1] key = doc_id + "|".join(sent.seq_word.vals) # map by doc_id + key if key not in sent_map: sent_map[key] = [sent] else: sent_map[key].append(sent) # -- num_files = len(input_files) matched_sents = [vs for vs in sent_map.values() if len(vs) == num_files] unmatched_sents = [vs for vs in sent_map.values() if len(vs) != num_files] zlog(f"Aligned sent of {len(matched_sents)}") breakpoint() # output for outi in range(num_files): out_sents = [z[outi] for z in matched_sents] writer = WriterGetterConf().get_writer( output_path=f"{output_prefix}{outi}") writer.write_insts(out_sents) writer.close()
def __init__(self, conf: PlainInputEmbedderConf, voc: SimpleVocab, npvec: np.ndarray = None, name="UNK"): super().__init__(conf, name) # -- conf: PlainInputEmbedderConf = self.conf self.voc = voc # check init embeddings if conf.init_from_pretrain: zlog( f"Try to init {self.extra_repr()} with npvec.shape={npvec.shape if (npvec is not None) else None}" ) if npvec is None: zwarn("warning: cannot get pre-trained embeddings to init!!") # get rare unk range voc_rare_unk_mask = [] for w in self.voc.full_i2w: c = self.voc.word2count(w, df=None) voc_rare_unk_mask.append( float(c is not None and c <= conf.rare_unk_thr)) self.rare_unk_mask = BK.input_real(voc_rare_unk_mask) # stored tensor! # self.register_buffer() # todo(note): do we need register buffer? self.use_rare_unk = (conf.rare_unk_rate > 0. and conf.rare_unk_thr > 0) # add the real embedding node self.E = EmbeddingNode(conf.econf, npvec=npvec, osize=conf.dim, n_words=len(self.voc))
def __init__(self, conf: ZDecoderSRLConf, name: str, vocab_evt: SimpleVocab, vocab_arg: SimpleVocab, ref_enc: ZEncoder, **kwargs): super().__init__(conf, name, **kwargs) conf: ZDecoderSRLConf = self.conf self.vocab_evt = vocab_evt self.vocab_arg = vocab_arg _enc_dim, _head_dim = ref_enc.get_enc_dim(), ref_enc.get_head_dim() # -- self.vocab_bio_arg = None self.pred_cons_mat = None if conf.arg_use_bio: self.vocab_bio_arg = SeqVocab(vocab_arg) # simply BIO vocab zlog(f"Use BIO vocab for srl: {self.vocab_bio_arg}") if conf.arg_pred_use_seq_cons: _m = self.vocab_bio_arg.get_allowed_transitions() self.pred_cons_mat = (1. - BK.input_real(_m)) * Constants.REAL_PRAC_MIN # [L, L] zlog(f"Further use BIO constraints for decoding: {self.pred_cons_mat.shape}") helper_vocab_arg = self.vocab_bio_arg else: helper_vocab_arg = self.vocab_arg # -- self.helper = ZDecoderSRLHelper(conf, self.vocab_evt, helper_vocab_arg, self.vocab_arg) # -- # nodes self.evt_node: IdecNode = conf.evt_conf.make_node(_isize=_enc_dim, _nhead=_head_dim, _csize=(2 if conf.binary_evt else len(vocab_evt))) self.arg_node: IdecNode = conf.arg_conf.make_node(_isize=_enc_dim, _nhead=_head_dim, _csize=len(helper_vocab_arg)) self.arg2_node: IdecNode = conf.arg2_conf.make_node(_isize=_enc_dim, _nhead=_head_dim, _csize=len(self.vocab_arg)) # -- raise RuntimeError("Deprecated after MED's collecting of scores!!")
def run_test_dataset(self, dataset: ZDataset): test_recorder = StatRecorder(timing=True) for ibatch in dataset.yield_batches(loop=False): with test_recorder.go(): one_res = self.model.predict_on_batch(ibatch) test_recorder.record(one_res) # -- # write output if self.is_main_process: # note: do saving only with main process dataset.write_insts(None) # use dataset's conf # -- # eval x = test_recorder.summary() zlog(f"Test-Info: {OtherHelper.printd_str(x, sep=' ')}") aggr = ResultAggregator() for task in self.t_center.tasks.values(): if task.name not in dataset.tasks: continue tn_res: ResultRecord = task.eval_insts(dataset.gold_insts, dataset.insts, quite=False) if tn_res is None: continue aggr.add(task.name, tn_res, task.conf.eval_weight) ret = aggr.get_res() return ret
def adjust_at_ckp(self, sname: str, obj: object, extra_info: str = ""): the_idx = getattr(obj, self.sv_conf.which_idx) old_val, new_val = self._set(the_idx) if self.cur_val != old_val: zlog(f"Change scheduled value {self.name}({extra_info}) at {sname}: {old_val} => {self.cur_val}.") else: zlog(f"Keep scheduled value {self.name}({extra_info}) at {sname} as {self.cur_val}.")
def __init__(self, corpus): from sklearn.feature_extraction.text import TfidfVectorizer vectorizer = TfidfVectorizer() X = vectorizer.fit_transform(corpus) self.vectorizer = vectorizer self.X = X # [n_sample, n_feat]<Sparse> zlog(f"Build SimpleTfIdfSearcher of {X.shape}")
def __init__(self, conf: UDAnalyzerConf): super().__init__(conf) conf: UDAnalyzerConf = self.conf # -- # read main files main_insts = list(conf.main.get_reader(input_path=conf.gold)) self.set_var("main", main_insts, explanation="init") # eval self.evaler = DparEvaler(conf.econf) # -- all_sents = [list(yield_sents(main_insts))] all_toks = [[t for s in yield_sents(main_insts) for t in s.tokens]] for one_pidx, one_pred in enumerate(conf.preds): one_insts = list(conf.extra.get_reader(input_path=one_pred)) # get all of them one_sents = list(yield_sents(one_insts)) assert len(one_sents) == len(all_sents[0]) # eval eres = self.evaler.eval(main_insts, one_insts) zlog(f"#=====\nEval with {conf.main} vs. {one_pred}: res = {eres}\n{eres.get_detailed_str()}") # -- all_sents.append(one_sents) all_toks.append([t for s in one_sents for t in s.tokens]) # -- s_lists = [MatchedList(z) for z in zip(*all_sents)] self.set_var("sl", s_lists, explanation="init") # sent pair s_toks = [MatchedList(z) for z in zip(*all_toks)] self.set_var("tl", s_toks, explanation="init") # token pair
def delete(self, wid: int): self.lock.acquire() if wid >= 0 and wid < len(self.workers): self.workers[wid].mark_delete() else: zlog(f"Err in WPool: invalid worker-id {wid}.") self.lock.release()
def load_vocabs(self, v_dir: str, quiet=False): info = OrderedDict() for n, t in self.tasks.items(): info[n] = t.load_vocab(v_dir) if not quiet: zlog(f"Load vocabs from {v_dir}, success={info}") return info
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 _run_end(self): x = self.test_recorder.summary() zlog(f"Test-Info: {OtherHelper.printd_str(x, sep=' ')}") res = self._go_end() # use eval results instead! res.results['info'] = x # add the infos self.test_recorder.reset() # reset recorder! return res
def build_vocabs(self, d_center: DataCenter, try_load_vdir=None, save_vdir=None): # first try load vocabs if try_load_vdir is not None: load_info = self.load_vocabs(try_load_vdir, quiet=True) else: load_info = OrderedDict() load_names = [k for k, v in load_info.items() if v] # then build for those not loaded! build_names = [] for n, t in self.tasks.items(): if not load_info.get(n, False): # if not loaded! t_datasets = d_center.get_datasets( task=n) # obtain by task name!! # -- assert t.vpack is None t.vpack = t.build_vocab(t_datasets) # -- build_names.append(n) if save_vdir is not None: t.save_vocab(save_vdir) zlog( f"Build vocabs: load {load_names} from {try_load_vdir}, build {build_names}" )
def _proj_grads(self, flattened_grads): _shuffle = self.conf.shuffle_losses if _shuffle: _gen = Random.get_generator('loss') _rates = self.conflicting_change_rates # -- all_g = [] for i, cur_g in enumerate(flattened_grads): new_g = cur_g.clone() other_idxes = list(range(len(flattened_grads))) if _shuffle: _gen.shuffle(other_idxes) for j in other_idxes: other_g = flattened_grads[j] rate = _rates[i][j] if rate > 0.: _dot = (new_g * other_g).sum() _other_s2 = (other_g * other_g).sum() _offset = (_dot / _other_s2) * other_g new_g.sub_(rate * ((_dot < 0).float() * _offset)) # -- just checking! if BK.get_value(_dot).item() < 0: zlog( f"Here! _dot<0 as _dot={_dot}, _off={_dot / _other_s2}" ) # -- all_g.append(new_g) ret = BK.stack(all_g, 0).sum(0) # [*] return ret
def aug_vocab_and_arr(main_vocab, main_arr, aug_vocab, aug_arr, aug_override: bool): # first merge the vocab new_vocab = SimpleVocab.merge_simple_vocabs( [main_vocab, aug_vocab], sorting=False, pre_list=main_vocab.pre_list, post_list=main_vocab.post_list) # then find the arrays # todo(+1): which order to find words assert aug_override, "To be implemented for other ordering!" # -- new_arr = [main_arr[i] for i in range(len(main_vocab.pre_list))] main_hit = aug_hit = 0 for idx in range(*(new_vocab.non_special_range())): word = new_vocab.idx2word(idx) # todo(warn): selecting the embeds in aug first (make it possible to override original ones!) aug_orig_idx = aug_vocab.get(word) if aug_orig_idx is None: main_orig_idx = main_vocab[word] # must be there! new_arr.append(main_arr[main_orig_idx]) main_hit += 1 else: new_arr.append(aug_arr[aug_orig_idx]) aug_hit += 1 new_arr.extend( [main_arr[i] for i in range(-len(main_vocab.post_list), 0)]) # -- zlog( f"For the final merged arr, the composition is all={len(new_arr)},main={main_hit},aug={aug_hit}" ) ret_arr = np.asarray(new_arr) return new_vocab, ret_arr
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 do_ae(self, pi: int, ss: str): pi = int(pi) einfo = self.cur_obj.err_infos[pi] old_explains = einfo.get_explains() einfo.set_explains(ss) new_explains = einfo.get_explains() zlog(f"Change #{pi} from {old_explains} to {new_explains}")
def pp(self, method: str, printing=False, **kwargs): from .helper2 import MyPrettyPrinter ff = getattr(MyPrettyPrinter, method) ss = ff(self, **kwargs) if printing: zlog(ss) return ss
def _next(self): ret = self.eos # by default, EOS if no one can return anything cur_idx, cur_ratio = self._cur_idx, self._cur_ratio # at most travel one round + 1 for _ in range(self._num_streamers + 1): flag_ok = False if cur_ratio <= 0.: pass # no budget elif cur_ratio < 1. and next(self._random_sampler) >= cur_ratio: pass # not hit with random ratio else: # try to get one cur_streamer = self._base_streamers[cur_idx] one, _iseos = cur_streamer.next_and_check() if _iseos: if self._stop_sidx == cur_idx: if self.verbose: zlog(f"End for one, count = {self._cur_counts}", func='report') return self.eos # directly EOS since SIDX returns EOS else: self._cur_counts[cur_idx] += 1 # record ret = one flag_ok = True # -- if flag_ok: self._cur_idx, self._cur_ratio = cur_idx, cur_ratio - 1 # cost one for the current step break else: # forward one streamer cur_idx = (cur_idx + 1) % self._num_streamers cur_ratio = float(self._ratios[cur_idx]) return ret
def iter_arg_choices(m: List, repeat=True, shuffle=True, max_num=-1): _gen = Random.get_generator("tune") # -- idx = 0 # expand fully args_pool = None if not repeat: args_pool = [[]] for cur_items in m: new_pool = [] for a in args_pool: for one_idx in range(len(cur_items)): new_pool.append(a + [one_idx]) args_pool = new_pool # -- zlog("** Arrange non-repeat iter, sized %d." % len(args_pool)) if shuffle: for _ in range(10): _gen.shuffle(args_pool) else: args_pool.reverse() # later using pop while True: if idx == max_num: break if repeat: sel_idxes = [_gen.randint(len(one)) for one in m] else: if len(args_pool) > 0: sel_idxes = args_pool.pop() else: break # ----- yield sel_idxes # return selection idxes idx += 1
def __init__(self, conf: BertEncoderConf, other_embed_nodes: Dict[str, EmbeddingNode] = None, other_embed_borrowing=True): super().__init__(conf) # -- conf: BertEncoderConf = self.conf zlog( f"Loading pre-trained bert model for Berter2 of {self.extra_repr()}" ) # make a impl and add module self.impl = BerterImpl.create(conf.bert_model, cache_dir=conf.cache_dir_or_none) if conf.bert_ft: # fine-tune it! self.add_module("M", ModuleWrapper(self.impl.model, None)) # reg it! zlog(f"Load ok, move to default device {BK.DEFAULT_DEVICE}") self.impl.model.to(BK.DEFAULT_DEVICE) # -- # other embedding node (by default just borrowing) self.other_embed_nodes = other_embed_nodes if not other_embed_borrowing and other_embed_nodes is not None: # include the modules for _k, _n in other_embed_nodes.items(): self.add_module(f"_N{_k}", _n) # output combiner self.combiner = CombinerNode(conf.bert_combiner, isizes=[self.impl.hidden_size] * len(conf.bert_output_layers)) # get max layer _nl = self.impl.num_hidden_layers # 0 is emb layer!! self.actual_output_layers = [ z if z >= 0 else (_nl + 1 + z) for z in conf.bert_output_layers ]
def main(args): conf = MainConf() conf.update_from_args(args) stat = Counter() if conf.domain_f in DOMAIN_FS: domain_f = DOMAIN_FS[conf.domain_f] else: domain_f = eval(conf.domain_f) # -- all_insts = {} # ID->List[inst] with zopen(conf.input) as fin: for line in fin: inst = json.loads(line) domain = domain_f(inst) if domain not in all_insts: all_insts[domain] = [] all_insts[domain].append(inst) stat["inst"] += 1 stat[f"inst_{domain}"] += 1 # -- # write input_name = os.path.basename(conf.input) for domain, insts in all_insts.items(): output_name_fields = input_name.split(".") output_name_fields.insert(conf.output_insert_place, domain) output_name = os.path.join(conf.output_dir, ".".join(output_name_fields)) zlog(f"Write to {output_name} {len(insts)}") with zopen(output_name, 'w') as fout: default_json_serializer.save_iter(insts, fout) # -- zlog(f"Read from {fin}, stat=\n{OtherHelper.printd_str(stat)}")
def do_ap(self, **kwargs): cur_obj_info = self.obj_info(self.cur_obj, **kwargs) ret = "" if cur_obj_info is not None: ret += cur_obj_info + "\n" ret += self.cur_status zlog(ret)
def loss_on_batch(self, annotated_insts: List, loss_factor=1., training=True, **kwargs): self.refresh_batch(training) # -- sents: List[Sent] = list(yield_sents(annotated_insts)) # == # extend to events import numpy as np bsize = sum(len(z.events) for z in sents) mlen = max(len(z) for z in sents) arr_preds = np.full([bsize, mlen], 0., dtype=np.int32) arr_inputs = np.full([bsize, mlen], b'<pad>', dtype=object) arr_labels = np.full([bsize, mlen], b'<pad>', dtype=object) ii = 0 for sent in sents: for evt in sent.events: widx, wlen = evt.mention.get_span() assert wlen == 1 # -- arr_preds[ii, widx] = 1 arr_inputs[ii, :len(sent)] = [ s.lower().encode() for s in sent.seq_word.vals ] # -- tmp_labels = ["O"] * len(sent) for arg in evt.args: role = arg.role a_widx, a_wlen = arg.arg.mention.get_span() a_labs = ["B-" + role] + ["I-" + role] * (a_wlen - 1) assert all(z == "O" for z in tmp_labels[a_widx:a_widx + a_wlen]) tmp_labels[a_widx:a_widx + a_wlen] = a_labs # -- arr_labels[ii, :len(sent)] = [z.encode() for z in tmp_labels] # -- ii += 1 assert ii == bsize features, labels = data.lookup(({ "preds": NpWarapper(arr_preds), "inputs": NpWarapper(arr_inputs) }, NpWarapper(arr_labels)), "train", self.params) # == final_loss = self.M(features, labels) info = { "inst": len(annotated_insts), "sent": len(sents), "fb": 1, "loss": final_loss.item() } if training: assert final_loss.requires_grad BK.backward(final_loss, loss_factor) zlog( f"batch shape = {len(annotated_insts)} {bsize} {mlen} {bsize*mlen}" ) return info
def __init__(self, conf: SRLAnalyzerConf): super().__init__(conf) conf: SRLAnalyzerConf = self.conf self.err_map = ErrDetail.ERR_MAPS[conf.err_map] # -- if conf.pre_load: self.do_load(conf.pre_load) else: # further analyze the arguments num_pred = len(conf.preds) f_lists = self.get_var("fl") # get frame matches f_all_correct_list = [] f_some_wrong_list = [] for fl in f_lists: gold_frame = fl.gold pred_frames = fl.preds assert len(pred_frames) == num_pred # get them all self._process_args(gold_frame) err_infos = [] for pf in pred_frames: self._process_args(pf) # sort args einfo = ErrInfo.create(gold_frame, pf) err_infos.append(einfo) fl.err_infos = err_infos # -- if all(e.fully_correct() for e in err_infos): f_all_correct_list.append(fl) else: f_some_wrong_list.append(fl) self.set_var("fl1", f_all_correct_list, explanation="init") # eval pair self.set_var("fl0", f_some_wrong_list, explanation="init") # eval pair zlog( f"All frames = {len(f_lists)}, all_corr = {len(f_all_correct_list)}({len(f_all_correct_list)/max(1, len(f_lists))})" ) # -- # breakdowns for all for pi in range(num_pred): one_err_infos = [ e for fl in f_lists for e in fl.err_infos[pi].rps ] self.set_var(f"eip{pi}", one_err_infos) # self.do_group(f"eip{pi}", "d.get_signature('etype', 'etype2', emap=self.err_map)") self.do_group(f"eip{pi}", "d.get_signature('etype', emap=self.err_map)") self.do_group(f"eip{pi}", "d.get_signature('etype2')") # group eip0 "d.get_signature('etype2')" # fg eip0 "d.get_signature('explain')!='_'" "d.get_signature('explain')" # -- # get ps objects # self.set_var("dps100", self._get_dpath_objects(f_lists, 100)) # -- # load vocab if conf.load_vocab: from msp2.utils import default_pickle_serializer self.vocabs, _ = default_pickle_serializer.from_file( conf.load_vocab)
def __init__(self, conf: PairScorerConf, **kwargs): super().__init__(conf, **kwargs) conf: PairScorerConf = self.conf # -- # rs self.rs = RScorerNode(conf.rs) self.apply_osize = conf.osize * self.rs.piece # -- self.use_input_flags = [ conf.use_input0, conf.use_input1, conf.use_input_pair ] # use what in ff1 and ff2 self.input_sizes = [conf.isize0, conf.isize1, conf.isizeP] self.input_sizes_valid = [ s for s, f in zip(self.input_sizes, self.use_input_flags) if f ] # -- # add components assert conf.use_ff1 or conf.use_ff2 or conf.use_biaffine, "No real calculations here!" # bias if conf.use_bias: self.B = BK.new_param([self.apply_osize]) # ff1 if conf.use_ff1: self.FF1s = [] for one_size, one_flag in zip(self.input_sizes, self.use_input_flags): if one_flag: one_node = get_mlp( one_size, self.apply_osize, conf.ff1_hid_size, conf.ff1_hid_layer, AffineConf().direct_update(out_act=conf.ff1_hid_act), AffineConf().direct_update(no_drop=True, use_bias=False)) self.add_module(f"FF1_{len(self.FF1s)}", one_node) else: one_node = lambda x: 0. self.FF1s.append(one_node) # ff2 if conf.use_ff2: self.FF2 = get_mlp( self.input_sizes_valid, self.apply_osize, conf.ff2_hid_size, conf.ff2_hid_layer, AffineConf().direct_update(out_act=conf.ff2_hid_act, which_affine=3), AffineConf().direct_update(no_drop=True, use_bias=False)) # biaffine if conf.use_biaffine: # this is different than BK.bilinear or layers.BiAffine self.BW = BK.new_param( [conf.isize0, conf.isize1 * self.apply_osize]) if conf.biaffine_div <= 0.: conf.biaffine_div = (conf.isize0 * conf.isize1)**0.25 # sqrt(sqrt(in1*in2)) zlog( f"Adopt biaffine_div of {conf.biaffine_div} for the current PairScorer!" ) # todo(note): no dropout at output, add it if needed! # -- self.reset_parameters()
def main(args): conf, model, vpack, test_iter = prepare_test(args) dconf = conf.dconf # go rr = ZsfpTestingRunner(model, test_iter, conf, dconf.output, dconf.test) res = rr.run() zlog(f"zzzfinal: {res}") zlog("The end of testing.")
def set_var(self, target: str, v: object, explanation=None): if hasattr(self.vars, target): zlog(f"Overwriting the existing var `{target}'") if target not in self.traces: self.traces[target] = [] # (explanation, history-idx) self.traces[target].append((explanation, len(self.history))) setattr(self.vars, target, v)