repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
micropython/micropython
|
ports/stm32/boards/make-pins.py
|
AlternateFunction.print
|
def print(self):
"""Prints the C representation of this AF."""
cond_var = None
if self.supported:
cond_var = conditional_var('{}{}'.format(self.func, self.fn_num))
print_conditional_if(cond_var)
print(' AF', end='')
else:
print(' //', end='')
fn_num = self.fn_num
if fn_num is None:
fn_num = 0
print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'.format(self.idx,
self.func, fn_num, self.pin_type, self.ptr(), self.af_str))
print_conditional_endif(cond_var)
|
python
|
def print(self):
"""Prints the C representation of this AF."""
cond_var = None
if self.supported:
cond_var = conditional_var('{}{}'.format(self.func, self.fn_num))
print_conditional_if(cond_var)
print(' AF', end='')
else:
print(' //', end='')
fn_num = self.fn_num
if fn_num is None:
fn_num = 0
print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'.format(self.idx,
self.func, fn_num, self.pin_type, self.ptr(), self.af_str))
print_conditional_endif(cond_var)
|
[
"def",
"print",
"(",
"self",
")",
":",
"cond_var",
"=",
"None",
"if",
"self",
".",
"supported",
":",
"cond_var",
"=",
"conditional_var",
"(",
"'{}{}'",
".",
"format",
"(",
"self",
".",
"func",
",",
"self",
".",
"fn_num",
")",
")",
"print_conditional_if",
"(",
"cond_var",
")",
"print",
"(",
"' AF'",
",",
"end",
"=",
"''",
")",
"else",
":",
"print",
"(",
"' //'",
",",
"end",
"=",
"''",
")",
"fn_num",
"=",
"self",
".",
"fn_num",
"if",
"fn_num",
"is",
"None",
":",
"fn_num",
"=",
"0",
"print",
"(",
"'({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'",
".",
"format",
"(",
"self",
".",
"idx",
",",
"self",
".",
"func",
",",
"fn_num",
",",
"self",
".",
"pin_type",
",",
"self",
".",
"ptr",
"(",
")",
",",
"self",
".",
"af_str",
")",
")",
"print_conditional_endif",
"(",
"cond_var",
")"
] |
Prints the C representation of this AF.
|
[
"Prints",
"the",
"C",
"representation",
"of",
"this",
"AF",
"."
] |
8031b7a25c21fb864fe9dd1fa40740030be66c11
|
https://github.com/micropython/micropython/blob/8031b7a25c21fb864fe9dd1fa40740030be66c11/ports/stm32/boards/make-pins.py#L121-L135
|
train
|
micropython/micropython
|
ports/cc3200/boards/make-pins.py
|
parse_port_pin
|
def parse_port_pin(name_str):
"""Parses a string and returns a (port, gpio_bit) tuple."""
if len(name_str) < 3:
raise ValueError("Expecting pin name to be at least 3 characters")
if name_str[:2] != 'GP':
raise ValueError("Expecting pin name to start with GP")
if not name_str[2:].isdigit():
raise ValueError("Expecting numeric GPIO number")
port = int(int(name_str[2:]) / 8)
gpio_bit = 1 << int(int(name_str[2:]) % 8)
return (port, gpio_bit)
|
python
|
def parse_port_pin(name_str):
"""Parses a string and returns a (port, gpio_bit) tuple."""
if len(name_str) < 3:
raise ValueError("Expecting pin name to be at least 3 characters")
if name_str[:2] != 'GP':
raise ValueError("Expecting pin name to start with GP")
if not name_str[2:].isdigit():
raise ValueError("Expecting numeric GPIO number")
port = int(int(name_str[2:]) / 8)
gpio_bit = 1 << int(int(name_str[2:]) % 8)
return (port, gpio_bit)
|
[
"def",
"parse_port_pin",
"(",
"name_str",
")",
":",
"if",
"len",
"(",
"name_str",
")",
"<",
"3",
":",
"raise",
"ValueError",
"(",
"\"Expecting pin name to be at least 3 characters\"",
")",
"if",
"name_str",
"[",
":",
"2",
"]",
"!=",
"'GP'",
":",
"raise",
"ValueError",
"(",
"\"Expecting pin name to start with GP\"",
")",
"if",
"not",
"name_str",
"[",
"2",
":",
"]",
".",
"isdigit",
"(",
")",
":",
"raise",
"ValueError",
"(",
"\"Expecting numeric GPIO number\"",
")",
"port",
"=",
"int",
"(",
"int",
"(",
"name_str",
"[",
"2",
":",
"]",
")",
"/",
"8",
")",
"gpio_bit",
"=",
"1",
"<<",
"int",
"(",
"int",
"(",
"name_str",
"[",
"2",
":",
"]",
")",
"%",
"8",
")",
"return",
"(",
"port",
",",
"gpio_bit",
")"
] |
Parses a string and returns a (port, gpio_bit) tuple.
|
[
"Parses",
"a",
"string",
"and",
"returns",
"a",
"(",
"port",
"gpio_bit",
")",
"tuple",
"."
] |
8031b7a25c21fb864fe9dd1fa40740030be66c11
|
https://github.com/micropython/micropython/blob/8031b7a25c21fb864fe9dd1fa40740030be66c11/ports/cc3200/boards/make-pins.py#L20-L30
|
train
|
onnx/onnx
|
onnx/backend/base.py
|
Backend.run_node
|
def run_node(cls,
node, # type: NodeProto
inputs, # type: Any
device='CPU', # type: Text
outputs_info=None, # type: Optional[Sequence[Tuple[numpy.dtype, Tuple[int, ...]]]]
**kwargs # type: Dict[Text, Any]
): # type: (...) -> Optional[Tuple[Any, ...]]
'''Simple run one operator and return the results.
Args:
outputs_info: a list of tuples, which contains the element type and
shape of each output. First element of the tuple is the dtype, and
the second element is the shape. More use case can be found in
https://github.com/onnx/onnx/blob/master/onnx/backend/test/runner/__init__.py
'''
# TODO Remove Optional from return type
if 'opset_version' in kwargs:
special_context = c_checker.CheckerContext()
special_context.ir_version = IR_VERSION
special_context.opset_imports = {'': kwargs['opset_version']} # type: ignore
onnx.checker.check_node(node, special_context)
else:
onnx.checker.check_node(node)
return None
|
python
|
def run_node(cls,
node, # type: NodeProto
inputs, # type: Any
device='CPU', # type: Text
outputs_info=None, # type: Optional[Sequence[Tuple[numpy.dtype, Tuple[int, ...]]]]
**kwargs # type: Dict[Text, Any]
): # type: (...) -> Optional[Tuple[Any, ...]]
'''Simple run one operator and return the results.
Args:
outputs_info: a list of tuples, which contains the element type and
shape of each output. First element of the tuple is the dtype, and
the second element is the shape. More use case can be found in
https://github.com/onnx/onnx/blob/master/onnx/backend/test/runner/__init__.py
'''
# TODO Remove Optional from return type
if 'opset_version' in kwargs:
special_context = c_checker.CheckerContext()
special_context.ir_version = IR_VERSION
special_context.opset_imports = {'': kwargs['opset_version']} # type: ignore
onnx.checker.check_node(node, special_context)
else:
onnx.checker.check_node(node)
return None
|
[
"def",
"run_node",
"(",
"cls",
",",
"node",
",",
"# type: NodeProto",
"inputs",
",",
"# type: Any",
"device",
"=",
"'CPU'",
",",
"# type: Text",
"outputs_info",
"=",
"None",
",",
"# type: Optional[Sequence[Tuple[numpy.dtype, Tuple[int, ...]]]]",
"*",
"*",
"kwargs",
"# type: Dict[Text, Any]",
")",
":",
"# type: (...) -> Optional[Tuple[Any, ...]]",
"# TODO Remove Optional from return type",
"if",
"'opset_version'",
"in",
"kwargs",
":",
"special_context",
"=",
"c_checker",
".",
"CheckerContext",
"(",
")",
"special_context",
".",
"ir_version",
"=",
"IR_VERSION",
"special_context",
".",
"opset_imports",
"=",
"{",
"''",
":",
"kwargs",
"[",
"'opset_version'",
"]",
"}",
"# type: ignore",
"onnx",
".",
"checker",
".",
"check_node",
"(",
"node",
",",
"special_context",
")",
"else",
":",
"onnx",
".",
"checker",
".",
"check_node",
"(",
"node",
")",
"return",
"None"
] |
Simple run one operator and return the results.
Args:
outputs_info: a list of tuples, which contains the element type and
shape of each output. First element of the tuple is the dtype, and
the second element is the shape. More use case can be found in
https://github.com/onnx/onnx/blob/master/onnx/backend/test/runner/__init__.py
|
[
"Simple",
"run",
"one",
"operator",
"and",
"return",
"the",
"results",
".",
"Args",
":",
"outputs_info",
":",
"a",
"list",
"of",
"tuples",
"which",
"contains",
"the",
"element",
"type",
"and",
"shape",
"of",
"each",
"output",
".",
"First",
"element",
"of",
"the",
"tuple",
"is",
"the",
"dtype",
"and",
"the",
"second",
"element",
"is",
"the",
"shape",
".",
"More",
"use",
"case",
"can",
"be",
"found",
"in",
"https",
":",
"//",
"github",
".",
"com",
"/",
"onnx",
"/",
"onnx",
"/",
"blob",
"/",
"master",
"/",
"onnx",
"/",
"backend",
"/",
"test",
"/",
"runner",
"/",
"__init__",
".",
"py"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/backend/base.py#L89-L111
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
load_external_data_for_tensor
|
def load_external_data_for_tensor(tensor, base_dir): # type: (TensorProto, Text) -> None
"""
Load data from an external file for tensor.
@params
tensor: a TensorProto object.
base_dir: directory that contains the external data.
"""
if tensor.HasField("raw_data"): # already loaded
return
info = ExternalDataInfo(tensor)
file_location = _sanitize_path(info.location)
external_data_file_path = os.path.join(base_dir, file_location)
with open(external_data_file_path, 'rb') as data_file:
if info.offset:
data_file.seek(info.offset)
if info.length:
tensor.raw_data = data_file.read(info.length)
else:
tensor.raw_data = data_file.read()
|
python
|
def load_external_data_for_tensor(tensor, base_dir): # type: (TensorProto, Text) -> None
"""
Load data from an external file for tensor.
@params
tensor: a TensorProto object.
base_dir: directory that contains the external data.
"""
if tensor.HasField("raw_data"): # already loaded
return
info = ExternalDataInfo(tensor)
file_location = _sanitize_path(info.location)
external_data_file_path = os.path.join(base_dir, file_location)
with open(external_data_file_path, 'rb') as data_file:
if info.offset:
data_file.seek(info.offset)
if info.length:
tensor.raw_data = data_file.read(info.length)
else:
tensor.raw_data = data_file.read()
|
[
"def",
"load_external_data_for_tensor",
"(",
"tensor",
",",
"base_dir",
")",
":",
"# type: (TensorProto, Text) -> None",
"if",
"tensor",
".",
"HasField",
"(",
"\"raw_data\"",
")",
":",
"# already loaded",
"return",
"info",
"=",
"ExternalDataInfo",
"(",
"tensor",
")",
"file_location",
"=",
"_sanitize_path",
"(",
"info",
".",
"location",
")",
"external_data_file_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"base_dir",
",",
"file_location",
")",
"with",
"open",
"(",
"external_data_file_path",
",",
"'rb'",
")",
"as",
"data_file",
":",
"if",
"info",
".",
"offset",
":",
"data_file",
".",
"seek",
"(",
"info",
".",
"offset",
")",
"if",
"info",
".",
"length",
":",
"tensor",
".",
"raw_data",
"=",
"data_file",
".",
"read",
"(",
"info",
".",
"length",
")",
"else",
":",
"tensor",
".",
"raw_data",
"=",
"data_file",
".",
"read",
"(",
")"
] |
Load data from an external file for tensor.
@params
tensor: a TensorProto object.
base_dir: directory that contains the external data.
|
[
"Load",
"data",
"from",
"an",
"external",
"file",
"for",
"tensor",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L32-L54
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
load_external_data_for_model
|
def load_external_data_for_model(model, base_dir): # type: (ModelProto, Text) -> None
"""
Loads external tensors into model
@params
model: ModelProto to load external data to
base_dir: directory that contains external data
"""
for tensor in _get_all_tensors(model):
if uses_external_data(tensor):
load_external_data_for_tensor(tensor, base_dir)
|
python
|
def load_external_data_for_model(model, base_dir): # type: (ModelProto, Text) -> None
"""
Loads external tensors into model
@params
model: ModelProto to load external data to
base_dir: directory that contains external data
"""
for tensor in _get_all_tensors(model):
if uses_external_data(tensor):
load_external_data_for_tensor(tensor, base_dir)
|
[
"def",
"load_external_data_for_model",
"(",
"model",
",",
"base_dir",
")",
":",
"# type: (ModelProto, Text) -> None",
"for",
"tensor",
"in",
"_get_all_tensors",
"(",
"model",
")",
":",
"if",
"uses_external_data",
"(",
"tensor",
")",
":",
"load_external_data_for_tensor",
"(",
"tensor",
",",
"base_dir",
")"
] |
Loads external tensors into model
@params
model: ModelProto to load external data to
base_dir: directory that contains external data
|
[
"Loads",
"external",
"tensors",
"into",
"model"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L57-L67
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
convert_model_to_external_data
|
def convert_model_to_external_data(model, all_tensors_to_one_file=True, location=None):
# type: (ModelProto, bool, Optional[Text]) -> None
"""
call to set all tensors as external data. save_model saves all the tensors data as external data after calling this function.
@params
model: ModelProto to be converted.
all_tensors_to_one_file: If true, save all tensors to one external file specified by location.
If false, save each tensor to a file named with the tensor name.
location: specify the external file that all tensors to save to.
If not specified, will use the model name.
"""
if all_tensors_to_one_file:
file_name = Text(uuid.uuid1())
if location:
file_name = location
for tensor in _get_all_tensors(model):
set_external_data(tensor, file_name)
else:
for tensor in _get_all_tensors(model):
set_external_data(tensor, tensor.name)
|
python
|
def convert_model_to_external_data(model, all_tensors_to_one_file=True, location=None):
# type: (ModelProto, bool, Optional[Text]) -> None
"""
call to set all tensors as external data. save_model saves all the tensors data as external data after calling this function.
@params
model: ModelProto to be converted.
all_tensors_to_one_file: If true, save all tensors to one external file specified by location.
If false, save each tensor to a file named with the tensor name.
location: specify the external file that all tensors to save to.
If not specified, will use the model name.
"""
if all_tensors_to_one_file:
file_name = Text(uuid.uuid1())
if location:
file_name = location
for tensor in _get_all_tensors(model):
set_external_data(tensor, file_name)
else:
for tensor in _get_all_tensors(model):
set_external_data(tensor, tensor.name)
|
[
"def",
"convert_model_to_external_data",
"(",
"model",
",",
"all_tensors_to_one_file",
"=",
"True",
",",
"location",
"=",
"None",
")",
":",
"# type: (ModelProto, bool, Optional[Text]) -> None",
"if",
"all_tensors_to_one_file",
":",
"file_name",
"=",
"Text",
"(",
"uuid",
".",
"uuid1",
"(",
")",
")",
"if",
"location",
":",
"file_name",
"=",
"location",
"for",
"tensor",
"in",
"_get_all_tensors",
"(",
"model",
")",
":",
"set_external_data",
"(",
"tensor",
",",
"file_name",
")",
"else",
":",
"for",
"tensor",
"in",
"_get_all_tensors",
"(",
"model",
")",
":",
"set_external_data",
"(",
"tensor",
",",
"tensor",
".",
"name",
")"
] |
call to set all tensors as external data. save_model saves all the tensors data as external data after calling this function.
@params
model: ModelProto to be converted.
all_tensors_to_one_file: If true, save all tensors to one external file specified by location.
If false, save each tensor to a file named with the tensor name.
location: specify the external file that all tensors to save to.
If not specified, will use the model name.
|
[
"call",
"to",
"set",
"all",
"tensors",
"as",
"external",
"data",
".",
"save_model",
"saves",
"all",
"the",
"tensors",
"data",
"as",
"external",
"data",
"after",
"calling",
"this",
"function",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L92-L111
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
convert_model_from_external_data
|
def convert_model_from_external_data(model): # type: (ModelProto) -> None
"""
call to set all tensors data as embedded data. save_model saves all the tensors data as embedded data after calling this function.
@params
model: ModelProto to be converted.
"""
for tensor in _get_all_tensors(model):
if uses_external_data(tensor):
if not tensor.HasField("raw_data"):
raise ValueError("raw_data field doesn't exist.")
del tensor.external_data[:]
tensor.data_location = TensorProto.DEFAULT
|
python
|
def convert_model_from_external_data(model): # type: (ModelProto) -> None
"""
call to set all tensors data as embedded data. save_model saves all the tensors data as embedded data after calling this function.
@params
model: ModelProto to be converted.
"""
for tensor in _get_all_tensors(model):
if uses_external_data(tensor):
if not tensor.HasField("raw_data"):
raise ValueError("raw_data field doesn't exist.")
del tensor.external_data[:]
tensor.data_location = TensorProto.DEFAULT
|
[
"def",
"convert_model_from_external_data",
"(",
"model",
")",
":",
"# type: (ModelProto) -> None",
"for",
"tensor",
"in",
"_get_all_tensors",
"(",
"model",
")",
":",
"if",
"uses_external_data",
"(",
"tensor",
")",
":",
"if",
"not",
"tensor",
".",
"HasField",
"(",
"\"raw_data\"",
")",
":",
"raise",
"ValueError",
"(",
"\"raw_data field doesn't exist.\"",
")",
"del",
"tensor",
".",
"external_data",
"[",
":",
"]",
"tensor",
".",
"data_location",
"=",
"TensorProto",
".",
"DEFAULT"
] |
call to set all tensors data as embedded data. save_model saves all the tensors data as embedded data after calling this function.
@params
model: ModelProto to be converted.
|
[
"call",
"to",
"set",
"all",
"tensors",
"data",
"as",
"embedded",
"data",
".",
"save_model",
"saves",
"all",
"the",
"tensors",
"data",
"as",
"embedded",
"data",
"after",
"calling",
"this",
"function",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L114-L125
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
save_external_data
|
def save_external_data(tensor, base_path): # type: (TensorProto, Text) -> None
"""
Write tensor data to an external file according to information in the `external_data` field.
@params
tensor: Tensor object to be serialized
base_path: System path of a folder where tensor data is to be stored
"""
info = ExternalDataInfo(tensor)
external_data_file_path = os.path.join(base_path, info.location)
# Retrieve the tensor's data from raw_data or load external file
if not tensor.HasField("raw_data"):
raise ValueError("raw_data field doesn't exist.")
# Create file if it doesn't exist
if not os.path.isfile(external_data_file_path):
open(external_data_file_path, 'ab').close()
# Open file for reading and writing at random locations ('r+b')
with open(external_data_file_path, 'r+b') as data_file:
data_file.seek(0, 2)
if info.offset is not None:
# Pad file to required offset if needed
file_size = data_file.tell()
if info.offset > file_size:
data_file.write(b"\0" * (info.offset - file_size))
data_file.seek(info.offset)
offset = data_file.tell()
data_file.write(tensor.raw_data)
set_external_data(tensor, info.location, offset, data_file.tell() - offset)
|
python
|
def save_external_data(tensor, base_path): # type: (TensorProto, Text) -> None
"""
Write tensor data to an external file according to information in the `external_data` field.
@params
tensor: Tensor object to be serialized
base_path: System path of a folder where tensor data is to be stored
"""
info = ExternalDataInfo(tensor)
external_data_file_path = os.path.join(base_path, info.location)
# Retrieve the tensor's data from raw_data or load external file
if not tensor.HasField("raw_data"):
raise ValueError("raw_data field doesn't exist.")
# Create file if it doesn't exist
if not os.path.isfile(external_data_file_path):
open(external_data_file_path, 'ab').close()
# Open file for reading and writing at random locations ('r+b')
with open(external_data_file_path, 'r+b') as data_file:
data_file.seek(0, 2)
if info.offset is not None:
# Pad file to required offset if needed
file_size = data_file.tell()
if info.offset > file_size:
data_file.write(b"\0" * (info.offset - file_size))
data_file.seek(info.offset)
offset = data_file.tell()
data_file.write(tensor.raw_data)
set_external_data(tensor, info.location, offset, data_file.tell() - offset)
|
[
"def",
"save_external_data",
"(",
"tensor",
",",
"base_path",
")",
":",
"# type: (TensorProto, Text) -> None",
"info",
"=",
"ExternalDataInfo",
"(",
"tensor",
")",
"external_data_file_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"base_path",
",",
"info",
".",
"location",
")",
"# Retrieve the tensor's data from raw_data or load external file",
"if",
"not",
"tensor",
".",
"HasField",
"(",
"\"raw_data\"",
")",
":",
"raise",
"ValueError",
"(",
"\"raw_data field doesn't exist.\"",
")",
"# Create file if it doesn't exist",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"external_data_file_path",
")",
":",
"open",
"(",
"external_data_file_path",
",",
"'ab'",
")",
".",
"close",
"(",
")",
"# Open file for reading and writing at random locations ('r+b')",
"with",
"open",
"(",
"external_data_file_path",
",",
"'r+b'",
")",
"as",
"data_file",
":",
"data_file",
".",
"seek",
"(",
"0",
",",
"2",
")",
"if",
"info",
".",
"offset",
"is",
"not",
"None",
":",
"# Pad file to required offset if needed",
"file_size",
"=",
"data_file",
".",
"tell",
"(",
")",
"if",
"info",
".",
"offset",
">",
"file_size",
":",
"data_file",
".",
"write",
"(",
"b\"\\0\"",
"*",
"(",
"info",
".",
"offset",
"-",
"file_size",
")",
")",
"data_file",
".",
"seek",
"(",
"info",
".",
"offset",
")",
"offset",
"=",
"data_file",
".",
"tell",
"(",
")",
"data_file",
".",
"write",
"(",
"tensor",
".",
"raw_data",
")",
"set_external_data",
"(",
"tensor",
",",
"info",
".",
"location",
",",
"offset",
",",
"data_file",
".",
"tell",
"(",
")",
"-",
"offset",
")"
] |
Write tensor data to an external file according to information in the `external_data` field.
@params
tensor: Tensor object to be serialized
base_path: System path of a folder where tensor data is to be stored
|
[
"Write",
"tensor",
"data",
"to",
"an",
"external",
"file",
"according",
"to",
"information",
"in",
"the",
"external_data",
"field",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L128-L159
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
_get_attribute_tensors
|
def _get_attribute_tensors(onnx_model_proto): # type: (ModelProto) -> Iterable[TensorProto]
"""Create an iterator of tensors from node attributes of an ONNX model."""
for node in onnx_model_proto.graph.node:
for attribute in node.attribute:
if attribute.HasField("t"):
yield attribute.t
for tensor in attribute.tensors:
yield tensor
|
python
|
def _get_attribute_tensors(onnx_model_proto): # type: (ModelProto) -> Iterable[TensorProto]
"""Create an iterator of tensors from node attributes of an ONNX model."""
for node in onnx_model_proto.graph.node:
for attribute in node.attribute:
if attribute.HasField("t"):
yield attribute.t
for tensor in attribute.tensors:
yield tensor
|
[
"def",
"_get_attribute_tensors",
"(",
"onnx_model_proto",
")",
":",
"# type: (ModelProto) -> Iterable[TensorProto]",
"for",
"node",
"in",
"onnx_model_proto",
".",
"graph",
".",
"node",
":",
"for",
"attribute",
"in",
"node",
".",
"attribute",
":",
"if",
"attribute",
".",
"HasField",
"(",
"\"t\"",
")",
":",
"yield",
"attribute",
".",
"t",
"for",
"tensor",
"in",
"attribute",
".",
"tensors",
":",
"yield",
"tensor"
] |
Create an iterator of tensors from node attributes of an ONNX model.
|
[
"Create",
"an",
"iterator",
"of",
"tensors",
"from",
"node",
"attributes",
"of",
"an",
"ONNX",
"model",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L174-L181
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
remove_external_data_field
|
def remove_external_data_field(tensor, field_key): # type: (TensorProto, Text) -> None
"""
Remove a field from a Tensor's external_data key-value store.
Modifies tensor object in place.
@params
tensor: Tensor object from which value will be removed
field_key: The key of the field to be removed
"""
for (i, field) in enumerate(tensor.external_data):
if field.key == field_key:
del tensor.external_data[i]
|
python
|
def remove_external_data_field(tensor, field_key): # type: (TensorProto, Text) -> None
"""
Remove a field from a Tensor's external_data key-value store.
Modifies tensor object in place.
@params
tensor: Tensor object from which value will be removed
field_key: The key of the field to be removed
"""
for (i, field) in enumerate(tensor.external_data):
if field.key == field_key:
del tensor.external_data[i]
|
[
"def",
"remove_external_data_field",
"(",
"tensor",
",",
"field_key",
")",
":",
"# type: (TensorProto, Text) -> None",
"for",
"(",
"i",
",",
"field",
")",
"in",
"enumerate",
"(",
"tensor",
".",
"external_data",
")",
":",
"if",
"field",
".",
"key",
"==",
"field_key",
":",
"del",
"tensor",
".",
"external_data",
"[",
"i",
"]"
] |
Remove a field from a Tensor's external_data key-value store.
Modifies tensor object in place.
@params
tensor: Tensor object from which value will be removed
field_key: The key of the field to be removed
|
[
"Remove",
"a",
"field",
"from",
"a",
"Tensor",
"s",
"external_data",
"key",
"-",
"value",
"store",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L197-L209
|
train
|
onnx/onnx
|
onnx/external_data_helper.py
|
write_external_data_tensors
|
def write_external_data_tensors(model, filepath): # type: (ModelProto, Text) -> ModelProto
"""
Write external data of all tensors to files on disk.
Note: This function also strips basepath information from all tensors' external_data fields.
@params
model: Model object which is the source of tensors to serialize.
filepath: System path to the directory which should be treated as base path for external data.
@return
The modified model object.
"""
for tensor in _get_all_tensors(model):
if uses_external_data(tensor):
save_external_data(tensor, filepath)
tensor.ClearField(str('raw_data'))
return model
|
python
|
def write_external_data_tensors(model, filepath): # type: (ModelProto, Text) -> ModelProto
"""
Write external data of all tensors to files on disk.
Note: This function also strips basepath information from all tensors' external_data fields.
@params
model: Model object which is the source of tensors to serialize.
filepath: System path to the directory which should be treated as base path for external data.
@return
The modified model object.
"""
for tensor in _get_all_tensors(model):
if uses_external_data(tensor):
save_external_data(tensor, filepath)
tensor.ClearField(str('raw_data'))
return model
|
[
"def",
"write_external_data_tensors",
"(",
"model",
",",
"filepath",
")",
":",
"# type: (ModelProto, Text) -> ModelProto",
"for",
"tensor",
"in",
"_get_all_tensors",
"(",
"model",
")",
":",
"if",
"uses_external_data",
"(",
"tensor",
")",
":",
"save_external_data",
"(",
"tensor",
",",
"filepath",
")",
"tensor",
".",
"ClearField",
"(",
"str",
"(",
"'raw_data'",
")",
")",
"return",
"model"
] |
Write external data of all tensors to files on disk.
Note: This function also strips basepath information from all tensors' external_data fields.
@params
model: Model object which is the source of tensors to serialize.
filepath: System path to the directory which should be treated as base path for external data.
@return
The modified model object.
|
[
"Write",
"external",
"data",
"of",
"all",
"tensors",
"to",
"files",
"on",
"disk",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/external_data_helper.py#L212-L230
|
train
|
onnx/onnx
|
tools/protoc-gen-mypy.py
|
PkgWriter._import
|
def _import(self, path, name):
# type: (Text, Text) -> Text
"""Imports a stdlib path and returns a handle to it
eg. self._import("typing", "Optional") -> "Optional"
"""
imp = path.replace('/', '.')
self.imports[imp].add(name)
return name
|
python
|
def _import(self, path, name):
# type: (Text, Text) -> Text
"""Imports a stdlib path and returns a handle to it
eg. self._import("typing", "Optional") -> "Optional"
"""
imp = path.replace('/', '.')
self.imports[imp].add(name)
return name
|
[
"def",
"_import",
"(",
"self",
",",
"path",
",",
"name",
")",
":",
"# type: (Text, Text) -> Text",
"imp",
"=",
"path",
".",
"replace",
"(",
"'/'",
",",
"'.'",
")",
"self",
".",
"imports",
"[",
"imp",
"]",
".",
"add",
"(",
"name",
")",
"return",
"name"
] |
Imports a stdlib path and returns a handle to it
eg. self._import("typing", "Optional") -> "Optional"
|
[
"Imports",
"a",
"stdlib",
"path",
"and",
"returns",
"a",
"handle",
"to",
"it",
"eg",
".",
"self",
".",
"_import",
"(",
"typing",
"Optional",
")",
"-",
">",
"Optional"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/tools/protoc-gen-mypy.py#L74-L81
|
train
|
onnx/onnx
|
tools/protoc-gen-mypy.py
|
PkgWriter._import_message
|
def _import_message(self, type_name):
# type: (d.FieldDescriptorProto) -> Text
"""Import a referenced message and return a handle"""
name = cast(Text, type_name)
if name[0] == '.' and name[1].isupper() and name[2].islower():
# Message defined in this file
return name[1:]
message_fd = self.descriptors.message_to_fd[name]
if message_fd.name == self.fd.name:
# message defined in this package
split = name.split('.')
for i, segment in enumerate(split):
if segment and segment[0].isupper() and segment[1].islower():
return ".".join(split[i:])
# Not in package. Must import
split = name.split(".")
for i, segment in enumerate(split):
if segment and segment[0].isupper() and segment[1].islower():
assert message_fd.name.endswith('.proto')
import_name = self._import(message_fd.name[:-6].replace('-', '_') + "_pb2", segment)
remains = ".".join(split[i + 1:])
if not remains:
return import_name
raise AssertionError("Don't support nested imports yet")
# return new_nested_import(import_name, remains)
raise AssertionError("Could not parse local name " + name)
|
python
|
def _import_message(self, type_name):
# type: (d.FieldDescriptorProto) -> Text
"""Import a referenced message and return a handle"""
name = cast(Text, type_name)
if name[0] == '.' and name[1].isupper() and name[2].islower():
# Message defined in this file
return name[1:]
message_fd = self.descriptors.message_to_fd[name]
if message_fd.name == self.fd.name:
# message defined in this package
split = name.split('.')
for i, segment in enumerate(split):
if segment and segment[0].isupper() and segment[1].islower():
return ".".join(split[i:])
# Not in package. Must import
split = name.split(".")
for i, segment in enumerate(split):
if segment and segment[0].isupper() and segment[1].islower():
assert message_fd.name.endswith('.proto')
import_name = self._import(message_fd.name[:-6].replace('-', '_') + "_pb2", segment)
remains = ".".join(split[i + 1:])
if not remains:
return import_name
raise AssertionError("Don't support nested imports yet")
# return new_nested_import(import_name, remains)
raise AssertionError("Could not parse local name " + name)
|
[
"def",
"_import_message",
"(",
"self",
",",
"type_name",
")",
":",
"# type: (d.FieldDescriptorProto) -> Text",
"name",
"=",
"cast",
"(",
"Text",
",",
"type_name",
")",
"if",
"name",
"[",
"0",
"]",
"==",
"'.'",
"and",
"name",
"[",
"1",
"]",
".",
"isupper",
"(",
")",
"and",
"name",
"[",
"2",
"]",
".",
"islower",
"(",
")",
":",
"# Message defined in this file",
"return",
"name",
"[",
"1",
":",
"]",
"message_fd",
"=",
"self",
".",
"descriptors",
".",
"message_to_fd",
"[",
"name",
"]",
"if",
"message_fd",
".",
"name",
"==",
"self",
".",
"fd",
".",
"name",
":",
"# message defined in this package",
"split",
"=",
"name",
".",
"split",
"(",
"'.'",
")",
"for",
"i",
",",
"segment",
"in",
"enumerate",
"(",
"split",
")",
":",
"if",
"segment",
"and",
"segment",
"[",
"0",
"]",
".",
"isupper",
"(",
")",
"and",
"segment",
"[",
"1",
"]",
".",
"islower",
"(",
")",
":",
"return",
"\".\"",
".",
"join",
"(",
"split",
"[",
"i",
":",
"]",
")",
"# Not in package. Must import",
"split",
"=",
"name",
".",
"split",
"(",
"\".\"",
")",
"for",
"i",
",",
"segment",
"in",
"enumerate",
"(",
"split",
")",
":",
"if",
"segment",
"and",
"segment",
"[",
"0",
"]",
".",
"isupper",
"(",
")",
"and",
"segment",
"[",
"1",
"]",
".",
"islower",
"(",
")",
":",
"assert",
"message_fd",
".",
"name",
".",
"endswith",
"(",
"'.proto'",
")",
"import_name",
"=",
"self",
".",
"_import",
"(",
"message_fd",
".",
"name",
"[",
":",
"-",
"6",
"]",
".",
"replace",
"(",
"'-'",
",",
"'_'",
")",
"+",
"\"_pb2\"",
",",
"segment",
")",
"remains",
"=",
"\".\"",
".",
"join",
"(",
"split",
"[",
"i",
"+",
"1",
":",
"]",
")",
"if",
"not",
"remains",
":",
"return",
"import_name",
"raise",
"AssertionError",
"(",
"\"Don't support nested imports yet\"",
")",
"# return new_nested_import(import_name, remains)",
"raise",
"AssertionError",
"(",
"\"Could not parse local name \"",
"+",
"name",
")"
] |
Import a referenced message and return a handle
|
[
"Import",
"a",
"referenced",
"message",
"and",
"return",
"a",
"handle"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/tools/protoc-gen-mypy.py#L83-L112
|
train
|
onnx/onnx
|
setup.py
|
mypy_type_check.run
|
def run(self):
"""Run command."""
onnx_script = os.path.realpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "tools/mypy-onnx.py"))
returncode = subprocess.call([sys.executable, onnx_script])
sys.exit(returncode)
|
python
|
def run(self):
"""Run command."""
onnx_script = os.path.realpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "tools/mypy-onnx.py"))
returncode = subprocess.call([sys.executable, onnx_script])
sys.exit(returncode)
|
[
"def",
"run",
"(",
"self",
")",
":",
"onnx_script",
"=",
"os",
".",
"path",
".",
"realpath",
"(",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"__file__",
")",
")",
",",
"\"tools/mypy-onnx.py\"",
")",
")",
"returncode",
"=",
"subprocess",
".",
"call",
"(",
"[",
"sys",
".",
"executable",
",",
"onnx_script",
"]",
")",
"sys",
".",
"exit",
"(",
"returncode",
")"
] |
Run command.
|
[
"Run",
"command",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/setup.py#L252-L256
|
train
|
onnx/onnx
|
onnx/helper.py
|
make_node
|
def make_node(
op_type, # type: Text
inputs, # type: Sequence[Text]
outputs, # type: Sequence[Text]
name=None, # type: Optional[Text]
doc_string=None, # type: Optional[Text]
domain=None, # type: Optional[Text]
**kwargs # type: Any
): # type: (...) -> NodeProto
"""Construct a NodeProto.
Arguments:
op_type (string): The name of the operator to construct
inputs (list of string): list of input names
outputs (list of string): list of output names
name (string, default None): optional unique identifier for NodeProto
doc_string (string, default None): optional documentation string for NodeProto
domain (string, default None): optional domain for NodeProto.
If it's None, we will just use default domain (which is empty)
**kwargs (dict): the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
"""
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if domain is not None:
node.domain = domain
if kwargs:
node.attribute.extend(
make_attribute(key, value)
for key, value in sorted(kwargs.items()))
return node
|
python
|
def make_node(
op_type, # type: Text
inputs, # type: Sequence[Text]
outputs, # type: Sequence[Text]
name=None, # type: Optional[Text]
doc_string=None, # type: Optional[Text]
domain=None, # type: Optional[Text]
**kwargs # type: Any
): # type: (...) -> NodeProto
"""Construct a NodeProto.
Arguments:
op_type (string): The name of the operator to construct
inputs (list of string): list of input names
outputs (list of string): list of output names
name (string, default None): optional unique identifier for NodeProto
doc_string (string, default None): optional documentation string for NodeProto
domain (string, default None): optional domain for NodeProto.
If it's None, we will just use default domain (which is empty)
**kwargs (dict): the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
"""
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if domain is not None:
node.domain = domain
if kwargs:
node.attribute.extend(
make_attribute(key, value)
for key, value in sorted(kwargs.items()))
return node
|
[
"def",
"make_node",
"(",
"op_type",
",",
"# type: Text",
"inputs",
",",
"# type: Sequence[Text]",
"outputs",
",",
"# type: Sequence[Text]",
"name",
"=",
"None",
",",
"# type: Optional[Text]",
"doc_string",
"=",
"None",
",",
"# type: Optional[Text]",
"domain",
"=",
"None",
",",
"# type: Optional[Text]",
"*",
"*",
"kwargs",
"# type: Any",
")",
":",
"# type: (...) -> NodeProto",
"node",
"=",
"NodeProto",
"(",
")",
"node",
".",
"op_type",
"=",
"op_type",
"node",
".",
"input",
".",
"extend",
"(",
"inputs",
")",
"node",
".",
"output",
".",
"extend",
"(",
"outputs",
")",
"if",
"name",
":",
"node",
".",
"name",
"=",
"name",
"if",
"doc_string",
":",
"node",
".",
"doc_string",
"=",
"doc_string",
"if",
"domain",
"is",
"not",
"None",
":",
"node",
".",
"domain",
"=",
"domain",
"if",
"kwargs",
":",
"node",
".",
"attribute",
".",
"extend",
"(",
"make_attribute",
"(",
"key",
",",
"value",
")",
"for",
"key",
",",
"value",
"in",
"sorted",
"(",
"kwargs",
".",
"items",
"(",
")",
")",
")",
"return",
"node"
] |
Construct a NodeProto.
Arguments:
op_type (string): The name of the operator to construct
inputs (list of string): list of input names
outputs (list of string): list of output names
name (string, default None): optional unique identifier for NodeProto
doc_string (string, default None): optional documentation string for NodeProto
domain (string, default None): optional domain for NodeProto.
If it's None, we will just use default domain (which is empty)
**kwargs (dict): the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
|
[
"Construct",
"a",
"NodeProto",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/helper.py#L20-L57
|
train
|
onnx/onnx
|
onnx/helper.py
|
make_operatorsetid
|
def make_operatorsetid(
domain, # type: Text
version, # type: int
): # type: (...) -> OperatorSetIdProto
"""Construct an OperatorSetIdProto.
Arguments:
domain (string): The domain of the operator set id
version (integer): Version of operator set id
"""
operatorsetid = OperatorSetIdProto()
operatorsetid.domain = domain
operatorsetid.version = version
return operatorsetid
|
python
|
def make_operatorsetid(
domain, # type: Text
version, # type: int
): # type: (...) -> OperatorSetIdProto
"""Construct an OperatorSetIdProto.
Arguments:
domain (string): The domain of the operator set id
version (integer): Version of operator set id
"""
operatorsetid = OperatorSetIdProto()
operatorsetid.domain = domain
operatorsetid.version = version
return operatorsetid
|
[
"def",
"make_operatorsetid",
"(",
"domain",
",",
"# type: Text",
"version",
",",
"# type: int",
")",
":",
"# type: (...) -> OperatorSetIdProto",
"operatorsetid",
"=",
"OperatorSetIdProto",
"(",
")",
"operatorsetid",
".",
"domain",
"=",
"domain",
"operatorsetid",
".",
"version",
"=",
"version",
"return",
"operatorsetid"
] |
Construct an OperatorSetIdProto.
Arguments:
domain (string): The domain of the operator set id
version (integer): Version of operator set id
|
[
"Construct",
"an",
"OperatorSetIdProto",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/helper.py#L60-L73
|
train
|
onnx/onnx
|
onnx/helper.py
|
_to_bytes_or_false
|
def _to_bytes_or_false(val): # type: (Union[Text, bytes]) -> Union[bytes, bool]
"""An internal graph to convert the input to a bytes or to False.
The criteria for conversion is as follows and should be python 2 and 3
compatible:
- If val is py2 str or py3 bytes: return bytes
- If val is py2 unicode or py3 str: return val.decode('utf-8')
- Otherwise, return False
"""
if isinstance(val, bytes):
return val
else:
try:
return val.encode('utf-8')
except AttributeError:
return False
|
python
|
def _to_bytes_or_false(val): # type: (Union[Text, bytes]) -> Union[bytes, bool]
"""An internal graph to convert the input to a bytes or to False.
The criteria for conversion is as follows and should be python 2 and 3
compatible:
- If val is py2 str or py3 bytes: return bytes
- If val is py2 unicode or py3 str: return val.decode('utf-8')
- Otherwise, return False
"""
if isinstance(val, bytes):
return val
else:
try:
return val.encode('utf-8')
except AttributeError:
return False
|
[
"def",
"_to_bytes_or_false",
"(",
"val",
")",
":",
"# type: (Union[Text, bytes]) -> Union[bytes, bool]",
"if",
"isinstance",
"(",
"val",
",",
"bytes",
")",
":",
"return",
"val",
"else",
":",
"try",
":",
"return",
"val",
".",
"encode",
"(",
"'utf-8'",
")",
"except",
"AttributeError",
":",
"return",
"False"
] |
An internal graph to convert the input to a bytes or to False.
The criteria for conversion is as follows and should be python 2 and 3
compatible:
- If val is py2 str or py3 bytes: return bytes
- If val is py2 unicode or py3 str: return val.decode('utf-8')
- Otherwise, return False
|
[
"An",
"internal",
"graph",
"to",
"convert",
"the",
"input",
"to",
"a",
"bytes",
"or",
"to",
"False",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/helper.py#L179-L194
|
train
|
onnx/onnx
|
onnx/helper.py
|
make_attribute
|
def make_attribute(
key, # type: Text
value, # type: Any
doc_string=None # type: Optional[Text]
): # type: (...) -> AttributeProto
"""Makes an AttributeProto based on the value type."""
attr = AttributeProto()
attr.name = key
if doc_string:
attr.doc_string = doc_string
is_iterable = isinstance(value, collections.Iterable)
bytes_or_false = _to_bytes_or_false(value)
# First, singular cases
# float
if isinstance(value, float):
attr.f = value
attr.type = AttributeProto.FLOAT
# integer
elif isinstance(value, numbers.Integral):
attr.i = cast(int, value)
attr.type = AttributeProto.INT
# string
elif bytes_or_false:
assert isinstance(bytes_or_false, bytes)
attr.s = bytes_or_false
attr.type = AttributeProto.STRING
elif isinstance(value, TensorProto):
attr.t.CopyFrom(value)
attr.type = AttributeProto.TENSOR
elif isinstance(value, GraphProto):
attr.g.CopyFrom(value)
attr.type = AttributeProto.GRAPH
# third, iterable cases
elif is_iterable:
byte_array = [_to_bytes_or_false(v) for v in value]
if all(isinstance(v, float) for v in value):
attr.floats.extend(value)
attr.type = AttributeProto.FLOATS
elif all(isinstance(v, numbers.Integral) for v in value):
# Turn np.int32/64 into Python built-in int.
attr.ints.extend(int(v) for v in value)
attr.type = AttributeProto.INTS
elif all(byte_array):
attr.strings.extend(cast(List[bytes], byte_array))
attr.type = AttributeProto.STRINGS
elif all(isinstance(v, TensorProto) for v in value):
attr.tensors.extend(value)
attr.type = AttributeProto.TENSORS
elif all(isinstance(v, GraphProto) for v in value):
attr.graphs.extend(value)
attr.type = AttributeProto.GRAPHS
else:
raise ValueError(
"You passed in an iterable attribute but I cannot figure out "
"its applicable type.")
else:
raise ValueError(
'Value "{}" is not valid attribute data type.'.format(value))
return attr
|
python
|
def make_attribute(
key, # type: Text
value, # type: Any
doc_string=None # type: Optional[Text]
): # type: (...) -> AttributeProto
"""Makes an AttributeProto based on the value type."""
attr = AttributeProto()
attr.name = key
if doc_string:
attr.doc_string = doc_string
is_iterable = isinstance(value, collections.Iterable)
bytes_or_false = _to_bytes_or_false(value)
# First, singular cases
# float
if isinstance(value, float):
attr.f = value
attr.type = AttributeProto.FLOAT
# integer
elif isinstance(value, numbers.Integral):
attr.i = cast(int, value)
attr.type = AttributeProto.INT
# string
elif bytes_or_false:
assert isinstance(bytes_or_false, bytes)
attr.s = bytes_or_false
attr.type = AttributeProto.STRING
elif isinstance(value, TensorProto):
attr.t.CopyFrom(value)
attr.type = AttributeProto.TENSOR
elif isinstance(value, GraphProto):
attr.g.CopyFrom(value)
attr.type = AttributeProto.GRAPH
# third, iterable cases
elif is_iterable:
byte_array = [_to_bytes_or_false(v) for v in value]
if all(isinstance(v, float) for v in value):
attr.floats.extend(value)
attr.type = AttributeProto.FLOATS
elif all(isinstance(v, numbers.Integral) for v in value):
# Turn np.int32/64 into Python built-in int.
attr.ints.extend(int(v) for v in value)
attr.type = AttributeProto.INTS
elif all(byte_array):
attr.strings.extend(cast(List[bytes], byte_array))
attr.type = AttributeProto.STRINGS
elif all(isinstance(v, TensorProto) for v in value):
attr.tensors.extend(value)
attr.type = AttributeProto.TENSORS
elif all(isinstance(v, GraphProto) for v in value):
attr.graphs.extend(value)
attr.type = AttributeProto.GRAPHS
else:
raise ValueError(
"You passed in an iterable attribute but I cannot figure out "
"its applicable type.")
else:
raise ValueError(
'Value "{}" is not valid attribute data type.'.format(value))
return attr
|
[
"def",
"make_attribute",
"(",
"key",
",",
"# type: Text",
"value",
",",
"# type: Any",
"doc_string",
"=",
"None",
"# type: Optional[Text]",
")",
":",
"# type: (...) -> AttributeProto",
"attr",
"=",
"AttributeProto",
"(",
")",
"attr",
".",
"name",
"=",
"key",
"if",
"doc_string",
":",
"attr",
".",
"doc_string",
"=",
"doc_string",
"is_iterable",
"=",
"isinstance",
"(",
"value",
",",
"collections",
".",
"Iterable",
")",
"bytes_or_false",
"=",
"_to_bytes_or_false",
"(",
"value",
")",
"# First, singular cases",
"# float",
"if",
"isinstance",
"(",
"value",
",",
"float",
")",
":",
"attr",
".",
"f",
"=",
"value",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"FLOAT",
"# integer",
"elif",
"isinstance",
"(",
"value",
",",
"numbers",
".",
"Integral",
")",
":",
"attr",
".",
"i",
"=",
"cast",
"(",
"int",
",",
"value",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"INT",
"# string",
"elif",
"bytes_or_false",
":",
"assert",
"isinstance",
"(",
"bytes_or_false",
",",
"bytes",
")",
"attr",
".",
"s",
"=",
"bytes_or_false",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"STRING",
"elif",
"isinstance",
"(",
"value",
",",
"TensorProto",
")",
":",
"attr",
".",
"t",
".",
"CopyFrom",
"(",
"value",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"TENSOR",
"elif",
"isinstance",
"(",
"value",
",",
"GraphProto",
")",
":",
"attr",
".",
"g",
".",
"CopyFrom",
"(",
"value",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"GRAPH",
"# third, iterable cases",
"elif",
"is_iterable",
":",
"byte_array",
"=",
"[",
"_to_bytes_or_false",
"(",
"v",
")",
"for",
"v",
"in",
"value",
"]",
"if",
"all",
"(",
"isinstance",
"(",
"v",
",",
"float",
")",
"for",
"v",
"in",
"value",
")",
":",
"attr",
".",
"floats",
".",
"extend",
"(",
"value",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"FLOATS",
"elif",
"all",
"(",
"isinstance",
"(",
"v",
",",
"numbers",
".",
"Integral",
")",
"for",
"v",
"in",
"value",
")",
":",
"# Turn np.int32/64 into Python built-in int.",
"attr",
".",
"ints",
".",
"extend",
"(",
"int",
"(",
"v",
")",
"for",
"v",
"in",
"value",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"INTS",
"elif",
"all",
"(",
"byte_array",
")",
":",
"attr",
".",
"strings",
".",
"extend",
"(",
"cast",
"(",
"List",
"[",
"bytes",
"]",
",",
"byte_array",
")",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"STRINGS",
"elif",
"all",
"(",
"isinstance",
"(",
"v",
",",
"TensorProto",
")",
"for",
"v",
"in",
"value",
")",
":",
"attr",
".",
"tensors",
".",
"extend",
"(",
"value",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"TENSORS",
"elif",
"all",
"(",
"isinstance",
"(",
"v",
",",
"GraphProto",
")",
"for",
"v",
"in",
"value",
")",
":",
"attr",
".",
"graphs",
".",
"extend",
"(",
"value",
")",
"attr",
".",
"type",
"=",
"AttributeProto",
".",
"GRAPHS",
"else",
":",
"raise",
"ValueError",
"(",
"\"You passed in an iterable attribute but I cannot figure out \"",
"\"its applicable type.\"",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Value \"{}\" is not valid attribute data type.'",
".",
"format",
"(",
"value",
")",
")",
"return",
"attr"
] |
Makes an AttributeProto based on the value type.
|
[
"Makes",
"an",
"AttributeProto",
"based",
"on",
"the",
"value",
"type",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/helper.py#L197-L256
|
train
|
onnx/onnx
|
onnx/helper.py
|
make_tensor_value_info
|
def make_tensor_value_info(
name, # type: Text
elem_type, # type: int
shape, # type: Optional[Sequence[Union[Text, int]]]
doc_string="", # type: Text
shape_denotation=None, # type: Optional[List[Text]]
): # type: (...) -> ValueInfoProto
"""Makes a ValueInfoProto based on the data type and shape."""
value_info_proto = ValueInfoProto()
value_info_proto.name = name
if doc_string:
value_info_proto.doc_string = doc_string
tensor_type_proto = value_info_proto.type.tensor_type
tensor_type_proto.elem_type = elem_type
tensor_shape_proto = tensor_type_proto.shape
if shape is not None:
# You might think this is a no-op (extending a normal Python
# list by [] certainly is), but protobuf lists work a little
# differently; if a field is never set, it is omitted from the
# resulting protobuf; a list that is explicitly set to be
# empty will get an (empty) entry in the protobuf. This
# difference is visible to our consumers, so make sure we emit
# an empty shape!
tensor_shape_proto.dim.extend([])
if shape_denotation:
if len(shape_denotation) != len(shape):
raise ValueError(
'Invalid shape_denotation. '
'Must be of the same length as shape.')
for i, d in enumerate(shape):
dim = tensor_shape_proto.dim.add()
if d is None:
pass
elif isinstance(d, integer_types):
dim.dim_value = d
elif isinstance(d, text_type):
dim.dim_param = d
else:
raise ValueError(
'Invalid item in shape: {}. '
'Needs to of integer_types or text_type.'.format(d))
if shape_denotation:
dim.denotation = shape_denotation[i]
return value_info_proto
|
python
|
def make_tensor_value_info(
name, # type: Text
elem_type, # type: int
shape, # type: Optional[Sequence[Union[Text, int]]]
doc_string="", # type: Text
shape_denotation=None, # type: Optional[List[Text]]
): # type: (...) -> ValueInfoProto
"""Makes a ValueInfoProto based on the data type and shape."""
value_info_proto = ValueInfoProto()
value_info_proto.name = name
if doc_string:
value_info_proto.doc_string = doc_string
tensor_type_proto = value_info_proto.type.tensor_type
tensor_type_proto.elem_type = elem_type
tensor_shape_proto = tensor_type_proto.shape
if shape is not None:
# You might think this is a no-op (extending a normal Python
# list by [] certainly is), but protobuf lists work a little
# differently; if a field is never set, it is omitted from the
# resulting protobuf; a list that is explicitly set to be
# empty will get an (empty) entry in the protobuf. This
# difference is visible to our consumers, so make sure we emit
# an empty shape!
tensor_shape_proto.dim.extend([])
if shape_denotation:
if len(shape_denotation) != len(shape):
raise ValueError(
'Invalid shape_denotation. '
'Must be of the same length as shape.')
for i, d in enumerate(shape):
dim = tensor_shape_proto.dim.add()
if d is None:
pass
elif isinstance(d, integer_types):
dim.dim_value = d
elif isinstance(d, text_type):
dim.dim_param = d
else:
raise ValueError(
'Invalid item in shape: {}. '
'Needs to of integer_types or text_type.'.format(d))
if shape_denotation:
dim.denotation = shape_denotation[i]
return value_info_proto
|
[
"def",
"make_tensor_value_info",
"(",
"name",
",",
"# type: Text",
"elem_type",
",",
"# type: int",
"shape",
",",
"# type: Optional[Sequence[Union[Text, int]]]",
"doc_string",
"=",
"\"\"",
",",
"# type: Text",
"shape_denotation",
"=",
"None",
",",
"# type: Optional[List[Text]]",
")",
":",
"# type: (...) -> ValueInfoProto",
"value_info_proto",
"=",
"ValueInfoProto",
"(",
")",
"value_info_proto",
".",
"name",
"=",
"name",
"if",
"doc_string",
":",
"value_info_proto",
".",
"doc_string",
"=",
"doc_string",
"tensor_type_proto",
"=",
"value_info_proto",
".",
"type",
".",
"tensor_type",
"tensor_type_proto",
".",
"elem_type",
"=",
"elem_type",
"tensor_shape_proto",
"=",
"tensor_type_proto",
".",
"shape",
"if",
"shape",
"is",
"not",
"None",
":",
"# You might think this is a no-op (extending a normal Python",
"# list by [] certainly is), but protobuf lists work a little",
"# differently; if a field is never set, it is omitted from the",
"# resulting protobuf; a list that is explicitly set to be",
"# empty will get an (empty) entry in the protobuf. This",
"# difference is visible to our consumers, so make sure we emit",
"# an empty shape!",
"tensor_shape_proto",
".",
"dim",
".",
"extend",
"(",
"[",
"]",
")",
"if",
"shape_denotation",
":",
"if",
"len",
"(",
"shape_denotation",
")",
"!=",
"len",
"(",
"shape",
")",
":",
"raise",
"ValueError",
"(",
"'Invalid shape_denotation. '",
"'Must be of the same length as shape.'",
")",
"for",
"i",
",",
"d",
"in",
"enumerate",
"(",
"shape",
")",
":",
"dim",
"=",
"tensor_shape_proto",
".",
"dim",
".",
"add",
"(",
")",
"if",
"d",
"is",
"None",
":",
"pass",
"elif",
"isinstance",
"(",
"d",
",",
"integer_types",
")",
":",
"dim",
".",
"dim_value",
"=",
"d",
"elif",
"isinstance",
"(",
"d",
",",
"text_type",
")",
":",
"dim",
".",
"dim_param",
"=",
"d",
"else",
":",
"raise",
"ValueError",
"(",
"'Invalid item in shape: {}. '",
"'Needs to of integer_types or text_type.'",
".",
"format",
"(",
"d",
")",
")",
"if",
"shape_denotation",
":",
"dim",
".",
"denotation",
"=",
"shape_denotation",
"[",
"i",
"]",
"return",
"value_info_proto"
] |
Makes a ValueInfoProto based on the data type and shape.
|
[
"Makes",
"a",
"ValueInfoProto",
"based",
"on",
"the",
"data",
"type",
"and",
"shape",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/helper.py#L290-L340
|
train
|
onnx/onnx
|
onnx/helper.py
|
strip_doc_string
|
def strip_doc_string(proto): # type: (google.protobuf.message.Message) -> None
"""
Empties `doc_string` field on any nested protobuf messages
"""
assert isinstance(proto, google.protobuf.message.Message)
for descriptor in proto.DESCRIPTOR.fields:
if descriptor.name == 'doc_string':
proto.ClearField(descriptor.name)
elif descriptor.type == descriptor.TYPE_MESSAGE:
if descriptor.label == descriptor.LABEL_REPEATED:
for x in getattr(proto, descriptor.name):
strip_doc_string(x)
elif proto.HasField(descriptor.name):
strip_doc_string(getattr(proto, descriptor.name))
|
python
|
def strip_doc_string(proto): # type: (google.protobuf.message.Message) -> None
"""
Empties `doc_string` field on any nested protobuf messages
"""
assert isinstance(proto, google.protobuf.message.Message)
for descriptor in proto.DESCRIPTOR.fields:
if descriptor.name == 'doc_string':
proto.ClearField(descriptor.name)
elif descriptor.type == descriptor.TYPE_MESSAGE:
if descriptor.label == descriptor.LABEL_REPEATED:
for x in getattr(proto, descriptor.name):
strip_doc_string(x)
elif proto.HasField(descriptor.name):
strip_doc_string(getattr(proto, descriptor.name))
|
[
"def",
"strip_doc_string",
"(",
"proto",
")",
":",
"# type: (google.protobuf.message.Message) -> None",
"assert",
"isinstance",
"(",
"proto",
",",
"google",
".",
"protobuf",
".",
"message",
".",
"Message",
")",
"for",
"descriptor",
"in",
"proto",
".",
"DESCRIPTOR",
".",
"fields",
":",
"if",
"descriptor",
".",
"name",
"==",
"'doc_string'",
":",
"proto",
".",
"ClearField",
"(",
"descriptor",
".",
"name",
")",
"elif",
"descriptor",
".",
"type",
"==",
"descriptor",
".",
"TYPE_MESSAGE",
":",
"if",
"descriptor",
".",
"label",
"==",
"descriptor",
".",
"LABEL_REPEATED",
":",
"for",
"x",
"in",
"getattr",
"(",
"proto",
",",
"descriptor",
".",
"name",
")",
":",
"strip_doc_string",
"(",
"x",
")",
"elif",
"proto",
".",
"HasField",
"(",
"descriptor",
".",
"name",
")",
":",
"strip_doc_string",
"(",
"getattr",
"(",
"proto",
",",
"descriptor",
".",
"name",
")",
")"
] |
Empties `doc_string` field on any nested protobuf messages
|
[
"Empties",
"doc_string",
"field",
"on",
"any",
"nested",
"protobuf",
"messages"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/helper.py#L538-L551
|
train
|
onnx/onnx
|
onnx/numpy_helper.py
|
to_array
|
def to_array(tensor): # type: (TensorProto) -> np.ndarray[Any]
"""Converts a tensor def object to a numpy array.
Inputs:
tensor: a TensorProto object.
Returns:
arr: the converted array.
"""
if tensor.HasField("segment"):
raise ValueError(
"Currently not supporting loading segments.")
if tensor.data_type == TensorProto.UNDEFINED:
raise ValueError("The data type is not defined.")
tensor_dtype = tensor.data_type
np_dtype = mapping.TENSOR_TYPE_TO_NP_TYPE[tensor_dtype]
storage_type = mapping.TENSOR_TYPE_TO_STORAGE_TENSOR_TYPE[tensor_dtype]
storage_np_dtype = mapping.TENSOR_TYPE_TO_NP_TYPE[storage_type]
storage_field = mapping.STORAGE_TENSOR_TYPE_TO_FIELD[storage_type]
dims = tensor.dims
if tensor.data_type == TensorProto.STRING:
utf8_strings = getattr(tensor, storage_field)
ss = list(s.decode('utf-8') for s in utf8_strings)
return np.asarray(ss).astype(np_dtype).reshape(dims)
if tensor.HasField("raw_data"):
# Raw_bytes support: using frombuffer.
return np.frombuffer(
tensor.raw_data,
dtype=np_dtype).reshape(dims)
else:
data = getattr(tensor, storage_field), # type: Sequence[np.complex64]
if (tensor_dtype == TensorProto.COMPLEX64
or tensor_dtype == TensorProto.COMPLEX128):
data = combine_pairs_to_complex(data)
return (
np.asarray(
data,
dtype=storage_np_dtype)
.astype(np_dtype)
.reshape(dims)
)
|
python
|
def to_array(tensor): # type: (TensorProto) -> np.ndarray[Any]
"""Converts a tensor def object to a numpy array.
Inputs:
tensor: a TensorProto object.
Returns:
arr: the converted array.
"""
if tensor.HasField("segment"):
raise ValueError(
"Currently not supporting loading segments.")
if tensor.data_type == TensorProto.UNDEFINED:
raise ValueError("The data type is not defined.")
tensor_dtype = tensor.data_type
np_dtype = mapping.TENSOR_TYPE_TO_NP_TYPE[tensor_dtype]
storage_type = mapping.TENSOR_TYPE_TO_STORAGE_TENSOR_TYPE[tensor_dtype]
storage_np_dtype = mapping.TENSOR_TYPE_TO_NP_TYPE[storage_type]
storage_field = mapping.STORAGE_TENSOR_TYPE_TO_FIELD[storage_type]
dims = tensor.dims
if tensor.data_type == TensorProto.STRING:
utf8_strings = getattr(tensor, storage_field)
ss = list(s.decode('utf-8') for s in utf8_strings)
return np.asarray(ss).astype(np_dtype).reshape(dims)
if tensor.HasField("raw_data"):
# Raw_bytes support: using frombuffer.
return np.frombuffer(
tensor.raw_data,
dtype=np_dtype).reshape(dims)
else:
data = getattr(tensor, storage_field), # type: Sequence[np.complex64]
if (tensor_dtype == TensorProto.COMPLEX64
or tensor_dtype == TensorProto.COMPLEX128):
data = combine_pairs_to_complex(data)
return (
np.asarray(
data,
dtype=storage_np_dtype)
.astype(np_dtype)
.reshape(dims)
)
|
[
"def",
"to_array",
"(",
"tensor",
")",
":",
"# type: (TensorProto) -> np.ndarray[Any]",
"if",
"tensor",
".",
"HasField",
"(",
"\"segment\"",
")",
":",
"raise",
"ValueError",
"(",
"\"Currently not supporting loading segments.\"",
")",
"if",
"tensor",
".",
"data_type",
"==",
"TensorProto",
".",
"UNDEFINED",
":",
"raise",
"ValueError",
"(",
"\"The data type is not defined.\"",
")",
"tensor_dtype",
"=",
"tensor",
".",
"data_type",
"np_dtype",
"=",
"mapping",
".",
"TENSOR_TYPE_TO_NP_TYPE",
"[",
"tensor_dtype",
"]",
"storage_type",
"=",
"mapping",
".",
"TENSOR_TYPE_TO_STORAGE_TENSOR_TYPE",
"[",
"tensor_dtype",
"]",
"storage_np_dtype",
"=",
"mapping",
".",
"TENSOR_TYPE_TO_NP_TYPE",
"[",
"storage_type",
"]",
"storage_field",
"=",
"mapping",
".",
"STORAGE_TENSOR_TYPE_TO_FIELD",
"[",
"storage_type",
"]",
"dims",
"=",
"tensor",
".",
"dims",
"if",
"tensor",
".",
"data_type",
"==",
"TensorProto",
".",
"STRING",
":",
"utf8_strings",
"=",
"getattr",
"(",
"tensor",
",",
"storage_field",
")",
"ss",
"=",
"list",
"(",
"s",
".",
"decode",
"(",
"'utf-8'",
")",
"for",
"s",
"in",
"utf8_strings",
")",
"return",
"np",
".",
"asarray",
"(",
"ss",
")",
".",
"astype",
"(",
"np_dtype",
")",
".",
"reshape",
"(",
"dims",
")",
"if",
"tensor",
".",
"HasField",
"(",
"\"raw_data\"",
")",
":",
"# Raw_bytes support: using frombuffer.",
"return",
"np",
".",
"frombuffer",
"(",
"tensor",
".",
"raw_data",
",",
"dtype",
"=",
"np_dtype",
")",
".",
"reshape",
"(",
"dims",
")",
"else",
":",
"data",
"=",
"getattr",
"(",
"tensor",
",",
"storage_field",
")",
",",
"# type: Sequence[np.complex64]",
"if",
"(",
"tensor_dtype",
"==",
"TensorProto",
".",
"COMPLEX64",
"or",
"tensor_dtype",
"==",
"TensorProto",
".",
"COMPLEX128",
")",
":",
"data",
"=",
"combine_pairs_to_complex",
"(",
"data",
")",
"return",
"(",
"np",
".",
"asarray",
"(",
"data",
",",
"dtype",
"=",
"storage_np_dtype",
")",
".",
"astype",
"(",
"np_dtype",
")",
".",
"reshape",
"(",
"dims",
")",
")"
] |
Converts a tensor def object to a numpy array.
Inputs:
tensor: a TensorProto object.
Returns:
arr: the converted array.
|
[
"Converts",
"a",
"tensor",
"def",
"object",
"to",
"a",
"numpy",
"array",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/numpy_helper.py#L24-L66
|
train
|
onnx/onnx
|
onnx/numpy_helper.py
|
from_array
|
def from_array(arr, name=None): # type: (np.ndarray[Any], Optional[Text]) -> TensorProto
"""Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
"""
tensor = TensorProto()
tensor.dims.extend(arr.shape)
if name:
tensor.name = name
if arr.dtype == np.object:
# Special care for strings.
tensor.data_type = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
# TODO: Introduce full string support.
# We flatten the array in case there are 2-D arrays are specified
# We throw the error below if we have a 3-D array or some kind of other
# object. If you want more complex shapes then follow the below instructions.
# Unlike other types where the shape is automatically inferred from
# nested arrays of values, the only reliable way now to feed strings
# is to put them into a flat array then specify type astype(np.object)
# (otherwise all strings may have different types depending on their length)
# and then specify shape .reshape([x, y, z])
flat_array = arr.flatten()
for e in flat_array:
if isinstance(e, text_type):
tensor.string_data.append(e.encode('utf-8'))
elif isinstance(e, np.ndarray):
for s in e:
if isinstance(s, text_type):
tensor.string_data.append(s.encode('utf-8'))
else:
raise NotImplementedError(
"Unrecognized object in the object array, expect a string, or array of bytes: ", str(type(e)))
return tensor
# For numerical types, directly use numpy raw bytes.
try:
dtype = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
except KeyError:
raise RuntimeError(
"Numpy data type not understood yet: {}".format(str(arr.dtype)))
tensor.data_type = dtype
tensor.raw_data = arr.tobytes() # note: tobytes() is only after 1.9.
return tensor
|
python
|
def from_array(arr, name=None): # type: (np.ndarray[Any], Optional[Text]) -> TensorProto
"""Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
"""
tensor = TensorProto()
tensor.dims.extend(arr.shape)
if name:
tensor.name = name
if arr.dtype == np.object:
# Special care for strings.
tensor.data_type = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
# TODO: Introduce full string support.
# We flatten the array in case there are 2-D arrays are specified
# We throw the error below if we have a 3-D array or some kind of other
# object. If you want more complex shapes then follow the below instructions.
# Unlike other types where the shape is automatically inferred from
# nested arrays of values, the only reliable way now to feed strings
# is to put them into a flat array then specify type astype(np.object)
# (otherwise all strings may have different types depending on their length)
# and then specify shape .reshape([x, y, z])
flat_array = arr.flatten()
for e in flat_array:
if isinstance(e, text_type):
tensor.string_data.append(e.encode('utf-8'))
elif isinstance(e, np.ndarray):
for s in e:
if isinstance(s, text_type):
tensor.string_data.append(s.encode('utf-8'))
else:
raise NotImplementedError(
"Unrecognized object in the object array, expect a string, or array of bytes: ", str(type(e)))
return tensor
# For numerical types, directly use numpy raw bytes.
try:
dtype = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
except KeyError:
raise RuntimeError(
"Numpy data type not understood yet: {}".format(str(arr.dtype)))
tensor.data_type = dtype
tensor.raw_data = arr.tobytes() # note: tobytes() is only after 1.9.
return tensor
|
[
"def",
"from_array",
"(",
"arr",
",",
"name",
"=",
"None",
")",
":",
"# type: (np.ndarray[Any], Optional[Text]) -> TensorProto",
"tensor",
"=",
"TensorProto",
"(",
")",
"tensor",
".",
"dims",
".",
"extend",
"(",
"arr",
".",
"shape",
")",
"if",
"name",
":",
"tensor",
".",
"name",
"=",
"name",
"if",
"arr",
".",
"dtype",
"==",
"np",
".",
"object",
":",
"# Special care for strings.",
"tensor",
".",
"data_type",
"=",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"arr",
".",
"dtype",
"]",
"# TODO: Introduce full string support.",
"# We flatten the array in case there are 2-D arrays are specified",
"# We throw the error below if we have a 3-D array or some kind of other",
"# object. If you want more complex shapes then follow the below instructions.",
"# Unlike other types where the shape is automatically inferred from",
"# nested arrays of values, the only reliable way now to feed strings",
"# is to put them into a flat array then specify type astype(np.object)",
"# (otherwise all strings may have different types depending on their length)",
"# and then specify shape .reshape([x, y, z])",
"flat_array",
"=",
"arr",
".",
"flatten",
"(",
")",
"for",
"e",
"in",
"flat_array",
":",
"if",
"isinstance",
"(",
"e",
",",
"text_type",
")",
":",
"tensor",
".",
"string_data",
".",
"append",
"(",
"e",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"elif",
"isinstance",
"(",
"e",
",",
"np",
".",
"ndarray",
")",
":",
"for",
"s",
"in",
"e",
":",
"if",
"isinstance",
"(",
"s",
",",
"text_type",
")",
":",
"tensor",
".",
"string_data",
".",
"append",
"(",
"s",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"else",
":",
"raise",
"NotImplementedError",
"(",
"\"Unrecognized object in the object array, expect a string, or array of bytes: \"",
",",
"str",
"(",
"type",
"(",
"e",
")",
")",
")",
"return",
"tensor",
"# For numerical types, directly use numpy raw bytes.",
"try",
":",
"dtype",
"=",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"arr",
".",
"dtype",
"]",
"except",
"KeyError",
":",
"raise",
"RuntimeError",
"(",
"\"Numpy data type not understood yet: {}\"",
".",
"format",
"(",
"str",
"(",
"arr",
".",
"dtype",
")",
")",
")",
"tensor",
".",
"data_type",
"=",
"dtype",
"tensor",
".",
"raw_data",
"=",
"arr",
".",
"tobytes",
"(",
")",
"# note: tobytes() is only after 1.9.",
"return",
"tensor"
] |
Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
|
[
"Converts",
"a",
"numpy",
"array",
"to",
"a",
"tensor",
"def",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/numpy_helper.py#L69-L117
|
train
|
onnx/onnx
|
onnx/__init__.py
|
_serialize
|
def _serialize(proto): # type: (Union[bytes, google.protobuf.message.Message]) -> bytes
'''
Serialize a in-memory proto to bytes
@params
proto is a in-memory proto, such as a ModelProto, TensorProto, etc
@return
Serialized proto in bytes
'''
if isinstance(proto, bytes):
return proto
elif hasattr(proto, 'SerializeToString') and callable(proto.SerializeToString):
result = proto.SerializeToString()
return result
else:
raise ValueError('No SerializeToString method is detected. '
'neither proto is a str.\ntype is {}'.format(type(proto)))
|
python
|
def _serialize(proto): # type: (Union[bytes, google.protobuf.message.Message]) -> bytes
'''
Serialize a in-memory proto to bytes
@params
proto is a in-memory proto, such as a ModelProto, TensorProto, etc
@return
Serialized proto in bytes
'''
if isinstance(proto, bytes):
return proto
elif hasattr(proto, 'SerializeToString') and callable(proto.SerializeToString):
result = proto.SerializeToString()
return result
else:
raise ValueError('No SerializeToString method is detected. '
'neither proto is a str.\ntype is {}'.format(type(proto)))
|
[
"def",
"_serialize",
"(",
"proto",
")",
":",
"# type: (Union[bytes, google.protobuf.message.Message]) -> bytes",
"if",
"isinstance",
"(",
"proto",
",",
"bytes",
")",
":",
"return",
"proto",
"elif",
"hasattr",
"(",
"proto",
",",
"'SerializeToString'",
")",
"and",
"callable",
"(",
"proto",
".",
"SerializeToString",
")",
":",
"result",
"=",
"proto",
".",
"SerializeToString",
"(",
")",
"return",
"result",
"else",
":",
"raise",
"ValueError",
"(",
"'No SerializeToString method is detected. '",
"'neither proto is a str.\\ntype is {}'",
".",
"format",
"(",
"type",
"(",
"proto",
")",
")",
")"
] |
Serialize a in-memory proto to bytes
@params
proto is a in-memory proto, such as a ModelProto, TensorProto, etc
@return
Serialized proto in bytes
|
[
"Serialize",
"a",
"in",
"-",
"memory",
"proto",
"to",
"bytes"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/__init__.py#L53-L70
|
train
|
onnx/onnx
|
onnx/__init__.py
|
_deserialize
|
def _deserialize(s, proto): # type: (bytes, _Proto) -> _Proto
'''
Parse bytes into a in-memory proto
@params
s is bytes containing serialized proto
proto is a in-memory proto object
@return
The proto instance filled in by s
'''
if not isinstance(s, bytes):
raise ValueError('Parameter s must be bytes, but got type: {}'.format(type(s)))
if not (hasattr(proto, 'ParseFromString') and callable(proto.ParseFromString)):
raise ValueError('No ParseFromString method is detected. '
'\ntype is {}'.format(type(proto)))
decoded = cast(Optional[int], proto.ParseFromString(s))
if decoded is not None and decoded != len(s):
raise google.protobuf.message.DecodeError(
"Protobuf decoding consumed too few bytes: {} out of {}".format(
decoded, len(s)))
return proto
|
python
|
def _deserialize(s, proto): # type: (bytes, _Proto) -> _Proto
'''
Parse bytes into a in-memory proto
@params
s is bytes containing serialized proto
proto is a in-memory proto object
@return
The proto instance filled in by s
'''
if not isinstance(s, bytes):
raise ValueError('Parameter s must be bytes, but got type: {}'.format(type(s)))
if not (hasattr(proto, 'ParseFromString') and callable(proto.ParseFromString)):
raise ValueError('No ParseFromString method is detected. '
'\ntype is {}'.format(type(proto)))
decoded = cast(Optional[int], proto.ParseFromString(s))
if decoded is not None and decoded != len(s):
raise google.protobuf.message.DecodeError(
"Protobuf decoding consumed too few bytes: {} out of {}".format(
decoded, len(s)))
return proto
|
[
"def",
"_deserialize",
"(",
"s",
",",
"proto",
")",
":",
"# type: (bytes, _Proto) -> _Proto",
"if",
"not",
"isinstance",
"(",
"s",
",",
"bytes",
")",
":",
"raise",
"ValueError",
"(",
"'Parameter s must be bytes, but got type: {}'",
".",
"format",
"(",
"type",
"(",
"s",
")",
")",
")",
"if",
"not",
"(",
"hasattr",
"(",
"proto",
",",
"'ParseFromString'",
")",
"and",
"callable",
"(",
"proto",
".",
"ParseFromString",
")",
")",
":",
"raise",
"ValueError",
"(",
"'No ParseFromString method is detected. '",
"'\\ntype is {}'",
".",
"format",
"(",
"type",
"(",
"proto",
")",
")",
")",
"decoded",
"=",
"cast",
"(",
"Optional",
"[",
"int",
"]",
",",
"proto",
".",
"ParseFromString",
"(",
"s",
")",
")",
"if",
"decoded",
"is",
"not",
"None",
"and",
"decoded",
"!=",
"len",
"(",
"s",
")",
":",
"raise",
"google",
".",
"protobuf",
".",
"message",
".",
"DecodeError",
"(",
"\"Protobuf decoding consumed too few bytes: {} out of {}\"",
".",
"format",
"(",
"decoded",
",",
"len",
"(",
"s",
")",
")",
")",
"return",
"proto"
] |
Parse bytes into a in-memory proto
@params
s is bytes containing serialized proto
proto is a in-memory proto object
@return
The proto instance filled in by s
|
[
"Parse",
"bytes",
"into",
"a",
"in",
"-",
"memory",
"proto"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/__init__.py#L76-L99
|
train
|
onnx/onnx
|
onnx/__init__.py
|
load_model
|
def load_model(f, format=None, load_external_data=True): # type: (Union[IO[bytes], Text], Optional[Any], bool) -> ModelProto
'''
Loads a serialized ModelProto into memory
@params
f can be a file-like object (has "read" function) or a string containing a file name
format is for future use
@return
Loaded in-memory ModelProto
'''
s = _load_bytes(f)
model = load_model_from_string(s, format=format)
if load_external_data:
model_filepath = _get_file_path(f)
if model_filepath:
base_dir = os.path.dirname(model_filepath)
load_external_data_for_model(model, base_dir)
return model
|
python
|
def load_model(f, format=None, load_external_data=True): # type: (Union[IO[bytes], Text], Optional[Any], bool) -> ModelProto
'''
Loads a serialized ModelProto into memory
@params
f can be a file-like object (has "read" function) or a string containing a file name
format is for future use
@return
Loaded in-memory ModelProto
'''
s = _load_bytes(f)
model = load_model_from_string(s, format=format)
if load_external_data:
model_filepath = _get_file_path(f)
if model_filepath:
base_dir = os.path.dirname(model_filepath)
load_external_data_for_model(model, base_dir)
return model
|
[
"def",
"load_model",
"(",
"f",
",",
"format",
"=",
"None",
",",
"load_external_data",
"=",
"True",
")",
":",
"# type: (Union[IO[bytes], Text], Optional[Any], bool) -> ModelProto",
"s",
"=",
"_load_bytes",
"(",
"f",
")",
"model",
"=",
"load_model_from_string",
"(",
"s",
",",
"format",
"=",
"format",
")",
"if",
"load_external_data",
":",
"model_filepath",
"=",
"_get_file_path",
"(",
"f",
")",
"if",
"model_filepath",
":",
"base_dir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"model_filepath",
")",
"load_external_data_for_model",
"(",
"model",
",",
"base_dir",
")",
"return",
"model"
] |
Loads a serialized ModelProto into memory
@params
f can be a file-like object (has "read" function) or a string containing a file name
format is for future use
@return
Loaded in-memory ModelProto
|
[
"Loads",
"a",
"serialized",
"ModelProto",
"into",
"memory"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/__init__.py#L102-L122
|
train
|
onnx/onnx
|
onnx/__init__.py
|
load_tensor
|
def load_tensor(f, format=None): # type: (Union[IO[bytes], Text], Optional[Any]) -> TensorProto
'''
Loads a serialized TensorProto into memory
@params
f can be a file-like object (has "read" function) or a string containing a file name
format is for future use
@return
Loaded in-memory TensorProto
'''
s = _load_bytes(f)
return load_tensor_from_string(s, format=format)
|
python
|
def load_tensor(f, format=None): # type: (Union[IO[bytes], Text], Optional[Any]) -> TensorProto
'''
Loads a serialized TensorProto into memory
@params
f can be a file-like object (has "read" function) or a string containing a file name
format is for future use
@return
Loaded in-memory TensorProto
'''
s = _load_bytes(f)
return load_tensor_from_string(s, format=format)
|
[
"def",
"load_tensor",
"(",
"f",
",",
"format",
"=",
"None",
")",
":",
"# type: (Union[IO[bytes], Text], Optional[Any]) -> TensorProto",
"s",
"=",
"_load_bytes",
"(",
"f",
")",
"return",
"load_tensor_from_string",
"(",
"s",
",",
"format",
"=",
"format",
")"
] |
Loads a serialized TensorProto into memory
@params
f can be a file-like object (has "read" function) or a string containing a file name
format is for future use
@return
Loaded in-memory TensorProto
|
[
"Loads",
"a",
"serialized",
"TensorProto",
"into",
"memory"
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/__init__.py#L125-L137
|
train
|
onnx/onnx
|
onnx/__init__.py
|
save_model
|
def save_model(proto, f, format=None): # type: (Union[ModelProto, bytes], Union[IO[bytes], Text], Optional[Any]) -> None
'''
Saves the ModelProto to the specified path.
@params
proto should be a in-memory ModelProto
f can be a file-like object (has "write" function) or a string containing a file name
format is for future use
'''
if isinstance(proto, bytes):
proto = _deserialize(proto, ModelProto())
model_filepath = _get_file_path(f)
if model_filepath:
basepath = os.path.dirname(model_filepath)
proto = write_external_data_tensors(proto, basepath)
s = _serialize(proto)
_save_bytes(s, f)
|
python
|
def save_model(proto, f, format=None): # type: (Union[ModelProto, bytes], Union[IO[bytes], Text], Optional[Any]) -> None
'''
Saves the ModelProto to the specified path.
@params
proto should be a in-memory ModelProto
f can be a file-like object (has "write" function) or a string containing a file name
format is for future use
'''
if isinstance(proto, bytes):
proto = _deserialize(proto, ModelProto())
model_filepath = _get_file_path(f)
if model_filepath:
basepath = os.path.dirname(model_filepath)
proto = write_external_data_tensors(proto, basepath)
s = _serialize(proto)
_save_bytes(s, f)
|
[
"def",
"save_model",
"(",
"proto",
",",
"f",
",",
"format",
"=",
"None",
")",
":",
"# type: (Union[ModelProto, bytes], Union[IO[bytes], Text], Optional[Any]) -> None",
"if",
"isinstance",
"(",
"proto",
",",
"bytes",
")",
":",
"proto",
"=",
"_deserialize",
"(",
"proto",
",",
"ModelProto",
"(",
")",
")",
"model_filepath",
"=",
"_get_file_path",
"(",
"f",
")",
"if",
"model_filepath",
":",
"basepath",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"model_filepath",
")",
"proto",
"=",
"write_external_data_tensors",
"(",
"proto",
",",
"basepath",
")",
"s",
"=",
"_serialize",
"(",
"proto",
")",
"_save_bytes",
"(",
"s",
",",
"f",
")"
] |
Saves the ModelProto to the specified path.
@params
proto should be a in-memory ModelProto
f can be a file-like object (has "write" function) or a string containing a file name
format is for future use
|
[
"Saves",
"the",
"ModelProto",
"to",
"the",
"specified",
"path",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/__init__.py#L168-L186
|
train
|
onnx/onnx
|
onnx/utils.py
|
polish_model
|
def polish_model(model): # type: (ModelProto) -> ModelProto
'''
This function combines several useful utility functions together.
'''
onnx.checker.check_model(model)
onnx.helper.strip_doc_string(model)
model = onnx.shape_inference.infer_shapes(model)
model = onnx.optimizer.optimize(model)
onnx.checker.check_model(model)
return model
|
python
|
def polish_model(model): # type: (ModelProto) -> ModelProto
'''
This function combines several useful utility functions together.
'''
onnx.checker.check_model(model)
onnx.helper.strip_doc_string(model)
model = onnx.shape_inference.infer_shapes(model)
model = onnx.optimizer.optimize(model)
onnx.checker.check_model(model)
return model
|
[
"def",
"polish_model",
"(",
"model",
")",
":",
"# type: (ModelProto) -> ModelProto",
"onnx",
".",
"checker",
".",
"check_model",
"(",
"model",
")",
"onnx",
".",
"helper",
".",
"strip_doc_string",
"(",
"model",
")",
"model",
"=",
"onnx",
".",
"shape_inference",
".",
"infer_shapes",
"(",
"model",
")",
"model",
"=",
"onnx",
".",
"optimizer",
".",
"optimize",
"(",
"model",
")",
"onnx",
".",
"checker",
".",
"check_model",
"(",
"model",
")",
"return",
"model"
] |
This function combines several useful utility functions together.
|
[
"This",
"function",
"combines",
"several",
"useful",
"utility",
"functions",
"together",
"."
] |
2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4
|
https://github.com/onnx/onnx/blob/2f7dc10f03a072526d94b6820cedbf2a1ec5a2c4/onnx/utils.py#L14-L23
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/contrib/rnn/rnn_cell.py
|
dynamic_unroll
|
def dynamic_unroll(cell, inputs, begin_state, drop_inputs=0, drop_outputs=0,
layout='TNC', valid_length=None):
"""Unrolls an RNN cell across time steps.
Currently, 'TNC' is a preferred layout. unroll on the input of this layout
runs much faster.
Parameters
----------
cell : an object whose base class is RNNCell.
The RNN cell to run on the input sequence.
inputs : Symbol
It should have shape (batch_size, length, ...) if `layout` is 'NTC',
or (length, batch_size, ...) if `layout` is 'TNC'.
begin_state : nested list of Symbol
The initial states of the RNN sequence.
drop_inputs : float, default 0.
The dropout rate for inputs. Won't apply dropout if it equals 0.
drop_outputs : float, default 0.
The dropout rate for outputs. Won't apply dropout if it equals 0.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
valid_length : Symbol, NDArray or None
`valid_length` specifies the length of the sequences in the batch without padding.
This option is especially useful for building sequence-to-sequence models where
the input and output sequences would potentially be padded.
If `valid_length` is None, all sequences are assumed to have the same length.
If `valid_length` is a Symbol or NDArray, it should have shape (batch_size,).
The ith element will be the length of the ith sequence in the batch.
The last valid state will be return and the padded outputs will be masked with 0.
Note that `valid_length` must be smaller or equal to `length`.
Returns
-------
outputs : Symbol
the output of the RNN from this unrolling.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state`.
Examples
--------
>>> seq_len = 3
>>> batch_size = 2
>>> input_size = 5
>>> cell = mx.gluon.rnn.LSTMCell(input_size, prefix='rnn_')
>>> cell.initialize(ctx=mx.cpu())
>>> rnn_data = mx.nd.normal(loc=0, scale=1, shape=(seq_len, batch_size, input_size))
>>> state_shape = (batch_size, input_size)
>>> states = [mx.nd.normal(loc=0, scale=1, shape=state_shape) for i in range(2)]
>>> valid_length = mx.nd.array([2, 3])
>>> output, states = mx.gluon.contrib.rnn.rnn_cell.dynamic_unroll(cell, rnn_data, states,
valid_length=valid_length,
layout='TNC')
>>> print(output)
[[[ 0.00767238 0.00023103 0.03973929 -0.00925503 -0.05660512]
[ 0.00881535 0.05428379 -0.02493718 -0.01834097 0.02189514]]
[[-0.00676967 0.01447039 0.01287002 -0.00574152 -0.05734247]
[ 0.01568508 0.02650866 -0.04270559 -0.04328435 0.00904011]]
[[ 0. 0. 0. 0. 0. ]
[ 0.01055336 0.02734251 -0.03153727 -0.03742751 -0.01378113]]]
<NDArray 3x2x5 @cpu(0)>
"""
# Merge is always True, so we don't need length.
inputs, axis, F, _ = _format_sequence(0, inputs, layout, True)
if axis != 0:
axes = list(range(len(layout)))
tmp = axes[0]
axes[0] = axes[axis]
axes[axis] = tmp
inputs = F.transpose(inputs, axes=axes)
states = begin_state
if drop_inputs:
inputs = F.Dropout(inputs, p=drop_inputs, axes=(axis,))
if valid_length is None:
def loop_body(inputs, states):
return cell(inputs, states)
else:
zeros = []
for s in states:
zeros.append(F.zeros_like(s))
states = list(_as_list(states))
states.append(F.zeros((1)))
def loop_body(inputs, states):
cell_states = states[:-1]
iter_no = states[-1]
out, new_states = cell(inputs, cell_states)
for i, state in enumerate(cell_states):
new_states[i] = F.where(F.broadcast_greater(valid_length, iter_no),
new_states[i], state)
new_states.append(iter_no + 1)
return out, new_states
outputs, states = F.contrib.foreach(loop_body, inputs, states)
if drop_outputs:
outputs = F.Dropout(outputs, p=drop_outputs, axes=(axis,))
if valid_length is not None:
if axis != 0:
outputs = F.transpose(outputs, axes)
outputs = F.SequenceMask(outputs, sequence_length=valid_length,
use_sequence_length=True, axis=axis)
# the last state is the iteration number. We don't need it.
return outputs, states[:-1]
else:
if axis != 0:
outputs = F.transpose(outputs, axes)
return outputs, states
|
python
|
def dynamic_unroll(cell, inputs, begin_state, drop_inputs=0, drop_outputs=0,
layout='TNC', valid_length=None):
"""Unrolls an RNN cell across time steps.
Currently, 'TNC' is a preferred layout. unroll on the input of this layout
runs much faster.
Parameters
----------
cell : an object whose base class is RNNCell.
The RNN cell to run on the input sequence.
inputs : Symbol
It should have shape (batch_size, length, ...) if `layout` is 'NTC',
or (length, batch_size, ...) if `layout` is 'TNC'.
begin_state : nested list of Symbol
The initial states of the RNN sequence.
drop_inputs : float, default 0.
The dropout rate for inputs. Won't apply dropout if it equals 0.
drop_outputs : float, default 0.
The dropout rate for outputs. Won't apply dropout if it equals 0.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
valid_length : Symbol, NDArray or None
`valid_length` specifies the length of the sequences in the batch without padding.
This option is especially useful for building sequence-to-sequence models where
the input and output sequences would potentially be padded.
If `valid_length` is None, all sequences are assumed to have the same length.
If `valid_length` is a Symbol or NDArray, it should have shape (batch_size,).
The ith element will be the length of the ith sequence in the batch.
The last valid state will be return and the padded outputs will be masked with 0.
Note that `valid_length` must be smaller or equal to `length`.
Returns
-------
outputs : Symbol
the output of the RNN from this unrolling.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state`.
Examples
--------
>>> seq_len = 3
>>> batch_size = 2
>>> input_size = 5
>>> cell = mx.gluon.rnn.LSTMCell(input_size, prefix='rnn_')
>>> cell.initialize(ctx=mx.cpu())
>>> rnn_data = mx.nd.normal(loc=0, scale=1, shape=(seq_len, batch_size, input_size))
>>> state_shape = (batch_size, input_size)
>>> states = [mx.nd.normal(loc=0, scale=1, shape=state_shape) for i in range(2)]
>>> valid_length = mx.nd.array([2, 3])
>>> output, states = mx.gluon.contrib.rnn.rnn_cell.dynamic_unroll(cell, rnn_data, states,
valid_length=valid_length,
layout='TNC')
>>> print(output)
[[[ 0.00767238 0.00023103 0.03973929 -0.00925503 -0.05660512]
[ 0.00881535 0.05428379 -0.02493718 -0.01834097 0.02189514]]
[[-0.00676967 0.01447039 0.01287002 -0.00574152 -0.05734247]
[ 0.01568508 0.02650866 -0.04270559 -0.04328435 0.00904011]]
[[ 0. 0. 0. 0. 0. ]
[ 0.01055336 0.02734251 -0.03153727 -0.03742751 -0.01378113]]]
<NDArray 3x2x5 @cpu(0)>
"""
# Merge is always True, so we don't need length.
inputs, axis, F, _ = _format_sequence(0, inputs, layout, True)
if axis != 0:
axes = list(range(len(layout)))
tmp = axes[0]
axes[0] = axes[axis]
axes[axis] = tmp
inputs = F.transpose(inputs, axes=axes)
states = begin_state
if drop_inputs:
inputs = F.Dropout(inputs, p=drop_inputs, axes=(axis,))
if valid_length is None:
def loop_body(inputs, states):
return cell(inputs, states)
else:
zeros = []
for s in states:
zeros.append(F.zeros_like(s))
states = list(_as_list(states))
states.append(F.zeros((1)))
def loop_body(inputs, states):
cell_states = states[:-1]
iter_no = states[-1]
out, new_states = cell(inputs, cell_states)
for i, state in enumerate(cell_states):
new_states[i] = F.where(F.broadcast_greater(valid_length, iter_no),
new_states[i], state)
new_states.append(iter_no + 1)
return out, new_states
outputs, states = F.contrib.foreach(loop_body, inputs, states)
if drop_outputs:
outputs = F.Dropout(outputs, p=drop_outputs, axes=(axis,))
if valid_length is not None:
if axis != 0:
outputs = F.transpose(outputs, axes)
outputs = F.SequenceMask(outputs, sequence_length=valid_length,
use_sequence_length=True, axis=axis)
# the last state is the iteration number. We don't need it.
return outputs, states[:-1]
else:
if axis != 0:
outputs = F.transpose(outputs, axes)
return outputs, states
|
[
"def",
"dynamic_unroll",
"(",
"cell",
",",
"inputs",
",",
"begin_state",
",",
"drop_inputs",
"=",
"0",
",",
"drop_outputs",
"=",
"0",
",",
"layout",
"=",
"'TNC'",
",",
"valid_length",
"=",
"None",
")",
":",
"# Merge is always True, so we don't need length.",
"inputs",
",",
"axis",
",",
"F",
",",
"_",
"=",
"_format_sequence",
"(",
"0",
",",
"inputs",
",",
"layout",
",",
"True",
")",
"if",
"axis",
"!=",
"0",
":",
"axes",
"=",
"list",
"(",
"range",
"(",
"len",
"(",
"layout",
")",
")",
")",
"tmp",
"=",
"axes",
"[",
"0",
"]",
"axes",
"[",
"0",
"]",
"=",
"axes",
"[",
"axis",
"]",
"axes",
"[",
"axis",
"]",
"=",
"tmp",
"inputs",
"=",
"F",
".",
"transpose",
"(",
"inputs",
",",
"axes",
"=",
"axes",
")",
"states",
"=",
"begin_state",
"if",
"drop_inputs",
":",
"inputs",
"=",
"F",
".",
"Dropout",
"(",
"inputs",
",",
"p",
"=",
"drop_inputs",
",",
"axes",
"=",
"(",
"axis",
",",
")",
")",
"if",
"valid_length",
"is",
"None",
":",
"def",
"loop_body",
"(",
"inputs",
",",
"states",
")",
":",
"return",
"cell",
"(",
"inputs",
",",
"states",
")",
"else",
":",
"zeros",
"=",
"[",
"]",
"for",
"s",
"in",
"states",
":",
"zeros",
".",
"append",
"(",
"F",
".",
"zeros_like",
"(",
"s",
")",
")",
"states",
"=",
"list",
"(",
"_as_list",
"(",
"states",
")",
")",
"states",
".",
"append",
"(",
"F",
".",
"zeros",
"(",
"(",
"1",
")",
")",
")",
"def",
"loop_body",
"(",
"inputs",
",",
"states",
")",
":",
"cell_states",
"=",
"states",
"[",
":",
"-",
"1",
"]",
"iter_no",
"=",
"states",
"[",
"-",
"1",
"]",
"out",
",",
"new_states",
"=",
"cell",
"(",
"inputs",
",",
"cell_states",
")",
"for",
"i",
",",
"state",
"in",
"enumerate",
"(",
"cell_states",
")",
":",
"new_states",
"[",
"i",
"]",
"=",
"F",
".",
"where",
"(",
"F",
".",
"broadcast_greater",
"(",
"valid_length",
",",
"iter_no",
")",
",",
"new_states",
"[",
"i",
"]",
",",
"state",
")",
"new_states",
".",
"append",
"(",
"iter_no",
"+",
"1",
")",
"return",
"out",
",",
"new_states",
"outputs",
",",
"states",
"=",
"F",
".",
"contrib",
".",
"foreach",
"(",
"loop_body",
",",
"inputs",
",",
"states",
")",
"if",
"drop_outputs",
":",
"outputs",
"=",
"F",
".",
"Dropout",
"(",
"outputs",
",",
"p",
"=",
"drop_outputs",
",",
"axes",
"=",
"(",
"axis",
",",
")",
")",
"if",
"valid_length",
"is",
"not",
"None",
":",
"if",
"axis",
"!=",
"0",
":",
"outputs",
"=",
"F",
".",
"transpose",
"(",
"outputs",
",",
"axes",
")",
"outputs",
"=",
"F",
".",
"SequenceMask",
"(",
"outputs",
",",
"sequence_length",
"=",
"valid_length",
",",
"use_sequence_length",
"=",
"True",
",",
"axis",
"=",
"axis",
")",
"# the last state is the iteration number. We don't need it.",
"return",
"outputs",
",",
"states",
"[",
":",
"-",
"1",
"]",
"else",
":",
"if",
"axis",
"!=",
"0",
":",
"outputs",
"=",
"F",
".",
"transpose",
"(",
"outputs",
",",
"axes",
")",
"return",
"outputs",
",",
"states"
] |
Unrolls an RNN cell across time steps.
Currently, 'TNC' is a preferred layout. unroll on the input of this layout
runs much faster.
Parameters
----------
cell : an object whose base class is RNNCell.
The RNN cell to run on the input sequence.
inputs : Symbol
It should have shape (batch_size, length, ...) if `layout` is 'NTC',
or (length, batch_size, ...) if `layout` is 'TNC'.
begin_state : nested list of Symbol
The initial states of the RNN sequence.
drop_inputs : float, default 0.
The dropout rate for inputs. Won't apply dropout if it equals 0.
drop_outputs : float, default 0.
The dropout rate for outputs. Won't apply dropout if it equals 0.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
valid_length : Symbol, NDArray or None
`valid_length` specifies the length of the sequences in the batch without padding.
This option is especially useful for building sequence-to-sequence models where
the input and output sequences would potentially be padded.
If `valid_length` is None, all sequences are assumed to have the same length.
If `valid_length` is a Symbol or NDArray, it should have shape (batch_size,).
The ith element will be the length of the ith sequence in the batch.
The last valid state will be return and the padded outputs will be masked with 0.
Note that `valid_length` must be smaller or equal to `length`.
Returns
-------
outputs : Symbol
the output of the RNN from this unrolling.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state`.
Examples
--------
>>> seq_len = 3
>>> batch_size = 2
>>> input_size = 5
>>> cell = mx.gluon.rnn.LSTMCell(input_size, prefix='rnn_')
>>> cell.initialize(ctx=mx.cpu())
>>> rnn_data = mx.nd.normal(loc=0, scale=1, shape=(seq_len, batch_size, input_size))
>>> state_shape = (batch_size, input_size)
>>> states = [mx.nd.normal(loc=0, scale=1, shape=state_shape) for i in range(2)]
>>> valid_length = mx.nd.array([2, 3])
>>> output, states = mx.gluon.contrib.rnn.rnn_cell.dynamic_unroll(cell, rnn_data, states,
valid_length=valid_length,
layout='TNC')
>>> print(output)
[[[ 0.00767238 0.00023103 0.03973929 -0.00925503 -0.05660512]
[ 0.00881535 0.05428379 -0.02493718 -0.01834097 0.02189514]]
[[-0.00676967 0.01447039 0.01287002 -0.00574152 -0.05734247]
[ 0.01568508 0.02650866 -0.04270559 -0.04328435 0.00904011]]
[[ 0. 0. 0. 0. 0. ]
[ 0.01055336 0.02734251 -0.03153727 -0.03742751 -0.01378113]]]
<NDArray 3x2x5 @cpu(0)>
|
[
"Unrolls",
"an",
"RNN",
"cell",
"across",
"time",
"steps",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/contrib/rnn/rnn_cell.py#L326-L437
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/contrib/rnn/rnn_cell.py
|
VariationalDropoutCell.unroll
|
def unroll(self, length, inputs, begin_state=None, layout='NTC', merge_outputs=None,
valid_length=None):
"""Unrolls an RNN cell across time steps.
Parameters
----------
length : int
Number of steps to unroll.
inputs : Symbol, list of Symbol, or None
If `inputs` is a single Symbol (usually the output
of Embedding symbol), it should have shape
(batch_size, length, ...) if `layout` is 'NTC',
or (length, batch_size, ...) if `layout` is 'TNC'.
If `inputs` is a list of symbols (usually output of
previous unroll), they should all have shape
(batch_size, ...).
begin_state : nested list of Symbol, optional
Input states created by `begin_state()`
or output state of another cell.
Created from `begin_state()` if `None`.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
merge_outputs : bool, optional
If `False`, returns outputs as a list of Symbols.
If `True`, concatenates output across time steps
and returns a single symbol with shape
(batch_size, length, ...) if layout is 'NTC',
or (length, batch_size, ...) if layout is 'TNC'.
If `None`, output whatever is faster.
valid_length : Symbol, NDArray or None
`valid_length` specifies the length of the sequences in the batch without padding.
This option is especially useful for building sequence-to-sequence models where
the input and output sequences would potentially be padded.
If `valid_length` is None, all sequences are assumed to have the same length.
If `valid_length` is a Symbol or NDArray, it should have shape (batch_size,).
The ith element will be the length of the ith sequence in the batch.
The last valid state will be return and the padded outputs will be masked with 0.
Note that `valid_length` must be smaller or equal to `length`.
Returns
-------
outputs : list of Symbol or Symbol
Symbol (if `merge_outputs` is True) or list of Symbols
(if `merge_outputs` is False) corresponding to the output from
the RNN from this unrolling.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state()`.
"""
# Dropout on inputs and outputs can be performed on the whole sequence
# only when state dropout is not present.
if self.drop_states:
return super(VariationalDropoutCell, self).unroll(length, inputs, begin_state,
layout, merge_outputs,
valid_length=valid_length)
self.reset()
inputs, axis, F, batch_size = _format_sequence(length, inputs, layout, True)
states = _get_begin_state(self, F, begin_state, inputs, batch_size)
if self.drop_inputs:
inputs = F.Dropout(inputs, p=self.drop_inputs, axes=(axis,))
outputs, states = self.base_cell.unroll(length, inputs, states, layout, merge_outputs=True,
valid_length=valid_length)
if self.drop_outputs:
outputs = F.Dropout(outputs, p=self.drop_outputs, axes=(axis,))
merge_outputs = isinstance(outputs, tensor_types) if merge_outputs is None else \
merge_outputs
outputs, _, _, _ = _format_sequence(length, outputs, layout, merge_outputs)
if valid_length is not None:
outputs = _mask_sequence_variable_length(F, outputs, length, valid_length, axis,
merge_outputs)
return outputs, states
|
python
|
def unroll(self, length, inputs, begin_state=None, layout='NTC', merge_outputs=None,
valid_length=None):
"""Unrolls an RNN cell across time steps.
Parameters
----------
length : int
Number of steps to unroll.
inputs : Symbol, list of Symbol, or None
If `inputs` is a single Symbol (usually the output
of Embedding symbol), it should have shape
(batch_size, length, ...) if `layout` is 'NTC',
or (length, batch_size, ...) if `layout` is 'TNC'.
If `inputs` is a list of symbols (usually output of
previous unroll), they should all have shape
(batch_size, ...).
begin_state : nested list of Symbol, optional
Input states created by `begin_state()`
or output state of another cell.
Created from `begin_state()` if `None`.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
merge_outputs : bool, optional
If `False`, returns outputs as a list of Symbols.
If `True`, concatenates output across time steps
and returns a single symbol with shape
(batch_size, length, ...) if layout is 'NTC',
or (length, batch_size, ...) if layout is 'TNC'.
If `None`, output whatever is faster.
valid_length : Symbol, NDArray or None
`valid_length` specifies the length of the sequences in the batch without padding.
This option is especially useful for building sequence-to-sequence models where
the input and output sequences would potentially be padded.
If `valid_length` is None, all sequences are assumed to have the same length.
If `valid_length` is a Symbol or NDArray, it should have shape (batch_size,).
The ith element will be the length of the ith sequence in the batch.
The last valid state will be return and the padded outputs will be masked with 0.
Note that `valid_length` must be smaller or equal to `length`.
Returns
-------
outputs : list of Symbol or Symbol
Symbol (if `merge_outputs` is True) or list of Symbols
(if `merge_outputs` is False) corresponding to the output from
the RNN from this unrolling.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state()`.
"""
# Dropout on inputs and outputs can be performed on the whole sequence
# only when state dropout is not present.
if self.drop_states:
return super(VariationalDropoutCell, self).unroll(length, inputs, begin_state,
layout, merge_outputs,
valid_length=valid_length)
self.reset()
inputs, axis, F, batch_size = _format_sequence(length, inputs, layout, True)
states = _get_begin_state(self, F, begin_state, inputs, batch_size)
if self.drop_inputs:
inputs = F.Dropout(inputs, p=self.drop_inputs, axes=(axis,))
outputs, states = self.base_cell.unroll(length, inputs, states, layout, merge_outputs=True,
valid_length=valid_length)
if self.drop_outputs:
outputs = F.Dropout(outputs, p=self.drop_outputs, axes=(axis,))
merge_outputs = isinstance(outputs, tensor_types) if merge_outputs is None else \
merge_outputs
outputs, _, _, _ = _format_sequence(length, outputs, layout, merge_outputs)
if valid_length is not None:
outputs = _mask_sequence_variable_length(F, outputs, length, valid_length, axis,
merge_outputs)
return outputs, states
|
[
"def",
"unroll",
"(",
"self",
",",
"length",
",",
"inputs",
",",
"begin_state",
"=",
"None",
",",
"layout",
"=",
"'NTC'",
",",
"merge_outputs",
"=",
"None",
",",
"valid_length",
"=",
"None",
")",
":",
"# Dropout on inputs and outputs can be performed on the whole sequence",
"# only when state dropout is not present.",
"if",
"self",
".",
"drop_states",
":",
"return",
"super",
"(",
"VariationalDropoutCell",
",",
"self",
")",
".",
"unroll",
"(",
"length",
",",
"inputs",
",",
"begin_state",
",",
"layout",
",",
"merge_outputs",
",",
"valid_length",
"=",
"valid_length",
")",
"self",
".",
"reset",
"(",
")",
"inputs",
",",
"axis",
",",
"F",
",",
"batch_size",
"=",
"_format_sequence",
"(",
"length",
",",
"inputs",
",",
"layout",
",",
"True",
")",
"states",
"=",
"_get_begin_state",
"(",
"self",
",",
"F",
",",
"begin_state",
",",
"inputs",
",",
"batch_size",
")",
"if",
"self",
".",
"drop_inputs",
":",
"inputs",
"=",
"F",
".",
"Dropout",
"(",
"inputs",
",",
"p",
"=",
"self",
".",
"drop_inputs",
",",
"axes",
"=",
"(",
"axis",
",",
")",
")",
"outputs",
",",
"states",
"=",
"self",
".",
"base_cell",
".",
"unroll",
"(",
"length",
",",
"inputs",
",",
"states",
",",
"layout",
",",
"merge_outputs",
"=",
"True",
",",
"valid_length",
"=",
"valid_length",
")",
"if",
"self",
".",
"drop_outputs",
":",
"outputs",
"=",
"F",
".",
"Dropout",
"(",
"outputs",
",",
"p",
"=",
"self",
".",
"drop_outputs",
",",
"axes",
"=",
"(",
"axis",
",",
")",
")",
"merge_outputs",
"=",
"isinstance",
"(",
"outputs",
",",
"tensor_types",
")",
"if",
"merge_outputs",
"is",
"None",
"else",
"merge_outputs",
"outputs",
",",
"_",
",",
"_",
",",
"_",
"=",
"_format_sequence",
"(",
"length",
",",
"outputs",
",",
"layout",
",",
"merge_outputs",
")",
"if",
"valid_length",
"is",
"not",
"None",
":",
"outputs",
"=",
"_mask_sequence_variable_length",
"(",
"F",
",",
"outputs",
",",
"length",
",",
"valid_length",
",",
"axis",
",",
"merge_outputs",
")",
"return",
"outputs",
",",
"states"
] |
Unrolls an RNN cell across time steps.
Parameters
----------
length : int
Number of steps to unroll.
inputs : Symbol, list of Symbol, or None
If `inputs` is a single Symbol (usually the output
of Embedding symbol), it should have shape
(batch_size, length, ...) if `layout` is 'NTC',
or (length, batch_size, ...) if `layout` is 'TNC'.
If `inputs` is a list of symbols (usually output of
previous unroll), they should all have shape
(batch_size, ...).
begin_state : nested list of Symbol, optional
Input states created by `begin_state()`
or output state of another cell.
Created from `begin_state()` if `None`.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
merge_outputs : bool, optional
If `False`, returns outputs as a list of Symbols.
If `True`, concatenates output across time steps
and returns a single symbol with shape
(batch_size, length, ...) if layout is 'NTC',
or (length, batch_size, ...) if layout is 'TNC'.
If `None`, output whatever is faster.
valid_length : Symbol, NDArray or None
`valid_length` specifies the length of the sequences in the batch without padding.
This option is especially useful for building sequence-to-sequence models where
the input and output sequences would potentially be padded.
If `valid_length` is None, all sequences are assumed to have the same length.
If `valid_length` is a Symbol or NDArray, it should have shape (batch_size,).
The ith element will be the length of the ith sequence in the batch.
The last valid state will be return and the padded outputs will be masked with 0.
Note that `valid_length` must be smaller or equal to `length`.
Returns
-------
outputs : list of Symbol or Symbol
Symbol (if `merge_outputs` is True) or list of Symbols
(if `merge_outputs` is False) corresponding to the output from
the RNN from this unrolling.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state()`.
|
[
"Unrolls",
"an",
"RNN",
"cell",
"across",
"time",
"steps",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/contrib/rnn/rnn_cell.py#L117-L195
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_fix_attribute_names
|
def _fix_attribute_names(attrs, change_map):
"""
Change attribute names as per values in change_map dictionary.
Parameters
----------
:param attrs : dict Dict of operator attributes
:param change_map : dict Dict of onnx attribute name to mxnet attribute names.
Returns
-------
:return new_attr : dict Converted dict of operator attributes.
"""
new_attr = {}
for k in attrs.keys():
if k in change_map:
new_attr[change_map[k]] = attrs[k]
else:
new_attr[k] = attrs[k]
return new_attr
|
python
|
def _fix_attribute_names(attrs, change_map):
"""
Change attribute names as per values in change_map dictionary.
Parameters
----------
:param attrs : dict Dict of operator attributes
:param change_map : dict Dict of onnx attribute name to mxnet attribute names.
Returns
-------
:return new_attr : dict Converted dict of operator attributes.
"""
new_attr = {}
for k in attrs.keys():
if k in change_map:
new_attr[change_map[k]] = attrs[k]
else:
new_attr[k] = attrs[k]
return new_attr
|
[
"def",
"_fix_attribute_names",
"(",
"attrs",
",",
"change_map",
")",
":",
"new_attr",
"=",
"{",
"}",
"for",
"k",
"in",
"attrs",
".",
"keys",
"(",
")",
":",
"if",
"k",
"in",
"change_map",
":",
"new_attr",
"[",
"change_map",
"[",
"k",
"]",
"]",
"=",
"attrs",
"[",
"k",
"]",
"else",
":",
"new_attr",
"[",
"k",
"]",
"=",
"attrs",
"[",
"k",
"]",
"return",
"new_attr"
] |
Change attribute names as per values in change_map dictionary.
Parameters
----------
:param attrs : dict Dict of operator attributes
:param change_map : dict Dict of onnx attribute name to mxnet attribute names.
Returns
-------
:return new_attr : dict Converted dict of operator attributes.
|
[
"Change",
"attribute",
"names",
"as",
"per",
"values",
"in",
"change_map",
"dictionary",
".",
"Parameters",
"----------",
":",
"param",
"attrs",
":",
"dict",
"Dict",
"of",
"operator",
"attributes",
":",
"param",
"change_map",
":",
"dict",
"Dict",
"of",
"onnx",
"attribute",
"name",
"to",
"mxnet",
"attribute",
"names",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L29-L47
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_remove_attributes
|
def _remove_attributes(attrs, remove_list):
"""
Removes attributes in the remove list from the input attribute dict
:param attrs : Dict of operator attributes
:param remove_list : list of attributes to be removed
:return new_attr : Dict of operator attributes without the listed attributes.
"""
new_attrs = {}
for attr in attrs.keys():
if attr not in remove_list:
new_attrs[attr] = attrs[attr]
return new_attrs
|
python
|
def _remove_attributes(attrs, remove_list):
"""
Removes attributes in the remove list from the input attribute dict
:param attrs : Dict of operator attributes
:param remove_list : list of attributes to be removed
:return new_attr : Dict of operator attributes without the listed attributes.
"""
new_attrs = {}
for attr in attrs.keys():
if attr not in remove_list:
new_attrs[attr] = attrs[attr]
return new_attrs
|
[
"def",
"_remove_attributes",
"(",
"attrs",
",",
"remove_list",
")",
":",
"new_attrs",
"=",
"{",
"}",
"for",
"attr",
"in",
"attrs",
".",
"keys",
"(",
")",
":",
"if",
"attr",
"not",
"in",
"remove_list",
":",
"new_attrs",
"[",
"attr",
"]",
"=",
"attrs",
"[",
"attr",
"]",
"return",
"new_attrs"
] |
Removes attributes in the remove list from the input attribute dict
:param attrs : Dict of operator attributes
:param remove_list : list of attributes to be removed
:return new_attr : Dict of operator attributes without the listed attributes.
|
[
"Removes",
"attributes",
"in",
"the",
"remove",
"list",
"from",
"the",
"input",
"attribute",
"dict",
":",
"param",
"attrs",
":",
"Dict",
"of",
"operator",
"attributes",
":",
"param",
"remove_list",
":",
"list",
"of",
"attributes",
"to",
"be",
"removed"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L49-L61
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_add_extra_attributes
|
def _add_extra_attributes(attrs, extra_attr_map):
"""
:param attrs: Current Attribute list
:param extraAttrMap: Additional attributes to be added
:return: new_attr
"""
for attr in extra_attr_map:
if attr not in attrs:
attrs[attr] = extra_attr_map[attr]
return attrs
|
python
|
def _add_extra_attributes(attrs, extra_attr_map):
"""
:param attrs: Current Attribute list
:param extraAttrMap: Additional attributes to be added
:return: new_attr
"""
for attr in extra_attr_map:
if attr not in attrs:
attrs[attr] = extra_attr_map[attr]
return attrs
|
[
"def",
"_add_extra_attributes",
"(",
"attrs",
",",
"extra_attr_map",
")",
":",
"for",
"attr",
"in",
"extra_attr_map",
":",
"if",
"attr",
"not",
"in",
"attrs",
":",
"attrs",
"[",
"attr",
"]",
"=",
"extra_attr_map",
"[",
"attr",
"]",
"return",
"attrs"
] |
:param attrs: Current Attribute list
:param extraAttrMap: Additional attributes to be added
:return: new_attr
|
[
":",
"param",
"attrs",
":",
"Current",
"Attribute",
"list",
":",
"param",
"extraAttrMap",
":",
"Additional",
"attributes",
"to",
"be",
"added",
":",
"return",
":",
"new_attr"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L63-L72
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_pad_sequence_fix
|
def _pad_sequence_fix(attr, kernel_dim=None):
"""Changing onnx's pads sequence to match with mxnet's pad_width
mxnet: (x1_begin, x1_end, ... , xn_begin, xn_end)
onnx: (x1_begin, x2_begin, ... , xn_end, xn_end)"""
new_attr = ()
if len(attr) % 2 == 0:
for index in range(int(len(attr) / 2)):
new_attr = new_attr + attr[index::int(len(attr) / 2)]
# Making sure pad values are in the attr for all axes.
if kernel_dim is not None:
while len(new_attr) < kernel_dim*2:
new_attr = new_attr + (0, 0)
return new_attr
|
python
|
def _pad_sequence_fix(attr, kernel_dim=None):
"""Changing onnx's pads sequence to match with mxnet's pad_width
mxnet: (x1_begin, x1_end, ... , xn_begin, xn_end)
onnx: (x1_begin, x2_begin, ... , xn_end, xn_end)"""
new_attr = ()
if len(attr) % 2 == 0:
for index in range(int(len(attr) / 2)):
new_attr = new_attr + attr[index::int(len(attr) / 2)]
# Making sure pad values are in the attr for all axes.
if kernel_dim is not None:
while len(new_attr) < kernel_dim*2:
new_attr = new_attr + (0, 0)
return new_attr
|
[
"def",
"_pad_sequence_fix",
"(",
"attr",
",",
"kernel_dim",
"=",
"None",
")",
":",
"new_attr",
"=",
"(",
")",
"if",
"len",
"(",
"attr",
")",
"%",
"2",
"==",
"0",
":",
"for",
"index",
"in",
"range",
"(",
"int",
"(",
"len",
"(",
"attr",
")",
"/",
"2",
")",
")",
":",
"new_attr",
"=",
"new_attr",
"+",
"attr",
"[",
"index",
":",
":",
"int",
"(",
"len",
"(",
"attr",
")",
"/",
"2",
")",
"]",
"# Making sure pad values are in the attr for all axes.",
"if",
"kernel_dim",
"is",
"not",
"None",
":",
"while",
"len",
"(",
"new_attr",
")",
"<",
"kernel_dim",
"*",
"2",
":",
"new_attr",
"=",
"new_attr",
"+",
"(",
"0",
",",
"0",
")",
"return",
"new_attr"
] |
Changing onnx's pads sequence to match with mxnet's pad_width
mxnet: (x1_begin, x1_end, ... , xn_begin, xn_end)
onnx: (x1_begin, x2_begin, ... , xn_end, xn_end)
|
[
"Changing",
"onnx",
"s",
"pads",
"sequence",
"to",
"match",
"with",
"mxnet",
"s",
"pad_width",
"mxnet",
":",
"(",
"x1_begin",
"x1_end",
"...",
"xn_begin",
"xn_end",
")",
"onnx",
":",
"(",
"x1_begin",
"x2_begin",
"...",
"xn_end",
"xn_end",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L75-L88
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_fix_pooling
|
def _fix_pooling(pool_type, inputs, new_attr):
"""onnx pooling operator supports asymmetrical padding
Adding pad operator before pooling in mxnet to work with onnx"""
stride = new_attr.get('stride')
kernel = new_attr.get('kernel')
padding = new_attr.get('pad')
p_value = new_attr.get('p_value')
# Adding default stride.
if stride is None:
stride = (1,) * len(kernel)
# Add padding attr if not provided.
if padding is None:
padding = (0,) * len(kernel) * 2
# Mxnet Pad operator supports only 4D/5D tensors.
# For 1D case, these are the steps:
# Step 1. Add extra dummy dimension to make it 4D. Adding to axis = 2
# Step 2. Apply padding to this changed tensor
# Step 3. Remove the extra dimension added in step 1.
if len(kernel) == 1:
dummy_axis = 2
# setting 0 padding to the new dim to be added.
padding = (0, padding[0], 0, padding[1])
pad_width = (0, 0, 0, 0) + _pad_sequence_fix(padding, kernel_dim=2)
# Step 1.
curr_sym = symbol.expand_dims(inputs[0], axis=dummy_axis)
# Step 2. Common for all tensor sizes
new_pad_op = symbol.pad(curr_sym, mode='edge', pad_width=pad_width)
# Step 3: Removing extra dim added.
new_pad_op = symbol.split(new_pad_op, axis=dummy_axis, num_outputs=1, squeeze_axis=1)
else:
# For 2D/3D cases:
# Apply padding
pad_width = (0, 0, 0, 0) + _pad_sequence_fix(padding, kernel_dim=len(kernel))
curr_sym = inputs[0]
if pool_type == 'max':
# For max pool : mode = 'edge', we should replicate the
# edge values to pad, so that we only include input data values
# for calculating 'max'
new_pad_op = symbol.pad(curr_sym, mode='edge', pad_width=pad_width)
else:
# For avg pool, we should add 'zeros' for padding so mode='constant'
new_pad_op = symbol.pad(curr_sym, mode='constant', pad_width=pad_width)
# Apply pooling without pads.
if pool_type == 'lp':
new_pooling_op = symbol.Pooling(new_pad_op, pool_type=pool_type, stride=stride, kernel=kernel, p_value=p_value)
else:
new_pooling_op = symbol.Pooling(new_pad_op, pool_type=pool_type, stride=stride, kernel=kernel)
return new_pooling_op
|
python
|
def _fix_pooling(pool_type, inputs, new_attr):
"""onnx pooling operator supports asymmetrical padding
Adding pad operator before pooling in mxnet to work with onnx"""
stride = new_attr.get('stride')
kernel = new_attr.get('kernel')
padding = new_attr.get('pad')
p_value = new_attr.get('p_value')
# Adding default stride.
if stride is None:
stride = (1,) * len(kernel)
# Add padding attr if not provided.
if padding is None:
padding = (0,) * len(kernel) * 2
# Mxnet Pad operator supports only 4D/5D tensors.
# For 1D case, these are the steps:
# Step 1. Add extra dummy dimension to make it 4D. Adding to axis = 2
# Step 2. Apply padding to this changed tensor
# Step 3. Remove the extra dimension added in step 1.
if len(kernel) == 1:
dummy_axis = 2
# setting 0 padding to the new dim to be added.
padding = (0, padding[0], 0, padding[1])
pad_width = (0, 0, 0, 0) + _pad_sequence_fix(padding, kernel_dim=2)
# Step 1.
curr_sym = symbol.expand_dims(inputs[0], axis=dummy_axis)
# Step 2. Common for all tensor sizes
new_pad_op = symbol.pad(curr_sym, mode='edge', pad_width=pad_width)
# Step 3: Removing extra dim added.
new_pad_op = symbol.split(new_pad_op, axis=dummy_axis, num_outputs=1, squeeze_axis=1)
else:
# For 2D/3D cases:
# Apply padding
pad_width = (0, 0, 0, 0) + _pad_sequence_fix(padding, kernel_dim=len(kernel))
curr_sym = inputs[0]
if pool_type == 'max':
# For max pool : mode = 'edge', we should replicate the
# edge values to pad, so that we only include input data values
# for calculating 'max'
new_pad_op = symbol.pad(curr_sym, mode='edge', pad_width=pad_width)
else:
# For avg pool, we should add 'zeros' for padding so mode='constant'
new_pad_op = symbol.pad(curr_sym, mode='constant', pad_width=pad_width)
# Apply pooling without pads.
if pool_type == 'lp':
new_pooling_op = symbol.Pooling(new_pad_op, pool_type=pool_type, stride=stride, kernel=kernel, p_value=p_value)
else:
new_pooling_op = symbol.Pooling(new_pad_op, pool_type=pool_type, stride=stride, kernel=kernel)
return new_pooling_op
|
[
"def",
"_fix_pooling",
"(",
"pool_type",
",",
"inputs",
",",
"new_attr",
")",
":",
"stride",
"=",
"new_attr",
".",
"get",
"(",
"'stride'",
")",
"kernel",
"=",
"new_attr",
".",
"get",
"(",
"'kernel'",
")",
"padding",
"=",
"new_attr",
".",
"get",
"(",
"'pad'",
")",
"p_value",
"=",
"new_attr",
".",
"get",
"(",
"'p_value'",
")",
"# Adding default stride.",
"if",
"stride",
"is",
"None",
":",
"stride",
"=",
"(",
"1",
",",
")",
"*",
"len",
"(",
"kernel",
")",
"# Add padding attr if not provided.",
"if",
"padding",
"is",
"None",
":",
"padding",
"=",
"(",
"0",
",",
")",
"*",
"len",
"(",
"kernel",
")",
"*",
"2",
"# Mxnet Pad operator supports only 4D/5D tensors.",
"# For 1D case, these are the steps:",
"# Step 1. Add extra dummy dimension to make it 4D. Adding to axis = 2",
"# Step 2. Apply padding to this changed tensor",
"# Step 3. Remove the extra dimension added in step 1.",
"if",
"len",
"(",
"kernel",
")",
"==",
"1",
":",
"dummy_axis",
"=",
"2",
"# setting 0 padding to the new dim to be added.",
"padding",
"=",
"(",
"0",
",",
"padding",
"[",
"0",
"]",
",",
"0",
",",
"padding",
"[",
"1",
"]",
")",
"pad_width",
"=",
"(",
"0",
",",
"0",
",",
"0",
",",
"0",
")",
"+",
"_pad_sequence_fix",
"(",
"padding",
",",
"kernel_dim",
"=",
"2",
")",
"# Step 1.",
"curr_sym",
"=",
"symbol",
".",
"expand_dims",
"(",
"inputs",
"[",
"0",
"]",
",",
"axis",
"=",
"dummy_axis",
")",
"# Step 2. Common for all tensor sizes",
"new_pad_op",
"=",
"symbol",
".",
"pad",
"(",
"curr_sym",
",",
"mode",
"=",
"'edge'",
",",
"pad_width",
"=",
"pad_width",
")",
"# Step 3: Removing extra dim added.",
"new_pad_op",
"=",
"symbol",
".",
"split",
"(",
"new_pad_op",
",",
"axis",
"=",
"dummy_axis",
",",
"num_outputs",
"=",
"1",
",",
"squeeze_axis",
"=",
"1",
")",
"else",
":",
"# For 2D/3D cases:",
"# Apply padding",
"pad_width",
"=",
"(",
"0",
",",
"0",
",",
"0",
",",
"0",
")",
"+",
"_pad_sequence_fix",
"(",
"padding",
",",
"kernel_dim",
"=",
"len",
"(",
"kernel",
")",
")",
"curr_sym",
"=",
"inputs",
"[",
"0",
"]",
"if",
"pool_type",
"==",
"'max'",
":",
"# For max pool : mode = 'edge', we should replicate the",
"# edge values to pad, so that we only include input data values",
"# for calculating 'max'",
"new_pad_op",
"=",
"symbol",
".",
"pad",
"(",
"curr_sym",
",",
"mode",
"=",
"'edge'",
",",
"pad_width",
"=",
"pad_width",
")",
"else",
":",
"# For avg pool, we should add 'zeros' for padding so mode='constant'",
"new_pad_op",
"=",
"symbol",
".",
"pad",
"(",
"curr_sym",
",",
"mode",
"=",
"'constant'",
",",
"pad_width",
"=",
"pad_width",
")",
"# Apply pooling without pads.",
"if",
"pool_type",
"==",
"'lp'",
":",
"new_pooling_op",
"=",
"symbol",
".",
"Pooling",
"(",
"new_pad_op",
",",
"pool_type",
"=",
"pool_type",
",",
"stride",
"=",
"stride",
",",
"kernel",
"=",
"kernel",
",",
"p_value",
"=",
"p_value",
")",
"else",
":",
"new_pooling_op",
"=",
"symbol",
".",
"Pooling",
"(",
"new_pad_op",
",",
"pool_type",
"=",
"pool_type",
",",
"stride",
"=",
"stride",
",",
"kernel",
"=",
"kernel",
")",
"return",
"new_pooling_op"
] |
onnx pooling operator supports asymmetrical padding
Adding pad operator before pooling in mxnet to work with onnx
|
[
"onnx",
"pooling",
"operator",
"supports",
"asymmetrical",
"padding",
"Adding",
"pad",
"operator",
"before",
"pooling",
"in",
"mxnet",
"to",
"work",
"with",
"onnx"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L91-L146
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_fix_bias
|
def _fix_bias(op_name, attrs, num_inputs):
"""A workaround for 'use_bias' attribute since onnx don't provide this attribute,
we have to check the number of inputs to decide it."""
if num_inputs == 3:
attrs['no_bias'] = False
elif num_inputs == 2:
attrs['no_bias'] = True
else:
raise ValueError("Unexpected number of inputs for: {}".format(op_name))
return attrs
|
python
|
def _fix_bias(op_name, attrs, num_inputs):
"""A workaround for 'use_bias' attribute since onnx don't provide this attribute,
we have to check the number of inputs to decide it."""
if num_inputs == 3:
attrs['no_bias'] = False
elif num_inputs == 2:
attrs['no_bias'] = True
else:
raise ValueError("Unexpected number of inputs for: {}".format(op_name))
return attrs
|
[
"def",
"_fix_bias",
"(",
"op_name",
",",
"attrs",
",",
"num_inputs",
")",
":",
"if",
"num_inputs",
"==",
"3",
":",
"attrs",
"[",
"'no_bias'",
"]",
"=",
"False",
"elif",
"num_inputs",
"==",
"2",
":",
"attrs",
"[",
"'no_bias'",
"]",
"=",
"True",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unexpected number of inputs for: {}\"",
".",
"format",
"(",
"op_name",
")",
")",
"return",
"attrs"
] |
A workaround for 'use_bias' attribute since onnx don't provide this attribute,
we have to check the number of inputs to decide it.
|
[
"A",
"workaround",
"for",
"use_bias",
"attribute",
"since",
"onnx",
"don",
"t",
"provide",
"this",
"attribute",
"we",
"have",
"to",
"check",
"the",
"number",
"of",
"inputs",
"to",
"decide",
"it",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L148-L157
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_fix_broadcast
|
def _fix_broadcast(op_name, inputs, broadcast_axis, proto_obj):
"""A workaround to reshape bias term to (1, num_channel)."""
if int(len(proto_obj._params)) > 0:
assert len(list(inputs)) == 2
input0_shape = get_input_shape(inputs[0], proto_obj)
#creating reshape shape
reshape_shape = list(len(input0_shape) * (1,))
reshape_shape[broadcast_axis] = -1
reshape_shape = tuple(reshape_shape)
reshape_op_sym = symbol.reshape(inputs[1], shape=reshape_shape)
op_sym = getattr(symbol, op_name)(inputs[0], reshape_op_sym)
else:
op_sym = op_name
return op_sym
|
python
|
def _fix_broadcast(op_name, inputs, broadcast_axis, proto_obj):
"""A workaround to reshape bias term to (1, num_channel)."""
if int(len(proto_obj._params)) > 0:
assert len(list(inputs)) == 2
input0_shape = get_input_shape(inputs[0], proto_obj)
#creating reshape shape
reshape_shape = list(len(input0_shape) * (1,))
reshape_shape[broadcast_axis] = -1
reshape_shape = tuple(reshape_shape)
reshape_op_sym = symbol.reshape(inputs[1], shape=reshape_shape)
op_sym = getattr(symbol, op_name)(inputs[0], reshape_op_sym)
else:
op_sym = op_name
return op_sym
|
[
"def",
"_fix_broadcast",
"(",
"op_name",
",",
"inputs",
",",
"broadcast_axis",
",",
"proto_obj",
")",
":",
"if",
"int",
"(",
"len",
"(",
"proto_obj",
".",
"_params",
")",
")",
">",
"0",
":",
"assert",
"len",
"(",
"list",
"(",
"inputs",
")",
")",
"==",
"2",
"input0_shape",
"=",
"get_input_shape",
"(",
"inputs",
"[",
"0",
"]",
",",
"proto_obj",
")",
"#creating reshape shape",
"reshape_shape",
"=",
"list",
"(",
"len",
"(",
"input0_shape",
")",
"*",
"(",
"1",
",",
")",
")",
"reshape_shape",
"[",
"broadcast_axis",
"]",
"=",
"-",
"1",
"reshape_shape",
"=",
"tuple",
"(",
"reshape_shape",
")",
"reshape_op_sym",
"=",
"symbol",
".",
"reshape",
"(",
"inputs",
"[",
"1",
"]",
",",
"shape",
"=",
"reshape_shape",
")",
"op_sym",
"=",
"getattr",
"(",
"symbol",
",",
"op_name",
")",
"(",
"inputs",
"[",
"0",
"]",
",",
"reshape_op_sym",
")",
"else",
":",
"op_sym",
"=",
"op_name",
"return",
"op_sym"
] |
A workaround to reshape bias term to (1, num_channel).
|
[
"A",
"workaround",
"to",
"reshape",
"bias",
"term",
"to",
"(",
"1",
"num_channel",
")",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L159-L173
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_fix_channels
|
def _fix_channels(op_name, attrs, inputs, proto_obj):
"""A workaround for getting 'channels' or 'units' since onnx don't provide
these attributes. We check the shape of weights provided to get the number.
"""
weight_name = inputs[1].name
if not weight_name in proto_obj._params:
raise ValueError("Unable to get channels/units attr from onnx graph.")
else:
wshape = proto_obj._params[weight_name].shape
assert len(wshape) >= 2, "Weights shape is invalid: {}".format(wshape)
if op_name == 'FullyConnected':
attrs['num_hidden'] = wshape[0]
else:
if op_name == 'Convolution':
# Weight shape for Conv and FC: (M x C x kH x kW) : M is number of
# feature maps/hidden and C is number of channels
attrs['num_filter'] = wshape[0]
elif op_name == 'Deconvolution':
# Weight shape for DeConv : (C x M x kH x kW) : M is number of
# feature maps/filters and C is number of channels
attrs['num_filter'] = wshape[1]
return attrs
|
python
|
def _fix_channels(op_name, attrs, inputs, proto_obj):
"""A workaround for getting 'channels' or 'units' since onnx don't provide
these attributes. We check the shape of weights provided to get the number.
"""
weight_name = inputs[1].name
if not weight_name in proto_obj._params:
raise ValueError("Unable to get channels/units attr from onnx graph.")
else:
wshape = proto_obj._params[weight_name].shape
assert len(wshape) >= 2, "Weights shape is invalid: {}".format(wshape)
if op_name == 'FullyConnected':
attrs['num_hidden'] = wshape[0]
else:
if op_name == 'Convolution':
# Weight shape for Conv and FC: (M x C x kH x kW) : M is number of
# feature maps/hidden and C is number of channels
attrs['num_filter'] = wshape[0]
elif op_name == 'Deconvolution':
# Weight shape for DeConv : (C x M x kH x kW) : M is number of
# feature maps/filters and C is number of channels
attrs['num_filter'] = wshape[1]
return attrs
|
[
"def",
"_fix_channels",
"(",
"op_name",
",",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"weight_name",
"=",
"inputs",
"[",
"1",
"]",
".",
"name",
"if",
"not",
"weight_name",
"in",
"proto_obj",
".",
"_params",
":",
"raise",
"ValueError",
"(",
"\"Unable to get channels/units attr from onnx graph.\"",
")",
"else",
":",
"wshape",
"=",
"proto_obj",
".",
"_params",
"[",
"weight_name",
"]",
".",
"shape",
"assert",
"len",
"(",
"wshape",
")",
">=",
"2",
",",
"\"Weights shape is invalid: {}\"",
".",
"format",
"(",
"wshape",
")",
"if",
"op_name",
"==",
"'FullyConnected'",
":",
"attrs",
"[",
"'num_hidden'",
"]",
"=",
"wshape",
"[",
"0",
"]",
"else",
":",
"if",
"op_name",
"==",
"'Convolution'",
":",
"# Weight shape for Conv and FC: (M x C x kH x kW) : M is number of",
"# feature maps/hidden and C is number of channels",
"attrs",
"[",
"'num_filter'",
"]",
"=",
"wshape",
"[",
"0",
"]",
"elif",
"op_name",
"==",
"'Deconvolution'",
":",
"# Weight shape for DeConv : (C x M x kH x kW) : M is number of",
"# feature maps/filters and C is number of channels",
"attrs",
"[",
"'num_filter'",
"]",
"=",
"wshape",
"[",
"1",
"]",
"return",
"attrs"
] |
A workaround for getting 'channels' or 'units' since onnx don't provide
these attributes. We check the shape of weights provided to get the number.
|
[
"A",
"workaround",
"for",
"getting",
"channels",
"or",
"units",
"since",
"onnx",
"don",
"t",
"provide",
"these",
"attributes",
".",
"We",
"check",
"the",
"shape",
"of",
"weights",
"provided",
"to",
"get",
"the",
"number",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L176-L198
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
_fix_gemm
|
def _fix_gemm(op_name, inputs, old_attr, proto_obj):
"""Using FullyConnected operator in place of linalg_gemm to perform same operation"""
op_sym = getattr(symbol, op_name, None)
alpha = float(old_attr.get('alpha', 1.0))
beta = float(old_attr.get('beta', 1.0))
trans_a = int(old_attr.get('transA', 0))
trans_b = int(old_attr.get('transB', 0))
if trans_a:
inputs[0] = symbol.transpose(inputs[0], axes=(1, 0))
if not trans_b:
inputs[1] = symbol.transpose(inputs[1], axes=(1, 0))
new_inputs = [alpha*inputs[0], inputs[1], beta*inputs[2]]
new_attr = {'num_hidden' : proto_obj._params[inputs[2].name].shape[0]}
return op_sym, new_attr, new_inputs
|
python
|
def _fix_gemm(op_name, inputs, old_attr, proto_obj):
"""Using FullyConnected operator in place of linalg_gemm to perform same operation"""
op_sym = getattr(symbol, op_name, None)
alpha = float(old_attr.get('alpha', 1.0))
beta = float(old_attr.get('beta', 1.0))
trans_a = int(old_attr.get('transA', 0))
trans_b = int(old_attr.get('transB', 0))
if trans_a:
inputs[0] = symbol.transpose(inputs[0], axes=(1, 0))
if not trans_b:
inputs[1] = symbol.transpose(inputs[1], axes=(1, 0))
new_inputs = [alpha*inputs[0], inputs[1], beta*inputs[2]]
new_attr = {'num_hidden' : proto_obj._params[inputs[2].name].shape[0]}
return op_sym, new_attr, new_inputs
|
[
"def",
"_fix_gemm",
"(",
"op_name",
",",
"inputs",
",",
"old_attr",
",",
"proto_obj",
")",
":",
"op_sym",
"=",
"getattr",
"(",
"symbol",
",",
"op_name",
",",
"None",
")",
"alpha",
"=",
"float",
"(",
"old_attr",
".",
"get",
"(",
"'alpha'",
",",
"1.0",
")",
")",
"beta",
"=",
"float",
"(",
"old_attr",
".",
"get",
"(",
"'beta'",
",",
"1.0",
")",
")",
"trans_a",
"=",
"int",
"(",
"old_attr",
".",
"get",
"(",
"'transA'",
",",
"0",
")",
")",
"trans_b",
"=",
"int",
"(",
"old_attr",
".",
"get",
"(",
"'transB'",
",",
"0",
")",
")",
"if",
"trans_a",
":",
"inputs",
"[",
"0",
"]",
"=",
"symbol",
".",
"transpose",
"(",
"inputs",
"[",
"0",
"]",
",",
"axes",
"=",
"(",
"1",
",",
"0",
")",
")",
"if",
"not",
"trans_b",
":",
"inputs",
"[",
"1",
"]",
"=",
"symbol",
".",
"transpose",
"(",
"inputs",
"[",
"1",
"]",
",",
"axes",
"=",
"(",
"1",
",",
"0",
")",
")",
"new_inputs",
"=",
"[",
"alpha",
"*",
"inputs",
"[",
"0",
"]",
",",
"inputs",
"[",
"1",
"]",
",",
"beta",
"*",
"inputs",
"[",
"2",
"]",
"]",
"new_attr",
"=",
"{",
"'num_hidden'",
":",
"proto_obj",
".",
"_params",
"[",
"inputs",
"[",
"2",
"]",
".",
"name",
"]",
".",
"shape",
"[",
"0",
"]",
"}",
"return",
"op_sym",
",",
"new_attr",
",",
"new_inputs"
] |
Using FullyConnected operator in place of linalg_gemm to perform same operation
|
[
"Using",
"FullyConnected",
"operator",
"in",
"place",
"of",
"linalg_gemm",
"to",
"perform",
"same",
"operation"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L201-L214
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py
|
get_input_shape
|
def get_input_shape(sym, proto_obj):
"""Helper function to obtain the shape of an array"""
arg_params = proto_obj.arg_dict
aux_params = proto_obj.aux_dict
model_input_shape = [data[1] for data in proto_obj.model_metadata.get('input_tensor_data')]
data_names = [data[0] for data in proto_obj.model_metadata.get('input_tensor_data')]
# creating dummy inputs
inputs = []
for in_shape in model_input_shape:
inputs.append(nd.ones(shape=in_shape))
data_shapes = []
for idx, input_name in enumerate(data_names):
data_shapes.append((input_name, inputs[idx].shape))
ctx = context.cpu()
# create a module
mod = module.Module(symbol=sym, data_names=data_names, context=ctx, label_names=None)
mod.bind(for_training=False, data_shapes=data_shapes, label_shapes=None)
mod.set_params(arg_params=arg_params, aux_params=aux_params)
data_forward = []
for idx, input_name in enumerate(data_names):
val = inputs[idx]
data_forward.append(val)
mod.forward(io.DataBatch(data_forward))
result = mod.get_outputs()[0].asnumpy()
return result.shape
|
python
|
def get_input_shape(sym, proto_obj):
"""Helper function to obtain the shape of an array"""
arg_params = proto_obj.arg_dict
aux_params = proto_obj.aux_dict
model_input_shape = [data[1] for data in proto_obj.model_metadata.get('input_tensor_data')]
data_names = [data[0] for data in proto_obj.model_metadata.get('input_tensor_data')]
# creating dummy inputs
inputs = []
for in_shape in model_input_shape:
inputs.append(nd.ones(shape=in_shape))
data_shapes = []
for idx, input_name in enumerate(data_names):
data_shapes.append((input_name, inputs[idx].shape))
ctx = context.cpu()
# create a module
mod = module.Module(symbol=sym, data_names=data_names, context=ctx, label_names=None)
mod.bind(for_training=False, data_shapes=data_shapes, label_shapes=None)
mod.set_params(arg_params=arg_params, aux_params=aux_params)
data_forward = []
for idx, input_name in enumerate(data_names):
val = inputs[idx]
data_forward.append(val)
mod.forward(io.DataBatch(data_forward))
result = mod.get_outputs()[0].asnumpy()
return result.shape
|
[
"def",
"get_input_shape",
"(",
"sym",
",",
"proto_obj",
")",
":",
"arg_params",
"=",
"proto_obj",
".",
"arg_dict",
"aux_params",
"=",
"proto_obj",
".",
"aux_dict",
"model_input_shape",
"=",
"[",
"data",
"[",
"1",
"]",
"for",
"data",
"in",
"proto_obj",
".",
"model_metadata",
".",
"get",
"(",
"'input_tensor_data'",
")",
"]",
"data_names",
"=",
"[",
"data",
"[",
"0",
"]",
"for",
"data",
"in",
"proto_obj",
".",
"model_metadata",
".",
"get",
"(",
"'input_tensor_data'",
")",
"]",
"# creating dummy inputs",
"inputs",
"=",
"[",
"]",
"for",
"in_shape",
"in",
"model_input_shape",
":",
"inputs",
".",
"append",
"(",
"nd",
".",
"ones",
"(",
"shape",
"=",
"in_shape",
")",
")",
"data_shapes",
"=",
"[",
"]",
"for",
"idx",
",",
"input_name",
"in",
"enumerate",
"(",
"data_names",
")",
":",
"data_shapes",
".",
"append",
"(",
"(",
"input_name",
",",
"inputs",
"[",
"idx",
"]",
".",
"shape",
")",
")",
"ctx",
"=",
"context",
".",
"cpu",
"(",
")",
"# create a module",
"mod",
"=",
"module",
".",
"Module",
"(",
"symbol",
"=",
"sym",
",",
"data_names",
"=",
"data_names",
",",
"context",
"=",
"ctx",
",",
"label_names",
"=",
"None",
")",
"mod",
".",
"bind",
"(",
"for_training",
"=",
"False",
",",
"data_shapes",
"=",
"data_shapes",
",",
"label_shapes",
"=",
"None",
")",
"mod",
".",
"set_params",
"(",
"arg_params",
"=",
"arg_params",
",",
"aux_params",
"=",
"aux_params",
")",
"data_forward",
"=",
"[",
"]",
"for",
"idx",
",",
"input_name",
"in",
"enumerate",
"(",
"data_names",
")",
":",
"val",
"=",
"inputs",
"[",
"idx",
"]",
"data_forward",
".",
"append",
"(",
"val",
")",
"mod",
".",
"forward",
"(",
"io",
".",
"DataBatch",
"(",
"data_forward",
")",
")",
"result",
"=",
"mod",
".",
"get_outputs",
"(",
")",
"[",
"0",
"]",
".",
"asnumpy",
"(",
")",
"return",
"result",
".",
"shape"
] |
Helper function to obtain the shape of an array
|
[
"Helper",
"function",
"to",
"obtain",
"the",
"shape",
"of",
"an",
"array"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_translation_utils.py#L216-L247
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
imresize
|
def imresize(src, w, h, *args, **kwargs):
r"""Resize image with OpenCV.
.. note:: `imresize` uses OpenCV (not the CV2 Python library). MXNet must have been built
with USE_OPENCV=1 for `imresize` to work.
Parameters
----------
src : NDArray
source image
w : int, required
Width of resized image.
h : int, required
Height of resized image.
interp : int, optional, default=1
Interpolation method (default=cv2.INTER_LINEAR).
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
out : NDArray, optional
The output NDArray to hold the result.
Returns
-------
out : NDArray or list of NDArrays
The output of this function.
Example
-------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> new_image = mx.img.resize(image, 240, 360)
>>> new_image
<NDArray 240x360x3 @cpu(0)>
"""
return _internal._cvimresize(src, w, h, *args, **kwargs)
|
python
|
def imresize(src, w, h, *args, **kwargs):
r"""Resize image with OpenCV.
.. note:: `imresize` uses OpenCV (not the CV2 Python library). MXNet must have been built
with USE_OPENCV=1 for `imresize` to work.
Parameters
----------
src : NDArray
source image
w : int, required
Width of resized image.
h : int, required
Height of resized image.
interp : int, optional, default=1
Interpolation method (default=cv2.INTER_LINEAR).
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
out : NDArray, optional
The output NDArray to hold the result.
Returns
-------
out : NDArray or list of NDArrays
The output of this function.
Example
-------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> new_image = mx.img.resize(image, 240, 360)
>>> new_image
<NDArray 240x360x3 @cpu(0)>
"""
return _internal._cvimresize(src, w, h, *args, **kwargs)
|
[
"def",
"imresize",
"(",
"src",
",",
"w",
",",
"h",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_internal",
".",
"_cvimresize",
"(",
"src",
",",
"w",
",",
"h",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
r"""Resize image with OpenCV.
.. note:: `imresize` uses OpenCV (not the CV2 Python library). MXNet must have been built
with USE_OPENCV=1 for `imresize` to work.
Parameters
----------
src : NDArray
source image
w : int, required
Width of resized image.
h : int, required
Height of resized image.
interp : int, optional, default=1
Interpolation method (default=cv2.INTER_LINEAR).
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
out : NDArray, optional
The output NDArray to hold the result.
Returns
-------
out : NDArray or list of NDArrays
The output of this function.
Example
-------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> new_image = mx.img.resize(image, 240, 360)
>>> new_image
<NDArray 240x360x3 @cpu(0)>
|
[
"r",
"Resize",
"image",
"with",
"OpenCV",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L86-L140
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
imdecode
|
def imdecode(buf, *args, **kwargs):
"""Decode an image to an NDArray.
.. note:: `imdecode` uses OpenCV (not the CV2 Python library).
MXNet must have been built with USE_OPENCV=1 for `imdecode` to work.
Parameters
----------
buf : str/bytes/bytearray or numpy.ndarray
Binary image data as string or numpy ndarray.
flag : int, optional, default=1
1 for three channel color output. 0 for grayscale output.
to_rgb : int, optional, default=1
1 for RGB formatted output (MXNet default). 0 for BGR formatted output (OpenCV default).
out : NDArray, optional
Output buffer. Use `None` for automatic allocation.
Returns
-------
NDArray
An `NDArray` containing the image.
Example
-------
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 224x224x3 @cpu(0)>
Set `flag` parameter to 0 to get grayscale output
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image, flag=0)
>>> image
<NDArray 224x224x1 @cpu(0)>
Set `to_rgb` parameter to 0 to get output in OpenCV format (BGR)
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image, to_rgb=0)
>>> image
<NDArray 224x224x3 @cpu(0)>
"""
if not isinstance(buf, nd.NDArray):
if sys.version_info[0] == 3 and not isinstance(buf, (bytes, bytearray, np.ndarray)):
raise ValueError('buf must be of type bytes, bytearray or numpy.ndarray,'
'if you would like to input type str, please convert to bytes')
buf = nd.array(np.frombuffer(buf, dtype=np.uint8), dtype=np.uint8)
return _internal._cvimdecode(buf, *args, **kwargs)
|
python
|
def imdecode(buf, *args, **kwargs):
"""Decode an image to an NDArray.
.. note:: `imdecode` uses OpenCV (not the CV2 Python library).
MXNet must have been built with USE_OPENCV=1 for `imdecode` to work.
Parameters
----------
buf : str/bytes/bytearray or numpy.ndarray
Binary image data as string or numpy ndarray.
flag : int, optional, default=1
1 for three channel color output. 0 for grayscale output.
to_rgb : int, optional, default=1
1 for RGB formatted output (MXNet default). 0 for BGR formatted output (OpenCV default).
out : NDArray, optional
Output buffer. Use `None` for automatic allocation.
Returns
-------
NDArray
An `NDArray` containing the image.
Example
-------
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 224x224x3 @cpu(0)>
Set `flag` parameter to 0 to get grayscale output
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image, flag=0)
>>> image
<NDArray 224x224x1 @cpu(0)>
Set `to_rgb` parameter to 0 to get output in OpenCV format (BGR)
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image, to_rgb=0)
>>> image
<NDArray 224x224x3 @cpu(0)>
"""
if not isinstance(buf, nd.NDArray):
if sys.version_info[0] == 3 and not isinstance(buf, (bytes, bytearray, np.ndarray)):
raise ValueError('buf must be of type bytes, bytearray or numpy.ndarray,'
'if you would like to input type str, please convert to bytes')
buf = nd.array(np.frombuffer(buf, dtype=np.uint8), dtype=np.uint8)
return _internal._cvimdecode(buf, *args, **kwargs)
|
[
"def",
"imdecode",
"(",
"buf",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"isinstance",
"(",
"buf",
",",
"nd",
".",
"NDArray",
")",
":",
"if",
"sys",
".",
"version_info",
"[",
"0",
"]",
"==",
"3",
"and",
"not",
"isinstance",
"(",
"buf",
",",
"(",
"bytes",
",",
"bytearray",
",",
"np",
".",
"ndarray",
")",
")",
":",
"raise",
"ValueError",
"(",
"'buf must be of type bytes, bytearray or numpy.ndarray,'",
"'if you would like to input type str, please convert to bytes'",
")",
"buf",
"=",
"nd",
".",
"array",
"(",
"np",
".",
"frombuffer",
"(",
"buf",
",",
"dtype",
"=",
"np",
".",
"uint8",
")",
",",
"dtype",
"=",
"np",
".",
"uint8",
")",
"return",
"_internal",
".",
"_cvimdecode",
"(",
"buf",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
Decode an image to an NDArray.
.. note:: `imdecode` uses OpenCV (not the CV2 Python library).
MXNet must have been built with USE_OPENCV=1 for `imdecode` to work.
Parameters
----------
buf : str/bytes/bytearray or numpy.ndarray
Binary image data as string or numpy ndarray.
flag : int, optional, default=1
1 for three channel color output. 0 for grayscale output.
to_rgb : int, optional, default=1
1 for RGB formatted output (MXNet default). 0 for BGR formatted output (OpenCV default).
out : NDArray, optional
Output buffer. Use `None` for automatic allocation.
Returns
-------
NDArray
An `NDArray` containing the image.
Example
-------
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 224x224x3 @cpu(0)>
Set `flag` parameter to 0 to get grayscale output
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image, flag=0)
>>> image
<NDArray 224x224x1 @cpu(0)>
Set `to_rgb` parameter to 0 to get output in OpenCV format (BGR)
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image, to_rgb=0)
>>> image
<NDArray 224x224x3 @cpu(0)>
|
[
"Decode",
"an",
"image",
"to",
"an",
"NDArray",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L143-L198
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
scale_down
|
def scale_down(src_size, size):
"""Scales down crop size if it's larger than image size.
If width/height of the crop is larger than the width/height of the image,
sets the width/height to the width/height of the image.
Parameters
----------
src_size : tuple of int
Size of the image in (width, height) format.
size : tuple of int
Size of the crop in (width, height) format.
Returns
-------
tuple of int
A tuple containing the scaled crop size in (width, height) format.
Example
--------
>>> src_size = (640,480)
>>> size = (720,120)
>>> new_size = mx.img.scale_down(src_size, size)
>>> new_size
(640,106)
"""
w, h = size
sw, sh = src_size
if sh < h:
w, h = float(w * sh) / h, sh
if sw < w:
w, h = sw, float(h * sw) / w
return int(w), int(h)
|
python
|
def scale_down(src_size, size):
"""Scales down crop size if it's larger than image size.
If width/height of the crop is larger than the width/height of the image,
sets the width/height to the width/height of the image.
Parameters
----------
src_size : tuple of int
Size of the image in (width, height) format.
size : tuple of int
Size of the crop in (width, height) format.
Returns
-------
tuple of int
A tuple containing the scaled crop size in (width, height) format.
Example
--------
>>> src_size = (640,480)
>>> size = (720,120)
>>> new_size = mx.img.scale_down(src_size, size)
>>> new_size
(640,106)
"""
w, h = size
sw, sh = src_size
if sh < h:
w, h = float(w * sh) / h, sh
if sw < w:
w, h = sw, float(h * sw) / w
return int(w), int(h)
|
[
"def",
"scale_down",
"(",
"src_size",
",",
"size",
")",
":",
"w",
",",
"h",
"=",
"size",
"sw",
",",
"sh",
"=",
"src_size",
"if",
"sh",
"<",
"h",
":",
"w",
",",
"h",
"=",
"float",
"(",
"w",
"*",
"sh",
")",
"/",
"h",
",",
"sh",
"if",
"sw",
"<",
"w",
":",
"w",
",",
"h",
"=",
"sw",
",",
"float",
"(",
"h",
"*",
"sw",
")",
"/",
"w",
"return",
"int",
"(",
"w",
")",
",",
"int",
"(",
"h",
")"
] |
Scales down crop size if it's larger than image size.
If width/height of the crop is larger than the width/height of the image,
sets the width/height to the width/height of the image.
Parameters
----------
src_size : tuple of int
Size of the image in (width, height) format.
size : tuple of int
Size of the crop in (width, height) format.
Returns
-------
tuple of int
A tuple containing the scaled crop size in (width, height) format.
Example
--------
>>> src_size = (640,480)
>>> size = (720,120)
>>> new_size = mx.img.scale_down(src_size, size)
>>> new_size
(640,106)
|
[
"Scales",
"down",
"crop",
"size",
"if",
"it",
"s",
"larger",
"than",
"image",
"size",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L201-L233
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
copyMakeBorder
|
def copyMakeBorder(src, top, bot, left, right, *args, **kwargs):
"""Pad image border with OpenCV.
Parameters
----------
src : NDArray
source image
top : int, required
Top margin.
bot : int, required
Bottom margin.
left : int, required
Left margin.
right : int, required
Right margin.
type : int, optional, default='0'
Filling type (default=cv2.BORDER_CONSTANT).
0 - cv2.BORDER_CONSTANT - Adds a constant colored border.
1 - cv2.BORDER_REFLECT - Border will be mirror reflection of the
border elements, like this : fedcba|abcdefgh|hgfedcb
2 - cv2.BORDER_REFLECT_101 or cv.BORDER_DEFAULT - Same as above,
but with a slight change, like this : gfedcb|abcdefgh|gfedcba
3 - cv2.BORDER_REPLICATE - Last element is replicated throughout,
like this: aaaaaa|abcdefgh|hhhhhhh
4 - cv2.BORDER_WRAP - it will look like this : cdefgh|abcdefgh|abcdefg
value : double, optional, default=0
(Deprecated! Use ``values`` instead.) Fill with single value.
values : tuple of <double>, optional, default=[]
Fill with value(RGB[A] or gray), up to 4 channels.
out : NDArray, optional
The output NDArray to hold the result.
Returns
-------
out : NDArray or list of NDArrays
The output of this function.
Example
--------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> new_image = mx_border = mx.image.copyMakeBorder(mx_img, 1, 2, 3, 4, type=0)
>>> new_image
<NDArray 2324x3489x3 @cpu(0)>
"""
return _internal._cvcopyMakeBorder(src, top, bot, left, right, *args, **kwargs)
|
python
|
def copyMakeBorder(src, top, bot, left, right, *args, **kwargs):
"""Pad image border with OpenCV.
Parameters
----------
src : NDArray
source image
top : int, required
Top margin.
bot : int, required
Bottom margin.
left : int, required
Left margin.
right : int, required
Right margin.
type : int, optional, default='0'
Filling type (default=cv2.BORDER_CONSTANT).
0 - cv2.BORDER_CONSTANT - Adds a constant colored border.
1 - cv2.BORDER_REFLECT - Border will be mirror reflection of the
border elements, like this : fedcba|abcdefgh|hgfedcb
2 - cv2.BORDER_REFLECT_101 or cv.BORDER_DEFAULT - Same as above,
but with a slight change, like this : gfedcb|abcdefgh|gfedcba
3 - cv2.BORDER_REPLICATE - Last element is replicated throughout,
like this: aaaaaa|abcdefgh|hhhhhhh
4 - cv2.BORDER_WRAP - it will look like this : cdefgh|abcdefgh|abcdefg
value : double, optional, default=0
(Deprecated! Use ``values`` instead.) Fill with single value.
values : tuple of <double>, optional, default=[]
Fill with value(RGB[A] or gray), up to 4 channels.
out : NDArray, optional
The output NDArray to hold the result.
Returns
-------
out : NDArray or list of NDArrays
The output of this function.
Example
--------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> new_image = mx_border = mx.image.copyMakeBorder(mx_img, 1, 2, 3, 4, type=0)
>>> new_image
<NDArray 2324x3489x3 @cpu(0)>
"""
return _internal._cvcopyMakeBorder(src, top, bot, left, right, *args, **kwargs)
|
[
"def",
"copyMakeBorder",
"(",
"src",
",",
"top",
",",
"bot",
",",
"left",
",",
"right",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_internal",
".",
"_cvcopyMakeBorder",
"(",
"src",
",",
"top",
",",
"bot",
",",
"left",
",",
"right",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
Pad image border with OpenCV.
Parameters
----------
src : NDArray
source image
top : int, required
Top margin.
bot : int, required
Bottom margin.
left : int, required
Left margin.
right : int, required
Right margin.
type : int, optional, default='0'
Filling type (default=cv2.BORDER_CONSTANT).
0 - cv2.BORDER_CONSTANT - Adds a constant colored border.
1 - cv2.BORDER_REFLECT - Border will be mirror reflection of the
border elements, like this : fedcba|abcdefgh|hgfedcb
2 - cv2.BORDER_REFLECT_101 or cv.BORDER_DEFAULT - Same as above,
but with a slight change, like this : gfedcb|abcdefgh|gfedcba
3 - cv2.BORDER_REPLICATE - Last element is replicated throughout,
like this: aaaaaa|abcdefgh|hhhhhhh
4 - cv2.BORDER_WRAP - it will look like this : cdefgh|abcdefgh|abcdefg
value : double, optional, default=0
(Deprecated! Use ``values`` instead.) Fill with single value.
values : tuple of <double>, optional, default=[]
Fill with value(RGB[A] or gray), up to 4 channels.
out : NDArray, optional
The output NDArray to hold the result.
Returns
-------
out : NDArray or list of NDArrays
The output of this function.
Example
--------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> new_image = mx_border = mx.image.copyMakeBorder(mx_img, 1, 2, 3, 4, type=0)
>>> new_image
<NDArray 2324x3489x3 @cpu(0)>
|
[
"Pad",
"image",
"border",
"with",
"OpenCV",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L236-L286
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
_get_interp_method
|
def _get_interp_method(interp, sizes=()):
"""Get the interpolation method for resize functions.
The major purpose of this function is to wrap a random interp method selection
and a auto-estimation method.
Parameters
----------
interp : int
interpolation method for all resizing operations
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
sizes : tuple of int
(old_height, old_width, new_height, new_width), if None provided, auto(9)
will return Area(2) anyway.
Returns
-------
int
interp method from 0 to 4
"""
if interp == 9:
if sizes:
assert len(sizes) == 4
oh, ow, nh, nw = sizes
if nh > oh and nw > ow:
return 2
elif nh < oh and nw < ow:
return 3
else:
return 1
else:
return 2
if interp == 10:
return random.randint(0, 4)
if interp not in (0, 1, 2, 3, 4):
raise ValueError('Unknown interp method %d' % interp)
return interp
|
python
|
def _get_interp_method(interp, sizes=()):
"""Get the interpolation method for resize functions.
The major purpose of this function is to wrap a random interp method selection
and a auto-estimation method.
Parameters
----------
interp : int
interpolation method for all resizing operations
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
sizes : tuple of int
(old_height, old_width, new_height, new_width), if None provided, auto(9)
will return Area(2) anyway.
Returns
-------
int
interp method from 0 to 4
"""
if interp == 9:
if sizes:
assert len(sizes) == 4
oh, ow, nh, nw = sizes
if nh > oh and nw > ow:
return 2
elif nh < oh and nw < ow:
return 3
else:
return 1
else:
return 2
if interp == 10:
return random.randint(0, 4)
if interp not in (0, 1, 2, 3, 4):
raise ValueError('Unknown interp method %d' % interp)
return interp
|
[
"def",
"_get_interp_method",
"(",
"interp",
",",
"sizes",
"=",
"(",
")",
")",
":",
"if",
"interp",
"==",
"9",
":",
"if",
"sizes",
":",
"assert",
"len",
"(",
"sizes",
")",
"==",
"4",
"oh",
",",
"ow",
",",
"nh",
",",
"nw",
"=",
"sizes",
"if",
"nh",
">",
"oh",
"and",
"nw",
">",
"ow",
":",
"return",
"2",
"elif",
"nh",
"<",
"oh",
"and",
"nw",
"<",
"ow",
":",
"return",
"3",
"else",
":",
"return",
"1",
"else",
":",
"return",
"2",
"if",
"interp",
"==",
"10",
":",
"return",
"random",
".",
"randint",
"(",
"0",
",",
"4",
")",
"if",
"interp",
"not",
"in",
"(",
"0",
",",
"1",
",",
"2",
",",
"3",
",",
"4",
")",
":",
"raise",
"ValueError",
"(",
"'Unknown interp method %d'",
"%",
"interp",
")",
"return",
"interp"
] |
Get the interpolation method for resize functions.
The major purpose of this function is to wrap a random interp method selection
and a auto-estimation method.
Parameters
----------
interp : int
interpolation method for all resizing operations
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
sizes : tuple of int
(old_height, old_width, new_height, new_width), if None provided, auto(9)
will return Area(2) anyway.
Returns
-------
int
interp method from 0 to 4
|
[
"Get",
"the",
"interpolation",
"method",
"for",
"resize",
"functions",
".",
"The",
"major",
"purpose",
"of",
"this",
"function",
"is",
"to",
"wrap",
"a",
"random",
"interp",
"method",
"selection",
"and",
"a",
"auto",
"-",
"estimation",
"method",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L289-L341
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
resize_short
|
def resize_short(src, size, interp=2):
"""Resizes shorter edge to size.
.. note:: `resize_short` uses OpenCV (not the CV2 Python library).
MXNet must have been built with OpenCV for `resize_short` to work.
Resizes the original image by setting the shorter edge to size
and setting the longer edge accordingly.
Resizing function is called from OpenCV.
Parameters
----------
src : NDArray
The original image.
size : int
The length to be set for the shorter edge.
interp : int, optional, default=2
Interpolation method used for resizing the image.
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
Returns
-------
NDArray
An 'NDArray' containing the resized image.
Example
-------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> size = 640
>>> new_image = mx.img.resize_short(image, size)
>>> new_image
<NDArray 2321x3482x3 @cpu(0)>
"""
h, w, _ = src.shape
if h > w:
new_h, new_w = size * h // w, size
else:
new_h, new_w = size, size * w // h
return imresize(src, new_w, new_h, interp=_get_interp_method(interp, (h, w, new_h, new_w)))
|
python
|
def resize_short(src, size, interp=2):
"""Resizes shorter edge to size.
.. note:: `resize_short` uses OpenCV (not the CV2 Python library).
MXNet must have been built with OpenCV for `resize_short` to work.
Resizes the original image by setting the shorter edge to size
and setting the longer edge accordingly.
Resizing function is called from OpenCV.
Parameters
----------
src : NDArray
The original image.
size : int
The length to be set for the shorter edge.
interp : int, optional, default=2
Interpolation method used for resizing the image.
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
Returns
-------
NDArray
An 'NDArray' containing the resized image.
Example
-------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> size = 640
>>> new_image = mx.img.resize_short(image, size)
>>> new_image
<NDArray 2321x3482x3 @cpu(0)>
"""
h, w, _ = src.shape
if h > w:
new_h, new_w = size * h // w, size
else:
new_h, new_w = size, size * w // h
return imresize(src, new_w, new_h, interp=_get_interp_method(interp, (h, w, new_h, new_w)))
|
[
"def",
"resize_short",
"(",
"src",
",",
"size",
",",
"interp",
"=",
"2",
")",
":",
"h",
",",
"w",
",",
"_",
"=",
"src",
".",
"shape",
"if",
"h",
">",
"w",
":",
"new_h",
",",
"new_w",
"=",
"size",
"*",
"h",
"//",
"w",
",",
"size",
"else",
":",
"new_h",
",",
"new_w",
"=",
"size",
",",
"size",
"*",
"w",
"//",
"h",
"return",
"imresize",
"(",
"src",
",",
"new_w",
",",
"new_h",
",",
"interp",
"=",
"_get_interp_method",
"(",
"interp",
",",
"(",
"h",
",",
"w",
",",
"new_h",
",",
"new_w",
")",
")",
")"
] |
Resizes shorter edge to size.
.. note:: `resize_short` uses OpenCV (not the CV2 Python library).
MXNet must have been built with OpenCV for `resize_short` to work.
Resizes the original image by setting the shorter edge to size
and setting the longer edge accordingly.
Resizing function is called from OpenCV.
Parameters
----------
src : NDArray
The original image.
size : int
The length to be set for the shorter edge.
interp : int, optional, default=2
Interpolation method used for resizing the image.
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
More details can be found in the documentation of OpenCV, please refer to
http://docs.opencv.org/master/da/d54/group__imgproc__transform.html.
Returns
-------
NDArray
An 'NDArray' containing the resized image.
Example
-------
>>> with open("flower.jpeg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.img.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> size = 640
>>> new_image = mx.img.resize_short(image, size)
>>> new_image
<NDArray 2321x3482x3 @cpu(0)>
|
[
"Resizes",
"shorter",
"edge",
"to",
"size",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L344-L403
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
fixed_crop
|
def fixed_crop(src, x0, y0, w, h, size=None, interp=2):
"""Crop src at fixed location, and (optionally) resize it to size.
Parameters
----------
src : NDArray
Input image
x0 : int
Left boundary of the cropping area
y0 : int
Top boundary of the cropping area
w : int
Width of the cropping area
h : int
Height of the cropping area
size : tuple of (w, h)
Optional, resize to new size after cropping
interp : int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
An `NDArray` containing the cropped image.
"""
out = nd.slice(src, begin=(y0, x0, 0), end=(y0 + h, x0 + w, int(src.shape[2])))
if size is not None and (w, h) != size:
sizes = (h, w, size[1], size[0])
out = imresize(out, *size, interp=_get_interp_method(interp, sizes))
return out
|
python
|
def fixed_crop(src, x0, y0, w, h, size=None, interp=2):
"""Crop src at fixed location, and (optionally) resize it to size.
Parameters
----------
src : NDArray
Input image
x0 : int
Left boundary of the cropping area
y0 : int
Top boundary of the cropping area
w : int
Width of the cropping area
h : int
Height of the cropping area
size : tuple of (w, h)
Optional, resize to new size after cropping
interp : int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
An `NDArray` containing the cropped image.
"""
out = nd.slice(src, begin=(y0, x0, 0), end=(y0 + h, x0 + w, int(src.shape[2])))
if size is not None and (w, h) != size:
sizes = (h, w, size[1], size[0])
out = imresize(out, *size, interp=_get_interp_method(interp, sizes))
return out
|
[
"def",
"fixed_crop",
"(",
"src",
",",
"x0",
",",
"y0",
",",
"w",
",",
"h",
",",
"size",
"=",
"None",
",",
"interp",
"=",
"2",
")",
":",
"out",
"=",
"nd",
".",
"slice",
"(",
"src",
",",
"begin",
"=",
"(",
"y0",
",",
"x0",
",",
"0",
")",
",",
"end",
"=",
"(",
"y0",
"+",
"h",
",",
"x0",
"+",
"w",
",",
"int",
"(",
"src",
".",
"shape",
"[",
"2",
"]",
")",
")",
")",
"if",
"size",
"is",
"not",
"None",
"and",
"(",
"w",
",",
"h",
")",
"!=",
"size",
":",
"sizes",
"=",
"(",
"h",
",",
"w",
",",
"size",
"[",
"1",
"]",
",",
"size",
"[",
"0",
"]",
")",
"out",
"=",
"imresize",
"(",
"out",
",",
"*",
"size",
",",
"interp",
"=",
"_get_interp_method",
"(",
"interp",
",",
"sizes",
")",
")",
"return",
"out"
] |
Crop src at fixed location, and (optionally) resize it to size.
Parameters
----------
src : NDArray
Input image
x0 : int
Left boundary of the cropping area
y0 : int
Top boundary of the cropping area
w : int
Width of the cropping area
h : int
Height of the cropping area
size : tuple of (w, h)
Optional, resize to new size after cropping
interp : int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
An `NDArray` containing the cropped image.
|
[
"Crop",
"src",
"at",
"fixed",
"location",
"and",
"(",
"optionally",
")",
"resize",
"it",
"to",
"size",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L406-L435
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
center_crop
|
def center_crop(src, size, interp=2):
"""Crops the image `src` to the given `size` by trimming on all four
sides and preserving the center of the image. Upsamples if `src` is smaller
than `size`.
.. note:: This requires MXNet to be compiled with USE_OPENCV.
Parameters
----------
src : NDArray
Binary source image data.
size : list or tuple of int
The desired output image size.
interp : int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
The cropped image.
Tuple
(x, y, width, height) where x, y are the positions of the crop in the
original image and width, height the dimensions of the crop.
Example
-------
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.image.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> cropped_image, (x, y, width, height) = mx.image.center_crop(image, (1000, 500))
>>> cropped_image
<NDArray 500x1000x3 @cpu(0)>
>>> x, y, width, height
(1241, 910, 1000, 500)
"""
h, w, _ = src.shape
new_w, new_h = scale_down((w, h), size)
x0 = int((w - new_w) / 2)
y0 = int((h - new_h) / 2)
out = fixed_crop(src, x0, y0, new_w, new_h, size, interp)
return out, (x0, y0, new_w, new_h)
|
python
|
def center_crop(src, size, interp=2):
"""Crops the image `src` to the given `size` by trimming on all four
sides and preserving the center of the image. Upsamples if `src` is smaller
than `size`.
.. note:: This requires MXNet to be compiled with USE_OPENCV.
Parameters
----------
src : NDArray
Binary source image data.
size : list or tuple of int
The desired output image size.
interp : int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
The cropped image.
Tuple
(x, y, width, height) where x, y are the positions of the crop in the
original image and width, height the dimensions of the crop.
Example
-------
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.image.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> cropped_image, (x, y, width, height) = mx.image.center_crop(image, (1000, 500))
>>> cropped_image
<NDArray 500x1000x3 @cpu(0)>
>>> x, y, width, height
(1241, 910, 1000, 500)
"""
h, w, _ = src.shape
new_w, new_h = scale_down((w, h), size)
x0 = int((w - new_w) / 2)
y0 = int((h - new_h) / 2)
out = fixed_crop(src, x0, y0, new_w, new_h, size, interp)
return out, (x0, y0, new_w, new_h)
|
[
"def",
"center_crop",
"(",
"src",
",",
"size",
",",
"interp",
"=",
"2",
")",
":",
"h",
",",
"w",
",",
"_",
"=",
"src",
".",
"shape",
"new_w",
",",
"new_h",
"=",
"scale_down",
"(",
"(",
"w",
",",
"h",
")",
",",
"size",
")",
"x0",
"=",
"int",
"(",
"(",
"w",
"-",
"new_w",
")",
"/",
"2",
")",
"y0",
"=",
"int",
"(",
"(",
"h",
"-",
"new_h",
")",
"/",
"2",
")",
"out",
"=",
"fixed_crop",
"(",
"src",
",",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
",",
"size",
",",
"interp",
")",
"return",
"out",
",",
"(",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
")"
] |
Crops the image `src` to the given `size` by trimming on all four
sides and preserving the center of the image. Upsamples if `src` is smaller
than `size`.
.. note:: This requires MXNet to be compiled with USE_OPENCV.
Parameters
----------
src : NDArray
Binary source image data.
size : list or tuple of int
The desired output image size.
interp : int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
The cropped image.
Tuple
(x, y, width, height) where x, y are the positions of the crop in the
original image and width, height the dimensions of the crop.
Example
-------
>>> with open("flower.jpg", 'rb') as fp:
... str_image = fp.read()
...
>>> image = mx.image.imdecode(str_image)
>>> image
<NDArray 2321x3482x3 @cpu(0)>
>>> cropped_image, (x, y, width, height) = mx.image.center_crop(image, (1000, 500))
>>> cropped_image
<NDArray 500x1000x3 @cpu(0)>
>>> x, y, width, height
(1241, 910, 1000, 500)
|
[
"Crops",
"the",
"image",
"src",
"to",
"the",
"given",
"size",
"by",
"trimming",
"on",
"all",
"four",
"sides",
"and",
"preserving",
"the",
"center",
"of",
"the",
"image",
".",
"Upsamples",
"if",
"src",
"is",
"smaller",
"than",
"size",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L477-L523
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
color_normalize
|
def color_normalize(src, mean, std=None):
"""Normalize src with mean and std.
Parameters
----------
src : NDArray
Input image
mean : NDArray
RGB mean to be subtracted
std : NDArray
RGB standard deviation to be divided
Returns
-------
NDArray
An `NDArray` containing the normalized image.
"""
if mean is not None:
src -= mean
if std is not None:
src /= std
return src
|
python
|
def color_normalize(src, mean, std=None):
"""Normalize src with mean and std.
Parameters
----------
src : NDArray
Input image
mean : NDArray
RGB mean to be subtracted
std : NDArray
RGB standard deviation to be divided
Returns
-------
NDArray
An `NDArray` containing the normalized image.
"""
if mean is not None:
src -= mean
if std is not None:
src /= std
return src
|
[
"def",
"color_normalize",
"(",
"src",
",",
"mean",
",",
"std",
"=",
"None",
")",
":",
"if",
"mean",
"is",
"not",
"None",
":",
"src",
"-=",
"mean",
"if",
"std",
"is",
"not",
"None",
":",
"src",
"/=",
"std",
"return",
"src"
] |
Normalize src with mean and std.
Parameters
----------
src : NDArray
Input image
mean : NDArray
RGB mean to be subtracted
std : NDArray
RGB standard deviation to be divided
Returns
-------
NDArray
An `NDArray` containing the normalized image.
|
[
"Normalize",
"src",
"with",
"mean",
"and",
"std",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L526-L547
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
random_size_crop
|
def random_size_crop(src, size, area, ratio, interp=2, **kwargs):
"""Randomly crop src with size. Randomize area and aspect ratio.
Parameters
----------
src : NDArray
Input image
size : tuple of (int, int)
Size of the crop formatted as (width, height).
area : float in (0, 1] or tuple of (float, float)
If tuple, minimum area and maximum area to be maintained after cropping
If float, minimum area to be maintained after cropping, maximum area is set to 1.0
ratio : tuple of (float, float)
Aspect ratio range as (min_aspect_ratio, max_aspect_ratio)
interp: int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
An `NDArray` containing the cropped image.
Tuple
A tuple (x, y, width, height) where (x, y) is top-left position of the crop in the
original image and (width, height) are the dimensions of the cropped image.
"""
h, w, _ = src.shape
src_area = h * w
if 'min_area' in kwargs:
warnings.warn('`min_area` is deprecated. Please use `area` instead.',
DeprecationWarning)
area = kwargs.pop('min_area')
assert not kwargs, "unexpected keyword arguments for `random_size_crop`."
if isinstance(area, numeric_types):
area = (area, 1.0)
for _ in range(10):
target_area = random.uniform(area[0], area[1]) * src_area
log_ratio = (np.log(ratio[0]), np.log(ratio[1]))
new_ratio = np.exp(random.uniform(*log_ratio))
new_w = int(round(np.sqrt(target_area * new_ratio)))
new_h = int(round(np.sqrt(target_area / new_ratio)))
if new_w <= w and new_h <= h:
x0 = random.randint(0, w - new_w)
y0 = random.randint(0, h - new_h)
out = fixed_crop(src, x0, y0, new_w, new_h, size, interp)
return out, (x0, y0, new_w, new_h)
# fall back to center_crop
return center_crop(src, size, interp)
|
python
|
def random_size_crop(src, size, area, ratio, interp=2, **kwargs):
"""Randomly crop src with size. Randomize area and aspect ratio.
Parameters
----------
src : NDArray
Input image
size : tuple of (int, int)
Size of the crop formatted as (width, height).
area : float in (0, 1] or tuple of (float, float)
If tuple, minimum area and maximum area to be maintained after cropping
If float, minimum area to be maintained after cropping, maximum area is set to 1.0
ratio : tuple of (float, float)
Aspect ratio range as (min_aspect_ratio, max_aspect_ratio)
interp: int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
An `NDArray` containing the cropped image.
Tuple
A tuple (x, y, width, height) where (x, y) is top-left position of the crop in the
original image and (width, height) are the dimensions of the cropped image.
"""
h, w, _ = src.shape
src_area = h * w
if 'min_area' in kwargs:
warnings.warn('`min_area` is deprecated. Please use `area` instead.',
DeprecationWarning)
area = kwargs.pop('min_area')
assert not kwargs, "unexpected keyword arguments for `random_size_crop`."
if isinstance(area, numeric_types):
area = (area, 1.0)
for _ in range(10):
target_area = random.uniform(area[0], area[1]) * src_area
log_ratio = (np.log(ratio[0]), np.log(ratio[1]))
new_ratio = np.exp(random.uniform(*log_ratio))
new_w = int(round(np.sqrt(target_area * new_ratio)))
new_h = int(round(np.sqrt(target_area / new_ratio)))
if new_w <= w and new_h <= h:
x0 = random.randint(0, w - new_w)
y0 = random.randint(0, h - new_h)
out = fixed_crop(src, x0, y0, new_w, new_h, size, interp)
return out, (x0, y0, new_w, new_h)
# fall back to center_crop
return center_crop(src, size, interp)
|
[
"def",
"random_size_crop",
"(",
"src",
",",
"size",
",",
"area",
",",
"ratio",
",",
"interp",
"=",
"2",
",",
"*",
"*",
"kwargs",
")",
":",
"h",
",",
"w",
",",
"_",
"=",
"src",
".",
"shape",
"src_area",
"=",
"h",
"*",
"w",
"if",
"'min_area'",
"in",
"kwargs",
":",
"warnings",
".",
"warn",
"(",
"'`min_area` is deprecated. Please use `area` instead.'",
",",
"DeprecationWarning",
")",
"area",
"=",
"kwargs",
".",
"pop",
"(",
"'min_area'",
")",
"assert",
"not",
"kwargs",
",",
"\"unexpected keyword arguments for `random_size_crop`.\"",
"if",
"isinstance",
"(",
"area",
",",
"numeric_types",
")",
":",
"area",
"=",
"(",
"area",
",",
"1.0",
")",
"for",
"_",
"in",
"range",
"(",
"10",
")",
":",
"target_area",
"=",
"random",
".",
"uniform",
"(",
"area",
"[",
"0",
"]",
",",
"area",
"[",
"1",
"]",
")",
"*",
"src_area",
"log_ratio",
"=",
"(",
"np",
".",
"log",
"(",
"ratio",
"[",
"0",
"]",
")",
",",
"np",
".",
"log",
"(",
"ratio",
"[",
"1",
"]",
")",
")",
"new_ratio",
"=",
"np",
".",
"exp",
"(",
"random",
".",
"uniform",
"(",
"*",
"log_ratio",
")",
")",
"new_w",
"=",
"int",
"(",
"round",
"(",
"np",
".",
"sqrt",
"(",
"target_area",
"*",
"new_ratio",
")",
")",
")",
"new_h",
"=",
"int",
"(",
"round",
"(",
"np",
".",
"sqrt",
"(",
"target_area",
"/",
"new_ratio",
")",
")",
")",
"if",
"new_w",
"<=",
"w",
"and",
"new_h",
"<=",
"h",
":",
"x0",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"w",
"-",
"new_w",
")",
"y0",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"h",
"-",
"new_h",
")",
"out",
"=",
"fixed_crop",
"(",
"src",
",",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
",",
"size",
",",
"interp",
")",
"return",
"out",
",",
"(",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
")",
"# fall back to center_crop",
"return",
"center_crop",
"(",
"src",
",",
"size",
",",
"interp",
")"
] |
Randomly crop src with size. Randomize area and aspect ratio.
Parameters
----------
src : NDArray
Input image
size : tuple of (int, int)
Size of the crop formatted as (width, height).
area : float in (0, 1] or tuple of (float, float)
If tuple, minimum area and maximum area to be maintained after cropping
If float, minimum area to be maintained after cropping, maximum area is set to 1.0
ratio : tuple of (float, float)
Aspect ratio range as (min_aspect_ratio, max_aspect_ratio)
interp: int, optional, default=2
Interpolation method. See resize_short for details.
Returns
-------
NDArray
An `NDArray` containing the cropped image.
Tuple
A tuple (x, y, width, height) where (x, y) is top-left position of the crop in the
original image and (width, height) are the dimensions of the cropped image.
|
[
"Randomly",
"crop",
"src",
"with",
"size",
".",
"Randomize",
"area",
"and",
"aspect",
"ratio",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L550-L602
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
CreateAugmenter
|
def CreateAugmenter(data_shape, resize=0, rand_crop=False, rand_resize=False, rand_mirror=False,
mean=None, std=None, brightness=0, contrast=0, saturation=0, hue=0,
pca_noise=0, rand_gray=0, inter_method=2):
"""Creates an augmenter list.
Parameters
----------
data_shape : tuple of int
Shape for output data
resize : int
Resize shorter edge if larger than 0 at the begining
rand_crop : bool
Whether to enable random cropping other than center crop
rand_resize : bool
Whether to enable random sized cropping, require rand_crop to be enabled
rand_gray : float
[0, 1], probability to convert to grayscale for all channels, the number
of channels will not be reduced to 1
rand_mirror : bool
Whether to apply horizontal flip to image with probability 0.5
mean : np.ndarray or None
Mean pixel values for [r, g, b]
std : np.ndarray or None
Standard deviations for [r, g, b]
brightness : float
Brightness jittering range (percent)
contrast : float
Contrast jittering range (percent)
saturation : float
Saturation jittering range (percent)
hue : float
Hue jittering range (percent)
pca_noise : float
Pca noise level (percent)
inter_method : int, default=2(Area-based)
Interpolation method for all resizing operations
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
Examples
--------
>>> # An example of creating multiple augmenters
>>> augs = mx.image.CreateAugmenter(data_shape=(3, 300, 300), rand_mirror=True,
... mean=True, brightness=0.125, contrast=0.125, rand_gray=0.05,
... saturation=0.125, pca_noise=0.05, inter_method=10)
>>> # dump the details
>>> for aug in augs:
... aug.dumps()
"""
auglist = []
if resize > 0:
auglist.append(ResizeAug(resize, inter_method))
crop_size = (data_shape[2], data_shape[1])
if rand_resize:
assert rand_crop
auglist.append(RandomSizedCropAug(crop_size, 0.08, (3.0 / 4.0, 4.0 / 3.0), inter_method))
elif rand_crop:
auglist.append(RandomCropAug(crop_size, inter_method))
else:
auglist.append(CenterCropAug(crop_size, inter_method))
if rand_mirror:
auglist.append(HorizontalFlipAug(0.5))
auglist.append(CastAug())
if brightness or contrast or saturation:
auglist.append(ColorJitterAug(brightness, contrast, saturation))
if hue:
auglist.append(HueJitterAug(hue))
if pca_noise > 0:
eigval = np.array([55.46, 4.794, 1.148])
eigvec = np.array([[-0.5675, 0.7192, 0.4009],
[-0.5808, -0.0045, -0.8140],
[-0.5836, -0.6948, 0.4203]])
auglist.append(LightingAug(pca_noise, eigval, eigvec))
if rand_gray > 0:
auglist.append(RandomGrayAug(rand_gray))
if mean is True:
mean = nd.array([123.68, 116.28, 103.53])
elif mean is not None:
assert isinstance(mean, (np.ndarray, nd.NDArray)) and mean.shape[0] in [1, 3]
if std is True:
std = nd.array([58.395, 57.12, 57.375])
elif std is not None:
assert isinstance(std, (np.ndarray, nd.NDArray)) and std.shape[0] in [1, 3]
if mean is not None or std is not None:
auglist.append(ColorNormalizeAug(mean, std))
return auglist
|
python
|
def CreateAugmenter(data_shape, resize=0, rand_crop=False, rand_resize=False, rand_mirror=False,
mean=None, std=None, brightness=0, contrast=0, saturation=0, hue=0,
pca_noise=0, rand_gray=0, inter_method=2):
"""Creates an augmenter list.
Parameters
----------
data_shape : tuple of int
Shape for output data
resize : int
Resize shorter edge if larger than 0 at the begining
rand_crop : bool
Whether to enable random cropping other than center crop
rand_resize : bool
Whether to enable random sized cropping, require rand_crop to be enabled
rand_gray : float
[0, 1], probability to convert to grayscale for all channels, the number
of channels will not be reduced to 1
rand_mirror : bool
Whether to apply horizontal flip to image with probability 0.5
mean : np.ndarray or None
Mean pixel values for [r, g, b]
std : np.ndarray or None
Standard deviations for [r, g, b]
brightness : float
Brightness jittering range (percent)
contrast : float
Contrast jittering range (percent)
saturation : float
Saturation jittering range (percent)
hue : float
Hue jittering range (percent)
pca_noise : float
Pca noise level (percent)
inter_method : int, default=2(Area-based)
Interpolation method for all resizing operations
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
Examples
--------
>>> # An example of creating multiple augmenters
>>> augs = mx.image.CreateAugmenter(data_shape=(3, 300, 300), rand_mirror=True,
... mean=True, brightness=0.125, contrast=0.125, rand_gray=0.05,
... saturation=0.125, pca_noise=0.05, inter_method=10)
>>> # dump the details
>>> for aug in augs:
... aug.dumps()
"""
auglist = []
if resize > 0:
auglist.append(ResizeAug(resize, inter_method))
crop_size = (data_shape[2], data_shape[1])
if rand_resize:
assert rand_crop
auglist.append(RandomSizedCropAug(crop_size, 0.08, (3.0 / 4.0, 4.0 / 3.0), inter_method))
elif rand_crop:
auglist.append(RandomCropAug(crop_size, inter_method))
else:
auglist.append(CenterCropAug(crop_size, inter_method))
if rand_mirror:
auglist.append(HorizontalFlipAug(0.5))
auglist.append(CastAug())
if brightness or contrast or saturation:
auglist.append(ColorJitterAug(brightness, contrast, saturation))
if hue:
auglist.append(HueJitterAug(hue))
if pca_noise > 0:
eigval = np.array([55.46, 4.794, 1.148])
eigvec = np.array([[-0.5675, 0.7192, 0.4009],
[-0.5808, -0.0045, -0.8140],
[-0.5836, -0.6948, 0.4203]])
auglist.append(LightingAug(pca_noise, eigval, eigvec))
if rand_gray > 0:
auglist.append(RandomGrayAug(rand_gray))
if mean is True:
mean = nd.array([123.68, 116.28, 103.53])
elif mean is not None:
assert isinstance(mean, (np.ndarray, nd.NDArray)) and mean.shape[0] in [1, 3]
if std is True:
std = nd.array([58.395, 57.12, 57.375])
elif std is not None:
assert isinstance(std, (np.ndarray, nd.NDArray)) and std.shape[0] in [1, 3]
if mean is not None or std is not None:
auglist.append(ColorNormalizeAug(mean, std))
return auglist
|
[
"def",
"CreateAugmenter",
"(",
"data_shape",
",",
"resize",
"=",
"0",
",",
"rand_crop",
"=",
"False",
",",
"rand_resize",
"=",
"False",
",",
"rand_mirror",
"=",
"False",
",",
"mean",
"=",
"None",
",",
"std",
"=",
"None",
",",
"brightness",
"=",
"0",
",",
"contrast",
"=",
"0",
",",
"saturation",
"=",
"0",
",",
"hue",
"=",
"0",
",",
"pca_noise",
"=",
"0",
",",
"rand_gray",
"=",
"0",
",",
"inter_method",
"=",
"2",
")",
":",
"auglist",
"=",
"[",
"]",
"if",
"resize",
">",
"0",
":",
"auglist",
".",
"append",
"(",
"ResizeAug",
"(",
"resize",
",",
"inter_method",
")",
")",
"crop_size",
"=",
"(",
"data_shape",
"[",
"2",
"]",
",",
"data_shape",
"[",
"1",
"]",
")",
"if",
"rand_resize",
":",
"assert",
"rand_crop",
"auglist",
".",
"append",
"(",
"RandomSizedCropAug",
"(",
"crop_size",
",",
"0.08",
",",
"(",
"3.0",
"/",
"4.0",
",",
"4.0",
"/",
"3.0",
")",
",",
"inter_method",
")",
")",
"elif",
"rand_crop",
":",
"auglist",
".",
"append",
"(",
"RandomCropAug",
"(",
"crop_size",
",",
"inter_method",
")",
")",
"else",
":",
"auglist",
".",
"append",
"(",
"CenterCropAug",
"(",
"crop_size",
",",
"inter_method",
")",
")",
"if",
"rand_mirror",
":",
"auglist",
".",
"append",
"(",
"HorizontalFlipAug",
"(",
"0.5",
")",
")",
"auglist",
".",
"append",
"(",
"CastAug",
"(",
")",
")",
"if",
"brightness",
"or",
"contrast",
"or",
"saturation",
":",
"auglist",
".",
"append",
"(",
"ColorJitterAug",
"(",
"brightness",
",",
"contrast",
",",
"saturation",
")",
")",
"if",
"hue",
":",
"auglist",
".",
"append",
"(",
"HueJitterAug",
"(",
"hue",
")",
")",
"if",
"pca_noise",
">",
"0",
":",
"eigval",
"=",
"np",
".",
"array",
"(",
"[",
"55.46",
",",
"4.794",
",",
"1.148",
"]",
")",
"eigvec",
"=",
"np",
".",
"array",
"(",
"[",
"[",
"-",
"0.5675",
",",
"0.7192",
",",
"0.4009",
"]",
",",
"[",
"-",
"0.5808",
",",
"-",
"0.0045",
",",
"-",
"0.8140",
"]",
",",
"[",
"-",
"0.5836",
",",
"-",
"0.6948",
",",
"0.4203",
"]",
"]",
")",
"auglist",
".",
"append",
"(",
"LightingAug",
"(",
"pca_noise",
",",
"eigval",
",",
"eigvec",
")",
")",
"if",
"rand_gray",
">",
"0",
":",
"auglist",
".",
"append",
"(",
"RandomGrayAug",
"(",
"rand_gray",
")",
")",
"if",
"mean",
"is",
"True",
":",
"mean",
"=",
"nd",
".",
"array",
"(",
"[",
"123.68",
",",
"116.28",
",",
"103.53",
"]",
")",
"elif",
"mean",
"is",
"not",
"None",
":",
"assert",
"isinstance",
"(",
"mean",
",",
"(",
"np",
".",
"ndarray",
",",
"nd",
".",
"NDArray",
")",
")",
"and",
"mean",
".",
"shape",
"[",
"0",
"]",
"in",
"[",
"1",
",",
"3",
"]",
"if",
"std",
"is",
"True",
":",
"std",
"=",
"nd",
".",
"array",
"(",
"[",
"58.395",
",",
"57.12",
",",
"57.375",
"]",
")",
"elif",
"std",
"is",
"not",
"None",
":",
"assert",
"isinstance",
"(",
"std",
",",
"(",
"np",
".",
"ndarray",
",",
"nd",
".",
"NDArray",
")",
")",
"and",
"std",
".",
"shape",
"[",
"0",
"]",
"in",
"[",
"1",
",",
"3",
"]",
"if",
"mean",
"is",
"not",
"None",
"or",
"std",
"is",
"not",
"None",
":",
"auglist",
".",
"append",
"(",
"ColorNormalizeAug",
"(",
"mean",
",",
"std",
")",
")",
"return",
"auglist"
] |
Creates an augmenter list.
Parameters
----------
data_shape : tuple of int
Shape for output data
resize : int
Resize shorter edge if larger than 0 at the begining
rand_crop : bool
Whether to enable random cropping other than center crop
rand_resize : bool
Whether to enable random sized cropping, require rand_crop to be enabled
rand_gray : float
[0, 1], probability to convert to grayscale for all channels, the number
of channels will not be reduced to 1
rand_mirror : bool
Whether to apply horizontal flip to image with probability 0.5
mean : np.ndarray or None
Mean pixel values for [r, g, b]
std : np.ndarray or None
Standard deviations for [r, g, b]
brightness : float
Brightness jittering range (percent)
contrast : float
Contrast jittering range (percent)
saturation : float
Saturation jittering range (percent)
hue : float
Hue jittering range (percent)
pca_noise : float
Pca noise level (percent)
inter_method : int, default=2(Area-based)
Interpolation method for all resizing operations
Possible values:
0: Nearest Neighbors Interpolation.
1: Bilinear interpolation.
2: Area-based (resampling using pixel area relation). It may be a
preferred method for image decimation, as it gives moire-free
results. But when the image is zoomed, it is similar to the Nearest
Neighbors method. (used by default).
3: Bicubic interpolation over 4x4 pixel neighborhood.
4: Lanczos interpolation over 8x8 pixel neighborhood.
9: Cubic for enlarge, area for shrink, bilinear for others
10: Random select from interpolation method metioned above.
Note:
When shrinking an image, it will generally look best with AREA-based
interpolation, whereas, when enlarging an image, it will generally look best
with Bicubic (slow) or Bilinear (faster but still looks OK).
Examples
--------
>>> # An example of creating multiple augmenters
>>> augs = mx.image.CreateAugmenter(data_shape=(3, 300, 300), rand_mirror=True,
... mean=True, brightness=0.125, contrast=0.125, rand_gray=0.05,
... saturation=0.125, pca_noise=0.05, inter_method=10)
>>> # dump the details
>>> for aug in augs:
... aug.dumps()
|
[
"Creates",
"an",
"augmenter",
"list",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L1015-L1126
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
Augmenter.dumps
|
def dumps(self):
"""Saves the Augmenter to string
Returns
-------
str
JSON formatted string that describes the Augmenter.
"""
return json.dumps([self.__class__.__name__.lower(), self._kwargs])
|
python
|
def dumps(self):
"""Saves the Augmenter to string
Returns
-------
str
JSON formatted string that describes the Augmenter.
"""
return json.dumps([self.__class__.__name__.lower(), self._kwargs])
|
[
"def",
"dumps",
"(",
"self",
")",
":",
"return",
"json",
".",
"dumps",
"(",
"[",
"self",
".",
"__class__",
".",
"__name__",
".",
"lower",
"(",
")",
",",
"self",
".",
"_kwargs",
"]",
")"
] |
Saves the Augmenter to string
Returns
-------
str
JSON formatted string that describes the Augmenter.
|
[
"Saves",
"the",
"Augmenter",
"to",
"string"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L616-L624
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
SequentialAug.dumps
|
def dumps(self):
"""Override the default to avoid duplicate dump."""
return [self.__class__.__name__.lower(), [x.dumps() for x in self.ts]]
|
python
|
def dumps(self):
"""Override the default to avoid duplicate dump."""
return [self.__class__.__name__.lower(), [x.dumps() for x in self.ts]]
|
[
"def",
"dumps",
"(",
"self",
")",
":",
"return",
"[",
"self",
".",
"__class__",
".",
"__name__",
".",
"lower",
"(",
")",
",",
"[",
"x",
".",
"dumps",
"(",
")",
"for",
"x",
"in",
"self",
".",
"ts",
"]",
"]"
] |
Override the default to avoid duplicate dump.
|
[
"Override",
"the",
"default",
"to",
"avoid",
"duplicate",
"dump",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L643-L645
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
ImageIter.reset
|
def reset(self):
"""Resets the iterator to the beginning of the data."""
if self.seq is not None and self.shuffle:
random.shuffle(self.seq)
if self.last_batch_handle != 'roll_over' or \
self._cache_data is None:
if self.imgrec is not None:
self.imgrec.reset()
self.cur = 0
if self._allow_read is False:
self._allow_read = True
|
python
|
def reset(self):
"""Resets the iterator to the beginning of the data."""
if self.seq is not None and self.shuffle:
random.shuffle(self.seq)
if self.last_batch_handle != 'roll_over' or \
self._cache_data is None:
if self.imgrec is not None:
self.imgrec.reset()
self.cur = 0
if self._allow_read is False:
self._allow_read = True
|
[
"def",
"reset",
"(",
"self",
")",
":",
"if",
"self",
".",
"seq",
"is",
"not",
"None",
"and",
"self",
".",
"shuffle",
":",
"random",
".",
"shuffle",
"(",
"self",
".",
"seq",
")",
"if",
"self",
".",
"last_batch_handle",
"!=",
"'roll_over'",
"or",
"self",
".",
"_cache_data",
"is",
"None",
":",
"if",
"self",
".",
"imgrec",
"is",
"not",
"None",
":",
"self",
".",
"imgrec",
".",
"reset",
"(",
")",
"self",
".",
"cur",
"=",
"0",
"if",
"self",
".",
"_allow_read",
"is",
"False",
":",
"self",
".",
"_allow_read",
"=",
"True"
] |
Resets the iterator to the beginning of the data.
|
[
"Resets",
"the",
"iterator",
"to",
"the",
"beginning",
"of",
"the",
"data",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L1278-L1288
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
ImageIter.hard_reset
|
def hard_reset(self):
"""Resets the iterator and ignore roll over data"""
if self.seq is not None and self.shuffle:
random.shuffle(self.seq)
if self.imgrec is not None:
self.imgrec.reset()
self.cur = 0
self._allow_read = True
self._cache_data = None
self._cache_label = None
self._cache_idx = None
|
python
|
def hard_reset(self):
"""Resets the iterator and ignore roll over data"""
if self.seq is not None and self.shuffle:
random.shuffle(self.seq)
if self.imgrec is not None:
self.imgrec.reset()
self.cur = 0
self._allow_read = True
self._cache_data = None
self._cache_label = None
self._cache_idx = None
|
[
"def",
"hard_reset",
"(",
"self",
")",
":",
"if",
"self",
".",
"seq",
"is",
"not",
"None",
"and",
"self",
".",
"shuffle",
":",
"random",
".",
"shuffle",
"(",
"self",
".",
"seq",
")",
"if",
"self",
".",
"imgrec",
"is",
"not",
"None",
":",
"self",
".",
"imgrec",
".",
"reset",
"(",
")",
"self",
".",
"cur",
"=",
"0",
"self",
".",
"_allow_read",
"=",
"True",
"self",
".",
"_cache_data",
"=",
"None",
"self",
".",
"_cache_label",
"=",
"None",
"self",
".",
"_cache_idx",
"=",
"None"
] |
Resets the iterator and ignore roll over data
|
[
"Resets",
"the",
"iterator",
"and",
"ignore",
"roll",
"over",
"data"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L1290-L1300
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
ImageIter.next_sample
|
def next_sample(self):
"""Helper function for reading in next sample."""
if self._allow_read is False:
raise StopIteration
if self.seq is not None:
if self.cur < self.num_image:
idx = self.seq[self.cur]
else:
if self.last_batch_handle != 'discard':
self.cur = 0
raise StopIteration
self.cur += 1
if self.imgrec is not None:
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
if self.imglist is None:
return header.label, img
else:
return self.imglist[idx][0], img
else:
label, fname = self.imglist[idx]
return label, self.read_image(fname)
else:
s = self.imgrec.read()
if s is None:
if self.last_batch_handle != 'discard':
self.imgrec.reset()
raise StopIteration
header, img = recordio.unpack(s)
return header.label, img
|
python
|
def next_sample(self):
"""Helper function for reading in next sample."""
if self._allow_read is False:
raise StopIteration
if self.seq is not None:
if self.cur < self.num_image:
idx = self.seq[self.cur]
else:
if self.last_batch_handle != 'discard':
self.cur = 0
raise StopIteration
self.cur += 1
if self.imgrec is not None:
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
if self.imglist is None:
return header.label, img
else:
return self.imglist[idx][0], img
else:
label, fname = self.imglist[idx]
return label, self.read_image(fname)
else:
s = self.imgrec.read()
if s is None:
if self.last_batch_handle != 'discard':
self.imgrec.reset()
raise StopIteration
header, img = recordio.unpack(s)
return header.label, img
|
[
"def",
"next_sample",
"(",
"self",
")",
":",
"if",
"self",
".",
"_allow_read",
"is",
"False",
":",
"raise",
"StopIteration",
"if",
"self",
".",
"seq",
"is",
"not",
"None",
":",
"if",
"self",
".",
"cur",
"<",
"self",
".",
"num_image",
":",
"idx",
"=",
"self",
".",
"seq",
"[",
"self",
".",
"cur",
"]",
"else",
":",
"if",
"self",
".",
"last_batch_handle",
"!=",
"'discard'",
":",
"self",
".",
"cur",
"=",
"0",
"raise",
"StopIteration",
"self",
".",
"cur",
"+=",
"1",
"if",
"self",
".",
"imgrec",
"is",
"not",
"None",
":",
"s",
"=",
"self",
".",
"imgrec",
".",
"read_idx",
"(",
"idx",
")",
"header",
",",
"img",
"=",
"recordio",
".",
"unpack",
"(",
"s",
")",
"if",
"self",
".",
"imglist",
"is",
"None",
":",
"return",
"header",
".",
"label",
",",
"img",
"else",
":",
"return",
"self",
".",
"imglist",
"[",
"idx",
"]",
"[",
"0",
"]",
",",
"img",
"else",
":",
"label",
",",
"fname",
"=",
"self",
".",
"imglist",
"[",
"idx",
"]",
"return",
"label",
",",
"self",
".",
"read_image",
"(",
"fname",
")",
"else",
":",
"s",
"=",
"self",
".",
"imgrec",
".",
"read",
"(",
")",
"if",
"s",
"is",
"None",
":",
"if",
"self",
".",
"last_batch_handle",
"!=",
"'discard'",
":",
"self",
".",
"imgrec",
".",
"reset",
"(",
")",
"raise",
"StopIteration",
"header",
",",
"img",
"=",
"recordio",
".",
"unpack",
"(",
"s",
")",
"return",
"header",
".",
"label",
",",
"img"
] |
Helper function for reading in next sample.
|
[
"Helper",
"function",
"for",
"reading",
"in",
"next",
"sample",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L1302-L1331
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
ImageIter._batchify
|
def _batchify(self, batch_data, batch_label, start=0):
"""Helper function for batchifying data"""
i = start
batch_size = self.batch_size
try:
while i < batch_size:
label, s = self.next_sample()
data = self.imdecode(s)
try:
self.check_valid_image(data)
except RuntimeError as e:
logging.debug('Invalid image, skipping: %s', str(e))
continue
data = self.augmentation_transform(data)
assert i < batch_size, 'Batch size must be multiples of augmenter output length'
batch_data[i] = self.postprocess_data(data)
batch_label[i] = label
i += 1
except StopIteration:
if not i:
raise StopIteration
return i
|
python
|
def _batchify(self, batch_data, batch_label, start=0):
"""Helper function for batchifying data"""
i = start
batch_size = self.batch_size
try:
while i < batch_size:
label, s = self.next_sample()
data = self.imdecode(s)
try:
self.check_valid_image(data)
except RuntimeError as e:
logging.debug('Invalid image, skipping: %s', str(e))
continue
data = self.augmentation_transform(data)
assert i < batch_size, 'Batch size must be multiples of augmenter output length'
batch_data[i] = self.postprocess_data(data)
batch_label[i] = label
i += 1
except StopIteration:
if not i:
raise StopIteration
return i
|
[
"def",
"_batchify",
"(",
"self",
",",
"batch_data",
",",
"batch_label",
",",
"start",
"=",
"0",
")",
":",
"i",
"=",
"start",
"batch_size",
"=",
"self",
".",
"batch_size",
"try",
":",
"while",
"i",
"<",
"batch_size",
":",
"label",
",",
"s",
"=",
"self",
".",
"next_sample",
"(",
")",
"data",
"=",
"self",
".",
"imdecode",
"(",
"s",
")",
"try",
":",
"self",
".",
"check_valid_image",
"(",
"data",
")",
"except",
"RuntimeError",
"as",
"e",
":",
"logging",
".",
"debug",
"(",
"'Invalid image, skipping: %s'",
",",
"str",
"(",
"e",
")",
")",
"continue",
"data",
"=",
"self",
".",
"augmentation_transform",
"(",
"data",
")",
"assert",
"i",
"<",
"batch_size",
",",
"'Batch size must be multiples of augmenter output length'",
"batch_data",
"[",
"i",
"]",
"=",
"self",
".",
"postprocess_data",
"(",
"data",
")",
"batch_label",
"[",
"i",
"]",
"=",
"label",
"i",
"+=",
"1",
"except",
"StopIteration",
":",
"if",
"not",
"i",
":",
"raise",
"StopIteration",
"return",
"i"
] |
Helper function for batchifying data
|
[
"Helper",
"function",
"for",
"batchifying",
"data"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L1333-L1354
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
ImageIter.imdecode
|
def imdecode(self, s):
"""Decodes a string or byte string to an NDArray.
See mx.img.imdecode for more details."""
def locate():
"""Locate the image file/index if decode fails."""
if self.seq is not None:
idx = self.seq[(self.cur % self.num_image) - 1]
else:
idx = (self.cur % self.num_image) - 1
if self.imglist is not None:
_, fname = self.imglist[idx]
msg = "filename: {}".format(fname)
else:
msg = "index: {}".format(idx)
return "Broken image " + msg
try:
img = imdecode(s)
except Exception as e:
raise RuntimeError("{}, {}".format(locate(), e))
return img
|
python
|
def imdecode(self, s):
"""Decodes a string or byte string to an NDArray.
See mx.img.imdecode for more details."""
def locate():
"""Locate the image file/index if decode fails."""
if self.seq is not None:
idx = self.seq[(self.cur % self.num_image) - 1]
else:
idx = (self.cur % self.num_image) - 1
if self.imglist is not None:
_, fname = self.imglist[idx]
msg = "filename: {}".format(fname)
else:
msg = "index: {}".format(idx)
return "Broken image " + msg
try:
img = imdecode(s)
except Exception as e:
raise RuntimeError("{}, {}".format(locate(), e))
return img
|
[
"def",
"imdecode",
"(",
"self",
",",
"s",
")",
":",
"def",
"locate",
"(",
")",
":",
"\"\"\"Locate the image file/index if decode fails.\"\"\"",
"if",
"self",
".",
"seq",
"is",
"not",
"None",
":",
"idx",
"=",
"self",
".",
"seq",
"[",
"(",
"self",
".",
"cur",
"%",
"self",
".",
"num_image",
")",
"-",
"1",
"]",
"else",
":",
"idx",
"=",
"(",
"self",
".",
"cur",
"%",
"self",
".",
"num_image",
")",
"-",
"1",
"if",
"self",
".",
"imglist",
"is",
"not",
"None",
":",
"_",
",",
"fname",
"=",
"self",
".",
"imglist",
"[",
"idx",
"]",
"msg",
"=",
"\"filename: {}\"",
".",
"format",
"(",
"fname",
")",
"else",
":",
"msg",
"=",
"\"index: {}\"",
".",
"format",
"(",
"idx",
")",
"return",
"\"Broken image \"",
"+",
"msg",
"try",
":",
"img",
"=",
"imdecode",
"(",
"s",
")",
"except",
"Exception",
"as",
"e",
":",
"raise",
"RuntimeError",
"(",
"\"{}, {}\"",
".",
"format",
"(",
"locate",
"(",
")",
",",
"e",
")",
")",
"return",
"img"
] |
Decodes a string or byte string to an NDArray.
See mx.img.imdecode for more details.
|
[
"Decodes",
"a",
"string",
"or",
"byte",
"string",
"to",
"an",
"NDArray",
".",
"See",
"mx",
".",
"img",
".",
"imdecode",
"for",
"more",
"details",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L1409-L1428
|
train
|
apache/incubator-mxnet
|
python/mxnet/image/image.py
|
ImageIter.read_image
|
def read_image(self, fname):
"""Reads an input image `fname` and returns the decoded raw bytes.
Examples
--------
>>> dataIter.read_image('Face.jpg') # returns decoded raw bytes.
"""
with open(os.path.join(self.path_root, fname), 'rb') as fin:
img = fin.read()
return img
|
python
|
def read_image(self, fname):
"""Reads an input image `fname` and returns the decoded raw bytes.
Examples
--------
>>> dataIter.read_image('Face.jpg') # returns decoded raw bytes.
"""
with open(os.path.join(self.path_root, fname), 'rb') as fin:
img = fin.read()
return img
|
[
"def",
"read_image",
"(",
"self",
",",
"fname",
")",
":",
"with",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"path_root",
",",
"fname",
")",
",",
"'rb'",
")",
"as",
"fin",
":",
"img",
"=",
"fin",
".",
"read",
"(",
")",
"return",
"img"
] |
Reads an input image `fname` and returns the decoded raw bytes.
Examples
--------
>>> dataIter.read_image('Face.jpg') # returns decoded raw bytes.
|
[
"Reads",
"an",
"input",
"image",
"fname",
"and",
"returns",
"the",
"decoded",
"raw",
"bytes",
".",
"Examples",
"--------",
">>>",
"dataIter",
".",
"read_image",
"(",
"Face",
".",
"jpg",
")",
"#",
"returns",
"decoded",
"raw",
"bytes",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/image/image.py#L1430-L1438
|
train
|
apache/incubator-mxnet
|
example/gluon/sn_gan/train.py
|
facc
|
def facc(label, pred):
""" evaluate accuracy """
pred = pred.ravel()
label = label.ravel()
return ((pred > 0.5) == label).mean()
|
python
|
def facc(label, pred):
""" evaluate accuracy """
pred = pred.ravel()
label = label.ravel()
return ((pred > 0.5) == label).mean()
|
[
"def",
"facc",
"(",
"label",
",",
"pred",
")",
":",
"pred",
"=",
"pred",
".",
"ravel",
"(",
")",
"label",
"=",
"label",
".",
"ravel",
"(",
")",
"return",
"(",
"(",
"pred",
">",
"0.5",
")",
"==",
"label",
")",
".",
"mean",
"(",
")"
] |
evaluate accuracy
|
[
"evaluate",
"accuracy"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/sn_gan/train.py#L68-L72
|
train
|
apache/incubator-mxnet
|
example/gluon/lipnet/utils/common.py
|
word_to_vector
|
def word_to_vector(word):
"""
Convert character vectors to integer vectors.
"""
vector = []
for char in list(word):
vector.append(char2int(char))
return vector
|
python
|
def word_to_vector(word):
"""
Convert character vectors to integer vectors.
"""
vector = []
for char in list(word):
vector.append(char2int(char))
return vector
|
[
"def",
"word_to_vector",
"(",
"word",
")",
":",
"vector",
"=",
"[",
"]",
"for",
"char",
"in",
"list",
"(",
"word",
")",
":",
"vector",
".",
"append",
"(",
"char2int",
"(",
"char",
")",
")",
"return",
"vector"
] |
Convert character vectors to integer vectors.
|
[
"Convert",
"character",
"vectors",
"to",
"integer",
"vectors",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/common.py#L46-L53
|
train
|
apache/incubator-mxnet
|
example/gluon/lipnet/utils/common.py
|
vector_to_word
|
def vector_to_word(vector):
"""
Convert integer vectors to character vectors.
"""
word = ""
for vec in vector:
word = word + int2char(vec)
return word
|
python
|
def vector_to_word(vector):
"""
Convert integer vectors to character vectors.
"""
word = ""
for vec in vector:
word = word + int2char(vec)
return word
|
[
"def",
"vector_to_word",
"(",
"vector",
")",
":",
"word",
"=",
"\"\"",
"for",
"vec",
"in",
"vector",
":",
"word",
"=",
"word",
"+",
"int2char",
"(",
"vec",
")",
"return",
"word"
] |
Convert integer vectors to character vectors.
|
[
"Convert",
"integer",
"vectors",
"to",
"character",
"vectors",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/common.py#L56-L63
|
train
|
apache/incubator-mxnet
|
example/gluon/lipnet/utils/common.py
|
char_conv
|
def char_conv(out):
"""
Convert integer vectors to character vectors for batch.
"""
out_conv = list()
for i in range(out.shape[0]):
tmp_str = ''
for j in range(out.shape[1]):
if int(out[i][j]) >= 0:
tmp_char = int2char(int(out[i][j]))
if int(out[i][j]) == 27:
tmp_char = ''
tmp_str = tmp_str + tmp_char
out_conv.append(tmp_str)
return out_conv
|
python
|
def char_conv(out):
"""
Convert integer vectors to character vectors for batch.
"""
out_conv = list()
for i in range(out.shape[0]):
tmp_str = ''
for j in range(out.shape[1]):
if int(out[i][j]) >= 0:
tmp_char = int2char(int(out[i][j]))
if int(out[i][j]) == 27:
tmp_char = ''
tmp_str = tmp_str + tmp_char
out_conv.append(tmp_str)
return out_conv
|
[
"def",
"char_conv",
"(",
"out",
")",
":",
"out_conv",
"=",
"list",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"out",
".",
"shape",
"[",
"0",
"]",
")",
":",
"tmp_str",
"=",
"''",
"for",
"j",
"in",
"range",
"(",
"out",
".",
"shape",
"[",
"1",
"]",
")",
":",
"if",
"int",
"(",
"out",
"[",
"i",
"]",
"[",
"j",
"]",
")",
">=",
"0",
":",
"tmp_char",
"=",
"int2char",
"(",
"int",
"(",
"out",
"[",
"i",
"]",
"[",
"j",
"]",
")",
")",
"if",
"int",
"(",
"out",
"[",
"i",
"]",
"[",
"j",
"]",
")",
"==",
"27",
":",
"tmp_char",
"=",
"''",
"tmp_str",
"=",
"tmp_str",
"+",
"tmp_char",
"out_conv",
".",
"append",
"(",
"tmp_str",
")",
"return",
"out_conv"
] |
Convert integer vectors to character vectors for batch.
|
[
"Convert",
"integer",
"vectors",
"to",
"character",
"vectors",
"for",
"batch",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/common.py#L66-L80
|
train
|
apache/incubator-mxnet
|
tools/coreml/converter/_add_pooling.py
|
add_pooling_with_padding_types
|
def add_pooling_with_padding_types(builder, name, height, width, stride_height, stride_width,
layer_type, padding_type, input_name, output_name,
padding_top = 0, padding_bottom = 0, padding_left = 0, padding_right = 0,
same_padding_asymmetry_mode = 'BOTTOM_RIGHT_HEAVY',
exclude_pad_area = True, is_global = False):
"""
Add a pooling layer to the model.
This is our own implementation of add_pooling since current CoreML's version (0.5.0) of builder
doesn't provide support for padding types apart from valid. This support will be added in the
next release of coremltools. When that happens, this can be removed.
Parameters
----------
builder: NeuralNetworkBuilder
A neural network builder object.
name: str
The name of this layer.
height: int
Height of pooling region.
width: int
Number of elements to be padded on the right side of the input blob.
stride_height: int
Stride along the height direction.
stride_width: int
Stride along the height direction.
layer_type: str
Type of pooling performed. Can either be 'MAX', 'AVERAGE' or 'L2'.
padding_type: str
Option for the output blob shape. Can be either 'VALID' , 'SAME' or 'INCLUDE_LAST_PIXEL'. Kindly look at NeuralNetwork.proto for details.
input_name: str
The input blob name of this layer.
output_name: str
The output blob name of this layer.
padding_top, padding_bottom, padding_left, padding_right: int
values of height (top, bottom) and width (left, right) padding to be used if padding type is "VALID" or "INCLUDE_LAST_PIXEL"
same_padding_asymmetry_mode : str.
Type of asymmetric padding to be used when padding_type = 'SAME'. Kindly look at NeuralNetwork.proto for details. Can be either 'BOTTOM_RIGHT_HEAVY' or 'TOP_LEFT_HEAVY'.
exclude_pad_area: boolean
Whether to exclude padded area in the pooling operation. Defaults to True.
- If True, the value of the padded area will be excluded.
- If False, the padded area will be included.
This flag is only used with average pooling.
is_global: boolean
Whether the pooling operation is global. Defaults to False.
- If True, the pooling operation is global -- the pooling region is of the same size of the input blob.
Parameters height, width, stride_height, stride_width will be ignored.
- If False, the pooling operation is not global.
See Also
--------
add_convolution, add_pooling, add_activation
"""
spec = builder.spec
nn_spec = builder.nn_spec
# Add a new layer
spec_layer = nn_spec.layers.add()
spec_layer.name = name
spec_layer.input.append(input_name)
spec_layer.output.append(output_name)
spec_layer_params = spec_layer.pooling
# Set the parameters
spec_layer_params.type = \
_NeuralNetwork_pb2.PoolingLayerParams.PoolingType.Value(layer_type)
if padding_type == 'VALID':
height_border = spec_layer_params.valid.paddingAmounts.borderAmounts.add()
height_border.startEdgeSize = padding_top
height_border.endEdgeSize = padding_bottom
width_border = spec_layer_params.valid.paddingAmounts.borderAmounts.add()
width_border.startEdgeSize = padding_left
width_border.endEdgeSize = padding_right
elif padding_type == 'SAME':
if not (same_padding_asymmetry_mode == 'BOTTOM_RIGHT_HEAVY' or same_padding_asymmetry_mode == 'TOP_LEFT_HEAVY'):
raise ValueError("Invalid value %d of same_padding_asymmetry_mode parameter" % same_padding_asymmetry_mode)
spec_layer_params.same.asymmetryMode = _NeuralNetwork_pb2.SamePadding.SamePaddingMode.Value(same_padding_asymmetry_mode)
elif padding_type == 'INCLUDE_LAST_PIXEL':
if padding_top != padding_bottom or padding_left != padding_right:
raise ValueError("Only symmetric padding is supported with the INCLUDE_LAST_PIXEL padding type")
spec_layer_params.includeLastPixel.paddingAmounts.append(padding_top)
spec_layer_params.includeLastPixel.paddingAmounts.append(padding_left)
spec_layer_params.kernelSize.append(height)
spec_layer_params.kernelSize.append(width)
spec_layer_params.stride.append(stride_height)
spec_layer_params.stride.append(stride_width)
spec_layer_params.avgPoolExcludePadding = exclude_pad_area
spec_layer_params.globalPooling = is_global
|
python
|
def add_pooling_with_padding_types(builder, name, height, width, stride_height, stride_width,
layer_type, padding_type, input_name, output_name,
padding_top = 0, padding_bottom = 0, padding_left = 0, padding_right = 0,
same_padding_asymmetry_mode = 'BOTTOM_RIGHT_HEAVY',
exclude_pad_area = True, is_global = False):
"""
Add a pooling layer to the model.
This is our own implementation of add_pooling since current CoreML's version (0.5.0) of builder
doesn't provide support for padding types apart from valid. This support will be added in the
next release of coremltools. When that happens, this can be removed.
Parameters
----------
builder: NeuralNetworkBuilder
A neural network builder object.
name: str
The name of this layer.
height: int
Height of pooling region.
width: int
Number of elements to be padded on the right side of the input blob.
stride_height: int
Stride along the height direction.
stride_width: int
Stride along the height direction.
layer_type: str
Type of pooling performed. Can either be 'MAX', 'AVERAGE' or 'L2'.
padding_type: str
Option for the output blob shape. Can be either 'VALID' , 'SAME' or 'INCLUDE_LAST_PIXEL'. Kindly look at NeuralNetwork.proto for details.
input_name: str
The input blob name of this layer.
output_name: str
The output blob name of this layer.
padding_top, padding_bottom, padding_left, padding_right: int
values of height (top, bottom) and width (left, right) padding to be used if padding type is "VALID" or "INCLUDE_LAST_PIXEL"
same_padding_asymmetry_mode : str.
Type of asymmetric padding to be used when padding_type = 'SAME'. Kindly look at NeuralNetwork.proto for details. Can be either 'BOTTOM_RIGHT_HEAVY' or 'TOP_LEFT_HEAVY'.
exclude_pad_area: boolean
Whether to exclude padded area in the pooling operation. Defaults to True.
- If True, the value of the padded area will be excluded.
- If False, the padded area will be included.
This flag is only used with average pooling.
is_global: boolean
Whether the pooling operation is global. Defaults to False.
- If True, the pooling operation is global -- the pooling region is of the same size of the input blob.
Parameters height, width, stride_height, stride_width will be ignored.
- If False, the pooling operation is not global.
See Also
--------
add_convolution, add_pooling, add_activation
"""
spec = builder.spec
nn_spec = builder.nn_spec
# Add a new layer
spec_layer = nn_spec.layers.add()
spec_layer.name = name
spec_layer.input.append(input_name)
spec_layer.output.append(output_name)
spec_layer_params = spec_layer.pooling
# Set the parameters
spec_layer_params.type = \
_NeuralNetwork_pb2.PoolingLayerParams.PoolingType.Value(layer_type)
if padding_type == 'VALID':
height_border = spec_layer_params.valid.paddingAmounts.borderAmounts.add()
height_border.startEdgeSize = padding_top
height_border.endEdgeSize = padding_bottom
width_border = spec_layer_params.valid.paddingAmounts.borderAmounts.add()
width_border.startEdgeSize = padding_left
width_border.endEdgeSize = padding_right
elif padding_type == 'SAME':
if not (same_padding_asymmetry_mode == 'BOTTOM_RIGHT_HEAVY' or same_padding_asymmetry_mode == 'TOP_LEFT_HEAVY'):
raise ValueError("Invalid value %d of same_padding_asymmetry_mode parameter" % same_padding_asymmetry_mode)
spec_layer_params.same.asymmetryMode = _NeuralNetwork_pb2.SamePadding.SamePaddingMode.Value(same_padding_asymmetry_mode)
elif padding_type == 'INCLUDE_LAST_PIXEL':
if padding_top != padding_bottom or padding_left != padding_right:
raise ValueError("Only symmetric padding is supported with the INCLUDE_LAST_PIXEL padding type")
spec_layer_params.includeLastPixel.paddingAmounts.append(padding_top)
spec_layer_params.includeLastPixel.paddingAmounts.append(padding_left)
spec_layer_params.kernelSize.append(height)
spec_layer_params.kernelSize.append(width)
spec_layer_params.stride.append(stride_height)
spec_layer_params.stride.append(stride_width)
spec_layer_params.avgPoolExcludePadding = exclude_pad_area
spec_layer_params.globalPooling = is_global
|
[
"def",
"add_pooling_with_padding_types",
"(",
"builder",
",",
"name",
",",
"height",
",",
"width",
",",
"stride_height",
",",
"stride_width",
",",
"layer_type",
",",
"padding_type",
",",
"input_name",
",",
"output_name",
",",
"padding_top",
"=",
"0",
",",
"padding_bottom",
"=",
"0",
",",
"padding_left",
"=",
"0",
",",
"padding_right",
"=",
"0",
",",
"same_padding_asymmetry_mode",
"=",
"'BOTTOM_RIGHT_HEAVY'",
",",
"exclude_pad_area",
"=",
"True",
",",
"is_global",
"=",
"False",
")",
":",
"spec",
"=",
"builder",
".",
"spec",
"nn_spec",
"=",
"builder",
".",
"nn_spec",
"# Add a new layer\r",
"spec_layer",
"=",
"nn_spec",
".",
"layers",
".",
"add",
"(",
")",
"spec_layer",
".",
"name",
"=",
"name",
"spec_layer",
".",
"input",
".",
"append",
"(",
"input_name",
")",
"spec_layer",
".",
"output",
".",
"append",
"(",
"output_name",
")",
"spec_layer_params",
"=",
"spec_layer",
".",
"pooling",
"# Set the parameters\r",
"spec_layer_params",
".",
"type",
"=",
"_NeuralNetwork_pb2",
".",
"PoolingLayerParams",
".",
"PoolingType",
".",
"Value",
"(",
"layer_type",
")",
"if",
"padding_type",
"==",
"'VALID'",
":",
"height_border",
"=",
"spec_layer_params",
".",
"valid",
".",
"paddingAmounts",
".",
"borderAmounts",
".",
"add",
"(",
")",
"height_border",
".",
"startEdgeSize",
"=",
"padding_top",
"height_border",
".",
"endEdgeSize",
"=",
"padding_bottom",
"width_border",
"=",
"spec_layer_params",
".",
"valid",
".",
"paddingAmounts",
".",
"borderAmounts",
".",
"add",
"(",
")",
"width_border",
".",
"startEdgeSize",
"=",
"padding_left",
"width_border",
".",
"endEdgeSize",
"=",
"padding_right",
"elif",
"padding_type",
"==",
"'SAME'",
":",
"if",
"not",
"(",
"same_padding_asymmetry_mode",
"==",
"'BOTTOM_RIGHT_HEAVY'",
"or",
"same_padding_asymmetry_mode",
"==",
"'TOP_LEFT_HEAVY'",
")",
":",
"raise",
"ValueError",
"(",
"\"Invalid value %d of same_padding_asymmetry_mode parameter\"",
"%",
"same_padding_asymmetry_mode",
")",
"spec_layer_params",
".",
"same",
".",
"asymmetryMode",
"=",
"_NeuralNetwork_pb2",
".",
"SamePadding",
".",
"SamePaddingMode",
".",
"Value",
"(",
"same_padding_asymmetry_mode",
")",
"elif",
"padding_type",
"==",
"'INCLUDE_LAST_PIXEL'",
":",
"if",
"padding_top",
"!=",
"padding_bottom",
"or",
"padding_left",
"!=",
"padding_right",
":",
"raise",
"ValueError",
"(",
"\"Only symmetric padding is supported with the INCLUDE_LAST_PIXEL padding type\"",
")",
"spec_layer_params",
".",
"includeLastPixel",
".",
"paddingAmounts",
".",
"append",
"(",
"padding_top",
")",
"spec_layer_params",
".",
"includeLastPixel",
".",
"paddingAmounts",
".",
"append",
"(",
"padding_left",
")",
"spec_layer_params",
".",
"kernelSize",
".",
"append",
"(",
"height",
")",
"spec_layer_params",
".",
"kernelSize",
".",
"append",
"(",
"width",
")",
"spec_layer_params",
".",
"stride",
".",
"append",
"(",
"stride_height",
")",
"spec_layer_params",
".",
"stride",
".",
"append",
"(",
"stride_width",
")",
"spec_layer_params",
".",
"avgPoolExcludePadding",
"=",
"exclude_pad_area",
"spec_layer_params",
".",
"globalPooling",
"=",
"is_global"
] |
Add a pooling layer to the model.
This is our own implementation of add_pooling since current CoreML's version (0.5.0) of builder
doesn't provide support for padding types apart from valid. This support will be added in the
next release of coremltools. When that happens, this can be removed.
Parameters
----------
builder: NeuralNetworkBuilder
A neural network builder object.
name: str
The name of this layer.
height: int
Height of pooling region.
width: int
Number of elements to be padded on the right side of the input blob.
stride_height: int
Stride along the height direction.
stride_width: int
Stride along the height direction.
layer_type: str
Type of pooling performed. Can either be 'MAX', 'AVERAGE' or 'L2'.
padding_type: str
Option for the output blob shape. Can be either 'VALID' , 'SAME' or 'INCLUDE_LAST_PIXEL'. Kindly look at NeuralNetwork.proto for details.
input_name: str
The input blob name of this layer.
output_name: str
The output blob name of this layer.
padding_top, padding_bottom, padding_left, padding_right: int
values of height (top, bottom) and width (left, right) padding to be used if padding type is "VALID" or "INCLUDE_LAST_PIXEL"
same_padding_asymmetry_mode : str.
Type of asymmetric padding to be used when padding_type = 'SAME'. Kindly look at NeuralNetwork.proto for details. Can be either 'BOTTOM_RIGHT_HEAVY' or 'TOP_LEFT_HEAVY'.
exclude_pad_area: boolean
Whether to exclude padded area in the pooling operation. Defaults to True.
- If True, the value of the padded area will be excluded.
- If False, the padded area will be included.
This flag is only used with average pooling.
is_global: boolean
Whether the pooling operation is global. Defaults to False.
- If True, the pooling operation is global -- the pooling region is of the same size of the input blob.
Parameters height, width, stride_height, stride_width will be ignored.
- If False, the pooling operation is not global.
See Also
--------
add_convolution, add_pooling, add_activation
|
[
"Add",
"a",
"pooling",
"layer",
"to",
"the",
"model",
".",
"This",
"is",
"our",
"own",
"implementation",
"of",
"add_pooling",
"since",
"current",
"CoreML",
"s",
"version",
"(",
"0",
".",
"5",
".",
"0",
")",
"of",
"builder",
"doesn",
"t",
"provide",
"support",
"for",
"padding",
"types",
"apart",
"from",
"valid",
".",
"This",
"support",
"will",
"be",
"added",
"in",
"the",
"next",
"release",
"of",
"coremltools",
".",
"When",
"that",
"happens",
"this",
"can",
"be",
"removed",
".",
"Parameters",
"----------",
"builder",
":",
"NeuralNetworkBuilder",
"A",
"neural",
"network",
"builder",
"object",
".",
"name",
":",
"str",
"The",
"name",
"of",
"this",
"layer",
".",
"height",
":",
"int",
"Height",
"of",
"pooling",
"region",
".",
"width",
":",
"int",
"Number",
"of",
"elements",
"to",
"be",
"padded",
"on",
"the",
"right",
"side",
"of",
"the",
"input",
"blob",
".",
"stride_height",
":",
"int",
"Stride",
"along",
"the",
"height",
"direction",
".",
"stride_width",
":",
"int",
"Stride",
"along",
"the",
"height",
"direction",
".",
"layer_type",
":",
"str",
"Type",
"of",
"pooling",
"performed",
".",
"Can",
"either",
"be",
"MAX",
"AVERAGE",
"or",
"L2",
".",
"padding_type",
":",
"str",
"Option",
"for",
"the",
"output",
"blob",
"shape",
".",
"Can",
"be",
"either",
"VALID",
"SAME",
"or",
"INCLUDE_LAST_PIXEL",
".",
"Kindly",
"look",
"at",
"NeuralNetwork",
".",
"proto",
"for",
"details",
".",
"input_name",
":",
"str",
"The",
"input",
"blob",
"name",
"of",
"this",
"layer",
".",
"output_name",
":",
"str",
"The",
"output",
"blob",
"name",
"of",
"this",
"layer",
".",
"padding_top",
"padding_bottom",
"padding_left",
"padding_right",
":",
"int",
"values",
"of",
"height",
"(",
"top",
"bottom",
")",
"and",
"width",
"(",
"left",
"right",
")",
"padding",
"to",
"be",
"used",
"if",
"padding",
"type",
"is",
"VALID",
"or",
"INCLUDE_LAST_PIXEL",
"same_padding_asymmetry_mode",
":",
"str",
".",
"Type",
"of",
"asymmetric",
"padding",
"to",
"be",
"used",
"when",
"padding_type",
"=",
"SAME",
".",
"Kindly",
"look",
"at",
"NeuralNetwork",
".",
"proto",
"for",
"details",
".",
"Can",
"be",
"either",
"BOTTOM_RIGHT_HEAVY",
"or",
"TOP_LEFT_HEAVY",
".",
"exclude_pad_area",
":",
"boolean",
"Whether",
"to",
"exclude",
"padded",
"area",
"in",
"the",
"pooling",
"operation",
".",
"Defaults",
"to",
"True",
".",
"-",
"If",
"True",
"the",
"value",
"of",
"the",
"padded",
"area",
"will",
"be",
"excluded",
".",
"-",
"If",
"False",
"the",
"padded",
"area",
"will",
"be",
"included",
".",
"This",
"flag",
"is",
"only",
"used",
"with",
"average",
"pooling",
".",
"is_global",
":",
"boolean",
"Whether",
"the",
"pooling",
"operation",
"is",
"global",
".",
"Defaults",
"to",
"False",
".",
"-",
"If",
"True",
"the",
"pooling",
"operation",
"is",
"global",
"--",
"the",
"pooling",
"region",
"is",
"of",
"the",
"same",
"size",
"of",
"the",
"input",
"blob",
".",
"Parameters",
"height",
"width",
"stride_height",
"stride_width",
"will",
"be",
"ignored",
".",
"-",
"If",
"False",
"the",
"pooling",
"operation",
"is",
"not",
"global",
".",
"See",
"Also",
"--------",
"add_convolution",
"add_pooling",
"add_activation"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/tools/coreml/converter/_add_pooling.py#L21-L118
|
train
|
apache/incubator-mxnet
|
example/kaggle-ndsb2/Preprocessing.py
|
get_frames
|
def get_frames(root_path):
"""Get path to all the frame in view SAX and contain complete frames"""
ret = []
for root, _, files in os.walk(root_path):
root=root.replace('\\','/')
files=[s for s in files if ".dcm" in s]
if len(files) == 0 or not files[0].endswith(".dcm") or root.find("sax") == -1:
continue
prefix = files[0].rsplit('-', 1)[0]
fileset = set(files)
expected = ["%s-%04d.dcm" % (prefix, i + 1) for i in range(30)]
if all(x in fileset for x in expected):
ret.append([root + "/" + x for x in expected])
# sort for reproduciblity
return sorted(ret, key = lambda x: x[0])
|
python
|
def get_frames(root_path):
"""Get path to all the frame in view SAX and contain complete frames"""
ret = []
for root, _, files in os.walk(root_path):
root=root.replace('\\','/')
files=[s for s in files if ".dcm" in s]
if len(files) == 0 or not files[0].endswith(".dcm") or root.find("sax") == -1:
continue
prefix = files[0].rsplit('-', 1)[0]
fileset = set(files)
expected = ["%s-%04d.dcm" % (prefix, i + 1) for i in range(30)]
if all(x in fileset for x in expected):
ret.append([root + "/" + x for x in expected])
# sort for reproduciblity
return sorted(ret, key = lambda x: x[0])
|
[
"def",
"get_frames",
"(",
"root_path",
")",
":",
"ret",
"=",
"[",
"]",
"for",
"root",
",",
"_",
",",
"files",
"in",
"os",
".",
"walk",
"(",
"root_path",
")",
":",
"root",
"=",
"root",
".",
"replace",
"(",
"'\\\\'",
",",
"'/'",
")",
"files",
"=",
"[",
"s",
"for",
"s",
"in",
"files",
"if",
"\".dcm\"",
"in",
"s",
"]",
"if",
"len",
"(",
"files",
")",
"==",
"0",
"or",
"not",
"files",
"[",
"0",
"]",
".",
"endswith",
"(",
"\".dcm\"",
")",
"or",
"root",
".",
"find",
"(",
"\"sax\"",
")",
"==",
"-",
"1",
":",
"continue",
"prefix",
"=",
"files",
"[",
"0",
"]",
".",
"rsplit",
"(",
"'-'",
",",
"1",
")",
"[",
"0",
"]",
"fileset",
"=",
"set",
"(",
"files",
")",
"expected",
"=",
"[",
"\"%s-%04d.dcm\"",
"%",
"(",
"prefix",
",",
"i",
"+",
"1",
")",
"for",
"i",
"in",
"range",
"(",
"30",
")",
"]",
"if",
"all",
"(",
"x",
"in",
"fileset",
"for",
"x",
"in",
"expected",
")",
":",
"ret",
".",
"append",
"(",
"[",
"root",
"+",
"\"/\"",
"+",
"x",
"for",
"x",
"in",
"expected",
"]",
")",
"# sort for reproduciblity",
"return",
"sorted",
"(",
"ret",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
")"
] |
Get path to all the frame in view SAX and contain complete frames
|
[
"Get",
"path",
"to",
"all",
"the",
"frame",
"in",
"view",
"SAX",
"and",
"contain",
"complete",
"frames"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/kaggle-ndsb2/Preprocessing.py#L39-L53
|
train
|
apache/incubator-mxnet
|
example/kaggle-ndsb2/Preprocessing.py
|
write_data_csv
|
def write_data_csv(fname, frames, preproc):
"""Write data to csv file"""
fdata = open(fname, "w")
dr = Parallel()(delayed(get_data)(lst,preproc) for lst in frames)
data,result = zip(*dr)
for entry in data:
fdata.write(','.join(entry)+'\r\n')
print("All finished, %d slices in total" % len(data))
fdata.close()
result = np.ravel(result)
return result
|
python
|
def write_data_csv(fname, frames, preproc):
"""Write data to csv file"""
fdata = open(fname, "w")
dr = Parallel()(delayed(get_data)(lst,preproc) for lst in frames)
data,result = zip(*dr)
for entry in data:
fdata.write(','.join(entry)+'\r\n')
print("All finished, %d slices in total" % len(data))
fdata.close()
result = np.ravel(result)
return result
|
[
"def",
"write_data_csv",
"(",
"fname",
",",
"frames",
",",
"preproc",
")",
":",
"fdata",
"=",
"open",
"(",
"fname",
",",
"\"w\"",
")",
"dr",
"=",
"Parallel",
"(",
")",
"(",
"delayed",
"(",
"get_data",
")",
"(",
"lst",
",",
"preproc",
")",
"for",
"lst",
"in",
"frames",
")",
"data",
",",
"result",
"=",
"zip",
"(",
"*",
"dr",
")",
"for",
"entry",
"in",
"data",
":",
"fdata",
".",
"write",
"(",
"','",
".",
"join",
"(",
"entry",
")",
"+",
"'\\r\\n'",
")",
"print",
"(",
"\"All finished, %d slices in total\"",
"%",
"len",
"(",
"data",
")",
")",
"fdata",
".",
"close",
"(",
")",
"result",
"=",
"np",
".",
"ravel",
"(",
"result",
")",
"return",
"result"
] |
Write data to csv file
|
[
"Write",
"data",
"to",
"csv",
"file"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/kaggle-ndsb2/Preprocessing.py#L94-L104
|
train
|
apache/incubator-mxnet
|
example/kaggle-ndsb2/Preprocessing.py
|
crop_resize
|
def crop_resize(img, size):
"""crop center and resize"""
if img.shape[0] < img.shape[1]:
img = img.T
# we crop image from center
short_egde = min(img.shape[:2])
yy = int((img.shape[0] - short_egde) / 2)
xx = int((img.shape[1] - short_egde) / 2)
crop_img = img[yy : yy + short_egde, xx : xx + short_egde]
# resize to 64, 64
resized_img = transform.resize(crop_img, (size, size))
resized_img *= 255
return resized_img.astype("uint8")
|
python
|
def crop_resize(img, size):
"""crop center and resize"""
if img.shape[0] < img.shape[1]:
img = img.T
# we crop image from center
short_egde = min(img.shape[:2])
yy = int((img.shape[0] - short_egde) / 2)
xx = int((img.shape[1] - short_egde) / 2)
crop_img = img[yy : yy + short_egde, xx : xx + short_egde]
# resize to 64, 64
resized_img = transform.resize(crop_img, (size, size))
resized_img *= 255
return resized_img.astype("uint8")
|
[
"def",
"crop_resize",
"(",
"img",
",",
"size",
")",
":",
"if",
"img",
".",
"shape",
"[",
"0",
"]",
"<",
"img",
".",
"shape",
"[",
"1",
"]",
":",
"img",
"=",
"img",
".",
"T",
"# we crop image from center",
"short_egde",
"=",
"min",
"(",
"img",
".",
"shape",
"[",
":",
"2",
"]",
")",
"yy",
"=",
"int",
"(",
"(",
"img",
".",
"shape",
"[",
"0",
"]",
"-",
"short_egde",
")",
"/",
"2",
")",
"xx",
"=",
"int",
"(",
"(",
"img",
".",
"shape",
"[",
"1",
"]",
"-",
"short_egde",
")",
"/",
"2",
")",
"crop_img",
"=",
"img",
"[",
"yy",
":",
"yy",
"+",
"short_egde",
",",
"xx",
":",
"xx",
"+",
"short_egde",
"]",
"# resize to 64, 64",
"resized_img",
"=",
"transform",
".",
"resize",
"(",
"crop_img",
",",
"(",
"size",
",",
"size",
")",
")",
"resized_img",
"*=",
"255",
"return",
"resized_img",
".",
"astype",
"(",
"\"uint8\"",
")"
] |
crop center and resize
|
[
"crop",
"center",
"and",
"resize"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/kaggle-ndsb2/Preprocessing.py#L107-L119
|
train
|
apache/incubator-mxnet
|
example/gluon/sn_gan/model.py
|
get_generator
|
def get_generator():
""" construct and return generator """
g_net = gluon.nn.Sequential()
with g_net.name_scope():
g_net.add(gluon.nn.Conv2DTranspose(
channels=512, kernel_size=4, strides=1, padding=0, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(
channels=256, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(
channels=128, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(
channels=64, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(channels=3, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.Activation('tanh'))
return g_net
|
python
|
def get_generator():
""" construct and return generator """
g_net = gluon.nn.Sequential()
with g_net.name_scope():
g_net.add(gluon.nn.Conv2DTranspose(
channels=512, kernel_size=4, strides=1, padding=0, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(
channels=256, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(
channels=128, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(
channels=64, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.BatchNorm())
g_net.add(gluon.nn.LeakyReLU(0.2))
g_net.add(gluon.nn.Conv2DTranspose(channels=3, kernel_size=4, strides=2, padding=1, use_bias=False))
g_net.add(gluon.nn.Activation('tanh'))
return g_net
|
[
"def",
"get_generator",
"(",
")",
":",
"g_net",
"=",
"gluon",
".",
"nn",
".",
"Sequential",
"(",
")",
"with",
"g_net",
".",
"name_scope",
"(",
")",
":",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"Conv2DTranspose",
"(",
"channels",
"=",
"512",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"1",
",",
"padding",
"=",
"0",
",",
"use_bias",
"=",
"False",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"Conv2DTranspose",
"(",
"channels",
"=",
"256",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"Conv2DTranspose",
"(",
"channels",
"=",
"128",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"Conv2DTranspose",
"(",
"channels",
"=",
"64",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"Conv2DTranspose",
"(",
"channels",
"=",
"3",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"g_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"Activation",
"(",
"'tanh'",
")",
")",
"return",
"g_net"
] |
construct and return generator
|
[
"construct",
"and",
"return",
"generator"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/sn_gan/model.py#L89-L117
|
train
|
apache/incubator-mxnet
|
example/gluon/sn_gan/model.py
|
get_descriptor
|
def get_descriptor(ctx):
""" construct and return descriptor """
d_net = gluon.nn.Sequential()
with d_net.name_scope():
d_net.add(SNConv2D(num_filter=64, kernel_size=4, strides=2, padding=1, in_channels=3, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=128, kernel_size=4, strides=2, padding=1, in_channels=64, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=256, kernel_size=4, strides=2, padding=1, in_channels=128, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=512, kernel_size=4, strides=2, padding=1, in_channels=256, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=1, kernel_size=4, strides=1, padding=0, in_channels=512, ctx=ctx))
return d_net
|
python
|
def get_descriptor(ctx):
""" construct and return descriptor """
d_net = gluon.nn.Sequential()
with d_net.name_scope():
d_net.add(SNConv2D(num_filter=64, kernel_size=4, strides=2, padding=1, in_channels=3, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=128, kernel_size=4, strides=2, padding=1, in_channels=64, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=256, kernel_size=4, strides=2, padding=1, in_channels=128, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=512, kernel_size=4, strides=2, padding=1, in_channels=256, ctx=ctx))
d_net.add(gluon.nn.LeakyReLU(0.2))
d_net.add(SNConv2D(num_filter=1, kernel_size=4, strides=1, padding=0, in_channels=512, ctx=ctx))
return d_net
|
[
"def",
"get_descriptor",
"(",
"ctx",
")",
":",
"d_net",
"=",
"gluon",
".",
"nn",
".",
"Sequential",
"(",
")",
"with",
"d_net",
".",
"name_scope",
"(",
")",
":",
"d_net",
".",
"add",
"(",
"SNConv2D",
"(",
"num_filter",
"=",
"64",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"in_channels",
"=",
"3",
",",
"ctx",
"=",
"ctx",
")",
")",
"d_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"d_net",
".",
"add",
"(",
"SNConv2D",
"(",
"num_filter",
"=",
"128",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"in_channels",
"=",
"64",
",",
"ctx",
"=",
"ctx",
")",
")",
"d_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"d_net",
".",
"add",
"(",
"SNConv2D",
"(",
"num_filter",
"=",
"256",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"in_channels",
"=",
"128",
",",
"ctx",
"=",
"ctx",
")",
")",
"d_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"d_net",
".",
"add",
"(",
"SNConv2D",
"(",
"num_filter",
"=",
"512",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"2",
",",
"padding",
"=",
"1",
",",
"in_channels",
"=",
"256",
",",
"ctx",
"=",
"ctx",
")",
")",
"d_net",
".",
"add",
"(",
"gluon",
".",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"d_net",
".",
"add",
"(",
"SNConv2D",
"(",
"num_filter",
"=",
"1",
",",
"kernel_size",
"=",
"4",
",",
"strides",
"=",
"1",
",",
"padding",
"=",
"0",
",",
"in_channels",
"=",
"512",
",",
"ctx",
"=",
"ctx",
")",
")",
"return",
"d_net"
] |
construct and return descriptor
|
[
"construct",
"and",
"return",
"descriptor"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/sn_gan/model.py#L120-L139
|
train
|
apache/incubator-mxnet
|
example/gluon/sn_gan/model.py
|
SNConv2D._spectral_norm
|
def _spectral_norm(self):
""" spectral normalization """
w = self.params.get('weight').data(self.ctx)
w_mat = nd.reshape(w, [w.shape[0], -1])
_u = self.u.data(self.ctx)
_v = None
for _ in range(POWER_ITERATION):
_v = nd.L2Normalization(nd.dot(_u, w_mat))
_u = nd.L2Normalization(nd.dot(_v, w_mat.T))
sigma = nd.sum(nd.dot(_u, w_mat) * _v)
if sigma == 0.:
sigma = EPSILON
with autograd.pause():
self.u.set_data(_u)
return w / sigma
|
python
|
def _spectral_norm(self):
""" spectral normalization """
w = self.params.get('weight').data(self.ctx)
w_mat = nd.reshape(w, [w.shape[0], -1])
_u = self.u.data(self.ctx)
_v = None
for _ in range(POWER_ITERATION):
_v = nd.L2Normalization(nd.dot(_u, w_mat))
_u = nd.L2Normalization(nd.dot(_v, w_mat.T))
sigma = nd.sum(nd.dot(_u, w_mat) * _v)
if sigma == 0.:
sigma = EPSILON
with autograd.pause():
self.u.set_data(_u)
return w / sigma
|
[
"def",
"_spectral_norm",
"(",
"self",
")",
":",
"w",
"=",
"self",
".",
"params",
".",
"get",
"(",
"'weight'",
")",
".",
"data",
"(",
"self",
".",
"ctx",
")",
"w_mat",
"=",
"nd",
".",
"reshape",
"(",
"w",
",",
"[",
"w",
".",
"shape",
"[",
"0",
"]",
",",
"-",
"1",
"]",
")",
"_u",
"=",
"self",
".",
"u",
".",
"data",
"(",
"self",
".",
"ctx",
")",
"_v",
"=",
"None",
"for",
"_",
"in",
"range",
"(",
"POWER_ITERATION",
")",
":",
"_v",
"=",
"nd",
".",
"L2Normalization",
"(",
"nd",
".",
"dot",
"(",
"_u",
",",
"w_mat",
")",
")",
"_u",
"=",
"nd",
".",
"L2Normalization",
"(",
"nd",
".",
"dot",
"(",
"_v",
",",
"w_mat",
".",
"T",
")",
")",
"sigma",
"=",
"nd",
".",
"sum",
"(",
"nd",
".",
"dot",
"(",
"_u",
",",
"w_mat",
")",
"*",
"_v",
")",
"if",
"sigma",
"==",
"0.",
":",
"sigma",
"=",
"EPSILON",
"with",
"autograd",
".",
"pause",
"(",
")",
":",
"self",
".",
"u",
".",
"set_data",
"(",
"_u",
")",
"return",
"w",
"/",
"sigma"
] |
spectral normalization
|
[
"spectral",
"normalization"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/sn_gan/model.py#L55-L74
|
train
|
apache/incubator-mxnet
|
example/speech_recognition/stt_utils.py
|
conv_output_length
|
def conv_output_length(input_length, filter_size, border_mode, stride,
dilation=1):
""" Compute the length of the output sequence after 1D convolution along
time. Note that this function is in line with the function used in
Convolution1D class from Keras.
Params:
input_length (int): Length of the input sequence.
filter_size (int): Width of the convolution kernel.
border_mode (str): Only support `same` or `valid`.
stride (int): Stride size used in 1D convolution.
dilation (int)
"""
if input_length is None:
return None
assert border_mode in {'same', 'valid'}
dilated_filter_size = filter_size + (filter_size - 1) * (dilation - 1)
if border_mode == 'same':
output_length = input_length
elif border_mode == 'valid':
output_length = input_length - dilated_filter_size + 1
return (output_length + stride - 1) // stride
|
python
|
def conv_output_length(input_length, filter_size, border_mode, stride,
dilation=1):
""" Compute the length of the output sequence after 1D convolution along
time. Note that this function is in line with the function used in
Convolution1D class from Keras.
Params:
input_length (int): Length of the input sequence.
filter_size (int): Width of the convolution kernel.
border_mode (str): Only support `same` or `valid`.
stride (int): Stride size used in 1D convolution.
dilation (int)
"""
if input_length is None:
return None
assert border_mode in {'same', 'valid'}
dilated_filter_size = filter_size + (filter_size - 1) * (dilation - 1)
if border_mode == 'same':
output_length = input_length
elif border_mode == 'valid':
output_length = input_length - dilated_filter_size + 1
return (output_length + stride - 1) // stride
|
[
"def",
"conv_output_length",
"(",
"input_length",
",",
"filter_size",
",",
"border_mode",
",",
"stride",
",",
"dilation",
"=",
"1",
")",
":",
"if",
"input_length",
"is",
"None",
":",
"return",
"None",
"assert",
"border_mode",
"in",
"{",
"'same'",
",",
"'valid'",
"}",
"dilated_filter_size",
"=",
"filter_size",
"+",
"(",
"filter_size",
"-",
"1",
")",
"*",
"(",
"dilation",
"-",
"1",
")",
"if",
"border_mode",
"==",
"'same'",
":",
"output_length",
"=",
"input_length",
"elif",
"border_mode",
"==",
"'valid'",
":",
"output_length",
"=",
"input_length",
"-",
"dilated_filter_size",
"+",
"1",
"return",
"(",
"output_length",
"+",
"stride",
"-",
"1",
")",
"//",
"stride"
] |
Compute the length of the output sequence after 1D convolution along
time. Note that this function is in line with the function used in
Convolution1D class from Keras.
Params:
input_length (int): Length of the input sequence.
filter_size (int): Width of the convolution kernel.
border_mode (str): Only support `same` or `valid`.
stride (int): Stride size used in 1D convolution.
dilation (int)
|
[
"Compute",
"the",
"length",
"of",
"the",
"output",
"sequence",
"after",
"1D",
"convolution",
"along",
"time",
".",
"Note",
"that",
"this",
"function",
"is",
"in",
"line",
"with",
"the",
"function",
"used",
"in",
"Convolution1D",
"class",
"from",
"Keras",
".",
"Params",
":",
"input_length",
"(",
"int",
")",
":",
"Length",
"of",
"the",
"input",
"sequence",
".",
"filter_size",
"(",
"int",
")",
":",
"Width",
"of",
"the",
"convolution",
"kernel",
".",
"border_mode",
"(",
"str",
")",
":",
"Only",
"support",
"same",
"or",
"valid",
".",
"stride",
"(",
"int",
")",
":",
"Stride",
"size",
"used",
"in",
"1D",
"convolution",
".",
"dilation",
"(",
"int",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/speech_recognition/stt_utils.py#L30-L50
|
train
|
apache/incubator-mxnet
|
example/speech_recognition/stt_utils.py
|
spectrogram
|
def spectrogram(samples, fft_length=256, sample_rate=2, hop_length=128):
"""
Compute the spectrogram for a real signal.
The parameters follow the naming convention of
matplotlib.mlab.specgram
Args:
samples (1D array): input audio signal
fft_length (int): number of elements in fft window
sample_rate (scalar): sample rate
hop_length (int): hop length (relative offset between neighboring
fft windows).
Returns:
x (2D array): spectrogram [frequency x time]
freq (1D array): frequency of each row in x
Note:
This is a truncating computation e.g. if fft_length=10,
hop_length=5 and the signal has 23 elements, then the
last 3 elements will be truncated.
"""
assert not np.iscomplexobj(samples), "Must not pass in complex numbers"
window = np.hanning(fft_length)[:, None]
window_norm = np.sum(window ** 2)
# The scaling below follows the convention of
# matplotlib.mlab.specgram which is the same as
# matlabs specgram.
scale = window_norm * sample_rate
trunc = (len(samples) - fft_length) % hop_length
x = samples[:len(samples) - trunc]
# "stride trick" reshape to include overlap
nshape = (fft_length, (len(x) - fft_length) // hop_length + 1)
nstrides = (x.strides[0], x.strides[0] * hop_length)
x = as_strided(x, shape=nshape, strides=nstrides)
# window stride sanity check
assert np.all(x[:, 1] == samples[hop_length:(hop_length + fft_length)])
# broadcast window, compute fft over columns and square mod
# This function computes the one-dimensional n-point discrete Fourier Transform (DFT) of a real-valued array by means of an efficient algorithm called the Fast Fourier Transform (FFT).
x = np.fft.rfft(x * window, axis=0)
x = np.absolute(x) ** 2
# scale, 2.0 for everything except dc and fft_length/2
x[1:-1, :] *= (2.0 / scale)
x[(0, -1), :] /= scale
freqs = float(sample_rate) / fft_length * np.arange(x.shape[0])
return x, freqs
|
python
|
def spectrogram(samples, fft_length=256, sample_rate=2, hop_length=128):
"""
Compute the spectrogram for a real signal.
The parameters follow the naming convention of
matplotlib.mlab.specgram
Args:
samples (1D array): input audio signal
fft_length (int): number of elements in fft window
sample_rate (scalar): sample rate
hop_length (int): hop length (relative offset between neighboring
fft windows).
Returns:
x (2D array): spectrogram [frequency x time]
freq (1D array): frequency of each row in x
Note:
This is a truncating computation e.g. if fft_length=10,
hop_length=5 and the signal has 23 elements, then the
last 3 elements will be truncated.
"""
assert not np.iscomplexobj(samples), "Must not pass in complex numbers"
window = np.hanning(fft_length)[:, None]
window_norm = np.sum(window ** 2)
# The scaling below follows the convention of
# matplotlib.mlab.specgram which is the same as
# matlabs specgram.
scale = window_norm * sample_rate
trunc = (len(samples) - fft_length) % hop_length
x = samples[:len(samples) - trunc]
# "stride trick" reshape to include overlap
nshape = (fft_length, (len(x) - fft_length) // hop_length + 1)
nstrides = (x.strides[0], x.strides[0] * hop_length)
x = as_strided(x, shape=nshape, strides=nstrides)
# window stride sanity check
assert np.all(x[:, 1] == samples[hop_length:(hop_length + fft_length)])
# broadcast window, compute fft over columns and square mod
# This function computes the one-dimensional n-point discrete Fourier Transform (DFT) of a real-valued array by means of an efficient algorithm called the Fast Fourier Transform (FFT).
x = np.fft.rfft(x * window, axis=0)
x = np.absolute(x) ** 2
# scale, 2.0 for everything except dc and fft_length/2
x[1:-1, :] *= (2.0 / scale)
x[(0, -1), :] /= scale
freqs = float(sample_rate) / fft_length * np.arange(x.shape[0])
return x, freqs
|
[
"def",
"spectrogram",
"(",
"samples",
",",
"fft_length",
"=",
"256",
",",
"sample_rate",
"=",
"2",
",",
"hop_length",
"=",
"128",
")",
":",
"assert",
"not",
"np",
".",
"iscomplexobj",
"(",
"samples",
")",
",",
"\"Must not pass in complex numbers\"",
"window",
"=",
"np",
".",
"hanning",
"(",
"fft_length",
")",
"[",
":",
",",
"None",
"]",
"window_norm",
"=",
"np",
".",
"sum",
"(",
"window",
"**",
"2",
")",
"# The scaling below follows the convention of",
"# matplotlib.mlab.specgram which is the same as",
"# matlabs specgram.",
"scale",
"=",
"window_norm",
"*",
"sample_rate",
"trunc",
"=",
"(",
"len",
"(",
"samples",
")",
"-",
"fft_length",
")",
"%",
"hop_length",
"x",
"=",
"samples",
"[",
":",
"len",
"(",
"samples",
")",
"-",
"trunc",
"]",
"# \"stride trick\" reshape to include overlap",
"nshape",
"=",
"(",
"fft_length",
",",
"(",
"len",
"(",
"x",
")",
"-",
"fft_length",
")",
"//",
"hop_length",
"+",
"1",
")",
"nstrides",
"=",
"(",
"x",
".",
"strides",
"[",
"0",
"]",
",",
"x",
".",
"strides",
"[",
"0",
"]",
"*",
"hop_length",
")",
"x",
"=",
"as_strided",
"(",
"x",
",",
"shape",
"=",
"nshape",
",",
"strides",
"=",
"nstrides",
")",
"# window stride sanity check",
"assert",
"np",
".",
"all",
"(",
"x",
"[",
":",
",",
"1",
"]",
"==",
"samples",
"[",
"hop_length",
":",
"(",
"hop_length",
"+",
"fft_length",
")",
"]",
")",
"# broadcast window, compute fft over columns and square mod",
"# This function computes the one-dimensional n-point discrete Fourier Transform (DFT) of a real-valued array by means of an efficient algorithm called the Fast Fourier Transform (FFT).",
"x",
"=",
"np",
".",
"fft",
".",
"rfft",
"(",
"x",
"*",
"window",
",",
"axis",
"=",
"0",
")",
"x",
"=",
"np",
".",
"absolute",
"(",
"x",
")",
"**",
"2",
"# scale, 2.0 for everything except dc and fft_length/2",
"x",
"[",
"1",
":",
"-",
"1",
",",
":",
"]",
"*=",
"(",
"2.0",
"/",
"scale",
")",
"x",
"[",
"(",
"0",
",",
"-",
"1",
")",
",",
":",
"]",
"/=",
"scale",
"freqs",
"=",
"float",
"(",
"sample_rate",
")",
"/",
"fft_length",
"*",
"np",
".",
"arange",
"(",
"x",
".",
"shape",
"[",
"0",
"]",
")",
"return",
"x",
",",
"freqs"
] |
Compute the spectrogram for a real signal.
The parameters follow the naming convention of
matplotlib.mlab.specgram
Args:
samples (1D array): input audio signal
fft_length (int): number of elements in fft window
sample_rate (scalar): sample rate
hop_length (int): hop length (relative offset between neighboring
fft windows).
Returns:
x (2D array): spectrogram [frequency x time]
freq (1D array): frequency of each row in x
Note:
This is a truncating computation e.g. if fft_length=10,
hop_length=5 and the signal has 23 elements, then the
last 3 elements will be truncated.
|
[
"Compute",
"the",
"spectrogram",
"for",
"a",
"real",
"signal",
".",
"The",
"parameters",
"follow",
"the",
"naming",
"convention",
"of",
"matplotlib",
".",
"mlab",
".",
"specgram",
"Args",
":",
"samples",
"(",
"1D",
"array",
")",
":",
"input",
"audio",
"signal",
"fft_length",
"(",
"int",
")",
":",
"number",
"of",
"elements",
"in",
"fft",
"window",
"sample_rate",
"(",
"scalar",
")",
":",
"sample",
"rate",
"hop_length",
"(",
"int",
")",
":",
"hop",
"length",
"(",
"relative",
"offset",
"between",
"neighboring",
"fft",
"windows",
")",
".",
"Returns",
":",
"x",
"(",
"2D",
"array",
")",
":",
"spectrogram",
"[",
"frequency",
"x",
"time",
"]",
"freq",
"(",
"1D",
"array",
")",
":",
"frequency",
"of",
"each",
"row",
"in",
"x",
"Note",
":",
"This",
"is",
"a",
"truncating",
"computation",
"e",
".",
"g",
".",
"if",
"fft_length",
"=",
"10",
"hop_length",
"=",
"5",
"and",
"the",
"signal",
"has",
"23",
"elements",
"then",
"the",
"last",
"3",
"elements",
"will",
"be",
"truncated",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/speech_recognition/stt_utils.py#L53-L104
|
train
|
apache/incubator-mxnet
|
example/speech_recognition/stt_utils.py
|
spectrogram_from_file
|
def spectrogram_from_file(filename, step=10, window=20, max_freq=None,
eps=1e-14, overwrite=False, save_feature_as_csvfile=False):
""" Calculate the log of linear spectrogram from FFT energy
Params:
filename (str): Path to the audio file
step (int): Step size in milliseconds between windows
window (int): FFT window size in milliseconds
max_freq (int): Only FFT bins corresponding to frequencies between
[0, max_freq] are returned
eps (float): Small value to ensure numerical stability (for ln(x))
"""
csvfilename = filename.replace(".wav", ".csv")
if (os.path.isfile(csvfilename) is False) or overwrite:
with soundfile.SoundFile(filename) as sound_file:
audio = sound_file.read(dtype='float32')
sample_rate = sound_file.samplerate
if audio.ndim >= 2:
audio = np.mean(audio, 1)
if max_freq is None:
max_freq = sample_rate / 2
if max_freq > sample_rate / 2:
raise ValueError("max_freq must not be greater than half of "
" sample rate")
if step > window:
raise ValueError("step size must not be greater than window size")
hop_length = int(0.001 * step * sample_rate)
fft_length = int(0.001 * window * sample_rate)
pxx, freqs = spectrogram(
audio, fft_length=fft_length, sample_rate=sample_rate,
hop_length=hop_length)
ind = np.where(freqs <= max_freq)[0][-1] + 1
res = np.transpose(np.log(pxx[:ind, :] + eps))
if save_feature_as_csvfile:
np.savetxt(csvfilename, res)
return res
else:
return np.loadtxt(csvfilename)
|
python
|
def spectrogram_from_file(filename, step=10, window=20, max_freq=None,
eps=1e-14, overwrite=False, save_feature_as_csvfile=False):
""" Calculate the log of linear spectrogram from FFT energy
Params:
filename (str): Path to the audio file
step (int): Step size in milliseconds between windows
window (int): FFT window size in milliseconds
max_freq (int): Only FFT bins corresponding to frequencies between
[0, max_freq] are returned
eps (float): Small value to ensure numerical stability (for ln(x))
"""
csvfilename = filename.replace(".wav", ".csv")
if (os.path.isfile(csvfilename) is False) or overwrite:
with soundfile.SoundFile(filename) as sound_file:
audio = sound_file.read(dtype='float32')
sample_rate = sound_file.samplerate
if audio.ndim >= 2:
audio = np.mean(audio, 1)
if max_freq is None:
max_freq = sample_rate / 2
if max_freq > sample_rate / 2:
raise ValueError("max_freq must not be greater than half of "
" sample rate")
if step > window:
raise ValueError("step size must not be greater than window size")
hop_length = int(0.001 * step * sample_rate)
fft_length = int(0.001 * window * sample_rate)
pxx, freqs = spectrogram(
audio, fft_length=fft_length, sample_rate=sample_rate,
hop_length=hop_length)
ind = np.where(freqs <= max_freq)[0][-1] + 1
res = np.transpose(np.log(pxx[:ind, :] + eps))
if save_feature_as_csvfile:
np.savetxt(csvfilename, res)
return res
else:
return np.loadtxt(csvfilename)
|
[
"def",
"spectrogram_from_file",
"(",
"filename",
",",
"step",
"=",
"10",
",",
"window",
"=",
"20",
",",
"max_freq",
"=",
"None",
",",
"eps",
"=",
"1e-14",
",",
"overwrite",
"=",
"False",
",",
"save_feature_as_csvfile",
"=",
"False",
")",
":",
"csvfilename",
"=",
"filename",
".",
"replace",
"(",
"\".wav\"",
",",
"\".csv\"",
")",
"if",
"(",
"os",
".",
"path",
".",
"isfile",
"(",
"csvfilename",
")",
"is",
"False",
")",
"or",
"overwrite",
":",
"with",
"soundfile",
".",
"SoundFile",
"(",
"filename",
")",
"as",
"sound_file",
":",
"audio",
"=",
"sound_file",
".",
"read",
"(",
"dtype",
"=",
"'float32'",
")",
"sample_rate",
"=",
"sound_file",
".",
"samplerate",
"if",
"audio",
".",
"ndim",
">=",
"2",
":",
"audio",
"=",
"np",
".",
"mean",
"(",
"audio",
",",
"1",
")",
"if",
"max_freq",
"is",
"None",
":",
"max_freq",
"=",
"sample_rate",
"/",
"2",
"if",
"max_freq",
">",
"sample_rate",
"/",
"2",
":",
"raise",
"ValueError",
"(",
"\"max_freq must not be greater than half of \"",
"\" sample rate\"",
")",
"if",
"step",
">",
"window",
":",
"raise",
"ValueError",
"(",
"\"step size must not be greater than window size\"",
")",
"hop_length",
"=",
"int",
"(",
"0.001",
"*",
"step",
"*",
"sample_rate",
")",
"fft_length",
"=",
"int",
"(",
"0.001",
"*",
"window",
"*",
"sample_rate",
")",
"pxx",
",",
"freqs",
"=",
"spectrogram",
"(",
"audio",
",",
"fft_length",
"=",
"fft_length",
",",
"sample_rate",
"=",
"sample_rate",
",",
"hop_length",
"=",
"hop_length",
")",
"ind",
"=",
"np",
".",
"where",
"(",
"freqs",
"<=",
"max_freq",
")",
"[",
"0",
"]",
"[",
"-",
"1",
"]",
"+",
"1",
"res",
"=",
"np",
".",
"transpose",
"(",
"np",
".",
"log",
"(",
"pxx",
"[",
":",
"ind",
",",
":",
"]",
"+",
"eps",
")",
")",
"if",
"save_feature_as_csvfile",
":",
"np",
".",
"savetxt",
"(",
"csvfilename",
",",
"res",
")",
"return",
"res",
"else",
":",
"return",
"np",
".",
"loadtxt",
"(",
"csvfilename",
")"
] |
Calculate the log of linear spectrogram from FFT energy
Params:
filename (str): Path to the audio file
step (int): Step size in milliseconds between windows
window (int): FFT window size in milliseconds
max_freq (int): Only FFT bins corresponding to frequencies between
[0, max_freq] are returned
eps (float): Small value to ensure numerical stability (for ln(x))
|
[
"Calculate",
"the",
"log",
"of",
"linear",
"spectrogram",
"from",
"FFT",
"energy",
"Params",
":",
"filename",
"(",
"str",
")",
":",
"Path",
"to",
"the",
"audio",
"file",
"step",
"(",
"int",
")",
":",
"Step",
"size",
"in",
"milliseconds",
"between",
"windows",
"window",
"(",
"int",
")",
":",
"FFT",
"window",
"size",
"in",
"milliseconds",
"max_freq",
"(",
"int",
")",
":",
"Only",
"FFT",
"bins",
"corresponding",
"to",
"frequencies",
"between",
"[",
"0",
"max_freq",
"]",
"are",
"returned",
"eps",
"(",
"float",
")",
":",
"Small",
"value",
"to",
"ensure",
"numerical",
"stability",
"(",
"for",
"ln",
"(",
"x",
"))"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/speech_recognition/stt_utils.py#L107-L146
|
train
|
apache/incubator-mxnet
|
example/ssd/tools/rand_sampler.py
|
RandCropper.sample
|
def sample(self, label):
"""
generate random cropping boxes according to parameters
if satifactory crops generated, apply to ground-truth as well
Parameters:
----------
label : numpy.array (n x 5 matrix)
ground-truths
Returns:
----------
list of (crop_box, label) tuples, if failed, return empty list []
"""
samples = []
count = 0
for trial in range(self.max_trials):
if count >= self.max_sample:
return samples
scale = np.random.uniform(self.min_scale, self.max_scale)
min_ratio = max(self.min_aspect_ratio, scale * scale)
max_ratio = min(self.max_aspect_ratio, 1. / scale / scale)
ratio = math.sqrt(np.random.uniform(min_ratio, max_ratio))
width = scale * ratio
height = scale / ratio
left = np.random.uniform(0., 1 - width)
top = np.random.uniform(0., 1 - height)
rand_box = (left, top, left + width, top + height)
valid_mask = np.where(label[:, 0] > -1)[0]
gt = label[valid_mask, :]
ious = self._check_satisfy(rand_box, gt)
if ious is not None:
# transform gt labels after crop, discard bad ones
l, t, r, b = rand_box
new_gt_boxes = []
new_width = r - l
new_height = b - t
for i in range(valid_mask.size):
if ious[i] > 0:
xmin = max(0., (gt[i, 1] - l) / new_width)
ymin = max(0., (gt[i, 2] - t) / new_height)
xmax = min(1., (gt[i, 3] - l) / new_width)
ymax = min(1., (gt[i, 4] - t) / new_height)
new_gt_boxes.append([gt[i, 0], xmin, ymin, xmax, ymax])
if not new_gt_boxes:
continue
new_gt_boxes = np.array(new_gt_boxes)
label = np.lib.pad(new_gt_boxes,
((0, label.shape[0]-new_gt_boxes.shape[0]), (0,0)), \
'constant', constant_values=(-1, -1))
samples.append((rand_box, label))
count += 1
return samples
|
python
|
def sample(self, label):
"""
generate random cropping boxes according to parameters
if satifactory crops generated, apply to ground-truth as well
Parameters:
----------
label : numpy.array (n x 5 matrix)
ground-truths
Returns:
----------
list of (crop_box, label) tuples, if failed, return empty list []
"""
samples = []
count = 0
for trial in range(self.max_trials):
if count >= self.max_sample:
return samples
scale = np.random.uniform(self.min_scale, self.max_scale)
min_ratio = max(self.min_aspect_ratio, scale * scale)
max_ratio = min(self.max_aspect_ratio, 1. / scale / scale)
ratio = math.sqrt(np.random.uniform(min_ratio, max_ratio))
width = scale * ratio
height = scale / ratio
left = np.random.uniform(0., 1 - width)
top = np.random.uniform(0., 1 - height)
rand_box = (left, top, left + width, top + height)
valid_mask = np.where(label[:, 0] > -1)[0]
gt = label[valid_mask, :]
ious = self._check_satisfy(rand_box, gt)
if ious is not None:
# transform gt labels after crop, discard bad ones
l, t, r, b = rand_box
new_gt_boxes = []
new_width = r - l
new_height = b - t
for i in range(valid_mask.size):
if ious[i] > 0:
xmin = max(0., (gt[i, 1] - l) / new_width)
ymin = max(0., (gt[i, 2] - t) / new_height)
xmax = min(1., (gt[i, 3] - l) / new_width)
ymax = min(1., (gt[i, 4] - t) / new_height)
new_gt_boxes.append([gt[i, 0], xmin, ymin, xmax, ymax])
if not new_gt_boxes:
continue
new_gt_boxes = np.array(new_gt_boxes)
label = np.lib.pad(new_gt_boxes,
((0, label.shape[0]-new_gt_boxes.shape[0]), (0,0)), \
'constant', constant_values=(-1, -1))
samples.append((rand_box, label))
count += 1
return samples
|
[
"def",
"sample",
"(",
"self",
",",
"label",
")",
":",
"samples",
"=",
"[",
"]",
"count",
"=",
"0",
"for",
"trial",
"in",
"range",
"(",
"self",
".",
"max_trials",
")",
":",
"if",
"count",
">=",
"self",
".",
"max_sample",
":",
"return",
"samples",
"scale",
"=",
"np",
".",
"random",
".",
"uniform",
"(",
"self",
".",
"min_scale",
",",
"self",
".",
"max_scale",
")",
"min_ratio",
"=",
"max",
"(",
"self",
".",
"min_aspect_ratio",
",",
"scale",
"*",
"scale",
")",
"max_ratio",
"=",
"min",
"(",
"self",
".",
"max_aspect_ratio",
",",
"1.",
"/",
"scale",
"/",
"scale",
")",
"ratio",
"=",
"math",
".",
"sqrt",
"(",
"np",
".",
"random",
".",
"uniform",
"(",
"min_ratio",
",",
"max_ratio",
")",
")",
"width",
"=",
"scale",
"*",
"ratio",
"height",
"=",
"scale",
"/",
"ratio",
"left",
"=",
"np",
".",
"random",
".",
"uniform",
"(",
"0.",
",",
"1",
"-",
"width",
")",
"top",
"=",
"np",
".",
"random",
".",
"uniform",
"(",
"0.",
",",
"1",
"-",
"height",
")",
"rand_box",
"=",
"(",
"left",
",",
"top",
",",
"left",
"+",
"width",
",",
"top",
"+",
"height",
")",
"valid_mask",
"=",
"np",
".",
"where",
"(",
"label",
"[",
":",
",",
"0",
"]",
">",
"-",
"1",
")",
"[",
"0",
"]",
"gt",
"=",
"label",
"[",
"valid_mask",
",",
":",
"]",
"ious",
"=",
"self",
".",
"_check_satisfy",
"(",
"rand_box",
",",
"gt",
")",
"if",
"ious",
"is",
"not",
"None",
":",
"# transform gt labels after crop, discard bad ones",
"l",
",",
"t",
",",
"r",
",",
"b",
"=",
"rand_box",
"new_gt_boxes",
"=",
"[",
"]",
"new_width",
"=",
"r",
"-",
"l",
"new_height",
"=",
"b",
"-",
"t",
"for",
"i",
"in",
"range",
"(",
"valid_mask",
".",
"size",
")",
":",
"if",
"ious",
"[",
"i",
"]",
">",
"0",
":",
"xmin",
"=",
"max",
"(",
"0.",
",",
"(",
"gt",
"[",
"i",
",",
"1",
"]",
"-",
"l",
")",
"/",
"new_width",
")",
"ymin",
"=",
"max",
"(",
"0.",
",",
"(",
"gt",
"[",
"i",
",",
"2",
"]",
"-",
"t",
")",
"/",
"new_height",
")",
"xmax",
"=",
"min",
"(",
"1.",
",",
"(",
"gt",
"[",
"i",
",",
"3",
"]",
"-",
"l",
")",
"/",
"new_width",
")",
"ymax",
"=",
"min",
"(",
"1.",
",",
"(",
"gt",
"[",
"i",
",",
"4",
"]",
"-",
"t",
")",
"/",
"new_height",
")",
"new_gt_boxes",
".",
"append",
"(",
"[",
"gt",
"[",
"i",
",",
"0",
"]",
",",
"xmin",
",",
"ymin",
",",
"xmax",
",",
"ymax",
"]",
")",
"if",
"not",
"new_gt_boxes",
":",
"continue",
"new_gt_boxes",
"=",
"np",
".",
"array",
"(",
"new_gt_boxes",
")",
"label",
"=",
"np",
".",
"lib",
".",
"pad",
"(",
"new_gt_boxes",
",",
"(",
"(",
"0",
",",
"label",
".",
"shape",
"[",
"0",
"]",
"-",
"new_gt_boxes",
".",
"shape",
"[",
"0",
"]",
")",
",",
"(",
"0",
",",
"0",
")",
")",
",",
"'constant'",
",",
"constant_values",
"=",
"(",
"-",
"1",
",",
"-",
"1",
")",
")",
"samples",
".",
"append",
"(",
"(",
"rand_box",
",",
"label",
")",
")",
"count",
"+=",
"1",
"return",
"samples"
] |
generate random cropping boxes according to parameters
if satifactory crops generated, apply to ground-truth as well
Parameters:
----------
label : numpy.array (n x 5 matrix)
ground-truths
Returns:
----------
list of (crop_box, label) tuples, if failed, return empty list []
|
[
"generate",
"random",
"cropping",
"boxes",
"according",
"to",
"parameters",
"if",
"satifactory",
"crops",
"generated",
"apply",
"to",
"ground",
"-",
"truth",
"as",
"well"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/tools/rand_sampler.py#L93-L145
|
train
|
apache/incubator-mxnet
|
example/ssd/tools/rand_sampler.py
|
RandCropper._check_satisfy
|
def _check_satisfy(self, rand_box, gt_boxes):
"""
check if overlap with any gt box is larger than threshold
"""
l, t, r, b = rand_box
num_gt = gt_boxes.shape[0]
ls = np.ones(num_gt) * l
ts = np.ones(num_gt) * t
rs = np.ones(num_gt) * r
bs = np.ones(num_gt) * b
mask = np.where(ls < gt_boxes[:, 1])[0]
ls[mask] = gt_boxes[mask, 1]
mask = np.where(ts < gt_boxes[:, 2])[0]
ts[mask] = gt_boxes[mask, 2]
mask = np.where(rs > gt_boxes[:, 3])[0]
rs[mask] = gt_boxes[mask, 3]
mask = np.where(bs > gt_boxes[:, 4])[0]
bs[mask] = gt_boxes[mask, 4]
w = rs - ls
w[w < 0] = 0
h = bs - ts
h[h < 0] = 0
inter_area = h * w
union_area = np.ones(num_gt) * max(0, r - l) * max(0, b - t)
union_area += (gt_boxes[:, 3] - gt_boxes[:, 1]) * (gt_boxes[:, 4] - gt_boxes[:, 2])
union_area -= inter_area
ious = inter_area / union_area
ious[union_area <= 0] = 0
max_iou = np.amax(ious)
if max_iou < self.min_overlap:
return None
# check ground-truth constraint
if self.config['gt_constraint'] == 'center':
for i in range(ious.shape[0]):
if ious[i] > 0:
gt_x = (gt_boxes[i, 1] + gt_boxes[i, 3]) / 2.0
gt_y = (gt_boxes[i, 2] + gt_boxes[i, 4]) / 2.0
if gt_x < l or gt_x > r or gt_y < t or gt_y > b:
return None
elif self.config['gt_constraint'] == 'corner':
for i in range(ious.shape[0]):
if ious[i] > 0:
if gt_boxes[i, 1] < l or gt_boxes[i, 3] > r \
or gt_boxes[i, 2] < t or gt_boxes[i, 4] > b:
return None
return ious
|
python
|
def _check_satisfy(self, rand_box, gt_boxes):
"""
check if overlap with any gt box is larger than threshold
"""
l, t, r, b = rand_box
num_gt = gt_boxes.shape[0]
ls = np.ones(num_gt) * l
ts = np.ones(num_gt) * t
rs = np.ones(num_gt) * r
bs = np.ones(num_gt) * b
mask = np.where(ls < gt_boxes[:, 1])[0]
ls[mask] = gt_boxes[mask, 1]
mask = np.where(ts < gt_boxes[:, 2])[0]
ts[mask] = gt_boxes[mask, 2]
mask = np.where(rs > gt_boxes[:, 3])[0]
rs[mask] = gt_boxes[mask, 3]
mask = np.where(bs > gt_boxes[:, 4])[0]
bs[mask] = gt_boxes[mask, 4]
w = rs - ls
w[w < 0] = 0
h = bs - ts
h[h < 0] = 0
inter_area = h * w
union_area = np.ones(num_gt) * max(0, r - l) * max(0, b - t)
union_area += (gt_boxes[:, 3] - gt_boxes[:, 1]) * (gt_boxes[:, 4] - gt_boxes[:, 2])
union_area -= inter_area
ious = inter_area / union_area
ious[union_area <= 0] = 0
max_iou = np.amax(ious)
if max_iou < self.min_overlap:
return None
# check ground-truth constraint
if self.config['gt_constraint'] == 'center':
for i in range(ious.shape[0]):
if ious[i] > 0:
gt_x = (gt_boxes[i, 1] + gt_boxes[i, 3]) / 2.0
gt_y = (gt_boxes[i, 2] + gt_boxes[i, 4]) / 2.0
if gt_x < l or gt_x > r or gt_y < t or gt_y > b:
return None
elif self.config['gt_constraint'] == 'corner':
for i in range(ious.shape[0]):
if ious[i] > 0:
if gt_boxes[i, 1] < l or gt_boxes[i, 3] > r \
or gt_boxes[i, 2] < t or gt_boxes[i, 4] > b:
return None
return ious
|
[
"def",
"_check_satisfy",
"(",
"self",
",",
"rand_box",
",",
"gt_boxes",
")",
":",
"l",
",",
"t",
",",
"r",
",",
"b",
"=",
"rand_box",
"num_gt",
"=",
"gt_boxes",
".",
"shape",
"[",
"0",
"]",
"ls",
"=",
"np",
".",
"ones",
"(",
"num_gt",
")",
"*",
"l",
"ts",
"=",
"np",
".",
"ones",
"(",
"num_gt",
")",
"*",
"t",
"rs",
"=",
"np",
".",
"ones",
"(",
"num_gt",
")",
"*",
"r",
"bs",
"=",
"np",
".",
"ones",
"(",
"num_gt",
")",
"*",
"b",
"mask",
"=",
"np",
".",
"where",
"(",
"ls",
"<",
"gt_boxes",
"[",
":",
",",
"1",
"]",
")",
"[",
"0",
"]",
"ls",
"[",
"mask",
"]",
"=",
"gt_boxes",
"[",
"mask",
",",
"1",
"]",
"mask",
"=",
"np",
".",
"where",
"(",
"ts",
"<",
"gt_boxes",
"[",
":",
",",
"2",
"]",
")",
"[",
"0",
"]",
"ts",
"[",
"mask",
"]",
"=",
"gt_boxes",
"[",
"mask",
",",
"2",
"]",
"mask",
"=",
"np",
".",
"where",
"(",
"rs",
">",
"gt_boxes",
"[",
":",
",",
"3",
"]",
")",
"[",
"0",
"]",
"rs",
"[",
"mask",
"]",
"=",
"gt_boxes",
"[",
"mask",
",",
"3",
"]",
"mask",
"=",
"np",
".",
"where",
"(",
"bs",
">",
"gt_boxes",
"[",
":",
",",
"4",
"]",
")",
"[",
"0",
"]",
"bs",
"[",
"mask",
"]",
"=",
"gt_boxes",
"[",
"mask",
",",
"4",
"]",
"w",
"=",
"rs",
"-",
"ls",
"w",
"[",
"w",
"<",
"0",
"]",
"=",
"0",
"h",
"=",
"bs",
"-",
"ts",
"h",
"[",
"h",
"<",
"0",
"]",
"=",
"0",
"inter_area",
"=",
"h",
"*",
"w",
"union_area",
"=",
"np",
".",
"ones",
"(",
"num_gt",
")",
"*",
"max",
"(",
"0",
",",
"r",
"-",
"l",
")",
"*",
"max",
"(",
"0",
",",
"b",
"-",
"t",
")",
"union_area",
"+=",
"(",
"gt_boxes",
"[",
":",
",",
"3",
"]",
"-",
"gt_boxes",
"[",
":",
",",
"1",
"]",
")",
"*",
"(",
"gt_boxes",
"[",
":",
",",
"4",
"]",
"-",
"gt_boxes",
"[",
":",
",",
"2",
"]",
")",
"union_area",
"-=",
"inter_area",
"ious",
"=",
"inter_area",
"/",
"union_area",
"ious",
"[",
"union_area",
"<=",
"0",
"]",
"=",
"0",
"max_iou",
"=",
"np",
".",
"amax",
"(",
"ious",
")",
"if",
"max_iou",
"<",
"self",
".",
"min_overlap",
":",
"return",
"None",
"# check ground-truth constraint",
"if",
"self",
".",
"config",
"[",
"'gt_constraint'",
"]",
"==",
"'center'",
":",
"for",
"i",
"in",
"range",
"(",
"ious",
".",
"shape",
"[",
"0",
"]",
")",
":",
"if",
"ious",
"[",
"i",
"]",
">",
"0",
":",
"gt_x",
"=",
"(",
"gt_boxes",
"[",
"i",
",",
"1",
"]",
"+",
"gt_boxes",
"[",
"i",
",",
"3",
"]",
")",
"/",
"2.0",
"gt_y",
"=",
"(",
"gt_boxes",
"[",
"i",
",",
"2",
"]",
"+",
"gt_boxes",
"[",
"i",
",",
"4",
"]",
")",
"/",
"2.0",
"if",
"gt_x",
"<",
"l",
"or",
"gt_x",
">",
"r",
"or",
"gt_y",
"<",
"t",
"or",
"gt_y",
">",
"b",
":",
"return",
"None",
"elif",
"self",
".",
"config",
"[",
"'gt_constraint'",
"]",
"==",
"'corner'",
":",
"for",
"i",
"in",
"range",
"(",
"ious",
".",
"shape",
"[",
"0",
"]",
")",
":",
"if",
"ious",
"[",
"i",
"]",
">",
"0",
":",
"if",
"gt_boxes",
"[",
"i",
",",
"1",
"]",
"<",
"l",
"or",
"gt_boxes",
"[",
"i",
",",
"3",
"]",
">",
"r",
"or",
"gt_boxes",
"[",
"i",
",",
"2",
"]",
"<",
"t",
"or",
"gt_boxes",
"[",
"i",
",",
"4",
"]",
">",
"b",
":",
"return",
"None",
"return",
"ious"
] |
check if overlap with any gt box is larger than threshold
|
[
"check",
"if",
"overlap",
"with",
"any",
"gt",
"box",
"is",
"larger",
"than",
"threshold"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/tools/rand_sampler.py#L147-L192
|
train
|
apache/incubator-mxnet
|
example/ssd/tools/rand_sampler.py
|
RandPadder.sample
|
def sample(self, label):
"""
generate random padding boxes according to parameters
if satifactory padding generated, apply to ground-truth as well
Parameters:
----------
label : numpy.array (n x 5 matrix)
ground-truths
Returns:
----------
list of (crop_box, label) tuples, if failed, return empty list []
"""
samples = []
count = 0
for trial in range(self.max_trials):
if count >= self.max_sample:
return samples
scale = np.random.uniform(self.min_scale, self.max_scale)
min_ratio = max(self.min_aspect_ratio, scale * scale)
max_ratio = min(self.max_aspect_ratio, 1. / scale / scale)
ratio = math.sqrt(np.random.uniform(min_ratio, max_ratio))
width = scale * ratio
if width < 1:
continue
height = scale / ratio
if height < 1:
continue
left = np.random.uniform(0., 1 - width)
top = np.random.uniform(0., 1 - height)
right = left + width
bot = top + height
rand_box = (left, top, right, bot)
valid_mask = np.where(label[:, 0] > -1)[0]
gt = label[valid_mask, :]
new_gt_boxes = []
for i in range(gt.shape[0]):
xmin = (gt[i, 1] - left) / width
ymin = (gt[i, 2] - top) / height
xmax = (gt[i, 3] - left) / width
ymax = (gt[i, 4] - top) / height
new_size = min(xmax - xmin, ymax - ymin)
if new_size < self.min_gt_scale:
new_gt_boxes = []
break
new_gt_boxes.append([gt[i, 0], xmin, ymin, xmax, ymax])
if not new_gt_boxes:
continue
new_gt_boxes = np.array(new_gt_boxes)
label = np.lib.pad(new_gt_boxes,
((0, label.shape[0]-new_gt_boxes.shape[0]), (0,0)), \
'constant', constant_values=(-1, -1))
samples.append((rand_box, label))
count += 1
return samples
|
python
|
def sample(self, label):
"""
generate random padding boxes according to parameters
if satifactory padding generated, apply to ground-truth as well
Parameters:
----------
label : numpy.array (n x 5 matrix)
ground-truths
Returns:
----------
list of (crop_box, label) tuples, if failed, return empty list []
"""
samples = []
count = 0
for trial in range(self.max_trials):
if count >= self.max_sample:
return samples
scale = np.random.uniform(self.min_scale, self.max_scale)
min_ratio = max(self.min_aspect_ratio, scale * scale)
max_ratio = min(self.max_aspect_ratio, 1. / scale / scale)
ratio = math.sqrt(np.random.uniform(min_ratio, max_ratio))
width = scale * ratio
if width < 1:
continue
height = scale / ratio
if height < 1:
continue
left = np.random.uniform(0., 1 - width)
top = np.random.uniform(0., 1 - height)
right = left + width
bot = top + height
rand_box = (left, top, right, bot)
valid_mask = np.where(label[:, 0] > -1)[0]
gt = label[valid_mask, :]
new_gt_boxes = []
for i in range(gt.shape[0]):
xmin = (gt[i, 1] - left) / width
ymin = (gt[i, 2] - top) / height
xmax = (gt[i, 3] - left) / width
ymax = (gt[i, 4] - top) / height
new_size = min(xmax - xmin, ymax - ymin)
if new_size < self.min_gt_scale:
new_gt_boxes = []
break
new_gt_boxes.append([gt[i, 0], xmin, ymin, xmax, ymax])
if not new_gt_boxes:
continue
new_gt_boxes = np.array(new_gt_boxes)
label = np.lib.pad(new_gt_boxes,
((0, label.shape[0]-new_gt_boxes.shape[0]), (0,0)), \
'constant', constant_values=(-1, -1))
samples.append((rand_box, label))
count += 1
return samples
|
[
"def",
"sample",
"(",
"self",
",",
"label",
")",
":",
"samples",
"=",
"[",
"]",
"count",
"=",
"0",
"for",
"trial",
"in",
"range",
"(",
"self",
".",
"max_trials",
")",
":",
"if",
"count",
">=",
"self",
".",
"max_sample",
":",
"return",
"samples",
"scale",
"=",
"np",
".",
"random",
".",
"uniform",
"(",
"self",
".",
"min_scale",
",",
"self",
".",
"max_scale",
")",
"min_ratio",
"=",
"max",
"(",
"self",
".",
"min_aspect_ratio",
",",
"scale",
"*",
"scale",
")",
"max_ratio",
"=",
"min",
"(",
"self",
".",
"max_aspect_ratio",
",",
"1.",
"/",
"scale",
"/",
"scale",
")",
"ratio",
"=",
"math",
".",
"sqrt",
"(",
"np",
".",
"random",
".",
"uniform",
"(",
"min_ratio",
",",
"max_ratio",
")",
")",
"width",
"=",
"scale",
"*",
"ratio",
"if",
"width",
"<",
"1",
":",
"continue",
"height",
"=",
"scale",
"/",
"ratio",
"if",
"height",
"<",
"1",
":",
"continue",
"left",
"=",
"np",
".",
"random",
".",
"uniform",
"(",
"0.",
",",
"1",
"-",
"width",
")",
"top",
"=",
"np",
".",
"random",
".",
"uniform",
"(",
"0.",
",",
"1",
"-",
"height",
")",
"right",
"=",
"left",
"+",
"width",
"bot",
"=",
"top",
"+",
"height",
"rand_box",
"=",
"(",
"left",
",",
"top",
",",
"right",
",",
"bot",
")",
"valid_mask",
"=",
"np",
".",
"where",
"(",
"label",
"[",
":",
",",
"0",
"]",
">",
"-",
"1",
")",
"[",
"0",
"]",
"gt",
"=",
"label",
"[",
"valid_mask",
",",
":",
"]",
"new_gt_boxes",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"gt",
".",
"shape",
"[",
"0",
"]",
")",
":",
"xmin",
"=",
"(",
"gt",
"[",
"i",
",",
"1",
"]",
"-",
"left",
")",
"/",
"width",
"ymin",
"=",
"(",
"gt",
"[",
"i",
",",
"2",
"]",
"-",
"top",
")",
"/",
"height",
"xmax",
"=",
"(",
"gt",
"[",
"i",
",",
"3",
"]",
"-",
"left",
")",
"/",
"width",
"ymax",
"=",
"(",
"gt",
"[",
"i",
",",
"4",
"]",
"-",
"top",
")",
"/",
"height",
"new_size",
"=",
"min",
"(",
"xmax",
"-",
"xmin",
",",
"ymax",
"-",
"ymin",
")",
"if",
"new_size",
"<",
"self",
".",
"min_gt_scale",
":",
"new_gt_boxes",
"=",
"[",
"]",
"break",
"new_gt_boxes",
".",
"append",
"(",
"[",
"gt",
"[",
"i",
",",
"0",
"]",
",",
"xmin",
",",
"ymin",
",",
"xmax",
",",
"ymax",
"]",
")",
"if",
"not",
"new_gt_boxes",
":",
"continue",
"new_gt_boxes",
"=",
"np",
".",
"array",
"(",
"new_gt_boxes",
")",
"label",
"=",
"np",
".",
"lib",
".",
"pad",
"(",
"new_gt_boxes",
",",
"(",
"(",
"0",
",",
"label",
".",
"shape",
"[",
"0",
"]",
"-",
"new_gt_boxes",
".",
"shape",
"[",
"0",
"]",
")",
",",
"(",
"0",
",",
"0",
")",
")",
",",
"'constant'",
",",
"constant_values",
"=",
"(",
"-",
"1",
",",
"-",
"1",
")",
")",
"samples",
".",
"append",
"(",
"(",
"rand_box",
",",
"label",
")",
")",
"count",
"+=",
"1",
"return",
"samples"
] |
generate random padding boxes according to parameters
if satifactory padding generated, apply to ground-truth as well
Parameters:
----------
label : numpy.array (n x 5 matrix)
ground-truths
Returns:
----------
list of (crop_box, label) tuples, if failed, return empty list []
|
[
"generate",
"random",
"padding",
"boxes",
"according",
"to",
"parameters",
"if",
"satifactory",
"padding",
"generated",
"apply",
"to",
"ground",
"-",
"truth",
"as",
"well"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/tools/rand_sampler.py#L232-L287
|
train
|
apache/incubator-mxnet
|
benchmark/python/sparse/dot.py
|
measure_cost
|
def measure_cost(repeat, scipy_trans_lhs, scipy_dns_lhs, func_name, *args, **kwargs):
"""Measure time cost of running a function
"""
mx.nd.waitall()
args_list = []
for arg in args:
args_list.append(arg)
start = time.time()
if scipy_trans_lhs:
args_list[0] = np.transpose(args_list[0]) if scipy_dns_lhs else sp.spmatrix.transpose(args_list[0])
for _ in range(repeat):
func_name(*args_list, **kwargs)
mx.nd.waitall()
end = time.time()
diff = end - start
return diff / repeat
|
python
|
def measure_cost(repeat, scipy_trans_lhs, scipy_dns_lhs, func_name, *args, **kwargs):
"""Measure time cost of running a function
"""
mx.nd.waitall()
args_list = []
for arg in args:
args_list.append(arg)
start = time.time()
if scipy_trans_lhs:
args_list[0] = np.transpose(args_list[0]) if scipy_dns_lhs else sp.spmatrix.transpose(args_list[0])
for _ in range(repeat):
func_name(*args_list, **kwargs)
mx.nd.waitall()
end = time.time()
diff = end - start
return diff / repeat
|
[
"def",
"measure_cost",
"(",
"repeat",
",",
"scipy_trans_lhs",
",",
"scipy_dns_lhs",
",",
"func_name",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"mx",
".",
"nd",
".",
"waitall",
"(",
")",
"args_list",
"=",
"[",
"]",
"for",
"arg",
"in",
"args",
":",
"args_list",
".",
"append",
"(",
"arg",
")",
"start",
"=",
"time",
".",
"time",
"(",
")",
"if",
"scipy_trans_lhs",
":",
"args_list",
"[",
"0",
"]",
"=",
"np",
".",
"transpose",
"(",
"args_list",
"[",
"0",
"]",
")",
"if",
"scipy_dns_lhs",
"else",
"sp",
".",
"spmatrix",
".",
"transpose",
"(",
"args_list",
"[",
"0",
"]",
")",
"for",
"_",
"in",
"range",
"(",
"repeat",
")",
":",
"func_name",
"(",
"*",
"args_list",
",",
"*",
"*",
"kwargs",
")",
"mx",
".",
"nd",
".",
"waitall",
"(",
")",
"end",
"=",
"time",
".",
"time",
"(",
")",
"diff",
"=",
"end",
"-",
"start",
"return",
"diff",
"/",
"repeat"
] |
Measure time cost of running a function
|
[
"Measure",
"time",
"cost",
"of",
"running",
"a",
"function"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/benchmark/python/sparse/dot.py#L110-L125
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.info
|
def info(self):
"""
Print information about the annotation file.
:return:
"""
for key, value in self.dataset['info'].items():
print('{}: {}'.format(key, value))
|
python
|
def info(self):
"""
Print information about the annotation file.
:return:
"""
for key, value in self.dataset['info'].items():
print('{}: {}'.format(key, value))
|
[
"def",
"info",
"(",
"self",
")",
":",
"for",
"key",
",",
"value",
"in",
"self",
".",
"dataset",
"[",
"'info'",
"]",
".",
"items",
"(",
")",
":",
"print",
"(",
"'{}: {}'",
".",
"format",
"(",
"key",
",",
"value",
")",
")"
] |
Print information about the annotation file.
:return:
|
[
"Print",
"information",
"about",
"the",
"annotation",
"file",
".",
":",
"return",
":"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L116-L122
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.getCatIds
|
def getCatIds(self, catNms=[], supNms=[], catIds=[]):
"""
filtering parameters. default skips that filter.
:param catNms (str array) : get cats for given cat names
:param supNms (str array) : get cats for given supercategory names
:param catIds (int array) : get cats for given cat ids
:return: ids (int array) : integer array of cat ids
"""
catNms = catNms if type(catNms) == list else [catNms]
supNms = supNms if type(supNms) == list else [supNms]
catIds = catIds if type(catIds) == list else [catIds]
if len(catNms) == len(supNms) == len(catIds) == 0:
cats = self.dataset['categories']
else:
cats = self.dataset['categories']
cats = cats if len(catNms) == 0 else [cat for cat in cats if cat['name'] in catNms]
cats = cats if len(supNms) == 0 else [cat for cat in cats if cat['supercategory'] in supNms]
cats = cats if len(catIds) == 0 else [cat for cat in cats if cat['id'] in catIds]
ids = [cat['id'] for cat in cats]
return ids
|
python
|
def getCatIds(self, catNms=[], supNms=[], catIds=[]):
"""
filtering parameters. default skips that filter.
:param catNms (str array) : get cats for given cat names
:param supNms (str array) : get cats for given supercategory names
:param catIds (int array) : get cats for given cat ids
:return: ids (int array) : integer array of cat ids
"""
catNms = catNms if type(catNms) == list else [catNms]
supNms = supNms if type(supNms) == list else [supNms]
catIds = catIds if type(catIds) == list else [catIds]
if len(catNms) == len(supNms) == len(catIds) == 0:
cats = self.dataset['categories']
else:
cats = self.dataset['categories']
cats = cats if len(catNms) == 0 else [cat for cat in cats if cat['name'] in catNms]
cats = cats if len(supNms) == 0 else [cat for cat in cats if cat['supercategory'] in supNms]
cats = cats if len(catIds) == 0 else [cat for cat in cats if cat['id'] in catIds]
ids = [cat['id'] for cat in cats]
return ids
|
[
"def",
"getCatIds",
"(",
"self",
",",
"catNms",
"=",
"[",
"]",
",",
"supNms",
"=",
"[",
"]",
",",
"catIds",
"=",
"[",
"]",
")",
":",
"catNms",
"=",
"catNms",
"if",
"type",
"(",
"catNms",
")",
"==",
"list",
"else",
"[",
"catNms",
"]",
"supNms",
"=",
"supNms",
"if",
"type",
"(",
"supNms",
")",
"==",
"list",
"else",
"[",
"supNms",
"]",
"catIds",
"=",
"catIds",
"if",
"type",
"(",
"catIds",
")",
"==",
"list",
"else",
"[",
"catIds",
"]",
"if",
"len",
"(",
"catNms",
")",
"==",
"len",
"(",
"supNms",
")",
"==",
"len",
"(",
"catIds",
")",
"==",
"0",
":",
"cats",
"=",
"self",
".",
"dataset",
"[",
"'categories'",
"]",
"else",
":",
"cats",
"=",
"self",
".",
"dataset",
"[",
"'categories'",
"]",
"cats",
"=",
"cats",
"if",
"len",
"(",
"catNms",
")",
"==",
"0",
"else",
"[",
"cat",
"for",
"cat",
"in",
"cats",
"if",
"cat",
"[",
"'name'",
"]",
"in",
"catNms",
"]",
"cats",
"=",
"cats",
"if",
"len",
"(",
"supNms",
")",
"==",
"0",
"else",
"[",
"cat",
"for",
"cat",
"in",
"cats",
"if",
"cat",
"[",
"'supercategory'",
"]",
"in",
"supNms",
"]",
"cats",
"=",
"cats",
"if",
"len",
"(",
"catIds",
")",
"==",
"0",
"else",
"[",
"cat",
"for",
"cat",
"in",
"cats",
"if",
"cat",
"[",
"'id'",
"]",
"in",
"catIds",
"]",
"ids",
"=",
"[",
"cat",
"[",
"'id'",
"]",
"for",
"cat",
"in",
"cats",
"]",
"return",
"ids"
] |
filtering parameters. default skips that filter.
:param catNms (str array) : get cats for given cat names
:param supNms (str array) : get cats for given supercategory names
:param catIds (int array) : get cats for given cat ids
:return: ids (int array) : integer array of cat ids
|
[
"filtering",
"parameters",
".",
"default",
"skips",
"that",
"filter",
".",
":",
"param",
"catNms",
"(",
"str",
"array",
")",
":",
"get",
"cats",
"for",
"given",
"cat",
"names",
":",
"param",
"supNms",
"(",
"str",
"array",
")",
":",
"get",
"cats",
"for",
"given",
"supercategory",
"names",
":",
"param",
"catIds",
"(",
"int",
"array",
")",
":",
"get",
"cats",
"for",
"given",
"cat",
"ids",
":",
"return",
":",
"ids",
"(",
"int",
"array",
")",
":",
"integer",
"array",
"of",
"cat",
"ids"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L152-L172
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.loadAnns
|
def loadAnns(self, ids=[]):
"""
Load anns with the specified ids.
:param ids (int array) : integer ids specifying anns
:return: anns (object array) : loaded ann objects
"""
if type(ids) == list:
return [self.anns[id] for id in ids]
elif type(ids) == int:
return [self.anns[ids]]
|
python
|
def loadAnns(self, ids=[]):
"""
Load anns with the specified ids.
:param ids (int array) : integer ids specifying anns
:return: anns (object array) : loaded ann objects
"""
if type(ids) == list:
return [self.anns[id] for id in ids]
elif type(ids) == int:
return [self.anns[ids]]
|
[
"def",
"loadAnns",
"(",
"self",
",",
"ids",
"=",
"[",
"]",
")",
":",
"if",
"type",
"(",
"ids",
")",
"==",
"list",
":",
"return",
"[",
"self",
".",
"anns",
"[",
"id",
"]",
"for",
"id",
"in",
"ids",
"]",
"elif",
"type",
"(",
"ids",
")",
"==",
"int",
":",
"return",
"[",
"self",
".",
"anns",
"[",
"ids",
"]",
"]"
] |
Load anns with the specified ids.
:param ids (int array) : integer ids specifying anns
:return: anns (object array) : loaded ann objects
|
[
"Load",
"anns",
"with",
"the",
"specified",
"ids",
".",
":",
"param",
"ids",
"(",
"int",
"array",
")",
":",
"integer",
"ids",
"specifying",
"anns",
":",
"return",
":",
"anns",
"(",
"object",
"array",
")",
":",
"loaded",
"ann",
"objects"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L195-L204
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.loadCats
|
def loadCats(self, ids=[]):
"""
Load cats with the specified ids.
:param ids (int array) : integer ids specifying cats
:return: cats (object array) : loaded cat objects
"""
if type(ids) == list:
return [self.cats[id] for id in ids]
elif type(ids) == int:
return [self.cats[ids]]
|
python
|
def loadCats(self, ids=[]):
"""
Load cats with the specified ids.
:param ids (int array) : integer ids specifying cats
:return: cats (object array) : loaded cat objects
"""
if type(ids) == list:
return [self.cats[id] for id in ids]
elif type(ids) == int:
return [self.cats[ids]]
|
[
"def",
"loadCats",
"(",
"self",
",",
"ids",
"=",
"[",
"]",
")",
":",
"if",
"type",
"(",
"ids",
")",
"==",
"list",
":",
"return",
"[",
"self",
".",
"cats",
"[",
"id",
"]",
"for",
"id",
"in",
"ids",
"]",
"elif",
"type",
"(",
"ids",
")",
"==",
"int",
":",
"return",
"[",
"self",
".",
"cats",
"[",
"ids",
"]",
"]"
] |
Load cats with the specified ids.
:param ids (int array) : integer ids specifying cats
:return: cats (object array) : loaded cat objects
|
[
"Load",
"cats",
"with",
"the",
"specified",
"ids",
".",
":",
"param",
"ids",
"(",
"int",
"array",
")",
":",
"integer",
"ids",
"specifying",
"cats",
":",
"return",
":",
"cats",
"(",
"object",
"array",
")",
":",
"loaded",
"cat",
"objects"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L206-L215
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.loadImgs
|
def loadImgs(self, ids=[]):
"""
Load anns with the specified ids.
:param ids (int array) : integer ids specifying img
:return: imgs (object array) : loaded img objects
"""
if type(ids) == list:
return [self.imgs[id] for id in ids]
elif type(ids) == int:
return [self.imgs[ids]]
|
python
|
def loadImgs(self, ids=[]):
"""
Load anns with the specified ids.
:param ids (int array) : integer ids specifying img
:return: imgs (object array) : loaded img objects
"""
if type(ids) == list:
return [self.imgs[id] for id in ids]
elif type(ids) == int:
return [self.imgs[ids]]
|
[
"def",
"loadImgs",
"(",
"self",
",",
"ids",
"=",
"[",
"]",
")",
":",
"if",
"type",
"(",
"ids",
")",
"==",
"list",
":",
"return",
"[",
"self",
".",
"imgs",
"[",
"id",
"]",
"for",
"id",
"in",
"ids",
"]",
"elif",
"type",
"(",
"ids",
")",
"==",
"int",
":",
"return",
"[",
"self",
".",
"imgs",
"[",
"ids",
"]",
"]"
] |
Load anns with the specified ids.
:param ids (int array) : integer ids specifying img
:return: imgs (object array) : loaded img objects
|
[
"Load",
"anns",
"with",
"the",
"specified",
"ids",
".",
":",
"param",
"ids",
"(",
"int",
"array",
")",
":",
"integer",
"ids",
"specifying",
"img",
":",
"return",
":",
"imgs",
"(",
"object",
"array",
")",
":",
"loaded",
"img",
"objects"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L217-L226
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.showAnns
|
def showAnns(self, anns):
"""
Display the specified annotations.
:param anns (array of object): annotations to display
:return: None
"""
if len(anns) == 0:
return 0
if 'segmentation' in anns[0] or 'keypoints' in anns[0]:
datasetType = 'instances'
elif 'caption' in anns[0]:
datasetType = 'captions'
else:
raise Exception('datasetType not supported')
if datasetType == 'instances':
ax = plt.gca()
ax.set_autoscale_on(False)
polygons = []
color = []
for ann in anns:
c = (np.random.random((1, 3))*0.6+0.4).tolist()[0]
if 'segmentation' in ann:
if type(ann['segmentation']) == list:
# polygon
for seg in ann['segmentation']:
poly = np.array(seg).reshape((int(len(seg)/2), 2))
polygons.append(Polygon(poly))
color.append(c)
else:
# mask
raise NotImplementedError("maskUtils disabled!")
if 'keypoints' in ann and type(ann['keypoints']) == list:
# turn skeleton into zero-based index
sks = np.array(self.loadCats(ann['category_id'])[0]['skeleton'])-1
kp = np.array(ann['keypoints'])
x = kp[0::3]
y = kp[1::3]
v = kp[2::3]
for sk in sks:
if np.all(v[sk]>0):
plt.plot(x[sk],y[sk], linewidth=3, color=c)
plt.plot(x[v>0], y[v>0],'o',markersize=8, markerfacecolor=c, markeredgecolor='k',markeredgewidth=2)
plt.plot(x[v>1], y[v>1],'o',markersize=8, markerfacecolor=c, markeredgecolor=c, markeredgewidth=2)
p = PatchCollection(polygons, facecolor=color, linewidths=0, alpha=0.4)
ax.add_collection(p)
p = PatchCollection(polygons, facecolor='none', edgecolors=color, linewidths=2)
ax.add_collection(p)
elif datasetType == 'captions':
for ann in anns:
print(ann['caption'])
|
python
|
def showAnns(self, anns):
"""
Display the specified annotations.
:param anns (array of object): annotations to display
:return: None
"""
if len(anns) == 0:
return 0
if 'segmentation' in anns[0] or 'keypoints' in anns[0]:
datasetType = 'instances'
elif 'caption' in anns[0]:
datasetType = 'captions'
else:
raise Exception('datasetType not supported')
if datasetType == 'instances':
ax = plt.gca()
ax.set_autoscale_on(False)
polygons = []
color = []
for ann in anns:
c = (np.random.random((1, 3))*0.6+0.4).tolist()[0]
if 'segmentation' in ann:
if type(ann['segmentation']) == list:
# polygon
for seg in ann['segmentation']:
poly = np.array(seg).reshape((int(len(seg)/2), 2))
polygons.append(Polygon(poly))
color.append(c)
else:
# mask
raise NotImplementedError("maskUtils disabled!")
if 'keypoints' in ann and type(ann['keypoints']) == list:
# turn skeleton into zero-based index
sks = np.array(self.loadCats(ann['category_id'])[0]['skeleton'])-1
kp = np.array(ann['keypoints'])
x = kp[0::3]
y = kp[1::3]
v = kp[2::3]
for sk in sks:
if np.all(v[sk]>0):
plt.plot(x[sk],y[sk], linewidth=3, color=c)
plt.plot(x[v>0], y[v>0],'o',markersize=8, markerfacecolor=c, markeredgecolor='k',markeredgewidth=2)
plt.plot(x[v>1], y[v>1],'o',markersize=8, markerfacecolor=c, markeredgecolor=c, markeredgewidth=2)
p = PatchCollection(polygons, facecolor=color, linewidths=0, alpha=0.4)
ax.add_collection(p)
p = PatchCollection(polygons, facecolor='none', edgecolors=color, linewidths=2)
ax.add_collection(p)
elif datasetType == 'captions':
for ann in anns:
print(ann['caption'])
|
[
"def",
"showAnns",
"(",
"self",
",",
"anns",
")",
":",
"if",
"len",
"(",
"anns",
")",
"==",
"0",
":",
"return",
"0",
"if",
"'segmentation'",
"in",
"anns",
"[",
"0",
"]",
"or",
"'keypoints'",
"in",
"anns",
"[",
"0",
"]",
":",
"datasetType",
"=",
"'instances'",
"elif",
"'caption'",
"in",
"anns",
"[",
"0",
"]",
":",
"datasetType",
"=",
"'captions'",
"else",
":",
"raise",
"Exception",
"(",
"'datasetType not supported'",
")",
"if",
"datasetType",
"==",
"'instances'",
":",
"ax",
"=",
"plt",
".",
"gca",
"(",
")",
"ax",
".",
"set_autoscale_on",
"(",
"False",
")",
"polygons",
"=",
"[",
"]",
"color",
"=",
"[",
"]",
"for",
"ann",
"in",
"anns",
":",
"c",
"=",
"(",
"np",
".",
"random",
".",
"random",
"(",
"(",
"1",
",",
"3",
")",
")",
"*",
"0.6",
"+",
"0.4",
")",
".",
"tolist",
"(",
")",
"[",
"0",
"]",
"if",
"'segmentation'",
"in",
"ann",
":",
"if",
"type",
"(",
"ann",
"[",
"'segmentation'",
"]",
")",
"==",
"list",
":",
"# polygon",
"for",
"seg",
"in",
"ann",
"[",
"'segmentation'",
"]",
":",
"poly",
"=",
"np",
".",
"array",
"(",
"seg",
")",
".",
"reshape",
"(",
"(",
"int",
"(",
"len",
"(",
"seg",
")",
"/",
"2",
")",
",",
"2",
")",
")",
"polygons",
".",
"append",
"(",
"Polygon",
"(",
"poly",
")",
")",
"color",
".",
"append",
"(",
"c",
")",
"else",
":",
"# mask",
"raise",
"NotImplementedError",
"(",
"\"maskUtils disabled!\"",
")",
"if",
"'keypoints'",
"in",
"ann",
"and",
"type",
"(",
"ann",
"[",
"'keypoints'",
"]",
")",
"==",
"list",
":",
"# turn skeleton into zero-based index",
"sks",
"=",
"np",
".",
"array",
"(",
"self",
".",
"loadCats",
"(",
"ann",
"[",
"'category_id'",
"]",
")",
"[",
"0",
"]",
"[",
"'skeleton'",
"]",
")",
"-",
"1",
"kp",
"=",
"np",
".",
"array",
"(",
"ann",
"[",
"'keypoints'",
"]",
")",
"x",
"=",
"kp",
"[",
"0",
":",
":",
"3",
"]",
"y",
"=",
"kp",
"[",
"1",
":",
":",
"3",
"]",
"v",
"=",
"kp",
"[",
"2",
":",
":",
"3",
"]",
"for",
"sk",
"in",
"sks",
":",
"if",
"np",
".",
"all",
"(",
"v",
"[",
"sk",
"]",
">",
"0",
")",
":",
"plt",
".",
"plot",
"(",
"x",
"[",
"sk",
"]",
",",
"y",
"[",
"sk",
"]",
",",
"linewidth",
"=",
"3",
",",
"color",
"=",
"c",
")",
"plt",
".",
"plot",
"(",
"x",
"[",
"v",
">",
"0",
"]",
",",
"y",
"[",
"v",
">",
"0",
"]",
",",
"'o'",
",",
"markersize",
"=",
"8",
",",
"markerfacecolor",
"=",
"c",
",",
"markeredgecolor",
"=",
"'k'",
",",
"markeredgewidth",
"=",
"2",
")",
"plt",
".",
"plot",
"(",
"x",
"[",
"v",
">",
"1",
"]",
",",
"y",
"[",
"v",
">",
"1",
"]",
",",
"'o'",
",",
"markersize",
"=",
"8",
",",
"markerfacecolor",
"=",
"c",
",",
"markeredgecolor",
"=",
"c",
",",
"markeredgewidth",
"=",
"2",
")",
"p",
"=",
"PatchCollection",
"(",
"polygons",
",",
"facecolor",
"=",
"color",
",",
"linewidths",
"=",
"0",
",",
"alpha",
"=",
"0.4",
")",
"ax",
".",
"add_collection",
"(",
"p",
")",
"p",
"=",
"PatchCollection",
"(",
"polygons",
",",
"facecolor",
"=",
"'none'",
",",
"edgecolors",
"=",
"color",
",",
"linewidths",
"=",
"2",
")",
"ax",
".",
"add_collection",
"(",
"p",
")",
"elif",
"datasetType",
"==",
"'captions'",
":",
"for",
"ann",
"in",
"anns",
":",
"print",
"(",
"ann",
"[",
"'caption'",
"]",
")"
] |
Display the specified annotations.
:param anns (array of object): annotations to display
:return: None
|
[
"Display",
"the",
"specified",
"annotations",
".",
":",
"param",
"anns",
"(",
"array",
"of",
"object",
")",
":",
"annotations",
"to",
"display",
":",
"return",
":",
"None"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L228-L277
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.download
|
def download(self, tarDir = None, imgIds = [] ):
'''
Download COCO images from mscoco.org server.
:param tarDir (str): COCO results directory name
imgIds (list): images to be downloaded
:return:
'''
if tarDir is None:
print('Please specify target directory')
return -1
if len(imgIds) == 0:
imgs = self.imgs.values()
else:
imgs = self.loadImgs(imgIds)
N = len(imgs)
if not os.path.exists(tarDir):
os.makedirs(tarDir)
for i, img in enumerate(imgs):
tic = time.time()
fname = os.path.join(tarDir, img['file_name'])
if not os.path.exists(fname):
urlretrieve(img['coco_url'], fname)
print('downloaded {}/{} images (t={:0.1f}s)'.format(i, N, time.time()- tic))
|
python
|
def download(self, tarDir = None, imgIds = [] ):
'''
Download COCO images from mscoco.org server.
:param tarDir (str): COCO results directory name
imgIds (list): images to be downloaded
:return:
'''
if tarDir is None:
print('Please specify target directory')
return -1
if len(imgIds) == 0:
imgs = self.imgs.values()
else:
imgs = self.loadImgs(imgIds)
N = len(imgs)
if not os.path.exists(tarDir):
os.makedirs(tarDir)
for i, img in enumerate(imgs):
tic = time.time()
fname = os.path.join(tarDir, img['file_name'])
if not os.path.exists(fname):
urlretrieve(img['coco_url'], fname)
print('downloaded {}/{} images (t={:0.1f}s)'.format(i, N, time.time()- tic))
|
[
"def",
"download",
"(",
"self",
",",
"tarDir",
"=",
"None",
",",
"imgIds",
"=",
"[",
"]",
")",
":",
"if",
"tarDir",
"is",
"None",
":",
"print",
"(",
"'Please specify target directory'",
")",
"return",
"-",
"1",
"if",
"len",
"(",
"imgIds",
")",
"==",
"0",
":",
"imgs",
"=",
"self",
".",
"imgs",
".",
"values",
"(",
")",
"else",
":",
"imgs",
"=",
"self",
".",
"loadImgs",
"(",
"imgIds",
")",
"N",
"=",
"len",
"(",
"imgs",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"tarDir",
")",
":",
"os",
".",
"makedirs",
"(",
"tarDir",
")",
"for",
"i",
",",
"img",
"in",
"enumerate",
"(",
"imgs",
")",
":",
"tic",
"=",
"time",
".",
"time",
"(",
")",
"fname",
"=",
"os",
".",
"path",
".",
"join",
"(",
"tarDir",
",",
"img",
"[",
"'file_name'",
"]",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"fname",
")",
":",
"urlretrieve",
"(",
"img",
"[",
"'coco_url'",
"]",
",",
"fname",
")",
"print",
"(",
"'downloaded {}/{} images (t={:0.1f}s)'",
".",
"format",
"(",
"i",
",",
"N",
",",
"time",
".",
"time",
"(",
")",
"-",
"tic",
")",
")"
] |
Download COCO images from mscoco.org server.
:param tarDir (str): COCO results directory name
imgIds (list): images to be downloaded
:return:
|
[
"Download",
"COCO",
"images",
"from",
"mscoco",
".",
"org",
"server",
".",
":",
"param",
"tarDir",
"(",
"str",
")",
":",
"COCO",
"results",
"directory",
"name",
"imgIds",
"(",
"list",
")",
":",
"images",
"to",
"be",
"downloaded",
":",
"return",
":"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L342-L364
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.loadNumpyAnnotations
|
def loadNumpyAnnotations(self, data):
"""
Convert result data from a numpy array [Nx7] where each row contains {imageID,x1,y1,w,h,score,class}
:param data (numpy.ndarray)
:return: annotations (python nested list)
"""
print('Converting ndarray to lists...')
assert(type(data) == np.ndarray)
print(data.shape)
assert(data.shape[1] == 7)
N = data.shape[0]
ann = []
for i in range(N):
if i % 1000000 == 0:
print('{}/{}'.format(i,N))
ann += [{
'image_id' : int(data[i, 0]),
'bbox' : [ data[i, 1], data[i, 2], data[i, 3], data[i, 4] ],
'score' : data[i, 5],
'category_id': int(data[i, 6]),
}]
return ann
|
python
|
def loadNumpyAnnotations(self, data):
"""
Convert result data from a numpy array [Nx7] where each row contains {imageID,x1,y1,w,h,score,class}
:param data (numpy.ndarray)
:return: annotations (python nested list)
"""
print('Converting ndarray to lists...')
assert(type(data) == np.ndarray)
print(data.shape)
assert(data.shape[1] == 7)
N = data.shape[0]
ann = []
for i in range(N):
if i % 1000000 == 0:
print('{}/{}'.format(i,N))
ann += [{
'image_id' : int(data[i, 0]),
'bbox' : [ data[i, 1], data[i, 2], data[i, 3], data[i, 4] ],
'score' : data[i, 5],
'category_id': int(data[i, 6]),
}]
return ann
|
[
"def",
"loadNumpyAnnotations",
"(",
"self",
",",
"data",
")",
":",
"print",
"(",
"'Converting ndarray to lists...'",
")",
"assert",
"(",
"type",
"(",
"data",
")",
"==",
"np",
".",
"ndarray",
")",
"print",
"(",
"data",
".",
"shape",
")",
"assert",
"(",
"data",
".",
"shape",
"[",
"1",
"]",
"==",
"7",
")",
"N",
"=",
"data",
".",
"shape",
"[",
"0",
"]",
"ann",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"N",
")",
":",
"if",
"i",
"%",
"1000000",
"==",
"0",
":",
"print",
"(",
"'{}/{}'",
".",
"format",
"(",
"i",
",",
"N",
")",
")",
"ann",
"+=",
"[",
"{",
"'image_id'",
":",
"int",
"(",
"data",
"[",
"i",
",",
"0",
"]",
")",
",",
"'bbox'",
":",
"[",
"data",
"[",
"i",
",",
"1",
"]",
",",
"data",
"[",
"i",
",",
"2",
"]",
",",
"data",
"[",
"i",
",",
"3",
"]",
",",
"data",
"[",
"i",
",",
"4",
"]",
"]",
",",
"'score'",
":",
"data",
"[",
"i",
",",
"5",
"]",
",",
"'category_id'",
":",
"int",
"(",
"data",
"[",
"i",
",",
"6",
"]",
")",
",",
"}",
"]",
"return",
"ann"
] |
Convert result data from a numpy array [Nx7] where each row contains {imageID,x1,y1,w,h,score,class}
:param data (numpy.ndarray)
:return: annotations (python nested list)
|
[
"Convert",
"result",
"data",
"from",
"a",
"numpy",
"array",
"[",
"Nx7",
"]",
"where",
"each",
"row",
"contains",
"{",
"imageID",
"x1",
"y1",
"w",
"h",
"score",
"class",
"}",
":",
"param",
"data",
"(",
"numpy",
".",
"ndarray",
")",
":",
"return",
":",
"annotations",
"(",
"python",
"nested",
"list",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L366-L387
|
train
|
apache/incubator-mxnet
|
example/ssd/dataset/pycocotools/coco.py
|
COCO.annToRLE
|
def annToRLE(self, ann):
"""
Convert annotation which can be polygons, uncompressed RLE to RLE.
:return: binary mask (numpy 2D array)
"""
t = self.imgs[ann['image_id']]
h, w = t['height'], t['width']
segm = ann['segmentation']
if type(segm) == list:
# polygon -- a single object might consist of multiple parts
# we merge all parts into one mask rle code
# rles = maskUtils.frPyObjects(segm, h, w)
# rle = maskUtils.merge(rles)
raise NotImplementedError("maskUtils disabled!")
elif type(segm['counts']) == list:
# uncompressed RLE
# rle = maskUtils.frPyObjects(segm, h, w)
raise NotImplementedError("maskUtils disabled!")
else:
# rle
rle = ann['segmentation']
return rle
|
python
|
def annToRLE(self, ann):
"""
Convert annotation which can be polygons, uncompressed RLE to RLE.
:return: binary mask (numpy 2D array)
"""
t = self.imgs[ann['image_id']]
h, w = t['height'], t['width']
segm = ann['segmentation']
if type(segm) == list:
# polygon -- a single object might consist of multiple parts
# we merge all parts into one mask rle code
# rles = maskUtils.frPyObjects(segm, h, w)
# rle = maskUtils.merge(rles)
raise NotImplementedError("maskUtils disabled!")
elif type(segm['counts']) == list:
# uncompressed RLE
# rle = maskUtils.frPyObjects(segm, h, w)
raise NotImplementedError("maskUtils disabled!")
else:
# rle
rle = ann['segmentation']
return rle
|
[
"def",
"annToRLE",
"(",
"self",
",",
"ann",
")",
":",
"t",
"=",
"self",
".",
"imgs",
"[",
"ann",
"[",
"'image_id'",
"]",
"]",
"h",
",",
"w",
"=",
"t",
"[",
"'height'",
"]",
",",
"t",
"[",
"'width'",
"]",
"segm",
"=",
"ann",
"[",
"'segmentation'",
"]",
"if",
"type",
"(",
"segm",
")",
"==",
"list",
":",
"# polygon -- a single object might consist of multiple parts",
"# we merge all parts into one mask rle code",
"# rles = maskUtils.frPyObjects(segm, h, w)",
"# rle = maskUtils.merge(rles)",
"raise",
"NotImplementedError",
"(",
"\"maskUtils disabled!\"",
")",
"elif",
"type",
"(",
"segm",
"[",
"'counts'",
"]",
")",
"==",
"list",
":",
"# uncompressed RLE",
"# rle = maskUtils.frPyObjects(segm, h, w)",
"raise",
"NotImplementedError",
"(",
"\"maskUtils disabled!\"",
")",
"else",
":",
"# rle",
"rle",
"=",
"ann",
"[",
"'segmentation'",
"]",
"return",
"rle"
] |
Convert annotation which can be polygons, uncompressed RLE to RLE.
:return: binary mask (numpy 2D array)
|
[
"Convert",
"annotation",
"which",
"can",
"be",
"polygons",
"uncompressed",
"RLE",
"to",
"RLE",
".",
":",
"return",
":",
"binary",
"mask",
"(",
"numpy",
"2D",
"array",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/pycocotools/coco.py#L389-L410
|
train
|
apache/incubator-mxnet
|
example/cnn_chinese_text_classification/text_cnn.py
|
save_model
|
def save_model():
"""Save cnn model
Returns
----------
callback: A callback function that can be passed as epoch_end_callback to fit
"""
if not os.path.exists("checkpoint"):
os.mkdir("checkpoint")
return mx.callback.do_checkpoint("checkpoint/checkpoint", args.save_period)
|
python
|
def save_model():
"""Save cnn model
Returns
----------
callback: A callback function that can be passed as epoch_end_callback to fit
"""
if not os.path.exists("checkpoint"):
os.mkdir("checkpoint")
return mx.callback.do_checkpoint("checkpoint/checkpoint", args.save_period)
|
[
"def",
"save_model",
"(",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"\"checkpoint\"",
")",
":",
"os",
".",
"mkdir",
"(",
"\"checkpoint\"",
")",
"return",
"mx",
".",
"callback",
".",
"do_checkpoint",
"(",
"\"checkpoint/checkpoint\"",
",",
"args",
".",
"save_period",
")"
] |
Save cnn model
Returns
----------
callback: A callback function that can be passed as epoch_end_callback to fit
|
[
"Save",
"cnn",
"model",
"Returns",
"----------",
"callback",
":",
"A",
"callback",
"function",
"that",
"can",
"be",
"passed",
"as",
"epoch_end_callback",
"to",
"fit"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/cnn_chinese_text_classification/text_cnn.py#L67-L75
|
train
|
apache/incubator-mxnet
|
example/cnn_chinese_text_classification/text_cnn.py
|
highway
|
def highway(data):
"""Construct highway net
Parameters
----------
data:
Returns
----------
Highway Networks
"""
_data = data
high_weight = mx.sym.Variable('high_weight')
high_bias = mx.sym.Variable('high_bias')
high_fc = mx.sym.FullyConnected(data=data, weight=high_weight, bias=high_bias, num_hidden=300, name='high_fc')
high_relu = mx.sym.Activation(high_fc, act_type='relu')
high_trans_weight = mx.sym.Variable('high_trans_weight')
high_trans_bias = mx.sym.Variable('high_trans_bias')
high_trans_fc = mx.sym.FullyConnected(data=_data, weight=high_trans_weight, bias=high_trans_bias, num_hidden=300,
name='high_trans_sigmoid')
high_trans_sigmoid = mx.sym.Activation(high_trans_fc, act_type='sigmoid')
return high_relu * high_trans_sigmoid + _data * (1 - high_trans_sigmoid)
|
python
|
def highway(data):
"""Construct highway net
Parameters
----------
data:
Returns
----------
Highway Networks
"""
_data = data
high_weight = mx.sym.Variable('high_weight')
high_bias = mx.sym.Variable('high_bias')
high_fc = mx.sym.FullyConnected(data=data, weight=high_weight, bias=high_bias, num_hidden=300, name='high_fc')
high_relu = mx.sym.Activation(high_fc, act_type='relu')
high_trans_weight = mx.sym.Variable('high_trans_weight')
high_trans_bias = mx.sym.Variable('high_trans_bias')
high_trans_fc = mx.sym.FullyConnected(data=_data, weight=high_trans_weight, bias=high_trans_bias, num_hidden=300,
name='high_trans_sigmoid')
high_trans_sigmoid = mx.sym.Activation(high_trans_fc, act_type='sigmoid')
return high_relu * high_trans_sigmoid + _data * (1 - high_trans_sigmoid)
|
[
"def",
"highway",
"(",
"data",
")",
":",
"_data",
"=",
"data",
"high_weight",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'high_weight'",
")",
"high_bias",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'high_bias'",
")",
"high_fc",
"=",
"mx",
".",
"sym",
".",
"FullyConnected",
"(",
"data",
"=",
"data",
",",
"weight",
"=",
"high_weight",
",",
"bias",
"=",
"high_bias",
",",
"num_hidden",
"=",
"300",
",",
"name",
"=",
"'high_fc'",
")",
"high_relu",
"=",
"mx",
".",
"sym",
".",
"Activation",
"(",
"high_fc",
",",
"act_type",
"=",
"'relu'",
")",
"high_trans_weight",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'high_trans_weight'",
")",
"high_trans_bias",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'high_trans_bias'",
")",
"high_trans_fc",
"=",
"mx",
".",
"sym",
".",
"FullyConnected",
"(",
"data",
"=",
"_data",
",",
"weight",
"=",
"high_trans_weight",
",",
"bias",
"=",
"high_trans_bias",
",",
"num_hidden",
"=",
"300",
",",
"name",
"=",
"'high_trans_sigmoid'",
")",
"high_trans_sigmoid",
"=",
"mx",
".",
"sym",
".",
"Activation",
"(",
"high_trans_fc",
",",
"act_type",
"=",
"'sigmoid'",
")",
"return",
"high_relu",
"*",
"high_trans_sigmoid",
"+",
"_data",
"*",
"(",
"1",
"-",
"high_trans_sigmoid",
")"
] |
Construct highway net
Parameters
----------
data:
Returns
----------
Highway Networks
|
[
"Construct",
"highway",
"net",
"Parameters",
"----------",
"data",
":",
"Returns",
"----------",
"Highway",
"Networks"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/cnn_chinese_text_classification/text_cnn.py#L78-L99
|
train
|
apache/incubator-mxnet
|
example/cnn_chinese_text_classification/text_cnn.py
|
train
|
def train(symbol_data, train_iterator, valid_iterator, data_column_names, target_names):
"""Train cnn model
Parameters
----------
symbol_data: symbol
train_iterator: DataIter
Train DataIter
valid_iterator: DataIter
Valid DataIter
data_column_names: list of str
Defaults to ('data') for a typical model used in image classification
target_names: list of str
Defaults to ('softmax_label') for a typical model used in image classification
"""
devs = mx.cpu() # default setting
if args.gpus is not None:
for i in args.gpus.split(','):
mx.gpu(int(i))
devs = mx.gpu()
module = mx.mod.Module(symbol_data, data_names=data_column_names, label_names=target_names, context=devs)
init_params = {
'vocab_embed_weight': {'uniform': 0.1},
'convolution0_weight': {'uniform': 0.1}, 'convolution0_bias': {'costant': 0},
'convolution1_weight': {'uniform': 0.1}, 'convolution1_bias': {'costant': 0},
'convolution2_weight': {'uniform': 0.1}, 'convolution2_bias': {'costant': 0},
'high_weight': {'uniform': 0.1}, 'high_bias': {'costant': 0},
'high_trans_weight': {'uniform': 0.1}, 'high_trans_bias': {'costant': -2},
'cls_weight': {'uniform': 0.1}, 'cls_bias': {'costant': 0},
}
# custom init_params
module.bind(data_shapes=train_iterator.provide_data, label_shapes=train_iterator.provide_label)
module.init_params(CustomInit(init_params))
lr_sch = mx.lr_scheduler.FactorScheduler(step=25000, factor=0.999)
module.init_optimizer(
optimizer='rmsprop', optimizer_params={'learning_rate': 0.0005, 'lr_scheduler': lr_sch})
def norm_stat(d):
return mx.nd.norm(d) / np.sqrt(d.size)
mon = mx.mon.Monitor(25000, norm_stat)
module.fit(train_data=train_iterator,
eval_data=valid_iterator,
eval_metric='acc',
kvstore=args.kv_store,
monitor=mon,
num_epoch=args.num_epochs,
batch_end_callback=mx.callback.Speedometer(args.batch_size, args.disp_batches),
epoch_end_callback=save_model())
|
python
|
def train(symbol_data, train_iterator, valid_iterator, data_column_names, target_names):
"""Train cnn model
Parameters
----------
symbol_data: symbol
train_iterator: DataIter
Train DataIter
valid_iterator: DataIter
Valid DataIter
data_column_names: list of str
Defaults to ('data') for a typical model used in image classification
target_names: list of str
Defaults to ('softmax_label') for a typical model used in image classification
"""
devs = mx.cpu() # default setting
if args.gpus is not None:
for i in args.gpus.split(','):
mx.gpu(int(i))
devs = mx.gpu()
module = mx.mod.Module(symbol_data, data_names=data_column_names, label_names=target_names, context=devs)
init_params = {
'vocab_embed_weight': {'uniform': 0.1},
'convolution0_weight': {'uniform': 0.1}, 'convolution0_bias': {'costant': 0},
'convolution1_weight': {'uniform': 0.1}, 'convolution1_bias': {'costant': 0},
'convolution2_weight': {'uniform': 0.1}, 'convolution2_bias': {'costant': 0},
'high_weight': {'uniform': 0.1}, 'high_bias': {'costant': 0},
'high_trans_weight': {'uniform': 0.1}, 'high_trans_bias': {'costant': -2},
'cls_weight': {'uniform': 0.1}, 'cls_bias': {'costant': 0},
}
# custom init_params
module.bind(data_shapes=train_iterator.provide_data, label_shapes=train_iterator.provide_label)
module.init_params(CustomInit(init_params))
lr_sch = mx.lr_scheduler.FactorScheduler(step=25000, factor=0.999)
module.init_optimizer(
optimizer='rmsprop', optimizer_params={'learning_rate': 0.0005, 'lr_scheduler': lr_sch})
def norm_stat(d):
return mx.nd.norm(d) / np.sqrt(d.size)
mon = mx.mon.Monitor(25000, norm_stat)
module.fit(train_data=train_iterator,
eval_data=valid_iterator,
eval_metric='acc',
kvstore=args.kv_store,
monitor=mon,
num_epoch=args.num_epochs,
batch_end_callback=mx.callback.Speedometer(args.batch_size, args.disp_batches),
epoch_end_callback=save_model())
|
[
"def",
"train",
"(",
"symbol_data",
",",
"train_iterator",
",",
"valid_iterator",
",",
"data_column_names",
",",
"target_names",
")",
":",
"devs",
"=",
"mx",
".",
"cpu",
"(",
")",
"# default setting",
"if",
"args",
".",
"gpus",
"is",
"not",
"None",
":",
"for",
"i",
"in",
"args",
".",
"gpus",
".",
"split",
"(",
"','",
")",
":",
"mx",
".",
"gpu",
"(",
"int",
"(",
"i",
")",
")",
"devs",
"=",
"mx",
".",
"gpu",
"(",
")",
"module",
"=",
"mx",
".",
"mod",
".",
"Module",
"(",
"symbol_data",
",",
"data_names",
"=",
"data_column_names",
",",
"label_names",
"=",
"target_names",
",",
"context",
"=",
"devs",
")",
"init_params",
"=",
"{",
"'vocab_embed_weight'",
":",
"{",
"'uniform'",
":",
"0.1",
"}",
",",
"'convolution0_weight'",
":",
"{",
"'uniform'",
":",
"0.1",
"}",
",",
"'convolution0_bias'",
":",
"{",
"'costant'",
":",
"0",
"}",
",",
"'convolution1_weight'",
":",
"{",
"'uniform'",
":",
"0.1",
"}",
",",
"'convolution1_bias'",
":",
"{",
"'costant'",
":",
"0",
"}",
",",
"'convolution2_weight'",
":",
"{",
"'uniform'",
":",
"0.1",
"}",
",",
"'convolution2_bias'",
":",
"{",
"'costant'",
":",
"0",
"}",
",",
"'high_weight'",
":",
"{",
"'uniform'",
":",
"0.1",
"}",
",",
"'high_bias'",
":",
"{",
"'costant'",
":",
"0",
"}",
",",
"'high_trans_weight'",
":",
"{",
"'uniform'",
":",
"0.1",
"}",
",",
"'high_trans_bias'",
":",
"{",
"'costant'",
":",
"-",
"2",
"}",
",",
"'cls_weight'",
":",
"{",
"'uniform'",
":",
"0.1",
"}",
",",
"'cls_bias'",
":",
"{",
"'costant'",
":",
"0",
"}",
",",
"}",
"# custom init_params",
"module",
".",
"bind",
"(",
"data_shapes",
"=",
"train_iterator",
".",
"provide_data",
",",
"label_shapes",
"=",
"train_iterator",
".",
"provide_label",
")",
"module",
".",
"init_params",
"(",
"CustomInit",
"(",
"init_params",
")",
")",
"lr_sch",
"=",
"mx",
".",
"lr_scheduler",
".",
"FactorScheduler",
"(",
"step",
"=",
"25000",
",",
"factor",
"=",
"0.999",
")",
"module",
".",
"init_optimizer",
"(",
"optimizer",
"=",
"'rmsprop'",
",",
"optimizer_params",
"=",
"{",
"'learning_rate'",
":",
"0.0005",
",",
"'lr_scheduler'",
":",
"lr_sch",
"}",
")",
"def",
"norm_stat",
"(",
"d",
")",
":",
"return",
"mx",
".",
"nd",
".",
"norm",
"(",
"d",
")",
"/",
"np",
".",
"sqrt",
"(",
"d",
".",
"size",
")",
"mon",
"=",
"mx",
".",
"mon",
".",
"Monitor",
"(",
"25000",
",",
"norm_stat",
")",
"module",
".",
"fit",
"(",
"train_data",
"=",
"train_iterator",
",",
"eval_data",
"=",
"valid_iterator",
",",
"eval_metric",
"=",
"'acc'",
",",
"kvstore",
"=",
"args",
".",
"kv_store",
",",
"monitor",
"=",
"mon",
",",
"num_epoch",
"=",
"args",
".",
"num_epochs",
",",
"batch_end_callback",
"=",
"mx",
".",
"callback",
".",
"Speedometer",
"(",
"args",
".",
"batch_size",
",",
"args",
".",
"disp_batches",
")",
",",
"epoch_end_callback",
"=",
"save_model",
"(",
")",
")"
] |
Train cnn model
Parameters
----------
symbol_data: symbol
train_iterator: DataIter
Train DataIter
valid_iterator: DataIter
Valid DataIter
data_column_names: list of str
Defaults to ('data') for a typical model used in image classification
target_names: list of str
Defaults to ('softmax_label') for a typical model used in image classification
|
[
"Train",
"cnn",
"model",
"Parameters",
"----------",
"symbol_data",
":",
"symbol",
"train_iterator",
":",
"DataIter",
"Train",
"DataIter",
"valid_iterator",
":",
"DataIter",
"Valid",
"DataIter",
"data_column_names",
":",
"list",
"of",
"str",
"Defaults",
"to",
"(",
"data",
")",
"for",
"a",
"typical",
"model",
"used",
"in",
"image",
"classification",
"target_names",
":",
"list",
"of",
"str",
"Defaults",
"to",
"(",
"softmax_label",
")",
"for",
"a",
"typical",
"model",
"used",
"in",
"image",
"classification"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/cnn_chinese_text_classification/text_cnn.py#L232-L280
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
default_batchify_fn
|
def default_batchify_fn(data):
"""Collate data into batch."""
if isinstance(data[0], nd.NDArray):
return nd.stack(*data)
elif isinstance(data[0], tuple):
data = zip(*data)
return [default_batchify_fn(i) for i in data]
else:
data = np.asarray(data)
return nd.array(data, dtype=data.dtype)
|
python
|
def default_batchify_fn(data):
"""Collate data into batch."""
if isinstance(data[0], nd.NDArray):
return nd.stack(*data)
elif isinstance(data[0], tuple):
data = zip(*data)
return [default_batchify_fn(i) for i in data]
else:
data = np.asarray(data)
return nd.array(data, dtype=data.dtype)
|
[
"def",
"default_batchify_fn",
"(",
"data",
")",
":",
"if",
"isinstance",
"(",
"data",
"[",
"0",
"]",
",",
"nd",
".",
"NDArray",
")",
":",
"return",
"nd",
".",
"stack",
"(",
"*",
"data",
")",
"elif",
"isinstance",
"(",
"data",
"[",
"0",
"]",
",",
"tuple",
")",
":",
"data",
"=",
"zip",
"(",
"*",
"data",
")",
"return",
"[",
"default_batchify_fn",
"(",
"i",
")",
"for",
"i",
"in",
"data",
"]",
"else",
":",
"data",
"=",
"np",
".",
"asarray",
"(",
"data",
")",
"return",
"nd",
".",
"array",
"(",
"data",
",",
"dtype",
"=",
"data",
".",
"dtype",
")"
] |
Collate data into batch.
|
[
"Collate",
"data",
"into",
"batch",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L127-L136
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
default_mp_batchify_fn
|
def default_mp_batchify_fn(data):
"""Collate data into batch. Use shared memory for stacking."""
if isinstance(data[0], nd.NDArray):
out = nd.empty((len(data),) + data[0].shape, dtype=data[0].dtype,
ctx=context.Context('cpu_shared', 0))
return nd.stack(*data, out=out)
elif isinstance(data[0], tuple):
data = zip(*data)
return [default_mp_batchify_fn(i) for i in data]
else:
data = np.asarray(data)
return nd.array(data, dtype=data.dtype,
ctx=context.Context('cpu_shared', 0))
|
python
|
def default_mp_batchify_fn(data):
"""Collate data into batch. Use shared memory for stacking."""
if isinstance(data[0], nd.NDArray):
out = nd.empty((len(data),) + data[0].shape, dtype=data[0].dtype,
ctx=context.Context('cpu_shared', 0))
return nd.stack(*data, out=out)
elif isinstance(data[0], tuple):
data = zip(*data)
return [default_mp_batchify_fn(i) for i in data]
else:
data = np.asarray(data)
return nd.array(data, dtype=data.dtype,
ctx=context.Context('cpu_shared', 0))
|
[
"def",
"default_mp_batchify_fn",
"(",
"data",
")",
":",
"if",
"isinstance",
"(",
"data",
"[",
"0",
"]",
",",
"nd",
".",
"NDArray",
")",
":",
"out",
"=",
"nd",
".",
"empty",
"(",
"(",
"len",
"(",
"data",
")",
",",
")",
"+",
"data",
"[",
"0",
"]",
".",
"shape",
",",
"dtype",
"=",
"data",
"[",
"0",
"]",
".",
"dtype",
",",
"ctx",
"=",
"context",
".",
"Context",
"(",
"'cpu_shared'",
",",
"0",
")",
")",
"return",
"nd",
".",
"stack",
"(",
"*",
"data",
",",
"out",
"=",
"out",
")",
"elif",
"isinstance",
"(",
"data",
"[",
"0",
"]",
",",
"tuple",
")",
":",
"data",
"=",
"zip",
"(",
"*",
"data",
")",
"return",
"[",
"default_mp_batchify_fn",
"(",
"i",
")",
"for",
"i",
"in",
"data",
"]",
"else",
":",
"data",
"=",
"np",
".",
"asarray",
"(",
"data",
")",
"return",
"nd",
".",
"array",
"(",
"data",
",",
"dtype",
"=",
"data",
".",
"dtype",
",",
"ctx",
"=",
"context",
".",
"Context",
"(",
"'cpu_shared'",
",",
"0",
")",
")"
] |
Collate data into batch. Use shared memory for stacking.
|
[
"Collate",
"data",
"into",
"batch",
".",
"Use",
"shared",
"memory",
"for",
"stacking",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L139-L151
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
_as_in_context
|
def _as_in_context(data, ctx):
"""Move data into new context."""
if isinstance(data, nd.NDArray):
return data.as_in_context(ctx)
elif isinstance(data, (list, tuple)):
return [_as_in_context(d, ctx) for d in data]
return data
|
python
|
def _as_in_context(data, ctx):
"""Move data into new context."""
if isinstance(data, nd.NDArray):
return data.as_in_context(ctx)
elif isinstance(data, (list, tuple)):
return [_as_in_context(d, ctx) for d in data]
return data
|
[
"def",
"_as_in_context",
"(",
"data",
",",
"ctx",
")",
":",
"if",
"isinstance",
"(",
"data",
",",
"nd",
".",
"NDArray",
")",
":",
"return",
"data",
".",
"as_in_context",
"(",
"ctx",
")",
"elif",
"isinstance",
"(",
"data",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"return",
"[",
"_as_in_context",
"(",
"d",
",",
"ctx",
")",
"for",
"d",
"in",
"data",
"]",
"return",
"data"
] |
Move data into new context.
|
[
"Move",
"data",
"into",
"new",
"context",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L154-L160
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
worker_loop_v1
|
def worker_loop_v1(dataset, key_queue, data_queue, batchify_fn):
"""Worker loop for multiprocessing DataLoader."""
while True:
idx, samples = key_queue.get()
if idx is None:
break
batch = batchify_fn([dataset[i] for i in samples])
data_queue.put((idx, batch))
|
python
|
def worker_loop_v1(dataset, key_queue, data_queue, batchify_fn):
"""Worker loop for multiprocessing DataLoader."""
while True:
idx, samples = key_queue.get()
if idx is None:
break
batch = batchify_fn([dataset[i] for i in samples])
data_queue.put((idx, batch))
|
[
"def",
"worker_loop_v1",
"(",
"dataset",
",",
"key_queue",
",",
"data_queue",
",",
"batchify_fn",
")",
":",
"while",
"True",
":",
"idx",
",",
"samples",
"=",
"key_queue",
".",
"get",
"(",
")",
"if",
"idx",
"is",
"None",
":",
"break",
"batch",
"=",
"batchify_fn",
"(",
"[",
"dataset",
"[",
"i",
"]",
"for",
"i",
"in",
"samples",
"]",
")",
"data_queue",
".",
"put",
"(",
"(",
"idx",
",",
"batch",
")",
")"
] |
Worker loop for multiprocessing DataLoader.
|
[
"Worker",
"loop",
"for",
"multiprocessing",
"DataLoader",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L163-L170
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
fetcher_loop_v1
|
def fetcher_loop_v1(data_queue, data_buffer, pin_memory=False,
pin_device_id=0, data_buffer_lock=None):
"""Fetcher loop for fetching data from queue and put in reorder dict."""
while True:
idx, batch = data_queue.get()
if idx is None:
break
if pin_memory:
batch = _as_in_context(batch, context.cpu_pinned(pin_device_id))
else:
batch = _as_in_context(batch, context.cpu())
if data_buffer_lock is not None:
with data_buffer_lock:
data_buffer[idx] = batch
else:
data_buffer[idx] = batch
|
python
|
def fetcher_loop_v1(data_queue, data_buffer, pin_memory=False,
pin_device_id=0, data_buffer_lock=None):
"""Fetcher loop for fetching data from queue and put in reorder dict."""
while True:
idx, batch = data_queue.get()
if idx is None:
break
if pin_memory:
batch = _as_in_context(batch, context.cpu_pinned(pin_device_id))
else:
batch = _as_in_context(batch, context.cpu())
if data_buffer_lock is not None:
with data_buffer_lock:
data_buffer[idx] = batch
else:
data_buffer[idx] = batch
|
[
"def",
"fetcher_loop_v1",
"(",
"data_queue",
",",
"data_buffer",
",",
"pin_memory",
"=",
"False",
",",
"pin_device_id",
"=",
"0",
",",
"data_buffer_lock",
"=",
"None",
")",
":",
"while",
"True",
":",
"idx",
",",
"batch",
"=",
"data_queue",
".",
"get",
"(",
")",
"if",
"idx",
"is",
"None",
":",
"break",
"if",
"pin_memory",
":",
"batch",
"=",
"_as_in_context",
"(",
"batch",
",",
"context",
".",
"cpu_pinned",
"(",
"pin_device_id",
")",
")",
"else",
":",
"batch",
"=",
"_as_in_context",
"(",
"batch",
",",
"context",
".",
"cpu",
"(",
")",
")",
"if",
"data_buffer_lock",
"is",
"not",
"None",
":",
"with",
"data_buffer_lock",
":",
"data_buffer",
"[",
"idx",
"]",
"=",
"batch",
"else",
":",
"data_buffer",
"[",
"idx",
"]",
"=",
"batch"
] |
Fetcher loop for fetching data from queue and put in reorder dict.
|
[
"Fetcher",
"loop",
"for",
"fetching",
"data",
"from",
"queue",
"and",
"put",
"in",
"reorder",
"dict",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L172-L187
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
_worker_fn
|
def _worker_fn(samples, batchify_fn, dataset=None):
"""Function for processing data in worker process."""
# pylint: disable=unused-argument
# it is required that each worker process has to fork a new MXIndexedRecordIO handle
# preserving dataset as global variable can save tons of overhead and is safe in new process
global _worker_dataset
batch = batchify_fn([_worker_dataset[i] for i in samples])
buf = io.BytesIO()
ForkingPickler(buf, pickle.HIGHEST_PROTOCOL).dump(batch)
return buf.getvalue()
|
python
|
def _worker_fn(samples, batchify_fn, dataset=None):
"""Function for processing data in worker process."""
# pylint: disable=unused-argument
# it is required that each worker process has to fork a new MXIndexedRecordIO handle
# preserving dataset as global variable can save tons of overhead and is safe in new process
global _worker_dataset
batch = batchify_fn([_worker_dataset[i] for i in samples])
buf = io.BytesIO()
ForkingPickler(buf, pickle.HIGHEST_PROTOCOL).dump(batch)
return buf.getvalue()
|
[
"def",
"_worker_fn",
"(",
"samples",
",",
"batchify_fn",
",",
"dataset",
"=",
"None",
")",
":",
"# pylint: disable=unused-argument",
"# it is required that each worker process has to fork a new MXIndexedRecordIO handle",
"# preserving dataset as global variable can save tons of overhead and is safe in new process",
"global",
"_worker_dataset",
"batch",
"=",
"batchify_fn",
"(",
"[",
"_worker_dataset",
"[",
"i",
"]",
"for",
"i",
"in",
"samples",
"]",
")",
"buf",
"=",
"io",
".",
"BytesIO",
"(",
")",
"ForkingPickler",
"(",
"buf",
",",
"pickle",
".",
"HIGHEST_PROTOCOL",
")",
".",
"dump",
"(",
"batch",
")",
"return",
"buf",
".",
"getvalue",
"(",
")"
] |
Function for processing data in worker process.
|
[
"Function",
"for",
"processing",
"data",
"in",
"worker",
"process",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L394-L403
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
ConnectionWrapper.send
|
def send(self, obj):
"""Send object"""
buf = io.BytesIO()
ForkingPickler(buf, pickle.HIGHEST_PROTOCOL).dump(obj)
self.send_bytes(buf.getvalue())
|
python
|
def send(self, obj):
"""Send object"""
buf = io.BytesIO()
ForkingPickler(buf, pickle.HIGHEST_PROTOCOL).dump(obj)
self.send_bytes(buf.getvalue())
|
[
"def",
"send",
"(",
"self",
",",
"obj",
")",
":",
"buf",
"=",
"io",
".",
"BytesIO",
"(",
")",
"ForkingPickler",
"(",
"buf",
",",
"pickle",
".",
"HIGHEST_PROTOCOL",
")",
".",
"dump",
"(",
"obj",
")",
"self",
".",
"send_bytes",
"(",
"buf",
".",
"getvalue",
"(",
")",
")"
] |
Send object
|
[
"Send",
"object"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L81-L85
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
_MultiWorkerIterV1._push_next
|
def _push_next(self):
"""Assign next batch workload to workers."""
r = next(self._iter, None)
if r is None:
return
self._key_queue.put((self._sent_idx, r))
self._sent_idx += 1
|
python
|
def _push_next(self):
"""Assign next batch workload to workers."""
r = next(self._iter, None)
if r is None:
return
self._key_queue.put((self._sent_idx, r))
self._sent_idx += 1
|
[
"def",
"_push_next",
"(",
"self",
")",
":",
"r",
"=",
"next",
"(",
"self",
".",
"_iter",
",",
"None",
")",
"if",
"r",
"is",
"None",
":",
"return",
"self",
".",
"_key_queue",
".",
"put",
"(",
"(",
"self",
".",
"_sent_idx",
",",
"r",
")",
")",
"self",
".",
"_sent_idx",
"+=",
"1"
] |
Assign next batch workload to workers.
|
[
"Assign",
"next",
"batch",
"workload",
"to",
"workers",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L237-L243
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
_MultiWorkerIterV1.shutdown
|
def shutdown(self):
"""Shutdown internal workers by pushing terminate signals."""
if not self._shutdown:
# send shutdown signal to the fetcher and join data queue first
# Remark: loop_fetcher need to be joined prior to the workers.
# otherwise, the the fetcher may fail at getting data
self._data_queue.put((None, None))
self._fetcher.join()
# send shutdown signal to all worker processes
for _ in range(self._num_workers):
self._key_queue.put((None, None))
# force shut down any alive worker processes
for w in self._workers:
if w.is_alive():
w.terminate()
self._shutdown = True
|
python
|
def shutdown(self):
"""Shutdown internal workers by pushing terminate signals."""
if not self._shutdown:
# send shutdown signal to the fetcher and join data queue first
# Remark: loop_fetcher need to be joined prior to the workers.
# otherwise, the the fetcher may fail at getting data
self._data_queue.put((None, None))
self._fetcher.join()
# send shutdown signal to all worker processes
for _ in range(self._num_workers):
self._key_queue.put((None, None))
# force shut down any alive worker processes
for w in self._workers:
if w.is_alive():
w.terminate()
self._shutdown = True
|
[
"def",
"shutdown",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"_shutdown",
":",
"# send shutdown signal to the fetcher and join data queue first",
"# Remark: loop_fetcher need to be joined prior to the workers.",
"# otherwise, the the fetcher may fail at getting data",
"self",
".",
"_data_queue",
".",
"put",
"(",
"(",
"None",
",",
"None",
")",
")",
"self",
".",
"_fetcher",
".",
"join",
"(",
")",
"# send shutdown signal to all worker processes",
"for",
"_",
"in",
"range",
"(",
"self",
".",
"_num_workers",
")",
":",
"self",
".",
"_key_queue",
".",
"put",
"(",
"(",
"None",
",",
"None",
")",
")",
"# force shut down any alive worker processes",
"for",
"w",
"in",
"self",
".",
"_workers",
":",
"if",
"w",
".",
"is_alive",
"(",
")",
":",
"w",
".",
"terminate",
"(",
")",
"self",
".",
"_shutdown",
"=",
"True"
] |
Shutdown internal workers by pushing terminate signals.
|
[
"Shutdown",
"internal",
"workers",
"by",
"pushing",
"terminate",
"signals",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L266-L281
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/data/dataloader.py
|
_MultiWorkerIter._push_next
|
def _push_next(self):
"""Assign next batch workload to workers."""
r = next(self._iter, None)
if r is None:
return
async_ret = self._worker_pool.apply_async(
self._worker_fn, (r, self._batchify_fn, self._dataset))
self._data_buffer[self._sent_idx] = async_ret
self._sent_idx += 1
|
python
|
def _push_next(self):
"""Assign next batch workload to workers."""
r = next(self._iter, None)
if r is None:
return
async_ret = self._worker_pool.apply_async(
self._worker_fn, (r, self._batchify_fn, self._dataset))
self._data_buffer[self._sent_idx] = async_ret
self._sent_idx += 1
|
[
"def",
"_push_next",
"(",
"self",
")",
":",
"r",
"=",
"next",
"(",
"self",
".",
"_iter",
",",
"None",
")",
"if",
"r",
"is",
"None",
":",
"return",
"async_ret",
"=",
"self",
".",
"_worker_pool",
".",
"apply_async",
"(",
"self",
".",
"_worker_fn",
",",
"(",
"r",
",",
"self",
".",
"_batchify_fn",
",",
"self",
".",
"_dataset",
")",
")",
"self",
".",
"_data_buffer",
"[",
"self",
".",
"_sent_idx",
"]",
"=",
"async_ret",
"self",
".",
"_sent_idx",
"+=",
"1"
] |
Assign next batch workload to workers.
|
[
"Assign",
"next",
"batch",
"workload",
"to",
"workers",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/data/dataloader.py#L431-L439
|
train
|
apache/incubator-mxnet
|
python/mxnet/kvstore.py
|
_ctype_key_value
|
def _ctype_key_value(keys, vals):
"""
Returns ctype arrays for the key-value args, and the whether string keys are used.
For internal use only.
"""
if isinstance(keys, (tuple, list)):
assert(len(keys) == len(vals))
c_keys = []
c_vals = []
use_str_keys = None
for key, val in zip(keys, vals):
c_key_i, c_val_i, str_keys_i = _ctype_key_value(key, val)
c_keys += c_key_i
c_vals += c_val_i
use_str_keys = str_keys_i if use_str_keys is None else use_str_keys
assert(use_str_keys == str_keys_i), "inconsistent types of keys detected."
c_keys_arr = c_array(ctypes.c_char_p, c_keys) if use_str_keys \
else c_array(ctypes.c_int, c_keys)
c_vals_arr = c_array(ctypes.c_void_p, c_vals)
return (c_keys_arr, c_vals_arr, use_str_keys)
assert(isinstance(keys, (int,) + string_types)), \
"unexpected type for keys: " + str(type(keys))
use_str_keys = isinstance(keys, string_types)
if isinstance(vals, NDArray):
c_keys = c_str_array([keys]) if use_str_keys \
else c_array_buf(ctypes.c_int, array('i', [keys]))
return (c_keys, c_handle_array([vals]), use_str_keys)
else:
for value in vals:
assert(isinstance(value, NDArray))
c_keys = c_str_array([keys] * len(vals)) if use_str_keys \
else c_array_buf(ctypes.c_int, array('i', [keys] * len(vals)))
return (c_keys, c_handle_array(vals), use_str_keys)
|
python
|
def _ctype_key_value(keys, vals):
"""
Returns ctype arrays for the key-value args, and the whether string keys are used.
For internal use only.
"""
if isinstance(keys, (tuple, list)):
assert(len(keys) == len(vals))
c_keys = []
c_vals = []
use_str_keys = None
for key, val in zip(keys, vals):
c_key_i, c_val_i, str_keys_i = _ctype_key_value(key, val)
c_keys += c_key_i
c_vals += c_val_i
use_str_keys = str_keys_i if use_str_keys is None else use_str_keys
assert(use_str_keys == str_keys_i), "inconsistent types of keys detected."
c_keys_arr = c_array(ctypes.c_char_p, c_keys) if use_str_keys \
else c_array(ctypes.c_int, c_keys)
c_vals_arr = c_array(ctypes.c_void_p, c_vals)
return (c_keys_arr, c_vals_arr, use_str_keys)
assert(isinstance(keys, (int,) + string_types)), \
"unexpected type for keys: " + str(type(keys))
use_str_keys = isinstance(keys, string_types)
if isinstance(vals, NDArray):
c_keys = c_str_array([keys]) if use_str_keys \
else c_array_buf(ctypes.c_int, array('i', [keys]))
return (c_keys, c_handle_array([vals]), use_str_keys)
else:
for value in vals:
assert(isinstance(value, NDArray))
c_keys = c_str_array([keys] * len(vals)) if use_str_keys \
else c_array_buf(ctypes.c_int, array('i', [keys] * len(vals)))
return (c_keys, c_handle_array(vals), use_str_keys)
|
[
"def",
"_ctype_key_value",
"(",
"keys",
",",
"vals",
")",
":",
"if",
"isinstance",
"(",
"keys",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"assert",
"(",
"len",
"(",
"keys",
")",
"==",
"len",
"(",
"vals",
")",
")",
"c_keys",
"=",
"[",
"]",
"c_vals",
"=",
"[",
"]",
"use_str_keys",
"=",
"None",
"for",
"key",
",",
"val",
"in",
"zip",
"(",
"keys",
",",
"vals",
")",
":",
"c_key_i",
",",
"c_val_i",
",",
"str_keys_i",
"=",
"_ctype_key_value",
"(",
"key",
",",
"val",
")",
"c_keys",
"+=",
"c_key_i",
"c_vals",
"+=",
"c_val_i",
"use_str_keys",
"=",
"str_keys_i",
"if",
"use_str_keys",
"is",
"None",
"else",
"use_str_keys",
"assert",
"(",
"use_str_keys",
"==",
"str_keys_i",
")",
",",
"\"inconsistent types of keys detected.\"",
"c_keys_arr",
"=",
"c_array",
"(",
"ctypes",
".",
"c_char_p",
",",
"c_keys",
")",
"if",
"use_str_keys",
"else",
"c_array",
"(",
"ctypes",
".",
"c_int",
",",
"c_keys",
")",
"c_vals_arr",
"=",
"c_array",
"(",
"ctypes",
".",
"c_void_p",
",",
"c_vals",
")",
"return",
"(",
"c_keys_arr",
",",
"c_vals_arr",
",",
"use_str_keys",
")",
"assert",
"(",
"isinstance",
"(",
"keys",
",",
"(",
"int",
",",
")",
"+",
"string_types",
")",
")",
",",
"\"unexpected type for keys: \"",
"+",
"str",
"(",
"type",
"(",
"keys",
")",
")",
"use_str_keys",
"=",
"isinstance",
"(",
"keys",
",",
"string_types",
")",
"if",
"isinstance",
"(",
"vals",
",",
"NDArray",
")",
":",
"c_keys",
"=",
"c_str_array",
"(",
"[",
"keys",
"]",
")",
"if",
"use_str_keys",
"else",
"c_array_buf",
"(",
"ctypes",
".",
"c_int",
",",
"array",
"(",
"'i'",
",",
"[",
"keys",
"]",
")",
")",
"return",
"(",
"c_keys",
",",
"c_handle_array",
"(",
"[",
"vals",
"]",
")",
",",
"use_str_keys",
")",
"else",
":",
"for",
"value",
"in",
"vals",
":",
"assert",
"(",
"isinstance",
"(",
"value",
",",
"NDArray",
")",
")",
"c_keys",
"=",
"c_str_array",
"(",
"[",
"keys",
"]",
"*",
"len",
"(",
"vals",
")",
")",
"if",
"use_str_keys",
"else",
"c_array_buf",
"(",
"ctypes",
".",
"c_int",
",",
"array",
"(",
"'i'",
",",
"[",
"keys",
"]",
"*",
"len",
"(",
"vals",
")",
")",
")",
"return",
"(",
"c_keys",
",",
"c_handle_array",
"(",
"vals",
")",
",",
"use_str_keys",
")"
] |
Returns ctype arrays for the key-value args, and the whether string keys are used.
For internal use only.
|
[
"Returns",
"ctype",
"arrays",
"for",
"the",
"key",
"-",
"value",
"args",
"and",
"the",
"whether",
"string",
"keys",
"are",
"used",
".",
"For",
"internal",
"use",
"only",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/kvstore.py#L33-L66
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.