in webserver_pkg/webserver_pkg/models.py [0:0]
def api_load_model(model_folder_name, model_name):
"""API to call the service to load model for inference after verifying if its in valid state.
Returns:
dict: Execution status if the API call was successful and the error reason if failed.
"""
webserver_node = webserver_publisher_node.get_webserver_node()
webserver_node.get_logger().info("Loading {}/{}".format(model_folder_name, model_name))
try:
verify_model_ready_req = VerifyModelReadySrv.Request()
verify_model_ready_req.model_name = model_folder_name
model_verification_res = call_service_sync(webserver_node.verify_model_ready_cli,
verify_model_ready_req)
webserver_node.get_logger().info("Model verification completed result "
f"{model_verification_res.response_status}")
if model_verification_res is None or not model_verification_res.response_status:
return jsonify({"success": False, "reason": "Model optimization failed!"})
err_code, err_msg, model_metadata_content = \
read_model_metadata_file(os.path.join(
os.path.join(constants.MODEL_DIRECTORY_PATH,
model_folder_name),
"model_metadata.json"))
if err_code > 0:
return jsonify({"success": False,
"reason": err_msg})
err_code, err_msg, model_metadata_sensors = get_sensors(model_metadata_content)
if err_code > 0:
return jsonify({"success": False,
"reason": err_msg})
err_code, err_msg, training_algorithm = get_training_algorithm(model_metadata_content)
if err_code > 0:
return jsonify({"success": False,
"reason": err_msg})
err_code, err_msg, action_space_type = get_action_space_type(model_metadata_content)
if err_code > 0:
return jsonify({"success": False,
"reason": err_msg})
err_code, err_msg, action_space = get_action_space(model_metadata_content)
if err_code > 0:
return jsonify({"success": False,
"reason": err_msg})
if not validate_action_space(action_space, action_space_type):
return jsonify({"success": False,
"reason": "Incorrect values in model_metadata.json"})
err_code, sensor_resp = get_sensor_status()
if err_code > 0:
return jsonify({"success": False,
"reason": "Error getting sensor status"})
err_code, err_msg = verify_sensor_connection(model_metadata_sensors, sensor_resp)
if err_code > 0:
return jsonify({"success": False,
"reason": err_msg})
err_code, err_msg, model_lidar_config = load_lidar_configuration(model_metadata_sensors,
model_metadata_content)
if err_code > 0:
return jsonify({"success": False,
"reason": err_msg})
# Configure lidar service. Call the service to load model specific lidar configuration
# or to reset the lidar configuration to default.
configure_lidar_req = LidarConfigSrv.Request()
configure_lidar_req.use_lidar = \
model_lidar_config[constants.ModelMetadataKeys.USE_LIDAR]
configure_lidar_req.min_angle = \
model_lidar_config[constants.ModelMetadataKeys.MIN_LIDAR_ANGLE]
configure_lidar_req.max_angle = \
model_lidar_config[constants.ModelMetadataKeys.MAX_LIDAR_ANGLE]
configure_lidar_req.num_values = \
model_lidar_config[constants.ModelMetadataKeys.NUM_LIDAR_VALUES]
configure_lidar_req.min_distance = \
model_lidar_config[constants.ModelMetadataKeys.MIN_LIDAR_DIST]
configure_lidar_req.max_distance = \
model_lidar_config[constants.ModelMetadataKeys.MAX_LIDAR_DIST]
configure_lidar_req.clipping_distance = \
model_lidar_config[constants.ModelMetadataKeys.LIDAR_CLIPPING_DIST]
configure_lidar_req.num_sectors = \
model_lidar_config[constants.ModelMetadataKeys.NUM_LIDAR_SECTORS]
configure_lidar_req.preprocess_type = \
model_lidar_config[constants.LIDAR_PREPROCESS_KEY]
configure_lidar_res = call_service_sync(webserver_node.configure_lidar_cli,
configure_lidar_req)
webserver_node.get_logger().info("Setting lidar configuration is completed: "
f"{configure_lidar_res.error}")
if configure_lidar_res is None or configure_lidar_res.error != 0:
return jsonify({"success": False, "reason": "Setting lidar configuration failed!"})
model_path = model_folder_name + "/" + model_name
model_state_req = ModelStateSrv.Request()
model_state_req.model_name = model_path
model_state_req.model_metadata_sensors = [sensor.value for sensor
in model_metadata_sensors]
model_state_req.training_algorithm = training_algorithm.value
model_state_req.action_space_type = action_space_type.value
model_state_req.img_format = constants.MODEL_FORMAT
model_state_req.width = constants.MODEL_WIDTH
model_state_req.height = constants.MODEL_HEIGHT
model_state_req.num_channels = constants.MODEL_CHANNELS
model_state_req.lidar_channels = \
model_lidar_config[constants.ModelMetadataKeys.NUM_LIDAR_SECTORS]
model_state_req.platform = constants.MODEL_PLATFORM
model_state_req.task_type = constants.MODEL_TASK_TYPE
model_state_req.pre_process_type = constants.MODEL_PRE_PROCESS
model_state_res = call_service_sync(webserver_node.model_state_cli,
model_state_req)
if model_state_res and model_state_res.error == 0:
webserver_node.get_logger().info("Model Loaded")
return jsonify({"success": True})
else:
webserver_node.get_logger().error("Model optimizer error")
return jsonify({"success": False,
"reason": "Model load failed! Please check the ROS logs"})
except Exception as ex:
webserver_node.get_logger().error("Unable to reach model state server: {ex}")
return jsonify({"success": False,
"reason": "Unable to reach model state server"})