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