Пример #1
0
    def update_param_to_nndct(self, node, param_name, param_data):
        for param_type, tensor in node.op.params.items():
            if tensor.name == param_name:
                if node.op.type in [
                        NNDCT_OP.CONVTRANSPOSE2D, NNDCT_OP.CONVTRANSPOSE3D
                ] and param_type == node.op.ParamName.WEIGHTS:
                    param_data = np.copy(param_data).swapaxes(1, 0)
                    param_data = np.ascontiguousarray(param_data)

                if node.op.type in [
                        NNDCT_OP.DEPTHWISE_CONV2D, NNDCT_OP.DEPTHWISE_CONV3D
                ] and param_type == node.op.ParamName.WEIGHTS:
                    in_channels = node.node_config("in_channels")
                    out_channels = node.node_config("out_channels")
                    kernel_size = node.node_config("kernel_size")
                    channel_mutiplier = int(out_channels / in_channels)
                    param_data = param_data.reshape(
                        (channel_mutiplier, in_channels, *kernel_size))

                if node.op.type in [
                        NNDCT_OP.DEPTHWISE_CONVTRANSPOSE2D,
                        NNDCT_OP.DEPTHWISE_CONVTRANSPOSE3D
                ] and param_type == node.op.ParamName.WEIGHTS:
                    in_channels = node.node_config("in_channels")
                    out_channels = node.node_config("out_channels")
                    kernel_size = node.node_config("kernel_size")
                    channel_mutiplier = int(out_channels / in_channels)
                    param_data = param_data.reshape(
                        (in_channels, channel_mutiplier, *kernel_size))
                    param_data = np.copy(param_data).swapaxes(0, 1)
                    param_data = np.ascontiguousarray(param_data)

                tensor.from_ndarray(param_data)
                tensor_util.convert_parameter_tensor_format(
                    tensor, FrameworkType.TORCH, FrameworkType.NNDCT)
Пример #2
0
    def update_param_to_nndct(self, node, param_name, param_data):
        for param_type, tensor in node.op.params.items():
            if tensor.name == param_name:
                if node.op.type == NNDCT_OP.CONVTRANSPOSE2D:
                    if param_type == node.op.ParamName.WEIGHTS:
                        param_data = np.copy(param_data).transpose(1, 0, 2, 3)

                if node.op.type == NNDCT_OP.DEPTHWISE_CONV2D and param_type == node.op.ParamName.WEIGHTS:
                    in_channels = node.node_config("in_channels")
                    out_channels = node.node_config("out_channels")
                    kernel_size = node.node_config("kernel_size")
                    channel_mutiplier = int(out_channels / in_channels)
                    param_data = param_data.reshape(
                        (channel_mutiplier, in_channels, *kernel_size))

                tensor.from_ndarray(param_data)
                tensor_util.convert_parameter_tensor_format(
                    tensor, key_names.FrameworkType.TORCH,
                    key_names.FrameworkType.NNDCT)
Пример #3
0
    def update_param_to_nndct(self, node, param_name, param_data):
        for param_type, tensor in node.op.params.items():
            if tensor.name == param_name:
                if node.op.type in [
                        NNDCT_OP.CONVTRANSPOSE2D, NNDCT_OP.CONVTRANSPOSE3D
                ] and param_type == node.op.ParamName.WEIGHTS:
                    param_data = np.copy(param_data).swapaxes(1, 0)
                    param_data = np.ascontiguousarray(param_data)

                if node.op.type in [
                        NNDCT_OP.DEPTHWISE_CONV2D, NNDCT_OP.DEPTHWISE_CONV3D
                ] and param_type == node.op.ParamName.WEIGHTS:
                    in_channels = node.node_config("in_channels")
                    out_channels = node.node_config("out_channels")
                    kernel_size = node.node_config("kernel_size")
                    channel_mutiplier = int(out_channels / in_channels)
                    param_data = param_data.reshape(
                        (channel_mutiplier, in_channels, *kernel_size))

                if node.op.type in [
                        NNDCT_OP.DEPTHWISE_CONVTRANSPOSE2D,
                        NNDCT_OP.DEPTHWISE_CONVTRANSPOSE3D
                ] and param_type == node.op.ParamName.WEIGHTS:
                    in_channels = node.node_config("in_channels")
                    out_channels = node.node_config("out_channels")
                    kernel_size = node.node_config("kernel_size")
                    channel_mutiplier = int(out_channels / in_channels)
                    param_data = param_data.reshape(
                        (in_channels, channel_mutiplier, *kernel_size))
                    param_data = np.copy(param_data).swapaxes(0, 1)
                    param_data = np.ascontiguousarray(param_data)

                origin_shape = tensor.shape

                tensor.from_ndarray(param_data)
                tensor_util.convert_parameter_tensor_format(
                    tensor, key_names.FrameworkType.TORCH,
                    key_names.FrameworkType.NNDCT)

                NndctScreenLogger().check(
                    f"The shape of data '{tensor.shape}' must be consistent with that of original data '{origin_shape}' for {tensor.name}",
                    origin_shape == tensor.shape)
Пример #4
0
def param_to_torch_format(tensor):
    tu.convert_parameter_tensor_format(tensor, FrameworkType.NNDCT,
                                       FrameworkType.TORCH)
Пример #5
0
def param_to_nndct_format(tensor):
    tu.convert_parameter_tensor_format(tensor, FrameworkType.TORCH,
                                       FrameworkType.NNDCT)
Пример #6
0
def nndct_param_to_tf(tensor):
    return convert_parameter_tensor_format(tensor, 'nndct', 'tensorflow')
Пример #7
0
def tf_param_to_nndct(tensor):
    return convert_parameter_tensor_format(tensor, 'tensorflow', 'nndct')