def __init__(self, numpy_rng, theano_rng=None, cfg = None, dnn = None): """ Stacked Denoising Autoencoders for DNN Pre-training """ self.cfg = cfg self.hidden_layers_sizes = cfg.hidden_layers_sizes self.n_ins = cfg.n_ins self.hidden_layers_number = len(self.hidden_layers_sizes) self.dA_layers = [] if not theano_rng: theano_rng = RandomStreams(numpy_rng.randint(2 ** 30)) # allocate symbolic variables for the data self.x = dnn.x for i in range(self.hidden_layers_number): # the size of the input is either the number of hidden units of # the layer below, or the input size if we are on the first layer if i == 0: input_size = self.n_ins layer_input = self.x else: input_size = self.hidden_layers_sizes[i - 1] layer_input = dnn.layers[i-1].output # Construct a denoising autoencoder that shared weights with this layer if i == 0: reconstruct_activation = cfg.firstlayer_reconstruct_activation else: reconstruct_activation = cfg.hidden_activation dA_layer = dA(numpy_rng=numpy_rng, theano_rng=theano_rng, input=layer_input, n_visible=input_size, n_hidden=self.hidden_layers_sizes[i], W=dnn.layers[i].W, bhid=dnn.layers[i].b, sparsity = cfg.sparsity, sparsity_weight = cfg.sparsity_weight, hidden_activation = cfg.hidden_activation, reconstruct_activation = reconstruct_activation) self.dA_layers.append(dA_layer)
def __init__(self, numpy_rng, theano_rng=None, cfg=None, dnn=None): """ Stacked Denoising Autoencoders for DNN Pre-training """ self.cfg = cfg self.hidden_layers_sizes = cfg.hidden_layers_sizes self.n_ins = cfg.n_ins self.hidden_layers_number = len(self.hidden_layers_sizes) self.dA_layers = [] if not theano_rng: theano_rng = RandomStreams(numpy_rng.randint(2**30)) # allocate symbolic variables for the data self.x = dnn.x for i in xrange(self.hidden_layers_number): # the size of the input is either the number of hidden units of # the layer below, or the input size if we are on the first layer if i == 0: input_size = self.n_ins layer_input = self.x else: input_size = self.hidden_layers_sizes[i - 1] layer_input = dnn.layers[i - 1].output # Construct a denoising autoencoder that shared weights with this layer if i == 0: reconstruct_activation = cfg.firstlayer_reconstruct_activation else: reconstruct_activation = cfg.hidden_activation dA_layer = dA(numpy_rng=numpy_rng, theano_rng=theano_rng, input=layer_input, n_visible=input_size, n_hidden=self.hidden_layers_sizes[i], W=dnn.layers[i].W, bhid=dnn.layers[i].b, sparsity=cfg.sparsity, sparsity_weight=cfg.sparsity_weight, hidden_activation=cfg.hidden_activation, reconstruct_activation=reconstruct_activation) self.dA_layers.append(dA_layer)
def __init__(self, numpy_rng, theano_rng=None, n_ins=784, hidden_layers_sizes=[500, 500], n_outs=10, corruption_levels=[0.1, 0.1], sparsity = None, sparsity_weight = None, hidden_activation = T.nnet.sigmoid, first_reconstruct_activation = T.tanh): self.sigmoid_layers = [] self.dA_layers = [] self.params = [] self.n_layers = len(hidden_layers_sizes) assert self.n_layers > 0 if not theano_rng: theano_rng = RandomStreams(numpy_rng.randint(2 ** 30)) # allocate symbolic variables for the data self.x = T.matrix('x') self.y = T.ivector('y') for i in xrange(self.n_layers): # construct the sigmoidal layer # the size of the input is either the number of hidden units of # the layer below or the input size if we are on the first layer if i == 0: input_size = n_ins else: input_size = hidden_layers_sizes[i - 1] # the input to this layer is either the activation of the hidden # layer below or the input of the SdA if you are on the first # layer if i == 0: layer_input = self.x else: layer_input = self.sigmoid_layers[-1].output sigmoid_layer = HiddenLayer(rng=numpy_rng, input=layer_input, n_in=input_size, n_out=hidden_layers_sizes[i], activation=hidden_activation) # add the layer to our list of layers self.sigmoid_layers.append(sigmoid_layer) self.params.extend(sigmoid_layer.params) # Construct a denoising autoencoder that shared weights with this layer if i == 0: reconstruct_activation = first_reconstruct_activation else: reconstruct_activation = hidden_activation dA_layer = dA(numpy_rng=numpy_rng, theano_rng=theano_rng, input=layer_input, n_visible=input_size, n_hidden=hidden_layers_sizes[i], W=sigmoid_layer.W, bhid=sigmoid_layer.b, sparsity = sparsity, sparsity_weight = sparsity_weight, hidden_activation = hidden_activation, reconstruct_activation = reconstruct_activation) self.dA_layers.append(dA_layer) # We now need to add a logistic layer on top of the MLP self.logLayer = LogisticRegression( input=self.sigmoid_layers[-1].output, n_in=hidden_layers_sizes[-1], n_out=n_outs) self.sigmoid_layers.append(self.logLayer) self.params.extend(self.logLayer.params)