def model_fn(features, labels, mode, params): """model_fn constructs the ML model used to predict handwritten digits.""" del params if mode == tf.estimator.ModeKeys.PREDICT: raise RuntimeError("mode {} is not supported yet".format(mode)) image = features if isinstance(image, dict): image = features["image"] model = mnist.create_model("channels_last") logits = model(image, training=(mode == tf.estimator.ModeKeys.TRAIN)) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) if mode == tf.estimator.ModeKeys.TRAIN: learning_rate = tf.train.exponential_decay(FLAGS.learning_rate, tf.train.get_global_step(), decay_steps=100000, decay_rate=0.96) optimizer = tf.train.GradientDescentOptimizer( learning_rate=learning_rate) if FLAGS.use_tpu: optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer) return tf.contrib.tpu.TPUEstimatorSpec(mode=mode, loss=loss, train_op=optimizer.minimize( loss, tf.train.get_global_step())) if mode == tf.estimator.ModeKeys.EVAL: return tf.contrib.tpu.TPUEstimatorSpec(mode=mode, loss=loss, eval_metrics=(metric_fn, [labels, logits]))
def evaluate(defun=False): model = mnist.create_model(data_format()) dataset = random_dataset() if defun: model.call = tfe.defun(model.call) with tf.device(device()): mnist_eager.test(model, dataset)
def model_fn(features, labels, mode, params): """model_fn constructs the ML model used to predict handwritten digits.""" del params if mode == tf.estimator.ModeKeys.PREDICT: raise RuntimeError("mode {} is not supported yet".format(mode)) image = features if isinstance(image, dict): image = features["image"] model = mnist.create_model("channels_last") logits = model(image, training=(mode == tf.estimator.ModeKeys.TRAIN)) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) if mode == tf.estimator.ModeKeys.TRAIN: learning_rate = tf.train.exponential_decay( FLAGS.learning_rate, tf.train.get_global_step(), decay_steps=100000, decay_rate=0.96) optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate) if FLAGS.use_tpu: optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer) return tf.contrib.tpu.TPUEstimatorSpec( mode=mode, loss=loss, train_op=optimizer.minimize(loss, tf.train.get_global_step())) if mode == tf.estimator.ModeKeys.EVAL: return tf.contrib.tpu.TPUEstimatorSpec( mode=mode, loss=loss, eval_metrics=(metric_fn, [labels, logits]))
def get_prediction(img, flags_obj): """Run MNIST training and eval loop in eager mode. Args: flags_obj: An object containing parsed flag values. """ # model_helpers.apply_clean(flags.FLAGS) model_helpers.apply_clean(flags_obj) # Automatically determine device and data_format (device, data_format) = ('/gpu:0', 'channels_first') if flags_obj.no_gpu or not tf.test.is_gpu_available(): (device, data_format) = ('/cpu:0', 'channels_last') # If data_format is defined in FLAGS, overwrite automatically set value. if flags_obj.data_format is not None: data_format = flags_obj.data_format print('Using device %s, and data format %s.' % (device, data_format)) # Load the datasets # train_ds = mnist_dataset.train(flags_obj.data_dir).shuffle(60000).batch( # flags_obj.batch_size) # test_ds = mnist_dataset.test(flags_obj.data_dir).batch( # flags_obj.batch_size) # Create the model and optimizer model = mnist.create_model(data_format) optimizer = tf.train.MomentumOptimizer(flags_obj.lr, flags_obj.momentum) # Create file writers for writing TensorBoard summaries. if flags_obj.output_dir: # Create directories to which summaries will be written # tensorboard --logdir=<output_dir> # can then be used to see the recorded summaries. train_dir = os.path.join(flags_obj.output_dir, 'train') test_dir = os.path.join(flags_obj.output_dir, 'eval') tf.gfile.MakeDirs(flags_obj.output_dir) else: train_dir = None test_dir = None # Create and restore checkpoint (if one exists on the path) checkpoint_prefix = os.path.join(flags_obj.model_dir, 'ckpt') step_counter = tf.train.get_or_create_global_step() checkpoint = tf.train.Checkpoint(model=model, optimizer=optimizer, step_counter=step_counter) # Restore variables on creation if a checkpoint exists. checkpoint.restore(tf.train.latest_checkpoint(flags_obj.model_dir)) # Train and evaluate for a set number of epochs. with tf.device(device): logits = model(img, training=False) prob = tf.nn.softmax(logits) cls = tf.argmax(logits, axis=1, output_type=tf.int64) return int(cls.numpy()[0]), prob.numpy()
def train(defun=False): model = mnist.create_model(data_format()) if defun: model.call = tfe.defun(model.call) optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01) dataset = random_dataset() with tf.device(device()): mnist_eager.train(model, optimizer, dataset, step_counter=tf.train.get_or_create_global_step())
def model_fn(features, labels, mode, params): """model_fn constructs the ML model used to predict handwritten digits.""" del params image = features if isinstance(image, dict): image = features["image"] model = mnist.create_model("channels_last") if mode == tf.estimator.ModeKeys.PREDICT: logits = model(image, training=False) predictions = { 'class_ids': tf.argmax(logits, axis=1), 'probabilities': tf.nn.softmax(logits), } return tf.contrib.tpu.TPUEstimatorSpec(mode, predictions=predictions) logits = model(image, training=(mode == tf.estimator.ModeKeys.TRAIN)) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) if mode == tf.estimator.ModeKeys.TRAIN: learning_rate = tf.train.exponential_decay(FLAGS.learning_rate, tf.train.get_global_step(), decay_steps=100000, decay_rate=0.96) optimizer = tf.train.GradientDescentOptimizer( learning_rate=learning_rate) if FLAGS.use_tpu: optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer) return tf.contrib.tpu.TPUEstimatorSpec(mode=mode, loss=loss, train_op=optimizer.minimize( loss, tf.train.get_global_step())) if mode == tf.estimator.ModeKeys.EVAL: return tf.contrib.tpu.TPUEstimatorSpec(mode=mode, loss=loss, eval_metrics=(metric_fn, [labels, logits]))
def model_fn(features, labels, mode, params): """model_fn constructs the ML model used to predict handwritten digits.""" del params image = features if isinstance(image, dict): image = features["image"] model = mnist.create_model("channels_last") if mode == tf.estimator.ModeKeys.PREDICT: logits = model(image, training=False) predictions = { 'class_ids': tf.argmax(logits, axis=1), 'probabilities': tf.nn.softmax(logits), } return tf.contrib.tpu.TPUEstimatorSpec(mode, predictions=predictions) logits = model(image, training=(mode == tf.estimator.ModeKeys.TRAIN)) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) if mode == tf.estimator.ModeKeys.TRAIN: learning_rate = tf.train.exponential_decay( FLAGS.learning_rate, tf.train.get_global_step(), decay_steps=100000, decay_rate=0.96) optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate) if FLAGS.use_tpu: optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer) return tf.contrib.tpu.TPUEstimatorSpec( mode=mode, loss=loss, train_op=optimizer.minimize(loss, tf.train.get_global_step())) if mode == tf.estimator.ModeKeys.EVAL: return tf.contrib.tpu.TPUEstimatorSpec( mode=mode, loss=loss, eval_metrics=(metric_fn, [labels, logits]))
def run_mnist_eager(flags_obj): """Run MNIST training and eval loop in eager mode. Args: flags_obj: An object containing parsed flag values. """ tf.enable_eager_execution() model_helpers.apply_clean(flags.FLAGS) # Automatically determine device and data_format (device, data_format) = ('/gpu:0', 'channels_first') if flags_obj.no_gpu or not tf.test.is_gpu_available(): (device, data_format) = ('/cpu:0', 'channels_last') # If data_format is defined in FLAGS, overwrite automatically set value. if flags_obj.data_format is not None: data_format = flags_obj.data_format print('Using device %s, and data format %s.' % (device, data_format)) # Load the datasets train_ds = mnist_dataset.train(flags_obj.data_dir).shuffle(60000).batch( flags_obj.batch_size) test_ds = mnist_dataset.test(flags_obj.data_dir).batch( flags_obj.batch_size) # Create the model and optimizer model = mnist.create_model(data_format) optimizer = tf.train.MomentumOptimizer(flags_obj.lr, flags_obj.momentum) # Create file writers for writing TensorBoard summaries. if flags_obj.output_dir: # Create directories to which summaries will be written # tensorboard --logdir=<output_dir> # can then be used to see the recorded summaries. train_dir = os.path.join(flags_obj.output_dir, 'train') test_dir = os.path.join(flags_obj.output_dir, 'eval') tf.gfile.MakeDirs(flags_obj.output_dir) else: train_dir = None test_dir = None summary_writer = tf.contrib.summary.create_file_writer(train_dir, flush_millis=10000) test_summary_writer = tf.contrib.summary.create_file_writer( test_dir, flush_millis=10000, name='test') # Create and restore checkpoint (if one exists on the path) checkpoint_prefix = os.path.join(flags_obj.model_dir, 'ckpt') step_counter = tf.train.get_or_create_global_step() checkpoint = tf.train.Checkpoint(model=model, optimizer=optimizer, step_counter=step_counter) # Restore variables on creation if a checkpoint exists. checkpoint.restore(tf.train.latest_checkpoint(flags_obj.model_dir)) # Train and evaluate for a set number of epochs. with tf.device(device): for _ in range(flags_obj.train_epochs): start = time.time() with summary_writer.as_default(): train(model, optimizer, train_ds, step_counter, flags_obj.log_interval) end = time.time() print('\nTrain time for epoch #%d (%d total steps): %f' % (checkpoint.save_counter.numpy() + 1, step_counter.numpy(), end - start)) with test_summary_writer.as_default(): test(model, test_ds) checkpoint.save(checkpoint_prefix)
def main(argv): parser = MNISTEagerArgParser() flags = parser.parse_args(args=argv[1:]) tfe.enable_eager_execution() # Automatically determine device and data_format (device, data_format) = ('/gpu:0', 'channels_first') if flags.no_gpu or tfe.num_gpus() <= 0: (device, data_format) = ('/cpu:0', 'channels_last') # If data_format is defined in FLAGS, overwrite automatically set value. if flags.data_format is not None: data_format = flags.data_format print('Using device %s, and data format %s.' % (device, data_format)) # Load the datasets train_ds = mnist_dataset.train(flags.data_dir).shuffle(60000).batch( flags.batch_size) test_ds = mnist_dataset.test(flags.data_dir).batch(flags.batch_size) # Create the model and optimizer model = mnist.create_model(data_format) optimizer = tf.train.MomentumOptimizer(flags.lr, flags.momentum) # Create file writers for writing TensorBoard summaries. if flags.output_dir: # Create directories to which summaries will be written # tensorboard --logdir=<output_dir> # can then be used to see the recorded summaries. train_dir = os.path.join(flags.output_dir, 'train') test_dir = os.path.join(flags.output_dir, 'eval') tf.gfile.MakeDirs(flags.output_dir) else: train_dir = None test_dir = None summary_writer = tf.contrib.summary.create_file_writer( train_dir, flush_millis=10000) test_summary_writer = tf.contrib.summary.create_file_writer( test_dir, flush_millis=10000, name='test') # Create and restore checkpoint (if one exists on the path) checkpoint_prefix = os.path.join(flags.model_dir, 'ckpt') step_counter = tf.train.get_or_create_global_step() checkpoint = tfe.Checkpoint( model=model, optimizer=optimizer, step_counter=step_counter) # Restore variables on creation if a checkpoint exists. checkpoint.restore(tf.train.latest_checkpoint(flags.model_dir)) # Train and evaluate for a set number of epochs. with tf.device(device): for _ in range(flags.train_epochs): start = time.time() with summary_writer.as_default(): train(model, optimizer, train_ds, step_counter, flags.log_interval) end = time.time() print('\nTrain time for epoch #%d (%d total steps): %f' % (checkpoint.save_counter.numpy() + 1, step_counter.numpy(), end - start)) with test_summary_writer.as_default(): test(model, test_ds) checkpoint.save(checkpoint_prefix)
from official.mnist import dataset as mnist_dataset from official.mnist import mnist from official.utils.flags import core as flags_core from official.utils.misc import model_helpers # Eager Modeに変更する tf.enable_eager_execution() tfe = tf.contrib.eager train_ds = mnist_dataset.train(".").shuffle(60000).batch(128) test_ds = mnist_dataset.train(".").batch(128) import ipdb ipdb.set_trace() model = mnist.create_model('channels_last') optimizer = tf.train.MomentumOptimizer(0.01, 0.01) train_dir = "train" test_dir = "test" def loss(logits, labels): return tf.reduce_mean( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=logits, labels=labels ) ) def test(model, dataset):