Simplify tabular API

Add test for accepted types and keys

Finish API and update examples

Add keys_accepted to constructor and update docs

Update docs

Author: pelillian

README.md

@@ -16,7 +16,7 @@ pip install dowel
 ## Usage
 ```python
 import dowel
-from dowel import logger, tabular
+from dowel import logger
 
 logger.add_output(dowel.StdOutput())
 logger.add_output(dowel.TensorBoardOutput('tensorboard_logdir'))
@@ -26,9 +26,8 @@ for i in range(1000):
     logger.push_prefix('itr {}'.format(i))
     logger.log('Running training step')
 
-    tabular.record('itr', i)
-    tabular.record('loss', 100.0 / (2 + i))
-    logger.log(tabular)
+    logger.logkv('itr', i)
+    logger.logkv('loss', 100.0 / (2 + i))
 
     logger.pop_prefix()
     logger.dump_all()

examples/log_progress.py

@@ -8,7 +8,7 @@
 import time
 
 import dowel
-from dowel import logger, tabular
+from dowel import logger
 
 logger.add_output(dowel.StdOutput())
 logger.add_output(dowel.CsvOutput('progress.csv'))
@@ -22,9 +22,8 @@
 
     time.sleep(0.01)  # Tensorboard doesn't like output to be too fast.
 
-    tabular.record('itr', i)
-    tabular.record('loss', 100.0 / (2 + i))
-    logger.log(tabular)
+    logger.logkv('itr', i)
+    logger.logkv('loss', 100.0 / (2 + i))
 
     logger.pop_prefix()
     logger.dump_all()

src/dowel/__init__.py

@@ -10,7 +10,6 @@
 from dowel.tensor_board_output import TensorBoardOutput
 
 logger = Logger()
-tabular = TabularInput()
 
 __all__ = [
     'Histogram',
@@ -23,5 +22,4 @@
     'TabularInput',
     'TensorBoardOutput',
     'logger',
-    'tabular',
 ]

src/dowel/csv_output.py

@@ -2,59 +2,66 @@
 import csv
 import warnings
 
-from dowel import TabularInput
+import numpy as np
+
 from dowel.simple_outputs import FileOutput
+from dowel.tabular_input import TabularInput
 from dowel.utils import colorize
 
 
 class CsvOutput(FileOutput):
     """CSV file output for logger.
 
     :param file_name: The file this output should log to.
+    :param keys_accepted: Regex for which keys this output should accept.
     """
 
-    def __init__(self, file_name):
-        super().__init__(file_name)
+    def __init__(self, file_name, keys_accepted=r'^'):
+        super().__init__(file_name, keys_accepted=keys_accepted)
         self._writer = None
         self._fieldnames = None
         self._warned_once = set()
         self._disable_warnings = False
+        self.tabular = TabularInput()
 
     @property
     def types_accepted(self):
-        """Accept TabularInput objects only."""
-        return (TabularInput, )
-
-    def record(self, data, prefix=''):
-        """Log tabular data to CSV."""
-        if isinstance(data, TabularInput):
-            to_csv = data.as_primitive_dict
-
-            if not to_csv.keys() and not self._writer:
-                return
-
-            if not self._writer:
-                self._fieldnames = set(to_csv.keys())
-                self._writer = csv.DictWriter(
-                    self._log_file,
-                    fieldnames=self._fieldnames,
-                    extrasaction='ignore')
-                self._writer.writeheader()
-
-            if to_csv.keys() != self._fieldnames:
-                self._warn('Inconsistent TabularInput keys detected. '
-                           'CsvOutput keys: {}. '
-                           'TabularInput keys: {}. '
-                           'Did you change key sets after your first '
-                           'logger.log(TabularInput)?'.format(
-                               set(self._fieldnames), set(to_csv.keys())))
-
-            self._writer.writerow(to_csv)
-
-            for k in to_csv.keys():
-                data.mark(k)
-        else:
-            raise ValueError('Unacceptable type.')
+        """Accept str and scalar objects."""
+        return (str, ) + np.ScalarType
+
+    def record(self, key, value, prefix=''):
+        """Log data to a csv file."""
+        self.tabular.record(key, value)
+
+    def dump(self, step=None):
+        """Flush data to log file."""
+        if self.tabular.empty:
+            return
+
+        to_csv = self.tabular.as_primitive_dict
+
+        if not to_csv.keys() and not self._writer:
+            return
+
+        if not self._writer:
+            self._fieldnames = set(to_csv.keys())
+            self._writer = csv.DictWriter(self._log_file,
+                                          fieldnames=self._fieldnames,
+                                          extrasaction='ignore')
+            self._writer.writeheader()
+
+        if to_csv.keys() != self._fieldnames:
+            self._warn('Inconsistent TabularInput keys detected. '
+                       'CsvOutput keys: {}. '
+                       'TabularInput keys: {}. '
+                       'Did you change key sets after your first '
+                       'logger.log(TabularInput)?'.format(
+                           set(self._fieldnames), set(to_csv.keys())))
+
+        self._writer.writerow(to_csv)
+
+        self._log_file.flush()
+        self.tabular.clear()
 
     def _warn(self, msg):
         """Warns the user using warnings.warn.
@@ -63,8 +70,9 @@ def _warn(self, msg):
         is the one printed.
         """
         if not self._disable_warnings and msg not in self._warned_once:
-            warnings.warn(
-                colorize(msg, 'yellow'), CsvOutputWarning, stacklevel=3)
+            warnings.warn(colorize(msg, 'yellow'),
+                          CsvOutputWarning,
+                          stacklevel=3)
         self._warned_once.add(msg)
         return msg
 

src/dowel/logger.py

@@ -133,29 +133,37 @@
 """
 import abc
 import contextlib
+import re
 import warnings
 
 from dowel.utils import colorize
 
 
 class LogOutput(abc.ABC):
-    """Abstract class for Logger Outputs."""
+    """Abstract class for Logger Outputs.
 
-    @property
-    def types_accepted(self):
-        """Pass these types to this logger output.
+    :param keys_accepted: Regex for which keys this output should accept.
+    """
 
-        The types in this tuple will be accepted by this output.
+    def __init__(self, keys_accepted=r'^$'):
+        self._keys_accepted = keys_accepted
 
-        :return: A tuple containing all valid input types.
-        """
+    @property
+    def types_accepted(self):
+        """Returns a tuple containing all valid input value types."""
         return ()
 
+    @property
+    def keys_accepted(self):
+        """Returns a regex string matching keys to be sent to this output."""
+        return self._keys_accepted
+
     @abc.abstractmethod
-    def record(self, data, prefix=''):
+    def record(self, key, value, prefix=''):
         """Pass logger data to this output.
 
-        :param data: The data to be logged by the output.
+        :param key: The key to be logged by the output.
+        :param value: The value to be logged by the output.
         :param prefix: A prefix placed before a log entry in text outputs.
         """
         pass
@@ -186,7 +194,7 @@ def __init__(self):
         self._warned_once = set()
         self._disable_warnings = False
 
-    def log(self, data):
+    def logkv(self, key, value):
         """Magic method that takes in all different types of input.
 
         This method is the main API for the logger. Any data to be logged goes
@@ -195,24 +203,30 @@ def log(self, data):
         Any data sent to this method is sent to all outputs that accept its
         type (defined in the types_accepted property).
 
-        :param data: Data to be logged. This can be any type specified in the
+        :param key: Key to be logged. This must be a string.
+        :param value: Value to be logged. This can be any type specified in the
          types_accepted property of any of the logger outputs.
         """
         if not self._outputs:
             self._warn('No outputs have been added to the logger.')
 
         at_least_one_logged = False
         for output in self._outputs:
-            if isinstance(data, output.types_accepted):
-                output.record(data, prefix=self._prefix_str)
+            if isinstance(value, output.types_accepted) and re.match(
+                    output.keys_accepted, key):
+                output.record(key, value, prefix=self._prefix_str)
                 at_least_one_logged = True
 
         if not at_least_one_logged:
             warning = (
                 'Log data of type {} was not accepted by any output'.format(
-                    type(data).__name__))
+                    type(value).__name__))
             self._warn(warning)
 
+    def log(self, value):
+        """Log just a value without a key."""
+        self.logkv('', value)
+
     def add_output(self, output):
         """Add a new output to the logger.
 

src/dowel/simple_outputs.py

@@ -8,6 +8,7 @@
 import sys
 
 import dateutil.tz
+import numpy as np
 
 from dowel import LogOutput
 from dowel.tabular_input import TabularInput
@@ -17,46 +18,53 @@
 class StdOutput(LogOutput):
     """Standard console output for the logger.
 
+    :param keys_accepted: Regex for which keys this output should accept.
     :param with_timestamp: Whether to log a timestamp before non-tabular data.
     """
 
-    def __init__(self, with_timestamp=True):
+    def __init__(self, keys_accepted=r'^', with_timestamp=True):
+        super().__init__(keys_accepted=keys_accepted)
         self._with_timestamp = with_timestamp
+        self.tabular = TabularInput()
 
     @property
     def types_accepted(self):
-        """Accept str and TabularInput objects."""
-        return (str, TabularInput)
+        """Accept str and scalar objects."""
+        return (str, ) + np.ScalarType
 
-    def record(self, data, prefix=''):
+    def record(self, key, value, prefix=''):
         """Log data to console."""
-        if isinstance(data, str):
-            out = prefix + data
-            if self._with_timestamp:
-                now = datetime.datetime.now(dateutil.tz.tzlocal())
-                timestamp = now.strftime('%Y-%m-%d %H:%M:%S')
-                out = '%s | %s' % (timestamp, out)
-        elif isinstance(data, TabularInput):
-            out = str(data)
-            data.mark_str()
+        if not key:
+            if isinstance(value, str):
+                out = prefix + value
+                if self._with_timestamp:
+                    now = datetime.datetime.now(dateutil.tz.tzlocal())
+                    timestamp = now.strftime('%Y-%m-%d %H:%M:%S')
+                    out = '%s | %s' % (timestamp, out)
+                print(out)
+            else:
+                raise ValueError('Unacceptable type')
         else:
-            raise ValueError('Unacceptable type')
-
-        print(out)
+            self.tabular.record(key, value)
 
     def dump(self, step=None):
         """Flush data to standard output stream."""
+        if not self.tabular.empty:
+            print(str(self.tabular))
+            self.tabular.clear()
         sys.stdout.flush()
 
 
 class FileOutput(LogOutput, metaclass=abc.ABCMeta):
     """File output abstract class for logger.
 
     :param file_name: The file this output should log to.
+    :param keys_accepted: Regex for which keys this output should accept.
     :param mode: File open mode ('a', 'w', etc).
     """
 
-    def __init__(self, file_name, mode='w'):
+    def __init__(self, file_name, keys_accepted=r'^', mode='w'):
+        super().__init__(keys_accepted=keys_accepted)
         mkdir_p(os.path.dirname(file_name))
         # Open the log file in child class
         self._log_file = open(file_name, mode)
@@ -75,31 +83,38 @@ class TextOutput(FileOutput):
     """Text file output for logger.
 
     :param file_name: The file this output should log to.
+    :param keys_accepted: Regex for which keys this output should accept.
     :param with_timestamp: Whether to log a timestamp before the data.
     """
 
-    def __init__(self, file_name, with_timestamp=True):
-        super().__init__(file_name, 'a')
+    def __init__(self, file_name, keys_accepted=r'^', with_timestamp=True):
+        super().__init__(file_name, keys_accepted=keys_accepted, mode='a')
         self._with_timestamp = with_timestamp
-        self._delimiter = ' | '
+        self.tabular = TabularInput()
 
     @property
     def types_accepted(self):
-        """Accept str objects only."""
-        return (str, TabularInput)
+        """Accept str and scalar objects."""
+        return (str, ) + np.ScalarType
 
-    def record(self, data, prefix=''):
+    def record(self, key, value, prefix=''):
         """Log data to text file."""
-        if isinstance(data, str):
-            out = prefix + data
-            if self._with_timestamp:
-                now = datetime.datetime.now(dateutil.tz.tzlocal())
-                timestamp = now.strftime('%Y-%m-%d %H:%M:%S')
-                out = '%s | %s' % (timestamp, out)
-        elif isinstance(data, TabularInput):
-            out = str(data)
-            data.mark_str()
+        if not key:
+            if isinstance(value, str):
+                out = prefix + value
+                if self._with_timestamp:
+                    now = datetime.datetime.now(dateutil.tz.tzlocal())
+                    timestamp = now.strftime('%Y-%m-%d %H:%M:%S')
+                    out = '%s | %s' % (timestamp, out)
+                self._log_file.write(out + '\n')
+            else:
+                raise ValueError('Unacceptable type')
         else:
-            raise ValueError('Unacceptable type.')
+            self.tabular.record(key, value)
 
-        self._log_file.write(out + '\n')
+    def dump(self, step=None):
+        """Flush data to log file."""
+        if not self.tabular.empty:
+            self._log_file.write(str(self.tabular) + '\n')
+            self.tabular.clear()
+        self._log_file.flush()