def _softmax_param_to_attr(node, caffe_layer):
softmax_param = caffe_layer.softmax_param
if softmax_param.HasField('engine'):
attr_value = attr_value_pb2.AttrValue()
_make_engine_attr(attr_value, softmax_param.engine)
if softmax_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = softmax_param.axis
node.attr['axis'].CopyFrom(attr_value)
def _clip_param_to_attr(node, caffe_layer):
clip_param = caffe_layer.clip_param
if clip_param.HasField('min'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = clip_param.min
node.attr['min'].CopyFrom(attr_value)
if clip_param.HasField('max'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = clip_param.max
node.attr['max'].CopyFrom(attr_value)
def _bias_param_to_attr(node, caffe_layer):
bias_param = caffe_layer.bias_param
if bias_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = bias_param.axis
node.attr['axis'].CopyFrom(attr_value)
if bias_param.HasField('num_axes'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = bias_param.num_axes
node.attr['num_axes'].CopyFrom(attr_value)
def _tile_param_to_attr(node, caffe_layer):
tile_param = caffe_layer.tile_param
if tile_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = tile_param.axis
node.attr['axis'].CopyFrom(attr_value)
if tile_param.HasField('tiles'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = tile_param.tiles
node.attr['tiles'].CopyFrom(attr_value)
def _flatten_param_to_attr(node, caffe_layer):
flatten_param = caffe_layer.flatten_param
if flatten_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = flatten_param.axis
node.attr['axis'].CopyFrom(attr_value)
if flatten_param.HasField('end_axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = flatten_param.end_axis
node.attr['end_axis'].CopyFrom(attr_value)
def _power_param_to_attr(node, caffe_layer):
power_param = caffe_layer.power_param
if power_param.HasField('power'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = power_param.power
node.attr['power'].CopyFrom(attr_value)
if power_param.HasField('scale'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = power_param.scale
node.attr['scale'].CopyFrom(attr_value)
def _concat_param_to_attr(node, caffe_layer):
concat_param = caffe_layer.concat_param
if concat_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = concat_param.axis
node.attr['axis'].CopyFrom(attr_value)
if concat_param.HasField('concat_dim'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = concat_param.concat_dim
node.attr['concat_dim'].CopyFrom(attr_value)
def _relu_param_to_attr(node, caffe_layer):
relu_param = caffe_layer.relu_param
if relu_param.HasField('negative_slope'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = relu_param.negative_slope
node.attr['negative_slope'].CopyFrom(attr_value)
if relu_param.HasField('engine'):
attr_value = attr_value_pb2.AttrValue()
_make_engine_attr(attr_value, relu_param.engine)
node.attr['engine'].CopyFrom(attr_value)
def _crop_param_to_attr(node, caffe_layer):
crop_param = caffe_layer.crop_param
if crop_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = crop_param.axis
node.attr['axis'].CopyFrom(attr_value)
if len(crop_param.offset):
offset_value = attr_value_pb2.AttrValue.ListValue()
offset_value.i.extend(crop_param.offset)
attr_value = attr_value_pb2.AttrValue()
attr_value.list.CopyFrom(offset_value)
node.attr['offset'].CopyFrom(attr_value)
def _accuracy_param_to_attr(node, caffe_layer):
accuracy_param = caffe_layer.accuracy_param
if accuracy_param.HasField('top_k'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = accuracy_param.top_k
node.attr['top_k'].CopyFrom(attr_value)
if accuracy_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = accuracy_param.axis
node.attr['axis'].CopyFrom(attr_value)
if accuracy_param.HasField('ignore_label'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = accuracy_param.ignore_label
node.attr['ignore_label'].CopyFrom(attr_value)
def _spp_param_to_attr(node, caffe_layer):
spp_param = caffe_layer.spp_param
if spp_param.HasField('pyramid_height'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = spp_param.pyramid_height
node.attr['pyramid_height'].CopyFrom(attr_value)
if spp_param.HasField('pool'):
attr_value = attr_value_pb2.AttrValue()
_make_pooling_attr(attr_value, spp_param.pool)
node.attr['pool'].CopyFrom(attr_value)
if spp_param.HasField('engine'):
attr_value = attr_value_pb2.AttrValue()
_make_engine_attr(attr_value, spp_param.engine)
node.attr['engine'].CopyFrom(attr_value)
def _log_param_to_attr(node, caffe_layer):
log_param = caffe_layer.log_param
if log_param.HasField('base'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = log_param.base
node.attr['base'].CopyFrom(attr_value)
if log_param.HasField('scale'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = log_param.scale
node.attr['scale'].CopyFrom(attr_value)
if log_param.HasField('shift'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = log_param.shift
node.attr['shift'].CopyFrom(attr_value)
def _slice_param_to_attr(node, caffe_layer):
slice_param = caffe_layer.slice_param
if slice_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = slice_param.axis
node.attr['axis'].CopyFrom(attr_value)
if slice_param.HasField('slice_point'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = slice_param.slice_point
node.attr['slice_point'].CopyFrom(attr_value)
if slice_param.HasField('slice_dim'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = slice_param.slice_dim
node.attr['slice_dim'].CopyFrom(attr_value)
def _argmax_param_to_attr(node, caffe_layer):
argmax_param = caffe_layer.argmax_param
if argmax_param.HasField('out_max_val'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = argmax_param.out_max_val
node.attr['out_max_val'].CopyFrom(attr_value)
if argmax_param.HasField('top_k'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = argmax_param.top_k
node.attr['top_k'].CopyFrom(attr_value)
if argmax_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = argmax_param.axis
node.attr['axis'].CopyFrom(attr_value)
def _batch_norm_param_to_attr(node, caffe_layer):
bn_param = caffe_layer.batch_norm_param
if bn_param.HasField('use_global_stats'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = bn_param.use_global_stats
node.attr['use_global_stats'].CopyFrom(attr_value)
if bn_param.HasField('moving_average_fraction'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = bn_param.moving_average_fraction
node.attr['moving_average_fraction'].CopyFrom(attr_value)
if bn_param.HasField('eps'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = bn_param.eps
node.attr['eps'].CopyFrom(attr_value)
def _reshape_param_to_attr(node, caffe_layer):
reshape_param = caffe_layer.reshape_param
if reshape_param.HasField('shape'):
attr_value = attr_value_pb2.AttrValue()
_make_shape_attr(attr_value, reshape_param.shape)
node.attr['shape'].CopyFrom(attr_value)
if reshape_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = reshape_param.axis
node.attr['axis'].CopyFrom(attr_value)
if reshape_param.HasField('num_axes'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = reshape_param.num_axes
node.attr['num_axes'].CopyFrom(attr_value)
def _eltwise_param_to_attr(node, caffe_layer):
eltwise_param = caffe_layer.eltwise_param
if eltwise_param.HasField('operation'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = eltwise_param.operation
node.attr['operation'].CopyFrom(attr_value)
if len(eltwise_param.coeff):
coeff_value = attr_value_pb2.AttrValue.ListValue()
coeff_value.f.extend(eltwise_param.coeff)
attr_value = attr_value_pb2.AttrValue()
attr_value.list.CopyFrom(coeff_value)
node.attr['coeff'].CopyFrom(attr_value)
if eltwise_param.HasField('stable_prod_grad'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = eltwise_param.stable_prod_grad
node.attr['stable_prod_grad'].CopyFrom(attr_value)
def _add_node_shapetype(self, node, shape_name):
""" build an internal node shape map if given the weights information """
if shape_name in self.shapes:
tensor_shape = tensor_shape_pb2.TensorShapeProto()
for shape_i in self.shapes[shape_name]:
shape_dim = tensor_shape_pb2.TensorShapeProto.Dim()
shape_dim.size = shape_i
tensor_shape.dim.extend([shape_dim])
attr_value = attr_value_pb2.AttrValue()
attr_value.shape.CopyFrom(tensor_shape)
node.attr['shape'].CopyFrom(attr_value)
# add optional dtype
if shape_name in self.types:
attr_value = attr_value_pb2.AttrValue()
attr_value.type = self.types[shape_name]
node.attr['dtype'].CopyFrom(attr_value)
def _transform_param_to_attr(node, caffe_layer):
transform_param = caffe_layer.transform_param
if transform_param.HasField('scale'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = transform_param.scale
node.attr['scale'].CopyFrom(attr_value)
if transform_param.HasField('mirror'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = transform_param.mirror
node.attr['mirror'].CopyFrom(attr_value)
if transform_param.HasField('crop_size'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = transform_param.crop_size
node.attr['crop_size'].CopyFrom(attr_value)
if transform_param.HasField('mean_file'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = bytes(transform_param.mean_file, "utf-8")
node.attr['mean_file'].CopyFrom(attr_value)
if len(transform_param.mean_value):
mean_value_list = attr_value_pb2.AttrValue.ListValue()
mean_value_list.f.extend(transform_param.mean_value)
attr_value = attr_value_pb2.AttrValue()
attr_value.list.CopyFrom(mean_value_list)
node.attr['mean_value'].CopyFrom(attr_value)
if transform_param.HasField('force_color'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = transform_param.force_color
node.attr['force_color'].CopyFrom(attr_value)
if transform_param.HasField('force_gray'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = transform_param.force_gray
node.attr['force_gray'].CopyFrom(attr_value)
def _data_param_to_attr(node, caffe_layer):
data_param = caffe_layer.data_param
if data_param.HasField('source'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = bytes(data_param.source, "utf-8")
node.attr['source'].CopyFrom(attr_value)
if data_param.HasField('batch_size'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = data_param.batch_size
node.attr['batch_size'].CopyFrom(attr_value)
if data_param.HasField('rand_skip'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = data_param.rand_skip
node.attr['rand_skip'].CopyFrom(attr_value)
if data_param.HasField('backend'):
attr_value = attr_value_pb2.AttrValue()
_make_backend_attr(attr_value, data_param.backend)
node.attr['backend'].CopyFrom(attr_value)
if data_param.HasField('scale'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = data_param.scale
node.attr['scale'].CopyFrom(attr_value)
if data_param.HasField('mean_file'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = data_param.mean_file
node.attr['mean_file'].CopyFrom(attr_value)
if data_param.HasField('crop_size'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = data_param.crop_size
node.attr['crop_size'].CopyFrom(attr_value)
if data_param.HasField('mirror'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = data_param.mirror
node.attr['mirror'].CopyFrom(attr_value)
if data_param.HasField('force_encoded_color'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = data_param.force_encoded_color
node.attr['force_encoded_color'].CopyFrom(attr_value)
if data_param.HasField('prefetch'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = data_param.prefetch
node.attr['prefetch'].CopyFrom(attr_value)
def _inner_product_param_to_attr(node, caffe_layer):
inner_product_param = caffe_layer.inner_product_param
if inner_product_param.HasField('num_output'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = inner_product_param.num_output
node.attr['num_output'].CopyFrom(attr_value)
if inner_product_param.HasField('bias_term'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = inner_product_param.bias_term
node.attr['bias_term'].CopyFrom(attr_value)
if inner_product_param.HasField('weight_filler'):
attr_value = attr_value_pb2.AttrValue()
weight_filler = inner_product_param.weight_filler
_make_filler_attr(attr_value, weight_filler)
node.attr['weight_filler'].CopyFrom(attr_value)
if inner_product_param.HasField('bias_filler'):
attr_value = attr_value_pb2.AttrValue()
bias_filler = inner_product_param.bias_filler
_make_filler_attr(attr_value, bias_filler)
node.attr['bias_filler'].CopyFrom(attr_value)
if inner_product_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = inner_product_param.axis
node.attr['axis'].CopyFrom(attr_value)
if inner_product_param.HasField('transpose'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = inner_product_param.transpose
node.attr['transpose'].CopyFrom(attr_value)
def _lrn_param_to_attr(node, caffe_layer):
lrn_param = caffe_layer.lrn_param
if lrn_param.HasField('local_size'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = lrn_param.local_size
node.attr['local_size'].CopyFrom(attr_value)
if lrn_param.HasField('alpha'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = lrn_param.alpha
node.attr['alpha'].CopyFrom(attr_value)
if lrn_param.HasField('beta'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = lrn_param.beta
node.attr['beta'].CopyFrom(attr_value)
if lrn_param.HasField('norm_region'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = lrn_param.norm_region
node.attr['norm_region'].CopyFrom(attr_value)
if lrn_param.HasField('k'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = lrn_param.k
node.attr['k'].CopyFrom(attr_value)
if lrn_param.HasField('engine'):
attr_value = attr_value_pb2.AttrValue()
_make_engine_attr(attr_value, lrn_param.engine)
node.attr['engine'].CopyFrom(attr_value)
def _scale_param_to_attr(node, caffe_layer):
scale_param = caffe_layer.scale_param
if scale_param.HasField('axis'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = scale_param.axis
node.attr['axis'].CopyFrom(attr_value)
if scale_param.HasField('num_axes'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = scale_param.num_axes
node.attr['num_axes'].CopyFrom(attr_value)
if scale_param.HasField('filler'):
attr_value = attr_value_pb2.AttrValue()
_make_filler_attr(attr_value, scale_param.filler)
node.attr['filler'].CopyFrom(attr_value)
if scale_param.HasField('bias_term'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = scale_param.bias_term
node.attr['bias_term'].CopyFrom(attr_value)
if scale_param.HasField('bias_filler'):
attr_value = attr_value_pb2.AttrValue()
_make_filler_attr(attr_value, scale_param.bias_filler)
node.attr['bias_filler'].CopyFrom(attr_value)
def _make_filler_attr(attr, filler):
""" Convert an caffe filler message into TensorBoard Attribute Message.
It's built into a map from name to AttrValue
Args:
attr: a AttrValue message for TensorBoard proto
filler: a FillerParameter message on caffe proto
"""
name_attr_list = attr_value_pb2.NameAttrList()
name_attr_list.name = "filler"
if filler.HasField('type'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = bytes(filler.type, "utf-8")
name_attr_list.attr['type'].CopyFrom(attr_value)
if filler.HasField('value'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = filler.value
name_attr_list.attr['value'].CopyFrom(attr_value)
if filler.HasField('min'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = filler.min
name_attr_list.attr['min'].CopyFrom(attr_value)
if filler.HasField('max'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = filler.max
name_attr_list.attr['max'].CopyFrom(attr_value)
if filler.HasField('mean'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = filler.mean
name_attr_list.attr['mean'].CopyFrom(attr_value)
if filler.HasField('std'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = filler.std
name_attr_list.attr['std'].CopyFrom(attr_value)
if filler.HasField('sparse'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = filler.sparse
name_attr_list.attr['sparse'].CopyFrom(attr_value)
if filler.HasField('variance_norm'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = filler.variance_norm
name_attr_list.attr['variance_norm'].CopyFrom(attr_value)
attr.func.CopyFrom(name_attr_list)
def convert_to_nodes(self, onnx_node):
new_node = node_def_pb2.NodeDef()
new_node.op = onnx_node.op_type
for onnx_input in onnx_node.input:
if onnx_input not in self._nodes_version:
in_node = node_def_pb2.NodeDef()
# These input tensors are filled by weights. So the op_type for
# them is set to `Initialization`
in_node.op = "Initialization"
self._nodes_version[onnx_input] = 0
in_node.name = '{}_{}'.format(onnx_input,
self._nodes_version[onnx_input])
self.tb_nodes[in_node.name] = in_node
self._tb_graph.node.extend([in_node])
new_node.input.append('{}_{}'.format(
onnx_input, self._nodes_version[onnx_input]))
if len(onnx_node.output) == 0:
# For those nodes who don't have output, the node name is the
# operation type for current tensorboard ir node
new_node.name = self._MakeSSAName(onnx_node.op_type)
else:
# For those nodes who have more than one outputs, the first output
# is as the node name. The other outputs are built as the sibling
# operation node for tensorboard ir
new_node.name = self._MakeSSAName(onnx_node.output[0])
# build sibling operation node for other outputs
for onnx_output in onnx_node.output[1:]:
out_node = node_def_pb2.NodeDef()
out_node.name = self._MakeSSAName(onnx_output)
out_node.op = "Sibling"
out_node.input.extend([new_node.name])
self.tb_nodes[out_node.name] = out_node
self._tb_graph.node.extend([out_node])
# handle onnx node attribute
for onnx_attr in onnx_node.attribute:
attr_value = attr_value_pb2.AttrValue()
_make_onnxattr_to_tbattr(onnx_attr, attr_value)
new_node.attr[onnx_attr.name].CopyFrom(attr_value)
self.tb_nodes[new_node.name] = new_node
self._tb_graph.node.extend([new_node])
def _window_data_param_to_attr(node, caffe_layer):
window_data_param = caffe_layer.window_data_param
if window_data_param.HasField('source'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = bytes(window_data_param.source, "utf-8")
node.attr['source'].CopyFrom(attr_value)
if window_data_param.HasField('scale'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = window_data_param.scale
node.attr['scale'].CopyFrom(attr_value)
if window_data_param.HasField('mean_file'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = bytes(window_data_param.mean_file, "utf-8")
if window_data_param.HasField('batch_size'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = window_data_param.batch_size
node.attr['batch_size'].CopyFrom(attr_value)
if window_data_param.HasField('crop_size'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = window_data_param.crop_size
node.attr['crop_size'].CopyFrom(attr_value)
if window_data_param.HasField('mirror'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = window_data_param.mirror
node.attr['mirror'].CopyFrom(attr_value)
if window_data_param.HasField('fg_threshold'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = window_data_param.fg_threshold
node.attr['fg_threshold'].CopyFrom(attr_value)
if window_data_param.HasField('bg_threshold'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = window_data_param.bg_threshold
node.attr['bg_threshold'].CopyFrom(attr_value)
if window_data_param.HasField('fg_fraction'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = window_data_param.fg_fraction
node.attr['fg_fraction'].CopyFrom(attr_value)
if window_data_param.HasField('context_pad'):
attr_value = attr_value_pb2.AttrValue()
attr_value.i = window_data_param.context_pad
node.attr['context_pad'].CopyFrom(attr_value)
if window_data_param.HasField('crop_mode'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = bytes(window_data_param.crop_mode, "utf-8")
node.attr['crop_mode'].CopyFrom(attr_value)
if window_data_param.HasField('cache_images'):
attr_value = attr_value_pb2.AttrValue()
attr_value.b = window_data_param.cache_images
node.attr['cache_images'].CopyFrom(attr_value)
if window_data_param.HasField('root_folder'):
attr_value = attr_value_pb2.AttrValue()
attr_value.s = bytes(window_data_param.root_folder, "utf-8")
node.attr['root_folder'].CopyFrom(attr_value)
def _threshold_param_to_attr(node, caffe_layer):
threshold_param = caffe_layer.threshold_param
if threshold_param.HasField('threshold'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = threshold_param.threshold
node.attr['threshold'].CopyFrom(attr_value)
def _tanh_param_to_attr(node, caffe_layer):
tanh_param = caffe_layer.tanh_param
if tanh_param.HasField('engine'):
attr_value = attr_value_pb2.AttrValue()
_make_engine_attr(attr_value, tanh_param.engine)
def _swish_param_to_attr(node, caffe_layer):
swish_param = caffe_layer.swish_param
if swish_param.HasField('beta'):
attr_value = attr_value_pb2.AttrValue()
attr_value.f = swish_param.beta
node.attr['beta'].CopyFrom(attr_value)
def _sigmoid_param_to_attr(node, caffe_layer):
sigmoid_param = caffe_layer.sigmoid_param
if sigmoid_param.HasField('engine'):
attr_value = attr_value_pb2.AttrValue()
_make_engine_attr(attr_value, sigmoid_param.engine)
