def METHOD_NAME(in_shape, kernel_output_channel, bias_shape, auto_pad_mode, dilation, group, kernel_shape, output_padding, pad, stride):
    inputs = []
    initializers = []
    # input
    input = helper.make_tensor_value_info('input', TensorProto.FLOAT, in_shape)
    inputs.append('input')
    # weight
    w_shape = []
    w_shape.append(in_shape[1])
    w_shape.append(kernel_output_channel)
    w_shape.extend(kernel_shape)
    weight = helper.make_tensor(
        'weight',
        TensorProto.FLOAT,
        dims=w_shape,
        vals=np.random.rand(*w_shape).astype(np.float32).flatten().tolist()
        # vals=np.ones(w_shape).astype(np.float32).flatten().tolist()
    )
    inputs.append('weight')
    initializers.append(weight)
    # bias
    if bias_shape is not None:
        bias = helper.make_tensor(
            'bias',
            TensorProto.FLOAT,
            dims=bias_shape,
            vals=np.random.rand(*bias_shape).astype(np.float32).flatten().tolist()
        )
        inputs.append('bias')
        initializers.append(bias)
    # dilation
    d = [1, 1] if dilation is None else dilation
    print('d = {0}'.format(d))
    # output_padding
    out_padding = [0, 0] if output_padding is None else output_padding
    # stride
    s = [1, 1] if stride is None else stride
    print('s = {0}'.format(s))
    # output
    out_shape = []
    out_shape.append(in_shape[0])
    out_shape.append(w_shape[1])
    # pad
    padding = [0, 0, 0, 0]
    if auto_pad_mode in [None, 'NOTSET'] and pad is not None:
        padding = pad
        out_shape.append(s[0] * (in_shape[2] - 1) + out_padding[0] +
                         (w_shape[2] - 1) * d[0] + 1 - padding[0] - padding[2])
        out_shape.append(s[1] * (in_shape[3] - 1) + out_padding[1] +
                         (w_shape[3] - 1) * d[1] + 1 - padding[1] - padding[3])
    elif auto_pad_mode in ['SAME_UPPER', 'SAME_LOWER']:
        out_shape.append(in_shape[2] * s[0])
        out_shape.append(in_shape[3] * s[1])
    else:
        out_shape.append(s[0] * (in_shape[2] - 1) + out_padding[0] +
                         (w_shape[2] - 1) * d[0] + 1 - padding[0] - padding[2])
        out_shape.append(s[1] * (in_shape[3] - 1) + out_padding[1] +
                         (w_shape[3] - 1) * d[1] + 1 - padding[1] - padding[3])
    print('auto_pad_mode = {0}, pad = {1}, padding = {2}'.format(auto_pad_mode, pad, padding))
    print('output shape = {0}'.format(out_shape))
    output = helper.make_tensor_value_info('output', TensorProto.FLOAT, out_shape)
    attributes_dict = {}
    if auto_pad_mode is not None:
        attributes_dict['auto_pad'] = auto_pad_mode
    if dilation is not None:
        attributes_dict['dilations'] = dilation
    if group is not None:
        attributes_dict['group'] = group
    if kernel_shape is not None:
        attributes_dict['kernel_shape'] = kernel_shape
    if output_padding is not None:
        attributes_dict['output_padding'] = output_padding
    if pad is not None:
        attributes_dict['pads'] = padding
    if stride is not None:
        attributes_dict['strides'] = stride
    node = onnx.helper.make_node(
        'ConvTranspose',
        inputs=inputs,
        outputs=['output'],
        **attributes_dict
    )
    nodes = []
    nodes.append(node)
    graph_def = helper.make_graph(
        nodes,
        'test-model',
        [input],
        [output],
        initializer=initializers)
    model_def = helper.make_model(graph_def, producer_name='kendryte')
    return model_def