Demo for ASAP grant renewal

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+media/pfp/*.png filter=lfs diff=lfs merge=lfs -text
+data/*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,14 @@
+# Ignore Mac temporary files
+*.DS_Store
+.DS_Store
+
+# Ignore python cache files
+__pycache__/
+
+# Ignore model files
+data/*.pt
+
+# Ignore secrets
+.streamlit/secrets.toml
+.streamlit/cipher_asap-user-db.json
+test.ipynb

.streamlit/config.toml

@@ -0,0 +1,5 @@
+[client]
+showSidebarNavigation = false
+
+[theme]
+base="light"

README.md

@@ -1,10 +1,10 @@
 ---
-title: Cipher Asap
-emoji: 📈
-colorFrom: blue
-colorTo: pink
+title: CIPHER
+emoji: 🧠
+colorFrom: red
+colorTo: purple
 sdk: streamlit
-sdk_version: 1.35.0
+sdk_version: 1.34.0
 app_file: app.py
 pinned: false
 ---

app.py

@@ -0,0 +1,157 @@
+import streamlit as st
+# Do not load st-gsheets-connection
+# from streamlit_gsheets import GSheetsConnection
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+import hmac
+
+# Standard imports
+import pandas as pd
+
+# Custom and other imports
+import project_config
+# from utils import add_logo
+from menu import menu
+
+# Initialize st.session_state.role to None
+if "role" not in st.session_state:
+    st.session_state.role = None
+
+# # Retrieve the role from Session State to initialize the widget
+# st.session_state._role = st.session_state.role
+
+# def set_role():
+#     # Callback function to save the role selection to Session State
+#     st.session_state.role = st.session_state._role
+
+
+# From https://stackoverflow.com/questions/55961295/serviceaccountcredentials-from-json-keyfile-name-equivalent-for-remote-json
+# See also https://www.slingacademy.com/article/pandas-how-to-read-and-update-google-sheet-files/
+# See also https://docs.streamlit.io/develop/tutorials/databases/private-gsheet
+# Note that the secrets cannot be passed in a group in HuggingFace Spaces, 
+#   which is required for the native Streamlit implementation
+def create_keyfile_dict():
+    variables_keys = {
+        # "spreadsheet": st.secrets['spreadsheet'], # spreadsheet
+        "type": st.secrets['type'], # type
+        "project_id": st.secrets['project_id'], # project_id
+        "private_key_id": st.secrets['private_key_id'], # private_key_id
+        # Have to replace \n with new lines (^l in Word) by hand
+        "private_key": st.secrets['private_key'], # private_key
+        "client_email": st.secrets['client_email'], # client_email
+        "client_id": st.secrets['client_id'], # client_id
+        "auth_uri": st.secrets['auth_uri'], # auth_uri
+        "token_uri": st.secrets['token_uri'], # token_uri
+        "auth_provider_x509_cert_url": st.secrets['auth_provider_x509_cert_url'], # auth_provider_x509_cert_url
+        "client_x509_cert_url": st.secrets['client_x509_cert_url'], # client_x509_cert_url
+        "universe_domain": st.secrets['universe_domain'] # universe_domain
+    }
+    return variables_keys
+
+
+def check_password():
+    """Returns `True` if the user had a correct password."""
+
+    def login_form():
+        """Form with widgets to collect user information"""
+        # Header
+        col1, col2, col3 = st.columns(3)
+        with col2:
+            st.image(str(project_config.MEDIA_DIR / 'cipher_logo.svg'), width=300)
+
+        # col1, col2, col3 = st.columns(3)
+        # with col1:
+        #     st.header("Log In")
+
+        with st.form("Credentials"):
+            st.text_input("Username", key="username")
+            st.text_input("Password", type="password", key="password")
+            st.form_submit_button("Log In", on_click=password_entered)
+
+    def password_entered():
+        """Checks whether a password entered by the user is correct."""
+
+        # Define the scope
+        scope = [
+            'https://spreadsheets.google.com/feeds',
+            'https://www.googleapis.com/auth/drive'
+        ]
+
+        # Add credentials to the account
+        creds = ServiceAccountCredentials.from_json_keyfile_dict(create_keyfile_dict(), scope)
+
+        # Authenticate and create the client
+        client = gspread.authorize(creds)
+
+        # Open the spreadsheet
+        sheet = client.open_by_url(st.secrets['spreadsheet']).worksheet("user_db")
+        data = sheet.get_all_records()
+        user_db = pd.DataFrame(data)
+        
+        # # Create a connection object to Google Sheets
+        # conn = st.connection("gsheets", type=GSheetsConnection)
+
+        # # Read the user database
+        # user_db = conn.read()
+        # user_db.dropna(axis=0, how="all", inplace=True)
+        # user_db.dropna(axis=1, how="all", inplace=True)
+
+        # Check if the username is in the database
+        if st.session_state["username"] in user_db.username.values:
+
+            st.session_state["username_correct"] = True
+
+            # Check if the password is correct
+            if hmac.compare_digest(
+                st.session_state["password"],
+                user_db.loc[user_db.username == st.session_state["username"], "password"].values[0],
+            ):
+                
+                st.session_state["password_correct"] = True
+                
+                # Check if the username is an admin
+                if st.session_state["username"] in user_db[user_db.role == "admin"].username.values:
+                    st.session_state["role"] = "admin"
+                else:
+                    st.session_state["role"] = "user"
+
+                # Retrieve and store user name and team
+                st.session_state["name"] = user_db.loc[user_db.username == st.session_state["username"], "name"].values[0]
+                st.session_state["team"] = user_db.loc[user_db.username == st.session_state["username"], "team"].values[0]
+                # st.session_state["profile_pic"] = user_db.loc[user_db.username == st.session_state["username"], "profile_pic"].values[0]
+                st.session_state["profile_pic"] = st.session_state["username"]
+
+                # Don't store the username or password
+                del st.session_state["password"]
+                # del st.session_state["username"]
+
+            else:
+                st.session_state["password_correct"] = False
+
+        else:
+            st.session_state["username_correct"] = False
+            st.session_state["password_correct"] = False
+
+    # Return True if the username + password is validated
+    if st.session_state.get("password_correct", False):
+        return True
+
+    # Show inputs for username + password
+    login_form()
+    if "password_correct" in st.session_state:
+
+        if not st.session_state["username_correct"]:
+            st.error("User not found.")
+        elif not st.session_state["password_correct"]:
+            st.error("The password you entered is incorrect.")
+        else:
+            st.error("An unexpected error occurred.")
+
+    return False
+
+menu() # Render the dynamic menu!
+
+if not check_password():
+    st.stop()
+
+st.switch_page("pages/about.py")

data/kg_edge_types.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ee79b2f5021304a4dd82581568e8a8c940f94b29cd1206f7730bdff6b82cab4
+size 5288

data/kg_edges.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab7d0e23c56381abf8e214cc5d4fae4e6a8b98957c8f2e5272b4f800953b1461
+size 2765378133

data/kg_node_types.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1a0afff52deec5f48689a22a479d14cd49333759e054624366687ec4ef306c8
+size 192

data/kg_nodes.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a21c42a1ee345195038d438854ee5d4befa7b1984e5efa4865ed74825a75b6d9
+size 8529743

menu.py

@@ -0,0 +1,51 @@
+# From https://docs.streamlit.io/develop/tutorials/multipage/st.page_link-nav
+import streamlit as st
+import os
+import project_config
+
+def authenticated_menu():
+
+    # Insert profile picture
+    pfp_path = str(project_config.MEDIA_DIR / 'pfp' / f"{st.session_state.profile_pic}.png")
+    if not os.path.exists(pfp_path):
+        pfp_path = str(project_config.MEDIA_DIR / 'pfp' / "cipher.png")
+    st.sidebar.image(pfp_path, use_column_width=True)
+    st.sidebar.markdown("---")
+
+    # Show a navigation menu for authenticated users
+    # st.sidebar.page_link("app.py", label="Switch Accounts", icon="🔒")
+    st.sidebar.page_link("pages/about.py", label="About", icon="📖")
+    st.sidebar.page_link("pages/input.py", label="Input", icon="💡")
+    st.sidebar.page_link("pages/predict.py", label="Predict", icon="🔍",
+                         disabled=("query" not in st.session_state))
+    st.sidebar.page_link("pages/validate.py", label="Validate", icon="✅",
+                         disabled=("query" not in st.session_state))
+    # st.sidebar.page_link("pages/explore.py", label="Explore", icon="🔍")
+    if st.session_state.role in ["admin"]:
+        st.sidebar.page_link("pages/admin.py", label="Manage Users", icon="🔧")
+
+    # Show the logout button
+    st.sidebar.markdown("---")
+    st.sidebar.button("Log Out", on_click=lambda: st.session_state.clear())
+
+
+def unauthenticated_menu():
+
+    # Show a navigation menu for unauthenticated users
+    st.sidebar.page_link("app.py", label="Log In", icon="🔒")
+
+
+def menu():
+    # Determine if a user is logged in or not, then show the correct navigation menu
+    if "role" not in st.session_state or st.session_state.role is None:
+        unauthenticated_menu()
+        return
+    authenticated_menu()
+
+
+def menu_with_redirect():
+    # Redirect users to the main page if not logged in, otherwise continue to
+    # render the navigation menu
+    if "role" not in st.session_state or st.session_state.role is None:
+        st.switch_page("app.py")
+    menu()

pages/about.py

@@ -0,0 +1,30 @@
+import streamlit as st
+from menu import menu_with_redirect
+
+# Path manipulation
+from pathlib import Path
+
+# Custom and other imports
+import project_config
+
+# Redirect to app.py if not logged in, otherwise show the navigation menu
+menu_with_redirect()
+
+# Header
+st.image(str(project_config.MEDIA_DIR / 'about_header.svg'), use_column_width=True)
+
+# Main content
+st.markdown("Welcome to CIPHER, a knowledge-grounded artificial intelligence (AI) system for **C**ontextually **I**nformed **P**recision **HE**althca**R**e in Parkinson's disease (PD).")
+
+# Subheader
+st.subheader("About CIPHER", divider = "grey")
+
+st.markdown("""
+CIPHER is a knowledge graph-based AI algorithm for diagnostic and therapeutic discovery in PD.
+            
+*Knowledge graph construction.* To create CIPHER, we integrated diverse public information about basic biomedical interactions into a harmonized data platform amenable for training large-scale AI models. Specifically, we constructed a multiscale heterogeneous knowledge graph (KG) with *n = 143,093* nodes and *n = 7,048,795* edges by curating 36 high-quality primary data sources, ontologies, and knowledge bases.
+            
+*Model training.* Next, to convert this trove of knowledge into an AI model with diagnostic and therapeutic capabilities, we employed graph representation learning, a deep learning to model biomedical networks by embedding graphs into informative low-dimensional vector spaces. We trained a state-of-the-art heterogeneous graph transformer to learn graph embeddings that encode the relationships in the KG.
+            
+Through CIPHER, we seek to enable molecular subtyping and patient stratification of PD by integrating genetic and clinical progression data (*e.g.*, PPMI and HBS2.0 cohorts) and nominate genes, proteins, and pathways for in-depth mechanistic studies in stem cell and other PD models.
+""")

pages/admin.py

@@ -0,0 +1,13 @@
+import streamlit as st
+from menu import menu_with_redirect
+
+# Redirect to app.py if not logged in, otherwise show the navigation menu
+menu_with_redirect()
+
+# Verify the user's role
+if st.session_state.role not in ["admin"]:
+    st.warning("You do not have permission to view this page.")
+    st.stop()
+
+st.title("User Management")
+st.markdown(f"You are currently logged with the role of {st.session_state.role}.")

pages/input.py

@@ -0,0 +1,107 @@
+import streamlit as st
+from menu import menu_with_redirect
+
+# Standard imports
+import numpy as np
+import pandas as pd
+
+# Path manipulation
+from pathlib import Path
+
+# Custom and other imports
+import project_config
+from utils import load_kg
+
+# Redirect to app.py if not logged in, otherwise show the navigation menu
+menu_with_redirect()
+
+# Header
+st.image(str(project_config.MEDIA_DIR / 'input_header.svg'), use_column_width=True)
+
+# Main content
+# st.markdown(f"Hello, {st.session_state.name}!")
+
+st.subheader("Construct Query", divider = "red")
+
+# # Checkbox to allow reverse edges
+# allow_reverse_edges = st.checkbox("Reverse Edges", value = False)
+
+# Load knowledge graph
+kg_nodes = load_kg()
+
+with st.spinner('Loading knowledge graph...'):
+    # kg_nodes = nodes = pd.read_csv(project_config.DATA_DIR / 'kg_nodes.csv', dtype = {'node_index': int}, low_memory = False)
+    node_types = pd.read_csv(project_config.DATA_DIR / 'kg_node_types.csv')
+    edge_types = pd.read_csv(project_config.DATA_DIR / 'kg_edge_types.csv')
+
+    # if not allow_reverse_edges:
+    #    edge_types = edge_types[edge_types.direction == 'forward']
+
+# If query is not in session state, initialize it
+if "query" not in st.session_state:
+    source_node_type_index = 0
+    source_node_index = 0
+    target_node_type_index = 0
+    relation_index = 0
+else:
+    source_node_type_index = st.session_state.query_options['source_node_type'].index(st.session_state.query['source_node_type'])
+    source_node_index = st.session_state.query_options['source_node'].index(st.session_state.query['source_node'])
+    target_node_type_index = st.session_state.query_options['target_node_type'].index(st.session_state.query['target_node_type'])
+    relation_index = st.session_state.query_options['relation'].index(st.session_state.query['relation'])
+
+# Select source node type
+# source_node_type_options = node_types['node_type']
+# source_node_type = st.selectbox("Source Node Type", source_node_type_options,
+#                                 format_func = lambda x: x.replace("_", " "), index = source_node_type_index)
+source_node_type = "disease"
+
+# Select source node
+# source_node_options = kg_nodes[kg_nodes['node_type'] == source_node_type]['node_name']
+# source_node = st.selectbox("Source Node", source_node_options,
+#                            index = source_node_index)
+source_node = "Parkinson disease"
+
+# Select target node type
+target_node_type_options = edge_types[edge_types.x_type == source_node_type].y_type.unique()
+target_node_type = st.selectbox("Target Node Type", target_node_type_options,
+                                format_func = lambda x: x.replace("_", " "), index = target_node_type_index)
+
+# Select relation
+relation_options = edge_types[(edge_types.x_type == source_node_type) & (edge_types.y_type == target_node_type)].relation.unique()
+relation = st.selectbox("Edge Type", relation_options,
+                        format_func = lambda x: x.replace("_", "-"), index = relation_index)
+
+# Button to submit query
+if st.button("Submit Query"):
+    
+    # Save query to session state
+    st.session_state.query = {
+        "source_node_type": source_node_type,
+        "source_node": source_node,
+        "target_node_type": target_node_type,
+        "relation": relation
+    }
+
+    # Save query options to session state
+    st.session_state.query_options = {
+        # "source_node_type": list(source_node_type_options),
+        # "source_node": list(source_node_options),
+        "source_node_type": ["disease"],
+        "source_node": ["Parkinson disease"],
+        "target_node_type": list(target_node_type_options),
+        "relation": list(relation_options)
+    }
+
+    # # Write query to console
+    # st.write("Current Query:")
+    # st.write(st.session_state.query)
+    st.write("Query submitted.")
+
+    # Switch to the Predict page
+    st.switch_page("pages/predict.py")
+
+
+# st.subheader("Knowledge Graph", divider = "red")    
+# display_data = kg_nodes[['node_id', 'node_type', 'node_name', 'node_source']].copy()
+# display_data = display_data.rename(columns = {'node_id': 'ID', 'node_type': 'Type', 'node_name': 'Name', 'node_source': 'Database'})
+# st.dataframe(display_data, use_container_width = True)

pages/predict.py

@@ -0,0 +1,199 @@
+import streamlit as st
+from menu import menu_with_redirect
+
+# Standard imports
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# Path manipulation
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+
+# Plotting
+import matplotlib.pyplot as plt
+plt.rcParams['font.sans-serif'] = 'Arial'
+
+# Custom and other imports
+import project_config
+from utils import capitalize_after_slash, load_kg
+
+# Redirect to app.py if not logged in, otherwise show the navigation menu
+menu_with_redirect()
+
+# Header
+st.image(str(project_config.MEDIA_DIR / 'predict_header.svg'), use_column_width=True)
+
+# Main content
+# st.markdown(f"Hello, {st.session_state.name}!")
+
+st.subheader(f"{capitalize_after_slash(st.session_state.query['target_node_type'])} Search", divider = "blue")
+
+# Print current query
+st.markdown(f"**Query:** {st.session_state.query['source_node'].replace('_', ' ')} ➡️ {st.session_state.query['relation'].replace('_', '-')} ➡️ {st.session_state.query['target_node_type'].replace('_', ' ')}")
+
+@st.cache_data(show_spinner = 'Downloading AI model...')
+def get_embeddings():
+    # Get checkpoint name
+    # best_ckpt = "2024_05_22_11_59_43_epoch=18-step=22912"
+    best_ckpt = "2024_05_15_13_05_33_epoch=2-step=40383"
+    # best_ckpt = "2024_03_29_04_12_52_epoch=3-step=54291"
+
+    # Get paths to embeddings, relation weights, and edge types
+    # with st.spinner('Downloading AI model...'):
+    embed_path = hf_hub_download(repo_id="ayushnoori/galaxy",
+                                filename=(best_ckpt + "-thresh=4000_embeddings.pt"),
+                                token=st.secrets["HF_TOKEN"])
+    relation_weights_path = hf_hub_download(repo_id="ayushnoori/galaxy",
+                                            filename=(best_ckpt + "_relation_weights.pt"),
+                                            token=st.secrets["HF_TOKEN"])
+    edge_types_path = hf_hub_download(repo_id="ayushnoori/galaxy",
+                                        filename=(best_ckpt + "_edge_types.pt"),
+                                        token=st.secrets["HF_TOKEN"])
+    return embed_path, relation_weights_path, edge_types_path
+
+@st.cache_data(show_spinner = 'Loading AI model...')
+def load_embeddings(embed_path, relation_weights_path, edge_types_path):
+    # Load embeddings, relation weights, and edge types
+    # with st.spinner('Loading AI model...'):
+    embeddings = torch.load(embed_path)
+    relation_weights = torch.load(relation_weights_path)
+    edge_types = torch.load(edge_types_path)
+
+    return embeddings, relation_weights, edge_types
+
+# Load knowledge graph and embeddings
+kg_nodes = load_kg()
+embed_path, relation_weights_path, edge_types_path = get_embeddings()
+embeddings, relation_weights, edge_types = load_embeddings(embed_path, relation_weights_path, edge_types_path)
+
+# # Print source node type
+# st.write(f"Source Node Type: {st.session_state.query['source_node_type']}")
+
+# # Print source node
+# st.write(f"Source Node: {st.session_state.query['source_node']}")
+
+# # Print relation
+# st.write(f"Edge Type: {st.session_state.query['relation']}")
+
+# # Print target node type
+# st.write(f"Target Node Type: {st.session_state.query['target_node_type']}")
+
+# Compute predictions
+with st.spinner('Computing predictions...'):
+
+    source_node_type = st.session_state.query['source_node_type']
+    source_node = st.session_state.query['source_node']
+    relation = st.session_state.query['relation']
+    target_node_type = st.session_state.query['target_node_type']
+
+    # Get source node index
+    src_index = kg_nodes[(kg_nodes.node_type == source_node_type) & (kg_nodes.node_name == source_node)].node_index.values[0]
+
+    # Get relation index
+    edge_type_index = [i for i, etype in enumerate(edge_types) if etype == (source_node_type, relation, target_node_type)][0]
+
+    # Get target nodes indices
+    target_nodes = kg_nodes[kg_nodes.node_type == target_node_type].copy()
+    dst_indices = target_nodes.node_index.values
+    src_indices = np.repeat(src_index, len(dst_indices))
+
+    # Retrieve cached embeddings and apply activation function
+    src_embeddings = embeddings[src_indices]
+    dst_embeddings = embeddings[dst_indices]
+    src_embeddings = F.leaky_relu(src_embeddings)
+    dst_embeddings = F.leaky_relu(dst_embeddings)
+
+    # Get relation weights
+    rel_weights = relation_weights[edge_type_index]
+
+    # Compute weighted dot product
+    scores = torch.sum(src_embeddings * rel_weights * dst_embeddings, dim = 1)
+    scores = torch.sigmoid(scores)
+
+    # Add scores to dataframe
+    target_nodes['score'] = scores.detach().numpy()
+    target_nodes = target_nodes.sort_values(by = 'score', ascending = False)
+    target_nodes['rank'] = np.arange(1, target_nodes.shape[0] + 1)
+
+    # Rename columns
+    display_data = target_nodes[['rank', 'node_id', 'node_name', 'score', 'node_source']].copy()
+    display_data = display_data.rename(columns = {'rank': 'Rank', 'node_id': 'ID', 'node_name': 'Name', 'score': 'Score', 'node_source': 'Database'})
+
+    # Define dictionary mapping node types to database URLs
+    map_dbs = {
+        'gene/protein': lambda x: f"https://ncbi.nlm.nih.gov/gene/?term={x}",
+        'drug': lambda x: f"https://go.drugbank.com/drugs/{x}",
+        'effect/phenotype': lambda x: f"https://hpo.jax.org/app/browse/term/HP:{x.zfill(7)}", # pad with 0s to 7 digits
+        'disease': lambda x: x, # MONDO
+        # pad with 0s to 7 digits
+        'biological_process': lambda x: f"https://amigo.geneontology.org/amigo/term/GO:{x.zfill(7)}", 
+        'molecular_function': lambda x: f"https://amigo.geneontology.org/amigo/term/GO:{x.zfill(7)}",
+        'cellular_component': lambda x: f"https://amigo.geneontology.org/amigo/term/GO:{x.zfill(7)}",
+        'exposure': lambda x: f"https://ctdbase.org/detail.go?type=chem&acc={x}",
+        'pathway': lambda x: f"https://reactome.org/content/detail/{x}",
+        'anatomy': lambda x: x,
+    }
+
+    # Get name of database
+    display_database = display_data['Database'].values[0] 
+
+    # Add URLs to database column
+    display_data['Database'] = display_data.apply(lambda x: map_dbs[target_node_type](x['ID']), axis = 1)
+
+
+    # NODE SEARCH
+
+    # Use multiselect to search for specific nodes
+    selected_nodes = st.multiselect(f"Search for specific {st.session_state.query['source_node_type'].replace('_', ' ')} nodes to determine their ranking.",
+                                    display_data.Name, placeholder = "Type to search...")
+
+    # Filter nodes
+    if len(selected_nodes) > 0:
+        selected_display_data = display_data[display_data.Name.isin(selected_nodes)]
+
+        # Show filtered nodes
+        if target_node_type not in ['disease', 'anatomy']:
+            st.dataframe(selected_display_data, use_container_width = True,
+                        column_config={"Database": st.column_config.LinkColumn(width = "small",
+                                                                               help = "Click to visit external database.",
+                                                                               display_text = display_database)})
+        else:
+            st.dataframe(selected_display_data, use_container_width = True)
+
+        # Plot rank vs. score using matplotlib
+        st.markdown("**Rank vs. Score**")
+        fig, ax = plt.subplots(figsize = (10, 6))
+        ax.plot(display_data['Rank'], display_data['Score'])
+        ax.set_xlabel('Rank', fontsize = 12)
+        ax.set_ylabel('Score', fontsize = 12)
+        ax.set_xlim(1, display_data['Rank'].max())
+
+        # Add vertical line for selected nodes
+        for i, node in selected_display_data.iterrows():
+            ax.axvline(node['Rank'], color = 'red', linestyle = '--', label = node['Name'])
+            ax.text(node['Rank'] + 100, node['Score'], node['Name'], fontsize = 10, color = 'red')
+
+        # Show plot
+        st.pyplot(fig)
+    
+    
+    # FULL RESULTS
+
+    # Show top ranked nodes
+    st.subheader("Model Predictions", divider = "blue")
+    top_k = st.slider('Select number of top ranked nodes to show.', 1, target_nodes.shape[0], min(500, target_nodes.shape[0])) 
+    
+    if target_node_type not in ['disease', 'anatomy']:
+        st.dataframe(display_data.iloc[:top_k], use_container_width = True,
+                    column_config={"Database": st.column_config.LinkColumn(width = "small",
+                                                                           help = "Click to visit external database.",
+                                                                           display_text = display_database)})
+    else:
+        st.dataframe(display_data.iloc[:top_k], use_container_width = True)
+
+    # Save to session state
+    st.session_state.predictions = display_data
+    st.session_state.display_database = display_database

pages/validate.py

@@ -0,0 +1,114 @@
+import streamlit as st
+from menu import menu_with_redirect
+
+# Standard imports
+import numpy as np
+import pandas as pd
+
+# Path manipulation
+from pathlib import Path
+
+# Plotting
+import matplotlib.pyplot as plt
+plt.rcParams['font.sans-serif'] = 'Arial'
+import matplotlib.colors as mcolors
+
+# Custom and other imports
+import project_config
+from utils import load_kg, load_kg_edges
+
+# Redirect to app.py if not logged in, otherwise show the navigation menu
+menu_with_redirect()
+
+# Header
+st.image(str(project_config.MEDIA_DIR / 'validate_header.svg'), use_column_width=True)
+
+# Main content
+# st.markdown(f"Hello, {st.session_state.name}!")
+
+st.subheader("Validate Predictions", divider = "green")
+
+# Print current query
+st.markdown(f"**Query:** {st.session_state.query['source_node'].replace('_', ' ')} ➡️ {st.session_state.query['relation'].replace('_', '-')} ➡️ {st.session_state.query['target_node_type'].replace('_', ' ')}")
+
+# Coming soon
+# st.write("Coming soon...")
+
+source_node_type = st.session_state.query['source_node_type']
+source_node = st.session_state.query['source_node']
+relation = st.session_state.query['relation']
+target_node_type = st.session_state.query['target_node_type']
+predictions = st.session_state.predictions
+
+kg_nodes = load_kg()
+kg_edges = load_kg_edges()
+
+# Convert tuple to hex
+def rgba_to_hex(rgba):
+    return mcolors.to_hex(rgba[:3])
+
+with st.spinner('Searching known relationships...'):
+
+    # Subset existing edges
+    edge_subset = kg_edges[(kg_edges.x_type == source_node_type) & (kg_edges.x_name == source_node)]
+    edge_subset = edge_subset[edge_subset.y_type == target_node_type]
+
+    # Merge edge subset with predictions
+    edges_in_kg = pd.merge(predictions, edge_subset[['relation', 'y_id']], left_on = 'ID', right_on = 'y_id', how = 'right')
+    edges_in_kg = edges_in_kg.sort_values(by = 'Score', ascending = False)
+    edges_in_kg = edges_in_kg.drop(columns = 'y_id')
+
+    # Rename relation to ground-truth
+    edges_in_kg = edges_in_kg[['relation'] + [col for col in edges_in_kg.columns if col != 'relation']]
+    edges_in_kg = edges_in_kg.rename(columns = {'relation': 'Known Relation'})
+
+# If there exist edges in KG
+if len(edges_in_kg) > 0:
+
+    with st.spinner('Plotting known relationships...'):
+
+        # Define a color map for different relations
+        color_map = plt.get_cmap('tab10')
+
+        # Group by relation and create separate plots
+        relations = edges_in_kg['Known Relation'].unique()
+        for idx, relation in enumerate(relations):
+
+            relation_data = edges_in_kg[edges_in_kg['Known Relation'] == relation]
+
+            # Get a color from the color map
+            color = color_map(idx % color_map.N)
+
+            fig, ax = plt.subplots(figsize=(10, 3))
+            ax.plot(predictions['Rank'], predictions['Score'])
+            ax.set_xlabel('Rank', fontsize=12)
+            ax.set_ylabel('Score', fontsize=12)
+            ax.set_xlim(1, predictions['Rank'].max())
+            
+            for i, node in relation_data.iterrows():
+                ax.axvline(node['Rank'], color=color, linestyle='--', label=node['Name'])
+                # ax.text(node['Rank'] + 100, node['Score'], node['Name'], fontsize=10, color=color)
+            
+            # ax.set_title(f'{relation.replace("_", "-")}')
+            # ax.legend()
+            color_hex = rgba_to_hex(color)
+
+            # Write header in color of relation
+            st.markdown(f"<h3 style='color:{color_hex}'>{relation.replace('_', ' ').title()}</h2>", unsafe_allow_html=True)
+
+            # Show plot
+            st.pyplot(fig)
+
+            # Drop known relation column
+            relation_data = relation_data.drop(columns = 'Known Relation')
+            if target_node_type not in ['disease', 'anatomy']:
+                st.dataframe(relation_data, use_container_width=True,
+                            column_config={"Database": st.column_config.LinkColumn(width = "small",
+                                                                                    help = "Click to visit external database.",
+                                                                                    display_text = st.session_state.display_database)})
+            else:
+                st.dataframe(relation_data, use_container_width=True)
+
+else:
+
+    st.error('No ground truth relationships found for the given query in the knowledge graph.', icon="✖️")

project_config.py

@@ -0,0 +1,17 @@
+'''
+PROJECT CONFIGURATION FILE
+This file contains the configuration variables for the project. The variables are used 
+in the other scripts to define the paths to the data and results directories. The variables 
+are also used to set the random seed for reproducibility.
+'''
+
+# import libraries
+import os
+from pathlib import Path
+
+# define project configuration variables
+PROJECT_DIR = Path(os.getcwd())
+DATA_DIR = PROJECT_DIR / 'data'
+MODEL_DIR = PROJECT_DIR / 'models'
+MEDIA_DIR = PROJECT_DIR / 'media'
+SEED = 42

requirements.txt

@@ -0,0 +1,11 @@
+numpy
+pandas
+scikit-learn
+matplotlib
+seaborn
+pathlib
+torch
+altair<5
+gspread
+oauth2client
+huggingface_hub

utils.py

@@ -0,0 +1,75 @@
+import streamlit as st
+import pandas as pd
+import project_config
+import base64
+
+
+@st.cache_data(show_spinner = 'Loading knowledge graph nodes...')
+def load_kg():
+    # with st.spinner('Loading knowledge graph...'):
+    kg_nodes = pd.read_csv(project_config.DATA_DIR / 'kg_nodes.csv', dtype = {'node_index': int}, low_memory = False)
+    return kg_nodes
+
+
+@st.cache_data(show_spinner = 'Loading knowledge graph edges...')
+def load_kg_edges():
+    # with st.spinner('Loading knowledge graph...'):
+    kg_edges = pd.read_csv(project_config.DATA_DIR / 'kg_edges.csv', dtype = {'edge_index': int, 'x_index': int, 'y_index': int}, low_memory = False)
+    return kg_edges
+
+
+def capitalize_after_slash(s):
+    # Split the string by slashes first
+    parts = s.split('/')
+    # Capitalize each part separately
+    capitalized_parts = [part.title() for part in parts]
+    # Rejoin the parts with slashes
+    capitalized_string = '/'.join(capitalized_parts).replace('_', ' ')
+    return capitalized_string
+
+
+# From https://stackoverflow.com/questions/73251012/put-logo-and-title-above-on-top-of-page-navigation-in-sidebar-of-streamlit-multi
+# See also https://arnaudmiribel.github.io/streamlit-extras/extras/app_logo/ 
+@st.cache_data()
+def get_base64_of_bin_file(png_file):
+    with open(png_file, "rb") as f:
+        data = f.read()
+    return base64.b64encode(data).decode()
+
+
+def build_markup_for_logo(
+    png_file,
+    background_position="50% 10%",
+    margin_top="10%",
+    padding="20px",
+    image_width="80%",
+    image_height="",
+):
+    binary_string = get_base64_of_bin_file(png_file)
+    return """
+            <style>
+                [data-testid="stSidebarNav"] {
+                    background-image: url("data:image/png;base64,%s");
+                    background-repeat: no-repeat;
+                    background-position: %s;
+                    margin-top: %s;
+                    padding: %s;
+                    background-size: %s %s;
+                }
+            </style>
+            """ % (
+        binary_string,
+        background_position,
+        margin_top,
+        padding,
+        image_width,
+        image_height,
+    )
+
+
+def add_logo(png_file):
+    logo_markup = build_markup_for_logo(png_file)
+    st.markdown(
+        logo_markup,
+        unsafe_allow_html=True,
+    )