def __init__(self, *args, **kwargs):
super(Parameter, self).__init__()
if 'scope' in kwargs.keys():
with nn.parameter_scope(kwargs['scope']):
set_parameter(self.__repr__(), self)
else:
set_parameter(self.__repr__(), self)
def load_param_in_txt(name, filepath):
with open(filepath, 'r') as input:
ds = input.read()
ds = ds.split("\n")
shape = eval(ds.pop(0))
variable = nn.Variable(shape, need_grad=True)
variable.d = np.fromstring("\n".join(ds), dtype=np.float32,
sep="\n").reshape(shape)
set_parameter(name, variable)
def load_param_in_txt(name, filepath):
with open(filepath, 'r') as input:
ds = input.read()
ds = ds.split("\n")
shape = eval(ds.pop(0))
variable = nn.Variable(shape, need_grad=True)
variable.d = np.fromstring("\n".join(ds),
dtype=np.float32,
sep="\n").reshape(shape)
set_parameter(name, variable)
def _get_variable_or_create(self, v, callback, current_scope):
if v.variable is not None:
return v.variable
v = callback._apply_generate_variable(v)
if v.variable is not None:
return v.variable
pvar = v.proto
name = pvar.name
shape = list(pvar.shape.dim)
if shape[0] < 0:
shape[0] = self.batch_size
shape = tuple(shape)
assert np.all(np.array(shape) > 0
), "Shape must be positive. Given {}.".format(shape)
if pvar.type != 'Parameter':
# Create a new variable and returns.
var = nn.Variable(shape)
v.variable = var
var.name = name
return var
# Trying to load the parameter from .nnp file.
callback.verbose('Loading parameter `{}` from .nnp.'.format(name))
try:
param = get_parameter(name)
if param is None:
logger.info(
'Parameter `{}` is not found. Initializing.'.format(name))
tmp = _create_variable(pvar, name, shape, self.rng)
param = tmp.variable_instance
set_parameter(name, param)
# Always copy param to current scope even if it already exists.
with nn.parameter_scope('', current_scope):
set_parameter(name, param)
except:
import sys
import traceback
raise ValueError(
'An error occurs during creation of a variable `{}` as a'
' parameter variable. The error was:\n----\n{}\n----\n'
'The parameters registered was {}'.format(
name, traceback.format_exc(), '\n'.join(
list(nn.get_parameters(grad_only=False).keys()))))
assert shape == param.shape
param = param.get_unlinked_variable(need_grad=v.need_grad)
v.variable = param
param.name = name
return param
def test_get_set_pop_parameter():
import nnabla as nn
from nnabla.parameter import set_parameter, pop_parameter, get_parameter
nn.clear_parameters()
x = nn.Variable((2, 3, 4, 5))
key = 'a/b/c'
set_parameter(key, x)
x2 = get_parameter(key)
assert x is x2
x3 = pop_parameter(key)
assert x is x3
x4 = get_parameter(key)
assert x4 is None
def yolov2_image_coordinate(t_xy, t_wh, biases):
import numpy as np
from nnabla.parameter import pop_parameter, set_parameter
h, w = t_xy.shape[-2:]
xs = pop_parameter('xs')
ys = pop_parameter('ys')
if xs is None or (h != xs.shape[-1]):
xs = nn.Variable.from_numpy_array(np.arange(w).reshape(1, 1, 1, -1))
xs.need_grad = False
set_parameter('xs', xs)
if ys is None or (h != ys.shape[-2]):
ys = nn.Variable.from_numpy_array(np.arange(h).reshape(1, 1, -1, 1))
ys.need_grad = False
set_parameter('ys', ys)
t_x, t_y = F.split(t_xy, axis=2)
oshape = list(t_x.shape)
oshape.insert(2, 1)
t_x = F.reshape((t_x + xs) / w, oshape)
t_y = F.reshape((t_y + ys) / h, oshape)
pop_parameter('biases')
biases = biases.reshape(1, biases.shape[0], biases.shape[1], 1,
1) / np.array([w, h]).reshape(1, 1, 2, 1, 1)
b = nn.Variable.from_numpy_array(biases)
b.need_grad = False
set_parameter('biases', b)
t_wh = t_wh * b
return t_x, t_y, t_wh
