Add untracked files and synchronize with remote

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.10
+
+WORKDIR /app
+
+COPY . /app
+
+RUN apt-get update && apt-get install -y curl
+RUN pip install -r requirements.txt
+
+RUN python -m spacy download en_core_web_sm
+
+CMD ["python", "app.py"]

components/data_utils.py

@@ -0,0 +1,15 @@
+def partition_data(dataset, num_clients):
+    """
+    Partitions a dataset into `num_clients` subsets.
+    This is just a placeholder. Implement a more sophisticated partitioning strategy
+    (e.g., based on medical specialty, patient demographics) for a real application.
+    """
+    data_per_client = len(dataset) // num_clients
+    remaining_data = len(dataset) % num_clients
+    partitioned_data = []
+    start_index = 0
+    for i in range(num_clients):
+        end_index = start_index + data_per_client + (1 if i < remaining_data else 0)
+        partitioned_data.append(dataset[start_index:end_index])
+        start_index = end_index
+    return partitioned_data

components/federated_learning.py

@@ -0,0 +1,43 @@
+import flwr as fl
+import torch
+from collections import OrderedDict # For the example provided.
+
+def run_federated_learning():
+    """
+    Sets up and starts a federated learning simulation.
+    This is a highly conceptual example. Actual implementation requires:
+        1. A defined model architecture.
+        2. A training loop using PyTorch or TensorFlow.
+        3. Data loaders.
+        4. Proper handling of FL strategies.
+    """
+
+    class FlowerClient(fl.client.NumPyClient):
+        def __init__(self, model, trainloader, valloader):
+            self.model = model
+            self.trainloader = trainloader
+            self.valloader = valloader
+
+        def get_parameters(self, config):
+            return [val.cpu().numpy() for _, val in self.model.state_dict().items()]
+
+        def set_parameters(self, parameters):
+            params_dict = zip(self.model.state_dict().keys(), parameters)
+            state_dict = OrderedDict({k: torch.Tensor(v) for k, v in params_dict})
+            self.model.load_state_dict(state_dict, strict=True)
+
+        def fit(self, parameters, config):
+            self.set_parameters(parameters)
+            # Train.
+            print("Train the parameters here.")
+            return parameters, 1, {}
+
+        def evaluate(self, parameters, config):
+            self.set_parameters(parameters)
+            # Test (validate).
+            return 1,1, {"accuracy": 1}
+
+    #Flower code
+    #The parameters needs to be added.
+
+    print("Started Simulation FL code")

components/knowledge_graph.py

@@ -0,0 +1,36 @@
+from py2neo import Graph, Node, Relationship
+import spacy
+
+def extract_knowledge_graph(text, nlp):
+    """Extracts entities and relationships and stores them to Neo4j."""
+
+    graph = Graph("bolt://localhost:7687", auth=("neo4j", "password"))  # Adjust credentials
+
+    doc = nlp(text)
+
+    for ent in doc.ents:
+        node = Node("Entity", name=ent.text, label=ent.label_)
+        graph.create(node)
+
+    #This requires more work for the relationship
+    """
+    This needs more work to make the information work. 
+    Example only. More data cleaning needed before real implementation
+
+    for token in doc:
+        # Example: look for verbs connecting entities
+        if token.dep_ == "ROOT" and token.pos_ == "VERB":
+            for child in token.children:
+                if child.dep_ == "nsubj" and child.ent_type_:  # Subject is an entity
+                    for obj in token.children:
+                        if obj.dep_ == "dobj" and obj.ent_type_:  # Object is an entity
+                            subject_node = Node("Entity", name=child.text, label=child.ent_type_)
+                            object_node = Node("Entity", name=obj.text, label=obj.ent_type_)
+                            relation = Relationship(subject_node, token.text, object_node)
+                            graph.create(relation)
+    """
+
+    print("Successfully loaded data to the knowledge base.")
+
+    # Example Node
+    print("Create a node called entity.")

components/model_utils.py

@@ -0,0 +1,18 @@
+from transformers import pipeline
+import os
+
+def load_summarization_model():
+    """Loads the summarization model.  Check for HUGGINGFACE_API_TOKEN first."""
+    api_token = os.environ.get("HUGGINGFACE_API_TOKEN")
+    model_name = "facebook/bart-large-cnn" # Or whatever
+
+    if not api_token:
+        print("HUGGINGFACE_API_TOKEN not found.  Summarization will not work.")
+        return None
+    try:
+        summarizer = pipeline("summarization", model=model_name, token=api_token)
+        print(f"Summarization Model {model_name} Loaded...")
+        return summarizer
+    except Exception as e:
+        print(f"Model load error: {e}")
+        return None

components/pubmed_search.py

@@ -0,0 +1,65 @@
+from Bio import Entrez
+import os  # For environment variables and file paths
+
+# ---------------------------- Configuration ----------------------------
+
+# ---------------------------- Helper Functions ----------------------------
+
+def log_error(message: str):
+    """Logs an error message to the console and a file (if possible)."""
+    print(f"ERROR: {message}")
+    try:
+        with open("error_log.txt", "a") as f:
+            f.write(f"{message}\n")
+    except:
+        print("Couldn't write to error log file.")  #If logging fails, still print to console
+
+# ---------------------------- Tool Functions ----------------------------
+
+def search_pubmed(query: str) -> list:
+    """Searches PubMed and returns a list of article IDs."""
+    try:
+        Entrez.email = os.environ.get("ENTREZ_EMAIL", "[email protected]")
+        handle = Entrez.esearch(db="pubmed", term=query, retmax="5")
+        record = Entrez.read(handle)
+        handle.close()
+        return record["IdList"]
+    except Exception as e:
+        log_error(f"PubMed search error: {e}")
+        return [f"Error during PubMed search: {e}"]
+
+def fetch_abstract(article_id: str) -> str:
+    """Fetches the abstract for a given PubMed article ID."""
+    try:
+        Entrez.email = os.environ.get("ENTREZ_EMAIL", "[email protected]")
+        handle = Entrez.efetch(db="pubmed", id=article_id, rettype="abstract", retmode="text")
+        abstract = handle.read()
+        handle.close()
+        return abstract
+    except Exception as e:
+        log_error(f"Error fetching abstract for {article_id}: {e}")
+        return f"Error fetching abstract for {article_id}: {e}"
+
+# ---------------------------- Agent Function ----------------------------
+
+def medai_agent(query: str) -> str:
+    """Orchestrates the medical literature review and presents abstract."""
+    article_ids = search_pubmed(query)
+
+    if isinstance(article_ids, list) and article_ids:
+        results = []
+        for article_id in article_ids:
+            abstract = fetch_abstract(article_id)
+            if "Error" not in abstract:
+                results.append(f"<div class='article'>\n"
+                               f"  <h3 class='article-id'>Article ID: {article_id}</h3>\n"
+                               f"  <p class='abstract'><strong>Abstract:</strong> {abstract}</p>\n"
+                               f"</div>\n")
+            else:
+                results.append(f"<div class='article error'>\n"
+                               f"  <h3 class='article-id'>Article ID: {article_id}</h3>\n"
+                               f"  <p class='error-message'>Error processing article: {abstract}</p>\n"
+                               f"</div>\n")
+        return "\n".join(results)
+    else:
+        return f"No articles found or error occurred: {article_ids}"

components/vis.py

@@ -0,0 +1,30 @@
+import matplotlib.pyplot as plt
+import io
+import base64
+
+def generate_federated_learning_plot(client_accuracies):
+    """
+    Generates a plot showing the training accuracy of each client in a federated learning setting.
+    This is a placeholder. You'll need to integrate it with your actual FL framework
+    and store the client accuracies during training.
+    """
+    # Assuming client_accuracies is a dictionary of client_id: accuracy
+    client_ids = list(client_accuracies.keys())
+    accuracies = list(client_accuracies.values())
+
+    plt.figure(figsize=(10, 6))
+    plt.bar(client_ids, accuracies, color='skyblue')
+    plt.xlabel('Client ID')
+    plt.ylabel('Accuracy')
+    plt.title('Federated Learning: Client Accuracies')
+    plt.ylim(0, 1)  # Assuming accuracy is between 0 and 1
+    plt.xticks(rotation=45, ha='right')
+    plt.tight_layout()
+
+    # Convert plot to base64 image
+    img_buf = io.BytesIO()
+    plt.savefig(img_buf, format='png')
+    img_buf.seek(0)
+    img_data = base64.b64encode(img_buf.read()).decode('utf-8')
+    plt.close()  # Close the plot to free memory
+    return f'<img src="data:image/png;base64,{img_data}" alt="Federated Learning Plot"/>'

requirements.txt

@@ -0,0 +1,4 @@
+gradio 
+transformers 
+biopython 
+spacy