fix cells to modules in mindnlp.peft (#1875)

Author: lvyufeng

mindnlp/peft/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""Parameter effcient fine tuning cells, like huggingface peft."""
+"""Parameter effcient fine tuning modules, like huggingface peft."""
 from .mapping import (
     MODEL_TYPE_TO_PEFT_MODEL_MAPPING,
     PEFT_TYPE_TO_CONFIG_MAPPING,

mindnlp/peft/config.py

@@ -166,7 +166,7 @@ class PromptLearningConfig(PeftConfig):
     Args:
         num_virtual_tokens (`int`): The number of virtual tokens to use.
         token_dim (`int`): The hidd-en embedding dimension of the base transformer model.
-        num_transformer_submodules (`int`): The number of transformer subcells in the base transformer model.
+        num_transformer_submodules (`int`): The number of transformer submodules in the base transformer model.
         num_attention_heads (`int`): The number of attention heads in the base transformer model.
         num_layers (`int`): The number of layers in the base transformer model.
     """
@@ -175,7 +175,7 @@ class PromptLearningConfig(PeftConfig):
         default=None, metadata={"help": "The hidden embedding dimension of the base transformer model"}
     )
     num_transformer_submodules: Optional[int] = field(
-        default=None, metadata={"help": "Number of transformer subcells"}
+        default=None, metadata={"help": "Number of transformer submodules"}
     )
     num_attention_heads: Optional[int] = field(default=None, metadata={"help": "Number of attention heads"})
     num_layers: Optional[int] = field(default=None, metadata={"help": "Number of transformer layers"})

mindnlp/peft/mapping.py

@@ -141,7 +141,7 @@ def inject_adapter_in_model(
 
     tuner_cls = PEFT_TYPE_TO_TUNER_MAPPING[peft_config.peft_type]
 
-    # By instantiating a peft model we are injecting randomly initialized LoRA layers into the model's cells.
+    # By instantiating a peft model we are injecting randomly initialized LoRA layers into the model's modules.
     peft_model = tuner_cls(model, peft_config, adapter_name=adapter_name)
 
     return peft_model.model

mindnlp/peft/peft_model.py

@@ -114,7 +114,7 @@ def __init__(self, model, peft_config: PeftConfig, adapter_name="default"):
             self.base_model = PEFT_TYPE_TO_MODEL_MAPPING[peft_config.peft_type](
                 self.base_model, self.peft_config, adapter_name
             )
-            self.set_additional_trainable_cells(peft_config, adapter_name)
+            self.set_additional_trainable_modules(peft_config, adapter_name)
         else:
             self.add_adapter(adapter_name, peft_config)
 
@@ -247,7 +247,7 @@ def load_adapter(self, model_id: str, adapter_name: str, is_trainable: bool = Fa
         load_result = set_peft_model_state_dict(self, adapters_weights, adapter_name=adapter_name)
         # TODO: add parallel logic & offload logic & device map logic(dispatch_model)
 
-        # Set model in evaluation mode to deactivate Dropout cells by default
+        # Set model in evaluation mode to deactivate Dropout modules by default
         if not is_trainable:
             self.set_train(False)
 
@@ -425,10 +425,10 @@ def add_adapter(self, adapter_name: str, peft_config: PeftConfig):
             del self.peft_config[adapter_name]
             raise
 
-        self.set_additional_trainable_cells(peft_config, adapter_name)
+        self.set_additional_trainable_modules(peft_config, adapter_name)
 
-    def set_additional_trainable_cells(self, peft_config, adapter_name):
-        """set additional trainable cells"""
+    def set_additional_trainable_modules(self, peft_config, adapter_name):
+        """set additional trainable modules"""
         if getattr(peft_config, "modules_to_save", None) is not None:
             if self.modules_to_save is None:
                 self.modules_to_save = set(peft_config.modules_to_save)
@@ -473,7 +473,7 @@ def __init__(self, model, peft_config: PeftConfig, adapter_name="default"):
         else:
             self.modules_to_save.update({"classifier", "score"})
 
-        for name, _ in self.base_model.cells_and_names():
+        for name, _ in self.base_model.modules_and_names():
             if any(module_name in name for module_name in self.modules_to_save):
                 self.cls_layer_name = name
                 break
@@ -955,7 +955,7 @@ def __init__(self, model, peft_config: PeftConfig = None, adapter_name="default"
         else:
             self.modules_to_save.update({"classifier", "score"})
 
-        for name, _ in self.base_model.cells_and_names():
+        for name, _ in self.base_model.modules_and_names():
             if any(module_name in name for module_name in self.modules_to_save):
                 self.cls_layer_name = name
                 break
@@ -1079,15 +1079,15 @@ def _prefix_tuning_forward(
         if "past_key_values" in fwd_params:
             return self.base_model(labels=labels, **kwargs)
         else:
-            transformer_backbone_name = self.base_model.get_subcell(self.transformer_backbone_name)
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
             fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
             if "past_key_values" not in fwd_params:
                 raise ValueError("Model does not support past key values which are required for prefix tuning.")
             outputs = transformer_backbone_name(**kwargs)
             sequence_output = outputs[0]
-            if "dropout" in [name for name, _ in list(self.base_model.cells_and_names())]:
+            if "dropout" in [name for name, _ in list(self.base_model.modules_and_names())]:
                 sequence_output = self.base_model.dropout(sequence_output)
-            logits = self.base_model.get_subcell(self.cls_layer_name)(sequence_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(sequence_output)
 
             loss = None
             if labels is not None:

mindnlp/peft/tuners/adalora/model.py

@@ -23,7 +23,7 @@
 from mindnlp.peft.utils import (
     TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING,
     _freeze_adapter,
-    _get_subcells,
+    _get_submodules,
 )
 
 from ..tuners_utils import BaseTunerLayer
@@ -145,7 +145,7 @@ def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
                     if "bias" in n:
                         p.requires_grad = True
             elif bias == "lora_only":
-                for m in model.cells():
+                for m in model.modules():
                     if isinstance(m, AdaLoraLayer) and hasattr(m, "bias") and m.bias is not None:
                         m.bias.requires_grad = True
             else:
@@ -331,7 +331,7 @@ def _prepare_adapter_config(peft_config, model_config):
         This method '_prepare_adapter_config' in the class 'AdaLoraModel' prepares the adapter configuration based on the provided 'peft_config' and 'model_config' parameters.
         
         Args:
-        - peft_config (dict): A dictionary containing the configuration details for the adapter. It should include information about the target cells. If 'target_modules' is not specified, it is inferred based
+        - peft_config (dict): A dictionary containing the configuration details for the adapter. It should include information about the target modules. If 'target_modules' is not specified, it is inferred based
 on the 'model_type' from the 'model_config' parameter.
         - model_config (dict): A dictionary containing the configuration details specific to the model. It is used to determine the 'model_type' which is then used to infer the 'target_modules' if not explicitly
 provided in 'peft_config'.
@@ -385,8 +385,8 @@ def forward(self, *args, **kwargs):
             outputs.loss += orth_reg_weight * regu_loss
         return outputs
 
-    def resize_cells_by_rank_pattern(self, rank_pattern, adapter_name):
-        "resize the cells by rank pattern"
+    def resize_modules_by_rank_pattern(self, rank_pattern, adapter_name):
+        "resize the modules by rank pattern"
         lora_config = self.peft_config[adapter_name]
         for name, rank_idx in rank_pattern.items():
             if isinstance(rank_idx, list):
@@ -398,7 +398,7 @@ def resize_cells_by_rank_pattern(self, rank_pattern, adapter_name):
             else:
                 raise ValueError("Unexpected type of rank_idx")
             key = ".".join(name.split(".")[0:-2]) if adapter_name in name else ".".join(name.split(".")[0:-1])
-            _, target, _ = _get_subcells(self.model, key)
+            _, target, _ = _get_submodules(self.model, key)
             lora_E_weights = target.lora_E[adapter_name][rank_idx]
             lora_A_weights = target.lora_A[adapter_name][rank_idx]
             lora_B_weights = target.lora_B[adapter_name][:, rank_idx]

mindnlp/peft/tuners/adaption_prompt/config.py

@@ -24,7 +24,7 @@
 class AdaptionPromptConfig(PeftConfig):
     """Stores the configuration of an [`AdaptionPromptModel`]."""
     target_modules: str = field(
-        default=None, metadata={"help": "Name of the attention subcells to insert adaption prompts into."}
+        default=None, metadata={"help": "Name of the attention submodules to insert adaption prompts into."}
     )
     adapter_len: int = field(default=None, metadata={"help": "Number of adapter tokens to insert"})
     adapter_layers: int = field(default=None, metadata={"help": "Number of adapter layers (from the top)"})

mindnlp/peft/tuners/adaption_prompt/model.py

@@ -16,7 +16,7 @@
 
 from mindnlp.core import nn
 
-from mindnlp.peft.utils import _freeze_adapter, _get_subcells
+from mindnlp.peft.utils import _freeze_adapter, _get_submodules
 
 from .config import AdaptionPromptConfig, prepare_config
 from .layer import AdaptedAttention
@@ -27,17 +27,17 @@ class AdaptionPromptModel(nn.Module):
     """
     Implements adaption prompts as described in https://arxiv.org/pdf/2303.16199.pdf.
 
-    The top L attention cells are replaced with AdaptedAttention cells that wrap the original ones, but insert
+    The top L attention modules are replaced with AdaptedAttention modules that wrap the original ones, but insert
     trainable prompts with gates (for zero init).
 
     Notes on the multi-adapter pattern:
-    - We store the states of different adapters by keeping a dictionary of AdaptedAttention cells indexed by adapter
+    - We store the states of different adapters by keeping a dictionary of AdaptedAttention modules indexed by adapter
       name.
-    - Every time we switch adapters, we remove the cells of the currently active adapter from the model, store them
-      in the dictionary, and replace them with the cells of the new adapter.
+    - Every time we switch adapters, we remove the modules of the currently active adapter from the model, store them
+      in the dictionary, and replace them with the modules of the new adapter.
     - To avoid duplicated and potentially inconsistent state, the currently active adapter is always removed from the
       dictionary.
-    - Disabling the adapter would also result in the cells being removed from the model.
+    - Disabling the adapter would also result in the modules being removed from the model.
     """
     def __init__(self, model, configs: Dict, adapter_name: str):
         r"""
@@ -80,11 +80,11 @@ def add_adapter(self, adapter_name: str, config: AdaptionPromptConfig) -> None:
 
         parents = []
         # 获取模型的所有子模块及其名称
-        for name, subcell in self.model.name_cells().items():
+        for name, submodule in self.model.named_modules().items():
             if name.endswith(config.target_modules):
-                # 对每个符合条件的子模块调用 _get_subcells 函数
-                parent, target, target_name = _get_subcells(self.model, name)
-                if target == subcell:
+                # 对每个符合条件的子模块调用 _get_submodules 函数
+                parent, target, target_name = _get_submodules(self.model, name)
+                if target == submodule:
                     parents.append(parent)
 
         if len(parents) < config.adapter_layers:
@@ -118,17 +118,17 @@ def set_adapter(self, adapter_name: str) -> None:
         self._active_adapter = adapter_name
 
     def enable_adapter_layers(self):
-        """Enable adapter layers by swapping in cached AdaptedAttention cells."""
+        """Enable adapter layers by swapping in cached AdaptedAttention modules."""
         self._enabled = True
         self._set_adapted_attentions(self._active_adapter)
 
     def disable_adapter_layers(self):
-        """Disable adapter layers by swapping out AdaptedAttention cells."""
+        """Disable adapter layers by swapping out AdaptedAttention modules."""
         self._enabled = False
         self._remove_adapted_attentions(self._active_adapter)
 
     def _create_adapted_attentions(self, config: AdaptionPromptConfig, parents: List[nn.Module]) -> None:
-        """Wrap LlamaAttention cells with newly created AdaptedAttention cells."""
+        """Wrap LlamaAttention modules with newly created AdaptedAttention modules."""
         for par in parents:
             attn = AdaptedAttention(
                 model_type=self.model.config.model_type,
@@ -138,15 +138,15 @@ def _create_adapted_attentions(self, config: AdaptionPromptConfig, parents: List
             setattr(par, config.target_modules, attn)
 
     def _set_adapted_attentions(self, adapter_name: str) -> None:
-        """Replace LlamaAttention cells with cached AdaptedAttention cells."""
+        """Replace LlamaAttention modules with cached AdaptedAttention modules."""
         cached = self._cached_adapters[adapter_name]
         del self._cached_adapters[adapter_name]
         config = self.peft_config[adapter_name]
         for i, par in enumerate(self._parents[adapter_name]):
             setattr(par, config.target_modules, cached[i])
 
     def _remove_adapted_attentions(self, adapter_name: str) -> None:
-        """Remove AdaptedAttention cells from the model and store them in the cache."""
+        """Remove AdaptedAttention modules from the model and store them in the cache."""
         config = self.peft_config[adapter_name]
         adapted_attentions = []
         for par in self._parents[adapter_name]: