Update app.py

app.py

@@ -71,10 +71,13 @@ def test(net, testloader):
     return loss, accuracy
 
 class CustomClient(fl.client.NumPyClient):
-    def __init__(self, net, trainloader, testloader):
+    def __init__(self, net, trainloader, testloader, client_id):
         self.net = net
         self.trainloader = trainloader
         self.testloader = testloader
+        self.client_id = client_id
+        self.losses = []
+        self.accuracies = []
 
     def get_parameters(self, config):
         return [val.cpu().numpy() for _, val in self.net.state_dict().items()]
@@ -87,6 +90,9 @@ class CustomClient(fl.client.NumPyClient):
     def fit(self, parameters, config):
         self.set_parameters(parameters)
         train(self.net, self.trainloader, epochs=1)
+        loss, accuracy = test(self.net, self.testloader)
+        self.losses.append(loss)
+        self.accuracies.append(accuracy)
         return self.get_parameters(config={}), len(self.trainloader.dataset), {}
 
     def evaluate(self, parameters, config):
@@ -94,13 +100,25 @@ class CustomClient(fl.client.NumPyClient):
         loss, accuracy = test(self.net, self.testloader)
         return float(loss), len(self.testloader.dataset), {"accuracy": float(accuracy)}
 
+    def plot_metrics(self):
+        fig, ax1 = plt.subplots()
+
+        ax2 = ax1.twinx()
+        ax1.plot(range(1, len(self.losses) + 1), self.losses, 'g-')
+        ax2.plot(range(1, len(self.accuracies) + 1), self.accuracies, 'b-')
+
+        ax1.set_xlabel('Round')
+        ax1.set_ylabel('Loss', color='g')
+        ax2.set_ylabel('Accuracy', color='b')
+
+        plt.title(f'Client {self.client_id} Metrics')
+        st.pyplot(fig)
+
 def main():
-    st.write("## Federated Learning with Flower and Dynamic Models and Datasets for Mobile Devices")
+    st.write("## Federated Learning with Dynamic Models and Datasets for Mobile Devices")
     dataset_name = st.selectbox("Dataset", ["imdb", "amazon_polarity", "ag_news"])
     model_name = st.selectbox("Model", ["bert-base-uncased", "distilbert-base-uncased"])
 
-    net = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2).to(DEVICE)
-
     NUM_CLIENTS = st.slider("Number of Clients", min_value=1, max_value=10, value=2)
     NUM_ROUNDS = st.slider("Number of Rounds", min_value=1, max_value=10, value=3)
 
@@ -108,6 +126,7 @@ def main():
 
     trainloaders = []
     testloaders = []
+    clients = []
 
     for i in range(NUM_CLIENTS):
         st.write(f"### Client {i+1} Datasets")
@@ -129,12 +148,11 @@ def main():
         trainloaders.append(trainloader)
         testloaders.append(testloader)
 
-    if st.button("Start Training"):
-        round_losses = []
-        round_accuracies = []
-
-        clients = [CustomClient(net, trainloaders[i], testloaders[i]) for i in range(NUM_CLIENTS)]
+        net = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2).to(DEVICE)
+        client = CustomClient(net, trainloader, testloader, client_id=i+1)
+        clients.append(client)
 
+    if st.button("Start Training"):
         def client_fn(cid):
             return clients[int(cid)]
 
@@ -161,6 +179,10 @@ def main():
 
         st.success(f"Training completed successfully!")
 
+        for client in clients:
+            st.write(f"### Client {client.client_id} Model Metrics")
+            client.plot_metrics()
+
     else:
         st.write("Click the 'Start Training' button to start the training process.")
 
@@ -169,6 +191,177 @@ if __name__ == "__main__":
 
 
 
+# 05/2024 # %%writefile app.py
+
+# import streamlit as st
+# import matplotlib.pyplot as plt
+# import torch
+# from transformers import AutoTokenizer, DataCollatorWithPadding, AutoModelForSequenceClassification, AdamW
+# from datasets import load_dataset, Dataset
+# from evaluate import load as load_metric
+# from torch.utils.data import DataLoader
+# import pandas as pd
+# import random
+# import warnings
+# from collections import OrderedDict
+# import flwr as fl
+
+# DEVICE = torch.device("cpu")
+
+# def load_data(dataset_name, train_size=20, test_size=20, num_clients=2):
+#     raw_datasets = load_dataset(dataset_name)
+#     raw_datasets = raw_datasets.shuffle(seed=42)
+#     del raw_datasets["unsupervised"]
+
+#     tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+
+#     def tokenize_function(examples):
+#         return tokenizer(examples["text"], truncation=True)
+
+#     tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+#     tokenized_datasets = tokenized_datasets.remove_columns("text")
+#     tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+
+#     train_datasets = []
+#     test_datasets = []
+
+#     for _ in range(num_clients):
+#         train_dataset = tokenized_datasets["train"].select(random.sample(range(len(tokenized_datasets["train"])), train_size))
+#         test_dataset = tokenized_datasets["test"].select(random.sample(range(len(tokenized_datasets["test"])), test_size))
+#         train_datasets.append(train_dataset)
+#         test_datasets.append(test_dataset)
+
+#     data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+
+#     return train_datasets, test_datasets, data_collator
+
+# def train(net, trainloader, epochs):
+#     optimizer = AdamW(net.parameters(), lr=5e-5)
+#     net.train()
+#     for _ in range(epochs):
+#         for batch in trainloader:
+#             batch = {k: v.to(DEVICE) for k, v in batch.items()}
+#             outputs = net(**batch)
+#             loss = outputs.loss
+#             loss.backward()
+#             optimizer.step()
+#             optimizer.zero_grad()
+
+# def test(net, testloader):
+#     metric = load_metric("accuracy")
+#     net.eval()
+#     loss = 0
+#     for batch in testloader:
+#         batch = {k: v.to(DEVICE) for k, v in batch.items()}
+#         with torch.no_grad():
+#             outputs = net(**batch)
+#         logits = outputs.logits
+#         loss += outputs.loss.item()
+#         predictions = torch.argmax(logits, dim=-1)
+#         metric.add_batch(predictions=predictions, references=batch["labels"])
+#     loss /= len(testloader)
+#     accuracy = metric.compute()["accuracy"]
+#     return loss, accuracy
+
+# class CustomClient(fl.client.NumPyClient):
+#     def __init__(self, net, trainloader, testloader):
+#         self.net = net
+#         self.trainloader = trainloader
+#         self.testloader = testloader
+
+#     def get_parameters(self, config):
+#         return [val.cpu().numpy() for _, val in self.net.state_dict().items()]
+
+#     def set_parameters(self, parameters):
+#         params_dict = zip(self.net.state_dict().keys(), parameters)
+#         state_dict = OrderedDict({k: torch.Tensor(v) for k, v in params_dict})
+#         self.net.load_state_dict(state_dict, strict=True)
+
+#     def fit(self, parameters, config):
+#         self.set_parameters(parameters)
+#         train(self.net, self.trainloader, epochs=1)
+#         return self.get_parameters(config={}), len(self.trainloader.dataset), {}
+
+#     def evaluate(self, parameters, config):
+#         self.set_parameters(parameters)
+#         loss, accuracy = test(self.net, self.testloader)
+#         return float(loss), len(self.testloader.dataset), {"accuracy": float(accuracy)}
+
+# def main():
+#     st.write("## Federated Learning with Flower and Dynamic Models and Datasets for Mobile Devices")
+#     dataset_name = st.selectbox("Dataset", ["imdb", "amazon_polarity", "ag_news"])
+#     model_name = st.selectbox("Model", ["bert-base-uncased", "distilbert-base-uncased"])
+
+#     net = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2).to(DEVICE)
+
+#     NUM_CLIENTS = st.slider("Number of Clients", min_value=1, max_value=10, value=2)
+#     NUM_ROUNDS = st.slider("Number of Rounds", min_value=1, max_value=10, value=3)
+
+#     train_datasets, test_datasets, data_collator = load_data(dataset_name, num_clients=NUM_CLIENTS)
+
+#     trainloaders = []
+#     testloaders = []
+
+#     for i in range(NUM_CLIENTS):
+#         st.write(f"### Client {i+1} Datasets")
+
+#         train_df = pd.DataFrame(train_datasets[i])
+#         test_df = pd.DataFrame(test_datasets[i])
+
+#         st.write("#### Train Dataset")
+#         edited_train_df = st.experimental_data_editor(train_df, key=f"train_{i}")
+#         st.write("#### Test Dataset")
+#         edited_test_df = st.experimental_data_editor(test_df, key=f"test_{i}")
+
+#         edited_train_dataset = Dataset.from_pandas(edited_train_df)
+#         edited_test_dataset = Dataset.from_pandas(edited_test_df)
+
+#         trainloader = DataLoader(edited_train_dataset, shuffle=True, batch_size=32, collate_fn=data_collator)
+#         testloader = DataLoader(edited_test_dataset, batch_size=32, collate_fn=data_collator)
+
+#         trainloaders.append(trainloader)
+#         testloaders.append(testloader)
+
+#     if st.button("Start Training"):
+#         round_losses = []
+#         round_accuracies = []
+
+#         clients = [CustomClient(net, trainloaders[i], testloaders[i]) for i in range(NUM_CLIENTS)]
+
+#         def client_fn(cid):
+#             return clients[int(cid)]
+
+#         def weighted_average(metrics):
+#             accuracies = [num_examples * m["accuracy"] for num_examples, m in metrics]
+#             losses = [num_examples * m["loss"] for num_examples, m in metrics]
+#             examples = [num_examples for num_examples, _ in metrics]
+#             return {"accuracy": sum(accuracies) / sum(examples), "loss": sum(losses) / sum(examples)}
+
+#         strategy = fl.server.strategy.FedAvg(
+#             fraction_fit=1.0,
+#             fraction_evaluate=1.0,
+#             evaluate_metrics_aggregation_fn=weighted_average,
+#         )
+
+#         fl.simulation.start_simulation(
+#             client_fn=client_fn,
+#             num_clients=NUM_CLIENTS,
+#             config=fl.server.ServerConfig(num_rounds=NUM_ROUNDS),
+#             strategy=strategy,
+#             client_resources={"num_cpus": 1, "num_gpus": 0},
+#             ray_init_args={"log_to_driver": False, "num_cpus": 1, "num_gpus": 0}
+#         )
+
+#         st.success(f"Training completed successfully!")
+
+#     else:
+#         st.write("Click the 'Start Training' button to start the training process.")
+
+# if __name__ == "__main__":
+#     main()
+
+
+
 ##ORIGINAL###