Add config testing (#4041)

* complete config testing

* add bert-testing

* update modeling comon

* fix testing issue

* update testing

* upate hf-config testing

* update test bert common

* Update test_modeling_common.py

* Update test_modeling_common.py

Co-authored-by: Sijun He <[email protected]>

Author: wj-Mcat

paddlenlp/transformers/configuration_utils.py

@@ -843,6 +843,9 @@ def from_dict(cls, config_dict: Dict[str, Any], **kwargs) -> "PretrainedConfig":
         # Those arguments may be passed along for our internal telemetry.
         # We remove them so they don't appear in `return_unused_kwargs`.
 
+        # convert local config to legacy config
+        config_dict = convert_to_legacy_config(cls.standard_config_map, config_dict)
+
         config = cls(**config_dict)
 
         if hasattr(config, "pruned_heads"):

paddlenlp/transformers/model_utils.py

@@ -48,7 +48,7 @@
     download_check,
     get_path_from_url_with_filelock,
 )
-from paddlenlp.utils.env import HF_CACHE_HOME, MODEL_HOME
+from paddlenlp.utils.env import HF_CACHE_HOME, LEGACY_CONFIG_NAME, MODEL_HOME
 from paddlenlp.utils.log import logger
 
 from .configuration_utils import PretrainedConfig
@@ -200,7 +200,10 @@ class is a pretrained model class adding layers on top of the base model,
     by which subclasses can track arguments for initialization automatically.
     """
 
-    model_config_file = "model_config.json"
+    # Deprecated(wj-Mcat): after 2.6.* version
+    # save the old-school `LEGACY_CONFIG_NAME`, and will be changed to `CONFIG_NAME` after 2.6.* version
+    model_config_file = LEGACY_CONFIG_NAME
+
     pretrained_init_configuration = {}
     # TODO: more flexible resource handle, namedtuple with fields as:
     # resource_name, saved_file, handle_name_for_load(None for used as __init__
@@ -1128,7 +1131,7 @@ def _find_mismatched_keys(
         return model_to_load, missing_keys, unexpected_keys, mismatched_keys
 
     @classmethod
-    def from_pretrained_v2(cls, pretrained_model_name_or_path, *args, **kwargs):
+    def from_pretrained_v2(cls, pretrained_model_name_or_path, from_hf_hub: bool = False, *args, **kwargs):
         """
         Creates an instance of `PretrainedModel`. Model weights are loaded
         by specifying name of a built-in pretrained model, a pretrained model from HF Hub, a community contributed model,
@@ -1143,6 +1146,7 @@ def from_pretrained_v2(cls, pretrained_model_name_or_path, *args, **kwargs):
                 - Name of a community-contributed pretrained model.
                 - Local directory path which contains model weights file("model_state.pdparams")
                   and model config file ("model_config.json").
+            from_hf_hub (bool): load model from huggingface hub. Default to `False`.
             *args (tuple): Position arguments for model `__init__`. If provided,
                 use these as position argument values for model initialization.
             **kwargs (dict): Keyword arguments for model `__init__`. If provided,
@@ -1182,7 +1186,6 @@ def from_pretrained_v2(cls, pretrained_model_name_or_path, *args, **kwargs):
         load_state_as_np = kwargs.pop("load_state_as_np", False)
         config = kwargs.pop("config", None)
         force_download = kwargs.pop("force_download", False)
-        from_hf_hub = kwargs.pop("from_hf_hub", False)
         ignore_mismatched_sizes = kwargs.pop("ignore_mismatched_sizes", None)
         dtype = kwargs.pop("dtype", None)
         cache_dir = kwargs.pop("cache_dir", None)

paddlenlp/transformers/pegasus/modeling.py

@@ -13,15 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from functools import partial
 import math
-import numpy as np
 
+import numpy as np
 import paddle
 import paddle.nn as nn
-import paddle.nn.functional as F
-import paddle.tensor as tensor
-from paddle.nn import Layer, Embedding
+from paddle.nn import Embedding
 
 from .. import PretrainedModel, register_base_model
 

tests/transformers/bert/test_modeling.py

@@ -34,15 +34,19 @@
     BertForSequenceClassification,
     BertForTokenClassification,
     BertModel,
-    BertPretrainedModel,
 )
 from paddlenlp.transformers.bert.configuration import BertConfig
 from paddlenlp.transformers.model_utils import PretrainedModel
 from paddlenlp.utils import install_package, uninstall_package
 
 from ...testing_utils import slow
 from ..test_configuration_common import ConfigTester
-from ..test_modeling_common import ModelTesterMixin, ModelTesterPretrainedMixin, ids_tensor, random_attention_mask
+from ..test_modeling_common import (
+    ModelTesterMixin,
+    ModelTesterPretrainedMixin,
+    ids_tensor,
+    random_attention_mask,
+)
 
 
 class BertModelTester:

tests/transformers/test_modeling_common.py

@@ -20,13 +20,14 @@
 import shutil
 import tempfile
 import unittest
+from typing import Optional, Tuple, Type
 
 import numpy as np
 import paddle
 
 from paddlenlp.transformers.configuration_utils import PretrainedConfig
 from paddlenlp.transformers.model_utils import PretrainedModel
-from paddlenlp.utils.env import MODEL_HOME
+from paddlenlp.utils.env import CONFIG_NAME, LEGACY_CONFIG_NAME, MODEL_HOME
 
 from ..testing_utils import slow
 
@@ -59,8 +60,8 @@ def check_two_model_parameter(first_model: PretrainedModel, second_model: Pretra
 
 class ModelTesterMixin:
     model_tester = None
-    base_model_class = None
-    all_model_classes = ()
+    base_model_class: Optional[Type[PretrainedModel]] = None
+    all_model_classes: Tuple[Type[PretrainedModel]] = ()
     all_generative_model_classes = ()
     test_resize_embeddings = True
     test_resize_position_embeddings = False
@@ -493,20 +494,50 @@ def test_model_name_list(self):
             model = self.base_model_class(**config)
         self.assertTrue(len(model.model_name_list) != 0)
 
+    def test_pretrained_config_save_load(self):
+
+        if self.base_model_class is None or not self.base_model_class.constructed_from_pretrained_config():
+            return
+
+        config_class = self.base_model_class.config_class
+        with tempfile.TemporaryDirectory() as tempdir:
+            config = config_class()
+
+            config.save_pretrained(tempdir)
+
+            # check the file exist
+            self.assertFalse(os.path.exists(os.path.join(tempdir, LEGACY_CONFIG_NAME)))
+            self.assertTrue(os.path.exists(os.path.join(tempdir, CONFIG_NAME)))
+
+            # rename the CONFIG_NAME
+            shutil.move(os.path.join(tempdir, CONFIG_NAME), os.path.join(tempdir, LEGACY_CONFIG_NAME))
+
+            loaded_config = config.__class__.from_pretrained(tempdir)
+            self.assertEqual(config.hidden_size, loaded_config.hidden_size)
+
+    def random_choice_pretrained_config_field(self) -> Optional[str]:
+
+        if self.base_model_class is None or not self.base_model_class.constructed_from_pretrained_config():
+            return None
+
+        config = self.base_model_class.config_class()
+        fields = [key for key, value in config.to_dict() if value]
+        return random.choice(fields)
+
 
 class ModelTesterPretrainedMixin:
     base_model_class: PretrainedModel = None
     hf_remote_test_model_path: str = None
     paddlehub_remote_test_model_path: str = None
 
+    # Download from HF doesn't work in CI yet
     @slow
     def test_model_from_pretrained_hf_hub(self):
         if self.hf_remote_test_model_path is None or self.base_model_class is None:
             return
         model = self.base_model_class.from_pretrained(self.hf_remote_test_model_path, from_hf_hub=True)
         self.assertIsNotNone(model)
 
-    @slow
     def test_model_from_pretrained_paddle_hub(self):
         if self.paddlehub_remote_test_model_path is None or self.base_model_class is None:
             return
@@ -553,8 +584,6 @@ def test_pretrained_save_and_load(self):
                     os.path.join(MODEL_HOME, model_name),
                     tempdirname,
                 )
-                files = os.listdir(tempdirname)
-
                 saved_model_state_file = os.path.join(
                     tempdirname, self.base_model_class.resource_files_names["model_state"]
                 )