diff --git a/.pylintrc b/.pylintrc index a1ccb0e..616c20a 100644 --- a/.pylintrc +++ b/.pylintrc @@ -82,7 +82,7 @@ persistent=yes # Minimum Python version to use for version dependent checks. Will default to # the version used to run pylint. -py-version=3.7 +py-version=3.8 # Discover python modules and packages in the file system subtree. recursive=no diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 895d99f..e2a2939 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -9,10 +9,13 @@ If you would like to implement a new feature or a bug, please make sure you (or ### Creating a Pull Request 1. [Fork](https://github.com/cnellington/Contextualized/fork) this repository. -2. Make your code changes locally. -3. Check the style using pylint and black following [these steps](https://github.com/cnellington/Contextualized/pull/111#issue-1323230194). -4. (Optional) Include your name in alphabetical order in [ACKNOWLEDGEMENTS.md](https://github.com/cnellington/Contextualized/blob/main/ACKNOWLEDGEMENTS.md). -5. Issue a PR to merge your changes into the `dev` branch. +2. Install locally with `pip install -e .`. +3. Install extra developer dependencies with `pip install -r dev_requirements.txt`. +4. Make your code changes locally. +5. Automatically format your code and check for style issues by running `format_style.sh`. We are working on linting the entire repo, but please make sure your code is cleared by pylint. +6. Automatically update our documentation by running `update_docs.sh`. +7. (Optional) Include your name in alphabetical order in [ACKNOWLEDGEMENTS.md](https://github.com/cnellington/Contextualized/blob/main/ACKNOWLEDGEMENTS.md). +8. Issue a PR to merge your changes into the `main` branch. ## Issues diff --git a/README.md b/README.md index c38021c..98e7787 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -![Preview](contextualized_logo.png) +![Preview](docs/logo.png) # ![License](https://img.shields.io/github/license/cnellington/contextualized.svg?style=flat-square) @@ -10,7 +10,7 @@ Code style: black -A statistical machine learning toolbox for estimating models, distributions, and functions with context-specific parameters. +An easy-to-use machine learning toolbox for estimating models, distributions, and functions with context-specific parameters. Context-specific parameters: - Find hidden heterogeneity in data -- are all samples the same? @@ -66,13 +66,16 @@ Feel free to add your own page(s) by sending a PR or request an improvement by c -ContextualizedML was originally implemented by [Caleb Ellington](https://calebellington.com/) (CMU) and [Ben Lengerich](http://web.mit.edu/~blengeri/www) (MIT). +Contextualized ML was originally implemented by [Caleb Ellington](https://calebellington.com/) (CMU) and [Ben Lengerich](http://web.mit.edu/~blengeri/www) (MIT). Many people have helped. Check out [ACKNOWLEDGEMENTS.md](https://github.com/cnellington/Contextualized/blob/main/ACKNOWLEDGEMENTS.md)! ## Related Publications and Pre-prints +- [Contextualized Machine Learning](https://arxiv.org/abs/2310.11340) +- [Contextualized Networks Reveal Heterogeneous Transcriptomic Regulation in Tumors at Sample-Specific Resolution](https://www.biorxiv.org/content/10.1101/2023.12.01.569658v1) +- [Contextualized Policy Recovery: Modeling and Interpreting Medical Decisions with Adaptive Imitation Learning](https://arxiv.org/abs/2310.07918) - [Automated Interpretable Discovery of Heterogeneous Treatment Effectiveness: A COVID-19 Case Study](https://www.sciencedirect.com/science/article/pii/S1532046422001022) - [NOTMAD: Estimating Bayesian Networks with Sample-Specific Structures and Parameters](http://arxiv.org/abs/2111.01104) - [Discriminative Subtyping of Lung Cancers from Histopathology Images via Contextual Deep Learning](https://www.medrxiv.org/content/10.1101/2020.06.25.20140053v1.abstract) diff --git a/contextualized/analysis/__init__.py b/contextualized/analysis/__init__.py index b08ac8e..0812ce8 100644 --- a/contextualized/analysis/__init__.py +++ b/contextualized/analysis/__init__.py @@ -12,3 +12,8 @@ plot_homogeneous_predictor_effects, plot_heterogeneous_predictor_effects, ) +from contextualized.analysis.pvals import ( + calc_homogeneous_context_effects_pvals, + calc_homogeneous_predictor_effects_pvals, + calc_heterogeneous_predictor_effects_pvals, +) diff --git a/contextualized/analysis/accuracy_split.py b/contextualized/analysis/accuracy_split.py index 06e7cdd..8bdb5fc 100644 --- a/contextualized/analysis/accuracy_split.py +++ b/contextualized/analysis/accuracy_split.py @@ -1,8 +1,10 @@ """ Utilities for post-hoc analysis of trained Contextualized models. """ +from typing import * import numpy as np +import pandas as pd from sklearn.metrics import roc_auc_score as roc @@ -14,11 +16,25 @@ def get_roc(Y_true, Y_pred): return np.nan -def print_acc_by_covars(Y_true, Y_pred, covar_df, **kwargs): +def print_acc_by_covars( + Y_true: np.ndarray, Y_pred: np.ndarray, covar_df: pd.DataFrame, **kwargs +) -> None: """ Prints Accuracy for different data splits with covariates. - Assume Y_true and Y_pred are np arrays. - Allows train_idx and test_idx as Boolean locators. + + Args: + Y_true (np.ndarray): True labels. + Y_pred (np.ndarray): Predicted labels. + covar_df (pd.DataFrame): DataFrame of covariates. + max_classes (int, optional): Maximum number of classes to print. Defaults to 20. + covar_stds (np.ndarray, optional): Standard deviations of covariates. Defaults to None. + covar_means (np.ndarray, optional): Means of covariates. Defaults to None. + covar_encoders (List[LabelEncoder], optional): Encoders for covariates. Defaults to None. + train_idx (np.ndarray, optional): Boolean array indicating training data. Defaults to None. + test_idx (np.ndarray, optional): Boolean array indicating testing data. Defaults to None. + + Returns: + None """ Y_true = np.squeeze(Y_true) Y_pred = np.squeeze(Y_pred) diff --git a/contextualized/analysis/bootstraps.py b/contextualized/analysis/bootstraps.py index 6204fc9..a9e2eba 100644 --- a/contextualized/analysis/bootstraps.py +++ b/contextualized/analysis/bootstraps.py @@ -1,5 +1,6 @@ # Utility functions for bootstraps + def select_good_bootstraps(sklearn_wrapper, train_errs, tol=2, **kwargs): """ Select bootstraps that are good for a given model. @@ -19,5 +20,6 @@ def select_good_bootstraps(sklearn_wrapper, train_errs, tol=2, **kwargs): train_errs_by_bootstrap = np.mean(train_errs, axis=(1, 2)) sklearn_wrapper.models = sklearn_wrapper.models[ - train_errs_by_bootstrap < tol*np.min(train_errs_by_bootstrap)] + train_errs_by_bootstrap < tol * np.min(train_errs_by_bootstrap) + ] return sklearn_wrapper diff --git a/contextualized/analysis/effects.py b/contextualized/analysis/effects.py index 6c15769..0787b6e 100644 --- a/contextualized/analysis/effects.py +++ b/contextualized/analysis/effects.py @@ -1,21 +1,29 @@ """ Utilities for plotting effects learned by Contextualized models. """ - +from typing import * import numpy as np import matplotlib.pyplot as plt +from contextualized.easy.wrappers import SKLearnWrapper + def simple_plot( - x_vals, - y_vals, + x_vals: List[Union[float, int]], + y_vals: List[Union[float, int]], **kwargs, -): +) -> None: """ - Simple plotting of xs and ys with kwargs passed to mpl helpers. - :param x_vals: - :param y_vals: + Simple plotting of y vs x with kwargs passed to matplotlib helpers. + + Args: + x_vals: x values to plot + y_vals: y values to plot + **kwargs: kwargs passed to matplotlib helpers (fill_alpha, fill_color, y_lowers, y_uppers, x_label, y_label, x_ticks, x_ticklabels, y_ticks, y_ticklabels) + + Returns: + None """ plt.figure(figsize=kwargs.get("figsize", (8, 8))) if "y_lowers" in kwargs and "y_uppers" in kwargs: @@ -84,16 +92,25 @@ def plot_effect(x_vals, y_means, y_lowers=None, y_uppers=None, **kwargs): ) -def get_homogeneous_context_effects(model, C, **kwargs): +def get_homogeneous_context_effects( + model: SKLearnWrapper, C: np.ndarray, **kwargs +) -> Tuple[np.ndarray, np.ndarray]: """ Get the homogeneous (context-invariant) effects of context. - :param model: - :param C: - returns: - c_vis: the context values that were used to estimate the effects - effects: np array of effects, one for each context. Each homogeneous effect is a matrix of shape: - (n_bootstraps, n_context_vals, n_outcomes). + Args: + model (SKLearnWrapper): a fitted ``contextualized.easy`` model + C: the context values to use to estimate the effects + verbose (bool, optional): print progess. Default True. + individual_preds (bool, optional): whether to use plot each bootstrap. Default True. + C_vis (np.ndarray, optional): Context bins used to visualize context (n_vis, n_contexts). Default None to construct anew. + n_vis (int, optional): Number of bins to use to visualize context. Default 1000. + + Returns: + Tuple[np.ndarray, np.ndarray]: + c_vis: the context values that were used to estimate the effects + effects: array of effects, one for each context. Each homogeneous effect is a matrix of shape: + (n_bootstraps, n_context_vals, n_outcomes). """ if kwargs.get("verbose", True): print("Estimating Homogeneous Contextual Effects.") @@ -233,14 +250,32 @@ def plot_boolean_vars(names, y_mean, y_err, **kwargs): def plot_homogeneous_context_effects( - model, - C, + model: SKLearnWrapper, + C: np.ndarray, **kwargs, -): +) -> None: """ - Plot the homogeneous (context-invariant) effects of context. - :param model: - :param C: + Plot the direct effect of context on outcomes, disregarding other features. + This context effect is homogeneous in that it is a static function of context (context-invariant). + + Args: + model (SKLearnWrapper): a fitted ``contextualized.easy`` model + C: the context values to use to estimate the effects + verbose (bool, optional): print progess. Default True. + individual_preds (bool, optional): whether to use plot each bootstrap. Default True. + C_vis (np.ndarray, optional): Context bins used to visualize context (n_vis, n_contexts). Default None to construct anew. + n_vis (int, optional): Number of bins to use to visualize context. Default 1000. + lower_pct (int, optional): Lower percentile for bootstraps. Default 2.5. + upper_pct (int, optional): Upper percentile for bootstraps. Default 97.5. + classification (bool, optional): Whether to exponentiate the effects. Default True. + C_encoders (List[sklearn.preprocessing.LabelEncoder], optional): encoders for each context. Default None. + C_means (np.ndarray, optional): means for each context. Default None. + C_stds (np.ndarray, optional): standard deviations for each context. Default None. + xlabel_prefix (str, optional): prefix for x label. Default "". + figname (str, optional): name of figure to save. Default None. + + Returns: + None """ c_vis, effects = get_homogeneous_context_effects(model, C, **kwargs) # effects.shape is (n_context, n_bootstraps, n_context_vals, n_outcomes) @@ -283,16 +318,34 @@ def plot_homogeneous_context_effects( def plot_homogeneous_predictor_effects( - model, - C, - X, + model: SKLearnWrapper, + C: np.ndarray, + X: np.ndarray, **kwargs, -): +) -> None: """ - Plot the homogeneous (context-invariant) effects of predictors. - :param model: - :param C: - :param X: + Plot the effect of predictors on outcomes that do not change with context (homogeneous). + + Args: + model (SKLearnWrapper): a fitted ``contextualized.easy`` model + C: the context values to use to estimate the effects + X: the predictor values to use to estimate the effects + max_classes_for_discrete (int, optional): maximum number of classes to treat as discrete. Default 10. + min_effect_size (float, optional): minimum effect size to plot. Default 0.003. + ylabel (str, optional): y label for plot. Default "Influence of ". + xlabel_prefix (str, optional): prefix for x label. Default "". + X_names (List[str], optional): names of predictors. Default None. + X_encoders (List[sklearn.preprocessing.LabelEncoder], optional): encoders for each predictor. Default None. + X_means (np.ndarray, optional): means for each predictor. Default None. + X_stds (np.ndarray, optional): standard deviations for each predictor. Default None. + verbose (bool, optional): print progess. Default True. + lower_pct (int, optional): Lower percentile for bootstraps. Default 2.5. + upper_pct (int, optional): Upper percentile for bootstraps. Default 97.5. + classification (bool, optional): Whether to exponentiate the effects. Default True. + figname (str, optional): name of figure to save. Default None. + + Returns: + None """ c_vis = np.zeros_like(C.values) x_vis = make_grid_mat(X.values, 1000) @@ -355,19 +408,31 @@ def plot_homogeneous_predictor_effects( def plot_heterogeneous_predictor_effects(model, C, X, **kwargs): """ - Plot the heterogeneous (context-dependent) effects of context. - :param model: - :param C: - :param X: - :param encoders: - :param C_means: - :param C_stds: - :param X_names: - :param ylabel: (Default value = "Influence of ") - :param min_effect_size: (Default value = 0.003) - :param n_vis: (Default value = 1000) - :param max_classes_for_discrete: (Default value = 10) - + Plot how the effect of predictors on outcomes changes with context (heterogeneous). + + Args: + model (SKLearnWrapper): a fitted ``contextualized.easy`` model + C: the context values to use to estimate the effects + X: the predictor values to use to estimate the effects + max_classes_for_discrete (int, optional): maximum number of classes to treat as discrete. Default 10. + min_effect_size (float, optional): minimum effect size to plot. Default 0.003. + y_prefix (str, optional): y prefix for plot. Default "Influence of ". + X_names (List[str], optional): names of predictors. Default None. + verbose (bool, optional): print progess. Default True. + individual_preds (bool, optional): whether to use plot each bootstrap. Default True. + C_vis (np.ndarray, optional): Context bins used to visualize context (n_vis, n_contexts). Default None to construct anew. + n_vis (int, optional): Number of bins to use to visualize context. Default 1000. + lower_pct (int, optional): Lower percentile for bootstraps. Default 2.5. + upper_pct (int, optional): Upper percentile for bootstraps. Default 97.5. + classification (bool, optional): Whether to exponentiate the effects. Default True. + C_encoders (List[sklearn.preprocessing.LabelEncoder], optional): encoders for each context. Default None. + C_means (np.ndarray, optional): means for each context. Default None. + C_stds (np.ndarray, optional): standard deviations for each context. Default None. + xlabel_prefix (str, optional): prefix for x label. Default "". + figname (str, optional): name of figure to save. Default None. + + Returns: + None """ c_vis = maybe_make_c_vis(C, **kwargs) n_vis = c_vis.shape[0] diff --git a/contextualized/analysis/embeddings.py b/contextualized/analysis/embeddings.py index d21257c..9cb649b 100644 --- a/contextualized/analysis/embeddings.py +++ b/contextualized/analysis/embeddings.py @@ -1,9 +1,10 @@ """ Utilities for plotting embeddings of fitted Contextualized models. """ - +from typing import * import numpy as np +import pandas as pd import matplotlib.pyplot as plt import matplotlib as mpl @@ -11,16 +12,26 @@ def plot_embedding_for_all_covars( - reps, covars_df, covars_stds=None, covars_means=None, covars_encoders=None, **kwargs -): + reps: np.ndarray, + covars_df: pd.DataFrame, + covars_stds: np.ndarray = None, + covars_means: np.ndarray = None, + covars_encoders: List[Callable] = None, + **kwargs, +) -> None: """ Plot embeddings of representations for all covariates in a Pandas dataframe. - :param reps: - :param covars_df: - :param covars_stds: Used to project back to readable values. (Default value = None) - :param covars_means: Used to project back to readable values. (Default value = None) - :param covars_encoders: Used to project back to readable values. (Default value = None) - :param kwargs: Keyword arguments for plotting. + + Args: + reps (np.ndarray): Embeddings of shape (n_samples, n_dims). + covars_df (pd.DataFrame): DataFrame of covariates. + covars_stds (np.ndarray, optional): Standard deviations of covariates. Defaults to None. + covars_means (np.ndarray, optional): Means of covariates. Defaults to None. + covars_encoders (List[LabelEncoder], optional): Encoders for covariates. Defaults to None. + kwargs: Keyword arguments for plotting. + + Returns: + None """ for i, covar in enumerate(covars_df.columns): my_labels = covars_df.iloc[:, i].values @@ -49,17 +60,20 @@ def plot_embedding_for_all_covars( def plot_lowdim_rep( - low_dim, - labels, + low_dim: np.ndarray, + labels: np.ndarray, **kwargs, ): """ + Plot a low-dimensional representation of a dataset. - :param low_dim: - :param labels: - :param kwargs: - Keyword arguments. + Args: + low_dim (np.ndarray): Low-dimensional representation of shape (n_samples, 2). + labels (np.ndarray): Labels of shape (n_samples,). + kwargs: Keyword arguments for plotting. + Returns: + None """ if len(set(labels)) < kwargs.get("max_classes_for_discrete", 10): # discrete labels diff --git a/contextualized/analysis/pvals.py b/contextualized/analysis/pvals.py index e98efd0..c745199 100644 --- a/contextualized/analysis/pvals.py +++ b/contextualized/analysis/pvals.py @@ -2,6 +2,7 @@ Analysis tools for generating pvalues from bootstrap replicates. """ +from typing import * import numpy as np @@ -10,6 +11,7 @@ get_homogeneous_predictor_effects, get_heterogeneous_predictor_effects, ) +from contextualized.easy.wrappers import SKLearnWrapper def calc_pval_bootstraps_one_sided(estimates, thresh=0, laplace_smoothing=1): @@ -48,19 +50,19 @@ def calc_pval_bootstraps_one_sided_mean(estimates, laplace_smoothing=1): ) -def calc_homogeneous_context_effects_pvals(model, C, **kwargs): +def calc_homogeneous_context_effects_pvals( + model: SKLearnWrapper, C: np.ndarray, **kwargs +) -> np.ndarray: """ Calculate p-values for the effects of context. - Parameters - ---------- - model : contextualized.models.Model - C : np.ndarray + Args: + model (SKLearnWrapper): Model to analyze. + C (np.ndarray): Contexts to analyze. - Returns - ------- - pvals : np.ndarray of shape (n_contexts, n_outcomes) testing whether the - sign is consistent across bootstraps + Returns: + np.ndarray: P-values of shape (n_contexts, n_outcomes) testing whether the + sign of the direct effect of context on outcomes is consistent across bootstraps. """ _, effects = get_homogeneous_context_effects(model, C, **kwargs) # effects.shape: (n_contexts, n_bootstraps, n_context_vals, n_outcomes) @@ -86,19 +88,19 @@ def calc_homogeneous_context_effects_pvals(model, C, **kwargs): return pvals -def calc_homogeneous_predictor_effects_pvals(model, C, **kwargs): +def calc_homogeneous_predictor_effects_pvals( + model: SKLearnWrapper, C: np.ndarray, **kwargs +) -> np.ndarray: """ - Calculate p-values for the effects of predictors. + Calculate p-values for the context-invariant effects of predictors. - Parameters - ---------- - model : contextualized.models.Model - C : np.ndarray + Args: + model (SKLearnWrapper): Model to analyze. + C (np.ndarray): Contexts to analyze. - Returns - ------- - pvals : np.ndarray of shape (n_predictors, n_outcomes) testing whether the - sign is consistent across bootstraps + Returns: + np.ndarray: P-values of shape (n_predictors, n_outcomes) testing whether the + sign of the context-invariant predictor effects are consistent across bootstraps. """ _, effects = get_homogeneous_predictor_effects(model, C, **kwargs) # effects.shape: (n_predictors, n_bootstraps, n_outcomes) @@ -126,15 +128,13 @@ def calc_heterogeneous_predictor_effects_pvals(model, C, **kwargs): """ Calculate p-values for the heterogeneous effects of predictors. - Parameters - ---------- - model : contextualized.models.Model - C : np.ndarray + Args: + model (SKLearnWrapper): Model to analyze. + C (np.ndarray): Contexts to analyze. - Returns - ------- - pvals : np.ndarray of shape (n_contexts, n_predictors, n_outcomes) testing - whether the sign of the change wrt context is consistent across bootstraps + Returns: + np.ndarray: P-values of shape (n_contexts, n_predictors, n_outcomes) testing whether the + context-varying parameter range is consistent across bootstraps. """ _, effects = get_heterogeneous_predictor_effects(model, C, **kwargs) # effects.shape is (n_contexts, n_predictors, n_bootstraps, n_context_vals, n_outcomes) diff --git a/contextualized/analysis/utils.py b/contextualized/analysis/utils.py index e420e4b..439f590 100644 --- a/contextualized/analysis/utils.py +++ b/contextualized/analysis/utils.py @@ -2,16 +2,20 @@ Miscellaneous utility functions. """ +from typing import * + import numpy as np -def convert_to_one_hot(col): +def convert_to_one_hot(col: Collection[Any]) -> Tuple[np.ndarray, List[Any]]: """ + Converts a categorical variable to a one-hot vector. - :param col: np array with observations - - returns col converted to one-hot values, and list of one-hot values. + Args: + col (Collection[Any]): The categorical variable. + Returns: + Tuple[np.ndarray, List[Any]]: The one-hot vector and the possible values. """ vals = list(set(col)) one_hot_vars = np.array([vals.index(x) for x in col], dtype=np.float32) diff --git a/contextualized/dags/lightning_modules.py b/contextualized/dags/lightning_modules.py index 9bda98c..a6099dc 100644 --- a/contextualized/dags/lightning_modules.py +++ b/contextualized/dags/lightning_modules.py @@ -28,7 +28,12 @@ } DEFAULT_DAG_LOSS_TYPE = "NOTEARS" DEFAULT_DAG_LOSS_PARAMS = { - "NOTEARS": {"alpha": 1e-1, "rho": 1e-2, "tol": 0.25, "use_dynamic_alpha_rho": False}, + "NOTEARS": { + "alpha": 1e-1, + "rho": 1e-2, + "tol": 0.25, + "use_dynamic_alpha_rho": False, + }, "DAGMA": {"s": 1, "alpha": 1e0}, "poly": {}, } @@ -143,13 +148,14 @@ def __init__( # DAG regularizers self.ss_dag_params = sample_specific_loss_params["dag"].get( "params", - DEFAULT_DAG_LOSS_PARAMS[sample_specific_loss_params["dag"]["loss_type"]].copy(), + DEFAULT_DAG_LOSS_PARAMS[ + sample_specific_loss_params["dag"]["loss_type"] + ].copy(), ) - self.arch_dag_params = archetype_loss_params["dag"].get( - "params", - DEFAULT_DAG_LOSS_PARAMS[archetype_loss_params["dag"]["loss_type"]].copy() + "params", + DEFAULT_DAG_LOSS_PARAMS[archetype_loss_params["dag"]["loss_type"]].copy(), ) self.val_dag_loss_params = {"alpha": 1e0, "rho": 1e0} @@ -415,7 +421,8 @@ def _maybe_update_alpha_rho(self, epoch_dag_loss, dag_params): """ if ( dag_params.get("use_dynamic_alpha_rho", False) - and epoch_dag_loss > dag_params.get("tol", .25) * dag_params.get("h_old", 0) + and epoch_dag_loss + > dag_params.get("tol", 0.25) * dag_params.get("h_old", 0) and dag_params["alpha"] < 1e12 and dag_params["rho"] < 1e12 ): diff --git a/contextualized/easy/ContextualGAM.py b/contextualized/easy/ContextualGAM.py index 9b50bca..5ea6cda 100644 --- a/contextualized/easy/ContextualGAM.py +++ b/contextualized/easy/ContextualGAM.py @@ -9,7 +9,18 @@ class ContextualGAMClassifier(ContextualizedClassifier): """ - A GAM as context encoder with a classifier on top. + The Contextual GAM Classifier separates and interprets the effect of context in context-varying decisions and classifiers, such as heterogeneous disease diagnoses. + Implemented as a Contextual Generalized Additive Model with a classifier on top. + Always uses a Neural Additive Model ("ngam") encoder for interpretability. + See `this paper `__ + for more details. + + Args: + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + num_archetypes (int, optional): Number of archetypes to use. Defaults to 0, which used the NaiveMetaModel. If > 0, uses archetypes in the ContextualizedMetaModel. + alpha (float, optional): Regularization strength. Defaults to 0.0. + mu_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization applies to context-specific parameters or context-specific offsets. Defaults to 0.0. + l1_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization penalizes l1 vs l2 parameter norms. Defaults to 0.0. """ def __init__(self, **kwargs): @@ -19,7 +30,18 @@ def __init__(self, **kwargs): class ContextualGAMRegressor(ContextualizedRegressor): """ - A GAM as context encoder with a regressor on top. + The Contextual GAM Regressor separates and interprets the effect of context in context-varying relationships, such as heterogeneous treatment effects. + Implemented as a Contextual Generalized Additive Model with a linear regressor on top. + Always uses a Neural Additive Model ("ngam") encoder for interpretability. + See `this paper `__ + for more details. + + Args: + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + num_archetypes (int, optional): Number of archetypes to use. Defaults to 0, which used the NaiveMetaModel. If > 0, uses archetypes in the ContextualizedMetaModel. + alpha (float, optional): Regularization strength. Defaults to 0.0. + mu_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization applies to context-specific parameters or context-specific offsets. Defaults to 0.0. + l1_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization penalizes l1 vs l2 parameter norms. Defaults to 0.0. """ def __init__(self, **kwargs): diff --git a/contextualized/easy/ContextualizedClassifier.py b/contextualized/easy/ContextualizedClassifier.py index a99d060..f5cab64 100644 --- a/contextualized/easy/ContextualizedClassifier.py +++ b/contextualized/easy/ContextualizedClassifier.py @@ -11,7 +11,16 @@ class ContextualizedClassifier(ContextualizedRegressor): """ - sklearn-like interface to Contextualized Classifiers. + Contextualized Logistic Regression reveals context-dependent decisions and decision boundaries. + Implemented as a ContextualizedRegressor with logistic link function and binary cross-entropy loss. + + Args: + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + num_archetypes (int, optional): Number of archetypes to use. Defaults to 0, which used the NaiveMetaModel. If > 0, uses archetypes in the ContextualizedMetaModel. + encoder_type (str, optional): Type of encoder to use ("mlp", "ngam", "linear"). Defaults to "mlp". + alpha (float, optional): Regularization strength. Defaults to 0.0. + mu_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization applies to context-specific parameters or context-specific offsets. Defaults to 0.0. + l1_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization penalizes l1 vs l2 parameter norms. Defaults to 0.0. """ def __init__(self, **kwargs): @@ -20,14 +29,15 @@ def __init__(self, **kwargs): super().__init__(**kwargs) def predict(self, C, X, individual_preds=False, **kwargs): - """ - Predict outcomes from context C and predictors X. + """Predict binary outcomes from context C and predictors X. - :param C: - :param X: - :param individual_preds: - :param **kwargs: + Args: + C (np.ndarray): Context array of shape (n_samples, n_context_features) + X (np.ndarray): Predictor array of shape (N, n_features) + individual_preds (bool, optional): Whether to return individual predictions for each model. Defaults to False. + Returns: + Union[np.ndarray, List[np.ndarray]]: The binary outcomes predicted by the context-specific models (n_samples, y_dim). Returned as lists of individual bootstraps if individual_preds is True. """ return np.round(super().predict(C, X, individual_preds, **kwargs)) @@ -35,10 +45,13 @@ def predict_proba(self, C, X, **kwargs): """ Predict probabilities of outcomes from context C and predictors X. - :param C: - :param X: - :param **kwargs: + Args: + C (np.ndarray): Context array of shape (n_samples, n_context_features) + X (np.ndarray): Predictor array of shape (N, n_features) + individual_preds (bool, optional): Whether to return individual predictions for each model. Defaults to False. + Returns: + Union[np.ndarray, List[np.ndarray]]: The outcome probabilities predicted by the context-specific models (n_samples, y_dim). Returned as lists of individual bootstraps if individual_preds is True. """ # Returns a np array of shape N samples, K outcomes, 2. probs = super().predict(C, X, **kwargs) diff --git a/contextualized/easy/ContextualizedNetworks.py b/contextualized/easy/ContextualizedNetworks.py index 0cae6bc..ae3b5a7 100644 --- a/contextualized/easy/ContextualizedNetworks.py +++ b/contextualized/easy/ContextualizedNetworks.py @@ -1,16 +1,21 @@ """ sklearn-like interface to Contextualized Networks. """ +from typing import * + import numpy as np from contextualized.easy.wrappers import SKLearnWrapper from contextualized.regression.trainers import CorrelationTrainer, MarkovTrainer from contextualized.regression.lightning_modules import ( ContextualizedCorrelation, - # TasksplitContextualizedCorrelation, # TODO: Incorporate Tasksplit ContextualizedMarkovGraph, ) -from contextualized.dags.lightning_modules import NOTMAD, DEFAULT_DAG_LOSS_TYPE, DEFAULT_DAG_LOSS_PARAMS +from contextualized.dags.lightning_modules import ( + NOTMAD, + DEFAULT_DAG_LOSS_TYPE, + DEFAULT_DAG_LOSS_PARAMS, +) from contextualized.dags.trainers import GraphTrainer from contextualized.dags.graph_utils import dag_pred_np @@ -20,28 +25,77 @@ class ContextualizedNetworks(SKLearnWrapper): sklearn-like interface to Contextualized Networks. """ - def _split_train_data(self, C, X, **kwargs): - return super()._split_train_data(C, X, Y_required=False, **kwargs) + def _split_train_data( + self, C: np.ndarray, X: np.ndarray, **kwargs + ) -> Tuple[List[np.ndarray], List[np.ndarray]]: + """Splits data into train and test sets. - def predict_networks(self, C, with_offsets=False, **kwargs): + Args: + C (np.ndarray): Contextual features for each sample. + X (np.ndarray): The data matrix. + + Returns: + Tuple[List[np.ndarray], List[np.ndarray]]: The train and test sets for C and X as ([C_train, X_train], [C_test, X_test]). """ - Predicts context-specific networks. + return super()._split_train_data(C, X, Y_required=False, **kwargs) + + def predict_networks( + self, + C: np.ndarray, + with_offsets: bool, + individual_preds: bool = False, + **kwargs, + ) -> Union[ + np.ndarray, + List[np.ndarray], + Tuple[np.ndarray, np.ndarray], + Tuple[List[np.ndarray], List[np.ndarray]], + ]: + """Predicts context-specific networks given contextual features. + + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + with_offsets (bool, optional): If True, returns both the network parameters and offsets. Defaults to False. + individual_preds (bool, optional): If True, returns the predictions for each bootstrap. Defaults to False. + + Returns: + Union[np.ndarray, List[np.ndarray], Tuple[np.ndarray, np.ndarray], Tuple[List[np.ndarray], List[np.ndarray]]]: The predicted network parameters (and offsets if with_offsets is True). Returned as lists of individual bootstraps if individual_preds is True. """ betas, mus = self.predict_params(C, uses_y=False, **kwargs) if with_offsets: return betas, mus return betas - def predict_X(self, C, X, **kwargs): - """ - Predicts X based on context-specific networks. + def predict_X( + self, C: np.ndarray, X: np.ndarray, individual_preds: bool = False, **kwargs + ) -> Union[np.ndarray, List[np.ndarray]]: + """Reconstructs the data matrix based on predicted contextualized networks and the true data matrix. + Useful for measuring reconstruction error or for imputation. + + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + X (np.ndarray): The data matrix (n_samples, n_features) + individual_preds (bool, optional): If True, returns the predictions for each bootstrap. Defaults to False. + **kwargs: Keyword arguments for the Lightning trainer's predict_y method. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The predicted data matrix, or matrices for each bootstrap if individual_preds is True (n_samples, n_features). """ - return self.predict(C, X, **kwargs) + return self.predict(C, X, individual_preds=individual_preds, **kwargs) class ContextualizedCorrelationNetworks(ContextualizedNetworks): """ - Easy interface to Contextualized Correlation Networks. + Contextualized Correlation Networks reveal context-varying feature correlations, interaction strengths, dependencies in feature groups. + Uses the Contextualized Networks model, see the `paper `__ for detailed estimation procedures. + + Args: + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + num_archetypes (int, optional): Number of archetypes to use. Defaults to 10. Always uses archetypes in the ContextualizedMetaModel. + encoder_type (str, optional): Type of encoder to use ("mlp", "ngam", "linear"). Defaults to "mlp". + alpha (float, optional): Regularization strength. Defaults to 0.0. + mu_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization applies to context-specific parameters or context-specific offsets. Defaults to 0.0. + l1_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization penalizes l1 vs l2 parameter norms. Defaults to 0.0. """ def __init__(self, **kwargs): @@ -49,18 +103,25 @@ def __init__(self, **kwargs): ContextualizedCorrelation, [], [], CorrelationTrainer, **kwargs ) - def predict_correlation(self, C, individual_preds=True, squared=True, **kwargs): - """ - Predict correlation matrices. + def predict_correlation( + self, C: np.ndarray, individual_preds: bool = True, squared: bool = True + ) -> Union[np.ndarray, List[np.ndarray]]: + """Predicts context-specific correlations between features. + + Args: + C (Numpy ndarray): Contextual features for each sample (n_samples, n_context_features) + individual_preds (bool, optional): If True, returns the predictions for each bootstrap. Defaults to True. + squared (bool, optional): If True, returns the squared correlations. Defaults to True. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The predicted context-specific correlation matrices, or matrices for each bootstrap if individual_preds is True (n_samples, n_features, n_features). """ get_dataloader = lambda i: self.models[i].dataloader( C, np.zeros((len(C), self.x_dim)) ) rhos = np.array( [ - self.trainers[i].predict_params( - self.models[i], get_dataloader(i), **kwargs - )[0] + self.trainers[i].predict_params(self.models[i], get_dataloader(i))[0] for i in range(len(self.models)) ] ) @@ -73,9 +134,18 @@ def predict_correlation(self, C, individual_preds=True, squared=True, **kwargs): return np.square(np.mean(rhos, axis=0)) return np.mean(rhos) - def measure_mses(self, C, X, individual_preds=False): - """ - Measure mean-squared errors. + def measure_mses( + self, C: np.ndarray, X: np.ndarray, individual_preds: bool = False + ) -> Union[np.ndarray, List[np.ndarray]]: + """Measures mean-squared errors. + + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + X (np.ndarray): The data matrix (n_samples, n_features) + individual_preds (bool, optional): If True, returns the predictions for each bootstrap. Defaults to False. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The mean-squared errors for each sample, or for each bootstrap if individual_preds is True (n_samples). """ betas, mus = self.predict_networks(C, individual_preds=True, with_offsets=True) mses = np.zeros((len(betas), len(C))) # n_bootstraps x n_samples @@ -92,15 +162,35 @@ def measure_mses(self, C, X, individual_preds=False): class ContextualizedMarkovNetworks(ContextualizedNetworks): """ - Easy interface to Contextualized Markov Networks. + Contextualized Markov Networks reveal context-varying feature dependencies, cliques, and modules. + Implemented as Contextualized Gaussian Precision Matrices, directly interpretable as Markov Networks. + Uses the Contextualized Networks model, see the `paper `__ for detailed estimation procedures. + + Args: + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + num_archetypes (int, optional): Number of archetypes to use. Defaults to 10. Always uses archetypes in the ContextualizedMetaModel. + encoder_type (str, optional): Type of encoder to use ("mlp", "ngam", "linear"). Defaults to "mlp". + alpha (float, optional): Regularization strength. Defaults to 0.0. + mu_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization applies to context-specific parameters or context-specific offsets. Defaults to 0.0. + l1_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization penalizes l1 vs l2 parameter norms. Defaults to 0.0. """ def __init__(self, **kwargs): super().__init__(ContextualizedMarkovGraph, [], [], MarkovTrainer, **kwargs) - def predict_precisions(self, C, individual_preds=True): - """ - Predict precision matrices. + def predict_precisions( + self, C: np.ndarray, individual_preds: bool = True + ) -> Union[np.ndarray, List[np.ndarray]]: + """Predicts context-specific precision matrices. + Can be converted to context-specific Markov networks by binarizing the networks and setting all non-zero entries to 1. + Can be converted to context-specific covariance matrices by taking the inverse. + + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + individual_preds (bool, optional): If True, returns the predictions for each bootstrap. Defaults to True. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The predicted context-specific Markov networks as precision matrices, or matrices for each bootstrap if individual_preds is True (n_samples, n_features, n_features). """ get_dataloader = lambda i: self.models[i].dataloader( C, np.zeros((len(C), self.x_dim)) @@ -115,9 +205,18 @@ def predict_precisions(self, C, individual_preds=True): return precisions return np.mean(precisions, axis=0) - def measure_mses(self, C, X, individual_preds=False): - """ - Measure mean-squared errors. + def measure_mses( + self, C: np.ndarray, X: np.ndarray, individual_preds: bool = False + ) -> Union[np.ndarray, List[np.ndarray]]: + """Measures mean-squared errors. + + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + X (np.ndarray): The data matrix (n_samples, n_features) + individual_preds (bool, optional): If True, returns the predictions for each bootstrap. Defaults to False. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The mean-squared errors for each sample, or for each bootstrap if individual_preds is True (n_samples). """ betas, mus = self.predict_networks(C, individual_preds=True, with_offsets=True) mses = np.zeros((len(betas), len(C))) # n_bootstraps x n_samples @@ -140,18 +239,40 @@ def measure_mses(self, C, X, individual_preds=False): class ContextualizedBayesianNetworks(ContextualizedNetworks): """ - Easy interface to Contextualized Bayesian Networks. - Uses NOTMAD model. - See this paper: - https://arxiv.org/abs/2111.01104 - for more details. + Contextualized Bayesian Networks and Directed Acyclic Graphs (DAGs) reveal context-dependent causal relationships, effect sizes, and variable ordering. + Uses the NOTMAD model, see the `paper `__ for detailed estimation procedures. + + Args: + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + num_archetypes (int, optional): Number of archetypes to use. Defaults to 16. Always uses archetypes in the ContextualizedMetaModel. + encoder_type (str, optional): Type of encoder to use ("mlp", "ngam", "linear"). Defaults to "mlp". + archetype_dag_loss_type (str, optional): The type of loss to use for the archetype loss. Defaults to "l1". + archetype_l1 (float, optional): The strength of the l1 regularization for the archetype loss. Defaults to 0.0. + archetype_dag_params (dict, optional): Parameters for the archetype loss. Defaults to {"loss_type": "l1", "params": {"alpha": 0.0, "rho": 0.0, "s": 0.0, "tol": 1e-4}}. + archetype_dag_loss_params (dict, optional): Parameters for the archetype loss. Defaults to {"alpha": 0.0, "rho": 0.0, "s": 0.0, "tol": 1e-4}. + archetype_alpha (float, optional): The strength of the alpha regularization for the archetype loss. Defaults to 0.0. + archetype_rho (float, optional): The strength of the rho regularization for the archetype loss. Defaults to 0.0. + archetype_s (float, optional): The strength of the s regularization for the archetype loss. Defaults to 0.0. + archetype_tol (float, optional): The tolerance for the archetype loss. Defaults to 1e-4. + archetype_use_dynamic_alpha_rho (bool, optional): Whether to use dynamic alpha and rho for the archetype loss. Defaults to False. + init_mat (np.ndarray, optional): The initial adjacency matrix for the archetype loss. Defaults to None. + num_factors (int, optional): The number of factors for the archetype loss. Defaults to 0. + factor_mat_l1 (float, optional): The strength of the l1 regularization for the factor matrix for the archetype loss. Defaults to 0. + sample_specific_dag_loss_type (str, optional): The type of loss to use for the sample-specific loss. Defaults to "l1". + sample_specific_alpha (float, optional): The strength of the alpha regularization for the sample-specific loss. Defaults to 0.0. + sample_specific_rho (float, optional): The strength of the rho regularization for the sample-specific loss. Defaults to 0.0. + sample_specific_s (float, optional): The strength of the s regularization for the sample-specific loss. Defaults to 0.0. + sample_specific_tol (float, optional): The tolerance for the sample-specific loss. Defaults to 1e-4. + sample_specific_use_dynamic_alpha_rho (bool, optional): Whether to use dynamic alpha and rho for the sample-specific loss. Defaults to False. """ def _parse_private_init_kwargs(self, **kwargs): """ - Parses private init kwargs. - """ + Parses the kwargs for the NOTMAD model. + Args: + **kwargs: Keyword arguments for the NOTMAD model, including the encoder, archetype loss, sample-specific loss, and optimization parameters. + """ # Encoder Parameters self._init_kwargs["model"]["encoder_kwargs"] = { "type": kwargs.pop( @@ -163,9 +284,11 @@ def _parse_private_init_kwargs(self, **kwargs): "link_fn": self.constructor_kwargs["encoder_kwargs"]["link_fn"], }, } - + # Archetype-specific parameters - archetype_dag_loss_type = kwargs.pop("archetype_dag_loss_type", DEFAULT_DAG_LOSS_TYPE) + archetype_dag_loss_type = kwargs.pop( + "archetype_dag_loss_type", DEFAULT_DAG_LOSS_TYPE + ) self._init_kwargs["model"]["archetype_loss_params"] = { "l1": kwargs.get("archetype_l1", 0.0), "dag": kwargs.get( @@ -185,9 +308,11 @@ def _parse_private_init_kwargs(self, **kwargs): } if self._init_kwargs["model"]["archetype_loss_params"]["num_archetypes"] <= 0: - print("WARNING: num_archetypes is 0. NOTMAD requires archetypes. Setting num_archetypes to 16.") + print( + "WARNING: num_archetypes is 0. NOTMAD requires archetypes. Setting num_archetypes to 16." + ) self._init_kwargs["model"]["archetype_loss_params"]["num_archetypes"] = 16 - + # Possibly update values with convenience parameters for param, value in self._init_kwargs["model"]["archetype_loss_params"]["dag"][ "params" @@ -213,11 +338,11 @@ def _parse_private_init_kwargs(self, **kwargs): }, ), } - + # Possibly update values with convenience parameters - for param, value in self._init_kwargs["model"]["sample_specific_loss_params"]["dag"][ - "params" - ].items(): + for param, value in self._init_kwargs["model"]["sample_specific_loss_params"][ + "dag" + ]["params"].items(): self._init_kwargs["model"]["sample_specific_loss_params"]["dag"]["params"][ param ] = kwargs.pop(f"sample_specific_{param}", value) @@ -227,7 +352,7 @@ def _parse_private_init_kwargs(self, **kwargs): "learning_rate": kwargs.pop("learning_rate", 1e-3), "step": kwargs.pop("step", 50), } - + return [ "archetype_dag_loss_type", "archetype_l1", @@ -271,39 +396,56 @@ def __init__(self, **kwargs): **kwargs, ) - def predict_params(self, C, **kwargs): - """ + def predict_params( + self, C: np.ndarray, **kwargs + ) -> Union[np.ndarray, List[np.ndarray]]: + """Predicts context-specific Bayesian network parameters as linear coefficients in a linear structural equation model (SEM). - :param C: - :param individual_preds: (Default value = False) + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + **kwargs: Keyword arguments for the contextualized.dags.GraphTrainer's predict_params method. + Returns: + Union[np.ndarray, List[np.ndarray]]: The linear coefficients of the predicted context-specific Bayesian network parameters (n_samples, n_features, n_features). Returned as lists of individual bootstraps if individual_preds is True. """ - # Returns betas - # TODO: No mus for NOTMAD at present. - return super().predict_params( - C, model_includes_mus=False, **kwargs - ) + # No mus for NOTMAD at present. + return super().predict_params(C, model_includes_mus=False, **kwargs) - def predict_networks(self, C, **kwargs): - """ - Predicts context-specific networks. + def predict_networks( + self, C: np.ndarray, project_to_dag: bool = True, **kwargs + ) -> Union[np.ndarray, List[np.ndarray]]: + """Predicts context-specific Bayesian networks. + + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + project_to_dag (bool, optional): If True, guarantees returned graphs are DAGs by trimming edges until acyclicity is satisified. Defaults to True. + **kwargs: Keyword arguments for the contextualized.dags.GraphTrainer's predict_params method. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The linear coefficients of the predicted context-specific Bayesian network parameters (n_samples, n_features, n_features). Returned as lists of individual bootstraps if individual_preds is True. """ if kwargs.pop("with_offsets", False): print("No offsets can be returned by NOTMAD.") betas = self.predict_params( - C, - uses_y=False, - project_to_dag=kwargs.pop("project_to_dag", True), - **kwargs + C, uses_y=False, project_to_dag=project_to_dag, **kwargs ) - return betas - def measure_mses(self, C, X, individual_preds=False): - """ - Measure mean-squared errors. + def measure_mses( + self, C: np.ndarray, X: np.ndarray, individual_preds: bool = False, **kwargs + ) -> Union[np.ndarray, List[np.ndarray]]: + """Measures mean-squared errors. + + Args: + C (np.ndarray): Contextual features for each sample (n_samples, n_context_features) + X (np.ndarray): The data matrix (n_samples, n_features) + individual_preds (bool, optional): If True, returns the predictions for each bootstrap. Defaults to False. + **kwargs: Keyword arguments for the contextualized.dags.GraphTrainer's predict_params method. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The mean-squared errors for each sample, or for each bootstrap if individual_preds is True (n_samples). """ - betas = self.predict_networks(C, individual_preds=True) + betas = self.predict_networks(C, individual_preds=True, **kwargs) mses = np.zeros((len(betas), len(C))) # n_bootstraps x n_samples for bootstrap in range(len(betas)): X_pred = dag_pred_np(X, betas[bootstrap]) diff --git a/contextualized/easy/ContextualizedRegressor.py b/contextualized/easy/ContextualizedRegressor.py index 117097e..8f7fcae 100644 --- a/contextualized/easy/ContextualizedRegressor.py +++ b/contextualized/easy/ContextualizedRegressor.py @@ -14,7 +14,17 @@ class ContextualizedRegressor(SKLearnWrapper): """ - sklearn-like interface to Contextualized Regression. + Contextualized Linear Regression quantifies context-varying linear relationships. + + Args: + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + num_archetypes (int, optional): Number of archetypes to use. Defaults to 0, which used the NaiveMetaModel. If > 0, uses archetypes in the ContextualizedMetaModel. + encoder_type (str, optional): Type of encoder to use ("mlp", "ngam", "linear"). Defaults to "mlp". + loss_fn (torch.nn.Module, optional): Loss function. Defaults to LOSSES["mse"]. + link_fn (torch.nn.Module, optional): Link function. Defaults to LINK_FUNCTIONS["identity"]. + alpha (float, optional): Regularization strength. Defaults to 0.0. + mu_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization applies to context-specific parameters or context-specific offsets. Defaults to 0.0. + l1_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization penalizes l1 vs l2 parameter norms. Defaults to 0.0. """ def __init__(self, **kwargs): diff --git a/contextualized/easy/tests/test_bayesian_networks.py b/contextualized/easy/tests/test_bayesian_networks.py index 60ff6eb..5ba4c46 100644 --- a/contextualized/easy/tests/test_bayesian_networks.py +++ b/contextualized/easy/tests/test_bayesian_networks.py @@ -28,13 +28,17 @@ def setUp(self): def test_bayesian_factors(self): """Test case for ContextualizedBayesianNetworks.""" - model = ContextualizedBayesianNetworks(encoder_type="ngam", num_archetypes=16, num_factors=2) + model = ContextualizedBayesianNetworks( + encoder_type="ngam", num_archetypes=16, num_factors=2 + ) model.fit(self.C, self.X, max_epochs=10) networks = model.predict_networks(self.C, individual_preds=False) assert np.shape(networks) == (self.n_samples, self.x_dim, self.x_dim) networks = model.predict_networks(self.C, factors=True) assert np.shape(networks) == (self.n_samples, 2, 2) - model = ContextualizedBayesianNetworks(encoder_type="ngam", num_archetypes=16, num_factors=2) + model = ContextualizedBayesianNetworks( + encoder_type="ngam", num_archetypes=16, num_factors=2 + ) self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3) def test_bayesian_default(self): @@ -43,7 +47,9 @@ def test_bayesian_default(self): def test_bayesian_val_split(self): model = ContextualizedBayesianNetworks() - self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3, val_split=0.5) + self._quicktest( + model, self.C, self.X, max_epochs=10, learning_rate=1e-3, val_split=0.5 + ) def test_bayesian_archetypes(self): model = ContextualizedBayesianNetworks(num_archetypes=16) @@ -61,12 +67,16 @@ def test_bayesian_encoder(self): assert np.shape(networks) == (self.n_samples, self.x_dim, self.x_dim) def test_bayesian_acyclicity(self): - model = ContextualizedBayesianNetworks(archetype_dag_loss_type="DAGMA", num_archetypes=16) + model = ContextualizedBayesianNetworks( + archetype_dag_loss_type="DAGMA", num_archetypes=16 + ) self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3) networks = model.predict_networks(self.C, individual_preds=False) assert np.shape(networks) == (self.n_samples, self.x_dim, self.x_dim) - model = ContextualizedBayesianNetworks(archetype_dag_loss_type="poly", num_archetypes=16) + model = ContextualizedBayesianNetworks( + archetype_dag_loss_type="poly", num_archetypes=16 + ) self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3) networks = model.predict_networks(self.C, individual_preds=False) assert np.shape(networks) == (self.n_samples, self.x_dim, self.x_dim) diff --git a/contextualized/easy/tests/test_correlation_networks.py b/contextualized/easy/tests/test_correlation_networks.py index 90cd890..52dbd3d 100644 --- a/contextualized/easy/tests/test_correlation_networks.py +++ b/contextualized/easy/tests/test_correlation_networks.py @@ -33,7 +33,9 @@ def test_correlation(self): model = ContextualizedCorrelationNetworks() self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3) - self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3, val_split=0.5) + self._quicktest( + model, self.C, self.X, max_epochs=10, learning_rate=1e-3, val_split=0.5 + ) model = ContextualizedCorrelationNetworks(num_archetypes=16) self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3) diff --git a/contextualized/easy/tests/test_markov_networks.py b/contextualized/easy/tests/test_markov_networks.py index eb8f1b4..b778321 100644 --- a/contextualized/easy/tests/test_markov_networks.py +++ b/contextualized/easy/tests/test_markov_networks.py @@ -30,7 +30,9 @@ def test_markov(self): """Test Case for ContextualizedMarkovNetworks.""" model = ContextualizedMarkovNetworks() self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3) - self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3, val_split=0.5) + self._quicktest( + model, self.C, self.X, max_epochs=10, learning_rate=1e-3, val_split=0.5 + ) model = ContextualizedMarkovNetworks(num_archetypes=16) self._quicktest(model, self.C, self.X, max_epochs=10, learning_rate=1e-3) diff --git a/contextualized/easy/tests/test_regressor.py b/contextualized/easy/tests/test_regressor.py index e3f66e2..a0b70a3 100644 --- a/contextualized/easy/tests/test_regressor.py +++ b/contextualized/easy/tests/test_regressor.py @@ -90,7 +90,7 @@ def test_regressor(self): learning_rate=1e-3, es_patience=float("inf"), ) - + # Check smaller Y. model = ContextualizedRegressor( num_archetypes=4, alpha=1e-1, l1_ratio=0.5, mu_ratio=0.1 diff --git a/contextualized/easy/wrappers/SKLearnWrapper.py b/contextualized/easy/wrappers/SKLearnWrapper.py index fed4090..33de005 100644 --- a/contextualized/easy/wrappers/SKLearnWrapper.py +++ b/contextualized/easy/wrappers/SKLearnWrapper.py @@ -3,6 +3,8 @@ """ import copy import os +from typing import * + import numpy as np from pytorch_lightning.callbacks.early_stopping import EarlyStopping from pytorch_lightning.callbacks import ModelCheckpoint @@ -28,6 +30,19 @@ class SKLearnWrapper: """ An sklearn-like wrapper for Contextualized models. + + Args: + base_constructor (class): The base class to construct the model. + extra_model_kwargs (dict): Extra kwargs to pass to the model constructor. + extra_data_kwargs (dict): Extra kwargs to pass to the dataloader constructor. + trainer_constructor (class): The trainer class to use. + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + encoder_type (str, optional): Type of encoder to use ("mlp", "ngam", "linear"). Defaults to "mlp". + loss_fn (torch.nn.Module, optional): Loss function. Defaults to LOSSES["mse"]. + link_fn (torch.nn.Module, optional): Link function. Defaults to LINK_FUNCTIONS["identity"]. + alpha (float, optional): Regularization strength. Defaults to 0.0. + mu_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization applies to context-specific parameters or context-specific offsets. + l1_ratio (float, optional): Float in range (0.0, 1.0), governs how much the regularization penalizes l1 vs l2 parameter norms. """ def _set_defaults(self): @@ -44,12 +59,12 @@ def _set_defaults(self): self.default_encoder_type = DEFAULT_ENCODER_TYPE def __init__( - self, - base_constructor, - extra_model_kwargs, - extra_data_kwargs, - trainer_constructor, - **kwargs, + self, + base_constructor, + extra_model_kwargs, + extra_data_kwargs, + trainer_constructor, + **kwargs, ): self._set_defaults() self.base_constructor = base_constructor @@ -69,7 +84,7 @@ def __init__( "test_batch_size", "C_val", "X_val", - "val_split" + "val_split", ], "model": [ "loss_fn", @@ -137,14 +152,18 @@ def __init__( if k not in self.constructor_kwargs and k not in self.convenience_kwargs } # Some args will not be ignored by wrapper because sub-class will handle them. - #self.private_kwargs = kwargs.pop("private_kwargs", []) - #self.private_kwargs.append("private_kwargs") + # self.private_kwargs = kwargs.pop("private_kwargs", []) + # self.private_kwargs.append("private_kwargs") # Add Predictor-Specific kwargs for parsing. - self._init_kwargs, unrecognized_general_kwargs = self._organize_kwargs(**self.not_constructor_kwargs) + self._init_kwargs, unrecognized_general_kwargs = self._organize_kwargs( + **self.not_constructor_kwargs + ) for key, value in self.constructor_kwargs.items(): self._init_kwargs["model"][key] = value recognized_private_init_kwargs = self._parse_private_init_kwargs(**kwargs) - for kwarg in set(unrecognized_general_kwargs) - set(recognized_private_init_kwargs): + for kwarg in set(unrecognized_general_kwargs) - set( + recognized_private_init_kwargs + ): print(f"Received unknown keyword argument {kwarg}, probably ignoring.") def _organize_and_expand_fit_kwargs(self, **kwargs): @@ -175,8 +194,8 @@ def maybe_add_kwarg(category, kwarg, default_val): maybe_add_kwarg("model", "x_dim", self.x_dim) maybe_add_kwarg("model", "y_dim", self.y_dim) if ( - "num_archetypes" in organized_kwargs["model"] - and organized_kwargs["model"]["num_archetypes"] == 0 + "num_archetypes" in organized_kwargs["model"] + and organized_kwargs["model"]["num_archetypes"] == 0 ): del organized_kwargs["model"]["num_archetypes"] @@ -212,7 +231,6 @@ def maybe_add_kwarg(category, kwarg, default_val): maybe_add_kwarg("trainer", "accelerator", self.accelerator) return organized_kwargs - def _parse_private_fit_kwargs(self, **kwargs): """ Parse private (model-specific) kwargs passed to fit function. @@ -234,8 +252,9 @@ def _update_acceptable_kwargs(self, category, new_kwargs, acceptable=True): If acceptable=False, the new kwargs will be removed from the list of acceptable kwargs. """ if acceptable: - self.acceptable_kwargs[category] = list(set( - self.acceptable_kwargs[category]).union(set(new_kwargs))) + self.acceptable_kwargs[category] = list( + set(self.acceptable_kwargs[category]).union(set(new_kwargs)) + ) else: self.acceptable_kwargs[category] = list( set(self.acceptable_kwargs[category]) - set(new_kwargs) @@ -252,7 +271,7 @@ def _organize_kwargs(self, **kwargs): organized_kwargs = {category: {} for category in self.acceptable_kwargs} unrecognized_kwargs = [] for kwarg, value in kwargs.items(): - #if kwarg in self.private_kwargs: + # if kwarg in self.private_kwargs: # continue not_found = True for category, category_kwargs in self.acceptable_kwargs.items(): @@ -367,11 +386,18 @@ def _build_dataloaders(self, model, train_data, val_data, **kwargs): return train_dataloader, val_dataloader - def predict(self, C, X, individual_preds=False, **kwargs): - """ - :param C: - :param X: - :param individual_preds: (Default value = False) + def predict( + self, C: np.ndarray, X: np.ndarray, individual_preds: bool = False, **kwargs + ) -> Union[np.ndarray, List[np.ndarray]]: + """Predict outcomes from context C and predictors X. + + Args: + C (np.ndarray): Context array of shape (n_samples, n_context_features) + X (np.ndarray): Predictor array of shape (N, n_features) + individual_preds (bool, optional): Whether to return individual predictions for each model. Defaults to False. + + Returns: + Union[np.ndarray, List[np.ndarray]]: The outcomes predicted by the context-specific models (n_samples, y_dim). Returned as lists of individual bootstraps if individual_preds is True. """ if not hasattr(self, "models") or self.models is None: raise ValueError( @@ -392,11 +418,33 @@ def predict(self, C, X, individual_preds=False, **kwargs): return np.mean(predictions, axis=0) def predict_params( - self, C, individual_preds=False, model_includes_mus=True, **kwargs - ): + self, + C: np.ndarray, + individual_preds: bool = False, + model_includes_mus: bool = True, + **kwargs, + ) -> Union[ + np.ndarray, + List[np.ndarray], + Tuple[np.ndarray, np.ndarray], + Tuple[List[np.ndarray], List[np.ndarray]], + ]: """ - :param C: - :param individual_preds: (Default value = False) + Predict context-specific model parameters from context C. + + Args: + C (np.ndarray): Context array of shape (n_samples, n_context_features) + individual_preds (bool, optional): Whether to return individual model predictions for each bootstrap. Defaults to False, averaging across bootstraps. + model_includes_mus (bool, optional): Whether the model includes context-specific offsets (mu). Defaults to True. + + Returns: + Union[np.ndarray, List[np.ndarray], Tuple[np.ndarray, np.ndarray], Tuple[List[np.ndarray], List[np.ndarray]]: The parameters of the predicted context-specific models. + Returned as lists of individual bootstraps if individual_preds is True, otherwise averages the bootstraps for a better estimate. + If model_includes_mus is True, returns both coefficients and offsets as a tuple of (betas, mus). Otherwise, returns coefficients (betas) only. + For model_includes_mus=True, ([betas], [mus]) if individual_preds is True, otherwise (betas, mus). + For model_includes_mus=False, [betas] if individual_preds is True, otherwise betas. + betas is shape (n_samples, x_dim, y_dim) or (n_samples, x_dim) if y_dim = 1. + mus is shape (n_samples, y_dim) or (n_samples,) if y_dim = 1. """ # Returns betas, mus if kwargs.pop("uses_y", True): @@ -423,13 +471,25 @@ def predict_params( return np.mean(betas, axis=0) return betas - def fit(self, *args, **kwargs): + def fit(self, *args, **kwargs) -> None: """ - Fit model to data. - Requires numpy arrays C, X, with optional Y. - If target Y is not given, then X is assumed to be the target. - :param *args: C, X, Y (optional) - :param **kwargs: + Fit contextualized model to data. + + Args: + C (np.ndarray): Context array of shape (n_samples, n_context_features) + X (np.ndarray): Predictor array of shape (N, n_features) + Y (np.ndarray, optional): Target array of shape (N, n_targets). Defaults to None, where X will be used as targets such as in Contextualized Networks. + max_epochs (int, optional): Maximum number of epochs to train for. Defaults to 1. + learning_rate (float, optional): Learning rate for optimizer. Defaults to 1e-3. + val_split (float, optional): Proportion of data to use for validation and early stopping. Defaults to 0.2. + n_bootstraps (int, optional): Number of bootstraps to use. Defaults to 1. + train_batch_size (int, optional): Batch size for training. Defaults to 1. + val_batch_size (int, optional): Batch size for validation. Defaults to 16. + test_batch_size (int, optional): Batch size for testing. Defaults to 16. + es_patience (int, optional): Number of epochs to wait before early stopping. Defaults to 1. + es_monitor (str, optional): Metric to monitor for early stopping. Defaults to "val_loss". + es_mode (str, optional): Mode for early stopping. Defaults to "min". + es_verbose (bool, optional): Whether to print early stopping updates. Defaults to False. """ self.models = [] self.trainers = [] @@ -469,7 +529,9 @@ def fit(self, *args, **kwargs): for f in organized_kwargs["trainer"]["callback_constructors"] ] del my_trainer_kwargs["callback_constructors"] - trainer = self.trainer_constructor(**my_trainer_kwargs, enable_progress_bar=False) + trainer = self.trainer_constructor( + **my_trainer_kwargs, enable_progress_bar=False + ) checkpoint_callback = my_trainer_kwargs["callbacks"][1] os.makedirs(checkpoint_callback.dirpath, exist_ok=True) try: diff --git a/contextualized/modules.py b/contextualized/modules.py index fc69678..a880f26 100644 --- a/contextualized/modules.py +++ b/contextualized/modules.py @@ -143,11 +143,7 @@ class Linear(nn.Module): Linear encoder """ - def __init__( - self, - input_dim, - output_dim - ): + def __init__(self, input_dim, output_dim): super().__init__() self.linear = MLP( input_dim, output_dim, width=output_dim, layers=0, activation=None @@ -158,11 +154,7 @@ def forward(self, X): return self.linear(X) -ENCODERS = { - "mlp": MLP, - "ngam": NGAM, - "linear": Linear -} +ENCODERS = {"mlp": MLP, "ngam": NGAM, "linear": Linear} if __name__ == "__main__": diff --git a/contextualized_logo.png b/contextualized_logo.png deleted file mode 100644 index 5acce57..0000000 Binary files a/contextualized_logo.png and /dev/null differ diff --git a/dev_requirements.txt b/dev_requirements.txt new file mode 100644 index 0000000..7071e1b --- /dev/null +++ b/dev_requirements.txt @@ -0,0 +1,22 @@ +# This file specifies extra dependencies for the development of Contextualized ML + +# Style +black==23.12.1 +pylint==2.15.5 +pylint-badge @ git+https://github.com/blengerich/pylint-badge + +# Documentation +jupyter-book==0.15.1 +myst-parser==0.18.1 +Sphinx==5.0.2 +sphinx-book-theme==1.0.1 +sphinx-jupyterbook-latex==0.5.2 +sphinx-rtd-theme==2.0.0 +sphinx_external_toc==0.3.1 + +# Testing +pytest==7.4.3 + +# Packaging +toml==0.10.2 +tomli==2.0.1 diff --git a/docs/_config.yml b/docs/_config.yml index 2b7a4f1..631c484 100644 --- a/docs/_config.yml +++ b/docs/_config.yml @@ -12,10 +12,11 @@ url: "https://contextualized.ml" # Force re-execution of notebooks on each build. # See https://jupyterbook.org/content/execute.html execute: - execute_notebooks: force - timeout: 300 + execute_notebooks: 'off' + # execute_notebooks: force + # timeout: 300 -only_build_toc_files: true +only_build_toc_files: false # Define the name of the latex output file for PDF builds latex: @@ -37,3 +38,27 @@ repository: html: use_issues_button: true use_repository_button: true + +# https://jupyterbook.org/en/stable/advanced/developers.html +sphinx: + extra_extensions: + - 'sphinx.ext.autodoc' + - 'sphinx.ext.napoleon' + - 'sphinx.ext.viewcode' + - 'sphinx.ext.autosummary' + config: + add_module_names: False + autosummary_generate: True + html_theme: sphinx_book_theme + # templates_path: ['_templates'] + # - sphinx.ext.duration +# - sphinx.ext.doctest +# - sphinx.ext.intersphinx +# - nbsphinx +# - myst_parser + # 'sphinx.ext.doctest', + # 'sphinx.ext.autodoc', + # 'sphinx.ext.autosummary', + # 'sphinx.ext.intersphinx', + # 'nbsphinx', + # 'myst_parser', \ No newline at end of file diff --git a/docs/_toc.yml b/docs/_toc.yml index 16307a3..87accbe 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -25,6 +25,8 @@ parts: - caption: Demos chapters: - file: demos/custom_models - - file: demos/robust-outliers - file: demos/benefits - + - caption: API Reference + chapters: + - file: source/easy + - file: source/analysis \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..687060f --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,37 @@ +############################################################################### +# Auto-generated by `jupyter-book config` +# If you wish to continue using _config.yml, make edits to that file and +# re-generate this one. +############################################################################### +add_module_names = False +author = 'Contextualized.ML Team' +autosummary_generate = True +bibtex_bibfiles = ['references.bib'] +comments_config = {'hypothesis': False, 'utterances': False} +copyright = '2023' +exclude_patterns = ['**.ipynb_checkpoints', '.DS_Store', 'Thumbs.db', '_build'] +extensions = ['sphinx_togglebutton', 'sphinx_copybutton', 'myst_nb', 'jupyter_book', 'sphinx_thebe', 'sphinx_comments', 'sphinx_external_toc', 'sphinx.ext.intersphinx', 'sphinx_design', 'sphinx_book_theme', 'sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode', 'sphinx.ext.autosummary', 'sphinxcontrib.bibtex', 'sphinx_jupyterbook_latex'] +external_toc_exclude_missing = False +external_toc_path = '_toc.yml' +html_baseurl = '' +html_favicon = '' +html_logo = 'logo.png' +html_sourcelink_suffix = '' +html_theme = 'sphinx_book_theme' +html_theme_options = {'search_bar_text': 'Search this book...', 'launch_buttons': {'notebook_interface': 'classic', 'binderhub_url': '', 'jupyterhub_url': '', 'thebe': False, 'colab_url': ''}, 'path_to_docs': '', 'repository_url': 'https://github.com/cnellington/contextualized', 'repository_branch': 'master', 'extra_footer': '', 'home_page_in_toc': True, 'announcement': '', 'analytics': {'google_analytics_id': ''}, 'use_repository_button': True, 'use_edit_page_button': False, 'use_issues_button': True} +html_title = 'Contextualized.ML Documentation' +latex_engine = 'pdflatex' +myst_enable_extensions = ['colon_fence', 'dollarmath', 'linkify', 'substitution', 'tasklist'] +myst_url_schemes = ['mailto', 'http', 'https'] +nb_execution_allow_errors = False +nb_execution_cache_path = '' +nb_execution_excludepatterns = [] +nb_execution_in_temp = False +nb_execution_mode = 'off' +nb_execution_timeout = 30 +nb_output_stderr = 'show' +numfig = True +pygments_style = 'sphinx' +suppress_warnings = ['myst.domains'] +use_jupyterbook_latex = True +use_multitoc_numbering = True diff --git a/docs/models/easy_bayesian_networks_factors.ipynb b/docs/models/easy_bayesian_networks_factors.ipynb index 54880e2..9cd0277 100644 --- a/docs/models/easy_bayesian_networks_factors.ipynb +++ b/docs/models/easy_bayesian_networks_factors.ipynb @@ -5,7 +5,7 @@ "id": "6e32bc2f", "metadata": {}, "source": [ - "# Contextualized Bayesian Networks" + "# Low-dimensional Contextualized Bayesian Networks" ] }, { @@ -259,7 +259,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/models/easy_classification.ipynb b/docs/models/easy_classification.ipynb index cb9cd09..f4f2bb5 100644 --- a/docs/models/easy_classification.ipynb +++ b/docs/models/easy_classification.ipynb @@ -105,7 +105,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -172,7 +172,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -239,7 +239,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/docs/requirements.txt b/docs/requirements.txt index 7e821e4..a094cde 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,3 +1,6 @@ jupyter-book matplotlib numpy +sphinx>=1.4 +ipykernel +nbsphinx diff --git a/docs/source/analysis.rst b/docs/source/analysis.rst new file mode 100644 index 0000000..bf25023 --- /dev/null +++ b/docs/source/analysis.rst @@ -0,0 +1,30 @@ +Model Analysis +============== + +``contextualized.analysis`` contains functions to analyze and plot the results of contextualized models. +All functions can be loaded directly from the module, e.g. ``from contextualized.analysis import plot_heterogeneous_predictor_effects``. + +.. currentmodule:: contextualized.analysis + +.. autosummary:: + :nosignatures: + + accuracy_split.print_acc_by_covars + embeddings.plot_lowdim_rep + embeddings.plot_embedding_for_all_covars + effects.plot_homogeneous_context_effects + effects.plot_homogeneous_predictor_effects + effects.plot_heterogeneous_predictor_effects + pvals.calc_homogeneous_context_effects_pval + pvals.calc_homogeneous_predictor_effects_pval + pvals.calc_heterogeneous_predictor_effects_pvals + +.. autofunction:: contextualized.analysis.accuracy_split.print_acc_by_covars +.. autofunction:: contextualized.analysis.embeddings.plot_lowdim_rep +.. autofunction:: contextualized.analysis.embeddings.plot_embedding_for_all_covars +.. autofunction:: contextualized.analysis.effects.plot_homogeneous_context_effects +.. autofunction:: contextualized.analysis.effects.plot_homogeneous_predictor_effects +.. autofunction:: contextualized.analysis.effects.plot_heterogeneous_predictor_effects +.. autofunction:: contextualized.analysis.pvals.calc_homogeneous_context_effects_pval +.. autofunction:: contextualized.analysis.pvals.calc_homogeneous_predictor_effects_pval +.. autofunction:: contextualized.analysis.pvals.calc_heterogeneous_predictor_effects_pvals \ No newline at end of file diff --git a/docs/source/easy.rst b/docs/source/easy.rst new file mode 100644 index 0000000..1a2e0a2 --- /dev/null +++ b/docs/source/easy.rst @@ -0,0 +1,46 @@ +Easy-start Models +================= + +The ``contextualized.easy`` module contains the most popular and useful model types, which have an SKLearn-like API for minimal overhead. +All models can be loaded directly from the module, e.g. ``from contextualized.easy import ContextualizedRegressor``. + +.. currentmodule:: contextualized.easy + +.. autosummary:: + :nosignatures: + + ContextualizedRegressor.ContextualizedRegressor + ContextualizedClassifier.ContextualizedClassifier + ContextualGAM.ContextualGAMRegressor + ContextualGAM.ContextualGAMClassifier + ContextualizedNetworks.ContextualizedCorrelationNetworks + ContextualizedNetworks.ContextualizedMarkovNetworks + ContextualizedNetworks.ContextualizedBayesianNetworks + +.. autoclass:: contextualized.easy.ContextualizedRegressor.ContextualizedRegressor + :members: + :inherited-members: + +.. autoclass:: contextualized.easy.ContextualizedClassifier.ContextualizedClassifier + :members: + :inherited-members: + +.. autoclass:: contextualized.easy.ContextualGAM.ContextualGAMRegressor + :members: + :inherited-members: + +.. autoclass:: contextualized.easy.ContextualGAM.ContextualGAMClassifier + :members: + :inherited-members: + +.. autoclass:: contextualized.easy.ContextualizedNetworks.ContextualizedCorrelationNetworks + :members: + :inherited-members: + +.. autoclass:: contextualized.easy.ContextualizedNetworks.ContextualizedMarkovNetworks + :members: + :inherited-members: + +.. autoclass:: contextualized.easy.ContextualizedNetworks.ContextualizedBayesianNetworks + :members: + :inherited-members: diff --git a/format_style.sh b/format_style.sh new file mode 100644 index 0000000..34392c8 --- /dev/null +++ b/format_style.sh @@ -0,0 +1,2 @@ +black contextualized +pylint-badge contextualized pylint.svg \ No newline at end of file diff --git a/make_docs.sh b/make_docs.sh new file mode 100644 index 0000000..5665673 --- /dev/null +++ b/make_docs.sh @@ -0,0 +1,2 @@ +jupyter-book config sphinx docs +sphinx-build docs docs/_build/html -b html \ No newline at end of file diff --git a/pylint.svg b/pylint.svg index 4c5a61b..5fd79d6 100644 --- a/pylint.svg +++ b/pylint.svg @@ -1 +1 @@ -pylintpylint8.788.78 \ No newline at end of file +pylintpylint8.38.3 \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index ebd4865..2bf3cf2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,14 +4,14 @@ build-backend = "hatchling.build" [project] name = "contextualized-ml" -version = "0.2.6" +version = "0.2.7" authors = [ { name="Caleb Ellington", email="cellingt@cs.cmu.edu" }, { name="Ben Lengerich", email="blengeri@mit.edu" }, ] description = "A statistical machine learning toolbox for estimating models, distributions, and functions with sample-specific parameters." readme = "README.md" -requires-python = ">=3.7" +requires-python = ">=3.8" classifiers = [ "Programming Language :: Python :: 3", "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", @@ -25,19 +25,23 @@ keywords = [ "multitask learning", ] dependencies = [ - 'pytorch-lightning>=2.0.0', - 'torch', - 'torchvision', - 'numpy', - 'scikit-learn', - 'igraph', - 'dill', - 'matplotlib', + 'lightning>=2.0.0', + 'torch>=2.1.0', + 'torchvision>=0.8.0', + 'numpy>=1.19.0', + 'pandas>=2.0.0', + 'scikit-learn>=1.0.0', + 'igraph>=0.11.0', + 'dill>=0.3.3', + 'matplotlib>=3.3.0', ] [tool.setuptools.packages] find = {} # Scanning implicit namespaces is active by default +[tool.hatch.build.targets.wheel] +packages = ["contextualized"] + [project.urls] "Homepage" = "https://contextualized.ml/" "Source" = "https://github.com/cnellington/Contextualized/" diff --git a/website/css/style.css b/website/css/style.css index 18b3333..e62edf3 100644 --- a/website/css/style.css +++ b/website/css/style.css @@ -7,13 +7,25 @@ h1 { font-family: Arial, sans-serif; font-style: normal; font-weight: bold; - font-size: 52px; + font-size: 42px; line-height: 45px; color: #FFFFFF; letter-spacing: 0.02em; -moz-osx-font-smoothing: grayscale; -webkit-font-smoothing: antialiased; } +@media (min-width: 768px) { + h1 { + font-size: 52px; + line-height: 68px; + } +} +@media (max-width: 400px) { + h1 { + font-size: 28px; + line-height: 30px; + } +} h2 { font-family: Arial, sans-serif; font-style: normal; @@ -25,6 +37,12 @@ h2 { -moz-osx-font-smoothing: grayscale; -webkit-font-smoothing: antialiased; } +@media (max-width: 400px) { + h2 { + font-size: 30px; + line-height: 36px; + } +} h3 { font-family: Arial, sans-serif; font-style: normal; @@ -36,6 +54,12 @@ h3 { -moz-osx-font-smoothing: grayscale; -webkit-font-smoothing: antialiased; } +@media (max-width: 400px) { + h2 { + font-size: 22px; + line-height: 24px; + } +} h4 { font-family: Arial, sans-serif; font-style: normal; diff --git a/website/index.html b/website/index.html index 3f5f6a5..45e8975 100644 --- a/website/index.html +++ b/website/index.html @@ -3,10 +3,10 @@ - Contextualized.ML + Contextualized ML - + @@ -50,8 +50,8 @@ Contextualized Logo
-

Contextualized.ML

-

A statistical machine learning toolbox for estimating models, distributions, and functions with context-specific parameters.

+

Contextualized ML

+

An easy-to-use machine learning toolbox for estimating models, distributions, and functions with context-specific parameters.

@@ -114,7 +114,7 @@

Contextualized.ML

-

Why ContextualizedML?

+

Why Contextualized ML?

@@ -228,19 +228,19 @@

Model Types

-
+

Contextualized Regression

Do the features which predict an outcome change from sample to sample?

-
+

Contextualized Bayesian Networks

Does the joint distribution of features change from sample to sample?

-
+

Contextualized Correlation

Do the correlations between features change from sample to sample?

@@ -319,7 +319,7 @@

Feature Impact

-

What You Can Do With ContextualizedML

+

What You Can Do With Contextualized ML

@@ -350,7 +350,7 @@

Connect Heterogeneity to Outcomes
-

Who Can Benefit from Contextualized.ML?

+

Who Can Benefit from Contextualized ML?

@@ -386,7 +386,7 @@

ML Researchers

Getting Started

- Install ContextualizedML + Install Contextualized ML
@@ -400,7 +400,7 @@

Getting Started

-

Contribute to ContextualizedML

+

Contribute to Contextualized ML

We encourage you to join the effort and contribute feedback, algorithms, ideas and more, so we can improve the toolkit together!

Contribute
@@ -422,12 +422,12 @@

Contribute to ContextualizedML

Resources

-

Learn More About Contextualized.ML

+

Learn More About Contextualized ML

-

Contextualized.ML documentation

+

Contextualized ML documentation

 -

Contextualized.ML for Biology

+

Contextualized ML for Biology