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

MEDfl-2.0.4.dev1.dist-info/RECORD

@@ -1,62 +0,0 @@
-MEDfl/__init__.py,sha256=70DmtU4C3A-1XYoaYm0moXBe-YGJ2FhEe3ga5SQVTts,97
-MEDfl/LearningManager/__init__.py,sha256=IMHJVeyx5ew0U_90LNMNCd4QISzWv3XCCri7fQRvcsM,341
-MEDfl/LearningManager/client.py,sha256=9Y_Zb0yxvCxx3dVCPQ1bXS5mCKasylSBnoVj-RDN270,5933
-MEDfl/LearningManager/dynamicModal.py,sha256=q8u7xPpj_TdZnSr8kYj0Xx7Sdz-diXsKBAfVce8-qSU,10534
-MEDfl/LearningManager/federated_dataset.py,sha256=InsZ5Rys2dgqaPxVyP5G3TrJMwiCNHOoTd3tCpUwUVM,2081
-MEDfl/LearningManager/flpipeline.py,sha256=5lT2uod5EqnkRQ04cgm0gYyZz0djumfIYipCrzX1fdo,7111
-MEDfl/LearningManager/model.py,sha256=vp8FIMxBdz3FTF5wJaea2IO_WGeANLZgBxTKVe3gW3Q,7456
-MEDfl/LearningManager/params.yaml,sha256=Ix1cNtlWr3vDC0te6pipl5w8iLADO6dZvwm633-VaIA,436
-MEDfl/LearningManager/params_optimiser.py,sha256=8e0gCt4imwQHlNSJ3A2EAuc3wSr6yfSI6JDghohfmZQ,17618
-MEDfl/LearningManager/plot.py,sha256=A6Z8wC8J-H-OmWBPKqwK5eiTB9vzOBGMaFv1SaNA9Js,7698
-MEDfl/LearningManager/server.py,sha256=oTgW3K1UT6m4SQBk23FIf23km_BDq9vvjeC6OgY8DNw,7077
-MEDfl/LearningManager/strategy.py,sha256=BHXpwmt7jx07y45YLUs8FZry2gYQbpiV4vNbHhsksQ4,3435
-MEDfl/LearningManager/utils.py,sha256=B4RULJp-puJr724O6teI0PxnUyPV8NG-uPC6jqaiDKI,9605
-MEDfl/NetManager/__init__.py,sha256=OpgsIiBg7UA6Bfnu_kqGfEPxU8JfpPxSFU98TOeDTP0,273
-MEDfl/NetManager/database_connector.py,sha256=G8DAsD_pAIK1U67x3Q8gmSJGW7iJyxQ_NE5lWpT-P0Q,1474
-MEDfl/NetManager/dataset.py,sha256=HTV0jrJ4Qlhl2aSJzdFU1lkxGBKtmJ390eBpwfKf_4o,2777
-MEDfl/NetManager/flsetup.py,sha256=CVu_TIU7l3G6DDnwtY6JURbhIZk7gKC3unqWnU-YtlM,11434
-MEDfl/NetManager/net_helper.py,sha256=tyfxmpbleSdfPfo2ezKT0VOvZu660v9nhBuHCpl8pG4,6812
-MEDfl/NetManager/net_manager_queries.py,sha256=j-CLQPjtTLyZuFPhIcwJStD7L7xtZpkmkhe_h3pDuTs,4086
-MEDfl/NetManager/network.py,sha256=5t705fzWc-BRg-QPAbAcDv5ckDGzsPwj_Q5V0iTgkx0,6829
-MEDfl/NetManager/node.py,sha256=t90QuYZ8M1X_AG1bwTta0CnlOuodqkmpVda2K7NOgHc,6542
-MEDfl/rw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MEDfl/rw/client.py,sha256=k8y8Wxh2KNe2oy5gRD-KXpTEGCYzp7X2oF5-Z6Rk1_E,1329
-MEDfl/rw/model.py,sha256=TKCfE4nYx75uQdgABwEMkb_ynT-xS_MxNPbGAzJ3EcQ,629
-MEDfl/rw/rwConfig.py,sha256=nK3Inv7v7Dm9gZnUnK5EqA4DmQ7TqiH4UoCZ8MlgFjA,823
-MEDfl/rw/server.py,sha256=PiCrUTlnx7rVcO9DcT-vnJF5WkOCe4eEzWXeRSUBh10,3286
-MEDfl/rw/strategy.py,sha256=sUwu0aAq6q3sKnfRimCRfps3be8s2iepGoD9NfcyjXI,6233
-MEDfl/rw/verbose_server.py,sha256=B_abnpCy43e3YrjotLFOm7cLiuiB5PSTeXD5sMP0CxA,851
-MEDfl/scripts/__init__.py,sha256=Pq1weevsPaU7MRMHfBYeyT0EOFeWLeVM6Y1DVz6jw1A,48
-MEDfl/scripts/base.py,sha256=QrmG7gkiPYkAy-5tXxJgJmOSLGAKeIVH6i0jq7G9xnA,752
-MEDfl/scripts/create_db.py,sha256=MnFtZkTueRZ-3qXPNX4JsXjOKj-4mlkxoRhSFdRcvJw,3817
-Medfl/__init__.py,sha256=-BV6VpkX931dhU_qLqRJyhhRP9ftIrlHBvTgQVC-jK0,79
-Medfl/LearningManager/__init__.py,sha256=IMHJVeyx5ew0U_90LNMNCd4QISzWv3XCCri7fQRvcsM,341
-Medfl/LearningManager/client.py,sha256=9Y_Zb0yxvCxx3dVCPQ1bXS5mCKasylSBnoVj-RDN270,5933
-Medfl/LearningManager/dynamicModal.py,sha256=q8u7xPpj_TdZnSr8kYj0Xx7Sdz-diXsKBAfVce8-qSU,10534
-Medfl/LearningManager/federated_dataset.py,sha256=InsZ5Rys2dgqaPxVyP5G3TrJMwiCNHOoTd3tCpUwUVM,2081
-Medfl/LearningManager/flpipeline.py,sha256=5lT2uod5EqnkRQ04cgm0gYyZz0djumfIYipCrzX1fdo,7111
-Medfl/LearningManager/model.py,sha256=vp8FIMxBdz3FTF5wJaea2IO_WGeANLZgBxTKVe3gW3Q,7456
-Medfl/LearningManager/params.yaml,sha256=_yAdYBtxNqKRWIhs_XebG_w1NGyq4-3NzVwWb8xiU5o,436
-Medfl/LearningManager/params_optimiser.py,sha256=8e0gCt4imwQHlNSJ3A2EAuc3wSr6yfSI6JDghohfmZQ,17618
-Medfl/LearningManager/plot.py,sha256=A6Z8wC8J-H-OmWBPKqwK5eiTB9vzOBGMaFv1SaNA9Js,7698
-Medfl/LearningManager/server.py,sha256=oTgW3K1UT6m4SQBk23FIf23km_BDq9vvjeC6OgY8DNw,7077
-Medfl/LearningManager/strategy.py,sha256=BHXpwmt7jx07y45YLUs8FZry2gYQbpiV4vNbHhsksQ4,3435
-Medfl/LearningManager/utils.py,sha256=B4RULJp-puJr724O6teI0PxnUyPV8NG-uPC6jqaiDKI,9605
-Medfl/NetManager/__init__.py,sha256=OpgsIiBg7UA6Bfnu_kqGfEPxU8JfpPxSFU98TOeDTP0,273
-Medfl/NetManager/database_connector.py,sha256=Yh3GxI0NmbftM7YUkqQBjsXAe3i1ucF9q5OyR9DOhDQ,1473
-Medfl/NetManager/dataset.py,sha256=HTV0jrJ4Qlhl2aSJzdFU1lkxGBKtmJ390eBpwfKf_4o,2777
-Medfl/NetManager/flsetup.py,sha256=CVu_TIU7l3G6DDnwtY6JURbhIZk7gKC3unqWnU-YtlM,11434
-Medfl/NetManager/net_helper.py,sha256=tyfxmpbleSdfPfo2ezKT0VOvZu660v9nhBuHCpl8pG4,6812
-Medfl/NetManager/net_manager_queries.py,sha256=j-CLQPjtTLyZuFPhIcwJStD7L7xtZpkmkhe_h3pDuTs,4086
-Medfl/NetManager/network.py,sha256=5t705fzWc-BRg-QPAbAcDv5ckDGzsPwj_Q5V0iTgkx0,6829
-Medfl/NetManager/node.py,sha256=t90QuYZ8M1X_AG1bwTta0CnlOuodqkmpVda2K7NOgHc,6542
-Medfl/scripts/__init__.py,sha256=Pq1weevsPaU7MRMHfBYeyT0EOFeWLeVM6Y1DVz6jw1A,48
-Medfl/scripts/base.py,sha256=QrmG7gkiPYkAy-5tXxJgJmOSLGAKeIVH6i0jq7G9xnA,752
-Medfl/scripts/create_db.py,sha256=MnFtZkTueRZ-3qXPNX4JsXjOKj-4mlkxoRhSFdRcvJw,3817
-alembic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alembic/env.py,sha256=-aSZ6SlJeK1ZeqHgM-54hOi9LhJRFP0SZGjut-JnY-4,1588
-MEDfl-2.0.4.dev1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-MEDfl-2.0.4.dev1.dist-info/METADATA,sha256=rvSMS_MZCyEDMkL54d4tRwWtSCa3AIQ3wuj6yZbszOc,4326
-MEDfl-2.0.4.dev1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-MEDfl-2.0.4.dev1.dist-info/top_level.txt,sha256=dIL9X8HOFuaVSzpg40DVveDPrymWRoShHtspH7kkjdI,14
-MEDfl-2.0.4.dev1.dist-info/RECORD,,

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)}

Medfl/LearningManager/dynamicModal.py

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

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