def __init__(self, rng, input, filter_shape, image_shape=None, poolsize=(2,2)):
self.input = input
W_values = numpy.zeros(filter_shape, dtype=theano.config.floatX)
self.W = theano.shared(value=W_values)
b_values = numpy.zeros((filter_shape[0],), dtype=theano.config.floatX)
self.b = theano.shared(value=b_values)
conv_out = conv.conv2d(input, self.W,
filter_shape=filter_shape, image_shape=image_shape)
fan_in = numpy.prod(filter_shape[1:])
fan_out = filter_shape[0] * numpy.prod(filter_shape[2:]) / numpy.prod(poolsize)
W_bound = numpy.sqrt(6./(fan_in + fan_out))
self.W.value = numpy.asarray(
rng.uniform(low=-W_bound, high=W_bound, size=filter_shape),
dtype = theano.config.floatX)
pooled_out = downsample.max_pool2D(conv_out, poolsize, ignore_border=True)
self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))
self.params = [self.W, self.b]
def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2,2)):
"""
Allocate a LeNetConvPoolLayer with shared variable internal parameters.
:type rng: numpy.random.RandomState
:param rng: a random number generator used to initialize weights
:type input: theano.tensor.dtensor4
:param input: symbolic image tensor, of shape image_shape
:type filter_shape: tuple or list of length 4
:param filter_shape: (number of filters, num input feature maps,
filter height,filter width)
:type image_shape: tuple or list of length 4
:param image_shape: (batch size, num input feature maps,
image height, image width)
:type poolsize: tuple or list of length 2
:param poolsize: the downsampling (pooling) factor (#rows,#cols)
"""
assert image_shape[1]==filter_shape[1]
self.input = input
# initialize weight values: the fan-in of each hidden neuron is
# restricted by the size of the receptive fields.
fan_in = numpy.prod(filter_shape[1:])
W_values = numpy.asarray( rng.uniform( \
low = -numpy.sqrt(3./fan_in), \
high = numpy.sqrt(3./fan_in), \
size = filter_shape), dtype = theano.config.floatX)
self.W = theano.shared(value = W_values)
# the bias is a 1D tensor -- one bias per output feature map
b_values = numpy.zeros((filter_shape[0],), dtype= theano.config.floatX)
self.b = theano.shared(value= b_values)
# convolve input feature maps with filters
conv_out = conv.conv2d(input, self.W,
filter_shape=filter_shape, image_shape=image_shape)
# downsample each feature map individually, using maxpooling
pooled_out = downsample.max_pool2D(conv_out, poolsize, ignore_border=True)
# add the bias term. Since the bias is a vector (1D array), we first
# reshape it to a tensor of shape (1,n_filters,1,1). Each bias will thus
# be broadcasted across mini-batches and feature map width & height
self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))
# store parameters of this layer
self.params = [self.W, self.b]
def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2,2)):
"""
Allocate a LeNetConvPoolLayer with shared variable internal parameters.
:type rng: numpy.random.RandomState
:param rng: a random number generator used to initialize weights
:type input: theano.tensor.dtensor4
:param input: symbolic image tensor, of shape image_shape
:type filter_shape: tuple or list of length 4
:param filter_shape: (number of filters, num input feature maps,
filter height,filter width)
:type image_shape: tuple or list of length 4
:param image_shape: (batch size, num input feature maps,
image height, image width)
:type poolsize: tuple or list of length 2
:param poolsize: the downsampling (pooling) factor (#rows,#cols)
"""
assert image_shape[1]==filter_shape[1]
self.input = input
# initialize weights to temporary values until we know the shape of the output feature
# maps
W_values = numpy.zeros(filter_shape, dtype=theano.config.floatX)
self.W = theano.shared(value = W_values)
# the bias is a 1D tensor -- one bias per output feature map
b_values = numpy.zeros((filter_shape[0],), dtype= theano.config.floatX)
self.b = theano.shared(value= b_values)
# convolve input feature maps with filters
conv_out = conv.conv2d(input = input, filters = self.W,
filter_shape=filter_shape, image_shape=image_shape)
# there are "num input feature maps * filter height * filter width" inputs
# to each hidden unit
fan_in = numpy.prod(filter_shape[1:])
# each unit in the lower layer receives a gradient from:
# "num output feature maps * filter height * filter width" / pooling size
fan_out = filter_shape[0] * numpy.prod(filter_shape[2:]) / numpy.prod(poolsize)
# replace weight values with random weights
W_bound = numpy.sqrt(6./(fan_in + fan_out))
self.W.value = numpy.asarray(
rng.uniform(low=-W_bound, high=W_bound, size=filter_shape),
dtype = theano.config.floatX)
# downsample each feature map individually, using maxpooling
pooled_out = downsample.max_pool2D( input = conv_out,
ds = poolsize, ignore_border=True)
# add the bias term. Since the bias is a vector (1D array), we first
# reshape it to a tensor of shape (1,n_filters,1,1). Each bias will thus
# be broadcasted across mini-batches and feature map width & height
self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))
# store parameters of this layer
self.params = [self.W, self.b]
def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
"""
Allocate a LeNetConvPoolLayer with shared variable internal parameters.
:type rng: numpy.random.RandomState
:param rng: a random number generator used to initialize weights
:type input: theano.tensor.dtensor4
:param input: symbolic image tensor, of shape image_shape
:type filter_shape: tuple or list of length 4
:param filter_shape: (number of filters, num input feature maps,
filter height,filter width)
:type image_shape: tuple or list of length 4
:param image_shape: (batch size, num input feature maps,
image height, image width)
:type poolsize: tuple or list of length 2
:param poolsize: the downsampling (pooling) factor (#rows,#cols)
"""
assert image_shape[1] == filter_shape[1]
self.input = input
# initialize weights to temporary values until we know the shape of the output feature
# maps
W_values = numpy.zeros(filter_shape, dtype=theano.config.floatX)
self.W = theano.shared(value=W_values)
# the bias is a 1D tensor -- one bias per output feature map
b_values = numpy.zeros((filter_shape[0], ), dtype=theano.config.floatX)
self.b = theano.shared(value=b_values)
# convolve input feature maps with filters
conv_out = conv.conv2d(input=input,
filters=self.W,
filter_shape=filter_shape,
image_shape=image_shape)
# there are "num input feature maps * filter height * filter width" inputs
# to each hidden unit
fan_in = numpy.prod(filter_shape[1:])
# each unit in the lower layer receives a gradient from:
# "num output feature maps * filter height * filter width" / pooling size
fan_out = filter_shape[0] * numpy.prod(
filter_shape[2:]) / numpy.prod(poolsize)
# replace weight values with random weights
W_bound = numpy.sqrt(6. / (fan_in + fan_out))
self.W.value = numpy.asarray(rng.uniform(low=-W_bound,
high=W_bound,
size=filter_shape),
dtype=theano.config.floatX)
# downsample each feature map individually, using maxpooling
pooled_out = downsample.max_pool2D(input=conv_out,
ds=poolsize,
ignore_border=True)
# add the bias term. Since the bias is a vector (1D array), we first
# reshape it to a tensor of shape (1,n_filters,1,1). Each bias will thus
# be broadcasted across mini-batches and feature map width & height
self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))
# store parameters of this layer
self.params = [self.W, self.b]
