def createMapImage(self):
"""Create a QImage containing all the different layers of the map."""
# create background, landscape and object layer
self.background_layer = Layers.BackgroundLayer()
self.landscape_layer = Layers.LandscapeLayer()
self.object_layer = Layers.ObjectLayer()
# create first tank
tank_one = Objects.Tank(0, 200, (self.height // 2),
100, 100, core.Qt.yellow, core.Qt.cyan)
self.tanks.append(tank_one)
self.getNewCoordinates(self.tanks[0].tank_id, 0)
# create second tank
tank_two = Objects.Tank(
1, (self.width - 200), (self.height // 2),
100, 100, core.Qt.black, core.Qt.red
)
self.tanks.append(tank_two)
self.getNewCoordinates(self.tanks[1].tank_id, 0)
# paint tanks
tmp_painter = gui.QPainter(self.object_layer)
tmp_painter.drawImage(self.tanks[0].x_position,
self.tanks[0].y_position, self.tanks[0])
tmp_painter.drawImage(self.tanks[1].x_position,
self.tanks[1].y_position, self.tanks[1])
tmp_painter.end()
# draw all layers
self.drawMap()
self.drawObjects()
self.drawGame()
self.setPixmap(gui.QPixmap.fromImage(self.game_image))
def __init__(self, input, batch_size, rng, n_kernels):
self.input = input
self.conv_pool_1 = Layers.conv_3x3(
input=self.input,
rng=rng,
input_shape=(batch_size, 1, 28, 28),
filter_shape_1=(n_kernels[0], 1, 3, 3),
filter_shape_2=(n_kernels[0], n_kernels[0], 3, 3),
pool_size=(2, 2)
)
self.conv_pool_2 = Layers.conv_3x3(
input=self.conv_pool_1.outputs,
rng=rng,
input_shape=(batch_size, n_kernels[0], 11, 11),
filter_shape_1=(n_kernels[1], n_kernels[0], 3, 3),
filter_shape_2=(n_kernels[1], n_kernels[1], 3, 3),
pool_size=(2, 2)
)
hidden_layer_input = self.conv_pool_2.outputs.flatten(2)
self.hidden_layer_1 = Layers.Hidden_layer(
input=hidden_layer_input,
rng=rng,
n_in=n_kernels[1] * 3 * 3,
n_out=192
)
self.softmax_layer = Layers.Logistic_layer(
input=self.hidden_layer_1.outputs,
rng=rng,
n_in=192,
n_out=10
)
self.results = self.softmax_layer.pred_y
self.params = self.conv_pool_1.params + self.conv_pool_2.params + self.hidden_layer_1.params + self.softmax_layer.params
def __init__(self, input, batch_size, rng, n_kernels):
self.input = input
self.conv_pool_1 = Layers.conv_pool_layer(
input=self.input,
rng=rng,
input_shape=(batch_size, 1, 28, 28),
filter_shape=(n_kernels[0], 1, 5, 5),
pool_size=(2, 2)
)
self.conv_pool_2 = Layers.conv_pool_layer(
input=self.conv_pool_1.outputs,
rng=rng,
input_shape=(batch_size, n_kernels[0], 12, 12),
filter_shape=(n_kernels[1], n_kernels[0], 3, 3),
pool_size=(2, 2)
)
hidden_layer_input = self.conv_pool_2.outputs.flatten(2)
self.hidden_layer_1 = Layers.Hidden_layer(
input=hidden_layer_input,
rng=rng,
n_in=n_kernels[1]*5*5,
n_out=500
)
self.softmax_layer = Layers.Logistic_layer(
input=self.hidden_layer_1.outputs,
rng=rng,
n_in=500,
n_out=10
)
self.results = self.softmax_layer.pred_y
self.params = self.conv_pool_1.params + self.conv_pool_2.params + self.hidden_layer_1.params + self.softmax_layer.params
def BL(template, dropout=0.1, regularizer=None, constraint=None):
"""
inputs
----
template: a list of network dimensions including input and output, e.g., [[40,10], [120,5], [3,1]]
dropout: dropout percentage
regularizer: keras regularizer object
constraint: keras constraint object
outputs
------
keras model object
"""
inputs = keras.layers.Input(template[0])
x = inputs
for k in range(1, len(template) - 1):
x = Layers.BL(template[k], regularizer, constraint)(x)
x = keras.layers.Activation('relu')(x)
x = keras.layers.Dropout(dropout)(x)
x = Layers.BL(template[-1], regularizer, constraint)(x)
outputs = keras.layers.Activation('softmax')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
optimizer = keras.optimizers.Adam(0.01)
model.compile(optimizer, 'categorical_crossentropy', [
'acc',
])
return model
def seq2seq_model(input_data, target_data, keep_prob, batch_size,
target_sequence_length,
max_target_word_length,
source_vocab_size, target_vocab_size,
enc_embedding_size, dec_embedding_size,
rnn_size, num_layers, target_vocab_to_int):
# Build the Sequence-to-Sequence model
# :return: Tuple of (Training BasicDecoderOutput, Inference BasicDecoderOutput)
enc_outputs, enc_states = Layers.encoding_layer(input_data,
rnn_size,
num_layers,
keep_prob,
source_vocab_size,
enc_embedding_size)
dec_input = Model_Inputs.process_decoder_input(target_data,
target_vocab_to_int,
batch_size)
train_output, infer_output = Layers.decoding_layer(dec_input,
enc_states,
target_sequence_length,
max_target_word_length,
rnn_size,
num_layers,
target_vocab_to_int,
target_vocab_size,
batch_size,
keep_prob,
dec_embedding_size)
return train_output, infer_output
def build_SIREN_model(dimensions):
actual_model = tf.keras.Sequential()
actual_model.add(Layers.FirstSirenLayer(dimensions[0], dimensions[1]))
other_layers = []
for dim0, dim1 in zip(dimensions[1:-2], dimensions[2:-1]):
actual_model.add(Layers.MiddleSirenLayer(dim0, dim1))
actual_model.add(Layers.FinalSirenLayer(dimensions[-2], dimensions[-1]))
return actual_model
def transition_layer(self, x, name): with tf.variable_scope(name): input_tensor_depth = int(x.get_shape()[-1]) output_depth = int(self.theta * input_tensor_depth) x = layers.batch_normalization(x, self.is_training, name = 'batch') x = tf.nn.relu(x) x = layers.convolution2d(x, 1, output_depth, weight_decay = CONV_WEIGHT_DECAY, bias = False, name = 'conv') x = tf.nn.dropout(x, self.keep_prob) x = layers.avg_pool_2d(x, kernel_size = 2, stride = 2, name="AvgPool2D") return x
def finalLayer(self, y, n_iters=1, learner_size=200):
print "Final Layer"
sigmoid = Layers.SigmoidLayer(self.X.shape[1],
learner_size,
noise=Noise.GaussianNoise(0.1))
softmax = Layers.SoftmaxLayer(learner_size, y.shape[1])
trainer = Trainer()
sigmoid, softmax = trainer.train([sigmoid, softmax], self.X, y,
n_iters)
self.Layers.append(sigmoid)
self.Layers.append(softmax)
def ConstructNet(tokens, leafCntString, Wleft, Wright, Bidx, tokenMap, numFea,
tokenNum):
leafCnt = leafCntString.split(' ')
for idx, cnt in enumerate(leafCnt):
leafCnt[idx] = int(leafCnt[idx])
totalLeaf = sum(leafCnt) + .0
leafCnt = np.array(leafCnt)
leafCnt = leafCnt / totalLeaf
layers = []
rootLayer = Lay.layer( tokens[0], \
range(numFea*tokenNum, numFea*(tokenNum+1) ),\
numFea,
)
totalChildren = len(tokens)
for idx in range(1, totalChildren):
childName = tokens[idx]
childIdx = tokenMap[childName]
# cunstruct node (layer)
childLayer = Lay.layer( name= childName,\
Bidx = range(numFea*childIdx, numFea*(childIdx+1)),\
numunit = numFea,
)
# add connection
if totalChildren == 2:
leftCoef = .5
rightCoef = .5
else:
rightCoef = (idx - 1.0) / (totalChildren - 2)
leftCoef = 1 - rightCoef
#print idx, len(leafCnt), len(tokens), leafCnt
leftCoef *= leafCnt[idx - 1]
rightCoef *= leafCnt[idx - 1]
if leftCoef != 0:
leftcon = Con.connection(childLayer, rootLayer, numFea, numFea,\
Wleft, leftCoef\
)
if rightCoef != 0:
rightcon = Con.connection(childLayer, rootLayer, numFea, numFea,\
Wright, rightCoef\
)
layers.append(childLayer)
# end of each layer
layers.append(rootLayer)
for idx in xrange(0, len(layers) - 1):
layers[idx].successiveUpper = layers[idx + 1]
layers[idx + 1].successiveLower = layers[idx]
return layers
def build_orthogonal_model_with_SIREN_encoder(dimensions, use_bias=False):
actual_model = tf.keras.Sequential()
actual_model.add(Layers.FirstSirenLayer(dimensions[0], dimensions[1]))
other_layers = []
for dim0, dim1 in zip(dimensions[1:-2], dimensions[2:-1]):
actual_model.add(Layers.Sinusoidal_BSNN(dim0, dim1, use_bias=use_bias))
actual_model.add(
Layers.Sinusoidal_BSNN(dimensions[-2],
dimensions[-1],
is_last=True,
use_bias=use_bias))
return actual_model
def return_generated_decode_block(self):
decode_block = nn.Sequential(
Layers.resnet_decoder_layer(self.n * 8, self.n * 4,
self.slope), # (bs, 256, 64, 64)
Layers.resnet_decoder_layer(self.n * 4, self.n * 2,
self.slope), # (bs, 128, 128, 128)
Layers.resnet_decoder_layer(self.n * 2, self.n * 1,
self.slope), # (bs, 64, 256, 256)
nn.Conv2d(self.n, self.img_channels, 7, 1, 3), # (bs, 3, 256, 256)
nn.Tanh())
return decode_block
def bottleneck_layer(self, x, name): with tf.variable_scope(name): x = layers.batch_normalization(x, self.is_training, name = 'batch1') x = tf.nn.relu(x) x = layers.convolution2d(x, 1, self.bn_size * self.growth_rate, weight_decay = CONV_WEIGHT_DECAY, bias = False, name = 'conv1') x = tf.nn.dropout(x, self.keep_prob) x = layers.batch_normalization(x, self.is_training, name = 'batch2') x = tf.nn.relu(x) x = layers.convolution2d(x, 3, self.growth_rate, weight_decay = CONV_WEIGHT_DECAY, bias = False, name = 'conv2') x = tf.nn.dropout(x, self.keep_prob) return x
def build_orthogonal_model_with_rotated_encoder(dimensions,
use_bias=False,
scale_factor=1.0):
actual_model = tf.keras.Sequential()
actual_model.add(
PositionalEncoders.RotatedPositionalEncoderLayer(
dimensions[0], dimensions[1], scale_factor=scale_factor))
other_layers = []
for dim0, dim1 in zip(dimensions[1:-2], dimensions[2:-1]):
actual_model.add(Layers.Sinusoidal_BSNN(dim0, dim1))
actual_model.add(
Layers.Sinusoidal_BSNN(dimensions[-2], dimensions[-1], is_last=True))
return actual_model
def __init__(self, hyperParams):
self.hP = hyperParams
#Instantiate Layers:
self.hL = Layers.HiddenLayer(inputSize = self.hP.layerSizes[0], outputSize = self.hP.layerSizes[1], \
activationType = self.hP.activations[0])
self.oL = Layers.OutputLayer(inputSize = self.hP.layerSizes[1], outputSize = self.hP.layerSizes[2], \
activationType = self.hP.activations[1])
self.inputSize = self.hL.inputSize
#Initialize Params
self.params = Params([self.hL, self.oL])
def pre_train(self, X, epochs=1, noise_rate=0.3):
self.structure = numpy.concatenate([[X.shape[1]], self.structure])
self.X = X
trainer = Trainer()
print("Pre-training: ") #, self.__repr__()
for i in range(len(self.structure) - 1):
#print ("Layer: %dx%d"%( self.structure[i], self.structure[i+1]))
s1 = Layers.SigmoidLayer(self.structure[i],
self.structure[i + 1],
noise=Noise.SaltAndPepper(noise_rate))
s2 = Layers.SigmoidLayer(self.structure[i + 1], self.X.shape[1])
s1, s2 = trainer.train([s1, s2], self.X, self.X, epochs)
self.X = s1.activate(self.X)
self.Layers.append(s1)
def return_generated_down_stack(self):
block = nn.ModuleList([
Layers.down_grade_layer(self.img_channels,
self.n,
self.slope,
norm=False), # (bs, 128, 128, 64)
Layers.down_grade_layer(self.n, self.n * 2,
self.slope), # (bs, 64, 64, 128)
Layers.down_grade_layer(self.n * 2, self.n * 4,
self.slope), # (bs, 32, 32, 256)
Layers.down_grade_layer(self.n * 4, self.n * 8,
self.slope), # (bs, 16, 16, 512)
Layers.down_grade_layer(self.n * 8, self.n * 8,
self.slope), # (bs, 8, 8, 512)
Layers.down_grade_layer(self.n * 8, self.n * 8,
self.slope), # (bs, 4, 4, 512)
Layers.down_grade_layer(self.n * 8, self.n * 8,
self.slope), # (bs, 2, 2, 512)
Layers.down_grade_layer(self.n * 8,
self.n * 8,
self.slope,
norm=False), # (bs, 1, 1, 512)
])
return block
def return_generated_encode_block(self):
encode_block = nn.Sequential(
nn.Conv2d(self.img_channels, self.n, 7, 1,
3), # (bs, 64, 256, 256)
nn.LeakyReLU(self.slope, True),
Layers.resnet_encoder_layer(self.n, self.n * 2,
self.slope), # (bs, 128, 128, 128)
Layers.resnet_encoder_layer(self.n * 2, self.n * 4,
self.slope), # (bs, 256, 64, 64)
Layers.resnet_encoder_layer(self.n * 4, self.n * 8,
self.slope), # (bs, 512, 32, 32)
)
return encode_block
def conv2d_transpose(
self,
name,
in_tensor,
kx,
ky,
kout,
outshape,
stride=None,
biased=True,
kernel_initializer=None,
biase_initializer=None,
padding='SAME',
):
out, w, b = Layers.conv2d_transpose(
in_tensor,
name,
kx,
ky,
kout,
outshape,
stride,
biased,
kernel_initializer,
biase_initializer,
padding,
data_format=self.data_format,
)
self.weights.update({w.op.name: w})
if biased:
self.weights.update({b.op.name: b})
return out
def get_sensing_model(input_shape, target_shape):
inputs = Input(input_shape)
outputs = Layers.TensorEncoder(target_shape, name='linear_encoder')(inputs)
model = Model(inputs=inputs, outputs=outputs)
return model
def batch_norm(self, name, in_tensor, phase_train, reuse=None):
return Layers.batch_norm(in_tensor,
phase_train,
name,
reuse,
data_format=self.data_format)
def __init__(self, in_dim, hidden_dim, weight_sharing=False):
self.in_dim = in_dim
self.n_dim = hidden_dim
self.out_dim = in_dim
self.weight_sharing = weight_sharing
self.encoder = L.DenseLayer(self.in_dim, self.n_dim)
self.decoder = L.DenseLayer(self.n_dim, self.out_dim)
self._layers = ["encoder", "decoder"]
if self.weight_sharing:
for l in xrange(len(self._layers) // 2):
encoder = getattr(self, self._layers[l])
decoder = getattr(self,
self._layers[len(self._layers) - 1 - l])
assert decoder.params['W'].data.shape == encoder.params[
'W'].data.transpose().shape
decoder.params['W'].data = encoder.params['W'].data.transpose()
def __init__(self, ngpu, nz, ngf, nc, k):
super(Generator, self).__init__()
self.ngpu = ngpu
layers = []
d_in = 2**k
layers.append(
nn.ConvTranspose2d(nz, ngf * d_in, kernel_size, 1, 0, bias=False))
layers.append(nn.BatchNorm2d(ngf * d_in))
layers.append(nn.ReLU(True))
# state size. (ngf*16) x 4 x 4
#------------------------------------------
for i in range(k):
n = k - i
layers.append(ll.GenLayerSN(ngf, n))
#------------------------------------------
layers.append(sa.Self_Attn(ngf, "relu"))
layers.append(
nn.ConvTranspose2d(ngf,
nc,
kernel_size,
stride,
padding,
bias=False))
layers.append(nn.Tanh())
# state size. (nc) x 128 x 128
self.main = nn.ModuleList(layers)
def initialize(self,
outsize,
batch_norm=False,
affine=True,
activation=-1,
usebias=True,
norm=False):
self.fc = L.fclayer(outsize, usebias, norm)
self.batch_norm = batch_norm
self.activation = activation
if self.activation == PARAM_PRELU:
self.act = torch.nn.PReLU(num_parameters=outchn)
elif self.activation == PARAM_PRELU1:
self.act = torch.nn.PReLU(num_parameters=1)
if batch_norm:
self.bn = L.BatchNorm(affine=affine)
def __init__(self):
model_output = input_image = kr.Input(shape=HP.image_size +
[HP.channel_size])
model_output = kr.layers.Conv2D(filters=64,
kernel_size=5,
padding='same',
activation=tf.nn.leaky_relu,
use_bias=False)(model_output)
model_output = HP.DiscriminatorNormLayer()(model_output)
for _ in range(4):
model_output = Layers.DownScale(conv_depth=0)(model_output)
model_output = kr.layers.Flatten()(model_output)
output_adversarial_value = kr.layers.Dense(
units=1, activation='linear', dtype='float32')(model_output)
if HP.is_acgan:
output_classification_value = kr.layers.Dense(
units=HP.attributes_size, activation='linear',
dtype='float32')(model_output)
else:
output_classification_value = kr.layers.Dense(
units=HP.attributes_size * 2,
activation='linear',
dtype='float32')(model_output)
self.model = kr.Model(
input_image,
[output_adversarial_value, output_classification_value])
def finalLayer(self, X, y, epochs=1, n_neurons=200):
print "Final Layer..."
V = self.predict(X)
# print(y)
softmax = Layers.SoftmaxLayer(self.Layers[-1].W.shape[1], y.shape[1])
softmax = Trainer().train([softmax], V, y, epochs)[0]
self.Layers.append(softmax)
def __init__(self, ngpu, ndf, nc, k):
super(Discriminator, self).__init__()
self.ngpu = ngpu
layers = []
layers.append(nn.Conv2d(nc, ndf, kernel_size, stride=stride, padding=padding, bias=False) )
layers.append(nn.LeakyReLU(0.2, inplace=True))
# state size. (ndf) x 64 x 64
#--------------------------------------------
for i in range(k):
layers.append(ll.DisLayerSN_d(ndf, i))
#--------------------------------------------
d_out = 2**k
layers.append(sa.Self_Attn(ndf*d_out, "relu"))
layers.append(sa.Self_Attn(ndf*d_out, "relu"))
layers.append(nn.Conv2d(ndf * d_out, 1, kernel_size, stride=1, padding=0, bias=False))
layers.append(nn.Sigmoid())
# state size. 1
self.main = nn.ModuleList(layers)
def initialize(self, chn):
self.gx = L.conv2D(3, chn)
self.gh = L.conv2D(3, chn)
self.fx = L.conv2D(3, chn)
self.fh = L.conv2D(3, chn)
self.ox = L.conv2D(3, chn)
self.oh = L.conv2D(3, chn)
self.gx = L.conv2D(3, chn)
self.gh = L.conv2D(3, chn)
def training():
train_images, train_labels = input_data.get_files(TRAIN_DIR)
batch_images, batch_labels = input_data.get_batches(
train_images, train_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
train_logits = CNN.CNN(batch_images, BATCH_SIZE, N_CLASSES)
train_loss = Layers.loss(train_logits, batch_labels)
train_op = Layers.optimize(train_loss, learning_rate)
train_accuracy = Layers.accuracy(train_logits, batch_labels)
summary_op = tf.summary.merge_all()
sess = tf.Session()
train_writer = tf.summary.FileWriter(LOGS_TRAIN_DIR, sess.graph)
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
for step in range(MAX_STEP):
if coord.should_stop():
break
_, tra_loss, tra_acc = sess.run(
[train_op, train_loss, train_accuracy])
if step % 50 == 0:
print(
'Step %d, the training loss is %.2f, train accuracy is %.2f%%'
% (step, tra_loss, tra_acc))
summary_str = sess.run(summary_op)
train_writer.add_summary(summary_str, step)
if step % 2000 == 0:
checkpoint_path = os.path.join(LOGS_TRAIN_DIR, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Training Done.')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
def Res2NetLite(input_, base_channel = 32, is_training = True, data_format = 'channels_last', reuse = False, c = 72, stage_number =[3,7,3], name = 'Res2NetLite'):
"""
the backbone of the detection model.
"""
with tf.variable_scope(name_or_scope = name, reuse = reuse):
layers = []
#stage-0: 224,224
bn1 = ly._bn(input_, data_format, is_training)
#112,112,32
conv1 = ly.conv_bn_activation(bn1, 32, 3, 2)
#56,56,32
maxp1 = ly.max_pooling(conv1, 3, 2)
#stage-1
#28,28,4c
bottle1_s1 = md.Bottleneck(32, 4*c, name ='Bottleneck_stage1')
out_s1 = bottle1_s1.forward(maxp1)
for i in range(stage_number[0]):
_name = 'res2block_'+str(i)+'_stage1'
layers.append(md.Res2Block(4*c, name = _name))
out_s1 = layers[-1].forward(out_s1)
#stage-2
#14,14,8c
bottle1_s2 = md.Bottleneck(4*c, 8*c, name ='Bottleneck_stage2')
out_s2 = bottle1_s2.forward(out_s1)
for i in range(stage_number[1]):
_name = 'res2block_'+str(i)+'_stage2'
layers.append(md.Res2Block(8*c, name = _name))
out_s2 = layers[-1].forward(out_s2)
#stage-3
#7,7,16c
bottle1_s3 = md.Bottleneck(8*c, 16*c, name ='Bottleneck_stage3')
out_s3 = bottle1_s3.forward(out_s2)
for i in range(stage_number[2]):
_name = 'res2block_'+str(i)+'_stage3'
layers.append(md.Res2Block(16*c, name = _name))
out_s3 = layers[-1].forward(out_s3)
#stage-4
out = ly.avg_pooling(out_s3, 7, 7)
print(out)
out = ly.conv_bn_activation(out, 1000, 1, 1)
print(conv1,maxp1,out_s1,out_s2,out_s3)
return out
def TABL(template,
dropout=0.1,
projection_regularizer=None,
projection_constraint=None,
attention_regularizer=None,
attention_constraint=None):
"""
Temporal Attention augmented Bilinear Layer network, refer to the paper https://arxiv.org/abs/1712.00975
inputs
----
template: a list of network dimensions including input and output, e.g., [[40,10], [120,5], [3,1]]
dropout: dropout percentage
projection_regularizer: keras regularizer object for projection matrices
projection_constraint: keras constraint object for projection matrices
attention_regularizer: keras regularizer object for attention matrices
attention_constraint: keras constraint object for attention matrices
outputs
------
keras model object
"""
inputs = keras.layers.Input(template[0])
x = inputs
for k in range(1, len(template) - 1):
x = Layers.BL(template[k], projection_regularizer,
projection_constraint)(x)
x = keras.layers.Activation('relu')(x)
x = keras.layers.Dropout(dropout)(x)
x = Layers.TABL(template[-1], projection_regularizer,
projection_constraint, attention_regularizer,
attention_constraint)(x)
outputs = keras.layers.Activation('softmax')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
optimizer = keras.optimizers.Adam(0.01)
model.compile(optimizer, 'categorical_crossentropy', [
'acc',
])
return model
def output_layer_delta(self, targets):
output_layer_scores = self.layers[-1].get_transfer_output()
output_layer_probabilities = Layers.get_probabilities_from_scores(
output_layer_scores
)
output_layer_probabilities[range(np.shape(targets)[0]), targets] -= 1
other_layer_delta = output_layer_probabilities / np.shape(targets)[0]
return other_layer_delta
import cv2
import matplotlib.pyplot as plt
import numpy as np
import Layers
rng = np.random.RandomState(1234)
image = cv2.imread('./dataset/images/1.jpg', 0)
input = image.reshape(1, 1, image.shape[0], image.shape[1])
input = np.array(input, dtype=np.float64)
conv_3x3 = Layers.conv_3x3(input, rng, input.shape, (4, 1, 3, 3), (6, 4, 3, 3))
out = conv_3x3.outputs
g_p = Layers.global_avearge_pool(out, pool_size=(2, 2))
value = g_p.outputs.eval()
print value.shape
for i in xrange(value.shape[1]):
plt.subplot(2, 3, i + 1)
plt.imshow(value[0, i, :, :], 'gray')
plt.show()
def lstm(sen):
layers = []
###########################################
# construct a layer for each word
# Layers
# |-----vector-----------| (nWords)
# constructing a layer
# def __init__(self, name, Bidx, numunit):
layers = []
for idx, w in enumerate(sen):
if w in vocab:
word_id = vocab[w] # d is the word
else:
word_id = 0
embedLayer = Lay.layer( w, word_id * numEmbed, numEmbed, '0')
i = Lay.layer( 'i_' + w, B_i[0], numLSTM, 'l' )
f = Lay.layer( 'f_' + w, B_f[0], numLSTM, 'l' )
o = Lay.layer( 'o_' + w, B_o[0], numLSTM, 'l' )
g = Lay.layer( 'g_' + w, B_g[0], numLSTM, 'l' )
# c_tilde is the c after applying activation function
c = Lay.layer( 'c_' + w, -1, numLSTM, '0' )
c_tilde = Lay.layer( 'c_tilde_' + w, -1, numLSTM, 't' )
h = Lay.layer( 'h_' + w, -1, numLSTM, '0' )
layers.append(embedLayer)
layers.append( i )
layers.append( f )
layers.append( o )
layers.append( g )
layers.append( c )
layers.append( c_tilde )
layers.append( h )
########################
# connections within this time slot
# connection:
# def __init__(self, xlayer, ylayer, Widx, Wcoef = 1.0)
# BilinearConnection:
# def __init__(self, xlayer1, xlayer2, ylayer, Widx)
Con.connection(embedLayer, i, W_i[0])
Con.connection(embedLayer, f, W_f[0])
Con.connection(embedLayer, o, W_o[0])
Con.connection(embedLayer, g, W_g[0])
Con.BilinearConnection( i, g, c, -1 )
Con.connection( c, c_tilde, -1)
Con.BilinearConnection( o, c_tilde, h, -1)
########################
# recurrent connections
# layers[-9]: hidden layer of last time slot (h)
# layers[-11]: cell of last time slot (c)
if idx != 0:
Con.connection(layers[-9], i, U_i[0])
Con.connection(layers[-9], f, U_f[0])
Con.connection(layers[-9], o, U_o[0])
Con.connection(layers[-9], g, U_g[0])
#print 'layer[-9].name: ', layers[-9].name
#print 'layer[-11].name: ', layers[-11].name
# self loop in c:
Con.BilinearConnection( layers[-11], f, c, -1)
###########################
# output layer
# softmax
outlayer = Lay.layer('output', Bout[0], numOut, 's')
Con.connection(layers[-1], outlayer, Wout[0])
layers.append(outlayer)
return layers
