uvx ruff format.

Author: baochunli

examples/gradient_leakage_attacks/defense/Outpost/perturb.py

@@ -52,8 +52,9 @@ def noise(dy_dx: list, risk: list):
             noise_mask, device=grad.device, dtype=grad.dtype
         )
         gauss_noise = noise_base * noise_mask_tensor
-        grad = torch.as_tensor(
-            grad_tensor, device=grad.device, dtype=torch.float32
-        ) + gauss_noise
+        grad = (
+            torch.as_tensor(grad_tensor, device=grad.device, dtype=torch.float32)
+            + gauss_noise
+        )
 
     return dy_dx

examples/gradient_leakage_attacks/dlg_trainer.py

@@ -332,9 +332,7 @@ def on_train_step_end(self, trainer, config, batch, loss, **kwargs) -> None:
                         flattened_weights, Config().algorithm.prune_pct
                     )
                     pruned = np.where(np.abs(grad_tensor) < thresh, 0, grad_tensor)
-                    gradient_list[index] = torch.from_numpy(pruned).to(
-                        trainer.device
-                    )
+                    gradient_list[index] = torch.from_numpy(pruned).to(trainer.device)
 
             elif (
                 defense_name == "DP"

examples/model_search/fedtp/fedtp_algorithm.py

@@ -30,7 +30,9 @@ def __init__(self, trainer: Trainer):
         super().__init__(trainer)
         self.current_weights: OrderedDict[str, Tensor] | None = None
 
-    def generate_attention(self, hnet: Module, client_id: int) -> OrderedDict[str, Tensor]:
+    def generate_attention(
+        self, hnet: Module, client_id: int
+    ) -> OrderedDict[str, Tensor]:
         """Generated the customized attention of each client."""
         weights = hnet(
             torch.tensor([client_id - 1], dtype=torch.long).to(Config().device())

examples/model_search/fedtp/hypernetworks.py

@@ -93,7 +93,8 @@ def forward(self, idx) -> OrderedDictType[str, Tensor]:
             else:
                 layer_list = cast(nn.ModuleList, layer_d_qkv_value_hyper)
                 layer_d_qkv_value = [
-                    layer(features).view(self.inner_dim, self.dim) for layer in layer_list
+                    layer(features).view(self.inner_dim, self.dim)
+                    for layer in layer_list
                 ]
                 name = Config().parameters.hypernet.attention % (dep, dep, dep)
                 names = name.split(",")

examples/server_aggregation/moon/moon_algorithm.py

@@ -20,7 +20,9 @@ class Algorithm(fedavg.Algorithm):
     """Algorithm providing MOON aggregation utilities."""
 
     @staticmethod
-    def _cast_tensor_like(tensor: torch.Tensor, reference: torch.Tensor) -> torch.Tensor:
+    def _cast_tensor_like(
+        tensor: torch.Tensor, reference: torch.Tensor
+    ) -> torch.Tensor:
         """Cast a tensor to match a reference dtype (handles bool/int safely)."""
         if tensor.dtype == reference.dtype:
             return tensor

plato/servers/strategies/aggregation/pfedgraph.py

@@ -95,8 +95,7 @@ def setup(self, context: ServerContext) -> None:
         if algorithm is not None and hasattr(algorithm, "extract_weights"):
             baseline = algorithm.extract_weights()
             self.initial_weights = {
-                name: tensor.detach().cpu().clone()
-                for name, tensor in baseline.items()
+                name: tensor.detach().cpu().clone() for name, tensor in baseline.items()
             }
 
         if self.total_clients > 0:
@@ -257,8 +256,7 @@ def _aggregate_client_weights(
         for client_id in selected_ids:
             row = graph[client_id, selected_ids]
             aggregated = {
-                name: torch.zeros_like(value)
-                for name, value in weights_cpu[0].items()
+                name: torch.zeros_like(value) for name, value in weights_cpu[0].items()
             }
 
             for neighbor_idx, weight in enumerate(row):
@@ -283,10 +281,13 @@ def _aggregate_global_weights(
         for idx, client_weights in enumerate(aggregated_weights):
             weight = float(sample_weights[idx])
             for name, tensor in client_weights.items():
-                global_weights[name] += tensor.to(
-                    dtype=baseline_weights[name].dtype,
-                    device=baseline_weights[name].device,
-                ) * weight
+                global_weights[name] += (
+                    tensor.to(
+                        dtype=baseline_weights[name].dtype,
+                        device=baseline_weights[name].device,
+                    )
+                    * weight
+                )
 
         return global_weights
 

plato/trainers/huggingface.py

@@ -415,6 +415,7 @@ def on_train_step_end(self, trainer, config, batch, loss, **kwargs):
 
 class Trainer(ComposableTrainer):
     """Composable HuggingFace trainer built on Plato's strategy API."""
+
     training_args: TrainingArguments
 
     def __init__(self, model=None, callbacks=None):

plato/trainers/strategies/algorithms/fedala_strategy.py

@@ -81,15 +81,11 @@ def __init__(
         if eta <= 0:
             raise ValueError(f"eta must be positive, got {eta}")
         if rand_percent < 0 or rand_percent > 100:
-            raise ValueError(
-                f"rand_percent must be in [0, 100], got {rand_percent}"
-            )
+            raise ValueError(f"rand_percent must be in [0, 100], got {rand_percent}")
         if threshold < 0:
             raise ValueError(f"threshold must be non-negative, got {threshold}")
         if num_pre_loss < 1:
-            raise ValueError(
-                f"num_pre_loss must be >= 1, got {num_pre_loss}"
-            )
+            raise ValueError(f"num_pre_loss must be >= 1, got {num_pre_loss}")
         if max_ala_epochs is not None and max_ala_epochs < 1:
             raise ValueError(
                 f"max_ala_epochs must be >= 1 or None, got {max_ala_epochs}"
@@ -378,9 +374,7 @@ def _move_to_device(value: Any, device: torch.device) -> Any:
         if isinstance(value, torch.Tensor):
             return value.to(device)
         if isinstance(value, tuple):
-            return tuple(
-                FedALAUpdateStrategy._move_to_device(v, device) for v in value
-            )
+            return tuple(FedALAUpdateStrategy._move_to_device(v, device) for v in value)
         if isinstance(value, list):
             return [FedALAUpdateStrategy._move_to_device(v, device) for v in value]
         if isinstance(value, dict):
@@ -450,9 +444,7 @@ def _adaptive_local_aggregation(
                 examples = self._move_to_device(
                     examples, next(model_t.parameters()).device
                 )
-                labels = self._move_to_device(
-                    labels, next(model_t.parameters()).device
-                )
+                labels = self._move_to_device(labels, next(model_t.parameters()).device)
 
                 optimizer.zero_grad()
                 output = model_t(examples)
@@ -526,9 +518,7 @@ def _ensure_weights(self, params: Iterable[torch.Tensor]) -> None:
 
         for weight, param in zip(self.weights, params_list):
             if weight.shape != param.data.shape:
-                self.weights = [
-                    torch.ones_like(param.data) for param in params_list
-                ]
+                self.weights = [torch.ones_like(param.data) for param in params_list]
                 return
 
 

plato/utils/reinforcement_learning/policies/sac.py

@@ -107,6 +107,7 @@ def forward(self, state, action):
 class GaussianPolicy(nn.Module):
     action_scale: torch.Tensor
     action_bias: torch.Tensor
+
     def __init__(self, num_inputs, num_actions, hidden_dim, action_space=None):
         super().__init__()
 
@@ -160,6 +161,7 @@ def sample(self, state) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
 class DeterministicPolicy(nn.Module):
     action_scale: torch.Tensor
     action_bias: torch.Tensor
+
     def __init__(self, num_inputs, num_actions, hidden_dim, action_space=None):
         super().__init__()
         self.linear1 = nn.Linear(num_inputs, hidden_dim)