Modernize pre-commit quality checks

.pre-commit-config.yaml

@@ -1,23 +1,26 @@
+minimum_pre_commit_version: "4.6.0"
+
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v6.0.0
     hooks:
       - id: check-merge-conflict
       - id: check-yaml
       - id: end-of-file-fixer
       - id: trailing-whitespace
-      - id: end-of-file-fixer
-      - id: check-yaml
   - repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
+    rev: 8.0.1
     hooks:
       - id: isort
         name: isort
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.7.1
+    rev: v1.20.2
     hooks:
       - id: mypy
+        additional_dependencies: [types-requests]
+        files: ^fedgraph/
+        args: [--config-file=pyproject.toml]
   - repo: https://github.com/psf/black
-    rev: 23.11.0
+    rev: 26.5.1
     hooks:
       - id: black

benchmark/benchmark_NC_FedGraph.py

@@ -69,8 +69,8 @@
 config = attridict(config)
 run_fedgraph(config)
 
-config.iid_beta=100
+config.iid_beta = 100
 run_fedgraph(config)
 
-config.iid_beta=10
-run_fedgraph(config)
+config.iid_beta = 10
+run_fedgraph(config)

benchmark/benchmark_NC_FederatedScope.py

@@ -67,7 +67,7 @@ def load_data(config, client_cfgs=None):
         ds = Planetoid(root="data/", name=PLANETOID_NAMES[name])
         full = ds[0]
         num_classes = int(full.y.max().item()) + 1
-        
+
         # 与data_process.py完全一致：在全部节点上做Dirichlet分割
         split_idxs = label_dirichlet_partition(
             full.y,  # 使用全部节点，不只是训练节点
@@ -77,16 +77,16 @@ def load_data(config, client_cfgs=None):
             config.iid_beta,
             config.distribution_type,
         )
-        
+
         parts = []
         for idxs in split_idxs:
             client_nodes = torch.tensor(idxs)
-            
+
             # 为每个客户端创建mask，但保持原有的train/val/test划分逻辑
             train_mask = torch.zeros(full.num_nodes, dtype=torch.bool)
             val_mask = torch.zeros(full.num_nodes, dtype=torch.bool)
             test_mask = torch.zeros(full.num_nodes, dtype=torch.bool)
-            
+
             # 在客户端节点中，保持原有数据集的train/val/test划分
             for node in client_nodes:
                 if full.train_mask[node]:
@@ -95,20 +95,21 @@ def load_data(config, client_cfgs=None):
                     val_mask[node] = True
                 elif full.test_mask[node]:
                     test_mask[node] = True
-            
+
             parts.append(
                 Data(
                     x=full.x,
                     edge_index=full.edge_index,
                     y=full.y,
                     train_mask=train_mask,  # 保持原有train划分
-                    val_mask=val_mask,      # 保持原有val划分
-                    test_mask=test_mask,    # 保持原有test划分
+                    val_mask=val_mask,  # 保持原有val划分
+                    test_mask=test_mask,  # 保持原有test划分
                 )
             )
-        
+
         data_dict = {
-            i + 1: {
+            i
+            + 1: {
                 "data": parts[i],
                 "train": [parts[i]],
                 "val": [parts[i]],
@@ -139,7 +140,6 @@ def build(cfg_model, input_shape):
 register_model(mkey, builder)
 
 
-
 def run_fedscope_experiment(ds, beta):
     cfg = global_cfg.clone()
     cfg.defrost()
@@ -150,7 +150,7 @@ def run_fedscope_experiment(ds, beta):
     cfg.federate.client_num = CLIENT_NUM
     cfg.federate.total_round_num = TOTAL_ROUNDS
     cfg.federate.make_global_eval = False
-    cfg.federate.process_num = CLIENT_NUM  
+    cfg.federate.process_num = CLIENT_NUM
     cfg.federate.num_cpus_per_trainer = CPUS_PER_TRAINER
     cfg.data.root = "data/"
     cfg.data.type = ds
@@ -180,13 +180,17 @@ def run_fedscope_experiment(ds, beta):
     res = runner.run()
     dur = time.time() - t0
     mem = peak_memory_mb()
-    
+
     # 获取FederatedScope结果
-    
+
     # 从FederatedScope的结果中获取准确率
     # 使用加权平均以与FedGraph保持一致
-    acc = res.get("client_summarized_weighted_avg", {}).get("test_acc", 0.0) if res else 0.0
-
+    acc = (
+        res.get("client_summarized_weighted_avg", {}).get("test_acc", 0.0)
+        if res
+        else 0.0
+    )
+
     acc_pct = acc * 100 if acc <= 1.0 else acc
     model = runner.server.model if runner.server else None
     if model is not None:
@@ -210,8 +214,6 @@ def run_fedscope_experiment(ds, beta):
     }
 
 
-
-
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--use_cluster", action="store_true")

benchmark/benchmark_NC_old.py

@@ -18,9 +18,9 @@
 # Datasets to benchmark
 datasets = [
     "cora",
-    #"citeseer",
-    #"pubmed",
-    #"ogbn-arxiv",
+    # "citeseer",
+    # "pubmed",
+    # "ogbn-arxiv",
 ]  # You can add more: ["cora", "citeseer", "ogbn-arxiv", "ogbn-products"]
 # datasets = ["ogbn-papers100M"]
 # Number of trainers to test

benchmark/exp/config.yaml

@@ -372,4 +372,3 @@ vertical:
   use: false
 wandb:
   use: false
-

benchmark/figure/GC_comm_costs/extract_GC_log.py

@@ -141,18 +141,18 @@ def extract_metrics(exp_text, algorithm, dataset, trainers):
         "Trainers": trainers,
         "Accuracy": accuracy,
         "Train_Time_ms": train_time,
-        "Theoretical_Pretrain_MB": float(theoretical_pretrain[-1])
-        if theoretical_pretrain
-        else 0,
-        "Theoretical_Train_MB": float(theoretical_train[-1])
-        if theoretical_train
-        else 0,
-        "Actual_Pretrain_MB": float(actual_pretrain_match.group(1))
-        if actual_pretrain_match
-        else None,
-        "Actual_Train_MB": float(actual_train_match.group(1))
-        if actual_train_match
-        else None,
+        "Theoretical_Pretrain_MB": (
+            float(theoretical_pretrain[-1]) if theoretical_pretrain else 0
+        ),
+        "Theoretical_Train_MB": (
+            float(theoretical_train[-1]) if theoretical_train else 0
+        ),
+        "Actual_Pretrain_MB": (
+            float(actual_pretrain_match.group(1)) if actual_pretrain_match else None
+        ),
+        "Actual_Train_MB": (
+            float(actual_train_match.group(1)) if actual_train_match else None
+        ),
     }
 
     # Calculate totals
@@ -185,15 +185,19 @@ def generate_accuracy_comparison(df, output_file="gc_accuracy_comparison.pdf"):
     plt.figure(figsize=(14, 8))
     datasets = sorted(
         comparison_data["Dataset"].unique(),
-        key=lambda x: ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
-        if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
-        else 999,
+        key=lambda x: (
+            ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
+            if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
+            else 999
+        ),
     )
     algorithms = sorted(
         comparison_data["Algorithm"].unique(),
-        key=lambda x: ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
-        if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
-        else 999,
+        key=lambda x: (
+            ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
+            if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
+            else 999
+        ),
     )
     x_positions = np.arange(len(datasets))
     width = 0.8 / len(algorithms)
@@ -249,15 +253,19 @@ def generate_train_time_comparison(df, output_file="gc_train_time_comparison.pdf
     plt.figure(figsize=(14, 8))
     datasets = sorted(
         comparison_data["Dataset"].unique(),
-        key=lambda x: ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
-        if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
-        else 999,
+        key=lambda x: (
+            ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
+            if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
+            else 999
+        ),
     )
     algorithms = sorted(
         comparison_data["Algorithm"].unique(),
-        key=lambda x: ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
-        if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
-        else 999,
+        key=lambda x: (
+            ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
+            if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
+            else 999
+        ),
     )
     x_positions = np.arange(len(datasets))
     width = 0.8 / len(algorithms)
@@ -330,16 +338,20 @@ def generate_comm_cost_comparison(df, output_file="gc_comm_cost_comparison.pdf")
     # Datasets and algorithms
     datasets = sorted(
         comparison_data["Dataset"].unique(),
-        key=lambda x: ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
-        if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
-        else 999,
+        key=lambda x: (
+            ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
+            if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
+            else 999
+        ),
     )
 
     algorithms = sorted(
         comparison_data["Algorithm"].unique(),
-        key=lambda x: ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
-        if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
-        else 999,
+        key=lambda x: (
+            ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
+            if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
+            else 999
+        ),
     )
 
     # X-axis setup

benchmark/figure/GC_comm_costs_old/extract_GC_log_old.py

@@ -141,18 +141,18 @@ def extract_metrics(exp_text, algorithm, dataset, trainers):
         "Trainers": trainers,
         "Accuracy": accuracy,
         "Train_Time_ms": train_time,
-        "Theoretical_Pretrain_MB": float(theoretical_pretrain[-1])
-        if theoretical_pretrain
-        else 0,
-        "Theoretical_Train_MB": float(theoretical_train[-1])
-        if theoretical_train
-        else 0,
-        "Actual_Pretrain_MB": float(actual_pretrain_match.group(1))
-        if actual_pretrain_match
-        else None,
-        "Actual_Train_MB": float(actual_train_match.group(1))
-        if actual_train_match
-        else None,
+        "Theoretical_Pretrain_MB": (
+            float(theoretical_pretrain[-1]) if theoretical_pretrain else 0
+        ),
+        "Theoretical_Train_MB": (
+            float(theoretical_train[-1]) if theoretical_train else 0
+        ),
+        "Actual_Pretrain_MB": (
+            float(actual_pretrain_match.group(1)) if actual_pretrain_match else None
+        ),
+        "Actual_Train_MB": (
+            float(actual_train_match.group(1)) if actual_train_match else None
+        ),
     }
 
     # Calculate totals
@@ -195,16 +195,20 @@ def generate_accuracy_comparison(df, output_file="gc_accuracy_comparison.pdf"):
     # Get unique datasets and algorithms in desired order
     datasets = sorted(
         comparison_data["Dataset"].unique(),
-        key=lambda x: ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
-        if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
-        else 999,
+        key=lambda x: (
+            ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
+            if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
+            else 999
+        ),
     )
 
     algorithms = sorted(
         comparison_data["Algorithm"].unique(),
-        key=lambda x: ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
-        if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
-        else 999,
+        key=lambda x: (
+            ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
+            if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
+            else 999
+        ),
     )
 
     # Set x positions
@@ -289,16 +293,20 @@ def generate_train_time_comparison(df, output_file="gc_train_time_comparison.pdf
     # Get unique datasets and algorithms in desired order
     datasets = sorted(
         comparison_data["Dataset"].unique(),
-        key=lambda x: ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
-        if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
-        else 999,
+        key=lambda x: (
+            ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
+            if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
+            else 999
+        ),
     )
 
     algorithms = sorted(
         comparison_data["Algorithm"].unique(),
-        key=lambda x: ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
-        if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
-        else 999,
+        key=lambda x: (
+            ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
+            if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
+            else 999
+        ),
     )
 
     # Set x positions
@@ -390,16 +398,20 @@ def generate_comm_cost_comparison(df, output_file="gc_comm_cost_comparison.pdf")
     # Datasets and algorithms
     datasets = sorted(
         comparison_data["Dataset"].unique(),
-        key=lambda x: ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
-        if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
-        else 999,
+        key=lambda x: (
+            ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"].index(x)
+            if x in ["IMDB-BINARY", "IMDB-MULTI", "MUTAG", "BZR", "COX2"]
+            else 999
+        ),
     )
 
     algorithms = sorted(
         comparison_data["Algorithm"].unique(),
-        key=lambda x: ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
-        if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
-        else 999,
+        key=lambda x: (
+            ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"].index(x)
+            if x in ["FedAvg", "GCFL", "GCFL+", "GCFL+dWs"]
+            else 999
+        ),
     )
 
     # X-axis setup