def __init__(self, nvis, num_hid, num_hid_2, num_class, h0_max_col_norm=None, h1_max_col_norm=None, y_max_col_norm=None): self.__dict__.update(locals()) del self.self self.input_space = VectorSpace(nvis) self.output_space = VectorSpace(num_class) self.theano_rng = MRG_RandomStreams(2012 + 10 + 16) rng = np.random.RandomState([16, 10, 2012]) self.W = sharedX(rng.uniform(-.05, .05, (nvis, num_hid)), 'h0_W') self.hb = sharedX(np.zeros((num_hid, )) - 1.) self.V = sharedX(rng.uniform(-.05, .05, (num_hid, num_hid_2)), 'h1_W') self.gb = sharedX(np.zeros((num_hid_2, )) - 1.) self.V2 = sharedX(rng.uniform(-.05, .05, (num_hid_2, num_class)), 'y_W') self.cb = sharedX(np.zeros((num_class, ))) self._params = [self.W, self.hb, self.V, self.V2, self.gb, self.cb]
def __setstate__(self, d): """ .. todo:: WRITEME """ if d['design_loc'] is not None: if control.get_load_data(): d['X'] = np.load(d['design_loc']) else: d['X'] = None if d['compress']: X = d['X'] mx = d['compress_max'] mn = d['compress_min'] del d['compress_max'] del d['compress_min'] d['X'] = 0 self.__dict__.update(d) if X is not None: self.X = np.cast['float32'](X) * mx / 255. + mn else: self.X = None else: self.__dict__.update(d) # To be able to unpickle older data after the addition of # the data_specs mechanism if not all(m in d for m in ('data_specs', 'X_space', '_iter_data_specs', 'X_topo_space')): X_space = VectorSpace(dim=self.X.shape[1]) X_source = 'features' if self.y is None: space = X_space source = X_source else: y_space = VectorSpace(dim=self.y.shape[-1]) y_source = 'targets' space = CompositeSpace((X_space, y_space)) source = (X_source, y_source) self.data_specs = (space, source) self.X_space = X_space self._iter_data_specs = (X_space, X_source) view_converter = d.get('view_converter', None) if view_converter is not None: # Get the topo_space from the view_converter if not hasattr(view_converter, 'topo_space'): raise NotImplementedError("Not able to get a topo_space " "from this converter: %s" % view_converter) # self.X_topo_space stores a "default" topological space that # will be used only when self.iterator is called without a # data_specs, and with "topo=True", which is deprecated. self.X_topo_space = view_converter.topo_space
def set_input_space(self, space): self.input_space = space if isinstance(space, VectorSpace): self.requires_reformat = False self.input_dim = space.dim else: self.requires_reformat = True self.input_dim = space.get_total_dimension() self.desired_space = VectorSpace(self.input_dim) self.output_space = VectorSpace(self.dim) rng = self.mlp.rng W = rng.uniform(-self.irange, self.irange, (self.input_dim, self.dim)) W = sharedX(W) W.name = self.layer_name + '_W' self.transformer = MatrixMul(W) W, = self.transformer.get_params() assert W.name is not None
def set_input_space(self, space): self.input_space = space if isinstance(space, VectorSpace): self.requires_reformat = False self.input_dim = space.dim else: self.requires_reformat = True self.input_dim = space.get_total_dimension() self.desired_space = VectorSpace(self.input_dim) self.output_space = VectorSpace(self.dim) self.rng = self.mlp.rng # sanity checking assert self.dictionary.input_dim == self.input_dim assert self.dictionary.size >= self.dim indices = self.rng.permutation(self.dictionary.size) indices = indices[:self.dim] indices.sort() W = self.dictionary.get_subdictionary(indices) # dictionary atoms are stored in rows but transformers expect them to # be in columns. W = sharedX(W.T) W.name = self.layer_name + "_W" self.transformer = MatrixMul(W)
def test_multiple_inputs(): """ Create a VectorSpacesDataset with two inputs (features0 and features1) and train an MLP which takes both inputs for 1 epoch. """ mlp = MLP(layers=[ FlattenerLayer( CompositeLayer('composite', [Linear(10, 'h0', 0.1), Linear(10, 'h1', 0.1)], { 0: [1], 1: [0] })), Softmax(5, 'softmax', 0.1) ], input_space=CompositeSpace([VectorSpace(15), VectorSpace(20)]), input_source=('features0', 'features1')) dataset = VectorSpacesDataset( (np.random.rand(20, 20).astype(theano.config.floatX), np.random.rand(20, 15).astype(theano.config.floatX), np.random.rand(20, 5).astype(theano.config.floatX)), (CompositeSpace( [VectorSpace(20), VectorSpace(15), VectorSpace(5)]), ('features1', 'features0', 'targets'))) train = Train(dataset, mlp, SGD(0.1, batch_size=5)) train.algorithm.termination_criterion = EpochCounter(1) train.main_loop()
def test_input_and_target_source(): """ Create a MLP and test input_source and target_source for default and non-default options. """ mlp = MLP( layers=[CompositeLayer( 'composite', [Linear(10, 'h0', 0.1), Linear(10, 'h1', 0.1)], { 0: [1], 1: [0] } ) ], input_space=CompositeSpace([VectorSpace(15), VectorSpace(20)]), input_source=('features0', 'features1'), target_source=('targets0', 'targets1') ) np.testing.assert_equal(mlp.get_input_source(), ('features0', 'features1')) np.testing.assert_equal(mlp.get_target_source(), ('targets0', 'targets1')) mlp = MLP( layers=[Linear(10, 'h0', 0.1)], input_space=VectorSpace(15) ) np.testing.assert_equal(mlp.get_input_source(), 'features') np.testing.assert_equal(mlp.get_target_source(), 'targets')
def __init__(self, nvis, nclasses): """ Initialize the parameters of the logistic regression instance. Parameters ---------- nvis : int number of input units, the dimension of the space in which \ the datapoints lie. nclasses : int number of output units, the dimension of the space in which \ the labels lie. """ super(LogisticRegressionLayer, self).__init__() assert nvis >= 0, "Number of visible units must be non-negative" self.input_space = VectorSpace(nvis) self.output_space = VectorSpace(nclasses) assert nclasses >= 0, "Number of classes must be non-negative" self.nvis = nvis self.nclasses = nclasses # initialize with 0 the weights W as a matrix of shape (nvis, nclasses) self.W = sharedX(numpy.zeros((nvis, nclasses)), name='W', borrow=True) # initialize the biases b as a vector of nclasses 0s self.b = sharedX(numpy.zeros((nclasses, )), name='b', borrow=True) # parameters of the model self._params = [self.W, self.b]
def set_input_space(self, space): self.input_space = space if isinstance(space, VectorSpace): self.requires_reformat = False self.input_dim = space.dim else: self.requires_reformat = True self.input_dim = space.get_total_dimension() self.desired_space = VectorSpace(self.input_dim) self.output_space = VectorSpace(self.dim) # we cannot set this in init() as we're not sure about input dimesnions yet if self.istdev is not None: W = self.rng.randn(self.input_dim, self.dim) * self.istdev b = self.rng.randn(self.dim, ) * self.istdev else: W = np.zeros((self.input_dim, self.dim)) b = np.zeros((self.dim, )) * self.istdev self.W = theano.shared(theano._asarray(W, dtype=theano.config.floatX), name=(self.layer_name + '_W')) self.b = theano.shared(theano._asarray(b, dtype=theano.config.floatX), name=(self.layer_name + '_b'))
def __init__(self, nvis, nhid, num_S=0, init_W=None): super(CMModel, self).__init__() self.nvis = nvis self.nhid = nhid self.num_S = num_S assert num_S in { 0, 1 }, "Currently only num_S == 0 or num_S == 1 is supported!" if init_W: model = pickle.load(open(init_W, "rb")) W = model.W.get_value() self.W = sharedX(W) else: self.W = sharedX(np.random.uniform(-1e-3, 1e-3, (nhid, nvis))) self.S = sharedX(np.random.uniform(-1e-3, 1e-3, (nhid, nhid))) self.theta = sharedX(np.zeros(nhid)) if self.num_S > 0: self._params = [self.W, self.S, self.theta] else: self._params = [self.W, self.theta] self.input_space = VectorSpace(dim=nvis) self.output_space = VectorSpace(dim=nhid)
def set_input_space(self, space): self.input_space = space if isinstance(space, VectorSpace): self.requires_reformat = False self.input_dim = space.dim else: self.requires_reformat = True self.input_dim = space.get_total_dimension() self.desired_space = VectorSpace(self.input_dim) if self.fprop_code==True: self.output_space = VectorSpace(self.dim) else: self.output_space = VectorSpace(self.input_dim) rng = self.mlp.rng W = rng.randn(self.input_dim, self.dim) self.W = sharedX(W.T, self.layer_name + '_W') self.transformer = MatrixMul(self.W) self.W, = self.transformer.get_params() b = np.zeros((self.input_dim,)) self.b = sharedX(b, self.layer_name + '_b') # We need both to pass input_dim valid X = .001 * rng.randn(self.batch_size, self.dim) self.X = sharedX(X, self.layer_name + '_X') self._params = [self.W, self.b, self.X] self.state_below = T.zeros((self.batch_size, self.input_dim))
def test_get_layer_monitor_channels(): """ Create a MLP with multiple layer types and get layer monitoring channels for MLP. """ mlp = MLP(layers=[ FlattenerLayer( CompositeLayer('composite', [Linear(10, 'h0', 0.1), Linear(10, 'h1', 0.1)], { 0: [1], 1: [0] })), Softmax(5, 'softmax', 0.1) ], input_space=CompositeSpace([VectorSpace(15), VectorSpace(20)]), input_source=('features0', 'features1')) dataset = VectorSpacesDataset( (np.random.rand(20, 20).astype(theano.config.floatX), np.random.rand(20, 15).astype(theano.config.floatX), np.random.rand(20, 5).astype(theano.config.floatX)), (CompositeSpace( [VectorSpace(20), VectorSpace(15), VectorSpace(5)]), ('features1', 'features0', 'targets'))) state_below = mlp.get_input_space().make_theano_batch() targets = mlp.get_target_space().make_theano_batch() mlp.get_layer_monitoring_channels(state_below=state_below, state=None, targets=targets)
def set_input_space(self, space): """ Note: this resets parameters! """ self.input_space = space if isinstance(space, VectorSpace): self.requires_reformat = False self.input_dim = space.dim else: self.requires_reformat = True self.input_dim = space.get_total_dimension() self.desired_space = VectorSpace(self.input_dim) self.output_space = VectorSpace(self.dim) rng = self.dbm.rng if self.irange is not None: assert self.sparse_init is None W = rng.uniform(-self.irange, self.irange, (self.input_dim, self.dim)) * \ (rng.uniform(0.,1., (self.input_dim, self.dim)) < self.include_prob) else: assert self.sparse_init is not None W = np.zeros((self.input_dim, self.dim)) W *= self.sparse_stdev W = sharedX(W) W.name = self.layer_name + '_W' self.transformer = MatrixMul(W) W ,= self.transformer.get_params() assert W.name is not None
def __init__(self): self.W1 = [sharedX(rng.randn(num_features, chunk_width)) for i in xrange(num_chunks)] disturb_mem.disturb_mem() self.W2 = [sharedX(rng.randn(chunk_width)) for i in xrange(num_chunks)] self._params = safe_union(self.W1, self.W2) self.input_space = VectorSpace(num_features) self.output_space = VectorSpace(1)
def __init__(self, X_path=None, y_path=None, from_scipy_sparse_dataset=None, zipped_npy=False): self.X_path = X_path self.y_path = y_path if self.X_path != None: if zipped_npy == True: logger.info('... loading sparse data set from a zip npy file') self.X = scipy.sparse.csr_matrix(numpy.load(gzip.open(X_path)), dtype=floatX) else: logger.info('... loading sparse data set from a npy file') self.X = scipy.sparse.csr_matrix(numpy.load(X_path).item(), dtype=floatX) else: logger.info('... building from given sparse dataset') self.X = from_scipy_sparse_dataset if self.y_path != None: if zipped_npy == True: logger.info('... loading sparse data set from a zip npy file') self.y = scipy.sparse.csr_matrix(numpy.load(gzip.open(y_path)), dtype=floatX).todense() else: logger.info('... loading sparse data set from a npy file') self.y = scipy.sparse.csr_matrix(numpy.load(y_path).item(), dtype=floatX) else: logger.info('... building from given sparse dataset') self.X = from_scipy_sparse_dataset self.data_n_rows = self.X.shape[0] self.num_examples = self.data_n_rows self.fancy = False self.stochastic = False X_space = VectorSpace(dim=self.X.shape[1]) X_source = 'features' if y_path is None: space = X_space source = X_source else: if self.y.ndim == 1: dim = 1 else: dim = self.y.shape[-1] y_space = VectorSpace(dim=dim) y_source = 'targets' space = CompositeSpace((X_space, y_space)) source = (X_source, y_source) self.data_specs = (space, source) self.X_space = X_space self._iter_data_specs = (self.X_space, 'features')
def set_topological_view(self, V, axes=('b', 0, 1, 'c')): """ Sets the dataset to represent V, where V is a batch of topological views of examples. .. todo:: Why is this parameter named 'V'? Parameters ---------- V : ndarray An array containing a design matrix representation of training examples. axes : WRITEME """ assert not contains_nan(V) rows = V.shape[axes.index(0)] cols = V.shape[axes.index(1)] channels = V.shape[axes.index('c')] self.view_converter = DefaultViewConverter([rows, cols, channels], axes=axes) self.X = self.view_converter.topo_view_to_design_mat(V) # self.X_topo_space stores a "default" topological space that # will be used only when self.iterator is called without a # data_specs, and with "topo=True", which is deprecated. self.X_topo_space = self.view_converter.topo_space assert not contains_nan(self.X) # Update data specs X_space = VectorSpace(dim=self.X.shape[1]) X_source = 'features' if self.y is None: space = X_space source = X_source else: if self.y.ndim == 1: dim = 1 else: dim = self.y.shape[-1] # This is to support old pickled models if getattr(self, 'y_labels', None) is not None: y_space = IndexSpace(dim=dim, max_labels=self.y_labels) elif getattr(self, 'max_labels', None) is not None: y_space = IndexSpace(dim=dim, max_labels=self.max_labels) else: y_space = VectorSpace(dim=dim) y_source = 'targets' Latent_space = VectorSpace(dim=self.latent.shape[-1]) Latent_source = 'latents' space = CompositeSpace((X_space, y_space,Latent_space)) source = (X_source, y_source,Latent_source) self.data_specs = (space, source) self.X_space = X_space self._iter_data_specs = (X_space, X_source)
def test_np_format_as_index2vector(): # Test 5 random batches for shape, number of non-zeros for _ in xrange(5): max_labels = np.random.randint(2, 10) batch_size = np.random.randint(1, 10) labels = np.random.randint(1, 10) batch = np.random.random_integers(max_labels - 1, size=(batch_size, labels)) index_space = IndexSpace(dim=labels, max_labels=max_labels) vector_space_merge = VectorSpace(dim=max_labels) vector_space_concatenate = VectorSpace(dim=max_labels * labels) merged = index_space.np_format_as(batch, vector_space_merge) concatenated = index_space.np_format_as(batch, vector_space_concatenate) if batch_size > 1: assert merged.shape == (batch_size, max_labels) assert concatenated.shape == (batch_size, max_labels * labels) else: assert merged.shape == (max_labels, ) assert concatenated.shape == (max_labels * labels, ) assert np.count_nonzero(merged) <= batch.size assert np.count_nonzero(concatenated) == batch.size assert np.all(np.unique(concatenated) == np.array([0, 1])) # Make sure Theano variables give the same result batch = tensor.lmatrix('batch') single = tensor.lvector('single') batch_size = np.random.randint(2, 10) np_batch = np.random.random_integers(max_labels - 1, size=(batch_size, labels)) np_single = np.random.random_integers(max_labels - 1, size=(labels)) f_batch_merge = theano.function([batch], index_space._format_as_impl( False, batch, vector_space_merge)) f_batch_concatenate = theano.function([batch], index_space._format_as_impl( False, batch, vector_space_concatenate)) f_single_merge = theano.function([single], index_space._format_as_impl( False, single, vector_space_merge)) f_single_concatenate = theano.function([single], index_space._format_as_impl( False, single, vector_space_concatenate)) np.testing.assert_allclose( f_batch_merge(np_batch), index_space._format_as_impl(True, np_batch, vector_space_merge)) np.testing.assert_allclose( f_batch_concatenate(np_batch), index_space._format_as_impl(True, np_batch, vector_space_concatenate)) np.testing.assert_allclose( f_single_merge(np_single), index_space._format_as_impl(True, np_single, vector_space_merge)) np.testing.assert_allclose( f_single_concatenate(np_single), index_space._format_as_impl(True, np_single, vector_space_concatenate))
def set_topological_view(self, V, axes=('b', 0, 1, 'c')): """ Set up dataset topological view, without building an in-memory design matrix. This is mostly copied from DenseDesignMatrix, except: * HDF5ViewConverter is used instead of DefaultViewConverter * Data specs are derived from topo_view, not X * NaN checks have been moved to HDF5DatasetIterator.next Note that y may be loaded into memory for reshaping if y.ndim != 2. Parameters ---------- V : ndarray Topological view. axes : tuple, optional (default ('b', 0, 1, 'c')) Order of axes in topological view. """ shape = [ V.shape[axes.index('b')], V.shape[axes.index(0)], V.shape[axes.index(1)], V.shape[axes.index('c')] ] self.view_converter = HDF5ViewConverter(shape[1:], axes=axes) self.X = self.view_converter.topo_view_to_design_mat(V) # self.X_topo_space stores a "default" topological space that # will be used only when self.iterator is called without a # data_specs, and with "topo=True", which is deprecated. self.X_topo_space = self.view_converter.topo_space # Update data specs X_space = VectorSpace(dim=V.shape[axes.index('b')]) X_source = 'features' if self.y is None: space = X_space source = X_source else: if self.y.ndim == 1: dim = 1 else: dim = self.y.shape[-1] # check if y_labels has been specified if getattr(self, 'y_labels', None) is not None: y_space = IndexSpace(dim=dim, max_labels=self.y_labels) elif getattr(self, 'max_labels', None) is not None: y_space = IndexSpace(dim=dim, max_labels=self.max_labels) else: y_space = VectorSpace(dim=dim) y_source = 'targets' space = CompositeSpace((X_space, y_space)) source = (X_source, y_source) self.data_specs = (space, source) self.X_space = X_space self._iter_data_specs = (X_space, X_source)
def make_composite_space(dtype0, dtype1, use_conv2d): if use_conv2d: second_space = Conv2DSpace(shape=shape[:2], dtype=dtype1, num_channels=shape[2]) else: second_space = VectorSpace(dim=np.prod(shape), dtype=dtype1) return CompositeSpace((VectorSpace(dim=shape.prod(), dtype=dtype0), second_space))
def set_input_space(self, space): if ((not isinstance(space, SequenceSpace) and not isinstance(space, SequenceDataSpace)) or not isinstance(space.space, VectorSpace)): raise ValueError("Recurrent layer needs a SequenceSpace(" "VectorSpace) or SequenceDataSpace(VectorSpace)\ as input but received %s instead" % (space)) self.input_space = space if self.indices is not None: if len(self.indices) > 1: raise ValueError("Only indices = [-1] is supported right now") self.output_space = CompositeSpace( [VectorSpace(dim=self.dim) for _ in range(len(self.indices))] ) else: assert self.indices == [-1], "Only indices = [-1] works now" self.output_space = VectorSpace(dim=self.dim) else: if isinstance(self.input_space, SequenceSpace): self.output_space = SequenceSpace(VectorSpace(dim=self.dim)) elif isinstance(self.input_space, SequenceDataSpace): self.output_space =\ SequenceDataSpace(VectorSpace(dim=self.dim)) # Initialize the parameters rng = self.mlp.rng if self.irange is None: raise ValueError("Recurrent layer requires an irange value in " "order to initialize its weight matrices") input_dim = self.input_space.dim # W is the input-to-hidden matrix W = rng.uniform(-self.irange, self.irange, (input_dim, self.dim * 4)) # U is the hidden-to-hidden transition matrix U = np.zeros((self.dim, self.dim * 4)) for i in xrange(4): u = rng.randn(self.dim, self.dim) U[:, i*self.dim:(i+1)*self.dim], _ = scipy.linalg.qr(u) # b is the bias b = np.zeros((self.dim * 4,)) self._params = [ sharedX(W, name=(self.layer_name + '_W')), sharedX(U, name=(self.layer_name + '_U')), sharedX(b + self.init_bias, name=(self.layer_name + '_b')) ]
def test_input_validation(): """ DataSpecsMapping should raise errors if inputs are not formatted as data specs. """ assert_raises(ValueError, DataSpecsMapping, (VectorSpace(dim=10), ('features', 'targets'))) assert_raises(AssertionError, DataSpecsMapping, (('features', 'targets'), VectorSpace(dim=10)))
def __init__(self, nvis, prior, conditional, posterior, nhid, learn_prior=True, kl_integrator=None, batch_size=None, seed=None): super(VAE, self).__init__() self.__dict__.update(locals()) del self.self self.rng = make_np_rng(self.seed, default_seed, ['uniform', 'randint', 'randn']) self.prior.set_vae(self) self.conditional.set_vae(self) self.posterior.set_vae(self) self.learn_prior = learn_prior # Space initialization self.input_space = VectorSpace(dim=self.nvis) self.input_source = 'features' self.latent_space = VectorSpace(dim=self.nhid) # Parameter initialization self.prior.initialize_parameters(nhid=self.nhid) self.conditional.initialize_parameters(input_space=self.latent_space, ndim=self.nvis) self.posterior.initialize_parameters(input_space=self.input_space, ndim=self.nhid) self._params = (self.get_posterior_params() + self.get_conditional_params()) if self.learn_prior: self._params += self.get_prior_params() names = [] for param in self._params: if param.name not in names: names.append(param.name) else: raise Exception( "no two parameters must share the same name: " + param.name) # Look for the right KLIntegrator if it's not specified if self.kl_integrator is None: self.kl_integrator = find_integrator_for(self.prior, self.posterior)
def cost_from_X_data_specs(self): if self.action_dims: space = [self.get_input_space()] space.append(VectorSpace(dim=self.action_dims)) #space.append(self.get_output_space()) space.append(VectorSpace(dim=1)) space = CompositeSpace(space) source = (self.get_input_source(), 'one_hot_mat', self.get_target_source()) return (space, source)
def set_topological_view(self, V, axes=('b', 0, 1, 'c')): """ Sets the dataset to represent V, where V is a batch of topological views of examples. Parameters ---------- V : ndarray An array containing a design matrix representation of training \ examples. axes : WRITEME .. todo:: Why is this parameter named 'V'? """ assert not np.any(np.isnan(V)) rows = V.shape[axes.index(0)] cols = V.shape[axes.index(1)] channels = V.shape[axes.index('c')] self.view_converter = DefaultViewConverter([rows, cols, channels], axes=axes) self.X = self.view_converter.topo_view_to_design_mat(V) # self.X_topo_space stores a "default" topological space that # will be used only when self.iterator is called without a # data_specs, and with "topo=True", which is deprecated. self.X_topo_space = self.view_converter.topo_space assert not np.any(np.isnan(self.X)) # Update data specs X_space = VectorSpace(dim=self.X.shape[1]) X_source = 'features' if self.y is None: space = X_space source = X_source else: if self.y.ndim != 2: raise NotImplementedError("It appears the new space / source interface" " broke the ability to iterate over 1D labels. Please" " use one-hot rather than integer-valued class labels" ". Most Pylearn2 Datasets have a one_hot argument you" " can set to True.") # The -1 index in this line assumes y.ndim is 2 y_space = VectorSpace(dim=self.y.shape[-1]) y_source = 'targets' space = CompositeSpace((X_space, y_space)) source = (X_source, y_source) self.data_specs = (space, source) self.X_space = X_space self._iter_data_specs = (X_space, X_source)
def fit_transform(self, X, y=None, **fit_params): print X.shape nfeat = X.shape[1] X = X.astype(theano.config.floatX) if y is None: dataset = VectorSpacesDataset(X, (VectorSpace(nfeat), 'features')) else: y = np.reshape(y, (y.shape[0], 1)) space = CompositeSpace([VectorSpace(nfeat), VectorSpace(1)]) source = ('features', 'targets') data_specs = (space, source) dataset = VectorSpacesDataset((X, y), data_specs) return dataset
def __init__(self, nvis, nclasses): super(LogisticRegression, self).__init__() self.nvis = nvis self.nclasses = nclasses W_value = numpy.random.uniform(size=(self.nvis, self.nclasses)) self.W = sharedX(W_value, 'W') b_value = numpy.zeros(self.nclasses) self.b = sharedX(b_value, 'b') self._params = [self.W, self.b] self.input_space = VectorSpace(dim=self.nvis) self.output_space = VectorSpace(dim=self.nclasses)
def set_topological_view(self, V, axes=('b', 0, 1, 'c')): """ Sets the dataset to represent V, where V is a batch of topological views of examples. Parameters ---------- V : ndarray An array containing a design matrix representation of training \ examples. axes : WRITEME .. todo:: Why is this parameter named 'V'? """ assert not np.any(np.isnan(V)) rows = V.shape[axes.index(0)] cols = V.shape[axes.index(1)] channels = V.shape[axes.index('c')] self.view_converter = DefaultViewConverter([rows, cols, channels], axes=axes) self.X = self.view_converter.topo_view_to_design_mat(V) # self.X_topo_space stores a "default" topological space that # will be used only when self.iterator is called without a # data_specs, and with "topo=True", which is deprecated. self.X_topo_space = self.view_converter.topo_space assert not np.any(np.isnan(self.X)) # Update data specs X_space = VectorSpace(dim=self.X.shape[1]) X_source = 'features' if self.y is None: space = X_space source = X_source else: if self.y.ndim != 2: assert self.max_labels y_space = IndexSpace(max_labels=self.max_labels, dim=1) y_source = 'targets' else: y_space = VectorSpace(dim=self.y.shape[-1]) y_source = 'targets' space = CompositeSpace((X_space, y_space)) source = (X_source, y_source) self.data_specs = (space, source) self.X_space = X_space self._iter_data_specs = (X_space, X_source)
def set_input_space(self, space): self.input_space = space assert isinstance(space, CompositeSpace) self.input_dim = [] self.desired_space = [] for sp in space.components: if isinstance(sp, VectorSpace): self.requires_reformat = False self.input_dim.append(sp.dim) else: self.requires_reformat = True self.input_dim.append(sp.get_total_dimension()) self.desired_space.append( VectorSpace(self.input_dim[-1]) ) if self.fprop_code==True: self.output_space = VectorSpace(self.dim) else: #self.output_space = VectorSpace(self.input_dim) # TODO: return composite space raise NotImplementedError rng = self.mlp.rng self.W = [] self.S = [] self.b = [] self.transformer = [] self._params = [] X = .001 * rng.randn(self.batch_size, self.dim) self.X = sharedX(X, self.layer_name + '_X') for c in range(len(self.input_space.components)): W = rng.randn(self.input_dim[c], self.dim) self.W += [ sharedX(W.T, self.layer_name + '_W' + str(c)) ] self.transformer += [ MatrixMul(self.W[c]) ] self.W[-1], = self.transformer[-1].get_params() b = np.zeros((self.input_dim[c],)) self.b += [ sharedX(b, self.layer_name + '_b' + str(c)) ] # We need both to pass input_dim valid S = rng.normal(0, .001, size=(self.batch_size, self.input_dim[c])) self.S += [ sharedX(S, self.layer_name + '_S' + str(c)) ] self._params += [self.W[-1], self.b[-1]] #self.state_below = T.zeros((self.batch_size, self.input_dim)) cost = self.get_local_cost() self.opt = top.Optimizer(self.X, cost, method='rmsprop', learning_rate=self.lr, momentum=.9)
def set_input_space(self, space): """ Note: this resets parameters! """ self.input_space = space if isinstance(space, VectorSpace): self.requires_reformat = False self.input_dim = space.dim else: self.requires_reformat = True self.input_dim = space.get_total_dimension() self.desired_space = VectorSpace(self.input_dim) if not (self.detector_layer_dim % self.pool_size == 0): raise ValueError( "detector_layer_dim = %d, pool_size = %d. Should be divisible but remainder is %d" % (self.detector_layer_dim, self.pool_size, self.detector_layer_dim % self.pool_size)) self.h_space = VectorSpace(self.detector_layer_dim) self.pool_layer_dim = self.detector_layer_dim / self.pool_size self.output_space = VectorSpace(self.pool_layer_dim) rng = self.dbm.rng if self.irange is not None: assert self.sparse_init is None W = rng.uniform(-self.irange, self.irange, (self.input_dim, self.detector_layer_dim)) * \ (rng.uniform(0.,1., (self.input_dim, self.detector_layer_dim)) < self.include_prob) else: assert self.sparse_init is not None W = np.zeros((self.input_dim, self.detector_layer_dim)) for i in xrange(self.detector_layer_dim): for j in xrange(self.sparse_init): idx = rng.randint(0, self.input_dim) while W[idx, i] != 0: idx = rng.randint(0, self.input_dim) W[idx, i] = rng.randn() W = sharedX(W) W.name = self.layer_name + '_W' self.transformer = MatrixMul(W) W, = self.transformer.get_params() assert W.name is not None
def __init__(self, corruptor, nvis, nhid, act_enc, act_dec, tied_weights=False, irange=1e-3, rng=9001): # sampling dot only supports tied weights assert tied_weights == True self.names_to_del = set() super(SparseDenoisingAutoencoder, self).__init__(corruptor, nvis, nhid, act_enc, act_dec, tied_weights=tied_weights, irange=irange, rng=rng) # this step is crucial to save loads of space because w_prime is never used in # training the sparse da. del self.w_prime self.input_space = VectorSpace(nvis, sparse=True)
def test_vector_to_conv_c01b_invertible(): """ Tests that the format_as methods between Conv2DSpace and VectorSpace are invertible for the ('c', 0, 1, 'b') axis format. """ rng = np.random.RandomState([2013, 5, 1]) batch_size = 3 rows = 4 cols = 5 channels = 2 conv = Conv2DSpace([rows, cols], channels=channels, axes=('c', 0, 1, 'b')) vec = VectorSpace(conv.get_total_dimension()) X = conv.make_batch_theano() Y = conv.format_as(X, vec) Z = vec.format_as(Y, conv) A = vec.make_batch_theano() B = vec.format_as(A, conv) C = conv.format_as(B, vec) f = function([X, A], [Z, C]) X = rng.randn(*(conv.get_origin_batch(batch_size).shape)).astype(X.dtype) A = rng.randn(*(vec.get_origin_batch(batch_size).shape)).astype(A.dtype) Z, C = f(X, A) np.testing.assert_allclose(Z, X) np.testing.assert_allclose(C, A)