def run(self):
session = CeleryDBAdapter.session()
winograd_autotune_job = session.query(WinogradAutotuneJobsModel).get(self.emit_message.job_id)
new_model = session.query(TopologiesModel).get(winograd_autotune_job.result_model_id)
tuned_path = new_model.path
set_status_in_db(WinogradAutotuneJobsModel, self.emit_message.job_id, StatusEnum.running, session)
session.close()
self.emit_message.emit_progress()
parameters = WinogradParameters(self.emit_message.config)
parameters.set_parameter('o', tuned_path)
parser = WinogradConsoleOutputParser(self.emit_message, WinogradToolStages.get_stages())
return_code, message = run_console_tool(parameters, parser)
if return_code:
message = parser.get_error() if not message else message
error_message = WinogradErrorMessageProcessor.recognize_error(message, 'winograd autotuner')
self.emit_message.add_error(error_message)
raise WinogradAutotuneError(error_message, self.emit_message.job_id)
session = CeleryDBAdapter.session()
set_status_in_db(WinogradAutotuneJobsModel, self.emit_message.job_id, StatusEnum.ready, session)
winograd_autotune_job = session.query(WinogradAutotuneJobsModel).get(self.emit_message.job_id)
winograd_autotune_job.progress = 100
write_record(winograd_autotune_job, session)
set_status_in_db(WinogradAutotuneJobsModel, self.emit_message.job_id, StatusEnum.ready, session, force=True)
session.close()
self.emit_message.emit_message()
def run(self):
emit_msg = self.emit_message
config = emit_msg.config
session = CeleryDBAdapter.session()
topology = session.query(TopologiesModel).get(config.topology_id)
log.debug('[ MODEL OPTIMIZER ] Analyzing model %s', topology.name)
mo_job_record = session.query(ModelOptimizerScanJobsModel).filter_by(topology_id=config.topology_id).first()
mo_job_id = mo_job_record.job_id
mo_job_record.status = StatusEnum.running
write_record(mo_job_record, session)
resolve_file_args(emit_msg.job_id, config, topology)
session.close()
parameters = ModelOptimizerParameters(config.mo_args, {'MO_ENABLED_TRANSFORMS': 'ANALYSIS_JSON_PRINT'})
parser = ModelOptimizerScanParser(self.emit_message, ModelOptimizerStages.get_stages())
return_code, message = run_console_tool(parameters, parser, self)
if return_code:
match = re.search(r': (.+)\.\s+For more information please refer to Model Optimizer FAQ', message)
if match:
short_error_message = match.group(1)
elif 'FRAMEWORK ERROR' in message:
short_error_message = 'Invalid topology'
else:
short_error_message = 'Model Optimizer Scan failed'
log.error('[ MODEL OPTIMIZER ] [ ERROR ]: %s', short_error_message)
session = CeleryDBAdapter.session()
set_status_in_db(ModelOptimizerScanJobsModel, mo_job_id, StatusEnum.error, session, short_error_message)
mo_job_record = session.query(ModelOptimizerScanJobsModel).filter_by(topology_id=config.topology_id).first()
mo_job_record.error_message = short_error_message
mo_job_record.detailed_error_message = re.sub(r'^.*ERROR \]\s*', '', re.sub(r'(\n\s*)+', '\n', message))
write_record(mo_job_record, session)
set_status_in_db(TopologiesModel, emit_msg.job_id, StatusEnum.error, session, short_error_message)
session.close()
self.emit_message.emit_message()
raise ModelOptimizerError(short_error_message, self.emit_message.job_id)
session = CeleryDBAdapter.session()
mo_job_record = session.query(ModelOptimizerScanJobsModel).get(mo_job_id)
mo_job_record.progress = 100
mo_job_record.status = StatusEnum.ready
write_record(mo_job_record, session)
session.close()
self.emit_message.emit_message()
def run(self):
parameters = self.emit_message.config
dataset_id = self.emit_message.job_id
current_job = self.emit_message.add_stage(
IEmitMessageStage('Setup dataset parameters', weight=0.1))
session = CeleryDBAdapter.session()
dataset = session.query(DatasetsModel).get(self.emit_message.job_id)
dataset.status = StatusEnum.running
dataset_path = dataset.path
write_record(dataset, session)
session.close()
image_size = parameters.width * parameters.height * parameters.channels
create_empty_dir(dataset_path)
try:
random_generator = DistributionLaw(
parameters.dist_law, parameters.params_dist).random_generator
except AssertionError as exception:
self.emit_message.add_error(str(exception))
raise
self.emit_message.update_progress(current_job, 100)
current_job = self.emit_message.add_stage(
IEmitMessageStage('Generate dataset', weight=0.9))
log.debug('Starting of generating dataset %s', dataset_id)
index = 0
while index < self.emit_message.config.size:
file_name = os.path.join(dataset_path, '{}.jpg'.format(index))
cv2.imwrite(
file_name,
random_generator(image_size).reshape(
parameters.height, parameters.width,
parameters.channels).astype(np.uint8))
percent = (index / (parameters.size + 2)) * 100
if index % np.ceil(parameters.size / 10) == 0:
self.emit_message.update_progress(current_job, percent)
with open(os.path.join(dataset_path, parameters.name + '.txt'),
'a') as desc_file:
desc_file.write('{}.jpg 0\n'.format(index))
index += 1
session = CeleryDBAdapter.session()
dataset = session.query(DatasetsModel).get(self.emit_message.job_id)
dataset.progress = 100
dataset.status = StatusEnum.ready
dataset.size = get_size_of_files(dataset_path)
write_record(dataset, session)
session.close()
self.emit_message.update_progress(current_job, 100)
log.debug('Finish of generating dataset %s', dataset_id)
def full_json(self):
session = CeleryDBAdapter.session()
job_record = session.query(WinogradAutotuneJobsModel).filter_by(job_id=self.job_id).first()
progress = job_record.progress
status = job_record.status.value
error_message = job_record.error_message
project_record = session.query(ProjectsModel).filter_by(
model_id=job_record.result_model_id,
dataset_id=self.config.dataset_id,
target=DevicesEnum(self.config.device),
optimization_type=OptimizationTypesEnum(self.job.job_type.value)
).first()
session.close()
message = {
'creationTimestamp': self.date,
'jobId': self.job_id,
'type': self.job.job_type.value,
'config': self.config.json(),
'projectId': project_record.id,
'originalModelId': get_top_level_model_id(project_record.id),
'status': {
'name': status,
'progress': progress
}
}
if error_message:
message['status']['errorMessage'] = error_message
return message
def set_task_id(self, task_id):
session = CeleryDBAdapter.session()
resulting_topology = session.query(TopologiesModel).get(
self.emit_message.config.result_model_id)
resulting_topology.task_id = task_id
write_record(resulting_topology, session)
session.close()
def update_progress_in_database(self, progress):
session = CeleryDBAdapter.session()
int8_record = session.query(Int8AutotuneJobsModel).filter_by(
job_id=self.job_id).first()
int8_record.progress = progress
write_record(int8_record, session)
session.close()
def set_task_id(self, task_id: str):
session = CeleryDBAdapter.session()
record = session.query(self.db_table).get(self.emit_message.job_id)
if record:
record.task_id = task_id
write_record(record, session)
session.close()
def full_json(self):
session = CeleryDBAdapter.session()
model = session.query(TopologiesModel).get(self.config.result_model_id)
record = (session.query(ModelDownloaderConversionJobsModel).filter_by(
result_model_id=self.config.result_model_id).order_by(
desc(ModelDownloaderConversionJobsModel.creation_timestamp)).
first())
session.close()
json_message = model.short_json()
json_message['stages'] = get_stages_status(record.job_id, session)
session.close()
if record.conversion_args:
json_message = {
'mo': {
'params': {
'dataType':
json.loads(record.conversion_args)['precision']
}
}
}
return json_message
def full_json(self):
session = CeleryDBAdapter.session()
dataset = session.query(DatasetsModel).get(self.job_id)
json_message = dataset.json()
json_message['status']['progress'] = self.total_progress
session.close()
return json_message
def __init__(self, path: str, exe: str, parameters: IConfig):
super(Parameters, self).__init__()
self.path = path
self.exe = exe
self.params = dict()
session = CeleryDBAdapter.session()
dataset = session.query(DatasetsModel).get(parameters.dataset_id)
dataset_path = dataset.path
if dataset.dataset_type in [
DatasetTypesEnum.voc_object_detection,
DatasetTypesEnum.voc_segmentation
]:
dataset_path = get_images_folder_for_voc(dataset_path)
model = session.query(TopologiesModel).get(parameters.model_id)
model_path = model.path
session.close()
self.params['i'] = dataset_path
xml_path = find_all_paths(model_path, ('.xml', ))[0]
self.params['m'] = xml_path
self.params['d'] = parameters.device
if self.params['d'] == 'CPU':
self.params['l'] = os.path.join(IE_BIN_PATH, 'lib',
'libcpu_extension' + LIB_EXTENSION)
def on_failure(self):
session = CeleryDBAdapter.session()
set_status_in_db(WinogradAutotuneJobsModel, self.emit_message.job_id, StatusEnum.error, session)
winograd_job = session.query(WinogradAutotuneJobsModel).get(self.emit_message.job_id)
result_model_id = winograd_job.result_model_id
session.close()
set_status_in_db(TopologiesModel, result_model_id, StatusEnum.error, session)
def update_progress_for_optimize(self):
job_progress = self.local_progress
session = CeleryDBAdapter.session()
record = session.query(ModelDownloaderConversionJobsModel).filter_by(
job_id=self.job_id).first()
record.progress = job_progress
write_record(record, session)
def on_failure(self):
session = CeleryDBAdapter.session()
set_status_in_db(DatasetsModel, self.emit_message.job_id,
StatusEnum.error, session)
session.close()
remove_dir(
os.path.join(UPLOAD_FOLDER_DATASETS, self.emit_message.job_id))
def full_json(self):
session = CeleryDBAdapter.session()
model = session.query(TopologiesModel).get(self.job_id)
model_analysis = session.query(TopologyAnalysisJobsModel).filter_by(model_id=self.job_id).first()
json_message = model.short_json()
json_message['stages'] = get_stages_status(model_analysis.job_id, session)
session.close()
return json_message
def total_progress(self):
session = CeleryDBAdapter.session()
artifact = session.query(TopologiesModel).get(self.job_id)
progress = self.local_progress * self.weight + self.previous_progress
artifact.progress = progress
write_record(artifact, session)
session.close()
return progress
def set_inference_result_to_record(self, results):
session = CeleryDBAdapter.session()
infer_result = session.query(InferenceResultsModel).get(
self.inference_result_record_id)
infer_result.progress = 100
infer_result.update(results)
write_record(infer_result, session)
session.close()
def update_progress_in_database(self, progress):
session = CeleryDBAdapter.session()
accuracy_record = session.query(AccuracyJobsModel).filter_by(
job_id=self.job_id).first()
accuracy_record.progress = progress
session.add(accuracy_record)
session.commit()
session.close()
def update_progress_for_inference_result(self):
session = CeleryDBAdapter.session()
infer_result = session.query(InferenceResultsModel).get(
self.inference_result_record_id)
infer_result.progress = self.local_progress
infer_result.status = StatusEnum.running
write_record(infer_result, session)
session.close()
def set_error_to_database(self, message):
session = CeleryDBAdapter.session()
job_record = session.query(ModelDownloaderModel).get(self.job_id)
set_status_in_db(ModelDownloaderModel, self.job_id, StatusEnum.error,
session, message)
set_status_in_db(TopologiesModel, job_record.result_model_id,
StatusEnum.error, session, message)
session.close()
def update_progress_in_database(self):
job_progress = self.local_progress
session = CeleryDBAdapter.session()
record = session.query(ModelDownloaderModel).filter_by(
job_id=self.job_id).first()
record.progress = job_progress
write_record(record, session)
session.close()
def on_failure(self):
super().on_failure()
session = CeleryDBAdapter.session()
mo_job_record = session.query(ModelOptimizerScanJobsModel).filter_by(
topology_id=self.emit_message.config.topology_id).first()
mo_job_record.status = StatusEnum.error
write_record(mo_job_record, session)
set_status_in_db(TopologiesModel, self.emit_message.config.topology_id, StatusEnum.error, session)
session.close()
def result_to_json(self) -> list:
res = []
session = CeleryDBAdapter.session()
inference_results = session.query(InferenceResultsModel).filter_by(
job_id=self.job_id).all()
for inference_result in inference_results:
res.append(inference_result.json())
session.close()
return res
def set_exec_info(self, data: dict):
session = CeleryDBAdapter.session()
infer_result = session.query(InferenceResultsModel).get(
self.inference_result_record_id)
infer_result.update(data)
session.add(infer_result)
session.commit()
session.close()
self.emit_message()
def on_failure(self):
super().on_failure()
session = CeleryDBAdapter.session()
set_status_in_db(TopologiesModel,
self.emit_message.config.result_model_id,
StatusEnum.error, session)
set_status_in_db(ModelDownloaderConversionJobsModel,
self.emit_message.job_id, StatusEnum.error, session)
session.close()
def model_optimizer_job_creator(job_id, data, weight):
session = CeleryDBAdapter.session()
record = session.query(ModelOptimizerJobModel).get(job_id)
config = ModelOptimizerConfig(record.session_id, record.json())
job = ModelOptimizerJob(record.result_model_id, config, weight)
job.emit_message.date = record.creation_timestamp.timestamp()
job.emit_message.previous_progress = record.result_model.progress
session.close()
return job
def run(self):
session = CeleryDBAdapter.session()
int8_job = session.query(Int8AutotuneJobsModel).get(self.emit_message.job_id)
new_int8_model = session.query(TopologiesModel).get(int8_job.result_model_id)
int8_model_id = new_int8_model.id
tuned_path = new_int8_model.path
session.close()
create_empty_dir(tuned_path)
self._run_python_calibration(tuned_path, int8_model_id)
def on_failure(self):
session = CeleryDBAdapter.session()
self.emit_message.add_error('')
set_status_in_db(self.db_table, self.emit_message.job_id,
StatusEnum.error, session)
session.close()
remove_dir(
os.path.join(self.emit_message.config.destination_path,
self.emit_message.config.path))
def update_model_optimizer_scan_result(self, results: str):
session = CeleryDBAdapter.session()
mo_job_record = (session.query(ModelOptimizerScanJobsModel).filter_by(
topology_id=self.config.topology_id).first())
mo_job_record.information = self.cleanup_results(results)
mo_job_record.progress = 100
mo_job_record.status = StatusEnum.ready
write_record(mo_job_record, session)
session.close()
def on_failure(self):
super().on_failure()
session = CeleryDBAdapter.session()
set_status_in_db(TopologiesModel,
self.emit_message.config.result_model_id,
StatusEnum.error, session)
remove_dir(
session.query(TopologiesModel).get(
self.emit_message.config.result_model_id).path)
session.close()
def get_top_level_model_id(project_id: int) -> int:
session = CeleryDBAdapter.session()
project = session.query(ProjectsModel).get(project_id)
model_id = project.model_id
while True:
parent_model = session.query(TopologiesModel).get(model_id)
if not parent_model.optimized_from:
session.close()
return parent_model.id
model_id = parent_model.optimized_from
