Python源码示例：chainer.links.Linear()
示例1
def __init__(self, n_actions, max_episode_steps):
super().__init__()
with self.init_scope():
self.embed = L.EmbedID(max_episode_steps + 1, 3136)
self.image2hidden = chainerrl.links.Sequence(
L.Convolution2D(None, 32, 8, stride=4),
F.relu,
L.Convolution2D(None, 64, 4, stride=2),
F.relu,
L.Convolution2D(None, 64, 3, stride=1),
functools.partial(F.reshape, shape=(-1, 3136)),
)
self.hidden2out = chainerrl.links.Sequence(
L.Linear(None, 512),
F.relu,
L.Linear(None, n_actions),
DiscreteActionValue,
)
示例2
def parse_arch(arch, n_actions):
if arch == 'nature':
return links.Sequence(
links.NatureDQNHead(),
L.Linear(512, n_actions),
DiscreteActionValue)
elif arch == 'doubledqn':
return links.Sequence(
links.NatureDQNHead(),
L.Linear(512, n_actions, nobias=True),
SingleSharedBias(),
DiscreteActionValue)
elif arch == 'nips':
return links.Sequence(
links.NIPSDQNHead(),
L.Linear(256, n_actions),
DiscreteActionValue)
elif arch == 'dueling':
return DuelingDQN(n_actions)
else:
raise RuntimeError('Not supported architecture: {}'.format(arch))
示例3
def parse_arch(arch, n_actions):
if arch == 'nature':
return links.Sequence(
links.NatureDQNHead(),
L.Linear(512, n_actions),
DiscreteActionValue)
elif arch == 'doubledqn':
return links.Sequence(
links.NatureDQNHead(),
L.Linear(512, n_actions, nobias=True),
SingleSharedBias(),
DiscreteActionValue)
elif arch == 'nips':
return links.Sequence(
links.NIPSDQNHead(),
L.Linear(256, n_actions),
DiscreteActionValue)
elif arch == 'dueling':
return DuelingDQN(n_actions)
else:
raise RuntimeError('Not supported architecture: {}'.format(arch))
示例4
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 = Sequence(
L.Linear(n_dim_obs, n_hidden_channels),
F.relu,
L.Linear(n_hidden_channels, n_hidden_channels),
F.relu,
L.LSTM(n_hidden_channels, n_hidden_channels),
policies.FCGaussianPolicy(
n_input_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.FCLSTMSAQFunction(
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)
示例5
def make_q_func(self, env):
obs_size = env.observation_space.low.size
hidden_size = 64
return iqn.StatelessRecurrentImplicitQuantileQFunction(
psi=chainerrl.links.StatelessRecurrentSequential(
L.Linear(obs_size, hidden_size),
F.relu,
L.NStepRNNTanh(1, hidden_size, hidden_size, 0),
),
phi=chainerrl.links.Sequence(
chainerrl.agents.iqn.CosineBasisLinear(32, hidden_size),
F.relu,
),
f=L.Linear(hidden_size, env.action_space.n,
initialW=chainer.initializers.LeCunNormal(1e-1)),
)
示例6
def test_manual(self):
link1 = L.Linear(2, 3)
link2 = L.Linear(2, 5)
link3 = chainer.Sequential(
L.Linear(2, 7),
F.tanh,
)
plink = Branched(link1, link2, link3)
x = np.zeros((self.batch_size, 2), dtype=np.float32)
pout = plink(x)
self.assertIsInstance(pout, tuple)
self.assertEqual(len(pout), 3)
out1 = link1(x)
out2 = link2(x)
out3 = link3(x)
np.testing.assert_allclose(pout[0].array, out1.array)
np.testing.assert_allclose(pout[1].array, out2.array)
np.testing.assert_allclose(pout[2].array, out3.array)
示例7
def test(self):
# Check if it can properly detect recurrent child links
link = stateless_recurrent.StatelessRecurrentChainList(
L.Linear(3, 4),
L.NStepLSTM(1, 3, 2, 0),
L.Linear(4, 5),
stateless_recurrent.StatelessRecurrentChainList(
L.NStepRNNTanh(1, 2, 5, 0),
),
)
self.assertEqual(len(link.recurrent_children), 2)
self.assertIs(link.recurrent_children[0], link[1])
self.assertIs(link.recurrent_children[1], link[3])
self.assertEqual(len(link.recurrent_children[1].recurrent_children), 1)
self.assertIs(
link.recurrent_children[1].recurrent_children[0], link[3][0])
示例8
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)
示例9
def test_copy_param(self):
a = L.Linear(1, 5)
b = L.Linear(1, 5)
s = chainer.Variable(np.random.rand(1, 1).astype(np.float32))
a_out = list(a(s).array.ravel())
b_out = list(b(s).array.ravel())
self.assertNotEqual(a_out, b_out)
# Copy b's parameters to a
copy_param.copy_param(a, b)
a_out_new = list(a(s).array.ravel())
b_out_new = list(b(s).array.ravel())
self.assertEqual(a_out_new, b_out)
self.assertEqual(b_out_new, b_out)
示例10
def test_soft_copy_param(self):
a = L.Linear(1, 5)
b = L.Linear(1, 5)
a.W.array[:] = 0.5
b.W.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.W.array, np.full(a.W.shape, 0.55))
np.testing.assert_almost_equal(b.W.array, np.full(b.W.shape, 1.0))
copy_param.soft_copy_param(target_link=a, source_link=b, tau=0.1)
np.testing.assert_almost_equal(a.W.array, np.full(a.W.shape, 0.595))
np.testing.assert_almost_equal(b.W.array, np.full(b.W.shape, 1.0))
示例11
def __init__(self, n_input_channels, n_dim_action, n_hidden_channels,
n_hidden_layers, action_space, scale_mu=True,
normalize_input=True):
self.n_input_channels = n_input_channels
self.n_hidden_layers = n_hidden_layers
self.n_hidden_channels = n_hidden_channels
assert action_space is not None
self.scale_mu = scale_mu
self.action_space = action_space
super().__init__()
with self.init_scope():
assert n_hidden_layers >= 1
self.hidden_layers = MLPBN(
in_size=n_input_channels, out_size=n_hidden_channels,
hidden_sizes=[n_hidden_channels] * (n_hidden_layers - 1),
normalize_input=normalize_input)
self.v = L.Linear(n_hidden_channels, 1)
self.mu = L.Linear(n_hidden_channels, n_dim_action)
self.mat_diag = L.Linear(n_hidden_channels, n_dim_action)
non_diag_size = n_dim_action * (n_dim_action - 1) // 2
if non_diag_size > 0:
self.mat_non_diag = L.Linear(n_hidden_channels, non_diag_size)
示例12
def __init__(self, mu_link, sigma_scale=0.4):
super(FactorizedNoisyLinear, self).__init__()
self._kernel = None
self.out_size = mu_link.out_size
self.nobias = not ('/b' in [name for name, _ in mu_link.namedparams()])
W_data = mu_link.W.array
in_size = None if W_data is None else W_data.shape[1]
device_id = mu_link._device_id
with self.init_scope():
self.mu = L.Linear(in_size, self.out_size, self.nobias,
initialW=LeCunUniform(1 / numpy.sqrt(3)))
self.sigma = L.Linear(in_size, self.out_size, self.nobias,
initialW=VarianceScalingConstant(
sigma_scale),
initial_bias=VarianceScalingConstant(
sigma_scale))
if device_id is not None:
self.to_gpu(device_id)
示例13
def __init__(self, in_size, out_size, hidden_sizes, nonlinearity=F.relu,
last_wscale=1):
self.in_size = in_size
self.out_size = out_size
self.hidden_sizes = hidden_sizes
self.nonlinearity = nonlinearity
super().__init__()
with self.init_scope():
if hidden_sizes:
hidden_layers = []
hidden_layers.append(L.Linear(in_size, hidden_sizes[0]))
for hin, hout in zip(hidden_sizes, hidden_sizes[1:]):
hidden_layers.append(L.Linear(hin, hout))
self.hidden_layers = chainer.ChainList(*hidden_layers)
self.output = L.Linear(hidden_sizes[-1], out_size,
initialW=LeCunNormal(last_wscale))
else:
self.output = L.Linear(in_size, out_size,
initialW=LeCunNormal(last_wscale))
示例14
def __init__(self):
super(VGG_multi, self).__init__(
conv1_1=L.Convolution2D(3, 64, 3, stride=1, pad=1),
conv1_2=L.Convolution2D(64, 64, 3, stride=1, pad=1),
conv2_1=L.Convolution2D(64, 128, 3, stride=1, pad=1),
conv2_2=L.Convolution2D(128, 128, 3, stride=1, pad=1),
conv3_1=L.Convolution2D(128, 256, 3, stride=1, pad=1),
conv3_2=L.Convolution2D(256, 256, 3, stride=1, pad=1),
conv3_3=L.Convolution2D(256, 256, 3, stride=1, pad=1),
conv4_1=L.Convolution2D(256, 512, 3, stride=1, pad=1),
conv4_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv4_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_1=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),
fc6=L.Linear(2048, 4096),
fc7=L.Linear(4096, 4096),
fc8=L.Linear(4096, 768),
)
self.train = True
示例15
def __init__(self):
super(VGG_single, self).__init__(
conv1_1=L.Convolution2D(3, 64, 3, stride=1, pad=1),
conv1_2=L.Convolution2D(64, 64, 3, stride=1, pad=1),
conv2_1=L.Convolution2D(64, 128, 3, stride=1, pad=1),
conv2_2=L.Convolution2D(128, 128, 3, stride=1, pad=1),
conv3_1=L.Convolution2D(128, 256, 3, stride=1, pad=1),
conv3_2=L.Convolution2D(256, 256, 3, stride=1, pad=1),
conv3_3=L.Convolution2D(256, 256, 3, stride=1, pad=1),
conv4_1=L.Convolution2D(256, 512, 3, stride=1, pad=1),
conv4_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv4_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_1=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),
fc6=L.Linear(2048, 4096),
fc7=L.Linear(4096, 4096),
fc8=L.Linear(4096, 256),
)
self.train = True
示例16
def __init__(self, obs_size, n_actions, n_hidden_channels=[1024,256]):
super(QFunction,self).__init__()
net = []
inpdim = obs_size
for i,n_hid in enumerate(n_hidden_channels):
net += [ ('l{}'.format(i), L.Linear( inpdim, n_hid ) ) ]
net += [ ('norm{}'.format(i), L.BatchNormalization( n_hid ) ) ]
net += [ ('_act{}'.format(i), F.relu ) ]
inpdim = n_hid
net += [('output', L.Linear( inpdim, n_actions) )]
with self.init_scope():
for n in net:
if not n[0].startswith('_'):
setattr(self, n[0], n[1])
self.forward = net
示例17
def __init__(self, n_input_channels, n_actions,
n_hidden_layers=0, n_hidden_channels=None):
self.n_input_channels = n_input_channels
self.n_actions = n_actions
self.n_hidden_layers = n_hidden_layers
self.n_hidden_channels = n_hidden_channels
layers = []
if n_hidden_layers > 0:
layers.append(L.Linear(n_input_channels, n_hidden_channels))
for i in range(n_hidden_layers - 1):
layers.append(L.Linear(n_hidden_channels, n_hidden_channels))
layers.append(L.Linear(n_hidden_channels, n_actions))
else:
layers.append(L.Linear(n_input_channels, n_actions))
super(FCSoftmaxPolicy, self).__init__(*layers)
示例18
def init_like_torch(link):
# Mimic torch's default parameter initialization
# TODO(muupan): Use chainer's initializers when it is merged
for l in link.links():
if isinstance(l, L.Linear):
out_channels, in_channels = l.W.data.shape
stdv = 1 / np.sqrt(in_channels)
l.W.data[:] = np.random.uniform(-stdv, stdv, size=l.W.data.shape)
if l.b is not None:
l.b.data[:] = np.random.uniform(-stdv, stdv,
size=l.b.data.shape)
elif isinstance(l, L.Convolution2D):
out_channels, in_channels, kh, kw = l.W.data.shape
stdv = 1 / np.sqrt(in_channels * kh * kw)
l.W.data[:] = np.random.uniform(-stdv, stdv, size=l.W.data.shape)
if l.b is not None:
l.b.data[:] = np.random.uniform(-stdv, stdv,
size=l.b.data.shape)
示例19
def __init__(self, n_input_channels, n_hidden_layers=0,
n_hidden_channels=None):
self.n_input_channels = n_input_channels
self.n_hidden_layers = n_hidden_layers
self.n_hidden_channels = n_hidden_channels
layers = []
if n_hidden_layers > 0:
layers.append(L.Linear(n_input_channels, n_hidden_channels))
for i in range(n_hidden_layers - 1):
layers.append(L.Linear(n_hidden_channels, n_hidden_channels))
layers.append(L.Linear(n_hidden_channels, 1))
else:
layers.append(L.Linear(n_input_channels, 1))
super(FCVFunction, self).__init__(*layers)
示例20
def __init__(self, Hi, Ha, Ho, init_orth=False, prev_word_embedding_size = None):
super(AttentionModule, self).__init__(
al_lin_h=L.Linear(Hi, Ha, nobias=False),
al_lin_s=L.Linear(Ho, Ha, nobias=True),
al_lin_o=L.Linear(Ha, 1, nobias=True)
)
self.Hi = Hi
self.Ha = Ha
if prev_word_embedding_size is not None:
self.add_link("al_lin_y", L.Linear(prev_word_embedding_size, Ha))
if init_orth:
ortho_init(self.al_lin_h)
ortho_init(self.al_lin_s)
ortho_init(self.al_lin_o)
示例21
def __init__(self, d_model = 512, n_heads = 8, experimental_relu=False, dropout=None):
if d_model%n_heads != 0:
raise ValueError("d_model(%i) should be divisible by n_head(%i)"%(d_model, n_heads))
super(ConstantSizeMultiBatchMultiHeadAttention, self).__init__(
w_Q = L.Linear(d_model, d_model, nobias=False),
w_K = L.Linear(d_model, d_model, nobias=True),
w_V = L.Linear(d_model, d_model, nobias=False),
)
if n_heads >= 2:
self.add_link("w_O", L.Linear(d_model, d_model)) #if n_heads == 1, it is redundant with w_V
self.d_model = d_model
self.n_heads = n_heads
self.head_size = d_model // n_heads
scaling_factor = 1.0 / self.xp.sqrt(self.xp.array([[[[self.head_size]]]], dtype=self.xp.float32))
self.add_persistent("scaling_factor", scaling_factor) #added as persistent so that it works with to_gpu/to_cpu
self.experimental_relu = experimental_relu
self.dropout = dropout
示例22
def __init__(self, V, d_model=512, n_heads=8, d_ff=2048, experimental_relu=False, dropout=None, nb_layers=6,
residual_mode="normal", no_normalize=False):
super(Decoder, self).__init__(
emb = L.EmbedID(V, d_model),
encoding_layers = DecoderMultiLayer(d_model, n_heads, d_ff=d_ff,
experimental_relu=experimental_relu,
dropout=dropout, nb_layers=nb_layers,
residual_mode=residual_mode, no_normalize=no_normalize),
logits_layer = L.Linear(d_model, V + 1)
)
self.dropout = dropout
self.n_heads = n_heads
self.d_model = d_model
self.cached_pos_vect = None
self.add_param("bos_encoding", (1, 1, d_model))
self.bos_encoding.data[...] = np.random.randn(d_model)
self.V = V
self.eos_idx = V
示例23
def __init__(self, n_class=1000):
super(VGG16, self).__init__(
conv1_1=L.Convolution2D(3, 64, 3, stride=1, pad=1),
conv1_2=L.Convolution2D(64, 64, 3, stride=1, pad=1),
conv2_1=L.Convolution2D(64, 128, 3, stride=1, pad=1),
conv2_2=L.Convolution2D(128, 128, 3, stride=1, pad=1),
conv3_1=L.Convolution2D(128, 256, 3, stride=1, pad=1),
conv3_2=L.Convolution2D(256, 256, 3, stride=1, pad=1),
conv3_3=L.Convolution2D(256, 256, 3, stride=1, pad=1),
conv4_1=L.Convolution2D(256, 512, 3, stride=1, pad=1),
conv4_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv4_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_1=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),
fc6=L.Linear(25088, 4096),
fc7=L.Linear(4096, 4096),
fc8=L.Linear(4096, 1000)
)
示例24
def __init__(self, label_count):
super(Alex, self).__init__(
conv1=L.Convolution2D(3, 96, 11, stride=4),
conv2=L.Convolution2D(96, 256, 5, pad=2),
conv3=L.Convolution2D(256, 384, 3, pad=1),
conv4=L.Convolution2D(384, 384, 3, pad=1),
conv5=L.Convolution2D(384, 256, 3, pad=1),
fc6=L.Linear(9216, 4096),
fc7=L.Linear(4096, 4096),
fc8=L.Linear(4096, 1024),
fc9=L.Linear(1024, label_count)
)
# extend a little layer
self.train = True
示例25
def __init__(self, in_ch, out_ch, width, activation=F.leaky_relu, dr=None):
super(L1DBlock, self).__init__()
initializer = chainer.initializers.GlorotUniform()
self.activation = activation
self.dr = dr
self.out_ch = out_ch
with self.init_scope():
self.l = L.Linear(in_ch*width, out_ch*width, initialW=initializer)
示例26
def __init__(self, n_units, n_out):
super(MLP, self).__init__()
with self.init_scope():
# the size of the inputs to each layer will be inferred
self.l1 = L.Linear(None, n_units) # n_in -> n_units
self.l2 = L.Linear(None, n_units) # n_units -> n_units
self.l3 = L.Linear(None, n_out) # n_units -> n_out
示例27
def __init__(self, obs_size, action_size, hidden_size=200, lstm_size=128):
self.pi_head = L.Linear(obs_size, hidden_size)
self.v_head = L.Linear(obs_size, hidden_size)
self.pi_lstm = L.LSTM(hidden_size, lstm_size)
self.v_lstm = L.LSTM(hidden_size, lstm_size)
self.pi = policies.FCGaussianPolicy(lstm_size, action_size)
self.v = v_function.FCVFunction(lstm_size)
super().__init__(self.pi_head, self.v_head,
self.pi_lstm, self.v_lstm, self.pi, self.v)
示例28
def make_q_func(self, env):
obs_size = env.observation_space.low.size
hidden_size = 64
return iqn.ImplicitQuantileQFunction(
psi=chainerrl.links.Sequence(
L.Linear(obs_size, hidden_size),
F.relu,
),
phi=chainerrl.links.Sequence(
chainerrl.agents.iqn.CosineBasisLinear(32, hidden_size),
F.relu,
),
f=L.Linear(hidden_size, env.action_space.n),
)
示例29
def make_q_func(self, env):
obs_size = env.observation_space.low.size
hidden_size = 64
return iqn.ImplicitQuantileQFunction(
psi=chainerrl.links.Sequence(
L.Linear(obs_size, hidden_size),
F.relu,
),
phi=chainerrl.links.Sequence(
iqn.CosineBasisLinear(32, hidden_size),
F.relu,
),
f=L.Linear(hidden_size, env.action_space.n),
)
示例30
def make_q_func(self, env):
n_hidden_channels = 10
return StatelessRecurrentSequential(
L.Linear(env.observation_space.low.size, n_hidden_channels),
F.elu,
L.NStepRNNTanh(1, n_hidden_channels, n_hidden_channels, 0),
L.Linear(n_hidden_channels, env.action_space.n),
DiscreteActionValue,
)
