PixelRNN，PixelCNN, Conditional PixelCNN

vertical_stack = Conv2D(
	WrapperLayer(self.X),
	input_dim,
	DIM,
	((filter_size // 2) + 1, filter_size),
	masktype=None,
	border_mode=(filter_size // 2 + 1, filter_size // 2),
	name= name + ".vstack1",
	activation = None
	)

out_v = vertical_stack.output()

'''
while generating i'th row we can only use information upto i-1th row in the vertical stack.
Horizontal stack gets input from vertical stack as well as previous layer.

'''
vertical_and_input_stack = T.concatenate([out_v[:,:,:-(filter_size//2)-2,:], self.X], axis=1)

'''horizontal stack is straight forward. For first layer, I have used masked convolution as
 	we are not allowed to see the pixel we would generate.

'''

horizontal_stack = Conv2D(
	WrapperLayer(vertical_and_input_stack),
	input_dim+DIM, DIM,
	(1,filter_size),
	border_mode = (0,filter_size//2),
	masktype='a',
	name = name + ".hstack1",
	activation = None
	)

self.params = vertical_stack.params + horizontal_stack.params

X_h = horizontal_stack.output() #horizontal stack output
X_v = out_v[:,:,1:-(filter_size//2) - 1,:] #vertical stack output

filter_size = 3 #all layers beyond first has effective filtersize 3

for i in range(num_layers - 2):
	vertical_stack = Conv2D(
		WrapperLayer(X_v),
		DIM,
		DIM,
		((filter_size // 2) + 1, filter_size),
		masktype = None,
		border_mode = (filter_size // 2 + 1, filter_size // 2),
		name= name + ".vstack{}".format(i+2),
		activation = None
		)
	v2h = Conv2D(
		vertical_stack,
		DIM,
		DIM,
		(1,1),
		masktype = None,
		border_mode = 'valid',
		name= name + ".v2h{}".format(i+2),
		activation = None
		)
	out_v = v2h.output()
	vertical_and_prev_stack = T.concatenate([out_v[:,:,:-(filter_size//2)-2,:], X_h], axis=1)

	horizontal_stack = Conv2D(
		WrapperLayer(vertical_and_prev_stack),
		DIM*2,
		DIM,
		(1, (filter_size // 2) + 1),
		border_mode = (0, filter_size // 2),
		masktype = None,
		name = name + ".hstack{}".format(i+2),
		activation = activation
		)

	h2h = Conv2D(
		horizontal_stack,
		DIM,
		DIM,
		(1, 1),
		border_mode = 'valid',
		masktype = None,
		name = name + ".h2hstack{}".format(i+2),
		activation = activation
		)

	self.params += (vertical_stack.params + horizontal_stack.params + v2h.params + h2h.params)

	X_v = apply_act(vertical_stack.output()[:,:,1:-(filter_size//2) - 1,:])
	X_h = h2h.output()[:,:,:,:-(filter_size//2)] + X_h #residual connection added 对位相加

combined_stack1 = Conv2D(
		WrapperLayer(X_h),
		DIM,
		DIM,
		(1, 1),
		masktype = None,
		border_mode = 'valid',
		name=name+".combined_stack1",
		activation = activation
		)

combined_stack2 = Conv2D(
		combined_stack1,
		DIM,
		out_dim,
		(1, 1),
		masktype = None,
		border_mode = 'valid',
		name=name+".combined_stack2",
		activation = None
		)

pre_final_out = combined_stack2.output().dimshuffle(0,2,3,1)

X = T.tensor3('X') # shape: (batchsize, height, width)
X_r = T.itensor3('X_r') #shape: (batchsize, height, width)

input_layer = WrapperLayer(X.dimshuffle(0,1,2,'x')) # input reshaped to (batchsize, height, width,1)

pixel_CNN = pixelConv(
	input_layer,
	1,
	DIM,
	name = model.name + ".pxCNN",
	num_layers = 2,
	Q_LEVELS = Q_LEVELS
	)

model.add_layer(pixel_CNN)

output_probab = Softmax(pixel_CNN).output()

cost = T.nnet.categorical_crossentropy(
	output_probab.reshape((-1,output_probab.shape[output_probab.ndim - 1])),
	X_r.flatten()
	).mean()

output_image = sample_from_softmax(output_probab) #按照概率采样。所以生成的图片会不一样

generate_routine = theano.function([X], output_image)

def generate_fn(generate_routine, HEIGHT, WIDTH, num):
	X = floatX(numpy.zeros((num, HEIGHT, WIDTH)))
	for i in range(HEIGHT):
		for j in range(WIDTH):
			samples = generate_routine(X)
			X[:,i,j] = downscale_images(samples[:,i,j,0], Q_LEVELS-1) #每次预测一个像素

	return X

X = generate_fn(generate_routine, 28, 28, 25)