def createMaxPoolLayer(self, conv_out=None, poolsize=None):
if conv_out is None: conv_out = self.conv_out
if poolsize is None: poolsize = self.poolsize
# pool each feature map individually, using maxpooling
#pooled_out = pool.pool_2d(
self.pooled_out = max_pool_3d(input=conv_out.dimshuffle(0, 2, 1, 3, 4),
ds=poolsize,
ignore_border=True)
return self.pooled_out.dimshuffle(0, 2, 1, 3, 4)
def __init__(self, input, pool_shape, method="max"):
"""
method: "max", "avg", "L2", "L4", ...
"""
self.__dict__.update(locals())
del self.self
if method=="max":
out = max_pool_3d(input,pool_shape)
else:
raise NotImplementedError()
self.output = out
def __init__(self, input, pool_shape, method="max"):
"""
method: "max", "avg", "L2", "L4", ...
"""
self.__dict__.update(locals())
del self.self
if method == "max":
out = max_pool_3d(input, pool_shape)
else:
raise NotImplementedError()
self.output = out
def __init__(self, input, n_in_maps, n_out_maps, kernel_shape, video_shape, pool_shape,
batch_size, layer_name="Conv", rng=RandomState(1234),
borrow=True, W=None, b=None):
"""
video_shape: (frames, height, width)
kernel_shape: (frames, height, width)
W_shape: (out, in, kern_frames, kern_height, kern_width)
"""
# init W
if W is not None:
self.W = W
else:
# fan in: filter time x filter height x filter width x input maps
fan_in = prod(kernel_shape) * n_in_maps
norm_scale = 2. * sqrt(1. / fan_in)
W_shape = (n_out_maps, n_in_maps) + kernel_shape
W_val = _asarray(rng.normal(loc=0, scale=norm_scale, size=W_shape), dtype=floatX)
self.W = shared(value=W_val, borrow=borrow, name=layer_name + '_W')
# init bias
if b is not None:
self.b = b
else:
b_val = zeros((n_out_maps,), dtype=floatX)
self.b = shared(b_val, name=layer_name + "_b", borrow=borrow)
self.params = [self.W, self.b]
# 3D convolution; dimshuffle: last 3 dimensions must be (in, h, w)
n_fr, h, w = video_shape
n_fr_k, h_k, w_k = kernel_shape
signals = input.dimshuffle([0, 2, 1, 3, 4])
out = conv3d(
signals=signals,
filters=self.W,
signals_shape=(batch_size, n_fr, n_in_maps, h, w),
filters_shape=(n_out_maps, n_fr_k, n_in_maps, h_k, w_k),
border_mode='valid').dimshuffle([0, 2, 1, 3, 4])
pooled_out = max_pool_3d(out, pool_shape, ignore_border=True)
pooled_out += self.b.dimshuffle('x', 0, 'x', 'x', 'x')
self.output = T.tanh(pooled_out)
def __init__(self, rng, input, filter_shape, image_shape, pool_shape):
self.input = input
# initialize weights with random weights
self.W = theano.shared(numpy.asarray(rng.uniform(low=-.1,
high=.1,
size=filter_shape),
dtype=theano.config.floatX),
borrow=True)
# 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, borrow=True)
# filter stride
d = theano.shared(numpy.ndarray(shape=(3, ), dtype=int))
d.set_value([1, 1, 1])
# convolve input feature maps with filters
# # theano.tensor.nnet.conv3D
# conv_out = conv3D(
# V=self.input,
# W=self.W,
# b=self.b,
# d=d)
# theano.tensor.nnet.conv3d2d.conv3d
conv_out = T.nnet.conv3d2d.conv3d(signals=self.input,
filters=self.W,
signals_shape=image_shape,
filters_shape=filter_shape,
border_mode='valid')
activation = T.tanh(conv_out +
self.b.dimshuffle('x', 'x', 0, 'x', 'x'))
if pool_shape == (1, 1, 1):
self.output = activation
else:
self.output = max_pool_3d(activation, pool_shape)
# store parameters of this layer
self.params = [self.W, self.b]
def __init__(self, rng, input, filter_shape, image_shape, pool_shape):
self.input = input
# initialize weights with random weights
self.W = theano.shared(
numpy.asarray(
rng.uniform(low=-.1, high=.1, size=filter_shape),
dtype=theano.config.floatX),
borrow=True)
# 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, borrow=True)
# filter stride
d = theano.shared(numpy.ndarray(shape=(3,),dtype=int))
d.set_value([1, 1, 1])
# convolve input feature maps with filters
# # theano.tensor.nnet.conv3D
# conv_out = conv3D(
# V=self.input,
# W=self.W,
# b=self.b,
# d=d)
# theano.tensor.nnet.conv3d2d.conv3d
conv_out = T.nnet.conv3d2d.conv3d(
signals=self.input,
filters=self.W,
signals_shape=image_shape,
filters_shape=filter_shape,
border_mode='valid')
activation = T.tanh(conv_out + self.b.dimshuffle('x', 'x', 0, 'x', 'x'))
if pool_shape == (1,1,1):
self.output = activation
else:
self.output = max_pool_3d(activation, pool_shape)
# store parameters of this layer
self.params = [self.W, self.b]
def __init__(self,
rng,
input,
signal_shape,
filter_shape,
poolsize=(2, 2, 2),
stride=None,
if_pool=False,
if_hidden_pool=False,
act=None,
share_with=None,
tied=None,
border_mode='valid'):
self.input = input
if share_with:
self.W = share_with.W
self.b = share_with.b
self.W_delta = share_with.W_delta
self.b_delta = share_with.b_delta
elif tied:
self.W = tied.W.dimshuffle(1, 0, 2, 3)
self.b = tied.b
self.W_delta = tied.W_delta.dimshuffle(1, 0, 2, 3)
self.b_delta = tied.b_delta
else:
fan_in = np.prod(filter_shape[1:])
poolsize_size = np.prod(poolsize) if poolsize else 1
fan_out = (filter_shape[0] * np.prod(filter_shape[2:]) /
poolsize_size)
W_bound = np.sqrt(6. / (fan_in + fan_out))
self.W = theano.shared(np.asarray(rng.uniform(low=-W_bound,
high=W_bound,
size=filter_shape),
dtype=theano.config.floatX),
borrow=True)
b_values = np.zeros((filter_shape[0], ),
dtype=theano.config.floatX)
self.b = theano.shared(value=b_values, borrow=True)
self.W_delta = theano.shared(np.zeros(filter_shape,
dtype=theano.config.floatX),
borrow=True)
self.b_delta = theano.shared(value=b_values, borrow=True)
# convolution
conv_out = conv3d2d.conv3d(signals=input,
filters=self.W,
signals_shape=signal_shape,
filters_shape=filter_shape,
border_mode=border_mode)
#if poolsize:
if if_pool:
conv_out = conv_out.dimshuffle(
0, 2, 1, 3, 4) #maxpool3d works on last 3 dimesnions
pooled_out = maxpool3d.max_pool_3d(input=conv_out,
ds=poolsize,
ignore_border=True)
tmp_out = pooled_out.dimshuffle(0, 2, 1, 3, 4)
tmp = tmp_out + self.b.dimshuffle('x', 'x', 0, 'x', 'x')
elif if_hidden_pool:
pooled_out = downsample.max_pool_2d(input=conv_out,
ds=poolsize[:2],
st=stride,
ignore_border=True)
tmp = pooled_out + self.b.dimshuffle('x', 'x', 0, 'x', 'x')
else:
tmp = conv_out + self.b.dimshuffle('x', 'x', 0, 'x', 'x')
if act == 'tanh':
self.output = T.tanh(tmp)
elif act == 'sigmoid':
self.output = nnet.sigmoid(tmp)
elif act == 'relu':
# self.output = tmp * (tmp>0)
self.output = 0.5 * (tmp + abs(tmp)) + 1e-9
elif act == 'softplus':
# self.output = T.log2(1+T.exp(tmp))
self.output = nnet.softplus(tmp)
else:
self.output = tmp
self.get_activation = theano.function([self.input],
self.output,
updates=None,
name='get hidden activation')
# store parameters of this layer
self.params = [self.W, self.b]
self.deltas = [self.W_delta, self.b_delta]
def __init__(self, signal_shape, filter_shape, poolsize, activation=None):
rng = np.random.RandomState(None)
dtensor5 = T.TensorType('float32', (False, ) * 5)
self.inputs = dtensor5(name='inputs')
self.image_shape = signal_shape
self.batchsize = signal_shape[0]
self.in_channels = signal_shape[2]
self.in_depth = signal_shape[1]
self.in_width = signal_shape[4]
self.in_height = signal_shape[3]
self.flt_channels = filter_shape[0]
self.flt_time = filter_shape[1]
self.flt_width = filter_shape[4]
self.flt_height = filter_shape[3]
self.activation = activation
self.hidden_layer = ConvolutionLayer3D(rng,
input=self.inputs,
signal_shape=signal_shape,
filter_shape=filter_shape,
act=activation,
border_mode='full',
if_hidden_pool=False)
self.hidden_image_shape = (self.batchsize, self.in_depth,
self.flt_channels,
self.in_height + self.flt_height - 1,
self.in_width + self.flt_width - 1)
self.hidden_pooled_image_shape = (
self.batchsize, self.in_depth / 2, self.flt_channels,
(self.in_height + self.flt_height - 1) / 2,
(self.in_width + self.flt_width - 1) / 2)
self.hidden_filter_shape = (self.in_channels, self.flt_time,
self.flt_channels, self.flt_height,
self.flt_width)
self.recon_layer = ConvolutionLayer3D(
rng,
input=self.hidden_layer.output,
signal_shape=self.hidden_image_shape,
filter_shape=self.hidden_filter_shape,
act=activation,
border_mode='valid')
self.layers = [self.hidden_layer, self.recon_layer]
self.params = sum([layer.params for layer in self.layers], [])
L = T.sum(T.pow(T.sub(self.recon_layer.output, self.inputs), 2),
axis=(1, 2, 3, 4))
self.cost = 0.5 * T.mean(L)
self.grads = T.grad(self.cost, self.params)
self.updates = adadelta_updates(self.params,
self.grads,
rho=0.95,
eps=1e-6)
self.train = theano.function([self.inputs],
self.cost,
updates=self.updates,
name="train cae model")
self.activation = maxpool3d.max_pool_3d(
input=self.hidden_layer.output.dimshuffle(0, 2, 1, 3, 4),
ds=poolsize,
ignore_border=True)
self.activation = self.activation.dimshuffle(0, 2, 1, 3, 4)
self.get_activation = theano.function([self.inputs],
self.activation,
updates=None,
name='get hidden activation')
def __init__(self, rng, input, signal_shape, filter_shape, poolsize=(2, 2, 2), stride=None, if_pool=False, if_hidden_pool=False,
act=None,
share_with=None,
tied=None,
border_mode='valid'):
self.input = input
if share_with:
self.W = share_with.W
self.b = share_with.b
self.W_delta = share_with.W_delta
self.b_delta = share_with.b_delta
elif tied:
self.W = tied.W.dimshuffle(1,0,2,3)
self.b = tied.b
self.W_delta = tied.W_delta.dimshuffle(1,0,2,3)
self.b_delta = tied.b_delta
else:
fan_in = np.prod(filter_shape[1:])
poolsize_size = np.prod(poolsize) if poolsize else 1
fan_out = (filter_shape[0] * np.prod(filter_shape[2:]) / poolsize_size)
W_bound = np.sqrt(6. / (fan_in + fan_out))
self.W = theano.shared(
np.asarray(
rng.uniform(low=-W_bound, high=W_bound, size=filter_shape),
dtype=theano.config.floatX
),
borrow=True
)
b_values = np.zeros((filter_shape[0],), dtype=theano.config.floatX)
self.b = theano.shared(value=b_values, borrow=True)
self.W_delta = theano.shared(
np.zeros(filter_shape, dtype=theano.config.floatX),
borrow=True
)
self.b_delta = theano.shared(value=b_values, borrow=True)
# convolution
conv_out = conv3d2d.conv3d(
signals=input,
filters=self.W,
signals_shape=signal_shape,
filters_shape=filter_shape,
border_mode=border_mode)
#if poolsize:
if if_pool:
conv_out = conv_out.dimshuffle(0,2,1,3,4) #maxpool3d works on last 3 dimesnions
pooled_out = maxpool3d.max_pool_3d(
input=conv_out,
ds=poolsize,
ignore_border=True)
tmp_out = pooled_out.dimshuffle(0,2,1,3,4)
tmp = tmp_out + self.b.dimshuffle('x', 'x', 0, 'x', 'x')
elif if_hidden_pool:
pooled_out = downsample.max_pool_2d(
input=conv_out,
ds=poolsize[:2],
st=stride,
ignore_border=True)
tmp = pooled_out + self.b.dimshuffle('x', 'x', 0, 'x', 'x')
else:
tmp = conv_out + self.b.dimshuffle('x', 'x', 0, 'x', 'x')
if act == 'tanh':
self.output = T.tanh(tmp)
elif act == 'sigmoid':
self.output = nnet.sigmoid(tmp)
elif act == 'relu':
# self.output = tmp * (tmp>0)
self.output = 0.5 * (tmp + abs(tmp)) + 1e-9
elif act == 'softplus':
# self.output = T.log2(1+T.exp(tmp))
self.output = nnet.softplus(tmp)
else:
self.output = tmp
self.get_activation = theano.function(
[self.input],
self.output,
updates=None,
name='get hidden activation')
# store parameters of this layer
self.params = [self.W, self.b]
self.deltas = [self.W_delta, self.b_delta]
def __init__(self, signal_shape, filter_shape, poolsize, activation=None):
rng = np.random.RandomState(None)
dtensor5 = T.TensorType('float32', (False,)*5)
self.inputs = dtensor5(name='inputs')
self.image_shape = signal_shape
self.batchsize = signal_shape[0]
self.in_channels = signal_shape[2]
self.in_depth = signal_shape[1]
self.in_width = signal_shape[4]
self.in_height = signal_shape[3]
self.flt_channels = filter_shape[0]
self.flt_time = filter_shape[1]
self.flt_width = filter_shape[4]
self.flt_height = filter_shape[3]
self.activation = activation
self.hidden_layer=ConvolutionLayer3D(rng,
input=self.inputs,
signal_shape=signal_shape,
filter_shape=filter_shape,
act=activation,
border_mode='full',
if_hidden_pool=False)
self.hidden_image_shape = (self.batchsize,
self.in_depth,
self.flt_channels,
self.in_height+self.flt_height-1,
self.in_width+self.flt_width-1)
self.hidden_pooled_image_shape = (self.batchsize,
self.in_depth/2,
self.flt_channels,
(self.in_height+self.flt_height-1)/2,
(self.in_width+self.flt_width-1)/2)
self.hidden_filter_shape = (self.in_channels, self.flt_time, self.flt_channels, self.flt_height,
self.flt_width)
self.recon_layer=ConvolutionLayer3D(rng,
input=self.hidden_layer.output,
signal_shape=self.hidden_image_shape,
filter_shape=self.hidden_filter_shape,
act=activation,
border_mode='valid')
self.layers = [self.hidden_layer, self.recon_layer]
self.params = sum([layer.params for layer in self.layers], [])
L=T.sum(T.pow(T.sub(self.recon_layer.output, self.inputs), 2), axis=(1,2,3,4))
self.cost = 0.5*T.mean(L)
self.grads = T.grad(self.cost, self.params)
self.updates = adadelta_updates(self.params, self.grads, rho=0.95, eps=1e-6)
self.train = theano.function(
[self.inputs],
self.cost,
updates=self.updates,
name = "train cae model"
)
self.activation = maxpool3d.max_pool_3d(
input=self.hidden_layer.output.dimshuffle(0,2,1,3,4),
ds=poolsize,
ignore_border=True)
self.activation = self.activation.dimshuffle(0,2,1,3,4)
self.get_activation = theano.function(
[self.inputs],
self.activation,
updates=None,
name='get hidden activation')
