MEDfl 2.0.4.dev0__py3-none-any.whl → 2.0.4.dev2__py3-none-any.whl

Medfl/LearningManager/flpipeline.py

@@ -1,192 +0,0 @@
-import datetime
-from typing import List
-import json
-import pandas as pd
-
-
-# File: create_query.py
-from sqlalchemy import text
-from torch.utils.data import DataLoader, TensorDataset
-import torch 
-
-from MEDfl.LearningManager.server import FlowerServer
-from MEDfl.LearningManager.utils import params, test
-from MEDfl.NetManager.net_helper import get_flpipeline_from_name
-from MEDfl.NetManager.net_manager_queries import (CREATE_FLPIPELINE_QUERY,
-                                                  DELETE_FLPIPELINE_QUERY , CREATE_TEST_RESULTS_QUERY)
-from MEDfl.NetManager.database_connector import DatabaseManager
-
-def create_query(name, description, creation_date, result):
-    query = text(
-        f"INSERT INTO FLpipeline(name, description, creation_date, results) "
-        f"VALUES ('{name}', '{description}', '{creation_date}', '{result}')"
-    )
-    return query
-
-
-
-class FLpipeline:
-    """
-    FLpipeline class for managing Federated Learning pipelines.
-
-    Attributes:
-        name (str): The name of the FLpipeline.
-        description (str): A description of the FLpipeline.
-        server (FlowerServer): The FlowerServer object associated with the FLpipeline.
-
-    Methods:
-        __init__(self, name: str, description: str, server: FlowerServer) -> None:
-            Initialize FLpipeline with the specified name, description, and server.
-  
-
-    """
-
-    def __init__(
-        self, name: str, description: str, server: FlowerServer
-    ) -> None:
-        self.name = name
-        self.description = description
-        self.server = server
-        self.validate()
-
-        db_manager = DatabaseManager()
-        db_manager.connect()
-        self.eng = db_manager.get_connection()
-
-    def validate(self) -> None:
-        """
-        Validate the name, description, and server attributes.
-        Raises:
-            TypeError: If the name is not a string, the description is not a string,
-                      or the server is not a FlowerServer object.
-        """
-        if not isinstance(self.name, str):
-            raise TypeError("name argument must be a string")
-
-        if not isinstance(self.description, str):
-            raise TypeError("description argument must be a string")
-
-        # if not isinstance(self.server, FlowerServer):
-        #     raise TypeError("server argument must be a FlowerServer")
-
-    def create(self, result: str) -> None:
-        """
-        Create a new FLpipeline entry in the database with the given result.
-
-        Args:
-            result (str): The result string to store in the database.
-
-        """
-        creation_date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        query = CREATE_FLPIPELINE_QUERY.format(
-            name=self.name,
-            description=self.description,
-            creation_date=creation_date,
-            result=result,
-        )
-        self.eng.execute(text(query))
-        self.id = get_flpipeline_from_name(self.name)
-        try:
-            self.server.fed_dataset.update(
-                FLpipeId=self.id, FedId=self.server.fed_dataset.id
-            )
-        except:
-            pass
-
-    def delete(self) -> None:
-        """
-        Delete the FLpipeline entry from the database based on its name.
-
-        Note: This is a placeholder method and needs to be implemented based on your specific database setup.
-
-        """
-        # Placeholder code for deleting the FLpipeline entry from the database based on the name.
-        # You need to implement the actual deletion based on your database setup.
-        self.eng.execute(DELETE_FLPIPELINE_QUERY.format(self.name))
-
-
-    def test_by_node(self, node_name: str, test_frac=1) -> dict:
-        """
-        Test the FLpipeline by node with the specified test_frac.
-
-        Args:
-            node_name (str): The name of the node to test.
-            test_frac (float, optional): The fraction of the test data to use. Default is 1.
-
-        Returns:
-            dict: A dictionary containing the node name and the classification report.
-
-        """
-        idx = self.server.fed_dataset.test_nodes.index(node_name)
-        global_model, test_loader = (
-            self.server.global_model,
-            self.server.fed_dataset.testloaders[idx],
-        )
-        
-        # Move model to GPU if available
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        global_model.model.to(device)
-        
-        # Prepare test data
-        test_data = test_loader.dataset
-        num_samples = int(test_frac * len(test_data))
-        test_data = TensorDataset(test_data[:num_samples][0].to(device), test_data[:num_samples][1].to(device))
-        
-        # Create DataLoader for test data
-        test_loader = DataLoader(test_data, batch_size=params["test_batch_size"])
-
-        # Perform testing
-        classification_report = test(model=global_model.model, test_loader=test_loader, device=device)
-
-        return {
-            "node_name": node_name,
-            "classification_report": str(classification_report),
-        }
-
-
-    def auto_test(self, test_frac=1) -> List[dict]:
-        """
-        Automatically test the FLpipeline on all nodes with the specified test_frac.
-
-        Args:
-            test_frac (float, optional): The fraction of the test data to use. Default is 1.
-
-        Returns:
-            List[dict]: A list of dictionaries containing the node names and the classification reports.
-
-        """
-        result = [
-            self.test_by_node(node, test_frac)
-            for node in self.server.fed_dataset.test_nodes
-        ]
-        self.create("\n".join(str(res).replace("'", '"') for res in result))
-
-        # stockage des resultats des tests
-        for entry in result:
-           node_name = entry['node_name']
-           classification_report_str = entry['classification_report']
-
-           # Convert the 'classification_report' string to a dictionary
-           classification_report_dict = json.loads(classification_report_str.replace("'", "\""))
-           try:
-               # Insert record into the 'testResults' table
-               query = CREATE_TEST_RESULTS_QUERY.format(
-                      pipelineId = self.id, 
-                      nodeName = node_name , 
-                      confusion_matrix = json.dumps(classification_report_dict['confusion matrix']), 
-                      accuracy =classification_report_dict['Accuracy'] , 
-                      sensivity = classification_report_dict['Sensitivity/Recall'] ,
-                      ppv = classification_report_dict['PPV/Precision'] ,
-                      npv= classification_report_dict['NPV'] ,
-                      f1score= classification_report_dict['F1-score'] ,
-                      fpr= classification_report_dict['False positive rate'] ,
-                      tpr= classification_report_dict['True positive rate'] 
-                )
-               self.eng.execute(text(query))
-           except Exception as e:
-                # This block will catch any other exceptions
-                print(f"An unexpected error occurred: {e}")
-               
-           
-
-        return result

Medfl/LearningManager/model.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-# froked from https://github.com/pythonlessons/mltu/blob/main/mltu/torch/model.py
-
-import typing
-from collections import OrderedDict
-from typing import Dict, List, Optional, Tuple
-
-import numpy as np
-import torch
-import torch.nn as nn
-from sklearn.metrics import accuracy_score,roc_auc_score
-
-from .utils import params
-
-
-class Model:
-    """
-    Model class for training and testing PyTorch neural networks.
-
-    Attributes:
-        model (torch.nn.Module): PyTorch neural network.
-        optimizer (torch.optim.Optimizer): PyTorch optimizer.
-        criterion (typing.Callable): Loss function.
-    """
-
-    def __init__(
-        self,
-        model: torch.nn.Module,
-        optimizer: torch.optim.Optimizer,
-        criterion: typing.Callable,
-    ) -> None:
-        """
-        Initialize Model class with the specified model, optimizer, and criterion.
-
-        Args:
-            model (torch.nn.Module): PyTorch neural network.
-            optimizer (torch.optim.Optimizer): PyTorch optimizer.
-            criterion (typing.Callable): Loss function.
-        """
-        self.model = model
-        self.optimizer = optimizer
-        self.criterion = criterion
-        # Get device on which model is running
-        self.validate()
-
-    def validate(self) -> None:
-        """
-        Validate model and optimizer.
-        """
-        if not isinstance(self.model, torch.nn.Module):
-            raise TypeError("model argument must be a torch.nn.Module")
-
-        if not isinstance(self.optimizer, torch.optim.Optimizer):
-            raise TypeError(
-                "optimizer argument must be a torch.optim.Optimizer"
-            )
-
-    def get_parameters(self) -> List[np.ndarray]:
-        """
-        Get the parameters of the model as a list of NumPy arrays.
-
-        Returns:
-            List[np.ndarray]: The parameters of the model as a list of NumPy arrays.
-        """
-        return [
-            val.cpu().numpy() for _, val in self.model.state_dict().items()
-        ]
-
-    def set_parameters(self, parameters: List[np.ndarray]) -> None:
-        """
-        Set the parameters of the model from a list of NumPy arrays.
-
-        Args:
-            parameters (List[np.ndarray]): The parameters to be set.
-        """
-        params_dict = zip(self.model.state_dict().keys(), parameters)
-        state_dict = OrderedDict({k: torch.Tensor(v) for k, v in params_dict})
-        self.model.load_state_dict(state_dict, strict=True)
-
-    def train(
-        self, train_loader, epoch, device, privacy_engine, diff_priv=False
-    ) -> float:
-        """
-        Train the model on the given train_loader for one epoch.
-
-        Args:
-            train_loader: The data loader for training data.
-            epoch (int): The current epoch number.
-            device: The device on which to perform the training.
-            privacy_engine: The privacy engine used for differential privacy (if enabled).
-            diff_priv (bool, optional): Whether differential privacy is used. Default is False.
-
-        Returns:
-            float: The value of epsilon used in differential privacy.
-        """
-        self.model.train()
-        epsilon = 0
-        losses = []
-        top1_acc = []
-
-        for i, (X_train, y_train) in enumerate(train_loader):
-            X_train, y_train = X_train.to(device), y_train.to(device)  
-            
-            self.optimizer.zero_grad()
-
-            # compute output
-            y_hat = torch.squeeze(self.model(X_train), 1)
-            loss = self.criterion(y_hat, y_train)
-
-            preds = np.argmax(y_hat.detach().cpu().numpy(), axis=0)
-            labels = y_train.detach().cpu().numpy()
-
-            # measure accuracy and record loss
-            acc = (preds == labels).mean()
-
-            losses.append(loss.item())
-            top1_acc.append(acc)
-
-            loss.backward()
-            self.optimizer.step()
-
-            if diff_priv:
-                epsilon = privacy_engine.get_epsilon(float(params["DELTA"]))
-
-            if (i + 1) % 10 == 0:
-                if diff_priv:
-                    epsilon = privacy_engine.get_epsilon(float(params["DELTA"]))
-                    print(
-                        f"\tTrain Epoch: {epoch} \t"
-                        f"Loss: {np.mean(losses):.6f} "
-                        f"Acc@1: {np.mean(top1_acc) * 100:.6f} "
-                        f"(ε = {epsilon:.2f}, δ = {params['DELTA']})"
-                    )
-                else:
-                    print(
-                        f"\tTrain Epoch: {epoch} \t"
-                        f"Loss: {np.mean(losses):.6f} "
-                        f"Acc@1: {np.mean(top1_acc) * 100:.6f}"
-                    )
-
-        return epsilon
-
-    def evaluate(self, val_loader, device=torch.device("cpu")) -> Tuple[float, float]:
-        """
-        Evaluate the model on the given validation data.
-
-        Args:
-            val_loader: The data loader for validation data.
-            device: The device on which to perform the evaluation. Default is 'cpu'.
-
-        Returns:
-            Tuple[float, float]: The evaluation loss and accuracy.
-        """
-        correct, total, loss, accuracy, auc = 0, 0, 0.0, [], []
-        self.model.eval()
-
-        with torch.no_grad():
-            for X_test, y_test in val_loader:
-                X_test, y_test = X_test.to(device), y_test.to(device)  # Move data to device
-
-                y_hat = torch.squeeze(self.model(X_test), 1)
-               
-                
-                criterion = self.criterion.to(y_hat.device)
-                loss += criterion(y_hat, y_test).item()
-
-
-                # Move y_hat to CPU for accuracy computation
-                y_hat_cpu = y_hat.cpu().detach().numpy()
-                accuracy.append(accuracy_score(y_test.cpu().numpy(), y_hat_cpu.round()))
-
-                # Move y_test to CPU for AUC computation
-                y_test_cpu = y_test.cpu().numpy()
-                y_prob_cpu = y_hat.cpu().detach().numpy()
-                if (len(np.unique(y_test_cpu)) != 1):
-                    auc.append(roc_auc_score(y_test_cpu, y_prob_cpu))
-
-                total += y_test.size(0)
-                correct += np.sum(y_hat_cpu.round() == y_test_cpu)
-
-        loss /= len(val_loader.dataset)
-        return loss, np.mean(accuracy), np.mean(auc)
-
-
-    @staticmethod
-    def save_model(model , model_name:str):
-        """
-        Saves a PyTorch model to a file.
-
-        Args:
-            model (torch.nn.Module): PyTorch model to be saved.
-            model_name (str): Name of the model file.
-
-        Raises:
-            Exception: If there is an issue during the saving process.
-
-        Returns:
-            None
-        """
-        try:
-            torch.save(model, '../../notebooks/.ipynb_checkpoints/trainedModels/' + model_name + ".pth")
-        except Exception as e:
-            raise Exception(f"Error saving the model: {str(e)}")
-    
-    @staticmethod
-    def load_model(model_path: str):
-        """
-        Loads a PyTorch model from a file.
-
-        Args:
-            model_path (str): Path to the model file to be loaded.
-
-        Returns:
-            torch.nn.Module: Loaded PyTorch model.
-        """
-        # Ensure models are loaded onto the CPU when CUDA is not available
-        if torch.cuda.is_available():
-            loaded_model = torch.load(model_path)
-        else:
-            loaded_model = torch.load(model_path, map_location=torch.device('cpu'))
-        return loaded_model
-
-

Medfl/LearningManager/params.yaml

@@ -1,14 +0,0 @@
-DELTA: 1.0e-05
-EPSILON: 5.0
-MAX_GRAD_NORM: 1.0
-diff_privacy: true
-lr: 0.01
-min_evalclient: 2
-num_rounds: 12
-optimizer: SGD
-path_to_master_csv: /home/local/USHERBROOKE/saho6810/MEDfl/code/MEDfl/notebooks/data/masterDataSet/Mimic_ouael.csv
-path_to_test_csv: /home/local/USHERBROOKE/saho6810/MEDfl/code/MEDfl/notebooks/data/masterDataSet/Mimic_train.csv
-task: BinaryClassification
-test_batch_size: 1
-train_batch_size: 32
-train_epochs: 116