def get_network(self, name, batch_size=None, callback=None):
'''Create a variable graph given network by name
Returns: NnpNetwork
'''
network_proto = nnabla_pb2.Network()
network_proto.CopyFrom(self.network_dict[name])
return NnpNetwork(network_proto, self._params, batch_size, callback=callback)
def _create_network(net):
n = nnabla_pb2.Network()
n.name = net['name']
n.batch_size = net['batch_size']
# List (dict: name -> Variable) of outputs.
outputs = net['outputs']
sink = _get_network_sink(outputs)
# Create force name table: Variable -> name.
names = {}
names.update(net['names'])
names.update(outputs)
# Reverse dict: Variable --> Name
names = {v: k for k, v in names.items()}
# Create table: NdArray -> str
# (Use Ndarray instead of Variable because parameter variable might be
# unlinked)
params = {v.data: k for k, v in get_parameters(grad_only=False).items()}
# ----------------------------------------------------------------------
# Parse graph to get variables and functions
# ----------------------------------------------------------------------
variables = OrderedDict()
functions = OrderedDict()
def collect_info(func):
# Collect information.
function_type = func.info.type_name
if function_type == 'Sink':
return
function_name = _get_unique_function_name(function_type, functions)
functions[function_name] = {
'type': function_type,
'args': func.info.args,
'inputs': [],
'outputs': []
}
for i in func.inputs:
base_name = '{}_Input'.format(function_name)
vname = _get_variable_name_or_register(i, variables, names, params,
base_name)
functions[function_name]['inputs'].append(vname)
for o in func.outputs:
base_name = '{}_Output'.format(function_name)
vname = _get_variable_name_or_register(o, variables, names, params,
base_name)
functions[function_name]['outputs'].append(vname)
sink.visit(collect_info)
# ----------------------------------------------------------------------
# Convert variables and functions into proto
# ----------------------------------------------------------------------
for name, variable in variables.items():
v = n.variable.add()
v.name = name
shape = list(numpy.array(variable.d).shape)
if variable.data in params:
v.type = 'Parameter'
else:
v.type = 'Buffer'
# TODO: The first dimension is always considered as batch size.
# No problem?
if len(shape) > 0:
shape[0] = -1
v.shape.dim.extend(shape)
# ----------------------------------------------------------------------
# Add info to variable
# ----------------------------------------------------------------------
# TODO: Only required for Parameter variables?
if variable.info:
i = v.initializer
i.type = variable.info.initializer.__class__.__name__.replace(
'Initializer', '')
i.multiplier = 0.0
if i.type == 'Constant':
i.multiplier = variable.info.initializer.value
elif i.type == 'Uniform':
i.multiplier = -variable.info.initializer.lim[0]
elif i.type == 'Normal':
i.multiplier = variable.info.initializer.sigma
else:
pass # TODO Error
for name, function in functions.items():
f = n.function.add()
_create_function_nntxt(f, name, function)
return n
def _create_network(net, variable_batch_size):
n = nnabla_pb2.Network()
n.name = net['name']
n.batch_size = net['batch_size']
# List (dict: name -> Variable) of outputs.
outputs = net['outputs']
sink = _get_network_sink(outputs)
# Create force name table: Variable -> name.
names = {}
names.update(net['names'])
names.update(outputs)
# Reverse dict: Variable --> Name
names = {v: k for k, v in names.items()}
# Create table: NdArray -> str
# (Use Ndarray instead of Variable because parameter variable might be
# unlinked)
params = {v.data: k for k, v in get_parameters(grad_only=False).items()}
# ----------------------------------------------------------------------
# Parse graph to get variables and functions
# ----------------------------------------------------------------------
variables = OrderedDict()
functions = OrderedDict()
def collect_info(func):
# Collect information.
function_type = func.info.type_name
if function_type == 'Sink':
return
function_name = _get_unique_function_name(function_type, functions)
functions[function_name] = {
'type': function_type,
'args': func.info.args,
'inputs': [],
'outputs': []
}
for i in func.inputs:
base_name = '{}_Input'.format(function_name)
vname = _get_variable_name_or_register(i, variables, names, params,
base_name)
functions[function_name]['inputs'].append(vname)
for o in func.outputs:
base_name = '{}_Output'.format(function_name)
vname = _get_variable_name_or_register(o, variables, names, params,
base_name)
functions[function_name]['outputs'].append(vname)
sink.visit(collect_info)
expect_batch_size = None
# ----------------------------------------------------------------------
# Convert variables and functions into proto
# ----------------------------------------------------------------------
for name, variable in variables.items():
v = n.variable.add()
v.name = name
shape = list(numpy.array(variable.d).shape)
if variable.data in params:
v.type = 'Parameter'
else:
v.type = 'Buffer'
if variable_batch_size:
# TODO: Temporarily dim 0 of shape expects to be batch size.
if len(shape) > 0:
b = shape[0]
if expect_batch_size is None:
expect_batch_size = b
if b != expect_batch_size:
raise ValueError(
'Variable "{}" has different batch size {} (expected {})'
.format(v.name, b, expect_batch_size))
shape[0] = -1
v.shape.dim.extend(shape)
# ----------------------------------------------------------------------
# Add info to variable
# ----------------------------------------------------------------------
# TODO: Only required for Parameter variables?
if variable.info:
i = v.initializer
i.type = variable.info.initializer.__class__.__name__.replace(
'Initializer', '')
i.multiplier = 0.0
if i.type == 'Constant':
i.multiplier = variable.info.initializer.value
elif i.type == 'Uniform':
i.multiplier = -variable.info.initializer.lim[0]
elif i.type == 'Normal':
i.multiplier = variable.info.initializer.sigma
else:
pass # TODO Error
for name, function in functions.items():
f = n.function.add()
if function['type'] == 'Reshape':
shape = function['args']['shape']
input_shape = variables[function['inputs'][0]].shape
shape_infer_index = -1
rest_size = 1
for i, s in enumerate(shape):
if s < 0:
if shape_infer_index >= 0:
raise ValueError(
'Rehaps: shape has multiple negative value.')
shape_infer_index = i
else:
rest_size *= s
if shape_infer_index >= 0:
function['args']['shape'][shape_infer_index] = int(
numpy.prod(input_shape) / rest_size)
if variable_batch_size:
# TODO: Temporarily dim 0 of shape expects to be batch size.
b = function['args']['shape'][0]
if expect_batch_size < 0:
expect_batch_size = b
if b != expect_batch_size:
raise ValueError(
'Variable "{}" has different batch size {} (expected {})'
.format(v.name, b, expect_batch_size))
function['args']['shape'][0] = -1
if function['type'] == 'Broadcast':
shape = function['args']['shape']
if variable_batch_size:
# TODO: Temporarily dim 0 of shape expects to be batch size.
b = function['args']['shape'][0]
if expect_batch_size < 0:
expect_batch_size = b
if b != expect_batch_size:
raise ValueError(
'Variable "{}" has different batch size {} (expected {})'
.format(v.name, b, expect_batch_size))
function['args']['shape'][0] = -1
_create_function_nntxt(f, name, function)
return n
def _create_network(net):
n = nnabla_pb2.Network()
n.name = net['name']
n.batch_size = net['batch_size']
params = {v: k for k, v in get_parameters(grad_only=False).items()}
variables = OrderedDict()
functions = OrderedDict()
def _network_recursive(func, seen):
if func is None:
return
seen.add(func)
for i in func.inputs:
if i.parent in seen:
continue
_network_recursive(i.parent, seen)
# Collect information.
function_type = func.info.type_name
function_name = function_name_base = function_type
count = 2
while function_name in functions:
function_name = '{}_{}'.format(function_name_base, count)
count += 1
functions[function_name] = {
'type': function_type,
'args': func.info.args,
'inputs': [],
'outputs': []
}
for i in func.inputs:
vname = _add_variable(i, variables, params,
'{}_Input'.format(function_name))
functions[function_name]['inputs'].append(vname)
for o in func.outputs:
vname = _add_variable(o, variables, params,
'{}_Output'.format(function_name))
functions[function_name]['outputs'].append(vname)
seen = set()
_network_recursive(net['variable'].parent, seen)
for name, variable in variables.items():
v = n.variable.add()
v.name = name
shape = list(numpy.array(variable.d).shape)
if variable in params:
v.type = 'Parameter'
else:
v.type = 'Buffer'
if len(shape) > 0:
shape[0] = -1
v.shape.dim.extend(shape)
if variable.info:
i = v.initializer
i.type = variable.info.initializer.__class__.__name__.replace(
'Initializer', '')
i.multiplier = 0.0
if i.type == 'Constant':
i.multiplier = variable.info.initializer.value
elif i.type == 'Uniform':
i.multiplier = -variable.info.initializer.lim[0]
elif i.type == 'Normal':
i.multiplier = variable.info.initializer.sigma
else:
pass # TODO Error
for name, function in functions.items():
f = n.function.add()
_create_function_nntxt(f, name, function)
return n
