MEDfl 0.1.0__py3-none-any.whl → 0.1.4__py3-none-any.whl

Medfl/LearningManager/utils.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+
+import pkg_resources
+import torch
+import yaml
+from sklearn.metrics import *
+from yaml.loader import SafeLoader
+
+from scripts.base import *
+import json
+
+
+import pandas as pd
+import numpy as np
+
+yaml_path = pkg_resources.resource_filename(__name__, "params.yaml")
+with open(yaml_path) as g:
+    params = yaml.load(g, Loader=SafeLoader)
+
+global_yaml_path = pkg_resources.resource_filename(__name__, "../../global_params.yaml")
+with open(global_yaml_path) as g:
+    global_params = yaml.load(g, Loader=SafeLoader)
+
+
+def custom_classification_report(y_true, y_pred_prob):
+    """
+    Compute custom classification report metrics including accuracy, sensitivity, specificity, precision, NPV,
+    F1-score, false positive rate, and true positive rate.
+
+    Args:
+        y_true (array-like): True labels.
+        y_pred (array-like): Predicted labels.
+
+    Returns:
+        dict: A dictionary containing custom classification report metrics.
+    """
+    y_pred = (y_pred_prob).round()  # Round absolute values of predicted probabilities to the nearest integer
+
+    auc = roc_auc_score(y_true, y_pred_prob)  # Calculate AUC
+
+    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
+
+    # Accuracy
+    denominator_acc = tp + tn + fp + fn
+    acc = (tp + tn) / denominator_acc if denominator_acc != 0 else 0.0
+
+    # Sensitivity/Recall
+    denominator_sen = tp + fn
+    sen = tp / denominator_sen if denominator_sen != 0 else 0.0
+
+    # Specificity
+    denominator_sp = tn + fp
+    sp = tn / denominator_sp if denominator_sp != 0 else 0.0
+
+    # PPV/Precision
+    denominator_ppv = tp + fp
+    ppv = tp / denominator_ppv if denominator_ppv != 0 else 0.0
+
+#     NPV
+    denominator_npv = tn + fn
+    npv = tn / denominator_npv if denominator_npv != 0 else 0.0
+
+    # F1 Score
+    denominator_f1 = sen + ppv
+    f1 = 2 * (sen * ppv) / denominator_f1 if denominator_f1 != 0 else 0.0
+
+    # False Positive Rate
+    denominator_fpr = fp + tn
+    fpr = fp / denominator_fpr if denominator_fpr != 0 else 0.0
+
+    # True Positive Rate
+    denominator_tpr = tp + fn
+    tpr = tp / denominator_tpr if denominator_tpr != 0 else 0.0
+
+    return {
+        "confusion matrix": {"TP": tp, "FP": fp, "FN": fn, "TN": tn},
+        "Accuracy": round(acc, 3),
+        "Sensitivity/Recall": round(sen, 3),
+        "Specificity": round(sp, 3),
+        "PPV/Precision": round(ppv, 3),
+        "NPV": round(npv, 3),
+        "F1-score": round(f1, 3),
+        "False positive rate": round(fpr, 3),
+        "True positive rate": round(tpr, 3),
+        "auc": auc
+    }
+
+
+def test(model, test_loader, device=torch.device("cpu")):
+    """
+    Evaluate a model using a test loader and return a custom classification report.
+
+    Args:
+        model (torch.nn.Module): PyTorch model to evaluate.
+        test_loader (torch.utils.data.DataLoader): DataLoader for the test dataset.
+        device (torch.device, optional): Device for model evaluation. Default is "cpu".
+
+    Returns:
+        dict: A dictionary containing custom classification report metrics.
+    """
+
+    model.eval()
+    with torch.no_grad():
+        X_test, y_test = test_loader.dataset[:][0].to(device), test_loader.dataset[:][1].to(device)
+        y_hat_prob = torch.squeeze(model(X_test), 1).cpu()
+
+    return custom_classification_report(y_test.cpu().numpy(), y_hat_prob.cpu().numpy())
+
+
+column_map = {"object": "VARCHAR(255)", "int64": "INT", "float64": "FLOAT"}
+
+
+def empty_db():
+    """
+    Empty the database by deleting records from multiple tables and resetting auto-increment counters.
+
+    Returns:
+        None
+    """
+
+    # my_eng.execute(text(f"DELETE FROM  {'DataSets'}"))
+    my_eng.execute(text(f"DELETE FROM {'Nodes'}"))
+    my_eng.execute(text(f"DELETE FROM {'FedDatasets'}"))
+    my_eng.execute(text(f"DELETE FROM {'Networks'}"))
+    my_eng.execute(text(f"DELETE FROM {'FLsetup'}"))
+
+    my_eng.execute(text(f"DELETE FROM {'FLpipeline'}"))
+    my_eng.execute(text(f"ALTER TABLE {'Nodes'} AUTO_INCREMENT = 1"))
+    my_eng.execute(text(f"ALTER TABLE {'Networks'} AUTO_INCREMENT = 1"))
+    my_eng.execute(text(f"ALTER TABLE {'FedDatasets'} AUTO_INCREMENT = 1"))
+    my_eng.execute(text(f"ALTER TABLE {'FLsetup'} AUTO_INCREMENT = 1"))
+    my_eng.execute(text(f"ALTER TABLE {'FLpipeline'} AUTO_INCREMENT = 1"))
+    my_eng.execute(text(f"DELETE FROM {'testResults'}"))
+    my_eng.execute(text(f"DROP TABLE IF EXISTS {'MasterDataset'}"))
+    my_eng.execute(text(f"DROP TABLE IF EXISTS {'DataSets'}"))
+
+def get_pipeline_from_name(name):
+    """
+    Get the pipeline ID from its name in the database.
+
+    Args:
+        name (str): Name of the pipeline.
+
+    Returns:
+        int: ID of the pipeline.
+    """
+
+    NodeId = int(
+        pd.read_sql(
+            text(f"SELECT id FROM FLpipeline WHERE name = '{name}'"), my_eng
+        ).iloc[0, 0]
+    )
+    return NodeId
+
+def get_pipeline_confusion_matrix(pipeline_id):
+    """
+    Get the global confusion matrix for a pipeline based on test results.
+
+    Args:
+        pipeline_id (int): ID of the pipeline.
+
+    Returns:
+        dict: A dictionary representing the global confusion matrix.
+    """
+
+    data = pd.read_sql(
+            text(f"SELECT confusionmatrix FROM testResults WHERE pipelineid = '{pipeline_id}'"), my_eng
+        )
+    
+    # Convert the column of strings into a list of dictionaries representing confusion matrices
+    confusion_matrices = [
+    json.loads(matrix.replace("'", "\"")) for matrix in data['confusionmatrix']
+    ]
+
+    # Initialize variables for global confusion matrix
+    global_TP = global_FP = global_FN = global_TN = 0
+
+    # Iterate through each dictionary and sum the corresponding values for each category
+    for matrix in confusion_matrices:
+        global_TP += matrix['TP']
+        global_FP += matrix['FP']
+        global_FN += matrix['FN']
+        global_TN += matrix['TN']
+
+    # Create a global confusion matrix as a dictionary
+    global_confusion_matrix = {
+        'TP': global_TP,
+        'FP': global_FP,
+        'FN': global_FN,
+        'TN': global_TN
+    }
+    # Return the list of dictionaries representing confusion matrices
+    return global_confusion_matrix
+
+def get_node_confusion_matrix(pipeline_id , node_name):
+    """
+    Get the confusion matrix for a specific node in a pipeline based on test results.
+
+    Args:
+        pipeline_id (int): ID of the pipeline.
+        node_name (str): Name of the node.
+
+    Returns:
+        dict: A dictionary representing the confusion matrix for the specified node.
+    """
+
+    data = pd.read_sql(
+            text(f"SELECT confusionmatrix FROM testResults WHERE pipelineid = '{pipeline_id}' AND nodename = '{node_name}'"), my_eng
+        )
+    
+    # Convert the column of strings into a list of dictionaries representing confusion matrices
+    confusion_matrices = [
+    json.loads(matrix.replace("'", "\"")) for matrix in data['confusionmatrix']
+    ]
+
+  
+    # Return the list of dictionaries representing confusion matrices
+    return confusion_matrices[0]
+
+def get_pipeline_result(pipeline_id):
+    """
+    Get the test results for a pipeline.
+
+    Args:
+        pipeline_id (int): ID of the pipeline.
+
+    Returns:
+        pandas.DataFrame: DataFrame containing test results for the specified pipeline.
+    """
+    data = pd.read_sql(
+            text(f"SELECT * FROM testResults WHERE pipelineid = '{pipeline_id}'"), my_eng
+        )
+    return data

Medfl/NetManager/__init__.py

@@ -0,0 +1,9 @@
+# Medfl/NetworkManager/__init__.py
+
+# Import modules from this package
+from .dataset import *
+from .flsetup import *
+from .net_helper import *
+from .net_manager_queries import *
+from .network import *
+from .node import *

Medfl/NetManager/dataset.py

@@ -0,0 +1,91 @@
+import pandas as pd
+from sqlalchemy import text
+
+from scripts.base import my_eng
+from .net_helper import *
+from .net_manager_queries import (DELETE_DATASET, INSERT_DATASET,
+                                  SELECT_ALL_DATASET_NAMES)
+
+
+class DataSet:
+    def __init__(self, name: str, path: str, engine=None):
+        """
+        Initialize a DataSet object.
+
+        :param name: The name of the dataset.
+        :type name: str
+        :param path: The file path of the dataset CSV file.
+        :type path: str
+        """
+        self.name = name
+        self.path = path
+        self.engine = engine if engine is not None else my_eng
+
+    def validate(self):
+        """
+        Validate name and path attributes.
+
+        :raises TypeError: If name or path is not a string.
+        """
+        if not isinstance(self.name, str):
+            raise TypeError("name argument must be a string")
+
+        if not isinstance(self.path, str):
+            raise TypeError("path argument must be a string")
+
+    def upload_dataset(self, NodeId=-1):
+        """
+        Upload the dataset to the database.
+
+        :param NodeId: The NodeId associated with the dataset.
+        :type NodeId: int
+
+        Notes:
+        - Assumes the file at self.path is a valid CSV file.
+        - The dataset is uploaded to the 'DataSets' table in the database.
+        """
+
+        data_df = pd.read_csv(self.path)
+        nodeId = NodeId
+        columns = data_df.columns.tolist()
+        
+
+        data_df = process_eicu(data_df)
+        for index, row in data_df.iterrows():
+            query_1 = "INSERT INTO DataSets(DataSetName,nodeId," + "".join(
+                f"{x}," for x in columns
+            )
+            query_2 = f" VALUES ('{self.name}',{nodeId}, " + "".join(
+                f"{is_str(data_df, row, x)}," for x in columns
+            )
+            query = query_1[:-1] + ")" + query_2[:-1] + ")"
+             
+            self.engine.execute(text(query))
+
+    def delete_dataset(self):
+        """
+        Delete the dataset from the database.
+
+        Notes:
+        - Assumes the dataset name is unique in the 'DataSets' table.
+        """
+        self.engine.execute(text(DELETE_DATASET), {"name": self.name})
+
+    def update_data(self):
+        """
+        Update the data in the dataset.
+
+        Not implemented yet.
+        """
+        pass
+
+    @staticmethod
+    def list_alldatasets(engine):
+        """
+        List all dataset names from the 'DataSets' table.
+
+        :returns: A DataFrame containing the names of all datasets in the 'DataSets' table.
+        :rtype: pd.DataFrame
+        """
+        res = pd.read_sql(text(SELECT_ALL_DATASET_NAMES), engine)
+        return res

Medfl/NetManager/flsetup.py

@@ -0,0 +1,304 @@
+from datetime import datetime
+
+
+from torch.utils.data import random_split, DataLoader, Dataset
+
+from Medfl.LearningManager.federated_dataset import FederatedDataset
+from .net_helper import *
+from .net_manager_queries import *  # Import the sql_queries module
+from .network import Network
+
+from .node import Node
+
+
+class FLsetup:
+    def __init__(self, name: str, description: str, network: Network):
+        """Initialize a Federated Learning (FL) setup.
+
+        Args:
+            name (str): The name of the FL setup.
+            description (str): A description of the FL setup.
+            network (Network): An instance of the Network class representing the network architecture.
+        """
+        self.name = name
+        self.description = description
+        self.network = network
+        self.column_name = None
+        self.auto = 1 if self.column_name is not None else 0
+        self.validate()
+        self.fed_dataset = None
+
+    def validate(self):
+        """Validate name, description, and network."""
+        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.network, Network):
+            raise TypeError(
+                "network argument must be a Medfl.NetManager.Network "
+            )
+
+    def create(self):
+        """Create an FL setup."""
+        creation_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        netid = get_netid_from_name(self.network.name)
+        my_eng.execute(
+            text(CREATE_FLSETUP_QUERY),
+            {
+                "name": self.name,
+                "description": self.description,
+                "creation_date": creation_date,
+                "net_id": netid,
+                "column_name": self.column_name,
+            },
+        )
+        self.id = get_flsetupid_from_name(self.name)
+
+    def delete(self):
+        """Delete the FL setup."""
+        if self.fed_dataset is not None:
+            self.fed_dataset.delete_Flsetup(FLsetupId=self.id)
+        my_eng.execute(text(DELETE_FLSETUP_QUERY), {"name": self.name})
+
+    @classmethod
+    def read_setup(cls, FLsetupId: int):
+        """Read the FL setup by FLsetupId.
+
+        Args:
+            FLsetupId (int): The id of the FL setup to read.
+
+        Returns:
+            FLsetup: An instance of the FLsetup class with the specified FLsetupId.
+        """
+        res = pd.read_sql(
+            text(READ_SETUP_QUERY), my_eng, params={"flsetup_id": FLsetupId}
+        ).iloc[0]
+        
+        network_res = pd.read_sql(
+            text(READ_NETWORK_BY_ID_QUERY),
+            my_eng,
+            params={"net_id": int(res["NetId"])},
+        ).iloc[0]
+        network = Network(network_res["NetName"])
+        setattr(network, "id", res["NetId"])
+        fl_setup = cls(res["name"], res["description"], network)
+        if res["column_name"] == str(None):
+            res["column_name"] = None
+        setattr(fl_setup, "column_name", res["column_name"])
+        setattr(fl_setup, "id", res["FLsetupId"])
+
+        return fl_setup
+
+    @staticmethod
+    def list_allsetups():
+        """List all the FL setups.
+
+        Returns:
+            DataFrame: A DataFrame containing information about all the FL setups.
+        """
+        Flsetups = pd.read_sql(text(READ_ALL_SETUPS_QUERY), my_eng)
+        return Flsetups
+
+    def create_nodes_from_master_dataset(self, params_dict: dict):
+        """Create nodes from the master dataset.
+
+        Args:
+            params_dict (dict): A dictionary containing parameters for node creation.
+                - column_name (str): The name of the column in the MasterDataset used to create nodes.
+                - train_nodes (list): A list of node names that will be used for training.
+                - test_nodes (list): A list of node names that will be used for testing.
+
+        Returns:
+            list: A list of Node instances created from the master dataset.
+        """
+        assert "column_name" in params_dict.keys()
+        column_name, train_nodes, test_nodes = (
+            params_dict["column_name"],
+            params_dict["train_nodes"],
+            params_dict["test_nodes"],
+        )
+        self.column_name = column_name
+        self.auto = 1
+
+        # Update the Column name of the auto flSetup
+        query = f"UPDATE FLsetup SET column_name = '{column_name}' WHERE name = '{self.name}'"
+        my_eng.execute(text(query))
+        
+
+        # Add Network to DB
+        # self.network.create_network()
+
+        netid = get_netid_from_name(self.network.name)
+
+        assert self.network.mtable_exists == 1
+        node_names = pd.read_sql(
+            text(READ_DISTINCT_NODES_QUERY.format(column_name)), my_eng
+        )
+
+        nodes = [Node(val[0], 1) for val in node_names.values.tolist()]
+
+        used_nodes = []
+
+        for node in nodes:
+            if node.name in train_nodes:
+                node.train = 1
+                node.create_node(netid)
+                used_nodes.append(node)
+            if node.name in test_nodes:
+                node.train =0
+                node.create_node(netid) 
+                used_nodes.append(node)
+        return used_nodes
+
+    def create_dataloader_from_node(
+        self,
+        node: Node,
+        output,
+        fill_strategy="mean",  fit_encode=[], to_drop=[],
+        train_batch_size: int = 32,
+        test_batch_size: int = 1,
+        split_frac: float = 0.2,
+        dataset: Dataset = None,
+
+    ):
+        """Create DataLoader from a Node.
+
+        Args:
+            node (Node): The node from which to create DataLoader.
+            train_batch_size (int): The batch size for training data.
+            test_batch_size (int): The batch size for test data.
+            split_frac (float): The fraction of data to be used for training.
+            dataset (Dataset): The dataset to use. If None, the method will read the dataset from the node.
+
+        Returns:
+            DataLoader: The DataLoader instances for training and testing.
+        """
+        if dataset is None:
+            if self.column_name is not None:
+                dataset = process_data_after_reading(
+                    node.get_dataset(self.column_name), output, fill_strategy=fill_strategy, fit_encode=fit_encode, to_drop=to_drop
+                )
+            else:
+                dataset = process_data_after_reading(
+                    node.get_dataset(), output, fill_strategy=fill_strategy, fit_encode=fit_encode, to_drop=to_drop)
+
+        dataset_size = len(dataset)
+        traindata_size = int(dataset_size * (1 - split_frac))
+        traindata, testdata = random_split(
+            dataset, [traindata_size, dataset_size - traindata_size]
+        )
+        trainloader, testloader = DataLoader(
+            traindata, batch_size=train_batch_size
+        ), DataLoader(testdata, batch_size=test_batch_size)
+        return trainloader, testloader
+
+    def create_federated_dataset(
+        self, output, fill_strategy="mean",  fit_encode=[], to_drop=[], val_frac=0.1, test_frac=0.2
+    ) -> FederatedDataset:
+        """Create a federated dataset.
+
+        Args:
+            output (string): the output feature of the dataset
+            val_frac (float): The fraction of data to be used for validation.
+            test_frac (float): The fraction of data to be used for testing.
+
+        Returns:
+            FederatedDataset: The FederatedDataset instance containing train, validation, and test data.
+        """
+        
+        if not self.column_name:
+            to_drop.extend(["DataSetName" , "NodeId" , "DataSetId"])
+        else :
+            to_drop.extend(["PatientId"]) 
+            
+        netid = self.network.id
+        train_nodes = pd.read_sql(
+            text(
+                f"SELECT Nodes.NodeName  FROM Nodes WHERE Nodes.NetId = {netid} AND Nodes.train = 1 "
+            ),
+            my_eng,
+        )
+        test_nodes = pd.read_sql(
+            text(
+                f"SELECT Nodes.NodeName  FROM Nodes WHERE Nodes.NetId = {netid} AND Nodes.train = 0 "
+            ),
+            my_eng,
+        )
+
+        train_nodes = [
+            Node(val[0], 1, test_frac) for val in train_nodes.values.tolist()
+        ]
+        test_nodes = [Node(val[0], 0) for val in test_nodes.values.tolist()]
+
+        trainloaders, valloaders, testloaders = [], [], []
+        # if len(test_nodes) == 0:
+        #     raise "test node empty"
+        if test_nodes is None:
+            _, testloader = self.create_dataloader_from_node(
+                train_nodes[0], output, fill_strategy=fill_strategy, fit_encode=fit_encode, to_drop=to_drop)
+            testloaders.append(testloader)
+        else:
+            for train_node in train_nodes:
+                train_valloader, testloader = self.create_dataloader_from_node(
+                    train_node, output, fill_strategy=fill_strategy,
+                    fit_encode=fit_encode, to_drop=to_drop,)
+                trainloader, valloader = self.create_dataloader_from_node(
+                    train_node,
+                    output, fill_strategy=fill_strategy, fit_encode=fit_encode, to_drop=to_drop,
+                    test_batch_size=32,
+                    split_frac=val_frac,
+                    dataset=train_valloader.dataset,
+                )
+                trainloaders.append(trainloader)
+                valloaders.append(valloader)
+                testloaders.append(testloader)
+
+            for test_node in test_nodes:
+                _, testloader = self.create_dataloader_from_node(
+                    test_node, output, fill_strategy=fill_strategy, fit_encode=fit_encode, to_drop=to_drop, split_frac=1.0
+                )
+                testloaders.append(testloader)
+        train_nodes_names = [node.name for node in train_nodes]
+        test_nodes_names = train_nodes_names + [
+            node.name for node in test_nodes
+        ]
+        
+        # test_nodes_names = [
+        #     node.name for node in test_nodes
+        # ]
+
+        # Add FlSetup on to the DataBase
+        # self.create()
+
+        # self.network.update_network(FLsetupId=self.id)
+        fed_dataset = FederatedDataset(
+            self.name + "_Feddataset",
+            train_nodes_names,
+            test_nodes_names,
+            trainloaders,
+            valloaders,
+            testloaders,
+        )
+        self.fed_dataset = fed_dataset
+        self.fed_dataset.create(self.id)
+        return self.fed_dataset
+    
+    
+
+
+    def get_flDataSet(self):
+        """
+        Retrieve the federated dataset associated with the FL setup using the FL setup's name.
+ 
+        Returns:
+            pandas.DataFrame: DataFrame containing the federated dataset information.
+        """
+        return pd.read_sql(
+            text(
+                f"SELECT * FROM FedDatasets WHERE FLsetupId = {get_flsetupid_from_name(self.name)}"
+            ),
+            my_eng,
+        )