fix: find_* defaults 1.0→0.0 to match PT, fix ruff RUF059 unused vars

- Change find_* label defaults from 1.0 to 0.0 in dpmodel losses
  (ener_spin, dos, tensor) to match PT behavior: missing labels should
  zero out the contribution, not assume they exist.
- Prefix unused unpacked variables with _ to satisfy ruff RUF059.

Author: Han Wang

deepmd/dpmodel/loss/dos.py

@@ -124,7 +124,7 @@ def call(
         more_loss = {}
 
         if self.has_ados and "atom_dos" in model_dict and "atom_dos" in label_dict:
-            find_local = label_dict.get("find_atom_dos", 1.0)
+            find_local = label_dict.get("find_atom_dos", 0.0)
             pref_ados = pref_ados * find_local
             local_pred = xp.reshape(model_dict["atom_dos"], (-1, natoms, self.numb_dos))
             local_label = xp.reshape(
@@ -145,7 +145,7 @@ def call(
             )
 
         if self.has_acdf and "atom_dos" in model_dict and "atom_dos" in label_dict:
-            find_local = label_dict.get("find_atom_dos", 1.0)
+            find_local = label_dict.get("find_atom_dos", 0.0)
             pref_acdf = pref_acdf * find_local
             local_pred_cdf = xp.cumulative_sum(
                 xp.reshape(model_dict["atom_dos"], (-1, natoms, self.numb_dos)),
@@ -170,7 +170,7 @@ def call(
             )
 
         if self.has_dos and "dos" in model_dict and "dos" in label_dict:
-            find_global = label_dict.get("find_dos", 1.0)
+            find_global = label_dict.get("find_dos", 0.0)
             pref_dos = pref_dos * find_global
             global_pred = xp.reshape(model_dict["dos"], (-1, self.numb_dos))
             global_label = xp.reshape(label_dict["dos"], (-1, self.numb_dos))
@@ -190,7 +190,7 @@ def call(
             )
 
         if self.has_cdf and "dos" in model_dict and "dos" in label_dict:
-            find_global = label_dict.get("find_dos", 1.0)
+            find_global = label_dict.get("find_dos", 0.0)
             pref_cdf = pref_cdf * find_global
             global_pred_cdf = xp.cumulative_sum(
                 xp.reshape(model_dict["dos"], (-1, self.numb_dos)), axis=-1

deepmd/dpmodel/loss/ener_spin.py

@@ -121,7 +121,7 @@ def call(
         if self.has_e:
             energy_pred = model_dict["energy"]
             energy_label = label_dict["energy"]
-            find_energy = label_dict.get("find_energy", 1.0)
+            find_energy = label_dict.get("find_energy", 0.0)
             pref_e = pref_e * find_energy
             if self.enable_atom_ener_coeff and "atom_energy" in model_dict:
                 atom_ener_pred = model_dict["atom_energy"]
@@ -148,7 +148,7 @@ def call(
                 more_loss["mae_e_all"] = self.display_if_exist(mae_e_all, find_energy)
 
         if self.has_fr:
-            find_force = label_dict.get("find_force", 1.0)
+            find_force = label_dict.get("find_force", 0.0)
             pref_fr = pref_fr * find_force
             force_pred = model_dict["force"]
             force_label = label_dict["force"]
@@ -173,7 +173,7 @@ def call(
                 )
 
         if self.has_fm:
-            find_force_mag = label_dict.get("find_force_mag", 1.0)
+            find_force_mag = label_dict.get("find_force_mag", 0.0)
             pref_fm = pref_fm * find_force_mag
             force_mag_pred = model_dict["force_mag"]
             force_mag_label = label_dict["force_mag"]
@@ -207,7 +207,7 @@ def call(
                 )
 
         if self.has_ae:
-            find_atom_ener = label_dict.get("find_atom_ener", 1.0)
+            find_atom_ener = label_dict.get("find_atom_ener", 0.0)
             pref_ae = pref_ae * find_atom_ener
             atom_ener = model_dict["atom_energy"]
             atom_ener_label = label_dict["atom_ener"]
@@ -231,7 +231,7 @@ def call(
                 )
 
         if self.has_v:
-            find_virial = label_dict.get("find_virial", 1.0)
+            find_virial = label_dict.get("find_virial", 0.0)
             pref_v = pref_v * find_virial
             virial_pred = xp.reshape(model_dict["virial"], (-1, 9))
             virial_label = label_dict["virial"]

deepmd/dpmodel/loss/tensor.py

@@ -92,7 +92,7 @@ def call(
             and self.tensor_name in model_dict
             and "atom_" + self.label_name in label_dict
         ):
-            find_local = label_dict.get("find_atom_" + self.label_name, 1.0)
+            find_local = label_dict.get("find_atom_" + self.label_name, 0.0)
             local_weight = self.local_weight * find_local
             local_pred = xp.reshape(
                 model_dict[self.tensor_name], (-1, natoms, self.tensor_size)
@@ -120,7 +120,7 @@ def call(
             and "global_" + self.tensor_name in model_dict
             and self.label_name in label_dict
         ):
-            find_global = label_dict.get("find_" + self.label_name, 1.0)
+            find_global = label_dict.get("find_" + self.label_name, 0.0)
             global_weight = self.global_weight * find_global
             global_pred = xp.reshape(
                 model_dict["global_" + self.tensor_name], (-1, self.tensor_size)

source/tests/consistent/loss/test_ener.py

@@ -91,13 +91,13 @@ def data(self) -> dict:
 
     @property
     def skip_tf(self) -> bool:
-        (use_huber, enable_atom_ener_coeff, loss_func, f_use_norm, _mae) = self.param
+        (_use_huber, _enable_atom_ener_coeff, loss_func, f_use_norm, _mae) = self.param
         # Skip TF for MAE loss tests (not implemented in TF backend)
         return CommonTest.skip_tf or loss_func == "mae" or f_use_norm
 
     @property
     def skip_pd(self) -> bool:
-        (use_huber, enable_atom_ener_coeff, loss_func, f_use_norm, _mae) = self.param
+        (_use_huber, _enable_atom_ener_coeff, loss_func, f_use_norm, _mae) = self.param
         # Skip Paddle for MAE loss tests (not implemented in Paddle backend)
         return not INSTALLED_PD or loss_func == "mae" or f_use_norm
 
@@ -116,7 +116,7 @@ def skip_pd(self) -> bool:
     args = loss_ener()
 
     def setUp(self) -> None:
-        (use_huber, enable_atom_ener_coeff, loss_func, f_use_norm, mae) = self.param
+        (use_huber, _enable_atom_ener_coeff, loss_func, f_use_norm, mae) = self.param
         # Skip invalid combinations
         if f_use_norm and not (use_huber or loss_func == "mae"):
             self.skipTest("f_use_norm requires either use_huber or loss_func='mae'")
@@ -189,7 +189,7 @@ def build_tf(self, obj: Any, suffix: str) -> tuple[list, dict]:
             for kk, vv in self.label.items()
         }
 
-        loss, more_loss = obj.build(
+        loss, _more_loss = obj.build(
             self.learning_rate,
             [self.natoms],
             predict,
@@ -424,7 +424,7 @@ def build_tf(self, obj: Any, suffix: str) -> tuple[list, dict]:
             for kk, vv in self.label.items()
         }
 
-        loss, more_loss = obj.build(
+        loss, _more_loss = obj.build(
             self.learning_rate,
             [self.natoms],
             predict,

source/tests/pt_expt/loss/test_dos.py

@@ -122,7 +122,7 @@ def test_consistency(self, prec, has_dos, has_ados) -> None:
             k: v.detach().cpu().numpy() if isinstance(v, torch.Tensor) else v
             for k, v in label.items()
         }
-        l_dp, more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
+        l_dp, _more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
 
         np.testing.assert_allclose(
             l0.detach().cpu().numpy(),
@@ -158,7 +158,7 @@ def test_cdf_terms(self, prec) -> None:
             rng, nframes, natoms, numb_dos, dtype, self.device
         )
 
-        l0, more0 = loss0(learning_rate, natoms, model_pred, label)
+        l0, _more0 = loss0(learning_rate, natoms, model_pred, label)
         assert l0.shape == ()
 
         # Compare with dpmodel

source/tests/pt_expt/loss/test_ener.py

@@ -133,7 +133,7 @@ def test_consistency(self, prec, use_huber) -> None:
             k: v.detach().cpu().numpy() if isinstance(v, torch.Tensor) else v
             for k, v in label.items()
         }
-        l_dp, more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
+        l_dp, _more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
 
         np.testing.assert_allclose(
             l0.detach().cpu().numpy(),

source/tests/pt_expt/loss/test_ener_spin.py

@@ -141,7 +141,7 @@ def test_consistency(self, prec, loss_func) -> None:
             k: v.detach().cpu().numpy() if isinstance(v, torch.Tensor) else v
             for k, v in label.items()
         }
-        l_dp, more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
+        l_dp, _more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
 
         np.testing.assert_allclose(
             l0.detach().cpu().numpy(),
@@ -229,7 +229,7 @@ def test_all_masked(self, prec) -> None:
             rng, nframes, natoms, n_magnetic, dtype, self.device
         )
 
-        l0, more0 = loss0(learning_rate, natoms, model_pred, label)
+        l0, _more0 = loss0(learning_rate, natoms, model_pred, label)
         assert l0.shape == ()
 
         # Compare with dpmodel

source/tests/pt_expt/loss/test_property.py

@@ -110,7 +110,7 @@ def test_consistency(self, prec, loss_func) -> None:
         dp_loss = PropertyLossDP.deserialize(loss0.serialize())
         model_pred_np = {k: v.detach().cpu().numpy() for k, v in model_pred.items()}
         label_np = {k: v.detach().cpu().numpy() for k, v in label.items()}
-        l_dp, more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
+        l_dp, _more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
 
         # Use relative tolerance: extreme out_std values (e.g. 0.001) can produce
         # large loss values where torch/numpy accumulation order differs at machine epsilon.

source/tests/pt_expt/loss/test_tensor.py

@@ -129,7 +129,7 @@ def test_consistency(self, prec, has_local, has_global) -> None:
             k: v.detach().cpu().numpy() if isinstance(v, torch.Tensor) else v
             for k, v in label.items()
         }
-        l_dp, more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
+        l_dp, _more_dp = dp_loss(learning_rate, natoms, model_pred_np, label_np)
 
         np.testing.assert_allclose(
             l0.detach().cpu().numpy(),
@@ -174,7 +174,7 @@ def test_with_atomic_weight(self, prec) -> None:
             rng.random((nframes, natoms)), dtype=dtype, device=self.device
         )
 
-        l0, more0 = loss0(learning_rate, natoms, model_pred, label)
+        l0, _more0 = loss0(learning_rate, natoms, model_pred, label)
         assert l0.shape == ()
 
         # Compare with dpmodel