def lecun_lcn(input, kernel_size=9, threshold=1e-4, use_divisor=False):
"""
Yann LeCun's local contrast normalization
Orginal code in Theano by: Guillaume Desjardins
:param input:
:param kernel_size:
:param threshold:
:param use_divisor:
:return:
"""
input_shape = (input.shape[0], 1, input.shape[1], input.shape[2])
input = input.reshape(input_shape).astype(floatX)
X = T.tensor4(dtype=floatX)
filter_shape = (1, 1, kernel_size, kernel_size)
filters = gaussian_filter(kernel_size).reshape(filter_shape)
filters = shared(_asarray(filters, dtype=floatX), borrow=True)
convout = conv2d(input=X,
filters=filters,
input_shape=input.shape,
filter_shape=filter_shape,
border_mode='half')
new_X = X - convout
if use_divisor:
# Scale down norm of kernel_size x kernel_size patch
sum_sqr_XX = conv2d(input=T.sqr(T.abs_(new_X)),
filters=filters,
input_shape=input.shape,
filter_shape=filter_shape,
border_mode='half')
denom = T.sqrt(sum_sqr_XX)
per_img_mean = denom.mean(axis=[2, 3])
divisor = T.largest(per_img_mean.dimshuffle(0, 1, 'x', 'x'), denom)
divisor = T.maximum(divisor, threshold)
new_X = new_X / divisor
new_X = new_X.dimshuffle(0, 2, 3, 1)
new_X = new_X.flatten(ndim=3)
f = function([X], new_X)
return f(input)
python类conv2d()的实例源码
def get_output(self):
if self.dropout_rate!=0:
seed = np.random.randint(10e6)
rng = RandomStreams(seed=seed)
retain_prob = 1. - self.dropout_rate
self.input *= rng.binomial(self.input.shape, p=retain_prob, dtype=self.input.dtype)
self.input /= retain_prob
conv_out = conv2d(self.input, self.Cnn_W) #(batch size, output channels, output rows, output columns)
conv_out = conv_out + self.Cnn_B.dimshuffle('x', 0, 'x', 'x')
# out_put_shape = self.get_output_shape()
# r_matrix_s = np.eye(out_put_shape[3], out_put_shape[3], 0)
# r_matrix_x = np.eye(out_put_shape[3], out_put_shape[3], -1)
# test = [[r_matrix_s for i in range(self.input_shape[1])] for j in range(self.input_shape[0])]
# print test
# r_matrix_s = theano.shared(np.array(r_matrix_s).astype(np.float32))
#
# r_matrix_x = theano.shared(np.array(r_matrix_x).astype(np.float32))
#
# r_matrix = r_matrix_s*self.Rnn_W_s.dimshuffle(0, 'x', 'x') + \
# r_matrix_x*(1-self.Rnn_W_s).dimshuffle(0, 'x', 'x')
# conv_out = conv_out.dimshuffle(1, 0, 2, 3)
# def step (con, r_m, r_b):
# return T.dot(con, r_m) + r_b
# conv_out, _ = theano.scan(step, sequences=[conv_out, r_matrix, self.Rnn_W_b])
# conv_out = conv_out.dimshuffle(1, 0, 2, 3)
# R_conv_out = T.concatenate([T.zeros_like(conv_out[:, :, :, :1]), conv_out], axis = 3)
# R_conv_out = R_conv_out[:, :, :,:conv_out.shape[3]]
# RNN_Ws = self.Rnn_W_s.dimshuffle('x', 0, 'x', 'x')
# RNN_b = self.Rnn_W_b
# R_conv_out = R_conv_out *RNN_Ws + conv_out * (1-RNN_Ws) + RNN_b
# conv_out = conv_out.dimshuffle(1,0,2,3)
#
# def Rnn_add(channel,RNN_b,RNN_Ws,RNN_Wx):
# RNN_channel = T.concatenate([T.zeros_like(channel[:, :, :1]),channel],axis = 2)
# RNN_channel = RNN_channel[:,:,:channel.shape[2]]
# res = RNN_channel*RNN_Ws + channel*RNN_Wx + RNN_b
# return res
#self.Rnn_W_s = T.abs_(self.Rnn_W_s)
# R_conv_out,_ = theano.scan(Rnn_add,sequences= [conv_out,self.Rnn_W_b,self.Rnn_W_s,1 - self.Rnn_W_s])
# R_conv_out = R_conv_out.dimshuffle(1,0,2,3)
#output = self.activition(R_conv_out)
#return self.input
return self.activition(conv_out)
#return output
def test_conv(self):
for conv_op in [conv.conv2d, conv2d]:
for border_mode in ['valid', 'full']:
image_shape = (2, 2, 4, 5)
filter_shape = (2, 2, 2, 3)
image_dim = len(image_shape)
filter_dim = len(filter_shape)
input = tensor.TensorType(
theano.config.floatX,
[False] * image_dim)(name='input')
filters = tensor.TensorType(
theano.config.floatX,
[False] * filter_dim)(name='filter')
ev_input = tensor.TensorType(
theano.config.floatX,
[False] * image_dim)(name='ev_input')
ev_filters = tensor.TensorType(
theano.config.floatX,
[False] * filter_dim)(name='ev_filters')
def sym_conv2d(input, filters):
return conv_op(input, filters, border_mode=border_mode)
output = sym_conv2d(input, filters).flatten()
yv = tensor.Rop(output, [input, filters], [ev_input, ev_filters])
mode = None
if theano.config.mode == "FAST_COMPILE":
mode = "FAST_RUN"
rop_f = function([input, filters, ev_input, ev_filters],
yv, on_unused_input='ignore', mode=mode)
sy, _ = theano.scan(lambda i, y, x1, x2, v1, v2:
(tensor.grad(y[i], x1) * v1).sum() +
(tensor.grad(y[i], x2) * v2).sum(),
sequences=tensor.arange(output.shape[0]),
non_sequences=[output, input, filters,
ev_input, ev_filters],
mode=mode)
scan_f = function([input, filters, ev_input, ev_filters], sy,
on_unused_input='ignore', mode=mode)
dtype = theano.config.floatX
image_data = numpy.random.random(image_shape).astype(dtype)
filter_data = numpy.random.random(filter_shape).astype(dtype)
ev_image_data = numpy.random.random(image_shape).astype(dtype)
ev_filter_data = numpy.random.random(filter_shape).astype(dtype)
v1 = rop_f(image_data, filter_data, ev_image_data, ev_filter_data)
v2 = scan_f(image_data, filter_data, ev_image_data, ev_filter_data)
assert numpy.allclose(v1, v2), ("Rop mismatch: %s %s" % (v1, v2))
