fedbiomed 5.4.1.dev2__tar.gz → 5.4.1.dev3__tar.gz

{fedbiomed-5.4.1.dev2 → fedbiomed-5.4.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fedbiomed
-Version: 5.4.1.dev2
+Version: 5.4.1.dev3
 Summary: Collaborative learning for healthcare
 Project-URL: Homepage, https://fedbiomed.org
 Project-URL: Documentation, https://fedbiomed.org

fedbiomed-5.4.1.dev3/envs/common/default_biprimes/biprime0.json

@@ -0,0 +1 @@
+{"secagg_version": "2", "secagg_id": "default_biprime0", "biprime": 158820908809271716671659880613366104677813341255487834154303909761107215283569995523817428402987962641429395032343305343341950966867458277812575065022203120547706127493272939455658018882112230042773163870472621818892994896895819790062496734944602899772583591514631486212290112369502692304700112819186167541107, "max_keysize": 2048}

fedbiomed-5.4.1.dev3/envs/common/default_keys/default_n2n_key.pem

@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgo0+8iUgUibpAw7gj
+duqcCXXcc1YeEQkzQaixpnJP4R+hRANCAATIZJixHBIRJnujJKWRgHyMM+UOqtT8
+VFDAMJPYX2VdJgWR1PIh0268KMxi0igWALA60mMPyyq3wRItZihhaHy1
+-----END PRIVATE KEY-----

fedbiomed-5.4.1.dev3/envs/common/default_training_plans/pytorch-celeba.txt

@@ -0,0 +1,113 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from fedbiomed.common.training_plans import TorchTrainingPlan
+from fedbiomed.common.data import DataManager
+from fedbiomed.common.constants import ProcessTypes
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+from torch.utils.data import Dataset
+from torchvision import transforms
+import pandas as pd
+from PIL import Image
+import os
+import numpy as np
+class CelebaTrainingPlan(TorchTrainingPlan):
+         
+    # Defines model 
+    def init_model(self):
+        model = self.Net()
+        return model 
+    
+    # Here we define the custom dependencies that will be needed by our custom Dataloader
+    def init_dependencies(self):
+        deps = ["from torch.utils.data import Dataset",
+                "from torchvision import transforms",
+                "import pandas as pd",
+                "from PIL import Image",
+                "import os",
+                "import numpy as np"]
+        return deps
+
+    # Torch modules class
+    class Net(nn.Module):
+        
+        def __init__(self):
+            super().__init__()
+            #convolution layers
+            self.conv1 = nn.Conv2d(3, 32, 3, 1)
+            self.conv2 = nn.Conv2d(32, 32, 3, 1)
+            self.conv3 = nn.Conv2d(32, 32, 3, 1)
+            self.conv4 = nn.Conv2d(32, 32, 3, 1)
+            self.dropout1 = nn.Dropout(0.25)
+            self.dropout2 = nn.Dropout(0.5)
+            # classifier
+            self.fc1 = nn.Linear(3168, 128)
+            self.fc2 = nn.Linear(128, 2)
+
+        def forward(self, x):
+            x = self.conv1(x)
+            x = F.max_pool2d(x, 2)
+            x = F.relu(x)
+
+            x = self.conv2(x)
+            x = F.max_pool2d(x, 2)
+            x = F.relu(x)
+
+            x = self.conv3(x)
+            x = F.max_pool2d(x, 2)
+            x = F.relu(x)
+
+            x = self.conv4(x)
+            x = F.max_pool2d(x, 2)
+            x = F.relu(x)
+
+            x = self.dropout1(x)
+            x = torch.flatten(x, 1)
+            x = self.fc1(x)
+            x = F.relu(x)
+
+            x = self.dropout2(x)
+            x = self.fc2(x)
+            output = F.log_softmax(x, dim=1)
+            return output
+
+
+    class CelebaDataset(Dataset):
+        """Custom Dataset for loading CelebA face images"""
+        
+        # we dont load the full data of the images, we retrieve the image with the get item. 
+        # in our case, each image is 218*178 * 3colors. there is 67533 images. this take at leas 7G of ram
+        # loading images when needed takes more time during training but it wont impact the ram usage as much as loading everything
+        def __init__(self, txt_path, img_dir, transform=None):
+            df = pd.read_csv(txt_path, sep="\t", index_col=0)
+            self.img_dir = img_dir
+            self.txt_path = txt_path
+            self.img_names = df.index.values
+            self.y = df['Smiling'].values
+            self.transform = transform
+            print("celeba dataset finished")
+
+        def __getitem__(self, index):
+            img = np.asarray(Image.open(os.path.join(self.img_dir,
+                                        self.img_names[index])))
+            img = transforms.ToTensor()(img)
+            label = self.y[index]
+            return img, label
+
+        def __len__(self):
+            return self.y.shape[0]
+    
+    # The training_data creates the Dataloader to be used for training in the 
+    # general class Torchnn of fedbiomed
+    def training_data(self):
+        dataset = self.CelebaDataset(self.dataset_path + "/target.csv", self.dataset_path + "/data/")
+        train_kwargs = {'shuffle': True}
+        return DataManager(dataset, **train_kwargs)
+    
+    # This function must return the loss to backward it 
+    def training_step(self, data, target):
+        
+        output = self.model().forward(data)
+        loss   = torch.nn.functional.nll_loss(output, target)
+        return loss

fedbiomed-5.4.1.dev3/envs/common/default_training_plans/pytorch-csv.txt

@@ -0,0 +1,63 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from fedbiomed.common.training_plans import TorchTrainingPlan
+from fedbiomed.common.data import DataManager
+from fedbiomed.common.constants import ProcessTypes
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+class MyTrainingPlan(TorchTrainingPlan):
+
+    # Defines and return model
+    def init_model(self, model_args):
+        return self.Net(model_args = model_args)
+
+    # Defines and return optimizer
+    def init_optimizer(self, optimizer_args):
+        return torch.optim.Adam(self.model().parameters(), lr = optimizer_args["lr"])
+
+    # Declares and return dependencies
+    def init_dependencies(self):
+        deps = ["from torchvision import datasets, transforms"]
+        return deps
+
+    class Net(nn.Module):
+        def __init__(self, model_args):
+            super().__init__()
+            self.conv1 = nn.Conv2d(1, 32, 3, 1)
+            self.conv2 = nn.Conv2d(32, 64, 3, 1)
+            self.dropout1 = nn.Dropout(0.25)
+            self.dropout2 = nn.Dropout(0.5)
+            self.fc1 = nn.Linear(9216, 128)
+            self.fc2 = nn.Linear(128, 10)
+
+        def forward(self, x):
+            x = self.conv1(x)
+            x = F.relu(x)
+            x = self.conv2(x)
+            x = F.relu(x)
+            x = F.max_pool2d(x, 2)
+            x = self.dropout1(x)
+            x = torch.flatten(x, 1)
+            x = self.fc1(x)
+            x = F.relu(x)
+            x = self.dropout2(x)
+            x = self.fc2(x)
+
+
+            output = F.log_softmax(x, dim=1)
+            return output
+
+    def training_data(self):
+        # Custom torch Dataloader for MNIST data
+        transform = transforms.Compose([transforms.ToTensor(),
+        transforms.Normalize((0.1307,), (0.3081,))])
+        dataset1 = datasets.MNIST(self.dataset_path, train=True, download=False, transform=transform)
+        loader_arguments = { 'shuffle': True}
+        return DataManager(dataset=dataset1, **loader_arguments)
+
+    def training_step(self, data, target):
+        output = self.model().forward(data)
+        loss   = torch.nn.functional.nll_loss(output, target)
+        return loss
+