def _build_middle(self,
l_in,
num_conv_layers=1,
num_dense_layers=1,
**kwargs):
assert len(l_in.shape) == 4, 'InputLayer shape must be (batch_size, channels, width, height) -- ' \
'reshape data or use RGB format?'
l_bottom = l_in
for i in xrange(num_conv_layers):
conv_kwargs = self._extract_layer_kwargs('c', i, kwargs)
if 'border_mode' not in conv_kwargs:
conv_kwargs['border_mode'] = 'same'
has_max_pool = conv_kwargs.pop('mp', False)
l_bottom = Conv2DLayer(l_bottom,
W=HeUniform(gain='relu'),
**conv_kwargs)
if has_max_pool:
max_pool_kwargs = self._extract_layer_kwargs('m', i, kwargs)
if 'pool_size' not in max_pool_kwargs:
max_pool_kwargs['pool_size'] = (2, 2)
l_bottom = MaxPool2DLayer(l_bottom, **max_pool_kwargs)
for i in xrange(num_dense_layers):
dense_kwargs = self._extract_layer_kwargs('d', i, kwargs)
dropout = dense_kwargs.pop('dropout', 0.5)
l_bottom = DenseLayer(l_bottom,
W=HeUniform(gain='relu'),
**dense_kwargs)
if dropout:
l_bottom = DropoutLayer(l_bottom, p=dropout)
return l_bottom
def buildSectorNet(self):
sectorNet = InputLayer(self.inputShape, self.inputVar)
for i, layer in enumerate(self.layerCategory):
self.logger.debug('Build {}th conv layer'.format(i))
self.logger.debug('The output shape of {}th layer equal {}'.format(
i - 1, get_output_shape(sectorNet)))
kernelXDim = int(layer[-1])
kernelDim = (kernelXDim, ) * 3
conv3D = batch_norm(
Conv3DLayer(incoming=sectorNet,
num_filters=self.numOfFMs[i],
filter_size=kernelDim,
W=HeUniform(gain='relu'),
nonlinearity=rectify,
name='Conv3D'))
self.logger.debug(
'The shape of {}th conv3D layer equals {}'.format(
i, get_output_shape(conv3D)))
sectorNet = ConcatLayer(
[conv3D, sectorNet],
1,
cropping=['center', 'None', 'center', 'center', 'center'])
self.logger.debug(
'The shape of {}th concat layer equals {}'.format(
i, get_output_shape(sectorNet)))
assert get_output_shape(sectorNet) == (None, sum(self.numOfFMs) + 1, 1,
1, 1)
sectorNet = batch_norm(
Conv3DLayer(incoming=sectorNet,
num_filters=2,
filter_size=(1, 1, 1),
W=HeUniform(gain='relu')))
self.logger.debug('The shape of last con3D layer equals {}'.format(
get_output_shape(sectorNet)))
sectorNet = ReshapeLayer(sectorNet, ([0], -1))
self.logger.debug('The shape of ReshapeLayer equals {}'.format(
get_output_shape(sectorNet)))
sectorNet = NonlinearityLayer(sectorNet, softmax)
self.logger.debug(
'The shape of output layer, i.e. NonlinearityLayer, equals {}'.
format(get_output_shape(sectorNet)))
assert get_output_shape(sectorNet) == (None, self.numOfOutputClass)
return sectorNet
def test_he_uniform_c01b_4d_only():
from lasagne.init import HeUniform
with pytest.raises(RuntimeError):
HeUniform(c01b=True).sample((100, ))
with pytest.raises(RuntimeError):
HeUniform(c01b=True).sample((100, 100))
with pytest.raises(RuntimeError):
HeUniform(c01b=True).sample((100, 100, 100))
def gooey_gadget(network_in, conv_add, stride):
network_c = Conv2DLayer(network_in,
conv_add / 2, (1, 1),
W=HeUniform('relu'))
network_c = prelu(network_c)
network_c = BatchNormLayer(network_c)
network_c = Conv2DLayer(network_c,
conv_add, (3, 3),
stride=stride,
W=HeUniform('relu'))
network_c = prelu(network_c)
network_c = BatchNormLayer(network_c)
network_p = MaxPool2DLayer(network_in, (3, 3), stride=stride)
return ConcatLayer((network_c, network_p))
def train_test(train, labels, test, weight_decay):
net = NeuralNet(
layers=[
('input', InputLayer),
('dropout0', DropoutLayer),
('dense1', DenseLayer),
('dropout1', DropoutLayer),
('dense2', DenseLayer),
('dropout2', DropoutLayer),
('dense3', DenseLayer),
('dropout3', DropoutLayer),
('output', DenseLayer),
],
update=nesterov_momentum,
loss=None,
objective=partial(WeightDecayObjective, weight_decay=weight_decay),
regression=False,
max_epochs=600,
eval_size=0.1,
#on_epoch_finished = None,
#on_training_finished = None,
verbose=bool(VERBOSITY),
input_shape=(None, train.shape[1]),
output_num_units=NCLASSES,
dense1_num_units=700,
dense2_num_units=1000,
dense3_num_units=700,
dense1_nonlinearity=LeakyRectify(leakiness=0.1),
dense2_nonlinearity=LeakyRectify(leakiness=0.1),
dense3_nonlinearity=LeakyRectify(leakiness=0.1),
output_nonlinearity=softmax,
dense1_W=HeUniform(),
dense2_W=HeUniform(),
dense3_W=HeUniform(),
dense1_b=Constant(0.),
dense2_b=Constant(0.),
dense3_b=Constant(0.),
output_b=Constant(0.),
dropout0_p=0.1,
dropout1_p=0.6,
dropout2_p=0.6,
dropout3_p=0.6,
update_learning_rate=shared(float32(0.02)), #
update_momentum=shared(float32(0.9)), #
batch_iterator_train=BatchIterator(batch_size=128),
batch_iterator_test=BatchIterator(batch_size=128),
)
net.fit(train, labels)
return net.predict_proba(test)
def __init__(self, input_shape=(None, 1, 33, 33, 33)):
self.cubeSize = input_shape[-1]
# Theano variables
self.input_var = T.tensor5('input_var') # input image
self.target_var = T.ivector('target_var') # target
self.logger = logging.getLogger(__name__)
input_layer = InputLayer(input_shape, self.input_var)
self.logger.info('The shape of input layer is {}'.format(
get_output_shape(input_layer)))
hidden_layer1 = Conv3DLayer(incoming=input_layer,
num_filters=16,
filter_size=(3, 3, 3),
W=HeUniform(gain='relu'),
nonlinearity=rectify)
self.logger.info('The shape of first hidden layer is {}'.format(
get_output_shape(hidden_layer1)))
hidden_layer2 = Conv3DLayer(incoming=hidden_layer1,
num_filters=32,
filter_size=(3, 3, 3),
W=HeUniform(gain='relu'),
nonlinearity=rectify)
self.logger.info('The shape of second hidden layer is {}'.format(
get_output_shape(hidden_layer2)))
hidden_layer3 = Conv3DLayer(incoming=hidden_layer2,
num_filters=2,
filter_size=(1, 1, 1),
W=HeUniform(gain='relu'),
nonlinearity=rectify)
self.logger.info('The shape of third hidden layer is {}'.format(
get_output_shape(hidden_layer3)))
shuffledLayer = DimshuffleLayer(hidden_layer3, (0, 2, 3, 4, 1))
self.logger.info('The shape of shuffled layer is {}'.format(
get_output_shape(shuffledLayer)))
reshapedLayer = ReshapeLayer(shuffledLayer, ([0], -1))
self.logger.info('The shape of reshaped layer is {}'.format(
get_output_shape(reshapedLayer)))
self.output_layer = NonlinearityLayer(reshapedLayer, softmax)
self.logger.info('The shape of output layer is {}'.format(
get_output_shape(self.output_layer)))
def SoftmaxLayer(inputs, n_classes):
"""
Performs 1x1 convolution followed by softmax nonlinearity
The output will have the shape (batch_size * n_rows * n_cols, n_classes)
"""
l = Conv2DLayer(inputs,
n_classes,
filter_size=1,
nonlinearity=linear,
W=HeUniform(gain='relu'),
pad='same',
flip_filters=False,
stride=1)
# We perform the softmax nonlinearity in 2 steps :
# 1. Reshape from (batch_size, n_classes, n_rows, n_cols) to (batch_size * n_rows * n_cols, n_classes)
# 2. Apply softmax
l = DimshuffleLayer(l, (0, 2, 3, 1))
batch_size, n_rows, n_cols, _ = get_output(l).shape
l = ReshapeLayer(l, (batch_size * n_rows * n_cols, n_classes))
l = NonlinearityLayer(l, softmax)
l = ReshapeLayer(l, (batch_size, n_rows, n_cols, n_classes))
l = DimshuffleLayer(l, (0, 3, 1, 2))
l = ReshapeLayer(l, (batch_size, n_classes, n_rows, n_cols))
return l
def build_model(self, input_batch):
## initialize shared parameters
Ws = []
bs = []
nLayersWithParams = 13
if self.refinement_network:
nLayersWithParams = nLayersWithParams + 4
for i in range(nLayersWithParams):
W = HeUniform()
Ws.append(W)
b = Constant(0.0)
bs.append(b)
hidden_state = InputLayer(input_var=np.zeros((self.batch_size, 64, self.npx/2, self.npx/2), dtype=np.float32), shape=(self.batch_size, 64, self.npx/2, self.npx/2))
## get inputs
inputs = InputLayer(input_var=input_batch, shape=(None, self.input_seqlen, self.npx, self.npx))
# inputs = InputLayer(input_var=input_batch, shape=(None, 1, self.npx, self.npx, self.input_seqlen))
# inputs = DimshuffleLayer(inputs, (0, 4, 2, 3, 1))
outputs = []
for i in range(self.input_seqlen - self.nInputs + self.target_seqlen):
input = SliceLayer(inputs, indices=slice(0,self.nInputs), axis=1)
output, hidden_state, filters = self.predict(input, hidden_state, Ws, bs)
## FIFO operation.
inputs = SliceLayer(inputs, indices=slice(1, None), axis=1)
if i == self.input_seqlen - self.nInputs:
filtersToVisualize = filters
if i >= self.input_seqlen - self.nInputs:
inputs = ConcatLayer([inputs, output], axis=1)
outputs.append(output)
return output, outputs, filtersToVisualize
def TransitionalNormalizeLayer(inputs, n_directions):
"""
Performs 1x1 convolution followed by softmax nonlinearity.
The output will have the shape (batch_size * n_rows * n_cols, n_classes)
"""
l = Conv2DLayer(inputs,
n_directions**2,
filter_size=1,
nonlinearity=linear,
W=HeUniform(gain='relu'),
pad='same',
flip_filters=False,
stride=1)
# We perform the softmax nonlinearity in 2 steps :
# 1. Reshape from (batch_size, n_classes, n_rows, n_cols) to (batch_size * n_rows * n_cols, n_classes)
# 2. Apply softmax
batch_size, n_channels, n_rows, n_cols = get_output(l).shape
l = ReshapeLayer(l,
(batch_size, n_directions, n_directions, n_rows, n_cols))
l = DimshuffleLayer(l, (0, 1, 3, 4, 2))
l = ReshapeLayer(
l, (batch_size * n_directions * n_rows * n_cols, n_directions))
l = NormalizeLayer(l)
l = ReshapeLayer(l,
(batch_size, n_directions, n_rows, n_cols, n_directions))
l = DimshuffleLayer(l, (0, 1, 4, 2, 3))
l = ReshapeLayer(l, (batch_size, n_channels, n_rows, n_cols))
return l
def BN_ReLU_Conv(inputs, n_filters, filter_size=3, dropout_p=0.2):
l = NonlinearityLayer(BatchNormLayer(inputs))
l = Conv2DLayer(l, n_filters, filter_size, pad='same', W=HeUniform(gain='relu'), nonlinearity=linear,
flip_filters=False)
if dropout_p != 0.0:
l = DropoutLayer(l, dropout_p)
return l
def SoftmaxLayer(inputs, n_classes):
l = Conv2DLayer(inputs, n_classes, filter_size=1, nonlinearity=linear, W=HeUniform(gain='relu'), pad='same',
flip_filters=False, stride=1)
l = DimshuffleLayer(l,(1,0,2,3))
l = ReshapeLayer(l, (n_classes,-1))
l = DimshuffleLayer(l, (1,0))
l = NonlinearityLayer(l, nonlinearity=softmax)
return l
def test_he_uniform_gain():
from lasagne.init import HeUniform
sample = HeUniform(gain=10.0).sample((300, 200))
assert -1.0 <= sample.min() < -0.9
assert 0.9 < sample.max() <= 1.0
sample = HeUniform(gain='relu').sample((100, 100))
assert -0.1 < sample.mean() < 0.1
assert 0.1 < sample.std() < 0.2
def choosy(network, cropsz, batchsz):
# 1st. Data size 117 -> 111 -> 55
network = Conv2DLayer(network, 64, (7, 7), stride=1, W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (3, 3), stride=2)
# 2nd. Data size 55 -> 27
network = Conv2DLayer(network,
112, (5, 5),
stride=1,
pad='same',
W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (3, 3), stride=2)
# 3rd. Data size 27 -> 13
network = Conv2DLayer(network,
192, (3, 3),
stride=1,
pad='same',
W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (3, 3), stride=2)
# 4th. Data size 11 -> 5
network = Conv2DLayer(network, 320, (3, 3), stride=1, W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (3, 3), stride=2)
# 5th. Data size 5 -> 3
network = Conv2DLayer(network, 512, (3, 3), nonlinearity=None)
network = prelu(network)
network = BatchNormLayer(network)
# 6th. Data size 3 -> 1
network = lasagne.layers.DenseLayer(network, 512, nonlinearity=None)
network = DropoutLayer(network)
network = FeaturePoolLayer(network, 2)
return network
def gooey(network, cropsz, batchsz):
# 1st. Data size 117 -> 111 -> 55
# 117*117*32 = 438048
network = Conv2DLayer(network, 32, (3, 3), stride=1, W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
# 115*115*32 = 423200
network = Conv2DLayer(network, 32, (3, 3), stride=1, W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
# 55*55*48 = 121000
network = Conv2DLayer(network, 40, (3, 3), stride=1, W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (3, 3), stride=2)
# 2nd. Data size 55 -> 27
# 27*27*96 = 69984
network = Conv2DLayer(network, 96, (3, 3), stride=2, W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
# 3rd. Data size 27 -> 13, 192 + 144
# 13*13*224 = 37856
network = gooey_gadget(network, 128, 2) # 92 + 128 = 224 channels
# 4th. Data size 13 -> 11 -> 5
# 11*11*192 = 23232
network = Conv2DLayer(network, 192, (3, 3), W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
# 5*5*412 = 10400
network = gooey_gadget(network, 224, 2) # 192 + 224 = 416 channels
# 5th. Data size 5 -> 3
# 3*3*672 = 6048
network = gooey_gadget(network, 256, 1) # 416 + 256 = 672 channels
# 6th. Data size 3 -> 1, 592 + 512 channels
# 1*1*1184 = 1184
network = gooey_gadget(network, 512, 1) # 672 + 512 = 1184 channels
return network
def create_network(available_actions_count):
# Create the input variables
s1 = tensor.tensor4("States")
a = tensor.vector("Actions", dtype="int32")
q2 = tensor.vector("Next State's best Q-Value")
r = tensor.vector("Rewards")
isterminal = tensor.vector("IsTerminal", dtype="int8")
dqn = InputLayer(shape=[None, 1, resolution[0], resolution[1]], input_var=s1)
dqn = Conv2DLayer(dqn, num_filters=32, filter_size=[8, 8],
nonlinearity=rectify, W=HeUniform("relu"),
b=Constant(.1), stride=4)
dqn = Conv2DLayer(dqn, num_filters=64, filter_size=[4, 4],
nonlinearity=rectify, W=HeUniform("relu"),
b=Constant(.1), stride=2)
dqn = DenseLayer(dqn, num_units=512, nonlinearity=rectify, W=HeUniform("relu"),
b=Constant(.1))
dqn = DenseLayer(dqn, num_units=available_actions_count, nonlinearity=None)
q = get_output(dqn)
target_q = tensor.set_subtensor(q[tensor.arange(q.shape[0]), a], r + discount_factor * (1 - isterminal) * q2)
loss = squared_error(q, target_q).mean()
params = get_all_params(dqn, trainable=True)
updates = rmsprop(loss, params, learning_rate)
print "Compiling the network ..."
function_learn = theano.function([s1, q2, a, r, isterminal], loss, updates=updates, name="learn_fn")
function_get_q_values = theano.function([s1], q, name="eval_fn")
function_get_best_action = theano.function([s1], tensor.argmax(q), name="test_fn")
print "Network compiled."
def simple_get_best_action(state):
return function_get_best_action(state.reshape([1, 1, resolution[0], resolution[1]]))
return dqn, function_learn, function_get_q_values, simple_get_best_action
def cslim(network, cropsz, batchsz):
# 1st
network = Conv2DLayer(network, 64, (5, 5), stride=2, W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (5, 5), stride=2)
# 2nd
network = Conv2DLayer(network,
96, (5, 5),
stride=1,
pad='same',
W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (5, 5), stride=2)
# 3rd
network = Conv2DLayer(network,
128, (3, 3),
stride=1,
pad='same',
W=HeUniform('relu'))
network = prelu(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (3, 3), stride=2)
# 4th
network = Conv2DLayer(network,
128, (3, 3),
stride=1,
pad='same',
W=HeUniform('relu'))
network = prelu(network)
network = DropoutLayer(network)
network = BatchNormLayer(network)
network = MaxPool2DLayer(network, (3, 3), stride=2)
# 5th
network = lasagne.layers.DenseLayer(network, 512, nonlinearity=None)
network = DropoutLayer(network)
network = FeaturePoolLayer(network, 2)
return network
def test_he_uniform_gain():
from lasagne.init import HeUniform
sample = HeUniform(gain=10.0).sample((300, 200))
assert -1.0 <= sample.min() < -0.9
assert 0.9 < sample.max() <= 1.0
sample = HeUniform(gain='relu').sample((100, 100))
assert -0.1 < sample.mean() < 0.1
assert 0.1 < sample.std() < 0.2
def construct_tiramisu_author(channels=1, no_f_base=45, f_size_base=3, bs=None, class_nums=2, k=16, denseblocks=[4,5,7,10,12], blockbottom=15, dropout_p=0.2, input_var=None, pad="same",c_nonlinearity=lasagne.nonlinearities.rectify,
f_nonlinearity=lasagne.nonlinearities.rectify, input_dim=[112,112]):
#Network start
inputs = InputLayer((bs, channels, input_dim[0], input_dim[1]), input_var)
stack = Conv2DLayer(inputs, no_f_base, f_size_base, pad=pad, W=HeUniform(gain='relu'), flip_filters=False)
n_filters = no_f_base
#Downward block building
horizontal_pass=[]
for blocks in xrange(len(denseblocks)):
for j in xrange(denseblocks[blocks]):
l = BN_ReLU_Conv(stack, k, dropout_p=dropout_p)
stack = ConcatLayer([stack, l])
print stack.output_shape
n_filters += k
horizontal_pass.append(stack)
stack = TransitionDown(stack, n_filters, dropout_p)
print "After TransitionDown: ",stack.output_shape
print "---Down done---"
#Bottom dense block
block_to_upsample = []
for bottom in xrange(blockbottom):
l = BN_ReLU_Conv(stack, k, dropout_p=dropout_p)
block_to_upsample.append(l)
stack = ConcatLayer([stack, l])
print "Bottomblock: ",stack.output_shape
print "---Bottom done---"
#Up dense block
for block in xrange(len(denseblocks)):
n_filters_keep = k*denseblocks[block]
stack = TransitionUp(horizontal_pass[-(block+1)], block_to_upsample, n_filters_keep)
print "After TransitionUp: ",stack.output_shape
block_to_upsample = []
for j in xrange(denseblocks[-(block+1)]):
l = BN_ReLU_Conv(stack, k, dropout_p=dropout_p)
block_to_upsample.append(l)
stack = ConcatLayer([stack, l])
print stack.output_shape
print "---Up done---"
#Out block
image_out = Conv2DLayer(stack, class_nums, 1, pad=pad, W=lasagne.init.HeUniform(gain='relu'), nonlinearity=linear)
net = SoftmaxLayer(stack, class_nums)
return net,image_out
def BN_ReLU_Conv(inputs, n_filters, filter_size=3, dropout_p=0.2, pad='same'):
"""
Apply successivly BatchNormalization, ReLu nonlinearity, Convolution and Dropout (if dropout_p > 0) on the inputs
"""
l = NonlinearityLayer(BatchNormLayer(inputs))
l = Conv2DLayer(l,
n_filters,
filter_size,
pad=pad,
W=HeUniform(gain='relu'),
nonlinearity=linear,
flip_filters=False)
if dropout_p != 0.0:
l = DropoutLayer(l, dropout_p)
return l
def TransitionUp(skip_connection, block_to_upsample, n_filters_keep):
"""
Performs upsampling on block_to_upsample by a factor 2 and concatenates it with the skip_connection """
# Upsample
l = ConcatLayer(block_to_upsample)
l = Deconv2DLayer(l,
n_filters_keep,
filter_size=3,
stride=2,
crop='valid',
W=HeUniform(gain='relu'),
nonlinearity=linear)
# Concatenate with skip connection
l = ConcatLayer([l, skip_connection],
cropping=[None, None, 'center', 'center'])
return l
def build_model(self, input_batch):
## initialize shared parameters
Ws = []
bs = []
for i in range(14):
W = HeUniform()
Ws.append(W)
b = Constant(0.0)
bs.append(b)
hidden_state = InputLayer(input_var=np.zeros(
(self.batch_size, 128, self.npx / 2, self.npx / 2),
dtype=np.float32),
shape=(self.batch_size, 128, self.npx / 2,
self.npx / 2))
## get inputs
input = InputLayer(input_var=input_batch,
shape=(None, 1, self.npx, self.npx))
output, hidden_state = self.predict(input, hidden_state, Ws, bs)
return output, [output]
nonlinearities = {
'tanh': tanh,
'sigmoid': sigmoid,
'rectify': rectify,
'leaky2': LeakyRectify(leakiness=0.02),
'leaky20': LeakyRectify(leakiness=0.2),
'softmax': softmax,
}
initializers = {
'orthogonal': Orthogonal(),
'sparse': Sparse(),
'glorot_normal': GlorotNormal(),
'glorot_uniform': GlorotUniform(),
'he_normal': HeNormal(),
'he_uniform': HeUniform(),
}
class NNet(BaseEstimator, ClassifierMixin):
def __init__(
self,
name='nameless_net', # used for saving, so maybe make it unique
dense1_size=60,
dense1_nonlinearity='tanh',
dense1_init='orthogonal',
dense2_size=None,
dense2_nonlinearity=None, # inherits dense1
dense2_init=None, # inherits dense1
dense3_size=None,
dense3_nonlinearity=None, # inherits dense2
def create_network(available_actions_count):
# Create the input variables
s1 = tensor.tensor4("States")
a = tensor.vector("Actions", dtype="int32")
q2 = tensor.vector("Next State's best Q-Value")
r = tensor.vector("Rewards")
isterminal = tensor.vector("IsTerminal", dtype="int8")
# Create the input layer of the network.
dqn = InputLayer(shape=[None, 1, resolution[0], resolution[1]],
input_var=s1)
# Add 2 convolutional layers with ReLu activation
dqn = Conv2DLayer(dqn,
num_filters=8,
filter_size=[6, 6],
nonlinearity=rectify,
W=HeUniform("relu"),
b=Constant(.1),
stride=3)
dqn = Conv2DLayer(dqn,
num_filters=8,
filter_size=[3, 3],
nonlinearity=rectify,
W=HeUniform("relu"),
b=Constant(.1),
stride=2)
# Add a single fully-connected layer.
dqn = DenseLayer(dqn,
num_units=128,
nonlinearity=rectify,
W=HeUniform("relu"),
b=Constant(.1))
# Add the output layer (also fully-connected).
# (no nonlinearity as it is for approximating an arbitrary real function)
dqn = DenseLayer(dqn, num_units=available_actions_count, nonlinearity=None)
# Define the loss function
q = get_output(dqn)
# target differs from q only for the selected action. The following means:
# target_Q(s,a) = r + gamma * max Q(s2,_) if isterminal else r
target_q = tensor.set_subtensor(
q[tensor.arange(q.shape[0]), a],
r + discount_factor * (1 - isterminal) * q2)
loss = squared_error(q, target_q).mean()
# Update the parameters according to the computed gradient using RMSProp.
params = get_all_params(dqn, trainable=True)
updates = rmsprop(loss, params, learning_rate)
# Compile the theano functions
print "Compiling the network ..."
function_learn = theano.function([s1, q2, a, r, isterminal],
loss,
updates=updates,
name="learn_fn")
function_get_q_values = theano.function([s1], q, name="eval_fn")
function_get_best_action = theano.function([s1],
tensor.argmax(q),
name="test_fn")
print "Network compiled."
def simple_get_best_action(state):
return function_get_best_action(
state.reshape([1, 1, resolution[0], resolution[1]]))
# Returns Theano objects for the net and functions.
return dqn, function_learn, function_get_q_values, simple_get_best_action
import re
import sys
import theano
from common import ENCODING, EPSILON, FMAX, FMIN, MAX_EPOCHS, MIN_EPOCHS, \
NONMATCH_RE, NEGATIVE_IDX, NEUTRAL_IDX, POSITIVE_IDX, \
floatX, sgd_updates_adadelta
from common import POSITIVE as POSITIVE_LBL
from common import NEGATIVE as NEGATIVE_LBL
from germanet import normalize
##################################################################
# Constants
SPACE_RE = re.compile(r"\s+")
ORTHOGONAL = Orthogonal()
HE_UNIFORM = HeUniform()
##################################################################
# Methods
def digitize_trainset(w2i, a_pos, a_neg, a_neut, a_pos_re, a_neg_re):
"""Method for generating sentiment lexicons using Velikovich's approach.
@param a_N - number of terms to extract
@param a_emb_fname - files of the original corpus
@param a_pos - initial set of positive terms to be expanded
@param a_neg - initial set of negative terms to be expanded
@param a_neut - initial set of neutral terms to be expanded
@param a_pos_re - regular expression for matching positive terms
@param a_neg_re - regular expression for matching negative terms
def create_network(available_actions_count):
# Crea las variables de entrada
s1 = tensor.tensor4("State")
a = tensor.vector("Action", dtype="int32")
q2 = tensor.vector("Q2")
r = tensor.vector("Reward")
isterminal = tensor.vector("IsTerminal", dtype="int8")
# Crea la capa de entradad de la red
dqn = InputLayer(shape=[None, 1, resolution[0], resolution[1]],
input_var=s1)
# Agrega 2 capas convolusionales con activacion ReLu activation
dqn = Conv2DLayer(dqn,
num_filters=8,
filter_size=[6, 6],
nonlinearity=rectify,
W=HeUniform("relu"),
b=Constant(.1),
stride=3)
dqn = Conv2DLayer(dqn,
num_filters=8,
filter_size=[3, 3],
nonlinearity=rectify,
W=HeUniform("relu"),
b=Constant(.1),
stride=2)
# Agrega 1 capa competamente conectada.
dqn = DenseLayer(dqn,
num_units=128,
nonlinearity=rectify,
W=HeUniform("relu"),
b=Constant(.1))
# Agrega la capa de salida (completamente conectada).
dqn = DenseLayer(dqn, num_units=available_actions_count, nonlinearity=None)
# Definimos la funcion de perdida
q = get_output(dqn)
# target_Q(s,a) = r + gamma * max Q(s2,_) if isterminal else r
target_q = tensor.set_subtensor(
q[tensor.arange(q.shape[0]), a],
r + discount_factor * (1 - isterminal) * q2)
loss = squared_error(q, target_q).mean()
# Actualizamos los parametros de acuerdo a la gracdiente calculada con RMSProp.
params = get_all_params(dqn, trainable=True)
updates = rmsprop(loss, params, learning_rate)
# Compilamos las funciones de theano
print("Compiling the network ...")
function_learn = theano.function([s1, q2, a, r, isterminal],
loss,
updates=updates,
name="learn_fn")
function_get_q_values = theano.function([s1], q, name="eval_fn")
function_get_best_action = theano.function([s1],
tensor.argmax(q),
name="test_fn")
print("Network compiled.")
def simple_get_best_action(state):
return function_get_best_action(
state.reshape([1, 1, resolution[0], resolution[1]]))
# Retorna los objetos de Theano para la red y las funciones.
return dqn, function_learn, function_get_q_values, simple_get_best_action
regression=False,
max_epochs=1000,
eval_size=0.1,
#on_epoch_finished = None,
#on_training_finished = None,
verbose=bool(VERBOSITY),
input_shape=(None, train.shape[1]),
output_num_units=NCLASSES,
dense1_num_units=500,
dense2_num_units=500,
dense3_num_units=400,
dense1_nonlinearity=LeakyRectify(leakiness=0.1),
dense2_nonlinearity=LeakyRectify(leakiness=0.1),
dense3_nonlinearity=LeakyRectify(leakiness=0.1),
output_nonlinearity=softmax,
dense1_W=HeUniform(),
dense2_W=HeUniform(),
dense3_W=HeUniform(),
dense1_b=Constant(0.),
dense2_b=Constant(0.),
dense3_b=Constant(0.),
output_b=Constant(0.),
dropout0_p=0.1,
dropout1_p=0.6,
dropout2_p=0.6,
dropout3_p=0.6,
update_learning_rate=shared(float32(0.02)), #
update_momentum=shared(float32(0.9)), #
batch_iterator_train=BatchIterator(batch_size=128),
batch_iterator_test=BatchIterator(batch_size=128),
)
def test_he_uniform_c01b():
from lasagne.init import HeUniform
sample = HeUniform(c01b=True).sample((75, 2, 2, 75))
assert -0.1 <= sample.min() < -0.09
assert 0.09 < sample.max() <= 0.1
def test_he_uniform_receptive_field():
from lasagne.init import HeUniform
sample = HeUniform().sample((150, 150, 2))
assert -0.10 <= sample.min() < -0.09
assert 0.09 < sample.max() <= 0.10
def test_he_uniform_receptive_field():
from lasagne.init import HeUniform
sample = HeUniform().sample((150, 150, 2))
assert -0.10 <= sample.min() < -0.09
assert 0.09 < sample.max() <= 0.10
def test_he_uniform():
from lasagne.init import HeUniform
sample = HeUniform().sample((300, 200))
assert -0.1 <= sample.min() < -0.09
assert 0.09 < sample.max() <= 0.1
def test_he_uniform_c01b():
from lasagne.init import HeUniform
sample = HeUniform(c01b=True).sample((75, 2, 2, 75))
assert -0.1 <= sample.min() < -0.09
assert 0.09 < sample.max() <= 0.1
def test_he_uniform_gain():
from lasagne.init import HeUniform
sample = HeUniform(gain=10.0).sample((300, 200))
assert -1.0 <= sample.min() < -0.9
assert 0.9 < sample.max() <= 1.0
def TransitionUp(skip_connection, block_to_upsample, n_filters_keep):
l = ConcatLayer(block_to_upsample)
l = Deconv2DLayer(l, n_filters_keep, filter_size=3, stride=2,
crop='valid', W=HeUniform(gain='relu'), nonlinearity=linear)
l = ConcatLayer([l, skip_connection], cropping=[None, None, 'center', 'center'])
return l
def test_he_uniform():
from lasagne.init import HeUniform
sample = HeUniform().sample((300, 200))
assert -0.1 <= sample.min() < -0.09
assert 0.09 < sample.max() <= 0.1
def __init__(self,
input_shape=(None, 3, None, None),
n_filters=48,
n_pool=4,
n_layers_per_block=5,
dropout_p=0.2):
"""
This code implements the Fully Convolutional DenseNet described in https://arxiv.org/abs/1611.09326
The network consist of a downsampling path, where dense blocks and transition down are applied, followed
by an upsampling path where transition up and dense blocks are applied.
Skip connections are used between the downsampling path and the upsampling path
Each layer is a composite function of BN - ReLU - Conv and the last layer is a softmax layer.
:param input_shape: shape of the input batch. Only the first dimension (n_channels) is needed
:param n_classes: number of classes
:param n_filters_first_conv: number of filters for the first convolution applied
:param n_pool: number of pooling layers = number of transition down = number of transition up
:param growth_rate: number of new feature maps created by each layer in a dense block
:param n_layers_per_block: number of layers per block. Can be an int or a list of size 2 * n_pool + 1
:param dropout_p: dropout rate applied after each convolution (0. for not using)
"""
if type(n_layers_per_block) == list:
assert (len(n_layers_per_block) == 2 * n_pool + 1)
elif type(n_layers_per_block) == int:
n_layers_per_block = [n_layers_per_block] * (2 * n_pool + 1)
else:
raise ValueError
# Theano variables
self.input_var = T.tensor4('input_var', dtype='float32') # input image
self.target_var = T.tensor4('target_var', dtype='float32') # target
#####################
# First Convolution #
#####################
inputs = InputLayer(input_shape, self.input_var)
# We perform a first convolution. All the features maps will be stored in the tensor called stack (the Tiramisu)
stack = Conv2DLayer(inputs, n_filters[0], filter_size=1, pad='same',
W=HeUniform(gain='relu'),
nonlinearity=linear, flip_filters=False)
#####################
# Downsampling path #
#####################
skip_connection_list = []
for i in range(n_pool):
# Dense Block
for j in range(n_layers_per_block[i]):
# Compute new feature maps
stack = BN_ReLU_Conv(stack, n_filters[i], dropout_p=dropout_p)
# At the end of the block, the current stack is stored in the skip_connections list
skip_connection_list.append(stack)
# Transition Down
stack = TransitionDown(stack, n_filters[i + 1], dropout_p)
skip_connection_list = skip_connection_list[::-1]
#####################
# Bottleneck #
#####################
# We store now the output of the next dense block in a list. We will only upsample these new feature maps
block_to_upsample = []
# Dense Block
for j in range(n_layers_per_block[n_pool]):
stack = BN_ReLU_Conv(stack, n_filters[n_pool], dropout_p=dropout_p)
#######################
# Upsampling path #
#######################
for i in range(n_pool):
# Transition Up ( Upsampling + concatenation with the skip connection)
stack = TransitionUpRes(skip_connection_list[i], stack,
n_filters[n_pool + i + 1], dropout_p=dropout_p)
# Dense Block
block_to_upsample = []
for j in range(n_layers_per_block[n_pool + i + 1]):
stack = BN_ReLU_Conv(stack, n_filters[n_pool + i + 1],
dropout_p=dropout_p)
#####################
# Sigmoid #
#####################
self.output_layer = SpatialSoftmaxLayer(stack)
name='rmsprop_f_update')
params = [zipped_grads, running_grads, running_grads2, updir]
return (f_grad_shared, f_update, params)
##################################################################
# Variables and Constants
MAX_ITERS = 150 # 450
CONV_EPS = 1e-5
DFLT_VDIM = 100
_HE_NORMAL = HeNormal()
HE_NORMAL = lambda x: floatX(_HE_NORMAL.sample(x))
_HE_UNIFORM = HeUniform()
HE_UNIFORM = lambda x: floatX(_HE_UNIFORM.sample(x))
_HE_UNIFORM_RELU = HeUniform(gain=np.sqrt(2))
HE_UNIFORM_RELU = lambda x: floatX(_HE_UNIFORM_RELU.sample(x))
_RELU_ALPHA = 0.
_HE_UNIFORM_LEAKY_RELU = HeUniform(
gain=np.sqrt(2. / (1 + (_RELU_ALPHA or 1e-6)**2)))
HE_UNIFORM_LEAKY_RELU = lambda x: \
floatX(_HE_UNIFORM_LEAKY_RELU.sample(x))
_ORTHOGONAL = Orthogonal()
ORTHOGONAL = lambda x: floatX(_ORTHOGONAL.sample(x))
TRNG = RandomStreams()
