FilesExpand file tree

 master

/

tutorial_keras.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

76 lines (63 loc) · 2.71 KB

 master

/

tutorial_keras.py

Copy path

Top

File metadata and controls

• Code
• Blame

76 lines (63 loc) · 2.71 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

#! /usr/bin/python

# -*- coding: utf8 -*-

import numpy as np

import tensorflow as tf

import tensorlayer as tl

import time

from keras import backend as K

from keras.layers import *

from tensorlayer.layers import *

X_train, y_train, X_val, y_val, X_test, y_test = \

tl.files.load_mnist_dataset(shape=(-1, 784))

sess = tf.InteractiveSession()

batch_size = 128

x = tf.placeholder(tf.float32, shape=[None, 784])

y_ = tf.placeholder(tf.int64, shape=[None,])

def keras_block(x):

x = Dropout(0.8)(x)

x = Dense(800, activation='relu')(x)

x = Dropout(0.5)(x)

x = Dense(800, activation='relu')(x)

x = Dropout(0.5)(x)

logits = Dense(10, activation='linear')(x)

return logits

network = InputLayer(x, name='input')

# network = KerasLayer(network, keras_layer=keras_block, name='keras')

network = LambdaLayer(network, fn=keras_block, name='keras') # the same

y = network.outputs

network.print_params(False)

network.print_layers()

cost = tl.cost.cross_entropy(y, y_, 'cost')

correct_prediction = tf.equal(tf.argmax(y, 1), y_)

acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

n_epoch = 200

learning_rate = 0.0001

train_params = network.all_params

train_op = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.999,

epsilon=1e-08, use_locking=False).minimize(cost, var_list=train_params)

tl.layers.initialize_global_variables(sess)

for epoch in range(n_epoch):

start_time = time.time()

## Training

for X_train_a, y_train_a in tl.iterate.minibatches(

X_train, y_train, batch_size, shuffle=True):

_, _ = sess.run([cost, train_op], feed_dict={x: X_train_a, y_: y_train_a,

K.learning_phase(): 1})

print("Epoch %d of %d took %fs" % (epoch + 1, n_epoch, time.time() - start_time))

## Evaluation

train_loss, train_acc, n_batch = 0, 0, 0

for X_train_a, y_train_a in tl.iterate.minibatches(

X_train, y_train, batch_size, shuffle=False):

err, ac = sess.run([cost, acc], feed_dict={x: X_train_a, y_: y_train_a,

K.learning_phase(): 0})

train_loss += err; train_acc += ac; n_batch += 1

print(" train loss: %f" % (train_loss/ n_batch))

print(" train acc: %f" % (train_acc/ n_batch))

val_loss, val_acc, n_batch = 0, 0, 0

for X_val_a, y_val_a in tl.iterate.minibatches(

X_val, y_val, batch_size, shuffle=False):

err, ac = sess.run([cost, acc], feed_dict={x: X_val_a, y_: y_val_a,

K.learning_phase(): 0})

val_loss += err; val_acc += ac; n_batch += 1

print(" val loss: %f" % (val_loss/ n_batch))

print(" val acc: %f" % (val_acc/ n_batch))