def build_network(self, output_dim=1):
config.check()
wscale = config.q_wscale
# Fully connected part of Q-Network
fc_attributes = {}
fc_units = [(34 * config.rl_history_length, config.q_fc_hidden_units[0])]
fc_units += zip(config.q_fc_hidden_units[:-1], config.q_fc_hidden_units[1:])
fc_units += [(config.q_fc_hidden_units[-1], output_dim)]
for i, (n_in, n_out) in enumerate(fc_units):
fc_attributes["layer_%i" % i] = L.Linear(n_in, n_out, wscale=wscale)
fc_attributes["batchnorm_%i" % i] = L.BatchNormalization(n_out)
fc = FullyConnectedNetwork(**fc_attributes)
fc.n_hidden_layers = len(fc_units) - 1
fc.activation_function = config.q_fc_activation_function
fc.apply_batchnorm = config.apply_batchnorm
fc.apply_dropout = config.q_fc_apply_dropout
fc.apply_batchnorm_to_input = config.q_fc_apply_batchnorm_to_input
if config.use_gpu:
fc.to_gpu()
return fc
python类Linear()的实例源码
def _setup_inner_product(self, layer):
param = layer.inner_product_param
bias_term = param.bias_term
if param.axis != 1:
raise RuntimeError(
'Non-default axis in InnerProduct is not supported')
blobs = layer.blobs
width, height = _get_width(blobs[0]), _get_height(blobs[0])
func = links.Linear(width, height, nobias=not bias_term)
func.W.data.ravel()[:] = blobs[0].data
if bias_term:
func.b.data[:] = blobs[1].data
self.add_link(layer.name, func)
self.forwards[layer.name] = _CallChildLink(self, layer.name)
self._add_layer(layer)
def __init__(self):
super(GoogLeNet, self).__init__(
conv1=L.Convolution2D(3, 64, 7, stride=2, pad=3),
conv2_reduce=L.Convolution2D(64, 64, 1),
conv2=L.Convolution2D(64, 192, 3, stride=1, pad=1),
inc3a=L.Inception(192, 64, 96, 128, 16, 32, 32),
inc3b=L.Inception(256, 128, 128, 192, 32, 96, 64),
inc4a=L.Inception(480, 192, 96, 208, 16, 48, 64),
inc4b=L.Inception(512, 160, 112, 224, 24, 64, 64),
inc4c=L.Inception(512, 128, 128, 256, 24, 64, 64),
inc4d=L.Inception(512, 112, 144, 288, 32, 64, 64),
inc4e=L.Inception(528, 256, 160, 320, 32, 128, 128),
inc5a=L.Inception(832, 256, 160, 320, 32, 128, 128),
inc5b=L.Inception(832, 384, 192, 384, 48, 128, 128),
loss3_fc=L.Linear(1024, 1000),
loss1_conv=L.Convolution2D(512, 128, 1),
loss1_fc1=L.Linear(4 * 4 * 128, 1024),
loss1_fc2=L.Linear(1024, 1000),
loss2_conv=L.Convolution2D(528, 128, 1),
loss2_fc1=L.Linear(4 * 4 * 128, 1024),
loss2_fc2=L.Linear(1024, 1000)
)
self.train = True
def setUp(self):
in_size = numpy.prod(self.in_shape)
self.link = links.Linear(in_size, self.out_size)
W = self.link.W.data
W[...] = numpy.random.uniform(-1, 1, W.shape)
b = self.link.b.data
b[...] = numpy.random.uniform(-1, 1, b.shape)
self.link.zerograds()
self.W = W.copy() # fixed on CPU
self.b = b.copy() # fixed on CPU
x_shape = (4,) + self.in_shape
self.x = numpy.random.uniform(-1, 1, x_shape).astype(numpy.float32)
self.gy = numpy.random.uniform(
-1, 1, (4, self.out_size)).astype(numpy.float32)
self.y = self.x.reshape(4, -1).dot(W.T) + b
def __init__(self, input_num, hidden_num,num_of_actions):
self.input_num = input_num
self.hidden_num = hidden_num
self.num_of_actions = num_of_actions
self.agent_state_dim = 4
self.market_state_dim = input_num - self.agent_state_dim
assert self.market_state_dim > 0
super(Q_DNN, self).__init__(
a1=L.Linear(self.agent_state_dim, 2),
a2=L.Linear(2, 2),
a3=L.Linear(2, 2),
s1=L.Linear(self.market_state_dim, self.hidden_num),
s2=L.Linear(self.hidden_num, self.hidden_num),
s3=L.Linear(self.hidden_num, self.hidden_num),
fc4=L.Linear(self.hidden_num + 2, self.hidden_num),
fc5=L.Linear(self.hidden_num, self.hidden_num),
q_value=L.Linear(self.hidden_num, self.num_of_actions,
initialW=np.zeros((self.num_of_actions, self.hidden_num),
dtype=np.float32))
)
def __init__(self, input_num, hidden_num,num_of_actions):
self.input_num = input_num
self.hidden_num = hidden_num
self.num_of_actions = num_of_actions
super(Q_DNN, self).__init__(
fc1=L.Linear(self.input_num, self.hidden_num),
bn1=L.BatchNormalization(self.hidden_num),
fc2=L.Linear(self.hidden_num, self.hidden_num),
bn2=L.BatchNormalization(self.hidden_num),
fc3=L.Linear(self.hidden_num, self.hidden_num),
bn3=L.BatchNormalization(self.hidden_num),
fc4=L.Linear(self.hidden_num, self.hidden_num),
bn4=L.BatchNormalization(self.hidden_num),
fc5=L.Linear(self.hidden_num, self.hidden_num),
bn5=L.BatchNormalization(self.hidden_num),
q_value=L.Linear(self.hidden_num, self.num_of_actions,
initialW=np.zeros((self.num_of_actions, self.hidden_num),
dtype=np.float32))
)
def __init__(self, input_num, hidden_num,num_of_actions):
self.input_num = input_num
self.hidden_num = hidden_num
self.num_of_actions = num_of_actions
super(Q_DNN, self).__init__(
fc1=L.Linear(self.input_num, self.hidden_num),
fc2=L.Linear(self.hidden_num, self.hidden_num),
fc3=L.Linear(self.hidden_num, self.hidden_num),
fc4=L.Linear(self.hidden_num, self.hidden_num),
fc5=L.Linear(self.hidden_num, self.hidden_num),
q_value=L.Linear(self.hidden_num, self.num_of_actions,
initialW=np.zeros((self.num_of_actions, self.hidden_num),
dtype=np.float32))
)
def __init__(self, input_num, hidden_num,num_of_actions):
self.input_num = input_num
self.hidden_num = hidden_num
self.num_of_actions = num_of_actions
super(Q_DNN, self).__init__(
fc1=L.Linear(self.input_num, self.hidden_num),
fc2=L.Linear(self.hidden_num, self.hidden_num),
fc3=L.Linear(self.hidden_num, self.hidden_num),
fc4=L.Linear(self.hidden_num, self.hidden_num),
fc5=L.Linear(self.hidden_num, self.hidden_num),
q_value=L.Linear(self.hidden_num, self.num_of_actions,
initialW=np.zeros((self.num_of_actions, self.hidden_num),
dtype=np.float32))
)
def __init__(self, out_dim):
super(SimpleConvnet, self).__init__(
conv1=L.Convolution2D(3, 50, 3),
bn_conv1=L.BatchNormalization(50),
conv21=L.Convolution2D(50, 100, 3),
bn_conv21=L.BatchNormalization(100),
conv22=L.Convolution2D(100, 100, 1),
bn_conv22=L.BatchNormalization(100),
conv31=L.Convolution2D(100, 200, 3),
bn_conv31=L.BatchNormalization(200),
conv32=L.Convolution2D(200, 200, 3),
bn_conv32=L.BatchNormalization(200),
conv41=L.Convolution2D(200, 400, 3),
bn_conv41=L.BatchNormalization(400),
conv42=L.Convolution2D(400, 400, 1),
bn_conv42=L.BatchNormalization(400),
conv5=L.Convolution2D(400, 400, 1),
bn_conv5=L.BatchNormalization(400),
conv6=L.Convolution2D(400, 400, 1),
bn_conv6=L.BatchNormalization(400),
linear1=L.Linear(400, 400),
bn_linear1=L.BatchNormalization(400),
linear2=L.Linear(400, out_dim)
)
def __init__(
self,
src_vocab_size,
trg_vocab_size,
embed_size,
hidden_size):
super(SimpleEncoderDecoder, self).__init__(
# Encoder
x_i = L.EmbedID(src_vocab_size, embed_size),
i_p = L.Linear(embed_size, 4 * hidden_size, nobias=True),
p_p = L.Linear(hidden_size, 4 * hidden_size),
# Decoder initializer
pc_qc = L.Linear(hidden_size, hidden_size),
p_q = L.Linear(hidden_size, hidden_size),
# Decoder
y_j = L.EmbedID(trg_vocab_size, embed_size),
j_q = L.Linear(embed_size, 4 * hidden_size, nobias=True),
q_q = L.Linear(hidden_size, 4 * hidden_size),
q_z = L.Linear(hidden_size, trg_vocab_size))
self.src_vocab_size = src_vocab_size
self.trg_vocab_size = trg_vocab_size
self.embed_size = embed_size
self.hidden_size = hidden_size
def __init__(self, n_layers, n_units, width=3, dropout=0.2):
super(ConvGLUDecoder, self).__init__()
links = [('l{}'.format(i + 1),
ConvGLU(n_units, width=width,
dropout=dropout, nopad=True))
for i in range(n_layers)]
for link in links:
self.add_link(*link)
self.conv_names = [name for name, _ in links]
self.width = width
init_preatt = VarInNormal(1.)
links = [('preatt{}'.format(i + 1),
L.Linear(n_units, n_units, initialW=init_preatt))
for i in range(n_layers)]
for link in links:
self.add_link(*link)
self.preatt_names = [name for name, _ in links]
def __init__(self, n_layers, n_source_vocab, n_target_vocab, n_units,
max_length=50, dropout=0.2, width=3):
init_emb = chainer.initializers.Normal(0.1)
init_out = VarInNormal(1.)
super(Seq2seq, self).__init__(
embed_x=L.EmbedID(n_source_vocab, n_units, ignore_label=-1,
initialW=init_emb),
embed_y=L.EmbedID(n_target_vocab, n_units, ignore_label=-1,
initialW=init_emb),
embed_position_x=L.EmbedID(max_length, n_units,
initialW=init_emb),
embed_position_y=L.EmbedID(max_length, n_units,
initialW=init_emb),
encoder=ConvGLUEncoder(n_layers, n_units, width, dropout),
decoder=ConvGLUDecoder(n_layers, n_units, width, dropout),
W=L.Linear(n_units, n_target_vocab, initialW=init_out),
)
self.n_layers = n_layers
self.n_units = n_units
self.n_target_vocab = n_target_vocab
self.max_length = max_length
self.width = width
self.dropout = dropout
def __init__(self, n_outputs, train=True):
super(ImageNet, self).__init__(
conv1=L.Convolution2D(None, 96, 11, stride=4),
bn1=L.BatchNormalization(96),
conv2=L.Convolution2D(None, 128, 5, pad=2),
bn2=L.BatchNormalization(128),
conv3=L.Convolution2D(None, 256, 3, pad=1),
conv4=L.Convolution2D(None, 384, 3, pad=1),
l5=L.Linear(None, 512),
l6=L.Linear(512, n_outputs),
)
for param in self.params():
param.data[...] = np.random.uniform(-0.1, 0.1, param.data.shape)
self.train = train
def __init__(self):
super(VGGNet, 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)
)
self.train = False
def __init__(self):
super(CNN_Drop, self).__init__(
# input 3 channel of 32*32
conv1_1=L.Convolution2D(3, 64, 3, pad=1),
conv1_2=L.Convolution2D(64, 64, 3, pad=1),
conv2_1=L.Convolution2D(64, 128, 3, pad=1),
conv2_2=L.Convolution2D(128, 128, 3, pad=1),
conv3_1=L.Convolution2D(128, 256, 3, pad=1),
conv3_2=L.Convolution2D(256, 256, 3, pad=1),
conv3_3=L.Convolution2D(256, 256, 3, pad=1),
conv3_4=L.Convolution2D(256, 256, 3, pad=1),
fc4 = L.Linear(256*4*4, 500),
fc5 = L.Linear(500, 500),
fc6 = L.Linear(500,10),
)
def __init__(self):
super(CNN_Pooling, self).__init__(
# input 3 channel of 32*32
conv1_1=L.Convolution2D(3, 64, 3, pad=1),
conv1_2=L.Convolution2D(64, 64, 3, pad=1),
conv2_1=L.Convolution2D(64, 128, 3, pad=1),
conv2_2=L.Convolution2D(128, 128, 3, pad=1),
conv3_1=L.Convolution2D(128, 256, 3, pad=1),
conv3_2=L.Convolution2D(256, 256, 3, pad=1),
conv3_3=L.Convolution2D(256, 256, 3, pad=1),
conv3_4=L.Convolution2D(256, 256, 3, pad=1),
fc4 = L.Linear(256*4*4, 500),
fc5 = L.Linear(500, 500),
fc6 = L.Linear(500,10),
)
def __init__(self):
super(CNN_avePooling, self).__init__(
# input 3 channel of 32*32
conv1_1=L.Convolution2D(3, 64, 3, pad=1 ),
conv1_2=L.Convolution2D(64, 64, 3, pad=1),
conv2_1=L.Convolution2D(64, 128, 3, pad=1 ),
conv2_2=L.Convolution2D(128, 128, 3, pad=1),
conv3_1=L.Convolution2D(128, 256, 3, pad=1),
conv3_2=L.Convolution2D(256, 256, 3, pad=1),
conv3_3=L.Convolution2D(256, 256, 3, pad=1),
conv3_4=L.Convolution2D(256, 256, 3, pad=1),
fc4 = L.Linear(256*4*4, 500),
fc5 = L.Linear(500, 500),
fc6 = L.Linear(500,10),
)
def __init__(self):
super(VoxelChain, self).__init__(
conv1 = L.ConvolutionND(3, 1, 20, 5), # 1 input, 20 outputs, filter size 5 pixels
conv2 = L.ConvolutionND(3, 20, 20, 5), # 20 inputs, 20 outputs, filter size 5 pixels
fc3=L.Linear(2500, 1300),
fc4=L.Linear(1300, 10),
)
self.train = True
def __init__(self, h_units):
super(MLP, self).__init__(
l1=L.Linear(784, h_units),
l2=L.Linear(h_units, 10)
)
def __init__(self):
super(VGG, self).__init__()
with self.init_scope():
self.conv1_1 = L.Convolution2D(3, 64, 3, stride=1, pad=1)
self.conv1_2 = L.Convolution2D(64, 64, 3, stride=1, pad=1)
self.conv2_1 = L.Convolution2D(64, 128, 3, stride=1, pad=1)
self.conv2_2 = L.Convolution2D(128, 128, 3, stride=1, pad=1)
self.conv3_1 = L.Convolution2D(128, 256, 3, stride=1, pad=1)
self.conv3_2 = L.Convolution2D(256, 256, 3, stride=1, pad=1)
self.conv3_3 = L.Convolution2D(256, 256, 3, stride=1, pad=1)
self.conv4_1 = L.Convolution2D(256, 512, 3, stride=1, pad=1)
self.conv4_2 = L.Convolution2D(512, 512, 3, stride=1, pad=1)
self.conv4_3 = L.Convolution2D(512, 512, 3, stride=1, pad=1)
self.conv5_1 = L.Convolution2D(512, 512, 3, stride=1, pad=1)
self.conv5_2 = L.Convolution2D(512, 512, 3, stride=1, pad=1)
self.conv5_3 = L.Convolution2D(512, 512, 3, stride=1, pad=1)
self.fc6 = L.Linear(25088, 4096)
self.fc7 = L.Linear(4096, 4096)
self.fc8 = L.Linear(4096, 1000)
# Keep track of the pooling indices inside each function instance
self.conv_blocks = [
[self.conv1_1, self.conv1_2],
[self.conv2_1, self.conv2_2],
[self.conv3_1, self.conv3_2, self.conv3_3],
[self.conv4_1, self.conv4_2, self.conv4_3],
[self.conv5_1, self.conv5_2, self.conv5_3]
]
self.deconv_blocks = []
self.mps = [F.MaxPooling2D(2, 2) for _ in self.conv_blocks]
