def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) ReduceMax.update_node_stat(node, { 'axis': int64_array([attrs.int('axis', 0)]), 'keep_dims': False }) return cls.enabled
def extract(cls, einsum_node): einsum_name = einsum_node.soft_get('name', einsum_node.id) attrs = get_mxnet_layer_attrs(einsum_node.symbol_dict) equation = attrs.str('subscripts') normalized_equation = Einsum.normalize_equation(einsum_name, equation) Einsum.update_node_stat(einsum_node, {'equation': normalized_equation}) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) act_type = attrs.str('act_type', 'leaky') if act_type == 'prelu': prelu_attrs = {'channel_shared': 1, 'filler_type': 'constant', 'filler_value': 0, 'min': 0, 'max': 1, 'mean': 0, 'std': 0, 'sparse': -1, 'variance_norm': "caffe.FillerParameter.FAN_IN"} PReLU.update_node_stat(node, prelu_attrs) elif act_type == 'elu': alpha = attrs.float('slope', 0.25) Elu.update_node_stat(node, {'alpha': alpha}) elif act_type == 'leaky': negative_slope = attrs.float('slope', 0.25) if negative_slope == 0: ReLU.update_node_stat(node) else: LeakyReLU.update_node_stat(node, {'negative_slope': negative_slope}) elif act_type == 'gelu': GeLUOP.update_node_stat(node, {'approximation_mode': 'erf'}) else: raise Error( "Operation '{}' not supported. Please register it as custom op. " + refer_to_faq_msg(86), act_type) return LeakyReLUFrontExtractor.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) top_k = attrs.int("nms_topk", -1) nms_threshold = attrs.float("nms_threshold", 0.5) confidence_threshold = attrs.float("threshold", 0.01) clip = 0 if not attrs.bool("clip", True) else 1 node_attrs = { 'type': 'DetectionOutput', 'op': __class__.op, 'keep_top_k': top_k, 'variance_encoded_in_target': 0, 'code_type': "caffe.PriorBoxParameter.CENTER_SIZE", 'share_location': 1, 'confidence_threshold': confidence_threshold, 'background_label_id': 0, 'nms_threshold': nms_threshold, 'top_k': top_k, 'decrease_label_id': 1, 'clip_before_nms': clip, 'normalized': 1, } DetectionOutput.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) spatial_scale = attrs.float('spatial_scale', None) group_size = attrs.int('group_size', 0) no_trans = attrs.bool('no_trans', False) trans_std = attrs.float('trans_std', 0) output_dim = attrs.int('output_dim', 0) part_size = attrs.int('part_size', 0) sample_per_part = attrs.int('sample_per_part', 1) pooled_size = attrs.int('pooled_size', 0) data = { 'spatial_scale': spatial_scale, 'mode': 'bilinear_deformable', 'group_size': group_size, 'output_dim': output_dim, 'trans_std': trans_std, 'part_size': part_size, 'spatial_bins_x': sample_per_part, 'spatial_bins_y': sample_per_part, 'pooled_width': pooled_size, 'pooled_height': pooled_size, } DeformablePSROIPoolingOp.update_node_stat(node, data) return cls.enabled
def extract(cls, node: Node): attrs = get_mxnet_layer_attrs(node.symbol_dict) AttributedClamp.update_node_stat(node, { 'min': attrs.float('a_min', None), 'max': attrs.float('a_max', None) }) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) axes = list(attrs.tuple("axes", int, [])) node_attrs = {'axes': axes} # update the attributes of the node SliceLike.update_node_stat(node, node_attrs) return cls.enabled
def extract(self, node): supported = False op_attrs = None node_attrs = get_mxnet_layer_attrs(node.symbol_dict) op_type = node_attrs.str('op_type', None) if op_type and op_type in MXNetCustomFrontExtractorOp.registered_ops: supported, op_attrs = MXNetCustomFrontExtractorOp.registered_ops[op_type]().extract(node) return supported, op_attrs
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) shift = list(attrs.tuple("shift", int, None)) axis = None if attrs.has("axis"): axis = list(attrs.tuple("axis", int, None)) AttributedRoll.update_node_stat(node, {'axes': axis, 'shift': shift}) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) Squeeze.update_node_stat(node, { 'squeeze_dims': attrs.int("axis", None), 'keep_at_least_1d': True }) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) data = { 'axis': attrs.int("dim", 1), } # update the attributes of the node Concat.update_node_stat(node, data) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) update_attrs = {'axis': attrs.int('axis', 0)} # update the attributes of the node PackOp.update_node_stat(node, update_attrs) return cls.enabled
def extract(cls, node: Node): attrs = get_mxnet_layer_attrs(node.symbol_dict) ArangeLikeOp.update_node_stat(node, { 'start': attrs.float('start', 0), 'repeat': attrs.int('repeat', 1), 'step': attrs.float('step', 1), 'axis': attrs.int('axis', None), }) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) output_size = attrs.tuple("output_size", int, None) if len(output_size) == 1: output_size = (output_size[0], output_size[0]) data = {'op': 'Pooling', 'output_size': output_size} AdaptiveAvgPooling.update_node_stat(node, data) return cls.enabled
def extract(cls, node: Node): attrs = get_mxnet_layer_attrs(node.symbol_dict) Range.update_node_stat(node, { 'start': attrs.int('start', 0), 'stop': attrs.int('stop', 0), 'repeat': attrs.int('repeat', 1), 'step': attrs.float('step', 1), 'dtype': np.dtype(attrs.str('dtype ', 'float32')) }) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) node_attrs = { 'crop_begin': mo_array(attrs.tuple("begin", int, ())), 'crop_end': mo_array(attrs.tuple("end", int, ())), 'step': mo_array(attrs.tuple("step", int, ())), } MXSlice.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node: Node): attr = get_mxnet_layer_attrs(node.symbol_dict) node_attrs = { 'epsilon': attr.float('eps', 9.99999975e-06), 'axis': attr.int('axis', -1), 'output_mean_var': attr.bool('output_mean_var', False) } LayerNorm.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) update_attrs = { 'axis': attrs.int('axis', 0), 'mx_out_type': attrs.dtype('dtype', None) } MXNetCumSum.update_node_stat(node, update_attrs) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) offset = attrs.tuple("offset", int, ()) axis = attrs.int("num_args", 0) node_attrs = { 'axis': axis, 'offset': list(offset), 'dim': None, } Crop.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node): attr = get_mxnet_layer_attrs(node.symbol_dict) kernel = attr.tuple("kernel", int, None) stride = attr.tuple("stride", int, tuple(np.ones(len(kernel), dtype=np.int64))) padding = attr.tuple("pad", int, tuple(np.zeros(len(kernel), dtype=np.int64))) dilate = attr.tuple("dilate", int, tuple(np.ones(len(kernel), dtype=np.int64))) group = attr.int("num_group", 1) output = attr.int("num_filter", None) bias_term = not attr.bool("no_bias", True) target_shape = attr.tuple("target_shape", int, None) if target_shape: target_shape = int64_array(target_shape) final_dilations = int64_array([1, 1, *[d for d in dilate] ]) if dilate is not None else None node_attrs = { 'op': __class__.op, 'type': 'Deconvolution', 'bias_addable': True, 'bias_term': bias_term, 'pad': int64_array([[0, 0], [0, 0], *[[pad, pad] for pad in padding]]), 'pad_spatial_shape': int64_array([[pad, pad] for pad in padding]), 'dilation': final_dilations, 'output_spatial_shape': target_shape, 'original_output_spatial_shape': target_shape, 'output_shape': None, 'stride': int64_array([1, 1, *[s for s in stride]]), 'group': group, 'output': output, 'kernel_spatial': int64_array([k for k in kernel]), 'input_feature_channel': 1, 'output_feature_channel': 0, 'kernel_spatial_idx': None, 'reshape_kernel': True, 'spatial_dims': None, 'channel_dims': int64_array([1]), 'batch_dims': int64_array([0]), 'layout': 'NCHW', 'get_pad': DeconvFrontExtractor.get_pad, } output_padding = attr.tuple("adj", int, None) if target_shape is None and output_padding: node_attrs["output_padding"] = int64_array( [0, 0, *[s for s in output_padding]]) # update the attributes of the node Convolution.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node): attr = get_mxnet_layer_attrs(node.symbol_dict) num_hidden = attr.int('num_hidden', None) assert num_hidden is not None, "{} node with no `num_hidden` parameter found".format(cls.op) attrs = { 'out-size': num_hidden, 'transpose_weights': True, 'flatten': attr.bool('flatten', True) } FullyConnected.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node: Node): attrs = get_mxnet_layer_attrs(node.symbol_dict) axis = attrs.int('axis', 0) repeats = attrs.int('repeats', None) assert repeats is not None and repeats > 0, \ '`repeat` op requires positive `repeats` attribute, but it is {} for node {}'.format(repeats, node.name) MXRepeat.update_node_stat(node, { 'axis': axis, 'repeats': repeats, }) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) update_attrs = { 'type': 'SoftMax', 'axis': attrs.int("axis", -1), 'temperature': attrs.float('temperature', 1.0) } # update the attributes of the node Softmax.update_node_stat(node, update_attrs) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) scale = attrs.int("scale", 1) num_filter = attrs.int("num_filter", 0) mode = attrs.str("sample_type", None) if mode == 'nearest': node_attrs = { 'factor': attrs.int("scale", 1), 'mode': mode, 'antialias': 0, 'axes': int64_array([2, 3]), } Interpolate.update_node_stat(node, node_attrs) elif mode == 'bilinear': """ Bilinear UpSampling uses deconvolution algorithm under the hood. For MXNet Bilinear UpSampling op just wrapper over Deconvolution op. Inputs data: input1 - input data input2 - deconvolution weight """ kernel = 2 * scale - scale % 2 stride = scale pad = math.ceil((scale - 1) / 2) num_group = num_filter node_attrs = { 'op': __class__.op, 'type': 'Deconvolution', 'bias_addable': True, 'bias_term': False, 'pad': int64_array([[0, 0], [0, 0], [pad, pad], [pad, pad]]), 'pad_spatial_shape': int64_array([[pad, pad], [pad, pad]]), 'dilation': None, 'output_spatial_shape': None, 'output_shape': None, 'stride': int64_array([1, 1, stride, stride]), 'group': num_group, 'output': num_filter, 'kernel_spatial': int64_array([kernel, kernel]), 'input_feature_channel': 0, 'output_feature_channel': 1, 'kernel_spatial_idx': None, 'reshape_kernel': True, 'spatial_dims': None, 'channel_dims': int64_array([1]), 'batch_dims': int64_array([0]), 'layout': 'NCHW', 'get_pad': DeconvFrontExtractor.get_pad, } Convolution.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) kernel = attrs.tuple("kernel", int, None) stride = attrs.tuple("stride", int, tuple(np.ones(len(kernel), dtype=np.int64))) padding = attrs.tuple("pad", int, tuple(np.zeros(len(kernel), dtype=np.int64))) method = attrs.str("pool_type", None) rt = 'floor' data = { 'window': np.array([1, 1, *[k for k in kernel]], dtype=np.int64), 'stride': np.array([1, 1, *[s for s in stride]], dtype=np.int64), 'pad': np.array([[0, 0], [0, 0], *[[pad, pad] for pad in padding]], dtype=np.int64), 'pad_spatial_shape': np.array([[pad, pad] for pad in padding], dtype=np.int64), 'pool_method': method, 'exclude_pad': False, 'output_spatial_shape': None, 'spatial_dims': None, 'channel_dims': np.array([1], dtype=np.int64), 'batch_dims': np.array([0], dtype=np.int64), 'layout': 'NCHW', 'rounding_type': rt, } pooling_conv = attrs.str("pooling_convention", 'valid') if pooling_conv: data["pooling_convention"] = pooling_conv if pooling_conv == 'full': data["rounding_type"] = 'ceil' global_pool = attrs.bool("global_pool", False) if global_pool: data["global_pool"] = global_pool # update the attributes of the node Pooling.update_node_stat(node, data) return cls.enabled
def extract(node): attrs = get_mxnet_layer_attrs(node.symbol_dict) dim1 = attrs.int("dim1", 0) dim2 = attrs.int("dim2", 0) update_attrs = { 'dim1': dim1, 'dim2': dim2, } # update the attributes of the node SwapAxis.update_node_stat(node, update_attrs) return True
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) shape = list(attrs.tuple("shape", int, None)) high = attrs.float("high", 1.0) low = attrs.float("low", 0.0) out_type = attrs.dtype("dtype", np.float32) new_attrs = { 'shape': shape, 'min_val': out_type(low), 'max_val': out_type(high), 'output_type': out_type } AttributedRandomUniform.update_node_stat(node, new_attrs) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) pads = np.array(list(attrs.tuple('pad_width', int, None))) pads = pads.reshape([-1, 2]) value = attrs.float('constant_value', 0.0) node_attrs = { 'pads': pads, 'mode': attrs.str('mode', None), 'fill_value': value, } AttributedPad.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node): attr = get_mxnet_layer_attrs(node.symbol_dict) kernel = attr.tuple("kernel", int, None) stride = attr.tuple("stride", int, tuple(np.ones(len(kernel), dtype=np.int64))) padding = attr.tuple("pad", int, tuple(np.zeros(len(kernel), dtype=np.int64))) dilate = attr.tuple("dilate", int, tuple(np.ones(len(kernel), dtype=np.int64))) num_deformable_group = attr.int("num_deformable_group", 1) num_group = attr.int("num_group", 1) output = attr.int("num_filter", None) bias_term = attr.str("no_bias", 'False') == 'False' final_dilations = int64_array([1, 1, *[d for d in dilate] ]) if dilate is not None else None node_attrs = { 'op': __class__.op, 'bias_addable': True, 'bias_term': bias_term, 'pad': int64_array([[0, 0], [0, 0], *[[pad, pad] for pad in padding]]), 'pad_spatial_shape': int64_array([[pad, pad] for pad in padding]), 'dilation': final_dilations, 'output_spatial_shape': None, 'output_shape': None, 'stride': int64_array([1, 1, *[s for s in stride]]), 'group': num_group, 'deformable_group': num_deformable_group, 'output': output, 'kernel_spatial': int64_array([k for k in kernel]), 'bilinear_interpolation_pad': True, 'input_feature_channel': 1, 'output_feature_channel': 0, 'kernel_spatial_idx': None, 'reshape_kernel': True, 'weights_index': 2, 'in_ports_count': 4, 'spatial_dims': None, 'channel_dims': int64_array([1]), 'batch_dims': int64_array([0]), 'layout': 'NCHW', } # update the attributes of the node DeformableConvolution.update_node_stat(node, node_attrs) return cls.enabled
def extract(cls, node): attrs = get_mxnet_layer_attrs(node.symbol_dict) alpha = attrs.float("alpha", 0.0001) beta = attrs.float("beta", 0.75) knorm = attrs.float("knorm", 2.0) nsize = attrs.int("nsize", None) AttributedLRN.update_node_stat(node, { 'alpha': alpha, 'beta': beta, 'bias': knorm, 'local_size': nsize, }) return cls.enabled