fix

Author: OutisLi

deepmd/dpmodel/utils/learning_rate.py

@@ -118,11 +118,12 @@ def __init__(
         self.warmup_start_lr = warmup_start_factor * start_lr
 
         # === Step 7. Store core parameters ===
-        self.start_lr = start_lr
+        self._start_lr = start_lr
         self.num_steps = num_steps
         # Decay phase covers (num_steps - warmup_steps) steps
         self.decay_num_steps = num_steps - self.warmup_steps
 
+    @property
     def start_lr(self) -> float:
         """
         Get the starting learning rate.
@@ -132,7 +133,7 @@ def start_lr(self) -> float:
         float
             The starting learning rate.
         """
-        return self.start_lr
+        return self._start_lr
 
     @abstractmethod
     def _decay_value(self, step: int | Array) -> Array:
@@ -184,7 +185,7 @@ def value(self, step: int | Array) -> Array | float:
             warmup_progress = xp.astype(step, xp.float64) / self.warmup_steps
             warmup_lr = (
                 self.warmup_start_lr
-                + (self.start_lr - self.warmup_start_lr) * warmup_progress
+                + (self._start_lr - self.warmup_start_lr) * warmup_progress
             )
 
             # === Step 3. Decay phase ===
@@ -338,7 +339,7 @@ def __init__(
             self.decay_rate = 1.0  # No decay
         else:
             self.decay_rate = np.exp(
-                np.log(clamped_stop_lr / self.start_lr)
+                np.log(clamped_stop_lr / self._start_lr)
                 / (decay_total / self.decay_steps)
             ).item()
 
@@ -367,7 +368,7 @@ def _decay_value(self, step: int | Array) -> Array:
             exponent = xp.astype(step, xp.float64) / self.decay_steps
         else:
             exponent = xp.astype(step // self.decay_steps, xp.float64)
-        step_lr = self.start_lr * xp.pow(
+        step_lr = self._start_lr * xp.pow(
             xp.asarray(self.decay_rate, device=array_api_compat.device(step)),
             exponent,
         )
@@ -472,11 +473,11 @@ def _decay_value(self, step: int | Array) -> Array:
         if not array_api_compat.is_array_api_obj(step):
             step = np.asarray(step)
         xp = array_api_compat.array_namespace(step)
-        min_lr = self.start_lr * self.lr_min_factor
+        min_lr = self._start_lr * self.lr_min_factor
         # Handle decay_num_steps=0 (no training steps) - return start_lr
         if self.decay_num_steps == 0:
-            return xp.full_like(step, self.start_lr, dtype=xp.float64)
-        step_lr = self.start_lr * (
+            return xp.full_like(step, self._start_lr, dtype=xp.float64)
+        step_lr = self._start_lr * (
             self.lr_min_factor
             + 0.5
             * (1 - self.lr_min_factor)

deepmd/pd/train/training.py

@@ -580,9 +580,9 @@ def single_model_finetune(
         # author: iProzd
         if self.opt_type == "Adam":
             self.scheduler = paddle.optimizer.lr.LambdaDecay(
-                learning_rate=self.lr_exp.start_lr(),
+                learning_rate=self.lr_exp.start_lr,
                 lr_lambda=lambda step: self.lr_exp.value(step + self.start_step)
-                / self.lr_exp.start_lr(),
+                / self.lr_exp.start_lr,
             )
             self.optimizer = paddle.optimizer.Adam(
                 learning_rate=self.scheduler, parameters=self.wrapper.parameters()

deepmd/pt/train/training.py

@@ -688,13 +688,13 @@ def single_model_finetune(
             if self.opt_type == "Adam":
                 self.optimizer = torch.optim.Adam(
                     self.wrapper.parameters(),
-                    lr=self.lr_exp.start_lr(),
+                    lr=self.lr_exp.start_lr,
                     fused=False if DEVICE.type == "cpu" else True,
                 )
             else:
                 self.optimizer = torch.optim.AdamW(
                     self.wrapper.parameters(),
-                    lr=self.lr_exp.start_lr(),
+                    lr=self.lr_exp.start_lr,
                     weight_decay=float(self.opt_param["weight_decay"]),
                     fused=False if DEVICE.type == "cpu" else True,
                 )
@@ -703,7 +703,7 @@ def single_model_finetune(
             self.scheduler = torch.optim.lr_scheduler.LambdaLR(
                 self.optimizer,
                 lambda step: self.lr_exp.value(step + self.start_step)
-                / self.lr_exp.start_lr(),
+                / self.lr_exp.start_lr,
             )
         elif self.opt_type == "LKF":
             self.optimizer = LKFOptimizer(
@@ -712,7 +712,7 @@ def single_model_finetune(
         elif self.opt_type == "AdaMuon":
             self.optimizer = AdaMuonOptimizer(
                 self.wrapper.parameters(),
-                lr=self.lr_exp.start_lr(),
+                lr=self.lr_exp.start_lr,
                 momentum=float(self.opt_param["momentum"]),
                 weight_decay=float(self.opt_param["weight_decay"]),
                 adam_betas=(
@@ -725,7 +725,7 @@ def single_model_finetune(
         elif self.opt_type == "HybridMuon":
             self.optimizer = HybridMuonOptimizer(
                 self.wrapper.parameters(),
-                lr=self.lr_exp.start_lr(),
+                lr=self.lr_exp.start_lr,
                 momentum=float(self.opt_param["momentum"]),
                 weight_decay=float(self.opt_param["weight_decay"]),
                 adam_betas=(
@@ -742,7 +742,7 @@ def single_model_finetune(
             self.scheduler = torch.optim.lr_scheduler.LambdaLR(
                 self.optimizer,
                 lambda step: self.lr_exp.value(step + self.start_step)
-                / self.lr_exp.start_lr(),
+                / self.lr_exp.start_lr,
             )
         else:
             raise ValueError(f"Not supported optimizer type '{self.opt_type}'")