class MultilayerPerceptronClassifier(Classifier): """ """ def initialize_l1(self, L1_reg): """ L1 norm ; one regularization option is to enforce L1 norm to be small """ self.L1 = (abs(self.hiddenLayer.weights).sum() + abs(self.logRegressionLayer.weights).sum()) self.L1_reg = L1_reg def initialize_l2(self, L2_reg): """ square of L2 norm ; one regularization option is to enforce square of L2 norm to be small """ self.L2_sqr = ((self.hiddenLayer.weights**2).sum() + (self.logRegressionLayer.weights**2).sum()) self.L2_reg = L2_reg def __init__(self, rng, n_in, n_hidden, n_out, L1_reg=0.00, L2_reg=0.0001): """ """ super(MultilayerPerceptronClassifier, self).__init__() self.hiddenLayer = HiddenLayer(rng=rng, input_units=n_in, output_units=n_hidden, nonlinear_function=Tensor.tanh) self.logRegressionLayer = LogisticClassifier(input_units=n_hidden, output_units=n_out) self.initialize_l1(L1_reg) self.initialize_l2(L2_reg) self.parameters = (self.hiddenLayer.parameters + self.logRegressionLayer.parameters) def cost_function(self, inputs, outputs): """docstring for cost""" hidden_outputs = self.hiddenLayer.output_probabilities_function(inputs) return ( self.logRegressionLayer.cost_function(hidden_outputs, outputs) + self.L1_reg * self.L1 + self.L2_reg * self.L2_sqr) def evaluation_function(self, inputs, outputs): """docstring for errors""" return self.logRegressionLayer.evaluation_function( self.hiddenLayer.output_probabilities_function(inputs), outputs)
class ConvolutionalMultilayerPerceptronClassifier(Classifier): """docstring for ConvolutionalMultilayerPerceptronClassifier""" def __init__(self, batch_size, nkerns=[20, 50]): """ """ super(ConvolutionalMultilayerPerceptronClassifier, self).__init__() self.batch_size = batch_size rng = numpy.random.RandomState(23455) # Reshape matrix of rasterized images of shape (self.batch_size,28*28) # to a 4D tensor, compatible with our PoolingLayer # Construct the first convolutional pooling layer: # filtering reduces the image size to (28-5+1,28-5+1)=(24,24) # maxpooling reduces this further to (24/2,24/2) = (12,12) # 4D output tensor is thus of shape (self.batch_size,nkerns[0],12,12) self.layer0 = PoolingLayer(rng, image_shape=(self.batch_size, 1, 28, 28), filter_shape=(nkerns[0], 1, 5, 5), poolsize=(2, 2)) # Construct the second convolutional pooling layer # filtering reduces the image size to (12-5+1,12-5+1)=(8,8) # maxpooling reduces this further to (8/2,8/2) = (4,4) # 4D output tensor is thus of shape (nkerns[0],nkerns[1],4,4) self.layer1 = PoolingLayer(rng, image_shape=(self.batch_size, nkerns[0], 12, 12), filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2)) # the HiddenLayer being fully-connected, it operates on 2D matrices of # shape (self.batch_size,num_pixels) (i.e matrix of rasterized images). # This will generate a matrix of shape (20,32*4*4) = (20,512) # construct a fully-connected sigmoidal layer self.layer2 = HiddenLayer(rng, input_units=nkerns[1] * 4 * 4, output_units=500, nonlinear_function=Tensor.tanh) # classify the values of the fully-connected sigmoidal layer self.layer3 = LogisticClassifier(input_units=500, output_units=10) # create a list of all model parameters to be fit by gradient descent self.parameters = (self.layer3.parameters + self.layer2.parameters + self.layer1.parameters + self.layer0.parameters) def cost_function(self, inputs, outputs): """docstring for cost_function""" prev_outputs = inputs.reshape((self.batch_size, 1, 28, 28)) prev_outputs = self.layer0.output_probabilities_function(prev_outputs) prev_outputs = self.layer1.output_probabilities_function( prev_outputs).flatten(2) prev_outputs = self.layer2.output_probabilities_function(prev_outputs) return self.layer3.cost_function(prev_outputs, outputs) def evaluation_function(self, inputs, outputs): """docstring for evaluation_function""" return self.layer3.evaluation_function( self.layer2.output_probabilities_function( self.layer1.output_probabilities_function( self.layer0.output_probabilities_function( inputs.reshape( (self.batch_size, 1, 28, 28)))).flatten(2)), outputs)
class MultilayerPerceptronClassifier(Classifier): """ """ def initialize_l1(self, L1_reg): """ L1 norm ; one regularization option is to enforce L1 norm to be small """ self.L1 = ( abs(self.hiddenLayer.weights).sum() + abs(self.logRegressionLayer.weights).sum() ) self.L1_reg = L1_reg def initialize_l2(self, L2_reg): """ square of L2 norm ; one regularization option is to enforce square of L2 norm to be small """ self.L2_sqr = ( (self.hiddenLayer.weights ** 2).sum() + (self.logRegressionLayer.weights ** 2).sum() ) self.L2_reg = L2_reg def __init__(self, rng, n_in, n_hidden, n_out, L1_reg=0.00, L2_reg=0.0001): """ """ super(MultilayerPerceptronClassifier, self).__init__() self.hiddenLayer = HiddenLayer( rng=rng, input_units=n_in, output_units=n_hidden, nonlinear_function=Tensor.tanh ) self.logRegressionLayer = LogisticClassifier( input_units=n_hidden, output_units=n_out ) self.initialize_l1(L1_reg) self.initialize_l2(L2_reg) self.parameters = ( self.hiddenLayer.parameters + self.logRegressionLayer.parameters ) def cost_function(self, inputs, outputs): """docstring for cost""" hidden_outputs = self.hiddenLayer.output_probabilities_function(inputs) return ( self.logRegressionLayer.cost_function( hidden_outputs, outputs ) + self.L1_reg * self.L1 + self.L2_reg * self.L2_sqr ) def evaluation_function(self, inputs, outputs): """docstring for errors""" return self.logRegressionLayer.evaluation_function( self.hiddenLayer.output_probabilities_function(inputs), outputs )
class ConvolutionalMultilayerPerceptronClassifier(Classifier): """docstring for ConvolutionalMultilayerPerceptronClassifier""" def __init__(self, batch_size, nkerns=[20, 50]): """ """ super(ConvolutionalMultilayerPerceptronClassifier, self).__init__() self.batch_size = batch_size rng = numpy.random.RandomState(23455) # Reshape matrix of rasterized images of shape (self.batch_size,28*28) # to a 4D tensor, compatible with our PoolingLayer # Construct the first convolutional pooling layer: # filtering reduces the image size to (28-5+1,28-5+1)=(24,24) # maxpooling reduces this further to (24/2,24/2) = (12,12) # 4D output tensor is thus of shape (self.batch_size,nkerns[0],12,12) self.layer0 = PoolingLayer( rng, image_shape=(self.batch_size, 1, 28, 28), filter_shape=(nkerns[0], 1, 5, 5), poolsize=(2, 2) ) # Construct the second convolutional pooling layer # filtering reduces the image size to (12-5+1,12-5+1)=(8,8) # maxpooling reduces this further to (8/2,8/2) = (4,4) # 4D output tensor is thus of shape (nkerns[0],nkerns[1],4,4) self.layer1 = PoolingLayer( rng, image_shape=(self.batch_size, nkerns[0], 12, 12), filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2) ) # the HiddenLayer being fully-connected, it operates on 2D matrices of # shape (self.batch_size,num_pixels) (i.e matrix of rasterized images). # This will generate a matrix of shape (20,32*4*4) = (20,512) # construct a fully-connected sigmoidal layer self.layer2 = HiddenLayer( rng, input_units=nkerns[1] * 4 * 4, output_units=500, nonlinear_function=Tensor.tanh ) # classify the values of the fully-connected sigmoidal layer self.layer3 = LogisticClassifier(input_units=500, output_units=10) # create a list of all model parameters to be fit by gradient descent self.parameters = ( self.layer3.parameters + self.layer2.parameters + self.layer1.parameters + self.layer0.parameters ) def cost_function(self, inputs, outputs): """docstring for cost_function""" prev_outputs = inputs.reshape((self.batch_size, 1, 28, 28)) prev_outputs = self.layer0.output_probabilities_function( prev_outputs ) prev_outputs = self.layer1.output_probabilities_function( prev_outputs ).flatten(2) prev_outputs = self.layer2.output_probabilities_function( prev_outputs ) return self.layer3.cost_function( prev_outputs, outputs ) def evaluation_function(self, inputs, outputs): """docstring for evaluation_function""" return self.layer3.evaluation_function( self.layer2.output_probabilities_function( self.layer1.output_probabilities_function( self.layer0.output_probabilities_function( inputs.reshape((self.batch_size, 1, 28, 28)) ) ).flatten(2) ), outputs )