def load_model_from_repo(project_id: str) -> Tuple[Response, int]:
"""
Route for loading a model for a project from the Neural Magic model repo.
Starts a background job in the JobWorker setup to run.
The state of the job can be checked after.
Raises an HTTPNotFoundError if the project is not found in the database.
:param project_id: the id of the project to load the model for
:return: a tuple containing (json response, http status code)
"""
_LOGGER.info(
"loading model from repo for project {} for request json {}".format(
project_id, request.json))
project = _add_model_check(project_id)
data = SetProjectModelFromSchema().load(request.get_json(force=True))
project_model = None
job = None
try:
project_model = ProjectModel.create(project=project,
source="downloaded_repo",
job=None)
job = Job.create(
project_id=project.project_id,
type_=ModelFromRepoJobWorker.get_type(),
worker_args=ModelFromRepoJobWorker.format_args(
model_id=project_model.model_id,
uri=data["uri"],
),
)
project_model.job = job
project_model.save()
project_model.setup_filesystem()
project_model.validate_filesystem()
except Exception as err:
_LOGGER.error(
"error while creating new project model, rolling back: {}".format(
err))
if project_model:
try:
project_model.delete_instance()
except Exception as rollback_err:
_LOGGER.error("error while rolling back new model: {}".format(
rollback_err))
if job:
try:
job.delete_instance()
except Exception as rollback_err:
_LOGGER.error("error while rolling back new model: {}".format(
rollback_err))
raise err
# call into JobWorkerManager to kick off job if it's not already running
JobWorkerManager().refresh()
resp_model = data_dump_and_validation(ResponseProjectModelSchema(),
{"model": project_model})
_LOGGER.info("created project model from repo {}".format(resp_model))
return jsonify(resp_model), HTTPStatus.OK.value
def create_perf_profile(project_id: str):
"""
Route for creating a new perf profile for a given project.
Raises an HTTPNotFoundError if the project is not found in the database.
:param project_id: the id of the project to create a perf profile for
:return: a tuple containing (json response, http status code)
"""
_LOGGER.info(
"creating perf profile for project {} for request json {}".format(
project_id, request.json))
project = get_project_by_id(project_id)
perf_profile_params = CreateProjectPerfProfileSchema().load(
request.get_json(force=True))
sys_info = get_ml_sys_info()
if not perf_profile_params[
"core_count"] or perf_profile_params["core_count"] < 1:
perf_profile_params["core_count"] = sys_info["cores_per_socket"]
if not perf_profile_params["core_count"]:
# extra check in case the system couldn't get cores_per_socket
perf_profile_params["core_count"] = -1
perf_profile_params["instruction_sets"] = sys_info[
"available_instructions"]
model = project.model
if model is None:
raise ValidationError(
("A model is has not been set for the project with id {}, "
"project must set a model before running a perf profile."
).format(project_id))
perf_profile = None
job = None
try:
perf_profile = ProjectPerfProfile.create(project=project,
source="generated",
**perf_profile_params)
job = Job.create(
project_id=project_id,
type_=CreatePerfProfileJobWorker.get_type(),
worker_args=CreatePerfProfileJobWorker.format_args(
model_id=model.model_id,
profile_id=perf_profile.profile_id,
batch_size=perf_profile_params["batch_size"],
core_count=perf_profile_params["core_count"],
pruning_estimations=perf_profile_params["pruning_estimations"],
quantized_estimations=perf_profile_params[
"quantized_estimations"],
iterations_per_check=perf_profile_params[
"iterations_per_check"],
warmup_iterations_per_check=perf_profile_params[
"warmup_iterations_per_check"],
),
)
perf_profile.job = job
perf_profile.save()
except Exception as err:
_LOGGER.error(
"error while creating new perf profile, rolling back: {}".format(
err))
if perf_profile:
try:
perf_profile.delete_instance()
except Exception as rollback_err:
_LOGGER.error(
"error while rolling back new perf profile: {}".format(
rollback_err))
if job:
try:
job.delete_instance()
except Exception as rollback_err:
_LOGGER.error(
"error while rolling back new perf profile: {}".format(
rollback_err))
raise err
# call into JobWorkerManager to kick off job if it's not already running
JobWorkerManager().refresh()
resp_profile = data_dump_and_validation(ResponseProjectPerfProfileSchema(),
{"profile": perf_profile})
_LOGGER.info("created perf profile and job: {}".format(resp_profile))
return jsonify(resp_profile), HTTPStatus.OK.value
def create_loss_profile(project_id: str):
"""
Route for creating a new loss profile for a given project.
Raises an HTTPNotFoundError if the project is not found in the database.
:param project_id: the id of the project to create a loss profile for
:return: a tuple containing (json response, http status code)
"""
_LOGGER.info(
"creating loss profile for project {} for request json {}".format(
project_id, request.json))
project = get_project_by_id(project_id)
loss_profile_params = CreateProjectLossProfileSchema().load(
request.get_json(force=True))
model = project.model
if model is None:
raise ValidationError(
("A model has not been set for the project with id {}, "
"project must set a model before running a loss profile."
).format(project_id))
loss_profile = None
job = None
try:
loss_profile = ProjectLossProfile.create(project=project,
source="generated",
**loss_profile_params)
job = Job.create(
project_id=project_id,
type_=CreateLossProfileJobWorker.get_type(),
worker_args=CreateLossProfileJobWorker.format_args(
model_id=model.model_id,
profile_id=loss_profile.profile_id,
pruning_estimations=loss_profile_params["pruning_estimations"],
pruning_estimation_type=loss_profile_params[
"pruning_estimation_type"],
pruning_structure=loss_profile_params["pruning_structure"],
quantized_estimations=loss_profile_params[
"quantized_estimations"],
),
)
loss_profile.job = job
loss_profile.save()
except Exception as err:
_LOGGER.error(
"error while creating new loss profile, rolling back: {}".format(
err))
if loss_profile:
try:
loss_profile.delete_instance()
except Exception as rollback_err:
_LOGGER.error(
"error while rolling back new loss profile: {}".format(
rollback_err))
if job:
try:
job.delete_instance()
except Exception as rollback_err:
_LOGGER.error(
"error while rolling back new loss profile: {}".format(
rollback_err))
raise err
# call into JobWorkerManager to kick off job if it's not already running
JobWorkerManager().refresh()
resp_profile = data_dump_and_validation(ResponseProjectLossProfileSchema(),
{"profile": loss_profile})
_LOGGER.info("created loss profile and job: {}".format(resp_profile))
return jsonify(resp_profile), HTTPStatus.OK.value
def load_data_from_repo(project_id: str):
"""
Route for loading data file(s) for a project from the Neural Magic model repo.
Starts a background job in the JobWorker setup to run.
The state of the job can be checked after.
Raises an HTTPNotFoundError if the project is not found in the database.
:param project_id: the id of the project to load the data for
:return: a tuple containing (json response, http status code)
"""
_LOGGER.info(
"loading data from repo for project {} for request json {}".format(
project_id, request.json))
project = get_project_by_id(project_id)
get_project_model_by_project_id(project_id)
data = SetProjectDataFromSchema().load(request.get_json(force=True))
project_data = None
job = None
try:
project_data = ProjectData.create(project=project,
source="downloaded_path",
job=None)
job = Job.create(
project_id=project.project_id,
type_=DataFromRepoJobWorker.get_type(),
worker_args=DataFromRepoJobWorker.format_args(
data_id=project_data.data_id, uri=data["uri"]),
)
project_data.job = job
project_data.save()
project_data.setup_filesystem()
project_data.validate_filesystem()
except Exception as err:
if project_data:
try:
os.remove(project_data.file_path)
except OSError:
pass
try:
project_data.delete_instance()
except Exception as rollback_err:
_LOGGER.error("error while rolling back new data: {}".format(
rollback_err))
if job:
try:
job.delete_instance()
except Exception as rollback_err:
_LOGGER.error("error while rolling back new data: {}".format(
rollback_err))
_LOGGER.error(
"error while creating new project data, rolling back: {}".format(
err))
raise err
# call into JobWorkerManager to kick off job if it's not already running
JobWorkerManager().refresh()
resp_data = data_dump_and_validation(ResponseProjectDataSingleSchema(),
{"data": project_data})
_LOGGER.info("created project data from path {}".format(resp_data))
return jsonify(resp_data), HTTPStatus.OK.value
def create_benchmark(project_id: str):
"""
Route for creating a new benchmark for a given project.
Raises an HTTPNotFoundError if the project is not found in the database.
:param project_id: the id of the project to create a benchmark for
:return: a tuple containing (json response, http status code)
"""
_LOGGER.info(
"creating benchmark for project {} for request json {}".format(
project_id, request.get_json()))
project = get_project_by_id(project_id)
benchmark_params = CreateProjectBenchmarkSchema().load(
request.get_json(force=True))
model = project.model
if model is None:
raise ValidationError(
("A model has not been set for the project with id {}, "
"project must set a model before running a benchmark."
).format(project_id))
sys_info = get_ml_sys_info()
benchmark = None
job = None
try:
benchmark_params["instruction_sets"] = (
sys_info["available_instructions"]
if "available_instructions" in sys_info else [])
benchmark = ProjectBenchmark.create(project=project,
source="generated",
**benchmark_params)
job = Job.create(
project_id=project.project_id,
type_=CreateBenchmarkJobWorker.get_type(),
worker_args=CreateBenchmarkJobWorker.format_args(
model_id=model.model_id,
benchmark_id=benchmark.benchmark_id,
core_counts=benchmark.core_counts,
batch_sizes=benchmark.batch_sizes,
instruction_sets=benchmark.instruction_sets,
inference_models=benchmark.inference_models,
warmup_iterations_per_check=benchmark.
warmup_iterations_per_check,
iterations_per_check=benchmark.iterations_per_check,
),
)
benchmark.job = job
benchmark.save()
except Exception as err:
_LOGGER.error(
"error while creating new benchmark, rolling back: {}".format(err))
if benchmark:
try:
benchmark.delete_instance()
except Exception as rollback_err:
_LOGGER.error(
"error while rolling back new benchmark: {}".format(
rollback_err))
if job:
try:
job.delete_instance()
except Exception as rollback_err:
_LOGGER.error(
"error while rolling back new benchmark: {}".format(
rollback_err))
raise err
JobWorkerManager().refresh()
resp_benchmark = data_dump_and_validation(ResponseProjectBenchmarkSchema(),
{"benchmark": benchmark})
_LOGGER.info("created benchmark and job: {}".format(resp_benchmark))
return jsonify(resp_benchmark), HTTPStatus.OK.value
