def main(argv): del argv named_strategy = ( ds_utils.named_strategies.get(FLAGS.strategy) if FLAGS.strategy else None) strategy = named_strategy.strategy if named_strategy else None with MaybeDistributionScope(strategy): feature_extractor = make_feature_extractor( FLAGS.input_saved_model_dir, FLAGS.retrain, FLAGS.regularization_loss_multiplier) model = make_classifier(feature_extractor) model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) # Train the classifier (possibly on a different dataset). (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( use_fashion_mnist=FLAGS.use_fashion_mnist, fake_tiny_data=FLAGS.fast_test_mode) print('Training on %s with %d trainable and %d untrainable variables.' % ('Fashion MNIST' if FLAGS.use_fashion_mnist else 'MNIST', len(model.trainable_variables), len(model.non_trainable_variables))) model.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test)) if FLAGS.output_saved_model_dir and FLAGS.output_saved_model_dir != 'None': tf.saved_model.save(model, FLAGS.output_saved_model_dir)
def main(argv): del argv # Build a complete classifier model using a feature extractor. default_hparams = dict(dropout_rate=0.25) l2_strength = 0.01 # Not a hparam for inputs -> outputs. feature_extractor = make_feature_extractor(l2_strength=l2_strength, **default_hparams) classifier = make_classifier(feature_extractor, l2_strength=l2_strength) # Train the complete model. (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( fake_tiny_data=FLAGS.fast_test_mode) classifier.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) classifier.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test)) # Save the feature extractor to a framework-agnostic SavedModel for reuse. # Note that the feature_extractor object has not been compiled or fitted, # so it does not contain an optimizer and related state. exportable = wrap_keras_model_for_export(feature_extractor, (None, ) + mnist_util.INPUT_SHAPE, set_feature_extractor_hparams, default_hparams) tf.saved_model.save(exportable, FLAGS.export_dir)
def main(argv): del argv # Build a complete classifier model using a feature extractor. feature_extractor = make_feature_extractor() classifier = make_classifier(feature_extractor) # Train the complete model (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( fake_tiny_data=FLAGS.fast_test_mode) classifier.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) classifier.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test)) # Save the feature extractor to a framework-agnostic SavedModel for reuse. # Note that the feature_extractor object has not been compiled or fitted, # so it does not contain an optimizer and related state. exportable = wrap_keras_model_for_export(feature_extractor) tf.saved_model.save(exportable, FLAGS.export_dir)
def main(argv): del argv if FLAGS.use_mirrored_strategy: strategy = tf.distribute.MirroredStrategy() else: strategy = tf.distribute.get_strategy() with strategy.scope(): feature_extractor = make_feature_extractor( FLAGS.input_saved_model_dir, FLAGS.retrain, FLAGS.regularization_loss_multiplier) model = make_classifier(feature_extractor, dropout_rate=0.0) # TODO(b/134660903): Remove. model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) # Train the classifier (possibly on a different dataset). (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( use_fashion_mnist=FLAGS.use_fashion_mnist, fake_tiny_data=FLAGS.fast_test_mode) print('Training on %s with %d trainable and %d untrainable variables.' % ('Fashion MNIST' if FLAGS.use_fashion_mnist else 'MNIST', len(model.trainable_variables), len(model.non_trainable_variables))) model.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test)) if FLAGS.output_saved_model_dir: tf.saved_model.save(model, FLAGS.output_saved_model_dir)
def main(argv): del argv # Load a pre-trained feature extractor and wrap it for use in Keras. obj = tf.saved_model.load(FLAGS.export_dir) scale_regularization_losses(obj, FLAGS.regularization_loss_multiplier) arguments = {} if FLAGS.dropout_rate is not None: arguments['dropout_rate'] = FLAGS.dropout_rate feature_extractor = util.CustomLayer(obj, output_shape=[10], trainable=FLAGS.retrain, arguments=arguments) # Build a classifier with it. model = make_classifier(feature_extractor) # Train the classifier (possibly on a different dataset). (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( use_fashion_mnist=FLAGS.use_fashion_mnist, fake_tiny_data=FLAGS.fast_test_mode) model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) print('Training on %s with %d trainable and %d untrainable variables.' % ('Fashion MNIST' if FLAGS.use_fashion_mnist else 'MNIST', len(model.trainable_variables), len(model.non_trainable_variables))) model.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test))
def main(argv): del argv if FLAGS.use_mirrored_strategy: strategy = tf.distribute.MirroredStrategy() else: strategy = tf.distribute.get_strategy() with strategy.scope(): feature_extractor = make_feature_extractor( FLAGS.export_dir, FLAGS.retrain, FLAGS.regularization_loss_multiplier) model = make_classifier(feature_extractor) model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) # Train the classifier (possibly on a different dataset). (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( use_fashion_mnist=FLAGS.use_fashion_mnist, fake_tiny_data=FLAGS.fast_test_mode) print('Training on %s with %d trainable and %d untrainable variables.' % ('Fashion MNIST' if FLAGS.use_fashion_mnist else 'MNIST', len(model.trainable_variables), len(model.non_trainable_variables))) model.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test))
def main(argv): del argv # Build a complete classifier model using a feature extractor. default_hparams = dict(dropout_rate=0.25) l2_strength = 0.01 # Not a hparam for inputs -> outputs. feature_extractor = make_feature_extractor(l2_strength=l2_strength, **default_hparams) classifier = make_classifier(feature_extractor, l2_strength=l2_strength) # Train the complete model. (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( fake_tiny_data=FLAGS.fast_test_mode) classifier.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) classifier.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test)) # Save the feature extractor to a framework-agnostic SavedModel for reuse. # Note that the feature_extractor object has not been compiled or fitted, # so it does not contain an optimizer and related state. exportable = wrap_keras_model_for_export(feature_extractor, (None,) + mnist_util.INPUT_SHAPE, set_feature_extractor_hparams, default_hparams) tf.saved_model.save(exportable, FLAGS.export_dir)
def main(argv): del argv # Load a pre-trained feature extractor and wrap it for use in Keras. obj = tf.saved_model.load(FLAGS.export_dir) feature_extractor = util.CustomLayer(obj, output_shape=[128], trainable=FLAGS.retrain) # Build a classifier with it. model = make_classifier(feature_extractor) # Train the classifier (possibly on a different dataset). (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( use_fashion_mnist=FLAGS.use_fashion_mnist, fake_tiny_data=FLAGS.fast_test_mode) model.compile( loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy'], # TODO(arnoegw): Remove after investigating huge allocs. run_eagerly=True) print('Training on %s with %d trainable and %d untrainable variables.' % ('Fashion MNIST' if FLAGS.use_fashion_mnist else 'MNIST', len(model.trainable_variables), len(model.non_trainable_variables))) model.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, steps_per_epoch=3, verbose=1, validation_data=(x_test, y_test))
def loadData(self): # module_path = os.path.dirname(__file__) # test_image = module_path + "t10k-images-idx3-ubyte" (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data(use_fashion_mnist=False, fake_tiny_data=False) x_train = np.reshape(x_train, (60000, 784)) x_test = np.reshape(x_test, (10000, 784)) return (x_train, y_train), (x_test, y_test)
def main(argv): del argv # First convert the SavedModel in a pristine environment. converter = tf.lite.TFLiteConverter.from_saved_model(FLAGS.saved_model_dir) lite_model_content = converter.convert() # Here is how you can save it for actual deployment. if FLAGS.tflite_output_file: with open(FLAGS.tflite_output_file, 'wb') as outfile: outfile.write(lite_model_content) # For testing, the TFLite model can be executed like this. interpreter = tf.lite.Interpreter(model_content=lite_model_content) def lite_model(images): interpreter.allocate_tensors() interpreter.set_tensor(interpreter.get_input_details()[0]['index'], images) interpreter.invoke() return interpreter.get_tensor( interpreter.get_output_details()[0]['index']) # Load the SavedModel again for use as a test baseline. imported = tf.saved_model.load(FLAGS.saved_model_dir) def tf_model(images): output_dict = imported.signatures['serving_default']( tf.constant(images)) logits, = output_dict.values() # Unpack single value. return logits # Compare model outputs on the test inputs. (_, _), (x_test, _) = mnist_util.load_reshaped_data( use_fashion_mnist=FLAGS.use_fashion_mnist, fake_tiny_data=FLAGS.fast_test_mode) for i, x in enumerate(x_test): x = x[None, ...] # Make batch of size 1. y_lite = lite_model(x) y_tf = tf_model(x) # This numpy primitive uses plain `raise` and works outside tf.TestCase. # Model outputs are probabilities that sum to 1, so atol makes sense here. np.testing.assert_allclose(y_lite, y_tf, rtol=0, atol=1e-5, err_msg='Mismatch at test example %d' % i)
def main(argv): del argv # Build a complete classifier model using a feature extractor. default_hparams = dict(dropout_rate=0.25) l2_strength = 0.01 # Not a hparam for inputs -> outputs. feature_extractor = make_feature_extractor(l2_strength=l2_strength, **default_hparams) classifier = make_classifier(feature_extractor, l2_strength=l2_strength) # Train the complete model. (x_train, y_train), (x_test, y_test) = mnist_util.load_reshaped_data( fake_tiny_data=FLAGS.fast_test_mode) classifier.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.SGD(), metrics=['accuracy']) classifier.fit(x_train, y_train, batch_size=128, epochs=FLAGS.epochs, verbose=1, validation_data=(x_test, y_test)) # Save the feature extractor to a framework-agnostic SavedModel for reuse. # Note that the feature_extractor object has not been compiled or fitted, # so it does not contain an optimizer and related state. if FLAGS.use_keras_save_api: # Use Keras' built-in way of creating reusable SavedModels. # This has no support for adjustable hparams at this time (July 2019). # (We could also call tf.saved_model.save(feature_extractor, ...), # point is we're passing a Keras model, not a plain Checkpoint.) tf.keras.models.save_model(feature_extractor, FLAGS.export_dir) else: # Assemble a reusable SavedModel manually, with adjustable hparams. exportable = wrap_keras_model_for_export( feature_extractor, (None, ) + mnist_util.INPUT_SHAPE, set_feature_extractor_hparams, default_hparams) tf.saved_model.save(exportable, FLAGS.export_dir)