No public description

PiperOrigin-RevId: 881732289

Author: tensorflower-gardener

official/core/train_utils.py

@@ -292,6 +292,7 @@ class ParseConfigOptions:
   tpu: str = ''
   tf_data_service: str = ''
   params_override: str = ''
+  strict_override: bool = True
 
   def __contains__(self, name):
     return name in dataclasses.asdict(self)
@@ -330,9 +331,13 @@ def base_experiment(self):
 
   def parse_config_file(self, params):
     """Override the configs of params from the config_file."""
+    is_strict = True
+    if isinstance(self._flags_obj, ParseConfigOptions):
+      is_strict = self._flags_obj.strict_override
     for config_file in self._flags_obj.config_file or []:
       params = hyperparams.override_params_dict(
-          params, config_file, is_strict=True)
+          params, config_file, is_strict=is_strict
+      )
     return params
 
   def parse_runtime(self, params):
@@ -363,14 +368,28 @@ def parse_data_service(self, params):
     return params
 
   def parse_params_override(self, params):
+    """Overrides params from the --params_override flag.
+
+    Args:
+      params: A ParamsDict object to be overridden.
+
+    Returns:
+      The overridden ParamsDict object.
+    """
     # Get the second level of override from `--params_override`.
     # `--params_override` is typically used as a further override over the
     # template. For example, one may define a particular template for training
     # ResNet50 on ImageNet in a config file and pass it via `--config_file`,
     # then define different learning rates and pass it via `--params_override`.
     if self._flags_obj.params_override:
+      is_strict = True
+      if isinstance(self._flags_obj, ParseConfigOptions):
+        is_strict = self._flags_obj.strict_override
       params = hyperparams.override_params_dict(
-          params, self._flags_obj.params_override, is_strict=True)
+          params,
+          self._flags_obj.params_override,
+          is_strict=is_strict,
+      )
     return params
 
 

official/core/train_utils_test.py

@@ -17,8 +17,10 @@
 import os
 import pprint
 
+from absl.testing import parameterized
 import numpy as np
 import tensorflow as tf, tf_keras
+import yaml
 
 from official.core import exp_factory
 from official.core import test_utils
@@ -47,7 +49,7 @@ def foo():
   return experiment_config
 
 
-class TrainUtilsTest(tf.test.TestCase):
+class TrainUtilsTest(tf.test.TestCase, parameterized.TestCase):
 
   def test_get_leaf_nested_dict(self):
     d = {'a': {'i': {'x': 5}}}
@@ -138,6 +140,87 @@ def test_construct_experiment_from_flags(self):
     self.assertEqual(params_from_obj.trainer.train_steps, 10)
     self.assertEqual(params_from_obj.trainer.validation_steps, 11)
 
+  @parameterized.named_parameters(
+      dict(
+          testcase_name='strict_with_extra',
+          strict_override=True,
+          has_extra=True,
+          expect_error=True,
+      ),
+      dict(
+          testcase_name='non_strict_with_extra',
+          strict_override=False,
+          has_extra=True,
+          expect_error=False,
+      ),
+      dict(
+          testcase_name='strict_no_extra',
+          strict_override=True,
+          has_extra=False,
+          expect_error=False,
+      ),
+      dict(
+          testcase_name='non_strict_no_extra',
+          strict_override=False,
+          has_extra=False,
+          expect_error=False,
+      ),
+  )
+  def test_parse_configuration_strict_override_file(
+      self, strict_override, has_extra, expect_error
+  ):
+    tempdir = self.create_tempdir().full_path
+    config_path = os.path.join(tempdir, 'config.yaml')
+    override_config = {
+        'task': {
+            'model': {
+                'model_id': 'override',
+            },
+        },
+        'trainer': {
+            'train_steps': 500,
+        },
+    }
+    if has_extra:
+      override_config['task']['extra_key'] = 'extra_value'
+
+    with open(config_path, 'w') as f:
+      yaml.dump(override_config, f)
+
+    options = train_utils.ParseConfigOptions(
+        experiment='foo',
+        config_file=[config_path],
+        strict_override=strict_override,
+    )
+
+    if expect_error:
+      with self.assertRaises(KeyError):
+        train_utils.parse_configuration(options)
+    else:
+      params = train_utils.parse_configuration(options)
+      self.assertEqual(params.task.model.model_id, 'override')
+      self.assertEqual(params.trainer.train_steps, 500)
+      if has_extra:
+        self.assertTrue(hasattr(params.task, 'extra_key'))
+        self.assertEqual(params.task.extra_key, 'extra_value')
+      else:
+        self.assertFalse(hasattr(params.task, 'extra_key'))
+
+  def test_parse_configuration_strict_override_string(self):
+    # Test non-strict loading with params_override string
+    options_non_strict_override = train_utils.ParseConfigOptions(
+        experiment='foo',
+        config_file=[],
+        params_override='task.another_extra=test,trainer.train_steps=100',
+        strict_override=False,
+    )
+    params_override = train_utils.parse_configuration(
+        options_non_strict_override
+    )
+    self.assertEqual(params_override.trainer.train_steps, 100)
+    self.assertTrue(hasattr(params_override.task, 'another_extra'))
+    self.assertEqual(params_override.task.another_extra, 'test')
+
 
 class BestCheckpointExporterTest(tf.test.TestCase):
 

official/modeling/hyperparams/params_dict.py

@@ -16,6 +16,7 @@
 
 import collections
 import copy
+import logging
 import re
 
 import six
@@ -192,6 +193,9 @@ def _override(self, override_dict, is_strict=True):
                          'To extend the existing keys, use '
                          '`override` with `is_strict` = False.'.format(k))
         else:
+          logging.warning(
+              'Adding new key `%s` to ParamsDict because is_strict=False.', k
+          )
           self._set(k, v)
       else:
         if isinstance(v, dict):