FilesExpand file tree

 master

/

06_autoencoder.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

86 lines (70 loc) · 3.06 KB

 master

/

06_autoencoder.py

Copy path

Top

File metadata and controls

• Code
• Blame

86 lines (70 loc) · 3.06 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

import tensorflow as tf

import numpy as np

from tensorflow.examples.tutorials.mnist import input_data

import matplotlib # to plot images

# Force matplotlib to not use any X-server backend.

matplotlib.use('Agg')

import matplotlib.pyplot as plt

import matplotlib.gridspec as gridspec

## Visualizing reconstructions

def vis(images, save_name):

dim = images.shape[0]

n_image_rows = int(np.ceil(np.sqrt(dim)))

n_image_cols = int(np.ceil(dim * 1.0/n_image_rows))

gs = gridspec.GridSpec(n_image_rows,n_image_cols,top=1., bottom=0., right=1., left=0., hspace=0., wspace=0.)

for g,count in zip(gs,range(int(dim))):

ax = plt.subplot(g)

ax.imshow(images[count,:].reshape((28,28)))

ax.set_xticks([])

ax.set_yticks([])

plt.savefig(save_name + '_vis.png')

mnist_width = 28

n_visible = mnist_width * mnist_width

n_hidden = 500

corruption_level = 0.3

# create node for input data

X = tf.placeholder("float", [None, n_visible], name='X')

# create node for corruption mask

mask = tf.placeholder("float", [None, n_visible], name='mask')

# create nodes for hidden variables

W_init_max = 4 * np.sqrt(6. / (n_visible + n_hidden))

W_init = tf.random_uniform(shape=[n_visible, n_hidden],

minval=-W_init_max,

maxval=W_init_max)

W = tf.Variable(W_init, name='W')

b = tf.Variable(tf.zeros([n_hidden]), name='b')

W_prime = tf.transpose(W) # tied weights between encoder and decoder

b_prime = tf.Variable(tf.zeros([n_visible]), name='b_prime')

def model(X, mask, W, b, W_prime, b_prime):

tilde_X = mask * X # corrupted X

Y = tf.nn.sigmoid(tf.matmul(tilde_X, W) + b) # hidden state

Z = tf.nn.sigmoid(tf.matmul(Y, W_prime) + b_prime) # reconstructed input

return Z

# build model graph

Z = model(X, mask, W, b, W_prime, b_prime)

# create cost function

cost = tf.reduce_sum(tf.pow(X - Z, 2)) # minimize squared error

train_op = tf.train.GradientDescentOptimizer(0.02).minimize(cost) # construct an optimizer

predict_op = Z

# load MNIST data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

# Launch the graph in a session

with tf.Session() as sess:

# you need to initialize all variables

tf.global_variables_initializer().run()

for i in range(100):

for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+1, 128)):

input_ = trX[start:end]

mask_np = np.random.binomial(1, 1 - corruption_level, input_.shape)

sess.run(train_op, feed_dict={X: input_, mask: mask_np})

mask_np = np.random.binomial(1, 1 - corruption_level, teX.shape)

print(i, sess.run(cost, feed_dict={X: teX, mask: mask_np}))

# save the predictions for 100 images

mask_np = np.random.binomial(1, 1 - corruption_level, teX[:100].shape)

predicted_imgs = sess.run(predict_op, feed_dict={X: teX[:100], mask: mask_np})

input_imgs = teX[:100]

# plot the reconstructed images

vis(predicted_imgs,'pred')

vis(input_imgs,'in')

print('Done')