Upload 5 files

src/package/ARLTheoretical.py

@@ -36,6 +36,19 @@ def get_ref_value_k(h: float, ARL_0: float) -> float:
 
     return k
 
+def get_threshold_h(k: float, ARL_0: float) -> float:
+    """
+    Calculation for the threshold h for given k and ARL_0.
+    
+    Args:
+        k (float): Normalized reference value.
+        ARL_0 (float): ARL0 value.
+    
+    Returns:
+        float: Normalized threshold h.
+    """
+    h = np.round(spc.xcusum_crit_(k, ARL_0, mu0=0, hs=0, sided="one", r=30), decimals=4).tolist()[0]
+    return h
 
 def get_ref_value(
     h: float, list_ARL_0: list[float]

src/package/app.py

@@ -11,7 +11,13 @@ import pandas as pd
 import gradio as gr
 import tomli
 from cusum import CUSUM
-from ARLTheoretical import get_ref_value, get_ref_value_k, get_ARL_1, get_ARL_1_h_mu1_k
+from ARLTheoretical import (
+    get_ref_value,
+    get_ref_value_k,
+    get_ARL_1,
+    get_ARL_1_h_mu1_k,
+    get_threshold_h,
+)
 from utils import (
     populate_summary_table_ARL0_k,
     populate_summary_table_ARL1_k,
@@ -81,7 +87,7 @@ def populate_table(h: str) -> tuple[gt.GT, gt.GT]:
     ), populate_summary_table_ARL1_k(summary_table_df_ARL1_k, dict_ARL0_k, h)
 
 
-def calculate_reference_value_k(h: str, arl_0: str) -> float:
+def calculate_reference_value_k(h: str, arl_0: str) -> tuple[str, str, str, str]:
     """
     Gets the reference value for given h and ARL_0.
 
@@ -90,7 +96,7 @@ def calculate_reference_value_k(h: str, arl_0: str) -> float:
         arl_0 (str): ARL0 value.
 
     Returns:
-        float: Normalized reference value k.
+        tuple[str, str, str, str]: Normalized reference value k (for output, k_phase1, k_phase2, h_phase2).
     """
     h = float(h)
     arl_0 = float(arl_0)
@@ -98,7 +104,27 @@ def calculate_reference_value_k(h: str, arl_0: str) -> float:
     k = get_ref_value_k(h=h, ARL_0=arl_0)
     k = "{:.2f}".format(k)
 
-    return k, k, k
+    return k, k, k, h, h
+
+
+def calculate_threshold_h(k: str, arl_0: str) -> tuple[str, str, str, str]:
+    """
+    Gets the threshold h for given k and ARL_0.
+
+    Args:
+        k (str): Normalized reference value.
+        arl_0 (str): ARL0 value.
+
+    Returns:
+        tuple[str, str, str, str]: Normalized threshold h (for output, h_phase1, h_phase2, k_phase2).
+    """
+    k_val = float(k)
+    arl_0 = float(arl_0)
+
+    h = get_threshold_h(k=k_val, ARL_0=arl_0)
+    h = "{:.2f}".format(h)
+
+    return h, h, h, k, h, k
 
 
 def calculate_arl1_h_k_mu1(h: str, k: str, mu1: str) -> float:
@@ -171,7 +197,7 @@ with gr.Blocks(
 
     gr.Markdown(f"""
                 ### AIM-CU Input:
-                AI output (e.g. metrics such as Accuracy, F1-score, Sensitivity etc.)
+                AI output metric (e.g. AUROC, F1-score, Sensitivity, Test Positive Rate, etc.)
                 """)  # noqa: F541
 
     with gr.Row():
@@ -181,7 +207,7 @@ with gr.Blocks(
                         """)  # noqa: F541
 
             gr.Markdown(f"""
-                ### Upload the AI output.
+                ### Upload the AI output metric.
                 """)  # noqa: F541
 
             # load the CSV file with specifities across days
@@ -191,7 +217,11 @@ with gr.Blocks(
 
             with gr.Row():
                 with gr.Column():
-                    init_days = gr.Textbox(label="Number of baseline observations", placeholder="30")
+                    init_days = gr.Textbox(
+                        label="Number of baseline observations",
+                        placeholder="30",
+                        value="30",
+                    )
                 with gr.Column():
                     button_calculate_incontrol_params = gr.Button(
                         "Calculate parameters"
@@ -213,16 +243,9 @@ with gr.Blocks(
                         Parameter choices for detecting change and detection delay estimates (theoretical calculations).
                         """)  # noqa: F541
 
-            gr.Markdown(f"""
-                ### Enter h value:
-                """)  # noqa: F541
-
-            h_phase1 = gr.Textbox(
-                label="h value =",
-                placeholder="h = normalized threshold, default = 4. Range: between 4 and 5 ([4, 5])",
-                value="3",
-                autofocus=True,
-            )
+            # gr.Markdown(f"""
+            #     ### Enter h value:
+            #     """)  # noqa: F541
 
             dataframe_gt_ref_value = gr.HTML(
                 label="Reference Values for an intended ARL0 with normalized threshold h",
@@ -231,44 +254,81 @@ with gr.Blocks(
             )
 
             gr.Markdown(f"""
-                ### Calculate reference value k for a specific value for ARL<sub>0</sub>:
+                ### Calculate parameters:
                 """)  # noqa: F541
 
-            with gr.Row():
-                arl_0 = gr.Textbox(
-                    label="ARL_0 value =", placeholder="ARL_0", value="100"
-                )
+            with gr.Tabs():
+                with gr.Tab("Specify k first"):
+                    gr.Markdown(f"""
+                        Calculate threshold h for specific values of k and ARL<sub>0</sub>:
+                        """)  # noqa: F541
+
+                    with gr.Row():
+                        k_for_h = gr.Textbox(
+                            label="k value =", placeholder="k", value="0.5"
+                        )
+                        arl_0_for_h = gr.Textbox(
+                            label="ARL₀ value =", placeholder="ARL₀", value="100"
+                        )
+
+                        button_calculate_h = gr.Button("Calculate h")
+
+                        output_h = gr.Textbox(label="Calculated h =", visible=False)
+
+                with gr.Tab("Specify h first"):
+                    gr.Markdown(f"""
+                        Calculate reference value k for specific values of h and ARL<sub>0</sub>:
+                        """)  # noqa: F541
 
-                button_calculate_k = gr.Button("Calculate k")
+                    with gr.Row():
+                        h_phase1 = gr.Textbox(
+                            label="h value =",
+                            placeholder="h = normalized threshold, default = 4. Range: between 4 and 5 ([4, 5])",
+                            value="4",
+                            autofocus=True,
+                        )
 
-                output_k = gr.Textbox(label="Calculated k =", visible=False)
+                        arl_0 = gr.Textbox(
+                            label="ARL₀ value =", placeholder="ARL₀", value="100"
+                        )
+
+                        button_calculate_k = gr.Button("Calculate k")
+
+                        output_k = gr.Textbox(label="Calculated k =", visible=False)
 
             dataframe_gt_ARL0 = gr.HTML(
-                label="Estimate of steady state ARL (ARL_1 based on the computed reference values and intended zero-state ARL (ARL_0) with normalized threshold h)",
+                label="Estimate of steady state ARL (ARL₁ based on the computed reference values and intended zero-state ARL (ARL₀) with normalized threshold h)",
                 show_label=True,
                 visible=False,
             )
 
             gr.Markdown(f"""
-                ### Calculate ARL<sub>1</sub> for reference value h, value k and shift in mean:
+                ### Calculate ARL<sub>1</sub> for threshold h, reference value k, and shift in mean:
                 """)  # noqa: F541
 
             with gr.Row():
+                h_for_arl1 = gr.Textbox(
+                    label="h value =", placeholder="h", value="4"
+                )
+
                 k_phase1 = gr.Textbox(
                     label="k value =", placeholder="k", value="0.2996"
                 )
+
+                # example: if std_in=0.03 and shift in mean (in original data)=0.045, then the value that the user enter will be 0.045/0.03=1.5
+                # Shift in mean value is the absolute differece of in-control mean and test mean
                 mu1 = gr.Textbox(
-                    label="Shift in mean value =",
+                    label="Shift in mean value (expressed in term of in-control standard deviation) =",
                     placeholder="Shift in mean value",
                     value="1.2",
                 )
 
-                button_calculate_ARL_1 = gr.Button("Calculate ARL_1")
+                button_calculate_ARL_1 = gr.Button("Calculate ARL₁")
 
-                output_ARL_1 = gr.Textbox(label="Calculated ARL_1 =", visible=False)
+                output_ARL_1 = gr.Textbox(label="Calculated ARL₁ =", visible=False)
 
             button_populate_table = gr.Button(
-                "Populate Reference Values and ARL_1 tables for the given h value"
+                "Populate Reference Values and ARL₁ tables for the given h value"
             )
 
             gr.Markdown(f"""
@@ -283,10 +343,6 @@ with gr.Blocks(
                 - Enter h and k values.
                 - Get CUSUM plots.
                 """)  # noqa: F541
-
-            table_param_description = gr.Dataframe(
-                value=pd.read_csv("../../assets/params.csv")
-            )
         with gr.Column():
             gr.Markdown(f"""
                         ### Monitoring:
@@ -301,7 +357,7 @@ with gr.Blocks(
                 h_phase2 = gr.Textbox(
                     label="h value =",
                     placeholder="normalized threshold, default = 4. Range: between 4 and 5 ([4, 5])",
-                    value="3",
+                    value="4",
                 )
 
                 k_phase2 = gr.Textbox(
@@ -312,11 +368,17 @@ with gr.Blocks(
 
             button_csv_metric = gr.Button("Show CUSUM plots")
 
+            plot_cusum_chart = gr.Plot(label="CUSUM Chart", visible=False)
+
             plot_avg_metric = gr.Plot(
                 label="AI model performance",
                 visible=False,
             )
-            plot_cusum_chart = gr.Plot(label="CUSUM Chart", visible=False)
+
+    with gr.Row():
+        table_param_description = gr.Dataframe(
+            value=pd.read_csv("../../assets/params.csv"),
+        )
 
     button_calculate_incontrol_params.click(
         fn=set_init_days,
@@ -341,9 +403,21 @@ with gr.Blocks(
         fn=lambda: gr.update(visible=True), inputs=[], outputs=dataframe_gt_ARL0
     )
 
+    # Calculate specific h for k and ARL_0
+    button_calculate_h.click(
+        fn=calculate_threshold_h,
+        inputs=[k_for_h, arl_0_for_h],
+        outputs=[output_h, h_phase1, h_phase2, k_phase2, h_for_arl1, k_phase1],
+    )
+    button_calculate_h.click(
+        fn=lambda: gr.update(visible=True), inputs=[], outputs=output_h
+    )
+
     # Calculate specific k for ARL_0
     button_calculate_k.click(
-        fn=calculate_reference_value_k, inputs=[h_phase1, arl_0], outputs=[output_k, k_phase1, k_phase2]
+        fn=calculate_reference_value_k,
+        inputs=[h_phase1, arl_0],
+        outputs=[output_k, k_phase1, k_phase2, h_phase2, h_for_arl1],
     )
     button_calculate_k.click(
         fn=lambda: gr.update(visible=True), inputs=[], outputs=output_k
@@ -352,7 +426,7 @@ with gr.Blocks(
     # Calculate specific ARL_1 for value h, value k and shift in mean
     button_calculate_ARL_1.click(
         fn=calculate_arl1_h_k_mu1,
-        inputs=[h_phase1, k_phase1, mu1],
+        inputs=[h_for_arl1, k_phase1, mu1],
         outputs=[output_ARL_1],
     )
     button_calculate_ARL_1.click(

src/package/cusum.py

@@ -111,7 +111,7 @@ class CUSUM:
         self.set_timeline(self.data)
 
     def compute_cusum(
-        self, x: list[float], mu_0: float, k: float
+        self, x: list[float], mu_0: float, ref_val: float
     ) -> tuple[list[float], list[float], list[float]]:
         """
         Compute CUSUM for the observations in x
@@ -119,7 +119,7 @@ class CUSUM:
         Args:
             x (list[float]): Performance metric to be monitored
             mu_0 (float)   : In-control mean of the observations/performance metric
-            k (float)      : Reference value related to the magnitude of change that one is interested in detecting
+            ref_val (float)      : Reference value related to the magnitude of change that one is interested in detecting
 
         Returns:
             tuple[list[float], list[float], list[float]]: Positive cumulative sum, negative cumulative sum, and CUSUM
@@ -130,10 +130,10 @@ class CUSUM:
         # S_hi : sum of positive changes --------------------------
         self.S_hi = np.zeros(num_rows, dtype=float)
         self.S_hi[0] = 0.0  # starts with 0
-        # Increase in mean = x-mu-k ----------------------------
+        # Increase in mean = x-mu-ref_val ----------------------------
         mean_hi = np.zeros(num_rows, dtype=float)
 
-        # Decrease in mean = mu-k-x----------------------------
+        # Decrease in mean = mu-ref_val-x----------------------------
         mean_lo = np.zeros(num_rows, dtype=float)
         # S_lo : sum of negative changes --------------------------
         self.S_lo = np.zeros(num_rows, dtype=float)
@@ -144,9 +144,9 @@ class CUSUM:
 
         for i in range(0, num_rows):
             x_mean[i] = x[i] - mu_0  # x - mean
-            mean_hi[i] = x[i] - mu_0 - k
+            mean_hi[i] = x[i] - mu_0 - ref_val
             self.S_hi[i] = max(0, self.S_hi[i - 1] + mean_hi[i])
-            mean_lo[i] = mu_0 - k - x[i]
+            mean_lo[i] = mu_0 - ref_val - x[i]
             self.S_lo[i] = max(0, self.S_lo[i - 1] + mean_lo[i])
             cusum[i] = cusum[i - 1] + x_mean[i]
 
@@ -171,9 +171,8 @@ class CUSUM:
             normalized_ref_value (float, optional): Normalized reference value for detecting a unit standard deviation change in mean of the process. Defaults to 0.5.
             normalized_threshold (float, optional): Normalized threshold. Defaults to 4.
         """
-        self.pre_change_days = self.init_days  # This is the number of baseline observations that we assume to be in-control - user enters or default = 30
+        self.pre_change_days = None # self.init_days  # This is the number of baseline observations that we assume to be in-control - user enters or default = 30
 
-        ref_val = normalized_ref_value
         control_limit = normalized_threshold
 
         DetectionTimes = np.array([], dtype=int)
@@ -188,80 +187,65 @@ class CUSUM:
         self.AvgDD = np.array([])  # Average Detection Delay
 
         self.H = control_limit * self.in_std  # Threhold
-        k = ref_val * self.in_std  # Reference value
+        ref_val = normalized_ref_value * self.in_std  # Reference value
 
         x = np.array(self.data)
 
-        # Call compute CUSUM function with x (observatoins), in-control mean (mu) and k (drift or reference value)
-        self.S_hi, self.S_lo, cusum = self.compute_cusum(x, self.in_mu, k)
-
-        # Check the variations in self.S_hi and self.S_lo to determine whether there was a change in the data
-        S_hi_last_known_zero = np.where(self.S_hi == 0)[
-            0
-        ]  # Find all the indices where self.S_hi was 0
-        S_hi_start_of_change = (
-            S_hi_last_known_zero[-1] + 1
-        )  # Fetch the last entry where self.S_hi was 0
-
-        S_lo_last_known_zero = np.where(self.S_lo == 0)[
-            0
-        ]  # Find all the indices where self.S_lo was 0
-        S_lo_start_of_change = (
-            S_lo_last_known_zero[-1] + 1
-        )  # Fetch the last entry where self.S_lo was 0
-
-        # Display the print messages in the UI
-        if (S_lo_start_of_change < S_hi_start_of_change) and (
-            self.S_lo[S_lo_start_of_change + 10] > self.H
-        ):  # check if the changes in the next 10 observations exceed the threshold
-            print(
-                f"Change-point with respect to S_lo is: {S_lo_start_of_change}"
-            )  # Use this change-point to generate histograms
-            self.pre_change_days = S_lo_start_of_change
-
-        elif (S_hi_start_of_change < S_lo_start_of_change) and (
-            self.S_hi[S_hi_start_of_change + 10] > self.H
-        ):
-            print(f"Change-point with respect to S_hi is: {S_hi_start_of_change}")
-            self.pre_change_days = S_hi_start_of_change
+        # Call compute CUSUM function with x (observatoins), in-control mean (mu) and ref_val (drift or reference value)
+        self.S_hi, self.S_lo, cusum = self.compute_cusum(x, self.in_mu, ref_val)
+
+        # # Check the variations in self.S_hi and self.S_lo to determine whether there was a change in the data
+        # S_hi_last_known_zero = np.where(self.S_hi == 0)[
+        #     0
+        # ]  # Find all the indices where self.S_hi was 0
+        # S_hi_start_of_change = (
+        #     S_hi_last_known_zero[-1] + 1
+        # )  # Fetch the last entry where self.S_hi was 0
+
+        # S_lo_last_known_zero = np.where(self.S_lo == 0)[
+        #     0
+        # ]  # Find all the indices where self.S_lo was 0
+        # S_lo_start_of_change = (
+        #     S_lo_last_known_zero[-1] + 1
+        # )  # Fetch the last entry where self.S_lo was 0
+
+        # # Display the print messages in the UI
+        # if (S_lo_start_of_change < S_hi_start_of_change) and (
+        #     self.S_lo[S_lo_start_of_change + 10] > self.H
+        # ):  # check if the changes in the next 10 observations exceed the threshold
+        #     print(
+        #         f"Detected change point with respect to S_lo is: {S_lo_start_of_change}"
+        #     )  # Use this change-point to generate histograms
+        #     self.pre_change_days = S_lo_start_of_change
+
+        # elif (S_hi_start_of_change < S_lo_start_of_change) and (
+        #     self.S_hi[S_hi_start_of_change + 10] > self.H
+        # ):
+        #     print(f"Detected change point with respect to S_hi is: {S_hi_start_of_change}")
+        #     self.pre_change_days = S_hi_start_of_change
+        # else:
+        #     print(f"No change")
+
+        # Find first occurrence where threshold is exceeded
+        S_hi_exceeds = np.where(self.S_hi > self.H)[0]
+        S_lo_exceeds = np.where(self.S_lo > self.H)[0]
+
+        # Take whichever comes first
+        if len(S_hi_exceeds) > 0 and len(S_lo_exceeds) > 0:
+            if S_hi_exceeds[0] < S_lo_exceeds[0]:
+                self.pre_change_days = S_hi_exceeds[0]
+                print(f"(both exceed threshold) Detected upward shift at: {S_hi_exceeds[0]}")
+            else:
+                self.pre_change_days = S_lo_exceeds[0]
+                print(f"(both exceed threshold) Detected downward shift at: {S_lo_exceeds[0]}")
+        elif len(S_hi_exceeds) > 0:
+            self.pre_change_days = S_hi_exceeds[0]
+            print(f"Detected upward shift at: {S_hi_exceeds[0]}")
+        elif len(S_lo_exceeds) > 0:
+            self.pre_change_days = S_lo_exceeds[0]
+            print(f"Detected downward shift at: {S_lo_exceeds[0]}")
         else:
-            print(f"No change")
-
-        # False positives and Total alarms
-        falsePos = 0
-        alarms = 0
-        avddd = 0  # this is the delay from the paper: td-ts (z_k-v) where v is the changepoint and z_k is the time of detection
-
-        for i in range(0, self.pre_change_days):
-            if (self.S_hi[i] > self.H) or (self.S_lo[i] > self.H):
-                falsePos += 1  # False Positives
-                DetectionTimes = np.append(
-                    DetectionTimes, i + 1
-                )  # time at which a false positive is detected
-                Dj = np.append(Dj, 1)
-                Zj = np.append(Zj, min(i, self.pre_change_days))
-                break
-
-        # If there is no false positive, Zj = pre_change_days, Dj = 0
-        if falsePos == 0:
-            Dj = np.append(Dj, 0)
-            Zj = np.append(Zj, self.pre_change_days)
-
-        # Delay to detect the first changepoint
-        # delay = 0
-        for i in range(self.pre_change_days, self.total_days):
-            if (self.S_hi[i] > self.H) or (self.S_lo[i] > self.H):
-                alarms += 1  # True Positive: break after detecting one TP
-                cj = np.append(cj, 1)
-                zj = np.append(zj, min(i, self.total_days) - self.pre_change_days)
-                break
-
-        # If there is no true detection, zj = total simulation days, cj = 0
-        if alarms == 0:
-            cj = np.append(cj, 0)
-            zj = np.append(zj, self.total_days)
-
-        self.AvgDD = np.append(self.AvgDD, avddd)  # ADD estimate from the paper
+            print("No change detected")
 
     def plot_input_metric_plotly_raw(self) -> go.Figure:
         """
@@ -364,7 +348,7 @@ class CUSUM:
         fig = go.Figure()
 
         font_size_title = 20
-        font_size_legend = 18
+        font_size_legend = 14
 
         # add subplots
         fig.add_trace(
@@ -382,7 +366,7 @@ class CUSUM:
                 x=x2,
                 y=y2,
                 mode="markers",
-                name=f"""Out-of-control data""",
+                name=f"""Test data""",
                 marker=dict(color="coral", size=10),
                 opacity=0.4,
             ),
@@ -403,7 +387,7 @@ class CUSUM:
                 x=[min(x2), max(x2)],
                 y=[mean_y2, mean_y2],
                 mode="lines",
-                name="Out-of-control mean",
+                name="Test mean",
                 line=dict(color="coral", dash="dash"),
             ),
         )
@@ -414,16 +398,19 @@ class CUSUM:
                 x=[self.pre_change_days, self.pre_change_days],
                 y=[np.min(self.data), np.max(self.data)],
                 mode="lines",
-                name="Change-point",
+                name="Detected change point",
                 line=dict(color="grey", dash="dash"),
-                # textfont=dict(size=18)
             ),
         )
 
         fig.update_layout(
             title={
-                "text": "Pre- and post-change observations",
+                "text": "AI model metric versus time",
                 "font": {"size": font_size_title, "weight": "bold"},
+                "x": 0.5,
+                "xanchor": "center",
+                "y": 0.98,
+                "yanchor": "top"
             },
             xaxis_title={
                 "text": "Time",
@@ -434,12 +421,24 @@ class CUSUM:
                 "font": {"size": font_size_legend, "weight": "bold"},
             },
             xaxis=dict(dtick=20),
+            autosize=True,
+            margin=dict(l=60, r=50, t=50, b=50),
         )
 
         fig.update_layout(plot_bgcolor=self.config["color"]["blue_005"])
 
         fig.update_layout(
-            legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="center",
+                x=0.5,
+                font=dict(size=14),
+                bgcolor="rgba(255, 255, 255, 0.9)",
+                bordercolor="rgba(0, 124, 186, 0.5)",
+                borderwidth=1
+            )
         )
 
         if self.config["control"]["save_figure"] == "true":
@@ -478,7 +477,7 @@ class CUSUM:
         fig = go.Figure()
 
         font_size_title = 20
-        font_size_legend = 18
+        font_size_legend = 14
 
         fig.add_trace(
             go.Scatter(
@@ -514,6 +513,10 @@ class CUSUM:
             title={
                 "text": "CUSUM Chart",
                 "font": {"size": font_size_title, "weight": "bold"},
+                "x": 0.5,
+                "xanchor": "center",
+                "y": 0.98,
+                "yanchor": "top"
             },
             xaxis_title={
                 "text": "Time",
@@ -524,9 +527,10 @@ class CUSUM:
                 "font": {"size": font_size_legend, "weight": "bold"},
             },
             xaxis=dict(dtick=20),
+            autosize=True,
+            margin=dict(l=60, r=50, t=50, b=50),  # Increased bottom margin for legend
         )
 
-
         fig.add_shape(
             type="rect",
             x0=0, x1=self.pre_change_days,
@@ -550,7 +554,17 @@ class CUSUM:
         )
 
         fig.update_layout(
-            legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="center",
+                x=0.5,
+                font=dict(size=14),
+                bgcolor="rgba(255, 255, 255, 0.9)",
+                bordercolor="rgba(0, 124, 186, 0.5)",
+                borderwidth=1
+            )
         )
 
         if self.config["control"]["save_figure"] == "true":