MEDfl 0.2.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

Medfl/LearningManager/plot.py

@@ -0,0 +1,229 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+
+from .utils import *
+
+# Replace this with your actual code for data collection
+results_dict = {
+    ("LR: 0.001, Optimizer: Adam", "accuracy"): [0.85, 0.89, 0.92, 0.94, ...],
+    ("LR: 0.001, Optimizer: Adam", "loss"): [0.2, 0.15, 0.1, 0.08, ...],
+    ("LR: 0.01, Optimizer: SGD", "accuracy"): [0.88, 0.91, 0.93, 0.95, ...],
+    ("LR: 0.01, Optimizer: SGD", "loss"): [0.18, 0.13, 0.09, 0.07, ...],
+    ("LR: 0.1, Optimizer: Adam", "accuracy"): [0.82, 0.87, 0.91, 0.93, ...],
+    ("LR: 0.1, Optimizer: Adam", "loss"): [0.25, 0.2, 0.15, 0.12, ...],
+}
+"""
+server should have:
+ #len = num of rounds
+  self.accuracies
+  self.losses
+  
+Client should have
+  # len = num of epochs
+  self.accuracies
+  self.losses
+  self.epsilons
+  self.deltas
+  
+#common things : LR,SGD, Aggregation
+  
+"""
+
+
+class AccuracyLossPlotter:
+    """
+    A utility class for plotting accuracy and loss metrics based on experiment results.
+
+    Args:
+        results_dict (dict): Dictionary containing experiment results organized by parameters and metrics.
+
+    Attributes:
+        results_dict (dict): Dictionary containing experiment results organized by parameters and metrics.
+        parameters (list): List of unique parameters in the experiment results.
+        metrics (list): List of unique metrics in the experiment results.
+        iterations (range): Range of iterations (rounds or epochs) in the experiment.
+    """
+
+    def __init__(self, results_dict):
+        """
+        Initialize the AccuracyLossPlotter with experiment results.
+
+        Args:
+            results_dict (dict): Dictionary containing experiment results organized by parameters and metrics.
+        """
+        self.results_dict = results_dict
+        self.parameters = list(
+            set([param[0] for param in results_dict.keys()])
+        )
+        self.metrics = list(set([param[1] for param in results_dict.keys()]))
+        self.iterations = range(1, len(list(results_dict.values())[0]) + 1)
+
+    def plot_accuracy_loss(self):
+        """
+        Plot accuracy and loss metrics for different parameters.
+        """
+
+        plt.figure(figsize=(8, 6))
+
+        for param in self.parameters:
+            for metric in self.metrics:
+                key = (param, metric)
+                values = self.results_dict[key]
+                plt.plot(
+                    self.iterations,
+                    values,
+                    label=f"{param} ({metric})",
+                    marker="o",
+                    linestyle="-",
+                )
+
+            plt.xlabel("Rounds")
+            plt.ylabel("Accuracy / Loss")
+            plt.title("Accuracy and Loss by Parameters")
+            plt.legend()
+            plt.grid(True)
+            plt.show()
+
+    @staticmethod
+    def plot_global_confusion_matrix(pipeline_name: str):
+        """
+        Plot a global confusion matrix based on pipeline results.
+
+        Args:
+            pipeline_name (str): Name of the pipeline.
+
+        Returns:
+            None
+        """
+        # Get the id of the pipeline by name
+        pipeline_id = get_pipeline_from_name(pipeline_name)
+        # get the confusion matrix pf the pipeline
+        confusion_matrix = get_pipeline_confusion_matrix(pipeline_id)
+
+        # Extracting confusion matrix values
+        TP = confusion_matrix['TP']
+        FP = confusion_matrix['FP']
+        FN = confusion_matrix['FN']
+        TN = confusion_matrix['TN']
+
+        # Creating a matrix for visualization
+        matrix = [[TN, FP],
+                  [FN, TP]]
+
+        # Plotting the confusion matrix as a heatmap
+        plt.figure(figsize=(6, 4))
+        sns.heatmap(matrix, annot=True, fmt='d', cmap='Blues',
+                    xticklabels=['Predicted Negative', 'Predicted Positive'],
+                    yticklabels=['Actual Negative', 'Actual Positive'])
+        plt.title('Global Confusion Matrix')
+        plt.xlabel('Predicted label')
+        plt.ylabel('True label')
+        plt.tight_layout()
+
+        # Display the confusion matrix heatmap
+        plt.show()
+
+    @staticmethod
+    def plot_confusion_Matrix_by_node(node_name: str, pipeline_name: str):
+        """
+        Plot a confusion matrix for a specific node in the pipeline.
+
+        Args:
+            node_name (str): Name of the node.
+            pipeline_name (str): Name of the pipeline.
+
+        Returns:
+            None
+        """
+
+        # Get the id of the pipeline by name
+        pipeline_id = get_pipeline_from_name(pipeline_name)
+        # get the confusion matrix pf the pipeline
+        confusion_matrix = get_node_confusion_matrix(
+            pipeline_id, node_name=node_name)
+
+        # Extracting confusion matrix values
+        TP = confusion_matrix['TP']
+        FP = confusion_matrix['FP']
+        FN = confusion_matrix['FN']
+        TN = confusion_matrix['TN']
+
+        # Creating a matrix for visualization
+        matrix = [[TN, FP],
+                  [FN, TP]]
+
+        # Plotting the confusion matrix as a heatmap
+        plt.figure(figsize=(6, 4))
+        sns.heatmap(matrix, annot=True, fmt='d', cmap='Blues',
+                    xticklabels=['Predicted Negative', 'Predicted Positive'],
+                    yticklabels=['Actual Negative', 'Actual Positive'])
+        plt.title('Confusion Matrix of node: '+node_name)
+        plt.xlabel('Predicted label')
+        plt.ylabel('True label')
+        plt.tight_layout()
+
+        # Display the confusion matrix heatmap
+        plt.show()
+        return
+    
+    @staticmethod
+    def plot_classification_report(pipeline_name: str):
+        """
+        Plot a comparison of classification report metrics between nodes.
+
+        Args:
+            pipeline_name (str): Name of the pipeline.
+
+        Returns:
+            None
+        """
+
+        colors = ['#FF5733', '#6A5ACD', '#3CB371', '#FFD700', '#FFA500', '#8A2BE2', '#00FFFF', '#FF00FF', '#A52A2A', '#00FF00']
+
+        # Get the id of the pipeline by name
+        pipeline_id = get_pipeline_from_name(pipeline_name)
+
+        pipeline_results = get_pipeline_result(pipeline_id)
+
+        nodesList = pipeline_results['nodename']
+        classificationReports = []
+
+        for index, node in enumerate(nodesList):
+            classificationReports.append({
+                'Accuracy': pipeline_results['accuracy'][index],
+                'Sensitivity/Recall': pipeline_results['sensivity'][index],
+                'PPV/Precision': pipeline_results['ppv'][index],
+                'NPV': pipeline_results['npv'][index],
+                'F1-score': pipeline_results['f1score'][index],
+                'False positive rate': pipeline_results['fpr'][index],
+                'True positive rate': pipeline_results['tpr'][index]
+            })
+
+        metric_labels = list(classificationReports[0].keys())  # Assuming both reports have the same keys
+
+        # Set the positions of the bars on the x-axis
+        x = np.arange(len(metric_labels))
+
+        # Set the width of the bars
+        width = 0.35
+
+        plt.figure(figsize=(12, 6))
+
+        for index, report in enumerate(classificationReports):
+            metric = list(report.values())
+            plt.bar(x + (index - len(nodesList) / 2) * width / len(nodesList), metric, width / len(nodesList),
+                    label=nodesList[index], color=colors[index % len(colors)])
+
+        # Adding labels, title, and legend
+        plt.xlabel('Metrics')
+        plt.ylabel('Values')
+        plt.title('Comparison of Classification Report Metrics between Nodes')
+        plt.xticks(ticks=x, labels=metric_labels, rotation=45)
+        plt.legend()
+
+        # Show plot
+        plt.tight_layout()
+        plt.show()
+
+        return 

Medfl/LearningManager/server.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+
+import copy
+from typing import Dict, Optional, Tuple
+
+import flwr as fl
+import torch
+
+from .client import FlowerClient
+from .federated_dataset import FederatedDataset
+from .model import Model
+from .strategy import Strategy
+
+
+class FlowerServer:
+    """
+    A class representing the central server for Federated Learning using Flower.
+
+    Attributes:
+        global_model (Model): The global model that will be federated among clients.
+        strategy (Strategy): The strategy used for federated learning, specifying communication and aggregation methods.
+        num_rounds (int): The number of federated learning rounds to perform.
+        num_clients (int): The number of clients participating in the federated learning process.
+        fed_dataset (FederatedDataset): The federated dataset used for training and evaluation.
+        diff_priv (bool): Whether differential privacy is used during the federated learning process.
+        accuracies (List[float]): A list to store the accuracy of the global model during each round.
+        losses (List[float]): A list to store the loss of the global model during each round.
+        flower_clients (List[FlowerClient]): A list to store the FlowerClient objects representing individual clients.
+     
+    """
+
+    def __init__(
+        self,
+        global_model: Model,
+        strategy: Strategy,
+        num_rounds: int,
+        num_clients: int,
+        fed_dataset: FederatedDataset,
+        diff_privacy: bool = False,
+        client_resources: Optional[Dict[str, float]] = {'num_cpus': 1, 'num_gpus': 0.0}
+    ) -> None:
+        """
+        Initialize a FlowerServer object with the specified parameters.
+
+        Args:
+            global_model (Model): The global model that will be federated among clients.
+            strategy (Strategy): The strategy used for federated learning, specifying communication and aggregation methods.
+            num_rounds (int): The number of federated learning rounds to perform.
+            num_clients (int): The number of clients participating in the federated learning process.
+            fed_dataset (FederatedDataset): The federated dataset used for training and evaluation.
+            diff_privacy (bool, optional): Whether differential privacy is used during the federated learning process.
+                                           Default is False.
+        """
+        self.device = torch.device(
+            f"cuda" if torch.cuda.is_available() else "cpu"
+        )
+        self.global_model = global_model
+        self.params = global_model.get_parameters()
+        self.global_model.model = global_model.model.to(self.device)
+        self.num_rounds = num_rounds
+        self.num_clients = num_clients
+        self.fed_dataset = fed_dataset
+        self.strategy = strategy
+        self.client_resources = client_resources
+        setattr(
+            self.strategy.strategy_object,
+            "min_available_clients",
+            self.num_clients,
+        )
+        setattr(
+            self.strategy.strategy_object,
+            "initial_parameters",
+            fl.common.ndarrays_to_parameters(self.params),
+        )
+        setattr(self.strategy.strategy_object, "evaluate_fn", self.evaluate)
+        self.fed_dataset = fed_dataset
+        self.diff_priv = diff_privacy
+        self.accuracies = []
+        self.losses = []
+        self.auc = []
+        self.flower_clients = []
+        self.validate()
+
+    def validate(self) -> None:
+        """Validate global_model, strategy, num_clients, num_rounds, fed_dataset, diff_privacy"""
+        if not isinstance(self.global_model, Model):
+            raise TypeError("global_model argument must be a Model instance")
+
+        # if not isinstance(self.strategy, Strategy):
+        #     print(self.strategy)
+        #     print(isinstance(self.strategy, Strategy))
+        #     raise TypeError("strategy argument must be a Strategy instance")
+
+        if not isinstance(self.num_clients, int):
+            raise TypeError("num_clients argument must be an int")
+
+        if not isinstance(self.num_rounds, int):
+            raise TypeError("num_rounds argument must be an int")
+
+        if not isinstance(self.diff_priv, bool):
+            raise TypeError("diff_priv argument must be a bool")
+
+    def client_fn(self, cid) -> FlowerClient:
+        """
+        Return a FlowerClient object for a specific client ID.
+
+        Args:
+            cid: The client ID.
+
+        Returns:
+            FlowerClient: A FlowerClient object representing the individual client.
+        """
+        
+        device = torch.device(
+            f"cuda:{int(cid) % 4}" if torch.cuda.is_available() else "cpu"
+        )
+        client_model = copy.deepcopy(self.global_model)
+      
+        trainloader = self.fed_dataset.trainloaders[int(cid)]
+        valloader = self.fed_dataset.valloaders[int(cid)]
+        # this helps in making plots
+        
+        client = FlowerClient(
+            cid, client_model, trainloader, valloader, self.diff_priv
+        )
+        self.flower_clients.append(client)
+        return client
+
+    def evaluate(
+        self,
+        server_round: int,
+        parameters: fl.common.NDArrays,
+        config: Dict[str, fl.common.Scalar],
+    ) -> Optional[Tuple[float, Dict[str, fl.common.Scalar]]]:
+        """
+        Evaluate the global model on the validation dataset and update the accuracies and losses.
+
+        Args:
+            server_round (int): The current round of the federated learning process.
+            parameters (fl.common.NDArrays): The global model parameters.
+            config (Dict[str, fl.common.Scalar]): Configuration dictionary.
+
+        Returns:
+            Optional[Tuple[float, Dict[str, fl.common.Scalar]]]: The evaluation loss and accuracy.
+        """
+        testloader = self.fed_dataset.valloaders[0]
+        
+        self.global_model.set_parameters(
+            parameters
+        )  # Update model with the latest parameters
+        loss, accuracy ,auc = self.global_model.evaluate(testloader, self.device)
+        self.auc.append(auc)
+        self.losses.append(loss)
+        self.accuracies.append(accuracy)
+        
+        return loss, {"accuracy": accuracy}
+
+    def run(self) -> None:
+        """
+        Run the federated learning process using Flower simulation.
+
+        Returns:
+            History: The history of the accuracies and losses during the training of each node 
+        """
+         # Increase the object store memory to the minimum allowed value or higher
+        ray_init_args = {"include_dashboard": False
+                         , "object_store_memory": 78643200
+                        }
+        self.fed_dataset.eng = None
+        
+        history = fl.simulation.start_simulation(
+            client_fn=self.client_fn,
+            num_clients=self.num_clients,
+            config=fl.server.ServerConfig(self.num_rounds),
+            strategy=self.strategy.strategy_object,
+            ray_init_args=ray_init_args,
+            client_resources = self.client_resources
+        )
+
+        return history
+

Medfl/LearningManager/strategy.py

@@ -0,0 +1,82 @@
+
+from collections import OrderedDict
+from typing import Dict, List, Optional, Tuple
+
+import flwr as fl
+import numpy as np
+
+import optuna
+
+
+
+
+class  Strategy:
+    """
+    A class representing a strategy for Federated Learning.
+
+    Attributes:
+        name (str): The name of the strategy. Default is "FedAvg".
+        fraction_fit (float): Fraction of clients to use for training during each round. Default is 1.0.
+        fraction_evaluate (float): Fraction of clients to use for evaluation during each round. Default is 1.0.
+        min_fit_clients (int): Minimum number of clients to use for training during each round. Default is 2.
+        min_evaluate_clients (int): Minimum number of clients to use for evaluation during each round. Default is 2.
+        min_available_clients (int): Minimum number of available clients required to start a round. Default is 2.
+        initial_parameters (Optional[]): The initial parameters of the server model 
+    Methods:
+     
+    """
+
+    def __init__(
+        self,
+        name: str = "FedAvg",
+        fraction_fit: float = 1.0,
+        fraction_evaluate: float = 1.0,
+        min_fit_clients: int = 2,
+        min_evaluate_clients: int = 2,
+        min_available_clients: int = 2,
+        initial_parameters = [],
+        evaluation_methode = "centralized"
+    ) -> None:
+        """
+        Initialize a Strategy object with the specified parameters.
+
+        Args:
+            name (str): The name of the strategy. Default is "FedAvg".
+            fraction_fit (float): Fraction of clients to use for training during each round. Default is 1.0.
+            fraction_evaluate (float): Fraction of clients to use for evaluation during each round. Default is 1.0.
+            min_fit_clients (int): Minimum number of clients to use for training during each round. Default is 2.
+            min_evaluate_clients (int): Minimum number of clients to use for evaluation during each round. Default is 2.
+            min_available_clients (int): Minimum number of available clients required to start a round. Default is 2.
+            initial_parameters (Optional[]): The initial parametres of the server model 
+            evaluation_methode ( "centralized" | "distributed")
+        """
+        self.fraction_fit = fraction_fit
+        self.fraction_evaluate = fraction_evaluate
+        self.min_fit_clients = min_fit_clients
+        self.min_evaluate_clients = min_evaluate_clients
+        self.min_available_clients = min_available_clients
+        self.initial_parameters = initial_parameters
+        self.evaluate_fn = None
+        self.name = name
+    
+    def optuna_fed_optimization(self, direction:str , hpo_rate:int , params_config):
+        self.study = optuna.create_study(direction=direction)
+        self.hpo_rate = hpo_rate
+        self.params_config = params_config
+    
+ 
+    def create_strategy(self):
+        self.strategy_object = self.get_strategy_by_name()(
+            fraction_fit=self.fraction_fit,
+            fraction_evaluate=self.fraction_evaluate,
+            min_fit_clients=self.min_fit_clients,
+            min_evaluate_clients=self.min_evaluate_clients,
+            min_available_clients=self.min_available_clients,
+            initial_parameters=fl.common.ndarrays_to_parameters(self.initial_parameters),
+            evaluate_fn=self.evaluate_fn
+        )
+    def get_strategy_by_name(self):
+        return eval(f"fl.server.strategy.{self.name}")
+    
+    
+