wider functions covering domain-wise-comparison and selected pairs comparisons

pages/2_new_Demo_1.py

@@ -123,13 +123,13 @@ else:
             with st.spinner('Computing regard results...'):
                 regard_male_results = regard.compute(data=st.session_state['male_continuations'],
                                                      references=st.session_state['male_wiki_continuation'])
-                st.write('**Raw Regard Results:**')
+                st.write('**Male Regard Results:**')
                 st.json(regard_male_results)
                 st.session_state['rmr'] = regard_male_results
 
                 regard_female_results = regard.compute(data=st.session_state['female_continuations'],
                                                        references=st.session_state['female_wiki_continuation'])
-                st.write('**Average Regard Results:**')
+                st.write('**Female Regard Results:**')
                 st.json(regard_female_results)
                 st.session_state['rfr'] = regard_female_results
 

pages/3_Demo_pairwise_computation.py

@@ -0,0 +1,238 @@
+import streamlit as st
+import pandas as pd
+from datasets import load_dataset, Dataset
+from random import sample
+from utils.metric import Regard
+from utils.model import gpt2
+import matplotlib.pyplot as plt
+import os
+
+# Set up the Streamlit interface
+st.title('Gender Bias Analysis in Text Generation')
+
+
+def check_password():
+    def password_entered():
+        if password_input == os.getenv('PASSWORD'):
+        # if password_input == "  ":
+            st.session_state['password_correct'] = True
+        else:
+            st.error("Incorrect Password, please try again.")
+
+    password_input = st.text_input("Enter Password:", type="password")
+    submit_button = st.button("Submit", on_click=password_entered)
+
+    if submit_button and not st.session_state.get('password_correct', False):
+        st.error("Please enter a valid password to access the demo.")
+
+
+if not st.session_state.get('password_correct', False):
+    check_password()
+else:
+    st.sidebar.success("Password Verified. Proceed with the demo.")
+
+    if 'data_size' not in st.session_state:
+        st.session_state['data_size'] = 10
+    if 'bold' not in st.session_state:
+        bold = pd.DataFrame({})
+        bold_raw = pd.DataFrame(load_dataset("AlexaAI/bold", split="train"))
+        for index, row in bold_raw.iterrows():
+            bold_raw_prompts = list(row['prompts'])
+            bold_raw_wikipedia = list(row['wikipedia'])
+            bold_expansion = zip(bold_raw_prompts, bold_raw_wikipedia)
+            for bold_prompt, bold_wikipedia in bold_expansion:
+                bold = bold._append(
+                    {'domain': row['domain'], 'name': row['name'], 'category': row['category'], 'prompts': bold_prompt,
+                     'wikipedia': bold_wikipedia}, ignore_index=True)
+        st.session_state['bold'] = Dataset.from_pandas(bold)
+    if 'female_bold' not in st.session_state:
+        st.session_state['female_bold'] = []
+    if 'male_bold' not in st.session_state:
+        st.session_state['male_bold'] = []
+
+    domain = st.selectbox(
+        "Select your domain",
+        pd.DataFrame(st.session_state['bold'])['domain'].unique())
+    domain_limited = [p for p in st.session_state['bold'] if p['domain'] == domain]
+
+    st.session_state['option_one'] = st.selectbox(
+        "Select your profession 1",
+        pd.DataFrame(domain_limited)['category'].unique())
+    option_one_list = [p for p in st.session_state['bold'] if p['category'] == st.session_state['option_one']]
+    o_one = st.session_state['option_one']
+    st.session_state['option_two'] = st.selectbox(
+        "Select your profession 2",
+        pd.DataFrame(domain_limited)['category'].unique())
+    option_two_list = [p for p in st.session_state['bold'] if p['category'] == st.session_state['option_two']]
+    o_two = st.session_state['option_two']
+
+
+    st.subheader('Step 1: Set Data Size')
+    max_length = min(len(option_one_list), len(option_two_list), 50)
+    data_size = st.slider('Select number of samples per category:', min_value=1, max_value=max_length,
+                          value=st.session_state['data_size'])
+    st.session_state['data_size'] = data_size
+
+    if st.button('Show Data'):
+        st.session_state['male_bold'] = sample(
+            option_one_list, data_size)
+        st.session_state['female_bold'] = sample(
+            option_two_list, data_size)
+
+        st.write(f'Sampled {data_size} female and male American actors.')
+        st.write(f'**{o_one} Samples:**', pd.DataFrame(st.session_state['female_bold']))
+        st.write(f'**{o_two} Samples:**', pd.DataFrame(st.session_state['male_bold']))
+
+    if st.session_state['female_bold'] and st.session_state['male_bold']:
+        st.subheader('Step 2: Generate Text')
+
+        if st.button('Generate Text'):
+            GPT2 = gpt2()
+            st.session_state['male_prompts'] = [p['prompts'] for p in st.session_state['male_bold']]
+            st.session_state['female_prompts'] = [p['prompts'] for p in st.session_state['female_bold']]
+            st.session_state['male_wiki_continuation'] = [p['wikipedia'].replace(p['prompts'], '') for p in
+                                                          st.session_state['male_bold']]
+            st.session_state['female_wiki_continuation'] = [p['wikipedia'].replace(p['prompts'], '') for p in
+                                                            st.session_state['female_bold']]
+
+            progress_bar = st.progress(0)
+
+            st.write(f'Generating text for {o_one} prompts...')
+            male_generation = GPT2.text_generation(st.session_state['male_prompts'], pad_token_id=50256, max_length=50,
+                                                   do_sample=False, truncation=True)
+            st.session_state['male_continuations'] = [gen[0]['generated_text'].replace(prompt, '') for gen, prompt in
+                                                      zip(male_generation, st.session_state['male_prompts'])]
+
+            progress_bar.progress(50)
+
+            st.write(f'Generating text for {o_two} prompts...')
+            female_generation = GPT2.text_generation(st.session_state['female_prompts'], pad_token_id=50256,
+                                                     max_length=50, do_sample=False, truncation=True)
+            st.session_state['female_continuations'] = [gen[0]['generated_text'].replace(prompt, '') for gen, prompt in
+                                                        zip(female_generation, st.session_state['female_prompts'])]
+
+            progress_bar.progress(100)
+            st.write('Text generation completed.')
+
+            st.session_state.pop('rmr', None)
+            st.session_state.pop('rfr', None)
+            st.subheader('Step 3: Sample Generated Texts')
+
+    if st.session_state.get('male_continuations') and st.session_state.get('female_continuations'):
+
+        st.write(f"{o_one} Data Samples:")
+        samples_df = pd.DataFrame({
+            f'{o_one} Prompt': st.session_state['male_prompts'],
+            f'{o_one} Continuation': st.session_state['male_continuations'],
+            f'{o_one} Wiki Continuation': st.session_state['male_wiki_continuation'],
+        })
+        st.write(samples_df)
+
+        st.write(f"{o_two} Data Samples:")
+        samples_df = pd.DataFrame({
+            f'{o_two} Prompt': st.session_state['female_prompts'],
+            f'{o_two} Continuation': st.session_state['female_continuations'],
+            f'{o_two} Wiki Continuation': st.session_state['female_wiki_continuation'],
+        })
+        st.write(samples_df)
+
+        if st.button('Evaluate'):
+            st.subheader('Step 4: Regard Results')
+            regard = Regard("inner_compare")
+            st.write('Computing regard results to compare male and female continuations...')
+
+            with st.spinner('Computing regard results...'):
+                regard_male_results = regard.compute(data=st.session_state['male_continuations'],
+                                                     references=st.session_state['male_wiki_continuation'])
+                st.write(f'**{o_one} Regard Results:**')
+                st.json(regard_male_results)
+                st.session_state['rmr'] = regard_male_results
+
+                regard_female_results = regard.compute(data=st.session_state['female_continuations'],
+                                                       references=st.session_state['female_wiki_continuation'])
+                st.write(f'**{o_two} Regard Results:**')
+                st.json(regard_female_results)
+                st.session_state['rfr'] = regard_female_results
+
+    if st.session_state.get('rmr') and st.session_state.get('rfr'):
+        st.subheader('Step 5: Regard Results Plotting')
+        if st.button('Plot'):
+            categories = ['GPT2', 'Wiki']
+
+            mp_gpt = st.session_state['rmr']['no_ref_diff_mean']['positive']
+            mn_gpt = st.session_state['rmr']['no_ref_diff_mean']['negative']
+            mo_gpt = 1 - (mp_gpt + mn_gpt)
+
+            mp_wiki = mp_gpt - st.session_state['rmr']['ref_diff_mean']['positive']
+            mn_wiki = mn_gpt - st.session_state['rmr']['ref_diff_mean']['negative']
+            mo_wiki = 1 - (mn_wiki + mp_wiki)
+
+            fp_gpt = st.session_state['rfr']['no_ref_diff_mean']['positive']
+            fn_gpt = st.session_state['rfr']['no_ref_diff_mean']['negative']
+            fo_gpt = 1 - (fp_gpt + fn_gpt)
+
+            fp_wiki = fp_gpt - st.session_state['rfr']['ref_diff_mean']['positive']
+            fn_wiki = fn_gpt - st.session_state['rfr']['ref_diff_mean']['negative']
+            fo_wiki = 1 - (fn_wiki + fp_wiki)
+
+            positive_m = [mp_gpt, mp_wiki]
+            other_m = [mo_gpt, mo_wiki]
+            negative_m = [mn_gpt, mn_wiki]
+
+            positive_f = [fp_gpt, fp_wiki]
+            other_f = [fo_gpt, fo_wiki]
+            negative_f = [fn_gpt, fn_wiki]
+
+            # Plotting
+            fig_a, ax_a = plt.subplots()
+            ax_a.bar(categories, negative_m, label='Negative', color='blue')
+            ax_a.bar(categories, other_m, bottom=negative_m, label='Other', color='orange')
+            ax_a.bar(categories, positive_m, bottom=[negative_m[i] + other_m[i] for i in range(len(negative_m))],
+                     label='Positive', color='green')
+
+            plt.xlabel('Categories')
+            plt.ylabel('Proportion')
+            plt.title(f'GPT vs Wiki on {o_one} regard')
+            plt.legend()
+
+            st.pyplot(fig_a)
+
+            fig_b, ax_b = plt.subplots()
+            ax_b.bar(categories, negative_f, label='Negative', color='blue')
+            ax_b.bar(categories, other_f, bottom=negative_f, label='Other', color='orange')
+            ax_b.bar(categories, positive_f, bottom=[negative_f[i] + other_f[i] for i in range(len(negative_f))],
+                     label='Positive', color='green')
+
+            plt.xlabel('Categories')
+            plt.ylabel('Proportion')
+            plt.title(f'GPT vs Wiki on {o_two} regard')
+            plt.legend()
+            st.pyplot(fig_b)
+
+            m_increase = mp_gpt - mn_gpt
+            m_relative_increase = mp_gpt - mp_wiki - (mn_gpt - mn_wiki)
+            f_increase = fp_gpt - fn_gpt
+            f_relative_increase = fp_gpt - fp_wiki - (fn_gpt - fn_wiki)
+
+            absolute_difference = [m_increase, f_increase]
+            relative_difference = [m_relative_increase, f_relative_increase]
+
+            new_categories = [f'{o_one}', f'{o_two}']
+
+            fig_c, ax_c = plt.subplots()
+            ax_c.bar(new_categories, absolute_difference, label='Positive - Negative', color='#40E0D0')
+
+            plt.xlabel('Categories')
+            plt.ylabel('Proportion')
+            plt.title(f'Difference of positive and negative: {o_one} vs {o_two}')
+            plt.legend()
+            st.pyplot(fig_c)
+
+            fig_d, ax_d = plt.subplots()
+            ax_d.bar(new_categories, relative_difference, label='Positive - Negative', color='#40E0D0')
+
+            plt.xlabel('Categories')
+            plt.ylabel('Proportion')
+            plt.title(f'Difference of positive and negative (relative to Wiki): {o_one} vs {o_two}')
+            plt.legend()
+            st.pyplot(fig_d)

pages/4_Demo_compute_by_domain.py

@@ -0,0 +1,119 @@
+import streamlit as st
+import pandas as pd
+from datasets import load_dataset, Dataset
+from random import sample
+from utils.pairwise_comparison import one_regard_computation
+import matplotlib.pyplot as plt
+import os
+
+# Set up the Streamlit interface
+st.title('Gender Bias Analysis in Text Generation')
+
+
+def check_password():
+    def password_entered():
+        if password_input == os.getenv('PASSWORD'):
+        # if password_input == "  ":
+            st.session_state['password_correct'] = True
+        else:
+            st.error("Incorrect Password, please try again.")
+
+    password_input = st.text_input("Enter Password:", type="password")
+    submit_button = st.button("Submit", on_click=password_entered)
+
+    if submit_button and not st.session_state.get('password_correct', False):
+        st.error("Please enter a valid password to access the demo.")
+
+
+if not st.session_state.get('password_correct', False):
+    check_password()
+else:
+    st.sidebar.success("Password Verified. Proceed with the demo.")
+
+    if 'data_size' not in st.session_state:
+        st.session_state['data_size'] = 10
+    if 'bold' not in st.session_state:
+        bold = pd.DataFrame({})
+        bold_raw = pd.DataFrame(load_dataset("AlexaAI/bold", split="train"))
+        for index, row in bold_raw.iterrows():
+            bold_raw_prompts = list(row['prompts'])
+            bold_raw_wikipedia = list(row['wikipedia'])
+            bold_expansion = zip(bold_raw_prompts, bold_raw_wikipedia)
+            for bold_prompt, bold_wikipedia in bold_expansion:
+                bold = bold._append(
+                    {'domain': row['domain'], 'name': row['name'], 'category': row['category'], 'prompts': bold_prompt,
+                     'wikipedia': bold_wikipedia}, ignore_index=True)
+        st.session_state['bold'] = Dataset.from_pandas(bold)
+
+    domain = st.selectbox(
+        "Select the domain",
+        pd.DataFrame(st.session_state['bold'])['domain'].unique())
+    domain_limited = [p for p in st.session_state['bold'] if p['domain'] == domain]
+
+    st.session_state['sample_size'] = st.slider('Select number of samples per category:', min_value=1, max_value=50,
+                                                value=st.session_state['data_size'])
+
+    if st.button('Compute'):
+        answer_dict = {}
+        category_list = pd.DataFrame(domain_limited)['category'].unique().tolist()
+        unique_pairs = []
+        ref_list = {}
+        no_ref_list = {}
+        for i in range(len(category_list)):
+            o_one = category_list[i]
+            with st.spinner(f'Computing regard results for {o_one.replace("_", " ")}'):
+                st.session_state['rmr'] = one_regard_computation(o_one, st.session_state['bold'],
+                                                                 st.session_state['sample_size'])
+                answer_dict[o_one] = (st.session_state['rmr'])
+                st.write(f'Regard results for {o_one.replace("_", " ")} computed successfully.')
+                # st.json(answer_dict[o_one])
+                ref_list[o_one] = st.session_state['rmr']['ref_diff_mean']['positive'] \
+                           - st.session_state['rmr']['ref_diff_mean']['negative']
+                no_ref_list[o_one] = st.session_state['rmr']['no_ref_diff_mean']['positive'] \
+                           - st.session_state['rmr']['no_ref_diff_mean']['negative']
+
+                # Plotting
+                categories = ['GPT2', 'Wiki']
+                mp_gpt = st.session_state['rmr']['no_ref_diff_mean']['positive']
+                mn_gpt = st.session_state['rmr']['no_ref_diff_mean']['negative']
+                mo_gpt = 1 - (mp_gpt + mn_gpt)
+
+                mp_wiki = mp_gpt - st.session_state['rmr']['ref_diff_mean']['positive']
+                mn_wiki = mn_gpt - st.session_state['rmr']['ref_diff_mean']['negative']
+                mo_wiki = 1 - (mn_wiki + mp_wiki)
+
+                positive_m = [mp_gpt, mp_wiki]
+                other_m = [mo_gpt, mo_wiki]
+                negative_m = [mn_gpt, mn_wiki]
+
+
+                fig_a, ax_a = plt.subplots()
+                ax_a.bar(categories, negative_m, label='Negative', color='blue')
+                ax_a.bar(categories, other_m, bottom=negative_m, label='Other', color='orange')
+                ax_a.bar(categories, positive_m, bottom=[negative_m[i] + other_m[i] for i in range(len(negative_m))],
+                         label='Positive', color='green')
+
+                plt.ylabel('Proportion')
+                plt.title(f'GPT2 vs Wiki on {o_one.replace("_", " ")} regard')
+                plt.legend()
+
+                st.pyplot(fig_a)
+
+
+        st.subheader(f'The comparison of absolute regard value in {domain.replace("_", " ")} by GPT2')
+        st.bar_chart(no_ref_list)
+        st.write(f'***Max difference of absolute regard values in the {domain.replace("_", " ")}:***')
+        keys_with_max_value_no_ref = [key for key, value in no_ref_list.items() if value == max(no_ref_list.values())][0]
+        keys_with_min_value_no_ref = [key for key, value in no_ref_list.items() if value == min(no_ref_list.values())][0]
+        st.write(f'     {keys_with_max_value_no_ref.replace("_", " ")} regard - {keys_with_min_value_no_ref.replace("_", " ")} regard ='
+                 f'{max(ref_list.values()) - min(ref_list.values())}')
+
+        st.subheader(f'The comparison of regard value in {domain.replace("_", " ")} with references to Wikipedia by GPT2')
+        st.bar_chart(ref_list)
+        st.write(f'***Max difference of regard values in the {domain.replace("_", " ")} with references to Wikipedia:***')
+        keys_with_max_value_ref = [key for key, value in ref_list.items() if value == max(ref_list.values())][0]
+        keys_with_min_value_ref = [key for key, value in ref_list.items() if value == min(ref_list.values())][0]
+        st.write(f'     {keys_with_max_value_ref.replace("_", " ")} regard - {keys_with_min_value_ref.replace("_", " ")} regard  = '
+                 f'{max(ref_list.values()) - min(ref_list.values())}')
+
+

utils/pairwise_comparison.py

@@ -0,0 +1,65 @@
+import streamlit as st
+import pandas as pd
+from datasets import load_dataset, Dataset
+from random import sample
+from utils.metric import Regard
+from utils.model import gpt2
+import matplotlib.pyplot as plt
+import os
+
+def one_regard_computation(category: str, dataset_: Dataset, sample_size: int):
+    option_list = [p for p in dataset_ if p['category'] == category]
+
+    data_size = min(len(option_list), sample_size)
+
+    bold = sample(option_list, data_size)
+
+    GPT2 = gpt2()
+    prompts = [p['prompts'] for p in bold]
+    wikipedia = [p['wikipedia'].replace(p['prompts'], '') for p in bold]
+
+    generations = GPT2.text_generation(prompts, pad_token_id=50256, max_length=50,
+                                       do_sample=False, truncation=True)
+    continuation = [gen[0]['generated_text'].replace(prompt, '') for gen, prompt in
+                    zip(generations, prompts)]
+
+    regard = Regard("inner_compare")
+
+    regard_results = regard.compute(data=continuation,
+                                    references=wikipedia)
+
+    return regard_results
+
+def pairwise_comparison(category_one: str, category_two: str, dataset_: Dataset, sample_size: int):
+    option_one_list = [p for p in dataset_ if p['category'] == category_one]
+    option_two_list = [p for p in dataset_ if p['category'] == category_two]
+
+    data_size = min(len(option_one_list), len(option_two_list), sample_size)
+
+    bold_c_one = sample(option_one_list, data_size)
+    bold_c_two = sample(option_two_list, data_size)
+
+    GPT2 = gpt2()
+    c_one_prompts = [p['prompts'] for p in bold_c_one]
+    c_two_prompts = [p['prompts'] for p in bold_c_two]
+    c_one_wiki = [p['wikipedia'].replace(p['prompts'], '') for p in bold_c_one]
+    c_two_wiki = [p['wikipedia'].replace(p['prompts'], '') for p in bold_c_two]
+
+    c_one_generations = GPT2.text_generation(c_one_prompts, pad_token_id=50256, max_length=50,
+                                             do_sample=False, truncation=True)
+    c_one_continuation = [gen[0]['generated_text'].replace(prompt, '') for gen, prompt in
+                          zip(c_one_generations, c_one_prompts)]
+
+    c_two_generations = GPT2.text_generation(c_two_prompts, pad_token_id=50256,
+                                             max_length=50, do_sample=False, truncation=True)
+    c_two_continuation = [gen[0]['generated_text'].replace(prompt, '') for gen, prompt in
+                          zip(c_two_generations, c_two_prompts)]
+
+    regard = Regard("inner_compare")
+
+    regard_one_results = regard.compute(data=c_one_continuation,
+                                        references=c_one_wiki)
+    regard_two_results = regard.compute(data=c_two_continuation,
+                                        references=c_two_wiki)
+
+    return regard_one_results, regard_two_results