def __init__(self, *args): # TVM ctx = tvm.cpu() # Hardcoded backend model_path = args[0] + '/' input_shape = shape_str_to_npshape(args[1]) input_type = datatype_str_to_nptype(args[2]) output_shape = shape_str_to_npshape(args[3]) output_type = datatype_str_to_nptype(args[4]) if input_type is None: print("Invalid input_shape") return None if output_type is None: print("Invalid output_shape") return None self.input_dims = [nns.TensorShape(input_shape, input_type)] self.output_dims = [nns.TensorShape(output_shape, output_type)] loaded_json = open(model_path + 'deploy_graph.json').read() loaded_lib = tvm.module.load(model_path + 'deploy_lib.tar') loaded_params = bytearray( open(model_path + 'deploy_param.params', 'rb').read()) self.module = graph_runtime.create(loaded_json, loaded_lib, ctx) self.module.load_params(loaded_params) return None
def __init__(self, *args): # Parse arguments model_path = args[0] input_shapes = shapes_str_to_npshapes(args[1]) input_types = datatypes_str_to_nptypes(args[2]) output_shapes = shapes_str_to_npshapes(args[3]) output_types = datatypes_str_to_nptypes(args[4]) input_names = names_str_to_strarray(args[5]) output_names = names_str_to_strarray(args[6]) for input_type in input_types: if input_type is None: print("Invalid input_type") return None for output_type in output_types: if output_type is None: print("Invalid output_type") return None if (len(input_shapes) > 4 or len(input_types) > 4 or len(input_names) > 4 or len(input_shapes) != len(input_types) or len(input_shapes) != len(input_names)): print("Invalid input count: (%d,%d,%d)".format( len(input_shapes), len(input_types), len(input_names))) return None if (len(output_shapes) > 4 or len(output_types) > 4 or len(output_names) > 4 or len(output_shapes) != len(output_types) or len(output_shapes) != len(output_names)): print("Invalid output count: (%d,%d,%d)".format( len(output_shapes), len(output_types), len(output_names))) return None self.input_dims = [] self.output_dims = [] for i in range(len(input_shapes)): input_dim = nns.TensorShape(input_shapes[i], input_types[i]) self.input_dims.append(input_dim) for i in range(len(output_shapes)): output_dim = nns.TensorShape(output_shapes[i], output_types[i]) self.output_dims.append(output_dim) self.input_names = input_names self.output_names = output_names # Initialize TVM runtime session with given binary session = rpc.LocalSession() session.upload(os.path.join(model_path, "mod.so")) lib = session.load_module("mod.so") ctx = session.cpu() # TODO: Hardcoded CPU backend # Load graph and create a module self.graph = open(os.path.join(model_path, "mod.json")).read() self.module = runtime.create(self.graph, lib, ctx) # Load params self.params = bytearray( open(os.path.join(model_path, "mod.params"), "rb").read()) self.module.load_params(self.params) return None
def convert(self, input_array): rate_n = 10 rate_d = 1 dim = [len(input_array[0]), 1, 1, 1] ttype = np.int32 tensors_info = [nns.TensorShape(dim, ttype)] return tensors_info, input_array, rate_n, rate_d
def convert(self, input_array): json_data = json.loads(input_array[0].tobytes()) json_string = (json_data["json_string"] + '\0').encode() json_object = json.dumps(json_data["json_object"]).encode() output_array1 = np.frombuffer(json_string, dtype=np.uint8) output_array2 = np.frombuffer(json_object, dtype=np.uint8) raw_data = [output_array1, output_array2] rate_n = 10 rate_d = 1 dim1 = [len(raw_data[0]), 1, 1, 1] dim2 = [len(raw_data[1]), 1, 1, 1] ttype = np.uint8 tensors_info = [nns.TensorShape(dim1, ttype), nns.TensorShape(dim2, ttype)] return tensors_info, raw_data, rate_n, rate_d
def __init__(self, *args): # Parse arguments model_path = args[0] input_shapes = util.shapes_str_to_npshapes(args[1]) input_types = util.datatypes_str_to_nptypes(args[2]) input_names = util.names_str_to_strarray(args[3]) num_fragments = int(args[4]) target_uri = args[5] for input_type in input_types: if input_type is None: print("Invalid input_type") return None if (len(input_shapes) > 4 or len(input_types) > 4 or len(input_names) > 4 or len(input_shapes) != len(input_types) or len(input_shapes) != len(input_names)): print("Invalid input count: (%d,%d,%d)".format( len(input_shapes), len(input_types), len(input_names))) return None self.input_dims = [] for i, input_shape in enumerate(input_shapes): input_dim = nns.TensorShape(input_shape, input_types[i]) self.input_dims.append(input_dim) output_dim = nns.TensorShape([1, 1, 1, 1], np.int32) self.output_dims = [output_dim] self.input_names = input_names self.num_fragments = num_fragments self.target_uri = target_uri # Initialize fragment runner self.offload_from = num_fragments - 1 # Initial setting model_path_head = os.path.join(model_path, 'mod') self.interpreters = runner.load_model(model_path_head, num_fragments) # Connect to target self.is_connected = False self.connect_to_target() return None
def setInputDim(self, input_dims): if len(input_dims) != 1: print("One input tensor is allowed") return None self.input_dims = input_dims self.output_dims = [nns.TensorShape(self.input_dims[0].getDims(), self.input_dims[0].getType())] dims = self.output_dims[0].getDims() if self.new_x > 0: dims[1] = self.new_x if self.new_y > 0: dims[2] = self.new_y return self.output_dims
def convert(self, input_array): data = input_array[0].tobytes() root = flexbuffers.GetRoot(data) tensors = root.AsMap num_tensors = tensors['num_tensors'].AsInt rate_n = tensors['rate_n'].AsInt rate_d = tensors['rate_d'].AsInt raw_data = [] tensors_info = [] for i in range(num_tensors): tensor_key = "tensor_{idx}".format(idx=i) tensor = tensors[tensor_key].AsVector ttype = convert_to_numpy_type(tensor[1].AsInt) tdim = tensor[2].AsTypedVector dim = [] for j in range(4): dim.append(tdim[j].AsInt) tensors_info.append(nns.TensorShape(dim, ttype)) raw_data.append(np.frombuffer(tensor[3].AsBlob, dtype=np.uint8)) return tensors_info, raw_data, rate_n, rate_d
def __init__(self, *args): self.input_dims = [nns.TensorShape([D1, D2, D3, D4], np.uint8)] self.output_dims = [nns.TensorShape([D1, D2, D3, D4], np.uint8)]