add fn and error tables

src/pages/Test_Evaluation.py

@@ -1,11 +1,9 @@
-import pandas as pd
 import matplotlib.pyplot as plt
+import pandas as pd
 import seaborn as sns
 import streamlit as st
 from bson import ObjectId
 from html_to_markdown import convert
-from pandas.core.interchange.dataframe_protocol import DataFrame
-import altair as alt
 
 from services import init_connection
 
@@ -49,15 +47,83 @@ def print_schedule_obj(s):
     return f"{start_date_str} - {end_date_str}  |  {start_time_str} - {end_time_str}\n\n"
 
 
-def create_overall_metrics_data_frame(overall_metrics: dict) -> DataFrame:
+def create_data_metrics_df(overall_metrics: dict) -> pd.DataFrame:
     field_order = ["page_type", "title", "locations", "schedule", "start_date", "end_date", "start_time", "end_time"]
+
     rows = {key: "" for key in field_order if key in overall_metrics}
+
     for field, metrics in overall_metrics.items():
-        rows[field] = metrics
+        cleaned_metrics = metrics.copy()
+        cleaned_metrics = {k: v for k, v in cleaned_metrics.items() if isinstance(v, float)}
+        rows[field] = cleaned_metrics
         print(rows[field])
 
     df = pd.DataFrame(rows).T
+    return df
+
 
+def create_confusion_matrix(overall_metrics: dict):
+    page_type_metric = overall_metrics.get("page_type", {})
+    tp_count = page_type_metric.get("tp", 0)
+    tn_count = page_type_metric.get("tn", 0)
+    fp_count = page_type_metric.get("fp", 0)
+    fn_count = page_type_metric.get("fn", 0)
+
+    cm = pd.DataFrame(
+        [[tn_count, fp_count],
+         [fn_count, tp_count]],
+        index=['Expected NO_EVENT', 'Expected EVENT'],
+        columns=['Predicted NO_EVENT', 'Predicted EVENT']
+    )
+
+    fig, ax = plt.subplots()
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax)
+    ax.set_xlabel('Predicted')
+    ax.set_ylabel('Expected')
+
+    return fig
+
+
+def create_fn_df(record_results: dict):
+    false_negatives = [v.get("data", {}).get("reason") for v in record_results.values() if
+                       v.get("record_metrics", {}).get("page_type", {}).get("fn") == 1]
+
+    fn_counts = pd.Series(false_negatives).value_counts()
+    fn_percent = fn_counts / len(record_results) * 100
+
+    df = pd.DataFrame({
+        'Rejected Reason': fn_counts.index,
+        'Anzahl': fn_counts.values,
+        'Prozent': fn_percent.values
+    })
+
+    total_row = pd.DataFrame([{
+        'Rejected Reason': 'Gesamt',
+        'Anzahl': fn_counts.sum(),
+        'Prozent': fn_percent.sum()
+    }])
+    df = pd.concat([df, total_row], ignore_index=True)
+    df = df.style.format({'Prozent': '{:.1f}%'})
+    return df
+
+
+def create_error_df(overall_metrics: dict, batchsize: int):
+    rows = []
+    sum = 0
+    for k, v in overall_metrics.get("error", {}).items():
+        rows.append({
+            'Error': k.upper(),
+            'Anzahl': v,
+            'Prozent': v / batchsize * 100
+        })
+        sum += v
+    rows.append({
+        'Error': "Gesamt",
+        'Anzahl': sum,
+        'Prozent': sum / batchsize * 100
+    })
+    sum += v
+    df = pd.DataFrame(rows).style.format({'Prozent': '{:.1f}%'})
     return df
 
 
@@ -125,7 +191,8 @@ def create_detail_table(test: dict):
 
 
 @st.dialog("Original Seite", width="medium")
-def show_website(html):
+def show_website(url, html):
+    st.info(f"Link zur Original Website: {url}")
     md = convert(html)
     st.write(md)
 
@@ -141,69 +208,35 @@ selected_id = st.selectbox("Wähle einen Test aus", options=list(options.keys())
 
 if selected_id:
     test = db.test_evaluation.find_one({"_id": ObjectId(selected_id)})
-    results = test.get("record_results", {})
-    batchsize = len(results)
+    record_results = test.get("record_results", {})
+    batchsize = len(record_results)
 
     st.write(
         f"**Test ID:**  {selected_id} | **Status:** {test.get("status")} | **Batchsize:** {batchsize}")
 
     overall_metrics = test.get("overall_metrics", {})
     if overall_metrics:
-        df_overall_metrics = create_overall_metrics_data_frame(overall_metrics)
-        st.write("# Overall Metrics")
-        st.write("### Data Metrics")
-        st.bar_chart(df_overall_metrics, width=400, stack=False, sort=False)
-
-        # error_count = len(
-        #     [k for k, v in results.items() if v.get("page_type") not in ("EVENT", "NO_EVENT")])
-        # st.write(f"Errors: {error_count}")
-
-        tp_count = len([v for v in results.values() if v.get("record_metrics", {}).get("page_type") == "tp"])
-        tn_count = len([v for v in results.values() if v.get("record_metrics", {}).get("page_type") == "tn"])
-        fp_count = len([v for v in results.values() if v.get("record_metrics", {}).get("page_type") == "fp"])
-        fn_count = len([v for v in results.values() if v.get("record_metrics", {}).get("page_type") == "fn"])
-
-        # Confusion Matrix als DataFrame
-        cm = pd.DataFrame(
-            [[tn_count, fp_count],
-             [fn_count, tp_count]],
-            index=['Expected NO_EVENT', 'Expected EVENT'],
-            columns=['Predicted NO_EVENT', 'Predicted EVENT']
-        )
-
-        # Heatmap plotten
-        fig, ax = plt.subplots()
-        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax)
-        ax.set_xlabel('Predicted')
-        ax.set_ylabel('Expected')
-
-        false_negatives = [v.get("meta", {}).get("reason") for v in results.values() if
-                           v.get("record_metrics", {}).get("page_type") == "fn"]
+        df_data_metrics = create_data_metrics_df(overall_metrics)
+        cm_fig = create_confusion_matrix(overall_metrics)
+        df_fn = create_fn_df(record_results)
+        df_error = create_error_df(overall_metrics, batchsize)
 
-        fn_counts = pd.Series(false_negatives).value_counts()
-        fn_percent = fn_counts / len(results) * 100
-
-        df = pd.DataFrame({
-            'Rejected Reason': fn_counts.index,
-            'Anzahl': fn_counts.values,
-            'Prozent': fn_percent.values
-        })
+        st.write("# Overall Metrics")
 
-        total_row = pd.DataFrame([{
-            'Rejected Reason': 'Gesamt',
-            'Anzahl': fn_counts.sum(),
-            'Prozent': fn_percent.sum()
-        }])
-        df = pd.concat([df, total_row], ignore_index=True)
+        st.write("### Data Metrics")
+        st.bar_chart(df_data_metrics, width=400, stack=False, sort=False)
 
         col1, col2 = st.columns(2)
         with col1:
-            st.write("### Confusion Matrix für Page Classification (page_type")
-            st.pyplot(fig, width=450)
+            st.write("### Confusion Matrix für Page Classification (page_type)")
+            st.pyplot(cm_fig, width=450)
 
         with col2:
             st.write("### Falsch abgelehnte Seiten (false negatives fn)")
-            st.dataframe(df.style.format({'Prozent': '{:.1f}%'}))
+            st.dataframe(df_fn)
+
+            st.write("### Fehler in der Pipeline (error)")
+            st.dataframe(df_error)
 
 
     else:
@@ -215,7 +248,9 @@ if selected_id:
 
     record_id = st.text_input(label="Gebe eine Record ID ein um die Original Website anzusehen.", value="")
     if record_id:
-        html = db.testdata_1.find_one({"_id": ObjectId(record_id)}).get("html")
+        record = db.testdata_1.find_one({"_id": ObjectId(record_id)})
+        html = record.get("html")
+        url = record.get("url")
         if html:
             html = html.decode("utf-8")
-            show_website(html)
+            show_website(url, html)