diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb new file mode 100644 index 0000000..17b64db --- /dev/null +++ b/notebooks/example.ipynb @@ -0,0 +1,782 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "#import deepdiagonstics\n", + "import models\n", + "import data\n", + "from utils.config import Config\n", + "from utils.register import register_simulator\n", + "\n", + "from plots import CDFRanks, CoverageFraction, Ranks, TARP, LocalTwoSampleTest\n", + "\n", + "import yaml\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction to DeepDiagnostics \n", + "\n", + "DeepDiagnostics is a command-line utility for running simulation-based inference (sbi) methods. \n", + "It works primarily by interacting with a yaml file to overwrite defaults and specify what diagnostics to run and how." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Configuration \n", + "\n", + "The configuration files controls most of DeepDiagnostics. \n", + "It is broken into 7 parts. \n", + "* Common\n", + "\n", + "This controls things like the paths of results, where the simulations are registered, and the random seed. \n", + "\n", + "* Model \n", + "\n", + "Specify the path and backend for running model inference. \n", + "\n", + "* Data \n", + "\n", + "Specify the prior, simulation, data file, and way to read the data file. \n", + "\n", + "* Plots Common \n", + "\n", + "Default parameters all plots use unless otherwise specified. \n", + "\n", + "* Metrics Common \n", + "\n", + "Default parameters all metrics use unless otherwise specified.\n", + "\n", + "* Plots \n", + "\n", + "Dictionary of all the plots to generate. Each field of the dictionary is the name of plot and their corresponding `kwargs`. \n", + "\n", + "* Metrics \n", + "\n", + "Same concept as plots! \n", + "\n", + "### Defaults \n", + "The defaults for these fields are as follows: " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'common': {'out_dir': './DeepDiagnosticsResources/results/',\n", + " 'temp_config': './DeepDiagnosticsResources/temp/temp_config.yml',\n", + " 'sim_location': 'DeepDiagnosticsResources/simulators',\n", + " 'random_seed': 42},\n", + " 'model': {'model_engine': 'SBIModel'},\n", + " 'data': {'data_engine': 'H5Data',\n", + " 'prior': 'normal',\n", + " 'prior_kwargs': None,\n", + " 'simulator_kwargs': None},\n", + " 'plots_common': {'axis_spines': False,\n", + " 'tight_layout': True,\n", + " 'default_colorway': 'viridis',\n", + " 'plot_style': 'fast',\n", + " 'parameter_labels': ['$m$', '$b$'],\n", + " 'parameter_colors': ['#9C92A3', '#0F5257'],\n", + " 'line_style_cycle': ['-', '-.'],\n", + " 'figure_size': [6, 6]},\n", + " 'plots': {'CDFRanks': {},\n", + " 'Ranks': {'num_bins': None},\n", + " 'CoverageFraction': {},\n", + " 'TARP': {'coverage_sigma': 3}},\n", + " 'metrics_common': {'use_progress_bar': False,\n", + " 'samples_per_inference': 1000,\n", + " 'percentiles': [75, 85, 95],\n", + " 'number_simulations': 50},\n", + " 'metrics': {'AllSBC': {}, 'CoverageFraction': {}}}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from utils.defaults import Defaults\n", + "Defaults" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running DeepDiagnostics \n", + "\n", + "Operation has two main modes: Either add command line arguments for key fields or specify a whole new configuration file. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "usage: diagnose [-h] [--config CONFIG] [--model_path MODEL_PATH]\n", + " [--model_engine {SBIModel}] [--data_path DATA_PATH]\n", + " [--data_engine {H5Data,PickleData}] [--simulator SIMULATOR]\n", + " [--out_dir OUT_DIR]\n", + " [--metrics {CoverageFraction,AllSBC} [{CoverageFraction,AllSBC} ...]]\n", + " [--plots {CDFRanks,CoverageFraction,Ranks,TARP} [{CDFRanks,CoverageFraction,Ranks,TARP} ...]]\n", + "\n", + "options:\n", + " -h, --help show this help message and exit\n", + " --config CONFIG, -c CONFIG\n", + " --model_path MODEL_PATH, -m MODEL_PATH\n", + " --model_engine {SBIModel}, -e {SBIModel}\n", + " --data_path DATA_PATH, -d DATA_PATH\n", + " --data_engine {H5Data,PickleData}, -g {H5Data,PickleData}\n", + " --simulator SIMULATOR, -s SIMULATOR\n", + " --out_dir OUT_DIR\n", + " --metrics {CoverageFraction,AllSBC} [{CoverageFraction,AllSBC} ...]\n", + " --plots {CDFRanks,CoverageFraction,Ranks,TARP} [{CDFRanks,CoverageFraction,Ranks,TARP} ...]\n" + ] + } + ], + "source": [ + "! diagnose -h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using a simulator\n", + "\n", + "In order to run the models, you must supply a simulator. \n", + "Simulators are all subclasses of `data.Simulator`, and need to be registered with `register_simulator` to use during runtime. \n", + "\n", + "`data.Simulator` is an abstract class that requires a `generate_context` \n", + "(which takes a number of samples and returns a random sample of context the simulator uses to produce results. \n", + "This can either be loaded in from a specific file, or a random distribution.) \n", + "and `simulate` method \n", + "(which takes a context and parameters of the model )\n", + "See below for an example with typing, simulating a 2d case where the model being fit is a linear model. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting my_simulator.py\n" + ] + } + ], + "source": [ + "%%writefile my_simulator.py \n", + "\n", + "from utils.register import register_simulator\n", + "from data.simulator import Simulator\n", + "import numpy as np \n", + "\n", + "class MySimulator(Simulator): \n", + " def generate_context(self, n_samples: int=101) -> np.ndarray:\n", + " return np.linspace(0, 100, n_samples)\n", + " \n", + " def simulate(self, theta: np.ndarray, context_samples: np.ndarray) -> np.ndarray:\n", + " thetas = np.atleast_2d(theta)\n", + " if thetas.shape[1] != 2:\n", + " raise ValueError(\"Input tensor must have shape (n, 2) where n is the number of parameter sets.\")\n", + "\n", + " if thetas.shape[0] == 1:\n", + " # If there's only one set of parameters, extract them directly\n", + " m, b = thetas[0, 0], thetas[0, 1]\n", + " else:\n", + " # If there are multiple sets of parameters, extract them for each row\n", + " m, b = thetas[:, 0], thetas[:, 1]\n", + " rs = np.random.RandomState()\n", + " sigma = 1\n", + " epsilon = rs.normal(loc=0, scale=sigma, size=(len(context_samples), thetas.shape[0]))\n", + " \n", + " # Initialize an empty array to store the results for each set of parameters\n", + " y = np.zeros((len(context_samples), thetas.shape[0]))\n", + " for i in range(thetas.shape[0]):\n", + " m, b = thetas[i, 0], thetas[i, 1]\n", + " y[:, i] = m * context_samples + b + epsilon[:, i]\n", + " return y.T" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Just running the file to make sure we're not either missing imports or have a syntax error\n", + "! python3 my_simulator.py" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Cannot load config from environment. Hint: Have you set the config path by passing a str path to Config?\n" + ] + } + ], + "source": [ + "from my_simulator import MySimulator\n", + "\n", + "register_simulator(\"MySimulator\", MySimulator) \n", + "# We are registering without having a config set ahead of time, so it may raise a warning. This is fine!\n", + "# Only reason we'd want to use a config ahead of time is if we were running this in a cluster \n", + "# And had specific requirements where we can put files \n", + "# In which case we'd change the \"common\":{\"sim_location\": } field" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "my_config = {\n", + " \"model\": {\"model_path\": \"../resources/savedmodels/sbi/sbi_linear_from_data.pkl\"}, \n", + " \"data\": {\n", + " \"data_path\": \"../resources/saveddata/data_validation.h5\", \n", + " \"simulator\": \"MySimulator\"}, \n", + " \"metrics_common\": {\n", + " \"use_progress_bar\": True,\n", + " \"samples_per_inference\": 1000,\n", + " \"percentiles\": [75, 85, 95],\n", + " \"number_simulations\": 50}, \n", + " \"metrics\": {},\n", + " \"plots\":{}\n", + "}\n", + "with open(\"./my_config.yaml\", \"w\") as f: \n", + " yaml.safe_dump(my_config, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Because nothing is set in the metrics or plots in the above config, nothing will run. \n", + "! diagnose --config ./my_config.yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# We can do a similar thing by passing specific kwargs \n", + "# Here we're just calculating the coverage fraction \n", + "! diagnose --model_path ../resources/savedmodels/sbi/sbi_linear_from_data.pkl --data_path ../resources/saveddata/data_validation.h5 --simulator MySimulator --metrics CoverageFraction --plots CoverageFraction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This produces a image of the coverage fraction from our model and data, shown below. \n", + "\n", + "\"Coverage" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using standalone functions \n", + "\n", + "DeepDiagnostics, if you have a configuration file set, can also be used with just the functions. Below is a list of all the functions and examples of their use. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "# All metrics require a model and data \n", + "Config(\"./my_config.yaml\")\n", + "\n", + "model = models.SBIModel(\"../resources/savedmodels/sbi/sbi_linear_from_data.pkl\")\n", + "data = data.H5Data(\"../resources/saveddata/data_validation.h5\", simulator=\"MySimulator\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/cdf_ranks.py:44: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " thetas = tensor(self.data.get_theta_true())\n", + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/cdf_ranks.py:45: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " context = tensor(self.data.true_context())\n", + "Running 10000 sbc samples.: 100%|██████████| 10000/10000 [01:42<00:00, 97.72it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot = CDFRanks(model, data, save=False, show=True)()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling from the posterior for each observation: 10000observation [01:44, 96.00observation/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot = CoverageFraction(model, data, show=True, save=False)()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/ranks.py:16: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " thetas = tensor(self.data.get_theta_true())\n", + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/ranks.py:17: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " context = tensor(self.data.true_context())\n", + "Running 10000 sbc samples.: 100%|██████████| 10000/10000 [01:39<00:00, 100.20it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Ranks(model, data, show=True, save=False)()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:00<00:00, 759.05it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "TARP(model, data, save=False, show=True)(\n", + " coverage_sigma=5, bootstrap_calculation=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "LocalTwoSampleTest(model, data, save=False, show=True)()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Replicating with command line interface\n", + "\n", + "To do the same thing with the CLI, just supply a config file with the metrics listed" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "my_config = {\n", + " \"model\": {\"model_path\": \"../resources/savedmodels/sbi/sbi_linear_from_data.pkl\"}, \n", + " \"data\": {\n", + " \"data_path\": \"../resources/saveddata/data_validation.h5\", \n", + " \"simulator\": \"MySimulator\"}, \n", + " \"metrics_common\": {\n", + " \"use_progress_bar\": True,\n", + " \"samples_per_inference\": 1000,\n", + " \"percentiles\": [75, 85, 95],\n", + " \"number_simulations\": 50}, \n", + " \"metrics\": {},\n", + " \"plots\":{\n", + " \"LC2ST\":{}, \n", + " \"TARP\":{\"coverage_sigma\":5, \"bootstrap_calculation\":True}, \n", + " \"Ranks\":{}, \n", + " \"CoverageFraction\":{}, \n", + " \"CDFRanks\":{}\n", + " }\n", + "}\n", + "with open(\"./my_full_config.yaml\", \"w\") as f: \n", + " yaml.safe_dump(my_config, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/cdf_ranks.py:31: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " thetas = tensor(self.data.get_theta_true())\n", + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/cdf_ranks.py:32: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " context = tensor(self.data.true_context())\n", + "Running 10000 sbc samples.: 100%|█████████| 10000/10000 [01:40<00:00, 99.17it/s]\n", + "Sampling from the posterior for each observation: 10000 observation [01:44, 95.86 observation/s]\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/Library/Caches/pypoetry/virtualenvs/deepdiagnostics-081AeCAa-py3.10/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/plot.py:75: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n", + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/ranks.py:32: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " thetas = tensor(self.data.get_theta_true())\n", + "/Users/maggiev-local/repo/DeepDiagnostics/src/plots/ranks.py:33: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " context = tensor(self.data.true_context())\n", + "Running 10000 sbc samples.: 100%|████████| 10000/10000 [01:39<00:00, 100.83it/s]\n", + "100%|████████████████████████████████████████| 100/100 [00:00<00:00, 555.41it/s]\n" + ] + } + ], + "source": [ + "! diagnose --config ./my_full_config.yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['coverage_fraction.png',\n", + " 'local_c2st_corner_plot.png',\n", + " 'local_c2st_pp_plot.png',\n", + " 'cdf_ranks.png',\n", + " 'tarp.png',\n", + " 'diagnostic_metrics.json',\n", + " 'ranks.png']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os \n", + "os.listdir(\"./DeepDiagnosticsResources/results\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "deepdiagnostics-081AeCAa-py3.10", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/client/client.py b/src/client/client.py index 063b1d3..147bdf4 100644 --- a/src/client/client.py +++ b/src/client/client.py @@ -38,7 +38,7 @@ def parser(): # List of metrics (cannot supply specific kwargs) parser.add_argument( "--metrics", - nargs="+", + nargs="?", default=list(Defaults["metrics"].keys()), choices=Metrics.keys(), ) @@ -46,7 +46,7 @@ def parser(): # List of plots parser.add_argument( "--plots", - nargs="+", + nargs="?", default=list(Defaults["plots"].keys()), choices=Plots.keys(), ) diff --git a/src/data/data.py b/src/data/data.py index 129877d..683c2bb 100644 --- a/src/data/data.py +++ b/src/data/data.py @@ -4,7 +4,7 @@ import numpy as np from utils.config import get_item - +from utils.register import load_simulator class Data: def __init__( @@ -19,44 +19,10 @@ def __init__( get_item("common", "random_seed", raise_exception=False) ) self.data = self._load(path) - self.simulator = self._load_simulator(simulator_name, simulator_kwargs) + self.simulator = load_simulator(simulator_name, simulator_kwargs) self.prior_dist = self.load_prior(prior, prior_kwargs) self.n_dims = self.get_theta_true().shape[1] - def _load_simulator(self, name, simulator_kwargs): - try: - sim_location = get_item("common", "sim_location", raise_exception=False) - simulator_path = os.environ[f"{sim_location}:{name}"] - except KeyError as e: - raise RuntimeError( - f"Simulator cannot be found using env var {e}. Hint: have you registered your simulation with utils.register_simulator?" - ) - - new_class = os.path.dirname(simulator_path) - sys.path.insert(1, new_class) - - # TODO robust error checks - module_name = os.path.basename(simulator_path.rstrip(".py")) - m = importlib.import_module(module_name) - - simulator = getattr(m, name) - - simulator_kwargs = simulator_kwargs if simulator_kwargs is not None else get_item("data", "simulator_kwargs", raise_exception=False) - simulator_kwargs = {} if simulator_kwargs is None else simulator_kwargs - simulator_instance = simulator(**simulator_kwargs) - - if not hasattr(simulator_instance, "generate_context"): - raise RuntimeError( - "Simulator improperly formed - requires a generate_context method." - ) - - if not hasattr(simulator_instance, "simulate"): - raise RuntimeError( - "Simulator improperly formed - requires a simulate method." - ) - - return simulator_instance - def _load(self, path: str): raise NotImplementedError diff --git a/src/metrics/__init__.py b/src/metrics/__init__.py index 6d58c90..9bb6fe9 100644 --- a/src/metrics/__init__.py +++ b/src/metrics/__init__.py @@ -1,4 +1,9 @@ from metrics.all_sbc import AllSBC from metrics.coverage_fraction import CoverageFraction +from metrics.local_two_sample import LocalTwoSampleTest -Metrics = {CoverageFraction.__name__: CoverageFraction, AllSBC.__name__: AllSBC} +Metrics = { + CoverageFraction.__name__: CoverageFraction, + AllSBC.__name__: AllSBC, + "LC2ST": LocalTwoSampleTest +} diff --git a/src/metrics/all_sbc.py b/src/metrics/all_sbc.py index 8193f68..e33a230 100644 --- a/src/metrics/all_sbc.py +++ b/src/metrics/all_sbc.py @@ -1,4 +1,4 @@ -from typing import Any +from typing import Any, Optional, Sequence from torch import tensor from sbi.analysis import run_sbc, check_sbc @@ -12,16 +12,19 @@ def __init__( model: Any, data: Any, out_dir: str | None = None, - samples_per_inference=None, + save: bool=True, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + percentiles: Optional[Sequence[int]] = None, + number_simulations: Optional[int] = None, ) -> None: - super().__init__(model, data, out_dir) - - if samples_per_inference is None: - self.samples_per_inference = get_item( - "metrics_common", "samples_per_inference", raise_exception=False - ) - else: - self.samples_per_inference = samples_per_inference + + super().__init__(model, data, out_dir, + save, + use_progress_bar, + samples_per_inference, + percentiles, + number_simulations) def _collect_data_params(self): self.thetas = tensor(self.data.get_theta_true()) @@ -41,7 +44,7 @@ def calculate(self): dap_samples, num_posterior_samples=self.samples_per_inference, ) - self.output = sbc_stats + self.output = {key: value.numpy().tolist() for key, value in sbc_stats.items()} return sbc_stats def __call__(self, **kwds: Any) -> Any: diff --git a/src/metrics/coverage_fraction.py b/src/metrics/coverage_fraction.py index 72c1df2..24c494a 100644 --- a/src/metrics/coverage_fraction.py +++ b/src/metrics/coverage_fraction.py @@ -1,7 +1,7 @@ import numpy as np from torch import tensor from tqdm import tqdm -from typing import Any +from typing import Any, Optional, Sequence from metrics.metric import Metric from utils.config import get_item @@ -14,32 +14,22 @@ def __init__( self, model: Any, data: Any, - out_dir: str | None = None, - samples_per_inference=None, - percentiles=None, - progress_bar: bool = None, + out_dir: Optional[str] = None, + save: bool=True, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + percentiles: Optional[Sequence[int]] = None, + number_simulations: Optional[int] = None, ) -> None: - super().__init__(model, data, out_dir) + + super().__init__(model, data, out_dir, + save, + use_progress_bar, + samples_per_inference, + percentiles, + number_simulations) self._collect_data_params() - self.samples_per_inference = ( - samples_per_inference - if samples_per_inference is not None - else get_item( - "metrics_common", "samples_per_inference", raise_exception=False - ) - ) - self.percentiles = ( - percentiles - if percentiles is not None - else get_item("metrics_common", "percentiles", raise_exception=False) - ) - self.progress_bar = ( - progress_bar - if progress_bar is not None - else get_item("metrics_common", "use_progress_bar", raise_exception=False) - ) - def _collect_data_params(self): self.thetas = self.data.get_theta_true() self.context = self.data.true_context() @@ -54,11 +44,11 @@ def calculate(self): ) count_array = [] iterator = enumerate(self.context) - if self.progress_bar: + if self.use_progress_bar: iterator = tqdm( iterator, desc="Sampling from the posterior for each observation", - unit="observation", + unit=" observation", ) for y_sample_index, y_sample in iterator: samples = self._run_model_inference(self.samples_per_inference, y_sample) diff --git a/src/metrics/local_two_sample.py b/src/metrics/local_two_sample.py index 4ed1b4f..f82a6fb 100644 --- a/src/metrics/local_two_sample.py +++ b/src/metrics/local_two_sample.py @@ -1,4 +1,4 @@ -from typing import Any, Optional, Union +from typing import Any, Optional, Sequence, Union import numpy as np from sklearn.model_selection import KFold @@ -6,33 +6,53 @@ from sklearn.utils import shuffle from metrics.metric import Metric -from utils.config import get_item class LocalTwoSampleTest(Metric): - def __init__(self, model: Any, data: Any, out_dir: str | None = None, num_simulations: Optional[int] = None) -> None: - super().__init__(model, data, out_dir) - self.num_simulations = num_simulations if num_simulations is not None else get_item( - "metrics_common", "number_simulations", raise_exception=False + def __init__( + self, + model: Any, + data: Any, + out_dir: Optional[str] = None, + save: bool=True, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + percentiles: Optional[Sequence[int]] = None, + number_simulations: Optional[int] = None, + ) -> None: + + super().__init__( + model, + data, + out_dir, + save, + use_progress_bar, + samples_per_inference, + percentiles, + number_simulations ) + def _collect_data_params(self): # P is the prior and x_P is generated via the simulator from the parameters P. - self.p = self.data.sample_prior(self.num_simulations) + self.p = self.data.sample_prior(self.number_simulations) self.q = np.zeros_like(self.p) - self.outcome_given_p = np.zeros((self.num_simulations, self.data.simulator.generate_context().shape[-1])) + context_size = self.data.true_context().shape[-1] + self.outcome_given_p = np.zeros( + (self.number_simulations, context_size) + ) self.outcome_given_q = np.zeros_like(self.outcome_given_p) self.evaluation_context = np.zeros_like(self.outcome_given_p) for index, p in enumerate(self.p): - context = self.data.simulator.generate_context() + context = self.data.simulator.generate_context(context_size) self.outcome_given_p[index] = self.data.simulator.simulate(p, context) # Q is the approximate posterior amortized in x q = self.model.sample_posterior(1, context).ravel() self.q[index] = q self.outcome_given_q[index] = self.data.simulator.simulate(q, context) - self.evaluation_context = np.array([self.data.simulator.generate_context() for _ in range(self.num_simulations)]) + self.evaluation_context = np.array([self.data.simulator.generate_context(context_size) for _ in range(self.number_simulations)]) def train_linear_classifier(self, p, q, x_p, x_q, classifier:str, classifier_kwargs:dict={}): classifier_map = { @@ -162,8 +182,8 @@ def calculate( null = np.array(null_hypothesis_probabilities) self.output = { - "lc2st_probabilities": probabilities, - "lc2st_null_hypothesis_probabilities": null + "lc2st_probabilities": probabilities.tolist(), + "lc2st_null_hypothesis_probabilities": null.tolist() } return probabilities, null diff --git a/src/metrics/metric.py b/src/metrics/metric.py index 0612b46..b92413b 100644 --- a/src/metrics/metric.py +++ b/src/metrics/metric.py @@ -1,19 +1,37 @@ -from typing import Any, Optional +from typing import Any, Optional, Sequence import json import os from data import data from models import model +from utils.config import get_item class Metric: - def __init__(self, model: model, data: data, out_dir: Optional[str] = None) -> None: + def __init__( + self, + model: model, + data: data, + out_dir: Optional[str] = None, + save: bool=True, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + percentiles: Optional[Sequence[int]] = None, + number_simulations: Optional[int] = None, + ) -> None: self.model = model self.data = data - self.out_dir = out_dir + if save: + self.out_dir = out_dir if out_dir is not None else get_item("common", "out_dir", raise_exception=False) + self.output = None + self.use_progress_bar = use_progress_bar if use_progress_bar is not None else get_item("metrics_common", "use_progress_bar", raise_exception=False) + self.samples_per_inference = samples_per_inference if samples_per_inference is not None else get_item("metrics_common", "samples_per_inference", raise_exception=False) + self.percentiles = percentiles if percentiles is not None else get_item("metrics_common", "percentiles", raise_exception=False) + self.number_simulations = number_simulations if number_simulations is not None else get_item("metrics_common", "number_simulations", raise_exception=False) + def _collect_data_params(): raise NotImplementedError @@ -29,17 +47,29 @@ def _finish(self): ), "Calculation has not been completed, have you run Metric.calculate?" if self.out_dir is not None: - if not os.path.exists(os.path.dirname(self.out_dir)): - os.makedirs(os.path.dirname(self.out_dir)) + if not os.path.exists(self.out_dir): + os.makedirs(self.out_dir) + + with open(f"{self.out_dir.rstrip('/')}/diagnostic_metrics.json", "w+") as f: + try: + data = json.load(f) + except json.decoder.JSONDecodeError: + data = {} - with open(self.out_dir) as f: - data = json.load(f) data.update(self.output) json.dump(data, f, ensure_ascii=True) f.close() def __call__(self, **kwds: Any) -> Any: - self._collect_data_params() - self._run_model_inference() + + try: + self._collect_data_params() + except NotImplementedError: + pass + try: + self._run_model_inference() + except NotImplementedError: + pass + self.calculate(kwds) self._finish() diff --git a/src/plots/__init__.py b/src/plots/__init__.py index f576bd7..d92e0b2 100644 --- a/src/plots/__init__.py +++ b/src/plots/__init__.py @@ -2,10 +2,12 @@ from plots.coverage_fraction import CoverageFraction from plots.ranks import Ranks from plots.tarp import TARP +from plots.local_two_sample import LocalTwoSampleTest Plots = { CDFRanks.__name__: CDFRanks, CoverageFraction.__name__: CoverageFraction, Ranks.__name__: Ranks, TARP.__name__: TARP, + "LC2ST": LocalTwoSampleTest } diff --git a/src/plots/cdf_ranks.py b/src/plots/cdf_ranks.py index 62b7a20..668b977 100644 --- a/src/plots/cdf_ranks.py +++ b/src/plots/cdf_ranks.py @@ -1,41 +1,28 @@ +from typing import Optional, Sequence from sbi.analysis import sbc_rank_plot, run_sbc from torch import tensor from plots.plot import Display -from utils.config import get_item class CDFRanks(Display): def __init__( - self, - model, - data, - save: bool, - show: bool, - out_dir: str | None = None, - samples_per_inference=None, - parameter_colors=None, - parameter_labels=None, + self, + model, + data, + save:bool, + show:bool, + out_dir:Optional[str]=None, + percentiles: Optional[Sequence] = None, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + number_simulations: Optional[int] = None, + parameter_names: Optional[Sequence] = None, + parameter_colors: Optional[Sequence]= None, + colorway: Optional[str]=None ): - super().__init__(model, data, save, show, out_dir) - - self.num_samples = ( - samples_per_inference - if samples_per_inference is not None - else get_item( - "metrics_common", "samples_per_inference", raise_exception=False - ) - ) - self.colors = ( - parameter_colors - if parameter_colors is not None - else get_item("plots_common", "parameter_colors", raise_exception=False) - ) - self.labels = ( - parameter_labels - if parameter_labels is not None - else get_item("plots_common", "parameter_labels", raise_exception=False) - ) + + super().__init__(model, data, save, show, out_dir, percentiles, use_progress_bar, samples_per_inference, number_simulations, parameter_names, parameter_colors, colorway) def _plot_name(self): return "cdf_ranks.png" @@ -45,7 +32,7 @@ def _data_setup(self): context = tensor(self.data.true_context()) ranks, _ = run_sbc( - thetas, context, self.model.posterior, num_posterior_samples=self.num_samples + thetas, context, self.model.posterior, num_posterior_samples=self.samples_per_inference ) self.ranks = ranks @@ -55,8 +42,8 @@ def _plot_settings(self): def _plot(self): sbc_rank_plot( self.ranks, - self.num_samples, + self.samples_per_inference, plot_type="cdf", - parameter_labels=self.labels, - colors=self.colors, + parameter_labels=self.parameter_names, + colors=self.parameter_colors, ) diff --git a/src/plots/coverage_fraction.py b/src/plots/coverage_fraction.py index bbfe293..b8eb8a4 100644 --- a/src/plots/coverage_fraction.py +++ b/src/plots/coverage_fraction.py @@ -1,6 +1,6 @@ +from typing import Optional, Sequence import numpy as np import matplotlib.pyplot as plt -from matplotlib import colormaps as cm from metrics.coverage_fraction import CoverageFraction as coverage_fraction_metric from plots.plot import Display @@ -9,42 +9,25 @@ class CoverageFraction(Display): def __init__( - self, - model, - data, - save: bool, - show: bool, - out_dir: str | None = None, - parameter_labels=None, - figure_size=None, - line_styles=None, - parameter_colors=None + self, + model, + data, + save:bool, + show:bool, + out_dir:Optional[str]=None, + percentiles: Optional[Sequence] = None, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + number_simulations: Optional[int] = None, + parameter_names: Optional[Sequence] = None, + parameter_colors: Optional[Sequence]= None, + colorway: Optional[str]=None ): - super().__init__(model, data, save, show, out_dir) - - self.labels = ( - parameter_labels - if parameter_labels is not None - else get_item("plots_common", "parameter_labels", raise_exception=False) - ) - self.colors = ( - parameter_colors - if parameter_colors is not None - else get_item("plots_common", "parameter_colors", raise_exception=False) - ) - self.n_parameters = len(self.labels) - self.figure_size = ( - figure_size - if figure_size is not None - else tuple(get_item("plots_common", "figure_size", raise_exception=False)) - ) - self.line_cycle = ( - line_styles - if line_styles is not None - else tuple( - get_item("plots_common", "line_style_cycle", raise_exception=False) - ) - ) + + super().__init__(model, data, save, show, out_dir, percentiles, use_progress_bar, samples_per_inference, number_simulations, parameter_names, parameter_colors, colorway) + + self.n_parameters = len(self.parameter_names) + self.line_cycle = tuple(get_item("plots_common", "line_style_cycle", raise_exception=False)) def _plot_name(self): return "coverage_fraction.png" @@ -55,9 +38,6 @@ def _data_setup(self): ).calculate() self.coverage_fractions = coverage - def _plot_settings(self): - pass - def _plot( self, figure_alpha=1.0, @@ -71,7 +51,7 @@ def _plot( ): n_steps = self.coverage_fractions.shape[0] percentile_array = np.linspace(0, 1, n_steps) - color_cycler = iter(plt.cycler("color", self.colors)) + color_cycler = iter(plt.cycler("color", self.parameter_colors)) line_style_cycler = iter(plt.cycler("line_style", self.line_cycle)) # Plotting @@ -89,7 +69,7 @@ def _plot( lw=line_width, linestyle=line_style, color=color, - label=self.labels[i], + label=self.parameter_names[i], ) ax.plot( diff --git a/src/plots/local_two_sample.py b/src/plots/local_two_sample.py index 0735d39..8014b90 100644 --- a/src/plots/local_two_sample.py +++ b/src/plots/local_two_sample.py @@ -7,41 +7,31 @@ from plots.plot import Display from metrics.local_two_sample import LocalTwoSampleTest as l2st -from utils.config import get_item from utils.plotting_utils import get_hex_colors class LocalTwoSampleTest(Display): # https://github.com/JuliaLinhart/lc2st/blob/e221cc326480cb0daadfd2ba50df4eefd374793b/lc2st/graphical_diagnostics.py#L133 - def __init__(self, - model, - data, - save:bool, - show:bool, - out_dir:Optional[str]=None, - percentiles: Optional[Sequence] = None, - parameter_names: Optional[Sequence] = None, - parameter_colors: Optional[Sequence]= None, - figure_size: Optional[Sequence] = None, - num_simulations: Optional[int] = None, - colorway: Optional[str]=None): - super().__init__(model, data, save, show, out_dir) - self.percentiles = percentiles if percentiles is not None else get_item("metrics_common", item='percentiles', raise_exception=False) - - self.param_names = parameter_names if parameter_names is not None else get_item("plots_common", item="parameter_labels", raise_exception=False) - self.param_colors = parameter_colors if parameter_colors is not None else get_item("plots_common", item="parameter_colors", raise_exception=False) - self.figure_size = figure_size if figure_size is not None else get_item("plots_common", item="figure_size", raise_exception=False) - - colorway = colorway if colorway is not None else get_item( - "plots_common", "default_colorway", raise_exception=False - ) - self.region_colors = get_hex_colors(n_colors=len(self.percentiles), colorway=colorway) - - num_simulations = num_simulations if num_simulations is not None else get_item( - "metrics_common", "number_simulations", raise_exception=False - ) - self.l2st = l2st(model, data, out_dir, num_simulations) + def __init__( + self, + model, + data, + save:bool, + show:bool, + out_dir:Optional[str]=None, + percentiles: Optional[Sequence] = None, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + number_simulations: Optional[int] = None, + parameter_names: Optional[Sequence] = None, + parameter_colors: Optional[Sequence]= None, + colorway: Optional[str]=None + ): + + super().__init__(model, data, save, show, out_dir, percentiles, use_progress_bar, samples_per_inference, number_simulations, parameter_names, parameter_colors, colorway) + self.region_colors = get_hex_colors(n_colors=len(self.percentiles), colorway=self.colorway) + self.l2st = l2st(model, data, out_dir, True, self.use_progress_bar, self.samples_per_inference, self.percentiles, self.number_simulations) def _plot_name(self): return "local_C2ST.png" @@ -76,7 +66,7 @@ def lc2st_pairplot(self, subplot, confidence_region_alpha=0.2): label=f"{percentile}% Conf. region", ) - for prob, label, color in zip(self.probability, self.param_names, self.param_colors): + for prob, label, color in zip(self.probability, self.parameter_names, self.parameter_colors): pairplot_values = self._make_pairplot_values(prob) subplot.plot(self.cdf_alphas, pairplot_values, label=label, color=color) @@ -94,7 +84,7 @@ def probability_intensity(self, subplot, features, n_bins=20): int(features) _, bins, patches = subplot.hist( - evaluation_data[:,features], n_bins, weights=self.probability, density=True, color=self.param_colors[features]) + evaluation_data[:,features], n_bins, weights=self.probability, density=True, color=self.parameter_colors[features]) eval_bins = np.select( [evaluation_data[:,features] <= i for i in bins[1:]], list(range(n_bins)) @@ -173,13 +163,14 @@ def _plot(self, # pp_plot_lc2st: https://github.com/JuliaLinhart/lc2st/blob/e221cc326480cb0daadfd2ba50df4eefd374793b/lc2st/graphical_diagnostics.py#L49 # eval_space_with_proba_intensity: https://github.com/JuliaLinhart/lc2st/blob/e221cc326480cb0daadfd2ba50df4eefd374793b/lc2st/graphical_diagnostics.py#L133 - self.l2st(**{ - "linear_classifier":linear_classifier, - "cross_evaluate": cross_evaluate, - "n_null_hypothesis_trials": n_null_hypothesis_trials, - "classifier_kwargs": classifier_kwargs}) + self.l2st._collect_data_params() + self.probability, self.null_hypothesis_probability = self.l2st.calculate( + linear_classifier=linear_classifier, + cross_evaluate=cross_evaluate, + n_null_hypothesis_trials = n_null_hypothesis_trials, + classifier_kwargs = classifier_kwargs + ) - self.probability, self.null_hypothesis_probability = self.l2st.output["lc2st_probabilities"], self.l2st.output["lc2st_null_hypothesis_probabilities"] fig, subplots = plt.subplots(1, 1, figsize=self.figure_size) self.cdf_alphas = np.linspace(0, 1, n_alpha_samples) @@ -196,10 +187,10 @@ def _plot(self, if use_intensity_plot: - fig, subplots = plt.subplots(len(self.param_names), len(self.param_names), figsize=(self.figure_size[0]*1.2, self.figure_size[1])) + fig, subplots = plt.subplots(len(self.parameter_names), len(self.parameter_names), figsize=(self.figure_size[0]*1.2, self.figure_size[1])) combos_run = [] - for x_index, x_param in enumerate(self.param_names): - for y_index, y_param in enumerate(self.param_names): + for x_index, x_param in enumerate(self.parameter_names): + for y_index, y_param in enumerate(self.parameter_names): if ({x_index, y_index} not in combos_run) and (x_index>=y_index): subplot = subplots[x_index][y_index] @@ -220,17 +211,17 @@ def _plot(self, subplots[x_index][y_index].axes.get_xaxis().set_visible(False) subplots[x_index][y_index].axes.get_yaxis().set_visible(False) - if x_index == len(self.param_names)-1: + if x_index == len(self.parameter_names)-1: subplots[x_index][y_index].set_xlabel(x_param) if y_index == 0: subplots[x_index][y_index].set_ylabel(y_param) - for index, y_label in enumerate(self.param_names): + for index, y_label in enumerate(self.parameter_names): subplots[index][0].set_ylabel(y_label) - for index, x_label in enumerate(self.param_names): - subplots[len(self.param_names)-1][-1*index].set_xlabel(x_label) + for index, x_label in enumerate(self.parameter_names): + subplots[len(self.parameter_names)-1][-1*index].set_xlabel(x_label) fig.supylabel(intensity_plot_ylabel) @@ -244,13 +235,4 @@ def _plot(self, self._finish() def __call__(self, **plot_args) -> None: - try: - self._data_setup() - except NotImplementedError: - pass - try: - self._plot_settings() - except NotImplementedError: - pass - self._plot(**plot_args) \ No newline at end of file diff --git a/src/plots/plot.py b/src/plots/plot.py index 0448800..b3abf9e 100644 --- a/src/plots/plot.py +++ b/src/plots/plot.py @@ -1,5 +1,5 @@ import os -from typing import Optional +from typing import Optional, Sequence import matplotlib.pyplot as plt from matplotlib import rcParams @@ -8,26 +8,45 @@ class Display: def __init__( - self, model, data, save: bool, show: bool, out_dir: Optional[str] = None - ): + self, + model, + data, + save:bool, + show:bool, + out_dir:Optional[str]=None, + percentiles: Optional[Sequence] = None, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + number_simulations: Optional[int] = None, + parameter_names: Optional[Sequence] = None, + parameter_colors: Optional[Sequence]= None, + colorway: Optional[str]=None + ): + self.save = save self.show = show self.data = data - self.out_path = None - if (out_dir is None) and self.save: - self.out_path = get_item("common", "out_dir", raise_exception=False) + self.use_progress_bar = use_progress_bar if use_progress_bar is not None else get_item("metrics_common", "use_progress_bar", raise_exception=False) + self.samples_per_inference = samples_per_inference if samples_per_inference is not None else get_item("metrics_common", "samples_per_inference", raise_exception=False) + self.percentiles = percentiles if percentiles is not None else get_item("metrics_common", "percentiles", raise_exception=False) + self.number_simulations = number_simulations if number_simulations is not None else get_item("metrics_common", "number_simulations", raise_exception=False) - elif self.save and (out_dir is not None): - self.out_path = out_dir + self.parameter_names = parameter_names if parameter_names is not None else get_item("plots_common", "parameter_labels", raise_exception=False) + self.parameter_colors = parameter_colors if parameter_colors is not None else get_item("plots_common", "parameter_colors", raise_exception=False) + self.colorway = colorway if colorway is not None else get_item( + "plots_common", "default_colorway", raise_exception=False + ) + + if save: + self.out_dir = out_dir if out_dir is not None else get_item("common", "out_dir", raise_exception=False) - if self.out_path is not None: - if not os.path.exists(os.path.dirname(self.out_path)): - os.makedirs(os.path.dirname(self.out_path)) + if self.out_dir is not None: + if not os.path.exists(os.path.dirname(self.out_dir)): + os.makedirs(os.path.dirname(self.out_dir)) self.model = model self._common_settings() - self._plot_settings() self.plot_name = self._plot_name() def _plot_name(self): @@ -37,10 +56,6 @@ def _data_setup(self): # Set all the vars used for the plot raise NotImplementedError - def _plot_settings(self): - # TODO Pull fom a config for specific plots - raise NotImplementedError - def _plot(self, **kwrgs): # Make the plot object with plt. raise NotImplementedError @@ -52,11 +67,7 @@ def _common_settings(self): rcParams["axes.spines.top"] = bool( get_item("plots_common", "axis_spines", raise_exception=False) ) - # Style - self.colorway = get_item( - "plots_common", "default_colorway", raise_exception=False - ) tight_layout = bool( get_item("plots_common", "tight_layout", raise_exception=False) ) @@ -65,18 +76,25 @@ def _common_settings(self): plot_style = get_item("plots_common", "plot_style", raise_exception=False) plt.style.use(plot_style) + self.figure_size = tuple(get_item("plots_common", "figure_size", raise_exception=False)) + def _finish(self): assert ( os.path.splitext(self.plot_name)[-1] != "" ), f"plot name, {self.plot_name}, is malformed. Please supply a name with an extension." - if self.save: - plt.savefig(f"{self.out_path.rstrip('/')}/{self.plot_name}") + if self.show: plt.show() - plt.cla() + if self.save: + plt.savefig(f"{self.out_dir.rstrip('/')}/{self.plot_name}") + plt.cla() def __call__(self, **plot_args) -> None: - self._data_setup() + try: + self._data_setup() + except NotImplementedError: + pass + self._plot(**plot_args) self._finish() diff --git a/src/plots/ranks.py b/src/plots/ranks.py index 050dbca..4b9dc12 100644 --- a/src/plots/ranks.py +++ b/src/plots/ranks.py @@ -1,3 +1,4 @@ +from typing import Optional, Sequence from sbi.analysis import sbc_rank_plot, run_sbc from torch import tensor @@ -6,38 +7,41 @@ class Ranks(Display): - def __init__(self, model, data, save: bool, show: bool, out_dir: str | None = None): - super().__init__(model, data, save, show, out_dir) - + def __init__( + self, + model, + data, + save:bool, + show:bool, + out_dir:Optional[str]=None, + percentiles: Optional[Sequence] = None, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + number_simulations: Optional[int] = None, + parameter_names: Optional[Sequence] = None, + parameter_colors: Optional[Sequence]= None, + colorway: Optional[str]=None + ): + + super().__init__(model, data, save, show, out_dir, percentiles, use_progress_bar, samples_per_inference, number_simulations, parameter_names, parameter_colors, colorway) + def _plot_name(self): return "ranks.png" def _data_setup(self): thetas = tensor(self.data.get_theta_true()) context = tensor(self.data.true_context()) - self.num_samples = get_item( - "metrics_common", "samples_per_inference", raise_exception=False - ) - ranks, _ = run_sbc( - thetas, context, self.model.posterior, num_posterior_samples=self.num_samples + thetas, context, self.model.posterior, num_posterior_samples=self.samples_per_inference ) self.ranks = ranks - def _plot_settings(self): - self.colors = get_item( - "plots_common", "parameter_colors", raise_exception=False - ) - self.labels = get_item( - "plots_common", "parameter_labels", raise_exception=False - ) - def _plot(self, num_bins=None): sbc_rank_plot( ranks=self.ranks, - num_posterior_samples=self.num_samples, + num_posterior_samples=self.samples_per_inference, plot_type="hist", num_bins=num_bins, - parameter_labels=self.labels, - colors=self.colors, + parameter_labels=self.parameter_names, + colors=self.parameter_colors, ) diff --git a/src/plots/tarp.py b/src/plots/tarp.py index e11c54d..038d3f7 100644 --- a/src/plots/tarp.py +++ b/src/plots/tarp.py @@ -1,5 +1,4 @@ -from typing import Optional, Union -from torch import tensor +from typing import Optional, Sequence, Union import numpy as np import tarp @@ -11,34 +10,42 @@ class TARP(Display): - def __init__(self, model, data, save: bool, show: bool, out_dir: str | None = None): - super().__init__(model, data, save, show, out_dir) - + def __init__( + self, + model, + data, + save:bool, + show:bool, + out_dir:Optional[str]=None, + percentiles: Optional[Sequence] = None, + use_progress_bar: Optional[bool] = None, + samples_per_inference: Optional[int] = None, + number_simulations: Optional[int] = None, + parameter_names: Optional[Sequence] = None, + parameter_colors: Optional[Sequence]= None, + colorway: Optional[str]=None + ): + super().__init__(model, data, save, show, out_dir, percentiles, use_progress_bar, samples_per_inference, number_simulations, parameter_names, parameter_colors, colorway) + self.line_style = get_item( + "plots_common", "line_style_cycle", raise_exception=False + ) def _plot_name(self): return "tarp.png" def _data_setup(self): self.theta_true = self.data.get_theta_true() - - samples_per_inference = get_item( - "metrics_common", "samples_per_inference", raise_exception=False - ) - num_simulations = get_item( - "metrics_common", "number_simulations", raise_exception=False - ) - n_dims = self.theta_true.shape[1] self.posterior_samples = np.zeros( - (num_simulations, samples_per_inference, n_dims) + (self.number_simulations, self.samples_per_inference, n_dims) ) - self.thetas = np.zeros((num_simulations, n_dims)) - for n in range(num_simulations): + self.thetas = np.zeros((self.number_simulations, n_dims)) + for n in range(self.number_simulations): sample_index = self.data.rng.integers(0, len(self.theta_true)) theta = self.theta_true[sample_index, :] x = self.data.true_context()[sample_index, :] self.posterior_samples[n] = self.model.sample_posterior( - samples_per_inference, x + self.samples_per_inference, x ) self.thetas[n] = theta @@ -49,13 +56,9 @@ def _plot_settings(self): "plots_common", "line_style_cycle", raise_exception=False ) - def _get_hex_sigma_colors(self, n_colors, colorway=None): - if colorway is None: - colorway = get_item( - "plots_common", "default_colorway", raise_exception=False - ) + def _get_hex_sigma_colors(self, n_colors): - cmap = plt.get_cmap(colorway) + cmap = plt.get_cmap(self.colorway) hex_colors = [] arr = np.linspace(0, 1, n_colors) for hit in arr: @@ -97,7 +100,7 @@ def _plot( ) k_sigma = range(1, coverage_sigma + 1) - colors = self._get_hex_sigma_colors(coverage_sigma, colorway=coverage_colorway) + colors = self._get_hex_sigma_colors(coverage_sigma) for sigma, color in zip(k_sigma, colors): ax.fill_between( credibility, diff --git a/src/utils/config.py b/src/utils/config.py index bc2469b..8bf2d9b 100644 --- a/src/utils/config.py +++ b/src/utils/config.py @@ -20,15 +20,19 @@ def __init__(self, config_path: Optional[str] = None) -> None: if config_path is not None: # Add it to the env vars in case we need to get it later. os.environ[self.ENV_VAR_PATH] = config_path + self.config = self._read_config(config_path) + self._validate_config() + else: # Get it from the env vars try: config_path = os.environ[self.ENV_VAR_PATH] - except KeyError: - assert False, "Cannot load config from enviroment. Hint: Have you set the config path by pasing a str path to Config?" + self.config = self._read_config(config_path) + self._validate_config() - self.config = self._read_config(config_path) - self._validate_config() + except KeyError: + print("Warning: Cannot load config from environment. Hint: Have you set the config path by passing a str path to Config?") + self.config = Defaults def _validate_config(self): # Validate common diff --git a/src/utils/defaults.py b/src/utils/defaults.py index 3e5a1ed..e227772 100644 --- a/src/utils/defaults.py +++ b/src/utils/defaults.py @@ -2,7 +2,7 @@ "common": { "out_dir": "./DeepDiagnosticsResources/results/", "temp_config": "./DeepDiagnosticsResources/temp/temp_config.yml", - "sim_location": "DeepDiagnosticsResources_Simulators", + "sim_location": "DeepDiagnosticsResources/simulators", "random_seed": 42, }, "model": {"model_engine": "SBIModel"}, @@ -29,6 +29,7 @@ "TARP": { "coverage_sigma": 3 # How many sigma to show coverage over }, + "LC2ST": {} }, "metrics_common": { "use_progress_bar": False, @@ -39,5 +40,6 @@ "metrics": { "AllSBC": {}, "CoverageFraction": {}, + "LC2ST":{} }, } diff --git a/src/utils/plotting_utils.py b/src/utils/plotting_utils.py new file mode 100644 index 0000000..dc138d6 --- /dev/null +++ b/src/utils/plotting_utils.py @@ -0,0 +1,11 @@ +import numpy as np +import matplotlib as mpl + +def get_hex_colors(n_colors:int, colorway:str): + cmap = mpl.pyplot.get_cmap(colorway) + hex_colors = [] + arr=np.linspace(0, 1, n_colors) + for hit in arr: + hex_colors.append(mpl.colors.rgb2hex(cmap(hit))) + + return hex_colors \ No newline at end of file diff --git a/src/utils/register.py b/src/utils/register.py index 9b1a438..5fcc8ff 100644 --- a/src/utils/register.py +++ b/src/utils/register.py @@ -1,11 +1,72 @@ import os import inspect +import importlib.util +import sys +import json -from utils.defaults import Defaults - +from utils.config import get_item def register_simulator(simulator_name, simulator): - simulator_prefix = Defaults["common"]["sim_location"] - env_var_name = f"{simulator_prefix}:{simulator_name}" + + simulator_config_path = get_item("common", "sim_location", raise_exception=False) + sim_paths = f"{simulator_config_path.strip('/')}/simulators.json" simulator_location = os.path.abspath(inspect.getfile(simulator)) - os.environ[env_var_name] = simulator_location + + if not os.path.exists(os.path.dirname(sim_paths)): + os.makedirs(os.path.dirname(sim_paths)) + + if not os.path.exists(sim_paths): + open(sim_paths, 'a').close() + + with open(sim_paths, "w+") as f: + try: + existing_sims = json.load(f) + except json.decoder.JSONDecodeError: + existing_sims = {} + + existing_sims[simulator_name] = simulator_location + json.dump(existing_sims, f) + + +def load_simulator(name, simulator_kwargs): + simulator_config_path = get_item("common", "sim_location", raise_exception=False) + sim_paths = f"{simulator_config_path.strip('/')}/simulators.json" + if not os.path.exists(sim_paths): + raise RuntimeError( + f"Simulator catalogue cannot be found at path {sim_paths}. Hint: have you registered your simulation with utils.register_simulator?" + ) + + with open(sim_paths, "r") as f: + paths = json.load(f) + try: + simulator_path = paths[name] + + except KeyError as e: + raise RuntimeError( + f"Simulator cannot be found using name {e}. Hint: have you registered your simulation with utils.register_simulator?" + ) + + new_class = os.path.dirname(simulator_path) + sys.path.insert(1, new_class) + + # TODO robust error checks + module_name = os.path.basename(simulator_path.rstrip(".py")) + m = importlib.import_module(module_name) + + simulator = getattr(m, name) + + simulator_kwargs = simulator_kwargs if simulator_kwargs is not None else get_item("data", "simulator_kwargs", raise_exception=False) + simulator_kwargs = {} if simulator_kwargs is None else simulator_kwargs + simulator_instance = simulator(**simulator_kwargs) + + if not hasattr(simulator_instance, "generate_context"): + raise RuntimeError( + "Simulator improperly formed - requires a generate_context method." + ) + + if not hasattr(simulator_instance, "simulate"): + raise RuntimeError( + "Simulator improperly formed - requires a simulate method." + ) + + return simulator_instance \ No newline at end of file diff --git a/tests/conftest.py b/tests/conftest.py index 094fbb6..65cc12a 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,12 +1,13 @@ import pytest import yaml import numpy as np +import os from data import H5Data from data.simulator import Simulator from models import SBIModel from utils.register import register_simulator - +from utils.config import get_item class MockSimulator(Simulator): def generate_context(self, n_samples: int) -> np.ndarray: @@ -34,6 +35,14 @@ def simulate(self, theta: np.ndarray, context_samples: np.ndarray) -> np.ndarray y[:, i] = m * context_samples + b + epsilon[:, i] return y.T +@pytest.fixture(autouse=True) +def setUp(): + register_simulator("MockSimulator", MockSimulator) + yield + simulator_config_path = get_item("common", "sim_location", raise_exception=False) + sim_paths = f"{simulator_config_path.strip('/')}/simulators.json" + os.remove(sim_paths) + @pytest.fixture def model_path(): return "resources/savedmodels/sbi/sbi_linear_from_data.pkl" @@ -44,9 +53,7 @@ def data_path(): @pytest.fixture def simulator_name(): - name = MockSimulator.__name__ - register_simulator(name, MockSimulator) - return name + return MockSimulator.__name__ @pytest.fixture def mock_model(model_path): diff --git a/tests/test_client.py b/tests/test_client.py index c60706e..8fa0162 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -9,7 +9,6 @@ def test_parser_args(model_path, data_path, simulator_name): process = subprocess.run(command) exit_code = process.returncode assert exit_code == 0 - print(process.stdout) def test_parser_config(config_factory, model_path, data_path, simulator_name): config_path = config_factory(model_path=model_path, data_path=data_path, simulator=simulator_name) @@ -17,7 +16,6 @@ def test_parser_config(config_factory, model_path, data_path, simulator_name): process = subprocess.run(command) exit_code = process.returncode assert exit_code == 0 - print(process.stdout) def test_main_no_methods(config_factory, model_path, data_path, simulator_name): out_dir = "./test_out_dir/" @@ -26,7 +24,6 @@ def test_main_no_methods(config_factory, model_path, data_path, simulator_name): process = subprocess.run(command) exit_code = process.returncode assert exit_code == 0 - print(process.stdout) # There should be nothing at the outpath assert os.listdir(out_dir) == [] @@ -37,11 +34,9 @@ def test_main_missing_config(): process = subprocess.run(command) exit_code = process.returncode assert exit_code == 1 - print(process.stdout) def test_main_missing_args(model_path): command = ["diagnose", "--model_path", model_path] process = subprocess.run(command) exit_code = process.returncode assert exit_code == 1 - print(process.stdout) diff --git a/tests/test_metrics.py b/tests/test_metrics.py index 1cec089..64ee77e 100644 --- a/tests/test_metrics.py +++ b/tests/test_metrics.py @@ -6,7 +6,8 @@ from metrics import ( Metrics, CoverageFraction, - AllSBC + AllSBC, + LocalTwoSampleTest ) @pytest.fixture @@ -14,41 +15,37 @@ def metric_config(config_factory): metrics_settings={"use_progress_bar":False, "samples_per_inference":10, "percentiles":[95]} config = config_factory(metrics_settings=metrics_settings) Config(config) - return config - -def test_all_metrics_catalogued(): - '''Each metrics gets its own file, and each metric is included in the Metrics dictionary - so the client can use it. - This test verifies all metrics are cataloged''' - - all_files = os.listdir("src/metrics/") - files_ignore = ['metric.py', '__init__.py', '__pycache__'] # All files not containing a metric - num_files = len([file for file in all_files if file not in files_ignore]) - assert len(Metrics) == num_files def test_all_defaults(metric_config, mock_model, mock_data): """ Ensures each metric has a default set of parameters and is included in the defaults list Ensures each test can initialize, regardless of the veracity of the output """ - Config(metric_config) for metric_name, metric_obj in Metrics.items(): assert metric_name in Defaults['metrics'] metric_obj(mock_model, mock_data) - def test_coverage_fraction(metric_config, mock_model, mock_data): - Config(metric_config) - coverage_fraction = CoverageFraction(mock_model, mock_data) + coverage_fraction = CoverageFraction(mock_model, mock_data, save=True) _, coverage = coverage_fraction.calculate() assert coverage_fraction.output.all() is not None # TODO Shape of coverage assert coverage.shape + + coverage_fraction = CoverageFraction(mock_model, mock_data, save=True) + coverage_fraction() + assert os.path.exists(f"{coverage_fraction.out_dir}/diagnostic_metrics.json") def test_all_sbc(metric_config, mock_model, mock_data): - Config(metric_config) - all_sbc = AllSBC(mock_model, mock_data) + all_sbc = AllSBC(mock_model, mock_data, save=True) all_sbc() - # TODO What is this supposed to be \ No newline at end of file + assert all_sbc.output is not None + assert os.path.exists(f"{all_sbc.out_dir}/diagnostic_metrics.json") + +def test_lc2st(metric_config, mock_model, mock_data): + lc2st = LocalTwoSampleTest(mock_model, mock_data, save=True) + lc2st() + assert lc2st.output is not None + assert os.path.exists(f"{lc2st.out_dir}/diagnostic_metrics.json") \ No newline at end of file diff --git a/tests/test_plots.py b/tests/test_plots.py index 253343b..33c57ce 100644 --- a/tests/test_plots.py +++ b/tests/test_plots.py @@ -8,7 +8,8 @@ CDFRanks, Ranks, CoverageFraction, - TARP + TARP, + LocalTwoSampleTest ) @pytest.fixture @@ -18,17 +19,6 @@ def plot_config(config_factory): config = config_factory(out_dir=out_dir, metrics_settings=metrics_settings) Config(config) - -def test_all_plot_catalogued(): - '''Each metrics gets its own file, and each metric is included in the Metrics dictionary - so the client can use it. - This test verifies all metrics are cataloged''' - - all_files = os.listdir("src/plots/") - files_ignore = ['plot.py', '__init__.py', '__pycache__'] # All files not containing a metric - num_files = len([file for file in all_files if file not in files_ignore]) - assert len(Plots) == num_files - def test_all_defaults(plot_config, mock_model, mock_data): """ Ensures each metric has a default set of parameters and is included in the defaults list @@ -41,18 +31,24 @@ def test_all_defaults(plot_config, mock_model, mock_data): def test_plot_cdf(plot_config, mock_model, mock_data): plot = CDFRanks(mock_model, mock_data, save=True, show=False) plot(**get_item("plots", "CDFRanks", raise_exception=False)) - assert os.path.exists(f"{plot.out_path}/{plot.plot_name}") + assert os.path.exists(f"{plot.out_dir}/{plot.plot_name}") def test_plot_ranks(plot_config, mock_model, mock_data): plot = Ranks(mock_model, mock_data, save=True, show=False) plot(**get_item("plots", "Ranks", raise_exception=False)) - assert os.path.exists(f"{plot.out_path}/{plot.plot_name}") + assert os.path.exists(f"{plot.out_dir}/{plot.plot_name}") def test_plot_coverage(plot_config, mock_model, mock_data): plot = CoverageFraction(mock_model, mock_data, save=True, show=False) plot(**get_item("plots", "CoverageFraction", raise_exception=False)) - assert os.path.exists(f"{plot.out_path}/{plot.plot_name}") + assert os.path.exists(f"{plot.out_dir}/{plot.plot_name}") def test_plot_tarp(plot_config, mock_model, mock_data): plot = TARP(mock_model, mock_data, save=True, show=False) - plot(**get_item("plots", "TARP", raise_exception=False)) \ No newline at end of file + plot(**get_item("plots", "TARP", raise_exception=False)) + assert os.path.exists(f"{plot.out_dir}/{plot.plot_name}") + +def test_lc2st(plot_config, mock_model, mock_data): + plot = LocalTwoSampleTest(mock_model, mock_data, save=True, show=False) + plot(**get_item("plots", "LC2ST", raise_exception=False)) + assert os.path.exists(f"{plot.out_dir}/{plot.plot_name}") \ No newline at end of file