code: def _convert_Mul(node, graph, err):
      input_name_list = [str(i) for i in node.inputs]
      output_name = str(node.outputs[0])
      node_name = node.name
      print("Mul:", node.name, node.attrs, input_name_list, output_name)
      if len(node.attrs) == 0:
          assert len(node.input_tensors) == 1
          assert len(input_name_list) == 2
          inp_tensor = node.input_tensors[input_name_list[1]]
          scale_value = float(inp_tensor)
          print(scale_value)
          layer = myf(
              "Scale",
              node_name,
              [input_name_list[0]],
              [output_name],
              bias_term=False,
              scale_param=dict(
                  filler=dict(value=scale_value), bias_term=False
              ),
          )
          return layer
          # layer = myf("Reshape", node_name, [input_name], [output_name], reshape_param = dict(shape=dict(dim=list(shape))))
      # print(len(node.input_tensors))
  
      # max_dim = 0
      # for name in input_name_list:
      #     if graph.channel_dims[name]>max_dim:
      #         max_dim = graph.channel_dims[name]
  
      if "broadcast" in node.attrs:
          if node.attrs["broadcast"] == 1:
              input_node_number = len(input_name_list)
              if input_node_number != 2:
                  return err.unsupported_op_configuration(
                      node,
                      "Broadcast Mul must has 2 input, not {}".format(
                          input_node_number
                      ),
                  )
              axis = node.attrs["axis"]
              flat_layer = myf(
                  "Flatten",
                  node_name + "_flat",
                  [input_name_list[1]],
                  [output_name + "_flat"],
              )
              layer = myf(
                  "Scale",
                  node_name,
                  [input_name_list[0], output_name + "_flat"],
                  [output_name],
                  bias_term=False,
                  axis=axis,
              )
              graph.channel_dims[output_name] = graph.channel_dims[
                  input_name_list[0]
              ]
              return flat_layer, layer
  
      layer = myf(
          "Eltwise",
          node_name,
          input_name_list,
          [output_name],
          operation=P.Eltwise.PROD,
      )
      graph.channel_dims[output_name] = graph.channel_dims[
          input_name_list[0]
      ]
      return layer
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  from caffe import params
  import math
  import numpy
  from ._graph import Node, Graph
  from MyCaffe import Function
label_desc: Use image node_id 8 for calling a global function with example usage: _convert_Mul(node, graph, err) and returns: layer, layer, flat_layer,  layer, err