Create visualization_app.py

visualization_app.py

@@ -0,0 +1,259 @@
+# Streamlit app to visualize homoglyphs alarm experiment results
+# This app lets users interactively explore experiment results stored in timestamped results folders
+# It loads the latest results by default, but allows selection of other runs
+
+import streamlit as st
+import os
+import glob
+import pandas as pd
+import yaml
+import matplotlib.pyplot as plt
+from matplotlib import font_manager
+import pycountry
+import re
+
+# Set Streamlit theme and custom font via config.toml (no manual CSS needed)
+st.set_page_config(
+    page_title="Homoglyphs Alarm Results", page_icon="📊", layout="centered"
+)
+
+# Set matplotlib font and color palette
+font_path = "IBMPlexSans-Regular.ttf"
+font_manager.fontManager.addfont(font_path)
+plt.rcParams["font.family"] = "IBM Plex Sans"
+plt.rcParams["axes.prop_cycle"] = plt.cycler(
+    color=["#F600FF", "#FF0000", "#00FBFF", "#00AAEC", "#0034A3"]
+)
+
+
+# Helper to get all result folders sorted by timestamp (descending)
+def get_result_folders(base_dir="results"):
+    folders = [
+        os.path.join(base_dir, d)
+        for d in os.listdir(base_dir)
+        if os.path.isdir(os.path.join(base_dir, d))
+    ]
+    folders = sorted(folders, reverse=True)
+    return folders
+
+
+# Helper to load YAML parameters
+def load_parameters(yaml_path):
+    with open(yaml_path, "r") as f:
+        return yaml.safe_load(f)
+
+
+# Helper to load CSVs
+def load_csv(csv_path):
+    # The first column is the row index, so set index_col=0 and drop it
+    return pd.read_csv(csv_path, index_col=0)
+
+
+# Map ISO language codes to human names
+def iso_to_name(lang_code):
+    try:
+        return pycountry.languages.get(alpha_2=lang_code).name
+    except Exception:
+        if lang_code == "iw":
+            return "Hebrew"
+        if lang_code == "language_agnostic":
+            return "Language Agnostic"
+        return lang_code
+
+
+# Main app logic
+def main():
+    st.title("Homoglyphs Alarm Experiment Results Viewer")
+
+    # Find all result folders
+    result_folders = get_result_folders()
+    if not result_folders:
+        st.error("No results found. Please run experiments first.")
+        return
+
+    # Always use the latest results folder
+    folder = result_folders[0]
+
+    # Load parameters
+    param_path = os.path.join(folder, "parameters.yaml")
+    if not os.path.exists(param_path):
+        st.error(f"parameters.yaml not found in {folder}")
+        return
+    params = load_parameters(param_path)
+    st.sidebar.header("Run Parameters")
+
+    # Parameter descriptions for user-friendly sidebar
+    param_descriptions = {
+        "LIST_OF_PERCENTAGES": "List of percentages of text replaced with homoglyphs in the experiments.",
+        "MAX_NUM_OF_EXAMPLES_PER_LANG": "Maximum number of examples per language included in the analysis.",
+        "NUMBER_OF_TIMES_TO_RUN_PROFILING": "Number of times each alarm is run for profiling (timing) purposes.",
+        "NUMBER_OF_TEXTS_TO_PROFILE": "Number of texts used for profiling the alarms.",
+        "LIMIT_TEXTS_MAX_CHARACTERS": "Maximum number of characters per text sample.",
+        "LANGS_TO_USE": "Languages included in the experiments (ISO codes).",
+        "ALARM_TYPES_CONFIGURED": "Configured alarm types (methods for detecting homoglyph attacks).",
+    }
+
+    # Try to get alarm type display names from parameters if available
+    alarm_type_display = None
+    for k in params:
+        if k.upper() == "ALARM_TYPES_CONFIGURED" and isinstance(params[k], dict):
+            alarm_type_display = params[k]
+            break
+        if k.upper() == "ATTACK_TYPES_CONFIGURED" and isinstance(params[k], dict):
+            alarm_type_display = params[k]
+            break
+
+    def get_alarm_display_name(alarm_type):
+        if alarm_type_display and alarm_type in alarm_type_display:
+            return alarm_type_display[alarm_type]
+        return alarm_type.replace("_", " ").capitalize()
+
+    def prettify_param_name(name):
+        # Replace underscores with spaces, capitalize, and handle ALL_CAPS
+        name = re.sub(r"_+", " ", name)
+        name = name.strip().capitalize()
+        # If all uppercase, just capitalize first letter
+        if name.isupper():
+            name = name.capitalize()
+        return name
+
+    for k, v in params.items():
+        desc = param_descriptions.get(k, None)
+        if desc:
+            st.sidebar.write(f"**{prettify_param_name(k)}**: {v}")
+            st.sidebar.caption(desc)
+        else:
+            st.sidebar.write(f"**{prettify_param_name(k)}**: {v}")
+
+    # Load results
+    results_csv = os.path.join(folder, "results.csv")
+    agg_csv = os.path.join(folder, "aggregates.csv")
+    if not os.path.exists(results_csv) or not os.path.exists(agg_csv):
+        st.error("results.csv or aggregates.csv not found in selected folder.")
+        return
+    df_results = load_csv(results_csv)
+    df_agg = load_csv(agg_csv)
+
+    # Defensive: ensure 'lang' column exists and is not all NaN
+    if "lang" not in df_results.columns or df_results["lang"].isnull().all():
+        st.error(
+            "No language information found in results.csv. Please check your experiment output."
+        )
+        return
+
+    # Map ISO language codes to human names (fix KeyError)
+    if "lang_name" not in df_results.columns:
+        df_results["lang_name"] = df_results["lang"].apply(iso_to_name)
+    if "lang" in df_agg.columns and "lang_name" not in df_agg.columns:
+        df_agg["lang_name"] = df_agg["lang"].apply(iso_to_name)
+
+    # Load profiling results if available
+    profiling_csv = os.path.join(folder, "profiling.csv")
+    df_profiling = None
+    if os.path.exists(profiling_csv):
+        df_profiling = load_csv(profiling_csv)
+
+    tab1, tab2, tab3 = st.tabs(
+        ["Language-centric view", "Alarm-centric view", "Profiling results"]
+    )
+
+    # --- Tab 1: Language-centric view ---
+    with tab1:
+        st.header(
+            "Language-centric: Compare alarms and percentages for a given language"
+        )
+        language_names = df_results["lang_name"].unique().tolist()
+        lang_name = st.selectbox("Language:", language_names, key="lang_tab2")
+        lang = None
+        for code in df_results["lang"].unique():
+            if iso_to_name(code) == lang_name:
+                lang = code
+                break
+        filtered = df_results[df_results["lang"] == lang]
+        st.subheader(f"AUC by Alarm and Percentage for {lang_name}")
+        # Show human-friendly alarm names in the table
+        filtered_disp = filtered.copy()
+        filtered_disp["alarm_display"] = filtered_disp["alarm_type"].apply(
+            get_alarm_display_name
+        )
+        st.dataframe(
+            filtered_disp[["alarm_display", "percentage", "auc"]]
+            .rename(columns={"alarm_display": "Alarm type"})
+            .sort_values(["Alarm type", "percentage"])
+        )
+        # Plot
+        fig, ax = plt.subplots()
+        for alarm in filtered["alarm_type"].unique():
+            sub = filtered[filtered["alarm_type"] == alarm]
+            ax.plot(
+                sub["percentage"],
+                sub["auc"],
+                marker="o",
+                label=get_alarm_display_name(alarm),
+            )
+        ax.set_xlabel("Percentage of text replaced")
+        ax.set_ylabel("AUC (Area Under Curve)")
+        ax.set_title(f"AUC by Alarm for {lang_name}")
+        ax.legend(title="Alarm type")
+        st.pyplot(fig)
+
+    # --- Tab 2: Alarm-centric view ---
+    with tab2:
+        st.header("Alarm-centric: Compare languages for a given alarm and percentage")
+        alarm_types = df_results["alarm_type"].unique().tolist()
+        alarm = st.selectbox(
+            "Alarm type:",
+            alarm_types,
+            key="alarm_tab1",
+            help="Select the alarm (detection method) to analyze.",
+            format_func=get_alarm_display_name,
+        )
+        percentages = sorted(df_results["percentage"].unique())
+        perc = st.selectbox(
+            "Percentage:",
+            percentages,
+            key="perc_tab1",
+            help="Select the percentage of text replaced with homoglyphs.",
+        )
+        filtered = df_results[
+            (df_results["alarm_type"] == alarm) & (df_results["percentage"] == perc)
+        ]
+        st.subheader(f"AUC by Language for {get_alarm_display_name(alarm)} at {perc}")
+        st.dataframe(
+            filtered[["lang_name", "auc"]]
+            .sort_values("auc", ascending=False)
+            .reset_index(drop=True)
+        )
+        st.info(
+            f"As there are {len(df_results['lang'].unique())} languages, we can't show all of them in a chart. "
+            "Please use the Language-centric tab to explore individual languages."
+        )
+        # Chart removed for clarity due to too many languages
+
+    # --- Tab 3: Profiling results ---
+    with tab3:
+        st.header("Profiling Results: Alarm Execution Time and Efficiency")
+        if df_profiling is not None:
+            st.dataframe(df_profiling)
+            st.markdown(
+                """
+            - **alarm**: The alarm type (method) being profiled.
+            - **total_time**: Total time taken for all runs (seconds).
+            - **number_of_runs**: Number of times the profiling was repeated.
+            - **number_of_texts**: Number of texts used in each profiling run.
+            - **time_per_run**: Average time per profiling run (seconds).
+            """
+            )
+            # Optional: bar chart of time per run
+            fig, ax = plt.subplots()
+            ax.bar(df_profiling["alarm"], df_profiling["time_per_run"], color="#F600FF")
+            ax.set_xlabel("Alarm type")
+            ax.set_ylabel("Time per run (s)")
+            ax.set_title("Average Time per Profiling Run by Alarm Type")
+            st.pyplot(fig)
+        else:
+            st.info("No profiling results found for this run.")
+
+
+if __name__ == "__main__":
+    main()