MEDfl 0.1.31__py3-none-any.whl → 0.1.33__py3-none-any.whl

scripts/base.py

@@ -1,30 +1,30 @@
-import mysql.connector
-from sqlalchemy import create_engine, text
-from configparser import ConfigParser
-import yaml
-import pkg_resources
-import os
-
-# Get the directory of the current script
-current_directory = os.path.dirname(os.path.abspath(__file__))
-
-# Load configuration from the config file
-config_file_path = os.path.join(current_directory, 'db_config.ini')
-
-config = ConfigParser()
-config.read(config_file_path)
-mysql_config = config['mysql']
-
-
-
-connection_string = (
-    f"mysql+mysqlconnector://{mysql_config['user']}:{mysql_config['password']}@"
-    f"{mysql_config['host']}:{mysql_config['port']}/{mysql_config['database']}"
-)
-
-eng = create_engine(
-    connection_string,
-    execution_options={"autocommit": True},
-)
-
+import mysql.connector
+from sqlalchemy import create_engine, text
+from configparser import ConfigParser
+import yaml
+import pkg_resources
+import os
+
+# Get the directory of the current script
+current_directory = os.path.dirname(os.path.abspath(__file__))
+
+# Load configuration from the config file
+config_file_path = os.path.join(current_directory, 'db_config.ini')
+
+config = ConfigParser()
+config.read(config_file_path)
+mysql_config = config['mysql']
+
+
+
+connection_string = (
+    f"mysql+mysqlconnector://{mysql_config['user']}:{mysql_config['password']}@"
+    f"{mysql_config['host']}:{mysql_config['port']}/{mysql_config['database']}"
+)
+
+eng = create_engine(
+    connection_string,
+    execution_options={"autocommit": True},
+)
+
 my_eng = eng.connect()

scripts/config.ini

@@ -1,6 +1,6 @@
-[mysql]
-host = localhost
-port = 3306
-user = root
-password = 
+[mysql]
+host = localhost
+port = 3306
+user = root
+password = 
 database = MEDfl

scripts/create_db.py

@@ -1,133 +1,133 @@
-import sys
-import mysql.connector
-import pandas as pd
-from mysql.connector import Error
-
-from configparser import ConfigParser
-import os
-
-def main(csv_file_path):
-    try:
-        # Get the directory of the current script
-        current_directory = os.path.dirname(os.path.abspath(__file__))
-
-        # Load configuration from the config file
-        config_file_path = os.path.join(current_directory, 'db_config.ini')
-
-        config = ConfigParser()
-        config.read(config_file_path)
-        mysql_config = config['mysql']
-
-        print('Im here !')
-
-        mydb = mysql.connector.connect(host=mysql_config['host'], user=mysql_config['user'], password=mysql_config['password'])
-        mycursor = mydb.cursor()
-
-        # Create the 'MEDfl' database if it doesn't exist
-        mycursor.execute("CREATE DATABASE IF NOT EXISTS MEDfl")
-
-        # Select the 'MEDfl' database
-        mycursor.execute("USE MEDfl")
-
-        # Get the list of all tables in the database
-        mycursor.execute("SHOW TABLES")
-        tables = mycursor.fetchall()
-
-        # Drop each table one by one
-        for table in tables:
-            table_name = table[0]
-            mycursor.execute(f"DROP TABLE IF EXISTS {table_name}")
-
-        # Create Networks table
-        mycursor.execute(
-            "CREATE TABLE Networks( \
-                         NetId INT NOT NULL AUTO_INCREMENT, \
-                         NetName VARCHAR(255), \
-                         PRIMARY KEY (NetId) \
-                         );"
-        )
-
-        # Create FLsetup table
-        mycursor.execute("CREATE TABLE FLsetup (\
-        FLsetupId int NOT NULL AUTO_INCREMENT,\
-        name varchar(255)  NOT NULL, \
-        description varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,\
-        creation_date datetime NOT NULL,\
-        NetId int NOT NULL,\
-        column_name varchar(255) DEFAULT NULL,\
-        PRIMARY KEY (`FLsetupId`) \
-        )")
-
-        # Create Nodes table
-        mycursor.execute("CREATE TABLE Nodes ( \
-         NodeId int NOT NULL AUTO_INCREMENT,\
-         NodeName varchar(255) DEFAULT NULL,\
-         train tinyint(1) DEFAULT '1',\
-         NetId int DEFAULT NULL,\
-         PRIMARY KEY (NodeId)\
-        )")
-
-        data_df = pd.read_csv(csv_file_path)
-        columns = data_df.columns.tolist()
-        column_map = {"object": "VARCHAR(255)", "int64": "INT", "float64": "FLOAT"}
-        sub_query = "".join(f"{col} {column_map[str(data_df[col].dtype)]}," for col in columns)
-
-        # Create Datasets table by getting columns from the master csv file
-        mycursor.execute(
-            f"CREATE TABLE DataSets( \
-                         DataSetId INT NOT NULL AUTO_INCREMENT, \
-                         DataSetName VARCHAR(255), \
-                         NodeId INT CHECK (NodeId = -1 OR NodeId IS NOT NULL),\
-                         {sub_query}\
-                         PRIMARY KEY (DataSetId)\
-                         )"
-        )
-
-        # Create FLpipeline table
-        mycursor.execute("CREATE TABLE FLpipeline(\
-         id int NOT NULL AUTO_INCREMENT,\
-         name varchar(255) NOT NULL, \
-         description varchar(255) NOT NULL,\
-         creation_date datetime NOT NULL,\
-         results longtext   NOT NULL,\
-         PRIMARY KEY (id)\
-        ) ")
-
-        # Create test results table
-        mycursor.execute("CREATE TABLE testResults(\
-         pipelineId INT,\
-         nodename VARCHAR(100) NOT NULL, \
-         confusionmatrix VARCHAR(255),\
-         accuracy LONG,\
-         sensivity LONG,\
-         ppv LONG,\
-         npv LONG,\
-         f1score LONG,\
-         fpr LONG,\
-         tpr LONG, \
-         PRIMARY KEY (pipelineId , nodename)\
-        ) ")
-
-        # Create FederatedDataset table
-        mycursor.execute("CREATE TABLE FedDatasets (\
-         FedId int NOT NULL AUTO_INCREMENT,\
-         FLsetupId int DEFAULT NULL,\
-         FLpipeId int DEFAULT NULL,\
-         name varchar(255) NOT NULL,\
-         PRIMARY KEY (FedId)\
-        )")
-
-        # Commit and close the cursor
-        mydb.commit()
-        mycursor.close()
-        mydb.close()
-
-    except Error as e:
-        print(f"Error: {e}")
-
-if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: python script.py <path_to_csv_file>")
-        sys.exit(1)
-    csv_file_path = sys.argv[1]
-    main(csv_file_path)
+import sys
+import mysql.connector
+import pandas as pd
+from mysql.connector import Error
+
+from configparser import ConfigParser
+import os
+
+def main(csv_file_path):
+    try:
+        # Get the directory of the current script
+        current_directory = os.path.dirname(os.path.abspath(__file__))
+
+        # Load configuration from the config file
+        config_file_path = os.path.join(current_directory, 'db_config.ini')
+
+        config = ConfigParser()
+        config.read(config_file_path)
+        mysql_config = config['mysql']
+
+        print('Im here !')
+
+        mydb = mysql.connector.connect(host=mysql_config['host'], user=mysql_config['user'], password=mysql_config['password'])
+        mycursor = mydb.cursor()
+
+        # Create the 'MEDfl' database if it doesn't exist
+        mycursor.execute("CREATE DATABASE IF NOT EXISTS MEDfl")
+
+        # Select the 'MEDfl' database
+        mycursor.execute("USE MEDfl")
+
+        # Get the list of all tables in the database
+        mycursor.execute("SHOW TABLES")
+        tables = mycursor.fetchall()
+
+        # Drop each table one by one
+        for table in tables:
+            table_name = table[0]
+            mycursor.execute(f"DROP TABLE IF EXISTS {table_name}")
+
+        # Create Networks table
+        mycursor.execute(
+            "CREATE TABLE Networks( \
+                         NetId INT NOT NULL AUTO_INCREMENT, \
+                         NetName VARCHAR(255), \
+                         PRIMARY KEY (NetId) \
+                         );"
+        )
+
+        # Create FLsetup table
+        mycursor.execute("CREATE TABLE FLsetup (\
+        FLsetupId int NOT NULL AUTO_INCREMENT,\
+        name varchar(255)  NOT NULL, \
+        description varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,\
+        creation_date datetime NOT NULL,\
+        NetId int NOT NULL,\
+        column_name varchar(255) DEFAULT NULL,\
+        PRIMARY KEY (`FLsetupId`) \
+        )")
+
+        # Create Nodes table
+        mycursor.execute("CREATE TABLE Nodes ( \
+         NodeId int NOT NULL AUTO_INCREMENT,\
+         NodeName varchar(255) DEFAULT NULL,\
+         train tinyint(1) DEFAULT '1',\
+         NetId int DEFAULT NULL,\
+         PRIMARY KEY (NodeId)\
+        )")
+
+        data_df = pd.read_csv(csv_file_path)
+        columns = data_df.columns.tolist()
+        column_map = {"object": "VARCHAR(255)", "int64": "INT", "float64": "FLOAT"}
+        sub_query = "".join(f"{col} {column_map[str(data_df[col].dtype)]}," for col in columns)
+
+        # Create Datasets table by getting columns from the master csv file
+        mycursor.execute(
+            f"CREATE TABLE DataSets( \
+                         DataSetId INT NOT NULL AUTO_INCREMENT, \
+                         DataSetName VARCHAR(255), \
+                         NodeId INT CHECK (NodeId = -1 OR NodeId IS NOT NULL),\
+                         {sub_query}\
+                         PRIMARY KEY (DataSetId)\
+                         )"
+        )
+
+        # Create FLpipeline table
+        mycursor.execute("CREATE TABLE FLpipeline(\
+         id int NOT NULL AUTO_INCREMENT,\
+         name varchar(255) NOT NULL, \
+         description varchar(255) NOT NULL,\
+         creation_date datetime NOT NULL,\
+         results longtext   NOT NULL,\
+         PRIMARY KEY (id)\
+        ) ")
+
+        # Create test results table
+        mycursor.execute("CREATE TABLE testResults(\
+         pipelineId INT,\
+         nodename VARCHAR(100) NOT NULL, \
+         confusionmatrix VARCHAR(255),\
+         accuracy LONG,\
+         sensivity LONG,\
+         ppv LONG,\
+         npv LONG,\
+         f1score LONG,\
+         fpr LONG,\
+         tpr LONG, \
+         PRIMARY KEY (pipelineId , nodename)\
+        ) ")
+
+        # Create FederatedDataset table
+        mycursor.execute("CREATE TABLE FedDatasets (\
+         FedId int NOT NULL AUTO_INCREMENT,\
+         FLsetupId int DEFAULT NULL,\
+         FLpipeId int DEFAULT NULL,\
+         name varchar(255) NOT NULL,\
+         PRIMARY KEY (FedId)\
+        )")
+
+        # Commit and close the cursor
+        mydb.commit()
+        mycursor.close()
+        mydb.close()
+
+    except Error as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python script.py <path_to_csv_file>")
+        sys.exit(1)
+    csv_file_path = sys.argv[1]
+    main(csv_file_path)

MEDfl/LearningManager/__init__.py

@@ -1,13 +0,0 @@
-# # MEDfl/LearningManager/__init__.py
-
-# # Import modules from this package
-# from .client import *
-# from .dynamicModal import *
-# from .flpipeline import *
-# from .federated_dataset import *
-# from .model import *
-# from .params_optimiser import *
-# from .plot import *
-# from .server import *
-# from .strategy import *
-# from .utils import *

MEDfl/LearningManager/client.py

@@ -1,150 +0,0 @@
-#!/usr/bin/env python3
-import flwr as fl
-from opacus import PrivacyEngine
-from torch.utils.data import DataLoader
-
-from .model import Model
-from .utils import params
-import torch
-
-class FlowerClient(fl.client.NumPyClient):
-    """
-    FlowerClient class for creating MEDfl clients.
-
-    Attributes:
-        cid (str): Client ID.
-        local_model (Model): Local model of the federated learning network.
-        trainloader (DataLoader): DataLoader for training data.
-        valloader (DataLoader): DataLoader for validation data.
-        diff_priv (bool): Flag indicating whether to use differential privacy.
-    """
-    def __init__(self, cid: str, local_model: Model, trainloader: DataLoader, valloader: DataLoader, diff_priv: bool = params["diff_privacy"]):
-        """
-        Initializes the FlowerClient instance.
-
-        Args:
-            cid (str): Client ID.
-            local_model (Model): Local model of the federated learning network.
-            trainloader (DataLoader): DataLoader for training data.
-            valloader (DataLoader): DataLoader for validation data.
-            diff_priv (bool): Flag indicating whether to use differential privacy.
-        """
-        self.cid = cid
-        self.local_model = local_model
-        self.trainloader = trainloader
-        self.valloader = valloader
-        if torch.cuda.is_available():
-            num_cuda_devices = torch.cuda.device_count()
-            if num_cuda_devices > 0:
-                device_idx = int(self.cid) % num_cuda_devices
-                self.device = torch.device(f"cuda:{device_idx}")
-                self.local_model.model.to(self.device)
-            else:
-                # Handle case where CUDA is available but no CUDA devices are found
-                raise RuntimeError("CUDA is available, but no CUDA devices are found.")
-        else:
-            # Handle case where CUDA is not available
-            self.device = torch.device("cpu")
-            self.local_model.model.to(self.device)
-
-        self.privacy_engine = PrivacyEngine(secure_mode=False)
-        self.diff_priv = diff_priv
-        self.epsilons = []
-        self.accuracies = []
-        self.losses = []
-        if self.diff_priv:
-            model, optimizer, self.trainloader = self.privacy_engine.make_private_with_epsilon(
-                module=self.local_model.model.train(),
-                optimizer=self.local_model.optimizer,
-                data_loader=self.trainloader,
-                epochs=params["train_epochs"],
-                target_epsilon=float(params["EPSILON"]),
-                target_delta= float(params["DELTA"]),
-                max_grad_norm=params["MAX_GRAD_NORM"],
-            )
-            setattr(self.local_model, "model", model)
-            setattr(self.local_model, "optimizer", optimizer)
-        self.validate()
-
-    def validate(self):
-        """Validates cid, local_model, trainloader, valloader."""
-        if not isinstance(self.cid, str):
-            raise TypeError("cid argument must be a string")
-
-        if not isinstance(self.local_model, Model):
-            raise TypeError("local_model argument must be a MEDfl.LearningManager.model.Model")
-
-        if not isinstance(self.trainloader, DataLoader):
-            raise TypeError("trainloader argument must be a torch.utils.data.dataloader")
-
-        if not isinstance(self.valloader, DataLoader):
-            raise TypeError("valloader argument must be a torch.utils.data.dataloader")
-
-        if not isinstance(self.diff_priv, bool):
-            raise TypeError("diff_priv argument must be a bool")
-
-    def get_parameters(self, config):
-        """
-        Returns the current parameters of the local model.
-
-        Args:
-            config: Configuration information.
-
-        Returns:
-            Numpy array: Parameters of the local model.
-        """
-        print(f"[Client {self.cid}] get_parameters")
-        return self.local_model.get_parameters()
-
-    def fit(self, parameters, config):
-        """
-        Fits the local model to the received parameters using federated learning.
-
-        Args:
-            parameters: Parameters received from the server.
-            config: Configuration information.
-
-        Returns:
-            Tuple: Parameters of the local model, number of training examples, and privacy information.
-        """
-        print('\n -------------------------------- \n  this is the config of the client')
-        print(f"[Client {self.cid}] fit, config: {config}")
-        # print(config['epochs'])
-        print('\n -------------------------------- \n  ')
-        self.local_model.set_parameters(parameters)
-        for _ in range(params["train_epochs"]):
-            epsilon = self.local_model.train(
-                self.trainloader,
-                epoch=_,
-                device=self.device,
-                privacy_engine=self.privacy_engine,
-                diff_priv=self.diff_priv,
-            )
-            self.epsilons.append(epsilon)
-        print(f"epsilon of client {self.cid} : eps = {epsilon}")
-        return (
-            self.local_model.get_parameters(),
-            len(self.trainloader),
-            {"epsilon": epsilon},
-        )
-
-    def evaluate(self, parameters, config):
-        """
-        Evaluates the local model on the validation data and returns the loss and accuracy.
-
-        Args:
-            parameters: Parameters received from the server.
-            config: Configuration information.
-
-        Returns:
-            Tuple: Loss, number of validation examples, and accuracy information.
-        """
-        print(f"[Client {self.cid}] evaluate, config: {config}")
-        self.local_model.set_parameters(parameters)
-        loss, accuracy , auc = self.local_model.evaluate(
-            self.valloader, device=self.device
-        )
-        self.losses.append(loss)
-        self.accuracies.append(accuracy)
-        
-        return float(loss), len(self.valloader), {"accuracy": float(accuracy)}