query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Map MXNet's deconvolution operator attributes to onnx's ConvTranspose operator and return the created node. | def convert_deconvolution(node, **kwargs):
name, inputs, attrs = get_inputs(node, kwargs)
kernel_dims = list(parse_helper(attrs, "kernel"))
stride_dims = list(parse_helper(attrs, "stride", [1, 1]))
pad_dims = list(parse_helper(attrs, "pad", [0, 0]))
num_group = int(attrs.get("num_group", 1))
di... | [
"def _create_transpose(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('perm', op.perm),\n ])\n return node",
"def convert_transpose(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's crop operator attributes to onnx's Crop operator and return the created node. | def convert_crop(node, **kwargs):
name, inputs, attrs = get_inputs(node, kwargs)
start = np.array([0, 0, 0, 0], dtype=np.int) # index是int类型
export_nodes = []
start_node = create_helper_tensor_node(start, name + '__starts', kwargs)
export_nodes.extend(start_node)
start_node = start_node[-1].... | [
"def create_crop(self, figure):\n return Crop(figure, self)",
"def _create_clip(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n if op.min is not None:\n node.input.append(op.name + \":min\")\n else:\n node.input.append(\"\")\n if ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's UpSampling operator attributes to onnx's Upsample operator and return the created node. | def convert_upsample(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
sample_type = attrs.get('sample_type', 'nearest')
sample_type = 'linear' if sample_type == 'bilinear' else sample_type
scale = convert_string_to_list(attrs.get('scale'))
scaleh = scalew = float(scale[0])
... | [
"def _darknet_upsampling(inputs, params, attrs, prefix):\n new_attrs = {}\n new_attrs[\"scale_h\"] = attrs.get(\"scale\", 1)\n new_attrs[\"scale_w\"] = attrs.get(\"scale\", 1)\n return get_relay_op(\"upsampling\")(*inputs, **new_attrs)",
"def test_upsampling(dpu_target):\n\n shape = (64, 512, 10, 1... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's FullyConnected operator attributes to onnx's Gemm operator and return the created node. | def convert_fully_connected(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
initializer = kwargs["initializer"]
no_bias = get_boolean_attribute_value(attrs, "no_bias")
fcnode = []
op_name = "flatten_" + str(kwargs["idx"])
flatten_node = onnx.helper.make_node(
'Fl... | [
"def _create_gemm(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('alpha', float(op.alpha)),\n helper.make_attribute('beta', float(op.beta)),\n helper.make_attribute('transA', op.transA),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's BatchNorm operator attributes to onnx's BatchNormalization operator and return the created node. | def convert_batchnorm(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
momentum = float(attrs.get("momentum", 0.9))
eps = float(attrs.get("eps", 0.001))
bn_node = onnx.helper.make_node(
"BatchNormalization",
input_nodes,
[name],
name=name,
ep... | [
"def convert_batchnorm(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n momentum = float(attrs.get(\"momentum\", 0.9))\n eps = float(attrs.get(\"eps\", 0.001))\n bn_node = onnx.helper.make_node(\n \"BatchNormalization\",\n input_nodes,\n [name],\n name... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's tanh operator attributes to onnx's Tanh operator and return the created node. | def convert_tanh(node, **kwargs):
return create_basic_op_node('Tanh', node, kwargs) | [
"def tanh(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Tanh\", [node])",
"def tanh(self):\n return type(self)(self.parent(),\n self._simplify(self._express.tanh()))",
"def _create_hardsigmoid(cls, op, op_t):\n node =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's cos operator attributes to onnx's Cos operator and return the created node. | def convert_cos(node, **kwargs):
return create_basic_op_node('Cos', node, kwargs) | [
"def cos(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Cos\", [node])",
"def cos(x):\n return CosOp(x)",
"def cos(self):\n return type(self)(self.parent(),\n self._simplify(self._express.cos()))",
"def cos(self) -> Self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's sin operator attributes to onnx's Sin operator and return the created node. | def convert_sin(node, **kwargs):
return create_basic_op_node('Sin', node, kwargs) | [
"def sin(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Sin\", [node])",
"def sin(self):\n return type(self)(self.parent(),\n self._simplify(self._express.sin()))",
"def sin(x):\n return SinOp(x)",
"def sin(obj):\n\tif i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's tan operator attributes to onnx's tan operator and return the created node. | def convert_tan(node, **kwargs):
return create_basic_op_node('Tan', node, kwargs) | [
"def tan(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Tan\", [node])",
"def convert_tanh(node, **kwargs):\n return create_basic_op_node('Tanh', node, kwargs)",
"def tan(self):\n return type(self)(self.parent(),\n self._s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's acos operator attributes to onnx's acos operator and return the created node. | def convert_acos(node, **kwargs):
return create_basic_op_node('Acos', node, kwargs) | [
"def convert_cos(node, **kwargs):\n return create_basic_op_node('Cos', node, kwargs)",
"def cos(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Cos\", [node])",
"def arccos(self):\n return type(self)(self.parent(),\n self._... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's asin operator attributes to onnx's asin operator and return the created node. | def convert_asin(node, **kwargs):
return create_basic_op_node('Asin', node, kwargs) | [
"def asin(x, name=None):\n result = _op_def_lib.apply_op(\"Asin\", x=x, name=name)\n return result",
"def as_pin_in( self ) -> \"pin_in\":\n return self._as_pin_in( self )",
"def __get_isin(instrument):\n return instrument['isin']",
"def asin(data):\n return _make.asin(data)",
"def toInfi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's atan operator attributes to onnx's atan operator and return the created node. | def convert_atan(node, **kwargs):
return create_basic_op_node('Atan', node, kwargs) | [
"def convert_acos(node, **kwargs):\n return create_basic_op_node('Acos', node, kwargs)",
"def atan (cls, x) :\n return Angle_R (math.atan (x))",
"def convert_tan(node, **kwargs):\n return create_basic_op_node('Tan', node, kwargs)",
"def convert_asin(node, **kwargs):\n return create_basic_op_no... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's sigmoid operator attributes to onnx's Sigmoid operator and return the created node. | def convert_sigmoid(node, **kwargs):
return create_basic_op_node('Sigmoid', node, kwargs) | [
"def _create_hardsigmoid(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('alpha', op.alpha),\n helper.make_attribute('beta', op.gamma),\n ])\n return node",
"def _create_hardsigmoid(cls, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's relu operator attributes to onnx's Relu operator and return the created node. | def convert_relu(node, **kwargs):
return create_basic_op_node('Relu', node, kwargs) | [
"def relu():\r\n\r\n\treturn activations.relu",
"def _create_elu(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('alpha', op.alpha),\n ])\n return node",
"def relu(x, name):\n\n with tf.nam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Activation operator attributes to onnx's Tanh/Relu operator and return the created node. | def convert_activation(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
act_type = attrs["act_type"]
# Creating a dictionary here, but if this titlecase pattern
# mxnet_name.title()
act_types = {
"tanh": "Tanh",
"relu": "Relu",
"sigmoid": "Sigmoid",
... | [
"def _create_elu(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('alpha', op.alpha),\n ])\n return node",
"def _create_gemm(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's pad operator attributes to onnx's Pad operator and return the created node. | def convert_pad(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mxnet_pad_width = convert_string_to_list(attrs.get("pad_width"))
onnx_pad_width = transform_padding(mxnet_pad_width)
pad_mode = attrs.get("mode")
if pad_mode == "constant":
pad_value = float(attrs.get("co... | [
"def get_pads(onnx_node): # type: (NodeWrapper) -> Tuple[int, int, int]\n auto_pad = onnx_node.get_attribute_value('auto_pad')\n pads = onnx_node.get_attribute_value('pads', ()) # Padding along each axis\n kernel_shape = onnx_node.get_attribute_value('kernel_shape')\n\n # Attribute 'auto_pad' is depre... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
create extra tensor node from numpy values | def create_helper_tensor_node(input_vals, output_name, kwargs):
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[input_vals.dtype]
tensor_node = onnx.helper.make_tensor_value_info(
name=output_name,
elem_type=data_type,
shape=input_vals.shape
)
kwargs["initializer"].append(
... | [
"def create_const_node(input_name, value, kwargs):\n from onnx.helper import make_tensor\n initializer = kwargs[\"initializer\"]\n dtype = value.dtype\n if dtype == 'float16':\n # when using float16, we must convert it to np.uint16 view first\n value = np.float16(value).view(np.uint16)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
create extra reshape node with static shape | def create_helper_reshape_node(input_name, output_name, shape, kwargs):
shape_tensor_node, = create_helper_tensor_node(
np.asarray(shape, dtype=np.int64), output_name + "__shape", kwargs
)
reshape_node = onnx.helper.make_node(
"Reshape",
inputs=[input_name, shape_tensor_node.name],
... | [
"def reshape(\n node: NodeInput,\n output_shape: NodeInput,\n special_zero: bool,\n name: Optional[str] = None,\n) -> Node:\n return _get_node_factory_opset1().create(\n \"Reshape\",\n as_nodes(node, output_shape),\n {\"special_zero\": special_zero},\n )",
"def convert_resha... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
create extra concat node | def create_helper_concat_node(inputs, output_name, axis=0):
concat_node = onnx.helper.make_node(
"Concat",
inputs=inputs,
outputs=[output_name],
name=output_name,
axis=axis,
)
return [concat_node] | [
"def _create_concat(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axis', op.axis),\n ])\n return node",
"def concat(nodes: List[NodeInput], axis: int, name: Optional[str] = None) -> Node:\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
create extra expand node | def create_helper_expand_node(input_name, output_name, expand_shape):
expand_node = onnx.helper.make_node(
"Expand",
inputs=[input_name, expand_shape],
outputs=[output_name],
name=output_name,
)
return [expand_node] | [
"def expandNode(self, id):",
"def expand(self, node):\n node.expand(self.selPolicy)",
"def expand_link(self, num, is_list, node_path_string, parent):\n return '%s%s%s%s%s\\n%s' % ( self.node_span(node_path_string),\n '[ ' if is_list else '{ ',\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
create extra shape node for specified input node | def create_helper_shape_node(input_name, output_name):
shape_node = onnx.helper.make_node(
"Shape",
inputs=[input_name],
outputs=[output_name],
name=output_name,
)
return [shape_node] | [
"def convert_shape(node, **kwargs):\n return create_basic_op_node('Shape', node, kwargs)",
"def add_input_and_output_shape(self, input_shape, output_shape):",
"def add_input_node(self,\n input_node: 'Node'):\n self.input_node.append(input_node)\n input_node.output_node.app... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's dot operator attributes to onnx's MatMul and Transpose operators based on the values set for transpose_a, transpose_b attributes. | def convert_dot(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
input_node_a = input_nodes[0]
input_node_b = input_nodes[1]
trans_a_node = None
trans_b_node = None
trans_a = get_boolean_attribute_value(attrs, "transpose_a")
trans_b = get_boolean_attribute_value(attrs, ... | [
"def _convert_operator(op_name, attrs, identity_list=None, convert_map=None):\n identity_list = identity_list if identity_list else _identity_list\n convert_map = convert_map if convert_map else _convert_map\n if op_name in identity_list:\n pass\n elif op_name in convert_map:\n op_name, at... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _linalg_gemm2 operator attributes to onnx's MatMul and Transpose operators based on the values set for transpose_a, transpose_b attributes. Return multiple nodes created. | def convert_linalg_gemm2(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
# Getting the attributes and assigning default values.
alpha = float(attrs.get("alpha", 1.0))
trans_a = get_boolean_attribute_value(attrs, "transpose_a")
trans_b = get_boolean_attribute_value(attrs, "trans... | [
"def _create_gemm(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('alpha', float(op.alpha)),\n helper.make_attribute('beta', float(op.beta)),\n helper.make_attribute('transA', op.transA),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Pooling operator attributes to onnx's MaxPool/AveragePool/GlobalMaxPool/GlobalAveragePool operators based on the input node's attributes and return the created node. | def convert_pooling(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
kernel = eval(attrs["kernel"])
pool_type = attrs["pool_type"] if attrs.get("pool_type") else "max"
stride = eval(attrs["stride"]) if attrs.get("stride") else (1, 1)
global_pool = get_boolean_attribute_value(att... | [
"def convert_roipooling(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n pooled_shape = convert_string_to_list(attrs.get('pooled_size'))\n scale = float(attrs.get(\"spatial_scale\"))\n\n node = onnx.helper.make_node(\n 'MaxRoiPool',\n input_nodes,\n [name],... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's exp operator attributes to onnx's Exp operator and return the created node. | def convert_exp(node, **kwargs):
return create_basic_op_node('Exp', node, kwargs) | [
"def exp(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Exp\", [node])",
"def setup_expression(node, handlers):\n global _LOG\n fun = operator(node)\n if fun not in handlers.keys():\n _LOG.error(\"unexpected operator \" + fun)\n return ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _copy operator attributes to onnx's Identity operator and return the created node. | def convert_copy(node, **kwargs):
return create_basic_op_node('Identity', node, kwargs) | [
"def clone(self) -> Op:",
"def clone(self):\r\n cp = self.__class__(self.op, self.inputs, [output.clone() for output in self.outputs])\r\n cp.tag = copy(self.tag)\r\n return cp",
"def __call__(self):\n new_node = Node()\n new_node.op = self\n return new_node",
"def __... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's identity operator attributes to onnx's ConstantFill operator and return the created node. | def convert_identity(node, **kwargs):
return create_basic_op_node('ConstantFill', node, kwargs) | [
"def convert_copy(node, **kwargs):\n return create_basic_op_node('Identity', node, kwargs)",
"def _create_constantOfShape(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n tensor_type = onnx.TensorProto.FLOAT if isinstance(\n op.value, float) else onnx.TensorPr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's InstanceNorm operator attributes to onnx's InstanceNormalization operator based on the input node's attributes and return the created node. | def convert_instancenorm(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
eps = float(attrs.get("eps", 0.001))
node = onnx.helper.make_node(
'InstanceNormalization',
inputs=input_nodes,
outputs=[name],
name=name,
epsilon=eps)
return [node] | [
"def convert_instance_norm(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n gamma = g.get_node(op.input(\"Scale\")[0])\n beta = g.get_node(op.input(\"Bias\")[0])\n epsilon = op.attr(\"epsilon\")\n\n scale = center = True\n out = _op.nn.instance_norm(x, gamma, beta, axis=1, epsilon=epsilon, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's LeakyReLU operator attributes to onnx's Elu/LeakyRelu/PRelu operators based on the input node's attributes and return the created node. | def convert_leakyrelu(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
initializer = kwargs["initializer"]
act_type = attrs.get("act_type", "leaky")
alpha = float(attrs.get("slope", 0.25))
act_name = {"elu": "Elu", "leaky": "LeakyRelu", "prelu": "PRelu",
"selu":... | [
"def convert_leakyrelu(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n initializer = kwargs[\"initializer\"]\n act_type = attrs.get(\"act_type\", \"leaky\")\n alpha = float(attrs.get(\"slope\", 0.25))\n act_name = {\"elu\": \"Elu\", \"leaky\": \"LeakyRelu\", \"prelu\": \"PRel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's RNN operator attributes to onnx's RNN operator and return the created node. | def convert_RNN(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
nodes = []
# ============================== Attributes ==============================
mode = attrs['mode'].upper()
rnn_kwargs = {}
if mode != 'LSTM':
raise NotImplementedError(
"Only LSTM mo... | [
"def _create_cast(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n map_dict = {\n tensor.float32: TensorProto.FLOAT, # FLOAT to float32\n tensor.int32: TensorProto.INT32, # INT32 to int32\n }\n node.attribute.extend([\n helpe... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _rnn_param_concat operator attributes to onnx's Concat operator and return the created node. | def convert_rnn_param_concat(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("dim"))
# mxnet RNN node and ONNX RNN/LSTM/GRU nodes
# use different ways to store their parameters
# The conversion between these formats is broken into 2 steps
# The first s... | [
"def _create_concat(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axis', op.axis),\n ])\n return node",
"def create_helper_concat_node(inputs, output_name, axis=0):\n concat_node = onnx.helper... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's transpose operator attributes to onnx's Transpose operator and return the created node. | def convert_transpose(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
axes = attrs.get("axes", ())
if axes:
axes = tuple(map(int, re.findall(r'\d+', axes)))
transpose_node = onnx.helper.make_node(
"Transpose",
input_nodes,
[name],
... | [
"def _create_transpose(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('perm', op.perm),\n ])\n return node",
"def transpose(self):\n nodex.utils.ensurePluginsLoaded(self._plugins)\n n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's LRN operator attributes to onnx's LRN operator and return the created node. | def convert_lrn(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
alpha = float(attrs.get("alpha", 0.0001))
beta = float(attrs.get("beta", 0.75))
bias = float(attrs.get("knorm", 1.0))
size = int(attrs.get("nsize"))
lrn_node = onnx.helper.make_node(
"LRN",
inp... | [
"def _create_gemm(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('alpha', float(op.alpha)),\n helper.make_attribute('beta', float(op.beta)),\n helper.make_attribute('transA', op.transA),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's L2Normalization operator attributes to onnx's LpNormalization operator and return the created node. | def convert_l2normalization(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mode = attrs.get("mode", "instance")
if mode != "channel":
raise AttributeError("L2Normalization: ONNX currently supports channel mode only")
l2norm_node = onnx.helper.make_node(
"LpNormal... | [
"def _darknet_l2normalize(inputs, params, attrs, prefix):\n new_attrs = {}\n new_attrs[\"eps\"] = attrs.get(\"eps\", 0.0)\n new_attrs[\"axis\"] = [attrs.get(\"axis\", 1)]\n return get_relay_op(\"l2_normalize\")(*inputs, **new_attrs)",
"def convert(context, cm_node, inputs, outputs):\n norms = [... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Dropout operator attributes to onnx's Dropout operator and return the created node. | def convert_dropout(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
probability = float(attrs.get("p", 0.5))
probability = np.array(probability, dtype=np.float32)
training_mode = False
training_mode = np.array(training_mode, dtype=np.bool)
node_ratio = create_helper_tenso... | [
"def _create_dropout(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('ratio', op.ratio),\n ])\n return node",
"def create_dropout_layer(self):\n return tf.keras.layers.Dropout(rate=self.dropo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Flatten operator attributes to onnx's Flatten operator and return the created node. | def convert_flatten(node, **kwargs):
return create_basic_op_node('Flatten', node, kwargs) | [
"def _create_flatten(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axis', op.axis),\n ])\n return node",
"def convert_broadcast_to(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Clip operator attributes to onnx's Clip operator and return the created node. | def convert_clip(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
a_min = np.float(attrs.get('a_min', -np.inf))
a_max = np.float(attrs.get('a_max', np.inf))
clip_node = onnx.helper.make_node(
"Clip",
input_nodes,
[name],
name=name,
min=a_min,... | [
"def _create_clip(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n if op.min is not None:\n node.input.append(op.name + \":min\")\n else:\n node.input.append(\"\")\n if op.max is not None:\n node.input.append(op.name + \":max\")\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _mul_scalar operator attributes to onnx's Mul operator. Creates a new node for the input scalar value, adds it to the initializer and return multiple created nodes. | def convert_mul_scalar(node, **kwargs):
return scalar_op_helper(node, 'Mul', **kwargs) | [
"def convert_elemwise_mul(node, **kwargs):\n return create_basic_op_node('Mul', node, kwargs)",
"def get_mul_node(inputs, output, name):\n return onnx.helper.make_node(\"Mul\", inputs, [output], name)",
"def convert_broadcast_mul(node, **kwargs):\n return create_basic_op_node('Mul', node, kwargs)",
"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _minus_scalar operator attributes to onnx's Minus operator. Creates a new node for the input scalar value, adds it to the initializer and return multiple created nodes. | def convert_minus_scalar(node, **kwargs):
return scalar_op_helper(node, 'Sub', **kwargs) | [
"def convert_rminus_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Sub', **kwargs)",
"def convert_minimum(node, **kwargs):\n return create_basic_op_node('Min', node, kwargs)",
"def _create_clip(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n if op.min is ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _rminus_scalar operator attributes to onnx's Sub operator. Creates a new node for the input scalar value, adds it to the initializer and return multiple created nodes. | def convert_rminus_scalar(node, **kwargs):
return scalar_op_helper(node, 'Sub', **kwargs) | [
"def convert_minus_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Sub', **kwargs)",
"def convert_elementwise_sub(node, **kwargs):\n return create_basic_op_node('Sub', node, kwargs)",
"def covert_broadcast_sub(node, **kwargs):\n return create_basic_op_node('Sub', node, kwargs)",
"def __rsub_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _plus_scalar operator attributes to onnx's Add operator. Creates a new node for the input scalar value, adds it to the initializer and return multiple created nodes. | def convert_add_scalar(node, **kwargs):
return scalar_op_helper(node, 'Add', **kwargs) | [
"def convert_elementwise_add(node, **kwargs):\n return create_basic_op_node('Add', node, kwargs)",
"def convert_addn(node, **kwargs):\n return create_basic_op_node('Sum', node, kwargs)",
"def covert_broadcast_add(node, **kwargs):\n return create_basic_op_node('Add', node, kwargs)",
"def __add__(self,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _div_scalar operator attributes to onnx's Div operator. Creates a new node for the input scalar value, adds it to the initializer and return multiple created nodes. | def convert_div_scalar(node, **kwargs):
return scalar_op_helper(node, 'Div', **kwargs) | [
"def convert_elemwise_div(node, **kwargs):\n return create_basic_op_node('Div', node, kwargs)",
"def convert_rdiv_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Div', **kwargs)",
"def convert_broadcast_div(node, **kwargs):\n return create_basic_op_node('Div', node, kwargs)",
"def __div__(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _rdiv_scalar operator attributes to onnx's Div operator. Creates a new node for the input scalar value, adds it to the initializer and return multiple created nodes. | def convert_rdiv_scalar(node, **kwargs):
return scalar_op_helper(node, 'Div', **kwargs) | [
"def convert_div_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Div', **kwargs)",
"def convert_elemwise_div(node, **kwargs):\n return create_basic_op_node('Div', node, kwargs)",
"def convert_broadcast_div(node, **kwargs):\n return create_basic_op_node('Div', node, kwargs)",
"def __rdiv__(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _pow_scalar operator attributes to onnx's Pow operator. Creates a new node for the input scalar value, adds it to the initializer and return multiple created nodes. | def convert_pow_scalar(node, **kwargs):
return scalar_op_helper(node, 'Pow', **kwargs) | [
"def convert_power(node, **kwargs):\n return create_basic_op_node('Pow', node, kwargs)",
"def __pow__(self, power):\n return NXfield(value=pow(self.nxdata,power), name=self.nxname,\n attrs=self.attrs)",
"def convert_broadcast_power(node, **kwargs):\n return create_basic_op_nod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's argmax operator attributes to onnx's ArgMax operator and return the created node. | def convert_argmax(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis"))
keepdims = get_boolean_attribute_value(attrs, "keepdims")
node = onnx.helper.make_node(
'ArgMax',
inputs=input_nodes,
axis=axis,
keepdims=keepdims,
... | [
"def convert_max(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's argmin operator attributes to onnx's ArgMin operator and return the created node. | def convert_argmin(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis"))
keepdims = get_boolean_attribute_value(attrs, "keepdims")
node = onnx.helper.make_node(
'ArgMin',
inputs=input_nodes,
axis=axis,
keepdims=keepdims,
... | [
"def convert_min(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _maximum operator attributes to onnx's Max operator and return the created node. | def convert_maximum(node, **kwargs):
return create_basic_op_node('Max', node, kwargs) | [
"def convert_max(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _minimum operator attributes to onnx's Min operator and return the created node. | def convert_minimum(node, **kwargs):
return create_basic_op_node('Min', node, kwargs) | [
"def convert_min(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's min operator attributes to onnx's ReduceMin operator and return the created node. | def convert_min(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
if axes is not None:
node = onnx.he... | [
"def convert_min(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's max operator attributes to onnx's ReduceMax operator and return the created node. | def convert_max(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
if axes is not None:
node = onnx.he... | [
"def convert_max(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's mean operator attributes to onnx's ReduceMean operator and return the created node. | def convert_mean(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
if axes is not None:
node = onnx.h... | [
"def convert_mean(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepd... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's prod operator attributes to onnx's ReduceProd operator and return the created node. | def convert_prod(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
if axes is not None:
node = onnx.h... | [
"def convert_prod(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = str(attrs.get(\"axis\", 'None'))\n axes = convert_string_to_list(mx_axis) if mx_axis != 'None' else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepd... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's elemwise_add operator attributes to onnx's Add operator and return the created node. | def convert_elementwise_add(node, **kwargs):
return create_basic_op_node('Add', node, kwargs) | [
"def covert_broadcast_add(node, **kwargs):\n return create_basic_op_node('Add', node, kwargs)",
"def add(self, op):\n self.ops.append(op)\n op.func = self",
"def convert_addn(node, **kwargs):\n return create_basic_op_node('Sum', node, kwargs)",
"def _rule_operator_add(self, op):\n return se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_add operator attributes to onnx's Add operator and return the created node. | def covert_broadcast_add(node, **kwargs):
return create_basic_op_node('Add', node, kwargs) | [
"def convert_elementwise_add(node, **kwargs):\n return create_basic_op_node('Add', node, kwargs)",
"def _add_node(self, node_entry, idx):\n if node_entry[\"op\"].name not in relay_to_onnx_op_mapping:\n raise NotImplementedError(\n f\"Currently the operator '{node_entry['op'].na... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's elemwise_sub operator attributes to onnx's Sub operator and return the created node. | def convert_elementwise_sub(node, **kwargs):
return create_basic_op_node('Sub', node, kwargs) | [
"def covert_broadcast_sub(node, **kwargs):\n return create_basic_op_node('Sub', node, kwargs)",
"def _subop_adaptor(run):\n def inner(vm):\n subop = (vm.ir & vm.SUBOP_MASK) >> vm.SUBOP_SHIFT\n run(vm, subop)\n return inner",
"def __sub__(self, rhs):\n return TensorI... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_sub operator attributes to onnx's Sub operator and return the created node. | def covert_broadcast_sub(node, **kwargs):
return create_basic_op_node('Sub', node, kwargs) | [
"def convert_elementwise_sub(node, **kwargs):\n return create_basic_op_node('Sub', node, kwargs)",
"def _subop_adaptor(run):\n def inner(vm):\n subop = (vm.ir & vm.SUBOP_MASK) >> vm.SUBOP_SHIFT\n run(vm, subop)\n return inner",
"def test_mi_function_subgraph_attr(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's elemwise_mul operator attributes to onnx's Mul operator and return the created node. | def convert_elemwise_mul(node, **kwargs):
return create_basic_op_node('Mul', node, kwargs) | [
"def get_mul_node(inputs, output, name):\n return onnx.helper.make_node(\"Mul\", inputs, [output], name)",
"def convert_broadcast_mul(node, **kwargs):\n return create_basic_op_node('Mul', node, kwargs)",
"def convert_mul_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Mul', **kwargs)",
"def ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_mul operator attributes to onnx's Mul operator and return the created node. | def convert_broadcast_mul(node, **kwargs):
return create_basic_op_node('Mul', node, kwargs) | [
"def convert_elemwise_mul(node, **kwargs):\n return create_basic_op_node('Mul', node, kwargs)",
"def get_mul_node(inputs, output, name):\n return onnx.helper.make_node(\"Mul\", inputs, [output], name)",
"def convert_mul_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Mul', **kwargs)",
"def m... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's elemwise_div operator attributes to onnx's Div operator and return the created node. | def convert_elemwise_div(node, **kwargs):
return create_basic_op_node('Div', node, kwargs) | [
"def convert_broadcast_div(node, **kwargs):\n return create_basic_op_node('Div', node, kwargs)",
"def convert_div_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Div', **kwargs)",
"def __div__(self, other):\n if isinstance(other, NXfield):\n return NXfield(value=self.nxdata/othe... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_div operator attributes to onnx's Div operator and return the created node. | def convert_broadcast_div(node, **kwargs):
return create_basic_op_node('Div', node, kwargs) | [
"def convert_elemwise_div(node, **kwargs):\n return create_basic_op_node('Div', node, kwargs)",
"def convert_div_scalar(node, **kwargs):\n return scalar_op_helper(node, 'Div', **kwargs)",
"def __div__(self, other):\n if isinstance(other, NXfield):\n return NXfield(value=self.nxdata/other... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's negative operator attributes to onnx's Neg operator and return the created node. | def convert_negative(node, **kwargs):
return create_basic_op_node('Neg', node, kwargs) | [
"def __neg__(self):\n return UnaryMinus(self)",
"def __neg__(self):\n return TensorIndex(_poly_op(lib.PLAIDML_INT_OP_NEG, self))",
"def negative(x):\n return NegativeOp(x)",
"def convert_logical_not(node, **kwargs):\n return create_basic_op_node('Not', node, kwargs)",
"def get_negative(s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's abs operator attributes to onnx's Abs operator and return the created node. | def convert_abs(node, **kwargs):
return create_basic_op_node('Abs', node, kwargs) | [
"def absolute(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Abs\", [node])",
"def abs(self) -> LinearOperator:\n return self.__class__(self._diag.abs())",
"def __abs__(self):\n out = self.copy()\n out.addFunction(Query.Function.Abs)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's add_n operator attributes to onnx's Sum operator and return the created node. | def convert_addn(node, **kwargs):
return create_basic_op_node('Sum', node, kwargs) | [
"def convert_elementwise_add(node, **kwargs):\n return create_basic_op_node('Add', node, kwargs)",
"def covert_broadcast_add(node, **kwargs):\n return create_basic_op_node('Add', node, kwargs)",
"def convert_sum(node, **kwargs):\n from onnx.helper import make_node\n\n name, input_nodes, attrs = get_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's ceil operator attributes to onnx's Ceil operator and return the created node. | def convert_ceil(node, **kwargs):
return create_basic_op_node('Ceil', node, kwargs) | [
"def ceiling(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Ceiling\", [node])",
"def ceiling(self) -> Payload:\n ceiling = self.resources.ceiling\n return Payload(brams=ceiling.brams, sliceLUTs=ceiling.sliceLUTs, processors=ceiling.processors)"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's floor operator attributes to onnx's Floor operator and return the created node. | def convert_floor(node, **kwargs):
return create_basic_op_node('Floor', node, kwargs) | [
"def floor(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Floor\", [node])",
"def floor(self):\n return self.container['floor']",
"def floor(self):\n return self._unop(\"floor\", rtype=\"int\")",
"def floor_mod(\n left_node: NodeInput,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Reshape operator attributes to onnx's Reshape operator. Converts output shape attribute to output shape tensor and return multiple created nodes. | def convert_reshape(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
output_shape_list = convert_string_to_list(attrs["shape"])
initializer = kwargs["initializer"]
output_shape_np = np.array(output_shape_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[outpu... | [
"def create_helper_reshape_node(input_name, output_name, shape, kwargs):\n shape_tensor_node, = create_helper_tensor_node(\n np.asarray(shape, dtype=np.int64), output_name + \"__shape\", kwargs\n )\n reshape_node = onnx.helper.make_node(\n \"Reshape\",\n inputs=[input_name, shape_tenso... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's slice_axis operator attributes to onnx's Slice operator and return the created node. | def convert_slice_axis(node, **kwargs):
name, input_nodes, input_shapes, attrs = get_inputs(node, kwargs, with_shapes=True)
axes = int(attrs.get("axis"))
starts = int(attrs.get("begin"))
ends = attrs.get("end", None)
if not ends or ends == 'None':
# ONNX doesn't support None for ends. Since... | [
"def _create_slice(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n for attr in ['starts', 'ends', 'axes', 'steps']:\n node.input.append(op.name + \":\" + attr)\n return node",
"def _fix_slice(self, inputs, new_attr):\n begin = new_attr.get('begin')... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's SliceChannel operator attributes to onnx's Squeeze or Split operator based on squeeze_axis attribute and return the created node. | def convert_slice_channel(node, **kwargs):
name, input_nodes, input_shapes, attrs = get_inputs(node, kwargs, with_shapes=True)
num_outputs = int(attrs.get("num_outputs"))
axis = int(attrs.get("axis", 1))
squeeze_axis = int(attrs.get("squeeze_axis", 0))
if squeeze_axis == 1 and num_outputs == 1:
... | [
"def _create_squeeze(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axes', list(op.axis)),\n ])\n return node",
"def convert_slice_channel(node, **kwargs):\n from onnx.helper import make_node\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's expand_dims operator attributes to onnx's Unsqueeze operator and return the created node. | def convert_expand_dims(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis"))
node = onnx.helper.make_node(
"Unsqueeze",
input_nodes,
[name],
axes=[axis],
name=name,
)
return [node] | [
"def _create_squeeze(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axes', list(op.axis)),\n ])\n return node",
"def _create_squeeze(cls, onnx_node, inputs, opset_version):\n axes = onnx_no... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's log operator attributes to onnx's Log operator and return the created node. | def convert_log(node, **kwargs):
return create_basic_op_node('Log', node, kwargs) | [
"def create_log(attribute=None):\n if attribute:\n return XLog(attribute)\n return XLog(XAttributeMap())",
"def log(self: Float[LinearOperator, \"*batch M N\"]) -> Float[LinearOperator, \"*batch M N\"]:\n return self.__class__(self._diag.log())",
"def log(self: Float[LinearOperat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's reciprocal operator attributes to onnx's Reciprocal operator and return the created node. | def convert_reciprocal(node, **kwargs):
return create_basic_op_node('Reciprocal', node, kwargs) | [
"def __call__(self):\n new_node = Node()\n new_node.op = self\n return new_node",
"def __call__(self):\r\n new_node = Node()\r\n new_node.op = self\r\n return new_node",
"def convert_reciprocal(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n dtype = infer_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _power operator attributes to onnx's Pow operator and return the created node. | def convert_power(node, **kwargs):
return create_basic_op_node('Pow', node, kwargs) | [
"def __pow__(self, power):\n return NXfield(value=pow(self.nxdata,power), name=self.nxname,\n attrs=self.attrs)",
"def convert_broadcast_power(node, **kwargs):\n return create_basic_op_node('Pow', node, kwargs)",
"def pow_expression(cls, tree):\n if len(tree.children) == 1... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's _power operator attributes to onnx's Pow operator and return the created node. | def convert_broadcast_power(node, **kwargs):
return create_basic_op_node('Pow', node, kwargs) | [
"def convert_power(node, **kwargs):\n return create_basic_op_node('Pow', node, kwargs)",
"def __pow__(self, power):\n return NXfield(value=pow(self.nxdata,power), name=self.nxname,\n attrs=self.attrs)",
"def pow_expression(cls, tree):\n if len(tree.children) == 1:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's sqrt operator attributes to onnx's Sqrt operator and return the created node. | def convert_sqrt(node, **kwargs):
return create_basic_op_node('Sqrt', node, kwargs) | [
"def sqrt(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"Sqrt\", [node])",
"def __call__(self, node_A):\r\n new_node = Op.__call__(self)\r\n new_node.inputs = [node_A]\r\n new_node.name = \"Sqrt(%s)\" % (node_A.name)\r\n return new... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's depth_to_space operator attributes to onnx's DepthToSpace operator and return the created node. | def convert_depthtospace(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
blksize = int(attrs.get("block_size", 0))
node = onnx.helper.make_node(
"DepthToSpace",
input_nodes,
[name],
blocksize=blksize,
name=name,
)
return [node] | [
"def convert_spacetodepth(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n blksize = int(attrs.get(\"block_size\", 0))\n\n node = onnx.helper.make_node(\n \"SpaceToDepth\",\n input_nodes,\n [name],\n blocksize=blksize,\n name=name,\n )\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's space_to_depth operator attributes to onnx's SpaceToDepth operator and return the created node. | def convert_spacetodepth(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
blksize = int(attrs.get("block_size", 0))
node = onnx.helper.make_node(
"SpaceToDepth",
input_nodes,
[name],
blocksize=blksize,
name=name,
)
return [node] | [
"def convert_depthtospace(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n blksize = int(attrs.get(\"block_size\", 0))\n\n node = onnx.helper.make_node(\n \"DepthToSpace\",\n input_nodes,\n [name],\n blocksize=blksize,\n name=name,\n )\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's sum operator attributes to onnx's ReduceSum operator and return the created node. | def convert_sum(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
if axes:
node = onnx.helper.make_no... | [
"def convert_sum(node, **kwargs):\n from onnx.helper import make_node\n\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = attrs.get(\"axis\", None)\n axes = convert_string_to_list(str(mx_axis)) if mx_axis not in [None, 'None'] else None\n\n keepdims = get_boolean_attribute_value(att... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's shape_array operator attributes to onnx's Shape operator and return the created node. | def convert_shape(node, **kwargs):
return create_basic_op_node('Shape', node, kwargs) | [
"def _shape_calculator_transformer(operator):\n _common_shape_calculator_t(operator)",
"def create_helper_shape_node(input_name, output_name):\n shape_node = onnx.helper.make_node(\n \"Shape\",\n inputs=[input_name],\n outputs=[output_name],\n name=output_name,\n )\n return... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_lesser operator attributes to onnx's Less operator and return the created node. | def convert_broadcast_lesser(node, **kwargs):
return create_basic_op_node('Less', node, kwargs) | [
"def convert_broadcast_greater(node, **kwargs):\n return create_basic_op_node('Greater', node, kwargs)",
"def test_less_than_bcast(self):\n utils.compare_tracing_methods(\n SimpleCompareOpsModule(\"lessThan\"),\n torch.randn(3, 4, 5),\n torch.randn(4, 5),\n fu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_greater operator attributes to onnx's Greater operator and return the created node. | def convert_broadcast_greater(node, **kwargs):
return create_basic_op_node('Greater', node, kwargs) | [
"def greater(\n left_node: NodeInput,\n right_node: NodeInput,\n auto_broadcast: str = \"NUMPY\",\n name: Optional[str] = None,\n) -> Node:\n return _get_node_factory_opset1().create(\n \"Greater\",\n [left_node, right_node],\n {\"auto_broadcast\": auto_broadcast.upper()},\n )... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_equal operator attributes to onnx's Equal operator and return the created node. | def convert_broadcast_equal(node, **kwargs):
return create_basic_op_node('Equal', node, kwargs) | [
"def greater_equal(\n left_node: NodeInput,\n right_node: NodeInput,\n auto_broadcast: str = \"NUMPY\",\n name: Optional[str] = None,\n) -> Node:\n return _get_node_factory_opset1().create(\n \"GreaterEqual\",\n [left_node, right_node],\n {\"auto_broadcast\": auto_broadcast.upper... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast logical or operator attributes to onnx's Or operator and return the created node. | def convert_broadcast_logical_or(node, **kwargs):
return create_basic_op_node('Or', node, kwargs) | [
"def logical_or(\n left_node: NodeInput,\n right_node: NodeInput,\n auto_broadcast: str = \"NUMPY\",\n name: Optional[str] = None,\n) -> Node:\n return _get_node_factory_opset1().create(\n \"LogicalOr\",\n [left_node, right_node],\n {\"auto_broadcast\": auto_broadcast.upper()},\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast logical xor operator attributes to onnx's Xor operator and return the created node. | def convert_broadcast_logical_xor(node, **kwargs):
return create_basic_op_node('Xor', node, kwargs) | [
"def convert_broadcast_logical_or(node, **kwargs):\n return create_basic_op_node('Or', node, kwargs)",
"def logical_xor(\n left_node: NodeInput,\n right_node: NodeInput,\n auto_broadcast: str = \"NUMPY\",\n name: Optional[str] = None,\n) -> Node:\n return _get_node_factory_opset1().create(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's logical not operator attributes to onnx's Not operator and return the created node. | def convert_logical_not(node, **kwargs):
return create_basic_op_node('Not', node, kwargs) | [
"def logical_not(node: NodeInput, name: Optional[str] = None) -> Node:\n return _get_node_factory_opset1().create(\"LogicalNot\", [node])",
"def logical_not(data):\n return _make.logical_not(data)",
"def logical_not(x, name=None):\n result = _op_def_lib.apply_op(\"LogicalNot\", x=x, name=name)\n return ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's size_array operator attributes to onnx's Size operator and return the created node. | def convert_size(node, **kwargs):
return create_basic_op_node('Size', node, kwargs) | [
"def convert_size(g, op, block):\n\n input_x = g.get_node(op.input(\"Input\")[0])\n out = _op.ndarray_size(input_x, dtype=\"int64\")\n out = _op.expand_dims(out, axis=0)\n g.add_node(op.output(\"Out\")[0], out)",
"def SizeExpression(self) -> CodeExpression:",
"def sizeof(self, **contextkw):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's log_softmax operator attributes to onnx's LogSoftMax operator and return the created node. | def convert_logsoftmax(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to int
axis = int(attrs.get("axis", -1))
temp = attrs.get("temperature", 'None')
if temp != 'None':
raise AttributeError("LogSoftMax: ONNX supports only temperature=None")
node = on... | [
"def convert_logsoftmax(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n # Converting to int\n axis = int(attrs.get(\"axis\", -1))\n temp = attrs.get('temperature', 'None')\n use_length = attrs.get('use_length', 'False')\n\n if temp != 'None':\n raise AttributeErro... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's norm operator attributes to onnx's ReduceL1 and ReduceL2 operators and return the created node. | def convert_norm(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
ord = int(attrs.get("ord", 2))
onnx_op_name = "Red... | [
"def convert_norm(node, **kwargs):\n from onnx.helper import make_node\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = attrs.get(\"axis\", None)\n axes = convert_string_to_list(str(mx_axis)) if mx_axis else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdims\")\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's multinomial operator attributes to onnx's Multinomial operator and return the created node. | def convert_multinomial(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype(attrs.get("dtype", 'int32'))]
sample_size = convert_string_to_list(attrs.get("shape", '1'))
if len(sample_size) < 2:
sample_size = sample_size[-1]
... | [
"def get_mul_node(inputs, output, name):\n return onnx.helper.make_node(\"Mul\", inputs, [output], name)",
"def multiclass_nms_op(operator, block):\n inputs, attrs, outputs = op_io_info(operator)\n result_name = outputs['Out'][0]\n background = attrs['background_label']\n normalized = attrs['normal... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's random_uniform operator attributes to onnx's RandomUniform operator and return the created node. | def convert_random_uniform(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
low = float(attrs.get("low", 0))
high = float(attrs.get("high", 1.0))
shape = convert_string_to_list(attrs.get('shape', '[]'))
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.d... | [
"def Random_uniform(*args):\n return _yarp.Random_uniform(*args)",
"def uniform(*args):\n return _yarp.Random_uniform(*args)",
"def glorot_uniform(seed=None):\n return lambda shape, dtype, batch_ndims=0: _initialize( # pylint: disable=g-long-lambda\n shape, dtype, batch_ndims,\n scale=1., mo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's random_normal operator attributes to onnx's RandomNormal operator and return the created node. | def convert_random_normal(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
mean = float(attrs.get("loc", 0))
scale = float(attrs.get("scale", 1.0))
shape = convert_string_to_list(attrs.get('shape', '[]'))
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np... | [
"def Random_normal(*args):\n return _yarp.Random_normal(*args)",
"def convert_random_uniform(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n # Converting to float32\n low = float(attrs.get(\"low\", 0))\n high = float(attrs.get(\"high\", 1.0))\n shape = convert_string_to_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's ROIPooling operator attributes to onnx's MaxRoiPool operator and return the created node. | def convert_roipooling(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
pooled_shape = convert_string_to_list(attrs.get('pooled_size'))
scale = float(attrs.get("spatial_scale"))
node = onnx.helper.make_node(
'MaxRoiPool',
input_nodes,
[name],
pooled_... | [
"def convert_pooling(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n kernel = eval(attrs[\"kernel\"])\n pool_type = attrs[\"pool_type\"] if attrs.get(\"pool_type\") else \"max\"\n stride = eval(attrs[\"stride\"]) if attrs.get(\"stride\") else (1, 1)\n global_pool = get_bool... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Tile operator attributes to onnx's Tile operator and return the created node. | def convert_tile(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
reps_list = convert_string_to_list(attrs["reps"])
initializer = kwargs["initializer"]
reps_shape_np = np.array(reps_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[reps_shape_np.dtype]
di... | [
"def createGridWarpNodeMI():\n return gy()",
"def phy(self):\n# refer back to the physical node, to access attributes such as name\n return OverlayNode(self.anm, \"phy\", self.node_id)",
"def new(topo):\n\t\treturn Tile(topo)",
"def _create_cast(cls, op, op_t):\n node = cls._common_singa_tens... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's broadcast_to operator attributes to onnx's Expand operator and return the created node. | def convert_broadcast_to(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
shape_list = convert_string_to_list(attrs["shape"])
initializer = kwargs["initializer"]
output_shape_np = np.array(shape_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[output_shape_n... | [
"def convert_broadcast_power(node, **kwargs):\n return create_basic_op_node('Pow', node, kwargs)",
"def convert_broadcast_mul(node, **kwargs):\n return create_basic_op_node('Mul', node, kwargs)",
"def create_helper_expand_node(input_name, output_name, expand_shape):\n expand_node = onnx.helper.make_nod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's topk operator attributes to onnx's TopK operator and return the created node. | def convert_topk(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get('axis', '-1'))
k = int(attrs.get('k', '1'))
ret_type = attrs.get('ret_typ')
dtype = attrs.get('dtype')
outputs = [name + '_output0']
if ret_type and ret_type == 'both':
if dty... | [
"def convert_topk(g, op, block):\n\n data = g.get_node(op.input(\"X\")[0])\n if op.input(\"K\"):\n k = g.get_node(op.input(\"K\")[0])\n else:\n k = op.attr(\"k\")\n\n largest = True\n axis = -1\n if op.has_attr(\"axis\"):\n axis = op.attr(\"axis\")\n if op.has_attr(\"larges... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Map MXNet's Take operator attributes to onnx's Gather operator. | def convert_take(node, **kwargs):
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get('axis', 0))
node = onnx.helper.make_node(
"Gather",
input_nodes,
[name],
axis=axis,
name=name,
)
return [node] | [
"def convert_gather(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n index = g.get_node(op.input(\"Index\")[0])\n axis = op.attr(\"axis\")\n out = _op.take(x, index, axis)\n g.add_node(op.output(\"Out\")[0], out)",
"def _create_gather(cls, onnx_node, inputs, opset_version):\n axis = o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
处理 url_queue中的 url,筛选掉已经浏览过或超过设定level的url 并将符合条件的 url,放入 data_queue | def check_url(url_queue, data_queue, level):
storage = Storage()
while True:
url, curr_level = url_queue.get()
if url is _sentinel:
break
if url not in storage and curr_level <= level:
storage.add(url)
data_queue.put((url, curr_level))
print "check... | [
"def handle(url_queue, data_queue, level, thread_id):\n try:\n while True:\n url, curr_level = data_queue.get(timeout=5)\n tool = URLTool(url)\n page = tool.open()\n print \"Thread\" + thread_id, url, curr_level\n\n if hasattr(sys, \"exc_clear\"):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
处理 data_queue 的函数, 可设定多个线程处理, 主要功能是打开 url,确定页面是否能够到达 如果能够到达此页面, 找出所有 m.sohu.com 域名下的页面,放入 url_queue thread_id 是自己设置的数字字符串,仅为了查看结果,无实义 | def handle(url_queue, data_queue, level, thread_id):
try:
while True:
url, curr_level = data_queue.get(timeout=5)
tool = URLTool(url)
page = tool.open()
print "Thread" + thread_id, url, curr_level
if hasattr(sys, "exc_clear"):
sys.... | [
"def get_page_queue(url, queue):\n queue.put(urlopen(url).read())\n return None",
"def __getThreads( self ):\r\n try:\r\n threads = [each.findParent('tr') for each in self.soup.findAll('td','tcr')]\r\n except:\r\n log.exception(self.log_msg('No thread foun... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
raise from_none(ValueError('a')) == raise ValueError('a') from None | def from_none(exc):
exc.__cause__ = None
exc.__suppress_context__ = True
return exc | [
"def ValueErrorOnNull(result, error):\n if result is None:\n raise ValueError(error)\n\n return result",
"def test_invalid_argument_type(self):\n t = TruthTable('A or B')\n\n with self.assertRaises(InvalidArgumentTypeError):\n t.equivalent_to(float())\n\n with self.assertRaise... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Calculates the average price we would pay / receive per unit of `symbol` if we wanted to trade `quantity` of that `symbol`, based on its order book | def getOrderBookPrice(exchange, symbol, side, quantity, order_book=None):
# TODO test it
# print("obap1")
order_book_side = order_book['asks'] \
if side == exchange.SIDE_SELL else order_book['bids']
quantity = Decimal(quantity)
i, orders, price = 0, [], Decimal(0)
accounted_for_quantity = Decimal(0)
... | [
"def get_mean_volume(symbol):\n df = pd.read_csv(\"data/{}.csv\".format(symbol)) # read in data\n # Quiz: Compute and return the mean volume for this stock\n return df['Volume'].mean()",
"def mid_market_price(orders: pandas.DataFrame):\n return numpy.mean((best_bid_price(orders), best_ask_price(order... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Inserts multiple new asks in the order book (assumes that the order book AND the new_asks list are sorted) | def insertAsks(previous_asks, received_asks):
new_asks = []
if len(received_asks) < 1:
return previous_asks
if len(previous_asks) < 1:
return received_asks
# print("Prev")
# pprint(previous_asks)
# print("Recv")
# pprint(received_asks)
# Uses the merge-sort idea of popping the first elemen... | [
"def add_books(cursor, order, old_order):\n books = str.split(old_order['books'], \"&&\") # a list of all the book IDs\n for book_id in books:\n cursor.execute(\"SELECT * FROM `books` WHERE `key`=%s\" % book_id)\n old_books = cursor.fetchall()\n assert len(old_books) == 1 # ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |