def testNoSharing(self):
    # Two writers with the same logdir should not share state.
    logdir = self.get_temp_dir()
    with context.eager_mode():
      writer1 = summary_ops.create_file_writer_v2(logdir)
      with writer1.as_default():
        summary_ops.write('tag', 1, step=1)
      event_files = gfile.Glob(os.path.join(logdir, '*'))
      self.assertEqual(1, len(event_files))
      file1 = event_files[0]

      writer2 = summary_ops.create_file_writer_v2(logdir)
      with writer2.as_default():
        summary_ops.write('tag', 1, step=2)
      event_files = gfile.Glob(os.path.join(logdir, '*'))
      self.assertEqual(2, len(event_files))
      event_files.remove(file1)
      file2 = event_files[0]

      # Extra writes to ensure interleaved usage works.
      with writer1.as_default():
        summary_ops.write('tag', 1, step=1)
      with writer2.as_default():
        summary_ops.write('tag', 1, step=2)

    events = iter(events_from_file(file1))
    self.assertEqual('brain.Event:2', next(events).file_version)
    self.assertEqual(1, next(events).step)
    self.assertEqual(1, next(events).step)
    self.assertRaises(StopIteration, lambda: next(events))
    events = iter(events_from_file(file2))
    self.assertEqual('brain.Event:2', next(events).file_version)
    self.assertEqual(2, next(events).step)
    self.assertEqual(2, next(events).step)
    self.assertRaises(StopIteration, lambda: next(events))
    def testNoSharing(self):
        # Two writers with the same logdir should not share state.
        logdir = self.get_temp_dir()
        with context.eager_mode():
            writer1 = summary_ops.create_file_writer_v2(logdir)
            with writer1.as_default():
                summary_ops.write('tag', 1, step=1)
            event_files = gfile.Glob(os.path.join(logdir, '*'))
            self.assertEqual(1, len(event_files))
            file1 = event_files[0]

            writer2 = summary_ops.create_file_writer_v2(logdir)
            with writer2.as_default():
                summary_ops.write('tag', 1, step=2)
            event_files = gfile.Glob(os.path.join(logdir, '*'))
            self.assertEqual(2, len(event_files))
            event_files.remove(file1)
            file2 = event_files[0]

            # Extra writes to ensure interleaved usage works.
            with writer1.as_default():
                summary_ops.write('tag', 1, step=1)
            with writer2.as_default():
                summary_ops.write('tag', 1, step=2)

        events = iter(events_from_file(file1))
        self.assertEqual('brain.Event:2', next(events).file_version)
        self.assertEqual(1, next(events).step)
        self.assertEqual(1, next(events).step)
        self.assertRaises(StopIteration, lambda: next(events))
        events = iter(events_from_file(file2))
        self.assertEqual('brain.Event:2', next(events).file_version)
        self.assertEqual(2, next(events).step)
        self.assertEqual(2, next(events).step)
        self.assertRaises(StopIteration, lambda: next(events))
 def testCreate_graphTensorArgument_raisesError(self):
   logdir = self.get_temp_dir()
   with context.graph_mode():
     logdir_tensor = constant_op.constant(logdir)
   with context.eager_mode():
     with self.assertRaisesRegex(
         ValueError, 'Invalid graph Tensor argument.*logdir'):
       summary_ops.create_file_writer_v2(logdir_tensor)
   self.assertEmpty(gfile.Glob(os.path.join(logdir, '*')))
 def testCreate_immediateSetAsDefault_retainsReference(self):
     logdir = self.get_temp_dir()
     try:
         with context.eager_mode():
             summary_ops.create_file_writer_v2(logdir).set_as_default()
             summary_ops.flush()
     finally:
         # Ensure we clean up no matter how the test executes.
         context.context().summary_writer_resource = None
 def testCreate_immediateSetAsDefault_retainsReference(self):
   logdir = self.get_temp_dir()
   try:
     with context.eager_mode():
       summary_ops.create_file_writer_v2(logdir).set_as_default()
       summary_ops.flush()
   finally:
     # Ensure we clean up no matter how the test executes.
     context.context().summary_writer_resource = None
示例#6
0
 def testCreate_immediateSetAsDefault_retainsReference(self):
   logdir = self.get_temp_dir()
   try:
     with context.eager_mode():
       summary_ops.create_file_writer_v2(logdir).set_as_default()
       summary_ops.flush()
   finally:
     # Ensure we clean up no matter how the test executes.
     summary_ops._summary_state.writer = None  # pylint: disable=protected-access
 def testCreate_graphTensorArgument_raisesError(self):
     logdir = self.get_temp_dir()
     with context.graph_mode():
         logdir_tensor = constant_op.constant(logdir)
     with context.eager_mode():
         with self.assertRaisesRegex(
                 ValueError, 'Invalid graph Tensor argument.*logdir'):
             summary_ops.create_file_writer_v2(logdir_tensor)
     self.assertEmpty(gfile.Glob(os.path.join(logdir, '*')))
    def testWrite_recordIf_callable_fromFunction(self):
        logdir = self.get_temp_dir()
        with context.eager_mode():
            writer = summary_ops.create_file_writer_v2(logdir)
            step = variables.Variable(-1, dtype=dtypes.int64)

            @def_function.function
            def record_fn():
                step.assign_add(1)
                return math_ops.equal(step % 2, 0)

            @def_function.function
            def f():
                with writer.as_default():
                    with summary_ops.record_if(record_fn):
                        return [
                            summary_ops.write('tag', 1, step=step),
                            summary_ops.write('tag', 1, step=step),
                            summary_ops.write('tag', 1, step=step)
                        ]

            self.assertAllEqual(f(), [True, False, True])
            self.assertAllEqual(f(), [False, True, False])
        events = events_from_logdir(logdir)
        self.assertEqual(4, len(events))
        self.assertEqual(0, events[1].step)
        self.assertEqual(2, events[2].step)
        self.assertEqual(4, events[3].step)
示例#9
0
  def test_summaries_in_tf_function(self):
    if not context.executing_eagerly():
      return

    class MyLayer(keras.layers.Layer):

      def call(self, inputs):
        summary_ops_v2.scalar('mean', math_ops.reduce_mean(inputs))
        return inputs

    tmp_dir = self.get_temp_dir()
    writer = summary_ops_v2.create_file_writer_v2(tmp_dir)
    with writer.as_default(), summary_ops_v2.always_record_summaries():
      my_layer = MyLayer()
      x = array_ops.ones((10, 10))

      def my_fn(x):
        return my_layer(x)

      _ = my_fn(x)

    event_file = gfile.Glob(os.path.join(tmp_dir, 'events*'))
    self.assertLen(event_file, 1)
    event_file = event_file[0]
    tags = set()
    for e in summary_iterator.summary_iterator(event_file):
      for val in e.summary.value:
        tags.add(val.tag)
    self.assertEqual(set(['my_layer/mean']), tags)
    def testSummaryWithCustomTrainingLoop(self):
        resolver = tpu_cluster_resolver.TPUClusterResolver('')
        tpu_strategy_util.initialize_tpu_system(resolver)
        strategy = tpu_strategy_lib.TPUStrategy(resolver)

        with strategy.scope():
            model = distribute_strategy_test.get_model()
            model.compile('sgd', 'mse')
            writer = summary_ops_v2.create_file_writer_v2(self.summary_dir)

            @def_function.function
            def custom_function(dataset):
                def _custom_step(features, labels):
                    del labels
                    logits = model(features)
                    with summary_ops_v2.always_record_summaries(
                    ), writer.as_default():
                        summary_ops_v2.scalar('logits',
                                              logits,
                                              step=model.optimizer.iterations)
                    return logits

                iterator = iter(dataset)
                output = strategy.unwrap(
                    strategy.run(_custom_step, args=(next(iterator))))
                return output

            dataset = strategy.experimental_distribute_dataset(
                distribute_strategy_test.get_dataset(strategy))

            custom_function(dataset)
示例#11
0
 def testAllV2SummaryOps(self):
   logdir = self.get_temp_dir()
   def define_ops():
     result = []
     # TF 2.0 summary ops
     result.append(summary_ops.write('write', 1, step=0))
     result.append(summary_ops.write_raw_pb(b'', step=0, name='raw_pb'))
     # TF 1.x tf.contrib.summary ops
     result.append(summary_ops.generic('tensor', 1, step=1))
     result.append(summary_ops.scalar('scalar', 2.0, step=1))
     result.append(summary_ops.histogram('histogram', [1.0], step=1))
     result.append(summary_ops.image('image', [[[[1.0]]]], step=1))
     result.append(summary_ops.audio('audio', [[1.0]], 1.0, 1, step=1))
     return result
   with context.graph_mode():
     ops_without_writer = define_ops()
     with summary_ops.create_file_writer_v2(logdir).as_default():
       with summary_ops.record_if(True):
         ops_recording_on = define_ops()
       with summary_ops.record_if(False):
         ops_recording_off = define_ops()
     # We should be collecting all ops defined with a default writer present,
     # regardless of whether recording was set on or off, but not those defined
     # without a writer at all.
     del ops_without_writer
     expected_ops = ops_recording_on + ops_recording_off
     self.assertCountEqual(expected_ops, summary_ops.all_v2_summary_ops())
    def testSummaryWithCustomTrainingLoop(self):
        strategy = get_tpu_strategy()

        with strategy.scope():
            model = distribute_strategy_test.get_model()
            model.compile('sgd', 'mse')
            writer = summary_ops_v2.create_file_writer_v2(self.summary_dir)

            @def_function.function
            def custom_function(dataset):
                def _custom_step(features, labels):
                    del labels
                    logits = model(features)
                    with summary_ops_v2.always_record_summaries(
                    ), writer.as_default():
                        scalar_summary_v2.scalar(
                            'logits',
                            math_ops.reduce_sum(logits),
                            step=model.optimizer.iterations)
                    return logits

                iterator = iter(dataset)
                output = strategy.unwrap(
                    strategy.run(_custom_step, args=(next(iterator))))
                return output

            dataset = strategy.experimental_distribute_dataset(
                distribute_strategy_test.get_dataset(strategy))

            custom_function(dataset)
示例#13
0
    def test_spmd_with_summary(self):
        original_device_placement = config.get_soft_device_placement()
        config.set_soft_device_placement(True)

        strategy, _ = get_tpu_strategy(enable_spmd=True)
        summary_dir = self.get_temp_dir()
        writer = summary_ops.create_file_writer_v2(summary_dir)

        with strategy.scope():
            step = variables.Variable(0, dtype=dtypes.int64)

        @def_function.function
        def run():
            with writer.as_default():
                summary_ops.scalar("result", step * 2, step=step)
                step.assign_add(1)

        for _ in range(10):
            strategy.run(run, args=())

        for val in step.values:
            for var in val.variables:
                self.assertAllEqual(10, var)

        config.set_soft_device_placement(original_device_placement)
示例#14
0
 def testAllV2SummaryOps(self):
   logdir = self.get_temp_dir()
   def define_ops():
     result = []
     # TF 2.0 summary ops
     result.append(summary_ops.write('write', 1, step=0))
     result.append(summary_ops.write_raw_pb(b'', step=0, name='raw_pb'))
     # TF 1.x tf.contrib.summary ops
     result.append(summary_ops.generic('tensor', 1, step=1))
     result.append(summary_ops.scalar('scalar', 2.0, step=1))
     result.append(summary_ops.histogram('histogram', [1.0], step=1))
     result.append(summary_ops.image('image', [[[[1.0]]]], step=1))
     result.append(summary_ops.audio('audio', [[1.0]], 1.0, 1, step=1))
     return result
   with context.graph_mode():
     ops_without_writer = define_ops()
     with summary_ops.create_file_writer_v2(logdir).as_default():
       with summary_ops.record_if(True):
         ops_recording_on = define_ops()
       with summary_ops.record_if(False):
         ops_recording_off = define_ops()
     # We should be collecting all ops defined with a default writer present,
     # regardless of whether recording was set on or off, but not those defined
     # without a writer at all.
     del ops_without_writer
     expected_ops = ops_recording_on + ops_recording_off
     self.assertCountEqual(expected_ops, summary_ops.all_v2_summary_ops())
示例#15
0
 def testWrite_ndarray(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('tag', [[1, 2], [3, 4]], step=12)
   events = events_from_logdir(logdir)
   value = events[1].summary.value[0]
   self.assertAllEqual([[1, 2], [3, 4]], to_numpy(value))
示例#16
0
 def testWriteRawPb_invalidValue(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       with self.assertRaisesRegex(
           errors.DataLossError,
           'Bad tf.compat.v1.Summary binary proto tensor string'):
         summary_ops.write_raw_pb('notaproto', step=12)
示例#17
0
 def testWrite_stringTensor(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('tag', [b'foo', b'bar'], step=12)
   events = events_from_logdir(logdir)
   value = events[1].summary.value[0]
   self.assertAllEqual([b'foo', b'bar'], to_numpy(value))
示例#18
0
 def _lav_writer(self, idx):
     label = f"lav_l{idx}"
     if label not in self._writers:
         lav_dir = f"{self._lav_dir}_l{idx}"
         os.makedirs(lav_dir, exist_ok=True)
         self._writers[label] = summary_ops_v2.create_file_writer_v2(
             lav_dir)
     return self._writers[label]
示例#19
0
 def testWrite_ndarray(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         with summary_ops.create_file_writer_v2(logdir).as_default():
             summary_ops.write('tag', [[1, 2], [3, 4]], step=12)
     events = events_from_logdir(logdir)
     value = events[1].summary.value[0]
     self.assertAllEqual([[1, 2], [3, 4]], to_numpy(value))
示例#20
0
 def testWriteRawPb_invalidValue(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         with summary_ops.create_file_writer_v2(logdir).as_default():
             with self.assertRaisesRegex(
                     errors.DataLossError,
                     'Bad tf.compat.v1.Summary binary proto tensor string'):
                 summary_ops.write_raw_pb('notaproto', step=12)
示例#21
0
 def testWrite_stringTensor(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         with summary_ops.create_file_writer_v2(logdir).as_default():
             summary_ops.write('tag', [b'foo', b'bar'], step=12)
     events = events_from_logdir(logdir)
     value = events[1].summary.value[0]
     self.assertAllEqual([b'foo', b'bar'], to_numpy(value))
示例#22
0
 def keras_model(self, *args, **kwargs):
   logdir = self.get_temp_dir()
   writer = summary_ops.create_file_writer_v2(logdir)
   with writer.as_default():
     summary_ops.keras_model(*args, **kwargs)
   writer.close()
   events = events_from_logdir(logdir)
   # The first event contains no summary values. The written content goes to
   # the second event.
   return events[1]
示例#23
0
 def testWrite_tensor(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     t = constant_op.constant([[1, 2], [3, 4]])
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('tag', t, step=12)
     expected = t.numpy()
   events = events_from_logdir(logdir)
   value = events[1].summary.value[0]
   self.assertAllEqual(expected, to_numpy(value))
示例#24
0
 def testWrite_tensor(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         t = constant_op.constant([[1, 2], [3, 4]])
         with summary_ops.create_file_writer_v2(logdir).as_default():
             summary_ops.write('tag', t, step=12)
         expected = t.numpy()
     events = events_from_logdir(logdir)
     value = events[1].summary.value[0]
     self.assertAllEqual(expected, to_numpy(value))
示例#25
0
 def __init__(self,
              every_n_steps=1,
              every_n_secs=None,
              output_dir=None,
              summary_writer=None,
              batch_size=None):
     writer = summary_writer or summary_ops_v2.create_file_writer_v2(
         output_dir)
     super().__init__(every_n_steps, every_n_secs, output_dir, writer,
                      batch_size)
示例#26
0
 def _init_writer(self, model):
     """Sets file writer."""
     if context.executing_eagerly():
         self.writer = summary_ops_v2.create_file_writer_v2(self.log_dir)
         if not model.run_eagerly and self.write_graph:
             with self.writer.as_default():
                 summary_ops_v2.graph(K.get_graph())
     elif self.write_graph:
         self.writer = tf_summary.FileWriter(self.log_dir, K.get_graph())
     else:
         self.writer = tf_summary.FileWriter(self.log_dir)
示例#27
0
 def testWrite(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       output = summary_ops.write('tag', 42, step=12)
       self.assertTrue(output.numpy())
   events = events_from_logdir(logdir)
   self.assertEqual(2, len(events))
   self.assertEqual(12, events[1].step)
   value = events[1].summary.value[0]
   self.assertEqual('tag', value.tag)
   self.assertEqual(42, to_numpy(value))
示例#28
0
 def testWrite(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         with summary_ops.create_file_writer_v2(logdir).as_default():
             output = summary_ops.write('tag', 42, step=12)
             self.assertTrue(output.numpy())
     events = events_from_logdir(logdir)
     self.assertEqual(2, len(events))
     self.assertEqual(12, events[1].step)
     value = events[1].summary.value[0]
     self.assertEqual('tag', value.tag)
     self.assertEqual(42, to_numpy(value))
示例#29
0
 def testWriteRawPb(self):
   logdir = self.get_temp_dir()
   pb = summary_pb2.Summary()
   pb.value.add().simple_value = 42.0
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       output = summary_ops.write_raw_pb(pb.SerializeToString(), step=12)
       self.assertTrue(output.numpy())
   events = events_from_logdir(logdir)
   self.assertEqual(2, len(events))
   self.assertEqual(12, events[1].step)
   self.assertProtoEquals(pb, events[1].summary)
示例#30
0
 def testWriteRawPb(self):
   logdir = self.get_temp_dir()
   pb = summary_pb2.Summary()
   pb.value.add().simple_value = 42.0
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       output = summary_ops.write_raw_pb(pb.SerializeToString(), step=12)
       self.assertTrue(output.numpy())
   events = events_from_logdir(logdir)
   self.assertEqual(2, len(events))
   self.assertEqual(12, events[1].step)
   self.assertProtoEquals(pb, events[1].summary)
示例#31
0
    def __init__(self,
                 model,
                 data,
                 checkpoint_dir,
                 log_dir=None,
                 steps=None,
                 max_evaluations=None):
        """Initializes an `SidecarEvaluator` object.

    Args:
      model: Model to use for evaluation. The model object used here should be a
        `tf.keras.Model`, and should be the same as the one that is used in
        training, where `tf.keras.Model`s are checkpointed. The model should
        have one or more metrics compiled before using `SidecarEvaluator`.
      data: The input data for evaluation. `SidecarEvaluator` supports all data
        types that Keras `model.evaluate` supports as the input data `x`, such
        as a `tf.data.Dataset`.
      checkpoint_dir: Directory where checkpoint files are saved.
      log_dir: Directory where summary files for TensorBoard are saved.
      steps: Number of steps to perform evaluation for, when evaluating a single
        checkpoint file. If `None`, evaluation continues until the dataset is
        exhausted. For repeated evaluation dataset, user must specify `steps` to
        avoid infinite evaluation loop.
      max_evaluations: Maximum number of the checkpoint file to be evaluated,
        for `SidecarEvaluator` to know when to stop. The evaluator will stop
        after it evaluates a checkpoint filepath ending with
        '<ckpt_name>-<max_evaluations>'. If using
        `tf.train.CheckpointManager.save` for saving checkpoints, the kth saved
        checkpoint has the filepath suffix '<ckpt_name>-<k>' (k=1 for the first
        saved), and if checkpoints are saved every epoch after training, the
        filepath saved at the kth epoch would end with '<ckpt_name>-<k>. Thus,
        if training runs for n epochs, and the evaluator should end after the
        training finishes, use n for this parameter. Note that this is not
        necessarily equal to the number of total evaluations, since some
        checkpoints may be skipped if evaluation is slower than checkpoint
        creation. If `None`, `SidecarEvaluator` will evaluate indefinitely, and
        the user must terminate evaluator program themselves.
    """
        self.model = model
        self.data = data
        self.checkpoint_dir = checkpoint_dir
        if log_dir:
            self._summary_writer = summary_ops_v2.create_file_writer_v2(
                logdir=log_dir)
        else:
            self._summary_writer = None
        self._iterations = variables.Variable(
            name='iterations',
            initial_value=_ITERATIONS_UNINITIALIZED,
            dtype=dtypes.int64)
        self.max_evaluations = max_evaluations
        self.steps = steps
示例#32
0
 def testMaxQueue(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(
         logdir, max_queue=1, flush_millis=999999).as_default():
       get_total = lambda: len(events_from_logdir(logdir))
       # Note: First tf.Event is always file_version.
       self.assertEqual(1, get_total())
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       # Should flush after second summary since max_queue = 1
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(3, get_total())
示例#33
0
 def testWrite_recordIf_constant(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       self.assertTrue(summary_ops.write('default', 1, step=0))
       with summary_ops.record_if(True):
         self.assertTrue(summary_ops.write('set_on', 1, step=0))
       with summary_ops.record_if(False):
         self.assertFalse(summary_ops.write('set_off', 1, step=0))
   events = events_from_logdir(logdir)
   self.assertEqual(3, len(events))
   self.assertEqual('default', events[1].summary.value[0].tag)
   self.assertEqual('set_on', events[2].summary.value[0].tag)
示例#34
0
 def testMaxQueue(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         with summary_ops.create_file_writer_v2(
                 logdir, max_queue=1, flush_millis=999999).as_default():
             get_total = lambda: len(events_from_logdir(logdir))
             # Note: First tf.Event is always file_version.
             self.assertEqual(1, get_total())
             summary_ops.write('tag', 1, step=0)
             self.assertEqual(1, get_total())
             # Should flush after second summary since max_queue = 1
             summary_ops.write('tag', 1, step=0)
             self.assertEqual(3, get_total())
示例#35
0
 def testWrite_recordIf_constant(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         with summary_ops.create_file_writer_v2(logdir).as_default():
             self.assertTrue(summary_ops.write('default', 1, step=0))
             with summary_ops.record_if(True):
                 self.assertTrue(summary_ops.write('set_on', 1, step=0))
             with summary_ops.record_if(False):
                 self.assertFalse(summary_ops.write('set_off', 1, step=0))
     events = events_from_logdir(logdir)
     self.assertEqual(3, len(events))
     self.assertEqual('default', events[1].summary.value[0].tag)
     self.assertEqual('set_on', events[2].summary.value[0].tag)
示例#36
0
def make_callbacks(args, experiment=None, run=None):

    if run is None:
        run = args["run_dir"]

    writer = summary_ops_v2.create_file_writer_v2(run)

    def schedule(epoch):
        if epoch < args["warmup_length"]:
            return args["warmup_coeff"] * args["learning_rate"]
        else:
            return args["learning_rate"]

    cb = [
        tf_callbacks.ModelCheckpoint(str(Path(run, "model.hdf5")),
                                     verbose=0,
                                     save_freq='epoch'),
        tf_callbacks.ModelCheckpoint(
            str(Path(run, "best-model.hdf5")),
            verbose=0,
            save_freq='epoch',
            save_best_only=True,
            mode="max",
            monitor="val_balanced_accuracy",
        ),
        tf_callbacks.EarlyStopping(monitor="val_balanced_accuracy",
                                   patience=args["es_patience"],
                                   mode="max",
                                   min_delta=args["es_epsilon"]),
        my_callbacks.ReduceLROnPlateauWithWarmup(
            monitor="val_balanced_accuracy",
            min_delta=args["lrplat_epsilon"],
            factor=args["lrplat_factor"],
            patience=int(args["lrplat_patience"]),
            base_learning_rate=args["learning_rate"],
            warmup_length=args["warmup_length"],
            warmup_coeff=args["warmup_coeff"]),
        # tf_callbacks.LearningRateScheduler(schedule),
        tf_callbacks.CSVLogger(str(Path(run, 'scores.log'))),
        my_callbacks.ImageLogger(writer),
        tf_callbacks.TensorBoard(log_dir=run,
                                 write_graph=True,
                                 profile_batch=0,
                                 histogram_freq=1),
        my_callbacks.AdamLRLogger(writer)
    ]

    if experiment:
        cb.append(my_callbacks.CometLogger(experiment))

    return cb
示例#37
0
 def testClose_preventsLaterUse(self):
     logdir = self.get_temp_dir()
     with context.eager_mode():
         writer = summary_ops.create_file_writer_v2(logdir)
         writer.close()
         writer.close()  # redundant close() is a no-op
         writer.flush()  # redundant flush() is a no-op
         with self.assertRaisesRegex(RuntimeError, 'already closed'):
             writer.init()
         with self.assertRaisesRegex(RuntimeError, 'already closed'):
             with writer.as_default():
                 self.fail('should not get here')
         with self.assertRaisesRegex(RuntimeError, 'already closed'):
             writer.set_as_default()
示例#38
0
 def testClose_preventsLaterUse(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     writer.close()
     writer.close()  # redundant close() is a no-op
     writer.flush()  # redundant flush() is a no-op
     with self.assertRaisesRegex(RuntimeError, 'already closed'):
       writer.init()
     with self.assertRaisesRegex(RuntimeError, 'already closed'):
       with writer.as_default():
         self.fail('should not get here')
     with self.assertRaisesRegex(RuntimeError, 'already closed'):
       writer.set_as_default()
示例#39
0
 def testWrite_metadata(self):
   logdir = self.get_temp_dir()
   metadata = summary_pb2.SummaryMetadata()
   metadata.plugin_data.plugin_name = 'foo'
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('obj', 0, 0, metadata=metadata)
       summary_ops.write('bytes', 0, 0, metadata=metadata.SerializeToString())
       m = constant_op.constant(metadata.SerializeToString())
       summary_ops.write('string_tensor', 0, 0, metadata=m)
   events = events_from_logdir(logdir)
   self.assertEqual(4, len(events))
   self.assertEqual(metadata, events[1].summary.value[0].metadata)
   self.assertEqual(metadata, events[2].summary.value[0].metadata)
   self.assertEqual(metadata, events[3].summary.value[0].metadata)
示例#40
0
 def _get_writer(self, writer_name):
     """Get a summary writer for the given subdirectory under the logdir.
 A writer will be created if it does not yet exist.
 Arguments:
   writer_name: The name of the directory for which to create or
     retrieve a writer. Should be either `self._train_run_name` or
     `self._validation_run_name`.
 Returns:
   A `SummaryWriter` object.
 """
     if writer_name not in self._writers:
         path = os.path.join(self.log_dir, writer_name)
         writer = summary_ops_v2.create_file_writer_v2(path)
         self._writers[writer_name] = writer
     return self._writers[writer_name]
示例#41
0
 def testWrite_metadata(self):
   logdir = self.get_temp_dir()
   metadata = summary_pb2.SummaryMetadata()
   metadata.plugin_data.plugin_name = 'foo'
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('obj', 0, 0, metadata=metadata)
       summary_ops.write('bytes', 0, 0, metadata=metadata.SerializeToString())
       m = constant_op.constant(metadata.SerializeToString())
       summary_ops.write('string_tensor', 0, 0, metadata=m)
   events = events_from_logdir(logdir)
   self.assertEqual(4, len(events))
   self.assertEqual(metadata, events[1].summary.value[0].metadata)
   self.assertEqual(metadata, events[2].summary.value[0].metadata)
   self.assertEqual(metadata, events[3].summary.value[0].metadata)
示例#42
0
 def __init__(self):
   self._resource = ged_ops.stats_aggregator_handle_v2()
   # There could be a conflict with multiple file writer in the same logdir,
   # (b/37351340). Possible workarounds till this bug is resolved are a) having
   # multiple dataset stats specific file inside log_dir and b) get default
   # summary writer, getting default summary writer quite doesn't solve the
   # problem as there might be summary writers in log dir not set as default
   # e.g. in Keras calback.
   # Creating a summary_writer here could potentially be replaced with getting
   # the default summary_writer if any, creating it otherwise or a public
   # method to associate summary writer.
   self._logdir = tempfile.mkdtemp()
   self._summary_writer = summary_ops_v2.create_file_writer_v2(
       self._logdir, max_queue=_DEFAULT_MAX_QUEUE)
   ged_ops.stats_aggregator_set_summary_writer(self._resource,
                                               self._summary_writer._resource)  # pylint: disable=protected-access
示例#43
0
 def testCreate_withInitAndClose(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(
         logdir, max_queue=1000, flush_millis=1000000)
     get_total = lambda: len(events_from_logdir(logdir))
     self.assertEqual(1, get_total())  # file_version Event
     # Calling init() again while writer is open has no effect
     writer.init()
     self.assertEqual(1, get_total())
     with writer.as_default():
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       # Calling .close() should do an implicit flush
       writer.close()
       self.assertEqual(2, get_total())
示例#44
0
 def testWriterFlush(self):
   logdir = self.get_temp_dir()
   get_total = lambda: len(events_from_logdir(logdir))
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(
         logdir, max_queue=1000, flush_millis=1000000)
     self.assertEqual(1, get_total())  # file_version Event
     with writer.as_default():
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       writer.flush()
       self.assertEqual(2, get_total())
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(2, get_total())
     # Exiting the "as_default()" should do an implicit flush
     self.assertEqual(3, get_total())
示例#45
0
 def testWriterFlush(self):
   logdir = self.get_temp_dir()
   get_total = lambda: len(events_from_logdir(logdir))
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(
         logdir, max_queue=1000, flush_millis=1000000)
     self.assertEqual(1, get_total())  # file_version Event
     with writer.as_default():
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       writer.flush()
       self.assertEqual(2, get_total())
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(2, get_total())
     # Exiting the "as_default()" should do an implicit flush
     self.assertEqual(3, get_total())
示例#46
0
 def testCreate_withInitAndClose(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(
         logdir, max_queue=1000, flush_millis=1000000)
     get_total = lambda: len(events_from_logdir(logdir))
     self.assertEqual(1, get_total())  # file_version Event
     # Calling init() again while writer is open has no effect
     writer.init()
     self.assertEqual(1, get_total())
     with writer.as_default():
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       # Calling .close() should do an implicit flush
       writer.close()
       self.assertEqual(2, get_total())
示例#47
0
 def testDereference_closesOpenFile(self):
   try:
     import psutil  # pylint: disable=g-import-not-at-top
   except ImportError:
     raise unittest.SkipTest('test requires psutil')
   proc = psutil.Process()
   get_open_filenames = lambda: set(info[0] for info in proc.open_files())
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     files = gfile.Glob(os.path.join(logdir, '*'))
     self.assertEqual(1, len(files))
     eventfile = files[0]
     self.assertIn(eventfile, get_open_filenames())
     del writer
     self.assertNotIn(eventfile, get_open_filenames())
示例#48
0
 def testDereference_closesOpenFile(self):
     try:
         import psutil  # pylint: disable=g-import-not-at-top
     except ImportError:
         raise unittest.SkipTest('test requires psutil')
     proc = psutil.Process()
     get_open_filenames = lambda: set(info[0] for info in proc.open_files())
     logdir = self.get_temp_dir()
     with context.eager_mode():
         writer = summary_ops.create_file_writer_v2(logdir)
         files = gfile.Glob(os.path.join(logdir, '*'))
         self.assertEqual(1, len(files))
         eventfile = files[0]
         self.assertIn(eventfile, get_open_filenames())
         del writer
         self.assertNotIn(eventfile, get_open_filenames())
示例#49
0
 def testWrite_recordIf_constant_fromFunction(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     @def_function.function
     def f():
       with writer.as_default():
         # Use assertAllEqual instead of assertTrue since it works in a defun.
         self.assertAllEqual(summary_ops.write('default', 1, step=0), True)
         with summary_ops.record_if(True):
           self.assertAllEqual(summary_ops.write('set_on', 1, step=0), True)
         with summary_ops.record_if(False):
           self.assertAllEqual(summary_ops.write('set_off', 1, step=0), False)
     f()
   events = events_from_logdir(logdir)
   self.assertEqual(3, len(events))
   self.assertEqual('default', events[1].summary.value[0].tag)
   self.assertEqual('set_on', events[2].summary.value[0].tag)
示例#50
0
 def testWrite_recordIf_callable(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     step = variables.Variable(-1, dtype=dtypes.int64)
     def record_fn():
       step.assign_add(1)
       return int(step % 2) == 0
     with summary_ops.create_file_writer_v2(logdir).as_default():
       with summary_ops.record_if(record_fn):
         self.assertTrue(summary_ops.write('tag', 1, step=step))
         self.assertFalse(summary_ops.write('tag', 1, step=step))
         self.assertTrue(summary_ops.write('tag', 1, step=step))
         self.assertFalse(summary_ops.write('tag', 1, step=step))
         self.assertTrue(summary_ops.write('tag', 1, step=step))
   events = events_from_logdir(logdir)
   self.assertEqual(4, len(events))
   self.assertEqual(0, events[1].step)
   self.assertEqual(2, events[2].step)
   self.assertEqual(4, events[3].step)
示例#51
0
 def testWrite_recordIf_tensorInput_fromFunction(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     @def_function.function(input_signature=[
         tensor_spec.TensorSpec(shape=[], dtype=dtypes.int64)])
     def f(step):
       with writer.as_default():
         with summary_ops.record_if(math_ops.equal(step % 2, 0)):
           return summary_ops.write('tag', 1, step=step)
     self.assertTrue(f(0))
     self.assertFalse(f(1))
     self.assertTrue(f(2))
     self.assertFalse(f(3))
     self.assertTrue(f(4))
   events = events_from_logdir(logdir)
   self.assertEqual(4, len(events))
   self.assertEqual(0, events[1].step)
   self.assertEqual(2, events[2].step)
   self.assertEqual(4, events[3].step)
示例#52
0
 def testFlushFunction(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(
         logdir, max_queue=999999, flush_millis=999999)
     with writer.as_default():
       get_total = lambda: len(events_from_logdir(logdir))
       # Note: First tf.Event is always file_version.
       self.assertEqual(1, get_total())
       summary_ops.write('tag', 1, step=0)
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       summary_ops.flush()
       self.assertEqual(3, get_total())
       # Test "writer" parameter
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(3, get_total())
       summary_ops.flush(writer=writer)
       self.assertEqual(4, get_total())
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(4, get_total())
       summary_ops.flush(writer=writer._resource)  # pylint:disable=protected-access
       self.assertEqual(5, get_total())
示例#53
0
 def testWriteRawPb_multipleValues(self):
   logdir = self.get_temp_dir()
   pb1 = summary_pb2.Summary()
   pb1.value.add().simple_value = 1.0
   pb1.value.add().simple_value = 2.0
   pb2 = summary_pb2.Summary()
   pb2.value.add().simple_value = 3.0
   pb3 = summary_pb2.Summary()
   pb3.value.add().simple_value = 4.0
   pb3.value.add().simple_value = 5.0
   pb3.value.add().simple_value = 6.0
   pbs = [pb.SerializeToString() for pb in (pb1, pb2, pb3)]
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       output = summary_ops.write_raw_pb(pbs, step=12)
       self.assertTrue(output.numpy())
   events = events_from_logdir(logdir)
   self.assertEqual(2, len(events))
   self.assertEqual(12, events[1].step)
   expected_pb = summary_pb2.Summary()
   for i in range(6):
     expected_pb.value.add().simple_value = i + 1.0
   self.assertProtoEquals(expected_pb, events[1].summary)
示例#54
0
 def testWrite_recordIf_callable_fromFunction(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     step = variables.Variable(-1, dtype=dtypes.int64)
     @def_function.function
     def record_fn():
       step.assign_add(1)
       return math_ops.equal(step % 2, 0)
     @def_function.function
     def f():
       with writer.as_default():
         with summary_ops.record_if(record_fn):
           return [
               summary_ops.write('tag', 1, step=step),
               summary_ops.write('tag', 1, step=step),
               summary_ops.write('tag', 1, step=step)]
     self.assertAllEqual(f(), [True, False, True])
     self.assertAllEqual(f(), [False, True, False])
   events = events_from_logdir(logdir)
   self.assertEqual(4, len(events))
   self.assertEqual(0, events[1].step)
   self.assertEqual(2, events[2].step)
   self.assertEqual(4, events[3].step)
示例#55
0
 def testNoMemoryLeak_eagerMode(self):
   logdir = self.get_temp_dir()
   with summary_ops.create_file_writer_v2(logdir).as_default():
     summary_ops.write('tag', 1, step=0)
示例#56
0
 def f():
   summary_ops.create_file_writer_v2(constant_op.constant(logdir))
示例#57
0
 def f():
   with summary_ops.create_file_writer_v2(logdir).as_default():
     pass  # Calling .as_default() is enough to indicate use.
示例#58
0
 def testCreate_immediateAsDefault_retainsReference(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.flush()
示例#59
0
 def f2():
   if not hasattr(f2, 'writer'):
     f2.writer = summary_ops.create_file_writer_v2(logdir)
   with f2.writer.as_default():
     summary_ops.write('tag', 1, step=2)
示例#60
0
 def testNoMemoryLeak_graphMode(self):
   logdir = self.get_temp_dir()
   with context.graph_mode(), ops.Graph().as_default():
     summary_ops.create_file_writer_v2(logdir)