def main(args): if len(args) < 2: print('You must specify model_dir for checkpoints such as' ' /tmp/tfkeras_example/.') return model_dir = args[1] export_dir = args[2] print('Using %s to store checkpoints.' % model_dir) # Define a Keras Model. model = tf.keras.Sequential() model.add(tf.keras.layers.Dense(16, activation='relu', input_shape=(10, ))) model.add(tf.keras.layers.Dense(1, activation='sigmoid')) # Compile the model. optimizer = tf.train.GradientDescentOptimizer(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary() tf.keras.backend.set_learning_phase(True) # Define DistributionStrategies and convert the Keras Model to an # Estimator that utilizes these DistributionStrateges. # Evaluator is a single worker, so using MirroredStrategy. config = tf.estimator.RunConfig( experimental_distribute=tf.contrib.distribute.DistributeConfig( train_distribute=tf.contrib.distribute.CollectiveAllReduceStrategy( num_gpus_per_worker=0), eval_distribute=tf.contrib.distribute.MirroredStrategy( num_gpus_per_worker=0))) keras_estimator = tf.keras.estimator.model_to_estimator( keras_model=model, config=config, model_dir=model_dir) # Train and evaluate the model. Evaluation will be skipped if there is not an # "evaluator" job in the cluster. tf.estimator.train_and_evaluate( keras_estimator, train_spec=tf.estimator.TrainSpec(input_fn=input_fn), eval_spec=tf.estimator.EvalSpec(input_fn=input_fn)) # def serving_input_receiver_fn(): # inputs = {model.input_names[0]: tf.placeholder(tf.float32, [None, 28, 28])} # return tf.estimator.export.ServingInputReceiver(inputs, inputs) # # keras_estimator.export_saved_model('saved_model', serving_input_receiver_fn) # task_type, task_id = (strategy.cluster_resolver.task_type, # strategy.cluster_resolver.task_id) tf_config_json = os.environ.get("TF_CONFIG", "{}") tf_config = json.loads(tf_config_json) task = tf_config.get("task", {}) job_name = task["type"] task_id = task["index"] is_chief = (job_name == 'chief' or job_name == 'worker') and (task_id == 0) if is_chief: print("exporting model ") # only save the model for chief keras_saved_model.save_keras_model(model, export_dir) print("exported model ")
def test_saving_with_tf_optimizer(self): with self.cached_session(): model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3, ))) model.add(keras.layers.Dense(3)) model.compile(loss='mse', optimizer=training_module.RMSPropOptimizer(0.1), metrics=['acc']) x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) model.train_on_batch(x, y) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model( model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) loaded_model.compile( loss='mse', optimizer=training_module.RMSPropOptimizer(0.1), metrics=['acc']) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05) # test that new updates are the same with both models x = np.random.random((1, 3)) y = np.random.random((1, 3)) ref_loss = model.train_on_batch(x, y) loss = loaded_model.train_on_batch(x, y) self.assertAllClose(ref_loss, loss, atol=1e-05) ref_y = model.predict(x) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05) # test saving/loading again temp_saved_model2 = self._save_model_dir('saved_model_2') output_path2 = keras_saved_model.save_keras_model( loaded_model, temp_saved_model2) loaded_model = keras_saved_model.load_keras_model(output_path2) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_with_tf_optimizer(self): with self.cached_session(): model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3,))) model.add(keras.layers.Dense(3)) model.compile( loss='mse', optimizer=training_module.RMSPropOptimizer(0.1), metrics=['acc']) x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) model.train_on_batch(x, y) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model(model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) loaded_model.compile( loss='mse', optimizer=training_module.RMSPropOptimizer(0.1), metrics=['acc']) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05) # test that new updates are the same with both models x = np.random.random((1, 3)) y = np.random.random((1, 3)) ref_loss = model.train_on_batch(x, y) loss = loaded_model.train_on_batch(x, y) self.assertAllClose(ref_loss, loss, atol=1e-05) ref_y = model.predict(x) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05) # test saving/loading again temp_saved_model2 = self._save_model_dir('saved_model_2') output_path2 = keras_saved_model.save_keras_model( loaded_model, temp_saved_model2) loaded_model = keras_saved_model.load_keras_model(output_path2) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_subclassed_model_raise_error(self): # For now, saving subclassed model should raise an error. It should be # avoided later with loading from SavedModel.pb. class SubclassedModel(training.Model): def __init__(self): super(SubclassedModel, self).__init__() self.layer1 = keras.layers.Dense(3) self.layer2 = keras.layers.Dense(1) def call(self, inp): return self.layer2(self.layer1(inp)) model = SubclassedModel() temp_saved_model = self._save_model_dir() with self.assertRaises(NotImplementedError): keras_saved_model.save_keras_model(model, temp_saved_model)
def test_saving_subclassed_model_raise_error(self): # For now, saving subclassed model should raise an error. It should be # avoided later with loading from SavedModel.pb. class SubclassedModel(training.Model): def __init__(self): super(SubclassedModel, self).__init__() self.layer1 = keras.layers.Dense(3) self.layer2 = keras.layers.Dense(1) def call(self, inp): return self.layer2(self.layer1(inp)) model = SubclassedModel() temp_saved_model = self._save_model_dir() with self.assertRaises(NotImplementedError): keras_saved_model.save_keras_model(model, temp_saved_model)
def testSaveSequentialModelWithoutInputShapes(self): model = sequential_model_without_input_shape(True) # A Sequential model that hasn't been built should raise an error. with self.assertRaisesRegexp(ValueError, 'Please build the model'): keras_saved_model.save_keras_model(model, '') saved_model_path = self._save_model_dir() output_path = keras_saved_model.save_keras_model( model, saved_model_path, input_signature=tensor_spec.TensorSpec(shape=(10, 11, 12, 13, 14), dtype=dtypes.float32, name='spec_input')) with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) self.assertEqual(5, inputs[next(iter(inputs.keys()))].shape.ndims) self.assertEqual(5, outputs[next(iter(outputs.keys()))].shape.ndims) self.assertEqual(3, outputs[next(iter(outputs.keys()))].shape[-1])
def test_saving_sequential_model_without_compile(self): with self.cached_session(): model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3,))) model.add(keras.layers.RepeatVector(3)) model.add(keras.layers.TimeDistributed(keras.layers.Dense(3))) x = np.random.random((1, 3)) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model(model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_sequential_model_without_compile(self): with self.cached_session(): model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3,))) model.add(keras.layers.RepeatVector(3)) model.add(keras.layers.TimeDistributed(keras.layers.Dense(3))) x = np.random.random((1, 3)) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model(model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def testServingOnly(self, model_builder, input_signature): saved_model_path = self._save_model_dir() input_arr = np.random.random((5, 3)).astype(np.float32) model = model_builder() ref_predict = model.predict(input_arr) output_path = keras_saved_model.save_keras_model( model, saved_model_path, serving_only=True, input_signature=input_signature) # Load predict graph, and test predictions with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) predictions = sess.run(outputs[next(iter(outputs.keys()))], {inputs[next(iter(inputs.keys()))]: input_arr}) self.assertAllClose(ref_predict, predictions, atol=1e-05)
def testSaveAndLoadSavedModelWithCustomObject(self): saved_model_path = self._save_model_dir() with session.Session(graph=ops.Graph()) as sess: def relu6(x): return keras.backend.relu(x, max_value=6) inputs = keras.layers.Input(shape=(1,)) outputs = keras.layers.Activation(relu6)(inputs) model = keras.models.Model(inputs, outputs) output_path = keras_saved_model.save_keras_model( model, saved_model_path, custom_objects={'relu6': relu6}) with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) input_name = model.input_names[0] output_name = model.output_names[0] predictions = sess.run( outputs[output_name], {inputs[input_name]: [[7], [-3], [4]]}) self.assertAllEqual([[6], [0], [4]], predictions)
def testSaveAndLoadSavedModelWithCustomObject(self): saved_model_path = self._save_model_dir() with session.Session(graph=ops.Graph()) as sess: def relu6(x): return keras.backend.relu(x, max_value=6) inputs = keras.layers.Input(shape=(1,)) outputs = keras.layers.Activation(relu6)(inputs) model = keras.models.Model(inputs, outputs) output_path = keras_saved_model.save_keras_model( model, saved_model_path, custom_objects={'relu6': relu6}) with session.Session(graph=ops.Graph()) as sess: inputs, outputs = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) input_name = model.input_names[0] output_name = model.output_names[0] predictions = sess.run( outputs[output_name], {inputs[input_name]: [[7], [-3], [4]]}) self.assertAllEqual([[6], [0], [4]], predictions)
def test_saving_functional_model_without_compile(self): with self.cached_session(): inputs = keras.layers.Input(shape=(3,)) x = keras.layers.Dense(2)(inputs) output = keras.layers.Dense(3)(x) model = keras.models.Model(inputs, output) x = np.random.random((1, 3)) y = np.random.random((1, 3)) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model(model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_functional_model_without_compile(self): with self.cached_session(): inputs = keras.layers.Input(shape=(3,)) x = keras.layers.Dense(2)(inputs) output = keras.layers.Dense(3)(x) model = keras.models.Model(inputs, output) x = np.random.random((1, 3)) y = np.random.random((1, 3)) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model(model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_functional_model(self): with self.cached_session(): inputs = keras.layers.Input(shape=(3, )) x = keras.layers.Dense(2)(inputs) output = keras.layers.Dense(3)(x) model = keras.models.Model(inputs, output) model.compile(loss=keras.losses.MSE, optimizer=keras.optimizers.RMSprop(lr=0.0001), metrics=[keras.metrics.categorical_accuracy]) x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model( model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_sequential_model(self): with self.cached_session(): model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3, ))) model.add(keras.layers.RepeatVector(3)) model.add(keras.layers.TimeDistributed(keras.layers.Dense(3))) model.compile(loss=keras.losses.MSE, optimizer=keras.optimizers.RMSprop(lr=0.0001), metrics=[keras.metrics.categorical_accuracy], sample_weight_mode='temporal') x = np.random.random((1, 3)) y = np.random.random((1, 3, 3)) model.train_on_batch(x, y) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model( model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_functional_model(self): with self.cached_session(): inputs = keras.layers.Input(shape=(3,)) x = keras.layers.Dense(2)(inputs) output = keras.layers.Dense(3)(x) model = keras.models.Model(inputs, output) model.compile( loss=keras.losses.MSE, optimizer=keras.optimizers.RMSprop(lr=0.0001), metrics=[keras.metrics.categorical_accuracy]) x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model(model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def test_saving_sequential_model(self): with self.cached_session(): model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3,))) model.add(keras.layers.RepeatVector(3)) model.add(keras.layers.TimeDistributed(keras.layers.Dense(3))) model.compile( loss=keras.losses.MSE, optimizer=keras.optimizers.RMSprop(lr=0.0001), metrics=[keras.metrics.categorical_accuracy], sample_weight_mode='temporal') x = np.random.random((1, 3)) y = np.random.random((1, 3, 3)) model.train_on_batch(x, y) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.save_keras_model(model, temp_saved_model) loaded_model = keras_saved_model.load_keras_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
def testSaveAndLoadSavedModelExport(self, model_builder, uses_learning_phase, optimizer, train_before_export): saved_model_path = self._save_model_dir() with self.session(graph=ops.Graph()): input_arr = np.random.random((1, 3)) target_arr = np.random.random((1, 3)) model = model_builder(uses_learning_phase) if optimizer is not None: model.compile(loss='mse', optimizer=optimizer, metrics=['mae']) if train_before_export: model.train_on_batch(input_arr, target_arr) ref_loss, ref_mae = model.evaluate(input_arr, target_arr) ref_predict = model.predict(input_arr) # Export SavedModel output_path = keras_saved_model.save_keras_model( model, saved_model_path) input_name = model.input_names[0] output_name = model.output_names[0] target_name = output_name + '_target' # Load predict graph, and test predictions with session.Session(graph=ops.Graph()) as sess: inputs, outputs = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) predictions = sess.run(outputs[output_name], {inputs[input_name]: input_arr}) self.assertAllClose(ref_predict, predictions, atol=1e-05) if optimizer: # Load eval graph, and test predictions, loss and metric values with session.Session(graph=ops.Graph()) as sess: inputs, outputs = load_model(sess, output_path, model_fn_lib.ModeKeys.EVAL) eval_results = sess.run(outputs, { inputs[input_name]: input_arr, inputs[target_name]: target_arr }) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertAllClose(ref_loss, eval_results['loss'], atol=1e-05) self.assertAllClose(ref_mae, eval_results['metrics/mae/update_op'], atol=1e-05) self.assertAllClose(ref_predict, eval_results['predictions/' + output_name], atol=1e-05) # Load train graph, and check for the train op, and prediction values with session.Session(graph=ops.Graph()) as sess: inputs, outputs = load_model(sess, output_path, model_fn_lib.ModeKeys.TRAIN) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertIn('loss', outputs) self.assertIn('metrics/mae/update_op', outputs) self.assertIn('metrics/mae/value', outputs) self.assertIn('predictions/' + output_name, outputs) # Train for a step train_op = ops.get_collection(constants.TRAIN_OP_KEY) train_outputs, _ = sess.run([outputs, train_op], { inputs[input_name]: input_arr, inputs[target_name]: target_arr }) self.assertEqual( int(train_before_export) + 1, sess.run(training_module.get_global_step())) if uses_learning_phase: self.assertAllClose([[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05) else: self.assertNotAllClose([[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05)
def testSaveAndLoadSavedModelExport(self, model_builder, uses_learning_phase, optimizer, train_before_export): saved_model_path = self._save_model_dir() with self.session(graph=ops.Graph()): np.random.seed(130) input_arr = np.random.random((1, 3)) target_arr = np.random.random((1, 3)) model = model_builder(uses_learning_phase) if optimizer is not None: model.compile(loss='mse', optimizer=optimizer, metrics=['mae']) if train_before_export: model.train_on_batch(input_arr, target_arr) ref_loss, ref_mae = model.evaluate(input_arr, target_arr) ref_predict = model.predict(input_arr) # Export SavedModel output_path = keras_saved_model.save_keras_model( model, saved_model_path) input_name = model.input_names[0] output_name = model.output_names[0] target_name = output_name + '_target' # Load predict graph, and test predictions with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) predictions = sess.run(outputs[output_name], {inputs[input_name]: input_arr}) self.assertAllClose(ref_predict, predictions, atol=1e-05) if optimizer: # Load eval graph, and test predictions, loss and metric values with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, model_fn_lib.ModeKeys.EVAL) # First obtain the loss and predictions, and run the metric update op by # feeding in the inputs and targets. loss, predictions, _ = sess.run( (outputs['loss'], outputs['predictions/' + output_name], outputs['metrics/mean_absolute_error/update_op']), { inputs[input_name]: input_arr, inputs[target_name]: target_arr }) # The metric value should be run after the update op, to ensure that it # reflects the correct value. metric_value = sess.run( outputs['metrics/mean_absolute_error/value']) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertAllClose(ref_loss, loss, atol=1e-05) self.assertAllClose(ref_mae, metric_value, atol=1e-05) self.assertAllClose(ref_predict, predictions, atol=1e-05) # Load train graph, and check for the train op, and prediction values with session.Session(graph=ops.Graph()) as sess: inputs, outputs, meta_graph_def = load_model( sess, output_path, model_fn_lib.ModeKeys.TRAIN) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertIn('loss', outputs) self.assertIn('metrics/mean_absolute_error/update_op', outputs) self.assertIn('metrics/mean_absolute_error/value', outputs) self.assertIn('predictions/' + output_name, outputs) # Train for a step train_op = loader_impl.get_train_op(meta_graph_def) train_outputs, _ = sess.run([outputs, train_op], { inputs[input_name]: input_arr, inputs[target_name]: target_arr }) self.assertEqual( int(train_before_export) + 1, sess.run(training_module.get_global_step())) if uses_learning_phase: self.assertAllClose([[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05) else: self.assertNotAllClose([[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05)
def testSaveSeqModelWithoutInputShapesRaisesError(self): """A Sequential model that hasn't been built should raise an error.""" model = sequential_model_without_input_shape(True) with self.assertRaisesRegexp( ValueError, 'must be built'): keras_saved_model.save_keras_model(model, '')
def testSaveAndLoadSavedModelExport( self, model_builder, uses_learning_phase, optimizer, train_before_export): saved_model_path = self._save_model_dir() with self.session(graph=ops.Graph()): input_arr = np.random.random((1, 3)) target_arr = np.random.random((1, 3)) model = model_builder(uses_learning_phase) if optimizer is not None: model.compile( loss='mse', optimizer=optimizer, metrics=['mae']) if train_before_export: model.train_on_batch(input_arr, target_arr) ref_loss, ref_mae = model.evaluate(input_arr, target_arr) ref_predict = model.predict(input_arr) # Export SavedModel output_path = keras_saved_model.save_keras_model(model, saved_model_path) input_name = model.input_names[0] output_name = model.output_names[0] target_name = output_name + '_target' # Load predict graph, and test predictions with session.Session(graph=ops.Graph()) as sess: inputs, outputs = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) predictions = sess.run(outputs[output_name], {inputs[input_name]: input_arr}) self.assertAllClose(ref_predict, predictions, atol=1e-05) if optimizer: # Load eval graph, and test predictions, loss and metric values with session.Session(graph=ops.Graph()) as sess: inputs, outputs = load_model(sess, output_path, model_fn_lib.ModeKeys.EVAL) eval_results = sess.run(outputs, {inputs[input_name]: input_arr, inputs[target_name]: target_arr}) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertAllClose(ref_loss, eval_results['loss'], atol=1e-05) self.assertAllClose( ref_mae, eval_results['metrics/mae/update_op'], atol=1e-05) self.assertAllClose( ref_predict, eval_results['predictions/' + output_name], atol=1e-05) # Load train graph, and check for the train op, and prediction values with session.Session(graph=ops.Graph()) as sess: inputs, outputs = load_model(sess, output_path, model_fn_lib.ModeKeys.TRAIN) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertIn('loss', outputs) self.assertIn('metrics/mae/update_op', outputs) self.assertIn('metrics/mae/value', outputs) self.assertIn('predictions/' + output_name, outputs) # Train for a step train_op = ops.get_collection(constants.TRAIN_OP_KEY) train_outputs, _ = sess.run( [outputs, train_op], {inputs[input_name]: input_arr, inputs[target_name]: target_arr}) self.assertEqual(int(train_before_export) + 1, sess.run(training_module.get_global_step())) if uses_learning_phase: self.assertAllClose( [[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05) else: self.assertNotAllClose( [[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05)
def testSaveAndLoadSavedModelExport( self, model_builder, uses_learning_phase, optimizer, train_before_export): saved_model_path = self._save_model_dir() with self.session(graph=ops.Graph()): np.random.seed(130) input_arr = np.random.random((1, 3)) target_arr = np.random.random((1, 3)) model = model_builder(uses_learning_phase) if optimizer is not None: model.compile( loss='mse', optimizer=optimizer, metrics=['mae']) if train_before_export: model.train_on_batch(input_arr, target_arr) ref_loss, ref_mae = model.evaluate(input_arr, target_arr) ref_predict = model.predict(input_arr) # Export SavedModel output_path = keras_saved_model.save_keras_model(model, saved_model_path) input_name = model.input_names[0] output_name = model.output_names[0] target_name = output_name + '_target' # Load predict graph, and test predictions with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, model_fn_lib.ModeKeys.PREDICT) predictions = sess.run(outputs[output_name], {inputs[input_name]: input_arr}) self.assertAllClose(ref_predict, predictions, atol=1e-05) if optimizer: # Load eval graph, and test predictions, loss and metric values with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, model_fn_lib.ModeKeys.EVAL) # First obtain the loss and predictions, and run the metric update op by # feeding in the inputs and targets. loss, predictions, _ = sess.run( (outputs['loss'], outputs['predictions/' + output_name], outputs['metrics/mean_absolute_error/update_op']), { inputs[input_name]: input_arr, inputs[target_name]: target_arr }) # The metric value should be run after the update op, to ensure that it # reflects the correct value. metric_value = sess.run(outputs['metrics/mean_absolute_error/value']) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertAllClose(ref_loss, loss, atol=1e-05) self.assertAllClose(ref_mae, metric_value, atol=1e-05) self.assertAllClose(ref_predict, predictions, atol=1e-05) # Load train graph, and check for the train op, and prediction values with session.Session(graph=ops.Graph()) as sess: inputs, outputs, meta_graph_def = load_model( sess, output_path, model_fn_lib.ModeKeys.TRAIN) self.assertEqual(int(train_before_export), sess.run(training_module.get_global_step())) self.assertIn('loss', outputs) self.assertIn('metrics/mean_absolute_error/update_op', outputs) self.assertIn('metrics/mean_absolute_error/value', outputs) self.assertIn('predictions/' + output_name, outputs) # Train for a step train_op = loader_impl.get_train_op(meta_graph_def) train_outputs, _ = sess.run( [outputs, train_op], {inputs[input_name]: input_arr, inputs[target_name]: target_arr}) self.assertEqual(int(train_before_export) + 1, sess.run(training_module.get_global_step())) if uses_learning_phase: self.assertAllClose( [[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05) else: self.assertNotAllClose( [[0, 0, 0]], train_outputs['predictions/' + output_name], atol=1e-05)
def testSaveSeqModelWithoutInputShapesRaisesError(self): """A Sequential model that hasn't been built should raise an error.""" model = sequential_model_without_input_shape(True) with self.assertRaisesRegexp(ValueError, 'must be built'): keras_saved_model.save_keras_model(model, '')