Restructure UX and optimise scripts for performance

app.py

@@ -110,7 +110,7 @@ def load_dataset(local_dataset, hf_dataset):
     )
 
     dataset_import_btn = gr.Button(
-        value="Import",
+        value="Import Dataset",
         interactive=True,
         variant="primary",
         visible=True,
@@ -156,7 +156,17 @@ def import_dataset(dataset_sampling_method, dataset_sampling_size, dataset_colum
     DATASET["sampling_size"] = dataset_sampling_size
     DATASET["column"] = dataset_column
 
-    return gr.Markdown(f"## Dataset (`{DATASET['name']}`)")
+    return (
+        gr.Markdown(
+            f"## Results (Dataset: {'✅' if DATASET['name'] else '❎'}) (Methodology: {'✅' if DATASET['methodology'] else '❎'})"
+        ),
+        gr.Button(
+            value="Evaluate",
+            interactive=(True if DATASET["name"] and DATASET["methodology"] else False),
+            variant="primary",
+            visible=True,
+        ),
+    )
 
 
 def import_methodology(methodology):
@@ -164,8 +174,7 @@ def import_methodology(methodology):
 
     return (
         gr.Markdown(
-            f"## Methodology (`{methodology}`)",
-            visible=True,
+            f"## Results (Dataset: {'✅' if DATASET['name'] else '❎'}) (Methodology: {'✅' if DATASET['methodology'] else '❎'})"
         ),
         gr.Markdown(
             METHODOLOGIES[methodology]["description"],
@@ -173,7 +182,7 @@ def import_methodology(methodology):
         ),
         gr.Button(
             value="Evaluate",
-            interactive=True,
+            interactive=(True if DATASET["name"] and DATASET["methodology"] else False),
             variant="primary",
             visible=True,
         ),
@@ -220,8 +229,11 @@ with BiasAware:
             hf_dataset = gr.Textbox(visible=False)
             hf_dataset_search_results = gr.Radio(visible=False)
 
-            dataset_load_btn = gr.Button(visible=False)
-            dataset_import_btn = gr.Button(visible=False)
+            with gr.Row():
+                with gr.Column(scale=1):
+                    dataset_load_btn = gr.Button(visible=False)
+                with gr.Column(scale=1):
+                    dataset_import_btn = gr.Button(visible=False)
 
             dataset_sampling_method = gr.Radio(visible=False)
             dataset_sampling_size = gr.Slider(visible=False)
@@ -237,6 +249,11 @@ with BiasAware:
                 choices=METHODOLOGIES.keys(),
             )
 
+            methodology_description = gr.Markdown(visible=False)
+
+        with gr.Column(scale=2):
+            result_title = gr.Markdown("## Results (Dataset: ❎) (Methodology: ❎)")
+
             evaluation_btn = gr.Button(
                 value="Evaluate",
                 interactive=False,
@@ -244,11 +261,6 @@ with BiasAware:
                 visible=True,
             )
 
-            methodology_description = gr.Markdown(visible=False)
-
-        with gr.Column(scale=2):
-            result_title = gr.Markdown("## Results")
-
             result_description = gr.Markdown(visible=False)
             result_plot = gr.Plot(show_label=False, container=False, visible=False)
             result_df = gr.DataFrame(visible=False)
@@ -343,13 +355,13 @@ with BiasAware:
             dataset_sampling_size,
             dataset_column,
         ],
-        outputs=[dataset_title],
+        outputs=[result_title, evaluation_btn],
     )
 
     methodology.input(
         fn=import_methodology,
         inputs=[methodology],
-        outputs=[methodology_title, methodology_description, evaluation_btn],
+        outputs=[result_title, methodology_description, evaluation_btn],
     )
 
     evaluation_btn.click(

scripts/gender_distribution.py

@@ -3,83 +3,68 @@ import json
 import plotly.express as px
 import pandas as pd
 
-with open("config/gender_lexicons.json", "r") as lexicon_file:
-    gender_lexicons = json.load(lexicon_file)
 
-male_lexicon = set(gender_lexicons.get("male_lexicons"))
-female_lexicon = set(gender_lexicons.get("female_lexicons"))
-
-male_pattern = re.compile(r"\b({})\b".format("|".join(map(re.escape, male_lexicon))))
-female_pattern = re.compile(
-    r"\b({})\b".format("|".join(map(re.escape, female_lexicon)))
-)
+def load_gender_lexicons():
+    with open("config/gender_lexicons.json", "r") as lexicon_file:
+        gender_lexicons = json.load(lexicon_file)
+    return gender_lexicons
 
 
 def count_gender_terms(text, gender_pattern):
-    matches = re.findall(gender_pattern, text)
-    return len(matches)
+    return len(gender_pattern.findall(text))
 
 
 def get_gender_tag(count_male_terms, count_female_terms):
     total_terms = count_male_terms + count_female_terms
-
     if total_terms == 0:
         return "No Gender"
 
     male_proportion = (count_male_terms / total_terms) * 100
+    female_proportion = (count_female_terms / total_terms) * 100
+
     if male_proportion >= 75:
         return "Male Strongly Positive Gender"
     elif male_proportion >= 50:
         return "Male Positive Gender"
-
-    female_proportion = (count_female_terms / total_terms) * 100
-    if female_proportion >= 75:
+    elif female_proportion >= 75:
         return "Female Strongly Positive Gender"
     elif female_proportion >= 50:
         return "Female Positive Gender"
-
     return "Equal Gender"
 
 
-def get_gender_category_counts(sample_df):
-    gender_labels = [
-        "No Gender",
-        "Equal Gender",
-        "Male Positive Gender",
-        "Male Strongly Positive Gender",
-        "Female Positive Gender",
-        "Female Strongly Positive Gender",
-    ]
-
-    gender_counts = sample_df["gender_category"].value_counts()
-    result = {label: str(gender_counts.get(label, 0)) for label in gender_labels}
+def analyze_text(text, gender_lexicons):
+    male_lexicon = set(gender_lexicons.get("male_lexicons"))
+    female_lexicon = set(gender_lexicons.get("female_lexicons"))
 
-    return result
+    male_pattern = re.compile(
+        r"\b({})\b".format("|".join(map(re.escape, male_lexicon)))
+    )
+    female_pattern = re.compile(
+        r"\b({})\b".format("|".join(map(re.escape, female_lexicon)))
+    )
 
+    text = text.lower().strip()
+    count_male_terms = count_gender_terms(text, male_pattern)
+    count_female_terms = count_gender_terms(text, female_pattern)
+    gender_category = get_gender_tag(count_male_terms, count_female_terms)
 
-def plot_gender_category_counts(gender_labels):
-    labels = [
-        "No Gender",
-        "Equal Gender",
-        "Male Positive Gender",
-        "Male Strongly Positive Gender",
-        "Female Positive Gender",
-        "Female Strongly Positive Gender",
-    ]
+    return count_male_terms, count_female_terms, gender_category
 
-    values = [gender_labels[label] for label in labels]
 
+def plot_gender_category_counts(labels, values):
     fig = px.pie(
         values=values,
         names=labels,
         title="Gender Distribution",
-        category_orders={"names": labels},
     )
 
     fig.update_traces(
         pull=[0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
         textinfo="percent+label",
-        marker=dict(line=dict(color="#000000", width=1)),
+        marker=dict(
+            line=dict(color="#000000", width=1),
+        ),
     )
 
     fig.update_layout(showlegend=False)
@@ -88,28 +73,29 @@ def plot_gender_category_counts(gender_labels):
 
 
 def eval_gender_distribution(data):
-    data[data.columns[0]] = data[data.columns[0]].str.lower().str.strip()
+    gender_lexicons = load_gender_lexicons()
 
-    data["count_male_terms"] = data[data.columns[0]].apply(
-        lambda x: count_gender_terms(x, male_pattern)
-    )
-    data["count_female_terms"] = data[data.columns[0]].apply(
-        lambda x: count_gender_terms(x, female_pattern)
+    data["count_male_terms"], data["count_female_terms"], data["gender_category"] = zip(
+        *data[data.columns[0]].apply(lambda x: analyze_text(x, gender_lexicons))
     )
 
-    data["gender_category"] = data.apply(
-        lambda row: get_gender_tag(row["count_male_terms"], row["count_female_terms"]),
-        axis=1,
-    )
+    gender_labels = [
+        "No Gender",
+        "Equal Gender",
+        "Male Positive Gender",
+        "Male Strongly Positive Gender",
+        "Female Positive Gender",
+        "Female Strongly Positive Gender",
+    ]
 
-    result_json = get_gender_category_counts(data)
-    result_plot = plot_gender_category_counts(result_json)
+    gender_counts = (
+        data["gender_category"].value_counts().reindex(gender_labels, fill_value=0)
+    )
 
-    result_df = (
-        pd.DataFrame.from_dict(result_json, orient="index")
-        .reset_index()
-        .rename(columns={"index": "Metric", 0: "Value"})
+    result_df = pd.DataFrame(
+        {"Metric": gender_counts.index, "Value": gender_counts.values}
     )
+    result_plot = plot_gender_category_counts(gender_labels, gender_counts)
 
     result_conclusion = ""
 

scripts/gender_profession_bias.py

@@ -6,15 +6,13 @@ import plotly.express as px
 import multiprocessing.pool
 from spacy.lang.en import English
 
-gender_lexicons = json.load(open("config/gender_lexicons.json", "r"))
-profession_lexicons = json.load(open("config/profession_lexicons.json", "r"))
 
 nlp = English()
 nlp.add_pipe("sentencizer")
 
 
 def call_multiprocessing_pool(df_text):
-    concurrent = 2000
+    concurrent = multiprocessing.cpu_count()
     pool = multiprocessing.pool.ThreadPool(processes=concurrent)
     result_list = pool.map(get_gender_prof_match_details, df_text, chunksize=1)
     pool.close()
@@ -27,29 +25,21 @@ def call_multiprocessing_pool(df_text):
     return return_df
 
 
-def get_split_text(text):
-    doc = nlp(text)
-    sentences = [sent for sent in doc.sents]
-    return sentences
-
-
-def compile_regex_patterns(patterns):
-    return [
-        re.compile(r"\b({})\b".format("|".join(pattern)), flags=re.IGNORECASE)
-        for pattern in patterns
-    ]
-
-
 def get_gender_prof_match_details(df_text):
+    gender_lexicons = json.load(open("config/gender_lexicons.json", "r"))
+    profession_lexicons = json.load(open("config/profession_lexicons.json", "r"))
+
     male_pronouns = gender_lexicons.get("male_pronouns")
     female_pronouns = gender_lexicons.get("female_pronouns")
     professions = profession_lexicons.get("professions")
 
-    male_pronoun_pat, female_pronoun_pat, professions_pat = compile_regex_patterns(
-        [male_pronouns, female_pronouns, professions]
+    male_pronoun_pat, female_pronoun_pat, professions_pat = (
+        re.compile(r"\b({})\b".format("|".join(pattern)), flags=re.IGNORECASE)
+        for pattern in [male_pronouns, female_pronouns, professions]
     )
 
-    split_text = get_split_text(df_text)
+    doc = nlp(df_text)
+    split_text = [sent for sent in doc.sents]
 
     results = []