def test_configuration_yaml():
configuration = OTEClassificationParameters()
configuration_yaml_str = convert(configuration, str)
configuration_yaml_converted = create(configuration_yaml_str)
configuration_yaml_loaded = create(
osp.join('torchreid', 'integration', 'sc', 'configuration.yaml'))
assert configuration_yaml_converted == configuration_yaml_loaded
def test_configuration_yaml(configurable_parameters, model_name):
# assert that we can parse the template.yaml
template_file_path = os.path.join("anomaly_classification", "configs", model_name, "template.yaml")
configuration_yaml_loaded, task_name = get_config_and_task_name(template_file_path)
configuration = configurable_parameters()
# assert that we can convert our config object to yaml format
configuration_yaml_str = convert(configuration, str)
# assert that we can create configurable parameters from the yaml string
configuration_yaml_converted = create(configuration_yaml_str)
# assert that we generate an anomalib config from the
get_anomalib_config(task_name, configuration_yaml_converted)
# assert that the python class and the yaml file result in the same configurable parameters object
assert configuration_yaml_converted == configuration_yaml_loaded
def get_config_and_task_name(
template_file_path: str) -> Tuple[ConfigurableParameters, str]:
"""Return configurable parameters and model name given template path
Args:
template_file_path (str): template path
Returns:
Tuple[ConfigurableParameters, str]: Configurable parameters, model name
"""
model_template: ModelTemplate = parse_model_template(template_file_path)
hyper_parameters: dict = model_template.hyper_parameters.data
config: ConfigurableParameters = create(hyper_parameters)
return config, model_template.name
def main():
"""
Main function that is used for model exporting.
"""
args = parse_args()
# Load template.yaml file.
template = find_and_parse_model_template(args.template)
# Get class for Task.
task_class = get_impl_class(template.entrypoints.base)
# Get hyper parameters schema.
hyper_parameters = create(template.hyper_parameters.data)
assert hyper_parameters
environment = TaskEnvironment(
model=None,
hyper_parameters=hyper_parameters,
label_schema=read_label_schema(
os.path.join(os.path.dirname(args.load_weights),
"label_schema.json")),
model_template=template,
)
model_adapters = {
"weights.pth": ModelAdapter(read_binary(args.load_weights))
}
model = ModelEntity(
configuration=environment.get_model_configuration(),
model_adapters=model_adapters,
train_dataset=None,
)
environment.model = model
task = task_class(task_environment=environment)
exported_model = ModelEntity(None,
environment.get_model_configuration(),
model_status=ModelStatus.NOT_READY)
task.export(ExportType.OPENVINO, exported_model)
os.makedirs(args.save_model_to, exist_ok=True)
save_model_data(exported_model, args.save_model_to)
def main():
"""
Main function that is used for model evaluation.
"""
# Parses input arguments.
args = parse_args()
# Reads model template file.
template = find_and_parse_model_template(args.template)
# Get hyper parameters schema.
hyper_parameters = template.hyper_parameters.data
assert hyper_parameters
# Get classes for Task, ConfigurableParameters and Dataset.
if not args.load_weights.endswith(".bin") and not args.load_weights.endswith(
".xml"
):
raise RuntimeError("Only OpenVINO-exported models are supported.")
task_class = get_impl_class(template.entrypoints.openvino)
environment = TaskEnvironment(
model=None,
hyper_parameters=create(hyper_parameters),
label_schema=read_label_schema(
os.path.join(os.path.dirname(args.load_weights), "label_schema.json")
),
model_template=template,
)
environment.model = read_model(
environment.get_model_configuration(), args.load_weights, None
)
task = task_class(task_environment=environment)
deployed_model = ModelEntity(None, environment.get_model_configuration())
os.makedirs(args.save_model_to, exist_ok=True)
task.deploy(deployed_model)
with open(os.path.join(args.save_model_to, "openvino.zip"), "wb") as write_file:
write_file.write(deployed_model.exportable_code)
def setup_configurable_parameters(template_dir, max_num_epochs=10):
model_template = parse_model_template(
osp.join(template_dir, 'template.yaml'))
hyper_parameters = create(model_template.hyper_parameters.data)
hyper_parameters.learning_parameters.max_num_epochs = max_num_epochs
return hyper_parameters, model_template
def main():
"""
Main function that is used for model demonstration.
"""
# Dynamically create an argument parser based on override parameters.
args, template, hyper_parameters = parse_args()
# Get new values from user's input.
updated_hyper_parameters = gen_params_dict_from_args(args)
# Override overridden parameters by user's values.
override_parameters(updated_hyper_parameters, hyper_parameters)
hyper_parameters = create(hyper_parameters)
# Get classes for Task, ConfigurableParameters and Dataset.
if args.load_weights.endswith(".bin") or args.load_weights.endswith(
".xml"):
task_class = get_impl_class(template.entrypoints.openvino)
else:
task_class = get_impl_class(template.entrypoints.base)
environment = TaskEnvironment(
model=None,
hyper_parameters=hyper_parameters,
label_schema=read_label_schema(
os.path.join(os.path.dirname(args.load_weights),
"label_schema.json")),
model_template=template,
)
environment.model = read_model(environment.get_model_configuration(),
args.load_weights, None)
task = task_class(task_environment=environment)
capture = open_images_capture(args.input, args.loop)
elapsed_times = deque(maxlen=10)
frame_index = 0
while True:
frame = capture.read()
if frame is None:
break
predictions, elapsed_time = get_predictions(task, frame)
elapsed_times.append(elapsed_time)
elapsed_time = np.mean(elapsed_times)
frame = draw_predictions(template.task_type, predictions, frame,
args.fit_to_size)
if args.display_perf:
put_text_on_rect_bg(
frame,
f"time: {elapsed_time:.4f} sec.",
(0, frame.shape[0] - 30),
color=(255, 255, 255),
)
if args.delay >= 0:
cv2.imshow("frame", frame)
if cv2.waitKey(args.delay) == ESC_BUTTON:
break
else:
print(f"{frame_index=}, {elapsed_time=}, {len(predictions)=}")
def main():
"""
Main function that is used for model evaluation.
"""
# Dynamically create an argument parser based on override parameters.
args, template, hyper_parameters = parse_args()
# Get new values from user's input.
updated_hyper_parameters = gen_params_dict_from_args(args)
# Override overridden parameters by user's values.
override_parameters(updated_hyper_parameters, hyper_parameters)
hyper_parameters = create(hyper_parameters)
# Get classes for Task, ConfigurableParameters and Dataset.
if args.load_weights.endswith(".bin") or args.load_weights.endswith(".xml"):
task_class = get_impl_class(template.entrypoints.openvino)
else:
task_class = get_impl_class(template.entrypoints.base)
dataset_class = get_dataset_class(template.task_type)
dataset = dataset_class(
test_subset={"ann_file": args.test_ann_files, "data_root": args.test_data_roots}
)
dataset_label_schema = generate_label_schema(dataset, template.task_type)
check_label_schemas(
read_label_schema(
os.path.join(os.path.dirname(args.load_weights), "label_schema.json")
),
dataset_label_schema,
)
environment = TaskEnvironment(
model=None,
hyper_parameters=hyper_parameters,
label_schema=dataset_label_schema,
model_template=template,
)
model = read_model(environment.get_model_configuration(), args.load_weights, None)
environment.model = model
task = task_class(task_environment=environment)
validation_dataset = dataset.get_subset(Subset.TESTING)
predicted_validation_dataset = task.infer(
validation_dataset.with_empty_annotations(),
InferenceParameters(is_evaluation=True),
)
resultset = ResultSetEntity(
model=model,
ground_truth_dataset=validation_dataset,
prediction_dataset=predicted_validation_dataset,
)
task.evaluate(resultset)
assert resultset.performance is not None
print(resultset.performance)
if args.save_performance:
with open(args.save_performance, "w", encoding="UTF-8") as write_file:
json.dump(
{resultset.performance.score.name: resultset.performance.score.value},
write_file,
)
def main():
"""
Main function that is used for model training.
"""
# Dynamically create an argument parser based on override parameters.
args, template, hyper_parameters = parse_args()
# Get new values from user's input.
updated_hyper_parameters = gen_params_dict_from_args(args)
# Override overridden parameters by user's values.
override_parameters(updated_hyper_parameters, hyper_parameters)
hyper_parameters = create(hyper_parameters)
# Get classes for Task, ConfigurableParameters and Dataset.
task_class = get_impl_class(template.entrypoints.base)
dataset_class = get_dataset_class(template.task_type)
# Create instances of Task, ConfigurableParameters and Dataset.
dataset = dataset_class(
train_subset={
"ann_file": args.train_ann_files,
"data_root": args.train_data_roots,
},
val_subset={"ann_file": args.val_ann_files, "data_root": args.val_data_roots},
)
environment = TaskEnvironment(
model=None,
hyper_parameters=hyper_parameters,
label_schema=generate_label_schema(dataset, template.task_type),
model_template=template,
)
if args.load_weights:
environment.model = ModelEntity(
train_dataset=dataset,
configuration=environment.get_model_configuration(),
model_adapters={
"weights.pth": ModelAdapter(read_binary(args.load_weights))
},
)
if args.enable_hpo:
run_hpo(args, environment, dataset, template.task_type)
task = task_class(task_environment=environment)
output_model = ModelEntity(
dataset,
environment.get_model_configuration(),
model_status=ModelStatus.NOT_READY,
)
task.train(dataset, output_model, train_parameters=TrainParameters())
save_model_data(output_model, args.save_model_to)
validation_dataset = dataset.get_subset(Subset.VALIDATION)
predicted_validation_dataset = task.infer(
validation_dataset.with_empty_annotations(),
InferenceParameters(is_evaluation=True),
)
resultset = ResultSetEntity(
model=output_model,
ground_truth_dataset=validation_dataset,
prediction_dataset=predicted_validation_dataset,
)
task.evaluate(resultset)
assert resultset.performance is not None
print(resultset.performance)
def run_hpo_trainer(
hp_config,
model,
hyper_parameters,
model_template,
dataset_paths,
task_type,
):
"""Run each training of each trial with given hyper parameters"""
if isinstance(hyper_parameters, dict):
current_params = {}
for val in hyper_parameters["parameters"]:
current_params[val] = hyper_parameters[val]
hyper_parameters = create(model_template.hyper_parameters.data)
HpoManager.set_hyperparameter(hyper_parameters, current_params)
if dataset_paths is None:
raise ValueError("Dataset is not defined.")
impl_class = get_dataset_class(task_type)
dataset = impl_class(
train_subset={
"ann_file": dataset_paths.get("train_ann_file", None),
"data_root": dataset_paths.get("train_data_root", None),
},
val_subset={
"ann_file": dataset_paths.get("val_ann_file", None),
"data_root": dataset_paths.get("val_data_root", None),
},
)
train_env = TaskEnvironment(
model=model,
hyper_parameters=hyper_parameters,
label_schema=generate_label_schema(dataset, task_type),
model_template=model_template,
)
hyper_parameters = train_env.get_hyper_parameters()
# set epoch
if task_type == TaskType.CLASSIFICATION:
(hyper_parameters.learning_parameters.max_num_epochs
) = hp_config["iterations"]
elif task_type in (TaskType.DETECTION, TaskType.SEGMENTATION):
hyper_parameters.learning_parameters.num_iters = hp_config[
"iterations"]
# set hyper-parameters and print them
HpoManager.set_hyperparameter(hyper_parameters, hp_config["params"])
print(f"hyper parameter of current trial : {hp_config['params']}")
train_env.set_hyper_parameters(hyper_parameters)
train_env.model_template.hpo = {
"hp_config": hp_config,
"metric": hp_config["metric"],
}
impl_class = get_impl_class(train_env.model_template.entrypoints.base)
task = impl_class(task_environment=train_env)
dataset = HpoDataset(dataset, hp_config)
if train_env.model:
train_env.model.train_dataset = dataset
train_env.model.confiugration.configurable_parameters = hyper_parameters
output_model = ModelEntity(
dataset,
train_env.get_model_configuration(),
model_status=ModelStatus.NOT_READY,
)
# make callback to report score to hpopt every epoch
train_param = TrainParameters(
False, HpoCallback(hp_config, hp_config["metric"], task), None)
train_param.train_on_empty_model = None
task.train(dataset=dataset,
output_model=output_model,
train_parameters=train_param)
hpopt.finalize_trial(hp_config)