def make_random_basic_binary_dbm(
rng,
pool_size_1,
num_vis = None,
num_pool_1 = None,
num_pool_2 = None,
pool_size_2 = None,
center = False
):
"""
Makes a DBM with BinaryVector for the visible layer,
and two hidden layers of type BinaryVectorMaxPool.
The weights and biases are initialized randomly with
somewhat large values (i.e., not what you'd want to
use for learning)
rng: A numpy RandomState.
pool_size_1: The size of the pools to use in the first
layer.
"""
if num_vis is None:
num_vis = rng.randint(1,11)
if num_pool_1 is None:
num_pool_1 = rng.randint(1,11)
if num_pool_2 is None:
num_pool_2 = rng.randint(1,11)
if pool_size_2 is None:
pool_size_2 = rng.randint(1,6)
num_h1 = num_pool_1 * pool_size_1
num_h2 = num_pool_2 * pool_size_2
v = BinaryVector(num_vis, center=center)
v.set_biases(rng.uniform(-1., 1., (num_vis,)).astype(config.floatX), recenter=center)
h1 = BinaryVectorMaxPool(
detector_layer_dim = num_h1,
pool_size = pool_size_1,
layer_name = 'h1',
center = center,
irange = 1.)
h1.set_biases(rng.uniform(-1., 1., (num_h1,)).astype(config.floatX), recenter=center)
h2 = BinaryVectorMaxPool(
center = center,
detector_layer_dim = num_h2,
pool_size = pool_size_2,
layer_name = 'h2',
irange = 1.)
h2.set_biases(rng.uniform(-1., 1., (num_h2,)).astype(config.floatX), recenter=center)
dbm = DBM(visible_layer = v,
hidden_layers = [h1, h2],
batch_size = 1,
niter = 50)
return dbm
def test_bvmp_make_state():
# Verifies that BinaryVector.make_state creates
# a shared variable whose value passes check_binary_samples
num_pools = 3
num_samples = 1000
tol = .04
rng = np.random.RandomState([2012,11,1,9])
# pool_size=1 is an important corner case
for pool_size in [1, 2, 5]:
n = num_pools * pool_size
layer = BinaryVectorMaxPool(
detector_layer_dim=n,
layer_name='h',
irange=1.,
pool_size=pool_size)
# This is just to placate mf_update below
input_space = VectorSpace(1)
class DummyDBM(object):
def __init__(self):
self.rng = rng
layer.set_dbm(DummyDBM())
layer.set_input_space(input_space)
layer.set_biases(rng.uniform(-pool_size, 1., (n,)).astype(config.floatX))
# To find the mean of the samples, we use mean field with an input of 0
mean = layer.mf_update(
state_below=T.alloc(0., 1, 1),
state_above=None,
layer_above=None)
mean = function([], mean)()
mean = [ mn[0,:] for mn in mean ]
state = layer.make_state(num_examples=num_samples,
numpy_rng=rng)
value = [elem.get_value() for elem in state]
check_bvmp_samples(value, num_samples, n, pool_size, mean, tol)