review-with-checkpoint.py

from __future__ import absolute_import, division, print_function

import tensorflow as tf
from tensorflow import keras
import os
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)

NUM_WORDS = 10000

def multi_hot_sequences(sequences, dimension):
    results = np.zeros((len(sequences), dimension))
    for i, word_indices in enumerate(sequences):
        results[i, word_indices] = 1.0
    return results


def plot_history(histories, key='binary_crossentropy'):
    plt.figure(figsize=(16, 10))

    for name, history in histories:
        val = plt.plot(history.epoch, history.history['val_' + key],
                       '--', label=name.title() + ' Val')
        plt.plot(history.epoch, history.history[key], color=val[0].get_color(),
                 label=name.title() + ' Train')

    plt.xlabel('Epochs')
    plt.ylabel(key.replace('_', ' ').title())
    plt.legend()

    plt.xlim([0, max(history.epoch)])


def create_model():
    model = keras.models.Sequential([
        keras.layers.Dense(16, activation=tf.nn.relu, input_shape=(NUM_WORDS,)),
        keras.layers.Dropout(0.5),
        keras.layers.Dense(16, activation=tf.nn.relu),
        keras.layers.Dropout(0.5),
        keras.layers.Dense(1, activation=tf.nn.sigmoid)
    ])

    model.compile(optimizer='adam',
                  loss='binary_crossentropy',
                  metrics=['accuracy', 'binary_crossentropy'])

    return model;


# create checkpoint

checkpoint_path = "model/cp-{epoch:04d}.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)
# Create checkpoint callback
cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
                                                 save_weights_only=True,
                                                 verbose=1,
                                                 period=5)


(train_data, train_labels), (test_data, test_labels) = keras.datasets.imdb.load_data(num_words=NUM_WORDS)
train_data = multi_hot_sequences(train_data, dimension=NUM_WORDS)
test_data = multi_hot_sequences(test_data, dimension=NUM_WORDS)

model = create_model()
model.save_weights(checkpoint_path.format(epoch=0))
model.summary()

##train and save snapshot
model.fit(train_data, train_labels,
          epochs=50,
          batch_size=512,
          validation_data=(test_data, test_labels),
          verbose=1,
          callbacks=[cp_callback])


# create new model and load the snapshot and evulate shit
model1 = create_model()

loss,acc, *_ = model1.evaluate(test_data, test_labels)
print("Untrained model, acc: {:5.2f}%".format(100*acc))

latest = tf.train.latest_checkpoint(checkpoint_dir)
print("latest checkpoint is :%s",latest)
model1.load_weights(latest)
loss,acc, *_ = model1.evaluate(test_data, test_labels)
print("loaded model, acc: {:5.2f}%".format(100*acc))