FilesExpand file tree

 master

/

09_convolutional_autoencoder.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

175 lines (152 loc) · 4.92 KB

 master

/

09_convolutional_autoencoder.py

Copy path

Top

File metadata and controls

• Code
• Blame

175 lines (152 loc) · 4.92 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

"""Tutorial on how to create a convolutional autoencoder w/ Tensorflow.

Parag K. Mital, Jan 2016

"""

import tensorflow as tf

import numpy as np

import math

from libs.activations import lrelu

from libs.utils import corrupt

# %%

def autoencoder(input_shape=[None, 784],

n_filters=[1, 10, 10, 10],

filter_sizes=[3, 3, 3, 3],

corruption=False):

"""Build a deep denoising autoencoder w/ tied weights.

Parameters

----------

input_shape : list, optional

Description

n_filters : list, optional

Description

filter_sizes : list, optional

Description

Returns

-------

x : Tensor

Input placeholder to the network

z : Tensor

Inner-most latent representation

y : Tensor

Output reconstruction of the input

cost : Tensor

Overall cost to use for training

Raises

------

ValueError

Description

"""

# %%

# input to the network

x = tf.placeholder(

tf.float32, input_shape, name='x')

# %%

# ensure 2-d is converted to square tensor.

if len(x.get_shape()) == 2:

x_dim = np.sqrt(x.get_shape().as_list()[1])

if x_dim != int(x_dim):

raise ValueError('Unsupported input dimensions')

x_dim = int(x_dim)

x_tensor = tf.reshape(

x, [-1, x_dim, x_dim, n_filters[0]])

elif len(x.get_shape()) == 4:

x_tensor = x

else:

raise ValueError('Unsupported input dimensions')

current_input = x_tensor

# %%

# Optionally apply denoising autoencoder

if corruption:

current_input = corrupt(current_input)

# %%

# Build the encoder

encoder = []

shapes = []

for layer_i, n_output in enumerate(n_filters[1:]):

n_input = current_input.get_shape().as_list()[3]

shapes.append(current_input.get_shape().as_list())

W = tf.Variable(

tf.random_uniform([

filter_sizes[layer_i],

filter_sizes[layer_i],

n_input, n_output],

-1.0 / math.sqrt(n_input),

1.0 / math.sqrt(n_input)))

b = tf.Variable(tf.zeros([n_output]))

encoder.append(W)

output = lrelu(

tf.add(tf.nn.conv2d(

current_input, W, strides=[1, 2, 2, 1], padding='SAME'), b))

current_input = output

# %%

# store the latent representation

z = current_input

encoder.reverse()

shapes.reverse()

# %%

# Build the decoder using the same weights

for layer_i, shape in enumerate(shapes):

W = encoder[layer_i]

b = tf.Variable(tf.zeros([W.get_shape().as_list()[2]]))

output = lrelu(tf.add(

tf.nn.conv2d_transpose(

current_input, W,

tf.stack([tf.shape(x)[0], shape[1], shape[2], shape[3]]),

strides=[1, 2, 2, 1], padding='SAME'), b))

current_input = output

# %%

# now have the reconstruction through the network

y = current_input

# cost function measures pixel-wise difference

cost = tf.reduce_sum(tf.square(y - x_tensor))

# %%

return {'x': x, 'z': z, 'y': y, 'cost': cost}

# %%

def test_mnist():

"""Test the convolutional autoencder using MNIST."""

# %%

import tensorflow as tf

import tensorflow.examples.tutorials.mnist.input_data as input_data

import matplotlib.pyplot as plt

# %%

# load MNIST as before

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

mean_img = np.mean(mnist.train.images, axis=0)

ae = autoencoder()

# %%

learning_rate = 0.01

optimizer = tf.train.AdamOptimizer(learning_rate).minimize(ae['cost'])

# %%

# We create a session to use the graph

sess = tf.Session()

sess.run(tf.global_variables_initializer())

# %%

# Fit all training data

batch_size = 100

n_epochs = 10

for epoch_i in range(n_epochs):

for batch_i in range(mnist.train.num_examples // batch_size):

batch_xs, _ = mnist.train.next_batch(batch_size)

train = np.array([img - mean_img for img in batch_xs])

sess.run(optimizer, feed_dict={ae['x']: train})

print(epoch_i, sess.run(ae['cost'], feed_dict={ae['x']: train}))

# %%

# Plot example reconstructions

n_examples = 10

test_xs, _ = mnist.test.next_batch(n_examples)

test_xs_norm = np.array([img - mean_img for img in test_xs])

recon = sess.run(ae['y'], feed_dict={ae['x']: test_xs_norm})

print(recon.shape)

fig, axs = plt.subplots(2, n_examples, figsize=(10, 2))

for example_i in range(n_examples):

axs[0][example_i].imshow(

np.reshape(test_xs[example_i, :], (28, 28)))

axs[1][example_i].imshow(

np.reshape(

np.reshape(recon[example_i, ...], (784,)) + mean_img,

(28, 28)))

fig.show()

plt.draw()

plt.waitforbuttonpress()

# %%

if __name__ == '__main__':

test_mnist()