aim-cu 0.2.0__tar.gz

aim_cu-0.2.0/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

aim_cu-0.2.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: aim-cu
+Version: 0.2.0
+Summary: AIM-CU: A CUSUM-based tool for AI Monitoring
+Home-page: https://github.com/DIDSR/AIM-CU
+Project-URL: User Inteface, https://huggingface.co/spaces/didsr/AIM-CU
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: matplotlib>=3.6
+Requires-Dist: rpy2>=3.5
+Requires-Dist: tomli; python_version < "3.11"
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+AIM-CU: A CUSUM-based tool for AI Monitoring
+============================================
+Monitoring a clinically deployed AI device to detect performance drift is an essential step to ensure the safety and effectiveness of AI. 
+
+AIM-CU is a statistical tool for AI monitoring based on a cumulative sum (AIM-CU) approach.
+
+AIM-CU computes:
+
+* The parameter choices for change-point detection based on an acceptable false alarm rate
+* Detection delay estimates for a given displacement of the performance metric from the target for those parameter choices.
+
+System setup
+------------
+Make sure R is installed in the system. There is no specific version that this relies on. Here we have used the version 4.1.2 (2021-11-01). 
+Instructions for Linux (the below setup is only performed in Linux):
+
+.. code-block:: shell
+
+    wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc |  tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc
+    add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/"
+    apt-get install -y --no-install-recommends r-base r-base-dev
+
+    # setup R configs
+    echo "r <- getOption('repos'); r['CRAN'] <- 'http://cran.us.r-project.org'; options(repos = r);" > ~/.Rprofile
+    Rscript -e "install.packages('ggplot2')"
+    Rscript -e "install.packages('hexbin')"
+    Rscript -e "install.packages('lazyeval')"
+    Rscript -e "install.packages('cusumcharter')"
+    Rscript -e "install.packages('RcppCNPy')"
+    Rscript -e "install.packages('spc')"
+
+Code execution
+--------------
+Clone AIM-CU repository.
+
+.. code-block:: shell
+
+    git clone https://github.com/DIDSR/AIM-CU.git
+
+Run the following commands to install required dependencies (Python = 3.10 is used).
+
+.. code-block:: shell
+
+    apt-get -y install python3
+    apt-get -y install pip
+    cd AIM-CU
+    pip install -r requirements.txt
+
+Run AIM-CU.
+
+.. code-block:: shell
+
+    cd src/package
+    python3 app.py
+
+Open the URL http://0.0.0.0:7860 that is running the AIM-CU locally.
+
+Example code execution
+----------------------
+Example code can be run through Jupyter Notebook. Do this by entering the ``jupyter notebook`` command from the ``/src/package/`` directory. The tool is designed to be used through a GUI, not from the console.
+
+Demo
+----
+AIM-CU can also be run through the demo available at https://huggingface.co/spaces/didsr/AIM-CU. If Space is paused, click on Restart button. Note: this Space uses a custom Docker container; build may break due to latest package updates pulled by HuggingFace.
+
+Usability
+---------
+* Example AI output CSV file is available as `config/spec-60-60.csv <config/spec-60-60.csv>`_ to be uploaded in monitoring phase.
+
+* Workflow instruction to run the tool is available at bottom-left of UI.
+
+* Sample UI output is available at `assets/ui.png <assets/ui.png>`_.
+
+* Setting ``control:save_figure`` to ``true`` from `config.toml <config/config.toml>`_ will save tables and plots in `figure/ <figure/>`_.
+
+* Running AIM-CU usually only takes a few seconds, and it does not require a GPU to run.
+
+Related References
+------------------
+* Smriti Prathapan, Ravi K. Samala, Nathan Hadjiyski, Pierre‑François D’Haese, Nicholas Petrick, Jana Delfino, Fabien Maldonado, Brandon Nelson, Ghada Zamzmi, Phuong Nguyen, Yelena Yesha, and Berkman Sahiner, "Detecting performance drift in AI models for medical image analysis using CUSUM chart" (Journal in press 2026)
+
+* Prathapan, S., Sahiner, B.,  Kadia, D., and Samala, R.K. 2025, "AIM-CU: A statistical tool for AI Monitoring." (Journal in-press 2026)
+
+* Prathapan, S., Samala, R.K., Hadjiyski, N., D’Haese, P.F., Maldonado, F., Nguyen, P., Yesha, Y. and Sahiner, B., 2024, April. Quantifying input data drift in medical machine learning models by detecting change-points in time-series data. In Medical Imaging 2024: Computer-Aided Diagnosis (Vol. 12927, pp. 67-76). SPIE. https://doi.org/10.1117/12.3008771
+
+* Smriti Prathapan, Ravi K. Samala, Nathan Hadjiyski, Pierre‑François D’Haese, Nicholas Petrick, Jana Delfino, Fabien Maldonado, Brandon Nelson, Ghada Zamzmi, Phuong Nguyen, Yelena Yesha, and Berkman Sahiner, "Post-market Monitoring of AI-enabled Medical Devices for Radiology and Healthcare Applications" (FDA-UMiami Collaboration Poster, September 2023)
+
+Disclaimer
+---------------------
+
+**About the Catalog of Regulatory Science Tools**
+
+The enclosed tool is *in preparation* for the `Catalog of Regulatory Science Tools <https://cdrh-rst.fda.gov>`_. Note that this software is not (yet) a standalone RST but rather is to be included as a **reference tool** to support other Regulatory Science Tools (such as synthetic datasets) for reproducibility.
+
+This catalog collates a variety of regulatory science tools that the FDA's Center for Devices and Radiological Health's (CDRH) Office of Science and Engineering Labs (OSEL) developed. These tools use the most innovative science to support medical device development and patient access to safe and effective medical devices. If you are considering using a tool from this catalog in your marketing submissions, note that these tools have not been qualified as `Medical Device Development Tools <https://www.fda.gov/medical-devices/medical-device-development-tools-mddt>`_ and the FDA has not evaluated the suitability of these tools within any specific context of use. You may `request feedback or meetings for medical device submissions <https://www.fda.gov/regulatory-information/search-fda-guidance-documents/requests-feedback-and-meetings-medical-device-submissions-q-submission-program>`_ as part of the Q-Submission Program.
+
+For more information about the Catalog of Regulatory Science Tools, email RST_CDRH@fda.hhs.gov.

aim_cu-0.2.0/aim_cu/README.rst

@@ -0,0 +1,97 @@
+AIM-CU: A CUSUM-based tool for AI Monitoring
+============================================
+Monitoring a clinically deployed AI device to detect performance drift is an essential step to ensure the safety and effectiveness of AI. 
+
+AIM-CU is a statistical tool for AI monitoring based on a cumulative sum (AIM-CU) approach.
+
+AIM-CU computes:
+
+* The parameter choices for change-point detection based on an acceptable false alarm rate
+* Detection delay estimates for a given displacement of the performance metric from the target for those parameter choices.
+
+System setup
+------------
+Make sure R is installed in the system. There is no specific version that this relies on. Here we have used the version 4.1.2 (2021-11-01). 
+Instructions for Linux (the below setup is only performed in Linux):
+
+.. code-block:: shell
+
+    wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc |  tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc
+    add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/"
+    apt-get install -y --no-install-recommends r-base r-base-dev
+
+    # setup R configs
+    echo "r <- getOption('repos'); r['CRAN'] <- 'http://cran.us.r-project.org'; options(repos = r);" > ~/.Rprofile
+    Rscript -e "install.packages('ggplot2')"
+    Rscript -e "install.packages('hexbin')"
+    Rscript -e "install.packages('lazyeval')"
+    Rscript -e "install.packages('cusumcharter')"
+    Rscript -e "install.packages('RcppCNPy')"
+    Rscript -e "install.packages('spc')"
+
+Code execution
+--------------
+Clone AIM-CU repository.
+
+.. code-block:: shell
+
+    git clone https://github.com/DIDSR/AIM-CU.git
+
+Run the following commands to install required dependencies (Python = 3.10 is used).
+
+.. code-block:: shell
+
+    apt-get -y install python3
+    apt-get -y install pip
+    cd AIM-CU
+    pip install -r requirements.txt
+
+Run AIM-CU.
+
+.. code-block:: shell
+
+    cd src/package
+    python3 app.py
+
+Open the URL http://0.0.0.0:7860 that is running the AIM-CU locally.
+
+Example code execution
+----------------------
+Example code can be run through Jupyter Notebook. Do this by entering the ``jupyter notebook`` command from the ``/src/package/`` directory. The tool is designed to be used through a GUI, not from the console.
+
+Demo
+----
+AIM-CU can also be run through the demo available at https://huggingface.co/spaces/didsr/AIM-CU. If Space is paused, click on Restart button. Note: this Space uses a custom Docker container; build may break due to latest package updates pulled by HuggingFace.
+
+Usability
+---------
+* Example AI output CSV file is available as `config/spec-60-60.csv <config/spec-60-60.csv>`_ to be uploaded in monitoring phase.
+
+* Workflow instruction to run the tool is available at bottom-left of UI.
+
+* Sample UI output is available at `assets/ui.png <assets/ui.png>`_.
+
+* Setting ``control:save_figure`` to ``true`` from `config.toml <config/config.toml>`_ will save tables and plots in `figure/ <figure/>`_.
+
+* Running AIM-CU usually only takes a few seconds, and it does not require a GPU to run.
+
+Related References
+------------------
+* Smriti Prathapan, Ravi K. Samala, Nathan Hadjiyski, Pierre‑François D’Haese, Nicholas Petrick, Jana Delfino, Fabien Maldonado, Brandon Nelson, Ghada Zamzmi, Phuong Nguyen, Yelena Yesha, and Berkman Sahiner, "Detecting performance drift in AI models for medical image analysis using CUSUM chart" (Journal in press 2026)
+
+* Prathapan, S., Sahiner, B.,  Kadia, D., and Samala, R.K. 2025, "AIM-CU: A statistical tool for AI Monitoring." (Journal in-press 2026)
+
+* Prathapan, S., Samala, R.K., Hadjiyski, N., D’Haese, P.F., Maldonado, F., Nguyen, P., Yesha, Y. and Sahiner, B., 2024, April. Quantifying input data drift in medical machine learning models by detecting change-points in time-series data. In Medical Imaging 2024: Computer-Aided Diagnosis (Vol. 12927, pp. 67-76). SPIE. https://doi.org/10.1117/12.3008771
+
+* Smriti Prathapan, Ravi K. Samala, Nathan Hadjiyski, Pierre‑François D’Haese, Nicholas Petrick, Jana Delfino, Fabien Maldonado, Brandon Nelson, Ghada Zamzmi, Phuong Nguyen, Yelena Yesha, and Berkman Sahiner, "Post-market Monitoring of AI-enabled Medical Devices for Radiology and Healthcare Applications" (FDA-UMiami Collaboration Poster, September 2023)
+
+Disclaimer
+---------------------
+
+**About the Catalog of Regulatory Science Tools**
+
+The enclosed tool is *in preparation* for the `Catalog of Regulatory Science Tools <https://cdrh-rst.fda.gov>`_. Note that this software is not (yet) a standalone RST but rather is to be included as a **reference tool** to support other Regulatory Science Tools (such as synthetic datasets) for reproducibility.
+
+This catalog collates a variety of regulatory science tools that the FDA's Center for Devices and Radiological Health's (CDRH) Office of Science and Engineering Labs (OSEL) developed. These tools use the most innovative science to support medical device development and patient access to safe and effective medical devices. If you are considering using a tool from this catalog in your marketing submissions, note that these tools have not been qualified as `Medical Device Development Tools <https://www.fda.gov/medical-devices/medical-device-development-tools-mddt>`_ and the FDA has not evaluated the suitability of these tools within any specific context of use. You may `request feedback or meetings for medical device submissions <https://www.fda.gov/regulatory-information/search-fda-guidance-documents/requests-feedback-and-meetings-medical-device-submissions-q-submission-program>`_ as part of the Q-Submission Program.
+
+For more information about the Catalog of Regulatory Science Tools, email RST_CDRH@fda.hhs.gov.

aim_cu-0.2.0/aim_cu/SECURITY.md

@@ -0,0 +1,38 @@
+# Security Policy
+
+## Reporting Security Vulnerabilities
+
+The U.S. Food and Drug Administration (FDA) takes security vulnerabilities seriously. If you believe you have found a security vulnerability in this repository, please report it to us through coordinated disclosure.
+
+**Please do NOT report security vulnerabilities through public GitHub issues, discussions, or pull requests.**
+
+---
+
+## How to Report
+
+FDA follows the HHS Vulnerability Disclosure Policy. Submit your report through the official HHS reporting portal:
+
+- **HHS Vulnerability Disclosure Policy:** [https://www.hhs.gov/vulnerability-disclosure-policy/index.html]
+- **Submit a Report:** [https://hhs.responsibledisclosure.com]
+
+### Contact
+
+For general security questions or concerns about FDA systems, contact:
+- **Repository Maintainer:** [RST_CDRH@fda.hhs.gov]
+- **Security Maintainer:** [ciocc@fda.hhs.gov]
+
+
+---
+## Security Best Practices for Contributors
+
+When contributing to this repository:
+
+- Follow the principle of least privilege
+- Validate and sanitize all inputs
+- Use parameterized queries for database access
+- Keep dependencies up to date
+- Never commit secrets, API keys, or credentials
+- Review security advisories for dependencies
+
+---
+

aim_cu-0.2.0/aim_cu/__init__.py

@@ -0,0 +1,27 @@
+# aim_cu/__init__.py
+
+"""
+AIM-CU: CUSUM-based AI performance monitoring.
+"""
+
+from .aim_cu import (
+    CUSUM,
+    compute_ARL1,
+    compute_ARL1_table,
+    get_ref_value,
+    get_ref_values,
+    get_threshold,
+    load_package_config,
+    shift_in_mean,
+)
+
+__all__ = [
+    "CUSUM",
+    "compute_ARL1",
+    "compute_ARL1_table",
+    "get_ref_value",
+    "get_ref_values",
+    "get_threshold",
+    "load_package_config",
+    "shift_in_mean",
+]

aim_cu-0.2.0/aim_cu/aim_cu.py

@@ -0,0 +1,623 @@
+"""
+AIM-CU is a statistical tool for AI monitoring based on a cumulative sum (AIM-CU) approach.
+
+AIM-CU computes:
+- The parameter choices for change-point detection based on an acceptable false alarm rate
+- Detection delay estimates for a given displacement of the performance metric from the target for those parameter choices.
+
+Notes:
+- Requires: rpy2, an R installation, and R package `spc` (plus optional ggplot2/hexbin/lazyeval/cusumcharter/RcppCNPy).
+- If R packages are missing, this code will attempt to install them (CRAN mirror must be reachable).
+"""
+#Packages
+import os
+import sys
+import random
+import warnings
+from collections import OrderedDict
+from typing import Tuple, List
+
+import numpy as np
+import pandas as pd
+import tomli
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from importlib.resources import files
+
+#Read config.toml 
+def load_package_config():
+    config_path = files("aim_cu").joinpath("config.toml")
+    with config_path.open("rb") as f:
+        return tomli.load(f)
+
+_CONFIG = load_package_config()
+#print("_CONFIG =", _CONFIG)
+shift_in_mean = _CONFIG["CUSUM_params"]["shift_in_mean"]
+# ---------------------------
+# R / rpy2 setup (spc package)
+# ---------------------------
+import rpy2.robjects as ro
+import rpy2.robjects.packages as rpackages
+
+#---new imports
+# import R's utility package
+utils = rpackages.importr('utils')
+spc = rpackages.importr('spc')
+
+# Suppress all R warnings globally
+ro.r["options"](warn=-1)
+
+#warnings.filterwarnings("ignore")
+warnings.filterwarnings("ignore", module=r"rpy2\..*")
+random.seed(58)
+
+# --------------------------------------------------------
+# I Compute CUSUM parameters: h,k and average run length
+# --------------------------------------------------------
+def get_ref_value(h: float, ARL_0: float) -> float:
+    """
+    Compute the normalized reference value (k) for a given threshold (h) and in-control Average Run Length (ARL₀).
+
+    Parameters
+    ----------
+    h : float
+        Normalized decision threshold of the CUSUM chart.
+    ARL_0 : float
+        Target in-control Average Run Length (ARL₀).
+
+    Returns
+    -------
+    float
+        Normalized reference value (k) corresponding to the given h and ARL₀.
+    """
+    k = np.round(spc.xcusum_crit_L0h(ARL_0, h), decimals=4).tolist()[0]
+    return k
+
+
+def get_threshold(k: float, ARL_0: float) -> float:
+    """
+    Compute the normalized threshold (h) for a given reference value (k) 
+    and target in-control Average Run Length (ARL₀).
+
+    Parameters
+    ----------
+    k : float
+        Normalized reference value used in the CUSUM chart.
+    ARL_0 : float
+        Target in-control Average Run Length (ARL₀).
+
+    Returns
+    -------
+    float
+        Normalized threshold (h) corresponding to the given k and ARL₀.
+    """
+    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_values(h: float, list_ARL_0: List[float]) -> Tuple[pd.DataFrame, OrderedDict]:
+    """
+    Compute normalized reference values (k) for a list of target ARL₀ values 
+    given a fixed threshold (h).
+
+    Parameters
+    ----------
+    h : float
+        Normalized decision threshold of the CUSUM chart.
+    list_ARL_0 : List[float]
+        List of target in-control Average Run Length (ARL₀) values.
+
+    Returns
+    -------
+    Tuple[pandas.DataFrame, collections.OrderedDict]
+        A tuple containing:
+        - DataFrame: Table with columns ['ARL_0', 'k'] listing each ARL₀ and its corresponding k.
+        - OrderedDict: Mapping of ARL₀ to k
+    """
+    dict_ARL0_k: OrderedDict = OrderedDict()
+    summary_table_df_ARL0_k = pd.DataFrame(columns=["ARL_0", "k"])
+
+    for n, ARL_0 in enumerate(list_ARL_0):
+        k = np.round(spc.xcusum_crit_L0h(ARL_0, h), decimals=4).tolist()[0]
+        summary_table_df_ARL0_k.loc[n] = [ARL_0, k]
+        dict_ARL0_k[ARL_0] = k
+
+    return summary_table_df_ARL0_k, dict_ARL0_k
+
+
+def compute_ARL1(h: float, k: float, mu1: float) -> float:
+    """
+    Compute the out-of-control Average Run Length (ARL₁) for a given 
+    threshold (h), reference value (k), and mean shift (μ₁).
+
+    Parameters
+    ----------
+    h : float
+        Normalized decision threshold.
+    k : float
+        Normalized reference value.
+    mu1 : float
+        Change in the process mean (standard deviations from the target value).
+
+    Returns
+    -------
+    float
+        Average Run Length (ARL₁), is the estimate of steady state ARL (expected detection delay) to detect the change in mean.
+    """
+    ARL_1 = np.round(
+        spc.xcusum_ad_(k=k, h=h, mu1=mu1, mu0=0, sided="two", r=20),
+        decimals=2,
+    ).tolist()[0]
+    return ARL_1
+
+
+def compute_ARL1_table(h: float, shift_in_mean: List[float], dict_ARL0_k: OrderedDict) -> pd.DataFrame:
+    """
+    Compute a table of Average Run Length (ARL₁) values across multiple change in mean and ARL₀-reference value (k) combinations.
+
+    Parameters
+    ----------
+    h : float
+        Normalized decision threshold.
+    shift_in_mean : List[float]
+        List of mean shifts (μ₁), expressed in standardized units.
+    dict_ARL0_k : OrderedDict
+        Mapping of target in-control ARL₀ values to their corresponding
+        normalized reference values (k).
+
+    Returns
+    -------
+    pandas.DataFrame
+        Table of ARL₁ values for mean shifts and corresponding ARL₀-k combinations.
+    """
+    list_ARL_0 = list(dict_ARL0_k.keys())
+
+    dict_data_ARL1_k: OrderedDict = OrderedDict()
+    dict_data_ARL1_k["Shift in mean"] = shift_in_mean
+
+    for ARL_0 in list_ARL_0:
+        k = dict_ARL0_k[ARL_0]
+        list_ARL_1 = []
+        for mu1 in shift_in_mean:
+            ARL_1 = np.round(
+                spc.xcusum_ad_(k=k, h=h, mu1=mu1, mu0=0, sided="two", r=20),
+                decimals=2,
+            ).tolist()[0]
+            list_ARL_1.append(ARL_1)
+
+        #Format column name: "50 (0.16)"
+        col_name = f"{int(ARL_0)} ({k:.2f})"
+        dict_data_ARL1_k[col_name] = list_ARL_1
+
+        #dict_data_ARL1_k[ARL_0] = list_ARL_1
+
+    return pd.DataFrame(dict_data_ARL1_k)
+
+
+# -------------------------------------------
+# II Performance drift detection using CUSUM
+# -------------------------------------------
+class CUSUM:
+    """
+    CUSUM-based performance drift detection.
+
+    This class provides methods to initialize baseline parameters, compute
+    positive and negative CUSUM statistics, detect performance drifts, and
+    generate CUSUM charts.
+    """
+
+    def __init__(self):
+        self.df_metric = None
+        self.metric_type = None
+
+        self.AvgDD = None
+        self.data = None
+
+        self.H = None
+        self.in_std = None
+        self.in_mu = None
+        self.S_hi = None
+        self.S_lo = None
+
+        self.config = None
+
+        self.total_days = None
+        self.pre_change_days = None
+        self.post_change_days = None
+
+        self.init_days = None
+
+    def initialize(self) -> None:
+        """
+        Load and initialize configuration settings from the configuration file (`config.toml`).
+
+        This method populates the 'config' attribute with parameters such as plotting options, and default values.
+
+        Returns
+        -------
+        None
+        """
+        try:
+            path_file_config = os.path.abspath("config.toml")
+            with open(path_file_config, "rb") as file_config:
+                self.config = tomli.load(file_config)
+        except FileNotFoundError:
+            print("Error: config.toml not found at", path_file_config)
+            sys.exit(1)
+
+    def set_init_stats(self, init_days: int) -> None:
+        """
+        Compute in-control parameters from baseline observations.
+
+        Uses the first 'init_days' observations to estimate the in-control mean and standard deviation.
+
+        Parameters
+        ----------
+        init_days : int
+            Number of observations assumed to be in-control.
+
+        Returns
+        -------
+        None
+        """
+        self.init_days = init_days
+        in_control_data = self.data[: self.init_days]
+        self.in_std = float(np.std(in_control_data))
+        self.in_mu = float(np.mean(in_control_data))
+
+    def set_timeline(self, data: np.ndarray) -> None:
+        """
+        Set the timeline of the performance metric.
+
+        Determines the total number of observations in the input data.
+
+        Parameters
+        ----------
+        data : np.ndarray
+            1D Array of the AI performance metric.
+
+        Returns
+        -------
+        None
+        """
+        self.total_days = int(np.shape(data)[0])
+
+    def set_df_metric_default(self) -> None:
+        """
+        Read the AI performance metric from the default CSV file and initializes the internal 
+        data and set the timeline.
+
+        Raises
+        ------
+        SystemExit
+            If the CSV file is not found at the specified path.
+
+        Returns
+        -------
+        None
+        """
+        try:
+            path_csv = os.path.abspath(os.path.join("../../", self.config["path_input"]["path_df_metric"]))
+            self.df_metric = pd.read_csv(path_csv)
+        except FileNotFoundError:
+            print("Error: CSV file not found at", path_csv)
+            sys.exit(1)
+
+        self.data = self.df_metric[self.df_metric.columns[1]].to_numpy()
+        self.set_timeline(self.data)
+
+    def set_df_metric_csv(self, data_csv: pd.DataFrame) -> None:
+        """
+        Assign the performance metric data read fom the input csv file to a datafram .
+        Parameters
+        ----------
+        data_csv : pandas.DataFrame
+            DataFrame containing the performance metric data. The values are expected in the second column (index 1).
+
+        Returns
+        -------
+        None
+        """
+        self.df_metric = data_csv
+        self.data = self.df_metric[self.df_metric.columns[1]].to_numpy()
+        self.set_timeline(self.data)
+
+    def compute_cusum(
+        self, x: List[float], mu_0: float, ref_val: float
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Compute CUSUM statistics for the performance metric.
+
+        Calculates the positive (S_hi) and negative (S_lo) cumulative sums,
+        along with the cumulative deviation from the in-control mean, to
+        monitor for shifts in the process.
+
+        Parameters
+        ----------
+        x : List[float]
+            Sequence of observed performance metric values.
+        mu_0 : float
+            In-control mean (baseline) of the performance metric.
+        ref_val : float
+            Reference value (k) that determines sensitivity to shifts.
+
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray, np.ndarray]
+            A tuple containing:
+            - S_hi : Positive CUSUM values (detects upward shifts)
+            - S_lo : Negative CUSUM values (detects downward shifts)
+            - cusum : Cumulative sum of deviations from the mean
+        """
+        x = np.asarray(x, dtype=float)
+        num_rows = x.shape[0]
+
+        x_mean = np.zeros(num_rows, dtype=float)
+        self.S_hi = np.zeros(num_rows, dtype=float)
+        self.S_lo = np.zeros(num_rows, dtype=float)
+        cusum = np.zeros(num_rows, dtype=float)
+
+        # Starts with 0
+        self.S_hi[0] = 0.0
+        self.S_lo[0] = 0.0
+        cusum[0] = 0.0
+
+        mean_hi = np.zeros(num_rows, dtype=float)
+        mean_lo = np.zeros(num_rows, dtype=float)
+
+        
+        x_mean[0] = x[0] - mu_0
+        mean_hi[0] = x[0] - mu_0 - ref_val
+        mean_lo[0] = mu_0 - ref_val - x[0]
+
+        for i in range(1, num_rows):
+            x_mean[i] = x[i] - mu_0
+            mean_hi[i] = x[i] - mu_0 - ref_val
+            self.S_hi[i] = max(0.0, self.S_hi[i - 1] + mean_hi[i])
+            mean_lo[i] = mu_0 - ref_val - x[i]
+            self.S_lo[i] = max(0.0, self.S_lo[i - 1] + mean_lo[i])
+            cusum[i] = cusum[i - 1] + x_mean[i]
+
+        return (
+            np.round(self.S_hi, 2),
+            np.round(self.S_lo, 2),
+            np.round(cusum, 2),
+        )
+
+    def change_detection(
+        self,
+        normalized_ref_value: float = 0.5,
+        normalized_threshold: float = 4,
+    ) -> None:
+        """
+        Detect changes in the process using CUSUM statistics.
+
+        Computes the CUSUM values and identifies the first point at which
+        the process deviates significantly from the in-control state based
+        on the specified reference value and threshold.
+
+        Parameters
+        ----------
+        normalized_ref_value : float, optional
+            Normalized reference value (k) that controls sensitivity to
+            shifts in the process mean. Default is 0.5.
+        normalized_threshold : float, optional
+            Normalized decision threshold (h) used to signal a change.
+            Default is 4.
+        Returns
+        -------
+        None
+        """
+        self.pre_change_days = None
+
+        control_limit = normalized_threshold
+        self.H = control_limit * self.in_std
+        ref_val = normalized_ref_value * self.in_std
+
+        x = np.array(self.data, dtype=float)
+        self.S_hi, self.S_lo, _ = self.compute_cusum(x, self.in_mu, ref_val)
+        
+        # Find first occurrence where the 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]
+        
+        # Detect whether S_hi or S_lo exceeds threshold
+        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 = int(S_hi_exceeds[0])
+                print(f"Detected upward drift at: {self.pre_change_days}")
+            else:
+                self.pre_change_days = int(S_lo_exceeds[0])
+                print(f"Detected downward drift at: {self.pre_change_days}")
+        elif len(S_hi_exceeds) > 0:
+            self.pre_change_days = int(S_hi_exceeds[0])
+            print(f"Detected upward drift at: {self.pre_change_days}")
+        elif len(S_lo_exceeds) > 0:
+            self.pre_change_days = int(S_lo_exceeds[0])
+            print(f"Detected downward drift at: {self.pre_change_days}")
+        else:
+            print("No performance drift detected")
+        
+    def plot_input_data(self):
+        """
+        Plot the AI performance metric with baseline region highlighted.
+
+        Generates a scatter plot of the performance metric over time
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            Matplotlib figure containing the scatter plot of the data.
+        """
+        x1 = np.arange(self.init_days)
+        y1 = self.data[: self.init_days]
+
+        x2 = np.arange(self.init_days, self.total_days, 1)
+        y2 = self.data[self.init_days : self.total_days]
+        
+        fig, ax = plt.subplots(figsize=(10, 5))
+
+        # Scatter plots
+        ax.scatter(x1, y1, color="lime", s=20, alpha=0.4)
+        ax.scatter(x2, y2, color="lime", s=20, alpha=0.2)
+
+        # Highlight baseline 
+        ax.axvspan(0, self.init_days, color="palegreen", alpha=0.25)
+
+        # Labels and title
+        ax.set_title("AI output", fontsize=16, fontweight="bold")
+        ax.set_xlabel("Time", fontsize=14, fontweight="bold")
+        ax.set_ylabel("AI model metric", fontsize=14, fontweight="bold")
+
+        # Tick spacing (similar to dtick=20)
+        ax.set_xticks(np.arange(0, self.total_days, 20))
+
+        # Background color (optional)
+        try:
+            ax.set_facecolor(self.config["color"]["blue_005"])
+        except Exception:
+            pass  # fallback if config not set
+
+        # Remove legend 
+        ax.legend().set_visible(False) if ax.get_legend() else None
+
+        plt.tight_layout()
+
+        return fig
+
+    def plot_changepoint(self):
+        """
+        Plot the AI performance metric with the detected change pointhighlighting in-control and out-of-control regions 
+        and marking the detected change point.
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            Matplotlib figure containing the change-point plot.
+        """
+
+        # Determine change-point
+        if self.pre_change_days is None:
+            split = self.init_days
+        else:
+            split = self.pre_change_days
+
+        # Split data
+        x1 = np.arange(split)
+        y1 = self.data[:split]
+        mean_y1 = np.mean(y1) if len(y1) else 0.0
+
+        x2 = np.arange(split, self.total_days)
+        y2 = self.data[split:self.total_days]
+        mean_y2 = np.mean(y2) if len(y2) else 0.0
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+
+        # Scatter plots
+        ax.scatter(x1, y1, color="darkturquoise", s=20, alpha=0.4, label="In-control data")
+        ax.scatter(x2, y2, color="coral", s=20, alpha=0.4, label="Test data")
+
+        # Mean lines
+        if len(x1):
+            ax.plot([x1.min(), x1.max()], [mean_y1, mean_y1],
+                    linestyle="--", color="darkturquoise", label="In-control mean")
+
+        if len(x2):
+            ax.plot([x2.min(), x2.max()], [mean_y2, mean_y2],
+                    linestyle="--", color="coral", label="Test mean")
+
+        # Change-point line
+        ax.axvline(x=split, color="grey", linestyle="--", label="Detected change-point")
+
+        # Labels and title
+        ax.set_title("AI model performance versus time", fontsize=16, fontweight="bold")
+        ax.set_xlabel("Time", fontsize=14, fontweight="bold")
+        ax.set_ylabel("AI model performance", fontsize=14, fontweight="bold")
+
+        # Tick spacing similar to dtick=20
+        ax.set_xticks(np.arange(0, self.total_days, 20))
+
+        # Background color (optional)
+        try:
+            ax.set_facecolor(self.config["color"]["blue_005"])
+        except Exception:
+            pass
+
+        # Legend (top center like Plotly)
+        ax.legend(loc="lower center", bbox_to_anchor=(0.5, 1.15), ncol=3, frameon=True)
+
+        plt.tight_layout()
+    
+        return fig
+
+    
+
+    def plot_cusum_chart(self):
+        """
+        Plot the CUSUM chart of the performance metric: the positive (S_hi) and negative (S_lo) CUSUM statistics 
+        along with the decision threshold 
+        used for change detection.
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            Matplotlib figure with the CUSUM chart.
+        """
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+
+        # X axis
+        x = np.arange(len(self.S_hi))
+
+        # Plot S_hi and S_lo (normalized)
+        ax.plot(x, self.S_hi / self.in_std,
+                label="Positive changes (S_hi)",
+                color="cyan")
+
+        ax.plot(x, self.S_lo / self.in_std,
+                label="Negative changes (S_lo)",
+                color="darkcyan")
+
+        # Threshold line
+        threshold = self.H / self.in_std
+        ax.plot([0, len(self.S_lo)],
+                [threshold, threshold],
+                linestyle="--",
+                color="magenta",
+                label="Threshold (h)")
+
+        # Determine split point
+        split = self.pre_change_days if self.pre_change_days is not None else self.init_days
+
+        # Background shading (like Plotly rectangles)
+        try:
+            ax.axvspan(0, split,
+                    color=self.config["color"]["blue_005"],
+                    alpha=0.8)
+
+            ax.axvspan(split, len(self.S_lo),
+                    color="rgb(253, 243, 235)",
+                    alpha=0.8)
+        except Exception:
+            # fallback if config missing
+            ax.axvspan(0, split, color="lightblue", alpha=0.3)
+            ax.axvspan(split, len(self.S_lo), color="mistyrose", alpha=0.3)
+
+        # Labels and title
+        ax.set_title("CUSUM Chart", fontsize=16, fontweight="bold")
+        ax.set_xlabel("Time", fontsize=14, fontweight="bold")
+        ax.set_ylabel("CUSUM value", fontsize=14, fontweight="bold")
+
+        # Tick spacing similar to dtick=20
+        ax.set_xticks(np.arange(0, len(self.S_lo), 20))
+
+        # Legend (top center)
+        ax.legend(loc="lower center", bbox_to_anchor=(0.5, 1.15), ncol=3, frameon=True)
+
+        plt.tight_layout()
+
+        return fig

aim_cu-0.2.0/aim_cu/config.toml

@@ -0,0 +1,21 @@
+# paths to output files
+[path_output]
+path_figure = "."
+
+# primary colors
+[color]
+blue_005 = "#F3F9FC"
+blue_020 = "#D0E4F0"
+blue_040 = "#A3CAE1"
+blue_060 = "#77B0D2"
+blue_080 = "#4F96C4"
+blue_100 = "#007CBA"
+
+# controls
+[control]
+save_figure = "false"
+
+# CUSUM parameters
+[CUSUM_params]
+list_ARL_0 = [50, 100, 150, 200, 300, 400, 500, 1000]
+shift_in_mean = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6]

aim_cu-0.2.0/aim_cu.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: aim-cu
+Version: 0.2.0
+Summary: AIM-CU: A CUSUM-based tool for AI Monitoring
+Home-page: https://github.com/DIDSR/AIM-CU
+Project-URL: User Inteface, https://huggingface.co/spaces/didsr/AIM-CU
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: matplotlib>=3.6
+Requires-Dist: rpy2>=3.5
+Requires-Dist: tomli; python_version < "3.11"
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+AIM-CU: A CUSUM-based tool for AI Monitoring
+============================================
+Monitoring a clinically deployed AI device to detect performance drift is an essential step to ensure the safety and effectiveness of AI. 
+
+AIM-CU is a statistical tool for AI monitoring based on a cumulative sum (AIM-CU) approach.
+
+AIM-CU computes:
+
+* The parameter choices for change-point detection based on an acceptable false alarm rate
+* Detection delay estimates for a given displacement of the performance metric from the target for those parameter choices.
+
+System setup
+------------
+Make sure R is installed in the system. There is no specific version that this relies on. Here we have used the version 4.1.2 (2021-11-01). 
+Instructions for Linux (the below setup is only performed in Linux):
+
+.. code-block:: shell
+
+    wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc |  tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc
+    add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/"
+    apt-get install -y --no-install-recommends r-base r-base-dev
+
+    # setup R configs
+    echo "r <- getOption('repos'); r['CRAN'] <- 'http://cran.us.r-project.org'; options(repos = r);" > ~/.Rprofile
+    Rscript -e "install.packages('ggplot2')"
+    Rscript -e "install.packages('hexbin')"
+    Rscript -e "install.packages('lazyeval')"
+    Rscript -e "install.packages('cusumcharter')"
+    Rscript -e "install.packages('RcppCNPy')"
+    Rscript -e "install.packages('spc')"
+
+Code execution
+--------------
+Clone AIM-CU repository.
+
+.. code-block:: shell
+
+    git clone https://github.com/DIDSR/AIM-CU.git
+
+Run the following commands to install required dependencies (Python = 3.10 is used).
+
+.. code-block:: shell
+
+    apt-get -y install python3
+    apt-get -y install pip
+    cd AIM-CU
+    pip install -r requirements.txt
+
+Run AIM-CU.
+
+.. code-block:: shell
+
+    cd src/package
+    python3 app.py
+
+Open the URL http://0.0.0.0:7860 that is running the AIM-CU locally.
+
+Example code execution
+----------------------
+Example code can be run through Jupyter Notebook. Do this by entering the ``jupyter notebook`` command from the ``/src/package/`` directory. The tool is designed to be used through a GUI, not from the console.
+
+Demo
+----
+AIM-CU can also be run through the demo available at https://huggingface.co/spaces/didsr/AIM-CU. If Space is paused, click on Restart button. Note: this Space uses a custom Docker container; build may break due to latest package updates pulled by HuggingFace.
+
+Usability
+---------
+* Example AI output CSV file is available as `config/spec-60-60.csv <config/spec-60-60.csv>`_ to be uploaded in monitoring phase.
+
+* Workflow instruction to run the tool is available at bottom-left of UI.
+
+* Sample UI output is available at `assets/ui.png <assets/ui.png>`_.
+
+* Setting ``control:save_figure`` to ``true`` from `config.toml <config/config.toml>`_ will save tables and plots in `figure/ <figure/>`_.
+
+* Running AIM-CU usually only takes a few seconds, and it does not require a GPU to run.
+
+Related References
+------------------
+* Smriti Prathapan, Ravi K. Samala, Nathan Hadjiyski, Pierre‑François D’Haese, Nicholas Petrick, Jana Delfino, Fabien Maldonado, Brandon Nelson, Ghada Zamzmi, Phuong Nguyen, Yelena Yesha, and Berkman Sahiner, "Detecting performance drift in AI models for medical image analysis using CUSUM chart" (Journal in press 2026)
+
+* Prathapan, S., Sahiner, B.,  Kadia, D., and Samala, R.K. 2025, "AIM-CU: A statistical tool for AI Monitoring." (Journal in-press 2026)
+
+* Prathapan, S., Samala, R.K., Hadjiyski, N., D’Haese, P.F., Maldonado, F., Nguyen, P., Yesha, Y. and Sahiner, B., 2024, April. Quantifying input data drift in medical machine learning models by detecting change-points in time-series data. In Medical Imaging 2024: Computer-Aided Diagnosis (Vol. 12927, pp. 67-76). SPIE. https://doi.org/10.1117/12.3008771
+
+* Smriti Prathapan, Ravi K. Samala, Nathan Hadjiyski, Pierre‑François D’Haese, Nicholas Petrick, Jana Delfino, Fabien Maldonado, Brandon Nelson, Ghada Zamzmi, Phuong Nguyen, Yelena Yesha, and Berkman Sahiner, "Post-market Monitoring of AI-enabled Medical Devices for Radiology and Healthcare Applications" (FDA-UMiami Collaboration Poster, September 2023)
+
+Disclaimer
+---------------------
+
+**About the Catalog of Regulatory Science Tools**
+
+The enclosed tool is *in preparation* for the `Catalog of Regulatory Science Tools <https://cdrh-rst.fda.gov>`_. Note that this software is not (yet) a standalone RST but rather is to be included as a **reference tool** to support other Regulatory Science Tools (such as synthetic datasets) for reproducibility.
+
+This catalog collates a variety of regulatory science tools that the FDA's Center for Devices and Radiological Health's (CDRH) Office of Science and Engineering Labs (OSEL) developed. These tools use the most innovative science to support medical device development and patient access to safe and effective medical devices. If you are considering using a tool from this catalog in your marketing submissions, note that these tools have not been qualified as `Medical Device Development Tools <https://www.fda.gov/medical-devices/medical-device-development-tools-mddt>`_ and the FDA has not evaluated the suitability of these tools within any specific context of use. You may `request feedback or meetings for medical device submissions <https://www.fda.gov/regulatory-information/search-fda-guidance-documents/requests-feedback-and-meetings-medical-device-submissions-q-submission-program>`_ as part of the Q-Submission Program.
+
+For more information about the Catalog of Regulatory Science Tools, email RST_CDRH@fda.hhs.gov.

aim_cu-0.2.0/aim_cu.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+setup.py
+aim_cu/README.rst
+aim_cu/SECURITY.md
+aim_cu/__init__.py
+aim_cu/aim_cu.py
+aim_cu/config.toml
+aim_cu.egg-info/PKG-INFO
+aim_cu.egg-info/SOURCES.txt
+aim_cu.egg-info/dependency_links.txt
+aim_cu.egg-info/requires.txt
+aim_cu.egg-info/top_level.txt
+test/test_aim_cu.py

aim_cu-0.2.0/aim_cu.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aim_cu-0.2.0/aim_cu.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy>=1.23
+pandas>=1.5
+matplotlib>=3.6
+rpy2>=3.5
+
+[:python_version < "3.11"]
+tomli

aim_cu-0.2.0/aim_cu.egg-info/top_level.txt

@@ -0,0 +1 @@
+aim_cu

aim_cu-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aim_cu-0.2.0/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+this_dir = Path(__file__).parent
+long_description = (this_dir / "aim_cu" / "README.rst").read_text(encoding="utf-8")
+
+setup(
+    name="aim-cu",
+    version="0.2.0",
+    description="AIM-CU: A CUSUM-based tool for AI Monitoring",
+    long_description=long_description,
+    long_description_content_type="text/x-rst",
+    authors="Smriti Prathapan, Berkman Sahiner, Dhaval Kadia and Ravi Samala",
+    packages=find_packages(),
+    python_requires=">=3.9",
+    install_requires=[
+        "numpy>=1.23",
+        "pandas>=1.5",
+        "matplotlib>=3.6",
+        "rpy2>=3.5",
+        "tomli; python_version<'3.11'",
+    ],
+    include_package_data=True,
+    package_data={
+        "aim_cu": ["config.toml", "SECURITY.md", "README.rst"],
+    },
+    url="https://github.com/DIDSR/AIM-CU",
+    project_urls={
+        "User Inteface" : "https://huggingface.co/spaces/didsr/AIM-CU",
+    },
+)

aim_cu-0.2.0/test/test_aim_cu.py

@@ -0,0 +1,90 @@
+#Usage:
+#  python test_aim_cu.py --csv /scratch/smriti.prathapan/fromOHPC/note1/AIM-CU-package/spec-60-60.csv  --norm_h 5
+
+import argparse
+# import numpy as np
+import pandas as pd
+import warnings
+warnings.simplefilter("ignore")
+import aim_cu
+# import matplotlib
+# from collections import OrderedDict
+# matplotlib.use("Agg")
+# import matplotlib.pyplot as plt
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--csv", default=None, help="input the CSV path")
+    parser.add_argument("--init_days", type=int, default=30)
+    parser.add_argument("--norm_k", type=float, default=0.5)
+    parser.add_argument("--norm_h", type=float, default=4.0)
+    #parser.add_argument("--show_plots", action="store_true")
+    args = parser.parse_args()
+    
+    # --------------------------------------------------------
+    # I Compute CUSUM parameters and average run length
+    # --------------------------------------------------------
+    h = float(args.norm_h)
+    print("\n=== SPC helper functions for computing CUSUM parameters ===")
+    k_for_arl100 = aim_cu.get_ref_value(h=h, ARL_0=100.0)
+    #print(f"k (for h={h}, ARL0=100): {k_for_arl100}")
+    
+    h_back = aim_cu.get_threshold(k=k_for_arl100, ARL_0=100.0)
+    print(f"h (for k={k_for_arl100}, ARL0=100): {h_back}")
+    
+    df_k, dict_k = aim_cu.get_ref_values(h=4.0, list_ARL_0=[50.0, 100.0, 200.0])
+    print(f"list of k values  h={h} : \n")
+    print(df_k)
+    
+    #print(aim_cu.shift_in_mean)
+    #print(aim_cu.dict_ARL0_k)
+
+    ARL_1 = aim_cu.compute_ARL1(h=h_back,k=k_for_arl100, mu1=0.65)
+    print(f"ARL_1 : {ARL_1}")
+    
+    df_arl_1 = aim_cu.compute_ARL1_table(h=4, shift_in_mean=[0.1, 0.2, 0.3], dict_ARL0_k=dict_k)
+    print(f"ARL_1 table : {df_arl_1}")
+
+    # -------------------------------
+    # II Performance drift detection
+    # -------------------------------
+    print("\n=== Performance drift detection using CUSUM ===")
+    cusum = aim_cu.CUSUM() 
+    
+
+    # If config.toml is not found, initialize() will sys.exit(1)
+    try:
+        cusum.initialize()
+    except SystemExit:
+        print("WARNING: config.toml not found. Using fallback config.")
+        cusum.config = {
+            "color": {"blue_005": "white"},
+            "control": {"save_figure": "false"},
+            "path_output": {"path_figure": "."},
+        }
+
+    if args.csv:
+        df = pd.read_csv(args.csv)
+        cusum.set_df_metric_csv(df)
+    else:
+        cusum.set_df_metric_default()
+
+    cusum.set_init_stats(args.init_days)
+    print(f"Total observations: {cusum.total_days}")
+    print(f"Baseline observations: {cusum.init_days}")
+
+    cusum.change_detection(normalized_ref_value=args.norm_k, normalized_threshold=args.norm_h)
+    
+    fig1 = cusum.plot_input_data()
+    #fig1.write_image("input_data.png") 
+    fig1.savefig("input_data.png", dpi=200, bbox_inches="tight")
+
+    fig2 = cusum.plot_changepoint()
+    fig2.savefig("changepoint.png", dpi=200, bbox_inches="tight")
+    
+    fig3 = cusum.plot_cusum_chart()
+    fig3.savefig("cusum_chart.png", dpi=200, bbox_inches="tight")
+
+
+if __name__ == "__main__":
+    main()