def __call__(self, template_path, kwargs_nncf):
if not is_optimisation_enabled_in_template(template_path):
logging.warning(
'WARNING: optimisation class is called for a template that does not enable optimisation.'
' This must not be happened in OTE.')
return {}
template = load_config(template_path)
optimisation_template = template[OPTIMISATION_PART_NAME]
optimisation_template = copy(optimisation_template)
optimisation_config_path = get_optimisation_config_from_template(
template)
optimisation_parts_to_choose = []
for k in POSSIBLE_NNCF_PARTS:
should_pick = bool(kwargs_nncf.get(k))
if should_pick:
optimisation_parts_to_choose.append(k)
if not optimisation_parts_to_choose:
return {}
nncf_config_part = self._merge_nncf_optimisation_parts(
optimisation_config_path, optimisation_parts_to_choose)
return nncf_config_part
def main():
logging.basicConfig(level=logging.INFO)
modules = load_config(MODULES_CONFIG_FILENAME)
arg_parser = build_arg_parser(modules['arg_parser'])
ote_args = vars(arg_parser.get_compression_parser(MODEL_TEMPLATE_FILENAME).parse_args())
if 'compression' not in modules:
raise RuntimeError(f'Cannot make compression for the template that'
f' does not have "compression" field in its modules'
f' file {MODULES_CONFIG_FILENAME}')
if not is_optimisation_enabled_in_template(MODEL_TEMPLATE_FILENAME):
raise RuntimeError(f'Cannot make compression for the template that'
f' does not enable any of compression flags')
arg_converter = build_arg_converter(modules['arg_converter_map'])
compress_args = arg_converter.convert_compress_args(ote_args)
compression_arg_transformer = build_compression_arg_transformer(modules['compression'])
compress_args, is_optimisation_enabled = \
compression_arg_transformer.process_args(MODEL_TEMPLATE_FILENAME, compress_args)
if not is_optimisation_enabled:
logging.warning('Optimization flags are not set -- compression is not made')
return
# Note that compression in this tool will be made by the same trainer,
# as in the tool train.py
# The difference is only in the argparser and in the NNCFConfigTransformer used to
# transform the configuration file.
trainer = build_trainer(modules['trainer'])
trainer(**compress_args)
def is_optimisation_enabled_in_template(template):
"""
The function returns if a model template contains
'optimisation' section; also the function
validates if the section is correct
The function receives as the parameter either
template path or template dict read from file
"""
if isinstance(template, str):
template = load_config(template)
optimisation_template = template.get(OPTIMISATION_PART_NAME)
if not optimisation_template:
return False
assert isinstance(optimisation_template, dict), (
f'Error: optimisation part of template is not a dict: template["optimisation"]={optimisation_template}'
)
unknown_keys = set(optimisation_template.keys()) - POSSIBLE_NNCF_PARTS
if unknown_keys:
raise RuntimeError(
f'Optimisation parameters contain unknown keys: {list(unknown_keys)}'
)
optimisation_configs = _get_optimisation_configs_from_template(template)
if not optimisation_configs:
raise RuntimeError(
f'Optimisation parameters do not contain the field "{COMPRESSION_CONFIG_KEY}"'
)
if len(optimisation_configs) > 1:
raise RuntimeError(
f'Wrong config: the optimisation config contains different config files: {optimisation_configs}'
)
return True
def main():
logging.basicConfig(level=logging.INFO)
modules = load_config(MODULES_CONFIG_FILENAME)
arg_parser = build_arg_parser(modules['arg_parser'])
ote_args = vars(arg_parser.get_train_parser(MODEL_TEMPLATE_FILENAME).parse_args())
arg_converter = build_arg_converter(modules['arg_converter'])
train_args = arg_converter.convert_train_args(MODEL_TEMPLATE_FILENAME, ote_args)
# Note that compression args transformer is not applied here,
# since NNCF compression (if it is enabled) will be applied
# later, when the training is finished.
trainer = build_trainer(modules['trainer'])
trainer(**train_args)
if modules.get('compression') and is_compression_enabled_in_template(MODEL_TEMPLATE_FILENAME):
# TODO: think on the case if compression is enabled in template.yaml, but modules does not contain 'compression'
latest_snapshot = trainer.get_latest_snapshot()
if not latest_snapshot:
raise RuntimeError('Cannot find latest snapshot to make compression after training')
compress_args = arg_converter.convert_train_args_to_compress_args(MODEL_TEMPLATE_FILENAME, ote_args)
arg_converter.update_converted_args_to_load_from_snapshot(compress_args, latest_snapshot)
compression_arg_transformer = build_compression_arg_transformer(modules['compression'])
compress_args = compression_arg_transformer.process_args(MODEL_TEMPLATE_FILENAME, compress_args)
compress_trainer = build_trainer(modules['trainer'])
compress_trainer(**compress_args)
def is_compression_enabled_in_template(template_path):
template = load_config(template_path)
compression_template = template.get('compression')
if not compression_template:
return False
assert isinstance(compression_template, dict), (
f'Error: compression part of template is not a dict: template["compression"]={compression_template}')
possible_keys = POSSIBLE_NNCF_PARTS | {COMPRESSION_CONFIG_KEY}
unknown_keys = set(compression_template.keys()) - possible_keys
if unknown_keys:
raise RuntimeError(f'Compression parameters contain unknown keys: {list(unknown_keys)}')
if COMPRESSION_CONFIG_KEY not in compression_template:
raise RuntimeError(f'Compression parameters do not contain the field "{COMPRESSION_CONFIG_KEY}"')
is_compression_enabled = any(compression_template.get(key) for key in POSSIBLE_NNCF_PARTS)
return is_compression_enabled
def main():
modules = load_config(MODULES_CONFIG_FILENAME)
arg_parser = build_arg_parser(modules['arg_parser'])
ote_args = vars(arg_parser.get_test_parser(MODEL_TEMPLATE_FILENAME).parse_args())
arg_converter = build_arg_converter(modules['arg_converter_map'])
eval_args = arg_converter.convert_test_args(ote_args)
if modules.get('compression') and is_optimisation_enabled_in_template(MODEL_TEMPLATE_FILENAME):
compression_arg_transformer = build_compression_arg_transformer(modules['compression'])
eval_args, _ = compression_arg_transformer.process_args(MODEL_TEMPLATE_FILENAME, eval_args)
evaluator = build_evaluator(modules['evaluator'])
evaluator(**eval_args)
def main():
logging.basicConfig(level=logging.INFO)
modules = load_config(MODULES_CONFIG_FILENAME)
arg_parser = build_arg_parser(modules['arg_parser'])
ote_args = vars(arg_parser.get_train_parser(MODEL_TEMPLATE_FILENAME).parse_args())
arg_converter = build_arg_converter(modules['arg_converter_map'])
train_args = arg_converter.convert_train_args(ote_args)
# Note that compression args transformer is not applied here,
# since NNCF compression (if it is enabled) will be applied
# later, when the training is finished.
trainer = build_trainer(modules['trainer'])
trainer(**train_args)
def main():
logging.basicConfig(level=logging.INFO)
modules = load_config(MODULES_CONFIG_FILENAME)
arg_parser = build_arg_parser(modules['arg_parser'])
ote_args = vars(
arg_parser.get_export_parser(MODEL_TEMPLATE_FILENAME).parse_args())
if modules.get('compression') and is_compression_enabled_in_template(
MODEL_TEMPLATE_FILENAME):
compression_arg_transformer = build_compression_arg_transformer(
modules['compression'])
ote_args = compression_arg_transformer.process_args(
MODEL_TEMPLATE_FILENAME, ote_args)
exporter = build_exporter(modules['exporter'])
exporter(ote_args)
def __call__(self, template_path):
assert is_compression_enabled_in_template(template_path), (
'Error: compression class is called for a template that does not enable compression.'
' This must not be happened in OTE.')
template = load_config(template_path)
compression_template = template['compression']
compression_template = copy(compression_template)
compression_config_path = compression_template.pop(COMPRESSION_CONFIG_KEY)
compression_parts_to_choose = []
for k, v in compression_template.items():
should_pick = bool(v)
if should_pick:
compression_parts_to_choose.append(k)
if not compression_parts_to_choose:
return {}
nncf_config_part = self._merge_nncf_compression_parts(compression_config_path, compression_parts_to_choose)
return nncf_config_part
