def add_all_variable_images(self, last_var, exclude_params=True, global_step=None, pattern='.*'):
cp = re.compile(pattern)
g = c.build_computational_graph(last_var)
names = NodeName(g.nodes)
for n in g.nodes:
if isinstance(n, chainer.variable.VariableNode) and \
(exclude_params and not isinstance(n._variable(), chainer.Parameter)) and \
n.data is not None and \
cp.match(names.name(n)):
data = chainer.cuda.to_cpu(n.data)
assert data.ndim < 5, "'variable.data' must be less than 5. the given 'variable.data.ndim' is %d." % data.ndim
if data.ndim == 4:
for i, d in enumerate(data):
img = make_grid(np.expand_dims(d, 1) if d.shape[0] != 3 else d)
self.add_image(names.name(n) + '/' + str(i), img, global_step)
else:
img = make_grid(np.expand_dims(data, 1) if data.shape[0] != 3 else data)
self.add_image(names.name(n), img, global_step)
python类Parameter()的实例源码
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0, initialV=None, nobias=False, cover_all=False):
super(Convolution1D, self).__init__()
ksize = conv_nd.as_tuple(ksize, 1)
self.ksize = ksize
self.nobias = nobias
self.stride = stride
self.pad = pad
self.out_channels = out_channels
self.in_channels = in_channels
self.cover_all = cover_all
self.initialV = initialV
with self.init_scope():
V_shape = (out_channels, in_channels) + ksize
initialV = initializers._get_initializer(initialV)
self.V = Parameter(initialV, V_shape)
if nobias:
self.b = None
def _initialize_params(self, t):
xp = cuda.get_array_module(t)
self.mean_t = xp.mean(t, axis=(0, 2)) # calculate average for each channel
self.std_t = xp.sqrt(xp.var(t, axis=(0, 2))) # calculate stddev for each channel
g = 1 / self.std_t
b = -self.mean_t / self.std_t
# print("g <- {}, b <- {}".format(g.reshape((-1,)), b.reshape((-1,))))
with self.init_scope():
if self.nobias == False:
self.b = Parameter(b, b.shape)
g_shape = (self.out_channels, 1) + (1,) * len(self.ksize)
self.g = Parameter(g.reshape(g_shape), g_shape)
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0, initialV=None, nobias=False, cover_all=False):
super(Convolution1D, self).__init__()
ksize = conv_nd.as_tuple(ksize, 1)
self.ksize = ksize
self.nobias = nobias
self.stride = stride
self.pad = pad
self.out_channels = out_channels
self.in_channels = in_channels
self.cover_all = cover_all
self.initialV = initialV
with self.init_scope():
V_shape = (out_channels, in_channels) + ksize
initialV = initializers._get_initializer(initialV)
self.V = Parameter(initialV, V_shape)
if nobias:
self.b = None
def _initialize_params(self, t):
xp = cuda.get_array_module(t)
self.mean_t = xp.mean(t, axis=(0, 2)) # calculate average for each channel
self.std_t = xp.sqrt(xp.var(t, axis=(0, 2))) # calculate stddev for each channel
g = 1 / self.std_t
b = -self.mean_t / self.std_t
# print("g <- {}, b <- {}".format(g.reshape((-1,)), b.reshape((-1,))))
with self.init_scope():
if self.nobias == False:
self.b = Parameter(b, b.shape)
g_shape = (self.out_channels, 1) + (1,) * len(self.ksize)
self.g = Parameter(g.reshape(g_shape), g_shape)
def __init__(self, n_input_channels, action_size,
n_hidden_layers=0, n_hidden_channels=None,
min_action=None, max_action=None, bound_mean=False,
var_type='spherical',
nonlinearity=F.relu, mean_wscale=1):
self.n_input_channels = n_input_channels
self.action_size = action_size
self.n_hidden_layers = n_hidden_layers
self.n_hidden_channels = n_hidden_channels
self.min_action = min_action
self.max_action = max_action
self.bound_mean = bound_mean
self.nonlinearity = nonlinearity
var_size = {'spherical': 1, 'diagonal': action_size}[var_type]
layers = []
layers.append(L.Linear(n_input_channels, n_hidden_channels))
for _ in range(n_hidden_layers - 1):
layers.append(self.nonlinearity)
layers.append(L.Linear(n_hidden_channels, n_hidden_channels))
layers.append(self.nonlinearity)
# The last layer is used to compute the mean
layers.append(
L.Linear(n_hidden_channels, action_size,
initialW=LeCunNormal(mean_wscale)))
if self.bound_mean:
layers.append(lambda x: bound_by_tanh(
x, self.min_action, self.max_action))
super().__init__()
with self.init_scope():
self.hidden_layers = links.Sequence(*layers)
self.var_param = chainer.Parameter(
initializer=0.0, shape=(var_size,))
def create_simple_link():
link = chainer.Link()
with link.init_scope():
link.param = chainer.Parameter(np.zeros(1))
return link
def add_all_parameter_histograms(self, last_var, global_step=None, pattern='.*'):
cp = re.compile(pattern)
g = c.build_computational_graph(last_var)
names = NodeName(g.nodes)
for n in g.nodes:
if isinstance(n, chainer.variable.VariableNode) and \
isinstance(n._variable(), chainer.Parameter) and \
cp.match(names.name(n)):
data = chainer.cuda.to_cpu(n._variable().data)
self.add_histogram(names.name(n), data, global_step)
def __init__(self, w, g):
super(SimpleLink, self).__init__()
with self.init_scope():
self.param = chainer.Parameter(w)
self.param.grad = g
def setInitAllParameters(self, optimizer, init_type="default",
init_scale=0.1):
sys.stdout.write("############ Current Parameters BEGIN\n")
self.printAllParameters(optimizer)
sys.stdout.write("############ Current Parameters END\n")
if init_type == "uniform":
sys.stdout.write(
"# initializer is [uniform] [%f]\n" %
(init_scale))
t_initializer = chainer.initializers.Uniform(init_scale)
named_params = sorted(
optimizer.target.namedparams(),
key=lambda x: x[0])
for n, p in named_params:
with cuda.get_device(p.data):
if args.chainer_version_check[0] == 2:
p.copydata(chainer.Parameter(
t_initializer, p.data.shape))
else:
chainer.initializers.init_weight(p.data, t_initializer)
elif init_type == "normal":
sys.stdout.write("# initializer is [normal] [%f]\n" % (init_scale))
t_initializer = chainer.initializers.Normal(init_scale)
named_params = sorted(
optimizer.target.namedparams(),
key=lambda x: x[0])
for n, p in named_params:
with cuda.get_device(p.data):
if args.chainer_version_check[0] == 2:
p.copydata(chainer.Parameter(
t_initializer, p.data.shape))
else:
chainer.initializers.init_weight(p.data, t_initializer)
else: # "default"
sys.stdout.write(
"# initializer is [defalit] [%f]\n" %
(init_scale))
named_params = sorted(
optimizer.target.namedparams(),
key=lambda x: x[0])
for n, p in named_params:
with cuda.get_device(p.data):
p.data *= args.init_scale
self.printAllParameters(optimizer, init_type, init_scale)
return 0
