def call_run(run_fn): import numpy as np params = NS.from_dict(json.loads(sys.stdin.read())) def load_data(name, path, **ignored): if isinstance(path, str) and data_keys.match(name): return name, np.load(path, allow_pickle=True) return name, path print(params.dataset) ds = NS.walk(params.dataset, load_data) config = params.config config.framework_params = NS.dict(config.framework_params) try: result = run_fn(ds, config) res = dict(result) for name in ['predictions', 'truth', 'probabilities']: arr = result[name] if arr is not None: res[name] = os.path.join(config.result_dir, '.'.join([name, 'npy'])) np.save(res[name], arr, allow_pickle=True) except Exception as e: log.exception(e) res = dict(error_message=str(e), models_count=0) print(config.result_token) print(json.dumps(res, separators=(',', ':')))
def parse_id(self): value = True if self.cur == '!': value = False self.i += 1 self.skip_spaces() # TODO(maximsmol): support other "truthy" and "falsy" values? if self.cur == '0': self.i += 1 return Namespace(type='const', val=(not value)) if self.cur == '1': self.i += 1 return Namespace(type='const', val=value) if self.cur != '$': putter.die(f'$ does not preceed macro name in {cf.bold(self.x)}.') self.i += 1 res = '' while self.i < self.l and self.cur not in ' \t)&|': if self.cur == '(': putter.die(f'Unexpected ( in macro name in {cf.bold(self.x)}.') res += self.cur self.i += 1 self.skip_spaces() return Namespace(type='macro', name=res, setto=value)
def parse_folder_command(self, res, parts): assert len(parts) >= 2 name = strip_quotes(parts[1]) if name not in res.folders: res.folders[name] = Namespace(files=[], libs=[], folders=Namespace()) # TODO(maximsmol): we lose definition order information here so something might break folder = res.folders[name] if len(parts) == 3: folder.cond = parse_cond(parts[2]) else: assert len(parts) == 2 for cmd, body_parts in self.parse_body_commands(): if cmd == 'folder': self.parse_folder_command(folder, body_parts) elif cmd in ['file', '-file', 'dynamicfile', '-dynamicfile']: self.parse_file_command(folder.files, parts) elif cmd in ['lib', 'libexternal']: lib = Namespace(type=cmd, paths=string_like(body_parts[1])) folder.libs.append(lib) if len(body_parts) == 3: lib.cond = parse_cond(body_parts[2]) else: assert len(body_parts) == 2 else: self.die(f'Unknown folder command {cf.bold(cmd)}.')
def _parse(self): res = Namespace(projects=Namespace(), groups=Namespace(), games=[], includes=[]) while self.token is not None: self.parse_command(res) return res
def _mk_cmd_list_schema(pretty_prefix, *args, declarative=False): res = Namespace(type='cmd_list', pretty_prefix=pretty_prefix, cmds=Namespace(), declarative=declarative) for cmd in args: assert cmd.name not in res.cmds res.cmds[cmd.name] = cmd return res
def print_generic_dict(x_name): x_key = vpc.configuration_commands[x_name].pythonized if x_key not in inst: return # TODO(maximsmol): print the merging process merged = Namespace() for x in inst[x_key]: if 'cond' not in x or eval_cond(x.cond): merge_command_data(merged, x) with putter.group(x_name): for k, v in merged.items(): print(f'{cf.bold(k)} = {cf.bold(v)}')
def finish_cur_res(): nonlocal cur_res assert not in_cond assert not in_str if part != '': cur_res.parts.append(Namespace(type='raw', x=part)) # do not push empty tokens if len(cur_res.parts) == 0 and 'comment' not in cur_res: return push_token(cur_res) cur_res = Namespace(type='parts', parts=[])
def eval_cond(x): if x.type == 'or': for c in x.conds: if not eval_cond(c): continue return True return False elif x.type == 'and': for c in x.conds: if eval_cond(c): continue return False return True elif x.type == 'const': return x.val elif x.type == 'macro': if x.name not in macro_state: # putter.die(f'Macro {x.name} is not defined.') return False == x.setto state = macro_state[x.name] if isinstance(state, bool): return state == x.setto if not isinstance(state, str): self.die(f'Cond {state} has invalid type.') # print(f'{state}, {x.name}') # assert False expr = expand_macros_in_string(state) return eval_cond(parse_cond(Namespace(type='cond', x=expr))) == x.setto else: putter.die(f'Unknown condition type: {cf.bold(x.type)}')
def __init__(self, model_save_path): self.modelconfig = json.load(open(os.path.join(model_save_path, 'layoutLM_config.json'), 'r', encoding='utf-8')) self.config = Namespace(**self.modelconfig) # super(TablePredictHandler, self).__init__(self.config) self.model_save_path = model_save_path self.pretrainmodelpath = self.config.pretrainmodelpath self.loadmodel(model_save_path)
def parse_command(self, res): parts = self.parse_command_parts() cmd = self.need_command(parts) if cmd == 'include': assert len(parts) == 2 res.includes.append(strip_quotes(parts[1])) elif cmd == 'games': assert len(parts) == 1 for body_parts in self.parse_body(): assert len(body_parts) == 1 res.games.append(strip_quotes(body_parts[0]).lower()) elif cmd == 'group': assert len(parts) >= 1 projects = [] for body_parts in self.parse_body(): assert len(body_parts) == 1 projects.append(strip_quotes(body_parts[0])) for g_name in parts[1:]: g_name = strip_quotes(g_name) group = res.groups.setdefault(g_name, Namespace()) group.setdefault('projects', []).extend(projects) elif cmd == 'project': assert len(parts) == 2 name = strip_quotes(parts[1]) if name in res.projects: self.die(f'Duplicate project {cf.bold(name)}.') proj = res.projects.setdefault(name, Namespace()) paths = proj.setdefault('paths', []) for body_parts in self.parse_body(): path = strip_quotes(body_parts[0]) if len(body_parts) == 2: cond = parse_cond(body_parts[1]) paths.append(Namespace(path=path, cond=cond)) else: assert len(body_parts) == 1 paths.append(Namespace(path=path)) else: print(parts) self.die(f'Unknown command {cf.bold(cmd)}.')
def parse_command_parts(self, merge_strings=False): tok = self.consume_token() if tok is None: self.die('Unexpected EOF: missing command parts.') assert tok.type == 'parts' l = len(tok.parts) res = Namespace(parts=[]) strs_to_merge = [] def push_merged_str(): if len(strs_to_merge) == 0: return res.parts.append( Namespace(type='str', x=''.join([x.x for x in strs_to_merge]))) for i, x in enumerate(tok.parts): if x.type == 'str': if not merge_strings: res.parts.append(x) continue strs_to_merge.append(x) continue push_merged_str() if x.type == 'raw': res.parts.append(x) continue if x.type == 'cond': assert i == l - 1 res.parts.append(x) continue self.die(f'Unknown token "{cf.bold(x.type)}".') if 'comment' in tok: res.comment = tok.comment # TODO(maximsmol): handle comments properly if 'comment' in res: pass return res.parts
def parse_cmd_schema(self, res, schema, parts): assert schema.type == 'cmd' part_cmd = self.need_command(parts, lowercase=False) assert part_cmd == schema.name i = 1 l = len(parts) def cast_arg(arg_type, x): if arg_type == 'str': return strip_quotes(x) if arg_type == 'sym': return raw_string(x) if arg_type == 'any_str': return string_like(x) if arg_type == 'merged_str': nonlocal i res = [strip_quotes(x)] while True: if i >= l: break cur = parts[i] if cur.type != 'str': break res.append(strip_quotes(x)) i += 1 return ''.join(res) self.die(f'Unknown argument type {cf.bold(arg_type)}.') # args begin at idx 1 optional_args_start = 1 + len(schema.args) while i < l: cur = parts[i] if cur.type == 'cond': # cond is only allowed at the very end assert i == l - 1 res.cond = parse_cond(cur) break if i < optional_args_start: arg_type = schema.args[i - 1] elif i - optional_args_start < len(schema.optional_args): arg_type = schema.optional_args[i - optional_args_start] else: self.die(f'Too many arguments for {cf.bold(schema.name)}') # must increment here because cast_arg will need lookahead to merge strings i += 1 res.setdefault('args', []).append(cast_arg(arg_type, cur)) if schema.body_schema is not None: res.body = Namespace() for cmd, body_parts in self.parse_body_commands(lowercase=False): self.parse_cmd_list_schema(res.body, schema.body_schema, body_parts)
def parse_file_command(self, res, parts): cmd = self.need_command(parts, lowercase=False) file = Namespace( type=cmd, # TODO(maximsmol): strip - paths=[], instructions=[]) res.append(file) if parts[-1].type == 'cond': file.cond = parse_cond(parts[-1]) parts = parts[:-1] for p in parts[1:]: file.paths.append(strip_quotes(p)) if self.token.type == '{': for cmd, parts in self.parse_body_commands(): if cmd == 'configuration': self.parse_configuration_comamnd(file, parts) else: self.die(f'Unknown file command {cf.bold(cmd)}.')
def _mk_cmd_schema(name, pythonized_name=None, args=[], optional_args=[], body_schema=None, allow_cond=True): return Namespace(name=name, type='cmd', args=args, optional_args=optional_args, pythonized_name=pythonized_name, body_schema=body_schema, allow_cond=True)
def parse_configuration_comamnd(self, res, parts): inst = Namespace(type='configuration') res.instructions.append(inst) if len(parts) == 2: inst.name = strip_quotes(parts[1]) else: assert len(parts) == 1 def generic_prop_group(group_data, body_parts): group = Namespace() inst.setdefault(group_data.pythonized, []).append(group) if group_data.nargs > 0: group.args = body_parts[1:group_data.nargs + 1] if len(body_parts) == group_data.nargs + 2: group.cond = parse_cond(body_parts[-1]) else: assert len(body_parts) == group_data.nargs + 1 if group_data.allow_body: for cmd, body_parts in self.parse_body_commands( lowercase=False): group.setdefault(cmd, []).append(body_parts[1:]) elif self.token.type == '{': # TODO(maximsmol): use the real name here self.die( f'Configuration command {group_data.pythonized} should not have a body.' ) for cmd, body_parts in self.parse_body_commands(lowercase=False): if cmd not in configuration_commands: self.die(f'Unknown configuration command {cf.bold(cmd)}.') generic_prop_group(configuration_commands[cmd], body_parts)
def parse_or(self): res = [] while self.i < self.l: res.append(self.parse_and()) if self.i >= self.l: break if self.cur == '|' and self.cur == '|': self.i += 2 else: break self.skip_spaces() if len(res) == 1: return res[0] return Namespace(type='or', conds=res)
def parse_cmd_list_schema(self, res, schema, parts): assert schema.type == 'cmd_list' cmd = self.need_command(parts, lowercase=False) if cmd not in schema.cmds: self.die(f'Unknown {schema.pretty_prefix} command') cmd_data = Namespace(cmd=cmd) cmd_schema = schema.cmds[cmd] self.parse_cmd_schema(cmd_data, cmd_schema, parts) if schema.declarative: if cmd in res: self.die(f'Duplicate {cmd}.') res[cmd] = cmd_data return res.setdefault('instructions', []).append(cmd_data)
def test(model_path, vocab_path, data_path, solver_log, batch_size, Config): graph = ontology_declaration() viol_logger = logging.getLogger('regr.graph.allennlp.utils.violation') viol_logger.propagate = False fh = logging.FileHandler('violations.log', 'w') formatter = logging.Formatter('%(message)s') fh.setFormatter(formatter) viol_logger.addHandler(fh) viol_logger.setLevel(logging.DEBUG) Config = Namespace(Config) Config.Model.graph.inference_testing_set = False Config.Model.graph.inference_loss = False Config.Model.graph.inference_interval = 100 lbp = model_declaration(graph, Config.Model) seed() lbp.load(model_path, 'last', vocab_path) metrics = lbp.test(data_path, solver_log, batch_size, log_violation=True) print(metrics)
def generic_prop_group(group_data, body_parts): group = Namespace() inst.setdefault(group_data.pythonized, []).append(group) if group_data.nargs > 0: group.args = body_parts[1:group_data.nargs + 1] if len(body_parts) == group_data.nargs + 2: group.cond = parse_cond(body_parts[-1]) else: assert len(body_parts) == group_data.nargs + 1 if group_data.allow_body: for cmd, body_parts in self.parse_body_commands( lowercase=False): group.setdefault(cmd, []).append(body_parts[1:]) elif self.token.type == '{': # TODO(maximsmol): use the real name here self.die( f'Configuration command {group_data.pythonized} should not have a body.' )
def __init__(self, app): Namespace.__init__(self) self._app = app
def build_project(name): project_data = Namespace(configuration=Namespace(compiler=Namespace())) root_path = None def build_data(path): data = read_project(path) for inst in data.instructions: if inst.type == 'conditional': val = expand_macros_in_string(inst.value) if 'cond' not in inst or eval_cond(inst.cond): if val == '1': val = True if val == '0': val = False if val in no_strings or val in yes_strings: putter.warning( f'Found yes/no string but refusing to convert it: {render_macro_value(val)}' ) print( f'{cf.magenta("Set conditional")} {cf.bold("$"+inst.name)} = {render_macro_value(val)}{cond_suffix(inst)}' ) if inst.name in macro_state and val != macro_state[ inst.name]: with putter.indent(): putter.warning( f'Overriding old value of {render_macro_value(macro_state[inst.name])}' ) macro_state[inst.name] = val else: print( f'Not setting conditional {cf.bold("$"+inst.name)} = {render_macro_value(val)}{cond_suffix(inst)} due to the false condition' ) elif inst.type == 'macro': val = expand_macros_in_string(inst.value) if 'cond' not in inst or eval_cond(inst.cond): if val == '1': val = True if val == '0': val = False if val in no_strings or val in yes_strings: putter.warning( f'Found yes/no stringbut refusing to convert it: {render_macro_value(val)}' ) print( f'{cf.magenta("Set")} {cf.bold("$"+inst.name)} = {render_macro_value(val)}{cond_suffix(inst)}' ) if inst.name in macro_state and val != macro_state[ inst.name]: with putter.indent(): putter.warning( f'Overriding old value of {render_macro_value(macro_state[inst.name])}' ) macro_state[inst.name] = val else: print( f'Not setting {cf.bold("$"+inst.name)} = {render_macro_value(val)}{cond_suffix(inst)} due to the false condition' ) elif inst.type == 'include': if 'cond' not in inst or eval_cond(inst.cond): print( f'{cf.magenta("Including")} {cf.italic(inst.path)}{cond_suffix(inst)}' ) with putter.indent(): include_path = expand_macros_in_string(inst.path) resolved_path = Path( ntpath.normpath( str(root_path.parent / include_path))) print( f'{cf.magenta("Resolved to")} {cf.italic(resolved_path)}' ) build_data(resolved_path) else: print( f'Not including {cf.italic(Path(inst.path).name)}{cond_suffix(inst)} due to the false condition' ) elif inst.type == 'configuration': def print_generic_dict(x_name): x_key = vpc.configuration_commands[x_name].pythonized if x_key not in inst: return # TODO(maximsmol): print the merging process merged = Namespace() for x in inst[x_key]: if 'cond' not in x or eval_cond(x.cond): merge_command_data(merged, x) with putter.group(x_name): for k, v in merged.items(): print(f'{cf.bold(k)} = {cf.bold(v)}') suffix = '' if 'name' in inst: suffix = f' "{inst.name}"' with putter.group(f'Configuration{suffix}'): for generic_group in vpc.configuration_commands: print_generic_dict(generic_group) elif inst.type == 'macro_required': invalid_value = macro_state.get( inst.name) == '' and not inst.allow_empty if inst.name not in macro_state or invalid_value: if 'default' not in inst: if inst.name not in macro_state: die(f'Macro {cf.bold("$"+inst.name)} is required, but not defined.' ) if not inst.allow_empty: die(f'Macro {cf.bold("$"+inst.name)} is required, but is set to an empty string.' ) with putter.indent(): print( f'{cf.magenta("Defaulted")} {cf.bold("$"+inst.name)} = {render_macro_value(inst.default)}' ) macro_state[inst.name] = inst.default else: print( f'{cf.magenta("Found required")} {cf.bold("$"+inst.name)}' ) else: putter.warning(f'Skipped instruction {cf.bold(inst.type)}.') root_path = resolve_project_path(name) print(f'Resolved project to {cf.italic(root_path)}') print() try: build_data(root_path) except (ValueError, AssertionError): putter.newline() putter.error(f'Root path is: {cf.italic(root_path)}') die('Could not parse file.', linefeed_before=False) raise except FileNotFoundError as e: putter.newline() putter.error(f'Root path is: {cf.italic(root_path)}') die(f'File not found: {cf.italic(e.filename)}.', linefeed_before=False) raise
def __init__(self, app): Namespace.__init__(self) self._app = app
mainlist = read_manifest(Path('vpc_scripts') / 'default.vgc') to_include = deque(mainlist.includes) while len(to_include) > 0: incl_path = to_include.popleft() included = read_manifest(Path(incl_path)) if parsed_args.log_includes: print(f'Included "{cf.bold(incl_path)}".') merge_command_data(mainlist.projects, included.projects) merge_command_data(mainlist.games, included.games) merge_command_data(mainlist.groups, included.groups, allow_duplicates=True) to_include.extend(included.includes) macro_state = Namespace() def cond_suffix(x): if 'cond' not in x: return '' return f' {render_cond(x.cond, macro_state)}' def render_macro_value(x): if not isinstance(x, str): return str(x) stripped = x.strip() if stripped != x or stripped == '': return cf.bold(f'"{x}"')
def _mk_configuration_command(pythonized, nargs=0, allow_body=False): return Namespace(pythonized=pythonized, nargs=nargs, allow_body=allow_body) configuration_commands = Namespace( Compiler=_mk_configuration_command('compiler', allow_body=True), General=_mk_configuration_command('general', allow_body=True), Linker=_mk_configuration_command('linker', allow_body=True), Debugging=_mk_configuration_command('debugging', allow_body=True), ManifestTool=_mk_configuration_command('manifest_tool', allow_body=True), XMLDocumentGenerator=_mk_configuration_command('xml_document_generator', allow_body=True), BrowseInformation=_mk_configuration_command('browse_information', allow_body=True), Resources=_mk_configuration_command('resources', allow_body=True), ExcludedFromBuild=_mk_configuration_command('excluded_from_build', nargs=1), CustomBuildStep=_mk_configuration_command('custom_build_step', allow_body=True), PreBuildEvent=_mk_configuration_command('pre_build_event', allow_body=True), PreLinkEvent=_mk_configuration_command('pre_link_event', allow_body=True), PostBuildEvent=_mk_configuration_command('post_build_event', allow_body=True), PostLinkEvent=_mk_configuration_command('post_link_event', allow_body=True)) # TODO(maximsmol): we are keeping track of "type" here just for asserts, it's # not really necessary # TODO(maximsmol): set allow cond only for specific commands
'pretrained_files': { 'word': 'data/glove.6B/glove.6B.300d.txt' }, 'trainer': { 'num_epochs': 100, 'patience': None, 'serialization_dir': 'log.{}'.format(time.strftime("%Y%m%d-%H%M%S", time.gmtime())), }, 'optimizer': { 'type': 'adam', 'lr': 1e-4, 'weight_decay': 1e-5 }, 'scheduler': { 'type': 'reduce_on_plateau', 'patience': 10 }, 'iterator': { 'batch_size': 8, } }, 'Source': { 'emr': caller_source() } } Config = Namespace(config)
def push_merged_str(): if len(strs_to_merge) == 0: return res.parts.append( Namespace(type='str', x=''.join([x.x for x in strs_to_merge])))
eval_manager_target.fit() eval_manager_sens.fit() with torch.no_grad(): # If we have wandb logger, or we return results, # we want to have the report as a dict. return_results = True output_dict = logger is not None or return_results _, report_target, acc_target = eval_manager_target.evaluate( output_dict) _, report_sens, acc_sens = eval_manager_sens.evaluate(output_dict) print(report_target) print(report_sens) if logger is not None: logger.log_metrics({ "target_classification_report": report_target, "sens_classification_report": report_sens, }) print("~ evaluation results ~~~~~~~~~~~~~") print("best target acc:", round(acc_target, 2)) print("best sens acc: ", round(acc_sens, 2)) print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") return acc_target, acc_sens if __name__ == "__main__": torch.manual_seed(0) args = Namespace(dataset="adult") evaluate_embeddings(args)
def __init__(self, **kw): self.env = Namespace(kw) self.log = logging.getLogger(self.__class__.__name__) self.log.setLevel(logging.root.level) self.clients = dict()
def _mk_configuration_command(pythonized, nargs=0, allow_body=False): return Namespace(pythonized=pythonized, nargs=nargs, allow_body=allow_body)
def parse_command(self, res): parts = self.parse_command_parts() cmd = self.need_command(parts, lowercase=False) if cmd == 'Macro': name = string_like(parts[1]) # TODO(maximsmol): weird unquoted macro values are allowed # and we skip the spaces in them + this parsing # is all around weird value = string_like(parts[2]) cond = None if len(parts) > 3: # TODO(maximsmol): check that weird unquoted macros are unquoted value_parts = [value] i = 3 for p in parts[3:]: if p.type == 'cond': cond = parse_cond(parts[3]) assert i == len(parts) - 1 break value_parts.append(raw_string(p)) i += 1 # TODO(maximsmol): this actually loses some whitespaces value = ' '.join(value_parts) else: assert len(parts) == 3 inst = Namespace(type='macro') inst.name = name inst.value = value if cond is not None: inst.cond = cond res.instructions.append(inst) elif cmd == 'Conditional': name = raw_string(parts[1]) inst = Namespace(type='conditional') res.instructions.append(inst) inst.name = name inst.value = strip_quotes(parts[2]) cond = None if len(parts) == 4: inst.cond = parse_cond(parts[3]) else: assert len(parts) == 3 elif cmd == 'MacroRequired': inst = Namespace(type='macro_required') if len(parts) == 3: inst.default = strip_quotes(parts[2]) else: assert len(parts) == 2 inst.name = string_like(parts[1]) inst.allow_empty = False elif cmd == 'MacroRequiredAllowEmpty': inst = Namespace(type='macro_required') if len(parts) == 3: inst.default = strip_quotes(parts[2]) else: assert len(parts) == 2 inst.name = string_like(parts[1]) inst.allow_empty = True elif cmd == 'LoadAddressMacro': inst = Namespace(type='address_macro') res.instructions.append(inst) assert len(parts) == 2 inst.name = raw_string(parts[1]) for body_parts in self.parse_body(): # TODO(maximsmol): parse this # this is only used on XBOX afaik pass elif cmd == 'LoadAddressMacroAuto': inst = Namespace(type='address_macro_auto') res.instructions.append(inst) assert len(parts) == 4 inst.name = raw_string(parts[1]) inst.addr = int(raw_string(parts[2]), 16) inst.cond = parse_cond(parts[3]) for body_parts in self.parse_body(): # TODO(maximsmol): parse this # this is only used on XBOX afaik pass elif cmd == 'IgnoreRedundancyWarning': inst = Namespace(type='ignore_redundancy_warning') assert len(parts) == 2 inst.value = strip_quotes(parts[1]).lower() elif cmd in ['Include', 'include']: # Valve, why do you insist on mixing case path = strip_quotes(parts[1]) cond = None if len(parts) == 3: cond = parse_cond(parts[2]) else: assert len(parts) == 2 inst = Namespace(type='include') inst.path = path if cond is not None: inst.cond = cond res.instructions.append(inst) elif cmd == 'Configuration': self.parse_configuration_comamnd(res, parts) elif cmd == 'Project': proj = Namespace(type='project', folders=Namespace(), files=[]) res.instructions.append(proj) if len(parts) == 2: name = strip_quotes(parts[1]) else: assert len(parts) == 1 for cmd, body_parts in self.parse_body_commands(): if cmd == 'folder': self.parse_folder_command(proj, body_parts) elif cmd in ['file']: self.parse_file_command(proj.files, parts) else: self.die(f'Unknown project command {cf.bold(cmd)}.') elif cmd == 'CustomBuildStep': self.parse_cmd_list_schema(res, project_schema, parts) # TODO(maximsmol): type will be renamed to name res.instructions[-1].type = cmd else: self.die(f'Unknown command {cf.bold(cmd)}.')
def _parse(self): res = Namespace(instructions=[]) while self.token is not None: self.parse_command(res) return res