def testInspectAll(self):
        data = [
            {"tag": "c", "histo": 2, "step": 10},
            {"tag": "c", "histo": 2, "step": 11},
            {"tag": "c", "histo": 2, "step": 9},
            {"tag": "b", "simple_value": 2, "step": 20},
            {"tag": "b", "simple_value": 2, "step": 15},
            {"tag": "a", "simple_value": 2, "step": 3},
        ]
        self._WriteScalarSummaries(data)
        units = efi.get_inspection_units(self.logdir)
        printable = efi.get_dict_to_print(units[0].field_to_obs)
        self.assertEqual(printable["histograms"]["max_step"], 11)
        self.assertEqual(printable["histograms"]["min_step"], 9)
        self.assertEqual(printable["histograms"]["num_steps"], 3)
        self.assertEqual(printable["histograms"]["last_step"], 9)
        self.assertEqual(printable["histograms"]["first_step"], 10)
        self.assertEqual(printable["histograms"]["outoforder_steps"], [(11, 9)])

        self.assertEqual(printable["scalars"]["max_step"], 20)
        self.assertEqual(printable["scalars"]["min_step"], 3)
        self.assertEqual(printable["scalars"]["num_steps"], 3)
        self.assertEqual(printable["scalars"]["last_step"], 3)
        self.assertEqual(printable["scalars"]["first_step"], 20)
        self.assertEqual(printable["scalars"]["outoforder_steps"], [(20, 15), (15, 3)])
Пример #2
0
 def testGetAvailableTags(self):
     data = [{
         'tag': 'c',
         'histo': 2,
         'step': 10
     }, {
         'tag': 'c',
         'histo': 2,
         'step': 11
     }, {
         'tag': 'c',
         'histo': 2,
         'step': 9
     }, {
         'tag': 'b',
         'simple_value': 2,
         'step': 20
     }, {
         'tag': 'b',
         'simple_value': 2,
         'step': 15
     }, {
         'tag': 'a',
         'simple_value': 2,
         'step': 3
     }]
     self._WriteScalarSummaries(data)
     units = efi.get_inspection_units(self.logdir)
     tags = efi.get_unique_tags(units[0].field_to_obs)
     self.assertEqual(['a', 'b'], tags['scalars'])
     self.assertEqual(['c'], tags['histograms'])
    def testInspectAllWithNestedLogdirs(self):
        data = [
            {"tag": "c", "simple_value": 2, "step": 10},
            {"tag": "c", "simple_value": 2, "step": 11},
            {"tag": "c", "simple_value": 2, "step": 9},
            {"tag": "b", "simple_value": 2, "step": 20},
            {"tag": "b", "simple_value": 2, "step": 15},
            {"tag": "a", "simple_value": 2, "step": 3},
        ]

        subdirs = ["eval", "train"]
        self._WriteScalarSummaries(data, subdirs=subdirs)
        units = efi.get_inspection_units(self.logdir)
        self.assertEqual(2, len(units))
        directory_names = [os.path.join(self.logdir, name) for name in subdirs]
        self.assertEqual(directory_names, sorted([unit.name for unit in units]))

        for unit in units:
            printable = efi.get_dict_to_print(unit.field_to_obs)["scalars"]
            self.assertEqual(printable["max_step"], 20)
            self.assertEqual(printable["min_step"], 3)
            self.assertEqual(printable["num_steps"], 6)
            self.assertEqual(printable["last_step"], 3)
            self.assertEqual(printable["first_step"], 10)
            self.assertEqual(printable["outoforder_steps"], [(11, 9), (20, 15), (15, 3)])
 def testGetAvailableTags(self):
   data = [{'tag': 'c', 'histo': 2, 'step': 10},
           {'tag': 'c', 'histo': 2, 'step': 11},
           {'tag': 'c', 'histo': 2, 'step': 9},
           {'tag': 'b', 'simple_value': 2, 'step': 20},
           {'tag': 'b', 'simple_value': 2, 'step': 15},
           {'tag': 'a', 'simple_value': 2, 'step': 3}]
   self._WriteScalarSummaries(data)
   units = efi.get_inspection_units(self.logdir)
   tags = efi.get_unique_tags(units[0].field_to_obs)
   self.assertEqual(['a', 'b'], tags['scalars'])
   self.assertEqual(['c'], tags['histograms'])
 def testGetAvailableTags(self):
     data = [
         {"tag": "c", "histo": 2, "step": 10},
         {"tag": "c", "histo": 2, "step": 11},
         {"tag": "c", "histo": 2, "step": 9},
         {"tag": "b", "simple_value": 2, "step": 20},
         {"tag": "b", "simple_value": 2, "step": 15},
         {"tag": "a", "simple_value": 2, "step": 3},
     ]
     self._WriteScalarSummaries(data)
     units = efi.get_inspection_units(self.logdir)
     tags = efi.get_unique_tags(units[0].field_to_obs)
     self.assertEqual(["a", "b"], tags["scalars"])
     self.assertEqual(["c"], tags["histograms"])
 def testInspectTag(self):
   data = [{'tag': 'c', 'histo': 2, 'step': 10},
           {'tag': 'c', 'histo': 2, 'step': 11},
           {'tag': 'c', 'histo': 2, 'step': 9},
           {'tag': 'b', 'histo': 2, 'step': 20},
           {'tag': 'b', 'simple_value': 2, 'step': 15},
           {'tag': 'a', 'simple_value': 2, 'step': 3}]
   self._WriteScalarSummaries(data)
   units = efi.get_inspection_units(self.logdir, tag='c')
   printable = efi.get_dict_to_print(units[0].field_to_obs)
   self.assertEqual(printable['histograms']['max_step'], 11)
   self.assertEqual(printable['histograms']['min_step'], 9)
   self.assertEqual(printable['histograms']['num_steps'], 3)
   self.assertEqual(printable['histograms']['last_step'], 9)
   self.assertEqual(printable['histograms']['first_step'], 10)
   self.assertEqual(printable['histograms']['outoforder_steps'], [(11, 9)])
   self.assertEqual(printable['scalars'], None)
 def testInspectTag(self):
   data = [{'tag': 'c', 'histo': 2, 'step': 10},
           {'tag': 'c', 'histo': 2, 'step': 11},
           {'tag': 'c', 'histo': 2, 'step': 9},
           {'tag': 'b', 'histo': 2, 'step': 20},
           {'tag': 'b', 'simple_value': 2, 'step': 15},
           {'tag': 'a', 'simple_value': 2, 'step': 3}]
   self._WriteScalarSummaries(data)
   units = efi.get_inspection_units(self.logdir, tag='c')
   printable = efi.get_dict_to_print(units[0].field_to_obs)
   self.assertEqual(printable['histograms']['max_step'], 11)
   self.assertEqual(printable['histograms']['min_step'], 9)
   self.assertEqual(printable['histograms']['num_steps'], 3)
   self.assertEqual(printable['histograms']['last_step'], 9)
   self.assertEqual(printable['histograms']['first_step'], 10)
   self.assertEqual(printable['histograms']['outoforder_steps'], [(11, 9)])
   self.assertEqual(printable['scalars'], None)
    def testSessionLogSummaries(self):
        data = [
            {"session_log": SessionLog(status=SessionLog.START), "step": 0},
            {"session_log": SessionLog(status=SessionLog.CHECKPOINT), "step": 1},
            {"session_log": SessionLog(status=SessionLog.CHECKPOINT), "step": 2},
            {"session_log": SessionLog(status=SessionLog.CHECKPOINT), "step": 3},
            {"session_log": SessionLog(status=SessionLog.STOP), "step": 4},
            {"session_log": SessionLog(status=SessionLog.START), "step": 5},
            {"session_log": SessionLog(status=SessionLog.STOP), "step": 6},
        ]

        self._WriteScalarSummaries(data)
        units = efi.get_inspection_units(self.logdir)
        self.assertEqual(1, len(units))
        printable = efi.get_dict_to_print(units[0].field_to_obs)
        self.assertEqual(printable["sessionlog:start"]["steps"], [0, 5])
        self.assertEqual(printable["sessionlog:stop"]["steps"], [4, 6])
        self.assertEqual(printable["sessionlog:checkpoint"]["num_steps"], 3)
  def testSessionLogSummaries(self):
    data = [
        {'session_log': SessionLog(status=SessionLog.START), 'step': 0},
        {'session_log': SessionLog(status=SessionLog.CHECKPOINT), 'step': 1},
        {'session_log': SessionLog(status=SessionLog.CHECKPOINT), 'step': 2},
        {'session_log': SessionLog(status=SessionLog.CHECKPOINT), 'step': 3},
        {'session_log': SessionLog(status=SessionLog.STOP), 'step': 4},
        {'session_log': SessionLog(status=SessionLog.START), 'step': 5},
        {'session_log': SessionLog(status=SessionLog.STOP), 'step': 6},
    ]

    self._WriteScalarSummaries(data)
    units = efi.get_inspection_units(self.logdir)
    self.assertEqual(1, len(units))
    printable = efi.get_dict_to_print(units[0].field_to_obs)
    self.assertEqual(printable['sessionlog:start']['steps'], [0, 5])
    self.assertEqual(printable['sessionlog:stop']['steps'], [4, 6])
    self.assertEqual(printable['sessionlog:checkpoint']['num_steps'], 3)
Пример #10
0
  def testSessionLogSummaries(self):
    data = [
        {'session_log': SessionLog(status=SessionLog.START), 'step': 0},
        {'session_log': SessionLog(status=SessionLog.CHECKPOINT), 'step': 1},
        {'session_log': SessionLog(status=SessionLog.CHECKPOINT), 'step': 2},
        {'session_log': SessionLog(status=SessionLog.CHECKPOINT), 'step': 3},
        {'session_log': SessionLog(status=SessionLog.STOP), 'step': 4},
        {'session_log': SessionLog(status=SessionLog.START), 'step': 5},
        {'session_log': SessionLog(status=SessionLog.STOP), 'step': 6},
    ]

    self._WriteScalarSummaries(data)
    units = efi.get_inspection_units(self.logdir)
    self.assertEqual(1, len(units))
    printable = efi.get_dict_to_print(units[0].field_to_obs)
    self.assertEqual(printable['sessionlog:start']['steps'], [0, 5])
    self.assertEqual(printable['sessionlog:stop']['steps'], [4, 6])
    self.assertEqual(printable['sessionlog:checkpoint']['num_steps'], 3)
Пример #11
0
    def testInspectAllWithNestedLogdirs(self):
        data = [{
            'tag': 'c',
            'simple_value': 2,
            'step': 10
        }, {
            'tag': 'c',
            'simple_value': 2,
            'step': 11
        }, {
            'tag': 'c',
            'simple_value': 2,
            'step': 9
        }, {
            'tag': 'b',
            'simple_value': 2,
            'step': 20
        }, {
            'tag': 'b',
            'simple_value': 2,
            'step': 15
        }, {
            'tag': 'a',
            'simple_value': 2,
            'step': 3
        }]

        subdirs = ['eval', 'train']
        self._WriteScalarSummaries(data, subdirs=subdirs)
        units = efi.get_inspection_units(self.logdir)
        self.assertEqual(2, len(units))
        directory_names = [os.path.join(self.logdir, name) for name in subdirs]
        self.assertEqual(directory_names,
                         sorted([unit.name for unit in units]))

        for unit in units:
            printable = efi.get_dict_to_print(unit.field_to_obs)['scalars']
            self.assertEqual(printable['max_step'], 20)
            self.assertEqual(printable['min_step'], 3)
            self.assertEqual(printable['num_steps'], 6)
            self.assertEqual(printable['last_step'], 3)
            self.assertEqual(printable['first_step'], 10)
            self.assertEqual(printable['outoforder_steps'], [(11, 9), (20, 15),
                                                             (15, 3)])
Пример #12
0
  def testInspectAllWithNestedLogdirs(self):
    data = [{'tag': 'c', 'simple_value': 2, 'step': 10},
            {'tag': 'c', 'simple_value': 2, 'step': 11},
            {'tag': 'c', 'simple_value': 2, 'step': 9},
            {'tag': 'b', 'simple_value': 2, 'step': 20},
            {'tag': 'b', 'simple_value': 2, 'step': 15},
            {'tag': 'a', 'simple_value': 2, 'step': 3}]

    subdirs = ['eval', 'train']
    self._WriteScalarSummaries(data, subdirs=subdirs)
    units = efi.get_inspection_units(self.logdir)
    self.assertEqual(2, len(units))
    directory_names = [os.path.join(self.logdir, name) for name in subdirs]
    self.assertEqual(directory_names, sorted([unit.name for unit in units]))

    for unit in units:
      printable = efi.get_dict_to_print(unit.field_to_obs)['scalars']
      self.assertEqual(printable['max_step'], 20)
      self.assertEqual(printable['min_step'], 3)
      self.assertEqual(printable['num_steps'], 6)
      self.assertEqual(printable['last_step'], 3)
      self.assertEqual(printable['first_step'], 10)
      self.assertEqual(printable['outoforder_steps'], [(11, 9), (20, 15),
                                                       (15, 3)])
 def testEmptyLogdir(self):
     # Nothing was wrriten to logdir
     units = efi.get_inspection_units(self.logdir)
     self.assertEqual([], units)
Пример #14
0
 def testEmptyLogdir(self):
     # Nothing was wrriten to logdir
     units = efi.get_inspection_units(self.logdir)
     self.assertEqual([], units)