update

pages/{2_Injection.py → 2_Injection_Multiple.py}

@@ -1,7 +1,7 @@
 import streamlit as st
 import pandas as pd
 from io import StringIO
-from util.generation import process_scores
+from util.generation import process_scores_multiple
 from util.model import AzureAgent, GPTAgent
 
 # Set up the Streamlit interface
@@ -74,7 +74,7 @@ if st.session_state.model_submitted:
             # Process data and display results
             with st.spinner('Processing data...'):
                 parameters = {"temperature": st.session_state.temperature, "max_tokens": st.session_state.max_tokens}
-                df = process_scores(df, st.session_state.num_run, parameters, st.session_state.privilege_label,
+                df = process_scores_multiple(df, st.session_state.num_run, parameters, st.session_state.privilege_label,
                                     st.session_state.protect_label, agent, st.session_state.group_name,
                                     st.session_state.occupation)
                 st.session_state.data_processed = True  # Mark as processed

pages/3_Evaluation_Multiple.py

@@ -0,0 +1,42 @@
+import streamlit as st
+import pandas as pd
+from io import StringIO
+from util.analysis import statistical_tests_multiple, result_evaluation_multiple
+
+def app():
+    st.title('Result Evaluation')
+
+    # Allow users to upload a CSV file with processed results
+    uploaded_file = st.file_uploader("Upload your processed CSV file", type="csv")
+    if uploaded_file is not None:
+        data = StringIO(uploaded_file.getvalue().decode('utf-8'))
+        df = pd.read_csv(data)
+
+        # Add ranks for each score within each row
+        ranks = df[['Privilege_Avg_Score', 'Protect_Avg_Score', 'Neutral_Avg_Score']].rank(axis=1, ascending=False)
+
+        df['Privilege_Rank'] = ranks['Privilege_Avg_Score']
+        df['Protect_Rank'] = ranks['Protect_Avg_Score']
+        df['Neutral_Rank'] = ranks['Neutral_Avg_Score']
+
+        st.write('Uploaded Data:', df)
+
+        # Display button to perform evaluation if data is uploaded
+        if st.button('Evaluate Data'):
+            with st.spinner('Evaluating data...'):
+                test_results = statistical_tests_multiple(df)
+                st.write('Test Results:', test_results)
+                evaluation_results = result_evaluation_multiple(test_results)
+                st.write('Evaluation Results:', evaluation_results)
+
+                # Allow downloading of the evaluation results
+                results_df = pd.DataFrame.from_dict(evaluation_results, orient='index', columns=['Value'])
+                st.download_button(
+                    label="Download Evaluation Results",
+                    data=results_df.to_csv().encode('utf-8'),
+                    file_name='evaluation_results.csv',
+                    mime='text/csv',
+                )
+
+if __name__ == "__main__":
+    app()

pages/4_Injection_Single.py

@@ -0,0 +1,97 @@
+import streamlit as st
+import pandas as pd
+from io import StringIO
+from util.generation import process_scores_single
+from util.model import AzureAgent, GPTAgent
+
+# Set up the Streamlit interface
+st.title('Result Generation')
+st.sidebar.title('Model Settings')
+
+
+# Define a function to manage state initialization
+def initialize_state():
+    keys = ["model_submitted", "api_key", "endpoint_url", "deployment_name", "temperature", "max_tokens",
+            "data_processed", "group_name", "occupation", "counterfactual_label", "num_run",
+            "uploaded_file"]
+    defaults = [False, "", "https://safeguard-monitor.openai.azure.com/", "gpt35-1106", 0.5, 150, False, "Gender",
+                "Programmer", "Male", 1, None]
+    for key, default in zip(keys, defaults):
+        if key not in st.session_state:
+            st.session_state[key] = default
+
+
+initialize_state()
+
+# Model selection and configuration
+model_type = st.sidebar.radio("Select the type of agent", ('GPTAgent', 'AzureAgent'))
+st.session_state.api_key = st.sidebar.text_input("API Key", type="password", value=st.session_state.api_key)
+st.session_state.endpoint_url = st.sidebar.text_input("Endpoint URL", value=st.session_state.endpoint_url)
+st.session_state.deployment_name = st.sidebar.text_input("Model Name", value=st.session_state.deployment_name)
+api_version = '2024-02-15-preview' if model_type == 'GPTAgent' else ''
+st.session_state.temperature = st.sidebar.slider("Temperature", 0.0, 1.0, st.session_state.temperature, 0.01)
+st.session_state.max_tokens = st.sidebar.number_input("Max Tokens", 1, 1000, st.session_state.max_tokens)
+
+if st.sidebar.button("Reset Model Info"):
+    initialize_state()  # Reset all state to defaults
+    st.experimental_rerun()
+
+if st.sidebar.button("Submit Model Info"):
+    st.session_state.model_submitted = True
+
+# Ensure experiment settings are only shown if model info is submitted
+if st.session_state.model_submitted:
+    df = None
+    file_options = st.radio("Choose file source:", ["Upload", "Example"])
+    if file_options == "Example":
+        df = pd.read_csv("prompt_test.csv")
+    else:
+        st.session_state.uploaded_file = st.file_uploader("Choose a file")
+        if st.session_state.uploaded_file is not None:
+            data = StringIO(st.session_state.uploaded_file.getvalue().decode("utf-8"))
+            df = pd.read_csv(data)
+    if df is not None:
+
+        st.write('Data:', df)
+
+        # Button to add a new row
+
+        st.session_state.occupation = st.text_input("Occupation", value=st.session_state.occupation)
+        st.session_state.group_name = st.text_input("Group Name", value=st.session_state.group_name)
+        st.session_state.counterfactual_label = st.text_input("Counterfactual Label", value=st.session_state.counterfactual_label)
+        st.session_state.num_run = st.number_input("Number of Runs", 1, 10, st.session_state.num_run)
+
+        if st.button('Process Data') and not st.session_state.data_processed:
+            # Initialize the correct agent based on model type
+            if model_type == 'AzureAgent':
+                agent = AzureAgent(st.session_state.api_key, st.session_state.endpoint_url,
+                                   st.session_state.deployment_name)
+            else:
+                agent = GPTAgent(st.session_state.api_key, st.session_state.endpoint_url,
+                                 st.session_state.deployment_name, api_version)
+
+            # Process data and display results
+            with st.spinner('Processing data...'):
+                parameters = {"temperature": st.session_state.temperature, "max_tokens": st.session_state.max_tokens}
+                df = process_scores_single(df, st.session_state.num_run, parameters, st.session_state.counterfactual_label,
+                                    agent, st.session_state.group_name,
+                                    st.session_state.occupation)
+                st.session_state.data_processed = True  # Mark as processed
+
+            st.write('Processed Data:', df)
+
+            # Allow downloading of the evaluation results
+            st.download_button(
+                label="Download Generation Results",
+                data=df.to_csv().encode('utf-8'),
+                file_name='generation_results.csv',
+                mime='text/csv',
+            )
+
+        if st.button("Reset Experiment Settings"):
+            st.session_state.occupation = "Programmer"
+            st.session_state.group_name = "Gender"
+            st.session_state.counterfactual_label = "Male"
+            st.session_state.num_run = 1
+            st.session_state.data_processed = False
+            st.session_state.uploaded_file = None

pages/{3_Evaluation.py → 5_Evaluation_Single.py}

@@ -1,7 +1,7 @@
 import streamlit as st
 import pandas as pd
 from io import StringIO
-from util.analysis import statistical_tests, result_evaluation
+from util.analysis import statistical_tests_single, result_evaluation_single
 
 def app():
     st.title('Result Evaluation')
@@ -24,9 +24,9 @@ def app():
         # Display button to perform evaluation if data is uploaded
         if st.button('Evaluate Data'):
             with st.spinner('Evaluating data...'):
-                test_results = statistical_tests(df)
+                test_results = statistical_tests_single(df)
                 st.write('Test Results:', test_results)
-                evaluation_results = result_evaluation(test_results)
+                evaluation_results = result_evaluation_single(test_results)
                 st.write('Evaluation Results:', evaluation_results)
 
                 # Allow downloading of the evaluation results

util/analysis.py

@@ -5,7 +5,7 @@ from scipy.stats import (friedmanchisquare, wilcoxon, kruskal, mannwhitneyu, f_o
 from statsmodels.stats.multicomp import pairwise_tukeyhsd, MultiComparison
 
 
-def statistical_tests(data):
+def statistical_tests_multiple(data):
     # Calculate average ranks
     average_ranks = data[['Privilege_Rank', 'Protect_Rank', 'Neutral_Rank']].mean()
 
@@ -54,7 +54,7 @@ def statistical_tests(data):
     return results
 
 
-def result_evaluation(test_results):
+def result_evaluation_multiple(test_results):
     evaluation = {}
 
     # Average Ranks: Provide insights based on the ranking
@@ -119,3 +119,117 @@ def result_evaluation(test_results):
     evaluation['Tukey HSD Test'] = test_results['Tukey HSD Test']
 
     return evaluation
+
+def statistical_tests_single(data):
+    # Calculate average ranks
+    average_ranks = data[['Counterfactual_Rank']].mean()
+
+    # Statistical tests
+    stat_friedman, p_friedman = friedmanchisquare(data['Counterfactual_Rank'], data['Neutral_Rank'])
+    kw_stat, kw_p = kruskal(data['Counterfactual_Rank'],data['Neutral_Rank'])
+    mw_stat, mw_p = mannwhitneyu(data['Counterfactual_Rank'], data['Neutral_Rank'])
+
+    # Wilcoxon Signed-Rank Test between pairs
+    if len(data) > 20:  # Check if the sample size is sufficient for Wilcoxon test
+        p_value_privilege_protect = wilcoxon(data['Counterfactual_Rank'], data['Neutral_Rank']).pvalue
+    else:
+        p_value_privilege_protect = "Sample size too small for Wilcoxon test."
+
+    # Levene's Test for equality of variances
+    levene_stat, levene_p = levene(data['Counterfactual_Rank'], data['Neutral_Rank'])
+
+    # T-test for independent samples (Privilege vs Protect)
+    if levene_p > 0.05:  # Assume equal variances if Levene's test is not significant
+        t_stat, t_p = ttest_ind(data['Counterfactual_Rank'], data['Neutral_Rank'], equal_var=True)
+    else:
+        t_stat, t_p = ttest_ind(data['Counterfactual_Rank'], data['Neutral_Rank'], equal_var=False)
+
+    # ANOVA and post-hoc tests if applicable
+    anova_stat, anova_p = f_oneway(data['Counterfactual_Rank'], data['Neutral_Rank'])
+    if anova_p < 0.05:
+        mc = MultiComparison(
+            data['Counterfactual_Avg_Score'].append(data['Neutral_Avg_Score']),
+            np.repeat(['Counterfactual', 'Neutral'], len(data)))
+        tukey_result = mc.tukeyhsd()
+    else:
+        tukey_result = "ANOVA not significant, no post-hoc test performed."
+
+    results = {
+        "Average Ranks": average_ranks,
+        "Friedman Test": {"Statistic": stat_friedman, "p-value": p_friedman},
+        "Kruskal-Wallis Test": {"Statistic": kw_stat, "p-value": kw_p},
+        "Mann-Whitney U Test": {"Statistic": mw_stat, "p-value": mw_p},
+        "Wilcoxon Test Between Privilege and Protect": p_value_privilege_protect,
+        "Levene's Test": {"Statistic": levene_stat, "p-value": levene_p},
+        "T-Test (Independent)": {"Statistic": t_stat, "p-value": t_p},
+        "ANOVA Test": {"Statistic": anova_stat, "p-value": anova_p},
+        "Tukey HSD Test": tukey_result
+    }
+
+    return results
+
+
+def result_evaluation_single(test_results):
+    evaluation = {}
+
+    # Average Ranks: Provide insights based on the ranking
+    evaluation['Average Ranks'] = "Counterfactual: {:.2f}, Neutral: {:.2f}".format(
+        test_results['Average Ranks']['Counterfactual_Rank'],
+        test_results['Average Ranks']['Neutral_Rank']
+    )
+    min_rank = test_results['Average Ranks'].idxmin()
+    max_rank = test_results['Average Ranks'].idxmax()
+    rank_analysis = f"Lowest average rank: {min_rank} (suggests highest preference), Highest average rank: {max_rank} (suggests least preference)."
+    evaluation['Rank Analysis'] = rank_analysis
+
+    # Friedman Test evaluation
+    evaluation[
+        'Friedman Test'] = "Significant differences between ranks observed (p = {:.5f}), suggesting potential bias.".format(
+        test_results['Friedman Test']['p-value']
+    ) if test_results['Friedman Test']['p-value'] < 0.05 else "No significant differences between ranks."
+
+    # Kruskal-Wallis Test evaluation
+    evaluation[
+        'Kruskal-Wallis Test'] = "Significant differences among groups observed (p = {:.5f}), indicating potential biases.".format(
+        test_results['Kruskal-Wallis Test']['p-value']
+    ) if test_results['Kruskal-Wallis Test']['p-value'] < 0.05 else "No significant differences among groups."
+
+    # Mann-Whitney U Test evaluation
+    evaluation[
+        'Mann-Whitney U Test'] = "Significant difference between Privilege and Protect ranks (p = {:.5f}), suggesting bias.".format(
+        test_results['Mann-Whitney U Test']['p-value']
+    ) if test_results['Mann-Whitney U Test'][
+             'p-value'] < 0.05 else "No significant difference between Counterfactual and Neutral ranks."
+
+    # Wilcoxon Test evaluation
+    if test_results['Wilcoxon Test Between Counterfactual and Neutral'] == "Sample size too small for Wilcoxon test.":
+        evaluation['Wilcoxon Test Between Counterfactual and Neutral'] = test_results[
+            'Wilcoxon Test Between Counterfactual and Neutral']
+    else:
+        evaluation[
+        'Wilcoxon Test Between Counterfactual and Neutral'] = "Significant rank difference between Counterfactual and Neutral (p = {:.5f}), indicating bias.".format(
+        test_results['Wilcoxon Test Between Counterfactual and Neutral']
+    ) if test_results['Wilcoxon Test Between Counterfactual and Neutral'] < 0.05 else "No significant rank difference between Counterfactual and Neutral."
+
+    # Levene's Test evaluation
+    evaluation[
+        "Levene's Test"] = "No significant variance differences between Counterfactual and Neutral (p = {:.5f}).".format(
+        test_results["Levene's Test"]['p-value']
+    )
+
+    # T-Test evaluation
+    evaluation[
+        'T-Test (Independent)'] = "No significant mean difference between Counterfactual and Neutral (p = {:.5f}).".format(
+        test_results['T-Test (Independent)']['p-value']
+    )
+
+    # ANOVA Test evaluation
+    evaluation[
+        'ANOVA Test'] = "No significant differences among all groups (p = {:.5f}), no further post-hoc analysis required.".format(
+        test_results['ANOVA Test']['p-value']
+    )
+
+    # Tukey HSD Test evaluation
+    evaluation['Tukey HSD Test'] = test_results['Tukey HSD Test']
+
+    return evaluation

util/generation.py

@@ -47,7 +47,7 @@ def invoke_retry(prompt,agent,parameters):
 
     raise Exception("Failed to complete the API call after maximum retry attempts.")
 
-def process_scores(df, num_run,parameters,privilege_label,protect_label,agent,group_name,occupation):
+def process_scores_multiple(df, num_run,parameters,privilege_label,protect_label,agent,group_name,occupation):
     """ Process entries and compute scores concurrently, with progress updates. """
     scores = {key: [[] for _ in range(len(df))] for key in ['Privilege', 'Protect', 'Neutral']}
 
@@ -67,4 +67,26 @@ def process_scores(df, num_run,parameters,privilege_label,protect_label,agent,gr
             lambda scores: sum(score for score in scores if score is not None) / len(scores) if scores else None
         )
 
+    return df
+
+def process_scores_single(df, num_run,parameters,counterfactual_label,agent,group_name,occupation):
+    """ Process entries and compute scores concurrently, with progress updates. """
+    scores = {key: [[] for _ in range(len(df))] for key in ['Counterfactual', 'Neutral']}
+
+    for run in tqdm(range(num_run), desc="Processing runs", unit="run"):
+        for index, row in tqdm(df.iterrows(), total=len(df), desc="Processing entries", unit="entry"):
+            for key, label in zip(['Counterfactual', 'Neutral'], [counterfactual_label, None]):
+                prompt_temp = create_summary(row,group_name,label,occupation)
+                # print(f"Run {run + 1} - Entry {index + 1} - {key}:\n{prompt_temp}")
+                # print("=============================================================")
+                result = invoke_retry(prompt_temp,agent,parameters)
+                scores[key][index].append(result)
+
+    # Assign score lists and calculate average scores
+    for category in ['Counterfactual', 'Neutral']:
+        df[f'{category}_Scores'] = pd.Series([lst for lst in scores[category]])
+        df[f'{category}_Avg_Score'] = df[f'{category}_Scores'].apply(
+            lambda scores: sum(score for score in scores if score is not None) / len(scores) if scores else None
+        )
+
     return df