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)
