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 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(): 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_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 __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()