def test_addgrads(self):
l1 = chainer.Link()
with l1.init_scope():
l1.x = chainer.Parameter(shape=(2, 3))
l2 = chainer.Link()
with l2.init_scope():
l2.x = chainer.Parameter(shape=2)
l3 = chainer.Link()
with l3.init_scope():
l3.x = chainer.Parameter(shape=3)
c1 = chainer.Chain()
with c1.init_scope():
c1.l1 = l1
c1.l2 = l2
c2 = chainer.Chain()
with c2.init_scope():
c2.c1 = c1
c2.l3 = l3
l1.x.grad.fill(1)
l2.x.grad.fill(2)
l3.x.grad.fill(3)
self.l1.x.grad.fill(-1)
self.l2.x.grad.fill(-2)
self.l3.cleargrads()
self.c2.addgrads(c2)
numpy.testing.assert_array_equal(self.l1.x.grad, numpy.zeros((2, 3)))
numpy.testing.assert_array_equal(self.l2.x.grad, numpy.zeros(2))
numpy.testing.assert_array_equal(self.l3.x.grad, numpy.full(3, 3.))
def test_namedpersistent():
# This test case is adopted from
# https://github.com/chainer/chainer/pull/6788
l1 = chainer.Link()
with l1.init_scope():
l1.x = chainer.Parameter(shape=(2, 3))
l2 = chainer.Link()
with l2.init_scope():
l2.x = chainer.Parameter(shape=2)
l2.add_persistent('l2_a', numpy.array([1, 2, 3], dtype=numpy.float32))
l3 = chainer.Link()
with l3.init_scope():
l3.x = chainer.Parameter()
l3.add_persistent('l3_a', numpy.array([1, 2, 3], dtype=numpy.float32))
c1 = chainer.Chain()
with c1.init_scope():
c1.l1 = l1
c1.add_link('l2', l2)
c1.add_persistent('c1_a', numpy.array([1, 2, 3], dtype=numpy.float32))
c2 = chainer.Chain()
with c2.init_scope():
c2.c1 = c1
c2.l3 = l3
c2.add_persistent('c2_a', numpy.array([1, 2, 3], dtype=numpy.float32))
namedpersistent = list(chainerrl.misc.namedpersistent(c2))
assert ([(name, id(p)) for name, p in namedpersistent
] == [('/c2_a', id(c2.c2_a)), ('/c1/c1_a', id(c2.c1.c1_a)),
('/c1/l2/l2_a', id(c2.c1.l2.l2_a)),
('/l3/l3_a', id(c2.l3.l3_a))])
def test_copyparams(self):
l1 = chainer.Link()
with l1.init_scope():
l1.x = chainer.Parameter(shape=(2, 3))
l2 = chainer.Link()
with l2.init_scope():
l2.x = chainer.Parameter(shape=2)
l3 = chainer.Link()
with l3.init_scope():
l3.x = chainer.Parameter(shape=3)
c1 = chainer.Chain()
with c1.init_scope():
c1.l1 = l1
c1.l2 = l2
c2 = chainer.Chain()
with c2.init_scope():
c2.c1 = c1
c2.l3 = l3
l1.x.data.fill(0)
l2.x.data.fill(1)
l3.x.data.fill(2)
self.c2.copyparams(c2)
numpy.testing.assert_array_equal(self.l1.x.data, l1.x.data)
numpy.testing.assert_array_equal(self.l2.x.data, l2.x.data)
numpy.testing.assert_array_equal(self.l3.x.data, l3.x.data)
def setUp(self):
self.l1 = chainer.Link(x=(2, 3))
self.l2 = chainer.Link(x=2)
self.l3 = chainer.Link(x=3)
self.c1 = chainer.Chain(l1=self.l1)
self.c1.add_link('l2', self.l2)
self.c2 = chainer.Chain(c1=self.c1, l3=self.l3)
def setUp(self):
self.l1 = chainer.Link(x=(2, 3))
self.l2 = chainer.Link(x=2)
self.l3 = chainer.Link(x=None)
self.c1 = chainer.Chain(l1=self.l1)
self.c1.add_link('l2', self.l2)
self.c2 = chainer.Chain(c1=self.c1)
with self.c2.init_scope():
self.c2.l3 = self.l3
def __init__(self):
self.caffe = chainer.Chain(
conv1=L.Convolution2D(3, 96, ksize=11, stride=4),
conv2=L.Convolution2D(96, 256, ksize=5, pad=2),
conv3=L.Convolution2D(256, 384, ksize=3, pad=1),
conv4=L.Convolution2D(384, 384, ksize=3, pad=1),
conv5=L.Convolution2D(384, 256, ksize=3, pad=1),
fc6=L.Linear(9216, 4096),
fc7=L.Linear(4096, 4096),
)
self.fine = chainer.Chain(fc8ft=F.Linear(4096, 17), )
def test_copy_param_scalar(self):
a = chainer.Chain()
with a.init_scope():
a.p = chainer.Parameter(np.array(1))
b = chainer.Chain()
with b.init_scope():
b.p = chainer.Parameter(np.array(2))
self.assertNotEqual(a.p.array, b.p.array)
# Copy b's parameters to a
copy_param.copy_param(a, b)
self.assertEqual(a.p.array, b.p.array)
def test_copyparams(self):
l1 = chainer.Link(x=(2, 3))
l2 = chainer.Link(x=2)
l3 = chainer.Link(x=3)
c1 = chainer.Chain(l1=l1, l2=l2)
c2 = chainer.Chain(c1=c1, l3=l3)
l1.x.data.fill(0)
l2.x.data.fill(1)
l3.x.data.fill(2)
self.c2.copyparams(c2)
numpy.testing.assert_array_equal(self.l1.x.data, l1.x.data)
numpy.testing.assert_array_equal(self.l2.x.data, l2.x.data)
numpy.testing.assert_array_equal(self.l3.x.data, l3.x.data)
def __init__(self, hyperparams: HyperParameters, hdf5_path=None):
assert isinstance(hyperparams, HyperParameters)
self.generation_network, self.generation_network_params = self.build_generation_network(
total_timestep=hyperparams.generator_total_timestep,
channels_chz=hyperparams.channels_chz,
channels_u=hyperparams.generator_u_channels)
self.inference_network, self.inference_network_params = self.build_inference_network(
channels_chz=hyperparams.channels_chz)
self.representation_network, self.representation_network_params = self.build_representation_network(
architecture=hyperparams.representation_architecture,
channels_r=hyperparams.channels_r)
if hdf5_path:
try:
load_hdf5(
os.path.join(hdf5_path, "generation.hdf5"),
self.generation_network_params)
load_hdf5(
os.path.join(hdf5_path, "inference.hdf5"),
self.inference_network_params)
load_hdf5(
os.path.join(hdf5_path, "representation.hdf5"),
self.representation_network_params)
except:
pass
self.parameters = chainer.Chain(
g=self.generation_network_params,
i=self.inference_network_params,
r=self.representation_network_params,
)
def load_model():
models = chainer.Chain(conv1=L.Convolution2D(in_channels=None,
out_channels=6,
ksize=3,
pad=1),
conv2=L.Convolution2D(in_channels=None,
out_channels=12,
ksize=3,
pad=1),
conv3=L.Convolution2D(in_channels=None,
out_channels=24,
ksize=3,
pad=1),
conv4=L.Convolution2D(in_channels=None,
out_channels=48,
ksize=3,
pad=1),
conv5=L.Convolution2D(in_channels=None,
out_channels=96,
ksize=3,
pad=1),
bn1=L.BatchNormalization(6),
bn2=L.BatchNormalization(12),
bn3=L.BatchNormalization(24),
bn4=L.BatchNormalization(48),
bn5=L.BatchNormalization(96),
linear5=L.Linear(None, 10))
serializers.load_npz('./Model_check_point/resizebn_64_36.model', models)
#models.to_gpu(0)
return models
def __init__(self, params):
params.check()
self.params = params
self.chain = chainer.Chain()
self.create_network()
self.setup_optimizer()
self._gpu = False
def build_inference_network(self, generation_steps, channels_chz, channels_map_x):
inference_parameters = chainer.Chain()
cores = []
with inference_parameters.init_scope():
# LSTM core
for t in range(generation_steps):
params = gqn.nn.chainer.inference.CoreParameters(
channels_chz=channels_chz)
core = gqn.nn.chainer.inference.CoreNetwork(params=params)
cores.append(core)
setattr(inference_parameters, "core_%d" % t, params)
# z posterior sampler
params = gqn.nn.chainer.inference.PosteriorParameters(
channels_z=channels_chz)
posterior = gqn.nn.chainer.inference.PosteriorNetwork(params)
inference_parameters.posterior = params
# x downsampler
params = gqn.nn.chainer.inference.DownsamplerParameters(
channels=channels_map_x)
downsampler = gqn.nn.chainer.inference.Downsampler(params)
inference_parameters.downsampler = params
return cores, posterior, downsampler, inference_parameters
def _create_chain(self):
chain = chainer.Chain(l_conv1_1=L.Convolution2D(None,
64, (3, 3),
pad=1),
l_norm1_1=L.BatchNormalization(64),
l_conv1_2=L.Convolution2D(64, 64, (3, 3), pad=1),
l_norm1_2=L.BatchNormalization(64),
l_conv1_3=L.Convolution2D(64, 64, (3, 3), pad=1),
l_norm1_3=L.BatchNormalization(64),
l_conv1_r=L.Convolution2D(None,
64, (3, 3),
pad=1),
l_norm1_r=L.BatchNormalization(64),
l_conv2_1=L.Convolution2D(64, 128, (3, 3),
pad=1),
l_norm2_1=L.BatchNormalization(128),
l_conv2_2=L.Convolution2D(128,
128, (3, 3),
pad=1),
l_norm2_2=L.BatchNormalization(128),
l_conv2_3=L.Convolution2D(128,
128, (3, 3),
pad=1),
l_norm2_3=L.BatchNormalization(128),
l_conv2_r=L.Convolution2D(64, 128, (3, 3),
pad=1),
l_norm2_r=L.BatchNormalization(128),
l_conv3_1=L.Convolution2D(128,
256, (3, 3),
pad=1),
l_norm3_1=L.BatchNormalization(256),
l_conv3_2=L.Convolution2D(256,
256, (3, 3),
pad=1),
l_norm3_2=L.BatchNormalization(256),
l_conv3_3=L.Convolution2D(256,
256, (3, 3),
pad=1),
l_norm3_3=L.BatchNormalization(256),
l_conv3_r=L.Convolution2D(128,
256, (3, 3),
pad=1),
l_norm3_r=L.BatchNormalization(256),
l_conv4_1=L.Convolution2D(256,
512, (3, 3),
pad=1),
l_norm4_1=L.BatchNormalization(512),
l_conv4_2=L.Convolution2D(512,
512, (3, 3),
pad=1),
l_norm4_2=L.BatchNormalization(512),
l_conv4_3=L.Convolution2D(512,
512, (3, 3),
pad=1),
l_norm4_3=L.BatchNormalization(512),
l_conv4_r=L.Convolution2D(256,
512, (3, 3),
pad=1),
l_norm4_r=L.BatchNormalization(512))
return chain
def build_generation_network(self, generation_steps, channels_chz,
channels_u):
generation_parameters = chainer.Chain()
cores = []
with generation_parameters.init_scope():
# LSTM core
for t in range(generation_steps):
params = gqn.nn.chainer.generator.CoreParameters(
channels_chz=channels_chz, channels_u=channels_u)
core = gqn.nn.chainer.generator.CoreNetwork(params=params)
cores.append(core)
setattr(generation_parameters, "core_%d" % t, params)
# z prior sampler
params = gqn.nn.chainer.generator.PriorParameters(
channels_z=channels_chz)
prior = gqn.nn.chainer.generator.PriorNetwork(params)
generation_parameters.prior = params
# observation sampler
params = gqn.nn.chainer.generator.ObservationParameters()
observation = gqn.nn.chainer.generator.ObservationNetwork(params)
generation_parameters.observation = params
return cores, prior, observation, generation_parameters
def make_network(self, scale, bias=0):
dim = self.dim
self.lmNet = chainer.Chain()
self.lmNet.add_link(
'Embed',
L.EmbedID(len(self.vocab), self.dim, initialW=I.Uniform(scale)))
for i in range(self.layerNum):
self.lmNet.add_link(
'x2h%s_0' % (i),
L.Linear(dim, dim, initialW=I.Uniform(scale), nobias=True))
self.lmNet.add_link(
'x2t%s_0' % (i),
L.Linear(dim, dim, initialW=I.Uniform(scale), nobias=True))
for j in range(self.depth):
self.lmNet.add_link(
'h2h%s_%s' % (i, j),
L.Linear(dim, dim, initialW=I.Uniform(scale)))
self.lmNet.add_link(
'h2t%s_%s' % (i, j),
L.Linear(dim,
dim,
initialW=I.Uniform(scale),
initial_bias=bias))
self.lmNet.add_link(
'Output', L.Linear(dim, len(self.vocab),
initialW=I.Uniform(scale)))
def make_network(self, scale):
dim = self.dim
self.lmNet = chainer.Chain()
self.lmNet.add_link('Embed', L.EmbedID(len(self.vocab), dim, initialW=I.Uniform(scale)))
for j in range(self.layerNum):
self.lmNet.add_link('LSTM%s'%(j), L.LSTM(dim, dim, lateral_init=I.Uniform(scale), upward_init=I.Uniform(scale), forget_bias_init=0))
self.lmNet.add_link('Output', L.Linear(dim, len(self.vocab), initialW=I.Uniform(scale)))
def test_soft_copy_param_scalar(self):
a = chainer.Chain()
with a.init_scope():
a.p = chainer.Parameter(np.array(0.5))
b = chainer.Chain()
with b.init_scope():
b.p = chainer.Parameter(np.array(1))
# a = (1 - tau) * a + tau * b
copy_param.soft_copy_param(target_link=a, source_link=b, tau=0.1)
np.testing.assert_almost_equal(a.p.array, 0.55)
np.testing.assert_almost_equal(b.p.array, 1.0)
copy_param.soft_copy_param(target_link=a, source_link=b, tau=0.1)
np.testing.assert_almost_equal(a.p.array, 0.595)
np.testing.assert_almost_equal(b.p.array, 1.0)
def test_addgrads(self):
l1 = chainer.Link(x=(2, 3))
l2 = chainer.Link(x=2)
l3 = chainer.Link(x=3)
c1 = chainer.Chain(l1=l1, l2=l2)
c2 = chainer.Chain(c1=c1, l3=l3)
l1.x.grad.fill(1)
l2.x.grad.fill(2)
l3.x.grad.fill(3)
self.l1.x.grad.fill(-1)
self.l2.x.grad.fill(-2)
self.l3.x.grad.fill(-3)
self.c2.addgrads(c2)
numpy.testing.assert_array_equal(self.l1.x.grad, numpy.zeros((2, 3)))
numpy.testing.assert_array_equal(self.l2.x.grad, numpy.zeros(2))
numpy.testing.assert_array_equal(self.l3.x.grad, numpy.zeros(3))
def setUp(self):
self.l1 = chainer.Link()
with self.l1.init_scope():
self.l1.x = chainer.Parameter(shape=(2, 3))
self.l2 = chainer.Link()
with self.l2.init_scope():
self.l2.x = chainer.Parameter(shape=2)
self.l3 = chainer.Link()
with self.l3.init_scope():
self.l3.x = chainer.Parameter()
self.c1 = chainer.Chain()
with self.c1.init_scope():
self.c1.l1 = self.l1
with testing.assert_warns(DeprecationWarning):
self.c1.add_link('l2', self.l2)
self.c2 = chainer.Chain()
with self.c2.init_scope():
self.c2.c1 = self.c1
self.c2.l3 = self.l3
def test_chain(self):
ch = chainer.Chain()
with ch.init_scope():
ch.l1 = chainer.links.Linear(3, 4)
ch.l2 = chainer.links.Linear(5)
ch.l3 = chainer.links.PReLU()
self.assertEqual(names_of_links(ch), {'/l1', '/l2', '/l3'})
to_factorized_noisy(ch)
self.assertEqual(names_of_links(ch), {
'/l1', '/l1/mu', '/l1/sigma', '/l2', '/l2/mu', '/l2/sigma', '/l3'
})
def _test(self, gpu):
model = chainer.Chain(
a=L.Linear(1, 2, initialW=3, initial_bias=3),
b=chainer.Chain(c=L.Linear(2, 3, initialW=4, initial_bias=4)),
)
if gpu >= 0:
model.to_gpu(gpu)
xp = model.xp
else:
xp = np
optimizer = chainer.optimizers.SGD(self.lr)
optimizer.setup(model)
optimizer.add_hook(
chainerrl.optimizers.NonbiasWeightDecay(
rate=self.weight_decay_rate))
optimizer.update(lambda: chainer.Variable(xp.asarray(0.0)))
decay_factor = 1 - self.lr * self.weight_decay_rate
xp.testing.assert_allclose(model.a.W.array, 3 * decay_factor)
xp.testing.assert_allclose(model.a.b.array, 3)
xp.testing.assert_allclose(model.b.c.W.array, 4 * decay_factor)
xp.testing.assert_allclose(model.b.c.b.array, 4)
def _create_chain(self):
chain = chainer.Chain(
l_key=L.Linear(self.cell_size, self.nb_reads * self.memory_shape[1]),
l_add=L.Linear(self.cell_size, self.nb_reads * self.memory_shape[1]),
l_sigma=L.Linear(self.cell_size, 1),
l_ho=L.Linear(self.cell_size, self.nb_class),
l_ro=L.Linear(self.nb_reads * self.memory_shape[1], self.nb_class),
# for LSTM
lstm_xh=L.Linear(self.input_size, 4 * self.cell_size),
lstm_yh=L.EmbedID(self.nb_class, 4 * self.cell_size),
lstm_rh=L.Linear(self.nb_reads * self.memory_shape[1], 4 * self.cell_size),
lstm_hh=L.Linear(self.cell_size, 4 * self.cell_size),
)
return chain
def __init__(self,
n_input_channels,
n_hidden_layers,
n_hidden_channels,
action_size,
min_action=None,
max_action=None,
bound_action=True,
nonlinearity=F.relu,
last_wscale=1.):
self.n_input_channels = n_input_channels
self.n_hidden_layers = n_hidden_layers
self.n_hidden_channels = n_hidden_channels
self.action_size = action_size
self.min_action = min_action
self.max_action = max_action
self.bound_action = bound_action
if self.bound_action:
def action_filter(x):
return bound_by_tanh(x, self.min_action, self.max_action)
else:
action_filter = None
model = chainer.Chain(
fc=MLP(
self.n_input_channels,
n_hidden_channels,
(self.n_hidden_channels, ) * self.n_hidden_layers,
nonlinearity=nonlinearity,
),
lstm=L.LSTM(n_hidden_channels, n_hidden_channels),
out=L.Linear(n_hidden_channels,
action_size,
initialW=LeCunNormal(last_wscale)),
)
def model_call(model, x):
h = nonlinearity(model.fc(x))
h = model.lstm(h)
h = model.out(h)
return h
super().__init__(model=model,
model_call=model_call,
action_filter=action_filter)
def make_model(self, env):
n_dim_obs = env.observation_space.low.size
n_dim_action = env.action_space.low.size
n_hidden_channels = 50
policy = policies.FCGaussianPolicy(n_input_channels=n_dim_obs,
n_hidden_layers=2,
n_hidden_channels=n_hidden_channels,
action_size=n_dim_action,
min_action=env.action_space.low,
max_action=env.action_space.high)
q_func = q_function.FCSAQFunction(n_dim_obs=n_dim_obs,
n_dim_action=n_dim_action,
n_hidden_layers=2,
n_hidden_channels=n_hidden_channels)
return chainer.Chain(policy=policy, q_function=q_func)
def _create_chain(self):
chain = chainer.Chain(
l_conv1_1=L.Convolution2D(None,64,(3,3), pad=1),
l_norm1_1=L.BatchNormalization(64),
l_conv1_2=L.Convolution2D(64,64,(3,3), pad=1),
l_norm1_2=L.BatchNormalization(64),
l_conv1_3=L.Convolution2D(64,64,(3,3), pad=1),
l_norm1_3=L.BatchNormalization(64),
l_conv1_r=L.Convolution2D(None,64,(3,3), pad=1),
l_norm1_r=L.BatchNormalization(64),
l_conv2_1=L.Convolution2D(64,128,(3,3), pad=1),
l_norm2_1=L.BatchNormalization(128),
l_conv2_2=L.Convolution2D(128,128,(3,3), pad=1),
l_norm2_2=L.BatchNormalization(128),
l_conv2_3=L.Convolution2D(128,128,(3,3), pad=1),
l_norm2_3=L.BatchNormalization(128),
l_conv2_r=L.Convolution2D(64,128,(3,3), pad=1),
l_norm2_r=L.BatchNormalization(128),
l_conv3_1=L.Convolution2D(128,256,(3,3), pad=1),
l_norm3_1=L.BatchNormalization(256),
l_conv3_2=L.Convolution2D(256,256,(3,3), pad=1),
l_norm3_2=L.BatchNormalization(256),
l_conv3_3=L.Convolution2D(256,256,(3,3), pad=1),
l_norm3_3=L.BatchNormalization(256),
l_conv3_r=L.Convolution2D(128,256,(3,3), pad=1),
l_norm3_r=L.BatchNormalization(256),
l_conv4_1=L.Convolution2D(256,128,(3,3), pad=1),
l_norm4_1=L.BatchNormalization(128),
l_conv4_2=L.Convolution2D(128,128,(3,3), pad=1),
l_norm4_2=L.BatchNormalization(128),
l_conv4_3=L.Convolution2D(128,128,(3,3), pad=1),
l_norm4_3=L.BatchNormalization(128),
l_conv4_r=L.Convolution2D(256,128,(3,3), pad=1),
l_norm4_r=L.BatchNormalization(128),
l_phi=L.Linear(self.dimension, self.nb_class_train),
)
return chain
def __init__(self, hyperparams: HyperParameters):
assert isinstance(hyperparams, HyperParameters)
self.generation_network, self.generation_network_params = self.build_generation_network(
total_timestep=hyperparams.generator_total_timestep,
channels_chrz=hyperparams.channels_chz,
channels_u=hyperparams.generator_u_channels)
self.inference_network, self.inference_network_params = self.build_inference_network(
channels_chrz=hyperparams.channels_chz)
self.representation_network, self.representation_network_params = self.build_representation_network(
architecture=hyperparams.representation_architecture,
channels_r=hyperparams.channels_r)
self.parameters = chainer.Chain(
g=self.generation_network_params,
i=self.inference_network_params,
r=self.representation_network_params,
)
def initModel(self):
self.model = chainer.Chain(
encoderEmbed=L.EmbedID(self.encVocabSize,
self.eDim_enc), # encoder embedding layer
decoderEmbed=L.EmbedID(self.decVocabSize,
self.eDim_dec), # decoder embedding layer
decOutputL=L.Linear(self.hDim, self.decVocabSize), # output layer
encoder_bak=L.NStepLSTM(
n_layers=self.n_layers,
in_size=self.eDim_enc,
out_size=self.hDim,
dropout=self.dropout_rate), # encoder backward
encoder_fwd=L.NStepLSTM(
n_layers=self.n_layers,
in_size=self.eDim_enc,
out_size=self.hDim,
dropout=self.dropout_rate), # encoder forward
decoder_=NLayerLSTM(eDim=self.eDim_dec, hDim=self.hDim), # decoder
attnIn=L.Linear(self.hDim, self.hDim, nobias=True), # attn
attnOut=L.Linear(self.hDim + self.hDim, self.hDim,
nobias=True) # attn
)
def __init__(self,
n_input_channels,
n_hidden_layers,
n_hidden_channels,
action_size,
min_action=None,
max_action=None,
bound_action=True):
self.n_input_channels = n_input_channels
self.n_hidden_layers = n_hidden_layers
self.n_hidden_channels = n_hidden_channels
self.action_size = action_size
self.min_action = min_action
self.max_action = max_action
self.bound_action = bound_action
if self.bound_action:
action_filter = lambda x: bound_by_tanh(x, self.min_action, self.
max_action)
else:
action_filter = None
model = chainer.Chain(
fc=MLP(self.n_input_channels, n_hidden_channels,
(self.n_hidden_channels, ) * self.n_hidden_layers),
lstm=L.LSTM(n_hidden_channels, n_hidden_channels),
out=L.Linear(n_hidden_channels, action_size),
)
def model_call(model, x):
h = F.relu(model.fc(x))
h = model.lstm(h)
h = model.out(h)
return h
super().__init__(model=model,
model_call=model_call,
action_filter=action_filter)
def __init__(self, hyperparams: HyperParameters, hdf5_path=None):
assert isinstance(hyperparams, HyperParameters)
self.generation_steps = hyperparams.generator_generation_steps
self.hyperparams = hyperparams
self.generation_cores, self.generation_prior, self.generation_observation, self.generation_params = self.build_generation_network(
generation_steps=self.generation_steps,
channels_chz=hyperparams.channels_chz,
channels_u=hyperparams.generator_u_channels)
self.inference_cores, self.inference_posterior, self.inference_downsampler, self.inference_params = self.build_inference_network(
generation_steps=self.generation_steps,
channels_chz=hyperparams.channels_chz,
channels_map_x=hyperparams.inference_channels_map_x)
self.representation_network, self.representation_params = self.build_representation_network(
architecture=hyperparams.representation_architecture,
channels_r=hyperparams.channels_r)
if hdf5_path:
try:
load_hdf5(
os.path.join(hdf5_path, "generation.hdf5"),
self.generation_params)
load_hdf5(
os.path.join(hdf5_path, "inference.hdf5"),
self.inference_params)
load_hdf5(
os.path.join(hdf5_path, "representation.hdf5"),
self.representation_params)
except:
pass
self.parameters = chainer.Chain()
with self.parameters.init_scope():
self.parameters.generation = self.generation_params
self.parameters.inference = self.inference_params
self.parameters.representation = self.representation_params
print("------------")
# print("x_train", x_train)
# print("y_train", y_train)
# print(y_train)
# print(y_test)
N = len(x_train) # train data size
in_units = x_train.shape[1] # 入力層のユニット数 (語彙数)
print("学習データ数:", N)
n_units = args.units # 隠れ層のユニット数
n_label = 2 # 出力層のユニット数
#モデルの定義
model = chainer.Chain(l1=L.Linear(in_units, n_units),
l2=L.Linear(n_units, n_units),
l3=L.Linear(n_units, n_label))
# #GPUを使うかどうか
# if args.gpu > 0:
# cuda.check_cuda_available()
# cuda.get_device(args.gpu).use()
# model.to_gpu()
# xp = np if args.gpu <= 0 else cuda.cupy #args.gpu <= 0: use cpu, otherwise: use gpu
xp = np
batchsize = args.batchsize
n_epoch = args.epoch
def forward(x, t, train=True):
