Fix: Minor typo, docstring, and format across the project; compatibility bug related to jpeg compression and RGBA image.

Author: BrandoZhang

CONTRIBUTING.md

@@ -82,4 +82,4 @@ This repository is organized as follows:
 └── unit_tests.py               # Main entry for unit tests, regarding `./models/` and `./utils/`.
 ```
 
-To develop a new project (or a new approach), a `runner` (which defines the training procedure, e.g., the data forwarding flow, the optimizing order of various loss terms, how the model(s) should be updated, etc.), a `loss` (which defines the computation of each loss term), and a `config` (which collects all configurations used in the project) are necessary. You may also need to design your own `dataset` (including data `transformation`), `model` structure, evaluation `metric`, `augmentation` pipeline, and running `controller` if they are not supported yet. **NOTE:** All these modules are almost independent of each other. Hence, once a new feature (e.g., `dataset`, `model`, `metric`, `augmentation`, or `controller`) is developed, it can be shared to others with minor effort. It you are interested in sharing your work, we really appreciate your contribution to these modules.
+To develop a new project (or a new approach), a `runner` (which defines the training procedure, e.g., the data forwarding flow, the optimizing order of various loss terms, how the model(s) should be updated, etc.), a `loss` (which defines the computation of each loss term), and a `config` (which collects all configurations used in the project) are necessary. You may also need to design your own `dataset` (including data `transformation`), `model` structure, evaluation `metric`, `augmentation` pipeline, and running `controller` if they are not supported yet. **NOTE:** All these modules are almost independent from each other. Hence, once a new feature (e.g., `dataset`, `model`, `metric`, `augmentation`, or `controller`) is developed, it can be shared to others with minor effort. It you are interested in sharing your work, we really appreciate your contribution to these modules.

README.md

@@ -68,12 +68,12 @@ Please find more training demos under `./scripts/training_demos/`.
 
 ## Inspect Training Results
 
-Besides using TensorBoard to track the training process, the raw results (e.g., training losses and running time) are saved in JSON format. They can be easily inspected with the following script
+Besides using TensorBoard to track the training process, the raw results (e.g., training losses and running time) are saved in [JSON Lines](https://jsonlines.org/) format. They can be easily inspected with the following script
 
 ```python
 import json
 
-file_name = '<PATH_TO_WORK_DIR>/log.json'
+file_name = '<PATH_TO_WORK_DIR>/log.jsonl'
 
 data_entries = []
 with open(file_name, 'r') as f:

configs/base_config.py

@@ -17,7 +17,7 @@
     ├── ${PROFILE_DIR}/
     ├── ${RESOURCE_DIR}/
     ├── ${CONFIG_FILENAME}  # in JSON format
-    ├── ${LOG_DATA_FILENAME}  # in JSON format
+    ├── ${LOG_DATA_FILENAME}  # in JSON Lines format
     └── ${LOG_FILENAME}  # in plain text
 """
 
@@ -36,6 +36,15 @@
 
 __all__ = ['BaseConfig']
 
+_PARAM_TYPE_TO_VALUE_TYPE = {
+    'IntegerParamType': 'int',
+    'FloatParamType': 'float',
+    'BooleanParamType': 'bool',
+    'StringParamType': 'str',
+    'IndexParamType': 'index-string',
+    'JsonParamType': 'json-string'
+}
+
 
 class BaseConfig(object):
     """Defines the base configuration class.
@@ -75,27 +84,37 @@ class BaseConfig(object):
     The base class provides the following functions to parse configuration from
     command line:
 
+    - Functions requiring implementation in derived class:
+
     (1) get_options(): Declare all options required by a particular task. The
         base class has already pre-declared some options that will be shared
         across tasks (e.g., data-related options). To declare more options,
         the derived class should override this function by first calling
-        `options = super().get_options()`. (requires implementation)
+        `options = super().get_options()`.
+    (2) parse_options(): Parse the options obtained from the command line (as
+        well as those options with default values) to `self.config`. This is the
+        core function of the configuration class, which converts `options` to
+        `configurations`.
+    (3) get_recommended_options(): Get a list of options that are recommended
+        for a particular task. The base class has already pre-declared some
+        recommended options that will be shared across tasks. To recommend more
+        options, the derived class should override this function by first
+        calling `recommended_opts = super().get_recommended_options()`.
+
+    - Helper functions shared by all derived classes:
+
+    (1) inspect_option(): Inspect argument from a particular `click.option`,
+        including the argument name, argument type, default value, and help
+        message.
     (2) add_options_to_command(): Add all options for a particular task to the
         corresponding command. This function is specially designed to show
-        user-friendly help message. (no need to care about by derived class)
+        user-friendly help message.
     (3) get_command(): Return a `click.command` to get interactive with users.
         This function makes it possible to pass options through command line.
-        (no need to care about by derived class)
-    (4) parse_options(): Parse the options obtained from the command line (as
-        well as those options with default values) to `self.config`. This is the
-        core function of the configuration class, which converts `options` to
-        `configurations`. (requires implementation)
-    (5) update_config(): Update the configuration parsed from options with
+    (4) update_config(): Update the configuration parsed from options with
         key-value pairs. This function makes option parsing more flexible.
-        (no need to care about by derived class)
-    (6) get_config(): The main function to get the parsed configuration, which
-        wraps functions `parse_options()` and `tune_config()`. (no need to care
-        about by derived class)
+    (5) get_config(): The main function to get the parsed configuration, which
+        wraps functions `parse_options()` and `update_config()`.
 
     In summary, to define a configuration class for a new task, the derived
     class only need to implement `get_options()` to declare changeable settings
@@ -114,6 +133,30 @@ class only need to implement `get_options()` to declare changeable settings
     json_type = JsonParamType()
     command_option = cloup.option
 
+    @staticmethod
+    def inspect_option(option):
+        """Inspects argument from a particular option.
+
+        Args:
+            option: The input `click.option` to inspect.
+
+        Returns:
+            An `EasyDict` indicating the `name`, `type`, `default` (default
+                value), and `help` (help message) of the argument.
+        """
+
+        @option
+        def func():
+            """A dummy function used to parse decorator."""
+
+        arg = func.__click_params__[0]
+        return EasyDict(
+            name=arg.name,
+            type=_PARAM_TYPE_TO_VALUE_TYPE[arg.type.__class__.__name__],
+            default=arg.default,
+            help=arg.help
+        )
+
     @staticmethod
     def add_options_to_command(options):
         """Adds task options to a command.
@@ -190,7 +233,7 @@ def get_options(cls):
                 '--config_path', type=str, default='config.json',
                 help='To which to save full configuration.'),
             cls.command_option(
-                '--log_data_path', type=str, default='log.json',
+                '--log_data_path', type=str, default='log.jsonl',
                 help='To which to save raw log data, e.g. losses.'),
             cls.command_option(
                 '--log_path', type=str, default='log.txt',

datasets/transformations/jpeg_compress.py

@@ -11,7 +11,6 @@
     fn = None
 
 from utils.formatting_utils import format_range
-from utils.formatting_utils import format_image
 from .base_transformation import BaseTransformation
 
 __all__ = ['JpegCompress']
@@ -51,8 +50,9 @@ def _CPU_forward(self, data):
         outputs = []
         for image in data:
             _, encoded_image = cv2.imencode('.jpg', image, encode_param)
-            decoded_image = format_image(
-                cv2.imdecode(encoded_image, cv2.IMREAD_UNCHANGED))
+            decoded_image = cv2.imdecode(encoded_image, cv2.IMREAD_UNCHANGED)
+            if decoded_image.ndim == 2:
+                decoded_image = decoded_image[:, :, np.newaxis]
             outputs.append(decoded_image)
         return outputs
 

dump_command_args.py

@@ -14,15 +14,15 @@
                 "type": "object",
                 "properties": {
                     "arg_1": {
+                        "is_recommended":  # true / false
                         "type":  # int / float / bool / str / json-string /
                                  # index-string
-                        "is_recommended":  # true / false
                         "default":
                         "description":
                     },
                     "arg_2": {
-                        "type":
                         "is_recommended":
+                        "type":
                         "default":
                         "description":
                     }
@@ -32,14 +32,14 @@
                 "type": "object",
                 "properties": {
                     "arg_3": {
-                        "type":
                         "is_recommended":
+                        "type":
                         "default":
                         "description":
                     },
                     "arg_4": {
-                        "type":
                         "is_recommended":
+                        "type":
                         "default":
                         "description":
                     }
@@ -54,8 +54,8 @@
                 "type": "object",
                 "properties": {
                     "arg_1": {
-                        "type":
                         "is_recommended":
+                        "type":
                         "default":
                         "description":
                     }
@@ -71,15 +71,6 @@
 
 from configs import CONFIG_POOL
 
-PARAM_TYPE_TO_VALUE_TYPE = {
-    'IntegerParamType': 'int',
-    'FloatParamType': 'float',
-    'BooleanParamType': 'bool',
-    'StringParamType': 'str',
-    'IndexParamType': 'index-string',
-    'JsonParamType': 'json-string'
-}
-
 
 def parse_args_from_config(config):
     """Parses available arguments from a configuration class.
@@ -89,21 +80,21 @@ def parse_args_from_config(config):
             defined in `configs/`. This class is supposed to derive from
             `BaseConfig` defined in `configs/base_config.py`.
     """
-    def _dummy_func():
-        """A dummy function used to parse decorator."""
-
-    args = dict()
-    func = config.add_options_to_command(config.get_options())(_dummy_func)
     recommended_opts = config.get_recommended_options()
-    for opt in reversed(func.__click_params__):
-        if opt.group.title not in args:
-            args[opt.group.title] = dict(type='object', properties=dict())
-        args[opt.group.title]['properties'][opt.name] = dict(
-            type=PARAM_TYPE_TO_VALUE_TYPE[opt.type.__class__.__name__],
-            default=opt.default,
-            is_recommended=opt.name in recommended_opts,
-            description=opt.help
+    args = dict()
+    for opt_group, opts in config.get_options().items():
+        args[opt_group] = dict(
+            type='object',
+            properties=dict()
         )
+        for opt in opts:
+            arg = config.inspect_option(opt)
+            args[opt_group]['properties'][arg.name] = dict(
+                is_recommended=arg.name in recommended_opts,
+                type=arg.type,
+                default=arg.default,
+                description=arg.help
+            )
     return args
 
 

metrics/utils.py

@@ -216,8 +216,9 @@ def compute_gan_precision_recall(fake_features,
                                  top_k=3):
     """Computes precision and recall for GAN evaluation.
 
-    KID metric is introduced in https://arxiv.org/pdf/1904.06991.pdf, with
-    official code
+    GAN precision and recall are introduced in
+
+    https://arxiv.org/pdf/1904.06991.pdf, with official code
 
     https://github.com/kynkaat/improved-precision-and-recall-metric.
 

models/stylegan2_generator.py

@@ -301,12 +301,12 @@ def forward(self,
         For layers in range [0, truncation_layers), the truncated w-code is
         computed as
 
-        w_new = w_avg + (w - w_avg) * truncation_psi
+        w_new = w_avg + (w - w_avg) * trunc_psi
 
         To disable truncation, please set
 
-        (1) truncation_psi = 1.0 (None) OR
-        (2) truncation_layers = 0 (None)
+        (1) trunc_psi = 1.0 (None) OR
+        (2) trunc_layers = 0 (None)
         """
 
         mapping_results = self.mapping(z, label, impl=impl)

models/stylegan3_generator.py

@@ -277,12 +277,12 @@ def forward(self,
         For layers in range [0, truncation_layers), the truncated w-code is
         computed as
 
-        w_new = w_avg + (w - w_avg) * truncation_psi
+        w_new = w_avg + (w - w_avg) * trunc_psi
 
         To disable truncation, please set
 
-        (1) truncation_psi = 1.0 (None) OR
-        (2) truncation_layers = 0 (None)
+        (1) trunc_psi = 1.0 (None) OR
+        (2) trunc_layers = 0 (None)
         """
 
         mapping_results = self.mapping(z, label, impl=impl)

runners/base_runner.py

@@ -507,25 +507,30 @@ def log_model_info(self):
             for param_name, param in model.named_parameters():
                 param_shapes[param_name] = f'{list(param.shape)}'
                 param_numels[param_name] = param.numel()
-            param_name_max_len = max(map(len, param_shapes.keys()))
-            param_name_max_len = max(param_name_max_len, len(name_header))
-            param_shape_max_len = max(map(len, param_shapes.values()))
-            param_shape_max_len = max(param_shape_max_len, len(shape_header))
-            param_numel_max_len = int(np.ceil(
-                np.log10(max(param_numels.values()))
-            ))
-            param_numel_max_len = max(param_numel_max_len, len(numel_header))
-            model_info += f'{name_header:<{param_name_max_len + 2}}'
-            model_info += f'{shape_header:<{param_shape_max_len + 2}}'
-            model_info += f'{numel_header:>{param_numel_max_len + 2}}\n'
-            model_info += f'{name_separator:<{param_name_max_len + 2}}'
-            model_info += f'{shape_separator:<{param_shape_max_len + 2}}'
-            model_info += f'{numel_separator:>{param_numel_max_len + 2}}\n'
-            for param_name, param_shape in param_shapes.items():
-                param_numel = param_numels[param_name]
-                model_info += f'{param_name:<{param_name_max_len + 2}}'
-                model_info += f'{param_shape:<{param_shape_max_len + 2}}'
-                model_info += f'{param_numel:{param_numel_max_len + 2}d}\n'
+            if len(param_shapes) == 0:  # no parameters
+                model_info += 'The model contains no parameter.\n'
+            else:
+                param_name_max_len = max(map(len, param_shapes.keys()))
+                param_name_max_len = max(param_name_max_len, len(name_header))
+                param_shape_max_len = max(map(len, param_shapes.values()))
+                param_shape_max_len = max(param_shape_max_len,
+                                          len(shape_header))
+                param_numel_max_len = int(np.ceil(
+                    np.log10(max(param_numels.values()))
+                ))
+                param_numel_max_len = max(param_numel_max_len,
+                                          len(numel_header))
+                model_info += f'{name_header:<{param_name_max_len + 2}}'
+                model_info += f'{shape_header:<{param_shape_max_len + 2}}'
+                model_info += f'{numel_header:>{param_numel_max_len + 2}}\n'
+                model_info += f'{name_separator:<{param_name_max_len + 2}}'
+                model_info += f'{shape_separator:<{param_shape_max_len + 2}}'
+                model_info += f'{numel_separator:>{param_numel_max_len + 2}}\n'
+                for param_name, param_shape in param_shapes.items():
+                    param_numel = param_numels[param_name]
+                    model_info += f'{param_name:<{param_name_max_len + 2}}'
+                    model_info += f'{param_shape:<{param_shape_max_len + 2}}'
+                    model_info += f'{param_numel:{param_numel_max_len + 2}d}\n'
             model_info += ('-' * 50 + '\n')
 
             model_info += 'Buffers:\n\n'
@@ -534,25 +539,31 @@ def log_model_info(self):
             for buffer_name, buffer in model.named_buffers():
                 buffer_shapes[buffer_name] = f'{list(buffer.shape)}'
                 buffer_numels[buffer_name] = buffer.numel()
-            buffer_name_max_len = max(map(len, buffer_shapes.keys()))
-            buffer_name_max_len = max(buffer_name_max_len, len(name_header))
-            buffer_shape_max_len = max(map(len, buffer_shapes.values()))
-            buffer_shape_max_len = max(buffer_shape_max_len, len(shape_header))
-            buffer_numel_max_len = int(np.ceil(
-                np.log10(max(buffer_numels.values()))
-            ))
-            buffer_numel_max_len = max(buffer_numel_max_len, len(numel_header))
-            model_info += f'{name_header:<{buffer_name_max_len + 2}}'
-            model_info += f'{shape_header:<{buffer_shape_max_len + 2}}'
-            model_info += f'{numel_header:>{buffer_numel_max_len + 2}}\n'
-            model_info += f'{name_separator:<{buffer_name_max_len + 2}}'
-            model_info += f'{shape_separator:<{buffer_shape_max_len + 2}}'
-            model_info += f'{numel_separator:>{buffer_numel_max_len + 2}}\n'
-            for buffer_name, buffer_shape in buffer_shapes.items():
-                buffer_numel = buffer_numels[buffer_name]
-                model_info += f'{buffer_name:<{buffer_name_max_len + 2}}'
-                model_info += f'{buffer_shape:<{buffer_shape_max_len + 2}}'
-                model_info += f'{buffer_numel:{buffer_numel_max_len + 2}d}\n'
+            if len(buffer_shapes) == 0:  # no buffers
+                model_info += 'The model contains no buffer.\n'
+            else:
+                buffer_name_max_len = max(map(len, buffer_shapes.keys()))
+                buffer_name_max_len = max(buffer_name_max_len, len(name_header))
+                buffer_shape_max_len = max(map(len, buffer_shapes.values()))
+                buffer_shape_max_len = max(buffer_shape_max_len,
+                                           len(shape_header))
+                buffer_numel_max_len = int(np.ceil(
+                    np.log10(max(buffer_numels.values()))
+                ))
+                buffer_numel_max_len = max(buffer_numel_max_len,
+                                           len(numel_header))
+                model_info += f'{name_header:<{buffer_name_max_len + 2}}'
+                model_info += f'{shape_header:<{buffer_shape_max_len + 2}}'
+                model_info += f'{numel_header:>{buffer_numel_max_len + 2}}\n'
+                model_info += f'{name_separator:<{buffer_name_max_len + 2}}'
+                model_info += f'{shape_separator:<{buffer_shape_max_len + 2}}'
+                model_info += f'{numel_separator:>{buffer_numel_max_len + 2}}\n'
+                for buffer_name, buffer_shape in buffer_shapes.items():
+                    buffer_numel = buffer_numels[buffer_name]
+                    model_info += f'{buffer_name:<{buffer_name_max_len + 2}}'
+                    model_info += f'{buffer_shape:<{buffer_shape_max_len + 2}}'
+                    model_info += f'{buffer_numel:{buffer_numel_max_len + 2}d}'
+                    model_info += '\n'
             model_info += ('-' * 50 + '\n')
 
             model_info += 'Size (using `Float32` for size computation):\n\n'