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.export(model, temp_saved_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) ref_y = model.predict(x) temp_saved_model = self._save_model_dir() output_path = keras_saved_model.export(model, temp_saved_model) loaded_model = keras_saved_model.load_from_saved_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.export(loaded_model, temp_saved_model2) loaded_model = keras_saved_model.load_from_saved_model( output_path2) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, atol=1e-05)
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.export(model, '') saved_model_path = self._save_model_dir() output_path = keras_saved_model.export( 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, mode_keys.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.export(model, temp_saved_model) loaded_model = keras_saved_model.load_from_saved_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.export(model, temp_saved_model) loaded_model = keras_saved_model.load_from_saved_model(output_path) y = loaded_model.predict(x) self.assertAllClose(ref_y, y, 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.export( model, saved_model_path, custom_objects={'relu6': relu6}) with session.Session(graph=ops.Graph()) as sess: inputs, outputs, _ = load_model(sess, output_path, mode_keys.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 testServingOnly(self, model_builder, input_signature): if context.executing_eagerly(): 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.export( 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, mode_keys.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 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.export(model, temp_saved_model) loaded_model = keras_saved_model.load_from_saved_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.export(model, temp_saved_model) loaded_model = keras_saved_model.load_from_saved_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()): 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.export(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, mode_keys.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, mode_keys.ModeKeys.TEST) # 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, mode_keys.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)