Initial Commit

.gitignore

@@ -0,0 +1,176 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+#
+#
+
+ImageNet-HARD-EMD-Real.zip
+demonstrations.zip
+ImageNet-HARD-Normal.zip
+demonstrations/
+visualizations_feb2022/
+ImageNet-HARD-EMD-5-Patches-Real.zip
+visualizations
+imagenet1k-pilot.tar.gz
+predictions/
+imagenet1k-pilot.zip
+Final.zip
+imagenet1k-val-50k-emd_results_rosy-brook-184.pickle
+CUB-Final.zip
+CUB-Demonstrations/

SessionState.py

@@ -0,0 +1,117 @@
+"""Hack to add per-session state to Streamlit.
+
+Usage
+-----
+
+>>> import SessionState
+>>>
+>>> session_state = SessionState.get(user_name='', favorite_color='black')
+>>> session_state.user_name
+''
+>>> session_state.user_name = 'Mary'
+>>> session_state.favorite_color
+'black'
+
+Since you set user_name above, next time your script runs this will be the
+result:
+>>> session_state = get(user_name='', favorite_color='black')
+>>> session_state.user_name
+'Mary'
+
+"""
+try:
+    import streamlit.ReportThread as ReportThread
+    from streamlit.server.Server import Server
+except Exception:
+    # Streamlit >= 0.65.0
+    import streamlit.report_thread as ReportThread
+    from streamlit.server.server import Server
+
+
+class SessionState(object):
+    def __init__(self, **kwargs):
+        """A new SessionState object.
+
+        Parameters
+        ----------
+        **kwargs : any
+            Default values for the session state.
+
+        Example
+        -------
+        >>> session_state = SessionState(user_name='', favorite_color='black')
+        >>> session_state.user_name = 'Mary'
+        ''
+        >>> session_state.favorite_color
+        'black'
+
+        """
+        for key, val in kwargs.items():
+            setattr(self, key, val)
+
+
+def get(**kwargs):
+    """Gets a SessionState object for the current session.
+
+    Creates a new object if necessary.
+
+    Parameters
+    ----------
+    **kwargs : any
+        Default values you want to add to the session state, if we're creating a
+        new one.
+
+    Example
+    -------
+    >>> session_state = get(user_name='', favorite_color='black')
+    >>> session_state.user_name
+    ''
+    >>> session_state.user_name = 'Mary'
+    >>> session_state.favorite_color
+    'black'
+
+    Since you set user_name above, next time your script runs this will be the
+    result:
+    >>> session_state = get(user_name='', favorite_color='black')
+    >>> session_state.user_name
+    'Mary'
+
+    """
+    # Hack to get the session object from Streamlit.
+
+    ctx = ReportThread.get_report_ctx()
+
+    this_session = None
+
+    current_server = Server.get_current()
+    if hasattr(current_server, '_session_infos'):
+        # Streamlit < 0.56
+        session_infos = Server.get_current()._session_infos.values()
+    else:
+        session_infos = Server.get_current()._session_info_by_id.values()
+
+    for session_info in session_infos:
+        s = session_info.session
+        if (
+            # Streamlit < 0.54.0
+            (hasattr(s, '_main_dg') and s._main_dg == ctx.main_dg)
+            or
+            # Streamlit >= 0.54.0
+            (not hasattr(s, '_main_dg') and s.enqueue == ctx.enqueue)
+            or
+            # Streamlit >= 0.65.2
+            (not hasattr(s, '_main_dg') and s._uploaded_file_mgr == ctx.uploaded_file_mgr)
+        ):
+            this_session = s
+
+    if this_session is None:
+        raise RuntimeError(
+            "Oh noes. Couldn't get your Streamlit Session object. "
+            'Are you doing something fancy with threads?')
+
+    # Got the session object! Now let's attach some state into it.
+
+    if not hasattr(this_session, '_custom_session_state'):
+        this_session._custom_session_state = SessionState(**kwargs)
+
+    return this_session._custom_session_state

app.py

@@ -0,0 +1,406 @@
+import json
+import os
+import pickle
+import random
+import time
+from collections import Counter
+from datetime import datetime
+from glob import glob
+
+import gdown
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import streamlit as st
+from PIL import Image
+
+import SessionState
+from download_utils import *
+from image_utils import *
+
+random.seed(datetime.now())
+np.random.seed(int(time.time()))
+
+NUMBER_OF_TRIALS = 20
+CLASSIFIER_TAG = ""
+selected_xai_tool = None
+
+# Config
+folder_to_name = {}
+# class_descriptions = {}
+classifier_predictions = {}
+selected_dataset = "Task-1-CUB-iNat-HumanStudy"
+
+root_visualization_dir = "./visualizations/"
+viz_url = "https://static.taesiri.com/xai/CUB-Task1.zip"
+viz_archivefile = "CUB-Final.zip"
+
+demonstration_url = "https://static.taesiri.com/xai/cub-demonstrations.zip"
+demonst_zipfile = "demonstrations.zip"
+
+picklefile_url = "https://static.taesiri.com/xai/Task1-CUB-CHMOnly.pickle"
+prediction_root = "./predictions/"
+prediction_pickle = f"{prediction_root}predictions.pickle"
+
+
+# Get the Data
+download_files(
+    root_visualization_dir,
+    viz_url,
+    viz_archivefile,
+    demonstration_url,
+    demonst_zipfile,
+    picklefile_url,
+    prediction_root,
+    prediction_pickle,
+)
+################################################
+# GLOBAL VARIABLES
+app_mode = ""
+
+# Shared/Global Information
+birds_list = list(
+    sorted([x.replace(".jpg", "") for x in os.listdir("./CUB-Demonstrations")])
+)
+id_to_bird = {i: x for i, x in enumerate(birds_list)}
+folder_to_name = {x: x for x in birds_list}  #
+################################################
+
+with open(prediction_pickle, "rb") as f:
+    classifier_predictions = pickle.load(f)
+
+# SESSION STATE
+session_state = SessionState.get(
+    page=1,
+    first_run=1,
+    user_feedback={},
+    queries=[],
+    is_classifier_correct={},
+    XAI_tool="Unselected",
+)
+################################################
+
+
+def resmaple_queries():
+    if session_state.first_run == 1:
+        both_correct = glob(
+            root_visualization_dir + selected_dataset + "/Both_correct/*.jpg"
+        )
+        both_wrong = glob(
+            root_visualization_dir + selected_dataset + "/Both_wrong/*.jpg"
+        )
+
+        correct_samples = list(
+            np.random.choice(a=both_correct, size=NUMBER_OF_TRIALS // 2, replace=False)
+        )
+        wrong_samples = list(
+            np.random.choice(a=both_wrong, size=NUMBER_OF_TRIALS // 2, replace=False)
+        )
+
+        all_images = correct_samples + wrong_samples
+        random.shuffle(all_images)
+        session_state.queries = all_images
+        session_state.first_run = -1
+        # RESET INTERACTIONS
+        session_state.user_feedback = {}
+        session_state.is_classifier_correct = {}
+
+
+def render_experiment(query):
+    current_query = session_state.queries[query]
+    query_id = os.path.basename(current_query)
+
+    predicted_wnid = classifier_predictions[query_id][f"{CLASSIFIER_TAG}-predictions"]
+    prediction_confidence = classifier_predictions[query_id][
+        f"{CLASSIFIER_TAG}-confidence"
+    ]
+    prediction_label = folder_to_name[predicted_wnid]
+    # class_def = class_descriptions[predicted_wnid]
+
+    session_state.is_classifier_correct[query_id] = classifier_predictions[query_id][
+        f"{CLASSIFIER_TAG.upper()}-Output"
+    ]
+
+    # SHOW QUERY and PREDICTION
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.image(load_query(current_query), caption=f"Query ID: {query_id}")
+    with col2:
+        # SHOW DESCRIPTION OF CLASS
+        with st.expander("Show Class Description"):
+            st.write(f"**Name**: {prediction_label}")
+            st.write("**Class Definition**:")
+            # st.markdown("`" + class_def + "`")
+            st.image(
+                Image.open(f"CUB-Demonstrations/{predicted_wnid}.jpg"),
+                caption=f"Class Explanation",
+                use_column_width=True,
+            )
+
+        default_value = 0
+        if query_id in session_state.user_feedback.keys():
+            if session_state.user_feedback[query_id] == "Correct":
+                default_value = 1
+            elif session_state.user_feedback[query_id] == "Wrong":
+                default_value = 2
+
+        session_state.user_feedback[query_id] = st.radio(
+            "What do you think about model's prediction?",
+            ("-", "Correct", "Wrong"),
+            key=query_id,
+            index=default_value,
+        )
+        st.write(f"**Model Prediction**: {prediction_label}")
+        st.write(f"**Model Confidence**: {prediction_confidence}")
+
+    # SHOW Model Explanation
+    if selected_xai_tool is not None:
+        st.image(
+            selected_xai_tool(current_query),
+            caption=f"Explaination",
+            use_column_width=True,
+        )
+
+    # SHOW DEBUG INFO
+
+    if st.button("Debug: Show Everything"):
+        st.image(Image.open(current_query))
+
+
+def render_results():
+    user_correct_guess = 0
+    # st.write(session_state.user_feedback)
+    # st.write(session_state.is_classifier_correct)
+    for q in session_state.user_feedback.keys():
+        if session_state.user_feedback[q] != "-":
+            uf = True if session_state.user_feedback[q] == "Correct" else False
+            if session_state.is_classifier_correct[q] == uf:
+                user_correct_guess += 1
+
+    st.write(
+        f"User performance on {CLASSIFIER_TAG}: {user_correct_guess} out of {len( session_state.user_feedback)} Correct"
+    )
+    st.markdown("##  User Performance Breakdown")
+
+    categories = [
+        "Correct",
+        "Wrong",
+    ]  # set(session_state.is_classifier_correct.values())
+    breakdown_stats_correct = {c: 0 for c in categories}
+    breakdown_stats_wrong = {c: 0 for c in categories}
+
+    experiment_summary = []
+
+    for q in session_state.user_feedback.keys():
+        category = "Correct" if session_state.is_classifier_correct[q] else "Wrong"
+        is_user_correct = category == session_state.user_feedback[q]
+
+        if is_user_correct:
+            breakdown_stats_correct[category] += 1
+        else:
+            breakdown_stats_wrong[category] += 1
+
+        experiment_summary.append(
+            [
+                q,
+                classifier_predictions[q]["gt_wnid"],
+                folder_to_name[
+                    classifier_predictions[q][f"{CLASSIFIER_TAG}-predictions"]
+                ],
+                category,
+                session_state.user_feedback[q],
+                is_user_correct,
+            ]
+        )
+    # Summary Table
+    experiment_summary_df = pd.DataFrame.from_records(
+        experiment_summary,
+        columns=[
+            "Query",
+            "GT Labels",
+            f"{CLASSIFIER_TAG} Prediction",
+            "Category",
+            "User Prediction",
+            "Is User Prediction Correct",
+        ],
+    )
+    st.write("Summary", experiment_summary_df)
+
+    csv = convert_df(experiment_summary_df)
+    st.download_button(
+        "Press to Download", csv, "summary.csv", "text/csv", key="download-records"
+    )
+    # SHOW BREAKDOWN
+    user_pf_by_model_pred = experiment_summary_df.groupby("Category").agg(
+        {"Is User Prediction Correct": ["count", "sum", "mean"]}
+    )
+    # rename columns
+    user_pf_by_model_pred.columns = user_pf_by_model_pred.columns.droplevel(0)
+    user_pf_by_model_pred.columns = [
+        "Count",
+        "Correct User Guess",
+        "Mean User Performance",
+    ]
+    user_pf_by_model_pred.index.name = "Model Prediction"
+    st.write("User performance break down by Model prediction:", user_pf_by_model_pred)
+    csv = convert_df(user_pf_by_model_pred)
+    st.download_button(
+        "Press to Download",
+        csv,
+        "user-performance-by-model-prediction.csv",
+        "text/csv",
+        key="download-performance-by-model-prediction",
+    )
+    # CONFUSION MATRIX
+
+    confusion_matrix = pd.crosstab(
+        experiment_summary_df["Category"],
+        experiment_summary_df["User Prediction"],
+        rownames=["Actual"],
+        colnames=["Predicted"],
+    )
+    st.write("Confusion Matrix", confusion_matrix)
+    csv = convert_df(confusion_matrix)
+    st.download_button(
+        "Press to Download",
+        csv,
+        "confusion-matrix.csv",
+        "text/csv",
+        key="download-confusiion-matrix",
+    )
+
+
+def render_menu():
+    # Render the readme as markdown using st.markdown.
+    readme_text = st.markdown(
+        """
+  # Instructions
+  ```
+  When testing this study, you should first see the class definition, then hide the expander and see the query.
+  ```
+  """
+    )
+
+    app_mode = st.selectbox(
+        "Choose the page to show:",
+        ["Experiment Instruction", "Start Experiment", "See the Results"],
+    )
+
+    if app_mode == "Experiment Instruction":
+        st.success("To continue select an option in the dropdown menu.")
+    elif app_mode == "Start Experiment":
+        # Clear Canvas
+        readme_text.empty()
+
+        page_id = session_state.page
+        col1, col4, col2, col3 = st.columns(4)
+        prev_page = col1.button("Previous Image")
+
+        if prev_page:
+            page_id -= 1
+            if page_id < 1:
+                page_id = 1
+
+        next_page = col2.button("Next Image")
+
+        if next_page:
+            page_id += 1
+            if page_id > NUMBER_OF_TRIALS:
+                page_id = NUMBER_OF_TRIALS
+
+        if page_id == NUMBER_OF_TRIALS:
+            st.success(
+                'You have reached the last image. Please go to the "Results" page to see your performance.'
+            )
+            if st.button("View"):
+                app_mode = "See the Results"
+
+        if col3.button("Resample"):
+            st.write("Restarting ...")
+            page_id = 1
+            session_state.first_run = 1
+            resmaple_queries()
+
+        session_state.page = page_id
+        st.write(f"Render Experiment: {session_state.page}")
+        render_experiment(session_state.page - 1)
+    elif app_mode == "See the Results":
+        readme_text.empty()
+        st.write("Results Summary")
+        render_results()
+
+
+def main():
+    global app_mode
+    global session_state
+    global selected_xai_tool
+    global CLASSIFIER_TAG
+
+    # Set the session state
+    # State Management and General Setup
+    st.set_page_config(layout="wide")
+    st.title("TASK - 1 - CUB")
+
+    # st.write(classifier_predictions.keys())
+    # st.write(classifier_predictions["ILSVRC2012_val_00024646.JPEG"])
+
+    options = [
+        "Unselected",
+        "NOXAI",
+        "KNN",
+        # "EMD Nearest Neighbors",
+        # "EMD Correspondence",
+        "CHM Nearest Neighbors",
+        "CHM Correspondence",
+    ]
+
+    st.markdown(
+        """ <style>
+              div[role="radiogroup"] >  :first-child{
+                  display: none !important;
+              }
+          </style>
+          """,
+        unsafe_allow_html=True,
+    )
+
+    if session_state.XAI_tool == "Unselected":
+        default = options.index(session_state.XAI_tool)
+        session_state.XAI_tool = st.radio(
+            "What explaination tool do you want to evaluate?",
+            options,
+            key="which_xai",
+            index=default,
+        )
+        # print(session_state.XAI_tool)
+
+    if session_state.XAI_tool != "Unselected":
+        st.markdown(f"## SELECTED METHOD ``{session_state.XAI_tool}``")
+
+        if session_state.XAI_tool == "NOXAI":
+            CLASSIFIER_TAG = "knn"
+            selected_xai_tool = None
+        elif session_state.XAI_tool == "KNN":
+            selected_xai_tool = load_knn_nns
+            CLASSIFIER_TAG = "knn"
+        elif session_state.XAI_tool == "CHM Nearest Neighbors":
+            selected_xai_tool = load_chm_nns
+            CLASSIFIER_TAG = "CHM"
+        elif session_state.XAI_tool == "CHM Correspondence":
+            selected_xai_tool = load_chm_corrs
+            CLASSIFIER_TAG = "CHM"
+        elif session_state.XAI_tool == "EMD Nearest Neighbors":
+            selected_xai_tool = load_emd_nns
+            CLASSIFIER_TAG = "EMD"
+        elif session_state.XAI_tool == "EMD Correspondence":
+            selected_xai_tool = load_emd_corrs
+            CLASSIFIER_TAG = "EMD"
+
+        resmaple_queries()
+        render_menu()
+
+
+if __name__ == "__main__":
+    main()

download_utils.py

@@ -0,0 +1,55 @@
+import json
+import os
+import pickle
+import random
+import tarfile
+import zipfile
+from collections import Counter
+from glob import glob
+
+import gdown
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import streamlit as st
+from PIL import Image
+
+import SessionState
+
+
+def download_files(
+    root_visualization_dir,
+    viz_url,
+    viz_archivefile,
+    demonstration_url,
+    demonst_zipfile,
+    picklefile_url,
+    prediction_root,
+    prediction_pickle,
+):
+    # Get Visualization
+    if not os.path.exists(root_visualization_dir):
+        gdown.download(viz_url, viz_archivefile, quiet=False)
+        os.makedirs(root_visualization_dir, exist_ok=True)
+
+        if viz_archivefile.endswith("tar.gz"):
+            tar = tarfile.open(viz_archivefile, "r:gz")
+            tar.extractall(path=root_visualization_dir)
+            tar.close()
+        elif viz_archivefile.endswith("zip"):
+            with zipfile.ZipFile(viz_archivefile, "r") as zip_ref:
+                zip_ref.extractall(root_visualization_dir)
+
+    # Get Demonstrations
+    if not os.path.exists(demonst_zipfile):
+        gdown.download(demonstration_url, demonst_zipfile, quiet=False)
+        # os.makedirs(roo_demonstration_dir, exist_ok=True)
+
+        with zipfile.ZipFile(demonst_zipfile, "r") as zip_ref:
+            zip_ref.extractall("./")
+
+    # Get Predictions
+    if not os.path.exists(prediction_pickle):
+        os.makedirs(prediction_root, exist_ok=True)
+        gdown.download(picklefile_url, prediction_pickle, quiet=False)

helper.py

@@ -0,0 +1,23 @@
+import os
+
+def get_label_for_query(image_url, model_name):
+      fourway_label = image_url.split('/')[-2]
+  
+  if fourway_label=='both_correct':
+    return 'Correct'
+  
+  if fourway_label=='both_wrong':
+    return 'Wrong'
+  
+  if fourway_label == 'chm_correct_knn_incorrect' and model_name == 'CHM':
+    return 'Correct'
+  elif fourway_label == 'knn_correct_chm_incorrect' and model_name == 'KNN':
+   return 'Correct'
+ 
+  return 'Wrong'
+
+def get_category(image_url):
+  return image_url.split('/')[-2]
+
+def translate_winds_to_names(winds):
+  return [folder_to_name[x] for x in winds]

image_utils.py

@@ -0,0 +1,139 @@
+import json
+import os
+import pickle
+import random
+from glob import glob
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+import streamlit as st
+from PIL import Image
+
+
+@st.cache(allow_output_mutation=True, max_entries=10, ttl=3600)
+def load_query(image_path):
+    image = Image.open(image_path)
+    width, height = image.size
+
+    new_width = width
+    new_height = height
+
+    left = (width - new_width) / 2
+    top = (height - new_height) / 2
+    right = (width + new_width) / 2
+    bottom = (height + new_height) / 2
+
+    # Crop the center of the image
+    cropped_image = image.crop(
+        (left + 75, top + 145, right - 1790, bottom - (1140))
+    ).resize((300, 300))
+
+    return cropped_image
+
+
+# CHM ############################################################################
+@st.cache(allow_output_mutation=True, max_entries=10, ttl=3600)
+def load_chm_nns(image_path):
+    image = Image.open(image_path)
+    width, height = image.size
+
+    new_width = width
+    new_height = height
+
+    left = (width - new_width) / 2
+    top = (height - new_height) / 2
+    right = (width + new_width) / 2
+    bottom = (height + new_height) / 2
+
+    # Crop the center of the image
+    cropped_image = image.crop((left + 485, top + 145, right - 15, bottom - (1140)))
+    return cropped_image
+
+
+@st.cache(allow_output_mutation=True, max_entries=10, ttl=3600)
+def load_chm_corrs(image_path):
+    image = Image.open(image_path)
+    width, height = image.size
+
+    new_width = width
+    new_height = height
+
+    left = (width - new_width) / 2
+    top = (height - new_height) / 2
+    right = (width + new_width) / 2
+    bottom = (height + new_height) / 2
+
+    # Crop the center of the image
+    cropped_image = image.crop((left + 485, top + 900, right - 15, bottom - (25 + 10)))
+    return cropped_image
+
+
+# CHM ############################################################################
+
+# KNN ############################################################################
+@st.cache(allow_output_mutation=True, max_entries=10, ttl=3600)
+def load_knn_nns(image_path):
+    image = Image.open(image_path)
+    width, height = image.size
+
+    new_width = width
+    new_height = height
+
+    left = (width - new_width) / 2
+    top = (height - new_height) / 2
+    right = (width + new_width) / 2
+    bottom = (height + new_height) / 2
+
+    # Crop the center of the image
+    cropped_image = image.crop((left + 485, top + 525, right - 10, bottom - (770)))
+    return cropped_image
+
+
+# KNN ############################################################################
+
+# EMD ############################################################################
+@st.cache(allow_output_mutation=True, max_entries=10, ttl=3600)
+def load_emd_nns(image_path):
+    image = Image.open(image_path)
+    width, height = image.size
+
+    new_width = width
+    new_height = height
+
+    left = (width - new_width) / 2
+    top = (height - new_height) / 2
+    right = (width + new_width) / 2
+    bottom = (height + new_height) / 2
+
+    # Crop the center of the image
+    cropped_image = image.crop(
+        (left + 10, top + 2075, right - 420, bottom - (925 + 25 + 10))
+    )
+    return cropped_image
+
+
+@st.cache(allow_output_mutation=True, max_entries=10, ttl=3600)
+def load_emd_corrs(image_path):
+    image = Image.open(image_path)
+    width, height = image.size
+
+    new_width = width
+    new_height = height
+
+    left = (width - new_width) / 2
+    top = (height - new_height) / 2
+    right = (width + new_width) / 2
+    bottom = (height + new_height) / 2
+
+    # Crop the center of the image
+    cropped_image = image.crop((left + 10, top + 2500, right - 20, bottom))
+    return cropped_image
+
+
+# EMD ############################################################################
+
+
+@st.cache()
+def convert_df(df):
+    return df.to_csv().encode("utf-8")