PythonModelExportSamples/SavingRestoringModel.py at master · FlinkML/PythonModelExportSamples · GitHub

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
# from https://github.com/aymericdamien/TensorFlow-Examples/blob/master/examples/4_Utils/save_restore_model.py

importtensorflowastf

# Import MNIST data
fromtensorflow.examples.tutorials.mnistimportinput_data
mnist=input_data.read_data_sets("MNIST_data/", one_hot=True)

# Parameters
learning_rate=0.001
batch_size=100
display_step=1
model_path="/Users/boris/Projects/TensorFlowPython/models/MNISTNueralNet.ckpt"

# Network Parameters
n_hidden_1=256# 1st layer number of features
n_hidden_2=256# 2nd layer number of features
n_input=784# MNIST data input (img shape: 28*28)
n_classes=10# MNIST total classes (0-9 digits)

# tf Graph input
x=tf.placeholder("float", [None, n_input])
y=tf.placeholder("float", [None, n_classes])


# Create model
defmultilayer_perceptron(x, weights, biases):
# Hidden layer with RELU activation
layer_1=tf.add(tf.matmul(x, weights['h1']), biases['b1'])
layer_1=tf.nn.relu(layer_1)
# Hidden layer with RELU activation
layer_2=tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
layer_2=tf.nn.relu(layer_2)
# Output layer with linear activation
out_layer=tf.matmul(layer_2, weights['out']) +biases['out']
returnout_layer

# Store layers weight & bias
weights= {
'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
}
biases= {
'b1': tf.Variable(tf.random_normal([n_hidden_1])),
'b2': tf.Variable(tf.random_normal([n_hidden_2])),
'out': tf.Variable(tf.random_normal([n_classes]))
}

# Construct model
pred=multilayer_perceptron(x, weights, biases)

# Define loss and optimizer
cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
optimizer=tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

# Initializing the variables
init=tf.global_variables_initializer()

# 'Saver' op to save and restore all the variables
saver=tf.train.Saver()

# Running first session - learning
print("Starting 1st session...")
withtf.Session() assess:
# Initialize variables
sess.run(init)

# Training cycle
forepochinrange(3):
avg_cost=0.
total_batch=int(mnist.train.num_examples/batch_size)
# Loop over all batches
foriinrange(total_batch):
batch_x, batch_y=mnist.train.next_batch(batch_size)
# Run optimization op (backprop) and cost op (to get loss value)
_, c=sess.run([optimizer, cost], feed_dict={x: batch_x,
y: batch_y})
# Compute average loss
avg_cost+=c/total_batch
# Display logs per epoch step
ifepoch%display_step==0:
print("Epoch:", '%04d'% (epoch+1), "cost=", \
"{:.9f}".format(avg_cost))
print("First Optimization Finished!")

# Test model
correct_prediction=tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# Calculate accuracy
accuracy=tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

# Save model weights to disk
save_path=saver.save(sess, model_path)
print("Model saved in file: %s"%save_path)

# Running a new session - continue training
print("Starting 2nd session...")
withtf.Session() assess:
# Initialize variables
sess.run(init)

# Restore model weights from previously saved model
saver.restore(sess, model_path)
print("Model restored from file: %s"%save_path)

# Resume training
forepochinrange(7):
avg_cost=0.
total_batch=int(mnist.train.num_examples/batch_size)
# Loop over all batches
foriinrange(total_batch):
batch_x, batch_y=mnist.train.next_batch(batch_size)
# Run optimization op (backprop) and cost op (to get loss value)
_, c=sess.run([optimizer, cost], feed_dict={x: batch_x,
y: batch_y})
# Compute average loss
avg_cost+=c/total_batch
# Display logs per epoch step
ifepoch%display_step==0:
print("Epoch:", '%04d'% (epoch+1), "cost=", \
"{:.9f}".format(avg_cost))
print("Second Optimization Finished!")

# Test model
correct_prediction=tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# Calculate accuracy
accuracy=tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Accuracy:", accuracy.eval(
 {x: mnist.test.images, y: mnist.test.labels}))