diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..74cb5e1 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,33 @@ +name: build + +on: + push: + branches: + - "*" +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install dependencies + run: python -m pip install .[test] --upgrade pip --no-cache-dir + - name: Test with pytest + run: pytest # --cov=./ --cov-report=xml + # repository > settings > github apps > configure codecov + + # - name: Build package distribution + # if: startsWith(github.ref, 'refs/tags') + # run: | + # python -m pip install build + # python -m build --sdist --wheel --outdir dist/ . + # - name: Publish package distribution to PyPI + # if: startsWith(github.ref, 'refs/tags') + # uses: pypa/gh-action-pypi-publish@master + # with: + # skip_existing: true + # user: __token__ + # password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml new file mode 100644 index 0000000..990c576 --- /dev/null +++ b/.github/workflows/deploy.yml @@ -0,0 +1,59 @@ +name: deploy + +on: + push: + tags: + - "v[0-9]+.[0-9]+.[0-9]+" + +permissions: + contents: write + +jobs: + pypi: + if: false + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install dependencies + run: python -m pip install build . --upgrade pip + # - name: Build package distribution + # run: python-m build --sdist --wheel --outdir dist/ . + # - name: Publish package distribution to PyPI + # uses: pypa/gh-action-pypi-publish@release/v1 + # with: + # skip_existing: true + # user: __token__ + # password: ${{ secrets.PYPI_API_TOKEN }} + + docs: + runs-on: ubuntu-latest + permissions: + pages: write + id-token: write + steps: + - uses: actions/checkout@v4 + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install dependencies + run: python -m pip install .[docs] --upgrade pip + - name: Generate API docs & Build sphinx documentation + run: | + git fetch --tags + cd docs + python build.py + cd .. + - name: Setup Pages + uses: actions/configure-pages@v5 + - name: Upload artifact + uses: actions/upload-pages-artifact@v3 + with: + path: './docs/pages' + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v4 \ No newline at end of file diff --git a/.github/workflows/python-build.yml b/.github/workflows/python-build.yml deleted file mode 100644 index 855040b..0000000 --- a/.github/workflows/python-build.yml +++ /dev/null @@ -1,29 +0,0 @@ -name: python-build -on: [push] -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - name: Set up Python 3.8 - uses: actions/setup-python@v2 - with: - python-version: 3.8 - - name: Install dependencies - run: python -m pip install .[dev] --upgrade pip - - name: Test with pytest - run: pytest - - name: Build package distribution - if: startsWith(github.ref, 'refs/tags') - run: | - python -m pip install build - python -m build --sdist --wheel --outdir dist/ . - - name: Publish package distribution to PyPI - if: startsWith(github.ref, 'refs/tags') - uses: pypa/gh-action-pypi-publish@master - with: - skip_existing: true - user: __token__ - password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.gitignore b/.gitignore index b6e4761..b1047d9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +**/.DS_Store + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..e0121b7 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,15 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Python Debugger: Current File", + "type": "debugpy", + "request": "launch", + "program": "${file}", + "console": "integratedTerminal" + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..feb8771 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,15 @@ +{ + "[python]": { + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.formatOnSave": true, + "editor.codeActionsOnSave": { + "source.organizeImports": "explicit", + }, + "editor.rulers": [80], + }, + "python.testing.pytestArgs": [ + "tests" + ], + "python.testing.unittestEnabled": false, + "python.testing.pytestEnabled": true, +} \ No newline at end of file diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..d4bb2cb --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/_static/css/custom.css b/docs/_static/css/custom.css new file mode 100644 index 0000000..e6b6138 --- /dev/null +++ b/docs/_static/css/custom.css @@ -0,0 +1,19 @@ +/* reduce the size of the main text */ +p { + font-size: 0.95rem; +} + +h1, +h2, +h3, +h4, +h5, +h6 { + font-weight: 500; +} + +.sidebar-brand-text { + font-size: 1rem; + font-weight: 500; + margin: auto; +} \ No newline at end of file diff --git a/docs/_static/logo/logo-dark.png b/docs/_static/logo/logo-dark.png new file mode 100644 index 0000000..b321abd Binary files /dev/null and b/docs/_static/logo/logo-dark.png differ diff --git a/docs/_static/logo/logo-light.png b/docs/_static/logo/logo-light.png new file mode 100644 index 0000000..1786e8f Binary files /dev/null and b/docs/_static/logo/logo-light.png differ diff --git a/docs/_templates/sidebar/variant-selector.html b/docs/_templates/sidebar/variant-selector.html new file mode 100644 index 0000000..f65a174 --- /dev/null +++ b/docs/_templates/sidebar/variant-selector.html @@ -0,0 +1,15 @@ +
+ +
\ No newline at end of file diff --git a/docs/api_reference/example.rst b/docs/api_reference/example.rst new file mode 100644 index 0000000..6efcabc --- /dev/null +++ b/docs/api_reference/example.rst @@ -0,0 +1,5 @@ +pypkg.example +============= + +.. automodule:: pypkg.example + :members: diff --git a/docs/api_reference/index.rst b/docs/api_reference/index.rst new file mode 100644 index 0000000..f1f9976 --- /dev/null +++ b/docs/api_reference/index.rst @@ -0,0 +1,13 @@ +API reference +============= + +.. toctree:: + :hidden: + :glob: + + * + +.. note:: + Briefly describe the organization of the API reference if any. + +In PyPkg, we only provide a dummy function :py:func:`.example.add` to show the bone structure of a Python pacakge. \ No newline at end of file diff --git a/docs/build.py b/docs/build.py new file mode 100644 index 0000000..aa2c854 --- /dev/null +++ b/docs/build.py @@ -0,0 +1,41 @@ +import functools +import subprocess + +import tomllib + +run = functools.partial(subprocess.run, shell=True) + + +def build_doc(version: str) -> None: + run(f"git checkout v{version}") + run("git checkout main -- conf.py") + run("git checkout main -- versions.toml") + + run("make html") + run(f"mv _build/html pages/{version}") + run("rm -rf _build") + run("git checkout main") + + +def build_init_page(version: str) -> None: + with open("pages/index.html", "w") as f: + f.write(f""" +""") + + +if __name__ == "__main__": + # create pages folder + run("rm -rf pages") + run("mkdir pages") + + # get versions + with open("meta.toml", "rb") as f: + versions = tomllib.load(f)["versions"] + versions.sort(reverse=True, key=lambda v: tuple(map(int, v.split(".")))) + + # build documentations for different versions + for version in versions: + build_doc(version) + + # build initial page that redirect to the latest version + build_init_page(versions[0]) diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..b5d791e --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,106 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath(".")) +import datetime + +import tomllib + +with open("../pyproject.toml", "rb") as f: + about = tomllib.load(f)["project"] + + +# -- Project information ----------------------------------------------------- + +project = about["name"] +author = ", ".join([info["name"] for info in about["authors"]]) +copyright = f"2019-{datetime.datetime.today().year}, {author}" + + +# The full version, including alpha/beta/rc tags +version = about["version"] + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named "sphinx.ext.*") or your custom +# ones. +extensions = [ + "sphinx.ext.autodoc", + "sphinx.ext.autosectionlabel", + "sphinx.ext.extlinks", + "sphinx.ext.intersphinx", + "sphinx.ext.mathjax", + "sphinx.ext.todo", + "sphinx.ext.viewcode", + "sphinx.ext.napoleon", +] +autodoc_typehints = "description" +autodoc_member_order = "bysource" +autodoc_type_aliases = { + "ArrayLike": "ArrayLike", + "NDArray": "NDArray", + "DataFrame": "DataFrame", +} + +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = "furo" + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ["_static"] +html_css_files = ["css/custom.css"] +html_title = f"{project} {version}" +html_theme_options = { + "sidebar_hide_name": False, + "light_logo": "logo/logo-light.png", + "dark_logo": "logo/logo-dark.png", + "light_css_variables": { + "color-brand-primary": "#008080", + "color-brand-content": "#008080", + "color-problematic": "#BF5844", + "color-background-secondary": "#F8F8F8", + "color-admonition-title--note": "#008080", + "color-admonition-title-background--note": "#00808033", + }, + "dark_css_variables": { + "color-brand-primary": "#6FD8D1", + "color-brand-content": "#6FD8D1", + "color-problematic": "#FA9F50", + "color-background-secondary": "#202020", + "color-admonition-title--note": "#6FD8D1", + "color-admonition-title-background--note": "#6FD8D133", + }, +} +# get versions +with open("meta.toml", "rb") as f: + versions = tomllib.load(f)["versions"] +html_context = { + "versions": versions, +} diff --git a/docs/developer_guide/index.rst b/docs/developer_guide/index.rst new file mode 100644 index 0000000..71c2114 --- /dev/null +++ b/docs/developer_guide/index.rst @@ -0,0 +1,11 @@ +Developer guide +=============== + +.. admonition:: Work in progress... + :class: attention + + Current topics + + * briefly describe how to contribute + * contributing to the documentation + * contributing to the code base \ No newline at end of file diff --git a/docs/getting_started/index.rst b/docs/getting_started/index.rst new file mode 100644 index 0000000..ad43ac6 --- /dev/null +++ b/docs/getting_started/index.rst @@ -0,0 +1,17 @@ +Getting started +=============== + +.. toctree:: + :hidden: + + installation + quickstart + +Welcome to distrx! +----------------- + +distrx allows you to calculate uncertainty when you need to apply a function to your data, such as +the log function, as well as various other transformations + +For installing the package please check :ref:`Installing distrx`. +For a simple example please check :ref:`Quickstart`. \ No newline at end of file diff --git a/docs/getting_started/installation.rst b/docs/getting_started/installation.rst new file mode 100644 index 0000000..617c4c3 --- /dev/null +++ b/docs/getting_started/installation.rst @@ -0,0 +1,27 @@ +================ +Installing distrx +================ + +Python version +-------------- + +The package :code:`distrx` is written in Python +and requires Python 3.12 or later. + +:code:`distrx` package is distributed at +.. `PyPI `_. +TBD +To install the package: + +.. code:: + + pip install distrx + +For developers, you can clone the repository and install the package in the +development mode. + +.. code:: + + git clone https://github.com/ihmeuw-msca/distrx.git + cd distrx + pip install -e ".[test,docs]" \ No newline at end of file diff --git a/docs/getting_started/quickstart.rst b/docs/getting_started/quickstart.rst new file mode 100644 index 0000000..df1d81e --- /dev/null +++ b/docs/getting_started/quickstart.rst @@ -0,0 +1,18 @@ +========== +Quickstart +========== + +Example +------- + +.. code-block:: python + + from distrx.transforms import distrx.transform_data + + mu = [1, 2, 3] + sigma = [0.2, 0.4, 0.6] + transform = "log" + method = "delta" + mu_transformed, sigma_transformed = transform_data(mu, sigma, transform, method) + assert mu_transformed = [0, 0.69, 1.1] + assert sigma_transformed = [0.2, 0.2, 0.2] diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..e7cbb8c --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,41 @@ +distrx documentation +=================== + +.. toctree:: + :hidden: + + getting_started/index + user_guide/index + api_reference/index + developer_guide/index + +Statistics like variance and SE (standard error) are a measure of spread in data. +When shifting all of your data up or down (i.e. adding and subtracting a constant from your data), +you need not worry about tinkering with the variance or SE calculations. +However, when applying a nonlinear transformation to data (e.g. a log transform), +one’s intuition may be to simply apply the same function to the resulting statistics. +While this might work for things like the sample mean, +but doing this for SE will produce completely incorrect uncertainty estimates. +The distrx package aims to provide functions based in sound statistical theory +to allow users to apply common transformation functions in the health sciences field +to produce transformations and maintain correct uncertainty estimates. + +.. list-table:: + :header-rows: 1 + :widths: 50 50 + + * - :ref:`Getting started` + - :ref:`User guide` + + * - If you are new to distrx, this is where you should go. It contains main use cases and examples to help you get started. + - The user guide provides in-depth information on key concepts of data transformation with useful background information and explanation. + +.. list-table:: + :header-rows: 1 + :widths: 50 50 + + * - :ref:`API reference` + - :ref:`Developer guide` + + * - If you are looking for information on a specific module, function, class or method, this part of the documentation is for you. + - Want to improve the existing functionalities and documentation? The contributing guidelines will guide you through the process. diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..32bb245 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/meta.toml b/docs/meta.toml new file mode 100644 index 0000000..c7c4f3a --- /dev/null +++ b/docs/meta.toml @@ -0,0 +1,3 @@ +versions = [ + "0.1.0", +] \ No newline at end of file diff --git a/docs/user_guide/index.rst b/docs/user_guide/index.rst new file mode 100644 index 0000000..3483dde --- /dev/null +++ b/docs/user_guide/index.rst @@ -0,0 +1,22 @@ +User guide +========== + +.. toctree:: + :hidden: + :numbered: + + simple_transformations + percentage_change + +.. note:: + + Follow the titles in the sidebar for more information on the general type of transformation you + are performing on your data to use this user guide + + +This user guide introduces and explains some key concepts behind transforming data. A common pitfall +modelers fall into is to simply apply the transformation they are using for their data (e.g. log) to +their standard errors as well. However, due to the nature of standard error calculation, this +will provide completely incorrect standard errors. In order to compute the standard error of data +after functions have been applied, or when functions of multiple variables are involved, more +complex transformation methods such as those based on the delta method are required. \ No newline at end of file diff --git a/docs/user_guide/percentage_change.rst b/docs/user_guide/percentage_change.rst new file mode 100644 index 0000000..d57fd53 --- /dev/null +++ b/docs/user_guide/percentage_change.rst @@ -0,0 +1,51 @@ +========================= +Bivariate Transformations +========================= + +There are currently 2 bivariate transformations implemented in distrx: + * percentage change + * ratio + +These transformations are implemented using the first order delta method. See INSERT CONCEPTS for +derivation if desired. Note that all functions are in terms of sample statistics (e.g. mean), not +raw counts, even though some functions do take counts as input. + +Example: Percentage Change +-------------------------- + +Suppose we have samples in 2 different years measuring the incidence of cancer cases in each year +in various state counties. The data may look something like the following, + +.. csv-table:: + :header: county, cases_1, sample_1, cases_2, sample_2 + :widths: 10, 10, 10, 10, 10 + :align: center + + "King", 252, 400, 258, 250 + "Snohomish", 12, 300, 90, 500 + "Pierce", 505, 1000, 219, 1000 + "Kitsap", 88, 124, 67, 204 + +and our goal is to find the percentage change in the prevalence of cancer with its appropriate SE. + +The first step is to import the required function from the distrx package. + +.. code-block:: python + + from distrx import transform_bivariate + +Different transformation functions can be chosen through specifying a string parameter of which +transform you would like to apply to your data. In this case, it is the following. + +.. code-block:: python + + mu_tx, sigma_tx = transform_bivariate(c_x=df["cases_1"], + n_x=df["sample_1"], + c_y=df["cases_2"], + n_y=df["sample_2"], + transform="percentage_change") + +``mu_tx`` and ``sigma_tx`` are simply the percentage change for each county and their corresponding +standard errors, respectively. ``sigma_tx`` has already been scaled the appropriate sample size so +we **should not** scale it additionally with some function of othe sample size to obtain a +confidence interval. diff --git a/docs/user_guide/simple_transformations.rst b/docs/user_guide/simple_transformations.rst new file mode 100644 index 0000000..2430373 --- /dev/null +++ b/docs/user_guide/simple_transformations.rst @@ -0,0 +1,53 @@ +========================== +Univariate Transformations +========================== + +There are currently 4 univariate transformations implemented in distrx: + * log + * logit + * exp + * expit + +These transformations are implemented using the first order delta method, which works in these +cases as all of the transformations listed are continuous and differentiable. To briefly summarize, +the delta method transforms the variance by multiplying the original standard error by the first +order Taylor expansion of the transformation function. + +Example: Log Transform +---------------------- + +Suppose that we have some means and standard errors (SEs) of systolic blood pressure (SBP) from +several different samples. The data may look something like the following, + +.. csv-table:: + :header: mean, se, n + :widths: 10, 10, 10 + :align: center + + 122, 10, 106 + 140, 14, 235 + 113, 8, 462 + 124, 15, 226 + 134, 7, 509 + +and our goal is to obtain the appropriate SEs for the data after applying the log transform. + +The first step is to import the required function from the distrx package. + +.. code-block:: python + + from distrx import transform_univariate + +Different transformation functions can be chosen through specifying a string parameter of which +transform you would like to apply to your data. In this case, it is the following. + +.. code-block:: python + + mu_tx, sigma_tx = transform_univariate(mu=df["means"], + sigma=df["se"], + n=df["n"], + transform="log") + +``mu_tx`` and ``sigma_tx`` are simply the means with the transformation function applied and their +corresponding standard errors, respectively. ``sigma_tx`` has already been scaled by :math:`\sqrt{n}` +so the we **should not** scale it by square root of the sample size to obtain a confidence interval. \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..ce54cee --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,27 @@ +[build-system] +requires = ["setuptools"] +build-backend = "setuptools.build_meta" + +[project] +name = "distrx" +version = "0.1.0" +description = "Python package template" +readme = "README.md" +requires-python = ">=3.12" +license = { text = "BSD-2-Clause" } +authors = [ + { name = "IHME Math Sciences", email = "ihme.math.sciences@gmail.com" }, +] +classifiers = [ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: BSD License", + "Natural Language :: English", +] +dependencies = ["typing", "numpy", "pandas", "msca"] + +[project.optional-dependencies] +test = ["pytest", "pytest-cov"] +docs = ["sphinx", "sphinx-autodoc-typehints", "furo"] + +[project.urls] +github = "https://github.com/ihmeuw-msca/distrx" \ No newline at end of file diff --git a/ruff.toml b/ruff.toml new file mode 100644 index 0000000..db4fdb4 --- /dev/null +++ b/ruff.toml @@ -0,0 +1,8 @@ +line-length = 80 +src = ["src"] + +[format] +docstring-code-format = true + +[lint.pydocstyle] +convention = "numpy" diff --git a/setup.py b/setup.py deleted file mode 100644 index d3a9cb6..0000000 --- a/setup.py +++ /dev/null @@ -1,51 +0,0 @@ -import sys -from pathlib import Path -from setuptools import setup, find_packages - - -if __name__ == '__main__': - base_dir = Path(__file__).parent - src_dir = base_dir/'src'/'distrx' - - sys.path.insert(0, src_dir.as_posix()) - import __about__ as about - - with (base_dir/'README.md').open() as f: - long_description = f.read() - - install_requirements = [ - 'numpy', - 'pandas', - 'scipy', - ] - - test_requirements = [ - 'pytest', - 'pytest-mock', - ] - - doc_requirements = [] - - setup(name=about.__title__, - version=about.__version__, - - description=about.__summary__, - long_description=long_description, - license=about.__license__, - url=about.__uri__, - - author=about.__author__, - author_email=about.__email__, - - package_dir={'': 'src'}, - packages=find_packages(where='src'), - include_package_data=True, - - install_requires=install_requirements, - tests_require=test_requirements, - extras_require={ - 'docs': doc_requirements, - 'test': test_requirements, - 'dev': doc_requirements + test_requirements - }, - zip_safe=False,) diff --git a/simulations.ipynb b/simulations.ipynb new file mode 100644 index 0000000..4bb7c83 --- /dev/null +++ b/simulations.ipynb @@ -0,0 +1,649 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n", + "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from distrx.transforms import (\n", + " transform_univariate,\n", + " transform_bivariate\n", + ")\n", + "NREP = 1000\n", + "Q = 1.96\n", + "TRANSFORM_DICT = {\n", + " \"log\": np.log,\n", + " \"exp\": np.exp,\n", + " \"logit\": lambda x: np.log(x / (1 - x)),\n", + " \"expit\": lambda x: np.exp(x) / (1 + np.exp(x))\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# helper functions\n", + "def simulate(distribution_func, transform_func, original_mean, sample_size=100, **distribution_params):\n", + " # calculate true transformed mean and initialize arrays to store results\n", + " truth = TRANSFORM_DICT[transform_func](original_mean)\n", + " coverages = np.zeros(NREP)\n", + " mu_txs = np.zeros(NREP)\n", + " ci_uppers = np.zeros(NREP)\n", + " ci_lowers = np.zeros(NREP)\n", + "\n", + " for i in range(NREP):\n", + " # generate data from given distribution, calculate sample_mean, sample_sd\n", + " data = distribution_func(size=sample_size, **distribution_params)\n", + " x_bar = np.mean(data)\n", + " sigma_hat = np.std(data)\n", + "\n", + " # run delta method transformation for transformed_mean and transformed_sd\n", + " mu_txs[i], sigma_tx = transform_univariate(x_bar, sigma_hat, transform_func, \"delta\")\n", + "\n", + " # calculate CI bounds with transformed_mean + Q * transformed_sd / sqrt(sample_size)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_tx / np.sqrt(sample_size)\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_tx / np.sqrt(sample_size)\n", + "\n", + " # indicate coverage success when transformed mean lies between CI bounds as described above\n", + " if (ci_lowers[i] < truth and truth < ci_uppers[i]):\n", + " coverages[i] = 1\n", + "\n", + " return (coverages, mu_txs, ci_uppers, ci_lowers, (coverages == 1).sum() / NREP)\n", + "\n", + "\n", + "def plot_simulation(coverages: np.ndarray, mu_txs: np.ndarray, ci_lowers: np.ndarray, ci_uppers: np.ndarray,\n", + " truth: float, transform: str, line_width=0.75, cap_size=2, marker_size=3, fig_size=(17, 6)):\n", + " \"\"\"\n", + " creates plot of CI coverage simulation\n", + " \"\"\"\n", + " plt.figure(figsize=fig_size)\n", + " for i in range(NREP):\n", + " if coverages[i] == 1:\n", + " plt.errorbar(i, mu_txs[i], elinewidth=line_width,\n", + " yerr=[[mu_txs[i]- ci_lowers[i]], [ci_uppers[i] - mu_txs[i]]],\n", + " fmt=\"o\", color=\"blue\", ecolor=\"blue\", capsize=cap_size, markersize=marker_size)\n", + " else:\n", + " plt.errorbar(i, mu_txs[i], elinewidth=line_width,\n", + " yerr=[[mu_txs[i] - ci_lowers[i]], [ci_uppers[i] - mu_txs[i]]],\n", + " fmt=\"o\", color=\"red\", ecolor=\"red\", capsize=cap_size, markersize=marker_size)\n", + "\n", + " plt.axhline(y=TRANSFORM_DICT[transform](truth), color='gray', linestyle='--')\n", + " plt.xlabel(\"replication no.\")\n", + " plt.ylabel(\"Mean\")\n", + " plt.title(\"95% CIs using Delta Method SE for \" + transform + \" transform\")\n", + " plt.legend([\"True Mean\"], loc=\"upper right\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Univariate Simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.945\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# log transformation w/N(5, 1)\n", + "orig_mean = 5\n", + "orig_sd = 1\n", + "transform = \"log\"\n", + "\n", + "coverages, mu_txs, ci_uppers, ci_lowers, coverage_pct = simulate(distribution_func=np.random.normal,\n", + " transform_func=transform,\n", + " original_mean=orig_mean,\n", + " loc=orig_mean,\n", + " scale=orig_sd)\n", + "\n", + "print(coverage_pct)\n", + "\n", + "# plotting\n", + "plot_simulation(coverages, mu_txs, ci_lowers, ci_uppers, orig_mean, transform)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.93\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# exp transformation w/Unif(-2, 9)\n", + "orig_lb = -2\n", + "orig_ub = 9\n", + "orig_mean = (orig_ub + orig_lb) / 2\n", + "transform = \"exp\"\n", + "\n", + "coverages, mu_txs, ci_uppers, ci_lowers, coverage_pct = simulate(distribution_func=np.random.uniform,\n", + " transform_func=transform,\n", + " original_mean=orig_mean,\n", + " low=orig_lb,\n", + " high=orig_ub)\n", + "\n", + "print(coverage_pct)\n", + "\n", + "# plotting\n", + "plot_simulation(coverages, mu_txs, ci_lowers, ci_uppers, orig_mean, transform)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.951\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# logit transformation w/Unif(0, 1)\n", + "orig_lb = 0\n", + "orig_ub = 1\n", + "orig_mean = (orig_ub + orig_lb) / 2\n", + "transform = \"logit\"\n", + "\n", + "coverages, mu_txs, ci_uppers, ci_lowers, coverage_pct = simulate(distribution_func=np.random.uniform,\n", + " transform_func=transform,\n", + " original_mean=orig_mean,\n", + " low=orig_lb,\n", + " high=orig_ub)\n", + "\n", + "print(coverage_pct)\n", + "\n", + "# plotting\n", + "plot_simulation(coverages, mu_txs, ci_lowers, ci_uppers, orig_mean, transform)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.913\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# logit transformation w/Gumbel(-5.7, 3.11)\n", + "orig_loc = -5.7\n", + "orig_scale = 3.11\n", + "orig_mean = orig_loc + orig_scale * np.euler_gamma\n", + "transform = \"expit\"\n", + "\n", + "coverages, mu_txs, ci_uppers, ci_lowers, coverage_pct = simulate(distribution_func=np.random.gumbel,\n", + " transform_func=transform,\n", + " original_mean=orig_mean,\n", + " loc=orig_loc,\n", + " scale=orig_scale)\n", + "\n", + "print(coverage_pct)\n", + "\n", + "# plotting\n", + "plot_simulation(coverages, mu_txs, ci_lowers, ci_uppers, orig_mean, transform)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bivariate Simulations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Percentage Change\n", + "* the function that currently works as intended calculates percentage change in prevalence rates\n", + " * note: prevalence is analogous to mean, just with binary data\n", + "* the function that simply calculates percentage change in counts does not currently work\n", + " * in my experience, the RV is a function of consistent estimators, counts don't fall into that category\n", + " * not completely certain that the above *must* be the case, perhaps just computing variance incorrectly?\n", + " * tried both the formula in our overleaf and simply $np(1 - p)$ for variance" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True percentage change in proportions: 9.333333333333336\n", + "10 replications of incidence counts in year 1: [35 29 37 29 31 23 37 30 28]\n" + ] + } + ], + "source": [ + "# parameters for population sizes and prevalence\n", + "Y1_POP, Y1_PREV = 1000, 0.03\n", + "Y2_POP, Y2_PREV = Y1_POP + 3000, (Y1_PREV + 0.28)\n", + "\n", + "# simulate incidence from 2 years w/differing aforementioned parameters\n", + "y1_incid = np.random.binomial(Y1_POP, Y1_PREV, size=NREP)\n", + "y2_incid = np.random.binomial(Y2_POP, Y2_PREV, size=NREP)\n", + "\n", + "# y1_incid = np.random.poisson(300, size=NREP)\n", + "# y2_incid = np.random.poisson(350, size=NREP)\n", + "\n", + "# true difference in prevalence\n", + "TRUE_DIFF = (Y2_PREV / Y1_PREV) - 1\n", + "# TRUE_DIFF = (350 / 300) - 1\n", + "print(\"True percentage change in proportions: \", TRUE_DIFF)\n", + "print(\"10 replications of incidence counts in year 1: \", y1_incid[0:9])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Coverage" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'transform_percentage_change' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 7\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# TODO: try to incorporate this into the testing suite\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# print(np.var(y1_incid, ddof=1))\u001b[39;00m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NREP):\n\u001b[0;32m----> 7\u001b[0m mu_txs[i], sigma_hat \u001b[38;5;241m=\u001b[39m \u001b[43mtransform_percentage_change\u001b[49m(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n\u001b[1;32m 8\u001b[0m ci_uppers[i] \u001b[38;5;241m=\u001b[39m mu_txs[i] \u001b[38;5;241m+\u001b[39m Q \u001b[38;5;241m*\u001b[39m sigma_hat\n\u001b[1;32m 9\u001b[0m ci_lowers[i] \u001b[38;5;241m=\u001b[39m mu_txs[i] \u001b[38;5;241m-\u001b[39m Q \u001b[38;5;241m*\u001b[39m sigma_hat\n", + "\u001b[0;31mNameError\u001b[0m: name 'transform_percentage_change' is not defined" + ] + } + ], + "source": [ + "# TODO: document coverage with graphs in the tails\n", + "coverages, mu_txs, ci_uppers, ci_lowers = np.zeros(NREP), np.zeros(NREP), np.zeros(NREP), np.zeros(NREP)\n", + "\n", + "# TODO: try to incorporate this into the testing suite\n", + "# print(np.var(y1_incid, ddof=1))\n", + "for i in range(NREP):\n", + " mu_txs[i], sigma_hat = transform_percentage_change(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_hat\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_hat\n", + " if (ci_lowers[i] < TRUE_DIFF and TRUE_DIFF < ci_uppers[i]):\n", + " coverages[i] = 1\n", + "\n", + "coverage_pct = (coverages == 1).sum() / NREP\n", + "print(\"CI coverage rate: \", coverage_pct)\n", + "\n", + "plot_simulation(coverages, mu_txs, ci_lowers, ci_uppers, TRUE_DIFF, \"percent change transform\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It seems as though the CI length is wider than it should be at more extreme values of prevalence (i.e. those near 0 or 1). This is probably due to the fact that when computing the CI, the standard error was divided by the sample size of the first year. Unclear as to what it should be instead, any suggestions?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Coverage over varying true prevalence" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/813324598.py:13: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " mu_txs[i], sigma_hat = transform_percentage_change(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n", + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/813324598.py:14: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_hat\n", + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/813324598.py:15: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_hat\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.01 0.06 0.11 0.16 0.21 0.26 0.31 0.36 0.41 0.46 0.51 0.56 0.61 0.66\n", + " 0.71 0.76 0.81 0.86 0.91 0.96] [0.941, 0.95, 0.959, 0.941, 0.943, 0.945, 0.955, 0.95, 0.94, 0.943, 0.949, 0.944, 0.952, 0.956, 0.934, 0.945, 0.949, 0.948, 0.953, 0.952]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y1_prevalences = np.arange(0.01, 1, 0.05)\n", + "all_coverages = []\n", + "\n", + "for y1_prev in y1_prevalences:\n", + " coverages, mu_txs, ci_uppers, ci_lowers = np.zeros(NREP), np.zeros(NREP), np.zeros(NREP), np.zeros(NREP)\n", + " Y1_POP, Y1_PREV = 1000, y1_prev\n", + " Y2_POP, Y2_PREV = 1000, (Y1_PREV + 0.02)\n", + " TRUE_DIFF = (Y2_PREV / Y1_PREV) - 1\n", + "\n", + " y1_incid = np.random.binomial(Y1_POP, Y1_PREV, size=NREP)\n", + " y2_incid = np.random.binomial(Y2_POP, Y2_PREV, size=NREP)\n", + " for i in range(NREP):\n", + " mu_txs[i], sigma_hat = transform_percentage_change(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_hat\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_hat\n", + " if (ci_lowers[i] < TRUE_DIFF and TRUE_DIFF < ci_uppers[i]):\n", + " coverages[i] = 1\n", + " all_coverages.append((coverages == 1).sum() / NREP)\n", + "\n", + "print(y1_prevalences, all_coverages)\n", + "plt.xlabel(\"prevalence in group X\")\n", + "plt.ylabel(\"coverage percentage\")\n", + "plt.title(\"coverage vs prevalence in group X\")\n", + "plt.scatter(y1_prevalences, all_coverages)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Coverage over varying true delta" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.09 0.01 0.11 0.21 0.31 0.41 0.51 0.61 0.71 0.81]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/3508961853.py:14: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " mu_txs[i], sigma_hat = transform_percentage_change(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n", + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/3508961853.py:15: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_hat\n", + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/3508961853.py:16: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_hat\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.9 0.1 1.1 2.1 3.1 4.1 5.1 6.1 7.1 8.1] [0.925, 0.937, 0.957, 0.947, 0.946, 0.942, 0.949, 0.944, 0.952, 0.952]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y2_prevalence_incs = np.arange(-0.09, 0.9, 0.1)\n", + "print(y2_prevalence_incs)\n", + "all_coverages = []\n", + "\n", + "for y2_prev_inc in y2_prevalence_incs:\n", + " coverages, mu_txs, ci_uppers, ci_lowers = np.zeros(NREP), np.zeros(NREP), np.zeros(NREP), np.zeros(NREP)\n", + " Y1_POP, Y1_PREV = 1000, 0.1\n", + " Y2_POP, Y2_PREV = 1000, (Y1_PREV + y2_prev_inc)\n", + " TRUE_DIFF = (Y2_PREV / Y1_PREV) - 1\n", + "\n", + " y1_incid = np.random.binomial(Y1_POP, Y1_PREV, size=NREP)\n", + " y2_incid = np.random.binomial(Y2_POP, Y2_PREV, size=NREP)\n", + " for i in range(NREP):\n", + " mu_txs[i], sigma_hat = transform_percentage_change(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_hat\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_hat\n", + " if (ci_lowers[i] < TRUE_DIFF and TRUE_DIFF < ci_uppers[i]):\n", + " coverages[i] = 1\n", + " all_coverages.append((coverages == 1).sum() / NREP)\n", + "\n", + "print(((0.1 + y2_prevalence_incs) / 0.1) - 1, all_coverages)\n", + "plt.xlabel(\"true delta\")\n", + "plt.ylabel(\"coverage percentage\")\n", + "plt.title(\"coverage vs true delta\")\n", + "plt.scatter(((0.1 + y2_prevalence_incs) / 0.1) - 1, all_coverages)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Coverage over varying difference in sample size" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/3515000061.py:15: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " mu_txs[i], sigma_hat = transform_percentage_change(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n", + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/3515000061.py:16: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_hat\n", + "/var/folders/55/53rfb8cd7bd3rvs9lvgv5zyw0000gn/T/ipykernel_28883/3515000061.py:17: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_hat\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.947, 0.945, 0.965, 0.955, 0.952, 0.951, 0.948, 0.956, 0.951, 0.96, 0.963, 0.961, 0.952, 0.944, 0.967, 0.949, 0.948, 0.951, 0.943, 0.949, 0.955]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# perhaps plot on a log scale?\n", + "# is it better to scale by the larger population?\n", + "y2_population_incs = np.arange(-500, 10000, 500)\n", + "all_coverages = []\n", + "\n", + "for y2_pop_inc in y2_population_incs:\n", + " coverages, mu_txs, ci_uppers, ci_lowers = np.zeros(NREP), np.zeros(NREP), np.zeros(NREP), np.zeros(NREP)\n", + " Y1_POP, Y1_PREV = 1000, 0.1\n", + " Y2_POP, Y2_PREV = Y1_POP + y2_pop_inc, 0.3\n", + " TRUE_DIFF = (Y2_PREV / Y1_PREV) - 1\n", + "\n", + " y1_incid = np.random.binomial(Y1_POP, Y1_PREV, size=NREP)\n", + " y2_incid = np.random.binomial(Y2_POP, Y2_PREV, size=NREP)\n", + " for i in range(NREP):\n", + " mu_txs[i], sigma_hat = transform_percentage_change(y1_incid[i], Y1_POP, y2_incid[i], Y2_POP)\n", + " ci_uppers[i] = mu_txs[i] + Q * sigma_hat\n", + " ci_lowers[i] = mu_txs[i] - Q * sigma_hat\n", + " if (ci_lowers[i] < TRUE_DIFF and TRUE_DIFF < ci_uppers[i]):\n", + " coverages[i] = 1\n", + " all_coverages.append((coverages == 1).sum() / NREP)\n", + "\n", + "print(all_coverages)\n", + "plt.xlabel(\"group Y population increase\")\n", + "plt.ylabel(\"coverage percentage\")\n", + "plt.title(\"coverage vs group Y population increase\")\n", + "plt.scatter(y2_population_incs, all_coverages)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Delta's distribution" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# maybe it's more interesting to plot the distribution of delta_hat - delta since that's what is normal by delta method/CLT\n", + "TRUE_DIFF = (Y2_PREV / Y1_PREV) - 1\n", + "y1_prevs = y1_incid / Y1_POP\n", + "y2_prevs = y2_incid / Y2_POP\n", + "plt.hist(((y2_prevs / y1_prevs) - 1) - TRUE_DIFF, bins=10, edgecolor=\"black\")\n", + "plt.xlabel(\"delta_hat - delta\")\n", + "plt.ylabel(\"count\")\n", + "plt.title(\"histogram of centered delta_hat statistic, prevalences: (\" + str(Y1_PREV) + \", \" + str(Y2_PREV) + \")\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ihme", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/distrx/__about__.py b/src/distrx/__about__.py deleted file mode 100644 index 682cd69..0000000 --- a/src/distrx/__about__.py +++ /dev/null @@ -1,16 +0,0 @@ -__all__ = [ - "__title__", "__summary__", "__uri__", "__version__", "__author__", - "__email__", "__license__", "__copyright__", -] - -__title__ = "distrx" -__summary__ = "Distribution transformation." -__uri__ = "https://github.com/ihmeuw-msca/distrx" - -__version__ = "0.0.0" - -__author__ = "IHME Math Sciences" -__email__ = "ihme.math.sciences@gmail.com" - -__license__ = "BSD 2-Clause License" -__copyright__ = f"Copyright 2021 {__author__}" \ No newline at end of file diff --git a/src/distrx/transforms.py b/src/distrx/transforms.py index bae43f0..63a129e 100644 --- a/src/distrx/transforms.py +++ b/src/distrx/transforms.py @@ -9,34 +9,227 @@ * Add decorators for accepting floats or vectors """ -from typing import Tuple + import warnings +from typing import Tuple import numpy as np import numpy.typing as npt +from msca.c2fun import c2fun_dict +METHOD_LIST = ["delta"] -TRANSFORM_DICT = { - 'log': [ - np.log, - lambda x: 1.0/x - ], 'logit': [ - lambda x: np.log(x/(1.0 - x)), - lambda x: 1.0/(x*(1.0 - x)) - ], 'exp': [ - np.exp, - np.exp - ], 'expit': [ - lambda x: 1.0/(1.0 + np.exp(-x)), - lambda x: np.exp(-x)/(1.0 + np.exp(-x))**2 - ] -} -METHOD_LIST = ['delta'] - - -def transform_data(mu: npt.ArrayLike, sigma: npt.ArrayLike, transform: str, - method: str = 'delta') -> Tuple[np.ndarray, np.ndarray]: - """Transform data from one space to another. + +class FirstOrder: + """ + Contains 4 most common 1st order delta method transformation functions + """ + + def __init__(self, transform: str) -> None: + """Initializes an object to perform 1st order delta method transformations + + Parameters + ---------- + transform : str + Function of choice + + Raises + ------ + ValueError + Is thrown function of choice not implemented + """ + self.transform = transform + + def __call__( + self, mu: npt.ArrayLike, sigma: npt.ArrayLike + ) -> Tuple[np.ndarray, np.ndarray]: + match self.transform: + case "log": + return self.log_trans(mu, sigma) + case "logit": + return self.logit_trans(mu, sigma) + case "exp": + return self.exp_trans(mu, sigma) + case "expit": + return self.expit_trans(mu, sigma) + case _: + raise ValueError(f"Invalid transform '{self.transform}'.") + + def log_trans( + self, mu: npt.ArrayLike, sigma: npt.ArrayLike + ) -> Tuple[np.ndarray, np.ndarray]: + """Performs delta method on data under log transform + + .. math:: + + \\log(mu), \\frac{\\sigma}{\\mu} + + Parameters + ---------- + mu : npt.ArrayLike + Sample statistics + sigma : npt.ArrayLike + Standard errors + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Transformed mean and standard error + """ + log = c2fun_dict["log"] + return log(mu), sigma * log(mu, order=1) + + def logit_trans( + self, mu: npt.ArrayLike, sigma: npt.ArrayLike + ) -> Tuple[np.ndarray, np.ndarray]: + """Performs delta method on data under logit transform + + .. math:: + + \\log(\\frac{\\mu}{1 - \\mu}), \\frac{\\sigma}{\\mu \\cdot (1 - \\mu)} + + Parameters + ---------- + mu : npt.ArrayLike + Sample statistics + sigma : npt.ArrayLike + Standard errors + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Transformed mean and standard error + """ + logit = c2fun_dict["logit"] + return logit(mu), sigma * logit(mu, order=1) + + def exp_trans( + self, mu: npt.ArrayLike, sigma: npt.ArrayLike + ) -> Tuple[np.ndarray, np.ndarray]: + """Performs delta method on data under exponential transform + + .. math:: + + \\exp(\\mu), \\sigma \\cdot \\exp(\\mu) + + Parameters + ---------- + mu : npt.ArrayLike + Sample statistics + sigma : npt.ArrayLike + Standard errors + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Transformed mean and standard error + """ + exp = c2fun_dict["exp"] + return exp(mu), sigma * exp(mu, order=1) + + def expit_trans( + self, mu: npt.ArrayLike, sigma: npt.ArrayLike + ) -> Tuple[np.ndarray, np.ndarray]: + """Performs delta method on data under expit transform + + .. math:: + + \\frac{1}{1 + \\exp(-\\mu)}, \\sigma \\cdot \\frac{\\exp(\\mu)}{(1 + \\exp(\\mu))^2} + + Parameters + ---------- + mu : npt.ArrayLike + Sample statistics + sigma : npt.ArrayLike + Standard errors + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Transformed mean and standard error + """ + expit = c2fun_dict["expit"] + return expit(mu), sigma * expit(mu, order=1) + + +class FirstOrderBivariate: + def __init__(self, transform: str) -> None: + """Initializes an object to perform 1st order delta method transformations + + Parameters + ---------- + transform : str + Function of choice + + Raises + ------ + ValueError + Is thrown function of choice not implemented + """ + self.transform = transform + + def __call__( + self, + c_x: npt.ArrayLike, + n_x: npt.ArrayLike, + c_y: npt.ArrayLike, + n_y: npt.ArrayLike, + ) -> Tuple[np.ndarray, np.ndarray]: + match self.transform: + case "percentage_change": + return self.percentage_change_trans(c_x, n_x, c_y, n_y) + case _: + raise ValueError(f"Invalid transform '{self.transform}'.") + + def percentage_change_trans( + self, + c_x: npt.ArrayLike, + n_x: npt.ArrayLike, + c_y: npt.ArrayLike, + n_y: npt.ArrayLike, + ) -> Tuple[np.ndarray, np.ndarray]: + """percentage change variance transformation for incidence data + + .. math:: + + \\frac{p_y}{p_x} - 1, \\sqrt{\\frac{\\sigma_y^2}{n_y\\mu_x^2} + \\frac{\\mu_y^2\\sigma_x^2}{n_x\\mu_x^4}} + + Parameters + ---------- + c_x : npt.ArrayLike + incidence counts in first sample + n_x : npt.ArrayLike + sample sizes of first sample + c_y : npt.ArrayLike + incidence counts in second sample + n_y : npt.ArrayLike + sample sizes of second sample + + Returns + ------- + (delta_hat, sigma_tx) + sample percentage change of prevalence and corresponding transformed standard error + """ + + mu_x = c_x / n_x + mu_y = c_y / n_y + sigma2_x = (c_x * (1 - mu_x) ** 2 + (n_x - c_x) * mu_x**2) / (n_x - 1) + sigma2_y = (c_y * (1 - mu_y) ** 2 + (n_y - c_y) * mu_y**2) / (n_y - 1) + + sigma2_tx = (sigma2_y / (n_y * mu_x**2)) + ( + mu_y**2 * sigma2_x / (n_x * mu_x**4) + ) + + return ((mu_y / mu_x) - 1), np.sqrt(sigma2_tx) + + +def transform_univariate( + mu: npt.ArrayLike, + sigma: npt.ArrayLike, + transform: str, + method: str = "delta", +) -> Tuple[np.ndarray, np.ndarray]: + """Transform univariate data from one space to another. Transform data, in the form of sample statistics and their standard errors, from one space to another using a given transform function. @@ -51,7 +244,7 @@ def transform_data(mu: npt.ArrayLike, sigma: npt.ArrayLike, transform: str, Standard errors. transform : {'log', 'logit', 'exp', 'expit'} Transform function. - method : {'delta'}, optional + method : {'delta'} Method used to transform data. Returns @@ -62,53 +255,115 @@ def transform_data(mu: npt.ArrayLike, sigma: npt.ArrayLike, transform: str, Standard errors in the transform space. """ - mu, sigma = np.array(mu), np.array(sigma) - _check_input(method, transform, mu, sigma) - if method == 'delta': - return delta_method(mu, sigma, transform) - - -def delta_method(mu: npt.ArrayLike, sigma: npt.ArrayLike, transform: str) -> \ - Tuple[np.ndarray, np.ndarray]: - """Transform data using the delta method. - Transform data, in the form of sample statistics and their standard - errors, from one space to another using a given transform function - and the delta method. No assumptions are made about the underlying - distributions of the given data. + mu, sigma = np.array(mu), np.array(sigma) + _check_input(mu, sigma) + match method: + case "delta": + transformer = FirstOrder(transform) + return transformer(mu, sigma) + case _: + raise ValueError(f"Invalid method '{method}'.") + + +def transform_bivariate( + c_x: npt.ArrayLike, + n_x: npt.ArrayLike, + c_y: npt.ArrayLike, + n_y: npt.ArrayLike, + transform: str, + method: str = "delta", +) -> Tuple[np.ndarray, np.ndarray]: + """Transform bivariate data to a univariate space + + Transform data, in the form of counts and sample size from 2 groups, + to point estimates and appropriate standard errors using a given transform + function. No assumptions are made about the underlying distributions of + the data. Parameters ---------- - mu : array_like - Sample statistics. - sigma : array_like - Standard errors. - transform : {'log', 'logit', 'exp', 'expit'} - Transform function. + c_x : npt.ArrayLike + _description_ + n_x : npt.ArrayLike + _description_ + c_y : npt.ArrayLike + _description_ + n_y : npt.ArrayLike + _description_ + transform : str + _description_ + method : str, optional + _description_, by default "delta" Returns ------- - mu_trans : numpy.ndarray - Sample statistics in the transform space. - sigma_trans : numpy.ndarray - Standard errors in the transform space. - - Notes - ----- - The delta method expands a function of a random variable about its - mean with a one-step Taylor approximation and then takes the - variance. + Tuple[np.ndarray, np.ndarray] + _description_ + Raises + ------ + ValueError + _description_ """ - mu, sigma = np.array(mu), np.array(sigma) - _check_input('delta', transform, mu, sigma) - mu_trans = TRANSFORM_DICT[transform][0](mu) - sigma_trans = sigma*TRANSFORM_DICT[transform][1](mu) - return mu_trans, sigma_trans - -def _check_input(method: str, transform: str, mu: npt.ArrayLike, - sigma: npt.ArrayLike) -> None: + c_x, n_x, c_y, n_y = ( + np.array(c_x), + np.array(n_x), + np.array(c_y), + np.array(n_y), + ) + match method: + case "delta": + transformer = FirstOrderBivariate(transform) + return transformer(c_x, n_x, c_y, n_y) + case _: + raise ValueError(f"Invalid method '{method}'.") + + +# def transform_percentage_change_experiment( +# x_vec: npt.ArrayLike, y_vec: npt.ArrayLike +# ) -> Tuple[float, float]: +# """percentage change with transformed standard error + +# Parameters +# ---------- +# x_vec : array_like +# observations from first sample +# y_vec : array_like +# observations from second sample + +# Returns +# ------- +# p_hat : float +# bias corrected percentage change +# sigma_trans : float +# standard error in the transformed space + +# Raises +# ------ +# ValueError +# covariance is not possible to calculate when x and y are different lengths +# """ +# if len(x_vec) != len(y_vec): +# raise ValueError("x_vec must be the same length as y_vec") + +# mu_x, mu_y = np.mean(x_vec), np.mean(y_vec) +# cov = np.cov(x_vec, y_vec) +# sigma2_x, sigma2_y, sigma_xy = cov[0, 0], cov[1, 1], cov[0, 1] + +# delta_hat = (mu_y - mu_x) / mu_x + +# sigma_trans = ( +# (sigma2_y / mu_x**2) +# - (2 * mu_y * sigma_xy / (mu_x**3)) +# + (mu_y**2 * sigma2_x / (mu_x**4)) +# ) + +# return delta_hat, np.sqrt(sigma_trans) + + +def _check_input(mu: npt.ArrayLike, sigma: npt.ArrayLike) -> None: """Run checks on input data. Parameters @@ -123,38 +378,10 @@ def _check_input(method: str, transform: str, mu: npt.ArrayLike, Standard errors. """ - _check_method_valid(method) - _check_transform_valid(transform) - _check_lengths_match(mu, sigma) + # _check_lengths_match(mu, sigma) _check_sigma_positive(sigma) -def _check_method_valid(method: str) -> None: - """Check that `method` is in METHOD_LIST. - - Parameters - ---------- - method : {'delta'} - Method used to transform data. - - """ - if method not in METHOD_LIST: - raise ValueError(f"Invalid method '{method}'.") - - -def _check_transform_valid(transform: str) -> None: - """Check that `transform` is in TRANSFORM_DICT. - - Parameters - ---------- - transform : {'log', 'logit', 'exp', 'expit'} - Transform function. - - """ - if transform not in TRANSFORM_DICT: - raise ValueError(f"Invalid transform '{transform}'.") - - def _check_lengths_match(mu: npt.ArrayLike, sigma: npt.ArrayLike) -> None: """Check that `mu` and `sigma` have the same lengths. diff --git a/tests/test_transforms.py b/tests/test_transforms.py index 0a84206..2caaaad 100644 --- a/tests/test_transforms.py +++ b/tests/test_transforms.py @@ -1,94 +1,135 @@ """Tests for transforms.py module.""" + import numpy as np +import pandas as pd import pytest -from distrx.transforms import transform_data, delta_method - - -TRANSFORM_DICT = { - 'log': [ - np.log, - lambda x: 1.0/x - ], 'logit': [ - lambda x: np.log(x/(1.0 - x)), - lambda x: 1.0/(x*(1.0 - x)) - ], 'exp': [ - np.exp, - np.exp - ], 'expit': [ - lambda x: 1.0/(1.0 + np.exp(-x)), - lambda x: np.exp(-x)/(1.0 + np.exp(-x))**2 - ] +from distrx.transforms import transform_bivariate, transform_univariate + +UNIVARIATE_TRANSFORM_DICT = { + "log": [np.log, lambda x: 1.0 / x], + "logit": [lambda x: np.log(x / (1.0 - x)), lambda x: 1.0 / (x * (1.0 - x))], + "exp": [np.exp, np.exp], + "expit": [ + lambda x: 1.0 / (1.0 + np.exp(-x)), + lambda x: np.exp(-x) / (1.0 + np.exp(-x)) ** 2, + ], } -TRANSFORM_LIST = list(TRANSFORM_DICT.keys()) -FUNCTION_LIST = [transform_data, delta_method] -VALS = [0.1]*2 +UNIVARIATE_TRANSFORM_LIST = list(UNIVARIATE_TRANSFORM_DICT.keys()) + +# BIVARIATE_TRANSFORM_DICT = { +# "percentage change": [np.] +# } +BIVARIATE_TRANSFORM_LIST = ["percentage_change"] +# FUNCTION_LIST = [transform_data, delta_method] +VALS = [0.1] * 2 +N = len(VALS) -@pytest.mark.parametrize('transform', TRANSFORM_LIST) +@pytest.mark.parametrize("transform", UNIVARIATE_TRANSFORM_LIST) def test_method_name_valid(transform): """Raise ValueError for invalue `method`.""" with pytest.raises(ValueError): - transform_data(VALS, VALS, transform, method='dummy') + transform_univariate(VALS, VALS, transform, method="dummy") -@pytest.mark.parametrize('function', FUNCTION_LIST) -@pytest.mark.parametrize('transform', TRANSFORM_LIST) -def test_input_len_match(function, transform): +@pytest.mark.parametrize("transform", UNIVARIATE_TRANSFORM_LIST) +def test_input_len_match(transform): """Raise ValueError if lengths of input vectors don't match.""" with pytest.raises(ValueError): - function(VALS, VALS*2, transform) + transform_univariate(VALS, VALS * 2, transform) -@pytest.mark.parametrize('function', FUNCTION_LIST) -@pytest.mark.parametrize('transform', TRANSFORM_LIST) -def test_sigma_negative(function, transform): +@pytest.mark.parametrize("transform", UNIVARIATE_TRANSFORM_LIST) +def test_sigma_negative(transform): """Raise ValueError if `sigma` contains negative values.""" vals = VALS + [-0.1] with pytest.raises(ValueError): - function(vals, vals, transform) + transform_univariate(vals, vals, transform) -@pytest.mark.parametrize('function', FUNCTION_LIST) -@pytest.mark.parametrize('transform', TRANSFORM_LIST) -def test_sigma_zero(function, transform): +@pytest.mark.parametrize("transform", UNIVARIATE_TRANSFORM_LIST) +def test_sigma_zero(transform): """Display warning if `sigma` contains zeros.""" vals = VALS + [0.0] with pytest.warns(UserWarning): - function(vals, vals, transform) + transform_univariate(vals, vals, transform) -@pytest.mark.parametrize('function', FUNCTION_LIST) -def test_transform_name_valid(function): +def test_transform_name_valid(): """Raise ValueError for invalid `transform`.""" with pytest.raises(ValueError): - function(VALS, VALS, 'dummy') + transform_univariate(VALS, VALS, N, "dummy") + transform_bivariate(VALS, VALS, VALS, VALS, "dummy") -@pytest.mark.parametrize('function', FUNCTION_LIST) -@pytest.mark.parametrize('transform', TRANSFORM_LIST) -def test_output_type(function, transform): +@pytest.mark.parametrize("transform", UNIVARIATE_TRANSFORM_LIST) +def test_output_type(transform): """Output should be numpy arrays.""" - mu, sigma = function(VALS, VALS, transform) + mu, sigma = transform_univariate(VALS, VALS, transform) assert isinstance(mu, np.ndarray) assert isinstance(sigma, np.ndarray) -@pytest.mark.parametrize('function', FUNCTION_LIST) -@pytest.mark.parametrize('transform', TRANSFORM_LIST) -def test_outout_len_match(function, transform): +@pytest.mark.parametrize("transform", UNIVARIATE_TRANSFORM_LIST) +def test_outout_len_match(transform): """Length of output vectors should match.""" - mu, sigma = function(VALS, VALS, transform) + mu, sigma = transform_univariate(VALS, VALS, transform) assert len(mu) == len(sigma) -@pytest.mark.parametrize('transform', TRANSFORM_LIST) +@pytest.mark.parametrize("transform", UNIVARIATE_TRANSFORM_LIST) def test_delta_result(transform): """Check expected results.""" mu = np.random.uniform(0.1, 1.0, size=10) sigma = np.random.uniform(0.1, 1.0, size=10) - mu_ref = TRANSFORM_DICT[transform][0](mu) - sigma_ref = sigma*TRANSFORM_DICT[transform][1](mu) - mu_trans, sigma_trans = delta_method(mu, sigma, transform) + mu_ref = UNIVARIATE_TRANSFORM_DICT[transform][0](mu) + sigma_ref = sigma * UNIVARIATE_TRANSFORM_DICT[transform][1](mu) + mu_trans, sigma_trans = transform_univariate(mu, sigma, transform) assert np.allclose(mu_trans, mu_ref) assert np.allclose(sigma_trans, sigma_ref) + + +# TODO: DEPRECATE +# def test_percentage_change(): +# x = np.random.normal(1, 0.1, 1000) +# y = np.random.normal(1.1, 0.1, 1000) +# z = np.random.normal(1, 0.1, 1001) +# p, sigma = transform_percentage_change_experiment(x, y) +# assert 0 < p and p < 1 +# assert 0 < sigma and sigma < 1 +# with pytest.raises(ValueError): +# transform_percentage_change_experiment(x, z) + + +def test_percentage_change_counts(): + x = np.random.choice([0, 1], size=1000, p=[0.1, 0.9]) + y = np.random.choice([0, 1], size=1100, p=[0.2, 0.8]) + mu, sigma = transform_bivariate( + (x == 1).sum(), len(x), (y == 1).sum(), len(y), "percentage_change" + ) + assert -1 <= mu and mu < np.inf + assert 0 < sigma and sigma < 1 + + +def test_percentage_change_input(): + # scalar input + c_x, n_x = 100, 1000 + c_y, n_y = 200, 1050 + # with pytest.raises(TypeError): + transform_bivariate(c_x, n_x, c_y, n_y, "percentage_change") + + # base list input + c_x = [100, 200] + n_x = [1000, 1000] + c_y = [300, 400] + n_y = [1050, 1050] + # with pytest.raises(TypeError): + transform_bivariate(c_x, n_x, c_y, n_y, "percentage_change") + + # dataframe input + df = pd.DataFrame({"c_x": c_x, "n_x": n_x, "c_y": c_y, "n_y": n_y}) + # with pytest.raises(TypeError): + transform_bivariate( + df["c_x"], df["n_x"], df["c_y"], df["n_y"], "percentage_change" + )