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

Medfl/LearningManager/dynamicModal.py

@@ -0,0 +1,287 @@
+import torch
+import torch.nn as nn
+from sklearn.svm import SVC
+
+class DynamicModel:
+    """DynamicModel class for creating various types of neural network models."""
+
+    # Create a binary classifier model
+    @staticmethod
+    def create_binary_classifier(input_dim, hidden_dims, output_dim, activation='relu', dropout_rate=0.0,
+                                 batch_norm=False, use_gpu=False):
+        """
+        Creates a binary classifier neural network model with customizable architecture.
+
+        Args:
+            input_dim (int): Dimension of the input data.
+            hidden_dims (List[int]): List of dimensions for hidden layers.
+            output_dim (int): Dimension of the output (number of classes).
+            activation (str, optional): Activation function for hidden layers. Default is 'relu'.
+            dropout_rate (float, optional): Dropout rate for regularization. Default is 0.0 (no dropout).
+            batch_norm (bool, optional): Whether to apply batch normalization. Default is False.
+            use_gpu (bool, optional): Whether to use GPU acceleration. Default is False.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+
+        layers = []
+
+        for i in range(len(hidden_dims)):
+            if i == 0:
+                layers.append(nn.Linear(input_dim, hidden_dims[0]))
+            else:
+                layers.append(nn.Linear(hidden_dims[i - 1], hidden_dims[i]))
+
+            if batch_norm:
+                layers.append(nn.BatchNorm1d(hidden_dims[i]))
+
+            activation_layer = nn.ReLU() if activation == 'relu' else nn.Sigmoid()
+            layers.append(activation_layer)
+
+            if dropout_rate > 0.0:
+                layers.append(nn.Dropout(dropout_rate))
+
+        layers.append(nn.Linear(hidden_dims[-1], output_dim))
+        layers.append(nn.Sigmoid())
+
+        model = nn.Sequential(*layers)
+
+        if use_gpu:
+            model = model.cuda()
+
+        return model
+
+    # Create a multi-class classifier model
+    @staticmethod
+    def create_multiclass_classifier(input_dim, hidden_dims, output_dim, activation='relu', dropout_rate=0.0,
+                                     batch_norm=False, use_gpu=False):
+        """
+        Creates a multiclass classifier neural network model with customizable architecture.
+
+        Args:
+            input_dim (int): Dimension of the input data.
+            hidden_dims (List[int]): List of dimensions for hidden layers.
+            output_dim (int): Dimension of the output (number of classes).
+            activation (str, optional): Activation function for hidden layers. Default is 'relu'.
+            dropout_rate (float, optional): Dropout rate for regularization. Default is 0.0 (no dropout).
+            batch_norm (bool, optional): Whether to apply batch normalization. Default is False.
+            use_gpu (bool, optional): Whether to use GPU acceleration. Default is False.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+        layers = []
+
+        for i in range(len(hidden_dims)):
+            if i == 0:
+                layers.append(nn.Linear(input_dim, hidden_dims[0]))
+            else:
+                layers.append(nn.Linear(hidden_dims[i - 1], hidden_dims[i]))
+
+            if batch_norm:
+                layers.append(nn.BatchNorm1d(hidden_dims[i]))
+
+            activation_layer = nn.ReLU() if activation == 'relu' else nn.Sigmoid()
+            layers.append(activation_layer)
+
+            if dropout_rate > 0.0:
+                layers.append(nn.Dropout(dropout_rate))
+
+        layers.append(nn.Linear(hidden_dims[-1], output_dim))
+        layers.append(nn.LogSoftmax(dim=1))
+
+        model = nn.Sequential(*layers)
+
+        if use_gpu:
+            model = model.cuda()
+
+        return model
+
+    # Create a linear regressor model
+    @staticmethod
+    def create_linear_regressor(input_dim, output_dim, use_gpu=False):
+        """
+        Creates a linear regressor neural network model.
+
+        Args:
+            input_dim (int): Dimension of the input data.
+            output_dim (int): Dimension of the output.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+        class LinearRegressionModel(nn.Module):
+            def __init__(self):
+                super(LinearRegressionModel, self).__init__()
+                self.linear = nn.Linear(input_dim, output_dim)
+
+            def forward(self, x):
+                return self.linear(x)
+
+        model = LinearRegressionModel()
+
+        if use_gpu:
+            model = model.cuda()
+
+        return model
+
+    # Create a logistic regressor model
+    @staticmethod
+    def create_logistic_regressor(input_dim, use_gpu=False):
+        """
+        Creates a logistic regressor neural network model.
+
+        Args:
+            input_dim (int): Dimension of the input data.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+        class LogisticRegressionModel(nn.Module):
+            def __init__(self):
+                super(LogisticRegressionModel, self).__init__()
+                self.linear = nn.Linear(input_dim, 1)
+
+            def forward(self, x):
+                return torch.sigmoid(self.linear(x))
+
+        model = LogisticRegressionModel()
+
+        if use_gpu:
+            model = model.cuda()
+
+        return model
+    
+    @staticmethod
+    def create_convolutional_neural_network(input_channels, output_channels, kernel_size, use_gpu=False):
+        """
+        Creates a convolutional neural network (CNN) model.
+
+        Args:
+            input_channels (int): Number of input channels.
+            output_channels (int): Number of output channels.
+            kernel_size (int): Size of the convolutional kernel.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+
+        model = nn.Sequential(
+            nn.Conv2d(input_channels, output_channels, kernel_size),
+            nn.ReLU(),
+            nn.MaxPool2d(2)
+        )
+
+        if use_gpu:
+            model = model.cuda()
+
+        return model
+    
+    @staticmethod
+    def create_recurrent_neural_network(input_size, hidden_size, use_gpu=False):
+        """
+        Creates a recurrent neural network (RNN) model.
+
+        Args:
+            input_size (int): Size of the input.
+            hidden_size (int): Size of the hidden layer.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+
+        model = nn.RNN(input_size, hidden_size, batch_first=True)
+
+        if use_gpu:
+            model = model.cuda()
+
+        return model
+    
+    @staticmethod
+    def create_lstm_network(input_size, hidden_size, use_gpu=False):
+        """
+        Creates a Long Short-Term Memory (LSTM) network model.
+
+        Args:
+            input_size (int): Size of the input layer.
+            hidden_size (int): Size of the hidden layer.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+
+        model = nn.LSTM(input_size, hidden_size, batch_first=True)
+
+        if use_gpu:
+            model = model.cuda()
+
+        return model
+
+    # Create the dynamic model
+    def create_model(self, model_type: str, params_dict={}) -> torch.nn.Module:
+        """
+        Create a specific type of model dynamically based on the given parameters.
+
+        Args:
+            model_type (str): Type of the model to create ('Binary Classifier', 'Multiclass Classifier', 'Linear Regressor', 'Logistic Regressor', 'SVM', 'Neural Network Classifier', 'Convolutional Neural Network', 'Recurrent Neural Network', 'LSTM Network', 'Autoencoder').
+            params_dict (dict): Dictionary containing parameters for model creation.
+
+        Returns:
+            torch.nn.Module: Created PyTorch model.
+        """
+        if model_type == 'Binary Classifier':
+            return self.create_binary_classifier(
+                params_dict['input_dim'], params_dict['hidden_dims'],
+                params_dict['output_dim'], params_dict.get('activation', 'relu'),
+                params_dict.get('dropout_rate', 0.0), params_dict.get('batch_norm', False),
+                params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'Multiclass Classifier':
+            return self.create_multiclass_classifier(
+                params_dict['input_dim'], params_dict['hidden_dims'],
+                params_dict['output_dim'], params_dict.get('activation', 'relu'),
+                params_dict.get('dropout_rate', 0.0), params_dict.get('batch_norm', False),
+                params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'Linear Regressor':
+            return self.create_linear_regressor(
+                params_dict['input_dim'], params_dict['output_dim'],
+                params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'Logistic Regressor':
+            return self.create_logistic_regressor(
+                params_dict['input_dim'], params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'Neural Network Classifier':
+            return self.create_neural_network_classifier(
+                params_dict['input_dim'], params_dict['output_dim'],
+                params_dict['hidden_dims'], params_dict.get('activation', 'relu'),
+                params_dict.get('dropout_rate', 0.0), params_dict.get('batch_norm', False),
+                params_dict.get('num_layers', 2), params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'Convolutional Neural Network':
+            return self.create_convolutional_neural_network(
+                params_dict['input_channels'], params_dict['output_channels'],
+                params_dict['kernel_size'], params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'Recurrent Neural Network':
+            return self.create_recurrent_neural_network(
+                params_dict['input_size'], params_dict['hidden_size'],
+                params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'LSTM Network':
+            return self.create_lstm_network(
+                params_dict['input_size'], params_dict['hidden_size'],
+                params_dict.get('use_gpu', False)
+            )
+        elif model_type == 'Autoencoder':
+            return self.create_autoencoder(
+                params_dict['input_size'], params_dict['encoder_hidden_size'],
+                params_dict.get('use_gpu', False)
+            )
+        else:
+            raise ValueError("Invalid model type provided")
+
+
+

Medfl/LearningManager/federated_dataset.py

@@ -0,0 +1,60 @@
+from MEDfl.NetManager.net_helper import *
+from MEDfl.NetManager.net_manager_queries import *
+from MEDfl.NetManager.database_connector import DatabaseManager
+
+class FederatedDataset:
+    def __init__(
+        self,
+        name: str,
+        train_nodes: list,
+        test_nodes: list,
+        trainloaders: list,
+        valloaders: list,
+        testloaders: list,
+    ):
+        """
+        Represents a Federated Dataset.
+
+        :param name: Name of the Federated Dataset.
+        :param train_nodes: List of train nodes.
+        :param test_nodes: List of test nodes.
+        :param trainloaders: List of train data loaders.
+        :param valloaders: List of validation data loaders.
+        :param testloaders: List of test data loaders.
+        """
+        self.name = name
+        self.train_nodes = train_nodes
+        self.test_nodes = test_nodes
+        self.trainloaders = trainloaders
+        self.valloaders = valloaders
+        self.testloaders = testloaders
+        self.size = len(self.trainloaders[0].dataset[0][0])
+
+        db_manager = DatabaseManager()
+        db_manager.connect()
+        self.eng = db_manager.get_connection()
+
+    def create(self, FLsetupId: int):
+        """
+        Create a new Federated Dataset in the database.
+
+        :param FLsetupId: The FLsetup ID associated with the Federated Dataset.
+        """
+        query_params = {"name": self.name, "FLsetupId": FLsetupId}
+        fedDataId = get_feddataset_id_from_name(self.name)
+        if fedDataId :
+            self.id = fedDataId
+        else:
+            self.eng.execute(text(INSERT_FLDATASET_QUERY), query_params)
+            self.id = get_feddataset_id_from_name(self.name)
+
+
+    def update(self, FLpipeId: int, FedId: int):
+        """
+        Update the FLpipe ID associated with the Federated Dataset in the database.
+
+        :param FLpipeId: The new FLpipe ID to be updated.
+        :param FedId: The Federated Dataset ID.
+        """
+        query_params = {"FLpipeId": FLpipeId, "FedId": FedId}
+        self.eng.execute(text(UPDATE_FLDATASET_QUERY), **query_params)

Medfl/LearningManager/flpipeline.py

@@ -0,0 +1,192 @@
+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