# 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()