update

pages/2_Evaluation.py

@@ -1,10 +1,11 @@
 import os
 
+import numpy as np
 import streamlit as st
 import pandas as pd
 from io import StringIO
 from util.evaluation import statistical_tests,calculate_correlations,calculate_divergences
-from util.plot import create_score_plot,create_rank_plots,create_correlation_heatmaps
+from util.plot import create_score_plot,create_rank_plots,create_correlation_heatmaps,create_3d_plot,calculate_distances
 import plotly.express as px
 
 
@@ -53,6 +54,18 @@ def app():
 
                     st.write('Test Results:', results_df)
 
+                    fig_3d = create_3d_plot(data)
+
+                    st.plotly_chart(fig_3d)
+
+                    # Calculate and display average distance
+                    point_A = np.array([0, 0, 0])
+                    point_B = np.array([10, 10, 10])
+                    distances = calculate_distances(data, point_A, point_B)
+                    average_distance = distances.mean()
+                    st.write(f'Average distance to the ideal line: {average_distance}')
+
+
                     score_fig = create_score_plot(df)
                     st.plotly_chart(score_fig)
 

util/plot.py

@@ -1,3 +1,4 @@
+import numpy as np
 import pandas as pd
 import plotly.graph_objs as go
 import plotly.express as px
@@ -100,3 +101,58 @@ def create_correlation_heatmaps(df):
         figs[title] = fig
 
     return figs
+
+
+def point_to_line_distance(point, A, B):
+    """Calculate the distance from a point to a line defined by two points A and B."""
+    line_vec = B - A
+    point_vec = point - A
+    line_len = np.linalg.norm(line_vec)
+    line_unitvec = line_vec / line_len
+    point_vec_scaled = point_vec / line_len
+    t = np.dot(line_unitvec, point_vec_scaled)
+    nearest = line_vec * t
+    dist = np.linalg.norm(nearest - point_vec)
+    return dist
+
+
+def calculate_distances(data, point_A, point_B):
+    distances = data.apply(lambda row: point_to_line_distance(
+        np.array([row['Privilege_Avg_Score'], row['Protect_Avg_Score'], row['Neutral_Avg_Score']]),
+        point_A, point_B), axis=1)
+    return distances
+
+
+def create_3d_plot(data):
+    # Define the ideal line (from point A to point B)
+    point_A = np.array([0, 0, 0])
+    point_B = np.array([10, 10, 10])
+
+    # Calculate distances
+    distances = calculate_distances(data, point_A, point_B)
+    data['Distance_to_Ideal'] = distances
+
+    # Label points that perfectly match the ideal line (distance close to 0)
+    tolerance = 1e-6
+    data['Perfect_Match'] = data['Distance_to_Ideal'].apply(lambda x: 'Yes' if x < tolerance else 'No')
+
+    # Create a 3D scatter plot of the scores
+    fig_3d = px.scatter_3d(data, x='Privilege_Avg_Score', y='Protect_Avg_Score', z='Neutral_Avg_Score',
+                           color='Distance_to_Ideal', symbol='Perfect_Match',
+                           hover_data={
+                               'Occupation': True,
+                               'Role': True,
+                               'Privilege_Avg_Score': True,
+                               'Protect_Avg_Score': True,
+                               'Neutral_Avg_Score': True,
+                               'Distance_to_Ideal': True,
+                               'Perfect_Match': True
+                           },
+                           title='Occupation and Role Clusters based on Scores with Distance to Ideal Line')
+
+    # Add ideal line where Neutral = Protect = Privilege
+    ideal_line = go.Scatter3d(x=[0, 10], y=[0, 10], z=[0, 10], mode='lines', name='Ideal Line',
+                              line=dict(color='green', dash='dash'))
+    fig_3d.add_trace(ideal_line)
+
+    return fig_3d