From 58d7c2b1fe8a111d9770e0bbc137aa02ba88b8cc Mon Sep 17 00:00:00 2001 From: BalzaniEdoardo Date: Wed, 21 Feb 2024 17:23:12 -0500 Subject: [PATCH 001/134] added ruff and nox. --- noxfile.py | 14 ++++++++++++++ pyproject.toml | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+) create mode 100644 noxfile.py diff --git a/noxfile.py b/noxfile.py new file mode 100644 index 00000000..e1ec0118 --- /dev/null +++ b/noxfile.py @@ -0,0 +1,14 @@ +import nox + + +@nox.session(name="Run Tests", python=["3.10", "3.11"]) +def tests(session): + """Run the test suite.""" + session.run("pytest") + + +@nox.session(name="linter", python = ["3.10", "3.11"]) +def linters(session): + """Run linters""" + session.run("ruff", "check", "--ignore", "D") + diff --git a/pyproject.toml b/pyproject.toml index 32318aa3..78dd115e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -52,6 +52,8 @@ dev = [ 'pytest-xdist', "torchvision>=0.3", "requests>=2.21", + "nox", + "ruff" ] nb = [ @@ -78,3 +80,50 @@ local_scheme = 'no-local-version' addopts = "--cov=plenoptic" testpaths = ["tests"] +[tool.ruff] + +# Exclude a variety of commonly ignored directories. +exclude = [ + ".bzr", + ".direnv", + ".eggs", + ".git", + ".github", + ".git-rewrite", + ".hg", + ".ipynb_checkpoints", + ".mypy_cache", + ".nox", + ".pants.d", + ".pyenv", + ".pytest_cache", + ".pytype", + ".ruff_cache", + ".svn", + ".tox", + ".venv", + ".vscode", + "__pypackages__", + "_build", + "buck-out", + "build", + "dist", + "node_modules", + "site-packages", + "venv", + "tests", + "examples", + "docs" +] + +# Set the maximum line length to 79. +line-length = 79 + +[tool.ruff.lint] +# Add the `line-too-long` rule to the enforced rule set. By default, Ruff omits rules that +# overlap with the use of a formatter, like Black, but we can override this behavior by +# explicitly adding the rule. +extend-select = ["D", "E", "F", "W", "B", "I"] + +[tool.ruff.lint.pydocstyle] +convention = "numpy" From 720dcd4f456130abfe41f66efb9debc9e4a54f81 Mon Sep 17 00:00:00 2001 From: BalzaniEdoardo Date: Wed, 21 Feb 2024 17:24:31 -0500 Subject: [PATCH 002/134] config nox for the py3.12 --- noxfile.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/noxfile.py b/noxfile.py index e1ec0118..425c95fa 100644 --- a/noxfile.py +++ b/noxfile.py @@ -7,7 +7,7 @@ def tests(session): session.run("pytest") -@nox.session(name="linter", python = ["3.10", "3.11"]) +@nox.session(name="linter", python=["3.10", "3.11", "3.12"]) def linters(session): """Run linters""" session.run("ruff", "check", "--ignore", "D") From cdda6702430948db724f0bec64ee66d1bcd30183 Mon Sep 17 00:00:00 2001 From: BalzaniEdoardo Date: Wed, 21 Feb 2024 18:29:21 -0500 Subject: [PATCH 003/134] add `nox`, `ruff` and a section on managing multiple python versions --- CONTRIBUTING.md | 111 ++++++++++++++++++++++++++++++++++++++++++++++++ noxfile.py | 4 +- 2 files changed, 113 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 899d8882..45726880 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -189,6 +189,117 @@ several choices for how to run a subset of the tests: View the [pytest documentation](http://doc.pytest.org/en/latest/usage.html) for more info. +### Using nox to simplify testing and linting +This section is optional but if you want to easily run tests in an isolated environment +using the [nox](https://nox.thea.codes/en/stable/) command-line tool. + +`nox` is installed automatically as a `[dev]` dependency of plenoptic. + +To run all tests and linters through `nox`, from the root folder of the +plenoptic package, execute the following command, + +```bash +nox +``` + +`nox` will read the configuration from the `noxfile.py` script. + +If you want to run just the tests, add the following option, + +```bash +nox -s tests +``` + +and for running only the linters, + +```bash +nox -s linters +``` + +`nox` offers a variety of configuration options, you can learn more about it from their +[documentation](https://nox.thea.codes/en/stable/config.html). + +#### Multi-python version testing with pyenv +Sometimes, before opening a pull-request that will trigger the `.github/workflow/ci.yml` continuous +integration workflow, you may want to test your changes over all the supported python versions locally. + +Handling multiple installed python versions on the same machine can be challenging and confusing. +[`pyenv`](https://github.com/pyenv/pyenv) is a great tool that really comes to the rescue. + +This tool doesn't come with the package dependencies and has to be installed separately. Installation instructions +are system specific but the package readme is very details, see +[here](https://github.com/pyenv/pyenv?tab=readme-ov-file#installation). + +Follow carefully the instructions to configure pyenv after installation. + +Once you have tha package installed and configured, you can install multiple python version through it. +First get a list of the available versions with the command, + +```bash +pyenv install -l +``` + +Install the python version you need. For this example, let's assume we want `python 3.10.11` and `python 3.11.8`, + +```bash +pyenv install 3.10.11 +pyenv install 3.11.8 +``` + +You can check which python version is currently set as default, by typing, + +```bash +pyenv which python +``` + +And you can list all available versions of python with, + +```bash +pyenv versions +``` +If you want to run `nox` on multiple python versions, all you need to do is: + +1. Set your desired versions as `global`. + ```bash + pyenv global 3.11.8 3.10.11 + ``` + This will make both version available, and the default python will be set to the first one listed + (`3.11.8` in this case). +2. Run nox specifying the python version as an option. + ```bash + nox -p 3.10 + ``` + +Note that `noxfile.py` lists the available option as keyword arguments in a session specific manner. + +If you have multiple python version installed, we recommend to manage your virtual environments +through `pyenv`. For that you'll need to install the extension +[`pyenv-virtualenv`](https://github.com/pyenv/pyenv-virtualenv). + +This tool works with most of the environment managers including (`venv` and `conda`). +Creating an environment with it is as simple as calling, + +```bash +pyenv virtualenv my-python my-enviroment +``` + +Here, `my-python` is the python version, one between `pyenv versions`, and `my-environment` is your +new environment name. + +If `my-python` has `conda` installed, it will create a conda environment, if not, it will use `venv`. + +You can list the virtual environment only with, + +```bash +pyenv virtualenvs +``` + +And you can uninstall an environment with, + +```bash +pyenv uninstall my-environment +``` + ### Adding tests New tests can be added in any of the existing `tests/test_*.py` scripts. Tests diff --git a/noxfile.py b/noxfile.py index 425c95fa..dff3aca5 100644 --- a/noxfile.py +++ b/noxfile.py @@ -1,13 +1,13 @@ import nox -@nox.session(name="Run Tests", python=["3.10", "3.11"]) +@nox.session(name="tests", python=["3.10", "3.11", "3.12"]) def tests(session): """Run the test suite.""" session.run("pytest") -@nox.session(name="linter", python=["3.10", "3.11", "3.12"]) +@nox.session(name="linters") def linters(session): """Run linters""" session.run("ruff", "check", "--ignore", "D") From 2b94867c22948cdda363dd04e4858c860aebf7ca Mon Sep 17 00:00:00 2001 From: "William F. Broderick" Date: Wed, 28 Feb 2024 15:57:43 -0500 Subject: [PATCH 004/134] adds src to ruff config --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 78dd115e..952d8578 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -81,7 +81,7 @@ addopts = "--cov=plenoptic" testpaths = ["tests"] [tool.ruff] - +src = ['src'] # Exclude a variety of commonly ignored directories. exclude = [ ".bzr", From d25dea286665bd4a4ffa921176d29b1fa5afe54e Mon Sep 17 00:00:00 2001 From: "William F. Broderick" Date: Wed, 28 Feb 2024 17:05:26 -0500 Subject: [PATCH 005/134] updates ruff version (to work with src config) --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 952d8578..9d3e274d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -53,7 +53,7 @@ dev = [ "torchvision>=0.3", "requests>=2.21", "nox", - "ruff" + "ruff>=0.2" ] nb = [ From fbb55c9083c3cfda3bb0d0594bf3876861eb0296 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 6 Jul 2024 13:00:21 -0400 Subject: [PATCH 006/134] added ruff and pre-commit configurations --- .pre-commit-config.yaml | 9 +++++++++ pyproject.toml | 5 +++++ 2 files changed, 14 insertions(+) create mode 100644 .pre-commit-config.yaml diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..c65b6686 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,9 @@ +repos: +- repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.1.4 + hooks: + # Run the linter. + - id: ruff + # Run the formatter. + - id: ruff-format \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 6a490ead..012bc9d1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,6 +55,7 @@ dev = [ 'pytest-xdist', "requests>=2.21", "pooch>=1.2.0", + "ruff>=0.5.1", ] nb = [ @@ -82,3 +83,7 @@ local_scheme = 'no-local-version' addopts = "--cov=plenoptic" testpaths = ["tests"] +[tool.ruff.lint] + +[tool.ruff.lint.pydocstyle] +convention = "numpy" \ No newline at end of file From e5adeccc74306754eb99d0c71eba1b7cb2087da9 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 6 Jul 2024 13:10:56 -0400 Subject: [PATCH 007/134] basic precommit confi --- .pre-commit-config.yaml | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c65b6686..e1fb863c 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,9 +1,14 @@ repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v2.3.0 + hooks: + - id: check-yaml + - id: end-of-file-fixer + - id: trailing-whitespace - repo: https://github.com/astral-sh/ruff-pre-commit - # Ruff version. rev: v0.1.4 hooks: # Run the linter. - id: ruff # Run the formatter. - - id: ruff-format \ No newline at end of file + - id: ruff-format From 870d2d65857131c0671896793d0a1cae460c7f68 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 6 Jul 2024 13:25:10 -0400 Subject: [PATCH 008/134] ruff linter added to ci --- .github/workflows/ci.yml | 6 ++++++ pyproject.toml | 5 +++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8d313be6..fbd28f05 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -121,6 +121,12 @@ jobs: print_all: false timeout: 5 retry_count: 3 + ruff-linting: + runs-on: ubuntu-latest + name: Run Ruff linter and check code formatting + steps: + - uses: actions/checkout@v4 + - uses: chartboost/ruff-action@v1 check: if: always() diff --git a/pyproject.toml b/pyproject.toml index 012bc9d1..9e8c48cc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -83,7 +83,8 @@ local_scheme = 'no-local-version' addopts = "--cov=plenoptic" testpaths = ["tests"] -[tool.ruff.lint] +[tool.ruff] +extend-include = ["*.ipynb"] [tool.ruff.lint.pydocstyle] -convention = "numpy" \ No newline at end of file +convention = "numpy" From dc40707085b0c896d0a9b003fd6eff545efc54b0 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 8 Jul 2024 20:50:44 -0400 Subject: [PATCH 009/134] formatter added --- .github/workflows/ci.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fbd28f05..447a5295 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -127,6 +127,8 @@ jobs: steps: - uses: actions/checkout@v4 - uses: chartboost/ruff-action@v1 + with: + args: 'format --check' check: if: always() From c802033d1949fd8cf9ac07cd5769b908ca36f159 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 8 Jul 2024 20:57:57 -0400 Subject: [PATCH 010/134] default check added to ci --- .github/workflows/ci.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 447a5295..0bb8d054 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -126,6 +126,9 @@ jobs: name: Run Ruff linter and check code formatting steps: - uses: actions/checkout@v4 + - uses: chartboost/ruff-action@v1 + with: + args: 'check' - uses: chartboost/ruff-action@v1 with: args: 'format --check' From 5f61b944cda6c57db819bf649bbc5473145f787f Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 8 Jul 2024 21:03:11 -0400 Subject: [PATCH 011/134] assigned separate github actions to ruff code formatter and linters --- .github/workflows/ci.yml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0bb8d054..f6da1dbd 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -123,12 +123,17 @@ jobs: retry_count: 3 ruff-linting: runs-on: ubuntu-latest - name: Run Ruff linter and check code formatting + name: Run Ruff linter steps: - uses: actions/checkout@v4 - uses: chartboost/ruff-action@v1 with: args: 'check' + ruff-formatting: + runs-on: ubuntu-latest + name: Run Ruff code formatting check + steps: + - uses: actions/checkout@v4 - uses: chartboost/ruff-action@v1 with: args: 'format --check' From b0a392cf30ca268cf3dc40e363bca723a217b3b8 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 9 Jul 2024 14:40:20 -0400 Subject: [PATCH 012/134] test --- .../simulate/models/portilla_simoncelli.py | 363 +++++++++++------- 1 file changed, 225 insertions(+), 138 deletions(-) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index f64ac40d..d0eb56db 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -24,7 +24,9 @@ from ...tools.display import clean_stem_plot, clean_up_axes, update_stem from ...tools.validate import validate_input from ..canonical_computations.steerable_pyramid_freq import SteerablePyramidFreq -from ..canonical_computations.steerable_pyramid_freq import SCALES_TYPE as PYR_SCALES_TYPE +from ..canonical_computations.steerable_pyramid_freq import ( + SCALES_TYPE as PYR_SCALES_TYPE, +) SCALES_TYPE = Union[Literal["pixel_statistics"], PYR_SCALES_TYPE] @@ -86,11 +88,14 @@ def __init__( super().__init__() self.image_shape = image_shape - if (any([(image_shape[-1] / 2**i) % 2 for i in range(n_scales)]) or - any([(image_shape[-2] / 2**i) % 2 for i in range(n_scales)])): - raise ValueError("Because of how the Portilla-Simoncelli model handles " - "multiscale representations, it only works with images" - " whose shape can be divided by 2 `n_scales` times.") + if any([(image_shape[-1] / 2**i) % 2 for i in range(n_scales)]) or any( + [(image_shape[-2] / 2**i) % 2 for i in range(n_scales)] + ): + raise ValueError( + "Because of how the Portilla-Simoncelli model handles " + "multiscale representations, it only works with images" + " whose shape can be divided by 2 `n_scales` times." + ) self.spatial_corr_width = spatial_corr_width self.n_scales = n_scales self.n_orientations = n_orientations @@ -114,13 +119,17 @@ def __init__( # Dictionary defining necessary statistics, that is, those that are not # redundant - self._necessary_stats_dict = self._create_necessary_stats_dict(scales_shape_dict) + self._necessary_stats_dict = self._create_necessary_stats_dict( + scales_shape_dict + ) # turn this into tensor we can use in forward pass. first into a # boolean mask... - _necessary_stats_mask = einops.pack(list(self._necessary_stats_dict.values()), '*')[0] + _necessary_stats_mask = einops.pack( + list(self._necessary_stats_dict.values()), "*" + )[0] # then into a tensor of indices _necessary_stats_mask = torch.where(_necessary_stats_mask)[0] - self.register_buffer('_necessary_stats_mask', _necessary_stats_mask) + self.register_buffer("_necessary_stats_mask", _necessary_stats_mask) # This array is composed of the following values: 'pixel_statistics', # 'residual_lowpass', 'residual_highpass' and integer values from 0 to @@ -128,9 +137,13 @@ def __init__( # returned by this object's forward method. It must be a numpy array so # we can have a mixture of ints and strs (and so we can use np.in1d # later) - self._representation_scales = einops.pack(list(scales_shape_dict.values()), '*')[0] + self._representation_scales = einops.pack( + list(scales_shape_dict.values()), "*" + )[0] # just select the scales of the necessary stats. - self._representation_scales = self._representation_scales[self._necessary_stats_mask] + self._representation_scales = self._representation_scales[ + self._necessary_stats_mask + ] def _create_scales_shape_dict(self) -> OrderedDict: """Create dictionary defining scales and shape of each stat. @@ -166,16 +179,18 @@ def _create_scales_shape_dict(self) -> OrderedDict: """ shape_dict = OrderedDict() # There are 6 pixel statistics - shape_dict['pixel_statistics'] = np.array(6*['pixel_statistics']) + shape_dict["pixel_statistics"] = np.array(6 * ["pixel_statistics"]) # These are the basic building blocks of the scale assignments for many # of the statistics calculated by the PortillaSimoncelli model. scales = np.arange(self.n_scales) # the cross-scale correlations exclude the coarsest scale - scales_without_coarsest = np.arange(self.n_scales-1) + scales_without_coarsest = np.arange(self.n_scales - 1) # the statistics computed on the reconstructed bandpass images have an # extra scale corresponding to the lowpass residual - scales_with_lowpass = np.array(scales.tolist() + ["residual_lowpass"], dtype=object) + scales_with_lowpass = np.array( + scales.tolist() + ["residual_lowpass"], dtype=object + ) # now we go through each statistic in order and create a dummy array # full of 1s with the same shape as the actual statistic (excluding the @@ -184,49 +199,65 @@ def _create_scales_shape_dict(self) -> OrderedDict: # arrays above to turn those 1s into values describing the # corresponding scale. - auto_corr_mag = np.ones((self.spatial_corr_width, self.spatial_corr_width, - self.n_scales, self.n_orientations), dtype=int) + auto_corr_mag = np.ones( + ( + self.spatial_corr_width, + self.spatial_corr_width, + self.n_scales, + self.n_orientations, + ), + dtype=int, + ) # this rearrange call is turning scales from 1d with shape (n_scales, ) # to 4d with shape (1, 1, n_scales, 1), so that it matches # auto_corr_mag. the following rearrange calls do similar. - auto_corr_mag *= einops.rearrange(scales, 's -> 1 1 s 1') - shape_dict['auto_correlation_magnitude'] = auto_corr_mag + auto_corr_mag *= einops.rearrange(scales, "s -> 1 1 s 1") + shape_dict["auto_correlation_magnitude"] = auto_corr_mag - shape_dict['skew_reconstructed'] = scales_with_lowpass + shape_dict["skew_reconstructed"] = scales_with_lowpass - shape_dict['kurtosis_reconstructed'] = scales_with_lowpass + shape_dict["kurtosis_reconstructed"] = scales_with_lowpass - auto_corr = np.ones((self.spatial_corr_width, self.spatial_corr_width, - self.n_scales+1), dtype=object) - auto_corr *= einops.rearrange(scales_with_lowpass, 's -> 1 1 s') - shape_dict['auto_correlation_reconstructed'] = auto_corr + auto_corr = np.ones( + (self.spatial_corr_width, self.spatial_corr_width, self.n_scales + 1), + dtype=object, + ) + auto_corr *= einops.rearrange(scales_with_lowpass, "s -> 1 1 s") + shape_dict["auto_correlation_reconstructed"] = auto_corr - shape_dict['std_reconstructed'] = scales_with_lowpass + shape_dict["std_reconstructed"] = scales_with_lowpass - cross_orientation_corr_mag = np.ones((self.n_orientations, self.n_orientations, - self.n_scales), dtype=int) - cross_orientation_corr_mag *= einops.rearrange(scales, 's -> 1 1 s') - shape_dict['cross_orientation_correlation_magnitude'] = cross_orientation_corr_mag + cross_orientation_corr_mag = np.ones( + (self.n_orientations, self.n_orientations, self.n_scales), dtype=int + ) + cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") + shape_dict[ + "cross_orientation_correlation_magnitude" + ] = cross_orientation_corr_mag mags_std = np.ones((self.n_orientations, self.n_scales), dtype=int) - mags_std *= einops.rearrange(scales, 's -> 1 s') - shape_dict['magnitude_std'] = mags_std + mags_std *= einops.rearrange(scales, "s -> 1 s") + shape_dict["magnitude_std"] = mags_std - cross_scale_corr_mag = np.ones((self.n_orientations, self.n_orientations, - self.n_scales-1), dtype=int) - cross_scale_corr_mag *= einops.rearrange(scales_without_coarsest, 's -> 1 1 s') - shape_dict['cross_scale_correlation_magnitude'] = cross_scale_corr_mag + cross_scale_corr_mag = np.ones( + (self.n_orientations, self.n_orientations, self.n_scales - 1), dtype=int + ) + cross_scale_corr_mag *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") + shape_dict["cross_scale_correlation_magnitude"] = cross_scale_corr_mag - cross_scale_corr_real = np.ones((self.n_orientations, 2*self.n_orientations, - self.n_scales-1), dtype=int) - cross_scale_corr_real *= einops.rearrange(scales_without_coarsest, 's -> 1 1 s') - shape_dict['cross_scale_correlation_real'] = cross_scale_corr_real + cross_scale_corr_real = np.ones( + (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), dtype=int + ) + cross_scale_corr_real *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") + shape_dict["cross_scale_correlation_real"] = cross_scale_corr_real - shape_dict['var_highpass_residual'] = np.array(["residual_highpass"]) + shape_dict["var_highpass_residual"] = np.array(["residual_highpass"]) return shape_dict - def _create_necessary_stats_dict(self, scales_shape_dict: OrderedDict) -> OrderedDict: + def _create_necessary_stats_dict( + self, scales_shape_dict: OrderedDict + ) -> OrderedDict: """Create mask specifying the necessary statistics. Some of the statistics computed by the model are redundant, due to @@ -254,21 +285,20 @@ def _create_necessary_stats_dict(self, scales_shape_dict: OrderedDict) -> Ordere mask_dict = scales_shape_dict.copy() # Pre-compute some necessary indices. # Lower triangular indices (including diagonal), for auto correlations - tril_inds = torch.tril_indices(self.spatial_corr_width, - self.spatial_corr_width) + tril_inds = torch.tril_indices(self.spatial_corr_width, self.spatial_corr_width) # Get the second half of the diagonal, i.e., everything from the center # element on. These are all repeated for the auto correlations. (As # these are autocorrelations (rather than auto-covariance) matrices, # they've been normalized by the variance and so the center element is # always 1, and thus uninformative) - diag_repeated = torch.arange(start=self.spatial_corr_width//2, - end=self.spatial_corr_width) + diag_repeated = torch.arange( + start=self.spatial_corr_width // 2, end=self.spatial_corr_width + ) # Upper triangle indices, including diagonal. These are redundant stats # for cross_orientation_correlation_magnitude (because we've normalized # this matrix to be true cross-correlations, the diagonals are all 1, # like for the auto-correlations) - triu_inds = torch.triu_indices(self.n_orientations, - self.n_orientations) + triu_inds = torch.triu_indices(self.n_orientations, self.n_orientations) for k, v in mask_dict.items(): if k in ["auto_correlation_magnitude", "auto_correlation_reconstructed"]: # Symmetry M_{i,j} = M_{n-i+1, n-j+1} @@ -280,7 +310,7 @@ def _create_necessary_stats_dict(self, scales_shape_dict: OrderedDict) -> Ordere if np.mod(self.spatial_corr_width, 2) == 0: mask[0] = True mask[diag_repeated, diag_repeated] = False - elif k == 'cross_orientation_correlation_magnitude': + elif k == "cross_orientation_correlation_magnitude": # Symmetry M_{i,j} = M_{j,i}. # Start with all True, then place False in redundant stats. mask = torch.ones(v.shape, dtype=torch.bool) @@ -340,7 +370,9 @@ def forward( # real_pyr_coeffs, which contain the demeaned magnitude of the pyramid # coefficients and the real part of the pyramid coefficients # respectively. - mag_pyr_coeffs, real_pyr_coeffs = self._compute_intermediate_representations(pyr_coeffs) + mag_pyr_coeffs, real_pyr_coeffs = self._compute_intermediate_representations( + pyr_coeffs + ) # Then, the reconstructed lowpass image at each scale. (this is a list # of length n_scales+1 containing tensors of shape (batch, channel, @@ -373,15 +405,16 @@ def forward( # kurtosis_recon will all end up as tensors of shape (batch, channel, # n_scales+1) std_recon = var_recon.sqrt() - skew_recon, kurtosis_recon = self._compute_skew_kurtosis_recon(reconstructed_images, - var_recon, - pixel_stats[..., 1]) + skew_recon, kurtosis_recon = self._compute_skew_kurtosis_recon( + reconstructed_images, var_recon, pixel_stats[..., 1] + ) # Compute the cross-orientation correlations between the magnitude # coefficients at each scale. this will be a tensor of shape (batch, # channel, n_orientations, n_orientations, n_scales) - cross_ori_corr_mags, mags_var = self._compute_cross_correlation(mag_pyr_coeffs, mag_pyr_coeffs, - tensors_are_identical=True) + cross_ori_corr_mags, mags_var = self._compute_cross_correlation( + mag_pyr_coeffs, mag_pyr_coeffs, tensors_are_identical=True + ) # mags_var is the variance of the magnitude coefficients at each scale # (it's an intermediary of the computation of the cross-orientation # correlations), of shape (batch, channel, n_orientations, n_scales). @@ -392,33 +425,44 @@ def forward( if self.n_scales != 1: # First, double the phase the coefficients, so we can correctly # compute correlations across scales. - phase_doubled_mags, phase_doubled_sep = self._double_phase_pyr_coeffs(pyr_coeffs) + phase_doubled_mags, phase_doubled_sep = self._double_phase_pyr_coeffs( + pyr_coeffs + ) # Compute the cross-scale correlations between the magnitude # coefficients. For each coefficient, we're correlating it with the # coefficients at the next-coarsest scale. this will be a tensor of # shape (batch, channel, n_orientations, n_orientations, # n_scales-1) - cross_scale_corr_mags, _ = self._compute_cross_correlation(mag_pyr_coeffs[:-1], phase_doubled_mags, - tensors_are_identical=False) + cross_scale_corr_mags, _ = self._compute_cross_correlation( + mag_pyr_coeffs[:-1], phase_doubled_mags, tensors_are_identical=False + ) # Compute the cross-scale correlations between the real # coefficients and the real and imaginary coefficients at the next # coarsest scale. this will be a tensor of shape (batch, channel, # n_orientations, 2*n_orientations, n_scales-1) - cross_scale_corr_real, _ = self._compute_cross_correlation(real_pyr_coeffs[:-1], phase_doubled_sep, - tensors_are_identical=False) + cross_scale_corr_real, _ = self._compute_cross_correlation( + real_pyr_coeffs[:-1], phase_doubled_sep, tensors_are_identical=False + ) # Compute the variance of the highpass residual var_highpass_residual = highpass.pow(2).mean(dim=(-2, -1)) # Now, combine all these stats together, first into a list - all_stats = [pixel_stats, autocorr_mags, skew_recon, - kurtosis_recon, autocorr_recon, std_recon, - cross_ori_corr_mags, mags_std] + all_stats = [ + pixel_stats, + autocorr_mags, + skew_recon, + kurtosis_recon, + autocorr_recon, + std_recon, + cross_ori_corr_mags, + mags_std, + ] if self.n_scales != 1: all_stats += [cross_scale_corr_mags, cross_scale_corr_real] all_stats += [var_highpass_residual] # And then pack them into a 3d tensor - representation_tensor, pack_info = einops.pack(all_stats, 'b c *') + representation_tensor, pack_info = einops.pack(all_stats, "b c *") # the only time when this is None is during testing, when we make sure # that our assumptions are all valid. @@ -428,7 +472,9 @@ def forward( self._pack_info = pack_info else: # Throw away all redundant statistics - representation_tensor = representation_tensor.index_select(-1, self._necessary_stats_mask) + representation_tensor = representation_tensor.index_select( + -1, self._necessary_stats_mask + ) # Return the subset of stats corresponding to the specified scale. if scales is not None: @@ -437,7 +483,7 @@ def forward( return representation_tensor def remove_scales( - self, representation_tensor: Tensor, scales_to_keep: List[SCALES_TYPE] + self, representation_tensor: Tensor, scales_to_keep: List[SCALES_TYPE] ) -> Tensor: """Remove statistics not associated with scales. @@ -491,7 +537,7 @@ def convert_to_tensor(self, representation_dict: OrderedDict) -> Tensor: Convert tensor representation to dictionary. """ - rep = einops.pack(list(representation_dict.values()), 'b c *')[0] + rep = einops.pack(list(representation_dict.values()), "b c *")[0] # then get rid of all the nans / unnecessary stats return rep.index_select(-1, self._necessary_stats_mask) @@ -511,7 +557,7 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: Returns ------- - rep + rep Dictionary of representation, with informative keys. See Also @@ -536,10 +582,13 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: # found in representation_tensor and all the other dimensions # determined by the values in necessary_stats_dict. shape = (*representation_tensor.shape[:2], *v.shape) - new_v = torch.nan * torch.ones(shape, dtype=representation_tensor.dtype, - device=representation_tensor.device) + new_v = torch.nan * torch.ones( + shape, + dtype=representation_tensor.dtype, + device=representation_tensor.device, + ) # v.sum() gives the number of necessary elements from this stat - this_stat_vec = representation_tensor[..., n_filled:n_filled+v.sum()] + this_stat_vec = representation_tensor[..., n_filled : n_filled + v.sum()] # use boolean indexing to put the values from new_stat_vec in the # appropriate place new_v[..., v] = this_stat_vec @@ -547,7 +596,9 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: n_filled += v.sum() return rep - def _compute_pyr_coeffs(self, image: Tensor) -> Tuple[OrderedDict, List[Tensor], Tensor, Tensor]: + def _compute_pyr_coeffs( + self, image: Tensor + ) -> Tuple[OrderedDict, List[Tensor], Tensor, Tensor]: """Compute pyramid coefficients of image. Note that the residual lowpass has been demeaned independently for each @@ -580,16 +631,18 @@ def _compute_pyr_coeffs(self, image: Tensor) -> Tuple[OrderedDict, List[Tensor], """ pyr_coeffs = self._pyr.forward(image) # separate out the residuals and demean the residual lowpass - lowpass = pyr_coeffs['residual_lowpass'] + lowpass = pyr_coeffs["residual_lowpass"] lowpass = lowpass - lowpass.mean(dim=(-2, -1), keepdim=True) - pyr_coeffs['residual_lowpass'] = lowpass - highpass = pyr_coeffs['residual_highpass'] + pyr_coeffs["residual_lowpass"] = lowpass + highpass = pyr_coeffs["residual_highpass"] # This is a list of tensors, one for each scale, where each tensor is # of shape (batch, channel, n_orientations, height, width) (note that # height and width halves on each scale) - coeffs_list = [torch.stack([pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2) - for i in range(self.n_scales)] + coeffs_list = [ + torch.stack([pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2) + for i in range(self.n_scales) + ] return pyr_coeffs, coeffs_list, highpass, lowpass @staticmethod @@ -619,15 +672,17 @@ def _compute_pixel_stats(image: Tensor) -> Tensor: kurtosis = stats.kurtosis(image, mean=mean, var=var, dim=[-2, -1]) # can't compute min/max over two dims simultaneously with # torch.min/max, so use einops - img_min = einops.reduce(image, 'b c h w -> b c', 'min') - img_max = einops.reduce(image, 'b c h w -> b c', 'max') + img_min = einops.reduce(image, "b c h w -> b c", "min") + img_max = einops.reduce(image, "b c h w -> b c", "max") # mean needed to be unflattened to be used by skew and kurtosis # correctly, but we'll want it to be flattened like this in the final # representation tensor - return einops.pack([mean, var, skew, kurtosis, img_min, img_max], 'b c *')[0] + return einops.pack([mean, var, skew, kurtosis, img_min, img_max], "b c *")[0] @staticmethod - def _compute_intermediate_representations(pyr_coeffs: Tensor) -> Tuple[List[Tensor], List[Tensor]]: + def _compute_intermediate_representations( + pyr_coeffs: Tensor + ) -> Tuple[List[Tensor], List[Tensor]]: """Compute useful intermediate representations. These representations are: @@ -658,12 +713,18 @@ def _compute_intermediate_representations(pyr_coeffs: Tensor) -> Tuple[List[Tens """ magnitude_pyr_coeffs = [coeff.abs() for coeff in pyr_coeffs] - magnitude_means = [mag.mean((-2, -1), keepdim=True) for mag in magnitude_pyr_coeffs] - magnitude_pyr_coeffs = [mag - mn for mag, mn in zip(magnitude_pyr_coeffs, magnitude_means)] + magnitude_means = [ + mag.mean((-2, -1), keepdim=True) for mag in magnitude_pyr_coeffs + ] + magnitude_pyr_coeffs = [ + mag - mn for mag, mn in zip(magnitude_pyr_coeffs, magnitude_means) + ] real_pyr_coeffs = [coeff.real for coeff in pyr_coeffs] return magnitude_pyr_coeffs, real_pyr_coeffs - def _reconstruct_lowpass_at_each_scale(self, pyr_coeffs_dict: OrderedDict) -> List[Tensor]: + def _reconstruct_lowpass_at_each_scale( + self, pyr_coeffs_dict: OrderedDict + ) -> List[Tensor]: """Reconstruct the lowpass unoriented image at each scale. The autocorrelation, standard deviation, skew, and kurtosis of each of @@ -685,9 +746,11 @@ def _reconstruct_lowpass_at_each_scale(self, pyr_coeffs_dict: OrderedDict) -> Li widths. """ - reconstructed_images = [self._pyr.recon_pyr(pyr_coeffs_dict, levels=['residual_lowpass'])] + reconstructed_images = [ + self._pyr.recon_pyr(pyr_coeffs_dict, levels=["residual_lowpass"]) + ] # go through scales backwards - for lev in range(self.n_scales-1, -1, -1): + for lev in range(self.n_scales - 1, -1, -1): recon = self._pyr.recon_pyr(pyr_coeffs_dict, levels=[lev]) reconstructed_images.append(recon + reconstructed_images[-1]) # now downsample as necessary, so that these end up the same size as @@ -695,8 +758,10 @@ def _reconstruct_lowpass_at_each_scale(self, pyr_coeffs_dict: OrderedDict) -> Li # in order to approximately equalize the steerable pyramid coefficient # values across scales. This could also be handled by making the # pyramid tight frame - reconstructed_images[:-1] = [signal.shrink(r, 2**(self.n_scales-i)) * 4**(self.n_scales-i) - for i, r in enumerate(reconstructed_images[:-1])] + reconstructed_images[:-1] = [ + signal.shrink(r, 2 ** (self.n_scales - i)) * 4 ** (self.n_scales - i) + for i, r in enumerate(reconstructed_images[:-1]) + ] return reconstructed_images def _compute_autocorr(self, coeffs_list: List[Tensor]) -> Tuple[Tensor, Tensor]: @@ -726,22 +791,25 @@ def _compute_autocorr(self, coeffs_list: List[Tensor]) -> Tuple[Tensor, Tensor]: """ if coeffs_list[0].ndim == 5: - dims = 's o' + dims = "s o" elif coeffs_list[0].ndim == 4: - dims = 's' + dims = "s" else: - raise ValueError("coeffs_list must contain tensors of either 4 or 5 dimensions!") + raise ValueError( + "coeffs_list must contain tensors of either 4 or 5 dimensions!" + ) acs = [signal.autocorrelation(coeff) for coeff in coeffs_list] var = [signal.center_crop(ac, 1) for ac in acs] - acs = [ac/v for ac, v in zip(acs, var)] - var = einops.pack(var, 'b c *')[0] + acs = [ac / v for ac, v in zip(acs, var)] + var = einops.pack(var, "b c *")[0] acs = [signal.center_crop(ac, self.spatial_corr_width) for ac in acs] acs = torch.stack(acs, 2) - return einops.rearrange(acs, f'b c {dims} a1 a2 -> b c a1 a2 {dims}'), var + return einops.rearrange(acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}"), var @staticmethod - def _compute_skew_kurtosis_recon(reconstructed_images: List[Tensor], var_recon: Tensor, - img_var: Tensor) -> Tuple[Tensor, Tensor]: + def _compute_skew_kurtosis_recon( + reconstructed_images: List[Tensor], var_recon: Tensor, img_var: Tensor + ) -> Tuple[Tensor, Tensor]: """Compute the skew and kurtosis of each lowpass reconstructed image. For each scale, if the ratio of its variance to the original image's @@ -771,11 +839,15 @@ def _compute_skew_kurtosis_recon(reconstructed_images: List[Tensor], var_recon: ``reconstructed_images``. """ - skew_recon = [stats.skew(im, mean=0, var=var_recon[..., i], dim=[-2, -1]) - for i, im in enumerate(reconstructed_images)] + skew_recon = [ + stats.skew(im, mean=0, var=var_recon[..., i], dim=[-2, -1]) + for i, im in enumerate(reconstructed_images) + ] skew_recon = torch.stack(skew_recon, -1) - kurtosis_recon = [stats.kurtosis(im, mean=0, var=var_recon[..., i], dim=[-2, -1]) - for i, im in enumerate(reconstructed_images)] + kurtosis_recon = [ + stats.kurtosis(im, mean=0, var=var_recon[..., i], dim=[-2, -1]) + for i, im in enumerate(reconstructed_images) + ] kurtosis_recon = torch.stack(kurtosis_recon, -1) skew_default = torch.zeros_like(skew_recon) kurtosis_default = 3 * torch.ones_like(kurtosis_recon) @@ -788,9 +860,12 @@ def _compute_skew_kurtosis_recon(reconstructed_images: List[Tensor], var_recon: kurtosis_recon = torch.where(unstable_locs, kurtosis_default, kurtosis_recon) return skew_recon, kurtosis_recon - def _compute_cross_correlation(self, coeffs_tensor: List[Tensor], - coeffs_tensor_other: List[Tensor], - tensors_are_identical: bool = False) -> Tuple[Tensor, Tensor]: + def _compute_cross_correlation( + self, + coeffs_tensor: List[Tensor], + coeffs_tensor_other: List[Tensor], + tensors_are_identical: bool = False, + ) -> Tuple[Tensor, Tensor]: """Compute cross-correlations. Parameters @@ -821,8 +896,9 @@ def _compute_cross_correlation(self, coeffs_tensor: List[Tensor], # precompute this, which we'll use for normalization numel = torch.mul(*coeff.shape[-2:]) # compute the covariance - covar = einops.einsum(coeff, coeff_other, - 'b c o1 h w, b c o2 h w -> b c o1 o2') + covar = einops.einsum( + coeff, coeff_other, "b c o1 h w, b c o2 h w -> b c o1 o2" + ) covar = covar / numel # Then normalize it to get the Pearson product-moment correlation # coefficient, see @@ -830,26 +906,29 @@ def _compute_cross_correlation(self, coeffs_tensor: List[Tensor], # First, compute the variances of each coeff (if coeff and # coeff_other are identical, this is equivalent to the diagonal of # the above covar matrix, but re-computing it is actually faster) - coeff_var = einops.einsum(coeff, coeff, - 'b c o1 h w, b c o1 h w -> b c o1') + coeff_var = einops.einsum(coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1") coeff_var = coeff_var / numel coeffs_var.append(coeff_var) if tensors_are_identical: coeff_other_var = coeff_var else: - coeff_other_var = einops.einsum(coeff_other, coeff_other, - 'b c o2 h w, b c o2 h w -> b c o2') + coeff_other_var = einops.einsum( + coeff_other, coeff_other, "b c o2 h w, b c o2 h w -> b c o2" + ) coeff_other_var = coeff_other_var / numel # Then compute the outer product of those variances. - var_outer_prod = einops.einsum(coeff_var, coeff_other_var, - 'b c o1, b c o2 -> b c o1 o2') + var_outer_prod = einops.einsum( + coeff_var, coeff_other_var, "b c o1, b c o2 -> b c o1 o2" + ) # And the sqrt of this is what we use to normalize the covariance # into the cross-correlation covars.append(covar / var_outer_prod.sqrt()) return torch.stack(covars, -1), torch.stack(coeffs_var, -1) @staticmethod - def _double_phase_pyr_coeffs(pyr_coeffs: List[Tensor]) -> Tuple[List[Tensor], List[Tensor]]: + def _double_phase_pyr_coeffs( + pyr_coeffs: List[Tensor] + ) -> Tuple[List[Tensor], List[Tensor]]: """Upsample and double the phase of pyramid coefficients. Parameters @@ -885,20 +964,23 @@ def _double_phase_pyr_coeffs(pyr_coeffs: List[Tensor]) -> Tuple[List[Tensor], Li doubled_phase = signal.expand(coeff, 2) / 4.0 doubled_phase = signal.modulate_phase(doubled_phase, 2) doubled_phase_mag = doubled_phase.abs() - doubled_phase_mag = doubled_phase_mag - doubled_phase_mag.mean((-2, -1), keepdim=True) + doubled_phase_mag = doubled_phase_mag - doubled_phase_mag.mean( + (-2, -1), keepdim=True + ) doubled_phase_mags.append(doubled_phase_mag) - doubled_phase_sep.append(einops.pack([doubled_phase.real, doubled_phase.imag], - 'b c * h w')[0]) + doubled_phase_sep.append( + einops.pack([doubled_phase.real, doubled_phase.imag], "b c * h w")[0] + ) return doubled_phase_mags, doubled_phase_sep def plot_representation( - self, - data: Tensor, - ax: Optional[plt.Axes] = None, - figsize: Tuple[float, float] = (15, 15), - ylim: Optional[Union[Tuple[float, float], Literal[False]]] = None, - batch_idx: int = 0, - title: Optional[str] = None, + self, + data: Tensor, + ax: Optional[plt.Axes] = None, + figsize: Tuple[float, float] = (15, 15), + ylim: Optional[Union[Tuple[float, float], Literal[False]]] = None, + batch_idx: int = 0, + title: Optional[str] = None, ) -> Tuple[plt.Figure, List[plt.Axes]]: r"""Plot the representation in a human viewable format -- stem plots with data separated out by statistic type. @@ -930,7 +1012,7 @@ def plot_representation( norm) If self.n_scales > 1, we also have: - + - cross_scale_correlation_magnitude: the cross-correlations between the pyramid coefficient magnitude at one scale and the same orientation at the next-coarsest scale (summarized using Euclidean norm). @@ -1021,12 +1103,15 @@ def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: Intended as a helper function for plot_representation. """ - if rep['skew_reconstructed'].ndim > 1: - raise ValueError("Currently, only know how to plot single batch and channel at a time! " - "Select and/or average over those dimensions") + if rep["skew_reconstructed"].ndim > 1: + raise ValueError( + "Currently, only know how to plot single batch and channel at a time! " + "Select and/or average over those dimensions" + ) data = OrderedDict() - data["pixels+var_highpass"] = torch.cat([rep.pop("pixel_statistics"), - rep.pop("var_highpass_residual")]) + data["pixels+var_highpass"] = torch.cat( + [rep.pop("pixel_statistics"), rep.pop("var_highpass_residual")] + ) data["std+skew+kurtosis recon"] = torch.cat( ( rep.pop("std_reconstructed"), @@ -1035,19 +1120,21 @@ def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: ) ) - data['magnitude_std'] = rep.pop('magnitude_std') + data["magnitude_std"] = rep.pop("magnitude_std") # want to plot these in a specific order - all_keys = ['auto_correlation_reconstructed', - 'auto_correlation_magnitude', - 'cross_orientation_correlation_magnitude', - 'cross_scale_correlation_magnitude', - 'cross_scale_correlation_real'] + all_keys = [ + "auto_correlation_reconstructed", + "auto_correlation_magnitude", + "cross_orientation_correlation_magnitude", + "cross_scale_correlation_magnitude", + "cross_scale_correlation_real", + ] if set(rep.keys()) != set(all_keys): raise ValueError("representation has unexpected keys!") for k in all_keys: # if we only have one scale, no cross-scale stats - if k.startswith('cross_scale') and self.n_scales == 1: + if k.startswith("cross_scale") and self.n_scales == 1: continue # we compute L2 norm manually, since there are NaNs (marking # redundant stats) @@ -1056,10 +1143,10 @@ def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: return data def update_plot( - self, - axes: List[plt.Axes], - data: Tensor, - batch_idx: int = 0, + self, + axes: List[plt.Axes], + data: Tensor, + batch_idx: int = 0, ) -> List[plt.Artist]: r"""Update the information in our representation plot. From 48a571d0581f674a46097f8ed1c088c5dc397a69 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 9 Jul 2024 14:42:44 -0400 Subject: [PATCH 013/134] test --- src/plenoptic/simulate/models/portilla_simoncelli.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index d0eb56db..81545620 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -146,6 +146,8 @@ def __init__( ] def _create_scales_shape_dict(self) -> OrderedDict: + + """Create dictionary defining scales and shape of each stat. This dictionary functions as metadata which is used for two main From 4302b55b6d5f2ff107d4e80705de3b54d493823d Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Wed, 10 Jul 2024 19:10:23 -0400 Subject: [PATCH 014/134] ruff badge added to readme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 4a9e6666..1674c706 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,7 @@ [![codecov](https://codecov.io/gh/LabForComputationalVision/plenoptic/branch/main/graph/badge.svg?token=EDtl5kqXKA)](https://codecov.io/gh/LabForComputationalVision/plenoptic) [![Binder](http://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/LabForComputationalVision/plenoptic/1.0.1?filepath=examples) [![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active) +[![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/format.json)](https://github.com/astral-sh/ruff) ![](docs/images/plenoptic_logo_wide.svg) From 8d44d45773180c0e7d828c3a6a6cead212a8b5b2 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 12 Jul 2024 17:21:21 -0400 Subject: [PATCH 015/134] noxfile added for automated testing across environments after commits --- noxfile.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 noxfile.py diff --git a/noxfile.py b/noxfile.py new file mode 100644 index 00000000..bcd13736 --- /dev/null +++ b/noxfile.py @@ -0,0 +1,13 @@ +import nox + +@nox.session(name="lint") +def lint(session): + # run linters + session.install("ruff") + session.run("ruff", "check", "--ignore", "D") + +@nox.session(name="tests") +def tests(session): + # run tests + session.install("pytest") + session.run("pytest") \ No newline at end of file From 83a3e4151927c0a8f579e14189c641df9182734b Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 12 Jul 2024 17:59:40 -0400 Subject: [PATCH 016/134] ruff linters, both ignore and select, specified --- pyproject.toml | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 9e8c48cc..f1f48347 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -86,5 +86,58 @@ testpaths = ["tests"] [tool.ruff] extend-include = ["*.ipynb"] +[tool.ruff.lint] +select = [ + # pycodestyle + "E", + # Pyflakes + "F", + # pyupgrade + "UP", + # flake8-bugbear + "B", + # flake8-simplify + "SIM", + # isort + "I", + # error message formatting + "EM", +] +# ignore a variety of directories +ignore = [ + "docs", + "build", + "dist", + "src/plenoptic/version.py", + ".bzr", + ".direnv", + ".eggs", + ".git", + ".github", + ".git-rewrite", + ".hg", + ".ipynb_checkpoints", + ".mypy_cache", + ".nox", + ".pants.d", + ".pyenv", + ".pytest_cache", + ".pytype", + ".ruff_cache", + ".svn", + ".tox", + ".venv", + ".vscode", + "__pypackages__", + "_build", + "buck-out", + "node_modules", + "site-packages", + "venv", + "tests", + ] + + + [tool.ruff.lint.pydocstyle] convention = "numpy" From 1badbad7865cf87c42af41774a081f1b9850fe6c Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 12 Jul 2024 18:09:32 -0400 Subject: [PATCH 017/134] ruff check runs --- pyproject.toml | 42 +++++++++++++++++++----------------------- 1 file changed, 19 insertions(+), 23 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index f1f48347..2f167000 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -85,30 +85,9 @@ testpaths = ["tests"] [tool.ruff] extend-include = ["*.ipynb"] - -[tool.ruff.lint] -select = [ - # pycodestyle - "E", - # Pyflakes - "F", - # pyupgrade - "UP", - # flake8-bugbear - "B", - # flake8-simplify - "SIM", - # isort - "I", - # error message formatting - "EM", -] +src = ['src'] # ignore a variety of directories -ignore = [ - "docs", - "build", - "dist", - "src/plenoptic/version.py", +exclude = [ ".bzr", ".direnv", ".eggs", @@ -137,6 +116,23 @@ ignore = [ "tests", ] +[tool.ruff.lint] +select = [ + # pycodestyle + "E", + # Pyflakes + "F", + # pyupgrade + "UP", + # flake8-bugbear + "B", + # flake8-simplify + "SIM", + # isort + "I", +] + + [tool.ruff.lint.pydocstyle] From 0c50992ddf34df574df6974176b57dcfb2911065 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Wed, 17 Jul 2024 20:35:59 -0400 Subject: [PATCH 018/134] toml formatting --- pyproject.toml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 988591ca..b3ff1666 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -120,7 +120,7 @@ exclude = [ "examples", "docs", ] - + # Set the maximum line length to 79. line-length = 79 @@ -140,8 +140,5 @@ select = [ "I", ] - - - [tool.ruff.lint.pydocstyle] convention = "numpy" From 7f8aec45d8107f2e92caedd1bc1a0305da3eb3b2 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 18 Jul 2024 12:10:19 -0400 Subject: [PATCH 019/134] added addtional pre-commit hooks --- .pre-commit-config.yaml | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index e1fb863c..3a527f65 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -2,9 +2,23 @@ repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v2.3.0 hooks: + # Validates YAML files for syntax errors. - id: check-yaml + # Ensures files have a newline at the end. - id: end-of-file-fixer + # Removes trailing whitespace characters from files. - id: trailing-whitespace + # Renames test files to follow a standard naming convention, often starting with test_. + - id: name-tests-test + # Detects debug statments (e.g., print, console.log, etc.) left in code. + - id: debug-statements + # Checks for files that contain merge conflict strings (e.g., <<<<<<<, =======, >>>>>>>). + - id: check-merge-conflict + # Checks for large files added to the repository, typically to prevent accidental inclusion of large binaries or datasets. + - id: check-added-large-files + # Detects potential filename conflicts due to case-insensitive filesystems (e.g., Windows) where File.txt and file.txt would be considered the same. + - id: check-case-conflict + - repo: https://github.com/astral-sh/ruff-pre-commit rev: v0.1.4 hooks: From 3e78c47b67c892a01d2e36b970d016657c62d11e Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 18 Jul 2024 14:02:02 -0400 Subject: [PATCH 020/134] pre-commit edits --- .pre-commit-config.yaml | 43 ++++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 20 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3a527f65..b518258d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,28 +1,31 @@ repos: +- repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.1.4 + hooks: + # Run the formatter. + - id: ruff-format + # Run the linter. + - id: ruff + + - repo: https://github.com/pre-commit/pre-commit-hooks rev: v2.3.0 + # note: pre-commit runs top-to-bottom, so put the hooks that modify content first, + # followed by checks that might be more likely to pass after the modifactaion hooks (like flake8) hooks: - # Validates YAML files for syntax errors. - - id: check-yaml - # Ensures files have a newline at the end. - - id: end-of-file-fixer - # Removes trailing whitespace characters from files. - - id: trailing-whitespace - # Renames test files to follow a standard naming convention, often starting with test_. - - id: name-tests-test - # Detects debug statments (e.g., print, console.log, etc.) left in code. - - id: debug-statements - # Checks for files that contain merge conflict strings (e.g., <<<<<<<, =======, >>>>>>>). - - id: check-merge-conflict # Checks for large files added to the repository, typically to prevent accidental inclusion of large binaries or datasets. - id: check-added-large-files # Detects potential filename conflicts due to case-insensitive filesystems (e.g., Windows) where File.txt and file.txt would be considered the same. - id: check-case-conflict - -- repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.1.4 - hooks: - # Run the linter. - - id: ruff - # Run the formatter. - - id: ruff-format + # Checks for files that contain merge conflict strings (e.g., <<<<<<<, =======, >>>>>>>). + - id: check-merge-conflict + # Validates YAML files for syntax errors. + - id: check-yaml + # Detects debug statments (e.g., print, console.log, etc.) left in code. + - id: debug-statements + # Ensures files have a newline at the end. + - id: end-of-file-fixer + # Renames test files to follow a standard naming convention, often starting with test_. + - id: name-tests-test + # Removes trailing whitespace characters from files. + - id: trailing-whitespace From 089497cc66d33d3309e3851921f80c1201dd76fc Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 19 Jul 2024 11:24:51 -0400 Subject: [PATCH 021/134] default for max line length is 88 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index b3ff1666..c6dbf6c0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -121,7 +121,7 @@ exclude = [ "docs", ] -# Set the maximum line length to 79. +# Set the maximum line length to 79. Default is 88. line-length = 79 [tool.ruff.lint] From 1ae3d118f7fe6036d0a5a9731eb44ff953a204ad Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 19 Jul 2024 12:36:01 -0400 Subject: [PATCH 022/134] error in deploy file: pypi environment not defined --- .github/workflows/ci.yml | 6 +++--- .github/workflows/deploy.yml | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f6da1dbd..b35ec40a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -72,8 +72,8 @@ jobs: - name: Run tests with pytest run: | pytest -n auto --cov-report xml - - name: Upload coverage to Codecov - uses: codecov/codecov-action@7598e39340e1dff4d6ebf7cf07a5e8184bde67e7 # v4.0.1 + - name: Upload coverage to Codecov4 + uses: codecov/codecov-action@v4 #codecov/codecov-action@7598e39340e1dff4d6ebf7cf07a5e8184bde67e7 # v4.0.1 with: token: ${{ secrets.CODECOV_TOKEN }} all_tutorials_in_docs: @@ -149,6 +149,6 @@ jobs: runs-on: ubuntu-latest steps: - name: Decide whether all tests and notebooks succeeded - uses: re-actors/alls-green@afee1c1eac2a506084c274e9c02c8e0687b48d9e # v1.2.2 + uses: re-actors/alls-green@release/v1 #re-actors/alls-green@afee1c1eac2a506084c274e9c02c8e0687b48d9e # v1.2.2, link does not work anymore with: jobs: ${{ toJSON(needs) }} diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index 337f1d75..f55d24a6 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -82,8 +82,8 @@ jobs: publish: name: Upload release to Test PyPI needs: [build] - environment: pypi runs-on: ubuntu-latest + environment: pypi permissions: id-token: write # IMPORTANT: this permission is mandatory for trusted publishing steps: From 1e9fc9cfafc8f522574c8705c1ae053c627d7b54 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 20 Jul 2024 11:51:22 -0400 Subject: [PATCH 023/134] link changed to previous one in ci.yml --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b35ec40a..297e6523 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -149,6 +149,6 @@ jobs: runs-on: ubuntu-latest steps: - name: Decide whether all tests and notebooks succeeded - uses: re-actors/alls-green@release/v1 #re-actors/alls-green@afee1c1eac2a506084c274e9c02c8e0687b48d9e # v1.2.2, link does not work anymore + uses: re-actors/alls-green@afee1c1eac2a506084c274e9c02c8e0687b48d9e # v1.2.2 with: jobs: ${{ toJSON(needs) }} From 1d8a57f36422cfe79385f69ee0d551753f71d349 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sun, 4 Aug 2024 12:20:47 -0400 Subject: [PATCH 024/134] ruff linting and formatting combined in 1 action in CI and added to needs field in check --- .github/workflows/ci.yml | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 297e6523..c8eec470 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -121,22 +121,27 @@ jobs: print_all: false timeout: 5 retry_count: 3 - ruff-linting: + ruff_linting_formatting: runs-on: ubuntu-latest - name: Run Ruff linter steps: + - name: Run Ruff linter - uses: actions/checkout@v4 - uses: chartboost/ruff-action@v1 with: args: 'check' - ruff-formatting: - runs-on: ubuntu-latest - name: Run Ruff code formatting check - steps: + - name: Run Ruff code formatting check - uses: actions/checkout@v4 - uses: chartboost/ruff-action@v1 with: args: 'format --check' + # ruff-formatting: + # runs-on: ubuntu-latest + # name: Run Ruff code formatting check + # steps: + # - uses: actions/checkout@v4 + # - uses: chartboost/ruff-action@v1 + # with: + # args: 'format --check' check: if: always() @@ -146,6 +151,7 @@ jobs: - all_tutorials_in_docs - no_extra_nblinks - check_urls + - ruff_linting_formatting runs-on: ubuntu-latest steps: - name: Decide whether all tests and notebooks succeeded From e0678b89182110a634e22879e33fa59fff14c185 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sun, 4 Aug 2024 20:04:14 -0400 Subject: [PATCH 025/134] ci -- calling ruff directly instead of via action --- .github/workflows/ci.yml | 46 ++++++++++++++++++++++++++-------------- .pre-commit-config.yaml | 42 ++++++++++++++++++------------------ pyproject.toml | 1 - 3 files changed, 51 insertions(+), 38 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c8eec470..4fc6fc45 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -121,27 +121,40 @@ jobs: print_all: false timeout: 5 retry_count: 3 - ruff_linting_formatting: + ruff_linting: runs-on: ubuntu-latest + name: Run Ruff linter steps: - - name: Run Ruff linter - uses: actions/checkout@v4 - - uses: chartboost/ruff-action@v1 + - name: Install Python 3 + uses: actions/setup-python@v5 with: - args: 'check' - - name: Run Ruff code formatting check + python-version: 3.12 + cache: pip + cache-dependency-path: setup.py + - name: Install dependencies + run: | + pip install --upgrade --upgrade-strategy eager .[dev] + - name: Run ruff linter + run: | + ruff check + ruff_formatting: + runs-on: ubuntu-latest + name: Run Ruff code formatting check + steps: - uses: actions/checkout@v4 - - uses: chartboost/ruff-action@v1 + - name: Install Python 3 + uses: actions/setup-python@v5 with: - args: 'format --check' - # ruff-formatting: - # runs-on: ubuntu-latest - # name: Run Ruff code formatting check - # steps: - # - uses: actions/checkout@v4 - # - uses: chartboost/ruff-action@v1 - # with: - # args: 'format --check' + python-version: 3.12 + cache: pip + cache-dependency-path: setup.py + - name: Install dependencies + run: | + pip install --upgrade --upgrade-strategy eager .[dev] + - name: Run ruff formatter + run: | + ruff format --check check: if: always() @@ -151,7 +164,8 @@ jobs: - all_tutorials_in_docs - no_extra_nblinks - check_urls - - ruff_linting_formatting + - ruff_linting + - ruff_formatting runs-on: ubuntu-latest steps: - name: Decide whether all tests and notebooks succeeded diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index b518258d..70b54891 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -8,24 +8,24 @@ repos: - id: ruff -- repo: https://github.com/pre-commit/pre-commit-hooks - rev: v2.3.0 - # note: pre-commit runs top-to-bottom, so put the hooks that modify content first, - # followed by checks that might be more likely to pass after the modifactaion hooks (like flake8) - hooks: - # Checks for large files added to the repository, typically to prevent accidental inclusion of large binaries or datasets. - - id: check-added-large-files - # Detects potential filename conflicts due to case-insensitive filesystems (e.g., Windows) where File.txt and file.txt would be considered the same. - - id: check-case-conflict - # Checks for files that contain merge conflict strings (e.g., <<<<<<<, =======, >>>>>>>). - - id: check-merge-conflict - # Validates YAML files for syntax errors. - - id: check-yaml - # Detects debug statments (e.g., print, console.log, etc.) left in code. - - id: debug-statements - # Ensures files have a newline at the end. - - id: end-of-file-fixer - # Renames test files to follow a standard naming convention, often starting with test_. - - id: name-tests-test - # Removes trailing whitespace characters from files. - - id: trailing-whitespace +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v2.3.0 + # note: pre-commit runs top-to-bottom, so put the hooks that modify content first, + # followed by checks that might be more likely to pass after the modifactaion hooks (like flake8) + hooks: + # Checks for large files added to the repository, typically to prevent accidental inclusion of large binaries or datasets. + - id: check-added-large-files + # Detects potential filename conflicts due to case-insensitive filesystems (e.g., Windows) where File.txt and file.txt would be considered the same. + - id: check-case-conflict + # Checks for files that contain merge conflict strings (e.g., <<<<<<<, =======, >>>>>>>). + - id: check-merge-conflict + # Validates YAML files for syntax errors. + - id: check-yaml + # Detects debug statments (e.g., print, console.log, etc.) left in code. + - id: debug-statements + # Ensures files have a newline at the end. + - id: end-of-file-fixer + # Renames test files to follow a standard naming convention, often starting with test_. + - id: name-tests-test + # Removes trailing whitespace characters from files. + - id: trailing-whitespace diff --git a/pyproject.toml b/pyproject.toml index c6dbf6c0..8d73327d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -117,7 +117,6 @@ exclude = [ "site-packages", "venv", "tests", - "examples", "docs", ] From 8272ba23d115043e4d61ce1a85c409e88a5a219b Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sun, 4 Aug 2024 20:04:52 -0400 Subject: [PATCH 026/134] test --- examples/02_Eigendistortions.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 8b85fc29..181a1967 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -60,7 +60,8 @@ " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\")\n", "import os.path as op\n", - "import plenoptic as po" + "import plenoptic as po\n", + "\n" ] }, { From 34524f5f4bdebc68a14abe3d16d5bf909417584a Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sun, 4 Aug 2024 20:09:18 -0400 Subject: [PATCH 027/134] . --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 8d73327d..a16c526f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -86,7 +86,7 @@ testpaths = ["tests"] [tool.ruff] extend-include = ["*.ipynb"] -src = ['src'] +src = ["src", "tests"] # Exclude a variety of commonly ignored directories. exclude = [ ".bzr", From 9b5fb543acb5d9d127f762f8ec3698646748670b Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sun, 4 Aug 2024 20:12:58 -0400 Subject: [PATCH 028/134] null changes in notebook reverted --- examples/02_Eigendistortions.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 181a1967..8b85fc29 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -60,8 +60,7 @@ " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\")\n", "import os.path as op\n", - "import plenoptic as po\n", - "\n" + "import plenoptic as po" ] }, { From 38a41505a789d9367407e39fe5b2f900e5838f47 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sun, 4 Aug 2024 20:28:51 -0400 Subject: [PATCH 029/134] in ci, specifying to use ruff config from pyproject.toml --- .github/workflows/ci.yml | 4 ++-- .pre-commit-config.yaml | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 4fc6fc45..d3b7c0f1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -137,7 +137,7 @@ jobs: pip install --upgrade --upgrade-strategy eager .[dev] - name: Run ruff linter run: | - ruff check + ruff check --config=pyproject.toml ruff_formatting: runs-on: ubuntu-latest name: Run Ruff code formatting check @@ -154,7 +154,7 @@ jobs: pip install --upgrade --upgrade-strategy eager .[dev] - name: Run ruff formatter run: | - ruff format --check + ruff format --check --config=pyproject.toml check: if: always() diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 70b54891..f8538d78 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,8 +4,10 @@ repos: hooks: # Run the formatter. - id: ruff-format + args: [--config=pyproject.toml] # Run the linter. - id: ruff + args: [--config=pyproject.toml] - repo: https://github.com/pre-commit/pre-commit-hooks From c1fd8bcb131387240356fe85392b66b5ae2bb6b4 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 8 Aug 2024 10:47:10 -0400 Subject: [PATCH 030/134] updating some deprecated imports, isinstance for union of types, unsorted imports, f-strings, replaced single quote with double quotes and deleted trailing whitespace --- examples/00_quickstart.ipynb | 12 +- examples/02_Eigendistortions.ipynb | 14 +- examples/03_Steerable_Pyramid.ipynb | 18 +- examples/04_Perceptual_distance.ipynb | 15 +- examples/05_Geodesics.ipynb | 49 +- examples/06_Metamer.ipynb | 8 +- examples/07_Simple_MAD.ipynb | 17 +- examples/08_MAD_Competition.ipynb | 8 +- examples/09_Original_MAD.ipynb | 9 +- examples/Demo_Eigendistortion.ipynb | 4 +- examples/Display.ipynb | 6 +- examples/Metamer-Portilla-Simoncelli.ipynb | 32 +- examples/Synthesis_extensions.ipynb | 22 +- noxfile.py | 2 + src/plenoptic/__init__.py | 10 +- src/plenoptic/data/__init__.py | 28 +- src/plenoptic/data/data_utils.py | 14 +- src/plenoptic/data/fetch.py | 110 ++- src/plenoptic/metric/__init__.py | 4 +- src/plenoptic/metric/classes.py | 12 +- src/plenoptic/metric/perceptual_distance.py | 165 ++-- src/plenoptic/simulate/__init__.py | 2 +- .../canonical_computations/__init__.py | 4 +- .../canonical_computations/filters.py | 27 +- .../laplacian_pyramid.py | 3 +- .../canonical_computations/non_linearities.py | 29 +- .../steerable_pyramid_freq.py | 221 +++-- src/plenoptic/simulate/models/frontend.py | 109 ++- src/plenoptic/simulate/models/naive.py | 80 +- .../simulate/models/portilla_simoncelli.py | 171 ++-- src/plenoptic/synthesize/__init__.py | 2 +- src/plenoptic/synthesize/autodiff.py | 7 +- src/plenoptic/synthesize/eigendistortion.py | 129 ++- src/plenoptic/synthesize/geodesic.py | 281 ++++-- src/plenoptic/synthesize/mad_competition.py | 763 +++++++++------ src/plenoptic/synthesize/metamer.py | 873 +++++++++++------- src/plenoptic/synthesize/simple_metamer.py | 50 +- src/plenoptic/synthesize/synthesis.py | 179 ++-- src/plenoptic/tools/__init__.py | 12 +- src/plenoptic/tools/conv.py | 75 +- src/plenoptic/tools/convergence.py | 37 +- src/plenoptic/tools/data.py | 42 +- src/plenoptic/tools/display.py | 342 ++++--- src/plenoptic/tools/external.py | 128 ++- src/plenoptic/tools/optim.py | 15 +- src/plenoptic/tools/signal.py | 90 +- src/plenoptic/tools/stats.py | 26 +- src/plenoptic/tools/straightness.py | 48 +- src/plenoptic/tools/validate.py | 81 +- 49 files changed, 2749 insertions(+), 1636 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index faf80c8b..0526e39a 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -15,10 +15,11 @@ "metadata": {}, "outputs": [], "source": [ - "import plenoptic as po\n", - "import torch\n", - "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "import plenoptic as po\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "\n", @@ -83,7 +84,10 @@ ], "source": [ "# this is a convenience function for creating a simple Gaussian kernel\n", - "from plenoptic.simulate.canonical_computations.filters import circular_gaussian2d\n", + "from plenoptic.simulate.canonical_computations.filters import (\n", + " circular_gaussian2d,\n", + ")\n", + "\n", "\n", "# Simple rectified Gaussian convolutional model\n", "class SimpleModel(torch.nn.Module):\n", diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 8b85fc29..f75c9602 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -45,11 +45,14 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "import torch\n", - "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", "from torch import nn\n", + "\n", + "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -59,7 +62,6 @@ " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\")\n", - "import os.path as op\n", "import plenoptic as po" ] }, @@ -822,7 +824,7 @@ } ], "source": [ - "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=3);\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=3)\n", "po.synth.eigendistortion.display_eigendistortion(ed_resneta, -1, as_rgb=True, zoom=3);" ] }, @@ -1025,10 +1027,10 @@ } ], "source": [ - "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=2, title=\"top eigendist\");\n", - "po.synth.eigendistortion.display_eigendistortion(ed_resneta, -1, as_rgb=True, zoom=2, title=\"bottom eigendist\");\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=2, title=\"top eigendist\")\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, -1, as_rgb=True, zoom=2, title=\"bottom eigendist\")\n", "\n", - "po.synth.eigendistortion.display_eigendistortion(ed_resnetb, 0, as_rgb=True, zoom=2, title=\"top eigendist\");\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resnetb, 0, as_rgb=True, zoom=2, title=\"top eigendist\")\n", "po.synth.eigendistortion.display_eigendistortion(ed_resnetb, -1, as_rgb=True, zoom=2, title=\"bottom eigendist\");" ] }, diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index a1030fba..2b82cddf 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -21,6 +21,7 @@ "source": [ "import numpy as np\n", "import torch\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -30,20 +31,19 @@ " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\")\n", - "import torchvision.transforms as transforms\n", + "import matplotlib.pyplot as plt\n", "import torch.nn.functional as F\n", + "import torchvision.transforms as transforms\n", "from torch import nn\n", - "import matplotlib.pyplot as plt\n", "\n", - "import pyrtools as pt\n", "import plenoptic as po\n", "from plenoptic.simulate import SteerablePyramidFreq\n", - "from plenoptic.synthesize import Eigendistortion\n", "from plenoptic.tools.data import to_numpy\n", + "\n", "dtype = torch.float32\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "import os\n", "from tqdm.auto import tqdm\n", + "\n", "%load_ext autoreload\n", "\n", "%autoreload 2\n", @@ -218,7 +218,7 @@ ], "source": [ "print(pyr_coeffs.keys())\n", - "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=0);\n", + "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=0)\n", "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=1);" ] }, @@ -267,7 +267,7 @@ "#get the 3rd scale\n", "print(pyr.scales)\n", "pyr_coeffs_scale0 = pyr(im_batch, scales=[2])\n", - "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=0);\n", + "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=0)\n", "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=1);" ] }, @@ -323,7 +323,7 @@ ], "source": [ "# the same visualization machinery works for complex pyramids; what is shown is the magnitude of the coefficients\n", - "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=0);\n", + "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=0)\n", "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=1);" ] }, @@ -2310,7 +2310,7 @@ } ], "source": [ - "po.pyrshow(pyr_coeffs_complex, zoom=0.5);\n", + "po.pyrshow(pyr_coeffs_complex, zoom=0.5)\n", "po.pyrshow(pyr_coeffs_fixed_1, zoom=0.5);" ] }, diff --git a/examples/04_Perceptual_distance.ipynb b/examples/04_Perceptual_distance.ipynb index 46bd12f0..93a1c869 100644 --- a/examples/04_Perceptual_distance.ipynb +++ b/examples/04_Perceptual_distance.ipynb @@ -28,14 +28,15 @@ "outputs": [], "source": [ "import os\n", - "import io\n", + "\n", "import imageio\n", - "import plenoptic as po\n", - "import numpy as np\n", - "from scipy.stats import pearsonr, spearmanr\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "import torch\n", - "from PIL import Image" + "from PIL import Image\n", + "from scipy.stats import pearsonr, spearmanr\n", + "\n", + "import plenoptic as po" ] }, { @@ -80,6 +81,8 @@ "outputs": [], "source": [ "import tempfile\n", + "\n", + "\n", "def add_jpeg_artifact(img, quality):\n", " # need to convert this back to 2d 8-bit int for writing out as jpg\n", " img = po.to_numpy(img.squeeze() * 255).astype(np.uint8)\n", @@ -393,7 +396,7 @@ " folder / \"distorted_images\" / distorted_filename).convert(\"L\"))) / 255\n", " distorted_images = distorted_images[:, [0] + list(range(2, 17)) + list(range(18, 24))] # Remove color distortions\n", "\n", - " with open(folder/ \"mos.txt\", \"r\", encoding=\"utf-8\") as g:\n", + " with open(folder/ \"mos.txt\", encoding=\"utf-8\") as g:\n", " mos_values = list(map(float, g.readlines()))\n", " mos_values = np.array(mos_values).reshape([25, 24, 5])\n", " mos_values = mos_values[:, [0] + list(range(2, 17)) + list(range(18, 24))] # Remove color distortions\n", diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index a6fc4a13..73f32e30 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -36,20 +36,24 @@ } ], "source": [ - "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "%matplotlib inline\n", "\n", "import pyrtools as pt\n", + "\n", "import plenoptic as po\n", "from plenoptic.tools import to_numpy\n", + "\n", "%load_ext autoreload\n", "%autoreload 2\n", "\n", "import torch\n", "import torch.nn as nn\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -142,6 +146,8 @@ "outputs": [], "source": [ "import torch.fft\n", + "\n", + "\n", "class Fourier(nn.Module):\n", " def __init__(self, representation = 'amp'):\n", " super().__init__()\n", @@ -222,7 +228,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", "po.synth.geodesic.plot_deviation_from_line(moog, vid, ax=axes[1]);" ] }, @@ -243,7 +249,7 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.step_energy), alpha=.2);\n", + "plt.plot(po.to_numpy(moog.step_energy), alpha=.2)\n", "plt.plot(moog.step_energy.mean(1), 'r-', label='path energy')\n", "plt.axhline(torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2) ** 2 / moog.n_steps ** 2)\n", "plt.legend()\n", @@ -302,7 +308,7 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.dev_from_line[..., 1]));\n", + "plt.plot(po.to_numpy(moog.dev_from_line[..., 1]))\n", "\n", "plt.title('evolution of distance from representation line')\n", "plt.ylabel('distance from representation line')\n", @@ -361,7 +367,7 @@ "geodesic = to_numpy(moog.geodesic.squeeze())\n", "fig = pt.imshow([video[5], pixelfade[5], geodesic[5]],\n", " title=['video', 'pixelfade', 'geodesic'],\n", - " col_wrap=3, zoom=4);\n", + " col_wrap=3, zoom=4)\n", "\n", "size = geodesic.shape[-1]\n", "h, m , l = (size//2 + size//4, size//2, size//2 - size//4)\n", @@ -372,9 +378,9 @@ " a.axhline(line, lw=2)\n", "\n", "pt.imshow([video[:,l], pixelfade[:,l], geodesic[:,l]],\n", - " title=None, col_wrap=3, zoom=4);\n", + " title=None, col_wrap=3, zoom=4)\n", "pt.imshow([video[:,m], pixelfade[:,m], geodesic[:,m]],\n", - " title=None, col_wrap=3, zoom=4);\n", + " title=None, col_wrap=3, zoom=4)\n", "pt.imshow([video[:,h], pixelfade[:,h], geodesic[:,h]],\n", " title=None, col_wrap=3, zoom=4);" ] @@ -471,7 +477,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" ] }, @@ -518,7 +524,7 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.step_energy), alpha=.2);\n", + "plt.plot(po.to_numpy(moog.step_energy), alpha=.2)\n", "plt.plot(moog.step_energy.mean(1), 'r-', label='path energy')\n", "plt.axhline(torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2) ** 2 / moog.n_steps ** 2)\n", "plt.legend()\n", @@ -630,9 +636,9 @@ ], "source": [ "print('geodesic')\n", - "pt.imshow(list(geodesic), vrange='auto1', title=None, zoom=4);\n", + "pt.imshow(list(geodesic), vrange='auto1', title=None, zoom=4)\n", "print('diff')\n", - "pt.imshow(list(geodesic - pixelfade), vrange='auto1', title=None, zoom=4);\n", + "pt.imshow(list(geodesic - pixelfade), vrange='auto1', title=None, zoom=4)\n", "print('pixelfade')\n", "pt.imshow(list(pixelfade), vrange='auto1', title=None, zoom=4);" ] @@ -657,7 +663,7 @@ "# checking that the range constraint is met\n", "plt.hist(video.flatten(), histtype='step', density=True, label='video')\n", "plt.hist(pixelfade.flatten(), histtype='step', density=True, label='pixelfade')\n", - "plt.hist(geodesic.flatten(), histtype='step', density=True, label='geodesic');\n", + "plt.hist(geodesic.flatten(), histtype='step', density=True, label='geodesic')\n", "plt.title('signal value histogram')\n", "plt.legend(loc=1)\n", "plt.show()" @@ -716,9 +722,9 @@ "l = 90\n", "imgA = imgA[..., u:u+224, l:l+224]\n", "imgB = imgB[..., u:u+224, l:l+224]\n", - "po.imshow([imgA, imgB], as_rgb=True);\n", + "po.imshow([imgA, imgB], as_rgb=True)\n", "diff = imgA - imgB\n", - "po.imshow(diff);\n", + "po.imshow(diff)\n", "pt.image_compare(po.to_numpy(imgA, True), po.to_numpy(imgB, True));" ] }, @@ -739,7 +745,6 @@ } ], "source": [ - "from torchvision import models\n", "# Create a class that takes the nth layer output of a given model\n", "class NthLayer(torch.nn.Module):\n", " \"\"\"Wrap any model to get the response of an intermediate layer\n", @@ -820,7 +825,7 @@ "predA = po.to_numpy(models.vgg16(pretrained=True)(imgA))[0]\n", "predB = po.to_numpy(models.vgg16(pretrained=True)(imgB))[0]\n", "\n", - "plt.plot(predA);\n", + "plt.plot(predA)\n", "plt.plot(predB);" ] }, @@ -935,7 +940,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" ] }, @@ -1052,12 +1057,12 @@ } ], "source": [ - "po.imshow(moog.geodesic, as_rgb=True, zoom=2, title=None, vrange='auto0');\n", - "po.imshow(moog.pixelfade, as_rgb=True, zoom=2, title=None, vrange='auto0');\n", + "po.imshow(moog.geodesic, as_rgb=True, zoom=2, title=None, vrange='auto0')\n", + "po.imshow(moog.pixelfade, as_rgb=True, zoom=2, title=None, vrange='auto0')\n", "# per channel difference\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 0:1]], zoom=2, title=None, vrange='auto1');\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 1:2]], zoom=2, title=None, vrange='auto1');\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 2:]], zoom=2, title=None, vrange='auto1');\n", + "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 0:1]], zoom=2, title=None, vrange='auto1')\n", + "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 1:2]], zoom=2, title=None, vrange='auto1')\n", + "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 2:]], zoom=2, title=None, vrange='auto1')\n", "# exaggerated color difference\n", "po.imshow([po.tools.rescale((moog.geodesic - moog.pixelfade)[1:-1])], as_rgb=True, zoom=2, title=None);" ] diff --git a/examples/06_Metamer.ipynb b/examples/06_Metamer.ipynb index 16f5cc68..a35c4644 100644 --- a/examples/06_Metamer.ipynb +++ b/examples/06_Metamer.ipynb @@ -21,12 +21,12 @@ "metadata": {}, "outputs": [], "source": [ - "import plenoptic as po\n", - "from plenoptic.tools import to_numpy\n", "import imageio\n", - "import torch\n", - "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "import plenoptic as po\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "# Animation-related settings\n", diff --git a/examples/07_Simple_MAD.ipynb b/examples/07_Simple_MAD.ipynb index 964594a6..52b177b9 100644 --- a/examples/07_Simple_MAD.ipynb +++ b/examples/07_Simple_MAD.ipynb @@ -24,16 +24,19 @@ } ], "source": [ + "import matplotlib.pyplot as plt\n", + "import pyrtools as pt\n", + "import torch\n", + "\n", "import plenoptic as po\n", "from plenoptic.tools import to_numpy\n", - "import torch\n", - "import pyrtools as pt\n", - "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", - "import numpy as np\n", "import itertools\n", "\n", + "import numpy as np\n", + "\n", "%load_ext autoreload\n", "%autoreload 2" ] @@ -117,7 +120,7 @@ "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1])):\n", + "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1], strict=False)):\n", " name = f'{m1.__name__}_{t}'\n", " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values! \n", " po.tools.set_seed(10)\n", @@ -168,7 +171,7 @@ "source": [ "fig, axes = plt.subplots(2, 2, figsize=(10, 10))\n", "pal = {'l1_norm': 'C0', 'l2_norm': 'C1'}\n", - "for ax, (k, mad) in zip(axes.flatten(), all_mad.items()):\n", + "for ax, (k, mad) in zip(axes.flatten(), all_mad.items(), strict=False):\n", " ax.plot(mad.optimized_metric_loss, pal[mad.optimized_metric.__name__], label=mad.optimized_metric.__name__)\n", " ax.plot(mad.reference_metric_loss, pal[mad.reference_metric.__name__], label=mad.reference_metric.__name__)\n", " ax.set(title=k.capitalize().replace('_', ' '), xlabel='Iteration', ylabel='Loss')\n", @@ -406,7 +409,7 @@ "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1])):\n", + "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1], strict=False)):\n", " name = f'{m1.__name__}_{t}'\n", " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values! \n", " po.tools.set_seed(0)\n", diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index 5688609c..9b16f3df 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -35,14 +35,12 @@ } ], "source": [ - "import plenoptic as po\n", - "import imageio\n", - "import torch\n", - "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "\n", + "import plenoptic as po\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", - "import numpy as np\n", "import warnings\n", "\n", "%load_ext autoreload\n", diff --git a/examples/09_Original_MAD.ipynb b/examples/09_Original_MAD.ipynb index 7c02a123..d731dc7e 100644 --- a/examples/09_Original_MAD.ipynb +++ b/examples/09_Original_MAD.ipynb @@ -17,15 +17,8 @@ "metadata": {}, "outputs": [], "source": [ - "import imageio\n", - "import torch\n", - "import scipy.io as sio\n", - "import pyrtools as pt\n", - "from scipy.io import loadmat\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", "import plenoptic as po\n", - "import os.path as op\n", + "\n", "%matplotlib inline\n", "\n", "%load_ext autoreload\n", diff --git a/examples/Demo_Eigendistortion.ipynb b/examples/Demo_Eigendistortion.ipynb index 558c0ad6..c811a5dc 100644 --- a/examples/Demo_Eigendistortion.ipynb +++ b/examples/Demo_Eigendistortion.ipynb @@ -44,8 +44,9 @@ } ], "source": [ - "from plenoptic.synthesize import Eigendistortion\n", "from plenoptic.simulate.models import OnOff\n", + "from plenoptic.synthesize import Eigendistortion\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -57,6 +58,7 @@ " \"and restart the notebook kernel\")\n", "import torch\n", "from torch import nn\n", + "\n", "import plenoptic as po\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", diff --git a/examples/Display.ipynb b/examples/Display.ipynb index a62db0da..f3dbf6c8 100644 --- a/examples/Display.ipynb +++ b/examples/Display.ipynb @@ -18,8 +18,10 @@ "metadata": {}, "outputs": [], "source": [ - "import plenoptic as po\n", "import matplotlib.pyplot as plt\n", + "\n", + "import plenoptic as po\n", + "\n", "# so that relativfe sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "# Animation-related settings\n", @@ -28,8 +30,8 @@ "plt.rcParams['animation.writer'] = 'ffmpeg'\n", "plt.rcParams['animation.ffmpeg_args'] = ['-threads', '1']\n", "\n", - "import torch\n", "import numpy as np\n", + "import torch\n", "\n", "%load_ext autoreload\n", "%autoreload 2\n", diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index 8e0e1816..4772e233 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -15,20 +15,13 @@ } ], "source": [ - "import numpy as np\n", - "import matplotlib\n", + "\n", + "import einops\n", "import matplotlib.pyplot as plt\n", "import torch\n", + "\n", "import plenoptic as po\n", - "import scipy.io as sio\n", - "import os\n", - "import os.path as op\n", - "import einops\n", - "import glob\n", - "import math\n", - "import pyrtools as pt\n", - "from tqdm import tqdm\n", - "from PIL import Image\n", + "\n", "%load_ext autoreload\n", "%autoreload \n", "\n", @@ -375,7 +368,7 @@ "# send image and PS model to GPU, if available. then im_init and Metamer will also use GPU\n", "img = img.to(DEVICE)\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "im_init = (torch.rand_like(img)-.5) * .1 + img.mean();\n", + "im_init = (torch.rand_like(img)-.5) * .1 + img.mean()\n", "\n", "met = po.synth.MetamerCTF(img, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init,\n", " coarse_to_fine='together')\n", @@ -526,6 +519,8 @@ "# Be sure to run this cell.\n", "\n", "from collections import OrderedDict\n", + "\n", + "\n", "class PortillaSimoncelliRemove(po.simul.PortillaSimoncelli):\n", " r\"\"\"Model for measuring a subset of texture statistics reported by PortillaSimoncelli\n", "\n", @@ -670,7 +665,7 @@ "source": [ "# visualize results\n", "fig = po.imshow([metamer.image, metamer.metamer, metamer_remove.metamer], \n", - " title=['Target image', 'Full Statistics', 'Without Marginal Statistics'], vrange='auto1');\n", + " title=['Target image', 'Full Statistics', 'Without Marginal Statistics'], vrange='auto1')\n", "# add plots showing the different pixel intensity histograms\n", "fig.add_axes([.33, -1, .33, .9])\n", "fig.add_axes([.67, -1, .33, .9])\n", @@ -1377,8 +1372,8 @@ " target=None\n", " ):\n", " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", - " self.mask = mask;\n", - " self.target = target;\n", + " self.mask = mask\n", + " self.target = target\n", " \n", " def forward(self, image, scales=None):\n", " r\"\"\"Generate Texture Statistics representation of an image using the target for the masked portion\n", @@ -1439,7 +1434,7 @@ "source": [ "img_file = DATA_PATH / 'fig14b.jpg'\n", "img = po.tools.load_images(img_file).to(DEVICE)\n", - "im_init = (torch.rand_like(img)-.5) * .1 + img.mean();\n", + "im_init = (torch.rand_like(img)-.5) * .1 + img.mean()\n", "\n", "mask = torch.zeros(1,1,256,256).bool().to(DEVICE)\n", "ctr_dim = (img.shape[-2]//4, img.shape[-1]//4)\n", @@ -1995,7 +1990,6 @@ "metadata": {}, "outputs": [], "source": [ - "from collections import OrderedDict\n", "\n", "class PortillaSimoncelliMagMeans(po.simul.PortillaSimoncelli):\n", " r\"\"\"Include the magnitude means in the PS texture representation.\n", @@ -2143,11 +2137,11 @@ ], "source": [ "fig, axes = plt.subplots(2, 2, figsize=(21, 11), gridspec_kw={'width_ratios': [1, 3.1]})\n", - "for ax, im, info in zip(axes[:, 0], [met.metamer, met_mag_means.metamer], ['with', 'without']):\n", + "for ax, im, info in zip(axes[:, 0], [met.metamer, met_mag_means.metamer], ['with', 'without'], strict=False):\n", " po.imshow(im, ax=ax, title=f\"Metamer {info} magnitude means\")\n", " ax.xaxis.set_visible(False)\n", " ax.yaxis.set_visible(False)\n", - "model_mag_means.plot_representation(model_mag_means(met.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[0,1]);\n", + "model_mag_means.plot_representation(model_mag_means(met.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[0,1])\n", "model_mag_means.plot_representation(model_mag_means(met_mag_means.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[1,1]);" ] }, diff --git a/examples/Synthesis_extensions.ipynb b/examples/Synthesis_extensions.ipynb index d0d1efe1..0e49b31c 100644 --- a/examples/Synthesis_extensions.ipynb +++ b/examples/Synthesis_extensions.ipynb @@ -21,13 +21,15 @@ }, "outputs": [], "source": [ - "import plenoptic as po\n", - "from torch import Tensor\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", "import warnings\n", - "from typing import Union, Callable, Tuple, Optional\n", - "from typing_extensions import Literal\n", + "from collections.abc import Callable\n", + "from typing import Literal\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from torch import Tensor\n", + "\n", + "import plenoptic as po\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", @@ -46,13 +48,13 @@ "class MADCompetitionVariant(po.synth.MADCompetition):\n", " \"\"\"Initialize MADCompetition with an image instead!\"\"\"\n", " def __init__(self, image: Tensor,\n", - " optimized_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]],\n", - " reference_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]],\n", + " optimized_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor],\n", + " reference_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor],\n", " minmax: Literal['min', 'max'],\n", " initial_image: Tensor = None,\n", - " metric_tradeoff_lambda: Optional[float] = None,\n", + " metric_tradeoff_lambda: float | None = None,\n", " range_penalty_lambda: float = .1,\n", - " allowed_range: Tuple[float, float] = (0, 1)):\n", + " allowed_range: tuple[float, float] = (0, 1)):\n", " if initial_image is None:\n", " initial_image = torch.rand_like(image)\n", " super().__init__(image, optimized_metric, reference_metric,\n", diff --git a/noxfile.py b/noxfile.py index 58bc0d91..111564db 100644 --- a/noxfile.py +++ b/noxfile.py @@ -1,11 +1,13 @@ import nox + @nox.session(name="lint") def lint(session): # run linters session.install("ruff") session.run("ruff", "check", "--ignore", "D") + @nox.session(name="tests", python=["3.10", "3.11", "3.12"]) def tests(session): # run tests diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index a62bb3da..1b7f4621 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,10 +1,6 @@ +from . import data, metric, tools from . import simulate as simul from . import synthesize as synth -from . import metric -from . import tools -from . import data - -from .tools.display import imshow, animshow, pyrshow -from .tools.data import to_numpy, load_images - +from .tools.data import load_images, to_numpy +from .tools.display import animshow, imshow, pyrshow from .version import version as __version__ diff --git a/src/plenoptic/data/__init__.py b/src/plenoptic/data/__init__.py index b6527ec8..fd974a06 100644 --- a/src/plenoptic/data/__init__.py +++ b/src/plenoptic/data/__init__.py @@ -1,28 +1,38 @@ -from . import data_utils -from .fetch import fetch_data, DOWNLOADABLE_FILES import torch -__all__ = ['einstein', 'curie', 'parrot', 'reptile_skin', - 'color_wheel', 'fetch_data', 'DOWNLOADABLE_FILES'] +from . import data_utils +from .fetch import DOWNLOADABLE_FILES, fetch_data + +__all__ = [ + "einstein", + "curie", + "parrot", + "reptile_skin", + "color_wheel", + "fetch_data", + "DOWNLOADABLE_FILES", +] + + def __dir__(): return __all__ def einstein() -> torch.Tensor: - return data_utils.get('einstein') + return data_utils.get("einstein") def curie() -> torch.Tensor: - return data_utils.get('curie') + return data_utils.get("curie") def parrot(as_gray: bool = False) -> torch.Tensor: - return data_utils.get('parrot', as_gray=as_gray) + return data_utils.get("parrot", as_gray=as_gray) def reptile_skin() -> torch.Tensor: - return data_utils.get('reptile_skin') + return data_utils.get("reptile_skin") def color_wheel(as_gray: bool = False) -> torch.Tensor: - return data_utils.get('color_wheel', as_gray=as_gray) + return data_utils.get("color_wheel", as_gray=as_gray) diff --git a/src/plenoptic/data/data_utils.py b/src/plenoptic/data/data_utils.py index 037baffa..cfce7003 100644 --- a/src/plenoptic/data/data_utils.py +++ b/src/plenoptic/data/data_utils.py @@ -1,7 +1,5 @@ from importlib import resources from importlib.abc import Traversable -from typing import Union - from ..tools.data import load_images @@ -30,12 +28,18 @@ def get_path(item_name: str) -> Traversable: This function uses glob to search for files in the current directory matching the `item_name`. It is assumed that there is only one file matching the name regardless of its extension. """ - fhs = [file for file in resources.files("plenoptic.data").iterdir() if file.stem == item_name] - assert len(fhs) == 1, f"Expected exactly one file for {item_name}, but found {len(fhs)}." + fhs = [ + file + for file in resources.files("plenoptic.data").iterdir() + if file.stem == item_name + ] + assert ( + len(fhs) == 1 + ), f"Expected exactly one file for {item_name}, but found {len(fhs)}." return fhs[0] -def get(*item_names: str, as_gray: Union[None, bool] = None): +def get(*item_names: str, as_gray: None | bool = None): """Load an image based on the item name from the package's data resources. Parameters diff --git a/src/plenoptic/data/fetch.py b/src/plenoptic/data/fetch.py index 3606f644..905f99a6 100644 --- a/src/plenoptic/data/fetch.py +++ b/src/plenoptic/data/fetch.py @@ -5,54 +5,64 @@ """ REGISTRY = { - 'plenoptic-test-files.tar.gz': 'a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8', - 'ssim_images.tar.gz': '19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e', - 'ssim_analysis.mat': '921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24', - 'msssim_images.tar.gz': 'a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c', - 'MAD_results.tar.gz': '29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe', - 'portilla_simoncelli_matlab_test_vectors.tar.gz': '83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81', - 'portilla_simoncelli_test_vectors.tar.gz': 'd67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb', - 'portilla_simoncelli_images.tar.gz': '4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827', - 'portilla_simoncelli_synthesize.npz': '9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80', - 'portilla_simoncelli_synthesize_torch_v1.12.0.npz': '5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f', - 'portilla_simoncelli_synthesize_gpu.npz': '324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee', - 'portilla_simoncelli_scales.npz': 'eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a', - 'sample_images.tar.gz': '0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5', - 'test_images.tar.gz': 'eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554', - 'tid2013.tar.gz': 'bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0', - 'portilla_simoncelli_test_vectors_refactor.tar.gz': '2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a', - 'portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz': '9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47', - 'portilla_simoncelli_synthesize_gpu_ps-refactor.npz': '9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61', - 'portilla_simoncelli_scales_ps-refactor.npz': '1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf', + "plenoptic-test-files.tar.gz": "a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8", + "ssim_images.tar.gz": "19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e", + "ssim_analysis.mat": "921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24", + "msssim_images.tar.gz": "a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c", + "MAD_results.tar.gz": "29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe", + "portilla_simoncelli_matlab_test_vectors.tar.gz": "83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81", + "portilla_simoncelli_test_vectors.tar.gz": "d67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb", + "portilla_simoncelli_images.tar.gz": "4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827", + "portilla_simoncelli_synthesize.npz": "9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80", + "portilla_simoncelli_synthesize_torch_v1.12.0.npz": "5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f", + "portilla_simoncelli_synthesize_gpu.npz": "324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee", + "portilla_simoncelli_scales.npz": "eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a", + "sample_images.tar.gz": "0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5", + "test_images.tar.gz": "eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554", + "tid2013.tar.gz": "bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0", + "portilla_simoncelli_test_vectors_refactor.tar.gz": "2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a", + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": "9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47", + "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": "9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61", + "portilla_simoncelli_scales_ps-refactor.npz": "1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf", } OSF_TEMPLATE = "https://osf.io/{}/download" # these are all from the OSF project at https://osf.io/ts37w/. REGISTRY_URLS = { - 'plenoptic-test-files.tar.gz': OSF_TEMPLATE.format('q9kn8'), - 'ssim_images.tar.gz': OSF_TEMPLATE.format('j65tw'), - 'ssim_analysis.mat': OSF_TEMPLATE.format('ndtc7'), - 'msssim_images.tar.gz': OSF_TEMPLATE.format('5fuba'), - 'MAD_results.tar.gz': OSF_TEMPLATE.format('jwcsr'), - 'portilla_simoncelli_matlab_test_vectors.tar.gz': OSF_TEMPLATE.format('qtn5y'), - 'portilla_simoncelli_test_vectors.tar.gz': OSF_TEMPLATE.format('8r2gq'), - 'portilla_simoncelli_images.tar.gz': OSF_TEMPLATE.format('eqr3t'), - 'portilla_simoncelli_synthesize.npz': OSF_TEMPLATE.format('a7p9r'), - 'portilla_simoncelli_synthesize_torch_v1.12.0.npz': OSF_TEMPLATE.format('gbv8e'), - 'portilla_simoncelli_synthesize_gpu.npz': OSF_TEMPLATE.format('tn4y8'), - 'portilla_simoncelli_scales.npz': OSF_TEMPLATE.format('xhwv3'), - 'sample_images.tar.gz': OSF_TEMPLATE.format('6drmy'), - 'test_images.tar.gz': OSF_TEMPLATE.format('au3b8'), - 'tid2013.tar.gz': OSF_TEMPLATE.format('uscgv'), - 'portilla_simoncelli_test_vectors_refactor.tar.gz': OSF_TEMPLATE.format('ca7qt'), - 'portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz': OSF_TEMPLATE.format('vmwzd'), - 'portilla_simoncelli_synthesize_gpu_ps-refactor.npz': OSF_TEMPLATE.format('mqs6y'), - 'portilla_simoncelli_scales_ps-refactor.npz': OSF_TEMPLATE.format('nvpr4'), + "plenoptic-test-files.tar.gz": OSF_TEMPLATE.format("q9kn8"), + "ssim_images.tar.gz": OSF_TEMPLATE.format("j65tw"), + "ssim_analysis.mat": OSF_TEMPLATE.format("ndtc7"), + "msssim_images.tar.gz": OSF_TEMPLATE.format("5fuba"), + "MAD_results.tar.gz": OSF_TEMPLATE.format("jwcsr"), + "portilla_simoncelli_matlab_test_vectors.tar.gz": OSF_TEMPLATE.format( + "qtn5y" + ), + "portilla_simoncelli_test_vectors.tar.gz": OSF_TEMPLATE.format("8r2gq"), + "portilla_simoncelli_images.tar.gz": OSF_TEMPLATE.format("eqr3t"), + "portilla_simoncelli_synthesize.npz": OSF_TEMPLATE.format("a7p9r"), + "portilla_simoncelli_synthesize_torch_v1.12.0.npz": OSF_TEMPLATE.format( + "gbv8e" + ), + "portilla_simoncelli_synthesize_gpu.npz": OSF_TEMPLATE.format("tn4y8"), + "portilla_simoncelli_scales.npz": OSF_TEMPLATE.format("xhwv3"), + "sample_images.tar.gz": OSF_TEMPLATE.format("6drmy"), + "test_images.tar.gz": OSF_TEMPLATE.format("au3b8"), + "tid2013.tar.gz": OSF_TEMPLATE.format("uscgv"), + "portilla_simoncelli_test_vectors_refactor.tar.gz": OSF_TEMPLATE.format( + "ca7qt" + ), + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": OSF_TEMPLATE.format( + "vmwzd" + ), + "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": OSF_TEMPLATE.format( + "mqs6y" + ), + "portilla_simoncelli_scales_ps-refactor.npz": OSF_TEMPLATE.format("nvpr4"), } DOWNLOADABLE_FILES = list(REGISTRY_URLS.keys()) import pathlib -from typing import List + try: import pooch except ImportError: @@ -63,7 +73,7 @@ # Use the default cache folder for the operating system # Pooch uses appdirs (https://github.com/ActiveState/appdirs) to # select an appropriate directory for the cache on each platform. - path=pooch.os_cache('plenoptic'), + path=pooch.os_cache("plenoptic"), base_url="", urls=REGISTRY_URLS, registry=REGISTRY, @@ -72,7 +82,7 @@ ) -def find_shared_directory(paths: List[pathlib.Path]) -> pathlib.Path: +def find_shared_directory(paths: list[pathlib.Path]) -> pathlib.Path: """Find directory shared by all paths.""" for dir in paths[0].parents: if all([dir in p.parents for p in paths]): @@ -92,17 +102,19 @@ def fetch_data(dataset_name: str) -> pathlib.Path: """ if retriever is None: - raise ImportError("Missing optional dependency 'pooch'." - " Please use pip or " - "conda to install 'pooch'.") - if dataset_name.endswith('.tar.gz'): + raise ImportError( + "Missing optional dependency 'pooch'." + " Please use pip or " + "conda to install 'pooch'." + ) + if dataset_name.endswith(".tar.gz"): processor = pooch.Untar() else: processor = None - fname = retriever.fetch(dataset_name, - progressbar=True, - processor=processor) - if dataset_name.endswith('.tar.gz'): + fname = retriever.fetch( + dataset_name, progressbar=True, processor=processor + ) + if dataset_name.endswith(".tar.gz"): fname = find_shared_directory([pathlib.Path(f) for f in fname]) else: fname = pathlib.Path(fname) diff --git a/src/plenoptic/metric/__init__.py b/src/plenoptic/metric/__init__.py index 6f4e6f5e..5e4c47e4 100644 --- a/src/plenoptic/metric/__init__.py +++ b/src/plenoptic/metric/__init__.py @@ -1,4 +1,4 @@ -from .perceptual_distance import ssim, ms_ssim, nlpd, ssim_map +from .classes import NLP from .model_metric import model_metric from .naive import mse -from .classes import NLP +from .perceptual_distance import ms_ssim, nlpd, ssim, ssim_map diff --git a/src/plenoptic/metric/classes.py b/src/plenoptic/metric/classes.py index 6bc83860..52206cde 100644 --- a/src/plenoptic/metric/classes.py +++ b/src/plenoptic/metric/classes.py @@ -1,4 +1,5 @@ import torch + from .perceptual_distance import normalized_laplacian_pyramid @@ -15,6 +16,7 @@ class NLP(torch.nn.Module): ``torch.sqrt(torch.mean(x-y)**2))`` as the distance metric between representations. """ + def __init__(self): super().__init__() @@ -36,10 +38,16 @@ def forward(self, image): """ if image.shape[0] > 1 or image.shape[1] > 1: - raise Exception("For now, this only supports batch and channel size 1") + raise Exception( + "For now, this only supports batch and channel size 1" + ) activations = normalized_laplacian_pyramid(image) # activations is a list of tensors, each at a different scale # (down-sampled by factors of 2). To combine these into one # vector, we need to flatten each of them and then unsqueeze so # it is 3d - return torch.cat([i.flatten() for i in activations]).unsqueeze(0).unsqueeze(0) + return ( + torch.cat([i.flatten() for i in activations]) + .unsqueeze(0) + .unsqueeze(0) + ) diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index f70fd003..efeb9515 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -1,15 +1,14 @@ +import os +import warnings + import numpy as np import torch import torch.nn.functional as F -import warnings from ..simulate.canonical_computations import LaplacianPyramid from ..simulate.canonical_computations.filters import circular_gaussian2d from ..tools.conv import same_padding -import os -import pickle - DIRNAME = os.path.dirname(__file__) @@ -37,25 +36,39 @@ def _ssim_parts(img1, img2, pad=False): these work. """ - img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) + img_ranges = torch.as_tensor( + [[img1.min(), img1.max()], [img2.min(), img2.max()]] + ) if (img_ranges > 1).any() or (img_ranges < 0).any(): - warnings.warn("Image range falls outside [0, 1]." - f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " - "Continuing anyway...") + warnings.warn( + "Image range falls outside [0, 1]." + f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " + "Continuing anyway..." + ) if not img1.ndim == img2.ndim == 4: - raise Exception("Input images should have four dimensions: (batch, channel, height, width)") + raise Exception( + "Input images should have four dimensions: (batch, channel, height, width)" + ) if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: - raise Exception("Either img1 and img2 should have the same number of " - "elements in each dimension, or one of " - "them should be 1! But got shapes " - f"{img1.shape}, {img2.shape} instead") + if ( + img1.shape[i] != img2.shape[i] + and img1.shape[i] != 1 + and img2.shape[i] != 1 + ): + raise Exception( + "Either img1 and img2 should have the same number of " + "elements in each dimension, or one of " + "them should be 1! But got shapes " + f"{img1.shape}, {img2.shape} instead" + ) if img1.shape[1] > 1 or img2.shape[1] > 1: - warnings.warn("SSIM was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches).") + warnings.warn( + "SSIM was designed for grayscale images and here it will be computed separately for each " + "channel (so channels are treated in the same way as batches)." + ) if img1.dtype != img2.dtype: raise ValueError("Input images must have same dtype!") @@ -79,9 +92,13 @@ def _ssim_parts(img1, img2, pad=False): def windowed_average(img): padd = 0 (n_batches, n_channels, _, _) = img.shape - img = img.reshape(n_batches * n_channels, 1, img.shape[2], img.shape[3]) + img = img.reshape( + n_batches * n_channels, 1, img.shape[2], img.shape[3] + ) img_average = F.conv2d(img, window, padding=padd) - img_average = img_average.reshape(n_batches, n_channels, img_average.shape[2], img_average.shape[3]) + img_average = img_average.reshape( + n_batches, n_channels, img_average.shape[2], img_average.shape[3] + ) return img_average mu1 = windowed_average(img1) @@ -95,18 +112,20 @@ def windowed_average(img): sigma2_sq = windowed_average(img2 * img2) - mu2_sq sigma12 = windowed_average(img1 * img2) - mu1_mu2 - C1 = 0.01 ** 2 - C2 = 0.03 ** 2 + C1 = 0.01**2 + C2 = 0.03**2 # SSIM is the product of a luminance component, a contrast component, and a # structure component. The contrast-structure component has to be separated # when computing MS-SSIM. luminance_map = (2 * mu1_mu2 + C1) / (mu1_sq + mu2_sq + C1) - contrast_structure_map = (2.0 * sigma12 + C2) / (sigma1_sq + sigma2_sq + C2) + contrast_structure_map = (2.0 * sigma12 + C2) / ( + sigma1_sq + sigma2_sq + C2 + ) map_ssim = luminance_map * contrast_structure_map # the weight used for stability - weight = torch.log((1 + sigma1_sq/C2) * (1 + sigma2_sq/C2)) + weight = torch.log((1 + sigma1_sq / C2) * (1 + sigma2_sq / C2)) return map_ssim, contrast_structure_map, weight @@ -190,12 +209,14 @@ def ssim(img1, img2, weighted=False, pad=False): if not weighted: mssim = map_ssim.mean((-1, -2)) else: - mssim = (map_ssim*weight).sum((-1, -2)) / weight.sum((-1, -2)) + mssim = (map_ssim * weight).sum((-1, -2)) / weight.sum((-1, -2)) if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn("SSIM uses 11x11 convolutional kernel, but the height and/or " - "the width of the input image is smaller than 11, so the " - "kernel size is set to be the minimum of these two numbers.") + warnings.warn( + "SSIM uses 11x11 convolutional kernel, but the height and/or " + "the width of the input image is smaller than 11, so the " + "kernel size is set to be the minimum of these two numbers." + ) return mssim @@ -257,9 +278,11 @@ def ssim_map(img1, img2): """ if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn("SSIM uses 11x11 convolutional kernel, but the height and/or " - "the width of the input image is smaller than 11, so the " - "kernel size is set to be the minimum of these two numbers.") + warnings.warn( + "SSIM uses 11x11 convolutional kernel, but the height and/or " + "the width of the input image is smaller than 11, so the " + "kernel size is set to be the minimum of these two numbers." + ) return _ssim_parts(img1, img2)[0] @@ -326,24 +349,30 @@ def ms_ssim(img1, img2, power_factors=None): power_factors = [0.0448, 0.2856, 0.3001, 0.2363, 0.1333] def downsample(img): - img = F.pad(img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate") + img = F.pad( + img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate" + ) img = F.avg_pool2d(img, kernel_size=2) return img msssim = 1 for i in range(len(power_factors) - 1): _, contrast_structure_map, _ = _ssim_parts(img1, img2) - msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow(power_factors[i]) + msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow( + power_factors[i] + ) img1 = downsample(img1) img2 = downsample(img2) map_ssim, _, _ = _ssim_parts(img1, img2) msssim *= F.relu(map_ssim.mean((-1, -2))).pow(power_factors[-1]) if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn("SSIM uses 11x11 convolutional kernel, but for some scales " - "of the input image, the height and/or the width is smaller " - "than 11, so the kernel size in SSIM is set to be the " - "minimum of these two numbers for these scales.") + warnings.warn( + "SSIM uses 11x11 convolutional kernel, but for some scales " + "of the input image, the height and/or the width is smaller " + "than 11, so the kernel size in SSIM is set to be the " + "minimum of these two numbers for these scales." + ) return msssim @@ -366,8 +395,8 @@ def normalized_laplacian_pyramid(img): (_, channel, height, width) = img.size() N_scales = 6 - spatialpooling_filters = np.load(os.path.join(DIRNAME, 'DN_filts.npy')) - sigmas = np.load(os.path.join(DIRNAME, 'DN_sigmas.npy')) + spatialpooling_filters = np.load(os.path.join(DIRNAME, "DN_filts.npy")) + sigmas = np.load(os.path.join(DIRNAME, "DN_sigmas.npy")) L = LaplacianPyramid(n_scales=N_scales, scale_filter=True) laplacian_activations = L.forward(img) @@ -375,10 +404,18 @@ def normalized_laplacian_pyramid(img): padd = 2 normalized_laplacian_activations = [] for N_b in range(0, N_scales): - filt = torch.as_tensor(spatialpooling_filters[N_b], dtype=torch.float32, - device=img.device).repeat(channel, 1, 1, 1) - filtered_activations = F.conv2d(torch.abs(laplacian_activations[N_b]), filt, padding=padd, groups=channel) - normalized_laplacian_activations.append(laplacian_activations[N_b] / (sigmas[N_b] + filtered_activations)) + filt = torch.as_tensor( + spatialpooling_filters[N_b], dtype=torch.float32, device=img.device + ).repeat(channel, 1, 1, 1) + filtered_activations = F.conv2d( + torch.abs(laplacian_activations[N_b]), + filt, + padding=padd, + groups=channel, + ) + normalized_laplacian_activations.append( + laplacian_activations[N_b] / (sigmas[N_b] + filtered_activations) + ) return normalized_laplacian_activations @@ -425,31 +462,47 @@ def nlpd(img1, img2): """ if not img1.ndim == img2.ndim == 4: - raise Exception("Input images should have four dimensions: (batch, channel, height, width)") + raise Exception( + "Input images should have four dimensions: (batch, channel, height, width)" + ) if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: - raise Exception("Either img1 and img2 should have the same number of " - "elements in each dimension, or one of " - "them should be 1! But got shapes " - f"{img1.shape}, {img2.shape} instead") + if ( + img1.shape[i] != img2.shape[i] + and img1.shape[i] != 1 + and img2.shape[i] != 1 + ): + raise Exception( + "Either img1 and img2 should have the same number of " + "elements in each dimension, or one of " + "them should be 1! But got shapes " + f"{img1.shape}, {img2.shape} instead" + ) if img1.shape[1] > 1 or img2.shape[1] > 1: - warnings.warn("NLPD was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches).") - - img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) + warnings.warn( + "NLPD was designed for grayscale images and here it will be computed separately for each " + "channel (so channels are treated in the same way as batches)." + ) + + img_ranges = torch.as_tensor( + [[img1.min(), img1.max()], [img2.min(), img2.max()]] + ) if (img_ranges > 1).any() or (img_ranges < 0).any(): - warnings.warn("Image range falls outside [0, 1]." - f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " - "Continuing anyway...") - + warnings.warn( + "Image range falls outside [0, 1]." + f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " + "Continuing anyway..." + ) + y1 = normalized_laplacian_pyramid(img1) y2 = normalized_laplacian_pyramid(img2) epsilon = 1e-10 # for optimization purpose (stabilizing the gradient around zero) dist = [] for i in range(6): - dist.append(torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon)) + dist.append( + torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon) + ) return torch.stack(dist).mean(dim=0) diff --git a/src/plenoptic/simulate/__init__.py b/src/plenoptic/simulate/__init__.py index 9659b0ce..c82eb526 100644 --- a/src/plenoptic/simulate/__init__.py +++ b/src/plenoptic/simulate/__init__.py @@ -1,2 +1,2 @@ -from .models import * from .canonical_computations import * +from .models import * diff --git a/src/plenoptic/simulate/canonical_computations/__init__.py b/src/plenoptic/simulate/canonical_computations/__init__.py index b51ca84b..49d69cc4 100644 --- a/src/plenoptic/simulate/canonical_computations/__init__.py +++ b/src/plenoptic/simulate/canonical_computations/__init__.py @@ -1,4 +1,4 @@ +from .filters import * from .laplacian_pyramid import LaplacianPyramid -from .steerable_pyramid_freq import SteerablePyramidFreq from .non_linearities import * -from .filters import * +from .steerable_pyramid_freq import SteerablePyramidFreq diff --git a/src/plenoptic/simulate/canonical_computations/filters.py b/src/plenoptic/simulate/canonical_computations/filters.py index 098d7a79..d45c4568 100644 --- a/src/plenoptic/simulate/canonical_computations/filters.py +++ b/src/plenoptic/simulate/canonical_computations/filters.py @@ -1,13 +1,10 @@ -from typing import Union, Tuple - import torch from torch import Tensor -from warnings import warn __all__ = ["gaussian1d", "circular_gaussian2d"] -def gaussian1d(kernel_size: int = 11, std: Union[float, Tensor] = 1.5) -> Tensor: +def gaussian1d(kernel_size: int = 11, std: float | Tensor = 1.5) -> Tensor: """Normalized 1D Gaussian. 1d Gaussian of size `kernel_size`, centered half-way, with variable std @@ -35,14 +32,14 @@ def gaussian1d(kernel_size: int = 11, std: Union[float, Tensor] = 1.5) -> Tensor x = torch.arange(kernel_size).to(device) mu = kernel_size // 2 - gauss = torch.exp(-((x - mu) ** 2) / (2 * std ** 2)) + gauss = torch.exp(-((x - mu) ** 2) / (2 * std**2)) filt = gauss / gauss.sum() # normalize return filt def circular_gaussian2d( - kernel_size: Union[int, Tuple[int, int]], - std: Union[float, Tensor], + kernel_size: int | tuple[int, int], + std: float | Tensor, out_channels: int = 1, ) -> Tensor: """Creates normalized, centered circular 2D gaussian tensor with which to convolve. @@ -75,17 +72,23 @@ def circular_gaussian2d( assert out_channels >= 1, "number of filters must be positive integer" assert torch.all(std > 0.0), "stdev must be positive" assert len(std) == out_channels, "Number of stds must equal out_channels" - origin = torch.as_tensor(((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0)) + origin = torch.as_tensor( + ((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0) + ) origin = origin.to(device) - shift_y = torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] # height - shift_x = torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] # width + shift_y = ( + torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] + ) # height + shift_x = ( + torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] + ) # width (xramp, yramp) = torch.meshgrid(shift_y, shift_x) - log_filt = ((xramp ** 2) + (yramp ** 2)) + log_filt = (xramp**2) + (yramp**2) log_filt = log_filt.repeat(out_channels, 1, 1, 1) # 4D - log_filt = log_filt / (-2. * std ** 2).view(out_channels, 1, 1, 1) + log_filt = log_filt / (-2.0 * std**2).view(out_channels, 1, 1, 1) filt = torch.exp(log_filt) filt = filt / torch.sum(filt, dim=[1, 2, 3], keepdim=True) # normalize diff --git a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py index d51e3955..53fac227 100644 --- a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py +++ b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py @@ -1,11 +1,12 @@ import torch import torch.nn as nn + from ...tools.conv import blur_downsample, upsample_blur class LaplacianPyramid(nn.Module): """Laplacian Pyramid in Torch. - + The Laplacian pyramid [1]_ is a multiscale image representation. It decomposes the image by computing the local mean using Gaussian blurring filters and substracting it from the image and repeating this operation on diff --git a/src/plenoptic/simulate/canonical_computations/non_linearities.py b/src/plenoptic/simulate/canonical_computations/non_linearities.py index fec6a59c..839918c7 100644 --- a/src/plenoptic/simulate/canonical_computations/non_linearities.py +++ b/src/plenoptic/simulate/canonical_computations/non_linearities.py @@ -1,6 +1,7 @@ import torch + from ...tools.conv import blur_downsample, upsample_blur -from ...tools.signal import rectangular_to_polar, polar_to_rectangular +from ...tools.signal import polar_to_rectangular, rectangular_to_polar def rectangular_to_polar_dict(coeff_dict, residuals=False): @@ -28,12 +29,12 @@ def rectangular_to_polar_dict(coeff_dict, residuals=False): state = {} for key in coeff_dict.keys(): # ignore residuals - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): energy[key], state[key] = rectangular_to_polar(coeff_dict[key]) if residuals: - energy['residual_lowpass'] = coeff_dict['residual_lowpass'] - energy['residual_highpass'] = coeff_dict['residual_highpass'] + energy["residual_lowpass"] = coeff_dict["residual_lowpass"] + energy["residual_highpass"] = coeff_dict["residual_highpass"] return energy, state @@ -63,12 +64,12 @@ def polar_to_rectangular_dict(energy, state, residuals=True): for key in energy.keys(): # ignore residuals - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): coeff_dict[key] = polar_to_rectangular(energy[key], state[key]) if residuals: - coeff_dict['residual_lowpass'] = energy['residual_lowpass'] - coeff_dict['residual_highpass'] = energy['residual_highpass'] + coeff_dict["residual_lowpass"] = energy["residual_lowpass"] + coeff_dict["residual_highpass"] = energy["residual_highpass"] return coeff_dict @@ -111,7 +112,7 @@ def local_gain_control(x, epsilon=1e-8): # these could be parameters, but no use case so far p = 2.0 - norm = blur_downsample(torch.abs(x ** p)).pow(1 / p) + norm = blur_downsample(torch.abs(x**p)).pow(1 / p) odd = torch.as_tensor(x.shape)[2:4] % 2 direction = x / (upsample_blur(norm, odd) + epsilon) @@ -190,12 +191,12 @@ def local_gain_control_dict(coeff_dict, residuals=True): state = {} for key in coeff_dict.keys(): - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): energy[key], state[key] = local_gain_control(coeff_dict[key]) if residuals: - energy['residual_lowpass'] = coeff_dict['residual_lowpass'] - energy['residual_highpass'] = coeff_dict['residual_highpass'] + energy["residual_lowpass"] = coeff_dict["residual_lowpass"] + energy["residual_highpass"] = coeff_dict["residual_highpass"] return energy, state @@ -230,11 +231,11 @@ def local_gain_release_dict(energy, state, residuals=True): coeff_dict = {} for key in energy.keys(): - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): coeff_dict[key] = local_gain_release(energy[key], state[key]) if residuals: - coeff_dict['residual_lowpass'] = energy['residual_lowpass'] - coeff_dict['residual_highpass'] = energy['residual_highpass'] + coeff_dict["residual_lowpass"] = energy["residual_lowpass"] + coeff_dict["residual_highpass"] = energy["residual_highpass"] return coeff_dict diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 5a6cf090..4b8fc189 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -5,23 +5,24 @@ """ import warnings from collections import OrderedDict -from typing import List, Optional, Tuple, Union +from typing import Literal, Union import numpy as np import torch import torch.fft as fft import torch.nn as nn from einops import rearrange +from numpy.typing import NDArray from scipy.special import factorial from torch import Tensor -from typing_extensions import Literal -from numpy.typing import NDArray from ...tools.signal import interpolate1d, raised_cosine, steer complex_types = [torch.cdouble, torch.cfloat] SCALES_TYPE = Union[int, Literal["residual_lowpass", "residual_highpass"]] -KEYS_TYPE = Union[Tuple[int, int], Literal["residual_lowpass", "residual_highpass"]] +KEYS_TYPE = Union[ + tuple[int, int], Literal["residual_lowpass", "residual_highpass"] +] class SteerablePyramidFreq(nn.Module): @@ -95,15 +96,14 @@ class SteerablePyramidFreq(nn.Module): def __init__( self, - image_shape: Tuple[int, int], - height: Union[Literal["auto"], int] = "auto", + image_shape: tuple[int, int], + height: Literal["auto"] | int = "auto", order: int = 3, twidth: int = 1, is_complex: bool = False, downsample: bool = True, tight_frame: bool = False, ): - super().__init__() self.pyr_size = OrderedDict() @@ -111,7 +111,9 @@ def __init__( self.image_shape = image_shape if (self.image_shape[0] % 2 != 0) or (self.image_shape[1] % 2 != 0): - warnings.warn("Reconstruction will not be perfect with odd-sized images") + warnings.warn( + "Reconstruction will not be perfect with odd-sized images" + ) self.is_complex = is_complex self.downsample = downsample @@ -129,11 +131,16 @@ def __init__( ) self.alpha = (self.Xcosn + np.pi) % (2 * np.pi) - np.pi - max_ht = np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) - 2 + max_ht = ( + np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) + - 2 + ) if height == "auto": self.num_scales = int(max_ht) elif height > max_ht: - raise ValueError("Cannot build pyramid higher than %d levels." % (max_ht)) + raise ValueError( + "Cannot build pyramid higher than %d levels." % (max_ht) + ) else: self.num_scales = int(height) @@ -151,7 +158,8 @@ def __init__( ctr = np.ceil((np.array(dims) + 0.5) / 2).astype(int) (xramp, yramp) = np.meshgrid( - np.linspace(-1, 1, dims[1] + 1)[:-1], np.linspace(-1, 1, dims[0] + 1)[:-1] + np.linspace(-1, 1, dims[1] + 1)[:-1], + np.linspace(-1, 1, dims[0] + 1)[:-1], ) self.angle = np.arctan2(yramp, xramp) @@ -160,7 +168,9 @@ def __init__( self.log_rad = np.log2(log_rad) # radial transition function (a raised cosine in log-frequency): - self.Xrcos, Yrcos = raised_cosine(twidth, (-twidth / 2.0), np.array([0, 1])) + self.Xrcos, Yrcos = raised_cosine( + twidth, (-twidth / 2.0), np.array([0, 1]) + ) self.Yrcos = np.sqrt(Yrcos) self.YIrcos = np.sqrt(1.0 - self.Yrcos**2) @@ -168,9 +178,8 @@ def __init__( # create low and high masks lo0mask = interpolate1d(self.log_rad, self.YIrcos, self.Xrcos) hi0mask = interpolate1d(self.log_rad, self.Yrcos, self.Xrcos) - self.register_buffer('lo0mask', torch.as_tensor(lo0mask).unsqueeze(0)) - self.register_buffer('hi0mask', torch.as_tensor(hi0mask).unsqueeze(0)) - + self.register_buffer("lo0mask", torch.as_tensor(lo0mask).unsqueeze(0)) + self.register_buffer("hi0mask", torch.as_tensor(hi0mask).unsqueeze(0)) # need a mock image to down-sample so that we correctly # construct the differently-sized masks @@ -199,7 +208,10 @@ def __init__( const = ( (2 ** (2 * self.order)) * (factorial(self.order, exact=True) ** 2) - / float(self.num_orientations * factorial(2 * self.order, exact=True)) + / float( + self.num_orientations + * factorial(2 * self.order, exact=True) + ) ) if self.is_complex: @@ -209,32 +221,50 @@ def __init__( * (np.cos(self.Xcosn) ** self.order) * (np.abs(self.alpha) < np.pi / 2.0).astype(int) ) - Ycosn_recon = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + Ycosn_recon = ( + np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + ) else: - Ycosn_forward = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + Ycosn_forward = ( + np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + ) Ycosn_recon = Ycosn_forward himask = interpolate1d(log_rad, self.Yrcos, Xrcos) - self.register_buffer(f'_himasks_scale_{i}', torch.as_tensor(himask).unsqueeze(0)) + self.register_buffer( + f"_himasks_scale_{i}", torch.as_tensor(himask).unsqueeze(0) + ) anglemasks = [] anglemasks_recon = [] for b in range(self.num_orientations): anglemask = interpolate1d( - angle, Ycosn_forward, self.Xcosn + np.pi * b / self.num_orientations + angle, + Ycosn_forward, + self.Xcosn + np.pi * b / self.num_orientations, ) anglemask_recon = interpolate1d( - angle, Ycosn_recon, self.Xcosn + np.pi * b / self.num_orientations + angle, + Ycosn_recon, + self.Xcosn + np.pi * b / self.num_orientations, ) anglemasks.append(torch.as_tensor(anglemask).unsqueeze(0)) - anglemasks_recon.append(torch.as_tensor(anglemask_recon).unsqueeze(0)) + anglemasks_recon.append( + torch.as_tensor(anglemask_recon).unsqueeze(0) + ) - self.register_buffer(f'_anglemasks_scale_{i}', torch.cat(anglemasks)) - self.register_buffer(f'_anglemasks_recon_scale_{i}', torch.cat(anglemasks_recon)) + self.register_buffer( + f"_anglemasks_scale_{i}", torch.cat(anglemasks) + ) + self.register_buffer( + f"_anglemasks_recon_scale_{i}", torch.cat(anglemasks_recon) + ) if not self.downsample: lomask = interpolate1d(log_rad, self.YIrcos, Xrcos) - self.register_buffer(f'_lomasks_scale_{i}', torch.as_tensor(lomask).unsqueeze(0)) + self.register_buffer( + f"_lomasks_scale_{i}", torch.as_tensor(lomask).unsqueeze(0) + ) self._loindices.append([np.array([0, 0]), dims]) lodft = lodft * lomask @@ -253,7 +283,9 @@ def __init__( angle = angle[lostart[0] : loend[0], lostart[1] : loend[1]] lomask = interpolate1d(log_rad, self.YIrcos, Xrcos) - self.register_buffer(f'_lomasks_scale_{i}', torch.as_tensor(lomask).unsqueeze(0)) + self.register_buffer( + f"_lomasks_scale_{i}", torch.as_tensor(lomask).unsqueeze(0) + ) # subsampling lodft = lodft[lostart[0] : loend[0], lostart[1] : loend[1]] # convolution in spatial domain @@ -265,7 +297,7 @@ def __init__( def forward( self, x: Tensor, - scales: Optional[List[SCALES_TYPE]] = None, + scales: list[SCALES_TYPE] | None = None, ) -> OrderedDict: r"""Generate the steerable pyramid coefficients for an image @@ -305,7 +337,9 @@ def forward( # x is a torch tensor batch of images of size (batch, channel, height, # width) - assert len(x.shape) == 4, "Input must be batch of images of shape BxCxHxW" + assert ( + len(x.shape) == 4 + ), "Input must be batch of images of shape BxCxHxW" imdft = fft.fft2(x, dim=(-2, -1), norm=self.fft_norm) imdft = fft.fftshift(imdft) @@ -322,20 +356,18 @@ def forward( lodft = imdft * lo0mask for i in range(self.num_scales): - if i in scales: # high-pass mask is selected based on the current scale - himask = getattr(self, f'_himasks_scale_{i}') + himask = getattr(self, f"_himasks_scale_{i}") # compute filter output at each orientation for b in range(self.num_orientations): - # band pass filtering is done in the fourier space as multiplying by the fft of a gaussian derivative. # The oriented dft is computed as a product of the fft of the low-passed component, # the precomputed anglemask (specifies orientation), and the precomputed hipass mask (creating a bandpass filter) # the complex_const variable comes from the Fourier transform of a gaussian derivative. # Based on the order of the gaussian, this constant changes. - anglemask = getattr(self, f'_anglemasks_scale_{i}')[b] + anglemask = getattr(self, f"_anglemasks_scale_{i}")[b] complex_const = np.power(complex(0, -1), self.order) banddft = complex_const * lodft * anglemask * himask @@ -348,7 +380,6 @@ def forward( if not self.is_complex: pyr_coeffs[(i, b)] = band.real else: - # Because the input signal is real, to maintain a tight frame # if the complex pyramid is used, magnitudes need to be divided by sqrt(2) # because energy is doubled. @@ -361,7 +392,7 @@ def forward( if not self.downsample: # no subsampling of angle and rad # just use lo0mask - lomask = getattr(self, f'_lomasks_scale_{i}') + lomask = getattr(self, f"_lomasks_scale_{i}") lodft = lodft * lomask # because we don't subsample here, if we are not using orthonormalization that @@ -378,9 +409,11 @@ def forward( angle = angle[lostart[0] : loend[0], lostart[1] : loend[1]] # subsampling of the dft for next scale - lodft = lodft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] + lodft = lodft[ + :, :, lostart[0] : loend[0], lostart[1] : loend[1] + ] # low-pass filter mask is selected - lomask = getattr(self, f'_lomasks_scale_{i}') + lomask = getattr(self, f"_lomasks_scale_{i}") # again multiply dft by subsampled mask (convolution in spatial domain) lodft = lodft * lomask @@ -397,7 +430,7 @@ def forward( @staticmethod def convert_pyr_to_tensor( pyr_coeffs: OrderedDict, split_complex: bool = False - ) -> Tuple[Tensor, Tuple[int, bool, List[KEYS_TYPE]]]: + ) -> tuple[Tensor, tuple[int, bool, list[KEYS_TYPE]]]: r"""Convert coefficient dictionary to a tensor. The output tensor has shape (batch, channel, height, width) and is @@ -473,10 +506,10 @@ def convert_pyr_to_tensor( try: pyr_tensor = torch.cat(coeff_list, dim=1) pyr_info = tuple([num_channels, split_complex, pyr_keys]) - except RuntimeError as e: + except RuntimeError: raise Exception( - """feature maps could not be concatenated into tensor. - Check that you are using coefficients that are not downsampled across scales. + """feature maps could not be concatenated into tensor. + Check that you are using coefficients that are not downsampled across scales. This is done with the 'downsample=False' argument for the pyramid""" ) @@ -487,7 +520,7 @@ def convert_tensor_to_pyr( pyr_tensor: Tensor, num_channels: int, split_complex: bool, - pyr_keys: List[KEYS_TYPE], + pyr_keys: list[KEYS_TYPE], ) -> OrderedDict: r"""Convert pyramid coefficient tensor to dictionary format. @@ -538,7 +571,8 @@ def convert_tensor_to_pyr( if split_complex: band = torch.view_as_complex( rearrange( - pyr_tensor[:, i : i + 2, ...], "b c h w -> b h w c" + pyr_tensor[:, i : i + 2, ...], + "b c h w -> b h w c", ) .unsqueeze(1) .contiguous() @@ -555,8 +589,8 @@ def convert_tensor_to_pyr( return pyr_coeffs def _recon_levels_check( - self, levels: Union[Literal["all"], List[SCALES_TYPE]] - ) -> List[SCALES_TYPE]: + self, levels: Literal["all"] | list[SCALES_TYPE] + ) -> list[SCALES_TYPE]: r"""Check whether levels arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), @@ -581,7 +615,9 @@ def _recon_levels_check( """ if isinstance(levels, str): if levels != "all": - raise TypeError(f"levels must be a list of levels or the string 'all' but got {levels}") + raise TypeError( + f"levels must be a list of levels or the string 'all' but got {levels}" + ) levels = ( ["residual_highpass"] + list(range(self.num_scales)) @@ -589,15 +625,18 @@ def _recon_levels_check( ) else: if not hasattr(levels, "__iter__"): - raise TypeError(f"levels must be a list of levels or the string 'all' but got {levels}") + raise TypeError( + f"levels must be a list of levels or the string 'all' but got {levels}" + ) levs_nums = np.array( [int(i) for i in levels if isinstance(i, int)] ) - assert (levs_nums >= 0).all(), "Level numbers must be non-negative." assert ( - levs_nums < self.num_scales - ).all(), "Level numbers must be in the range [0, %d]" % ( - self.num_scales - 1 + levs_nums >= 0 + ).all(), "Level numbers must be non-negative." + assert (levs_nums < self.num_scales).all(), ( + "Level numbers must be in the range [0, %d]" + % (self.num_scales - 1) ) levs_tmp = list(np.sort(levs_nums)) # we want smallest first if "residual_highpass" in levels: @@ -620,8 +659,8 @@ def _recon_levels_check( return levels def _recon_bands_check( - self, bands: Union[Literal["all"], List[int]] - ) -> List[int]: + self, bands: Literal["all"] | list[int] + ) -> list[int]: """Check whether bands arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies @@ -644,26 +683,31 @@ def _recon_bands_check( """ if isinstance(bands, str): if bands != "all": - raise TypeError(f"bands must be a list of ints or the string 'all' but got {bands}") + raise TypeError( + f"bands must be a list of ints or the string 'all' but got {bands}" + ) bands = np.arange(self.num_orientations) else: if not hasattr(bands, "__iter__"): - raise TypeError(f"bands must be a list of ints or the string 'all' but got {bands}") + raise TypeError( + f"bands must be a list of ints or the string 'all' but got {bands}" + ) bands: NDArray = np.array(bands, ndmin=1) - assert (bands >= 0).all(), "Error: band numbers must be larger than 0." assert ( - bands < self.num_orientations - ).all(), "Error: band numbers must be in the range [0, %d]" % ( - self.num_orientations - 1 + bands >= 0 + ).all(), "Error: band numbers must be larger than 0." + assert (bands < self.num_orientations).all(), ( + "Error: band numbers must be in the range [0, %d]" + % (self.num_orientations - 1) ) return list(bands) def _recon_keys( self, - levels: Union[Literal["all"], List[SCALES_TYPE]], - bands: Union[Literal["all"], List[int]], - max_orientations: Optional[int] = None, - ) -> List[KEYS_TYPE]: + levels: Literal["all"] | list[SCALES_TYPE], + bands: Literal["all"] | list[int], + max_orientations: int | None = None, + ) -> list[KEYS_TYPE]: """Make a list of all the relevant keys from `pyr_coeffs` to use in pyramid reconstruction When reconstructing the input image (i.e., when calling `recon_pyr()`), @@ -701,11 +745,9 @@ def _recon_keys( for i in bands: if i >= max_orientations: warnings.warn( - ( - "You wanted band %d in the reconstruction but max_orientation" - " is %d, so we're ignoring that band" - % (i, max_orientations) - ) + "You wanted band %d in the reconstruction but max_orientation" + " is %d, so we're ignoring that band" + % (i, max_orientations) ) bands = [i for i in bands if i < max_orientations] recon_keys = [] @@ -722,8 +764,8 @@ def _recon_keys( def recon_pyr( self, pyr_coeffs: OrderedDict, - levels: Union[Literal["all"], List[SCALES_TYPE]] = "all", - bands: Union[Literal["all"], List[int]] = "all", + levels: Literal["all"] | list[SCALES_TYPE] = "all", + bands: Literal["all"] | list[int] = "all", ) -> Tensor: """Reconstruct the image or batch of images, optionally using subset of pyramid coefficients. @@ -788,7 +830,9 @@ def recon_pyr( # generate highpass residual Reconstruction if "residual_highpass" in recon_keys: hidft = fft.fft2( - pyr_coeffs["residual_highpass"], dim=(-2, -1), norm=self.fft_norm + pyr_coeffs["residual_highpass"], + dim=(-2, -1), + norm=self.fft_norm, ) hidft = fft.fftshift(hidft) @@ -801,7 +845,9 @@ def recon_pyr( # get output reconstruction by inverting the fft reconstruction = fft.ifftshift(outdft) - reconstruction = fft.ifft2(reconstruction, dim=(-2, -1), norm=self.fft_norm) + reconstruction = fft.ifft2( + reconstruction, dim=(-2, -1), norm=self.fft_norm + ) # get real part of reconstruction (if complex) reconstruction = reconstruction.real @@ -809,7 +855,7 @@ def recon_pyr( return reconstruction def _recon_levels( - self, pyr_coeffs: OrderedDict, recon_keys: List[KEYS_TYPE], scale: int + self, pyr_coeffs: OrderedDict, recon_keys: list[KEYS_TYPE], scale: int ) -> Tensor: """Recursive function used to build the reconstruction. Called by recon_pyr @@ -838,14 +884,14 @@ def _recon_levels( if scale == self.num_scales: if "residual_lowpass" in recon_keys: lodft = fft.fft2( - pyr_coeffs["residual_lowpass"], dim=(-2, -1), norm=self.fft_norm + pyr_coeffs["residual_lowpass"], + dim=(-2, -1), + norm=self.fft_norm, ) lodft = fft.fftshift(lodft) else: lodft = fft.fft2( - torch.zeros_like( - pyr_coeffs["residual_lowpass"] - ), + torch.zeros_like(pyr_coeffs["residual_lowpass"]), dim=(-2, -1), norm=self.fft_norm, ) @@ -854,12 +900,14 @@ def _recon_levels( # Reconstruct from orientation bands # update himask - himask = getattr(self, f'_himasks_scale_{scale}') + himask = getattr(self, f"_himasks_scale_{scale}") orientdft = torch.zeros_like(pyr_coeffs[(scale, 0)]) for b in range(self.num_orientations): if (scale, b) in recon_keys: - anglemask = getattr(self, f'_anglemasks_recon_scale_{scale}')[b] + anglemask = getattr(self, f"_anglemasks_recon_scale_{scale}")[ + b + ] coeffs = pyr_coeffs[(scale, b)] if self.tight_frame and self.is_complex: coeffs = coeffs * np.sqrt(2) @@ -875,7 +923,7 @@ def _recon_levels( lostart, loend = self._loindices[scale] # create lowpass mask - lomask = getattr(self, f'_lomasks_scale_{scale}') + lomask = getattr(self, f"_lomasks_scale_{scale}") # Recursively reconstruct by going to the next scale reslevdft = self._recon_levels(pyr_coeffs, recon_keys, scale + 1) @@ -883,17 +931,24 @@ def _recon_levels( if (not self.tight_frame) and (not self.downsample): reslevdft = reslevdft / 2 # create output for reconstruction result - resdft = torch.zeros_like(pyr_coeffs[(scale, 0)], dtype=torch.complex64) + resdft = torch.zeros_like( + pyr_coeffs[(scale, 0)], dtype=torch.complex64 + ) # place upsample and convolve lowpass component - resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = reslevdft * lomask + resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = ( + reslevdft * lomask + ) recondft = resdft + orientdft # add orientation interpolated and added images to the lowpass image return recondft def steer_coeffs( - self, pyr_coeffs: OrderedDict, angles: List[float], even_phase: bool = True - ) -> Tuple[dict, dict]: + self, + pyr_coeffs: OrderedDict, + angles: list[float], + even_phase: bool = True, + ) -> tuple[dict, dict]: """Steer pyramid coefficients to the specified angles This allows you to have filters that have the Gaussian derivative order specified in diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 7d1050dc..802de615 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -10,22 +10,25 @@ .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ -from typing import Tuple, Union, Callable +from collections import OrderedDict +from collections.abc import Callable +from warnings import warn import torch import torch.nn as nn import torch.nn.functional as F from torch import Tensor -from .naive import Gaussian, CenterSurround from ...tools.display import imshow from ...tools.signal import make_disk -from collections import OrderedDict -from warnings import warn - +from .naive import CenterSurround, Gaussian -__all__ = ["LinearNonlinear", "LuminanceGainControl", - "LuminanceContrastGainControl", "OnOff"] +__all__ = [ + "LinearNonlinear", + "LuminanceGainControl", + "LuminanceContrastGainControl", + "OnOff", +] class LinearNonlinear(nn.Module): @@ -66,12 +69,11 @@ class LinearNonlinear(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", - activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -112,7 +114,7 @@ def display_filters(self, zoom=5.0, **kwargs): class LuminanceGainControl(nn.Module): - """ Linear center-surround followed by luminance gain control and activation. + """Linear center-surround followed by luminance gain control and activation. Model is described in [1]_ and [2]_. Parameters @@ -150,14 +152,14 @@ class LuminanceGainControl(nn.Module): representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ + def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", - activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -201,17 +203,25 @@ def display_filters(self, zoom=5.0, **kwargs): dim=0, ).detach() - title = ["linear filt", "luminance filt",] + title = [ + "linear filt", + "luminance filt", + ] fig = imshow( - weights, title=title, col_wrap=2, zoom=zoom, vrange="indep0", **kwargs + weights, + title=title, + col_wrap=2, + zoom=zoom, + vrange="indep0", + **kwargs, ) return fig class LuminanceContrastGainControl(nn.Module): - """ Linear center-surround followed by luminance and contrast gain control, + """Linear center-surround followed by luminance and contrast gain control, and activation function. Model is described in [1]_ and [2]_. Parameters @@ -255,12 +265,11 @@ class LuminanceContrastGainControl(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", - activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -285,7 +294,9 @@ def forward(self, x: Tensor) -> Tensor: lum = self.luminance(x) lum_normed = linear / (1 + self.luminance_scalar * lum) - con = self.contrast(lum_normed.pow(2)).sqrt() + 1E-6 # avoid div by zero + con = ( + self.contrast(lum_normed.pow(2)).sqrt() + 1e-6 + ) # avoid div by zero con_normed = lum_normed / (1 + self.contrast_scalar * con) y = self.activation(con_normed) return y @@ -316,7 +327,12 @@ def display_filters(self, zoom=5.0, **kwargs): title = ["linear filt", "luminance filt", "contrast filt"] fig = imshow( - weights, title=title, col_wrap=3, zoom=zoom, vrange="indep0", **kwargs + weights, + title=title, + col_wrap=3, + zoom=zoom, + vrange="indep0", + **kwargs, ) return fig @@ -369,7 +385,7 @@ class OnOff(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", @@ -377,16 +393,20 @@ def __init__( activation: Callable[[Tensor], Tensor] = F.softplus, apply_mask: bool = False, cache_filt: bool = False, - ): super().__init__() if isinstance(kernel_size, int): kernel_size = (kernel_size, kernel_size) if pretrained: - assert kernel_size == (31, 31), "pretrained model has kernel_size (31, 31)" + assert kernel_size == ( + 31, + 31, + ), "pretrained model has kernel_size (31, 31)" if cache_filt is False: - warn("pretrained is True but cache_filt is False. Set cache_filt to " - "True for efficiency unless you are fine-tuning.") + warn( + "pretrained is True but cache_filt is False. Set cache_filt to " + "True for efficiency unless you are fine-tuning." + ) self.center_surround = CenterSurround( kernel_size=kernel_size, @@ -399,17 +419,17 @@ def __init__( ) self.luminance = Gaussian( - kernel_size=kernel_size, - out_channels=2, - pad_mode=pad_mode, - cache_filt=cache_filt, + kernel_size=kernel_size, + out_channels=2, + pad_mode=pad_mode, + cache_filt=cache_filt, ) self.contrast = Gaussian( - kernel_size=kernel_size, - out_channels=2, - pad_mode=pad_mode, - cache_filt=cache_filt, + kernel_size=kernel_size, + out_channels=2, + pad_mode=pad_mode, + cache_filt=cache_filt, ) # init scalar values around fitted parameters found in Berardino et al 2017 @@ -426,15 +446,23 @@ def __init__( def forward(self, x: Tensor) -> Tensor: linear = self.center_surround(x) lum = self.luminance(x) - lum_normed = linear / (1 + self.luminance_scalar.view(1, 2, 1, 1) * lum) + lum_normed = linear / ( + 1 + self.luminance_scalar.view(1, 2, 1, 1) * lum + ) - con = self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1E-6 # avoid div by 0 - con_normed = lum_normed / (1 + self.contrast_scalar.view(1, 2, 1, 1) * con) + con = ( + self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1e-6 + ) # avoid div by 0 + con_normed = lum_normed / ( + 1 + self.contrast_scalar.view(1, 2, 1, 1) * con + ) y = self.activation(con_normed) if self.apply_mask: im_shape = x.shape[-2:] - if self._disk is None or self._disk.shape != im_shape: # cache new mask + if ( + self._disk is None or self._disk.shape != im_shape + ): # cache new mask self._disk = make_disk(im_shape).to(x.device) if self._disk.device != x.device: self._disk = self._disk.to(x.device) @@ -443,7 +471,6 @@ def forward(self, x: Tensor) -> Tensor: return y - def display_filters(self, zoom=5.0, **kwargs): """Displays convolutional filters of model @@ -477,7 +504,12 @@ def display_filters(self, zoom=5.0, **kwargs): ] fig = imshow( - weights, title=title, col_wrap=2, zoom=zoom, vrange="indep0", **kwargs + weights, + title=title, + col_wrap=2, + zoom=zoom, + vrange="indep0", + **kwargs, ) return fig @@ -494,7 +526,6 @@ def _pretrained_state_dict() -> OrderedDict: ("center_surround.amplitude_ratio", torch.as_tensor([1.25])), ("luminance.std", torch.as_tensor([8.7366, 1.4751])), ("contrast.std", torch.as_tensor([2.7353, 1.5583])), - ] ) return state_dict diff --git a/src/plenoptic/simulate/models/naive.py b/src/plenoptic/simulate/models/naive.py index 16263abe..9b8a7035 100644 --- a/src/plenoptic/simulate/models/naive.py +++ b/src/plenoptic/simulate/models/naive.py @@ -1,8 +1,5 @@ -from typing import Union, Tuple, List import torch -from torch import nn, nn as nn, Tensor -from torch import Tensor -import numpy as np +from torch import Tensor, nn from torch.nn import functional as F from ...tools.conv import same_padding @@ -58,7 +55,7 @@ class Linear(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]] = (3, 3), + kernel_size: int | tuple[int, int] = (3, 3), pad_mode: str = "circular", default_filters: bool = True, ): @@ -73,10 +70,10 @@ def __init__( self.conv = nn.Conv2d(1, 2, kernel_size, bias=False) if default_filters: - var = torch.as_tensor(3.) + var = torch.as_tensor(3.0) f1 = circular_gaussian2d(kernel_size, std=torch.sqrt(var)) - f2 = circular_gaussian2d(kernel_size, std=torch.sqrt(var/3)) + f2 = circular_gaussian2d(kernel_size, std=torch.sqrt(var / 3)) f2 = f2 - f1 f2 = f2 / f2.sum() @@ -110,8 +107,8 @@ class Gaussian(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], - std: Union[float, Tensor] = 3.0, + kernel_size: int | tuple[int, int], + std: float | Tensor = 3.0, pad_mode: str = "reflect", out_channels: int = 1, cache_filt: bool = False, @@ -129,17 +126,19 @@ def __init__( self.out_channels = out_channels self.cache_filt = cache_filt - self.register_buffer('_filt', None) + self.register_buffer("_filt", None) @property def filt(self): if self._filt is not None: # use old filter return self._filt else: # create new filter, optionally cache it - filt = circular_gaussian2d(self.kernel_size, self.std, self.out_channels) + filt = circular_gaussian2d( + self.kernel_size, self.std, self.out_channels + ) if self.cache_filt: - self.register_buffer('_filt', filt) + self.register_buffer("_filt", filt) return filt def forward(self, x: Tensor, **conv2d_kwargs) -> Tensor: @@ -196,12 +195,12 @@ class CenterSurround(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], - on_center: Union[bool, List[bool, ]] = True, + kernel_size: int | tuple[int, int], + on_center: bool | list[bool,] = True, width_ratio_limit: float = 2.0, amplitude_ratio: float = 1.25, - center_std: Union[float, Tensor] = 1.0, - surround_std: Union[float, Tensor] = 4.0, + center_std: float | Tensor = 1.0, + surround_std: float | Tensor = 4.0, out_channels: int = 1, pad_mode: str = "reflect", cache_filt: bool = False, @@ -211,31 +210,46 @@ def __init__( # make sure each channel is on-off or off-on if isinstance(on_center, bool): on_center = [on_center] * out_channels - assert len(on_center) == out_channels, "len(on_center) must match out_channels" + assert ( + len(on_center) == out_channels + ), "len(on_center) must match out_channels" # make sure each channel has a center and surround std if isinstance(center_std, float) or center_std.shape == torch.Size([]): center_std = torch.ones(out_channels) * center_std - if isinstance(surround_std, float) or surround_std.shape == torch.Size([]): + if isinstance(surround_std, float) or surround_std.shape == torch.Size( + [] + ): surround_std = torch.ones(out_channels) * surround_std - assert len(center_std) == out_channels and len(surround_std) == out_channels, "stds must correspond to each out_channel" - assert width_ratio_limit > 1.0, "stdev of surround must be greater than center" - assert amplitude_ratio >= 1.0, "ratio of amplitudes must at least be 1." + assert ( + len(center_std) == out_channels + and len(surround_std) == out_channels + ), "stds must correspond to each out_channel" + assert ( + width_ratio_limit > 1.0 + ), "stdev of surround must be greater than center" + assert ( + amplitude_ratio >= 1.0 + ), "ratio of amplitudes must at least be 1." self.on_center = on_center self.kernel_size = kernel_size self.width_ratio_limit = width_ratio_limit - self.register_buffer("amplitude_ratio", torch.as_tensor(amplitude_ratio)) + self.register_buffer( + "amplitude_ratio", torch.as_tensor(amplitude_ratio) + ) self.center_std = nn.Parameter(torch.ones(out_channels) * center_std) - self.surround_std = nn.Parameter(torch.ones(out_channels) * surround_std) + self.surround_std = nn.Parameter( + torch.ones(out_channels) * surround_std + ) self.out_channels = out_channels self.pad_mode = pad_mode self.cache_filt = cache_filt - self.register_buffer('_filt', None) + self.register_buffer("_filt", None) @property def filt(self) -> Tensor: @@ -246,24 +260,32 @@ def filt(self) -> Tensor: on_amp = self.amplitude_ratio device = on_amp.device - filt_center = circular_gaussian2d(self.kernel_size, self.center_std, self.out_channels) - filt_surround = circular_gaussian2d(self.kernel_size, self.surround_std, self.out_channels) + filt_center = circular_gaussian2d( + self.kernel_size, self.center_std, self.out_channels + ) + filt_surround = circular_gaussian2d( + self.kernel_size, self.surround_std, self.out_channels + ) # sign is + or - depending on center is on or off - sign = torch.as_tensor([1. if x else -1. for x in self.on_center]).to(device) + sign = torch.as_tensor( + [1.0 if x else -1.0 for x in self.on_center] + ).to(device) sign = sign.view(self.out_channels, 1, 1, 1) filt = on_amp * (sign * (filt_center - filt_surround)) if self.cache_filt: - self.register_buffer('_filt', filt) + self.register_buffer("_filt", filt) return filt def _clamp_surround_std(self): """Clamps surround standard deviation to ratio_limit times center_std""" lower_bound = self.width_ratio_limit * self.center_std for i, lb in enumerate(lower_bound): - self.surround_std[i].data = self.surround_std[i].data.clamp(min=float(lb)) + self.surround_std[i].data = self.surround_std[i].data.clamp( + min=float(lb) + ) def forward(self, x: Tensor) -> Tensor: x = same_padding(x, self.kernel_size, pad_mode=self.pad_mode) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index 81545620..edc7d3d0 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -7,7 +7,7 @@ consider them as members of the same family of textures. """ from collections import OrderedDict -from typing import List, Optional, Tuple, Union +from typing import Literal, Union import einops import matplotlib as mpl @@ -17,16 +17,17 @@ import torch.fft import torch.nn as nn from torch import Tensor -from typing_extensions import Literal from ...tools import signal, stats from ...tools.data import to_numpy from ...tools.display import clean_stem_plot, clean_up_axes, update_stem from ...tools.validate import validate_input -from ..canonical_computations.steerable_pyramid_freq import SteerablePyramidFreq from ..canonical_computations.steerable_pyramid_freq import ( SCALES_TYPE as PYR_SCALES_TYPE, ) +from ..canonical_computations.steerable_pyramid_freq import ( + SteerablePyramidFreq, +) SCALES_TYPE = Union[Literal["pixel_statistics"], PYR_SCALES_TYPE] @@ -80,7 +81,7 @@ class PortillaSimoncelli(nn.Module): def __init__( self, - image_shape: Tuple[int, int], + image_shape: tuple[int, int], n_scales: int = 4, n_orientations: int = 4, spatial_corr_width: int = 9, @@ -146,8 +147,6 @@ def __init__( ] def _create_scales_shape_dict(self) -> OrderedDict: - - """Create dictionary defining scales and shape of each stat. This dictionary functions as metadata which is used for two main @@ -221,7 +220,11 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["kurtosis_reconstructed"] = scales_with_lowpass auto_corr = np.ones( - (self.spatial_corr_width, self.spatial_corr_width, self.n_scales + 1), + ( + self.spatial_corr_width, + self.spatial_corr_width, + self.n_scales + 1, + ), dtype=object, ) auto_corr *= einops.rearrange(scales_with_lowpass, "s -> 1 1 s") @@ -230,7 +233,8 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["std_reconstructed"] = scales_with_lowpass cross_orientation_corr_mag = np.ones( - (self.n_orientations, self.n_orientations, self.n_scales), dtype=int + (self.n_orientations, self.n_orientations, self.n_scales), + dtype=int, ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") shape_dict[ @@ -242,15 +246,21 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["magnitude_std"] = mags_std cross_scale_corr_mag = np.ones( - (self.n_orientations, self.n_orientations, self.n_scales - 1), dtype=int + (self.n_orientations, self.n_orientations, self.n_scales - 1), + dtype=int, + ) + cross_scale_corr_mag *= einops.rearrange( + scales_without_coarsest, "s -> 1 1 s" ) - cross_scale_corr_mag *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_magnitude"] = cross_scale_corr_mag cross_scale_corr_real = np.ones( - (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), dtype=int + (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), + dtype=int, + ) + cross_scale_corr_real *= einops.rearrange( + scales_without_coarsest, "s -> 1 1 s" ) - cross_scale_corr_real *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_real"] = cross_scale_corr_real shape_dict["var_highpass_residual"] = np.array(["residual_highpass"]) @@ -287,7 +297,9 @@ def _create_necessary_stats_dict( mask_dict = scales_shape_dict.copy() # Pre-compute some necessary indices. # Lower triangular indices (including diagonal), for auto correlations - tril_inds = torch.tril_indices(self.spatial_corr_width, self.spatial_corr_width) + tril_inds = torch.tril_indices( + self.spatial_corr_width, self.spatial_corr_width + ) # Get the second half of the diagonal, i.e., everything from the center # element on. These are all repeated for the auto correlations. (As # these are autocorrelations (rather than auto-covariance) matrices, @@ -300,9 +312,14 @@ def _create_necessary_stats_dict( # for cross_orientation_correlation_magnitude (because we've normalized # this matrix to be true cross-correlations, the diagonals are all 1, # like for the auto-correlations) - triu_inds = torch.triu_indices(self.n_orientations, self.n_orientations) + triu_inds = torch.triu_indices( + self.n_orientations, self.n_orientations + ) for k, v in mask_dict.items(): - if k in ["auto_correlation_magnitude", "auto_correlation_reconstructed"]: + if k in [ + "auto_correlation_magnitude", + "auto_correlation_reconstructed", + ]: # Symmetry M_{i,j} = M_{n-i+1, n-j+1} # Start with all False, then place True in necessary stats. mask = torch.zeros(v.shape, dtype=torch.bool) @@ -324,7 +341,7 @@ def _create_necessary_stats_dict( return mask_dict def forward( - self, image: Tensor, scales: Optional[List[SCALES_TYPE]] = None + self, image: Tensor, scales: list[SCALES_TYPE] | None = None ) -> Tensor: r"""Generate Texture Statistics representation of an image. @@ -372,14 +389,17 @@ def forward( # real_pyr_coeffs, which contain the demeaned magnitude of the pyramid # coefficients and the real part of the pyramid coefficients # respectively. - mag_pyr_coeffs, real_pyr_coeffs = self._compute_intermediate_representations( - pyr_coeffs - ) + ( + mag_pyr_coeffs, + real_pyr_coeffs, + ) = self._compute_intermediate_representations(pyr_coeffs) # Then, the reconstructed lowpass image at each scale. (this is a list # of length n_scales+1 containing tensors of shape (batch, channel, # height, width)) - reconstructed_images = self._reconstruct_lowpass_at_each_scale(pyr_dict) + reconstructed_images = self._reconstruct_lowpass_at_each_scale( + pyr_dict + ) # the reconstructed_images list goes from coarse-to-fine, but we want # each of the stats computed from it to go from fine-to-coarse, so we # reverse its direction. @@ -401,7 +421,9 @@ def forward( # tensor of shape (batch, channel, spatial_corr_width, # spatial_corr_width, n_scales+1), and var_recon is a tensor of shape # (batch, channel, n_scales+1) - autocorr_recon, var_recon = self._compute_autocorr(reconstructed_images) + autocorr_recon, var_recon = self._compute_autocorr( + reconstructed_images + ) # Compute the standard deviation, skew, and kurtosis of each # reconstructed lowpass image. std_recon, skew_recon, and # kurtosis_recon will all end up as tensors of shape (batch, channel, @@ -427,23 +449,28 @@ def forward( if self.n_scales != 1: # First, double the phase the coefficients, so we can correctly # compute correlations across scales. - phase_doubled_mags, phase_doubled_sep = self._double_phase_pyr_coeffs( - pyr_coeffs - ) + ( + phase_doubled_mags, + phase_doubled_sep, + ) = self._double_phase_pyr_coeffs(pyr_coeffs) # Compute the cross-scale correlations between the magnitude # coefficients. For each coefficient, we're correlating it with the # coefficients at the next-coarsest scale. this will be a tensor of # shape (batch, channel, n_orientations, n_orientations, # n_scales-1) cross_scale_corr_mags, _ = self._compute_cross_correlation( - mag_pyr_coeffs[:-1], phase_doubled_mags, tensors_are_identical=False + mag_pyr_coeffs[:-1], + phase_doubled_mags, + tensors_are_identical=False, ) # Compute the cross-scale correlations between the real # coefficients and the real and imaginary coefficients at the next # coarsest scale. this will be a tensor of shape (batch, channel, # n_orientations, 2*n_orientations, n_scales-1) cross_scale_corr_real, _ = self._compute_cross_correlation( - real_pyr_coeffs[:-1], phase_doubled_sep, tensors_are_identical=False + real_pyr_coeffs[:-1], + phase_doubled_sep, + tensors_are_identical=False, ) # Compute the variance of the highpass residual @@ -480,12 +507,14 @@ def forward( # Return the subset of stats corresponding to the specified scale. if scales is not None: - representation_tensor = self.remove_scales(representation_tensor, scales) + representation_tensor = self.remove_scales( + representation_tensor, scales + ) return representation_tensor def remove_scales( - self, representation_tensor: Tensor, scales_to_keep: List[SCALES_TYPE] + self, representation_tensor: Tensor, scales_to_keep: list[SCALES_TYPE] ) -> Tensor: """Remove statistics not associated with scales. @@ -590,7 +619,9 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: device=representation_tensor.device, ) # v.sum() gives the number of necessary elements from this stat - this_stat_vec = representation_tensor[..., n_filled : n_filled + v.sum()] + this_stat_vec = representation_tensor[ + ..., n_filled : n_filled + v.sum() + ] # use boolean indexing to put the values from new_stat_vec in the # appropriate place new_v[..., v] = this_stat_vec @@ -600,7 +631,7 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: def _compute_pyr_coeffs( self, image: Tensor - ) -> Tuple[OrderedDict, List[Tensor], Tensor, Tensor]: + ) -> tuple[OrderedDict, list[Tensor], Tensor, Tensor]: """Compute pyramid coefficients of image. Note that the residual lowpass has been demeaned independently for each @@ -642,7 +673,9 @@ def _compute_pyr_coeffs( # of shape (batch, channel, n_orientations, height, width) (note that # height and width halves on each scale) coeffs_list = [ - torch.stack([pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2) + torch.stack( + [pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2 + ) for i in range(self.n_scales) ] return pyr_coeffs, coeffs_list, highpass, lowpass @@ -679,12 +712,14 @@ def _compute_pixel_stats(image: Tensor) -> Tensor: # mean needed to be unflattened to be used by skew and kurtosis # correctly, but we'll want it to be flattened like this in the final # representation tensor - return einops.pack([mean, var, skew, kurtosis, img_min, img_max], "b c *")[0] + return einops.pack( + [mean, var, skew, kurtosis, img_min, img_max], "b c *" + )[0] @staticmethod def _compute_intermediate_representations( pyr_coeffs: Tensor - ) -> Tuple[List[Tensor], List[Tensor]]: + ) -> tuple[list[Tensor], list[Tensor]]: """Compute useful intermediate representations. These representations are: @@ -719,14 +754,17 @@ def _compute_intermediate_representations( mag.mean((-2, -1), keepdim=True) for mag in magnitude_pyr_coeffs ] magnitude_pyr_coeffs = [ - mag - mn for mag, mn in zip(magnitude_pyr_coeffs, magnitude_means) + mag - mn + for mag, mn in zip( + magnitude_pyr_coeffs, magnitude_means, strict=False + ) ] real_pyr_coeffs = [coeff.real for coeff in pyr_coeffs] return magnitude_pyr_coeffs, real_pyr_coeffs def _reconstruct_lowpass_at_each_scale( self, pyr_coeffs_dict: OrderedDict - ) -> List[Tensor]: + ) -> list[Tensor]: """Reconstruct the lowpass unoriented image at each scale. The autocorrelation, standard deviation, skew, and kurtosis of each of @@ -761,12 +799,15 @@ def _reconstruct_lowpass_at_each_scale( # values across scales. This could also be handled by making the # pyramid tight frame reconstructed_images[:-1] = [ - signal.shrink(r, 2 ** (self.n_scales - i)) * 4 ** (self.n_scales - i) + signal.shrink(r, 2 ** (self.n_scales - i)) + * 4 ** (self.n_scales - i) for i, r in enumerate(reconstructed_images[:-1]) ] return reconstructed_images - def _compute_autocorr(self, coeffs_list: List[Tensor]) -> Tuple[Tensor, Tensor]: + def _compute_autocorr( + self, coeffs_list: list[Tensor] + ) -> tuple[Tensor, Tensor]: """Compute the autocorrelation of some statistics. Parameters @@ -802,16 +843,18 @@ def _compute_autocorr(self, coeffs_list: List[Tensor]) -> Tuple[Tensor, Tensor]: ) acs = [signal.autocorrelation(coeff) for coeff in coeffs_list] var = [signal.center_crop(ac, 1) for ac in acs] - acs = [ac / v for ac, v in zip(acs, var)] + acs = [ac / v for ac, v in zip(acs, var, strict=False)] var = einops.pack(var, "b c *")[0] acs = [signal.center_crop(ac, self.spatial_corr_width) for ac in acs] acs = torch.stack(acs, 2) - return einops.rearrange(acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}"), var + return einops.rearrange( + acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}" + ), var @staticmethod def _compute_skew_kurtosis_recon( - reconstructed_images: List[Tensor], var_recon: Tensor, img_var: Tensor - ) -> Tuple[Tensor, Tensor]: + reconstructed_images: list[Tensor], var_recon: Tensor, img_var: Tensor + ) -> tuple[Tensor, Tensor]: """Compute the skew and kurtosis of each lowpass reconstructed image. For each scale, if the ratio of its variance to the original image's @@ -859,15 +902,17 @@ def _compute_skew_kurtosis_recon( res = torch.finfo(img_var.dtype).resolution unstable_locs = var_recon / img_var.unsqueeze(-1) < res skew_recon = torch.where(unstable_locs, skew_default, skew_recon) - kurtosis_recon = torch.where(unstable_locs, kurtosis_default, kurtosis_recon) + kurtosis_recon = torch.where( + unstable_locs, kurtosis_default, kurtosis_recon + ) return skew_recon, kurtosis_recon def _compute_cross_correlation( self, - coeffs_tensor: List[Tensor], - coeffs_tensor_other: List[Tensor], + coeffs_tensor: list[Tensor], + coeffs_tensor_other: list[Tensor], tensors_are_identical: bool = False, - ) -> Tuple[Tensor, Tensor]: + ) -> tuple[Tensor, Tensor]: """Compute cross-correlations. Parameters @@ -894,7 +939,9 @@ def _compute_cross_correlation( """ covars = [] coeffs_var = [] - for coeff, coeff_other in zip(coeffs_tensor, coeffs_tensor_other): + for coeff, coeff_other in zip( + coeffs_tensor, coeffs_tensor_other, strict=False + ): # precompute this, which we'll use for normalization numel = torch.mul(*coeff.shape[-2:]) # compute the covariance @@ -908,14 +955,18 @@ def _compute_cross_correlation( # First, compute the variances of each coeff (if coeff and # coeff_other are identical, this is equivalent to the diagonal of # the above covar matrix, but re-computing it is actually faster) - coeff_var = einops.einsum(coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1") + coeff_var = einops.einsum( + coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1" + ) coeff_var = coeff_var / numel coeffs_var.append(coeff_var) if tensors_are_identical: coeff_other_var = coeff_var else: coeff_other_var = einops.einsum( - coeff_other, coeff_other, "b c o2 h w, b c o2 h w -> b c o2" + coeff_other, + coeff_other, + "b c o2 h w, b c o2 h w -> b c o2", ) coeff_other_var = coeff_other_var / numel # Then compute the outer product of those variances. @@ -929,8 +980,8 @@ def _compute_cross_correlation( @staticmethod def _double_phase_pyr_coeffs( - pyr_coeffs: List[Tensor] - ) -> Tuple[List[Tensor], List[Tensor]]: + pyr_coeffs: list[Tensor] + ) -> tuple[list[Tensor], list[Tensor]]: """Upsample and double the phase of pyramid coefficients. Parameters @@ -971,19 +1022,21 @@ def _double_phase_pyr_coeffs( ) doubled_phase_mags.append(doubled_phase_mag) doubled_phase_sep.append( - einops.pack([doubled_phase.real, doubled_phase.imag], "b c * h w")[0] + einops.pack( + [doubled_phase.real, doubled_phase.imag], "b c * h w" + )[0] ) return doubled_phase_mags, doubled_phase_sep def plot_representation( self, data: Tensor, - ax: Optional[plt.Axes] = None, - figsize: Tuple[float, float] = (15, 15), - ylim: Optional[Union[Tuple[float, float], Literal[False]]] = None, + ax: plt.Axes | None = None, + figsize: tuple[float, float] = (15, 15), + ylim: tuple[float, float] | Literal[False] | None = None, batch_idx: int = 0, - title: Optional[str] = None, - ) -> Tuple[plt.Figure, List[plt.Axes]]: + title: str | None = None, + ) -> tuple[plt.Figure, list[plt.Axes]]: r"""Plot the representation in a human viewable format -- stem plots with data separated out by statistic type. @@ -1146,10 +1199,10 @@ def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: def update_plot( self, - axes: List[plt.Axes], + axes: list[plt.Axes], data: Tensor, batch_idx: int = 0, - ) -> List[plt.Artist]: + ) -> list[plt.Artist]: r"""Update the information in our representation plot. This is used for creating an animation of the representation @@ -1202,7 +1255,7 @@ def update_plot( # of the first two dims rep = {k: v[0, 0] for k, v in self.convert_to_dict(data).items()} rep = self._representation_for_plotting(rep) - for ax, d in zip(axes, rep.values()): + for ax, d in zip(axes, rep.values(), strict=False): if isinstance(d, dict): vals = np.array([dd.detach() for dd in d.values()]) else: diff --git a/src/plenoptic/synthesize/__init__.py b/src/plenoptic/synthesize/__init__.py index f9d7e0f3..7eb36795 100644 --- a/src/plenoptic/synthesize/__init__.py +++ b/src/plenoptic/synthesize/__init__.py @@ -1,5 +1,5 @@ from .eigendistortion import Eigendistortion -from .metamer import Metamer, MetamerCTF from .geodesic import Geodesic from .mad_competition import MADCompetition +from .metamer import Metamer, MetamerCTF from .simple_metamer import SimpleMetamer diff --git a/src/plenoptic/synthesize/autodiff.py b/src/plenoptic/synthesize/autodiff.py index 8be6e00c..84c7724f 100755 --- a/src/plenoptic/synthesize/autodiff.py +++ b/src/plenoptic/synthesize/autodiff.py @@ -1,6 +1,7 @@ +import warnings + import torch from torch import Tensor -import warnings def jacobian(y: Tensor, x: Tensor) -> Tensor: @@ -40,7 +41,9 @@ def jacobian(y: Tensor, x: Tensor) -> Tensor: .t() ) - if y.shape[0] == 1: # need to return a 2D tensor even if y dimensionality is 1 + if ( + y.shape[0] == 1 + ): # need to return a 2D tensor even if y dimensionality is 1 J = J.unsqueeze(0) return J.detach() diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 3f4061c4..2dd67037 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -1,18 +1,22 @@ -from typing import Tuple, List, Callable, Union, Optional import warnings -from typing_extensions import Literal +from collections.abc import Callable +from typing import Literal import matplotlib.pyplot -from matplotlib.figure import Figure import numpy as np import torch +from matplotlib.figure import Figure from torch import Tensor from tqdm.auto import tqdm -from .synthesis import Synthesis -from .autodiff import jacobian, vector_jacobian_product, jacobian_vector_product from ..tools.display import imshow from ..tools.validate import validate_input, validate_model +from .autodiff import ( + jacobian, + jacobian_vector_product, + vector_jacobian_product, +) +from .synthesis import Synthesis def fisher_info_matrix_vector_product( @@ -49,7 +53,7 @@ def fisher_info_matrix_vector_product( def fisher_info_matrix_eigenvalue( - y: Tensor, x: Tensor, v: Tensor, dummy_vec: Optional[Tensor] = None + y: Tensor, x: Tensor, v: Tensor, dummy_vec: Tensor | None = None ) -> Tensor: r"""Compute the eigenvalues of the Fisher Information Matrix corresponding to eigenvectors in v :math:`\lambda= v^T F v` @@ -60,7 +64,7 @@ def fisher_info_matrix_eigenvalue( Fv = fisher_info_matrix_vector_product(y, x, v, dummy_vec) # compute eigenvalues for all vectors in v - lmbda = torch.stack([a.dot(b) for a, b in zip(v.T, Fv.T)]) + lmbda = torch.stack([a.dot(b) for a, b in zip(v.T, Fv.T, strict=False)]) return lmbda @@ -117,8 +121,12 @@ class Eigendistortion(Synthesis): def __init__(self, image: Tensor, model: torch.nn.Module): validate_input(image, no_batch=True) - validate_model(model, image_shape=image.shape, - image_dtype=image.dtype, device=image.device) + validate_model( + model, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) ( self.batch_size, @@ -143,7 +151,7 @@ def __init__(self, image: Tensor, model: torch.nn.Module): self._eigenindex = None def _init_representation(self, image): - """Set self._representation_flat, based on model and image """ + """Set self._representation_flat, based on model and image""" self._image = self._image_flat.view(*image.shape) image_representation = self.model(self.image) @@ -193,24 +201,29 @@ def synthesize( """ allowed_methods = ["power", "exact", "randomized_svd"] - assert method in allowed_methods, f"method must be in {allowed_methods}" + assert ( + method in allowed_methods + ), f"method must be in {allowed_methods}" if ( method == "exact" - and self._representation_flat.size(0) * self._image_flat.size(0) > 1e6 + and self._representation_flat.size(0) * self._image_flat.size(0) + > 1e6 ): warnings.warn( "Jacobian > 1e6 elements and may cause out-of-memory. Use method = {'power', 'randomized_svd'}." ) if method == "exact": # compute exact Jacobian - print(f"Computing all eigendistortions") + print("Computing all eigendistortions") eig_vals, eig_vecs = self._synthesize_exact() eig_vecs = self._vector_to_image(eig_vecs.detach()) eig_vecs_ind = torch.arange(len(eig_vecs)) elif method == "randomized_svd": - print(f"Estimating top k={k} eigendistortions using randomized SVD") + print( + f"Estimating top k={k} eigendistortions using randomized SVD" + ) lmbda_new, v_new, error_approx = self._synthesize_randomized_svd( k=k, p=p, q=q ) @@ -224,7 +237,6 @@ def synthesize( ) else: # method == 'power' - assert max_iter > 0, "max_iter must be greater than zero" lmbda_max, v_max = self._synthesize_power( @@ -235,16 +247,20 @@ def synthesize( ) n = v_max.shape[0] - eig_vecs = self._vector_to_image(torch.cat((v_max, v_min), dim=1).detach()) + eig_vecs = self._vector_to_image( + torch.cat((v_max, v_min), dim=1).detach() + ) eig_vals = torch.cat([lmbda_max, lmbda_min]).squeeze() eig_vecs_ind = torch.cat((torch.arange(k), torch.arange(n - k, n))) # reshape to (n x num_chans x h x w) - self._eigendistortions = torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] + self._eigendistortions = ( + torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] + ) self._eigenvalues = torch.abs(eig_vals.detach()) self._eigenindex = eig_vecs_ind - def _synthesize_exact(self) -> Tuple[Tensor, Tensor]: + def _synthesize_exact(self) -> tuple[Tensor, Tensor]: r"""Eigendecomposition of explicitly computed Fisher Information Matrix. To be used when the input is small (e.g. less than 70x70 image on cluster or 30x30 on your own machine). This @@ -284,8 +300,8 @@ def compute_jacobian(self) -> Tensor: return J def _synthesize_power( - self, k: int, shift: Union[Tensor, float], tol: float, max_iter: int - ) -> Tuple[Tensor, Tensor]: + self, k: int, shift: Tensor | float, tol: float, max_iter: int + ) -> tuple[Tensor, Tensor]: r"""Use power method (or orthogonal iteration when k>1) to obtain largest (smallest) eigenvalue/vector pairs. Apply the algorithm to approximate the extremal eigenvalues and eigenvectors of the Fisher @@ -326,7 +342,9 @@ def _synthesize_power( v = torch.randn(len(x), k, device=x.device, dtype=x.dtype) v = v / torch.linalg.vector_norm(v, dim=0, keepdim=True, ord=2) - _dummy_vec = torch.ones_like(y, requires_grad=True) # cache a dummy vec for jvp + _dummy_vec = torch.ones_like( + y, requires_grad=True + ) # cache a dummy vec for jvp Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) v = Fv / torch.linalg.vector_norm(Fv, dim=0, keepdim=True, ord=2) lmbda = fisher_info_matrix_eigenvalue(y, x, v, _dummy_vec) @@ -348,11 +366,15 @@ def _synthesize_power( Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) Fv = Fv - shift * v # optionally shift: (F - shift*I)v - v_new, _ = torch.linalg.qr(Fv, "reduced") # (ortho)normalize vector(s) + v_new, _ = torch.linalg.qr( + Fv, "reduced" + ) # (ortho)normalize vector(s) lmbda_new = fisher_info_matrix_eigenvalue(y, x, v_new, _dummy_vec) - d_lambda = torch.linalg.vector_norm(lmbda - lmbda_new, ord=2) # stability of eigenspace + d_lambda = torch.linalg.vector_norm( + lmbda - lmbda_new, ord=2 + ) # stability of eigenspace v = v_new lmbda = lmbda_new @@ -362,7 +384,7 @@ def _synthesize_power( def _synthesize_randomized_svd( self, k: int, p: int, q: int - ) -> Tuple[Tensor, Tensor, Tensor]: + ) -> tuple[Tensor, Tensor, Tensor]: r"""Synthesize eigendistortions using randomized truncated SVD. This method approximates the column space of the Fisher Info Matrix, projects the FIM into that column space, @@ -421,11 +443,13 @@ def _synthesize_randomized_svd( y, x, torch.randn(n, 20).to(x.device), _dummy_vec ) error_approx = omega - (Q @ Q.T @ omega) - error_approx = torch.linalg.vector_norm(error_approx, dim=0, ord=2).mean() + error_approx = torch.linalg.vector_norm( + error_approx, dim=0, ord=2 + ).mean() return S[:k].clone(), V[:, :k].clone(), error_approx # truncate - def _vector_to_image(self, vecs: Tensor) -> List[Tensor]: + def _vector_to_image(self, vecs: Tensor) -> list[Tensor]: r"""Reshapes eigenvectors back into correct image dimensions. Parameters @@ -441,7 +465,9 @@ def _vector_to_image(self, vecs: Tensor) -> List[Tensor]: """ imgs = [ - vecs[:, i].reshape((self.n_channels, self.im_height, self.im_width)) + vecs[:, i].reshape( + (self.n_channels, self.im_height, self.im_width) + ) for i in range(vecs.shape[1]) ] return imgs @@ -453,7 +479,9 @@ def _indexer(self, idx: int) -> int: i = idx_range[idx] all_idx = self.eigenindex - assert i in all_idx, "eigenindex must be the index of one of the vectors" + assert ( + i in all_idx + ), "eigenindex must be the index of one of the vectors" assert ( all_idx is not None and len(all_idx) != 0 ), "No eigendistortions synthesized" @@ -506,14 +534,24 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ["_jacobian", "_eigendistortions", "_eigenvalues", - "_eigenindex", "_model", "_image", "_image_flat", - "_representation_flat"] + attrs = [ + "_jacobian", + "_eigendistortions", + "_eigenvalues", + "_eigenindex", + "_model", + "_image", + "_image_flat", + "_representation_flat", + ] super().to(*args, attrs=attrs, **kwargs) - def load(self, file_path: str, - map_location: Union[str, None] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: str | None = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Eigendistortion`` object -- @@ -547,12 +585,15 @@ def load(self, file_path: str, *then* load. """ - check_attributes = ['_image', '_representation_flat'] + check_attributes = ["_image", "_representation_flat"] check_loss_functions = [] - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) # make these require a grad again self._image_flat.requires_grad_() # we need _representation_flat and _image_flat to be connected in the @@ -570,22 +611,22 @@ def image(self): @property def jacobian(self): - """Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``. """ + """Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``.""" return self._jacobian @property def eigendistortions(self): - """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue. """ + """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue.""" return self._eigendistortions @property def eigenvalues(self): - """Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order. """ + """Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order.""" return self._eigenvalues @property def eigenindex(self): - """Index of each eigenvector/eigenvalue. """ + """Index of each eigenvector/eigenvalue.""" return self._eigenindex @@ -594,7 +635,7 @@ def display_eigendistortion( eigenindex: int = 0, alpha: float = 5.0, process_image: Callable[[Tensor], Tensor] = lambda x: x, - ax: Optional[matplotlib.pyplot.axis] = None, + ax: matplotlib.pyplot.axis | None = None, plot_complex: str = "rectangular", **kwargs, ) -> Figure: diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index 9e4f6a14..56fd81b8 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -1,21 +1,24 @@ -from collections import OrderedDict import warnings -import matplotlib.pyplot as plt +from collections import OrderedDict +from typing import Literal + import matplotlib as mpl +import matplotlib.pyplot as plt import torch import torch.autograd as autograd from torch import Tensor from tqdm.auto import tqdm -from typing import Union, Tuple, Optional -from typing_extensions import Literal -from .synthesis import OptimizedSynthesis +from ..tools.convergence import pixel_change_convergence from ..tools.data import to_numpy from ..tools.optim import penalize_range +from ..tools.straightness import ( + deviation_from_line, + make_straight_line, + sample_brownian_bridge, +) from ..tools.validate import validate_input, validate_model -from ..tools.convergence import pixel_change_convergence -from ..tools.straightness import (deviation_from_line, make_straight_line, - sample_brownian_bridge) +from .synthesis import OptimizedSynthesis class Geodesic(OptimizedSynthesis): @@ -96,16 +99,26 @@ class Geodesic(OptimizedSynthesis): http://www.cns.nyu.edu/~lcv/pubs/makeAbs.php?loc=Henaff16b """ - def __init__(self, image_a: Tensor, image_b: Tensor, - model: torch.nn.Module, n_steps: int = 10, - initial_sequence: Literal['straight', 'bridge'] = 'straight', - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1)): + + def __init__( + self, + image_a: Tensor, + image_b: Tensor, + model: torch.nn.Module, + n_steps: int = 10, + initial_sequence: Literal["straight", "bridge"] = "straight", + range_penalty_lambda: float = 0.1, + allowed_range: tuple[float, float] = (0, 1), + ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image_a, no_batch=True, allowed_range=allowed_range) validate_input(image_b, no_batch=True, allowed_range=allowed_range) - validate_model(model, image_shape=image_a.shape, image_dtype=image_a.dtype, - device=image_a.device) + validate_model( + model, + image_shape=image_a.shape, + image_dtype=image_a.dtype, + device=image_a.device, + ) self.n_steps = n_steps self._model = model @@ -126,22 +139,27 @@ def _initialize(self, initial_sequence, start, stop, n_steps): (``'straight'``), or with a brownian bridge between the two anchors (``'bridge'``). """ - if initial_sequence == 'bridge': + if initial_sequence == "bridge": geodesic = sample_brownian_bridge(start, stop, n_steps) - elif initial_sequence == 'straight': + elif initial_sequence == "straight": geodesic = make_straight_line(start, stop, n_steps) else: - raise ValueError(f"Don't know how to handle initial_sequence={initial_sequence}") - _, geodesic, _ = torch.split(geodesic, [1, n_steps-1, 1]) + raise ValueError( + f"Don't know how to handle initial_sequence={initial_sequence}" + ) + _, geodesic, _ = torch.split(geodesic, [1, n_steps - 1, 1]) self._initial_sequence = initial_sequence geodesic.requires_grad_() self._geodesic = geodesic - def synthesize(self, max_iter: int = 1000, - optimizer: Optional[torch.optim.Optimizer] = None, - store_progress: Union[bool, int] = False, - stop_criterion: Optional[float] = None, - stop_iters_to_check: int = 50): + def synthesize( + self, + max_iter: int = 1000, + optimizer: torch.optim.Optimizer | None = None, + store_progress: bool | int = False, + stop_criterion: float | None = None, + stop_iters_to_check: int = 50, + ): """Synthesize a geodesic via optimization. Parameters @@ -173,10 +191,17 @@ def synthesize(self, max_iter: int = 1000, """ if stop_criterion is None: # semi arbitrary default choice of tolerance - stop_criterion = torch.linalg.vector_norm(self.pixelfade, ord=2) / 1e4 * (1 + 5 ** .5) / 2 - print(f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}") - - self._initialize_optimizer(optimizer, '_geodesic', .001) + stop_criterion = ( + torch.linalg.vector_norm(self.pixelfade, ord=2) + / 1e4 + * (1 + 5**0.5) + / 2 + ) + print( + f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}" + ) + + self._initialize_optimizer(optimizer, "_geodesic", 0.001) # get ready to store progress self.store_progress = store_progress @@ -191,12 +216,14 @@ def synthesize(self, max_iter: int = 1000, raise ValueError("Found a NaN in loss during optimization.") if self._check_convergence(stop_criterion, stop_iters_to_check): - warnings.warn("Pixel change norm has converged, stopping synthesis") + warnings.warn( + "Pixel change norm has converged, stopping synthesis" + ) break pbar.close() - def objective_function(self, geodesic: Optional[Tensor] = None) -> Tensor: + def objective_function(self, geodesic: Tensor | None = None) -> Tensor: """Compute geodesic synthesis loss. This is the path energy (i.e., squared L2 norm of each step) of the @@ -224,16 +251,19 @@ def objective_function(self, geodesic: Optional[Tensor] = None) -> Tensor: if geodesic is None: geodesic = self.geodesic self._geodesic_representation = self.model(geodesic) - self._most_recent_step_energy = self._calculate_step_energy(self._geodesic_representation) + self._most_recent_step_energy = self._calculate_step_energy( + self._geodesic_representation + ) loss = self._most_recent_step_energy.mean() range_penalty = penalize_range(self.geodesic, self.allowed_range) return loss + self.range_penalty_lambda * range_penalty def _calculate_step_energy(self, z): - """calculate the energy (i.e. squared l2 norm) of each step in `z`. - """ + """calculate the energy (i.e. squared l2 norm) of each step in `z`.""" velocity = torch.diff(z, dim=0) - step_energy = torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 + step_energy = ( + torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 + ) return step_energy def _optimizer_step(self, pbar): @@ -254,21 +284,30 @@ def _optimizer_step(self, pbar): loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm(self._geodesic.grad.data, - ord=2, dim=None) + grad_norm = torch.linalg.vector_norm( + self._geodesic.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm) - pixel_change_norm = torch.linalg.vector_norm(self._geodesic - last_iter_geodesic, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self._geodesic - last_iter_geodesic, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm) # displaying some information - pbar.set_postfix(OrderedDict([('loss', f'{loss.item():.4e}'), - ('gradient norm', f'{grad_norm.item():.4e}'), - ('pixel change norm', f"{pixel_change_norm.item():.5e}")])) + pbar.set_postfix( + OrderedDict( + [ + ("loss", f"{loss.item():.4e}"), + ("gradient norm", f"{grad_norm.item():.4e}"), + ("pixel change norm", f"{pixel_change_norm.item():.5e}"), + ] + ) + ) return loss - def _check_convergence(self, stop_criterion: float, - stop_iters_to_check: int) -> bool: + def _check_convergence( + self, stop_criterion: float, stop_iters_to_check: int + ) -> bool: """Check whether the pixel change norm has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -297,9 +336,11 @@ def _check_convergence(self, stop_criterion: float, Whether the pixel change norm has stabilized or not. """ - return pixel_change_convergence(self, stop_criterion, stop_iters_to_check) + return pixel_change_convergence( + self, stop_criterion, stop_iters_to_check + ) - def calculate_jerkiness(self, geodesic: Optional[Tensor] = None) -> Tensor: + def calculate_jerkiness(self, geodesic: Tensor | None = None) -> Tensor: """Compute the alignment of representation's acceleration to model local curvature. This is the first order optimality condition for a geodesic, and can be @@ -321,15 +362,19 @@ def calculate_jerkiness(self, geodesic: Optional[Tensor] = None) -> Tensor: geodesic_representation = self.model(geodesic) velocity = torch.diff(geodesic_representation, dim=0) acceleration = torch.diff(velocity, dim=0) - acc_magnitude = torch.linalg.vector_norm(acceleration, ord=2, dim=[1,2,3], - keepdim=True) + acc_magnitude = torch.linalg.vector_norm( + acceleration, ord=2, dim=[1, 2, 3], keepdim=True + ) acc_direction = torch.div(acceleration, acc_magnitude) # we slice the output of the VJP, rather than slicing geodesic, because # slicing interferes with the gradient computation: # https://stackoverflow.com/a/54767100 - accJac = self._vector_jacobian_product(geodesic_representation[1:-1], - geodesic, acc_direction)[1:-1] - step_jerkiness = torch.linalg.vector_norm(accJac, dim=[1,2,3], ord=2) ** 2 + accJac = self._vector_jacobian_product( + geodesic_representation[1:-1], geodesic, acc_direction + )[1:-1] + step_jerkiness = ( + torch.linalg.vector_norm(accJac, dim=[1, 2, 3], ord=2) ** 2 + ) return step_jerkiness def _vector_jacobian_product(self, y, x, a): @@ -337,9 +382,9 @@ def _vector_jacobian_product(self, y, x, a): and allow for further gradient computations by retaining, and creating the graph. """ - accJac = autograd.grad(y, x, a, - retain_graph=True, - create_graph=True)[0] + accJac = autograd.grad(y, x, a, retain_graph=True, create_graph=True)[ + 0 + ] return accJac def _store(self, i: int) -> bool: @@ -362,15 +407,29 @@ def _store(self, i: int) -> bool: if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs try: - self._step_energy.append(self._most_recent_step_energy.detach().to('cpu')) - self._dev_from_line.append(torch.stack(deviation_from_line(self._geodesic_representation.detach().to('cpu'))).T) + self._step_energy.append( + self._most_recent_step_energy.detach().to("cpu") + ) + self._dev_from_line.append( + torch.stack( + deviation_from_line( + self._geodesic_representation.detach().to("cpu") + ) + ).T + ) except AttributeError: # the first time _store is called (i.e., before optimizer is # stepped for first time) those attributes won't be # initialized geod_rep = self.model(self.geodesic) - self._step_energy.append(self._calculate_step_energy(geod_rep).detach().to('cpu')) - self._dev_from_line.append(torch.stack(deviation_from_line(geod_rep.detach().to('cpu'))).T) + self._step_energy.append( + self._calculate_step_energy(geod_rep).detach().to("cpu") + ) + self._dev_from_line.append( + torch.stack( + deviation_from_line(geod_rep.detach().to("cpu")) + ).T + ) stored = True else: stored = False @@ -427,13 +486,23 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ['_image_a', '_image_b', '_geodesic', '_model', - '_step_energy', '_dev_from_line', 'pixelfade'] + attrs = [ + "_image_a", + "_image_b", + "_geodesic", + "_model", + "_step_energy", + "_dev_from_line", + "pixelfade", + ] super().to(*args, attrs=attrs, **kwargs) - def load(self, file_path: str, - map_location: Union[str, None] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: str | None = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Geodesic`` object -- we will @@ -469,28 +538,47 @@ def load(self, file_path: str, *then* load. """ - check_attributes = ['_image_a', '_image_b', 'n_steps', - '_initial_sequence', '_range_penalty_lambda', - '_allowed_range', 'pixelfade'] + check_attributes = [ + "_image_a", + "_image_b", + "n_steps", + "_initial_sequence", + "_range_penalty_lambda", + "_allowed_range", + "pixelfade", + ] check_loss_functions = [] new_loss = self.objective_function(self.pixelfade) - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) - old_loss = self.__dict__.pop('_save_check') + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) + old_loss = self.__dict__.pop("_save_check") if not torch.allclose(new_loss, old_loss, rtol=1e-2): - raise ValueError("objective_function on pixelfade of saved and initialized Geodesic object are different! Do they use the same model?" - f" Self: {new_loss}, Saved: {old_loss}") + raise ValueError( + "objective_function on pixelfade of saved and initialized Geodesic object are different! Do they use the same model?" + f" Self: {new_loss}, Saved: {old_loss}" + ) # make this require a grad again self._geodesic.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if len(self._dev_from_line) and self._dev_from_line[0].device.type != 'cpu': - self._dev_from_line = [dev.to('cpu') for dev in self._dev_from_line] - if len(self._step_energy) and self._step_energy[0].device.type != 'cpu': - self._step_energy = [step.to('cpu') for step in self._step_energy] + if ( + len(self._dev_from_line) + and self._dev_from_line[0].device.type != "cpu" + ): + self._dev_from_line = [ + dev.to("cpu") for dev in self._dev_from_line + ] + if ( + len(self._step_energy) + and self._step_energy[0].device.type != "cpu" + ): + self._step_energy = [step.to("cpu") for step in self._step_energy] @property def model(self): @@ -535,9 +623,9 @@ def dev_from_line(self): return torch.stack(self._dev_from_line) -def plot_loss(geodesic: Geodesic, - ax: Union[mpl.axes.Axes, None] = None, - **kwargs) -> mpl.axes.Axes: +def plot_loss( + geodesic: Geodesic, ax: mpl.axes.Axes | None = None, **kwargs +) -> mpl.axes.Axes: """Plot synthesis loss. Parameters @@ -559,14 +647,15 @@ def plot_loss(geodesic: Geodesic, if ax is None: ax = plt.gca() ax.semilogy(geodesic.losses, **kwargs) - ax.set(xlabel='Synthesis iteration', - ylabel='Loss') + ax.set(xlabel="Synthesis iteration", ylabel="Loss") return ax -def plot_deviation_from_line(geodesic: Geodesic, - natural_video: Union[Tensor, None] = None, - ax: Union[mpl.axes.Axes, None] = None - ) -> mpl.axes.Axes: + +def plot_deviation_from_line( + geodesic: Geodesic, + natural_video: Tensor | None = None, + ax: mpl.axes.Axes | None = None, +) -> mpl.axes.Axes: """Visual diagnostic of geodesic linearity in representation space. This plot illustrates the deviation from the straight line connecting @@ -609,18 +698,24 @@ def plot_deviation_from_line(geodesic: Geodesic, ax = plt.gca() pixelfade_dev = deviation_from_line(geodesic.model(geodesic.pixelfade)) - ax.plot(*[to_numpy(d) for d in pixelfade_dev], 'g-o', label='pixelfade') + ax.plot(*[to_numpy(d) for d in pixelfade_dev], "g-o", label="pixelfade") - geodesic_dev = deviation_from_line(geodesic.model(geodesic.geodesic).detach()) - ax.plot(*[to_numpy(d) for d in geodesic_dev], 'r-o', label='geodesic') + geodesic_dev = deviation_from_line( + geodesic.model(geodesic.geodesic).detach() + ) + ax.plot(*[to_numpy(d) for d in geodesic_dev], "r-o", label="geodesic") if natural_video is not None: video_dev = deviation_from_line(geodesic.model(natural_video)) - ax.plot(*[to_numpy(d) for d in video_dev], 'b-o', label='natural video') - - ax.set(xlabel='Distance along representation line', - ylabel='Distance from representation line', - title='Deviation from the straight line') + ax.plot( + *[to_numpy(d) for d in video_dev], "b-o", label="natural video" + ) + + ax.set( + xlabel="Distance along representation line", + ylabel="Distance from representation line", + title="Deviation from the straight line", + ) ax.legend(loc=1) return ax diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index b3e61330..4baf6dd0 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -1,19 +1,21 @@ """Run MAD Competition.""" -import torch -import numpy as np -from torch import Tensor -from tqdm.auto import tqdm -from ..tools import optim, display, data -from typing import Union, Tuple, Callable, List, Dict, Optional -from typing_extensions import Literal -from .synthesis import OptimizedSynthesis import warnings +from collections import OrderedDict +from collections.abc import Callable +from typing import Literal + import matplotlib as mpl import matplotlib.pyplot as plt -from collections import OrderedDict +import numpy as np +import torch from pyrtools.tools.display import make_figure as pt_make_figure -from ..tools.validate import validate_input, validate_metric +from torch import Tensor +from tqdm.auto import tqdm + +from ..tools import data, display, optim from ..tools.convergence import loss_convergence +from ..tools.validate import validate_input, validate_metric +from .synthesis import OptimizedSynthesis class MADCompetition(OptimizedSynthesis): @@ -97,20 +99,32 @@ class MADCompetition(OptimizedSynthesis): http://dx.doi.org/10.1167/8.12.8 """ - def __init__(self, image: Tensor, - optimized_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], - reference_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], - minmax: Literal['min', 'max'], - initial_noise: float = .1, - metric_tradeoff_lambda: Optional[float] = None, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1)): + + def __init__( + self, + image: Tensor, + optimized_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], + reference_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], + minmax: Literal["min", "max"], + initial_noise: float = 0.1, + metric_tradeoff_lambda: float | None = None, + range_penalty_lambda: float = 0.1, + allowed_range: tuple[float, float] = (0, 1), + ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) - validate_metric(optimized_metric, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) - validate_metric(reference_metric, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) + validate_metric( + optimized_metric, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) + validate_metric( + reference_metric, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) self._optimized_metric = optimized_metric self._reference_metric = reference_metric self._image = image.detach() @@ -118,25 +132,33 @@ def __init__(self, image: Tensor, self.scheduler = None self._optimized_metric_loss = [] self._reference_metric_loss = [] - if minmax not in ['min', 'max']: - raise ValueError("synthesis_target must be one of {'min', 'max'}, but got " - f"value {minmax} instead!") + if minmax not in ["min", "max"]: + raise ValueError( + "synthesis_target must be one of {'min', 'max'}, but got " + f"value {minmax} instead!" + ) self._minmax = minmax self._initialize(initial_noise) # If no metric_tradeoff_lambda is specified, pick one that gets them to # approximately the same magnitude if metric_tradeoff_lambda is None: - loss_ratio = torch.as_tensor(self.optimized_metric_loss[-1] / self.reference_metric_loss[-1], - dtype=torch.float32) - metric_tradeoff_lambda = torch.pow(torch.as_tensor(10), - torch.round(torch.log10(loss_ratio))).item() - warnings.warn("Since metric_tradeoff_lamda was None, automatically set" - f" to {metric_tradeoff_lambda} to roughly balance metrics.") + loss_ratio = torch.as_tensor( + self.optimized_metric_loss[-1] + / self.reference_metric_loss[-1], + dtype=torch.float32, + ) + metric_tradeoff_lambda = torch.pow( + torch.as_tensor(10), torch.round(torch.log10(loss_ratio)) + ).item() + warnings.warn( + "Since metric_tradeoff_lamda was None, automatically set" + f" to {metric_tradeoff_lambda} to roughly balance metrics." + ) self._metric_tradeoff_lambda = metric_tradeoff_lambda self._store_progress = None self._saved_mad_image = [] - def _initialize(self, initial_noise: float = .1): + def _initialize(self, initial_noise: float = 0.1): """Initialize the synthesized image. Initialize ``self.mad_image`` attribute to be ``image`` plus @@ -149,24 +171,28 @@ def _initialize(self, initial_noise: float = .1): ``mad_image`` from ``image``. """ - mad_image = (self.image + initial_noise * - torch.randn_like(self.image)) + mad_image = self.image + initial_noise * torch.randn_like(self.image) mad_image = mad_image.clamp(*self.allowed_range) self._initial_image = mad_image.clone() mad_image.requires_grad_() self._mad_image = mad_image - self._reference_metric_target = self.reference_metric(self.image, - self.mad_image).item() + self._reference_metric_target = self.reference_metric( + self.image, self.mad_image + ).item() self._reference_metric_loss.append(self._reference_metric_target) - self._optimized_metric_loss.append(self.optimized_metric(self.image, - self.mad_image).item()) - - def synthesize(self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, - stop_criterion: float = 1e-4, stop_iters_to_check: int = 50 - ): + self._optimized_metric_loss.append( + self.optimized_metric(self.image, self.mad_image).item() + ) + + def synthesize( + self, + max_iter: int = 100, + optimizer: torch.optim.Optimizer | None = None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, + store_progress: bool | int = False, + stop_criterion: float = 1e-4, + stop_iters_to_check: int = 50, + ): r"""Synthesize a MAD image. Update the pixels of ``initial_image`` to maximize or minimize @@ -228,9 +254,9 @@ def synthesize(self, max_iter: int = 100, pbar.close() - def objective_function(self, - mad_image: Optional[Tensor] = None, - image: Optional[Tensor] = None) -> Tensor: + def objective_function( + self, mad_image: Tensor | None = None, image: Tensor | None = None + ) -> Tensor: r"""Compute the MADCompetition synthesis loss. This computes: @@ -268,15 +294,18 @@ def objective_function(self, image = self.image if mad_image is None: mad_image = self.mad_image - synth_target = {'min': 1, 'max': -1}[self.minmax] + synth_target = {"min": 1, "max": -1}[self.minmax] synthesis_loss = self.optimized_metric(image, mad_image) - fixed_loss = (self._reference_metric_target - - self.reference_metric(image, mad_image)).pow(2) - range_penalty = optim.penalize_range(mad_image, - self.allowed_range) - return (synth_target * synthesis_loss + - self.metric_tradeoff_lambda * fixed_loss + - self.range_penalty_lambda * range_penalty) + fixed_loss = ( + self._reference_metric_target + - self.reference_metric(image, mad_image) + ).pow(2) + range_penalty = optim.penalize_range(mad_image, self.allowed_range) + return ( + synth_target * synthesis_loss + + self.metric_tradeoff_lambda * fixed_loss + + self.range_penalty_lambda * range_penalty + ) def _optimizer_step(self, pbar: tqdm) -> Tensor: r"""Compute and propagate gradients, then step the optimizer to update mad_image. @@ -298,8 +327,9 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: last_iter_mad_image = self.mad_image.clone() loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm(self.mad_image.grad.data, - ord=2, dim=None) + grad_norm = torch.linalg.vector_norm( + self.mad_image.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm.item()) fm = self.reference_metric(self.image, self.mad_image) @@ -311,18 +341,22 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm(self.mad_image - last_iter_mad_image, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self.mad_image - last_iter_mad_image, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict(loss=f"{loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]['lr'], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}", - reference_metric=f'{fm.item():.04e}', - optimized_metric=f'{sm.item():.04e}')) + OrderedDict( + loss=f"{loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]["lr"], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + reference_metric=f"{fm.item():.04e}", + optimized_metric=f"{sm.item():.04e}", + ) + ) return loss def _check_convergence(self, stop_criterion, stop_iters_to_check): @@ -358,7 +392,7 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): def _initialize_optimizer(self, optimizer, scheduler): """Initialize optimizer and scheduler.""" - super()._initialize_optimizer(optimizer, 'mad_image') + super()._initialize_optimizer(optimizer, "mad_image") self.scheduler = scheduler def _store(self, i: int) -> bool: @@ -379,7 +413,7 @@ def _store(self, i: int) -> bool: """ if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs - self._saved_mad_image.append(self.mad_image.clone().to('cpu')) + self._saved_mad_image.append(self.mad_image.clone().to("cpu")) stored = True else: stored = False @@ -405,9 +439,9 @@ def save(self, file_path: str): # if the metrics are Modules, then we don't want to save them. If # they're functions then saving them is fine. if isinstance(self.optimized_metric, torch.nn.Module): - attrs.pop('_optimized_metric') + attrs.pop("_optimized_metric") if isinstance(self.reference_metric, torch.nn.Module): - attrs.pop('_reference_metric') + attrs.pop("_reference_metric") super().save(file_path, attrs=attrs) def to(self, *args, **kwargs): @@ -444,8 +478,7 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ['_initial_image', '_image', '_mad_image', - '_saved_mad_image'] + attrs = ["_initial_image", "_image", "_mad_image", "_saved_mad_image"] super().to(*args, attrs=attrs, **kwargs) # if the metrics are Modules, then we should pass them as well. If # they're functions then nothing needs to be done. @@ -458,9 +491,12 @@ def to(self, *args, **kwargs): except AttributeError: pass - def load(self, file_path: str, - map_location: Optional[None] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: None | None = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``MADCompetition`` object -- we @@ -497,21 +533,33 @@ def load(self, file_path: str, *then* load. """ - check_attributes = ['_image', '_metric_tradeoff_lambda', - '_range_penalty_lambda', '_allowed_range', - '_minmax'] - check_loss_functions = ['_reference_metric', '_optimized_metric'] - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) + check_attributes = [ + "_image", + "_metric_tradeoff_lambda", + "_range_penalty_lambda", + "_allowed_range", + "_minmax", + ] + check_loss_functions = ["_reference_metric", "_optimized_metric"] + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) # make this require a grad again self.mad_image.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if len(self._saved_mad_image) and self._saved_mad_image[0].device.type != 'cpu': - self._saved_mad_image = [mad.to('cpu') for mad in self._saved_mad_image] + if ( + len(self._saved_mad_image) + and self._saved_mad_image[0].device.type != "cpu" + ): + self._saved_mad_image = [ + mad.to("cpu") for mad in self._saved_mad_image + ] @property def mad_image(self): @@ -554,10 +602,12 @@ def saved_mad_image(self): return torch.stack(self._saved_mad_image) -def plot_loss(mad: MADCompetition, - iteration: Optional[int] = None, - axes: Union[List[mpl.axes.Axes], mpl.axes.Axes, None] = None, - **kwargs) -> mpl.axes.Axes: +def plot_loss( + mad: MADCompetition, + iteration: int | None = None, + axes: list[mpl.axes.Axes] | mpl.axes.Axes | None = None, + **kwargs, +) -> mpl.axes.Axes: """Plot metric losses. Plots ``mad.optimized_metric_loss`` and ``mad.reference_metric_loss`` on two @@ -602,30 +652,32 @@ def plot_loss(mad: MADCompetition, loss_idx = iteration if axes is None: axes = plt.gca() - if not hasattr(axes, '__iter__'): - axes = display.clean_up_axes(axes, False, - ['top', 'right', 'bottom', 'left'], - ['x', 'y']) + if not hasattr(axes, "__iter__"): + axes = display.clean_up_axes( + axes, False, ["top", "right", "bottom", "left"], ["x", "y"] + ) gs = axes.get_subplotspec().subgridspec(1, 2) fig = axes.figure axes = [fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[0, 1])] losses = [mad.reference_metric_loss, mad.optimized_metric_loss] - names = ['Reference metric loss', 'Optimized metric loss'] - for ax, loss, name in zip(axes, losses, names): + names = ["Reference metric loss", "Optimized metric loss"] + for ax, loss, name in zip(axes, losses, names, strict=False): ax.plot(loss, **kwargs) - ax.scatter(loss_idx, loss[loss_idx], c='r') - ax.set(xlabel='Synthesis iteration', ylabel=name) + ax.scatter(loss_idx, loss[loss_idx], c="r") + ax.set(xlabel="Synthesis iteration", ylabel=name) return ax -def display_mad_image(mad: MADCompetition, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, - title: str = 'MADCompetition', - **kwargs) -> mpl.axes.Axes: +def display_mad_image( + mad: MADCompetition, + batch_idx: int = 0, + channel_idx: int | None = None, + zoom: float | None = None, + iteration: int | None = None, + ax: mpl.axes.Axes | None = None, + title: str = "MADCompetition", + **kwargs, +) -> mpl.axes.Axes: """Display MAD image. You can specify what iteration to view by using the ``iteration`` arg. @@ -680,21 +732,30 @@ def display_mad_image(mad: MADCompetition, as_rgb = False if ax is None: ax = plt.gca() - display.imshow(image, ax=ax, title=title, zoom=zoom, - batch_idx=batch_idx, channel_idx=channel_idx, - as_rgb=as_rgb, **kwargs) + display.imshow( + image, + ax=ax, + title=title, + zoom=zoom, + batch_idx=batch_idx, + channel_idx=channel_idx, + as_rgb=as_rgb, + **kwargs, + ) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) return ax -def plot_pixel_values(mad: MADCompetition, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float], Literal[False]] = False, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: +def plot_pixel_values( + mad: MADCompetition, + batch_idx: int = 0, + channel_idx: int | None = None, + iteration: int | None = None, + ylim: tuple[float] | Literal[False] = False, + ax: mpl.axes.Axes | None = None, + **kwargs, +) -> mpl.axes.Axes: r"""Plot histogram of pixel values of reference and MAD images. As a way to check the distributions of pixel intensities and see @@ -726,11 +787,12 @@ def plot_pixel_values(mad: MADCompetition, Creates axes. """ + def _freedman_diaconis_bins(a): """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) - iqr = np.diff(np.percentile(a, [.25, .75]))[0] + iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] if len(a) < 2: return 1 h = 2 * iqr / (len(a) ** (1 / 3)) @@ -740,7 +802,7 @@ def _freedman_diaconis_bins(a): else: return int(np.ceil((a.max() - a.min()) / h)) - kwargs.setdefault('alpha', .4) + kwargs.setdefault("alpha", 0.4) if iteration is None: mad_image = mad.mad_image[batch_idx] else: @@ -753,10 +815,18 @@ def _freedman_diaconis_bins(a): ax = plt.gca() image = data.to_numpy(image).flatten() mad_image = data.to_numpy(mad_image).flatten() - ax.hist(image, bins=min(_freedman_diaconis_bins(image), 50), - label='Reference image', **kwargs) - ax.hist(mad_image, bins=min(_freedman_diaconis_bins(image), 50), - label='MAD image', **kwargs) + ax.hist( + image, + bins=min(_freedman_diaconis_bins(image), 50), + label="Reference image", + **kwargs, + ) + ax.hist( + mad_image, + bins=min(_freedman_diaconis_bins(image), 50), + label="MAD image", + **kwargs, + ) ax.legend() if ylim: ax.set_ylim(ylim) @@ -764,8 +834,9 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots(to_check: Union[List[str], Dict[str, int]], - to_check_name: str): +def _check_included_plots( + to_check: list[str] | dict[str, int], to_check_name: str +): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -782,26 +853,37 @@ def _check_included_plots(to_check: Union[List[str], Dict[str, int]], Name of the `to_check` variable, used in the error message. """ - allowed_vals = ['display_mad_image', 'plot_loss', 'plot_pixel_values', 'misc'] + allowed_vals = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + "misc", + ] try: vals = to_check.keys() except AttributeError: vals = to_check not_allowed = [v for v in vals if v not in allowed_vals] if not_allowed: - raise ValueError(f'{to_check_name} contained value(s) {not_allowed}! ' - f'Only {allowed_vals} are permissible!') - - -def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = ['display_mad_image', - 'plot_loss', - 'plot_pixel_values'], - display_mad_image_width: float = 1, - plot_loss_width: float = 2, - plot_pixel_values_width: float = 1) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: + raise ValueError( + f"{to_check_name} contained value(s) {not_allowed}! " + f"Only {allowed_vals} are permissible!" + ) + + +def _setup_synthesis_fig( + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float] | None = None, + included_plots: list[str] = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + ], + display_mad_image_width: float = 1, + plot_loss_width: float = 2, + plot_pixel_values_width: float = 1, +) -> tuple[mpl.figure.Figure, list[mpl.axes.Axes], dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -852,64 +934,75 @@ def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, n_subplots = 0 axes_idx = axes_idx.copy() width_ratios = [] - if 'display_mad_image' in included_plots: + if "display_mad_image" in included_plots: n_subplots += 1 width_ratios.append(display_mad_image_width) - if 'display_mad_image' not in axes_idx.keys(): - axes_idx['display_mad_image'] = data._find_min_int(axes_idx.values()) - if 'plot_loss' in included_plots: + if "display_mad_image" not in axes_idx.keys(): + axes_idx["display_mad_image"] = data._find_min_int( + axes_idx.values() + ) + if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if 'plot_loss' not in axes_idx.keys(): - axes_idx['plot_loss'] = data._find_min_int(axes_idx.values()) - if 'plot_pixel_values' in included_plots: + if "plot_loss" not in axes_idx.keys(): + axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) + if "plot_pixel_values" in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if 'plot_pixel_values' not in axes_idx.keys(): - axes_idx['plot_pixel_values'] = data._find_min_int(axes_idx.values()) + if "plot_pixel_values" not in axes_idx.keys(): + axes_idx["plot_pixel_values"] = data._find_min_int( + axes_idx.values() + ) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: # we want (5, 5) for each subplot, with a bit of room between # each subplot - figsize = ((width_ratios*5).sum() + width_ratios.sum()-1, 5) + figsize = ((width_ratios * 5).sum() + width_ratios.sum() - 1, 5) width_ratios = width_ratios / width_ratios.sum() - fig, axes = plt.subplots(1, n_subplots, figsize=figsize, - gridspec_kw={'width_ratios': width_ratios}) + fig, axes = plt.subplots( + 1, + n_subplots, + figsize=figsize, + gridspec_kw={"width_ratios": width_ratios}, + ) if n_subplots == 1: axes = [axes] else: axes = fig.axes # make sure misc contains all the empty axes - misc_axes = axes_idx.get('misc', []) - if not hasattr(misc_axes, '__iter__'): + misc_axes = axes_idx.get("misc", []) + if not hasattr(misc_axes, "__iter__"): misc_axes = [misc_axes] all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, '__iter__'): + if hasattr(i, "__iter__"): all_axes.extend(i) else: all_axes.append(i) misc_axes += [i for i, _ in enumerate(fig.axes) if i not in all_axes] - axes_idx['misc'] = misc_axes + axes_idx["misc"] = misc_axes return fig, axes, axes_idx -def plot_synthesis_status(mad: MADCompetition, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - vrange: Union[Tuple[float], str] = 'indep1', - zoom: Optional[float] = None, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = ['display_mad_image', - 'plot_loss', - 'plot_pixel_values'], - width_ratios: Dict[str, float] = {}, - ) -> Tuple[mpl.figure.Figure, Dict[str, int]]: +def plot_synthesis_status( + mad: MADCompetition, + batch_idx: int = 0, + channel_idx: int | None = None, + iteration: int | None = None, + vrange: tuple[float] | str = "indep1", + zoom: float | None = None, + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float] | None = None, + included_plots: list[str] = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + ], + width_ratios: dict[str, float] = {}, +) -> tuple[mpl.figure.Figure, dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create two @@ -977,62 +1070,75 @@ def plot_synthesis_status(mad: MADCompetition, """ if iteration is not None and not mad.store_progress: - raise ValueError("synthesis() was run with store_progress=False, " - "cannot specify which iteration to plot (only" - " last one, with iteration=None)") + raise ValueError( + "synthesis() was run with store_progress=False, " + "cannot specify which iteration to plot (only" + " last one, with iteration=None)" + ) if mad.mad_image.ndim not in [3, 4]: - raise ValueError("plot_synthesis_status() expects 3 or 4d data;" - "unexpected behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') - width_ratios = {f'{k}_width': v for k, v in width_ratios.items()} - fig, axes, axes_idx = _setup_synthesis_fig(fig, axes_idx, figsize, - included_plots, - **width_ratios) - - if 'display_mad_image' in included_plots: - display_mad_image(mad, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['display_mad_image']], - zoom=zoom, vrange=vrange) - if 'plot_loss' in included_plots: - plot_loss(mad, iteration=iteration, axes=axes[axes_idx['plot_loss']]) + raise ValueError( + "plot_synthesis_status() expects 3 or 4d data;" + "unexpected behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") + width_ratios = {f"{k}_width": v for k, v in width_ratios.items()} + fig, axes, axes_idx = _setup_synthesis_fig( + fig, axes_idx, figsize, included_plots, **width_ratios + ) + + if "display_mad_image" in included_plots: + display_mad_image( + mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["display_mad_image"]], + zoom=zoom, + vrange=vrange, + ) + if "plot_loss" in included_plots: + plot_loss(mad, iteration=iteration, axes=axes[axes_idx["plot_loss"]]) # this function creates a single axis for loss, which plot_loss then # split into two. this makes sure the right two axes are present in the # dict all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, '__iter__'): + if hasattr(i, "__iter__"): all_axes.extend(i) else: all_axes.append(i) - new_axes = [i for i, _ in enumerate(fig.axes) - if i not in all_axes] - axes_idx['plot_loss'] = new_axes - if 'plot_pixel_values' in included_plots: - plot_pixel_values(mad, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['plot_pixel_values']]) + new_axes = [i for i, _ in enumerate(fig.axes) if i not in all_axes] + axes_idx["plot_loss"] = new_axes + if "plot_pixel_values" in included_plots: + plot_pixel_values( + mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["plot_pixel_values"]], + ) return fig, axes_idx -def animate(mad: MADCompetition, - framerate: int = 10, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = ['display_mad_image', - 'plot_loss', - 'plot_pixel_values'], - width_ratios: Dict[str, float] = {}, - ) -> mpl.animation.FuncAnimation: +def animate( + mad: MADCompetition, + framerate: int = 10, + batch_idx: int = 0, + channel_idx: int | None = None, + zoom: float | None = None, + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float] | None = None, + included_plots: list[str] = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + ], + width_ratios: dict[str, float] = {}, +) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. This is essentially the figure produced by @@ -1105,51 +1211,67 @@ def animate(mad: MADCompetition, """ if not mad.store_progress: - raise ValueError("synthesize() was run with store_progress=False," - " cannot animate!") + raise ValueError( + "synthesize() was run with store_progress=False," + " cannot animate!" + ) if mad.mad_image.ndim not in [3, 4]: - raise ValueError("animate() expects 3 or 4d data; unexpected" - " behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') + raise ValueError( + "animate() expects 3 or 4d data; unexpected" + " behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") # we run plot_synthesis_status to initialize the figure if either fig is # None or if there are no titles on any axes, which we assume means that # it's an empty figure if fig is None or not any([ax.get_title() for ax in fig.axes]): - fig, axes_idx = plot_synthesis_status(mad=mad, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=0, figsize=figsize, - zoom=zoom, fig=fig, - included_plots=included_plots, - axes_idx=axes_idx, - width_ratios=width_ratios) + fig, axes_idx = plot_synthesis_status( + mad=mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=0, + figsize=figsize, + zoom=zoom, + fig=fig, + included_plots=included_plots, + axes_idx=axes_idx, + width_ratios=width_ratios, + ) # grab the artist for the second plot (we don't need to do this for the # MAD image plot, because we use the update_plot function for that) - if 'plot_loss' in included_plots: - scat = [fig.axes[i].collections[0] for i in axes_idx['plot_loss']] + if "plot_loss" in included_plots: + scat = [fig.axes[i].collections[0] for i in axes_idx["plot_loss"]] # can also have multiple plots def movie_plot(i): artists = [] - if 'display_mad_image' in included_plots: - artists.extend(display.update_plot(fig.axes[axes_idx['display_mad_image']], - data=mad.saved_mad_image[i], - batch_idx=batch_idx)) - if 'plot_pixel_values' in included_plots: + if "display_mad_image" in included_plots: + artists.extend( + display.update_plot( + fig.axes[axes_idx["display_mad_image"]], + data=mad.saved_mad_image[i], + batch_idx=batch_idx, + ) + ) + if "plot_pixel_values" in included_plots: # this is the dumbest way to do this, but it's simple -- # clearing the axes can cause problems if the user has, for # example, changed the tick locator or formatter. not sure how # to handle this best right now - fig.axes[axes_idx['plot_pixel_values']].clear() - plot_pixel_values(mad, batch_idx=batch_idx, - channel_idx=channel_idx, iteration=i, - ax=fig.axes[axes_idx['plot_pixel_values']]) - if 'plot_loss' in included_plots: + fig.axes[axes_idx["plot_pixel_values"]].clear() + plot_pixel_values( + mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=i, + ax=fig.axes[axes_idx["plot_pixel_values"]], + ) + if "plot_loss" in included_plots: # loss always contains values from every iteration, but everything # else will be subsampled. - x_val = i*mad.store_progress + x_val = i * mad.store_progress scat[0].set_offsets((x_val, mad.reference_metric_loss[x_val])) scat[1].set_offsets((x_val, mad.optimized_metric_loss[x_val])) artists.extend(scat) @@ -1157,22 +1279,28 @@ def movie_plot(i): return artists # don't need an init_func, since we handle initialization ourselves - anim = mpl.animation.FuncAnimation(fig, movie_plot, - frames=len(mad.saved_mad_image), - blit=True, interval=1000./framerate, - repeat=False) + anim = mpl.animation.FuncAnimation( + fig, + movie_plot, + frames=len(mad.saved_mad_image), + blit=True, + interval=1000.0 / framerate, + repeat=False, + ) plt.close(fig) return anim -def display_mad_image_all(mad_metric1_min: MADCompetition, - mad_metric2_min: MADCompetition, - mad_metric1_max: MADCompetition, - mad_metric2_max: MADCompetition, - metric1_name: Optional[str] = None, - metric2_name: Optional[str] = None, - zoom: Union[int, float] = 1, - **kwargs) -> mpl.figure.Figure: +def display_mad_image_all( + mad_metric1_min: MADCompetition, + mad_metric2_min: MADCompetition, + mad_metric1_max: MADCompetition, + mad_metric2_max: MADCompetition, + metric1_name: str | None = None, + metric2_name: str | None = None, + zoom: int | float = 1, + **kwargs, +) -> mpl.figure.Figure: """Display all MAD Competition images. To generate a full set of MAD Competition images, you need four instances: @@ -1216,49 +1344,74 @@ def display_mad_image_all(mad_metric1_min: MADCompetition, # this is a bit of a hack right now, because they don't all have same # initial image if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: metric2_name = mad_metric2_min.optimized_metric.__name__ - fig = pt_make_figure(3, 2, [zoom * i for i in - mad_metric1_min.image.shape[-2:]]) + fig = pt_make_figure( + 3, 2, [zoom * i for i in mad_metric1_min.image.shape[-2:]] + ) mads = [mad_metric1_min, mad_metric1_max, mad_metric2_min, mad_metric2_max] - titles = [f'Minimize {metric1_name}', f'Maximize {metric1_name}', - f'Minimize {metric2_name}', f'Maximize {metric2_name}'] + titles = [ + f"Minimize {metric1_name}", + f"Maximize {metric1_name}", + f"Minimize {metric2_name}", + f"Maximize {metric2_name}", + ] # we're only plotting one image here, so if the user wants multiple # channels, they must be RGB - if kwargs.get('channel_idx', None) is None and mad_metric1_min.initial_image.shape[1] > 1: + if ( + kwargs.get("channel_idx", None) is None + and mad_metric1_min.initial_image.shape[1] > 1 + ): as_rgb = True else: as_rgb = False - display.imshow(mad_metric1_min.image, ax=fig.axes[0], - title='Reference image', zoom=zoom, as_rgb=as_rgb, - **kwargs) - display.imshow(mad_metric1_min.initial_image, ax=fig.axes[1], - title='Initial (noisy) image', zoom=zoom, as_rgb=as_rgb, - **kwargs) - for ax, mad, title in zip(fig.axes[2:], mads, titles): - display_mad_image(mad, zoom=zoom, ax=ax, title=title, - **kwargs) + display.imshow( + mad_metric1_min.image, + ax=fig.axes[0], + title="Reference image", + zoom=zoom, + as_rgb=as_rgb, + **kwargs, + ) + display.imshow( + mad_metric1_min.initial_image, + ax=fig.axes[1], + title="Initial (noisy) image", + zoom=zoom, + as_rgb=as_rgb, + **kwargs, + ) + for ax, mad, title in zip(fig.axes[2:], mads, titles, strict=False): + display_mad_image(mad, zoom=zoom, ax=ax, title=title, **kwargs) return fig -def plot_loss_all(mad_metric1_min: MADCompetition, - mad_metric2_min: MADCompetition, - mad_metric1_max: MADCompetition, - mad_metric2_max: MADCompetition, - metric1_name: Optional[str] = None, - metric2_name: Optional[str] = None, - metric1_kwargs: Dict = {'c': 'C0'}, - metric2_kwargs: Dict = {'c': 'C1'}, - min_kwargs: Dict = {'linestyle': '--'}, - max_kwargs: Dict = {'linestyle': '-'}, - figsize=(10, 5)) -> mpl.figure.Figure: +def plot_loss_all( + mad_metric1_min: MADCompetition, + mad_metric2_min: MADCompetition, + mad_metric1_max: MADCompetition, + mad_metric2_max: MADCompetition, + metric1_name: str | None = None, + metric2_name: str | None = None, + metric1_kwargs: dict = {"c": "C0"}, + metric2_kwargs: dict = {"c": "C1"}, + min_kwargs: dict = {"linestyle": "--"}, + max_kwargs: dict = {"linestyle": "-"}, + figsize=(10, 5), +) -> mpl.figure.Figure: """Plot loss for full set of MAD Competiton instances. To generate a full set of MAD Competition images, you need four instances: @@ -1306,26 +1459,52 @@ def plot_loss_all(mad_metric1_min: MADCompetition, """ if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: metric2_name = mad_metric2_min.optimized_metric.__name__ fig, axes = plt.subplots(1, 2, figsize=figsize) - plot_loss(mad_metric1_min, axes=axes, label=f'Minimize {metric1_name}', - **metric1_kwargs, **min_kwargs) - plot_loss(mad_metric1_max, axes=axes, label=f'Maximize {metric1_name}', - **metric1_kwargs, **max_kwargs) + plot_loss( + mad_metric1_min, + axes=axes, + label=f"Minimize {metric1_name}", + **metric1_kwargs, + **min_kwargs, + ) + plot_loss( + mad_metric1_max, + axes=axes, + label=f"Maximize {metric1_name}", + **metric1_kwargs, + **max_kwargs, + ) # we pass the axes backwards here because the fixed and synthesis metrics are the opposite as they are in the instances above. - plot_loss(mad_metric2_min, axes=axes[::-1], label=f'Minimize {metric2_name}', - **metric2_kwargs, **min_kwargs) - plot_loss(mad_metric2_max, axes=axes[::-1], label=f'Maximize {metric2_name}', - **metric2_kwargs, **max_kwargs) - axes[0].set(ylabel='Loss', title=metric2_name) - axes[1].set(ylabel='Loss', title=metric1_name) - axes[1].legend(loc='center left', bbox_to_anchor=(1.1, .5)) + plot_loss( + mad_metric2_min, + axes=axes[::-1], + label=f"Minimize {metric2_name}", + **metric2_kwargs, + **min_kwargs, + ) + plot_loss( + mad_metric2_max, + axes=axes[::-1], + label=f"Maximize {metric2_name}", + **metric2_kwargs, + **max_kwargs, + ) + axes[0].set(ylabel="Loss", title=metric2_name) + axes[1].set(ylabel="Loss", title=metric1_name) + axes[1].legend(loc="center left", bbox_to_anchor=(1.1, 0.5)) return fig diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index 616bdb20..d2027ea7 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -1,20 +1,25 @@ """Synthesize model metamers.""" -import torch import re +import warnings +from collections import OrderedDict +from collections.abc import Callable +from typing import Literal + +import matplotlib as mpl +import matplotlib.pyplot as plt import numpy as np +import torch from torch import Tensor from tqdm.auto import tqdm -from ..tools import optim, display, signal, data -from ..tools.validate import validate_input, validate_model, validate_coarse_to_fine +from ..tools import data, display, optim, signal from ..tools.convergence import coarse_to_fine_enough, loss_convergence -from typing import Union, Tuple, Callable, List, Dict, Optional -from typing_extensions import Literal +from ..tools.validate import ( + validate_coarse_to_fine, + validate_input, + validate_model, +) from .synthesis import OptimizedSynthesis -import warnings -import matplotlib as mpl -import matplotlib.pyplot as plt -from collections import OrderedDict class Metamer(OptimizedSynthesis): @@ -82,15 +87,24 @@ class Metamer(OptimizedSynthesis): http://www.cns.nyu.edu/~lcv/texture/ """ - def __init__(self, image: Tensor, model: torch.nn.Module, - loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1), - initial_image: Optional[Tensor] = None): + + def __init__( + self, + image: Tensor, + model: torch.nn.Module, + loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, + range_penalty_lambda: float = 0.1, + allowed_range: tuple[float, float] = (0, 1), + initial_image: Tensor | None = None, + ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) - validate_model(model, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) + validate_model( + model, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) self._model = model self._image = image self._image_shape = image.shape @@ -101,7 +115,7 @@ def __init__(self, image: Tensor, model: torch.nn.Module, self._saved_metamer = [] self._store_progress = None - def _initialize(self, initial_image: Optional[Tensor] = None): + def _initialize(self, initial_image: Tensor | None = None): """Initialize the metamer. Set the ``self.metamer`` attribute to be an attribute with the @@ -123,22 +137,29 @@ def _initialize(self, initial_image: Optional[Tensor] = None): metamer.requires_grad_() else: if initial_image.ndimension() < 4: - raise ValueError("initial_image must be torch.Size([n_batch" - ", n_channels, im_height, im_width]) but got " - f"{initial_image.size()}") + raise ValueError( + "initial_image must be torch.Size([n_batch" + ", n_channels, im_height, im_width]) but got " + f"{initial_image.size()}" + ) if initial_image.size() != self.image.size(): raise ValueError("initial_image and image must be same size!") metamer = initial_image.clone().detach() - metamer = metamer.to(dtype=self.image.dtype, device=self.image.device) + metamer = metamer.to( + dtype=self.image.dtype, device=self.image.device + ) metamer.requires_grad_() self._metamer = metamer - def synthesize(self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, - stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, - ): + def synthesize( + self, + max_iter: int = 100, + optimizer: torch.optim.Optimizer | None = None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, + store_progress: bool | int = False, + stop_criterion: float = 1e-4, + stop_iters_to_check: int = 50, + ): r"""Synthesize a metamer. Update the pixels of ``initial_image`` until its representation matches @@ -197,8 +218,11 @@ def synthesize(self, max_iter: int = 100, pbar.close() - def objective_function(self, metamer_representation: Optional[Tensor] = None, - target_representation: Optional[Tensor] = None) -> Tensor: + def objective_function( + self, + metamer_representation: Tensor | None = None, + target_representation: Tensor | None = None, + ) -> Tensor: """Compute the metamer synthesis loss. This calls self.loss_function on ``metamer_representation`` and @@ -222,10 +246,10 @@ def objective_function(self, metamer_representation: Optional[Tensor] = None, metamer_representation = self.model(self.metamer) if target_representation is None: target_representation = self.target_representation - loss = self.loss_function(metamer_representation, - target_representation) - range_penalty = optim.penalize_range(self.metamer, - self.allowed_range) + loss = self.loss_function( + metamer_representation, target_representation + ) + range_penalty = optim.penalize_range(self.metamer, self.allowed_range) return loss + self.range_penalty_lambda * range_penalty def _optimizer_step(self, pbar: tqdm) -> Tensor: @@ -249,23 +273,28 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, - dim=None) + grad_norm = torch.linalg.vector_norm( + self.metamer.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm(self.metamer - last_iter_metamer, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self.metamer - last_iter_metamer, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict(loss=f"{loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]['lr'], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}")) + OrderedDict( + loss=f"{loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]["lr"], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + ) + ) return loss def _check_convergence(self, stop_criterion, stop_iters_to_check): @@ -299,18 +328,20 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): """ return loss_convergence(self, stop_criterion, stop_iters_to_check) - def _initialize_optimizer(self, - optimizer: Optional[torch.optim.Optimizer], - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler]): + def _initialize_optimizer( + self, + optimizer: torch.optim.Optimizer | None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None, + ): """Initialize optimizer and scheduler.""" # this uses the OptimizedSynthesis setter - super()._initialize_optimizer(optimizer, 'metamer') + super()._initialize_optimizer(optimizer, "metamer") self.scheduler = scheduler for pg in self.optimizer.param_groups: # initialize initial_lr if it's not here. Scheduler should add it # if it's not None. - if 'initial_lr' not in pg: - pg['initial_lr'] = pg['lr'] + if "initial_lr" not in pg: + pg["initial_lr"] = pg["lr"] def _store(self, i: int) -> bool: """Store metamer, if appropriate. @@ -330,7 +361,7 @@ def _store(self, i: int) -> bool: """ if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs - self._saved_metamer.append(self.metamer.clone().to('cpu')) + self._saved_metamer.append(self.metamer.clone().to("cpu")) stored = True else: stored = False @@ -386,13 +417,21 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ['_image', '_target_representation', - '_metamer', '_model', '_saved_metamer'] + attrs = [ + "_image", + "_target_representation", + "_metamer", + "_model", + "_saved_metamer", + ] super().to(*args, attrs=attrs, **kwargs) - def load(self, file_path: str, - map_location: Optional[str] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: str | None = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Metamer`` object -- we will @@ -429,33 +468,48 @@ def load(self, file_path: str, """ self._load(file_path, map_location, **pickle_load_args) - def _load(self, file_path: str, - map_location: Optional[str] = None, - additional_check_attributes: List[str] = [], - additional_check_loss_functions: List[str] = [], - **pickle_load_args): + def _load( + self, + file_path: str, + map_location: str | None = None, + additional_check_attributes: list[str] = [], + additional_check_loss_functions: list[str] = [], + **pickle_load_args, + ): r"""Helper function for loading. Users interact with ``load`` (without the underscore), this is to allow subclasses to specify additional attributes or loss functions to check. """ - check_attributes = ['_image', '_target_representation', - '_range_penalty_lambda', '_allowed_range'] + check_attributes = [ + "_image", + "_target_representation", + "_range_penalty_lambda", + "_allowed_range", + ] check_attributes += additional_check_attributes - check_loss_functions = ['loss_function'] + check_loss_functions = ["loss_function"] check_loss_functions += additional_check_loss_functions - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) # make this require a grad again self.metamer.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if len(self._saved_metamer) and self._saved_metamer[0].device.type != 'cpu': - self._saved_metamer = [met.to('cpu') for met in self._saved_metamer] + if ( + len(self._saved_metamer) + and self._saved_metamer[0].device.type != "cpu" + ): + self._saved_metamer = [ + met.to("cpu") for met in self._saved_metamer + ] @property def model(self): @@ -519,7 +573,7 @@ class MetamerCTF(Metamer): scale separately (ignoring the others), then with respect to all of them at the end. (see ``Metamer`` tutorial for more details). - + Attributes ---------- target_representation : torch.Tensor @@ -549,46 +603,63 @@ class MetamerCTF(Metamer): scales_finished : list or None List of scales that we've finished optimizing. """ - def __init__(self, image: Tensor, model: torch.nn.Module, - loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1), - initial_image: Optional[Tensor] = None, - coarse_to_fine: Literal['together', 'separate'] = 'together'): - super().__init__(image, model, loss_function, range_penalty_lambda, - allowed_range, initial_image) + + def __init__( + self, + image: Tensor, + model: torch.nn.Module, + loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, + range_penalty_lambda: float = 0.1, + allowed_range: tuple[float, float] = (0, 1), + initial_image: Tensor | None = None, + coarse_to_fine: Literal["together", "separate"] = "together", + ): + super().__init__( + image, + model, + loss_function, + range_penalty_lambda, + allowed_range, + initial_image, + ) self._init_ctf(coarse_to_fine) - def _init_ctf(self, coarse_to_fine: Literal['together', 'separate']): + def _init_ctf(self, coarse_to_fine: Literal["together", "separate"]): """Initialize stuff related to coarse-to-fine.""" # this will hold the reduced representation of the target image. - if coarse_to_fine not in ['separate', 'together']: - raise ValueError(f"Don't know how to handle value {coarse_to_fine}!" - " Must be one of: 'separate', 'together'") + if coarse_to_fine not in ["separate", "together"]: + raise ValueError( + f"Don't know how to handle value {coarse_to_fine}!" + " Must be one of: 'separate', 'together'" + ) self._ctf_target_representation = None - validate_coarse_to_fine(self.model, image_shape=self.image.shape, - device=self.image.device) + validate_coarse_to_fine( + self.model, image_shape=self.image.shape, device=self.image.device + ) # if self.scales is not None, we're continuing a previous version # and want to continue. this list comprehension creates a new # object, so we don't modify model.scales self._scales = [i for i in self.model.scales[:-1]] - if coarse_to_fine == 'separate': + if coarse_to_fine == "separate": self._scales += [self.model.scales[-1]] - self._scales += ['all'] + self._scales += ["all"] self._scales_timing = dict((k, []) for k in self.scales) self._scales_timing[self.scales[0]].append(0) self._scales_loss = [] self._scales_finished = [] self._coarse_to_fine = coarse_to_fine - def synthesize(self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, - stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, - change_scale_criterion: Optional[float] = 1e-2, - ctf_iters_to_check: int = 50, - ): + def synthesize( + self, + max_iter: int = 100, + optimizer: torch.optim.Optimizer | None = None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, + store_progress: bool | int = False, + stop_criterion: float = 1e-4, + stop_iters_to_check: int = 50, + change_scale_criterion: float | None = 1e-2, + ctf_iters_to_check: int = 50, + ): r"""Synthesize a metamer. Update the pixels of ``initial_image`` until its representation matches @@ -633,9 +704,13 @@ def synthesize(self, max_iter: int = 100, switch scales. """ - if (change_scale_criterion is not None) and (stop_criterion >= change_scale_criterion): - raise ValueError("stop_criterion must be strictly less than " - "change_scale_criterion, or things get weird!") + if (change_scale_criterion is not None) and ( + stop_criterion >= change_scale_criterion + ): + raise ValueError( + "stop_criterion must be strictly less than " + "change_scale_criterion, or things get weird!" + ) # initialize the optimizer and scheduler self._initialize_optimizer(optimizer, scheduler) @@ -643,7 +718,6 @@ def synthesize(self, max_iter: int = 100, # get ready to store progress self.store_progress = store_progress - pbar = tqdm(range(max_iter)) for i in pbar: @@ -651,22 +725,27 @@ def synthesize(self, max_iter: int = 100, # iterations and will be correct across calls to `synthesize` self._store(len(self.losses)) - loss = self._optimizer_step(pbar, change_scale_criterion, ctf_iters_to_check) + loss = self._optimizer_step( + pbar, change_scale_criterion, ctf_iters_to_check + ) if not torch.isfinite(loss): raise ValueError("Found a NaN in loss during optimization.") - if self._check_convergence(i, stop_criterion, stop_iters_to_check, - ctf_iters_to_check): + if self._check_convergence( + i, stop_criterion, stop_iters_to_check, ctf_iters_to_check + ): warnings.warn("Loss has converged, stopping synthesis") break pbar.close() - def _optimizer_step(self, pbar: tqdm, - change_scale_criterion: float, - ctf_iters_to_check: int - ) -> Tensor: + def _optimizer_step( + self, + pbar: tqdm, + change_scale_criterion: float, + ctf_iters_to_check: int, + ) -> Tensor: r"""Compute and propagate gradients, then step the optimizer to update metamer. Parameters @@ -695,19 +774,31 @@ def _optimizer_step(self, pbar: tqdm, # has stopped declining and, if so, switch to the next scale. Then # we're checking if self.scales_loss is long enough to check # ctf_iters_to_check back. - if len(self.scales) > 1 and len(self.scales_loss) >= ctf_iters_to_check: + if ( + len(self.scales) > 1 + and len(self.scales_loss) >= ctf_iters_to_check + ): # Now we check whether loss has decreased less than # change_scale_criterion - if ((change_scale_criterion is None) or abs(self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check]) < change_scale_criterion): + if (change_scale_criterion is None) or abs( + self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check] + ) < change_scale_criterion: # and finally we check whether we've been optimizing this # scale for ctf_iters_to_check - if len(self.losses) - self.scales_timing[self.scales[0]][0] >= ctf_iters_to_check: - self._scales_timing[self.scales[0]].append(len(self.losses)-1) + if ( + len(self.losses) - self.scales_timing[self.scales[0]][0] + >= ctf_iters_to_check + ): + self._scales_timing[self.scales[0]].append( + len(self.losses) - 1 + ) self._scales_finished.append(self._scales.pop(0)) - self._scales_timing[self.scales[0]].append(len(self.losses)) + self._scales_timing[self.scales[0]].append( + len(self.losses) + ) # reset optimizer's lr. for pg in self.optimizer.param_groups: - pg['lr'] = pg['initial_lr'] + pg["lr"] = pg["initial_lr"] # reset ctf target representation, so we update it on # next pass self._ctf_target_representation = None @@ -715,28 +806,33 @@ def _optimizer_step(self, pbar: tqdm, self._scales_loss.append(loss.item()) self._losses.append(overall_loss.item()) - grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, - dim=None) + grad_norm = torch.linalg.vector_norm( + self.metamer.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm(self.metamer - last_iter_metamer, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self.metamer - last_iter_metamer, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict(loss=f"{overall_loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]['lr'], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}", - current_scale=self.scales[0], - current_scale_loss=f'{loss.item():.04e}')) + OrderedDict( + loss=f"{overall_loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]["lr"], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + current_scale=self.scales[0], + current_scale_loss=f"{loss.item():.04e}", + ) + ) return overall_loss - def _closure(self) -> Tuple[Tensor, Tensor]: + def _closure(self) -> tuple[Tensor, Tensor]: r"""An abstraction of the gradient calculation, before the optimization step. This enables optimization algorithms that perform several evaluations @@ -763,12 +859,12 @@ def _closure(self) -> Tuple[Tensor, Tensor]: self.optimizer.zero_grad() analyze_kwargs = {} # if we've reached 'all', we use the full model - if self.scales[0] != 'all': - analyze_kwargs['scales'] = [self.scales[0]] + if self.scales[0] != "all": + analyze_kwargs["scales"] = [self.scales[0]] # if 'together', then we also want all the coarser # scales - if self.coarse_to_fine == 'together': - analyze_kwargs['scales'] += self.scales_finished + if self.coarse_to_fine == "together": + analyze_kwargs["scales"] += self.scales_finished metamer_representation = self.model(self.metamer, **analyze_kwargs) # if analyze_kwargs is empty, we can just compare # metamer_representation against our cached target_representation @@ -792,9 +888,13 @@ def _closure(self) -> Tuple[Tensor, Tensor]: return loss, overall_loss - def _check_convergence(self, i: int, stop_criterion: float, - stop_iters_to_check: int, - ctf_iters_to_check: int) -> bool: + def _check_convergence( + self, + i: int, + stop_criterion: float, + stop_iters_to_check: int, + ctf_iters_to_check: int, + ) -> bool: r"""Check whether the loss has stabilized and whether we've synthesized all scales. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -837,9 +937,12 @@ def _check_convergence(self, i: int, stop_criterion: float, loss_conv = loss_convergence(self, stop_criterion, stop_iters_to_check) return loss_conv and coarse_to_fine_enough(self, i, ctf_iters_to_check) - def load(self, file_path: str, - map_location: Optional[str] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: str | None = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Metamer`` object -- we will @@ -874,8 +977,9 @@ def load(self, file_path: str, *then* load. """ - super()._load(file_path, map_location, ['_coarse_to_fine'], - **pickle_load_args) + super()._load( + file_path, map_location, ["_coarse_to_fine"], **pickle_load_args + ) @property def coarse_to_fine(self): @@ -898,10 +1002,12 @@ def scales_finished(self): return tuple(self._scales_finished) -def plot_loss(metamer: Metamer, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: +def plot_loss( + metamer: Metamer, + iteration: int | None = None, + ax: mpl.axes.Axes | None = None, + **kwargs, +) -> mpl.axes.Axes: """Plot synthesis loss with log-scaled y axis. Plots ``metamer.losses`` over all iterations. Also plots a red dot at @@ -939,21 +1045,23 @@ def plot_loss(metamer: Metamer, ax = plt.gca() ax.semilogy(metamer.losses, **kwargs) try: - ax.scatter(loss_idx, metamer.losses[loss_idx], c='r') + ax.scatter(loss_idx, metamer.losses[loss_idx], c="r") except IndexError: # then there's no loss here pass - ax.set(xlabel='Synthesis iteration', ylabel='Loss') + ax.set(xlabel="Synthesis iteration", ylabel="Loss") return ax -def display_metamer(metamer: Metamer, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: +def display_metamer( + metamer: Metamer, + batch_idx: int = 0, + channel_idx: int | None = None, + zoom: float | None = None, + iteration: int | None = None, + ax: mpl.axes.Axes | None = None, + **kwargs, +) -> mpl.axes.Axes: """Display metamer. You can specify what iteration to view by using the ``iteration`` arg. @@ -1006,17 +1114,24 @@ def display_metamer(metamer: Metamer, as_rgb = False if ax is None: ax = plt.gca() - display.imshow(image, ax=ax, title='Metamer', zoom=zoom, - batch_idx=batch_idx, channel_idx=channel_idx, - as_rgb=as_rgb, **kwargs) + display.imshow( + image, + ax=ax, + title="Metamer", + zoom=zoom, + batch_idx=batch_idx, + channel_idx=channel_idx, + as_rgb=as_rgb, + **kwargs, + ) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) return ax -def _representation_error(metamer: Metamer, - iteration: Optional[int] = None, - **kwargs) -> Tensor: +def _representation_error( + metamer: Metamer, iteration: int | None = None, **kwargs +) -> Tensor: r"""Get the representation error. This is ``metamer.model(metamer) - target_representation)``. If @@ -1039,19 +1154,25 @@ def _representation_error(metamer: Metamer, """ if iteration is not None: - metamer_rep = metamer.model(metamer.saved_metamer[iteration].to(metamer.target_representation.device)) + metamer_rep = metamer.model( + metamer.saved_metamer[iteration].to( + metamer.target_representation.device + ) + ) else: metamer_rep = metamer.model(metamer.metamer, **kwargs) return metamer_rep - metamer.target_representation -def plot_representation_error(metamer: Metamer, - batch_idx: int = 0, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], None, Literal[False]] = None, - ax: Optional[mpl.axes.Axes] = None, - as_rgb: bool = False, - **kwargs) -> List[mpl.axes.Axes]: +def plot_representation_error( + metamer: Metamer, + batch_idx: int = 0, + iteration: int | None = None, + ylim: tuple[float, float] | None | Literal[False] = None, + ax: mpl.axes.Axes | None = None, + as_rgb: bool = False, + **kwargs, +) -> list[mpl.axes.Axes]: r"""Plot distance ratio showing how close we are to convergence. We plot ``_representation_error(metamer, iteration)``. For more details, see @@ -1088,22 +1209,31 @@ def plot_representation_error(metamer: Metamer, List of created axes """ - representation_error = _representation_error(metamer=metamer, - iteration=iteration, **kwargs) + representation_error = _representation_error( + metamer=metamer, iteration=iteration, **kwargs + ) if ax is None: ax = plt.gca() - return display.plot_representation(metamer.model, representation_error, ax, - title="Representation error", ylim=ylim, - batch_idx=batch_idx, as_rgb=as_rgb) - - -def plot_pixel_values(metamer: Metamer, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], Literal[False]] = False, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: + return display.plot_representation( + metamer.model, + representation_error, + ax, + title="Representation error", + ylim=ylim, + batch_idx=batch_idx, + as_rgb=as_rgb, + ) + + +def plot_pixel_values( + metamer: Metamer, + batch_idx: int = 0, + channel_idx: int | None = None, + iteration: int | None = None, + ylim: tuple[float, float] | Literal[False] = False, + ax: mpl.axes.Axes | None = None, + **kwargs, +) -> mpl.axes.Axes: r"""Plot histogram of pixel values of target image and its metamer. As a way to check the distributions of pixel intensities and see @@ -1135,11 +1265,12 @@ def plot_pixel_values(metamer: Metamer, Created axes. """ + def _freedman_diaconis_bins(a): """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) - iqr = np.diff(np.percentile(a, [.25, .75]))[0] + iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] if len(a) < 2: return 1 h = 2 * iqr / (len(a) ** (1 / 3)) @@ -1149,7 +1280,7 @@ def _freedman_diaconis_bins(a): else: return int(np.ceil((a.max() - a.min()) / h)) - kwargs.setdefault('alpha', .4) + kwargs.setdefault("alpha", 0.4) if iteration is None: met = metamer.metamer[batch_idx] else: @@ -1162,10 +1293,18 @@ def _freedman_diaconis_bins(a): ax = plt.gca() image = data.to_numpy(image).flatten() met = data.to_numpy(met).flatten() - ax.hist(met, bins=min(_freedman_diaconis_bins(image), 50), - label='metamer', **kwargs) - ax.hist(image, bins=min(_freedman_diaconis_bins(image), 50), - label='target image', **kwargs) + ax.hist( + met, + bins=min(_freedman_diaconis_bins(image), 50), + label="metamer", + **kwargs, + ) + ax.hist( + image, + bins=min(_freedman_diaconis_bins(image), 50), + label="target image", + **kwargs, + ) ax.legend() if ylim: ax.set_ylim(ylim) @@ -1173,8 +1312,9 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots(to_check: Union[List[str], Dict[str, float]], - to_check_name: str): +def _check_included_plots( + to_check: list[str] | dict[str, float], to_check_name: str +): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -1191,28 +1331,39 @@ def _check_included_plots(to_check: Union[List[str], Dict[str, float]], Name of the `to_check` variable, used in the error message. """ - allowed_vals = ['display_metamer', 'plot_loss', 'plot_representation_error', - 'plot_pixel_values', 'misc'] + allowed_vals = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + "plot_pixel_values", + "misc", + ] try: vals = to_check.keys() except AttributeError: vals = to_check not_allowed = [v for v in vals if v not in allowed_vals] if not_allowed: - raise ValueError(f'{to_check_name} contained value(s) {not_allowed}! ' - f'Only {allowed_vals} are permissible!') - - -def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = ['display_metamer', - 'plot_loss', - 'plot_representation_error'], - display_metamer_width: float = 1, - plot_loss_width: float = 1, - plot_representation_error_width: float = 1, - plot_pixel_values_width: float = 1) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: + raise ValueError( + f"{to_check_name} contained value(s) {not_allowed}! " + f"Only {allowed_vals} are permissible!" + ) + + +def _setup_synthesis_fig( + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float, float] | None = None, + included_plots: list[str] = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + ], + display_metamer_width: float = 1, + plot_loss_width: float = 1, + plot_representation_error_width: float = 1, + plot_pixel_values_width: float = 1, +) -> tuple[mpl.figure.Figure, list[mpl.axes.Axes], dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -1269,68 +1420,79 @@ def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, if "display_metamer" in included_plots: n_subplots += 1 width_ratios.append(display_metamer_width) - if 'display_metamer' not in axes_idx.keys(): - axes_idx['display_metamer'] = data._find_min_int(axes_idx.values()) + if "display_metamer" not in axes_idx.keys(): + axes_idx["display_metamer"] = data._find_min_int(axes_idx.values()) if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if 'plot_loss' not in axes_idx.keys(): - axes_idx['plot_loss'] = data._find_min_int(axes_idx.values()) + if "plot_loss" not in axes_idx.keys(): + axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) if "plot_representation_error" in included_plots: n_subplots += 1 width_ratios.append(plot_representation_error_width) - if 'plot_representation_error' not in axes_idx.keys(): - axes_idx['plot_representation_error'] = data._find_min_int(axes_idx.values()) + if "plot_representation_error" not in axes_idx.keys(): + axes_idx["plot_representation_error"] = data._find_min_int( + axes_idx.values() + ) if "plot_pixel_values" in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if 'plot_pixel_values' not in axes_idx.keys(): - axes_idx['plot_pixel_values'] = data._find_min_int(axes_idx.values()) + if "plot_pixel_values" not in axes_idx.keys(): + axes_idx["plot_pixel_values"] = data._find_min_int( + axes_idx.values() + ) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: # we want (5, 5) for each subplot, with a bit of room between # each subplot - figsize = ((width_ratios*5).sum() + width_ratios.sum()-1, 5) + figsize = ((width_ratios * 5).sum() + width_ratios.sum() - 1, 5) width_ratios = width_ratios / width_ratios.sum() - fig, axes = plt.subplots(1, n_subplots, figsize=figsize, - gridspec_kw={'width_ratios': width_ratios}) + fig, axes = plt.subplots( + 1, + n_subplots, + figsize=figsize, + gridspec_kw={"width_ratios": width_ratios}, + ) if n_subplots == 1: axes = [axes] else: axes = fig.axes # make sure misc contains all the empty axes - misc_axes = axes_idx.get('misc', []) - if not hasattr(misc_axes, '__iter__'): + misc_axes = axes_idx.get("misc", []) + if not hasattr(misc_axes, "__iter__"): misc_axes = [misc_axes] all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, '__iter__'): + if hasattr(i, "__iter__"): all_axes.extend(i) else: all_axes.append(i) misc_axes += [i for i, _ in enumerate(fig.axes) if i not in all_axes] - axes_idx['misc'] = misc_axes + axes_idx["misc"] = misc_axes return fig, axes, axes_idx -def plot_synthesis_status(metamer: Metamer, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], None, Literal[False]] = None, - vrange: Union[Tuple[float, float], str] = 'indep1', - zoom: Optional[float] = None, - plot_representation_error_as_rgb: bool = False, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = ['display_metamer', - 'plot_loss', - 'plot_representation_error'], - width_ratios: Dict[str, float] = {}, - ) -> Tuple[mpl.figure.Figure, Dict[str, int]]: +def plot_synthesis_status( + metamer: Metamer, + batch_idx: int = 0, + channel_idx: int | None = None, + iteration: int | None = None, + ylim: tuple[float, float] | None | Literal[False] = None, + vrange: tuple[float, float] | str = "indep1", + zoom: float | None = None, + plot_representation_error_as_rgb: bool = False, + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float, float] | None = None, + included_plots: list[str] = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + ], + width_ratios: dict[str, float] = {}, +) -> tuple[mpl.figure.Figure, dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create three @@ -1410,19 +1572,23 @@ def plot_synthesis_status(metamer: Metamer, """ if iteration is not None and not metamer.store_progress: - raise ValueError("synthesis() was run with store_progress=False, " - "cannot specify which iteration to plot (only" - " last one, with iteration=None)") + raise ValueError( + "synthesis() was run with store_progress=False, " + "cannot specify which iteration to plot (only" + " last one, with iteration=None)" + ) if metamer.metamer.ndim not in [3, 4]: - raise ValueError("plot_synthesis_status() expects 3 or 4d data;" - "unexpected behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') - width_ratios = {f'{k}_width': v for k, v in width_ratios.items()} - fig, axes, axes_idx = _setup_synthesis_fig(fig, axes_idx, figsize, - included_plots, - **width_ratios) + raise ValueError( + "plot_synthesis_status() expects 3 or 4d data;" + "unexpected behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") + width_ratios = {f"{k}_width": v for k, v in width_ratios.items()} + fig, axes, axes_idx = _setup_synthesis_fig( + fig, axes_idx, figsize, included_plots, **width_ratios + ) def check_iterables(i, vals): for j in vals: @@ -1436,48 +1602,64 @@ def check_iterables(i, vals): return True if "display_metamer" in included_plots: - display_metamer(metamer, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['display_metamer']], - zoom=zoom, vrange=vrange) + display_metamer( + metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["display_metamer"]], + zoom=zoom, + vrange=vrange, + ) if "plot_loss" in included_plots: - plot_loss(metamer, iteration=iteration, ax=axes[axes_idx['plot_loss']]) + plot_loss(metamer, iteration=iteration, ax=axes[axes_idx["plot_loss"]]) if "plot_representation_error" in included_plots: - plot_representation_error(metamer, batch_idx=batch_idx, - iteration=iteration, - ax=axes[axes_idx['plot_representation_error']], - ylim=ylim, - as_rgb=plot_representation_error_as_rgb) + plot_representation_error( + metamer, + batch_idx=batch_idx, + iteration=iteration, + ax=axes[axes_idx["plot_representation_error"]], + ylim=ylim, + as_rgb=plot_representation_error_as_rgb, + ) # this can add a bunch of axes, so this will try and figure # them out - new_axes = [i for i, _ in enumerate(fig.axes) if not - check_iterables(i, axes_idx.values())] + [axes_idx['plot_representation_error']] - axes_idx['plot_representation_error'] = new_axes + new_axes = [ + i + for i, _ in enumerate(fig.axes) + if not check_iterables(i, axes_idx.values()) + ] + [axes_idx["plot_representation_error"]] + axes_idx["plot_representation_error"] = new_axes if "plot_pixel_values" in included_plots: - plot_pixel_values(metamer, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['plot_pixel_values']]) + plot_pixel_values( + metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["plot_pixel_values"]], + ) return fig, axes_idx -def animate(metamer: Metamer, - framerate: int = 10, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - ylim: Union[str, None, Tuple[float, float], Literal[False]] = None, - vrange: Union[Tuple[float, float], str] = (0, 1), - zoom: Optional[float] = None, - plot_representation_error_as_rgb: bool = False, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = ['display_metamer', - 'plot_loss', - 'plot_representation_error'], - width_ratios: Dict[str, float] = {}, - ) -> mpl.animation.FuncAnimation: +def animate( + metamer: Metamer, + framerate: int = 10, + batch_idx: int = 0, + channel_idx: int | None = None, + ylim: str | None | tuple[float, float] | Literal[False] = None, + vrange: tuple[float, float] | str = (0, 1), + zoom: float | None = None, + plot_representation_error_as_rgb: bool = False, + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float, float] | None = None, + included_plots: list[str] = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + ], + width_ratios: dict[str, float] = {}, +) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. This is essentially the figure produced by @@ -1583,119 +1765,150 @@ def animate(metamer: Metamer, """ if not metamer.store_progress: - raise ValueError("synthesize() was run with store_progress=False," - " cannot animate!") + raise ValueError( + "synthesize() was run with store_progress=False," + " cannot animate!" + ) if metamer.metamer.ndim not in [3, 4]: - raise ValueError("animate() expects 3 or 4d data; unexpected" - " behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') + raise ValueError( + "animate() expects 3 or 4d data; unexpected" + " behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") if metamer.target_representation.ndimension() == 4: # we have to do this here so that we set the # ylim_rescale_interval such that we never rescale ylim # (rescaling ylim messes up an image axis) ylim = False try: - if ylim.startswith('rescale'): + if ylim.startswith("rescale"): try: - ylim_rescale_interval = int(ylim.replace('rescale', '')) + ylim_rescale_interval = int(ylim.replace("rescale", "")) except ValueError: # then there's nothing we can convert to an int there - ylim_rescale_interval = int((metamer.saved_metamer.shape[0] - 1) // 10) + ylim_rescale_interval = int( + (metamer.saved_metamer.shape[0] - 1) // 10 + ) if ylim_rescale_interval == 0: - ylim_rescale_interval = int(metamer.saved_metamer.shape[0] - 1) + ylim_rescale_interval = int( + metamer.saved_metamer.shape[0] - 1 + ) ylim = None else: raise ValueError("Don't know how to handle ylim %s!" % ylim) except AttributeError: # this way we'll never rescale - ylim_rescale_interval = len(metamer.saved_metamer)+1 + ylim_rescale_interval = len(metamer.saved_metamer) + 1 # we run plot_synthesis_status to initialize the figure if either fig is # None or if there are no titles on any axes, which we assume means that # it's an empty figure if fig is None or not any([ax.get_title() for ax in fig.axes]): - fig, axes_idx = plot_synthesis_status(metamer=metamer, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=0, figsize=figsize, - ylim=ylim, vrange=vrange, - zoom=zoom, fig=fig, - axes_idx=axes_idx, - included_plots=included_plots, - plot_representation_error_as_rgb=plot_representation_error_as_rgb, - width_ratios=width_ratios) + fig, axes_idx = plot_synthesis_status( + metamer=metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=0, + figsize=figsize, + ylim=ylim, + vrange=vrange, + zoom=zoom, + fig=fig, + axes_idx=axes_idx, + included_plots=included_plots, + plot_representation_error_as_rgb=plot_representation_error_as_rgb, + width_ratios=width_ratios, + ) # grab the artist for the second plot (we don't need to do this for the # metamer or representation plot, because we use the update_plot # function for that) - if 'plot_loss' in included_plots: - scat = fig.axes[axes_idx['plot_loss']].collections[0] + if "plot_loss" in included_plots: + scat = fig.axes[axes_idx["plot_loss"]].collections[0] # can have multiple plots - if 'plot_representation_error' in included_plots: + if "plot_representation_error" in included_plots: try: - rep_error_axes = [fig.axes[i] for i in axes_idx['plot_representation_error']] + rep_error_axes = [ + fig.axes[i] for i in axes_idx["plot_representation_error"] + ] except TypeError: # in this case, axes_idx['plot_representation_error'] is not iterable and so is # a single value - rep_error_axes = [fig.axes[axes_idx['plot_representation_error']]] + rep_error_axes = [fig.axes[axes_idx["plot_representation_error"]]] else: rep_error_axes = [] # can also have multiple plots if metamer.target_representation.ndimension() == 4: - if 'plot_representation_error' in included_plots: - warnings.warn("Looks like representation is image-like, haven't fully thought out how" - " to best handle rescaling color ranges yet!") + if "plot_representation_error" in included_plots: + warnings.warn( + "Looks like representation is image-like, haven't fully thought out how" + " to best handle rescaling color ranges yet!" + ) # replace the bit of the title that specifies the range, # since we don't make any promises about that. we have to do # this here because we need the figure to have been created for ax in rep_error_axes: - ax.set_title(re.sub(r'\n range: .* \n', '\n\n', ax.get_title())) + ax.set_title(re.sub(r"\n range: .* \n", "\n\n", ax.get_title())) def movie_plot(i): artists = [] - if 'display_metamer' in included_plots: - artists.extend(display.update_plot(fig.axes[axes_idx['display_metamer']], - data=metamer.saved_metamer[i], - batch_idx=batch_idx)) - if 'plot_representation_error' in included_plots: - rep_error = _representation_error(metamer, - iteration=i) + if "display_metamer" in included_plots: + artists.extend( + display.update_plot( + fig.axes[axes_idx["display_metamer"]], + data=metamer.saved_metamer[i], + batch_idx=batch_idx, + ) + ) + if "plot_representation_error" in included_plots: + rep_error = _representation_error(metamer, iteration=i) # we pass rep_error_axes to update, and we've grabbed # the right things above - artists.extend(display.update_plot(rep_error_axes, - batch_idx=batch_idx, - model=metamer.model, - data=rep_error)) + artists.extend( + display.update_plot( + rep_error_axes, + batch_idx=batch_idx, + model=metamer.model, + data=rep_error, + ) + ) # again, we know that rep_error_axes contains all the axes # with the representation ratio info - if ((i+1) % ylim_rescale_interval) == 0: + if ((i + 1) % ylim_rescale_interval) == 0: if metamer.target_representation.ndimension() == 3: - display.rescale_ylim(rep_error_axes, - rep_error) - if 'plot_pixel_values' in included_plots: + display.rescale_ylim(rep_error_axes, rep_error) + if "plot_pixel_values" in included_plots: # this is the dumbest way to do this, but it's simple -- # clearing the axes can cause problems if the user has, for # example, changed the tick locator or formatter. not sure how # to handle this best right now - fig.axes[axes_idx['plot_pixel_values']].clear() - plot_pixel_values(metamer, batch_idx=batch_idx, - channel_idx=channel_idx, iteration=i, - ax=fig.axes[axes_idx['plot_pixel_values']]) - if 'plot_loss'in included_plots: + fig.axes[axes_idx["plot_pixel_values"]].clear() + plot_pixel_values( + metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=i, + ax=fig.axes[axes_idx["plot_pixel_values"]], + ) + if "plot_loss" in included_plots: # loss always contains values from every iteration, but everything # else will be subsampled. - x_val = i*metamer.store_progress + x_val = i * metamer.store_progress scat.set_offsets((x_val, metamer.losses[x_val])) artists.append(scat) # as long as blitting is True, need to return a sequence of artists return artists # don't need an init_func, since we handle initialization ourselves - anim = mpl.animation.FuncAnimation(fig, movie_plot, - frames=len(metamer.saved_metamer), - blit=True, interval=1000./framerate, - repeat=False) + anim = mpl.animation.FuncAnimation( + fig, + movie_plot, + frames=len(metamer.saved_metamer), + blit=True, + interval=1000.0 / framerate, + repeat=False, + ) plt.close(fig) return anim diff --git a/src/plenoptic/synthesize/simple_metamer.py b/src/plenoptic/synthesize/simple_metamer.py index fd6b8f8a..db857b3a 100644 --- a/src/plenoptic/synthesize/simple_metamer.py +++ b/src/plenoptic/synthesize/simple_metamer.py @@ -1,11 +1,12 @@ """Simple Metamer Class """ + import torch from tqdm.auto import tqdm -from .synthesis import Synthesis -from ..tools.validate import validate_input, validate_model + from ..tools import optim -from typing import Union +from ..tools.validate import validate_input, validate_model +from .synthesis import Synthesis class SimpleMetamer(Synthesis): @@ -29,8 +30,12 @@ class SimpleMetamer(Synthesis): """ def __init__(self, image: torch.Tensor, model: torch.nn.Module): - validate_model(model, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) + validate_model( + model, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) self.model = model validate_input(image) self.image = image @@ -39,8 +44,11 @@ def __init__(self, image: torch.Tensor, model: torch.nn.Module): self.optimizer = None self.losses = [] - def synthesize(self, max_iter: int = 100, - optimizer: Union[None, torch.optim.Optimizer] = None) -> torch.Tensor: + def synthesize( + self, + max_iter: int = 100, + optimizer: None | torch.optim.Optimizer = None, + ) -> torch.Tensor: """Synthesize a simple metamer. If called multiple times, will continue where we left off. @@ -62,8 +70,9 @@ def synthesize(self, max_iter: int = 100, """ if optimizer is None: if self.optimizer is None: - self.optimizer = torch.optim.Adam([self.metamer], - lr=.01, amsgrad=True) + self.optimizer = torch.optim.Adam( + [self.metamer], lr=0.01, amsgrad=True + ) else: self.optimizer = optimizer @@ -78,10 +87,10 @@ def closure(): # function. You could theoretically also just clamp metamer on # each step of the iteration, but the penalty in the loss seems # to work better in practice - loss = optim.mse(metamer_representation, - self.target_representation) - loss = loss + .1 * optim.penalize_range(self.metamer, - (0, 1)) + loss = optim.mse( + metamer_representation, self.target_representation + ) + loss = loss + 0.1 * optim.penalize_range(self.metamer, (0, 1)) self.losses.append(loss.item()) loss.backward(retain_graph=False) pbar.set_postfix(loss=loss.item()) @@ -100,8 +109,7 @@ def save(self, file_path: str): """ super().save(file_path, attrs=None) - def load(self, file_path: str, - map_location: Union[str, None] = None): + def load(self, file_path: str, map_location: str | None = None): r"""Load all relevant attributes from a .pt file. Note this operates in place and so doesn't return anything. @@ -111,9 +119,12 @@ def load(self, file_path: str, file_path The path to load the synthesis object from """ - check_attributes = ['target_representation', 'image'] - super().load(file_path, check_attributes=check_attributes, - map_location=map_location) + check_attributes = ["target_representation", "image"] + super().load( + file_path, + check_attributes=check_attributes, + map_location=map_location, + ) def to(self, *args, **kwargs): r"""Move and/or cast the parameters and buffers. @@ -146,7 +157,6 @@ def to(self, *args, **kwargs): Returns: Module: self """ - attrs = ['model', 'image', 'target_representation', - 'metamer'] + attrs = ["model", "image", "target_representation", "metamer"] super().to(*args, attrs=attrs, **kwargs) return self diff --git a/src/plenoptic/synthesize/synthesis.py b/src/plenoptic/synthesize/synthesis.py index 8c52dd8c..cc18555c 100644 --- a/src/plenoptic/synthesize/synthesis.py +++ b/src/plenoptic/synthesize/synthesis.py @@ -1,8 +1,8 @@ """abstract synthesis super-class.""" import abc import warnings + import torch -from typing import Optional, List, Tuple, Union class Synthesis(abc.ABC): @@ -20,7 +20,7 @@ def synthesize(self): r"""Synthesize something.""" pass - def save(self, file_path: str, attrs: Optional[List[str]] = None): + def save(self, file_path: str, attrs: list[str] | None = None): r"""Save all relevant (non-model) variables in .pt file. If you leave attrs as None, we grab vars(self) and exclude 'model'. @@ -40,14 +40,16 @@ def save(self, file_path: str, attrs: Optional[List[str]] = None): # this copies the attributes dict so we don't actually remove the # model attribute in the next line attrs = {k: v for k, v in vars(self).items()} - attrs.pop('_model', None) + attrs.pop("_model", None) save_dict = {} for k in attrs: - if k == '_model': - warnings.warn("Models can be quite large and they don't change" - " over synthesis. Please be sure that you " - "actually want to save the model.") + if k == "_model": + warnings.warn( + "Models can be quite large and they don't change" + " over synthesis. Please be sure that you " + "actually want to save the model." + ) attr = getattr(self, k) # detaching the tensors avoids some headaches like the # tensors having extra hooks or the like @@ -56,11 +58,14 @@ def save(self, file_path: str, attrs: Optional[List[str]] = None): save_dict[k] = attr torch.save(save_dict, file_path) - def load(self, file_path: str, - map_location: Optional[str] = None, - check_attributes: List[str] = [], - check_loss_functions: List[str] = [], - **pickle_load_args): + def load( + self, + file_path: str, + map_location: str | None = None, + check_attributes: list[str] = [], + check_loss_functions: list[str] = [], + **pickle_load_args, + ): r"""Load all relevant attributes from a .pt file. This should be called by an initialized ``Synthesis`` object -- we will @@ -98,9 +103,9 @@ def load(self, file_path: str, ``torch.load``, see that function's docstring for details. """ - tmp_dict = torch.load(file_path, - map_location=map_location, - **pickle_load_args) + tmp_dict = torch.load( + file_path, map_location=map_location, **pickle_load_args + ) if map_location is not None: device = map_location else: @@ -116,47 +121,60 @@ def load(self, file_path: str, # the initial underscore. This is because this function # needs to be able to set the attribute, which can only be # done with the hidden version. - if k.startswith('_'): + if k.startswith("_"): display_k = k[1:] else: display_k = k if not hasattr(self, k): - raise AttributeError("All values of `check_attributes` should be " - "attributes set at initialization, but got " - f"attr {display_k}!") + raise AttributeError( + "All values of `check_attributes` should be " + "attributes set at initialization, but got " + f"attr {display_k}!" + ) if isinstance(getattr(self, k), torch.Tensor): # there are two ways this can fail -- the first is if they're # the same shape but different values and the second (in the # except block) are if they're different shapes. try: - if not torch.allclose(getattr(self, k).to(tmp_dict[k].device), - tmp_dict[k], rtol=5e-2): - raise ValueError(f"Saved and initialized {display_k} are " - f"different! Initialized: {getattr(self, k)}" - f", Saved: {tmp_dict[k]}, difference: " - f"{getattr(self, k) - tmp_dict[k]}") + if not torch.allclose( + getattr(self, k).to(tmp_dict[k].device), + tmp_dict[k], + rtol=5e-2, + ): + raise ValueError( + f"Saved and initialized {display_k} are " + f"different! Initialized: {getattr(self, k)}" + f", Saved: {tmp_dict[k]}, difference: " + f"{getattr(self, k) - tmp_dict[k]}" + ) except RuntimeError as e: # we end up here if dtype or shape don't match - if 'The size of tensor a' in e.args[0]: - raise RuntimeError(f"Attribute {display_k} have different shapes in" - " saved and initialized versions! Initialized" - f": {getattr(self, k).shape}, Saved: " - f"{tmp_dict[k].shape}") - elif 'did not match' in e.args[0]: - raise RuntimeError(f"Attribute {display_k} has different dtype in " - "saved and initialized versions! Initialized" - f": {getattr(self, k).dtype}, Saved: " - f"{tmp_dict[k].dtype}") + if "The size of tensor a" in e.args[0]: + raise RuntimeError( + f"Attribute {display_k} have different shapes in" + " saved and initialized versions! Initialized" + f": {getattr(self, k).shape}, Saved: " + f"{tmp_dict[k].shape}" + ) + elif "did not match" in e.args[0]: + raise RuntimeError( + f"Attribute {display_k} has different dtype in " + "saved and initialized versions! Initialized" + f": {getattr(self, k).dtype}, Saved: " + f"{tmp_dict[k].dtype}" + ) else: raise e else: if getattr(self, k) != tmp_dict[k]: - raise ValueError(f"Saved and initialized {display_k} are different!" - f" Self: {getattr(self, k)}, " - f"Saved: {tmp_dict[k]}") + raise ValueError( + f"Saved and initialized {display_k} are different!" + f" Self: {getattr(self, k)}, " + f"Saved: {tmp_dict[k]}" + ) for k in check_loss_functions: # same as above - if k.startswith('_'): + if k.startswith("_"): display_k = k[1:] else: display_k = k @@ -165,20 +183,22 @@ def load(self, file_path: str, saved_loss = tmp_dict[k](tensor_a, tensor_b) init_loss = getattr(self, k)(tensor_a, tensor_b) if not torch.allclose(saved_loss, init_loss, rtol=1e-2): - raise ValueError(f"Saved and initialized {display_k} are " - "different! On two random tensors: " - f"Initialized: {init_loss}, Saved: " - f"{saved_loss}, difference: " - f"{init_loss-saved_loss}") + raise ValueError( + f"Saved and initialized {display_k} are " + "different! On two random tensors: " + f"Initialized: {init_loss}, Saved: " + f"{saved_loss}, difference: " + f"{init_loss-saved_loss}" + ) for k, v in tmp_dict.items(): setattr(self, k, v) @abc.abstractmethod - def to(self, *args, attrs: List[str] = [], **kwargs): + def to(self, *args, attrs: list[str] = [], **kwargs): r"""Moves and/or casts the parameters and buffers. Similar to ``save``, this is an abstract method only because you need to define the attributes to call to on. - + This can be called as .. function:: to(device=None, dtype=None, non_blocking=False) .. function:: to(dtype, non_blocking=False) @@ -210,13 +230,19 @@ def to(self, *args, attrs: List[str] = [], **kwargs): except AttributeError: warnings.warn("model has no `to` method, so we leave it as is...") - device, dtype, non_blocking, memory_format = torch._C._nn._parse_to(*args, **kwargs) + device, dtype, non_blocking, memory_format = torch._C._nn._parse_to( + *args, **kwargs + ) def move(a, k): move_device = None if k.startswith("saved_") else device if memory_format is not None and a.dim() == 4: - return a.to(move_device, dtype, non_blocking, - memory_format=memory_format) + return a.to( + move_device, + dtype, + non_blocking, + memory_format=memory_format, + ) else: return a.to(move_device, dtype, non_blocking) @@ -239,10 +265,12 @@ class OptimizedSynthesis(Synthesis): these will use an optimizer object to iteratively update their output. """ - def __init__(self, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1), - ): + + def __init__( + self, + range_penalty_lambda: float = 0.1, + allowed_range: tuple[float, float] = (0, 1), + ): """Initialize the properties of OptimizedSynthesis.""" self._losses = [] self._gradient_norm = [] @@ -296,10 +324,12 @@ def _closure(self) -> torch.Tensor: loss.backward(retain_graph=False) return loss - def _initialize_optimizer(self, - optimizer: Optional[torch.optim.Optimizer], - synth_name: str, - learning_rate: float = .01): + def _initialize_optimizer( + self, + optimizer: torch.optim.Optimizer | None, + synth_name: str, + learning_rate: float = 0.01, + ): """Initialize optimizer. First time this is called, optimizer can be: @@ -319,15 +349,20 @@ def _initialize_optimizer(self, synth_attr = getattr(self, synth_name) if optimizer is None: if self.optimizer is None: - self._optimizer = torch.optim.Adam([synth_attr], - lr=learning_rate, amsgrad=True) + self._optimizer = torch.optim.Adam( + [synth_attr], lr=learning_rate, amsgrad=True + ) else: if self.optimizer is not None: - raise TypeError("When resuming synthesis, optimizer arg must be None!") - params = optimizer.param_groups[0]['params'] + raise TypeError( + "When resuming synthesis, optimizer arg must be None!" + ) + params = optimizer.param_groups[0]["params"] if len(params) != 1 or not torch.equal(params[0], synth_attr): - raise ValueError(f"For {synth_name} synthesis, optimizer must have one " - f"parameter, the {synth_name} we're synthesizing.") + raise ValueError( + f"For {synth_name} synthesis, optimizer must have one " + f"parameter, the {synth_name} we're synthesizing." + ) self._optimizer = optimizer @property @@ -358,7 +393,7 @@ def store_progress(self): return self._store_progress @store_progress.setter - def store_progress(self, store_progress: Union[bool, int]): + def store_progress(self, store_progress: bool | int): """Initialize store_progress. Sets the ``self.store_progress`` attribute, as well as changing the @@ -378,19 +413,23 @@ def store_progress(self, store_progress: Union[bool, int]): if store_progress: if store_progress is True: store_progress = 1 - if self.store_progress is not None and store_progress != self.store_progress: + if ( + self.store_progress is not None + and store_progress != self.store_progress + ): # we require store_progress to be the same because otherwise the # subsampling relationship between attrs that are stored every # iteration (loss, gradient, etc) and those that are stored every # store_progress iteration (e.g., saved_metamer) changes partway # through and that's annoying - raise Exception("If you've already run synthesize() before, must " - "re-run it with same store_progress arg. You " - f"passed {store_progress} instead of " - f"{self.store_progress} (True is equivalent to 1)") + raise Exception( + "If you've already run synthesize() before, must " + "re-run it with same store_progress arg. You " + f"passed {store_progress} instead of " + f"{self.store_progress} (True is equivalent to 1)" + ) self._store_progress = store_progress @property def optimizer(self): return self._optimizer - diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index 2c815b31..e02d1c9c 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,12 +1,10 @@ -from .data import * +from . import validate from .conv import * +from .data import * +from .display import * +from .external import * +from .optim import * from .signal import * from .stats import * -from .display import * from .straightness import * - -from .optim import * -from .external import * from .validate import remove_grad - -from . import validate diff --git a/src/plenoptic/tools/conv.py b/src/plenoptic/tools/conv.py index 70832efd..cc4ae6eb 100644 --- a/src/plenoptic/tools/conv.py +++ b/src/plenoptic/tools/conv.py @@ -1,10 +1,10 @@ +import math + import numpy as np +import pyrtools as pt import torch -from torch import Tensor import torch.nn.functional as F -import pyrtools as pt -from typing import Union, Tuple -import math +from torch import Tensor def correlate_downsample(image, filt, padding_mode="reflect"): @@ -24,8 +24,15 @@ def correlate_downsample(image, filt, padding_mode="reflect"): assert isinstance(image, torch.Tensor) and isinstance(filt, torch.Tensor) assert image.ndim == 4 and filt.ndim == 2 n_channels = image.shape[1] - image_padded = same_padding(image, kernel_size=filt.shape, pad_mode=padding_mode) - return F.conv2d(image_padded, filt.repeat(n_channels, 1, 1, 1), stride=2, groups=n_channels) + image_padded = same_padding( + image, kernel_size=filt.shape, pad_mode=padding_mode + ) + return F.conv2d( + image_padded, + filt.repeat(n_channels, 1, 1, 1), + stride=2, + groups=n_channels, + ) def upsample_convolve(image, odd, filt, padding_mode="reflect"): @@ -54,10 +61,18 @@ def upsample_convolve(image, odd, filt, padding_mode="reflect"): pad_end = np.array(filt.shape) - np.array(odd) - pad_start pad = np.array([pad_start[1], pad_end[1], pad_start[0], pad_end[0]]) image_prepad = F.pad(image, tuple(pad // 2), mode=padding_mode) - image_upsample = F.conv_transpose2d(image_prepad, - weight=torch.ones((n_channels, 1, 1, 1), device=image.device, dtype=image.dtype), stride=2, groups=n_channels) + image_upsample = F.conv_transpose2d( + image_prepad, + weight=torch.ones( + (n_channels, 1, 1, 1), device=image.device, dtype=image.dtype + ), + stride=2, + groups=n_channels, + ) image_postpad = F.pad(image_upsample, tuple(pad % 2)) - return F.conv2d(image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels) + return F.conv2d( + image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels + ) def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): @@ -77,7 +92,9 @@ def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) + filt = torch.as_tensor( + np.outer(f, f), dtype=torch.float32, device=x.device + ) if scale_filter: filt = filt / 2 for _ in range(n_scales): @@ -103,38 +120,46 @@ def upsample_blur(x, odd, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) + filt = torch.as_tensor( + np.outer(f, f), dtype=torch.float32, device=x.device + ) if scale_filter: filt = filt * 2 return upsample_convolve(x, odd, filt) def _get_same_padding( - x: int, - kernel_size: int, - stride: int, - dilation: int + x: int, kernel_size: int, stride: int, dilation: int ) -> int: """Helper function to determine integer padding for F.pad() given img and kernel""" - pad = (math.ceil(x / stride) - 1) * stride + (kernel_size - 1) * dilation + 1 - x + pad = ( + (math.ceil(x / stride) - 1) * stride + + (kernel_size - 1) * dilation + + 1 + - x + ) pad = max(pad, 0) return pad def same_padding( - x: Tensor, - kernel_size: Union[int, Tuple[int, int]], - stride: Union[int, Tuple[int, int]] = (1, 1), - dilation: Union[int, Tuple[int, int]] = (1, 1), - pad_mode: str = "circular", + x: Tensor, + kernel_size: int | tuple[int, int], + stride: int | tuple[int, int] = (1, 1), + dilation: int | tuple[int, int] = (1, 1), + pad_mode: str = "circular", ) -> Tensor: """Pad a tensor so that 2D convolution will result in output with same dims.""" - assert len(x.shape) > 2, "Input must be tensor whose last dims are height x width" + assert ( + len(x.shape) > 2 + ), "Input must be tensor whose last dims are height x width" ih, iw = x.shape[-2:] pad_h = _get_same_padding(ih, kernel_size[0], stride[0], dilation[0]) pad_w = _get_same_padding(iw, kernel_size[1], stride[1], dilation[1]) if pad_h > 0 or pad_w > 0: - x = F.pad(x, - [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], - mode=pad_mode) + x = F.pad( + x, + [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], + mode=pad_mode, + ) return x diff --git a/src/plenoptic/tools/convergence.py b/src/plenoptic/tools/convergence.py index 8a658ea1..bba4b2d1 100644 --- a/src/plenoptic/tools/convergence.py +++ b/src/plenoptic/tools/convergence.py @@ -20,14 +20,17 @@ # to avoid circular import error: # https://adamj.eu/tech/2021/05/13/python-type-hints-how-to-fix-circular-imports/ from typing import TYPE_CHECKING + if TYPE_CHECKING: - from ..synthesize.synthesis import OptimizedSynthesis from ..synthesize.metamer import Metamer + from ..synthesize.synthesis import OptimizedSynthesis -def loss_convergence(synth: "OptimizedSynthesis", - stop_criterion: float, - stop_iters_to_check: int) -> bool: +def loss_convergence( + synth: "OptimizedSynthesis", + stop_criterion: float, + stop_iters_to_check: int, +) -> bool: r"""Check whether the loss has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -59,13 +62,17 @@ def loss_convergence(synth: "OptimizedSynthesis", """ if len(synth.losses) > stop_iters_to_check: - if abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) < stop_criterion: + if ( + abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) + < stop_criterion + ): return True return False -def coarse_to_fine_enough(synth: "Metamer", i: int, - ctf_iters_to_check: int) -> bool: +def coarse_to_fine_enough( + synth: "Metamer", i: int, ctf_iters_to_check: int +) -> bool: r"""Check whether we've synthesized all scales and done so for at least ctf_iters_to_check iterations This is meant to be paired with another convergence check, such as ``loss_convergence``. @@ -86,18 +93,20 @@ def coarse_to_fine_enough(synth: "Metamer", i: int, Whether we've been doing coarse to fine synthesis for long enough. """ - all_scales = synth.scales[0] == 'all' + all_scales = synth.scales[0] == "all" # synth.scales_timing['all'] will only be a non-empty list if all_scales is # True, so we only check it then. This is equivalent to checking if both conditions are trued if all_scales: - return (i - synth.scales_timing['all'][0]) > ctf_iters_to_check + return (i - synth.scales_timing["all"][0]) > ctf_iters_to_check else: return False -def pixel_change_convergence(synth: "OptimizedSynthesis", - stop_criterion: float, - stop_iters_to_check: int) -> bool: +def pixel_change_convergence( + synth: "OptimizedSynthesis", + stop_criterion: float, + stop_iters_to_check: int, +) -> bool: """Check whether the pixel change norm has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -129,6 +138,8 @@ def pixel_change_convergence(synth: "OptimizedSynthesis", """ if len(synth.pixel_change_norm) > stop_iters_to_check: - if (synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion).all(): + if ( + synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion + ).all(): return True return False diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index 415defa5..5f462842 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -1,13 +1,12 @@ +import os.path as op import pathlib -from typing import List, Optional, Union, Tuple import warnings import imageio import numpy as np -import os.path as op +import torch from pyrtools import synthetic_images from skimage import color -import torch from torch import Tensor from .signal import rescale @@ -28,10 +27,12 @@ np.complex128: torch.complex128, } -TORCH_TO_NUMPY_TYPES = {value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items()} +TORCH_TO_NUMPY_TYPES = { + value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items() +} -def to_numpy(x: Union[Tensor, np.ndarray], squeeze: bool = False) -> np.ndarray: +def to_numpy(x: Tensor | np.ndarray, squeeze: bool = False) -> np.ndarray: r"""cast tensor to numpy in the most conservative way possible Parameters @@ -57,7 +58,7 @@ def to_numpy(x: Union[Tensor, np.ndarray], squeeze: bool = False) -> np.ndarray: return x -def load_images(paths: Union[str, List[str]], as_gray: bool = True) -> Tensor: +def load_images(paths: str | list[str], as_gray: bool = True) -> Tensor: r"""Correctly load in images Our models and synthesis methods expect their inputs to be 4d @@ -138,8 +139,10 @@ def load_images(paths: Union[str, List[str]], as_gray: bool = True) -> Tensor: im = np.expand_dims(im, 0).repeat(3, 0) images.append(im) if len(set([i.shape for i in images])) > 1: - raise ValueError("All images must be the same shape but got the following: " - f"{[i.shape for i in images]}") + raise ValueError( + "All images must be the same shape but got the following: " + f"{[i.shape for i in images]}" + ) images = torch.as_tensor(np.array(images), dtype=torch.float32) if as_gray: if images.ndimension() != 3: @@ -194,7 +197,9 @@ def convert_float_to_int(im: np.ndarray, dtype=np.uint8) -> np.ndarray: return (im * np.iinfo(dtype).max).astype(dtype) -def make_synthetic_stimuli(size: int = 256, requires_grad: bool = True) -> Tensor: +def make_synthetic_stimuli( + size: int = 256, requires_grad: bool = True +) -> Tensor: r"""Make a set of basic stimuli, useful for developping and debugging models Parameters @@ -223,10 +228,13 @@ def make_synthetic_stimuli(size: int = 256, requires_grad: bool = True) -> Tenso bar = np.zeros((size, size)) bar[ - size // 2 - size // 10 : size // 2 + size // 10, size // 2 - 1 : size // 2 + 1 + size // 2 - size // 10 : size // 2 + size // 10, + size // 2 - 1 : size // 2 + 1, ] = 1 - curv_edge = synthetic_images.disk(size=size, radius=size / 1.2, origin=(size, size)) + curv_edge = synthetic_images.disk( + size=size, radius=size / 1.2, origin=(size, size) + ) sine_grating = synthetic_images.sine(size) * synthetic_images.gaussian( size, covariance=size @@ -275,10 +283,10 @@ def make_synthetic_stimuli(size: int = 256, requires_grad: bool = True) -> Tenso def polar_radius( - size: Union[int, Tuple[int, int]], + size: int | tuple[int, int], exponent: float = 1.0, - origin: Optional[Union[int, Tuple[int, int]]] = None, - device: Optional[Union[str, torch.device]] = None, + origin: int | tuple[int, int] | None = None, + device: str | torch.device | None = None, ) -> Tensor: """Make distance-from-origin (r) matrix @@ -336,10 +344,10 @@ def polar_radius( def polar_angle( - size: Union[int, Tuple[int, int]], + size: int | tuple[int, int], phase: float = 0.0, - origin: Optional[Union[int, Tuple[float, float]]] = None, - device: Optional[torch.device] = None, + origin: int | tuple[float, float] | None = None, + device: torch.device | None = None, ) -> Tensor: """Make polar angle matrix (in radians). diff --git a/src/plenoptic/tools/display.py b/src/plenoptic/tools/display.py index 97350074..d903e22f 100644 --- a/src/plenoptic/tools/display.py +++ b/src/plenoptic/tools/display.py @@ -1,20 +1,34 @@ """various helpful utilities for plotting or displaying information """ import warnings -import torch + +import matplotlib.pyplot as plt import numpy as np import pyrtools as pt -import matplotlib.pyplot as plt +import torch + from .data import to_numpy + try: from IPython.display import HTML except ImportError: warnings.warn("Unable to import IPython.display.HTML") -def imshow(image, vrange='indep1', zoom=None, title='', col_wrap=None, ax=None, - cmap=None, plot_complex='rectangular', batch_idx=None, - channel_idx=None, as_rgb=False, **kwargs): +def imshow( + image, + vrange="indep1", + zoom=None, + title="", + col_wrap=None, + ax=None, + cmap=None, + plot_complex="rectangular", + batch_idx=None, + channel_idx=None, + as_rgb=False, + **kwargs, +): """Show image(s) correctly. This function shows images correctly, making sure that each element in the @@ -118,22 +132,26 @@ def imshow(image, vrange='indep1', zoom=None, title='', col_wrap=None, ax=None, im = to_numpy(im) if im.shape[0] > 1 and batch_idx is not None: # this preserves the number of dimensions - im = im[batch_idx:batch_idx+1] + im = im[batch_idx : batch_idx + 1] if channel_idx is not None: # this preserves the number of dimensions - im = im[:, channel_idx:channel_idx+1] + im = im[:, channel_idx : channel_idx + 1] # allow RGB and RGBA if as_rgb: if im.shape[1] not in [3, 4]: - raise Exception("If as_rgb is True, then channel must have 3 " - "or 4 elements!") + raise Exception( + "If as_rgb is True, then channel must have 3 " + "or 4 elements!" + ) im = im.transpose(0, 2, 3, 1) # want to insert a fake "channel" dimension here, so our putting it # into a list below works as expected im = im.reshape((im.shape[0], 1, *im.shape[1:])) elif im.shape[1] > 1 and im.shape[0] > 1: - raise Exception("Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting") + raise Exception( + "Don't know how to plot images with more than one channel and batch!" + " Use batch_idx / channel_idx to choose a subset for plotting" + ) # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate image. # because of how we've handled everything above, we know that im will @@ -152,7 +170,8 @@ def find_zoom(x, limit): divisors = [i for i in range(2, x) if not x % i] # find the largest zoom (equivalently, smallest divisor) such that the # zoomed in image is smaller than the limit - return 1 / min([i for i in divisors if x/i <= limit]) + return 1 / min([i for i in divisors if x / i <= limit]) + if ax is not None and zoom is None: if ax.bbox.height > max(heights): zoom = ax.bbox.height // max(heights) @@ -164,15 +183,35 @@ def find_zoom(x, limit): zoom = find_zoom(max(widths), ax.bbox.width) elif zoom is None: zoom = 1 - return pt.imshow(images_to_plot, vrange=vrange, zoom=zoom, title=title, - col_wrap=col_wrap, ax=ax, cmap=cmap, plot_complex=plot_complex, - **kwargs) - - -def animshow(video, framerate=2., repeat=False, vrange='indep1', zoom=1, - title='', col_wrap=None, ax=None, cmap=None, - plot_complex='rectangular', batch_idx=None, channel_idx=None, - as_rgb=False, **kwargs): + return pt.imshow( + images_to_plot, + vrange=vrange, + zoom=zoom, + title=title, + col_wrap=col_wrap, + ax=ax, + cmap=cmap, + plot_complex=plot_complex, + **kwargs, + ) + + +def animshow( + video, + framerate=2.0, + repeat=False, + vrange="indep1", + zoom=1, + title="", + col_wrap=None, + ax=None, + cmap=None, + plot_complex="rectangular", + batch_idx=None, + channel_idx=None, + as_rgb=False, + **kwargs, +): """Animate video(s) correctly. This function animates videos correctly, making sure that each element in @@ -301,37 +340,59 @@ def animshow(video, framerate=2., repeat=False, vrange='indep1', zoom=1, vid = to_numpy(vid) if vid.shape[0] > 1 and batch_idx is not None: # this preserves the number of dimensions - vid = vid[batch_idx:batch_idx+1] + vid = vid[batch_idx : batch_idx + 1] if channel_idx is not None: # this preserves the number of dimensions - vid = vid[:, channel_idx:channel_idx+1] + vid = vid[:, channel_idx : channel_idx + 1] # allow RGB and RGBA if as_rgb: if vid.shape[1] not in [3, 4]: - raise Exception("If as_rgb is True, then channel must have 3 " - "or 4 elements!") + raise Exception( + "If as_rgb is True, then channel must have 3 " + "or 4 elements!" + ) vid = vid.transpose(0, 2, 3, 4, 1) # want to insert a fake "channel" dimension here, so our putting it # into a list below works as expected vid = vid.reshape((vid.shape[0], 1, *vid.shape[1:])) elif vid.shape[1] > 1 and vid.shape[0] > 1: - raise Exception("Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting") + raise Exception( + "Don't know how to plot images with more than one channel and batch!" + " Use batch_idx / channel_idx to choose a subset for plotting" + ) # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate video. # because of how we've handled everything above, we know that vid will # be (b,c,t,h,w) or (b,c,t,h,w,r) where r is the RGB(A) values for v in vid: videos_to_show.extend([v_.squeeze() for v_ in v]) - return pt.animshow(videos_to_show, framerate=framerate, as_html5=False, - repeat=repeat, vrange=vrange, zoom=zoom, title=title, - col_wrap=col_wrap, ax=ax, cmap=cmap, - plot_complex=plot_complex, **kwargs) - - -def pyrshow(pyr_coeffs, vrange='indep1', zoom=1, show_residuals=True, - cmap=None, plot_complex='rectangular', batch_idx=0, channel_idx=0, - **kwargs): + return pt.animshow( + videos_to_show, + framerate=framerate, + as_html5=False, + repeat=repeat, + vrange=vrange, + zoom=zoom, + title=title, + col_wrap=col_wrap, + ax=ax, + cmap=cmap, + plot_complex=plot_complex, + **kwargs, + ) + + +def pyrshow( + pyr_coeffs, + vrange="indep1", + zoom=1, + show_residuals=True, + cmap=None, + plot_complex="rectangular", + batch_idx=0, + channel_idx=0, + **kwargs, +): r"""Display steerable pyramid coefficients in orderly fashion. This function uses ``imshow`` to show the coefficients of the steeable @@ -408,20 +469,31 @@ def pyrshow(pyr_coeffs, vrange='indep1', zoom=1, show_residuals=True, if np.iscomplex(im).any(): is_complex = True # this removes only the first (batch) dimension - im = im[batch_idx:batch_idx+1].squeeze(0) + im = im[batch_idx : batch_idx + 1].squeeze(0) # this removes only the first (now channel) dimension - im = im[channel_idx:channel_idx+1].squeeze(0) + im = im[channel_idx : channel_idx + 1].squeeze(0) # because of how we've handled everything above, we know that im will # be (h,w). pyr_coeffvis[k] = im - return pt.pyrshow(pyr_coeffvis, is_complex=is_complex, vrange=vrange, - zoom=zoom, cmap=cmap, plot_complex=plot_complex, - show_residuals=show_residuals, **kwargs) - - -def clean_up_axes(ax, ylim=None, spines_to_remove=['top', 'right', 'bottom'], - axes_to_remove=['x']): + return pt.pyrshow( + pyr_coeffvis, + is_complex=is_complex, + vrange=vrange, + zoom=zoom, + cmap=cmap, + plot_complex=plot_complex, + show_residuals=show_residuals, + **kwargs, + ) + + +def clean_up_axes( + ax, + ylim=None, + spines_to_remove=["top", "right", "bottom"], + axes_to_remove=["x"], +): r"""Clean up an axis, as desired when making a stem plot of the representation Parameters @@ -445,18 +517,18 @@ def clean_up_axes(ax, ylim=None, spines_to_remove=['top', 'right', 'bottom'], """ if spines_to_remove is None: - spines_to_remove = ['top', 'right', 'bottom'] + spines_to_remove = ["top", "right", "bottom"] if axes_to_remove is None: - axes_to_remove = ['x'] + axes_to_remove = ["x"] if ylim is not None: if ylim: ax.set_ylim(ylim) else: ax.set_ylim((0, ax.get_ylim()[1])) - if 'x' in axes_to_remove: + if "x" in axes_to_remove: ax.xaxis.set_visible(False) - if 'y' in axes_to_remove: + if "y" in axes_to_remove: ax.yaxis.set_visible(False) for s in spines_to_remove: ax.spines[s].set_visible(False) @@ -491,7 +563,7 @@ def update_stem(stem_container, ydata): """ stem_container.markerline.set_ydata(ydata) segments = stem_container.stemlines.get_segments().copy() - for s, y in zip(segments, ydata): + for s, y in zip(segments, ydata, strict=False): try: s[1, 1] = y except IndexError: @@ -517,6 +589,7 @@ def rescale_ylim(axes, data): values) """ data = data.cpu() + def find_ymax(data): try: return np.abs(data).max() @@ -524,6 +597,7 @@ def find_ymax(data): # then we need to call to_numpy on it because it needs to be # detached and converted to an array return np.abs(to_numpy(data)).max() + try: y_max = find_ymax(data) except TypeError: @@ -533,7 +607,7 @@ def find_ymax(data): ax.set_ylim((-y_max, y_max)) -def clean_stem_plot(data, ax=None, title='', ylim=None, xvals=None, **kwargs): +def clean_stem_plot(data, ax=None, title="", ylim=None, xvals=None, **kwargs): r"""convenience wrapper for plotting stem plots This plots the data, baseline, cleans up the axis, and sets the @@ -617,14 +691,15 @@ def clean_stem_plot(data, ax=None, title='', ylim=None, xvals=None, **kwargs): if ax is None: ax = plt.gca() if xvals is not None: - basefmt = ' ' - ax.hlines(len(xvals[0])*[0], xvals[0], xvals[1], colors='C3', - zorder=10) + basefmt = " " + ax.hlines( + len(xvals[0]) * [0], xvals[0], xvals[1], colors="C3", zorder=10 + ) else: # this is the default basefmt value basefmt = None ax.stem(data, basefmt=basefmt, **kwargs) - ax = clean_up_axes(ax, ylim, ['top', 'right', 'bottom']) + ax = clean_up_axes(ax, ylim, ["top", "right", "bottom"]) if title is not None: ax.set_title(title) return ax @@ -652,7 +727,7 @@ def _get_artists_from_axes(axes, data): use, keys are the corresponding keys for data """ - if not hasattr(axes, '__iter__'): + if not hasattr(axes, "__iter__"): # then we only have one axis, so we may be able to update more than one # data element. if len(axes.containers) > 0: @@ -672,17 +747,25 @@ def _get_artists_from_axes(axes, data): artists = {ax.get_label(): ax for ax in artists} else: if data_check == 1 and data.shape[1] != len(artists): - raise Exception(f"data has {data.shape[1]} things to plot, but " - f"your axis contains {len(artists)} plotting artists, " - "so unsure how to continue! Pass data as a dictionary" - " with keys corresponding to the labels of the artists" - " to update to resolve this.") - elif data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): - raise Exception(f"data has {data.shape[-3]} things to plot, but " - f"your axis contains {len(artists)} plotting artists, " - "so unsure how to continue! Pass data as a dictionary" - " with keys corresponding to the labels of the artists" - " to update to resolve this.") + raise Exception( + f"data has {data.shape[1]} things to plot, but " + f"your axis contains {len(artists)} plotting artists, " + "so unsure how to continue! Pass data as a dictionary" + " with keys corresponding to the labels of the artists" + " to update to resolve this." + ) + elif ( + data_check == 2 + and data.ndim > 2 + and data.shape[-3] != len(artists) + ): + raise Exception( + f"data has {data.shape[-3]} things to plot, but " + f"your axis contains {len(artists)} plotting artists, " + "so unsure how to continue! Pass data as a dictionary" + " with keys corresponding to the labels of the artists" + " to update to resolve this." + ) else: # then we have multiple axes, so we are only updating one data element # per plot @@ -703,19 +786,31 @@ def _get_artists_from_axes(axes, data): data_check = 2 if isinstance(data, dict): if len(data.keys()) != len(artists): - raise Exception(f"data has {len(data.keys())} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!") - artists = {k: a for k, a in zip(data.keys(), artists)} + raise Exception( + f"data has {len(data.keys())} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!" + ) + artists = { + k: a for k, a in zip(data.keys(), artists, strict=False) + } else: if data_check == 1 and data.shape[1] != len(artists): - raise Exception(f"data has {data.shape[1]} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!") - if data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): - raise Exception(f"data has {data.shape[-3]} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!") + raise Exception( + f"data has {data.shape[1]} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!" + ) + if ( + data_check == 2 + and data.ndim > 2 + and data.shape[-3] != len(artists) + ): + raise Exception( + f"data has {data.shape[-3]} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!" + ) if not isinstance(artists, dict): artists = {f"{i:02d}": a for i, a in enumerate(artists)} return artists @@ -787,14 +882,18 @@ def update_plot(axes, data, model=None, batch_idx=0): if isinstance(data, dict): for v in data.values(): if v.ndim not in [3, 4]: - raise ValueError("update_plot expects 3 or 4 dimensional data" - "; unexpected behavior will result otherwise!" - f" Got data of shape {v.shape}") + raise ValueError( + "update_plot expects 3 or 4 dimensional data" + "; unexpected behavior will result otherwise!" + f" Got data of shape {v.shape}" + ) else: if data.ndim not in [3, 4]: - raise ValueError("update_plot expects 3 or 4 dimensional data" - "; unexpected behavior will result otherwise!" - f" Got data of shape {data.shape}") + raise ValueError( + "update_plot expects 3 or 4 dimensional data" + "; unexpected behavior will result otherwise!" + f" Got data of shape {data.shape}" + ) try: artists = model.update_plot(axes=axes, batch_idx=batch_idx, data=data) except AttributeError: @@ -808,19 +907,24 @@ def update_plot(axes, data, model=None, batch_idx=0): # instead, as suggested # https://stackoverflow.com/questions/43629270/how-to-get-single-value-from-dict-with-single-entry try: - if next(iter(ax_artists.values())).get_array().data.ndim > 1: + if ( + next(iter(ax_artists.values())).get_array().data.ndim + > 1 + ): # then this is an RGBA image - data_dict = {'00': data} + data_dict = {"00": data} except Exception as e: - raise Exception("Thought this was an RGB(A) image based on the number of " - "artists and data shape, but something is off! " - f"Original exception: {e}") + raise Exception( + "Thought this was an RGB(A) image based on the number of " + "artists and data shape, but something is off! " + f"Original exception: {e}" + ) else: for i, d in enumerate(data.unbind(1)): # need to keep the shape the same because of how we # check for shape below (unbinding removes a dimension, # so we add it back) - data_dict[f'{i:02d}'] = d.unsqueeze(1) + data_dict[f"{i:02d}"] = d.unsqueeze(1) data = data_dict for k, d in data.items(): try: @@ -861,8 +965,16 @@ def update_plot(axes, data, model=None, batch_idx=0): return artists -def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), - ylim=False, batch_idx=0, title='', as_rgb=False): +def plot_representation( + model=None, + data=None, + ax=None, + figsize=(5, 5), + ylim=False, + batch_idx=0, + title="", + as_rgb=False, +): r"""Helper function for plotting model representation We are trying to plot ``data`` on ``ax``, using @@ -933,15 +1045,15 @@ def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), try: # no point in passing figsize, because we've already created # and are passing an axis or are passing the user-specified one - fig, axes = model.plot_representation(ylim=ylim, ax=ax, title=title, - batch_idx=batch_idx, - data=data) + fig, axes = model.plot_representation( + ylim=ylim, ax=ax, title=title, batch_idx=batch_idx, data=data + ) except AttributeError: if data is None: data = model.representation if not isinstance(data, dict): if title is None: - title = 'Representation' + title = "Representation" data_dict = {} if not as_rgb: # then we peel apart the channels @@ -949,20 +1061,22 @@ def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), # need to keep the shape the same because of how we # check for shape below (unbinding removes a dimension, # so we add it back) - data_dict[title+'_%02d' % i] = d.unsqueeze(1) + data_dict[title + "_%02d" % i] = d.unsqueeze(1) else: data_dict[title] = data data = data_dict else: warnings.warn("data has keys, so we're ignoring title!") # want to make sure the axis we're taking over is basically invisible. - ax = clean_up_axes(ax, False, - ['top', 'right', 'bottom', 'left'], ['x', 'y']) + ax = clean_up_axes( + ax, False, ["top", "right", "bottom", "left"], ["x", "y"] + ) axes = [] if len(list(data.values())[0].shape) == 3: # then this is 'vector-like' - gs = ax.get_subplotspec().subgridspec(min(4, len(data)), - int(np.ceil(len(data) / 4))) + gs = ax.get_subplotspec().subgridspec( + min(4, len(data)), int(np.ceil(len(data) / 4)) + ) for i, (k, v) in enumerate(data.items()): ax = fig.add_subplot(gs[i % 4, i // 4]) # only plot the specified batch, but plot each channel @@ -974,23 +1088,31 @@ def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), axes.append(ax) elif len(list(data.values())[0].shape) == 4: # then this is 'image-like' - gs = ax.get_subplotspec().subgridspec(int(np.ceil(len(data) / 4)), - min(4, len(data))) + gs = ax.get_subplotspec().subgridspec( + int(np.ceil(len(data) / 4)), min(4, len(data)) + ) for i, (k, v) in enumerate(data.items()): ax = fig.add_subplot(gs[i // 4, i % 4]) - ax = clean_up_axes(ax, - False, ['top', 'right', 'bottom', 'left'], - ['x', 'y']) + ax = clean_up_axes( + ax, False, ["top", "right", "bottom", "left"], ["x", "y"] + ) # only plot the specified batch - imshow(v, batch_idx=batch_idx, title=k, ax=ax, - vrange='indep0', as_rgb=as_rgb) + imshow( + v, + batch_idx=batch_idx, + title=k, + ax=ax, + vrange="indep0", + as_rgb=as_rgb, + ) axes.append(ax) # because we're plotting image data, don't want to change # ylim at all ylim = False else: - raise Exception("Don't know what to do with data of shape" - f" {data.shape}") + raise Exception( + "Don't know what to do with data of shape" f" {data.shape}" + ) if ylim is None: if isinstance(data, dict): data = torch.cat(list(data.values()), dim=2) diff --git a/src/plenoptic/tools/external.py b/src/plenoptic/tools/external.py index 310f684d..c6ddefba 100644 --- a/src/plenoptic/tools/external.py +++ b/src/plenoptic/tools/external.py @@ -10,13 +10,19 @@ import numpy as np import pyrtools as pt import scipy.io as sio + from ..data import fetch_data -def plot_MAD_results(original_image, noise_levels=None, - results_dir=None, - ssim_images_dir=None, - zoom=3, vrange='indep1', **kwargs): +def plot_MAD_results( + original_image, + noise_levels=None, + results_dir=None, + ssim_images_dir=None, + zoom=3, + vrange="indep1", + **kwargs, +): r"""plot original MAD results, provided by Zhou Wang Plot the results of original MAD Competition, as provided in .mat @@ -71,9 +77,9 @@ def plot_MAD_results(original_image, noise_levels=None, """ if results_dir is None: - results_dir = str(fetch_data('MAD_results.tar.gz')) + results_dir = str(fetch_data("MAD_results.tar.gz")) if ssim_images_dir is None: - ssim_images_dir = str(fetch_data('ssim_images.tar.gz')) + ssim_images_dir = str(fetch_data("ssim_images.tar.gz")) img_path = op.join(op.expanduser(ssim_images_dir), f"{original_image}.tif") orig_img = imageio.imread(img_path) blanks = np.ones((*orig_img.shape, 4)) @@ -81,63 +87,107 @@ def plot_MAD_results(original_image, noise_levels=None, noise_levels = [2**i for i in range(1, 11)] results = {} images = np.dstack([orig_img, blanks]) - titles = ['Original image'] + 4*[None] - super_titles = 5*[None] - keys = ['im_init', 'im_fixmse_maxssim', 'im_fixmse_minssim', 'im_fixssim_minmse', - 'im_fixssim_maxmse'] + titles = ["Original image"] + 4 * [None] + super_titles = 5 * [None] + keys = [ + "im_init", + "im_fixmse_maxssim", + "im_fixmse_minssim", + "im_fixssim_minmse", + "im_fixssim_maxmse", + ] for l in noise_levels: - mat = sio.loadmat(op.join(op.expanduser(results_dir), - f"{original_image}_L{l}_results.mat"), squeeze_me=True) + mat = sio.loadmat( + op.join( + op.expanduser(results_dir), + f"{original_image}_L{l}_results.mat", + ), + squeeze_me=True, + ) # remove these metadata keys - [mat.pop(k) for k in ['__header__', '__version__', '__globals__']] - key_titles = [f'Noise level: {l}', f"Best SSIM: {mat['maxssim']:.05f}", - f"Worst SSIM: {mat['minssim']:.05f}", - f"Best MSE: {mat['minmse']:.05f}", - f"Worst MSE: {mat['maxmse']:.05f}"] - key_super_titles = [None, f"Fix MSE: {mat['FIX_MSE']:.0f}", None, - f"Fix SSIM: {mat['FIX_SSIM']:.05f}", None] - for k, t, s in zip(keys, key_titles, key_super_titles): + [mat.pop(k) for k in ["__header__", "__version__", "__globals__"]] + key_titles = [ + f"Noise level: {l}", + f"Best SSIM: {mat['maxssim']:.05f}", + f"Worst SSIM: {mat['minssim']:.05f}", + f"Best MSE: {mat['minmse']:.05f}", + f"Worst MSE: {mat['maxmse']:.05f}", + ] + key_super_titles = [ + None, + f"Fix MSE: {mat['FIX_MSE']:.0f}", + None, + f"Fix SSIM: {mat['FIX_SSIM']:.05f}", + None, + ] + for k, t, s in zip(keys, key_titles, key_super_titles, strict=False): images = np.dstack([images, mat.pop(k)]) titles.append(t) super_titles.append(s) # this then just contains the loss information - mat.update({'noise_level': l, 'original_image': original_image}) - results[f'L{l}'] = mat + mat.update({"noise_level": l, "original_image": original_image}) + results[f"L{l}"] = mat images = images.transpose((2, 0, 1)) - if vrange.startswith('row'): + if vrange.startswith("row"): vrange_list = [] - for i in range(len(images)//5): - vr, cmap = pt.tools.display.colormap_range(images[5*i:5*(i+1)], - vrange.replace('row', 'auto')) + for i in range(len(images) // 5): + vr, cmap = pt.tools.display.colormap_range( + images[5 * i : 5 * (i + 1)], vrange.replace("row", "auto") + ) vrange_list.extend(vr) else: vrange_list, cmap = pt.tools.display.colormap_range(images, vrange) # this is a bit of hack to do the same thing imshow does, but with # slightly more space dedicated to the title - fig = pt.tools.display.make_figure(len(images)//5, 5, [zoom*i+1 for i in images.shape[-2:]], - vert_pct=.75) - for img, ax, t, vr, s in zip(images, fig.axes, titles, vrange_list, super_titles): + fig = pt.tools.display.make_figure( + len(images) // 5, + 5, + [zoom * i + 1 for i in images.shape[-2:]], + vert_pct=0.75, + ) + for img, ax, t, vr, s in zip( + images, fig.axes, titles, vrange_list, super_titles, strict=False + ): # these are the blanks if (img == 1).all(): continue - pt.imshow(img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs) + pt.imshow( + img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs + ) if s is not None: - font = {k.replace('_', ''): v for k, v in - ax.title.get_font_properties().__dict__.items()} + font = { + k.replace("_", ""): v + for k, v in ax.title.get_font_properties().__dict__.items() + } # these are the acceptable keys for the fontdict below - font = {k: v for k, v in font.items() if k in ['family', 'color', 'weight', 'size', - 'style']} + font = { + k: v + for k, v in font.items() + if k in ["family", "color", "weight", "size", "style"] + } # for some reason, this (with passing the transform) is # different (and looks better) than using ax.text. We also # slightly adjust the placement of the text to account for # different zoom levels (we also have 10 pixels between the # rows and columns, which correspond to a different) img_size = ax.bbox.size - fig.text(1+(5/img_size[0]), (1/.75), s, fontdict=font, - transform=ax.transAxes, ha='center', va='top') + fig.text( + 1 + (5 / img_size[0]), + (1 / 0.75), + s, + fontdict=font, + transform=ax.transAxes, + ha="center", + va="top", + ) # linewidth of 1.5 looks good with bbox of 192, 192 - linewidth = np.max([1.5 * np.mean(img_size/192), 1]) - line = lines.Line2D(2*[0-((5+linewidth/2)/img_size[0])], [0, (1/.75)], - transform=ax.transAxes, figure=fig, linewidth=linewidth) + linewidth = np.max([1.5 * np.mean(img_size / 192), 1]) + line = lines.Line2D( + 2 * [0 - ((5 + linewidth / 2) / img_size[0])], + [0, (1 / 0.75)], + transform=ax.transAxes, + figure=fig, + linewidth=linewidth, + ) fig.lines.append(line) return fig, results diff --git a/src/plenoptic/tools/optim.py b/src/plenoptic/tools/optim.py index 439cc8c3..4dcf339e 100644 --- a/src/plenoptic/tools/optim.py +++ b/src/plenoptic/tools/optim.py @@ -1,12 +1,12 @@ """Tools related to optimization such as more objective functions. """ + +import numpy as np import torch from torch import Tensor -from typing import Optional, Tuple -import numpy as np -def set_seed(seed: Optional[int] = None) -> None: +def set_seed(seed: int | None = None) -> None: """Set the seed. We call both ``torch.manual_seed()`` and ``np.random.seed()``. @@ -99,11 +99,16 @@ def relative_MSE(synth_rep: Tensor, ref_rep: Tensor, **kwargs) -> Tensor: Ratio of the squared l2-norm of the difference between ``ref_rep`` and ``synth_rep`` to the squared l2-norm of ``ref_rep`` """ - return torch.linalg.vector_norm(ref_rep - synth_rep, ord=2) ** 2 / torch.linalg.vector_norm(ref_rep, ord=2) ** 2 + return ( + torch.linalg.vector_norm(ref_rep - synth_rep, ord=2) ** 2 + / torch.linalg.vector_norm(ref_rep, ord=2) ** 2 + ) def penalize_range( - synth_img: Tensor, allowed_range: Tuple[float, float] = (0.0, 1.0), **kwargs + synth_img: Tensor, + allowed_range: tuple[float, float] = (0.0, 1.0), + **kwargs, ) -> Tensor: r"""penalize values outside of allowed_range diff --git a/src/plenoptic/tools/signal.py b/src/plenoptic/tools/signal.py index 33841d7c..90f4e939 100644 --- a/src/plenoptic/tools/signal.py +++ b/src/plenoptic/tools/signal.py @@ -1,14 +1,11 @@ -from typing import List, Optional, Tuple, Union - import numpy as np import torch -from torch import Tensor -import torch.fft as fft from pyrtools.pyramids.steer import steer_to_harmonics_mtx +from torch import Tensor def minimum( - x: Tensor, dim: Optional[List[int]] = None, keepdim: bool = False + x: Tensor, dim: list[int] | None = None, keepdim: bool = False ) -> Tensor: r"""Compute minimum in torch over any axis or combination of axes in tensor. @@ -16,14 +13,14 @@ def minimum( ---------- x Input tensor. - dim + dim Dimensions over which you would like to compute the minimum. - keepdim + keepdim Keep original dimensions of tensor when returning result. Returns ------- - min_x + min_x Minimum value of x. """ if dim is None: @@ -36,7 +33,7 @@ def minimum( def maximum( - x: Tensor, dim: Optional[List[int]] = None, keepdim: bool = False + x: Tensor, dim: list[int] | None = None, keepdim: bool = False ) -> Tensor: r"""Compute maximum in torch over any dim or combination of axes in tensor. @@ -73,8 +70,8 @@ def rescale(x: Tensor, a: float = 0.0, b: float = 1.0) -> Tensor: def raised_cosine( - width: float = 1, position: float = 0, values: Tuple[float, float] = (0, 1) -) -> Tuple[np.ndarray, np.ndarray]: + width: float = 1, position: float = 0, values: tuple[float, float] = (0, 1) +) -> tuple[np.ndarray, np.ndarray]: """Return a lookup table containing a "raised cosine" soft threshold function. Y = VALUES(1) @@ -116,7 +113,7 @@ def raised_cosine( def interpolate1d( - x_new: Tensor, Y: Union[Tensor, np.ndarray], X: Union[Tensor, np.ndarray] + x_new: Tensor, Y: Tensor | np.ndarray, X: Tensor | np.ndarray ) -> Tensor: r"""One-dimensional linear interpolation. @@ -145,7 +142,7 @@ def interpolate1d( return np.reshape(out, x_new.shape) -def rectangular_to_polar(x: Tensor) -> Tuple[Tensor, Tensor]: +def rectangular_to_polar(x: Tensor) -> tuple[Tensor, Tensor]: r"""Rectangular to polar coordinate transform Parameters @@ -190,9 +187,9 @@ def polar_to_rectangular(amplitude: Tensor, phase: Tensor) -> Tensor: def steer( basis: Tensor, - angle: Union[np.ndarray, Tensor, float], - harmonics: Optional[List[int]] = None, - steermtx: Optional[Union[Tensor, np.ndarray]] = None, + angle: np.ndarray | Tensor | float, + harmonics: list[int] | None = None, + steermtx: Tensor | np.ndarray | None = None, return_weights: bool = False, even_phase: bool = True, ): @@ -286,9 +283,9 @@ def steer( def make_disk( - img_size: Union[int, Tuple[int, int], torch.Size], - outer_radius: Optional[float] = None, - inner_radius: Optional[float] = None, + img_size: int | tuple[int, int] | torch.Size, + outer_radius: float | None = None, + inner_radius: float | None = None, ) -> Tensor: r"""Create a circular mask with softened edges to an image. @@ -327,7 +324,6 @@ def make_disk( for i in range(img_size[0]): # height for j in range(img_size[1]): # width - r = np.sqrt((i - i0) ** 2 + (j - j0) ** 2) if r > outer_radius: @@ -335,13 +331,15 @@ def make_disk( elif r < inner_radius: mask[i][j] = 1 else: - radial_decay = (r - inner_radius) / (outer_radius - inner_radius) + radial_decay = (r - inner_radius) / ( + outer_radius - inner_radius + ) mask[i][j] = (1 + np.cos(np.pi * radial_decay)) / 2 return mask -def add_noise(img: Tensor, noise_mse: Union[float, List[float]]) -> Tensor: +def add_noise(img: Tensor, noise_mse: float | list[float]) -> Tensor: """Add normally distributed noise to an image This adds normally-distributed noise to an image so that the resulting @@ -368,7 +366,9 @@ def add_noise(img: Tensor, noise_mse: Union[float, List[float]]) -> Tensor: ).unsqueeze(0) noise_mse = noise_mse.view(noise_mse.nelement(), 1, 1, 1) noise = 200 * torch.randn( - max(noise_mse.shape[0], img.shape[0]), *img.shape[1:], device=img.device + max(noise_mse.shape[0], img.shape[0]), + *img.shape[1:], + device=img.device, ) noise = noise - noise.mean() noise = noise * torch.sqrt( @@ -377,7 +377,7 @@ def add_noise(img: Tensor, noise_mse: Union[float, List[float]]) -> Tensor: return img + noise -def modulate_phase(x: Tensor, phase_factor: float = 2.) -> Tensor: +def modulate_phase(x: Tensor, phase_factor: float = 2.0) -> Tensor: """Modulate the phase of a complex signal. Doubling the phase of a complex signal allows you to, for example, take the @@ -471,8 +471,11 @@ def center_crop(x: Tensor, output_size: int) -> Tensor: """ h, w = x.shape[-2:] - return x[..., (h//2 - output_size//2) : (h//2 + (output_size+1)//2), - (w//2 - output_size//2) : (w//2 + (output_size+1)//2)] + return x[ + ..., + (h // 2 - output_size // 2) : (h // 2 + (output_size + 1) // 2), + (w // 2 - output_size // 2) : (w // 2 + (output_size + 1) // 2), + ] def expand(x: Tensor, factor: float) -> Tensor: @@ -507,9 +510,13 @@ def expand(x: Tensor, factor: float) -> Tensor: mx = factor * im_x my = factor * im_y if int(mx) != mx: - raise ValueError(f"factor * x.shape[-1] must be an integer but got {mx} instead!") + raise ValueError( + f"factor * x.shape[-1] must be an integer but got {mx} instead!" + ) if int(my) != my: - raise ValueError(f"factor * x.shape[-2] must be an integer but got {my} instead!") + raise ValueError( + f"factor * x.shape[-2] must be an integer but got {my} instead!" + ) mx = int(mx) my = int(my) @@ -588,14 +595,20 @@ def shrink(x: Tensor, factor: int) -> Tensor: my = im_y / factor if int(mx) != mx: - raise ValueError(f"x.shape[-1]/factor must be an integer but got {mx} instead!") + raise ValueError( + f"x.shape[-1]/factor must be an integer but got {mx} instead!" + ) if int(my) != my: - raise ValueError(f"x.shape[-2]/factor must be an integer but got {my} instead!") + raise ValueError( + f"x.shape[-2]/factor must be an integer but got {my} instead!" + ) mx = int(mx) my = int(my) - fourier = 1/factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) + fourier = ( + 1 / factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) + ) fourier_small = torch.zeros( *x.shape[:-2], my, @@ -617,9 +630,18 @@ def shrink(x: Tensor, factor: int) -> Tensor: # This line is equivalent to fourier_small[..., 1:, 1:] = fourier[..., y1:y2, x1:x2] - fourier_small[..., 0, 1:] = (fourier[..., y1-1, x1:x2] + fourier[..., y2, x1:x2])/ 2 - fourier_small[..., 1:, 0] = (fourier[..., y1:y2, x1-1] + fourier[..., y1:y2, x2])/ 2 - fourier_small[..., 0, 0] = (fourier[..., y1-1, x1-1] + fourier[..., y1-1, x2] + fourier[..., y2, x1-1] + fourier[..., y2, x2]) / 4 + fourier_small[..., 0, 1:] = ( + fourier[..., y1 - 1, x1:x2] + fourier[..., y2, x1:x2] + ) / 2 + fourier_small[..., 1:, 0] = ( + fourier[..., y1:y2, x1 - 1] + fourier[..., y1:y2, x2] + ) / 2 + fourier_small[..., 0, 0] = ( + fourier[..., y1 - 1, x1 - 1] + + fourier[..., y1 - 1, x2] + + fourier[..., y2, x1 - 1] + + fourier[..., y2, x2] + ) / 4 fourier_small = torch.fft.ifftshift(fourier_small, dim=(-2, -1)) im_small = torch.fft.ifft2(fourier_small) diff --git a/src/plenoptic/tools/stats.py b/src/plenoptic/tools/stats.py index ecabf1c8..f862ea0d 100644 --- a/src/plenoptic/tools/stats.py +++ b/src/plenoptic/tools/stats.py @@ -1,13 +1,11 @@ -from typing import List, Optional, Union - import torch from torch import Tensor def variance( x: Tensor, - mean: Optional[Union[float, Tensor]] = None, - dim: Optional[Union[int, List[int]]] = None, + mean: float | Tensor | None = None, + dim: int | list[int] | None = None, keepdim: bool = False, ) -> Tensor: r"""Calculate sample variance. @@ -41,9 +39,9 @@ def variance( def skew( x: Tensor, - mean: Optional[Union[float, Tensor]] = None, - var: Optional[Union[float, Tensor]] = None, - dim: Optional[Union[int, List[int]]] = None, + mean: float | Tensor | None = None, + var: float | Tensor | None = None, + dim: int | list[int] | None = None, keepdim: bool = False, ) -> Tensor: r"""Sample estimate of `x` *asymmetry* about its mean @@ -72,14 +70,16 @@ def skew( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow(1.5) + return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow( + 1.5 + ) def kurtosis( x: Tensor, - mean: Optional[Union[float, Tensor]] = None, - var: Optional[Union[float, Tensor]] = None, - dim: Optional[Union[int, List[int]]] = None, + mean: float | Tensor | None = None, + var: float | Tensor | None = None, + dim: int | list[int] | None = None, keepdim: bool = False, ) -> Tensor: r"""sample estimate of `x` *tailedness* (presence of outliers) @@ -114,4 +114,6 @@ def kurtosis( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean(torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim) / var.pow(2) + return torch.mean( + torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim + ) / var.pow(2) diff --git a/src/plenoptic/tools/straightness.py b/src/plenoptic/tools/straightness.py index e90e651a..4ee0301b 100644 --- a/src/plenoptic/tools/straightness.py +++ b/src/plenoptic/tools/straightness.py @@ -1,6 +1,6 @@ import torch from torch import Tensor -from typing import Tuple + from .validate import validate_input @@ -26,7 +26,9 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: validate_input(start, no_batch=True) validate_input(stop, no_batch=True) if start.shape != stop.shape: - raise ValueError(f"start and stop must be same shape, but got {start.shape} and {stop.shape}!") + raise ValueError( + f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" + ) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") shape = start.shape[1:] @@ -34,15 +36,17 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: device = start.device start = start.reshape(1, -1) stop = stop.reshape(1, -1) - tt = torch.linspace(0, 1, steps=n_steps+1, device=device - ).view(n_steps+1, 1) + tt = torch.linspace(0, 1, steps=n_steps + 1, device=device).view( + n_steps + 1, 1 + ) straight = (1 - tt) * start + tt * stop - return straight.reshape((n_steps+1, *shape)) + return straight.reshape((n_steps + 1, *shape)) -def sample_brownian_bridge(start: Tensor, stop: Tensor, - n_steps: int, max_norm: float = 1) -> Tensor: +def sample_brownian_bridge( + start: Tensor, stop: Tensor, n_steps: int, max_norm: float = 1 +) -> Tensor: """Sample a brownian bridge between `start` and `stop` made up of `n_steps` Parameters @@ -70,7 +74,9 @@ def sample_brownian_bridge(start: Tensor, stop: Tensor, validate_input(start, no_batch=True) validate_input(stop, no_batch=True) if start.shape != stop.shape: - raise ValueError(f"start and stop must be same shape, but got {start.shape} and {stop.shape}!") + raise ValueError( + f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" + ) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") if max_norm < 0: @@ -81,21 +87,22 @@ def sample_brownian_bridge(start: Tensor, stop: Tensor, start = start.reshape(1, -1) stop = stop.reshape(1, -1) D = start.shape[1] - dt = torch.as_tensor(1/n_steps) - tt = torch.linspace(0, 1, steps=n_steps+1, device=device)[:, None] + dt = torch.as_tensor(1 / n_steps) + tt = torch.linspace(0, 1, steps=n_steps + 1, device=device)[:, None] - sigma = torch.sqrt(dt / D) * 2. * max_norm - dW = sigma * torch.randn(n_steps+1, D, device=device) + sigma = torch.sqrt(dt / D) * 2.0 * max_norm + dW = sigma * torch.randn(n_steps + 1, D, device=device) dW[0] = start.flatten() W = torch.cumsum(dW, dim=0) bridge = W - tt * (W[-1:] - stop) - return bridge.reshape((n_steps+1, *shape)) + return bridge.reshape((n_steps + 1, *shape)) -def deviation_from_line(sequence: Tensor, - normalize: bool = True) -> Tuple[Tensor, Tensor]: +def deviation_from_line( + sequence: Tensor, normalize: bool = True +) -> tuple[Tensor, Tensor]: """Compute the deviation of `sequence` to the straight line between its endpoints. Project each point of the path `sequence` onto the line defined by @@ -126,14 +133,15 @@ def deviation_from_line(sequence: Tensor, y0 = y[0].view(1, D) y1 = y[-1].view(1, D) - line = (y1 - y0) + line = y1 - y0 line_length = torch.linalg.vector_norm(line, ord=2) line = line / line_length y_centered = y - y0 dist_along_line = y_centered @ line[0] projection = dist_along_line.view(T, 1) * line - dist_from_line = torch.linalg.vector_norm(y_centered - projection, dim=1, - ord=2) + dist_from_line = torch.linalg.vector_norm( + y_centered - projection, dim=1, ord=2 + ) if normalize: dist_along_line /= line_length @@ -162,9 +170,9 @@ def translation_sequence(image: Tensor, n_steps: int = 10) -> Tensor: validate_input(image, no_batch=True) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") - sequence = torch.empty(n_steps+1, *image.shape[1:]).to(image.device) + sequence = torch.empty(n_steps + 1, *image.shape[1:]).to(image.device) - for shift in range(n_steps+1): + for shift in range(n_steps + 1): sequence[shift] = torch.roll(image, shift, [-1]) return sequence diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index c062c70f..c1a5028d 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -1,16 +1,16 @@ """Functions to validate synthesis inputs. """ -import torch -import warnings import itertools -from typing import Tuple, Optional, Callable, Union -from torch import Tensor import warnings +from collections.abc import Callable + +import torch +from torch import Tensor def validate_input( input_tensor: Tensor, no_batch: bool = False, - allowed_range: Optional[Tuple[float, float]] = None, + allowed_range: tuple[float, float] | None = None, ): """Determine whether input_tensor tensor can be used for synthesis. @@ -39,10 +39,17 @@ def validate_input( """ # validate dtype - if input_tensor.dtype not in [torch.float16, torch.complex32, - torch.float32, torch.complex64, - torch.float64, torch.complex128]: - raise TypeError(f"Only float or complex dtypes are allowed but got type {input_tensor.dtype}") + if input_tensor.dtype not in [ + torch.float16, + torch.complex32, + torch.float32, + torch.complex64, + torch.float64, + torch.complex128, + ]: + raise TypeError( + f"Only float or complex dtypes are allowed but got type {input_tensor.dtype}" + ) if input_tensor.ndimension() != 4: if no_batch: n_batch = 1 @@ -57,24 +64,29 @@ def validate_input( if no_batch and input_tensor.shape[0] != 1: # numpy raises ValueError when operands cannot be broadcast together, # so it seems reasonable here - raise ValueError(f"input_tensor batch dimension must be 1.") + raise ValueError("input_tensor batch dimension must be 1.") if allowed_range is not None: if allowed_range[0] >= allowed_range[1]: raise ValueError( "allowed_range[0] must be strictly less than" f" allowed_range[1], but got {allowed_range}" ) - if input_tensor.min() < allowed_range[0] or input_tensor.max() > allowed_range[1]: + if ( + input_tensor.min() < allowed_range[0] + or input_tensor.max() > allowed_range[1] + ): raise ValueError( f"input_tensor range must lie within {allowed_range}, but got" f" {(input_tensor.min().item(), input_tensor.max().item())}" ) -def validate_model(model: torch.nn.Module, - image_shape: Optional[Tuple[int, int, int, int]] = None, - image_dtype: torch.dtype = torch.float32, - device: Union[str, torch.device] = 'cpu'): +def validate_model( + model: torch.nn.Module, + image_shape: tuple[int, int, int, int] | None = None, + image_dtype: torch.dtype = torch.float32, + device: str | torch.device = "cpu", +): """Determine whether model can be used for sythesis. In particular, this function checks the following (with their associated @@ -126,8 +138,9 @@ def validate_model(model: torch.nn.Module, """ if image_shape is None: image_shape = (1, 1, 16, 16) - test_img = torch.rand(image_shape, dtype=image_dtype, requires_grad=False, - device=device) + test_img = torch.rand( + image_shape, dtype=image_dtype, requires_grad=False, device=device + ) try: if model(test_img).requires_grad: raise ValueError( @@ -163,12 +176,14 @@ def validate_model(model: torch.nn.Module, elif image_dtype in [torch.float64, torch.complex128]: allowed_dtypes = [torch.float64, torch.complex128] else: - raise TypeError(f"Only float or complex dtypes are allowed but got type {image_dtype}") + raise TypeError( + f"Only float or complex dtypes are allowed but got type {image_dtype}" + ) if model(test_img).dtype not in allowed_dtypes: raise TypeError("model changes precision of input, don't do that!") if model(test_img).ndimension() not in [3, 4]: raise ValueError( - f"When given a 4d input, model output must be three- or four-" + "When given a 4d input, model output must be three- or four-" "dimensional but had {model(test_img).ndimension()} dimensions instead!" ) if model(test_img).device != test_img.device: @@ -181,9 +196,11 @@ def validate_model(model: torch.nn.Module, ) -def validate_coarse_to_fine(model: torch.nn.Module, - image_shape: Optional[Tuple[int, int, int, int]] = None, - device: Union[str, torch.device] = 'cpu'): +def validate_coarse_to_fine( + model: torch.nn.Module, + image_shape: tuple[int, int, int, int] | None = None, + device: str | torch.device = "cpu", +): """Determine whether a model can be used for coarse-to-fine synthesis. In particular, this function checks the following (with associated errors): @@ -208,7 +225,9 @@ def validate_coarse_to_fine(model: torch.nn.Module, Which device to place the test image on. """ - warnings.warn("Validating whether model can work with coarse-to-fine synthesis -- this can take a while!") + warnings.warn( + "Validating whether model can work with coarse-to-fine synthesis -- this can take a while!" + ) msg = "and therefore we cannot do coarse-to-fine synthesis" if not hasattr(model, "scales"): raise AttributeError(f"model has no scales attribute {msg}") @@ -221,7 +240,7 @@ def validate_coarse_to_fine(model: torch.nn.Module, try: if model_output_shape == model(test_img, scales=sc).shape: raise ValueError( - f"Output of model forward method doesn't change" + "Output of model forward method doesn't change" " shape when scales keyword arg is set to {sc} {msg}" ) except TypeError: @@ -230,10 +249,12 @@ def validate_coarse_to_fine(model: torch.nn.Module, ) -def validate_metric(metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], - image_shape: Optional[Tuple[int, int, int, int]] = None, - image_dtype: torch.dtype = torch.float32, - device: Union[str, torch.device] = 'cpu'): +def validate_metric( + metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], + image_shape: tuple[int, int, int, int] | None = None, + image_dtype: torch.dtype = torch.float32, + device: str | torch.device = "cpu", +): """Determines whether a metric can be used for MADCompetition synthesis. In particular, this functions checks the following (with associated @@ -270,7 +291,9 @@ def validate_metric(metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Te try: same_val = metric(test_img, test_img).item() except TypeError: - raise TypeError("metric should be callable and accept two 4d tensors as input") + raise TypeError( + "metric should be callable and accept two 4d tensors as input" + ) # as of torch 2.0.0, this is a RuntimeError (a Tensor with X elements # cannot be converted to Scalar); previously it was a ValueError (only one # element tensors can be converted to Python scalars) From 4bb4333e9c23f673b101a82f4e3bf4b4b5c0944f Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 8 Aug 2024 11:01:59 -0400 Subject: [PATCH 031/134] notebooks 00-quickstart and 02-eigendistortions line-length correction --- examples/00_quickstart.ipynb | 68 ++++++++---- examples/02_Eigendistortions.ipynb | 160 ++++++++++++++++++----------- 2 files changed, 148 insertions(+), 80 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index 0526e39a..5b94b690 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -95,15 +95,18 @@ " def __init__(self, kernel_size=(7, 7)):\n", " super().__init__()\n", " self.kernel_size = kernel_size\n", - " self.conv = torch.nn.Conv2d(1, 1, kernel_size=kernel_size, padding=(0, 0), bias=False)\n", - " self.conv.weight.data[0, 0] = circular_gaussian2d(kernel_size, 3.)\n", - " \n", + " self.conv = torch.nn.Conv2d(\n", + " 1, 1, kernel_size=kernel_size, padding=(0, 0), bias=False\n", + " )\n", + " self.conv.weight.data[0, 0] = circular_gaussian2d(kernel_size, 3.0)\n", + "\n", " # the forward pass of the model defines how to get from an image to the representation\n", " def forward(self, x):\n", " # use circular padding so our output is the same size as our input\n", - " x = po.tools.conv.same_padding(x, self.kernel_size, pad_mode='circular')\n", + " x = po.tools.conv.same_padding(x, self.kernel_size, pad_mode=\"circular\")\n", " return self.conv(x)\n", "\n", + "\n", "model = SimpleModel()\n", "rep = model(im)" ] @@ -162,7 +165,7 @@ } ], "source": [ - "fig = po.imshow(torch.cat([im, rep]), title=['Original image', 'Model output'])" + "fig = po.imshow(torch.cat([im, rep]), title=[\"Original image\", \"Model output\"])" ] }, { @@ -311,10 +314,17 @@ } ], "source": [ - "fig = po.imshow([im, rep, metamer.metamer, model(metamer.metamer)], \n", - " col_wrap=2, vrange='auto1',\n", - " title=['Original image', 'Model representation\\nof original image',\n", - " 'Synthesized metamer', 'Model representation\\nof synthesized metamer']);" + "fig = po.imshow(\n", + " [im, rep, metamer.metamer, model(metamer.metamer)],\n", + " col_wrap=2,\n", + " vrange=\"auto1\",\n", + " title=[\n", + " \"Original image\",\n", + " \"Model representation\\nof original image\",\n", + " \"Synthesized metamer\",\n", + " \"Model representation\\nof synthesized metamer\",\n", + " ],\n", + ")" ] }, { @@ -4229,7 +4239,9 @@ } ], "source": [ - "po.synth.metamer.animate(metamer, included_plots=['display_metamer', 'plot_loss'], figsize=(12, 5))" + "po.synth.metamer.animate(\n", + " metamer, included_plots=[\"display_metamer\", \"plot_loss\"], figsize=(12, 5)\n", + ")" ] }, { @@ -4257,7 +4269,7 @@ ], "source": [ "curie = po.data.curie()\n", - "po.imshow([curie]);" + "po.imshow([curie])" ] }, { @@ -4297,12 +4309,16 @@ } ], "source": [ - "metamer = po.synthesize.Metamer(im, model, initial_image=curie, )\n", + "metamer = po.synthesize.Metamer(\n", + " im,\n", + " model,\n", + " initial_image=curie,\n", + ")\n", "\n", "# we increase the length of time we run synthesis and decrease the\n", "# stop_criterion, which determines when we think loss has converged\n", "# for stopping synthesis early.\n", - "synth_image = metamer.synthesize(max_iter=500, stop_criterion=1e-6)" + "synth_image = metamer.synthesize(max_iter=500, stop_criterion=1e-6)" ] }, { @@ -4366,10 +4382,17 @@ } ], "source": [ - "fig = po.imshow([im, rep, metamer.metamer, model(metamer.metamer)], \n", - " col_wrap=2, vrange='auto1',\n", - " title=['Original image', 'Model representation\\nof original image',\n", - " 'Synthesized metamer', 'Model representation\\nof synthesized metamer']);" + "fig = po.imshow(\n", + " [im, rep, metamer.metamer, model(metamer.metamer)],\n", + " col_wrap=2,\n", + " vrange=\"auto1\",\n", + " title=[\n", + " \"Original image\",\n", + " \"Model representation\\nof original image\",\n", + " \"Synthesized metamer\",\n", + " \"Model representation\\nof synthesized metamer\",\n", + " ],\n", + ")" ] }, { @@ -4427,7 +4450,7 @@ ], "source": [ "eig = po.synthesize.Eigendistortion(im, model)\n", - "eig.synthesize();" + "eig.synthesize()" ] }, { @@ -4454,8 +4477,9 @@ } ], "source": [ - "po.imshow(eig.eigendistortions, title=['Maximum eigendistortion', \n", - " 'Minimum eigendistortion']);" + "po.imshow(\n", + " eig.eigendistortions, title=[\"Maximum eigendistortion\", \"Minimum eigendistortion\"]\n", + ")" ] }, { @@ -4472,7 +4496,7 @@ "kernelspec": { "display_name": "plenoptic", "language": "python", - "name": "plenoptic" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -4484,7 +4508,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.10" } }, "nbformat": 4, diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index f75c9602..ee3a7628 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -47,21 +47,23 @@ "import matplotlib.pyplot as plt\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "import torch\n", "from torch import nn\n", "\n", "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", - "# if this fails, install torchvision in your plenoptic environment \n", + "# if this fails, install torchvision in your plenoptic environment\n", "# and restart the notebook kernel.\n", "try:\n", " from torchvision import models\n", "except ModuleNotFoundError:\n", - " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", - " \" please install it in your plenoptic environment \"\n", - " \"and restart the notebook kernel\")\n", + " raise ModuleNotFoundError(\n", + " \"optional dependency torchvision not found!\"\n", + " \" please install it in your plenoptic environment \"\n", + " \"and restart the notebook kernel\"\n", + " )\n", "import plenoptic as po" ] }, @@ -125,6 +127,7 @@ " \"\"\"The simplest model we can make.\n", " Its Jacobian should be the weight matrix of M, and the eigenvectors of the Fisher matrix are therefore the\n", " eigenvectors of M.T @ M\"\"\"\n", + "\n", " def __init__(self, n, m):\n", " super(LinearModel, self).__init__()\n", " torch.manual_seed(0)\n", @@ -134,21 +137,24 @@ " y = self.M(x) # this computes y = x @ M.T\n", " return y\n", "\n", + "\n", "n = 25 # input vector dim (can you predict what the eigenvec/vals would be when n Date: Thu, 8 Aug 2024 11:13:35 -0400 Subject: [PATCH 032/134] Revert "notebooks 00-quickstart and 02-eigendistortions line-length correction" This reverts commit 4bb4333e9c23f673b101a82f4e3bf4b4b5c0944f. --- examples/00_quickstart.ipynb | 68 ++++-------- examples/02_Eigendistortions.ipynb | 160 +++++++++++------------------ 2 files changed, 80 insertions(+), 148 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index 5b94b690..0526e39a 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -95,18 +95,15 @@ " def __init__(self, kernel_size=(7, 7)):\n", " super().__init__()\n", " self.kernel_size = kernel_size\n", - " self.conv = torch.nn.Conv2d(\n", - " 1, 1, kernel_size=kernel_size, padding=(0, 0), bias=False\n", - " )\n", - " self.conv.weight.data[0, 0] = circular_gaussian2d(kernel_size, 3.0)\n", - "\n", + " self.conv = torch.nn.Conv2d(1, 1, kernel_size=kernel_size, padding=(0, 0), bias=False)\n", + " self.conv.weight.data[0, 0] = circular_gaussian2d(kernel_size, 3.)\n", + " \n", " # the forward pass of the model defines how to get from an image to the representation\n", " def forward(self, x):\n", " # use circular padding so our output is the same size as our input\n", - " x = po.tools.conv.same_padding(x, self.kernel_size, pad_mode=\"circular\")\n", + " x = po.tools.conv.same_padding(x, self.kernel_size, pad_mode='circular')\n", " return self.conv(x)\n", "\n", - "\n", "model = SimpleModel()\n", "rep = model(im)" ] @@ -165,7 +162,7 @@ } ], "source": [ - "fig = po.imshow(torch.cat([im, rep]), title=[\"Original image\", \"Model output\"])" + "fig = po.imshow(torch.cat([im, rep]), title=['Original image', 'Model output'])" ] }, { @@ -314,17 +311,10 @@ } ], "source": [ - "fig = po.imshow(\n", - " [im, rep, metamer.metamer, model(metamer.metamer)],\n", - " col_wrap=2,\n", - " vrange=\"auto1\",\n", - " title=[\n", - " \"Original image\",\n", - " \"Model representation\\nof original image\",\n", - " \"Synthesized metamer\",\n", - " \"Model representation\\nof synthesized metamer\",\n", - " ],\n", - ")" + "fig = po.imshow([im, rep, metamer.metamer, model(metamer.metamer)], \n", + " col_wrap=2, vrange='auto1',\n", + " title=['Original image', 'Model representation\\nof original image',\n", + " 'Synthesized metamer', 'Model representation\\nof synthesized metamer']);" ] }, { @@ -4239,9 +4229,7 @@ } ], "source": [ - "po.synth.metamer.animate(\n", - " metamer, included_plots=[\"display_metamer\", \"plot_loss\"], figsize=(12, 5)\n", - ")" + "po.synth.metamer.animate(metamer, included_plots=['display_metamer', 'plot_loss'], figsize=(12, 5))" ] }, { @@ -4269,7 +4257,7 @@ ], "source": [ "curie = po.data.curie()\n", - "po.imshow([curie])" + "po.imshow([curie]);" ] }, { @@ -4309,16 +4297,12 @@ } ], "source": [ - "metamer = po.synthesize.Metamer(\n", - " im,\n", - " model,\n", - " initial_image=curie,\n", - ")\n", + "metamer = po.synthesize.Metamer(im, model, initial_image=curie, )\n", "\n", "# we increase the length of time we run synthesis and decrease the\n", "# stop_criterion, which determines when we think loss has converged\n", "# for stopping synthesis early.\n", - "synth_image = metamer.synthesize(max_iter=500, stop_criterion=1e-6)" + "synth_image = metamer.synthesize(max_iter=500, stop_criterion=1e-6)" ] }, { @@ -4382,17 +4366,10 @@ } ], "source": [ - "fig = po.imshow(\n", - " [im, rep, metamer.metamer, model(metamer.metamer)],\n", - " col_wrap=2,\n", - " vrange=\"auto1\",\n", - " title=[\n", - " \"Original image\",\n", - " \"Model representation\\nof original image\",\n", - " \"Synthesized metamer\",\n", - " \"Model representation\\nof synthesized metamer\",\n", - " ],\n", - ")" + "fig = po.imshow([im, rep, metamer.metamer, model(metamer.metamer)], \n", + " col_wrap=2, vrange='auto1',\n", + " title=['Original image', 'Model representation\\nof original image',\n", + " 'Synthesized metamer', 'Model representation\\nof synthesized metamer']);" ] }, { @@ -4450,7 +4427,7 @@ ], "source": [ "eig = po.synthesize.Eigendistortion(im, model)\n", - "eig.synthesize()" + "eig.synthesize();" ] }, { @@ -4477,9 +4454,8 @@ } ], "source": [ - "po.imshow(\n", - " eig.eigendistortions, title=[\"Maximum eigendistortion\", \"Minimum eigendistortion\"]\n", - ")" + "po.imshow(eig.eigendistortions, title=['Maximum eigendistortion', \n", + " 'Minimum eigendistortion']);" ] }, { @@ -4496,7 +4472,7 @@ "kernelspec": { "display_name": "plenoptic", "language": "python", - "name": "python3" + "name": "plenoptic" }, "language_info": { "codemirror_mode": { @@ -4508,7 +4484,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index ee3a7628..f75c9602 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -47,23 +47,21 @@ "import matplotlib.pyplot as plt\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams[\"figure.dpi\"] = 72\n", + "plt.rcParams['figure.dpi'] = 72\n", "import torch\n", "from torch import nn\n", "\n", "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", - "# if this fails, install torchvision in your plenoptic environment\n", + "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", "try:\n", " from torchvision import models\n", "except ModuleNotFoundError:\n", - " raise ModuleNotFoundError(\n", - " \"optional dependency torchvision not found!\"\n", - " \" please install it in your plenoptic environment \"\n", - " \"and restart the notebook kernel\"\n", - " )\n", + " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", + " \" please install it in your plenoptic environment \"\n", + " \"and restart the notebook kernel\")\n", "import plenoptic as po" ] }, @@ -127,7 +125,6 @@ " \"\"\"The simplest model we can make.\n", " Its Jacobian should be the weight matrix of M, and the eigenvectors of the Fisher matrix are therefore the\n", " eigenvectors of M.T @ M\"\"\"\n", - "\n", " def __init__(self, n, m):\n", " super(LinearModel, self).__init__()\n", " torch.manual_seed(0)\n", @@ -137,24 +134,21 @@ " y = self.M(x) # this computes y = x @ M.T\n", " return y\n", "\n", - "\n", "n = 25 # input vector dim (can you predict what the eigenvec/vals would be when n Date: Thu, 8 Aug 2024 11:17:48 -0400 Subject: [PATCH 033/134] Revert "updating some deprecated imports, isinstance for union of types, unsorted imports, f-strings, replaced single quote with double quotes and deleted trailing whitespace" This reverts commit c1fd8bcb131387240356fe85392b66b5ae2bb6b4. --- examples/00_quickstart.ipynb | 12 +- examples/02_Eigendistortions.ipynb | 14 +- examples/03_Steerable_Pyramid.ipynb | 18 +- examples/04_Perceptual_distance.ipynb | 15 +- examples/05_Geodesics.ipynb | 49 +- examples/06_Metamer.ipynb | 8 +- examples/07_Simple_MAD.ipynb | 17 +- examples/08_MAD_Competition.ipynb | 8 +- examples/09_Original_MAD.ipynb | 9 +- examples/Demo_Eigendistortion.ipynb | 4 +- examples/Display.ipynb | 6 +- examples/Metamer-Portilla-Simoncelli.ipynb | 32 +- examples/Synthesis_extensions.ipynb | 22 +- noxfile.py | 2 - src/plenoptic/__init__.py | 10 +- src/plenoptic/data/__init__.py | 28 +- src/plenoptic/data/data_utils.py | 14 +- src/plenoptic/data/fetch.py | 110 +-- src/plenoptic/metric/__init__.py | 4 +- src/plenoptic/metric/classes.py | 12 +- src/plenoptic/metric/perceptual_distance.py | 165 ++-- src/plenoptic/simulate/__init__.py | 2 +- .../canonical_computations/__init__.py | 4 +- .../canonical_computations/filters.py | 27 +- .../laplacian_pyramid.py | 3 +- .../canonical_computations/non_linearities.py | 29 +- .../steerable_pyramid_freq.py | 221 ++--- src/plenoptic/simulate/models/frontend.py | 109 +-- src/plenoptic/simulate/models/naive.py | 80 +- .../simulate/models/portilla_simoncelli.py | 171 ++-- src/plenoptic/synthesize/__init__.py | 2 +- src/plenoptic/synthesize/autodiff.py | 7 +- src/plenoptic/synthesize/eigendistortion.py | 129 +-- src/plenoptic/synthesize/geodesic.py | 281 ++---- src/plenoptic/synthesize/mad_competition.py | 763 ++++++--------- src/plenoptic/synthesize/metamer.py | 873 +++++++----------- src/plenoptic/synthesize/simple_metamer.py | 50 +- src/plenoptic/synthesize/synthesis.py | 179 ++-- src/plenoptic/tools/__init__.py | 12 +- src/plenoptic/tools/conv.py | 75 +- src/plenoptic/tools/convergence.py | 37 +- src/plenoptic/tools/data.py | 42 +- src/plenoptic/tools/display.py | 342 +++---- src/plenoptic/tools/external.py | 128 +-- src/plenoptic/tools/optim.py | 15 +- src/plenoptic/tools/signal.py | 90 +- src/plenoptic/tools/stats.py | 26 +- src/plenoptic/tools/straightness.py | 48 +- src/plenoptic/tools/validate.py | 81 +- 49 files changed, 1636 insertions(+), 2749 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index 0526e39a..faf80c8b 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -15,11 +15,10 @@ "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "import torch\n", - "\n", "import plenoptic as po\n", - "\n", + "import torch\n", + "import pyrtools as pt\n", + "import matplotlib.pyplot as plt\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "\n", @@ -84,10 +83,7 @@ ], "source": [ "# this is a convenience function for creating a simple Gaussian kernel\n", - "from plenoptic.simulate.canonical_computations.filters import (\n", - " circular_gaussian2d,\n", - ")\n", - "\n", + "from plenoptic.simulate.canonical_computations.filters import circular_gaussian2d\n", "\n", "# Simple rectified Gaussian convolutional model\n", "class SimpleModel(torch.nn.Module):\n", diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index f75c9602..8b85fc29 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -45,14 +45,11 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", - "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "import torch\n", - "from torch import nn\n", - "\n", "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", - "\n", + "from torch import nn\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -62,6 +59,7 @@ " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\")\n", + "import os.path as op\n", "import plenoptic as po" ] }, @@ -824,7 +822,7 @@ } ], "source": [ - "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=3)\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=3);\n", "po.synth.eigendistortion.display_eigendistortion(ed_resneta, -1, as_rgb=True, zoom=3);" ] }, @@ -1027,10 +1025,10 @@ } ], "source": [ - "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=2, title=\"top eigendist\")\n", - "po.synth.eigendistortion.display_eigendistortion(ed_resneta, -1, as_rgb=True, zoom=2, title=\"bottom eigendist\")\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=2, title=\"top eigendist\");\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, -1, as_rgb=True, zoom=2, title=\"bottom eigendist\");\n", "\n", - "po.synth.eigendistortion.display_eigendistortion(ed_resnetb, 0, as_rgb=True, zoom=2, title=\"top eigendist\")\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resnetb, 0, as_rgb=True, zoom=2, title=\"top eigendist\");\n", "po.synth.eigendistortion.display_eigendistortion(ed_resnetb, -1, as_rgb=True, zoom=2, title=\"bottom eigendist\");" ] }, diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index 2b82cddf..a1030fba 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -21,7 +21,6 @@ "source": [ "import numpy as np\n", "import torch\n", - "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -31,19 +30,20 @@ " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\")\n", - "import matplotlib.pyplot as plt\n", - "import torch.nn.functional as F\n", "import torchvision.transforms as transforms\n", + "import torch.nn.functional as F\n", "from torch import nn\n", + "import matplotlib.pyplot as plt\n", "\n", + "import pyrtools as pt\n", "import plenoptic as po\n", "from plenoptic.simulate import SteerablePyramidFreq\n", + "from plenoptic.synthesize import Eigendistortion\n", "from plenoptic.tools.data import to_numpy\n", - "\n", "dtype = torch.float32\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "import os\n", "from tqdm.auto import tqdm\n", - "\n", "%load_ext autoreload\n", "\n", "%autoreload 2\n", @@ -218,7 +218,7 @@ ], "source": [ "print(pyr_coeffs.keys())\n", - "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=0)\n", + "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=0);\n", "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=1);" ] }, @@ -267,7 +267,7 @@ "#get the 3rd scale\n", "print(pyr.scales)\n", "pyr_coeffs_scale0 = pyr(im_batch, scales=[2])\n", - "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=0)\n", + "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=0);\n", "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=1);" ] }, @@ -323,7 +323,7 @@ ], "source": [ "# the same visualization machinery works for complex pyramids; what is shown is the magnitude of the coefficients\n", - "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=0)\n", + "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=0);\n", "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=1);" ] }, @@ -2310,7 +2310,7 @@ } ], "source": [ - "po.pyrshow(pyr_coeffs_complex, zoom=0.5)\n", + "po.pyrshow(pyr_coeffs_complex, zoom=0.5);\n", "po.pyrshow(pyr_coeffs_fixed_1, zoom=0.5);" ] }, diff --git a/examples/04_Perceptual_distance.ipynb b/examples/04_Perceptual_distance.ipynb index 93a1c869..46bd12f0 100644 --- a/examples/04_Perceptual_distance.ipynb +++ b/examples/04_Perceptual_distance.ipynb @@ -28,15 +28,14 @@ "outputs": [], "source": [ "import os\n", - "\n", + "import io\n", "import imageio\n", - "import matplotlib.pyplot as plt\n", + "import plenoptic as po\n", "import numpy as np\n", - "import torch\n", - "from PIL import Image\n", "from scipy.stats import pearsonr, spearmanr\n", - "\n", - "import plenoptic as po" + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from PIL import Image" ] }, { @@ -81,8 +80,6 @@ "outputs": [], "source": [ "import tempfile\n", - "\n", - "\n", "def add_jpeg_artifact(img, quality):\n", " # need to convert this back to 2d 8-bit int for writing out as jpg\n", " img = po.to_numpy(img.squeeze() * 255).astype(np.uint8)\n", @@ -396,7 +393,7 @@ " folder / \"distorted_images\" / distorted_filename).convert(\"L\"))) / 255\n", " distorted_images = distorted_images[:, [0] + list(range(2, 17)) + list(range(18, 24))] # Remove color distortions\n", "\n", - " with open(folder/ \"mos.txt\", encoding=\"utf-8\") as g:\n", + " with open(folder/ \"mos.txt\", \"r\", encoding=\"utf-8\") as g:\n", " mos_values = list(map(float, g.readlines()))\n", " mos_values = np.array(mos_values).reshape([25, 24, 5])\n", " mos_values = mos_values[:, [0] + list(range(2, 17)) + list(range(18, 24))] # Remove color distortions\n", diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index 73f32e30..a6fc4a13 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -36,24 +36,20 @@ } ], "source": [ - "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "\n", + "import matplotlib.pyplot as plt\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "%matplotlib inline\n", "\n", "import pyrtools as pt\n", - "\n", "import plenoptic as po\n", "from plenoptic.tools import to_numpy\n", - "\n", "%load_ext autoreload\n", "%autoreload 2\n", "\n", "import torch\n", "import torch.nn as nn\n", - "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -146,8 +142,6 @@ "outputs": [], "source": [ "import torch.fft\n", - "\n", - "\n", "class Fourier(nn.Module):\n", " def __init__(self, representation = 'amp'):\n", " super().__init__()\n", @@ -228,7 +222,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", "po.synth.geodesic.plot_deviation_from_line(moog, vid, ax=axes[1]);" ] }, @@ -249,7 +243,7 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.step_energy), alpha=.2)\n", + "plt.plot(po.to_numpy(moog.step_energy), alpha=.2);\n", "plt.plot(moog.step_energy.mean(1), 'r-', label='path energy')\n", "plt.axhline(torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2) ** 2 / moog.n_steps ** 2)\n", "plt.legend()\n", @@ -308,7 +302,7 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.dev_from_line[..., 1]))\n", + "plt.plot(po.to_numpy(moog.dev_from_line[..., 1]));\n", "\n", "plt.title('evolution of distance from representation line')\n", "plt.ylabel('distance from representation line')\n", @@ -367,7 +361,7 @@ "geodesic = to_numpy(moog.geodesic.squeeze())\n", "fig = pt.imshow([video[5], pixelfade[5], geodesic[5]],\n", " title=['video', 'pixelfade', 'geodesic'],\n", - " col_wrap=3, zoom=4)\n", + " col_wrap=3, zoom=4);\n", "\n", "size = geodesic.shape[-1]\n", "h, m , l = (size//2 + size//4, size//2, size//2 - size//4)\n", @@ -378,9 +372,9 @@ " a.axhline(line, lw=2)\n", "\n", "pt.imshow([video[:,l], pixelfade[:,l], geodesic[:,l]],\n", - " title=None, col_wrap=3, zoom=4)\n", + " title=None, col_wrap=3, zoom=4);\n", "pt.imshow([video[:,m], pixelfade[:,m], geodesic[:,m]],\n", - " title=None, col_wrap=3, zoom=4)\n", + " title=None, col_wrap=3, zoom=4);\n", "pt.imshow([video[:,h], pixelfade[:,h], geodesic[:,h]],\n", " title=None, col_wrap=3, zoom=4);" ] @@ -477,7 +471,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" ] }, @@ -524,7 +518,7 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.step_energy), alpha=.2)\n", + "plt.plot(po.to_numpy(moog.step_energy), alpha=.2);\n", "plt.plot(moog.step_energy.mean(1), 'r-', label='path energy')\n", "plt.axhline(torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2) ** 2 / moog.n_steps ** 2)\n", "plt.legend()\n", @@ -636,9 +630,9 @@ ], "source": [ "print('geodesic')\n", - "pt.imshow(list(geodesic), vrange='auto1', title=None, zoom=4)\n", + "pt.imshow(list(geodesic), vrange='auto1', title=None, zoom=4);\n", "print('diff')\n", - "pt.imshow(list(geodesic - pixelfade), vrange='auto1', title=None, zoom=4)\n", + "pt.imshow(list(geodesic - pixelfade), vrange='auto1', title=None, zoom=4);\n", "print('pixelfade')\n", "pt.imshow(list(pixelfade), vrange='auto1', title=None, zoom=4);" ] @@ -663,7 +657,7 @@ "# checking that the range constraint is met\n", "plt.hist(video.flatten(), histtype='step', density=True, label='video')\n", "plt.hist(pixelfade.flatten(), histtype='step', density=True, label='pixelfade')\n", - "plt.hist(geodesic.flatten(), histtype='step', density=True, label='geodesic')\n", + "plt.hist(geodesic.flatten(), histtype='step', density=True, label='geodesic');\n", "plt.title('signal value histogram')\n", "plt.legend(loc=1)\n", "plt.show()" @@ -722,9 +716,9 @@ "l = 90\n", "imgA = imgA[..., u:u+224, l:l+224]\n", "imgB = imgB[..., u:u+224, l:l+224]\n", - "po.imshow([imgA, imgB], as_rgb=True)\n", + "po.imshow([imgA, imgB], as_rgb=True);\n", "diff = imgA - imgB\n", - "po.imshow(diff)\n", + "po.imshow(diff);\n", "pt.image_compare(po.to_numpy(imgA, True), po.to_numpy(imgB, True));" ] }, @@ -745,6 +739,7 @@ } ], "source": [ + "from torchvision import models\n", "# Create a class that takes the nth layer output of a given model\n", "class NthLayer(torch.nn.Module):\n", " \"\"\"Wrap any model to get the response of an intermediate layer\n", @@ -825,7 +820,7 @@ "predA = po.to_numpy(models.vgg16(pretrained=True)(imgA))[0]\n", "predB = po.to_numpy(models.vgg16(pretrained=True)(imgB))[0]\n", "\n", - "plt.plot(predA)\n", + "plt.plot(predA);\n", "plt.plot(predB);" ] }, @@ -940,7 +935,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" ] }, @@ -1057,12 +1052,12 @@ } ], "source": [ - "po.imshow(moog.geodesic, as_rgb=True, zoom=2, title=None, vrange='auto0')\n", - "po.imshow(moog.pixelfade, as_rgb=True, zoom=2, title=None, vrange='auto0')\n", + "po.imshow(moog.geodesic, as_rgb=True, zoom=2, title=None, vrange='auto0');\n", + "po.imshow(moog.pixelfade, as_rgb=True, zoom=2, title=None, vrange='auto0');\n", "# per channel difference\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 0:1]], zoom=2, title=None, vrange='auto1')\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 1:2]], zoom=2, title=None, vrange='auto1')\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 2:]], zoom=2, title=None, vrange='auto1')\n", + "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 0:1]], zoom=2, title=None, vrange='auto1');\n", + "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 1:2]], zoom=2, title=None, vrange='auto1');\n", + "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 2:]], zoom=2, title=None, vrange='auto1');\n", "# exaggerated color difference\n", "po.imshow([po.tools.rescale((moog.geodesic - moog.pixelfade)[1:-1])], as_rgb=True, zoom=2, title=None);" ] diff --git a/examples/06_Metamer.ipynb b/examples/06_Metamer.ipynb index a35c4644..16f5cc68 100644 --- a/examples/06_Metamer.ipynb +++ b/examples/06_Metamer.ipynb @@ -21,12 +21,12 @@ "metadata": {}, "outputs": [], "source": [ + "import plenoptic as po\n", + "from plenoptic.tools import to_numpy\n", "import imageio\n", - "import matplotlib.pyplot as plt\n", "import torch\n", - "\n", - "import plenoptic as po\n", - "\n", + "import pyrtools as pt\n", + "import matplotlib.pyplot as plt\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "# Animation-related settings\n", diff --git a/examples/07_Simple_MAD.ipynb b/examples/07_Simple_MAD.ipynb index 52b177b9..964594a6 100644 --- a/examples/07_Simple_MAD.ipynb +++ b/examples/07_Simple_MAD.ipynb @@ -24,18 +24,15 @@ } ], "source": [ - "import matplotlib.pyplot as plt\n", - "import pyrtools as pt\n", - "import torch\n", - "\n", "import plenoptic as po\n", "from plenoptic.tools import to_numpy\n", - "\n", + "import torch\n", + "import pyrtools as pt\n", + "import matplotlib.pyplot as plt\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", - "import itertools\n", - "\n", "import numpy as np\n", + "import itertools\n", "\n", "%load_ext autoreload\n", "%autoreload 2" @@ -120,7 +117,7 @@ "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1], strict=False)):\n", + "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1])):\n", " name = f'{m1.__name__}_{t}'\n", " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values! \n", " po.tools.set_seed(10)\n", @@ -171,7 +168,7 @@ "source": [ "fig, axes = plt.subplots(2, 2, figsize=(10, 10))\n", "pal = {'l1_norm': 'C0', 'l2_norm': 'C1'}\n", - "for ax, (k, mad) in zip(axes.flatten(), all_mad.items(), strict=False):\n", + "for ax, (k, mad) in zip(axes.flatten(), all_mad.items()):\n", " ax.plot(mad.optimized_metric_loss, pal[mad.optimized_metric.__name__], label=mad.optimized_metric.__name__)\n", " ax.plot(mad.reference_metric_loss, pal[mad.reference_metric.__name__], label=mad.reference_metric.__name__)\n", " ax.set(title=k.capitalize().replace('_', ' '), xlabel='Iteration', ylabel='Loss')\n", @@ -409,7 +406,7 @@ "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1], strict=False)):\n", + "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1])):\n", " name = f'{m1.__name__}_{t}'\n", " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values! \n", " po.tools.set_seed(0)\n", diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index 9b16f3df..5688609c 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -35,12 +35,14 @@ } ], "source": [ - "import matplotlib.pyplot as plt\n", - "\n", "import plenoptic as po\n", - "\n", + "import imageio\n", + "import torch\n", + "import pyrtools as pt\n", + "import matplotlib.pyplot as plt\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", + "import numpy as np\n", "import warnings\n", "\n", "%load_ext autoreload\n", diff --git a/examples/09_Original_MAD.ipynb b/examples/09_Original_MAD.ipynb index d731dc7e..7c02a123 100644 --- a/examples/09_Original_MAD.ipynb +++ b/examples/09_Original_MAD.ipynb @@ -17,8 +17,15 @@ "metadata": {}, "outputs": [], "source": [ + "import imageio\n", + "import torch\n", + "import scipy.io as sio\n", + "import pyrtools as pt\n", + "from scipy.io import loadmat\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "import plenoptic as po\n", - "\n", + "import os.path as op\n", "%matplotlib inline\n", "\n", "%load_ext autoreload\n", diff --git a/examples/Demo_Eigendistortion.ipynb b/examples/Demo_Eigendistortion.ipynb index c811a5dc..558c0ad6 100644 --- a/examples/Demo_Eigendistortion.ipynb +++ b/examples/Demo_Eigendistortion.ipynb @@ -44,9 +44,8 @@ } ], "source": [ - "from plenoptic.simulate.models import OnOff\n", "from plenoptic.synthesize import Eigendistortion\n", - "\n", + "from plenoptic.simulate.models import OnOff\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment \n", "# and restart the notebook kernel.\n", @@ -58,7 +57,6 @@ " \"and restart the notebook kernel\")\n", "import torch\n", "from torch import nn\n", - "\n", "import plenoptic as po\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", diff --git a/examples/Display.ipynb b/examples/Display.ipynb index f3dbf6c8..a62db0da 100644 --- a/examples/Display.ipynb +++ b/examples/Display.ipynb @@ -18,10 +18,8 @@ "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "\n", "import plenoptic as po\n", - "\n", + "import matplotlib.pyplot as plt\n", "# so that relativfe sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", "# Animation-related settings\n", @@ -30,8 +28,8 @@ "plt.rcParams['animation.writer'] = 'ffmpeg'\n", "plt.rcParams['animation.ffmpeg_args'] = ['-threads', '1']\n", "\n", - "import numpy as np\n", "import torch\n", + "import numpy as np\n", "\n", "%load_ext autoreload\n", "%autoreload 2\n", diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index 4772e233..8e0e1816 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -15,13 +15,20 @@ } ], "source": [ - "\n", - "import einops\n", + "import numpy as np\n", + "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import torch\n", - "\n", "import plenoptic as po\n", - "\n", + "import scipy.io as sio\n", + "import os\n", + "import os.path as op\n", + "import einops\n", + "import glob\n", + "import math\n", + "import pyrtools as pt\n", + "from tqdm import tqdm\n", + "from PIL import Image\n", "%load_ext autoreload\n", "%autoreload \n", "\n", @@ -368,7 +375,7 @@ "# send image and PS model to GPU, if available. then im_init and Metamer will also use GPU\n", "img = img.to(DEVICE)\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "im_init = (torch.rand_like(img)-.5) * .1 + img.mean()\n", + "im_init = (torch.rand_like(img)-.5) * .1 + img.mean();\n", "\n", "met = po.synth.MetamerCTF(img, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init,\n", " coarse_to_fine='together')\n", @@ -519,8 +526,6 @@ "# Be sure to run this cell.\n", "\n", "from collections import OrderedDict\n", - "\n", - "\n", "class PortillaSimoncelliRemove(po.simul.PortillaSimoncelli):\n", " r\"\"\"Model for measuring a subset of texture statistics reported by PortillaSimoncelli\n", "\n", @@ -665,7 +670,7 @@ "source": [ "# visualize results\n", "fig = po.imshow([metamer.image, metamer.metamer, metamer_remove.metamer], \n", - " title=['Target image', 'Full Statistics', 'Without Marginal Statistics'], vrange='auto1')\n", + " title=['Target image', 'Full Statistics', 'Without Marginal Statistics'], vrange='auto1');\n", "# add plots showing the different pixel intensity histograms\n", "fig.add_axes([.33, -1, .33, .9])\n", "fig.add_axes([.67, -1, .33, .9])\n", @@ -1372,8 +1377,8 @@ " target=None\n", " ):\n", " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", - " self.mask = mask\n", - " self.target = target\n", + " self.mask = mask;\n", + " self.target = target;\n", " \n", " def forward(self, image, scales=None):\n", " r\"\"\"Generate Texture Statistics representation of an image using the target for the masked portion\n", @@ -1434,7 +1439,7 @@ "source": [ "img_file = DATA_PATH / 'fig14b.jpg'\n", "img = po.tools.load_images(img_file).to(DEVICE)\n", - "im_init = (torch.rand_like(img)-.5) * .1 + img.mean()\n", + "im_init = (torch.rand_like(img)-.5) * .1 + img.mean();\n", "\n", "mask = torch.zeros(1,1,256,256).bool().to(DEVICE)\n", "ctr_dim = (img.shape[-2]//4, img.shape[-1]//4)\n", @@ -1990,6 +1995,7 @@ "metadata": {}, "outputs": [], "source": [ + "from collections import OrderedDict\n", "\n", "class PortillaSimoncelliMagMeans(po.simul.PortillaSimoncelli):\n", " r\"\"\"Include the magnitude means in the PS texture representation.\n", @@ -2137,11 +2143,11 @@ ], "source": [ "fig, axes = plt.subplots(2, 2, figsize=(21, 11), gridspec_kw={'width_ratios': [1, 3.1]})\n", - "for ax, im, info in zip(axes[:, 0], [met.metamer, met_mag_means.metamer], ['with', 'without'], strict=False):\n", + "for ax, im, info in zip(axes[:, 0], [met.metamer, met_mag_means.metamer], ['with', 'without']):\n", " po.imshow(im, ax=ax, title=f\"Metamer {info} magnitude means\")\n", " ax.xaxis.set_visible(False)\n", " ax.yaxis.set_visible(False)\n", - "model_mag_means.plot_representation(model_mag_means(met.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[0,1])\n", + "model_mag_means.plot_representation(model_mag_means(met.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[0,1]);\n", "model_mag_means.plot_representation(model_mag_means(met_mag_means.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[1,1]);" ] }, diff --git a/examples/Synthesis_extensions.ipynb b/examples/Synthesis_extensions.ipynb index 0e49b31c..d0d1efe1 100644 --- a/examples/Synthesis_extensions.ipynb +++ b/examples/Synthesis_extensions.ipynb @@ -21,15 +21,13 @@ }, "outputs": [], "source": [ - "import warnings\n", - "from collections.abc import Callable\n", - "from typing import Literal\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import torch\n", - "from torch import Tensor\n", - "\n", "import plenoptic as po\n", + "from torch import Tensor\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "from typing import Union, Callable, Tuple, Optional\n", + "from typing_extensions import Literal\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams['figure.dpi'] = 72\n", @@ -48,13 +46,13 @@ "class MADCompetitionVariant(po.synth.MADCompetition):\n", " \"\"\"Initialize MADCompetition with an image instead!\"\"\"\n", " def __init__(self, image: Tensor,\n", - " optimized_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor],\n", - " reference_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor],\n", + " optimized_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]],\n", + " reference_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]],\n", " minmax: Literal['min', 'max'],\n", " initial_image: Tensor = None,\n", - " metric_tradeoff_lambda: float | None = None,\n", + " metric_tradeoff_lambda: Optional[float] = None,\n", " range_penalty_lambda: float = .1,\n", - " allowed_range: tuple[float, float] = (0, 1)):\n", + " allowed_range: Tuple[float, float] = (0, 1)):\n", " if initial_image is None:\n", " initial_image = torch.rand_like(image)\n", " super().__init__(image, optimized_metric, reference_metric,\n", diff --git a/noxfile.py b/noxfile.py index 111564db..58bc0d91 100644 --- a/noxfile.py +++ b/noxfile.py @@ -1,13 +1,11 @@ import nox - @nox.session(name="lint") def lint(session): # run linters session.install("ruff") session.run("ruff", "check", "--ignore", "D") - @nox.session(name="tests", python=["3.10", "3.11", "3.12"]) def tests(session): # run tests diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index 1b7f4621..a62bb3da 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,6 +1,10 @@ -from . import data, metric, tools from . import simulate as simul from . import synthesize as synth -from .tools.data import load_images, to_numpy -from .tools.display import animshow, imshow, pyrshow +from . import metric +from . import tools +from . import data + +from .tools.display import imshow, animshow, pyrshow +from .tools.data import to_numpy, load_images + from .version import version as __version__ diff --git a/src/plenoptic/data/__init__.py b/src/plenoptic/data/__init__.py index fd974a06..b6527ec8 100644 --- a/src/plenoptic/data/__init__.py +++ b/src/plenoptic/data/__init__.py @@ -1,38 +1,28 @@ -import torch - from . import data_utils -from .fetch import DOWNLOADABLE_FILES, fetch_data - -__all__ = [ - "einstein", - "curie", - "parrot", - "reptile_skin", - "color_wheel", - "fetch_data", - "DOWNLOADABLE_FILES", -] - +from .fetch import fetch_data, DOWNLOADABLE_FILES +import torch +__all__ = ['einstein', 'curie', 'parrot', 'reptile_skin', + 'color_wheel', 'fetch_data', 'DOWNLOADABLE_FILES'] def __dir__(): return __all__ def einstein() -> torch.Tensor: - return data_utils.get("einstein") + return data_utils.get('einstein') def curie() -> torch.Tensor: - return data_utils.get("curie") + return data_utils.get('curie') def parrot(as_gray: bool = False) -> torch.Tensor: - return data_utils.get("parrot", as_gray=as_gray) + return data_utils.get('parrot', as_gray=as_gray) def reptile_skin() -> torch.Tensor: - return data_utils.get("reptile_skin") + return data_utils.get('reptile_skin') def color_wheel(as_gray: bool = False) -> torch.Tensor: - return data_utils.get("color_wheel", as_gray=as_gray) + return data_utils.get('color_wheel', as_gray=as_gray) diff --git a/src/plenoptic/data/data_utils.py b/src/plenoptic/data/data_utils.py index cfce7003..037baffa 100644 --- a/src/plenoptic/data/data_utils.py +++ b/src/plenoptic/data/data_utils.py @@ -1,5 +1,7 @@ from importlib import resources from importlib.abc import Traversable +from typing import Union + from ..tools.data import load_images @@ -28,18 +30,12 @@ def get_path(item_name: str) -> Traversable: This function uses glob to search for files in the current directory matching the `item_name`. It is assumed that there is only one file matching the name regardless of its extension. """ - fhs = [ - file - for file in resources.files("plenoptic.data").iterdir() - if file.stem == item_name - ] - assert ( - len(fhs) == 1 - ), f"Expected exactly one file for {item_name}, but found {len(fhs)}." + fhs = [file for file in resources.files("plenoptic.data").iterdir() if file.stem == item_name] + assert len(fhs) == 1, f"Expected exactly one file for {item_name}, but found {len(fhs)}." return fhs[0] -def get(*item_names: str, as_gray: None | bool = None): +def get(*item_names: str, as_gray: Union[None, bool] = None): """Load an image based on the item name from the package's data resources. Parameters diff --git a/src/plenoptic/data/fetch.py b/src/plenoptic/data/fetch.py index 905f99a6..3606f644 100644 --- a/src/plenoptic/data/fetch.py +++ b/src/plenoptic/data/fetch.py @@ -5,64 +5,54 @@ """ REGISTRY = { - "plenoptic-test-files.tar.gz": "a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8", - "ssim_images.tar.gz": "19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e", - "ssim_analysis.mat": "921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24", - "msssim_images.tar.gz": "a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c", - "MAD_results.tar.gz": "29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe", - "portilla_simoncelli_matlab_test_vectors.tar.gz": "83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81", - "portilla_simoncelli_test_vectors.tar.gz": "d67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb", - "portilla_simoncelli_images.tar.gz": "4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827", - "portilla_simoncelli_synthesize.npz": "9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80", - "portilla_simoncelli_synthesize_torch_v1.12.0.npz": "5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f", - "portilla_simoncelli_synthesize_gpu.npz": "324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee", - "portilla_simoncelli_scales.npz": "eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a", - "sample_images.tar.gz": "0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5", - "test_images.tar.gz": "eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554", - "tid2013.tar.gz": "bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0", - "portilla_simoncelli_test_vectors_refactor.tar.gz": "2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a", - "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": "9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47", - "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": "9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61", - "portilla_simoncelli_scales_ps-refactor.npz": "1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf", + 'plenoptic-test-files.tar.gz': 'a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8', + 'ssim_images.tar.gz': '19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e', + 'ssim_analysis.mat': '921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24', + 'msssim_images.tar.gz': 'a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c', + 'MAD_results.tar.gz': '29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe', + 'portilla_simoncelli_matlab_test_vectors.tar.gz': '83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81', + 'portilla_simoncelli_test_vectors.tar.gz': 'd67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb', + 'portilla_simoncelli_images.tar.gz': '4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827', + 'portilla_simoncelli_synthesize.npz': '9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80', + 'portilla_simoncelli_synthesize_torch_v1.12.0.npz': '5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f', + 'portilla_simoncelli_synthesize_gpu.npz': '324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee', + 'portilla_simoncelli_scales.npz': 'eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a', + 'sample_images.tar.gz': '0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5', + 'test_images.tar.gz': 'eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554', + 'tid2013.tar.gz': 'bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0', + 'portilla_simoncelli_test_vectors_refactor.tar.gz': '2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a', + 'portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz': '9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47', + 'portilla_simoncelli_synthesize_gpu_ps-refactor.npz': '9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61', + 'portilla_simoncelli_scales_ps-refactor.npz': '1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf', } OSF_TEMPLATE = "https://osf.io/{}/download" # these are all from the OSF project at https://osf.io/ts37w/. REGISTRY_URLS = { - "plenoptic-test-files.tar.gz": OSF_TEMPLATE.format("q9kn8"), - "ssim_images.tar.gz": OSF_TEMPLATE.format("j65tw"), - "ssim_analysis.mat": OSF_TEMPLATE.format("ndtc7"), - "msssim_images.tar.gz": OSF_TEMPLATE.format("5fuba"), - "MAD_results.tar.gz": OSF_TEMPLATE.format("jwcsr"), - "portilla_simoncelli_matlab_test_vectors.tar.gz": OSF_TEMPLATE.format( - "qtn5y" - ), - "portilla_simoncelli_test_vectors.tar.gz": OSF_TEMPLATE.format("8r2gq"), - "portilla_simoncelli_images.tar.gz": OSF_TEMPLATE.format("eqr3t"), - "portilla_simoncelli_synthesize.npz": OSF_TEMPLATE.format("a7p9r"), - "portilla_simoncelli_synthesize_torch_v1.12.0.npz": OSF_TEMPLATE.format( - "gbv8e" - ), - "portilla_simoncelli_synthesize_gpu.npz": OSF_TEMPLATE.format("tn4y8"), - "portilla_simoncelli_scales.npz": OSF_TEMPLATE.format("xhwv3"), - "sample_images.tar.gz": OSF_TEMPLATE.format("6drmy"), - "test_images.tar.gz": OSF_TEMPLATE.format("au3b8"), - "tid2013.tar.gz": OSF_TEMPLATE.format("uscgv"), - "portilla_simoncelli_test_vectors_refactor.tar.gz": OSF_TEMPLATE.format( - "ca7qt" - ), - "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": OSF_TEMPLATE.format( - "vmwzd" - ), - "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": OSF_TEMPLATE.format( - "mqs6y" - ), - "portilla_simoncelli_scales_ps-refactor.npz": OSF_TEMPLATE.format("nvpr4"), + 'plenoptic-test-files.tar.gz': OSF_TEMPLATE.format('q9kn8'), + 'ssim_images.tar.gz': OSF_TEMPLATE.format('j65tw'), + 'ssim_analysis.mat': OSF_TEMPLATE.format('ndtc7'), + 'msssim_images.tar.gz': OSF_TEMPLATE.format('5fuba'), + 'MAD_results.tar.gz': OSF_TEMPLATE.format('jwcsr'), + 'portilla_simoncelli_matlab_test_vectors.tar.gz': OSF_TEMPLATE.format('qtn5y'), + 'portilla_simoncelli_test_vectors.tar.gz': OSF_TEMPLATE.format('8r2gq'), + 'portilla_simoncelli_images.tar.gz': OSF_TEMPLATE.format('eqr3t'), + 'portilla_simoncelli_synthesize.npz': OSF_TEMPLATE.format('a7p9r'), + 'portilla_simoncelli_synthesize_torch_v1.12.0.npz': OSF_TEMPLATE.format('gbv8e'), + 'portilla_simoncelli_synthesize_gpu.npz': OSF_TEMPLATE.format('tn4y8'), + 'portilla_simoncelli_scales.npz': OSF_TEMPLATE.format('xhwv3'), + 'sample_images.tar.gz': OSF_TEMPLATE.format('6drmy'), + 'test_images.tar.gz': OSF_TEMPLATE.format('au3b8'), + 'tid2013.tar.gz': OSF_TEMPLATE.format('uscgv'), + 'portilla_simoncelli_test_vectors_refactor.tar.gz': OSF_TEMPLATE.format('ca7qt'), + 'portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz': OSF_TEMPLATE.format('vmwzd'), + 'portilla_simoncelli_synthesize_gpu_ps-refactor.npz': OSF_TEMPLATE.format('mqs6y'), + 'portilla_simoncelli_scales_ps-refactor.npz': OSF_TEMPLATE.format('nvpr4'), } DOWNLOADABLE_FILES = list(REGISTRY_URLS.keys()) import pathlib - +from typing import List try: import pooch except ImportError: @@ -73,7 +63,7 @@ # Use the default cache folder for the operating system # Pooch uses appdirs (https://github.com/ActiveState/appdirs) to # select an appropriate directory for the cache on each platform. - path=pooch.os_cache("plenoptic"), + path=pooch.os_cache('plenoptic'), base_url="", urls=REGISTRY_URLS, registry=REGISTRY, @@ -82,7 +72,7 @@ ) -def find_shared_directory(paths: list[pathlib.Path]) -> pathlib.Path: +def find_shared_directory(paths: List[pathlib.Path]) -> pathlib.Path: """Find directory shared by all paths.""" for dir in paths[0].parents: if all([dir in p.parents for p in paths]): @@ -102,19 +92,17 @@ def fetch_data(dataset_name: str) -> pathlib.Path: """ if retriever is None: - raise ImportError( - "Missing optional dependency 'pooch'." - " Please use pip or " - "conda to install 'pooch'." - ) - if dataset_name.endswith(".tar.gz"): + raise ImportError("Missing optional dependency 'pooch'." + " Please use pip or " + "conda to install 'pooch'.") + if dataset_name.endswith('.tar.gz'): processor = pooch.Untar() else: processor = None - fname = retriever.fetch( - dataset_name, progressbar=True, processor=processor - ) - if dataset_name.endswith(".tar.gz"): + fname = retriever.fetch(dataset_name, + progressbar=True, + processor=processor) + if dataset_name.endswith('.tar.gz'): fname = find_shared_directory([pathlib.Path(f) for f in fname]) else: fname = pathlib.Path(fname) diff --git a/src/plenoptic/metric/__init__.py b/src/plenoptic/metric/__init__.py index 5e4c47e4..6f4e6f5e 100644 --- a/src/plenoptic/metric/__init__.py +++ b/src/plenoptic/metric/__init__.py @@ -1,4 +1,4 @@ -from .classes import NLP +from .perceptual_distance import ssim, ms_ssim, nlpd, ssim_map from .model_metric import model_metric from .naive import mse -from .perceptual_distance import ms_ssim, nlpd, ssim, ssim_map +from .classes import NLP diff --git a/src/plenoptic/metric/classes.py b/src/plenoptic/metric/classes.py index 52206cde..6bc83860 100644 --- a/src/plenoptic/metric/classes.py +++ b/src/plenoptic/metric/classes.py @@ -1,5 +1,4 @@ import torch - from .perceptual_distance import normalized_laplacian_pyramid @@ -16,7 +15,6 @@ class NLP(torch.nn.Module): ``torch.sqrt(torch.mean(x-y)**2))`` as the distance metric between representations. """ - def __init__(self): super().__init__() @@ -38,16 +36,10 @@ def forward(self, image): """ if image.shape[0] > 1 or image.shape[1] > 1: - raise Exception( - "For now, this only supports batch and channel size 1" - ) + raise Exception("For now, this only supports batch and channel size 1") activations = normalized_laplacian_pyramid(image) # activations is a list of tensors, each at a different scale # (down-sampled by factors of 2). To combine these into one # vector, we need to flatten each of them and then unsqueeze so # it is 3d - return ( - torch.cat([i.flatten() for i in activations]) - .unsqueeze(0) - .unsqueeze(0) - ) + return torch.cat([i.flatten() for i in activations]).unsqueeze(0).unsqueeze(0) diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index efeb9515..f70fd003 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -1,14 +1,15 @@ -import os -import warnings - import numpy as np import torch import torch.nn.functional as F +import warnings from ..simulate.canonical_computations import LaplacianPyramid from ..simulate.canonical_computations.filters import circular_gaussian2d from ..tools.conv import same_padding +import os +import pickle + DIRNAME = os.path.dirname(__file__) @@ -36,39 +37,25 @@ def _ssim_parts(img1, img2, pad=False): these work. """ - img_ranges = torch.as_tensor( - [[img1.min(), img1.max()], [img2.min(), img2.max()]] - ) + img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) if (img_ranges > 1).any() or (img_ranges < 0).any(): - warnings.warn( - "Image range falls outside [0, 1]." - f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " - "Continuing anyway..." - ) + warnings.warn("Image range falls outside [0, 1]." + f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " + "Continuing anyway...") if not img1.ndim == img2.ndim == 4: - raise Exception( - "Input images should have four dimensions: (batch, channel, height, width)" - ) + raise Exception("Input images should have four dimensions: (batch, channel, height, width)") if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if ( - img1.shape[i] != img2.shape[i] - and img1.shape[i] != 1 - and img2.shape[i] != 1 - ): - raise Exception( - "Either img1 and img2 should have the same number of " - "elements in each dimension, or one of " - "them should be 1! But got shapes " - f"{img1.shape}, {img2.shape} instead" - ) + if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: + raise Exception("Either img1 and img2 should have the same number of " + "elements in each dimension, or one of " + "them should be 1! But got shapes " + f"{img1.shape}, {img2.shape} instead") if img1.shape[1] > 1 or img2.shape[1] > 1: - warnings.warn( - "SSIM was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches)." - ) + warnings.warn("SSIM was designed for grayscale images and here it will be computed separately for each " + "channel (so channels are treated in the same way as batches).") if img1.dtype != img2.dtype: raise ValueError("Input images must have same dtype!") @@ -92,13 +79,9 @@ def _ssim_parts(img1, img2, pad=False): def windowed_average(img): padd = 0 (n_batches, n_channels, _, _) = img.shape - img = img.reshape( - n_batches * n_channels, 1, img.shape[2], img.shape[3] - ) + img = img.reshape(n_batches * n_channels, 1, img.shape[2], img.shape[3]) img_average = F.conv2d(img, window, padding=padd) - img_average = img_average.reshape( - n_batches, n_channels, img_average.shape[2], img_average.shape[3] - ) + img_average = img_average.reshape(n_batches, n_channels, img_average.shape[2], img_average.shape[3]) return img_average mu1 = windowed_average(img1) @@ -112,20 +95,18 @@ def windowed_average(img): sigma2_sq = windowed_average(img2 * img2) - mu2_sq sigma12 = windowed_average(img1 * img2) - mu1_mu2 - C1 = 0.01**2 - C2 = 0.03**2 + C1 = 0.01 ** 2 + C2 = 0.03 ** 2 # SSIM is the product of a luminance component, a contrast component, and a # structure component. The contrast-structure component has to be separated # when computing MS-SSIM. luminance_map = (2 * mu1_mu2 + C1) / (mu1_sq + mu2_sq + C1) - contrast_structure_map = (2.0 * sigma12 + C2) / ( - sigma1_sq + sigma2_sq + C2 - ) + contrast_structure_map = (2.0 * sigma12 + C2) / (sigma1_sq + sigma2_sq + C2) map_ssim = luminance_map * contrast_structure_map # the weight used for stability - weight = torch.log((1 + sigma1_sq / C2) * (1 + sigma2_sq / C2)) + weight = torch.log((1 + sigma1_sq/C2) * (1 + sigma2_sq/C2)) return map_ssim, contrast_structure_map, weight @@ -209,14 +190,12 @@ def ssim(img1, img2, weighted=False, pad=False): if not weighted: mssim = map_ssim.mean((-1, -2)) else: - mssim = (map_ssim * weight).sum((-1, -2)) / weight.sum((-1, -2)) + mssim = (map_ssim*weight).sum((-1, -2)) / weight.sum((-1, -2)) if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn( - "SSIM uses 11x11 convolutional kernel, but the height and/or " - "the width of the input image is smaller than 11, so the " - "kernel size is set to be the minimum of these two numbers." - ) + warnings.warn("SSIM uses 11x11 convolutional kernel, but the height and/or " + "the width of the input image is smaller than 11, so the " + "kernel size is set to be the minimum of these two numbers.") return mssim @@ -278,11 +257,9 @@ def ssim_map(img1, img2): """ if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn( - "SSIM uses 11x11 convolutional kernel, but the height and/or " - "the width of the input image is smaller than 11, so the " - "kernel size is set to be the minimum of these two numbers." - ) + warnings.warn("SSIM uses 11x11 convolutional kernel, but the height and/or " + "the width of the input image is smaller than 11, so the " + "kernel size is set to be the minimum of these two numbers.") return _ssim_parts(img1, img2)[0] @@ -349,30 +326,24 @@ def ms_ssim(img1, img2, power_factors=None): power_factors = [0.0448, 0.2856, 0.3001, 0.2363, 0.1333] def downsample(img): - img = F.pad( - img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate" - ) + img = F.pad(img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate") img = F.avg_pool2d(img, kernel_size=2) return img msssim = 1 for i in range(len(power_factors) - 1): _, contrast_structure_map, _ = _ssim_parts(img1, img2) - msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow( - power_factors[i] - ) + msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow(power_factors[i]) img1 = downsample(img1) img2 = downsample(img2) map_ssim, _, _ = _ssim_parts(img1, img2) msssim *= F.relu(map_ssim.mean((-1, -2))).pow(power_factors[-1]) if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn( - "SSIM uses 11x11 convolutional kernel, but for some scales " - "of the input image, the height and/or the width is smaller " - "than 11, so the kernel size in SSIM is set to be the " - "minimum of these two numbers for these scales." - ) + warnings.warn("SSIM uses 11x11 convolutional kernel, but for some scales " + "of the input image, the height and/or the width is smaller " + "than 11, so the kernel size in SSIM is set to be the " + "minimum of these two numbers for these scales.") return msssim @@ -395,8 +366,8 @@ def normalized_laplacian_pyramid(img): (_, channel, height, width) = img.size() N_scales = 6 - spatialpooling_filters = np.load(os.path.join(DIRNAME, "DN_filts.npy")) - sigmas = np.load(os.path.join(DIRNAME, "DN_sigmas.npy")) + spatialpooling_filters = np.load(os.path.join(DIRNAME, 'DN_filts.npy')) + sigmas = np.load(os.path.join(DIRNAME, 'DN_sigmas.npy')) L = LaplacianPyramid(n_scales=N_scales, scale_filter=True) laplacian_activations = L.forward(img) @@ -404,18 +375,10 @@ def normalized_laplacian_pyramid(img): padd = 2 normalized_laplacian_activations = [] for N_b in range(0, N_scales): - filt = torch.as_tensor( - spatialpooling_filters[N_b], dtype=torch.float32, device=img.device - ).repeat(channel, 1, 1, 1) - filtered_activations = F.conv2d( - torch.abs(laplacian_activations[N_b]), - filt, - padding=padd, - groups=channel, - ) - normalized_laplacian_activations.append( - laplacian_activations[N_b] / (sigmas[N_b] + filtered_activations) - ) + filt = torch.as_tensor(spatialpooling_filters[N_b], dtype=torch.float32, + device=img.device).repeat(channel, 1, 1, 1) + filtered_activations = F.conv2d(torch.abs(laplacian_activations[N_b]), filt, padding=padd, groups=channel) + normalized_laplacian_activations.append(laplacian_activations[N_b] / (sigmas[N_b] + filtered_activations)) return normalized_laplacian_activations @@ -462,47 +425,31 @@ def nlpd(img1, img2): """ if not img1.ndim == img2.ndim == 4: - raise Exception( - "Input images should have four dimensions: (batch, channel, height, width)" - ) + raise Exception("Input images should have four dimensions: (batch, channel, height, width)") if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if ( - img1.shape[i] != img2.shape[i] - and img1.shape[i] != 1 - and img2.shape[i] != 1 - ): - raise Exception( - "Either img1 and img2 should have the same number of " - "elements in each dimension, or one of " - "them should be 1! But got shapes " - f"{img1.shape}, {img2.shape} instead" - ) + if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: + raise Exception("Either img1 and img2 should have the same number of " + "elements in each dimension, or one of " + "them should be 1! But got shapes " + f"{img1.shape}, {img2.shape} instead") if img1.shape[1] > 1 or img2.shape[1] > 1: - warnings.warn( - "NLPD was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches)." - ) - - img_ranges = torch.as_tensor( - [[img1.min(), img1.max()], [img2.min(), img2.max()]] - ) + warnings.warn("NLPD was designed for grayscale images and here it will be computed separately for each " + "channel (so channels are treated in the same way as batches).") + + img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) if (img_ranges > 1).any() or (img_ranges < 0).any(): - warnings.warn( - "Image range falls outside [0, 1]." - f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " - "Continuing anyway..." - ) - + warnings.warn("Image range falls outside [0, 1]." + f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " + "Continuing anyway...") + y1 = normalized_laplacian_pyramid(img1) y2 = normalized_laplacian_pyramid(img2) epsilon = 1e-10 # for optimization purpose (stabilizing the gradient around zero) dist = [] for i in range(6): - dist.append( - torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon) - ) + dist.append(torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon)) return torch.stack(dist).mean(dim=0) diff --git a/src/plenoptic/simulate/__init__.py b/src/plenoptic/simulate/__init__.py index c82eb526..9659b0ce 100644 --- a/src/plenoptic/simulate/__init__.py +++ b/src/plenoptic/simulate/__init__.py @@ -1,2 +1,2 @@ -from .canonical_computations import * from .models import * +from .canonical_computations import * diff --git a/src/plenoptic/simulate/canonical_computations/__init__.py b/src/plenoptic/simulate/canonical_computations/__init__.py index 49d69cc4..b51ca84b 100644 --- a/src/plenoptic/simulate/canonical_computations/__init__.py +++ b/src/plenoptic/simulate/canonical_computations/__init__.py @@ -1,4 +1,4 @@ -from .filters import * from .laplacian_pyramid import LaplacianPyramid -from .non_linearities import * from .steerable_pyramid_freq import SteerablePyramidFreq +from .non_linearities import * +from .filters import * diff --git a/src/plenoptic/simulate/canonical_computations/filters.py b/src/plenoptic/simulate/canonical_computations/filters.py index d45c4568..098d7a79 100644 --- a/src/plenoptic/simulate/canonical_computations/filters.py +++ b/src/plenoptic/simulate/canonical_computations/filters.py @@ -1,10 +1,13 @@ +from typing import Union, Tuple + import torch from torch import Tensor +from warnings import warn __all__ = ["gaussian1d", "circular_gaussian2d"] -def gaussian1d(kernel_size: int = 11, std: float | Tensor = 1.5) -> Tensor: +def gaussian1d(kernel_size: int = 11, std: Union[float, Tensor] = 1.5) -> Tensor: """Normalized 1D Gaussian. 1d Gaussian of size `kernel_size`, centered half-way, with variable std @@ -32,14 +35,14 @@ def gaussian1d(kernel_size: int = 11, std: float | Tensor = 1.5) -> Tensor: x = torch.arange(kernel_size).to(device) mu = kernel_size // 2 - gauss = torch.exp(-((x - mu) ** 2) / (2 * std**2)) + gauss = torch.exp(-((x - mu) ** 2) / (2 * std ** 2)) filt = gauss / gauss.sum() # normalize return filt def circular_gaussian2d( - kernel_size: int | tuple[int, int], - std: float | Tensor, + kernel_size: Union[int, Tuple[int, int]], + std: Union[float, Tensor], out_channels: int = 1, ) -> Tensor: """Creates normalized, centered circular 2D gaussian tensor with which to convolve. @@ -72,23 +75,17 @@ def circular_gaussian2d( assert out_channels >= 1, "number of filters must be positive integer" assert torch.all(std > 0.0), "stdev must be positive" assert len(std) == out_channels, "Number of stds must equal out_channels" - origin = torch.as_tensor( - ((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0) - ) + origin = torch.as_tensor(((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0)) origin = origin.to(device) - shift_y = ( - torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] - ) # height - shift_x = ( - torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] - ) # width + shift_y = torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] # height + shift_x = torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] # width (xramp, yramp) = torch.meshgrid(shift_y, shift_x) - log_filt = (xramp**2) + (yramp**2) + log_filt = ((xramp ** 2) + (yramp ** 2)) log_filt = log_filt.repeat(out_channels, 1, 1, 1) # 4D - log_filt = log_filt / (-2.0 * std**2).view(out_channels, 1, 1, 1) + log_filt = log_filt / (-2. * std ** 2).view(out_channels, 1, 1, 1) filt = torch.exp(log_filt) filt = filt / torch.sum(filt, dim=[1, 2, 3], keepdim=True) # normalize diff --git a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py index 53fac227..d51e3955 100644 --- a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py +++ b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py @@ -1,12 +1,11 @@ import torch import torch.nn as nn - from ...tools.conv import blur_downsample, upsample_blur class LaplacianPyramid(nn.Module): """Laplacian Pyramid in Torch. - + The Laplacian pyramid [1]_ is a multiscale image representation. It decomposes the image by computing the local mean using Gaussian blurring filters and substracting it from the image and repeating this operation on diff --git a/src/plenoptic/simulate/canonical_computations/non_linearities.py b/src/plenoptic/simulate/canonical_computations/non_linearities.py index 839918c7..fec6a59c 100644 --- a/src/plenoptic/simulate/canonical_computations/non_linearities.py +++ b/src/plenoptic/simulate/canonical_computations/non_linearities.py @@ -1,7 +1,6 @@ import torch - from ...tools.conv import blur_downsample, upsample_blur -from ...tools.signal import polar_to_rectangular, rectangular_to_polar +from ...tools.signal import rectangular_to_polar, polar_to_rectangular def rectangular_to_polar_dict(coeff_dict, residuals=False): @@ -29,12 +28,12 @@ def rectangular_to_polar_dict(coeff_dict, residuals=False): state = {} for key in coeff_dict.keys(): # ignore residuals - if isinstance(key, tuple) or not key.startswith("residual"): + if isinstance(key, tuple) or not key.startswith('residual'): energy[key], state[key] = rectangular_to_polar(coeff_dict[key]) if residuals: - energy["residual_lowpass"] = coeff_dict["residual_lowpass"] - energy["residual_highpass"] = coeff_dict["residual_highpass"] + energy['residual_lowpass'] = coeff_dict['residual_lowpass'] + energy['residual_highpass'] = coeff_dict['residual_highpass'] return energy, state @@ -64,12 +63,12 @@ def polar_to_rectangular_dict(energy, state, residuals=True): for key in energy.keys(): # ignore residuals - if isinstance(key, tuple) or not key.startswith("residual"): + if isinstance(key, tuple) or not key.startswith('residual'): coeff_dict[key] = polar_to_rectangular(energy[key], state[key]) if residuals: - coeff_dict["residual_lowpass"] = energy["residual_lowpass"] - coeff_dict["residual_highpass"] = energy["residual_highpass"] + coeff_dict['residual_lowpass'] = energy['residual_lowpass'] + coeff_dict['residual_highpass'] = energy['residual_highpass'] return coeff_dict @@ -112,7 +111,7 @@ def local_gain_control(x, epsilon=1e-8): # these could be parameters, but no use case so far p = 2.0 - norm = blur_downsample(torch.abs(x**p)).pow(1 / p) + norm = blur_downsample(torch.abs(x ** p)).pow(1 / p) odd = torch.as_tensor(x.shape)[2:4] % 2 direction = x / (upsample_blur(norm, odd) + epsilon) @@ -191,12 +190,12 @@ def local_gain_control_dict(coeff_dict, residuals=True): state = {} for key in coeff_dict.keys(): - if isinstance(key, tuple) or not key.startswith("residual"): + if isinstance(key, tuple) or not key.startswith('residual'): energy[key], state[key] = local_gain_control(coeff_dict[key]) if residuals: - energy["residual_lowpass"] = coeff_dict["residual_lowpass"] - energy["residual_highpass"] = coeff_dict["residual_highpass"] + energy['residual_lowpass'] = coeff_dict['residual_lowpass'] + energy['residual_highpass'] = coeff_dict['residual_highpass'] return energy, state @@ -231,11 +230,11 @@ def local_gain_release_dict(energy, state, residuals=True): coeff_dict = {} for key in energy.keys(): - if isinstance(key, tuple) or not key.startswith("residual"): + if isinstance(key, tuple) or not key.startswith('residual'): coeff_dict[key] = local_gain_release(energy[key], state[key]) if residuals: - coeff_dict["residual_lowpass"] = energy["residual_lowpass"] - coeff_dict["residual_highpass"] = energy["residual_highpass"] + coeff_dict['residual_lowpass'] = energy['residual_lowpass'] + coeff_dict['residual_highpass'] = energy['residual_highpass'] return coeff_dict diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 4b8fc189..5a6cf090 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -5,24 +5,23 @@ """ import warnings from collections import OrderedDict -from typing import Literal, Union +from typing import List, Optional, Tuple, Union import numpy as np import torch import torch.fft as fft import torch.nn as nn from einops import rearrange -from numpy.typing import NDArray from scipy.special import factorial from torch import Tensor +from typing_extensions import Literal +from numpy.typing import NDArray from ...tools.signal import interpolate1d, raised_cosine, steer complex_types = [torch.cdouble, torch.cfloat] SCALES_TYPE = Union[int, Literal["residual_lowpass", "residual_highpass"]] -KEYS_TYPE = Union[ - tuple[int, int], Literal["residual_lowpass", "residual_highpass"] -] +KEYS_TYPE = Union[Tuple[int, int], Literal["residual_lowpass", "residual_highpass"]] class SteerablePyramidFreq(nn.Module): @@ -96,14 +95,15 @@ class SteerablePyramidFreq(nn.Module): def __init__( self, - image_shape: tuple[int, int], - height: Literal["auto"] | int = "auto", + image_shape: Tuple[int, int], + height: Union[Literal["auto"], int] = "auto", order: int = 3, twidth: int = 1, is_complex: bool = False, downsample: bool = True, tight_frame: bool = False, ): + super().__init__() self.pyr_size = OrderedDict() @@ -111,9 +111,7 @@ def __init__( self.image_shape = image_shape if (self.image_shape[0] % 2 != 0) or (self.image_shape[1] % 2 != 0): - warnings.warn( - "Reconstruction will not be perfect with odd-sized images" - ) + warnings.warn("Reconstruction will not be perfect with odd-sized images") self.is_complex = is_complex self.downsample = downsample @@ -131,16 +129,11 @@ def __init__( ) self.alpha = (self.Xcosn + np.pi) % (2 * np.pi) - np.pi - max_ht = ( - np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) - - 2 - ) + max_ht = np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) - 2 if height == "auto": self.num_scales = int(max_ht) elif height > max_ht: - raise ValueError( - "Cannot build pyramid higher than %d levels." % (max_ht) - ) + raise ValueError("Cannot build pyramid higher than %d levels." % (max_ht)) else: self.num_scales = int(height) @@ -158,8 +151,7 @@ def __init__( ctr = np.ceil((np.array(dims) + 0.5) / 2).astype(int) (xramp, yramp) = np.meshgrid( - np.linspace(-1, 1, dims[1] + 1)[:-1], - np.linspace(-1, 1, dims[0] + 1)[:-1], + np.linspace(-1, 1, dims[1] + 1)[:-1], np.linspace(-1, 1, dims[0] + 1)[:-1] ) self.angle = np.arctan2(yramp, xramp) @@ -168,9 +160,7 @@ def __init__( self.log_rad = np.log2(log_rad) # radial transition function (a raised cosine in log-frequency): - self.Xrcos, Yrcos = raised_cosine( - twidth, (-twidth / 2.0), np.array([0, 1]) - ) + self.Xrcos, Yrcos = raised_cosine(twidth, (-twidth / 2.0), np.array([0, 1])) self.Yrcos = np.sqrt(Yrcos) self.YIrcos = np.sqrt(1.0 - self.Yrcos**2) @@ -178,8 +168,9 @@ def __init__( # create low and high masks lo0mask = interpolate1d(self.log_rad, self.YIrcos, self.Xrcos) hi0mask = interpolate1d(self.log_rad, self.Yrcos, self.Xrcos) - self.register_buffer("lo0mask", torch.as_tensor(lo0mask).unsqueeze(0)) - self.register_buffer("hi0mask", torch.as_tensor(hi0mask).unsqueeze(0)) + self.register_buffer('lo0mask', torch.as_tensor(lo0mask).unsqueeze(0)) + self.register_buffer('hi0mask', torch.as_tensor(hi0mask).unsqueeze(0)) + # need a mock image to down-sample so that we correctly # construct the differently-sized masks @@ -208,10 +199,7 @@ def __init__( const = ( (2 ** (2 * self.order)) * (factorial(self.order, exact=True) ** 2) - / float( - self.num_orientations - * factorial(2 * self.order, exact=True) - ) + / float(self.num_orientations * factorial(2 * self.order, exact=True)) ) if self.is_complex: @@ -221,50 +209,32 @@ def __init__( * (np.cos(self.Xcosn) ** self.order) * (np.abs(self.alpha) < np.pi / 2.0).astype(int) ) - Ycosn_recon = ( - np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order - ) + Ycosn_recon = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order else: - Ycosn_forward = ( - np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order - ) + Ycosn_forward = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order Ycosn_recon = Ycosn_forward himask = interpolate1d(log_rad, self.Yrcos, Xrcos) - self.register_buffer( - f"_himasks_scale_{i}", torch.as_tensor(himask).unsqueeze(0) - ) + self.register_buffer(f'_himasks_scale_{i}', torch.as_tensor(himask).unsqueeze(0)) anglemasks = [] anglemasks_recon = [] for b in range(self.num_orientations): anglemask = interpolate1d( - angle, - Ycosn_forward, - self.Xcosn + np.pi * b / self.num_orientations, + angle, Ycosn_forward, self.Xcosn + np.pi * b / self.num_orientations ) anglemask_recon = interpolate1d( - angle, - Ycosn_recon, - self.Xcosn + np.pi * b / self.num_orientations, + angle, Ycosn_recon, self.Xcosn + np.pi * b / self.num_orientations ) anglemasks.append(torch.as_tensor(anglemask).unsqueeze(0)) - anglemasks_recon.append( - torch.as_tensor(anglemask_recon).unsqueeze(0) - ) + anglemasks_recon.append(torch.as_tensor(anglemask_recon).unsqueeze(0)) - self.register_buffer( - f"_anglemasks_scale_{i}", torch.cat(anglemasks) - ) - self.register_buffer( - f"_anglemasks_recon_scale_{i}", torch.cat(anglemasks_recon) - ) + self.register_buffer(f'_anglemasks_scale_{i}', torch.cat(anglemasks)) + self.register_buffer(f'_anglemasks_recon_scale_{i}', torch.cat(anglemasks_recon)) if not self.downsample: lomask = interpolate1d(log_rad, self.YIrcos, Xrcos) - self.register_buffer( - f"_lomasks_scale_{i}", torch.as_tensor(lomask).unsqueeze(0) - ) + self.register_buffer(f'_lomasks_scale_{i}', torch.as_tensor(lomask).unsqueeze(0)) self._loindices.append([np.array([0, 0]), dims]) lodft = lodft * lomask @@ -283,9 +253,7 @@ def __init__( angle = angle[lostart[0] : loend[0], lostart[1] : loend[1]] lomask = interpolate1d(log_rad, self.YIrcos, Xrcos) - self.register_buffer( - f"_lomasks_scale_{i}", torch.as_tensor(lomask).unsqueeze(0) - ) + self.register_buffer(f'_lomasks_scale_{i}', torch.as_tensor(lomask).unsqueeze(0)) # subsampling lodft = lodft[lostart[0] : loend[0], lostart[1] : loend[1]] # convolution in spatial domain @@ -297,7 +265,7 @@ def __init__( def forward( self, x: Tensor, - scales: list[SCALES_TYPE] | None = None, + scales: Optional[List[SCALES_TYPE]] = None, ) -> OrderedDict: r"""Generate the steerable pyramid coefficients for an image @@ -337,9 +305,7 @@ def forward( # x is a torch tensor batch of images of size (batch, channel, height, # width) - assert ( - len(x.shape) == 4 - ), "Input must be batch of images of shape BxCxHxW" + assert len(x.shape) == 4, "Input must be batch of images of shape BxCxHxW" imdft = fft.fft2(x, dim=(-2, -1), norm=self.fft_norm) imdft = fft.fftshift(imdft) @@ -356,18 +322,20 @@ def forward( lodft = imdft * lo0mask for i in range(self.num_scales): + if i in scales: # high-pass mask is selected based on the current scale - himask = getattr(self, f"_himasks_scale_{i}") + himask = getattr(self, f'_himasks_scale_{i}') # compute filter output at each orientation for b in range(self.num_orientations): + # band pass filtering is done in the fourier space as multiplying by the fft of a gaussian derivative. # The oriented dft is computed as a product of the fft of the low-passed component, # the precomputed anglemask (specifies orientation), and the precomputed hipass mask (creating a bandpass filter) # the complex_const variable comes from the Fourier transform of a gaussian derivative. # Based on the order of the gaussian, this constant changes. - anglemask = getattr(self, f"_anglemasks_scale_{i}")[b] + anglemask = getattr(self, f'_anglemasks_scale_{i}')[b] complex_const = np.power(complex(0, -1), self.order) banddft = complex_const * lodft * anglemask * himask @@ -380,6 +348,7 @@ def forward( if not self.is_complex: pyr_coeffs[(i, b)] = band.real else: + # Because the input signal is real, to maintain a tight frame # if the complex pyramid is used, magnitudes need to be divided by sqrt(2) # because energy is doubled. @@ -392,7 +361,7 @@ def forward( if not self.downsample: # no subsampling of angle and rad # just use lo0mask - lomask = getattr(self, f"_lomasks_scale_{i}") + lomask = getattr(self, f'_lomasks_scale_{i}') lodft = lodft * lomask # because we don't subsample here, if we are not using orthonormalization that @@ -409,11 +378,9 @@ def forward( angle = angle[lostart[0] : loend[0], lostart[1] : loend[1]] # subsampling of the dft for next scale - lodft = lodft[ - :, :, lostart[0] : loend[0], lostart[1] : loend[1] - ] + lodft = lodft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] # low-pass filter mask is selected - lomask = getattr(self, f"_lomasks_scale_{i}") + lomask = getattr(self, f'_lomasks_scale_{i}') # again multiply dft by subsampled mask (convolution in spatial domain) lodft = lodft * lomask @@ -430,7 +397,7 @@ def forward( @staticmethod def convert_pyr_to_tensor( pyr_coeffs: OrderedDict, split_complex: bool = False - ) -> tuple[Tensor, tuple[int, bool, list[KEYS_TYPE]]]: + ) -> Tuple[Tensor, Tuple[int, bool, List[KEYS_TYPE]]]: r"""Convert coefficient dictionary to a tensor. The output tensor has shape (batch, channel, height, width) and is @@ -506,10 +473,10 @@ def convert_pyr_to_tensor( try: pyr_tensor = torch.cat(coeff_list, dim=1) pyr_info = tuple([num_channels, split_complex, pyr_keys]) - except RuntimeError: + except RuntimeError as e: raise Exception( - """feature maps could not be concatenated into tensor. - Check that you are using coefficients that are not downsampled across scales. + """feature maps could not be concatenated into tensor. + Check that you are using coefficients that are not downsampled across scales. This is done with the 'downsample=False' argument for the pyramid""" ) @@ -520,7 +487,7 @@ def convert_tensor_to_pyr( pyr_tensor: Tensor, num_channels: int, split_complex: bool, - pyr_keys: list[KEYS_TYPE], + pyr_keys: List[KEYS_TYPE], ) -> OrderedDict: r"""Convert pyramid coefficient tensor to dictionary format. @@ -571,8 +538,7 @@ def convert_tensor_to_pyr( if split_complex: band = torch.view_as_complex( rearrange( - pyr_tensor[:, i : i + 2, ...], - "b c h w -> b h w c", + pyr_tensor[:, i : i + 2, ...], "b c h w -> b h w c" ) .unsqueeze(1) .contiguous() @@ -589,8 +555,8 @@ def convert_tensor_to_pyr( return pyr_coeffs def _recon_levels_check( - self, levels: Literal["all"] | list[SCALES_TYPE] - ) -> list[SCALES_TYPE]: + self, levels: Union[Literal["all"], List[SCALES_TYPE]] + ) -> List[SCALES_TYPE]: r"""Check whether levels arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), @@ -615,9 +581,7 @@ def _recon_levels_check( """ if isinstance(levels, str): if levels != "all": - raise TypeError( - f"levels must be a list of levels or the string 'all' but got {levels}" - ) + raise TypeError(f"levels must be a list of levels or the string 'all' but got {levels}") levels = ( ["residual_highpass"] + list(range(self.num_scales)) @@ -625,18 +589,15 @@ def _recon_levels_check( ) else: if not hasattr(levels, "__iter__"): - raise TypeError( - f"levels must be a list of levels or the string 'all' but got {levels}" - ) + raise TypeError(f"levels must be a list of levels or the string 'all' but got {levels}") levs_nums = np.array( [int(i) for i in levels if isinstance(i, int)] ) + assert (levs_nums >= 0).all(), "Level numbers must be non-negative." assert ( - levs_nums >= 0 - ).all(), "Level numbers must be non-negative." - assert (levs_nums < self.num_scales).all(), ( - "Level numbers must be in the range [0, %d]" - % (self.num_scales - 1) + levs_nums < self.num_scales + ).all(), "Level numbers must be in the range [0, %d]" % ( + self.num_scales - 1 ) levs_tmp = list(np.sort(levs_nums)) # we want smallest first if "residual_highpass" in levels: @@ -659,8 +620,8 @@ def _recon_levels_check( return levels def _recon_bands_check( - self, bands: Literal["all"] | list[int] - ) -> list[int]: + self, bands: Union[Literal["all"], List[int]] + ) -> List[int]: """Check whether bands arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies @@ -683,31 +644,26 @@ def _recon_bands_check( """ if isinstance(bands, str): if bands != "all": - raise TypeError( - f"bands must be a list of ints or the string 'all' but got {bands}" - ) + raise TypeError(f"bands must be a list of ints or the string 'all' but got {bands}") bands = np.arange(self.num_orientations) else: if not hasattr(bands, "__iter__"): - raise TypeError( - f"bands must be a list of ints or the string 'all' but got {bands}" - ) + raise TypeError(f"bands must be a list of ints or the string 'all' but got {bands}") bands: NDArray = np.array(bands, ndmin=1) + assert (bands >= 0).all(), "Error: band numbers must be larger than 0." assert ( - bands >= 0 - ).all(), "Error: band numbers must be larger than 0." - assert (bands < self.num_orientations).all(), ( - "Error: band numbers must be in the range [0, %d]" - % (self.num_orientations - 1) + bands < self.num_orientations + ).all(), "Error: band numbers must be in the range [0, %d]" % ( + self.num_orientations - 1 ) return list(bands) def _recon_keys( self, - levels: Literal["all"] | list[SCALES_TYPE], - bands: Literal["all"] | list[int], - max_orientations: int | None = None, - ) -> list[KEYS_TYPE]: + levels: Union[Literal["all"], List[SCALES_TYPE]], + bands: Union[Literal["all"], List[int]], + max_orientations: Optional[int] = None, + ) -> List[KEYS_TYPE]: """Make a list of all the relevant keys from `pyr_coeffs` to use in pyramid reconstruction When reconstructing the input image (i.e., when calling `recon_pyr()`), @@ -745,9 +701,11 @@ def _recon_keys( for i in bands: if i >= max_orientations: warnings.warn( - "You wanted band %d in the reconstruction but max_orientation" - " is %d, so we're ignoring that band" - % (i, max_orientations) + ( + "You wanted band %d in the reconstruction but max_orientation" + " is %d, so we're ignoring that band" + % (i, max_orientations) + ) ) bands = [i for i in bands if i < max_orientations] recon_keys = [] @@ -764,8 +722,8 @@ def _recon_keys( def recon_pyr( self, pyr_coeffs: OrderedDict, - levels: Literal["all"] | list[SCALES_TYPE] = "all", - bands: Literal["all"] | list[int] = "all", + levels: Union[Literal["all"], List[SCALES_TYPE]] = "all", + bands: Union[Literal["all"], List[int]] = "all", ) -> Tensor: """Reconstruct the image or batch of images, optionally using subset of pyramid coefficients. @@ -830,9 +788,7 @@ def recon_pyr( # generate highpass residual Reconstruction if "residual_highpass" in recon_keys: hidft = fft.fft2( - pyr_coeffs["residual_highpass"], - dim=(-2, -1), - norm=self.fft_norm, + pyr_coeffs["residual_highpass"], dim=(-2, -1), norm=self.fft_norm ) hidft = fft.fftshift(hidft) @@ -845,9 +801,7 @@ def recon_pyr( # get output reconstruction by inverting the fft reconstruction = fft.ifftshift(outdft) - reconstruction = fft.ifft2( - reconstruction, dim=(-2, -1), norm=self.fft_norm - ) + reconstruction = fft.ifft2(reconstruction, dim=(-2, -1), norm=self.fft_norm) # get real part of reconstruction (if complex) reconstruction = reconstruction.real @@ -855,7 +809,7 @@ def recon_pyr( return reconstruction def _recon_levels( - self, pyr_coeffs: OrderedDict, recon_keys: list[KEYS_TYPE], scale: int + self, pyr_coeffs: OrderedDict, recon_keys: List[KEYS_TYPE], scale: int ) -> Tensor: """Recursive function used to build the reconstruction. Called by recon_pyr @@ -884,14 +838,14 @@ def _recon_levels( if scale == self.num_scales: if "residual_lowpass" in recon_keys: lodft = fft.fft2( - pyr_coeffs["residual_lowpass"], - dim=(-2, -1), - norm=self.fft_norm, + pyr_coeffs["residual_lowpass"], dim=(-2, -1), norm=self.fft_norm ) lodft = fft.fftshift(lodft) else: lodft = fft.fft2( - torch.zeros_like(pyr_coeffs["residual_lowpass"]), + torch.zeros_like( + pyr_coeffs["residual_lowpass"] + ), dim=(-2, -1), norm=self.fft_norm, ) @@ -900,14 +854,12 @@ def _recon_levels( # Reconstruct from orientation bands # update himask - himask = getattr(self, f"_himasks_scale_{scale}") + himask = getattr(self, f'_himasks_scale_{scale}') orientdft = torch.zeros_like(pyr_coeffs[(scale, 0)]) for b in range(self.num_orientations): if (scale, b) in recon_keys: - anglemask = getattr(self, f"_anglemasks_recon_scale_{scale}")[ - b - ] + anglemask = getattr(self, f'_anglemasks_recon_scale_{scale}')[b] coeffs = pyr_coeffs[(scale, b)] if self.tight_frame and self.is_complex: coeffs = coeffs * np.sqrt(2) @@ -923,7 +875,7 @@ def _recon_levels( lostart, loend = self._loindices[scale] # create lowpass mask - lomask = getattr(self, f"_lomasks_scale_{scale}") + lomask = getattr(self, f'_lomasks_scale_{scale}') # Recursively reconstruct by going to the next scale reslevdft = self._recon_levels(pyr_coeffs, recon_keys, scale + 1) @@ -931,24 +883,17 @@ def _recon_levels( if (not self.tight_frame) and (not self.downsample): reslevdft = reslevdft / 2 # create output for reconstruction result - resdft = torch.zeros_like( - pyr_coeffs[(scale, 0)], dtype=torch.complex64 - ) + resdft = torch.zeros_like(pyr_coeffs[(scale, 0)], dtype=torch.complex64) # place upsample and convolve lowpass component - resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = ( - reslevdft * lomask - ) + resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = reslevdft * lomask recondft = resdft + orientdft # add orientation interpolated and added images to the lowpass image return recondft def steer_coeffs( - self, - pyr_coeffs: OrderedDict, - angles: list[float], - even_phase: bool = True, - ) -> tuple[dict, dict]: + self, pyr_coeffs: OrderedDict, angles: List[float], even_phase: bool = True + ) -> Tuple[dict, dict]: """Steer pyramid coefficients to the specified angles This allows you to have filters that have the Gaussian derivative order specified in diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 802de615..7d1050dc 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -10,25 +10,22 @@ .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ -from collections import OrderedDict -from collections.abc import Callable -from warnings import warn +from typing import Tuple, Union, Callable import torch import torch.nn as nn import torch.nn.functional as F from torch import Tensor +from .naive import Gaussian, CenterSurround from ...tools.display import imshow from ...tools.signal import make_disk -from .naive import CenterSurround, Gaussian +from collections import OrderedDict +from warnings import warn + -__all__ = [ - "LinearNonlinear", - "LuminanceGainControl", - "LuminanceContrastGainControl", - "OnOff", -] +__all__ = ["LinearNonlinear", "LuminanceGainControl", + "LuminanceContrastGainControl", "OnOff"] class LinearNonlinear(nn.Module): @@ -69,11 +66,12 @@ class LinearNonlinear(nn.Module): def __init__( self, - kernel_size: int | tuple[int, int], + kernel_size: Union[int, Tuple[int, int]], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", + activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -114,7 +112,7 @@ def display_filters(self, zoom=5.0, **kwargs): class LuminanceGainControl(nn.Module): - """Linear center-surround followed by luminance gain control and activation. + """ Linear center-surround followed by luminance gain control and activation. Model is described in [1]_ and [2]_. Parameters @@ -152,14 +150,14 @@ class LuminanceGainControl(nn.Module): representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ - def __init__( self, - kernel_size: int | tuple[int, int], + kernel_size: Union[int, Tuple[int, int]], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", + activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -203,25 +201,17 @@ def display_filters(self, zoom=5.0, **kwargs): dim=0, ).detach() - title = [ - "linear filt", - "luminance filt", - ] + title = ["linear filt", "luminance filt",] fig = imshow( - weights, - title=title, - col_wrap=2, - zoom=zoom, - vrange="indep0", - **kwargs, + weights, title=title, col_wrap=2, zoom=zoom, vrange="indep0", **kwargs ) return fig class LuminanceContrastGainControl(nn.Module): - """Linear center-surround followed by luminance and contrast gain control, + """ Linear center-surround followed by luminance and contrast gain control, and activation function. Model is described in [1]_ and [2]_. Parameters @@ -265,11 +255,12 @@ class LuminanceContrastGainControl(nn.Module): def __init__( self, - kernel_size: int | tuple[int, int], + kernel_size: Union[int, Tuple[int, int]], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", + activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -294,9 +285,7 @@ def forward(self, x: Tensor) -> Tensor: lum = self.luminance(x) lum_normed = linear / (1 + self.luminance_scalar * lum) - con = ( - self.contrast(lum_normed.pow(2)).sqrt() + 1e-6 - ) # avoid div by zero + con = self.contrast(lum_normed.pow(2)).sqrt() + 1E-6 # avoid div by zero con_normed = lum_normed / (1 + self.contrast_scalar * con) y = self.activation(con_normed) return y @@ -327,12 +316,7 @@ def display_filters(self, zoom=5.0, **kwargs): title = ["linear filt", "luminance filt", "contrast filt"] fig = imshow( - weights, - title=title, - col_wrap=3, - zoom=zoom, - vrange="indep0", - **kwargs, + weights, title=title, col_wrap=3, zoom=zoom, vrange="indep0", **kwargs ) return fig @@ -385,7 +369,7 @@ class OnOff(nn.Module): def __init__( self, - kernel_size: int | tuple[int, int], + kernel_size: Union[int, Tuple[int, int]], width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", @@ -393,20 +377,16 @@ def __init__( activation: Callable[[Tensor], Tensor] = F.softplus, apply_mask: bool = False, cache_filt: bool = False, + ): super().__init__() if isinstance(kernel_size, int): kernel_size = (kernel_size, kernel_size) if pretrained: - assert kernel_size == ( - 31, - 31, - ), "pretrained model has kernel_size (31, 31)" + assert kernel_size == (31, 31), "pretrained model has kernel_size (31, 31)" if cache_filt is False: - warn( - "pretrained is True but cache_filt is False. Set cache_filt to " - "True for efficiency unless you are fine-tuning." - ) + warn("pretrained is True but cache_filt is False. Set cache_filt to " + "True for efficiency unless you are fine-tuning.") self.center_surround = CenterSurround( kernel_size=kernel_size, @@ -419,17 +399,17 @@ def __init__( ) self.luminance = Gaussian( - kernel_size=kernel_size, - out_channels=2, - pad_mode=pad_mode, - cache_filt=cache_filt, + kernel_size=kernel_size, + out_channels=2, + pad_mode=pad_mode, + cache_filt=cache_filt, ) self.contrast = Gaussian( - kernel_size=kernel_size, - out_channels=2, - pad_mode=pad_mode, - cache_filt=cache_filt, + kernel_size=kernel_size, + out_channels=2, + pad_mode=pad_mode, + cache_filt=cache_filt, ) # init scalar values around fitted parameters found in Berardino et al 2017 @@ -446,23 +426,15 @@ def __init__( def forward(self, x: Tensor) -> Tensor: linear = self.center_surround(x) lum = self.luminance(x) - lum_normed = linear / ( - 1 + self.luminance_scalar.view(1, 2, 1, 1) * lum - ) + lum_normed = linear / (1 + self.luminance_scalar.view(1, 2, 1, 1) * lum) - con = ( - self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1e-6 - ) # avoid div by 0 - con_normed = lum_normed / ( - 1 + self.contrast_scalar.view(1, 2, 1, 1) * con - ) + con = self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1E-6 # avoid div by 0 + con_normed = lum_normed / (1 + self.contrast_scalar.view(1, 2, 1, 1) * con) y = self.activation(con_normed) if self.apply_mask: im_shape = x.shape[-2:] - if ( - self._disk is None or self._disk.shape != im_shape - ): # cache new mask + if self._disk is None or self._disk.shape != im_shape: # cache new mask self._disk = make_disk(im_shape).to(x.device) if self._disk.device != x.device: self._disk = self._disk.to(x.device) @@ -471,6 +443,7 @@ def forward(self, x: Tensor) -> Tensor: return y + def display_filters(self, zoom=5.0, **kwargs): """Displays convolutional filters of model @@ -504,12 +477,7 @@ def display_filters(self, zoom=5.0, **kwargs): ] fig = imshow( - weights, - title=title, - col_wrap=2, - zoom=zoom, - vrange="indep0", - **kwargs, + weights, title=title, col_wrap=2, zoom=zoom, vrange="indep0", **kwargs ) return fig @@ -526,6 +494,7 @@ def _pretrained_state_dict() -> OrderedDict: ("center_surround.amplitude_ratio", torch.as_tensor([1.25])), ("luminance.std", torch.as_tensor([8.7366, 1.4751])), ("contrast.std", torch.as_tensor([2.7353, 1.5583])), + ] ) return state_dict diff --git a/src/plenoptic/simulate/models/naive.py b/src/plenoptic/simulate/models/naive.py index 9b8a7035..16263abe 100644 --- a/src/plenoptic/simulate/models/naive.py +++ b/src/plenoptic/simulate/models/naive.py @@ -1,5 +1,8 @@ +from typing import Union, Tuple, List import torch -from torch import Tensor, nn +from torch import nn, nn as nn, Tensor +from torch import Tensor +import numpy as np from torch.nn import functional as F from ...tools.conv import same_padding @@ -55,7 +58,7 @@ class Linear(nn.Module): def __init__( self, - kernel_size: int | tuple[int, int] = (3, 3), + kernel_size: Union[int, Tuple[int, int]] = (3, 3), pad_mode: str = "circular", default_filters: bool = True, ): @@ -70,10 +73,10 @@ def __init__( self.conv = nn.Conv2d(1, 2, kernel_size, bias=False) if default_filters: - var = torch.as_tensor(3.0) + var = torch.as_tensor(3.) f1 = circular_gaussian2d(kernel_size, std=torch.sqrt(var)) - f2 = circular_gaussian2d(kernel_size, std=torch.sqrt(var / 3)) + f2 = circular_gaussian2d(kernel_size, std=torch.sqrt(var/3)) f2 = f2 - f1 f2 = f2 / f2.sum() @@ -107,8 +110,8 @@ class Gaussian(nn.Module): def __init__( self, - kernel_size: int | tuple[int, int], - std: float | Tensor = 3.0, + kernel_size: Union[int, Tuple[int, int]], + std: Union[float, Tensor] = 3.0, pad_mode: str = "reflect", out_channels: int = 1, cache_filt: bool = False, @@ -126,19 +129,17 @@ def __init__( self.out_channels = out_channels self.cache_filt = cache_filt - self.register_buffer("_filt", None) + self.register_buffer('_filt', None) @property def filt(self): if self._filt is not None: # use old filter return self._filt else: # create new filter, optionally cache it - filt = circular_gaussian2d( - self.kernel_size, self.std, self.out_channels - ) + filt = circular_gaussian2d(self.kernel_size, self.std, self.out_channels) if self.cache_filt: - self.register_buffer("_filt", filt) + self.register_buffer('_filt', filt) return filt def forward(self, x: Tensor, **conv2d_kwargs) -> Tensor: @@ -195,12 +196,12 @@ class CenterSurround(nn.Module): def __init__( self, - kernel_size: int | tuple[int, int], - on_center: bool | list[bool,] = True, + kernel_size: Union[int, Tuple[int, int]], + on_center: Union[bool, List[bool, ]] = True, width_ratio_limit: float = 2.0, amplitude_ratio: float = 1.25, - center_std: float | Tensor = 1.0, - surround_std: float | Tensor = 4.0, + center_std: Union[float, Tensor] = 1.0, + surround_std: Union[float, Tensor] = 4.0, out_channels: int = 1, pad_mode: str = "reflect", cache_filt: bool = False, @@ -210,46 +211,31 @@ def __init__( # make sure each channel is on-off or off-on if isinstance(on_center, bool): on_center = [on_center] * out_channels - assert ( - len(on_center) == out_channels - ), "len(on_center) must match out_channels" + assert len(on_center) == out_channels, "len(on_center) must match out_channels" # make sure each channel has a center and surround std if isinstance(center_std, float) or center_std.shape == torch.Size([]): center_std = torch.ones(out_channels) * center_std - if isinstance(surround_std, float) or surround_std.shape == torch.Size( - [] - ): + if isinstance(surround_std, float) or surround_std.shape == torch.Size([]): surround_std = torch.ones(out_channels) * surround_std - assert ( - len(center_std) == out_channels - and len(surround_std) == out_channels - ), "stds must correspond to each out_channel" - assert ( - width_ratio_limit > 1.0 - ), "stdev of surround must be greater than center" - assert ( - amplitude_ratio >= 1.0 - ), "ratio of amplitudes must at least be 1." + assert len(center_std) == out_channels and len(surround_std) == out_channels, "stds must correspond to each out_channel" + assert width_ratio_limit > 1.0, "stdev of surround must be greater than center" + assert amplitude_ratio >= 1.0, "ratio of amplitudes must at least be 1." self.on_center = on_center self.kernel_size = kernel_size self.width_ratio_limit = width_ratio_limit - self.register_buffer( - "amplitude_ratio", torch.as_tensor(amplitude_ratio) - ) + self.register_buffer("amplitude_ratio", torch.as_tensor(amplitude_ratio)) self.center_std = nn.Parameter(torch.ones(out_channels) * center_std) - self.surround_std = nn.Parameter( - torch.ones(out_channels) * surround_std - ) + self.surround_std = nn.Parameter(torch.ones(out_channels) * surround_std) self.out_channels = out_channels self.pad_mode = pad_mode self.cache_filt = cache_filt - self.register_buffer("_filt", None) + self.register_buffer('_filt', None) @property def filt(self) -> Tensor: @@ -260,32 +246,24 @@ def filt(self) -> Tensor: on_amp = self.amplitude_ratio device = on_amp.device - filt_center = circular_gaussian2d( - self.kernel_size, self.center_std, self.out_channels - ) - filt_surround = circular_gaussian2d( - self.kernel_size, self.surround_std, self.out_channels - ) + filt_center = circular_gaussian2d(self.kernel_size, self.center_std, self.out_channels) + filt_surround = circular_gaussian2d(self.kernel_size, self.surround_std, self.out_channels) # sign is + or - depending on center is on or off - sign = torch.as_tensor( - [1.0 if x else -1.0 for x in self.on_center] - ).to(device) + sign = torch.as_tensor([1. if x else -1. for x in self.on_center]).to(device) sign = sign.view(self.out_channels, 1, 1, 1) filt = on_amp * (sign * (filt_center - filt_surround)) if self.cache_filt: - self.register_buffer("_filt", filt) + self.register_buffer('_filt', filt) return filt def _clamp_surround_std(self): """Clamps surround standard deviation to ratio_limit times center_std""" lower_bound = self.width_ratio_limit * self.center_std for i, lb in enumerate(lower_bound): - self.surround_std[i].data = self.surround_std[i].data.clamp( - min=float(lb) - ) + self.surround_std[i].data = self.surround_std[i].data.clamp(min=float(lb)) def forward(self, x: Tensor) -> Tensor: x = same_padding(x, self.kernel_size, pad_mode=self.pad_mode) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index edc7d3d0..81545620 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -7,7 +7,7 @@ consider them as members of the same family of textures. """ from collections import OrderedDict -from typing import Literal, Union +from typing import List, Optional, Tuple, Union import einops import matplotlib as mpl @@ -17,17 +17,16 @@ import torch.fft import torch.nn as nn from torch import Tensor +from typing_extensions import Literal from ...tools import signal, stats from ...tools.data import to_numpy from ...tools.display import clean_stem_plot, clean_up_axes, update_stem from ...tools.validate import validate_input +from ..canonical_computations.steerable_pyramid_freq import SteerablePyramidFreq from ..canonical_computations.steerable_pyramid_freq import ( SCALES_TYPE as PYR_SCALES_TYPE, ) -from ..canonical_computations.steerable_pyramid_freq import ( - SteerablePyramidFreq, -) SCALES_TYPE = Union[Literal["pixel_statistics"], PYR_SCALES_TYPE] @@ -81,7 +80,7 @@ class PortillaSimoncelli(nn.Module): def __init__( self, - image_shape: tuple[int, int], + image_shape: Tuple[int, int], n_scales: int = 4, n_orientations: int = 4, spatial_corr_width: int = 9, @@ -147,6 +146,8 @@ def __init__( ] def _create_scales_shape_dict(self) -> OrderedDict: + + """Create dictionary defining scales and shape of each stat. This dictionary functions as metadata which is used for two main @@ -220,11 +221,7 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["kurtosis_reconstructed"] = scales_with_lowpass auto_corr = np.ones( - ( - self.spatial_corr_width, - self.spatial_corr_width, - self.n_scales + 1, - ), + (self.spatial_corr_width, self.spatial_corr_width, self.n_scales + 1), dtype=object, ) auto_corr *= einops.rearrange(scales_with_lowpass, "s -> 1 1 s") @@ -233,8 +230,7 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["std_reconstructed"] = scales_with_lowpass cross_orientation_corr_mag = np.ones( - (self.n_orientations, self.n_orientations, self.n_scales), - dtype=int, + (self.n_orientations, self.n_orientations, self.n_scales), dtype=int ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") shape_dict[ @@ -246,21 +242,15 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["magnitude_std"] = mags_std cross_scale_corr_mag = np.ones( - (self.n_orientations, self.n_orientations, self.n_scales - 1), - dtype=int, - ) - cross_scale_corr_mag *= einops.rearrange( - scales_without_coarsest, "s -> 1 1 s" + (self.n_orientations, self.n_orientations, self.n_scales - 1), dtype=int ) + cross_scale_corr_mag *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_magnitude"] = cross_scale_corr_mag cross_scale_corr_real = np.ones( - (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), - dtype=int, - ) - cross_scale_corr_real *= einops.rearrange( - scales_without_coarsest, "s -> 1 1 s" + (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), dtype=int ) + cross_scale_corr_real *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_real"] = cross_scale_corr_real shape_dict["var_highpass_residual"] = np.array(["residual_highpass"]) @@ -297,9 +287,7 @@ def _create_necessary_stats_dict( mask_dict = scales_shape_dict.copy() # Pre-compute some necessary indices. # Lower triangular indices (including diagonal), for auto correlations - tril_inds = torch.tril_indices( - self.spatial_corr_width, self.spatial_corr_width - ) + tril_inds = torch.tril_indices(self.spatial_corr_width, self.spatial_corr_width) # Get the second half of the diagonal, i.e., everything from the center # element on. These are all repeated for the auto correlations. (As # these are autocorrelations (rather than auto-covariance) matrices, @@ -312,14 +300,9 @@ def _create_necessary_stats_dict( # for cross_orientation_correlation_magnitude (because we've normalized # this matrix to be true cross-correlations, the diagonals are all 1, # like for the auto-correlations) - triu_inds = torch.triu_indices( - self.n_orientations, self.n_orientations - ) + triu_inds = torch.triu_indices(self.n_orientations, self.n_orientations) for k, v in mask_dict.items(): - if k in [ - "auto_correlation_magnitude", - "auto_correlation_reconstructed", - ]: + if k in ["auto_correlation_magnitude", "auto_correlation_reconstructed"]: # Symmetry M_{i,j} = M_{n-i+1, n-j+1} # Start with all False, then place True in necessary stats. mask = torch.zeros(v.shape, dtype=torch.bool) @@ -341,7 +324,7 @@ def _create_necessary_stats_dict( return mask_dict def forward( - self, image: Tensor, scales: list[SCALES_TYPE] | None = None + self, image: Tensor, scales: Optional[List[SCALES_TYPE]] = None ) -> Tensor: r"""Generate Texture Statistics representation of an image. @@ -389,17 +372,14 @@ def forward( # real_pyr_coeffs, which contain the demeaned magnitude of the pyramid # coefficients and the real part of the pyramid coefficients # respectively. - ( - mag_pyr_coeffs, - real_pyr_coeffs, - ) = self._compute_intermediate_representations(pyr_coeffs) + mag_pyr_coeffs, real_pyr_coeffs = self._compute_intermediate_representations( + pyr_coeffs + ) # Then, the reconstructed lowpass image at each scale. (this is a list # of length n_scales+1 containing tensors of shape (batch, channel, # height, width)) - reconstructed_images = self._reconstruct_lowpass_at_each_scale( - pyr_dict - ) + reconstructed_images = self._reconstruct_lowpass_at_each_scale(pyr_dict) # the reconstructed_images list goes from coarse-to-fine, but we want # each of the stats computed from it to go from fine-to-coarse, so we # reverse its direction. @@ -421,9 +401,7 @@ def forward( # tensor of shape (batch, channel, spatial_corr_width, # spatial_corr_width, n_scales+1), and var_recon is a tensor of shape # (batch, channel, n_scales+1) - autocorr_recon, var_recon = self._compute_autocorr( - reconstructed_images - ) + autocorr_recon, var_recon = self._compute_autocorr(reconstructed_images) # Compute the standard deviation, skew, and kurtosis of each # reconstructed lowpass image. std_recon, skew_recon, and # kurtosis_recon will all end up as tensors of shape (batch, channel, @@ -449,28 +427,23 @@ def forward( if self.n_scales != 1: # First, double the phase the coefficients, so we can correctly # compute correlations across scales. - ( - phase_doubled_mags, - phase_doubled_sep, - ) = self._double_phase_pyr_coeffs(pyr_coeffs) + phase_doubled_mags, phase_doubled_sep = self._double_phase_pyr_coeffs( + pyr_coeffs + ) # Compute the cross-scale correlations between the magnitude # coefficients. For each coefficient, we're correlating it with the # coefficients at the next-coarsest scale. this will be a tensor of # shape (batch, channel, n_orientations, n_orientations, # n_scales-1) cross_scale_corr_mags, _ = self._compute_cross_correlation( - mag_pyr_coeffs[:-1], - phase_doubled_mags, - tensors_are_identical=False, + mag_pyr_coeffs[:-1], phase_doubled_mags, tensors_are_identical=False ) # Compute the cross-scale correlations between the real # coefficients and the real and imaginary coefficients at the next # coarsest scale. this will be a tensor of shape (batch, channel, # n_orientations, 2*n_orientations, n_scales-1) cross_scale_corr_real, _ = self._compute_cross_correlation( - real_pyr_coeffs[:-1], - phase_doubled_sep, - tensors_are_identical=False, + real_pyr_coeffs[:-1], phase_doubled_sep, tensors_are_identical=False ) # Compute the variance of the highpass residual @@ -507,14 +480,12 @@ def forward( # Return the subset of stats corresponding to the specified scale. if scales is not None: - representation_tensor = self.remove_scales( - representation_tensor, scales - ) + representation_tensor = self.remove_scales(representation_tensor, scales) return representation_tensor def remove_scales( - self, representation_tensor: Tensor, scales_to_keep: list[SCALES_TYPE] + self, representation_tensor: Tensor, scales_to_keep: List[SCALES_TYPE] ) -> Tensor: """Remove statistics not associated with scales. @@ -619,9 +590,7 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: device=representation_tensor.device, ) # v.sum() gives the number of necessary elements from this stat - this_stat_vec = representation_tensor[ - ..., n_filled : n_filled + v.sum() - ] + this_stat_vec = representation_tensor[..., n_filled : n_filled + v.sum()] # use boolean indexing to put the values from new_stat_vec in the # appropriate place new_v[..., v] = this_stat_vec @@ -631,7 +600,7 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: def _compute_pyr_coeffs( self, image: Tensor - ) -> tuple[OrderedDict, list[Tensor], Tensor, Tensor]: + ) -> Tuple[OrderedDict, List[Tensor], Tensor, Tensor]: """Compute pyramid coefficients of image. Note that the residual lowpass has been demeaned independently for each @@ -673,9 +642,7 @@ def _compute_pyr_coeffs( # of shape (batch, channel, n_orientations, height, width) (note that # height and width halves on each scale) coeffs_list = [ - torch.stack( - [pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2 - ) + torch.stack([pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2) for i in range(self.n_scales) ] return pyr_coeffs, coeffs_list, highpass, lowpass @@ -712,14 +679,12 @@ def _compute_pixel_stats(image: Tensor) -> Tensor: # mean needed to be unflattened to be used by skew and kurtosis # correctly, but we'll want it to be flattened like this in the final # representation tensor - return einops.pack( - [mean, var, skew, kurtosis, img_min, img_max], "b c *" - )[0] + return einops.pack([mean, var, skew, kurtosis, img_min, img_max], "b c *")[0] @staticmethod def _compute_intermediate_representations( pyr_coeffs: Tensor - ) -> tuple[list[Tensor], list[Tensor]]: + ) -> Tuple[List[Tensor], List[Tensor]]: """Compute useful intermediate representations. These representations are: @@ -754,17 +719,14 @@ def _compute_intermediate_representations( mag.mean((-2, -1), keepdim=True) for mag in magnitude_pyr_coeffs ] magnitude_pyr_coeffs = [ - mag - mn - for mag, mn in zip( - magnitude_pyr_coeffs, magnitude_means, strict=False - ) + mag - mn for mag, mn in zip(magnitude_pyr_coeffs, magnitude_means) ] real_pyr_coeffs = [coeff.real for coeff in pyr_coeffs] return magnitude_pyr_coeffs, real_pyr_coeffs def _reconstruct_lowpass_at_each_scale( self, pyr_coeffs_dict: OrderedDict - ) -> list[Tensor]: + ) -> List[Tensor]: """Reconstruct the lowpass unoriented image at each scale. The autocorrelation, standard deviation, skew, and kurtosis of each of @@ -799,15 +761,12 @@ def _reconstruct_lowpass_at_each_scale( # values across scales. This could also be handled by making the # pyramid tight frame reconstructed_images[:-1] = [ - signal.shrink(r, 2 ** (self.n_scales - i)) - * 4 ** (self.n_scales - i) + signal.shrink(r, 2 ** (self.n_scales - i)) * 4 ** (self.n_scales - i) for i, r in enumerate(reconstructed_images[:-1]) ] return reconstructed_images - def _compute_autocorr( - self, coeffs_list: list[Tensor] - ) -> tuple[Tensor, Tensor]: + def _compute_autocorr(self, coeffs_list: List[Tensor]) -> Tuple[Tensor, Tensor]: """Compute the autocorrelation of some statistics. Parameters @@ -843,18 +802,16 @@ def _compute_autocorr( ) acs = [signal.autocorrelation(coeff) for coeff in coeffs_list] var = [signal.center_crop(ac, 1) for ac in acs] - acs = [ac / v for ac, v in zip(acs, var, strict=False)] + acs = [ac / v for ac, v in zip(acs, var)] var = einops.pack(var, "b c *")[0] acs = [signal.center_crop(ac, self.spatial_corr_width) for ac in acs] acs = torch.stack(acs, 2) - return einops.rearrange( - acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}" - ), var + return einops.rearrange(acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}"), var @staticmethod def _compute_skew_kurtosis_recon( - reconstructed_images: list[Tensor], var_recon: Tensor, img_var: Tensor - ) -> tuple[Tensor, Tensor]: + reconstructed_images: List[Tensor], var_recon: Tensor, img_var: Tensor + ) -> Tuple[Tensor, Tensor]: """Compute the skew and kurtosis of each lowpass reconstructed image. For each scale, if the ratio of its variance to the original image's @@ -902,17 +859,15 @@ def _compute_skew_kurtosis_recon( res = torch.finfo(img_var.dtype).resolution unstable_locs = var_recon / img_var.unsqueeze(-1) < res skew_recon = torch.where(unstable_locs, skew_default, skew_recon) - kurtosis_recon = torch.where( - unstable_locs, kurtosis_default, kurtosis_recon - ) + kurtosis_recon = torch.where(unstable_locs, kurtosis_default, kurtosis_recon) return skew_recon, kurtosis_recon def _compute_cross_correlation( self, - coeffs_tensor: list[Tensor], - coeffs_tensor_other: list[Tensor], + coeffs_tensor: List[Tensor], + coeffs_tensor_other: List[Tensor], tensors_are_identical: bool = False, - ) -> tuple[Tensor, Tensor]: + ) -> Tuple[Tensor, Tensor]: """Compute cross-correlations. Parameters @@ -939,9 +894,7 @@ def _compute_cross_correlation( """ covars = [] coeffs_var = [] - for coeff, coeff_other in zip( - coeffs_tensor, coeffs_tensor_other, strict=False - ): + for coeff, coeff_other in zip(coeffs_tensor, coeffs_tensor_other): # precompute this, which we'll use for normalization numel = torch.mul(*coeff.shape[-2:]) # compute the covariance @@ -955,18 +908,14 @@ def _compute_cross_correlation( # First, compute the variances of each coeff (if coeff and # coeff_other are identical, this is equivalent to the diagonal of # the above covar matrix, but re-computing it is actually faster) - coeff_var = einops.einsum( - coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1" - ) + coeff_var = einops.einsum(coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1") coeff_var = coeff_var / numel coeffs_var.append(coeff_var) if tensors_are_identical: coeff_other_var = coeff_var else: coeff_other_var = einops.einsum( - coeff_other, - coeff_other, - "b c o2 h w, b c o2 h w -> b c o2", + coeff_other, coeff_other, "b c o2 h w, b c o2 h w -> b c o2" ) coeff_other_var = coeff_other_var / numel # Then compute the outer product of those variances. @@ -980,8 +929,8 @@ def _compute_cross_correlation( @staticmethod def _double_phase_pyr_coeffs( - pyr_coeffs: list[Tensor] - ) -> tuple[list[Tensor], list[Tensor]]: + pyr_coeffs: List[Tensor] + ) -> Tuple[List[Tensor], List[Tensor]]: """Upsample and double the phase of pyramid coefficients. Parameters @@ -1022,21 +971,19 @@ def _double_phase_pyr_coeffs( ) doubled_phase_mags.append(doubled_phase_mag) doubled_phase_sep.append( - einops.pack( - [doubled_phase.real, doubled_phase.imag], "b c * h w" - )[0] + einops.pack([doubled_phase.real, doubled_phase.imag], "b c * h w")[0] ) return doubled_phase_mags, doubled_phase_sep def plot_representation( self, data: Tensor, - ax: plt.Axes | None = None, - figsize: tuple[float, float] = (15, 15), - ylim: tuple[float, float] | Literal[False] | None = None, + ax: Optional[plt.Axes] = None, + figsize: Tuple[float, float] = (15, 15), + ylim: Optional[Union[Tuple[float, float], Literal[False]]] = None, batch_idx: int = 0, - title: str | None = None, - ) -> tuple[plt.Figure, list[plt.Axes]]: + title: Optional[str] = None, + ) -> Tuple[plt.Figure, List[plt.Axes]]: r"""Plot the representation in a human viewable format -- stem plots with data separated out by statistic type. @@ -1199,10 +1146,10 @@ def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: def update_plot( self, - axes: list[plt.Axes], + axes: List[plt.Axes], data: Tensor, batch_idx: int = 0, - ) -> list[plt.Artist]: + ) -> List[plt.Artist]: r"""Update the information in our representation plot. This is used for creating an animation of the representation @@ -1255,7 +1202,7 @@ def update_plot( # of the first two dims rep = {k: v[0, 0] for k, v in self.convert_to_dict(data).items()} rep = self._representation_for_plotting(rep) - for ax, d in zip(axes, rep.values(), strict=False): + for ax, d in zip(axes, rep.values()): if isinstance(d, dict): vals = np.array([dd.detach() for dd in d.values()]) else: diff --git a/src/plenoptic/synthesize/__init__.py b/src/plenoptic/synthesize/__init__.py index 7eb36795..f9d7e0f3 100644 --- a/src/plenoptic/synthesize/__init__.py +++ b/src/plenoptic/synthesize/__init__.py @@ -1,5 +1,5 @@ from .eigendistortion import Eigendistortion +from .metamer import Metamer, MetamerCTF from .geodesic import Geodesic from .mad_competition import MADCompetition -from .metamer import Metamer, MetamerCTF from .simple_metamer import SimpleMetamer diff --git a/src/plenoptic/synthesize/autodiff.py b/src/plenoptic/synthesize/autodiff.py index 84c7724f..8be6e00c 100755 --- a/src/plenoptic/synthesize/autodiff.py +++ b/src/plenoptic/synthesize/autodiff.py @@ -1,7 +1,6 @@ -import warnings - import torch from torch import Tensor +import warnings def jacobian(y: Tensor, x: Tensor) -> Tensor: @@ -41,9 +40,7 @@ def jacobian(y: Tensor, x: Tensor) -> Tensor: .t() ) - if ( - y.shape[0] == 1 - ): # need to return a 2D tensor even if y dimensionality is 1 + if y.shape[0] == 1: # need to return a 2D tensor even if y dimensionality is 1 J = J.unsqueeze(0) return J.detach() diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 2dd67037..3f4061c4 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -1,22 +1,18 @@ +from typing import Tuple, List, Callable, Union, Optional import warnings -from collections.abc import Callable -from typing import Literal +from typing_extensions import Literal import matplotlib.pyplot +from matplotlib.figure import Figure import numpy as np import torch -from matplotlib.figure import Figure from torch import Tensor from tqdm.auto import tqdm +from .synthesis import Synthesis +from .autodiff import jacobian, vector_jacobian_product, jacobian_vector_product from ..tools.display import imshow from ..tools.validate import validate_input, validate_model -from .autodiff import ( - jacobian, - jacobian_vector_product, - vector_jacobian_product, -) -from .synthesis import Synthesis def fisher_info_matrix_vector_product( @@ -53,7 +49,7 @@ def fisher_info_matrix_vector_product( def fisher_info_matrix_eigenvalue( - y: Tensor, x: Tensor, v: Tensor, dummy_vec: Tensor | None = None + y: Tensor, x: Tensor, v: Tensor, dummy_vec: Optional[Tensor] = None ) -> Tensor: r"""Compute the eigenvalues of the Fisher Information Matrix corresponding to eigenvectors in v :math:`\lambda= v^T F v` @@ -64,7 +60,7 @@ def fisher_info_matrix_eigenvalue( Fv = fisher_info_matrix_vector_product(y, x, v, dummy_vec) # compute eigenvalues for all vectors in v - lmbda = torch.stack([a.dot(b) for a, b in zip(v.T, Fv.T, strict=False)]) + lmbda = torch.stack([a.dot(b) for a, b in zip(v.T, Fv.T)]) return lmbda @@ -121,12 +117,8 @@ class Eigendistortion(Synthesis): def __init__(self, image: Tensor, model: torch.nn.Module): validate_input(image, no_batch=True) - validate_model( - model, - image_shape=image.shape, - image_dtype=image.dtype, - device=image.device, - ) + validate_model(model, image_shape=image.shape, + image_dtype=image.dtype, device=image.device) ( self.batch_size, @@ -151,7 +143,7 @@ def __init__(self, image: Tensor, model: torch.nn.Module): self._eigenindex = None def _init_representation(self, image): - """Set self._representation_flat, based on model and image""" + """Set self._representation_flat, based on model and image """ self._image = self._image_flat.view(*image.shape) image_representation = self.model(self.image) @@ -201,29 +193,24 @@ def synthesize( """ allowed_methods = ["power", "exact", "randomized_svd"] - assert ( - method in allowed_methods - ), f"method must be in {allowed_methods}" + assert method in allowed_methods, f"method must be in {allowed_methods}" if ( method == "exact" - and self._representation_flat.size(0) * self._image_flat.size(0) - > 1e6 + and self._representation_flat.size(0) * self._image_flat.size(0) > 1e6 ): warnings.warn( "Jacobian > 1e6 elements and may cause out-of-memory. Use method = {'power', 'randomized_svd'}." ) if method == "exact": # compute exact Jacobian - print("Computing all eigendistortions") + print(f"Computing all eigendistortions") eig_vals, eig_vecs = self._synthesize_exact() eig_vecs = self._vector_to_image(eig_vecs.detach()) eig_vecs_ind = torch.arange(len(eig_vecs)) elif method == "randomized_svd": - print( - f"Estimating top k={k} eigendistortions using randomized SVD" - ) + print(f"Estimating top k={k} eigendistortions using randomized SVD") lmbda_new, v_new, error_approx = self._synthesize_randomized_svd( k=k, p=p, q=q ) @@ -237,6 +224,7 @@ def synthesize( ) else: # method == 'power' + assert max_iter > 0, "max_iter must be greater than zero" lmbda_max, v_max = self._synthesize_power( @@ -247,20 +235,16 @@ def synthesize( ) n = v_max.shape[0] - eig_vecs = self._vector_to_image( - torch.cat((v_max, v_min), dim=1).detach() - ) + eig_vecs = self._vector_to_image(torch.cat((v_max, v_min), dim=1).detach()) eig_vals = torch.cat([lmbda_max, lmbda_min]).squeeze() eig_vecs_ind = torch.cat((torch.arange(k), torch.arange(n - k, n))) # reshape to (n x num_chans x h x w) - self._eigendistortions = ( - torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] - ) + self._eigendistortions = torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] self._eigenvalues = torch.abs(eig_vals.detach()) self._eigenindex = eig_vecs_ind - def _synthesize_exact(self) -> tuple[Tensor, Tensor]: + def _synthesize_exact(self) -> Tuple[Tensor, Tensor]: r"""Eigendecomposition of explicitly computed Fisher Information Matrix. To be used when the input is small (e.g. less than 70x70 image on cluster or 30x30 on your own machine). This @@ -300,8 +284,8 @@ def compute_jacobian(self) -> Tensor: return J def _synthesize_power( - self, k: int, shift: Tensor | float, tol: float, max_iter: int - ) -> tuple[Tensor, Tensor]: + self, k: int, shift: Union[Tensor, float], tol: float, max_iter: int + ) -> Tuple[Tensor, Tensor]: r"""Use power method (or orthogonal iteration when k>1) to obtain largest (smallest) eigenvalue/vector pairs. Apply the algorithm to approximate the extremal eigenvalues and eigenvectors of the Fisher @@ -342,9 +326,7 @@ def _synthesize_power( v = torch.randn(len(x), k, device=x.device, dtype=x.dtype) v = v / torch.linalg.vector_norm(v, dim=0, keepdim=True, ord=2) - _dummy_vec = torch.ones_like( - y, requires_grad=True - ) # cache a dummy vec for jvp + _dummy_vec = torch.ones_like(y, requires_grad=True) # cache a dummy vec for jvp Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) v = Fv / torch.linalg.vector_norm(Fv, dim=0, keepdim=True, ord=2) lmbda = fisher_info_matrix_eigenvalue(y, x, v, _dummy_vec) @@ -366,15 +348,11 @@ def _synthesize_power( Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) Fv = Fv - shift * v # optionally shift: (F - shift*I)v - v_new, _ = torch.linalg.qr( - Fv, "reduced" - ) # (ortho)normalize vector(s) + v_new, _ = torch.linalg.qr(Fv, "reduced") # (ortho)normalize vector(s) lmbda_new = fisher_info_matrix_eigenvalue(y, x, v_new, _dummy_vec) - d_lambda = torch.linalg.vector_norm( - lmbda - lmbda_new, ord=2 - ) # stability of eigenspace + d_lambda = torch.linalg.vector_norm(lmbda - lmbda_new, ord=2) # stability of eigenspace v = v_new lmbda = lmbda_new @@ -384,7 +362,7 @@ def _synthesize_power( def _synthesize_randomized_svd( self, k: int, p: int, q: int - ) -> tuple[Tensor, Tensor, Tensor]: + ) -> Tuple[Tensor, Tensor, Tensor]: r"""Synthesize eigendistortions using randomized truncated SVD. This method approximates the column space of the Fisher Info Matrix, projects the FIM into that column space, @@ -443,13 +421,11 @@ def _synthesize_randomized_svd( y, x, torch.randn(n, 20).to(x.device), _dummy_vec ) error_approx = omega - (Q @ Q.T @ omega) - error_approx = torch.linalg.vector_norm( - error_approx, dim=0, ord=2 - ).mean() + error_approx = torch.linalg.vector_norm(error_approx, dim=0, ord=2).mean() return S[:k].clone(), V[:, :k].clone(), error_approx # truncate - def _vector_to_image(self, vecs: Tensor) -> list[Tensor]: + def _vector_to_image(self, vecs: Tensor) -> List[Tensor]: r"""Reshapes eigenvectors back into correct image dimensions. Parameters @@ -465,9 +441,7 @@ def _vector_to_image(self, vecs: Tensor) -> list[Tensor]: """ imgs = [ - vecs[:, i].reshape( - (self.n_channels, self.im_height, self.im_width) - ) + vecs[:, i].reshape((self.n_channels, self.im_height, self.im_width)) for i in range(vecs.shape[1]) ] return imgs @@ -479,9 +453,7 @@ def _indexer(self, idx: int) -> int: i = idx_range[idx] all_idx = self.eigenindex - assert ( - i in all_idx - ), "eigenindex must be the index of one of the vectors" + assert i in all_idx, "eigenindex must be the index of one of the vectors" assert ( all_idx is not None and len(all_idx) != 0 ), "No eigendistortions synthesized" @@ -534,24 +506,14 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = [ - "_jacobian", - "_eigendistortions", - "_eigenvalues", - "_eigenindex", - "_model", - "_image", - "_image_flat", - "_representation_flat", - ] + attrs = ["_jacobian", "_eigendistortions", "_eigenvalues", + "_eigenindex", "_model", "_image", "_image_flat", + "_representation_flat"] super().to(*args, attrs=attrs, **kwargs) - def load( - self, - file_path: str, - map_location: str | None = None, - **pickle_load_args, - ): + def load(self, file_path: str, + map_location: Union[str, None] = None, + **pickle_load_args): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Eigendistortion`` object -- @@ -585,15 +547,12 @@ def load( *then* load. """ - check_attributes = ["_image", "_representation_flat"] + check_attributes = ['_image', '_representation_flat'] check_loss_functions = [] - super().load( - file_path, - map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args, - ) + super().load(file_path, map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args) # make these require a grad again self._image_flat.requires_grad_() # we need _representation_flat and _image_flat to be connected in the @@ -611,22 +570,22 @@ def image(self): @property def jacobian(self): - """Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``.""" + """Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``. """ return self._jacobian @property def eigendistortions(self): - """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue.""" + """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue. """ return self._eigendistortions @property def eigenvalues(self): - """Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order.""" + """Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order. """ return self._eigenvalues @property def eigenindex(self): - """Index of each eigenvector/eigenvalue.""" + """Index of each eigenvector/eigenvalue. """ return self._eigenindex @@ -635,7 +594,7 @@ def display_eigendistortion( eigenindex: int = 0, alpha: float = 5.0, process_image: Callable[[Tensor], Tensor] = lambda x: x, - ax: matplotlib.pyplot.axis | None = None, + ax: Optional[matplotlib.pyplot.axis] = None, plot_complex: str = "rectangular", **kwargs, ) -> Figure: diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index 56fd81b8..9e4f6a14 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -1,24 +1,21 @@ -import warnings from collections import OrderedDict -from typing import Literal - -import matplotlib as mpl +import warnings import matplotlib.pyplot as plt +import matplotlib as mpl import torch import torch.autograd as autograd from torch import Tensor from tqdm.auto import tqdm +from typing import Union, Tuple, Optional +from typing_extensions import Literal -from ..tools.convergence import pixel_change_convergence +from .synthesis import OptimizedSynthesis from ..tools.data import to_numpy from ..tools.optim import penalize_range -from ..tools.straightness import ( - deviation_from_line, - make_straight_line, - sample_brownian_bridge, -) from ..tools.validate import validate_input, validate_model -from .synthesis import OptimizedSynthesis +from ..tools.convergence import pixel_change_convergence +from ..tools.straightness import (deviation_from_line, make_straight_line, + sample_brownian_bridge) class Geodesic(OptimizedSynthesis): @@ -99,26 +96,16 @@ class Geodesic(OptimizedSynthesis): http://www.cns.nyu.edu/~lcv/pubs/makeAbs.php?loc=Henaff16b """ - - def __init__( - self, - image_a: Tensor, - image_b: Tensor, - model: torch.nn.Module, - n_steps: int = 10, - initial_sequence: Literal["straight", "bridge"] = "straight", - range_penalty_lambda: float = 0.1, - allowed_range: tuple[float, float] = (0, 1), - ): + def __init__(self, image_a: Tensor, image_b: Tensor, + model: torch.nn.Module, n_steps: int = 10, + initial_sequence: Literal['straight', 'bridge'] = 'straight', + range_penalty_lambda: float = .1, + allowed_range: Tuple[float, float] = (0, 1)): super().__init__(range_penalty_lambda, allowed_range) validate_input(image_a, no_batch=True, allowed_range=allowed_range) validate_input(image_b, no_batch=True, allowed_range=allowed_range) - validate_model( - model, - image_shape=image_a.shape, - image_dtype=image_a.dtype, - device=image_a.device, - ) + validate_model(model, image_shape=image_a.shape, image_dtype=image_a.dtype, + device=image_a.device) self.n_steps = n_steps self._model = model @@ -139,27 +126,22 @@ def _initialize(self, initial_sequence, start, stop, n_steps): (``'straight'``), or with a brownian bridge between the two anchors (``'bridge'``). """ - if initial_sequence == "bridge": + if initial_sequence == 'bridge': geodesic = sample_brownian_bridge(start, stop, n_steps) - elif initial_sequence == "straight": + elif initial_sequence == 'straight': geodesic = make_straight_line(start, stop, n_steps) else: - raise ValueError( - f"Don't know how to handle initial_sequence={initial_sequence}" - ) - _, geodesic, _ = torch.split(geodesic, [1, n_steps - 1, 1]) + raise ValueError(f"Don't know how to handle initial_sequence={initial_sequence}") + _, geodesic, _ = torch.split(geodesic, [1, n_steps-1, 1]) self._initial_sequence = initial_sequence geodesic.requires_grad_() self._geodesic = geodesic - def synthesize( - self, - max_iter: int = 1000, - optimizer: torch.optim.Optimizer | None = None, - store_progress: bool | int = False, - stop_criterion: float | None = None, - stop_iters_to_check: int = 50, - ): + def synthesize(self, max_iter: int = 1000, + optimizer: Optional[torch.optim.Optimizer] = None, + store_progress: Union[bool, int] = False, + stop_criterion: Optional[float] = None, + stop_iters_to_check: int = 50): """Synthesize a geodesic via optimization. Parameters @@ -191,17 +173,10 @@ def synthesize( """ if stop_criterion is None: # semi arbitrary default choice of tolerance - stop_criterion = ( - torch.linalg.vector_norm(self.pixelfade, ord=2) - / 1e4 - * (1 + 5**0.5) - / 2 - ) - print( - f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}" - ) - - self._initialize_optimizer(optimizer, "_geodesic", 0.001) + stop_criterion = torch.linalg.vector_norm(self.pixelfade, ord=2) / 1e4 * (1 + 5 ** .5) / 2 + print(f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}") + + self._initialize_optimizer(optimizer, '_geodesic', .001) # get ready to store progress self.store_progress = store_progress @@ -216,14 +191,12 @@ def synthesize( raise ValueError("Found a NaN in loss during optimization.") if self._check_convergence(stop_criterion, stop_iters_to_check): - warnings.warn( - "Pixel change norm has converged, stopping synthesis" - ) + warnings.warn("Pixel change norm has converged, stopping synthesis") break pbar.close() - def objective_function(self, geodesic: Tensor | None = None) -> Tensor: + def objective_function(self, geodesic: Optional[Tensor] = None) -> Tensor: """Compute geodesic synthesis loss. This is the path energy (i.e., squared L2 norm of each step) of the @@ -251,19 +224,16 @@ def objective_function(self, geodesic: Tensor | None = None) -> Tensor: if geodesic is None: geodesic = self.geodesic self._geodesic_representation = self.model(geodesic) - self._most_recent_step_energy = self._calculate_step_energy( - self._geodesic_representation - ) + self._most_recent_step_energy = self._calculate_step_energy(self._geodesic_representation) loss = self._most_recent_step_energy.mean() range_penalty = penalize_range(self.geodesic, self.allowed_range) return loss + self.range_penalty_lambda * range_penalty def _calculate_step_energy(self, z): - """calculate the energy (i.e. squared l2 norm) of each step in `z`.""" + """calculate the energy (i.e. squared l2 norm) of each step in `z`. + """ velocity = torch.diff(z, dim=0) - step_energy = ( - torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 - ) + step_energy = torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 return step_energy def _optimizer_step(self, pbar): @@ -284,30 +254,21 @@ def _optimizer_step(self, pbar): loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm( - self._geodesic.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self._geodesic.grad.data, + ord=2, dim=None) self._gradient_norm.append(grad_norm) - pixel_change_norm = torch.linalg.vector_norm( - self._geodesic - last_iter_geodesic, ord=2, dim=None - ) + pixel_change_norm = torch.linalg.vector_norm(self._geodesic - last_iter_geodesic, + ord=2, dim=None) self._pixel_change_norm.append(pixel_change_norm) # displaying some information - pbar.set_postfix( - OrderedDict( - [ - ("loss", f"{loss.item():.4e}"), - ("gradient norm", f"{grad_norm.item():.4e}"), - ("pixel change norm", f"{pixel_change_norm.item():.5e}"), - ] - ) - ) + pbar.set_postfix(OrderedDict([('loss', f'{loss.item():.4e}'), + ('gradient norm', f'{grad_norm.item():.4e}'), + ('pixel change norm', f"{pixel_change_norm.item():.5e}")])) return loss - def _check_convergence( - self, stop_criterion: float, stop_iters_to_check: int - ) -> bool: + def _check_convergence(self, stop_criterion: float, + stop_iters_to_check: int) -> bool: """Check whether the pixel change norm has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -336,11 +297,9 @@ def _check_convergence( Whether the pixel change norm has stabilized or not. """ - return pixel_change_convergence( - self, stop_criterion, stop_iters_to_check - ) + return pixel_change_convergence(self, stop_criterion, stop_iters_to_check) - def calculate_jerkiness(self, geodesic: Tensor | None = None) -> Tensor: + def calculate_jerkiness(self, geodesic: Optional[Tensor] = None) -> Tensor: """Compute the alignment of representation's acceleration to model local curvature. This is the first order optimality condition for a geodesic, and can be @@ -362,19 +321,15 @@ def calculate_jerkiness(self, geodesic: Tensor | None = None) -> Tensor: geodesic_representation = self.model(geodesic) velocity = torch.diff(geodesic_representation, dim=0) acceleration = torch.diff(velocity, dim=0) - acc_magnitude = torch.linalg.vector_norm( - acceleration, ord=2, dim=[1, 2, 3], keepdim=True - ) + acc_magnitude = torch.linalg.vector_norm(acceleration, ord=2, dim=[1,2,3], + keepdim=True) acc_direction = torch.div(acceleration, acc_magnitude) # we slice the output of the VJP, rather than slicing geodesic, because # slicing interferes with the gradient computation: # https://stackoverflow.com/a/54767100 - accJac = self._vector_jacobian_product( - geodesic_representation[1:-1], geodesic, acc_direction - )[1:-1] - step_jerkiness = ( - torch.linalg.vector_norm(accJac, dim=[1, 2, 3], ord=2) ** 2 - ) + accJac = self._vector_jacobian_product(geodesic_representation[1:-1], + geodesic, acc_direction)[1:-1] + step_jerkiness = torch.linalg.vector_norm(accJac, dim=[1,2,3], ord=2) ** 2 return step_jerkiness def _vector_jacobian_product(self, y, x, a): @@ -382,9 +337,9 @@ def _vector_jacobian_product(self, y, x, a): and allow for further gradient computations by retaining, and creating the graph. """ - accJac = autograd.grad(y, x, a, retain_graph=True, create_graph=True)[ - 0 - ] + accJac = autograd.grad(y, x, a, + retain_graph=True, + create_graph=True)[0] return accJac def _store(self, i: int) -> bool: @@ -407,29 +362,15 @@ def _store(self, i: int) -> bool: if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs try: - self._step_energy.append( - self._most_recent_step_energy.detach().to("cpu") - ) - self._dev_from_line.append( - torch.stack( - deviation_from_line( - self._geodesic_representation.detach().to("cpu") - ) - ).T - ) + self._step_energy.append(self._most_recent_step_energy.detach().to('cpu')) + self._dev_from_line.append(torch.stack(deviation_from_line(self._geodesic_representation.detach().to('cpu'))).T) except AttributeError: # the first time _store is called (i.e., before optimizer is # stepped for first time) those attributes won't be # initialized geod_rep = self.model(self.geodesic) - self._step_energy.append( - self._calculate_step_energy(geod_rep).detach().to("cpu") - ) - self._dev_from_line.append( - torch.stack( - deviation_from_line(geod_rep.detach().to("cpu")) - ).T - ) + self._step_energy.append(self._calculate_step_energy(geod_rep).detach().to('cpu')) + self._dev_from_line.append(torch.stack(deviation_from_line(geod_rep.detach().to('cpu'))).T) stored = True else: stored = False @@ -486,23 +427,13 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = [ - "_image_a", - "_image_b", - "_geodesic", - "_model", - "_step_energy", - "_dev_from_line", - "pixelfade", - ] + attrs = ['_image_a', '_image_b', '_geodesic', '_model', + '_step_energy', '_dev_from_line', 'pixelfade'] super().to(*args, attrs=attrs, **kwargs) - def load( - self, - file_path: str, - map_location: str | None = None, - **pickle_load_args, - ): + def load(self, file_path: str, + map_location: Union[str, None] = None, + **pickle_load_args): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Geodesic`` object -- we will @@ -538,47 +469,28 @@ def load( *then* load. """ - check_attributes = [ - "_image_a", - "_image_b", - "n_steps", - "_initial_sequence", - "_range_penalty_lambda", - "_allowed_range", - "pixelfade", - ] + check_attributes = ['_image_a', '_image_b', 'n_steps', + '_initial_sequence', '_range_penalty_lambda', + '_allowed_range', 'pixelfade'] check_loss_functions = [] new_loss = self.objective_function(self.pixelfade) - super().load( - file_path, - map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args, - ) - old_loss = self.__dict__.pop("_save_check") + super().load(file_path, map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args) + old_loss = self.__dict__.pop('_save_check') if not torch.allclose(new_loss, old_loss, rtol=1e-2): - raise ValueError( - "objective_function on pixelfade of saved and initialized Geodesic object are different! Do they use the same model?" - f" Self: {new_loss}, Saved: {old_loss}" - ) + raise ValueError("objective_function on pixelfade of saved and initialized Geodesic object are different! Do they use the same model?" + f" Self: {new_loss}, Saved: {old_loss}") # make this require a grad again self._geodesic.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if ( - len(self._dev_from_line) - and self._dev_from_line[0].device.type != "cpu" - ): - self._dev_from_line = [ - dev.to("cpu") for dev in self._dev_from_line - ] - if ( - len(self._step_energy) - and self._step_energy[0].device.type != "cpu" - ): - self._step_energy = [step.to("cpu") for step in self._step_energy] + if len(self._dev_from_line) and self._dev_from_line[0].device.type != 'cpu': + self._dev_from_line = [dev.to('cpu') for dev in self._dev_from_line] + if len(self._step_energy) and self._step_energy[0].device.type != 'cpu': + self._step_energy = [step.to('cpu') for step in self._step_energy] @property def model(self): @@ -623,9 +535,9 @@ def dev_from_line(self): return torch.stack(self._dev_from_line) -def plot_loss( - geodesic: Geodesic, ax: mpl.axes.Axes | None = None, **kwargs -) -> mpl.axes.Axes: +def plot_loss(geodesic: Geodesic, + ax: Union[mpl.axes.Axes, None] = None, + **kwargs) -> mpl.axes.Axes: """Plot synthesis loss. Parameters @@ -647,15 +559,14 @@ def plot_loss( if ax is None: ax = plt.gca() ax.semilogy(geodesic.losses, **kwargs) - ax.set(xlabel="Synthesis iteration", ylabel="Loss") + ax.set(xlabel='Synthesis iteration', + ylabel='Loss') return ax - -def plot_deviation_from_line( - geodesic: Geodesic, - natural_video: Tensor | None = None, - ax: mpl.axes.Axes | None = None, -) -> mpl.axes.Axes: +def plot_deviation_from_line(geodesic: Geodesic, + natural_video: Union[Tensor, None] = None, + ax: Union[mpl.axes.Axes, None] = None + ) -> mpl.axes.Axes: """Visual diagnostic of geodesic linearity in representation space. This plot illustrates the deviation from the straight line connecting @@ -698,24 +609,18 @@ def plot_deviation_from_line( ax = plt.gca() pixelfade_dev = deviation_from_line(geodesic.model(geodesic.pixelfade)) - ax.plot(*[to_numpy(d) for d in pixelfade_dev], "g-o", label="pixelfade") + ax.plot(*[to_numpy(d) for d in pixelfade_dev], 'g-o', label='pixelfade') - geodesic_dev = deviation_from_line( - geodesic.model(geodesic.geodesic).detach() - ) - ax.plot(*[to_numpy(d) for d in geodesic_dev], "r-o", label="geodesic") + geodesic_dev = deviation_from_line(geodesic.model(geodesic.geodesic).detach()) + ax.plot(*[to_numpy(d) for d in geodesic_dev], 'r-o', label='geodesic') if natural_video is not None: video_dev = deviation_from_line(geodesic.model(natural_video)) - ax.plot( - *[to_numpy(d) for d in video_dev], "b-o", label="natural video" - ) - - ax.set( - xlabel="Distance along representation line", - ylabel="Distance from representation line", - title="Deviation from the straight line", - ) + ax.plot(*[to_numpy(d) for d in video_dev], 'b-o', label='natural video') + + ax.set(xlabel='Distance along representation line', + ylabel='Distance from representation line', + title='Deviation from the straight line') ax.legend(loc=1) return ax diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 4baf6dd0..b3e61330 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -1,21 +1,19 @@ """Run MAD Competition.""" +import torch +import numpy as np +from torch import Tensor +from tqdm.auto import tqdm +from ..tools import optim, display, data +from typing import Union, Tuple, Callable, List, Dict, Optional +from typing_extensions import Literal +from .synthesis import OptimizedSynthesis import warnings -from collections import OrderedDict -from collections.abc import Callable -from typing import Literal - import matplotlib as mpl import matplotlib.pyplot as plt -import numpy as np -import torch +from collections import OrderedDict from pyrtools.tools.display import make_figure as pt_make_figure -from torch import Tensor -from tqdm.auto import tqdm - -from ..tools import data, display, optim -from ..tools.convergence import loss_convergence from ..tools.validate import validate_input, validate_metric -from .synthesis import OptimizedSynthesis +from ..tools.convergence import loss_convergence class MADCompetition(OptimizedSynthesis): @@ -99,32 +97,20 @@ class MADCompetition(OptimizedSynthesis): http://dx.doi.org/10.1167/8.12.8 """ - - def __init__( - self, - image: Tensor, - optimized_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], - reference_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], - minmax: Literal["min", "max"], - initial_noise: float = 0.1, - metric_tradeoff_lambda: float | None = None, - range_penalty_lambda: float = 0.1, - allowed_range: tuple[float, float] = (0, 1), - ): + def __init__(self, image: Tensor, + optimized_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], + reference_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], + minmax: Literal['min', 'max'], + initial_noise: float = .1, + metric_tradeoff_lambda: Optional[float] = None, + range_penalty_lambda: float = .1, + allowed_range: Tuple[float, float] = (0, 1)): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) - validate_metric( - optimized_metric, - image_shape=image.shape, - image_dtype=image.dtype, - device=image.device, - ) - validate_metric( - reference_metric, - image_shape=image.shape, - image_dtype=image.dtype, - device=image.device, - ) + validate_metric(optimized_metric, image_shape=image.shape, image_dtype=image.dtype, + device=image.device) + validate_metric(reference_metric, image_shape=image.shape, image_dtype=image.dtype, + device=image.device) self._optimized_metric = optimized_metric self._reference_metric = reference_metric self._image = image.detach() @@ -132,33 +118,25 @@ def __init__( self.scheduler = None self._optimized_metric_loss = [] self._reference_metric_loss = [] - if minmax not in ["min", "max"]: - raise ValueError( - "synthesis_target must be one of {'min', 'max'}, but got " - f"value {minmax} instead!" - ) + if minmax not in ['min', 'max']: + raise ValueError("synthesis_target must be one of {'min', 'max'}, but got " + f"value {minmax} instead!") self._minmax = minmax self._initialize(initial_noise) # If no metric_tradeoff_lambda is specified, pick one that gets them to # approximately the same magnitude if metric_tradeoff_lambda is None: - loss_ratio = torch.as_tensor( - self.optimized_metric_loss[-1] - / self.reference_metric_loss[-1], - dtype=torch.float32, - ) - metric_tradeoff_lambda = torch.pow( - torch.as_tensor(10), torch.round(torch.log10(loss_ratio)) - ).item() - warnings.warn( - "Since metric_tradeoff_lamda was None, automatically set" - f" to {metric_tradeoff_lambda} to roughly balance metrics." - ) + loss_ratio = torch.as_tensor(self.optimized_metric_loss[-1] / self.reference_metric_loss[-1], + dtype=torch.float32) + metric_tradeoff_lambda = torch.pow(torch.as_tensor(10), + torch.round(torch.log10(loss_ratio))).item() + warnings.warn("Since metric_tradeoff_lamda was None, automatically set" + f" to {metric_tradeoff_lambda} to roughly balance metrics.") self._metric_tradeoff_lambda = metric_tradeoff_lambda self._store_progress = None self._saved_mad_image = [] - def _initialize(self, initial_noise: float = 0.1): + def _initialize(self, initial_noise: float = .1): """Initialize the synthesized image. Initialize ``self.mad_image`` attribute to be ``image`` plus @@ -171,28 +149,24 @@ def _initialize(self, initial_noise: float = 0.1): ``mad_image`` from ``image``. """ - mad_image = self.image + initial_noise * torch.randn_like(self.image) + mad_image = (self.image + initial_noise * + torch.randn_like(self.image)) mad_image = mad_image.clamp(*self.allowed_range) self._initial_image = mad_image.clone() mad_image.requires_grad_() self._mad_image = mad_image - self._reference_metric_target = self.reference_metric( - self.image, self.mad_image - ).item() + self._reference_metric_target = self.reference_metric(self.image, + self.mad_image).item() self._reference_metric_loss.append(self._reference_metric_target) - self._optimized_metric_loss.append( - self.optimized_metric(self.image, self.mad_image).item() - ) - - def synthesize( - self, - max_iter: int = 100, - optimizer: torch.optim.Optimizer | None = None, - scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, - store_progress: bool | int = False, - stop_criterion: float = 1e-4, - stop_iters_to_check: int = 50, - ): + self._optimized_metric_loss.append(self.optimized_metric(self.image, + self.mad_image).item()) + + def synthesize(self, max_iter: int = 100, + optimizer: Optional[torch.optim.Optimizer] = None, + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, + store_progress: Union[bool, int] = False, + stop_criterion: float = 1e-4, stop_iters_to_check: int = 50 + ): r"""Synthesize a MAD image. Update the pixels of ``initial_image`` to maximize or minimize @@ -254,9 +228,9 @@ def synthesize( pbar.close() - def objective_function( - self, mad_image: Tensor | None = None, image: Tensor | None = None - ) -> Tensor: + def objective_function(self, + mad_image: Optional[Tensor] = None, + image: Optional[Tensor] = None) -> Tensor: r"""Compute the MADCompetition synthesis loss. This computes: @@ -294,18 +268,15 @@ def objective_function( image = self.image if mad_image is None: mad_image = self.mad_image - synth_target = {"min": 1, "max": -1}[self.minmax] + synth_target = {'min': 1, 'max': -1}[self.minmax] synthesis_loss = self.optimized_metric(image, mad_image) - fixed_loss = ( - self._reference_metric_target - - self.reference_metric(image, mad_image) - ).pow(2) - range_penalty = optim.penalize_range(mad_image, self.allowed_range) - return ( - synth_target * synthesis_loss - + self.metric_tradeoff_lambda * fixed_loss - + self.range_penalty_lambda * range_penalty - ) + fixed_loss = (self._reference_metric_target - + self.reference_metric(image, mad_image)).pow(2) + range_penalty = optim.penalize_range(mad_image, + self.allowed_range) + return (synth_target * synthesis_loss + + self.metric_tradeoff_lambda * fixed_loss + + self.range_penalty_lambda * range_penalty) def _optimizer_step(self, pbar: tqdm) -> Tensor: r"""Compute and propagate gradients, then step the optimizer to update mad_image. @@ -327,9 +298,8 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: last_iter_mad_image = self.mad_image.clone() loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm( - self.mad_image.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self.mad_image.grad.data, + ord=2, dim=None) self._gradient_norm.append(grad_norm.item()) fm = self.reference_metric(self.image, self.mad_image) @@ -341,22 +311,18 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm( - self.mad_image - last_iter_mad_image, ord=2, dim=None - ) + pixel_change_norm = torch.linalg.vector_norm(self.mad_image - last_iter_mad_image, + ord=2, dim=None) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict( - loss=f"{loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]["lr"], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}", - reference_metric=f"{fm.item():.04e}", - optimized_metric=f"{sm.item():.04e}", - ) - ) + OrderedDict(loss=f"{loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]['lr'], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + reference_metric=f'{fm.item():.04e}', + optimized_metric=f'{sm.item():.04e}')) return loss def _check_convergence(self, stop_criterion, stop_iters_to_check): @@ -392,7 +358,7 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): def _initialize_optimizer(self, optimizer, scheduler): """Initialize optimizer and scheduler.""" - super()._initialize_optimizer(optimizer, "mad_image") + super()._initialize_optimizer(optimizer, 'mad_image') self.scheduler = scheduler def _store(self, i: int) -> bool: @@ -413,7 +379,7 @@ def _store(self, i: int) -> bool: """ if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs - self._saved_mad_image.append(self.mad_image.clone().to("cpu")) + self._saved_mad_image.append(self.mad_image.clone().to('cpu')) stored = True else: stored = False @@ -439,9 +405,9 @@ def save(self, file_path: str): # if the metrics are Modules, then we don't want to save them. If # they're functions then saving them is fine. if isinstance(self.optimized_metric, torch.nn.Module): - attrs.pop("_optimized_metric") + attrs.pop('_optimized_metric') if isinstance(self.reference_metric, torch.nn.Module): - attrs.pop("_reference_metric") + attrs.pop('_reference_metric') super().save(file_path, attrs=attrs) def to(self, *args, **kwargs): @@ -478,7 +444,8 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ["_initial_image", "_image", "_mad_image", "_saved_mad_image"] + attrs = ['_initial_image', '_image', '_mad_image', + '_saved_mad_image'] super().to(*args, attrs=attrs, **kwargs) # if the metrics are Modules, then we should pass them as well. If # they're functions then nothing needs to be done. @@ -491,12 +458,9 @@ def to(self, *args, **kwargs): except AttributeError: pass - def load( - self, - file_path: str, - map_location: None | None = None, - **pickle_load_args, - ): + def load(self, file_path: str, + map_location: Optional[None] = None, + **pickle_load_args): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``MADCompetition`` object -- we @@ -533,33 +497,21 @@ def load( *then* load. """ - check_attributes = [ - "_image", - "_metric_tradeoff_lambda", - "_range_penalty_lambda", - "_allowed_range", - "_minmax", - ] - check_loss_functions = ["_reference_metric", "_optimized_metric"] - super().load( - file_path, - map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args, - ) + check_attributes = ['_image', '_metric_tradeoff_lambda', + '_range_penalty_lambda', '_allowed_range', + '_minmax'] + check_loss_functions = ['_reference_metric', '_optimized_metric'] + super().load(file_path, map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args) # make this require a grad again self.mad_image.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if ( - len(self._saved_mad_image) - and self._saved_mad_image[0].device.type != "cpu" - ): - self._saved_mad_image = [ - mad.to("cpu") for mad in self._saved_mad_image - ] + if len(self._saved_mad_image) and self._saved_mad_image[0].device.type != 'cpu': + self._saved_mad_image = [mad.to('cpu') for mad in self._saved_mad_image] @property def mad_image(self): @@ -602,12 +554,10 @@ def saved_mad_image(self): return torch.stack(self._saved_mad_image) -def plot_loss( - mad: MADCompetition, - iteration: int | None = None, - axes: list[mpl.axes.Axes] | mpl.axes.Axes | None = None, - **kwargs, -) -> mpl.axes.Axes: +def plot_loss(mad: MADCompetition, + iteration: Optional[int] = None, + axes: Union[List[mpl.axes.Axes], mpl.axes.Axes, None] = None, + **kwargs) -> mpl.axes.Axes: """Plot metric losses. Plots ``mad.optimized_metric_loss`` and ``mad.reference_metric_loss`` on two @@ -652,32 +602,30 @@ def plot_loss( loss_idx = iteration if axes is None: axes = plt.gca() - if not hasattr(axes, "__iter__"): - axes = display.clean_up_axes( - axes, False, ["top", "right", "bottom", "left"], ["x", "y"] - ) + if not hasattr(axes, '__iter__'): + axes = display.clean_up_axes(axes, False, + ['top', 'right', 'bottom', 'left'], + ['x', 'y']) gs = axes.get_subplotspec().subgridspec(1, 2) fig = axes.figure axes = [fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[0, 1])] losses = [mad.reference_metric_loss, mad.optimized_metric_loss] - names = ["Reference metric loss", "Optimized metric loss"] - for ax, loss, name in zip(axes, losses, names, strict=False): + names = ['Reference metric loss', 'Optimized metric loss'] + for ax, loss, name in zip(axes, losses, names): ax.plot(loss, **kwargs) - ax.scatter(loss_idx, loss[loss_idx], c="r") - ax.set(xlabel="Synthesis iteration", ylabel=name) + ax.scatter(loss_idx, loss[loss_idx], c='r') + ax.set(xlabel='Synthesis iteration', ylabel=name) return ax -def display_mad_image( - mad: MADCompetition, - batch_idx: int = 0, - channel_idx: int | None = None, - zoom: float | None = None, - iteration: int | None = None, - ax: mpl.axes.Axes | None = None, - title: str = "MADCompetition", - **kwargs, -) -> mpl.axes.Axes: +def display_mad_image(mad: MADCompetition, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + zoom: Optional[float] = None, + iteration: Optional[int] = None, + ax: Optional[mpl.axes.Axes] = None, + title: str = 'MADCompetition', + **kwargs) -> mpl.axes.Axes: """Display MAD image. You can specify what iteration to view by using the ``iteration`` arg. @@ -732,30 +680,21 @@ def display_mad_image( as_rgb = False if ax is None: ax = plt.gca() - display.imshow( - image, - ax=ax, - title=title, - zoom=zoom, - batch_idx=batch_idx, - channel_idx=channel_idx, - as_rgb=as_rgb, - **kwargs, - ) + display.imshow(image, ax=ax, title=title, zoom=zoom, + batch_idx=batch_idx, channel_idx=channel_idx, + as_rgb=as_rgb, **kwargs) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) return ax -def plot_pixel_values( - mad: MADCompetition, - batch_idx: int = 0, - channel_idx: int | None = None, - iteration: int | None = None, - ylim: tuple[float] | Literal[False] = False, - ax: mpl.axes.Axes | None = None, - **kwargs, -) -> mpl.axes.Axes: +def plot_pixel_values(mad: MADCompetition, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + ylim: Union[Tuple[float], Literal[False]] = False, + ax: Optional[mpl.axes.Axes] = None, + **kwargs) -> mpl.axes.Axes: r"""Plot histogram of pixel values of reference and MAD images. As a way to check the distributions of pixel intensities and see @@ -787,12 +726,11 @@ def plot_pixel_values( Creates axes. """ - def _freedman_diaconis_bins(a): """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) - iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] + iqr = np.diff(np.percentile(a, [.25, .75]))[0] if len(a) < 2: return 1 h = 2 * iqr / (len(a) ** (1 / 3)) @@ -802,7 +740,7 @@ def _freedman_diaconis_bins(a): else: return int(np.ceil((a.max() - a.min()) / h)) - kwargs.setdefault("alpha", 0.4) + kwargs.setdefault('alpha', .4) if iteration is None: mad_image = mad.mad_image[batch_idx] else: @@ -815,18 +753,10 @@ def _freedman_diaconis_bins(a): ax = plt.gca() image = data.to_numpy(image).flatten() mad_image = data.to_numpy(mad_image).flatten() - ax.hist( - image, - bins=min(_freedman_diaconis_bins(image), 50), - label="Reference image", - **kwargs, - ) - ax.hist( - mad_image, - bins=min(_freedman_diaconis_bins(image), 50), - label="MAD image", - **kwargs, - ) + ax.hist(image, bins=min(_freedman_diaconis_bins(image), 50), + label='Reference image', **kwargs) + ax.hist(mad_image, bins=min(_freedman_diaconis_bins(image), 50), + label='MAD image', **kwargs) ax.legend() if ylim: ax.set_ylim(ylim) @@ -834,9 +764,8 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots( - to_check: list[str] | dict[str, int], to_check_name: str -): +def _check_included_plots(to_check: Union[List[str], Dict[str, int]], + to_check_name: str): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -853,37 +782,26 @@ def _check_included_plots( Name of the `to_check` variable, used in the error message. """ - allowed_vals = [ - "display_mad_image", - "plot_loss", - "plot_pixel_values", - "misc", - ] + allowed_vals = ['display_mad_image', 'plot_loss', 'plot_pixel_values', 'misc'] try: vals = to_check.keys() except AttributeError: vals = to_check not_allowed = [v for v in vals if v not in allowed_vals] if not_allowed: - raise ValueError( - f"{to_check_name} contained value(s) {not_allowed}! " - f"Only {allowed_vals} are permissible!" - ) - - -def _setup_synthesis_fig( - fig: mpl.figure.Figure | None = None, - axes_idx: dict[str, int] = {}, - figsize: tuple[float] | None = None, - included_plots: list[str] = [ - "display_mad_image", - "plot_loss", - "plot_pixel_values", - ], - display_mad_image_width: float = 1, - plot_loss_width: float = 2, - plot_pixel_values_width: float = 1, -) -> tuple[mpl.figure.Figure, list[mpl.axes.Axes], dict[str, int]]: + raise ValueError(f'{to_check_name} contained value(s) {not_allowed}! ' + f'Only {allowed_vals} are permissible!') + + +def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float]] = None, + included_plots: List[str] = ['display_mad_image', + 'plot_loss', + 'plot_pixel_values'], + display_mad_image_width: float = 1, + plot_loss_width: float = 2, + plot_pixel_values_width: float = 1) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -934,75 +852,64 @@ def _setup_synthesis_fig( n_subplots = 0 axes_idx = axes_idx.copy() width_ratios = [] - if "display_mad_image" in included_plots: + if 'display_mad_image' in included_plots: n_subplots += 1 width_ratios.append(display_mad_image_width) - if "display_mad_image" not in axes_idx.keys(): - axes_idx["display_mad_image"] = data._find_min_int( - axes_idx.values() - ) - if "plot_loss" in included_plots: + if 'display_mad_image' not in axes_idx.keys(): + axes_idx['display_mad_image'] = data._find_min_int(axes_idx.values()) + if 'plot_loss' in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if "plot_loss" not in axes_idx.keys(): - axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) - if "plot_pixel_values" in included_plots: + if 'plot_loss' not in axes_idx.keys(): + axes_idx['plot_loss'] = data._find_min_int(axes_idx.values()) + if 'plot_pixel_values' in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if "plot_pixel_values" not in axes_idx.keys(): - axes_idx["plot_pixel_values"] = data._find_min_int( - axes_idx.values() - ) + if 'plot_pixel_values' not in axes_idx.keys(): + axes_idx['plot_pixel_values'] = data._find_min_int(axes_idx.values()) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: # we want (5, 5) for each subplot, with a bit of room between # each subplot - figsize = ((width_ratios * 5).sum() + width_ratios.sum() - 1, 5) + figsize = ((width_ratios*5).sum() + width_ratios.sum()-1, 5) width_ratios = width_ratios / width_ratios.sum() - fig, axes = plt.subplots( - 1, - n_subplots, - figsize=figsize, - gridspec_kw={"width_ratios": width_ratios}, - ) + fig, axes = plt.subplots(1, n_subplots, figsize=figsize, + gridspec_kw={'width_ratios': width_ratios}) if n_subplots == 1: axes = [axes] else: axes = fig.axes # make sure misc contains all the empty axes - misc_axes = axes_idx.get("misc", []) - if not hasattr(misc_axes, "__iter__"): + misc_axes = axes_idx.get('misc', []) + if not hasattr(misc_axes, '__iter__'): misc_axes = [misc_axes] all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, "__iter__"): + if hasattr(i, '__iter__'): all_axes.extend(i) else: all_axes.append(i) misc_axes += [i for i, _ in enumerate(fig.axes) if i not in all_axes] - axes_idx["misc"] = misc_axes + axes_idx['misc'] = misc_axes return fig, axes, axes_idx -def plot_synthesis_status( - mad: MADCompetition, - batch_idx: int = 0, - channel_idx: int | None = None, - iteration: int | None = None, - vrange: tuple[float] | str = "indep1", - zoom: float | None = None, - fig: mpl.figure.Figure | None = None, - axes_idx: dict[str, int] = {}, - figsize: tuple[float] | None = None, - included_plots: list[str] = [ - "display_mad_image", - "plot_loss", - "plot_pixel_values", - ], - width_ratios: dict[str, float] = {}, -) -> tuple[mpl.figure.Figure, dict[str, int]]: +def plot_synthesis_status(mad: MADCompetition, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + vrange: Union[Tuple[float], str] = 'indep1', + zoom: Optional[float] = None, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float]] = None, + included_plots: List[str] = ['display_mad_image', + 'plot_loss', + 'plot_pixel_values'], + width_ratios: Dict[str, float] = {}, + ) -> Tuple[mpl.figure.Figure, Dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create two @@ -1070,75 +977,62 @@ def plot_synthesis_status( """ if iteration is not None and not mad.store_progress: - raise ValueError( - "synthesis() was run with store_progress=False, " - "cannot specify which iteration to plot (only" - " last one, with iteration=None)" - ) + raise ValueError("synthesis() was run with store_progress=False, " + "cannot specify which iteration to plot (only" + " last one, with iteration=None)") if mad.mad_image.ndim not in [3, 4]: - raise ValueError( - "plot_synthesis_status() expects 3 or 4d data;" - "unexpected behavior will result otherwise!" - ) - _check_included_plots(included_plots, "included_plots") - _check_included_plots(width_ratios, "width_ratios") - _check_included_plots(axes_idx, "axes_idx") - width_ratios = {f"{k}_width": v for k, v in width_ratios.items()} - fig, axes, axes_idx = _setup_synthesis_fig( - fig, axes_idx, figsize, included_plots, **width_ratios - ) - - if "display_mad_image" in included_plots: - display_mad_image( - mad, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx["display_mad_image"]], - zoom=zoom, - vrange=vrange, - ) - if "plot_loss" in included_plots: - plot_loss(mad, iteration=iteration, axes=axes[axes_idx["plot_loss"]]) + raise ValueError("plot_synthesis_status() expects 3 or 4d data;" + "unexpected behavior will result otherwise!") + _check_included_plots(included_plots, 'included_plots') + _check_included_plots(width_ratios, 'width_ratios') + _check_included_plots(axes_idx, 'axes_idx') + width_ratios = {f'{k}_width': v for k, v in width_ratios.items()} + fig, axes, axes_idx = _setup_synthesis_fig(fig, axes_idx, figsize, + included_plots, + **width_ratios) + + if 'display_mad_image' in included_plots: + display_mad_image(mad, batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx['display_mad_image']], + zoom=zoom, vrange=vrange) + if 'plot_loss' in included_plots: + plot_loss(mad, iteration=iteration, axes=axes[axes_idx['plot_loss']]) # this function creates a single axis for loss, which plot_loss then # split into two. this makes sure the right two axes are present in the # dict all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, "__iter__"): + if hasattr(i, '__iter__'): all_axes.extend(i) else: all_axes.append(i) - new_axes = [i for i, _ in enumerate(fig.axes) if i not in all_axes] - axes_idx["plot_loss"] = new_axes - if "plot_pixel_values" in included_plots: - plot_pixel_values( - mad, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx["plot_pixel_values"]], - ) + new_axes = [i for i, _ in enumerate(fig.axes) + if i not in all_axes] + axes_idx['plot_loss'] = new_axes + if 'plot_pixel_values' in included_plots: + plot_pixel_values(mad, batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx['plot_pixel_values']]) return fig, axes_idx -def animate( - mad: MADCompetition, - framerate: int = 10, - batch_idx: int = 0, - channel_idx: int | None = None, - zoom: float | None = None, - fig: mpl.figure.Figure | None = None, - axes_idx: dict[str, int] = {}, - figsize: tuple[float] | None = None, - included_plots: list[str] = [ - "display_mad_image", - "plot_loss", - "plot_pixel_values", - ], - width_ratios: dict[str, float] = {}, -) -> mpl.animation.FuncAnimation: +def animate(mad: MADCompetition, + framerate: int = 10, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + zoom: Optional[float] = None, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float]] = None, + included_plots: List[str] = ['display_mad_image', + 'plot_loss', + 'plot_pixel_values'], + width_ratios: Dict[str, float] = {}, + ) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. This is essentially the figure produced by @@ -1211,67 +1105,51 @@ def animate( """ if not mad.store_progress: - raise ValueError( - "synthesize() was run with store_progress=False," - " cannot animate!" - ) + raise ValueError("synthesize() was run with store_progress=False," + " cannot animate!") if mad.mad_image.ndim not in [3, 4]: - raise ValueError( - "animate() expects 3 or 4d data; unexpected" - " behavior will result otherwise!" - ) - _check_included_plots(included_plots, "included_plots") - _check_included_plots(width_ratios, "width_ratios") - _check_included_plots(axes_idx, "axes_idx") + raise ValueError("animate() expects 3 or 4d data; unexpected" + " behavior will result otherwise!") + _check_included_plots(included_plots, 'included_plots') + _check_included_plots(width_ratios, 'width_ratios') + _check_included_plots(axes_idx, 'axes_idx') # we run plot_synthesis_status to initialize the figure if either fig is # None or if there are no titles on any axes, which we assume means that # it's an empty figure if fig is None or not any([ax.get_title() for ax in fig.axes]): - fig, axes_idx = plot_synthesis_status( - mad=mad, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=0, - figsize=figsize, - zoom=zoom, - fig=fig, - included_plots=included_plots, - axes_idx=axes_idx, - width_ratios=width_ratios, - ) + fig, axes_idx = plot_synthesis_status(mad=mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=0, figsize=figsize, + zoom=zoom, fig=fig, + included_plots=included_plots, + axes_idx=axes_idx, + width_ratios=width_ratios) # grab the artist for the second plot (we don't need to do this for the # MAD image plot, because we use the update_plot function for that) - if "plot_loss" in included_plots: - scat = [fig.axes[i].collections[0] for i in axes_idx["plot_loss"]] + if 'plot_loss' in included_plots: + scat = [fig.axes[i].collections[0] for i in axes_idx['plot_loss']] # can also have multiple plots def movie_plot(i): artists = [] - if "display_mad_image" in included_plots: - artists.extend( - display.update_plot( - fig.axes[axes_idx["display_mad_image"]], - data=mad.saved_mad_image[i], - batch_idx=batch_idx, - ) - ) - if "plot_pixel_values" in included_plots: + if 'display_mad_image' in included_plots: + artists.extend(display.update_plot(fig.axes[axes_idx['display_mad_image']], + data=mad.saved_mad_image[i], + batch_idx=batch_idx)) + if 'plot_pixel_values' in included_plots: # this is the dumbest way to do this, but it's simple -- # clearing the axes can cause problems if the user has, for # example, changed the tick locator or formatter. not sure how # to handle this best right now - fig.axes[axes_idx["plot_pixel_values"]].clear() - plot_pixel_values( - mad, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=i, - ax=fig.axes[axes_idx["plot_pixel_values"]], - ) - if "plot_loss" in included_plots: + fig.axes[axes_idx['plot_pixel_values']].clear() + plot_pixel_values(mad, batch_idx=batch_idx, + channel_idx=channel_idx, iteration=i, + ax=fig.axes[axes_idx['plot_pixel_values']]) + if 'plot_loss' in included_plots: # loss always contains values from every iteration, but everything # else will be subsampled. - x_val = i * mad.store_progress + x_val = i*mad.store_progress scat[0].set_offsets((x_val, mad.reference_metric_loss[x_val])) scat[1].set_offsets((x_val, mad.optimized_metric_loss[x_val])) artists.extend(scat) @@ -1279,28 +1157,22 @@ def movie_plot(i): return artists # don't need an init_func, since we handle initialization ourselves - anim = mpl.animation.FuncAnimation( - fig, - movie_plot, - frames=len(mad.saved_mad_image), - blit=True, - interval=1000.0 / framerate, - repeat=False, - ) + anim = mpl.animation.FuncAnimation(fig, movie_plot, + frames=len(mad.saved_mad_image), + blit=True, interval=1000./framerate, + repeat=False) plt.close(fig) return anim -def display_mad_image_all( - mad_metric1_min: MADCompetition, - mad_metric2_min: MADCompetition, - mad_metric1_max: MADCompetition, - mad_metric2_max: MADCompetition, - metric1_name: str | None = None, - metric2_name: str | None = None, - zoom: int | float = 1, - **kwargs, -) -> mpl.figure.Figure: +def display_mad_image_all(mad_metric1_min: MADCompetition, + mad_metric2_min: MADCompetition, + mad_metric1_max: MADCompetition, + mad_metric2_max: MADCompetition, + metric1_name: Optional[str] = None, + metric2_name: Optional[str] = None, + zoom: Union[int, float] = 1, + **kwargs) -> mpl.figure.Figure: """Display all MAD Competition images. To generate a full set of MAD Competition images, you need four instances: @@ -1344,74 +1216,49 @@ def display_mad_image_all( # this is a bit of a hack right now, because they don't all have same # initial image if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: metric2_name = mad_metric2_min.optimized_metric.__name__ - fig = pt_make_figure( - 3, 2, [zoom * i for i in mad_metric1_min.image.shape[-2:]] - ) + fig = pt_make_figure(3, 2, [zoom * i for i in + mad_metric1_min.image.shape[-2:]]) mads = [mad_metric1_min, mad_metric1_max, mad_metric2_min, mad_metric2_max] - titles = [ - f"Minimize {metric1_name}", - f"Maximize {metric1_name}", - f"Minimize {metric2_name}", - f"Maximize {metric2_name}", - ] + titles = [f'Minimize {metric1_name}', f'Maximize {metric1_name}', + f'Minimize {metric2_name}', f'Maximize {metric2_name}'] # we're only plotting one image here, so if the user wants multiple # channels, they must be RGB - if ( - kwargs.get("channel_idx", None) is None - and mad_metric1_min.initial_image.shape[1] > 1 - ): + if kwargs.get('channel_idx', None) is None and mad_metric1_min.initial_image.shape[1] > 1: as_rgb = True else: as_rgb = False - display.imshow( - mad_metric1_min.image, - ax=fig.axes[0], - title="Reference image", - zoom=zoom, - as_rgb=as_rgb, - **kwargs, - ) - display.imshow( - mad_metric1_min.initial_image, - ax=fig.axes[1], - title="Initial (noisy) image", - zoom=zoom, - as_rgb=as_rgb, - **kwargs, - ) - for ax, mad, title in zip(fig.axes[2:], mads, titles, strict=False): - display_mad_image(mad, zoom=zoom, ax=ax, title=title, **kwargs) + display.imshow(mad_metric1_min.image, ax=fig.axes[0], + title='Reference image', zoom=zoom, as_rgb=as_rgb, + **kwargs) + display.imshow(mad_metric1_min.initial_image, ax=fig.axes[1], + title='Initial (noisy) image', zoom=zoom, as_rgb=as_rgb, + **kwargs) + for ax, mad, title in zip(fig.axes[2:], mads, titles): + display_mad_image(mad, zoom=zoom, ax=ax, title=title, + **kwargs) return fig -def plot_loss_all( - mad_metric1_min: MADCompetition, - mad_metric2_min: MADCompetition, - mad_metric1_max: MADCompetition, - mad_metric2_max: MADCompetition, - metric1_name: str | None = None, - metric2_name: str | None = None, - metric1_kwargs: dict = {"c": "C0"}, - metric2_kwargs: dict = {"c": "C1"}, - min_kwargs: dict = {"linestyle": "--"}, - max_kwargs: dict = {"linestyle": "-"}, - figsize=(10, 5), -) -> mpl.figure.Figure: +def plot_loss_all(mad_metric1_min: MADCompetition, + mad_metric2_min: MADCompetition, + mad_metric1_max: MADCompetition, + mad_metric2_max: MADCompetition, + metric1_name: Optional[str] = None, + metric2_name: Optional[str] = None, + metric1_kwargs: Dict = {'c': 'C0'}, + metric2_kwargs: Dict = {'c': 'C1'}, + min_kwargs: Dict = {'linestyle': '--'}, + max_kwargs: Dict = {'linestyle': '-'}, + figsize=(10, 5)) -> mpl.figure.Figure: """Plot loss for full set of MAD Competiton instances. To generate a full set of MAD Competition images, you need four instances: @@ -1459,52 +1306,26 @@ def plot_loss_all( """ if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: metric2_name = mad_metric2_min.optimized_metric.__name__ fig, axes = plt.subplots(1, 2, figsize=figsize) - plot_loss( - mad_metric1_min, - axes=axes, - label=f"Minimize {metric1_name}", - **metric1_kwargs, - **min_kwargs, - ) - plot_loss( - mad_metric1_max, - axes=axes, - label=f"Maximize {metric1_name}", - **metric1_kwargs, - **max_kwargs, - ) + plot_loss(mad_metric1_min, axes=axes, label=f'Minimize {metric1_name}', + **metric1_kwargs, **min_kwargs) + plot_loss(mad_metric1_max, axes=axes, label=f'Maximize {metric1_name}', + **metric1_kwargs, **max_kwargs) # we pass the axes backwards here because the fixed and synthesis metrics are the opposite as they are in the instances above. - plot_loss( - mad_metric2_min, - axes=axes[::-1], - label=f"Minimize {metric2_name}", - **metric2_kwargs, - **min_kwargs, - ) - plot_loss( - mad_metric2_max, - axes=axes[::-1], - label=f"Maximize {metric2_name}", - **metric2_kwargs, - **max_kwargs, - ) - axes[0].set(ylabel="Loss", title=metric2_name) - axes[1].set(ylabel="Loss", title=metric1_name) - axes[1].legend(loc="center left", bbox_to_anchor=(1.1, 0.5)) + plot_loss(mad_metric2_min, axes=axes[::-1], label=f'Minimize {metric2_name}', + **metric2_kwargs, **min_kwargs) + plot_loss(mad_metric2_max, axes=axes[::-1], label=f'Maximize {metric2_name}', + **metric2_kwargs, **max_kwargs) + axes[0].set(ylabel='Loss', title=metric2_name) + axes[1].set(ylabel='Loss', title=metric1_name) + axes[1].legend(loc='center left', bbox_to_anchor=(1.1, .5)) return fig diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index d2027ea7..616bdb20 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -1,25 +1,20 @@ """Synthesize model metamers.""" +import torch import re -import warnings -from collections import OrderedDict -from collections.abc import Callable -from typing import Literal - -import matplotlib as mpl -import matplotlib.pyplot as plt import numpy as np -import torch from torch import Tensor from tqdm.auto import tqdm -from ..tools import data, display, optim, signal +from ..tools import optim, display, signal, data +from ..tools.validate import validate_input, validate_model, validate_coarse_to_fine from ..tools.convergence import coarse_to_fine_enough, loss_convergence -from ..tools.validate import ( - validate_coarse_to_fine, - validate_input, - validate_model, -) +from typing import Union, Tuple, Callable, List, Dict, Optional +from typing_extensions import Literal from .synthesis import OptimizedSynthesis +import warnings +import matplotlib as mpl +import matplotlib.pyplot as plt +from collections import OrderedDict class Metamer(OptimizedSynthesis): @@ -87,24 +82,15 @@ class Metamer(OptimizedSynthesis): http://www.cns.nyu.edu/~lcv/texture/ """ - - def __init__( - self, - image: Tensor, - model: torch.nn.Module, - loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, - range_penalty_lambda: float = 0.1, - allowed_range: tuple[float, float] = (0, 1), - initial_image: Tensor | None = None, - ): + def __init__(self, image: Tensor, model: torch.nn.Module, + loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, + range_penalty_lambda: float = .1, + allowed_range: Tuple[float, float] = (0, 1), + initial_image: Optional[Tensor] = None): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) - validate_model( - model, - image_shape=image.shape, - image_dtype=image.dtype, - device=image.device, - ) + validate_model(model, image_shape=image.shape, image_dtype=image.dtype, + device=image.device) self._model = model self._image = image self._image_shape = image.shape @@ -115,7 +101,7 @@ def __init__( self._saved_metamer = [] self._store_progress = None - def _initialize(self, initial_image: Tensor | None = None): + def _initialize(self, initial_image: Optional[Tensor] = None): """Initialize the metamer. Set the ``self.metamer`` attribute to be an attribute with the @@ -137,29 +123,22 @@ def _initialize(self, initial_image: Tensor | None = None): metamer.requires_grad_() else: if initial_image.ndimension() < 4: - raise ValueError( - "initial_image must be torch.Size([n_batch" - ", n_channels, im_height, im_width]) but got " - f"{initial_image.size()}" - ) + raise ValueError("initial_image must be torch.Size([n_batch" + ", n_channels, im_height, im_width]) but got " + f"{initial_image.size()}") if initial_image.size() != self.image.size(): raise ValueError("initial_image and image must be same size!") metamer = initial_image.clone().detach() - metamer = metamer.to( - dtype=self.image.dtype, device=self.image.device - ) + metamer = metamer.to(dtype=self.image.dtype, device=self.image.device) metamer.requires_grad_() self._metamer = metamer - def synthesize( - self, - max_iter: int = 100, - optimizer: torch.optim.Optimizer | None = None, - scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, - store_progress: bool | int = False, - stop_criterion: float = 1e-4, - stop_iters_to_check: int = 50, - ): + def synthesize(self, max_iter: int = 100, + optimizer: Optional[torch.optim.Optimizer] = None, + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, + store_progress: Union[bool, int] = False, + stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, + ): r"""Synthesize a metamer. Update the pixels of ``initial_image`` until its representation matches @@ -218,11 +197,8 @@ def synthesize( pbar.close() - def objective_function( - self, - metamer_representation: Tensor | None = None, - target_representation: Tensor | None = None, - ) -> Tensor: + def objective_function(self, metamer_representation: Optional[Tensor] = None, + target_representation: Optional[Tensor] = None) -> Tensor: """Compute the metamer synthesis loss. This calls self.loss_function on ``metamer_representation`` and @@ -246,10 +222,10 @@ def objective_function( metamer_representation = self.model(self.metamer) if target_representation is None: target_representation = self.target_representation - loss = self.loss_function( - metamer_representation, target_representation - ) - range_penalty = optim.penalize_range(self.metamer, self.allowed_range) + loss = self.loss_function(metamer_representation, + target_representation) + range_penalty = optim.penalize_range(self.metamer, + self.allowed_range) return loss + self.range_penalty_lambda * range_penalty def _optimizer_step(self, pbar: tqdm) -> Tensor: @@ -273,28 +249,23 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm( - self.metamer.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, + dim=None) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm( - self.metamer - last_iter_metamer, ord=2, dim=None - ) + pixel_change_norm = torch.linalg.vector_norm(self.metamer - last_iter_metamer, + ord=2, dim=None) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict( - loss=f"{loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]["lr"], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}", - ) - ) + OrderedDict(loss=f"{loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]['lr'], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}")) return loss def _check_convergence(self, stop_criterion, stop_iters_to_check): @@ -328,20 +299,18 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): """ return loss_convergence(self, stop_criterion, stop_iters_to_check) - def _initialize_optimizer( - self, - optimizer: torch.optim.Optimizer | None, - scheduler: torch.optim.lr_scheduler._LRScheduler | None, - ): + def _initialize_optimizer(self, + optimizer: Optional[torch.optim.Optimizer], + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler]): """Initialize optimizer and scheduler.""" # this uses the OptimizedSynthesis setter - super()._initialize_optimizer(optimizer, "metamer") + super()._initialize_optimizer(optimizer, 'metamer') self.scheduler = scheduler for pg in self.optimizer.param_groups: # initialize initial_lr if it's not here. Scheduler should add it # if it's not None. - if "initial_lr" not in pg: - pg["initial_lr"] = pg["lr"] + if 'initial_lr' not in pg: + pg['initial_lr'] = pg['lr'] def _store(self, i: int) -> bool: """Store metamer, if appropriate. @@ -361,7 +330,7 @@ def _store(self, i: int) -> bool: """ if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs - self._saved_metamer.append(self.metamer.clone().to("cpu")) + self._saved_metamer.append(self.metamer.clone().to('cpu')) stored = True else: stored = False @@ -417,21 +386,13 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = [ - "_image", - "_target_representation", - "_metamer", - "_model", - "_saved_metamer", - ] + attrs = ['_image', '_target_representation', + '_metamer', '_model', '_saved_metamer'] super().to(*args, attrs=attrs, **kwargs) - def load( - self, - file_path: str, - map_location: str | None = None, - **pickle_load_args, - ): + def load(self, file_path: str, + map_location: Optional[str] = None, + **pickle_load_args): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Metamer`` object -- we will @@ -468,48 +429,33 @@ def load( """ self._load(file_path, map_location, **pickle_load_args) - def _load( - self, - file_path: str, - map_location: str | None = None, - additional_check_attributes: list[str] = [], - additional_check_loss_functions: list[str] = [], - **pickle_load_args, - ): + def _load(self, file_path: str, + map_location: Optional[str] = None, + additional_check_attributes: List[str] = [], + additional_check_loss_functions: List[str] = [], + **pickle_load_args): r"""Helper function for loading. Users interact with ``load`` (without the underscore), this is to allow subclasses to specify additional attributes or loss functions to check. """ - check_attributes = [ - "_image", - "_target_representation", - "_range_penalty_lambda", - "_allowed_range", - ] + check_attributes = ['_image', '_target_representation', + '_range_penalty_lambda', '_allowed_range'] check_attributes += additional_check_attributes - check_loss_functions = ["loss_function"] + check_loss_functions = ['loss_function'] check_loss_functions += additional_check_loss_functions - super().load( - file_path, - map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args, - ) + super().load(file_path, map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args) # make this require a grad again self.metamer.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if ( - len(self._saved_metamer) - and self._saved_metamer[0].device.type != "cpu" - ): - self._saved_metamer = [ - met.to("cpu") for met in self._saved_metamer - ] + if len(self._saved_metamer) and self._saved_metamer[0].device.type != 'cpu': + self._saved_metamer = [met.to('cpu') for met in self._saved_metamer] @property def model(self): @@ -573,7 +519,7 @@ class MetamerCTF(Metamer): scale separately (ignoring the others), then with respect to all of them at the end. (see ``Metamer`` tutorial for more details). - + Attributes ---------- target_representation : torch.Tensor @@ -603,63 +549,46 @@ class MetamerCTF(Metamer): scales_finished : list or None List of scales that we've finished optimizing. """ - - def __init__( - self, - image: Tensor, - model: torch.nn.Module, - loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, - range_penalty_lambda: float = 0.1, - allowed_range: tuple[float, float] = (0, 1), - initial_image: Tensor | None = None, - coarse_to_fine: Literal["together", "separate"] = "together", - ): - super().__init__( - image, - model, - loss_function, - range_penalty_lambda, - allowed_range, - initial_image, - ) + def __init__(self, image: Tensor, model: torch.nn.Module, + loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, + range_penalty_lambda: float = .1, + allowed_range: Tuple[float, float] = (0, 1), + initial_image: Optional[Tensor] = None, + coarse_to_fine: Literal['together', 'separate'] = 'together'): + super().__init__(image, model, loss_function, range_penalty_lambda, + allowed_range, initial_image) self._init_ctf(coarse_to_fine) - def _init_ctf(self, coarse_to_fine: Literal["together", "separate"]): + def _init_ctf(self, coarse_to_fine: Literal['together', 'separate']): """Initialize stuff related to coarse-to-fine.""" # this will hold the reduced representation of the target image. - if coarse_to_fine not in ["separate", "together"]: - raise ValueError( - f"Don't know how to handle value {coarse_to_fine}!" - " Must be one of: 'separate', 'together'" - ) + if coarse_to_fine not in ['separate', 'together']: + raise ValueError(f"Don't know how to handle value {coarse_to_fine}!" + " Must be one of: 'separate', 'together'") self._ctf_target_representation = None - validate_coarse_to_fine( - self.model, image_shape=self.image.shape, device=self.image.device - ) + validate_coarse_to_fine(self.model, image_shape=self.image.shape, + device=self.image.device) # if self.scales is not None, we're continuing a previous version # and want to continue. this list comprehension creates a new # object, so we don't modify model.scales self._scales = [i for i in self.model.scales[:-1]] - if coarse_to_fine == "separate": + if coarse_to_fine == 'separate': self._scales += [self.model.scales[-1]] - self._scales += ["all"] + self._scales += ['all'] self._scales_timing = dict((k, []) for k in self.scales) self._scales_timing[self.scales[0]].append(0) self._scales_loss = [] self._scales_finished = [] self._coarse_to_fine = coarse_to_fine - def synthesize( - self, - max_iter: int = 100, - optimizer: torch.optim.Optimizer | None = None, - scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, - store_progress: bool | int = False, - stop_criterion: float = 1e-4, - stop_iters_to_check: int = 50, - change_scale_criterion: float | None = 1e-2, - ctf_iters_to_check: int = 50, - ): + def synthesize(self, max_iter: int = 100, + optimizer: Optional[torch.optim.Optimizer] = None, + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, + store_progress: Union[bool, int] = False, + stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, + change_scale_criterion: Optional[float] = 1e-2, + ctf_iters_to_check: int = 50, + ): r"""Synthesize a metamer. Update the pixels of ``initial_image`` until its representation matches @@ -704,13 +633,9 @@ def synthesize( switch scales. """ - if (change_scale_criterion is not None) and ( - stop_criterion >= change_scale_criterion - ): - raise ValueError( - "stop_criterion must be strictly less than " - "change_scale_criterion, or things get weird!" - ) + if (change_scale_criterion is not None) and (stop_criterion >= change_scale_criterion): + raise ValueError("stop_criterion must be strictly less than " + "change_scale_criterion, or things get weird!") # initialize the optimizer and scheduler self._initialize_optimizer(optimizer, scheduler) @@ -718,6 +643,7 @@ def synthesize( # get ready to store progress self.store_progress = store_progress + pbar = tqdm(range(max_iter)) for i in pbar: @@ -725,27 +651,22 @@ def synthesize( # iterations and will be correct across calls to `synthesize` self._store(len(self.losses)) - loss = self._optimizer_step( - pbar, change_scale_criterion, ctf_iters_to_check - ) + loss = self._optimizer_step(pbar, change_scale_criterion, ctf_iters_to_check) if not torch.isfinite(loss): raise ValueError("Found a NaN in loss during optimization.") - if self._check_convergence( - i, stop_criterion, stop_iters_to_check, ctf_iters_to_check - ): + if self._check_convergence(i, stop_criterion, stop_iters_to_check, + ctf_iters_to_check): warnings.warn("Loss has converged, stopping synthesis") break pbar.close() - def _optimizer_step( - self, - pbar: tqdm, - change_scale_criterion: float, - ctf_iters_to_check: int, - ) -> Tensor: + def _optimizer_step(self, pbar: tqdm, + change_scale_criterion: float, + ctf_iters_to_check: int + ) -> Tensor: r"""Compute and propagate gradients, then step the optimizer to update metamer. Parameters @@ -774,31 +695,19 @@ def _optimizer_step( # has stopped declining and, if so, switch to the next scale. Then # we're checking if self.scales_loss is long enough to check # ctf_iters_to_check back. - if ( - len(self.scales) > 1 - and len(self.scales_loss) >= ctf_iters_to_check - ): + if len(self.scales) > 1 and len(self.scales_loss) >= ctf_iters_to_check: # Now we check whether loss has decreased less than # change_scale_criterion - if (change_scale_criterion is None) or abs( - self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check] - ) < change_scale_criterion: + if ((change_scale_criterion is None) or abs(self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check]) < change_scale_criterion): # and finally we check whether we've been optimizing this # scale for ctf_iters_to_check - if ( - len(self.losses) - self.scales_timing[self.scales[0]][0] - >= ctf_iters_to_check - ): - self._scales_timing[self.scales[0]].append( - len(self.losses) - 1 - ) + if len(self.losses) - self.scales_timing[self.scales[0]][0] >= ctf_iters_to_check: + self._scales_timing[self.scales[0]].append(len(self.losses)-1) self._scales_finished.append(self._scales.pop(0)) - self._scales_timing[self.scales[0]].append( - len(self.losses) - ) + self._scales_timing[self.scales[0]].append(len(self.losses)) # reset optimizer's lr. for pg in self.optimizer.param_groups: - pg["lr"] = pg["initial_lr"] + pg['lr'] = pg['initial_lr'] # reset ctf target representation, so we update it on # next pass self._ctf_target_representation = None @@ -806,33 +715,28 @@ def _optimizer_step( self._scales_loss.append(loss.item()) self._losses.append(overall_loss.item()) - grad_norm = torch.linalg.vector_norm( - self.metamer.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, + dim=None) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm( - self.metamer - last_iter_metamer, ord=2, dim=None - ) + pixel_change_norm = torch.linalg.vector_norm(self.metamer - last_iter_metamer, + ord=2, dim=None) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict( - loss=f"{overall_loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]["lr"], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}", - current_scale=self.scales[0], - current_scale_loss=f"{loss.item():.04e}", - ) - ) + OrderedDict(loss=f"{overall_loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]['lr'], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + current_scale=self.scales[0], + current_scale_loss=f'{loss.item():.04e}')) return overall_loss - def _closure(self) -> tuple[Tensor, Tensor]: + def _closure(self) -> Tuple[Tensor, Tensor]: r"""An abstraction of the gradient calculation, before the optimization step. This enables optimization algorithms that perform several evaluations @@ -859,12 +763,12 @@ def _closure(self) -> tuple[Tensor, Tensor]: self.optimizer.zero_grad() analyze_kwargs = {} # if we've reached 'all', we use the full model - if self.scales[0] != "all": - analyze_kwargs["scales"] = [self.scales[0]] + if self.scales[0] != 'all': + analyze_kwargs['scales'] = [self.scales[0]] # if 'together', then we also want all the coarser # scales - if self.coarse_to_fine == "together": - analyze_kwargs["scales"] += self.scales_finished + if self.coarse_to_fine == 'together': + analyze_kwargs['scales'] += self.scales_finished metamer_representation = self.model(self.metamer, **analyze_kwargs) # if analyze_kwargs is empty, we can just compare # metamer_representation against our cached target_representation @@ -888,13 +792,9 @@ def _closure(self) -> tuple[Tensor, Tensor]: return loss, overall_loss - def _check_convergence( - self, - i: int, - stop_criterion: float, - stop_iters_to_check: int, - ctf_iters_to_check: int, - ) -> bool: + def _check_convergence(self, i: int, stop_criterion: float, + stop_iters_to_check: int, + ctf_iters_to_check: int) -> bool: r"""Check whether the loss has stabilized and whether we've synthesized all scales. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -937,12 +837,9 @@ def _check_convergence( loss_conv = loss_convergence(self, stop_criterion, stop_iters_to_check) return loss_conv and coarse_to_fine_enough(self, i, ctf_iters_to_check) - def load( - self, - file_path: str, - map_location: str | None = None, - **pickle_load_args, - ): + def load(self, file_path: str, + map_location: Optional[str] = None, + **pickle_load_args): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Metamer`` object -- we will @@ -977,9 +874,8 @@ def load( *then* load. """ - super()._load( - file_path, map_location, ["_coarse_to_fine"], **pickle_load_args - ) + super()._load(file_path, map_location, ['_coarse_to_fine'], + **pickle_load_args) @property def coarse_to_fine(self): @@ -1002,12 +898,10 @@ def scales_finished(self): return tuple(self._scales_finished) -def plot_loss( - metamer: Metamer, - iteration: int | None = None, - ax: mpl.axes.Axes | None = None, - **kwargs, -) -> mpl.axes.Axes: +def plot_loss(metamer: Metamer, + iteration: Optional[int] = None, + ax: Optional[mpl.axes.Axes] = None, + **kwargs) -> mpl.axes.Axes: """Plot synthesis loss with log-scaled y axis. Plots ``metamer.losses`` over all iterations. Also plots a red dot at @@ -1045,23 +939,21 @@ def plot_loss( ax = plt.gca() ax.semilogy(metamer.losses, **kwargs) try: - ax.scatter(loss_idx, metamer.losses[loss_idx], c="r") + ax.scatter(loss_idx, metamer.losses[loss_idx], c='r') except IndexError: # then there's no loss here pass - ax.set(xlabel="Synthesis iteration", ylabel="Loss") + ax.set(xlabel='Synthesis iteration', ylabel='Loss') return ax -def display_metamer( - metamer: Metamer, - batch_idx: int = 0, - channel_idx: int | None = None, - zoom: float | None = None, - iteration: int | None = None, - ax: mpl.axes.Axes | None = None, - **kwargs, -) -> mpl.axes.Axes: +def display_metamer(metamer: Metamer, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + zoom: Optional[float] = None, + iteration: Optional[int] = None, + ax: Optional[mpl.axes.Axes] = None, + **kwargs) -> mpl.axes.Axes: """Display metamer. You can specify what iteration to view by using the ``iteration`` arg. @@ -1114,24 +1006,17 @@ def display_metamer( as_rgb = False if ax is None: ax = plt.gca() - display.imshow( - image, - ax=ax, - title="Metamer", - zoom=zoom, - batch_idx=batch_idx, - channel_idx=channel_idx, - as_rgb=as_rgb, - **kwargs, - ) + display.imshow(image, ax=ax, title='Metamer', zoom=zoom, + batch_idx=batch_idx, channel_idx=channel_idx, + as_rgb=as_rgb, **kwargs) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) return ax -def _representation_error( - metamer: Metamer, iteration: int | None = None, **kwargs -) -> Tensor: +def _representation_error(metamer: Metamer, + iteration: Optional[int] = None, + **kwargs) -> Tensor: r"""Get the representation error. This is ``metamer.model(metamer) - target_representation)``. If @@ -1154,25 +1039,19 @@ def _representation_error( """ if iteration is not None: - metamer_rep = metamer.model( - metamer.saved_metamer[iteration].to( - metamer.target_representation.device - ) - ) + metamer_rep = metamer.model(metamer.saved_metamer[iteration].to(metamer.target_representation.device)) else: metamer_rep = metamer.model(metamer.metamer, **kwargs) return metamer_rep - metamer.target_representation -def plot_representation_error( - metamer: Metamer, - batch_idx: int = 0, - iteration: int | None = None, - ylim: tuple[float, float] | None | Literal[False] = None, - ax: mpl.axes.Axes | None = None, - as_rgb: bool = False, - **kwargs, -) -> list[mpl.axes.Axes]: +def plot_representation_error(metamer: Metamer, + batch_idx: int = 0, + iteration: Optional[int] = None, + ylim: Union[Tuple[float, float], None, Literal[False]] = None, + ax: Optional[mpl.axes.Axes] = None, + as_rgb: bool = False, + **kwargs) -> List[mpl.axes.Axes]: r"""Plot distance ratio showing how close we are to convergence. We plot ``_representation_error(metamer, iteration)``. For more details, see @@ -1209,31 +1088,22 @@ def plot_representation_error( List of created axes """ - representation_error = _representation_error( - metamer=metamer, iteration=iteration, **kwargs - ) + representation_error = _representation_error(metamer=metamer, + iteration=iteration, **kwargs) if ax is None: ax = plt.gca() - return display.plot_representation( - metamer.model, - representation_error, - ax, - title="Representation error", - ylim=ylim, - batch_idx=batch_idx, - as_rgb=as_rgb, - ) - - -def plot_pixel_values( - metamer: Metamer, - batch_idx: int = 0, - channel_idx: int | None = None, - iteration: int | None = None, - ylim: tuple[float, float] | Literal[False] = False, - ax: mpl.axes.Axes | None = None, - **kwargs, -) -> mpl.axes.Axes: + return display.plot_representation(metamer.model, representation_error, ax, + title="Representation error", ylim=ylim, + batch_idx=batch_idx, as_rgb=as_rgb) + + +def plot_pixel_values(metamer: Metamer, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + ylim: Union[Tuple[float, float], Literal[False]] = False, + ax: Optional[mpl.axes.Axes] = None, + **kwargs) -> mpl.axes.Axes: r"""Plot histogram of pixel values of target image and its metamer. As a way to check the distributions of pixel intensities and see @@ -1265,12 +1135,11 @@ def plot_pixel_values( Created axes. """ - def _freedman_diaconis_bins(a): """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) - iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] + iqr = np.diff(np.percentile(a, [.25, .75]))[0] if len(a) < 2: return 1 h = 2 * iqr / (len(a) ** (1 / 3)) @@ -1280,7 +1149,7 @@ def _freedman_diaconis_bins(a): else: return int(np.ceil((a.max() - a.min()) / h)) - kwargs.setdefault("alpha", 0.4) + kwargs.setdefault('alpha', .4) if iteration is None: met = metamer.metamer[batch_idx] else: @@ -1293,18 +1162,10 @@ def _freedman_diaconis_bins(a): ax = plt.gca() image = data.to_numpy(image).flatten() met = data.to_numpy(met).flatten() - ax.hist( - met, - bins=min(_freedman_diaconis_bins(image), 50), - label="metamer", - **kwargs, - ) - ax.hist( - image, - bins=min(_freedman_diaconis_bins(image), 50), - label="target image", - **kwargs, - ) + ax.hist(met, bins=min(_freedman_diaconis_bins(image), 50), + label='metamer', **kwargs) + ax.hist(image, bins=min(_freedman_diaconis_bins(image), 50), + label='target image', **kwargs) ax.legend() if ylim: ax.set_ylim(ylim) @@ -1312,9 +1173,8 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots( - to_check: list[str] | dict[str, float], to_check_name: str -): +def _check_included_plots(to_check: Union[List[str], Dict[str, float]], + to_check_name: str): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -1331,39 +1191,28 @@ def _check_included_plots( Name of the `to_check` variable, used in the error message. """ - allowed_vals = [ - "display_metamer", - "plot_loss", - "plot_representation_error", - "plot_pixel_values", - "misc", - ] + allowed_vals = ['display_metamer', 'plot_loss', 'plot_representation_error', + 'plot_pixel_values', 'misc'] try: vals = to_check.keys() except AttributeError: vals = to_check not_allowed = [v for v in vals if v not in allowed_vals] if not_allowed: - raise ValueError( - f"{to_check_name} contained value(s) {not_allowed}! " - f"Only {allowed_vals} are permissible!" - ) - - -def _setup_synthesis_fig( - fig: mpl.figure.Figure | None = None, - axes_idx: dict[str, int] = {}, - figsize: tuple[float, float] | None = None, - included_plots: list[str] = [ - "display_metamer", - "plot_loss", - "plot_representation_error", - ], - display_metamer_width: float = 1, - plot_loss_width: float = 1, - plot_representation_error_width: float = 1, - plot_pixel_values_width: float = 1, -) -> tuple[mpl.figure.Figure, list[mpl.axes.Axes], dict[str, int]]: + raise ValueError(f'{to_check_name} contained value(s) {not_allowed}! ' + f'Only {allowed_vals} are permissible!') + + +def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float, float]] = None, + included_plots: List[str] = ['display_metamer', + 'plot_loss', + 'plot_representation_error'], + display_metamer_width: float = 1, + plot_loss_width: float = 1, + plot_representation_error_width: float = 1, + plot_pixel_values_width: float = 1) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -1420,79 +1269,68 @@ def _setup_synthesis_fig( if "display_metamer" in included_plots: n_subplots += 1 width_ratios.append(display_metamer_width) - if "display_metamer" not in axes_idx.keys(): - axes_idx["display_metamer"] = data._find_min_int(axes_idx.values()) + if 'display_metamer' not in axes_idx.keys(): + axes_idx['display_metamer'] = data._find_min_int(axes_idx.values()) if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if "plot_loss" not in axes_idx.keys(): - axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) + if 'plot_loss' not in axes_idx.keys(): + axes_idx['plot_loss'] = data._find_min_int(axes_idx.values()) if "plot_representation_error" in included_plots: n_subplots += 1 width_ratios.append(plot_representation_error_width) - if "plot_representation_error" not in axes_idx.keys(): - axes_idx["plot_representation_error"] = data._find_min_int( - axes_idx.values() - ) + if 'plot_representation_error' not in axes_idx.keys(): + axes_idx['plot_representation_error'] = data._find_min_int(axes_idx.values()) if "plot_pixel_values" in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if "plot_pixel_values" not in axes_idx.keys(): - axes_idx["plot_pixel_values"] = data._find_min_int( - axes_idx.values() - ) + if 'plot_pixel_values' not in axes_idx.keys(): + axes_idx['plot_pixel_values'] = data._find_min_int(axes_idx.values()) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: # we want (5, 5) for each subplot, with a bit of room between # each subplot - figsize = ((width_ratios * 5).sum() + width_ratios.sum() - 1, 5) + figsize = ((width_ratios*5).sum() + width_ratios.sum()-1, 5) width_ratios = width_ratios / width_ratios.sum() - fig, axes = plt.subplots( - 1, - n_subplots, - figsize=figsize, - gridspec_kw={"width_ratios": width_ratios}, - ) + fig, axes = plt.subplots(1, n_subplots, figsize=figsize, + gridspec_kw={'width_ratios': width_ratios}) if n_subplots == 1: axes = [axes] else: axes = fig.axes # make sure misc contains all the empty axes - misc_axes = axes_idx.get("misc", []) - if not hasattr(misc_axes, "__iter__"): + misc_axes = axes_idx.get('misc', []) + if not hasattr(misc_axes, '__iter__'): misc_axes = [misc_axes] all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, "__iter__"): + if hasattr(i, '__iter__'): all_axes.extend(i) else: all_axes.append(i) misc_axes += [i for i, _ in enumerate(fig.axes) if i not in all_axes] - axes_idx["misc"] = misc_axes + axes_idx['misc'] = misc_axes return fig, axes, axes_idx -def plot_synthesis_status( - metamer: Metamer, - batch_idx: int = 0, - channel_idx: int | None = None, - iteration: int | None = None, - ylim: tuple[float, float] | None | Literal[False] = None, - vrange: tuple[float, float] | str = "indep1", - zoom: float | None = None, - plot_representation_error_as_rgb: bool = False, - fig: mpl.figure.Figure | None = None, - axes_idx: dict[str, int] = {}, - figsize: tuple[float, float] | None = None, - included_plots: list[str] = [ - "display_metamer", - "plot_loss", - "plot_representation_error", - ], - width_ratios: dict[str, float] = {}, -) -> tuple[mpl.figure.Figure, dict[str, int]]: +def plot_synthesis_status(metamer: Metamer, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + ylim: Union[Tuple[float, float], None, Literal[False]] = None, + vrange: Union[Tuple[float, float], str] = 'indep1', + zoom: Optional[float] = None, + plot_representation_error_as_rgb: bool = False, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float, float]] = None, + included_plots: List[str] = ['display_metamer', + 'plot_loss', + 'plot_representation_error'], + width_ratios: Dict[str, float] = {}, + ) -> Tuple[mpl.figure.Figure, Dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create three @@ -1572,23 +1410,19 @@ def plot_synthesis_status( """ if iteration is not None and not metamer.store_progress: - raise ValueError( - "synthesis() was run with store_progress=False, " - "cannot specify which iteration to plot (only" - " last one, with iteration=None)" - ) + raise ValueError("synthesis() was run with store_progress=False, " + "cannot specify which iteration to plot (only" + " last one, with iteration=None)") if metamer.metamer.ndim not in [3, 4]: - raise ValueError( - "plot_synthesis_status() expects 3 or 4d data;" - "unexpected behavior will result otherwise!" - ) - _check_included_plots(included_plots, "included_plots") - _check_included_plots(width_ratios, "width_ratios") - _check_included_plots(axes_idx, "axes_idx") - width_ratios = {f"{k}_width": v for k, v in width_ratios.items()} - fig, axes, axes_idx = _setup_synthesis_fig( - fig, axes_idx, figsize, included_plots, **width_ratios - ) + raise ValueError("plot_synthesis_status() expects 3 or 4d data;" + "unexpected behavior will result otherwise!") + _check_included_plots(included_plots, 'included_plots') + _check_included_plots(width_ratios, 'width_ratios') + _check_included_plots(axes_idx, 'axes_idx') + width_ratios = {f'{k}_width': v for k, v in width_ratios.items()} + fig, axes, axes_idx = _setup_synthesis_fig(fig, axes_idx, figsize, + included_plots, + **width_ratios) def check_iterables(i, vals): for j in vals: @@ -1602,64 +1436,48 @@ def check_iterables(i, vals): return True if "display_metamer" in included_plots: - display_metamer( - metamer, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx["display_metamer"]], - zoom=zoom, - vrange=vrange, - ) + display_metamer(metamer, batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx['display_metamer']], + zoom=zoom, vrange=vrange) if "plot_loss" in included_plots: - plot_loss(metamer, iteration=iteration, ax=axes[axes_idx["plot_loss"]]) + plot_loss(metamer, iteration=iteration, ax=axes[axes_idx['plot_loss']]) if "plot_representation_error" in included_plots: - plot_representation_error( - metamer, - batch_idx=batch_idx, - iteration=iteration, - ax=axes[axes_idx["plot_representation_error"]], - ylim=ylim, - as_rgb=plot_representation_error_as_rgb, - ) + plot_representation_error(metamer, batch_idx=batch_idx, + iteration=iteration, + ax=axes[axes_idx['plot_representation_error']], + ylim=ylim, + as_rgb=plot_representation_error_as_rgb) # this can add a bunch of axes, so this will try and figure # them out - new_axes = [ - i - for i, _ in enumerate(fig.axes) - if not check_iterables(i, axes_idx.values()) - ] + [axes_idx["plot_representation_error"]] - axes_idx["plot_representation_error"] = new_axes + new_axes = [i for i, _ in enumerate(fig.axes) if not + check_iterables(i, axes_idx.values())] + [axes_idx['plot_representation_error']] + axes_idx['plot_representation_error'] = new_axes if "plot_pixel_values" in included_plots: - plot_pixel_values( - metamer, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx["plot_pixel_values"]], - ) + plot_pixel_values(metamer, batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx['plot_pixel_values']]) return fig, axes_idx -def animate( - metamer: Metamer, - framerate: int = 10, - batch_idx: int = 0, - channel_idx: int | None = None, - ylim: str | None | tuple[float, float] | Literal[False] = None, - vrange: tuple[float, float] | str = (0, 1), - zoom: float | None = None, - plot_representation_error_as_rgb: bool = False, - fig: mpl.figure.Figure | None = None, - axes_idx: dict[str, int] = {}, - figsize: tuple[float, float] | None = None, - included_plots: list[str] = [ - "display_metamer", - "plot_loss", - "plot_representation_error", - ], - width_ratios: dict[str, float] = {}, -) -> mpl.animation.FuncAnimation: +def animate(metamer: Metamer, + framerate: int = 10, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + ylim: Union[str, None, Tuple[float, float], Literal[False]] = None, + vrange: Union[Tuple[float, float], str] = (0, 1), + zoom: Optional[float] = None, + plot_representation_error_as_rgb: bool = False, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float, float]] = None, + included_plots: List[str] = ['display_metamer', + 'plot_loss', + 'plot_representation_error'], + width_ratios: Dict[str, float] = {}, + ) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. This is essentially the figure produced by @@ -1765,150 +1583,119 @@ def animate( """ if not metamer.store_progress: - raise ValueError( - "synthesize() was run with store_progress=False," - " cannot animate!" - ) + raise ValueError("synthesize() was run with store_progress=False," + " cannot animate!") if metamer.metamer.ndim not in [3, 4]: - raise ValueError( - "animate() expects 3 or 4d data; unexpected" - " behavior will result otherwise!" - ) - _check_included_plots(included_plots, "included_plots") - _check_included_plots(width_ratios, "width_ratios") - _check_included_plots(axes_idx, "axes_idx") + raise ValueError("animate() expects 3 or 4d data; unexpected" + " behavior will result otherwise!") + _check_included_plots(included_plots, 'included_plots') + _check_included_plots(width_ratios, 'width_ratios') + _check_included_plots(axes_idx, 'axes_idx') if metamer.target_representation.ndimension() == 4: # we have to do this here so that we set the # ylim_rescale_interval such that we never rescale ylim # (rescaling ylim messes up an image axis) ylim = False try: - if ylim.startswith("rescale"): + if ylim.startswith('rescale'): try: - ylim_rescale_interval = int(ylim.replace("rescale", "")) + ylim_rescale_interval = int(ylim.replace('rescale', '')) except ValueError: # then there's nothing we can convert to an int there - ylim_rescale_interval = int( - (metamer.saved_metamer.shape[0] - 1) // 10 - ) + ylim_rescale_interval = int((metamer.saved_metamer.shape[0] - 1) // 10) if ylim_rescale_interval == 0: - ylim_rescale_interval = int( - metamer.saved_metamer.shape[0] - 1 - ) + ylim_rescale_interval = int(metamer.saved_metamer.shape[0] - 1) ylim = None else: raise ValueError("Don't know how to handle ylim %s!" % ylim) except AttributeError: # this way we'll never rescale - ylim_rescale_interval = len(metamer.saved_metamer) + 1 + ylim_rescale_interval = len(metamer.saved_metamer)+1 # we run plot_synthesis_status to initialize the figure if either fig is # None or if there are no titles on any axes, which we assume means that # it's an empty figure if fig is None or not any([ax.get_title() for ax in fig.axes]): - fig, axes_idx = plot_synthesis_status( - metamer=metamer, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=0, - figsize=figsize, - ylim=ylim, - vrange=vrange, - zoom=zoom, - fig=fig, - axes_idx=axes_idx, - included_plots=included_plots, - plot_representation_error_as_rgb=plot_representation_error_as_rgb, - width_ratios=width_ratios, - ) + fig, axes_idx = plot_synthesis_status(metamer=metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=0, figsize=figsize, + ylim=ylim, vrange=vrange, + zoom=zoom, fig=fig, + axes_idx=axes_idx, + included_plots=included_plots, + plot_representation_error_as_rgb=plot_representation_error_as_rgb, + width_ratios=width_ratios) # grab the artist for the second plot (we don't need to do this for the # metamer or representation plot, because we use the update_plot # function for that) - if "plot_loss" in included_plots: - scat = fig.axes[axes_idx["plot_loss"]].collections[0] + if 'plot_loss' in included_plots: + scat = fig.axes[axes_idx['plot_loss']].collections[0] # can have multiple plots - if "plot_representation_error" in included_plots: + if 'plot_representation_error' in included_plots: try: - rep_error_axes = [ - fig.axes[i] for i in axes_idx["plot_representation_error"] - ] + rep_error_axes = [fig.axes[i] for i in axes_idx['plot_representation_error']] except TypeError: # in this case, axes_idx['plot_representation_error'] is not iterable and so is # a single value - rep_error_axes = [fig.axes[axes_idx["plot_representation_error"]]] + rep_error_axes = [fig.axes[axes_idx['plot_representation_error']]] else: rep_error_axes = [] # can also have multiple plots if metamer.target_representation.ndimension() == 4: - if "plot_representation_error" in included_plots: - warnings.warn( - "Looks like representation is image-like, haven't fully thought out how" - " to best handle rescaling color ranges yet!" - ) + if 'plot_representation_error' in included_plots: + warnings.warn("Looks like representation is image-like, haven't fully thought out how" + " to best handle rescaling color ranges yet!") # replace the bit of the title that specifies the range, # since we don't make any promises about that. we have to do # this here because we need the figure to have been created for ax in rep_error_axes: - ax.set_title(re.sub(r"\n range: .* \n", "\n\n", ax.get_title())) + ax.set_title(re.sub(r'\n range: .* \n', '\n\n', ax.get_title())) def movie_plot(i): artists = [] - if "display_metamer" in included_plots: - artists.extend( - display.update_plot( - fig.axes[axes_idx["display_metamer"]], - data=metamer.saved_metamer[i], - batch_idx=batch_idx, - ) - ) - if "plot_representation_error" in included_plots: - rep_error = _representation_error(metamer, iteration=i) + if 'display_metamer' in included_plots: + artists.extend(display.update_plot(fig.axes[axes_idx['display_metamer']], + data=metamer.saved_metamer[i], + batch_idx=batch_idx)) + if 'plot_representation_error' in included_plots: + rep_error = _representation_error(metamer, + iteration=i) # we pass rep_error_axes to update, and we've grabbed # the right things above - artists.extend( - display.update_plot( - rep_error_axes, - batch_idx=batch_idx, - model=metamer.model, - data=rep_error, - ) - ) + artists.extend(display.update_plot(rep_error_axes, + batch_idx=batch_idx, + model=metamer.model, + data=rep_error)) # again, we know that rep_error_axes contains all the axes # with the representation ratio info - if ((i + 1) % ylim_rescale_interval) == 0: + if ((i+1) % ylim_rescale_interval) == 0: if metamer.target_representation.ndimension() == 3: - display.rescale_ylim(rep_error_axes, rep_error) - if "plot_pixel_values" in included_plots: + display.rescale_ylim(rep_error_axes, + rep_error) + if 'plot_pixel_values' in included_plots: # this is the dumbest way to do this, but it's simple -- # clearing the axes can cause problems if the user has, for # example, changed the tick locator or formatter. not sure how # to handle this best right now - fig.axes[axes_idx["plot_pixel_values"]].clear() - plot_pixel_values( - metamer, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=i, - ax=fig.axes[axes_idx["plot_pixel_values"]], - ) - if "plot_loss" in included_plots: + fig.axes[axes_idx['plot_pixel_values']].clear() + plot_pixel_values(metamer, batch_idx=batch_idx, + channel_idx=channel_idx, iteration=i, + ax=fig.axes[axes_idx['plot_pixel_values']]) + if 'plot_loss'in included_plots: # loss always contains values from every iteration, but everything # else will be subsampled. - x_val = i * metamer.store_progress + x_val = i*metamer.store_progress scat.set_offsets((x_val, metamer.losses[x_val])) artists.append(scat) # as long as blitting is True, need to return a sequence of artists return artists # don't need an init_func, since we handle initialization ourselves - anim = mpl.animation.FuncAnimation( - fig, - movie_plot, - frames=len(metamer.saved_metamer), - blit=True, - interval=1000.0 / framerate, - repeat=False, - ) + anim = mpl.animation.FuncAnimation(fig, movie_plot, + frames=len(metamer.saved_metamer), + blit=True, interval=1000./framerate, + repeat=False) plt.close(fig) return anim diff --git a/src/plenoptic/synthesize/simple_metamer.py b/src/plenoptic/synthesize/simple_metamer.py index db857b3a..fd6b8f8a 100644 --- a/src/plenoptic/synthesize/simple_metamer.py +++ b/src/plenoptic/synthesize/simple_metamer.py @@ -1,12 +1,11 @@ """Simple Metamer Class """ - import torch from tqdm.auto import tqdm - -from ..tools import optim -from ..tools.validate import validate_input, validate_model from .synthesis import Synthesis +from ..tools.validate import validate_input, validate_model +from ..tools import optim +from typing import Union class SimpleMetamer(Synthesis): @@ -30,12 +29,8 @@ class SimpleMetamer(Synthesis): """ def __init__(self, image: torch.Tensor, model: torch.nn.Module): - validate_model( - model, - image_shape=image.shape, - image_dtype=image.dtype, - device=image.device, - ) + validate_model(model, image_shape=image.shape, image_dtype=image.dtype, + device=image.device) self.model = model validate_input(image) self.image = image @@ -44,11 +39,8 @@ def __init__(self, image: torch.Tensor, model: torch.nn.Module): self.optimizer = None self.losses = [] - def synthesize( - self, - max_iter: int = 100, - optimizer: None | torch.optim.Optimizer = None, - ) -> torch.Tensor: + def synthesize(self, max_iter: int = 100, + optimizer: Union[None, torch.optim.Optimizer] = None) -> torch.Tensor: """Synthesize a simple metamer. If called multiple times, will continue where we left off. @@ -70,9 +62,8 @@ def synthesize( """ if optimizer is None: if self.optimizer is None: - self.optimizer = torch.optim.Adam( - [self.metamer], lr=0.01, amsgrad=True - ) + self.optimizer = torch.optim.Adam([self.metamer], + lr=.01, amsgrad=True) else: self.optimizer = optimizer @@ -87,10 +78,10 @@ def closure(): # function. You could theoretically also just clamp metamer on # each step of the iteration, but the penalty in the loss seems # to work better in practice - loss = optim.mse( - metamer_representation, self.target_representation - ) - loss = loss + 0.1 * optim.penalize_range(self.metamer, (0, 1)) + loss = optim.mse(metamer_representation, + self.target_representation) + loss = loss + .1 * optim.penalize_range(self.metamer, + (0, 1)) self.losses.append(loss.item()) loss.backward(retain_graph=False) pbar.set_postfix(loss=loss.item()) @@ -109,7 +100,8 @@ def save(self, file_path: str): """ super().save(file_path, attrs=None) - def load(self, file_path: str, map_location: str | None = None): + def load(self, file_path: str, + map_location: Union[str, None] = None): r"""Load all relevant attributes from a .pt file. Note this operates in place and so doesn't return anything. @@ -119,12 +111,9 @@ def load(self, file_path: str, map_location: str | None = None): file_path The path to load the synthesis object from """ - check_attributes = ["target_representation", "image"] - super().load( - file_path, - check_attributes=check_attributes, - map_location=map_location, - ) + check_attributes = ['target_representation', 'image'] + super().load(file_path, check_attributes=check_attributes, + map_location=map_location) def to(self, *args, **kwargs): r"""Move and/or cast the parameters and buffers. @@ -157,6 +146,7 @@ def to(self, *args, **kwargs): Returns: Module: self """ - attrs = ["model", "image", "target_representation", "metamer"] + attrs = ['model', 'image', 'target_representation', + 'metamer'] super().to(*args, attrs=attrs, **kwargs) return self diff --git a/src/plenoptic/synthesize/synthesis.py b/src/plenoptic/synthesize/synthesis.py index cc18555c..8c52dd8c 100644 --- a/src/plenoptic/synthesize/synthesis.py +++ b/src/plenoptic/synthesize/synthesis.py @@ -1,8 +1,8 @@ """abstract synthesis super-class.""" import abc import warnings - import torch +from typing import Optional, List, Tuple, Union class Synthesis(abc.ABC): @@ -20,7 +20,7 @@ def synthesize(self): r"""Synthesize something.""" pass - def save(self, file_path: str, attrs: list[str] | None = None): + def save(self, file_path: str, attrs: Optional[List[str]] = None): r"""Save all relevant (non-model) variables in .pt file. If you leave attrs as None, we grab vars(self) and exclude 'model'. @@ -40,16 +40,14 @@ def save(self, file_path: str, attrs: list[str] | None = None): # this copies the attributes dict so we don't actually remove the # model attribute in the next line attrs = {k: v for k, v in vars(self).items()} - attrs.pop("_model", None) + attrs.pop('_model', None) save_dict = {} for k in attrs: - if k == "_model": - warnings.warn( - "Models can be quite large and they don't change" - " over synthesis. Please be sure that you " - "actually want to save the model." - ) + if k == '_model': + warnings.warn("Models can be quite large and they don't change" + " over synthesis. Please be sure that you " + "actually want to save the model.") attr = getattr(self, k) # detaching the tensors avoids some headaches like the # tensors having extra hooks or the like @@ -58,14 +56,11 @@ def save(self, file_path: str, attrs: list[str] | None = None): save_dict[k] = attr torch.save(save_dict, file_path) - def load( - self, - file_path: str, - map_location: str | None = None, - check_attributes: list[str] = [], - check_loss_functions: list[str] = [], - **pickle_load_args, - ): + def load(self, file_path: str, + map_location: Optional[str] = None, + check_attributes: List[str] = [], + check_loss_functions: List[str] = [], + **pickle_load_args): r"""Load all relevant attributes from a .pt file. This should be called by an initialized ``Synthesis`` object -- we will @@ -103,9 +98,9 @@ def load( ``torch.load``, see that function's docstring for details. """ - tmp_dict = torch.load( - file_path, map_location=map_location, **pickle_load_args - ) + tmp_dict = torch.load(file_path, + map_location=map_location, + **pickle_load_args) if map_location is not None: device = map_location else: @@ -121,60 +116,47 @@ def load( # the initial underscore. This is because this function # needs to be able to set the attribute, which can only be # done with the hidden version. - if k.startswith("_"): + if k.startswith('_'): display_k = k[1:] else: display_k = k if not hasattr(self, k): - raise AttributeError( - "All values of `check_attributes` should be " - "attributes set at initialization, but got " - f"attr {display_k}!" - ) + raise AttributeError("All values of `check_attributes` should be " + "attributes set at initialization, but got " + f"attr {display_k}!") if isinstance(getattr(self, k), torch.Tensor): # there are two ways this can fail -- the first is if they're # the same shape but different values and the second (in the # except block) are if they're different shapes. try: - if not torch.allclose( - getattr(self, k).to(tmp_dict[k].device), - tmp_dict[k], - rtol=5e-2, - ): - raise ValueError( - f"Saved and initialized {display_k} are " - f"different! Initialized: {getattr(self, k)}" - f", Saved: {tmp_dict[k]}, difference: " - f"{getattr(self, k) - tmp_dict[k]}" - ) + if not torch.allclose(getattr(self, k).to(tmp_dict[k].device), + tmp_dict[k], rtol=5e-2): + raise ValueError(f"Saved and initialized {display_k} are " + f"different! Initialized: {getattr(self, k)}" + f", Saved: {tmp_dict[k]}, difference: " + f"{getattr(self, k) - tmp_dict[k]}") except RuntimeError as e: # we end up here if dtype or shape don't match - if "The size of tensor a" in e.args[0]: - raise RuntimeError( - f"Attribute {display_k} have different shapes in" - " saved and initialized versions! Initialized" - f": {getattr(self, k).shape}, Saved: " - f"{tmp_dict[k].shape}" - ) - elif "did not match" in e.args[0]: - raise RuntimeError( - f"Attribute {display_k} has different dtype in " - "saved and initialized versions! Initialized" - f": {getattr(self, k).dtype}, Saved: " - f"{tmp_dict[k].dtype}" - ) + if 'The size of tensor a' in e.args[0]: + raise RuntimeError(f"Attribute {display_k} have different shapes in" + " saved and initialized versions! Initialized" + f": {getattr(self, k).shape}, Saved: " + f"{tmp_dict[k].shape}") + elif 'did not match' in e.args[0]: + raise RuntimeError(f"Attribute {display_k} has different dtype in " + "saved and initialized versions! Initialized" + f": {getattr(self, k).dtype}, Saved: " + f"{tmp_dict[k].dtype}") else: raise e else: if getattr(self, k) != tmp_dict[k]: - raise ValueError( - f"Saved and initialized {display_k} are different!" - f" Self: {getattr(self, k)}, " - f"Saved: {tmp_dict[k]}" - ) + raise ValueError(f"Saved and initialized {display_k} are different!" + f" Self: {getattr(self, k)}, " + f"Saved: {tmp_dict[k]}") for k in check_loss_functions: # same as above - if k.startswith("_"): + if k.startswith('_'): display_k = k[1:] else: display_k = k @@ -183,22 +165,20 @@ def load( saved_loss = tmp_dict[k](tensor_a, tensor_b) init_loss = getattr(self, k)(tensor_a, tensor_b) if not torch.allclose(saved_loss, init_loss, rtol=1e-2): - raise ValueError( - f"Saved and initialized {display_k} are " - "different! On two random tensors: " - f"Initialized: {init_loss}, Saved: " - f"{saved_loss}, difference: " - f"{init_loss-saved_loss}" - ) + raise ValueError(f"Saved and initialized {display_k} are " + "different! On two random tensors: " + f"Initialized: {init_loss}, Saved: " + f"{saved_loss}, difference: " + f"{init_loss-saved_loss}") for k, v in tmp_dict.items(): setattr(self, k, v) @abc.abstractmethod - def to(self, *args, attrs: list[str] = [], **kwargs): + def to(self, *args, attrs: List[str] = [], **kwargs): r"""Moves and/or casts the parameters and buffers. Similar to ``save``, this is an abstract method only because you need to define the attributes to call to on. - + This can be called as .. function:: to(device=None, dtype=None, non_blocking=False) .. function:: to(dtype, non_blocking=False) @@ -230,19 +210,13 @@ def to(self, *args, attrs: list[str] = [], **kwargs): except AttributeError: warnings.warn("model has no `to` method, so we leave it as is...") - device, dtype, non_blocking, memory_format = torch._C._nn._parse_to( - *args, **kwargs - ) + device, dtype, non_blocking, memory_format = torch._C._nn._parse_to(*args, **kwargs) def move(a, k): move_device = None if k.startswith("saved_") else device if memory_format is not None and a.dim() == 4: - return a.to( - move_device, - dtype, - non_blocking, - memory_format=memory_format, - ) + return a.to(move_device, dtype, non_blocking, + memory_format=memory_format) else: return a.to(move_device, dtype, non_blocking) @@ -265,12 +239,10 @@ class OptimizedSynthesis(Synthesis): these will use an optimizer object to iteratively update their output. """ - - def __init__( - self, - range_penalty_lambda: float = 0.1, - allowed_range: tuple[float, float] = (0, 1), - ): + def __init__(self, + range_penalty_lambda: float = .1, + allowed_range: Tuple[float, float] = (0, 1), + ): """Initialize the properties of OptimizedSynthesis.""" self._losses = [] self._gradient_norm = [] @@ -324,12 +296,10 @@ def _closure(self) -> torch.Tensor: loss.backward(retain_graph=False) return loss - def _initialize_optimizer( - self, - optimizer: torch.optim.Optimizer | None, - synth_name: str, - learning_rate: float = 0.01, - ): + def _initialize_optimizer(self, + optimizer: Optional[torch.optim.Optimizer], + synth_name: str, + learning_rate: float = .01): """Initialize optimizer. First time this is called, optimizer can be: @@ -349,20 +319,15 @@ def _initialize_optimizer( synth_attr = getattr(self, synth_name) if optimizer is None: if self.optimizer is None: - self._optimizer = torch.optim.Adam( - [synth_attr], lr=learning_rate, amsgrad=True - ) + self._optimizer = torch.optim.Adam([synth_attr], + lr=learning_rate, amsgrad=True) else: if self.optimizer is not None: - raise TypeError( - "When resuming synthesis, optimizer arg must be None!" - ) - params = optimizer.param_groups[0]["params"] + raise TypeError("When resuming synthesis, optimizer arg must be None!") + params = optimizer.param_groups[0]['params'] if len(params) != 1 or not torch.equal(params[0], synth_attr): - raise ValueError( - f"For {synth_name} synthesis, optimizer must have one " - f"parameter, the {synth_name} we're synthesizing." - ) + raise ValueError(f"For {synth_name} synthesis, optimizer must have one " + f"parameter, the {synth_name} we're synthesizing.") self._optimizer = optimizer @property @@ -393,7 +358,7 @@ def store_progress(self): return self._store_progress @store_progress.setter - def store_progress(self, store_progress: bool | int): + def store_progress(self, store_progress: Union[bool, int]): """Initialize store_progress. Sets the ``self.store_progress`` attribute, as well as changing the @@ -413,23 +378,19 @@ def store_progress(self, store_progress: bool | int): if store_progress: if store_progress is True: store_progress = 1 - if ( - self.store_progress is not None - and store_progress != self.store_progress - ): + if self.store_progress is not None and store_progress != self.store_progress: # we require store_progress to be the same because otherwise the # subsampling relationship between attrs that are stored every # iteration (loss, gradient, etc) and those that are stored every # store_progress iteration (e.g., saved_metamer) changes partway # through and that's annoying - raise Exception( - "If you've already run synthesize() before, must " - "re-run it with same store_progress arg. You " - f"passed {store_progress} instead of " - f"{self.store_progress} (True is equivalent to 1)" - ) + raise Exception("If you've already run synthesize() before, must " + "re-run it with same store_progress arg. You " + f"passed {store_progress} instead of " + f"{self.store_progress} (True is equivalent to 1)") self._store_progress = store_progress @property def optimizer(self): return self._optimizer + diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index e02d1c9c..2c815b31 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,10 +1,12 @@ -from . import validate -from .conv import * from .data import * -from .display import * -from .external import * -from .optim import * +from .conv import * from .signal import * from .stats import * +from .display import * from .straightness import * + +from .optim import * +from .external import * from .validate import remove_grad + +from . import validate diff --git a/src/plenoptic/tools/conv.py b/src/plenoptic/tools/conv.py index cc4ae6eb..70832efd 100644 --- a/src/plenoptic/tools/conv.py +++ b/src/plenoptic/tools/conv.py @@ -1,10 +1,10 @@ -import math - import numpy as np -import pyrtools as pt import torch -import torch.nn.functional as F from torch import Tensor +import torch.nn.functional as F +import pyrtools as pt +from typing import Union, Tuple +import math def correlate_downsample(image, filt, padding_mode="reflect"): @@ -24,15 +24,8 @@ def correlate_downsample(image, filt, padding_mode="reflect"): assert isinstance(image, torch.Tensor) and isinstance(filt, torch.Tensor) assert image.ndim == 4 and filt.ndim == 2 n_channels = image.shape[1] - image_padded = same_padding( - image, kernel_size=filt.shape, pad_mode=padding_mode - ) - return F.conv2d( - image_padded, - filt.repeat(n_channels, 1, 1, 1), - stride=2, - groups=n_channels, - ) + image_padded = same_padding(image, kernel_size=filt.shape, pad_mode=padding_mode) + return F.conv2d(image_padded, filt.repeat(n_channels, 1, 1, 1), stride=2, groups=n_channels) def upsample_convolve(image, odd, filt, padding_mode="reflect"): @@ -61,18 +54,10 @@ def upsample_convolve(image, odd, filt, padding_mode="reflect"): pad_end = np.array(filt.shape) - np.array(odd) - pad_start pad = np.array([pad_start[1], pad_end[1], pad_start[0], pad_end[0]]) image_prepad = F.pad(image, tuple(pad // 2), mode=padding_mode) - image_upsample = F.conv_transpose2d( - image_prepad, - weight=torch.ones( - (n_channels, 1, 1, 1), device=image.device, dtype=image.dtype - ), - stride=2, - groups=n_channels, - ) + image_upsample = F.conv_transpose2d(image_prepad, + weight=torch.ones((n_channels, 1, 1, 1), device=image.device, dtype=image.dtype), stride=2, groups=n_channels) image_postpad = F.pad(image_upsample, tuple(pad % 2)) - return F.conv2d( - image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels - ) + return F.conv2d(image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels) def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): @@ -92,9 +77,7 @@ def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor( - np.outer(f, f), dtype=torch.float32, device=x.device - ) + filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) if scale_filter: filt = filt / 2 for _ in range(n_scales): @@ -120,46 +103,38 @@ def upsample_blur(x, odd, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor( - np.outer(f, f), dtype=torch.float32, device=x.device - ) + filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) if scale_filter: filt = filt * 2 return upsample_convolve(x, odd, filt) def _get_same_padding( - x: int, kernel_size: int, stride: int, dilation: int + x: int, + kernel_size: int, + stride: int, + dilation: int ) -> int: """Helper function to determine integer padding for F.pad() given img and kernel""" - pad = ( - (math.ceil(x / stride) - 1) * stride - + (kernel_size - 1) * dilation - + 1 - - x - ) + pad = (math.ceil(x / stride) - 1) * stride + (kernel_size - 1) * dilation + 1 - x pad = max(pad, 0) return pad def same_padding( - x: Tensor, - kernel_size: int | tuple[int, int], - stride: int | tuple[int, int] = (1, 1), - dilation: int | tuple[int, int] = (1, 1), - pad_mode: str = "circular", + x: Tensor, + kernel_size: Union[int, Tuple[int, int]], + stride: Union[int, Tuple[int, int]] = (1, 1), + dilation: Union[int, Tuple[int, int]] = (1, 1), + pad_mode: str = "circular", ) -> Tensor: """Pad a tensor so that 2D convolution will result in output with same dims.""" - assert ( - len(x.shape) > 2 - ), "Input must be tensor whose last dims are height x width" + assert len(x.shape) > 2, "Input must be tensor whose last dims are height x width" ih, iw = x.shape[-2:] pad_h = _get_same_padding(ih, kernel_size[0], stride[0], dilation[0]) pad_w = _get_same_padding(iw, kernel_size[1], stride[1], dilation[1]) if pad_h > 0 or pad_w > 0: - x = F.pad( - x, - [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], - mode=pad_mode, - ) + x = F.pad(x, + [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], + mode=pad_mode) return x diff --git a/src/plenoptic/tools/convergence.py b/src/plenoptic/tools/convergence.py index bba4b2d1..8a658ea1 100644 --- a/src/plenoptic/tools/convergence.py +++ b/src/plenoptic/tools/convergence.py @@ -20,17 +20,14 @@ # to avoid circular import error: # https://adamj.eu/tech/2021/05/13/python-type-hints-how-to-fix-circular-imports/ from typing import TYPE_CHECKING - if TYPE_CHECKING: - from ..synthesize.metamer import Metamer from ..synthesize.synthesis import OptimizedSynthesis + from ..synthesize.metamer import Metamer -def loss_convergence( - synth: "OptimizedSynthesis", - stop_criterion: float, - stop_iters_to_check: int, -) -> bool: +def loss_convergence(synth: "OptimizedSynthesis", + stop_criterion: float, + stop_iters_to_check: int) -> bool: r"""Check whether the loss has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -62,17 +59,13 @@ def loss_convergence( """ if len(synth.losses) > stop_iters_to_check: - if ( - abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) - < stop_criterion - ): + if abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) < stop_criterion: return True return False -def coarse_to_fine_enough( - synth: "Metamer", i: int, ctf_iters_to_check: int -) -> bool: +def coarse_to_fine_enough(synth: "Metamer", i: int, + ctf_iters_to_check: int) -> bool: r"""Check whether we've synthesized all scales and done so for at least ctf_iters_to_check iterations This is meant to be paired with another convergence check, such as ``loss_convergence``. @@ -93,20 +86,18 @@ def coarse_to_fine_enough( Whether we've been doing coarse to fine synthesis for long enough. """ - all_scales = synth.scales[0] == "all" + all_scales = synth.scales[0] == 'all' # synth.scales_timing['all'] will only be a non-empty list if all_scales is # True, so we only check it then. This is equivalent to checking if both conditions are trued if all_scales: - return (i - synth.scales_timing["all"][0]) > ctf_iters_to_check + return (i - synth.scales_timing['all'][0]) > ctf_iters_to_check else: return False -def pixel_change_convergence( - synth: "OptimizedSynthesis", - stop_criterion: float, - stop_iters_to_check: int, -) -> bool: +def pixel_change_convergence(synth: "OptimizedSynthesis", + stop_criterion: float, + stop_iters_to_check: int) -> bool: """Check whether the pixel change norm has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -138,8 +129,6 @@ def pixel_change_convergence( """ if len(synth.pixel_change_norm) > stop_iters_to_check: - if ( - synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion - ).all(): + if (synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion).all(): return True return False diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index 5f462842..415defa5 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -1,12 +1,13 @@ -import os.path as op import pathlib +from typing import List, Optional, Union, Tuple import warnings import imageio import numpy as np -import torch +import os.path as op from pyrtools import synthetic_images from skimage import color +import torch from torch import Tensor from .signal import rescale @@ -27,12 +28,10 @@ np.complex128: torch.complex128, } -TORCH_TO_NUMPY_TYPES = { - value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items() -} +TORCH_TO_NUMPY_TYPES = {value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items()} -def to_numpy(x: Tensor | np.ndarray, squeeze: bool = False) -> np.ndarray: +def to_numpy(x: Union[Tensor, np.ndarray], squeeze: bool = False) -> np.ndarray: r"""cast tensor to numpy in the most conservative way possible Parameters @@ -58,7 +57,7 @@ def to_numpy(x: Tensor | np.ndarray, squeeze: bool = False) -> np.ndarray: return x -def load_images(paths: str | list[str], as_gray: bool = True) -> Tensor: +def load_images(paths: Union[str, List[str]], as_gray: bool = True) -> Tensor: r"""Correctly load in images Our models and synthesis methods expect their inputs to be 4d @@ -139,10 +138,8 @@ def load_images(paths: str | list[str], as_gray: bool = True) -> Tensor: im = np.expand_dims(im, 0).repeat(3, 0) images.append(im) if len(set([i.shape for i in images])) > 1: - raise ValueError( - "All images must be the same shape but got the following: " - f"{[i.shape for i in images]}" - ) + raise ValueError("All images must be the same shape but got the following: " + f"{[i.shape for i in images]}") images = torch.as_tensor(np.array(images), dtype=torch.float32) if as_gray: if images.ndimension() != 3: @@ -197,9 +194,7 @@ def convert_float_to_int(im: np.ndarray, dtype=np.uint8) -> np.ndarray: return (im * np.iinfo(dtype).max).astype(dtype) -def make_synthetic_stimuli( - size: int = 256, requires_grad: bool = True -) -> Tensor: +def make_synthetic_stimuli(size: int = 256, requires_grad: bool = True) -> Tensor: r"""Make a set of basic stimuli, useful for developping and debugging models Parameters @@ -228,13 +223,10 @@ def make_synthetic_stimuli( bar = np.zeros((size, size)) bar[ - size // 2 - size // 10 : size // 2 + size // 10, - size // 2 - 1 : size // 2 + 1, + size // 2 - size // 10 : size // 2 + size // 10, size // 2 - 1 : size // 2 + 1 ] = 1 - curv_edge = synthetic_images.disk( - size=size, radius=size / 1.2, origin=(size, size) - ) + curv_edge = synthetic_images.disk(size=size, radius=size / 1.2, origin=(size, size)) sine_grating = synthetic_images.sine(size) * synthetic_images.gaussian( size, covariance=size @@ -283,10 +275,10 @@ def make_synthetic_stimuli( def polar_radius( - size: int | tuple[int, int], + size: Union[int, Tuple[int, int]], exponent: float = 1.0, - origin: int | tuple[int, int] | None = None, - device: str | torch.device | None = None, + origin: Optional[Union[int, Tuple[int, int]]] = None, + device: Optional[Union[str, torch.device]] = None, ) -> Tensor: """Make distance-from-origin (r) matrix @@ -344,10 +336,10 @@ def polar_radius( def polar_angle( - size: int | tuple[int, int], + size: Union[int, Tuple[int, int]], phase: float = 0.0, - origin: int | tuple[float, float] | None = None, - device: torch.device | None = None, + origin: Optional[Union[int, Tuple[float, float]]] = None, + device: Optional[torch.device] = None, ) -> Tensor: """Make polar angle matrix (in radians). diff --git a/src/plenoptic/tools/display.py b/src/plenoptic/tools/display.py index d903e22f..97350074 100644 --- a/src/plenoptic/tools/display.py +++ b/src/plenoptic/tools/display.py @@ -1,34 +1,20 @@ """various helpful utilities for plotting or displaying information """ import warnings - -import matplotlib.pyplot as plt +import torch import numpy as np import pyrtools as pt -import torch - +import matplotlib.pyplot as plt from .data import to_numpy - try: from IPython.display import HTML except ImportError: warnings.warn("Unable to import IPython.display.HTML") -def imshow( - image, - vrange="indep1", - zoom=None, - title="", - col_wrap=None, - ax=None, - cmap=None, - plot_complex="rectangular", - batch_idx=None, - channel_idx=None, - as_rgb=False, - **kwargs, -): +def imshow(image, vrange='indep1', zoom=None, title='', col_wrap=None, ax=None, + cmap=None, plot_complex='rectangular', batch_idx=None, + channel_idx=None, as_rgb=False, **kwargs): """Show image(s) correctly. This function shows images correctly, making sure that each element in the @@ -132,26 +118,22 @@ def imshow( im = to_numpy(im) if im.shape[0] > 1 and batch_idx is not None: # this preserves the number of dimensions - im = im[batch_idx : batch_idx + 1] + im = im[batch_idx:batch_idx+1] if channel_idx is not None: # this preserves the number of dimensions - im = im[:, channel_idx : channel_idx + 1] + im = im[:, channel_idx:channel_idx+1] # allow RGB and RGBA if as_rgb: if im.shape[1] not in [3, 4]: - raise Exception( - "If as_rgb is True, then channel must have 3 " - "or 4 elements!" - ) + raise Exception("If as_rgb is True, then channel must have 3 " + "or 4 elements!") im = im.transpose(0, 2, 3, 1) # want to insert a fake "channel" dimension here, so our putting it # into a list below works as expected im = im.reshape((im.shape[0], 1, *im.shape[1:])) elif im.shape[1] > 1 and im.shape[0] > 1: - raise Exception( - "Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting" - ) + raise Exception("Don't know how to plot images with more than one channel and batch!" + " Use batch_idx / channel_idx to choose a subset for plotting") # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate image. # because of how we've handled everything above, we know that im will @@ -170,8 +152,7 @@ def find_zoom(x, limit): divisors = [i for i in range(2, x) if not x % i] # find the largest zoom (equivalently, smallest divisor) such that the # zoomed in image is smaller than the limit - return 1 / min([i for i in divisors if x / i <= limit]) - + return 1 / min([i for i in divisors if x/i <= limit]) if ax is not None and zoom is None: if ax.bbox.height > max(heights): zoom = ax.bbox.height // max(heights) @@ -183,35 +164,15 @@ def find_zoom(x, limit): zoom = find_zoom(max(widths), ax.bbox.width) elif zoom is None: zoom = 1 - return pt.imshow( - images_to_plot, - vrange=vrange, - zoom=zoom, - title=title, - col_wrap=col_wrap, - ax=ax, - cmap=cmap, - plot_complex=plot_complex, - **kwargs, - ) - - -def animshow( - video, - framerate=2.0, - repeat=False, - vrange="indep1", - zoom=1, - title="", - col_wrap=None, - ax=None, - cmap=None, - plot_complex="rectangular", - batch_idx=None, - channel_idx=None, - as_rgb=False, - **kwargs, -): + return pt.imshow(images_to_plot, vrange=vrange, zoom=zoom, title=title, + col_wrap=col_wrap, ax=ax, cmap=cmap, plot_complex=plot_complex, + **kwargs) + + +def animshow(video, framerate=2., repeat=False, vrange='indep1', zoom=1, + title='', col_wrap=None, ax=None, cmap=None, + plot_complex='rectangular', batch_idx=None, channel_idx=None, + as_rgb=False, **kwargs): """Animate video(s) correctly. This function animates videos correctly, making sure that each element in @@ -340,59 +301,37 @@ def animshow( vid = to_numpy(vid) if vid.shape[0] > 1 and batch_idx is not None: # this preserves the number of dimensions - vid = vid[batch_idx : batch_idx + 1] + vid = vid[batch_idx:batch_idx+1] if channel_idx is not None: # this preserves the number of dimensions - vid = vid[:, channel_idx : channel_idx + 1] + vid = vid[:, channel_idx:channel_idx+1] # allow RGB and RGBA if as_rgb: if vid.shape[1] not in [3, 4]: - raise Exception( - "If as_rgb is True, then channel must have 3 " - "or 4 elements!" - ) + raise Exception("If as_rgb is True, then channel must have 3 " + "or 4 elements!") vid = vid.transpose(0, 2, 3, 4, 1) # want to insert a fake "channel" dimension here, so our putting it # into a list below works as expected vid = vid.reshape((vid.shape[0], 1, *vid.shape[1:])) elif vid.shape[1] > 1 and vid.shape[0] > 1: - raise Exception( - "Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting" - ) + raise Exception("Don't know how to plot images with more than one channel and batch!" + " Use batch_idx / channel_idx to choose a subset for plotting") # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate video. # because of how we've handled everything above, we know that vid will # be (b,c,t,h,w) or (b,c,t,h,w,r) where r is the RGB(A) values for v in vid: videos_to_show.extend([v_.squeeze() for v_ in v]) - return pt.animshow( - videos_to_show, - framerate=framerate, - as_html5=False, - repeat=repeat, - vrange=vrange, - zoom=zoom, - title=title, - col_wrap=col_wrap, - ax=ax, - cmap=cmap, - plot_complex=plot_complex, - **kwargs, - ) - - -def pyrshow( - pyr_coeffs, - vrange="indep1", - zoom=1, - show_residuals=True, - cmap=None, - plot_complex="rectangular", - batch_idx=0, - channel_idx=0, - **kwargs, -): + return pt.animshow(videos_to_show, framerate=framerate, as_html5=False, + repeat=repeat, vrange=vrange, zoom=zoom, title=title, + col_wrap=col_wrap, ax=ax, cmap=cmap, + plot_complex=plot_complex, **kwargs) + + +def pyrshow(pyr_coeffs, vrange='indep1', zoom=1, show_residuals=True, + cmap=None, plot_complex='rectangular', batch_idx=0, channel_idx=0, + **kwargs): r"""Display steerable pyramid coefficients in orderly fashion. This function uses ``imshow`` to show the coefficients of the steeable @@ -469,31 +408,20 @@ def pyrshow( if np.iscomplex(im).any(): is_complex = True # this removes only the first (batch) dimension - im = im[batch_idx : batch_idx + 1].squeeze(0) + im = im[batch_idx:batch_idx+1].squeeze(0) # this removes only the first (now channel) dimension - im = im[channel_idx : channel_idx + 1].squeeze(0) + im = im[channel_idx:channel_idx+1].squeeze(0) # because of how we've handled everything above, we know that im will # be (h,w). pyr_coeffvis[k] = im - return pt.pyrshow( - pyr_coeffvis, - is_complex=is_complex, - vrange=vrange, - zoom=zoom, - cmap=cmap, - plot_complex=plot_complex, - show_residuals=show_residuals, - **kwargs, - ) - - -def clean_up_axes( - ax, - ylim=None, - spines_to_remove=["top", "right", "bottom"], - axes_to_remove=["x"], -): + return pt.pyrshow(pyr_coeffvis, is_complex=is_complex, vrange=vrange, + zoom=zoom, cmap=cmap, plot_complex=plot_complex, + show_residuals=show_residuals, **kwargs) + + +def clean_up_axes(ax, ylim=None, spines_to_remove=['top', 'right', 'bottom'], + axes_to_remove=['x']): r"""Clean up an axis, as desired when making a stem plot of the representation Parameters @@ -517,18 +445,18 @@ def clean_up_axes( """ if spines_to_remove is None: - spines_to_remove = ["top", "right", "bottom"] + spines_to_remove = ['top', 'right', 'bottom'] if axes_to_remove is None: - axes_to_remove = ["x"] + axes_to_remove = ['x'] if ylim is not None: if ylim: ax.set_ylim(ylim) else: ax.set_ylim((0, ax.get_ylim()[1])) - if "x" in axes_to_remove: + if 'x' in axes_to_remove: ax.xaxis.set_visible(False) - if "y" in axes_to_remove: + if 'y' in axes_to_remove: ax.yaxis.set_visible(False) for s in spines_to_remove: ax.spines[s].set_visible(False) @@ -563,7 +491,7 @@ def update_stem(stem_container, ydata): """ stem_container.markerline.set_ydata(ydata) segments = stem_container.stemlines.get_segments().copy() - for s, y in zip(segments, ydata, strict=False): + for s, y in zip(segments, ydata): try: s[1, 1] = y except IndexError: @@ -589,7 +517,6 @@ def rescale_ylim(axes, data): values) """ data = data.cpu() - def find_ymax(data): try: return np.abs(data).max() @@ -597,7 +524,6 @@ def find_ymax(data): # then we need to call to_numpy on it because it needs to be # detached and converted to an array return np.abs(to_numpy(data)).max() - try: y_max = find_ymax(data) except TypeError: @@ -607,7 +533,7 @@ def find_ymax(data): ax.set_ylim((-y_max, y_max)) -def clean_stem_plot(data, ax=None, title="", ylim=None, xvals=None, **kwargs): +def clean_stem_plot(data, ax=None, title='', ylim=None, xvals=None, **kwargs): r"""convenience wrapper for plotting stem plots This plots the data, baseline, cleans up the axis, and sets the @@ -691,15 +617,14 @@ def clean_stem_plot(data, ax=None, title="", ylim=None, xvals=None, **kwargs): if ax is None: ax = plt.gca() if xvals is not None: - basefmt = " " - ax.hlines( - len(xvals[0]) * [0], xvals[0], xvals[1], colors="C3", zorder=10 - ) + basefmt = ' ' + ax.hlines(len(xvals[0])*[0], xvals[0], xvals[1], colors='C3', + zorder=10) else: # this is the default basefmt value basefmt = None ax.stem(data, basefmt=basefmt, **kwargs) - ax = clean_up_axes(ax, ylim, ["top", "right", "bottom"]) + ax = clean_up_axes(ax, ylim, ['top', 'right', 'bottom']) if title is not None: ax.set_title(title) return ax @@ -727,7 +652,7 @@ def _get_artists_from_axes(axes, data): use, keys are the corresponding keys for data """ - if not hasattr(axes, "__iter__"): + if not hasattr(axes, '__iter__'): # then we only have one axis, so we may be able to update more than one # data element. if len(axes.containers) > 0: @@ -747,25 +672,17 @@ def _get_artists_from_axes(axes, data): artists = {ax.get_label(): ax for ax in artists} else: if data_check == 1 and data.shape[1] != len(artists): - raise Exception( - f"data has {data.shape[1]} things to plot, but " - f"your axis contains {len(artists)} plotting artists, " - "so unsure how to continue! Pass data as a dictionary" - " with keys corresponding to the labels of the artists" - " to update to resolve this." - ) - elif ( - data_check == 2 - and data.ndim > 2 - and data.shape[-3] != len(artists) - ): - raise Exception( - f"data has {data.shape[-3]} things to plot, but " - f"your axis contains {len(artists)} plotting artists, " - "so unsure how to continue! Pass data as a dictionary" - " with keys corresponding to the labels of the artists" - " to update to resolve this." - ) + raise Exception(f"data has {data.shape[1]} things to plot, but " + f"your axis contains {len(artists)} plotting artists, " + "so unsure how to continue! Pass data as a dictionary" + " with keys corresponding to the labels of the artists" + " to update to resolve this.") + elif data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): + raise Exception(f"data has {data.shape[-3]} things to plot, but " + f"your axis contains {len(artists)} plotting artists, " + "so unsure how to continue! Pass data as a dictionary" + " with keys corresponding to the labels of the artists" + " to update to resolve this.") else: # then we have multiple axes, so we are only updating one data element # per plot @@ -786,31 +703,19 @@ def _get_artists_from_axes(axes, data): data_check = 2 if isinstance(data, dict): if len(data.keys()) != len(artists): - raise Exception( - f"data has {len(data.keys())} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!" - ) - artists = { - k: a for k, a in zip(data.keys(), artists, strict=False) - } + raise Exception(f"data has {len(data.keys())} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!") + artists = {k: a for k, a in zip(data.keys(), artists)} else: if data_check == 1 and data.shape[1] != len(artists): - raise Exception( - f"data has {data.shape[1]} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!" - ) - if ( - data_check == 2 - and data.ndim > 2 - and data.shape[-3] != len(artists) - ): - raise Exception( - f"data has {data.shape[-3]} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!" - ) + raise Exception(f"data has {data.shape[1]} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!") + if data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): + raise Exception(f"data has {data.shape[-3]} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!") if not isinstance(artists, dict): artists = {f"{i:02d}": a for i, a in enumerate(artists)} return artists @@ -882,18 +787,14 @@ def update_plot(axes, data, model=None, batch_idx=0): if isinstance(data, dict): for v in data.values(): if v.ndim not in [3, 4]: - raise ValueError( - "update_plot expects 3 or 4 dimensional data" - "; unexpected behavior will result otherwise!" - f" Got data of shape {v.shape}" - ) + raise ValueError("update_plot expects 3 or 4 dimensional data" + "; unexpected behavior will result otherwise!" + f" Got data of shape {v.shape}") else: if data.ndim not in [3, 4]: - raise ValueError( - "update_plot expects 3 or 4 dimensional data" - "; unexpected behavior will result otherwise!" - f" Got data of shape {data.shape}" - ) + raise ValueError("update_plot expects 3 or 4 dimensional data" + "; unexpected behavior will result otherwise!" + f" Got data of shape {data.shape}") try: artists = model.update_plot(axes=axes, batch_idx=batch_idx, data=data) except AttributeError: @@ -907,24 +808,19 @@ def update_plot(axes, data, model=None, batch_idx=0): # instead, as suggested # https://stackoverflow.com/questions/43629270/how-to-get-single-value-from-dict-with-single-entry try: - if ( - next(iter(ax_artists.values())).get_array().data.ndim - > 1 - ): + if next(iter(ax_artists.values())).get_array().data.ndim > 1: # then this is an RGBA image - data_dict = {"00": data} + data_dict = {'00': data} except Exception as e: - raise Exception( - "Thought this was an RGB(A) image based on the number of " - "artists and data shape, but something is off! " - f"Original exception: {e}" - ) + raise Exception("Thought this was an RGB(A) image based on the number of " + "artists and data shape, but something is off! " + f"Original exception: {e}") else: for i, d in enumerate(data.unbind(1)): # need to keep the shape the same because of how we # check for shape below (unbinding removes a dimension, # so we add it back) - data_dict[f"{i:02d}"] = d.unsqueeze(1) + data_dict[f'{i:02d}'] = d.unsqueeze(1) data = data_dict for k, d in data.items(): try: @@ -965,16 +861,8 @@ def update_plot(axes, data, model=None, batch_idx=0): return artists -def plot_representation( - model=None, - data=None, - ax=None, - figsize=(5, 5), - ylim=False, - batch_idx=0, - title="", - as_rgb=False, -): +def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), + ylim=False, batch_idx=0, title='', as_rgb=False): r"""Helper function for plotting model representation We are trying to plot ``data`` on ``ax``, using @@ -1045,15 +933,15 @@ def plot_representation( try: # no point in passing figsize, because we've already created # and are passing an axis or are passing the user-specified one - fig, axes = model.plot_representation( - ylim=ylim, ax=ax, title=title, batch_idx=batch_idx, data=data - ) + fig, axes = model.plot_representation(ylim=ylim, ax=ax, title=title, + batch_idx=batch_idx, + data=data) except AttributeError: if data is None: data = model.representation if not isinstance(data, dict): if title is None: - title = "Representation" + title = 'Representation' data_dict = {} if not as_rgb: # then we peel apart the channels @@ -1061,22 +949,20 @@ def plot_representation( # need to keep the shape the same because of how we # check for shape below (unbinding removes a dimension, # so we add it back) - data_dict[title + "_%02d" % i] = d.unsqueeze(1) + data_dict[title+'_%02d' % i] = d.unsqueeze(1) else: data_dict[title] = data data = data_dict else: warnings.warn("data has keys, so we're ignoring title!") # want to make sure the axis we're taking over is basically invisible. - ax = clean_up_axes( - ax, False, ["top", "right", "bottom", "left"], ["x", "y"] - ) + ax = clean_up_axes(ax, False, + ['top', 'right', 'bottom', 'left'], ['x', 'y']) axes = [] if len(list(data.values())[0].shape) == 3: # then this is 'vector-like' - gs = ax.get_subplotspec().subgridspec( - min(4, len(data)), int(np.ceil(len(data) / 4)) - ) + gs = ax.get_subplotspec().subgridspec(min(4, len(data)), + int(np.ceil(len(data) / 4))) for i, (k, v) in enumerate(data.items()): ax = fig.add_subplot(gs[i % 4, i // 4]) # only plot the specified batch, but plot each channel @@ -1088,31 +974,23 @@ def plot_representation( axes.append(ax) elif len(list(data.values())[0].shape) == 4: # then this is 'image-like' - gs = ax.get_subplotspec().subgridspec( - int(np.ceil(len(data) / 4)), min(4, len(data)) - ) + gs = ax.get_subplotspec().subgridspec(int(np.ceil(len(data) / 4)), + min(4, len(data))) for i, (k, v) in enumerate(data.items()): ax = fig.add_subplot(gs[i // 4, i % 4]) - ax = clean_up_axes( - ax, False, ["top", "right", "bottom", "left"], ["x", "y"] - ) + ax = clean_up_axes(ax, + False, ['top', 'right', 'bottom', 'left'], + ['x', 'y']) # only plot the specified batch - imshow( - v, - batch_idx=batch_idx, - title=k, - ax=ax, - vrange="indep0", - as_rgb=as_rgb, - ) + imshow(v, batch_idx=batch_idx, title=k, ax=ax, + vrange='indep0', as_rgb=as_rgb) axes.append(ax) # because we're plotting image data, don't want to change # ylim at all ylim = False else: - raise Exception( - "Don't know what to do with data of shape" f" {data.shape}" - ) + raise Exception("Don't know what to do with data of shape" + f" {data.shape}") if ylim is None: if isinstance(data, dict): data = torch.cat(list(data.values()), dim=2) diff --git a/src/plenoptic/tools/external.py b/src/plenoptic/tools/external.py index c6ddefba..310f684d 100644 --- a/src/plenoptic/tools/external.py +++ b/src/plenoptic/tools/external.py @@ -10,19 +10,13 @@ import numpy as np import pyrtools as pt import scipy.io as sio - from ..data import fetch_data -def plot_MAD_results( - original_image, - noise_levels=None, - results_dir=None, - ssim_images_dir=None, - zoom=3, - vrange="indep1", - **kwargs, -): +def plot_MAD_results(original_image, noise_levels=None, + results_dir=None, + ssim_images_dir=None, + zoom=3, vrange='indep1', **kwargs): r"""plot original MAD results, provided by Zhou Wang Plot the results of original MAD Competition, as provided in .mat @@ -77,9 +71,9 @@ def plot_MAD_results( """ if results_dir is None: - results_dir = str(fetch_data("MAD_results.tar.gz")) + results_dir = str(fetch_data('MAD_results.tar.gz')) if ssim_images_dir is None: - ssim_images_dir = str(fetch_data("ssim_images.tar.gz")) + ssim_images_dir = str(fetch_data('ssim_images.tar.gz')) img_path = op.join(op.expanduser(ssim_images_dir), f"{original_image}.tif") orig_img = imageio.imread(img_path) blanks = np.ones((*orig_img.shape, 4)) @@ -87,107 +81,63 @@ def plot_MAD_results( noise_levels = [2**i for i in range(1, 11)] results = {} images = np.dstack([orig_img, blanks]) - titles = ["Original image"] + 4 * [None] - super_titles = 5 * [None] - keys = [ - "im_init", - "im_fixmse_maxssim", - "im_fixmse_minssim", - "im_fixssim_minmse", - "im_fixssim_maxmse", - ] + titles = ['Original image'] + 4*[None] + super_titles = 5*[None] + keys = ['im_init', 'im_fixmse_maxssim', 'im_fixmse_minssim', 'im_fixssim_minmse', + 'im_fixssim_maxmse'] for l in noise_levels: - mat = sio.loadmat( - op.join( - op.expanduser(results_dir), - f"{original_image}_L{l}_results.mat", - ), - squeeze_me=True, - ) + mat = sio.loadmat(op.join(op.expanduser(results_dir), + f"{original_image}_L{l}_results.mat"), squeeze_me=True) # remove these metadata keys - [mat.pop(k) for k in ["__header__", "__version__", "__globals__"]] - key_titles = [ - f"Noise level: {l}", - f"Best SSIM: {mat['maxssim']:.05f}", - f"Worst SSIM: {mat['minssim']:.05f}", - f"Best MSE: {mat['minmse']:.05f}", - f"Worst MSE: {mat['maxmse']:.05f}", - ] - key_super_titles = [ - None, - f"Fix MSE: {mat['FIX_MSE']:.0f}", - None, - f"Fix SSIM: {mat['FIX_SSIM']:.05f}", - None, - ] - for k, t, s in zip(keys, key_titles, key_super_titles, strict=False): + [mat.pop(k) for k in ['__header__', '__version__', '__globals__']] + key_titles = [f'Noise level: {l}', f"Best SSIM: {mat['maxssim']:.05f}", + f"Worst SSIM: {mat['minssim']:.05f}", + f"Best MSE: {mat['minmse']:.05f}", + f"Worst MSE: {mat['maxmse']:.05f}"] + key_super_titles = [None, f"Fix MSE: {mat['FIX_MSE']:.0f}", None, + f"Fix SSIM: {mat['FIX_SSIM']:.05f}", None] + for k, t, s in zip(keys, key_titles, key_super_titles): images = np.dstack([images, mat.pop(k)]) titles.append(t) super_titles.append(s) # this then just contains the loss information - mat.update({"noise_level": l, "original_image": original_image}) - results[f"L{l}"] = mat + mat.update({'noise_level': l, 'original_image': original_image}) + results[f'L{l}'] = mat images = images.transpose((2, 0, 1)) - if vrange.startswith("row"): + if vrange.startswith('row'): vrange_list = [] - for i in range(len(images) // 5): - vr, cmap = pt.tools.display.colormap_range( - images[5 * i : 5 * (i + 1)], vrange.replace("row", "auto") - ) + for i in range(len(images)//5): + vr, cmap = pt.tools.display.colormap_range(images[5*i:5*(i+1)], + vrange.replace('row', 'auto')) vrange_list.extend(vr) else: vrange_list, cmap = pt.tools.display.colormap_range(images, vrange) # this is a bit of hack to do the same thing imshow does, but with # slightly more space dedicated to the title - fig = pt.tools.display.make_figure( - len(images) // 5, - 5, - [zoom * i + 1 for i in images.shape[-2:]], - vert_pct=0.75, - ) - for img, ax, t, vr, s in zip( - images, fig.axes, titles, vrange_list, super_titles, strict=False - ): + fig = pt.tools.display.make_figure(len(images)//5, 5, [zoom*i+1 for i in images.shape[-2:]], + vert_pct=.75) + for img, ax, t, vr, s in zip(images, fig.axes, titles, vrange_list, super_titles): # these are the blanks if (img == 1).all(): continue - pt.imshow( - img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs - ) + pt.imshow(img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs) if s is not None: - font = { - k.replace("_", ""): v - for k, v in ax.title.get_font_properties().__dict__.items() - } + font = {k.replace('_', ''): v for k, v in + ax.title.get_font_properties().__dict__.items()} # these are the acceptable keys for the fontdict below - font = { - k: v - for k, v in font.items() - if k in ["family", "color", "weight", "size", "style"] - } + font = {k: v for k, v in font.items() if k in ['family', 'color', 'weight', 'size', + 'style']} # for some reason, this (with passing the transform) is # different (and looks better) than using ax.text. We also # slightly adjust the placement of the text to account for # different zoom levels (we also have 10 pixels between the # rows and columns, which correspond to a different) img_size = ax.bbox.size - fig.text( - 1 + (5 / img_size[0]), - (1 / 0.75), - s, - fontdict=font, - transform=ax.transAxes, - ha="center", - va="top", - ) + fig.text(1+(5/img_size[0]), (1/.75), s, fontdict=font, + transform=ax.transAxes, ha='center', va='top') # linewidth of 1.5 looks good with bbox of 192, 192 - linewidth = np.max([1.5 * np.mean(img_size / 192), 1]) - line = lines.Line2D( - 2 * [0 - ((5 + linewidth / 2) / img_size[0])], - [0, (1 / 0.75)], - transform=ax.transAxes, - figure=fig, - linewidth=linewidth, - ) + linewidth = np.max([1.5 * np.mean(img_size/192), 1]) + line = lines.Line2D(2*[0-((5+linewidth/2)/img_size[0])], [0, (1/.75)], + transform=ax.transAxes, figure=fig, linewidth=linewidth) fig.lines.append(line) return fig, results diff --git a/src/plenoptic/tools/optim.py b/src/plenoptic/tools/optim.py index 4dcf339e..439cc8c3 100644 --- a/src/plenoptic/tools/optim.py +++ b/src/plenoptic/tools/optim.py @@ -1,12 +1,12 @@ """Tools related to optimization such as more objective functions. """ - -import numpy as np import torch from torch import Tensor +from typing import Optional, Tuple +import numpy as np -def set_seed(seed: int | None = None) -> None: +def set_seed(seed: Optional[int] = None) -> None: """Set the seed. We call both ``torch.manual_seed()`` and ``np.random.seed()``. @@ -99,16 +99,11 @@ def relative_MSE(synth_rep: Tensor, ref_rep: Tensor, **kwargs) -> Tensor: Ratio of the squared l2-norm of the difference between ``ref_rep`` and ``synth_rep`` to the squared l2-norm of ``ref_rep`` """ - return ( - torch.linalg.vector_norm(ref_rep - synth_rep, ord=2) ** 2 - / torch.linalg.vector_norm(ref_rep, ord=2) ** 2 - ) + return torch.linalg.vector_norm(ref_rep - synth_rep, ord=2) ** 2 / torch.linalg.vector_norm(ref_rep, ord=2) ** 2 def penalize_range( - synth_img: Tensor, - allowed_range: tuple[float, float] = (0.0, 1.0), - **kwargs, + synth_img: Tensor, allowed_range: Tuple[float, float] = (0.0, 1.0), **kwargs ) -> Tensor: r"""penalize values outside of allowed_range diff --git a/src/plenoptic/tools/signal.py b/src/plenoptic/tools/signal.py index 90f4e939..33841d7c 100644 --- a/src/plenoptic/tools/signal.py +++ b/src/plenoptic/tools/signal.py @@ -1,11 +1,14 @@ +from typing import List, Optional, Tuple, Union + import numpy as np import torch -from pyrtools.pyramids.steer import steer_to_harmonics_mtx from torch import Tensor +import torch.fft as fft +from pyrtools.pyramids.steer import steer_to_harmonics_mtx def minimum( - x: Tensor, dim: list[int] | None = None, keepdim: bool = False + x: Tensor, dim: Optional[List[int]] = None, keepdim: bool = False ) -> Tensor: r"""Compute minimum in torch over any axis or combination of axes in tensor. @@ -13,14 +16,14 @@ def minimum( ---------- x Input tensor. - dim + dim Dimensions over which you would like to compute the minimum. - keepdim + keepdim Keep original dimensions of tensor when returning result. Returns ------- - min_x + min_x Minimum value of x. """ if dim is None: @@ -33,7 +36,7 @@ def minimum( def maximum( - x: Tensor, dim: list[int] | None = None, keepdim: bool = False + x: Tensor, dim: Optional[List[int]] = None, keepdim: bool = False ) -> Tensor: r"""Compute maximum in torch over any dim or combination of axes in tensor. @@ -70,8 +73,8 @@ def rescale(x: Tensor, a: float = 0.0, b: float = 1.0) -> Tensor: def raised_cosine( - width: float = 1, position: float = 0, values: tuple[float, float] = (0, 1) -) -> tuple[np.ndarray, np.ndarray]: + width: float = 1, position: float = 0, values: Tuple[float, float] = (0, 1) +) -> Tuple[np.ndarray, np.ndarray]: """Return a lookup table containing a "raised cosine" soft threshold function. Y = VALUES(1) @@ -113,7 +116,7 @@ def raised_cosine( def interpolate1d( - x_new: Tensor, Y: Tensor | np.ndarray, X: Tensor | np.ndarray + x_new: Tensor, Y: Union[Tensor, np.ndarray], X: Union[Tensor, np.ndarray] ) -> Tensor: r"""One-dimensional linear interpolation. @@ -142,7 +145,7 @@ def interpolate1d( return np.reshape(out, x_new.shape) -def rectangular_to_polar(x: Tensor) -> tuple[Tensor, Tensor]: +def rectangular_to_polar(x: Tensor) -> Tuple[Tensor, Tensor]: r"""Rectangular to polar coordinate transform Parameters @@ -187,9 +190,9 @@ def polar_to_rectangular(amplitude: Tensor, phase: Tensor) -> Tensor: def steer( basis: Tensor, - angle: np.ndarray | Tensor | float, - harmonics: list[int] | None = None, - steermtx: Tensor | np.ndarray | None = None, + angle: Union[np.ndarray, Tensor, float], + harmonics: Optional[List[int]] = None, + steermtx: Optional[Union[Tensor, np.ndarray]] = None, return_weights: bool = False, even_phase: bool = True, ): @@ -283,9 +286,9 @@ def steer( def make_disk( - img_size: int | tuple[int, int] | torch.Size, - outer_radius: float | None = None, - inner_radius: float | None = None, + img_size: Union[int, Tuple[int, int], torch.Size], + outer_radius: Optional[float] = None, + inner_radius: Optional[float] = None, ) -> Tensor: r"""Create a circular mask with softened edges to an image. @@ -324,6 +327,7 @@ def make_disk( for i in range(img_size[0]): # height for j in range(img_size[1]): # width + r = np.sqrt((i - i0) ** 2 + (j - j0) ** 2) if r > outer_radius: @@ -331,15 +335,13 @@ def make_disk( elif r < inner_radius: mask[i][j] = 1 else: - radial_decay = (r - inner_radius) / ( - outer_radius - inner_radius - ) + radial_decay = (r - inner_radius) / (outer_radius - inner_radius) mask[i][j] = (1 + np.cos(np.pi * radial_decay)) / 2 return mask -def add_noise(img: Tensor, noise_mse: float | list[float]) -> Tensor: +def add_noise(img: Tensor, noise_mse: Union[float, List[float]]) -> Tensor: """Add normally distributed noise to an image This adds normally-distributed noise to an image so that the resulting @@ -366,9 +368,7 @@ def add_noise(img: Tensor, noise_mse: float | list[float]) -> Tensor: ).unsqueeze(0) noise_mse = noise_mse.view(noise_mse.nelement(), 1, 1, 1) noise = 200 * torch.randn( - max(noise_mse.shape[0], img.shape[0]), - *img.shape[1:], - device=img.device, + max(noise_mse.shape[0], img.shape[0]), *img.shape[1:], device=img.device ) noise = noise - noise.mean() noise = noise * torch.sqrt( @@ -377,7 +377,7 @@ def add_noise(img: Tensor, noise_mse: float | list[float]) -> Tensor: return img + noise -def modulate_phase(x: Tensor, phase_factor: float = 2.0) -> Tensor: +def modulate_phase(x: Tensor, phase_factor: float = 2.) -> Tensor: """Modulate the phase of a complex signal. Doubling the phase of a complex signal allows you to, for example, take the @@ -471,11 +471,8 @@ def center_crop(x: Tensor, output_size: int) -> Tensor: """ h, w = x.shape[-2:] - return x[ - ..., - (h // 2 - output_size // 2) : (h // 2 + (output_size + 1) // 2), - (w // 2 - output_size // 2) : (w // 2 + (output_size + 1) // 2), - ] + return x[..., (h//2 - output_size//2) : (h//2 + (output_size+1)//2), + (w//2 - output_size//2) : (w//2 + (output_size+1)//2)] def expand(x: Tensor, factor: float) -> Tensor: @@ -510,13 +507,9 @@ def expand(x: Tensor, factor: float) -> Tensor: mx = factor * im_x my = factor * im_y if int(mx) != mx: - raise ValueError( - f"factor * x.shape[-1] must be an integer but got {mx} instead!" - ) + raise ValueError(f"factor * x.shape[-1] must be an integer but got {mx} instead!") if int(my) != my: - raise ValueError( - f"factor * x.shape[-2] must be an integer but got {my} instead!" - ) + raise ValueError(f"factor * x.shape[-2] must be an integer but got {my} instead!") mx = int(mx) my = int(my) @@ -595,20 +588,14 @@ def shrink(x: Tensor, factor: int) -> Tensor: my = im_y / factor if int(mx) != mx: - raise ValueError( - f"x.shape[-1]/factor must be an integer but got {mx} instead!" - ) + raise ValueError(f"x.shape[-1]/factor must be an integer but got {mx} instead!") if int(my) != my: - raise ValueError( - f"x.shape[-2]/factor must be an integer but got {my} instead!" - ) + raise ValueError(f"x.shape[-2]/factor must be an integer but got {my} instead!") mx = int(mx) my = int(my) - fourier = ( - 1 / factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) - ) + fourier = 1/factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) fourier_small = torch.zeros( *x.shape[:-2], my, @@ -630,18 +617,9 @@ def shrink(x: Tensor, factor: int) -> Tensor: # This line is equivalent to fourier_small[..., 1:, 1:] = fourier[..., y1:y2, x1:x2] - fourier_small[..., 0, 1:] = ( - fourier[..., y1 - 1, x1:x2] + fourier[..., y2, x1:x2] - ) / 2 - fourier_small[..., 1:, 0] = ( - fourier[..., y1:y2, x1 - 1] + fourier[..., y1:y2, x2] - ) / 2 - fourier_small[..., 0, 0] = ( - fourier[..., y1 - 1, x1 - 1] - + fourier[..., y1 - 1, x2] - + fourier[..., y2, x1 - 1] - + fourier[..., y2, x2] - ) / 4 + fourier_small[..., 0, 1:] = (fourier[..., y1-1, x1:x2] + fourier[..., y2, x1:x2])/ 2 + fourier_small[..., 1:, 0] = (fourier[..., y1:y2, x1-1] + fourier[..., y1:y2, x2])/ 2 + fourier_small[..., 0, 0] = (fourier[..., y1-1, x1-1] + fourier[..., y1-1, x2] + fourier[..., y2, x1-1] + fourier[..., y2, x2]) / 4 fourier_small = torch.fft.ifftshift(fourier_small, dim=(-2, -1)) im_small = torch.fft.ifft2(fourier_small) diff --git a/src/plenoptic/tools/stats.py b/src/plenoptic/tools/stats.py index f862ea0d..ecabf1c8 100644 --- a/src/plenoptic/tools/stats.py +++ b/src/plenoptic/tools/stats.py @@ -1,11 +1,13 @@ +from typing import List, Optional, Union + import torch from torch import Tensor def variance( x: Tensor, - mean: float | Tensor | None = None, - dim: int | list[int] | None = None, + mean: Optional[Union[float, Tensor]] = None, + dim: Optional[Union[int, List[int]]] = None, keepdim: bool = False, ) -> Tensor: r"""Calculate sample variance. @@ -39,9 +41,9 @@ def variance( def skew( x: Tensor, - mean: float | Tensor | None = None, - var: float | Tensor | None = None, - dim: int | list[int] | None = None, + mean: Optional[Union[float, Tensor]] = None, + var: Optional[Union[float, Tensor]] = None, + dim: Optional[Union[int, List[int]]] = None, keepdim: bool = False, ) -> Tensor: r"""Sample estimate of `x` *asymmetry* about its mean @@ -70,16 +72,14 @@ def skew( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow( - 1.5 - ) + return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow(1.5) def kurtosis( x: Tensor, - mean: float | Tensor | None = None, - var: float | Tensor | None = None, - dim: int | list[int] | None = None, + mean: Optional[Union[float, Tensor]] = None, + var: Optional[Union[float, Tensor]] = None, + dim: Optional[Union[int, List[int]]] = None, keepdim: bool = False, ) -> Tensor: r"""sample estimate of `x` *tailedness* (presence of outliers) @@ -114,6 +114,4 @@ def kurtosis( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean( - torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim - ) / var.pow(2) + return torch.mean(torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim) / var.pow(2) diff --git a/src/plenoptic/tools/straightness.py b/src/plenoptic/tools/straightness.py index 4ee0301b..e90e651a 100644 --- a/src/plenoptic/tools/straightness.py +++ b/src/plenoptic/tools/straightness.py @@ -1,6 +1,6 @@ import torch from torch import Tensor - +from typing import Tuple from .validate import validate_input @@ -26,9 +26,7 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: validate_input(start, no_batch=True) validate_input(stop, no_batch=True) if start.shape != stop.shape: - raise ValueError( - f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" - ) + raise ValueError(f"start and stop must be same shape, but got {start.shape} and {stop.shape}!") if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") shape = start.shape[1:] @@ -36,17 +34,15 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: device = start.device start = start.reshape(1, -1) stop = stop.reshape(1, -1) - tt = torch.linspace(0, 1, steps=n_steps + 1, device=device).view( - n_steps + 1, 1 - ) + tt = torch.linspace(0, 1, steps=n_steps+1, device=device + ).view(n_steps+1, 1) straight = (1 - tt) * start + tt * stop - return straight.reshape((n_steps + 1, *shape)) + return straight.reshape((n_steps+1, *shape)) -def sample_brownian_bridge( - start: Tensor, stop: Tensor, n_steps: int, max_norm: float = 1 -) -> Tensor: +def sample_brownian_bridge(start: Tensor, stop: Tensor, + n_steps: int, max_norm: float = 1) -> Tensor: """Sample a brownian bridge between `start` and `stop` made up of `n_steps` Parameters @@ -74,9 +70,7 @@ def sample_brownian_bridge( validate_input(start, no_batch=True) validate_input(stop, no_batch=True) if start.shape != stop.shape: - raise ValueError( - f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" - ) + raise ValueError(f"start and stop must be same shape, but got {start.shape} and {stop.shape}!") if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") if max_norm < 0: @@ -87,22 +81,21 @@ def sample_brownian_bridge( start = start.reshape(1, -1) stop = stop.reshape(1, -1) D = start.shape[1] - dt = torch.as_tensor(1 / n_steps) - tt = torch.linspace(0, 1, steps=n_steps + 1, device=device)[:, None] + dt = torch.as_tensor(1/n_steps) + tt = torch.linspace(0, 1, steps=n_steps+1, device=device)[:, None] - sigma = torch.sqrt(dt / D) * 2.0 * max_norm - dW = sigma * torch.randn(n_steps + 1, D, device=device) + sigma = torch.sqrt(dt / D) * 2. * max_norm + dW = sigma * torch.randn(n_steps+1, D, device=device) dW[0] = start.flatten() W = torch.cumsum(dW, dim=0) bridge = W - tt * (W[-1:] - stop) - return bridge.reshape((n_steps + 1, *shape)) + return bridge.reshape((n_steps+1, *shape)) -def deviation_from_line( - sequence: Tensor, normalize: bool = True -) -> tuple[Tensor, Tensor]: +def deviation_from_line(sequence: Tensor, + normalize: bool = True) -> Tuple[Tensor, Tensor]: """Compute the deviation of `sequence` to the straight line between its endpoints. Project each point of the path `sequence` onto the line defined by @@ -133,15 +126,14 @@ def deviation_from_line( y0 = y[0].view(1, D) y1 = y[-1].view(1, D) - line = y1 - y0 + line = (y1 - y0) line_length = torch.linalg.vector_norm(line, ord=2) line = line / line_length y_centered = y - y0 dist_along_line = y_centered @ line[0] projection = dist_along_line.view(T, 1) * line - dist_from_line = torch.linalg.vector_norm( - y_centered - projection, dim=1, ord=2 - ) + dist_from_line = torch.linalg.vector_norm(y_centered - projection, dim=1, + ord=2) if normalize: dist_along_line /= line_length @@ -170,9 +162,9 @@ def translation_sequence(image: Tensor, n_steps: int = 10) -> Tensor: validate_input(image, no_batch=True) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") - sequence = torch.empty(n_steps + 1, *image.shape[1:]).to(image.device) + sequence = torch.empty(n_steps+1, *image.shape[1:]).to(image.device) - for shift in range(n_steps + 1): + for shift in range(n_steps+1): sequence[shift] = torch.roll(image, shift, [-1]) return sequence diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index c1a5028d..c062c70f 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -1,16 +1,16 @@ """Functions to validate synthesis inputs. """ -import itertools -import warnings -from collections.abc import Callable - import torch +import warnings +import itertools +from typing import Tuple, Optional, Callable, Union from torch import Tensor +import warnings def validate_input( input_tensor: Tensor, no_batch: bool = False, - allowed_range: tuple[float, float] | None = None, + allowed_range: Optional[Tuple[float, float]] = None, ): """Determine whether input_tensor tensor can be used for synthesis. @@ -39,17 +39,10 @@ def validate_input( """ # validate dtype - if input_tensor.dtype not in [ - torch.float16, - torch.complex32, - torch.float32, - torch.complex64, - torch.float64, - torch.complex128, - ]: - raise TypeError( - f"Only float or complex dtypes are allowed but got type {input_tensor.dtype}" - ) + if input_tensor.dtype not in [torch.float16, torch.complex32, + torch.float32, torch.complex64, + torch.float64, torch.complex128]: + raise TypeError(f"Only float or complex dtypes are allowed but got type {input_tensor.dtype}") if input_tensor.ndimension() != 4: if no_batch: n_batch = 1 @@ -64,29 +57,24 @@ def validate_input( if no_batch and input_tensor.shape[0] != 1: # numpy raises ValueError when operands cannot be broadcast together, # so it seems reasonable here - raise ValueError("input_tensor batch dimension must be 1.") + raise ValueError(f"input_tensor batch dimension must be 1.") if allowed_range is not None: if allowed_range[0] >= allowed_range[1]: raise ValueError( "allowed_range[0] must be strictly less than" f" allowed_range[1], but got {allowed_range}" ) - if ( - input_tensor.min() < allowed_range[0] - or input_tensor.max() > allowed_range[1] - ): + if input_tensor.min() < allowed_range[0] or input_tensor.max() > allowed_range[1]: raise ValueError( f"input_tensor range must lie within {allowed_range}, but got" f" {(input_tensor.min().item(), input_tensor.max().item())}" ) -def validate_model( - model: torch.nn.Module, - image_shape: tuple[int, int, int, int] | None = None, - image_dtype: torch.dtype = torch.float32, - device: str | torch.device = "cpu", -): +def validate_model(model: torch.nn.Module, + image_shape: Optional[Tuple[int, int, int, int]] = None, + image_dtype: torch.dtype = torch.float32, + device: Union[str, torch.device] = 'cpu'): """Determine whether model can be used for sythesis. In particular, this function checks the following (with their associated @@ -138,9 +126,8 @@ def validate_model( """ if image_shape is None: image_shape = (1, 1, 16, 16) - test_img = torch.rand( - image_shape, dtype=image_dtype, requires_grad=False, device=device - ) + test_img = torch.rand(image_shape, dtype=image_dtype, requires_grad=False, + device=device) try: if model(test_img).requires_grad: raise ValueError( @@ -176,14 +163,12 @@ def validate_model( elif image_dtype in [torch.float64, torch.complex128]: allowed_dtypes = [torch.float64, torch.complex128] else: - raise TypeError( - f"Only float or complex dtypes are allowed but got type {image_dtype}" - ) + raise TypeError(f"Only float or complex dtypes are allowed but got type {image_dtype}") if model(test_img).dtype not in allowed_dtypes: raise TypeError("model changes precision of input, don't do that!") if model(test_img).ndimension() not in [3, 4]: raise ValueError( - "When given a 4d input, model output must be three- or four-" + f"When given a 4d input, model output must be three- or four-" "dimensional but had {model(test_img).ndimension()} dimensions instead!" ) if model(test_img).device != test_img.device: @@ -196,11 +181,9 @@ def validate_model( ) -def validate_coarse_to_fine( - model: torch.nn.Module, - image_shape: tuple[int, int, int, int] | None = None, - device: str | torch.device = "cpu", -): +def validate_coarse_to_fine(model: torch.nn.Module, + image_shape: Optional[Tuple[int, int, int, int]] = None, + device: Union[str, torch.device] = 'cpu'): """Determine whether a model can be used for coarse-to-fine synthesis. In particular, this function checks the following (with associated errors): @@ -225,9 +208,7 @@ def validate_coarse_to_fine( Which device to place the test image on. """ - warnings.warn( - "Validating whether model can work with coarse-to-fine synthesis -- this can take a while!" - ) + warnings.warn("Validating whether model can work with coarse-to-fine synthesis -- this can take a while!") msg = "and therefore we cannot do coarse-to-fine synthesis" if not hasattr(model, "scales"): raise AttributeError(f"model has no scales attribute {msg}") @@ -240,7 +221,7 @@ def validate_coarse_to_fine( try: if model_output_shape == model(test_img, scales=sc).shape: raise ValueError( - "Output of model forward method doesn't change" + f"Output of model forward method doesn't change" " shape when scales keyword arg is set to {sc} {msg}" ) except TypeError: @@ -249,12 +230,10 @@ def validate_coarse_to_fine( ) -def validate_metric( - metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], - image_shape: tuple[int, int, int, int] | None = None, - image_dtype: torch.dtype = torch.float32, - device: str | torch.device = "cpu", -): +def validate_metric(metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], + image_shape: Optional[Tuple[int, int, int, int]] = None, + image_dtype: torch.dtype = torch.float32, + device: Union[str, torch.device] = 'cpu'): """Determines whether a metric can be used for MADCompetition synthesis. In particular, this functions checks the following (with associated @@ -291,9 +270,7 @@ def validate_metric( try: same_val = metric(test_img, test_img).item() except TypeError: - raise TypeError( - "metric should be callable and accept two 4d tensors as input" - ) + raise TypeError("metric should be callable and accept two 4d tensors as input") # as of torch 2.0.0, this is a RuntimeError (a Tensor with X elements # cannot be converted to Scalar); previously it was a ValueError (only one # element tensors can be converted to Python scalars) From 3bb9ce13bb7b2299ffc8a917b005b5d3d261b12f Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 8 Aug 2024 17:05:34 -0400 Subject: [PATCH 034/134] additional line length and double quote fixes in 02-eigendistortions.ipynb --- examples/02_Eigendistortions.ipynb | 178 +++++++++++++++++++---------- pyproject.toml | 8 +- 2 files changed, 122 insertions(+), 64 deletions(-) diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 8b85fc29..b075d1a2 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -45,20 +45,24 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "import torch\n", "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", "from torch import nn\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", - "# if this fails, install torchvision in your plenoptic environment \n", + "# if this fails, install torchvision in your plenoptic environment\n", "# and restart the notebook kernel.\n", "try:\n", " from torchvision import models\n", "except ModuleNotFoundError:\n", - " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", - " \" please install it in your plenoptic environment \"\n", - " \"and restart the notebook kernel\")\n", + " raise ModuleNotFoundError(\n", + " \"optional dependency torchvision not found!\"\n", + " \" please install it in your plenoptic environment \"\n", + " \"and restart the notebook kernel\"\n", + " )\n", "import os.path as op\n", "import plenoptic as po" ] @@ -123,6 +127,7 @@ " \"\"\"The simplest model we can make.\n", " Its Jacobian should be the weight matrix of M, and the eigenvectors of the Fisher matrix are therefore the\n", " eigenvectors of M.T @ M\"\"\"\n", + "\n", " def __init__(self, n, m):\n", " super(LinearModel, self).__init__()\n", " torch.manual_seed(0)\n", @@ -132,21 +137,24 @@ " y = self.M(x) # this computes y = x @ M.T\n", " return y\n", "\n", + "\n", "n = 25 # input vector dim (can you predict what the eigenvec/vals would be when n Date: Thu, 8 Aug 2024 17:39:38 -0400 Subject: [PATCH 035/134] all notebooks in experiments refactored to meet pydocstyle and pyflakes criteria --- examples/00_quickstart.ipynb | 85 ++- examples/03_Steerable_Pyramid.ipynb | 213 ++++--- examples/04_Perceptual_distance.ipynb | 206 ++++-- examples/05_Geodesics.ipynb | 269 +++++--- examples/06_Metamer.ipynb | 71 ++- examples/07_Simple_MAD.ipynb | 201 ++++-- examples/08_MAD_Competition.ipynb | 69 +- examples/09_Original_MAD.ipynb | 9 +- examples/Demo_Eigendistortion.ipynb | 126 ++-- examples/Display.ipynb | 127 ++-- examples/Metamer-Portilla-Simoncelli.ipynb | 708 ++++++++++++++------- examples/Synthesis_extensions.ipynb | 90 ++- pyproject.toml | 3 +- 13 files changed, 1463 insertions(+), 714 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index faf80c8b..0c550c61 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -19,15 +19,16 @@ "import torch\n", "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "\n", "%matplotlib inline\n", "\n", - "plt.rcParams['animation.html'] = 'html5'\n", + "plt.rcParams[\"animation.html\"] = \"html5\"\n", "# use single-threaded ffmpeg for animation writer\n", - "plt.rcParams['animation.writer'] = 'ffmpeg'\n", - "plt.rcParams['animation.ffmpeg_args'] = ['-threads', '1']" + "plt.rcParams[\"animation.writer\"] = \"ffmpeg\"\n", + "plt.rcParams[\"animation.ffmpeg_args\"] = [\"-threads\", \"1\"]" ] }, { @@ -83,7 +84,10 @@ ], "source": [ "# this is a convenience function for creating a simple Gaussian kernel\n", - "from plenoptic.simulate.canonical_computations.filters import circular_gaussian2d\n", + "from plenoptic.simulate.canonical_computations.filters import (\n", + " circular_gaussian2d,\n", + ")\n", + "\n", "\n", "# Simple rectified Gaussian convolutional model\n", "class SimpleModel(torch.nn.Module):\n", @@ -91,15 +95,20 @@ " def __init__(self, kernel_size=(7, 7)):\n", " super().__init__()\n", " self.kernel_size = kernel_size\n", - " self.conv = torch.nn.Conv2d(1, 1, kernel_size=kernel_size, padding=(0, 0), bias=False)\n", - " self.conv.weight.data[0, 0] = circular_gaussian2d(kernel_size, 3.)\n", - " \n", + " self.conv = torch.nn.Conv2d(\n", + " 1, 1, kernel_size=kernel_size, padding=(0, 0), bias=False\n", + " )\n", + " self.conv.weight.data[0, 0] = circular_gaussian2d(kernel_size, 3.0)\n", + "\n", " # the forward pass of the model defines how to get from an image to the representation\n", " def forward(self, x):\n", " # use circular padding so our output is the same size as our input\n", - " x = po.tools.conv.same_padding(x, self.kernel_size, pad_mode='circular')\n", + " x = po.tools.conv.same_padding(\n", + " x, self.kernel_size, pad_mode=\"circular\"\n", + " )\n", " return self.conv(x)\n", "\n", + "\n", "model = SimpleModel()\n", "rep = model(im)" ] @@ -158,7 +167,7 @@ } ], "source": [ - "fig = po.imshow(torch.cat([im, rep]), title=['Original image', 'Model output'])" + "fig = po.imshow(torch.cat([im, rep]), title=[\"Original image\", \"Model output\"])" ] }, { @@ -307,10 +316,17 @@ } ], "source": [ - "fig = po.imshow([im, rep, metamer.metamer, model(metamer.metamer)], \n", - " col_wrap=2, vrange='auto1',\n", - " title=['Original image', 'Model representation\\nof original image',\n", - " 'Synthesized metamer', 'Model representation\\nof synthesized metamer']);" + "fig = po.imshow(\n", + " [im, rep, metamer.metamer, model(metamer.metamer)],\n", + " col_wrap=2,\n", + " vrange=\"auto1\",\n", + " title=[\n", + " \"Original image\",\n", + " \"Model representation\\nof original image\",\n", + " \"Synthesized metamer\",\n", + " \"Model representation\\nof synthesized metamer\",\n", + " ],\n", + ")" ] }, { @@ -4225,7 +4241,9 @@ } ], "source": [ - "po.synth.metamer.animate(metamer, included_plots=['display_metamer', 'plot_loss'], figsize=(12, 5))" + "po.synth.metamer.animate(\n", + " metamer, included_plots=[\"display_metamer\", \"plot_loss\"], figsize=(12, 5)\n", + ")" ] }, { @@ -4253,7 +4271,7 @@ ], "source": [ "curie = po.data.curie()\n", - "po.imshow([curie]);" + "po.imshow([curie])" ] }, { @@ -4293,12 +4311,16 @@ } ], "source": [ - "metamer = po.synthesize.Metamer(im, model, initial_image=curie, )\n", + "metamer = po.synthesize.Metamer(\n", + " im,\n", + " model,\n", + " initial_image=curie,\n", + ")\n", "\n", "# we increase the length of time we run synthesis and decrease the\n", "# stop_criterion, which determines when we think loss has converged\n", "# for stopping synthesis early.\n", - "synth_image = metamer.synthesize(max_iter=500, stop_criterion=1e-6)" + "synth_image = metamer.synthesize(max_iter=500, stop_criterion=1e-6)" ] }, { @@ -4362,10 +4384,17 @@ } ], "source": [ - "fig = po.imshow([im, rep, metamer.metamer, model(metamer.metamer)], \n", - " col_wrap=2, vrange='auto1',\n", - " title=['Original image', 'Model representation\\nof original image',\n", - " 'Synthesized metamer', 'Model representation\\nof synthesized metamer']);" + "fig = po.imshow(\n", + " [im, rep, metamer.metamer, model(metamer.metamer)],\n", + " col_wrap=2,\n", + " vrange=\"auto1\",\n", + " title=[\n", + " \"Original image\",\n", + " \"Model representation\\nof original image\",\n", + " \"Synthesized metamer\",\n", + " \"Model representation\\nof synthesized metamer\",\n", + " ],\n", + ")" ] }, { @@ -4423,7 +4452,7 @@ ], "source": [ "eig = po.synthesize.Eigendistortion(im, model)\n", - "eig.synthesize();" + "eig.synthesize()" ] }, { @@ -4450,8 +4479,10 @@ } ], "source": [ - "po.imshow(eig.eigendistortions, title=['Maximum eigendistortion', \n", - " 'Minimum eigendistortion']);" + "po.imshow(\n", + " eig.eigendistortions,\n", + " title=[\"Maximum eigendistortion\", \"Minimum eigendistortion\"],\n", + ");" ] }, { @@ -4468,7 +4499,7 @@ "kernelspec": { "display_name": "plenoptic", "language": "python", - "name": "plenoptic" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -4480,7 +4511,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.10" } }, "nbformat": 4, diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index a1030fba..cd6a2a5b 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -21,15 +21,18 @@ "source": [ "import numpy as np\n", "import torch\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", - "# if this fails, install torchvision in your plenoptic environment \n", + "# if this fails, install torchvision in your plenoptic environment\n", "# and restart the notebook kernel.\n", "try:\n", " import torchvision\n", "except ModuleNotFoundError:\n", - " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", - " \" please install it in your plenoptic environment \"\n", - " \"and restart the notebook kernel\")\n", + " raise ModuleNotFoundError(\n", + " \"optional dependency torchvision not found!\"\n", + " \" please install it in your plenoptic environment \"\n", + " \"and restart the notebook kernel\"\n", + " )\n", "import torchvision.transforms as transforms\n", "import torch.nn.functional as F\n", "from torch import nn\n", @@ -40,23 +43,25 @@ "from plenoptic.simulate import SteerablePyramidFreq\n", "from plenoptic.synthesize import Eigendistortion\n", "from plenoptic.tools.data import to_numpy\n", + "\n", "dtype = torch.float32\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "import os\n", "from tqdm.auto import tqdm\n", + "\n", "%load_ext autoreload\n", "\n", "%autoreload 2\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "\n", "%matplotlib inline\n", "\n", - "plt.rcParams['animation.html'] = 'html5'\n", + "plt.rcParams[\"animation.html\"] = \"html5\"\n", "# use single-threaded ffmpeg for animation writer\n", - "plt.rcParams['animation.writer'] = 'ffmpeg'\n", - "plt.rcParams['animation.ffmpeg_args'] = ['-threads', '1']" + "plt.rcParams[\"animation.writer\"] = \"ffmpeg\"\n", + "plt.rcParams[\"animation.ffmpeg_args\"] = [\"-threads\", \"1\"]" ] }, { @@ -104,13 +109,15 @@ "source": [ "order = 3\n", "imsize = 64\n", - "pyr = SteerablePyramidFreq(height=3, image_shape=[imsize, imsize], order=order).to(device)\n", + "pyr = SteerablePyramidFreq(\n", + " height=3, image_shape=[imsize, imsize], order=order\n", + ").to(device)\n", "empty_image = torch.zeros((1, 1, imsize, imsize), dtype=dtype).to(device)\n", "pyr_coeffs = pyr.forward(empty_image)\n", "\n", "# insert a 1 in the center of each coefficient...\n", - "for k,v in pyr.pyr_size.items():\n", - " mid = (v[0]//2, v[1]//2)\n", + "for k, v in pyr.pyr_size.items():\n", + " mid = (v[0] // 2, v[1] // 2)\n", " pyr_coeffs[k][0, 0, mid[0], mid[1]] = 1\n", "\n", "# ... and then reconstruct this dummy image to visualize the filter.\n", @@ -119,8 +126,8 @@ " # we ignore the residual_highpass and residual_lowpass, since we're focusing on the filters here\n", " if isinstance(k, tuple):\n", " reconList.append(pyr.recon_pyr(pyr_coeffs, [k[0]], [k[1]]))\n", - " \n", - "po.imshow(reconList, col_wrap=order+1, vrange='indep1', zoom=2);" + "\n", + "po.imshow(reconList, col_wrap=order + 1, vrange=\"indep1\", zoom=2);" ] }, { @@ -171,7 +178,9 @@ "po.imshow(im_batch)\n", "order = 3\n", "dim_im = 256\n", - "pyr = SteerablePyramidFreq(height=4, image_shape=[dim_im, dim_im], order=order).to(device)\n", + "pyr = SteerablePyramidFreq(\n", + " height=4, image_shape=[dim_im, dim_im], order=order\n", + ").to(device)\n", "pyr_coeffs = pyr(im_batch)" ] }, @@ -218,7 +227,7 @@ ], "source": [ "print(pyr_coeffs.keys())\n", - "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=0);\n", + "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=0)\n", "po.pyrshow(pyr_coeffs, zoom=0.5, batch_idx=1);" ] }, @@ -264,11 +273,11 @@ } ], "source": [ - "#get the 3rd scale\n", + "# get the 3rd scale\n", "print(pyr.scales)\n", "pyr_coeffs_scale0 = pyr(im_batch, scales=[2])\n", - "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=0);\n", - "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=1);" + "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=0)\n", + "po.pyrshow(pyr_coeffs_scale0, zoom=2, batch_idx=1)" ] }, { @@ -290,7 +299,9 @@ "order = 3\n", "height = 3\n", "\n", - "pyr_complex = SteerablePyramidFreq(height=height, image_shape=[256,256], order=order, is_complex=True)\n", + "pyr_complex = SteerablePyramidFreq(\n", + " height=height, image_shape=[256, 256], order=order, is_complex=True\n", + ")\n", "pyr_complex.to(device)\n", "pyr_coeffs_complex = pyr_complex(im_batch)" ] @@ -322,9 +333,9 @@ } ], "source": [ - "# the same visualization machinery works for complex pyramids; what is shown is the magnitude of the coefficients\n", - "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=0);\n", - "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=1);" + "# the same visualization machinery works for complex pyramidswhat is shown is the magnitude of the coefficients\n", + "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=0)\n", + "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=1)" ] }, { @@ -332,7 +343,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now that we have seen the basics of using the pyramid, it's worth noting the following: an important property of the steerable pyramid is that it should respect the generalized parseval theorem (i.e. the energy of the pyramid coefficients should equal the energy of the original image). The [matlabpyrtools](https://github.com/LabForComputationalVision/matlabPyrTools) and [pyrtools](https://pyrtools.readthedocs.io/en/latest/) versions of the SteerablePyramid DO NOT respect this, so in our version, we have provided a fix that normalizes the FFTs such that energy is preserved. This is set using the `tight_frame=True` when instantiating the pyramid; however, if you require matching the outputs to the matlabPyrTools or PyrTools versions, please note that you will need to set this argument to `False`. " + "Now that we have seen the basics of using the pyramid, it's worth noting the following: an important property of the steerable pyramid is that it should respect the generalized parseval theorem (i.e. the energy of the pyramid coefficients should equal the energy of the original image). The [matlabpyrtools](https://github.com/LabForComputationalVision/matlabPyrTools) and [pyrtools](https://pyrtools.readthedocs.io/en/latest/) versions of the SteerablePyramid DO NOT respect this, so in our version, we have provided a fix that normalizes the FFTs such that energy is preserved. This is set using the `tight_frame=True` when instantiating the pyramidhowever, if you require matching the outputs to the matlabPyrTools or PyrTools versions, please note that you will need to set this argument to `False`. " ] }, { @@ -2161,17 +2172,23 @@ ], "source": [ "# note that steering is currently only implemeted for real pyramids, so the `is_complex` argument must be False (as it is by default)\n", - "pyr = SteerablePyramidFreq(height=3, image_shape=[256,256], order=3, twidth=1).to(device)\n", + "pyr = SteerablePyramidFreq(\n", + " height=3, image_shape=[256, 256], order=3, twidth=1\n", + ").to(device)\n", "coeffs = pyr(im_batch)\n", "\n", "# play around with different scales! Coarser scales tend to make the steering a bit more obvious.\n", "target_scale = 2\n", - "N_steer = 64 \n", - "M = torch.zeros(1, 1, N_steer, 256//2**target_scale, 256//2**target_scale)\n", + "N_steer = 64\n", + "M = torch.zeros(1, 1, N_steer, 256 // 2**target_scale, 256 // 2**target_scale)\n", "for i, steering_offset in enumerate(np.linspace(0, 1, N_steer)):\n", " steer_angle = steering_offset * 2 * np.pi\n", - " steered_coeffs, steering_weights = pyr.steer_coeffs(coeffs, [steer_angle]) # (the steering coefficients are also returned by pyr.steer_coeffs steered_coeffs_ij = oig_coeffs_ij @ steering_weights)\n", - " M[0, 0, i] = steered_coeffs[(target_scale, 4)][0, 0] # we are always looking at the same band, but the steering angle changes\n", + " steered_coeffs, steering_weights = pyr.steer_coeffs(\n", + " coeffs, [steer_angle]\n", + " ) # (the steering coefficients are also returned by pyr.steer_coeffs steered_coeffs_ij = oig_coeffs_ij @ steering_weights)\n", + " M[0, 0, i] = steered_coeffs[(target_scale, 4)][\n", + " 0, 0\n", + " ] # we are always looking at the same band, but the steering angle changes\n", "\n", "po.animshow(M, framerate=6, repeat=True, zoom=2**target_scale)" ] @@ -2215,11 +2232,21 @@ "source": [ "height = 3\n", "order = 3\n", - "pyr_fixed = SteerablePyramidFreq(height=height, image_shape=[256,256], order=order, is_complex=True,\n", - " downsample=False, tight_frame=True).to(device)\n", - "pyr_coeffs_fixed, pyr_info = pyr_fixed.convert_pyr_to_tensor(pyr_fixed(im_batch), split_complex=False)\n", - " # we can also split the complex coefficients into real and imaginary parts as separate channels.\n", - "pyr_coeffs_split, _ = pyr_fixed.convert_pyr_to_tensor(pyr_fixed(im_batch), split_complex=True)\n", + "pyr_fixed = SteerablePyramidFreq(\n", + " height=height,\n", + " image_shape=[256, 256],\n", + " order=order,\n", + " is_complex=True,\n", + " downsample=False,\n", + " tight_frame=True,\n", + ").to(device)\n", + "pyr_coeffs_fixed, pyr_info = pyr_fixed.convert_pyr_to_tensor(\n", + " pyr_fixed(im_batch), split_complex=False\n", + ")\n", + "# we can also split the complex coefficients into real and imaginary parts as separate channels.\n", + "pyr_coeffs_split, _ = pyr_fixed.convert_pyr_to_tensor(\n", + " pyr_fixed(im_batch), split_complex=True\n", + ")\n", "print(pyr_coeffs_split.shape, pyr_coeffs_split.dtype)\n", "print(pyr_coeffs_fixed.shape, pyr_coeffs_fixed.dtype)" ] @@ -2270,7 +2297,9 @@ ], "source": [ "pyr_coeffs_fixed_1 = pyr_fixed(im_batch)\n", - "pyr_coeffs_fixed_2 = pyr_fixed.convert_tensor_to_pyr(pyr_coeffs_fixed, *pyr_info)\n", + "pyr_coeffs_fixed_2 = pyr_fixed.convert_tensor_to_pyr(\n", + " pyr_coeffs_fixed, *pyr_info\n", + ")\n", "for k in pyr_coeffs_fixed_1.keys():\n", " print(torch.allclose(pyr_coeffs_fixed_2[k], pyr_coeffs_fixed_1[k]))" ] @@ -2310,7 +2339,7 @@ } ], "source": [ - "po.pyrshow(pyr_coeffs_complex, zoom=0.5);\n", + "po.pyrshow(pyr_coeffs_complex, zoom=0.5)\n", "po.pyrshow(pyr_coeffs_fixed_1, zoom=0.5);" ] }, @@ -2351,10 +2380,26 @@ ], "source": [ "# the following passes with tight_frame=True or tight_frame=False, either way.\n", - "pyr_not_downsample = SteerablePyramidFreq(height=height,image_shape=[256,256],order=order,is_complex = False,twidth=1, downsample=False, tight_frame=False)\n", + "pyr_not_downsample = SteerablePyramidFreq(\n", + " height=height,\n", + " image_shape=[256, 256],\n", + " order=order,\n", + " is_complex=False,\n", + " twidth=1,\n", + " downsample=False,\n", + " tight_frame=False,\n", + ")\n", "pyr_not_downsample.to(device)\n", "\n", - "pyr_downsample = SteerablePyramidFreq(height=height,image_shape=[256,256],order=order,is_complex = False,twidth=1, downsample=True, tight_frame=False)\n", + "pyr_downsample = SteerablePyramidFreq(\n", + " height=height,\n", + " image_shape=[256, 256],\n", + " order=order,\n", + " is_complex=False,\n", + " twidth=1,\n", + " downsample=True,\n", + " tight_frame=False,\n", + ")\n", "pyr_downsample.to(device)\n", "pyr_coeffs_downsample = pyr_downsample(im_batch.to(device))\n", "pyr_coeffs_not_downsample = pyr_not_downsample(im_batch.to(device))\n", @@ -2364,25 +2409,35 @@ " v2 = to_numpy(pyr_coeffs_not_downsample[k])\n", " v1 = v1.squeeze()\n", " v2 = v2.squeeze()\n", - " #check if energies match in each band between downsampled and fixed size pyramid responses\n", - " print(np.allclose(np.sum(np.abs(v1)**2), np.sum(np.abs(v2)**2), rtol=1e-4, atol=1e-4))\n", + " # check if energies match in each band between downsampled and fixed size pyramid responses\n", + " print(\n", + " np.allclose(\n", + " np.sum(np.abs(v1) ** 2),\n", + " np.sum(np.abs(v2) ** 2),\n", + " rtol=1e-4,\n", + " atol=1e-4,\n", + " )\n", + " )\n", "\n", - "def check_parseval(im ,coeff, rtol=1e-4, atol=0):\n", - " '''\n", + "\n", + "def check_parseval(im, coeff, rtol=1e-4, atol=0):\n", + " \"\"\"\n", " function that checks if the pyramid is parseval, i.e. energy of coeffs is\n", " the same as the energy in the original image.\n", " Args:\n", " input image: image stimulus as torch.Tensor\n", " coeff: dictionary of torch tensors corresponding to each band\n", - " '''\n", + " \"\"\"\n", " total_band_energy = 0\n", " im_energy = im.abs().square().sum().numpy()\n", - " for k,v in coeff.items():\n", + " for k, v in coeff.items():\n", " band = coeff[k]\n", " print(band.abs().square().sum().numpy())\n", " total_band_energy += band.abs().square().sum().numpy()\n", "\n", - " np.testing.assert_allclose(total_band_energy, im_energy, rtol=rtol, atol=atol)" + " np.testing.assert_allclose(\n", + " total_band_energy, im_energy, rtol=rtol, atol=atol\n", + " )" ] }, { @@ -2485,12 +2540,10 @@ "# First we define/download the dataset\n", "train_set = torchvision.datasets.FashionMNIST(\n", " # change this line to wherever you'd like to download the FashionMNIST dataset\n", - " root = '../data', \n", - " train = True,\n", - " download = True,\n", - " transform = transforms.Compose([\n", - " transforms.ToTensor() \n", - " ])\n", + " root=\"../data\",\n", + " train=True,\n", + " download=True,\n", + " transform=transforms.Compose([transforms.ToTensor()]),\n", ")" ] }, @@ -2504,51 +2557,59 @@ "class PyrConvFull(nn.Module):\n", " def __init__(self, imshape, order, scales, exclude=[], is_complex=True):\n", " super().__init__()\n", - " \n", + "\n", " self.imshape = imshape\n", " self.order = order\n", " self.scales = scales\n", - " self.output_dim = 20 # number of channels in the convolutional block\n", + " self.output_dim = 20 # number of channels in the convolutional block\n", " self.kernel_size = 6\n", " self.is_complex = is_complex\n", - " \n", + "\n", " self.rect = nn.ReLU()\n", - " self.pyr = SteerablePyramidFreq(height=self.scales,image_shape=self.imshape,\n", - " order=self.order,is_complex = self.is_complex,twidth=1, downsample=False)\n", - " \n", - " # num_channels = num_scales * num_orientations (+ 2 residual bands) (* 2 if complex) \n", + " self.pyr = SteerablePyramidFreq(\n", + " height=self.scales,\n", + " image_shape=self.imshape,\n", + " order=self.order,\n", + " is_complex=self.is_complex,\n", + " twidth=1,\n", + " downsample=False,\n", + " )\n", + "\n", + " # num_channels = num_scales * num_orientations (+ 2 residual bands) (* 2 if complex)\n", " channels_per = 2 if self.is_complex else 1\n", - " self.pyr_channels = ((self.order + 1) * self.scales + 2) * channels_per \n", + " self.pyr_channels = ((self.order + 1) * self.scales + 2) * channels_per\n", "\n", - " self.conv = nn.Conv2d(in_channels=self.pyr_channels, kernel_size=self.kernel_size, \n", - " out_channels=self.output_dim, stride=2)\n", + " self.conv = nn.Conv2d(\n", + " in_channels=self.pyr_channels,\n", + " kernel_size=self.kernel_size,\n", + " out_channels=self.output_dim,\n", + " stride=2,\n", + " )\n", " # the input ndim here has to do with the dimensionality of self.conv's output, so will have to change\n", " # if kernel_size or output_dim do\n", " self.fc = nn.Linear(self.output_dim * 12**2, 10)\n", - " \n", + "\n", " def forward(self, x):\n", " out = self.pyr(x)\n", " out, _ = self.pyr.convert_pyr_to_tensor(out)\n", - " \n", + "\n", " # case handling for real v. complex forward passes\n", " if self.is_complex:\n", " # split to real and imaginary so nonlinearities make sense\n", " out_re = self.rect(out.imag)\n", " out_im = self.rect(out.real)\n", - " \n", + "\n", " # concatenate\n", " out = torch.cat([out_re, out_im], dim=1)\n", " else:\n", " out = self.rect(out)\n", - " \n", - " \n", + "\n", " out = self.conv(out)\n", " out = self.rect(out)\n", - " out = out.view(out.shape[0], -1) # reshape for linear layer\n", + " out = out.view(out.shape[0], -1) # reshape for linear layer\n", " out = self.fc(out)\n", "\n", - " return out\n", - " " + " return out" ] }, { @@ -2608,7 +2669,7 @@ "source": [ "# Training Pyramid Model\n", "model_pyr = PyrConvFull([28, 28], order=4, scales=2, is_complex=False)\n", - "loader = torch.utils.data.DataLoader(train_set, batch_size = 50)\n", + "loader = torch.utils.data.DataLoader(train_set, batch_size=50)\n", "optimizer = torch.optim.Adam(model_pyr.parameters(), lr=1e-3)\n", "\n", "\n", @@ -2625,19 +2686,19 @@ " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", - " \n", + "\n", " losses.append(loss.item())\n", - " \n", + "\n", " n_correct = preds.argmax(dim=1).eq(labels).sum().item()\n", " fracts_correct.append(n_correct / 50)\n", "\n", - "fig, axs = plt.subplots(1, 2, figsize=(10, 5)) \n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", "axs[0].plot(losses)\n", - "axs[0].set_xlabel('Iteration')\n", - "axs[0].set_ylabel('Cross Entropy Loss')\n", + "axs[0].set_xlabel(\"Iteration\")\n", + "axs[0].set_ylabel(\"Cross Entropy Loss\")\n", "axs[1].plot(fracts_correct)\n", - "axs[1].set_xlabel('Iteration')\n", - "axs[1].set_ylabel('Classification Performance')" + "axs[1].set_xlabel(\"Iteration\")\n", + "axs[1].set_ylabel(\"Classification Performance\")" ] }, { diff --git a/examples/04_Perceptual_distance.ipynb b/examples/04_Perceptual_distance.ipynb index 46bd12f0..ce44957e 100644 --- a/examples/04_Perceptual_distance.ipynb +++ b/examples/04_Perceptual_distance.ipynb @@ -80,15 +80,18 @@ "outputs": [], "source": [ "import tempfile\n", + "\n", + "\n", "def add_jpeg_artifact(img, quality):\n", " # need to convert this back to 2d 8-bit int for writing out as jpg\n", " img = po.to_numpy(img.squeeze() * 255).astype(np.uint8)\n", " # write to a temporary file\n", - " with tempfile.NamedTemporaryFile(suffix='.jpg') as tmp:\n", + " with tempfile.NamedTemporaryFile(suffix=\".jpg\") as tmp:\n", " imageio.imwrite(tmp.name, img, quality=quality)\n", " img = po.load_images(tmp.name)\n", " return img\n", "\n", + "\n", "def add_saltpepper_noise(img, threshold):\n", " po.tools.set_seed(0)\n", " img_saltpepper = img.clone()\n", @@ -102,6 +105,7 @@ " np.random.seed(None)\n", " return img_saltpepper\n", "\n", + "\n", "def get_distorted_images():\n", " img = po.data.einstein()\n", " img_contrast = torch.clip(img + 0.20515 * (2 * img - 1), min=0, max=1)\n", @@ -109,7 +113,10 @@ " img_jpeg = add_jpeg_artifact(img, quality=4)\n", " img_blur = po.simul.Gaussian(5, std=2.68)(img)\n", " img_saltpepper = add_saltpepper_noise(img, threshold=0.00651)\n", - " img_distorted = torch.cat([img, img_contrast, img_mean, img_jpeg, img_blur, img_saltpepper], axis=0)\n", + " img_distorted = torch.cat(\n", + " [img, img_contrast, img_mean, img_jpeg, img_blur, img_saltpepper],\n", + " axis=0,\n", + " )\n", " return img_distorted" ] }, @@ -142,8 +149,18 @@ "img_distorted = get_distorted_images()\n", "mse_values = torch.square(img_distorted - img_distorted[0]).mean(dim=(1, 2, 3))\n", "ssim_values = po.metric.ssim(img_distorted, img_distorted[[0]])[:, 0]\n", - "names = [\"Original image\", \"Contrast change\", \"Mean shift\", \"JPEG artifact\", \"Gaussian blur\", \"Salt-and-pepper noise\"]\n", - "titles = [f\"{names[i]}\\nMSE={mse_values[i]:.3e}, SSIM={ssim_values[i]:.4f}\" for i in range(6)]\n", + "names = [\n", + " \"Original image\",\n", + " \"Contrast change\",\n", + " \"Mean shift\",\n", + " \"JPEG artifact\",\n", + " \"Gaussian blur\",\n", + " \"Salt-and-pepper noise\",\n", + "]\n", + "titles = [\n", + " f\"{names[i]}\\nMSE={mse_values[i]:.3e}, SSIM={ssim_values[i]:.4f}\"\n", + " for i in range(6)\n", + "]\n", "po.imshow(img_distorted, vrange=\"auto\", title=titles, col_wrap=3);" ] }, @@ -195,7 +212,7 @@ "source": [ "img_demo = get_demo_images()\n", "titles = [\"Original\", \"JPEG artifact\", \"SSIM map\", \"Absolute error\"]\n", - "po.imshow(img_demo, title=titles);" + "po.imshow(img_demo, title=titles)" ] }, { @@ -249,9 +266,19 @@ ], "source": [ "msssim_values = po.metric.ms_ssim(img_distorted, img_distorted[[0]])[:, 0]\n", - "names = [\"Original image\", \"Contrast change\", \"Mean shift\", \"JPEG artifact\", \"Gaussian blur\", \"Salt-and-pepper noise\"]\n", - "titles = [f\"{names[i]}\\nMSE={mse_values[i]:.3e}, MS-SSIM={msssim_values[i]:.3f}\" for i in range(6)]\n", - "po.imshow(img_distorted, vrange=\"auto\", title=titles, col_wrap=3);" + "names = [\n", + " \"Original image\",\n", + " \"Contrast change\",\n", + " \"Mean shift\",\n", + " \"JPEG artifact\",\n", + " \"Gaussian blur\",\n", + " \"Salt-and-pepper noise\",\n", + "]\n", + "titles = [\n", + " f\"{names[i]}\\nMSE={mse_values[i]:.3e}, MS-SSIM={msssim_values[i]:.3f}\"\n", + " for i in range(6)\n", + "]\n", + "po.imshow(img_distorted, vrange=\"auto\", title=titles, col_wrap=3)" ] }, { @@ -301,9 +328,19 @@ ], "source": [ "nlpd_values = po.metric.nlpd(img_distorted, img_distorted[[0]])[:, 0]\n", - "names = [\"Original image\", \"Contrast change\", \"Mean shift\", \"JPEG artifact\", \"Gaussian blur\", \"Salt-and-pepper noise\"]\n", - "titles = [f\"{names[i]}\\nMSE={mse_values[i]:.3e}, NLPD={nlpd_values[i]:.4f}\" for i in range(6)]\n", - "po.imshow(img_distorted, vrange=\"auto\", title=titles, col_wrap=3);" + "names = [\n", + " \"Original image\",\n", + " \"Contrast change\",\n", + " \"Mean shift\",\n", + " \"JPEG artifact\",\n", + " \"Gaussian blur\",\n", + " \"Salt-and-pepper noise\",\n", + "]\n", + "titles = [\n", + " f\"{names[i]}\\nMSE={mse_values[i]:.3e}, NLPD={nlpd_values[i]:.4f}\"\n", + " for i in range(6)\n", + "]\n", + "po.imshow(img_distorted, vrange=\"auto\", title=titles, col_wrap=3)" ] }, { @@ -343,7 +380,9 @@ "source": [ "# Take SSIM as an example here. The images in img_demo have a range of [0, 1].\n", "val1 = po.metric.ssim(img_demo[[0]], img_demo[[1]])\n", - "val2 = po.metric.ssim(img_demo[[0]] * 255, img_demo[[1]] * 255) # This produces a wrong result and triggers a warning: Image range falls outside [0, 1].\n", + "val2 = po.metric.ssim(\n", + " img_demo[[0]] * 255, img_demo[[1]] * 255\n", + ") # This produces a wrong result and triggers a warning: Image range falls outside [0, 1].\n", "print(f\"True SSIM: {float(val1):.4f}, rescaled image SSIM: {float(val2):.4f}\")" ] }, @@ -376,64 +415,102 @@ "metadata": {}, "outputs": [], "source": [ - "def get_tid2013_data(): \n", - " folder = po.data.fetch_data('tid2013.tar.gz')\n", + "def get_tid2013_data():\n", + " folder = po.data.fetch_data(\"tid2013.tar.gz\")\n", " reference_images = torch.zeros([25, 1, 384, 512])\n", " distorted_images = torch.zeros([25, 24, 5, 1, 384, 512])\n", - " reference_filemap = {s.lower(): s for s in os.listdir(folder / \"reference_images\")}\n", - " distorted_filemap = {s.lower(): s for s in os.listdir(folder / \"distorted_images\")}\n", + " reference_filemap = {\n", + " s.lower(): s for s in os.listdir(folder / \"reference_images\")\n", + " }\n", + " distorted_filemap = {\n", + " s.lower(): s for s in os.listdir(folder / \"distorted_images\")\n", + " }\n", " for i in range(25):\n", " reference_filename = reference_filemap[f\"i{i+1:02d}.bmp\"]\n", - " reference_images[i] = torch.as_tensor(np.asarray(Image.open(\n", - " folder / \"reference_images\" / reference_filename).convert(\"L\"))) / 255\n", + " reference_images[i] = (\n", + " torch.as_tensor(\n", + " np.asarray(\n", + " Image.open(\n", + " folder / \"reference_images\" / reference_filename\n", + " ).convert(\"L\")\n", + " )\n", + " )\n", + " / 255\n", + " )\n", " for j in range(24):\n", " for k in range(5):\n", - " distorted_filename = distorted_filemap[f\"i{i+1:02d}_{j+1:02d}_{k+1}.bmp\"]\n", - " distorted_images[i, j, k] = torch.as_tensor(np.asarray(Image.open(\n", - " folder / \"distorted_images\" / distorted_filename).convert(\"L\"))) / 255\n", - " distorted_images = distorted_images[:, [0] + list(range(2, 17)) + list(range(18, 24))] # Remove color distortions\n", + " distorted_filename = distorted_filemap[\n", + " f\"i{i+1:02d}_{j+1:02d}_{k+1}.bmp\"\n", + " ]\n", + " distorted_images[i, j, k] = (\n", + " torch.as_tensor(\n", + " np.asarray(\n", + " Image.open(\n", + " folder\n", + " / \"distorted_images\"\n", + " / distorted_filename\n", + " ).convert(\"L\")\n", + " )\n", + " )\n", + " / 255\n", + " )\n", + " distorted_images = distorted_images[\n", + " :, [0] + list(range(2, 17)) + list(range(18, 24))\n", + " ] # Remove color distortions\n", "\n", - " with open(folder/ \"mos.txt\", \"r\", encoding=\"utf-8\") as g:\n", + " with open(folder / \"mos.txt\", \"r\", encoding=\"utf-8\") as g:\n", " mos_values = list(map(float, g.readlines()))\n", " mos_values = np.array(mos_values).reshape([25, 24, 5])\n", - " mos_values = mos_values[:, [0] + list(range(2, 17)) + list(range(18, 24))] # Remove color distortions\n", + " mos_values = mos_values[\n", + " :, [0] + list(range(2, 17)) + list(range(18, 24))\n", + " ] # Remove color distortions\n", " return reference_images, distorted_images, mos_values\n", "\n", + "\n", "def correlate_with_tid(func_list, name_list):\n", " reference_images, distorted_images, mos_values = get_tid2013_data()\n", " distance = torch.zeros([len(func_list), 25, 22, 5])\n", " for i, func in enumerate(func_list):\n", " for j in range(25):\n", - " distance[i, j] = func(reference_images[[j]], distorted_images[j].flatten(0, 1)).reshape(22, 5)\n", - " \n", + " distance[i, j] = func(\n", + " reference_images[[j]], distorted_images[j].flatten(0, 1)\n", + " ).reshape(22, 5)\n", + "\n", " plot_size = int(np.ceil(np.sqrt(len(func_list))))\n", - " fig, axs = plt.subplots(plot_size, plot_size, squeeze=False, figsize=(plot_size * 6, plot_size * 6))\n", + " fig, axs = plt.subplots(\n", + " plot_size,\n", + " plot_size,\n", + " squeeze=False,\n", + " figsize=(plot_size * 6, plot_size * 6),\n", + " )\n", " axs = axs.flatten()\n", " edgecolor_list = [\"m\", \"c\", \"k\", \"g\", \"r\"]\n", " facecolor_list = [None, \"none\", \"none\", None, \"none\"]\n", " shape_list = [\"x\", \"s\", \"o\", \"*\", \"^\"]\n", - " distortion_names = [\"Additive Gaussian noise\",\n", - " \"Spatially correlated noise\",\n", - " \"Masked noise\",\n", - " \"High frequency noise\",\n", - " \"Impulse noise\",\n", - " \"Quantization noise\",\n", - " \"Gaussian blur\",\n", - " \"Image denoising\",\n", - " \"JPEG compression\",\n", - " \"JPEG2000 compression\",\n", - " \"JPEG transmission errors\",\n", - " \"JPEG2000 transmission errors\",\n", - " \"Non eccentricity pattern noise\",\n", - " \"Local block-wise distortions of different intensity\",\n", - " \"Mean shift (intensity shift)\",\n", - " \"Contrast change\",\n", - " \"Multiplicative Gaussian noise\",\n", - " \"Comfort noise\",\n", - " \"Lossy compression of noisy images\",\n", - " \"Image color quantization with dither\",\n", - " \"Chromatic aberrations\",\n", - " \"Sparse sampling and reconstruction\"]\n", + " distortion_names = [\n", + " \"Additive Gaussian noise\",\n", + " \"Spatially correlated noise\",\n", + " \"Masked noise\",\n", + " \"High frequency noise\",\n", + " \"Impulse noise\",\n", + " \"Quantization noise\",\n", + " \"Gaussian blur\",\n", + " \"Image denoising\",\n", + " \"JPEG compression\",\n", + " \"JPEG2000 compression\",\n", + " \"JPEG transmission errors\",\n", + " \"JPEG2000 transmission errors\",\n", + " \"Non eccentricity pattern noise\",\n", + " \"Local block-wise distortions of different intensity\",\n", + " \"Mean shift (intensity shift)\",\n", + " \"Contrast change\",\n", + " \"Multiplicative Gaussian noise\",\n", + " \"Comfort noise\",\n", + " \"Lossy compression of noisy images\",\n", + " \"Image color quantization with dither\",\n", + " \"Chromatic aberrations\",\n", + " \"Sparse sampling and reconstruction\",\n", + " ]\n", "\n", " for i, name in enumerate(name_list):\n", " for j in range(22):\n", @@ -442,13 +519,24 @@ " if facecolor is None:\n", " facecolor = edgecolor\n", " edgecolor = None\n", - " axs[i].scatter(distance[i, :, j].flatten(), mos_values[:, j].flatten(), s=20,\n", - " edgecolors=edgecolor, facecolors=facecolor,\n", - " marker=shape_list[j // 5], label=distortion_names[j])\n", - " pearsonr_value = pearsonr(-mos_values.flatten(), distance[i].flatten())[0]\n", - " spearmanr_value = spearmanr(-mos_values.flatten(), distance[i].flatten())[0]\n", + " axs[i].scatter(\n", + " distance[i, :, j].flatten(),\n", + " mos_values[:, j].flatten(),\n", + " s=20,\n", + " edgecolors=edgecolor,\n", + " facecolors=facecolor,\n", + " marker=shape_list[j // 5],\n", + " label=distortion_names[j],\n", + " )\n", + " pearsonr_value = pearsonr(\n", + " -mos_values.flatten(), distance[i].flatten()\n", + " )[0]\n", + " spearmanr_value = spearmanr(\n", + " -mos_values.flatten(), distance[i].flatten()\n", + " )[0]\n", " axs[i].set_title(\n", - " f\"pearson {pearsonr_value:.4f}, spearman {spearmanr_value:.4f}\")\n", + " f\"pearson {pearsonr_value:.4f}, spearman {spearmanr_value:.4f}\"\n", + " )\n", " axs[i].set_xlabel(name)\n", " axs[i].set_ylabel(\"MOS\")\n", " lines, labels = axs[0].get_legend_handles_labels()\n", @@ -478,14 +566,20 @@ "def rmse(img1, img2):\n", " return torch.sqrt(torch.square(img1 - img2).mean(dim=(-2, -1)))\n", "\n", + "\n", "def one_minus_ssim(img1, img2):\n", " return 1 - po.metric.ssim(img1, img2)\n", "\n", + "\n", "def one_minus_msssim(img1, img2):\n", " return 1 - po.metric.ms_ssim(img1, img2)\n", "\n", + "\n", "# This takes some minutes to run\n", - "correlate_with_tid(func_list=[rmse, one_minus_ssim, one_minus_msssim, po.metric.nlpd], name_list=[\"RMSE\", \"1 - SSIM\", \"1 - (MS-SSIM)\", \"NLPD\"]) " + "correlate_with_tid(\n", + " func_list=[rmse, one_minus_ssim, one_minus_msssim, po.metric.nlpd],\n", + " name_list=[\"RMSE\", \"1 - SSIM\", \"1 - (MS-SSIM)\", \"NLPD\"],\n", + ")" ] }, { diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index a6fc4a13..e71e4f2f 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -38,32 +38,37 @@ "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "%matplotlib inline\n", "\n", "import pyrtools as pt\n", "import plenoptic as po\n", "from plenoptic.tools import to_numpy\n", + "\n", "%load_ext autoreload\n", "%autoreload 2\n", "\n", "import torch\n", "import torch.nn as nn\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", - "# if this fails, install torchvision in your plenoptic environment \n", + "# if this fails, install torchvision in your plenoptic environment\n", "# and restart the notebook kernel.\n", "try:\n", " import torchvision\n", "except ModuleNotFoundError:\n", - " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", - " \" please install it in your plenoptic environment \"\n", - " \"and restart the notebook kernel\")\n", + " raise ModuleNotFoundError(\n", + " \"optional dependency torchvision not found!\"\n", + " \" please install it in your plenoptic environment \"\n", + " \"and restart the notebook kernel\"\n", + " )\n", "import torchvision.transforms as transforms\n", "from torchvision import models\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "dtype = torch.float32\n", + "dtype = torch.float32\n", "torch.__version__" ] }, @@ -124,7 +129,7 @@ "# convention: full name for numpy arrays, short hands for torch tensors\n", "video = to_numpy(vid).squeeze()\n", "print(video.shape)\n", - "pt.imshow(list(video.squeeze()), zoom=4, col_wrap=6);" + "pt.imshow(list(video.squeeze()), zoom=4, col_wrap=6)" ] }, { @@ -142,28 +147,32 @@ "outputs": [], "source": [ "import torch.fft\n", + "\n", + "\n", "class Fourier(nn.Module):\n", - " def __init__(self, representation = 'amp'):\n", + " def __init__(self, representation=\"amp\"):\n", " super().__init__()\n", " self.representation = representation\n", - " \n", + "\n", " def spectrum(self, x):\n", " return torch.fft.rfftn(x, dim=(2, 3))\n", "\n", " def forward(self, x):\n", - " if self.representation == 'amp':\n", + " if self.representation == \"amp\":\n", " return torch.abs(self.spectrum(x))\n", - " elif self.representation == 'phase':\n", + " elif self.representation == \"phase\":\n", " return torch.angle(self.spectrum(x))\n", - " elif self.representation == 'rectangular':\n", + " elif self.representation == \"rectangular\":\n", " return self.spectrum(x)\n", - " elif self.representation == 'polar':\n", - " return torch.cat((torch.abs(self.spectrum(x)),\n", - " torch.angle(self.spectrum(x))),\n", - " dim=1)\n", + " elif self.representation == \"polar\":\n", + " return torch.cat(\n", + " (torch.abs(self.spectrum(x)), torch.angle(self.spectrum(x))),\n", + " dim=1,\n", + " )\n", "\n", - "model = Fourier('amp')\n", - "# model = Fourier('polar') # note: need pytorch>=1.8 to take gradients through torch.angle " + "\n", + "model = Fourier(\"amp\")\n", + "# model = Fourier('polar') # note: need pytorch>=1.8 to take gradients through torch.angle" ] }, { @@ -198,9 +207,9 @@ } ], "source": [ - "n_steps = len(video)-1\n", - "moog = po.synth.Geodesic(imgA, imgB, model, n_steps, initial_sequence='bridge')\n", - "optim = torch.optim.Adam([moog._geodesic], lr=.01, amsgrad=True)\n", + "n_steps = len(video) - 1\n", + "moog = po.synth.Geodesic(imgA, imgB, model, n_steps, initial_sequence=\"bridge\")\n", + "optim = torch.optim.Adam([moog._geodesic], lr=0.01, amsgrad=True)\n", "moog.synthesize(max_iter=500, optimizer=optim, store_progress=True)" ] }, @@ -222,7 +231,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", "po.synth.geodesic.plot_deviation_from_line(moog, vid, ax=axes[1]);" ] }, @@ -243,14 +252,20 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.step_energy), alpha=.2);\n", - "plt.plot(moog.step_energy.mean(1), 'r-', label='path energy')\n", - "plt.axhline(torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2) ** 2 / moog.n_steps ** 2)\n", + "plt.plot(po.to_numpy(moog.step_energy), alpha=0.2)\n", + "plt.plot(moog.step_energy.mean(1), \"r-\", label=\"path energy\")\n", + "plt.axhline(\n", + " torch.linalg.vector_norm(\n", + " moog.model(moog.image_a) - moog.model(moog.image_b), ord=2\n", + " )\n", + " ** 2\n", + " / moog.n_steps**2\n", + ")\n", "plt.legend()\n", - "plt.title('evolution of representation step energy')\n", - "plt.ylabel('step energy')\n", - "plt.xlabel('iteration')\n", - "plt.yscale('log')\n", + "plt.title(\"evolution of representation step energy\")\n", + "plt.ylabel(\"step energy\")\n", + "plt.xlabel(\"iteration\")\n", + "plt.yscale(\"log\")\n", "plt.show()" ] }, @@ -282,7 +297,7 @@ ], "source": [ "plt.plot(moog.calculate_jerkiness().detach())\n", - "plt.title('final representation step jerkiness')" + "plt.title(\"final representation step jerkiness\")" ] }, { @@ -302,11 +317,10 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.dev_from_line[..., 1]));\n", - "\n", - "plt.title('evolution of distance from representation line')\n", - "plt.ylabel('distance from representation line')\n", - "plt.xlabel('iteration step')\n", + "plt.plot(po.to_numpy(moog.dev_from_line[..., 1]))\n", + "plt.title(\"evolution of distance from representation line\")\n", + "plt.ylabel(\"distance from representation line\")\n", + "plt.xlabel(\"iteration step\")\n", "plt.show()" ] }, @@ -359,24 +373,38 @@ "source": [ "pixelfade = to_numpy(moog.pixelfade.squeeze())\n", "geodesic = to_numpy(moog.geodesic.squeeze())\n", - "fig = pt.imshow([video[5], pixelfade[5], geodesic[5]],\n", - " title=['video', 'pixelfade', 'geodesic'],\n", - " col_wrap=3, zoom=4);\n", - "\n", + "fig = pt.imshow(\n", + " [video[5], pixelfade[5], geodesic[5]],\n", + " title=[\"video\", \"pixelfade\", \"geodesic\"],\n", + " col_wrap=3,\n", + " zoom=4,\n", + ")\n", "size = geodesic.shape[-1]\n", - "h, m , l = (size//2 + size//4, size//2, size//2 - size//4)\n", + "h, m, l = (size // 2 + size // 4, size // 2, size // 2 - size // 4)\n", "\n", "# for a in fig.get_axes()[0]:\n", "a = fig.get_axes()[0]\n", "for line in (h, m, l):\n", " a.axhline(line, lw=2)\n", "\n", - "pt.imshow([video[:,l], pixelfade[:,l], geodesic[:,l]],\n", - " title=None, col_wrap=3, zoom=4);\n", - "pt.imshow([video[:,m], pixelfade[:,m], geodesic[:,m]],\n", - " title=None, col_wrap=3, zoom=4);\n", - "pt.imshow([video[:,h], pixelfade[:,h], geodesic[:,h]],\n", - " title=None, col_wrap=3, zoom=4);" + "pt.imshow(\n", + " [video[:, l], pixelfade[:, l], geodesic[:, l]],\n", + " title=None,\n", + " col_wrap=3,\n", + " zoom=4,\n", + ")\n", + "pt.imshow(\n", + " [video[:, m], pixelfade[:, m], geodesic[:, m]],\n", + " title=None,\n", + " col_wrap=3,\n", + " zoom=4,\n", + ")\n", + "pt.imshow(\n", + " [video[:, h], pixelfade[:, h], geodesic[:, h]],\n", + " title=None,\n", + " col_wrap=3,\n", + " zoom=4,\n", + ");" ] }, { @@ -413,7 +441,7 @@ } ], "source": [ - "model = po.simul.OnOff(kernel_size=(31,31), pretrained=True)\n", + "model = po.simul.OnOff(kernel_size=(31, 31), pretrained=True)\n", "po.tools.remove_grad(model)\n", "po.imshow(model(imgA), zoom=8);" ] @@ -425,7 +453,7 @@ "outputs": [], "source": [ "n_steps = 10\n", - "moog = po.synth.Geodesic(imgA, imgB, model, n_steps, initial_sequence='bridge')" + "moog = po.synth.Geodesic(imgA, imgB, model, n_steps, initial_sequence=\"bridge\")" ] }, { @@ -471,7 +499,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" ] }, @@ -492,12 +520,12 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.dev_from_line[...,0]))\n", + "plt.plot(po.to_numpy(moog.dev_from_line[..., 0]))\n", "\n", - "plt.title('evolution of distance from representation line')\n", - "plt.ylabel('distance from representation line')\n", - "plt.xlabel('iteration step')\n", - "plt.yscale('log')\n", + "plt.title(\"evolution of distance from representation line\")\n", + "plt.ylabel(\"distance from representation line\")\n", + "plt.xlabel(\"iteration step\")\n", + "plt.yscale(\"log\")\n", "plt.show()" ] }, @@ -518,14 +546,20 @@ } ], "source": [ - "plt.plot(po.to_numpy(moog.step_energy), alpha=.2);\n", - "plt.plot(moog.step_energy.mean(1), 'r-', label='path energy')\n", - "plt.axhline(torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2) ** 2 / moog.n_steps ** 2)\n", + "plt.plot(po.to_numpy(moog.step_energy), alpha=0.2)\n", + "plt.plot(moog.step_energy.mean(1), \"r-\", label=\"path energy\")\n", + "plt.axhline(\n", + " torch.linalg.vector_norm(\n", + " moog.model(moog.image_a) - moog.model(moog.image_b), ord=2\n", + " )\n", + " ** 2\n", + " / moog.n_steps**2\n", + ")\n", "plt.legend()\n", - "plt.title('evolution of representation step energy')\n", - "plt.ylabel('step energy')\n", - "plt.xlabel('iteration')\n", - "plt.yscale('log')\n", + "plt.title(\"evolution of representation step energy\")\n", + "plt.ylabel(\"step energy\")\n", + "plt.xlabel(\"iteration\")\n", + "plt.yscale(\"log\")\n", "plt.show()" ] }, @@ -557,7 +591,7 @@ ], "source": [ "plt.plot(moog.calculate_jerkiness().detach())\n", - "plt.title('final representation step jerkiness')" + "plt.title(\"final representation step jerkiness\")" ] }, { @@ -577,7 +611,7 @@ } ], "source": [ - "geodesic = po.to_numpy(moog.geodesic).squeeze()\n", + "geodesic = po.to_numpy(moog.geodesic).squeeze()\n", "pixelfade = po.to_numpy(moog.pixelfade).squeeze()\n", "assert geodesic.shape == pixelfade.shape\n", "geodesic.shape" @@ -629,12 +663,12 @@ } ], "source": [ - "print('geodesic')\n", - "pt.imshow(list(geodesic), vrange='auto1', title=None, zoom=4);\n", - "print('diff')\n", - "pt.imshow(list(geodesic - pixelfade), vrange='auto1', title=None, zoom=4);\n", - "print('pixelfade')\n", - "pt.imshow(list(pixelfade), vrange='auto1', title=None, zoom=4);" + "print(\"geodesic\")\n", + "pt.imshow(list(geodesic), vrange=\"auto1\", title=None, zoom=4)\n", + "print(\"diff\")\n", + "pt.imshow(list(geodesic - pixelfade), vrange=\"auto1\", title=None, zoom=4)\n", + "print(\"pixelfade\")\n", + "pt.imshow(list(pixelfade), vrange=\"auto1\", title=None, zoom=4);" ] }, { @@ -655,10 +689,10 @@ ], "source": [ "# checking that the range constraint is met\n", - "plt.hist(video.flatten(), histtype='step', density=True, label='video')\n", - "plt.hist(pixelfade.flatten(), histtype='step', density=True, label='pixelfade')\n", - "plt.hist(geodesic.flatten(), histtype='step', density=True, label='geodesic');\n", - "plt.title('signal value histogram')\n", + "plt.hist(video.flatten(), histtype=\"step\", density=True, label=\"video\")\n", + "plt.hist(pixelfade.flatten(), histtype=\"step\", density=True, label=\"pixelfade\")\n", + "plt.hist(geodesic.flatten(), histtype=\"step\", density=True, label=\"geodesic\")\n", + "plt.title(\"signal value histogram\")\n", "plt.legend(loc=1)\n", "plt.show()" ] @@ -709,16 +743,18 @@ "# We have some optional example images that we'll download for this. In order to do so,\n", "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError for you,\n", "# then install pooch in your plenoptic environment and restart your kernel.\n", - "sample_image_dir = po.data.fetch_data('sample_images.tar.gz')\n", - "imgA = po.load_images(sample_image_dir / 'frontwindow_affine.jpeg', as_gray=False)\n", - "imgB = po.load_images(sample_image_dir / 'frontwindow.jpeg', as_gray=False)\n", + "sample_image_dir = po.data.fetch_data(\"sample_images.tar.gz\")\n", + "imgA = po.load_images(\n", + " sample_image_dir / \"frontwindow_affine.jpeg\", as_gray=False\n", + ")\n", + "imgB = po.load_images(sample_image_dir / \"frontwindow.jpeg\", as_gray=False)\n", "u = 300\n", "l = 90\n", - "imgA = imgA[..., u:u+224, l:l+224]\n", - "imgB = imgB[..., u:u+224, l:l+224]\n", - "po.imshow([imgA, imgB], as_rgb=True);\n", + "imgA = imgA[..., u : u + 224, l : l + 224]\n", + "imgB = imgB[..., u : u + 224, l : l + 224]\n", + "po.imshow([imgA, imgB], as_rgb=True)\n", "diff = imgA - imgB\n", - "po.imshow(diff);\n", + "po.imshow(diff)\n", "pt.image_compare(po.to_numpy(imgA, True), po.to_numpy(imgB, True));" ] }, @@ -740,13 +776,16 @@ ], "source": [ "from torchvision import models\n", + "\n", + "\n", "# Create a class that takes the nth layer output of a given model\n", "class NthLayer(torch.nn.Module):\n", " \"\"\"Wrap any model to get the response of an intermediate layer\n", - " \n", + "\n", " Works for Resnet18 or VGG16.\n", - " \n", + "\n", " \"\"\"\n", + "\n", " def __init__(self, model, layer=None):\n", " \"\"\"\n", " Parameters\n", @@ -758,17 +797,23 @@ " super().__init__()\n", "\n", " # TODO\n", - " # is centrering appropriate??? \n", - " self.normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", - " std=[0.229, 0.224, 0.225])\n", + " # is centrering appropriate???\n", + " self.normalize = transforms.Normalize(\n", + " mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]\n", + " )\n", " try:\n", " # then this is VGG16\n", " features = list(model.features)\n", " except AttributeError:\n", " # then it's resnet18\n", - " features = ([model.conv1, model.bn1, model.relu, model.maxpool] + [l for l in model.layer1] + \n", - " [l for l in model.layer2] + [l for l in model.layer3] + [l for l in model.layer4] + \n", - " [model.avgpool, model.fc])\n", + " features = (\n", + " [model.conv1, model.bn1, model.relu, model.maxpool]\n", + " + [l for l in model.layer1]\n", + " + [l for l in model.layer2]\n", + " + [l for l in model.layer3]\n", + " + [l for l in model.layer4]\n", + " + [model.avgpool, model.fc]\n", + " )\n", " self.features = nn.ModuleList(features).eval()\n", "\n", " if layer is None:\n", @@ -776,20 +821,20 @@ " self.layer = layer\n", "\n", " def forward(self, x):\n", - " \n", " x = self.normalize(x)\n", " for ii, mdl in enumerate(self.features):\n", " x = mdl(x)\n", " if ii == self.layer:\n", " return x\n", "\n", + "\n", "# different potential models of human visual perception of distortions\n", "# resnet18 = NthLayer(models.resnet18(pretrained=True), layer=3)\n", "\n", "# choosing what layer representation to study\n", "# for l in range(len(models.vgg16().features)):\n", - "# print(f'({l}) ', models.vgg16().features[l]) \n", - "# y = NthLayer(models.vgg16(pretrained=True), layer=l)(imgA) \n", + "# print(f'({l}) ', models.vgg16().features[l])\n", + "# y = NthLayer(models.vgg16(pretrained=True), layer=l)(imgA)\n", "# print(\"dim\", torch.numel(y), \"shape \", y.shape,)\n", "\n", "vgg_pool1 = NthLayer(models.vgg16(pretrained=True), layer=4)\n", @@ -820,7 +865,7 @@ "predA = po.to_numpy(models.vgg16(pretrained=True)(imgA))[0]\n", "predB = po.to_numpy(models.vgg16(pretrained=True)(imgB))[0]\n", "\n", - "plt.plot(predA);\n", + "plt.plot(predA)\n", "plt.plot(predB);" ] }, @@ -935,7 +980,7 @@ ], "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", - "po.synth.geodesic.plot_loss(moog, ax=axes[0]);\n", + "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" ] }, @@ -967,7 +1012,7 @@ ], "source": [ "plt.plot(moog.calculate_jerkiness().detach())\n", - "plt.title('final representation step jerkiness')" + "plt.title(\"final representation step jerkiness\")" ] }, { @@ -1052,14 +1097,34 @@ } ], "source": [ - "po.imshow(moog.geodesic, as_rgb=True, zoom=2, title=None, vrange='auto0');\n", - "po.imshow(moog.pixelfade, as_rgb=True, zoom=2, title=None, vrange='auto0');\n", + "po.imshow(moog.geodesic, as_rgb=True, zoom=2, title=None, vrange=\"auto0\")\n", + "po.imshow(moog.pixelfade, as_rgb=True, zoom=2, title=None, vrange=\"auto0\")\n", "# per channel difference\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 0:1]], zoom=2, title=None, vrange='auto1');\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 1:2]], zoom=2, title=None, vrange='auto1');\n", - "po.imshow([(moog.geodesic - moog.pixelfade)[1:-1, 2:]], zoom=2, title=None, vrange='auto1');\n", + "po.imshow(\n", + " [(moog.geodesic - moog.pixelfade)[1:-1, 0:1]],\n", + " zoom=2,\n", + " title=None,\n", + " vrange=\"auto1\",\n", + ")\n", + "po.imshow(\n", + " [(moog.geodesic - moog.pixelfade)[1:-1, 1:2]],\n", + " zoom=2,\n", + " title=None,\n", + " vrange=\"auto1\",\n", + ")\n", + "po.imshow(\n", + " [(moog.geodesic - moog.pixelfade)[1:-1, 2:]],\n", + " zoom=2,\n", + " title=None,\n", + " vrange=\"auto1\",\n", + ")\n", "# exaggerated color difference\n", - "po.imshow([po.tools.rescale((moog.geodesic - moog.pixelfade)[1:-1])], as_rgb=True, zoom=2, title=None);" + "po.imshow(\n", + " [po.tools.rescale((moog.geodesic - moog.pixelfade)[1:-1])],\n", + " as_rgb=True,\n", + " zoom=2,\n", + " title=None,\n", + ");" ] } ], @@ -1067,7 +1132,7 @@ "kernelspec": { "display_name": "plenoptic", "language": "python", - "name": "plenoptic" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1079,7 +1144,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.10" }, "toc-autonumbering": true, "toc-showtags": true diff --git a/examples/06_Metamer.ipynb b/examples/06_Metamer.ipynb index 16f5cc68..c223c1f1 100644 --- a/examples/06_Metamer.ipynb +++ b/examples/06_Metamer.ipynb @@ -27,13 +27,14 @@ "import torch\n", "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "# Animation-related settings\n", - "plt.rcParams['animation.html'] = 'html5'\n", + "plt.rcParams[\"animation.html\"] = \"html5\"\n", "# use single-threaded ffmpeg for animation writer\n", - "plt.rcParams['animation.writer'] = 'ffmpeg'\n", - "plt.rcParams['animation.ffmpeg_args'] = ['-threads', '1']\n", + "plt.rcParams[\"animation.writer\"] = \"ffmpeg\"\n", + "plt.rcParams[\"animation.ffmpeg_args\"] = [\"-threads\", \"1\"]\n", "import numpy as np\n", "\n", "%load_ext autoreload\n", @@ -67,7 +68,7 @@ ], "source": [ "img = po.data.curie()\n", - "po.imshow(img);" + "po.imshow(img)" ] }, { @@ -157,7 +158,7 @@ } ], "source": [ - "po.tools.display.plot_representation(data=model(img), figsize=(11, 5));" + "po.tools.display.plot_representation(data=model(img), figsize=(11, 5))" ] }, { @@ -233,7 +234,9 @@ ], "source": [ "# model response error plot has two subplots, so we increase its relative width\n", - "po.synth.metamer.plot_synthesis_status(met, width_ratios={'plot_representation_error': 2});" + "po.synth.metamer.plot_synthesis_status(\n", + " met, width_ratios={\"plot_representation_error\": 2}\n", + ");" ] }, { @@ -260,7 +263,9 @@ } ], "source": [ - "fig, axes = plt.subplots(1, 3, figsize=(25, 5), gridspec_kw={'width_ratios': [1, 1, 2]})\n", + "fig, axes = plt.subplots(\n", + " 1, 3, figsize=(25, 5), gridspec_kw={\"width_ratios\": [1, 1, 2]}\n", + ")\n", "po.synth.metamer.display_metamer(met, ax=axes[0])\n", "po.synth.metamer.plot_loss(met, ax=axes[1])\n", "po.synth.metamer.plot_representation_error(met, ax=axes[2]);" @@ -333,7 +338,9 @@ } ], "source": [ - "po.synth.metamer.plot_synthesis_status(met, iteration=-10, width_ratios={'plot_representation_error': 2});" + "po.synth.metamer.plot_synthesis_status(\n", + " met, iteration=-10, width_ratios={\"plot_representation_error\": 2}\n", + ");" ] }, { @@ -10259,7 +10266,9 @@ } ], "source": [ - "anim = po.synth.metamer.animate(met, width_ratios={'plot_representation_error': 2})\n", + "anim = po.synth.metamer.animate(\n", + " met, width_ratios={\"plot_representation_error\": 2}\n", + ")\n", "anim" ] }, @@ -10296,9 +10305,9 @@ "source": [ "met_image = po.to_numpy(met.metamer).squeeze()\n", "# convert from array to int8 for saving as an image\n", - "print(f'Metamer range: ({met_image.min()}, {met_image.max()})')\n", + "print(f\"Metamer range: ({met_image.min()}, {met_image.max()})\")\n", "met_image = po.tools.convert_float_to_int(np.clip(met_image, 0, 1))\n", - "imageio.imwrite('test.png', met_image)" + "imageio.imwrite(\"test.png\", met_image)" ] }, { @@ -10316,7 +10325,7 @@ "metadata": {}, "outputs": [], "source": [ - "met.save('test.pt')" + "met.save(\"test.pt\")" ] }, { @@ -10353,7 +10362,7 @@ "source": [ "met_copy = po.synth.Metamer(img, model)\n", "# it's modified in place, so this method doesn't return anything\n", - "met_copy.load('test.pt')\n", + "met_copy.load(\"test.pt\")\n", "(met_copy.saved_metamer == met.saved_metamer).all()" ] }, @@ -10422,7 +10431,7 @@ ], "source": [ "met = po.synth.Metamer(img, model)\n", - "opt = torch.optim.Adam([met.metamer], lr=.001, amsgrad=True)\n", + "opt = torch.optim.Adam([met.metamer], lr=0.001, amsgrad=True)\n", "met.synthesize(optimizer=opt)" ] }, @@ -10506,7 +10515,9 @@ } ], "source": [ - "met = po.synth.MetamerCTF(img, ps, loss_function=po.tools.optim.l2_norm, coarse_to_fine='together')\n", + "met = po.synth.MetamerCTF(\n", + " img, ps, loss_function=po.tools.optim.l2_norm, coarse_to_fine=\"together\"\n", + ")\n", "met.synthesize(store_progress=True, max_iter=100)\n", "# we don't show our synthesized image here, because it hasn't gone through all the scales, and so hasn't finished synthesizing" ] @@ -10550,11 +10561,25 @@ ], "source": [ "# initialize with some noise that is approximately mean-matched and with low variance\n", - "im_init = torch.rand_like(img) * .1 + img.mean()\n", - "met = po.synth.MetamerCTF(img, ps, loss_function=po.tools.optim.l2_norm, initial_image=im_init, coarse_to_fine='together', )\n", - "met.synthesize(store_progress=10, max_iter=500, \n", - " change_scale_criterion=None, ctf_iters_to_check=7)\n", - "po.imshow([met.image, met.metamer], title=['Target image', 'Synthesized metamer'], vrange='auto1');" + "im_init = torch.rand_like(img) * 0.1 + img.mean()\n", + "met = po.synth.MetamerCTF(\n", + " img,\n", + " ps,\n", + " loss_function=po.tools.optim.l2_norm,\n", + " initial_image=im_init,\n", + " coarse_to_fine=\"together\",\n", + ")\n", + "met.synthesize(\n", + " store_progress=10,\n", + " max_iter=500,\n", + " change_scale_criterion=None,\n", + " ctf_iters_to_check=7,\n", + ")\n", + "po.imshow(\n", + " [met.image, met.metamer],\n", + " title=[\"Target image\", \"Synthesized metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -14827,7 +14852,7 @@ "kernelspec": { "display_name": "plenoptic", "language": "python", - "name": "plenoptic" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -14839,7 +14864,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.10" } }, "nbformat": 4, diff --git a/examples/07_Simple_MAD.ipynb b/examples/07_Simple_MAD.ipynb index 964594a6..f1191b20 100644 --- a/examples/07_Simple_MAD.ipynb +++ b/examples/07_Simple_MAD.ipynb @@ -29,8 +29,9 @@ "import torch\n", "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "import numpy as np\n", "import itertools\n", "\n", @@ -110,24 +111,42 @@ } ], "source": [ - "img = torch.as_tensor([.5, .5], dtype=torch.float32).reshape((1, 1, 1, 2))\n", + "img = torch.as_tensor([0.5, 0.5], dtype=torch.float32).reshape((1, 1, 1, 2))\n", + "\n", + "\n", "def l1_norm(x, y):\n", - " return torch.linalg.vector_norm(x-y, ord=1)\n", + " return torch.linalg.vector_norm(x - y, ord=1)\n", + "\n", + "\n", "metrics = [po.tools.optim.l2_norm, l1_norm]\n", "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1])):\n", - " name = f'{m1.__name__}_{t}'\n", - " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values! \n", + "for t, (m1, m2) in itertools.product(\n", + " [\"min\", \"max\"], zip(metrics, metrics[::-1])\n", + "):\n", + " name = f\"{m1.__name__}_{t}\"\n", + " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values!\n", " po.tools.set_seed(10)\n", - " all_mad[name] = po.synth.MADCompetition(img, m1, m2, t, metric_tradeoff_lambda=1e4)\n", - " optim = torch.optim.Adam([all_mad[name].mad_image], lr=.0001)\n", + " all_mad[name] = po.synth.MADCompetition(\n", + " img, m1, m2, t, metric_tradeoff_lambda=1e4\n", + " )\n", + " optim = torch.optim.Adam([all_mad[name].mad_image], lr=0.0001)\n", " print(f\"Synthesizing {name}\")\n", - " all_mad[name].synthesize(store_progress=True, max_iter=2000, optimizer=optim, stop_criterion=1e-10)\n", + " all_mad[name].synthesize(\n", + " store_progress=True,\n", + " max_iter=2000,\n", + " optimizer=optim,\n", + " stop_criterion=1e-10,\n", + " )\n", "\n", "# double-check that these are all equal.\n", - "assert all([torch.allclose(all_mad['l2_norm_min'].initial_image, v.initial_image) for v in all_mad.values()])" + "assert all(\n", + " [\n", + " torch.allclose(all_mad[\"l2_norm_min\"].initial_image, v.initial_image)\n", + " for v in all_mad.values()\n", + " ]\n", + ")" ] }, { @@ -167,12 +186,24 @@ ], "source": [ "fig, axes = plt.subplots(2, 2, figsize=(10, 10))\n", - "pal = {'l1_norm': 'C0', 'l2_norm': 'C1'}\n", + "pal = {\"l1_norm\": \"C0\", \"l2_norm\": \"C1\"}\n", "for ax, (k, mad) in zip(axes.flatten(), all_mad.items()):\n", - " ax.plot(mad.optimized_metric_loss, pal[mad.optimized_metric.__name__], label=mad.optimized_metric.__name__)\n", - " ax.plot(mad.reference_metric_loss, pal[mad.reference_metric.__name__], label=mad.reference_metric.__name__)\n", - " ax.set(title=k.capitalize().replace('_', ' '), xlabel='Iteration', ylabel='Loss')\n", - "ax.legend(loc='center left', bbox_to_anchor=(1.1, 1.1))" + " ax.plot(\n", + " mad.optimized_metric_loss,\n", + " pal[mad.optimized_metric.__name__],\n", + " label=mad.optimized_metric.__name__,\n", + " )\n", + " ax.plot(\n", + " mad.reference_metric_loss,\n", + " pal[mad.reference_metric.__name__],\n", + " label=mad.reference_metric.__name__,\n", + " )\n", + " ax.set(\n", + " title=k.capitalize().replace(\"_\", \" \"),\n", + " xlabel=\"Iteration\",\n", + " ylabel=\"Loss\",\n", + " )\n", + "ax.legend(loc=\"center left\", bbox_to_anchor=(1.1, 1.1))" ] }, { @@ -190,22 +221,46 @@ "metadata": {}, "outputs": [], "source": [ - "l1 = to_numpy(torch.linalg.vector_norm(all_mad['l2_norm_max'].image - all_mad['l2_norm_max'].initial_image, ord=1))\n", - "l2 = to_numpy(torch.linalg.vector_norm(all_mad['l2_norm_max'].image - all_mad['l2_norm_max'].initial_image, ord=2))\n", - "ref = to_numpy(all_mad['l2_norm_max'].image.squeeze())\n", - "init = to_numpy(all_mad['l2_norm_max'].initial_image.squeeze())\n", + "l1 = to_numpy(\n", + " torch.linalg.vector_norm(\n", + " all_mad[\"l2_norm_max\"].image - all_mad[\"l2_norm_max\"].initial_image,\n", + " ord=1,\n", + " )\n", + ")\n", + "l2 = to_numpy(\n", + " torch.linalg.vector_norm(\n", + " all_mad[\"l2_norm_max\"].image - all_mad[\"l2_norm_max\"].initial_image,\n", + " ord=2,\n", + " )\n", + ")\n", + "ref = to_numpy(all_mad[\"l2_norm_max\"].image.squeeze())\n", + "init = to_numpy(all_mad[\"l2_norm_max\"].initial_image.squeeze())\n", + "\n", "\n", "def circle(origin, r, n=1000):\n", - " theta = 2*np.pi/n*np.arange(0, n+1)\n", - " return np.array([origin[1]+r*np.cos(theta), origin[0]+r*np.sin(theta)])\n", + " theta = 2 * np.pi / n * np.arange(0, n + 1)\n", + " return np.array(\n", + " [origin[1] + r * np.cos(theta), origin[0] + r * np.sin(theta)]\n", + " )\n", + "\n", + "\n", "def diamond(origin, r, n=1000):\n", - " theta = 2*np.pi/n*np.arange(0, n+1)\n", - " rotation = np.pi/4\n", - " square_correction = (np.abs(np.cos(theta-rotation)-np.sin(theta-rotation)) + np.abs(np.cos(theta-rotation)+np.sin(theta-rotation)))\n", + " theta = 2 * np.pi / n * np.arange(0, n + 1)\n", + " rotation = np.pi / 4\n", + " square_correction = np.abs(\n", + " np.cos(theta - rotation) - np.sin(theta - rotation)\n", + " ) + np.abs(np.cos(theta - rotation) + np.sin(theta - rotation))\n", " square_correction /= square_correction[0]\n", " r = r / square_correction\n", - " return np.array([origin[1]+r*np.cos(theta), origin[0]+r*np.sin(theta)])\n", - "l2_level_set = circle(ref, l2,)\n", + " return np.array(\n", + " [origin[1] + r * np.cos(theta), origin[0] + r * np.sin(theta)]\n", + " )\n", + "\n", + "\n", + "l2_level_set = circle(\n", + " ref,\n", + " l2,\n", + ")\n", "l1_level_set = diamond(ref, l1)" ] }, @@ -244,15 +299,15 @@ ], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n", - "ax.scatter(*ref, label='reference', c='r', s=100)\n", - "ax.scatter(*init, label='initial', c='k', s=100)\n", - "ax.plot(*l1_level_set, pal['l1_norm']+'--', label='L1 norm level set')\n", - "ax.plot(*l2_level_set, pal['l2_norm']+'--', label='L2 norm level set')\n", + "ax.scatter(*ref, label=\"reference\", c=\"r\", s=100)\n", + "ax.scatter(*init, label=\"initial\", c=\"k\", s=100)\n", + "ax.plot(*l1_level_set, pal[\"l1_norm\"] + \"--\", label=\"L1 norm level set\")\n", + "ax.plot(*l2_level_set, pal[\"l2_norm\"] + \"--\", label=\"L2 norm level set\")\n", "for k, v in all_mad.items():\n", " ec = pal[v.reference_metric.__name__]\n", - " fc = 'none' if 'min' in k else ec\n", + " fc = \"none\" if \"min\" in k else ec\n", " ax.scatter(*v.mad_image.squeeze().detach(), fc=fc, ec=ec, label=k)\n", - "plt.legend(bbox_to_anchor=(1.04,1), loc=\"upper left\")" + "plt.legend(bbox_to_anchor=(1.04, 1), loc=\"upper left\")" ] }, { @@ -281,7 +336,7 @@ } ], "source": [ - "all_mad['l1_norm_max'].mad_image - all_mad['l1_norm_max'].image" + "all_mad[\"l1_norm_max\"].mad_image - all_mad[\"l1_norm_max\"].image" ] }, { @@ -316,14 +371,24 @@ "source": [ "def create_checkerboard(image_size, period, values=[0, 1]):\n", " image = pt.synthetic_images.square_wave(image_size, period=period)\n", - " image += pt.synthetic_images.square_wave(image_size, period=period, direction=np.pi/2)\n", + " image += pt.synthetic_images.square_wave(\n", + " image_size, period=period, direction=np.pi / 2\n", + " )\n", " image += np.abs(image.min())\n", " image /= image.max()\n", - " return torch.from_numpy(np.where((image < .75) & (image > .25), *values[::-1])).unsqueeze(0).unsqueeze(0).to(torch.float32)\n", + " return (\n", + " torch.from_numpy(\n", + " np.where((image < 0.75) & (image > 0.25), *values[::-1])\n", + " )\n", + " .unsqueeze(0)\n", + " .unsqueeze(0)\n", + " .to(torch.float32)\n", + " )\n", + "\n", "\n", "# by setting the image to lie between 0 and 255 and be slightly within the max possible range, we make the optimizatio a bit easier.\n", - "img = 255 * create_checkerboard((64, 64), 16, [.1, .9])\n", - "po.imshow(img, vrange=(0, 255), zoom=4);\n", + "img = 255 * create_checkerboard((64, 64), 16, [0.1, 0.9])\n", + "po.imshow(img, vrange=(0, 255), zoom=4)\n", "# you could also do this with another natural image, give it a try!" ] }, @@ -398,25 +463,52 @@ ], "source": [ "def l1_norm(x, y):\n", - " return torch.linalg.vector_norm(x-y, ord=1)\n", + " return torch.linalg.vector_norm(x - y, ord=1)\n", + "\n", + "\n", "metrics = [po.tools.optim.l2_norm, l1_norm]\n", - "tradeoffs = {'l2_norm_max': 1e-4, 'l2_norm_min': 1e-4,\n", - " 'l1_norm_max': 1e2, 'l1_norm_min': 1e3}\n", + "tradeoffs = {\n", + " \"l2_norm_max\": 1e-4,\n", + " \"l2_norm_min\": 1e-4,\n", + " \"l1_norm_max\": 1e2,\n", + " \"l1_norm_min\": 1e3,\n", + "}\n", "\n", "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(['min', 'max'], zip(metrics, metrics[::-1])):\n", - " name = f'{m1.__name__}_{t}'\n", - " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values! \n", + "for t, (m1, m2) in itertools.product(\n", + " [\"min\", \"max\"], zip(metrics, metrics[::-1])\n", + "):\n", + " name = f\"{m1.__name__}_{t}\"\n", + " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values!\n", " po.tools.set_seed(0)\n", - " all_mad[name] = po.synth.MADCompetition(img, m1, m2, t, metric_tradeoff_lambda=tradeoffs[name], initial_noise=20, allowed_range=(0, 255), range_penalty_lambda=1)\n", - " optim = torch.optim.Adam([all_mad[name].mad_image], lr=.1)\n", + " all_mad[name] = po.synth.MADCompetition(\n", + " img,\n", + " m1,\n", + " m2,\n", + " t,\n", + " metric_tradeoff_lambda=tradeoffs[name],\n", + " initial_noise=20,\n", + " allowed_range=(0, 255),\n", + " range_penalty_lambda=1,\n", + " )\n", + " optim = torch.optim.Adam([all_mad[name].mad_image], lr=0.1)\n", " print(f\"Synthesizing {name}\")\n", - " all_mad[name].synthesize(store_progress=True, max_iter=30000, optimizer=optim, stop_criterion=1e-10)\n", + " all_mad[name].synthesize(\n", + " store_progress=True,\n", + " max_iter=30000,\n", + " optimizer=optim,\n", + " stop_criterion=1e-10,\n", + " )\n", "\n", "# double-check that these are all equal.\n", - "assert all([torch.allclose(all_mad['l2_norm_min'].initial_image, v.initial_image) for v in all_mad.values()])" + "assert all(\n", + " [\n", + " torch.allclose(all_mad[\"l2_norm_min\"].initial_image, v.initial_image)\n", + " for v in all_mad.values()\n", + " ]\n", + ")" ] }, { @@ -470,7 +562,9 @@ } ], "source": [ - "po.synth.mad_competition.display_mad_image_all(*all_mad.values(), zoom=4, vrange=(0, 255));" + "po.synth.mad_competition.display_mad_image_all(\n", + " *all_mad.values(), zoom=4, vrange=(0, 255)\n", + ");" ] }, { @@ -500,9 +594,14 @@ } ], "source": [ - "keys = ['l2_norm_min', 'l2_norm_max', 'l1_norm_min', 'l1_norm_max']\n", - "po.imshow([all_mad[k].mad_image - all_mad[k].image for k in keys], title=keys,\n", - " zoom=4, vrange='indep0', col_wrap=2);" + "keys = [\"l2_norm_min\", \"l2_norm_max\", \"l1_norm_min\", \"l1_norm_max\"]\n", + "po.imshow(\n", + " [all_mad[k].mad_image - all_mad[k].image for k in keys],\n", + " title=keys,\n", + " zoom=4,\n", + " vrange=\"indep0\",\n", + " col_wrap=2,\n", + ");" ] }, { diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index 5688609c..8a81962d 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -40,8 +40,9 @@ "import torch\n", "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "import numpy as np\n", "import warnings\n", "\n", @@ -100,7 +101,7 @@ "metadata": {}, "outputs": [], "source": [ - "model1 = lambda *args: 1-po.metric.ssim(*args, weighted=True, pad='reflect')\n", + "model1 = lambda *args: 1 - po.metric.ssim(*args, weighted=True, pad=\"reflect\")\n", "model2 = po.metric.mse" ] }, @@ -128,8 +129,14 @@ } ], "source": [ - "mad = po.synth.MADCompetition(img, optimized_metric=model1, reference_metric=model2, minmax='min', initial_noise=.04,\n", - " metric_tradeoff_lambda=10000)" + "mad = po.synth.MADCompetition(\n", + " img,\n", + " optimized_metric=model1,\n", + " reference_metric=model2,\n", + " minmax=\"min\",\n", + " initial_noise=0.04,\n", + " metric_tradeoff_lambda=10000,\n", + ")" ] }, { @@ -166,7 +173,7 @@ "with warnings.catch_warnings():\n", " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", " # which will happen briefly during synthesis.\n", - " warnings.simplefilter('ignore')\n", + " warnings.simplefilter(\"ignore\")\n", " mad.synthesize(max_iter=200)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad)" ] @@ -204,12 +211,18 @@ } ], "source": [ - "mad_ssim_max = po.synth.MADCompetition(img, optimized_metric=model1, reference_metric=model2, minmax='max', initial_noise=.04,\n", - " metric_tradeoff_lambda=1e6)\n", + "mad_ssim_max = po.synth.MADCompetition(\n", + " img,\n", + " optimized_metric=model1,\n", + " reference_metric=model2,\n", + " minmax=\"max\",\n", + " initial_noise=0.04,\n", + " metric_tradeoff_lambda=1e6,\n", + ")\n", "with warnings.catch_warnings():\n", " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", " # which will happen briefly during synthesis.\n", - " warnings.simplefilter('ignore')\n", + " warnings.simplefilter(\"ignore\")\n", " mad_ssim_max.synthesize(max_iter=200)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_ssim_max)" ] @@ -250,7 +263,7 @@ "with warnings.catch_warnings():\n", " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", " # which will happen briefly during synthesis.\n", - " warnings.simplefilter('ignore')\n", + " warnings.simplefilter(\"ignore\")\n", " mad_ssim_max.synthesize(max_iter=300)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_ssim_max)" ] @@ -286,12 +299,18 @@ } ], "source": [ - "mad_mse_min = po.synth.MADCompetition(img, optimized_metric=model2, reference_metric=model1, minmax='min', initial_noise=.04, \n", - " metric_tradeoff_lambda=1)\n", + "mad_mse_min = po.synth.MADCompetition(\n", + " img,\n", + " optimized_metric=model2,\n", + " reference_metric=model1,\n", + " minmax=\"min\",\n", + " initial_noise=0.04,\n", + " metric_tradeoff_lambda=1,\n", + ")\n", "with warnings.catch_warnings():\n", " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", " # which will happen briefly during synthesis.\n", - " warnings.simplefilter('ignore')\n", + " warnings.simplefilter(\"ignore\")\n", " mad_mse_min.synthesize(max_iter=400, stop_criterion=1e-6)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_mse_min)" ] @@ -329,12 +348,18 @@ } ], "source": [ - "mad_mse_max = po.synth.MADCompetition(img, optimized_metric=model2, reference_metric=model1, minmax='max', initial_noise=.04, \n", - " metric_tradeoff_lambda=10)\n", + "mad_mse_max = po.synth.MADCompetition(\n", + " img,\n", + " optimized_metric=model2,\n", + " reference_metric=model1,\n", + " minmax=\"max\",\n", + " initial_noise=0.04,\n", + " metric_tradeoff_lambda=10,\n", + ")\n", "with warnings.catch_warnings():\n", " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", " # which will happen briefly during synthesis.\n", - " warnings.simplefilter('ignore')\n", + " warnings.simplefilter(\"ignore\")\n", " mad_mse_max.synthesize(max_iter=200, stop_criterion=1e-6)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_mse_max)" ] @@ -375,8 +400,10 @@ } ], "source": [ - "fig, axes = plt.subplots(1, 2, figsize=(15, 5), gridspec_kw={'width_ratios': [1, 2]})\n", - "po.synth.mad_competition.display_mad_image(mad, ax=axes[0], zoom=.5)\n", + "fig, axes = plt.subplots(\n", + " 1, 2, figsize=(15, 5), gridspec_kw={\"width_ratios\": [1, 2]}\n", + ")\n", + "po.synth.mad_competition.display_mad_image(mad, ax=axes[0], zoom=0.5)\n", "po.synth.mad_competition.plot_loss(mad, axes=axes[1], iteration=-100)" ] }, @@ -404,7 +431,9 @@ } ], "source": [ - "po.synth.mad_competition.display_mad_image_all(mad, mad_mse_min, mad_ssim_max, mad_mse_max, 'SDSIM');" + "po.synth.mad_competition.display_mad_image_all(\n", + " mad, mad_mse_min, mad_ssim_max, mad_mse_max, \"SDSIM\"\n", + ")" ] }, { @@ -435,7 +464,9 @@ } ], "source": [ - "po.synth.mad_competition.plot_loss_all(mad, mad_mse_min, mad_ssim_max, mad_mse_max, 'SDSIM');" + "po.synth.mad_competition.plot_loss_all(\n", + " mad, mad_mse_min, mad_ssim_max, mad_mse_max, \"SDSIM\"\n", + ");" ] } ], diff --git a/examples/09_Original_MAD.ipynb b/examples/09_Original_MAD.ipynb index 7c02a123..a78b708c 100644 --- a/examples/09_Original_MAD.ipynb +++ b/examples/09_Original_MAD.ipynb @@ -26,6 +26,7 @@ "import matplotlib.pyplot as plt\n", "import plenoptic as po\n", "import os.path as op\n", + "\n", "%matplotlib inline\n", "\n", "%load_ext autoreload\n", @@ -51,7 +52,7 @@ "source": [ "img1 = po.data.einstein()\n", "img2 = po.data.curie()\n", - "noisy = po.tools.add_noise(img1, [2,4,8])" + "noisy = po.tools.add_noise(img1, [2, 4, 8])" ] }, { @@ -150,9 +151,11 @@ ], "source": [ "# We need to download some additional data for this portion of the notebook. In order to do so,\n", - "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError \n", + "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError\n", "# then install pooch in your plenoptic environment and restart your kernel.\n", - "fig, results = po.tools.external.plot_MAD_results('samp6', [128], vrange='row1', zoom=3)" + "fig, results = po.tools.external.plot_MAD_results(\n", + " \"samp6\", [128], vrange=\"row1\", zoom=3\n", + ")" ] }, { diff --git a/examples/Demo_Eigendistortion.ipynb b/examples/Demo_Eigendistortion.ipynb index 558c0ad6..3ee9fd8a 100644 --- a/examples/Demo_Eigendistortion.ipynb +++ b/examples/Demo_Eigendistortion.ipynb @@ -46,15 +46,18 @@ "source": [ "from plenoptic.synthesize import Eigendistortion\n", "from plenoptic.simulate.models import OnOff\n", + "\n", "# this notebook uses torchvision, which is an optional dependency.\n", - "# if this fails, install torchvision in your plenoptic environment \n", + "# if this fails, install torchvision in your plenoptic environment\n", "# and restart the notebook kernel.\n", "try:\n", " from torchvision.models import vgg16\n", "except ModuleNotFoundError:\n", - " raise ModuleNotFoundError(\"optional dependency torchvision not found!\"\n", - " \" please install it in your plenoptic environment \"\n", - " \"and restart the notebook kernel\")\n", + " raise ModuleNotFoundError(\n", + " \"optional dependency torchvision not found!\"\n", + " \" please install it in your plenoptic environment \"\n", + " \"and restart the notebook kernel\"\n", + " )\n", "import torch\n", "from torch import nn\n", "import plenoptic as po\n", @@ -115,7 +118,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -128,21 +131,23 @@ "image = po.data.parrot(as_gray=True)\n", "zoom = 1\n", "\n", + "\n", "def crop(img):\n", " \"\"\"Returns 2D numpy as image as 4D tensor Shape((b, c, h, w))\"\"\"\n", " img_tensor = img.clone()\n", - " return img_tensor[...,:254,:254] # crop to same size\n", + " return img_tensor[..., :254, :254] # crop to same size\n", + "\n", "\n", "image_tensor = crop(image).to(device)\n", "print(\"Torch image shape:\", image_tensor.shape)\n", "\n", "# reduce size of image if we're on CPU, otherwise this will take too long\n", - "if device.type == 'cpu':\n", - " image_tensor = image_tensor[...,100:164,100:164]\n", + "if device.type == \"cpu\":\n", + " image_tensor = image_tensor[..., 100:164, 100:164]\n", " # want to zoom so this is displayed at same size\n", " zoom = 256 / 64\n", - " \n", - "po.imshow(image_tensor, zoom=zoom);\n" + "\n", + "po.imshow(image_tensor, zoom=zoom)" ] }, { @@ -182,7 +187,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -197,7 +202,11 @@ "mdl_f = mdl_f.to(device)\n", "\n", "response_f = mdl_f(image_tensor)\n", - "po.imshow(response_f, title=['on channel response', 'off channel response'], zoom=zoom);" + "po.imshow(\n", + " response_f,\n", + " title=[\"on channel response\", \"off channel response\"],\n", + " zoom=zoom,\n", + ");" ] }, { @@ -296,7 +305,7 @@ "source": [ "# synthesize the top and bottom k distortions\n", "eigendist_f = Eigendistortion(image=image_tensor, model=mdl_f)\n", - "eigendist_f.synthesize(k=3, method='power', max_iter=max_iter_frontend)" + "eigendist_f.synthesize(k=3, method=\"power\", max_iter=max_iter_frontend)" ] }, { @@ -328,7 +337,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhkAAAFICAYAAAD9IOxEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA7EAAAOxAGVKw4bAADmFElEQVR4nOz9eZhsXVYWiL875ogTc0TmzZv3m6qKqgKhHwHFRhQohkYatWUSmdRypkER26JVZCicfgo4tjSKgoUMAq0CAooMUoVKIypKMxRVUl9933eHvJkRGfM87d8fJ96VK/Y9kTfz3sybeb+73+fJJzMjTpyzzz4nznr3Wu9ay1hr4eHh4eHh4eFx0Yhd9QA8PDw8PDw8Xp/wJMPDw8PDw8PjUuBJhoeHh4eHh8elwJMMDw8PDw8Pj0uBJxkeHh4eHh4elwJPMjw8PDw8PDwuBZ5keHh4eHh4eFwKPMnw8PDw8PDwuBR4kuHh4eHh4eFxKfAkQ8EY805jzNuu6NgfuT5+2Xn9JWOMvapxrcfwtrOM4UmMNeoYxph3G2Pedc59vNMY89IljO/txpi3R7z+TmPMKxd9PI/rgau8vpd5P5/x+J9pjPmKiNffboy50pLS63l56Biuw1hfr/AkYxNfB+BtV3Tsj1wfv+y8fgDgtwL4hSc8nqcJXwrgL59j+5cQzvVLlzCWt69/XPxjAJ91Ccfz8HgJl3c/nwWfCeArIl7/UYTPLo9nGImrHoDH6bDWTgH83FWP4zrDWvurVz0GY0x6fa0iYa29A+DOExySh8eVwlrbANC46nF4XC2uhSeDLi1jzJuNMT9hjBkZY141xvyh9fu/3xjzPmPMwBjz74wxb3A+nzTG/BVjzCvGmNn6918xxiTVNgljzF82xnzAGDMxxjSNMf/BGPPb1+/TVfZ167HYKLe32h/d9n/UGPPXjDGHxpiWMeZ7jTFVZ9uiMebvG2PuGWOm63P5M8YYs37/7QD+yXrzD/L4znHe5uzzc4wxP2uMGRpjuuu/P9U537+wPtbUGHPXGPONxpi02sYYY77BGPPfjTE9Y0zDGPNTxpiP3XLaZWPMd62P1zHGfKsxJrdtjtRxPtsY83Pr69oxxny/Mea5M3wuu5634/W1/1cAHvicGy4xxuwZY75DzfeBMeZHjDG763n86fWmP62u9Uvrz556rdbbMHz0mcaYbzfGHAN4xRjzbgCfCOAT1X7ftf7MA+50Y8xNY8w/Xd+LE2PMLxpjvtjZ5u3r/fyW9bz1jTG31/dy/GFz6HE1MMYE6+8Wn0kvG2P+vHMf8V577/p7fGCM+VfGmA919vXI9/OWsZ35njLGvNUY84Pr7+14/T3+dPX+uwD8QQAvqmO/Wx/H2R+fS+9dn8uRMeaHjTEvqm12jDH/YH2+s/W2f8TZz/PGmG8zxvz6elyvGWO+2xhza8s5f4Qx5mfW2942xvwf2+YnYqxbn6EeD8d182T8CwD/CMA3IHSBf5sx5i0APh7A/wkgDeDvAPguAL9Nfe47APxeAH8VwM8C+DgAfxHAGwF84XqbPwfgz6xf/+8ASgB+MwASgt8K4P8F8G0IXdsA8IEzjPmrAfwHhC7yXQB/E8DfA/DFAGCMiSF0G34UgK8B8CsAfheAvwVgB8BXrd//K+t9fTbCEMlWGGP+1PoY/wLANwEYAfgYAC+qzb5rfZy/jtAT8uEA/hKAFwD8vvU2MQB7AL4RwF0AeQB/AMDPGGN+k7X2l5xD/30APwLg8wD8RoQhiiyA33/KWL8EwP8N4NsBfD3Cef96AO82xnyktXZwyql+C4AvAPBOAP8VwKcB+J5Ttie+E+FcfCWA2wBuAPhUADmEYacvA/DN698MQx2c8VppfDOAH16PMQPg1xHOOxDev8CWlZwxJgDwHoThsb+A0MvxxQC+0xiTs9Z+q/OR7wLwzwB8K8J79Z0AXsXJvepxTWCMSQD4MQAfhvA78ssIn0lfD6CC8FkEAAWEz+CvA3AIoIbwvvl/jTEfZq29v97uke7nMwz11HvKGLOP8NnWXe+7B+BPAvhRY8zvtNb+2Pr8dgB8NE7Cgb1Tjvm9AH4Pwu/Uv1ufwyev9/GqMaa4PmYawNcCeAXAZwD4R8aYlLX2W9b72QXQQWgXmgBuAXgHgP9ojPlQa+3EOe4PAviHCG3E5wD4m8aYrrX22x4yPw97hno8DNbaK/9BeHNbAF+oXqsAWCB8SOfV61++3vbW+v+PWP//1c4+v3r9+oev//8RAP/yIeOwAN55xjG/tN7+p5zX3wFgCsCs//9d6+2+2NnuHwOYAKiu/3/7eruXthznbev/iwD6AL7/lLF9vDuf69d///r1j9jyuTjCh977Afxd9frb1p/7oYhzXQJ465ax5hE+oL7V+dwbAcwA/MlTzuEt632/w3n9W/Qx1q+9G8C71P8DAF9+yr7f5u7jnNeKn//eiH2/G8C7t9zjr6j//+R6H7/d2e4nAdwHEHPui69xtvsRAD9+2d9N/3O2H3191ffs45xtvmb9bKht2UccodEdAPgz6vVHup9P2f5M9xTCBcwcwBucMb4PwH9Wr71L39vucdT/n7w+7peeMravATAG8Cbn9W9DSMTip8zdC+v9f5ZzXayeT3Wur7nfM/X+Iz1D/c+DP9ciXKLwb/iHtbYN4AjAz9rN1e6vrX8/v/79Cevf34VNfJfz/n8G8BnGmL9qjPltxpjUWQZkjImt3Wb8cefsR53/fwlACuFqg8dfIGTw7vjSAP7ns4xD4eMQGm93pavx6QiN4g/osQP4t2pMAABjzKcaY37ahC7/BcKHypsBvDViv//c+f/7EXpDfsuWcfxWhKTou51xvIbwQfUJWz4HhPMSWx9Dw53HKPxnAF9pjPnytZvUPPQTIc57rX7ojPvddqxXrbX/IeJYN/Dg/EfdZy88xvE9Lg+fjtAL+vPOff9jCJ8Nch8ZYz7PGPOfjDEdhPfeEECAzev/SPezMSbuPLvczz3snvoEAP/RWvtBvmCtXSL0fvymtTfuPPg0hAuH07wHn47QG/1qxNztQs2LMeZ/N2GIcYBw7l5dv3XWZ9fzCD0g28Zxpmeox+m4ViRjTSw0ZgCiXgNC9zRwEu5w3YP3nff/GkK35P+G0B13bMJ4ehWn42sRGl7+fLvzfsv5n+I/Pb6mtXbxkPGdFbX179NEhLvr44+wOfZDvQ9jzEcD+NcA7iFk8h+LMOzyi2r8GkfO/9zf/injAMLV/dz5+Qh1LlHgPg+d193/o/D7APwrhG7pXwJwxxjz1REE0cV5r9V9PDqqiHZpbztW1H0WdY08rh67AN6EB+/5n1+/z+/f7wbwfQhd8Z+PkHx8DELvrb62j3o//5Rz/D/ovP+we+q0e9TgwUy4h6GG8Pu1VSCNcO4+GQ/OHRcbnDuGjH8AYXbLb0H4/AIu7tn10Geox8Nx3TQZjwJ+UW4ijN8Re/p9a+0cwN8A8DeMMXs4ibWnAXzRKfv/VoSuNaL5COOrG2MSjvHaGN85wOPfwolXx8UxwhXR27a8f2/9+3MAvGat3Th/Y0wNYbzTxa7zP70199wN1TiA0MUYNdb+ls/pfd5A6Plwj7kV1tojhDHkLzPGvBXhw/UvI3xA/KNTPnrea/U4efUtAB8S8fqj3hce1wfHCPU5X7DlfXoGPh/Av7PW/mm+sfawbhDMx7if/wRC3Yd73LOihfC56mIP4b3fOef+mgi/X6dlYh0jJDbbhJnvW//+fAD/1Fr7Tr5hjHnTKcfeRahnIc7y7DrLM9TjIbhWnoxHxM+sf3+h8/oXOe8LrLX3rbX/GGH8+yPUWzM4LNhae89a+1/UzyvnHN97EJK5z4sY3xTAf1r/73pAtuFnEcZo//gp2/wYQpdr4IydP/yC5BC6GQXGmP8FERkca3yu8//nAVipc4gaax9hfDVqHO/b8jms97nCg/P2+ad85gFYa99nrf0qhB4xXuttc33Wa3UazupheA9CRf7HOa9/IULjcdrceFxv/BjCsEN3y31P8p1DuDrW+IMI9QWROM/9vN426rhnxXsAfJyT+RFH6Fn5r9baoTr+We75H0d4bn/4lG0omH1ly9xxYRI1d6ftN+rZdRuh4H3bOM7yDPV4CJ56T4a19peNMf8MwNebMGWV2SVfDeB7rLW/AgDGmB9CGAb4BYRf0I9CGHf7ZrW79wL43caYH0eokP7gI3wxXfwbhOGZf2iM2QXwqwD+VwB/FMBfs9Zyxfre9e8vNcZ8D4CFtfa/RJxv3xjzFwD8X+sY6/cgdOn9JgCH1tpvt9a+ez0nP2CM+Vs4cdO+hFCp/WettR9A+EX6CmPM30OoL/gNCLNvtn3xPtoY8w8A/EuExcP+EsI5fn/UxtbanjHmKwH8/bX36N8gnNdbAD4JwE9Ya79vy2ffb4z5TgB/dX1d/wvCmO7v3DI2AIAxpoSQPH43Qu/JHKE7tYLwIQeEwtYlgD9sjOkhJJf/H85+rU7DewH8cWPM5yCMETe3ENN3AfjTAP6lMYZz/kUA/hcAf8JauzrDsTyuJ74bwB9CmFL6TTjRaX0IwnDt71qv5H8MwLcYY74G4XPrYxF6LDrc0ePcz9ZahpYfFX8bYRj1J40xX4fwu/tlCEXZ+nvIe/6PIPwe9aIWENbanzbG/AsAf9cY8wLCMGoaYXjku9bPu7+NkMT8e2PM316fWwHAhyIU0jKDhc+uX1kf/3cgzFrZhi9dayp+ESHh+J0A/ui279k5nqEeD8NVK0+tUgBHvP4KVNbA+rW34cHsghTCFNBXEX4JX13/n1Tb/FmEsc8WQvXy+xDqLRJqm49DuFodrI/x9lPG/FLUNmp8L6nXigjTPw8QPgDejzCd1jif/YvrsS84H3AyNtS2n4fwxh8jzOD4jwA+Rb0fQ2jEfhGhgKmLMHX3bwAoqu3+FEI36hihwOxT4WRIqHP6TIQPuy7CB+G3ImT67py4Y/0MhLn8PYSE6H8gFH996EPuiyxCEthaX5N/hTB1eWt2CcKH1j9EmH46WI/15wF8vrPvP7Iex0xfr7NcK5yi5kcY4/0hhO5Wq8b1TjgKfISu6O9E6Eaerq+Vm9nydjj307b9+Z+r+3GvB8KV/TsREoPp+n74Twh1YcxoiCF8Tt1bfy/eg3Dx88pF3c9bxnrmewqhiPIH18edIHyGfrqzTR7AP0Woe1hh/eyAk7Gxfi2JcAHIsR6tvy8vqG0qCMnGB9U2PwPgT6ltsggzzRoIvaU/AuANcDIEcZJd8uHrfYwR6tn+bNScOK+d6Rnqf07/YZqlh4eHh4eHh8eF4vWgyfDw8PDw8PC4hvAkw8PDw8PDw+NS4EmGh4eHh4eHx6XAkwwPDw8PDw+PS4EnGU8Qxph3mZNOhQ9tbGWM+e3GmH9ijPklY8zCOF08H/LZt6lj6Z/O45zDlmN9pgk7uU5M2HXyq9xqhMaY322M+R4TdjRcmXWnxsc45uPMzecaY/6FCTv9jowxv2bCcvP5xxnTlmNd2NwYY37MON1dPV4/8M8H/3x4PT4fnvo6GU8h/hvCTotumdsofArCGvn/BWEaVvERjqc7MwJO8a3HhTHmdyDsBvuPEaZ6fhTCEu4BwpRc4jMR1tb4eYRpeY+Lx5mbdyCsIvpVCNPZPgphqtsnGmM+wV5QjYpLmJuvQFjK+QcuYnwe1xL++eCfD6+v58NV59Ce9gMgfdVjuODzeRciOnSesn3M+ewr5/js23COzoyPcU7/DQ92ov1ahHnlO1vO5d3nmYdLmJudiNf+wHq+PuG6zw0i6sc8iz/++eCfD5c0N/75cIE/1yZcYox559rN8xuMMT9pws5637F+7w8bY37GGNMwxvSNMb9gjPkDEfuw6/38WWPMa8aYnjHm35iwupzeLmeM+RZjzLExZmCM+QFjzMetP/82Z9vPNsb83Npt1jHGfL8xZlvZ7QuFfUJVH40xb1i74xprt90vGGP+tzN87nmEDNvtgPudCBn3p/OFiz6Xx9mftbYR8TKrq250ZXwa5+b1CP98eBD++bAd/vlwfXBtSIbCDwH4CQC/Gyclv9+IsHz2FwL4bISdQ7/dGPMlEZ9/O8LSzH8SYS37D0VYpVLjWxGW/f0GAJ+FsPqnuw3W+//nAH4ZYTOxLwHwGwG8W8fn1APwpXOf7eXj+4wxS2NM0xjz3eubW7D+/z8h7IPwFQhL8/4SgB80xpxawhthFT0gnB+BDVtDjxCWKX9a8Enr3yzv7ufmesI/Hy4W/vlwNvjnwyPiOmoy/qa19h/oF6y1X82/TSiK+WmEnQD/dwD/YPPjmCDsDbBYbw8A/48xZt9ae8+EXQy/EMA7rLV/a/2ZnzDG5BCW2OZx8gjLx/5ja+0fV6//PMJSwW9HWH4aCEvpLvF4XTkvGl0AfxNhqeIewnjfVwH4BGPMR1lr2c31nQjH/4nW2vb6tX+7Xo19PYAfPeUY7BbZjnivjfO3sb8SGGNuIZyHH7PW/nf11jvxjM/NNYR/PlwM/PPhjPDPh8fDdfVkbMAY82ZjzD8zxtxF2JtkjrBW/1sjPv/jdrNN9y+tf9Ml+j8DMAD+H+dz/9z5/7ciFAt9tzEmwR+EgqD3IRQVAQCstX/JWpuw1r56pjN0oPe/PsZjw1r736y177DW/rC19j3W2r+D0AV3E+Eqjvh0hF+GvjOGf4OwIVpgQugxbu0S+bRhbSx+CGF/CbeL4zM9N9cU/vlwAfDPh7PBPx8eH9eRZNzX/6wv8k8gdIn+WQAfD+BjAHw7opW2bqdMtw3yzfVvV7196Py/u/79bpw8uPjzEQBqp5/G2bB2obr7vxRYa38BYcOvj1Ev7yL88rhj+EaED9sqgE903mP3QbLwSsThKnjwWlwrGGMyCB8gbwDwadbaA2eTZ3ZurjH88+GS4J8Pm/DPh4vBtQuX2LU8VuG3AngRwMdba2/zRWNM6hEPwRtlF8Bt9foNZzu2eP/9CN2fLvqPeHwX97D5pX4S0HN8jPBB+U1btj1E2HFVj5EP5l9Z//5whB1cAciDMYewVfq1hAnbx38/gN+CsHtt1Fifybm5zvDPhycC/3zwz4cLw7UjGRHIrX8LgzfG1AA8VMG7BT+P8Ev0ewH8LfX673W2+1mED4o3WWtdBfCFwVo7w4ly+VJhjPnNCF3I36te/jGELuJfttZOtnw0cozW2teMMb8I4IsQpokRX7z+zL+9gGFfONZx++9EKAD8DGvtz2/Z9Jmbm6cQ/vlwQfDPhxD++XCxeBpIxs8iFCZ9lzHmGxG6oL4aQAOPUHzGWvtrxpjvAfDX1mz1FwB8MkK1OhAKeWCt7RljvhLA3zfG7CGMs/UQpjB9EoCfsNZ+HwAYY74WYX7zmx417hoFY8wOQncbEK7WcsaYz13//595LBOm6307Qsb9nvVr3w3ggwD+K0KR10cD+PMIV2ffjBN8LcIH63uMMd8M4FWE7rr/CcAL1to/9pBhfhWAHzHGfAuA70MoIPtqAH/LWisuZ2PMizhh9Dvr13gu72HamDHm7QD+CYBPsta++zLmBqEg7/cB+KsAxsaYj1W7vmOtvXMd58YjEv75EMI/Hy5obuCfDxeL8xbWuKwfhEpdu+W9T0ZYuGSMMKb15VHbI1yBvNN57SU4RWcQrn6+BWHcawDgXwH4nevtfqPz+c9AqFbvIUwt+h8Avg3Ah7pjB/DSQ87xXThfsZ23rfcb9fN2td3bI87xLwD4/xA+QOYIBWn/EMBexHGeQ1h17i5CFn0A4McBfOEZx/nZAH4RoSvwNQBfAyDubMMxRv3ocX/Z+rUPu8S5eeWUz7r3z7WZG2f877rq7+yT/IF/Plz0d8A/H7bPzSunfNa9f67N3Djjf9dVf2f5Y9aDeuZhjHkHwrSjmt3u+nrcY7wLoYjoUwCs7FNeZOUysF5Flq21n3HVY7luWLtxYwB+HaExevvVjujZgX8+XA/458N2XNfnw9MQLrlwGGN+D8IiPP99/dLHI1Sm//3LeoAofALClcO3Afijl3yspxGfAODzrnoQ1xT/GsDvuOpBvN7hnw/XGv75sB3X8vnwTHoyjDGfDOCvIxQ5ZRHG0r4DwP/PWru8xOO+BKC+/rdhLzA+6/H6hzHmzQBK63+b1tpXrnA4r1v454PH04jr+nx4JkmGh4eHh4eHx+XjOhbj8vDw8PDw8HgdwJMMDw8PDw8Pj0uBJxlrGGPevVZ38/+3G2OuZSzJGPOKCbs6WmPMF6vX/5gx5l8bY+4aY4bGmF82YVvrpPP5t6nP65/OQ477D9bbvesRx/0pxpjvMsZ8wBgzXv/+5nVOu7tt1PisMeYjT9n/56+3ecV5fc/Zx9vOON5XHrrRybZ/0Bjzz9W1eddZP+tx/eGfD/75ELG/Vx660cm2z+zz4ZnMLjkjfhRhyeLrim9DmJ/96+q1r0XYx+HbEZa8/e0IC8r8ZgBfELGPL0NYbIhYRGwDADDG/DaE1eh6jzHmLwGQB/BXALwM4M0I0wI/zRjzkdbaobM9z1Hj/VvGVwbwd+D0tljjGOG1/GhsFhqK2s+XAvhJa+371Ws3AfxBa+1fP+WjX4ywUM5PImz77fH6hn8+KPjng38+bIMnGVtgwypq17mS2h1r7c85r3203az+9tPGGAPg640xf85a+5qz/a9G7OMBrFc6/xDhA+lPPMaYv9QZ33uMMe9H2G76cwD8U2f7qHPchm9AWNTmAGEhHoG1dg7g50zY8OhheD+AbzPG/CyAlDHmz63H9g0P+dzvYF0DY8ynnnHMHk8p/PPhBP754J8Pp+GZDJcYY36vMea9xpiJMeZXjDGfFbHNA+7QtZvrncaYrzTGvLZ2Of6oMWbHGHPDGPP9xpje+r13OJ/dM8Z8hzHmnjFmaow5MMb8iDFmFxcEG11elnXzbz3Grr8SQBzbGwGdCZc1PrWK+rJH3Qdhrf1JhLn4dYQdOT8RwG+31rqtvt3P+cJJrxP458O54Z8P/vmwFc8cyTDGfBLCOvHvQ8hAvwnA30WYE38W/CGExXm+BGH54o9HmEP/gwiL93w2wsY532iM+TT1ue9E6JL7SoSNd74cYSlaNnhi3PeVRzqx7fgkAEuE5Y5dfJ8xZmmMaRpjvtsY87y7gTHmQxDW0//SNeO/aHzS+vd7I977U+sH7tAY81Prh4U7viSAbwXwjdbaX39wF+fDOh77boQu1AOEq6h/b4x5plyczyr882ED/vnw4P7eBv98OB+uuq75k/4B8B8Q1uw36rWPRVgH/l3qtbcjuvfBe6FqyyPs1GgB/Hn1WgLAEYB/pF4bAPjyh4ztpwD8+hnO4RU4NfS3bPcbAUwAfIvz+kchfHj+boRM/CvW470NoO5s+xMAvss59rseduwzXosCQvfjL+HBev3fibBJ0ccjXIX8IsLeAB/vbPfVCOPOmfX/7wLwypbjvQ1b6v2rbb4MwFt4ruvf+/r6nvH6XMgc+Z8n++OfD/754J8PF/vzTGkyjDFxAL8FwF+x66sNANbanzvHCuHH7WbVv19b/5bWvNbahTHm1wFo5v+fAXxlGALFvwPwK3oM6899ylnP5WFYi5F+EOGK7Cud4/w3hA2liPcYY34GYUfBP4mwoRNMqEz/GJx9FXee8SUA/DMANwD8NmdOYa39/erff2+M+SEAvwzgL2MdU12vov4igM+yF1Tu2Vr7gPDLWnsPYQVIj9cx/PNBjuOfD1vgnw/nx7MWLqkDSAI4jHgv6rUotJ3/Z6e8roVEvw9hN8c/h5CZ3zHGfLUJm9pcKIwxVYSdAC2AT7fWDh72GWvtLyBcNXzMeh95hKuwvwFgaowpm1ChHUMoeCqvHwSPMj6DsF3zpwD4PdbaXz7D+PoIFf0fo17+ewgfyD+nxpcCEFv/fxYh12nHfOlxPu/x1ME/H7bAPx8ij/nS43z+WcGzRjKaCJsP3Yh4L+q1C4O19sha+2XW2lsImy99B0LW/Ucu8jjGmALCmG8NwKdaaw/OO9T17zrClKu/hvAByZ/nEaa7tQE8qkr6/wbw+QA+z1r77kccHwD8BoSttvX4vmA9xjbWKy4PjzPCPx/OMNT1b/988DgTnqlwibV2aYz5TwA+1xjzl+mONMZ8LICXEIp4nsQ43gfgq4wxXwLgIy5qv8aYLIAfAfAmAJ9orX35HJ/9zQjdnt+7fuk+TkRXGt+LUMD21xHGrs87xm8A8McB/AFr7Q+f43NFAL8LocuW+HxsrgYB4M8D+Mj1e25KnofHVvjnw6mf9c8Hj0fCM0Uy1vhahAKqHzDGfCuAXQB/CdFFWi4ExpgSwiIs340wRjsH8JkAKgjdltzupwC8aK39kEc81L9AKIT60wDy64cj8QG7ThEzxnw3gA8C+K8AugiL0Px5hMKubwaAdQzz3RHnMgFw311hrNP5vsNa+/ZtgzPG/J8I47/fDuADzvga1toPrLd7B8IH2r9DqOB+CcA7EK4mP58fsBE58saYtwOYPMIK6LFgjPkNCFdOQJgR8KIx5nPX//9ra+3oSY7H45Hhnw/++XDheJafD88cybDW/rQx5vMRPjh+AKHy+E+vfy4LE4SV8/4YgBcRpoy9D8AXWGt/VG0Xx+Ndk/91/fvvRbz3hxAqq4FQIPUFAP4Uwhv+AOED6OustcfnPagxJlj/+bAH8Wesf//h9Y/GdyBU7APh3HzW+qeE8EH3HwC83Vr7X3A98XkAvk79/zacFP15A0JFucc1h38+APDPh8vAM/t88K3en0Ksle7/FOGDcOmq0K9gPJ8G4IcBvMlae+cqx7INaxHaJyJcMX7Sk17JeHg8Kfjnw/nhnw+Xh2dN+Pl6wtcgdKt+0VUPBOGX8zuu8QNkD+Fc/eRVj8XD4wnBPx/OCP98uFx4T8ZTCGPM/wQgvf73ZWtt6yrHc92xXqV8pHrpfeuUNw+P1x388+F88M+Hy4UnGR4eHh4eHh6XAh8u8fDw8PDw8LgUeJLh4eHh4eHhcSnwJMPDw8PDw8PjUnDmnOtv+qZv8uIND49nEO94xzvMw7bxzwcPj2cPZ3k2eE+Gh4eHh4eHx6Xgmav46eHh4eFxfpyWibhuUe/h8QA8yfDw8PDweADnKW9grfVEwyMSnmR4eHh4eAhccqH/90TC47zwJMPDw8PjGYJLIjRx0O9Zax8gGJflseA+fXHI1x+88NPDw8PjdYwoEkEC4RIJF1FEwxiDWCwmf7vHcI+lt9v2vsfrF96T4eHh4fE6wTYvhfZCaKKhPQgkA8vlcuN/TSxisc116Wq12jh2FGHQxzztuHpceuzbXvN4OuBJhoeHh8c1xrZwRtRrUe+TGLgGXRt7kgW+vlqtNohFIpFAPB7f2H61WiEWi8nf1trIY+ljcr88jktaTpsDH0p5OuFJhoeHh8c1xcNW7u7qn3/zf5IA/TpDHfF4HACwXC6FMPBzfC8ejyOVSiGRSIihXy6XG6RhtVphuVwiFosJEXHHpcmHG6bRx+U5uyRIz4Wr3/CZLdcbnmR4eHh4PAWI0kdoRHk86GFwDTQ9FPP5HPP5HMvlcsNbEY/HhZCQPJBgaKJCgrFYLJBMJjeOvy3sos9DEw6SIR5Th2L0+KNIjMf1hScZHh4eHtcY2qBqQ8zXXH0DCYA29MlkUgx3PB7fCHPM53P5PIkG37fWYj6fY7FYAAiN/GKxQDwel88lEgkkEqEpWS6XWC6XG3/zfU0I4vG47J/b89x4fJeI6PPWGpOHhZM8rhaeZHh4eHhcU+hVPsMaiURiIwSijbImHCQUmgTM53MYY5BMJjGdTrFYLJBKpQCEZCGZTD7gXVgul5jNZpH7AyDej8ViIZ9LJBLiKVksFpjNZg+ENegd0cSJxIc/3I/r7XA9IzxnwhOP6wNPMjw8PDyeEB5m8FyRJD+jV/JRXgwtvuR+SAZSqRSWyyXm8zlmsxlisdgGaQiCALPZDLPZDMPhUDwhPAb1FhwPvRrUbVhr5TVrLabTqRw7l8shHo9jPB7L9poQaW0IAEynU/G+kKxowsDz1CSDZOUsc3uWa+BxsfAkw8PDw+OScBaDpg2kK5zk3xRg0hORSqUQj8fFe8CQw2QyQTqdRi6XEwM9n88xHA6xWCyQyWSQyWTQ7/cxm81kDDT0yWQSxhhMJhNkMhkhEMlkEtlsFvF4HIPBAMvlUjwgs9kM8/kc0+kU+XweqVQKsVjsAZ1HIpFANpsVDQdJTjqdxmQy2QjluCmrOgtF6010+ITHdOddp+56geiThycZHh4eHheMh5ELl0Row+mKHPV2WpDJz8XjcUynUySTSWQyGaTTaRhjMBgMMJ/PxRCn02lkMhnxFsRiMSSTSSSTScTjcfT7ffFYjMdjpFIppNNprFYrpFIpjMdjAGFYJQgCHB8fI5lMyna5XE68JgAwHo8xn89RqVTkuNRmDIdD2Q/JAQkUPRhASGBIqlzhaJSglWJUPWfa8xF1fTzxuFx4kuHh4eFxgYgiGK6rXhtM/nbDEPF4XASSOjQwmUwwHA7FY0DdQ7FY3MjIWCwWiMViQgDG4zESiQRarRaKxeKGQHM8HsNai2w2Kx4JajRGo5F4PXRohfUzAGA0GiGVSmEwGGA2myGfz8MYg9lshvF4LB6XTqfzgBbDGCPeDCAkMcvlEtPpdEODovUiBNNpXWGpKwrVXg93G/e6edJxsfAkw8PDw+OCsI1guN4JbfwY0tD70LUn0uk0stksJpMJFosFer0eisUiRqMRAIg3YblcotvtAoB4M6iRyOfzmEwmGI/HiMViyGQy6PV6SKVSmM1mODo6Qi6XQxAEMrZ+v4/lconBYIBarYb5fA5rLTKZDFqtFjKZzIZeI5VKYbVaYTQaIZFIoFgsYjqd4ujoCKVSCfl8XkjSarXCZDJBt9uVUAc9KiRW6XRaCAfPnduxMil/GJKhJ8MlCpxTalp86OTJwZMMDw8PjwtG1KpYp5bqWhDcJpFIYD6fi3eAYYPxeCyr+Fgshlwuh3Q6LQaf4YbVarURNlmtVpjNZmi326hWq4jFYphMJmJkZ7MZMpkMFosFSqUSyuWyeBvS6TSm06l4N+hpYBhFVwIdDAbyd6lUwvHxMVKpFPL5PFqtFgqFAtLpNMbjsWhFgJDE5HI59Ho9IQnpdBoAxIORy+UwnU4Ri8UkE4ZkZjKZPDC/nAvXk6GFs1qw6pLCs3ozvHj07PAkw8PDw+MCsC2VksaPq+zZbIZEIiF6B4YNuHKfz+fyt7UW/X4f0+lUBJaFQgHJZBJHR0coFArijeDqv1wuo1AooNvtIp/PY7VaYTgcIpfLIZvNotvtwlqLXC4nAs7pdIrj42PkcjnMZjMsl0vs7++jUqngV3/1VwFAxj2ZTDCfz1GtVoWgtNttNBoNVCoVIRLD4RClUgkAJA12NpshmUwiCALk83kAQLlchjFGUmoXiwWm0ynS6bSEa1ibgyGjVCoFa62EYjjPTLGdz+fiFSEBo36FRcN0HRH+/zD9hr6u297z2IQnGR4eHh6PiSghIbUCeuXM31rASL0ChZnj8RiTyUQMJoWSDJ3E43HU63U0m02Mx2M0m00YY8RjsFqt8MEPfhCr1Qq7u7tS0ZOppPREdDodAECtVkOpVEK328VsNsOLL76IbreL8XiMg4MDdDod3Lp1C/V6HcfHxyiVSkJM+v0+MpkMisWikBOGf+7fvy8prLVaTc4pFothPB7LdslkErlcDgCEYJFEuHPV7/fR7/eFoJCUMMSi02R1/Q5qSJjxorNWXBEpr91poRf3WnuysR2eZHh4eHhcEFxBJ3Ai5KTXgimhuhonPQmZTEZW66VSScSgiUQC1WoVv/7rv45WqyVhg+l0it3dXcxmMwwGAxQKBfECWGuRz+dxfHyMbDYr4RWSliAI5P/VaiV/N5tNzGYzFItF5PN57O7uotFoIBaLIQgC8WaMRqMNo60Lg+3s7EiaqjEGnU4Hi8UC+Xxeski4n+FwiGw2KxoTelfoaeDYgiDAeDzeICjGGJkz3YOF4lK+vs1bQRJC8D1+fts1dt/zZGM7PMnw8PDwOAeiVrZubQu+zqwM7dGgAWPWBI1tsVhEMpmUwlWj0QiTyQS5XA7tdlu0EaVSCaPRaCNFM5vNyucYEqDoM5vNij5Ckxp6F4bDoQg3GaKgNqLf74tngSJN1uKoVquYTCYbaaa3b99GvV7H3bt3sVwu8dxzz6HZbMJaiyAI0Gw2EYvFNup8MDtGhymm0ymCIMBgMJBzYqhFazIWi8WGB0frN6jh0N1jSVwoHuV2bq0ShlfOm3ESRUCedXiS4eHh4XEKogzMNhc6jb7uajoYDJBKpURkyfAFV+usH5FOp9FsNpFMJrG7u4tOpyP6gRdeeAG9Xg9BECAej6PX6yGZTEqWCbM8GL6gt6LVaiEIAhweHoo+g4Z3Pp9jMBigVCpthG6SyaTUzCDxOT4+xosvvojFYoE7d+4glUrh+PgYOzs76Ha7WC6XqFQqMMYgCALJcjk6OhKjX6vVhEhMJhMkk0lUq1Xcu3cPxhhks1n0ej1kMpkNAjadTpHJZER3os9Bly8naWA2Cr03zLShp4OkiP1c+HnOob6mUTVLPM6H2MM38fDw8Hi24KaabtuGv0ku5vO5rLAZOshms+IdoGejVCptpFRSM1AqlTCZTHB4eIjZbCYC0Lt372IwGIjn4LnnnoO1VogKvRDpdBrD4RDGGNTrdQRBgL29PdTrdSwWi43Mjul0ikqlgna7LaGX0WiE+XyOer2OQqEgabHGGBwfH+Po6Aj7+/vI5XIwxmA4HIpX5tVXXwUA3Lt3D/P5HLVaTTwFyWQSjUYD4/EY3W5XUlmPjo6kcihDIvS29Hq9jflm7Yz5fI5sNiskiGm3JCoMxZBsAScpvTwWu89yW+phtHdFpxITbi2O00ShHiG8J8PDw8ND4axGYlvVSL3CZkppIpHAaDSS7I/ZbCYGk8aQK+dsNosbN26g0+lIAa0gCKTuxMHBAWazmQgaR6MRqtWqaDEKhQLa7TZ2d3eRSCTwK7/yK3j++edFmzAej6XY1mw2Ew8Cs09GoxGGwyGOj4+xv7+P0WiEer0uws3j42NYa1GpVCSNNJ/Pb9TLoBYEAPL5PA4PD3Hz5k0Mh0PE43FUKhW88sor2N/fl7LnADAYDBAEgYR5qLcg4aL3gUSAc0pCUi6XUS6XMRwOxfOhe6Hw8yyDzrRgikajwl4auoDYo9wzzyK8J8PDw8NjjdOMBQ0VDRdd8zqtkjUs2JODBa6YRsoiWKxFUavVRIB5eHgoBrXT6aDb7SKTySCbzWI+n6PZbGK1WmF/fx/FYlE8DdVqdaOAFgnAwcEBgiDACy+8sCE2BSClyJfLpazyZ7MZer0e8vk8lsslnn/+efHKTKdTTCYTWGtRq9WQy+XkHICQHNBTkk6npQJoJpORlFuSoHg8joODA6TTafHidDodZLNZyXThuDhuCj7Ze4UhGhb24nVghVEA4pVheixDJToDhq9T/wKE+pl8Po9cLifaDYa+6JmhqNXVbpzlPnrW4EmGh4eHB6INg+6TQUOiSQZXx9QQUMS4Wq3Q6XREG0AxIQApCc66F6PRCNlsVkIs9HRUKhUsFgspxhUEAUajETqdjhhTuv3ZC6RarWI8HmM2m2F/fx/Hx8dCJih4zGazYnAZJuG5l8tl9Ho9WGtF68FS4iQ17XYbQJj62mg0xPNAgSqLas1mM0wmE9y9e1eMNNNmi8UigJAIWGtRr9eFcNA7c3BwIIafIaHxeIxWq4VsNoudnR3RdRQKBRQKhY3eLtymWCwil8ttFC3j9ZjP50IOAUg4i9oMfZ35Gsml9pCcRjiedXiS4eHh4XEKtAEhUWBfD2Y6sCgUY/6xWEw6kt65cwez2UwKXWUyGdFUsIlZv9/HCy+8gMlkIoZb9+Vgpc7lcomdnR0Mh0NUKhXJWuF7DBsUCgWpvEkSxO6rJB25XE7STqlpoPCSxIKFrZLJJNrtNorFItLpNObzuYRTJpOJdIgtFovo9XrSYp6t5AuFAmKxGAqFgugdWGZ8OBxKRVDqLqgjqVQqQnRyuRwGgwGAsPkarwlJD/UjDFUxJMUiX7p0OTUYJIAsy07SNhgMpJ8LPR463ZVaGkJreLwXYxOeZHh4eHhge5lp9zWdjrpYLKSNOjueVqtVqXjJ9NJyuYxkMonJZIJCoYC7d+9iNBohl8uhVCphPp9Loax4PI5MJoN2uy0egHQ6LcSg3+9LMzIa5WKxKGmi+Xwed+/eRblcRiqVkjRV1r7QGRsMc9CjQUFnp9MRISRDDqVSSUI2+XxeUlJpWDnWfD6PxWIh5zcajbBardDr9aTmRb/fR6/Xk+Jby+VSMmMYPgGAVqslHheGcvb29qR8OQDcv39frgdBzUqz2US73d7oOjuZTLBcLsV7xHlneITiXZZ4Z/os9SdaZMvrRaLHyq76/tl2Hz0r8MJPDw8Pjy3QxhOAhBy4IuYqnivh5XKJ+/fvy+q/UChIIzCGFVarFYIgQBAEmM/n0luEHUzr9bp0Sg2CAPfv398Ig5RKJTGMdOcPBgOsVispJV6r1TCbzdDv91Gr1aQIGCuH7uzs4OjoSASg3W5XhKXL5RLFYlHqbqRSKQkZsEAYe5Lo4mH9fl8MNwWsFL6ySRsrjzILJAgCIWn5fB7lclm8BdR9sO7HcDhEsVjE/fv3UalUkEwmJYMmHo+j2+2iXq8DAFKpFOr1ungmdLdaep6YuUNBK9OKSRystZIZ1Ol0JGRDYkcvke58y3sm6j56VuE9GR4eHs803EZaJBRuv5HZbCYGjyJJutVns5mkes7nc+zt7aFQKMiKn43K6vW6CCM7nY6EXSaTCRKJBHZ2dqQ7aiwWw9HREXZ2dqQJWbVaFS8DMzIoTszlcigUChImsNZiZ2cH/X5fPBZswd5oNIRULBYLaYjGQlkUWWrBKLM4VquVkB6dMlupVMTLMRgMxAAzbZbeBhKiWCyGe/fuodPpCAE7OjqSzJJms4mbN2/i5s2bSKfT8pt6l/l8jqOjI9Go0APRaDRwcHAgZJB6EmarkGiwiRwForq2CcMxi8VCdCEU8dK7Q1Es7xFqNXjv0MNBL8ezSjS8J8PDw+OZxVnqYEynU0m9TCQSstKmEJIpkEyxZB+PdruNXq8nKZ40eIPBQFJUafC4Xx6Hx2W/EIYgut0uSqUSBoMBisUiOp0OisWifI5khRVA6XFgpUsazHK5jMFggGw2KyXGKXpk+GQ0GkkvFQpVOQ5WAh2Px3K+TD9lt1Wm8NIDwIqc9Xpdzv3GjRuSisuwRK1WQ7/fx3A4RKFQkIwZzvXNmzfRarXw/PPPb2S1sAJpvV7HcDgUQSwFmp1OBzs7O5ICS+8FS7i3Wq2NBmo6RZhVRV1CQs0MsJl9pHuokITQ4/GshU28J8PDw+OZxGkEg94L1rJg+IOpnCQWNCgstjUajaTBWalUQqVSkQJbTJ8MgkAKYNFwMp2TLdNZVrvb7SKbzYqhzGQyUmqcJGE+nyOXy0mRKoY/SHj0qhyA6BvYvp2re543dRy5XE4Ek8RsNoO1Jx1cSSRisRjK5bL8zZACw0LUZbA1PBBmp4xGI9y9exfz+Rw3btwQj0o6ncZLL70k55TNZsULNB6PJXOHqb7tdltCGqvVaoM0BEEgXqPZbIbd3V25vvF4XGqMHB4eik6EGhtjDGq1moSDgJAkFAoF0dkwZMUQGueaBBLAM+3N8J4MDw+PZxpu900aSRpYagXYdjyfz6Pf70s2wmg0klLcL7zwwoYolOGInZ0d3L17F9lsVjwLk8lEdBkMGXCFTULD5mM0ViQ17OPBHicUbM7ncwAQjwNDD+w3wpbruVxO9BKs/8DqoVy5U2NBrQm1F+wbohuj0WDzh5kfLNdNwpLP5yUT5/DwEMlkEm9605vQ7/fxwQ9+UDw89KTQOHN/HFe1Wt1I82UGzXA4xGQykSZq7GKrK51qY8/aH/l8Hm95y1skDMY51GXhZ7MZyuXyRvM1ekx0UzZdsIvb8Z7QDfSeFXhPhoeHxzMJGgAaCL1ip0eBHoxyuSwdP5mBwOqahUIBN2/eRD6fl/bn1FnkcjnkcjkcHR3hxRdfRC6XQ6vVAhCGWxhOKRaLYsjptaBng7Ud3M6tJDlabMnzYJooK3hmMhkJXZCkUNDJUA89LfSS0DuiSRjHQm0EyQt1HMlkUkI59JIwTTWXy+Hw8BCZTAa7u7vSsr7T6WA0Gknn1mQyKUW3KCC11qLb7eLevXuS3cHiZfP5HLPZDK+99poUPatWq9KSfrlcSmfZbDYr+g2ePyuXHhwcyLXgsVkFleEsdp1lKEb3UCGBIMnicbRO41lMcfUkw8PD45kCV5u666YuKa3FikzFZMXJyWQirdbz+bzUjDg4OAAA6UHCtNPpdCp1Ge7du4fxeCwVOjudjng1WJRKr9y1B4MhDOoFSH4AbIRtSBq4H+150b08uC3JFIWeuksp39eFqDiWwWAg2RlMA2Vl00wmg6OjIwmfzOdzVCoVyYwZDAa4f/8+CoUC3ve+90kWDut83Lx5E41GY6MEOHuh7O/vixfo5s2bUr9iuVyiXq/j5s2byGQyWC6XePnll9FqtZBOp/HGN75RXqeAczweo1Ao4OjoSAgevT8U8vb7ffEWVSoVCatwG9YU0R1gKdrVBbt0DQ39/7MATzI8PDyeGbgVPPXDnsaaq8/5fC7plhQBsk7CYrFAr9cTw8JS3iwwpT0L/X5fMj+oCxiPxyiXy1LoKQgCKSAFnFScJPEgqdCeDLrpuY1uysaUU9akYD+PRCKx0fCLmgqmkpI0cTvuX/fzYLYGC3cxPZWFr5LJJEqlEtrtthQgY8ExVjRlmObFF1+EMUZIUC6XwyuvvCIGnVVN2Y+FWSX0xnCOGOJ53/veJ+GNt7zlLdjd3cXdu3dx584dqVtCfQYLd7HfCUM67ChbLpfFy8K5ymazKBaL2N/fl1RYXe2V14Ql1dlRlvPH/Wsv2uudbHiS4eHh8czALQNN979e4VOESU8Fi2MBkDoTQRCICJEah2aziUajIZkdJAM09NRLzOdzMWCr1QqFQgGDwUC215Ul3YZd9FKQCLgEgP9TAzCfzxEEgbSJZxVPZkcsFgtJh83n8xgOhzJ+Eg5dEp1GcTabiTdAe1eY6cKiY7rlerlchrUWx8fH4q3pdDqinaCwkmm/LC5GkSmJGD0urFBar9dFw2KtxYd92Ifh6OgIr732GiaTiYSpKMTVQlVmn9y+fVsygBKJBBqNhtQFuXnzJqrVKvr9vnSQXa1WMq7lcolMJoN8Pg8AEtoKgkCukS5Fr+tqvN4JBuCFnx4eHs8YGBIAIOmPurAVUxRTqZSEEpgtws8zJs/upBQl0qDk83lMJhP0+30xmDokw/AExYqpVGpDj0GNBA0aPRX0MGhxpfseDTi1Jlr8SW8Ix0GPQCaTwWg0kkwQXUhL75veEhINeiR0BVGSNC1cZV0JnnOpVBJCxv2w5kYikcDh4aGEUOi92Nvbk/BVLBZDLpdDPp/HaDQSPcmtW7fw6quvIhaL4datWxiPxyKMvX37NoIgQL1eF+0Mx3JwcCDFzFiunZ4KajWYPUSPDb0YLOIFQAgXhbG8V0jOSI7cAl5aCOqGUp52kaj3ZHh4eLyuoePhNJAsMU0jSKNIQ0zRJPtp5PP5jXTJdDotRaeGwyGSySSazSbi8bjUbgAg2RQ6K4PdRZlBobugUh/iehxILHSYR3s1GD7RJEQLDnVRLa0N0OEYemZIMNzj62wNpplqDQgA6WGixaR8nVoFhipIODgPOqTA2hvJZBI7OzvijaHQNR6Pi7eI5can06lUCN3Z2RFvDENXL7zwghQro1YlnU7j7t272N3dFc/LYrHA0dGReCPoRWGaLbvKUtSrrx9rqrCKqNb7aGLBjB630dq2+/dphicZHh4er3voLBI2NqOwkGmd+kHPbUgChsMhdnZ2kMvlUKvVpIcHMxAmk4lUvCyVSlJ2Wpf/ZjlxFr+icWRdhkwmIyEV7Y3QlSgpytTEggJT1tBguqVLKujlALAh5tREg5+l8FWTG5IVHeLRrdBZMp2aFWo3KAxlxVBjjMz9dDqVzJJWq4VMJiNGmyGGg4MD5HK5jXLfAOQ4tVpNCAxFpIeHhxLKSSQSGI1GODw8lJ4mzLrh+7PZDIeHh7h16xZyuZzU0gDCeh4cM0MwtVoN1WpVPBe8Prx+JA66XoZOc6VOxe3c+npstOZJhoeHx+sabjYJRXlcqdPVnUgkEASB1Flot9uoVCq4deuWeCeOjo4AQNqxsxw2q1pSDMo6FDwGvQAkLdyGhb2Y8kpCosuc694pNIgkA8w6odHM5XISitHeEOBE06H3reeIhEu3NKdegwJPluput9syBwCkERyNK3ue0GORzWbR7Xaxs7MjKadM0Y3FYhgMBqhWq1gsFmi32xiNRqjX6+LVYHYPiQ7DWkEQ4PDwEMfHx1IHhPNAbwh7pNRqNfGuFAoFCY8EQSD3w71799Dv9zEajdDtdtHpdESLQX3OZDLB//gf/wOtVkuuPa8vG9TpueA5UpRL74ae923E4vVANDzJ8PDweN3BjWnrKowAJHwxHA7FeFJzwJ4jfPi//PLLslLe3d1Fv9+XcAA7osbjcXQ6HVSrVUl5ZC0JGqH5fC79MrSxZ5omDSBDHjQ6miRs82QwzEE9BQmLW7FTp8dumzcehx6cUqmEXq8ndTOm0ykqlQo6nY4UBOPc6kJkXP1rTw1Jh66MSS0Le7YUi0UUi0Xcvn17QwjLNFiSRHpvYrEYXnrpJXQ6HckEYsiL2SnxeBx37tzBcrlEuVwWoSe1MwxV1Wo1lEolJBIJ7O7u4rnnnkMikZCwy97eHvb391Gv1+Wa93o96W0DYEMXo0Nf2ouWzWY3qrxGdXDlves1GR4eHh7XCHxQ02Dy4U0SQaEmy3mPRiM0Gg0poBSLxaQU92QyQbValZRN1npot9sSwyeZYDVKxvB1xUrtoqfnQhMKra2g0FLrLwBsZITwcywMpUMm1EtQo6G1ADoEs23utHFka/lisYjRaCQail6vh2KxKASCYQddBIy9TDinNPxc4QOhV4kaht3dXWlv3+/3sbOzAwBS1Ozo6EjCTPxso9FAPp/Hq6++Kh4P6mc45+VyGcfHx3jDG94gFVpv3Lgh3V/H47Fc01Qqhdu3b8Nai0ajsVGqnKXM2+02Go0G9vb2JPOEGg2eF4kk9SOsvTKZTOT+0/cpyVqU6PNpJxo+u8TDw+N1gyiXsyYZzAyg2zudTkv/DxpBkgNjDMrlMlqtlpSeZsbBzs4O7t27J2WwGSJgV1VWuKTRZQGrQqEgQlGXAGgD7wo0eR76fS0IpaHXHg69nbuPbZ4MGj+SMAoteT7MmiA54wofgMynFoYydMO5TyQSG+EYepBu3LiBg4MDVKtVdLtdCTcxPZS1MjiXJEA8P+pgOPe1Wg29Xk+OSxLHqp+j0UgyesrlMprNJgqFAlKpFHK5nDSQI3FjH5jj42MAwO7uLhqNxkYqMQt5xeNxCcccHR2J3odeLC263VYrgyTFreUSFeq67vCeDA8Pj9cN9KqP8W/9kKY7njHz+XyO8XgMIDR6bBtO0tDpdJDP51EqlWQVztoKu7u7ODw8RD6fF6NIsSf1AayZQP0GwwVa8KdTUKNIh+vJ0NkjWhiqX+fqWZMUzs9Z4vxaGMowD0WsutEai37pzB2mbHIOmEnDkMlkMhHyQi+Mbj1fKpWEJJEw8Vw7nQ5KpZJ0gs3n8+h2uzJXvOYsyMXXuB1rbdBjxN4j5XIZo9EIx8fHSCaTaDQa8nl6tG7fvo16vS4hFp4zQyWZTEbSnCnqzGQyqFQqkqrL68z+LVowyrnU4T23Yqi+N54WeJLh4eHxuoHrXnZ/sxQ2Xfms0MkQSaFQwN7enhhphkRoIPQq9fj4WNqSz2Yz0Wgw7ZHGmZkeo9FoQ4xI/QLrLJCkaOPjppq6mgyXaOhMlEc1RDqThFoBHcphhgSNIjUg7B5LLw09ErFYDMPhEMViEa1WC7lcTgSl3GehUBCvD0NKACT8wfPM5XKi3QiCQLxDnGOOT1ddpQCV9UqY2RGLxbC3t4d+v4/pdIpyuSzZLQxt8HoFQSDkhkRKh4ZYr6NUKqFWq0kdFXpHGKbToSpNHnk/aFEo01ujPBr689cdnmR4eHi8LqAJhbsa5EqXq1eKN1k9cjwei3v+5Zdfln0Oh0MhHMxEocFjTQjdEp3aCBZvYqEtdiBlxVBjzANdULW3gOOnUdJZJQxFMPzgEg2dDqmJylnnj3OlS5DrdFddyCuZTEoPFpIkAGKgGXpKp9PodDrS3p3zRcLEc1oul+JlYlim3+9L6IWkh2TBPV99rXX4q1gsiuaG7d8nkwmazaZ4H4bDodTQoKaGBIuv3b9/H8PhEPv7+zJG3lfz+RzNZhPdblfCLsvlEt1uV9KDgyBANpuVEurUbNA7xOtord0ILelzfNpKkXuS4eHh8dRDx7dZ8ImKfhKERCIh5Z9zuRxGoxGGwyG63a6UmU6lUqhUKuLWL5fL0rMiFouh2+2KV4P6g8FggEqlguFwKCtShgmoy9AFqKgr0ESCnhQKJa21EmZhyWyOiWSEWgW3CiiAjfCBSz62zZ+r3dBeC60X0c3bdClxGnWGDkiCWJgql8uh0+lIiXZ6GFjOmz1emDI7GAyEuHG+SXooMmXhMBpeGmVd3IxF1eiRWC6XGI/H4lGhUU+n00in0wDCcAd1HryPWB8jl8uh2+3KOCggrVQqGI1GEgIicaAXiJoehuQASKhFa0eY/susJZ3eqtNdeZ7XHZ5keHh4PPXQBENXWKRbm0ZlMpkAALLZrMTaa7WakAl6IRhT73Q6ALBhlNj9k23Q2cqcK3b2/6CBpUFkO3drw7blXP1zrCztTUGibkdOwuHW2GDIhMcgKXAFog8Te7rbaEKxjaBwvrVHhjUoqHNh3xddOZVzyzAJvUgUW5I8sS4FX+NcAhDhJ5u6ac8QPRz0NNEDRG8I54ypxvR8sZAW7x/W3qDR53HpeaFHh8cvlUoolUowJmxPzwwXEks2xiNJpVaFc8nwC0kNvXAkjryu/Fv/vs7wJMPDw+Ophau/oDiTK0SSAeoF+BpTMKkZODw8RLPZRL/fRywWk5RK9tRggablcolXXnkFQRCIh6FcLgsRGA6H4tWggScRodiPrnI2LeN2ulaG9ogQujw4PRkMO3Clz9U7a0toz8M26LAK59ENtWiBKs9Jd5rlOGlcWdyKZbpZz4IkShMUehs6nY54crhaHwwGKJfLEkbShc3Yk4UGn4XJOC8kacws0XodEh96Lxj2GgwGAEIR8HPPPYfJZCJFu7hv6jR2dnbEC2atxb179zAYDOR+o4CVVU9ZEbVer0uNDM4bi7ExBZoVU/k+yQaroD5Naa2eZHh4eDz14CqPK+9MJiMxcMbHKfBcrVYol8uy+u90OtKm/U1vepPE/sfjMYwxaDQauHHjBqrVKmazGZ577jnRb8TjcenMSeNLgwhA0i254qXhnc/n0vskmUw+oLtw24HTuOpCWVqTQSNFLwA/p2P5xFk0Gm5mC0kFPRY6JKAzUdh9lQYyk8nImGezGcrlsjQm0/VA6JnQ/UasDbuwsuAZx6yrkmpxLcNQOlWWxplki/vRYZB2u41qtYpms4nd3V0hZ41GQ0qPl8tl7OzsoNfr4fj4GKVSCcfHx0IguK/d3V15jwSBmhv2u6HYWIfDmCarz5EeFBISvq7Jkr6+1zV04kmGh4fHUw0t8mR4ZLlcSvt06iLYNZNixcPDQykpzdUnm5wZY6QjKJttHRwcIJvNot1uS1iC4QBNCnQpcVbepDufK3hmm3Bs2htBA0hobQWNCQ0+DRx1EDp91tVRAJvkIcpjAWx6TDRx4+skTAzX6OugQxI6DKHnvVKpyLVwi4KRLHFeSFR4XOCktLruf0J9jE6XpYdFXw96AkgCGbJhqjLLx9PzcuvWLSSTSdy9exedTkeaolFEqpvIAcDR0ZH0YKFnZT6fo16vo9VqCallATJ6WEgUqVfhfDEUo0NMupjZ05Bx4kmGh4fHUw3tQmZBLK5gWY2Tq0G62Z9//nmp8kg3NuPzq9UKtVpN3OwUIAZBICQCgIQPWOCJIQyGAHhcehZ0tgazH0gwOHadZUFE1cbgPjgGGjSt1dCVQYGT7Aud4uqKQ4GTlFqGLegd4DnQKNLA6vRKl/xMp1OplppOp5FMJqUdPI+l28EDkMJlzM7Q7eW1QSbxoMZCi2X1fDDDh+eui4GRRDHtlllAzGi5d+8eut0ubt26FTn+wWCwkZa8v7+/4U2j2HM0GmEymSAIAiGy1A+x7TzLpdPTQv0QtyNR0ufA63qdxaCeZHh4eDx1oBaAWST84WqWIkmmEDKuPhwOMRwOcXR0JKmM3I8OZzA2zte0p4JGj94DAOKFoOeCBkHrIvTYdbhC6x4YwtFGhKEUXdXTFXjqHibUZtAQ0zC5q3rgQQIDbHoKGP7hebKqp1uRVBMMXVMjk8mg3++jUqmg2+1KgzUSBJ4XvSBc2VMfQQ8FCZIW9WqRKueIJI0GvdvtolQqiRjX7YDLa0svmN4/PQnValWqf1JUyveLxeJGZVFqdLrdLhqNhtTKmM1mqFQqSCaTKJVKUoo8Ho8LEZnP52i32yKS5X2lm9DxXqVXIyocdt3gSYaHh8dTB67uXJJBUaG7ep/P53jppZdw48YN7OzsiLGbTqdSlIuixnq9jul0imKxiE6nI/F2pkUyjECioUmEW2yJRliXBHe9B9qLQI+GFrPqiqDagFMDookGMyp0BgVw4jHQhb6ATQKjvRT8vA5XUMTIVT4NI7NiWBxLd6DlcWn09epce1NYBZOhJ2o06JXRqbqcW0KTMxIsEq58Pi/Ei7U7qL1gES56KHgN+v0+CoUCut0ustksjo+PRRuxWCwQBIFc49FohOl0ilu3bgEIwyXpdBrlchnlchn5fF7uGc43ySF7mCSTSVSrVcRiMVQqFezs7Mh5skIpPUokXTp0RlxXb4YnGR4eHk8NogSLfOhOp9ONokY0noy502V9fHyMo6MjWcEOh0PcuXMH3W4Xo9FIGnCxwiRXjLPZTEpK63oFmkQAm/0l3JTQqGqermdDEwzqIDQR0CXIOQa9f12gS2eG6FoafM/dP8+LngqSF2PC4mK6wiaFmd1uF8ViEYPBQCpfumXVGZrQFU0ZIqEOhaW3SSAZ9tA9Tji/27wxLhnTIlgAUra83W6LEJNppdyG4RJeazY+4/l1Oh0hWOl0GvV6Ha+99hoKhQJKpRImkwkODg4kK6nZbCIIArTbbbTbbSmJPplMpE7LZDLBdDrFK6+8Ipkr1tqNe5HEToeJ6A1xwyf691XDkwwPD4+nAjr2r1f+fOBzVZlKpcTQ0Ojk83nRFFSrVdTrddFaFAoFVKtVvPTSS6jVarKyPTo6eqB+BdNOSWaAzYe5SzbcrBBX7KiJiAtd7dPtS6LrX+hjnfZelAbD9WSQXPBzPJ7OkGBxLRYYY9EqrS3RJcnpxaB4UYdIdNoptSzAg2JXrUdwa3foQmI6LMRQEVOLWUlUCz+73S7S6TSCIJBiai6pIRErlUqSUsvy8u12W+ZZe7VYE4X3G3vdJBIJFAoFxGJhU7dbt24J4apUKtL1ttfriaiY+g/eR5pU+OwSDw8PjwuCu0JjLJ5xbZZppmcglUptlPKeTCZotVobK0Eav/F4jOFwKFVAmeLK/WSzWVQqFSmipEMawEk4gnF9js8NpWjhJs9lWzqpNppR4RXX2LokIirrIIpoaC+A9nTwnDTR0OGc2WwmpcNXq5WEN+iJ0KXDtZHnOLTQlYW0okJNevyaULhzxd/6XKgpKZfLUoeDhGi1Wknog2mszAhiiIhjZOt6IBT83r9/X1KjR6MRyuWyEBjtMeI91O/3pbopyc9qtcK9e/ckBZe1Oujx4X3E+5LeFv6Mx2NMJpMHsk2uW/0MTzI8PDyuNVz1vC64xRW23k5Xhuz1epL2x7g+hY2snDkejzEYDKR3hbVhRc7nn38e1lrcvn0b8/kcd+/eRRAEALBBNGgUaDA5Hm3sOO6HVd90sY1YROk5AES+FjWfUfuJIhhRWhAaskwmg16vJ9VNdaEtt1AWW8O7BcSoIXH1InqMnActkD0NmhQtl0sEQYBOp4NyuSxkhxlJJD2lUgm9Xk/CKcz2oAaDTdkYLnnhhRfQ6XQkLMcqngyxkQBoUSrFr8xEAcLiZa1Wa6OUODUsJGi8ZiwiR1LBDBTWJHHn5rqQDU8yPDw8ri1cgR9j0nxws5ImK0vyQczmVtlsFoVCAbVaTVatND40eBTqlUolcYX3ej20Wi3UajVks1mUy2Ukk0mp35BKpSQ1kg983Y00yu0e5Wk4S1EsTU62/dZzFLXSj9qvHoP+rcMuOqtFi15JJAqFAkaj0UZqJXUMFIGy3kU2m5XiVu450QMRNT/uew+7T/S8kvzQ48LzIEnShFVX/yRBzOVyaDQaqFarsNYKWaHOgvsEgGKxiPv376NYLEoqLL0p7H2ie6JQzHnjxg0sFgt0Oh0RzC4WC4zHYyHAOoOH5IjnzO8Dvx9nIWJPEp5keHh4PDWIxWLSj4IGguJExrp3dnZQKpXkYTybzTAYDCTltFKpyCqQBqnX64kRKBQKUpny8PAQhUJBMi7a7baMg0aGeg+62XXcXwsKH+aFOA2aCGj9QZSm47Twi8Y2b4o+jiuopHGj4depwjSCPG9dWIzZIwyZuMSG49MEQx/HzYpxxbWalOi5dXUkJENsyEbPC0M6yWQSvV4PhUIBq9UK4/FY9DsANtJgdcnwfr8PANjd3cX9+/dFxApAaq3cuHFDPCgsOjYej9Hr9ZDL5cT7Rh1QLpdDrVZDqVTCzs4O8vk8qtUqstmsdHKlJ0UTK5KM60I2PMnw8PC4ltiWnscGVQBEW8EKidZaKQtO4adOY2UMm8aG+2GDNPaiSCQSKBaLcmyuMhl7Z7XHVColRoVuboYHdNv207wR54U2Jo86n2c9jvZsuMZfa2NcvYwrSGSHWc6P3l+UpoT71UTH3Q7YzCzRxIKhHb7O+4TiUuo0xuOxCIeZGVOr1ST7JBaLbXSY5TUj2WABsVqtJiQ1m80COPEw5HI5BEGA27dvi8A1m81KaMQYg263i2q1Kl1cKYilhojeOnpgKBblvUohLomUex2vEp5keHh4XEtEPRyZLcA4OAlEKpUSI8I4+Gq1ku6odPMzhl2pVGTFyFLP6XQamUwGjUYD9+7dgzFGSAW31USDq9e9vT0hNBSe6tUugMgU0vN4Mp4k3LRaTSq2iUv1Z1wvi+7TwjLZJH96f3p+9HG3iVsBiFfArZyqhZ9s8U4PxXg8lrRmNnIjOWHIgZ/l9WaJeYbZjo+PUalUxNizW6/WrzCbqd/vw1qLQqEghdpY3IvklJoQ3YGX6dOLxQJHR0cwxqDf7+Po6Eg8NNlsVvQcPOa2lNarwvW7wz08PDzW0C5fGq0gCMSLwLg3swC42gOA5557TlaKqVQK1WoVhUIBrVZLMgsajQYymQxu3LiB4+NjxONx3Lx5E/v7+wAgFUNv3ryJTCaDbreLVquFXC4nbcCpAWEmgW5brjMtdP0KNzPkOsEdn6vXiCIYUR4Fniv7tOgUUhpxTRKiioVx//pv/b5uKqfvFe31yufzaLfbqFQqkmHCglskpSQ9fI+t5VkHJJvNit7EGCN6Ht5vxWJRDDwA8WLx+NZaIbjGGGmURjLLDJK9vT0hCCQ25XIZlUpF6nDM53MMh0PxlMxmM9k354fk56oJBuBJhoeHxzWEG1fmCpVeDKb40RXeaDQwGAxQKpVQLBYxnU5xcHCA8Xgsan8aDwr1ksmkqPtjsRiKxaII7WazmRTmopG8e/cubt68KW50GplisSiiULaQZ4dOrkrdAlnXlWAAm9qIh2W06G3dbBQa2dVqJQJY/k1Pk+414s7Tw6DFtdpjpGtrsNdIpVKRGicsoqU1NOyTMhwOpUqn1pQwbFIsFuVYLJueSCQkTZrZNplMRkSiJLL0NGSzWRwdHWE+n2Nvb088HtVqFR/84AfF48P7jvcKQzucG02kBoOB3LenNVC7CiQevomHh4fHk4O7GgWwUfZZK+tZGrpYLIornm3YrbV46aWXpAkadRKxWEwextlsFvV6HQcHByiVSjDGiAeCOg1mjORyOcmwuHfvHvb39yVuns/npQkYAGQyGYnl63Nyz/G64ixEY1u4Q3sn3BRVt8sst9lGNKLCJG7arS5y5upDGOYaDAYbqavUzfT7fZTLZbTbbRH4MgWZKc68n1gTg6SDWUMU97Lk93Q6hbUWN27cwL1793Dz5s2Nyp30WEynU+lYa4zBaDSS/ibs0AuEadjWWhweHm6IPvX8D4dDuXZ8/arJBeE9GR4eHtcS2sAwNs2qnrpLZTqdFqFcr9cTd3QqlcLh4SGSySRSqZTExPv9Pmq1GmazmTSjotdhuVxKdkqn08F4PMZoNAIAIRyj0QhvfvOb0e/3pZooDSw9I1yJUnDoiievEq5Ic9t4okIkUVqSqFRcni9JA8mELrplrd3QMJyXYLhZMC7x4D5IekgwWO1zPB6jWq2i1WqhXq9jPB5vnAd1HNQ4sD8LyYweTy6XQ6vVktBcPB7H8fExdnZ2pPcJtRM8NouZUQvCjrE8FrNPWGSuXC6jXq9LPQ1rrTTyYwYPQ3gMl/A66mv1pO8/TzI8PDyuDaLCJHxgMv6syz3TcA0GA4mpT6dTNJtNWcVyldntdoWAzGYzrFZh+ed2uy39LOgWZ7Muqvd7vR5isZhoQA4ODsSYUfTJWgiFQmEjs4ViQk00rgpuqmMUQdj2mYdpSdxMEE0ANJnQ4RBNCqJKonObKJ2Im2Wi+6DoRnG8NrpuCWtgtFotVKtVNJtN8RwAYdiFfVpITlh6nJoHPcbRaCQp1PSWMcWZWhRm2VCnw2Jm+XweAMQTRoEq5282m4mnh+nYR0dH0quH9yh/03tGXHUqqycZHh4e1xpM1eODOZlMIp/PiwHhAzaVSsnKj4WV8vm8pKmORiMxeHyQ93o9cWuXy2UpIqV1BgCkxwSrPDK9lYaRLb+1e52hEwoIAWyUHb8KPE7Y5mGkROsyXE/EtvALDWCUt4KI8mDweCQN1lqpKsry5gyPUZPDQlsAxGBnMhmMx2OUSiWMRqMNnQ8rfvKYzGBhFhPvP4Y7SIJZ5IvXmudOEsTPc8yDwUC8YMwSoWeN999wOBRdEmtqpFIpZDIZBEGAIAgkdZZzptNctVfjSRMOTzI8PDyuDbQ7N6omAxAaFy2M29nZkZoHNAyMWR8cHEjM/NatWxK/DoJAPCJserVcLiU2z/g862H82q/9Gqy1knJIgR+NWrPZxI0bNyTzhNkujP1T/U9dx1WHTC4K+jzcDBN9HV2xK4WzNML6Wm/LXnGJBg03V+6z2Uyuic4OGQ6HQv4YwtLhGgAi+GRreYbOSGQ4jmQyKV4uEgpWfmUoZj6fy745H9R3zOdz6fCqu9suFgvJDun1ejg6OtoQPJOMTKdTdLtdACf1SUiySXhJYKLEn55keHh4PLPgw5APTGaS6FVvr9fDbDbD0dGRlHRuNBro9/uIxWLiRRgMBuJhqNfr6HQ6GA6HWC6X8oBnrD6VSonugnUUtCt6tVrhrW99K4wxogNJpVLS+ns8HqNYLKLVaqFSqUiZbW2AOZZOpyOZDK8HouGml0aRwqgUVxpvrva3kYqo1+gtAU7qUtDY6qwQFswiwWBoTbePJxFkqirvDe4HgByLoQtWOOX/3L8OCelzZJl1ZoqwNwrJy2g0QqlUkgqhN27cEK8G7+mXXnoJxhjkcjlp8Z7L5SQ8w148JCr0pGiB7rbrdtnwJMPDw+PKoR+C7qoWODFgqVRKVn65XE7KOuvqiplMBqVSCePxWFaIFGfSTU5vCDUeTGVkpgrrKnA8H/jAByTDhNkm2WxWsgO0653j4/51USZd2CmqUubTDk0y3AJd9A7Qla81E67GYVsRLl3KnFoJbdRJQHToTBOATCYjjdxINIAwkyQIAgwGAwlZ8DrrsA7vH96jJDaskUIPDeuzcL88JmtiZDIZAGEorVQqodFoSAdWik37/T7i8Tja7TZefvllGRf3ff/+fTSbTclcASChEd3mnjVJtAfnSXo0PMnw8PC4FuCDjw9CNjzTaYfUYgRBgFgsJs2jCoWCCC/Z/ZJFkvgQ1gaBxopqf93gzFor4ZRut4tMJoPd3V2MRqONGL9bz8FN5eS2s9lMPDN0tUcJHZ92ouHqKrSg0w2JMAyg33czVtw0WZ0eyxAYryONvNY/kPQxbJFIJOQ6a1Gu9paQhLBMN0Mf1NEwS4aEiOPn31qkvFqtpEW8bsZGTwjTYsfjMfL5vGSVJBIJqfmSSCRw48YNFItFWGvRbDZFyxEEAWq1Gur1umSWULzKcWmCpAnGk4QnGR4eHlcKndevMzFoAOjWpqGw1kq1xNVqJQQgFotJTQRjjBh6ZonolTMNB931bODFglx0N5dKJamumEqlEASBkAddD0IbUuDEYNFdT2OntQj0flArQCL1NJKNKILBFb3uIeKemxtWIXSITO/PFYbqjBKSCQDSR4aVOXl87ofzrOd8tVqJJ4viX95v3C5qHByj9spQk8G0V3rbtPiUhNSYsDYLxZxBEIg+5Pj4WMgwM59Yhpzan8VigW63K4SbWhKOS5O3q8gy8STDw8PjSkEdBlemACTNkKGN2WwmqaXj8Vg8DHt7e2g2m0IiFosFyuXyxkrZjf3rEAwf0gCEaOh27trjYG3Y6puEgJ4Thkd0eiUAWU1PJhPxknCly1Ws7qdBUaKr13gaSIcrztRt4l2iAWAjdBJV4VN7d0gGGRbh52nYp9OpCDF1PQyGsxgacQWQvOd47QBICik1EiQm2gPD6xwlQtXnTOHpeDyGMWZDJMrz6vV6UvTN2rCQV7/fl6qfTIulxujGjRuw1uL9738/+v2+EOIgCKRgHauQzmYz0atQx8FQy5OEJxkeHh5XBu3FcIlGMpmU4kL0NlDwBoRttV999VVpeEZVfTKZRKfTkbCIbvOtoY0GjRe3Z0Mvuqb5WiaTEaPHOhwMh7haBL1SpSdEu9TpOWG5c65A6Y6PEkCeZT717yeFqDTVKKKhSRbJH0mbHjeNO8NmbqVQnfZKg6o9CRREsm6KziqhloKkTwtJSU6Gw6FU8NTExk3jjQr/cDwsrqVTmRk+4/Utl8totVobqbQkBBQaa1IKQL4D2tvHcbOzK79D+n5gwa5t3qPLgicZHh4eVwo3PdU11vQIMK7d6XSQSqXQ7XYRBAEymQxarRbK5bJU5KzX66KvYHVE11hEpVTSPc50SOAkvj0ej8Vbwgc5W4dzP3rsPJ6u5aBX8Pw8xYc0ploTENUw7DToSpjb5vii4Rrf04gGDbLb30RrGVyCRkKQzWZFi6FDMwA20kU599RXkHxwv7y+OoxB7wKvEzNRtKBTFxXj8aLCPyRQOlwDbHpnqA8hmHbdbrcfqBBL8rJYLNBqtTAcDvHcc8+JZ4JEt9VqodvtyvFIiLUeA9gseMf/LxOeZHh4eFwp9EOPq36WCgcgqy8W0yqVSmIEMpmMtG2ncQiCAEdHRxurPa3niCr6RA8Cwx+r1UlnTmafMCOFxpCr1ygBIQB5j/vUmRVuszTqM3TFUC0q1Pt34XpP3NRPbbwvGlGr+21EQ+sfXIOttRd6brVYkjUsdFM0eofc4l4kcLyWHAfBuhP0GlBgTIOtM0lIkig4ZdZQVPhG6zu0RkQTC/7NOWIGCABks1nx3lAEulgsUK1WsVqtsLOzg16vJx4Splpns1kpEDcej6WXCY9Bz5smGxqXSTQ8yfDw8Lhy8AHIHxpYGqLhcIharSYubsabV6sV7t+/j3g8LjqNdruNvb09KeFMI0WvgwudkaDd8oybM5WRnhG9vTaU2uAAEONHbYAeA42qznzgOTPFkUSEXgCd4qnd4LpBWFT4R3/+NOHleRGVrurOqTbwmgS4dTM4Vh1OckkJ542iWRbeYliDc65JAT0T3D/HyrTm2Wy24cmg94HCXxIN3S1Wly3XJFBrftxwDvUWQRDAGCNpqry/AEh9FXpt+MPQ2t27d5HJZLCzsyPaJM6dFiJXq1XxYqxWK0nlpuCZXjhXB3NZ8CTDw8PjSqD1GFyFc4XHAkM67EDNxWq1kpoTrJfBH7qdR6ORPOCBkywETQzcplxaYMgV6GKxQKlUQrfblZUiQxhu91DXOLragOFwiEKhIB1BtQHUnhyurLW3huQkykPBcdDg0dBpLQjHp1esUWGV81w7l2BE7TuqUqcev5tRogmabpbmFuFKp9NSpXM8HotBJRnQ/VO0F4XXOx6PS+0KEkbef8z+oLaC86f7oUSFTHgP6Xb33NZaK1qP1Wol9y73GwQBJpOJVK4NggCtVguTyQTD4RDGGHzYh30YOp0OBoMBAIhGo91uo9PpCAFnSI9CUFePFIvFxHvyJIiGJxkeHh5XAm1g6BbngxcISQW7qjJ0wgdmqVSSB2oQBLh///6GESIJoPGg94Nud1ZgZJyfK32daqlj4fRCMHSiMw9oTOjmZhyeRo46iyAI0Ol0UC6X0el0EASBrJI5Fy5BIGHiSlVnYuhQC8MGnCNmc3A7EjktWHQ9G+cRl55GMPQxt2VjaM+HawB1LQwdHiHxoleAGTtaN0FSpr06OnWZRFOHRvSccTxR4lSXkLqeGHqdGHbj+GjQdTo1s5R4np1OB5VKBd1uF7lcDsfHx9jb28N8PketVkMqlcL9+/dhrd0oQHfz5k3U63UYE5Ynj8Vi0pmV9yhFpPxZLBYboaPLhicZHh4eVwK9eqdhTSaT0h8kkUigUqmgUqlIF9RisYjJZCIGf7lcotfrYXd3VzwfXIHqsAEAidPrctNMHeWKVBthZghwGxIcGhsaahoKY8I0xW63K6JRhn64DduHVyoVdDod5PN5ib1z7Lp/Bl3sXM3SSGrSoAWiAKSyKbUgbgt1HX7gdThPFkuUBsPFNiIS5dlw01q1F4BkSXs2qJcgGeV2q9VKMjp4fRjGoHeBhJLX0W07rz0nJA2a8Ljvu6SP1y+fz0uHVZecAqEXgmGTnZ2dDXEmvXm8n4fDIWazmXgqgiBAKpWSvjydTgcAUK1WJV2XZJ3lxufz+QP/u4LQy4InGR4eHlcGGiDGxOkB0Eaa8Ws2l5rNZkI2crkcisUims0mstmsGAa601m+mUZYl6XWHgDXuDIMQZc8H8xa08GHMw2RtRaj0Uj6l3C17LZ8z2azUouBzbJo/KbTqRRiIqkYDAbSp4LNv3SoJSococmPNp4cAw1mVEGxs163s7yvf28jGq5nxvUouZ/XpI7XiB4CXi/t9dEZGrpmh5473nua2DBEo0Mlru7CnXeKMLvdLqrVKrrdroiYGSajqBcA8vk8Dg8PJVOk3+/LtW6326hWqwAgAmcSk/l8jmq1Cmut3GN37twRz1mtVkOlUpH7JJ1ObxAvrX8CLjf7yJMMDw+PK4FejbOEOLMs9AqTpMKYsEFUPp9Ho9EQgtBqtbC7u4tutysGi/Ht0WgkD1l6N7h6puFxH7DazU6vB/tG6JU1V9Ta9cyKo6zeyCwALc6k6HAwGGz0taBuRBdsGo/HKBQKmEwmWCwWCIIA/X5fsia09kAbUrcKqSYFJGKu/kNnQmwLZzwOtmWfuGRC/+bfOgRErwJFktRlWGslDMZrznnQeglNqoCTtOkoj0VU2qor7NTnwLBIuVxGs9kU7cVwOJS+NbyXKEwmOZ7NZqjVahJKqVQqGAwGGI/HQlqXy6XcJ8xGWq1Wco9Qh6GzU6g1yefzSKfTQnqoTbno6+zCkwwPD48rBY0OjfhkMkG3290QzMXjcRweHorIcWdnRx6QrKqoUwEzmQx6vZ6scJk1oI2vmxGhx8JVLMMrTHHUBIUrT2oruBrWRcB0nwwaKN3DRNdS0McFQrEqjSZJCytEkmjoTBh6JXRTLlYjdb0UOj6vha5uyulpYZTHMUquViPqWujjuBk41PDo1u4kZcys4OtuyEVn25DAANjwZOixaQ2GFs+6nhfOIauGVqtVCfORHJI8sj4KSQlwEloj8R0MBojH46hWqxKGqVarmM/n4lkDIOT5hRdewL1799Dtdjd69Oj+PLFYWBGUglcdqryssIknGR4eHlcCGvrZbCZGmrFqGnW6vlerFWq1mtQZaDQaUmqc5cBJBugOpgdBCzddI+IaNr061UabxgE48QRQA0BPhHa9axe7/pwruOPKXGsltIuemRIkSoVCAcPhcEM0yvlhSIlNuRh2cfuiuKEKbWwpXGSNiai+LPr6PS7ROE08qkM/umcICQY7rVLrwKqYbF5HLYurS9EeLF4Td26iwjxRGTR6bPS+MeOJYa7VaiXzSe8LRZ+tVgs7OzuiERqNRsjn8xJ2Yb0LCpjb7bb0NtHzr71XOzs7qFQqor8gcWm326Lr4HdEp/XyfC8anmR4eHhcGXSohNkUxWJRUlKPjo4wHA6FdNCY3Lx5U4oTad0Es0qYKUD9gRYSuqt0Fy7R4KqXf+siTyQierUMYMOI63NNJpMYjUZCFlgrQWsldPEu4ISI0JhuqztBA+GGTFzDGmVMXVKla3toL4ubjXIRREP/jnpPCzf5GsfJMFg8HhcPQj6fBwC5L+jRoaF2zz2KPEWdn/u/9nRo8a3OZOLYSACNMeJhGAwGqNVqODo6QqFQ2NiWWTIkx9PpFLVaTfQcbEk/m81QKBRw9+7djf0PBgMcHh5ujJ0Eh6TeDRV6T4aHh8frAtp48KHPGDLLJtOjUSwWEYvFUKlUJOskmUzi8PAQuVwOjUYDQRCIDoKGX7uxNQFwi1NtqxPgrvg5XoYwWEBJ788tmqVDJNwfG7gdHR2hWq1KmiHHQU8C0wy1MaUXh6EaXTuDIj7W1GBoiIaZK/+o/h+Em4LpdoiN6j/iko+Ljuu7oZKoMA9JGrUQ3W4XyWRSzoPzqa8DoUNgLoGKyoLZVu+Dr+mwFYmtzjwaDofIZrPodDqoVqviyRiNRlJgrNfrIZvNotlsAjjpVdLv95FMJsVDpTU5pVJJdEsM0+VyOfHmxONx0TNZazGZTMTjowWglwFPMjw8PJ4o6KZmtkcqlUI2m0UQBMjlchJHbzQaAIBSqYRGoyE9S+gW1/Up2HiKhlHrFDSh0EWdtnky9DhdL4GO9bveAm2AaAg1YWD9hsFggHq9Lk3c9H5cwqCNPbelG5xZKQCEOHAFzTHyc7FYTBpwMdYPYCuRigqZMBRDYqRX6rr+xUXeJ/p6uTUp+DeNOq8N54VEYBvB1PuJys5xM122bavvE53yyuPRGzQajaSNPHU1pVJJMqN4bagpyWaz8l3g69PpVDoFU9/T7/dhrUWz2UQ8Hpc6GalUCplMRghHsViUcWrwe8j79qLhSYaHh8cTAR9iWmzGhzbV7lpNXyqVJEQSj8dRqVRw//592VbXsaARGY/HEjphzQHXTX5ame0o6NUqY/2s1UEtBoANnYfWDFDxPx6PkUgkZCWbz+fl/GiIaAQoHNXeBAobs9mshF34uq75QJc5U3S13oWN5PiaNow6/KOJBokc55cZCgxNnKbbOO/9of/WOhM3tZTXBQBSqZR0stVaA91wTod9OE6XRLrhIy3ojCIargBUV43VGh2KMBmC0pqI5XIpmSG9Xm9DpGmMQbfbxXK5RL1el0JdOg2aKaz5fF68fBQbM9W52Wzi+PgYi8VCCCqFxPQm8rcnGR4eHk8t3LRE/rAM8nA4FCU+tRnsfEqNwnPPPScrOwo9uVJnqp5bLtotouSKCM8Ddn/lKpNt5AE8cAySIBp0eleYzjgYDBCLxZBOpzfICPUkbgMxhmoo5nN1G1rcSA+A1nIwBXY4HG4092LohfNIY05PjPYKcCy9Xk+8Mbpi6Tadw8PgekG04d5WdVOnBLP0O8NEHKsmnVroqT0hUWN3CYabuuqep/6f157j41xTCMqQRhAEkimSz+clpML7l2GQZDKJTqeDbDYrniUSp0QigU6nIxkqFASvVmGdl3v37gmBSKfTQlCZRqvn29VvXBQ8yfDw8Hhi0EWA6HJPp9MSNmFtiaOjo40eIfP5HOPxWNJYGTbhCpvGhi5kXWhKr4BdF/h5HqaxWFi2ulQqSYOqQqEgD3zXeFHESSPMlSvj67lcTrQEXM3S++KGcWiseI7aQ+OOUZ+31nRwzt1OpgA2KmhyPxTlkszp1NFisYhOpyNGU1ccfRSdxmnpxLoXiO4Xo7N+GIrgtdD3l/b4aC2HTt3Uv08jGFHj5jmS6LFGB4XIJNMkQvQg8H2GeTjfJBiLxUK2J7lrtVpCSDjPzz33HJbLJYbDoYTCBoMBZrMZ6vW63Gf9fl/GR9LJOeZcuKTpIuBJhoeHxxMBDRRLHNNI6kJQXJXu7e0JOWB/kkwmIwW2+BldaprVFGkstOhTawaihH5nHT9XxyxoRAFfu91GPp8XYR/HwWNrkZ5uWmatlZ4mNNi6Z4cO69BYaYJBbw2NFeP1uqcHwX2QaGj9gg4B6JRgigSDIMB0OgUA+Ww2m8Vqtdpoua7DLxRqntVguatpPW7tgSLBYPiB1TI5Zp0SrL1grh4HwAbh1KEQXYzrtCwknfrLedVhLV5vrRdhGikA8W4ZYzaqgTK8lc/n0W63xfugj5tMJtFoNNDv9wEA9XpdyHq9XpcCZS+99JJ44OjR4b3EEuT6Glw0PMnw8PC4VOgVkhZF8uHPFTxLiTN+zIcgCxExPk2Vvi4iRQPLVSCAUz0Wj+oOphua9TkymQxarRZqtRp6vd5Gl1UW4aJxozHm6xz3cDhEsViUNF7qTBjm0G5+LSqkboMEYLVaSdEndnnlap7Ghcedz+fI5/NCbnRYabVaSUVS1nagNoMaA51Oq8NP1KLQg3NeMhflVXBTRkk02HSOOgc9Dlc0SkIWlfqriUTU76g0Vp26Su0MyaQOSwEQPYgWsHJ/y+VSPDK6AuhyuUSj0UAsFkOpVMJkMsFoNJIQFRBmIr344otyPQaDgfS4oVeq1+uh0+lI2nSlUkE6nd6YS4YrV6vVRhjzogiHJxkeHh6XBjdFkgaABq3b7eL4+FjEg9o9zo6pfEjXarWNOhR6vzT+us13VLrh44JGtlgsot/vC9GgS57kSY9DF2tieiHfp5em1+tJgSZ6CUiaADzguqfhZ8VLkgGulikyZYgnnU5v7Ievs44EyUkQBGJ4OJ9cndMTpRuN0TDRGOuaHlHt5c8CTTRcI6+NI4tVkWSRUHJeXQ/WtnvCJRRR2gsguoEbz5XeCd7b7JzLa+IKT7VniyRPa4pWqxWef/559Ho9ISGpVArNZhPFYlFIBfVBLFdO/QnJTCKRQK/XQ6vV2vCs0YPCMfDaMhPKh0s8PDyeKrhpqwwLUIxGw8x4P2PKFKfR3Uz3ri6u5Lrp3bRSHTd3RX7nBV3iTEMcjUZyDC2S1MYLONFK6O6o/H8wGKBUKklGDI2XPke9DxpRXQuDLm+KSGnUOHf0CpG4MfuBx2M2z2AwEA8Er5MmC5xXt24FDbf2tjyKJ4NwjXyUKJR1JVhXhcaYpIrGkvOnwy5RtS5Ouzd0xpCb2st9cW5IgCjG1C3f3Uwekgo919RgsBYMdTVMYaa+olarAYB8JhY7qQhKrUoqlcIb3vAGlMtlCWmxdL/uSEvio38uypvhSYaHh8cThY5T5/N5VCoVABBDRyLChk5HR0dSJTEIgg33vStydCt7coXK47or4/OCGgi28qaHgOEa1jXQmSEu0eD4gNCzQEOpe5hog63rVLjnzHNyPQ1ROhB6XOjKp/HToRd6LUgCeS20RkGX5wY2w1J6nI+b2uoaOL0P7TXh/PF8mParQyg6XdrV6Ww7hv6f5JKeKM4b7weSNxIBamOoQSI5oAeJHiodNtSZKfF4XO4tXT2U42EfG4pyKZ5mKIlhr/F4jOPjY6TTaXS7XfR6PRGZ8n7R5Ooy0lg9yfDw8Lg06PguV1FuPJrVM9PpNBqNhugtXnvtNcRiMezv72+UU6Y2wI2Jc4WuiYb2JmhD87ieDIZHqM+g4I6rQ12Ii0bbLe9N8qMLOOmmZwAkJELDyDHwt+6PwnNlSiozXyiupYFkRVAaQhpkkgcSCl1BVXswdBqp693Q56IrbT7uiljrNAiXaNBDpOuXbCvGxnPkfqJCatpDo3VEJJPcPzVCDFUAkJASvQmcVx0SpMiWczUejxGPx6WBng5XuV4phtkoMB0MBmg2m3jhhRfQbrc39EvNZlPCaYVCAbdu3UKxWBQSQ3LDe46vXVQqqycZHh4elw4+kEk4aKz5YKPLu16vAwgJx3PPPYfxeIxmsyl5/npFx1UkdQk0oPrh7BoTHZN/FMOn4/KMkdfrdWnFTqOvdQsANoywzmzQxo3eBG34acDo1tZhFDfLhMa23++jUqng+PhY+niQiNE7ocWoTLGlvoCucu2B0dkdmsC5mR9a4Kq9TY9rrNyQhjtvmljSi6LFnm4GiSa6OvSj961TWfX9RkLLa0JtS6fTEWJHQqg9RLxGJD2cIxI+VgGl1871hJEoApBCW7ra6Vve8ha8/PLLSCQS+JAP+RAUCgUAQK1WkzTWVquFbrcr+6MOSF9vzsFFeTQ8yfDw8LhU0EBQzAmclG0mVqsVOp2OpFN2Oh3p1cAYc7fbFcPB/fJhrFewutKl20vETWV9lHPh8YfDIW7evCmxc652XU8GcNLjRAvttAHkQ173t2CaLw2KjvVrF7smGNR3tNttFIvFjWJPTPeMEjNqwSK9ADQ07lj1ebjX2M2k0SGTx0XU8fR56PRThifclFRNUnQ6rCZDPHet82H4iV4ikl1d56JcLsu801OhtTo69EQPjCbCutYH7x0dhuL9zeutRbn9fh8vv/wydnd3kclk8P73vx/37t1DIpHAcDjEyy+/jGq1Kh4fhnR6vZ4QF15nLdC+CHiS4eHhcakgwWC2AwWerNyZSCRQrVYlS2Bvbw/GGNTrdSEdw+EQlUpF6jK4ugvXbe+GTPRYHkeTQSMEhIK+RqOBer0uq1e+p6s+alJBI+d6Eyj8czugApBzcGtBaDc+xYHUXTBjYbFYiH5Ekwed5qubeLkZOi7B0F6BbammrmfjIjwZUdfBTXfVBEJ7YaIICSum6vl0wyqcG+0V0Z4cnhuADQHvaDTayKCiYJRhLWCTrJJIWmvlGkaJS7UGxFqLYrEoRbh2d3dRLpexWCzQ7/ext7eH/f19FAoFabAWi8Wwu7uL0WiERqMBY4z0CiKpYOhEf2celyB6kuHh4XEpcNXpjDcHQYBisSg1Lei14Or84OAAsVgMd+7c2WiAxiqb5XIZvV4PQRBIIzCtfdCEQxt+4nEMniYL8/lcUlmZzaEzB6JW8q6BB7CRHaKzF7j61UbPddVrcSf/p2G0NuxrwdRUAGIUtYeC5c/n87l8XntJXLFnFMHQr0ddg8cldu7vKIKxraaFGybTHgneV7qYGIkGDbomE1EpsPSm5XI59Ho96S9CTwTnmPe71gVR+MuaJDqFm/e0DlfRm8E+P9RddDodGGM2Mpfu3buHe/fuydhHoxGazSYymQxqtZpkbjFlmQsBekt4fvr3o8CTDA8Pj0sHmzPxhxkNyWQSOzs7sgJPp9PSt6RarYr3g2r+QqGA4+Nj6f1B8Zv2GAAPFnW6KGi3vM4o0aEEnSXAVa8r/qSWhOfFz1A7ocmJTifV6Zl8nfOrswr0+FiynARCzxO9TAyl0DNC0kAjytd0Fc9tZIL7dXUoj2qoogiFJmun/aa4UusbaMgptiRB1GRFe0J0Dxd9jlpXwfLlOg1Yk0Nd4VV7R5jCykqgmqTpa8PsFRJq6psKhYLc3xQMk6xUKhVUKhWUSiUkEgmpgQJA7gOOSc+1JqLudXgUeJLh4eFxadAqdVdhT0HcaDRCr9fb6FVy7949rFZhUykAG94DnUnAjBLgQZ3HZUCHD4ATL4ReMfNc3R4Z2uim02nJSKCBJyGg+I/HoxFnfJ+Fp/g6PRyj0UhIGQkCj8PQi667QfLAz7vVRaNCUdpbwN9u1ow27jrL5HE9SFEEw4Xr9SDZ01k7vDYMTTCMoceuhZf0ELD7LgmfJn3UoFCATCKgPRncl+7SygqvvEa6uBm/LxQ2UxC8Wq0kPXa1WqHVamFnZ0fCXaPRCEdHR6LVoCiZWo9CoYDZbCbzyvvYWiteDc7hRRB0TzI8PDwuFG4GAI3sYrGQssc0SP1+H7FYTLwZQCiorNfrUlCIHg+usmjo6PbWqYo0/nocFwlX3EjDpAmFjtu7Hgx6BHRhLIZGmKFQLBYjRYvAiceCBooub2o5+LqeF+4fOGmEpgmAMSe9NnQ6rBZ4ahe/a+RdASvnSQty3fTIR8HDvFOu+JPnoL0A9C5xvhh60teNxpufY3oyCYRuJOem+WoCSuKlr4HOeOHn9dzzNYZyZrOZkEWGddLpNI6PjyVUt7Ozg+PjYyEgALCzs/NA8zp+f/r9PjqdDpbLJYIgQBAE0u2V948Olz0u0fAkw8PD48Lguqx1NkgikZBW03T1s8DRZDKRngx0TXe7XQmH0Pjxwe+m3em+EDz+RYsNuV9tkHgcXYBKu9a14Ysy0DrkwLbk7JCpxXh6PmkE3Vi+bimvjYQuMc0VsRY8rlZhz5PBYBC5sndFk654Vf+ttQokMi5BjCqCdZ75d8cVpY/Qhdm0mJLXhmmj9B5QfEkioQWbnO9t9T/ojaAnya3FQi+VLievxbFaFMq6L0EQoNvtolgsSm8fbjebzVCtVjeuZRAEEmrkd0p7jyjuXCwW2N3dxWq1EgKj55L/u3oqPf/nhScZHh4eF4KoBxCNFQtXsXsphXLxeBzlchnJZBKZTEbaoLOyJ2sA0GCzjoR27QPYWL3zuJcBHbfncelN0IZDe2/cyph019OFzlAIiRJj+HTHu8JOAFLaXGczaOPnNuSKxWIYj8dSsl1rWRKJBPr9/kardG1EXZ2C653R23CcOjx0mhD2Uec/6jcAOQ7JgO4xoouF6TAHDTi1ESRb9Dbo8yeJ0SEg3avE7emii4XpWi70dGlhsvZgsGkea29wnNTasAAcCZK1FqPRSETU/K6wVTzrYbA5GpulTSYTtFotdDodOT8tKuZ5PA48yfDw8LgU6NURV6+z2QyDwQCLxQLT6RSz2Qzj8VgejL1eD9VqFa1WC9lsFu12eyN1T8ev9WpLawJ4zMuC9l7o5mh6pU7jElUrQ5en1qEErWVgbFw3z3LJDY9NTQoNp27CRk/ScDiUDrF03etMGHpFaCjdDBOSFr3yjfKwaGLCawJARJY6E+hx5t79rT0q2pvkVvfktrrsuRZ3cg5JBKJSod2UXobLOG86JVkTSmYGuT1pdLaL3mYymSCfz4tHT7ew57Uwxgg5LBaL2Nvb2xBMP//888hkMjg4OBAyobvr6nuW4+B720jGeb9bnmR4eHhcCkgutPhxtVpJ8R8a4VgsrOYZBIGIPff29qQ2Bg1uOp3GYDCQbAl6CHgsTTAuy5MBPNgsS8f6tQdAezU4Lj7QSTSYKULQgHGFzMqf2iDokI3WobhFsHT2Qq1WQ6fTEQEosFntEsAD3hWOm4ZSZ87o1E63Job+nM6KyefzGwLHiyQaeo71PLi9YLSeR3thAGych35N9x7ZpgnS11uHP3S4THuXXIGw7k+iPVfU6vT7fRF7MlzI71av15O5ffXVVzEYDGCtxWQyQbvdxmAwQLFYxP7+PnZ3d7FYLHBwcCCf09ejUChITQ1XW/Wo8CTDw8Pj0qBXvXwYLxYLSaujC3c8HouL2FqLRqMhBpKrMr3iPm1F/CQyTLSIUxdwAk5W7W7YAdgsFKXFoy5B0uEIGhs2NqPB04RDhzL03+xxwbRfigsZkokKP+m6IjoEpNNldYVVtyGaS3o4JwzJ6HN4nGug50vvS2fx0GDTmHOMPDeCmhjOMb0NnBN9Tq6HxyUdJM8624bXw72+JJKaGGqvEGtjaM2HFmjm83nJ1KpUKqjX65KFUqvVJCy2WoXN0hi6icfjqNVqIiKeTqeiPeEY+b3zJMPDw+PaggZ/NBqh3+/LQ+34+BixWAzHx8fSEI0PS3o1GBLRD2emsLqloLWRuexQiZtNoV32yWQSw+EQ5XL5ATc3sNmxlEaJrxPuqnu5XCKXy6HdbktVR3dMmuy4okiuht027jp0wxoZpxXU0gWpNLGgQeeqXgsYdTpnEASSPaM7il7ENdGICt246bQ8N36WGSC6TgnnivsE8IAXQp+zFgS7dTlcsa8mJDp8wrnlZ7md9iYxI4XksVKpYDwey3eM3rVGowEgJEaFQgHtdhvZbFZeWywWQkDovSAR4T1wEdfIkwwPD49LAQ0ViUA6nUY2m0W9Xke9XsfNmzdRKBRQrVY33MkMqbAGhnbha2PhPsif1Dm5RaaAEzc9H/AM67giQm3Iec583Q1PcDsW6aIXgA9+fc7au6J7bdAgUhNAz4JbBwLARiaIS6bc6qn6PFwiSLKoRZQUKBaLRfR6PSGQ3NdFXh/t5eE8uQW1dNl3DVdE6no93AJprg5Ih1x4f7hEQ8+t613RPW84lww38fqxrgmzWhqNBiqVCmKxGIIgkO9EsVgU4XA2m4W1VvoDMaWZCIJACM50Ot1Iv37ca+RJhoeHx4VAP5D4N+PGwMkK2BiDTqeD9773vbh7966k9/EB3+v1UKvVxFC62QG6gqN+kF+mDoNwUzO18eHKnatoCjdZi8E1qloXQEPITAcaB12cSa926dXhsenqZgiE6cE0qvQssLS1bo9Og8cQiNbPaILh6i5co8qxWntSBIyl30kquAKnkXO9UBdxfdwQhdY90JOmPWIkcrp2BkMVeo55rXWIyiW37pzpUJomIxyn6xFze9nwutILVCgU5Ppxvtlifjwew1qLXq8ntT3a7TaWy6VkLeXzeeRyOclYMcYIYdHXkym8mhg9KjzJ8PDwuDBoQ0+SwAflcrmUtEnm7X/4h384jDH4wAc+IKGAmzdv4v79+5I1oVd3WmzoPsgvM0xC0NjrCpk6JDEajaSQ03K5PLXipSsKJBnQpcp1VoQ2AgA2qkkyjZYCWcbZaYDoEicBoVHlOOmF0d1dgU19g86+4LXQWRM0jNTdMPzAWg40fNz2IsmhJrj6PnB1EgxdsXYFyc9isRC9D0MK/AznVXdGdWt+uJobTUJcguGGtKI8R/paLpdLzOdzEXfyWmoPlDEG2WwWsVhYTnw6naLT6eDNb34zEokEms2mEIzhcIheryeEZjgcotPpiN5Djysqu+S818uTDA8PjwuDVusDoVFmQyc+nLrd7kb2xGq1whvf+EaMRiPJ7S8UCg8o8t1VtOuqfxKgZ8UlAvF4XFbsFDnqAkjbwjnaY6A9DKx9wHNzvQZ8jePR7m1uE4vFpIGcMUb0BroiJT1ENGg0wjpUo2tN6CqZOsOGxlCHTHR/EHp4eK4cp86keFScdh/ocWidBT03Wtyp5365XAqRBCDkaBvZjRL3Rnk7dIqzmy2kyQhDIf1+X+aOoTDqfni+JJjL5VLSw40J66Y0m00RWq9WKxwcHCCdTqNQKGzob7Swl1lJ+t7zngwPD48rR5T4kg8suqj58CuXy7DWYjgcYjgcSgOvSqUiD2nXkD9Jj8Vp0GEJvTpmuIFCTVZUfJheRBtHnZHh1lygkdT6Do6Hq2BqDEgotJHQK2Ud5qHx0q3pOSYtPHQreAKbng6tT9GkiNU1NVl0haKPm2miiYZ7rXR2jM4M0XUtdFVSkqsoD5EbtnPPQ19TN+tIXyuXNOvP8/5i6ulwOJQwl7V2ozU8P8tzYAdYbq89VDo0l0ql0Ol0MJ/PRSO1WCykuii300TjUeFJhoeHx4VDkwy67vkgpeqdsd9isSgphOPxWIwA3fCuaO4qz8lN0WR2wHK5xHQ6lU6XekV/nnFzO+1BoDufsXNg04jRCOhMEdYUYVEu4KRvCfevjYk2elo8qcekV+B6PnQqrxsu0ymY1Ky4GpXL9mS4JIRzRy+MW+At6lz19TitNoi+jlHhIE0GowiK1t8wzKRToV3BML1HQRCg1+tJ5VIem5V2Dw4OkM1mcfPmTUkPL5fL4nXr9/siKuX3VetmvPDTw8Pj2kCvfPhAz2azqFarYgCPjo6wWq2wu7uLyWSC6XQqtTOYSscVJfEkhJ2nQaco8iHPlWI8HhfDrmt40BsAPJiRAUSTD9fjQL3AaDQCgA1tAMejdQX0ptCgJ5NJJBIJKb5EESCPtc0gupoCLVSkEdZFyHitNEFhWILZNr1ebyN0oonMo17f00JmUXoCbu+Gc3RqsCZx3I+rxYgKlejz3+bdcD0h7hxw3/RicT+uPoIhR62/Ya0ZEoR+v4/d3V3k83k0Gg1JceW11M32SI4BSLhEC415zPPCkwwPD48LhXb78oEbBAHy+byo2Wu1Gm7duoU7d+6IqG02m8kKqlqtot/vb5Trvg5hElcXwRUxxXmuuFJ3Ot2mK3HhajFopJlmyG6cFFfyf76nxYw0UrPZDKVSCcPhUAyHqxdxMyN4fhyra1h1bQl6c+hxIfGKxWJiADudDkqlkninGBo6r7cnCufxFLmiS86RFl1qUqG31SQlKhwCbJJJ9zXtEdEp2EC010WPWxcYI7QehsfhtWcF3U6nI31ZKpUK9vf3MRwOcXh4KOdXq9VQKBREnMueQSSXmmicF55keHh4XBq4OuTDjlkGr7zyCqbTKer1umgZdDfJZrOJSqUivTn0w/6q4BoWN7ZvjJEiYbFYTIpyDQYDGGM2jITrIt+2EqeRZiooSQezHdiThF4Outh1kS8SChp+GjjgJGxCoSO1HDwPPU5XyMgQV6FQEM9TEARotVoolUqYTqew9qT5WKFQ2NAXuDUhLvO6EVHaFC0O5Wpep0lv041s04HwGHp7TTAYptFVPrWXKIrMUGzMCp4cu+4cS42QTu/mXGezWRQKBfneGWPwwgsvSA0TnS7NkMnjEAsNTzI8PDwuHO5DmR0i+ZBloarj42PJgKBYkm5/rpB1Pwe9/6uA6zamceaDn6vf5XKJQqGAZrOJYrG48eDWoSRdkMkVXWrtAOeChIBah3w+j16vJxkkNDg0GLruAl313EaLGLW3RM+7m7nCcXPlTw9FJpNBPB5Hu93G3t4eWq2WNNqiaJL71YWm9Hnreb3I6xVFlFyPTFShLt2L5qyi49O0GFpgq1vP897QQl8t5iXBKBQK6Ha7EvLi/cfj6Cwh6jLouaGok/VLuE2325UUVvYU0uE9npPrrTkPPMnw8PC4FOiHXxAEKBaL0jEyCAIAQLlcRrlcllU6H5p8wNNQanfwthXkk4QWaLoFphhSYW8JZs7oEAsNLGszcDvXwLjudR3aoCeDoSbt1qbx1gaNoRX252A/DHowgiCQVS6wWd1UpznydzwelwyI+XyO+XyOcrmM4+NjZLPZB0iU20BOp9/yeBcREnPJkCscdmtY8Fro9Fa3Fftp4S332FGERIfaSBqZIktPk66pwrHxGmazWen9wvLw3G8QBNLFmOmtN27cEA8aPU3xeFxCJrxPjTEbDdJIThn+I2GOqpdxVniS4eHhcSngw3M+n2MwGIgBo/u8VqthMpmI94IPu3Q6jV6vh1wuJw881qLgw+6iDNKjQB9fexp0GiQNNg2O7qiq9QwMd9AbQZLl9qrQOhAAYvQZatLuca3LIEnhypWeDxIN7WZnOIWfIbmg4eVqnzoZpuqOx2PRWHC1zKJiOhvD1dZwdU9j567+HwVRmgn3PnGJhlveW+snHiXFNsrz4WoydIM5ZojoMegsF0006IUi4YzH4+h2uyiVSkIuk8kk2u22eElYa4Pfw9VqhW63K/OUyWSQyWSQTqdFJEwxqJsu/SjwJMPDw+PCwVV1IpEQfYC1YftpEg0+xHQ2QjweF4U8Xb5cnTP18aIM0jY8LF1Wr5Rp7LUxNcaIpwCArASj4vv8W5flBk6KP5E86LCFm4rJ1+LxuFTY5NzqsEQQBOh2u6hWqxgMBtKtk/umkdOpqQTDM263UIZcXE2BLrHOudymRdFekschjnpuonQRGi7B0L1BHjfjxfWS6PFFiT8p5HQFt9qD52Y2cd4o6CV5oAaGhD0IAkljZTiIwk560qjTSSaTG/9r4acnGR4eHtcGNGwAZGWvV6yLxQLT6RTHx8fyYM3n83jttdekGJeuP8GHrq6EGVWX4SLgaiIeZvTo8qexZdiCIQgAG1oLGmOGLhiy0CW5E4mEpHzSsNDboAWLD9OHaE8SQysMZxQKhQf2OZvNkMvlNqpg6nRPXYyKsX4d+tDkgZ4Rvh9VT4OfZ3Ept+39o1y7qN9R27nhCAooqRl5HLjhGA3tYXGvJeeEXg3t6dD7BbDhERkMBkilUojH46K54bU8PDyUSrqVSgWz2QzHx8fI5XJCaMbjMQaDgWzH0uW8hx6XaHiS4eHhcSnQD03gRFCWSCSQy+WQy+VET5BIJCSbhIZWd8mky97VNVx0yMQlGA97sOpaFVq/wLCBDu/oapL0OND9ba2V1e10OkW5XEan0xHjn8/nN8IPWlyoww9aW8B90jWfzWYxHo+ln4nuYMu6Gm4rdu1Z0RVYo+ZKH5+eDJ3poLfTWR0M5bjzdVmICpVwfhgyehy4GUguXM1IVIlxEkO3WZr2TNE7oe8fAJIyPZlMsLe3h3w+LyFKiq4pBGVXVn43OfcM8blE41HgSYaHh8elgF4MramgYWNRLr7GVS4ND1dzNE4kF3y4krw86oPvNC+F6yF42Dm6dSZoOPXKnJoGt2Q4yZT2ZDD9leLJZDIpcXWd7ukWytIGnKAB5Qqd22sBJsc2HA5Rq9XQarUQBMFGUzDWMhmNRlIwzfVI6CZqJFC6LLfueqo9CboiqK5TcVlwSYAuma69NI+Kh4Xz3JCXJgw6hVUTaZIhVzDL+SMR4LgZaplOp7h//74QTfZEicViIgLN5/PiUeFndejucQmfJxkeHh4XCv2QpkHRq6HZbIajoyP0ej3MZjOMRiP0+30sFgv0ej3pxqpj1G5PCe7vUUImrn7gIkAjQEOlCyzR+DKTgymLnA+u/GngaGj5GdZD0A3GGEbS5cE595ok6eZgq1XYvZPZLAyr6IZvJDd01TMbhW51eieisja0V4efB8I+KsViUcgLr6feXhf0ukwvBq+JG27SoR9NHB8Vp52DG0rh/OtwoNZjAJs9bUjKOU6dAUPBJs8zHo/jxo0bQjDS6TQODw9FcE1PCfVD/J/eMK2b8tklHh4e1wbahU/hGTMXaDBZIZMx+Ww2i3q9jl6vJ94LXVOBK26dgaFXYGcBP+emUz7uuUZVAqWhItFgbQotAuWDnOSDnp9UKiU1ESiwpNZBZ35oz4bWRPA3j00RLkW1LDE+n883Mnv02BhC6fV6UvOCxlmvpF2PkiZCeh+lUkmO5xaN0im6l501dBqJiPIGXRQ0mXEJtG4ip7N0gJNQIb9LrPBKcqbJez6fl3uK9xDv+b29Pfn+MX2W5J7khvcu50L/PCo8yfDw8LhwaKNDTwaRSqVQr9dRLpc36mcsFgscHh4im82KG1jrCyiIZPbEtuZUp4FG1K3m+Ljnqlf2NLJ0heu/jTFSmIpGg+9pj4W1VjptMvXU1UnoviU6BKLhijOZtaIblekQlc5qMcZIKINaBR6Tng96QzgehrL0HFA3wAqgOn1TX8fLEvNG4bRQmZsVEvXZs4iC3e21DsQtEa7nbjKZSGgKgJBzvscKrwx90HuWTCbR6/VgrUW9Xkez2cTu7q4UvGu32xgMBkJgGDLhfcYwjPaUXcS18CTDw8PjUsHsEj5oaUBXqxXu3r2Lfr+PRqMBay2KxSKWy+WGcJAPYrr7ueJ7lJ4m2gNyka557kfHy2nU+TcJBR/yNAp8yLMjJvUMrKNRrVbRarWkEBPnhRkZ2u3Ov7VQTxsL7WXQdUdoVF1xrdYquIW1dMtxvRoHIBoDhri090V7MFzR43mM90XBPe7D/t5WB2Pb+N1sE+310t1VadhzuZx4sXg9Sbi1N2q1OmmM1u/3kUgkkMlkkEwmce/ePeTzeSQSCdFeZLNZue+Y5spicuPxeKPwFr0h9CI+DjzJ8PDwuBBEpbrRWFGENhqNMJ/P0ev1MBqNRKfAdu/D4VBy9pkBocmAzp44TcH/sHFeVgYDNSP0EJAk8XUSrMViIQSi2+2KnoMkih01WTyLBIMr13g8LkSEnhltwK21kR0+tQHUc+C+rt36OqRBY6e9KW4abzqdFrKkQzC8jlFZKU+aWOhzdUmDG9bQJMAlaFr0G0U+ot6LInrAicdvPB6jWCxiOBzKduxdw3uJpdxjsRi63S7K5TKGw6FUnb1x4wZGoxFarZY0HuQ9QY8ItyfhCYJgow6NFqc+znfFkwwPD49Lgfug1UWpGEsOggClUgmr1Qrz+RzFYlFKJGtvhRZKulkNl53yeB5o4SZd4Fwh6iZqsVgMuVwOnU5HelG4lR61kSe50jFy9rIwxojngBoXGiZXJOuSttOMu0s0WLBK17/Qhbh47qxiyjohUd4K9zhXBdfo6/+Z9aF1Mm5PE14LTRrcEJ4OlUT91vc1w0kk37xvqKFhBk61WkWz2ZTOqWxAx+t079497O/vAwjn98aNGzg+PkalUsFiscB4PEan05HvGa8z54SfuwhtiicZHh4elwY+hHXaIhB2Cw2CQOLLh4eHGxoAuuCj3Ogu0XhYOuqTJCE0zLpniC7VrbNtdM0KHWKhZsMtUKXPmavZer0uq1GKKa21G4JNZhvQm8Jy0+c5H509oz1JHB/1JDrMpa+56906Lb1T/34UnPWz2vi7fUp0jxHqHXSVVJ3mqbUq9CS5obhtRIPXVhMThqF0hk+5XEav10OhUMB0OkWz2cSLL76IO3fuIJvNIpfLodFoIB6Po1wuSyoyPRTvf//7JZuEnsJbt26hWq1GpoozM0Vfj0e9Jp5keHh4XDh0mETHeemqpVuXaYuVSkVqM+jsjG3x8LP0leCDPapvxmWdMwkGm1ZRe6JbietGWVwR0/hTs1EoFMTLQaLCcAiNfC6XQ7/fl1LRzFzRXVsBbGgvaLRY5OxhcAWLbjaP9mgwvENRq6sD0WRj23XQpPFRjNpZP+saffd+Iikk0ZvNZmLodb0SEhJqV3TWjUuuoggGcKKDoSeBnj6Stlwuh+FwiCAI0G63USgUUCgUcP/+fezu7mI6nWI6nWJ/fx/dbhdHR0fyGgnrm9/8Zuzu7mKxWKBcLstcM418tVpJfyGefzKZ3PBqPOp3x5MMDw+PSwMfThR/Aifiy+FwiA9+8INiYNvttjT20sZIGzhtpB+mydBu74tMWd0GGi7dHXU6nQKAlBF3S3OT/Ljt4kejkQg+uXrlfij25OqSzcgo6mM4g4afRc5Idmgk9bhdD4Kef73Cj/Imca7ZUVbrRrRY1P38tjl8HAHoWT/rkhmXmOiwHnUvnU5HOgbrol08T50lo0Mvep9Rug3dAA/ARuM7VnjlsZh+TE8ZPSb9fl/Cjfv7+zDGoFQqYTKZYLlc4uDgQHRAw+FQSolzLLzvEonERkE0ktPHgScZHh4eF46o7IZUKoVcLidFmgDg5s2b0oqaQkGd8ucq8fXvKJGdhu7voItkPa5a/mHnzfg9V7ssI07xHo28tVYqYlLcSeErAOk1MhgMJIuDxlsTLXpFtIiPRKVUKgl50Z4MGhKdVeIW1+I11PPt6g800eDKn3oCTQi13uQ0EvC4ngzu4zyIIja8d9j5FACKxSLa7bbUF3FFn+5x9Ry6AlN9H2pxLYANrwi9G9SG8P4hwWBIpV6vYzgcCgEZDofSBbhYLMp1ZAYTRaCpVEp0HLrxGr2Q+pweNWTiSYaHh8elQWsQ+KDTJbZns5mkrOq0xqjsBq4Uz5K+qo29XhE+iUwGGhVdk0N3+qQgkiv81WolvUpyuZyMky3v8/k8BoOBhJbc1FO9IubxudLV9SyYGlkoFGSFTe8GwwJauEpPC6+VMSfVSXVfDVdboLfX8xH197a5e1RPxnnhhoNo+OlNoIh1sVhgMBigVqtJZocWu5IMaFIVFWZyiQbwYMt73W9GC20p5p1Opxut3pkpUigUZOyZTAa5XA6JRAKtVgvZbBbJZBLlchk7OzsolUqS8qq/F/w+utfJ1ZecB55keHh4XAq4iucPc/PZDI2ljNliWocz9AM4ygW9zQi5YRYa+CdFMHhsvSLURpvj0g2rAEiYwRgjoY/BYCBtvIvFoqQq9no98VbofVKQSBEi55AZC71eT9q883MsvsSsBeo5XM8H4/O6OBdDN67+gEbUDam418y9Fq649UnAzeLhnDFUks/n0e12kc1mkc1m0Ww2pZGfrrqqQx26mqkO1UURDY6B881wG8u508PFe4K/6XWg5oefqdfr0uWYWSP0IsbjcQlP0us0HA6l7HsQBKLjoY6K1+VxhLieZHh4eFwa6MmgoaXLt91uY7VaSQ4/3bNaFMmVYlTqo/u3DrFEpRY+SYJBcqNX+1pEqFMOadBpOObz+Ub4iO+zM+v9+/dx48YNjMdj8TQw64Mpq/T0sH4FxbesuUEXOTNcqOsgwdH7oaGlOJBCQt1plcJUrT/Q5OcsIRBXiPmksoGixMHAiTdgMBigXC6j2+3CWrvhcdIVaXnOuvCY1qO4nWg1oeLfAORas8cMNRi6MB29RbFYDO12G5VKBb1eD8lkUlKamQbL3jcUFJO8AkAmk0Gv1wMA2acmO49LLghPMjw8PC4NNDar1UrcvPP5XDIQdEolV340ZHQfb0tdBR70dOgqijz+k1wZc4x0tVMEyVUoa11kMhkpWEUXNVfDOtRAb4K1FsPhEDs7Ozg8PBSvh9asMGOHhpoGjtuNRiMJx5CEcCXMa0RNBXUsNLTsXcJGXixprbMtorQurkF1PRt6zrYVs7psuCEaZsvQ2Hc6HVQqFcxmMymUNRqNJIOIJcB1mM/VI5HIuPeu9hYAJ2EaEjiGu3TqMLdbLBbI5/NoNpvY29vDarXCaDQSDQbL0dPbYoyRlFWt72HKODU9vD8u6hp4kuHh4XFpoPGipyKRSCCbzYrRrFQq8tBj6IDEA8BGlcioDAftMXDrODyp1bALejJoHGhYmOXByp9BEAgR0fNDwsWVNb0K9Cxks1kAeKDFN2P2DL2Mx2PxIpG8kQxw5Urio9uGUwfA1xkW0fvnWOj12Lbq3SZ6jPI+uVqFy0JUVon+7WqBmDWTyWQkk4c6l2KxiE6nI7oN7keLXrWA0w2NuIRKk0aXPDMEwveopyARnM1mqNVq4p0olUrifWH/GN6fFI0ydMcCXVEkEHi8gmmeZHh4eDwRsGdCJpNBrVbDzs4OYrEYbt++jeVyKUaRAke9+tMZDsCJsJMGgB1OSTie9GpYQxtV6h64apxOp8hmsyJ2pVucNTK0cQJOsj9ojBl/HwwGKBQKGwY+kUig3+9v9DhhSITuduAk3ZRptjq1VgtlAWzMZTKZlM/ozB8KQnV10W3GWxvWh2VdPInrE/Vbk1jdwZZVajUBmE6nIsZkSFAbafYGISHQwlA3ZOJmcuiQE8M3/J6wv81sNkOxWMTx8TEKhQJisRgmk4l8T9rttmg0RqMRjo6OAADZbFbKiA+HQ9F3kAgzfMb5cufvPPAkw8PD44lgtVphMplgNBphPB5jOp2KsI1tqMfjsRhD6jnomuaqWxvbbrcrqzd6DjQZuWqQDGkPBQkHjYeuyskHO40QP0siQNLASqmahHGfWgtAlzpDHgyjkKQwZMN4PUM71MsUCgUhQVrUSOPLlTY9N65HRhtPN3Slfz9JT8a2Y7paHpZpJ7nQDem0uJceJ867Jo/xeFzCKtrjRn0F96PLx5Po6T4iJDmsPspjstLnG9/4RtE58Tomk0kh7CQU6XRayCe/jwwPcRzaI8P5eBx4kuHh4XFp0KshrsKYo8+HOTMaWq0W3vCGN8gDlH0w9vb2cHR0JCt0Fp0aDAbY2dnB0dERyuUyxuOxCEYvezV8FmjhaVRYgNu47nLGxLlittZK+GO1WkkFSN1zguSF8XyuuAGIq5w6F66K6eGg50IbQB6z3W6jXC7LPkloGOoBIC58kh7d3O6shEGLRM977R41LOYeU2slOEes+UGNA7UpWujKz3MOWE+jVqsJka5Wq/J5hqTo4dApziQkFP/qLB2tVdJElQLQdDot3Vv1fbZcLtHv9xEEgdQvabVaG9lc4/FYvpMk8SRT+h59FMJx9d9EDw+P1y3cmgiMC9NA8sHJVdpwOBQjy4d5o9FApVLBcrmUVf9gMEC9Xsfh4SFqtRr6/f6G5uCqQiUabnojtRrUNVDQqcWC9MQkk0kRaq5WKzFIiURCamdYazfqJWgPD93mOvTEcehGWCRkrrue16JcLsvc6lU1jSmNHfU1vH40nlGEISrmDzyaSNcVk54XUcaToSCGj5bLpWTvUJuiiSL1EqvVCkEQSGXQTqeDRCKBarWKRqMhqaj0VDDbh6G+bDYracrtdhtBEGyQNJIQXe2TJIheimKxKDqSdrst7d3L5bKQfCDUa8RiMWnax/PhvaT7lrhzdV54kuHh4XHp4AqXqy9mmQAnxIMPRgBStjkIAtEH9Pt9AKFxLBQKaDabQjC4QrsuBIOgIdIt3/v9vhhkTRCYscHqi4y7A5AMBgDiwtfZIWy2xpUuRZk0alyhUltBokHvBL0gJDm6mBezf7QIlzUzGAJgTYd0Oi01QHgNeRz+Pi2lddu1i9o+Sgx8EXC1IgBEc0ICBUD0KAwVxWIxDIdDqdzK11qtlhTxymazQooY9tJ6HXpByuWy3Ac0/gzFUAycTqdFB8KCXMYY3L9/H7PZDPV6HZPJBO12W673YDBAq9UCgI17gOmryWRSarCQfD6ugNqTDA8Pj0uHVu1Pp1OptTAYDGS1n0wmZYWVzWbR6XRkpT+bzZDP56WA0GKxEE3BdSQYOnMCwEaRK9YnYGycokEKK3WaKR/63W4XxWJRepgAJwWjWGeDLnESjuFwKN4dxt1JNICTFEqGYHRKLYmIDpHoqqDajU/olXyhUJBQz8OyObZhW4qrPt6TuOZ6rEwrtdZKnx0KOkkwdHVWfobppGxAxuJmTBklkZ5MJlKALRaLieeCRIRZWNTp8H+tv9jb2xPvi76Gw+EQ+/v7Qij4Od4/+lzda/A48CTDw8Pj0qBjuszJLxaLksaaSqUkfEDRmV7Js84DV8x0J5OsXEeCAZzE9XX6J3URADaKbzE7geEhehFIDtj4SndlJWGghoNeDWYe9Pv9jfoV9B7pz2nx5nA4FOOmW8GTGLKIE8M3OkTBlXU+n8fx8bHoD3jc0wSgrhGL8nhsyzyJuuaPEzaJ+izJGT0HJIEApEBZoVBAt9vdqATKe57jTyaTEvIiaeY1YLiExI3X0ForJNq9ttRo0FOivWHULMXjceTzeezv70sWUiqVQqFQkB4mrK3CedRFwS7CiwF4kuHh4XFJ4INWr565umOztOVyiVarJasrupDpigdOenHE43HxXlBseNbunk8SVOmz6iL1DCQPzFCgS1r3NGH4g+dLHcV4PJY4Pxt0aY+C3j9raZCg8Rro2hs6JZgprSQRUR1aSSIY4tGtyQGI0apUKpJJoduhu7qJKKKh9RX697bMkyhS+ShEU4dG3PuH5IzaIS261eEvhkhI9ji/FHXys6PRSLwYrFXCMt/JZFLeYyYV7xde0263K2EQzrvOFjHGoNFoYDqd4t69e5jNZuj3+3Ld+v2+aKBYfEuTP7ecuP79qPAkw8PD41Kg4/d8CNI9zBj0ZDJBtVqVOhHASfxbdxnlao8PfGao6CqI5xUNXhZIILSnha/RmDCWT2NM4sUOqXSfk6TE43H0ej1UKhV0u10Jo+jaFzSEep90sbuNu9zKqBQecsVL4kZ3ezKZRK/Xk6JT3JfOhuEqm4aRokmeexTR4O/Tamact4bGNi/JNnDfUWPUc0XSw/kleWbxMhaao3ZGNzxjejW9WfR2kNBRo8NQC4/Ja8S04lwuh1arJW3cSUYY6iIx39/fx+7uLoIgkLGXSiUUCgW5b7LZrHhleA25CLjI75EnGR4eHpcGXWiID3Cu1CaTCfb29jAejzEajeThNhqNUKlU5CHOTAeGWABs1ILQ6aDXAToLg0aWhkkbLGowdDEnko3BYCBxdq5aXb0DtROueNMtkMVjuo27KBqkO1831SIZ4pzOZjOUSiV0Oh3xzNDtTwNIVz2vMw2WWxciCttCI1p3ERV60XMetY+HEQ1u75IwTXrosaGuRqew6homrJrJolYUfwInpeJp3EkGeW/cv38fxWJR+sRoAhoEAbrdLgBshK5IOBlOGQwGGI1GqNfraLfb0iOIIclWq4U7d+5ILRp+t5iNxB/X+/i43ytPMjw8PJ4I+OBi6h1dtnQhU4BmjEGn09loqsY6EbpUMw3odSEXGjReFAhyxUnPABAaHrrQdf0Eeiz6/b7Uu7DWblSXJIkgiSF50+mpDJ+QjDCllR1UeS04lzR6JAs6s4ShLIZTaMgpPtU6Dl1KW4eMSH62YZsnQxu7KI/GaeTktDod+nO6lHfUfnQ4yhgj6cUUdPL60pMRj8eRzWbR6/VEZKlDelpHNJ/PsbOzg06nI4XNuM98Po/Dw0PcvHlTCCLHOZvNsL+/j1arJb1w9vb20Gw20ev15N7hdcrlcqhUKiiXy+Lx0BkluqeNrpHxuPAkw8PD41KhwyYApAoi3es0dKPRSIwQ3boMrdCQ6cqIbqhE/75qaL0EjTrTQBmHZ8ooyZRbR4N1Emi0Ach88G9d44Ikg6RBNztze7wwnOIW4QJO6j6wUBeNlQ75UPvBkAmJjG7wRYLB1NqzEMKo0IkbYnFf52vbwi7boImE7sIa9boOO7EzK0Mbulor9RkkydTPUNhJDQfDHZxXajY41wDk+8DUbnq+5vM5SqUSWq2WpDInk0kh4kAYfrlx44aQlfl8LrU8KPZkrQ2ty3iY5uVR4EmGh4fHpSJKlEmDaK2VWDKzKJbLJXq9ntQVoOHkw19Xw+R+tYv7OhANjpOudcbf2TOEqaJcZZJsMMxA46O1DswW0cfQxpaeERIUhmK0MaOhpKufYQwaKu3d0LU92AKeugyWJad3STf2ooDVrbWhhaJngfZkbEtn1URDQxOPKJzmNXFJm64bosWtFGqy7D3LkI/HY9TrdQwGA6lXwlDMdDqV7Bseg2JSkohsNotGo4HnnntOBNAkMzs7O9KqvVQqIZPJIAgCtNttIZ/0QDSbTdy/f19IIb0abnaQWyb+ogm7JxkeHh5PDDrtMZVK4ebNm9IobT6f486dO1K5cHd3V1zPbrYBDbg2BFFG6argZnOwbbguJU2DrytLuufHpmeMvzPMwR8dEkin01JtkkJAN1RBLwW9DtoTQpLAa0GDo8td08CyXoSuw0GCRCGk7iCqw0RnhSYSp2WbaHKpr/1pK/FtxELD9Q5NJpONPjDWWnlNazUoaGYhOV6T0Wgk/XZYXGu1WqHT6UgJcnoeKpUKOp0Out2ukILpdCrZJdRoTCYT3Lt3D8ViEaVSCffv30etVhPPV7lcFm8O70n2K6GwVN9LF5m6KnN9YXvy8PDw2AIdV+cDLRYLm581Gg0cHBwgnU5LrQFWMNR9SPQqnK/pVbc2Zlet06BxIokoFAro9XoSC6cAUAs+mSHClTEJFkV9DJ/QcOtaDCQDJBg6w0PPDQ0NDRdFofRG0FjycwA2+pzoRmtRKagcB8/TDWedB2fNNjmLDkMf3yUl7nbue1oc6lY9JSGjiHI6naJUKmG1WomXJwgCNJtNVCoVaVjH/dJ7RDKpzz2RSOC5554TcXO5XBaSkM/n0Wq1UKlU8MILL2C1WklDtsVigeFwKNVBa7UaxuPxxnlQ7Km7/ep06IuEJxkeHh5PFDr+q2PKN2/eFLcuV9SspQFADLb2WlBEp937Z8kquGxoQ8XGVaVSaaMAFzvHApDsj9FohFKpJKWlx+Ox6DgYP6fGwvXaxGIxCY1o7wRFmFw5c7XN6qB0s1NwyEqRNIC6fLibPqy9ISSEPJ5OY32U6/EwQed50lw1mdhGQM/iKeG1oBeA3gudOTMYDCTDhAW7KpUKDg8PpdYF55s9X0hCuK/BYIDxeCwaDKZ0T6dT9Pt95PN5CZP0+300m02sVivcvHlTvlPValX2sVgsJCSXzWbl2upaGReVTeLCkwwPD48nAr0ydMV8dPW3220pIGSMkZU1DSirgOqUQxINHZ64ak8GcLIqns1mKJfLG/UtWGGTK0waNBKNYrEoRa2oCaA7W2dp0DCSFDCjQ/fOoPZFu8sLhQI6nQ5SqZQck54KFgTTYRgSjdlsJrUh2JyL2SY8vts59lEzgB7VkxGlAXrYNToLodHj4RyQ+DE9NZ1Oy/yz9gtFl/V6Hb1eT0IYiURCsoWAkCSyVsZb3vIWAKGnrlqtiscknU7jxo0baDQaordJJpO4desWYrEYBoMBVquwuBrTUykynk6nGI1GGI1GUg9Ffxd5H100PMnw8PC4dGgjQ6PKBxzz+Y0xkmbHOhl0LZNg0MgBJ0W76OrVWQCueO1JezbclX2n00GpVJLeFRQRMiVUVy9l+imNFKs96lLU9CxwLumqZ2+XcrmMXq8nxEtnt/DYxWIRAKRUOzUWDK/QoLKIFNM26Y3RhaVoBHXaJInLo3oygPMX6jqLx0Jfo/MQGDebhdeLnjVdRC6bzUplWhLjwWAgmSdAaNS73a6QjeFwiEKhgGQyiVdeeUW8Vp1ORzwm9IwAQLvdRqFQQDabxfHx8QZZmEwmQiKBsMbH7u4uisWivAacpLDqlGvvyfDw8HjqoI0MH2ZcLafTadRqNTES3W5X4tP9fl+yTqbTKZbLpbTcpmpeV7fUmoxtgsAnAR3DX61WIsLkA15nIjDUw7RQpjACkMZkusYFDb72OOjjaQEoP0ePCckIS4QDkBUxgA1DyhUwvUjs0ZHP5zeartFzwTLp2tsxnU4vzLP0MKJx3mO4+4tKhY0iODpNmNtrbwHPu1QqYTabiVejWCzi+PgY9XpdamCwPgyb21Gjk8vlUC6XhYDSK0HtxWKxwHPPPSchlNlsJvdGvV5HLBYWvCMpGQ6HmE6nUnCN1+pJwJMMDw+PJwaulLQ7ng/EwWCAwWCAbDaLfD6/EQOnG5+KftYPYCEv7TnYRjCeZAiFK8OozAqGRRiCoPGit0aLQV3jxtLj3I4eIc4jjT97vOg6GFx9M+1S6110ozYek/NLckLDyGvhli7XIQMAksUSJcR8nDk9L8E4jVy6dTcelvKqa7oUi0WpOZHL5dDpdFAsFoWw8d6k7qbZbOLWrVtoNptSHpxZOkwLJlG01qLRaIhAkxkrxWJRUr5nsxnu3r2LdDqNcrkslUD7/T56vR5u3LiBQqGAarUqNTwopib5ING4DMEn4UmGh4fHE4MmGHQx53I5yaIAIF1Y0+m09DXhapGCung8Lu54rZDXuCqCoaGJAbNJuAqmAebYGOqge53noLNJ6KlgLJ4hIp05AkBIhJ4Halg4Jq5q6dnodDriHSHpoe5AF6sCTsIY1MNoLwpJ4KOmrm7DaZ6MbccgMdkGl7hsy0JxwZoWzOJZLpfI5/NCyjKZjFwfXeuCISz2OWEGyHw+lxBXoVCQap5s504dUqfTkYJbi8UC1WpVPFVAWDuD36XhcIhWqyXhrnQ6LePVBPGyiYYnGR4eHk8EUemCjDXrsseLxQL9fl9WXu12G7FYTB6mLFzElaX2XkSJ/6KOe5nQLnbgxEtALw0Jhg4zMIuDngKdAsoqm9Rr6A6qFHJSK8FtWW9BzweJipuemUgkZGWuy58ze0SnTfZ6vQcKfOm0Yp2BchkhqvMSjW3ZJu51ikp/dfdNskfSwNAQe+qQ2NEzR3LG1GDe5/TMaa8P+5UwNGatxcHBgYx9b29Pzo/Vcnu9HgCI96nRaEiRLxJMjoVkhoJQXh+S/svQYhCeZHh4eFwJKESkoHG1WqFYLIqaPpvNIh6PY29vT1b/hUIBpVIJo9FoY6WsU1l19oVr6C5bn6GJDgmQ7vtB74GuBsq0XBp7ejL0OdBTQOjQCOto0PWuK4TSOHJ+Xe2GNn6sz+FmhFhrJQOFWg62kncJHY209no8zlxG4TQxqPuZba+fprlwP8vf2uvDmifGGBF7MoPIWitzz2MwZZSpr8ViUQp8JRIJFItFdLtdEcqWSiUUi0VJOb19+7ZkYQVBgJdffhlBEIjuJpVKoVKpiIeLpIHZQ8lkEqlUSmpkkKRrsnFZ8CTDw8PjicDVJZBgsC7DdDpFq9XaWHVba3F8fIxut4vFYoHj4+ONpmA0ntZa6SSqH7Luqv2yhaDaKOkiW4yh6xofACQTQWedsAy39ljQyHG/Op2XGSPMQhkOh+K6p2aDc0RxIg2crj7K1EuWwdZCSBIdXZNEpwwDJwXG3LLpj4KzXqPTiEZUKMS9J/Rv1+vl7pshPGaJkOiSVLRaLZTLZcmY0mRThydWqxV6vd5GpddOp4P9/X10u10Ri8bjcXS7XQmZpFIpDIdDdDodVCoVqbXSbDaRzWYlNZaaEBZam8/nIqDmmKhj4j3rZn9dJDzJ8PDweOLQMX3WuhiPx+h0OhiNRlJ7gca1XC6jVCqhVqthNBrhxo0bUhFTu7EZjtC1J1yvxmXpNLQ40F3hu2Ed/k9RH93v7BHCdFJ6eWjguX8ac2ooGN7gHGhtB49LjwpJDfdPQ0eSw2wITdS0N0QbJ+1hoSCyVCpJC/JH1WREkUH9W78elSXyqCLRbdeU9yFDHMza0VVdGRIDIPUyeD10YzwW0srlcnKP53I5NBoNFItFVCoVAGFm1a1bt6RQHXuirFYrmVu2cWdr+clkIt4prcXhPUKtjxYMX3b40JMMDw+PJ4YodzYrTuoGTwA2GkNxRTwajbBcLtHv9+XByYc5m4Pp1E5difGyPRmuB8M9liY2NFgkQzQGOj1VN03TQlFqAZgqyQwVGkLqBLRHhGPT2SmDwUBSaxnKYUM2Zka4XiJdplzPq86mYd8OneJ5Xuh5I7HRv7fVrtAei7MQjG1ERkN7JEi0tFdHzws9OMlkEq1WC8ViEa1WC4VCQYz/dDpFr9eT99mPxBiDTqcDa614I+i563Q6QhCYtsqKoSysRs+V1mOQiOTzeUld1deNRJfX0As/PTw8XhfQD7TVaiWhgUKhgHw+j3w+j36/j1gsJgWMOp0OFouF1B8oFAryIAXCh6+uMqkNUxTBuChPRlRIRusodNhEh0loxLWokJ4FXbKapIF6DhbjYriDTdC4L5IQXamTc0S3e6/XQ7VaRbfb3RClApBUVXpTmN2g98dsB22gmS1Er8jj1Md4mDfiLELN07bltXLJRxT5jNrHarWSbJFKpSI1Rxjqm0wmqFarUi+j1+ttFESrVCoy/7lcDkdHR4jH49LCfXd3F/v7+6LZyOVymEwmIgrW+hAKP8vlMrLZrHjFOE5eCwpzx+OxEEo3VHIZ8CTDw8PjiUKvmrTRZY8GCkAZ/6aYjauxZDK50b9DP+ipLdApoDT62+ohPI7bWBMEXQhMZ4Ho8uc8rls4TLdKd0Wh1GnQc8Hy3xRhkhDwWMwYITnR/UxoWPQKm7Uz+B7DAfSGUBjKXiQ6O4bgipmajsfRYxCnZZKcRaj5MFHoNrLp/q/DQm7oqVKpoN1uI5VKiXdIe5Z6vd6GZoa9eXq9nlyzcrm84aHa2dnB0dERXn31Vel6u1wusbe3J/d5LpdDNpvFarWS/ia85/k9IpEgwaV+h9+1J0EwAE8yPDw8rgCaaGhjQjCljyv7fD6PdruNZDKJ4+NjLBYLSeGrVquymudntaaAhkh7FTgGIDr+f9Zz4Opdewx0DF8TB/05bsfj6pg/x6grS9K4M5OkVCqJ94HZBTw/4KRSKDNBdIVOuuN1MzTt/idRoceEniaORbdyd70wDPdQr/A47vfzejK2aTPOcl1Pe5+EkXPDucpkMuj1esjlcrDWSoiJYzHGoFQqSciP17zb7UrZ/Ol0iuPjY8n+YNGtxWKBer2OIAhkvhuNhqS5MsU7kUhgf38fxWJRQm6DwUBCI0yZ5XfDve8uO7ME8CTDw8PjCsEHHImA9gJo9zvTK6vVqhQ+2tvbw2QykZg1H/ZuRoQWJtL74YZS3OwDIkp0qMfOGLsOZ7gxfJ1mS0KhPQcsoEVvgK6J4eoAqHfQmQ2uMJP755zpUuX0WpBEGHPS1l23d9dhD5IThkx0ETQ9Zj1O7aV5nHvjLJ6MqIyQ8xxXX/8oaCJJLxn/p0iXgmOGRqipmUwm4mlgf5hKpSLhk0KhICRiuVyiXC7LfpbLJV599VXM53NUKhXJWuF5sgFep9PB0dGREB9N3JlpxetC8kGCyH1dJjzJ8PDwuHIw7syVIEWR6XRafo9GIxF8ttttdLtdpFIpZLNZSbukAdTNvhg+GAwGsp1OCdWpha6+YpvYUBMGtwInjZy7PYmAMUaMMkkKSYDWarhGlG53EgzdP0Nnn7AgFw2d9uToUux6v/wMm5u52RP0yFBgyzCKJh0kJRcpHjxvyISf0TjNmxGly3ChhbacF2peWDvk+PgY1WoVrVZL7lmSWVbhpGCZYuXxeCyekGw2i3a7LaXDWRStVCrJda7X61JPRYe+eF66581kMpG0aODkGrPCp84uuWx4kuHh4XHl0Ep3qudpxPlA54M5kUjgQz7kQyR00u12pUAXxYu6yBVLkFerVelMqd8HsOEJ0N4NnSJLI6wzVwA8oKWIEhGS1NCrwpCI282UHgbum/sBIAWz2KCM88L9aKKix0lPg66DodN89fhIwGhQddVPhm9oaIEw24d9N3So4CLvi7OETKIMZpR41PWuRIXqXLieDIbGWKuk3+9jZ2cHzWYT6XRaSrSzvHez2cRqtcJoNMILL7wg1zibzYroM5lMSthvOByi2+1uNLbr9Xq4f/++eDPq9bpkl7D8frlcFq8Tv0tswAZA7j13ri6bbHiS4eHhcaXQ8WG9gk+n0xvGloWjgiDAr/3ar2G5XOKtb30rFosFDg8Pkc/nkUql0Gg0kMvlxChbGxZL6vV6KBaLIoDTAlEt0NRaDk0wdN0KriTdzJXTztHt/cHUULrbWRSLsXld9IrxdnZCpauc3gPG/WlkmMWgs09IStyQkRae6jLYugS6mwbLxmBu+OSiEeXJcNNbXaJxWgqrq9fgMbZdO+2F0teDehXqZfr9PqrVqhS+YuZTs9nEzZs3kUwmUSgUcPv2bSEg7J5KD4gxYdO/559/XvqX8NqwAijnn5qddDqNdruNdrstYZlEIoF0Oi3bUdtEUbXWYTwJb4YnGR4eHlcO98HHBzmN23Q6xXA4xHg8RrFYFMPPpl6FQkF6NNRqNcxmM1nx8WHN1agOKfBvbUy18dFEw82qOK/mwN1e1zHQRbdYkIvhHXpvEokEut0uyuWyNOICIKRAGx9mp7D1uD4vHdJxM1tIZnTlUYZ2CDekw2v1uNkk2+CGnqLm9GGpq+f1gBD0cGh9jBaU0ujTU8GS3avVCpPJBLu7uzg6OpJCcy+++CJ2dnYQi8VQr9flOlK42W63cffuXSnqVSgUNvqRMEzFbqrFYhH5fB4AhETQG8WMk+VyKWSUc8afJwFPMjw8PK4MrpASgHgKSDZ06IKGMJPJIJVKSQycPRkASJpeEARoNBqyyqaBYEiGBEML+ugFcImGm8Z4EdAkRmeUMCukWCyi3+9vZIGUSiV0Oh0JC2ldiCZQ2ui72Sv0enCu3QwYEirOiXa3R4lmH0Vs+Shz5Qpyt4U9zvvbvQf1uWgy5no+eK3YOZXki0Wx6KXK5XIol8vI5XK4ffs2RqMRGo0G7t27h3K5jOFwiMFgAGstdnZ2kM/npY08U02NMTg8PMRyuRTyVy6XJcuHHYx5XK3DASDfncsigqfBkwwPD48rhTZWNLTatcvVfr1elzg1dQnsFdFoNGTFRh3GdDqV1SI7X3I1yMJIWiCpM0NcA8bfj5sx4cLdJwkQz5MiVnoy+v2+hHxo1Oh94IpaNz/TFTp1nQut/9DeGTdEpAuJRaXiRukcLhvaW6FxHmKhCaM+B1dMym3d8Aw9QJPJBIVCQYiG9jTxfup2u6ItKhQKCIIAL774IoIgkPbrbLbW7/fR7XYBQJqjcRzlclkyquihGA6HUh+G46I2Rws8+ftJejAITzI8PDyuBUgoWCyI4kamsB4cHEjzqGazKe8Nh0NUq1UYY0SDQG/H8fGxGAlWU6SHgJURuerXZOIq50DXntBhDPbHGA6HknGjBaMkE8YYyQIh0dD1HXSqq1vASxMS3aROh0T0XD1pgsE5ivJCRBGJbQRDe2+2EREAElbT+wJOKmlqbwXLwTPNmEXiisWihL6m0ylWqxVee+01ABDhMvUviUQCpVJJQl+8l7lvfU10obRMJiM6DIbKtEfQnT8dnrxseJLh8dh40jetx+sb+mFurUUQBAiCQJpBsblUqVRCoVAQA8z6D0y15N/VahW9Xg/T6RTlclmKWbHBmpvCeh2gxY38XunOqTxnN02XKassbe16aVyjrEMg3B/FjDo7RbcQd4uaXQWiQjTbPBXaC+EWHdPeK/c3PT26dgmwqUmhl41CXX3dkskkGo2GhO4WiwX6/T6SySSSyaS0e2dfExbuarVaAICjoyOsVivs7e0hmUyi3+/j+PgYuVwOhUJBxkDv1HQ6xWKxkCZpJDTAZuG5J33dPMnweGRE3bCebHg8Lmgw6UpOJpPiUqYbmqv56XSKwWCAWq2G6XSKZrOJXC6HWq0mfTlu374tng4aXGZEcJXqejOuI3SGg9ZeaD2HLqjl9kKh4dTnqMNUurooM1U4527a6+NW87wIuDoNTRA0wdDvaxGv9s5EZZ9wvnUTOt2QT6fs0uPB7WezGYrFovQS6ff7mEwmePOb34xOpyN9SxiuWy6XuHv3LgCIoLNcLguxjMViGI1GmM1myOVy4u0iVquVdGFl1VCGHK8anmT8/9u7subEsaWZYBYhEAjwPj1zt9f7///Gfb9LfzEzHrfNDkISu74HR5aLM8Lunmm3sbsywuFuzI7QyZOVlWX4atAE45hP1objhXsM0bXPFj12jTCIaDQaiVSdpqnEbQ8GA1lMrq6upDzCjAedk+Hu8F978TwEvRvXZkRtmKUaoQesaSKiDZvuQqy9GCyL6Imueirra/gwDr0feSbdvJKONv3Sh6LLIPp1kXSxlZcGS3p9dNcNf5fLZcznc4RhKCm0JBye56HRaKDf7yNNU2lXBh4IQq1Wk4FqxWJR1DaWB1myKpfLiOMYk8kEAOD7/u+CtdwyybdsV82DkQzDQWijUJ5pKK8zQP/biIbhS8FjirtGPdGzWq2Kc77b7aJYLMpJlqWUUqkkIUfX19eibtTrdUynUwnkonfBXYhew2PwpTj0/KhkkEixg0QvnJpsUBXRJSPXCKqTQL9mZ82XwlUteJnrzXDLKCRT+nXnxZ67xwHJhO/7iONY2oD5N96Gag/9QXo6bqvVwm63Q7vdxmazEfUtCAJJX2Va6Gg0QhRFuLq6QhiGGI/HmM1m8n4Xi0Wcn5+jXq/LZ0cSqBNs2UHiejJekzgbyTB8MZ4iH64/49hP2IbjAY8hdwfGEzsDqDivhLvSQqEgeQOMHt9sNvj3v/8NALi4uBDJn62hzKV4T9CdKZTzuZi6eRY0iuqhbnnJppp4vSYB089BI68V1fVpuK/7KVKi1Q6aiDn/hccLy24sc7AteLd7TEplW2oQBPj48SN838d6vUaz2ZRy4HA4lOmql5eXQjjm87n4aur1OgAgiiLEcSyXU90AHttT9VC0crks/39NPwYAlJ6/iuF7hfuldhcBXucpX4Z7UjikfhgMGloC5vHEHRynSsZxvJeNwRN8EAQAgHq9LqmLAPZimrmwHOo2eIvHplsO0OmU2p+h56ZoL4rO7Di290GbN12lIq/tmOD7oWPfXYKRp3TowXfMpSDpAiDqBY3J4/EY7XYb/X4fFxcXKBaLkjx7cXGB7XaLIAgk12W1Wkn+yXQ6FQ8IO6S0mZnKXBzH8rpIIPjdYPnFzcI4RCy+5edqSoZhT314rlOEX1ItyXHoTp4k99x9GQwaWhnjcQVgj2SsViv0+33c39+LkjGdTiWkKk1TiVpmRobv+3KCp2FPS+du6eCtIo8s6DLIIZVC3/a1VYtDyFNVeKy4z1UTiUMhaq7HhccXy0za9KlzRADIccdYb05WPT09xXQ6xWAwkLbUfr8vJIcptrvdTiat+r4vz6nVagF48FrsdjtMJhM5hzKcq1qtSpcVu4uYm8GOIL6+Qy2s3xJGMr5z6BNM3o/rTtYkg0RDS3XuDvTQ4xkMh+CW4XQ2g040bLfb0vbXarWQZZn4MFqtFsIwRLFYxHg8FvWjXC7L9FZ9MmbpgItHnmr3VqAXYR0c5aoUh277FuCWSdznrS9/ijTpy9n6zOmzJJ86kh149L6wVMJIe77Xm80G19fXMiun1WpJwJbv+5JpMZlMfmcAZVkmyzKZSsxzq/Z+bLdbaVnl69BTWA8dt6/x+RrJMOwRCv1DZsyD2mXJmmDkkQx936ZmGL4U+rhcr9eSdEhlYrfbYTab7Z1o7+7ukGWZSMtZluHy8hJJkshuj1kZbGFlpgG7TZ5bmN4S9CbiGLwVfwZu6dZtO9VwyyB59+XeniqBO99GGz2ZS8EWaCZ5UtWg6bbf76PVaqHf76NYLMq4d5K86XSKzWYjWRlhGIrHYzQaYT6fSwvqZDLZC+Pa7XZYLpdI01SUGGZ0aOP0sXzGRjLeOL7UPXzouvpktNvtRNbTE/wo11HuA7BXNtExts89hsHwHLjYU2bm8cfaNUfCkxzQfMc2P/o24jiWE/p0OpXjlAtIoVCQjgB3QJrhOOAaNvVlOqGToOEzrwTGjhOdC8KMC16/WCzuqRq6q4STgOfzuXQzscWXPg7Oy2H3CePCGZZ1enqKWq2GQuEhEp9kmfHhzWZTOqYAyMh2htLVajXpkHI3eJ9T9v6WMJLxijjUGvoltz2E5w60Q4ZMfTnJBgnGYrFAmqZI01Rap7gzouv5KTXDfX6HnovBAOQfo1wgdDw2DXg8aTcaDYRhiDRNhVxQ2g7DEIPBAO12W/IgWBfXWRB2TB4XWPpxyyOHuk5o+NRBZIQO2SJBYMuvTj9lLLurahSLRZmUm2XZniej0WggTVPMZjP4vi8EZrlc4uzsbC/CncFyVDfq9boMOlssFpjNZthut2g0GuK9oKLM++D3QSsXh877r0U4jGS8Ep47iT1FEvI6Pj7ntoceU5c+GHmrBygxpnY+n2M+nyOOY0mfI8t3a+jubvCYmLXhbUGTWL179TxvL/0wSRL0ej052dfrdQRBILtUKnPX19f47bffxMVPMs2Wz7y5GIbXhyYa2qDqXsdVKnQrLzsw2IKaJImQCXoatMGY50WqGro0ose081zo+74EmDHafrPZ4OzsTAhsvV7HYDDAZDIRtWI2m4lawrJ0vV4Xk/JyuRQVmYoKj2c3Otx9P177vGstrK+AzyEYT902b4enzUP6Pp4rW+gTuG6LWq/XSJJE5GjggV1nWSZfFq1e5JVLNNE49DzsRG54Ck8RY5IO/psnec/z0Ov1kCQJOp0OhsMhrq6uJB309vZWwrx4HdbQOfH0mLssvmc85S3RnTW6ZVcTDf6doVlayXAHoa3Xa9RqNURRhFarJS3TVNJIJLIsw2KxQLvdxt3dnWRh0HRMotvv96WM0ul04HmelOp834fv+5jNZjIUjUSH51+eX6kgkzjpLIynCMdrwUjGN8Zzrt+nlItDpRVKZfztEgx3wSdTJnPmFD/f90VyJrNfrVaIogjAI5vmyb1SqchsCZ1Mp4nGIcnumL4EhuNG3m6VLYXcsZ6cnMhiQQNdpVKR+Q+MIi+VSmg0GigWixI1PplMxAzKneih4/etmyffM6hyMBtEey60qZdKBwebMV+FRINx4sym4NRez/NkEXeTVbWCwQ4TbdYcjUbiz4jjWEhPv9/fK4dwIivw6B3heZpTg1keyevmO8bzqpGMI4ImCHlEwTVVamKhO0EAyAFIlQF4jGqmgY5smQOoOp0OwjCUeiG/bGy/Yv2bX1AdacvnqEsmeRMAj/FLYDh+6OOehFabkjmIynX7kyBzt8dOlPl8LiQ5SRJJdmTXCU/u7nPIG6Rl+PZwjaD6fKlbdWnmpPqqSyFUwHQphH/zPE8yMng58DjfhX6P5XIpHR88Jkhczs7OhGiEYYh2uy0lFnZMVatVFAqFvXk8wENeRrlclpyMPOPrW4GRjCNE3smNCoFrYCJr3mw2e4Ex/AJVKhWpNXIcME+q/KJQHm42m7i4uECtVkOSJCgWi4jjWEYP69Aa/aNb/vJUFzsRG/4M8k6sus2aRFfPNuEiQeNyuVzG5eUlfvvtNwRBgFarhSiKZId6cnKC2WyGMAwRx7GQEr146fCuY0zF/J7gGkH1v7XapD8r4KFLg6ZNqrU68VWbRYEHxWI2m8nxwrZVmkSpmunrVyoVTKdTaUFlOBdbY8fjsWzuSG4qlQpOTk7QarXkPvnceUy7x9oh39uxwUjGEcA1auoTm1YGdAIiF3fd/cEaHadM1mo1aXnigJ7ZbCZTKtm2d3JygvPzc5RKJbRaLTSbTRkVPBwOJZFOxzK7isrnGIzMl2H4GnCJLdUL7g6p3E2nU1xcXMhJv1AoiKzNqZqcKcHpmbPZTBz+/D7paGo3OdOIxsvjkIKkiQav99RtsyyTOO84jiWRU8dzu4FccRwjDENMJhM0m02kaYosyxAEAebzuZg72+02RqPRnrLmeZ5MXL2+vpbj8/LyUo6p1WolpIebPR7PwOOGkSRJbzh12e5YCQZgJONNQKdrapKhQ4o4NIoMuVKpIAgCMRjxoOUAnru7O0k+BICzszMsFgsAD2ycJ2R+WYAHklGtVuXLmDdf4pCf5HOMqAbD54LHjI4dp1eIwUTtdlsIRr1ex/39PXzfl0CuyWQiJZVWqyVTN1lK1CUWt76vZ4CYR+PloEmCLlVoVVWTD7eM5RKRarWK+XyORqMhkfN6pgkJAlWOSqWCNE3Ft8GySxRFUmZer9cYDAaiTLA1mi2nJCwAEMcxfN8X5aNerwvZoHpM8soSDY8tHTqmz6PHTDAAIxlHh7xF2lUz+IUh403TFEmSyBRA9luHYYjz83PZvW02G3z69AlpmmI4HOL+/l7kwouLC2mrYpoivxgstzCamQYmHf6in9Mfabs1GL4E+juhvUck3qy9U+2rVqtyAuesh2q1isFgIIFKHK3daDSwXq8BYC8FkgSDErerZBjR+PpwCQYTX3WQmiYYLH2wRKIHxDEpkwTD7SgBHg2dmjxyeup8PpfPm7kqcRxjsVig2+1KlhDJye3tLa6urlAoFCQ3o91uY7VaYTabicGTmziqJHw++vXpse3A0+r3scFIxjfGl5YHeGBpJzHZLE2cDMnSTLdSqaDVauH09FSy9WlCyrJsz2tRq9Vwd3cnP2xnZbQtD2CmKmrDqG6d0u2zx86uDW8Hh74zWknT/6aBjgmgYRgCgGS8VKtVAMB4PMbZ2RmWyyU+ffqEZrOJUqkkCkeWZSJ5c0Gi2U+HPOmyjZVOvi7cjhG3JVVfh2UFXdaiCXO5XIoyQEWCZIQklCVnXp/kJggCjMdjNBoN2XyRnHAOCY2bPP/O53Ocn5+Lwswcl06ng/l8LscInwu7/Ego+DgkF64Xjzh2ggEYyXh1HGqR47/d3/rv+oAnGdAjfz3PQ6PRkCFS4/FYUuh4UuTBP51OMRwO0ev1hECwZ5vkgW1UAMSopGuCfD2HcvOP9UtgOH5oopFnLtaXMZ1xtVohjmMUCg+BSTz2KY9/+PBBFIt2uy0JoY1GQ8okbhqku5N2CYYRja8Lvp9UI9gpokscuuvCva7bnqoVAZ6rSByLxSJqtRpGo5EcD6VSScpp9KORYJbLZTmnskzH0jSfE8lNEATYbDYYj8fwPA/NZhMAxLRMcsOyHKG9GHw/+H/3+3CsMJLxBuC6hw+dwDT50As9T7ysGdbrdTF48qSZZRmSJJGJlXRhp2m6t2PgbiDPk3HoOR77l8DwNvAc0eB1eJyzdELyvVwupZT46dMnycYol8toNBpiAgQeyyQkElwEmLLoEgzrNnkZHOrq0Yuufu+pZPC6LikBsEcWSQgAiH+n2+1K19F2u5XALpILEs80TcWzxnLIaDRCsVhEEATi8aFSsVwupZzCIC8aiFn2034MEl3d0cdjTisbxw4jGUeIPFOPniioTW+MAtfyLb0a7CbhgUu5sdls4vz8XNI8m82mDOJJkgSTyUQY9WKx2FMy9FAe/pvPE3h++p8RDsOfgVs6yZOK3TwBJnsCkMWCAUilUknINB3+hUJBFhDOqQiCQDpPtJpIY6GOIzei8XWRFyXOz8BVLnge1J8LF2t6a3jOpMmTLao0ZTIjiGSS97FYLKT0TM8P/Rb0/wRBIKmyVC9o7Gw0GnuZGmxNpVeEHX0a3OC95fKzkYxXQF6NOe/Eqf9PoqH/ToMRe7fJirMsQ5qmYuKkJDyfzwEAQRBIGxUnCna7Xdn9caQ2f1xSQ5KhjZ95z9eFEQzD14CrkukSnc4wAB6ncdIYWigUJCeGte9arYZyuYzBYCDqRavVwnq9RpqmkvjINEcSCl0qNILxcuD7qwmlfq/pqyAxYBt/FEVoNptCHuI43usq4bFAUyePEZY4mHi83W5xenqKfr8vM5tarRam0ynCMNzL4Li5ucHFxQWq1SqCIMBisUAcx3udJrwPvjaWpzmbBIAQIb2x5M9bO48ayThCuDslnjzd+tzJyYnUGumi523TNMV4PJZALcYuk72fnZ1JaxW/EL7vC/un10ObjLREl5c+qn/nvSaD4Wsjr0xHosE6OXecLPVtNhtcX18jiiJp2/Y8D3Eco9PpIIoiWcS4mDQaDWRZJpM7aS51MxuMYHx9uL4LXRLh3zXJo3JF8sBcDBIMmj7pz+H03XK5jDiOJaiLXSW73Q7/93//h6urK/msWVZjfsZwOES5XMbV1ZWUlW9ubsSA32g0hEDw/EryS6Oqni7svv68f78VGMl4JRxipCQJrrLhmpv4u1wuSyuUHr2+XC4xnU6x2+32svJZo2SyHE2inPmgnc26Y4TPTbudNcFwDaD6NgbDtwKPTR6TOo0RgKhzvu+LEphlDyFNzNWg9M20xrOzM/R6PRm+xkhqty5uBONl4JI5lkaoqjIGfLFYSLS8zjVhzgUVDODh3MlWVWZfpGkq5RLP8xAEgQzOOz8/l01aEAS4u7tDt9uVUkyn05GSRxAEqFarMoSPj8eyCVuugf0NIy+jiqFfs7uZe0swkvGKeKqzxL0eT3oaLF/wi6PlNjJ0lj+4myNZ4awHEgctJ+vyTJ6B01UwDj1vg+FbQhN0lg2Bx2OUte/ZbIbVaoV6vb43krtSqUg3FTsN+D3SfycxoXpIH4D2Cri/DX8MuhRFYsf3nKFXLEEwaI0l4NlsJmPYOVGVk6Q5M4TlEXrMeD360VjyoF+Hj91ut6XcstlspE0aeCAJv/zyC/72t7+h1+vJ+Zmbt0qlIoFceuPIEg1JCI9ZvXl7i5s2IxlHCPfElEcy9MHJsCx+aXg9hhKxXqlnn2gTpy595M0kcR/TPdDzPBkGw2sgr/uE3wnWwaliUCK/vb2VkK28gVfz+Rw//vgj/vvf/6Lb7UpXADMS2G3A7+hTCZSGz0ee14WlCv15FQoFSd7UuRbtdhuz2UzUKXozAAgpoRGYj8eJvQzI8n0f8/lcgg6r1Spms5l0K52enmKxWOD29hbX19e4uLjA/f29lFloqKdqzLKIJsDu3CmtEr8HGMk4MuSVS4D92rMO3QKwJ7/p+wCwl4CoWbI+kHU7mEsy3OfG34e+BHYyNRwL3JIGv1flcll2povFQsokrJPryP5ms4mff/4Zg8EA3W5XjKJBECCKImRZBt/3ZbGzAWpfB7o7REeJ89zHMgVLHVQYgAcCoQ2eNIZSgeI8Ek7iZWgXACyXS2k/LRaLmEwm6HQ6Qir0GAaeI5MkwYcPHzCfzzEajVAoPETaUxWZz+d7HSl8PW72BV+33lC+h2Pn7TTbfudwHcZuDobus87LsKDZKM9vof92SMUgnmLY7+ELYXgfcE2gOiKfdXsm5XJ3y0mtuh2V0jbJymq1wu3trSxCWZZJbV9HWutF8T3tSr8VdNKnzrqgilGr1aRrbrPZoFar7Q09I0Fh1wbJA0kDQ7GAx647llAWi4V0KHGwJM2i9Xod6/Ua9/f3uL+/l3PndrvFfD5HqVSC7/uIogjb7RaLxUJ8I9qITBWZG0L3/Mx/v+XWVcJIxhHiuYXc/eFttErB3zqK3CUpLuHQ/3bvW6sXeTkeb/2LYHh/cI9z4PF7QkPoZrORhaBYLKLX64lfI8syDAYDFItFCVxqt9s4Pz8HAGkv5MLjxl/r0C7Xp2F4GlQy9HA6kjY99I7ZGGmaotFoYDKZIAxDRFEkahOVq36/j3a7LVHjjCfn58uWfx3aRt9amqY4OTlBkiQolUr44YcfJIIeeBjNcHp6ikajIceHbovVJJUG/bzX7J5/38N51UjGkeKpcoSrZrhkgAe2mw+gTZ3uCfgQwfjc52UwHCNcwxx3jSQXJAeM159MJuJN4q6ZkzKLxSLu7u6kC4s1/slkIiFdTApNkgS1Wk0WlLzyyff6XTrk7QJ+36mmMzD4OWVZJuFoLIHwtgzXajabQjjSNBUikWWZtKzSuAlAyAYASfi8ublBEAQIggBJkqDdbiOKIpRKJfR6PYRhiKurKyyXS9zd3Uks/X/+85+9jkCaiEmaeLnrx3A3c+8FRjKOGIcOuDw1wyUaVDH0j9sVoonGny2VGAzHiEO+o0LhIbDJ933ZabIdvF6vS9cCF4DtdistrEmSYDabyaA1SvlZ9jCdmDV/JkFSOdGqhk4J/Z7UDd3hphdb/tZGTwDiY9BJnZxL02g0pJuE82U2mw2azaYktjI2XpcuqDYBD8bOWq2G29tbNJtNjMdjLJdLhGGIIAgwHA4xn8+lDOP7Ps7OzjCdTnFycoJ+v4+LiwsZ0RDHMTzPQ7vdxunp6d4Gj+Udfe7VJlAjGYZXQ96Bp9n7oeu7nSN5JCOPqOQZPt/bgW/4fnDou6M7s7jgNZtN6VRg+UMvhmxnJDmYTqdi8qOZr1arYTAYSHaCfg560XRHxr83v9NzSkVeF05eJgZbSeM4xm63Q6PRwHK53DPnsjTB/Av6OGq1GgqFh9wgTkWlwsshkMvlUhSJdruNWq2G6XSKWq0mXSKNRgOz2Qzz+RyTyQRZlkmXEfBwLIVhKKZgTsjebDaYz+d7JTkAueQiz4z/HmAk4w1DkwJXfThENPTfn7rP565nMLwl5B3/JBlc3HTSLYOT+FMsFqW+n6YpfvzxRwmwu7+/l3ko8/kchUIBYRhiMpmIyVR3OLD7QRsVSWb43PQCxAXZvewYoRfJ50yvh4gGd/kccMbBY51OB9vtVsogJGz0ZzCDYrFY4OrqCoPBQAagBUGA29tbAA/KE42ZtVoNvu9jOByKSZifG7MyyuWyJMN2Oh3U63V8+PABu91OymWMHE/TFIvFQkzFTFvW52GW7Ei43vsmzlpY3zieklrdk9Vz95N3e4PhPcI1TLM2zuRHLnKNRgO1Wg21Wg0fPnxAkiQYjUaiYNCzsd1uxVDIXSu7F9hdwJHiQRBgOp2KrK+nhOqBXyzt6G4VLsA6oOq1oUseecqES+5cteKQgkHStVgs0Ol0MBgMJKl4NpvJWAXgcRorx7J/+vRJEjeZc1GtVmXarud5onoAkMej34ZEhJ8nADSbTQlzYypsGIaSPurGhOtOGPpBdGtq3rn5GD7Prw1TMt4BntrVfO5B65ZU3uPBbjDo49s1TzNyvFqt7k0mHo/HuLu7w93dHabTKVqtlrS9MjWURlB2JHC4lY6upoFxPp8jDENpjdQGQYZMUYbnbl7P6tAmUuB1SymuxyJPmdDX1aRCGzy1UkNSxdZU4CH7gvkVURSh0WiIakF1abvdotVq7Q2/I1EgKWTJgyUNzhSp1+t7barT6RSe5yEMQ4RhKOoUjfWe52Gz2cjz4mwbqhQkNPV6fS8g0VWX3Wj694j3/wq/E1hHiMHw+dALgl7kS6WS7Dx930eh8JBtEAQBwjCUlkYuREmSII5jxHGMdruNxWIhwVzT6VTug14ASvSTyUSmulIFYGkgiiLZobNFk0SDlx0qr3xLPEUstPdCv+f8rW8LYO+1UPWpVqt7baDs8KnX61itVjLMbDwe4+rqCtvtVkonnudhuVzC931pM47jWIZBkmwwBZbBXff396Jglctl/Pzzz7i/vwcAfPz4UbpRqtUqWq2WkECdx6I7RwDkziDha/0eYCTjneEpQ6fBYHiE/n6QTOi6OX0a6/VaauyUwAHslUOoZjDca7lc4uLiQm7PFlcuPkEQSJcEOyO4qLZaLZmxwRKLVjf03A6+ji8xhn8tsETBzhmtTuTBVTHYYQM8TnXebDZoNBqSpkoVSIep0Uzr+z7W67WUR0qlkhhEtd+FceMsg202G3ieh8vLS8nKqNfrSNMUQRCgUChgMBggyzJ0u12cnZ1JtwjNo3EcyxDKfr8v49zdmSMAcoMO8xKV3yuMZBgMBgMepWydhut5nuyKl8ulpDWu12sUCgV0u13pImA5hNdL01R24rvdTlohN5uNdEe0Wi2p8TMEim2X3CVzPgoHtnGnz4XKjS7P8znw8j+KPCKj/SNUGfR1C4XCHgGhGkFFh2UFvfhWKhVMJhO0Wi35TJIkERJCgseALpKGarWKYrGI5XIpSgTw2M1TrVZxenoqn00URTKdleoTVaMgCGRwWrvdRpIkuLm5wWazQZqmqNfrqFarODk5kURYql2lUmnPLMxkTzcu4HvaABrJMBgM3zXc1m4SBsrd3E0Xi0UhF1xAGUnN2r7neVIG4X23220AD8ZBDt9iOWA4HMrumUZEKiTcGW+3WzE7VqtVISTcNeu8DZ3BkTfz448sapq08DVpg6ZbvuHjsPxDrwpfj54zkqapdPiwLZQBWnyv2YZaKBTkfSMhILnhD8sV9G5o70Sv10O9XkcQBCiXyxgOh0IUAYjqxC6i9XotE3t1uzEJTJZl8DwPzWZTwr1YOiHReo8Dz74URjIMBsN3D9fwrGP2tezNhYhqgvYLLJdLTCYTSRSlJ2A0GiFN072ZGmmaYrlcotVqyXwMzlVZLpfi3eBCy+vO53NRAJgmqgduuVHcXJCpHnyp0dBVRbQ6QU8LDZMc0sj3zPd9jMdjdLtdIUgsgTARlYSJxIVKDrt2AAjhW6/XSJJE3j8GqFE9SJIEp6en4o+h2sNSFce2k1z88MMPmM/nWC6XSJIEFxcXaLfb4vXQ5KDb7cpE1jiOMZvNMJvN9nwlukNIk1V9DH0PyoULIxkGg8GA32dpUOLmwlGtVve6PEgKdOmC3SbNZlMmu3JRZpsjAFEk2PoahiFWq5W0wXIuBoOnmMdwenoqBkMqGdzVc9EnUfE8T8bQU0Wg2vDUe6AXQhIM3pblB3oZ+LpJtPi+ZNlDfHcYhhiPxwiCAKvVSp43y0lpmkpJolarYTgcolwu4+rqCuPxGLvdTghdo9GQbBK2D4/HY9TrdRlYRwVku90ijmMx3QIPJRbgoSVWl3ZI5AaDAabTqXy+bE1uNpsAsDc47+TkRBSoJElkAJoe45BHLL5HRcNIhsFgMCjktXIz0pqXcddOb4UmEsxS4ALq+z46nc5eCytDufh4LJNQpgcgZkSWBUqlEsbjsXS4UBnhos/nRdJBJYM+hOdyNVyVQneAcIHl43JX7/u+PDZLA/SPABCFgws3g620p4Elp9VqhdPTUwDAzc0NfN9Ho9GQ+PDRaIRSqYRff/1V/C0kKLwu54TMZjN8+PBBArW63S52u50oFK1WC8vlUp7f1dWVzCzh+7Db7TAcDjGZTETB0ERLB7kxvI3qksUAPMJIhsFgMCjkKRravMfFl4oCf5bLpeQ1cDGaTqeIogjj8Rir1QpRFIlng6bHbrcrO3C9yPG5MD6bLZN8LvQ5sByi/RnAY1soF3mdD+K+Xl5flz7069b3US6XkSSJxHl7nrdnavR9H2mayu2p/lBJKJVKmE6nct3tdoswDJFlmaRmnp6eYrvdot/vSwmK8e3/+Mc/ZEYMANzd3cnzu7u7Q7fbRRRFUmIBIImco9FIzLfaW5MkibS+0mNRLpfRbDaFPDFLA4DcN9Ubvoeu0fZ7SfV8Cpb4aTAYDAp5nRRcsDXJ0CUL7mx522q1Kr4JzkBhGaPZbKLX64lqQcVjsVjg/Px8L79hs9nA931sNhvc39+j2+0iSRJJsOS8jizLRLmggdL3fSkN6M4ZN4kzLwyMA8n4d5IEts6yjZbqCWe6JEkiZKzVamE4HKJWq6FSqYihslQqycj1OI7ltZLkMChruVzip59+ksm4NGLyevTEXF5eSg4JCQGDu1qtlpRmfN/HdDrFarWSMlKz2ZT/M8WTxKhcLsP3fSlzuXNu+L7zc/+jxtr3DiMZBoPB4EATDd1N4YYpcbHhTpqyOSOm6cvg5fRMVKtV+VuWZZKzwOFenU5HyMpsNkO9XpdYay6wbLv0PE8mv7Ldk+USAHvlFE003G4Ull4WiwVqtZoYMqlqaCMpiUyn00Gv15Nsj2q1Ko8zmUwkjIxx3/RYJEmCJElweXkps1zohygUCjKufTgcSuZFoVBAp9ORxyYxOD09lQwTz/MwGo0k1Iyx4mEY4v7+Hs1mU/JMAEi+yWq1EsIWRZGUvjzPk2A0EkZgn2gcygb5XpULF1YuMRgMhhy4WQYuwdDtifo6en4FY8UBiHm0WCyi2WxKeaBQeEgQ5c9PP/0kpYLVaiWlFbatsstivV7v7dhZPtAzTmq12u8mgLrPl8oAyx21Wk3aPxmQBUBivHk/HDpGvwlLSFQJ+Fz52DR2bjYbhGGIVquFm5sblMtlfPz4UbwmrVZLcjJWqxWCIJC/0fMRhiGur68BQDIvWOYhUaLa0+l00G630W63MZ/PkSSJtNwyI4PvrX5PmHdBMqdbdDXxdPE9l0byYCTDYDAYPhNufV0ngwL4XYsoOxFYxuDo7yiKxPjJzojxeIwoijAYDJAkCa6urpBlD0O4er0eut2uzE6hD4OLK//PBXCxWEhHCoeBaVMiFQyC2RUcEMfHYqCUTsqkqpEkCT58+IDxeAwAkhECQOaHMNZ7vV6j1+vhhx9+wGazwWAwQLlclmmqJFaLxUIIB0Fywy6R5XKJ8XiM8Xgs3SZUOvies9xB5SeOY3k97MSh6kIix5bTSqUipREqS/Tf6OOAJEOHaxl+DyMZBoPB8Aeh1Q6dq+HW7bkA0mtQKBRkceQi6Ps+zs/P4XmelFhcdYG7beBBSQAeulDYSskOCY6S73Q6krtBPwQ7VqiikFywLbVSqaDf76Pdbu9lPJC8MFGzWCzi/v5e/BWr1QrD4VA6ana7HUajEbIsE9VhPB7jw4cPQih2ux1msxmiKBIfR7vdxmQykeArkjD6H8rlsnSd6OCr5XIp3gyd2skWU8/zZGAZAGk/9n1fvBflcllKJBx0B+B3aZ368zc8DSMZBoPB8CeRt6ulvE7CwFIKd+k0E+pAJ5oQsyyTHA12pHDK6HQ6BQAMBgMJB8uyDJ1OB5PJRKaXMmhKZ1ssl0t0u13EcYxGoyHeiSAIRJFhJweDv+j7YDcIOzfY0aKHyl1cXOB///uf7PqZjnl/fy/Xubm5QaVSQavVkveAORjb7RbdblcCz9gKXKvVJGuDs2Hm87l0j5AAtNttRFGE4XAoJIXeF+ZnkBBxuB2VDLag6rh2emt0d5EmXVYWeR5GMgwGg+ErQUv2OvGRygYXLOY3FAoF2UVT8qdysVwuhZBQrmcseRiGEpnNroler4fLy0uZEHtxcSElAe7IT05OpFTBNMxqtSpTSNmuOp1ORWVhlwjLMZz3sdlscHZ2ht9++01SMNM0xY8//ihx4/SesAOj0WigVCohiiL0+32USiWJHv/48SMWiwWm06lMQQ2CQAgOCVMURVLSYKw4CRN9LyQTnPVCMsLPht0qfB3A/pA2XRrRatX3Hqz1R2DdJQaDwfAn4ZpCXUk9b5HSg9hYztBEhIseZ20ADx4BDlADgE6ng/V6jb/+9a+4ubmR3TnLK9pLUSgUZJEvl8v49ddfZYQ91YxyuYzBYICrqytMJhPxfJAsTCYTNJtNeJ6HXq8nKaTMraDvg0pJv98XgyxHptfrdSEcvK7neTg9PUWWZbi9vUWr1UKlUsFsNtuL+d5sNuh0OvB9X+aKMEeEPyzV0CQKQF4/PRm6o4afmfaoHCqDGLH4chjJMBgMhq8AdwE6FHqlL+fYcrZlukFaTBBlVwd37Fycb29vxbdAfwVbatfrtQz/6vV6aDabuL+/FyPoX/7yF2l9HY1GMv307OxMWmr/+c9/4u7uTv62Xq/R7/elO2Q6nUqgFnf/zWYTURQBgKRrrtdrXF1diU/i/PwcvV4Pq9VKskGm06l4ITh2HQDOzs6k1ZckiwpRu90WVYKmVbYK+76PWq0mhEMPUOP/+d5rr4tr7NWtzIYvh5VLDAaD4YWhFy6qFTQz0jCqO1S4C2eCKFtBqSZst1s0Gg3ZtdMbwXbL1WqFTqcDANLuSk8EO0TSNEUURbi9vUWh8DAwbDAYSPhVqVTCv/71L1ESfN+H53n4+9//jiRJsFgshBCMRiMAD2bK8XgsIVhZlu0NdZtOp5hMJjLjg6+dxId+EAB7HTNRFElHCN8n3/f3ykG8PRUiXQphhwt9Gbwe32vXU2P4ejAlw2AwGF4YOnZa/x94VDZopNThV5T7OWmUHRkM12KLKH0E1WoVZ2dnWK/Xok40m01cXFygVqvhl19+wXq9Rr1el/vU6aTX19cS+805IvQz3N3dCYlhKmcYhojjWIa5kUiQYJD4lMtliVZvNBoy4p0GUx1fTvWArx0AWq2WEC+2BdMYy7H2VCN0MBrbXnUp5LkZLoavCyMZBoPB8ILIW9B03obOrWCpgx0h/D9/A48x3wyL4kRXGiHZ6lqv1/cmqI7HY8mlYAvt+fk5qtUq0jTFYDDAZrOR+6MBk2WYKIpkLgg7NDabjaSRMjCrVqvttcNut1tJ3WQZR5c89DwQwvM8iShnpw1fL1WP3W4nwVq1Wk0elzkZnEvC9yAvRMtNdf2cz87wZTCSYTAYDN8I7qKlDYc6QZQ/bO/U16Nhkbt4LtbL5VIWSrZftlotVKtVjMdjlMtl6STRJQO2vTKWu1QqyaRYEhQ9hZSR5e6kVQCSwRHHsfhDGo2GhFox8ZRR3cvlUnwTVEfYwsscDE6hpWeFHTj0rVDJIRnSba26lJLns8j7TA5dZvhjMJJhMBgML4i8gWv6cv03Loz6NnrSpy6V8D7oLaABk9fbbrfwPA9RFCGKIoRhiHq9jiiKZJ4IWza5qNfrdYxGI7nP2Wwm5IX+B/6bRkvOY4njWMaqc6hbHMeSDaLNlTqwDICURvRQOaoz7B7Rw8tIutyhZfy7nmLrzhjJ6/4xvByMZBgMBsMLI2/+ib780HV166tOnOQuHoCYKKkcAJDrMYCL2RaMOOfiy7ZZZlCwM6NWq0kUOkOz6K1ghge9EFRTqGKwE4QLPTs/9CwU/pRKJelkoZeCfg79Ovg6aQTl3/LeT63maFJhZOJ1YCTDYDAYvhEOkQ39N/5dL4x64TzkK9C7eV6uk0YBCDHg/bAUwfAsTmIFILNV+Pgc6MZ2Wr3ok6yQWDDqnMRos9lgNpvJfZfLZTFmcl4I74PX4f1pvwq9GJp0uS2mecrRITXJ8PIwkmEwGAzfGM8lRz5lQtRyPxdgHXvNhZglE+7oeT36MagY0BTJv5OQLBYLlMtlMWtSsWCgFT0dNJzqBV+bLdnhwVIGw8aYZkqSwpCwcrksj3eopOR26eQpFUYqjgNGMgwGg+EV8dzimKdwuLt3vdhycebljPTmbWmM5GUst2jvh1YPtHJClQGAEAv6QAAIcSC5oUqhSx4kOlRCeL+6e0aXiVyS4f7NvfzQ+2p4HRjJMBgMhiPCoZJKXvKka2TUXg1X7eAirFUAKhPEarUStYGmSpISGi51pwtNowTJhVvS0QmbVEAA/M4MqifZuqWizyEURiyOD0YyDAaD4QjxXEnFvdxdePMCv1xVQMeB8/a6M4PtoTp7QqsIeR0jWk2h0kEFQyeb6ueY50HJIxJasXnq/TIcD4xkGAwGw5Hjc4yL7iJ7SAnQqgah2zx5G62SuCRAqxFu5oTOr3A9I/o55ZV6nlMkjEi8PRjJMBgMhjeAz+1Meeq2RF7C5SEvyOcoIu7tqGjkmVXz7u9LXovhbcFIhsFgMLwh/NFF+BDRyEu/1IZLlyzkEQf9GJ9DHPJu6z4Hw/uAkQyDwWD4TvE5Xo+nFv2nsik08v5uZOL7gJEMg8FgMPxhfI5B1b2e4fuBkQyDwWAwfDaMLBi+BMXnr2IwGAwGg8Hw5TCSYTAYDAaD4UVQMOnLYDAYDAbDS8CUDIPBYDAYDC8CIxkGg8FgMBheBEYyDAaDwWAwvAiMZBgMBoPBYHgRGMkwGAwGg8HwIjCSYTAYDAaD4UVgJMNgMBgMBsOLwEiGwWAwGAyGF4GRDIPBYDAYDC+C/wdIDoKdq9StlQAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "" ] @@ -338,7 +347,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -348,7 +357,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -358,14 +367,28 @@ } ], "source": [ - "po.imshow(eigendist_f.eigendistortions[[0,-1]].mean(1, keepdim=True), vrange='auto1',\n", - " title=[\"most-noticeable distortion\", \"least-noticeable\"], zoom=zoom)\n", + "po.imshow(\n", + " eigendist_f.eigendistortions[[0, -1]].mean(1, keepdim=True),\n", + " vrange=\"auto1\",\n", + " title=[\"most-noticeable distortion\", \"least-noticeable\"],\n", + " zoom=zoom,\n", + ")\n", "\n", - "alpha_max, alpha_min = 3., 4.\n", - "f_max = po.synth.eigendistortion.display_eigendistortion(eigendist_f, eigenindex=0, alpha=alpha_max, \n", - " title=f'img + {alpha_max} * max_dist', zoom=zoom)\n", - "f_min = po.synth.eigendistortion.display_eigendistortion(eigendist_f, eigenindex=-1, alpha=alpha_min, \n", - " title=f'img + {alpha_min} * min_dist', zoom=zoom)" + "alpha_max, alpha_min = 3.0, 4.0\n", + "f_max = po.synth.eigendistortion.display_eigendistortion(\n", + " eigendist_f,\n", + " eigenindex=0,\n", + " alpha=alpha_max,\n", + " title=f\"img + {alpha_max} * max_dist\",\n", + " zoom=zoom,\n", + ")\n", + "f_min = po.synth.eigendistortion.display_eigendistortion(\n", + " eigendist_f,\n", + " eigenindex=-1,\n", + " alpha=alpha_min,\n", + " title=f\"img + {alpha_min} * min_dist\",\n", + " zoom=zoom,\n", + ")" ] }, { @@ -399,7 +422,8 @@ "# Create a class that takes the nth layer output of a given model\n", "class NthLayerVGG16(nn.Module):\n", " \"\"\"Wrapper to get the response of an intermediate layer of VGG16\"\"\"\n", - " def __init__(self, layer: int = None, device=torch.device('cpu')):\n", + "\n", + " def __init__(self, layer: int = None, device=torch.device(\"cpu\")):\n", " \"\"\"\n", " Parameters\n", " ----------\n", @@ -509,23 +533,25 @@ "# VGG16\n", "def normalize(img_tensor):\n", " \"\"\"standardize the image for vgg16\"\"\"\n", - " return (img_tensor-img_tensor.mean())/ img_tensor.std()\n", + " return (img_tensor - img_tensor.mean()) / img_tensor.std()\n", + "\n", + "\n", "image_tensor = normalize(crop(image)).to(device)\n", "\n", "# reduce size of image if we're on CPU, otherwise this will take too long\n", - "if device.type == 'cpu':\n", - " image_tensor = image_tensor[...,100:164,100:164]\n", + "if device.type == \"cpu\":\n", + " image_tensor = image_tensor[..., 100:164, 100:164]\n", " # want to zoom so this is displayed at same size\n", " zoom = 256 / 64\n", "\n", - "image_tensor3 = torch.cat([image_tensor]*3, dim=1).to(device)\n", + "image_tensor3 = torch.cat([image_tensor] * 3, dim=1).to(device)\n", "\n", "# \"layer 3\" according to Berardino et al (2017)\n", "mdl_v = NthLayerVGG16(layer=11, device=device)\n", "po.tools.remove_grad(mdl_v)\n", "\n", "eigendist_v = Eigendistortion(image=image_tensor3, model=mdl_v)\n", - "eigendist_v.synthesize(k=2, method='power', max_iter=max_iter_vgg)" + "eigendist_v.synthesize(k=2, method=\"power\", max_iter=max_iter_vgg)" ] }, { @@ -561,7 +587,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -571,7 +597,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -581,7 +607,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAAFJCAYAAAAlscChAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA7EAAAOxAGVKw4bAAEAAElEQVR4nOy9eZikV3Ue/t7aq7r2qq6urt737hmtIzYpYMAIpOAYYmNAtrENiR1s5+fY8R4nNjg42NgEEieOTRwcYWMMMbGxYzABZKSAAQkhjTRbz/ReXV1da9fStW/f74+v3jNft2akGaGWGNz3efrpmeqvqr7l3nPPec973qM0TcPxOB7H43jcSMP0Qp/A8Tgex+N4XO84NlzH43gcjxtuHBuu43E8jscNN44N1/E4HsfjhhvHhut4HI/jccONY8N1PI7H8bjhxrHhOh7H43jccOPYcB2P43E8brhxbLiOx/E4HjfcuC7DpZR6t1Jq84jO5QUbSqmfVUr9H6VUUimlKaXe/TTH/gul1EWlVLP/+53fzHFXee8/VUqdVko1lFKbSqlfUUpd87O6nmfUv963X+vxz/VQSr39hfz+ZzqPb4U5r5S6/1rO4fk+18Pfp5Sa7M+nV13HZ/xTpdTPXO93X6/H9T8AfM/1fskNMH4MQATAp57uIKXUjwH4AwB/DuDe/u/f779+3cdd5TvuAfC/ATwM4B8D+F0AvwbgPc/wvp9USs0fem1YKfXLz/SdL/B4e//nhR5vx5XP49t1zh/F2AVwJ4DHruM9/xTAz1zvF1mu52BN0xIAEtf7Jc/X6Fv/d2uadv91vvWkpmm9/mf8xFU+2wLgPwD4n5qm/bv+y19USsUA/IZS6n9qmta51uOe5lx+C8CDmqa90/BeN4BfUUr9J03Tsld53yUAH1ZKfQWATSn1SwDeBOC3r+kOHI8rjm/1Of+tNDRNawL42vPxXd9UqGhwDX9MKfVbSqm0UmpfKfVRpZRLKTWrlPq/SqmKUmpVKfW2K3zm9yullvth0Rml1BuUUg8qpe7/5i/v2gaN1jOMOwEMAvjoodf/BLq3dud1HveUoZQaA3DbVd5rh+69XXFomvYFAN8BIAxgGMArAbxc07RPXu09T3Mer1JK/V3/uVWUUn+rlDpx6Jg39p9tSilVU0qd7Yfc5kPH/YBS6vH+55T7z/id/b892D/PV/bnkXatz70/FzWl1Ez/PKpKqTWl1E9d4diXKKW+YLieLyilXmL4+1XP40rhl1JqQCn1PqXUeh8KSCqlPqGU8hmOmVJKfUwple3P7ceUUm849Dk3KaX+TCm1pZSq98//vymlAle55u/of05DKbWilPrBa7hPA0qp31Y65NDqn/MvK6XUM7330OfcqpT6f/3v3lFK/SoAdeiYp4SKSql7lFJfUUqV+vf+olLq1/p/ux/AjwCYMNz3B6/lfK7L43qa8e8APADghwGcBPA+AF0ApwB8CMD7AfwkgI8opR7VNG25f+KvBfCn0EO0n4W+4P8TAAeAzefo3J6rcbL/++yh18/1f58A8KXrOO6av0PTtA2lVK3/3iuO/mT5degh5i6AhwB8SSn125qm/e+rve8Kn/NdAP4KwF8D+AHom9sv9z/rFk3TdvqHzgD4WwAfBNAC8CIA/x66cf7l/me9HLoR/l0Av9D/rCUA/v5n/CQuG+mf7P++mkd5tfEpAPcD+B0A3w3gd5VSF/qGHEqpW6Dfi7O4HAr+EoCHlFIv1TTtyes5D6WUDcDnAdwC4Deh3+8AgH8CwA2g1N+AHgaQgh4G5aDfy08ppb5b07RP9z9uDMAKgI8DKACYBfArAG7HUze4APQN7DcBxAH8KIA/UUqlea1XOFcLgM9Cv+fv6d+Du6DPk0D/PjzjUEoFAfwdgDR0Q9ME8Iv98+8+zfumoc+jT0KfG20AcwCm+4e8B/qaP4XL4Xj5Ws4JmqZd8w+AdwPYNPx/EoAG4HOHjvuL/uv3GV4LAOgA+LeG174C4AkAyvDaHf333v8M56KgG17jzyaAf3boNfN1XqMGPdw8/Pqv9P9mOfS6pf/6v7me467y3T/QP2b2Cn9LAPjQ07z3XwKY7/97s/87BuCXr+F63274/yqA/3voGD+APID3P8Oz+HfQF6Cp//rPA9h7hu9/EHpo/Gzmogbghw69fgbAfzf8/5MA9gB4Da95+6/9+TOdxxXm/D/rf+/rn+bcPgzdaAUOvf4AgEef5n0WAK/of/7thtfv77/2PYfu+RkAf/805/pD/ffddeh7fhW68Qld473+jf7xI4bXBqAb5CvZg1f1//99/f97n+az7zd+xrX+PFd0iL899P/l/u//yxc0TSsAyEC30uiHFC8C8EmtfwX9474BYOMavvOV0C248WcC+qQxvvbA9V/OjTc0Tfs9TdMuHXotqWnab13rZyil5qB7Un+qlLLwB0AF+ibzHYZjh5VSH1JKbUH3uNrQd1A/dK8LAL4OIKB06OC7jKHUczg+fej/ZwGMG/7/HQD+WtM02cn7//5rGK7nOsbrAOxomvaZpznm3v557R+6j38L4JRSagDQvTelZ4yXlVJ16Pfw//U/Y+HQZ7b758xr0KAnfV6srp5xvhfAGoBHDp3HZwHYALz0Gq/5TugGkt42NE2rAvg/z/C+0/3z/rhS6k1KqcFr/L5nHM+V4Soc+n8LEGN1+HVH/99hAFboxuzwSF/Dd34DwIsP/exCd4ONr10zDeEZBq/lMP4Q7P/eu87jruc7+NrTvVeGpmmT13LcFQYNzkfw1E3hnwAIAUB/ofw1gFcBeBeAV0O/1/+h/35H/zweAvBm6JvVpwDklFKfV0rd9CzP7ylD07TD96SJy3MM0O/77hXemsLlZ3I9I4RnBusj0D2zw/fwd6B7Svze3wTwbwD8IYDXQ7+H39v/m/EaACCvadrhsCwNfQ1dzSBEoG9Eh8/jEcO1XMuI4cpr8mnXqaZpqwDugW5nPgogrZT6mlLqFdf4vVcdzxXG9WxGDvpNjFzhb0MALj7dmzVN2wfwqPE1pVQLutv56JXf9U0NYlQnoYcVHMSdzl/ncc/0HV/ni0qpSQCuZ3jvczHy/d+/COCLV/h7s/97Brq3/B2apglep5R64+E3aHpy4JNKz4y+Cjr++bdKqXGjp32EYw96suLwiOIaN4JDIwdg8RmOyUN/9u+/yt+54O8D8Nuapv1H/uFpvNKQUsp8yHgNQV9DV8MF89BD/++/yt+vJbIBgGT/uw6PK712YGia9kXomXE7gH8EHev6jFJq4gqbzjWPF4w5338AjwL4PmOGQyl1B4CpF+q8nmZ8FfqkPZzJeRv0ifPV6zzuKUPTtDh0zO9K723BEHof0bgIHSc8oWnao1f4OdM/ztX/3eYb+6D1VbNcmqZVNE37G+jJmlFc9ioPe0jP9XgIwHcrpTyGc/VAB/L/n+G4az2PzwEYVUr946c55rMAbgVw9ir3sdU/zgXDPeyPf3aVz7QCkKxkf818H4BHtKtnxT8LPWwuXeU88ld53+HxFQD/SCk1Yvj+Aej38JqGpmlNTdP+Djo9xw0d1gGe5fN/IT0uQA8zPgfgfyul/gf08PHd0N34a6EoPCdDKfUi6MAixwml1PcB4jFA07R2PwX835RSu9CzLN8JfaL9hNbnZl3rcf3vfQDAhKZps4bv/hUAf6OU+n0An4CeYfp3AD6gadqVwurnbGiapiml/iWAv1JKOaBjKHno3sldANY1TfvPAC4A2Opf47ugL6qfxaFnppT699B35S9C37XHAPwr6AA1d9sLAP6FUupN/c/MaZq2+Rxe1nugh7lfUEqR0/aL0I2GkdR7refxUeiE5f+llHov9LDLB+C7APxaHwf6tf7rDymlfq//eQEANwMY1zSNROTPAvh5pVQa+v15C66OO5UB/CelVAR6VvHH+p/32qe59j8F8A7oHs/7oYP5NujZyzcA+Ceazr16pvFB6NnWzymlfh36JvqLAOpP9yal1I9DxxE/A2Ab+vr+N9BDbUYPvO//HMCTAMqapj1ttAXgOcsqvv0Kx2lXeP8mDmULoWfSLkK3vOegp0UfB/DB68009D//7c/ifff3r+MpP1c49sehkz2b/d8/cZXPfMbjoIcTT8moQMc5nui/Nw49C3Rd2dHruPYrPb87AfwNdMyt0b+vfwbgZYZjbgPwZQC1/kT899BT9BqAyf4x3wXdS9ztX8s2dCZ61PA5Mej0izyuIZt8DXPsfhzKDkI3Bg9ATzJU+v9+yaFjrngeh+d8/zU3gP/YfzYt6Ebnz3Awcznav9ad/jG70DfpHzAcE8ZlKkQBuqF58eFn0r+mTegZx8f693IVwNuebn32X3P0X1/uvy8PnarxLvSzv9d4v2+D7qE2+tf0q9Dx5CvZg1cZ5tFf9Z97s38PPoF+9ttwL/8YOtbdO/zsrvaj+m/+lhlKqVHoD+XHNE37kxf6fI7H8Tge33rjBTVcfcD2dwB8ATouNAOdqOiEXoZTfcFO7ngcj+PxLTteaIyrAz3j83vQU7Ml6JjQLx4brX+4o881uurQnr7W83hcx+jzKZ+u/KerfauFZXiBPa7jcTwOjz7145nS9FPacwvg/4MdSq/DnHiaQ96hXb9owZGPF9rjOh7H4/BIQgeon+mY4/HcjO+GXsB/tXGtXK/ndRx7XMfjeByPG24cSzd/Cw6lK15S5uN/HPpbQCn1YaVUXulSLtdcQqOUciil3q+U2lW6jMpXn4vyi+sZSilTvz5vU+kSKaeVUk8R6rvW467je69Z5fYq7/+mVGmfi6GUernSJWLq/Wf4H/t8u+s+Tin1WXWdUkLfUuMouEHHP9/cD3TezmMAXgZg2vC6gs6dikMvF7kXOjM8C2D4Gj73T6HzhX4UwGugq3jUAdzyPF7bf4DOBfpZ6DWOH4IujXLPsznuOr73AnT+0n/DVRRAnua99/S/+0P9c/nZ/rn9h+fxvt3Sf1Z/0X92P9p/ln/6LI9b7M+vXVwjd+5b6ecFP4Hn6KHaX+hzeI6v535cWWLljf1F9wrDaz7oNXcfeIbPvBWHZGCgY5wXAfzFc3Tem3gaAjD0utQmgF899PoDAB673uOu89xMhn9fr+F6HMADh177tb7xGnwO7tu7r/S8Dx3zl9BJpBbDaz/cv5Zbrve4Q8/s/qOYx0f5c8OFiuqy8uUJ1Ve1hK5mAKXUP1O6SmNW6UqsjymlfvgKn6H1P+fnlFJxpStz/q1SavzQcS6l1O/3w7KKUuovlVJ3qSs0BFBKfa/SK99rSqmiUup/9cm0z+V4A4C4Zihs1jStBF1e5CkFzld4bwt6GQ/f24HO3P7HSikrX1dKDSql/qAfVrWUUhf6JRnf7LgHesnJYYXXjwK4XekCfNdz3DUP7dpUbp8y1HWq0iq9ScoT/ZAyq5T6Q6WU/9l8t+Ezrf3v+YR2kAryv6A/0zdez3HfDuOGM1yG8VfQlSi/GzoPDNCVFT8GvYzoe6HXSP1Rv2bq8Hg79Dqv/w96HeEi9FDKOP479Fqv34ZeinTxCsewJuuT0LWg3gS93OdWAA/2SbY8jkZ38rqvVh8n8VRlVUAvlZpSSjmf4b2rmqY1rvBeB/qqlEopL/Rw9F7oXsXroetI/aG6ih7/dYyTAGqaph3OVBnVYa/nuOdjXFWVFnq5k5yLUuq3oM/Fz0HfKH4Jep3kZ75JPGwG+jM6fA4N6HpbJ67zuBt+3Mh0iP+oadofGF/QLjenoGbUF6EXCP8E9K47xtGAXmTa6R8PAH+ulIppmpZUSi1AN4A/r2naB/rv+bxSygVAdM37hul9AP6Hpmn/wvD6I9Bd9rcD+K/9l3vQsZJnm8oNQi+HOjz2oONffly98DWIp+qm8b38OwD8NHRFgZs0TVvrv/YFpcutvFsp9d81Tesq/YaZ8dRhUgcJpJp2WYrlWs/hWo97Pga/60rnU+Df+5vRL0APb9/LA5RSK9Br/F4Pvf7zSqRPk/7yQeKtwWt6unPYw8H7di3H3fDjRve4Dgyl1JzSmw/s4LJo2j/HU9UkAV1u2uhOU7KF4eJLoU+uP8fBcbj5xJ3QpYAPq4bGoXtoorKpadq/1zTNomna1jVd4Qsz7oUuY7KlnqqaGcHle/lKHCvQGsdroa+nw/PgqwD2cVBtdQ0H79Gv9v9+4H5+E575t/24kT2ulPE/fc/n89BF2n4Olyv3fwJX1ji6knImcFkbiOJzh6VkDqs+Ugjxwauc53MpRVPAldVRg9C9uOIzvHfkCq8fVmaNQJc9OawTxUHVTCrQGsdfQw+v/8bw2v6hc7ja+RvP4VqPez4GvZdnUqXlPNi8yucY1UYPkz7/BfReC4fVekm0fbpzCEJXX7ie4274ccMaLq2fEjGMO6Hv+K/QNE0ekNIF7p7NoNxvBAcf+GHVR4qx/RAua+0bx/4VXnu24xx0ba/D4wSADU3Tnk4f6RyANyql7NpBDaYT0MPm9f7/89Cv/Wev8jkXgWetQHsOgEspNakdLNm5korstRz3fIxrVaXlPHgNrtypJsd/aJcFGflZ/wS61MvV7tsa9I31JAwRQJ+bNQ1dUud6jrvhx40cKh4eV1LlDMGgGnmd4xHoXsybD71++P9fgW6cZrQrq0w+syjatY+/ht6D7h/xhT6Y/t0wNFK4yvg/0Hf57zO81wLgrQA+q2ka7xvbWW1e5Xq+GUP8WejP50oKr6cNG861HnfkQ7t2VdrPQ8cwx65y3za/iXNoQb8nbz2Eg30f9Gf6f67nuG+L8ULzMa73B1cXkBuEri7xBejp9O+HvluuHj4eV+Dx4JAIWv+1j0L3Rn4JOobxm9BDAQ263jqPeyf0hfb70A3lq6BP9P8B4K2G434NuiLGxDNc4/24Mo/LhD7+BN3g3AM9RM3hYOuoif73/Nqh938cemjzz6F7Bp/sX99thmN80MmaF6CHMK+Cbhh/AcBfPsN5b+IZhByhd+puAPjX/c/+fegL/h8/y+MexDW0t4Kukf99uNwy63/x/4eOewB69tX42uv73/37/XP51/1z+81Dx70Xeqbxt/rveQ305MzHYODeXWVOP+V5Hzrmtv53frL/uf+8/yz/7Nkcd+iZ3f9Cr+vr/XnBT+C6T/gqhqv/t++EThasQ3eb/9WVjse1Gy5Xf7LuQVfO/Gvoqp4agFsPvf/10LOY5f7kXYEOVC8ePnf0FUKf5hrvv9pEho5V/M/+OdWgG+pbrnIth6/RCeAD0PHBBvR26a+8wncEoMv1bkD3KjLQM2M/9QznvYlnNlxm6FLUcehhzZMA3vRNHPd1AF+7hnlzP65B5RbfpCotdMjgawCq/TlzHsB/ARB7hjl9xed96LhXQgf7G9Cx1g8CcD7b4wzP7P7nco0+Hz/HRdbXOZRSPw9dsjakPZUT9Vx9x/3QG4a8BkBPe5bkyW/3ofSGDUUAP6hp2v96gU/nhhp9upAJekTyoKZpb39hz+j6xg0Lzj8fQ+ntthahN7YEdM3vnwPwX4/KaBkG0+Mfhl5vdjyeOu6CvvAOU1SOxzOPz0CHGm7IcexxPc1QSn0ndLxiAXqYtQW9vOg3tac253wuv3cSeiMFAMhq39q8r+NxAw6ldy339f/7XHdWOvJxbLiOx/E4Hjfc+HaiQxyP43E8/oGMY8N1PI7H8bjhxrHheg6GUupBo4qkUurtSqlvyRhc6eqdVL58m+H1H1NKfUYptaN0ZdWzfdkf66H3v8rwfuNP8Rm+9w/UN6G2qZR6jVLqo0qpNaUre64ppX5PKTV4hWOvdH6aUuq2p/n8+/rHbB56PXroM151jee7+YwHXT72R5RSnzQ8m/uv9b3/UMdxVvFoxqehlyB9q44PQyfHGpUmfg06+/uPoJevvBy6CumLoJN5D49/CV2lleOqLcP6TP+34cqlMNc6fhx61+PfgF6eNAedlvI6pdRt2lPb2fEajePSVc7PD+A/4VD9a3/koT/LU7gsn3TFoZT6SQBf0DTtkuG1YQA/omnabz3NW98GnUD9BeiySMfjGcax4TqCoWlaFrqc8rfqSGia9rVDr53qnzfHF/vSNb+ulPolTS99MY7zV/iMp4y+x/Yh6EbwcBHx9YyfPHR+DymlLkGXrn4T9DbuxnGla7za+G3o5NJd6Mx4GZpeCvU1dQVt9yuMSwA+rJT6CgCbUuqX+uf228/wvnvI1VNK3X2N5/wPehyHitc5lFJvVroiaEMpdU5dudHDU0JFdVl19ReUrrpaVUp9Wulqo0NKV0wt9//284feG1VKfUTpiqRNpTdA+BulVATP0ThkFDhY9HslVYlrHb8AnQX//m/iM47s/Aze4L98tp/BoWnaF6Dz78LQ1UVeCeDlmqY9Lc/smGB8/ePYcF3HUEq9GsAnoCskvAn6YvzPuLLe15XGO6CTWH8cejnSK6Dzwj4FneT6vdCLZH9HKfU6w/v+BHq48gvQayb/FYAdXC4sJ862+awu7Orj1dCFD1eu8LdPKKW6SqmcUupP1RXklJVSs9DLdn5Su1zE/VyfH6DXVR4eP9U38lWl1APGwnTD+Vmhy/D8jqZpVxJovK7Rx78exGWFjYcAfEkpdRz+PcfjOFS8vvEe6LK436P1CXBKqQvQ68KuZdT67+3233sSesHuvyEGopR6EMA/ha5C8bn+++4E8Cuaphllow8LHHbxNDjT9Q6l1K3QlV7/UNO0nOFPJQD/EfqiLAO4HcCvAPgOpdTth479feiNOL74XJ2X4fw80GvwzuKpqgcfha4JloRecP4L0EPf12gGvX7oxfN26MXzz8U4CeDHNE27pJR6i6Zp71NK/Qn0ZhXH4zkcx4brGofS5XZfAuA3aLQAQNO0r12Hp/O5Q4x76ndRGgWapnWUUqsAjB7M1wH8gg454e8AnDOeQ/99r7nWa3mm0QeUPwXds/yFQ9/zOPRCdo6HlFL/D7oM0P8HvWAY/Yzli3Ht3uj1nJ8FurbUEIB/dLiKQdO0HzL890tKqb+CbuDegz6G1fcG/y30jeQ5Kd/SNO0p4L2maUno1RfH4zkcx6HitY8wACueqoCKq7x2pXFYC7z1NK8bweC3Qlem+CXoEtMJpdS/U0fQkFQpFYTu6WkA7tU0rfJM79E07THowPSL+5/hhq5C8T4ATaWUv5+5M0EHrf3qkL76dZyfgq6O8RoAb9Q07UrNQw6f3z70TK9RsfV3oW8CXzOcnw26Zr7/GsH4p/vOyW/m/cfj6cex4br2kYNe9HxYARVXee05G5qmZTRN+5eapo1AL/r+CHTv4bloGSajH359FrrM8N2apu0+w1uecqr932Ho6f33QjfK/BmDTq0oAHi22bP/Br0Z7ls0TXvwWZ4foKupvv7Q+X1//xwL6HuOx+NbcxyHitc4NL2zzcMAvk8p9R4DxvUy6PpXDz1P53ERwK8ovSXaTc/V5yq9tdnfQG9x9UpN09af4S3G974Iekj48f5LKVwGzo3j49CTEL8FXV/res/xt6GLG/6wpmnXrOapdJXYfwI9nOW4Dwe9WgD4ZehCfPdB19w6Ht+i49hwXd/4NegKmX+plPrv0PXo/z2uTFx8TobS24J9AXo/x2XoXt8/hS729znDcQ9AV1adfZZf9b+hZzl/GoC7b5A51khHUEr9KXSBwW9AB+pPQV/w2+gTNPuY0YNXuJYGgNRhT6lPHfnI02lCKaV+ETre9kcA1g6dX1brt1LrU0kWoIeBu9A3lZ+H7hXfxzdcieOllHo7gMaz8OS+qaGUOoHLevou6PLclNj+jKZptefzfG6EcWy4rmNomvZFpdR90I3VX0Jnnv90/+eoRgM6Q/3HoGfIutBB8+/XNO3ThuPM+Oae5z/u//7dK/ztHdAVRAEd5P5+6BlHF3Tj8L8BvEvTtPwV3vu0Q+ligMAzG//X93//Mzy1a9NHoEskA/q9+Z7+jw+6cf0ydGXWqzWjeKHHWwC8y/D/V+EyEXYKV+8c9A92HMva/AMb/QzoH0M3vt3D2ckX4HxeB53OMKNpWuKFPJerjX4i4ZXQPd9XP98e2fF46jgG5/9hjl/FlbvovBDjldDDxG9VoxWFfq++8EKfy/G4PI49rn9gQyl1My43I13XNO35bK56w42+t3Wb4aWL2jfXou14PAfj2HAdj+NxPG64cRwqHo/jcTxuuHFsuI7H8TgeN9w4NlzH43gcjxtuHDmP6y1veYtmsVhQLpdhtVqhaRrsdjuq1Sr29/cxMDCASCSCVquFRqMhPwMDA9A0Db1eD8FgEFtbW3A4HCgWi1haWkIikYDf70ej0YDf78f29jYGBgbgcDjQarWwv7+PUCiEXC4Hr9cLj8eDbFaXdPJ4PCgWiwiFQgCAWq0Gi8WCQCCATCYDs9mM8fFxnDt3Dh6PB+FwGMViEW63G7VaDVarFalUCmNjY2i1WrBarajX67BarXC73djc3ES73cbMzAyy2Sz29/cxOTmJUqmEQqEAv98PAOh2u/D7/ajVauj1enA4HNje3pa/ezwelEoleDweNJtNuFwu9Ho9VKtVdDod+P1+aJqGcrmMUCgEu92Ozc1NhMNhNJtN2O12WCwW7O/vw+VyYWBgADabDYVCAdPT01BKoVgsIhAIwGq1wufzIZfLwWazoVKpyHm4XC7s7+9jaGgInU4HOzs7GBsbg81mg8vlglIKNpsN9XoddrsdoVAIzWYTtVoNLpcLbrcbOzs7mJ6ehslkgqZpSKfTqFarGBwcRLPZBADY7XaYzWZks1kMDAygVqthamoKm5ubiEQiGBgYwMbGBjRNQzgcRr1eh9/vx+rqKpaWlpDJZBAIBGRetVotBAIB7OzsIBAIoFgsYmJiAtlsFrFYDPl8HgMDAzCbzUilUpicnITX60UqlUI2m8Wdd96Jv//7v0cgEMDw8DBOnz6NW2+9FW63G+VyGSaTvu/3ej10Oh20221YLBa51k6ng2q1iqGhIZw7dw7z8/PIZDKo1WpoNBoYHBxEMBhEJpPB3t4eAoEAer0eZmZmEI/H0ev14HQ6EY/H5Xr5vIrFIsxmM6xWK7a3t7GwsIBcLodUKoWRkREkEgl4PB44HA4kk0l4vV7Y7XZ0u100Gg04HA7k83m43W40Gg0opeQ5lMtlOBwO1Go1OJ1OFAoFeDweFAoF5HI5DA0NQdM05HI5BAIB5PN5OJ1OFItFeDwe7O/v4yMf+Yg6SrvyvHhc7XYbbrcbfr8fDocDjYZejD8xMQG32429vT3s7e3BbDbD7/cjGo2iWq3C5XKh2+0imUxicHAQHo8Hk5OT6HQ6sNvt0DQNDocDmUwGnU4HkUgE29vbcLlcCAQC2N3dRSgUQqFQwKVLlzA+Pg4AqFarCIVCaDQa6Ha7cLvdMJlM6HQ68Hq9cLlc2N3dxeTkJBwOhyyERqOBer2OTqeDUCiEdruNvb09tNttmEwmtNttbG1twWKxYHx8HKurusTT4OAgVlZWUKvVEI1G0e120W634ff7UalU0Ol04HK5kE6nMTY2BovFAqUU6vU6BgYGsLW1hYGBAdTrdaRSKbhcLmiahmaziVarhV6vh0ajgbNnzyIcDsNut6NSqcBut6NQKMDr9cLpdKLT6aBQKCAQCKBQKGBvbw82mw02mw2pVAq1Wg0mkwkjIyPy3BwOBzY3N2UCl8tlzM7OotvVBRnq9bpMeofDIUasWCzKppTJZOD3+5HP55HNZpFKpWA2mzEwMIBSqQSbzQaPx4NcLofd3V14vV4MDupS8uVyGb1eD9lsFisrK7BYLBgYGIDVahUjODQ0hFKpBKvVikajgVqtJj/7+/vwer3odrvw+XyIx+Nwu93I5XLw+Xxy/06cOIFUKoVkMon9/X34fD7s7+9jZmYGfr8f3W4XJ06cQKVSkfvQaDTQbrfRarVgNpvR7XbR7XYxOjqKer2OvT09YRuPxzE1NYXd3V3U63XMzs5idHRUjFKxWMTs7CzMZjOq1Sri8TharRby+TwqlQq63S6i0SjMZjPcbjesViuGh4eRzWZl8zh//jycTiecTieq1SrMZjNMJhOq1SqUUvD5fNjY2ECtVsPOzo6cd6FQkLb2PH+n0wmv1wulFBqNBjweD+r1OlqtlszfdDoNh8Mhx9tsNvh8PpjNZvR6R6+LeOSGy+12o16vi4FyOp2wWq0IhULY2NiAw+GA2+2G2+2GpmkoFApIJpPw+/3odDowm83weDyyS/FmK6WglILZbEY0GkWj0UAymcT4+DhqtRoKhQImJyfR6/VgsViwtLSEnZ0dRCIReDweMXrNZlOOoUfkcrng8Xiwu7sLl8uFRqOB/X09A04DAACVSgUOhwN7e3twOBzo9Xpwu90Ih8NYX19HKBRCOBzG/v4+7HY7bDYbGo0GXC6XeDeVSgW1Wk125lwuB6vVimw2i2q1ina7jenpaTQaDQQCAYTDYezt7SEYDELTNJjNZplACwsLaLfbsmPm83m0WroAhaZpcLvdcDqdCAaDcLlc8Hq9YhAnJyeRz+dhtVpx4cIFBINBWK1WtNttTE1NwWw2w2azwe/3Ix6Poy+xg2azCafTCaUUNE2DUgorKysYGxuD2+1GoVBAq9VCLpdDp9OB0+mE2WyG3W4/sHgymQwqlQrC4TAajQYuXbqEqakp1Go1uN1uuc5gMIharYZyuYx6vY6dnR14PB7xRCuVCoLBIOx2O6xWvc+H3W5Hq9VCt9uFy+VCpVJBq9VCqVRCuVzG3t4eCoWCbEA+nw82mw3nzp1Dr9eT91WrVcRiMTGGpVIJDocDJpMJ3W5XPBp6wUopdLtdmM1m7O3twW63w263Y2trC/V6Hfv7+3C73ej1emKwBwYGUC6XoWmaPGN64nt7e2g0GtA0DRcuXEAsFkMikUAwGITP58Pm5iYAwOFwSLTi8/lQKBRQLBYxODgIu92O4eFhdDodiWo8Ho/MmUqlAqfTiZ2dHbhcLsRiMVgsFuTzeUxOTspcDQaDCAQCMJlMMJvNskbS6TTcbvdRm5Wjp0P8yI/8iFav1wEANpsNe3t7soMNDAwgm83CYrHA4XCI8XC73eh0OqhUKnC5XKjVami1WggGgyiXy+h0OhgcHMTZs2fh9/sxMjICm82G7e1t9Ho9DAwMoFqtwmq1SvjW7XbR6XSglEK5XIbP50O32z3g3dCIZrNZOJ1OBAIB8faq1ap4MpzENpsNnU4HNpsN3W4XXq8X29vbsFgs6PV6CIfDaLVaqFar4g36/X7ZCQcGBtButzEwMIBms4lSqQSv14tWqwW32y2eDM83l8thcnISzWYTyWQSIyMjsticTicymYyEbpVKBT6fT8KZUCgkXoHL5UKr1YLf70exWEQwGESj0ZBJSIPocrlgtVrR6XRgMplgsVjQ6XTg8XiQz+fh9Xrh9/sPvM5zsdvt2N/fR6VSwfDwMMxmM/b39w8sWD6jgYEBWCwW8YBtNhsAoFgswuXSRV57vR6sViuKxSK8Xi9sNhusVivMZjMqlYqE8RMTE9ja2oLJZBKj3Gq1sLi4KBtRs9lEMBhEoVCA2WxGJBJBp9PB/v4+otEo9vb25LkyTM9msxgbG0OtVkMwGJTwu1arifeczWbh9/uhlEIymUQwGESpVEKv10Or1YLH44HZbAagwwQ8t1gshlKpBE3TUKvV4PV60el0xOPWNA35fF6eW6PRkOt2Op0wmUxoNpuyCXMzYfjq9XpRLpdlDdCJoCfabrflOXO+2e12lEolOJ1OudZms4lGoyHrzxjiWq1W7O3toV6vY3x8HO973/tu7FAxHo/LpKQRKZfL2N/fR7FYRL1el9Bld3cXFosFZrMZSinY7XbUajXY7XZ4vV7xOmw2G0qlEiYnJzE4OIjTp09jd3cXg4ODKBaLaLVa4h3U63WYzWZsbGyIxxGJRCTUIO7mdrtlx/F4PLDb7chms2K0rFYrms2mGB2GKcQ3uBO2221EIhHYbDb0ej1kMhnBxCwWHVK0WCxot9syUSqVCprNJgYHByVcM5lM4tXEYjFUq1VMT09jZ2cH9XodU1NT2N/fR6fTkcXDsI8emclkwt7eHkwmk3wHPT/ifQBk0fAziNm1223kcjnxOmlY0+k0IpEIer0e2u02SqUSTCaTPONarYZEIiHhSjqdRiKRQKvVknvt8/nkHvO9jUZDwt50Og2v14t2uw1N08RA2u122TjK5TJarZYs0nA4jK2tLQwODmJkZEQ2H3oUDOFphP1+v3iDnGPcZCwWC5xOJ/b29qCUwm233YZms3kgTOp0OrBarfB4PIIplUolmYv0eBgWm81m1Go1FItFaJommwzDtVKphEAggFKpJN/bbrfRbrdRq+l11sRUuVHa7XbkcrrorM1mk3XDeddut+XeEiflmmC4W6/XBXqo1+sYHBxEu92WyMNms6FWqyGfzyMQCMBisYhxHB0dhVIK1WpVNv5vi1Bxbm5OLDZB5YGBAfFGIpEIksmkgMcmkwm7u7solUpiuLrdroSH7XYbdrtdjE6328XLXvYyWZxLS0toNpuwWq0CoNL7KZfLWFlZgVIKmUxGdiK7XSeSE4vrdDool8twOp3I5/PQNE3CPHpxBC+Jt9AoERshIB0MBtHtdsXzKRaLMJlMGBwcRDabhdfrRa/Xg8lkQqvVknBjb29PQq+9vT2EQiHE43HEYjG4XC4kEgk4HA6YzeYDk7DdbiMQCGBjYwPVahWzs7OSsBgYGBDPYmRkBPv7+4IZRSIRSTC4XC4MDw+j2WzKb6fTCUAPj0dGRpDNZtFutzE8PIx2W5eTZ1gD6Pjl9vY2QqGQhPX0bDudDhKJBCwWC2ZnZ1EsFgHoXhUBaZ/Ph+3tbQkld3Z2sL+/D5PJhGw2i1arJThMKBSShU0vtlwuy0IdGhoS3GZ5eVmSOu12G0NDQ4hEIshms+IlplIpBINBtFotDA8Pi7GmV8lnZrPZYDab0W63MTIyImA5Q2d+Fj2d/f19AbJrtRq2trYknNzf34fVakWlUhEvi+Gn3W5HOBwWz8hqtcJut4snSFiF72m1WpIgofdNPLVaraJer8Pn86HT6Yhnmc1mZYPgRl2v12Xj8ng8mJ+fx+6uLtFmt9tRLBZl87Db7TKPn49x5N+STqfl5judTnFly+UygsEg1tfXZedg5tFisWBsbEyMh1IKTqcTpVIJ7XZb3Nter4d6vY6NjQ3xFLh7ApBFzQfHjA2zJ4VCQVxiAp/FYlGws2aziYGBATidTgEp6WH1ej0MDg4KVhIKhZBMJmGz2SSrOT09DYfDgXa7DY/HI0mDQqEAk8kk4bHL5YLNZhPPgd/LsNhut2N3dxcejwetVgvlchlDQ0Podrvi7XD3J6Zy6623IhgMCjbFe9LtdtFsNmVnDIfDkoCYmZlBvV5HtVpFNpuVe0AjEAwGYbFYUK/XMTY2Br/fj1KphGAwKB7e5uYmLBaLJAroFfLv9XodtVoNg4ODsFqtuHjxIgKBgHiamUwG1WoVpVIJLpdLQh2LxSKGcWBgACMjIxK+ENfa3d2F3++H0+nE4OAgpqenBV+0Wq1QSmFqakoWKO97sVhEJBKBw+GAzWZDKBSS35lMBhaLRUI6s9ks3phSCrVa7UCI1el04PP5ZNPivHM6neLl5fN5MTTE37hhlctlJBIJhEIhyZASakmn0+Id0ZNiOE9jTcPVbrdRqVTkXCuVimBo3W5Xkjc0nDSMTGpYLBYxkNws0um0OBgbGxsIBAJiXC0WC0wmk4SfRz2O3HDRstNIKKUEnC6Xy4Iv0PuggcrlcpIRIXjOhVgqlRCNRuWz6CLT4nMhcAIz/Nzf35eJTE+i0WjA7XYLSO5wOA4YPovFglQqJd6NpmmSiUokEmg2m7BYLIjH4xgeHhbsDtANY71eh81mQz6fx/7+vhifXC6HXq+HWq0mE4xGk6AyQ6NOp4Ph4WGUy2XBU5rNptA8uOAY1rZaLSQSCaGd0PMgmByLxVAul+H1emXROxwOwRvr9TpCoRA8Ho9kBOlxEkRnRsvpdEqI4XQ6MTQ0JIui2+0in8/DZrNhfX0d+/v7El7Qa+JG0uv1BD/kPaxUKvLciK0wkUBjyoXSbDbFe4tEImL0FhcXAVzOkNLAu1wuAdXpnZjNZoRCIQwODgoUMD4+LvScXq+HoaEh7O/vQymFbDYrn8NFWy6XkU6nMTw8jEwmI7CFMST2+XywWCxyT8vlsoSPHo8HPp8PgJ5RzWazknigEWm1WjJXNE2TZ8EopNFoCA2mVCrJWiQ84XQ60Wq1BCOz2+3Y2dmRcJEbltfrRb1eR6VSgclkgs1mQyAQQLlcxujoqHiYpDb1ej24XC5JXh3lOHLDRU+LqfJut4tqtSrYC0NG0gu2t7cxPj6OZrOJSCQiD1PTNOzs7AhlYH19XTJwxCy4OxGALhaLKBaLsNlsKJfLmJiYkExIs9mEx+ORnZCZK2IqDEu5yxeLRXGtQ6GQeB00aC6XCzs7O0ilUtjZ2ZGJWa3qDZYdDgeGh4exvr6OQCAAAIhEIqhUKhgaGkI6nRbeVCAQQL1eh8vlEq4ZPR4C2JzwnMTM3jJrx12fyQdN0+Dz+YQu4PF4JFx65JFHxGjY7XZJIHQ6HfF0mIafnZ1FJBKRLFwymUS1WkWv10MqlUK1WoXH4xFgnOccDAbFK8nlcpKNzWQysvAYtjJryFCQ581Fce7cOTgcDni9XphMJuF4MVtdr9dRKBRQKBSQz+dRq9UwPj4unkEsFhOaSCwWg9VqRSSit6h0u93I5/MCpLfbbYTDYTkvfke1WpXnxc2FdJdOp4N0Oi0bDzecVqsFi8WCSqWCSqUiuFaj0YDNZkMul8Pe3h6azaZQQ4iBRaNR7O/vY3d3F4VCQTxublT0wqxWK6LRKLxeL8xmM+r1umBzNJT7+/totVpwOBwol8uIx+OSaKrVarImaawsFousRX4XQ2dy6ZhlLBQKklw5ynHkhos7rqZp2N/fl12tWq0K+Y0p8HA4jNHRUZRKJdkZ6No2Gg2MjIzA7XYjnU7D4/HIJONEdzgc8Pl8gqPw4TJULJVKKBaL2NvbExIq8QZiZADE6xgcHES9Xkc0GpWY32KxSEaRaWtyuBwOB0ZGRjA6OiqfwQXA8/B4PAAgmVKHwyE7NDk7SikJE7LZLKxWK1qtluzepVIJCwsLSCaTgolkMhkUCgXJDtVqNfHMAoGA4DRms/kAJUEphZmZGXS7XdRqNfEQyREjHUXTNAmZ2u02JicnxUv2+XzY3d0VA8NwPhwOI5VKHeAL+f1+uR4aWNI5zGYzdnd30el0ZKHl83m0223Mzc2JgZmamhKi58DAAHK5nMACFotFwqNQKASfz4fh4WHJohHrI3hPOIL3pdfrIRKJoFwuC/xATxm4DC+EQiHxXAAIxkNveXJyEpVKRcB7zoFWqyWhHz05fh8TRYRG7HY7xsfHkcvlcPr0aUSjUdjtdsFPGWnwvL1er3C04vG40BkY0mqahkajAa/XC0CHDXhPmYUNhUJYXl6WzDwpQ1xTe3t7EkJ2u114PB6kUinZtJh4O+px5IbL7/cjmUzC7XbLwgN045DL5dButyV2z2QykrIOBAJIJBJot9ti7JgNMeICBLqVUrJglVJiYLgrM8VPgun+/j7Gx8cl5b6/vy+YE9O9hUIBPp8P6+vrQsKjB0IeEsFocme63a5kecj10TRNgHGy0j0ejxBA+Z0AJHx1OBzw+/0YGBgQQJiAdCgUwqVLl7C4uCgUgaGhIVlc/B4SW3d3d5FOp7GwsIBqtYpwOIxEIiHgcjabFW4XAMFaAoHAARqDyWQSNnyhUMDU1BSKxaKE4vl8HsFgEPl8Ho1GQ/g+xAUZvjFkYcjNTJ3ZbJasWTAYRL1eh9frxfDwMFZWVoQoybBpfHxcQj0jN49McKbyc7mceBHE9rjYaby5MElDMZlMB44tl8tifAh4k0rBTSUWiwmWub+/j6mpKSQSCfGeNU0TL5QYVrVaRSaTkY2B8zadTiOfz+PChQvCqKfnWywWBZznawT+R0ZGJLPodrsFFyaWajKZhK/HZ80MZzqdRrfbxfDwsIT1BOqZKQyHwwAghORGo4HR0VFh9pOgetTjyHlc73znOzXG2cRxTCYT7HY7fD4fisWiAKeFQgEWi0U8LN4MEj15kxl+cPcnkE2wnAsX0DNdAA7wXhg6NZtNhEIhwR6IpbEciNwqlspwIWqahkwmg1AohGKxKJywYrEoKfZGoyF4HflG5IoFAgHkcjkBQJVS4n0xK0PDUy6XcdNNNyGZTEo5DgHlcDgsvCmGAAynWFmwtLSE9fV1DAwMwG63y31keMNJTnCbXibDXyZAaNT9fj82NjZkgfI6Ga7Ts2ZoSRoJ6SH02vgdW1tbGBsbEwyLISYTBwx/CbAzo8fyIyZXTCaTgOfMYJJ/Rv6T2+2WUI0bBRc9Q6tWqyX4DkMsJoPC4TAymYwYq3w+D5/PJ6EujQ9DQG7YxJ94XdwsOD8Zsvn9fmQyGTl/zoGBgQHs7e1JhMHEAb3qRCIheB03V0IozNLTcNObNZvNKBaLQqgF9KxuoVCQOcDXGH0Ui0VUq1WhQ9DL5bzka+VyGR/96EdvbB4X43Rm34wg4s7OjmQxuHBZgsNdnRgZ8ah2uy2ZL6aemZre2NgQo0c2e7vdlrq5aDSKbDYrYK7L5YLZbEahUJCdld4RcRgy+gEIBSKfz8NkMmFnZwd2u10Ii2R1s/yBpRrMAJEDk8/nhWVP9jaxsv39fbkf5AFtbm5KqMwQleeys7MjdAKGowAkacBqBS4o4la8T/RIm82m0AS4sRSLRfFKWIvYaDQwNTUlxiOfz4uxIBjs8XiEQJzNZhGJRFCr1dBsNpFKpZ5Ce6A3NzAwAJ/Ph2azCZ/Ph4GBAczPzyMajYpnq2kavF4v9vb2JBSjl0DaB/E8cr4IiHMeMpFBEH9oaEgoNPTu6dXQ2BlxSd5f1pl2Oh1kMhmpJdzc3BTKD9+3s7MjyRqGYGazWTYxzlN6dCxlo6dDgxsOh1EqlSRCWF5elk3YWF9qMpkkfGMtJgDJiAN6NLS/v49CoYB0Wm8NyppewjqkwhQKeuvPXq8n4TsdDcIo5CEyOXWU48gNl9F19Pl80DRNSIpMz5LDks1mZSLzAZJcyZ3a5/OJEcrn8wKcc3ESFI9EIlITR45VoVDA6OiosLUBnVfFxEGv15M0fDQaFZoEXXwuSBpZLiZOTnKJms0mqtUqGo0G1tbW4Pf7xRBwp2O4wUnKnZ2ZGS4ws9ksngPrCcPhsNAJRkZGhLFM/IjeFj1RAu3MfDFLRM+VtYo8PzLoaWiJ/w0PDyOXyyGfz8NiseCxxx7D4uIiWq0WstmsLAp6yJ1ORxYguUysPmg2m1KTR/4YvZDh4WGEQiEJjxhuDw8PS/p/aGhIvKKJiQnB/gKBAKLRqJCFuYnQwHFks1nBRnu9nuCBNBCsZmB4TrZ6uVyWzbher0tmMRaLSajpdDqxurqK/f19yTIyQdXtdmW+tdttpFIphMNhhMNhKXrmpsIIYmVlRV+sJhMKhQIikQj29vaws7MjRpeJDBJPe70eAoGAUGv4Hl5PpVIRRn80GkUsFhPqidPplOqWdrstmW4W87tcLpn75GYyOaaUEuN5lOPIDRfxHqZoaTD44Ov1OmKxGHZ3dzE/Py9ZM2aAGD71ej0pgbHZbMIp0TTtAM+KhoqeB8t6WIRdr9dRLpeF5UwwmUxx7oDEmnZ3dzEwMCDeUa/Xw/j4uJBS6Ykwk0mlB+I6Y2NjsjAJZHPHp1FkZUGj0cDQ0BBqtRqy2ax4VpxsLGAl0N1sNlEoFDA8PHwAJCbGR68GgBhDegoABFthRnFpaQlra2timJLJpKhWWK1WZDIZTExMCC7l9/tx8eJFyVKSxW4kvAKQVL+xKoD0Ey4w8ow4qB7B7KIxFAIgSQeHwyHYyuzsrBhAZvRY5UAaDOtiGQZ7vV4xmOSzuVwuuFwuAfl5X9PpNAKBgBhPLlIWszscDoEWSGng86WxIrxBLzkcDiObzYrRItZWKpVQqVQQCARkrrB6gPPX7/djb29PqDnEscido+EplUqixGHMFvI3uYEUNDB67qwmUUqJYgopFxMTEwAgsAChEm7gRzmO3HBxl6WRYQqfBoikt7m5OWxubgo2xdouZn2YFeLEZ0hJ/IyfTy+MBoLFzz6fT1xcehjhcBhDQ0NoNBqIRqNy4xna+Hw+zM/PA4AYKCoVsI6NShc8RwKg9MposFnYe/HiRYyMjEgGkZiW1+tFMBgUeR6WNjHLtra2JtQAhrKUgVldXRUVDHpXPp8P1WpVJhGLqkkrINubnolSCt/4xjdw2223IRaLSW0e6STcdLa2toT8yxIaqmKwSDwej0uqnh4NjWi73RbVDDK7yWkjVkYKTDgcFqNOA8IQi16Fz+dDMBjE2bNnZd4AEBCbHrrP55OkQDablQoJYqR8jqzv5DxiVQBDY6pz8Ps5hxlOVyoVwaH4LAYGBgTIJl46NDQk5U2BQECydEYs0QhD5HI5bG1tSc0uNxfiYVxrLMzn/GIGNBQKIZ1OS0UCGf2pVEpoSvTwyZfk68YKksXFRfkbkyTNZlNoQsRij3ocOTj/tre9TaOx2NzcxOzsrJAA19fXhdDHkgRmhJiG39zclNop7pyhUEhCOu4YXGjGkham95nxo+dGDSSGlaQuMLThsSTOElOZm5sTwJxhLDObjO1JpiS2Qo+ANYyUprFYLFITyWJbnovFYsHu7i7Gx8dRrVbFCDGrBeg7OfXGRkZGUCqVkMlksLCwgK2tLVitVkxOTkpZDz02Y2aPnsXu7i4mJibEG2WWjjstpWu46Pj+TCZzAMjtdrtS5Ozz+YQewBCYAC7D7Vwuh5MnT4pX1+l0xKPhoqRxYuay2+0KQdTr9Qr+aExK8B4xIUNPjveY4LRxMPNIsievnzQJALKxNZtNCc9pCJxOp2RjGWrTC2ONKGEJbmacmwydXS4X9vb2MDo6ilQqJSE/DRM3QM5JAJKEMM5ZY3hXr9elpInPnJsOWfh8TvF4HBMTE5IltdvtCAQCSKVSknxgBYfT6cTy8jLC4bBAKYFAQPCwD37wgzc2OM8dv9vtYnZ2Fqurq1Jdz98DAwMHpGyY6aKMCItRe72eEFVZBsJJGI1GBRhXSgl/iFlCYjl8sMRyGAY1m01JJXMnpPfHhbyzs4NcLicTiYXGzLRwwTDeZ1EtFwnd+rGxMczOzgrA6XQ6EY1GEQwGxSDSaBHLYZholFFhuc3Ozo5UIbDIOBgMSv0Zs4/VahW5XA61Wk1Ir/F4XPCPdruNaDQqIDwxMpfLJYsXgOAsgUAAoVAImqYJ5ra1tSUEWoZExL1YVM+MKDO0LLyPxWLCdaJ3SaPOKgmSZIm50BA1m02pZaSXwkwxw1R6RMbsIa87HA5LKEtDDOieNENJZnM5N8xms8i4cPGGw2GpsSSWS++Lmxg3XtYNms1mTE5OotVqCW+Lc4FAOjdEEm+Nemg0QiQzk6XPbOGZM2eEKsP6wlQqJUkmzg164FwP7XZbQliLxSKF741GA7lcDouLi+KRGdU4WFJ3lOPIDRd3r5WVFUlrkz1NnIiERTmp/sIkUEiWPTW5OGnonRmxIH6e1+sVzGBiYuLA+/L5vOxwhUIB2WxWQH7Ko3BysMTB5XIJ+M3aNDKQKedCoJ0ZQ76fKXCSPHO5HFZXV2G1WjE6OipZR7r/LBRmzaAxjU02PMMl7vAMoyl7w5o+m80mC3poaAihUEiM+dDQEIaGhoTVzdCcMjNcwBQTpHSJx+MRbhsXNetFWZLFZAAzusRFqGawu7srxEd6law1ZIhDCgAxRiZIGFKNjo6K90sciRlEh8Mh6qvkKdFIMrtNAiyvizw24lM0qIODg4IDMiNOrTh6xyxg3trawsTEBNLptIRazWYTmUwGxWIRzWZTpHlIzSGVhplBVgGQgE1BP2qs0Xslp433i+KZ4+PjolYxMDCAubk5eQaxWEyw1mg0ikqlIsaTn5VMJiWsZ5RCtr6xXpTZYCpwpNPp502P68gNF72Oubk5rK2tST0dFS5pIIgX0aLbbDbE43Ekk0lhkTP2JohKbhSVLFmWQQ+DwG6tVsP09LRgUyMjI7IoXS6XkB1jsRhWVlbk+wjQMysJQNx3j8cj4RO9CmJb3M0BCLZFRQkqdnJBMfvY6/WE5EqPc2ZmRngypH3Mzs6KGKPb7RaQmjQDcnpoaBg2GNnrDMW4AJxOp4C6JG0ynKMUr1ESG9DxlO3tbSnxsFgsAigzY8ZQqVgsymZB7tzIyAjy+bx4ICTakmnudrvF0FI1gXJBnFe5XE7exwXIjYPgN0Mo47OgYeIGwHpNepqsVaXmGIHqVColIXmj0ZAEQyQSEY+QTHtmmpmZJV7HhAw3P4bS1Pniouc8YnKJnLZYLCZZa5atcWOjegmrTlh5QFik3W7j0UcflesiRsX5QFyVUQ6pMOQckqtHTI/3n8Rxv98vdb9HPZ4Xw8XJ4fP5xFWnTE2xr1NNUTuGApwQkUhEiJ+siSNXiCEYcS2GAOQUhUIhWXCpVEqYwMxCZTIZmYhk+A8ODgqfi4bJmA3iBOW/aYiCwaCkhRlKApc9Tk40cr24a6VSKWHF05NgNT69GJNJV+V0uVzIZDLI5XJSAD00NITl5WXcfPPNQsK0WCxSacDkBwuxib3R8NIDHBkZEc/QarWKMWIoFQwGAUCE9TRNE3WAVColz4D0BWbAWI7DyWzE/yYmJg5ocXERklKQz+cPCEfS8JBSwmwxtbh4DKkqLKOhESUm2m63RS0UgHj7zIhyhEIhgSKonOp0OjEyMiIGjsYnnU4LcM57US6XhQVPKITEVZ4LAJEOJ0WGXiZraBli0hhFIhGBVZgoASBh6f7+PkZHR7G6uipJhWw2i2aziZmZGdmcaOiYRCH+SNoFy358Pp94wgwbAYhOF6MKykLR8B/lOHLDRQCafBLyRyiwlkwmhf9DhQK64ASAaZC4IxNPaLVasngImnKX4C6cy+WkCDSfzyMSiUgygNIm1IxiZoWTh0WrzLzRVWcZBeu/9vb2sLm5iVarhZ2dHXkvS4DoQTLcJeCdy+UwPz8vnCuev8lkwtjYmBhnv9+Pzc1NyZZSmUApJbQQapUnk0mpnSTB08jnomRKOp1GOBwWj4ucN24m6XQa7XZbPGOSM0mMZa0psSoqf9LrKBQKB3beyclJMabk72WzWYTD4QMhEa+x0WggFoshEolI6RTPVSklqX2eczweFx4VazYpREjQn0A+QyZAJ0hzozKeLwuhk8mkGODBwUGRnSE8wLCblBR69aReGDfgeDwunKrd3V3JWnKz9fv9EmqT0En9K9JkKI9M48GkFqBTK/gdZPXPzMzINdIb5AbGWl6SvBlOFgoF2aiYWGFlgxG2oCQSy8NYy/htgXExdmf2jA0ryNCemZlBLpcT1QLyQBjqDQ4OiidCY0DPze/3SxhFI8HdnN4ZMzX5fF6KpUluNU5kVtczu0hFA5IyyWanVhNd+FarhYmJCcFQyNviQqQoHDlNRmyO7Hq6/vTCOp0Oksmk7KDxeFzIopVKRZjkNOSDg4PI5/O45ZZbRFaGrGiGJNRk4sQkrkI8j/eKGVliGYVCQXbVYl9dlp+fSqVE/pjEx+3tbQAQ75MbEBUSWCjfaDQQCoUkJGJ9It9LjhFpJ6S3kOpBvhUB8PHxcZGPIejP50tVBKob8DWGZwTdWf5DvTLiaKzPJC+PuCppHIwqSEbNZDLiSRrrERkeM3PLe0TvidLbNHwUCaQBDYfDUEpJLSHLngAdcmEjFGN50fLysmQ0mXUlzaZUKgnXi4kOZvNJsmU4yuLqVqsl7H1mgpnBpAEdGho6arNy9IaLch3cIQg4e71exONxlMtl4dTQanPHNaauyRvhrhMOhyUtzHo1aiaxzIUZJQLeJD5aLBYJn6jvzcHSkYGBARGDY+hDlVFiJmazGcPDw4jH4yK5S0+H7jYLsrlLUaSNOMHZs2clDGTJDDXCZmZmUKlUMDk5KRORodnu7q6QZwn2njlzRqoCWHTMFDmZ6wzbaFCNIS5xIYKu/O12u3H27FkJWUkSBvTQL5fLyfcQMM/lcpLBNGZ7yScjXunxeDA4OCjeBcMp6oeRvc5z5wbGZ0jAnYkbEnDJETMW5jNBQh00Yjv03KkjRu4YsToaIaWU9A3gZtdsNrG9vS1eGDsEcbM1klsLhYKoShAX5Rz1eDyS1aYh8Pv9Ej7PzMxga2tL7jlJ1yaTCePj40JWZVaWvCrSFaLR6IEidMIBLEYnTkwNMb+hI1e320UkEhHF2L29PREhIN2Dz4ye91GPIzdc9Ejo4prNZgGmFxYW5DgjP4iscz5s6mQTT2LWiu4609CM9Zn9oUdCr4tFzwRHG42GcGuIozF0rVarslsaZXco78vOQ+w5x+QBPYVarSagM0FtY20lEwvj4+Oyexm5X72e3vmFKXdmv0iEHRsbk4XP+zs8PIxqtYpUKiUhAaCHE5y0/D8nG1n6LMDmQmLYxi47ZHgzG0ggvtvtIhaLSShNIJjp91arhaWlJQnnuQFx4XEDAoClpSU5P84TGvlQKCSJHNZdGjXpjVQBIzeRxd1c5EwS8FppmGgAWZTcaDREBomKEaT25HI5afVFwiZxPyYjut2uFDe73W7JcpOqMTIyIiRW0l5o4J1Op2z2nJesJSSFiIa41WpJRrTZ1JuoAJAEk5EWwiw0w1CqWzBaYcjf6XREImd0dFTezwSPcRNktpjeV7fbPYAfHtU4csNFyoDJZBK5XRoQyroQ0CM2w6wPQVc27uRk9/l8kronBYJhEDMjvV7vKbK7DEEJrtJ1JjOb6hMAxENkSp67cL1ex8LCgoQwAARs5fXSs2PMr5SSpgNMpxvxOlJEAAjZFoBgQSaTSTquUKsrl8sJQG0UIWS5CTOBAJBMJgU7JJGVoDLDXxpj7sYARKxwc3MTxWIR4+PjUipFNQOn04l0Oo1SqSRyKZ1OR3TbaWwIdDNZQeyxXq9jfn5e7gVrM2lIaXSJMxGTYfUAiZj0mlmuxeyWsdAcgPQzJH+J58vCfKUUwuHwAVA+lUrJpsNkBjdHJl0mJiZk/pCyMTs7i0qlgrNnzwq5emBgQDBHpRS8Xi+sVisSiQTS6bR49cy+M1Qj14z9Bxiu22w22XAB4PbbbxfaCDcWUhtYvM5kUSaTwfr6usxdihKS2sAsPUNQEoiJqdKwMmRliP98jCP/FiPLudVqHSDw0RgwRNI0TVi+lJXhw6YHxhvHnZASG5SdYWaLTHWy8Jn6d7vd2N7ellIPLuRyuSxYDlnRFosFIyMjSCaT8hCdTidWVlakzq9UKkk3ZvLUEokEBgcHBWfpdDqSaqeBImeGWTdmE41ihZubm5JNslgsB5p3MrPEcJFGnyEogViGT8TeBgcHsbe3J5ON3h+9JaPuPsN2as2Tfa1pGubm5sSgMCxhrSY7d3PRMW1O75fJD2JWrCekJ03PhYaChoCyzsSQKGLHjQqA0AYAHMiA8b4T62FyhR43VQ5Yj8pwkp/PYulOpyPFzczysX6QYTvn7fb2tvQH2N3dhclkEm+XlAVGDjabDaOjo7IZEi6gFz40NCReFo00i8QBCH7LTjws1VJKCdE0EomIKKDP55NET6/XkwJpSugY61+j0SjW19fFCzYqaRj10biuo9HoUZuV5wecX19fl87J3O2oIupw6BrvvFguaBJQSb6jYXM4HLIz0nWncaCGETGtQqEg9AeGBgwTCLgT4yL3K5FIIBKJyEPhNXDnInubjRQYZjLEJV5A95sZVKa7CeKzRIhpZmJuxOhmZ2elDtBYosM0ubEygF25KZnDLuDEGjjZOUFZlcAJvLOzI54rsRXK0AQCAVy8ePFASNXr9ZBOp7G/vy+aUwyvKIHNULnb7eKmm26SBUoch3SS4eFhCTuJLbrdbqRSKbjdbgwODsqmZTLpUt9er1ewJC5+YpEsPWEyhSx98vn8fVlqJg74POh1G5MonG/04ni/WdycyWRQLpfFAyXYrZSS7DX5XOzJSEyXvC7qmpFQajabJZNLQ0WjTO0142/WYlI3niGh8f3Dw8MHDI3VapVrYu+HcDiMarUq92tra0vwvng8Lkm17e1tIe6SDEt+Gmkq3xYKqACErUsXk4RTZqJMJpPcSGbXCEQTqCQTnUoJAAQ/AiAZKAACMPp8PmGUM4NGnaahoSEp96Enw5Q0FStpjHju5APRMzKGfwxl+B4aO2Oan4x4StAwm0rPhLLJw8PD2NraOlB6RJ4NG3ewPIaeAT0ts9l8QIGDlIpqtSreGo07AOHTMSvERcB7mUqlMDk5KYXIDJGMooRMltRqNeHYATogTeoFSbWtlt7yi14S23VxEZLES2/LbDYLXECvktfFRrmcA/QgWHZis9mEIGyUDWIigQaB2lulUkkSLCSCMutGuIMGlYuXnh/rXrnJpFIp6dbudDol0xwKhZBKpQ4UUVN/nqGmkZhKVQl6+MSYCBsQOqAAIB2BgYEBKYvj5ppIJDA5OSmGhjWV3OS8Xi/Gx8ext7cnsA6x01wuh3q9juHhYSilpHcnP4ecSWNzjqMcR264xsfHBQMi65xGgOA6U9WczLyx7XZb1CmNmbFWqyULkRgQAOGUsDMLAAkFudAYyjALxUxJpVIRzhgnAgFPlnJwEhPUJfucRbKzs7My+Sh7zDC3VtObpAIQThk9Sr/fLwaRVA7qmROrGBkZAQDcdNNNKBQK2NjYEA0o4LJAHAm3vI5uV+/RSAPK8JL4DgDJiLKYmxSQTqcjxxuNJD1lhtYs0fL5fHC73fB4PNLmnRsI7wcXKxMNbrcboVBI6AdcdGwXX6lUsLe3B+Byz0Tee6P8MgDxrJ1OvREsa1K5GTF02tzcRDqdlnnncrkEtwIgIDeJpDR6fK6pVArZbFbKr7a3t8V7ByALnl41NyXWh5JmQ5I0BS1J7zAqvjKjzsYqxEaZ5GDN6tjYmGjnczOlAWa4HQgEpOEMExmHN2JCE0zc8J7TE+f8J4HZarUimUxibW1N5LS/LQiolHdhaELvgTs+dzKyd8lRYVqbuvBer1fS6L1eD5OTk/K5XAD05AqFgqSSjTVlVqtVShcymYy42cz4ERjnTs6dOxgMHuCTGRnYzCaxBIJtmlg8Tq+KISaZ3LFYTJjW5CRxoTGDSNde0zSpMHjkkUdEXTORSAgxk9dPg9Lr9RCPx+F0OhGLxYSYyAwms1Zs+MHEBw0fcSJ6PdwImA1lATelhOLxONxut1xPoVCQxURaCw0Rib9cKMDlrPLAwIBcA8uB2OWG9IzDagjM2tJLNIYqtVpN8DFueJOTk9LQhMfz/rEsiSRfeiP7+/siK+N0OjE8PCwhI2teK5UK9vf3sbe3B7vdLkaYUkXsUEVcFoB4uqwWIHveYrFga2vrAAePEtvkvo2Njcnmx74NxCqNxjscDgtOaLVaMTU1Jckwri+qOly6dEnC1mg0KjWJxsYtTAgRn6bAgcViQSaTkY3mKMfzklVkypR1W0xxM6vl9Xphs9mwsLCAUqkkZTMk5dEzYrkEmxesrKwgEomg0WiIAie9BNIJuCBZ2kDuF1PzDE3oXfl8PukizZpKLlaed6fTQT6fx/j4uHgLTBmTw1OtVoVKwdIbepnMzgAQMUDSEABIypqlT0NDQzCbdfld0icIqPv7nYdJruQip3AijQu5YPV6Xbyr3d1dqQ1lOlzTNMTjccFWWGhMD42ZqnA4LBIrsVgMIyMjiMfjaDQaGBsbEz4Xu+1MTU2h3W5jamoKTqfef9FisWB0dFSAenqFxtKvfD4vmmj0ggE9DC6VSrKIiYEZRz6fF++TuB8pCbznAKSUJZ1OS5hGVVRuTsyGMwO5s7Mjx3KjJUZGg0gKDz1zElxtNhvC4bBsqDRYTAyQD0VCLq+LqhuNRkPY9zyW0j/AZTpJLpdDp9MRg8pkCOtJW60WNjY2pBluLpfD0tKSQAGJREI80UgkIgaXZUTValXmGGlAz0eBNfA8GC4+bJvNJnV2fCAE07PZrMjGUMP70qVLsrvQ3WUNGnGAmZkZSdsyxCTwy/exNIjZzHA4jHQ6jVAoJJrxxjrJVColzHGn04lMJiPnT+0kYgOZTAZbW1uSbSHo7fV6MTIyIgoPgUBAjGMikZASD4bC4+Pj8ncuol6vJwt/Z2dHiKVMOXNRsMyFPKpgMCghNasACBzbbLqMMXdF0hVI86Da6/T0tDDi6e1WKhXhU/Fz6aFSjO7lL385QqEQyuWyeBuBQACNRuPAc7JarVJmxcJuegqsDGCZFetRGdIxBCIgzznG+cQEASWJSVgdGBiA2WxGPB4XPInwA9n3JNfyvrLsib0judi5+OmdkxbCUjKG5Kw5HB0dlbnL0JX0E6qN8t4yi2403pQbWllZgcfjwW233SalU8RWOx29aTCz5wTZqWPPUNHf7xxFkUVuINyA6EXt7e3B5/MJYZbPtFKpSPE2W7AZuzlRJPGox5ELCf7oj/6oRs4KXXJOGNac0aiw3yK5MBcuXBClyFarJWL8nDjskk3ODjEvxv/EcAhQMgtJ3gtDvkZD1xPnxKP3RLqG1+vF9va24DckyNKT5GIiZsHSB5ZKMHxiBX4ikTiAzRlJqzTMxJRorGgUeU0E0UlnyGazmJubEw+EjHe6/TRYJpMJc3Nzkran1hfJjMSwAB20jsVi0miBnCzKnDBsIK7E+0Wgnt8zPDwsgDbVZkkjIZGU58rzYL2dUYuM10/KBsNO/p+JGGqcEQsiDkRyJ/HUcrksGmlGIUBK37DLEz1tY+cbGnWjcinL1LiJ5XI5IQUTwPZ6vQLOM5NJbJNJKV4n61CZlGJHHm6elBuKRCLCi6OxJ7zALGsymRRDT02uF73oRdjc3JQuPcFgUDAvQM9KMhnBemMWv9P4Mdzf3d2F2+3GxMQE9vb28J73vOfGFhJkSERSJaDfOGabSCqkC97t6m3bd3d3EY1GhSjocrlEII10Bz50Gi+6+Eop4fBQMpfKAgwJ6H2wjIjeCr+P4RhxKCpYkO/FDBMBe4KqxEcGBweFTc+FxFCOIRmNilEzivpHTNMbi7yNEsMEpmlYjU0wSMmgwaP3xPIoeokkXeZyOaysrIg2PvEKZj5ZKqNpeuuxarWKgYEBuXZilyaTCdFoFDab7UDigeA9lQ0IVBMDZBjN505+Fj1cFu6S5kDpZYaZ1Fvn/aBHSPyrUCjI/CB3i+F4IBCQhUnSKY066/f4OfToyL8zEohZtE6eE8NXcufIY2OIymfMlmPMENIAcN7FYjHpw7i+vo5utytNQ8rlMk6ePAkqDJMUSi/bGBkMDQ1JAT5D9HPnzh2AFMh55Jrg+1m4zuwt8VsKgNpsNkxMTGBychIrKytSr3qU48gNl7Guj4W9BFwXFhaknotuM4tRaYxIbmM6mVke7pD0LLgz0COiNzQ+Po7h4WF5AHyP3++X7svc1ahlxXOm+0tlBhoCk8kkzPTDFf7MvrCJBQFe0jy4azIzQ4NOQ0IjzlCVrG16naR2WCwWSRokEglhRxNvI7ZDbX3W77FMg14wDU4kEkG325VdPpPJSCs3TmjKZbfbbZmcBL65gbDuENATL1RdYOdwFs4Devg3PT2NwcFBpFIpjI2NwefzIZFISCjFxU3vleUzACScHh0dFToDtatoqNrttvDSmHSgN2aU6EkmkyiXy7LRkWxMUifbzDWbTezs7AhpmeKOxPjC4bCw8ZlJpZYYEyHUu6KBmJubE+yXGxCTOXwOLHfjvarVakJ8ZrKGnKxqtQp/X1bIatU7IpEuwTnMTCPxKW5ETJoQO2XfAT6Lra0tzMzMIB6PiyIxGfgbGxvw+XyIx+NHbVaO3nCxyQUzEmzA6nA4ZIJyl+KkpOHp9XriBnPBsFaPqqGcGIFAQB4wKQqUTuFORKVKeg78PNIwCNzSY1tdXZUQhqEFAGE9s08jw13yo1juQvyDlAW/3494PC48J4KrvB6mxUljIDbRbDalnIa8IYZEDBFo7Iw9F430CILTnJi8ZqPBZLhCiR5OVt5Pj8cjVQTsScgsLcM9QO8hSGZ9MBgUZQem+XkeLHfJZDIIh8O4dOmShLVjY2MS2jIUJm/Ibrdje3sbpVJJiKWknpDoS68DgGx2xL/YVYdJGz4nbhoMFfP5vCh6Urve7XaLLj7LvsbGxmQDYxKH+BTVMCgRRDwV0PW+uEZKpZIA5UwIMbkQjUZlYycHENCjGM5z4zwGINdFCIPZdm7O1Wr1QBE7M6MkHnOO7+7uih5bqVRCLBY7IBZZLBYRDAYFx83n83J+RzmO3HDFYjFsbm4KAM1whPiKzWYTraStrS2x/PQ2SE3gxAAgXkW5XBaBQYZ+BBfJ+qU8iMViEc+Ln2+z2SStS6Inmc5ms1kWGndacoaYUSMmtrGxIWA8QWiWirBhKtneRu+JoC6loUneoy4SJyLry3iOZIizZInaVFxQAATPMJY7kdPF7CJDW1YZMCMWDoexuLgooDG5dJyUJMOS/AhAMkwMI1KplHgWRm/V5/Ph/PnzUEqJJNHAwABcLpeE7gyDAoGAJBIGBwcRj8dlDhAvSiQS4k0S+9za2hIuICViGP5xThqVOIir8v7ynlJB15hFpNFhmzeW0KRSKSwsLAhPi1nheDyOWq0mXYMKhYLgQEz4mEwmLC0tYXJyEqVSScD2cDgsmy8pEoQlaLR4/lTYHRwchNfrFRI11YITiYTcf1JXmBShsqvT6RSeGCkYDocDU1NTWFtbk8oM3lPWBtOBcDqdcLvd0jT3KMeRG66dnR2MjY1JZ2mm1LkLUPKFGBNF+qmVxBtIgiOBQGol0Q2nh0EBOpb20JMhNlSpVESSg22hiKUAkFIWkhUZ6gGQrA+/k14QDRlLVIhZlUolqZfM5/MAIBy2yclJ2WkXFhZkR6b3Q9yHChUsVyLG4XA4sL29jbGxMWxvbwvgTaNHHhgAKc+g1hR14JlxJRjearVEomZ1dRXtdlsAeWI2BOppzKkIysVPT5F4FMNWY/jOOkluTn6/H9vb2yLVzMxqtVrF6OgohoeHsbe3h0gkcgCIZ68A4oeU6olGozh79qwYCmaXSTQlbufz+QTvO3funPQ3YGkOwXpjN2gWzxs3g2AwKOETQ0UaDKfTKZAIk0e9Xg+jo6NSJ8lwq9lsiuEhDsYohdUMpC34fL4DtbhUBQH0EJ1kZ+r6kz5BHTjCKzSkxI1JDiYmFwwGsba2hmg0KlQf1puaTCZpMksYiJvUUY/nhQ5BgiXDLWaGstmshCFGyV0qQJALxc/odvXWVIFAQHgvVCQ1ZnJYd0dPh8aPBFBmMJnirVarQrZj6pqUCxJPyaCnMSMATm/OZDJJpo+0gnA4LCxv1i9OTEzAarVidXVVsmos3mUxMgFWKliwZIj3aHV1Fc1mE6Ojo8I3i8fjIo5Yr9eRSCSkZpAhEdPzmqa3NmPygROQXjCzdQzTKefD7Bc1tKgiyt59xJMo5cvfHo9HEghkVbM8if/395vLcn7QA2L4QuVYhn/pdBrRaBSNht60l+ByOp2GyWTC/Py8iOUlEgnhHdHoVKtVnD9/HkNDQ6jX65ibmxN541wuh1KpJD03CbIzC0j+H3FIhq4Mi1mpwFI31v2RlsHnx4oFbpQ2m00aspJQSqyKHi7DNa4TrgWSt7lxMXK5dOmSqI9MTU0JpsdNlfI1NpsNjz76qOhzUVmFPELO73A4jGQyKd7h+Pi4qM3yO5mVPsrxvDDnmZbe39/H4OAgLBaLPBRm0ZjtYraIN5DYEzkk5NuwIw7ja5JQZ2dnJRzizsqwiJkfsqnJMTObdQnpdDqNnZ0dAaqJi5CWQANit9tx6dIlwaBIzbBa9W4x7E23vb19gK3f6+nNZAnck1FPLhF5PsSmmIBgaE1Zk8nJScH2rFYrRkZG4Pf7BfTm4qLnw52f2TGqI/AaaeRIPGRZBykPqVQKTzzxhEjgMFyjgCJLhAj2kmtGrhVVI3htFB9kUTHLXxYWFoRISy2pYDAoEAI5cryufD6P4eFhuU+kWqRSKSSTSTGkLNFiqQszZk6nE6urq5LNY1hP/S2eIwAxyFzMfKbM2C4uLsJisYjuGLN5TKBQlcRk0mW5uSlTCYQGNRqNihHiv+nBkDqSyWRkAyr2u4THYjEUCgVYLBasra2JV0sOpMvlwvnz52UDcjgcIlVDWagTJ04gGo1ib29PnkkkEpHNg3I4bFrC2lN6iDR43zZF1iwBufnmm6UzDLMqZHGzTGd3dxdbW1uyo5JtTikWQCca3nLLLSLFsbGxIUBoPp9Ht9uVhrCUZiEozdIJY6kJa+soJcz0Og1JsS9Z7PP5kE6nYbfbRUOKO5JRjTMejwvTmgaEWShKuzC1zOJrargz5GFWi5OAbHyyyZmsoME2m/UGJAxJ6TlRZ5/lSDRaxvtASRQaDLLkyb62Wq249dZbsb6+Lnig1WoVwiO16xniK6UkS0b6AmWNLBaLeGrcnff39zEzMyNkX7L/LRa9cxDLu2q1GpLJpISk9I5Y6F0oFNBsNjE8PCzeDmWPGS5tbm4KZ4+4XjKZlLKXVqslZVE0GuynSRrN/Py8JJPC4bCoZJhMJjF+hEWYQa5Wqzh58qSEdVRDoW47Kxyo5BsMBrGxsSFhNj1uFuEzzGemkBljZs3ZEo2UIYfDgaWlJUnWEONjc2JiwhQRZL3oxYsXMTY2Jpun0+nEmTNnJKnGZFcqlZLwknPwKMfz0uWHbNqzZ89KvRXJe5QMZl1Vs9kUjyKVSqHRaAiWxPBvf38fTz75JIaGhsSg0JsIBAKySzAjx8kIQHZQqgCwqLharWJ9fV12IXpiBJW9Xi92d3cPLBjukFw8PH8uGBoi6pUzXGLWslwuC0+Jhqjdbsukp0fGXZHY3MTEhIC0vZ7eYLZUKqFQKIg3SsPn9/uxs7MjNBRmz4irkL9Eb4ElKKurq8KurlaroobJzCHVXSn9QmIspXfoHRMnY5jN5AI5aXxmRiVZlpsQ4G40GuJlkO9EsiwzukNDQ5JJK5VKuHTpEra3t4WkSzyR50Z6Cushmd2lsaVhMJa7kHZBXlqz2RSCMakTVGigWoTX6xUgnwacWCGrBYxZdOKTVGUIBoNyD3h/9vf3JZtHsJwqH6lUCiaTruJKigZrZ+PxOJaXlyU6MKpgEGJg1MGyNjYL5kZbq9Vw8803S0aelBR2pG+1WrjtttuO2qw8Px6XxaK3DmeBqdl8We52ZGREUth8cBcvXsT4+LiQEWkMqH8VCASk0zOZ3AwX6OIyxGMhNhm+DFOpP8S6K7vdjltuuUWq5ElvoHrE+vo6vF6vLFiCoix3Ydqe/BeCoSQnEsshiM3iV54b09AsOzL2WGTWlO46Q2FO5Fwuh6mpKSmjcTqdImVN40MQn5yv8+fPIxqNCgBNo2vs2UdpGMrWkLs2OjoqJUcEi3mO0WhUCrupwMrwjtgVs1mADiVUKhWhcdDb42ZBT3ZiYgIApEEvM2TJZFI6QxO0ZoY5HA6j2Bec5L2nsSTATJ31tbU1TE1NSadynofNZkMikRCDy/l18uRJKKUwNzcnApY03js7O9J01WQySS+FWCyGYrEohGqSkGn4iVfxfP39hiQ0vsW+wCPrKI2y5oVCAaurqwfkaqizRYkgi8UifQzoNAAQ4L9SqWBmZgaRSATDw8Oy4TBbTaPNBBM9NWbzlVIIBoPPS5H1kZf83H333RqJcsR5CHxTMpg3gcAhS2r40BmupNNpxGIx8UaMqqGcAMZwjBlKPkhm2bhb8nim+IlH8TfPhzQOgt9UCDB6ZcymcLEzzOPDpSGkRhfDSiNHitQNaqmTt0MgnTuaUkpqLScmJpBMJmG32zE6Oio659QOo8fAnpGkDHDH5b1imp84FLO6tVpNvBO/34/p6WnBtmKxmOiVUeudOCM9SL5OouuJEycEVyJAT8+EnD/W7wWDQWQyGXg8HmxvbyMSiUipFRMPvJ80SMTziNFxDsXj8QMqodTlajabsrGYzWahPFBk0Rj2tlot2O12DA8Po9vtSq9On88nHi3DJWYdiU8xYdTtdgVaMEojUaWEHjFLzqgQy7lCz4c4lM1mw/b2tlAROE8ZukWjUWHrk8s4NjYmcAOrO0hIptYWM6CMXsjzYoKMNCLK2ng8HlkDTqcT733ve2/skh9SBQAceJBsvsAJZ2wcygdGsinBzpmZGVE3IJmQuA8NMPlZpFwYlU+5y3Hn4M7FekDyUWg819fXZcenACF3p8OZORpDEgU3Nzfh9XqFMX3ixAlMTEzIwyURMZfLCcbR6XTEqFGNdHx8HNlsVoix1Hei4d7b2xPSKkF2pvCZNYrH4xgcHBQdKuJ+5I8xzGAGk4x31mF6PB7RZdrY2IDf75dwlR4OQ70777xTNhZWHjD8IceK4SQAkU3hLk3ZY9az8jlROJGeNUMkMvr5XhpK3kNmlFmC9fDDDwvW1+l0pJ+k1+sVMUun0yl1jwT46/U6RkdHxbDk83mcPHlSzp9/Y5aZEtdjY2Myf5vNphhfbkx8rmazGRMTE7JhU8nEYrFIxpQZSAAyV5iBD4fDghGSlOxwOKQwm0q10WhUkhz0OClxxGzk1NQURkZGDjQqrtfrkmigDhkN7Pz8vDwXVjUc9Thyw8UJTYCSE5T4BXcz9mobHR0FcFk0jmAvyXb0coaHh4WcyuPogbHCn0YLwIG6N+IP9DxWVlbk4TMNnU6npSaMBpVy0RR3YwccenLkexHMbjQaEsadPn1a9PCnpqZkxyMORpCTuyoNIUFlAr7EwcirstvtgvMwvCL/i7IvxGsikYgUgTODS6POLBmgF4eTO2QsKI/FYpibmxP9eqpzWiwWIRhvbGzIvWDowO8YGhqSkIPGlRsD9de4qEOhkISVJLyywoKeGT+DqXomMMj7o8oBy7jy+TwWFxeFnrOzsyOeBcPB3d1dCflIxGy32yKfRHzT6dRbjDHxYrVaRZGBqgyAriBLUJ8hIJt8MHtIb8xY7O9wOES3v1gsCtDe6XSwubkJu92OtbU1CR8vXLggMAFLsIiDJRIJwVRJXibOubS0JCVR9HbJV+O5EnOjAi/Xs8fjgdvtluQGw2k2sT3KceSGa2hoSFjLzJYwdiY4TuIoC5fJn3G5XILNhEIhbG9vY3x8XMiXJIQydKLXxsJjGgKyz7mzccclK3l0dFQybYznWaTNrCAAWQB08fkwCdbSO+h2u7IAOp0OstmsEFbNZrMwxzudjqgTUJyNoRMXczweRyqVQr1el/CCxoj3geRak8mE7e1tyYwyjKMix9bWFgqFAiKRyIFuPWSHk93PDaJQKAjZk+Euy0RoMKmbXygUMDQ0JEaWheQ0esTx8vk8KpUKwuHwAeVP1hqSimDsGE5+EDN0bPjBBIRR+5xy4MxSM/mTy+VQLpelKJg8JYLLLB9iMoL1e3zOpPTQw6R4HsNKAIKdbm5uHkhccAOkGB8xOW6+hDVYAE38k94xQX928qnX6zL/TabLfRJY5aBpmvDyCHewXIohP8Pq5eVlKainph1DbfLRiGeSHsN+mSaTSYio/kMt8I56WI76C2iICAIDkIp5GjMaBoYPFLhrNpsyaUwmE4aHh4X9OzExgbW1NVHdNEqgsOJ+fn4eKysrQtbL5XLCESuXyzCbzWL86PaSv0OgdG9vT0IFZlFsNptU75PNTkyHx2WzWSHukWwYjUalYoBe0fj4uJRfGPlq8XhcuFmDg4PI5XJSAkWaBstIiFG123qn6L29PTGu2WxW+EtsVLG7u4tgMCheAjO9zN7y/lC0kfwo1iaSzU3jSg+H109WNtPqLDjmsyVXjJ/NOUEmOz0WKnnQK2fCxWazIRaLIZ1OI5lMSihGD5iG2pjZJQbF+jp6zaRo0ENhUoQJGn53qVQS7hhB/Ewmgxe96EW4ePGi0G0IvFMQwOv1yjVMTU0hHo9LkoDYKPFVNpulYeY9DYVCYlS4MTcaDeFEjoyMyGbCCpJYLIZkMgmz2Sy9EelFEQcDIPjZ6dOnD+jC7e3tYWxsTHBCUni44ZO4TUoLoR3OoaMeR264WJzJEhqn04lgMIidnR1Uq1WMj4/L7mdcGMbmCCSRsqZudHQU+Xxedm0S/Yr91lOtVgvj4+NIJpOikUX8iZ4VCZLGCctskt/vF8+C9XxOp1MyZwAO6BZR9oOTjnrepDIsLS3JImaY0W63JcwipjE/P49yuSxifsxIkrIRiURw++23i0LpS17yEmxsbAgdgCRMhssMY4hxABCvMJfLCWGVIRIAaX7barWwsLAgIQEn6alTp5DNZqWLD3CZi6bU5a49rD+kBtrW1pZ8H4HxRqMhXDKfzyfqE5QK7vV6GB8fF3A4k8lILSN5aaOjo4In5nI5EbejB7izs3NAnoalY/TMmHFjQsbI5aKefqvVOgBNsATqxIkTiMfjmJubQ6FQkDrcTCaDhYWFA3pwzCafOHECFy9eRDAYlAQEN3fSLpj9JkTRarVEnZdF3+x9yBpaJgkoGVQqlQSfNIbL9Ka4OU9PT6NcLiMUCol3zXtMvJQeIfFfenHEDkmXYStCCjse5TjyrOI73/lOLZvNSuaFk4TAOrWXCGqzOJdpVxL1dnd3MTk5KSlvekLcvSYmJpDJZKSxBgDx1IgLWa1WwUHIEu92u8IsZjKANArj7kaxOOI1AKQ5wcTEhDysU6dOSQNVn88nxb+Uax4bG5OC3LW1NfHsqHdFXlAikZAi2UqlIp4kZX+M50+qRLvdxokTJ5DP5+Hz+VCpVLC8vCyGmrJBxOsI1ObzeYyMjGBjY0PoBrxni4uLcDgcUvZDQbmxsTHZDKanp7Gzs4OFhQUR7SM+5e+rfdKYM6TWNE24RhTf4+KKx+OYn58X4i89Q2blGE6RFsJ763a7RUmEtA4qcTDE5rURJiAATdoLjT2/i12EmLGjd0wvbmxsTOYHVTrYBo0kaxKVacg9Ho/UNdIzZHdwGgRuqOFwWGoKWU9KvTHqzfH8qEXGBBLpJPwOFlAz9OOmzHlPWgY9dH4/y76SyaTM8729PZm71EcrlUo4efIkvvGNb+BjH/vYkWYVj9xw3XvvvZrX65WJR14Qd+lWqyW1g8xqEaCdmJhAPB5HsVjEyMgItre3ZYfggq1Wq6Kc6nQ6sby8jNtuu01S9lSh9Hg8WF9fx8TEhPCUqtXqAU+FuBofCvkqRk0xej4vfvGLZeflgzeZTIjFYtjZ2ZGiZgAiGsfib8o1G4mDVAsgSE3tsIsXLwpWY+Sr8XpOnjyJs2fPSnftTqeD8fFxoRewiJwhIhfwzs4Odnd3D6S1GYowXc4mCyaTSRQyQ6GQvDYwMCClSCR2BgIB4S3RoGqa3kB2c3NTOHssTs5msweoCNRuZ5EwaR/MChoXGNnurBzga6RhELhWSmFtbQ3T09OSEGB7MyMdhFgpddWolsq5xmoKAt0Mn7gBpNNpRCIREdmj5DZLYkjCZRaTGUXSaIiPkvPHJqykjvR6PSGHUgl1cnJSwrNCoYBwOCyF8zSmVOwg9nnzzTcLDcSIRVLDjdJMnBOUk6ZUkFHimlJC3W5Xiv2r1So+9KEP3dh0CBY5U36GhDUAkvFjsTJVJwnyPfHEEwIuk6dkbDPFBcy6xVAohMHBQQlJqcDZ7XaxurqKcDgs6WEAsnuxIQfxEFIqxsbGRGSODRtOnTqFkydPimu9vb2N7e1tKRT/6le/ikwmI4ZscHAQr3zlKwFAGq8SqCXewTAgGAzKxE6n00in07jlllvgcrkwODgooH2xWIS/38VoY2NDsIWtrS3s7u5ieXkZX/7yl5FOp7G3t4dEIiELloXAd9xxB77ru74LN910E17xilccKKD2eDwiJcQw399vHEEDD0DS51xExBIJEHPxOJ1OPPbYYwfIo1yMBKVZ2lKv1wWb4j2ORCLCX+JC4/1laGw09gSUqTzSbDaFTsGEBL+PnDFuLAyT6FUR5yNPiefMUIoZ0kKhgMXFRZH2yefzovLKhAcNCvtEGus3eS3UXuOmw40ukUigUqnIOTOc3NzcBABR2SWuRg8ymUxKgiKbzWJ8fByJREIal2xsbEAphWQyiaGhIVGHYOhMIw3oIa+RvU+BABr9WCwmxuyox5F7XD/8wz+ssUEGVSgJ/jLlznQ9VRQymQz8/S4n29vbUt+2vr4uoDJLDlwuFy5duoTR0VFJhU9NTQnAT4+O4QX132m8qtWqnBMAmVgXL17ExMSEAP0LCwsiF029p1KpJCU/9BKZeWH9odPpxMtf/nKRWeFC8vl82N/fF+lgegrkV3FHNnLPyOmhaCANv6bpLcIIpjKDFIvFsL29jb29PZw4cULIrP5+W61QKCQeIvXXL168iIcffhjBYBDhcBiRSAS9Xk9keNgQlLWErBYAINQUNqZg15pgMChiekyCkOc0MjIim8nQ0JDIzNB4s+cAu6DTgFGpgRvG/v6+GAEuWBpTGjpipXzGxpCfoDMxmmKxiKmpKVHOoL4Zwe+FhQVks1nx7oi1UV+MZFxqf7F05/z587KwWaDN8NBqtco9I2N9b29P6ButVgubm5vw95vJplIpiUzoURO7LRaLmJubk0J0UjcASJKpXq9L/0tN02TdUXeNrH3gMr+OkAnX6ejoKLrdrihMxGIx7O3t4f3vf/+NHSq+4Q1v0MiZIo7BkIShl81mkw6/BK6pOmC32+HxeJDL5UQ9k91vCGpTMnhvb09KhPx+PxKJhOyS/M6hoSG0223s7u6KNEwqlZKdgulnhgokcvp8Pvj9fjz88MMHxNxKpRL8fj+SySTGx8dhsViwsrIiwDJ5PcxkZTIZyS52u10hJLIMg4A9gAMKGZSnoVc4OzuL7e1t4RiVy2Vh3xPrYHjDzGckEsHQ0JDwiDY3N0Xm2GQySQqeel07OzuC4wHA0tKSYCP8bBpVMqp5rwcGBrC+vo6FhYUDdAI2VGUChF7j0NCQ9LokCE0D63Bc7phNBjufJ5U7qG7r9/tx4cIF+Hw+CXtI9GQJDnlNBN+bzaZk1BgWs9CdtbBUSuh0OlKsPzo6iieffBJ33XWX1KsyPGZkwY2RdZFGldpisSjaYeR5Eef1+XzI5XIAIFxGKuXy70xoUVQTgIhKMstK4i8L7WOxmGTUKcTJNckSO0ozsZaSFBeSw3d3dzEzMyPPgckHZhotFgt+93d/98YOFTkxWFZARjMnE4XOiEWQeXzx4kXhQHEitlp64wNms4yLnQxtluBwlyLFgSD51taWFLhqmib8HupltVotXLp0SXTwFxcXMTc3h3Q6jQcffFAaZKysrEg2lIoB+XweKysrqFQquP322zE6Ogqn04lz584J34dYHikFrH1j8TUzQAyBGHYwbc0FdP78eeTzeXHXCbomEgkJS9LptIQk1ImnFhTBd6paXrp0Sa6HIeP8/LzgMWwcWiqVRA6H5ShWq1USJQAk6zQyMoL9/X0xIn6/X1rJk8PHpAPxQeIo7C7OyoRsNitESQDCjk+n01JwzcXKTJfdrjcKASBlOMwwMvQHIJsX9aZI6zBWbZDuQvmhqakpqZ44e/Ys2u22eN309JlsaDQaIq9DuWwKEjIjzvCV9BIad3IOCaOUSiXMzc3JvK9UKgIdjI2NHSD20kNljSgTEsyuUtWB30cqDcvGer2eKIBQ6tooHU1qErOnNMq850c5jpwOwdIRNgIgHaFSqWBubk5uBgUAKeMciUTEw6JHwywdq9WZcWEKnZOeADtvPss2CBiT8MqYnt9BHarZ2VmhSKRSKfR6PSQSCYTDYQAQpQYAGBkZEZ4OwyROmE6nI0aWi4leAOVjKIvDiUz+GncxGgViPyQKFotFoSuwbIXhWKfTkewoDRQn+tbWlky8xcVF4TIZjQpJksR7GJ4y5GNNncfjOcAnYwUDs1VkXFNxgZhkJpNBrVbD8PCwZIKZWSQdhtr8Rs4SFSeYDGm3L/c8PMzLcjgcSKfT8ixYmUCoIJlMinAlFz612uj1E09yOp2C91A7jgoNk5OT4h1So53P0ag5trOzIwXzh0N+ClwWi0W5nsHBQayvr0t2e3d3VxJJzIJSRz4UCol8OL08PgvSGJLJpBhUeswul0u6UDGCsNvtooRqXKsUImDSa2dnB7FYDGazWWAbUmhIyD3K8byoQ9CdZdqa6qDb29viYrPBpd1uRywWk/IIut/sVANc5g2xjETTNNEHAnT8Y2RkRLwm9oCjRA0bYDCk5E48OTmJ7/qu78Kdd96Jn/zJnxQ8jeEUlSq3t7fh9Xpx2223SQE3w7DZ2VmMjo5KgavL5cLMzIzsmvF4HKVSSUIg6mvxOpnh0zRNvFWKKZKdHIvFRI+s2FcboNfpdruxsbEhpUihUAiRSETS2BRe1DRNuHT7+/uo1WqyebCQnTgKd/tMJoMLFy7AYrGIljpDBbfbLc/FaMy8Xq+0da/VatJTkrgUQ1lihqwmYMIhn8/LPaI3qmmabIR33HEH/H6/fB69dhoM8s/o0ZJiwVCXmw1VDZg4MZlM4gnSQNNLbzQaQoUg5YKGxufzSaNcFuVbLBbxhIy1f8SKLly4IOVqpHtwrrFMjlr9JCKTfuB2uw+IXxJuMSrQEjgnQZceM1v+sfcDaxgBiMIGibXEwKanp6VmlhQMepEMI5m8Ocpx5BjX93zP92jkxjAMqVarB7KM5LfQCJCbRV3tra0tkellFofZGoKbZCUTHzLK7LLrDnd+TibWXCWTSXznd34nXve61+HWW29FPp+XLBQNzunTp6GUwuc+9zlcunQJr3vd6zA7O4tPfOITWFlZQavVwsTEhBhUGhFmDQFIQwzeB3pI5LgRKCVwns/nEQwG0Wg0JCNILpqxhyI9SXo0VCBYW1uDz+cTL4G6YJy45CsV+yqaxHWCweCBzJCx+QMZ3iwdGR8fx/T0tIQ8jUZD2N58jWVNXBTGgnYuboY99OaIQ7JVHakPXPykkrBbk9HbJIGZDH2WFBHXWVxcFI+askcsJWJCQNM0hMNh8eQnJiakHpYiAJxrRrUNypOTrU7Ph9gcoQFiuMSgWNLFsjCG00xoOBwOKSLnppBKpUT+m9EG7xeL7wlNsKqCXCxmCwcHBwWeIYTAPo/MYpMSwtIuwgJMGJCjxjpbn8+Hd73rXTc+OE8eE3EbWn663KVSSRjhRtkSo9wN+S4MaYz8EWpCxWIxOJ1OxONxqbtjSRBru8rlMhYWFlDsF67Ozc1hdnYW3//93y8ZFO4YZNIzG0PDt7a2JmqSf/zHf4y1tTUJBejWM/HQbutNMIhBmc1mKeGJRqNotVpIJpN43eteh4ceeghKKYyPj2NjYwOLi4vSXo1AMgABxI01gCTlslsLsSnWQBKYJmm0VqtJh2OW4zgcDuzs7GBqagqXLl3CzTffLM+BHgq/f3NzUxYOANx7772IRCICHNODNhJljXWZVOukISTznvSHTqeDUqmEUqkkGVVKFNGbYqaRIS6ziCzZYVKBISRDQ+JV09PT0kyDRfU0SOQbLi4uYmdnR0BshnTkezGzW6vVMDo6KlUF5FV1u5dlpmkI4vE4RkdHsby8LMknZiSNjTpcLpd0oKanxo2bBeeEFigwSYkZltUxxOTmOTU1hSeffBJLS0vY2toSxQrSUoghUhGXFRYs9h4fHxcvi/QYbtQ0ZB6PB7/+679+Yxuut771rRrBSE4oSopQQ51ZHJYhGJURKBlLmRRKshzu30awd2JiAufOncPMzIxoEjFtvbCwICRHxuk/8zM/g8XFRaEopFIpUX0ktsEdlZkeYl1ra2siEHfp0iV88pOfxJkzZ5BOpwFAZEeGhoZgNpuloQI9PYfDIS468TBmHm+++WaUy2VJHJBrlE6nMTk5KfIyLPGgMafXA+hp/p2dHSGwUoWDC8q4m1N5lFgFca9yuYz5+Xlks1lMTU1JJvWWW24RGsPp06fhdDoxNDSEV73qVQiHw9IpGoBw6WjIqfFESgc9LmaO+fzZ5oxE1YmJCSQSCZHNocdAcJka6PSIyAekdHEoFBLPxd/v0k1t9omJCRT7Srisn6XXy1Ic3jOv1yuS4yaTCel0GvPz81hbWxPDTIoL8VmC9UxcEPNj1MDkUaul98BkVpjF5yRnk9vF8wmHw1hfX8fw8LDUIpInyawhSbJcawTmuQEmEgkEg0Gk02khFxO7ohJrPB6XonOW7BmzoNPT01LtUq1Wj5wOceQYFxnqxD/abb3RAjEN7mwADiiBOhwOAVKpj8TK9VwuJ0Q4aiqRbEr5ZeIC7JBM5jVDzlqthp/5mZ/BrbfeKlme9fV1ASSJJ5HVzwnKXdyolOnxeLCwsID5+XksLi7i5MmTOHnypGArzC4x/U3MzljuNDExIdyZUCiEM2fOSIqcOunFvsR1PB4XlQLWFjKDxq7CAwMDyOfzmJyclHS63W7H2bNnZYLTGLvdbsnaMmwnED4zMyPY0ubmJrLZLFKpFNbX1/HEE0+g0+ngtttuQ6VSwblz5/DFL35RhA1Zu5ZOp0WGmxsUw3CjkoFSSjAnerosHLbb9QYlg4ODqNfrYtiIkxo14lmPyY2HgngsXGYndaqqNhoNIWpS24wF2cTG2LzX31dWIE5IPJUSzNTHZ13r9va2aOx3Oh1pf0cAnYkUhnY0YDwv9lqgJ0MIxUjlId2GIocMaakvzxA9EAhIpQCNE0M/KnqQZ0eyLsF7lnytr68fIPdyfezt7Uk51fOhyXXkhotib+zXx5S18eEyzmeTApbqJJNJTExMHOhzSC4MxQAZvmQyGZjN5gNhUqlUwtTUlGQzx8bG0O12MTk5ibe+9a24/fbbUSqVkMlkcObMGTzwwANYXl7Gww8/jNOnTwvZUCklBElmcohlEWtIpVIIBAL4wR/8Qfzsz/4sfu7nfg733HOPeDNra2u4+eabsb6+Lp1X6FHm83kBNYmlzM7OikFmEw9Ax1Oi0SiCwaAsWJIq2Xk6FApJwe/y8rLcd+603BCozcV2XHa7XQi/nPhc0MxknT9/HsFgEBcuXIDX60UymRRpIBrcL3zhC/jSl74kcj70ogKBgGRg6QUBEE+TxogbHT0gZlRJF6GeFL0beoHkNTWbels5EpxJPGV/Q5PJhJGREQHqh4aGJBTnoiP4TGMxOTkp3LtAICChF89XKSVkaIvFIkXtfI3Pmp4S6wyZtWUozU2IRpeCgiz5MfYioAoqPWWGcyR7s7sQqUapVEoaw+ZyOQk3yU3jHGLSiIaMmmqdTgf33HOPQCEsJWPhOe/B8vLyUZuVozdc3FVZoMvwrlQqHaAS0CPrdDrY2NjA7Oys1HtRH5wcGrLoqXw6MDAgsT4XXLlcxubmJhwOvQ8h0/yNRgMzMzNYWlpCvV7HhQsX8KUvfQlPPPEE9vf38dnPfhZ/9md/hk984hP44z/+YxT7ksbsXEJDyTpGqkqOjIzIpLPb7bj55pvxwz/8w3jTm96Ee++9Fy996UthsVhEiZQGg6Dy2NiYdNGh/jsbRpjNZkSjUdkxa7UaLly4ALfbLcKIlNBhyETQmix+prw7nY4A0Q8//LDUaRYKBWkAQtE89jOkMqjdrnfx3tjYEK2yZrOJbDaLkZERLCwsYGZmBiaTCV/5ylfw4Q9/GJ///Ocla0kvgVwwAu1UuKA3Vi6XRVeMrG96p/S+dnZ2hG9FvTUSQ2lw6E3wPhQKBaE5AHqhMM+HxpQG3sij4txjJUEymRR2PMm29P6J70WjUfE0SWhmy7SpqSlJHFHzjNpWkUgEiURCip+ZDTQSe7mJkRzNLCfLwriBM7FkJNJSWYVyToFAQAr5A4GAAPrs00lcl9jX+vq6gPtMgDSbTdkEa7UaTpw4cdRm5egxru/+7u/WWJBrNpuxubkpgC4A4YiQYEjsh5kkArMmk0mybwCEGc/6RQKloVAITz75JGw2GxYXF3Hx4kUBwZnq/8Ef/EGEw2Ephj537pwoL3BXjcVisNlsmJycxF133SWV/FywBPJJgGQoNzMzIzyjCxcu4I477sDDDz+MmZkZrK6u4uMf/zgeeughIfYFg0HBubjjJxIJeDwe0Vwn34y4hMfjkZT5zMwMer0eNjc3cccdd+CRRx4R3TKSLLlgrVa9M/HZs2cxMTEhWIkxeUIsjWE58TI+GxbI8//E1jqdjlwTgev19XVJp8/MzMimk0wmJQvFLBr7XiqlJONKz8DpdEomk5sWMU/+nV4wN7BYLCbkS3oLsVhMrsftdmN4eBiJRAJLS0tSIAzoBm12dlbKb4ygPDtQ0+MmtYMe4Pb2tsxFAtjceBkWM1NJ/CiXy4lHyfeQznLu3DlMTEyIkOP+/r6opDC62NzcxNLSkuCnNFbEpqhsQXkihrqkUbAJDQC55zS27PNwmLdG+IMJMPLv6P0fteb8kRuu1772tRqxG054usoWiwW5XA4nT56UEMXIC+FvGi+CsRSp445HDpQxy0Mvg8XCxCeIeSQSCRSLRUxPT2NrawsjIyPislMTSdM0LCwsIBQK4e677xYuFHdgpo9ZK7iwsCAda2KxmAD5LLL1+/1YXV3FE088gY997GPCkmZ9HRUNGNpwN+XOzGYMJGVSk4k6ZgMDenv3ra0tYasTKKf0iVGDjIRSViAwSUCMj0aM9WvshG21WpHNZgW4b7fbwkivVqt48YtfLHpmSikhg46MjGBpaUkA9EwmI8+TemokQRL/ZEbX6XSKbnqxWITL5ZKyFHLfotGoiCQawzx6ZKQpsHSFc4PJEv6wb2E6ncbCwoIosUajUcHP0um0GCVqbZHXZgTi7Xa7tIFrNpsolUqySRmTViaTSbpnGxvT0ni0Wi1JRDCkozdNCsvu7q7QLE6dOiUF09lsVsrjpqamJHM5ODiItbU1MdLsY8DMJOkNzNbS+WBtLluyUcyRGGm5XMYHPvCBIzVcR86cJ3GTngWNg8lkQjablZvH+kS6p8w0USqW/RKNZDt+FndZ1iyura3JLj4/P49EIoFAIIBarSaaR2NjY7KrnzhxQlxwEjxbrRYuXLiAhx56CAMDA3jZy14mWACJd6QkPProo9Lqq9vVG2WwnAnQG+Jub29jfn4egUAAL3/5yzEyMoJHH30Ujz/+uGios1SDAHImkxGMa2RkRKoESLhlqLq1tSXt1alHFQqFxAizmoCD3gEAKVwnFcHf15Gq1WqiylAqlUR9IR6PIx6P484774TH48GlS5cQDoexuLgoIczFixextraG7/3e7xUDyZQ6Q6dQKIRgMCgVEZTd5rU5nU4Je5lN5XlT2JHYDpUaGDoReiBOZOwPYAS4yapnqRKzhAzH5+bmBPCn6gOfMTXl2IPRuIkSXAcghc+8j9R2z2az4oWxUoRGjCEwa1WJ3VFckdfQbreRy+UwPz8vITITWcw09no9gWesVqtgXNyootEo8vn8gQJrXhc3GKrjUsyz0WhgdnYWly5dgtVqxejoqKxTapgd9ThyjIuaRiToAZf5QgSJvV4vAoGAlMkAeokMJUqYlYnH48Ko7na7UnDMLi9ms97nMBqNYmlpCSdOnJAShq2tLRT7PfboebGTCc+v1WphZGQE3a4uM33q1CmUSiV8+tOfxoMPPihaWACkzstqteLkyZOYmpoS7IZGk6UsBPdJAxkdHcVLX/pSvOENb8D09LRokfP+GAXjCFITV9nY2EClUsFNN90klQRLS0vC6aHntb6+LlgNQ2+jmuzMzIzUkPLeRSIR8d6cTqfgJKQVUDrlpS99KXZ3d0XrjPIo9DjC4TBe8YpX4IEHHkAmkxEcjhk6Arlms1l4QQSHqZhgrNnMZrMAIJQJqiSQ6U1PIRAIwOv1Cg2jUqkIBEHvk/WARt18YrDGmkByoKirTzCeWeTNzU2hw7CgmuUxPI7KrsYmMSaTCadPnxaeFvllLBXiBkPDS04YvTjCJh6PB2NjY5ienpaQ3+PxCN+OEQvrBomDMuvJbC0NIMuJmOygwTSSjxkhTExMHGiEy2YZ0WhUPPajHkduuFhTRbc6n8+jXC5jYmIC+XxemN70OlgPRuY7S1JcLhdGRkYkrHE4HIjH49J8w2q1Ym5uTrJJ6XRaasXIiQmFQhgdHUUsFsPo6Kgs8rGxMWSzWezv72NlZQWlUgnLy8tYW1vD3NwcRkdH8cUvflFceBYXE2cDIMDk+fPn4fP5pN7LZDIhGAzKQzabzXjkkUeEFBoKhRAIBJDJZMQTZQ/CsbExISAy6UCju7KyIqAp8QfgskE1kiG5exYKBWkKsbu7Kx10jPhWq9USTg+9DWpCMVTe3NwU78Vut+PChQvY2tpCtVrF2tqaZGpPnDghssMMO6ampqSKgZsAScX0LgmgExviImTzBnrX4+PjEtayaS2rBxjekL9Ej5vEWHo9VNKNxWLSy2B1dRVra2uiO0/yJ2Vnut0uZmdnRT6p1WpheXkZ4+Pjgv0Q12UITQ+6Wq1K8TmzcEapGOJH3HTYRowEXYakpPywAHx8fFzCN+JyTqcTY2NjmJiYgM/nw6VLlw7UYTJicDqdUu7EzCWpPtQFYzhLQ8WkjqZp0kl+Z2dH4J2jHkeOcb3lLW/RSqUSJicnsbKygkgkIjff4/FgbW1NZIBZosGQgfE7ww2y6rPZrISejP1JmOt0OkLspOAb07kMDwi0EvBfX18XOWL2mKvValhdXZUi5unpafzbf/tvMTk5eUDDSymFS5cuCc+MpEYCoczgZbNZLC0tIZFIoFAo4KabbhJDsrKygo985CMSfrK1F8tumO1jMfno6Kgoo3LHJAeOVQJLS0soFAriAXFXpzHkObHbDxt6EHzvdDoYGhoSuRx6gGxTxooHPif2eGQihFpk1PMi0ZRYotvtFm+XGVYuBi4qlvlYrVZsbW1J5QPDzlqthrGxMSmhYahKgjGNLTsREWej90jMrtPpCPE5m81KiMWSLfLLWP/H67506ZI0IOn1ekLp0TQN0WhUWoZR5cRICyLGRQyJxGEKY/LZkzpEcUSqmOTzedx0001Ip9NC1CWfjtggNy1CHKlUCjabTZjyLNhuNpuSCWW4auTQsYTr0qVLYiBJFWJUwUjDarVib28P/+W//Jcbm4BKI7O8vIz5+XkhtXH3YBbO6XQiEAhISMUdhbrrNCZ2u114TOFwGKOjo0IuZP2b0+mUvzEbyB2bqX1W6rPnXbvdxtraGhKJBB599FFx3ZktoyKD1WoVRjLd6XA4LBrynU4H6+vreOyxx/CVr3wFZ86cwebmJvb39/H3f//38Hg8QhqNRqOYn5/HHXfcIb0KE4mEhAVUE2XNJnfubDaL+fl54bdNTk4CgNynmZkZoVqwtjGRSAhZ1263i3tPT5jNKsjjSSaTKJfLSKVSWFlZAQARXzxz5owY0ZGREQCQJAoXGrE4s9ks2BAACeM2Nzfx2GOPiaDk7OwsRkZGZHenqkE8Hhey6MbGhmS7WKpSqVRk8ZDZTerF8PAwAAhfiZSVbreLaDQqLPZmsykLmIoZzG4SL2MTkGJfSZREzkwmg2azifX1dWngwSoBctBIbWi39bZjlE8CIDQV8toYZiWTSdmEw+GwJACImY2NjYl3NjQ0JBEMeWUejwdOp1MK5v19YU5iqeRBct0tLS2JtDfnEf9Nh4JcNxKauTnz88j0z2QyR21Wjt5wkXQHQOQ/yJvhbsR0dT6fFyyB7Hi6+wQZKZgGQATQLly4IGxfpmaZrWOq2mQySZp/Z2dHDB0lktfX13Hx4kXhaxnllKl1/uSTT8rnUIOIMjnZbBZ33HEHlpaWYLfbce7cOfn98Y9/XBY5uWecpIlEAsPDw3j961+PU6dOIRAIiJIoya/G7kAs/2CavFwuH9BsorQzjRIA+SxOOIvFIkB8sS/kyCwbOVdzc3OSJSKlIJlMSmjKMGV3d1cAdVIfbDYbAoEA2u22SMt0u10JP5PJpNSj7uzsYHl5WaonSLNgoX0gEBDZo6GhIemjyMQKs678DpfLJVhfNpuFzWaTcIdAPr0/I4eOwPb29jYACBudUMOlS5dkw6X6p1J6w1vKJxPCoOou8Vo+G3pcxJBKpZLIHrHuj5I4w8PDAmUwCwnomwcJv36/H6Ojo7h06ZLcOzb0IJWIoT+byJJnRu+ZEQD7OXBdBQIBVCoVeYbE0ahaQmoHwXg2L1leXv72Aec7nQ6mpqaktIHV7YyRuRiZrmfoQfIjoO/UgUBAQEiWfnB3j8VieMlLXiKtq6gUSWImeT8WiwVra2soFArSbJVNDsLhsBhZSgfTQwmHw7h06RK+8pWvSIMG8o26Xb1RAL0L4l1f/vKXsb29jccffxx/+7d/i3q9jscff1xY/SsrKyI9cvfdd8uCK5fLyGazkkYnz4aS0ZRnZnNTlv4wk2jUT6erT0+UWaTp6WkJo1jeQe+OQD55XMSDuPuOjo5KVpObA0teKFxobPdFI+f3+6V2klnhjY0NPPLII7hw4QKy2SzC4TAmJydl8jN8ZMjGTKrJZJKw3lhUzZAlEAhIiMzaSOIvzJyywiKVSgn9gsbp4sWLcDqdEjYR9Od8JNa4t7eHW265RcQAuDESc8xms4KLcZPjnOl0OsKxIx2hWCwKcXZvb09CfUpBEctdXl6WRMX8/Lx4oqSfcIOhl0ZDSN15bmYk1g4MDEgCiBQHeoHUBGOJECkr5AXys0hw/bYo+aEEicmk9yuk2FmxWDwgX8vFQbCQ6WuTySQ9Fv1+P6LRqNRMEVxl2JnJZFAsFrG0tIRwOCx4AHeslZUVbGxsoF6vY2dnB+l0WhY2XXPuJtVqVXYneiYEVKmZT+4KACwsLIh8CgtnNzc3sbq6inq9jjNnzuChhx4SjwPAAX2oM2fO4OUvf7lQDEhXMDKeo9GoZMBoRJiGLxaLoobJQtlivzsSMRiHwyGk0FqtJr0AeQ1cdP6+6CLr3Oid8dpZXxcOhyUbSk+ARFIK8FHnLB6Pi1QM/84Q52Uvexl6vR7OnTsnJU2zs7NSquX3+6VTMystmIYPBALS3YgeOrun0xuo1+vinTLU39nZESyVJFCy1+kd0xCYzWaBCpg5Y9a2VCphY2MDpVJJkiGstSRdh8XKFy5cECoHEzcM51k2MzMzI1pb09PTB0qDqGnXbuu9E6ii0Ww2pbcAqR8+nw9jY2OyjkilYGaatawMHcltY/3nwMCAlJqR1MqQkJ49y48og8NjaNyPchw5j4sgKZnN1PGhKBvJiSQGctck6zcUColI3cbGBmZmZoTpPjs7K1gVdemDwSAuXryIkZER4R+xdoygIvlkXOBMMzNbQoyM+AkfMEl83AmfeOIJoVRsbW2JVvfCwgI2NzcxOjqKZrMpE+vrX/+6pOOJTVFwbmBgACMjI3jLW96CRCKB5eVlnD9//kDj2UQiIZlITkJjAwn+3t3dlaYYxJS4SbBWkTWjlI4xm80wmUwYHR3F6uqq3HOr1YqxsTHBLdgQl7QKqip0u7rmPD0NtqGvVqtYWVkR742EV0r8khrBREsul5NeAaFQSIB5pZRgg0xEsBkFr4/UE+KoAMR7SafTIpjHRBCxLYo+JhIJ2YwoJmiz2ZBOpyX0XVlZwcjIiChH0BMjneDSpUuS1aSXRXyK0jjU2Nc0va09M55+vx8bGxsAIC32CIYzGUSuGSMPelEnTpw4QAytVCq4cOEC6vU6Tp06heXlZQQCAWxsbEiRNhslE6phoomeGLP7fNZUZRkeHhbFFlJk6M0y4XXU48g9ru3tbQnpuEOwz5tRLiaRSEhIR4+IzUgpN1upVHD69Gkp32BpAq0+F3iv1xOyXyqVQiaTkQnM4mYKryUSCdRqNRFYY9q5UCgIQZAZ0Pn5edndKatMcin7542NjWFxcVFUF8h2B/Rqf3ZdrtVqiMfjEsZNT09LDeDk5KTQMBi+fulLX5JkATNumUwGnU4Ha2trEv4Qx2OBdr1ex/LystQJzs3NYW9vT5qMMltLDSo2THA4HDIZGarSE2Xx7tbWFpLJpIT69XpdQi6HwyHNODRNO7Co6MXSOJTLZeRyOSE1EqBmKzN6OTTW3a7e+IPeEyEHJndYjkWtK2alKWXD0hjy1uiFTk5OClQxNDQkhpj6VgyBqcbabDbFQHU6HSSTSWksUavVsL29LTWfBO2NLHYy/4k3WSwWRCIR8QCj0Sji8bgoMFAkkMRQihYaW9fxen0+HwKBgGwsRvoQCaaswCBtg/eEahRUQGFdLp8x1wugJz5YksS2ZeyKfpTjeVFA5URljR+lXAYGBmSiMyNF2WI2BWB2Z21tDYODgwewsMnJSZw5cwajo6MYHR1FIpEQmRx2lqHsL9Uf2eGXGu8kzDGTQnYwdzQazXK5jLvvvhsmkwm33norBgcHhcVc7Mv4rq+vo9PpYHt7G1tbW/jyl78sOBCLpl/96lfj1KlTiMVi0l04EAhgc3NTvI8XvehF4ro3Gg3kcjk8+OCDOHfunJxTLpcTI+t0OnHx4kWRpGZ6fXt7GxMTE8hms1BKCW2AsiY0TEyHM2zw+Xyi2EGMg6lzEomZqbJYLMI3Yu1er9cT7I2lPZSljsVioqVmrFYwm83iSdFjoYQ3PUkSgzVNw+joqLD7+R3s/ETiMrWoNE0TVviJEyckE8hMW6vVEjIx1XFtNhvW1tYwNTUldA1mFjl3qGjKmtMnn3xSAH+SRre2tkTIz+12Y3d3V/qI+nw+4a4xIeHz+VAoFKQSIxQKSfMK0iJsNhs2NzelnpYGhR4PiaSdTkcy89SDYwVGKBQSLh3laWi8SAKmU8ASLHpmbrdbGvkyvGaPh4mJCRQKBfzGb/zGjV3yQ9Yt3U4KsDHDwvKFTCaD8fFx2ZHm5uZQr9extraGbrcrbeeJEXC3IC3iiSeekJo/qiuQT0SuD4mE9OwACPeLGTVOJrfbLW48db3ZGDWTyYi3NTQ0hOnpaeTzeaytrQkGxDQ2wd1EIoFkMik4D0mzNAAs02FPQMqnkJ/0jne8AxcvXpQFtba2JhpI29vbUojdaDQEDxoaGhIO2rlz5zA5OYlCoSAeAHWk6A2TJsC+k0opyQoODw8LbkOvmBlWijey+PfEiROywI0bhfEcyXman5+XwnLCCVSxJUWEIoeUembHIW58Q0NDQubkQmZygVmwarWKmZkZ7O7uIhKJCAuf2mMUQtzb25OaTb/fL148N4BAICAhLjEyAFhdXZUCZE3TpNsS1SfoqbF4mtgttcGazSZuuukmuSfEpBiGcsMoFotCoKU3yDnNhBdVYd1ut0AmmqZhcnJSDB4zmIQpaKwYueRyOYyMjAhplxAHi/vJpGemkVgaE1NHPY48VCRJjaxnigmy1IfdVmi0hoaG8JKXvETSwwwBSEykVjZLEcrlMra2tqREhU0c6N3x+6hpzhCImS16CUxtM/3NyVkoFJBKpTA7O4uHHnpI2jmRf2M2m0V+hgv/1KlTEjIAwKVLlyRUo8ezuLgoFI69vT3MzMxA0zRcvHgRmUxGvKoLFy5IDebJkyfxkpe8BKdOncIrXvEKaYnGBTQzM4M3v/nNeMc73oFXv/rVsFqt2N3dRblcxqtf/WrxqAqFgpRDsY6NIHu5XEYgEJCGE8SV2O2bevgsTymXyzh37hxmZ2clA0l6Bmv0XC6XNEfhnGA/ykQigfPnz0uozRBmcXFRsCHiMCdPnhTCLLW4mLL3+/2imktqB3sQkGpBIJveBQAhKbvdbly4cAEmk0m8G4ZXmqY3FrFarSLquL29faC43+PxSGhIrhPn7f7+vtQCNhoNnD9/Hl6vV8Qk2VCW6qHctMbHx8WDZTUGs+ThcPgAH5I4FD1rQgDsiMUSJHZZMpvNIrt88eJF0bgnHUXTNMks0gNldpfrib1JKSVN/JflTUc5jtxwuVwu6UpCeWWHwyHuJuP5/f19zM7OYnh4GMvLy9LamwAkU7K8SclkUtpyMWNGgTVqJXEn4S7Y7XYFP+PuPj09LVk0utQAJMSYnJzE4uKi7MTcaYijkPRnsVgwPT0tYRVVRff29kRbirgbMTTiGa1WC1/5ylckc8VekoFAAHfeeSduuukm4aUBELzD5XLh9ttvx9ve9jYJW1/2spdha2sLn/vc5/DlL38Z9913H97znvfgbW97G1wuF974xjfi5ptvxvnz52Gz2XDq1ClMTk6i1+shHo9jd3cXZ86cQaVSkYnJNDxZ+2Rg0zOZn5/H6uoqcrkcbDYbdnZ2xEAAkLQ9+W5msxmzs7NCcozFYpIBprwyAWS73Y6ZmRlMTU0hm81icnJSsDrK49BgcSEDkDCQi536U6xB5ByhcgelvcvlsjQ/IZmWHCYji35hYQHValVwxnw+j/HxcfG22NiEmCFpQUopnDhxAtlsViAPknPb7fYBAixDPsr2GGsRGSlQ9pySSPTUCBmwVRyB9FKpBJfLhWKxKBw4chVNJpNIarvdbslGGj3sgYEBgXVY1cBkGhUumMA5yvG8CAnSneVETKVS8uBY88cHlkqlpO9dMBgUUmMkEkGpVJJOvZOTk5IuJ9GSGbRCoYChoSEAEHmQYr/Bgc/nQywWQ7vdFmyE7N/z58+L8bPZbLILlstlDA8Po9Fo4POf/zxyuZwAq4lEAuvr69jf35fGAsScMpmM1EkyK8cORw888IB4HfF4XGgglUoFp06dwg/8wA9IgS6gG1J6Oo1GA2fOnMFXv/pVRKNRfPjDH0YwGMT3fM/34MEHH8Rf/MVfQNM0vO9978OP//iPQymFT33qU1heXhY5mje+8Y1429vehje/+c34mZ/5Gdxzzz1IpVISElBQjoRWqjGwto/gb7fbRT6fl47d3Fgo+gdAUv2hUAihUAjhcBirq6vC1CaHrFQqIZVKYWdnB1tbWwBwQDWEoT4TI9PT0wiHwweSMsV+GzoewzpAhjM0xMViEfPz83JuACQUHx8fF+yQiQvyrPhD6gmJpHa7Hd/4xjeEwsMyKiO7nJUHAwMDggV5vV6p5WWiwmazYWhoSPqCMklDA0KCLzdncrcomxwIBGQj5uayuLgoHdlLpZJ4w0z0KKVEoZaYFq+V64gGSyklBFhm/re3t1EoFDA5OXmg2e5RjSPHuHiDvF6veDzsvMMaNqUUdnZ2DlT6T09Py41jnR1TwZVKBfF4XFLmzOhQwI91ZOFw+MCOw/IWYgyzs7N47LHHAECKd+kSk3HdaDREYYFkUIaGIyMjAg6zSJyKBLfddhu2trZk0iwvL2NyclLqJOfn51EoFLC1tYXBwUEhVtIFZ+jm9/sFF6nVaojFYnjwwQfxJ3/yJ3jNa16Dxx57DPV6Hf/6X/9rtFotPPDAA7jtttvw1re+FbfeeisSiQT+4A/+AF/84hcRCASwvr6ON73pTXj961+P1dVVeDwenD17Fi6XC3/wB3+Ar371qzh79qyILLJMZGVlBWNjY/B4PCiXy8KkZ2/BdrstXgGBdYZKGxsbsosbi7WdTie2trYEn2FLOIYk5AW1223Mz8/DYrFgeXlZCKVM2dtsNuEajY+PCwGZHgs9MmayuXGdPXsWAKSky5iUyGazUsdIcJweGqsEKP5HdVWSgsn9MgLcCwsLAj9QBptUH6qSJJNJ0YczeviMLPheam5R9A+A1H1SroYGjevh4sWLovVGJV2LxYLt7W0xZhsbGyJRbbPZMDY2JgmsgYEBZDIZhEIhrK2tweFw4Pbbb4fJZMLu7u4BpQ2uqSO1K0f9Bcyq5fN5FAoFkfHgjnzLLbdIkfSZM2eEnUx8i0xel8sl6goDAwMYHBwUnIr97MgYbrf1XoVer1d+O51OzM3NHahvO336NABdQodCf8zOZDIZxONxEXvjNbRaemv7ZDIpIS4xFJ/Ph93dXaF43HTTTYJ1LSws4Cd+4idw9913Y2VlBb1eD0tLS5IdtVqt+PrXvy6tzk0mEyYnJyX7GI/HUa1W8bGPfQz3338/IpEIlpaWMDc3hw996EOYnp7GX/3VXyGZTOJlL3uZyOd+6lOfwle+8hWpR7z33ntx3333iVfw8MMP48/+7M8kfIrFYrjrrrvwmte8BouLixgeHpYmDPl8HslkEuvr64JnbG5uol6vw2Kx4Pbbb5fNh4RSI0PbbDZjdHRUSKQsqxoYGMDa2hoymQxyuZwYOtJTTCYTLl68iFKphKWlJcGt6vU6QqGQeD0MG8fGxgTjdDqdUrROj4TGkNQTyh253W5RI6WqBDePer0ufSJZ60ohP+JfpAGwyJ+UAQDCKaQhY/kSs4q5XA6nTp3C6uoqfD4ffD4flpaWJJQbHBzE6OgoHA4HnnjiCQlfie2SFEqgnvwqp9N5gEjNkD+bzQrhm9zFaDQq+JVSCpubm4LhsYCeWmbRaBRPPvmkZGcBSE3j6OjoUZuVozdcVKS02+2IRCJCbPR6vdIUlouVmRxOcvKfWLpCuY52u42trS2J20kEZJjHCcwMUCAQEBLi1taWkBCpwmrUquekNJlM0mLciG8UCgWcOXNGQj6llJAWNzc3BZtgx+GpqSkMDg7i7rvvFjnpV73qVQB0QDyXy+H06dNYXV2V9uwMOdmBmvVslUoFDz74IHK5HF7/+tfj9ttvx1ve8haMj4/jT//0T/GJT3xCNPDX19fx3ve+F7/zO7+DYDCIV77ylVBK4c4770S320U8HsfXvvY1vO9970M6nUapVML9998Pl8uFe+65B694xSvwQz/0Q3jTm94k5EZuEmxuweeRSqVQLpfxyCOPIJPJwOv1Sv0e1WUZTtCDZhcmYqB33HGHiAlSuYLZOPbETKVS2N7eFnylUqlgeXlZ6DSsc2Xih/eSHhehhGq1KqU/BNGZifN6vVLGRG4U0/3tdhs7OzvCJWPmmZgri66JM42Ojh4g8lLGidpfhEGormqxWKSsjSqlgUBAQvhcLgev14u77rrrgNwNr51KEDT6pLyw9IdJk5mZGQlvSdXhOiwWi5KFJEeOmWpCGtQeoxoKK0oASDenox5HbriGh4eRyWQknNrd3UWlUkE4HIbZbMbKygqKxaLwZNLptEyIZrMpdAGmgNlCbH5+XhqlttttfO1rX5M0eKvVwujoqBQ6E0OhR2acDO223mn43LlzolvF0glm0sg09/l8eNGLXgRAJ5NeuHBByIHM6hGAHx0dxYtf/GLcfPPNeMMb3oC77rpLvBy63uyYfeutt8JisWBiYgI33XQTXvaylwkuV61WEQqF8PKXvxy9Xg87OzuIRqNSDtLtdvH1r38df/iHf4hut4uf+qmfwuLiIjY3N/EXf/EXsNlsePOb34wzZ85gcHAQXq8XjzzyCN7//vfjj/7oj+Dz+TA5OYlut4v77rsPi4uL+MxnPoNSqYQXvehFuOuuu/DqV78ar33tayUDVa/XRT6ZGS7WAjK8Zu/JwcFB1Go1ab7L+sLFxUWcP38ezWYT0WgUX/3qVw8s5ImJCYyOjkqzlFQqhXg8jp2dHeF1UTqbC54ZMYrtkTdGaaPJyUkBs7komf5n0w3eU9YXsj6U1BomGWigCOLzeZG/1W63sb29LbwqNiJm3wO/3y/kasINy8vLmJmZkT6IVD5ldyLSiFjzy02Xuv92u13CQ2rXG2WkmVB55JFHMD4+LhlV3i8KNpKAygQQnyElikho9Xq94lyQ3sSu1kc9jtxwUYSfwOBNN90ktX9MS1NMjx6H3W5HKBQ6IFNMNjhxiNXVVaTTaWxsbAirXdM0KSfa29tDLBaTFDgzKQ6HA2trawJIMmsyNjYmYnssACYOVy6XxfM6e/YsnE4nNjc3xUOk618qlXDzzTdjcXERFy5cQCgUwq233opgMCgM6I2NDeHMUFeKzTbm5uYkg0SdcaWU0Aj+7u/+DrlcDi95yUswPT2NVCqFZDKJL33pS0gmk/jRH/1R3HPPPYLfLC4u4r3vfS8+97nP4fHHH8cdd9yBZrOJ3/u938NDDz2EsbExnDx5Eq997WvxwQ9+EH6/H+9+97uxvr6OO+64Q7DFb3zjGzh9+rQYFJZwsat3NptFq9VCOBzG9PS0dIam1HKx3w/y0UcfFSoDOXws3WE26vTp0xJqEEtbWVlBNpsVsJlVAyz23d7eljCJfSt7vd4BhQcmhOhdU1mCnjo9flZBEC8dHByU7uCkHfB4EntJVmaIyNDu9ttvF6NAusitt94qgD2NTCKRgMvlwujoKNbX1zE4OIhCoSB8QuKdTF4xeqHiBA0xM+GsxiAvkXOd95lJAEY25D1SxJH4Ib0q3nOqioyOjkptJ+tYScFgwu2ox5Ez5++77z6NtV8ej0c6wLBQ1WQyievs8/mkXX2xWBS8gt2LyVNhFogPl330AIgePEO/fD4vYOTm5iZcLhdKpRIWFxfx1a9+FXfccQfOnTsnYSPFC2lw6dWxvII7qM/nQzgcxitf+UrMzs4KUEz2e6FQwPz8vHS94eKbm5uTjjLFYlFws2azKU1luSA3Njak1rHZbOLnf/7nMT4+jl/6pV8SNdTt7W28+93vhslkwn/+z/9ZgP5UKoV2u40///M/x8c//nHcfffdeMc73oHPfOYz+L3f+z286U1vwn333YdyuYxoNIrPfe5z+OhHPwqn04kPfvCD2N/flz6T7Mz9lre8BTfffDPOnj2LT3/60xJOGTEkqhm43W4xJsRfyEpnhjSdTstuzga/L37xi0UgkEzvc+fOYWRkRIT81tbWRPI6FApJDeLExATGx8extbUluBpxUjLJBwYGpCSGJV00ouxzQJ4TeXy8BiYMqBzCjOj4+DjW19eFusMyHG6At99+O06fPo3JyUmsra1hcXFReh+SWM0yOFJ4mLQi/EG4ghgdADE6LNtheEmiMKWXMpmMJMl4D+lxMtlFThzDYGavGZKzGJxhO8uxqPXPwnYa+9/8zd+8sYUESdJjV5LBwUFpIspMUCQSEWJmoVDAysoKzGazGC0+KOIsxFrC4TBisZgUr9LDikQiWF1dBQCMjY2J7ha9sXA4LC2d1tfXJVPDEhg2LAAg7PNIJCLJAMqcPP744xI2Gev5yNHijsrW8rOzswLyE+/Z2dnB3/3d34kiBnf+VquF2dlZkar59Kc/jYGBAfz0T/+07N7Ex5LJJL7jO75DZK13d3fh9/vxjW98A3/5l3+JpaUlvPOd75QmqB/4wAfwnve8R5jiH/3oR/Hxj38cgUAA73rXu5BMJvGBD3wAjz32GPL5PDqdDr7zO78Tr371qzE+Po57770X73znO/GKV7xCZIvz+bxUArBHI6kq/n5vQ4L2lFwmeE6e2ODgINbX13Hp0iVcvHhRaljHxsZgt+tNZff396XUaGpqSowSxQWpgcUCfhYJ03vlORk9eD63VqslC7/RaBzQ/WemmRQVlrvYbDZpOELlEmb9qOP/+OOP46abbkKn08Hc3JyomJCKQH5it9sVZj95aFNTU6IhT8oDZaQrlYps0qShMJwkxJDL5Q6Qrf39TlPF/5+7/4yO/L7ve/E3ehsAMwCmz6DXBRZbySUpblgkiiqkJCpSZClWdB3LcuQkdnLimujk3OLrJOf6utuSlZM4VlzVbEmUKBaREsXlklxu30Uvg2kAZgYzg94x/wfY10eDPLkP/gc6R55zfGxL5C4w85vv9/N513zeyCfeL+J2EDTX1NRY0QwTq/NewzuYMeQBF3w0GrWL7jhfxy6H4EE6e/asiUbR2FRXV6upqclWAlgmANKJiQlLr+RNQ1KBPwvwE+1QRUWFeczAQiRZuiclsQ0NDRoZGVFLS4tpYojPraurM+3Z5uamenp6NDMzY8Akt7ff7zdGEY0NNxdsKmN6R0eH6XZOnz6t9fV1zc7Oan9/Xx/96EeNLauvr7dJFDzmO9/5jr7//e/r8ccftxRZgNjnnntOoVBITz/9tDKZjJXfRqNRvfbaa1pYWNAHP/hBtba2KhKJ6Nd+7ddMsf73f//3+upXv6r19XX19/frE5/4hGpra/Xf//t/N4Lg4OBAjz32mD71qU+ZEhvgPZfLye/369y5c6aHw+gL4zY/P28eVMITwYJIWPV4PKaJisViOnXqlH2BiRAmsTWXy6m1tVVLS0saGBhQd3e3tTqBsQWDQYVCITvAAYuZLviiNTU1WfUY0zzlrqurq7bOkQZCFBBtRQMDA1Yesb29bU04DodDra2tkmQYFgdUoVDQ2bNnTR+GnYZI697eXm1ublqIIkb1vb09m+rR0xUfZAD6xXpJmHn6DUpKSmwVlWRROcQewU6CndXU1Kijo0PJZFLd3d2an5+3iYrIJHoVOejPnDnzY8mcP/aDi/zra9euWYEnUxG/PCsEezQJEjws/GfEsFCWymrGTZzNZuV2u+2BXF1dVX9/v30paN4tKSnR3NycZXavra2ZdgUgHqsJViRibQDwWTlefvllhUIhtbe3W3VZcb8c2epXrlyxh48RHgBYko3fS0tLNhFEIhHdvn1bt2/f1i/+4i+qublZ165dM+vQn/3Zn+n111/Xz/7szxrYS43V/Py8JicnNTAwoI9+9KNH6rlu3rypL37xi3rhhRfU2NioBx98UP/8n/9znT9/Xq+99pruu+8+7e7u6vbt23r66af1r//1v1Y2m9Xo6KjGx8eNyHjggQf0wQ9+UGtra0okEhofHzdNTzqd1vz8vNra2qxthphu4ry9Xq/i8bhldtFehCRlZmbGmL+uri4tLS3pzJkzyufzRtIkEgnzWhYfiPg1UXHTb4DiHgU6UyBBent7eyYTADONxWKGMVVWVtqKR9kqhyU6q52dHXm9XjucXC6XYrGYBWBubGzYYQezt7q6atFO0qGuMBKJWLAjOjMOcnywSDsIDKQPMZlMKpvN2oGECZ3pbW5uTs57YYXoI9PptEkjwFqLWUQ6CObm5uTz+UzoTVzRysqKNjY2fizpEMe+KjY2NlooXDQatRuptPSwvy6RSGhzc9OoYoBKOhcJUStu6kG4SvImdCx9iPinGIvRqkAvI0wlw9zlclmoHTVWlJTijySsD5p4ZGTEJrIf/vCHhjHs7u7K7/dbsipSjra2NjMNw2Tt7+/rwQcfVGdnp9HtpaWlGhgYkMvlMlvKz//8z2tmZkY/+MEPDCN67rnn9O1vf1tPP/20/uk//af2niaTSU1OTurFF1/U9evXdebMGdOpLS8v68qVK/rDP/xDvfrqq+rs7NSjjz6qX/qlX9KZM2eUTqc1NTWlS5cuKR6P6/7779eFCxd0/fp1/bt/9+/027/923r11VfV3d2tz372s3rwwQeVy+U0PDysT33qU/rFX/xFfeYzn5HT6VRVVZX5/4htGRsbM9/d9vZhOWooFDLdEQTH8vKyMXOjo6NaWVnR1atX7T1tbGzU448/rp2dHd28eVPZbNZKTN1ut7LZrOLxuHp6esxGdHBwoPb2dvNaSrJ6sOXlZW1ubmpoaMigAzyyKP5ZI7lUigWkVVVVWllZ0ezsrK3CMzMzFlW9sLAgv99va9jq6qpWVlY0PT1tei5JplYHz4UwIjAS0oEJcHd317A02N3GxkZVVVUpHA7bJQ47jWCVwmAcD7Q5UUCzvb2tfD5v7hPYyGg0akEGW1tbam1tVTabNayQn4MI6ON8HfvE1d7erqmpKbOKsJfD7lC0iUqZdATsBzU1NXaroqim6y6fz8vtdlsQG/8MES2A9sUaL5fLZeUPHo/HokR2dnbssMTkStgdCQKYxbFYYIBdWFhQJBLR2bNnFY/Hj4QQHhwc6Nq1a9bgjKQDzILInrq6Onk8HmvYHh0dVSAQUEdHh77whS9oZ2dHP/dzP6eysjJNTU3pS1/6kpqamvSP//E/VjgcNm1baWmp3n77bV29elXvfe979ZGPfMR0RUTyPv/883r88ccVCATU19enYDCoTCajK1eu6Bvf+IaVfrz73e9WKpXSyy+/LKfTqTNnzmhoaEgHBwe6ffu2RkZG9OlPf1rDw8OSpKamJp0+fVrDw8O6efOmrl+/rsnJSVNcw9Ay6aC1C4VCevPNN+1AC4fDBvy3tbUpk8mop6fHwGB8r7RsS7L8fnyk+XzecEYOQkm2MnNJMG1Eo1FNTk4eeVbGx8cNIEdWQNsS6y8mZMS7fr9f8/Pz6u/vt0kHxT4lJm1tbXI4HPJ4POYEIFhwe3vbggthACGuYP+wDpEwwRTGz4lZPpPJ2GF9cHCgmZkZE5lyMKOPJAWV3lIcEs57HRHFTGtzc/ORPLKzZ8+aBo7f4bhfx35w3b592zKvWFeIHsZgik2BW4SHhbRF1LsOh0PhcFiTk5N2Q5NQyWgPRQsWNT8/b+N+IBAwZz4JBbA1WCT49wmAI0bX6/WaRgXgHhX93t6eifb29/d148YNDQ4OWldjOBy2tAKn06lHHnlEy8vLSiaTunXrlh3CHJKLi4uWV/biiy9qcHBQv/ALv6DKykrNzs7qhRde0MLCgn7hF35Bw8PDevXVV3XlyhW1trbK7/fra1/7mioqKkyHwwqcTCZ1+fJlfepTn7LM/A984AO2Xt2+fVvj4+OqqqrSfffdJ5/Pp2AwqGeeeUarq6u6fv26bt68qb/7u7/TAw88YOLWeDyuuro6uVwuSYdr7+OPP67W1lZduXJFIyMj2tzctGRVv99v9fBgX2fOnDH1PsQN72dTU5Omp6cVCoXsPXe5XPL7/WpubrYInfr6els5S0tLdevWLZ0+fVqlpaWWa5XL5WxNjEQixnjSeAMssb6+brrCYlEypSVIHxobG21KghGHZUZmQ8ouKbEIRn0+nzY2Nuz3hEkMBoOanp42zHV2dlanT5/W4uKikTf8O2C94F/FEUyNjY2KxWKG86EbI4hwb2/PLlDE2hRlSDKFfU1NjcWRc0CSIzcxMaFkMnlk5S4utDmu17Gvij6fz7Ce+vp6++Ln83m1tLTI6/Va1ArsDgK6hoYGqw/DakE3nt/vt+kEaprRvLq6WmNjYyoUCmpra7N+w1wup5aWliMWIZhG2LOrV69aXlVZWZndNrBj9AWura0ZPb27u6s333zTsBgiVvjZAa27urqUzWbN/tHX12epBU6nU4ODg+rt7dXTTz+txx9/XI2Njfr5n/95feITn7AQxWAwKIfDof/yX/6LPB6P/uIv/kKf+9zn5PP59Mgjj1hnIiGKkixXamtrSx/+8Ie1v7+vt956S88884xFVi8tLen69esqLy/XQw89pM997nN6//vfryeeeEL7+/v6n//zf+oP/uAPNDIyoi9+8Yv6b//tvykUClmEyczMjJ5//nk9++yzmpiY0NWrV5XL5XTffffpmWee0bve9S797M/+rM6ePatEIiGXy2UtP2+//batHkw7TM4dHR3a2NgwUSRt5rW1tXb4Ua7S0NCgiYkJayqampqyklvAbPoE19bWbH3LZDJqbGw0nyoTycTEhJaWlgysLi8vNyyRHgVU+xzAlK0Qusg6WozJIgfa2tqS3++3kmE2hKWlJdNK1dfXy+v1WglvQ0ODhVtiGqdvAV8jUxM2KP4unmsm0uIwRyAbpuK9vT1jtJkakZMkEgkbLtrb2435r6urM3/mcb+OfeKanp62sZw0Bm6nRCJhmqWamhplMhn19vaaxw3TKBlMGxsbVtDgvFecQblncQxJPp9Xf3+/YrGYgfJgE9woi4uLamtr0+bmpn1R0um0KZc51GBpeHBRv/OwVVZWamFhQdlsVpOTkzpx4oS6u7uPBNyFQiHLXQdzIBSvu7vbWpjB8jiw29ra7GdEblFTU6N//a//tTY2NvS7v/u7un37tt71rnfpQx/6kPL5vG7cuGHCwwceeMD0adiq/vqv/1rXr1/X5z73OXm9Xi0tLSkajeoLX/iCksmk3v3ud+s//+f/bNlm3/jGN/RXf/VXymQy+vjHP65PfOIT6u/v1/b2tt58803Lj9rd3TUmTZJNwCsrK8pms3I4HNY0PjIyorW1NVvTmpubbbpl9Xa73VpYWJAk01dh5CVcsKWlRclk0hqOYLy49Qk4pHsTJwZ4KWkj/GfUeAFY83sUT+Lo92ZnZ9XR0WExRoFAwHLjyQ9DZ1VdXW3gOowhYDY4KAcW0UZOp9Oq2ZDnEI1NTDKJqhwqc3NzdlDi683fq59j6uN/SCzZ2jrs9yTXi9+htLTU2pncbrcxmKS54Od1Op1W6Ax59Q+CVcRlz5RDky7jLfs6r9u3bxvTwj+P5AD8C8aGD4rc7oaGBkt3JFGBFuOVlRWNjo6qo6PDsLSNjQ37M9xut4LBoOrq6mzEHxkZkSR7CLlVoNc5zDwej8bHx/XWW29Z1Ao/J3HJDodDU1NTete73mW/68TEhAqFgjW0kDkWDAbtdofOLi8vt3TSQqGg73//+0qlUvrpn/5pPfzww8rlcvr85z+vb33rWxoeHtav/uqv6sKFCxZOVygU9Pd///e6du2aurq6jpicv/GNb2hqakpPP/20PvnJT2pqakq1tbX667/+a/3e7/2e7r//fv1v/9v/pk9/+tNaW1vT7Oysbt26pc3NTZ04cUI+n0+ZTEaxWMwsKEtLS/J4PGpoaLD3bnp6Wu3t7XrPe96jb37zm6aWLy0ttVhk57002EQiYVFGUPO0IlVWVhqr19TUZH2dDodDLpdLIyMjhvV0dnbaJUPYIypyvIUw1wg/fT6fRkZGbKLx+Xx2wUlSPp83IXFXV5eV9RIe4Pf7jR3s6OjQyMiIbRbFAH04HDZrDokSa2tr5tUEVwNTlaRgMKjJyUljzmtqapS/Fx9N7Az+ShhGcNzl5WUTuJI7T3hm/l7bFBV+yWTSbHb8306n05jG5eVlBYNBLS0tWeIK31kkUMf5OvaDC1qa6YkJiGaV6elpw1iYaCTZjYrNAR8bU1A+n1dbW5uSyaSqqqo0MDCg6elpkyoQ1QvgWllZqd7eXpWVlVmRJRPTzs6O7fv0AwLmut1uzc3NGf3MrePxeIxJ5MGJRCJKp9OGvxHhwn/f2NhoQtixsTGtra1pYGBAJ06c0N7enl5++WW9+eabxl6eOnXK8vnz+bz+/u//XsvLy0ZHf+YznzEF+Xe+8x19/etfV19fn37u537Oprb29nZNTEyYULaxsdHqq86ePavnn39era2teu9736vm5mbdvn1bJ0+e1O3bt/X888+rvb1dH//4x/XYY49pcnJSr7zyivx+vzo7O9XZ2aloNKpXX31Vly5d0muvvWYOA2KokTqcPn3aZA7PPPOMpqentbm5qWQyaQZhtHOYetGqARB3dHRYew9rFdMNE+rt27dNp4U2i3SN+vp6DQ4OamRkRDU1NRY1jNYKjeHq6qo8Ho+1T3GRwcJtbR22Ybe1tZmXlecJ0TFJCpFIxFhWjM9Mwej9iDICjwTvxQeLv5V4G0IE4vG4gsGgFhcXFQ6HlclkTA4DHFNfX3+EhUQNv7W1ZY4VcumRZSCBaGhoMDIBUSmrZUtLi0VRoYVjiuQ7fJyvYz+4GCG9Xq9hG3ilKD7gQCCPHtoXnyKZ25i1i/v70FdhqGWNQEhIuwtjLSB/NBq1ai8+wLKyMisi4GHDlJ3JZKxqjS9VaWmppQzA5BDjy4NSWVlpyaAwrH6/327xK1euKBQK6cyZMzp9+rR6e3ut6AFf5fT0tF544QUlEgkFg0G9//3v18WLFw3DkqTR0VH99E//tD7xiU/YWkST0M7Ojr71rW/p0qVL2t7e1r/6V/9KnZ2dlpZx+fJllZaW6sknn9T58+c1OTmpP/mTP9HGxoZ+/dd/Xe95z3v0/PPPa2lpSYODg+ro6FChUNDU1JS++tWv6q233lIymdT999+vfD5vqa5cSG+//bbi8bgef/xxra+v64c//KGGh4f1zW9+04otwGC6urosMliSZXyRvw4zzbqNoRurDivgwcGB2trarLK+WMjMlLa6umrN5eSsMfnk7yXREv+dv1eIguwAjRcHQCKRUHNzs0KhkGFY29vb6uzsNBjD5/MZZrqysqKamhqL/YEISKVSGhgYUCwWMwbaWRTYhzNBkq3TVPmRa7a+vq5AIKBoNKpoNGqXaHFJCiZ/571QSJqMEIUvLi7ae7O2tma5d+DEiURC7e3tmpmZUXNzs5qamkzcijbxOF/HfnChBdnZ2VFfX5+2trZMs1RVVaVcLmcrWHNzs43TrGfcwPgFoaDBs8AaaNjd3t62rjtsCDMzM9bUMzs7q3A4bKAujndytcEX1tbW1NHRYSM02h+sHkyQqVTKcBJuLcS0hPCVlJTo2rVreuCBByzTamdnR2fPnrUDjwqxtrY2q95iSpuZmdGHPvQhSyX1eDwmL+FW/OxnP6uTJ0+ajzISicjv92t9fV1/9Ed/pOeee04Oh0Of+9zn9NM//dN644039OyzzyoWi+n8+fN64okndN9992l5eVn/+//+v2t2dla/8Au/oMcee0zXrl0zdT1Z8HNzc3r11Vf1ve99T36/X+fPn1dfX5/p0CKRiA4ODtTd3a2XXnpJqVRKf/VXf6XHHntMHR0dxiiCiVRVVam2ttZEoKzaJM+S7pG/Z9j2+XyKxWJqamrS3NycMcVDQ0NH+hr5e3gWlpeXlUqlTPXtcrmUTCbt0kJ643A4dN9992lmZsbyvRAmk47Kc4G5WDoMR8QZgu+P+CPYSSY22GmwX+QdHBhga7QGcSBzSMCOcomikayvr7fJEwE1xSK4PYqtTcX+XgIEIIMKhYJNkhy6SE2IjJIOyRngkGKs87hex35wcQoXpzVi9mTKgk1kLdjb27ODC98fFVhoSfgwu7u77XDDvZ+/F99L5jiAKKWrZHahECbfaX193co7ent7TbkMKEpK6v7+vpz3OvrQYsXjcaPwueExsdbV1enixYtKJBJ69NFHNTIyomeffdZ0V+95z3u0v7+v69ev66tf/apOnz4tSRZz8/TTTxvLBHjt8XiUTCbtfWxtbdXVq1c1Ojoqj8cjSerp6dFf/uVfamZmRk8++aQ++clP6uLFi5qbmzNh7z/9p/9ULS0tZq954YUX5Ha79du//dt69NFHbWXp7OxUe3u7amtrdfnyZX33u9/Vq6++qqefflqDg4OWSS5J0WhU6XRa5eXlGhoaUktLi8bHx/Xaa6/Zl4vKuGw2q6WlJcPJdnZ2LEjP7/drenradGbQ8LQPQbKQTtDa2mo+V6fTqdu3b2toaMjMxxTFEvjIBVNfX6+RkRFVV1cbjuj1ejU5OalAIGCfp8PhsHUXXRWC4IaGBi0sLNiBubu7az9rMpm0A58mavyyxSGWYG1gYKlUyi4h2PCdnR3bHt58803V1dXJ7/dbrM7Ozo61PkmHkySQCvY6srNo2Do4ODC7ECwqekuv12s5aUxuGM2lw8MVdh2ZE90Ix/k69oOrs7NT+/v79qHs7u7aQ4suhZsQYSIhbXt7e6YqBriOx+PyeDyWxLi4uGjxJWhTsN7wd0HPIsWIx+Pyer0G2jY1Ndn4HQ6HrU7sxIkTRstLP8rPB0QF4MTVD3U8MDBg9iI0bH19fXrjjTd04cIF9fT0qLW11X5fDMC9vb26c+eOvve97xmbc/PmTT3yyCMG6oZCIcOvcrmcvvGNb5iNhgf63LlzevTRR01iMDw8rMcff9xaqilNGBwcNG1cKpXSzZs3VVVVpX/zb/6N/H6/SkpK9M1vflNVVVXmdbtx44ZefvllvfHGG3r66aetA5IbOxaLye/3q7W11aJ8Ghoa5Pf71djYqNdee02Dg4OW00ZcNRcRa5nL5VI8HreLiC/L7OysYYKsRvhGYdyQAcDIMkHjC8xms9YfWFVVZSkVFIb09PQoHo/L4XBYYitmfZJkwZmAGhYXF1VWVmZWGKaXg4MDBYNBq93DHgTgTaYXPwu5VpA0Y2NjZvQHgqC27/Tp01agC5O4t7dn28nW1pZZjKgRw7JEkQvFykyMxUmnhBqS/rC0tKT19XX5fD7TZdKSVSgUDML5cayKxx5r84EPfKCAmRRaGHaCqQqFMVQ32BHUay6XM7qaDx9KtrKy0gLburu7LWGBPxctDLhZ8U2B7AGmpbq6WuPj43rHO96hycnJIwmqrKG7u7sm5uR2xKRaWlqqD3/4w/rUpz5lKyAAOXhKW1ub1tbW9Nxzz+nFF1/U+9//fjU1NVm8SWVlpaLRqEZGRvTKK69ocXFRHR0dunDhggYHB3Xu3Dm53W7dvXtXs7OzFsxHttLZs2dVV1enO3fuKJ/PKxAIKJFIWCXb7u6u1cWTYjA3N6doNKqLFy8qGAwqHo9rfn5eL730kmpqavT+979fAwMDWlxc1GuvvaaXX35ZDz/8sM6fP698Pi/pMGJlbGxMs7Oz2tnZUX9/v7G5nZ2dqqio0Le//W3FYjG9853v1NDQkJLJpK5cuWJ4lSRjhyERJNkXhiISGLzy8nJrqAHT3N3dNYyPFc3v9xuJQkNSNpvV1NSUurq6lEqlrFcAryn1YYDTMMhNTU2an59XMBi0qOJ0Oq1AICBJ5q7w+/3a3d01di9/LwsOnAhJDUr4bDZrQmxwUVZJxKaA+qzGi4uLlgyLuJX4IMgtTOWEBMDiEm9OrI/X67VJGNytpqbGuiTxA0MgLCwsyHkvrZhnHXeGJP3pn/7pT3YhLGM7mVwEoxGeh1cMLAixaiaTMQanUCiY7svn85ltgUOksrLS8KiSkhLzYfFllmQ6FUBGwFE0YJhUeTClQ+8Y/xssjD+PeBLKBMrLy7W4uGh6H3RHbW1tloWEwbyjo0NPPPGEPv/5z2t8fNyMw16vV+Fw2CaWjo4Off3rX9eNGzds8nr77bfV2dmp8+fPq7e3VxcuXLBJ4Nq1a/rLv/xLTU9PK5FIWIFHVVWVGhoa1N/fr+HhYd24cUMzMzNaWFjQ3NycTp8+rfe///2qrq7WV77yFT3//PNaXV1VIBDQpz71KQ0MDGhubk63bt3SK6+8olAopNOnT1vhwvT0tAqFgl5//XXNzs5qfX1dtbW1qqqqUmtrq8lPmMhSqZSV2bpcLiUSCTU1NRkcgFyBL2FVVZW8Xq9pvzY2NmyKAPNLJpNqa2sz7RfrHQkP0qGUIJFIyO/3G5YJu0uRsCQTXpaXl1vOO1MaK1M+n7fQQirVmJ5h+LCUcWmTA09r1ebmpgmZkfqQ/kujNdM0olEON9bI4sZ2ZENYkPDygoUxVYJtFQcWrK2taW1tzexMHHrEUFEmzKXQ0NBgsgcE3kRYsaEc5+vYD66amhq7EaBbmSwYM8GCGGHJu2IiIkEUB/7+/r5F/KKkx67g9Xo1NTVlEgzWJTLBYrGYCT3X1tYMR0NLxGTF+EskzUsvvaTBwUHt7e3Zg8zNPz8/bxqydDqtjY0NY3qgszmk+c9jsZh+7ud+TqOjo7p9+7aWlpb06KOPamNjw8DN/v5+/fIv/7IikYhef/11XblyRZcuXVJvb6/eeustvf/971dFRYUcDofm5uYUiUQ0NzdncglEnz09PTp79qwODg4Ui8X0wgsvKJvN6qmnntJTTz2ld73rXaqoqNAf//Ef6xvf+Iaqq6v1q7/6qxoaGlI8HtfExIStQ3V1dXr00UdVV1dnotvV1VU9//zzBlpvbR02I3GLo0Eicpruy9LSUgPZCaiTZLgkGKIky4rCd4gZfmJiQqFQSF6vV9FoVB0dHTZtEPtMJM6JEydUKBS0vr6utrY2s39RP0aeFlnzXIysdxAAxcXGjY2NFskES4jHkENlc3PTGpp2dna0tLSk7e1tq7hDxIp8Q5J1MyaTSfl8Pk1NTcnlcpmAG4EqgDsYYDAYtOkwnU5rYGBA8/PzcrlcZjVi9UUgS/YWRBbt29IhHu28l39GmipaOgpmqV4jUfgfhACVuBhKC4iwWVlZUTgc1uLiojXvHBwcaG9vz/ApspAaGhrsA4FmZ5qam5sztsbhcGh6elqtra2myqcAFHygtLRUiURCjY2NZvWg4SQSiaimpsY+EFz/Y2NjOnPmjFZWVlRbW2v2IB7OxsZGOZ1Ozc/PK5vNGrjLl5Nsp1OnTunGjRsaGxvTzMyMnnnmGT366KP6+7//e83Pz+v//D//T/3UT/2UHnjgAZWVlam3t1c9PT3a2dnRz/7sz+pd73qX/vZv/9YatW/evKnHHntM/+gf/SNJ0jvf+U499NBDli0GCYJanxSNX//1X5ff75ff71d1dbVJAYLBoD772c+qu7vbfHS0S+NlvHDhgjwej/n5mJ7RHqG+Bu9gMs7f6xWQZDq63t5evfnmm6qoqNDAwIDu3r1rqyAsYGlpqV00JIwinRgbGzuSxonSnPWF2BjWr7t371oagnSIZ16/fl29vb3K30ujBddkrWYlra+v19LSkhnAm5ubLeECbIn3GqaOkADwolQqZQ3UsJUzMzM2MfOzYv6GELp586aam5tN3wfbDEZIjRxibTBV/JFEoKPh6u7uNhAenFA6BOsDgYAdqPX19VpYWFBbW5vi8bilGON5rKqq0tLSkk2TsPv0DRzn69gPLmJmWCsox0QoRxY8DymNMVgTwCnAxjjgiiOUYUtwt09OTsrpdFocCUzf2tqarYYUhXKIknAJjoX/i9UPUWtpaancbrcikYgB/Py8xKrw5UXl3tvbazlWJSUlCofDevHFF3Xjxg05nU61t7cbGP3Vr35Vc3Nzev/73698Pq8f/vCH6urq0vj4uJqamvRv/+2/1fnz57W8vKzvfve7+pu/+RuNjIzone98p62DxTVts7OzGh8f1/j4uOEdLpdL169fN3PtX/3VX1k8cEdHhxWZ4GDo6urSK6+8Yu8NhASXSH19vXw+n65fvy7pcMoeGBhQ/l6hBiAvKQV9fX12wAwODtp77fV6LYCRwwd1OYwjLBhJts3NzVpaWjIQv6ysTIFAQPl7lWMQPUziWHjAct73vvfpzTffNDabizZ/LysO/IeYaCYgJBRIISYmJjQ8PGwkD+wdaxt/NhKMiooKra6uqqury5rV2TxmZ2dNCkR8DjIbxL3FVjkIIGrFent7LRurrq7OHCjotpAz7O3tKZVKWeM1TUWw4ysrK6qrq9Ps7KwkmVkbzSPvNx2MlG0cN24u/ZhWRYL1NzY2jA4OBAKWcIoWZX19XcFgUAsLC3bY4WQHuEcSgWGWU5/0SvZ9bnqAebQoWDjW19dNssBkgF2ivr5es7Ozct7r06Mlhrww/nMORB4KgP7iHG4ilqPRqJaXl/XEE08omUwqGAzq9ddf18WLF/W+971PY2Nj+uxnP6svfvGLevXVVzUwMGCesaqqKnV2diqZTMrv9+uZZ56RJAUCAb388ssKh8OKRqMmiGQlbW5utoC8t99+W/Pz86qsrNRXvvIVY8nOnj2rlpYWOZ1O9fX12XvrcDhUW1uryclJLS8v23qJxUqS9VsWCgUTtNJW1NfXZ/lMHR0disfjJiKl9ALDMp8Znwm4Fpgnzoa1tTUzM1dXV9ulgkyB9wqwni8SuKbf77dVsjhCmzgWpm9U+jBz29vb5qPEzuXxeExYWl5ertbWVgOo5+fnrQWdUo+6ujrLr0LHCJG0urpq08/6+rpdPDCMTMy0q/Pzk2jCAQmmx2THSk0yRltbmxn8UdnjIyZvvqmpyco56CNgGlxYWLDcNwpDurq6jBTBg0xC7nG+jv3ggtEisgNnP3YB8obKy8tVXV2tV199VWfPntXS0pIlL5KjTmB/Mpm0WqTiW41bHBEfjJ/T6TRfIKteTU2N2SwA0rF+sMbyM6K8l2QfIDYI1MikFdBCzQHGgcwUwyEOs4OFpbe3V/v7+/rn//yf6+WXX9b3v/99VVVV6fz585qbm1M4HDbLEiD/8PCwXnjhBX33u99Vd3e3vF6v+vr61NLSomw2aw/9M888o8cff9y+qGB6DQ0N8ng8CgaDR0zheDGxs1y/ft3CGSUZdoNgMplM6sEHH9Tw8LDm5+ctlDGVSlmzdT6fN2wSfRBCXtb44lgZ1lzYT3yJRKwgkyFnHta5WLTc3NxsU7TP55Pb7dbY2JhOnz6tu3fv2mfHRYNY0+PxqKWlRWNjY1b8QVw4wYI8z7CaWMQoQUHzBqA9MTGhyclJ68rc29vT0tKSHQYkjkiHLCp58fyMXLb8vvX19fZccpCz2vM5kVzC51mMDTMtF6ebLi8vK5FIyO12GxuKDIfvxO3bt+19xQZV7POEjDvu17HLIcLhcAGZwsrKirElqNu3t7ctcbStrU27u7v2gXGbwcAUTzWFQsHG08rKSsXjcYsJ3tzcNHGp1+vVrVu3LFeLxp1iIB66GjwHxiSbzaq7u/vI1MiEtbi4aLYcUilPnTql06dPa2VlRQ888IBNXBy0CPT29/f1pS99SS+88II++tGP6sknn7ToabCUr33ta+azfOKJJ/TQQw+ZJg6At6WlRVeuXNGXv/xljY+Pm5L7s5/9rDVZUyaB2Zl8/VgsZkkb0iETFQ6H9YMf/EA1NTVqa2vTysqK6uvr9Wd/9me6cuWKMW0f//jHLVee6RQFP3o7jLd8IV988UVNTEzo3Llzuu+++2x6iMfjisfjkg7LYzFI19XVHZnuEIuiXoc1hPxgikctj+6LVTWbzaqvr0+xWEzhcFiSDIBH3AuBRGYcGezSIf6D3k6SXC6X3G63MctYbWDIed4ODg67MAOBgPUyYhZnaqEMhsIMBNFE0CDtYKpBRgEOtrOzo8rKSrlcLttUeM8aGxu1sLBgl0Qul5Pb7ba1m4MLHRg+YAITU6mUlcEWC3ArKytNy4iGL5PJqKSkRF6vV3/wB3/wky2HIIFRkt1+4Fs9PT26deuWiRRpmW5oaFD+Xl7Xzs6OJYTCOPLgkt6YyWQUCoW0ubmplZUV+f1+NTQ0KJVKWYMPK8XCwoK1xsCMAKYWNwKHQiHDwSgkqKurM90UOVpgHg0NDaqoqFAgEFBnZ6cCgYD29/eVzWbt1kbzIx2q4l0uly5fvqy6ujqFw2ETsTqdTj3wwAOan59XJpPR17/+dS0uLurDH/6wBgcHDY9zOBx66KGHdO7cOf35n/+5XnvtNeVyOf3hH/6h6urqNDw8bD/Lo48+apMPOej8XdzIs7Ozuv/++22dWV1dNTYulUppZmZGuVxO4+PjOnXqlFZXV7W5uanu7m6rXGMiLikpkc/n0/z8vKLRqE1JrPjd3d3W3NPf328HFdlqXFTd3d1mkAZzAzzf3Nw0yQBuAr70e3t7amtrUyKR0Orqqk0R1HOhq+O9RNNEfR3meLx3iGMpl2C6puKeTlDpUItGixTYZCaTMZyWS5zoGRp7sHnRV8DBj7Kd6QtmHvyLJp/5+Xm1trZqY2PDAv/QETLFsh6ura3Jea98hhBMVlWkKeB2qVRKgUDAsu7AIBFwRyIRDQ0NKRAI2MR83K9jt3FTTCDpCPNUUVFh+fL8dy0tLVYSipodOQKrBB+IJBvRid5Ajb60tKSlpSWtrKwcoZ0xvm5vbyuRSFjJA4UD+/v78ng8ZsIG82C1kmT5SHzg3Di0PN+5c0d9fX2WsOrz+dTS0mICSZfLpba2NnV1dWljY0NLS0v627/9W1VUVKizs1PDw8NqbW1Ve3u7fvZnf1YXL15UWVmZXnjhBf3hH/6hvv3tb9ukClZRU1OjT37yk/rjP/5j/fIv/7IefPBB7e7u6tVXX9U3vvEN/fmf/7m++MUvam1tTel02tjASCRikSYVFRXWdYlxmYgZp9OpCxcuyOfzqaysTPPz87p9+7ZNzcVNyisrKzp79qwcDofGx8eVSCT0+uuvK5PJmCi1pqbG2qlp8CHqGuyNaGbWTVYkVmtA52g0qv39ffX09NgFxBcLHRIyhsXFRfn9fiWTSYMwiI0Btpifn1dZWZkmJibk8/m0vb1tz9nc3Jx99pWVlZZFNT4+bmGUfKErKiqsrDibzaq0tNQSJwjsw7fL//A+MLnyTCKnkGRAemNjo8UzQziFQiGbuFj5Ozo6FIvFrGAYPRi5XcRdA2vwnSHaGVY/mUxKkvmJmeDW1taskGZ7e9tsbMf9+rHE2vBmgHegOMfTBF0Mq0L/G0AtYCNyBA6rg4MDSw7o6+vT2NiY5VgtLCzI5/NZKBwPA0JBcsAYtyVZGuXu7q4Btnfv3lVbW5vy+bwZSOfm5iTJyIBi/CMSiSgSiainp8eAVnyaTIvILpqbm5XL5azFJRwO69KlS2pra1NTU5MCgYBOnjypwcFB/f7v/77eeOMNpdNpfec737G6MG7Q5uZmud1utbe365/8k3+iS5cu6Tvf+Y6mp6cVi8X0xS9+Ua+99poGBgYs0HBwcFB9fX1WjSbJ/jfixP39fS0sLKiurk4PPvig1aclk0mLrCHmRzq8gC5duiRJunnzpjG573nPeyxq2+/3G74jHX4ZysvL5ff7jZFiEif9FjU30S719fWam5uzLH9iXxAnk5kOo4Y0hVYh8DCEycgtSFvFNcFBxyqGfAB5Q3EjN4zn7u6uTWzIRhoaGnTjxg2DSrgQOZBg2sHoeJ6QWMAo4ttFjuPz+cyrWWy4LnYikMOP+r04Osrtdisejxs5UFtbq/n5ebN45fP5I7pEYqrRT87Pz5uVCPEsborjfB37wUVETDgctjcXSpYDjKpv3jyXy2WUK+wJAD9FnyifSXLk4QR3kGR0MHIH1gv+bnZ7SjQjkYjC4bA9vLFYzKqesHXwz7D6MIGhTvb5fDp9+rRmZ2ftSwMAjb7sxIkTGh8f18DAgF599VUVCgVdv35dkUjEcvZpdnE6nXrf+96ng4MDffWrX9XIyIiy2az+4A/+QB/4wAfU09Oj+++/36ZZ1oHh4WE99thjmp+f17PPPqtEIqHbt2/rpZdeMkLE7/fr7/7u7/Tud79b58+fV3l5uRWARiIR6/iDsm9oaLC1u6SkRJcvX7YGZyh+WLmVlRUTKw4ODioQCMjj8dhBd+fOHblcLisCJjMKO5Ik003B1nGZwNz5fD6l02lLP+3v7zczPdolAhNnZ2f14IMP6vLly2pqarK0BexSdBQAJzgcDvl8PiUSCYVCIeVyOQUCAS0sLCiTyZimChaWXDimYA5d/HxjY2P2LDLFFWeGIRUidYLnnkmIbkVJxsSWl5fr+vXrGh4eNugDrC2TySgcDpuuanJy0tY8OhyKk3anp6fNg8hzTbv67du3j6SqorUEq6YRC+yLjeg4X8c+0w0MDJgkAJwI4RxNP6QugBOh5aGCDFq8oaHBvtjcmqRuot6dnJy0GGBoZ6QS9BaSpyT9CPSFZYvFYoad8SoUCvah8sBvbGxYSoXH4zli2J6ZmbGaqKWlJY2MjFhCJXoidFb8DFtbW3rzzTf16quv6uWXX5bb7VZzc7NlkL33ve/VL//yL1tiw/T0tL773e/qv/23/6Y//uM/thKEnZ0dS0iYnp5WV1eX/u2//bf6l//yX+r//r//bz3zzDN2uBUKBV25ckX/7//7/+pXf/VX9frrr0s6nDzr6+uVSCQkHep3AoGAqqurdfPmTb3zne9UX1+f2traJB0muU5NTWl6elp37tzRtWvXFI/HVVNTowceeEAPPPCAampqbIWm+dntdqurq8u+kA0NDfJ6vSamZKrhfY/H47YiI6hEFoGdhemJlAZwLYScpCYUm5Zpy5mcnFRlZaVaWlq0vb2tiYkJswnRWcBzSqDl2tqaAeWkwILZArzTNL2+vm45dMUiZ3yBmJ15VjjUkIrU1tbaxQKgD74IqE96AwUjhBSSIc/36uDgQKlUyqYq+gPKysps65EOL4/i1GIOfQIRC4WC2aXW1tbU29tr0/dxvo6dVXz66acLExMT1pUYDoctYqP4hVizpaXFWELUy9vb2/J6vVpcXNTBwYGxQrlczqqS+AD4c2EJ8V+Vl5cbK4bFgQhbRKqwNTSfkOMEswWgOT8/bzlR+Nfq6uosr+rChQuGtbW0tOjg4EC9vb32oFy9elU1NTW6ffu2vv71r5s1iJKCtrY2/dIv/ZLi8bg6OzvNH4Yn7y/+4i909epVY9lmZmb0vve9Tx/5yEdUXV2t8+fPq6GhQZFIxA78XC6n06dPa3V1Va+//rpee+21IwLIa9euaXFxUd3d3Xrqqac0PDxsuCK3fX19vSYmJqzK6ubNm4bloYFramrS3t6e5ufn9cQTT6i9vV0NDQ3q7e1VIpFQJBKxz4mI4BMnThhAjsfuv/7X/2q4CmJU8COSGQCXWadgCbn5mWQ4SIigqaurszWTdRu9XzgctkDL5uZmzc7Omv+VfKxEImEXL6p3GGEsX3z5+fmqqqq0trZmqxWaNYIps9msXeD8zB0dHRofH7cVG2kDqyH6RJTsxdE+brf7yD9PeCG6PvyY6XTaIBnSa0OhkIUI7OzsmECcCPCKigpLBJZkUysTZllZmf6f/+f/OVZW8dgPrvvuu6+AtgfBIJS2JFuxMNdiTcE6wfpAwBttP0ShcBPBupAiAOjMwYIokAeEELq6ujqTUsB+SjKxHlgJtyo0Nw8EzTNnzpzRRz7yEesYBIgPhUKm+QFLkw71R3fu3NFf/MVfWBora6h0aN+5c+eOAoGA3v/+9+vRRx81VrJQKOh73/ue/uiP/shy2uPxuIaGhoyOfvLJJ3XmzBlTQLMOB4NBra2taW5uzh7ukpISXb9+XV/+8pc1NTUlp9Opf/bP/pkuXLigxcVFLS8v68yZM6YzcjqdikQi5ickloWcKUzIra2tlhWWzWZ1+/ZtLS8vG/bT2tpqUxdfTvReo6Oj+spXvmKpHqQrVFdXy+12mx/w4ODApAY1NTVHQiphr4PBoNH4SAFYJznoAKCHhobU19enmZkZBYNBs6GBDZHwgTIeiQNSCDBSvuxra2t2QABz0EJEWxCWuI6ODttMYHybmpo0OztrGBW2Hso8igMO4/G44YWRSET9/f0WIUX7D64OnCB817LZrNrb280LyYSJrAgBK/E9PAf8mRAY7e3tWlpa0u/+7u/+ZMshUHEDyksysSc3CxQxkgXytjDLLi4uWu04WVrcuID6kgw4JU2SEo3/9cGMRCIWnUIpqSQLdyPFANyIsR52cW5uztTMTBn4usLhsN3u3GrQ+263W2+//baVhj744IOanJzUzMyMHnnkEdXX1+vGjRtWrLC4uKgbN26YV45pcWBgQD/3cz+nhx9+WL/xG79xpDi3UCgom83q7t276u7u1i/+4i/K6XRa8e7c3Jyy2awuXrxoa+Xe3p7C4bA+/elP68///M916dIl/c7v/I5+5Vd+xRisK1euqKWlxVa24eFhM9WiJcLSwsrf0dFhh+03v/lNjY6OWorDY489pocfflilpaUWUZRMJrW8vKxAIKCGhgYTc/IlhhVD+kCcdjQaNakCGAtptOBfm5ubCgaDSqVShsexolJzRj9jNptVR0eHpqambNoG4G5vb7cvfiwWM08mFykxMUATZWVlGhkZMRcINWrAJLlczrCs/f19m/CJT2ZSK54YuZjBq6RDcH9oaEiJREL19fU6efKkEQb8uWCHHJZMsQiv8fcy0VVXV9u6TcrI/v6+/H6/rcwww+gFabY+7texH1zgRXxIWBBisZg9OFRMYSdYXV3V/v6+fD6fZQ7xgCKCo0aJQoLl5WWrLGe6AMdA3+JwOBSJRFRXV6fTp0/b7l9bW6toNKq+vj6dPHlS09PTZmRNp9Pq6OiwUDboclwAra2tcrlcGhoaMi8luN3CwoLKy8vV0tKiqqoqXb58WVtbW8rlcjp//rwWFxfV2dmppqYmdXR0KBKJqL29Xfl7eefoaq5du6bh4WGLFqbhJRAI6Atf+IJ+8IMf6C//8i/15ptv2gG2t7enfD6vX/mVX9EnP/lJPfnkk6aOrqur040bNxQIBGxFra6uVkdHh1ZWVlRRUaHLly/rz/7sz/Sxj33Mii9YY9xut65evWqXSXl5ufk2sYOsra1pZGREV69eVTqd1t27d7WysqL77rtPH/7wh1VTU2OlqYg2+dyYrGDQYGYRRjIFE5KHZYiJC9YMzaAkkwdwqMEAlpeXW/cgkxaVaSRQ0BaNnQr70f7+vkKhkElMsBtRNQZ+SksPz/fKyooF88GQVlRUaGlpyUBwvhOpVMpCElnpYBzz+by6u7ute4EqQPLjJamrq8smfoSplMJQOgypAxaMHAVdI5Mp0AzfWaY7WEz+HFwNx/k69lXx9OnThc3NzSNFmehnPB6PebAY2Xd2diyGlocYcRy5VhRTchtj24GCJvOr2E5CJId0KNEIhUKan583GwYPOOxOIBDQ4uKiAY94GmGX2OnBuTo7OxUOh9Xa2mqVWBQd1NTUaHJyUoVCwYR8xUbh3/u939OJEycUj8d1+fJlxeNxnTp1ShUVFYpEItrb21Nvb698Pp/5G3/1V3/VUhTwe/6n//Sf9Pzzz2t/f1+nTp3S2NiYFhYW1NLSovPnz+vs2bOqra3VmTNnrOQBv2exL6+6ulp37tzR//gf/0OTk5MKhUJ68MEHzXd48uRJW6tJ4Nje3jZZyMLCgm7dumWtRzgNOjo6NDAwoHPnzumd73yn/H6/crmcZmdnLRMKXRU6tNHRUaVSKctuhwnkeZJk7GJbW5v1F2KkRtDJVN7a2qpkMqnOzk6bVg4ODuTxeFReXq5EIqHOzk4NDg5axRm2HTyQZFehDcPaAyTBn4lOT5IdEJS8tLS0GI5aHCDgdrttBeVAJR2VogwOhsbGRsXjcXV0dFjMEpcdgZHFRAXfneItAzcKl04xIYCeEniFlA3eeyxFlZWVtsbCYv77f//vf7IxrgceeKDAZMWtwcHDPo8sAroVdTKHE2JDDh4ebsZgMC5AWIy82E2wABUfnltbW0Z/w8Zh4Ha5XFYzBaZAimksFrNEVMZ6Ym8//elP69SpUwaAEhOMvgizLwkNWDJef/11m3x+67d+S+l0Wg8//LDKysr03HPPqaKiQr29vQqFQnr55ZdVVlamj33sY/rgBz9o6v2BgQE5HA5dunRJn//85zU8PKynn35aX/3qV/V3f/d3ZjV65JFH9C/+xb+wW760tNSKKZaWltTa2qqxsTG1t7crGo1qZmZGzz33nGFara2tunDhgoLBoAKBgCYnJxWLxewSQVRMEsaJEyd06tQpDQ8PK5vN6tKlS2Y1eeCBB9TZ2algMGgHJ8wgONfs7Kymp6etWAXCZWdnx/RWCwsLFqpXW1trtWPZbFahUMiIl2QyqcHBQaPvMVyzHtF/MD8/r+HhYZ0/f97KXEpKSgxGQJeFMwIt39ramtlqMH3X1NRoenrafKHgrshxJBm5s7OzY1sCBnucGWBpTJ9bW1vGriPOBY8rFAq2juKhJN0ilUqZ6Z2LoFjsSg4emCISF74LXAAQAvzckDcY+f/kT/7kJ/vgOn36dIFwNX5JDNVoblKplDo7OxWJRGzMZQrgQCEuF70MBxztPLCH6IzAQgg4k2TjcE1NjYUEctvykGC9IX4HXRLTHumbZWVlNroTQvjQQw/pzJkzpmZm5WhoaJAkY782NzcVCoXsYMb3mE6n9cILL+jtt99WKBTSE088ob/927+1dAJuxLKyMi0vL+sTn/iElSicOXNGPT09Frf7d3/3d3K73Xrsscd05coV3bp1S1/+8pe1vb2tc+fO6ZFHHtHy8rKGh4fV3d2tQCCgvb09y18nZG91dVXpdFrRaFRTU1O6ffu2SkpKNDg4qPb2do2Pjysej2tpaUmZTEbBYNCKN9xut86fP6/a2lqdOHFCuVzOUlrRJ7W3t+vRRx/VqVOndO7cOcViMasY29ra0q1btzQ6OqqZmRkLIOTgK04raG5utvUaCxXyAih9hMnd3d126TFBIMHgs25ubtbQ0JDq6uqsyowE3+XlZSNf5ufn7RJjgmWN4yCAWeQZYEXGAgejOTk5qe7ubsOjiqOXWMPoLkSjJsmEzVziCEmTyaQx84iUwaAQzVJQg/wBLVpxGS1YNAMIh2oxAyrJvmdut1u/8Ru/8ZN9cLW2thYozAQMZM/3eDxHwtC4QTo6Oo5Q4cXiVPbpXC5nuUhQtKiUy8vLLXoYNg8LEbt7carE7u6uGbzj8bhKS0tNCoGFAqyCQ5O8qt3dXSMUiCcmIXN4eNhuY1gZh8OhlpYWM3Ovr6+bGpwH6fvf/76i0aje+973WkKqJLNv5PN57e7u6ty5c3riiSdUKBTk9/vV399vUcOLi4tKp9Nqb2+3ifaVV17Rs88+q0uXLtkF4fV69e53v9sKPNxut1paWpTL5SzTieKPiooKA6RJusTbh/0DoSl5aQMDAwYY87C/8cYbevHFFzU6Omom6ccee0wf/ehH5fP5rDh1ampKqVRKV65cMQYMV8Py8rJcLpddbFNTU3I4HHLeq2wLh8MaGxuzMg5J5hmk7RxyASM9AYgXL17U+Pi4HA6HHXK0Ce3t7SmRSJiTgyo0RKV8iQkIKO4vBFyHiQNjYz2HSMjfy8ZnkkQsCnbJ4STJDhiy6DgUgQAqKiosKZW1Ds0YZnTWVEpuE4mE2b4oIMFC5bzXI4B0CB0dqyb2rz/6oz/6yT64enp6Cnt7e8ZawAIWu/wZVUmLJGoWhTy3JbdaKpUyU3VxDAujOaJVJiyXy2W4kiTLridQ0OfzWbsLfYDUT+HJ4nCUZAkU/FxEQj/wwAPa29vTmTNndOHCBdXV1VkHIEwn60QoFJLT6bSmo0wmo/X1dTU3N+vKlSuKRqPq7e1VLpfT888/r0wmY0Wyly5d0tramrq7u3XhwgWjy5966ikFg0FT3DudTsvtx4guSa+++qp+8zd/U5OTk2Zh6uzs1FNPPWVdkGfPnrWDgZUGvyciTzoKebBhdIkWam9vtxhpvJrJZFLd3d0aHR3V9773Pb300ksm+n3kkUd07tw5PfbYY9YNeOLECb3yyiu6fv26VdOXl5cbEF684qNSZ7XGiL+ysnLkwuJ529raks/nMzFlU1OTTWfIDM6ePWtCUuQsML7EAM3MzBjkAdZUnK8F61asT8TUXxxUODk5qZ6eHhOcklqBfoxDiYm7vPywBZuhgMO3qalJGxsbymQydjHwMxAXBQSCO4XvCxc+nl62BdwW+EZpc8Iv2tvba3impJ98HdfQ0FCBhx0BpfNeJyHZXORaFwcN8iExirKqEYlbX1+v+vp6Kw2Yn583QSJ/JtaEaDQqj8djDx6Bgh0dHSYwBPDk4UWdHQwGtbS0pI2NDVstUSavrq5qeHjYGnqkwwq0D3/4wxoeHjaGbnV11YLpKisrbWrq6ekxG0ZpaanS6bTcbrdmZmY0Pj6uQCCg2tpafetb39Lzzz+v7e1tffrTn9Zbb72lV155RWVlZbpw4YJSqZQikYiGh4f1xBNP6M6dO6qrq9NTTz2lkydP2kNHxPH+/r5mZ2f17W9/W2+99ZZu3rx5xMfZ0dGhhoYGfexjH1OhULD0ht3dXSWTSdMp8XcDynPIk5vG58FKRF4ak0dJSYm+9a1v6W/+5m+0srJiYt2PfOQjGhgYsAn8xo0byufzSiQS5nJgzSY6qDjYERCcDsV0Om2TPocUP6vb7VY2m1VTU5O6u7sNigDz8/l8pr26deuWYaiSDDLAtwkrW7waSrL3lcsXTJZopVu3bmlwcNBMzajQSXONxWLq7Oy0+B/IJkmGY5Fuu7X1o35RVmOq2rBVUVgLJIPUh64FnApMakyIlH6AhfK+EckUDocVj8fV2Nio3/u93/vJ1nHBehUfJBxQTqfTsKbq6mprXs7fyyriA5cO85CobMKkOzExob6+PptGuIm4aRHGtba2KhaL2cTAzRuPx40RYwRPJBJ2aFLOIckU+fwuBwcHOn/+vJz3QtPa2tq0sbGhbDarW7duWWa3y+Uymp4o4UAgIJfLpUwmY8LbqqoqW2cdDoe19wQCAX3mM59RKBTSc889p/r6ev3jf/yPNTs7q0gkovHxcV24cEGrq6saHx+Xx+PR3bt3dffuXUWjUX3gAx+wDHu+6BAEv/Irv6IbN27ozp07unTpklZXVzU2NqZIJKKSkhJduXJFTqdTra2tCgaDunDhgn1JT548qWvXrlmSAmJQr9erUChkXzhC8jjQ9vb2LOBwdHRUTz/9tJaWlvTss88asB+NRvXggw9qbm5OFRUVZr5mmlpeXtb29ra19WCYh40LBoPa2NhQMplUNptVW1ubreS0QRHvjBWGixETMQcHAPXm5qZcLpflu8/NzZmFDUU6BcKIS1H6b25u2uSDKh0G0uVyWWM2F119fb0xhnt7e6qsrNT8/LxKSkqMoMjn88rlcnbY0o/ItpDL5Uw24vV6dfv2bSPAMK3znnHYcTiCEyNO5vMCZ0O64fV6dfXqVZ04cULl5eWmd/xx9Coe+8ElyVJMiU8GeCftAVyEW0mSAfPoRWjEZlff29vT+fPnlc1mLXfqpZdeUigU0tjY2BHxXCKRMKM22fCSTDwJ1lRVVWWGWjQ/qVRKNTU1CoVCampqksfj0QMPPKC5uTnt7e3ZynHnzh0zZ/P3YpXp6OjQ4uKiMpmMqqqqlM1mtby8bKtUIpFQa2uracKK69rQ0Xz0ox+1COnh4WF9/vOf12/91m/phz/8oRobG9Xb26vnnntOzz77rPx+v5qamvTcc89pcXFRCwsL+qmf+ikDYYvjg6g5O336tAqFgl5++WW99NJLZkomzSIej+u//tf/qv7+fstIQ6c0MzNjRagNDQ3q6OjQmTNndOLECXV3d6u8vFyzs7O2ZqLm7+zsVElJid73vveppqZGzz77rNLptDVQU/hBgQZf6pKSErtguJxoiAoEApYYKx0G/k1OTprOa3NzU4FAQFNTU9ZCNDc3Z92akBsnTpyQx+PR/Py8urq6jKShdJdoF/R8PLfEHWcyGTtsEcMiUi4pKbHfA0a6sbHROh7Bnpqbm61yrDg1hQQKDmjEuJLMWcLhQw+iw+EwXBaNGDBJcWM22wr2Kf4eCK/8vVq2dDqtXC53JHV2cnJS9913n+HTx/k69lXxySefLNy6dUt9fX32i5JTtLe3Z5HDy8vLJuwj9A0V+PLyskUFc9gB3vb29ur+++83MPrOnTtqbW21ZMpikyqTGdgIhtZcLqdQKGQfNPVR3d3dkqQzZ87o9OnTZnUA+8rlckqlUjbNINeQpHe84x166qmnzGayvb2tzs5OXb9+3VqBpqentb6+bllWyCSIK+Y9QALAukec9NbWlj71qU9pfX1dP//zP6+vfe1rdqCsra1pd3dXq6uramtr04ULF3TixAk98MAD1jJdUlJilVms6FDyN27ckCSdPn1aOzs7ev311/X666/b1BONRpVOp9XT06PZ2Vn7OWloLhQKeuihhxQKhdTf32+MpyRbn/GQlpWV6c6dO/qjP/ojjYyMqKamRh0dHfqpn/ophUIh+5kSiYTKyg7brFn5sBD19fUpfy+CBcU9CSMIaNPptA4ODqxBKJfL6b777jOgHrEzGq2+vj6Th1RUVFjtXT6f1+bmpl2GKM/n5+ftuUHGEIvFzGZFei4pqzCHNTU1crvdhjUifQD0B4DnvS9uUSeDDLKF6Q9fIekewBA8r2jEcAawxtfU1NgmgtSDw5cpsbe3VwsLCzZRxuNx9ff3KxqNWoDn3/zN3/xkY1wnT54sLC8vWx06oGJZ2WFdud/vP7KyATCiTkcVPT8/bxMQgsBsNqvm5mY99NBDkqRYLKZsNmv1YQTbwXyFQiGbpADGsVSQJc6I3dXVZSsdVehE38B6kYZKeYHL5bKbq6WlRU899ZQeeeQR6yAcGBjQ+vq6rb/cyBTRVlZWamJiQoODg+rp6TGbFNMgq3P+XjInyQSvvvqqenp65HK59Pu///sWfwymwWrscDj0yCOP6Kd+6qdsbdva2lJ3d7clGADGSoeJqPhI9/f3bfXC+/j666/bl2hxcdEmmXg8bpfN5OSkLly4IIfDoX/1r/6Vurq6rAvy8uXLZiGJxWJ69dVX9YUvfEEHBwfy+Xx68MEH9bGPfcxqyDKZjNbW1hSNRo2pI5QPoNt5r28A7LCzs9PInMrKSrvcHnnkETPUYxoPh8Pm0wOjQ/9XWVmpt99+2+K9i8t/mZwbGhrkdru1tbVlzU/E1GCZQRMGnkfZBYmoJDAUl7OiQ6R4lQMMyw/uAzoeC4WCuru7VVZ2WN/H+goryJ/FBQdTyPvBZAZTysTI2soF7XA4jHCgLRxI5T/9p//0k39w7e3tmZu8UChY2y9qZYLTYDwcDofGxsbU1NSk1tZW1dbW6sqVK1peXjbnO7dBoVDQk08+qWAwqFgsZtlZ6+vrBq6idyFDiyQK7EM8nNPT0+rp6dHTTz9tAOnCwoLpdCAD+NCJkmaNaGxsNGaNGJjBwUE988wzSqVS5uGjJIPESr6QiAopU8VGg9QD5kj6kZVKkk0RWEP+x//4H7p8+bKWl5cNmMZNUFFRoa6uLn384x9XbW2t/H6/pTJMT08bMJ+/l4qKhi4UClkh7Nramh3WfOE4+PDxvfXWW/rud7+rq1evWl57R0eHPvShDykQCKi9vd1itbkIrl27pn/5L/+lCYOdTqceeeQRU+qn02lLReWySyaThqGxrgI6894gUdnf35fX69Xo6Kgxf5ubm2pvbzfCpbq62g7jXC5nFxdxzITxoemrqqoypwfPB+Wvxd5Java2t7cVCARMvY/olimV52BnZ8e2EmJokN9QrdbQ0GB5/8h+/H6/xUKtra3ZoVps2p6ZmbF/hyjtg4MDm/r4vPi9eL6BX7CIgUPTctXZ2WlFMT/xrOLjjz9eGBkZUTAY1OzsrLxer4aGhoxtAuhraGgwDKBYG0KRxbe+9S2zdHArwCCB0+AzS6fTymazRgxQ3U6SAbVOvPnUaHV2durxxx/XzMyMRkdHTYcTCAR0+fJlbWxsWGEoVgridlDtl5YedkNS19Xe3q5PfOITOnnypIkXSTMATGbtg7anZko6XFNh4ABSAYQdDofZYZz3Gl9QZV++fFmbm5v667/+a129etVsL7wf73znO/X000+ru7vbzOIHBwcaHBxUQ0ODbt68ac3clJKwdpWVlRluCINGpEtXV5cJNimR/fM//3PDRAYGBtTV1aWLFy9qcHBQnZ2dGhsbs6ngW9/6lt588029+eabGh4e1vr6uj7zmc8YWM37Ozc3Z/jQ4uKiQqGQSRioyEIaIsmikjc2NuxzQ7rAe3twcKBTp07ZFAce53K5VFZWZs1JxEtPTEzYIVtcmkFWFwc7K2UgEDBpAiUV9IoW+wlhQLmMstms6Qc3NzctDoekCoze+XzeiKOSkhKbqC9cuGC478HBgYLBoNbX1w2TJMuLWjjKX8Du8IPy3KOLK5Zh8Hsz4X3hC1/4yT64gsFggTGdJEeKJopVurA5CEOhV7e3t/X8889bcQYBcozL0L4DAwO258Pa4Jvr7u62xmseGOKiMXRXV1fr05/+tEXGVFRUWPHC7Oys0fhMaozteBwRj5IKkU6ntbe3p1AopPvuu0/ve9/7zBNJ8FsgEFBdXZ3d3JQUVFdXa3Z21hjUUCh0pLkFpT1q54qKCs3MzFhc9PT0tDwejyoqKjQ6OqqvfvWr+uEPf2gJmQC5H/rQh9TV1aVLly4pGAzaLY8qfnZ2Vh6PRz09PdZ1ub+/r87OTlu1eWgB6sFw0Aj5/X5973vf01//9V9bzRlr/tNPP60zZ86otrZWAwMDKhQKWlxc1F/91V/p+vXr2tnZsQz7++67zzLGNjc3rUEbt0Q6nTbSh4r54phuLq3W1lbDs/B4MiV7vV47VKjySqVSam5uVnV1tbLZrObm5jQ0NGTrPvYY/jywxbq6Ovt3Dg4OrN2Z7xsHBmUYwAYcCqxv5NGRjkHoIJ5AxMBMS2iwijWIHOjF6Sf8mbQzMfm1tbVpfHzcmuNJSKXEpFg2Q0Is8enYkba3t/Vbv/VbP9lyiOrqagOC6WMDCE6n06ZM5o2Ym5szGw7Yls/ns/p4Dix2/Gw2awcKyaPhcNjyzDs7OzUxMaGBgQGrEMe+wQqJCLCurk537tyxKJ5oNKpMJnNEXQyugrIY3UoymVR/f7/lgSOvWFhY0MHBgZVvsPqurq5aBDBMIrXstOXQtJNOp60qzOFwWAolZl00QTBSsHXb29t6+OGHNTw8rG9961v6+te/romJCUmHX4xr165Zaucbb7wh6RC3ePPNN/XzP//zeuONNyz76YMf/KDd0uSe7e7uqrGx0YDq/f19kwtgJVlZWdHFixfl8Xj0p3/6p7p165YZtL/2ta9pZGREH/nIR+R2uyUd+vZgbcEKySsjmaJYy8XhxiVYW1ur9vZ2W5+rq6uNkQZDKhQKam9vV0lJicbHx9Xd3W04XVdXl007HGBINLxeryX6AnGAM3V2dtoKCUaVvxdmCQtOPBHTHwdoS0uLrWTIStgYgsGglcbw37H6S7LEWIpZ0GiRcEtGWFNTkyYnJ23aCgQCSiQS5uDgcIvFYibZINmXElmn06lsNqtcLqe2tjZNTU1Zyi9DAVDMcb+OfeJ68MEHC+i2Tp48qfn5ebW3t5vydmVlRel0Wq2traaix2lfW1urr3zlK7b/YwTlA5ZkhZWDg4OGYW1vb6urq0t37twxLMDr9dphJsnaq+fm5lQoFPTud79bTU1N+t73vmdFHCS1UmZB8B4ZRthOyFQiOpeoEXyYjz76qLq7u/We97zHsrEQBmYyGcP6+DNra2vtxuN3XVhYMPnGww8/fMSnl0ql1N7ebl8GjOX8PfgG3377bb322mv69re/bU6AUCikpaUlzc/P222Nlq6trc0KXsPhsFlRBgcHFQqFTIbB+tPa2mqaIA4tpqHq6motLCxoZWVFX/va13T58mVNTEyosbFRZ86cUX9/v02Qp0+f1p07d6zSCzZ6a2tL586d08jIiJmuWTHRJlF7VxwqCDNImCVAtaQjtXZlZWWmoIeJ3N/f1/T0tDUTIQYNh8OWaAuADsMG48dBQ9ICEdLYhPb399XY2GjgfXl5uU01HAR89j6fzw5oh8NhpcAdHR0mDaG9u1AoqK6uTuPj4+bsoMaNYhOereLGHnoVgUFgGJubmy17H5cI8AaMJxd6fX291tfX9fu///s/2atiS0tLob29XSdOnDAjKJQpth+C9UiCwEw9OztrYJ8kC/CH4p2dnZXf77dVs6qqSm63W8FgUPF43GQD2WzWVgaHw6Hq6mpTITNddXd3a2ZmRrdv31YoFDJpBuM+ICc3P4kSkuzvJsKWLwUm7K2tLX36059WZ2en/H6/qqur1dPTY4USaL7q6+s1PT1tav2WlhazfaTTaev3SyQS6urqknQ4oXBD+nw+i98B4+DLgAShrq5O3/zmN/Wbv/mb2t/fV0dHh62m+Xxefr/fpj2Xy6VYLKZMJqPu7m6bOJlgQ6GQfuZnfkYlJYeNzn6/31gvh8NhBuXS0lLD9RobGzUxMaHvfOc7+tu//Vuj0Mlxdzqd9rsBHczPz5uNi9w2Pj8wP8B41PFLS0saGhpSPp83ryWrHJejz+ezlh06NnFBELVdjBfxZfd4PAa+M/2tra3ZRIrMpngyB39MJBJm/aKPEckOP1vxIcKkg5qdVQy5BlDL+Pi4Pd/Y0ba3tw0/hqlnUga/3dvbs1hn5D4w7AsLC2publYkErFpju+h2+22wtpinJpp/LgPrmMvy+jo6DA/FEI1WnkIDSxucYHNIKkAzyIxHVVVVXI6nbp165aCwaAmJyePAJ4bGxuan5839ieRSJg/jIkIEF86XJnOnDmjvb09xWIxC9fDRlFXV2dJj7QPcRDw79fW1po4kgcXKQaM4LVr18x8jVI/m82acHFpacnKJWpra+22Hx0dtfjhoaEhSxaFKdvd3dXY2JjcbrexnWCApAawVmN0fvrpp/WlL31J999/v1566SU5HA596EMfsoTQmZkZORwOzc7Oqr293Q6t0tJSm2AnJyc1Pj6u3/zN39TLL7+sW7du6ebNm5Yimk6nbSqUZCs3CZ7PPPOM/o//4//Qxz/+cVuVNjY2dOPGDet8BOxuaWmxkte1tTWLq2bVZzUHNgAvnZubM+CdqYB0DtaxdDpt7z0AM89hXV2d6uvrjbgg8pqpqKSkRO3t7fZFD4VCCoVCcrvdJngNhUJ2qJH6gC4KqxnrGAwkjDYHDNNa8XcA9nl6elobGxvq7u62qGkORoqRpUMHC+wwxTCY44nLKc7t5zJGrsIBVazM5yJl4KioqDBW9bhfx35wVVVVmZG1GC9CI9LR0WFxJdRfjY+PW0QJ0RkwhLCN3d3disfj6urqMpUwQGs8HrexnWzwubk5a1dBZkA2UUVFhb73ve/Zv4830ePxaHZ29kiqIwcA7N/a2podrtls1pgbVt38vUBEIpMTiYR2dnY0Ojoqj8dj00BDQ4MuXbpka+fOzo5ZNKqrqzUxMWEhhvX19Rb7wsXAysuUguEYqxX/PdEkPT09+oM/+AP9xm/8hq5fvy6fz6d/9+/+nck4Njc3TQHO5JjP57W8vKyBgQGzT21sbOjmzZv60z/9U33961/Xd77zHWMgYblYEQma+/a3v61YLKaTJ0/qQx/6kP7JP/kn6unpUTabNTzz6tWrmpub0+joqKnIvV6vvbco5dvb222dxl/Y0tIit9ttB0FDQ4Pq6uoM7yGwkvgXlPnt7e3W3MRBxRQCC93W1mYyh1AoZJcKGipYV9JCNjc3bYosLS3VwMCAscNgmBxMxfX229vbRjggOSmOV4IJJpWX7xa1dsTftLe3q7a2Vi0tLRoeHrbvDNjl7u6uTWM0eFdWVloCC4c2/Qukfuzv71sZMocxrUc4U47zdeyr4ic/+ckCEwan/O7urtrb203JzGpxcHAgv9+vN954Q7FYzESApEky7SDkQ8dF6zHyCJi3qqoqayeBuUEIiOXm3LlzVkWFCHRubs4OQlgyvjA0tHD4ImbFd4gdgyBCjMaZTEa/8Ru/oYsXLxqI29nZKZfLZYUUPOhgRUSHYPpubm42yw75SGjkDg4ODKfisOSBLK6LYoqFfausrNTs7KwmJib00Y9+VHNzc/rv//2/66233rJQOBIB5ufnbR0pVvLDFK+urlrOWEtLi7q7u3X27FnV19fL6/VaBDDeSLfbrZ6eHsOKfvjDH+qll15SIBCQdNjihBG9tbXV1rJcLmeRy9DvxaW/xXVniHWZaMg9W11dNZJnd3fXYr9pMueQg0hCUb+ysqLm5ma1t7draGjIZBmImEkvQZZDaGZxuw+lMBxQZOfzmXu9XsvckmR6M+e9sMPGxkZ7BoBAcEMgCiXDi++EJKtHK25FQmJCWgQXN9AHmkc2hdLSUjvwtra2FA6HNTU1ZQMFJMnv/M7v/GSzipR65vN5o+HdbrcSiYQxhIz8KJE5tYm0JYu7+BDB7Mlkwi3DuhAMBo3VK24nocqMNID19XVdvXpVkhQOh43KJtajuJAAsSqHGOwSiZqQEGB5HFoYtmOxmBU+ELfS2tpqUwK/TzqdNsEuueCpVMrWqdXVVXV2dhp+RfQJaxIeP1aSYsytWL7h9Xq1tram1tZWnT17VpFIRG1tbfq1X/s1FQoF/ef//J9148YNW6WIeFlZWbH4ZHREECq3b99Wc3OzRkdHdenSJd28eVPnz583iQUg8t7enp5//nlFo1GdOnVK6+vruv/++1VeXm7gO5/x7OysFZU2NTWpq6vL2sJpImd9xAiMTcrlcmlubs5q7wCjsRuRWIL1CvEm2BGHtsPhsImfP6e8vFydnZ0WoLiwsGDrXCaTsfcaVX5xt2gsFrNaNHyLyWRSBwcHZpaWflT9BflDfBB9BcvLy0bw0K6ErAYWEz8nYtv5+Xltbm6aIwOXBZoxpilWYiAC/fmbhQAApZZJREFUpj4CFcvLy+29BfxH63Xcr2M/uNCbwO6k02ljv1i5nE6nRYdAz2NWhr5mBGZyQsGNmBRqurm5+Uhul8Ph0PT0tD2EmEgvXryoqqoqvfLKK/L5fNrf39fc3JwWFxcl6Uj+Fpnf3OA0/yAUDAQCdvgkEgkL/JNkqwoZRvQIbm9vKxKJqLm52TAYSXaroiHjJmT1QcaB7QIDLauMJDvkabOhQCKdTqu+vt5ighCkciPz4IKL/NIv/ZJyuZy+853vKJVKmRNgbGxMc3Nzam5u1okTJ1RaWqq3335bd+/eVTqd1uLioiU64PNbX1+3yrfJyUl5vV4Fg0HNzMwYMI2urb+/31itXC5nGGVHR4e1ILFaEo/EhRCNRnXixAmTUJSUlJhgFDCc6YAU1f39fS0sLGhgYECZTMZWIqaxsrIy+/mi0ai2t7fV1tZmuqqWlhbTHQJSs14T9U3UMfgZqSYkPhQKBWMYcZGgHyNtFesauj86Dbxer5LJpE3ld+7csRWaQ4SLkJKRbDZr5mmeZS66TCZjk3RZWZmxmbg4ipuPdnd3tbi4aI1ZFRUVVqhxnK9jP7iGh4eNhWAvl2SAYGNjo+l6oNBramrskCCgjROfhAGEp3yIeBwbGhoM1GXMb2lp0erqqmmmHnzwQbW3t+vtt9824LS/v98ai5kicMKjcM5ms0fsLdXV1bbC8gByg/N3c2OhxUIA29XVpd3dXY2MjKi7u1tVVVVqbm7W/Py80dTUSiG0hdxg4sSiQjvy7u6u5aiXlpbK5XIpmUyaF5Akg2g0auJeDn9J9jPwuzU3N2t3d1ef+cxnVFpaqrt376q8vFwf+MAHtLy8rLGxMRUKBXV0dOjJJ5/UG2+8oWeffVaTk5P2nmUyGT3//POKx+OqqKjQBz/4QfX09CidTmtkZETV1dWam5szVnBzc1MtLS1qaGiwwpL+/n7l83mNjIzI5XKpqanJEjWam5vt8yf4jpILJv1CoaBwOKxIJGJfPLfbba3Tu7u75g11Op2Wwc8XkYkZcDudTlvuPaA0Bw4aPTA02ptgJLlAmdolGSnCM479CHkH5cMUc/AMMfWTgQ+j7Ha7DX9kcpRk2JV0qK9cXl42sTSZ/RxeznvFxzgHIKucTqet7FwYxcQQBMpxv44dnId6jsViJiJlmgGwb2pqUmdnpxl0saeUl5fbCApmQ4MwoWbQ1OBoMEPcAICm9fX1amho0MmTJxUIBPTiiy/q7t27Gh4etocim80anUv9GZMJpaCwnZKMaePLXyws5IYFh3I4HCbxoPnF5/PZTYjHsrm52WxGBwcHJmBdX1+3TH6C8KipwtzLagy9jhewpKREfr9f9fX1qqmpUTgc1tramtVL7e7uGpuYSqXsd8CcDIZz5swZBQIB08sFg0Gz1ezt7empp57S//V//V+6ePGiEREdHR0aHh5WMpnUl7/8ZX3lK1+Ry+XS4OCgTp48af7KnZ0dxeNx88mhTEcoGg6H5Xa7bTIoFAoaHx832wkpqBA5KPtRouODZX0HuigpKVFra6symYyt+n6/3/5cLomJiQnrZ2Sdwx6DNqq6utouNphQSXbY1tTUWHigdCgelQ7DJ91utxVsEG3ONAfJQdMQ7gP6OnFJ+P1+JRKJIzhg8aTJlI5OC02Zz+ezicrlctnv39zcbPYisskgjNhy+P4Br9DFcNyvYz+4xsfH5Xa7jwj6mAby+bzdHolEwmJjNzc3LeqYIgEOBm4u/n0eZA5AxIq8mdTaA/zX1dXp8uXLOjg4MEq9ra1No6OjZl2ZnZ2Vw+HQ1NSUpMMVCmc8yamIZdHccGiScAkLis2GbkVMyHwpGhoaFIvFtLy8bB4/MAkKSGOxmDFoFK4S90s3ZEVFhTwej3w+n0lNwOSozALkJXcMuQCsE63fPp/PIq+JRnG5XJaQwcru9/sVDocVCATkdDqVTqfV1NSkX/7lX9Z//I//UQ8//LBWV1ctiyuTyehLX/qSvvWtbykSiZjui7VpY2PDkh+Wlpa0vLxs1hvpsFqMIlpM+ij3ycqCmV5fXzfcED1VeXm5HQjISiQZ4SPJGOXi0D/ej6WlJVVUVKitrc10TQ6HQ83NzTZ1sd7x/lRWVtplVFtba+RKf3+/JX4wGYHLNjU1yXmv5AIj8+7urvkeESPDbLICQqaQTEEsEtIZWqZgFMvKDlu3Z2ZmJMlWY1wGSDGKs+dTqZRNtshOCNAEMvkHMXExgvLmIgBdWlqytETC/yoqKpRMJs1mwRvLrQaeg4sepXNNTY0BhAjnYBfRs/T29urUqVNWN5VMJlVaWqr5+XnNzs7K5/OZ6x62r6+vz9YO8rYB9yXZbUOECxngOzs79ntLP4qv2draMsCW22p/f1/t7e2WmEnwGw8G1WixWMymUcSYTK1oflDNo7ze3NzU3NycrRoOh0ONjY2WY8VBxe8Iiyod6q5YWdPptFlKOJzRzKHlYQpEO/apT31Kv/Zrv2YJp4gXDw4O9KUvfUlf+9rXtLGxYa3Mvb29unPnjvb393Xy5EnDN9PptCTZAcTBwjpM0QjltK2trUaWLCwsmEWJw4GpiEMBUSYTPFISnkUsadLhhExMNbIHoo+Z+lOplDWwg+viXCBjy+PxKJfLye1229pIBwH4kMvlUmdn55GWIIgfptL9/X0lEglJMqwSbJSDdH19XSMjI2YdYzIjpdTpdNpnwLMAOREIBOT3+62ZO5lMWswRWkgwUS7S9fV1i7Y5ztexH1xYHvhSbWxsGL1cWVmpQCBgETVra2uanJy0fy+RSBg1LclAS+wFiD6ZLGjxRf28tbWlp59+WsPDw+rp6bHcIqh0lNGwkU6n00bgxcVFWxkPDg4MEO/o6ND09LT9+YzPALgej0eFQsEeflpymFpw8i8sLKi9vd2aZ+gWhJ4uFArWEk1cyerqqrW5gL/wXsViMU1PTxszVlpaKp/Pp7a2NqVSKWODVlZWlMlk1NjYKNqXDg4O7HDa3t62KXV0dNTiWjCPw+wBmK+srEiS4SisxxsbGxoYGNBnPvMZffazn7XfaWNjQ7FYTHfu3NGdO3dsfWWN2d/f161bt8y7J8kOCHoUiarGgQDOdXBwoKmpKTtUyHurqKgwSQQXGmF7CEDRnXEhbm5uGtwgHV4+k5OT9gxOTk6aZo6phtTVQCBgTFz+XnLo1taWTp8+rebmZhUKBUuQ8Pl8RtYgQfD5fPZZ1NXVqazssHfR4/GYoDabzcrtdpugGyU+mwD4F/IfyB9JtpIWDwZ8zlTL4XOECEPBj64M3SWpHcWlHcctsZJ+DAcXUoaKigr7wm1vbysajSoSiejWrVuamZmRx+NRV1eXHnroIau3AqhEYEj0SDKZtJuMBwM1eyKRUGVlpVpaWvTxj39cPp/PYqFjsZj5FclMkmQRHrlc7kjKKBomaqfwgpGwCT2+sbGh9fV1lZWV2SFFTDQJEbCK9BdSjJBKpdTT06Py8nJ1d3dbEw/TpNvtNnCUCOGSkhIDVAOBgJqamuTz+cyhANYgyfRFFBowoUYiERPWEn9C7hRfKI/HY0r1paUlM9iijGaCLBQKFoGC84Fey2g0ql//9V/Xf/gP/8E+s52dHcViMb3yyisaGRmxMg5KcMGoiAlC4AjhAQPIhSMdrsFOp1OdnZ2WL0ZKBZITp9NplD2/I/8/X3T0XeFw2ESo6XTaIpt3dnbM2M6BwFqN+RiBMM9hse6poaHBUhQwlgM3cBASPkDs08HBgbq7u63glsk4nU7b5F1eXm76q2w2a4WvXJQQCayRGPJLSg6rz7AlpdNpZTIZO3jJrA8Gg2pubja2F5HywcGBJQ5vbm6qv7/fnr3jfB07q9jf36/JyUmtrKwYWMxhQ2QIsctVVVWmT2JSwZm+trZmCuh8Pq/5+XmL0igtLdXMzIy9wX19fcYCwXzFYjETF4KZkTEOoL+ysmIsEzoaYlOYQvhZmpqabE3jYGTq4p933quhIs4Y7dbBwYHJJzjwtre3Df+iVgrJR01NjSYnJ+1Gx3tJ4N3BwYGt3IhKKWcAyyCCJBqNqrOz074opBDwEAeDQa2uriqXyxkzxqpOz2RlZaVp8dbX19XZ2WmMkyQDcwF9S0tL9eSTT8rr9eqP//iPdePGDZtSEomE7ty5Y6ZpkgrQMlVVVZm8AuM6TB/vHdM3sc6hUMim+oODA924ccNWR35GoozAt7C37O3t6c6dO3rwwQcto4opCVKJC2Bqasrao7DhkGjB1Ef3ItMpmizCKRGW8hmWlZXpxIkTRgQBduNV5AICnwW+wFpGvVpra6u2t7etW6C6+rChGwaW3PiKigqbxiFKiPB2uVxWuFF8SM3MzBjpA8GGhu7HZfk5duX8v/gX/6KQv1emOjU1ZQ81Iy20OVoi6fCw6OrqMtxqamrKWEMARzQxsH8NDQ3y+/0qKSmR1+tVLpfT+Pi43aSpVEr9/f2KRCL291RWVhqwzQPJjYLOhy8vNofa2lpLTCA7iweR2xpWj1uZ8bqqqkof+MAH9IEPfECbm5saHBxUJpMx5Ts4SElJie7evWsgMMkUTHMAwHgUWQ+Lv9Bra2tWUEtiafHqSr49BxNMIkWhxcGLxPfyRWCqwyLDyslBzmGLkHF9fV2tra2SpC9/+cv6kz/5EzPVd3d369SpU6qsrFRVVZU8Ho8ikYjprdra2uzC4H+Df7rdbgP1SRYF76PdfG9vz+xRmICnp6ftWQFgpuSCn3ViYkJDQ0PGIHNpFssIHA6H3v3udxtzDevNOopXEzwrkUiYzQsbDZgoWrfi4lsOTqZCJuSNjQ0lEgmbtphEsXhR+MLnwsGCN5K4HY/Ho2g0akkPrJOQDEyzGLPBZGtra+2ZLisrM7Et70Ftbe2x15Md+6pItC7COR5wwssQH3I4sCLGYjFdvXpVq6urCofDGhoakt/v1/333693vetduu+++/SOd7xDjz76qM6cOaMHH3xQDz74oGpqahSNRjUzM2NYFvs5YXgA5CjjKQFoaWmRy+VSXV2dCoWCrZVbW1smYYAk4BaTfiRW5YZntWOSKqay3377bVtfWNtGRkbMQoRfbGBgwISubrfboluc9xpmJJkEgjUOryRr28rKihYWFlRZWanGxkYDbFmpibMhSrq4d3FhYUFLS0v2BWDVQPrR09NjqQzgKxzkpFoAynMgzs/P60Mf+pAeeuihI88EdP/29rb5TDnEEWdSYAH+iH4NqQy1cbC3KMFdLtfhg34PYyMBg2kf8TMJDCsrK8boJpNJs3KRyQ5QDwve0NBgompJZl/a399XS0uLqqur5fP5zFfIv0OmGms1pBPFscVMJRYtZCfLy8tyu91GkFRVVVnUDJ5Z4AIIMYYFnCRElTscDs3Pz9tajgeU9A1CDWDTafCmOwFmnIBKLo3jfh37wcVKEw6Hdd9999ntFAwGTeOUz+dVXX3YWp3P5xWNRk07FYvFtLi4qDt37mh7e1ujo6O6deuWSSYKhYIymYzu3Lmjl19+2VILoGdnZ2ctsG9ra8uiljnQ0IehqYEpJB8eQJzuPUBx8CtuKf45JrLq6mp74CSZzegd73iHnPdilgF+vV6vIpGIpqenVVZWpsXFRTU0NJiTgMKPpaUlsxNx0C4tLdkEAiPEtLi3t2dEwO7urgkuOcRoZL58+bKuXLli+CMCVJ/Pp0AgYOA+Uy75YbFYzMD1YixFOrywYAf5QjFd/MzP/IxOnDihcDgsh8Oh69evm+q9vr7eLhmPx6OGhgYT3vK7AyXwPuzv79u6hBi3o6PDJgFcD8lk0lYjn8+neDx+5D0GauDSWVlZsb7CiooKcyLAmlVWVurq1at2gdTW1srj8dhngC2KC6y8vFwtLS3W6k3UD+sf0p/+/n5tbW2ptbXV0hcwMDMlsjp6PB6l02mdPn3apC6kpBKkSDzO9va2CW8ZKNA8csARbkj3QDKZ1M7Ojvr7+w2TJc+LFZcJkykeMu04Xz82VhGxHB8y/x3KXPZiVLuwX9ls1pgemCRWkkgkoqtXr2pyclLxeFypVEoTExM2zubzea2srKitrc2muVwuZ8WzsDgwh+hP2NexGdG7WKzMRzlMiSzeLgSEyBbAG7B0TE1NaXR0VFtbW5qbm1M8HrdJoL293dIkU6mUuQ34uTBbe71eM4ODNbCiRiIRo8hhGzOZjK0fiIC9Xq+5F4LBoGpqajQzM6NcLqeKigotLCwom80qGo1awgepFWNjY0a6QGyQTkBFF4kUpNPCEu7s7Mjr9eqRRx6xybW5uVm3b9+25NBsNqvBwUG53W4tLCxodnbWbnxW5lwup0wmo4GBAcvzYirs6Ogw4S7RwtXV1RZcCXyQSCTsIKyvr1c0GjVLFWvh9PS0SkpK7P0jjwuJC84J0k74IkuytZnDmxw34IO1tcMqPqZLeg+4WMHf2ARY7bu6uozokg6nIjAo8rh2dnbMd4nCncNeOmQ+6U3Ex5tMJi3KZ3Z21voRyNuCwCH6HBErkyB2Oi6v43z9WA4uGJDa2lrrgMPvhQo5nU5bxA0gaV1dnYXGoW/Z29s7ogLmw2WMDwQC6uzstNRSwHz0MJKM+kWmATaESnphYcGkG7CNLS0tplthTUF1Hg6HtbGxYa0sTDNIL4or0ubn541FRBvGtJnNZm1NQnPU3NyseDyua9euqb29Xbu7u/re975ngs6NjY0jefpMGJAFlDlwcHq9Xm1sbFiCAULV+fl5hcNhuVwupVIpSytAEoCUgsOOBpydnR3Nzc1Z5Mr+/r5JOpgWIDbm5uZUWlqqaDSqnp4eDQ8Pq76+XktLS9rf39edO3eUTCbV2Nio6elps3QNDg6qo6PDasf6+/stv5/fHV/e3NyclpaWFI/H5fP51Nraar9/T0+PPVf19fXq7++XJJOc8EKMiv4KA3c+n1ckEjFrFes5XtrGxkZjCJl+mOw5TMDInPdy3Ih2HhoaUigUOuIRrK6utnz/uro6U+BLhwm+PT09qqg47EJE4ArhhK6K3gUmJdZrWHEmP/A5plcgk3w+b+s+spiSkhL19fXZFA05RSoJQZDH+Tr2g4v+P3CHsrIydXZ2qrKyUnfu3FFpaanC4bAxcozB5eXlikajdlDgf2MKAqgvzoqC6t3b21NjY6MkmW0H2h82iYNqb2/PMCTyuJBCcIPQlcfDiA0Jmh4nPjEymKHxoKEDgzWLxWJWStrU1KRYLKbh4WEdHByW087OztoUs7GxYexOOp3W5uamzp07J0m2vhbfkvycd+/etZp02pM2NjY0NjamUChkETrFbC0WIx5gCIjy8nJjzfhsmGgpZmB97ujoUHt7uym0W1paTKNE9HFDQ4NOnz5tqRBgZ2Snz87OamVlRW+++aZOnDiheDxuIsiZmRk7eLGGoc+qra01kejp06eVSqWsdPfg4MDq59CtoaYHVCZlAscEOifWQKKSJycnzc0QiUQ0NTVlUwZrLV9wLuGamhqLY8KC43K5VFVVpWAwaJHXXDadnZ1H0inAjjh4uZxox6L0xePxmN/S4/FoZ2dHbW1tdvgh0chms5Y5h0hZkh1oYIloJSEG+KwXFxft8uc7ipTnH4Ryvrm52Wh+GBE62Pr6+kwe4XA45HK5LA2C0gviM5AwQN2jq+LG7erqsulpaWnJMoKKcTSXy6Xm5mbTHkkyjIt1MJfLGUgJZgRT5fV6TS+EfoeIDw4zFOsNDQ3KZrPWpwcozESG/YZ/H/1MRUWF+vv7rWwWWxMGWg4PvGhYhUgH4GBBLEgmVF9fn6VjIqCsqqpSXV2dfWkymYyZu/P5vHkN+QzW19fl8/mMKQS4xZyNrIU1jZVMOpwQHA6HiWYnJyd14sQJ9ff3K51Om7QC2UNXV5elHhDcNzY2ZlM5KaFgRvv7+8rlcqYtI0IJMWhLS4t5OXFvcKCvr69rcHDQJvCqqiqLoEHOsbNz2DB19+5dORwO8xZmMhlNT0+rsrLSHBvgSQDirIhIIZDMoNkikpnVraamRltbW+rp6bHDjBw0AgeR2pSXl8vlcikQCFg3AxvG/4p/csAuLi6qt7dXkgwrvXHjhpVd8Gw7nU4bKGjeIrEERh9JEuw1dW/H/Tr2g4sVkYeAXCOfzyefz2csWTFbQoAZplnEcQCpJERsb2/rxIkT2t3dtcIAcAeAWtY9JjAq21ljipki1g9sJOASrD25XM7WJnAMn88nr9dr5ZlMd8XVV1DNOzs71lo9Pz9vMSElJSWqq6uT1+tVQ0ODRkZG7D9D2+Pz+TQ5OWmKftYKGrd52KRDLIxijUgkYlghWeSzs7M2ZSA45QFsamoywDYUCplSnsMKMSu3PLEw+Xxera2tdhC+9dZbZs8pFAqGWWIoR6Xd1dUlj8djcdkYp+/cuWOg74kTJ+wz3Nra0vz8vAYHB02lDQDN1MAK3tjYaOWnm5ubqq2ttS/YxsZhfX1nZ6ccDofm5uZUW1trCbCUczidTmPVcHrgDqCxijw5n89nPxMWLNJKKysrTf+FlIBIJA6EQuGw1JbnG+tYOBw2jLWzs9MuX37nuro6O8y4YLmQuSAJHgS/JU2krq7O+gKIY+Z9Rs+FNY/vAH/u/v6+eSOZMBsbG48EVx7X69gPLkm2hkiyRAcUuzw8qJEXFhZMb4QtYX5+3h5s573yCxTJKJqbm5uVSqUkyT5wtCUUFQC4QwZgkoZd5CakpQWZBislKa4UJezt7WlmZsZYu+K2bpp2ikWLGxsbCoVCunPnjimgV1ZW7FCfnZ212xWRLikHkATEtED/8+/jN1tcXLQEBLLOlpaWdPv2bXu4MX6jTWNidblcttaSod7e3i6v16uamhr19/fr5MmTxsASzUMQHjiiz+fTww8/bMkOKysrlr6xvb2tfD5vXxr+XnCX5eVl+wLBos7MzNilRhoGOBFYIu9xoVCw6OidnR27WJh4nU6nKioqbCImhdfj8aipqclYvvX1dYv+QcJAy5QkE7/ig4RcQgMIVlhTU2NSC1JHmYhI5aDhqjgbH9tPeXm5mde7uroUjUbtcoT5lA4hES5MwgxgSLGmAYmw4rE6srY6nU5ziRRrwzY3N21T4t9jSkQcTIYb5Nlxv479b9jd3TV7y/7+vlHSaGacTqflqAMGO++VGrBW8KYzwYA9JBIJlZeX25vb29trE01xHI7X69XMzIytLrCOUMqIPhHZra6uWuQLoDM3ChMZso7Ozk7V1dXJ7XZrfHxcVVVVhr+BUxWP9ru7u/J4PEYeOJ1Ow0pOnDihXC5nDBzG4r6+Po2MjJhsJJvNWo0Zlelo1MBLwEYAXVmN8UjCTAWDQQOMsbo0NzdbwgKfIfgFEywTUHt7u0KhkIUGUjcHPkIzE04HQvRguMCoWIGwOFGkgraJ9X10dFTNzc3K5XJGbPB5STJP387Ojgltp6am1N7eboZgdE2hUMj6DrAHQelvbW2ZLqmsrMyEyyUlJaZ7Wl1dNTyp+NDlfS4O1CPQDyaRl8fjOSJyjcfjdsAj8C3WxVFai2UNhwVrHdn6Pp/PZBG9vb2KxWKGA2YyGdtcyHWDAd3b2zO5C0B7oVCw6CnM3blczlqtSbigoJYQzeN8HfvB5XK5NDs7q9bWVvuywUphJC5eH9GlwLrV1NTY7cIKwE2LahhHP1KHxcVFw8WY7iTZekcENH8vdo79/X1z10Mno0oHi1pYWDA9FwfU9vZhF2FXV5f9fdxK4FvgHLxWVlbU2dmplZUVpVIpo5lhEnEMNDU1WTzuyZMnVVZWZhql8vJydXR02EHFGoBUoqmpyR5K/m/ytObm5qwVxu/3a2BgQG1tbWprazPmkSkOszMHFmJKfq+5uTkNDAyovb1dg4ODZqGanJy0+Gl8imRN8TMUs6n33XefYrGYTaessazaGJBRyU9MTKi6utr0UMhk+CL5/X4lk0nDNPm5wLV4X8LhsPb29mxtY6IF30wkEjZd8NwVbwSU9KKdk2Trm3S4ukNSFT+HTLzgZUQtke3FsxQKhWxKw7ITDoft+Sa8kEkafRVs6/z8vDo7O83PCpCOTSoejxu2hdeTtZUiYqw89fX1BicgPMUPu7e3Z5vQcb9+LHIIRuD6+nqLRqEIg8TPlpYWA69PnTpl+pi9vT27gbj1+TO9Xq8JI0tLS+3LhLVjbW3NDNGI+aDY6VxECY6dRZIJB1m11tfX7WFmlaXVBA0QeAAH5vr6uuUf0e4LeYCJFWwD1obIlOXlZVu7eFA5LEmipOx1bGzMGE6Ek2jHCJJzuVx6+OGH7ZCLRqPK5/OWE8/aS/ggXyYODUnG+CJdAOejgSd/L+sc1XmxTxLwnlILvKCdnZ0mktzb29PY2Jh9uZLJpH2efBH5EqHq93q9RiwUiyyLjdy8z/F43KbZQCCgcDhsmkFidSQdwRVpFaKCjJ8TiUwwGLT1emJiwrLp6UxAVsGBihSotLTU7D4A+Gj/uFDB1MCVgsGgysrK1NDQoI6ODiMDmKw5LHhuKisrjUzin1leXrYkFTDHqqoqu/z5u6kPBAurr69XIBCw7DPSX/f39w3/IxBhfn7+H4aOCy8hb9Lk5KTl+iA+5IsjybLEWTFYTfjigDcUt5Fsbm4a68GIi0UknU7boQBoCgVORhX4BMmUxUJNIjz4wlBLXigUTNCIgh/1MQcjsSBQ6dDJ9DCST84B/b+amVHR81AR+IatCe0R9gvAd25mggiRYiSTSfX29urcuXN64IEHtLW1pVwuZ78v2A6rM4fg5uamTSAo5bEWMbWur6+bWJTVEn8j5mfyzgBxl5eXdevWLVvfi8WblZWVGhkZUTweN0yMiVjSEfU8WVuSLKGDkD2kG/QJlpeXKxwOG+mytbVlUxYWq8bGRlPsM1XzjFJfhqgTUTOKfXAmScYGkzlfzFAToCnJJCkcjtls1lZdflcuCq/Xq3g8brHnqPL5c5hSYSjZRnj+0Gc1NTXZmoqwGLyz+HtGIgQgP0REU1OTDRDr6+t2GTvvNWcf9+vYD65gMGhsVLFoDn1P8YqG2G93d9fSI91ut3w+n6QfiVkB1lFMs5bhpl9ZWTGGkCheImc5IKDr+d/of3jzwde4XTEeg22QLuF2uy1bvrm5WePj42ppaTG8AFsFqQ+kVM7Pz1s2FWM3MgZSKBOJhEkmCMBDHe73+xUMBo26B4hGxrG/v2/4COsRjUAkp9bX16urq0snTpywQo+FhQVjzWjPhjFF+oCxFjxnbW1N+XzeyknIsMevx/qNWjyRSCgcDiuXyxnVXigUVFpaagmarDzYo5iE8H3il+OfAwvjUC0pKVE0GrUk1Gw2q8XFRTMv7+3tqb293QSZeBIxhxMyGQgEbHICO8O+Q5xRY2PjkXWQPx+5QPH/4ACRZL5QDrriAhnq7pEdQJhEIhG53W6LneGZ5LsCCx8KhQzzcjqdcrlcdvgUCgVzDVAsy7rH6g6Gm7/XLIWnklgliBPsVdXV1UqlUsaYH/fr2A8uTL7cUMlk0hgXmAtYMJTRoVDIMAe+tKFQyBIdeVNhJVFsQ91iyWECSqfTFmBIvRgMDzgWX/jy8nLLImcSwR6xtrZmjdaFQuHIisWKUllZaZYN7E5MBIgFi0WZkqzAYnFxUZOTk4Z9QUQwxW1vb2t6etrAb8S4wWDQAOJQKGQxK2VlZRoZGbFLYX19XUtLS5qenj5iZZqZmTGcDHEw2qdcLmdWI0mWlwXORYidx+OxlZ+pIp/Pa3Fx0Vbguro6hUIhK7t48cUXTYAqyQ5lJCTRaFSZTEaLi4t2+JWUlNjKAzPIBchkzYWF2RwbT3FwYjabtWka+xZEEs8GIZaszul0Wi6XS+Fw2MpXYEdTqZRu3rxp/Z74VktLS+3ixlTP+g0cgQuEjYCfmaarxsZG+0yYniWZ77aqqkpNTU0msEYnSMIt0yT/PmQRbob+/n5LVmXClqRIJGI2NNZXRLMENLJZ8P4Wt5cf5+vYDy4OAnANj8ej+fl5wxfQt/AlRSEeCoXM/MlN0NLSYpn0iEvpCoS1K052hGkpTnZEVc9Ny+jLg8WUhFygpqbG/IMVFRVW1kluPkwo7KPf77fJbmVlxdjTvb09O7TX1g6rrsBSMHmnUin5/X47wBE/zs/Pq7y8XK2trerp6TE/GrleZFdhkHY4HLpz545cLpcVTPB3ANCzzpI1T9IA0by5XE65XM5WQVTvU1NTliZx69Yt8zxy0C0uLlrDMVVYjY2NcjgcCofDNvXcuXNH8XjcJjvMy6jgYfNQbvPlR5kOdsnUjCQBfR76s62tLbu0SHnY3d215iASPcgT29nZsRUfdT1ffKh+pBh4E1kf6X9ExsJFBsHE5YfeDJFsfX29TfVoBuvr67W2tqZMJmOHJ1McNh8YwOItpKamxuK5+Uxgwzm0MFO7XC4T+ZISOzc3J5/PZ/VlxFePj48bEN/U1GSicXBGSba6/oOQQxAvQpwyYyhJlkwWAH3xeFzhcFhdXV3K5/MaHBy0E/zg4MC8gQj1YFW2trYUCoUsRYCHhJwpbmMeACqkiKEpPrj4YDkIS0tLbboBfIS5QkpQ/POwEhB1TNgdotaamhprlsHi9MMf/tCmFaw5TJsc+svLy4rFYnr77bftC+hyueTz+dTY2Gg+vfn5eZ04ccJU8hASJSUlJmMgdZQVIxaLWaktEynr9crKin15mpubtbm5qUQioaGhoSPTJlE54+PjymQyamtrMy3Q3t6eJiYmlEqlTKoCE4j+jUsFnIgwRP5OTPn44vjvUbUjmiRldmFhwbA+Pn9Y5MXFRTU1NVk2FkwsADVsKvgiJms8oOChkDvAFOSV0bbESlcsveGLzSSF7kuSTWhE/rBplJYeNkijmSJ+hgkL7WIxduZyuezngnwi5RbXx/b2tqqrq+VwOLS4uKju7m6VlpYadFBbW6vNzU3LKuMA5jCfmZlROBw2DLFY63acrx9LPRlGYOhaphEU2SjZ0f7gFyO3CJpVktWZ87DyRd/Y2DC/ViAQkMvlMl8VehUeFDAGVkNWhtraWgWDQXtAWW+4YaCCiTQG5wAA5ncqBnr58jP5BAIBOyggFqhUx5y7s7NjSubl5WXV1dUpm80eyQxraWlRJpOR3+/X5OSkyTZaWlqsvQYFviTDwfCcEXuMTSgcDtuhT944WjLKaAHmHQ6H2tralMvlNDMzY0JHSTb5DgwM2MSbTqdNyDs0NGQZVoDJxZ/X/v6+2YnKysosYRTyhZ+fSTUYDEqSrf0NDQ0aHx83Tdbi4qL29vYsdaE4igjgvdgaBgwBO4qKHEcAuB8Hzvb2tr3/HKwwqbglaAOCeYUpR9cn/UjnhQCYZ43sNukwP64YX2K6IwQRuQLPAmwfKb5cwPX19TbdMQ3v7e1pZGTEVlesemgnOfj29/eVTqeNvIAA4YWQ9bhfP5aDiweY4kr0WGRTg1EhqEOTBGhLzRQMCaO5JGuuYRVEPIe9gbA/3nT0N9w0MDoA2eiyWAHQYYVCIaVSKZvWoK+lH2FUPp/P5ArchHi+rl27ZnqfXC5nBxFqbYpxT506pdXVVSUSCbW3t9vqi6YHRolRf2xszPLdMbwCxEuHXwhW8YODAwUCAeXzeWvHJlk0lUodSVbAsxmPx5VMJi15NZvNam/vMCfN4XCopqbGWFXkKohH0+m0GYRJSsWGFYlEjkTC8DMxVfOloiYL3R9sGdqvZDIpSYaTLSwsqKWlRW1tbUcOttnZWQUCAcNaKYulNITnIhKJWG8ksg9ikJHgFONq5IEVCgVduXJF09PTkmRfZvyh/IzFnkV8kei5pB/lz4PLUerC54/pH7y2tbXVmHKv12tZcNiCcHuwOQBbYO4GCqmqqlJ3d7c1ZU1NTRn2yxrLBc/7yDNFkCFsNGzocb6O/eCanJw0yw0jM4AusgW0IPl79fZELfPh8hDjnUOTAnW7vr5uX6jx8XGtrKzYJMEuzoeDwbbYmgAeAybFBIS8oFAoaGlpyRhHdFWISre3t004C+YlHcoWuNEDgYAuXLigYDCoqakpA1uz2eyRDsW33nrLYkSIat7Y2DAcqL293f7/4rWlUCios7NTmUxG4+Pjtpqwgvh8PlsTiM3mAGKaxMXQ2tqq9vZ23b5925jC3d1dy2Qi9I7pGKwFdXZVVZWtIaRvoKrGQC/JQOa6ujqdPHnS8uZZfVhr+ZLxxa2vrz+inidR1+/3m46KKCQyw5iG8FnCbJaWHhZHAAVw2WGtqq+vVyaTsWeGgwCQn2eosrJSp06d0vT09BEvJ7YgScYoMilJMpzO4XBYAi3vEdgTzpHGxkaVlJTYgXZwcKBbt26ZR3JpaUl+v9+0VsUR6bC2LpfLMLBMJqNoNCq/36+pqSnDZ3O5nDo6OgxeQEPX0NBgOW3k3mHP6ujosMOey+I4X8d+cJ07d+5IDjfiSKJ7PR6PEomE3Xrc/mAnyWRSCwsLKhQKWl9fl9vtVltbm8WTAAwWf0EA3WG5AKYpmZBk4zgaGXLci3Pbd3d3lUwmTaQJBra1tWWrJBqd7e1tU2Az2a2srNhBUygUNDQ0JEmGEYG9NDQ02MRDnDXTBu8TpuKpqSlLzWBq5HfOZDIKh8OG3SAT6erqsnQB2mXI7g+Hw0YusEqTEtHd3a2zZ89a0wzNMExBfKE3Nzc1MTFhGFplZaWWl5ctlRQygCkarydx16w9gMc4G4AO+LLy9xZrlMhRJ+4bvSD/3Pb2trxer0kZmMD9fr9NNyjm8Q9KsoA/ScYG89lilGbFZIqDsQaeqK+vP2K1Ki0tNV0UL6YwyINiQS0tRLChy8vL6uzsNGyTEM7t7W3lcjl1dnYewTEl2eUG0USuHDjWwMCAFhcXde7cOYswojCl+Gdi2ga/7e7u1urqqpEDPE+4Lo779WMxWa+srFh2FCN5c3OzMpmMlpaW5HK5rJABpTJhfK2trWptbTWjKDKJqqoq9fb2WlQuQkB0MYTeccggtEMV73A4bLyFAUIasb6+rpWVFQWDQcsmohwB0SjMXrHJeGVlxb4M3Nazs7MqLT0sfQgEAopGo6bJoaaNNczlcqm7u1ubm5uqq6vT4uKixUbHYjH5/X6FQiHDcGAV4/G4GccxmoMrSrJm6Nu3b5vkAiP37Oys6urq5PP5lEwmzd8Xi8VUUlKiK1euqFAoWFKrJLOEZDIZI0AQwyIFIfr34ODAZA2lpYe573Nzc5qZmTED+Pj4uOGLHR0dJmDEvgU+1tzcbF8o8r2YlOPxuAKBgFpaWgzTXF9fl9frNewMqQT6KzDKg4MDhcNhIwDy+by1Y0MgQPeTzYb3sqzssI8RsXM8HrdDbXNz00gHtIjxeNzivPFiYjD/X2vtAOr5Z1taWgz0l2SOBLfbrVAoZPib2+22Qhefz6eZmRlrp8ZnCX7JBY6ljWDHhYWFIyJqVtxAIGA5Y5Isw6yxsdF8o/8glPMAwBQn8GEQ7k9wGocMU44ky9tKpVKGGfCgUknV1tamkydPmlixrKzMLCE7OzvKZDLGEgHGSj/CHooVwXjaEIEiHKU8gFyxYpV0cUMR0wjuevKl5ufn9cADD9iBhXaIQ5uHZXd319afqqoqBQIBY+xcLpfm5+ftIONBobK9OAaYWBosR7dv3zaan+mDFZy1jCYYJhLkGTU1Nfr+97+vgYEB9fX1aXt72x5s1o9CoaC2tjbl83nDX8AKaaJua2uzy2dqaso+n93dXQOCmZwAhJeXl02hT7ejw+Gw4hE+y7KyMoXDYc3MzFh6KILQZDJp5m48dxx44GFMdmjr6urqrIiVNQ9Rb2VlpTwej4aGhsyuRcopFzMBmcU4KF9mWEJ+bv5vGEwO3f/VLkS0E1FQPP/ELkMIoLxHCrKzs6PTp09rf/+w7aejo8Nq0lgLW1pajNhC0wa0w6QmyYYNJny0fxAPOCT+QcgheAixB+zv76upqcnwFozSxUFzjM/5fN4c6WQUkdLAbUnWODQxfsienh4zcPP3wu4QQwy7w8+JGLK5udksDWtra1ZXX1tba2WlfHDFdhCkFkRUo4V6+OGH1dPTo/HxcVPCu1wuDQwM2MNVWVmpmZkZ+2JEIhHzyxV7KAFlMdWCpzjvRQsTa+31ei1kr7+/X83Nzfb3oZ0rxkug9Dc3N82kjoXqzJkzqqio0Ntvv22sp3Q4EfFeMSWgAdrZOaw1QxA7Pz9vq6gky1lva2uzaQ1nAZEpEBOZTMbWsba2NgtcLParkk47NjamnZ0d3XfffcY4cyCgjWMKJ0oGXRWKdNY1JnMSR1lRC4WCcrmcCV1ZW5H0/OAHP9DGxmH7Duwd3kJJtsbx7xdHPvE87+/vm4hVkh1eSEGYekl74JCBGDo4OND8/LxNdJS3cBltbm5a0ODS0pJ8Pp8dvIuLixZ0CEEGHk32Wy6XMzkGOjqPx2OFI8f9OvaDi7wrkhgZi1Ggc1uw4mHdkGQyAABYaFpAeYfDYSkJxCz39fWZ8x0am9Yen89nETuS7ANlbYLdmZ+ft3TKvb09s/9IMpwqFArJ4XAoGAxazhO4Dg0r6Ggk2QfNwYu1xeVyaW5uzhT2PAhovlgnaHeheYiGHTDCmZkZbW5u2sqDdxHbTaFQMLEla1BxKi1K8Hw+r3g8rhs3bmh9fd30dzCHsIRDQ0OWXBqNRnXt2jWVl5fr7t27WlxcVCQSUV1dnZLJpLa3t3XlypUjBw5dh6Q0QMOHw2HTXDF9sXoXCgVNTExYaCRiUFhIiiy8Xq9GR0dVWlqqoaEhI3oQtjLJSTIbFAwfAk/eQ1hPDlQC/JADwJbSKg2wjl5tf3/fIATWRdZ5DtbS0tIj0ANyDy5ZplrWXyJu8OxyCTQ3NxurTujg3t6eeV8ZCkpLD+O+w+Gw6uvrjeHHzI2codiXCcZ748YNjYyMWLwOhcINDQ2KRCIaHBw88n05rtePJR2CdYwHh4B9fFB8mdjzAdC5tRG2YQXhQwUInZyctOA3As/8fr9OnDghl8tlHYCo2PH4sXIiIoQxgw2ELubvPjg40OzsrP0+gL+FQkHZbFbhcFitra2myWloaNDFixd19uxZU5+D0YDHRKNRE9CCUTG1wY5KMtM4BENfX59isZiN+CQj3L1712QJfKHBrXhPMUdz0KZSKe3s7NiEuL29Lb/fr3A4rFQqZcByS0uLnE6nWltbNT4+busEui5yrsLhsH1p4vG4Ghoa9I53vMOkIKy8zqJQyHg8bl9enhsOGFYqvjxnz541MSQiYljkmZkZA4qz2axu3bqloaGhI4Z5iAXeY0iZ4sOFyRTWmGQN4qmxiBECuL+/b63PqVTKXBJAD8UGcaKnHQ6HJZRIsqlOkv35EEjAAshPmJCAVyjH4N/3+Xx2cPId5FklWiqZTFog4tbWlrq6uqxnk8MZAomU4pqaGtM6ZrNZ9fT02FRbXl6uSCTyDwPjCofDpvxG3Efca3V1tWmuivUs+MQk2ZqEendxcdFYMSY10iEnJiYMYMcxT85XoVDQ8PCwgsGgAeFkUGGa5UUdF3nnFHmyNkDjg5nkcjljzhCa+nw+PfLII+rp6dHQ0JA2NjbMExgMBhWNRpXL5RQOh5XJZFRWVia/329JBZlMxtZT1hNieiUZc8o6tb+/b0JFssdramp069YtbW9v66233tLNmzet9l06pOLT6bRNW7zvFy9eVGNjoxnki/VjlFnk83nNzMyYxASglyTalZUVHRwc6PTp0+rs7LRyjStXrph9BDsRcTxEA6FVYlKgCYr1e2Jiwr7kFHowLbW2ttqzVFZWpsHBQRPier1eixvyer0WHUOc9cLCgpLJpLHAXCLo9JCwOO81P5OgsbKyYpIC1O1jY2NWTSbJmEhJdnjyuSJkBRMDW+PnosuANdDj8dhlg02JC2JnZ+dI/R/C4uLCD+mQhW9tbTUBqtfrNaG3z+czwqmpqclWWLonmZJrag77NFnXPR6PmeGP+3XsB9cPfvADE5Vms1nDGCSZyRdxHQAjnjXA3+JpizQEMp8ODg5UV1enkZERO9BgBRHELSwsKBgMWv6Uz+eT2+02hvLkyZPWKgxmgIGUqJUTJ05YxyNAPxIMhIocwm63W8PDw+rt7TX1dllZmYW0kSpB1lFDQ4OtSy0tLdZvd+PGDVONox1iGuIyyGQycrvd6uvrsweKBxe2kvIKsLnq6molEglje9FkVVVVqbW1VVNTUxaDAwnR1NRkejyYLXKciMS5fv26fbaSDCNC+vHaa68pkUhY2ipJnOTdz8/P22Q3OjpqBxoH4uLiopEATEmJRMImMNwACCb5WRHazs3NKRQKKZlMGjZYVXVYRAtJwoSzt7cnv99vlV+wpPX19eZLRWdIJRx4bTqdViQS0cTEhLGU0uFhwVqKXo1gQrRvkiwr6+DgwFwQHGZra2u2USDvQHyK2BnbGkB8dXW1TW/4UCsrKxWJREwQzPOCZ5XfEXcJeBifL+wnZctcVKQRH/fr2A+uixcvKpFIGMtWnBwJ6CrJvojgKAhN2felQ2wA7x7/HcbT1tZWW62IreULKv2I1SkvLzfTdlNTk+rq6rS7u6uenh5VV1erq6vLAuLQ0JSXl1u4H6AxRRHc1NIhuMstzwQWjUb15ptvanV11QpHKyoqdOPGDW1tbZlK/eDgwBg51oq3337bLD5VVVXWXLSxsaGpqSm53W719vbaRMCXCRkE5EdfX5+ZkVlJ3W63yRGYXOrq6rSwsGBqe/A1WDkOBdjU/f19i0TZ3d1VV1eXOjo6TOIB7R6NRvXNb35ToVBIuVxOi4uLNgWAoaFJI2W0t7fXGCu+6Lu7u1pfX1dnZ6dJEMiah7EmkQGlNwwnnw94Z21trZLJpJaXl023VFxN193dbcQJwstcLmerNn7CTCZjsdVer9cuQCKOYKwLhYLJFySZt5JSFQggKsfQW0FcgKfV1dXZZNXS0mIXNwwhoYKJREKjo6MKhULGeCKfoZ2bnkmkNFVVVcbc1tfXm3Mkk8lYdyLfUYStfD/a29stCebHkYBa/v/9j/z/94rH43az1NfXm2BufX3daOTih4GKMklHAtG4VRA1VlZWHuk4zGazNl5Ho1HTm8BWwkDC6AHqsp/Pz88rFAppYWHBhH88GKwvFRUVBlZKUiKRkN/vV3V1tbq7u+X3+w1LIXse/RFfcIITSePEcF5SUmK2FtT9Ho9Ho6OjamtrU3Nzs/x+v2E/sLIc5rQ79/f3y+/3a25uziQT/E4LCwtaXFw0AB83gtPptDUWEJpAuO3tbS0uLpq8AFxpcXFRy8vLtqZ2dnaaRot1bWhoSIlEQul0WtevX1c+nzdwWJIRNSSGSDKge319Xe3t7WYBkmRiyYWFBbuoIGZaWloM7+KzBvfii1occQMUUczElZSUmACWiZ+VEx8jqyaYLauZx+MxqQCESUlJiV566SV9+MMftmm5ONWE4oxibx+fJar/YtU9glZyyJjYSREGVtjc3JTX61VXV5fp5ThwcDgwmQHM19XVKZFImOcSkqCurk7nzp3Ta6+9ps7OTrMUFQoFJZNJBYNBGwT4DlOmcpyvEkSFx/X65Cc/WZB0RNuBOI/DAPU1aYpEeqCsBiDlACkuxETzgvcunU4boAvAjmkadoQpAvAV/QvxuolEQoFAQJJs/QMH6uzsNLFqc3OzGYZbW1tNK7W+vm74RDqdtnwsLDA88KlUSo899pg97KWlperv7zesb29vzzRlTz31lGVbAdDTkJ1KpXThwgVtbGyYhgez897e3pF2FiJ6wC+YaElXJSsMrJEvGf49Mqig/zs7OxWLxeTz+YxIwUtJgOHnPvc5mxgODg5sHUZYS0LF8vKyVldX9fjjj+v69esaGhoy0Su4ldPpNJMvhSYUscAQ420kngggHudGcXglRnrYWj5zRKdcukATTIBVVVWWWItNBx0d/r6FhQWdOXNG733vey01oljzt7W1Zbo/nl9J9hzyf/NC0gHJhUCU33l+ft7YbQIwpR8V20aj0SNsNasm06vD4VAymZTDcdge39raamJdMrxINEELiBYOORHdlJ/+9KePtVzx2CcuWA1ASFgMvF/gQzBLgI2A8ggVYaCwiEgyCpwSDj4IGBvYHtYMMDT8gwsLC+ro6DCNEeI9DtKamhrNzMyovb1d0WhUS0tLpkkCN3E4HKqsrLSJgix0lPrIB3jYabOWDtNhr127ZixmIBDQ6OioHnvsMc3Nzamjo0OlpaUaHx83PI2HH+Ce9+TmzZtW045HDVV3IBAwTAk5SXt7u27cuGH4S2Njo+maampqND4+bnVopMNSe5VOp1VTU6POzk6TPTQ3N9ulAQSQSCQUj8clHRIBrEZbW1tmCIYIQVDqdrs1MjKi8vJyzc7O6vz589rY2DApSDweV3d3tw4ODuymZ71jleGfSaVSpqHyeDx2gSG9gHzAYweOxD8XDoeN/cQQ7/f7devWLfX39xtrV/xchUIhS2mA1XzooYdUV1enQqFgolGmekkGE0gy4S4uDVZLJn8mcg4v/lkcEDDTkBewgzs7O5Zcsrm5aZMReBkYFSshzUB8DyFd8A2jgwTzg7VGg3ncr2OfuD70oQ8VUPHy4kAh7weVejKZVEdHh5LJpMkPim+W4ixv2CZWMlZOsDEKC/hnstmsMUmE7TE1VFdX2w1DpDFrq8Ph0NTUlN1i+XslE0gBoJlZvQDHSTLApNrY2Kj5+Xn5fD47OMF5qEsHMJZkHkSM5SQxhEIhdXR0qK2tTXt7hwUTqM7ByJgEKFWoqamxCiywKcIAa2trLagQ29Xe3p4mJyc1PDysSCRiTFIikVBNTY0uXryol19+WX6/3wIFT58+bX/mxMSENjY2dPLkSX3+85/XrVu3jmRw8buhncOnWKw0Z2VpbGy0iw3PHozp9va2sV7IZJiecrmcHaiXL19WV1eXtre3LfZ6dHRUTqdTJSUlmpmZ0cDAgE31dCHQfsPqzDSLxAR9IdPb+vq6Tp48abIDdHlOp1P/7J/9M8O5JB2JXCovL1cqlbLLUJL956yfkuwSxNJWXl5uViM2EyREMNdERjc0NByxT/G7An/QD8CBBgHDIY5rYG1tzXoe+X52dXXpxo0bFgG1u7urn/mZnznWievYwXl2f77IJC2Ul5dblAuHVzAY1MzMjHkWsSWAK1A7T7oE0cLcdtzMCDh5yCVZsqokWxeQQEDlYjzlw9vY2DAjsST7+8HISHwEjOWLx6qE7onbihoqsr6lQ5D2xIkT2tjYsGkJ9mlhYUGXL1/WlStXdOvWLX3ta1/Tl7/8Zb366qt65ZVXNDk5ab8DAC/0PpoiUjSwoKCMlw6Nv1NTU5YDz3pKxBA4D2tQb2+vaXWIeJ6enrYVn5UEI/rk5KQymYzS6bRNg8XrV2Njo/L32r8bGhrswKmurtb09LSc9/LmOzo6tLOzY8GT5eXlVpKL3YQVBZaLKW5qaspCFVmR0+m0XXirq6saHBy03zOZTBocgJyA1QrD8dramuE4PLvUpHFA8/fwM01PT9u6y8GGDGdzc1Mej+eIK6G8vFzxeFwtLS32OcLkMlEhpAbIxz3Q0tJizzC2HEpRSNsA20L4TXsTwZHFuWWY68Gi0aUxTLz++uuG3SKfOe7Xj8WryC0HBcwbSrUV+BPrGQ8kTIf0oyYUbl+n02m2C6hw6UdKfafTaVQwkRx8qcE18GaBqZHPjVi1pKTEwG/GeQ7h4eFhE8/CnqHzgsYndpc8L5JFAUjx5hGHy3sC2wnQnE6nTaO2sLCgb3zjG/qf//N/6itf+YpNGSUlJeru7rYvXFNTkzKZjObm5hSNRg0zRN1NYWldXZ28Xq+tAOl0WisrK5qbm9PExIRpdPjZyCfb3t5WLBZTV1eX/tE/+kcKhUJ2KJeWlurq1at67bXXLEmV9NaKigpL3OBScLlcVmwB9tPQ0KBoNKqNjQ1jhltaWixKhSQHxMMQLU6nU6WlpVpcXLTQxtLSUosg5nBfXV21wzeZTGpxcVHV1dXq7Ow0VrSnp0fRaNQIIhhl1kEYcnRdy8vLZhGj3aehoUEul0s3b96055iQRISfNTU1WlhYMHJJkjVES7JSGDBHpmYy4oBc0L4V28LcbrfBCnw2RA8575VoIBeSDrehiYkJBYNB5fN509QV454csmwPxSQXxNlxv459VXzf+95XcDqdisViRjFzUPElYuWCaUHbBRAL09TU1GTJkdDUGJ+h3w8ODpRMJq12HQyCKWt3d9ckA319fbbasa6BudG6w4G2vr6uaDSqcDisiYkJS8B0u9128wHOY9DFYgH7Bk4CyLqxsWHYHBOTy+WyYltYyEQiYZgdwkcEo62trRoeHtYjjzxi61BXV5cZh5lYSRsF84pEIhoeHtb8/LzKysrsIGhsbNQbb7whv99vOA30NokUxPRiIo9GoyYZaGho0Isvvqhr164ZCZJIJEzSQWU8oLrP5zMWWJJFREuyA2ZoaMgEnKdOnVIikbD2Hr5AeDdZv2kCgpAoKSkxINrhcNhUgpevtLTUWrKJ1c7lchaHg5QEOY3f71d5ebnGxsaO0P9guWS20VNYXl6uD3zgA/J6vbZpNDc3GxCfSqXk8Xgk6cj/zXcFsWwmk5HX6zXRMpckFzQZb8Wpu4RN4rzAT8pziJYLYoGUiWLNF7glkExxGQjbB+/16uqqPve5z/1kr4pdXV12W1FasL+/b94xMCD26EQiYWMqtxOnPhIFGDHKFrhFksmkKZ0ROcKakZXU1tambDarQCBgOh8eMGQMJC5gfl1ZWTHKmX+3urpa4XBY4+PjxmIhaGWVqa6u1tjYmDGZTqfTcBo8iyTEAhYvLy+rra1Na2trWl1dVTKZNJMwbTo7OztyuVyWZnrz5k397u/+rl5++WWtr6/r8uXL2tzc1MrKiqLRqAHoANrEAnPgRiIR+59kMmkJBKj1eZjRP62srBjAzs83MzOjt99+W5cuXdJbb72llZUVS4dA98aXZXV1VVtbWwoEAlpcXJTzXib+wcGBrYrIJkjXnJyctHw2TOT4CPnzwabAQLGqAAsgwUHjtb29bVjp1NSU6d2WlpZUU1Ojtra2IxnxxfHf0uFURNpDcS5acVwMsEhZWZmy2azhakT0sFkQz0RagySracNqw2Gdy+UMDPd6vUewM5hTDumZmRmbeovTLthK6DglgJE/k02ANBR8t4R+QjCtr6+rqanJhMj4SI/7deys4sLCglKplMLhsEkQeFO9Xq8J9Ii2KS6oYL1h/SHRE81PS0uLyRHojwOn6erqUiKRMNYD2cPCwoIdSqlUSq2trXYjFgP8ExMTCgQCRjGDoYBJILdArV9VVaVwOKxYLCZJpnnp6emxUlcYJQ5t8LjZ2VmdOXNGd+7csTWkUChYljvK5uIvODoi6RC0jUQiunr1qq0/sVjMVt/S0lIlEgnt7u6qra3N5BGoo7EKgS0C9NLYs7+/r66uLo2OjpqyenNzU5cvX7Y1fW1tTWNjY0amoMXji18sMZBkq6Lb7VYulzMTuc/nM6wLrRHPzdbWltVfkSNPBLbT6bSsLfChQCBg4DQgNBVcTOqA6OgH+d2JhWbyQb+XSCTU0tKiyclJW5lgcekd5KDjfyO1efPNN9Xd3W2uCf57SKr9/X17f7FDsYEwFS8uLqq5ufmIpxGSCTO2z+fTysrKkcmdDQFtWzgc1tzcnDwejxEBXCikhQDbNDc3a2VlxQgV2EiGEFT+OAs41I7zdewTF0mOfEkBVzGsclCAV7GvQ82iyWK/Ly7TvH37tpLJ5JGuuvX1dQvsA7PhoWbyAkDk0IEp4racm5szTQt6FXRAqI/Ly8t1+/Ztw81YUdG4kHTAQSYdSgJIatjb27ODCeoeTyXyEfKqsAIx+TQ2Nlo/I/aUtrY2zc7O6utf/7pu375t434kErF00Gw2a3nprGMYvyUZcH7nzh3DgiQZy3jy5EkFg0GlUil9+9vf1je+8Q394Ac/0Pe//329/vrrJk8gZoVJgTWFeCKeC6Qv+/v7hh/xxcIYzHpaHOGDqBmTOIJXl8tl+Jvf7zcJBqs48hCsYujAYGo51KTDwwQDMYLLnZ0diygunv6xq2EHKz7MSWcoFlOD1zocDutqlGQ1cqTbkpLBoYokBRAfpT1bCxcG7xcxOPzuHJZMcaWlpUeKkBGIc6nBAiNFgbFmcqb+rqmpyZhnimSO+/VjyePiC4jvDe0QOE/+XssPxlHWu3w+f8Tcim6JnKwnnnjCsuPb29s1OTlpBx/SBuw/e3s/amYmnI4PEBwL/AKsiwmHog20LoFAwDRgsEwchKx9kmwiw8gaDAYtPFCSHZbchFDk6NIQmRarzfv7++2gL9bD1dTUKJPJ6MqVK/rTP/1TjYyMmBGWB41JcnFxUTMzMxYvxBdgc3NT0WhUbW1tZlPBsbC5uambN2/qL//yL/X8889b+WlxhhrYChMMmevFOWL5e4FzHGJcNCja8YkiDu7o6LCJnJX84YcftsYdJvlsNquZmRnz7CUSCWOU29vbTUNVVlZmIlvifaqqqjQzM6OVlRU7HCEU8CHijUQ8PDAwoMnJSZvigQOYzCKRiEUKgZdWVFTYGspFy+UpHa7srI4A4cAVbCJ8V0gbRQqD0Lm1tdUOTNg9rHbFrUJIW7B7QdzQuM5zDKNKpE9JSYk6OzvtMoKZ5PKZnZ21y+k4X8cOzv/Mz/xMIX+voBMBZqFQMOCPfRgAvby83Ey0rIzoTRjJ8awBMiOaI1EB7RK3EcbsoaEhRaPRI9MUD31TU5MZboPBoCKRiFU9kSnFqkA4HnXmKL/v3Lmj1tZWs70U41KJRMIORL60REKzCrJyFse1cLjT2sx/hnMAv6F0eBDCTsIcud1unT9/3t63UCikyspK9fT02AFL4mwxy4oDgAuEuJitrS3FYjGTgoB31dbW2gFUVlZmxmqPx6N4PK7a2lotLy8rFAppbm7Oct5xQSD8ZY1LpVLq7OzU6uqqpbk2Nzfbc8JhzaXU2dlpbB5rP6B2eXm5rU8IlgnBk3Tk2aRHMBgM6u7du/YzcAFDABD9TGoFMIPD4TByKRQKGZbG5ev1evWxj33MyISqqiql02mb3uLxuDHQAN8w7rCnmK2JpmG9BY/i0OWZYeL6X3VjXIBcEoD1kFqIiVlZS0pKNDIyoo6ODtN88Xslk0k7uJqamo4dnD/2g+unf/qnC9lsVh6PRxsbG/bgcdMDGAPC47LnIUDox4e1sLCgc+fOKR6PG25C3Ao3vySrJkd7s7y8LLfbrXw+bzcLBwarACsqq0VxUB3SjenpaVsDAPSZmrA8ECRHqWYulzMsDXM4jdWwo+BsuP0hARjpaaXh52xubrZ+Sdgdfs7NzU073GpraxUKheTz+ZTJZOTz+UwGwUqztbWltrY2pVIp8zwuLS3Z4bO7u2s9iB0dHUfeKzx8m5ubZrKl+ESSYXKsL8WKfmrnFhYWjHRgdaTxmy9dVVWVBgcHzTjOFFNZWana2loTDUuy6Y7sqeIv5srKypFnEZEwWf51dXWqrq42xhT5DFlxHJiwoxzmgN6s/yTd0hReKBTs8vroRz9qAYmSLDKa5xYhMWJT/nuEywQd4ksEp0JewhSEL5ULAmwT/LhQOCzboNuAaRk7Wnt7u5FmfDaQF/Q0rq2tWfAmWrLV1VX9l//yX36yWcWlpaUjyQ2MqhhL8fzx35NxhSCwubnZFLv19fVmQsXagxCOID2C71wul4kO+bABDaGYuX3AQXK5nKWI8v8zdvPlKV4F4/G45agjxiM8T5KtPcSreDwey0QnPpqJqa2tTZJMgEr+ETHIMFWwl+Pj48b0VFZWqqury8b5oaEhtbe3W3LGxMSE7t69q83NTb3yyisaGRnR5cuXlUwm9dxzz2lpaUk3b95ULBbTyMiIVZYR/4uGixJaANnS0lL7GZFuIEnhUCv2B/Jgg9mB6cDwFgfqJRIJk87AqqZSKUtLIFUBULsYp+NAQI8HTgb4zgHgdDrV0tKi6upqRSIRS6oA/E6n0zaN8sy63W5NTU2ppKREjY2NZoMCB0LoWSgU7OIh6BC4YnFx0USoKNIRBWO9QhgqyQ4qwjOZIpF9rK2t2VpXDH0gP1pdXbWSjmLrHdY2RNW4DiiiWV5eVktLixg8CFvk4mFzQjrD74h96Thfx35wVVRUaHZ21hqBkUQwyjOGE2tc3G6CUTR/r/ev2F8FDsBIywQEwMjftbm5aYcXhx/pn+A4gMIej0cul0uRSMRW1o6ODgPDX3vtNUmysMKmpiYD57H5EKfM6M/PtbOzY1lM+MV6e3uNcs5kMmpqajpSabWzs2PxOAC5YFrowVBuv/baaybsRS2P9Uc61AaR75VMJvXWW2/phz/8oWFFuVxOt27d0uLiolZWVjQ6Omrt40QPU/slHU6pOBFYWzGi07SMALg4GLK4FAIhKa3eTGV7e3tqamo6grWRUMtEUVVVpcrKSvODLi0t2aTu8XjM+MzEwyFa/N8BuNfW1pq4uampSaOjo2pqarJSkunpaWuempqaUldXl/28HCBNTU0WsAjEsb29bS6LnZ0dS+JlzeSyJeQQZ4YkpdNpHRwcaHp62tZGfIk8g8AJpaWl8vv95l+kpSmXy9mUze9NNHl3d/eRvgQ+D1Js0+m0PXPl5eVKJBLK5/O2ooKPZbNZa0mXZImwx/069r8BCho7QfEDXOxOB+va3Ny0Wu+FhQUb3cnpXl5etgcKqwm4BOA6Ux03FFjL7OysHRyAtPw7yA7476DLOWjj8bjOnDljE9Hi4qJloi8uLhoNTwYXefJMVNhdeNCg7GF0AOXz+bytR/+/9t5sqbE0O/9+xCzEICE0oBlIcqjMrp6qHe12+MQR7TNfgyN8PQ77VnwHjg4f2Q5XdVdWZiVJMmlEEkggEAgQ4juA35Ob/k7/qojuyB3hcFdVJsPW3utd65kWFibGSe4bMhEe7rm5ORWLRZu/0QPxEvAgMXJ///33zlui+/j222/19u1b2zZYIAuus7GxoQ8fPuj+/t6nN2JP8s8B+SlOFGhGH0bhIM5UrVbtqmCUBJBmNyTjMx307OysfvzxRwcY9no9x0KzhwAwHuYRFpaiBEtcr9cdawM0ACDPvydEsV6vW6jbbDbV6XRsqkeYu7KyYsW59DD68Xe+++47HRwcWASLTINuEQiCJIaJiQmtr6979AvuHZDkbT0E+kGWNBoNbWxsOLsNYzndYKFQcLIqBwMjfblcflLowTzxJAY9vvh0Y7GYnRr1el3jhp+kn6BwAZajy6GCoxpfWloy9gALcnt76xNCkqNxCXtDuQvjhdUDvQppElh9Th/Xu6NpYR7nZwluY4E5nJ+f18uXLx3pQXYS2BkdAJ0P+fGxWEwbGxuWNBAT0mq1/GcZfckQD8bCINnAP3l/f291MymgMGFB7U2n03HxZExrNpsWRRJWeHl5qWKxaNvU3d2di8Cvf/1rxxVfXl565GDtVDqd1srKiru529tb4yZ8zz9PeqDoo4GDDeNzQycGnsNIfHx87NGF7DGKHmJYMszoCtHmMdrz/CEz2d/fd2gegljof0Ip7+/vvaMQMzWfPS8q5NEvfvELH3aA/cfHx9YWhsPhJxuhf/e730l6OHyxCyFUxSwdfdyUTnHieQVHxVB+c3OjfD7vkM6pqSm1223/GdjLtbU141p0lbhHkCgBwczNzSmXyznCCGaTjhlAHpsZm6KAB168eOHDZdzX2MH5f/mXf7k/OjryOiVOZOkBlIQuh66XZBYQEF2Sx8toNGoQHLNpJBLR6emplxNgvKYrYDYnypk2HayJ0xGwHVM0uiC+DkI7gFniTkgJgBHjQYJWps0/Pz+32l2Si9jKyorOz8/NBBKUh3QgGo1627ckK8Wlz5n8fH90SqlUyiD/zMzDcoz379/rV7/6lYbDof89eAcFH0yDEfjg4EBbW1u2XLFPkdx01OF0XtPT015cent7a4EpLC8vEHYqVNuA0dfX14o+brzGrM7vyKiINxDwGJlMLpdzd0LR4yXn2aDLkeSOkEOAQs1mb0ZPnBks6SX8kWTQ2dlZ7ezsOB0ErBEmfH19Xa1WyzqoX//613r16pXv9fLysmVAkp7IYXheucB20Yv9uUodqAAsllgemHSSVlKplDt2mHcSdhnX8ed+//33DgjAlRAOh3VycvLEiE2o4Lfffqt///d//8sG5xnbgiJDgD1eSjocSW7XE4mE7Rv8XZJK7+/vXRQoKnwvNFHgKBQNlNSwbsGXBqAXkJLChAocgP7+/mFzDKmn+OQA0+kGpQexKbYOviftNC9JJBJx+CH4AycpdqTV1VXVajVls1mPCpjRwfYYuaHYC4WC2u22kKFwmrMApNPpuLusVCrG48BIKM78rqxmJ08Lbx7sMPglOAsRQtwP0jNSqZSxFTx3dIJ4TXO5nAs6OKMkY4pgRLOzswbOz8/PfUAgLu33+8aAWCVGB8z/5n5fXFxYGE0Xie2GlxiMEmP87e2t1tbW/Lytr6/7M6Xr5fOoVquamJgwYQSxwTNFlw0Ty2ELHguzS0pJkF2kS6UJGAwGllNID5a7q6srHR8fa21tTdvb28pms/rTn/5kr+/5+bkhGDa2gy2Xy2UnVIDdcUBDsNzc3Hj/6cXFhUql0jhLykOdGPc3ADxHnDc3N2dBIyMUER/8eT4oBKmwh9C3odDDEk8+dLKwmOV5uOiqhsOh2UmC06C8MZiS7sjYyHIKQHxyza+urrS3t+cH7/z83LHIYBPRaNQqZliutbW1J9uiV1dXDY4GM8EzmYzB23Q67Sx1aGmKCi/MysqKiyveP2whwfuPZYQCKz3gZUtLS/rxxx99cqOzSyQS/lyCOwlJckUTBJ0+Go38+zH+MW5ghh4MBiqXy0qlUsrlct7Ph6SElx7GGVEvwX9IY7LZrDtosrnomjKZzJNEEQ4x7E1gRqQxkDOP1QZpBdubOBjpLiX9/7L4GQXZKM4YnU6nrbvCslStVnVwcODCjBiZDduSPHZeXFw4WDAYywS2OjEx4Q3rQZEvnS8sNNq+oD+R9WX8jhQrOvBiseiCTzoK7xSMaNDh0G631el0DM+M+xp74eIDQzNE6Bp2gnQ6bZyJkw8Aktx4ihcvBw/e8fGxJFncSEoEAlX+G9T1x48f9fz5c+3u7tqSwoeGXIEuDT0RmVwYwUulkvEQTvlQKKStrS3bOdCoIQoE54I9JHKZLCmKGP9M1AtFZ25uzjG8MG50mWQnzc/PO4WBzpBTt9/vW6FNMByxxUtLS9ra2vL3h+hAN8YpTnwQKmruda/X86ER9JlKMs5Uq9U8AhItQ6w25AJ6MtTs6Pt4GTOZjAWoxEmnUikztkgyAJXD4bDzvshrJ9cK7RnPAGMXIyfPGCkMwA5HR0cOogwuYqGon56eqlgsmoABUL++vtbx8bGJJ3YZ0PkS4yPJ8g3uXZAZRofIIQ/GChTCfYfhRsuH/qrZbDpHjMmAlF3GPixPFH0gjkKhYJEp/473jGd0fn7eQt9xX2MvXPjKSB9l/AHs5EVA4BaPxz0CdbtdDQYDa1uQAeAzwxkPsIuoDvCQcY6xh7FOkhMISAhAe8ILw0gyMfGwOQcTN9IKChupFIeHhy5mg8HAS1gHg4flrR8+fHDXk0gkjM/hAaOIAtpCHLRaLecm8XPDWvV6PRWLxSfsEoUkiB0hPgyanVnNBVvLw8diW1TwQaX20tKSXw5CDOkSWFbB96FDgnnkviGSBLdhMUij0TBDxX9jND4+PjaDd35+7sMJ0SVyFP48jDMhetyrVCplIzYdDYzfaDTyZ7y8vGwIA3vNaSCcMBQK2WqD7SUSibhrAzsE52M5LMp2NFtgm9x7zNbhcFiNRkMLCwvO1sdfynsAjMF2JFwCiLaBVq6vr9XpdAyg12o1v3PcI0SnxGlPTk76QCFRotfrqVQq+WtzeIAvg8/2ej0fquO8fpIE1ODpRFQwDBuALB7Bvb09TU9Pu8Ohu0G20O/3bXQG0AYjACQPRqcAVMbjcbOC6XTa+hlsF6isg7R7NBo1wLq3t2fAGnkCViE2rMRiMQPcPIiSbMugMJ2cnFgmwVjA4ghwBzpV9GuId0ejkTEpxtvgw0dRRatGp4HbHxyQ4sALent76+SM7e1tryKjE6LIc1Bsbm464YKU08vLS7OFk5OTjlUGkJ+ZmVE6nXbhQrgoSV999ZXC4bDjkjn9iV9OJBLWqRGJgxCTLH0sMXt7eyYQiLCBXDk/P1cul9Pe3p4ikYjZMroT2GBGWz5TcFC6JYD8k5MTf1awwbz4SEJIk22327Zd8T7w+UhyIN/s7KxDBCX536FfAysGLAeEZ3HK8vKyms2msTbkGisrKyoUCi5I5LTxs7PBB1IEEWywU0cATLggvxNpJURYj/sae+HCxkOmOmA5LyE3EH1SoVBwnHMikbAZFUyBgjAajdzdzM3NWc2MEhmaFyyIiBZ0Tkgv0Lpgjj05OdHp6alHDApVNpvVcDjU2dmZcahg3Mri4qJqtdoTIF+St/syHrGHjpcbAyzruPAr4vJndADHQLQrybhbIpHwSABWwcPHGHJycmLhriSfxnwdutbBYKDXr18r+rgtBu8fIwovOnod5BWLi4tmfOlUwARh/IilmZ2d9feS5LRT0l+DyQfYj7777jt31CcnJzo8PDRhEIlEtLOz401RHDj8fktLS4pEIoYF9vb29OLFC01NTXkJbfCgBJ8LZo9RVFqtlmZmZswOk4owMzPzRKuHYJfEEZjN+fl5k1NsJwouwYCdlT4TW3S8fG4sGGbcoxNmUoC9RaCNTKharfrg4ufjIKE54BknQRVXQCgUMukCqw2EkEwmba0jA2/c1/glrpJfPLohhJ+s66LD4UShuLCckhGIU58Pij/f6/UcNbu6ump6HmMq4XzX19fe6MP4AKMZiUS0t7dnU+/m5qZPd8Y5RpnJyUm39WBDZIQVCgUDlsg/SE1Ip9OqVCpOmiQymhwligsJF6iaGY8ZQUlVkJ4uuMXywYsC+BzsGBBoMpLw8gWjdOgGSFRFzBksijC6aNIocHSHyAckec8jNHo4HLY2DtvPy5cvXdD47/l83hR7Pp+3HxOmD2D+9vZW+Xze4zexymBdFCNeeMZT8DPkAMhv+OzQM1F8+D7Hx8dP4mf29/c1NzfnJBOgjZmZh+TQnZ0dxwfx7Hz69MlYJR20JD8LZ2dn7m74LBEDs8gDdheYhegm2EHEpMTgrK6u2v4Ejrq3t2e7ztTUlBNoYb+ZPBqNht9TCtpw+LDlh3/GUgSsMc7rJwHnMWTCpIAbsfMw6Eyn4+FDYgXUwsKC0xXpsngQAP/xnL18+VLSw4hGHHG321W/3zfOQHIjBYFCBA6Glonk1fv7e297Ji6HbouT6tmzZxY5wjAiyoSFIaOLzonoHDCufD7vh4Q0A3ANfGQUfsY8gHtOUSxT7XbbxReLCF1Fr9ezZAOMQtKTEZSUg6CtCnU7Cm98hixFgc0EdI7H4/46SDh4IZB8SNL29rZ/59XVVc3OPmxVBnu6vb015hbUnzGiDAYDZ67T6aBQ51lKpVLuwImw4UXn9wdbbDQazuuanJxULBbzs4rcAFKBrH/IGn4mcK/gIVYsFpXJZDQxMaHd3V0XYcYs6QEvJGkVLJWxGPKInyHIunOP6NK3trZMADCN4HA4PT3V9va2Njc3jetymADhkNCLg4FnaX5+3rgbpAw+TBjccV9jL1wrKytqNBpKJpPuEuh8Dg8PfWJy8vIA0u4ifwCDolsK2ntgNGBWAI7/9m//1hn14EgUlFAo5OUOi4uLlkCQAjAYDLS1tfVwkx7jSPjfRBvTpVxeXuqrr77S9va21tbWLLMAxESZzYO/urpqXyWUMtG+9XrdOBVaol6v5xGFB4lt1DCyKLiDY8LGxoY72tPTUxMQjNh0pdfX1xZdsk0JawcdB8WJrw+dXq/XFY1GHWfC/sZkMmkmbmZmxlhWs9n0GrRYLOaOl7BJPoOLiwvjdhRPct4Z9XFdQAyAcyKC3dzcVLlcNlhMtAvyCfAl7u3V1ZXZUyQ5BEG2220XRp47isFwOFStVvNKL0neAs6BiMKdpSHlctmBi5L8e8EEHx4eGnyX5OeHgx/9HkJXPq+guBqvK0xzv9+3lIWx/P37995ejiUMS91oNFKlUlEqlVIsFvP7OxgMTBr1+33t7u5qMBjo5cuXbgrGfY29cJ0+rl1nbg+KDdnAApsIzkIaqCTnNLEcE80Q8gdGSEn+d9lsVp1OR3/84x+dHNrv99XpdLS+vq7Dw0ODt8vLy7Zx8MJiUzo4OHiSwApVzMsVCoUcVLi3t+fwvNFopHQ6rZ2dHW8TIjsrKGQNZnfT6aCxgnQIRh/f3NyoXC57Uw5WEcDlTqfjHHPafl4IcqI4UclX4qWGYev1ekokEu4AeNlxEUQfU0tR99P5kjZLgazX6xZ/cjI3m01npeFflT7jjKjeMauz8CEej2s0GmlnZ8f+SUl+edjOjezg8vJSR0dH2tnZ8YFDlw5AD4COL1GSGVReYHx9dFZIehh5Scet1WqamJhQPp+X9HAwoIFDQsIhAHbaaDSeML0csLC27M3kPkjyAQU8QSwP/437i9yDRA2YdmCVWq1mMS2dHazj5OSk3r175+53bW3NSRlgYfiM8Rjz/r19+1bLy8uOAh/nNfbCdXBwoHg8blYMapbgNkle18XNmZ6edpwK7TLCQR58gghh5WZmZpTNZr1cAUobQJuTiSUWqHsBrMG52MBCRDFdCImShBlKcsYSjM/Kyoo7QiI/MCVTvAExYd8Q7EFYoIMinI17w5jw/PlziwGDGBzdV6lU0unp6RMQmILLiI4thRdQ+mx652GfmJjQ6uqqtTrdbtfjH6MrjBodL3AAgXxE/SCGZBxhzyBJGOTxz83N6ejoyETN+fm5Dg4O3HWsrq5qb2/PBTcWi6larVpycXd3506ByHC8dRMTD5lmQaA7EomoXC4rmUx6Xdvh4aGLGuA/ox8dM13dDz/8oIWFBb148UKSTGCAsVLAgEGQcYTDYWWzWfslJZmUODk58c+HqJRxkY6QgwcCh0yzfD7vUZcCSQGFEIpEIsrlcspms2o0Gnrx4oUdKbCvdKJIXa6vr53rBTYYPNzQsK2urqrdbqtcLo+7rIy/cGWzWYPMy8vL9ixC1ROrgoeLlwLN1tTUlKUPnU7HoCmnNBIDcK6ZmRl9/fXXnvt5mNg3Rw53o9GwgplTrd/vq1KpGGhlSWm73XaCAZQ3qaSYjpET8GJzejNi0V2AM93f39tmJMknL+JLLB2AuIzCo9HIItW5uTlrhxjp6vW6V6Tz4jSbTdtWKEqS/AKgp0N9ThFCzQ0uBFbDYZDNZr38o9/vW46yvr6u8/NzbW5uWq9HNhmeRO4nvrzp6Wn/H53o/f29c98lGccMdt0sZ6B4YoJnDOX7R6NR56zF43F3KM+ePbMsZWJiwgWcJascepAeExMT2t/f1+HhoRKJhMW1GLPz+byN0MQoEXPEGEUIwOljPr/0kIoSjEgKdqNgrOHww0ZyRk/SUYiyIVmW7hZMtNvtqlqtetq5uXlYhBKLxfTf//3fniBgwCncwZG02WyqVCrZTUIiB4cMo3Eul3uyrm1c19gLF5acPx9fGGHQBN3f32t3d9ddEVYNFgSgQ7m6utLa2pq63a6eP3/umBO+ZrfbVaVScW5QEN/i1Io+BshtbGyYoeSBR+OVSCTMBKXTabXbbW1ubpqVIotrYuIh7x7NEmMi+BcnkyT/nPgh0VqBiwDeMkqm02nlcjlFH5ffAjqTPsGI8/LlS5+00mfzOt+XWBJ0SGhzgvHFvEgUVv4uIDd7ABgN8BuStgBpQiZXKpXy5iMEmlNTU74f7XZbJycntimBM2GSZ6TjUGMEGgwGJjumpqb8otGBZLNZF9rr62sbsVG7o/hHxgFwD6EBFtvv93V6eqrLy0tvTAKDSqVSymQyNmgz+i0uLmp3d/eJKZrCwYsOk4r5+ejoSJIMEVD8+Vwo2tLDOJ9KpXRz87AmLRaLeZSDtACfhd3Gx8oBTWIpBzXWNFwG7CrgZ4DNpBuEZSR2iX2MwZVshAGM8xp74eJhY9RKJBJPUkwlaX9/X5lMRvf39w4wo7Um+vjk5ESNRsMFL51Oq1ar+UOBqZLkDSooqxmzIAEAd9FBwT5J8ojUaDQ0Go3cvbBt+fLy0nvkaLvL5bJ9e0H5ATokTmwKCkJPMAlepOXlZdVqNRfXTqej/f19b625ublRo9HQ6WNYnSSLasFyuKeMTQh4WcVFegRq8MFgYIM3hANYCoWVpAmwEkYBRhlJ3kLD90OywZjCn8fKBcaJUTqTyWh3d9fjSTgcVjwet+6PKBvGY6xO+DzxwyKQpTsG/6NzJoKbEYdihD4QOQAjHpowQHEkPeVy2eGCHBIkjUQiEcMekpROp53Pj6WJqKLz83PnhwUV54x2jG1TU1MucuCmV1dX3jiFvIHvcXFxoU6n4yKO9mpjY8N2M7pr3imkFkg2hsOhCyFNBzginwGHDZE6Hz9+dALwOK+xFy5Av+ACyXq9rkKh4FYfrVIoFNLJyYnz0SX5Rr98+VLD4cNKrz/84Q9WVPMgE9kRi8XUarUc5JfP5y10hPUql8vW6FBYwI0w0FKwgs57ts+gL1teXnY2ufTQtVAgyJOCkZMeuhdiUSAVAO7v7u6sxF9YWNDMzIy/niR3CDBip6enqtVqKhaL7uQ4IObn573Jpt/vG3dj3GNkQ1uGmRcjMmMJpzWJHBiO6VTRPkkPLxPFFb0PW77B0sBeyON/+/atNVvlclmdTkdHR0c2LpO8CokDfMA9oBMAO1pZWbHFCY0e2W50OMg6wAiDhSGIP3W7XdtZwDiJk8GJUalUNBo9LJMNh8MqFAreul4qldTtdk0aIFNAdMrzV6vVnP0FlnVzc+N7hqhWkpM16BIRmOI8wTyNFQn9Y9CTicwnFAo5fZhgA94BRNAQV0wY+B8pcmSwITliQQc7Ncd5jb1wYfYlHZECxqk4Go2Mldze3joniBfv9HHjyNHRkb2Jf//3f69qtaqjoyO3tGAMsGOlUknlctkfMh9Us9l8srE4m83apIqrnoeNh1CSNxKFQiFls1mtrKyY4iauBbErES+Mu3j3SCWFqOCkTCaTSqVStjChTyIUjwBEdD+wiaurq6rX6+7oODmlB9Ev4Y10ohQlhKiS9MMPP7hrQFQKc0ShKRQKmpqaMhiM2Rh9F8WQTpDubH9//4l/lG7o7u5O5XJZa2trOjg4sFJ7fn7+yWhCJhkjUqPRcPIshwn0/czMjDqdzpPOSnqAKj59+mRmEovX3NycpQ7ITnhRSd6lKyH/Hg8kfj4ErpFIRK1Wy106hxVfg3wuHAQwofg5kbJQcCCggEpIq5DkmBuwL8gkIn1wbgQjn5gE6ADRRnJAYEMjBZVFuySmXlxc2KZGXj6FFhJCklM0forrJ7H8sBJrY2PDjAsnAloczLO09QTWkcCJP7BcLhszKxaLHqtgOjg5OVUByQF2Ly8v/cEF19CD20D5MvqwKQcFcigU0p/+9CfVajX9/Oc/96h5fn6ufr+v169fG//AngE7CrbB96GQtFotr48PhUJ6/vy57u7uLH7tdrtKp9NKp9PGoHjZSI5AWAqlHolEtLi4qMPDQ7OB4IAkcUQiEe/9o1PlcyHLCqU9pzv5ZXQ9nOZB4qPVarlbxVOIABeTdTQateylVCo9IWuADX788Ufr1ehaMaiT3YVPE7EtjHA6nTbVv7y87Ex/uvGLiwsfLtiNeHGRGjBmMUYS0c0UcXZ25o3OkAMwmIhk6/W6hcq5XE4XFxfa2dnxYYC0hYJOvBAHEOTT4uKiWfhOp+Mxn2eB9wD3wcHBgQkXtGdAADCYwCYcqHyuvHuQVhymw+FQyWRSxWLRmCtuDpI3eLbHff0koyJjTKVS8ZZntFy8tLA+kgwck2c0NTWlQqHgrczhcNg0Lw/F0dGRKfXgCIHXjBYWPxgjKllWl5eXSqfTBht5IdfW1ow90DEkk0klk0n98Y9/1NLSkjsFsotub2+f7LojZeL6+tqq92DOOKwjEob//d//9Ybh5eVld1QIOxFkSvIDmEwmvVAUNo1obBhGUiFOH5ePtNtt21KazaZzyugkJicnzRjxQOLjA5MJYoOMdmCUgNL8PJL8IjSbTWWzWS0sLOjjx48uFhsbG5qbm1Mmk9GvfvUrffjwwV+fFyKfz3t/wGAw0Onpqd68eaONjQ1ls1lJckIpufMky05MTPiA4EB79eqVpS501eyVnJiYMFFDp8ZyC8Io0eCB51WrVYuhiUyiQ5ubm1M+n/d4ybMLm8xzRoIFzyvPFgdyMAjg4ODA29ir1aq7MthLhMZnZ2e6v783NoWhH/V8t9u1xm04fFiegQ4MNpKtUTCswYw21rmBv47z+km8igg5ycheXl72qJXJZHRzc6NKpWLQlJOb7TP4zOgiKHyAzuBMnEiXl5cuIBQeWmY6COlzzC1JpITLVSoVa8DY0MILF4zywJM1Gj1knUM8ZDIZj1nYJYLiT+w9FAZsLRcXF0qn0/rFL35hdTmnNngCi2gBrBGoNhoNFYtFL4ZgROXn40HEa0gHywOfSCRcDEejkTEZcMRUKmUwHBYRDRa4BwA/o2KQ3kdvFH3cjDw3N+fRnqxy7gNBiu/fv3ccDHIEmNXXr1+r3W5rcXFR+XzeTBh2LUnucPl7/HzT09NaXl7W+fm54vG46vW6nyW6f8ZPOkcKG8WFbDYKOVq06+trs+B7e3s+wPCB4oucnp5WrVazsZ4iK322bsHIwxgC2MNI88xubGx4fE0kEi6cTBQA+IhQ8UHiSYXAIMo8ePAsLy9rbm7OgmG+BtABBzw4JLqzcV8/SXTzV199pYuLCy+MCIVC9rTR2q+tralSqTxJ3YRiB/AG9Mtms9rb2zOgGIvFzB6CRbAoEwEiIDgjQr1eVyQSMVMFwMgFsIudot1umxm8v79XoVBwGw67eHt7q48fP2pnZ8cZ8UG1cSaTMbCPPzASiZi2JnEgGKcSjDThtMWyk8vlLOhl+Sgd0/n5+ZMkBrRNiFUHg4EL1MTEhPc39vt924FgvjhREXfSfYVCIYcsgm2wtYhuIljYeDHevHmjQqHwJLEBWQMXGffoz4bDoUWpQAqA8VhM2Iv55zIaOlq6/06n42KMKJhnBeaQg4FRLYip8TzSATImMV5ScDjYtra27JkMh8Pa2dlRLBYzDIDjgBceL2XQBE4iCr93q9Uy0M4oKckAeavV8lQTzLtrNBqanZ21FUiSnwWwTmCPIDxSr9d1cnLi54OsfLBhnpXb21sHDozzGnvhmp2d1Q8//KBMJmMVfLPZtKIeMR3dEtlYjBYIAQECJyYmVC6X9c0333izDSMg2FYsFnPbTvsvyWMMoHU8HtenT580OzurcrlsXQ12D7LDiMhBZX5xceE9c3d3d6pUKjo6OnLCaiaTsUIbRooxlhFjZWVFvV7PZmeKMB6/4+NjMzqYx3O5nIH+Tqejw8NDlUolHRwcaHV11f8M8wcOA0hLtwfuOBgM/DKSHx6JRJTJZJyDT9GTZEC3UChY2xTMI2eMp3OiW0Mqwjhxd3dn2p5Y48XFRWuJwD1brZb29/d1dnamQqFgDBNx6sbGhhKJhNLptCUtsKq8bHxeBAaSoxWLxXxQsrCXn5HPf2ZmRoeHh5ZWwAYScUMeFvePYgmuRsfDSrKgJq7b7SqZTFqH+OHDBxcurFUIRlHvw+LCWBMUAAaFif/s7MwNQhBfjUQivt/lctmibaRBeEPxpIZCIW8UX1tb831nqS5kGy6Js7MzlUolF9FxXj8Jq1goFDxjh8NhvXnzxtgULw+ZUoTHsTkXIyfRw7AmnM4AuyyBZZsJCQfgRjCLx8fH7pywScCk3dzcOOWSBxAgFssL8gRYvLW1NY85rKWS5FMIKwm4xfHxsQFxss6z2ayur6+f4Airq6veAhONRi2WbLVaCofDevnypTPOg8GCwVOcMQZP2/z8vGn+P/3pT04DBeODraxUKlZCM8oOBgMv7Wi1Whb21mo1y1fQrxE7jUOAk5/iwUv0+vVrnT5uzEaYmUwm1Wq1LJR99eqVR0EKA2uxhsOh8vm8CQ3GXxI8wGpub2+tJMdOgw2HAD02S1EwgokfrVZLp6enJni411ii6LCwwKysrHicur+/dyeMto6MLAgH1q99+vRJkhwsgCSCgyAYssgzf3h4aJfAwsKC/8zl5aWazaYuLi60vb3tjor3DifL6uqq9vf3LcztdDr6/vvv7Xghk56ubH5+XuVyWSsrK95lSUMSi8W0vb1tlnGc10+SgEpbC+V/dHRkevX8/PzJjjYe9KOjI2Nc4CqLi4sGjonsZX8cDArfE4c/Ucasm8rlcioWi86yX1xcVKPRUKFQsIIbQ22j0TCLRKvebrcViUSc+ID9hrYbHGBq6mHnI0A/WhwM4IyASCagzROJhMeKYLgfbGyxWDTuRaHC8L2wsGB9UCgUsneMTUOYZhcWFpTP542hRR93+TG+plIps1yM35OTk9rc3NS7d++suqZInT5u/AbY5WfAGI4Kn04oGEL385//3JnovV7PUhi0ROCBt7e33uqdTqc9biPNYDQiKHBjY8O56bBtp6enXiEm6Ql+yUGIfYtnSdITho14l5OTE+uu0IKxDBbzMX/n6upK/X7fW62np6cdKsDvxPcBQAfYR+XO9yE6BlIJ0oGvwc9PEGe73dYvf/lLDQYDBwlOT097wcve3p7W19efBF8uLy/r6OjIW4ogg/is6bwYKUejkSEZPvdxX2MvXADDgKFYAjKZjCnqoHmUrmM0Gj0B/NDF8FAwCqJuB7wHr6JYEHJH8Wk0Gs71IhOLKJaNjY0n8TPLy8taXFw0gM+4h9UEQSIvLJahSqViKwaqcyJRYP6CqQ+sSQ+Hw0+25yCMnJ+f19ramlX02GjoJqDjb29vnRMWzH9i9x94Fl3r6WNyB7on8DgOg6BlBDU2wYHZbFaHh4eS5C6PMEdIjbm5h21GQU3YxsaGksmkSRleeAL1iFCmwBJZs7m5+QSHZHUXurSbmxuvns9kMvby3d/f6+PHj37OQqGQMpmMOp2ONjc33WGBDZGRBolBeCQqexbEcj/y+bzC4bBKpZJ6vZ4POES+HHBglrBuvA+A65OTk/qv//ovvX//3qLSiYkJr0AjPYNoJn4XPje6IvRr09PTlqVsb2+7C4Mo6Ha7xjxJmyCeSPoM2PM+4e8lAhzyBuU9uzTRa477+kkKFw9lcE9iq9VyhjjtL8tYaa+Zv8kr//Tpk09MXiy0IxsbG46OwYOFR470Uh5ySQ4WBFtaW1tTo9Fw2y3JIYVgIoxZxC2DH6BMp4VHrV8oFAy0g1Gk02nFYjFjbHzo//M//2NzN0B5JBLxwzYYDPT73/9ew+HQoxxufwoqIyHjJv5AcqKg9SV5mUjQC4eWjOKdTqdtwOXvraysaHFx0TYjwGxYL9hGZArskwymlBLVTbEn9YNCjuyAKBrU/ez8Y+ynIATjXSB91tfX3eVubm46Nubm5kZ/+MMfFA4/bBCHgUMgK8mQBM+QJMs/glABQliM7OA/x8fHxtIQM+dyOWOssNmQTXTM6XRa5XLZouDj42NVq1V9+PDBYt/gMwjpQXfOiIuuL5VK6e/+7u90dnZmEoffg3eQz71cLuvg4MBBg3RZHI4wqliNwDdxrZTLZeXzeWOk475+kr2KJIOS8gDzB65DQmMymXQ08czMjFqtlgMGOWH7/b5TDyhgoVBI79+/94eCuBGLBQ8N/jdwCPAv9FuTkw8rnIJRyolEQr1eT8fHx/7+4D+MhTykSA7QccE84bEEY2NVFd3P0dGRGcfJyUlHHSeTSS0sLLhgI4DEcTAajVzsb29vFX0MSKSYMNLwgNFlodyXHl4a8vSnpqa0v7//RBhJd0nGFS+1JBvG8YmiKZNkXR4nfXBpLKZvQv16vZ6LbSwWcyfw29/+1gU2+rirMhiBA+aC/AW5xu3tw1JX5C8A93z9r7766ok3D1Cc0QjpTrPZtI80FAo5fQPJyf39vcMw4/G4DyhGu+PjY5VKJe+efPbsmXZ3dw2cE6bIGLi3t2cWF2lKKpUy3sQ0ggSBUZXn8Ojo6Mmhe3l5qffv33scZULBcwjxw7PPoUDYIB02RSuTyaher9uihl8UJpVnii1G47zGXrhoh/FBQeXzARAYSOuN5gZsifga/IOMgHROrHD62c9+prOzM2/gnZmZ0erqqnOwGFfq9bqV/MgRAEkpYiyroLsjJA4LCMwTowp4GbgE8SwExW1ubro7+Oqrr/xn6Makz9t2iECORqP6/vvvlcvlJD0cAI1Gw6dg0KkvyVEojAso6NHDBUfcZDJphTwRwOBQnJYQBBQvUkqJaJFkwJzuQ5KLBZ8ZHRW/LyMO/4zchYiebrerRCKhZDLposwYg56IkDxJ7ojb7ba1UvjywPUArSORiCEFdFlIIAC3gzIFfvZQKGTR7uLiolNur66u9NVXX2liYsKryBC8ssxjf3/fB0m32/X6vVqt5mfv9DHLKpPJqFKpmElcXV31gt7V1VUTM8FcN+4/BysTzfn5uer1uoXY0ccQS55TXBUIoTGSw+Yy6YA9T01NqVwuu+OkESDrrVQqqd1ue0nKuK+xF65oNKp0Oq1CoaDV1VV3NFRxjJ6AxJyajG8E5JE9FI/Hn6ysZ3suoO3q6qof8m63a4yEbmdpaUkfP340/kHmVDgcNp5wcXFhnAEs7ODgwHgZJx5iRU6qpaUlx9Swvp6RB7GeJAtgGY+jj6miNzc3qtfrViWz/ZoTl8IxMzOjtbU1U+uclnd3d87mCm6eIbKZzoTCTpcFm4UM4ObmxtIDfgZAd0ZZ7jEPLl0ahRFdG+6EVqul58+fexyjKGDyhWh4+fKl3r17564qWITwImKaJ8BuZuZh6w5gPMp+XrhWq+XDikwruhRJLqQkfRI4iODz7u5O2WzWGjxwMA4nPKR0M5lMxvsU0FDd3t660FEEz8/PtbS05O3j09PT+s1vfqOdnR0dHx87NRg2mcJOUYfB5v0JmsLBF0nF5WeAqKlUKo5wIrQTNwK6OqYKMuTn5+dVr9dtH6K7BdeCxcYDOs5r7IULC8SnT5+0s7Pz8E0fNT8I+aDC0UthfyH5E5AUrdHS0pLTQfl76IJ6vZ6q1arpcoSEw+HwyZp2Rg2U3rBle3t7HtEoRESmcJoz5t3fP8Q/k9q5v7/vETebzWp3d1dLS0veGUhh5vvf3d1Z0CfJoyIAOCkTSBYajYbevXvnsY90CaQijD0snGDcINt8YWHBQXT8Lp1O50meGC88Lz1jMNKUXC7nk5l7EsS2yC8HvKWjBEtkMzQYEvFAQXHvN998Y2wFg3U0GlUqlbKXlQ4VjItsLzrO4FYcsB20TsGwPBhDAiBhIOkgS6WSvbBzc3PuRji0zs7OTBigUH/79q0N8pFIxELnpaUlVatVTU1NaXl52WvjwNjAok5OTnR0dORCTYGgi+12u08SIvjZEcxWq1XLfjKZjKEXki1oBJgUvv76ax0fH+vVq1dO6Oh2uw7qxJHw4cMH32+im3nHpQeSplKp6Pnz5+MuK+MvXM1mU4uLiyqVSs7wRoENtoXoFDyBDwJ9DLgNGUDgKKjlr66u7P6/vb213IG/F9w7B4BJp4Ohe2try5KKWq3mDchQwATjYUTl5wNbIlESYoDZHxU2hulEIuHcqfPzc3dltVrNYtWZmRnH22xubioSibhzReAKEUFhvbq6sqAyGO8bjKPp9/v2StItIUU4OzvzGjk6HZTbCAr7/b43+VBo8DKS7AnLmcvllMvlrKzP5XJm3M7OzowdkvQK7lir1XRwcKBoNKpEIqHXr1/r6upKh4eHXghxcXHhAsDITJwzuzTRh/HfLi4unmwAIukiFAp5oQd6NfA9EjooxPhUc7mcO1okJVdXV9ra2tL9/b3evHmjdDqtu7s7ByFOTU3ZqHx2dqZ6va5KpeIO7fQxgXRyclKZTMZMoCSbr8F6O52Ot5Az/rVaLUcyQTTAgrI9++Liwja0aDRq98j29rZ1YghnEafSVLDUOJ/Pe4cDXs9oNGqYh4STcV9jL1zPnz/XcDjU7u6uc64ZPRCkciPwhhFHzP5BOofBYOBRcWtry90AuBntMgB/PB5Xp9MxI8gJSMuPlWNlZcUOesbFXq/nk5wCwMgZ9E6iR6JriEajWlxcVLVatSUkHo+rVCqZ7ofah36nIGKoZSRFKhEkMcB78vm8dVbQ68hGGEUxQPNykTAwOTnpTLBkMmnXwPT0tAqFgtlXutmgNg0WEwzx9evXFueS3om2ZzQa6cWLF1aA9/t95fN5zc7Oql6vO82CXZpo4qamptRsNp26ORgM9OrVK2Mn8XjcyQ7SZ3cFnkO6G4Sb6PVgPwHpg6wqdqf5+XmtrKwomUw+kS8QI06nAfva7XZtvSFQEhEvDGkwEQUgHzM5zy7Flfvd6XRMDkiyWJbPEW8vYYSlUkm5XE71et1SBjp4zNoEO/K/gWSwZ0kPOC+yjvn5ebOGxFkDvAMpMG7TlaMAGPf1k7CKx8fHKhaL3kzDC0sEDV0KFgYAcTKnkB3c3t5qf3//SQghoWtkb6NWXlhYMKPGWALFjKG53+87/4t8KE529GMUC0L2pM/ryjBj833Bqs7Pzx1ehx4MfRMmbCwrpVLJok928LG0A50ZXR5g88zMjNrttnVfjH/cs3w+b4YVUzrKcAzgg8HALC4xJUErCIkOdJaMccPh0HhGq9XSu3fvHJeDFookh3w+7yWpdDfIFfDF8TlGIhEVi0UtLy97UxNykU6n488M/V7QzsWegKBaPdjlBAWd6OQY+RYWFpxQCuv6448/miw4Pj5Wu912LhbxN/g3KWgs/UXLNjc3p7OzMzUaDS8IQb8myewhmW5IadB3zczMaHt7W2/fvnVRvrl52PI0MTHhjn1hYcGdYb1et+AZISwNAXsymQBIXUW0C2SBsJaf5+zsTMlkUvPz82q1WmaWkR1BTOAaYTIa9zX2wsVN7vf7SqfTBkt5UBgfJBm4ZTMuYwpBbXNzcyoUCsYq0A4R4YEw7u7uzuJPwH20TLTf4CNYZra2tmyfgIXBS4b/DfkErB6bgQFgm82mTzxMvb1ez6kPgJ5TU1Pa3Nx0lEv0McMbF0EsFrP3bXFxUbOzs8Ze2OQSTFcFY6nX6waP0U6Rm0WcNSwSWBp2GsZqrE50ecGIG156sC/8jmtra2bOUH9Xq1UNBg87MpeXl73Eg70CYJlBhfrx8bExr6OjI21vb2tubk4bGxtO9yRLit8BWQsjLlHf/Jyzs7P2DPLSEl6JhANFPZlUz54904cPH7whHSkE9xV8i3uDbev+/l5v37719yDFFt1Zv99XrVYzRsSEwL2AeJiamvI42u/3jZ11u12P2nT6fE4ECLx7907D4dCShVAoZMaVAijJBX52dtbCUiJuwHG73a5hD9jEIGHC8wE0AZb8V+FVJNKGLKtqtept0TxcULuMEKVSyacmuijMo1DYnFIoxoNAOrN2r9fzQ4coNDjasQMRsJvWGeX+27dvNTk5aRBZehgpUqmUxbNgDog319fXn4hA6UQSiYSN5BsbGy46Kysrev78ubs5wFPcBoT1IQIkTQH9TiqVMktGd4qMAU0S4D2GWH4XUhIo8ozwnU5HyWRS0uegQtwDxPvA0sbjcRMa0kMnQUc5Go304cOHJxu7MdbT7fLiDIdDx/kgr+DlhSjgRUwmk5aG0IEBvqPNAjujgMIWx+NxJZNJvX//3tgfyRWo66+uHjZ086yl02mFQiGtrKw4dJGRjeeJUW99fd2j43A4dAcCoJ5MJo0l8vWq1arq9bo7SjAm7iHvBpjdwsKC2cKzszO9ePHC4QAUUN4DSTZBc9iybQgRM5DEcDg0sQOxQlb90dGR73P0MXuMSB4gk1Kp5M9r3FeILmdc1z//8z/fM2KAUWE9AXugiBDNguscrQhSgdvbW62vr+v09FSVSsUfGAA/9hSsCDBnyBDAZ04fd86RixRM/UQ/dnR0pFwu5+UJjBXgSHRm2F/wU4IF0KrPzc3pxYsX/n2mph6igPP5vMcxRJ2kLxwdHZmqRmQpfV6EQUAfLy2nIv8d0PXs7EzD4VDFYlGXl5c6fVzWioo/SFjg1wSERbWOODH6GDdMUipRwKVSyeMMLHGxWPR4OBqNjCPd3d1pc3PTI3QymdTt7cOWJwLwOORmZh62YC8uLlpSgm0LzyVeOYL1+JyQQ2ANQ4nPJqF2u+1uOpjHj4CWsSeRSOjjx49OV0gmk2q328rlcopEIvr++++txQLDQrUuyWQCnRG6PbpTlqXQ+eN5xZaEOZyMf/ykl5eXOjs7c1c+Go1s6ep2u8asEC2vrKx4zR1jXr1et5eXr4sGCx1io9HQ6uqquyjwYgTVbIvCNgaDOzMzo3/9138da/Uae8dFm4pdguhecCviRxjJLi4unJLKqYH+anZ2Vu/fv7ceptPpGBAPFi2Yj9XVVd3f32tzc1OxWMz6plgs5j2FdH6Xl5d++RntwNpIHOCh4GFPp9PK5/M6OTlxTpUkK6tTqZQVyKlUypuyX7x4oV6vZ3EhAPvKyopisZgXdi4vL6tYLBpDg+lJJBJaWlrS5uamR6VgBjwEgfSwYKFarTrsjRGHLoCxJbgbEYwLkBW9Ep1eMpk05ra7u6uJiQkr6MHzGKv5mdCgcagkk0lLGnjo6VzRUX399ddPsEM6JKw7/X7fmB27EcE8GbuCwZNsPVpbW7NchJQGmDDGTQBwBL43NzfeeMQOBCJcYBcpUkG3AdntiGkZXymArGfj9yNDjaw3ZDB8BjDBuVzOchaSIFjACx6MI6FarSoaSEshaBExNd0VhZ3uES0XOsnp6Wl7HJmSpAfYJTiy8x6M8xp74aJAAFrTnvISsNlGkj1yLNbsdrsO5EOfhN0Hap6TAe8iWAAyBxIhkVUwmyPeRFMGcIvDHUkG+iRJTpzkBKpWqxZdcupls1kTBUQFw7LhUzt9DI0D/5ibm9PS0pIXlVKIEEXmcjmrwyORiCqVirVskgym8meISEEMyDp3dv8xdjEm0tWxexAWsVqtulPEt4luS3oYa8PhsDu92dlZa66w2fDf+ezYFgO2BVlze3urra0tLS4u6tWrV7q9vVW5XLZiO5lMqlqt+sVilIZBffHihXZ3d00CBMc03AitVssH56dPnyxKhaElUikoIyFva3193S86950DhGcynU7bdkUQI4tmmQAgafh9rq6ulEgktLKyYlC+1+vphx9+8Pe/urrS9va2dW1kyoVCIYf9cV/29vbU7Xa1srLiIsgzCKNOIbq6unLxJtrn7u7O8gw6ZpwsFE8mJhwXTEQwoH81rCLdEFEodDk8FADtvMR0RmS7M+uD/1xfXzt7fTgc6s2bN9bLAJyCTZFPxEmHYRrBHicbWMXd3Z1p83g87lRNVO5YfeieYNhQxoMbQT6gbwIQhklFXc8oQ9vNuITbgBE5FArp5cuXtnsgKMWqIckvHR7AYF4+9/jy8tLmWkZMDpb19XVdXV25U6XrZExirKerCLoI+J7EDUkPI23QJ8cGZJ4FST69uS90SUgDGP0YCQH00SxxcGxvbyufz9umwk5B1OIbGxvunuhuwaI4LBgjKQjBsY70TxaMBJNkOTSRG6yvrzsGhv/OwRmPxw1V8N+J1wFDRK6CUyTYtQIlSJ8dGDDGRE5TjIgz5xlAmB0Ohy25gUS6uLgwQYUFjs6JQ+b0Ma6cKCXixSFGuI9/FV5FScaD8vm8T02EpIg9aZcpTOArxHAwSgCkvn37Vi9fvjQ4DVYlyabPXq+nZ8+e+eVHaIjVYmVlxZnw0NcIV2m9IQoobLxcmLwBpSmupDDc3987g35+ft4KZknetsy6q2AeVzgcVrFYtI4M+8by8rJ/Vn5emCq0YGhveMGIeGk0Gkqn0+5+SWiloDJaBkWGyEfIo8dTiLo8m82aEWMTOWM7ne36+rqxIgzF7LaUPi+RRRiL1qpcLrtb4/MmewqmFJvT1NSUDg4O9OLFC0fBoGkC+wyFQvr06ZPjhYJYHyMyIz0jLjHRwehtlrnQPbOqC/MzinsOg7OzM7PRMJ24LVhyjJaRbVEfP37U9fW10yP4v06n421ESBEQbKNdiz6GC0AwHR4eGq9DahEUj56fnysUCnkEPTg4UKFQMBAvyc0BTQWH0uTkpMMJ6BYnJiY8ko/7+klibdjGg56IdvTk5MRMBC8KIkVCz8g2onAApC8vL6tSqTikMBaL+eWhNZ6bm7ObfXJy0uJG7B6SPGJxuqCNYsnrx48ftby8bIYp+rgtB8AaoFuSg+QoumB52Cfo1mBBSewEe6LTCYVCFpQi9EQKQkLrxcWFQeZEIqFsNutuFQkAYDLqf+4LhuNgEgDFbnJyUh8+fFA8HtfS0pLlEtFADM/NzY03SwfvYTKZdGLE6uqqRqORWcSgdQvriiT7MAmvW1tbM1bF9yJtAxV7tVp1fMzs7Ky+/vprlctljzU8B3R3ExMTFkIjy6DDR1pBnlc4HDY2CdaEPAH1ORuAYLZvbm58QFC8KXiS1Gg09OzZM/9MHJBIZLDgrK2taX193cQLBzaJqqHQQ5b+zs6Ovz5d1+ljqCI4MlFOwb2b6LJgL5EQoXskxPDs7MzSE94/ujBkHP1+X+122xADDDis+7ivn2RZBhWe0xI9DZlbg8HADN7U1JR2d3d9SuN0BzhH3gA2xfKAXq9n5bv0UETIpKL7Avvg/6O/wjJEvHS73TbgziorTjUATzAfisHq6qpOTk788nIagid9+PDBpl0eCILyyuWymTw8ZXQtuVzOfwfdVzqd1tramn7729/q7u7OSQZgKajVW62WxyNAW/YzsjABLxyMazqd1i9/+UuD4oxQgOFotYjSAQgGL2KUQBDLAoXg70zuVr/ft2ofuxZdDDgf5MFwOPTKNiKTiTTiQEFXxy5GmGO6mvPzc2UyGd3d3ZlF4+Dh5YRZhok+OTlRPp/X//3f//ngC8oEGF3fvXv3xDmAXCB4rxYXFw2O0/lQoOfn5y1HCY7iFBn8i3g2g51qELNi3d/d3Z0PbbAqumbE10tLS9rf31cikTD2d3R0pGw26zhvDPJINOgwSRgJ7hWgQcAcPs5r7IVrYWFBi4uLT3yFqNLBXeLxuP1SQRsBN4P8cUnevHtxcWFcBP3WaDTyOEhXQ+wH6+FhoHDSg5shRJ2fnzfATGoAKmfiRxDj8YFBIhC3wu+K3CObzWo0GqlYLCoWi+ndu3eWE6Acj8ViT1ZSMUpWq1VT5EtLS3r27JmWl5ddcGKxmEqlkubn592iU/BSqdSTgLxkMmntG987n887qoVRkkLJeHB3d+dYnyDTGBz9GGl4UTAlYxBGqHp5eemFH7CosG8bGxv282FQn5ycVDabfWJVQsOG/QrPY1C/dHd3pxcvXjjjnz9PNwsAHw6HdXh4+KRgYF5HwlCpVPTs2TMfLJFIRD/88MOTLTipVMoR0oT4kTwCjoSiHeO59BlnxM86GAws80A0jCEbQur8/FyNRkMzMzOGNMCRaQw+ffqk9fV1zc3NWefHSAzhQvFnYuFzx88IuYEXFn8s+xRghPm+wfSRcV9jL1wodzlxg/Q/WFSz2VQul/MoyPZjwMnRaKT9/X2r1InsoMUNRp0gXcBNT5dBgB52GgBSxHjhcNi6IV5Cvk7Q7xYc+3gB/+Ef/kGpVMpAPbsK6ebQOfGQf/31127JV1dXlUwmValUTFyAmw2HQxdTXk7AUB6Ui4sL3d4+rISiWEOVr66uam1tzbjKxMSEJQm8wOBqkjz6ckF2JBIJhUIh1Wo1v2QYlnmwg7gTADb/GxcCbCUjaLB7w6IFKA9pQ8eNcwA/J/v+ELLyWWMLQ0zKWHN2duaxFb0TOBqs9eXlw0ZsEkzBFwkCZJxtNptaX1+XJC/SgAig+KJyJ94HEuP8/FzZbNZFmaz2UChkOQJ7JhndWHxCqgbvAe8PGjSYdyJ0UL8jlgWuoRNHMY+fEqyNcZcJgaKby+XcbUHCEG/e7XZVLBYNK4z7+klGRdiTubk5++PQxaD+rlQqZtXQTyFM3dvb8+IJAFiEkXyI8Xjc2eWEscGiXVxcGCdgGQMLDljFFOzKGGkODg78AqFcJ9uI4nF3d6e3b986HoauCdEop1a9XnfrjlxjbW3NrB2CUzqhYrH4xChLB0ScD9aR58+f27hLFtmnT5+0tLTkeCCSFrCQ5PN5C3N5+UnluLl5WAPH/QOzIxBxdXVV2WzW+Fg6nbZNqVAoWMpA54LRGRYLfIlRKBqNqlarWX9VKpU0PT1t6wn7IOmcJbljOT4+dleFLQjXAf5AnAbVatUSAXK5WB3G2AcWxDhIZ8FziSeUe9tut/XixQtjT+l0WoeHhzasT0xM6LvvvvPG6NFopPX1ddXrdUs3ms2mR05YzYODA+OOJycn1vTxOWDMpuNhrIYBRa4DPDIYDCwChrCo1WrWYtEpSQ9Z869fvzZEAi4JfhWMhyqVSmbdORCAbsZ9jV05/0//9E/3OO7xi9HiS3IHMTHxsBqdyA3Ecqyk4gUmKobTC/AQ0J4VUIyhAOCTk5M6Pj62SrhUKhkzACMIAqpgPIy0aLvAbwA9oeavr68tFUADk0qlLAF49uyZ/vEf/1H39/fWAZ2fnz9JdSCShReBe9Jut425wMaSjDE1NWVzK6dnUJlOl7e/v6/oY/wxOAxdElYqvHd8bwonneXCwoLi8biazeYTtTomXcZoOjFJ1i6VSiV/nUKh4IUlpHREH6OBrq6uvKlma2vLG6CCGri5uTl3kKSKAkovLS1pbm7OmBzPC7goXeTFxYUFqejE6Ba4H+jjIFnoLMBX6drIgQMSIJwxkUhoOBw6DpsOjw6SgkgBI56ctAg+fyxniURC5XJZtVrNBFWr1fJ9xe/I+0EhZCTEnE5hA7MEC5Ye2ELcKMSr0xDwbrJ9qVaraWtrS91u18Lcg4MDpdNp/du//dtftnIexozsIQoA/itu9uTkpA4PD12QgkFyzWbTWA3dGqpzQOVoNKpIJOIwPXAXAHVOn4uLC2dBdTodFwQEg8gNbm5u3Ikxt4O9cUqjJWPBAN0L3RHMFIbn4XDovxvcWHN/f2/bB78fSuparaaFhQUlk0lHDmP0hTkiQje4nm0wGPg07/f7XiZyenrqjKognkZ6wmAwcHeK2RzfIH+O7pfPF0yQ+yM9iBBh3vg9ybpiA0/Q8M14R+DiV1995YIOI3l/f69sNmsmDsU2LBwgM1ICXmBM3uCPMKCwsxBDExMTTu9ERMyzE31cFgzeCQAelGqA1Z2fn6tYLOr+/t5Jo5J8oOHVJZeu3W4rlUqZpeWzRLnOc8zzwIhdr9edIsxmahwUHI7X19fa2tqyZpAECEZ9rEZ8dsAzxAaBr05NTbmjZ2IIYnIkx4IPjvsae+FqtVq2iNAJITzldKKa4+0KivbwSjG6sEU3l8u54EmyBocHMChcRFWMuJMu7+XLl8ZlACChi8k6kmTBKxuPETPu7e1ZSQxrI8m/FyK9SCSiw8ND9ft9PX/+3FgN+jOiWUiBmJiYUDqd1mg08niAyZliTktOAcI/h1F8c3NTU1NTSqfTHoWeP3/uGBaKMTojdGho54KrqKSHkfebb76xP/P29tY2F/YBIICdmZnxNmVJ/plQibNCi32XdBaNRkOpVMqLRunIOLBmZmYMeMP03tzcaG1t7UmqKgA6BEulUlGhUHBeP/sJMReTS391dWXpCDgsXSUkyurqqqNo0AZiGbu6urLpH9YSbI/PYnJy0llkNzc36nQ62tracsYbZmciiYAu8CiSPQbzyoh6cHCger3uIEIgl0wmY5YesgTMkiKOswHsmDGUf08qK/cMuQopLIQmcqBxqI3zGnvhouOhbYfqp6Dw0icSCd3d3bmLwoWOZwpchDRHCh6qYsR0PESSPHqhdAe0JMedha/QvOAIBA8uLCwYO6AoAeTe3NyoWCw6UI6HDPyDyA8o5nQ6rUajYbsPSa0ka5ZKJX8vSY6jXltbMxbIbkmU7/V63d0aufboc66vr1UsFq19wk5FV0lQIGMp/k2o/nw+b+sHY8Xs7KxfXrpKUhTQ2U1OTtoeEnQboP4nMRUiAR8r6+ownMNGQ6qQ4c7PEvQe0nkCe8RiMR0dHalarWpzc9PPxe3trfWDAM5gQRRicC1gCYoYAlMwwsPDQ4/nRI4H02SD+xUwOoOTsv7r6upKz58/96gKzkQnHJRKQECxeAUD+e3trf7jP/5D0WhUL1++1NXVlb799lvveeSzCIYF0hGl02l7ZlH0Hx8f2+pGZv7GxoaePXtmkiL6GEEeBPAZ1S8uLuyFHOc19sIFrUt7jCKXE5+uCUCef09aBCkH09PTtvV8/fXXziRC68JmXtgs7DeMEZy+gK60/ICV7L8DNI7H41peXnZ3xkMbtMHs7u5aWQzVfH197d2MrVbrCXvEKQ3WwveMRCKq1+t+OVFGr62teYciqulg1hExJgcHB06yRM3e6XTcgdA18WK1220XBrCSoPCQ4EDGHHA9QFgkEfF43EF9YCRBhwOrxjA5Rx8Xjq6trbnYYll6/vy5l30wMgYN+j/++KMZyUqlYpkKVD+prPPz87a2lEoldTod669ubm7MqLZaLcexTE5O6tOnT773dELABEF2kq5vY2PDhb7b7fp5pUBXKhWtr6/72Ucuw8FIRMz5+bmePXvm7LU/J55IHUGa8u233yoejyuXy2l/f1+RSES///3vVa1Wtbu7a2ji/fv3hj+QT0if90HSbeIGQBrEoSLJAtxGo+HN6UAQExMTnnIoekQG/VUECa6srFjbwrhILhX56JK8rnx6etpLRxkT0LAAcIJDsOBBkscAHPWcmBSR29uHrdMoyq+vr3V+fq5YLKZareYWWXqQBVxfX+vw8NC2DUYdHiJ0RxQe5B1/LrrEksHpTSGbnZ31cs9Op+PvTzY/GjWwmLW1Nf87SU9A5uCaNOnh4SwUCj45yeriXhOtIz0UGsbtwWCgvb09ExQwSd1uV8+ePdPHjx/NqknymMqYA8gMoLy7u2txL4RMNpvVd999p9PTU+Och4eHPqkXFhbUbredpwawPjc3p4WFBfV6Ped45XI5a8soGhQfOiqM2oiF6dTBGcGLwIroUII+T9wIRAAxepMimk6n9bOf/cwxMVNTU1pcXFStVlO5XPb43O/31Wg07FbY2tqyzITxkWJJFE8sFtPx8bG+/fZbxzUDrRDrRDdMAaGbrdVqjgNC5BsKhZ6kVXAYQ0z1ej0n4gb1fKR2sPgD3JVdBQh79/b2jF2O8/pJlmXgZTo7O7PEANCP01iSPWK41rnRkvzgtVotd0iMVbTRiEqDxs9gptNoNFK1WnUyAx/u8+fP1ev1/P1gt9LptBlLQEtEhogVEaYyGoFdIPSD3ST8rVKpGIPB6kHhgYFDQoB6H9aOUzOTyfiFBguho4Bp4qBAuMuePe4TYXuML+CC4CPccywx3G/ocMgPScYikWhQBBBmSg/jD1lVbAoiYufVq1fuiskXW1xcNIbHfV1eXnZo4eLior777jutrKz452d0YtRDAkFSCIp5YpsLhYLDGcHJwFIPDw/dcXMgYtgmKBITfjgcdlIIRAVjFp5IlOej0cgsIYuB7+7u9Dd/8zc6Oztz13h9fa1qtaqDgwPF43FjdHd3d0qn045oxmt4eXmp/f19FYtFd7LYwBiB0chRqJgwWD8myXKc5eVlLSwsmBzi92LEHQ6Hajablv+w6DmTyfx1WH7u7+/NYtEqk+XEBRDPuEGKIjnZnFAAt7xYWBmIaAmFQt6jyALNjY0N7e/v26iMJxKcaHp6Wp1Ox1lUZC5hVJVkXQ7qemJoMMSCyUElAzaT8U5iJ3HEiCPT6bQjXig6FL12u61sNqsPHz7o7OzsSTwJoyumWTLFT05OvMCTZAAEiGTR8yLygGJcBuBn0zbCWFIJ+Jq9Xs+YoKQnGWUzMzPuhvi8m82mKpWKrq+vlUqlXOBGo5G2trbcnfIZdrtdXVxcqNVqmTmMRCKWHPzud79Tu93WYDBQsVi0LCGRSCgcDtsLePq43BfJRPD3gCza3t52kecwRB4DO93tdi1YxgcZdBAE9xuAwSJZQYhcKBSexF53Oh17+3Bn7O3taWpqypY1uuRwOKxGo2G2GiJnaWnJTgiKbyKRcAjn+/fvvY8A/dja2poZdXRrgP/kyUFo0VkiqUAqAo5JmgVCaw6ps7Mz+4DHeY29cGWzWb+IRLFQFMja5hcHW0GPhSZnYWHB3ViQxSKWgxwsxqWZmRm3yJeXl8rn88YsaO9RjSMhgIVhsxA/6/39vXq9nkFutvnC8BDRy4sHfsCIWK/Xn2QdXVxceDEHglAecPLF6vW6YrGYhsOhXr165c3R4FiomWGrpqamfCIuLS0plUrZiEsSBXYrxKxkowVD99C1ATRzX/r9hw1IYBzRaFR3d3c2XZNmcHNz48IXDoetAUPDRWBfLpfT4uKifXV0AuBdgMnBwywajVoHuLGx4a6n3W6bECBkMUjY0IFNTU1pZ2fHnzf6M7oPghPx6B0dHVmSgnuC35UxnWgi6XO0TND3+v79exc1lhPD7CHnCXpBEXEGpRLT09PK5XK6u7vT+/fv/XWANYADJLnjbDQa+s1vfqO9vT0fhKenp+p2uzZgcz/n5+cN3KOpA9fjM8dmBbYVTI6QZAKMJch/FawiIreg14ubw0lPR0DiALgJlOtwONTm5qYmJiYsfgPAZKQ8Ojry+MLXZf0YAlGKGUD0cDh0qgRiO4oSCQ+ciKi1eYAZuXhoCI/jtAEf4NSkOFxcXPj7F4tFra6uOggR1u3Nmzc2IAc1aLlcTqePAYjdbteJDpiDo9Gozs/P1Ww2vWbs5OTExR7sDwU7+GAwm56XhfgXulfIhlwup0qlYrZMkgs8DBhjEi8q1H2z2fSWIsbn6GMIH7o2SBQkFBA3/HO73daPP/5oXIduFxkBIzdeQ8ZpRknp80JiEkTAxm5uHvZoFotFZbNZA9Vo546Pjx2EiOhzfX1d7969cydHxzcajZ7ES6+srKjZbFpdH9zSNDMz80TpD9MNm0i2GCw5QD65YIzvKPkp+vl8/sl+B2Q6MKx8L/4bhxmOC1wiTBDEDDHu8qyTmru6uuplsuO+xl64UFFz8iEZCLajdA5ENiNmXFxc1Gg0snP95OTE8Sx4w4IBhEgICJjLZDLWcAF2MpbQqZXLZT8cYGK8MMPh0PsSYaAYY0m9QGcVFKzCCJKVRdxKMKaFFnxmZsZ4Dnoq/v0vfvEL5yv1+33t7e15xOh2u/YhcsIRrodkIthVxmIx71JkzGHMJqGD/ZKTk5Oq1WoOPiR5I5i0AB6Ef4/4FbRqwfGWAo+/T3rAxT58+GBd1dzc3BMWkRSEdrvtjhxSAGyR+x48fDgYwK1qtdqTURwB5cXFhSOQYJgzmYw7zeFw6BDK4+Njdyd0xnQZBF5eX1+r2WxaxIv5//j42LKG6elp7e/va319XaVSyQJYmNFgblkoFLKYlCw3uiJgESALSe4Ov//+e93d3WlnZ8d2HrLt+cx4FvndJRlwPzk5eZLkAc6JJAcTNwA8BzJCcwruuK+xFy4of6j46+trK9bRO1FcONkYAaWHDmdtbU0fP37U7OysR7ngGFGv1w2ezs/POyoGfAdal9OKf+Yl5CHAwwbYTaFCCkFu/tXVlXEOBKtIMLBHwAzSBQZzjCR5dOVnxq6STCZdlPj5Jfn0Rc1NR4RolhFjcXHRy0wxmofDYbVaLY9FFD5edorh9fW1UyIQvaK2R35A9DaaKR5SHnRICrZd81kFjc3dbte6OYBzFmdQiHARFItFY0unp6fGEicmJtTpdDzSMA6jTcMCMxgM1Gg0lMlkNBqNtLOzo3A4bMsSXX46nXbYHxKdly9fGr+jq0GzxCgZXI7BXoOzszOzv8fHxxoMBr53FBiSckOhkEmJdrvtdFPCNhkRsZeR2lutVlWtVg3F8OzFYjElEgn9+te/NpNN4gMCYITGyCUQ2TJd8C7BhpOkAYbLpiEmHgoZCa9B/Hpc19gLFw8yankUyDxkWDmCNwz8gZeUCBtJHrHIukJKsLKy4tHg4ODADxFMELjC0tKSAVe8egCVgM60zsHsbISw5HjDUEGHS3qSTEBBAstj5GBV2MLCghMxwG4ohLlczos3KaYUhuvraxMMeEAZ52Ap9/f3jZHw4KVSKef7EyMN+H55eakXL16oWq1abBuLxXxf8OCRvQTOFo/HVa1W9ebNG7VaLe3v7+vi4kLb29s6Pj62oPHq6soFgM6CaB2+3t7ens3bFDhkCkF/K6Mg96XX66lcLmt5eVn7+/tPDg/WrG1sbFhCk0gknjCw0gNLywp7Uj6mp6f18eNH52FRIIPLMejIwNDw+FGAecYp7rVazTpFNIu8IzxHyDPYjdDpdFyo+Hp0dKjoSUSZnp42PoucBMKHpSJAKTzv4XBYzWbThwXjaPDeB+1pEAqs3EP+wU4JNnCP+xp74WKDCIkKPPy0oXxQfNBUcRYHAM7j0keYyLgJ7oMIFZYHqh7rAlgYGhcAYZTnCBJh6sCbGEnwx71+/drdIJQzgsVoNKq1tTXHviDXCC79xMJE98kDANNILtfs7KxHucPDQ4+h8Xhci4uL9vqdnp4qk8n4QJD0pJAyTkoPq+rJMwvq3yYmJrS3t6dSqWSRJjsYiTyBGZ6bm7NQEgPux48f9ezZM83NPWwY+tnPfqb5+XktLi7q5cuXLty8/NVq1bo89HWxWMybnzOZjE3b7XZb19fXNpJD1QPsk1fVarWsceL5gH1E/c8YSDcNiSM94DTr6+tqNpvKZrPGP7vdrqKP6a+9Xs/4HiNUo9HwGEXoHp3n+fm5izRGc7BACBw6/1Qq5T2byA2CMgZwOEz7xPlgV6LrZGvP0dGR4vG4R9r9/f0nFi0OZ7puRMm4EIL2LQ5siAlSUbCeUcjBqnn+xnn9JEGCvCiwfhQnMAZaVsYKwD/y5kkE4IahuYIlRN3d6XQcD0K3RNvOWCnJ1hgidDEC84FChfNyU+RImJRkBuzk5ETNZtPaIfyUgPzRxxxwxj4ypmj7GRNvbm60sbHhpEuKL0mhtPv9fl/7+/tmx2CEyKEnU2piYsKev7m5OXU6HeNlSAToDABv8S2S1UR2Pupo8L9Wq6VYLGaVufTZjzg1NaX3798/8X7yNbB6wSyjYWM8h7Hc3d31faMAEhCIlIaoYf7M+vq6qtWqJNnGUiwWTZ6whXpy8mHhLZ9xsVi0sZ2DkRGL36dSqTwZrUj0xVKFpw+WmSXIsLYQSujWMGzPzs66E+Q+SQ+EVjabtfeRv9Nutz0KM/aWSiVr5MjUIuOM8ZMDBWgiOFZLcqE6Ozt74h6BKRwOh5a5cP9hvZkCwNCCRNY4r7EXLtpOSRbgIdokhWA4HNoTRttMEBsnFH6wfv/zXkSwGDCxoMeMJE+2DqPXYeQhgmZ6elo7OzvGNQiBQ/0MKEyHcX5+bnyE6BR2H3IdHx97vMAcDBMFvV4ul/1SMvrt7u6aLTp9TJHkBdze3nY+fSKR0MHBgRYXF40pJJNJ26vW19c1Ozvr7o68Mg6DoO0kuBRjf3/ferDl5WVdXV2p3W5LkkFjNE4UPsBwJB888CwY4c+cnJwonU67UwGnajQaur+/V6fTUaFQMElADHa1WrXhe3FxUY1GQ3t7ewbwX758qXK57C01dEoQFGifMI9PTj4sIDk7O/OWnyCeI0mVSsX2q8nJSWNIFAZIAYiRT58+aTQa6f379/rw4YMV8UdHR7YvkRaCyXplZcW/E2MaUwKHBzop2FR2GqLV63Q6+uGHHywEhRnmWe12uyoUCtrZ2bFgmo5rNBqp0+k8yU2Lx+NmdXu9nk4f01oJKqSj4uszURAtzcETfBfGdf0k4DxAXnAjDimnCE35ZaGVwUMuLy+1vLysqakpn/SSfMIUCgVrxPjwYbvAisgrh1ULGqcnJye1urqqTqdjvxWdEx60er3ukRUsCPkFDwAfPiMMMgjwDDAFljLAhPHQwZzNzMyYReTUrlarKpVKBrCJg5bkEYVuk+6uXC7r48ePT7A4utVkMumXlJMSh0Iul7Molq6NgyQej1tWMT8/r6OjI48ikp7o9WZnZx0dTEfTaDSe7B5YXV3Vs2fPdHt768MHrRDmb1JLP336pF6vp83NTWMr0oMz4/7+XgcHB/7ekCEU3mq1+gRLhSFGH0d6B+wi6QmFQsGfIcw0Xx8DPfo/TNiDwUD/+Z//qR9//FF3d3c+CE5OTowv3d3dqdFo6PDw0NguHSDpr+wTvb192DP65s0bb9WBGCLtdnNzU998841dBltbWy5+4MN06HhISYUI7gbAwws2ikODexnMikMzBtyDtYy01nFfYw8S/HJ9ub5cX67/19dPslfxy/Xl+nJ9uf5fXl8K15fry/Xl+ou7vhSuL9eX68v1F3d9KVxfri/Xl+sv7vpSuL5cX64v11/c9aVwfbm+XF+uv7jrS+H6cn25vlx/cdeXwvXl+nJ9uf7iri+F68v15fpy/cVd/x/Tjh3/+DYaLgAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "" ] @@ -591,21 +617,33 @@ } ], "source": [ - "po.imshow(eigendist_v.eigendistortions[[0,-1]].mean(1, keepdim=True), vrange='auto1',\n", - " title=[\"most-noticeable distortion\", \"least-noticeable\"], zoom=zoom)\n", + "po.imshow(\n", + " eigendist_v.eigendistortions[[0, -1]].mean(1, keepdim=True),\n", + " vrange=\"auto1\",\n", + " title=[\"most-noticeable distortion\", \"least-noticeable\"],\n", + " zoom=zoom,\n", + ")\n", "\n", "# create an image processing function to unnormalize the image and avg the channels to grayscale\n", - "unnormalize = lambda x: (x*image.std() + image.mean()).mean(1, keepdims=True)\n", - "alpha_max, alpha_min = 15., 100.\n", + "unnormalize = lambda x: (x * image.std() + image.mean()).mean(1, keepdims=True)\n", + "alpha_max, alpha_min = 15.0, 100.0\n", "\n", - "v_max = po.synth.eigendistortion.display_eigendistortion(eigendist_v, eigenindex=0, alpha=alpha_max, \n", - " process_image=unnormalize,\n", - " title=f'img + {alpha_max} * most_noticeable_dist', \n", - " zoom=zoom)\n", - "v_min = po.synth.eigendistortion.display_eigendistortion(eigendist_v, eigenindex=-1, alpha=alpha_min, \n", - " process_image=unnormalize,\n", - " title=f'img + {alpha_min} * least_noticeable_dist', \n", - " zoom=zoom)" + "v_max = po.synth.eigendistortion.display_eigendistortion(\n", + " eigendist_v,\n", + " eigenindex=0,\n", + " alpha=alpha_max,\n", + " process_image=unnormalize,\n", + " title=f\"img + {alpha_max} * most_noticeable_dist\",\n", + " zoom=zoom,\n", + ")\n", + "v_min = po.synth.eigendistortion.display_eigendistortion(\n", + " eigendist_v,\n", + " eigenindex=-1,\n", + " alpha=alpha_min,\n", + " process_image=unnormalize,\n", + " title=f\"img + {alpha_min} * least_noticeable_dist\",\n", + " zoom=zoom,\n", + ")" ] }, { diff --git a/examples/Display.ipynb b/examples/Display.ipynb index a62db0da..ad15d879 100644 --- a/examples/Display.ipynb +++ b/examples/Display.ipynb @@ -20,13 +20,14 @@ "source": [ "import plenoptic as po\n", "import matplotlib.pyplot as plt\n", + "\n", "# so that relativfe sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "# Animation-related settings\n", - "plt.rcParams['animation.html'] = 'html5'\n", + "plt.rcParams[\"animation.html\"] = \"html5\"\n", "# use single-threaded ffmpeg for animation writer\n", - "plt.rcParams['animation.writer'] = 'ffmpeg'\n", - "plt.rcParams['animation.ffmpeg_args'] = ['-threads', '1']\n", + "plt.rcParams[\"animation.writer\"] = \"ffmpeg\"\n", + "plt.rcParams[\"animation.ffmpeg_args\"] = [\"-threads\", \"1\"]\n", "\n", "import torch\n", "import numpy as np\n", @@ -42,7 +43,7 @@ "metadata": {}, "outputs": [], "source": [ - "plt.rcParams['figure.dpi'] = 72" + "plt.rcParams[\"figure.dpi\"] = 72" ] }, { @@ -134,7 +135,9 @@ "metadata": {}, "outputs": [], "source": [ - "pyr = po.simul.SteerablePyramidFreq(img.shape[-2:], downsample=False, height=1, order=2)" + "pyr = po.simul.SteerablePyramidFreq(\n", + " img.shape[-2:], downsample=False, height=1, order=2\n", + ")" ] }, { @@ -151,7 +154,7 @@ } ], "source": [ - "coeffs, _ = pyr.convert_pyr_to_tensor(pyr(img),split_complex=False)\n", + "coeffs, _ = pyr.convert_pyr_to_tensor(pyr(img), split_complex=False)\n", "\n", "print(coeffs.shape)" ] @@ -191,7 +194,7 @@ ], "source": [ "po.imshow(coeffs[:, 1:-1], batch_idx=0)\n", - "po.imshow(coeffs[:, 1:-1], batch_idx=1);" + "po.imshow(coeffs[:, 1:-1], batch_idx=1)" ] }, { @@ -1515,11 +1518,18 @@ } ], "source": [ - "pyr = po.simul.SteerablePyramidFreq(img.shape[-2:], downsample=False, height='auto', order=3, is_complex=True, tight_frame=False)\n", + "pyr = po.simul.SteerablePyramidFreq(\n", + " img.shape[-2:],\n", + " downsample=False,\n", + " height=\"auto\",\n", + " order=3,\n", + " is_complex=True,\n", + " tight_frame=False,\n", + ")\n", "coeffs, _ = pyr.convert_pyr_to_tensor(pyr(img), split_complex=False)\n", "print(coeffs.shape)\n", "# because coeffs is 4d, we add a dummy dimension for the channel in order to make animshow happy\n", - "po.animshow(coeffs.unsqueeze(1), batch_idx=0,vrange='indep1')" + "po.animshow(coeffs.unsqueeze(1), batch_idx=0, vrange=\"indep1\")" ] }, { @@ -1624,7 +1634,10 @@ "source": [ "po.tools.remove_grad(model)\n", "met = po.synth.Metamer(img, model)\n", - "met.synthesize(max_iter=100, store_progress=True,);" + "met.synthesize(\n", + " max_iter=100,\n", + " store_progress=True,\n", + ");" ] }, { @@ -1660,7 +1673,9 @@ ], "source": [ "# we have two image plots for representation error, so that bit should be 2x wider\n", - "fig = po.synth.metamer.plot_synthesis_status(met, width_ratios={'plot_representation_error': 2.1})" + "fig = po.synth.metamer.plot_synthesis_status(\n", + " met, width_ratios={\"plot_representation_error\": 2.1}\n", + ")" ] }, { @@ -1687,7 +1702,9 @@ } ], "source": [ - "fig = po.synth.metamer.plot_synthesis_status(met, iteration=10, width_ratios={'plot_representation_error': 2.1})" + "fig = po.synth.metamer.plot_synthesis_status(\n", + " met, iteration=10, width_ratios={\"plot_representation_error\": 2.1}\n", + ")" ] }, { @@ -1714,9 +1731,16 @@ } ], "source": [ - "fig = po.synth.metamer.plot_synthesis_status(met, included_plots=['display_metamer', 'plot_loss', \n", - " 'plot_representation_error', 'plot_pixel_values'], \n", - " width_ratios={'plot_representation_error': 2.1})" + "fig = po.synth.metamer.plot_synthesis_status(\n", + " met,\n", + " included_plots=[\n", + " \"display_metamer\",\n", + " \"plot_loss\",\n", + " \"plot_representation_error\",\n", + " \"plot_pixel_values\",\n", + " ],\n", + " width_ratios={\"plot_representation_error\": 2.1},\n", + ")" ] }, { @@ -1744,9 +1768,11 @@ ], "source": [ "fig, axes = plt.subplots(2, 2, figsize=(12, 12))\n", - "fig = po.synth.metamer.plot_synthesis_status(met, included_plots=['display_metamer', 'plot_loss', \n", - " 'plot_pixel_values'],\n", - " fig=fig)" + "fig = po.synth.metamer.plot_synthesis_status(\n", + " met,\n", + " included_plots=[\"display_metamer\", \"plot_loss\", \"plot_pixel_values\"],\n", + " fig=fig,\n", + ")" ] }, { @@ -1774,10 +1800,13 @@ ], "source": [ "fig, axes = plt.subplots(2, 2, figsize=(12, 12))\n", - "axes_idx = {'display_metamer': 3, 'plot_pixel_values': 0}\n", - "fig = po.synth.metamer.plot_synthesis_status(met, included_plots=['display_metamer', 'plot_loss', \n", - " 'plot_pixel_values'],\n", - " fig=fig, axes_idx=axes_idx)" + "axes_idx = {\"display_metamer\": 3, \"plot_pixel_values\": 0}\n", + "fig = po.synth.metamer.plot_synthesis_status(\n", + " met,\n", + " included_plots=[\"display_metamer\", \"plot_loss\", \"plot_pixel_values\"],\n", + " fig=fig,\n", + " axes_idx=axes_idx,\n", + ")" ] }, { @@ -1806,13 +1835,21 @@ "source": [ "fig, axes = plt.subplots(2, 3, figsize=(17, 12))\n", "# to tell plot_synthesis_status to ignore plots, add them to the misc keys\n", - "axes_idx = {'display_metamer': 5, 'misc': [0, 4]}\n", - "axes[0, 0].text(.5, .5, 'SUPER COOL TEXT', color='r')\n", - "axes[1, 0].arrow(0, 0, .25, .25, )\n", + "axes_idx = {\"display_metamer\": 5, \"misc\": [0, 4]}\n", + "axes[0, 0].text(0.5, 0.5, \"SUPER COOL TEXT\", color=\"r\")\n", + "axes[1, 0].arrow(\n", + " 0,\n", + " 0,\n", + " 0.25,\n", + " 0.25,\n", + ")\n", "axes[0, 0].plot(np.linspace(0, 1), np.random.rand(50))\n", - "fig = po.synth.metamer.plot_synthesis_status(met, included_plots=['display_metamer', 'plot_loss', \n", - " 'plot_pixel_values'],\n", - " fig=fig, axes_idx=axes_idx)" + "fig = po.synth.metamer.plot_synthesis_status(\n", + " met,\n", + " included_plots=[\"display_metamer\", \"plot_loss\", \"plot_pixel_values\"],\n", + " fig=fig,\n", + " axes_idx=axes_idx,\n", + ")" ] }, { @@ -5522,13 +5559,21 @@ "source": [ "fig, axes = plt.subplots(2, 3, figsize=(17, 12))\n", "# to tell plot_synthesis_status to ignore plots, add them to the misc keys\n", - "axes_idx = {'display_metamer': 5, 'misc': [0, 4]}\n", - "axes[0, 0].text(.5, .5, 'SUPER COOL TEXT', color='r')\n", - "axes[1, 0].arrow(0, 0, .25, .25, )\n", + "axes_idx = {\"display_metamer\": 5, \"misc\": [0, 4]}\n", + "axes[0, 0].text(0.5, 0.5, \"SUPER COOL TEXT\", color=\"r\")\n", + "axes[1, 0].arrow(\n", + " 0,\n", + " 0,\n", + " 0.25,\n", + " 0.25,\n", + ")\n", "axes[0, 0].plot(np.linspace(0, 1), np.random.rand(50))\n", - "po.synth.metamer.animate(met, included_plots=['display_metamer', 'plot_loss', \n", - " 'plot_pixel_values'],\n", - " fig=fig, axes_idx=axes_idx,)" + "po.synth.metamer.animate(\n", + " met,\n", + " included_plots=[\"display_metamer\", \"plot_loss\", \"plot_pixel_values\"],\n", + " fig=fig,\n", + " axes_idx=axes_idx,\n", + ")" ] }, { @@ -5649,9 +5694,15 @@ } ], "source": [ - "met = po.synth.MetamerCTF(img, ps, loss_function=po.tools.optim.l2_norm, coarse_to_fine='together')\n", - "met.synthesize(max_iter=400, store_progress=10,\n", - " change_scale_criterion=None, ctf_iters_to_check=10);" + "met = po.synth.MetamerCTF(\n", + " img, ps, loss_function=po.tools.optim.l2_norm, coarse_to_fine=\"together\"\n", + ")\n", + "met.synthesize(\n", + " max_iter=400,\n", + " store_progress=10,\n", + " change_scale_criterion=None,\n", + " ctf_iters_to_check=10,\n", + ");" ] }, { diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index 8e0e1816..eac8f9f4 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -29,17 +29,18 @@ "import pyrtools as pt\n", "from tqdm import tqdm\n", "from PIL import Image\n", + "\n", "%load_ext autoreload\n", "%autoreload \n", "\n", "# We need to download some additional images for this notebook. In order to do so,\n", - "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError \n", + "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError\n", "# then install pooch in your plenoptic environment and restart your kernel.\n", - "DATA_PATH = po.data.fetch_data('portilla_simoncelli_images.tar.gz')\n", + "DATA_PATH = po.data.fetch_data(\"portilla_simoncelli_images.tar.gz\")\n", "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "\n", "# set seed for reproducibility\n", "po.tools.set_seed(1)" @@ -113,17 +114,31 @@ "source": [ "# Load and display a set of visual textures\n", "\n", + "\n", "def display_images(im_files, title=None):\n", " images = po.tools.load_images(im_files)\n", " fig = po.imshow(images, col_wrap=4, title=None)\n", " if title is not None:\n", " fig.suptitle(title, y=1.05)\n", "\n", - "natural = ['3a','6a','8a','14b','15c','15d','15e','15f','16c','16b','16a']\n", - "artificial = ['4a','4b','14a','16e','14e','14c','5a']\n", - "hand_drawn = ['5b','13a','13b','13c','13d']\n", "\n", - "im_files = [DATA_PATH / f'fig{num}.jpg' for num in natural]\n", + "natural = [\n", + " \"3a\",\n", + " \"6a\",\n", + " \"8a\",\n", + " \"14b\",\n", + " \"15c\",\n", + " \"15d\",\n", + " \"15e\",\n", + " \"15f\",\n", + " \"16c\",\n", + " \"16b\",\n", + " \"16a\",\n", + "]\n", + "artificial = [\"4a\", \"4b\", \"14a\", \"16e\", \"14e\", \"14c\", \"5a\"]\n", + "hand_drawn = [\"5b\", \"13a\", \"13b\", \"13c\", \"13d\"]\n", + "\n", + "im_files = [DATA_PATH / f\"fig{num}.jpg\" for num in natural]\n", "display_images(im_files, \"Natural textures\")" ] }, @@ -144,8 +159,8 @@ } ], "source": [ - "im_files = [DATA_PATH / f'fig{num}.jpg' for num in artificial]\n", - "display_images(im_files, 'Articial textures')" + "im_files = [DATA_PATH / f\"fig{num}.jpg\" for num in artificial]\n", + "display_images(im_files, \"Articial textures\")" ] }, { @@ -165,8 +180,8 @@ } ], "source": [ - "im_files = [DATA_PATH / f'fig{num}.jpg' for num in hand_drawn]\n", - "display_images(im_files, 'Hand-drawn / computer-generated textures')" + "im_files = [DATA_PATH / f\"fig{num}.jpg\" for num in hand_drawn]\n", + "display_images(im_files, \"Hand-drawn / computer-generated textures\")" ] }, { @@ -206,7 +221,7 @@ } ], "source": [ - "img = po.tools.load_images(DATA_PATH / 'fig4a.jpg')\n", + "img = po.tools.load_images(DATA_PATH / \"fig4a.jpg\")\n", "po.imshow(img);" ] }, @@ -239,8 +254,8 @@ } ], "source": [ - "n=img.shape[-1]\n", - "model = po.simul.PortillaSimoncelli([n,n])\n", + "n = img.shape[-1]\n", + "model = po.simul.PortillaSimoncelli([n, n])\n", "stats = model(img)\n", "print(stats)" ] @@ -305,7 +320,9 @@ ], "source": [ "# representation_error plot has three subplots, so we increase its relative width\n", - "po.synth.metamer.plot_synthesis_status(met, width_ratios={'plot_representation_error': 3.1});" + "po.synth.metamer.plot_synthesis_status(\n", + " met, width_ratios={\"plot_representation_error\": 3.1}\n", + ");" ] }, { @@ -375,19 +392,23 @@ "# send image and PS model to GPU, if available. then im_init and Metamer will also use GPU\n", "img = img.to(DEVICE)\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "im_init = (torch.rand_like(img)-.5) * .1 + img.mean();\n", - "\n", - "met = po.synth.MetamerCTF(img, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init,\n", - " coarse_to_fine='together')\n", - "\n", - "o=met.synthesize(\n", + "im_init = (torch.rand_like(img) - 0.5) * 0.1 + img.mean()\n", + "met = po.synth.MetamerCTF(\n", + " img,\n", + " model,\n", + " loss_function=po.tools.optim.l2_norm,\n", + " initial_image=im_init,\n", + " coarse_to_fine=\"together\",\n", + ")\n", + "\n", + "o = met.synthesize(\n", " max_iter=short_synth_max_iter,\n", " store_progress=True,\n", " # setting change_scale_criterion=None means that we change scales every ctf_iters_to_check,\n", " # see the metamer notebook for details.\n", - " change_scale_criterion=None, \n", - " ctf_iters_to_check=7\n", - " )" + " change_scale_criterion=None,\n", + " ctf_iters_to_check=7,\n", + ")" ] }, { @@ -414,7 +435,11 @@ } ], "source": [ - "po.imshow([met.image, met.metamer], title=['Target image', 'Synthesized metamer'], vrange='auto1');" + "po.imshow(\n", + " [met.image, met.metamer],\n", + " title=[\"Target image\", \"Synthesized metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -443,7 +468,9 @@ } ], "source": [ - "po.synth.metamer.plot_synthesis_status(met, width_ratios={'plot_representation_error': 3.1});" + "po.synth.metamer.plot_synthesis_status(\n", + " met, width_ratios={\"plot_representation_error\": 3.1}\n", + ");" ] }, { @@ -457,34 +484,40 @@ "\n", "# Be sure to run this cell.\n", "\n", - "def run_synthesis(img, model, im_init=None):\n", - " r\"\"\" Performs synthesis with the full Portilla-Simoncelli model. \n", "\n", - " Parameters\n", - " ----------\n", - " img : Tensor\n", - " A tensor containing an img.\n", - " model :\n", - " A model to constrain synthesis.\n", - " im_init: Tensor\n", - " A tensor to start image synthesis.\n", + "def run_synthesis(img, model, im_init=None):\n", + " r\"\"\"Performs synthesis with the full Portilla-Simoncelli model.\n", "\n", - " Returns\n", - " -------\n", - " met: Metamer\n", - " Metamer from the full Portilla-Simoncelli Model\n", + " Parameters\n", + " ----------\n", + " img : Tensor\n", + " A tensor containing an img.\n", + " model :\n", + " A model to constrain synthesis.\n", + " im_init: Tensor\n", + " A tensor to start image synthesis.\n", + "\n", + " Returns\n", + " -------\n", + " met: Metamer\n", + " Metamer from the full Portilla-Simoncelli Model\n", "\n", - " \"\"\"\n", + " \"\"\"\n", " if im_init is None:\n", - " im_init = torch.rand_like(img) * .01 + img.mean()\n", - " met = po.synth.MetamerCTF(img, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init,\n", - " coarse_to_fine='together')\n", + " im_init = torch.rand_like(img) * 0.01 + img.mean()\n", + " met = po.synth.MetamerCTF(\n", + " img,\n", + " model,\n", + " loss_function=po.tools.optim.l2_norm,\n", + " initial_image=im_init,\n", + " coarse_to_fine=\"together\",\n", + " )\n", " met.synthesize(\n", - " max_iter=long_synth_max_iter, \n", + " max_iter=long_synth_max_iter,\n", " store_progress=True,\n", " change_scale_criterion=None,\n", " ctf_iters_to_check=3,\n", - " )\n", + " )\n", " return met" ] }, @@ -521,11 +554,13 @@ "source": [ "# The following class extends the PortillaSimoncelli model so that you can specify which\n", "# statistics you would like to remove. We have created this model so that we can examine\n", - "# the consequences of the absence of specific statistics. \n", + "# the consequences of the absence of specific statistics.\n", "#\n", "# Be sure to run this cell.\n", "\n", "from collections import OrderedDict\n", + "\n", + "\n", "class PortillaSimoncelliRemove(po.simul.PortillaSimoncelli):\n", " r\"\"\"Model for measuring a subset of texture statistics reported by PortillaSimoncelli\n", "\n", @@ -536,18 +571,21 @@ " remove_keys: list\n", " The dictionary keys for the statistics we will \"remove\". In practice we set them to zero.\n", " Possible keys: [\"pixel_statistics\", \"auto_correlation_magnitude\",\n", - " \"skew_reconstructed\", \"kurtosis_reconstructed\", \"auto_correlation_reconstructed\", \n", - " \"std_reconstructed\", \"magnitude_std\", \"cross_orientation_correlation_magnitude\", \n", + " \"skew_reconstructed\", \"kurtosis_reconstructed\", \"auto_correlation_reconstructed\",\n", + " \"std_reconstructed\", \"magnitude_std\", \"cross_orientation_correlation_magnitude\",\n", " \"cross_scale_correlation_magnitude\" \"cross_scale_correlation_real\", \"var_highpass_residual\"]\n", " \"\"\"\n", + "\n", " def __init__(\n", " self,\n", " im_shape,\n", " remove_keys,\n", " ):\n", - " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", + " super().__init__(\n", + " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9\n", + " )\n", " self.remove_keys = remove_keys\n", - " \n", + "\n", " def forward(self, image, scales=None):\n", " r\"\"\"Generate Texture Statistics representation of an image with `remove_keys` removed.\n", "\n", @@ -571,11 +609,11 @@ " # convert to dict so it's easy to zero out the keys we don't care about\n", " stats_dict = self.convert_to_dict(stats_vec)\n", " for kk in self.remove_keys:\n", - " # we zero out the stats (instead of removing them) because removing them \n", - " # makes it difficult to keep track of which stats belong to which scale \n", + " # we zero out the stats (instead of removing them) because removing them\n", + " # makes it difficult to keep track of which stats belong to which scale\n", " # (which is necessary for coarse-to-fine synthesis) -- see discussion above.\n", - " if isinstance(stats_dict[kk],OrderedDict):\n", - " for (key,val) in stats_dict[kk].items():\n", + " if isinstance(stats_dict[kk], OrderedDict):\n", + " for key, val in stats_dict[kk].items():\n", " stats_dict[kk][key] *= 0\n", " else:\n", " stats_dict[kk] *= 0\n", @@ -584,7 +622,7 @@ " stats_vec = self.convert_to_tensor(stats_dict)\n", " if scales is not None:\n", " stats_vec = self.remove_scales(stats_vec, scales)\n", - " return stats_vec\n" + " return stats_vec" ] }, { @@ -620,17 +658,23 @@ ], "source": [ "# which statistics to remove\n", - "remove_statistics = ['pixel_statistics','skew_reconstructed','kurtosis_reconstructed']\n", + "remove_statistics = [\n", + " \"pixel_statistics\",\n", + " \"skew_reconstructed\",\n", + " \"kurtosis_reconstructed\",\n", + "]\n", "\n", "# run on fig3a or fig3b to replicate paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig3b.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig3b.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", "metamer = run_synthesis(img, model)\n", "\n", "# synthesis with pixel and marginal statistics absent\n", - "model_remove = PortillaSimoncelliRemove(img.shape[-2:] ,remove_keys=remove_statistics).to(DEVICE)\n", + "model_remove = PortillaSimoncelliRemove(\n", + " img.shape[-2:], remove_keys=remove_statistics\n", + ").to(DEVICE)\n", "metamer_remove = run_synthesis(img, model_remove)" ] }, @@ -669,16 +713,19 @@ ], "source": [ "# visualize results\n", - "fig = po.imshow([metamer.image, metamer.metamer, metamer_remove.metamer], \n", - " title=['Target image', 'Full Statistics', 'Without Marginal Statistics'], vrange='auto1');\n", + "fig = po.imshow(\n", + " [metamer.image, metamer.metamer, metamer_remove.metamer],\n", + " title=[\"Target image\", \"Full Statistics\", \"Without Marginal Statistics\"],\n", + " vrange=\"auto1\",\n", + ")\n", "# add plots showing the different pixel intensity histograms\n", - "fig.add_axes([.33, -1, .33, .9])\n", - "fig.add_axes([.67, -1, .33, .9])\n", + "fig.add_axes([0.33, -1, 0.33, 0.9])\n", + "fig.add_axes([0.67, -1, 0.33, 0.9])\n", "# this helper function expects a metamer object. see the metamer notebook for details.\n", "po.synth.metamer.plot_pixel_values(metamer, ax=fig.axes[3])\n", - "fig.axes[3].set_title('Full statistics')\n", + "fig.axes[3].set_title(\"Full statistics\")\n", "po.synth.metamer.plot_pixel_values(metamer_remove, ax=fig.axes[4])\n", - "fig.axes[4].set_title('Without marginal statistics')" + "fig.axes[4].set_title(\"Without marginal statistics\")" ] }, { @@ -713,17 +760,19 @@ "# which statistics to remove. note that, in the original paper, std_reconstructed is implicitly contained within\n", "# auto_correlation_reconstructed, view the section on differences between plenoptic and matlab implementation\n", "# for details\n", - "remove_statistics = ['auto_correlation_reconstructed', 'std_reconstructed']\n", + "remove_statistics = [\"auto_correlation_reconstructed\", \"std_reconstructed\"]\n", "\n", "# run on fig4a or fig4b to replicate paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig4b.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig4b.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", "metamer = run_synthesis(img, model)\n", "\n", "# synthesis with coefficient correlations absent\n", - "model_remove = PortillaSimoncelliRemove(img.shape[-2:], remove_keys=remove_statistics).to(DEVICE)\n", + "model_remove = PortillaSimoncelliRemove(\n", + " img.shape[-2:], remove_keys=remove_statistics\n", + ").to(DEVICE)\n", "metamer_remove = run_synthesis(img, model_remove)" ] }, @@ -745,8 +794,15 @@ ], "source": [ "# visualize results\n", - "po.imshow([metamer.image, metamer.metamer, metamer_remove.metamer], \n", - " title=['Target image', 'Full Statistics', 'Without Correlation Statistics'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer, metamer_remove.metamer],\n", + " title=[\n", + " \"Target image\",\n", + " \"Full Statistics\",\n", + " \"Without Correlation Statistics\",\n", + " ],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -783,13 +839,19 @@ } ], "source": [ - "fig, _ = model.plot_representation(model(metamer_remove.metamer) - model(metamer.image),\n", - " figsize=(15, 5), ylim=(-4, 4))\n", - "fig.suptitle('Without Correlation Statistics')\n", + "fig, _ = model.plot_representation(\n", + " model(metamer_remove.metamer) - model(metamer.image),\n", + " figsize=(15, 5),\n", + " ylim=(-4, 4),\n", + ")\n", + "fig.suptitle(\"Without Correlation Statistics\")\n", "\n", - "fig, _ = model.plot_representation(model(metamer.metamer) - model(metamer.image),\n", - " figsize=(15, 5), ylim=(-4, 4))\n", - "fig.suptitle('Full statistics');" + "fig, _ = model.plot_representation(\n", + " model(metamer.metamer) - model(metamer.image),\n", + " figsize=(15, 5),\n", + " ylim=(-4, 4),\n", + ")\n", + "fig.suptitle(\"Full statistics\");" ] }, { @@ -824,18 +886,24 @@ "# which statistics to remove. note that, in the original paper, magnitude_std is implicitly contained within\n", "# auto_correlation_magnitude, view the section on differences between plenoptic and matlab implementation\n", "# for details\n", - "remove_statistics = ['magnitude_std', 'cross_orientation_correlation_magnitude', \n", - " 'cross_scale_correlation_magnitude', 'auto_correlation_magnitude']\n", + "remove_statistics = [\n", + " \"magnitude_std\",\n", + " \"cross_orientation_correlation_magnitude\",\n", + " \"cross_scale_correlation_magnitude\",\n", + " \"auto_correlation_magnitude\",\n", + "]\n", "\n", "# run on fig6a or fig6b to replicate paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig6a.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig6a.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", "metamer = run_synthesis(img, model)\n", "\n", "# synthesis with pixel and marginal statistics absent\n", - "model_remove = PortillaSimoncelliRemove(img.shape[-2:],remove_keys=remove_statistics).to(DEVICE)\n", + "model_remove = PortillaSimoncelliRemove(\n", + " img.shape[-2:], remove_keys=remove_statistics\n", + ").to(DEVICE)\n", "metamer_remove = run_synthesis(img, model_remove)" ] }, @@ -857,8 +925,11 @@ ], "source": [ "# visualize results\n", - "po.imshow([metamer.image, metamer.metamer, metamer_remove.metamer],\n", - " title=['Target image', 'Full Statistics','Without Magnitude Statistics'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer, metamer_remove.metamer],\n", + " title=[\"Target image\", \"Full Statistics\", \"Without Magnitude Statistics\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -895,13 +966,19 @@ } ], "source": [ - "fig, _ = model.plot_representation(model(metamer_remove.metamer) - model(metamer.image),\n", - " figsize=(15, 5), ylim=(-2, 2))\n", - "fig.suptitle('Without Correlation Statistics')\n", + "fig, _ = model.plot_representation(\n", + " model(metamer_remove.metamer) - model(metamer.image),\n", + " figsize=(15, 5),\n", + " ylim=(-2, 2),\n", + ")\n", + "fig.suptitle(\"Without Correlation Statistics\")\n", "\n", - "fig, _ = model.plot_representation(model(metamer.metamer) - model(metamer.image),\n", - " figsize=(15, 5), ylim=(-2, 2))\n", - "fig.suptitle('Full statistics');" + "fig, _ = model.plot_representation(\n", + " model(metamer.metamer) - model(metamer.image),\n", + " figsize=(15, 5),\n", + " ylim=(-2, 2),\n", + ")\n", + "fig.suptitle(\"Full statistics\");" ] }, { @@ -934,17 +1011,19 @@ ], "source": [ "# which statistics to remove\n", - "remove_statistics = ['cross_scale_correlation_real']\n", + "remove_statistics = [\"cross_scale_correlation_real\"]\n", "\n", "# run on fig8a and fig8b to replicate paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig8b.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig8b.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", "metamer = run_synthesis(img, model)\n", "\n", "# synthesis with pixel and marginal statistics absent\n", - "model_remove = PortillaSimoncelliRemove(img.shape[-2:], remove_keys=remove_statistics).to(DEVICE)\n", + "model_remove = PortillaSimoncelliRemove(\n", + " img.shape[-2:], remove_keys=remove_statistics\n", + ").to(DEVICE)\n", "metamer_remove = run_synthesis(img, model_remove)" ] }, @@ -966,8 +1045,15 @@ ], "source": [ "# visualize results\n", - "po.imshow([metamer.image, metamer.metamer, metamer_remove.metamer],\n", - " title=['Target image', 'Full Statistics','Without Cross-Scale Phase Statistics'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer, metamer_remove.metamer],\n", + " title=[\n", + " \"Target image\",\n", + " \"Full Statistics\",\n", + " \"Without Cross-Scale Phase Statistics\",\n", + " ],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -1004,13 +1090,19 @@ } ], "source": [ - "fig, _ = model.plot_representation(model(metamer_remove.metamer) - model(metamer.image),\n", - " figsize=(15, 5), ylim=(-1.2, 1.2))\n", - "fig.suptitle('Without Correlation Statistics')\n", + "fig, _ = model.plot_representation(\n", + " model(metamer_remove.metamer) - model(metamer.image),\n", + " figsize=(15, 5),\n", + " ylim=(-1.2, 1.2),\n", + ")\n", + "fig.suptitle(\"Without Correlation Statistics\")\n", "\n", - "fig, _ = model.plot_representation(model(metamer.metamer) - model(metamer.image),\n", - " figsize=(15, 5), ylim=(-1.2, 1.2))\n", - "fig.suptitle('Full statistics');" + "fig, _ = model.plot_representation(\n", + " model(metamer.metamer) - model(metamer.image),\n", + " figsize=(15, 5),\n", + " ylim=(-1.2, 1.2),\n", + ")\n", + "fig.suptitle(\"Full statistics\");" ] }, { @@ -1051,11 +1143,11 @@ } ], "source": [ - "img = po.tools.load_images(DATA_PATH / 'fig12a.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig12a.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "metamer = run_synthesis(img,model)" + "metamer = run_synthesis(img, model)" ] }, { @@ -1075,8 +1167,11 @@ } ], "source": [ - "po.imshow([metamer.image, metamer.metamer], \n", - " title=['Target image', 'Synthesized Metamer'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer],\n", + " title=[\"Target image\", \"Synthesized Metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -1107,11 +1202,11 @@ ], "source": [ "# Run on fig13a, fig13b, fig13c, fig13d to replicate examples in paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig13a.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig13a.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "metamer_left = run_synthesis(img,model)" + "metamer_left = run_synthesis(img, model)" ] }, { @@ -1129,11 +1224,11 @@ ], "source": [ "# Run on fig13a, fig13b, fig13c, fig13d to replicate examples in paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig13b.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig13b.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "metamer_right = run_synthesis(img,model)" + "metamer_right = run_synthesis(img, model)" ] }, { @@ -1160,10 +1255,22 @@ } ], "source": [ - "po.imshow([metamer_left.image, metamer_left.metamer, \n", - " metamer_right.image, metamer_right.metamer],\n", - " title=['Target image 1', 'Synthesized Metamer 1', 'Target Image 2', 'Synthesized Metamer 2'],\n", - " vrange='auto1', col_wrap=2);" + "po.imshow(\n", + " [\n", + " metamer_left.image,\n", + " metamer_left.metamer,\n", + " metamer_right.image,\n", + " metamer_right.metamer,\n", + " ],\n", + " title=[\n", + " \"Target image 1\",\n", + " \"Synthesized Metamer 1\",\n", + " \"Target Image 2\",\n", + " \"Synthesized Metamer 2\",\n", + " ],\n", + " vrange=\"auto1\",\n", + " col_wrap=2,\n", + ");" ] }, { @@ -1192,11 +1299,11 @@ ], "source": [ "# Run on fig14a, fig14b, fig14c, fig14d, fig14e, fig14f to replicate examples in paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig14a.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig14a.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "metamer = run_synthesis(img,model)" + "metamer = run_synthesis(img, model)" ] }, { @@ -1216,8 +1323,11 @@ } ], "source": [ - "po.imshow([metamer.image, metamer.metamer],\n", - " title=['Target image', 'Synthesized Metamer'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer],\n", + " title=[\"Target image\", \"Synthesized Metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -1246,11 +1356,11 @@ ], "source": [ "# Run on fig15a, fig15b, fig15c, fig15d to replicate examples in paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig15a.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig15a.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", - "metamer = run_synthesis(img,model)" + "metamer = run_synthesis(img, model)" ] }, { @@ -1270,8 +1380,11 @@ } ], "source": [ - "po.imshow([metamer.image, metamer.metamer],\n", - " title=['Target image', 'Synthesized Metamer'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer],\n", + " title=[\"Target image\", \"Synthesized Metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -1300,7 +1413,7 @@ ], "source": [ "# Run on fig16a, fig16b, fig16c, fig16d to replicate examples in paper\n", - "img = po.tools.load_images(DATA_PATH / 'fig16e.jpg').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig16e.jpg\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", @@ -1324,8 +1437,11 @@ } ], "source": [ - "po.imshow([metamer.image, metamer.metamer],\n", - " title=['Target image', 'Synthesized metamer'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer],\n", + " title=[\"Target image\", \"Synthesized metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -1352,10 +1468,11 @@ "metadata": {}, "outputs": [], "source": [ - "# The following class inherits from the PortillaSimoncelli model for \n", + "# The following class inherits from the PortillaSimoncelli model for\n", "# the purpose of extrapolating (filling in) a chunk of an imaged defined\n", "# by a mask.\n", "\n", + "\n", "class PortillaSimoncelliMask(po.simul.PortillaSimoncelli):\n", " r\"\"\"Extend the PortillaSimoncelli model to operate on masked images.\n", "\n", @@ -1367,6 +1484,7 @@ " image target for synthesis\n", "\n", " \"\"\"\n", + "\n", " def __init__(\n", " self,\n", " im_shape,\n", @@ -1374,12 +1492,14 @@ " n_orientations=4,\n", " spatial_corr_width=9,\n", " mask=None,\n", - " target=None\n", + " target=None,\n", " ):\n", - " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", - " self.mask = mask;\n", - " self.target = target;\n", - " \n", + " super().__init__(\n", + " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9\n", + " )\n", + " self.mask = mask\n", + " self.target = target\n", + "\n", " def forward(self, image, scales=None):\n", " r\"\"\"Generate Texture Statistics representation of an image using the target for the masked portion\n", "\n", @@ -1402,25 +1522,25 @@ " \"\"\"\n", " if self.mask is not None and self.target is not None:\n", " image = self.texture_masked_image(image)\n", - " \n", - " return super().forward(image,scales=scales)\n", - " \n", - " def texture_masked_image(self,image):\n", - " r\"\"\" Fill in part of the image (designated by the mask) with the saved target image\n", - " \n", + "\n", + " return super().forward(image, scales=scales)\n", + "\n", + " def texture_masked_image(self, image):\n", + " r\"\"\"Fill in part of the image (designated by the mask) with the saved target image\n", + "\n", " Parameters\n", " ------------\n", " image : torch.Tensor\n", " A tensor containing a single image\n", - " \n", + "\n", " Returns\n", " -------\n", " texture_masked_image: torch.Tensor\n", - " An image that is a combination of the input image and the saved target. \n", + " An image that is a combination of the input image and the saved target.\n", " Combination is specified by self.mask\n", - " \n", + "\n", " \"\"\"\n", - " return self.target*self.mask + image*(~self.mask)" + " return self.target * self.mask + image * (~self.mask)" ] }, { @@ -1437,27 +1557,33 @@ } ], "source": [ - "img_file = DATA_PATH / 'fig14b.jpg'\n", + "img_file = DATA_PATH / \"fig14b.jpg\"\n", "img = po.tools.load_images(img_file).to(DEVICE)\n", - "im_init = (torch.rand_like(img)-.5) * .1 + img.mean();\n", - "\n", - "mask = torch.zeros(1,1,256,256).bool().to(DEVICE)\n", - "ctr_dim = (img.shape[-2]//4, img.shape[-1]//4)\n", - "mask[...,ctr_dim[0]:3*ctr_dim[0],ctr_dim[1]:3*ctr_dim[1]] = True\n", - "\n", - "model = PortillaSimoncelliMask(img.shape[-2:], target=img, mask=mask).to(DEVICE)\n", - "met = po.synth.MetamerCTF(img, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init,\n", - " coarse_to_fine='together')\n", - "\n", - "optimizer = torch.optim.Adam([met.metamer],lr=.02, amsgrad=True)\n", + "im_init = (torch.rand_like(img) - 0.5) * 0.1 + img.mean()\n", + "mask = torch.zeros(1, 1, 256, 256).bool().to(DEVICE)\n", + "ctr_dim = (img.shape[-2] // 4, img.shape[-1] // 4)\n", + "mask[..., ctr_dim[0] : 3 * ctr_dim[0], ctr_dim[1] : 3 * ctr_dim[1]] = True\n", + "\n", + "model = PortillaSimoncelliMask(img.shape[-2:], target=img, mask=mask).to(\n", + " DEVICE\n", + ")\n", + "met = po.synth.MetamerCTF(\n", + " img,\n", + " model,\n", + " loss_function=po.tools.optim.l2_norm,\n", + " initial_image=im_init,\n", + " coarse_to_fine=\"together\",\n", + ")\n", + "\n", + "optimizer = torch.optim.Adam([met.metamer], lr=0.02, amsgrad=True)\n", "\n", "met.synthesize(\n", " optimizer=optimizer,\n", - " max_iter=short_synth_max_iter, \n", + " max_iter=short_synth_max_iter,\n", " store_progress=True,\n", " change_scale_criterion=None,\n", - " ctf_iters_to_check=3\n", - " )" + " ctf_iters_to_check=3,\n", + ")" ] }, { @@ -1477,8 +1603,11 @@ } ], "source": [ - "po.imshow([met.image, mask*met.image, model.texture_masked_image(met.metamer)], vrange='auto1',\n", - " title=['Full target image', 'Masked target' ,'synthesized image']);" + "po.imshow(\n", + " [met.image, mask * met.image, model.texture_masked_image(met.metamer)],\n", + " vrange=\"auto1\",\n", + " title=[\"Full target image\", \"Masked target\", \"synthesized image\"],\n", + ");" ] }, { @@ -1500,25 +1629,28 @@ "metadata": {}, "outputs": [], "source": [ - "# The following classes are designed to extend the PortillaSimoncelli model \n", + "# The following classes are designed to extend the PortillaSimoncelli model\n", "# and the Metamer synthesis method for the purpose of mixing two target textures.\n", "\n", + "\n", "class PortillaSimoncelliMixture(po.simul.PortillaSimoncelli):\n", " r\"\"\"Extend the PortillaSimoncelli model to mix two different images\n", "\n", - " Parameters\n", - " ----------\n", - " im_shape: int\n", - " the size of the images being processed by the model\n", + " Parameters\n", + " ----------\n", + " im_shape: int\n", + " the size of the images being processed by the model\n", "\n", " \"\"\"\n", + "\n", " def __init__(\n", " self,\n", " im_shape,\n", " ):\n", - " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", - " \n", - " \n", + " super().__init__(\n", + " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9\n", + " )\n", + "\n", " def forward(self, images, scales=None):\n", " r\"\"\"Average Texture Statistics representations of two image\n", "\n", @@ -1543,14 +1675,16 @@ " # need the images to be 4d, so we use the \"1 element slice\"\n", " stats0 = super().forward(images[:1], scales=scales)\n", " stats1 = super().forward(images[1:2], scales=scales)\n", - " return (stats0+stats1)/2\n", + " return (stats0 + stats1) / 2\n", " else:\n", " return super().forward(images, scales=scales)\n", - " \n", + "\n", + "\n", "class MetamerMixture(po.synth.MetamerCTF):\n", - " r\"\"\" Extending metamer synthesis based on image-computable \n", + " r\"\"\"Extending metamer synthesis based on image-computable\n", " differentiable models, for mixing two images.\n", " \"\"\"\n", + "\n", " def _initialize(self, initial_image):\n", " \"\"\"Initialize the metamer.\n", "\n", @@ -1566,15 +1700,16 @@ "\n", " \"\"\"\n", " if initial_image.ndimension() < 4:\n", - " raise Exception(\"initial_image must be torch.Size([n_batch\"\n", - " \", n_channels, im_height, im_width]) but got \"\n", - " f\"{initial_image.size()}\")\n", + " raise Exception(\n", + " \"initial_image must be torch.Size([n_batch\"\n", + " \", n_channels, im_height, im_width]) but got \"\n", + " f\"{initial_image.size()}\"\n", + " )\n", " # the difference between this and the regular version of Metamer is that\n", " # the regular version requires synthesized_signal and target_signal to have\n", " # the same shape, and here target_signal is (2, 1, 256, 256), not (1, 1, 256, 256)\n", " metamer = initial_image.clone().detach()\n", - " metamer = metamer.to(dtype=self.image.dtype,\n", - " device=self.image.device)\n", + " metamer = metamer.to(dtype=self.image.dtype, device=self.image.device)\n", " metamer.requires_grad_()\n", " self._metamer = metamer" ] @@ -1594,27 +1729,32 @@ ], "source": [ "# Figure 20. Examples of “mixture” textures.\n", - "# To replicate paper use the following combinations: \n", + "# To replicate paper use the following combinations:\n", "# (Fig. 15a, Fig. 15b); (Fig. 14b, Fig. 4a); (Fig. 15e, Fig. 14e).\n", "\n", - "img_files = [DATA_PATH / 'fig15e.jpg', DATA_PATH / 'fig14e.jpg']\n", + "img_files = [DATA_PATH / \"fig15e.jpg\", DATA_PATH / \"fig14e.jpg\"]\n", "imgs = po.tools.load_images(img_files).to(DEVICE)\n", - "im_init = torch.rand_like(imgs[0,:,:,:].unsqueeze(0)) * .01 + imgs.mean()\n", - "n=imgs.shape[-1]\n", + "im_init = torch.rand_like(imgs[0, :, :, :].unsqueeze(0)) * 0.01 + imgs.mean()\n", + "n = imgs.shape[-1]\n", "\n", - "model = PortillaSimoncelliMixture([n,n]).to(DEVICE)\n", - "met = MetamerMixture(imgs, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init,\n", - " coarse_to_fine='together')\n", + "model = PortillaSimoncelliMixture([n, n]).to(DEVICE)\n", + "met = MetamerMixture(\n", + " imgs,\n", + " model,\n", + " loss_function=po.tools.optim.l2_norm,\n", + " initial_image=im_init,\n", + " coarse_to_fine=\"together\",\n", + ")\n", "\n", - "optimizer = torch.optim.Adam([met.metamer],lr=.02, amsgrad=True)\n", + "optimizer = torch.optim.Adam([met.metamer], lr=0.02, amsgrad=True)\n", "\n", "met.synthesize(\n", " optimizer=optimizer,\n", - " max_iter=longest_synth_max_iter, \n", + " max_iter=longest_synth_max_iter,\n", " store_progress=True,\n", " change_scale_criterion=None,\n", - " ctf_iters_to_check=3\n", - " )" + " ctf_iters_to_check=3,\n", + ")" ] }, { @@ -1634,7 +1774,11 @@ } ], "source": [ - "po.imshow([met.image, met.metamer], vrange='auto1',title=['Target image 1', 'Target image 2', 'Synthesized Mixture Metamer']);" + "po.imshow(\n", + " [met.image, met.metamer],\n", + " vrange=\"auto1\",\n", + " title=[\"Target image 1\", \"Target image 2\", \"Synthesized Mixture Metamer\"],\n", + ");" ] }, { @@ -1693,8 +1837,11 @@ } ], "source": [ - "po.imshow([metamer.image, metamer.metamer],\n", - " title=['Target image', 'Synthesized Metamer'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer],\n", + " title=[\"Target image\", \"Synthesized Metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -1718,7 +1865,7 @@ } ], "source": [ - "img = po.tools.load_images(DATA_PATH / 'fig18a.png').to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig18a.png\").to(DEVICE)\n", "\n", "# synthesis with full PortillaSimoncelli model\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", @@ -1742,8 +1889,11 @@ } ], "source": [ - "po.imshow([metamer.image, metamer.metamer],\n", - " title=['Target image', 'Synthesized Metamer'], vrange='auto1');" + "po.imshow(\n", + " [metamer.image, metamer.metamer],\n", + " title=[\"Target image\", \"Synthesized Metamer\"],\n", + " vrange=\"auto1\",\n", + ");" ] }, { @@ -1812,17 +1962,17 @@ } ], "source": [ - "img = po.tools.load_images(DATA_PATH / 'fig4a.jpg')\n", + "img = po.tools.load_images(DATA_PATH / \"fig4a.jpg\")\n", "image_shape = img.shape[2:4]\n", "\n", "# Initialize the minimal model. Use same params as paper\n", - "model = po.simul.PortillaSimoncelli(image_shape, n_scales=4,\n", - " n_orientations=4,\n", - " spatial_corr_width=7)\n", + "model = po.simul.PortillaSimoncelli(\n", + " image_shape, n_scales=4, n_orientations=4, spatial_corr_width=7\n", + ")\n", "\n", "stats = model(img)\n", "\n", - "print(f'Stats for N=4, K=4, M=7: {stats[0].shape[1]} statistics')" + "print(f\"Stats for N=4, K=4, M=7: {stats[0].shape[1]} statistics\")" ] }, { @@ -1855,7 +2005,7 @@ "stats_dict = model.convert_to_dict(stats)\n", "s = 1\n", "o = 2\n", - "print(stats_dict['auto_correlation_magnitude'][0,0,:,:,s,o])" + "print(stats_dict[\"auto_correlation_magnitude\"][0, 0, :, :, s, o])" ] }, { @@ -1881,8 +2031,10 @@ } ], "source": [ - "acm_not_redundant = torch.sum(~torch.isnan(stats_dict['auto_correlation_magnitude']))\n", - "print(f'Non-redundant elements in acm: {acm_not_redundant}')" + "acm_not_redundant = torch.sum(\n", + " ~torch.isnan(stats_dict[\"auto_correlation_magnitude\"])\n", + ")\n", + "print(f\"Non-redundant elements in acm: {acm_not_redundant}\")" ] }, { @@ -1906,7 +2058,9 @@ } ], "source": [ - "print(f\"Number magnitude band variances: {stats_dict['magnitude_std'].numel()}\")" + "print(\n", + " f\"Number magnitude band variances: {stats_dict['magnitude_std'].numel()}\"\n", + ")" ] }, { @@ -1947,30 +2101,50 @@ ], "source": [ "# Sum marginal statistics\n", - "marginal_stats_num = (torch.sum(~torch.isnan(stats_dict['kurtosis_reconstructed'])) +\n", - " torch.sum(~torch.isnan(stats_dict['skew_reconstructed'])) +\n", - " torch.sum(~torch.isnan(stats_dict['var_highpass_residual'])) +\n", - " torch.sum(~torch.isnan(stats_dict['pixel_statistics'])))\n", - "print(f'Marginal statistics: {marginal_stats_num} parameters, compared to 17 in paper')\n", + "marginal_stats_num = (\n", + " torch.sum(~torch.isnan(stats_dict[\"kurtosis_reconstructed\"]))\n", + " + torch.sum(~torch.isnan(stats_dict[\"skew_reconstructed\"]))\n", + " + torch.sum(~torch.isnan(stats_dict[\"var_highpass_residual\"]))\n", + " + torch.sum(~torch.isnan(stats_dict[\"pixel_statistics\"]))\n", + ")\n", + "print(\n", + " f\"Marginal statistics: {marginal_stats_num} parameters, compared to 17 in paper\"\n", + ")\n", "\n", "# Sum raw coefficient correlations\n", - "real_coefficient_corr_num = torch.sum(~torch.isnan(stats_dict['auto_correlation_reconstructed']))\n", - "real_variances = torch.sum(~torch.isnan(stats_dict['std_reconstructed']))\n", - "print(f'Raw coefficient correlation: {real_coefficient_corr_num + real_variances} parameters, '\n", - " 'compared to 125 in paper')\n", + "real_coefficient_corr_num = torch.sum(\n", + " ~torch.isnan(stats_dict[\"auto_correlation_reconstructed\"])\n", + ")\n", + "real_variances = torch.sum(~torch.isnan(stats_dict[\"std_reconstructed\"]))\n", + "print(\n", + " f\"Raw coefficient correlation: {real_coefficient_corr_num + real_variances} parameters, \"\n", + " \"compared to 125 in paper\"\n", + ")\n", "\n", "# Sum coefficient magnitude statistics\n", - "coeff_magnitude_stats_num = (torch.sum(~torch.isnan(stats_dict['auto_correlation_magnitude'])) +\n", - " torch.sum(~torch.isnan(stats_dict['cross_scale_correlation_magnitude'])) + \n", - " torch.sum(~torch.isnan(stats_dict['cross_orientation_correlation_magnitude'])))\n", - "coeff_magnitude_variances = torch.sum(~torch.isnan(stats_dict['magnitude_std']))\n", - "\n", - "print(f'Coefficient magnitude statistics: {coeff_magnitude_stats_num + coeff_magnitude_variances} '\n", - " 'parameters, compared to 472 in paper')\n", + "coeff_magnitude_stats_num = (\n", + " torch.sum(~torch.isnan(stats_dict[\"auto_correlation_magnitude\"]))\n", + " + torch.sum(~torch.isnan(stats_dict[\"cross_scale_correlation_magnitude\"]))\n", + " + torch.sum(\n", + " ~torch.isnan(stats_dict[\"cross_orientation_correlation_magnitude\"])\n", + " )\n", + ")\n", + "coeff_magnitude_variances = torch.sum(\n", + " ~torch.isnan(stats_dict[\"magnitude_std\"])\n", + ")\n", + "\n", + "print(\n", + " f\"Coefficient magnitude statistics: {coeff_magnitude_stats_num + coeff_magnitude_variances} \"\n", + " \"parameters, compared to 472 in paper\"\n", + ")\n", "\n", "# Sum cross-scale phase statistics\n", - "phase_statistics_num = torch.sum(~torch.isnan(stats_dict['cross_scale_correlation_real']))\n", - "print(f'Phase statistics: {phase_statistics_num} parameters, compared to 96 in paper')" + "phase_statistics_num = torch.sum(\n", + " ~torch.isnan(stats_dict[\"cross_scale_correlation_real\"])\n", + ")\n", + "print(\n", + " f\"Phase statistics: {phase_statistics_num} parameters, compared to 96 in paper\"\n", + ")" ] }, { @@ -1997,22 +2171,25 @@ "source": [ "from collections import OrderedDict\n", "\n", + "\n", "class PortillaSimoncelliMagMeans(po.simul.PortillaSimoncelli):\n", " r\"\"\"Include the magnitude means in the PS texture representation.\n", "\n", - " Parameters\n", - " ----------\n", - " im_shape: int\n", - " the size of the images being processed by the model\n", + " Parameters\n", + " ----------\n", + " im_shape: int\n", + " the size of the images being processed by the model\n", "\n", " \"\"\"\n", + "\n", " def __init__(\n", " self,\n", " im_shape,\n", " ):\n", - " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=7)\n", - " \n", - " \n", + " super().__init__(\n", + " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=7\n", + " )\n", + "\n", " def forward(self, image, scales=None):\n", " r\"\"\"Average Texture Statistics representations of two image\n", "\n", @@ -2038,29 +2215,41 @@ " # pyramid coefficients at each scale\n", " pyr_coeffs = self._compute_pyr_coeffs(image)[1]\n", " # only compute the magnitudes for the desired scales\n", - " magnitude_pyr_coeffs = [coeff.abs() for i, coeff in enumerate(pyr_coeffs)\n", - " if scales is None or i in scales]\n", + " magnitude_pyr_coeffs = [\n", + " coeff.abs()\n", + " for i, coeff in enumerate(pyr_coeffs)\n", + " if scales is None or i in scales\n", + " ]\n", " magnitude_means = [mag.mean((-2, -1)) for mag in magnitude_pyr_coeffs]\n", - " return einops.pack([stats, *magnitude_means], 'b c *')[0]\n", - " \n", - " # overwriting these following two methods allows us to use the plot_representation method \n", + " return einops.pack([stats, *magnitude_means], \"b c *\")[0]\n", + "\n", + " # overwriting these following two methods allows us to use the plot_representation method\n", " # with the modified model, making examining it easier.\n", - " def convert_to_dict(self, representation_tensor: torch.Tensor) -> OrderedDict:\n", + " def convert_to_dict(\n", + " self, representation_tensor: torch.Tensor\n", + " ) -> OrderedDict:\n", " \"\"\"Convert tensor of stats to dictionary.\"\"\"\n", " n_mag_means = self.n_scales * self.n_orientations\n", - " rep = super().convert_to_dict(representation_tensor[..., :-n_mag_means])\n", + " rep = super().convert_to_dict(\n", + " representation_tensor[..., :-n_mag_means]\n", + " )\n", " mag_means = representation_tensor[..., -n_mag_means:]\n", - " rep['magnitude_means'] = einops.rearrange(mag_means, 'b c (s o) -> b c s o', s=self.n_scales, o=self.n_orientations)\n", + " rep[\"magnitude_means\"] = einops.rearrange(\n", + " mag_means,\n", + " \"b c (s o) -> b c s o\",\n", + " s=self.n_scales,\n", + " o=self.n_orientations,\n", + " )\n", " return rep\n", - " \n", + "\n", " def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict:\n", " r\"\"\"Convert the data into a dictionary representation that is more convenient for plotting.\n", "\n", " Intended as a helper function for plot_representation.\n", " \"\"\"\n", - " mag_means = rep.pop('magnitude_means')\n", + " mag_means = rep.pop(\"magnitude_means\")\n", " data = super()._representation_for_plotting(rep)\n", - " data['magnitude_means'] = mag_means.flatten()\n", + " data[\"magnitude_means\"] = mag_means.flatten()\n", " return data" ] }, @@ -2077,10 +2266,12 @@ "metadata": {}, "outputs": [], "source": [ - "img = po.tools.load_images(DATA_PATH / 'fig4a.jpg').to(DEVICE)\n", - "model = po.simul.PortillaSimoncelli(img.shape[-2:], spatial_corr_width=7).to(DEVICE)\n", + "img = po.tools.load_images(DATA_PATH / \"fig4a.jpg\").to(DEVICE)\n", + "model = po.simul.PortillaSimoncelli(img.shape[-2:], spatial_corr_width=7).to(\n", + " DEVICE\n", + ")\n", "model_mag_means = PortillaSimoncelliMagMeans(img.shape[-2:]).to(DEVICE)\n", - "im_init = (torch.rand_like(img)-.5) * .1 + img.mean()" + "im_init = (torch.rand_like(img) - 0.5) * 0.1 + img.mean()" ] }, { @@ -2107,12 +2298,29 @@ "source": [ "# Set the RNG seed to make the two synthesis procedures as similar as possible.\n", "po.tools.set_seed(100)\n", - "met = po.synth.MetamerCTF(img, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init)\n", - "met.synthesize(store_progress=10, max_iter=short_synth_max_iter, change_scale_criterion=None, ctf_iters_to_check=7)\n", + "met = po.synth.MetamerCTF(\n", + " img, model, loss_function=po.tools.optim.l2_norm, initial_image=im_init\n", + ")\n", + "met.synthesize(\n", + " store_progress=10,\n", + " max_iter=short_synth_max_iter,\n", + " change_scale_criterion=None,\n", + " ctf_iters_to_check=7,\n", + ")\n", "\n", "po.tools.set_seed(100)\n", - "met_mag_means = po.synth.MetamerCTF(img, model_mag_means, loss_function=po.tools.optim.l2_norm, initial_image=im_init)\n", - "met_mag_means.synthesize(store_progress=10, max_iter=short_synth_max_iter, change_scale_criterion=None, ctf_iters_to_check=7)" + "met_mag_means = po.synth.MetamerCTF(\n", + " img,\n", + " model_mag_means,\n", + " loss_function=po.tools.optim.l2_norm,\n", + " initial_image=im_init,\n", + ")\n", + "met_mag_means.synthesize(\n", + " store_progress=10,\n", + " max_iter=short_synth_max_iter,\n", + " change_scale_criterion=None,\n", + " ctf_iters_to_check=7,\n", + ")" ] }, { @@ -2142,13 +2350,25 @@ } ], "source": [ - "fig, axes = plt.subplots(2, 2, figsize=(21, 11), gridspec_kw={'width_ratios': [1, 3.1]})\n", - "for ax, im, info in zip(axes[:, 0], [met.metamer, met_mag_means.metamer], ['with', 'without']):\n", + "fig, axes = plt.subplots(\n", + " 2, 2, figsize=(21, 11), gridspec_kw={\"width_ratios\": [1, 3.1]}\n", + ")\n", + "for ax, im, info in zip(\n", + " axes[:, 0], [met.metamer, met_mag_means.metamer], [\"with\", \"without\"]\n", + "):\n", " po.imshow(im, ax=ax, title=f\"Metamer {info} magnitude means\")\n", " ax.xaxis.set_visible(False)\n", " ax.yaxis.set_visible(False)\n", - "model_mag_means.plot_representation(model_mag_means(met.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[0,1]);\n", - "model_mag_means.plot_representation(model_mag_means(met_mag_means.metamer)-model_mag_means(img), ylim=(-.06, .06), ax=axes[1,1]);" + "model_mag_means.plot_representation(\n", + " model_mag_means(met.metamer) - model_mag_means(img),\n", + " ylim=(-0.06, 0.06),\n", + " ax=axes[0, 1],\n", + ")\n", + "model_mag_means.plot_representation(\n", + " model_mag_means(met_mag_means.metamer) - model_mag_means(img),\n", + " ylim=(-0.06, 0.06),\n", + " ax=axes[1, 1],\n", + ");" ] }, { diff --git a/examples/Synthesis_extensions.ipynb b/examples/Synthesis_extensions.ipynb index d0d1efe1..840b4d76 100644 --- a/examples/Synthesis_extensions.ipynb +++ b/examples/Synthesis_extensions.ipynb @@ -30,7 +30,7 @@ "from typing_extensions import Literal\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams['figure.dpi'] = 72\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", "\n", "%load_ext autoreload\n", "%autoreload 2" @@ -45,30 +45,47 @@ "source": [ "class MADCompetitionVariant(po.synth.MADCompetition):\n", " \"\"\"Initialize MADCompetition with an image instead!\"\"\"\n", - " def __init__(self, image: Tensor,\n", - " optimized_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]],\n", - " reference_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]],\n", - " minmax: Literal['min', 'max'],\n", - " initial_image: Tensor = None,\n", - " metric_tradeoff_lambda: Optional[float] = None,\n", - " range_penalty_lambda: float = .1,\n", - " allowed_range: Tuple[float, float] = (0, 1)):\n", + "\n", + " def __init__(\n", + " self,\n", + " image: Tensor,\n", + " optimized_metric: Union[\n", + " torch.nn.Module, Callable[[Tensor, Tensor], Tensor]\n", + " ],\n", + " reference_metric: Union[\n", + " torch.nn.Module, Callable[[Tensor, Tensor], Tensor]\n", + " ],\n", + " minmax: Literal[\"min\", \"max\"],\n", + " initial_image: Tensor = None,\n", + " metric_tradeoff_lambda: Optional[float] = None,\n", + " range_penalty_lambda: float = 0.1,\n", + " allowed_range: Tuple[float, float] = (0, 1),\n", + " ):\n", " if initial_image is None:\n", " initial_image = torch.rand_like(image)\n", - " super().__init__(image, optimized_metric, reference_metric,\n", - " minmax, initial_image, metric_tradeoff_lambda,\n", - " range_penalty_lambda, allowed_range)\n", + " super().__init__(\n", + " image,\n", + " optimized_metric,\n", + " reference_metric,\n", + " minmax,\n", + " initial_image,\n", + " metric_tradeoff_lambda,\n", + " range_penalty_lambda,\n", + " allowed_range,\n", + " )\n", "\n", " def _initialize(self, initial_image: Tensor):\n", " mad_image = initial_image.clamp(*self.allowed_range)\n", " self._initial_image = mad_image.clone()\n", " mad_image.requires_grad_()\n", " self._mad_image = mad_image\n", - " self._reference_metric_target = self.reference_metric(self.image,\n", - " self.mad_image).item()\n", + " self._reference_metric_target = self.reference_metric(\n", + " self.image, self.mad_image\n", + " ).item()\n", " self._reference_metric_loss.append(self._reference_metric_target)\n", - " self._optimized_metric_loss.append(self.optimized_metric(self.image,\n", - " self.mad_image).item())" + " self._optimized_metric_loss.append(\n", + " self.optimized_metric(self.image, self.mad_image).item()\n", + " )" ] }, { @@ -106,10 +123,12 @@ "image = po.data.einstein()\n", "curie = po.data.curie()\n", "\n", - "new_mad = MADCompetitionVariant(image, po.metric.mse, lambda *args: 1-po.metric.ssim(*args), \n", - " 'min', curie)\n", - "old_mad = po.synth.MADCompetition(image, po.metric.mse, lambda *args: 1-po.metric.ssim(*args), \n", - " 'min', .1)" + "new_mad = MADCompetitionVariant(\n", + " image, po.metric.mse, lambda *args: 1 - po.metric.ssim(*args), \"min\", curie\n", + ")\n", + "old_mad = po.synth.MADCompetition(\n", + " image, po.metric.mse, lambda *args: 1 - po.metric.ssim(*args), \"min\", 0.1\n", + ")" ] }, { @@ -128,7 +147,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -138,8 +157,15 @@ } ], "source": [ - "po.imshow([old_mad.image, old_mad.initial_image, new_mad.image, new_mad.initial_image],\n", - " col_wrap=2);" + "po.imshow(\n", + " [\n", + " old_mad.image,\n", + " old_mad.initial_image,\n", + " new_mad.image,\n", + " new_mad.initial_image,\n", + " ],\n", + " col_wrap=2,\n", + ")" ] }, { @@ -172,7 +198,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -185,9 +211,11 @@ "with warnings.catch_warnings():\n", " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", " # which will happen briefly during synthesis.\n", - " warnings.simplefilter('ignore')\n", + " warnings.simplefilter(\"ignore\")\n", " old_mad.synthesize(store_progress=True)\n", - "po.synth.mad_competition.plot_synthesis_status(old_mad, included_plots=['display_mad_image', 'plot_loss']);" + "po.synth.mad_competition.plot_synthesis_status(\n", + " old_mad, included_plots=[\"display_mad_image\", \"plot_loss\"]\n", + ");" ] }, { @@ -212,7 +240,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -225,9 +253,11 @@ "with warnings.catch_warnings():\n", " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", " # which will happen briefly during synthesis.\n", - " warnings.simplefilter('ignore')\n", + " warnings.simplefilter(\"ignore\")\n", " new_mad.synthesize(store_progress=True)\n", - "po.synth.mad_competition.plot_synthesis_status(new_mad, included_plots=['display_mad_image', 'plot_loss']);" + "po.synth.mad_competition.plot_synthesis_status(\n", + " new_mad, included_plots=[\"display_mad_image\", \"plot_loss\"]\n", + ");" ] }, { @@ -246,7 +276,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/pyproject.toml b/pyproject.toml index c76036fd..5b543255 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -127,7 +127,8 @@ line-length = 79 select = [ # pycodestyle "E", - # Pyflakes + # Pyflakes: basic static analzsis for common errors like undefined names + # and missing imports. "F", # pyupgrade #"UP", From 47acd9976a40f54453e8e60063fa7efb3fd4cca6 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 8 Aug 2024 17:42:40 -0400 Subject: [PATCH 036/134] all files in metric refactored to meet pydocstyle and pyflakes criteria --- src/plenoptic/metric/classes.py | 8 +- src/plenoptic/metric/model_metric.py | 1 - src/plenoptic/metric/perceptual_distance.py | 158 +++++++++++++------- 3 files changed, 112 insertions(+), 55 deletions(-) diff --git a/src/plenoptic/metric/classes.py b/src/plenoptic/metric/classes.py index 6bc83860..39bbe38d 100644 --- a/src/plenoptic/metric/classes.py +++ b/src/plenoptic/metric/classes.py @@ -15,6 +15,7 @@ class NLP(torch.nn.Module): ``torch.sqrt(torch.mean(x-y)**2))`` as the distance metric between representations. """ + def __init__(self): super().__init__() @@ -36,10 +37,13 @@ def forward(self, image): """ if image.shape[0] > 1 or image.shape[1] > 1: - raise Exception("For now, this only supports batch and channel size 1") + raise Exception( + "For now, this only supports batch and channel size 1" + ) activations = normalized_laplacian_pyramid(image) # activations is a list of tensors, each at a different scale # (down-sampled by factors of 2). To combine these into one # vector, we need to flatten each of them and then unsqueeze so # it is 3d - return torch.cat([i.flatten() for i in activations]).unsqueeze(0).unsqueeze(0) + + return torch.cat([i.flatten() for i in activations])[None, None, :] diff --git a/src/plenoptic/metric/model_metric.py b/src/plenoptic/metric/model_metric.py index f501b8f1..ec73dc7f 100644 --- a/src/plenoptic/metric/model_metric.py +++ b/src/plenoptic/metric/model_metric.py @@ -2,7 +2,6 @@ def model_metric(x, y, model): - """ Calculate distance between x and y in model space root mean squared error diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index f70fd003..2ee8999e 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -37,25 +37,39 @@ def _ssim_parts(img1, img2, pad=False): these work. """ - img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) + img_ranges = torch.as_tensor( + [[img1.min(), img1.max()], [img2.min(), img2.max()]] + ) if (img_ranges > 1).any() or (img_ranges < 0).any(): - warnings.warn("Image range falls outside [0, 1]." - f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " - "Continuing anyway...") + warnings.warn( + "Image range falls outside [0, 1]." + f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " + "Continuing anyway..." + ) if not img1.ndim == img2.ndim == 4: - raise Exception("Input images should have four dimensions: (batch, channel, height, width)") + raise Exception( + "Input images should have four dimensions: (batch, channel, height, width)" + ) if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: - raise Exception("Either img1 and img2 should have the same number of " - "elements in each dimension, or one of " - "them should be 1! But got shapes " - f"{img1.shape}, {img2.shape} instead") + if ( + img1.shape[i] != img2.shape[i] + and img1.shape[i] != 1 + and img2.shape[i] != 1 + ): + raise Exception( + "Either img1 and img2 should have the same number of " + "elements in each dimension, or one of " + "them should be 1! But got shapes " + f"{img1.shape}, {img2.shape} instead" + ) if img1.shape[1] > 1 or img2.shape[1] > 1: - warnings.warn("SSIM was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches).") + warnings.warn( + "SSIM was designed for grayscale images and here it will be computed separately for each " + "channel (so channels are treated in the same way as batches)." + ) if img1.dtype != img2.dtype: raise ValueError("Input images must have same dtype!") @@ -79,9 +93,13 @@ def _ssim_parts(img1, img2, pad=False): def windowed_average(img): padd = 0 (n_batches, n_channels, _, _) = img.shape - img = img.reshape(n_batches * n_channels, 1, img.shape[2], img.shape[3]) + img = img.reshape( + n_batches * n_channels, 1, img.shape[2], img.shape[3] + ) img_average = F.conv2d(img, window, padding=padd) - img_average = img_average.reshape(n_batches, n_channels, img_average.shape[2], img_average.shape[3]) + img_average = img_average.reshape( + n_batches, n_channels, img_average.shape[2], img_average.shape[3] + ) return img_average mu1 = windowed_average(img1) @@ -95,18 +113,20 @@ def windowed_average(img): sigma2_sq = windowed_average(img2 * img2) - mu2_sq sigma12 = windowed_average(img1 * img2) - mu1_mu2 - C1 = 0.01 ** 2 - C2 = 0.03 ** 2 + C1 = 0.01**2 + C2 = 0.03**2 # SSIM is the product of a luminance component, a contrast component, and a # structure component. The contrast-structure component has to be separated # when computing MS-SSIM. luminance_map = (2 * mu1_mu2 + C1) / (mu1_sq + mu2_sq + C1) - contrast_structure_map = (2.0 * sigma12 + C2) / (sigma1_sq + sigma2_sq + C2) + contrast_structure_map = (2.0 * sigma12 + C2) / ( + sigma1_sq + sigma2_sq + C2 + ) map_ssim = luminance_map * contrast_structure_map # the weight used for stability - weight = torch.log((1 + sigma1_sq/C2) * (1 + sigma2_sq/C2)) + weight = torch.log((1 + sigma1_sq / C2) * (1 + sigma2_sq / C2)) return map_ssim, contrast_structure_map, weight @@ -190,12 +210,14 @@ def ssim(img1, img2, weighted=False, pad=False): if not weighted: mssim = map_ssim.mean((-1, -2)) else: - mssim = (map_ssim*weight).sum((-1, -2)) / weight.sum((-1, -2)) + mssim = (map_ssim * weight).sum((-1, -2)) / weight.sum((-1, -2)) if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn("SSIM uses 11x11 convolutional kernel, but the height and/or " - "the width of the input image is smaller than 11, so the " - "kernel size is set to be the minimum of these two numbers.") + warnings.warn( + "SSIM uses 11x11 convolutional kernel, but the height and/or " + "the width of the input image is smaller than 11, so the " + "kernel size is set to be the minimum of these two numbers." + ) return mssim @@ -257,9 +279,11 @@ def ssim_map(img1, img2): """ if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn("SSIM uses 11x11 convolutional kernel, but the height and/or " - "the width of the input image is smaller than 11, so the " - "kernel size is set to be the minimum of these two numbers.") + warnings.warn( + "SSIM uses 11x11 convolutional kernel, but the height and/or " + "the width of the input image is smaller than 11, so the " + "kernel size is set to be the minimum of these two numbers." + ) return _ssim_parts(img1, img2)[0] @@ -326,24 +350,30 @@ def ms_ssim(img1, img2, power_factors=None): power_factors = [0.0448, 0.2856, 0.3001, 0.2363, 0.1333] def downsample(img): - img = F.pad(img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate") + img = F.pad( + img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate" + ) img = F.avg_pool2d(img, kernel_size=2) return img msssim = 1 for i in range(len(power_factors) - 1): _, contrast_structure_map, _ = _ssim_parts(img1, img2) - msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow(power_factors[i]) + msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow( + power_factors[i] + ) img1 = downsample(img1) img2 = downsample(img2) map_ssim, _, _ = _ssim_parts(img1, img2) msssim *= F.relu(map_ssim.mean((-1, -2))).pow(power_factors[-1]) if min(img1.shape[2], img1.shape[3]) < 11: - warnings.warn("SSIM uses 11x11 convolutional kernel, but for some scales " - "of the input image, the height and/or the width is smaller " - "than 11, so the kernel size in SSIM is set to be the " - "minimum of these two numbers for these scales.") + warnings.warn( + "SSIM uses 11x11 convolutional kernel, but for some scales " + "of the input image, the height and/or the width is smaller " + "than 11, so the kernel size in SSIM is set to be the " + "minimum of these two numbers for these scales." + ) return msssim @@ -366,8 +396,8 @@ def normalized_laplacian_pyramid(img): (_, channel, height, width) = img.size() N_scales = 6 - spatialpooling_filters = np.load(os.path.join(DIRNAME, 'DN_filts.npy')) - sigmas = np.load(os.path.join(DIRNAME, 'DN_sigmas.npy')) + spatialpooling_filters = np.load(os.path.join(DIRNAME, "DN_filts.npy")) + sigmas = np.load(os.path.join(DIRNAME, "DN_sigmas.npy")) L = LaplacianPyramid(n_scales=N_scales, scale_filter=True) laplacian_activations = L.forward(img) @@ -375,10 +405,18 @@ def normalized_laplacian_pyramid(img): padd = 2 normalized_laplacian_activations = [] for N_b in range(0, N_scales): - filt = torch.as_tensor(spatialpooling_filters[N_b], dtype=torch.float32, - device=img.device).repeat(channel, 1, 1, 1) - filtered_activations = F.conv2d(torch.abs(laplacian_activations[N_b]), filt, padding=padd, groups=channel) - normalized_laplacian_activations.append(laplacian_activations[N_b] / (sigmas[N_b] + filtered_activations)) + filt = torch.as_tensor( + spatialpooling_filters[N_b], dtype=torch.float32, device=img.device + ).repeat(channel, 1, 1, 1) + filtered_activations = F.conv2d( + torch.abs(laplacian_activations[N_b]), + filt, + padding=padd, + groups=channel, + ) + normalized_laplacian_activations.append( + laplacian_activations[N_b] / (sigmas[N_b] + filtered_activations) + ) return normalized_laplacian_activations @@ -425,31 +463,47 @@ def nlpd(img1, img2): """ if not img1.ndim == img2.ndim == 4: - raise Exception("Input images should have four dimensions: (batch, channel, height, width)") + raise Exception( + "Input images should have four dimensions: (batch, channel, height, width)" + ) if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: - raise Exception("Either img1 and img2 should have the same number of " - "elements in each dimension, or one of " - "them should be 1! But got shapes " - f"{img1.shape}, {img2.shape} instead") + if ( + img1.shape[i] != img2.shape[i] + and img1.shape[i] != 1 + and img2.shape[i] != 1 + ): + raise Exception( + "Either img1 and img2 should have the same number of " + "elements in each dimension, or one of " + "them should be 1! But got shapes " + f"{img1.shape}, {img2.shape} instead" + ) if img1.shape[1] > 1 or img2.shape[1] > 1: - warnings.warn("NLPD was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches).") - - img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) + warnings.warn( + "NLPD was designed for grayscale images and here it will be computed separately for each " + "channel (so channels are treated in the same way as batches)." + ) + + img_ranges = torch.as_tensor( + [[img1.min(), img1.max()], [img2.min(), img2.max()]] + ) if (img_ranges > 1).any() or (img_ranges < 0).any(): - warnings.warn("Image range falls outside [0, 1]." - f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " - "Continuing anyway...") - + warnings.warn( + "Image range falls outside [0, 1]." + f" img1: {img_ranges[0]}, img2: {img_ranges[1]}. " + "Continuing anyway..." + ) + y1 = normalized_laplacian_pyramid(img1) y2 = normalized_laplacian_pyramid(img2) epsilon = 1e-10 # for optimization purpose (stabilizing the gradient around zero) dist = [] for i in range(6): - dist.append(torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon)) + dist.append( + torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon) + ) return torch.stack(dist).mean(dim=0) From 618ef87abc063f59ef92a59fb68e94e208fd56fb Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 8 Aug 2024 17:44:50 -0400 Subject: [PATCH 037/134] all files in simulate and models refactored to meet pydocstyle and pyflakes criteria --- .../canonical_computations/filters.py | 22 ++- .../laplacian_pyramid.py | 2 +- .../canonical_computations/non_linearities.py | 26 +-- .../steerable_pyramid_freq.py | 169 ++++++++++++------ src/plenoptic/simulate/models/frontend.py | 92 ++++++---- src/plenoptic/simulate/models/naive.py | 63 +++++-- .../simulate/models/portilla_simoncelli.py | 120 +++++++++---- 7 files changed, 333 insertions(+), 161 deletions(-) diff --git a/src/plenoptic/simulate/canonical_computations/filters.py b/src/plenoptic/simulate/canonical_computations/filters.py index 098d7a79..ab3770c3 100644 --- a/src/plenoptic/simulate/canonical_computations/filters.py +++ b/src/plenoptic/simulate/canonical_computations/filters.py @@ -7,7 +7,9 @@ __all__ = ["gaussian1d", "circular_gaussian2d"] -def gaussian1d(kernel_size: int = 11, std: Union[float, Tensor] = 1.5) -> Tensor: +def gaussian1d( + kernel_size: int = 11, std: Union[float, Tensor] = 1.5 +) -> Tensor: """Normalized 1D Gaussian. 1d Gaussian of size `kernel_size`, centered half-way, with variable std @@ -35,7 +37,7 @@ def gaussian1d(kernel_size: int = 11, std: Union[float, Tensor] = 1.5) -> Tensor x = torch.arange(kernel_size).to(device) mu = kernel_size // 2 - gauss = torch.exp(-((x - mu) ** 2) / (2 * std ** 2)) + gauss = torch.exp(-((x - mu) ** 2) / (2 * std**2)) filt = gauss / gauss.sum() # normalize return filt @@ -75,17 +77,23 @@ def circular_gaussian2d( assert out_channels >= 1, "number of filters must be positive integer" assert torch.all(std > 0.0), "stdev must be positive" assert len(std) == out_channels, "Number of stds must equal out_channels" - origin = torch.as_tensor(((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0)) + origin = torch.as_tensor( + ((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0) + ) origin = origin.to(device) - shift_y = torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] # height - shift_x = torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] # width + shift_y = ( + torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] + ) # height + shift_x = ( + torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] + ) # width (xramp, yramp) = torch.meshgrid(shift_y, shift_x) - log_filt = ((xramp ** 2) + (yramp ** 2)) + log_filt = (xramp**2) + (yramp**2) log_filt = log_filt.repeat(out_channels, 1, 1, 1) # 4D - log_filt = log_filt / (-2. * std ** 2).view(out_channels, 1, 1, 1) + log_filt = log_filt / (-2.0 * std**2).view(out_channels, 1, 1, 1) filt = torch.exp(log_filt) filt = filt / torch.sum(filt, dim=[1, 2, 3], keepdim=True) # normalize diff --git a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py index d51e3955..ac7b03b3 100644 --- a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py +++ b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py @@ -5,7 +5,7 @@ class LaplacianPyramid(nn.Module): """Laplacian Pyramid in Torch. - + The Laplacian pyramid [1]_ is a multiscale image representation. It decomposes the image by computing the local mean using Gaussian blurring filters and substracting it from the image and repeating this operation on diff --git a/src/plenoptic/simulate/canonical_computations/non_linearities.py b/src/plenoptic/simulate/canonical_computations/non_linearities.py index fec6a59c..279216f9 100644 --- a/src/plenoptic/simulate/canonical_computations/non_linearities.py +++ b/src/plenoptic/simulate/canonical_computations/non_linearities.py @@ -28,12 +28,12 @@ def rectangular_to_polar_dict(coeff_dict, residuals=False): state = {} for key in coeff_dict.keys(): # ignore residuals - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): energy[key], state[key] = rectangular_to_polar(coeff_dict[key]) if residuals: - energy['residual_lowpass'] = coeff_dict['residual_lowpass'] - energy['residual_highpass'] = coeff_dict['residual_highpass'] + energy["residual_lowpass"] = coeff_dict["residual_lowpass"] + energy["residual_highpass"] = coeff_dict["residual_highpass"] return energy, state @@ -63,12 +63,12 @@ def polar_to_rectangular_dict(energy, state, residuals=True): for key in energy.keys(): # ignore residuals - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): coeff_dict[key] = polar_to_rectangular(energy[key], state[key]) if residuals: - coeff_dict['residual_lowpass'] = energy['residual_lowpass'] - coeff_dict['residual_highpass'] = energy['residual_highpass'] + coeff_dict["residual_lowpass"] = energy["residual_lowpass"] + coeff_dict["residual_highpass"] = energy["residual_highpass"] return coeff_dict @@ -111,7 +111,7 @@ def local_gain_control(x, epsilon=1e-8): # these could be parameters, but no use case so far p = 2.0 - norm = blur_downsample(torch.abs(x ** p)).pow(1 / p) + norm = blur_downsample(torch.abs(x**p)).pow(1 / p) odd = torch.as_tensor(x.shape)[2:4] % 2 direction = x / (upsample_blur(norm, odd) + epsilon) @@ -190,12 +190,12 @@ def local_gain_control_dict(coeff_dict, residuals=True): state = {} for key in coeff_dict.keys(): - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): energy[key], state[key] = local_gain_control(coeff_dict[key]) if residuals: - energy['residual_lowpass'] = coeff_dict['residual_lowpass'] - energy['residual_highpass'] = coeff_dict['residual_highpass'] + energy["residual_lowpass"] = coeff_dict["residual_lowpass"] + energy["residual_highpass"] = coeff_dict["residual_highpass"] return energy, state @@ -230,11 +230,11 @@ def local_gain_release_dict(energy, state, residuals=True): coeff_dict = {} for key in energy.keys(): - if isinstance(key, tuple) or not key.startswith('residual'): + if isinstance(key, tuple) or not key.startswith("residual"): coeff_dict[key] = local_gain_release(energy[key], state[key]) if residuals: - coeff_dict['residual_lowpass'] = energy['residual_lowpass'] - coeff_dict['residual_highpass'] = energy['residual_highpass'] + coeff_dict["residual_lowpass"] = energy["residual_lowpass"] + coeff_dict["residual_highpass"] = energy["residual_highpass"] return coeff_dict diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 5a6cf090..eaae6dba 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -3,6 +3,7 @@ Construct a steerable pyramid on matrix two dimensional signals, in the Fourier domain. """ + import warnings from collections import OrderedDict from typing import List, Optional, Tuple, Union @@ -21,7 +22,9 @@ complex_types = [torch.cdouble, torch.cfloat] SCALES_TYPE = Union[int, Literal["residual_lowpass", "residual_highpass"]] -KEYS_TYPE = Union[Tuple[int, int], Literal["residual_lowpass", "residual_highpass"]] +KEYS_TYPE = Union[ + Tuple[int, int], Literal["residual_lowpass", "residual_highpass"] +] class SteerablePyramidFreq(nn.Module): @@ -103,7 +106,6 @@ def __init__( downsample: bool = True, tight_frame: bool = False, ): - super().__init__() self.pyr_size = OrderedDict() @@ -111,7 +113,9 @@ def __init__( self.image_shape = image_shape if (self.image_shape[0] % 2 != 0) or (self.image_shape[1] % 2 != 0): - warnings.warn("Reconstruction will not be perfect with odd-sized images") + warnings.warn( + "Reconstruction will not be perfect with odd-sized images" + ) self.is_complex = is_complex self.downsample = downsample @@ -129,11 +133,16 @@ def __init__( ) self.alpha = (self.Xcosn + np.pi) % (2 * np.pi) - np.pi - max_ht = np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) - 2 + max_ht = ( + np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) + - 2 + ) if height == "auto": self.num_scales = int(max_ht) elif height > max_ht: - raise ValueError("Cannot build pyramid higher than %d levels." % (max_ht)) + raise ValueError( + "Cannot build pyramid higher than %d levels." % (max_ht) + ) else: self.num_scales = int(height) @@ -151,7 +160,8 @@ def __init__( ctr = np.ceil((np.array(dims) + 0.5) / 2).astype(int) (xramp, yramp) = np.meshgrid( - np.linspace(-1, 1, dims[1] + 1)[:-1], np.linspace(-1, 1, dims[0] + 1)[:-1] + np.linspace(-1, 1, dims[1] + 1)[:-1], + np.linspace(-1, 1, dims[0] + 1)[:-1], ) self.angle = np.arctan2(yramp, xramp) @@ -160,7 +170,9 @@ def __init__( self.log_rad = np.log2(log_rad) # radial transition function (a raised cosine in log-frequency): - self.Xrcos, Yrcos = raised_cosine(twidth, (-twidth / 2.0), np.array([0, 1])) + self.Xrcos, Yrcos = raised_cosine( + twidth, (-twidth / 2.0), np.array([0, 1]) + ) self.Yrcos = np.sqrt(Yrcos) self.YIrcos = np.sqrt(1.0 - self.Yrcos**2) @@ -168,9 +180,8 @@ def __init__( # create low and high masks lo0mask = interpolate1d(self.log_rad, self.YIrcos, self.Xrcos) hi0mask = interpolate1d(self.log_rad, self.Yrcos, self.Xrcos) - self.register_buffer('lo0mask', torch.as_tensor(lo0mask).unsqueeze(0)) - self.register_buffer('hi0mask', torch.as_tensor(hi0mask).unsqueeze(0)) - + self.register_buffer("lo0mask", torch.as_tensor(lo0mask).unsqueeze(0)) + self.register_buffer("hi0mask", torch.as_tensor(hi0mask).unsqueeze(0)) # need a mock image to down-sample so that we correctly # construct the differently-sized masks @@ -199,7 +210,10 @@ def __init__( const = ( (2 ** (2 * self.order)) * (factorial(self.order, exact=True) ** 2) - / float(self.num_orientations * factorial(2 * self.order, exact=True)) + / float( + self.num_orientations + * factorial(2 * self.order, exact=True) + ) ) if self.is_complex: @@ -209,32 +223,50 @@ def __init__( * (np.cos(self.Xcosn) ** self.order) * (np.abs(self.alpha) < np.pi / 2.0).astype(int) ) - Ycosn_recon = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + Ycosn_recon = ( + np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + ) else: - Ycosn_forward = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + Ycosn_forward = ( + np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order + ) Ycosn_recon = Ycosn_forward himask = interpolate1d(log_rad, self.Yrcos, Xrcos) - self.register_buffer(f'_himasks_scale_{i}', torch.as_tensor(himask).unsqueeze(0)) + self.register_buffer( + f"_himasks_scale_{i}", torch.as_tensor(himask).unsqueeze(0) + ) anglemasks = [] anglemasks_recon = [] for b in range(self.num_orientations): anglemask = interpolate1d( - angle, Ycosn_forward, self.Xcosn + np.pi * b / self.num_orientations + angle, + Ycosn_forward, + self.Xcosn + np.pi * b / self.num_orientations, ) anglemask_recon = interpolate1d( - angle, Ycosn_recon, self.Xcosn + np.pi * b / self.num_orientations + angle, + Ycosn_recon, + self.Xcosn + np.pi * b / self.num_orientations, ) anglemasks.append(torch.as_tensor(anglemask).unsqueeze(0)) - anglemasks_recon.append(torch.as_tensor(anglemask_recon).unsqueeze(0)) + anglemasks_recon.append( + torch.as_tensor(anglemask_recon).unsqueeze(0) + ) - self.register_buffer(f'_anglemasks_scale_{i}', torch.cat(anglemasks)) - self.register_buffer(f'_anglemasks_recon_scale_{i}', torch.cat(anglemasks_recon)) + self.register_buffer( + f"_anglemasks_scale_{i}", torch.cat(anglemasks) + ) + self.register_buffer( + f"_anglemasks_recon_scale_{i}", torch.cat(anglemasks_recon) + ) if not self.downsample: lomask = interpolate1d(log_rad, self.YIrcos, Xrcos) - self.register_buffer(f'_lomasks_scale_{i}', torch.as_tensor(lomask).unsqueeze(0)) + self.register_buffer( + f"_lomasks_scale_{i}", torch.as_tensor(lomask).unsqueeze(0) + ) self._loindices.append([np.array([0, 0]), dims]) lodft = lodft * lomask @@ -253,7 +285,9 @@ def __init__( angle = angle[lostart[0] : loend[0], lostart[1] : loend[1]] lomask = interpolate1d(log_rad, self.YIrcos, Xrcos) - self.register_buffer(f'_lomasks_scale_{i}', torch.as_tensor(lomask).unsqueeze(0)) + self.register_buffer( + f"_lomasks_scale_{i}", torch.as_tensor(lomask).unsqueeze(0) + ) # subsampling lodft = lodft[lostart[0] : loend[0], lostart[1] : loend[1]] # convolution in spatial domain @@ -305,7 +339,9 @@ def forward( # x is a torch tensor batch of images of size (batch, channel, height, # width) - assert len(x.shape) == 4, "Input must be batch of images of shape BxCxHxW" + assert ( + len(x.shape) == 4 + ), "Input must be batch of images of shape BxCxHxW" imdft = fft.fft2(x, dim=(-2, -1), norm=self.fft_norm) imdft = fft.fftshift(imdft) @@ -322,20 +358,18 @@ def forward( lodft = imdft * lo0mask for i in range(self.num_scales): - if i in scales: # high-pass mask is selected based on the current scale - himask = getattr(self, f'_himasks_scale_{i}') + himask = getattr(self, f"_himasks_scale_{i}") # compute filter output at each orientation for b in range(self.num_orientations): - # band pass filtering is done in the fourier space as multiplying by the fft of a gaussian derivative. # The oriented dft is computed as a product of the fft of the low-passed component, # the precomputed anglemask (specifies orientation), and the precomputed hipass mask (creating a bandpass filter) # the complex_const variable comes from the Fourier transform of a gaussian derivative. # Based on the order of the gaussian, this constant changes. - anglemask = getattr(self, f'_anglemasks_scale_{i}')[b] + anglemask = getattr(self, f"_anglemasks_scale_{i}")[b] complex_const = np.power(complex(0, -1), self.order) banddft = complex_const * lodft * anglemask * himask @@ -348,7 +382,6 @@ def forward( if not self.is_complex: pyr_coeffs[(i, b)] = band.real else: - # Because the input signal is real, to maintain a tight frame # if the complex pyramid is used, magnitudes need to be divided by sqrt(2) # because energy is doubled. @@ -361,7 +394,7 @@ def forward( if not self.downsample: # no subsampling of angle and rad # just use lo0mask - lomask = getattr(self, f'_lomasks_scale_{i}') + lomask = getattr(self, f"_lomasks_scale_{i}") lodft = lodft * lomask # because we don't subsample here, if we are not using orthonormalization that @@ -378,9 +411,11 @@ def forward( angle = angle[lostart[0] : loend[0], lostart[1] : loend[1]] # subsampling of the dft for next scale - lodft = lodft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] + lodft = lodft[ + :, :, lostart[0] : loend[0], lostart[1] : loend[1] + ] # low-pass filter mask is selected - lomask = getattr(self, f'_lomasks_scale_{i}') + lomask = getattr(self, f"_lomasks_scale_{i}") # again multiply dft by subsampled mask (convolution in spatial domain) lodft = lodft * lomask @@ -538,7 +573,8 @@ def convert_tensor_to_pyr( if split_complex: band = torch.view_as_complex( rearrange( - pyr_tensor[:, i : i + 2, ...], "b c h w -> b h w c" + pyr_tensor[:, i : i + 2, ...], + "b c h w -> b h w c", ) .unsqueeze(1) .contiguous() @@ -581,7 +617,9 @@ def _recon_levels_check( """ if isinstance(levels, str): if levels != "all": - raise TypeError(f"levels must be a list of levels or the string 'all' but got {levels}") + raise TypeError( + f"levels must be a list of levels or the string 'all' but got {levels}" + ) levels = ( ["residual_highpass"] + list(range(self.num_scales)) @@ -589,15 +627,18 @@ def _recon_levels_check( ) else: if not hasattr(levels, "__iter__"): - raise TypeError(f"levels must be a list of levels or the string 'all' but got {levels}") + raise TypeError( + f"levels must be a list of levels or the string 'all' but got {levels}" + ) levs_nums = np.array( [int(i) for i in levels if isinstance(i, int)] ) - assert (levs_nums >= 0).all(), "Level numbers must be non-negative." assert ( - levs_nums < self.num_scales - ).all(), "Level numbers must be in the range [0, %d]" % ( - self.num_scales - 1 + levs_nums >= 0 + ).all(), "Level numbers must be non-negative." + assert (levs_nums < self.num_scales).all(), ( + "Level numbers must be in the range [0, %d]" + % (self.num_scales - 1) ) levs_tmp = list(np.sort(levs_nums)) # we want smallest first if "residual_highpass" in levels: @@ -644,17 +685,22 @@ def _recon_bands_check( """ if isinstance(bands, str): if bands != "all": - raise TypeError(f"bands must be a list of ints or the string 'all' but got {bands}") + raise TypeError( + f"bands must be a list of ints or the string 'all' but got {bands}" + ) bands = np.arange(self.num_orientations) else: if not hasattr(bands, "__iter__"): - raise TypeError(f"bands must be a list of ints or the string 'all' but got {bands}") + raise TypeError( + f"bands must be a list of ints or the string 'all' but got {bands}" + ) bands: NDArray = np.array(bands, ndmin=1) - assert (bands >= 0).all(), "Error: band numbers must be larger than 0." assert ( - bands < self.num_orientations - ).all(), "Error: band numbers must be in the range [0, %d]" % ( - self.num_orientations - 1 + bands >= 0 + ).all(), "Error: band numbers must be larger than 0." + assert (bands < self.num_orientations).all(), ( + "Error: band numbers must be in the range [0, %d]" + % (self.num_orientations - 1) ) return list(bands) @@ -788,7 +834,9 @@ def recon_pyr( # generate highpass residual Reconstruction if "residual_highpass" in recon_keys: hidft = fft.fft2( - pyr_coeffs["residual_highpass"], dim=(-2, -1), norm=self.fft_norm + pyr_coeffs["residual_highpass"], + dim=(-2, -1), + norm=self.fft_norm, ) hidft = fft.fftshift(hidft) @@ -801,7 +849,9 @@ def recon_pyr( # get output reconstruction by inverting the fft reconstruction = fft.ifftshift(outdft) - reconstruction = fft.ifft2(reconstruction, dim=(-2, -1), norm=self.fft_norm) + reconstruction = fft.ifft2( + reconstruction, dim=(-2, -1), norm=self.fft_norm + ) # get real part of reconstruction (if complex) reconstruction = reconstruction.real @@ -838,14 +888,14 @@ def _recon_levels( if scale == self.num_scales: if "residual_lowpass" in recon_keys: lodft = fft.fft2( - pyr_coeffs["residual_lowpass"], dim=(-2, -1), norm=self.fft_norm + pyr_coeffs["residual_lowpass"], + dim=(-2, -1), + norm=self.fft_norm, ) lodft = fft.fftshift(lodft) else: lodft = fft.fft2( - torch.zeros_like( - pyr_coeffs["residual_lowpass"] - ), + torch.zeros_like(pyr_coeffs["residual_lowpass"]), dim=(-2, -1), norm=self.fft_norm, ) @@ -854,12 +904,14 @@ def _recon_levels( # Reconstruct from orientation bands # update himask - himask = getattr(self, f'_himasks_scale_{scale}') + himask = getattr(self, f"_himasks_scale_{scale}") orientdft = torch.zeros_like(pyr_coeffs[(scale, 0)]) for b in range(self.num_orientations): if (scale, b) in recon_keys: - anglemask = getattr(self, f'_anglemasks_recon_scale_{scale}')[b] + anglemask = getattr(self, f"_anglemasks_recon_scale_{scale}")[ + b + ] coeffs = pyr_coeffs[(scale, b)] if self.tight_frame and self.is_complex: coeffs = coeffs * np.sqrt(2) @@ -875,7 +927,7 @@ def _recon_levels( lostart, loend = self._loindices[scale] # create lowpass mask - lomask = getattr(self, f'_lomasks_scale_{scale}') + lomask = getattr(self, f"_lomasks_scale_{scale}") # Recursively reconstruct by going to the next scale reslevdft = self._recon_levels(pyr_coeffs, recon_keys, scale + 1) @@ -883,16 +935,23 @@ def _recon_levels( if (not self.tight_frame) and (not self.downsample): reslevdft = reslevdft / 2 # create output for reconstruction result - resdft = torch.zeros_like(pyr_coeffs[(scale, 0)], dtype=torch.complex64) + resdft = torch.zeros_like( + pyr_coeffs[(scale, 0)], dtype=torch.complex64 + ) # place upsample and convolve lowpass component - resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = reslevdft * lomask + resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = ( + reslevdft * lomask + ) recondft = resdft + orientdft # add orientation interpolated and added images to the lowpass image return recondft def steer_coeffs( - self, pyr_coeffs: OrderedDict, angles: List[float], even_phase: bool = True + self, + pyr_coeffs: OrderedDict, + angles: List[float], + even_phase: bool = True, ) -> Tuple[dict, dict]: """Steer pyramid coefficients to the specified angles diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 7d1050dc..1af42c8a 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -24,8 +24,12 @@ from warnings import warn -__all__ = ["LinearNonlinear", "LuminanceGainControl", - "LuminanceContrastGainControl", "OnOff"] +__all__ = [ + "LinearNonlinear", + "LuminanceGainControl", + "LuminanceContrastGainControl", + "OnOff", +] class LinearNonlinear(nn.Module): @@ -71,7 +75,6 @@ def __init__( width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", - activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -112,7 +115,7 @@ def display_filters(self, zoom=5.0, **kwargs): class LuminanceGainControl(nn.Module): - """ Linear center-surround followed by luminance gain control and activation. + """Linear center-surround followed by luminance gain control and activation. Model is described in [1]_ and [2]_. Parameters @@ -150,6 +153,7 @@ class LuminanceGainControl(nn.Module): representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ + def __init__( self, kernel_size: Union[int, Tuple[int, int]], @@ -157,7 +161,6 @@ def __init__( width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", - activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -201,17 +204,25 @@ def display_filters(self, zoom=5.0, **kwargs): dim=0, ).detach() - title = ["linear filt", "luminance filt",] + title = [ + "linear filt", + "luminance filt", + ] fig = imshow( - weights, title=title, col_wrap=2, zoom=zoom, vrange="indep0", **kwargs + weights, + title=title, + col_wrap=2, + zoom=zoom, + vrange="indep0", + **kwargs, ) return fig class LuminanceContrastGainControl(nn.Module): - """ Linear center-surround followed by luminance and contrast gain control, + """Linear center-surround followed by luminance and contrast gain control, and activation function. Model is described in [1]_ and [2]_. Parameters @@ -260,7 +271,6 @@ def __init__( width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", - activation: Callable[[Tensor], Tensor] = F.softplus, ): super().__init__() @@ -285,7 +295,9 @@ def forward(self, x: Tensor) -> Tensor: lum = self.luminance(x) lum_normed = linear / (1 + self.luminance_scalar * lum) - con = self.contrast(lum_normed.pow(2)).sqrt() + 1E-6 # avoid div by zero + con = ( + self.contrast(lum_normed.pow(2)).sqrt() + 1e-6 + ) # avoid div by zero con_normed = lum_normed / (1 + self.contrast_scalar * con) y = self.activation(con_normed) return y @@ -316,7 +328,12 @@ def display_filters(self, zoom=5.0, **kwargs): title = ["linear filt", "luminance filt", "contrast filt"] fig = imshow( - weights, title=title, col_wrap=3, zoom=zoom, vrange="indep0", **kwargs + weights, + title=title, + col_wrap=3, + zoom=zoom, + vrange="indep0", + **kwargs, ) return fig @@ -377,16 +394,20 @@ def __init__( activation: Callable[[Tensor], Tensor] = F.softplus, apply_mask: bool = False, cache_filt: bool = False, - ): super().__init__() if isinstance(kernel_size, int): kernel_size = (kernel_size, kernel_size) if pretrained: - assert kernel_size == (31, 31), "pretrained model has kernel_size (31, 31)" + assert kernel_size == ( + 31, + 31, + ), "pretrained model has kernel_size (31, 31)" if cache_filt is False: - warn("pretrained is True but cache_filt is False. Set cache_filt to " - "True for efficiency unless you are fine-tuning.") + warn( + "pretrained is True but cache_filt is False. Set cache_filt to " + "True for efficiency unless you are fine-tuning." + ) self.center_surround = CenterSurround( kernel_size=kernel_size, @@ -399,17 +420,17 @@ def __init__( ) self.luminance = Gaussian( - kernel_size=kernel_size, - out_channels=2, - pad_mode=pad_mode, - cache_filt=cache_filt, + kernel_size=kernel_size, + out_channels=2, + pad_mode=pad_mode, + cache_filt=cache_filt, ) self.contrast = Gaussian( - kernel_size=kernel_size, - out_channels=2, - pad_mode=pad_mode, - cache_filt=cache_filt, + kernel_size=kernel_size, + out_channels=2, + pad_mode=pad_mode, + cache_filt=cache_filt, ) # init scalar values around fitted parameters found in Berardino et al 2017 @@ -426,15 +447,23 @@ def __init__( def forward(self, x: Tensor) -> Tensor: linear = self.center_surround(x) lum = self.luminance(x) - lum_normed = linear / (1 + self.luminance_scalar.view(1, 2, 1, 1) * lum) + lum_normed = linear / ( + 1 + self.luminance_scalar.view(1, 2, 1, 1) * lum + ) - con = self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1E-6 # avoid div by 0 - con_normed = lum_normed / (1 + self.contrast_scalar.view(1, 2, 1, 1) * con) + con = ( + self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1e-6 + ) # avoid div by 0 + con_normed = lum_normed / ( + 1 + self.contrast_scalar.view(1, 2, 1, 1) * con + ) y = self.activation(con_normed) if self.apply_mask: im_shape = x.shape[-2:] - if self._disk is None or self._disk.shape != im_shape: # cache new mask + if ( + self._disk is None or self._disk.shape != im_shape + ): # cache new mask self._disk = make_disk(im_shape).to(x.device) if self._disk.device != x.device: self._disk = self._disk.to(x.device) @@ -443,7 +472,6 @@ def forward(self, x: Tensor) -> Tensor: return y - def display_filters(self, zoom=5.0, **kwargs): """Displays convolutional filters of model @@ -477,7 +505,12 @@ def display_filters(self, zoom=5.0, **kwargs): ] fig = imshow( - weights, title=title, col_wrap=2, zoom=zoom, vrange="indep0", **kwargs + weights, + title=title, + col_wrap=2, + zoom=zoom, + vrange="indep0", + **kwargs, ) return fig @@ -494,7 +527,6 @@ def _pretrained_state_dict() -> OrderedDict: ("center_surround.amplitude_ratio", torch.as_tensor([1.25])), ("luminance.std", torch.as_tensor([8.7366, 1.4751])), ("contrast.std", torch.as_tensor([2.7353, 1.5583])), - ] ) return state_dict diff --git a/src/plenoptic/simulate/models/naive.py b/src/plenoptic/simulate/models/naive.py index 16263abe..e9580541 100644 --- a/src/plenoptic/simulate/models/naive.py +++ b/src/plenoptic/simulate/models/naive.py @@ -73,10 +73,10 @@ def __init__( self.conv = nn.Conv2d(1, 2, kernel_size, bias=False) if default_filters: - var = torch.as_tensor(3.) + var = torch.as_tensor(3.0) f1 = circular_gaussian2d(kernel_size, std=torch.sqrt(var)) - f2 = circular_gaussian2d(kernel_size, std=torch.sqrt(var/3)) + f2 = circular_gaussian2d(kernel_size, std=torch.sqrt(var / 3)) f2 = f2 - f1 f2 = f2 / f2.sum() @@ -129,17 +129,19 @@ def __init__( self.out_channels = out_channels self.cache_filt = cache_filt - self.register_buffer('_filt', None) + self.register_buffer("_filt", None) @property def filt(self): if self._filt is not None: # use old filter return self._filt else: # create new filter, optionally cache it - filt = circular_gaussian2d(self.kernel_size, self.std, self.out_channels) + filt = circular_gaussian2d( + self.kernel_size, self.std, self.out_channels + ) if self.cache_filt: - self.register_buffer('_filt', filt) + self.register_buffer("_filt", filt) return filt def forward(self, x: Tensor, **conv2d_kwargs) -> Tensor: @@ -197,7 +199,7 @@ class CenterSurround(nn.Module): def __init__( self, kernel_size: Union[int, Tuple[int, int]], - on_center: Union[bool, List[bool, ]] = True, + on_center: Union[bool, List[bool,]] = True, width_ratio_limit: float = 2.0, amplitude_ratio: float = 1.25, center_std: Union[float, Tensor] = 1.0, @@ -211,31 +213,46 @@ def __init__( # make sure each channel is on-off or off-on if isinstance(on_center, bool): on_center = [on_center] * out_channels - assert len(on_center) == out_channels, "len(on_center) must match out_channels" + assert ( + len(on_center) == out_channels + ), "len(on_center) must match out_channels" # make sure each channel has a center and surround std if isinstance(center_std, float) or center_std.shape == torch.Size([]): center_std = torch.ones(out_channels) * center_std - if isinstance(surround_std, float) or surround_std.shape == torch.Size([]): + if isinstance(surround_std, float) or surround_std.shape == torch.Size( + [] + ): surround_std = torch.ones(out_channels) * surround_std - assert len(center_std) == out_channels and len(surround_std) == out_channels, "stds must correspond to each out_channel" - assert width_ratio_limit > 1.0, "stdev of surround must be greater than center" - assert amplitude_ratio >= 1.0, "ratio of amplitudes must at least be 1." + assert ( + len(center_std) == out_channels + and len(surround_std) == out_channels + ), "stds must correspond to each out_channel" + assert ( + width_ratio_limit > 1.0 + ), "stdev of surround must be greater than center" + assert ( + amplitude_ratio >= 1.0 + ), "ratio of amplitudes must at least be 1." self.on_center = on_center self.kernel_size = kernel_size self.width_ratio_limit = width_ratio_limit - self.register_buffer("amplitude_ratio", torch.as_tensor(amplitude_ratio)) + self.register_buffer( + "amplitude_ratio", torch.as_tensor(amplitude_ratio) + ) self.center_std = nn.Parameter(torch.ones(out_channels) * center_std) - self.surround_std = nn.Parameter(torch.ones(out_channels) * surround_std) + self.surround_std = nn.Parameter( + torch.ones(out_channels) * surround_std + ) self.out_channels = out_channels self.pad_mode = pad_mode self.cache_filt = cache_filt - self.register_buffer('_filt', None) + self.register_buffer("_filt", None) @property def filt(self) -> Tensor: @@ -246,24 +263,32 @@ def filt(self) -> Tensor: on_amp = self.amplitude_ratio device = on_amp.device - filt_center = circular_gaussian2d(self.kernel_size, self.center_std, self.out_channels) - filt_surround = circular_gaussian2d(self.kernel_size, self.surround_std, self.out_channels) + filt_center = circular_gaussian2d( + self.kernel_size, self.center_std, self.out_channels + ) + filt_surround = circular_gaussian2d( + self.kernel_size, self.surround_std, self.out_channels + ) # sign is + or - depending on center is on or off - sign = torch.as_tensor([1. if x else -1. for x in self.on_center]).to(device) + sign = torch.as_tensor( + [1.0 if x else -1.0 for x in self.on_center] + ).to(device) sign = sign.view(self.out_channels, 1, 1, 1) filt = on_amp * (sign * (filt_center - filt_surround)) if self.cache_filt: - self.register_buffer('_filt', filt) + self.register_buffer("_filt", filt) return filt def _clamp_surround_std(self): """Clamps surround standard deviation to ratio_limit times center_std""" lower_bound = self.width_ratio_limit * self.center_std for i, lb in enumerate(lower_bound): - self.surround_std[i].data = self.surround_std[i].data.clamp(min=float(lb)) + self.surround_std[i].data = self.surround_std[i].data.clamp( + min=float(lb) + ) def forward(self, x: Tensor) -> Tensor: x = same_padding(x, self.kernel_size, pad_mode=self.pad_mode) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index 81545620..c1fdd240 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -6,6 +6,7 @@ images have the same values for all PS texture stats, humans should consider them as members of the same family of textures. """ + from collections import OrderedDict from typing import List, Optional, Tuple, Union @@ -23,7 +24,9 @@ from ...tools.data import to_numpy from ...tools.display import clean_stem_plot, clean_up_axes, update_stem from ...tools.validate import validate_input -from ..canonical_computations.steerable_pyramid_freq import SteerablePyramidFreq +from ..canonical_computations.steerable_pyramid_freq import ( + SteerablePyramidFreq, +) from ..canonical_computations.steerable_pyramid_freq import ( SCALES_TYPE as PYR_SCALES_TYPE, ) @@ -146,8 +149,6 @@ def __init__( ] def _create_scales_shape_dict(self) -> OrderedDict: - - """Create dictionary defining scales and shape of each stat. This dictionary functions as metadata which is used for two main @@ -221,7 +222,11 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["kurtosis_reconstructed"] = scales_with_lowpass auto_corr = np.ones( - (self.spatial_corr_width, self.spatial_corr_width, self.n_scales + 1), + ( + self.spatial_corr_width, + self.spatial_corr_width, + self.n_scales + 1, + ), dtype=object, ) auto_corr *= einops.rearrange(scales_with_lowpass, "s -> 1 1 s") @@ -230,27 +235,34 @@ def _create_scales_shape_dict(self) -> OrderedDict: shape_dict["std_reconstructed"] = scales_with_lowpass cross_orientation_corr_mag = np.ones( - (self.n_orientations, self.n_orientations, self.n_scales), dtype=int + (self.n_orientations, self.n_orientations, self.n_scales), + dtype=int, ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") - shape_dict[ - "cross_orientation_correlation_magnitude" - ] = cross_orientation_corr_mag + shape_dict["cross_orientation_correlation_magnitude"] = ( + cross_orientation_corr_mag + ) mags_std = np.ones((self.n_orientations, self.n_scales), dtype=int) mags_std *= einops.rearrange(scales, "s -> 1 s") shape_dict["magnitude_std"] = mags_std cross_scale_corr_mag = np.ones( - (self.n_orientations, self.n_orientations, self.n_scales - 1), dtype=int + (self.n_orientations, self.n_orientations, self.n_scales - 1), + dtype=int, + ) + cross_scale_corr_mag *= einops.rearrange( + scales_without_coarsest, "s -> 1 1 s" ) - cross_scale_corr_mag *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_magnitude"] = cross_scale_corr_mag cross_scale_corr_real = np.ones( - (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), dtype=int + (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), + dtype=int, + ) + cross_scale_corr_real *= einops.rearrange( + scales_without_coarsest, "s -> 1 1 s" ) - cross_scale_corr_real *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_real"] = cross_scale_corr_real shape_dict["var_highpass_residual"] = np.array(["residual_highpass"]) @@ -287,7 +299,9 @@ def _create_necessary_stats_dict( mask_dict = scales_shape_dict.copy() # Pre-compute some necessary indices. # Lower triangular indices (including diagonal), for auto correlations - tril_inds = torch.tril_indices(self.spatial_corr_width, self.spatial_corr_width) + tril_inds = torch.tril_indices( + self.spatial_corr_width, self.spatial_corr_width + ) # Get the second half of the diagonal, i.e., everything from the center # element on. These are all repeated for the auto correlations. (As # these are autocorrelations (rather than auto-covariance) matrices, @@ -300,9 +314,14 @@ def _create_necessary_stats_dict( # for cross_orientation_correlation_magnitude (because we've normalized # this matrix to be true cross-correlations, the diagonals are all 1, # like for the auto-correlations) - triu_inds = torch.triu_indices(self.n_orientations, self.n_orientations) + triu_inds = torch.triu_indices( + self.n_orientations, self.n_orientations + ) for k, v in mask_dict.items(): - if k in ["auto_correlation_magnitude", "auto_correlation_reconstructed"]: + if k in [ + "auto_correlation_magnitude", + "auto_correlation_reconstructed", + ]: # Symmetry M_{i,j} = M_{n-i+1, n-j+1} # Start with all False, then place True in necessary stats. mask = torch.zeros(v.shape, dtype=torch.bool) @@ -372,14 +391,16 @@ def forward( # real_pyr_coeffs, which contain the demeaned magnitude of the pyramid # coefficients and the real part of the pyramid coefficients # respectively. - mag_pyr_coeffs, real_pyr_coeffs = self._compute_intermediate_representations( - pyr_coeffs + mag_pyr_coeffs, real_pyr_coeffs = ( + self._compute_intermediate_representations(pyr_coeffs) ) # Then, the reconstructed lowpass image at each scale. (this is a list # of length n_scales+1 containing tensors of shape (batch, channel, # height, width)) - reconstructed_images = self._reconstruct_lowpass_at_each_scale(pyr_dict) + reconstructed_images = self._reconstruct_lowpass_at_each_scale( + pyr_dict + ) # the reconstructed_images list goes from coarse-to-fine, but we want # each of the stats computed from it to go from fine-to-coarse, so we # reverse its direction. @@ -401,7 +422,9 @@ def forward( # tensor of shape (batch, channel, spatial_corr_width, # spatial_corr_width, n_scales+1), and var_recon is a tensor of shape # (batch, channel, n_scales+1) - autocorr_recon, var_recon = self._compute_autocorr(reconstructed_images) + autocorr_recon, var_recon = self._compute_autocorr( + reconstructed_images + ) # Compute the standard deviation, skew, and kurtosis of each # reconstructed lowpass image. std_recon, skew_recon, and # kurtosis_recon will all end up as tensors of shape (batch, channel, @@ -427,8 +450,8 @@ def forward( if self.n_scales != 1: # First, double the phase the coefficients, so we can correctly # compute correlations across scales. - phase_doubled_mags, phase_doubled_sep = self._double_phase_pyr_coeffs( - pyr_coeffs + phase_doubled_mags, phase_doubled_sep = ( + self._double_phase_pyr_coeffs(pyr_coeffs) ) # Compute the cross-scale correlations between the magnitude # coefficients. For each coefficient, we're correlating it with the @@ -436,14 +459,18 @@ def forward( # shape (batch, channel, n_orientations, n_orientations, # n_scales-1) cross_scale_corr_mags, _ = self._compute_cross_correlation( - mag_pyr_coeffs[:-1], phase_doubled_mags, tensors_are_identical=False + mag_pyr_coeffs[:-1], + phase_doubled_mags, + tensors_are_identical=False, ) # Compute the cross-scale correlations between the real # coefficients and the real and imaginary coefficients at the next # coarsest scale. this will be a tensor of shape (batch, channel, # n_orientations, 2*n_orientations, n_scales-1) cross_scale_corr_real, _ = self._compute_cross_correlation( - real_pyr_coeffs[:-1], phase_doubled_sep, tensors_are_identical=False + real_pyr_coeffs[:-1], + phase_doubled_sep, + tensors_are_identical=False, ) # Compute the variance of the highpass residual @@ -480,7 +507,9 @@ def forward( # Return the subset of stats corresponding to the specified scale. if scales is not None: - representation_tensor = self.remove_scales(representation_tensor, scales) + representation_tensor = self.remove_scales( + representation_tensor, scales + ) return representation_tensor @@ -590,7 +619,9 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: device=representation_tensor.device, ) # v.sum() gives the number of necessary elements from this stat - this_stat_vec = representation_tensor[..., n_filled : n_filled + v.sum()] + this_stat_vec = representation_tensor[ + ..., n_filled : n_filled + v.sum() + ] # use boolean indexing to put the values from new_stat_vec in the # appropriate place new_v[..., v] = this_stat_vec @@ -642,7 +673,9 @@ def _compute_pyr_coeffs( # of shape (batch, channel, n_orientations, height, width) (note that # height and width halves on each scale) coeffs_list = [ - torch.stack([pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2) + torch.stack( + [pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2 + ) for i in range(self.n_scales) ] return pyr_coeffs, coeffs_list, highpass, lowpass @@ -679,11 +712,13 @@ def _compute_pixel_stats(image: Tensor) -> Tensor: # mean needed to be unflattened to be used by skew and kurtosis # correctly, but we'll want it to be flattened like this in the final # representation tensor - return einops.pack([mean, var, skew, kurtosis, img_min, img_max], "b c *")[0] + return einops.pack( + [mean, var, skew, kurtosis, img_min, img_max], "b c *" + )[0] @staticmethod def _compute_intermediate_representations( - pyr_coeffs: Tensor + pyr_coeffs: Tensor, ) -> Tuple[List[Tensor], List[Tensor]]: """Compute useful intermediate representations. @@ -761,12 +796,15 @@ def _reconstruct_lowpass_at_each_scale( # values across scales. This could also be handled by making the # pyramid tight frame reconstructed_images[:-1] = [ - signal.shrink(r, 2 ** (self.n_scales - i)) * 4 ** (self.n_scales - i) + signal.shrink(r, 2 ** (self.n_scales - i)) + * 4 ** (self.n_scales - i) for i, r in enumerate(reconstructed_images[:-1]) ] return reconstructed_images - def _compute_autocorr(self, coeffs_list: List[Tensor]) -> Tuple[Tensor, Tensor]: + def _compute_autocorr( + self, coeffs_list: List[Tensor] + ) -> Tuple[Tensor, Tensor]: """Compute the autocorrelation of some statistics. Parameters @@ -806,7 +844,9 @@ def _compute_autocorr(self, coeffs_list: List[Tensor]) -> Tuple[Tensor, Tensor]: var = einops.pack(var, "b c *")[0] acs = [signal.center_crop(ac, self.spatial_corr_width) for ac in acs] acs = torch.stack(acs, 2) - return einops.rearrange(acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}"), var + return einops.rearrange( + acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}" + ), var @staticmethod def _compute_skew_kurtosis_recon( @@ -859,7 +899,9 @@ def _compute_skew_kurtosis_recon( res = torch.finfo(img_var.dtype).resolution unstable_locs = var_recon / img_var.unsqueeze(-1) < res skew_recon = torch.where(unstable_locs, skew_default, skew_recon) - kurtosis_recon = torch.where(unstable_locs, kurtosis_default, kurtosis_recon) + kurtosis_recon = torch.where( + unstable_locs, kurtosis_default, kurtosis_recon + ) return skew_recon, kurtosis_recon def _compute_cross_correlation( @@ -908,14 +950,18 @@ def _compute_cross_correlation( # First, compute the variances of each coeff (if coeff and # coeff_other are identical, this is equivalent to the diagonal of # the above covar matrix, but re-computing it is actually faster) - coeff_var = einops.einsum(coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1") + coeff_var = einops.einsum( + coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1" + ) coeff_var = coeff_var / numel coeffs_var.append(coeff_var) if tensors_are_identical: coeff_other_var = coeff_var else: coeff_other_var = einops.einsum( - coeff_other, coeff_other, "b c o2 h w, b c o2 h w -> b c o2" + coeff_other, + coeff_other, + "b c o2 h w, b c o2 h w -> b c o2", ) coeff_other_var = coeff_other_var / numel # Then compute the outer product of those variances. @@ -929,7 +975,7 @@ def _compute_cross_correlation( @staticmethod def _double_phase_pyr_coeffs( - pyr_coeffs: List[Tensor] + pyr_coeffs: List[Tensor], ) -> Tuple[List[Tensor], List[Tensor]]: """Upsample and double the phase of pyramid coefficients. @@ -971,7 +1017,9 @@ def _double_phase_pyr_coeffs( ) doubled_phase_mags.append(doubled_phase_mag) doubled_phase_sep.append( - einops.pack([doubled_phase.real, doubled_phase.imag], "b c * h w")[0] + einops.pack( + [doubled_phase.real, doubled_phase.imag], "b c * h w" + )[0] ) return doubled_phase_mags, doubled_phase_sep From 43937bc34c33b3cc430607af81d854089ab749e2 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 8 Aug 2024 17:48:25 -0400 Subject: [PATCH 038/134] all files in src refactored to meet pydocstyle and pyflakes criteria --- src/plenoptic/synthesize/autodiff.py | 4 +- src/plenoptic/synthesize/eigendistortion.py | 106 ++- src/plenoptic/synthesize/geodesic.py | 265 ++++-- src/plenoptic/synthesize/mad_competition.py | 744 ++++++++++------- src/plenoptic/synthesize/metamer.py | 853 ++++++++++++-------- src/plenoptic/synthesize/simple_metamer.py | 47 +- src/plenoptic/synthesize/synthesis.py | 172 ++-- src/plenoptic/tools/conv.py | 70 +- src/plenoptic/tools/convergence.py | 36 +- src/plenoptic/tools/data.py | 25 +- src/plenoptic/tools/display.py | 334 +++++--- src/plenoptic/tools/external.py | 126 ++- src/plenoptic/tools/optim.py | 13 +- src/plenoptic/tools/signal.py | 59 +- src/plenoptic/tools/stats.py | 8 +- src/plenoptic/tools/straightness.py | 46 +- src/plenoptic/tools/validate.py | 68 +- 17 files changed, 1922 insertions(+), 1054 deletions(-) diff --git a/src/plenoptic/synthesize/autodiff.py b/src/plenoptic/synthesize/autodiff.py index 8be6e00c..892eef40 100755 --- a/src/plenoptic/synthesize/autodiff.py +++ b/src/plenoptic/synthesize/autodiff.py @@ -40,7 +40,9 @@ def jacobian(y: Tensor, x: Tensor) -> Tensor: .t() ) - if y.shape[0] == 1: # need to return a 2D tensor even if y dimensionality is 1 + if ( + y.shape[0] == 1 + ): # need to return a 2D tensor even if y dimensionality is 1 J = J.unsqueeze(0) return J.detach() diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 3f4061c4..4cd837c7 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -10,7 +10,11 @@ from tqdm.auto import tqdm from .synthesis import Synthesis -from .autodiff import jacobian, vector_jacobian_product, jacobian_vector_product +from .autodiff import ( + jacobian, + vector_jacobian_product, + jacobian_vector_product, +) from ..tools.display import imshow from ..tools.validate import validate_input, validate_model @@ -38,7 +42,8 @@ def fisher_info_matrix_vector_product( Notes ----- - Under white Gaussian noise assumption, :math:`F` is matrix multiplication of Jacobian transpose and Jacobian: + Under white Gaussian noise assumption, :math:`F` is matrix multiplication + of Jacobian transpose and Jacobian: :math:`F = J^T J`. Hence: :math:`Fv = J^T (Jv)` """ @@ -117,8 +122,12 @@ class Eigendistortion(Synthesis): def __init__(self, image: Tensor, model: torch.nn.Module): validate_input(image, no_batch=True) - validate_model(model, image_shape=image.shape, - image_dtype=image.dtype, device=image.device) + validate_model( + model, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) ( self.batch_size, @@ -143,7 +152,7 @@ def __init__(self, image: Tensor, model: torch.nn.Module): self._eigenindex = None def _init_representation(self, image): - """Set self._representation_flat, based on model and image """ + """Set self._representation_flat, based on model and image""" self._image = self._image_flat.view(*image.shape) image_representation = self.model(self.image) @@ -193,11 +202,14 @@ def synthesize( """ allowed_methods = ["power", "exact", "randomized_svd"] - assert method in allowed_methods, f"method must be in {allowed_methods}" + assert ( + method in allowed_methods + ), f"method must be in {allowed_methods}" if ( method == "exact" - and self._representation_flat.size(0) * self._image_flat.size(0) > 1e6 + and self._representation_flat.size(0) * self._image_flat.size(0) + > 1e6 ): warnings.warn( "Jacobian > 1e6 elements and may cause out-of-memory. Use method = {'power', 'randomized_svd'}." @@ -210,7 +222,9 @@ def synthesize( eig_vecs_ind = torch.arange(len(eig_vecs)) elif method == "randomized_svd": - print(f"Estimating top k={k} eigendistortions using randomized SVD") + print( + f"Estimating top k={k} eigendistortions using randomized SVD" + ) lmbda_new, v_new, error_approx = self._synthesize_randomized_svd( k=k, p=p, q=q ) @@ -224,7 +238,6 @@ def synthesize( ) else: # method == 'power' - assert max_iter > 0, "max_iter must be greater than zero" lmbda_max, v_max = self._synthesize_power( @@ -235,12 +248,16 @@ def synthesize( ) n = v_max.shape[0] - eig_vecs = self._vector_to_image(torch.cat((v_max, v_min), dim=1).detach()) + eig_vecs = self._vector_to_image( + torch.cat((v_max, v_min), dim=1).detach() + ) eig_vals = torch.cat([lmbda_max, lmbda_min]).squeeze() eig_vecs_ind = torch.cat((torch.arange(k), torch.arange(n - k, n))) # reshape to (n x num_chans x h x w) - self._eigendistortions = torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] + self._eigendistortions = ( + torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] + ) self._eigenvalues = torch.abs(eig_vals.detach()) self._eigenindex = eig_vecs_ind @@ -326,7 +343,9 @@ def _synthesize_power( v = torch.randn(len(x), k, device=x.device, dtype=x.dtype) v = v / torch.linalg.vector_norm(v, dim=0, keepdim=True, ord=2) - _dummy_vec = torch.ones_like(y, requires_grad=True) # cache a dummy vec for jvp + _dummy_vec = torch.ones_like( + y, requires_grad=True + ) # cache a dummy vec for jvp Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) v = Fv / torch.linalg.vector_norm(Fv, dim=0, keepdim=True, ord=2) lmbda = fisher_info_matrix_eigenvalue(y, x, v, _dummy_vec) @@ -348,11 +367,15 @@ def _synthesize_power( Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) Fv = Fv - shift * v # optionally shift: (F - shift*I)v - v_new, _ = torch.linalg.qr(Fv, "reduced") # (ortho)normalize vector(s) + v_new, _ = torch.linalg.qr( + Fv, "reduced" + ) # (ortho)normalize vector(s) lmbda_new = fisher_info_matrix_eigenvalue(y, x, v_new, _dummy_vec) - d_lambda = torch.linalg.vector_norm(lmbda - lmbda_new, ord=2) # stability of eigenspace + d_lambda = torch.linalg.vector_norm( + lmbda - lmbda_new, ord=2 + ) # stability of eigenspace v = v_new lmbda = lmbda_new @@ -421,7 +444,9 @@ def _synthesize_randomized_svd( y, x, torch.randn(n, 20).to(x.device), _dummy_vec ) error_approx = omega - (Q @ Q.T @ omega) - error_approx = torch.linalg.vector_norm(error_approx, dim=0, ord=2).mean() + error_approx = torch.linalg.vector_norm( + error_approx, dim=0, ord=2 + ).mean() return S[:k].clone(), V[:, :k].clone(), error_approx # truncate @@ -441,7 +466,9 @@ def _vector_to_image(self, vecs: Tensor) -> List[Tensor]: """ imgs = [ - vecs[:, i].reshape((self.n_channels, self.im_height, self.im_width)) + vecs[:, i].reshape( + (self.n_channels, self.im_height, self.im_width) + ) for i in range(vecs.shape[1]) ] return imgs @@ -453,7 +480,9 @@ def _indexer(self, idx: int) -> int: i = idx_range[idx] all_idx = self.eigenindex - assert i in all_idx, "eigenindex must be the index of one of the vectors" + assert ( + i in all_idx + ), "eigenindex must be the index of one of the vectors" assert ( all_idx is not None and len(all_idx) != 0 ), "No eigendistortions synthesized" @@ -506,14 +535,24 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ["_jacobian", "_eigendistortions", "_eigenvalues", - "_eigenindex", "_model", "_image", "_image_flat", - "_representation_flat"] + attrs = [ + "_jacobian", + "_eigendistortions", + "_eigenvalues", + "_eigenindex", + "_model", + "_image", + "_image_flat", + "_representation_flat", + ] super().to(*args, attrs=attrs, **kwargs) - def load(self, file_path: str, - map_location: Union[str, None] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: Union[str, None] = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Eigendistortion`` object -- @@ -547,12 +586,15 @@ def load(self, file_path: str, *then* load. """ - check_attributes = ['_image', '_representation_flat'] + check_attributes = ["_image", "_representation_flat"] check_loss_functions = [] - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) # make these require a grad again self._image_flat.requires_grad_() # we need _representation_flat and _image_flat to be connected in the @@ -570,22 +612,22 @@ def image(self): @property def jacobian(self): - """Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``. """ + """Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``.""" return self._jacobian @property def eigendistortions(self): - """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue. """ + """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue.""" return self._eigendistortions @property def eigenvalues(self): - """Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order. """ + """Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order.""" return self._eigenvalues @property def eigenindex(self): - """Index of each eigenvector/eigenvalue. """ + """Index of each eigenvector/eigenvalue.""" return self._eigenindex diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index 9e4f6a14..b74a027b 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -14,8 +14,11 @@ from ..tools.optim import penalize_range from ..tools.validate import validate_input, validate_model from ..tools.convergence import pixel_change_convergence -from ..tools.straightness import (deviation_from_line, make_straight_line, - sample_brownian_bridge) +from ..tools.straightness import ( + deviation_from_line, + make_straight_line, + sample_brownian_bridge, +) class Geodesic(OptimizedSynthesis): @@ -96,16 +99,26 @@ class Geodesic(OptimizedSynthesis): http://www.cns.nyu.edu/~lcv/pubs/makeAbs.php?loc=Henaff16b """ - def __init__(self, image_a: Tensor, image_b: Tensor, - model: torch.nn.Module, n_steps: int = 10, - initial_sequence: Literal['straight', 'bridge'] = 'straight', - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1)): + + def __init__( + self, + image_a: Tensor, + image_b: Tensor, + model: torch.nn.Module, + n_steps: int = 10, + initial_sequence: Literal["straight", "bridge"] = "straight", + range_penalty_lambda: float = 0.1, + allowed_range: Tuple[float, float] = (0, 1), + ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image_a, no_batch=True, allowed_range=allowed_range) validate_input(image_b, no_batch=True, allowed_range=allowed_range) - validate_model(model, image_shape=image_a.shape, image_dtype=image_a.dtype, - device=image_a.device) + validate_model( + model, + image_shape=image_a.shape, + image_dtype=image_a.dtype, + device=image_a.device, + ) self.n_steps = n_steps self._model = model @@ -126,22 +139,27 @@ def _initialize(self, initial_sequence, start, stop, n_steps): (``'straight'``), or with a brownian bridge between the two anchors (``'bridge'``). """ - if initial_sequence == 'bridge': + if initial_sequence == "bridge": geodesic = sample_brownian_bridge(start, stop, n_steps) - elif initial_sequence == 'straight': + elif initial_sequence == "straight": geodesic = make_straight_line(start, stop, n_steps) else: - raise ValueError(f"Don't know how to handle initial_sequence={initial_sequence}") - _, geodesic, _ = torch.split(geodesic, [1, n_steps-1, 1]) + raise ValueError( + f"Don't know how to handle initial_sequence={initial_sequence}" + ) + _, geodesic, _ = torch.split(geodesic, [1, n_steps - 1, 1]) self._initial_sequence = initial_sequence geodesic.requires_grad_() self._geodesic = geodesic - def synthesize(self, max_iter: int = 1000, - optimizer: Optional[torch.optim.Optimizer] = None, - store_progress: Union[bool, int] = False, - stop_criterion: Optional[float] = None, - stop_iters_to_check: int = 50): + def synthesize( + self, + max_iter: int = 1000, + optimizer: Optional[torch.optim.Optimizer] = None, + store_progress: Union[bool, int] = False, + stop_criterion: Optional[float] = None, + stop_iters_to_check: int = 50, + ): """Synthesize a geodesic via optimization. Parameters @@ -173,10 +191,17 @@ def synthesize(self, max_iter: int = 1000, """ if stop_criterion is None: # semi arbitrary default choice of tolerance - stop_criterion = torch.linalg.vector_norm(self.pixelfade, ord=2) / 1e4 * (1 + 5 ** .5) / 2 - print(f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}") - - self._initialize_optimizer(optimizer, '_geodesic', .001) + stop_criterion = ( + torch.linalg.vector_norm(self.pixelfade, ord=2) + / 1e4 + * (1 + 5**0.5) + / 2 + ) + print( + f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}" + ) + + self._initialize_optimizer(optimizer, "_geodesic", 0.001) # get ready to store progress self.store_progress = store_progress @@ -191,7 +216,9 @@ def synthesize(self, max_iter: int = 1000, raise ValueError("Found a NaN in loss during optimization.") if self._check_convergence(stop_criterion, stop_iters_to_check): - warnings.warn("Pixel change norm has converged, stopping synthesis") + warnings.warn( + "Pixel change norm has converged, stopping synthesis" + ) break pbar.close() @@ -224,16 +251,19 @@ def objective_function(self, geodesic: Optional[Tensor] = None) -> Tensor: if geodesic is None: geodesic = self.geodesic self._geodesic_representation = self.model(geodesic) - self._most_recent_step_energy = self._calculate_step_energy(self._geodesic_representation) + self._most_recent_step_energy = self._calculate_step_energy( + self._geodesic_representation + ) loss = self._most_recent_step_energy.mean() range_penalty = penalize_range(self.geodesic, self.allowed_range) return loss + self.range_penalty_lambda * range_penalty def _calculate_step_energy(self, z): - """calculate the energy (i.e. squared l2 norm) of each step in `z`. - """ + """calculate the energy (i.e. squared l2 norm) of each step in `z`.""" velocity = torch.diff(z, dim=0) - step_energy = torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 + step_energy = ( + torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 + ) return step_energy def _optimizer_step(self, pbar): @@ -254,21 +284,30 @@ def _optimizer_step(self, pbar): loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm(self._geodesic.grad.data, - ord=2, dim=None) + grad_norm = torch.linalg.vector_norm( + self._geodesic.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm) - pixel_change_norm = torch.linalg.vector_norm(self._geodesic - last_iter_geodesic, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self._geodesic - last_iter_geodesic, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm) # displaying some information - pbar.set_postfix(OrderedDict([('loss', f'{loss.item():.4e}'), - ('gradient norm', f'{grad_norm.item():.4e}'), - ('pixel change norm', f"{pixel_change_norm.item():.5e}")])) + pbar.set_postfix( + OrderedDict( + [ + ("loss", f"{loss.item():.4e}"), + ("gradient norm", f"{grad_norm.item():.4e}"), + ("pixel change norm", f"{pixel_change_norm.item():.5e}"), + ] + ) + ) return loss - def _check_convergence(self, stop_criterion: float, - stop_iters_to_check: int) -> bool: + def _check_convergence( + self, stop_criterion: float, stop_iters_to_check: int + ) -> bool: """Check whether the pixel change norm has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -297,7 +336,9 @@ def _check_convergence(self, stop_criterion: float, Whether the pixel change norm has stabilized or not. """ - return pixel_change_convergence(self, stop_criterion, stop_iters_to_check) + return pixel_change_convergence( + self, stop_criterion, stop_iters_to_check + ) def calculate_jerkiness(self, geodesic: Optional[Tensor] = None) -> Tensor: """Compute the alignment of representation's acceleration to model local curvature. @@ -321,15 +362,19 @@ def calculate_jerkiness(self, geodesic: Optional[Tensor] = None) -> Tensor: geodesic_representation = self.model(geodesic) velocity = torch.diff(geodesic_representation, dim=0) acceleration = torch.diff(velocity, dim=0) - acc_magnitude = torch.linalg.vector_norm(acceleration, ord=2, dim=[1,2,3], - keepdim=True) + acc_magnitude = torch.linalg.vector_norm( + acceleration, ord=2, dim=[1, 2, 3], keepdim=True + ) acc_direction = torch.div(acceleration, acc_magnitude) # we slice the output of the VJP, rather than slicing geodesic, because # slicing interferes with the gradient computation: # https://stackoverflow.com/a/54767100 - accJac = self._vector_jacobian_product(geodesic_representation[1:-1], - geodesic, acc_direction)[1:-1] - step_jerkiness = torch.linalg.vector_norm(accJac, dim=[1,2,3], ord=2) ** 2 + accJac = self._vector_jacobian_product( + geodesic_representation[1:-1], geodesic, acc_direction + )[1:-1] + step_jerkiness = ( + torch.linalg.vector_norm(accJac, dim=[1, 2, 3], ord=2) ** 2 + ) return step_jerkiness def _vector_jacobian_product(self, y, x, a): @@ -337,9 +382,9 @@ def _vector_jacobian_product(self, y, x, a): and allow for further gradient computations by retaining, and creating the graph. """ - accJac = autograd.grad(y, x, a, - retain_graph=True, - create_graph=True)[0] + accJac = autograd.grad(y, x, a, retain_graph=True, create_graph=True)[ + 0 + ] return accJac def _store(self, i: int) -> bool: @@ -362,15 +407,29 @@ def _store(self, i: int) -> bool: if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs try: - self._step_energy.append(self._most_recent_step_energy.detach().to('cpu')) - self._dev_from_line.append(torch.stack(deviation_from_line(self._geodesic_representation.detach().to('cpu'))).T) + self._step_energy.append( + self._most_recent_step_energy.detach().to("cpu") + ) + self._dev_from_line.append( + torch.stack( + deviation_from_line( + self._geodesic_representation.detach().to("cpu") + ) + ).T + ) except AttributeError: # the first time _store is called (i.e., before optimizer is # stepped for first time) those attributes won't be # initialized geod_rep = self.model(self.geodesic) - self._step_energy.append(self._calculate_step_energy(geod_rep).detach().to('cpu')) - self._dev_from_line.append(torch.stack(deviation_from_line(geod_rep.detach().to('cpu'))).T) + self._step_energy.append( + self._calculate_step_energy(geod_rep).detach().to("cpu") + ) + self._dev_from_line.append( + torch.stack( + deviation_from_line(geod_rep.detach().to("cpu")) + ).T + ) stored = True else: stored = False @@ -427,13 +486,23 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ['_image_a', '_image_b', '_geodesic', '_model', - '_step_energy', '_dev_from_line', 'pixelfade'] + attrs = [ + "_image_a", + "_image_b", + "_geodesic", + "_model", + "_step_energy", + "_dev_from_line", + "pixelfade", + ] super().to(*args, attrs=attrs, **kwargs) - def load(self, file_path: str, - map_location: Union[str, None] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: Union[str, None] = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Geodesic`` object -- we will @@ -469,28 +538,47 @@ def load(self, file_path: str, *then* load. """ - check_attributes = ['_image_a', '_image_b', 'n_steps', - '_initial_sequence', '_range_penalty_lambda', - '_allowed_range', 'pixelfade'] + check_attributes = [ + "_image_a", + "_image_b", + "n_steps", + "_initial_sequence", + "_range_penalty_lambda", + "_allowed_range", + "pixelfade", + ] check_loss_functions = [] new_loss = self.objective_function(self.pixelfade) - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) - old_loss = self.__dict__.pop('_save_check') + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) + old_loss = self.__dict__.pop("_save_check") if not torch.allclose(new_loss, old_loss, rtol=1e-2): - raise ValueError("objective_function on pixelfade of saved and initialized Geodesic object are different! Do they use the same model?" - f" Self: {new_loss}, Saved: {old_loss}") + raise ValueError( + "objective_function on pixelfade of saved and initialized Geodesic object are different! Do they use the same model?" + f" Self: {new_loss}, Saved: {old_loss}" + ) # make this require a grad again self._geodesic.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if len(self._dev_from_line) and self._dev_from_line[0].device.type != 'cpu': - self._dev_from_line = [dev.to('cpu') for dev in self._dev_from_line] - if len(self._step_energy) and self._step_energy[0].device.type != 'cpu': - self._step_energy = [step.to('cpu') for step in self._step_energy] + if ( + len(self._dev_from_line) + and self._dev_from_line[0].device.type != "cpu" + ): + self._dev_from_line = [ + dev.to("cpu") for dev in self._dev_from_line + ] + if ( + len(self._step_energy) + and self._step_energy[0].device.type != "cpu" + ): + self._step_energy = [step.to("cpu") for step in self._step_energy] @property def model(self): @@ -535,9 +623,9 @@ def dev_from_line(self): return torch.stack(self._dev_from_line) -def plot_loss(geodesic: Geodesic, - ax: Union[mpl.axes.Axes, None] = None, - **kwargs) -> mpl.axes.Axes: +def plot_loss( + geodesic: Geodesic, ax: Union[mpl.axes.Axes, None] = None, **kwargs +) -> mpl.axes.Axes: """Plot synthesis loss. Parameters @@ -559,14 +647,15 @@ def plot_loss(geodesic: Geodesic, if ax is None: ax = plt.gca() ax.semilogy(geodesic.losses, **kwargs) - ax.set(xlabel='Synthesis iteration', - ylabel='Loss') + ax.set(xlabel="Synthesis iteration", ylabel="Loss") return ax -def plot_deviation_from_line(geodesic: Geodesic, - natural_video: Union[Tensor, None] = None, - ax: Union[mpl.axes.Axes, None] = None - ) -> mpl.axes.Axes: + +def plot_deviation_from_line( + geodesic: Geodesic, + natural_video: Union[Tensor, None] = None, + ax: Union[mpl.axes.Axes, None] = None, +) -> mpl.axes.Axes: """Visual diagnostic of geodesic linearity in representation space. This plot illustrates the deviation from the straight line connecting @@ -609,18 +698,24 @@ def plot_deviation_from_line(geodesic: Geodesic, ax = plt.gca() pixelfade_dev = deviation_from_line(geodesic.model(geodesic.pixelfade)) - ax.plot(*[to_numpy(d) for d in pixelfade_dev], 'g-o', label='pixelfade') + ax.plot(*[to_numpy(d) for d in pixelfade_dev], "g-o", label="pixelfade") - geodesic_dev = deviation_from_line(geodesic.model(geodesic.geodesic).detach()) - ax.plot(*[to_numpy(d) for d in geodesic_dev], 'r-o', label='geodesic') + geodesic_dev = deviation_from_line( + geodesic.model(geodesic.geodesic).detach() + ) + ax.plot(*[to_numpy(d) for d in geodesic_dev], "r-o", label="geodesic") if natural_video is not None: video_dev = deviation_from_line(geodesic.model(natural_video)) - ax.plot(*[to_numpy(d) for d in video_dev], 'b-o', label='natural video') - - ax.set(xlabel='Distance along representation line', - ylabel='Distance from representation line', - title='Deviation from the straight line') + ax.plot( + *[to_numpy(d) for d in video_dev], "b-o", label="natural video" + ) + + ax.set( + xlabel="Distance along representation line", + ylabel="Distance from representation line", + title="Deviation from the straight line", + ) ax.legend(loc=1) return ax diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index b3e61330..d5a24904 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -1,4 +1,5 @@ """Run MAD Competition.""" + import torch import numpy as np from torch import Tensor @@ -97,20 +98,36 @@ class MADCompetition(OptimizedSynthesis): http://dx.doi.org/10.1167/8.12.8 """ - def __init__(self, image: Tensor, - optimized_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], - reference_metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], - minmax: Literal['min', 'max'], - initial_noise: float = .1, - metric_tradeoff_lambda: Optional[float] = None, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1)): + + def __init__( + self, + image: Tensor, + optimized_metric: Union[ + torch.nn.Module, Callable[[Tensor, Tensor], Tensor] + ], + reference_metric: Union[ + torch.nn.Module, Callable[[Tensor, Tensor], Tensor] + ], + minmax: Literal["min", "max"], + initial_noise: float = 0.1, + metric_tradeoff_lambda: Optional[float] = None, + range_penalty_lambda: float = 0.1, + allowed_range: Tuple[float, float] = (0, 1), + ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) - validate_metric(optimized_metric, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) - validate_metric(reference_metric, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) + validate_metric( + optimized_metric, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) + validate_metric( + reference_metric, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) self._optimized_metric = optimized_metric self._reference_metric = reference_metric self._image = image.detach() @@ -118,25 +135,33 @@ def __init__(self, image: Tensor, self.scheduler = None self._optimized_metric_loss = [] self._reference_metric_loss = [] - if minmax not in ['min', 'max']: - raise ValueError("synthesis_target must be one of {'min', 'max'}, but got " - f"value {minmax} instead!") + if minmax not in ["min", "max"]: + raise ValueError( + "synthesis_target must be one of {'min', 'max'}, but got " + f"value {minmax} instead!" + ) self._minmax = minmax self._initialize(initial_noise) # If no metric_tradeoff_lambda is specified, pick one that gets them to # approximately the same magnitude if metric_tradeoff_lambda is None: - loss_ratio = torch.as_tensor(self.optimized_metric_loss[-1] / self.reference_metric_loss[-1], - dtype=torch.float32) - metric_tradeoff_lambda = torch.pow(torch.as_tensor(10), - torch.round(torch.log10(loss_ratio))).item() - warnings.warn("Since metric_tradeoff_lamda was None, automatically set" - f" to {metric_tradeoff_lambda} to roughly balance metrics.") + loss_ratio = torch.as_tensor( + self.optimized_metric_loss[-1] + / self.reference_metric_loss[-1], + dtype=torch.float32, + ) + metric_tradeoff_lambda = torch.pow( + torch.as_tensor(10), torch.round(torch.log10(loss_ratio)) + ).item() + warnings.warn( + "Since metric_tradeoff_lamda was None, automatically set" + f" to {metric_tradeoff_lambda} to roughly balance metrics." + ) self._metric_tradeoff_lambda = metric_tradeoff_lambda self._store_progress = None self._saved_mad_image = [] - def _initialize(self, initial_noise: float = .1): + def _initialize(self, initial_noise: float = 0.1): """Initialize the synthesized image. Initialize ``self.mad_image`` attribute to be ``image`` plus @@ -149,24 +174,28 @@ def _initialize(self, initial_noise: float = .1): ``mad_image`` from ``image``. """ - mad_image = (self.image + initial_noise * - torch.randn_like(self.image)) + mad_image = self.image + initial_noise * torch.randn_like(self.image) mad_image = mad_image.clamp(*self.allowed_range) self._initial_image = mad_image.clone() mad_image.requires_grad_() self._mad_image = mad_image - self._reference_metric_target = self.reference_metric(self.image, - self.mad_image).item() + self._reference_metric_target = self.reference_metric( + self.image, self.mad_image + ).item() self._reference_metric_loss.append(self._reference_metric_target) - self._optimized_metric_loss.append(self.optimized_metric(self.image, - self.mad_image).item()) - - def synthesize(self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, - stop_criterion: float = 1e-4, stop_iters_to_check: int = 50 - ): + self._optimized_metric_loss.append( + self.optimized_metric(self.image, self.mad_image).item() + ) + + def synthesize( + self, + max_iter: int = 100, + optimizer: Optional[torch.optim.Optimizer] = None, + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, + store_progress: Union[bool, int] = False, + stop_criterion: float = 1e-4, + stop_iters_to_check: int = 50, + ): r"""Synthesize a MAD image. Update the pixels of ``initial_image`` to maximize or minimize @@ -228,9 +257,11 @@ def synthesize(self, max_iter: int = 100, pbar.close() - def objective_function(self, - mad_image: Optional[Tensor] = None, - image: Optional[Tensor] = None) -> Tensor: + def objective_function( + self, + mad_image: Optional[Tensor] = None, + image: Optional[Tensor] = None, + ) -> Tensor: r"""Compute the MADCompetition synthesis loss. This computes: @@ -268,15 +299,18 @@ def objective_function(self, image = self.image if mad_image is None: mad_image = self.mad_image - synth_target = {'min': 1, 'max': -1}[self.minmax] + synth_target = {"min": 1, "max": -1}[self.minmax] synthesis_loss = self.optimized_metric(image, mad_image) - fixed_loss = (self._reference_metric_target - - self.reference_metric(image, mad_image)).pow(2) - range_penalty = optim.penalize_range(mad_image, - self.allowed_range) - return (synth_target * synthesis_loss + - self.metric_tradeoff_lambda * fixed_loss + - self.range_penalty_lambda * range_penalty) + fixed_loss = ( + self._reference_metric_target + - self.reference_metric(image, mad_image) + ).pow(2) + range_penalty = optim.penalize_range(mad_image, self.allowed_range) + return ( + synth_target * synthesis_loss + + self.metric_tradeoff_lambda * fixed_loss + + self.range_penalty_lambda * range_penalty + ) def _optimizer_step(self, pbar: tqdm) -> Tensor: r"""Compute and propagate gradients, then step the optimizer to update mad_image. @@ -298,8 +332,9 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: last_iter_mad_image = self.mad_image.clone() loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm(self.mad_image.grad.data, - ord=2, dim=None) + grad_norm = torch.linalg.vector_norm( + self.mad_image.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm.item()) fm = self.reference_metric(self.image, self.mad_image) @@ -311,18 +346,22 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm(self.mad_image - last_iter_mad_image, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self.mad_image - last_iter_mad_image, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict(loss=f"{loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]['lr'], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}", - reference_metric=f'{fm.item():.04e}', - optimized_metric=f'{sm.item():.04e}')) + OrderedDict( + loss=f"{loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]["lr"], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + reference_metric=f"{fm.item():.04e}", + optimized_metric=f"{sm.item():.04e}", + ) + ) return loss def _check_convergence(self, stop_criterion, stop_iters_to_check): @@ -358,7 +397,7 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): def _initialize_optimizer(self, optimizer, scheduler): """Initialize optimizer and scheduler.""" - super()._initialize_optimizer(optimizer, 'mad_image') + super()._initialize_optimizer(optimizer, "mad_image") self.scheduler = scheduler def _store(self, i: int) -> bool: @@ -379,7 +418,7 @@ def _store(self, i: int) -> bool: """ if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs - self._saved_mad_image.append(self.mad_image.clone().to('cpu')) + self._saved_mad_image.append(self.mad_image.clone().to("cpu")) stored = True else: stored = False @@ -405,9 +444,9 @@ def save(self, file_path: str): # if the metrics are Modules, then we don't want to save them. If # they're functions then saving them is fine. if isinstance(self.optimized_metric, torch.nn.Module): - attrs.pop('_optimized_metric') + attrs.pop("_optimized_metric") if isinstance(self.reference_metric, torch.nn.Module): - attrs.pop('_reference_metric') + attrs.pop("_reference_metric") super().save(file_path, attrs=attrs) def to(self, *args, **kwargs): @@ -444,8 +483,7 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ['_initial_image', '_image', '_mad_image', - '_saved_mad_image'] + attrs = ["_initial_image", "_image", "_mad_image", "_saved_mad_image"] super().to(*args, attrs=attrs, **kwargs) # if the metrics are Modules, then we should pass them as well. If # they're functions then nothing needs to be done. @@ -458,9 +496,12 @@ def to(self, *args, **kwargs): except AttributeError: pass - def load(self, file_path: str, - map_location: Optional[None] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: Optional[None] = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``MADCompetition`` object -- we @@ -497,21 +538,33 @@ def load(self, file_path: str, *then* load. """ - check_attributes = ['_image', '_metric_tradeoff_lambda', - '_range_penalty_lambda', '_allowed_range', - '_minmax'] - check_loss_functions = ['_reference_metric', '_optimized_metric'] - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) + check_attributes = [ + "_image", + "_metric_tradeoff_lambda", + "_range_penalty_lambda", + "_allowed_range", + "_minmax", + ] + check_loss_functions = ["_reference_metric", "_optimized_metric"] + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) # make this require a grad again self.mad_image.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if len(self._saved_mad_image) and self._saved_mad_image[0].device.type != 'cpu': - self._saved_mad_image = [mad.to('cpu') for mad in self._saved_mad_image] + if ( + len(self._saved_mad_image) + and self._saved_mad_image[0].device.type != "cpu" + ): + self._saved_mad_image = [ + mad.to("cpu") for mad in self._saved_mad_image + ] @property def mad_image(self): @@ -554,10 +607,12 @@ def saved_mad_image(self): return torch.stack(self._saved_mad_image) -def plot_loss(mad: MADCompetition, - iteration: Optional[int] = None, - axes: Union[List[mpl.axes.Axes], mpl.axes.Axes, None] = None, - **kwargs) -> mpl.axes.Axes: +def plot_loss( + mad: MADCompetition, + iteration: Optional[int] = None, + axes: Union[List[mpl.axes.Axes], mpl.axes.Axes, None] = None, + **kwargs, +) -> mpl.axes.Axes: """Plot metric losses. Plots ``mad.optimized_metric_loss`` and ``mad.reference_metric_loss`` on two @@ -602,30 +657,32 @@ def plot_loss(mad: MADCompetition, loss_idx = iteration if axes is None: axes = plt.gca() - if not hasattr(axes, '__iter__'): - axes = display.clean_up_axes(axes, False, - ['top', 'right', 'bottom', 'left'], - ['x', 'y']) + if not hasattr(axes, "__iter__"): + axes = display.clean_up_axes( + axes, False, ["top", "right", "bottom", "left"], ["x", "y"] + ) gs = axes.get_subplotspec().subgridspec(1, 2) fig = axes.figure axes = [fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[0, 1])] losses = [mad.reference_metric_loss, mad.optimized_metric_loss] - names = ['Reference metric loss', 'Optimized metric loss'] + names = ["Reference metric loss", "Optimized metric loss"] for ax, loss, name in zip(axes, losses, names): ax.plot(loss, **kwargs) - ax.scatter(loss_idx, loss[loss_idx], c='r') - ax.set(xlabel='Synthesis iteration', ylabel=name) + ax.scatter(loss_idx, loss[loss_idx], c="r") + ax.set(xlabel="Synthesis iteration", ylabel=name) return ax -def display_mad_image(mad: MADCompetition, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, - title: str = 'MADCompetition', - **kwargs) -> mpl.axes.Axes: +def display_mad_image( + mad: MADCompetition, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + zoom: Optional[float] = None, + iteration: Optional[int] = None, + ax: Optional[mpl.axes.Axes] = None, + title: str = "MADCompetition", + **kwargs, +) -> mpl.axes.Axes: """Display MAD image. You can specify what iteration to view by using the ``iteration`` arg. @@ -680,21 +737,30 @@ def display_mad_image(mad: MADCompetition, as_rgb = False if ax is None: ax = plt.gca() - display.imshow(image, ax=ax, title=title, zoom=zoom, - batch_idx=batch_idx, channel_idx=channel_idx, - as_rgb=as_rgb, **kwargs) + display.imshow( + image, + ax=ax, + title=title, + zoom=zoom, + batch_idx=batch_idx, + channel_idx=channel_idx, + as_rgb=as_rgb, + **kwargs, + ) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) return ax -def plot_pixel_values(mad: MADCompetition, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float], Literal[False]] = False, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: +def plot_pixel_values( + mad: MADCompetition, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + ylim: Union[Tuple[float], Literal[False]] = False, + ax: Optional[mpl.axes.Axes] = None, + **kwargs, +) -> mpl.axes.Axes: r"""Plot histogram of pixel values of reference and MAD images. As a way to check the distributions of pixel intensities and see @@ -726,11 +792,12 @@ def plot_pixel_values(mad: MADCompetition, Creates axes. """ + def _freedman_diaconis_bins(a): """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) - iqr = np.diff(np.percentile(a, [.25, .75]))[0] + iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] if len(a) < 2: return 1 h = 2 * iqr / (len(a) ** (1 / 3)) @@ -740,7 +807,7 @@ def _freedman_diaconis_bins(a): else: return int(np.ceil((a.max() - a.min()) / h)) - kwargs.setdefault('alpha', .4) + kwargs.setdefault("alpha", 0.4) if iteration is None: mad_image = mad.mad_image[batch_idx] else: @@ -753,10 +820,18 @@ def _freedman_diaconis_bins(a): ax = plt.gca() image = data.to_numpy(image).flatten() mad_image = data.to_numpy(mad_image).flatten() - ax.hist(image, bins=min(_freedman_diaconis_bins(image), 50), - label='Reference image', **kwargs) - ax.hist(mad_image, bins=min(_freedman_diaconis_bins(image), 50), - label='MAD image', **kwargs) + ax.hist( + image, + bins=min(_freedman_diaconis_bins(image), 50), + label="Reference image", + **kwargs, + ) + ax.hist( + mad_image, + bins=min(_freedman_diaconis_bins(image), 50), + label="MAD image", + **kwargs, + ) ax.legend() if ylim: ax.set_ylim(ylim) @@ -764,8 +839,9 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots(to_check: Union[List[str], Dict[str, int]], - to_check_name: str): +def _check_included_plots( + to_check: Union[List[str], Dict[str, int]], to_check_name: str +): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -782,26 +858,37 @@ def _check_included_plots(to_check: Union[List[str], Dict[str, int]], Name of the `to_check` variable, used in the error message. """ - allowed_vals = ['display_mad_image', 'plot_loss', 'plot_pixel_values', 'misc'] + allowed_vals = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + "misc", + ] try: vals = to_check.keys() except AttributeError: vals = to_check not_allowed = [v for v in vals if v not in allowed_vals] if not_allowed: - raise ValueError(f'{to_check_name} contained value(s) {not_allowed}! ' - f'Only {allowed_vals} are permissible!') - - -def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = ['display_mad_image', - 'plot_loss', - 'plot_pixel_values'], - display_mad_image_width: float = 1, - plot_loss_width: float = 2, - plot_pixel_values_width: float = 1) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: + raise ValueError( + f"{to_check_name} contained value(s) {not_allowed}! " + f"Only {allowed_vals} are permissible!" + ) + + +def _setup_synthesis_fig( + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float]] = None, + included_plots: List[str] = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + ], + display_mad_image_width: float = 1, + plot_loss_width: float = 2, + plot_pixel_values_width: float = 1, +) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -852,64 +939,75 @@ def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, n_subplots = 0 axes_idx = axes_idx.copy() width_ratios = [] - if 'display_mad_image' in included_plots: + if "display_mad_image" in included_plots: n_subplots += 1 width_ratios.append(display_mad_image_width) - if 'display_mad_image' not in axes_idx.keys(): - axes_idx['display_mad_image'] = data._find_min_int(axes_idx.values()) - if 'plot_loss' in included_plots: + if "display_mad_image" not in axes_idx.keys(): + axes_idx["display_mad_image"] = data._find_min_int( + axes_idx.values() + ) + if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if 'plot_loss' not in axes_idx.keys(): - axes_idx['plot_loss'] = data._find_min_int(axes_idx.values()) - if 'plot_pixel_values' in included_plots: + if "plot_loss" not in axes_idx.keys(): + axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) + if "plot_pixel_values" in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if 'plot_pixel_values' not in axes_idx.keys(): - axes_idx['plot_pixel_values'] = data._find_min_int(axes_idx.values()) + if "plot_pixel_values" not in axes_idx.keys(): + axes_idx["plot_pixel_values"] = data._find_min_int( + axes_idx.values() + ) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: # we want (5, 5) for each subplot, with a bit of room between # each subplot - figsize = ((width_ratios*5).sum() + width_ratios.sum()-1, 5) + figsize = ((width_ratios * 5).sum() + width_ratios.sum() - 1, 5) width_ratios = width_ratios / width_ratios.sum() - fig, axes = plt.subplots(1, n_subplots, figsize=figsize, - gridspec_kw={'width_ratios': width_ratios}) + fig, axes = plt.subplots( + 1, + n_subplots, + figsize=figsize, + gridspec_kw={"width_ratios": width_ratios}, + ) if n_subplots == 1: axes = [axes] else: axes = fig.axes # make sure misc contains all the empty axes - misc_axes = axes_idx.get('misc', []) - if not hasattr(misc_axes, '__iter__'): + misc_axes = axes_idx.get("misc", []) + if not hasattr(misc_axes, "__iter__"): misc_axes = [misc_axes] all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, '__iter__'): + if hasattr(i, "__iter__"): all_axes.extend(i) else: all_axes.append(i) misc_axes += [i for i, _ in enumerate(fig.axes) if i not in all_axes] - axes_idx['misc'] = misc_axes + axes_idx["misc"] = misc_axes return fig, axes, axes_idx -def plot_synthesis_status(mad: MADCompetition, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - vrange: Union[Tuple[float], str] = 'indep1', - zoom: Optional[float] = None, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = ['display_mad_image', - 'plot_loss', - 'plot_pixel_values'], - width_ratios: Dict[str, float] = {}, - ) -> Tuple[mpl.figure.Figure, Dict[str, int]]: +def plot_synthesis_status( + mad: MADCompetition, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + vrange: Union[Tuple[float], str] = "indep1", + zoom: Optional[float] = None, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float]] = None, + included_plots: List[str] = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + ], + width_ratios: Dict[str, float] = {}, +) -> Tuple[mpl.figure.Figure, Dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create two @@ -977,62 +1075,75 @@ def plot_synthesis_status(mad: MADCompetition, """ if iteration is not None and not mad.store_progress: - raise ValueError("synthesis() was run with store_progress=False, " - "cannot specify which iteration to plot (only" - " last one, with iteration=None)") + raise ValueError( + "synthesis() was run with store_progress=False, " + "cannot specify which iteration to plot (only" + " last one, with iteration=None)" + ) if mad.mad_image.ndim not in [3, 4]: - raise ValueError("plot_synthesis_status() expects 3 or 4d data;" - "unexpected behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') - width_ratios = {f'{k}_width': v for k, v in width_ratios.items()} - fig, axes, axes_idx = _setup_synthesis_fig(fig, axes_idx, figsize, - included_plots, - **width_ratios) - - if 'display_mad_image' in included_plots: - display_mad_image(mad, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['display_mad_image']], - zoom=zoom, vrange=vrange) - if 'plot_loss' in included_plots: - plot_loss(mad, iteration=iteration, axes=axes[axes_idx['plot_loss']]) + raise ValueError( + "plot_synthesis_status() expects 3 or 4d data;" + "unexpected behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") + width_ratios = {f"{k}_width": v for k, v in width_ratios.items()} + fig, axes, axes_idx = _setup_synthesis_fig( + fig, axes_idx, figsize, included_plots, **width_ratios + ) + + if "display_mad_image" in included_plots: + display_mad_image( + mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["display_mad_image"]], + zoom=zoom, + vrange=vrange, + ) + if "plot_loss" in included_plots: + plot_loss(mad, iteration=iteration, axes=axes[axes_idx["plot_loss"]]) # this function creates a single axis for loss, which plot_loss then # split into two. this makes sure the right two axes are present in the # dict all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, '__iter__'): + if hasattr(i, "__iter__"): all_axes.extend(i) else: all_axes.append(i) - new_axes = [i for i, _ in enumerate(fig.axes) - if i not in all_axes] - axes_idx['plot_loss'] = new_axes - if 'plot_pixel_values' in included_plots: - plot_pixel_values(mad, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['plot_pixel_values']]) + new_axes = [i for i, _ in enumerate(fig.axes) if i not in all_axes] + axes_idx["plot_loss"] = new_axes + if "plot_pixel_values" in included_plots: + plot_pixel_values( + mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["plot_pixel_values"]], + ) return fig, axes_idx -def animate(mad: MADCompetition, - framerate: int = 10, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = ['display_mad_image', - 'plot_loss', - 'plot_pixel_values'], - width_ratios: Dict[str, float] = {}, - ) -> mpl.animation.FuncAnimation: +def animate( + mad: MADCompetition, + framerate: int = 10, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + zoom: Optional[float] = None, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float]] = None, + included_plots: List[str] = [ + "display_mad_image", + "plot_loss", + "plot_pixel_values", + ], + width_ratios: Dict[str, float] = {}, +) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. This is essentially the figure produced by @@ -1105,51 +1216,67 @@ def animate(mad: MADCompetition, """ if not mad.store_progress: - raise ValueError("synthesize() was run with store_progress=False," - " cannot animate!") + raise ValueError( + "synthesize() was run with store_progress=False," + " cannot animate!" + ) if mad.mad_image.ndim not in [3, 4]: - raise ValueError("animate() expects 3 or 4d data; unexpected" - " behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') + raise ValueError( + "animate() expects 3 or 4d data; unexpected" + " behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") # we run plot_synthesis_status to initialize the figure if either fig is # None or if there are no titles on any axes, which we assume means that # it's an empty figure if fig is None or not any([ax.get_title() for ax in fig.axes]): - fig, axes_idx = plot_synthesis_status(mad=mad, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=0, figsize=figsize, - zoom=zoom, fig=fig, - included_plots=included_plots, - axes_idx=axes_idx, - width_ratios=width_ratios) + fig, axes_idx = plot_synthesis_status( + mad=mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=0, + figsize=figsize, + zoom=zoom, + fig=fig, + included_plots=included_plots, + axes_idx=axes_idx, + width_ratios=width_ratios, + ) # grab the artist for the second plot (we don't need to do this for the # MAD image plot, because we use the update_plot function for that) - if 'plot_loss' in included_plots: - scat = [fig.axes[i].collections[0] for i in axes_idx['plot_loss']] + if "plot_loss" in included_plots: + scat = [fig.axes[i].collections[0] for i in axes_idx["plot_loss"]] # can also have multiple plots def movie_plot(i): artists = [] - if 'display_mad_image' in included_plots: - artists.extend(display.update_plot(fig.axes[axes_idx['display_mad_image']], - data=mad.saved_mad_image[i], - batch_idx=batch_idx)) - if 'plot_pixel_values' in included_plots: + if "display_mad_image" in included_plots: + artists.extend( + display.update_plot( + fig.axes[axes_idx["display_mad_image"]], + data=mad.saved_mad_image[i], + batch_idx=batch_idx, + ) + ) + if "plot_pixel_values" in included_plots: # this is the dumbest way to do this, but it's simple -- # clearing the axes can cause problems if the user has, for # example, changed the tick locator or formatter. not sure how # to handle this best right now - fig.axes[axes_idx['plot_pixel_values']].clear() - plot_pixel_values(mad, batch_idx=batch_idx, - channel_idx=channel_idx, iteration=i, - ax=fig.axes[axes_idx['plot_pixel_values']]) - if 'plot_loss' in included_plots: + fig.axes[axes_idx["plot_pixel_values"]].clear() + plot_pixel_values( + mad, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=i, + ax=fig.axes[axes_idx["plot_pixel_values"]], + ) + if "plot_loss" in included_plots: # loss always contains values from every iteration, but everything # else will be subsampled. - x_val = i*mad.store_progress + x_val = i * mad.store_progress scat[0].set_offsets((x_val, mad.reference_metric_loss[x_val])) scat[1].set_offsets((x_val, mad.optimized_metric_loss[x_val])) artists.extend(scat) @@ -1157,22 +1284,28 @@ def movie_plot(i): return artists # don't need an init_func, since we handle initialization ourselves - anim = mpl.animation.FuncAnimation(fig, movie_plot, - frames=len(mad.saved_mad_image), - blit=True, interval=1000./framerate, - repeat=False) + anim = mpl.animation.FuncAnimation( + fig, + movie_plot, + frames=len(mad.saved_mad_image), + blit=True, + interval=1000.0 / framerate, + repeat=False, + ) plt.close(fig) return anim -def display_mad_image_all(mad_metric1_min: MADCompetition, - mad_metric2_min: MADCompetition, - mad_metric1_max: MADCompetition, - mad_metric2_max: MADCompetition, - metric1_name: Optional[str] = None, - metric2_name: Optional[str] = None, - zoom: Union[int, float] = 1, - **kwargs) -> mpl.figure.Figure: +def display_mad_image_all( + mad_metric1_min: MADCompetition, + mad_metric2_min: MADCompetition, + mad_metric1_max: MADCompetition, + mad_metric2_max: MADCompetition, + metric1_name: Optional[str] = None, + metric2_name: Optional[str] = None, + zoom: Union[int, float] = 1, + **kwargs, +) -> mpl.figure.Figure: """Display all MAD Competition images. To generate a full set of MAD Competition images, you need four instances: @@ -1216,49 +1349,74 @@ def display_mad_image_all(mad_metric1_min: MADCompetition, # this is a bit of a hack right now, because they don't all have same # initial image if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: metric2_name = mad_metric2_min.optimized_metric.__name__ - fig = pt_make_figure(3, 2, [zoom * i for i in - mad_metric1_min.image.shape[-2:]]) + fig = pt_make_figure( + 3, 2, [zoom * i for i in mad_metric1_min.image.shape[-2:]] + ) mads = [mad_metric1_min, mad_metric1_max, mad_metric2_min, mad_metric2_max] - titles = [f'Minimize {metric1_name}', f'Maximize {metric1_name}', - f'Minimize {metric2_name}', f'Maximize {metric2_name}'] + titles = [ + f"Minimize {metric1_name}", + f"Maximize {metric1_name}", + f"Minimize {metric2_name}", + f"Maximize {metric2_name}", + ] # we're only plotting one image here, so if the user wants multiple # channels, they must be RGB - if kwargs.get('channel_idx', None) is None and mad_metric1_min.initial_image.shape[1] > 1: + if ( + kwargs.get("channel_idx", None) is None + and mad_metric1_min.initial_image.shape[1] > 1 + ): as_rgb = True else: as_rgb = False - display.imshow(mad_metric1_min.image, ax=fig.axes[0], - title='Reference image', zoom=zoom, as_rgb=as_rgb, - **kwargs) - display.imshow(mad_metric1_min.initial_image, ax=fig.axes[1], - title='Initial (noisy) image', zoom=zoom, as_rgb=as_rgb, - **kwargs) + display.imshow( + mad_metric1_min.image, + ax=fig.axes[0], + title="Reference image", + zoom=zoom, + as_rgb=as_rgb, + **kwargs, + ) + display.imshow( + mad_metric1_min.initial_image, + ax=fig.axes[1], + title="Initial (noisy) image", + zoom=zoom, + as_rgb=as_rgb, + **kwargs, + ) for ax, mad, title in zip(fig.axes[2:], mads, titles): - display_mad_image(mad, zoom=zoom, ax=ax, title=title, - **kwargs) + display_mad_image(mad, zoom=zoom, ax=ax, title=title, **kwargs) return fig -def plot_loss_all(mad_metric1_min: MADCompetition, - mad_metric2_min: MADCompetition, - mad_metric1_max: MADCompetition, - mad_metric2_max: MADCompetition, - metric1_name: Optional[str] = None, - metric2_name: Optional[str] = None, - metric1_kwargs: Dict = {'c': 'C0'}, - metric2_kwargs: Dict = {'c': 'C1'}, - min_kwargs: Dict = {'linestyle': '--'}, - max_kwargs: Dict = {'linestyle': '-'}, - figsize=(10, 5)) -> mpl.figure.Figure: +def plot_loss_all( + mad_metric1_min: MADCompetition, + mad_metric2_min: MADCompetition, + mad_metric1_max: MADCompetition, + mad_metric2_max: MADCompetition, + metric1_name: Optional[str] = None, + metric2_name: Optional[str] = None, + metric1_kwargs: Dict = {"c": "C0"}, + metric2_kwargs: Dict = {"c": "C1"}, + min_kwargs: Dict = {"linestyle": "--"}, + max_kwargs: Dict = {"linestyle": "-"}, + figsize=(10, 5), +) -> mpl.figure.Figure: """Plot loss for full set of MAD Competiton instances. To generate a full set of MAD Competition images, you need four instances: @@ -1306,26 +1464,52 @@ def plot_loss_all(mad_metric1_min: MADCompetition, """ if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError("All four instances of MADCompetition must have same image!") + raise ValueError( + "All four instances of MADCompetition must have same image!" + ) if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: metric2_name = mad_metric2_min.optimized_metric.__name__ fig, axes = plt.subplots(1, 2, figsize=figsize) - plot_loss(mad_metric1_min, axes=axes, label=f'Minimize {metric1_name}', - **metric1_kwargs, **min_kwargs) - plot_loss(mad_metric1_max, axes=axes, label=f'Maximize {metric1_name}', - **metric1_kwargs, **max_kwargs) + plot_loss( + mad_metric1_min, + axes=axes, + label=f"Minimize {metric1_name}", + **metric1_kwargs, + **min_kwargs, + ) + plot_loss( + mad_metric1_max, + axes=axes, + label=f"Maximize {metric1_name}", + **metric1_kwargs, + **max_kwargs, + ) # we pass the axes backwards here because the fixed and synthesis metrics are the opposite as they are in the instances above. - plot_loss(mad_metric2_min, axes=axes[::-1], label=f'Minimize {metric2_name}', - **metric2_kwargs, **min_kwargs) - plot_loss(mad_metric2_max, axes=axes[::-1], label=f'Maximize {metric2_name}', - **metric2_kwargs, **max_kwargs) - axes[0].set(ylabel='Loss', title=metric2_name) - axes[1].set(ylabel='Loss', title=metric1_name) - axes[1].legend(loc='center left', bbox_to_anchor=(1.1, .5)) + plot_loss( + mad_metric2_min, + axes=axes[::-1], + label=f"Minimize {metric2_name}", + **metric2_kwargs, + **min_kwargs, + ) + plot_loss( + mad_metric2_max, + axes=axes[::-1], + label=f"Maximize {metric2_name}", + **metric2_kwargs, + **max_kwargs, + ) + axes[0].set(ylabel="Loss", title=metric2_name) + axes[1].set(ylabel="Loss", title=metric1_name) + axes[1].legend(loc="center left", bbox_to_anchor=(1.1, 0.5)) return fig diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index 616bdb20..aa0972c3 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -1,4 +1,5 @@ """Synthesize model metamers.""" + import torch import re import numpy as np @@ -6,7 +7,11 @@ from tqdm.auto import tqdm from ..tools import optim, display, signal, data -from ..tools.validate import validate_input, validate_model, validate_coarse_to_fine +from ..tools.validate import ( + validate_input, + validate_model, + validate_coarse_to_fine, +) from ..tools.convergence import coarse_to_fine_enough, loss_convergence from typing import Union, Tuple, Callable, List, Dict, Optional from typing_extensions import Literal @@ -82,15 +87,24 @@ class Metamer(OptimizedSynthesis): http://www.cns.nyu.edu/~lcv/texture/ """ - def __init__(self, image: Tensor, model: torch.nn.Module, - loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1), - initial_image: Optional[Tensor] = None): + + def __init__( + self, + image: Tensor, + model: torch.nn.Module, + loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, + range_penalty_lambda: float = 0.1, + allowed_range: Tuple[float, float] = (0, 1), + initial_image: Optional[Tensor] = None, + ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) - validate_model(model, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) + validate_model( + model, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) self._model = model self._image = image self._image_shape = image.shape @@ -123,22 +137,29 @@ def _initialize(self, initial_image: Optional[Tensor] = None): metamer.requires_grad_() else: if initial_image.ndimension() < 4: - raise ValueError("initial_image must be torch.Size([n_batch" - ", n_channels, im_height, im_width]) but got " - f"{initial_image.size()}") + raise ValueError( + "initial_image must be torch.Size([n_batch" + ", n_channels, im_height, im_width]) but got " + f"{initial_image.size()}" + ) if initial_image.size() != self.image.size(): raise ValueError("initial_image and image must be same size!") metamer = initial_image.clone().detach() - metamer = metamer.to(dtype=self.image.dtype, device=self.image.device) + metamer = metamer.to( + dtype=self.image.dtype, device=self.image.device + ) metamer.requires_grad_() self._metamer = metamer - def synthesize(self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, - stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, - ): + def synthesize( + self, + max_iter: int = 100, + optimizer: Optional[torch.optim.Optimizer] = None, + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, + store_progress: Union[bool, int] = False, + stop_criterion: float = 1e-4, + stop_iters_to_check: int = 50, + ): r"""Synthesize a metamer. Update the pixels of ``initial_image`` until its representation matches @@ -197,8 +218,11 @@ def synthesize(self, max_iter: int = 100, pbar.close() - def objective_function(self, metamer_representation: Optional[Tensor] = None, - target_representation: Optional[Tensor] = None) -> Tensor: + def objective_function( + self, + metamer_representation: Optional[Tensor] = None, + target_representation: Optional[Tensor] = None, + ) -> Tensor: """Compute the metamer synthesis loss. This calls self.loss_function on ``metamer_representation`` and @@ -222,10 +246,10 @@ def objective_function(self, metamer_representation: Optional[Tensor] = None, metamer_representation = self.model(self.metamer) if target_representation is None: target_representation = self.target_representation - loss = self.loss_function(metamer_representation, - target_representation) - range_penalty = optim.penalize_range(self.metamer, - self.allowed_range) + loss = self.loss_function( + metamer_representation, target_representation + ) + range_penalty = optim.penalize_range(self.metamer, self.allowed_range) return loss + self.range_penalty_lambda * range_penalty def _optimizer_step(self, pbar: tqdm) -> Tensor: @@ -249,23 +273,28 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, - dim=None) + grad_norm = torch.linalg.vector_norm( + self.metamer.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm(self.metamer - last_iter_metamer, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self.metamer - last_iter_metamer, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict(loss=f"{loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]['lr'], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}")) + OrderedDict( + loss=f"{loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]["lr"], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + ) + ) return loss def _check_convergence(self, stop_criterion, stop_iters_to_check): @@ -299,18 +328,20 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): """ return loss_convergence(self, stop_criterion, stop_iters_to_check) - def _initialize_optimizer(self, - optimizer: Optional[torch.optim.Optimizer], - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler]): + def _initialize_optimizer( + self, + optimizer: Optional[torch.optim.Optimizer], + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler], + ): """Initialize optimizer and scheduler.""" # this uses the OptimizedSynthesis setter - super()._initialize_optimizer(optimizer, 'metamer') + super()._initialize_optimizer(optimizer, "metamer") self.scheduler = scheduler for pg in self.optimizer.param_groups: # initialize initial_lr if it's not here. Scheduler should add it # if it's not None. - if 'initial_lr' not in pg: - pg['initial_lr'] = pg['lr'] + if "initial_lr" not in pg: + pg["initial_lr"] = pg["lr"] def _store(self, i: int) -> bool: """Store metamer, if appropriate. @@ -330,7 +361,7 @@ def _store(self, i: int) -> bool: """ if self.store_progress and (i % self.store_progress == 0): # want these to always be on cpu, to reduce memory use for GPUs - self._saved_metamer.append(self.metamer.clone().to('cpu')) + self._saved_metamer.append(self.metamer.clone().to("cpu")) stored = True else: stored = False @@ -386,13 +417,21 @@ def to(self, *args, **kwargs): dtype and device for all parameters and buffers in this module """ - attrs = ['_image', '_target_representation', - '_metamer', '_model', '_saved_metamer'] + attrs = [ + "_image", + "_target_representation", + "_metamer", + "_model", + "_saved_metamer", + ] super().to(*args, attrs=attrs, **kwargs) - def load(self, file_path: str, - map_location: Optional[str] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: Optional[str] = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Metamer`` object -- we will @@ -429,33 +468,48 @@ def load(self, file_path: str, """ self._load(file_path, map_location, **pickle_load_args) - def _load(self, file_path: str, - map_location: Optional[str] = None, - additional_check_attributes: List[str] = [], - additional_check_loss_functions: List[str] = [], - **pickle_load_args): + def _load( + self, + file_path: str, + map_location: Optional[str] = None, + additional_check_attributes: List[str] = [], + additional_check_loss_functions: List[str] = [], + **pickle_load_args, + ): r"""Helper function for loading. Users interact with ``load`` (without the underscore), this is to allow subclasses to specify additional attributes or loss functions to check. """ - check_attributes = ['_image', '_target_representation', - '_range_penalty_lambda', '_allowed_range'] + check_attributes = [ + "_image", + "_target_representation", + "_range_penalty_lambda", + "_allowed_range", + ] check_attributes += additional_check_attributes - check_loss_functions = ['loss_function'] + check_loss_functions = ["loss_function"] check_loss_functions += additional_check_loss_functions - super().load(file_path, map_location=map_location, - check_attributes=check_attributes, - check_loss_functions=check_loss_functions, - **pickle_load_args) + super().load( + file_path, + map_location=map_location, + check_attributes=check_attributes, + check_loss_functions=check_loss_functions, + **pickle_load_args, + ) # make this require a grad again self.metamer.requires_grad_() # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if len(self._saved_metamer) and self._saved_metamer[0].device.type != 'cpu': - self._saved_metamer = [met.to('cpu') for met in self._saved_metamer] + if ( + len(self._saved_metamer) + and self._saved_metamer[0].device.type != "cpu" + ): + self._saved_metamer = [ + met.to("cpu") for met in self._saved_metamer + ] @property def model(self): @@ -519,7 +573,7 @@ class MetamerCTF(Metamer): scale separately (ignoring the others), then with respect to all of them at the end. (see ``Metamer`` tutorial for more details). - + Attributes ---------- target_representation : torch.Tensor @@ -549,46 +603,63 @@ class MetamerCTF(Metamer): scales_finished : list or None List of scales that we've finished optimizing. """ - def __init__(self, image: Tensor, model: torch.nn.Module, - loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1), - initial_image: Optional[Tensor] = None, - coarse_to_fine: Literal['together', 'separate'] = 'together'): - super().__init__(image, model, loss_function, range_penalty_lambda, - allowed_range, initial_image) + + def __init__( + self, + image: Tensor, + model: torch.nn.Module, + loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, + range_penalty_lambda: float = 0.1, + allowed_range: Tuple[float, float] = (0, 1), + initial_image: Optional[Tensor] = None, + coarse_to_fine: Literal["together", "separate"] = "together", + ): + super().__init__( + image, + model, + loss_function, + range_penalty_lambda, + allowed_range, + initial_image, + ) self._init_ctf(coarse_to_fine) - def _init_ctf(self, coarse_to_fine: Literal['together', 'separate']): + def _init_ctf(self, coarse_to_fine: Literal["together", "separate"]): """Initialize stuff related to coarse-to-fine.""" # this will hold the reduced representation of the target image. - if coarse_to_fine not in ['separate', 'together']: - raise ValueError(f"Don't know how to handle value {coarse_to_fine}!" - " Must be one of: 'separate', 'together'") + if coarse_to_fine not in ["separate", "together"]: + raise ValueError( + f"Don't know how to handle value {coarse_to_fine}!" + " Must be one of: 'separate', 'together'" + ) self._ctf_target_representation = None - validate_coarse_to_fine(self.model, image_shape=self.image.shape, - device=self.image.device) + validate_coarse_to_fine( + self.model, image_shape=self.image.shape, device=self.image.device + ) # if self.scales is not None, we're continuing a previous version # and want to continue. this list comprehension creates a new # object, so we don't modify model.scales self._scales = [i for i in self.model.scales[:-1]] - if coarse_to_fine == 'separate': + if coarse_to_fine == "separate": self._scales += [self.model.scales[-1]] - self._scales += ['all'] + self._scales += ["all"] self._scales_timing = dict((k, []) for k in self.scales) self._scales_timing[self.scales[0]].append(0) self._scales_loss = [] self._scales_finished = [] self._coarse_to_fine = coarse_to_fine - def synthesize(self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, - stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, - change_scale_criterion: Optional[float] = 1e-2, - ctf_iters_to_check: int = 50, - ): + def synthesize( + self, + max_iter: int = 100, + optimizer: Optional[torch.optim.Optimizer] = None, + scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, + store_progress: Union[bool, int] = False, + stop_criterion: float = 1e-4, + stop_iters_to_check: int = 50, + change_scale_criterion: Optional[float] = 1e-2, + ctf_iters_to_check: int = 50, + ): r"""Synthesize a metamer. Update the pixels of ``initial_image`` until its representation matches @@ -633,9 +704,13 @@ def synthesize(self, max_iter: int = 100, switch scales. """ - if (change_scale_criterion is not None) and (stop_criterion >= change_scale_criterion): - raise ValueError("stop_criterion must be strictly less than " - "change_scale_criterion, or things get weird!") + if (change_scale_criterion is not None) and ( + stop_criterion >= change_scale_criterion + ): + raise ValueError( + "stop_criterion must be strictly less than " + "change_scale_criterion, or things get weird!" + ) # initialize the optimizer and scheduler self._initialize_optimizer(optimizer, scheduler) @@ -643,7 +718,6 @@ def synthesize(self, max_iter: int = 100, # get ready to store progress self.store_progress = store_progress - pbar = tqdm(range(max_iter)) for i in pbar: @@ -651,22 +725,27 @@ def synthesize(self, max_iter: int = 100, # iterations and will be correct across calls to `synthesize` self._store(len(self.losses)) - loss = self._optimizer_step(pbar, change_scale_criterion, ctf_iters_to_check) + loss = self._optimizer_step( + pbar, change_scale_criterion, ctf_iters_to_check + ) if not torch.isfinite(loss): raise ValueError("Found a NaN in loss during optimization.") - if self._check_convergence(i, stop_criterion, stop_iters_to_check, - ctf_iters_to_check): + if self._check_convergence( + i, stop_criterion, stop_iters_to_check, ctf_iters_to_check + ): warnings.warn("Loss has converged, stopping synthesis") break pbar.close() - def _optimizer_step(self, pbar: tqdm, - change_scale_criterion: float, - ctf_iters_to_check: int - ) -> Tensor: + def _optimizer_step( + self, + pbar: tqdm, + change_scale_criterion: float, + ctf_iters_to_check: int, + ) -> Tensor: r"""Compute and propagate gradients, then step the optimizer to update metamer. Parameters @@ -695,19 +774,31 @@ def _optimizer_step(self, pbar: tqdm, # has stopped declining and, if so, switch to the next scale. Then # we're checking if self.scales_loss is long enough to check # ctf_iters_to_check back. - if len(self.scales) > 1 and len(self.scales_loss) >= ctf_iters_to_check: + if ( + len(self.scales) > 1 + and len(self.scales_loss) >= ctf_iters_to_check + ): # Now we check whether loss has decreased less than # change_scale_criterion - if ((change_scale_criterion is None) or abs(self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check]) < change_scale_criterion): + if (change_scale_criterion is None) or abs( + self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check] + ) < change_scale_criterion: # and finally we check whether we've been optimizing this # scale for ctf_iters_to_check - if len(self.losses) - self.scales_timing[self.scales[0]][0] >= ctf_iters_to_check: - self._scales_timing[self.scales[0]].append(len(self.losses)-1) + if ( + len(self.losses) - self.scales_timing[self.scales[0]][0] + >= ctf_iters_to_check + ): + self._scales_timing[self.scales[0]].append( + len(self.losses) - 1 + ) self._scales_finished.append(self._scales.pop(0)) - self._scales_timing[self.scales[0]].append(len(self.losses)) + self._scales_timing[self.scales[0]].append( + len(self.losses) + ) # reset optimizer's lr. for pg in self.optimizer.param_groups: - pg['lr'] = pg['initial_lr'] + pg["lr"] = pg["initial_lr"] # reset ctf target representation, so we update it on # next pass self._ctf_target_representation = None @@ -715,25 +806,30 @@ def _optimizer_step(self, pbar: tqdm, self._scales_loss.append(loss.item()) self._losses.append(overall_loss.item()) - grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, - dim=None) + grad_norm = torch.linalg.vector_norm( + self.metamer.grad.data, ord=2, dim=None + ) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler if self.scheduler is not None: self.scheduler.step(loss.item()) - pixel_change_norm = torch.linalg.vector_norm(self.metamer - last_iter_metamer, - ord=2, dim=None) + pixel_change_norm = torch.linalg.vector_norm( + self.metamer - last_iter_metamer, ord=2, dim=None + ) self._pixel_change_norm.append(pixel_change_norm.item()) # add extra info here if you want it to show up in progress bar pbar.set_postfix( - OrderedDict(loss=f"{overall_loss.item():.04e}", - learning_rate=self.optimizer.param_groups[0]['lr'], - gradient_norm=f"{grad_norm.item():.04e}", - pixel_change_norm=f"{pixel_change_norm.item():.04e}", - current_scale=self.scales[0], - current_scale_loss=f'{loss.item():.04e}')) + OrderedDict( + loss=f"{overall_loss.item():.04e}", + learning_rate=self.optimizer.param_groups[0]["lr"], + gradient_norm=f"{grad_norm.item():.04e}", + pixel_change_norm=f"{pixel_change_norm.item():.04e}", + current_scale=self.scales[0], + current_scale_loss=f"{loss.item():.04e}", + ) + ) return overall_loss def _closure(self) -> Tuple[Tensor, Tensor]: @@ -763,12 +859,12 @@ def _closure(self) -> Tuple[Tensor, Tensor]: self.optimizer.zero_grad() analyze_kwargs = {} # if we've reached 'all', we use the full model - if self.scales[0] != 'all': - analyze_kwargs['scales'] = [self.scales[0]] + if self.scales[0] != "all": + analyze_kwargs["scales"] = [self.scales[0]] # if 'together', then we also want all the coarser # scales - if self.coarse_to_fine == 'together': - analyze_kwargs['scales'] += self.scales_finished + if self.coarse_to_fine == "together": + analyze_kwargs["scales"] += self.scales_finished metamer_representation = self.model(self.metamer, **analyze_kwargs) # if analyze_kwargs is empty, we can just compare # metamer_representation against our cached target_representation @@ -792,9 +888,13 @@ def _closure(self) -> Tuple[Tensor, Tensor]: return loss, overall_loss - def _check_convergence(self, i: int, stop_criterion: float, - stop_iters_to_check: int, - ctf_iters_to_check: int) -> bool: + def _check_convergence( + self, + i: int, + stop_criterion: float, + stop_iters_to_check: int, + ctf_iters_to_check: int, + ) -> bool: r"""Check whether the loss has stabilized and whether we've synthesized all scales. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -837,9 +937,12 @@ def _check_convergence(self, i: int, stop_criterion: float, loss_conv = loss_convergence(self, stop_criterion, stop_iters_to_check) return loss_conv and coarse_to_fine_enough(self, i, ctf_iters_to_check) - def load(self, file_path: str, - map_location: Optional[str] = None, - **pickle_load_args): + def load( + self, + file_path: str, + map_location: Optional[str] = None, + **pickle_load_args, + ): r"""Load all relevant stuff from a .pt file. This should be called by an initialized ``Metamer`` object -- we will @@ -874,8 +977,9 @@ def load(self, file_path: str, *then* load. """ - super()._load(file_path, map_location, ['_coarse_to_fine'], - **pickle_load_args) + super()._load( + file_path, map_location, ["_coarse_to_fine"], **pickle_load_args + ) @property def coarse_to_fine(self): @@ -898,10 +1002,12 @@ def scales_finished(self): return tuple(self._scales_finished) -def plot_loss(metamer: Metamer, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: +def plot_loss( + metamer: Metamer, + iteration: Optional[int] = None, + ax: Optional[mpl.axes.Axes] = None, + **kwargs, +) -> mpl.axes.Axes: """Plot synthesis loss with log-scaled y axis. Plots ``metamer.losses`` over all iterations. Also plots a red dot at @@ -939,21 +1045,23 @@ def plot_loss(metamer: Metamer, ax = plt.gca() ax.semilogy(metamer.losses, **kwargs) try: - ax.scatter(loss_idx, metamer.losses[loss_idx], c='r') + ax.scatter(loss_idx, metamer.losses[loss_idx], c="r") except IndexError: # then there's no loss here pass - ax.set(xlabel='Synthesis iteration', ylabel='Loss') + ax.set(xlabel="Synthesis iteration", ylabel="Loss") return ax -def display_metamer(metamer: Metamer, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: +def display_metamer( + metamer: Metamer, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + zoom: Optional[float] = None, + iteration: Optional[int] = None, + ax: Optional[mpl.axes.Axes] = None, + **kwargs, +) -> mpl.axes.Axes: """Display metamer. You can specify what iteration to view by using the ``iteration`` arg. @@ -1006,17 +1114,24 @@ def display_metamer(metamer: Metamer, as_rgb = False if ax is None: ax = plt.gca() - display.imshow(image, ax=ax, title='Metamer', zoom=zoom, - batch_idx=batch_idx, channel_idx=channel_idx, - as_rgb=as_rgb, **kwargs) + display.imshow( + image, + ax=ax, + title="Metamer", + zoom=zoom, + batch_idx=batch_idx, + channel_idx=channel_idx, + as_rgb=as_rgb, + **kwargs, + ) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) return ax -def _representation_error(metamer: Metamer, - iteration: Optional[int] = None, - **kwargs) -> Tensor: +def _representation_error( + metamer: Metamer, iteration: Optional[int] = None, **kwargs +) -> Tensor: r"""Get the representation error. This is ``metamer.model(metamer) - target_representation)``. If @@ -1039,19 +1154,25 @@ def _representation_error(metamer: Metamer, """ if iteration is not None: - metamer_rep = metamer.model(metamer.saved_metamer[iteration].to(metamer.target_representation.device)) + metamer_rep = metamer.model( + metamer.saved_metamer[iteration].to( + metamer.target_representation.device + ) + ) else: metamer_rep = metamer.model(metamer.metamer, **kwargs) return metamer_rep - metamer.target_representation -def plot_representation_error(metamer: Metamer, - batch_idx: int = 0, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], None, Literal[False]] = None, - ax: Optional[mpl.axes.Axes] = None, - as_rgb: bool = False, - **kwargs) -> List[mpl.axes.Axes]: +def plot_representation_error( + metamer: Metamer, + batch_idx: int = 0, + iteration: Optional[int] = None, + ylim: Union[Tuple[float, float], None, Literal[False]] = None, + ax: Optional[mpl.axes.Axes] = None, + as_rgb: bool = False, + **kwargs, +) -> List[mpl.axes.Axes]: r"""Plot distance ratio showing how close we are to convergence. We plot ``_representation_error(metamer, iteration)``. For more details, see @@ -1088,22 +1209,31 @@ def plot_representation_error(metamer: Metamer, List of created axes """ - representation_error = _representation_error(metamer=metamer, - iteration=iteration, **kwargs) + representation_error = _representation_error( + metamer=metamer, iteration=iteration, **kwargs + ) if ax is None: ax = plt.gca() - return display.plot_representation(metamer.model, representation_error, ax, - title="Representation error", ylim=ylim, - batch_idx=batch_idx, as_rgb=as_rgb) - - -def plot_pixel_values(metamer: Metamer, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], Literal[False]] = False, - ax: Optional[mpl.axes.Axes] = None, - **kwargs) -> mpl.axes.Axes: + return display.plot_representation( + metamer.model, + representation_error, + ax, + title="Representation error", + ylim=ylim, + batch_idx=batch_idx, + as_rgb=as_rgb, + ) + + +def plot_pixel_values( + metamer: Metamer, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + ylim: Union[Tuple[float, float], Literal[False]] = False, + ax: Optional[mpl.axes.Axes] = None, + **kwargs, +) -> mpl.axes.Axes: r"""Plot histogram of pixel values of target image and its metamer. As a way to check the distributions of pixel intensities and see @@ -1135,11 +1265,12 @@ def plot_pixel_values(metamer: Metamer, Created axes. """ + def _freedman_diaconis_bins(a): """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) - iqr = np.diff(np.percentile(a, [.25, .75]))[0] + iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] if len(a) < 2: return 1 h = 2 * iqr / (len(a) ** (1 / 3)) @@ -1149,7 +1280,7 @@ def _freedman_diaconis_bins(a): else: return int(np.ceil((a.max() - a.min()) / h)) - kwargs.setdefault('alpha', .4) + kwargs.setdefault("alpha", 0.4) if iteration is None: met = metamer.metamer[batch_idx] else: @@ -1162,10 +1293,18 @@ def _freedman_diaconis_bins(a): ax = plt.gca() image = data.to_numpy(image).flatten() met = data.to_numpy(met).flatten() - ax.hist(met, bins=min(_freedman_diaconis_bins(image), 50), - label='metamer', **kwargs) - ax.hist(image, bins=min(_freedman_diaconis_bins(image), 50), - label='target image', **kwargs) + ax.hist( + met, + bins=min(_freedman_diaconis_bins(image), 50), + label="metamer", + **kwargs, + ) + ax.hist( + image, + bins=min(_freedman_diaconis_bins(image), 50), + label="target image", + **kwargs, + ) ax.legend() if ylim: ax.set_ylim(ylim) @@ -1173,8 +1312,9 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots(to_check: Union[List[str], Dict[str, float]], - to_check_name: str): +def _check_included_plots( + to_check: Union[List[str], Dict[str, float]], to_check_name: str +): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -1191,28 +1331,39 @@ def _check_included_plots(to_check: Union[List[str], Dict[str, float]], Name of the `to_check` variable, used in the error message. """ - allowed_vals = ['display_metamer', 'plot_loss', 'plot_representation_error', - 'plot_pixel_values', 'misc'] + allowed_vals = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + "plot_pixel_values", + "misc", + ] try: vals = to_check.keys() except AttributeError: vals = to_check not_allowed = [v for v in vals if v not in allowed_vals] if not_allowed: - raise ValueError(f'{to_check_name} contained value(s) {not_allowed}! ' - f'Only {allowed_vals} are permissible!') - - -def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = ['display_metamer', - 'plot_loss', - 'plot_representation_error'], - display_metamer_width: float = 1, - plot_loss_width: float = 1, - plot_representation_error_width: float = 1, - plot_pixel_values_width: float = 1) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: + raise ValueError( + f"{to_check_name} contained value(s) {not_allowed}! " + f"Only {allowed_vals} are permissible!" + ) + + +def _setup_synthesis_fig( + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float, float]] = None, + included_plots: List[str] = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + ], + display_metamer_width: float = 1, + plot_loss_width: float = 1, + plot_representation_error_width: float = 1, + plot_pixel_values_width: float = 1, +) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -1269,68 +1420,79 @@ def _setup_synthesis_fig(fig: Optional[mpl.figure.Figure] = None, if "display_metamer" in included_plots: n_subplots += 1 width_ratios.append(display_metamer_width) - if 'display_metamer' not in axes_idx.keys(): - axes_idx['display_metamer'] = data._find_min_int(axes_idx.values()) + if "display_metamer" not in axes_idx.keys(): + axes_idx["display_metamer"] = data._find_min_int(axes_idx.values()) if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if 'plot_loss' not in axes_idx.keys(): - axes_idx['plot_loss'] = data._find_min_int(axes_idx.values()) + if "plot_loss" not in axes_idx.keys(): + axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) if "plot_representation_error" in included_plots: n_subplots += 1 width_ratios.append(plot_representation_error_width) - if 'plot_representation_error' not in axes_idx.keys(): - axes_idx['plot_representation_error'] = data._find_min_int(axes_idx.values()) + if "plot_representation_error" not in axes_idx.keys(): + axes_idx["plot_representation_error"] = data._find_min_int( + axes_idx.values() + ) if "plot_pixel_values" in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if 'plot_pixel_values' not in axes_idx.keys(): - axes_idx['plot_pixel_values'] = data._find_min_int(axes_idx.values()) + if "plot_pixel_values" not in axes_idx.keys(): + axes_idx["plot_pixel_values"] = data._find_min_int( + axes_idx.values() + ) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: # we want (5, 5) for each subplot, with a bit of room between # each subplot - figsize = ((width_ratios*5).sum() + width_ratios.sum()-1, 5) + figsize = ((width_ratios * 5).sum() + width_ratios.sum() - 1, 5) width_ratios = width_ratios / width_ratios.sum() - fig, axes = plt.subplots(1, n_subplots, figsize=figsize, - gridspec_kw={'width_ratios': width_ratios}) + fig, axes = plt.subplots( + 1, + n_subplots, + figsize=figsize, + gridspec_kw={"width_ratios": width_ratios}, + ) if n_subplots == 1: axes = [axes] else: axes = fig.axes # make sure misc contains all the empty axes - misc_axes = axes_idx.get('misc', []) - if not hasattr(misc_axes, '__iter__'): + misc_axes = axes_idx.get("misc", []) + if not hasattr(misc_axes, "__iter__"): misc_axes = [misc_axes] all_axes = [] for i in axes_idx.values(): # so if it's a list of ints - if hasattr(i, '__iter__'): + if hasattr(i, "__iter__"): all_axes.extend(i) else: all_axes.append(i) misc_axes += [i for i, _ in enumerate(fig.axes) if i not in all_axes] - axes_idx['misc'] = misc_axes + axes_idx["misc"] = misc_axes return fig, axes, axes_idx -def plot_synthesis_status(metamer: Metamer, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], None, Literal[False]] = None, - vrange: Union[Tuple[float, float], str] = 'indep1', - zoom: Optional[float] = None, - plot_representation_error_as_rgb: bool = False, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = ['display_metamer', - 'plot_loss', - 'plot_representation_error'], - width_ratios: Dict[str, float] = {}, - ) -> Tuple[mpl.figure.Figure, Dict[str, int]]: +def plot_synthesis_status( + metamer: Metamer, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + iteration: Optional[int] = None, + ylim: Union[Tuple[float, float], None, Literal[False]] = None, + vrange: Union[Tuple[float, float], str] = "indep1", + zoom: Optional[float] = None, + plot_representation_error_as_rgb: bool = False, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float, float]] = None, + included_plots: List[str] = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + ], + width_ratios: Dict[str, float] = {}, +) -> Tuple[mpl.figure.Figure, Dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create three @@ -1410,19 +1572,23 @@ def plot_synthesis_status(metamer: Metamer, """ if iteration is not None and not metamer.store_progress: - raise ValueError("synthesis() was run with store_progress=False, " - "cannot specify which iteration to plot (only" - " last one, with iteration=None)") + raise ValueError( + "synthesis() was run with store_progress=False, " + "cannot specify which iteration to plot (only" + " last one, with iteration=None)" + ) if metamer.metamer.ndim not in [3, 4]: - raise ValueError("plot_synthesis_status() expects 3 or 4d data;" - "unexpected behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') - width_ratios = {f'{k}_width': v for k, v in width_ratios.items()} - fig, axes, axes_idx = _setup_synthesis_fig(fig, axes_idx, figsize, - included_plots, - **width_ratios) + raise ValueError( + "plot_synthesis_status() expects 3 or 4d data;" + "unexpected behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") + width_ratios = {f"{k}_width": v for k, v in width_ratios.items()} + fig, axes, axes_idx = _setup_synthesis_fig( + fig, axes_idx, figsize, included_plots, **width_ratios + ) def check_iterables(i, vals): for j in vals: @@ -1436,48 +1602,64 @@ def check_iterables(i, vals): return True if "display_metamer" in included_plots: - display_metamer(metamer, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['display_metamer']], - zoom=zoom, vrange=vrange) + display_metamer( + metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["display_metamer"]], + zoom=zoom, + vrange=vrange, + ) if "plot_loss" in included_plots: - plot_loss(metamer, iteration=iteration, ax=axes[axes_idx['plot_loss']]) + plot_loss(metamer, iteration=iteration, ax=axes[axes_idx["plot_loss"]]) if "plot_representation_error" in included_plots: - plot_representation_error(metamer, batch_idx=batch_idx, - iteration=iteration, - ax=axes[axes_idx['plot_representation_error']], - ylim=ylim, - as_rgb=plot_representation_error_as_rgb) + plot_representation_error( + metamer, + batch_idx=batch_idx, + iteration=iteration, + ax=axes[axes_idx["plot_representation_error"]], + ylim=ylim, + as_rgb=plot_representation_error_as_rgb, + ) # this can add a bunch of axes, so this will try and figure # them out - new_axes = [i for i, _ in enumerate(fig.axes) if not - check_iterables(i, axes_idx.values())] + [axes_idx['plot_representation_error']] - axes_idx['plot_representation_error'] = new_axes + new_axes = [ + i + for i, _ in enumerate(fig.axes) + if not check_iterables(i, axes_idx.values()) + ] + [axes_idx["plot_representation_error"]] + axes_idx["plot_representation_error"] = new_axes if "plot_pixel_values" in included_plots: - plot_pixel_values(metamer, batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=iteration, - ax=axes[axes_idx['plot_pixel_values']]) + plot_pixel_values( + metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=iteration, + ax=axes[axes_idx["plot_pixel_values"]], + ) return fig, axes_idx -def animate(metamer: Metamer, - framerate: int = 10, - batch_idx: int = 0, - channel_idx: Optional[int] = None, - ylim: Union[str, None, Tuple[float, float], Literal[False]] = None, - vrange: Union[Tuple[float, float], str] = (0, 1), - zoom: Optional[float] = None, - plot_representation_error_as_rgb: bool = False, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = ['display_metamer', - 'plot_loss', - 'plot_representation_error'], - width_ratios: Dict[str, float] = {}, - ) -> mpl.animation.FuncAnimation: +def animate( + metamer: Metamer, + framerate: int = 10, + batch_idx: int = 0, + channel_idx: Optional[int] = None, + ylim: Union[str, None, Tuple[float, float], Literal[False]] = None, + vrange: Union[Tuple[float, float], str] = (0, 1), + zoom: Optional[float] = None, + plot_representation_error_as_rgb: bool = False, + fig: Optional[mpl.figure.Figure] = None, + axes_idx: Dict[str, int] = {}, + figsize: Optional[Tuple[float, float]] = None, + included_plots: List[str] = [ + "display_metamer", + "plot_loss", + "plot_representation_error", + ], + width_ratios: Dict[str, float] = {}, +) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. This is essentially the figure produced by @@ -1583,119 +1765,150 @@ def animate(metamer: Metamer, """ if not metamer.store_progress: - raise ValueError("synthesize() was run with store_progress=False," - " cannot animate!") + raise ValueError( + "synthesize() was run with store_progress=False," + " cannot animate!" + ) if metamer.metamer.ndim not in [3, 4]: - raise ValueError("animate() expects 3 or 4d data; unexpected" - " behavior will result otherwise!") - _check_included_plots(included_plots, 'included_plots') - _check_included_plots(width_ratios, 'width_ratios') - _check_included_plots(axes_idx, 'axes_idx') + raise ValueError( + "animate() expects 3 or 4d data; unexpected" + " behavior will result otherwise!" + ) + _check_included_plots(included_plots, "included_plots") + _check_included_plots(width_ratios, "width_ratios") + _check_included_plots(axes_idx, "axes_idx") if metamer.target_representation.ndimension() == 4: # we have to do this here so that we set the # ylim_rescale_interval such that we never rescale ylim # (rescaling ylim messes up an image axis) ylim = False try: - if ylim.startswith('rescale'): + if ylim.startswith("rescale"): try: - ylim_rescale_interval = int(ylim.replace('rescale', '')) + ylim_rescale_interval = int(ylim.replace("rescale", "")) except ValueError: # then there's nothing we can convert to an int there - ylim_rescale_interval = int((metamer.saved_metamer.shape[0] - 1) // 10) + ylim_rescale_interval = int( + (metamer.saved_metamer.shape[0] - 1) // 10 + ) if ylim_rescale_interval == 0: - ylim_rescale_interval = int(metamer.saved_metamer.shape[0] - 1) + ylim_rescale_interval = int( + metamer.saved_metamer.shape[0] - 1 + ) ylim = None else: raise ValueError("Don't know how to handle ylim %s!" % ylim) except AttributeError: # this way we'll never rescale - ylim_rescale_interval = len(metamer.saved_metamer)+1 + ylim_rescale_interval = len(metamer.saved_metamer) + 1 # we run plot_synthesis_status to initialize the figure if either fig is # None or if there are no titles on any axes, which we assume means that # it's an empty figure if fig is None or not any([ax.get_title() for ax in fig.axes]): - fig, axes_idx = plot_synthesis_status(metamer=metamer, - batch_idx=batch_idx, - channel_idx=channel_idx, - iteration=0, figsize=figsize, - ylim=ylim, vrange=vrange, - zoom=zoom, fig=fig, - axes_idx=axes_idx, - included_plots=included_plots, - plot_representation_error_as_rgb=plot_representation_error_as_rgb, - width_ratios=width_ratios) + fig, axes_idx = plot_synthesis_status( + metamer=metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=0, + figsize=figsize, + ylim=ylim, + vrange=vrange, + zoom=zoom, + fig=fig, + axes_idx=axes_idx, + included_plots=included_plots, + plot_representation_error_as_rgb=plot_representation_error_as_rgb, + width_ratios=width_ratios, + ) # grab the artist for the second plot (we don't need to do this for the # metamer or representation plot, because we use the update_plot # function for that) - if 'plot_loss' in included_plots: - scat = fig.axes[axes_idx['plot_loss']].collections[0] + if "plot_loss" in included_plots: + scat = fig.axes[axes_idx["plot_loss"]].collections[0] # can have multiple plots - if 'plot_representation_error' in included_plots: + if "plot_representation_error" in included_plots: try: - rep_error_axes = [fig.axes[i] for i in axes_idx['plot_representation_error']] + rep_error_axes = [ + fig.axes[i] for i in axes_idx["plot_representation_error"] + ] except TypeError: # in this case, axes_idx['plot_representation_error'] is not iterable and so is # a single value - rep_error_axes = [fig.axes[axes_idx['plot_representation_error']]] + rep_error_axes = [fig.axes[axes_idx["plot_representation_error"]]] else: rep_error_axes = [] # can also have multiple plots if metamer.target_representation.ndimension() == 4: - if 'plot_representation_error' in included_plots: - warnings.warn("Looks like representation is image-like, haven't fully thought out how" - " to best handle rescaling color ranges yet!") + if "plot_representation_error" in included_plots: + warnings.warn( + "Looks like representation is image-like, haven't fully thought out how" + " to best handle rescaling color ranges yet!" + ) # replace the bit of the title that specifies the range, # since we don't make any promises about that. we have to do # this here because we need the figure to have been created for ax in rep_error_axes: - ax.set_title(re.sub(r'\n range: .* \n', '\n\n', ax.get_title())) + ax.set_title(re.sub(r"\n range: .* \n", "\n\n", ax.get_title())) def movie_plot(i): artists = [] - if 'display_metamer' in included_plots: - artists.extend(display.update_plot(fig.axes[axes_idx['display_metamer']], - data=metamer.saved_metamer[i], - batch_idx=batch_idx)) - if 'plot_representation_error' in included_plots: - rep_error = _representation_error(metamer, - iteration=i) + if "display_metamer" in included_plots: + artists.extend( + display.update_plot( + fig.axes[axes_idx["display_metamer"]], + data=metamer.saved_metamer[i], + batch_idx=batch_idx, + ) + ) + if "plot_representation_error" in included_plots: + rep_error = _representation_error(metamer, iteration=i) # we pass rep_error_axes to update, and we've grabbed # the right things above - artists.extend(display.update_plot(rep_error_axes, - batch_idx=batch_idx, - model=metamer.model, - data=rep_error)) + artists.extend( + display.update_plot( + rep_error_axes, + batch_idx=batch_idx, + model=metamer.model, + data=rep_error, + ) + ) # again, we know that rep_error_axes contains all the axes # with the representation ratio info - if ((i+1) % ylim_rescale_interval) == 0: + if ((i + 1) % ylim_rescale_interval) == 0: if metamer.target_representation.ndimension() == 3: - display.rescale_ylim(rep_error_axes, - rep_error) - if 'plot_pixel_values' in included_plots: + display.rescale_ylim(rep_error_axes, rep_error) + if "plot_pixel_values" in included_plots: # this is the dumbest way to do this, but it's simple -- # clearing the axes can cause problems if the user has, for # example, changed the tick locator or formatter. not sure how # to handle this best right now - fig.axes[axes_idx['plot_pixel_values']].clear() - plot_pixel_values(metamer, batch_idx=batch_idx, - channel_idx=channel_idx, iteration=i, - ax=fig.axes[axes_idx['plot_pixel_values']]) - if 'plot_loss'in included_plots: + fig.axes[axes_idx["plot_pixel_values"]].clear() + plot_pixel_values( + metamer, + batch_idx=batch_idx, + channel_idx=channel_idx, + iteration=i, + ax=fig.axes[axes_idx["plot_pixel_values"]], + ) + if "plot_loss" in included_plots: # loss always contains values from every iteration, but everything # else will be subsampled. - x_val = i*metamer.store_progress + x_val = i * metamer.store_progress scat.set_offsets((x_val, metamer.losses[x_val])) artists.append(scat) # as long as blitting is True, need to return a sequence of artists return artists # don't need an init_func, since we handle initialization ourselves - anim = mpl.animation.FuncAnimation(fig, movie_plot, - frames=len(metamer.saved_metamer), - blit=True, interval=1000./framerate, - repeat=False) + anim = mpl.animation.FuncAnimation( + fig, + movie_plot, + frames=len(metamer.saved_metamer), + blit=True, + interval=1000.0 / framerate, + repeat=False, + ) plt.close(fig) return anim diff --git a/src/plenoptic/synthesize/simple_metamer.py b/src/plenoptic/synthesize/simple_metamer.py index fd6b8f8a..916b0f6c 100644 --- a/src/plenoptic/synthesize/simple_metamer.py +++ b/src/plenoptic/synthesize/simple_metamer.py @@ -1,5 +1,5 @@ -"""Simple Metamer Class -""" +"""Simple Metamer Class""" + import torch from tqdm.auto import tqdm from .synthesis import Synthesis @@ -29,8 +29,12 @@ class SimpleMetamer(Synthesis): """ def __init__(self, image: torch.Tensor, model: torch.nn.Module): - validate_model(model, image_shape=image.shape, image_dtype=image.dtype, - device=image.device) + validate_model( + model, + image_shape=image.shape, + image_dtype=image.dtype, + device=image.device, + ) self.model = model validate_input(image) self.image = image @@ -39,8 +43,11 @@ def __init__(self, image: torch.Tensor, model: torch.nn.Module): self.optimizer = None self.losses = [] - def synthesize(self, max_iter: int = 100, - optimizer: Union[None, torch.optim.Optimizer] = None) -> torch.Tensor: + def synthesize( + self, + max_iter: int = 100, + optimizer: Union[None, torch.optim.Optimizer] = None, + ) -> torch.Tensor: """Synthesize a simple metamer. If called multiple times, will continue where we left off. @@ -62,8 +69,9 @@ def synthesize(self, max_iter: int = 100, """ if optimizer is None: if self.optimizer is None: - self.optimizer = torch.optim.Adam([self.metamer], - lr=.01, amsgrad=True) + self.optimizer = torch.optim.Adam( + [self.metamer], lr=0.01, amsgrad=True + ) else: self.optimizer = optimizer @@ -78,10 +86,10 @@ def closure(): # function. You could theoretically also just clamp metamer on # each step of the iteration, but the penalty in the loss seems # to work better in practice - loss = optim.mse(metamer_representation, - self.target_representation) - loss = loss + .1 * optim.penalize_range(self.metamer, - (0, 1)) + loss = optim.mse( + metamer_representation, self.target_representation + ) + loss = loss + 0.1 * optim.penalize_range(self.metamer, (0, 1)) self.losses.append(loss.item()) loss.backward(retain_graph=False) pbar.set_postfix(loss=loss.item()) @@ -100,8 +108,7 @@ def save(self, file_path: str): """ super().save(file_path, attrs=None) - def load(self, file_path: str, - map_location: Union[str, None] = None): + def load(self, file_path: str, map_location: Union[str, None] = None): r"""Load all relevant attributes from a .pt file. Note this operates in place and so doesn't return anything. @@ -111,9 +118,12 @@ def load(self, file_path: str, file_path The path to load the synthesis object from """ - check_attributes = ['target_representation', 'image'] - super().load(file_path, check_attributes=check_attributes, - map_location=map_location) + check_attributes = ["target_representation", "image"] + super().load( + file_path, + check_attributes=check_attributes, + map_location=map_location, + ) def to(self, *args, **kwargs): r"""Move and/or cast the parameters and buffers. @@ -146,7 +156,6 @@ def to(self, *args, **kwargs): Returns: Module: self """ - attrs = ['model', 'image', 'target_representation', - 'metamer'] + attrs = ["model", "image", "target_representation", "metamer"] super().to(*args, attrs=attrs, **kwargs) return self diff --git a/src/plenoptic/synthesize/synthesis.py b/src/plenoptic/synthesize/synthesis.py index 8c52dd8c..f6488fc0 100644 --- a/src/plenoptic/synthesize/synthesis.py +++ b/src/plenoptic/synthesize/synthesis.py @@ -1,4 +1,5 @@ """abstract synthesis super-class.""" + import abc import warnings import torch @@ -40,14 +41,16 @@ def save(self, file_path: str, attrs: Optional[List[str]] = None): # this copies the attributes dict so we don't actually remove the # model attribute in the next line attrs = {k: v for k, v in vars(self).items()} - attrs.pop('_model', None) + attrs.pop("_model", None) save_dict = {} for k in attrs: - if k == '_model': - warnings.warn("Models can be quite large and they don't change" - " over synthesis. Please be sure that you " - "actually want to save the model.") + if k == "_model": + warnings.warn( + "Models can be quite large and they don't change" + " over synthesis. Please be sure that you " + "actually want to save the model." + ) attr = getattr(self, k) # detaching the tensors avoids some headaches like the # tensors having extra hooks or the like @@ -56,11 +59,14 @@ def save(self, file_path: str, attrs: Optional[List[str]] = None): save_dict[k] = attr torch.save(save_dict, file_path) - def load(self, file_path: str, - map_location: Optional[str] = None, - check_attributes: List[str] = [], - check_loss_functions: List[str] = [], - **pickle_load_args): + def load( + self, + file_path: str, + map_location: Optional[str] = None, + check_attributes: List[str] = [], + check_loss_functions: List[str] = [], + **pickle_load_args, + ): r"""Load all relevant attributes from a .pt file. This should be called by an initialized ``Synthesis`` object -- we will @@ -98,9 +104,9 @@ def load(self, file_path: str, ``torch.load``, see that function's docstring for details. """ - tmp_dict = torch.load(file_path, - map_location=map_location, - **pickle_load_args) + tmp_dict = torch.load( + file_path, map_location=map_location, **pickle_load_args + ) if map_location is not None: device = map_location else: @@ -116,47 +122,60 @@ def load(self, file_path: str, # the initial underscore. This is because this function # needs to be able to set the attribute, which can only be # done with the hidden version. - if k.startswith('_'): + if k.startswith("_"): display_k = k[1:] else: display_k = k if not hasattr(self, k): - raise AttributeError("All values of `check_attributes` should be " - "attributes set at initialization, but got " - f"attr {display_k}!") + raise AttributeError( + "All values of `check_attributes` should be " + "attributes set at initialization, but got " + f"attr {display_k}!" + ) if isinstance(getattr(self, k), torch.Tensor): # there are two ways this can fail -- the first is if they're # the same shape but different values and the second (in the # except block) are if they're different shapes. try: - if not torch.allclose(getattr(self, k).to(tmp_dict[k].device), - tmp_dict[k], rtol=5e-2): - raise ValueError(f"Saved and initialized {display_k} are " - f"different! Initialized: {getattr(self, k)}" - f", Saved: {tmp_dict[k]}, difference: " - f"{getattr(self, k) - tmp_dict[k]}") + if not torch.allclose( + getattr(self, k).to(tmp_dict[k].device), + tmp_dict[k], + rtol=5e-2, + ): + raise ValueError( + f"Saved and initialized {display_k} are " + f"different! Initialized: {getattr(self, k)}" + f", Saved: {tmp_dict[k]}, difference: " + f"{getattr(self, k) - tmp_dict[k]}" + ) except RuntimeError as e: # we end up here if dtype or shape don't match - if 'The size of tensor a' in e.args[0]: - raise RuntimeError(f"Attribute {display_k} have different shapes in" - " saved and initialized versions! Initialized" - f": {getattr(self, k).shape}, Saved: " - f"{tmp_dict[k].shape}") - elif 'did not match' in e.args[0]: - raise RuntimeError(f"Attribute {display_k} has different dtype in " - "saved and initialized versions! Initialized" - f": {getattr(self, k).dtype}, Saved: " - f"{tmp_dict[k].dtype}") + if "The size of tensor a" in e.args[0]: + raise RuntimeError( + f"Attribute {display_k} have different shapes in" + " saved and initialized versions! Initialized" + f": {getattr(self, k).shape}, Saved: " + f"{tmp_dict[k].shape}" + ) + elif "did not match" in e.args[0]: + raise RuntimeError( + f"Attribute {display_k} has different dtype in " + "saved and initialized versions! Initialized" + f": {getattr(self, k).dtype}, Saved: " + f"{tmp_dict[k].dtype}" + ) else: raise e else: if getattr(self, k) != tmp_dict[k]: - raise ValueError(f"Saved and initialized {display_k} are different!" - f" Self: {getattr(self, k)}, " - f"Saved: {tmp_dict[k]}") + raise ValueError( + f"Saved and initialized {display_k} are different!" + f" Self: {getattr(self, k)}, " + f"Saved: {tmp_dict[k]}" + ) for k in check_loss_functions: # same as above - if k.startswith('_'): + if k.startswith("_"): display_k = k[1:] else: display_k = k @@ -165,11 +184,13 @@ def load(self, file_path: str, saved_loss = tmp_dict[k](tensor_a, tensor_b) init_loss = getattr(self, k)(tensor_a, tensor_b) if not torch.allclose(saved_loss, init_loss, rtol=1e-2): - raise ValueError(f"Saved and initialized {display_k} are " - "different! On two random tensors: " - f"Initialized: {init_loss}, Saved: " - f"{saved_loss}, difference: " - f"{init_loss-saved_loss}") + raise ValueError( + f"Saved and initialized {display_k} are " + "different! On two random tensors: " + f"Initialized: {init_loss}, Saved: " + f"{saved_loss}, difference: " + f"{init_loss-saved_loss}" + ) for k, v in tmp_dict.items(): setattr(self, k, v) @@ -178,7 +199,7 @@ def to(self, *args, attrs: List[str] = [], **kwargs): r"""Moves and/or casts the parameters and buffers. Similar to ``save``, this is an abstract method only because you need to define the attributes to call to on. - + This can be called as .. function:: to(device=None, dtype=None, non_blocking=False) .. function:: to(dtype, non_blocking=False) @@ -210,13 +231,19 @@ def to(self, *args, attrs: List[str] = [], **kwargs): except AttributeError: warnings.warn("model has no `to` method, so we leave it as is...") - device, dtype, non_blocking, memory_format = torch._C._nn._parse_to(*args, **kwargs) + device, dtype, non_blocking, memory_format = torch._C._nn._parse_to( + *args, **kwargs + ) def move(a, k): move_device = None if k.startswith("saved_") else device if memory_format is not None and a.dim() == 4: - return a.to(move_device, dtype, non_blocking, - memory_format=memory_format) + return a.to( + move_device, + dtype, + non_blocking, + memory_format=memory_format, + ) else: return a.to(move_device, dtype, non_blocking) @@ -239,10 +266,12 @@ class OptimizedSynthesis(Synthesis): these will use an optimizer object to iteratively update their output. """ - def __init__(self, - range_penalty_lambda: float = .1, - allowed_range: Tuple[float, float] = (0, 1), - ): + + def __init__( + self, + range_penalty_lambda: float = 0.1, + allowed_range: Tuple[float, float] = (0, 1), + ): """Initialize the properties of OptimizedSynthesis.""" self._losses = [] self._gradient_norm = [] @@ -296,10 +325,12 @@ def _closure(self) -> torch.Tensor: loss.backward(retain_graph=False) return loss - def _initialize_optimizer(self, - optimizer: Optional[torch.optim.Optimizer], - synth_name: str, - learning_rate: float = .01): + def _initialize_optimizer( + self, + optimizer: Optional[torch.optim.Optimizer], + synth_name: str, + learning_rate: float = 0.01, + ): """Initialize optimizer. First time this is called, optimizer can be: @@ -319,15 +350,20 @@ def _initialize_optimizer(self, synth_attr = getattr(self, synth_name) if optimizer is None: if self.optimizer is None: - self._optimizer = torch.optim.Adam([synth_attr], - lr=learning_rate, amsgrad=True) + self._optimizer = torch.optim.Adam( + [synth_attr], lr=learning_rate, amsgrad=True + ) else: if self.optimizer is not None: - raise TypeError("When resuming synthesis, optimizer arg must be None!") - params = optimizer.param_groups[0]['params'] + raise TypeError( + "When resuming synthesis, optimizer arg must be None!" + ) + params = optimizer.param_groups[0]["params"] if len(params) != 1 or not torch.equal(params[0], synth_attr): - raise ValueError(f"For {synth_name} synthesis, optimizer must have one " - f"parameter, the {synth_name} we're synthesizing.") + raise ValueError( + f"For {synth_name} synthesis, optimizer must have one " + f"parameter, the {synth_name} we're synthesizing." + ) self._optimizer = optimizer @property @@ -378,19 +414,23 @@ def store_progress(self, store_progress: Union[bool, int]): if store_progress: if store_progress is True: store_progress = 1 - if self.store_progress is not None and store_progress != self.store_progress: + if ( + self.store_progress is not None + and store_progress != self.store_progress + ): # we require store_progress to be the same because otherwise the # subsampling relationship between attrs that are stored every # iteration (loss, gradient, etc) and those that are stored every # store_progress iteration (e.g., saved_metamer) changes partway # through and that's annoying - raise Exception("If you've already run synthesize() before, must " - "re-run it with same store_progress arg. You " - f"passed {store_progress} instead of " - f"{self.store_progress} (True is equivalent to 1)") + raise Exception( + "If you've already run synthesize() before, must " + "re-run it with same store_progress arg. You " + f"passed {store_progress} instead of " + f"{self.store_progress} (True is equivalent to 1)" + ) self._store_progress = store_progress @property def optimizer(self): return self._optimizer - diff --git a/src/plenoptic/tools/conv.py b/src/plenoptic/tools/conv.py index 70832efd..0a0a442f 100644 --- a/src/plenoptic/tools/conv.py +++ b/src/plenoptic/tools/conv.py @@ -24,8 +24,15 @@ def correlate_downsample(image, filt, padding_mode="reflect"): assert isinstance(image, torch.Tensor) and isinstance(filt, torch.Tensor) assert image.ndim == 4 and filt.ndim == 2 n_channels = image.shape[1] - image_padded = same_padding(image, kernel_size=filt.shape, pad_mode=padding_mode) - return F.conv2d(image_padded, filt.repeat(n_channels, 1, 1, 1), stride=2, groups=n_channels) + image_padded = same_padding( + image, kernel_size=filt.shape, pad_mode=padding_mode + ) + return F.conv2d( + image_padded, + filt.repeat(n_channels, 1, 1, 1), + stride=2, + groups=n_channels, + ) def upsample_convolve(image, odd, filt, padding_mode="reflect"): @@ -34,7 +41,8 @@ def upsample_convolve(image, odd, filt, padding_mode="reflect"): Parameters ---------- image: torch.Tensor of shape (batch, channel, height, width) - Image, or batch of images. Channels are treated in the same way as batches. + Image, or batch of images. Channels are treated in the same way as + batches. odd: tuple, list or numpy.ndarray This should contain two integers of value 0 or 1, which determines whether the output height and width should be even (0) or odd (1). @@ -54,10 +62,18 @@ def upsample_convolve(image, odd, filt, padding_mode="reflect"): pad_end = np.array(filt.shape) - np.array(odd) - pad_start pad = np.array([pad_start[1], pad_end[1], pad_start[0], pad_end[0]]) image_prepad = F.pad(image, tuple(pad // 2), mode=padding_mode) - image_upsample = F.conv_transpose2d(image_prepad, - weight=torch.ones((n_channels, 1, 1, 1), device=image.device, dtype=image.dtype), stride=2, groups=n_channels) + image_upsample = F.conv_transpose2d( + image_prepad, + weight=torch.ones( + (n_channels, 1, 1, 1), device=image.device, dtype=image.dtype + ), + stride=2, + groups=n_channels, + ) image_postpad = F.pad(image_upsample, tuple(pad % 2)) - return F.conv2d(image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels) + return F.conv2d( + image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels + ) def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): @@ -77,7 +93,9 @@ def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) + filt = torch.as_tensor( + np.outer(f, f), dtype=torch.float32, device=x.device + ) if scale_filter: filt = filt / 2 for _ in range(n_scales): @@ -103,38 +121,46 @@ def upsample_blur(x, odd, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) + filt = torch.as_tensor( + np.outer(f, f), dtype=torch.float32, device=x.device + ) if scale_filter: filt = filt * 2 return upsample_convolve(x, odd, filt) def _get_same_padding( - x: int, - kernel_size: int, - stride: int, - dilation: int + x: int, kernel_size: int, stride: int, dilation: int ) -> int: """Helper function to determine integer padding for F.pad() given img and kernel""" - pad = (math.ceil(x / stride) - 1) * stride + (kernel_size - 1) * dilation + 1 - x + pad = ( + (math.ceil(x / stride) - 1) * stride + + (kernel_size - 1) * dilation + + 1 + - x + ) pad = max(pad, 0) return pad def same_padding( - x: Tensor, - kernel_size: Union[int, Tuple[int, int]], - stride: Union[int, Tuple[int, int]] = (1, 1), - dilation: Union[int, Tuple[int, int]] = (1, 1), - pad_mode: str = "circular", + x: Tensor, + kernel_size: Union[int, Tuple[int, int]], + stride: Union[int, Tuple[int, int]] = (1, 1), + dilation: Union[int, Tuple[int, int]] = (1, 1), + pad_mode: str = "circular", ) -> Tensor: """Pad a tensor so that 2D convolution will result in output with same dims.""" - assert len(x.shape) > 2, "Input must be tensor whose last dims are height x width" + assert ( + len(x.shape) > 2 + ), "Input must be tensor whose last dims are height x width" ih, iw = x.shape[-2:] pad_h = _get_same_padding(ih, kernel_size[0], stride[0], dilation[0]) pad_w = _get_same_padding(iw, kernel_size[1], stride[1], dilation[1]) if pad_h > 0 or pad_w > 0: - x = F.pad(x, - [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], - mode=pad_mode) + x = F.pad( + x, + [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], + mode=pad_mode, + ) return x diff --git a/src/plenoptic/tools/convergence.py b/src/plenoptic/tools/convergence.py index 8a658ea1..5d359c39 100644 --- a/src/plenoptic/tools/convergence.py +++ b/src/plenoptic/tools/convergence.py @@ -17,17 +17,21 @@ ``False`` if not. """ + # to avoid circular import error: # https://adamj.eu/tech/2021/05/13/python-type-hints-how-to-fix-circular-imports/ from typing import TYPE_CHECKING + if TYPE_CHECKING: from ..synthesize.synthesis import OptimizedSynthesis from ..synthesize.metamer import Metamer -def loss_convergence(synth: "OptimizedSynthesis", - stop_criterion: float, - stop_iters_to_check: int) -> bool: +def loss_convergence( + synth: "OptimizedSynthesis", + stop_criterion: float, + stop_iters_to_check: int, +) -> bool: r"""Check whether the loss has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -59,13 +63,17 @@ def loss_convergence(synth: "OptimizedSynthesis", """ if len(synth.losses) > stop_iters_to_check: - if abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) < stop_criterion: + if ( + abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) + < stop_criterion + ): return True return False -def coarse_to_fine_enough(synth: "Metamer", i: int, - ctf_iters_to_check: int) -> bool: +def coarse_to_fine_enough( + synth: "Metamer", i: int, ctf_iters_to_check: int +) -> bool: r"""Check whether we've synthesized all scales and done so for at least ctf_iters_to_check iterations This is meant to be paired with another convergence check, such as ``loss_convergence``. @@ -86,18 +94,20 @@ def coarse_to_fine_enough(synth: "Metamer", i: int, Whether we've been doing coarse to fine synthesis for long enough. """ - all_scales = synth.scales[0] == 'all' + all_scales = synth.scales[0] == "all" # synth.scales_timing['all'] will only be a non-empty list if all_scales is # True, so we only check it then. This is equivalent to checking if both conditions are trued if all_scales: - return (i - synth.scales_timing['all'][0]) > ctf_iters_to_check + return (i - synth.scales_timing["all"][0]) > ctf_iters_to_check else: return False -def pixel_change_convergence(synth: "OptimizedSynthesis", - stop_criterion: float, - stop_iters_to_check: int) -> bool: +def pixel_change_convergence( + synth: "OptimizedSynthesis", + stop_criterion: float, + stop_iters_to_check: int, +) -> bool: """Check whether the pixel change norm has stabilized and, if so, return True. Have we been synthesizing for ``stop_iters_to_check`` iterations? @@ -129,6 +139,8 @@ def pixel_change_convergence(synth: "OptimizedSynthesis", """ if len(synth.pixel_change_norm) > stop_iters_to_check: - if (synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion).all(): + if ( + synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion + ).all(): return True return False diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index 415defa5..3e430f3f 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -28,10 +28,14 @@ np.complex128: torch.complex128, } -TORCH_TO_NUMPY_TYPES = {value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items()} +TORCH_TO_NUMPY_TYPES = { + value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items() +} -def to_numpy(x: Union[Tensor, np.ndarray], squeeze: bool = False) -> np.ndarray: +def to_numpy( + x: Union[Tensor, np.ndarray], squeeze: bool = False +) -> np.ndarray: r"""cast tensor to numpy in the most conservative way possible Parameters @@ -138,8 +142,10 @@ def load_images(paths: Union[str, List[str]], as_gray: bool = True) -> Tensor: im = np.expand_dims(im, 0).repeat(3, 0) images.append(im) if len(set([i.shape for i in images])) > 1: - raise ValueError("All images must be the same shape but got the following: " - f"{[i.shape for i in images]}") + raise ValueError( + "All images must be the same shape but got the following: " + f"{[i.shape for i in images]}" + ) images = torch.as_tensor(np.array(images), dtype=torch.float32) if as_gray: if images.ndimension() != 3: @@ -194,7 +200,9 @@ def convert_float_to_int(im: np.ndarray, dtype=np.uint8) -> np.ndarray: return (im * np.iinfo(dtype).max).astype(dtype) -def make_synthetic_stimuli(size: int = 256, requires_grad: bool = True) -> Tensor: +def make_synthetic_stimuli( + size: int = 256, requires_grad: bool = True +) -> Tensor: r"""Make a set of basic stimuli, useful for developping and debugging models Parameters @@ -223,10 +231,13 @@ def make_synthetic_stimuli(size: int = 256, requires_grad: bool = True) -> Tenso bar = np.zeros((size, size)) bar[ - size // 2 - size // 10 : size // 2 + size // 10, size // 2 - 1 : size // 2 + 1 + size // 2 - size // 10 : size // 2 + size // 10, + size // 2 - 1 : size // 2 + 1, ] = 1 - curv_edge = synthetic_images.disk(size=size, radius=size / 1.2, origin=(size, size)) + curv_edge = synthetic_images.disk( + size=size, radius=size / 1.2, origin=(size, size) + ) sine_grating = synthetic_images.sine(size) * synthetic_images.gaussian( size, covariance=size diff --git a/src/plenoptic/tools/display.py b/src/plenoptic/tools/display.py index 97350074..18e56e62 100644 --- a/src/plenoptic/tools/display.py +++ b/src/plenoptic/tools/display.py @@ -1,20 +1,32 @@ -"""various helpful utilities for plotting or displaying information -""" +"""various helpful utilities for plotting or displaying information""" + import warnings import torch import numpy as np import pyrtools as pt import matplotlib.pyplot as plt from .data import to_numpy + try: from IPython.display import HTML except ImportError: warnings.warn("Unable to import IPython.display.HTML") -def imshow(image, vrange='indep1', zoom=None, title='', col_wrap=None, ax=None, - cmap=None, plot_complex='rectangular', batch_idx=None, - channel_idx=None, as_rgb=False, **kwargs): +def imshow( + image, + vrange="indep1", + zoom=None, + title="", + col_wrap=None, + ax=None, + cmap=None, + plot_complex="rectangular", + batch_idx=None, + channel_idx=None, + as_rgb=False, + **kwargs, +): """Show image(s) correctly. This function shows images correctly, making sure that each element in the @@ -118,22 +130,26 @@ def imshow(image, vrange='indep1', zoom=None, title='', col_wrap=None, ax=None, im = to_numpy(im) if im.shape[0] > 1 and batch_idx is not None: # this preserves the number of dimensions - im = im[batch_idx:batch_idx+1] + im = im[batch_idx : batch_idx + 1] if channel_idx is not None: # this preserves the number of dimensions - im = im[:, channel_idx:channel_idx+1] + im = im[:, channel_idx : channel_idx + 1] # allow RGB and RGBA if as_rgb: if im.shape[1] not in [3, 4]: - raise Exception("If as_rgb is True, then channel must have 3 " - "or 4 elements!") + raise Exception( + "If as_rgb is True, then channel must have 3 " + "or 4 elements!" + ) im = im.transpose(0, 2, 3, 1) # want to insert a fake "channel" dimension here, so our putting it # into a list below works as expected im = im.reshape((im.shape[0], 1, *im.shape[1:])) elif im.shape[1] > 1 and im.shape[0] > 1: - raise Exception("Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting") + raise Exception( + "Don't know how to plot images with more than one channel and batch!" + " Use batch_idx / channel_idx to choose a subset for plotting" + ) # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate image. # because of how we've handled everything above, we know that im will @@ -152,7 +168,8 @@ def find_zoom(x, limit): divisors = [i for i in range(2, x) if not x % i] # find the largest zoom (equivalently, smallest divisor) such that the # zoomed in image is smaller than the limit - return 1 / min([i for i in divisors if x/i <= limit]) + return 1 / min([i for i in divisors if x / i <= limit]) + if ax is not None and zoom is None: if ax.bbox.height > max(heights): zoom = ax.bbox.height // max(heights) @@ -164,15 +181,35 @@ def find_zoom(x, limit): zoom = find_zoom(max(widths), ax.bbox.width) elif zoom is None: zoom = 1 - return pt.imshow(images_to_plot, vrange=vrange, zoom=zoom, title=title, - col_wrap=col_wrap, ax=ax, cmap=cmap, plot_complex=plot_complex, - **kwargs) - - -def animshow(video, framerate=2., repeat=False, vrange='indep1', zoom=1, - title='', col_wrap=None, ax=None, cmap=None, - plot_complex='rectangular', batch_idx=None, channel_idx=None, - as_rgb=False, **kwargs): + return pt.imshow( + images_to_plot, + vrange=vrange, + zoom=zoom, + title=title, + col_wrap=col_wrap, + ax=ax, + cmap=cmap, + plot_complex=plot_complex, + **kwargs, + ) + + +def animshow( + video, + framerate=2.0, + repeat=False, + vrange="indep1", + zoom=1, + title="", + col_wrap=None, + ax=None, + cmap=None, + plot_complex="rectangular", + batch_idx=None, + channel_idx=None, + as_rgb=False, + **kwargs, +): """Animate video(s) correctly. This function animates videos correctly, making sure that each element in @@ -301,37 +338,59 @@ def animshow(video, framerate=2., repeat=False, vrange='indep1', zoom=1, vid = to_numpy(vid) if vid.shape[0] > 1 and batch_idx is not None: # this preserves the number of dimensions - vid = vid[batch_idx:batch_idx+1] + vid = vid[batch_idx : batch_idx + 1] if channel_idx is not None: # this preserves the number of dimensions - vid = vid[:, channel_idx:channel_idx+1] + vid = vid[:, channel_idx : channel_idx + 1] # allow RGB and RGBA if as_rgb: if vid.shape[1] not in [3, 4]: - raise Exception("If as_rgb is True, then channel must have 3 " - "or 4 elements!") + raise Exception( + "If as_rgb is True, then channel must have 3 " + "or 4 elements!" + ) vid = vid.transpose(0, 2, 3, 4, 1) # want to insert a fake "channel" dimension here, so our putting it # into a list below works as expected vid = vid.reshape((vid.shape[0], 1, *vid.shape[1:])) elif vid.shape[1] > 1 and vid.shape[0] > 1: - raise Exception("Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting") + raise Exception( + "Don't know how to plot images with more than one channel and batch!" + " Use batch_idx / channel_idx to choose a subset for plotting" + ) # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate video. # because of how we've handled everything above, we know that vid will # be (b,c,t,h,w) or (b,c,t,h,w,r) where r is the RGB(A) values for v in vid: videos_to_show.extend([v_.squeeze() for v_ in v]) - return pt.animshow(videos_to_show, framerate=framerate, as_html5=False, - repeat=repeat, vrange=vrange, zoom=zoom, title=title, - col_wrap=col_wrap, ax=ax, cmap=cmap, - plot_complex=plot_complex, **kwargs) - - -def pyrshow(pyr_coeffs, vrange='indep1', zoom=1, show_residuals=True, - cmap=None, plot_complex='rectangular', batch_idx=0, channel_idx=0, - **kwargs): + return pt.animshow( + videos_to_show, + framerate=framerate, + as_html5=False, + repeat=repeat, + vrange=vrange, + zoom=zoom, + title=title, + col_wrap=col_wrap, + ax=ax, + cmap=cmap, + plot_complex=plot_complex, + **kwargs, + ) + + +def pyrshow( + pyr_coeffs, + vrange="indep1", + zoom=1, + show_residuals=True, + cmap=None, + plot_complex="rectangular", + batch_idx=0, + channel_idx=0, + **kwargs, +): r"""Display steerable pyramid coefficients in orderly fashion. This function uses ``imshow`` to show the coefficients of the steeable @@ -408,20 +467,31 @@ def pyrshow(pyr_coeffs, vrange='indep1', zoom=1, show_residuals=True, if np.iscomplex(im).any(): is_complex = True # this removes only the first (batch) dimension - im = im[batch_idx:batch_idx+1].squeeze(0) + im = im[batch_idx : batch_idx + 1].squeeze(0) # this removes only the first (now channel) dimension - im = im[channel_idx:channel_idx+1].squeeze(0) + im = im[channel_idx : channel_idx + 1].squeeze(0) # because of how we've handled everything above, we know that im will # be (h,w). pyr_coeffvis[k] = im - return pt.pyrshow(pyr_coeffvis, is_complex=is_complex, vrange=vrange, - zoom=zoom, cmap=cmap, plot_complex=plot_complex, - show_residuals=show_residuals, **kwargs) - - -def clean_up_axes(ax, ylim=None, spines_to_remove=['top', 'right', 'bottom'], - axes_to_remove=['x']): + return pt.pyrshow( + pyr_coeffvis, + is_complex=is_complex, + vrange=vrange, + zoom=zoom, + cmap=cmap, + plot_complex=plot_complex, + show_residuals=show_residuals, + **kwargs, + ) + + +def clean_up_axes( + ax, + ylim=None, + spines_to_remove=["top", "right", "bottom"], + axes_to_remove=["x"], +): r"""Clean up an axis, as desired when making a stem plot of the representation Parameters @@ -445,18 +515,18 @@ def clean_up_axes(ax, ylim=None, spines_to_remove=['top', 'right', 'bottom'], """ if spines_to_remove is None: - spines_to_remove = ['top', 'right', 'bottom'] + spines_to_remove = ["top", "right", "bottom"] if axes_to_remove is None: - axes_to_remove = ['x'] + axes_to_remove = ["x"] if ylim is not None: if ylim: ax.set_ylim(ylim) else: ax.set_ylim((0, ax.get_ylim()[1])) - if 'x' in axes_to_remove: + if "x" in axes_to_remove: ax.xaxis.set_visible(False) - if 'y' in axes_to_remove: + if "y" in axes_to_remove: ax.yaxis.set_visible(False) for s in spines_to_remove: ax.spines[s].set_visible(False) @@ -517,6 +587,7 @@ def rescale_ylim(axes, data): values) """ data = data.cpu() + def find_ymax(data): try: return np.abs(data).max() @@ -524,6 +595,7 @@ def find_ymax(data): # then we need to call to_numpy on it because it needs to be # detached and converted to an array return np.abs(to_numpy(data)).max() + try: y_max = find_ymax(data) except TypeError: @@ -533,7 +605,7 @@ def find_ymax(data): ax.set_ylim((-y_max, y_max)) -def clean_stem_plot(data, ax=None, title='', ylim=None, xvals=None, **kwargs): +def clean_stem_plot(data, ax=None, title="", ylim=None, xvals=None, **kwargs): r"""convenience wrapper for plotting stem plots This plots the data, baseline, cleans up the axis, and sets the @@ -617,14 +689,15 @@ def clean_stem_plot(data, ax=None, title='', ylim=None, xvals=None, **kwargs): if ax is None: ax = plt.gca() if xvals is not None: - basefmt = ' ' - ax.hlines(len(xvals[0])*[0], xvals[0], xvals[1], colors='C3', - zorder=10) + basefmt = " " + ax.hlines( + len(xvals[0]) * [0], xvals[0], xvals[1], colors="C3", zorder=10 + ) else: # this is the default basefmt value basefmt = None ax.stem(data, basefmt=basefmt, **kwargs) - ax = clean_up_axes(ax, ylim, ['top', 'right', 'bottom']) + ax = clean_up_axes(ax, ylim, ["top", "right", "bottom"]) if title is not None: ax.set_title(title) return ax @@ -652,7 +725,7 @@ def _get_artists_from_axes(axes, data): use, keys are the corresponding keys for data """ - if not hasattr(axes, '__iter__'): + if not hasattr(axes, "__iter__"): # then we only have one axis, so we may be able to update more than one # data element. if len(axes.containers) > 0: @@ -672,17 +745,25 @@ def _get_artists_from_axes(axes, data): artists = {ax.get_label(): ax for ax in artists} else: if data_check == 1 and data.shape[1] != len(artists): - raise Exception(f"data has {data.shape[1]} things to plot, but " - f"your axis contains {len(artists)} plotting artists, " - "so unsure how to continue! Pass data as a dictionary" - " with keys corresponding to the labels of the artists" - " to update to resolve this.") - elif data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): - raise Exception(f"data has {data.shape[-3]} things to plot, but " - f"your axis contains {len(artists)} plotting artists, " - "so unsure how to continue! Pass data as a dictionary" - " with keys corresponding to the labels of the artists" - " to update to resolve this.") + raise Exception( + f"data has {data.shape[1]} things to plot, but " + f"your axis contains {len(artists)} plotting artists, " + "so unsure how to continue! Pass data as a dictionary" + " with keys corresponding to the labels of the artists" + " to update to resolve this." + ) + elif ( + data_check == 2 + and data.ndim > 2 + and data.shape[-3] != len(artists) + ): + raise Exception( + f"data has {data.shape[-3]} things to plot, but " + f"your axis contains {len(artists)} plotting artists, " + "so unsure how to continue! Pass data as a dictionary" + " with keys corresponding to the labels of the artists" + " to update to resolve this." + ) else: # then we have multiple axes, so we are only updating one data element # per plot @@ -703,19 +784,29 @@ def _get_artists_from_axes(axes, data): data_check = 2 if isinstance(data, dict): if len(data.keys()) != len(artists): - raise Exception(f"data has {len(data.keys())} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!") + raise Exception( + f"data has {len(data.keys())} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!" + ) artists = {k: a for k, a in zip(data.keys(), artists)} else: if data_check == 1 and data.shape[1] != len(artists): - raise Exception(f"data has {data.shape[1]} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!") - if data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): - raise Exception(f"data has {data.shape[-3]} things to plot, but " - f"you passed {len(axes)} axes , so unsure how " - "to continue!") + raise Exception( + f"data has {data.shape[1]} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!" + ) + if ( + data_check == 2 + and data.ndim > 2 + and data.shape[-3] != len(artists) + ): + raise Exception( + f"data has {data.shape[-3]} things to plot, but " + f"you passed {len(axes)} axes , so unsure how " + "to continue!" + ) if not isinstance(artists, dict): artists = {f"{i:02d}": a for i, a in enumerate(artists)} return artists @@ -787,14 +878,18 @@ def update_plot(axes, data, model=None, batch_idx=0): if isinstance(data, dict): for v in data.values(): if v.ndim not in [3, 4]: - raise ValueError("update_plot expects 3 or 4 dimensional data" - "; unexpected behavior will result otherwise!" - f" Got data of shape {v.shape}") + raise ValueError( + "update_plot expects 3 or 4 dimensional data" + "; unexpected behavior will result otherwise!" + f" Got data of shape {v.shape}" + ) else: if data.ndim not in [3, 4]: - raise ValueError("update_plot expects 3 or 4 dimensional data" - "; unexpected behavior will result otherwise!" - f" Got data of shape {data.shape}") + raise ValueError( + "update_plot expects 3 or 4 dimensional data" + "; unexpected behavior will result otherwise!" + f" Got data of shape {data.shape}" + ) try: artists = model.update_plot(axes=axes, batch_idx=batch_idx, data=data) except AttributeError: @@ -808,19 +903,24 @@ def update_plot(axes, data, model=None, batch_idx=0): # instead, as suggested # https://stackoverflow.com/questions/43629270/how-to-get-single-value-from-dict-with-single-entry try: - if next(iter(ax_artists.values())).get_array().data.ndim > 1: + if ( + next(iter(ax_artists.values())).get_array().data.ndim + > 1 + ): # then this is an RGBA image - data_dict = {'00': data} + data_dict = {"00": data} except Exception as e: - raise Exception("Thought this was an RGB(A) image based on the number of " - "artists and data shape, but something is off! " - f"Original exception: {e}") + raise Exception( + "Thought this was an RGB(A) image based on the number of " + "artists and data shape, but something is off! " + f"Original exception: {e}" + ) else: for i, d in enumerate(data.unbind(1)): # need to keep the shape the same because of how we # check for shape below (unbinding removes a dimension, # so we add it back) - data_dict[f'{i:02d}'] = d.unsqueeze(1) + data_dict[f"{i:02d}"] = d.unsqueeze(1) data = data_dict for k, d in data.items(): try: @@ -861,8 +961,16 @@ def update_plot(axes, data, model=None, batch_idx=0): return artists -def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), - ylim=False, batch_idx=0, title='', as_rgb=False): +def plot_representation( + model=None, + data=None, + ax=None, + figsize=(5, 5), + ylim=False, + batch_idx=0, + title="", + as_rgb=False, +): r"""Helper function for plotting model representation We are trying to plot ``data`` on ``ax``, using @@ -933,15 +1041,15 @@ def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), try: # no point in passing figsize, because we've already created # and are passing an axis or are passing the user-specified one - fig, axes = model.plot_representation(ylim=ylim, ax=ax, title=title, - batch_idx=batch_idx, - data=data) + fig, axes = model.plot_representation( + ylim=ylim, ax=ax, title=title, batch_idx=batch_idx, data=data + ) except AttributeError: if data is None: data = model.representation if not isinstance(data, dict): if title is None: - title = 'Representation' + title = "Representation" data_dict = {} if not as_rgb: # then we peel apart the channels @@ -949,20 +1057,22 @@ def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), # need to keep the shape the same because of how we # check for shape below (unbinding removes a dimension, # so we add it back) - data_dict[title+'_%02d' % i] = d.unsqueeze(1) + data_dict[title + "_%02d" % i] = d.unsqueeze(1) else: data_dict[title] = data data = data_dict else: warnings.warn("data has keys, so we're ignoring title!") # want to make sure the axis we're taking over is basically invisible. - ax = clean_up_axes(ax, False, - ['top', 'right', 'bottom', 'left'], ['x', 'y']) + ax = clean_up_axes( + ax, False, ["top", "right", "bottom", "left"], ["x", "y"] + ) axes = [] if len(list(data.values())[0].shape) == 3: # then this is 'vector-like' - gs = ax.get_subplotspec().subgridspec(min(4, len(data)), - int(np.ceil(len(data) / 4))) + gs = ax.get_subplotspec().subgridspec( + min(4, len(data)), int(np.ceil(len(data) / 4)) + ) for i, (k, v) in enumerate(data.items()): ax = fig.add_subplot(gs[i % 4, i // 4]) # only plot the specified batch, but plot each channel @@ -974,23 +1084,31 @@ def plot_representation(model=None, data=None, ax=None, figsize=(5, 5), axes.append(ax) elif len(list(data.values())[0].shape) == 4: # then this is 'image-like' - gs = ax.get_subplotspec().subgridspec(int(np.ceil(len(data) / 4)), - min(4, len(data))) + gs = ax.get_subplotspec().subgridspec( + int(np.ceil(len(data) / 4)), min(4, len(data)) + ) for i, (k, v) in enumerate(data.items()): ax = fig.add_subplot(gs[i // 4, i % 4]) - ax = clean_up_axes(ax, - False, ['top', 'right', 'bottom', 'left'], - ['x', 'y']) + ax = clean_up_axes( + ax, False, ["top", "right", "bottom", "left"], ["x", "y"] + ) # only plot the specified batch - imshow(v, batch_idx=batch_idx, title=k, ax=ax, - vrange='indep0', as_rgb=as_rgb) + imshow( + v, + batch_idx=batch_idx, + title=k, + ax=ax, + vrange="indep0", + as_rgb=as_rgb, + ) axes.append(ax) # because we're plotting image data, don't want to change # ylim at all ylim = False else: - raise Exception("Don't know what to do with data of shape" - f" {data.shape}") + raise Exception( + "Don't know what to do with data of shape" f" {data.shape}" + ) if ylim is None: if isinstance(data, dict): data = torch.cat(list(data.values()), dim=2) diff --git a/src/plenoptic/tools/external.py b/src/plenoptic/tools/external.py index 310f684d..3792b65c 100644 --- a/src/plenoptic/tools/external.py +++ b/src/plenoptic/tools/external.py @@ -3,6 +3,7 @@ For example, pre-existing synthesized images """ + import os.path as op import imageio @@ -13,10 +14,15 @@ from ..data import fetch_data -def plot_MAD_results(original_image, noise_levels=None, - results_dir=None, - ssim_images_dir=None, - zoom=3, vrange='indep1', **kwargs): +def plot_MAD_results( + original_image, + noise_levels=None, + results_dir=None, + ssim_images_dir=None, + zoom=3, + vrange="indep1", + **kwargs, +): r"""plot original MAD results, provided by Zhou Wang Plot the results of original MAD Competition, as provided in .mat @@ -71,9 +77,9 @@ def plot_MAD_results(original_image, noise_levels=None, """ if results_dir is None: - results_dir = str(fetch_data('MAD_results.tar.gz')) + results_dir = str(fetch_data("MAD_results.tar.gz")) if ssim_images_dir is None: - ssim_images_dir = str(fetch_data('ssim_images.tar.gz')) + ssim_images_dir = str(fetch_data("ssim_images.tar.gz")) img_path = op.join(op.expanduser(ssim_images_dir), f"{original_image}.tif") orig_img = imageio.imread(img_path) blanks = np.ones((*orig_img.shape, 4)) @@ -81,63 +87,107 @@ def plot_MAD_results(original_image, noise_levels=None, noise_levels = [2**i for i in range(1, 11)] results = {} images = np.dstack([orig_img, blanks]) - titles = ['Original image'] + 4*[None] - super_titles = 5*[None] - keys = ['im_init', 'im_fixmse_maxssim', 'im_fixmse_minssim', 'im_fixssim_minmse', - 'im_fixssim_maxmse'] + titles = ["Original image"] + 4 * [None] + super_titles = 5 * [None] + keys = [ + "im_init", + "im_fixmse_maxssim", + "im_fixmse_minssim", + "im_fixssim_minmse", + "im_fixssim_maxmse", + ] for l in noise_levels: - mat = sio.loadmat(op.join(op.expanduser(results_dir), - f"{original_image}_L{l}_results.mat"), squeeze_me=True) + mat = sio.loadmat( + op.join( + op.expanduser(results_dir), + f"{original_image}_L{l}_results.mat", + ), + squeeze_me=True, + ) # remove these metadata keys - [mat.pop(k) for k in ['__header__', '__version__', '__globals__']] - key_titles = [f'Noise level: {l}', f"Best SSIM: {mat['maxssim']:.05f}", - f"Worst SSIM: {mat['minssim']:.05f}", - f"Best MSE: {mat['minmse']:.05f}", - f"Worst MSE: {mat['maxmse']:.05f}"] - key_super_titles = [None, f"Fix MSE: {mat['FIX_MSE']:.0f}", None, - f"Fix SSIM: {mat['FIX_SSIM']:.05f}", None] + [mat.pop(k) for k in ["__header__", "__version__", "__globals__"]] + key_titles = [ + f"Noise level: {l}", + f"Best SSIM: {mat['maxssim']:.05f}", + f"Worst SSIM: {mat['minssim']:.05f}", + f"Best MSE: {mat['minmse']:.05f}", + f"Worst MSE: {mat['maxmse']:.05f}", + ] + key_super_titles = [ + None, + f"Fix MSE: {mat['FIX_MSE']:.0f}", + None, + f"Fix SSIM: {mat['FIX_SSIM']:.05f}", + None, + ] for k, t, s in zip(keys, key_titles, key_super_titles): images = np.dstack([images, mat.pop(k)]) titles.append(t) super_titles.append(s) # this then just contains the loss information - mat.update({'noise_level': l, 'original_image': original_image}) - results[f'L{l}'] = mat + mat.update({"noise_level": l, "original_image": original_image}) + results[f"L{l}"] = mat images = images.transpose((2, 0, 1)) - if vrange.startswith('row'): + if vrange.startswith("row"): vrange_list = [] - for i in range(len(images)//5): - vr, cmap = pt.tools.display.colormap_range(images[5*i:5*(i+1)], - vrange.replace('row', 'auto')) + for i in range(len(images) // 5): + vr, cmap = pt.tools.display.colormap_range( + images[5 * i : 5 * (i + 1)], vrange.replace("row", "auto") + ) vrange_list.extend(vr) else: vrange_list, cmap = pt.tools.display.colormap_range(images, vrange) # this is a bit of hack to do the same thing imshow does, but with # slightly more space dedicated to the title - fig = pt.tools.display.make_figure(len(images)//5, 5, [zoom*i+1 for i in images.shape[-2:]], - vert_pct=.75) - for img, ax, t, vr, s in zip(images, fig.axes, titles, vrange_list, super_titles): + fig = pt.tools.display.make_figure( + len(images) // 5, + 5, + [zoom * i + 1 for i in images.shape[-2:]], + vert_pct=0.75, + ) + for img, ax, t, vr, s in zip( + images, fig.axes, titles, vrange_list, super_titles + ): # these are the blanks if (img == 1).all(): continue - pt.imshow(img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs) + pt.imshow( + img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs + ) if s is not None: - font = {k.replace('_', ''): v for k, v in - ax.title.get_font_properties().__dict__.items()} + font = { + k.replace("_", ""): v + for k, v in ax.title.get_font_properties().__dict__.items() + } # these are the acceptable keys for the fontdict below - font = {k: v for k, v in font.items() if k in ['family', 'color', 'weight', 'size', - 'style']} + font = { + k: v + for k, v in font.items() + if k in ["family", "color", "weight", "size", "style"] + } # for some reason, this (with passing the transform) is # different (and looks better) than using ax.text. We also # slightly adjust the placement of the text to account for # different zoom levels (we also have 10 pixels between the # rows and columns, which correspond to a different) img_size = ax.bbox.size - fig.text(1+(5/img_size[0]), (1/.75), s, fontdict=font, - transform=ax.transAxes, ha='center', va='top') + fig.text( + 1 + (5 / img_size[0]), + (1 / 0.75), + s, + fontdict=font, + transform=ax.transAxes, + ha="center", + va="top", + ) # linewidth of 1.5 looks good with bbox of 192, 192 - linewidth = np.max([1.5 * np.mean(img_size/192), 1]) - line = lines.Line2D(2*[0-((5+linewidth/2)/img_size[0])], [0, (1/.75)], - transform=ax.transAxes, figure=fig, linewidth=linewidth) + linewidth = np.max([1.5 * np.mean(img_size / 192), 1]) + line = lines.Line2D( + 2 * [0 - ((5 + linewidth / 2) / img_size[0])], + [0, (1 / 0.75)], + transform=ax.transAxes, + figure=fig, + linewidth=linewidth, + ) fig.lines.append(line) return fig, results diff --git a/src/plenoptic/tools/optim.py b/src/plenoptic/tools/optim.py index 439cc8c3..6423ceb1 100644 --- a/src/plenoptic/tools/optim.py +++ b/src/plenoptic/tools/optim.py @@ -1,5 +1,5 @@ -"""Tools related to optimization such as more objective functions. -""" +"""Tools related to optimization such as more objective functions.""" + import torch from torch import Tensor from typing import Optional, Tuple @@ -99,11 +99,16 @@ def relative_MSE(synth_rep: Tensor, ref_rep: Tensor, **kwargs) -> Tensor: Ratio of the squared l2-norm of the difference between ``ref_rep`` and ``synth_rep`` to the squared l2-norm of ``ref_rep`` """ - return torch.linalg.vector_norm(ref_rep - synth_rep, ord=2) ** 2 / torch.linalg.vector_norm(ref_rep, ord=2) ** 2 + return ( + torch.linalg.vector_norm(ref_rep - synth_rep, ord=2) ** 2 + / torch.linalg.vector_norm(ref_rep, ord=2) ** 2 + ) def penalize_range( - synth_img: Tensor, allowed_range: Tuple[float, float] = (0.0, 1.0), **kwargs + synth_img: Tensor, + allowed_range: Tuple[float, float] = (0.0, 1.0), + **kwargs, ) -> Tensor: r"""penalize values outside of allowed_range diff --git a/src/plenoptic/tools/signal.py b/src/plenoptic/tools/signal.py index 33841d7c..5055d306 100644 --- a/src/plenoptic/tools/signal.py +++ b/src/plenoptic/tools/signal.py @@ -16,14 +16,14 @@ def minimum( ---------- x Input tensor. - dim + dim Dimensions over which you would like to compute the minimum. - keepdim + keepdim Keep original dimensions of tensor when returning result. Returns ------- - min_x + min_x Minimum value of x. """ if dim is None: @@ -327,7 +327,6 @@ def make_disk( for i in range(img_size[0]): # height for j in range(img_size[1]): # width - r = np.sqrt((i - i0) ** 2 + (j - j0) ** 2) if r > outer_radius: @@ -335,7 +334,9 @@ def make_disk( elif r < inner_radius: mask[i][j] = 1 else: - radial_decay = (r - inner_radius) / (outer_radius - inner_radius) + radial_decay = (r - inner_radius) / ( + outer_radius - inner_radius + ) mask[i][j] = (1 + np.cos(np.pi * radial_decay)) / 2 return mask @@ -368,7 +369,9 @@ def add_noise(img: Tensor, noise_mse: Union[float, List[float]]) -> Tensor: ).unsqueeze(0) noise_mse = noise_mse.view(noise_mse.nelement(), 1, 1, 1) noise = 200 * torch.randn( - max(noise_mse.shape[0], img.shape[0]), *img.shape[1:], device=img.device + max(noise_mse.shape[0], img.shape[0]), + *img.shape[1:], + device=img.device, ) noise = noise - noise.mean() noise = noise * torch.sqrt( @@ -377,7 +380,7 @@ def add_noise(img: Tensor, noise_mse: Union[float, List[float]]) -> Tensor: return img + noise -def modulate_phase(x: Tensor, phase_factor: float = 2.) -> Tensor: +def modulate_phase(x: Tensor, phase_factor: float = 2.0) -> Tensor: """Modulate the phase of a complex signal. Doubling the phase of a complex signal allows you to, for example, take the @@ -471,8 +474,11 @@ def center_crop(x: Tensor, output_size: int) -> Tensor: """ h, w = x.shape[-2:] - return x[..., (h//2 - output_size//2) : (h//2 + (output_size+1)//2), - (w//2 - output_size//2) : (w//2 + (output_size+1)//2)] + return x[ + ..., + (h // 2 - output_size // 2) : (h // 2 + (output_size + 1) // 2), + (w // 2 - output_size // 2) : (w // 2 + (output_size + 1) // 2), + ] def expand(x: Tensor, factor: float) -> Tensor: @@ -507,9 +513,13 @@ def expand(x: Tensor, factor: float) -> Tensor: mx = factor * im_x my = factor * im_y if int(mx) != mx: - raise ValueError(f"factor * x.shape[-1] must be an integer but got {mx} instead!") + raise ValueError( + f"factor * x.shape[-1] must be an integer but got {mx} instead!" + ) if int(my) != my: - raise ValueError(f"factor * x.shape[-2] must be an integer but got {my} instead!") + raise ValueError( + f"factor * x.shape[-2] must be an integer but got {my} instead!" + ) mx = int(mx) my = int(my) @@ -588,14 +598,20 @@ def shrink(x: Tensor, factor: int) -> Tensor: my = im_y / factor if int(mx) != mx: - raise ValueError(f"x.shape[-1]/factor must be an integer but got {mx} instead!") + raise ValueError( + f"x.shape[-1]/factor must be an integer but got {mx} instead!" + ) if int(my) != my: - raise ValueError(f"x.shape[-2]/factor must be an integer but got {my} instead!") + raise ValueError( + f"x.shape[-2]/factor must be an integer but got {my} instead!" + ) mx = int(mx) my = int(my) - fourier = 1/factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) + fourier = ( + 1 / factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) + ) fourier_small = torch.zeros( *x.shape[:-2], my, @@ -617,9 +633,18 @@ def shrink(x: Tensor, factor: int) -> Tensor: # This line is equivalent to fourier_small[..., 1:, 1:] = fourier[..., y1:y2, x1:x2] - fourier_small[..., 0, 1:] = (fourier[..., y1-1, x1:x2] + fourier[..., y2, x1:x2])/ 2 - fourier_small[..., 1:, 0] = (fourier[..., y1:y2, x1-1] + fourier[..., y1:y2, x2])/ 2 - fourier_small[..., 0, 0] = (fourier[..., y1-1, x1-1] + fourier[..., y1-1, x2] + fourier[..., y2, x1-1] + fourier[..., y2, x2]) / 4 + fourier_small[..., 0, 1:] = ( + fourier[..., y1 - 1, x1:x2] + fourier[..., y2, x1:x2] + ) / 2 + fourier_small[..., 1:, 0] = ( + fourier[..., y1:y2, x1 - 1] + fourier[..., y1:y2, x2] + ) / 2 + fourier_small[..., 0, 0] = ( + fourier[..., y1 - 1, x1 - 1] + + fourier[..., y1 - 1, x2] + + fourier[..., y2, x1 - 1] + + fourier[..., y2, x2] + ) / 4 fourier_small = torch.fft.ifftshift(fourier_small, dim=(-2, -1)) im_small = torch.fft.ifft2(fourier_small) diff --git a/src/plenoptic/tools/stats.py b/src/plenoptic/tools/stats.py index ecabf1c8..975fbb05 100644 --- a/src/plenoptic/tools/stats.py +++ b/src/plenoptic/tools/stats.py @@ -72,7 +72,9 @@ def skew( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow(1.5) + return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow( + 1.5 + ) def kurtosis( @@ -114,4 +116,6 @@ def kurtosis( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean(torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim) / var.pow(2) + return torch.mean( + torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim + ) / var.pow(2) diff --git a/src/plenoptic/tools/straightness.py b/src/plenoptic/tools/straightness.py index e90e651a..fef9cfc9 100644 --- a/src/plenoptic/tools/straightness.py +++ b/src/plenoptic/tools/straightness.py @@ -26,7 +26,9 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: validate_input(start, no_batch=True) validate_input(stop, no_batch=True) if start.shape != stop.shape: - raise ValueError(f"start and stop must be same shape, but got {start.shape} and {stop.shape}!") + raise ValueError( + f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" + ) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") shape = start.shape[1:] @@ -34,15 +36,17 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: device = start.device start = start.reshape(1, -1) stop = stop.reshape(1, -1) - tt = torch.linspace(0, 1, steps=n_steps+1, device=device - ).view(n_steps+1, 1) + tt = torch.linspace(0, 1, steps=n_steps + 1, device=device).view( + n_steps + 1, 1 + ) straight = (1 - tt) * start + tt * stop - return straight.reshape((n_steps+1, *shape)) + return straight.reshape((n_steps + 1, *shape)) -def sample_brownian_bridge(start: Tensor, stop: Tensor, - n_steps: int, max_norm: float = 1) -> Tensor: +def sample_brownian_bridge( + start: Tensor, stop: Tensor, n_steps: int, max_norm: float = 1 +) -> Tensor: """Sample a brownian bridge between `start` and `stop` made up of `n_steps` Parameters @@ -70,7 +74,9 @@ def sample_brownian_bridge(start: Tensor, stop: Tensor, validate_input(start, no_batch=True) validate_input(stop, no_batch=True) if start.shape != stop.shape: - raise ValueError(f"start and stop must be same shape, but got {start.shape} and {stop.shape}!") + raise ValueError( + f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" + ) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") if max_norm < 0: @@ -81,21 +87,22 @@ def sample_brownian_bridge(start: Tensor, stop: Tensor, start = start.reshape(1, -1) stop = stop.reshape(1, -1) D = start.shape[1] - dt = torch.as_tensor(1/n_steps) - tt = torch.linspace(0, 1, steps=n_steps+1, device=device)[:, None] + dt = torch.as_tensor(1 / n_steps) + tt = torch.linspace(0, 1, steps=n_steps + 1, device=device)[:, None] - sigma = torch.sqrt(dt / D) * 2. * max_norm - dW = sigma * torch.randn(n_steps+1, D, device=device) + sigma = torch.sqrt(dt / D) * 2.0 * max_norm + dW = sigma * torch.randn(n_steps + 1, D, device=device) dW[0] = start.flatten() W = torch.cumsum(dW, dim=0) bridge = W - tt * (W[-1:] - stop) - return bridge.reshape((n_steps+1, *shape)) + return bridge.reshape((n_steps + 1, *shape)) -def deviation_from_line(sequence: Tensor, - normalize: bool = True) -> Tuple[Tensor, Tensor]: +def deviation_from_line( + sequence: Tensor, normalize: bool = True +) -> Tuple[Tensor, Tensor]: """Compute the deviation of `sequence` to the straight line between its endpoints. Project each point of the path `sequence` onto the line defined by @@ -126,14 +133,15 @@ def deviation_from_line(sequence: Tensor, y0 = y[0].view(1, D) y1 = y[-1].view(1, D) - line = (y1 - y0) + line = y1 - y0 line_length = torch.linalg.vector_norm(line, ord=2) line = line / line_length y_centered = y - y0 dist_along_line = y_centered @ line[0] projection = dist_along_line.view(T, 1) * line - dist_from_line = torch.linalg.vector_norm(y_centered - projection, dim=1, - ord=2) + dist_from_line = torch.linalg.vector_norm( + y_centered - projection, dim=1, ord=2 + ) if normalize: dist_along_line /= line_length @@ -162,9 +170,9 @@ def translation_sequence(image: Tensor, n_steps: int = 10) -> Tensor: validate_input(image, no_batch=True) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") - sequence = torch.empty(n_steps+1, *image.shape[1:]).to(image.device) + sequence = torch.empty(n_steps + 1, *image.shape[1:]).to(image.device) - for shift in range(n_steps+1): + for shift in range(n_steps + 1): sequence[shift] = torch.roll(image, shift, [-1]) return sequence diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index c062c70f..f1ae938a 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -1,4 +1,5 @@ -"""Functions to validate synthesis inputs. """ +"""Functions to validate synthesis inputs.""" + import torch import warnings import itertools @@ -39,10 +40,17 @@ def validate_input( """ # validate dtype - if input_tensor.dtype not in [torch.float16, torch.complex32, - torch.float32, torch.complex64, - torch.float64, torch.complex128]: - raise TypeError(f"Only float or complex dtypes are allowed but got type {input_tensor.dtype}") + if input_tensor.dtype not in [ + torch.float16, + torch.complex32, + torch.float32, + torch.complex64, + torch.float64, + torch.complex128, + ]: + raise TypeError( + f"Only float or complex dtypes are allowed but got type {input_tensor.dtype}" + ) if input_tensor.ndimension() != 4: if no_batch: n_batch = 1 @@ -64,17 +72,22 @@ def validate_input( "allowed_range[0] must be strictly less than" f" allowed_range[1], but got {allowed_range}" ) - if input_tensor.min() < allowed_range[0] or input_tensor.max() > allowed_range[1]: + if ( + input_tensor.min() < allowed_range[0] + or input_tensor.max() > allowed_range[1] + ): raise ValueError( f"input_tensor range must lie within {allowed_range}, but got" f" {(input_tensor.min().item(), input_tensor.max().item())}" ) -def validate_model(model: torch.nn.Module, - image_shape: Optional[Tuple[int, int, int, int]] = None, - image_dtype: torch.dtype = torch.float32, - device: Union[str, torch.device] = 'cpu'): +def validate_model( + model: torch.nn.Module, + image_shape: Optional[Tuple[int, int, int, int]] = None, + image_dtype: torch.dtype = torch.float32, + device: Union[str, torch.device] = "cpu", +): """Determine whether model can be used for sythesis. In particular, this function checks the following (with their associated @@ -126,8 +139,9 @@ def validate_model(model: torch.nn.Module, """ if image_shape is None: image_shape = (1, 1, 16, 16) - test_img = torch.rand(image_shape, dtype=image_dtype, requires_grad=False, - device=device) + test_img = torch.rand( + image_shape, dtype=image_dtype, requires_grad=False, device=device + ) try: if model(test_img).requires_grad: raise ValueError( @@ -163,7 +177,9 @@ def validate_model(model: torch.nn.Module, elif image_dtype in [torch.float64, torch.complex128]: allowed_dtypes = [torch.float64, torch.complex128] else: - raise TypeError(f"Only float or complex dtypes are allowed but got type {image_dtype}") + raise TypeError( + f"Only float or complex dtypes are allowed but got type {image_dtype}" + ) if model(test_img).dtype not in allowed_dtypes: raise TypeError("model changes precision of input, don't do that!") if model(test_img).ndimension() not in [3, 4]: @@ -181,9 +197,11 @@ def validate_model(model: torch.nn.Module, ) -def validate_coarse_to_fine(model: torch.nn.Module, - image_shape: Optional[Tuple[int, int, int, int]] = None, - device: Union[str, torch.device] = 'cpu'): +def validate_coarse_to_fine( + model: torch.nn.Module, + image_shape: Optional[Tuple[int, int, int, int]] = None, + device: Union[str, torch.device] = "cpu", +): """Determine whether a model can be used for coarse-to-fine synthesis. In particular, this function checks the following (with associated errors): @@ -208,7 +226,9 @@ def validate_coarse_to_fine(model: torch.nn.Module, Which device to place the test image on. """ - warnings.warn("Validating whether model can work with coarse-to-fine synthesis -- this can take a while!") + warnings.warn( + "Validating whether model can work with coarse-to-fine synthesis -- this can take a while!" + ) msg = "and therefore we cannot do coarse-to-fine synthesis" if not hasattr(model, "scales"): raise AttributeError(f"model has no scales attribute {msg}") @@ -230,10 +250,12 @@ def validate_coarse_to_fine(model: torch.nn.Module, ) -def validate_metric(metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], - image_shape: Optional[Tuple[int, int, int, int]] = None, - image_dtype: torch.dtype = torch.float32, - device: Union[str, torch.device] = 'cpu'): +def validate_metric( + metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], + image_shape: Optional[Tuple[int, int, int, int]] = None, + image_dtype: torch.dtype = torch.float32, + device: Union[str, torch.device] = "cpu", +): """Determines whether a metric can be used for MADCompetition synthesis. In particular, this functions checks the following (with associated @@ -270,7 +292,9 @@ def validate_metric(metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Te try: same_val = metric(test_img, test_img).item() except TypeError: - raise TypeError("metric should be callable and accept two 4d tensors as input") + raise TypeError( + "metric should be callable and accept two 4d tensors as input" + ) # as of torch 2.0.0, this is a RuntimeError (a Tensor with X elements # cannot be converted to Scalar); previously it was a ValueError (only one # element tensors can be converted to Python scalars) From 01bbaf9fc8dd4083d9edff1bbb643489a2c1c170 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 9 Aug 2024 09:54:03 -0400 Subject: [PATCH 039/134] running pyupgrade linter to upgrade syntac for newer versions --- examples/00_quickstart.ipynb | 1 - examples/02_Eigendistortions.ipynb | 1 - examples/03_Steerable_Pyramid.ipynb | 3 - examples/04_Perceptual_distance.ipynb | 3 +- examples/05_Geodesics.ipynb | 1 - examples/06_Metamer.ipynb | 2 - examples/08_MAD_Competition.ipynb | 4 - examples/09_Original_MAD.ipynb | 8 -- examples/Metamer-Portilla-Simoncelli.ipynb | 11 -- examples/Synthesis_extensions.ipynb | 16 +-- pyproject.toml | 2 +- src/plenoptic/data/data_utils.py | 13 +- src/plenoptic/data/fetch.py | 110 ++++++++------- src/plenoptic/metric/perceptual_distance.py | 1 - .../canonical_computations/filters.py | 11 +- .../steerable_pyramid_freq.py | 56 ++++---- src/plenoptic/simulate/models/frontend.py | 10 +- src/plenoptic/simulate/models/naive.py | 19 ++- .../simulate/models/portilla_simoncelli.py | 68 ++++----- src/plenoptic/synthesize/eigendistortion.py | 22 +-- src/plenoptic/synthesize/geodesic.py | 23 ++-- src/plenoptic/synthesize/mad_competition.py | 112 ++++++++------- src/plenoptic/synthesize/metamer.py | 130 +++++++++--------- src/plenoptic/synthesize/simple_metamer.py | 5 +- src/plenoptic/synthesize/synthesis.py | 17 ++- src/plenoptic/tools/conv.py | 7 +- src/plenoptic/tools/data.py | 19 ++- src/plenoptic/tools/optim.py | 5 +- src/plenoptic/tools/signal.py | 29 ++-- src/plenoptic/tools/stats.py | 18 ++- src/plenoptic/tools/straightness.py | 3 +- src/plenoptic/tools/validate.py | 25 ++-- 32 files changed, 354 insertions(+), 401 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index 0c550c61..83722317 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -17,7 +17,6 @@ "source": [ "import plenoptic as po\n", "import torch\n", - "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index b075d1a2..679830f9 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -63,7 +63,6 @@ " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\"\n", " )\n", - "import os.path as op\n", "import plenoptic as po" ] }, diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index cd6a2a5b..81ed62f9 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -38,15 +38,12 @@ "from torch import nn\n", "import matplotlib.pyplot as plt\n", "\n", - "import pyrtools as pt\n", "import plenoptic as po\n", "from plenoptic.simulate import SteerablePyramidFreq\n", - "from plenoptic.synthesize import Eigendistortion\n", "from plenoptic.tools.data import to_numpy\n", "\n", "dtype = torch.float32\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "import os\n", "from tqdm.auto import tqdm\n", "\n", "%load_ext autoreload\n", diff --git a/examples/04_Perceptual_distance.ipynb b/examples/04_Perceptual_distance.ipynb index ce44957e..02df2f76 100644 --- a/examples/04_Perceptual_distance.ipynb +++ b/examples/04_Perceptual_distance.ipynb @@ -28,7 +28,6 @@ "outputs": [], "source": [ "import os\n", - "import io\n", "import imageio\n", "import plenoptic as po\n", "import numpy as np\n", @@ -458,7 +457,7 @@ " :, [0] + list(range(2, 17)) + list(range(18, 24))\n", " ] # Remove color distortions\n", "\n", - " with open(folder / \"mos.txt\", \"r\", encoding=\"utf-8\") as g:\n", + " with open(folder / \"mos.txt\", encoding=\"utf-8\") as g:\n", " mos_values = list(map(float, g.readlines()))\n", " mos_values = np.array(mos_values).reshape([25, 24, 5])\n", " mos_values = mos_values[\n", diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index e71e4f2f..cdd3cc87 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -775,7 +775,6 @@ } ], "source": [ - "from torchvision import models\n", "\n", "\n", "# Create a class that takes the nth layer output of a given model\n", diff --git a/examples/06_Metamer.ipynb b/examples/06_Metamer.ipynb index c223c1f1..9b1bdf16 100644 --- a/examples/06_Metamer.ipynb +++ b/examples/06_Metamer.ipynb @@ -22,10 +22,8 @@ "outputs": [], "source": [ "import plenoptic as po\n", - "from plenoptic.tools import to_numpy\n", "import imageio\n", "import torch\n", - "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index 8a81962d..c1ae269b 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -36,14 +36,10 @@ ], "source": [ "import plenoptic as po\n", - "import imageio\n", - "import torch\n", - "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", - "import numpy as np\n", "import warnings\n", "\n", "%load_ext autoreload\n", diff --git a/examples/09_Original_MAD.ipynb b/examples/09_Original_MAD.ipynb index a78b708c..4937cd8b 100644 --- a/examples/09_Original_MAD.ipynb +++ b/examples/09_Original_MAD.ipynb @@ -17,15 +17,7 @@ "metadata": {}, "outputs": [], "source": [ - "import imageio\n", - "import torch\n", - "import scipy.io as sio\n", - "import pyrtools as pt\n", - "from scipy.io import loadmat\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", "import plenoptic as po\n", - "import os.path as op\n", "\n", "%matplotlib inline\n", "\n", diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index eac8f9f4..b7f24ee4 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -15,20 +15,10 @@ } ], "source": [ - "import numpy as np\n", - "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import torch\n", "import plenoptic as po\n", - "import scipy.io as sio\n", - "import os\n", - "import os.path as op\n", "import einops\n", - "import glob\n", - "import math\n", - "import pyrtools as pt\n", - "from tqdm import tqdm\n", - "from PIL import Image\n", "\n", "%load_ext autoreload\n", "%autoreload \n", @@ -2169,7 +2159,6 @@ "metadata": {}, "outputs": [], "source": [ - "from collections import OrderedDict\n", "\n", "\n", "class PortillaSimoncelliMagMeans(po.simul.PortillaSimoncelli):\n", diff --git a/examples/Synthesis_extensions.ipynb b/examples/Synthesis_extensions.ipynb index 840b4d76..5082989d 100644 --- a/examples/Synthesis_extensions.ipynb +++ b/examples/Synthesis_extensions.ipynb @@ -26,8 +26,8 @@ "import torch\n", "import matplotlib.pyplot as plt\n", "import warnings\n", - "from typing import Union, Callable, Tuple, Optional\n", - "from typing_extensions import Literal\n", + "from collections.abc import Callable\n", + "from typing import Literal\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", @@ -49,17 +49,13 @@ " def __init__(\n", " self,\n", " image: Tensor,\n", - " optimized_metric: Union[\n", - " torch.nn.Module, Callable[[Tensor, Tensor], Tensor]\n", - " ],\n", - " reference_metric: Union[\n", - " torch.nn.Module, Callable[[Tensor, Tensor], Tensor]\n", - " ],\n", + " optimized_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor],\n", + " reference_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor],\n", " minmax: Literal[\"min\", \"max\"],\n", " initial_image: Tensor = None,\n", - " metric_tradeoff_lambda: Optional[float] = None,\n", + " metric_tradeoff_lambda: float | None = None,\n", " range_penalty_lambda: float = 0.1,\n", - " allowed_range: Tuple[float, float] = (0, 1),\n", + " allowed_range: tuple[float, float] = (0, 1),\n", " ):\n", " if initial_image is None:\n", " initial_image = torch.rand_like(image)\n", diff --git a/pyproject.toml b/pyproject.toml index 5b543255..0faf6e16 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -131,7 +131,7 @@ select = [ # and missing imports. "F", # pyupgrade - #"UP", + "UP", # flake8-bugbear #"B", # flake8-simplify diff --git a/src/plenoptic/data/data_utils.py b/src/plenoptic/data/data_utils.py index 037baffa..70b2bc18 100644 --- a/src/plenoptic/data/data_utils.py +++ b/src/plenoptic/data/data_utils.py @@ -1,6 +1,5 @@ from importlib import resources from importlib.abc import Traversable -from typing import Union from ..tools.data import load_images @@ -30,12 +29,18 @@ def get_path(item_name: str) -> Traversable: This function uses glob to search for files in the current directory matching the `item_name`. It is assumed that there is only one file matching the name regardless of its extension. """ - fhs = [file for file in resources.files("plenoptic.data").iterdir() if file.stem == item_name] - assert len(fhs) == 1, f"Expected exactly one file for {item_name}, but found {len(fhs)}." + fhs = [ + file + for file in resources.files("plenoptic.data").iterdir() + if file.stem == item_name + ] + assert ( + len(fhs) == 1 + ), f"Expected exactly one file for {item_name}, but found {len(fhs)}." return fhs[0] -def get(*item_names: str, as_gray: Union[None, bool] = None): +def get(*item_names: str, as_gray: None | bool = None): """Load an image based on the item name from the package's data resources. Parameters diff --git a/src/plenoptic/data/fetch.py b/src/plenoptic/data/fetch.py index 3606f644..905f99a6 100644 --- a/src/plenoptic/data/fetch.py +++ b/src/plenoptic/data/fetch.py @@ -5,54 +5,64 @@ """ REGISTRY = { - 'plenoptic-test-files.tar.gz': 'a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8', - 'ssim_images.tar.gz': '19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e', - 'ssim_analysis.mat': '921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24', - 'msssim_images.tar.gz': 'a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c', - 'MAD_results.tar.gz': '29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe', - 'portilla_simoncelli_matlab_test_vectors.tar.gz': '83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81', - 'portilla_simoncelli_test_vectors.tar.gz': 'd67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb', - 'portilla_simoncelli_images.tar.gz': '4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827', - 'portilla_simoncelli_synthesize.npz': '9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80', - 'portilla_simoncelli_synthesize_torch_v1.12.0.npz': '5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f', - 'portilla_simoncelli_synthesize_gpu.npz': '324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee', - 'portilla_simoncelli_scales.npz': 'eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a', - 'sample_images.tar.gz': '0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5', - 'test_images.tar.gz': 'eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554', - 'tid2013.tar.gz': 'bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0', - 'portilla_simoncelli_test_vectors_refactor.tar.gz': '2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a', - 'portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz': '9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47', - 'portilla_simoncelli_synthesize_gpu_ps-refactor.npz': '9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61', - 'portilla_simoncelli_scales_ps-refactor.npz': '1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf', + "plenoptic-test-files.tar.gz": "a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8", + "ssim_images.tar.gz": "19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e", + "ssim_analysis.mat": "921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24", + "msssim_images.tar.gz": "a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c", + "MAD_results.tar.gz": "29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe", + "portilla_simoncelli_matlab_test_vectors.tar.gz": "83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81", + "portilla_simoncelli_test_vectors.tar.gz": "d67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb", + "portilla_simoncelli_images.tar.gz": "4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827", + "portilla_simoncelli_synthesize.npz": "9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80", + "portilla_simoncelli_synthesize_torch_v1.12.0.npz": "5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f", + "portilla_simoncelli_synthesize_gpu.npz": "324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee", + "portilla_simoncelli_scales.npz": "eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a", + "sample_images.tar.gz": "0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5", + "test_images.tar.gz": "eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554", + "tid2013.tar.gz": "bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0", + "portilla_simoncelli_test_vectors_refactor.tar.gz": "2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a", + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": "9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47", + "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": "9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61", + "portilla_simoncelli_scales_ps-refactor.npz": "1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf", } OSF_TEMPLATE = "https://osf.io/{}/download" # these are all from the OSF project at https://osf.io/ts37w/. REGISTRY_URLS = { - 'plenoptic-test-files.tar.gz': OSF_TEMPLATE.format('q9kn8'), - 'ssim_images.tar.gz': OSF_TEMPLATE.format('j65tw'), - 'ssim_analysis.mat': OSF_TEMPLATE.format('ndtc7'), - 'msssim_images.tar.gz': OSF_TEMPLATE.format('5fuba'), - 'MAD_results.tar.gz': OSF_TEMPLATE.format('jwcsr'), - 'portilla_simoncelli_matlab_test_vectors.tar.gz': OSF_TEMPLATE.format('qtn5y'), - 'portilla_simoncelli_test_vectors.tar.gz': OSF_TEMPLATE.format('8r2gq'), - 'portilla_simoncelli_images.tar.gz': OSF_TEMPLATE.format('eqr3t'), - 'portilla_simoncelli_synthesize.npz': OSF_TEMPLATE.format('a7p9r'), - 'portilla_simoncelli_synthesize_torch_v1.12.0.npz': OSF_TEMPLATE.format('gbv8e'), - 'portilla_simoncelli_synthesize_gpu.npz': OSF_TEMPLATE.format('tn4y8'), - 'portilla_simoncelli_scales.npz': OSF_TEMPLATE.format('xhwv3'), - 'sample_images.tar.gz': OSF_TEMPLATE.format('6drmy'), - 'test_images.tar.gz': OSF_TEMPLATE.format('au3b8'), - 'tid2013.tar.gz': OSF_TEMPLATE.format('uscgv'), - 'portilla_simoncelli_test_vectors_refactor.tar.gz': OSF_TEMPLATE.format('ca7qt'), - 'portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz': OSF_TEMPLATE.format('vmwzd'), - 'portilla_simoncelli_synthesize_gpu_ps-refactor.npz': OSF_TEMPLATE.format('mqs6y'), - 'portilla_simoncelli_scales_ps-refactor.npz': OSF_TEMPLATE.format('nvpr4'), + "plenoptic-test-files.tar.gz": OSF_TEMPLATE.format("q9kn8"), + "ssim_images.tar.gz": OSF_TEMPLATE.format("j65tw"), + "ssim_analysis.mat": OSF_TEMPLATE.format("ndtc7"), + "msssim_images.tar.gz": OSF_TEMPLATE.format("5fuba"), + "MAD_results.tar.gz": OSF_TEMPLATE.format("jwcsr"), + "portilla_simoncelli_matlab_test_vectors.tar.gz": OSF_TEMPLATE.format( + "qtn5y" + ), + "portilla_simoncelli_test_vectors.tar.gz": OSF_TEMPLATE.format("8r2gq"), + "portilla_simoncelli_images.tar.gz": OSF_TEMPLATE.format("eqr3t"), + "portilla_simoncelli_synthesize.npz": OSF_TEMPLATE.format("a7p9r"), + "portilla_simoncelli_synthesize_torch_v1.12.0.npz": OSF_TEMPLATE.format( + "gbv8e" + ), + "portilla_simoncelli_synthesize_gpu.npz": OSF_TEMPLATE.format("tn4y8"), + "portilla_simoncelli_scales.npz": OSF_TEMPLATE.format("xhwv3"), + "sample_images.tar.gz": OSF_TEMPLATE.format("6drmy"), + "test_images.tar.gz": OSF_TEMPLATE.format("au3b8"), + "tid2013.tar.gz": OSF_TEMPLATE.format("uscgv"), + "portilla_simoncelli_test_vectors_refactor.tar.gz": OSF_TEMPLATE.format( + "ca7qt" + ), + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": OSF_TEMPLATE.format( + "vmwzd" + ), + "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": OSF_TEMPLATE.format( + "mqs6y" + ), + "portilla_simoncelli_scales_ps-refactor.npz": OSF_TEMPLATE.format("nvpr4"), } DOWNLOADABLE_FILES = list(REGISTRY_URLS.keys()) import pathlib -from typing import List + try: import pooch except ImportError: @@ -63,7 +73,7 @@ # Use the default cache folder for the operating system # Pooch uses appdirs (https://github.com/ActiveState/appdirs) to # select an appropriate directory for the cache on each platform. - path=pooch.os_cache('plenoptic'), + path=pooch.os_cache("plenoptic"), base_url="", urls=REGISTRY_URLS, registry=REGISTRY, @@ -72,7 +82,7 @@ ) -def find_shared_directory(paths: List[pathlib.Path]) -> pathlib.Path: +def find_shared_directory(paths: list[pathlib.Path]) -> pathlib.Path: """Find directory shared by all paths.""" for dir in paths[0].parents: if all([dir in p.parents for p in paths]): @@ -92,17 +102,19 @@ def fetch_data(dataset_name: str) -> pathlib.Path: """ if retriever is None: - raise ImportError("Missing optional dependency 'pooch'." - " Please use pip or " - "conda to install 'pooch'.") - if dataset_name.endswith('.tar.gz'): + raise ImportError( + "Missing optional dependency 'pooch'." + " Please use pip or " + "conda to install 'pooch'." + ) + if dataset_name.endswith(".tar.gz"): processor = pooch.Untar() else: processor = None - fname = retriever.fetch(dataset_name, - progressbar=True, - processor=processor) - if dataset_name.endswith('.tar.gz'): + fname = retriever.fetch( + dataset_name, progressbar=True, processor=processor + ) + if dataset_name.endswith(".tar.gz"): fname = find_shared_directory([pathlib.Path(f) for f in fname]) else: fname = pathlib.Path(fname) diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index 2ee8999e..fc624d7c 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -8,7 +8,6 @@ from ..tools.conv import same_padding import os -import pickle DIRNAME = os.path.dirname(__file__) diff --git a/src/plenoptic/simulate/canonical_computations/filters.py b/src/plenoptic/simulate/canonical_computations/filters.py index ab3770c3..d45c4568 100644 --- a/src/plenoptic/simulate/canonical_computations/filters.py +++ b/src/plenoptic/simulate/canonical_computations/filters.py @@ -1,15 +1,10 @@ -from typing import Union, Tuple - import torch from torch import Tensor -from warnings import warn __all__ = ["gaussian1d", "circular_gaussian2d"] -def gaussian1d( - kernel_size: int = 11, std: Union[float, Tensor] = 1.5 -) -> Tensor: +def gaussian1d(kernel_size: int = 11, std: float | Tensor = 1.5) -> Tensor: """Normalized 1D Gaussian. 1d Gaussian of size `kernel_size`, centered half-way, with variable std @@ -43,8 +38,8 @@ def gaussian1d( def circular_gaussian2d( - kernel_size: Union[int, Tuple[int, int]], - std: Union[float, Tensor], + kernel_size: int | tuple[int, int], + std: float | Tensor, out_channels: int = 1, ) -> Tensor: """Creates normalized, centered circular 2D gaussian tensor with which to convolve. diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index eaae6dba..9c4bc0bb 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -6,7 +6,7 @@ import warnings from collections import OrderedDict -from typing import List, Optional, Tuple, Union +from typing import Union # noqa: UP035 import numpy as np import torch @@ -15,7 +15,7 @@ from einops import rearrange from scipy.special import factorial from torch import Tensor -from typing_extensions import Literal +from typing_extensions import Literal # noqa: UP035 from numpy.typing import NDArray from ...tools.signal import interpolate1d, raised_cosine, steer @@ -23,7 +23,7 @@ complex_types = [torch.cdouble, torch.cfloat] SCALES_TYPE = Union[int, Literal["residual_lowpass", "residual_highpass"]] KEYS_TYPE = Union[ - Tuple[int, int], Literal["residual_lowpass", "residual_highpass"] + tuple[int, int], Literal["residual_lowpass", "residual_highpass"] ] @@ -98,8 +98,8 @@ class SteerablePyramidFreq(nn.Module): def __init__( self, - image_shape: Tuple[int, int], - height: Union[Literal["auto"], int] = "auto", + image_shape: tuple[int, int], + height: Literal["auto"] | int = "auto", order: int = 3, twidth: int = 1, is_complex: bool = False, @@ -299,7 +299,7 @@ def __init__( def forward( self, x: Tensor, - scales: Optional[List[SCALES_TYPE]] = None, + scales: list[SCALES_TYPE] | None = None, ) -> OrderedDict: r"""Generate the steerable pyramid coefficients for an image @@ -432,7 +432,7 @@ def forward( @staticmethod def convert_pyr_to_tensor( pyr_coeffs: OrderedDict, split_complex: bool = False - ) -> Tuple[Tensor, Tuple[int, bool, List[KEYS_TYPE]]]: + ) -> tuple[Tensor, tuple[int, bool, list[KEYS_TYPE]]]: r"""Convert coefficient dictionary to a tensor. The output tensor has shape (batch, channel, height, width) and is @@ -508,10 +508,10 @@ def convert_pyr_to_tensor( try: pyr_tensor = torch.cat(coeff_list, dim=1) pyr_info = tuple([num_channels, split_complex, pyr_keys]) - except RuntimeError as e: + except RuntimeError: raise Exception( - """feature maps could not be concatenated into tensor. - Check that you are using coefficients that are not downsampled across scales. + """feature maps could not be concatenated into tensor. + Check that you are using coefficients that are not downsampled across scales. This is done with the 'downsample=False' argument for the pyramid""" ) @@ -522,7 +522,7 @@ def convert_tensor_to_pyr( pyr_tensor: Tensor, num_channels: int, split_complex: bool, - pyr_keys: List[KEYS_TYPE], + pyr_keys: list[KEYS_TYPE], ) -> OrderedDict: r"""Convert pyramid coefficient tensor to dictionary format. @@ -591,8 +591,8 @@ def convert_tensor_to_pyr( return pyr_coeffs def _recon_levels_check( - self, levels: Union[Literal["all"], List[SCALES_TYPE]] - ) -> List[SCALES_TYPE]: + self, levels: Literal["all"] | list[SCALES_TYPE] + ) -> list[SCALES_TYPE]: r"""Check whether levels arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), @@ -661,8 +661,8 @@ def _recon_levels_check( return levels def _recon_bands_check( - self, bands: Union[Literal["all"], List[int]] - ) -> List[int]: + self, bands: Literal["all"] | list[int] + ) -> list[int]: """Check whether bands arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies @@ -706,10 +706,10 @@ def _recon_bands_check( def _recon_keys( self, - levels: Union[Literal["all"], List[SCALES_TYPE]], - bands: Union[Literal["all"], List[int]], - max_orientations: Optional[int] = None, - ) -> List[KEYS_TYPE]: + levels: Literal["all"] | list[SCALES_TYPE], + bands: Literal["all"] | list[int], + max_orientations: int | None = None, + ) -> list[KEYS_TYPE]: """Make a list of all the relevant keys from `pyr_coeffs` to use in pyramid reconstruction When reconstructing the input image (i.e., when calling `recon_pyr()`), @@ -747,11 +747,9 @@ def _recon_keys( for i in bands: if i >= max_orientations: warnings.warn( - ( - "You wanted band %d in the reconstruction but max_orientation" - " is %d, so we're ignoring that band" - % (i, max_orientations) - ) + "You wanted band %d in the reconstruction but max_orientation" + " is %d, so we're ignoring that band" + % (i, max_orientations) ) bands = [i for i in bands if i < max_orientations] recon_keys = [] @@ -768,8 +766,8 @@ def _recon_keys( def recon_pyr( self, pyr_coeffs: OrderedDict, - levels: Union[Literal["all"], List[SCALES_TYPE]] = "all", - bands: Union[Literal["all"], List[int]] = "all", + levels: Literal["all"] | list[SCALES_TYPE] = "all", + bands: Literal["all"] | list[int] = "all", ) -> Tensor: """Reconstruct the image or batch of images, optionally using subset of pyramid coefficients. @@ -859,7 +857,7 @@ def recon_pyr( return reconstruction def _recon_levels( - self, pyr_coeffs: OrderedDict, recon_keys: List[KEYS_TYPE], scale: int + self, pyr_coeffs: OrderedDict, recon_keys: list[KEYS_TYPE], scale: int ) -> Tensor: """Recursive function used to build the reconstruction. Called by recon_pyr @@ -950,9 +948,9 @@ def _recon_levels( def steer_coeffs( self, pyr_coeffs: OrderedDict, - angles: List[float], + angles: list[float], even_phase: bool = True, - ) -> Tuple[dict, dict]: + ) -> tuple[dict, dict]: """Steer pyramid coefficients to the specified angles This allows you to have filters that have the Gaussian derivative order specified in diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 1af42c8a..1e1f87f3 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -10,7 +10,7 @@ .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ -from typing import Tuple, Union, Callable +from typing import Callable # noqa: UP035 import torch import torch.nn as nn @@ -70,7 +70,7 @@ class LinearNonlinear(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, @@ -156,7 +156,7 @@ class LuminanceGainControl(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, @@ -266,7 +266,7 @@ class LuminanceContrastGainControl(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], on_center: bool = True, width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, @@ -386,7 +386,7 @@ class OnOff(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], + kernel_size: int | tuple[int, int], width_ratio_limit: float = 4.0, amplitude_ratio: float = 1.25, pad_mode: str = "reflect", diff --git a/src/plenoptic/simulate/models/naive.py b/src/plenoptic/simulate/models/naive.py index e9580541..a7fc926a 100644 --- a/src/plenoptic/simulate/models/naive.py +++ b/src/plenoptic/simulate/models/naive.py @@ -1,8 +1,5 @@ -from typing import Union, Tuple, List import torch -from torch import nn, nn as nn, Tensor -from torch import Tensor -import numpy as np +from torch import nn as nn, Tensor from torch.nn import functional as F from ...tools.conv import same_padding @@ -58,7 +55,7 @@ class Linear(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]] = (3, 3), + kernel_size: int | tuple[int, int] = (3, 3), pad_mode: str = "circular", default_filters: bool = True, ): @@ -110,8 +107,8 @@ class Gaussian(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], - std: Union[float, Tensor] = 3.0, + kernel_size: int | tuple[int, int], + std: float | Tensor = 3.0, pad_mode: str = "reflect", out_channels: int = 1, cache_filt: bool = False, @@ -198,12 +195,12 @@ class CenterSurround(nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, int]], - on_center: Union[bool, List[bool,]] = True, + kernel_size: int | tuple[int, int], + on_center: bool | list[bool,] = True, width_ratio_limit: float = 2.0, amplitude_ratio: float = 1.25, - center_std: Union[float, Tensor] = 1.0, - surround_std: Union[float, Tensor] = 4.0, + center_std: float | Tensor = 1.0, + surround_std: float | Tensor = 4.0, out_channels: int = 1, pad_mode: str = "reflect", cache_filt: bool = False, diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index c1fdd240..b87535de 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -8,7 +8,7 @@ """ from collections import OrderedDict -from typing import List, Optional, Tuple, Union +from typing import Union # noqa: UP035 import einops import matplotlib as mpl @@ -18,7 +18,7 @@ import torch.fft import torch.nn as nn from torch import Tensor -from typing_extensions import Literal +from typing_extensions import Literal # noqa: UP035 from ...tools import signal, stats from ...tools.data import to_numpy @@ -83,7 +83,7 @@ class PortillaSimoncelli(nn.Module): def __init__( self, - image_shape: Tuple[int, int], + image_shape: tuple[int, int], n_scales: int = 4, n_orientations: int = 4, spatial_corr_width: int = 9, @@ -239,9 +239,9 @@ def _create_scales_shape_dict(self) -> OrderedDict: dtype=int, ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") - shape_dict["cross_orientation_correlation_magnitude"] = ( - cross_orientation_corr_mag - ) + shape_dict[ + "cross_orientation_correlation_magnitude" + ] = cross_orientation_corr_mag mags_std = np.ones((self.n_orientations, self.n_scales), dtype=int) mags_std *= einops.rearrange(scales, "s -> 1 s") @@ -343,7 +343,7 @@ def _create_necessary_stats_dict( return mask_dict def forward( - self, image: Tensor, scales: Optional[List[SCALES_TYPE]] = None + self, image: Tensor, scales: list[SCALES_TYPE] | None = None ) -> Tensor: r"""Generate Texture Statistics representation of an image. @@ -391,9 +391,10 @@ def forward( # real_pyr_coeffs, which contain the demeaned magnitude of the pyramid # coefficients and the real part of the pyramid coefficients # respectively. - mag_pyr_coeffs, real_pyr_coeffs = ( - self._compute_intermediate_representations(pyr_coeffs) - ) + ( + mag_pyr_coeffs, + real_pyr_coeffs, + ) = self._compute_intermediate_representations(pyr_coeffs) # Then, the reconstructed lowpass image at each scale. (this is a list # of length n_scales+1 containing tensors of shape (batch, channel, @@ -450,9 +451,10 @@ def forward( if self.n_scales != 1: # First, double the phase the coefficients, so we can correctly # compute correlations across scales. - phase_doubled_mags, phase_doubled_sep = ( - self._double_phase_pyr_coeffs(pyr_coeffs) - ) + ( + phase_doubled_mags, + phase_doubled_sep, + ) = self._double_phase_pyr_coeffs(pyr_coeffs) # Compute the cross-scale correlations between the magnitude # coefficients. For each coefficient, we're correlating it with the # coefficients at the next-coarsest scale. this will be a tensor of @@ -514,7 +516,7 @@ def forward( return representation_tensor def remove_scales( - self, representation_tensor: Tensor, scales_to_keep: List[SCALES_TYPE] + self, representation_tensor: Tensor, scales_to_keep: list[SCALES_TYPE] ) -> Tensor: """Remove statistics not associated with scales. @@ -631,7 +633,7 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: def _compute_pyr_coeffs( self, image: Tensor - ) -> Tuple[OrderedDict, List[Tensor], Tensor, Tensor]: + ) -> tuple[OrderedDict, list[Tensor], Tensor, Tensor]: """Compute pyramid coefficients of image. Note that the residual lowpass has been demeaned independently for each @@ -719,7 +721,7 @@ def _compute_pixel_stats(image: Tensor) -> Tensor: @staticmethod def _compute_intermediate_representations( pyr_coeffs: Tensor, - ) -> Tuple[List[Tensor], List[Tensor]]: + ) -> tuple[list[Tensor], list[Tensor]]: """Compute useful intermediate representations. These representations are: @@ -761,7 +763,7 @@ def _compute_intermediate_representations( def _reconstruct_lowpass_at_each_scale( self, pyr_coeffs_dict: OrderedDict - ) -> List[Tensor]: + ) -> list[Tensor]: """Reconstruct the lowpass unoriented image at each scale. The autocorrelation, standard deviation, skew, and kurtosis of each of @@ -803,8 +805,8 @@ def _reconstruct_lowpass_at_each_scale( return reconstructed_images def _compute_autocorr( - self, coeffs_list: List[Tensor] - ) -> Tuple[Tensor, Tensor]: + self, coeffs_list: list[Tensor] + ) -> tuple[Tensor, Tensor]: """Compute the autocorrelation of some statistics. Parameters @@ -850,8 +852,8 @@ def _compute_autocorr( @staticmethod def _compute_skew_kurtosis_recon( - reconstructed_images: List[Tensor], var_recon: Tensor, img_var: Tensor - ) -> Tuple[Tensor, Tensor]: + reconstructed_images: list[Tensor], var_recon: Tensor, img_var: Tensor + ) -> tuple[Tensor, Tensor]: """Compute the skew and kurtosis of each lowpass reconstructed image. For each scale, if the ratio of its variance to the original image's @@ -906,10 +908,10 @@ def _compute_skew_kurtosis_recon( def _compute_cross_correlation( self, - coeffs_tensor: List[Tensor], - coeffs_tensor_other: List[Tensor], + coeffs_tensor: list[Tensor], + coeffs_tensor_other: list[Tensor], tensors_are_identical: bool = False, - ) -> Tuple[Tensor, Tensor]: + ) -> tuple[Tensor, Tensor]: """Compute cross-correlations. Parameters @@ -975,8 +977,8 @@ def _compute_cross_correlation( @staticmethod def _double_phase_pyr_coeffs( - pyr_coeffs: List[Tensor], - ) -> Tuple[List[Tensor], List[Tensor]]: + pyr_coeffs: list[Tensor], + ) -> tuple[list[Tensor], list[Tensor]]: """Upsample and double the phase of pyramid coefficients. Parameters @@ -1026,12 +1028,12 @@ def _double_phase_pyr_coeffs( def plot_representation( self, data: Tensor, - ax: Optional[plt.Axes] = None, - figsize: Tuple[float, float] = (15, 15), - ylim: Optional[Union[Tuple[float, float], Literal[False]]] = None, + ax: plt.Axes | None = None, + figsize: tuple[float, float] = (15, 15), + ylim: tuple[float, float] | Literal[False] | None = None, batch_idx: int = 0, - title: Optional[str] = None, - ) -> Tuple[plt.Figure, List[plt.Axes]]: + title: str | None = None, + ) -> tuple[plt.Figure, list[plt.Axes]]: r"""Plot the representation in a human viewable format -- stem plots with data separated out by statistic type. @@ -1194,10 +1196,10 @@ def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: def update_plot( self, - axes: List[plt.Axes], + axes: list[plt.Axes], data: Tensor, batch_idx: int = 0, - ) -> List[plt.Artist]: + ) -> list[plt.Artist]: r"""Update the information in our representation plot. This is used for creating an animation of the representation diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 4cd837c7..b64db803 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -1,6 +1,6 @@ -from typing import Tuple, List, Callable, Union, Optional +from typing import Callable # noqa: UP035 import warnings -from typing_extensions import Literal +from typing_extensions import Literal # noqa: UP035 import matplotlib.pyplot from matplotlib.figure import Figure @@ -54,7 +54,7 @@ def fisher_info_matrix_vector_product( def fisher_info_matrix_eigenvalue( - y: Tensor, x: Tensor, v: Tensor, dummy_vec: Optional[Tensor] = None + y: Tensor, x: Tensor, v: Tensor, dummy_vec: Tensor | None = None ) -> Tensor: r"""Compute the eigenvalues of the Fisher Information Matrix corresponding to eigenvectors in v :math:`\lambda= v^T F v` @@ -216,7 +216,7 @@ def synthesize( ) if method == "exact": # compute exact Jacobian - print(f"Computing all eigendistortions") + print("Computing all eigendistortions") eig_vals, eig_vecs = self._synthesize_exact() eig_vecs = self._vector_to_image(eig_vecs.detach()) eig_vecs_ind = torch.arange(len(eig_vecs)) @@ -261,7 +261,7 @@ def synthesize( self._eigenvalues = torch.abs(eig_vals.detach()) self._eigenindex = eig_vecs_ind - def _synthesize_exact(self) -> Tuple[Tensor, Tensor]: + def _synthesize_exact(self) -> tuple[Tensor, Tensor]: r"""Eigendecomposition of explicitly computed Fisher Information Matrix. To be used when the input is small (e.g. less than 70x70 image on cluster or 30x30 on your own machine). This @@ -301,8 +301,8 @@ def compute_jacobian(self) -> Tensor: return J def _synthesize_power( - self, k: int, shift: Union[Tensor, float], tol: float, max_iter: int - ) -> Tuple[Tensor, Tensor]: + self, k: int, shift: Tensor | float, tol: float, max_iter: int + ) -> tuple[Tensor, Tensor]: r"""Use power method (or orthogonal iteration when k>1) to obtain largest (smallest) eigenvalue/vector pairs. Apply the algorithm to approximate the extremal eigenvalues and eigenvectors of the Fisher @@ -385,7 +385,7 @@ def _synthesize_power( def _synthesize_randomized_svd( self, k: int, p: int, q: int - ) -> Tuple[Tensor, Tensor, Tensor]: + ) -> tuple[Tensor, Tensor, Tensor]: r"""Synthesize eigendistortions using randomized truncated SVD. This method approximates the column space of the Fisher Info Matrix, projects the FIM into that column space, @@ -450,7 +450,7 @@ def _synthesize_randomized_svd( return S[:k].clone(), V[:, :k].clone(), error_approx # truncate - def _vector_to_image(self, vecs: Tensor) -> List[Tensor]: + def _vector_to_image(self, vecs: Tensor) -> list[Tensor]: r"""Reshapes eigenvectors back into correct image dimensions. Parameters @@ -550,7 +550,7 @@ def to(self, *args, **kwargs): def load( self, file_path: str, - map_location: Union[str, None] = None, + map_location: str | None = None, **pickle_load_args, ): r"""Load all relevant stuff from a .pt file. @@ -636,7 +636,7 @@ def display_eigendistortion( eigenindex: int = 0, alpha: float = 5.0, process_image: Callable[[Tensor], Tensor] = lambda x: x, - ax: Optional[matplotlib.pyplot.axis] = None, + ax: matplotlib.pyplot.axis | None = None, plot_complex: str = "rectangular", **kwargs, ) -> Figure: diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index b74a027b..11f388e8 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -6,8 +6,7 @@ import torch.autograd as autograd from torch import Tensor from tqdm.auto import tqdm -from typing import Union, Tuple, Optional -from typing_extensions import Literal +from typing_extensions import Literal # noqa: UP035 from .synthesis import OptimizedSynthesis from ..tools.data import to_numpy @@ -108,7 +107,7 @@ def __init__( n_steps: int = 10, initial_sequence: Literal["straight", "bridge"] = "straight", range_penalty_lambda: float = 0.1, - allowed_range: Tuple[float, float] = (0, 1), + allowed_range: tuple[float, float] = (0, 1), ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image_a, no_batch=True, allowed_range=allowed_range) @@ -155,9 +154,9 @@ def _initialize(self, initial_sequence, start, stop, n_steps): def synthesize( self, max_iter: int = 1000, - optimizer: Optional[torch.optim.Optimizer] = None, - store_progress: Union[bool, int] = False, - stop_criterion: Optional[float] = None, + optimizer: torch.optim.Optimizer | None = None, + store_progress: bool | int = False, + stop_criterion: float | None = None, stop_iters_to_check: int = 50, ): """Synthesize a geodesic via optimization. @@ -223,7 +222,7 @@ def synthesize( pbar.close() - def objective_function(self, geodesic: Optional[Tensor] = None) -> Tensor: + def objective_function(self, geodesic: Tensor | None = None) -> Tensor: """Compute geodesic synthesis loss. This is the path energy (i.e., squared L2 norm of each step) of the @@ -340,7 +339,7 @@ def _check_convergence( self, stop_criterion, stop_iters_to_check ) - def calculate_jerkiness(self, geodesic: Optional[Tensor] = None) -> Tensor: + def calculate_jerkiness(self, geodesic: Tensor | None = None) -> Tensor: """Compute the alignment of representation's acceleration to model local curvature. This is the first order optimality condition for a geodesic, and can be @@ -500,7 +499,7 @@ def to(self, *args, **kwargs): def load( self, file_path: str, - map_location: Union[str, None] = None, + map_location: str | None = None, **pickle_load_args, ): r"""Load all relevant stuff from a .pt file. @@ -624,7 +623,7 @@ def dev_from_line(self): def plot_loss( - geodesic: Geodesic, ax: Union[mpl.axes.Axes, None] = None, **kwargs + geodesic: Geodesic, ax: mpl.axes.Axes | None = None, **kwargs ) -> mpl.axes.Axes: """Plot synthesis loss. @@ -653,8 +652,8 @@ def plot_loss( def plot_deviation_from_line( geodesic: Geodesic, - natural_video: Union[Tensor, None] = None, - ax: Union[mpl.axes.Axes, None] = None, + natural_video: Tensor | None = None, + ax: mpl.axes.Axes | None = None, ) -> mpl.axes.Axes: """Visual diagnostic of geodesic linearity in representation space. diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index d5a24904..0064b589 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -5,8 +5,8 @@ from torch import Tensor from tqdm.auto import tqdm from ..tools import optim, display, data -from typing import Union, Tuple, Callable, List, Dict, Optional -from typing_extensions import Literal +from typing import Callable # noqa: UP035 +from typing_extensions import Literal # noqa: UP035 from .synthesis import OptimizedSynthesis import warnings import matplotlib as mpl @@ -102,17 +102,13 @@ class MADCompetition(OptimizedSynthesis): def __init__( self, image: Tensor, - optimized_metric: Union[ - torch.nn.Module, Callable[[Tensor, Tensor], Tensor] - ], - reference_metric: Union[ - torch.nn.Module, Callable[[Tensor, Tensor], Tensor] - ], + optimized_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], + reference_metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], minmax: Literal["min", "max"], initial_noise: float = 0.1, - metric_tradeoff_lambda: Optional[float] = None, + metric_tradeoff_lambda: float | None = None, range_penalty_lambda: float = 0.1, - allowed_range: Tuple[float, float] = (0, 1), + allowed_range: tuple[float, float] = (0, 1), ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) @@ -190,9 +186,9 @@ def _initialize(self, initial_noise: float = 0.1): def synthesize( self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, + optimizer: torch.optim.Optimizer | None = None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, + store_progress: bool | int = False, stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, ): @@ -259,8 +255,8 @@ def synthesize( def objective_function( self, - mad_image: Optional[Tensor] = None, - image: Optional[Tensor] = None, + mad_image: Tensor | None = None, + image: Tensor | None = None, ) -> Tensor: r"""Compute the MADCompetition synthesis loss. @@ -499,7 +495,7 @@ def to(self, *args, **kwargs): def load( self, file_path: str, - map_location: Optional[None] = None, + map_location: None | None = None, **pickle_load_args, ): r"""Load all relevant stuff from a .pt file. @@ -609,8 +605,8 @@ def saved_mad_image(self): def plot_loss( mad: MADCompetition, - iteration: Optional[int] = None, - axes: Union[List[mpl.axes.Axes], mpl.axes.Axes, None] = None, + iteration: int | None = None, + axes: list[mpl.axes.Axes] | mpl.axes.Axes | None = None, **kwargs, ) -> mpl.axes.Axes: """Plot metric losses. @@ -676,10 +672,10 @@ def plot_loss( def display_mad_image( mad: MADCompetition, batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, + channel_idx: int | None = None, + zoom: float | None = None, + iteration: int | None = None, + ax: mpl.axes.Axes | None = None, title: str = "MADCompetition", **kwargs, ) -> mpl.axes.Axes: @@ -755,10 +751,10 @@ def display_mad_image( def plot_pixel_values( mad: MADCompetition, batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float], Literal[False]] = False, - ax: Optional[mpl.axes.Axes] = None, + channel_idx: int | None = None, + iteration: int | None = None, + ylim: tuple[float] | Literal[False] = False, + ax: mpl.axes.Axes | None = None, **kwargs, ) -> mpl.axes.Axes: r"""Plot histogram of pixel values of reference and MAD images. @@ -840,7 +836,7 @@ def _freedman_diaconis_bins(a): def _check_included_plots( - to_check: Union[List[str], Dict[str, int]], to_check_name: str + to_check: list[str] | dict[str, int], to_check_name: str ): """Check whether the user wanted us to create plots that we can't. @@ -877,10 +873,10 @@ def _check_included_plots( def _setup_synthesis_fig( - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = [ + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float] | None = None, + included_plots: list[str] = [ "display_mad_image", "plot_loss", "plot_pixel_values", @@ -888,7 +884,7 @@ def _setup_synthesis_fig( display_mad_image_width: float = 1, plot_loss_width: float = 2, plot_pixel_values_width: float = 1, -) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: +) -> tuple[mpl.figure.Figure, list[mpl.axes.Axes], dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -994,20 +990,20 @@ def _setup_synthesis_fig( def plot_synthesis_status( mad: MADCompetition, batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - vrange: Union[Tuple[float], str] = "indep1", - zoom: Optional[float] = None, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = [ + channel_idx: int | None = None, + iteration: int | None = None, + vrange: tuple[float] | str = "indep1", + zoom: float | None = None, + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float] | None = None, + included_plots: list[str] = [ "display_mad_image", "plot_loss", "plot_pixel_values", ], - width_ratios: Dict[str, float] = {}, -) -> Tuple[mpl.figure.Figure, Dict[str, int]]: + width_ratios: dict[str, float] = {}, +) -> tuple[mpl.figure.Figure, dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create two @@ -1132,17 +1128,17 @@ def animate( mad: MADCompetition, framerate: int = 10, batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float]] = None, - included_plots: List[str] = [ + channel_idx: int | None = None, + zoom: float | None = None, + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float] | None = None, + included_plots: list[str] = [ "display_mad_image", "plot_loss", "plot_pixel_values", ], - width_ratios: Dict[str, float] = {}, + width_ratios: dict[str, float] = {}, ) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. @@ -1301,9 +1297,9 @@ def display_mad_image_all( mad_metric2_min: MADCompetition, mad_metric1_max: MADCompetition, mad_metric2_max: MADCompetition, - metric1_name: Optional[str] = None, - metric2_name: Optional[str] = None, - zoom: Union[int, float] = 1, + metric1_name: str | None = None, + metric2_name: str | None = None, + zoom: int | float = 1, **kwargs, ) -> mpl.figure.Figure: """Display all MAD Competition images. @@ -1409,12 +1405,12 @@ def plot_loss_all( mad_metric2_min: MADCompetition, mad_metric1_max: MADCompetition, mad_metric2_max: MADCompetition, - metric1_name: Optional[str] = None, - metric2_name: Optional[str] = None, - metric1_kwargs: Dict = {"c": "C0"}, - metric2_kwargs: Dict = {"c": "C1"}, - min_kwargs: Dict = {"linestyle": "--"}, - max_kwargs: Dict = {"linestyle": "-"}, + metric1_name: str | None = None, + metric2_name: str | None = None, + metric1_kwargs: dict = {"c": "C0"}, + metric2_kwargs: dict = {"c": "C1"}, + min_kwargs: dict = {"linestyle": "--"}, + max_kwargs: dict = {"linestyle": "-"}, figsize=(10, 5), ) -> mpl.figure.Figure: """Plot loss for full set of MAD Competiton instances. diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index aa0972c3..a557ae68 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -13,8 +13,8 @@ validate_coarse_to_fine, ) from ..tools.convergence import coarse_to_fine_enough, loss_convergence -from typing import Union, Tuple, Callable, List, Dict, Optional -from typing_extensions import Literal +from typing import Callable # noqa: UP035 +from typing_extensions import Literal # noqa: UP035 from .synthesis import OptimizedSynthesis import warnings import matplotlib as mpl @@ -94,8 +94,8 @@ def __init__( model: torch.nn.Module, loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, range_penalty_lambda: float = 0.1, - allowed_range: Tuple[float, float] = (0, 1), - initial_image: Optional[Tensor] = None, + allowed_range: tuple[float, float] = (0, 1), + initial_image: Tensor | None = None, ): super().__init__(range_penalty_lambda, allowed_range) validate_input(image, allowed_range=allowed_range) @@ -115,7 +115,7 @@ def __init__( self._saved_metamer = [] self._store_progress = None - def _initialize(self, initial_image: Optional[Tensor] = None): + def _initialize(self, initial_image: Tensor | None = None): """Initialize the metamer. Set the ``self.metamer`` attribute to be an attribute with the @@ -154,9 +154,9 @@ def _initialize(self, initial_image: Optional[Tensor] = None): def synthesize( self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, + optimizer: torch.optim.Optimizer | None = None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, + store_progress: bool | int = False, stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, ): @@ -220,8 +220,8 @@ def synthesize( def objective_function( self, - metamer_representation: Optional[Tensor] = None, - target_representation: Optional[Tensor] = None, + metamer_representation: Tensor | None = None, + target_representation: Tensor | None = None, ) -> Tensor: """Compute the metamer synthesis loss. @@ -330,8 +330,8 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): def _initialize_optimizer( self, - optimizer: Optional[torch.optim.Optimizer], - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler], + optimizer: torch.optim.Optimizer | None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None, ): """Initialize optimizer and scheduler.""" # this uses the OptimizedSynthesis setter @@ -429,7 +429,7 @@ def to(self, *args, **kwargs): def load( self, file_path: str, - map_location: Optional[str] = None, + map_location: str | None = None, **pickle_load_args, ): r"""Load all relevant stuff from a .pt file. @@ -471,9 +471,9 @@ def load( def _load( self, file_path: str, - map_location: Optional[str] = None, - additional_check_attributes: List[str] = [], - additional_check_loss_functions: List[str] = [], + map_location: str | None = None, + additional_check_attributes: list[str] = [], + additional_check_loss_functions: list[str] = [], **pickle_load_args, ): r"""Helper function for loading. @@ -610,8 +610,8 @@ def __init__( model: torch.nn.Module, loss_function: Callable[[Tensor, Tensor], Tensor] = optim.mse, range_penalty_lambda: float = 0.1, - allowed_range: Tuple[float, float] = (0, 1), - initial_image: Optional[Tensor] = None, + allowed_range: tuple[float, float] = (0, 1), + initial_image: Tensor | None = None, coarse_to_fine: Literal["together", "separate"] = "together", ): super().__init__( @@ -652,12 +652,12 @@ def _init_ctf(self, coarse_to_fine: Literal["together", "separate"]): def synthesize( self, max_iter: int = 100, - optimizer: Optional[torch.optim.Optimizer] = None, - scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, - store_progress: Union[bool, int] = False, + optimizer: torch.optim.Optimizer | None = None, + scheduler: torch.optim.lr_scheduler._LRScheduler | None = None, + store_progress: bool | int = False, stop_criterion: float = 1e-4, stop_iters_to_check: int = 50, - change_scale_criterion: Optional[float] = 1e-2, + change_scale_criterion: float | None = 1e-2, ctf_iters_to_check: int = 50, ): r"""Synthesize a metamer. @@ -832,7 +832,7 @@ def _optimizer_step( ) return overall_loss - def _closure(self) -> Tuple[Tensor, Tensor]: + def _closure(self) -> tuple[Tensor, Tensor]: r"""An abstraction of the gradient calculation, before the optimization step. This enables optimization algorithms that perform several evaluations @@ -940,7 +940,7 @@ def _check_convergence( def load( self, file_path: str, - map_location: Optional[str] = None, + map_location: str | None = None, **pickle_load_args, ): r"""Load all relevant stuff from a .pt file. @@ -1004,8 +1004,8 @@ def scales_finished(self): def plot_loss( metamer: Metamer, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, + iteration: int | None = None, + ax: mpl.axes.Axes | None = None, **kwargs, ) -> mpl.axes.Axes: """Plot synthesis loss with log-scaled y axis. @@ -1056,10 +1056,10 @@ def plot_loss( def display_metamer( metamer: Metamer, batch_idx: int = 0, - channel_idx: Optional[int] = None, - zoom: Optional[float] = None, - iteration: Optional[int] = None, - ax: Optional[mpl.axes.Axes] = None, + channel_idx: int | None = None, + zoom: float | None = None, + iteration: int | None = None, + ax: mpl.axes.Axes | None = None, **kwargs, ) -> mpl.axes.Axes: """Display metamer. @@ -1130,7 +1130,7 @@ def display_metamer( def _representation_error( - metamer: Metamer, iteration: Optional[int] = None, **kwargs + metamer: Metamer, iteration: int | None = None, **kwargs ) -> Tensor: r"""Get the representation error. @@ -1167,12 +1167,12 @@ def _representation_error( def plot_representation_error( metamer: Metamer, batch_idx: int = 0, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], None, Literal[False]] = None, - ax: Optional[mpl.axes.Axes] = None, + iteration: int | None = None, + ylim: tuple[float, float] | None | Literal[False] = None, + ax: mpl.axes.Axes | None = None, as_rgb: bool = False, **kwargs, -) -> List[mpl.axes.Axes]: +) -> list[mpl.axes.Axes]: r"""Plot distance ratio showing how close we are to convergence. We plot ``_representation_error(metamer, iteration)``. For more details, see @@ -1228,10 +1228,10 @@ def plot_representation_error( def plot_pixel_values( metamer: Metamer, batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], Literal[False]] = False, - ax: Optional[mpl.axes.Axes] = None, + channel_idx: int | None = None, + iteration: int | None = None, + ylim: tuple[float, float] | Literal[False] = False, + ax: mpl.axes.Axes | None = None, **kwargs, ) -> mpl.axes.Axes: r"""Plot histogram of pixel values of target image and its metamer. @@ -1313,7 +1313,7 @@ def _freedman_diaconis_bins(a): def _check_included_plots( - to_check: Union[List[str], Dict[str, float]], to_check_name: str + to_check: list[str] | dict[str, float], to_check_name: str ): """Check whether the user wanted us to create plots that we can't. @@ -1351,10 +1351,10 @@ def _check_included_plots( def _setup_synthesis_fig( - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = [ + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float, float] | None = None, + included_plots: list[str] = [ "display_metamer", "plot_loss", "plot_representation_error", @@ -1363,7 +1363,7 @@ def _setup_synthesis_fig( plot_loss_width: float = 1, plot_representation_error_width: float = 1, plot_pixel_values_width: float = 1, -) -> Tuple[mpl.figure.Figure, List[mpl.axes.Axes], Dict[str, int]]: +) -> tuple[mpl.figure.Figure, list[mpl.axes.Axes], dict[str, int]]: """Set up figure for plot_synthesis_status. Creates figure with enough axes for the all the plots you want. Will @@ -1477,22 +1477,22 @@ def _setup_synthesis_fig( def plot_synthesis_status( metamer: Metamer, batch_idx: int = 0, - channel_idx: Optional[int] = None, - iteration: Optional[int] = None, - ylim: Union[Tuple[float, float], None, Literal[False]] = None, - vrange: Union[Tuple[float, float], str] = "indep1", - zoom: Optional[float] = None, + channel_idx: int | None = None, + iteration: int | None = None, + ylim: tuple[float, float] | None | Literal[False] = None, + vrange: tuple[float, float] | str = "indep1", + zoom: float | None = None, plot_representation_error_as_rgb: bool = False, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = [ + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float, float] | None = None, + included_plots: list[str] = [ "display_metamer", "plot_loss", "plot_representation_error", ], - width_ratios: Dict[str, float] = {}, -) -> Tuple[mpl.figure.Figure, Dict[str, int]]: + width_ratios: dict[str, float] = {}, +) -> tuple[mpl.figure.Figure, dict[str, int]]: r"""Make a plot showing synthesis status. We create several subplots to analyze this. By default, we create three @@ -1645,20 +1645,20 @@ def animate( metamer: Metamer, framerate: int = 10, batch_idx: int = 0, - channel_idx: Optional[int] = None, - ylim: Union[str, None, Tuple[float, float], Literal[False]] = None, - vrange: Union[Tuple[float, float], str] = (0, 1), - zoom: Optional[float] = None, + channel_idx: int | None = None, + ylim: str | None | tuple[float, float] | Literal[False] = None, + vrange: tuple[float, float] | str = (0, 1), + zoom: float | None = None, plot_representation_error_as_rgb: bool = False, - fig: Optional[mpl.figure.Figure] = None, - axes_idx: Dict[str, int] = {}, - figsize: Optional[Tuple[float, float]] = None, - included_plots: List[str] = [ + fig: mpl.figure.Figure | None = None, + axes_idx: dict[str, int] = {}, + figsize: tuple[float, float] | None = None, + included_plots: list[str] = [ "display_metamer", "plot_loss", "plot_representation_error", ], - width_ratios: Dict[str, float] = {}, + width_ratios: dict[str, float] = {}, ) -> mpl.animation.FuncAnimation: r"""Animate synthesis progress. diff --git a/src/plenoptic/synthesize/simple_metamer.py b/src/plenoptic/synthesize/simple_metamer.py index 916b0f6c..0c80c13c 100644 --- a/src/plenoptic/synthesize/simple_metamer.py +++ b/src/plenoptic/synthesize/simple_metamer.py @@ -5,7 +5,6 @@ from .synthesis import Synthesis from ..tools.validate import validate_input, validate_model from ..tools import optim -from typing import Union class SimpleMetamer(Synthesis): @@ -46,7 +45,7 @@ def __init__(self, image: torch.Tensor, model: torch.nn.Module): def synthesize( self, max_iter: int = 100, - optimizer: Union[None, torch.optim.Optimizer] = None, + optimizer: None | torch.optim.Optimizer = None, ) -> torch.Tensor: """Synthesize a simple metamer. @@ -108,7 +107,7 @@ def save(self, file_path: str): """ super().save(file_path, attrs=None) - def load(self, file_path: str, map_location: Union[str, None] = None): + def load(self, file_path: str, map_location: str | None = None): r"""Load all relevant attributes from a .pt file. Note this operates in place and so doesn't return anything. diff --git a/src/plenoptic/synthesize/synthesis.py b/src/plenoptic/synthesize/synthesis.py index f6488fc0..18846661 100644 --- a/src/plenoptic/synthesize/synthesis.py +++ b/src/plenoptic/synthesize/synthesis.py @@ -3,7 +3,6 @@ import abc import warnings import torch -from typing import Optional, List, Tuple, Union class Synthesis(abc.ABC): @@ -21,7 +20,7 @@ def synthesize(self): r"""Synthesize something.""" pass - def save(self, file_path: str, attrs: Optional[List[str]] = None): + def save(self, file_path: str, attrs: list[str] | None = None): r"""Save all relevant (non-model) variables in .pt file. If you leave attrs as None, we grab vars(self) and exclude 'model'. @@ -62,9 +61,9 @@ def save(self, file_path: str, attrs: Optional[List[str]] = None): def load( self, file_path: str, - map_location: Optional[str] = None, - check_attributes: List[str] = [], - check_loss_functions: List[str] = [], + map_location: str | None = None, + check_attributes: list[str] = [], + check_loss_functions: list[str] = [], **pickle_load_args, ): r"""Load all relevant attributes from a .pt file. @@ -195,7 +194,7 @@ def load( setattr(self, k, v) @abc.abstractmethod - def to(self, *args, attrs: List[str] = [], **kwargs): + def to(self, *args, attrs: list[str] = [], **kwargs): r"""Moves and/or casts the parameters and buffers. Similar to ``save``, this is an abstract method only because you need to define the attributes to call to on. @@ -270,7 +269,7 @@ class OptimizedSynthesis(Synthesis): def __init__( self, range_penalty_lambda: float = 0.1, - allowed_range: Tuple[float, float] = (0, 1), + allowed_range: tuple[float, float] = (0, 1), ): """Initialize the properties of OptimizedSynthesis.""" self._losses = [] @@ -327,7 +326,7 @@ def _closure(self) -> torch.Tensor: def _initialize_optimizer( self, - optimizer: Optional[torch.optim.Optimizer], + optimizer: torch.optim.Optimizer | None, synth_name: str, learning_rate: float = 0.01, ): @@ -394,7 +393,7 @@ def store_progress(self): return self._store_progress @store_progress.setter - def store_progress(self, store_progress: Union[bool, int]): + def store_progress(self, store_progress: bool | int): """Initialize store_progress. Sets the ``self.store_progress`` attribute, as well as changing the diff --git a/src/plenoptic/tools/conv.py b/src/plenoptic/tools/conv.py index 0a0a442f..783f7114 100644 --- a/src/plenoptic/tools/conv.py +++ b/src/plenoptic/tools/conv.py @@ -3,7 +3,6 @@ from torch import Tensor import torch.nn.functional as F import pyrtools as pt -from typing import Union, Tuple import math @@ -145,9 +144,9 @@ def _get_same_padding( def same_padding( x: Tensor, - kernel_size: Union[int, Tuple[int, int]], - stride: Union[int, Tuple[int, int]] = (1, 1), - dilation: Union[int, Tuple[int, int]] = (1, 1), + kernel_size: int | tuple[int, int], + stride: int | tuple[int, int] = (1, 1), + dilation: int | tuple[int, int] = (1, 1), pad_mode: str = "circular", ) -> Tensor: """Pad a tensor so that 2D convolution will result in output with same dims.""" diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index 3e430f3f..9afda3f0 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -1,5 +1,4 @@ import pathlib -from typing import List, Optional, Union, Tuple import warnings import imageio @@ -33,9 +32,7 @@ } -def to_numpy( - x: Union[Tensor, np.ndarray], squeeze: bool = False -) -> np.ndarray: +def to_numpy(x: Tensor | np.ndarray, squeeze: bool = False) -> np.ndarray: r"""cast tensor to numpy in the most conservative way possible Parameters @@ -61,7 +58,7 @@ def to_numpy( return x -def load_images(paths: Union[str, List[str]], as_gray: bool = True) -> Tensor: +def load_images(paths: str | list[str], as_gray: bool = True) -> Tensor: r"""Correctly load in images Our models and synthesis methods expect their inputs to be 4d @@ -286,10 +283,10 @@ def make_synthetic_stimuli( def polar_radius( - size: Union[int, Tuple[int, int]], + size: int | tuple[int, int], exponent: float = 1.0, - origin: Optional[Union[int, Tuple[int, int]]] = None, - device: Optional[Union[str, torch.device]] = None, + origin: int | tuple[int, int] | None = None, + device: str | torch.device | None = None, ) -> Tensor: """Make distance-from-origin (r) matrix @@ -347,10 +344,10 @@ def polar_radius( def polar_angle( - size: Union[int, Tuple[int, int]], + size: int | tuple[int, int], phase: float = 0.0, - origin: Optional[Union[int, Tuple[float, float]]] = None, - device: Optional[torch.device] = None, + origin: int | tuple[float, float] | None = None, + device: torch.device | None = None, ) -> Tensor: """Make polar angle matrix (in radians). diff --git a/src/plenoptic/tools/optim.py b/src/plenoptic/tools/optim.py index 6423ceb1..19ea5359 100644 --- a/src/plenoptic/tools/optim.py +++ b/src/plenoptic/tools/optim.py @@ -2,11 +2,10 @@ import torch from torch import Tensor -from typing import Optional, Tuple import numpy as np -def set_seed(seed: Optional[int] = None) -> None: +def set_seed(seed: int | None = None) -> None: """Set the seed. We call both ``torch.manual_seed()`` and ``np.random.seed()``. @@ -107,7 +106,7 @@ def relative_MSE(synth_rep: Tensor, ref_rep: Tensor, **kwargs) -> Tensor: def penalize_range( synth_img: Tensor, - allowed_range: Tuple[float, float] = (0.0, 1.0), + allowed_range: tuple[float, float] = (0.0, 1.0), **kwargs, ) -> Tensor: r"""penalize values outside of allowed_range diff --git a/src/plenoptic/tools/signal.py b/src/plenoptic/tools/signal.py index 5055d306..7d91b135 100644 --- a/src/plenoptic/tools/signal.py +++ b/src/plenoptic/tools/signal.py @@ -1,14 +1,11 @@ -from typing import List, Optional, Tuple, Union - import numpy as np import torch from torch import Tensor -import torch.fft as fft from pyrtools.pyramids.steer import steer_to_harmonics_mtx def minimum( - x: Tensor, dim: Optional[List[int]] = None, keepdim: bool = False + x: Tensor, dim: list[int] | None = None, keepdim: bool = False ) -> Tensor: r"""Compute minimum in torch over any axis or combination of axes in tensor. @@ -36,7 +33,7 @@ def minimum( def maximum( - x: Tensor, dim: Optional[List[int]] = None, keepdim: bool = False + x: Tensor, dim: list[int] | None = None, keepdim: bool = False ) -> Tensor: r"""Compute maximum in torch over any dim or combination of axes in tensor. @@ -73,8 +70,8 @@ def rescale(x: Tensor, a: float = 0.0, b: float = 1.0) -> Tensor: def raised_cosine( - width: float = 1, position: float = 0, values: Tuple[float, float] = (0, 1) -) -> Tuple[np.ndarray, np.ndarray]: + width: float = 1, position: float = 0, values: tuple[float, float] = (0, 1) +) -> tuple[np.ndarray, np.ndarray]: """Return a lookup table containing a "raised cosine" soft threshold function. Y = VALUES(1) @@ -116,7 +113,7 @@ def raised_cosine( def interpolate1d( - x_new: Tensor, Y: Union[Tensor, np.ndarray], X: Union[Tensor, np.ndarray] + x_new: Tensor, Y: Tensor | np.ndarray, X: Tensor | np.ndarray ) -> Tensor: r"""One-dimensional linear interpolation. @@ -145,7 +142,7 @@ def interpolate1d( return np.reshape(out, x_new.shape) -def rectangular_to_polar(x: Tensor) -> Tuple[Tensor, Tensor]: +def rectangular_to_polar(x: Tensor) -> tuple[Tensor, Tensor]: r"""Rectangular to polar coordinate transform Parameters @@ -190,9 +187,9 @@ def polar_to_rectangular(amplitude: Tensor, phase: Tensor) -> Tensor: def steer( basis: Tensor, - angle: Union[np.ndarray, Tensor, float], - harmonics: Optional[List[int]] = None, - steermtx: Optional[Union[Tensor, np.ndarray]] = None, + angle: np.ndarray | Tensor | float, + harmonics: list[int] | None = None, + steermtx: Tensor | np.ndarray | None = None, return_weights: bool = False, even_phase: bool = True, ): @@ -286,9 +283,9 @@ def steer( def make_disk( - img_size: Union[int, Tuple[int, int], torch.Size], - outer_radius: Optional[float] = None, - inner_radius: Optional[float] = None, + img_size: int | tuple[int, int] | torch.Size, + outer_radius: float | None = None, + inner_radius: float | None = None, ) -> Tensor: r"""Create a circular mask with softened edges to an image. @@ -342,7 +339,7 @@ def make_disk( return mask -def add_noise(img: Tensor, noise_mse: Union[float, List[float]]) -> Tensor: +def add_noise(img: Tensor, noise_mse: float | list[float]) -> Tensor: """Add normally distributed noise to an image This adds normally-distributed noise to an image so that the resulting diff --git a/src/plenoptic/tools/stats.py b/src/plenoptic/tools/stats.py index 975fbb05..f862ea0d 100644 --- a/src/plenoptic/tools/stats.py +++ b/src/plenoptic/tools/stats.py @@ -1,13 +1,11 @@ -from typing import List, Optional, Union - import torch from torch import Tensor def variance( x: Tensor, - mean: Optional[Union[float, Tensor]] = None, - dim: Optional[Union[int, List[int]]] = None, + mean: float | Tensor | None = None, + dim: int | list[int] | None = None, keepdim: bool = False, ) -> Tensor: r"""Calculate sample variance. @@ -41,9 +39,9 @@ def variance( def skew( x: Tensor, - mean: Optional[Union[float, Tensor]] = None, - var: Optional[Union[float, Tensor]] = None, - dim: Optional[Union[int, List[int]]] = None, + mean: float | Tensor | None = None, + var: float | Tensor | None = None, + dim: int | list[int] | None = None, keepdim: bool = False, ) -> Tensor: r"""Sample estimate of `x` *asymmetry* about its mean @@ -79,9 +77,9 @@ def skew( def kurtosis( x: Tensor, - mean: Optional[Union[float, Tensor]] = None, - var: Optional[Union[float, Tensor]] = None, - dim: Optional[Union[int, List[int]]] = None, + mean: float | Tensor | None = None, + var: float | Tensor | None = None, + dim: int | list[int] | None = None, keepdim: bool = False, ) -> Tensor: r"""sample estimate of `x` *tailedness* (presence of outliers) diff --git a/src/plenoptic/tools/straightness.py b/src/plenoptic/tools/straightness.py index fef9cfc9..3d848ed4 100644 --- a/src/plenoptic/tools/straightness.py +++ b/src/plenoptic/tools/straightness.py @@ -1,6 +1,5 @@ import torch from torch import Tensor -from typing import Tuple from .validate import validate_input @@ -102,7 +101,7 @@ def sample_brownian_bridge( def deviation_from_line( sequence: Tensor, normalize: bool = True -) -> Tuple[Tensor, Tensor]: +) -> tuple[Tensor, Tensor]: """Compute the deviation of `sequence` to the straight line between its endpoints. Project each point of the path `sequence` onto the line defined by diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index f1ae938a..07ad9f3c 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -3,15 +3,14 @@ import torch import warnings import itertools -from typing import Tuple, Optional, Callable, Union +from typing import Callable # noqa: UP035 from torch import Tensor -import warnings def validate_input( input_tensor: Tensor, no_batch: bool = False, - allowed_range: Optional[Tuple[float, float]] = None, + allowed_range: tuple[float, float] | None = None, ): """Determine whether input_tensor tensor can be used for synthesis. @@ -65,7 +64,7 @@ def validate_input( if no_batch and input_tensor.shape[0] != 1: # numpy raises ValueError when operands cannot be broadcast together, # so it seems reasonable here - raise ValueError(f"input_tensor batch dimension must be 1.") + raise ValueError("input_tensor batch dimension must be 1.") if allowed_range is not None: if allowed_range[0] >= allowed_range[1]: raise ValueError( @@ -84,9 +83,9 @@ def validate_input( def validate_model( model: torch.nn.Module, - image_shape: Optional[Tuple[int, int, int, int]] = None, + image_shape: tuple[int, int, int, int] | None = None, image_dtype: torch.dtype = torch.float32, - device: Union[str, torch.device] = "cpu", + device: str | torch.device = "cpu", ): """Determine whether model can be used for sythesis. @@ -184,7 +183,7 @@ def validate_model( raise TypeError("model changes precision of input, don't do that!") if model(test_img).ndimension() not in [3, 4]: raise ValueError( - f"When given a 4d input, model output must be three- or four-" + "When given a 4d input, model output must be three- or four-" "dimensional but had {model(test_img).ndimension()} dimensions instead!" ) if model(test_img).device != test_img.device: @@ -199,8 +198,8 @@ def validate_model( def validate_coarse_to_fine( model: torch.nn.Module, - image_shape: Optional[Tuple[int, int, int, int]] = None, - device: Union[str, torch.device] = "cpu", + image_shape: tuple[int, int, int, int] | None = None, + device: str | torch.device = "cpu", ): """Determine whether a model can be used for coarse-to-fine synthesis. @@ -241,7 +240,7 @@ def validate_coarse_to_fine( try: if model_output_shape == model(test_img, scales=sc).shape: raise ValueError( - f"Output of model forward method doesn't change" + "Output of model forward method doesn't change" " shape when scales keyword arg is set to {sc} {msg}" ) except TypeError: @@ -251,10 +250,10 @@ def validate_coarse_to_fine( def validate_metric( - metric: Union[torch.nn.Module, Callable[[Tensor, Tensor], Tensor]], - image_shape: Optional[Tuple[int, int, int, int]] = None, + metric: torch.nn.Module | Callable[[Tensor, Tensor], Tensor], + image_shape: tuple[int, int, int, int] | None = None, image_dtype: torch.dtype = torch.float32, - device: Union[str, torch.device] = "cpu", + device: str | torch.device = "cpu", ): """Determines whether a metric can be used for MADCompetition synthesis. From bb714bfd7a06cb2b61a2552f6f785824abbc45c6 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 9 Aug 2024 10:06:02 -0400 Subject: [PATCH 040/134] running flake8 simplify on entire codebase --- examples/05_Geodesics.ipynb | 2 -- examples/Metamer-Portilla-Simoncelli.ipynb | 2 -- noxfile.py | 2 ++ pyproject.toml | 2 +- src/plenoptic/data/__init__.py | 23 +++++++++++++++------- 5 files changed, 19 insertions(+), 12 deletions(-) diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index cdd3cc87..cb7c7ee4 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -775,8 +775,6 @@ } ], "source": [ - "\n", - "\n", "# Create a class that takes the nth layer output of a given model\n", "class NthLayer(torch.nn.Module):\n", " \"\"\"Wrap any model to get the response of an intermediate layer\n", diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index b7f24ee4..066d0f20 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -2159,8 +2159,6 @@ "metadata": {}, "outputs": [], "source": [ - "\n", - "\n", "class PortillaSimoncelliMagMeans(po.simul.PortillaSimoncelli):\n", " r\"\"\"Include the magnitude means in the PS texture representation.\n", "\n", diff --git a/noxfile.py b/noxfile.py index 58bc0d91..111564db 100644 --- a/noxfile.py +++ b/noxfile.py @@ -1,11 +1,13 @@ import nox + @nox.session(name="lint") def lint(session): # run linters session.install("ruff") session.run("ruff", "check", "--ignore", "D") + @nox.session(name="tests", python=["3.10", "3.11", "3.12"]) def tests(session): # run tests diff --git a/pyproject.toml b/pyproject.toml index 0faf6e16..dd359011 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -135,7 +135,7 @@ select = [ # flake8-bugbear #"B", # flake8-simplify - #"SIM", + "SIM", # isort #"I", ] diff --git a/src/plenoptic/data/__init__.py b/src/plenoptic/data/__init__.py index b6527ec8..5931ef38 100644 --- a/src/plenoptic/data/__init__.py +++ b/src/plenoptic/data/__init__.py @@ -2,27 +2,36 @@ from .fetch import fetch_data, DOWNLOADABLE_FILES import torch -__all__ = ['einstein', 'curie', 'parrot', 'reptile_skin', - 'color_wheel', 'fetch_data', 'DOWNLOADABLE_FILES'] +__all__ = [ + "einstein", + "curie", + "parrot", + "reptile_skin", + "color_wheel", + "fetch_data", + "DOWNLOADABLE_FILES", +] + + def __dir__(): return __all__ def einstein() -> torch.Tensor: - return data_utils.get('einstein') + return data_utils.get("einstein") def curie() -> torch.Tensor: - return data_utils.get('curie') + return data_utils.get("curie") def parrot(as_gray: bool = False) -> torch.Tensor: - return data_utils.get('parrot', as_gray=as_gray) + return data_utils.get("parrot", as_gray=as_gray) def reptile_skin() -> torch.Tensor: - return data_utils.get('reptile_skin') + return data_utils.get("reptile_skin") def color_wheel(as_gray: bool = False) -> torch.Tensor: - return data_utils.get('color_wheel', as_gray=as_gray) + return data_utils.get("color_wheel", as_gray=as_gray) From 8724a2b576f9f1f885988c74a2644f4869801ccc Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 9 Aug 2024 10:26:54 -0400 Subject: [PATCH 041/134] removing # noqa: UP035 tag --- .../canonical_computations/steerable_pyramid_freq.py | 4 ++-- src/plenoptic/simulate/models/frontend.py | 2 +- src/plenoptic/simulate/models/portilla_simoncelli.py | 10 +++++----- src/plenoptic/synthesize/eigendistortion.py | 4 ++-- src/plenoptic/synthesize/geodesic.py | 2 +- src/plenoptic/synthesize/mad_competition.py | 4 ++-- src/plenoptic/synthesize/metamer.py | 4 ++-- src/plenoptic/tools/validate.py | 2 +- 8 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 9c4bc0bb..7e6b3e09 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -6,7 +6,7 @@ import warnings from collections import OrderedDict -from typing import Union # noqa: UP035 +from typing import Union import numpy as np import torch @@ -15,7 +15,7 @@ from einops import rearrange from scipy.special import factorial from torch import Tensor -from typing_extensions import Literal # noqa: UP035 +from typing_extensions import Literal from numpy.typing import NDArray from ...tools.signal import interpolate1d, raised_cosine, steer diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 1e1f87f3..1534232c 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -10,7 +10,7 @@ .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ -from typing import Callable # noqa: UP035 +from typing import Callable import torch import torch.nn as nn diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index b87535de..765c939f 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -8,7 +8,7 @@ """ from collections import OrderedDict -from typing import Union # noqa: UP035 +from typing import Union import einops import matplotlib as mpl @@ -18,7 +18,7 @@ import torch.fft import torch.nn as nn from torch import Tensor -from typing_extensions import Literal # noqa: UP035 +from typing_extensions import Literal from ...tools import signal, stats from ...tools.data import to_numpy @@ -239,9 +239,9 @@ def _create_scales_shape_dict(self) -> OrderedDict: dtype=int, ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") - shape_dict[ - "cross_orientation_correlation_magnitude" - ] = cross_orientation_corr_mag + shape_dict["cross_orientation_correlation_magnitude"] = ( + cross_orientation_corr_mag + ) mags_std = np.ones((self.n_orientations, self.n_scales), dtype=int) mags_std *= einops.rearrange(scales, "s -> 1 s") diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index b64db803..907b498b 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -1,6 +1,6 @@ -from typing import Callable # noqa: UP035 +from typing import Callable import warnings -from typing_extensions import Literal # noqa: UP035 +from typing_extensions import Literal import matplotlib.pyplot from matplotlib.figure import Figure diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index 11f388e8..f2f2d6af 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -6,7 +6,7 @@ import torch.autograd as autograd from torch import Tensor from tqdm.auto import tqdm -from typing_extensions import Literal # noqa: UP035 +from typing_extensions import Literal from .synthesis import OptimizedSynthesis from ..tools.data import to_numpy diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 0064b589..42b94ba1 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -5,8 +5,8 @@ from torch import Tensor from tqdm.auto import tqdm from ..tools import optim, display, data -from typing import Callable # noqa: UP035 -from typing_extensions import Literal # noqa: UP035 +from typing import Callable +from typing_extensions import Literal from .synthesis import OptimizedSynthesis import warnings import matplotlib as mpl diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index a557ae68..2d262598 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -13,8 +13,8 @@ validate_coarse_to_fine, ) from ..tools.convergence import coarse_to_fine_enough, loss_convergence -from typing import Callable # noqa: UP035 -from typing_extensions import Literal # noqa: UP035 +from typing import Callable +from typing_extensions import Literal from .synthesis import OptimizedSynthesis import warnings import matplotlib as mpl diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index 07ad9f3c..4a4f3198 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -3,7 +3,7 @@ import torch import warnings import itertools -from typing import Callable # noqa: UP035 +from typing import Callable from torch import Tensor From fa290886309baa783ca5487c5b26064f83bee3a9 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 13 Aug 2024 10:37:05 -0400 Subject: [PATCH 042/134] test coverage session added to noxfile --- noxfile.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/noxfile.py b/noxfile.py index 111564db..38ed8f2d 100644 --- a/noxfile.py +++ b/noxfile.py @@ -13,3 +13,11 @@ def tests(session): # run tests session.install("pytest") session.run("pytest") + # queue up coverage session to run next + session.notify("coverage") + + +@nox.session +def coverage(session): + session.install("coverage") + session.run("coverage") From 13f3db23f24f981b10b38c39555f6b63e8118afd Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 13 Aug 2024 12:35:42 -0400 Subject: [PATCH 043/134] pytest ini_options adjustments to accomodate module not implemented error when runnin nox sesssion tests --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index dd359011..78f15fac 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -81,7 +81,7 @@ version_scheme = 'python-simplified-semver' local_scheme = 'no-local-version' [tool.pytest.ini_options] -addopts = "--cov=plenoptic" +addopts = ["--cov=plenoptic",] testpaths = ["tests"] [tool.ruff] From d3e825cf0f8acdee80df7e72d9623d059ab5a8be Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 13 Aug 2024 14:41:14 -0400 Subject: [PATCH 044/134] updating test session in nox file to install all dependencies as listes in toml file and fixing none-type error in eigendistortions.py --- noxfile.py | 16 ++++++++++++++++ src/plenoptic/synthesize/eigendistortion.py | 3 ++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/noxfile.py b/noxfile.py index 38ed8f2d..e2da816c 100644 --- a/noxfile.py +++ b/noxfile.py @@ -1,4 +1,6 @@ import nox +import sys +from pathlib import Path @nox.session(name="lint") @@ -12,6 +14,20 @@ def lint(session): def tests(session): # run tests session.install("pytest") + # Install dependencies listed in pyproject.toml + session.install( + "numpy>=1.1", + "torch>=1.8,!=1.12.0", + "pyrtools>=1.0.1", + "scipy>=1.0", + "matplotlib>=3.3", + "tqdm>=4.29", + "imageio>=2.5", + "scikit-image>=0.15.0", + "einops>=0.3.0", + "importlib-resources>=6.0", + ) + session.env["PYTHONPATH"] = str(Path().resolve() / "src") session.run("pytest") # queue up coverage session to run next session.notify("coverage") diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 907b498b..9f96eaaa 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -636,7 +636,8 @@ def display_eigendistortion( eigenindex: int = 0, alpha: float = 5.0, process_image: Callable[[Tensor], Tensor] = lambda x: x, - ax: matplotlib.pyplot.axis | None = None, + # ax: matplotlib.pyplot.axis | None = None, + ax: matplotlib.axes.Axes | None = None, plot_complex: str = "rectangular", **kwargs, ) -> Figure: From 4aa2765ae2784d5d7a9b97cfc3da600ddbd11ca0 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 13 Aug 2024 16:31:53 -0400 Subject: [PATCH 045/134] pytest can now be run with nox including test coverage --- noxfile.py | 3 +++ src/plenoptic/synthesize/mad_competition.py | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/noxfile.py b/noxfile.py index e2da816c..b175e108 100644 --- a/noxfile.py +++ b/noxfile.py @@ -14,6 +14,8 @@ def lint(session): def tests(session): # run tests session.install("pytest") + # Install pytest-cov for coverage reporting + session.install("pytest-cov") # Install dependencies listed in pyproject.toml session.install( "numpy>=1.1", @@ -26,6 +28,7 @@ def tests(session): "scikit-image>=0.15.0", "einops>=0.3.0", "importlib-resources>=6.0", + "pooch>=1.5", ) session.env["PYTHONPATH"] = str(Path().resolve() / "src") session.run("pytest") diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 42b94ba1..36f6ab55 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -495,7 +495,7 @@ def to(self, *args, **kwargs): def load( self, file_path: str, - map_location: None | None = None, + map_location: str | None = None, **pickle_load_args, ): r"""Load all relevant stuff from a .pt file. From 180a17edb54163e29375616bb4ba23ee7a2884b5 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 13 Aug 2024 20:17:43 -0400 Subject: [PATCH 046/134] resolving some too long lines --- src/plenoptic/tools/validate.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index 4a4f3198..6d577948 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -299,13 +299,15 @@ def validate_metric( # element tensors can be converted to Python scalars) except (ValueError, RuntimeError): raise ValueError( - f"metric should return a scalar value but output had shape {metric(test_img, test_img).shape}" + "metric should return a scalar value but" + + f" output had shape {metric(test_img, test_img).shape}" ) # on gpu, 1-SSIM of two identical images is 5e-8, so we use a threshold # of 5e-7 to check for zero if same_val > 5e-7: raise ValueError( - f"metric should return <= 5e-7 on two identical images but got {same_val}" + "metric should return <= 5e-7 on" + + f" two identical images but got {same_val}" ) From cec2844313c9789465a6e340be8179ee180bc770 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 13 Aug 2024 20:52:24 -0400 Subject: [PATCH 047/134] too long lines in validate.py corrected --- pyproject.toml | 2 +- src/plenoptic/tools/validate.py | 53 +++++++++++++++++++-------------- 2 files changed, 32 insertions(+), 23 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 78f15fac..0ca52833 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -120,7 +120,7 @@ exclude = [ "docs", ] -# Set the maximum line length to 79. Default is 88. +# Set the maximum line length. line-length = 79 [tool.ruff.lint] diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index 6d577948..78a96b87 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -3,7 +3,7 @@ import torch import warnings import itertools -from typing import Callable +from collections.abc import Callable from torch import Tensor @@ -22,7 +22,8 @@ def validate_input( - If ``no_batch`` is True, check whether ``input_tensor.shape[0] != 1`` - - If ``allowed_range`` is not None, check whether all values of ``input_tensor`` lie + - If ``allowed_range`` is not None, check whether all values of + ``input_tensor`` lie within the specified range. If any of the above fail, a ``ValueError`` is raised. @@ -32,10 +33,12 @@ def validate_input( input_tensor The tensor to validate. no_batch - If True, raise a ValueError if the batch dimension of ``input_tensor`` is greater + If True, raise a ValueError if the batch dimension of ``input_tensor`` + is greater than 1. allowed_range - If not None, ensure that all values of ``input_tensor`` lie within allowed_range. + If not None, ensure that all values of ``input_tensor`` lie within + allowed_range. """ # validate dtype @@ -48,7 +51,8 @@ def validate_input( torch.complex128, ]: raise TypeError( - f"Only float or complex dtypes are allowed but got type {input_tensor.dtype}" + "Only float or complex dtypes are" + + f" allowed but got type {input_tensor.dtype}" ) if input_tensor.ndimension() != 4: if no_batch: @@ -92,11 +96,11 @@ def validate_model( In particular, this function checks the following (with their associated errors raised): - - If ``model`` adds a gradient to an input tensor, which implies that some of - it is learnable (``ValueError``). + - If ``model`` adds a gradient to an input tensor, which implies that some + of it is learnable (``ValueError``). - - If ``model`` returns a tensor when given a tensor, failure implies that not - all computations are done using torch (``ValueError``). + - If ``model`` returns a tensor when given a tensor, failure implies that + not all computations are done using torch (``ValueError``). - If ``model`` strips gradient from an input with gradient attached (``ValueError``). @@ -111,10 +115,9 @@ def validate_model( - If ``model`` changes the device of the input (``RuntimeError``). - Finally, we check if ``model`` is in training mode and raise a warning if so. - Note that this is different from having learnable parameters, see ``pytorch - docs - ``_ + Finally, we check if ``model`` is in training mode and raise a warning + if so. Note that this is different from having learnable parameters, + see ``pytorch docs ``_ Parameters ---------- @@ -144,8 +147,9 @@ def validate_model( try: if model(test_img).requires_grad: raise ValueError( - "model adds gradient to input, at least one of its parameters is" - " learnable. Try calling plenoptic.tools.remove_grad() on it." + "model adds gradient to input, at least one of its parameters" + " is learnable. Try calling plenoptic.tools.remove_grad()" + " on it." ) # in particular, numpy arrays lack requires_grad attribute except AttributeError: @@ -166,8 +170,9 @@ def validate_model( # and then try to cast it back to a tensor except RuntimeError: raise ValueError( - "model tries to cast the input into something other than torch.Tensor" - " object -- are you sure all computations are performed using torch?" + "model tries to cast the input into something other than" + " torch.Tensor object -- are you sure all computations are" + " performed using torch?" ) if image_dtype in [torch.float16, torch.complex32]: allowed_dtypes = [torch.float16, torch.complex32] @@ -177,14 +182,16 @@ def validate_model( allowed_dtypes = [torch.float64, torch.complex128] else: raise TypeError( - f"Only float or complex dtypes are allowed but got type {image_dtype}" + "Only float or complex dtypes are allowed but got type" + f" {image_dtype}" ) if model(test_img).dtype not in allowed_dtypes: raise TypeError("model changes precision of input, don't do that!") if model(test_img).ndimension() not in [3, 4]: raise ValueError( - "When given a 4d input, model output must be three- or four-" - "dimensional but had {model(test_img).ndimension()} dimensions instead!" + "When given a 4d input, model output must be three- or" + " four-dimensional but had {model(test_img).ndimension()}" + " dimensions instead!" ) if model(test_img).device != test_img.device: # pytorch device errors are RuntimeErrors @@ -226,7 +233,8 @@ def validate_coarse_to_fine( """ warnings.warn( - "Validating whether model can work with coarse-to-fine synthesis -- this can take a while!" + "Validating whether model can work with coarse-to-fine synthesis --" + " this can take a while!" ) msg = "and therefore we cannot do coarse-to-fine synthesis" if not hasattr(model, "scales"): @@ -245,7 +253,8 @@ def validate_coarse_to_fine( ) except TypeError: raise TypeError( - f"model forward method does not accept scales argument {sc} {msg}" + "model forward method does not accept scales argument" + f" {sc} {msg}" ) From 1230ef647624c774e61dd897b7d197fb01735369 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 13 Aug 2024 21:01:11 -0400 Subject: [PATCH 048/134] formatting with line-length set to 88 --- examples/00_quickstart.ipynb | 4 +- examples/02_Eigendistortions.ipynb | 16 +- examples/03_Steerable_Pyramid.ipynb | 26 +- examples/04_Perceptual_distance.ipynb | 26 +- examples/05_Geodesics.ipynb | 12 +- examples/06_Metamer.ipynb | 8 +- examples/07_Simple_MAD.ipynb | 24 +- examples/08_MAD_Competition.ipynb | 4 +- examples/09_Original_MAD.ipynb | 4 +- examples/Display.ipynb | 4 +- examples/Metamer-Portilla-Simoncelli.ipynb | 60 +- pyproject.toml | 2 +- src/plenoptic/data/fetch.py | 100 ++- src/plenoptic/metric/classes.py | 4 +- src/plenoptic/metric/perceptual_distance.py | 56 +- .../canonical_computations/filters.py | 12 +- .../steerable_pyramid_freq.py | 111 +-- src/plenoptic/simulate/models/frontend.py | 29 +- src/plenoptic/simulate/models/naive.py | 41 +- .../simulate/models/portilla_simoncelli.py | 90 +-- src/plenoptic/synthesize/autodiff.py | 9 +- src/plenoptic/synthesize/eigendistortion.py | 50 +- src/plenoptic/synthesize/geodesic.py | 62 +- src/plenoptic/synthesize/mad_competition.py | 62 +- src/plenoptic/synthesize/metamer.py | 69 +- src/plenoptic/synthesize/simple_metamer.py | 8 +- src/plenoptic/synthesize/synthesis.py | 13 +- src/plenoptic/tools/conv.py | 31 +- src/plenoptic/tools/convergence.py | 13 +- src/plenoptic/tools/data.py | 16 +- src/plenoptic/tools/display.py | 51 +- src/plenoptic/tools/external.py | 8 +- src/plenoptic/tools/signal.py | 24 +- src/plenoptic/tools/stats.py | 8 +- src/plenoptic/tools/straightness.py | 14 +- src/plenoptic/tools/validate.py | 7 +- tests/conftest.py | 92 ++- tests/test_data_get.py | 35 +- tests/test_display.py | 730 +++++++++++------- tests/test_eigendistortion.py | 209 +++-- tests/test_geodesic.py | 429 ++++++---- tests/test_mad.py | 251 ++++-- tests/test_metamers.py | 329 +++++--- tests/test_metric.py | 164 ++-- tests/test_models.py | 630 ++++++++++----- tests/test_steerable_pyr.py | 390 +++++++--- tests/test_tools.py | 325 +++++--- tests/utils.py | 67 +- 48 files changed, 2793 insertions(+), 1936 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index 83722317..1500e3bc 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -102,9 +102,7 @@ " # the forward pass of the model defines how to get from an image to the representation\n", " def forward(self, x):\n", " # use circular padding so our output is the same size as our input\n", - " x = po.tools.conv.same_padding(\n", - " x, self.kernel_size, pad_mode=\"circular\"\n", - " )\n", + " x = po.tools.conv.same_padding(x, self.kernel_size, pad_mode=\"circular\")\n", " return self.conv(x)\n", "\n", "\n", diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 679830f9..641af0d5 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -325,9 +325,7 @@ "\n", "# Eigenvectors (aka eigendistortions) and associated eigenvectors are found in the distortions dict attribute\n", "fig, ax = plt.subplots(1, 2, sharex=\"all\")\n", - "ax[0].imshow(\n", - " eig_jac.eigendistortions.squeeze(), vmin=-1, vmax=1, cmap=\"coolwarm\"\n", - ")\n", + "ax[0].imshow(eig_jac.eigendistortions.squeeze(), vmin=-1, vmax=1, cmap=\"coolwarm\")\n", "ax[0].set(title=\"Eigendistortions\", xlabel=\"Eigenvector index\", ylabel=\"Entry\")\n", "ax[1].plot(eig_jac.eigenvalues, \".\")\n", "ax[1].set(title=\"Eigenvalues\", xlabel=\"Eigenvector index\", ylabel=\"Eigenvalue\")\n", @@ -465,9 +463,7 @@ "print(f\"Indices of computed eigenvectors: {eig_pow.eigenindex}\\n\")\n", "\n", "fig, ax = plt.subplots(1, 1)\n", - "ax.plot(\n", - " eig_pow.eigenindex, eig_pow.eigenvalues, \".\", markersize=15, label=\"Power\"\n", - ")\n", + "ax.plot(eig_pow.eigenindex, eig_pow.eigenvalues, \".\", markersize=15, label=\"Power\")\n", "ax.plot(eig_jac.eigenvalues, \".-\", label=\"Jacobian\")\n", "ax.set(\n", " title=\"Power method vs Jacobian\",\n", @@ -868,12 +864,8 @@ } ], "source": [ - "po.synth.eigendistortion.display_eigendistortion(\n", - " ed_resneta, 0, as_rgb=True, zoom=3\n", - ")\n", - "po.synth.eigendistortion.display_eigendistortion(\n", - " ed_resneta, -1, as_rgb=True, zoom=3\n", - ");" + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, 0, as_rgb=True, zoom=3)\n", + "po.synth.eigendistortion.display_eigendistortion(ed_resneta, -1, as_rgb=True, zoom=3);" ] }, { diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index 81ed62f9..63818db6 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -106,9 +106,9 @@ "source": [ "order = 3\n", "imsize = 64\n", - "pyr = SteerablePyramidFreq(\n", - " height=3, image_shape=[imsize, imsize], order=order\n", - ").to(device)\n", + "pyr = SteerablePyramidFreq(height=3, image_shape=[imsize, imsize], order=order).to(\n", + " device\n", + ")\n", "empty_image = torch.zeros((1, 1, imsize, imsize), dtype=dtype).to(device)\n", "pyr_coeffs = pyr.forward(empty_image)\n", "\n", @@ -175,9 +175,9 @@ "po.imshow(im_batch)\n", "order = 3\n", "dim_im = 256\n", - "pyr = SteerablePyramidFreq(\n", - " height=4, image_shape=[dim_im, dim_im], order=order\n", - ").to(device)\n", + "pyr = SteerablePyramidFreq(height=4, image_shape=[dim_im, dim_im], order=order).to(\n", + " device\n", + ")\n", "pyr_coeffs = pyr(im_batch)" ] }, @@ -2169,9 +2169,9 @@ ], "source": [ "# note that steering is currently only implemeted for real pyramids, so the `is_complex` argument must be False (as it is by default)\n", - "pyr = SteerablePyramidFreq(\n", - " height=3, image_shape=[256, 256], order=3, twidth=1\n", - ").to(device)\n", + "pyr = SteerablePyramidFreq(height=3, image_shape=[256, 256], order=3, twidth=1).to(\n", + " device\n", + ")\n", "coeffs = pyr(im_batch)\n", "\n", "# play around with different scales! Coarser scales tend to make the steering a bit more obvious.\n", @@ -2294,9 +2294,7 @@ ], "source": [ "pyr_coeffs_fixed_1 = pyr_fixed(im_batch)\n", - "pyr_coeffs_fixed_2 = pyr_fixed.convert_tensor_to_pyr(\n", - " pyr_coeffs_fixed, *pyr_info\n", - ")\n", + "pyr_coeffs_fixed_2 = pyr_fixed.convert_tensor_to_pyr(pyr_coeffs_fixed, *pyr_info)\n", "for k in pyr_coeffs_fixed_1.keys():\n", " print(torch.allclose(pyr_coeffs_fixed_2[k], pyr_coeffs_fixed_1[k]))" ] @@ -2432,9 +2430,7 @@ " print(band.abs().square().sum().numpy())\n", " total_band_energy += band.abs().square().sum().numpy()\n", "\n", - " np.testing.assert_allclose(\n", - " total_band_energy, im_energy, rtol=rtol, atol=atol\n", - " )" + " np.testing.assert_allclose(total_band_energy, im_energy, rtol=rtol, atol=atol)" ] }, { diff --git a/examples/04_Perceptual_distance.ipynb b/examples/04_Perceptual_distance.ipynb index 02df2f76..7bc8d04b 100644 --- a/examples/04_Perceptual_distance.ipynb +++ b/examples/04_Perceptual_distance.ipynb @@ -157,8 +157,7 @@ " \"Salt-and-pepper noise\",\n", "]\n", "titles = [\n", - " f\"{names[i]}\\nMSE={mse_values[i]:.3e}, SSIM={ssim_values[i]:.4f}\"\n", - " for i in range(6)\n", + " f\"{names[i]}\\nMSE={mse_values[i]:.3e}, SSIM={ssim_values[i]:.4f}\" for i in range(6)\n", "]\n", "po.imshow(img_distorted, vrange=\"auto\", title=titles, col_wrap=3);" ] @@ -336,8 +335,7 @@ " \"Salt-and-pepper noise\",\n", "]\n", "titles = [\n", - " f\"{names[i]}\\nMSE={mse_values[i]:.3e}, NLPD={nlpd_values[i]:.4f}\"\n", - " for i in range(6)\n", + " f\"{names[i]}\\nMSE={mse_values[i]:.3e}, NLPD={nlpd_values[i]:.4f}\" for i in range(6)\n", "]\n", "po.imshow(img_distorted, vrange=\"auto\", title=titles, col_wrap=3)" ] @@ -418,12 +416,8 @@ " folder = po.data.fetch_data(\"tid2013.tar.gz\")\n", " reference_images = torch.zeros([25, 1, 384, 512])\n", " distorted_images = torch.zeros([25, 24, 5, 1, 384, 512])\n", - " reference_filemap = {\n", - " s.lower(): s for s in os.listdir(folder / \"reference_images\")\n", - " }\n", - " distorted_filemap = {\n", - " s.lower(): s for s in os.listdir(folder / \"distorted_images\")\n", - " }\n", + " reference_filemap = {s.lower(): s for s in os.listdir(folder / \"reference_images\")}\n", + " distorted_filemap = {s.lower(): s for s in os.listdir(folder / \"distorted_images\")}\n", " for i in range(25):\n", " reference_filename = reference_filemap[f\"i{i+1:02d}.bmp\"]\n", " reference_images[i] = (\n", @@ -445,9 +439,7 @@ " torch.as_tensor(\n", " np.asarray(\n", " Image.open(\n", - " folder\n", - " / \"distorted_images\"\n", - " / distorted_filename\n", + " folder / \"distorted_images\" / distorted_filename\n", " ).convert(\"L\")\n", " )\n", " )\n", @@ -527,12 +519,8 @@ " marker=shape_list[j // 5],\n", " label=distortion_names[j],\n", " )\n", - " pearsonr_value = pearsonr(\n", - " -mos_values.flatten(), distance[i].flatten()\n", - " )[0]\n", - " spearmanr_value = spearmanr(\n", - " -mos_values.flatten(), distance[i].flatten()\n", - " )[0]\n", + " pearsonr_value = pearsonr(-mos_values.flatten(), distance[i].flatten())[0]\n", + " spearmanr_value = spearmanr(-mos_values.flatten(), distance[i].flatten())[0]\n", " axs[i].set_title(\n", " f\"pearson {pearsonr_value:.4f}, spearman {spearmanr_value:.4f}\"\n", " )\n", diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index cb7c7ee4..2e479445 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -255,9 +255,7 @@ "plt.plot(po.to_numpy(moog.step_energy), alpha=0.2)\n", "plt.plot(moog.step_energy.mean(1), \"r-\", label=\"path energy\")\n", "plt.axhline(\n", - " torch.linalg.vector_norm(\n", - " moog.model(moog.image_a) - moog.model(moog.image_b), ord=2\n", - " )\n", + " torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2)\n", " ** 2\n", " / moog.n_steps**2\n", ")\n", @@ -549,9 +547,7 @@ "plt.plot(po.to_numpy(moog.step_energy), alpha=0.2)\n", "plt.plot(moog.step_energy.mean(1), \"r-\", label=\"path energy\")\n", "plt.axhline(\n", - " torch.linalg.vector_norm(\n", - " moog.model(moog.image_a) - moog.model(moog.image_b), ord=2\n", - " )\n", + " torch.linalg.vector_norm(moog.model(moog.image_a) - moog.model(moog.image_b), ord=2)\n", " ** 2\n", " / moog.n_steps**2\n", ")\n", @@ -744,9 +740,7 @@ "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError for you,\n", "# then install pooch in your plenoptic environment and restart your kernel.\n", "sample_image_dir = po.data.fetch_data(\"sample_images.tar.gz\")\n", - "imgA = po.load_images(\n", - " sample_image_dir / \"frontwindow_affine.jpeg\", as_gray=False\n", - ")\n", + "imgA = po.load_images(sample_image_dir / \"frontwindow_affine.jpeg\", as_gray=False)\n", "imgB = po.load_images(sample_image_dir / \"frontwindow.jpeg\", as_gray=False)\n", "u = 300\n", "l = 90\n", diff --git a/examples/06_Metamer.ipynb b/examples/06_Metamer.ipynb index 9b1bdf16..972df828 100644 --- a/examples/06_Metamer.ipynb +++ b/examples/06_Metamer.ipynb @@ -261,9 +261,7 @@ } ], "source": [ - "fig, axes = plt.subplots(\n", - " 1, 3, figsize=(25, 5), gridspec_kw={\"width_ratios\": [1, 1, 2]}\n", - ")\n", + "fig, axes = plt.subplots(1, 3, figsize=(25, 5), gridspec_kw={\"width_ratios\": [1, 1, 2]})\n", "po.synth.metamer.display_metamer(met, ax=axes[0])\n", "po.synth.metamer.plot_loss(met, ax=axes[1])\n", "po.synth.metamer.plot_representation_error(met, ax=axes[2]);" @@ -10264,9 +10262,7 @@ } ], "source": [ - "anim = po.synth.metamer.animate(\n", - " met, width_ratios={\"plot_representation_error\": 2}\n", - ")\n", + "anim = po.synth.metamer.animate(met, width_ratios={\"plot_representation_error\": 2})\n", "anim" ] }, diff --git a/examples/07_Simple_MAD.ipynb b/examples/07_Simple_MAD.ipynb index f1191b20..c9151477 100644 --- a/examples/07_Simple_MAD.ipynb +++ b/examples/07_Simple_MAD.ipynb @@ -122,15 +122,11 @@ "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(\n", - " [\"min\", \"max\"], zip(metrics, metrics[::-1])\n", - "):\n", + "for t, (m1, m2) in itertools.product([\"min\", \"max\"], zip(metrics, metrics[::-1])):\n", " name = f\"{m1.__name__}_{t}\"\n", " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values!\n", " po.tools.set_seed(10)\n", - " all_mad[name] = po.synth.MADCompetition(\n", - " img, m1, m2, t, metric_tradeoff_lambda=1e4\n", - " )\n", + " all_mad[name] = po.synth.MADCompetition(img, m1, m2, t, metric_tradeoff_lambda=1e4)\n", " optim = torch.optim.Adam([all_mad[name].mad_image], lr=0.0001)\n", " print(f\"Synthesizing {name}\")\n", " all_mad[name].synthesize(\n", @@ -239,9 +235,7 @@ "\n", "def circle(origin, r, n=1000):\n", " theta = 2 * np.pi / n * np.arange(0, n + 1)\n", - " return np.array(\n", - " [origin[1] + r * np.cos(theta), origin[0] + r * np.sin(theta)]\n", - " )\n", + " return np.array([origin[1] + r * np.cos(theta), origin[0] + r * np.sin(theta)])\n", "\n", "\n", "def diamond(origin, r, n=1000):\n", @@ -252,9 +246,7 @@ " ) + np.abs(np.cos(theta - rotation) + np.sin(theta - rotation))\n", " square_correction /= square_correction[0]\n", " r = r / square_correction\n", - " return np.array(\n", - " [origin[1] + r * np.cos(theta), origin[0] + r * np.sin(theta)]\n", - " )\n", + " return np.array([origin[1] + r * np.cos(theta), origin[0] + r * np.sin(theta)])\n", "\n", "\n", "l2_level_set = circle(\n", @@ -377,9 +369,7 @@ " image += np.abs(image.min())\n", " image /= image.max()\n", " return (\n", - " torch.from_numpy(\n", - " np.where((image < 0.75) & (image > 0.25), *values[::-1])\n", - " )\n", + " torch.from_numpy(np.where((image < 0.75) & (image > 0.25), *values[::-1]))\n", " .unsqueeze(0)\n", " .unsqueeze(0)\n", " .to(torch.float32)\n", @@ -477,9 +467,7 @@ "all_mad = {}\n", "\n", "# this gets us all four possibilities\n", - "for t, (m1, m2) in itertools.product(\n", - " [\"min\", \"max\"], zip(metrics, metrics[::-1])\n", - "):\n", + "for t, (m1, m2) in itertools.product([\"min\", \"max\"], zip(metrics, metrics[::-1])):\n", " name = f\"{m1.__name__}_{t}\"\n", " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values!\n", " po.tools.set_seed(0)\n", diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index c1ae269b..836351cf 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -396,9 +396,7 @@ } ], "source": [ - "fig, axes = plt.subplots(\n", - " 1, 2, figsize=(15, 5), gridspec_kw={\"width_ratios\": [1, 2]}\n", - ")\n", + "fig, axes = plt.subplots(1, 2, figsize=(15, 5), gridspec_kw={\"width_ratios\": [1, 2]})\n", "po.synth.mad_competition.display_mad_image(mad, ax=axes[0], zoom=0.5)\n", "po.synth.mad_competition.plot_loss(mad, axes=axes[1], iteration=-100)" ] diff --git a/examples/09_Original_MAD.ipynb b/examples/09_Original_MAD.ipynb index 4937cd8b..d451d989 100644 --- a/examples/09_Original_MAD.ipynb +++ b/examples/09_Original_MAD.ipynb @@ -145,9 +145,7 @@ "# We need to download some additional data for this portion of the notebook. In order to do so,\n", "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError\n", "# then install pooch in your plenoptic environment and restart your kernel.\n", - "fig, results = po.tools.external.plot_MAD_results(\n", - " \"samp6\", [128], vrange=\"row1\", zoom=3\n", - ")" + "fig, results = po.tools.external.plot_MAD_results(\"samp6\", [128], vrange=\"row1\", zoom=3)" ] }, { diff --git a/examples/Display.ipynb b/examples/Display.ipynb index ad15d879..c0c6a7a1 100644 --- a/examples/Display.ipynb +++ b/examples/Display.ipynb @@ -135,9 +135,7 @@ "metadata": {}, "outputs": [], "source": [ - "pyr = po.simul.SteerablePyramidFreq(\n", - " img.shape[-2:], downsample=False, height=1, order=2\n", - ")" + "pyr = po.simul.SteerablePyramidFreq(img.shape[-2:], downsample=False, height=1, order=2)" ] }, { diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index 066d0f20..853df937 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -571,9 +571,7 @@ " im_shape,\n", " remove_keys,\n", " ):\n", - " super().__init__(\n", - " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9\n", - " )\n", + " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", " self.remove_keys = remove_keys\n", "\n", " def forward(self, image, scales=None):\n", @@ -1484,9 +1482,7 @@ " mask=None,\n", " target=None,\n", " ):\n", - " super().__init__(\n", - " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9\n", - " )\n", + " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", " self.mask = mask\n", " self.target = target\n", "\n", @@ -1554,9 +1550,7 @@ "ctr_dim = (img.shape[-2] // 4, img.shape[-1] // 4)\n", "mask[..., ctr_dim[0] : 3 * ctr_dim[0], ctr_dim[1] : 3 * ctr_dim[1]] = True\n", "\n", - "model = PortillaSimoncelliMask(img.shape[-2:], target=img, mask=mask).to(\n", - " DEVICE\n", - ")\n", + "model = PortillaSimoncelliMask(img.shape[-2:], target=img, mask=mask).to(DEVICE)\n", "met = po.synth.MetamerCTF(\n", " img,\n", " model,\n", @@ -1637,9 +1631,7 @@ " self,\n", " im_shape,\n", " ):\n", - " super().__init__(\n", - " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9\n", - " )\n", + " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=9)\n", "\n", " def forward(self, images, scales=None):\n", " r\"\"\"Average Texture Statistics representations of two image\n", @@ -2021,9 +2013,7 @@ } ], "source": [ - "acm_not_redundant = torch.sum(\n", - " ~torch.isnan(stats_dict[\"auto_correlation_magnitude\"])\n", - ")\n", + "acm_not_redundant = torch.sum(~torch.isnan(stats_dict[\"auto_correlation_magnitude\"]))\n", "print(f\"Non-redundant elements in acm: {acm_not_redundant}\")" ] }, @@ -2048,9 +2038,7 @@ } ], "source": [ - "print(\n", - " f\"Number magnitude band variances: {stats_dict['magnitude_std'].numel()}\"\n", - ")" + "print(f\"Number magnitude band variances: {stats_dict['magnitude_std'].numel()}\")" ] }, { @@ -2097,9 +2085,7 @@ " + torch.sum(~torch.isnan(stats_dict[\"var_highpass_residual\"]))\n", " + torch.sum(~torch.isnan(stats_dict[\"pixel_statistics\"]))\n", ")\n", - "print(\n", - " f\"Marginal statistics: {marginal_stats_num} parameters, compared to 17 in paper\"\n", - ")\n", + "print(f\"Marginal statistics: {marginal_stats_num} parameters, compared to 17 in paper\")\n", "\n", "# Sum raw coefficient correlations\n", "real_coefficient_corr_num = torch.sum(\n", @@ -2115,13 +2101,9 @@ "coeff_magnitude_stats_num = (\n", " torch.sum(~torch.isnan(stats_dict[\"auto_correlation_magnitude\"]))\n", " + torch.sum(~torch.isnan(stats_dict[\"cross_scale_correlation_magnitude\"]))\n", - " + torch.sum(\n", - " ~torch.isnan(stats_dict[\"cross_orientation_correlation_magnitude\"])\n", - " )\n", - ")\n", - "coeff_magnitude_variances = torch.sum(\n", - " ~torch.isnan(stats_dict[\"magnitude_std\"])\n", + " + torch.sum(~torch.isnan(stats_dict[\"cross_orientation_correlation_magnitude\"]))\n", ")\n", + "coeff_magnitude_variances = torch.sum(~torch.isnan(stats_dict[\"magnitude_std\"]))\n", "\n", "print(\n", " f\"Coefficient magnitude statistics: {coeff_magnitude_stats_num + coeff_magnitude_variances} \"\n", @@ -2132,9 +2114,7 @@ "phase_statistics_num = torch.sum(\n", " ~torch.isnan(stats_dict[\"cross_scale_correlation_real\"])\n", ")\n", - "print(\n", - " f\"Phase statistics: {phase_statistics_num} parameters, compared to 96 in paper\"\n", - ")" + "print(f\"Phase statistics: {phase_statistics_num} parameters, compared to 96 in paper\")" ] }, { @@ -2173,9 +2153,7 @@ " self,\n", " im_shape,\n", " ):\n", - " super().__init__(\n", - " im_shape, n_scales=4, n_orientations=4, spatial_corr_width=7\n", - " )\n", + " super().__init__(im_shape, n_scales=4, n_orientations=4, spatial_corr_width=7)\n", "\n", " def forward(self, image, scales=None):\n", " r\"\"\"Average Texture Statistics representations of two image\n", @@ -2212,14 +2190,10 @@ "\n", " # overwriting these following two methods allows us to use the plot_representation method\n", " # with the modified model, making examining it easier.\n", - " def convert_to_dict(\n", - " self, representation_tensor: torch.Tensor\n", - " ) -> OrderedDict:\n", + " def convert_to_dict(self, representation_tensor: torch.Tensor) -> OrderedDict:\n", " \"\"\"Convert tensor of stats to dictionary.\"\"\"\n", " n_mag_means = self.n_scales * self.n_orientations\n", - " rep = super().convert_to_dict(\n", - " representation_tensor[..., :-n_mag_means]\n", - " )\n", + " rep = super().convert_to_dict(representation_tensor[..., :-n_mag_means])\n", " mag_means = representation_tensor[..., -n_mag_means:]\n", " rep[\"magnitude_means\"] = einops.rearrange(\n", " mag_means,\n", @@ -2254,9 +2228,7 @@ "outputs": [], "source": [ "img = po.tools.load_images(DATA_PATH / \"fig4a.jpg\").to(DEVICE)\n", - "model = po.simul.PortillaSimoncelli(img.shape[-2:], spatial_corr_width=7).to(\n", - " DEVICE\n", - ")\n", + "model = po.simul.PortillaSimoncelli(img.shape[-2:], spatial_corr_width=7).to(DEVICE)\n", "model_mag_means = PortillaSimoncelliMagMeans(img.shape[-2:]).to(DEVICE)\n", "im_init = (torch.rand_like(img) - 0.5) * 0.1 + img.mean()" ] @@ -2337,9 +2309,7 @@ } ], "source": [ - "fig, axes = plt.subplots(\n", - " 2, 2, figsize=(21, 11), gridspec_kw={\"width_ratios\": [1, 3.1]}\n", - ")\n", + "fig, axes = plt.subplots(2, 2, figsize=(21, 11), gridspec_kw={\"width_ratios\": [1, 3.1]})\n", "for ax, im, info in zip(\n", " axes[:, 0], [met.metamer, met_mag_means.metamer], [\"with\", \"without\"]\n", "):\n", diff --git a/pyproject.toml b/pyproject.toml index 0ca52833..ff8f02cc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -121,7 +121,7 @@ exclude = [ ] # Set the maximum line length. -line-length = 79 +line-length = 88 [tool.ruff.lint] select = [ diff --git a/src/plenoptic/data/fetch.py b/src/plenoptic/data/fetch.py index 905f99a6..f1e2b49a 100644 --- a/src/plenoptic/data/fetch.py +++ b/src/plenoptic/data/fetch.py @@ -5,25 +5,63 @@ """ REGISTRY = { - "plenoptic-test-files.tar.gz": "a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8", - "ssim_images.tar.gz": "19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e", - "ssim_analysis.mat": "921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24", - "msssim_images.tar.gz": "a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c", - "MAD_results.tar.gz": "29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe", - "portilla_simoncelli_matlab_test_vectors.tar.gz": "83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81", - "portilla_simoncelli_test_vectors.tar.gz": "d67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb", - "portilla_simoncelli_images.tar.gz": "4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827", - "portilla_simoncelli_synthesize.npz": "9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80", - "portilla_simoncelli_synthesize_torch_v1.12.0.npz": "5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f", - "portilla_simoncelli_synthesize_gpu.npz": "324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee", - "portilla_simoncelli_scales.npz": "eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a", - "sample_images.tar.gz": "0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5", - "test_images.tar.gz": "eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554", - "tid2013.tar.gz": "bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0", - "portilla_simoncelli_test_vectors_refactor.tar.gz": "2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a", - "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": "9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47", - "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": "9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61", - "portilla_simoncelli_scales_ps-refactor.npz": "1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf", + "plenoptic-test-files.tar.gz": ( + "a6b8e03ecc8d7e40c505c88e6c767af5da670478d3bebb4e13a9d08ee4f39ae8" + ), + "ssim_images.tar.gz": ( + "19c1955921a3c37d30c88724fd5a13bdbc9620c9e7dfaeaa3ff835283d2bb42e" + ), + "ssim_analysis.mat": ( + "921d324783f06d1a2e6f1ce154c7ba9204f91c569772936991311ff299597f24" + ), + "msssim_images.tar.gz": ( + "a01273c95c231ba9e860dfc48f2ac8044ac3db13ad7061739c29ea5f9f20382c" + ), + "MAD_results.tar.gz": ( + "29794ed7dc14626f115b9e4173bff88884cb356378a1d4f1f6cd940dd5b31dbe" + ), + "portilla_simoncelli_matlab_test_vectors.tar.gz": ( + "83087d4d9808a3935b8eb4197624bbae19007189cd0d786527084c98b0b0ab81" + ), + "portilla_simoncelli_test_vectors.tar.gz": ( + "d67787620a0cf13addbe4588ec05b276105ff1fad46e72f8c58d99f184386dfb" + ), + "portilla_simoncelli_images.tar.gz": ( + "4d3228fbb51de45b4fc81eba590d20f5861a54d9e46766c8431ab08326e80827" + ), + "portilla_simoncelli_synthesize.npz": ( + "9c304580cd60e0275a2ef663187eccb71f2e6a31883c88acf4c6a699f4854c80" + ), + "portilla_simoncelli_synthesize_torch_v1.12.0.npz": ( + "5a76ef223bac641c9d48a0b7f49b3ce0a05c12a48e96cd309866b1e7d5e4473f" + ), + "portilla_simoncelli_synthesize_gpu.npz": ( + "324efc2a6c54382aae414d361c099394227b56cd24460eebab2532f70728c3ee" + ), + "portilla_simoncelli_scales.npz": ( + "eae2db6bd5db7d37c28d8f8320c4dd4fa5ab38294f5be22f8cf69e5cd5e4936a" + ), + "sample_images.tar.gz": ( + "0ba6fe668a61e9f3cb52032da740fbcf32399ffcc142ddb14380a8e404409bf5" + ), + "test_images.tar.gz": ( + "eaf35f5f6136e2d51e513f00202a11188a85cae8c6f44141fb9666de25ae9554" + ), + "tid2013.tar.gz": ( + "bc486ac749b6cfca8dc5f5340b04b9bb01ab24149a5f3a712f13e9d0489dcde0" + ), + "portilla_simoncelli_test_vectors_refactor.tar.gz": ( + "2ca60f1a60b192668567eb3d94c0cdc8679b23bf94a98331890c41eb9406503a" + ), + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": ( + "9525844b71cf81509b86ed9677172745353588c6bb54e4de8000d695598afa47" + ), + "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": ( + "9fbb490f1548133f6aa49c54832130cf70f8dc6546af59688ead17f62ab94e61" + ), + "portilla_simoncelli_scales_ps-refactor.npz": ( + "1053790a37707627810482beb0dd059cbc193efd688b60c441b3548a75626fdf" + ), } OSF_TEMPLATE = "https://osf.io/{}/download" @@ -34,29 +72,21 @@ "ssim_analysis.mat": OSF_TEMPLATE.format("ndtc7"), "msssim_images.tar.gz": OSF_TEMPLATE.format("5fuba"), "MAD_results.tar.gz": OSF_TEMPLATE.format("jwcsr"), - "portilla_simoncelli_matlab_test_vectors.tar.gz": OSF_TEMPLATE.format( - "qtn5y" - ), + "portilla_simoncelli_matlab_test_vectors.tar.gz": OSF_TEMPLATE.format("qtn5y"), "portilla_simoncelli_test_vectors.tar.gz": OSF_TEMPLATE.format("8r2gq"), "portilla_simoncelli_images.tar.gz": OSF_TEMPLATE.format("eqr3t"), "portilla_simoncelli_synthesize.npz": OSF_TEMPLATE.format("a7p9r"), - "portilla_simoncelli_synthesize_torch_v1.12.0.npz": OSF_TEMPLATE.format( - "gbv8e" - ), + "portilla_simoncelli_synthesize_torch_v1.12.0.npz": OSF_TEMPLATE.format("gbv8e"), "portilla_simoncelli_synthesize_gpu.npz": OSF_TEMPLATE.format("tn4y8"), "portilla_simoncelli_scales.npz": OSF_TEMPLATE.format("xhwv3"), "sample_images.tar.gz": OSF_TEMPLATE.format("6drmy"), "test_images.tar.gz": OSF_TEMPLATE.format("au3b8"), "tid2013.tar.gz": OSF_TEMPLATE.format("uscgv"), - "portilla_simoncelli_test_vectors_refactor.tar.gz": OSF_TEMPLATE.format( - "ca7qt" - ), - "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": OSF_TEMPLATE.format( - "vmwzd" - ), - "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": OSF_TEMPLATE.format( - "mqs6y" + "portilla_simoncelli_test_vectors_refactor.tar.gz": OSF_TEMPLATE.format("ca7qt"), + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor.npz": ( + OSF_TEMPLATE.format("vmwzd") ), + "portilla_simoncelli_synthesize_gpu_ps-refactor.npz": OSF_TEMPLATE.format("mqs6y"), "portilla_simoncelli_scales_ps-refactor.npz": OSF_TEMPLATE.format("nvpr4"), } DOWNLOADABLE_FILES = list(REGISTRY_URLS.keys()) @@ -111,9 +141,7 @@ def fetch_data(dataset_name: str) -> pathlib.Path: processor = pooch.Untar() else: processor = None - fname = retriever.fetch( - dataset_name, progressbar=True, processor=processor - ) + fname = retriever.fetch(dataset_name, progressbar=True, processor=processor) if dataset_name.endswith(".tar.gz"): fname = find_shared_directory([pathlib.Path(f) for f in fname]) else: diff --git a/src/plenoptic/metric/classes.py b/src/plenoptic/metric/classes.py index 39bbe38d..d4fd1762 100644 --- a/src/plenoptic/metric/classes.py +++ b/src/plenoptic/metric/classes.py @@ -37,9 +37,7 @@ def forward(self, image): """ if image.shape[0] > 1 or image.shape[1] > 1: - raise Exception( - "For now, this only supports batch and channel size 1" - ) + raise Exception("For now, this only supports batch and channel size 1") activations = normalized_laplacian_pyramid(image) # activations is a list of tensors, each at a different scale # (down-sampled by factors of 2). To combine these into one diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index fc624d7c..21f56b55 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -36,9 +36,7 @@ def _ssim_parts(img1, img2, pad=False): these work. """ - img_ranges = torch.as_tensor( - [[img1.min(), img1.max()], [img2.min(), img2.max()]] - ) + img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) if (img_ranges > 1).any() or (img_ranges < 0).any(): warnings.warn( "Image range falls outside [0, 1]." @@ -48,16 +46,13 @@ def _ssim_parts(img1, img2, pad=False): if not img1.ndim == img2.ndim == 4: raise Exception( - "Input images should have four dimensions: (batch, channel, height, width)" + "Input images should have four dimensions: (batch, channel," + " height, width)" ) if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if ( - img1.shape[i] != img2.shape[i] - and img1.shape[i] != 1 - and img2.shape[i] != 1 - ): + if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: raise Exception( "Either img1 and img2 should have the same number of " "elements in each dimension, or one of " @@ -66,8 +61,9 @@ def _ssim_parts(img1, img2, pad=False): ) if img1.shape[1] > 1 or img2.shape[1] > 1: warnings.warn( - "SSIM was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches)." + "SSIM was designed for grayscale images and here it will be" + " computed separately for each channel (so channels are treated in" + " the same way as batches)." ) if img1.dtype != img2.dtype: raise ValueError("Input images must have same dtype!") @@ -92,9 +88,7 @@ def _ssim_parts(img1, img2, pad=False): def windowed_average(img): padd = 0 (n_batches, n_channels, _, _) = img.shape - img = img.reshape( - n_batches * n_channels, 1, img.shape[2], img.shape[3] - ) + img = img.reshape(n_batches * n_channels, 1, img.shape[2], img.shape[3]) img_average = F.conv2d(img, window, padding=padd) img_average = img_average.reshape( n_batches, n_channels, img_average.shape[2], img_average.shape[3] @@ -119,9 +113,7 @@ def windowed_average(img): # structure component. The contrast-structure component has to be separated # when computing MS-SSIM. luminance_map = (2 * mu1_mu2 + C1) / (mu1_sq + mu2_sq + C1) - contrast_structure_map = (2.0 * sigma12 + C2) / ( - sigma1_sq + sigma2_sq + C2 - ) + contrast_structure_map = (2.0 * sigma12 + C2) / (sigma1_sq + sigma2_sq + C2) map_ssim = luminance_map * contrast_structure_map # the weight used for stability @@ -349,18 +341,14 @@ def ms_ssim(img1, img2, power_factors=None): power_factors = [0.0448, 0.2856, 0.3001, 0.2363, 0.1333] def downsample(img): - img = F.pad( - img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate" - ) + img = F.pad(img, (0, img.shape[3] % 2, 0, img.shape[2] % 2), mode="replicate") img = F.avg_pool2d(img, kernel_size=2) return img msssim = 1 for i in range(len(power_factors) - 1): _, contrast_structure_map, _ = _ssim_parts(img1, img2) - msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow( - power_factors[i] - ) + msssim *= F.relu(contrast_structure_map.mean((-1, -2))).pow(power_factors[i]) img1 = downsample(img1) img2 = downsample(img2) map_ssim, _, _ = _ssim_parts(img1, img2) @@ -463,16 +451,13 @@ def nlpd(img1, img2): if not img1.ndim == img2.ndim == 4: raise Exception( - "Input images should have four dimensions: (batch, channel, height, width)" + "Input images should have four dimensions: (batch, channel," + " height, width)" ) if img1.shape[-2:] != img2.shape[-2:]: raise Exception("img1 and img2 must have the same height and width!") for i in range(2): - if ( - img1.shape[i] != img2.shape[i] - and img1.shape[i] != 1 - and img2.shape[i] != 1 - ): + if img1.shape[i] != img2.shape[i] and img1.shape[i] != 1 and img2.shape[i] != 1: raise Exception( "Either img1 and img2 should have the same number of " "elements in each dimension, or one of " @@ -481,13 +466,12 @@ def nlpd(img1, img2): ) if img1.shape[1] > 1 or img2.shape[1] > 1: warnings.warn( - "NLPD was designed for grayscale images and here it will be computed separately for each " - "channel (so channels are treated in the same way as batches)." + "NLPD was designed for grayscale images and here it will be" + " computed separately for each channel (so channels are treated in" + " the same way as batches)." ) - img_ranges = torch.as_tensor( - [[img1.min(), img1.max()], [img2.min(), img2.max()]] - ) + img_ranges = torch.as_tensor([[img1.min(), img1.max()], [img2.min(), img2.max()]]) if (img_ranges > 1).any() or (img_ranges < 0).any(): warnings.warn( "Image range falls outside [0, 1]." @@ -501,8 +485,6 @@ def nlpd(img1, img2): epsilon = 1e-10 # for optimization purpose (stabilizing the gradient around zero) dist = [] for i in range(6): - dist.append( - torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon) - ) + dist.append(torch.sqrt(torch.mean((y1[i] - y2[i]) ** 2, dim=(2, 3)) + epsilon)) return torch.stack(dist).mean(dim=0) diff --git a/src/plenoptic/simulate/canonical_computations/filters.py b/src/plenoptic/simulate/canonical_computations/filters.py index d45c4568..464a15e9 100644 --- a/src/plenoptic/simulate/canonical_computations/filters.py +++ b/src/plenoptic/simulate/canonical_computations/filters.py @@ -72,17 +72,11 @@ def circular_gaussian2d( assert out_channels >= 1, "number of filters must be positive integer" assert torch.all(std > 0.0), "stdev must be positive" assert len(std) == out_channels, "Number of stds must equal out_channels" - origin = torch.as_tensor( - ((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0) - ) + origin = torch.as_tensor(((kernel_size[0] + 1) / 2.0, (kernel_size[1] + 1) / 2.0)) origin = origin.to(device) - shift_y = ( - torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] - ) # height - shift_x = ( - torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] - ) # width + shift_y = torch.arange(1, kernel_size[0] + 1, device=device) - origin[0] # height + shift_x = torch.arange(1, kernel_size[1] + 1, device=device) - origin[1] # width (xramp, yramp) = torch.meshgrid(shift_y, shift_x) diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 7e6b3e09..1be64b70 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -22,9 +22,7 @@ complex_types = [torch.cdouble, torch.cfloat] SCALES_TYPE = Union[int, Literal["residual_lowpass", "residual_highpass"]] -KEYS_TYPE = Union[ - tuple[int, int], Literal["residual_lowpass", "residual_highpass"] -] +KEYS_TYPE = Union[tuple[int, int], Literal["residual_lowpass", "residual_highpass"]] class SteerablePyramidFreq(nn.Module): @@ -113,9 +111,7 @@ def __init__( self.image_shape = image_shape if (self.image_shape[0] % 2 != 0) or (self.image_shape[1] % 2 != 0): - warnings.warn( - "Reconstruction will not be perfect with odd-sized images" - ) + warnings.warn("Reconstruction will not be perfect with odd-sized images") self.is_complex = is_complex self.downsample = downsample @@ -133,16 +129,11 @@ def __init__( ) self.alpha = (self.Xcosn + np.pi) % (2 * np.pi) - np.pi - max_ht = ( - np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) - - 2 - ) + max_ht = np.floor(np.log2(min(self.image_shape[0], self.image_shape[1]))) - 2 if height == "auto": self.num_scales = int(max_ht) elif height > max_ht: - raise ValueError( - "Cannot build pyramid higher than %d levels." % (max_ht) - ) + raise ValueError("Cannot build pyramid higher than %d levels." % (max_ht)) else: self.num_scales = int(height) @@ -170,9 +161,7 @@ def __init__( self.log_rad = np.log2(log_rad) # radial transition function (a raised cosine in log-frequency): - self.Xrcos, Yrcos = raised_cosine( - twidth, (-twidth / 2.0), np.array([0, 1]) - ) + self.Xrcos, Yrcos = raised_cosine(twidth, (-twidth / 2.0), np.array([0, 1])) self.Yrcos = np.sqrt(Yrcos) self.YIrcos = np.sqrt(1.0 - self.Yrcos**2) @@ -210,10 +199,7 @@ def __init__( const = ( (2 ** (2 * self.order)) * (factorial(self.order, exact=True) ** 2) - / float( - self.num_orientations - * factorial(2 * self.order, exact=True) - ) + / float(self.num_orientations * factorial(2 * self.order, exact=True)) ) if self.is_complex: @@ -223,14 +209,10 @@ def __init__( * (np.cos(self.Xcosn) ** self.order) * (np.abs(self.alpha) < np.pi / 2.0).astype(int) ) - Ycosn_recon = ( - np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order - ) + Ycosn_recon = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order else: - Ycosn_forward = ( - np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order - ) + Ycosn_forward = np.sqrt(const) * (np.cos(self.Xcosn)) ** self.order Ycosn_recon = Ycosn_forward himask = interpolate1d(log_rad, self.Yrcos, Xrcos) @@ -252,13 +234,9 @@ def __init__( self.Xcosn + np.pi * b / self.num_orientations, ) anglemasks.append(torch.as_tensor(anglemask).unsqueeze(0)) - anglemasks_recon.append( - torch.as_tensor(anglemask_recon).unsqueeze(0) - ) + anglemasks_recon.append(torch.as_tensor(anglemask_recon).unsqueeze(0)) - self.register_buffer( - f"_anglemasks_scale_{i}", torch.cat(anglemasks) - ) + self.register_buffer(f"_anglemasks_scale_{i}", torch.cat(anglemasks)) self.register_buffer( f"_anglemasks_recon_scale_{i}", torch.cat(anglemasks_recon) ) @@ -339,9 +317,7 @@ def forward( # x is a torch tensor batch of images of size (batch, channel, height, # width) - assert ( - len(x.shape) == 4 - ), "Input must be batch of images of shape BxCxHxW" + assert len(x.shape) == 4, "Input must be batch of images of shape BxCxHxW" imdft = fft.fft2(x, dim=(-2, -1), norm=self.fft_norm) imdft = fft.fftshift(imdft) @@ -411,9 +387,7 @@ def forward( angle = angle[lostart[0] : loend[0], lostart[1] : loend[1]] # subsampling of the dft for next scale - lodft = lodft[ - :, :, lostart[0] : loend[0], lostart[1] : loend[1] - ] + lodft = lodft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] # low-pass filter mask is selected lomask = getattr(self, f"_lomasks_scale_{i}") # again multiply dft by subsampled mask (convolution in spatial domain) @@ -618,7 +592,8 @@ def _recon_levels_check( if isinstance(levels, str): if levels != "all": raise TypeError( - f"levels must be a list of levels or the string 'all' but got {levels}" + "levels must be a list of levels or the string 'all' but" + f" got {levels}" ) levels = ( ["residual_highpass"] @@ -628,17 +603,13 @@ def _recon_levels_check( else: if not hasattr(levels, "__iter__"): raise TypeError( - f"levels must be a list of levels or the string 'all' but got {levels}" + "levels must be a list of levels or the string 'all' but" + f" got {levels}" ) - levs_nums = np.array( - [int(i) for i in levels if isinstance(i, int)] - ) - assert ( - levs_nums >= 0 - ).all(), "Level numbers must be non-negative." + levs_nums = np.array([int(i) for i in levels if isinstance(i, int)]) + assert (levs_nums >= 0).all(), "Level numbers must be non-negative." assert (levs_nums < self.num_scales).all(), ( - "Level numbers must be in the range [0, %d]" - % (self.num_scales - 1) + "Level numbers must be in the range [0, %d]" % (self.num_scales - 1) ) levs_tmp = list(np.sort(levs_nums)) # we want smallest first if "residual_highpass" in levels: @@ -660,9 +631,7 @@ def _recon_levels_check( levels.pop(0) return levels - def _recon_bands_check( - self, bands: Literal["all"] | list[int] - ) -> list[int]: + def _recon_bands_check(self, bands: Literal["all"] | list[int]) -> list[int]: """Check whether bands arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies @@ -686,18 +655,18 @@ def _recon_bands_check( if isinstance(bands, str): if bands != "all": raise TypeError( - f"bands must be a list of ints or the string 'all' but got {bands}" + "bands must be a list of ints or the string 'all' but got" + f" {bands}" ) bands = np.arange(self.num_orientations) else: if not hasattr(bands, "__iter__"): raise TypeError( - f"bands must be a list of ints or the string 'all' but got {bands}" + "bands must be a list of ints or the string 'all' but got" + f" {bands}" ) bands: NDArray = np.array(bands, ndmin=1) - assert ( - bands >= 0 - ).all(), "Error: band numbers must be larger than 0." + assert (bands >= 0).all(), "Error: band numbers must be larger than 0." assert (bands < self.num_orientations).all(), ( "Error: band numbers must be in the range [0, %d]" % (self.num_orientations - 1) @@ -747,8 +716,8 @@ def _recon_keys( for i in bands: if i >= max_orientations: warnings.warn( - "You wanted band %d in the reconstruction but max_orientation" - " is %d, so we're ignoring that band" + "You wanted band %d in the reconstruction but" + " max_orientation is %d, so we're ignoring that band" % (i, max_orientations) ) bands = [i for i in bands if i < max_orientations] @@ -804,16 +773,16 @@ def recon_pyr( if s not in pyr_coeffs.keys(): raise Exception( f"scale {s} not in pyr_coeffs! pyr_coeffs must include" - " all scales, so make sure forward() was called with arg " - "scales=None" + " all scales, so make sure forward() was called with" + " arg scales=None" ) else: for b in range(self.num_orientations): if (s, b) not in pyr_coeffs.keys(): raise Exception( - f"scale {s} not in pyr_coeffs! pyr_coeffs must " - "include all scales, so make sure forward() was called " - "with arg scales=None" + f"scale {s} not in pyr_coeffs! pyr_coeffs must" + " include all scales, so make sure forward() was" + " called with arg scales=None" ) recon_keys = self._recon_keys(levels, bands) @@ -847,9 +816,7 @@ def recon_pyr( # get output reconstruction by inverting the fft reconstruction = fft.ifftshift(outdft) - reconstruction = fft.ifft2( - reconstruction, dim=(-2, -1), norm=self.fft_norm - ) + reconstruction = fft.ifft2(reconstruction, dim=(-2, -1), norm=self.fft_norm) # get real part of reconstruction (if complex) reconstruction = reconstruction.real @@ -907,9 +874,7 @@ def _recon_levels( for b in range(self.num_orientations): if (scale, b) in recon_keys: - anglemask = getattr(self, f"_anglemasks_recon_scale_{scale}")[ - b - ] + anglemask = getattr(self, f"_anglemasks_recon_scale_{scale}")[b] coeffs = pyr_coeffs[(scale, b)] if self.tight_frame and self.is_complex: coeffs = coeffs * np.sqrt(2) @@ -933,14 +898,10 @@ def _recon_levels( if (not self.tight_frame) and (not self.downsample): reslevdft = reslevdft / 2 # create output for reconstruction result - resdft = torch.zeros_like( - pyr_coeffs[(scale, 0)], dtype=torch.complex64 - ) + resdft = torch.zeros_like(pyr_coeffs[(scale, 0)], dtype=torch.complex64) # place upsample and convolve lowpass component - resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = ( - reslevdft * lomask - ) + resdft[:, :, lostart[0] : loend[0], lostart[1] : loend[1]] = reslevdft * lomask recondft = resdft + orientdft # add orientation interpolated and added images to the lowpass image return recondft diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 1534232c..edd378b8 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -107,9 +107,7 @@ def display_filters(self, zoom=5.0, **kwargs): weights = self.center_surround.filt.detach() title = "linear filt" - fig = imshow( - weights, title=title, zoom=zoom, vrange="indep0", **kwargs - ) + fig = imshow(weights, title=title, zoom=zoom, vrange="indep0", **kwargs) return fig @@ -295,9 +293,7 @@ def forward(self, x: Tensor) -> Tensor: lum = self.luminance(x) lum_normed = linear / (1 + self.luminance_scalar * lum) - con = ( - self.contrast(lum_normed.pow(2)).sqrt() + 1e-6 - ) # avoid div by zero + con = self.contrast(lum_normed.pow(2)).sqrt() + 1e-6 # avoid div by zero con_normed = lum_normed / (1 + self.contrast_scalar * con) y = self.activation(con_normed) return y @@ -405,8 +401,9 @@ def __init__( ), "pretrained model has kernel_size (31, 31)" if cache_filt is False: warn( - "pretrained is True but cache_filt is False. Set cache_filt to " - "True for efficiency unless you are fine-tuning." + "pretrained is True but cache_filt is False. Set" + " cache_filt to True for efficiency unless you are" + " fine-tuning." ) self.center_surround = CenterSurround( @@ -447,23 +444,15 @@ def __init__( def forward(self, x: Tensor) -> Tensor: linear = self.center_surround(x) lum = self.luminance(x) - lum_normed = linear / ( - 1 + self.luminance_scalar.view(1, 2, 1, 1) * lum - ) + lum_normed = linear / (1 + self.luminance_scalar.view(1, 2, 1, 1) * lum) - con = ( - self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1e-6 - ) # avoid div by 0 - con_normed = lum_normed / ( - 1 + self.contrast_scalar.view(1, 2, 1, 1) * con - ) + con = self.contrast(lum_normed.pow(2), groups=2).sqrt() + 1e-6 # avoid div by 0 + con_normed = lum_normed / (1 + self.contrast_scalar.view(1, 2, 1, 1) * con) y = self.activation(con_normed) if self.apply_mask: im_shape = x.shape[-2:] - if ( - self._disk is None or self._disk.shape != im_shape - ): # cache new mask + if self._disk is None or self._disk.shape != im_shape: # cache new mask self._disk = make_disk(im_shape).to(x.device) if self._disk.device != x.device: self._disk = self._disk.to(x.device) diff --git a/src/plenoptic/simulate/models/naive.py b/src/plenoptic/simulate/models/naive.py index a7fc926a..a306f42f 100644 --- a/src/plenoptic/simulate/models/naive.py +++ b/src/plenoptic/simulate/models/naive.py @@ -133,9 +133,7 @@ def filt(self): if self._filt is not None: # use old filter return self._filt else: # create new filter, optionally cache it - filt = circular_gaussian2d( - self.kernel_size, self.std, self.out_channels - ) + filt = circular_gaussian2d(self.kernel_size, self.std, self.out_channels) if self.cache_filt: self.register_buffer("_filt", filt) @@ -210,40 +208,27 @@ def __init__( # make sure each channel is on-off or off-on if isinstance(on_center, bool): on_center = [on_center] * out_channels - assert ( - len(on_center) == out_channels - ), "len(on_center) must match out_channels" + assert len(on_center) == out_channels, "len(on_center) must match out_channels" # make sure each channel has a center and surround std if isinstance(center_std, float) or center_std.shape == torch.Size([]): center_std = torch.ones(out_channels) * center_std - if isinstance(surround_std, float) or surround_std.shape == torch.Size( - [] - ): + if isinstance(surround_std, float) or surround_std.shape == torch.Size([]): surround_std = torch.ones(out_channels) * surround_std assert ( - len(center_std) == out_channels - and len(surround_std) == out_channels + len(center_std) == out_channels and len(surround_std) == out_channels ), "stds must correspond to each out_channel" - assert ( - width_ratio_limit > 1.0 - ), "stdev of surround must be greater than center" - assert ( - amplitude_ratio >= 1.0 - ), "ratio of amplitudes must at least be 1." + assert width_ratio_limit > 1.0, "stdev of surround must be greater than center" + assert amplitude_ratio >= 1.0, "ratio of amplitudes must at least be 1." self.on_center = on_center self.kernel_size = kernel_size self.width_ratio_limit = width_ratio_limit - self.register_buffer( - "amplitude_ratio", torch.as_tensor(amplitude_ratio) - ) + self.register_buffer("amplitude_ratio", torch.as_tensor(amplitude_ratio)) self.center_std = nn.Parameter(torch.ones(out_channels) * center_std) - self.surround_std = nn.Parameter( - torch.ones(out_channels) * surround_std - ) + self.surround_std = nn.Parameter(torch.ones(out_channels) * surround_std) self.out_channels = out_channels self.pad_mode = pad_mode @@ -268,9 +253,9 @@ def filt(self) -> Tensor: ) # sign is + or - depending on center is on or off - sign = torch.as_tensor( - [1.0 if x else -1.0 for x in self.on_center] - ).to(device) + sign = torch.as_tensor([1.0 if x else -1.0 for x in self.on_center]).to( + device + ) sign = sign.view(self.out_channels, 1, 1, 1) filt = on_amp * (sign * (filt_center - filt_surround)) @@ -283,9 +268,7 @@ def _clamp_surround_std(self): """Clamps surround standard deviation to ratio_limit times center_std""" lower_bound = self.width_ratio_limit * self.center_std for i, lb in enumerate(lower_bound): - self.surround_std[i].data = self.surround_std[i].data.clamp( - min=float(lb) - ) + self.surround_std[i].data = self.surround_std[i].data.clamp(min=float(lb)) def forward(self, x: Tensor) -> Tensor: x = same_padding(x, self.kernel_size, pad_mode=self.pad_mode) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index 30b7054c..fe4b482a 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -239,9 +239,9 @@ def _create_scales_shape_dict(self) -> OrderedDict: dtype=int, ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") - shape_dict[ - "cross_orientation_correlation_magnitude" - ] = cross_orientation_corr_mag + shape_dict["cross_orientation_correlation_magnitude"] = ( + cross_orientation_corr_mag + ) mags_std = np.ones((self.n_orientations, self.n_scales), dtype=int) mags_std *= einops.rearrange(scales, "s -> 1 s") @@ -251,18 +251,14 @@ def _create_scales_shape_dict(self) -> OrderedDict: (self.n_orientations, self.n_orientations, self.n_scales - 1), dtype=int, ) - cross_scale_corr_mag *= einops.rearrange( - scales_without_coarsest, "s -> 1 1 s" - ) + cross_scale_corr_mag *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_magnitude"] = cross_scale_corr_mag cross_scale_corr_real = np.ones( (self.n_orientations, 2 * self.n_orientations, self.n_scales - 1), dtype=int, ) - cross_scale_corr_real *= einops.rearrange( - scales_without_coarsest, "s -> 1 1 s" - ) + cross_scale_corr_real *= einops.rearrange(scales_without_coarsest, "s -> 1 1 s") shape_dict["cross_scale_correlation_real"] = cross_scale_corr_real shape_dict["var_highpass_residual"] = np.array(["residual_highpass"]) @@ -299,9 +295,7 @@ def _create_necessary_stats_dict( mask_dict = scales_shape_dict.copy() # Pre-compute some necessary indices. # Lower triangular indices (including diagonal), for auto correlations - tril_inds = torch.tril_indices( - self.spatial_corr_width, self.spatial_corr_width - ) + tril_inds = torch.tril_indices(self.spatial_corr_width, self.spatial_corr_width) # Get the second half of the diagonal, i.e., everything from the center # element on. These are all repeated for the auto correlations. (As # these are autocorrelations (rather than auto-covariance) matrices, @@ -314,9 +308,7 @@ def _create_necessary_stats_dict( # for cross_orientation_correlation_magnitude (because we've normalized # this matrix to be true cross-correlations, the diagonals are all 1, # like for the auto-correlations) - triu_inds = torch.triu_indices( - self.n_orientations, self.n_orientations - ) + triu_inds = torch.triu_indices(self.n_orientations, self.n_orientations) for k, v in mask_dict.items(): if k in [ "auto_correlation_magnitude", @@ -342,9 +334,7 @@ def _create_necessary_stats_dict( mask_dict[k] = mask return mask_dict - def forward( - self, image: Tensor, scales: list[SCALES_TYPE] | None = None - ) -> Tensor: + def forward(self, image: Tensor, scales: list[SCALES_TYPE] | None = None) -> Tensor: r"""Generate Texture Statistics representation of an image. Note that separate batches and channels are analyzed in parallel. @@ -399,9 +389,7 @@ def forward( # Then, the reconstructed lowpass image at each scale. (this is a list # of length n_scales+1 containing tensors of shape (batch, channel, # height, width)) - reconstructed_images = self._reconstruct_lowpass_at_each_scale( - pyr_dict - ) + reconstructed_images = self._reconstruct_lowpass_at_each_scale(pyr_dict) # the reconstructed_images list goes from coarse-to-fine, but we want # each of the stats computed from it to go from fine-to-coarse, so we # reverse its direction. @@ -423,9 +411,7 @@ def forward( # tensor of shape (batch, channel, spatial_corr_width, # spatial_corr_width, n_scales+1), and var_recon is a tensor of shape # (batch, channel, n_scales+1) - autocorr_recon, var_recon = self._compute_autocorr( - reconstructed_images - ) + autocorr_recon, var_recon = self._compute_autocorr(reconstructed_images) # Compute the standard deviation, skew, and kurtosis of each # reconstructed lowpass image. std_recon, skew_recon, and # kurtosis_recon will all end up as tensors of shape (batch, channel, @@ -509,9 +495,7 @@ def forward( # Return the subset of stats corresponding to the specified scale. if scales is not None: - representation_tensor = self.remove_scales( - representation_tensor, scales - ) + representation_tensor = self.remove_scales(representation_tensor, scales) return representation_tensor @@ -601,11 +585,11 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: """ if representation_tensor.shape[-1] != len(self._representation_scales): raise ValueError( - "representation tensor is the wrong length (expected " - f"{len(self._representation_scales)} but got {representation_tensor.shape[-1]})!" - " Did you remove some of the scales? (i.e., by setting " - "scales in the forward pass)? convert_to_dict does not " - "support such tensors." + "representation tensor is the wrong length (expected" + f" {len(self._representation_scales)} but got" + f" {representation_tensor.shape[-1]})! Did you remove some of" + " the scales? (i.e., by setting scales in the forward pass)?" + " convert_to_dict does not support such tensors." ) rep = self._necessary_stats_dict.copy() @@ -621,9 +605,7 @@ def convert_to_dict(self, representation_tensor: Tensor) -> OrderedDict: device=representation_tensor.device, ) # v.sum() gives the number of necessary elements from this stat - this_stat_vec = representation_tensor[ - ..., n_filled : n_filled + v.sum() - ] + this_stat_vec = representation_tensor[..., n_filled : n_filled + v.sum()] # use boolean indexing to put the values from new_stat_vec in the # appropriate place new_v[..., v] = this_stat_vec @@ -675,9 +657,7 @@ def _compute_pyr_coeffs( # of shape (batch, channel, n_orientations, height, width) (note that # height and width halves on each scale) coeffs_list = [ - torch.stack( - [pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2 - ) + torch.stack([pyr_coeffs[(i, j)] for j in range(self.n_orientations)], 2) for i in range(self.n_scales) ] return pyr_coeffs, coeffs_list, highpass, lowpass @@ -714,9 +694,7 @@ def _compute_pixel_stats(image: Tensor) -> Tensor: # mean needed to be unflattened to be used by skew and kurtosis # correctly, but we'll want it to be flattened like this in the final # representation tensor - return einops.pack( - [mean, var, skew, kurtosis, img_min, img_max], "b c *" - )[0] + return einops.pack([mean, var, skew, kurtosis, img_min, img_max], "b c *")[0] @staticmethod def _compute_intermediate_representations( @@ -798,15 +776,12 @@ def _reconstruct_lowpass_at_each_scale( # values across scales. This could also be handled by making the # pyramid tight frame reconstructed_images[:-1] = [ - signal.shrink(r, 2 ** (self.n_scales - i)) - * 4 ** (self.n_scales - i) + signal.shrink(r, 2 ** (self.n_scales - i)) * 4 ** (self.n_scales - i) for i, r in enumerate(reconstructed_images[:-1]) ] return reconstructed_images - def _compute_autocorr( - self, coeffs_list: list[Tensor] - ) -> tuple[Tensor, Tensor]: + def _compute_autocorr(self, coeffs_list: list[Tensor]) -> tuple[Tensor, Tensor]: """Compute the autocorrelation of some statistics. Parameters @@ -846,9 +821,10 @@ def _compute_autocorr( var = einops.pack(var, "b c *")[0] acs = [signal.center_crop(ac, self.spatial_corr_width) for ac in acs] acs = torch.stack(acs, 2) - return einops.rearrange( - acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}" - ), var + return ( + einops.rearrange(acs, f"b c {dims} a1 a2 -> b c a1 a2 {dims}"), + var, + ) @staticmethod def _compute_skew_kurtosis_recon( @@ -901,9 +877,7 @@ def _compute_skew_kurtosis_recon( res = torch.finfo(img_var.dtype).resolution unstable_locs = var_recon / img_var.unsqueeze(-1) < res skew_recon = torch.where(unstable_locs, skew_default, skew_recon) - kurtosis_recon = torch.where( - unstable_locs, kurtosis_default, kurtosis_recon - ) + kurtosis_recon = torch.where(unstable_locs, kurtosis_default, kurtosis_recon) return skew_recon, kurtosis_recon def _compute_cross_correlation( @@ -952,9 +926,7 @@ def _compute_cross_correlation( # First, compute the variances of each coeff (if coeff and # coeff_other are identical, this is equivalent to the diagonal of # the above covar matrix, but re-computing it is actually faster) - coeff_var = einops.einsum( - coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1" - ) + coeff_var = einops.einsum(coeff, coeff, "b c o1 h w, b c o1 h w -> b c o1") coeff_var = coeff_var / numel coeffs_var.append(coeff_var) if tensors_are_identical: @@ -1019,9 +991,7 @@ def _double_phase_pyr_coeffs( ) doubled_phase_mags.append(doubled_phase_mag) doubled_phase_sep.append( - einops.pack( - [doubled_phase.real, doubled_phase.imag], "b c * h w" - )[0] + einops.pack([doubled_phase.real, doubled_phase.imag], "b c * h w")[0] ) return doubled_phase_mags, doubled_phase_sep @@ -1159,8 +1129,8 @@ def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: """ if rep["skew_reconstructed"].ndim > 1: raise ValueError( - "Currently, only know how to plot single batch and channel at a time! " - "Select and/or average over those dimensions" + "Currently, only know how to plot single batch and channel at" + " a time! Select and/or average over those dimensions" ) data = OrderedDict() data["pixels+var_highpass"] = torch.cat( diff --git a/src/plenoptic/synthesize/autodiff.py b/src/plenoptic/synthesize/autodiff.py index 892eef40..4e52f41f 100755 --- a/src/plenoptic/synthesize/autodiff.py +++ b/src/plenoptic/synthesize/autodiff.py @@ -22,8 +22,9 @@ def jacobian(y: Tensor, x: Tensor) -> Tensor: if x.numel() > 1e4: warnings.warn( - "Calculation of Jacobian with input dimensionality greater than 1E4 may take too long; consider" - "an iterative method (e.g. power method, randomized svd) instead." + "Calculation of Jacobian with input dimensionality greater than" + " 1E4 may take too long; consideran iterative method (e.g. power" + " method, randomized svd) instead." ) J = ( @@ -40,9 +41,7 @@ def jacobian(y: Tensor, x: Tensor) -> Tensor: .t() ) - if ( - y.shape[0] == 1 - ): # need to return a 2D tensor even if y dimensionality is 1 + if y.shape[0] == 1: # need to return a 2D tensor even if y dimensionality is 1 J = J.unsqueeze(0) return J.detach() diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 9f96eaaa..40ac8a8d 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -142,8 +142,9 @@ def __init__(self, image: Tensor, model: torch.nn.Module): self._init_representation(image) print( - f"\nInitializing Eigendistortion -- " - f"Input dim: {len(self._image_flat.squeeze())} | Output dim: {len(self._representation_flat.squeeze())}" + "\nInitializing Eigendistortion -- Input dim:" + f" {len(self._image_flat.squeeze())} | Output dim:" + f" {len(self._representation_flat.squeeze())}" ) self._jacobian = None @@ -202,17 +203,15 @@ def synthesize( """ allowed_methods = ["power", "exact", "randomized_svd"] - assert ( - method in allowed_methods - ), f"method must be in {allowed_methods}" + assert method in allowed_methods, f"method must be in {allowed_methods}" if ( method == "exact" - and self._representation_flat.size(0) * self._image_flat.size(0) - > 1e6 + and self._representation_flat.size(0) * self._image_flat.size(0) > 1e6 ): warnings.warn( - "Jacobian > 1e6 elements and may cause out-of-memory. Use method = {'power', 'randomized_svd'}." + "Jacobian > 1e6 elements and may cause out-of-memory. Use" + " method = {'power', 'randomized_svd'}." ) if method == "exact": # compute exact Jacobian @@ -222,9 +221,7 @@ def synthesize( eig_vecs_ind = torch.arange(len(eig_vecs)) elif method == "randomized_svd": - print( - f"Estimating top k={k} eigendistortions using randomized SVD" - ) + print(f"Estimating top k={k} eigendistortions using randomized SVD") lmbda_new, v_new, error_approx = self._synthesize_randomized_svd( k=k, p=p, q=q ) @@ -234,7 +231,8 @@ def synthesize( # display the approximate estimation error of the range space print( - f"Randomized SVD complete! Estimated spectral approximation error = {error_approx:.2f}" + "Randomized SVD complete! Estimated spectral approximation" + f" error = {error_approx:.2f}" ) else: # method == 'power' @@ -248,16 +246,12 @@ def synthesize( ) n = v_max.shape[0] - eig_vecs = self._vector_to_image( - torch.cat((v_max, v_min), dim=1).detach() - ) + eig_vecs = self._vector_to_image(torch.cat((v_max, v_min), dim=1).detach()) eig_vals = torch.cat([lmbda_max, lmbda_min]).squeeze() eig_vecs_ind = torch.cat((torch.arange(k), torch.arange(n - k, n))) # reshape to (n x num_chans x h x w) - self._eigendistortions = ( - torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] - ) + self._eigendistortions = torch.stack(eig_vecs, 0) if len(eig_vecs) != 0 else [] self._eigenvalues = torch.abs(eig_vals.detach()) self._eigenindex = eig_vecs_ind @@ -343,9 +337,7 @@ def _synthesize_power( v = torch.randn(len(x), k, device=x.device, dtype=x.dtype) v = v / torch.linalg.vector_norm(v, dim=0, keepdim=True, ord=2) - _dummy_vec = torch.ones_like( - y, requires_grad=True - ) # cache a dummy vec for jvp + _dummy_vec = torch.ones_like(y, requires_grad=True) # cache a dummy vec for jvp Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) v = Fv / torch.linalg.vector_norm(Fv, dim=0, keepdim=True, ord=2) lmbda = fisher_info_matrix_eigenvalue(y, x, v, _dummy_vec) @@ -367,9 +359,7 @@ def _synthesize_power( Fv = fisher_info_matrix_vector_product(y, x, v, _dummy_vec) Fv = Fv - shift * v # optionally shift: (F - shift*I)v - v_new, _ = torch.linalg.qr( - Fv, "reduced" - ) # (ortho)normalize vector(s) + v_new, _ = torch.linalg.qr(Fv, "reduced") # (ortho)normalize vector(s) lmbda_new = fisher_info_matrix_eigenvalue(y, x, v_new, _dummy_vec) @@ -444,9 +434,7 @@ def _synthesize_randomized_svd( y, x, torch.randn(n, 20).to(x.device), _dummy_vec ) error_approx = omega - (Q @ Q.T @ omega) - error_approx = torch.linalg.vector_norm( - error_approx, dim=0, ord=2 - ).mean() + error_approx = torch.linalg.vector_norm(error_approx, dim=0, ord=2).mean() return S[:k].clone(), V[:, :k].clone(), error_approx # truncate @@ -466,9 +454,7 @@ def _vector_to_image(self, vecs: Tensor) -> list[Tensor]: """ imgs = [ - vecs[:, i].reshape( - (self.n_channels, self.im_height, self.im_width) - ) + vecs[:, i].reshape((self.n_channels, self.im_height, self.im_width)) for i in range(vecs.shape[1]) ] return imgs @@ -480,9 +466,7 @@ def _indexer(self, idx: int) -> int: i = idx_range[idx] all_idx = self.eigenindex - assert ( - i in all_idx - ), "eigenindex must be the index of one of the vectors" + assert i in all_idx, "eigenindex must be the index of one of the vectors" assert ( all_idx is not None and len(all_idx) != 0 ), "No eigendistortions synthesized" diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index f2f2d6af..95fc8e37 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -191,14 +191,9 @@ def synthesize( if stop_criterion is None: # semi arbitrary default choice of tolerance stop_criterion = ( - torch.linalg.vector_norm(self.pixelfade, ord=2) - / 1e4 - * (1 + 5**0.5) - / 2 + torch.linalg.vector_norm(self.pixelfade, ord=2) / 1e4 * (1 + 5**0.5) / 2 ) - print( - f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}" - ) + print(f"\n Stop criterion for pixel_change_norm = {stop_criterion:.5e}") self._initialize_optimizer(optimizer, "_geodesic", 0.001) @@ -215,9 +210,7 @@ def synthesize( raise ValueError("Found a NaN in loss during optimization.") if self._check_convergence(stop_criterion, stop_iters_to_check): - warnings.warn( - "Pixel change norm has converged, stopping synthesis" - ) + warnings.warn("Pixel change norm has converged, stopping synthesis") break pbar.close() @@ -260,9 +253,7 @@ def objective_function(self, geodesic: Tensor | None = None) -> Tensor: def _calculate_step_energy(self, z): """calculate the energy (i.e. squared l2 norm) of each step in `z`.""" velocity = torch.diff(z, dim=0) - step_energy = ( - torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 - ) + step_energy = torch.linalg.vector_norm(velocity, ord=2, dim=[1, 2, 3]) ** 2 return step_energy def _optimizer_step(self, pbar): @@ -283,9 +274,7 @@ def _optimizer_step(self, pbar): loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm( - self._geodesic.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self._geodesic.grad.data, ord=2, dim=None) self._gradient_norm.append(grad_norm) pixel_change_norm = torch.linalg.vector_norm( @@ -335,9 +324,7 @@ def _check_convergence( Whether the pixel change norm has stabilized or not. """ - return pixel_change_convergence( - self, stop_criterion, stop_iters_to_check - ) + return pixel_change_convergence(self, stop_criterion, stop_iters_to_check) def calculate_jerkiness(self, geodesic: Tensor | None = None) -> Tensor: """Compute the alignment of representation's acceleration to model local curvature. @@ -371,9 +358,7 @@ def calculate_jerkiness(self, geodesic: Tensor | None = None) -> Tensor: accJac = self._vector_jacobian_product( geodesic_representation[1:-1], geodesic, acc_direction )[1:-1] - step_jerkiness = ( - torch.linalg.vector_norm(accJac, dim=[1, 2, 3], ord=2) ** 2 - ) + step_jerkiness = torch.linalg.vector_norm(accJac, dim=[1, 2, 3], ord=2) ** 2 return step_jerkiness def _vector_jacobian_product(self, y, x, a): @@ -381,9 +366,7 @@ def _vector_jacobian_product(self, y, x, a): and allow for further gradient computations by retaining, and creating the graph. """ - accJac = autograd.grad(y, x, a, retain_graph=True, create_graph=True)[ - 0 - ] + accJac = autograd.grad(y, x, a, retain_graph=True, create_graph=True)[0] return accJac def _store(self, i: int) -> bool: @@ -425,9 +408,7 @@ def _store(self, i: int) -> bool: self._calculate_step_energy(geod_rep).detach().to("cpu") ) self._dev_from_line.append( - torch.stack( - deviation_from_line(geod_rep.detach().to("cpu")) - ).T + torch.stack(deviation_from_line(geod_rep.detach().to("cpu"))).T ) stored = True else: @@ -558,7 +539,8 @@ def load( old_loss = self.__dict__.pop("_save_check") if not torch.allclose(new_loss, old_loss, rtol=1e-2): raise ValueError( - "objective_function on pixelfade of saved and initialized Geodesic object are different! Do they use the same model?" + "objective_function on pixelfade of saved and initialized" + " Geodesic object are different! Do they use the same model?" f" Self: {new_loss}, Saved: {old_loss}" ) # make this require a grad again @@ -566,17 +548,9 @@ def load( # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if ( - len(self._dev_from_line) - and self._dev_from_line[0].device.type != "cpu" - ): - self._dev_from_line = [ - dev.to("cpu") for dev in self._dev_from_line - ] - if ( - len(self._step_energy) - and self._step_energy[0].device.type != "cpu" - ): + if len(self._dev_from_line) and self._dev_from_line[0].device.type != "cpu": + self._dev_from_line = [dev.to("cpu") for dev in self._dev_from_line] + if len(self._step_energy) and self._step_energy[0].device.type != "cpu": self._step_energy = [step.to("cpu") for step in self._step_energy] @property @@ -699,16 +673,12 @@ def plot_deviation_from_line( pixelfade_dev = deviation_from_line(geodesic.model(geodesic.pixelfade)) ax.plot(*[to_numpy(d) for d in pixelfade_dev], "g-o", label="pixelfade") - geodesic_dev = deviation_from_line( - geodesic.model(geodesic.geodesic).detach() - ) + geodesic_dev = deviation_from_line(geodesic.model(geodesic.geodesic).detach()) ax.plot(*[to_numpy(d) for d in geodesic_dev], "r-o", label="geodesic") if natural_video is not None: video_dev = deviation_from_line(geodesic.model(natural_video)) - ax.plot( - *[to_numpy(d) for d in video_dev], "b-o", label="natural video" - ) + ax.plot(*[to_numpy(d) for d in video_dev], "b-o", label="natural video") ax.set( xlabel="Distance along representation line", diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 36f6ab55..45cccab7 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -142,8 +142,7 @@ def __init__( # approximately the same magnitude if metric_tradeoff_lambda is None: loss_ratio = torch.as_tensor( - self.optimized_metric_loss[-1] - / self.reference_metric_loss[-1], + self.optimized_metric_loss[-1] / self.reference_metric_loss[-1], dtype=torch.float32, ) metric_tradeoff_lambda = torch.pow( @@ -298,8 +297,7 @@ def objective_function( synth_target = {"min": 1, "max": -1}[self.minmax] synthesis_loss = self.optimized_metric(image, mad_image) fixed_loss = ( - self._reference_metric_target - - self.reference_metric(image, mad_image) + self._reference_metric_target - self.reference_metric(image, mad_image) ).pow(2) range_penalty = optim.penalize_range(mad_image, self.allowed_range) return ( @@ -328,9 +326,7 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: last_iter_mad_image = self.mad_image.clone() loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm( - self.mad_image.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self.mad_image.grad.data, ord=2, dim=None) self._gradient_norm.append(grad_norm.item()) fm = self.reference_metric(self.image, self.mad_image) @@ -554,13 +550,8 @@ def load( # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if ( - len(self._saved_mad_image) - and self._saved_mad_image[0].device.type != "cpu" - ): - self._saved_mad_image = [ - mad.to("cpu") for mad in self._saved_mad_image - ] + if len(self._saved_mad_image) and self._saved_mad_image[0].device.type != "cpu": + self._saved_mad_image = [mad.to("cpu") for mad in self._saved_mad_image] @property def mad_image(self): @@ -835,9 +826,7 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots( - to_check: list[str] | dict[str, int], to_check_name: str -): +def _check_included_plots(to_check: list[str] | dict[str, int], to_check_name: str): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -939,9 +928,7 @@ def _setup_synthesis_fig( n_subplots += 1 width_ratios.append(display_mad_image_width) if "display_mad_image" not in axes_idx.keys(): - axes_idx["display_mad_image"] = data._find_min_int( - axes_idx.values() - ) + axes_idx["display_mad_image"] = data._find_min_int(axes_idx.values()) if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) @@ -951,9 +938,7 @@ def _setup_synthesis_fig( n_subplots += 1 width_ratios.append(plot_pixel_values_width) if "plot_pixel_values" not in axes_idx.keys(): - axes_idx["plot_pixel_values"] = data._find_min_int( - axes_idx.values() - ) + axes_idx["plot_pixel_values"] = data._find_min_int(axes_idx.values()) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: @@ -1213,8 +1198,7 @@ def animate( """ if not mad.store_progress: raise ValueError( - "synthesize() was run with store_progress=False," - " cannot animate!" + "synthesize() was run with store_progress=False, cannot animate!" ) if mad.mad_image.ndim not in [3, 4]: raise ValueError( @@ -1345,24 +1329,16 @@ def display_mad_image_all( # this is a bit of a hack right now, because they don't all have same # initial image if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: metric2_name = mad_metric2_min.optimized_metric.__name__ - fig = pt_make_figure( - 3, 2, [zoom * i for i in mad_metric1_min.image.shape[-2:]] - ) + fig = pt_make_figure(3, 2, [zoom * i for i in mad_metric1_min.image.shape[-2:]]) mads = [mad_metric1_min, mad_metric1_max, mad_metric2_min, mad_metric2_max] titles = [ f"Minimize {metric1_name}", @@ -1460,17 +1436,11 @@ def plot_loss_all( """ if not torch.allclose(mad_metric1_min.image, mad_metric2_min.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric1_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if not torch.allclose(mad_metric1_min.image, mad_metric2_max.image): - raise ValueError( - "All four instances of MADCompetition must have same image!" - ) + raise ValueError("All four instances of MADCompetition must have same image!") if metric1_name is None: metric1_name = mad_metric1_min.optimized_metric.__name__ if metric2_name is None: diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index 2d262598..4f62dc79 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -145,9 +145,7 @@ def _initialize(self, initial_image: Tensor | None = None): if initial_image.size() != self.image.size(): raise ValueError("initial_image and image must be same size!") metamer = initial_image.clone().detach() - metamer = metamer.to( - dtype=self.image.dtype, device=self.image.device - ) + metamer = metamer.to(dtype=self.image.dtype, device=self.image.device) metamer.requires_grad_() self._metamer = metamer @@ -246,9 +244,7 @@ def objective_function( metamer_representation = self.model(self.metamer) if target_representation is None: target_representation = self.target_representation - loss = self.loss_function( - metamer_representation, target_representation - ) + loss = self.loss_function(metamer_representation, target_representation) range_penalty = optim.penalize_range(self.metamer, self.allowed_range) return loss + self.range_penalty_lambda * range_penalty @@ -273,9 +269,7 @@ def _optimizer_step(self, pbar: tqdm) -> Tensor: loss = self.optimizer.step(self._closure) self._losses.append(loss.item()) - grad_norm = torch.linalg.vector_norm( - self.metamer.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, dim=None) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler @@ -503,13 +497,8 @@ def _load( # these are always supposed to be on cpu, but may get copied over to # gpu on load (which can cause problems when resuming synthesis), so # fix that. - if ( - len(self._saved_metamer) - and self._saved_metamer[0].device.type != "cpu" - ): - self._saved_metamer = [ - met.to("cpu") for met in self._saved_metamer - ] + if len(self._saved_metamer) and self._saved_metamer[0].device.type != "cpu": + self._saved_metamer = [met.to("cpu") for met in self._saved_metamer] @property def model(self): @@ -774,10 +763,7 @@ def _optimizer_step( # has stopped declining and, if so, switch to the next scale. Then # we're checking if self.scales_loss is long enough to check # ctf_iters_to_check back. - if ( - len(self.scales) > 1 - and len(self.scales_loss) >= ctf_iters_to_check - ): + if len(self.scales) > 1 and len(self.scales_loss) >= ctf_iters_to_check: # Now we check whether loss has decreased less than # change_scale_criterion if (change_scale_criterion is None) or abs( @@ -789,13 +775,9 @@ def _optimizer_step( len(self.losses) - self.scales_timing[self.scales[0]][0] >= ctf_iters_to_check ): - self._scales_timing[self.scales[0]].append( - len(self.losses) - 1 - ) + self._scales_timing[self.scales[0]].append(len(self.losses) - 1) self._scales_finished.append(self._scales.pop(0)) - self._scales_timing[self.scales[0]].append( - len(self.losses) - ) + self._scales_timing[self.scales[0]].append(len(self.losses)) # reset optimizer's lr. for pg in self.optimizer.param_groups: pg["lr"] = pg["initial_lr"] @@ -806,9 +788,7 @@ def _optimizer_step( self._scales_loss.append(loss.item()) self._losses.append(overall_loss.item()) - grad_norm = torch.linalg.vector_norm( - self.metamer.grad.data, ord=2, dim=None - ) + grad_norm = torch.linalg.vector_norm(self.metamer.grad.data, ord=2, dim=None) self._gradient_norm.append(grad_norm.item()) # optionally step the scheduler @@ -977,9 +957,7 @@ def load( *then* load. """ - super()._load( - file_path, map_location, ["_coarse_to_fine"], **pickle_load_args - ) + super()._load(file_path, map_location, ["_coarse_to_fine"], **pickle_load_args) @property def coarse_to_fine(self): @@ -1155,9 +1133,7 @@ def _representation_error( """ if iteration is not None: metamer_rep = metamer.model( - metamer.saved_metamer[iteration].to( - metamer.target_representation.device - ) + metamer.saved_metamer[iteration].to(metamer.target_representation.device) ) else: metamer_rep = metamer.model(metamer.metamer, **kwargs) @@ -1312,9 +1288,7 @@ def _freedman_diaconis_bins(a): return ax -def _check_included_plots( - to_check: list[str] | dict[str, float], to_check_name: str -): +def _check_included_plots(to_check: list[str] | dict[str, float], to_check_name: str): """Check whether the user wanted us to create plots that we can't. Helper function for plot_synthesis_status and animate. @@ -1438,9 +1412,7 @@ def _setup_synthesis_fig( n_subplots += 1 width_ratios.append(plot_pixel_values_width) if "plot_pixel_values" not in axes_idx.keys(): - axes_idx["plot_pixel_values"] = data._find_min_int( - axes_idx.values() - ) + axes_idx["plot_pixel_values"] = data._find_min_int(axes_idx.values()) if fig is None: width_ratios = np.array(width_ratios) if figsize is None: @@ -1766,8 +1738,7 @@ def animate( """ if not metamer.store_progress: raise ValueError( - "synthesize() was run with store_progress=False," - " cannot animate!" + "synthesize() was run with store_progress=False, cannot animate!" ) if metamer.metamer.ndim not in [3, 4]: raise ValueError( @@ -1788,13 +1759,9 @@ def animate( ylim_rescale_interval = int(ylim.replace("rescale", "")) except ValueError: # then there's nothing we can convert to an int there - ylim_rescale_interval = int( - (metamer.saved_metamer.shape[0] - 1) // 10 - ) + ylim_rescale_interval = int((metamer.saved_metamer.shape[0] - 1) // 10) if ylim_rescale_interval == 0: - ylim_rescale_interval = int( - metamer.saved_metamer.shape[0] - 1 - ) + ylim_rescale_interval = int(metamer.saved_metamer.shape[0] - 1) ylim = None else: raise ValueError("Don't know how to handle ylim %s!" % ylim) @@ -1842,8 +1809,8 @@ def animate( if metamer.target_representation.ndimension() == 4: if "plot_representation_error" in included_plots: warnings.warn( - "Looks like representation is image-like, haven't fully thought out how" - " to best handle rescaling color ranges yet!" + "Looks like representation is image-like, haven't fully" + " thought out how to best handle rescaling color ranges yet!" ) # replace the bit of the title that specifies the range, # since we don't make any promises about that. we have to do diff --git a/src/plenoptic/synthesize/simple_metamer.py b/src/plenoptic/synthesize/simple_metamer.py index 0c80c13c..be040d89 100644 --- a/src/plenoptic/synthesize/simple_metamer.py +++ b/src/plenoptic/synthesize/simple_metamer.py @@ -68,9 +68,7 @@ def synthesize( """ if optimizer is None: if self.optimizer is None: - self.optimizer = torch.optim.Adam( - [self.metamer], lr=0.01, amsgrad=True - ) + self.optimizer = torch.optim.Adam([self.metamer], lr=0.01, amsgrad=True) else: self.optimizer = optimizer @@ -85,9 +83,7 @@ def closure(): # function. You could theoretically also just clamp metamer on # each step of the iteration, but the penalty in the loss seems # to work better in practice - loss = optim.mse( - metamer_representation, self.target_representation - ) + loss = optim.mse(metamer_representation, self.target_representation) loss = loss + 0.1 * optim.penalize_range(self.metamer, (0, 1)) self.losses.append(loss.item()) loss.backward(retain_graph=False) diff --git a/src/plenoptic/synthesize/synthesis.py b/src/plenoptic/synthesize/synthesis.py index 18846661..96c21869 100644 --- a/src/plenoptic/synthesize/synthesis.py +++ b/src/plenoptic/synthesize/synthesis.py @@ -103,9 +103,7 @@ def load( ``torch.load``, see that function's docstring for details. """ - tmp_dict = torch.load( - file_path, map_location=map_location, **pickle_load_args - ) + tmp_dict = torch.load(file_path, map_location=map_location, **pickle_load_args) if map_location is not None: device = map_location else: @@ -354,9 +352,7 @@ def _initialize_optimizer( ) else: if self.optimizer is not None: - raise TypeError( - "When resuming synthesis, optimizer arg must be None!" - ) + raise TypeError("When resuming synthesis, optimizer arg must be None!") params = optimizer.param_groups[0]["params"] if len(params) != 1 or not torch.equal(params[0], synth_attr): raise ValueError( @@ -413,10 +409,7 @@ def store_progress(self, store_progress: bool | int): if store_progress: if store_progress is True: store_progress = 1 - if ( - self.store_progress is not None - and store_progress != self.store_progress - ): + if self.store_progress is not None and store_progress != self.store_progress: # we require store_progress to be the same because otherwise the # subsampling relationship between attrs that are stored every # iteration (loss, gradient, etc) and those that are stored every diff --git a/src/plenoptic/tools/conv.py b/src/plenoptic/tools/conv.py index 783f7114..c4231d40 100644 --- a/src/plenoptic/tools/conv.py +++ b/src/plenoptic/tools/conv.py @@ -23,9 +23,7 @@ def correlate_downsample(image, filt, padding_mode="reflect"): assert isinstance(image, torch.Tensor) and isinstance(filt, torch.Tensor) assert image.ndim == 4 and filt.ndim == 2 n_channels = image.shape[1] - image_padded = same_padding( - image, kernel_size=filt.shape, pad_mode=padding_mode - ) + image_padded = same_padding(image, kernel_size=filt.shape, pad_mode=padding_mode) return F.conv2d( image_padded, filt.repeat(n_channels, 1, 1, 1), @@ -70,9 +68,7 @@ def upsample_convolve(image, odd, filt, padding_mode="reflect"): groups=n_channels, ) image_postpad = F.pad(image_upsample, tuple(pad % 2)) - return F.conv2d( - image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels - ) + return F.conv2d(image_postpad, filt.repeat(n_channels, 1, 1, 1), groups=n_channels) def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): @@ -92,9 +88,7 @@ def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor( - np.outer(f, f), dtype=torch.float32, device=x.device - ) + filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) if scale_filter: filt = filt / 2 for _ in range(n_scales): @@ -120,24 +114,15 @@ def upsample_blur(x, odd, filtname="binom5", scale_filter=True): """ f = pt.named_filter(filtname) - filt = torch.as_tensor( - np.outer(f, f), dtype=torch.float32, device=x.device - ) + filt = torch.as_tensor(np.outer(f, f), dtype=torch.float32, device=x.device) if scale_filter: filt = filt * 2 return upsample_convolve(x, odd, filt) -def _get_same_padding( - x: int, kernel_size: int, stride: int, dilation: int -) -> int: +def _get_same_padding(x: int, kernel_size: int, stride: int, dilation: int) -> int: """Helper function to determine integer padding for F.pad() given img and kernel""" - pad = ( - (math.ceil(x / stride) - 1) * stride - + (kernel_size - 1) * dilation - + 1 - - x - ) + pad = (math.ceil(x / stride) - 1) * stride + (kernel_size - 1) * dilation + 1 - x pad = max(pad, 0) return pad @@ -150,9 +135,7 @@ def same_padding( pad_mode: str = "circular", ) -> Tensor: """Pad a tensor so that 2D convolution will result in output with same dims.""" - assert ( - len(x.shape) > 2 - ), "Input must be tensor whose last dims are height x width" + assert len(x.shape) > 2, "Input must be tensor whose last dims are height x width" ih, iw = x.shape[-2:] pad_h = _get_same_padding(ih, kernel_size[0], stride[0], dilation[0]) pad_w = _get_same_padding(iw, kernel_size[1], stride[1], dilation[1]) diff --git a/src/plenoptic/tools/convergence.py b/src/plenoptic/tools/convergence.py index 5d359c39..4d418d67 100644 --- a/src/plenoptic/tools/convergence.py +++ b/src/plenoptic/tools/convergence.py @@ -63,17 +63,12 @@ def loss_convergence( """ if len(synth.losses) > stop_iters_to_check: - if ( - abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) - < stop_criterion - ): + if abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) < stop_criterion: return True return False -def coarse_to_fine_enough( - synth: "Metamer", i: int, ctf_iters_to_check: int -) -> bool: +def coarse_to_fine_enough(synth: "Metamer", i: int, ctf_iters_to_check: int) -> bool: r"""Check whether we've synthesized all scales and done so for at least ctf_iters_to_check iterations This is meant to be paired with another convergence check, such as ``loss_convergence``. @@ -139,8 +134,6 @@ def pixel_change_convergence( """ if len(synth.pixel_change_norm) > stop_iters_to_check: - if ( - synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion - ).all(): + if (synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion).all(): return True return False diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index 9afda3f0..b4ea6f65 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -27,9 +27,7 @@ np.complex128: torch.complex128, } -TORCH_TO_NUMPY_TYPES = { - value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items() -} +TORCH_TO_NUMPY_TYPES = {value: key for (key, value) in NUMPY_TO_TORCH_TYPES.items()} def to_numpy(x: Tensor | np.ndarray, squeeze: bool = False) -> np.ndarray: @@ -147,7 +145,7 @@ def load_images(paths: str | list[str], as_gray: bool = True) -> Tensor: if as_gray: if images.ndimension() != 3: raise ValueError( - "For loading in images as grayscale, this should be a 3d tensor!" + "For loading in images as grayscale, this should be a 3d" " tensor!" ) images = images.unsqueeze(1) else: @@ -161,7 +159,7 @@ def load_images(paths: str | list[str], as_gray: bool = True) -> Tensor: images = images.unsqueeze(1) if images.ndimension() != 4: raise ValueError( - "Somehow ended up with other than 4 dimensions! Not sure how we got here" + "Somehow ended up with other than 4 dimensions! Not sure how we" " got here" ) return images @@ -197,9 +195,7 @@ def convert_float_to_int(im: np.ndarray, dtype=np.uint8) -> np.ndarray: return (im * np.iinfo(dtype).max).astype(dtype) -def make_synthetic_stimuli( - size: int = 256, requires_grad: bool = True -) -> Tensor: +def make_synthetic_stimuli(size: int = 256, requires_grad: bool = True) -> Tensor: r"""Make a set of basic stimuli, useful for developping and debugging models Parameters @@ -232,9 +228,7 @@ def make_synthetic_stimuli( size // 2 - 1 : size // 2 + 1, ] = 1 - curv_edge = synthetic_images.disk( - size=size, radius=size / 1.2, origin=(size, size) - ) + curv_edge = synthetic_images.disk(size=size, radius=size / 1.2, origin=(size, size)) sine_grating = synthetic_images.sine(size) * synthetic_images.gaussian( size, covariance=size diff --git a/src/plenoptic/tools/display.py b/src/plenoptic/tools/display.py index 18e56e62..35f5b60c 100644 --- a/src/plenoptic/tools/display.py +++ b/src/plenoptic/tools/display.py @@ -138,8 +138,7 @@ def imshow( if as_rgb: if im.shape[1] not in [3, 4]: raise Exception( - "If as_rgb is True, then channel must have 3 " - "or 4 elements!" + "If as_rgb is True, then channel must have 3 " "or 4 elements!" ) im = im.transpose(0, 2, 3, 1) # want to insert a fake "channel" dimension here, so our putting it @@ -147,8 +146,9 @@ def imshow( im = im.reshape((im.shape[0], 1, *im.shape[1:])) elif im.shape[1] > 1 and im.shape[0] > 1: raise Exception( - "Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting" + "Don't know how to plot images with more than one channel and" + " batch! Use batch_idx / channel_idx to choose a subset for" + " plotting" ) # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate image. @@ -346,8 +346,7 @@ def animshow( if as_rgb: if vid.shape[1] not in [3, 4]: raise Exception( - "If as_rgb is True, then channel must have 3 " - "or 4 elements!" + "If as_rgb is True, then channel must have 3 " "or 4 elements!" ) vid = vid.transpose(0, 2, 3, 4, 1) # want to insert a fake "channel" dimension here, so our putting it @@ -355,8 +354,9 @@ def animshow( vid = vid.reshape((vid.shape[0], 1, *vid.shape[1:])) elif vid.shape[1] > 1 and vid.shape[0] > 1: raise Exception( - "Don't know how to plot images with more than one channel and batch!" - " Use batch_idx / channel_idx to choose a subset for plotting" + "Don't know how to plot images with more than one channel and" + " batch! Use batch_idx / channel_idx to choose a subset for" + " plotting" ) # by iterating through it twice, we make sure to peel apart the batch # and channel dimensions so that they each show up as a separate video. @@ -690,9 +690,7 @@ def clean_stem_plot(data, ax=None, title="", ylim=None, xvals=None, **kwargs): ax = plt.gca() if xvals is not None: basefmt = " " - ax.hlines( - len(xvals[0]) * [0], xvals[0], xvals[1], colors="C3", zorder=10 - ) + ax.hlines(len(xvals[0]) * [0], xvals[0], xvals[1], colors="C3", zorder=10) else: # this is the default basefmt value basefmt = None @@ -752,11 +750,7 @@ def _get_artists_from_axes(axes, data): " with keys corresponding to the labels of the artists" " to update to resolve this." ) - elif ( - data_check == 2 - and data.ndim > 2 - and data.shape[-3] != len(artists) - ): + elif data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): raise Exception( f"data has {data.shape[-3]} things to plot, but " f"your axis contains {len(artists)} plotting artists, " @@ -797,11 +791,7 @@ def _get_artists_from_axes(axes, data): f"you passed {len(axes)} axes , so unsure how " "to continue!" ) - if ( - data_check == 2 - and data.ndim > 2 - and data.shape[-3] != len(artists) - ): + if data_check == 2 and data.ndim > 2 and data.shape[-3] != len(artists): raise Exception( f"data has {data.shape[-3]} things to plot, but " f"you passed {len(axes)} axes , so unsure how " @@ -903,17 +893,14 @@ def update_plot(axes, data, model=None, batch_idx=0): # instead, as suggested # https://stackoverflow.com/questions/43629270/how-to-get-single-value-from-dict-with-single-entry try: - if ( - next(iter(ax_artists.values())).get_array().data.ndim - > 1 - ): + if next(iter(ax_artists.values())).get_array().data.ndim > 1: # then this is an RGBA image data_dict = {"00": data} except Exception as e: raise Exception( - "Thought this was an RGB(A) image based on the number of " - "artists and data shape, but something is off! " - f"Original exception: {e}" + "Thought this was an RGB(A) image based on the number" + " of artists and data shape, but something is off!" + f" Original exception: {e}" ) else: for i, d in enumerate(data.unbind(1)): @@ -1064,9 +1051,7 @@ def plot_representation( else: warnings.warn("data has keys, so we're ignoring title!") # want to make sure the axis we're taking over is basically invisible. - ax = clean_up_axes( - ax, False, ["top", "right", "bottom", "left"], ["x", "y"] - ) + ax = clean_up_axes(ax, False, ["top", "right", "bottom", "left"], ["x", "y"]) axes = [] if len(list(data.values())[0].shape) == 3: # then this is 'vector-like' @@ -1106,9 +1091,7 @@ def plot_representation( # ylim at all ylim = False else: - raise Exception( - "Don't know what to do with data of shape" f" {data.shape}" - ) + raise Exception(f"Don't know what to do with data of shape {data.shape}") if ylim is None: if isinstance(data, dict): data = torch.cat(list(data.values()), dim=2) diff --git a/src/plenoptic/tools/external.py b/src/plenoptic/tools/external.py index 3792b65c..545da3d0 100644 --- a/src/plenoptic/tools/external.py +++ b/src/plenoptic/tools/external.py @@ -145,15 +145,11 @@ def plot_MAD_results( [zoom * i + 1 for i in images.shape[-2:]], vert_pct=0.75, ) - for img, ax, t, vr, s in zip( - images, fig.axes, titles, vrange_list, super_titles - ): + for img, ax, t, vr, s in zip(images, fig.axes, titles, vrange_list, super_titles): # these are the blanks if (img == 1).all(): continue - pt.imshow( - img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs - ) + pt.imshow(img, ax=ax, title=t, zoom=zoom, vrange=vr, cmap=cmap, **kwargs) if s is not None: font = { k.replace("_", ""): v diff --git a/src/plenoptic/tools/signal.py b/src/plenoptic/tools/signal.py index 7d91b135..4c04c721 100644 --- a/src/plenoptic/tools/signal.py +++ b/src/plenoptic/tools/signal.py @@ -4,9 +4,7 @@ from pyrtools.pyramids.steer import steer_to_harmonics_mtx -def minimum( - x: Tensor, dim: list[int] | None = None, keepdim: bool = False -) -> Tensor: +def minimum(x: Tensor, dim: list[int] | None = None, keepdim: bool = False) -> Tensor: r"""Compute minimum in torch over any axis or combination of axes in tensor. Parameters @@ -32,9 +30,7 @@ def minimum( return min_x -def maximum( - x: Tensor, dim: list[int] | None = None, keepdim: bool = False -) -> Tensor: +def maximum(x: Tensor, dim: list[int] | None = None, keepdim: bool = False) -> Tensor: r"""Compute maximum in torch over any dim or combination of axes in tensor. Parameters @@ -331,9 +327,7 @@ def make_disk( elif r < inner_radius: mask[i][j] = 1 else: - radial_decay = (r - inner_radius) / ( - outer_radius - inner_radius - ) + radial_decay = (r - inner_radius) / (outer_radius - inner_radius) mask[i][j] = (1 + np.cos(np.pi * radial_decay)) / 2 return mask @@ -595,20 +589,14 @@ def shrink(x: Tensor, factor: int) -> Tensor: my = im_y / factor if int(mx) != mx: - raise ValueError( - f"x.shape[-1]/factor must be an integer but got {mx} instead!" - ) + raise ValueError(f"x.shape[-1]/factor must be an integer but got {mx} instead!") if int(my) != my: - raise ValueError( - f"x.shape[-2]/factor must be an integer but got {my} instead!" - ) + raise ValueError(f"x.shape[-2]/factor must be an integer but got {my} instead!") mx = int(mx) my = int(my) - fourier = ( - 1 / factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) - ) + fourier = 1 / factor**2 * torch.fft.fftshift(torch.fft.fft2(x), dim=(-2, -1)) fourier_small = torch.zeros( *x.shape[:-2], my, diff --git a/src/plenoptic/tools/stats.py b/src/plenoptic/tools/stats.py index f862ea0d..66ebcf92 100644 --- a/src/plenoptic/tools/stats.py +++ b/src/plenoptic/tools/stats.py @@ -70,9 +70,7 @@ def skew( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow( - 1.5 - ) + return torch.mean((x - mean).pow(3), dim=dim, keepdim=keepdim) / var.pow(1.5) def kurtosis( @@ -114,6 +112,4 @@ def kurtosis( mean = torch.mean(x, dim=dim, keepdim=True) if var is None: var = variance(x, mean=mean, dim=dim, keepdim=keepdim) - return torch.mean( - torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim - ) / var.pow(2) + return torch.mean(torch.abs(x - mean).pow(4), dim=dim, keepdim=keepdim) / var.pow(2) diff --git a/src/plenoptic/tools/straightness.py b/src/plenoptic/tools/straightness.py index 3d848ed4..02bf8dee 100644 --- a/src/plenoptic/tools/straightness.py +++ b/src/plenoptic/tools/straightness.py @@ -26,7 +26,8 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: validate_input(stop, no_batch=True) if start.shape != stop.shape: raise ValueError( - f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" + f"start and stop must be same shape, but got {start.shape} and" + f" {stop.shape}!" ) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") @@ -35,9 +36,7 @@ def make_straight_line(start: Tensor, stop: Tensor, n_steps: int) -> Tensor: device = start.device start = start.reshape(1, -1) stop = stop.reshape(1, -1) - tt = torch.linspace(0, 1, steps=n_steps + 1, device=device).view( - n_steps + 1, 1 - ) + tt = torch.linspace(0, 1, steps=n_steps + 1, device=device).view(n_steps + 1, 1) straight = (1 - tt) * start + tt * stop return straight.reshape((n_steps + 1, *shape)) @@ -74,7 +73,8 @@ def sample_brownian_bridge( validate_input(stop, no_batch=True) if start.shape != stop.shape: raise ValueError( - f"start and stop must be same shape, but got {start.shape} and {stop.shape}!" + f"start and stop must be same shape, but got {start.shape} and" + f" {stop.shape}!" ) if n_steps <= 0: raise ValueError(f"n_steps must be positive, but got {n_steps}") @@ -138,9 +138,7 @@ def deviation_from_line( y_centered = y - y0 dist_along_line = y_centered @ line[0] projection = dist_along_line.view(T, 1) * line - dist_from_line = torch.linalg.vector_norm( - y_centered - projection, dim=1, ord=2 - ) + dist_from_line = torch.linalg.vector_norm(y_centered - projection, dim=1, ord=2) if normalize: dist_along_line /= line_length diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index 78a96b87..71fffe8d 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -182,8 +182,7 @@ def validate_model( allowed_dtypes = [torch.float64, torch.complex128] else: raise TypeError( - "Only float or complex dtypes are allowed but got type" - f" {image_dtype}" + "Only float or complex dtypes are allowed but got type" f" {image_dtype}" ) if model(test_img).dtype not in allowed_dtypes: raise TypeError("model changes precision of input, don't do that!") @@ -300,9 +299,7 @@ def validate_metric( try: same_val = metric(test_img, test_img).item() except TypeError: - raise TypeError( - "metric should be callable and accept two 4d tensors as input" - ) + raise TypeError("metric should be callable and accept two 4d tensors as input") # as of torch 2.0.0, this is a RuntimeError (a Tensor with X elements # cannot be converted to Scalar); previously it was a ValueError (only one # element tensors can be converted to Python scalars) diff --git a/tests/conftest.py b/tests/conftest.py index c96f3166..1d659a00 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -8,14 +8,17 @@ DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") DTYPE = torch.float32 -IMG_DIR = po.data.fetch_data('test_images.tar.gz') +IMG_DIR = po.data.fetch_data("test_images.tar.gz") torch.set_num_threads(1) # torch uses all avail threads which will slow tests torch.manual_seed(0) if torch.cuda.is_available(): torch.cuda.manual_seed(0) + + class ColorModel(torch.nn.Module): """Simple model that takes color image as input and outputs 2d conv.""" + def __init__(self): super().__init__() self.conv = torch.nn.Conv2d(3, 4, 3, 1) @@ -24,48 +27,56 @@ def forward(self, x): return self.conv(x) -@pytest.fixture(scope='package') +@pytest.fixture(scope="package") def curie_img(): - return po.load_images(IMG_DIR / "256" / 'curie.pgm').to(DEVICE) + return po.load_images(IMG_DIR / "256" / "curie.pgm").to(DEVICE) -@pytest.fixture(scope='package') +@pytest.fixture(scope="package") def einstein_img(): - return po.load_images(IMG_DIR / "256" / 'curie.pgm').to(DEVICE) + return po.load_images(IMG_DIR / "256" / "curie.pgm").to(DEVICE) + -@pytest.fixture(scope='package') +@pytest.fixture(scope="package") def einstein_small_seq(einstein_img_small): return po.tools.translation_sequence(einstein_img_small, 5) -@pytest.fixture(scope='package') + +@pytest.fixture(scope="package") def einstein_img_small(einstein_img): return po.tools.center_crop(einstein_img, 64).to(DEVICE) -@pytest.fixture(scope='package') + +@pytest.fixture(scope="package") def color_img(): - img = po.load_images(IMG_DIR / "256" / 'color_wheel.jpg', - as_gray=False).to(DEVICE) + img = po.load_images( + IMG_DIR / "256" / "color_wheel.jpg", as_gray=False + ).to(DEVICE) return img[..., :256, :256] -@pytest.fixture(scope='package') +@pytest.fixture(scope="package") def basic_stim(): return po.tools.make_synthetic_stimuli().to(DEVICE) def get_model(name): - if name == 'SPyr': + if name == "SPyr": # in order to get a tensor back, need to wrap steerable pyramid so that # we can call convert_pyr_to_tensor in the forward call. in order for # that to work, downsample must be False class spyr(po.simul.SteerablePyramidFreq): def __init__(self, *args, **kwargs): - kwargs.pop('downsample', None) + kwargs.pop("downsample", None) super().__init__(*args, downsample=False, **kwargs) + def forward(self, *args, **kwargs): coeffs = super().forward(*args, **kwargs) - pyr_tensor, _ = po.simul.SteerablePyramidFreq.convert_pyr_to_tensor(coeffs) + pyr_tensor, _ = ( + po.simul.SteerablePyramidFreq.convert_pyr_to_tensor(coeffs) + ) return pyr_tensor + # setting height=1 and # order=1 limits the size return spyr((256, 256), height=1, order=1).to(DEVICE) elif name == "LPyr": @@ -74,73 +85,84 @@ def forward(self, *args, **kwargs): class lpyr(po.simul.LaplacianPyramid): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) + def forward(self, *args, **kwargs): coeffs = super().forward(*args, **kwargs) return torch.cat([c.flatten(-2) for c in coeffs], -1) + return lpyr().to(DEVICE) - elif name == 'Identity': + elif name == "Identity": return po.simul.models.naive.Identity().to(DEVICE) - elif name == 'NLP': + elif name == "NLP": return po.metric.NLP().to(DEVICE) - elif name == 'nlpd': + elif name == "nlpd": return po.metric.nlpd - elif name == 'mse': + elif name == "mse": return po.metric.naive.mse - elif name == 'ColorModel': + elif name == "ColorModel": model = ColorModel().to(DEVICE) po.tools.remove_grad(model) return model # naive models - elif name in ['Identity', "naive.Identity"]: + elif name in ["Identity", "naive.Identity"]: return po.simul.Identity().to(DEVICE) - elif name == 'naive.CenterSurround': + elif name == "naive.CenterSurround": return po.simul.CenterSurround((31, 31)).to(DEVICE) - elif name == 'naive.Gaussian': + elif name == "naive.Gaussian": return po.simul.Gaussian((31, 31)).to(DEVICE) - elif name == 'naive.Linear': + elif name == "naive.Linear": return po.simul.Linear((31, 31)).to(DEVICE) # FrontEnd models: - elif name == 'frontend.LinearNonlinear': + elif name == "frontend.LinearNonlinear": return po.simul.LinearNonlinear((31, 31)).to(DEVICE) - elif name == 'frontend.LinearNonlinear.nograd': + elif name == "frontend.LinearNonlinear.nograd": model = po.simul.LinearNonlinear((31, 31)).to(DEVICE) po.tools.remove_grad(model) return model - elif name == 'frontend.LuminanceGainControl': + elif name == "frontend.LuminanceGainControl": return po.simul.LuminanceGainControl((31, 31)).to(DEVICE) - elif name == 'frontend.LuminanceContrastGainControl': + elif name == "frontend.LuminanceContrastGainControl": return po.simul.LuminanceContrastGainControl((31, 31)).to(DEVICE) - elif name == 'frontend.OnOff': - return po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to(DEVICE) - elif name == 'frontend.OnOff.nograd': - mdl = po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to(DEVICE) + elif name == "frontend.OnOff": + return po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to( + DEVICE + ) + elif name == "frontend.OnOff.nograd": + mdl = po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to( + DEVICE + ) po.tools.remove_grad(mdl) return mdl - elif name == 'VideoModel': + elif name == "VideoModel": # super simple model that combines across the batch dimension, as a # model with a temporal component would do class VideoModel(po.simul.OnOff): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) + def forward(self, *args, **kwargs): # this will do on/off on each batch separately rep = super().forward(*args, **kwargs) return rep.mean(0) - model = VideoModel((31, 31), pretrained=True, cache_filt=True).to(DEVICE) + + model = VideoModel((31, 31), pretrained=True, cache_filt=True).to( + DEVICE + ) po.tools.remove_grad(model) return model elif name == "PortillaSimoncelli": return po.simul.PortillaSimoncelli((256, 256)) -@pytest.fixture(scope='package') +@pytest.fixture(scope="package") def model(request): return get_model(request.param) + # this is the same as model() fixture above, in order to get two independent # fixtures. -@pytest.fixture(scope='package') +@pytest.fixture(scope="package") def model2(request): return get_model(request.param) diff --git a/tests/test_data_get.py b/tests/test_data_get.py index 1a6b5ff3..6b6e0fb7 100644 --- a/tests/test_data_get.py +++ b/tests/test_data_get.py @@ -12,9 +12,21 @@ "item_name, expectation", [ ("color_wheel", does_not_raise()), - ("xyz", pytest.raises(AssertionError, match="Expected exactly one file for xyz, but found 2")), - ("xyzw", pytest.raises(AssertionError, match=f"Expected exactly one file for xyzw, but found 0")) - ] + ( + "xyz", + pytest.raises( + AssertionError, + match="Expected exactly one file for xyz, but found 2", + ), + ), + ( + "xyzw", + pytest.raises( + AssertionError, + match=f"Expected exactly one file for xyzw, but found 0", + ), + ), + ], ) def test_data_get_path(item_name, expectation): """Test the retrieval of file paths with varying expectations.""" @@ -43,9 +55,7 @@ def test_data_get_path_type(item_name): assert isinstance(po.data.data_utils.get_path(item_name), Traversable) -@pytest.mark.parametrize( - "item_name", ["color_wheel", "parrot", "curie"] -) +@pytest.mark.parametrize("item_name", ["color_wheel", "parrot", "curie"]) def test_data_get_type(item_name): """Test that the retrieved data is of type Tensor.""" img = po.data.data_utils.get(item_name) @@ -57,8 +67,8 @@ def test_data_get_type(item_name): [ ("color_wheel", (1, 3, 600, 600)), ("parrot", (1, 3, 254, 266)), - ("curie", (1, 1, 256, 256)) - ] + ("curie", (1, 1, 256, 256)), + ], ) def test_data_get_shape(item_name, img_shape): """Check if the shape of the retrieved image matches the expected dimensions.""" @@ -66,8 +76,11 @@ def test_data_get_shape(item_name, img_shape): assert all(shp == img_shape[i] for i, shp in enumerate(img.shape)) -@pytest.mark.parametrize("item_name", ["color_wheel", "parrot", "curie", - 'einstein', 'reptile_skin']) +@pytest.mark.parametrize( + "item_name", ["color_wheel", "parrot", "curie", "einstein", "reptile_skin"] +) def test_data_module(item_name): """Test that data module works.""" - assert (eval(f"po.data.{item_name}()") == po.data.data_utils.get(item_name)).all() + assert ( + eval(f"po.data.{item_name}()") == po.data.data_utils.get(item_name) + ).all() diff --git a/tests/test_display.py b/tests/test_display.py index 92adaba4..d438283e 100644 --- a/tests/test_display.py +++ b/tests/test_display.py @@ -1,9 +1,10 @@ # necessary to avoid issues with animate: # https://github.com/matplotlib/matplotlib/issues/10287/ import matplotlib as mpl + # use the html backend, so we don't need to have ffmpeg -mpl.rcParams['animation.writer'] = 'html' -mpl.use('agg') +mpl.rcParams["animation.writer"] = "html" +mpl.use("agg") import pytest import matplotlib.pyplot as plt import plenoptic as po @@ -20,52 +21,58 @@ def test_update_plot_line(self): y1 = np.random.rand(*x.shape) y2 = np.random.rand(*x.shape) fig, ax = plt.subplots(1, 1) - ax.plot(x, y1, '-o', label='hi') + ax.plot(x, y1, "-o", label="hi") po.tools.update_plot(ax, torch.as_tensor(y2).reshape(1, 1, len(x))) assert len(ax.lines) == 1, "Too many lines were plotted!" _, ax_y = ax.lines[0].get_data() if not np.allclose(ax_y, y2): raise Exception("Didn't update line correctly!") - plt.close('all') + plt.close("all") - @pytest.mark.parametrize('how', ['dict', 'tensor']) + @pytest.mark.parametrize("how", ["dict", "tensor"]) def test_update_plot_line_multi_axes(self, how): x = np.linspace(0, 100) y1 = np.random.rand(*x.shape) y2 = np.random.rand(2, *y1.shape) - if how == 'tensor': + if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, *y1.shape) - elif how == 'dict': - y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) for i in range(2)} + elif how == "dict": + y2 = { + i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) + for i in range(2) + } fig, axes = plt.subplots(1, 2) for ax in axes: - ax.plot(x, y1, '-o', label='hi') + ax.plot(x, y1, "-o", label="hi") po.tools.update_plot(axes, y2) for i, ax in enumerate(axes): assert len(ax.lines) == 1, "Too many lines were plotted!" _, ax_y = ax.lines[0].get_data() - if how == 'tensor': + if how == "tensor": y_check = y2[0, i] else: y_check = y2[i] if not np.allclose(ax_y, y_check): raise Exception("Didn't update line correctly!") - plt.close('all') + plt.close("all") - @pytest.mark.parametrize('how', ['dict-single', 'dict-multi', 'tensor']) + @pytest.mark.parametrize("how", ["dict-single", "dict-multi", "tensor"]) def test_update_plot_line_multi_channel(self, how): - if how == 'dict-single': + if how == "dict-single": n_data = 1 else: n_data = 2 x = np.linspace(0, 100) y1 = np.random.rand(2, *x.shape) y2 = np.random.rand(n_data, *x.shape) - if how == 'tensor': + if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, len(x)) - elif how == 'dict-multi': - y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) for i in range(2)} - elif how == 'dict-single': + elif how == "dict-multi": + y2 = { + i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) + for i in range(2) + } + elif how == "dict-single": y2 = {0: torch.as_tensor(y2[0]).reshape(1, 1, len(x))} fig, ax = plt.subplots(1, 1) for i in range(2): @@ -74,84 +81,92 @@ def test_update_plot_line_multi_channel(self, how): assert len(ax.lines) == 2, "Incorrect number of lines were plotted!" for i in range(2): _, ax_y = ax.lines[i].get_data() - if how == 'tensor': + if how == "tensor": y_check = y2[0, i] - elif how == 'dict-multi': + elif how == "dict-multi": y_check = y2[i] - elif how == 'dict-single': + elif how == "dict-single": y_check = {0: y2[0], 1: y1[1]}[i] if not np.allclose(ax_y, y_check): raise Exception("Didn't update line correctly!") - plt.close('all') + plt.close("all") def test_update_plot_stem(self): x = np.linspace(0, 100) y1 = np.random.rand(*x.shape) y2 = np.random.rand(*x.shape) fig, ax = plt.subplots(1, 1) - ax.stem(x, y1, '-o', label='hi') + ax.stem(x, y1, "-o", label="hi") po.tools.update_plot(ax, torch.as_tensor(y2).reshape(1, 1, len(x))) assert len(ax.containers) == 1, "Too many stems were plotted!" ax_y = ax.containers[0].markerline.get_ydata() if not np.allclose(ax_y, y2): raise Exception("Didn't update stems correctly!") - plt.close('all') + plt.close("all") - @pytest.mark.parametrize('how', ['dict', 'tensor']) + @pytest.mark.parametrize("how", ["dict", "tensor"]) def test_update_plot_stem_multi_axes(self, how): x = np.linspace(0, 100) y1 = np.random.rand(*x.shape) y2 = np.random.rand(2, *y1.shape) - if how == 'tensor': + if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, *y1.shape) - elif how == 'dict': - y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) for i in range(2)} + elif how == "dict": + y2 = { + i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) + for i in range(2) + } fig, axes = plt.subplots(1, 2) for ax in axes: - ax.stem(x, y1, label='hi') + ax.stem(x, y1, label="hi") po.tools.update_plot(axes, y2) for i, ax in enumerate(axes): assert len(ax.containers) == 1, "Too many stems were plotted!" ax_y = ax.containers[0].markerline.get_ydata() - if how == 'tensor': + if how == "tensor": y_check = y2[0, i] else: y_check = y2[i] if not np.allclose(ax_y, y_check): raise Exception("Didn't update stem correctly!") - plt.close('all') + plt.close("all") - @pytest.mark.parametrize('how', ['dict-single', 'dict-multi', 'tensor']) + @pytest.mark.parametrize("how", ["dict-single", "dict-multi", "tensor"]) def test_update_plot_stem_multi_channel(self, how): - if how == 'dict-single': + if how == "dict-single": n_data = 1 else: n_data = 2 x = np.linspace(0, 100) y1 = np.random.rand(2, *x.shape) y2 = np.random.rand(n_data, *x.shape) - if how == 'tensor': + if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, len(x)) - elif how == 'dict-multi': - y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) for i in range(2)} - elif how == 'dict-single': + elif how == "dict-multi": + y2 = { + i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) + for i in range(2) + } + elif how == "dict-single": y2 = {0: torch.as_tensor(y2[0]).reshape(1, 1, len(x))} fig, ax = plt.subplots(1, 1) for i in range(2): ax.stem(x, y1[i], label=str(i)) po.tools.update_plot(ax, y2) - assert len(ax.containers) == 2, "Incorrect number of stems were plotted!" + assert ( + len(ax.containers) == 2 + ), "Incorrect number of stems were plotted!" for i in range(2): ax_y = ax.containers[i].markerline.get_ydata() - if how == 'tensor': + if how == "tensor": y_check = y2[0, i] - elif how == 'dict-multi': + elif how == "dict-multi": y_check = y2[i] - elif how == 'dict-single': + elif how == "dict-single": y_check = {0: y2[0], 1: y1[1]}[i] if not np.allclose(ax_y, y_check): raise Exception("Didn't update stem correctly!") - plt.close('all') + plt.close("all") def test_update_plot_image(self): y1 = np.random.rand(1, 1, 100, 100) @@ -163,28 +178,31 @@ def test_update_plot_image(self): ax_y = ax.images[0].get_array().data if not np.allclose(ax_y, y2): raise Exception("Didn't update image correctly!") - plt.close('all') + plt.close("all") - @pytest.mark.parametrize('how', ['dict', 'tensor']) + @pytest.mark.parametrize("how", ["dict", "tensor"]) def test_update_plot_image_multi_axes(self, how): y1 = np.random.rand(1, 2, 100, 100) y2 = np.random.rand(1, 2, 100, 100) - if how == 'tensor': + if how == "tensor": y2 = torch.as_tensor(y2) - elif how == 'dict': - y2 = {i: torch.as_tensor(y2[0, i]).reshape(1, 1, 100, 100) for i in range(2)} + elif how == "dict": + y2 = { + i: torch.as_tensor(y2[0, i]).reshape(1, 1, 100, 100) + for i in range(2) + } fig = pt.imshow([y for y in y1.squeeze()]) po.tools.update_plot(fig.axes, y2) for i, ax in enumerate(fig.axes): assert len(ax.images) == 1, "Too many lines were plotted!" ax_y = ax.images[0].get_array().data - if how == 'tensor': + if how == "tensor": y_check = y2[0, i] else: y_check = y2[i] if not np.allclose(ax_y, y_check): raise Exception("Didn't update image correctly!") - plt.close('all') + plt.close("all") def test_update_plot_scatter(self): x1 = np.random.rand(100) @@ -193,24 +211,35 @@ def test_update_plot_scatter(self): y2 = np.random.rand(*x2.shape) fig, ax = plt.subplots(1, 1) ax.scatter(x1, y1) - data = torch.stack((torch.as_tensor(x2), torch.as_tensor(y2)), -1).reshape(1, 1, len(x2), 2) + data = torch.stack( + (torch.as_tensor(x2), torch.as_tensor(y2)), -1 + ).reshape(1, 1, len(x2), 2) po.tools.update_plot(ax, data) assert len(ax.collections) == 1, "Too many scatter plots created" ax_data = ax.collections[0].get_offsets() if not np.allclose(ax_data, data): - raise Exception("Didn't update points of the scatter plot correctly!") - plt.close('all') + raise Exception( + "Didn't update points of the scatter plot correctly!" + ) + plt.close("all") - @pytest.mark.parametrize('how', ['dict', 'tensor']) + @pytest.mark.parametrize("how", ["dict", "tensor"]) def test_update_plot_scatter_multi_axes(self, how): x1 = np.random.rand(100) x2 = np.random.rand(2, 100) y1 = np.random.rand(*x1.shape) y2 = np.random.rand(2, *y1.shape) - if how == 'tensor': - data = torch.stack((torch.as_tensor(x2), torch.as_tensor(y2)), -1).reshape(1, 2, len(x1), 2) - elif how == 'dict': - data = {i: torch.stack((torch.as_tensor(x2[i]), torch.as_tensor(y2[i])), -1).reshape(1, 1, len(x1), 2) for i in range(2)} + if how == "tensor": + data = torch.stack( + (torch.as_tensor(x2), torch.as_tensor(y2)), -1 + ).reshape(1, 2, len(x1), 2) + elif how == "dict": + data = { + i: torch.stack( + (torch.as_tensor(x2[i]), torch.as_tensor(y2[i])), -1 + ).reshape(1, 1, len(x1), 2) + for i in range(2) + } fig, axes = plt.subplots(1, 2) for ax in axes: ax.scatter(x1, y1) @@ -218,17 +247,19 @@ def test_update_plot_scatter_multi_axes(self, how): for i, ax in enumerate(axes): assert len(ax.collections) == 1, "Too many scatter plots created" ax_data = ax.collections[0].get_offsets() - if how == 'tensor': + if how == "tensor": data_check = data[0, i] else: data_check = data[i] if not np.allclose(ax_data, data_check): - raise Exception("Didn't update points of the scatter plot correctly!") - plt.close('all') + raise Exception( + "Didn't update points of the scatter plot correctly!" + ) + plt.close("all") - @pytest.mark.parametrize('how', ['dict-single', 'dict-multi', 'tensor']) + @pytest.mark.parametrize("how", ["dict-single", "dict-multi", "tensor"]) def test_update_plot_scatter_multi_channel(self, how): - if how == 'dict-single': + if how == "dict-single": n_data = 1 else: n_data = 2 @@ -236,36 +267,56 @@ def test_update_plot_scatter_multi_channel(self, how): x2 = np.random.rand(n_data, 100) y1 = np.random.rand(*x1.shape) y2 = np.random.rand(*x2.shape) - if how == 'tensor': - data = torch.stack((torch.as_tensor(x2), torch.as_tensor(y2)), -1).reshape(1, 2, x1.shape[-1], 2) - elif how == 'dict-multi': - data = {i: torch.stack((torch.as_tensor(x2[i]), torch.as_tensor(y2[i])), -1).reshape(1, 1, x1.shape[-1], 2) for i in range(2)} - elif how == 'dict-single': - data = {0: torch.stack((torch.as_tensor(x2[0]), torch.as_tensor(y2[0])), -1).reshape(1, 1, x1.shape[-1], 2)} + if how == "tensor": + data = torch.stack( + (torch.as_tensor(x2), torch.as_tensor(y2)), -1 + ).reshape(1, 2, x1.shape[-1], 2) + elif how == "dict-multi": + data = { + i: torch.stack( + (torch.as_tensor(x2[i]), torch.as_tensor(y2[i])), -1 + ).reshape(1, 1, x1.shape[-1], 2) + for i in range(2) + } + elif how == "dict-single": + data = { + 0: torch.stack( + (torch.as_tensor(x2[0]), torch.as_tensor(y2[0])), -1 + ).reshape(1, 1, x1.shape[-1], 2) + } fig, ax = plt.subplots(1, 1) for i in range(2): ax.scatter(x1[i], y1[i], label=i) po.tools.update_plot(ax, data) - assert len(ax.collections) == 2, "Incorrect number of scatter plots created" + assert ( + len(ax.collections) == 2 + ), "Incorrect number of scatter plots created" for i in range(2): ax_data = ax.collections[i].get_offsets() - if how == 'tensor': + if how == "tensor": data_check = data[0, i] - elif how == 'dict-multi': + elif how == "dict-multi": data_check = data[i] - elif how == 'dict-single': - tmp = torch.stack((torch.as_tensor(x1), torch.as_tensor(y1)), -1) + elif how == "dict-single": + tmp = torch.stack( + (torch.as_tensor(x1), torch.as_tensor(y1)), -1 + ) data_check = {0: data[0], 1: tmp[1]}[i] if not np.allclose(ax_data, data_check): - raise Exception("Didn't update points of the scatter plot correctly!") + raise Exception( + "Didn't update points of the scatter plot correctly!" + ) def test_update_plot_mixed_multi_axes(self): x1 = np.linspace(0, 1, 100) x2 = np.random.rand(2, 100) y1 = np.random.rand(*x1.shape) y2 = np.random.rand(*x2.shape) - data = {0: torch.stack((torch.as_tensor(x2[0]), torch.as_tensor(y2[0])), - -1).reshape(1, 1, x2.shape[-1], 2)} + data = { + 0: torch.stack( + (torch.as_tensor(x2[0]), torch.as_tensor(y2[0])), -1 + ).reshape(1, 1, x2.shape[-1], 2) + } data[1] = torch.as_tensor(y2[1]).reshape(1, 1, x2.shape[-1]) fig, axes = plt.subplots(1, 2) for i, ax in enumerate(axes): @@ -276,31 +327,40 @@ def test_update_plot_mixed_multi_axes(self): po.tools.update_plot(axes, data) for i, ax in enumerate(axes): if i == 0: - assert len(ax.collections) == 1, "Too many scatter plots created" + assert ( + len(ax.collections) == 1 + ), "Too many scatter plots created" assert len(ax.lines) == 0, "Too many lines created" ax_data = ax.collections[0].get_offsets() else: - assert len(ax.collections) == 0, "Too many scatter plots created" + assert ( + len(ax.collections) == 0 + ), "Too many scatter plots created" assert len(ax.lines) == 1, "Too many lines created" _, ax_data = ax.lines[0].get_data() if not np.allclose(ax_data, data[i]): - raise Exception("Didn't update points of the scatter plot correctly!") - plt.close('all') - - @pytest.mark.parametrize('as_rgb', [True, False]) - @pytest.mark.parametrize('channel_idx', [None, 0, [0, 1]]) - @pytest.mark.parametrize('batch_idx', [None, 0, [0, 1]]) - @pytest.mark.parametrize('is_complex', [False, 'logpolar', 'rectangular', 'polar']) - @pytest.mark.parametrize('mini_im', [True, False]) + raise Exception( + "Didn't update points of the scatter plot correctly!" + ) + plt.close("all") + + @pytest.mark.parametrize("as_rgb", [True, False]) + @pytest.mark.parametrize("channel_idx", [None, 0, [0, 1]]) + @pytest.mark.parametrize("batch_idx", [None, 0, [0, 1]]) + @pytest.mark.parametrize( + "is_complex", [False, "logpolar", "rectangular", "polar"] + ) + @pytest.mark.parametrize("mini_im", [True, False]) # test the edge cases where we try to plot a tensor that's (b, c, 1, w) or # (b, c, h, 1) - @pytest.mark.parametrize('one_dim', [False, 'h', 'w']) - def test_imshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_im, - one_dim): + @pytest.mark.parametrize("one_dim", [False, "h", "w"]) + def test_imshow( + self, as_rgb, channel_idx, batch_idx, is_complex, mini_im, one_dim + ): fails = False - if one_dim == 'h': + if one_dim == "h": im_shape = [2, 4, 1, 5] - elif one_dim == 'w': + elif one_dim == "w": im_shape = [2, 4, 5, 1] else: im_shape = [2, 4, 5, 5] @@ -322,11 +382,11 @@ def test_imshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_im, n_axes += 8 # same number of batches and channels, then double the height and # width - shape = im_shape[:2] + [i*2 for i in im_shape[-2:]] + shape = im_shape[:2] + [i * 2 for i in im_shape[-2:]] im = [im, torch.rand(shape, dtype=dtype)] if not is_complex: # need to change this to one of the acceptable strings - is_complex = 'rectangular' + is_complex = "rectangular" if batch_idx is None and channel_idx is None and not as_rgb: # then we'd have a 4d array we want to plot in grayscale -- don't # know how to do that @@ -352,28 +412,44 @@ def test_imshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_im, # neither of these are supported fails = True if not fails: - fig = po.imshow(im, as_rgb=as_rgb, channel_idx=channel_idx, - batch_idx=batch_idx, plot_complex=is_complex) - assert len(fig.axes) == n_axes, f"Created {len(fig.axes)} axes, but expected {n_axes}! Probably plotting color as grayscale or vice versa" - plt.close('all') + fig = po.imshow( + im, + as_rgb=as_rgb, + channel_idx=channel_idx, + batch_idx=batch_idx, + plot_complex=is_complex, + ) + assert len(fig.axes) == n_axes, ( + f"Created {len(fig.axes)} axes, but expected {n_axes}!" + " Probably plotting color as grayscale or vice versa" + ) + plt.close("all") if fails: with pytest.raises(Exception): - po.imshow(im, as_rgb=as_rgb, channel_idx=channel_idx, - batch_idx=batch_idx, plot_complex=is_complex) - - @pytest.fixture(scope='class', params=['complex', 'not-complex']) + po.imshow( + im, + as_rgb=as_rgb, + channel_idx=channel_idx, + batch_idx=batch_idx, + plot_complex=is_complex, + ) + + @pytest.fixture(scope="class", params=["complex", "not-complex"]) def steerpyr(self, request): - if request.param == 'complex': + if request.param == "complex": is_complex = True - elif request.param == 'not-complex': + elif request.param == "not-complex": is_complex = False - return po.simul.SteerablePyramidFreq((32, 32), height=2, order=1, is_complex=is_complex).to(DEVICE) - - @pytest.mark.parametrize('channel_idx', [None, 0, [0, 1]]) - @pytest.mark.parametrize('batch_idx', [None, 0, [0, 1]]) - @pytest.mark.parametrize('show_residuals', [True, False]) - def test_pyrshow(self, steerpyr, channel_idx, batch_idx, show_residuals, - curie_img): + return po.simul.SteerablePyramidFreq( + (32, 32), height=2, order=1, is_complex=is_complex + ).to(DEVICE) + + @pytest.mark.parametrize("channel_idx", [None, 0, [0, 1]]) + @pytest.mark.parametrize("batch_idx", [None, 0, [0, 1]]) + @pytest.mark.parametrize("show_residuals", [True, False]) + def test_pyrshow( + self, steerpyr, channel_idx, batch_idx, show_residuals, curie_img + ): fails = False if not isinstance(channel_idx, int) or not isinstance(batch_idx, int): fails = True @@ -383,36 +459,49 @@ def test_pyrshow(self, steerpyr, channel_idx, batch_idx, show_residuals, if show_residuals: n_axes += 2 img = curie_img.clone() - img = img[..., :steerpyr.lo0mask.shape[-2], :steerpyr.lo0mask.shape[-1]] + img = img[ + ..., : steerpyr.lo0mask.shape[-2], : steerpyr.lo0mask.shape[-1] + ] coeffs = steerpyr(img) if not fails: # unfortunately, can't figure out how to properly parametrize this # and use the steerpyr fixture - for comp in ['rectangular', 'polar', 'logpolar']: - fig = po.pyrshow(coeffs, show_residuals=show_residuals, - plot_complex=comp, batch_idx=batch_idx, - channel_idx=channel_idx) + for comp in ["rectangular", "polar", "logpolar"]: + fig = po.pyrshow( + coeffs, + show_residuals=show_residuals, + plot_complex=comp, + batch_idx=batch_idx, + channel_idx=channel_idx, + ) # get all the axes that have an image (so, get all non-empty # axes) axes = [ax for ax in fig.axes if ax.images] if len(axes) != n_axes: - raise Exception(f"Created {len(fig.axes)} axes, but expected {n_axes}!") - plt.close('all') + raise Exception( + f"Created {len(fig.axes)} axes, but expected {n_axes}!" + ) + plt.close("all") else: with pytest.raises(TypeError): - po.pyrshow(coeffs, batch_idx=batch_idx, channel_idx=channel_idx) + po.pyrshow( + coeffs, batch_idx=batch_idx, channel_idx=channel_idx + ) def test_display_test_signals(self): po.imshow(po.tools.make_synthetic_stimuli(128)) po.imshow(po.load_images(IMG_DIR / "256")) - - @pytest.mark.parametrize('as_rgb', [True, False]) - @pytest.mark.parametrize('channel_idx', [None, 0, [0, 1]]) - @pytest.mark.parametrize('batch_idx', [None, 0, [0, 1]]) - @pytest.mark.parametrize('is_complex', [False, 'logpolar', 'rectangular', 'polar']) - @pytest.mark.parametrize('mini_vid', [True, False]) - def test_animshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_vid): + @pytest.mark.parametrize("as_rgb", [True, False]) + @pytest.mark.parametrize("channel_idx", [None, 0, [0, 1]]) + @pytest.mark.parametrize("batch_idx", [None, 0, [0, 1]]) + @pytest.mark.parametrize( + "is_complex", [False, "logpolar", "rectangular", "polar"] + ) + @pytest.mark.parametrize("mini_vid", [True, False]) + def test_animshow( + self, as_rgb, channel_idx, batch_idx, is_complex, mini_vid + ): fails = False if is_complex: # this is 2 (the two complex components) * 4 (the four channels) * @@ -436,7 +525,7 @@ def test_animshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_vid): vid = [vid, torch.rand(shape, dtype=dtype)] if not is_complex: # need to change this to one of the acceptable strings - is_complex = 'rectangular' + is_complex = "rectangular" if batch_idx is None and channel_idx is None and not as_rgb: # then we'd have a 4d array we want to plot in grayscale -- don't # know how to do that @@ -462,21 +551,34 @@ def test_animshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_vid): # neither of these are supported fails = True if not fails: - anim = po.animshow(vid, as_rgb=as_rgb, channel_idx=channel_idx, - batch_idx=batch_idx, plot_complex=is_complex) + anim = po.animshow( + vid, + as_rgb=as_rgb, + channel_idx=channel_idx, + batch_idx=batch_idx, + plot_complex=is_complex, + ) fig = anim._fig - assert len(fig.axes) == n_axes, f"Created {len(fig.axes)} axes, but expected {n_axes}! Probably plotting color as grayscale or vice versa" - plt.close('all') + assert len(fig.axes) == n_axes, ( + f"Created {len(fig.axes)} axes, but expected {n_axes}!" + " Probably plotting color as grayscale or vice versa" + ) + plt.close("all") if fails: with pytest.raises(Exception): - po.animshow(vid, as_rgb=as_rgb, channel_idx=channel_idx, - batch_idx=batch_idx, plot_complex=is_complex) + po.animshow( + vid, + as_rgb=as_rgb, + channel_idx=channel_idx, + batch_idx=batch_idx, + plot_complex=is_complex, + ) def test_update_plot_shape_fail(self, einstein_img): # update_plot expects 3 or 4d data -- this checks that update_plot # fails with 2d data and raises the proper exception fig = po.imshow(einstein_img) - with pytest.raises(ValueError, match='3 or 4 dimensional'): + with pytest.raises(ValueError, match="3 or 4 dimensional"): po.tools.update_plot(fig.axes[0], einstein_img.squeeze()) def test_synthesis_plot_shape_fail(self, einstein_img): @@ -495,16 +597,21 @@ def forward(self, *args, **kwargs): met = po.synth.Metamer(einstein_img, model) met.synthesize(max_iter=3, store_progress=True) met._metamer = met.metamer.squeeze() - with pytest.raises(ValueError, match='3 or 4d'): + with pytest.raises(ValueError, match="3 or 4d"): po.synth.metamer.plot_synthesis_status(met) - with pytest.raises(ValueError, match='3 or 4d'): + with pytest.raises(ValueError, match="3 or 4d"): po.synth.metamer.animate(met) -def template_test_synthesis_all_plot(synthesis_object, iteration, - display_synth, loss, - representation_error, - pixel_values, fig_creation): +def template_test_synthesis_all_plot( + synthesis_object, + iteration, + display_synth, + loss, + representation_error, + pixel_values, + fig_creation, +): # template function to test whether we can plot all possible combinations # of plots. test_custom_fig tests whether these animate correctly. Any # synthesis object that has had synthesis() called should work with this @@ -517,197 +624,241 @@ def template_test_synthesis_all_plot(synthesis_object, iteration, if isinstance(synthesis_object, po.synth.Metamer): containing_file = po.synth.metamer as_rgb = synthesis_object.image.shape[1] > 1 - plot_kwargs['plot_representation_error_as_rgb'] = as_rgb + plot_kwargs["plot_representation_error_as_rgb"] = as_rgb if display_synth: - included_plots.append('display_metamer') + included_plots.append("display_metamer") elif isinstance(synthesis_object, po.synth.MADCompetition): containing_file = po.synth.mad_competition if display_synth: - included_plots.append('display_mad_image') + included_plots.append("display_mad_image") if loss: - included_plots.append('plot_loss') + included_plots.append("plot_loss") if representation_error: - included_plots.append('plot_representation_error') + included_plots.append("plot_representation_error") if pixel_values: - included_plots.append('plot_pixel_values') + included_plots.append("plot_pixel_values") width_ratios = {} - if fig_creation.startswith('auto'): + if fig_creation.startswith("auto"): fig = None axes_idx = {} - if fig_creation.endswith('ratios'): + if fig_creation.endswith("ratios"): if loss: - width_ratios['plot_loss'] = 2 + width_ratios["plot_loss"] = 2 elif display_synth: if isinstance(synthesis_object, po.synth.Metamer): - width_ratios['display_metamer'] = 2 + width_ratios["display_metamer"] = 2 elif isinstance(synthesis_object, po.synth.MADCompetition): - width_ratios['display_mad_image'] = 2 - elif fig_creation.startswith('pass'): - fig, axes, axes_idx = containing_file._setup_synthesis_fig(None, {}, None, - included_plots=included_plots) - if fig_creation.endswith('without'): + width_ratios["display_mad_image"] = 2 + elif fig_creation.startswith("pass"): + fig, axes, axes_idx = containing_file._setup_synthesis_fig( + None, {}, None, included_plots=included_plots + ) + if fig_creation.endswith("without"): axes_idx = {} - containing_file.plot_synthesis_status(synthesis_object, iteration=iteration, - included_plots=included_plots, - fig=fig, - axes_idx=axes_idx, - **plot_kwargs, - width_ratios=width_ratios) - plt.close('all') - - -def template_test_synthesis_custom_fig(synthesis_object, func, fig_creation, - tmp_path): + containing_file.plot_synthesis_status( + synthesis_object, + iteration=iteration, + included_plots=included_plots, + fig=fig, + axes_idx=axes_idx, + **plot_kwargs, + width_ratios=width_ratios, + ) + plt.close("all") + + +def template_test_synthesis_custom_fig( + synthesis_object, func, fig_creation, tmp_path +): # template function to test whether we can create our own figure and pass # it to the plotting and animating functions, specifying some or all of the # locations for the plots. Any synthesis object that has had synthesis() # called should work with this plot_kwargs = {} - included_plots = ['plot_loss', 'plot_pixel_values'] + included_plots = ["plot_loss", "plot_pixel_values"] # need to figure out which plotting function to call if isinstance(synthesis_object, po.synth.Metamer): containing_file = po.synth.metamer as_rgb = synthesis_object.image.shape[1] > 1 - plot_kwargs['plot_representation_error_as_rgb'] = as_rgb - included_plots.append('plot_representation_error') - if fig_creation.endswith('extra'): - included_plots.append('display_metamer') - axes_idx = {'display_metamer': 0, 'plot_representation_error': 8} + plot_kwargs["plot_representation_error_as_rgb"] = as_rgb + included_plots.append("plot_representation_error") + if fig_creation.endswith("extra"): + included_plots.append("display_metamer") + axes_idx = {"display_metamer": 0, "plot_representation_error": 8} elif isinstance(synthesis_object, po.synth.MADCompetition): containing_file = po.synth.mad_competition - if fig_creation.endswith('extra'): - included_plots.append('display_mad_image') - axes_idx = {'display_mad_image': 0} + if fig_creation.endswith("extra"): + included_plots.append("display_mad_image") + axes_idx = {"display_mad_image": 0} fig, axes = plt.subplots(3, 3, figsize=(35, 17)) - if '-' in fig_creation: - axes_idx['misc'] = [1, 4] - if not fig_creation.split('-')[-1] in ['without']: - axes_idx.update({'plot_loss': 6, 'plot_pixel_values': 7}) - if func == 'plot' or fig_creation.endswith('preplot'): - fig, axes_idx = containing_file.plot_synthesis_status(synthesis_object, - included_plots=included_plots, - fig=fig, - axes_idx=axes_idx, - **plot_kwargs) - if func == 'animate': - path = tmp_path / 'test_anim.html' - containing_file.animate(synthesis_object, - fig=fig, - axes_idx=axes_idx, - included_plots=included_plots, - **plot_kwargs).save(path) - plt.close('all') + if "-" in fig_creation: + axes_idx["misc"] = [1, 4] + if not fig_creation.split("-")[-1] in ["without"]: + axes_idx.update({"plot_loss": 6, "plot_pixel_values": 7}) + if func == "plot" or fig_creation.endswith("preplot"): + fig, axes_idx = containing_file.plot_synthesis_status( + synthesis_object, + included_plots=included_plots, + fig=fig, + axes_idx=axes_idx, + **plot_kwargs, + ) + if func == "animate": + path = tmp_path / "test_anim.html" + containing_file.animate( + synthesis_object, + fig=fig, + axes_idx=axes_idx, + included_plots=included_plots, + **plot_kwargs, + ).save(path) + plt.close("all") class TestMADDisplay(object): - @pytest.fixture(scope='class', params=['rgb', 'grayscale']) + @pytest.fixture(scope="class", params=["rgb", "grayscale"]) def synthesized_mad(self, request): # make the images really small so nothing takes as long - if request.param == 'rgb': - img = po.load_images(IMG_DIR / "256" / 'color_wheel.jpg', False).to(DEVICE) + if request.param == "rgb": + img = po.load_images( + IMG_DIR / "256" / "color_wheel.jpg", False + ).to(DEVICE) img = img[..., :16, :16] else: - img = po.load_images(IMG_DIR / "256" / 'nuts.pgm').to(DEVICE) + img = po.load_images(IMG_DIR / "256" / "nuts.pgm").to(DEVICE) img = img[..., :16, :16] + # to serve as a metric, need to return a single value, but SSIM and MSE # will return a separate value for each RGB channel. Additionally, MAD # requires metrics are *dis*-similarity metrics, so that they return 0 # if two images are identical (SSIM normally returns 1) def rgb_ssim(*args, **kwargs): return 1 - po.metric.ssim(*args, **kwargs).mean() + def rgb_mse(*args, **kwargs): return po.metric.mse(*args, **kwargs).mean() - mad = po.synth.MADCompetition(img, rgb_mse, rgb_ssim, 'min') + + mad = po.synth.MADCompetition(img, rgb_mse, rgb_ssim, "min") mad.synthesize(max_iter=2, store_progress=True) return mad - @pytest.mark.parametrize('iteration', [None, 1, -1]) - @pytest.mark.parametrize('display_mad', [True, False]) - @pytest.mark.parametrize('loss', [True, False]) - @pytest.mark.parametrize('pixel_values', [True, False]) - @pytest.mark.parametrize('fig_creation', ['auto', 'auto-ratios', - 'pass-with', 'pass-without']) - def test_all_plot(self, synthesized_mad, iteration, - display_mad, loss, - pixel_values, fig_creation): + @pytest.mark.parametrize("iteration", [None, 1, -1]) + @pytest.mark.parametrize("display_mad", [True, False]) + @pytest.mark.parametrize("loss", [True, False]) + @pytest.mark.parametrize("pixel_values", [True, False]) + @pytest.mark.parametrize( + "fig_creation", ["auto", "auto-ratios", "pass-with", "pass-without"] + ) + def test_all_plot( + self, + synthesized_mad, + iteration, + display_mad, + loss, + pixel_values, + fig_creation, + ): # tests whether we can plot all possible combinations of plots. # test_custom_fig tests whether these animate correctly. - template_test_synthesis_all_plot(synthesized_mad, iteration, - display_mad, loss, False, - pixel_values, fig_creation) - - @pytest.mark.parametrize('func', ['plot', 'animate']) - @pytest.mark.parametrize('fig_creation', ['custom', 'custom-misc', 'custom-without', - 'custom-extra', 'custom-preplot']) + template_test_synthesis_all_plot( + synthesized_mad, + iteration, + display_mad, + loss, + False, + pixel_values, + fig_creation, + ) + + @pytest.mark.parametrize("func", ["plot", "animate"]) + @pytest.mark.parametrize( + "fig_creation", + [ + "custom", + "custom-misc", + "custom-without", + "custom-extra", + "custom-preplot", + ], + ) def test_custom_fig(self, synthesized_mad, func, fig_creation, tmp_path): # tests whether we can create our own figure and pass it to # MADCompetition's plotting and animating functions, specifying some or # all of the locations for the plots - template_test_synthesis_custom_fig(synthesized_mad, func, fig_creation, tmp_path) + template_test_synthesis_custom_fig( + synthesized_mad, func, fig_creation, tmp_path + ) - @pytest.fixture(scope='class') + @pytest.fixture(scope="class") def all_mad(self): # run synthesis for all 4 MAD images. - img = po.load_images(IMG_DIR / "256" / 'nuts.pgm').to(DEVICE) + img = po.load_images(IMG_DIR / "256" / "nuts.pgm").to(DEVICE) img = img[..., :16, :16] model1 = po.metric.mse # MAD requires metrics are *dis*-similarity metrics, so that they # return 0 if two images are identical (SSIM normally returns 1) model2 = lambda *args: 1 - po.metric.ssim(*args).mean() - mad = po.synth.MADCompetition(img, model1, model2, 'min') + mad = po.synth.MADCompetition(img, model1, model2, "min") mad.synthesize(max_iter=2) - mad2 = po.synth.MADCompetition(img, model1, model2, 'max') + mad2 = po.synth.MADCompetition(img, model1, model2, "max") mad2.synthesize(max_iter=2) - mad3 = po.synth.MADCompetition(img, model2, model1, 'min') + mad3 = po.synth.MADCompetition(img, model2, model1, "min") mad3.synthesize(max_iter=2) - mad4 = po.synth.MADCompetition(img, model2, model1, 'max') + mad4 = po.synth.MADCompetition(img, model2, model1, "max") mad4.synthesize(max_iter=2) return mad, mad2, mad3, mad4 - @pytest.mark.parametrize('func', ['loss', 'image']) + @pytest.mark.parametrize("func", ["loss", "image"]) def test_helper_funcs(self, all_mad, func): - if func == 'loss': + if func == "loss": func = po.synth.mad_competition.plot_loss_all - elif func == 'image': + elif func == "image": func = po.synth.mad_competition.display_mad_image_all func(*all_mad) - @pytest.mark.parametrize('func', ['plot', 'animate']) + @pytest.mark.parametrize("func", ["plot", "animate"]) # plot_representation_error is an allowed value for metamer, but not MAD. # the second is just a typo - @pytest.mark.parametrize('val', ['plot_representation_error', 'plot_mad_image']) - @pytest.mark.parametrize('variable', ['included_plots', 'width_ratios', - 'axes_idx']) - def test_allowed_plots_exception(self, synthesized_mad, - func, val, variable): - if func == 'plot': + @pytest.mark.parametrize( + "val", ["plot_representation_error", "plot_mad_image"] + ) + @pytest.mark.parametrize( + "variable", ["included_plots", "width_ratios", "axes_idx"] + ) + def test_allowed_plots_exception( + self, synthesized_mad, func, val, variable + ): + if func == "plot": func = po.synth.mad_competition.plot_synthesis_status - elif func == 'animate': + elif func == "animate": func = po.synth.mad_competition.animate kwargs = {} - if variable == 'included_plots': - kwargs['included_plots'] = [val, 'plot_loss'] - elif variable == 'width_ratios': - kwargs['width_ratios'] = {val: 1, 'plot_loss': 1} - elif variable == 'axes_idx': - kwargs['axes_idx'] = {val: 0, 'plot_loss': 1} - with pytest.raises(ValueError, match=f'{variable} contained value'): + if variable == "included_plots": + kwargs["included_plots"] = [val, "plot_loss"] + elif variable == "width_ratios": + kwargs["width_ratios"] = {val: 1, "plot_loss": 1} + elif variable == "axes_idx": + kwargs["axes_idx"] = {val: 0, "plot_loss": 1} + with pytest.raises(ValueError, match=f"{variable} contained value"): func(synthesized_mad, **kwargs) class TestMetamerDisplay(object): - @pytest.fixture(scope='class', params=['rgb', 'grayscale']) + @pytest.fixture(scope="class", params=["rgb", "grayscale"]) def synthesized_met(self, request): - img= request.param + img = request.param # make the images really small so nothing takes as long - if img == 'rgb': - img = po.load_images(IMG_DIR / "256" / 'color_wheel.jpg', False).to(DEVICE) + if img == "rgb": + img = po.load_images( + IMG_DIR / "256" / "color_wheel.jpg", False + ).to(DEVICE) img = img[..., :16, :16] else: - img = po.load_images(IMG_DIR / "256" / 'nuts.pgm').to(DEVICE) + img = po.load_images(IMG_DIR / "256" / "nuts.pgm").to(DEVICE) img = img[..., :16, :16] + # height=1 and order=0 to limit the time this takes, and then we # only return one of the tensors so that everything is easy for # plotting code to figure out (if we downsampled and were on an @@ -717,8 +868,10 @@ def synthesized_met(self, request): class SPyr(po.simul.SteerablePyramidFreq): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) + def forward(self, *args, **kwargs): return super().forward(*args, **kwargs)[(0, 0)] + model = SPyr(img.shape[-2:], height=1, order=1).to(DEVICE) met = po.synth.Metamer(img, model) met.synthesize(max_iter=2, store_progress=True) @@ -726,50 +879,75 @@ def forward(self, *args, **kwargs): # mix together func and iteration, because iteration doesn't make sense to # pass to animate - @pytest.mark.parametrize('iteration', [None, 1, -1]) - @pytest.mark.parametrize('display_metamer', [True, False]) - @pytest.mark.parametrize('loss', [True, False]) - @pytest.mark.parametrize('representation_error', [True, False]) - @pytest.mark.parametrize('pixel_values', [True, False]) - @pytest.mark.parametrize('fig_creation', ['auto', 'auto-ratios', - 'pass-with', 'pass-without']) - def test_all_plot(self, synthesized_met, iteration, display_metamer, loss, - representation_error, pixel_values, fig_creation): + @pytest.mark.parametrize("iteration", [None, 1, -1]) + @pytest.mark.parametrize("display_metamer", [True, False]) + @pytest.mark.parametrize("loss", [True, False]) + @pytest.mark.parametrize("representation_error", [True, False]) + @pytest.mark.parametrize("pixel_values", [True, False]) + @pytest.mark.parametrize( + "fig_creation", ["auto", "auto-ratios", "pass-with", "pass-without"] + ) + def test_all_plot( + self, + synthesized_met, + iteration, + display_metamer, + loss, + representation_error, + pixel_values, + fig_creation, + ): # tests whether we can plot all possible combinations of plots. # test_custom_fig tests whether these animate correctly. - template_test_synthesis_all_plot(synthesized_met, iteration, - display_metamer, loss, - representation_error, pixel_values, - fig_creation) - - @pytest.mark.parametrize('func', ['plot', 'animate']) - @pytest.mark.parametrize('fig_creation', ['custom', 'custom-misc', 'custom-without', - 'custom-extra', 'custom-preplot']) + template_test_synthesis_all_plot( + synthesized_met, + iteration, + display_metamer, + loss, + representation_error, + pixel_values, + fig_creation, + ) + + @pytest.mark.parametrize("func", ["plot", "animate"]) + @pytest.mark.parametrize( + "fig_creation", + [ + "custom", + "custom-misc", + "custom-without", + "custom-extra", + "custom-preplot", + ], + ) def test_custom_fig(self, synthesized_met, func, fig_creation, tmp_path): # tests whether we can create our own figure and pass it to Metamer's # plotting and animating functions, specifying some or all of the # locations for the plots - template_test_synthesis_custom_fig(synthesized_met, func, fig_creation, - tmp_path) + template_test_synthesis_custom_fig( + synthesized_met, func, fig_creation, tmp_path + ) - @pytest.mark.parametrize('func', ['plot', 'animate']) + @pytest.mark.parametrize("func", ["plot", "animate"]) # display_mad_image is an allowed value for MAD but not metamer. # the second is just a typo - @pytest.mark.parametrize('val', ['display_mad_image', 'plot_metamer']) - @pytest.mark.parametrize('variable', ['included_plots', 'width_ratios', - 'axes_idx']) - def test_allowed_plots_exception(self, synthesized_met, - func, val, variable): - if func == 'plot': + @pytest.mark.parametrize("val", ["display_mad_image", "plot_metamer"]) + @pytest.mark.parametrize( + "variable", ["included_plots", "width_ratios", "axes_idx"] + ) + def test_allowed_plots_exception( + self, synthesized_met, func, val, variable + ): + if func == "plot": func = po.synth.metamer.plot_synthesis_status - elif func == 'animate': + elif func == "animate": func = po.synth.metamer.animate kwargs = {} - if variable == 'included_plots': - kwargs['included_plots'] = [val, 'plot_loss'] - elif variable == 'width_ratios': - kwargs['width_ratios'] = {val: 1, 'plot_loss': 1} - elif variable == 'axes_idx': - kwargs['axes_idx'] = {val: 0, 'plot_loss': 1} - with pytest.raises(ValueError, match=f'{variable} contained value'): + if variable == "included_plots": + kwargs["included_plots"] = [val, "plot_loss"] + elif variable == "width_ratios": + kwargs["width_ratios"] = {val: 1, "plot_loss": 1} + elif variable == "axes_idx": + kwargs["axes_idx"] = {val: 0, "plot_loss": 1} + with pytest.raises(ValueError, match=f"{variable} contained value"): func(synthesized_met, **kwargs) diff --git a/tests/test_eigendistortion.py b/tests/test_eigendistortion.py index 6753fc95..fb31b565 100644 --- a/tests/test_eigendistortion.py +++ b/tests/test_eigendistortion.py @@ -5,7 +5,10 @@ from torch import nn from plenoptic.simulate import OnOff, Gaussian from plenoptic.tools import remove_grad -from plenoptic.synthesize.eigendistortion import Eigendistortion, display_eigendistortion +from plenoptic.synthesize.eigendistortion import ( + Eigendistortion, + display_eigendistortion, +) from conftest import get_model, DEVICE import matplotlib.pyplot as plt import os.path as op @@ -14,16 +17,19 @@ SMALL_DIM = 20 LARGE_DIM = 100 + class TestEigendistortionSynthesis: - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_method_assertion(self, einstein_img, model): einstein_img = einstein_img[..., :SMALL_DIM, :SMALL_DIM] ed = Eigendistortion(einstein_img, model) with pytest.raises(AssertionError, match="method must be in "): - ed.synthesize(method='asdfsdfasf') + ed.synthesize(method="asdfsdfasf") - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd', 'ColorModel'], indirect=True) + @pytest.mark.parametrize( + "model", ["frontend.OnOff.nograd", "ColorModel"], indirect=True + ) def test_method_exact(self, model, einstein_img, color_img): # in this case, we're working with grayscale images if model.__class__ == OnOff: @@ -36,16 +42,22 @@ def test_method_exact(self, model, einstein_img, color_img): ed = Eigendistortion(img, model) # invert matrix explicitly - ed.synthesize(method='exact') + ed.synthesize(method="exact") - assert len(ed.eigenvalues) == n_chans*SMALL_DIM**2 - assert len(ed.eigendistortions) == n_chans*SMALL_DIM**2 - assert len(ed.eigenindex) == n_chans*SMALL_DIM**2 + assert len(ed.eigenvalues) == n_chans * SMALL_DIM**2 + assert len(ed.eigendistortions) == n_chans * SMALL_DIM**2 + assert len(ed.eigenindex) == n_chans * SMALL_DIM**2 # test that each eigenvector returned is original img shape - assert ed.eigendistortions.shape[-3:] == (n_chans, SMALL_DIM, SMALL_DIM) - - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd', 'ColorModel'], indirect=True) + assert ed.eigendistortions.shape[-3:] == ( + n_chans, + SMALL_DIM, + SMALL_DIM, + ) + + @pytest.mark.parametrize( + "model", ["frontend.OnOff.nograd", "ColorModel"], indirect=True + ) def test_method_power(self, model, einstein_img, color_img): if model.__class__ == OnOff: n_chans = 1 @@ -55,67 +67,83 @@ def test_method_power(self, model, einstein_img, color_img): n_chans = 3 img = img[..., :LARGE_DIM, :LARGE_DIM] ed = Eigendistortion(img, model) - ed.synthesize(method='power', max_iter=3) + ed.synthesize(method="power", max_iter=3) # test it should only return two eigenvectors and values assert len(ed.eigenvalues) == 2 assert len(ed.eigendistortions) == 2 assert len(ed.eigenindex) == 2 - assert ed.eigendistortions.shape[-3:] == (n_chans, LARGE_DIM, LARGE_DIM) + assert ed.eigendistortions.shape[-3:] == ( + n_chans, + LARGE_DIM, + LARGE_DIM, + ) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_orthog_iter(self, model, einstein_img): n, k = 30, 10 n_chans = 1 # TODO color einstein_img = einstein_img[..., :n, :n] ed = Eigendistortion(einstein_img, model) - ed.synthesize(k=k, method='power', max_iter=10) + ed.synthesize(k=k, method="power", max_iter=10) - assert ed.eigendistortions.shape == (k*2, n_chans, n, n) - assert ed.eigenindex.allclose(torch.cat((torch.arange(k), torch.arange(n**2 - k, n**2)))) - assert len(ed.eigenvalues) == 2*k + assert ed.eigendistortions.shape == (k * 2, n_chans, n, n) + assert ed.eigenindex.allclose( + torch.cat((torch.arange(k), torch.arange(n**2 - k, n**2))) + ) + assert len(ed.eigenvalues) == 2 * k - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_method_randomized_svd(self, model, einstein_img): n, k = 30, 10 n_chans = 1 # TODO color einstein_img = einstein_img[..., :n, :n] ed = Eigendistortion(einstein_img, model) - ed.synthesize(k=k, method='randomized_svd') + ed.synthesize(k=k, method="randomized_svd") assert ed.eigendistortions.shape == (k, n_chans, n, n) assert ed.eigenindex.allclose(torch.arange(k)) assert len(ed.eigenvalues) == k - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_temp(self, model, einstein_img): y = model(einstein_img) print(y.shape) # e_pow = Eigendistortion(einstein_img, model) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_method_accuracy(self, model, einstein_img): # test pow and svd against ground-truth jacobian (exact) method - einstein_img = einstein_img[..., 125:125+25, 125:125+25] + einstein_img = einstein_img[..., 125 : 125 + 25, 125 : 125 + 25] e_jac = Eigendistortion(einstein_img, model) e_pow = Eigendistortion(einstein_img, model) e_svd = Eigendistortion(einstein_img, model) k_pow, k_svd = 1, 75 - e_jac.synthesize(method='exact') + e_jac.synthesize(method="exact") set_seed(0) - e_pow.synthesize(k=k_pow, method='power', max_iter=2500) - e_svd.synthesize(k=k_svd, method='randomized_svd') - - print("synthesized first and last: ", e_pow.eigenvalues[0], e_pow.eigenvalues[-1]) - print("exact first and last: ", e_jac.eigenvalues[0], e_jac.eigenvalues[-1]) + e_pow.synthesize(k=k_pow, method="power", max_iter=2500) + e_svd.synthesize(k=k_svd, method="randomized_svd") + + print( + "synthesized first and last: ", + e_pow.eigenvalues[0], + e_pow.eigenvalues[-1], + ) + print( + "exact first and last: ", + e_jac.eigenvalues[0], + e_jac.eigenvalues[-1], + ) assert e_pow.eigenvalues[0].isclose(e_jac.eigenvalues[0], atol=1e-2) assert e_pow.eigenvalues[-1].isclose(e_jac.eigenvalues[-1], atol=1e-2) assert e_svd.eigenvalues[0].isclose(e_jac.eigenvalues[0], atol=1e-2) - @pytest.mark.parametrize("model", ['frontend.OnOff.nograd', 'ColorModel'], indirect=True) - @pytest.mark.parametrize("method", ['power', 'randomized_svd']) + @pytest.mark.parametrize( + "model", ["frontend.OnOff.nograd", "ColorModel"], indirect=True + ) + @pytest.mark.parametrize("method", ["power", "randomized_svd"]) @pytest.mark.parametrize("k", [2, 3]) def test_display(self, model, einstein_img, color_img, method, k): # in this case, we're working with grayscale images @@ -128,81 +156,100 @@ def test_display(self, model, einstein_img, color_img, method, k): eigendist.synthesize(k=k, method=method, max_iter=10) display_eigendistortion(eigendist, eigenindex=0) display_eigendistortion(eigendist, eigenindex=1) - + if method == "power": display_eigendistortion(eigendist, eigenindex=-1) - display_eigendistortion(eigendist,eigenindex=-2) - elif method == "randomized_svd": # svd only has top k not bottom k eigendists + display_eigendistortion(eigendist, eigenindex=-2) + elif ( + method == "randomized_svd" + ): # svd only has top k not bottom k eigendists with pytest.raises(AssertionError): display_eigendistortion(eigendist, eigenindex=-1) - plt.close("all") + plt.close("all") - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) - @pytest.mark.parametrize('fail', [False, 'img', 'model']) - @pytest.mark.parametrize('method', ['exact', 'power', 'randomized_svd']) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) + @pytest.mark.parametrize("fail", [False, "img", "model"]) + @pytest.mark.parametrize("method", ["exact", "power", "randomized_svd"]) def test_save_load(self, einstein_img, model, fail, method, tmp_path): - if method in ['exact', 'randomized_svd']: + if method in ["exact", "randomized_svd"]: img = einstein_img[..., :SMALL_DIM, :SMALL_DIM] else: img = einstein_img ed = Eigendistortion(img, model) ed.synthesize(max_iter=4, method=method) - ed.save(op.join(tmp_path, 'test_eigendistortion_save_load.pt')) + ed.save(op.join(tmp_path, "test_eigendistortion_save_load.pt")) if fail: - if fail == 'img': + if fail == "img": img = torch.rand_like(img) - expectation = pytest.raises(ValueError, match='Saved and initialized image are different') - elif fail == 'model': + expectation = pytest.raises( + ValueError, + match="Saved and initialized image are different", + ) + elif fail == "model": model = Gaussian(30).to(DEVICE) remove_grad(model) - expectation = pytest.raises(RuntimeError, match='Attribute representation_flat have different shapes') + expectation = pytest.raises( + RuntimeError, + match=( + "Attribute representation_flat have different shapes" + ), + ) ed_copy = Eigendistortion(img, model) with expectation: - ed_copy.load(op.join(tmp_path, "test_eigendistortion_save_load.pt"), - map_location=DEVICE) + ed_copy.load( + op.join(tmp_path, "test_eigendistortion_save_load.pt"), + map_location=DEVICE, + ) else: ed_copy = Eigendistortion(img, model) - ed_copy.load(op.join(tmp_path, "test_eigendistortion_save_load.pt"), - map_location=DEVICE) - for k in ['image', '_representation_flat']: + ed_copy.load( + op.join(tmp_path, "test_eigendistortion_save_load.pt"), + map_location=DEVICE, + ) + for k in ["image", "_representation_flat"]: if not getattr(ed, k).allclose(getattr(ed_copy, k), rtol=1e-2): - raise ValueError("Something went wrong with saving and loading! %s not the same" - % k) + raise ValueError( + "Something went wrong with saving and loading! %s not" + " the same" % k + ) # check that can resume ed_copy.synthesize(max_iter=4, method=method) - @pytest.mark.parametrize('model', ['Identity'], indirect=True) - @pytest.mark.parametrize('to_type', ['dtype', 'device']) + @pytest.mark.parametrize("model", ["Identity"], indirect=True) + @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, curie_img, model, to_type): ed = Eigendistortion(curie_img, model) - ed.synthesize(max_iter=5, method='power') - if to_type == 'dtype': + ed.synthesize(max_iter=5, method="power") + if to_type == "dtype": ed.to(torch.float16) assert ed.image.dtype == torch.float16 assert ed.eigendistortions.dtype == torch.float16 # can only run this one if we're on a device with CPU and GPU. - elif to_type == 'device' and DEVICE.type != 'cpu': - ed.to('cpu') + elif to_type == "device" and DEVICE.type != "cpu": + ed.to("cpu") ed.eigendistortions - ed.image - @pytest.mark.skipif(DEVICE.type == 'cpu', reason="Only makes sense to test on cuda") - @pytest.mark.parametrize('model', ['Identity'], indirect=True) + @pytest.mark.skipif( + DEVICE.type == "cpu", reason="Only makes sense to test on cuda" + ) + @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_map_location(self, curie_img, model, tmp_path): curie_img = curie_img.to(DEVICE) model.to(DEVICE) ed = Eigendistortion(curie_img, model) - ed.synthesize(max_iter=4, method='power') - ed.save(op.join(tmp_path, 'test_eig_map_location.pt')) + ed.synthesize(max_iter=4, method="power") + ed.save(op.join(tmp_path, "test_eig_map_location.pt")) # calling load with map_location effectively switches everything # over to that device ed_copy = Eigendistortion(curie_img, model) - ed_copy.load(op.join(tmp_path, 'test_eig_map_location.pt'), - map_location='cpu') - assert ed_copy.eigendistortions.device.type == 'cpu' - assert ed_copy.image.device.type == 'cpu' - ed_copy.synthesize(max_iter=4, method='power') - - @pytest.mark.parametrize('model', ['Identity'], indirect=True) + ed_copy.load( + op.join(tmp_path, "test_eig_map_location.pt"), map_location="cpu" + ) + assert ed_copy.eigendistortions.device.type == "cpu" + assert ed_copy.image.device.type == "cpu" + ed_copy.synthesize(max_iter=4, method="power") + + @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_change_precision_save_load(self, einstein_img, model, tmp_path): # Identity model doesn't change when you call .to() with a dtype # (unlike those models that have weights) so we use it here @@ -210,24 +257,26 @@ def test_change_precision_save_load(self, einstein_img, model, tmp_path): ed.synthesize(max_iter=5) ed.to(torch.float64) assert ed.image.dtype == torch.float64, "dtype incorrect!" - ed.save(op.join(tmp_path, 'test_change_prec_save_load.pt')) + ed.save(op.join(tmp_path, "test_change_prec_save_load.pt")) ed_copy = Eigendistortion(einstein_img.to(torch.float64), model) - ed_copy.load(op.join(tmp_path, 'test_change_prec_save_load.pt')) + ed_copy.load(op.join(tmp_path, "test_change_prec_save_load.pt")) ed_copy.synthesize(max_iter=5) assert ed_copy.image.dtype == torch.float64, "dtype incorrect!" + class TestAutodiffFunctions: - @pytest.fixture(scope='class') + @pytest.fixture(scope="class") def state(self, einstein_img): """variables to be reused across tests in this class""" k = 2 # num vectors with which to compute vjp, jvp, Fv - einstein_img = einstein_img[..., 100:100+16, 100:100+16] # reduce image size + einstein_img = einstein_img[ + ..., 100 : 100 + 16, 100 : 100 + 16 + ] # reduce image size # eigendistortion object - ed = Eigendistortion(einstein_img, get_model('frontend.OnOff.nograd')) - + ed = Eigendistortion(einstein_img, get_model("frontend.OnOff.nograd")) x, y = ed._image_flat, ed._representation_flat @@ -243,7 +292,7 @@ def test_jacobian(self, state): assert jac.shape == (y_dim, x_dim) assert jac.requires_grad is False - @pytest.mark.parametrize('detach', [False, True]) + @pytest.mark.parametrize("detach", [False, True]) def test_vec_jac_prod(self, state, detach): x, y, x_dim, y_dim, k = state @@ -267,7 +316,9 @@ def test_jac_vec_prod(self, state): def test_fisher_vec_prod(self, state): x, y, x_dim, y_dim, k = state - V, _ = torch.linalg.qr(torch.ones((x_dim, k), device=DEVICE), "reduced") + V, _ = torch.linalg.qr( + torch.ones((x_dim, k), device=DEVICE), "reduced" + ) U = V.clone() Jv = autodiff.jacobian_vector_product(y, x, V) Fv = autodiff.vector_jacobian_product(y, x, Jv) @@ -277,11 +328,11 @@ def test_fisher_vec_prod(self, state): Fv2 = jac.T @ jac @ U # manually compute product to compare accuracy assert Fv.shape == (x_dim, k) - assert Fv2.allclose(Fv, atol=1E-6) + assert Fv2.allclose(Fv, atol=1e-6) def test_simple_model_eigenvalues(self): """Test if Jacobian is constant in all directions for linear model""" - singular_value = torch.ones(1, device=DEVICE) * 3. + singular_value = torch.ones(1, device=DEVICE) * 3.0 class LM(nn.Module): """Simple y = Mx where M=3""" @@ -309,4 +360,4 @@ def forward(self, x): x, y = e._image_flat, e._representation_flat Jv = autodiff.jacobian_vector_product(y, x, V) Fv = autodiff.vector_jacobian_product(y, x, Jv) - assert torch.diag(V.T @ Fv).sqrt().allclose(singular_value, rtol=1E-3) + assert torch.diag(V.T @ Fv).sqrt().allclose(singular_value, rtol=1e-3) diff --git a/tests/test_geodesic.py b/tests/test_geodesic.py index 70acdfb2..8ef5a6cc 100644 --- a/tests/test_geodesic.py +++ b/tests/test_geodesic.py @@ -19,75 +19,107 @@ def test_deviation_from_line_and_brownian_bridge(self): sqrt_d = int(np.sqrt(d)) start = torch.randn(1, d).reshape(1, 1, sqrt_d, sqrt_d).to(DEVICE) stop = torch.randn(1, d).reshape(1, 1, sqrt_d, sqrt_d).to(DEVICE) - b = po.tools.sample_brownian_bridge(start, stop, - t, d**.5) + b = po.tools.sample_brownian_bridge(start, stop, t, d**0.5) a, f = po.tools.deviation_from_line(b, normalize=True) - assert torch.abs(a[t//2] - .5) < 1e-2, f"{a[t//2]}" - assert torch.abs(f[t//2] - 2**.5/2) < 1e-2, f"{f[t//2]}" + assert torch.abs(a[t // 2] - 0.5) < 1e-2, f"{a[t//2]}" + assert torch.abs(f[t // 2] - 2**0.5 / 2) < 1e-2, f"{f[t//2]}" @pytest.mark.parametrize("normalize", [True, False]) def test_deviation_from_line_multichannel(self, normalize, einstein_img): einstein_img = einstein_img.repeat(1, 3, 1, 1) seq = po.tools.translation_sequence(einstein_img) dist_along, dist_from = po.tools.deviation_from_line(seq, normalize) - assert dist_along.shape[0] == seq.shape[0], "Distance along line has wrong number of transitions!" - assert dist_from.shape[0] == seq.shape[0], "Distance from line has wrong number of transitions!" + assert ( + dist_along.shape[0] == seq.shape[0] + ), "Distance along line has wrong number of transitions!" + assert ( + dist_from.shape[0] == seq.shape[0] + ), "Distance from line has wrong number of transitions!" @pytest.mark.parametrize("n_steps", [1, 10]) @pytest.mark.parametrize("max_norm", [0, 1, 10]) @pytest.mark.parametrize("multichannel", [False, True]) - def test_brownian_bridge(self, einstein_img, curie_img, n_steps, multichannel, max_norm): + def test_brownian_bridge( + self, einstein_img, curie_img, n_steps, multichannel, max_norm + ): if multichannel: einstein_img = einstein_img.repeat(1, 3, 1, 1) curie_img = curie_img.repeat(1, 3, 1, 1) - bridge = po.tools.sample_brownian_bridge(einstein_img, curie_img, n_steps, max_norm) - assert bridge.shape == (n_steps+1, *einstein_img.shape[1:]), "sample_brownian_bridge returned a tensor of the wrong shape!" + bridge = po.tools.sample_brownian_bridge( + einstein_img, curie_img, n_steps, max_norm + ) + assert bridge.shape == ( + n_steps + 1, + *einstein_img.shape[1:], + ), "sample_brownian_bridge returned a tensor of the wrong shape!" - @pytest.mark.parametrize("fail", ['batch', 'same_shape', 'n_steps', 'max_norm']) + @pytest.mark.parametrize( + "fail", ["batch", "same_shape", "n_steps", "max_norm"] + ) def test_brownian_bridge_fail(self, einstein_img, curie_img, fail): n_steps = 2 max_norm = 1 - if fail == 'batch': + if fail == "batch": einstein_img = einstein_img.repeat(2, 1, 1, 1) curie_img = curie_img.repeat(2, 1, 1, 1) - expectation = pytest.raises(ValueError, match="input_tensor batch dimension must be 1") - elif fail == 'same_shape': + expectation = pytest.raises( + ValueError, match="input_tensor batch dimension must be 1" + ) + elif fail == "same_shape": # rand_like preserves DEVICE and dtype curie_img = torch.rand_like(curie_img)[..., :128, :128] - expectation = pytest.raises(ValueError, match="start and stop must be same shape") - elif fail == 'n_steps': + expectation = pytest.raises( + ValueError, match="start and stop must be same shape" + ) + elif fail == "n_steps": n_steps = 0 - expectation = pytest.raises(ValueError, match="n_steps must be positive") - elif fail == 'max_norm': + expectation = pytest.raises( + ValueError, match="n_steps must be positive" + ) + elif fail == "max_norm": max_norm = -1 - expectation = pytest.raises(ValueError, match="max_norm must be non-negative") + expectation = pytest.raises( + ValueError, match="max_norm must be non-negative" + ) with expectation: - po.tools.sample_brownian_bridge(einstein_img, curie_img, n_steps, max_norm) + po.tools.sample_brownian_bridge( + einstein_img, curie_img, n_steps, max_norm + ) @pytest.mark.parametrize("n_steps", [1, 10]) @pytest.mark.parametrize("multichannel", [False, True]) - def test_straight_line(self, einstein_img, curie_img, n_steps, multichannel): + def test_straight_line( + self, einstein_img, curie_img, n_steps, multichannel + ): if multichannel: einstein_img = einstein_img.repeat(1, 3, 1, 1) curie_img = curie_img.repeat(1, 3, 1, 1) - line = po.tools.make_straight_line(einstein_img, curie_img, - n_steps) - assert line.shape == (n_steps+1, *einstein_img.shape[1:]), "make_straight_line returned a tensor of the wrong shape!" + line = po.tools.make_straight_line(einstein_img, curie_img, n_steps) + assert line.shape == ( + n_steps + 1, + *einstein_img.shape[1:], + ), "make_straight_line returned a tensor of the wrong shape!" - @pytest.mark.parametrize("fail", ['batch', 'same_shape', 'n_steps']) + @pytest.mark.parametrize("fail", ["batch", "same_shape", "n_steps"]) def test_straight_line_fail(self, einstein_img, curie_img, fail): n_steps = 2 - if fail == 'batch': + if fail == "batch": einstein_img = einstein_img.repeat(2, 1, 1, 1) curie_img = curie_img.repeat(2, 1, 1, 1) - expectation = pytest.raises(ValueError, match="input_tensor batch dimension must be 1") - elif fail == 'same_shape': + expectation = pytest.raises( + ValueError, match="input_tensor batch dimension must be 1" + ) + elif fail == "same_shape": # rand_like preserves DEVICE and dtype curie_img = torch.rand_like(curie_img)[..., :128, :128] - expectation = pytest.raises(ValueError, match="start and stop must be same shape") - elif fail == 'n_steps': + expectation = pytest.raises( + ValueError, match="start and stop must be same shape" + ) + elif fail == "n_steps": n_steps = 0 - expectation = pytest.raises(ValueError, match="n_steps must be positive") + expectation = pytest.raises( + ValueError, match="n_steps must be positive" + ) with expectation: po.tools.make_straight_line(einstein_img, curie_img, n_steps) @@ -95,213 +127,342 @@ def test_straight_line_fail(self, einstein_img, curie_img, fail): @pytest.mark.parametrize("multichannel", [False, True]) def test_translation_sequence(self, einstein_img, n_steps, multichannel): if n_steps == 0: - expectation = pytest.raises(ValueError, match="n_steps must be positive") + expectation = pytest.raises( + ValueError, match="n_steps must be positive" + ) else: expectation = does_not_raise() if multichannel: einstein_img = einstein_img.repeat(1, 3, 1, 1) with expectation: shifted = po.tools.translation_sequence(einstein_img, n_steps) - assert torch.equal(shifted[0], einstein_img[0]), "somehow first frame changed!" - assert torch.equal(shifted[1, 0, :, 1], shifted[0, 0, :, 0]), "wrong dimension was translated!" + assert torch.equal( + shifted[0], einstein_img[0] + ), "somehow first frame changed!" + assert torch.equal( + shifted[1, 0, :, 1], shifted[0, 0, :, 0] + ), "wrong dimension was translated!" - @pytest.mark.parametrize("func", ['make_straight_line', 'translation_sequence', - 'sample_brownian_bridge', 'deviation_from_line']) + @pytest.mark.parametrize( + "func", + [ + "make_straight_line", + "translation_sequence", + "sample_brownian_bridge", + "deviation_from_line", + ], + ) def test_preserve_device(self, einstein_img, func): kwargs = {} - if func != 'deviation_from_line': - kwargs['n_steps'] = 5 - if func != 'translation_sequence': - kwargs['stop'] = torch.rand_like(einstein_img) + if func != "deviation_from_line": + kwargs["n_steps"] = 5 + if func != "translation_sequence": + kwargs["stop"] = torch.rand_like(einstein_img) seq = getattr(po.tools, func)(einstein_img, **kwargs) # kinda hacky -- deviation_from_line returns a tuple, all the others # return a 4d tensor. regardless seq[0] will be a tensor - assert seq[0].device == einstein_img.device, f'{func} changed device!' + assert seq[0].device == einstein_img.device, f"{func} changed device!" + class TestGeodesic(object): - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) @pytest.mark.parametrize("init", ["straight", "bridge"]) @pytest.mark.parametrize("optimizer", [None, "SGD"]) @pytest.mark.parametrize("n_steps", [5, 10]) - def test_texture(self, einstein_img_small, model, init, optimizer, n_steps): + def test_texture( + self, einstein_img_small, model, init, optimizer, n_steps + ): sequence = po.tools.translation_sequence(einstein_img_small, n_steps) - moog = po.synth.Geodesic(sequence[:1], sequence[-1:], - model, n_steps, init) + moog = po.synth.Geodesic( + sequence[:1], sequence[-1:], model, n_steps, init + ) if optimizer == "SGD": - optimizer = torch.optim.SGD([moog._geodesic], lr=.01) + optimizer = torch.optim.SGD([moog._geodesic], lr=0.01) moog.synthesize(max_iter=5, optimizer=optimizer) po.synth.geodesic.plot_loss(moog) - po.synth.geodesic.plot_deviation_from_line(moog, natural_video=sequence) + po.synth.geodesic.plot_deviation_from_line( + moog, natural_video=sequence + ) moog.calculate_jerkiness() - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_endpoints_dont_change(self, einstein_small_seq, model): - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], - model, 5, 'straight') + moog = po.synth.Geodesic( + einstein_small_seq[:1], + einstein_small_seq[-1:], + model, + 5, + "straight", + ) moog.synthesize(max_iter=5) - assert torch.equal(moog.geodesic[0], einstein_small_seq[0]), "Somehow first endpoint changed!" - assert torch.equal(moog.geodesic[-1], einstein_small_seq[-1]), "Somehow last endpoint changed!" - assert not torch.equal(moog.pixelfade[1:-1], moog.geodesic[1:-1]), "Somehow middle of geodesic didn't changed!" + assert torch.equal( + moog.geodesic[0], einstein_small_seq[0] + ), "Somehow first endpoint changed!" + assert torch.equal( + moog.geodesic[-1], einstein_small_seq[-1] + ), "Somehow last endpoint changed!" + assert not torch.equal( + moog.pixelfade[1:-1], moog.geodesic[1:-1] + ), "Somehow middle of geodesic didn't changed!" - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) - @pytest.mark.parametrize('fail', [False, 'img_a', 'img_b', 'model', 'n_steps', 'init', - 'range_penalty']) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) + @pytest.mark.parametrize( + "fail", + [False, "img_a", "img_b", "model", "n_steps", "init", "range_penalty"], + ) def test_save_load(self, einstein_small_seq, model, fail, tmp_path): img_a = einstein_small_seq[:1] img_b = einstein_small_seq[-1:] n_steps = 3 - init = 'straight' + init = "straight" range_penalty = 0 - moog = po.synth.Geodesic(img_a, img_b, model, n_steps, init, range_penalty_lambda=range_penalty) + moog = po.synth.Geodesic( + img_a, + img_b, + model, + n_steps, + init, + range_penalty_lambda=range_penalty, + ) moog.synthesize(max_iter=4) - moog.save(op.join(tmp_path, 'test_geodesic_save_load.pt')) + moog.save(op.join(tmp_path, "test_geodesic_save_load.pt")) if fail: - if fail == 'img_a': + if fail == "img_a": img_a = torch.rand_like(img_a) - expectation = pytest.raises(ValueError, match='Saved and initialized image_a are different') - elif fail == 'img_b': + expectation = pytest.raises( + ValueError, + match="Saved and initialized image_a are different", + ) + elif fail == "img_b": img_b = torch.rand_like(img_b) - expectation = pytest.raises(ValueError, match='Saved and initialized image_b are different') - elif fail == 'model': + expectation = pytest.raises( + ValueError, + match="Saved and initialized image_b are different", + ) + elif fail == "model": model = po.simul.Gaussian(30).to(DEVICE) po.tools.remove_grad(model) - expectation = pytest.raises(ValueError, match='objective_function on pixelfade of saved') - elif fail == 'n_steps': + expectation = pytest.raises( + ValueError, + match="objective_function on pixelfade of saved", + ) + elif fail == "n_steps": n_steps = 5 - expectation = pytest.raises(ValueError, match='Saved and initialized n_steps are different') - elif fail == 'init': - init = 'bridge' - expectation = pytest.raises(ValueError, match='Saved and initialized initial_sequence are different') - elif fail == 'range_penalty': - range_penalty = .5 - expectation = pytest.raises(ValueError, match='Saved and initialized range_penalty_lambda are different') - moog_copy = po.synth.Geodesic(img_a, img_b, model, n_steps, init, - range_penalty_lambda=range_penalty) + expectation = pytest.raises( + ValueError, + match="Saved and initialized n_steps are different", + ) + elif fail == "init": + init = "bridge" + expectation = pytest.raises( + ValueError, + match=( + "Saved and initialized initial_sequence are different" + ), + ) + elif fail == "range_penalty": + range_penalty = 0.5 + expectation = pytest.raises( + ValueError, + match=( + "Saved and initialized range_penalty_lambda are" + " different" + ), + ) + moog_copy = po.synth.Geodesic( + img_a, + img_b, + model, + n_steps, + init, + range_penalty_lambda=range_penalty, + ) with expectation: - moog_copy.load(op.join(tmp_path, "test_geodesic_save_load.pt"), - map_location=DEVICE) + moog_copy.load( + op.join(tmp_path, "test_geodesic_save_load.pt"), + map_location=DEVICE, + ) else: - moog_copy = po.synth.Geodesic(img_a, img_b, model, n_steps, init, - range_penalty_lambda=range_penalty) - moog_copy.load(op.join(tmp_path, "test_geodesic_save_load.pt"), - map_location=DEVICE) - for k in ['image_a', 'image_b', 'pixelfade', 'geodesic']: - if not getattr(moog, k).allclose(getattr(moog_copy, k), rtol=1e-2): - raise ValueError(f"Something went wrong with saving and loading! {k} not the same") + moog_copy = po.synth.Geodesic( + img_a, + img_b, + model, + n_steps, + init, + range_penalty_lambda=range_penalty, + ) + moog_copy.load( + op.join(tmp_path, "test_geodesic_save_load.pt"), + map_location=DEVICE, + ) + for k in ["image_a", "image_b", "pixelfade", "geodesic"]: + if not getattr(moog, k).allclose( + getattr(moog_copy, k), rtol=1e-2 + ): + raise ValueError( + "Something went wrong with saving and loading!" + f" {k} not the same" + ) # check that can resume moog_copy.synthesize(max_iter=4) - @pytest.mark.skipif(DEVICE.type == 'cpu', reason="Only makes sense to test on cuda") - @pytest.mark.parametrize('model', ['Identity'], indirect=True) + @pytest.mark.skipif( + DEVICE.type == "cpu", reason="Only makes sense to test on cuda" + ) + @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_map_location(self, einstein_small_seq, model, tmp_path): - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], model) + moog = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model + ) moog.synthesize(max_iter=4, store_progress=True) - moog.save(op.join(tmp_path, 'test_geodesic_map_location.pt')) + moog.save(op.join(tmp_path, "test_geodesic_map_location.pt")) # calling load with map_location effectively switches everything # over to that device - moog_copy = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], model) - moog_copy.load(op.join(tmp_path, 'test_geodesic_map_location.pt'), - map_location='cpu') - assert moog_copy.geodesic.device.type == 'cpu' - assert moog_copy.image_a.device.type == 'cpu' + moog_copy = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model + ) + moog_copy.load( + op.join(tmp_path, "test_geodesic_map_location.pt"), + map_location="cpu", + ) + assert moog_copy.geodesic.device.type == "cpu" + assert moog_copy.image_a.device.type == "cpu" moog_copy.synthesize(max_iter=4, store_progress=True) - @pytest.mark.parametrize('model', ['Identity'], indirect=True) - @pytest.mark.parametrize('to_type', ['dtype', 'device']) + @pytest.mark.parametrize("model", ["Identity"], indirect=True) + @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, einstein_small_seq, model, to_type): - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], model) + moog = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model + ) moog.synthesize(max_iter=5) - if to_type == 'dtype': + if to_type == "dtype": moog.to(torch.float16) assert moog.image_a.dtype == torch.float16 assert moog.geodesic.dtype == torch.float16 # can only run this one if we're on a device with CPU and GPU. - elif to_type == 'device' and DEVICE.type != 'cpu': - moog.to('cpu') + elif to_type == "device" and DEVICE.type != "cpu": + moog.to("cpu") moog.geodesic - moog.image_a - @pytest.mark.parametrize('model', ['Identity'], indirect=True) - def test_change_precision_save_load(self, einstein_small_seq, model, tmp_path): + @pytest.mark.parametrize("model", ["Identity"], indirect=True) + def test_change_precision_save_load( + self, einstein_small_seq, model, tmp_path + ): # Identity model doesn't change when you call .to() with a dtype # (unlike those models that have weights) so we use it here - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], model) + moog = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model + ) moog.synthesize(max_iter=5) moog.to(torch.float64) assert moog.geodesic.dtype == torch.float64, "dtype incorrect!" - moog.save(op.join(tmp_path, 'test_change_prec_save_load.pt')) + moog.save(op.join(tmp_path, "test_change_prec_save_load.pt")) seq = einstein_small_seq.to(torch.float64) moog_copy = po.synth.Geodesic(seq[:1], seq[-1:], model) - moog_copy.load(op.join(tmp_path, 'test_change_prec_save_load.pt')) + moog_copy.load(op.join(tmp_path, "test_change_prec_save_load.pt")) moog_copy.synthesize(max_iter=5) assert moog_copy.geodesic.dtype == torch.float64, "dtype incorrect!" # this determines whether we mix across channels or treat them separately, # both of which are supported - @pytest.mark.parametrize('model', ['ColorModel', 'Identity'], indirect=True) + @pytest.mark.parametrize( + "model", ["ColorModel", "Identity"], indirect=True + ) def test_multichannel(self, color_img, model): img = color_img[..., :64, :64] seq = po.tools.translation_sequence(img, 5) - moog = po.synth.Geodesic(seq[:1], seq[-1:], - model, 5) + moog = po.synth.Geodesic(seq[:1], seq[-1:], model, 5) moog.synthesize(max_iter=5) - assert moog.geodesic.shape[1:] == img.shape[1:], "Geodesic image should have same number of channels, height, width shape as input!" + assert moog.geodesic.shape[1:] == img.shape[1:], ( + "Geodesic image should have same number of channels, height, width" + " shape as input!" + ) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) - @pytest.mark.parametrize("func", ['objective_function', 'calculate_jerkiness']) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) + @pytest.mark.parametrize( + "func", ["objective_function", "calculate_jerkiness"] + ) def test_funcs_external_tensor(self, einstein_small_seq, model, func): - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], - model, 5) + moog = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model, 5 + ) no_arg = getattr(moog, func)() arg_tensor = torch.rand_like(moog.geodesic) # calculate jerkiness requires tensor to have gradient attached # (because we use autodiff functions) - if func == 'calculate_jerkiness': + if func == "calculate_jerkiness": arg_tensor.requires_grad_() with_arg = getattr(moog, func)(arg_tensor) - assert not torch.equal(no_arg, with_arg), f"{func} is not using the input tensor!" + assert not torch.equal( + no_arg, with_arg + ), f"{func} is not using the input tensor!" - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_continue(self, einstein_small_seq, model): - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], - model, 5) + moog = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model, 5 + ) moog.synthesize(max_iter=3, store_progress=True) moog.synthesize(max_iter=3, store_progress=True) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_nan_loss(self, model, einstein_small_seq): # clone to prevent NaN from showing up in other tests seq = einstein_small_seq.clone() moog = po.synth.Geodesic(seq[:1], seq[-1:], model, 5) moog.synthesize(max_iter=5) moog.image_a[..., 0, 0] = torch.nan - with pytest.raises(ValueError, match='Found a NaN in loss during optimization'): + with pytest.raises( + ValueError, match="Found a NaN in loss during optimization" + ): moog.synthesize(max_iter=1) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) - @pytest.mark.parametrize('store_progress', [True, 2, 3]) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) + @pytest.mark.parametrize("store_progress", [True, 2, 3]) def test_store_progress(self, einstein_small_seq, model, store_progress): - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], - model, 5) + moog = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model, 5 + ) max_iter = 3 if store_progress == 3: max_iter = 6 moog.synthesize(max_iter=max_iter, store_progress=store_progress) - assert len(moog.step_energy) == np.ceil(max_iter/store_progress), "Didn't end up with enough step_energy after first synth!" - assert len(moog.dev_from_line) == np.ceil(max_iter/store_progress), "Didn't end up with enough dev_from_line after first synth!" - assert len(moog.losses) == max_iter, "Didn't end up with enough losses after first synth!" + assert len(moog.step_energy) == np.ceil( + max_iter / store_progress + ), "Didn't end up with enough step_energy after first synth!" + assert len(moog.dev_from_line) == np.ceil( + max_iter / store_progress + ), "Didn't end up with enough dev_from_line after first synth!" + assert ( + len(moog.losses) == max_iter + ), "Didn't end up with enough losses after first synth!" moog.synthesize(max_iter=max_iter, store_progress=store_progress) - assert len(moog.step_energy) == np.ceil(2*max_iter/store_progress), "Didn't end up with enough step_energy after second synth!" - assert len(moog.dev_from_line) == np.ceil(2*max_iter/store_progress), "Didn't end up with enough dev_from_line after second synth!" - assert len(moog.losses) == 2*max_iter, "Didn't end up with enough losses after second synth!" + assert len(moog.step_energy) == np.ceil( + 2 * max_iter / store_progress + ), "Didn't end up with enough step_energy after second synth!" + assert len(moog.dev_from_line) == np.ceil( + 2 * max_iter / store_progress + ), "Didn't end up with enough dev_from_line after second synth!" + assert ( + len(moog.losses) == 2 * max_iter + ), "Didn't end up with enough losses after second synth!" - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_stop_criterion(self, einstein_small_seq, model): # checking that this hits the criterion and stops early, so set seed # for reproducibility po.tools.set_seed(0) - moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], - model, 5) - moog.synthesize(max_iter=10, stop_criterion=.06, stop_iters_to_check=1) - assert (abs(moog.pixel_change_norm[-1:]) < .06).all(), "Didn't stop when hit criterion!" - assert (abs(moog.pixel_change_norm[:-1]) > .06).all(), "Stopped after hit criterion!" + moog = po.synth.Geodesic( + einstein_small_seq[:1], einstein_small_seq[-1:], model, 5 + ) + moog.synthesize( + max_iter=10, stop_criterion=0.06, stop_iters_to_check=1 + ) + assert ( + abs(moog.pixel_change_norm[-1:]) < 0.06 + ).all(), "Didn't stop when hit criterion!" + assert ( + abs(moog.pixel_change_norm[:-1]) > 0.06 + ).all(), "Stopped after hit criterion!" diff --git a/tests/test_mad.py b/tests/test_mad.py index 06a8d4b8..20be1ecc 100644 --- a/tests/test_mad.py +++ b/tests/test_mad.py @@ -1,9 +1,10 @@ # necessary to avoid issues with animate: # https://github.com/matplotlib/matplotlib/issues/10287/ import matplotlib as mpl + # use the html backend, so we don't need to have ffmpeg -mpl.rcParams['animation.writer'] = 'html' -mpl.use('agg') +mpl.rcParams["animation.writer"] = "html" +mpl.use("agg") import pytest import plenoptic as po import torch @@ -30,14 +31,14 @@ def dis_ssim(*args): class TestMAD(object): - @pytest.mark.parametrize('target', ['min', 'max']) - @pytest.mark.parametrize('model_order', ['mse-ssim', 'ssim-mse']) - @pytest.mark.parametrize('store_progress', [False, True, 2]) + @pytest.mark.parametrize("target", ["min", "max"]) + @pytest.mark.parametrize("model_order", ["mse-ssim", "ssim-mse"]) + @pytest.mark.parametrize("store_progress", [False, True, 2]) def test_basic(self, curie_img, target, model_order, store_progress): - if model_order == 'mse-ssim': + if model_order == "mse-ssim": model = po.metric.mse model2 = dis_ssim - elif model_order == 'ssim-mse': + elif model_order == "ssim-mse": model = dis_ssim model2 = po.metric.mse mad = po.synth.MADCompetition(curie_img, model, model2, target) @@ -45,9 +46,10 @@ def test_basic(self, curie_img, target, model_order, store_progress): if store_progress: mad.synthesize(max_iter=5, store_progress=store_progress) - @pytest.mark.parametrize('fail', [False, 'img', 'metric1', 'metric2', 'target', - 'tradeoff']) - @pytest.mark.parametrize('rgb', [False, True]) + @pytest.mark.parametrize( + "fail", [False, "img", "metric1", "metric2", "target", "tradeoff"] + ) + @pytest.mark.parametrize("rgb", [False, True]) def test_save_load(self, curie_img, fail, rgb, tmp_path): # this works with either rgb or grayscale images metric = rgb_mse @@ -56,91 +58,139 @@ def test_save_load(self, curie_img, fail, rgb, tmp_path): metric2 = rgb_l2_norm else: metric2 = dis_ssim - target = 'min' + target = "min" tradeoff = 1 - mad = po.synth.MADCompetition(curie_img, metric, metric2, target, - metric_tradeoff_lambda=tradeoff) + mad = po.synth.MADCompetition( + curie_img, metric, metric2, target, metric_tradeoff_lambda=tradeoff + ) mad.synthesize(max_iter=4, store_progress=True) - mad.save(op.join(tmp_path, 'test_mad_save_load.pt')) + mad.save(op.join(tmp_path, "test_mad_save_load.pt")) if fail: - if fail == 'img': + if fail == "img": curie_img = torch.rand_like(curie_img) - expectation = pytest.raises(ValueError, match='Saved and initialized image are different') - elif fail == 'metric1': + expectation = pytest.raises( + ValueError, + match="Saved and initialized image are different", + ) + elif fail == "metric1": # this works with either rgb or grayscale images (though note # that SSIM just operates on each RGB channel independently, # which is probably not the right thing to do) metric = dis_ssim - expectation = pytest.raises(ValueError, match='Saved and initialized optimized_metric are different') - elif fail == 'metric2': + expectation = pytest.raises( + ValueError, + match=( + "Saved and initialized optimized_metric are different" + ), + ) + elif fail == "metric2": # this works with either rgb or grayscale images metric2 = rgb_mse - expectation = pytest.raises(ValueError, match='Saved and initialized reference_metric are different') - elif fail == 'target': - target = 'max' - expectation = pytest.raises(ValueError, match='Saved and initialized minmax are different') - elif fail == 'tradeoff': + expectation = pytest.raises( + ValueError, + match=( + "Saved and initialized reference_metric are different" + ), + ) + elif fail == "target": + target = "max" + expectation = pytest.raises( + ValueError, + match="Saved and initialized minmax are different", + ) + elif fail == "tradeoff": tradeoff = 10 - expectation = pytest.raises(ValueError, match='Saved and initialized metric_tradeoff_lambda are different') - mad_copy = po.synth.MADCompetition(curie_img, metric, metric2, - target, metric_tradeoff_lambda=tradeoff) + expectation = pytest.raises( + ValueError, + match=( + "Saved and initialized metric_tradeoff_lambda are" + " different" + ), + ) + mad_copy = po.synth.MADCompetition( + curie_img, + metric, + metric2, + target, + metric_tradeoff_lambda=tradeoff, + ) with expectation: - mad_copy.load(op.join(tmp_path, "test_mad_save_load.pt"), - map_location=DEVICE) + mad_copy.load( + op.join(tmp_path, "test_mad_save_load.pt"), + map_location=DEVICE, + ) else: - mad_copy = po.synth.MADCompetition(curie_img, metric, metric2, target, - metric_tradeoff_lambda=tradeoff) - mad_copy.load(op.join(tmp_path, "test_mad_save_load.pt"), map_location=DEVICE) + mad_copy = po.synth.MADCompetition( + curie_img, + metric, + metric2, + target, + metric_tradeoff_lambda=tradeoff, + ) + mad_copy.load( + op.join(tmp_path, "test_mad_save_load.pt"), map_location=DEVICE + ) # check that can resume mad_copy.synthesize(max_iter=5, store_progress=True) if rgb: # since this is a fixture, get this back to a grayscale image curie_img = curie_img.mean(1, True) - @pytest.mark.parametrize('optimizer', ['Adam', None, 'Scheduler']) + @pytest.mark.parametrize("optimizer", ["Adam", None, "Scheduler"]) def test_optimizer_opts(self, curie_img, optimizer): - mad = po.synth.MADCompetition(curie_img, po.metric.mse, - lambda *args: 1-po.metric.ssim(*args), - 'min') + mad = po.synth.MADCompetition( + curie_img, + po.metric.mse, + lambda *args: 1 - po.metric.ssim(*args), + "min", + ) scheduler = None - if optimizer == 'Adam' or optimizer == 'Scheduler': + if optimizer == "Adam" or optimizer == "Scheduler": optimizer = torch.optim.Adam([mad.mad_image]) - if optimizer == 'Scheduler': - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer) + if optimizer == "Scheduler": + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( + optimizer + ) mad.synthesize(max_iter=5, optimizer=optimizer, scheduler=scheduler) - @pytest.mark.parametrize('to_type', ['dtype', 'device']) + @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, curie_img, to_type): - mad = po.synth.MADCompetition(curie_img, po.metric.mse, - po.tools.optim.l2_norm, 'min') + mad = po.synth.MADCompetition( + curie_img, po.metric.mse, po.tools.optim.l2_norm, "min" + ) mad.synthesize(max_iter=5) - if to_type == 'dtype': + if to_type == "dtype": mad.to(torch.float16) assert mad.initial_image.dtype == torch.float16 assert mad.image.dtype == torch.float16 assert mad.mad_image.dtype == torch.float16 # can only run this one if we're on a device with CPU and GPU. - elif to_type == 'device' and DEVICE.type != 'cpu': - mad.to('cpu') + elif to_type == "device" and DEVICE.type != "cpu": + mad.to("cpu") # initial_image doesn't get used anywhere after init, so check it like # this mad.initial_image - mad.image mad.mad_image - mad.image - @pytest.mark.skipif(DEVICE.type == 'cpu', reason="Only makes sense to test on cuda") + @pytest.mark.skipif( + DEVICE.type == "cpu", reason="Only makes sense to test on cuda" + ) def test_map_location(self, curie_img, tmp_path): curie_img = curie_img - mad = po.synth.MADCompetition(curie_img, po.metric.mse, - po.tools.optim.l2_norm, 'min') + mad = po.synth.MADCompetition( + curie_img, po.metric.mse, po.tools.optim.l2_norm, "min" + ) mad.synthesize(max_iter=4, store_progress=True) - mad.save(op.join(tmp_path, 'test_mad_map_location.pt')) - curie_img = curie_img.to('cpu') - mad_copy = po.synth.MADCompetition(curie_img, po.metric.mse, - po.tools.optim.l2_norm, 'min') - assert mad_copy.image.device.type == 'cpu' - mad_copy.load(op.join(tmp_path, 'test_mad_map_location.pt'), - map_location='cpu') - assert mad_copy.mad_image.device.type == 'cpu' + mad.save(op.join(tmp_path, "test_mad_map_location.pt")) + curie_img = curie_img.to("cpu") + mad_copy = po.synth.MADCompetition( + curie_img, po.metric.mse, po.tools.optim.l2_norm, "min" + ) + assert mad_copy.image.device.type == "cpu" + mad_copy.load( + op.join(tmp_path, "test_mad_map_location.pt"), map_location="cpu" + ) + assert mad_copy.mad_image.device.type == "cpu" mad_copy.synthesize(max_iter=4, store_progress=True) # MAD can accept multiple images on the batch dimension, but the metrics @@ -149,55 +199,90 @@ def test_map_location(self, curie_img, tmp_path): # images in parallel def test_batch_synthesis(self, curie_img, einstein_img): img = torch.cat([curie_img, einstein_img], dim=0) - mad = po.synth.MADCompetition(img, lambda *args: po.metric.mse(*args).mean(), - po.tools.optim.l2_norm, 'min') + mad = po.synth.MADCompetition( + img, + lambda *args: po.metric.mse(*args).mean(), + po.tools.optim.l2_norm, + "min", + ) mad.synthesize(max_iter=10) - assert mad.mad_image.shape == img.shape, "MAD image should have the same shape as input!" + assert ( + mad.mad_image.shape == img.shape + ), "MAD image should have the same shape as input!" - @pytest.mark.parametrize('store_progress', [True, 2, 3]) + @pytest.mark.parametrize("store_progress", [True, 2, 3]) def test_store_rep(self, einstein_img, store_progress): - mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, 'min') + mad = po.synth.MADCompetition( + einstein_img, po.metric.mse, dis_ssim, "min" + ) max_iter = 3 if store_progress == 3: max_iter = 6 mad.synthesize(max_iter=max_iter, store_progress=store_progress) - assert len(mad.saved_mad_image) == np.ceil(max_iter/store_progress), "Didn't end up with enough saved mad after first synth!" - assert len(mad.losses) == max_iter, "Didn't end up with enough losses after first synth!" + assert len(mad.saved_mad_image) == np.ceil( + max_iter / store_progress + ), "Didn't end up with enough saved mad after first synth!" + assert ( + len(mad.losses) == max_iter + ), "Didn't end up with enough losses after first synth!" # these have a +1 because we calculate them during initialization as # well (so we know our starting point). - assert len(mad.optimized_metric_loss) == max_iter+1, "Didn't end up with enough optimized metric losses after first synth!" - assert len(mad.reference_metric_loss) == max_iter+1, "Didn't end up with enough reference metric losses after first synth!" + assert len(mad.optimized_metric_loss) == max_iter + 1, ( + "Didn't end up with enough optimized metric losses after first" + " synth!" + ) + assert len(mad.reference_metric_loss) == max_iter + 1, ( + "Didn't end up with enough reference metric losses after first" + " synth!" + ) mad.synthesize(max_iter=max_iter, store_progress=store_progress) - assert len(mad.saved_mad_image) == np.ceil(2*max_iter/store_progress), "Didn't end up with enough saved mad after second synth!" - assert len(mad.losses) == 2*max_iter, "Didn't end up with enough losses after second synth!" - assert len(mad.optimized_metric_loss) == 2*max_iter+1, "Didn't end up with enough optimized metric losses after second synth!" - assert len(mad.reference_metric_loss) == 2*max_iter+1, "Didn't end up with enough reference metric losses after second synth!" + assert len(mad.saved_mad_image) == np.ceil( + 2 * max_iter / store_progress + ), "Didn't end up with enough saved mad after second synth!" + assert ( + len(mad.losses) == 2 * max_iter + ), "Didn't end up with enough losses after second synth!" + assert len(mad.optimized_metric_loss) == 2 * max_iter + 1, ( + "Didn't end up with enough optimized metric losses after second" + " synth!" + ) + assert len(mad.reference_metric_loss) == 2 * max_iter + 1, ( + "Didn't end up with enough reference metric losses after second" + " synth!" + ) def test_continue(self, einstein_img): - mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, 'min') + mad = po.synth.MADCompetition( + einstein_img, po.metric.mse, dis_ssim, "min" + ) mad.synthesize(max_iter=3, store_progress=True) mad.synthesize(max_iter=3, store_progress=True) def test_nan_loss(self, einstein_img): # clone to prevent NaN from showing up in other tests img = einstein_img.clone() - mad = po.synth.MADCompetition(img, po.metric.mse, dis_ssim, 'min') + mad = po.synth.MADCompetition(img, po.metric.mse, dis_ssim, "min") mad.synthesize(max_iter=5) mad.image[..., 0, 0] = torch.nan - with pytest.raises(ValueError, match='Found a NaN in loss during optimization'): + with pytest.raises( + ValueError, match="Found a NaN in loss during optimization" + ): mad.synthesize(max_iter=1) def test_change_precision_save_load(self, einstein_img, tmp_path): # Identity model doesn't change when you call .to() with a dtype # (unlike those models that have weights) so we use it here - mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, 'min') + mad = po.synth.MADCompetition( + einstein_img, po.metric.mse, dis_ssim, "min" + ) mad.synthesize(max_iter=5) mad.to(torch.float64) assert mad.mad_image.dtype == torch.float64, "dtype incorrect!" - mad.save(op.join(tmp_path, 'test_change_prec_save_load.pt')) - mad_copy = po.synth.MADCompetition(einstein_img.to(torch.float64), - po.metric.mse, dis_ssim, 'min') - mad_copy.load(op.join(tmp_path, 'test_change_prec_save_load.pt')) + mad.save(op.join(tmp_path, "test_change_prec_save_load.pt")) + mad_copy = po.synth.MADCompetition( + einstein_img.to(torch.float64), po.metric.mse, dis_ssim, "min" + ) + mad_copy.load(op.join(tmp_path, "test_change_prec_save_load.pt")) mad_copy.synthesize(max_iter=5) assert mad_copy.mad_image.dtype == torch.float64, "dtype incorrect!" @@ -205,7 +290,13 @@ def test_stop_criterion(self, einstein_img): # checking that this hits the criterion and stops early, so set seed # for reproducibility po.tools.set_seed(0) - mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, 'min') + mad = po.synth.MADCompetition( + einstein_img, po.metric.mse, dis_ssim, "min" + ) mad.synthesize(max_iter=15, stop_criterion=1e-3, stop_iters_to_check=5) - assert abs(mad.losses[-5]-mad.losses[-1]) < 1e-3, "Didn't stop when hit criterion!" - assert abs(mad.losses[-6]-mad.losses[-2]) > 1e-3, "Stopped after hit criterion!" + assert ( + abs(mad.losses[-5] - mad.losses[-1]) < 1e-3 + ), "Didn't stop when hit criterion!" + assert ( + abs(mad.losses[-6] - mad.losses[-2]) > 1e-3 + ), "Stopped after hit criterion!" diff --git a/tests/test_metamers.py b/tests/test_metamers.py index d5abf4fa..a15d5396 100644 --- a/tests/test_metamers.py +++ b/tests/test_metamers.py @@ -1,7 +1,8 @@ # necessary to avoid issues with animate: # https://github.com/matplotlib/matplotlib/issues/10287/ import matplotlib -matplotlib.use('agg') + +matplotlib.use("agg") import os.path as op import numpy as np import torch @@ -13,198 +14,308 @@ # in order for pickling to work with functions, they must be defined at top of # module: https://stackoverflow.com/a/36995008 def custom_loss(x1, x2): - return (x1-x2).sum() + return (x1 - x2).sum() class TestMetamers(object): - @pytest.mark.parametrize('model', ['frontend.LinearNonlinear.nograd'], indirect=True) - @pytest.mark.parametrize('loss_func', ['mse', 'l2', 'custom']) - @pytest.mark.parametrize('fail', [False, 'img', 'model', 'loss', 'range_penalty', 'dtype']) - @pytest.mark.parametrize('range_penalty', [.1, 0]) - def test_save_load(self, einstein_img, model, loss_func, fail, range_penalty, tmp_path): - if loss_func == 'mse': + @pytest.mark.parametrize( + "model", ["frontend.LinearNonlinear.nograd"], indirect=True + ) + @pytest.mark.parametrize("loss_func", ["mse", "l2", "custom"]) + @pytest.mark.parametrize( + "fail", [False, "img", "model", "loss", "range_penalty", "dtype"] + ) + @pytest.mark.parametrize("range_penalty", [0.1, 0]) + def test_save_load( + self, einstein_img, model, loss_func, fail, range_penalty, tmp_path + ): + if loss_func == "mse": loss = po.tools.optim.mse - elif loss_func == 'l2': + elif loss_func == "l2": loss = po.tools.optim.l2_norm - elif loss_func == 'custom': + elif loss_func == "custom": loss = custom_loss - met = po.synth.Metamer(einstein_img, model, loss_function=loss, - range_penalty_lambda=range_penalty) + met = po.synth.Metamer( + einstein_img, + model, + loss_function=loss, + range_penalty_lambda=range_penalty, + ) met.synthesize(max_iter=4, store_progress=True) - met.save(op.join(tmp_path, 'test_metamer_save_load.pt')) + met.save(op.join(tmp_path, "test_metamer_save_load.pt")) if fail: - if fail == 'img': + if fail == "img": einstein_img = torch.rand_like(einstein_img) - expectation = pytest.raises(ValueError, match='Saved and initialized image are different') - elif fail == 'model': + expectation = pytest.raises( + ValueError, + match="Saved and initialized image are different", + ) + elif fail == "model": model = po.simul.Gaussian(30).to(DEVICE) po.tools.remove_grad(model) - expectation = pytest.raises(ValueError, match='Saved and initialized target_representation are different') - elif fail == 'loss': + expectation = pytest.raises( + ValueError, + match=( + "Saved and initialized target_representation are" + " different" + ), + ) + elif fail == "loss": loss = po.metric.ssim - expectation = pytest.raises(ValueError, match='Saved and initialized loss_function are different') - elif fail == 'range_penalty': - range_penalty = .5 - expectation = pytest.raises(ValueError, match='Saved and initialized range_penalty_lambda are different') - elif fail == 'dtype': + expectation = pytest.raises( + ValueError, + match="Saved and initialized loss_function are different", + ) + elif fail == "range_penalty": + range_penalty = 0.5 + expectation = pytest.raises( + ValueError, + match=( + "Saved and initialized range_penalty_lambda are" + " different" + ), + ) + elif fail == "dtype": einstein_img = einstein_img.to(torch.float64) # need to create new instance of model, because otherwise the # version with doubles as weights will persist for other tests model = po.simul.LinearNonlinear((31, 31)).to(DEVICE) po.tools.remove_grad(model) model.to(torch.float64) - expectation = pytest.raises(RuntimeError, match='Attribute image has different dtype') - met_copy = po.synth.Metamer(einstein_img, model, - loss_function=loss, - range_penalty_lambda=range_penalty) + expectation = pytest.raises( + RuntimeError, match="Attribute image has different dtype" + ) + met_copy = po.synth.Metamer( + einstein_img, + model, + loss_function=loss, + range_penalty_lambda=range_penalty, + ) with expectation: - met_copy.load(op.join(tmp_path, "test_metamer_save_load.pt"), - map_location=DEVICE) + met_copy.load( + op.join(tmp_path, "test_metamer_save_load.pt"), + map_location=DEVICE, + ) else: - met_copy = po.synth.Metamer(einstein_img, model, - loss_function=loss, - range_penalty_lambda=range_penalty) - met_copy.load(op.join(tmp_path, "test_metamer_save_load.pt"), - map_location=DEVICE) - for k in ['image', 'saved_metamer', 'metamer', 'target_representation']: - if not getattr(met, k).allclose(getattr(met_copy, k), rtol=1e-2): - raise ValueError("Something went wrong with saving and loading! %s not the same" - % k) + met_copy = po.synth.Metamer( + einstein_img, + model, + loss_function=loss, + range_penalty_lambda=range_penalty, + ) + met_copy.load( + op.join(tmp_path, "test_metamer_save_load.pt"), + map_location=DEVICE, + ) + for k in [ + "image", + "saved_metamer", + "metamer", + "target_representation", + ]: + if not getattr(met, k).allclose( + getattr(met_copy, k), rtol=1e-2 + ): + raise ValueError( + "Something went wrong with saving and loading! %s not" + " the same" % k + ) # check loss functions correctly saved - met_loss = met.loss_function(met.model(met.metamer), - met.target_representation) - met_copy_loss = met_copy.loss_function(met.model(met.metamer), - met_copy.target_representation) - if not torch.allclose(met_loss, met_copy_loss, rtol=1E-2): - raise ValueError(f"Loss function not properly saved! Before saving was {met_loss}, " - f"after loading was {met_copy_loss}") + met_loss = met.loss_function( + met.model(met.metamer), met.target_representation + ) + met_copy_loss = met_copy.loss_function( + met.model(met.metamer), met_copy.target_representation + ) + if not torch.allclose(met_loss, met_copy_loss, rtol=1e-2): + raise ValueError( + "Loss function not properly saved! Before saving was" + f" {met_loss}, after loading was {met_copy_loss}" + ) # check that can resume - met_copy.synthesize(max_iter=4, store_progress=True,) + met_copy.synthesize( + max_iter=4, + store_progress=True, + ) - @pytest.mark.parametrize('model', ['frontend.LinearNonlinear.nograd'], indirect=True) - @pytest.mark.parametrize('store_progress', [True, 2, 3]) + @pytest.mark.parametrize( + "model", ["frontend.LinearNonlinear.nograd"], indirect=True + ) + @pytest.mark.parametrize("store_progress", [True, 2, 3]) def test_store_rep(self, einstein_img, model, store_progress): metamer = po.synth.Metamer(einstein_img, model) max_iter = 3 if store_progress == 3: max_iter = 6 metamer.synthesize(max_iter=max_iter, store_progress=store_progress) - assert len(metamer.saved_metamer) == np.ceil(max_iter/store_progress), "Didn't end up with enough saved metamer after first synth!" - assert len(metamer.losses) == max_iter, "Didn't end up with enough losses after first synth!" + assert len(metamer.saved_metamer) == np.ceil( + max_iter / store_progress + ), "Didn't end up with enough saved metamer after first synth!" + assert ( + len(metamer.losses) == max_iter + ), "Didn't end up with enough losses after first synth!" metamer.synthesize(max_iter=max_iter, store_progress=store_progress) - assert len(metamer.saved_metamer) == np.ceil(2*max_iter/store_progress), "Didn't end up with enough saved metamer after second synth!" - assert len(metamer.losses) == 2*max_iter, "Didn't end up with enough losses after second synth!" + assert len(metamer.saved_metamer) == np.ceil( + 2 * max_iter / store_progress + ), "Didn't end up with enough saved metamer after second synth!" + assert ( + len(metamer.losses) == 2 * max_iter + ), "Didn't end up with enough losses after second synth!" - @pytest.mark.parametrize('model', ['frontend.LinearNonlinear.nograd'], indirect=True) + @pytest.mark.parametrize( + "model", ["frontend.LinearNonlinear.nograd"], indirect=True + ) def test_continue(self, einstein_img, model): metamer = po.synth.Metamer(einstein_img, model) metamer.synthesize(max_iter=3, store_progress=True) metamer.synthesize(max_iter=3, store_progress=True) - @pytest.mark.parametrize('model', ['SPyr'], indirect=True) - @pytest.mark.parametrize('coarse_to_fine', ['separate', 'together']) - def test_coarse_to_fine(self, einstein_img, model, coarse_to_fine, tmp_path): - metamer = po.synth.MetamerCTF(einstein_img, model, coarse_to_fine=coarse_to_fine) - metamer.synthesize(max_iter=5, stop_iters_to_check=1, - change_scale_criterion=10, ctf_iters_to_check=1) - assert len(metamer.scales_finished) > 0, "Didn't actually switch scales!" - - metamer.save(op.join(tmp_path, 'test_metamer_ctf.pt')) - metamer_copy = po.synth.MetamerCTF(einstein_img, model, - coarse_to_fine=coarse_to_fine) - metamer_copy.load(op.join(tmp_path, "test_metamer_ctf.pt"), - map_location=DEVICE) + @pytest.mark.parametrize("model", ["SPyr"], indirect=True) + @pytest.mark.parametrize("coarse_to_fine", ["separate", "together"]) + def test_coarse_to_fine( + self, einstein_img, model, coarse_to_fine, tmp_path + ): + metamer = po.synth.MetamerCTF( + einstein_img, model, coarse_to_fine=coarse_to_fine + ) + metamer.synthesize( + max_iter=5, + stop_iters_to_check=1, + change_scale_criterion=10, + ctf_iters_to_check=1, + ) + assert ( + len(metamer.scales_finished) > 0 + ), "Didn't actually switch scales!" + + metamer.save(op.join(tmp_path, "test_metamer_ctf.pt")) + metamer_copy = po.synth.MetamerCTF( + einstein_img, model, coarse_to_fine=coarse_to_fine + ) + metamer_copy.load( + op.join(tmp_path, "test_metamer_ctf.pt"), map_location=DEVICE + ) # check the ctf-related attributes all saved correctly - for k in ['coarse_to_fine', 'scales', 'scales_loss', 'scales_timing', - 'scales_finished']: + for k in [ + "coarse_to_fine", + "scales", + "scales_loss", + "scales_timing", + "scales_finished", + ]: if not getattr(metamer, k) == (getattr(metamer_copy, k)): - raise ValueError("Something went wrong with saving and loading! %s not the same" - % k) + raise ValueError( + "Something went wrong with saving and loading! %s not the" + " same" % k + ) # check we can resume - metamer.synthesize(max_iter=5, stop_iters_to_check=1, - change_scale_criterion=10, ctf_iters_to_check=1) + metamer.synthesize( + max_iter=5, + stop_iters_to_check=1, + change_scale_criterion=10, + ctf_iters_to_check=1, + ) - @pytest.mark.parametrize('model', ['NLP'], indirect=True) - @pytest.mark.parametrize('optimizer', ['Adam', None, 'Scheduler']) + @pytest.mark.parametrize("model", ["NLP"], indirect=True) + @pytest.mark.parametrize("optimizer", ["Adam", None, "Scheduler"]) def test_optimizer(self, curie_img, model, optimizer): met = po.synth.Metamer(curie_img, model) scheduler = None - if optimizer == 'Adam' or optimizer == 'Scheduler': + if optimizer == "Adam" or optimizer == "Scheduler": optimizer = torch.optim.Adam([met.metamer]) - if optimizer == 'Scheduler': - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer) - met.synthesize(max_iter=5, optimizer=optimizer, - scheduler=scheduler) + if optimizer == "Scheduler": + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( + optimizer + ) + met.synthesize(max_iter=5, optimizer=optimizer, scheduler=scheduler) - @pytest.mark.skipif(DEVICE.type == 'cpu', reason="Only makes sense to test on cuda") - @pytest.mark.parametrize('model', ['Identity'], indirect=True) + @pytest.mark.skipif( + DEVICE.type == "cpu", reason="Only makes sense to test on cuda" + ) + @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_map_location(self, curie_img, model, tmp_path): curie_img = curie_img.to(DEVICE) model.to(DEVICE) met = po.synth.Metamer(curie_img, model) met.synthesize(max_iter=4, store_progress=True) - met.save(op.join(tmp_path, 'test_metamer_map_location.pt')) + met.save(op.join(tmp_path, "test_metamer_map_location.pt")) # calling load with map_location effectively switches everything # over to that device met_copy = po.synth.Metamer(curie_img, model) - met_copy.load(op.join(tmp_path, 'test_metamer_map_location.pt'), - map_location='cpu') - assert met_copy.metamer.device.type == 'cpu' - assert met_copy.image.device.type == 'cpu' + met_copy.load( + op.join(tmp_path, "test_metamer_map_location.pt"), + map_location="cpu", + ) + assert met_copy.metamer.device.type == "cpu" + assert met_copy.image.device.type == "cpu" met_copy.synthesize(max_iter=4, store_progress=True) - @pytest.mark.parametrize('model', ['Identity'], indirect=True) - @pytest.mark.parametrize('to_type', ['dtype', 'device']) + @pytest.mark.parametrize("model", ["Identity"], indirect=True) + @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, curie_img, model, to_type): met = po.synth.Metamer(curie_img, model) met.synthesize(max_iter=5) - if to_type == 'dtype': + if to_type == "dtype": met.to(torch.float16) assert met.image.dtype == torch.float16 assert met.metamer.dtype == torch.float16 # can only run this one if we're on a device with CPU and GPU. - elif to_type == 'device' and DEVICE.type != 'cpu': - met.to('cpu') + elif to_type == "device" and DEVICE.type != "cpu": + met.to("cpu") met.metamer - met.image # this determines whether we mix across channels or treat them separately, # both of which are supported - @pytest.mark.parametrize('model', ['ColorModel', 'Identity'], indirect=True) + @pytest.mark.parametrize( + "model", ["ColorModel", "Identity"], indirect=True + ) def test_multichannel(self, model, color_img): met = po.synth.Metamer(color_img, model) met.synthesize(max_iter=5) - assert met.metamer.shape == color_img.shape, "Metamer image should have the same shape as input!" + assert ( + met.metamer.shape == color_img.shape + ), "Metamer image should have the same shape as input!" # this determines whether we mix across batches (e.g., a video model) or # treat them separately, both of which are supported - @pytest.mark.parametrize('model', ['VideoModel', 'Identity'], indirect=True) + @pytest.mark.parametrize( + "model", ["VideoModel", "Identity"], indirect=True + ) def test_multibatch(self, model, einstein_img, curie_img): img = torch.cat([curie_img, einstein_img], dim=0) met = po.synth.Metamer(img, model) met.synthesize(max_iter=5) - assert met.metamer.shape == img.shape, "Metamer image should have the same shape as input!" + assert ( + met.metamer.shape == img.shape + ), "Metamer image should have the same shape as input!" # we assume that the target representation has no gradient attached, so # doublecheck that (validate_model should ensure this) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_rep_no_grad(self, model, einstein_img): met = po.synth.Metamer(einstein_img, model) - assert met.target_representation.grad is None, "Target representation has a gradient attached, how?" + assert ( + met.target_representation.grad is None + ), "Target representation has a gradient attached, how?" met.synthesize(max_iter=5) - assert met.target_representation.grad is None, "Target representation has a gradient attached, how?" + assert ( + met.target_representation.grad is None + ), "Target representation has a gradient attached, how?" - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_nan_loss(self, model, einstein_img): # clone to prevent NaN from showing up in other tests img = einstein_img.clone() met = po.synth.Metamer(img, model) met.synthesize(max_iter=5) met.target_representation[..., 0, 0] = torch.nan - with pytest.raises(ValueError, match='Found a NaN in loss during optimization'): + with pytest.raises( + ValueError, match="Found a NaN in loss during optimization" + ): met.synthesize(max_iter=1) - @pytest.mark.parametrize('model', ['Identity'], indirect=True) + @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_change_precision_save_load(self, model, einstein_img, tmp_path): # Identity model doesn't change when you call .to() with a dtype # (unlike those models that have weights) so we use it here @@ -212,13 +323,15 @@ def test_change_precision_save_load(self, model, einstein_img, tmp_path): met.synthesize(max_iter=5) met.to(torch.float64) assert met.metamer.dtype == torch.float64, "dtype incorrect!" - met.save(op.join(tmp_path, 'test_metamer_change_prec_save_load.pt')) + met.save(op.join(tmp_path, "test_metamer_change_prec_save_load.pt")) met_copy = po.synth.Metamer(einstein_img.to(torch.float64), model) - met_copy.load(op.join(tmp_path, 'test_metamer_change_prec_save_load.pt')) + met_copy.load( + op.join(tmp_path, "test_metamer_change_prec_save_load.pt") + ) met_copy.synthesize(max_iter=5) assert met_copy.metamer.dtype == torch.float64, "dtype incorrect!" - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_stop_criterion(self, einstein_img, model): # checking that this hits the criterion and stops early, so set seed # for reproducibility @@ -226,5 +339,9 @@ def test_stop_criterion(self, einstein_img, model): met = po.synth.Metamer(einstein_img, model) # takes different numbers of iter to converge on GPU and CPU met.synthesize(max_iter=30, stop_criterion=1e-5, stop_iters_to_check=5) - assert abs(met.losses[-5]-met.losses[-1]) < 1e-5, "Didn't stop when hit criterion!" - assert abs(met.losses[-6]-met.losses[-2]) > 1e-5, "Stopped after hit criterion!" + assert ( + abs(met.losses[-5] - met.losses[-1]) < 1e-5 + ), "Didn't stop when hit criterion!" + assert ( + abs(met.losses[-6] - met.losses[-2]) > 1e-5 + ), "Stopped after hit criterion!" diff --git a/tests/test_metric.py b/tests/test_metric.py index 04828575..36d07ec4 100644 --- a/tests/test_metric.py +++ b/tests/test_metric.py @@ -9,33 +9,38 @@ @pytest.fixture() def test_files_dir(): - return po.data.fetch_data('plenoptic-test-files.tar.gz') + return po.data.fetch_data("plenoptic-test-files.tar.gz") def test_find_files(test_files_dir): - assert os.path.exists(os.path.join(test_files_dir, 'buildSCFpyr0.mat')) + assert os.path.exists(os.path.join(test_files_dir, "buildSCFpyr0.mat")) @pytest.fixture() def ssim_images(): - return po.data.fetch_data('ssim_images.tar.gz') + return po.data.fetch_data("ssim_images.tar.gz") @pytest.fixture() def msssim_images(): - return po.data.fetch_data('msssim_images.tar.gz') + return po.data.fetch_data("msssim_images.tar.gz") @pytest.fixture() def ssim_analysis(): - ssim_analysis = po.data.fetch_data('ssim_analysis.mat') + ssim_analysis = po.data.fetch_data("ssim_analysis.mat") return sio.loadmat(ssim_analysis, squeeze_me=True) -@pytest.mark.parametrize('paths', [IMG_DIR / "mixed", IMG_DIR / "256" / 'einstein.pgm', - [IMG_DIR / "256" / "einstein.pgm", - IMG_DIR / "256" / 'curie.pgm']]) -@pytest.mark.parametrize('as_gray', [True, False]) +@pytest.mark.parametrize( + "paths", + [ + IMG_DIR / "mixed", + IMG_DIR / "256" / "einstein.pgm", + [IMG_DIR / "256" / "einstein.pgm", IMG_DIR / "256" / "curie.pgm"], + ], +) +@pytest.mark.parametrize("as_gray", [True, False]) def test_load_images(paths, as_gray): if paths == IMG_DIR / "mixed": # there are images of different sizes in here, which means we should raise @@ -44,15 +49,19 @@ def test_load_images(paths, as_gray): images = po.tools.data.load_images(paths, as_gray) else: images = po.tools.data.load_images(paths, as_gray) - assert images.ndimension() == 4, "load_images did not return a 4d tensor!" + assert ( + images.ndimension() == 4 + ), "load_images did not return a 4d tensor!" class TestPerceptualMetrics(object): - @pytest.mark.parametrize('weighted', [True, False]) + @pytest.mark.parametrize("weighted", [True, False]) def test_ssim_grad(self, einstein_img, curie_img, weighted): curie_img.requires_grad_() - assert po.metric.ssim(einstein_img, curie_img, weighted=weighted).requires_grad + assert po.metric.ssim( + einstein_img, curie_img, weighted=weighted + ).requires_grad curie_img.requires_grad_(False) def test_msssim_grad(self, einstein_img, curie_img): @@ -60,18 +69,28 @@ def test_msssim_grad(self, einstein_img, curie_img): assert po.metric.ms_ssim(einstein_img, curie_img).requires_grad curie_img.requires_grad_(False) - @pytest.mark.parametrize('func_name', ['ssim', 'ms-ssim', 'nlpd']) - @pytest.mark.parametrize('size_A', [(), (3,), (1, 1), (6, 3), (6, 1), (6, 4)]) - @pytest.mark.parametrize('size_B', [(), (3,), (1, 1), (6, 3), (3, 1), (1, 4)]) - def test_batch_handling(self, einstein_img, curie_img, func_name, size_A, size_B): - func = {'ssim': po.metric.ssim, - 'ms-ssim': po.metric.ms_ssim, - 'nlpd': po.metric.nlpd}[func_name] + @pytest.mark.parametrize("func_name", ["ssim", "ms-ssim", "nlpd"]) + @pytest.mark.parametrize( + "size_A", [(), (3,), (1, 1), (6, 3), (6, 1), (6, 4)] + ) + @pytest.mark.parametrize( + "size_B", [(), (3,), (1, 1), (6, 3), (3, 1), (1, 4)] + ) + def test_batch_handling( + self, einstein_img, curie_img, func_name, size_A, size_B + ): + func = { + "ssim": po.metric.ssim, + "ms-ssim": po.metric.ms_ssim, + "nlpd": po.metric.nlpd, + }[func_name] A = einstein_img[0, 0].repeat(*size_A, 1, 1) B = curie_img[0, 0].repeat(*size_B, 1, 1) - + if not len(size_A) == len(size_B) == 2: - with pytest.raises(Exception, match="Input images should have four dimensions"): + with pytest.raises( + Exception, match="Input images should have four dimensions" + ): func(A, B) else: tgt_size = [] @@ -82,94 +101,125 @@ def test_batch_handling(self, einstein_img, curie_img, func_name, size_A, size_B tgt_size = None break if tgt_size is None: - with pytest.raises(Exception, match="Either img1 and img2 should have the same number of " - "elements in each dimension, or one of them should be 1"): + with pytest.raises( + Exception, + match=( + "Either img1 and img2 should have the same number of" + " elements in each dimension, or one of them should" + " be 1" + ), + ): func(A, B) elif tgt_size[1] > 1: - with pytest.warns(Warning, match="computed separately for each channel"): + with pytest.warns( + Warning, match="computed separately for each channel" + ): assert func(A, B).shape == tuple(tgt_size) else: assert func(A, B).shape == tuple(tgt_size) - @pytest.mark.parametrize('mode', ['many-to-one', 'one-to-many']) + @pytest.mark.parametrize("mode", ["many-to-one", "one-to-many"]) def test_noise_independence(self, einstein_img, mode): # this makes sure that we are drawing the noise independently in the # two cases here - if mode == 'many-to-one': + if mode == "many-to-one": einstein_img = einstein_img.repeat(2, 1, 1, 1) noise_lvl = 1 - elif mode == 'one-to-many': + elif mode == "one-to-many": noise_lvl = [1, 1] noisy = po.tools.add_noise(einstein_img, noise_lvl) assert not torch.equal(*noisy) - @pytest.mark.parametrize('noise_lvl', [[1], [128], [2, 4], [2, 4, 8], [0]]) - @pytest.mark.parametrize('noise_as_tensor', [True, False]) + @pytest.mark.parametrize("noise_lvl", [[1], [128], [2, 4], [2, 4, 8], [0]]) + @pytest.mark.parametrize("noise_as_tensor", [True, False]) def test_add_noise(self, einstein_img, noise_lvl, noise_as_tensor): if noise_as_tensor: - noise_lvl = torch.as_tensor(noise_lvl, dtype=torch.float32, device=DEVICE).unsqueeze(1) + noise_lvl = torch.as_tensor( + noise_lvl, dtype=torch.float32, device=DEVICE + ).unsqueeze(1) noisy = po.tools.add_noise(einstein_img, noise_lvl).to(DEVICE) if not noise_as_tensor: # always needs to be a tensor to properly check with allclose - noise_lvl = torch.as_tensor(noise_lvl, dtype=torch.float32, device=DEVICE).unsqueeze(1) + noise_lvl = torch.as_tensor( + noise_lvl, dtype=torch.float32, device=DEVICE + ).unsqueeze(1) assert torch.allclose(po.metric.mse(einstein_img, noisy), noise_lvl) @pytest.fixture def ssim_base_img(self, ssim_images, ssim_analysis): - return po.load_images(os.path.join(ssim_images, ssim_analysis['base_img'])).to(DEVICE) - - @pytest.mark.parametrize('weighted', [True, False]) - @pytest.mark.parametrize('other_img', np.arange(1, 11)) - def test_ssim_analysis(self, weighted, other_img, ssim_images, - ssim_analysis, ssim_base_img): - mat_type = {True: 'weighted', False: 'standard'}[weighted] - other = po.load_images(os.path.join(ssim_images, f"samp{other_img}.tif")).to(DEVICE) + return po.load_images( + os.path.join(ssim_images, ssim_analysis["base_img"]) + ).to(DEVICE) + + @pytest.mark.parametrize("weighted", [True, False]) + @pytest.mark.parametrize("other_img", np.arange(1, 11)) + def test_ssim_analysis( + self, weighted, other_img, ssim_images, ssim_analysis, ssim_base_img + ): + mat_type = {True: "weighted", False: "standard"}[weighted] + other = po.load_images( + os.path.join(ssim_images, f"samp{other_img}.tif") + ).to(DEVICE) # dynamic range is 1 for these images, because po.load_images # automatically re-ranges them. They were comptued with # dynamic_range=255 in MATLAB, and by correctly setting this value, # that should be corrected for plen_val = po.metric.ssim(ssim_base_img, other, weighted) - mat_val = torch.as_tensor(ssim_analysis[mat_type][f'samp{other_img}'].astype(np.float32), device=DEVICE) + mat_val = torch.as_tensor( + ssim_analysis[mat_type][f"samp{other_img}"].astype(np.float32), + device=DEVICE, + ) # float32 precision is ~1e-6 (see `np.finfo(np.float32)`), and the # errors increase through multiplication and other operations. - print(plen_val-mat_val, plen_val, mat_val) + print(plen_val - mat_val, plen_val, mat_val) assert torch.allclose(plen_val, mat_val.view_as(plen_val), atol=1e-5) def test_msssim_analysis(self, msssim_images): # True values are defined by https://ece.uwaterloo.ca/~z70wang/research/iwssim/msssim.zip - true_values = torch.as_tensor([1.0000000, 0.9112161, 0.7699084, 0.8785111, 0.9488805], device=DEVICE) + true_values = torch.as_tensor( + [1.0000000, 0.9112161, 0.7699084, 0.8785111, 0.9488805], + device=DEVICE, + ) computed_values = torch.zeros_like(true_values) - base_img = po.load_images(os.path.join(msssim_images, "samp0.tiff")).to(DEVICE) + base_img = po.load_images( + os.path.join(msssim_images, "samp0.tiff") + ).to(DEVICE) for i in range(len(true_values)): - other_img = po.load_images(os.path.join(msssim_images, f"samp{i}.tiff")).to(DEVICE) + other_img = po.load_images( + os.path.join(msssim_images, f"samp{i}.tiff") + ).to(DEVICE) computed_values[i] = po.metric.ms_ssim(base_img, other_img) assert torch.allclose(true_values, computed_values) def test_nlpd_grad(self, einstein_img, curie_img): curie_img.requires_grad_() assert po.metric.nlpd(einstein_img, curie_img).requires_grad - curie_img.requires_grad_(False) # return to previous state for pytest fixtures + curie_img.requires_grad_( + False + ) # return to previous state for pytest fixtures - @pytest.mark.parametrize('model', ['frontend.OnOff'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff"], indirect=True) def test_model_metric_grad(self, einstein_img, curie_img, model): curie_img.requires_grad_() - assert po.metric.model_metric(einstein_img, curie_img, model).requires_grad + assert po.metric.model_metric( + einstein_img, curie_img, model + ).requires_grad curie_img.requires_grad_(False) def test_ssim_dtype(self, einstein_img, curie_img): - po.metric.ssim(einstein_img.to(torch.float64), - curie_img.to(torch.float64)) + po.metric.ssim( + einstein_img.to(torch.float64), curie_img.to(torch.float64) + ) def test_ssim_dtype_exception(self, einstein_img, curie_img): - with pytest.raises(ValueError, match='must have same dtype'): - po.metric.ssim(einstein_img.to(torch.float64), - curie_img) + with pytest.raises(ValueError, match="must have same dtype"): + po.metric.ssim(einstein_img.to(torch.float64), curie_img) def test_msssim_dtype(self, einstein_img, curie_img): - po.metric.ms_ssim(einstein_img.to(torch.float64), - curie_img.to(torch.float64)) + po.metric.ms_ssim( + einstein_img.to(torch.float64), curie_img.to(torch.float64) + ) def test_msssim_dtype_exception(self, einstein_img, curie_img): - with pytest.raises(ValueError, match='must have same dtype'): - po.metric.ms_ssim(einstein_img.to(torch.float64), - curie_img) + with pytest.raises(ValueError, match="must have same dtype"): + po.metric.ms_ssim(einstein_img.to(torch.float64), curie_img) diff --git a/tests/test_models.py b/tests/test_models.py index da099a2e..78af7ddf 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -6,7 +6,10 @@ from conftest import DEVICE, IMG_DIR import scipy.io as sio import pyrtools as pt -from plenoptic.simulate.canonical_computations import gaussian1d, circular_gaussian2d +from plenoptic.simulate.canonical_computations import ( + gaussian1d, + circular_gaussian2d, +) import plenoptic as po import torch import numpy as np @@ -16,7 +19,8 @@ from typing import Dict import os from contextlib import nullcontext as does_not_raise -os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8' + +os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8" ALL_MODELS = [ @@ -43,12 +47,14 @@ def image_input(): @pytest.fixture() def portilla_simoncelli_matlab_test_vectors(): - return po.data.fetch_data('portilla_simoncelli_matlab_test_vectors.tar.gz') + return po.data.fetch_data("portilla_simoncelli_matlab_test_vectors.tar.gz") @pytest.fixture() def portilla_simoncelli_test_vectors(): - return po.data.fetch_data('portilla_simoncelli_test_vectors_refactor.tar.gz') + return po.data.fetch_data( + "portilla_simoncelli_test_vectors_refactor.tar.gz" + ) def get_portilla_simoncelli_synthesize_filename(torch_version=None): @@ -62,31 +68,38 @@ def get_portilla_simoncelli_synthesize_filename(torch_version=None): if torch_version is None: # the bit after the + defines the CUDA version used (if any), which # doesn't appear to be relevant for this. - torch_version = torch.__version__.split('+')[0] + torch_version = torch.__version__.split("+")[0] # following https://stackoverflow.com/a/11887885 for how to compare version # strings - if version.parse(torch_version) < version.parse('1.12') or DEVICE.type == 'cuda': - torch_version = '' + if ( + version.parse(torch_version) < version.parse("1.12") + or DEVICE.type == "cuda" + ): + torch_version = "" # going from 1.11 to 1.12 only changes this synthesis output on cpu, not # gpu else: - torch_version = '_torch_v1.12.0' + torch_version = "_torch_v1.12.0" # during refactor, we changed PS model output so that it doesn't include # redundant stats. This changes the solution that is found (though not its # quality) - name_template = 'portilla_simoncelli_synthesize{gpu}{torch_version}_ps-refactor.npz' + name_template = ( + "portilla_simoncelli_synthesize{gpu}{torch_version}_ps-refactor.npz" + ) # synthesis gives differnet outputs on cpu vs gpu, so we have two different # versions to test against - if DEVICE.type == 'cpu': - gpu = '' - elif DEVICE.type == 'cuda': - gpu = '_gpu' + if DEVICE.type == "cpu": + gpu = "" + elif DEVICE.type == "cuda": + gpu = "_gpu" return name_template.format(gpu=gpu, torch_version=torch_version) @pytest.fixture() def portilla_simoncelli_synthesize(torch_version=None): - return po.data.fetch_data(get_portilla_simoncelli_synthesize_filename(torch_version)) + return po.data.fetch_data( + get_portilla_simoncelli_synthesize_filename(torch_version) + ) @pytest.fixture() @@ -94,19 +107,20 @@ def portilla_simoncelli_scales(): # During PS refactor, we changed the structure of the # _representation_scales attribute, so have a different file to test # against - return po.data.fetch_data('portilla_simoncelli_scales_ps-refactor.npz') + return po.data.fetch_data("portilla_simoncelli_scales_ps-refactor.npz") @pytest.mark.parametrize("model", ALL_MODELS, indirect=True) -@pytest.mark.skipif(DEVICE.type == 'cpu', reason="Can only test on cuda") +@pytest.mark.skipif(DEVICE.type == "cpu", reason="Can only test on cuda") def test_cuda(model, einstein_img): model.cuda() model(einstein_img) # make sure it ends on same device it started, since it might be a fixture model.to(DEVICE) + @pytest.mark.parametrize("model", ALL_MODELS, indirect=True) -@pytest.mark.skipif(DEVICE.type == 'cpu', reason="Can only test on cuda") +@pytest.mark.skipif(DEVICE.type == "cpu", reason="Can only test on cuda") def test_cpu_and_back(model, einstein_img): model.cpu() model.cuda() @@ -114,8 +128,9 @@ def test_cpu_and_back(model, einstein_img): # make sure it ends on same device it started, since it might be a fixture model.to(DEVICE) + @pytest.mark.parametrize("model", ALL_MODELS, indirect=True) -@pytest.mark.skipif(DEVICE.type == 'cpu', reason="Can only test on cuda") +@pytest.mark.skipif(DEVICE.type == "cpu", reason="Can only test on cuda") def test_cuda_and_back(model, einstein_img): model.cuda() model.cpu() @@ -124,6 +139,7 @@ def test_cuda_and_back(model, einstein_img): einstein_img.to(DEVICE) model.to(DEVICE) + @pytest.mark.parametrize("model", ALL_MODELS, indirect=True) def test_cpu(model, einstein_img): model.cpu() @@ -132,19 +148,31 @@ def test_cpu(model, einstein_img): einstein_img.to(DEVICE) model.to(DEVICE) + @pytest.mark.parametrize("model", ALL_MODELS, indirect=True) def test_validate_model(model): po.tools.remove_grad(model) - po.tools.validate.validate_model(model, device=DEVICE, - image_shape=(1, 1, 256, 256)) + po.tools.validate.validate_model( + model, device=DEVICE, image_shape=(1, 1, 256, 256) + ) + class TestNonLinearities(object): def test_rectangular_to_polar_dict(self, basic_stim): - spc = po.simul.SteerablePyramidFreq(basic_stim.shape[-2:], height=5, - order=1, is_complex=True, tight_frame=True).to(DEVICE) + spc = po.simul.SteerablePyramidFreq( + basic_stim.shape[-2:], + height=5, + order=1, + is_complex=True, + tight_frame=True, + ).to(DEVICE) y = spc(basic_stim) - energy, state = po.simul.non_linearities.rectangular_to_polar_dict(y, residuals=True) - y_hat = po.simul.non_linearities.polar_to_rectangular_dict(energy, state, residuals=True) + energy, state = po.simul.non_linearities.rectangular_to_polar_dict( + y, residuals=True + ) + y_hat = po.simul.non_linearities.polar_to_rectangular_dict( + energy, state, residuals=True + ) for key in y.keys(): diff = y[key] - y_hat[key] assert torch.linalg.vector_norm(diff.flatten(), ord=2) < 1e-5 @@ -157,11 +185,20 @@ def test_local_gain_control(self): assert torch.linalg.vector_norm(diff.flatten(), ord=2) < 1e-4 def test_local_gain_control_dict(self, basic_stim): - spr = po.simul.SteerablePyramidFreq(basic_stim.shape[-2:], height=5, - order=1, is_complex=False, tight_frame=True).to(DEVICE) + spr = po.simul.SteerablePyramidFreq( + basic_stim.shape[-2:], + height=5, + order=1, + is_complex=False, + tight_frame=True, + ).to(DEVICE) y = spr(basic_stim) - energy, state = po.simul.non_linearities.local_gain_control_dict(y, residuals=True) - y_hat = po.simul.non_linearities.local_gain_release_dict(energy, state, residuals=True) + energy, state = po.simul.non_linearities.local_gain_control_dict( + y, residuals=True + ) + y_hat = po.simul.non_linearities.local_gain_release_dict( + energy, state, residuals=True + ) for key in y.keys(): diff = y[key] - y_hat[key] assert torch.linalg.vector_norm(diff.flatten(), ord=2) < 1e-5 @@ -176,7 +213,9 @@ def test_grad(self, basic_stim): @pytest.mark.parametrize("n_scales", [3, 4, 5, 6]) def test_synthesis(self, curie_img, n_scales): - img = curie_img[:, :, 0:253, 0:234] # Original 256x256 shape is not good for testing padding + img = curie_img[ + :, :, 0:253, 0:234 + ] # Original 256x256 shape is not good for testing padding lpyr = po.simul.LaplacianPyramid(n_scales=n_scales).to(DEVICE) y = lpyr.forward(img) img_recon = lpyr.recon_pyr(y) @@ -187,7 +226,9 @@ def test_match_pyrtools(self, curie_img, n_scales): img = curie_img[:, :, 0:253, 0:234] lpyr_po = po.simul.LaplacianPyramid(n_scales=n_scales).to(DEVICE) y_po = lpyr_po(img) - lpyr_pt = pt.pyramids.LaplacianPyramid(img.squeeze().cpu(), height=n_scales) + lpyr_pt = pt.pyramids.LaplacianPyramid( + img.squeeze().cpu(), height=n_scales + ) y_pt = [lpyr_pt.pyr_coeffs[(i, 0)] for i in range(n_scales)] assert len(y_po) == len(y_pt) for x_po, x_pt in zip(y_po, y_pt): @@ -199,6 +240,7 @@ def test_match_pyrtools(self, curie_img, n_scales): # after upsampling up to one row/column. This causes inconsistency on the right and # bottom edges, so they are exluded in the comparison. + class TestFrontEnd: all_models = [ @@ -227,9 +269,13 @@ def test_onoff(self): def test_pretrained_onoff(self, kernel_size, cache_filt): if kernel_size != 31: with pytest.raises(AssertionError): - mdl = po.simul.OnOff(kernel_size, pretrained=True, cache_filt=cache_filt).to(DEVICE) + mdl = po.simul.OnOff( + kernel_size, pretrained=True, cache_filt=cache_filt + ).to(DEVICE) else: - mdl = po.simul.OnOff(kernel_size, pretrained=True, cache_filt=cache_filt).to(DEVICE) + mdl = po.simul.OnOff( + kernel_size, pretrained=True, cache_filt=cache_filt + ).to(DEVICE) @pytest.mark.parametrize("model", all_models, indirect=True) def test_frontend_display_filters(self, model): @@ -257,9 +303,13 @@ def test_gradient_flow(self, model): def test_cache_filt(self, cache_filt, mdl): img = torch.ones(1, 1, 100, 100).to(DEVICE).requires_grad_() if mdl == "naive.Gaussian": - model = po.simul.Gaussian((31, 31), 1., cache_filt=cache_filt).to(DEVICE) + model = po.simul.Gaussian((31, 31), 1.0, cache_filt=cache_filt).to( + DEVICE + ) elif mdl == "naive.CenterSurround": - model = po.simul.CenterSurround((31, 31), cache_filt=cache_filt).to(DEVICE) + model = po.simul.CenterSurround( + (31, 31), cache_filt=cache_filt + ).to(DEVICE) y = model(img) # forward pass should cache filt if True @@ -268,24 +318,37 @@ def test_cache_filt(self, cache_filt, mdl): else: assert model._filt is None - @pytest.mark.parametrize("center_std", [1., torch.as_tensor([1., 2.])]) + @pytest.mark.parametrize("center_std", [1.0, torch.as_tensor([1.0, 2.0])]) @pytest.mark.parametrize("out_channels", [1, 2, 3]) @pytest.mark.parametrize("on_center", [True, [True, False]]) - def test_CenterSurround_channels(self, center_std, out_channels, on_center): - if not isinstance(center_std, float) and len(center_std) != out_channels: + def test_CenterSurround_channels( + self, center_std, out_channels, on_center + ): + if ( + not isinstance(center_std, float) + and len(center_std) != out_channels + ): with pytest.raises(AssertionError): - model = po.simul.CenterSurround((31, 31), center_std=center_std, out_channels=out_channels) + model = po.simul.CenterSurround( + (31, 31), center_std=center_std, out_channels=out_channels + ) else: - model = po.simul.CenterSurround((31, 31), center_std=center_std, out_channels=out_channels) + model = po.simul.CenterSurround( + (31, 31), center_std=center_std, out_channels=out_channels + ) def test_linear(self, basic_stim): model = po.simul.Linear().to(DEVICE) assert model(basic_stim).requires_grad -def convert_matlab_ps_rep_to_dict(vec: torch.Tensor, n_scales: int, - n_orientations: int, spatial_corr_width: int, - use_true_correlations: bool) -> OrderedDict: +def convert_matlab_ps_rep_to_dict( + vec: torch.Tensor, + n_scales: int, + n_orientations: int, + spatial_corr_width: int, + use_true_correlations: bool, +) -> OrderedDict: """Converts matlab vector of statistics to a dictionary. The matlab (and old plenoptic) PS representation includes a bunch of @@ -314,7 +377,15 @@ def convert_matlab_ps_rep_to_dict(vec: torch.Tensor, n_scales: int, # magnitude_means rep["magnitude_means"] = OrderedDict() - keys = ['residual_highpass'] + [(sc, ori) for sc in range(n_scales) for ori in range(n_orientations)] + ['residual_lowpass'] + keys = ( + ["residual_highpass"] + + [ + (sc, ori) + for sc in range(n_scales) + for ori in range(n_orientations) + ] + + ["residual_lowpass"] + ) for ii, k in enumerate(keys): rep["magnitude_means"][k] = vec[..., n_filled + ii] n_filled += ii + 1 @@ -363,7 +434,9 @@ def convert_matlab_ps_rep_to_dict(vec: torch.Tensor, n_scales: int, if use_true_correlations: nn = (n_orientations, n_scales) - rep["magnitude_std"] = vec[..., n_filled : (n_filled + np.prod(nn))].unflatten(-1, nn) + rep["magnitude_std"] = vec[ + ..., n_filled : (n_filled + np.prod(nn)) + ].unflatten(-1, nn) n_filled += np.prod(nn) else: # place a dummy entry, so the order of keys is correct @@ -400,8 +473,9 @@ def convert_matlab_ps_rep_to_dict(vec: torch.Tensor, n_scales: int, return rep -def construct_normalizing_dict(plen_ps: po.simul.PortillaSimoncelli, - img: torch.Tensor) -> Dict[str, torch.Tensor]: +def construct_normalizing_dict( + plen_ps: po.simul.PortillaSimoncelli, img: torch.Tensor +) -> Dict[str, torch.Tensor]: """Construct dictionary to normalize covariances in PS representation. The matlab code computes covariances instead of correlations for the @@ -417,28 +491,46 @@ def construct_normalizing_dict(plen_ps: po.simul.PortillaSimoncelli, mags_var = torch.stack([m.var((-2, -1), correction=0) for m in mags], -1) normalizing_dict = {} - com = einops.einsum(mags_var, mags_var, 'b c o1 s, b c o2 s -> b c o1 o2 s') - normalizing_dict['cross_orientation_correlation_magnitude'] = com.pow(0.5) + com = einops.einsum( + mags_var, mags_var, "b c o1 s, b c o2 s -> b c o1 o2 s" + ) + normalizing_dict["cross_orientation_correlation_magnitude"] = com.pow(0.5) if plen_ps.n_scales > 1: - doub_mags_var = torch.stack([m.var((-2, -1), correction=0) for m in doub_mags], -1) - reals_var = torch.stack([r.var((-2, -1), correction=0) for r in reals], -1) - doub_sep_var = torch.stack([s.var((-2, -1), correction=0) for s in doub_sep], -1) - csm = einops.einsum(mags_var[..., :-1], doub_mags_var, 'b c o1 s, b c o2 s -> b c o1 o2 s') - normalizing_dict['cross_scale_correlation_magnitude'] = csm.pow(0.5) - csr = einops.einsum(reals_var[..., :-1], doub_sep_var, 'b c o1 s, b c o2 s -> b c o1 o2 s') - normalizing_dict['cross_scale_correlation_real'] = csr.pow(0.5) + doub_mags_var = torch.stack( + [m.var((-2, -1), correction=0) for m in doub_mags], -1 + ) + reals_var = torch.stack( + [r.var((-2, -1), correction=0) for r in reals], -1 + ) + doub_sep_var = torch.stack( + [s.var((-2, -1), correction=0) for s in doub_sep], -1 + ) + csm = einops.einsum( + mags_var[..., :-1], + doub_mags_var, + "b c o1 s, b c o2 s -> b c o1 o2 s", + ) + normalizing_dict["cross_scale_correlation_magnitude"] = csm.pow(0.5) + csr = einops.einsum( + reals_var[..., :-1], + doub_sep_var, + "b c o1 s, b c o2 s -> b c o1 o2 s", + ) + normalizing_dict["cross_scale_correlation_real"] = csr.pow(0.5) else: - normalizing_dict['cross_scale_correlation_magnitude'] = 1 - normalizing_dict['cross_scale_correlation_real'] = 1 + normalizing_dict["cross_scale_correlation_magnitude"] = 1 + normalizing_dict["cross_scale_correlation_real"] = 1 return normalizing_dict -def remove_redundant_and_normalize(matlab_rep: OrderedDict, - use_true_correlations: bool, - plen_ps: po.simul.PortillaSimoncelli, - normalizing_dict: dict) -> torch.Tensor: +def remove_redundant_and_normalize( + matlab_rep: OrderedDict, + use_true_correlations: bool, + plen_ps: po.simul.PortillaSimoncelli, + normalizing_dict: dict, +) -> torch.Tensor: """Remove redundant stats from dictionary of representation, and normalize correlations Redundant stats fall in two categories: those that are not included at all @@ -469,40 +561,61 @@ def remove_redundant_and_normalize(matlab_rep: OrderedDict, """ # Remove those stats that are not included at all. - matlab_rep.pop('magnitude_means') - matlab_rep.pop('cross_orientation_correlation_real') + matlab_rep.pop("magnitude_means") + matlab_rep.pop("cross_orientation_correlation_real") # Remove the 0 placeholders - matlab_rep['cross_scale_correlation_magnitude'] = matlab_rep['cross_scale_correlation_magnitude'][..., :-1] - matlab_rep['cross_orientation_correlation_magnitude'] = matlab_rep['cross_orientation_correlation_magnitude'][..., :-1] - matlab_rep['cross_scale_correlation_real'] = matlab_rep['cross_scale_correlation_real'][..., :plen_ps.n_orientations, :, :-1] + matlab_rep["cross_scale_correlation_magnitude"] = matlab_rep[ + "cross_scale_correlation_magnitude" + ][..., :-1] + matlab_rep["cross_orientation_correlation_magnitude"] = matlab_rep[ + "cross_orientation_correlation_magnitude" + ][..., :-1] + matlab_rep["cross_scale_correlation_real"] = matlab_rep[ + "cross_scale_correlation_real" + ][..., : plen_ps.n_orientations, :, :-1] # if there are two orientations, there's some more 0 placeholders if plen_ps.n_orientations == 2: - matlab_rep['cross_scale_correlation_real'] = matlab_rep['cross_scale_correlation_real'][..., :-1, :] + matlab_rep["cross_scale_correlation_real"] = matlab_rep[ + "cross_scale_correlation_real" + ][..., :-1, :] # See docstring for why we make these specific stats negative - matlab_rep['cross_scale_correlation_real'][..., :plen_ps.n_orientations, :] = -matlab_rep['cross_scale_correlation_real'][..., :plen_ps.n_orientations, :] + matlab_rep["cross_scale_correlation_real"][ + ..., : plen_ps.n_orientations, : + ] = -matlab_rep["cross_scale_correlation_real"][ + ..., : plen_ps.n_orientations, : + ] if not use_true_correlations: # Create std_reconstructed ctr_ind = plen_ps.spatial_corr_width // 2 - var_recon = matlab_rep['auto_correlation_reconstructed'][..., ctr_ind, ctr_ind, :].clone() - matlab_rep['std_reconstructed'] = var_recon ** 0.5 + var_recon = matlab_rep["auto_correlation_reconstructed"][ + ..., ctr_ind, ctr_ind, : + ].clone() + matlab_rep["std_reconstructed"] = var_recon**0.5 # Normalize the autocorrelations using their center values - matlab_rep['auto_correlation_reconstructed'] /= var_recon - acm_ctr = matlab_rep['auto_correlation_magnitude'][..., ctr_ind, ctr_ind, :, :].clone() - matlab_rep['auto_correlation_magnitude'] /= acm_ctr + matlab_rep["auto_correlation_reconstructed"] /= var_recon + acm_ctr = matlab_rep["auto_correlation_magnitude"][ + ..., ctr_ind, ctr_ind, :, : + ].clone() + matlab_rep["auto_correlation_magnitude"] /= acm_ctr # Create magnitude_std diag = torch.arange(plen_ps.n_orientations) - var_mags = matlab_rep['cross_orientation_correlation_magnitude'][..., diag, diag, :] - matlab_rep['magnitude_std'] = var_mags.pow(0.5) + var_mags = matlab_rep["cross_orientation_correlation_magnitude"][ + ..., diag, diag, : + ] + matlab_rep["magnitude_std"] = var_mags.pow(0.5) # The cross-correlations are normalized by the outer product of the # variances of the tensors that create them. We have created these and # saved them in normalizing dict, which we use here - crosscorr_keys = ['cross_scale_correlation_real', 'cross_scale_correlation_magnitude', - 'cross_orientation_correlation_magnitude'] + crosscorr_keys = [ + "cross_scale_correlation_real", + "cross_scale_correlation_magnitude", + "cross_orientation_correlation_magnitude", + ] for k in crosscorr_keys: matlab_rep[k] = matlab_rep[k] / normalizing_dict[k] @@ -534,9 +647,14 @@ def test_portilla_simoncelli( @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", [3, 5, 7, 9]) @pytest.mark.parametrize("im", ["curie", "einstein", "metal", "nuts"]) - def test_ps_torch_v_matlab(self, n_scales, n_orientations, - spatial_corr_width, im, - portilla_simoncelli_matlab_test_vectors): + def test_ps_torch_v_matlab( + self, + n_scales, + n_orientations, + spatial_corr_width, + im, + portilla_simoncelli_matlab_test_vectors, + ): # the matlab outputs were computed on images with values between 0 and # 255 (not 0 and 1, which is what po.load_images does by default). Note @@ -546,23 +664,39 @@ def test_ps_torch_v_matlab(self, n_scales, n_orientations, # floating points are fun. im0 = 255 * po.load_images(IMG_DIR / "256" / f"{im}.pgm") im0 = im0.to(torch.float64).to(DEVICE) - ps = po.simul.PortillaSimoncelli( - im0.shape[-2:], - n_scales=n_scales, - n_orientations=n_orientations, - spatial_corr_width=spatial_corr_width, - ).to(DEVICE).to(torch.float64) + ps = ( + po.simul.PortillaSimoncelli( + im0.shape[-2:], + n_scales=n_scales, + n_orientations=n_orientations, + spatial_corr_width=spatial_corr_width, + ) + .to(DEVICE) + .to(torch.float64) + ) python_vector = ps(im0) - matlab_rep = sio.loadmat(f"{portilla_simoncelli_matlab_test_vectors}/" - f"{im}-scales{n_scales}-ori{n_orientations}" - f"-spat{spatial_corr_width}.mat") - matlab_rep = torch.from_numpy(matlab_rep["params_vector"].flatten()).unsqueeze(0).unsqueeze(0) - matlab_rep = convert_matlab_ps_rep_to_dict(matlab_rep.to(DEVICE), n_scales, - n_orientations, spatial_corr_width, - False) + matlab_rep = sio.loadmat( + f"{portilla_simoncelli_matlab_test_vectors}/" + f"{im}-scales{n_scales}-ori{n_orientations}" + f"-spat{spatial_corr_width}.mat" + ) + matlab_rep = ( + torch.from_numpy(matlab_rep["params_vector"].flatten()) + .unsqueeze(0) + .unsqueeze(0) + ) + matlab_rep = convert_matlab_ps_rep_to_dict( + matlab_rep.to(DEVICE), + n_scales, + n_orientations, + spatial_corr_width, + False, + ) norm_dict = construct_normalizing_dict(ps, im0) - matlab_rep = remove_redundant_and_normalize(matlab_rep, False, ps, norm_dict) + matlab_rep = remove_redundant_and_normalize( + matlab_rep, False, ps, norm_dict + ) matlab_rep = po.to_numpy(matlab_rep).squeeze() python_vector = po.to_numpy(python_vector).squeeze() @@ -577,34 +711,44 @@ def test_ps_torch_v_matlab(self, n_scales, n_orientations, @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) @pytest.mark.parametrize("im", ["curie", "einstein", "metal", "nuts"]) - def test_ps_torch_output(self, n_scales, n_orientations, - spatial_corr_width, im, - portilla_simoncelli_test_vectors): + def test_ps_torch_output( + self, + n_scales, + n_orientations, + spatial_corr_width, + im, + portilla_simoncelli_test_vectors, + ): im0 = po.load_images(IMG_DIR / "256" / f"{im}.pgm") im0 = im0.to(torch.float64).to(DEVICE) - ps = po.simul.PortillaSimoncelli( - im0.shape[-2:], - n_scales=n_scales, - n_orientations=n_orientations, - spatial_corr_width=spatial_corr_width, - ).to(DEVICE).to(torch.float64) + ps = ( + po.simul.PortillaSimoncelli( + im0.shape[-2:], + n_scales=n_scales, + n_orientations=n_orientations, + spatial_corr_width=spatial_corr_width, + ) + .to(DEVICE) + .to(torch.float64) + ) output = ps(im0) - saved = np.load(f"{portilla_simoncelli_test_vectors}/" - f"{im}_scales-{n_scales}_ori-{n_orientations}_" - f"spat-{spatial_corr_width}.npy") + saved = np.load( + f"{portilla_simoncelli_test_vectors}/" + f"{im}_scales-{n_scales}_ori-{n_orientations}_" + f"spat-{spatial_corr_width}.npy" + ) output = po.to_numpy(output) - np.testing.assert_allclose( - output, saved, rtol=1e-5, atol=1e-5 - ) + np.testing.assert_allclose(output, saved, rtol=1e-5, atol=1e-5) @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) - def test_ps_convert(self, n_scales, n_orientations, spatial_corr_width, - einstein_img): + def test_ps_convert( + self, n_scales, n_orientations, spatial_corr_width, einstein_img + ): ps = po.simul.PortillaSimoncelli( einstein_img.shape[-2:], n_scales=n_scales, @@ -612,10 +756,11 @@ def test_ps_convert(self, n_scales, n_orientations, spatial_corr_width, spatial_corr_width=spatial_corr_width, ).to(DEVICE) rep = ps(einstein_img) - assert torch.all(rep == ps.convert_to_tensor(ps.convert_to_dict(rep))), "Convert to tensor or dict is broken!" + assert torch.all( + rep == ps.convert_to_tensor(ps.convert_to_dict(rep)) + ), "Convert to tensor or dict is broken!" - def test_ps_synthesis(self, portilla_simoncelli_synthesize, - run_test=True): + def test_ps_synthesis(self, portilla_simoncelli_synthesize, run_test=True): """Test PS texture metamer synthesis. Parameters @@ -641,46 +786,68 @@ def test_ps_synthesis(self, portilla_simoncelli_synthesize, # version, because that's what we test against. torch.use_deterministic_algorithms(True) with np.load(portilla_simoncelli_synthesize) as f: - im = f['im'] - im_init = f['im_init'] - im_synth = f['im_synth'] - rep_synth = f['rep_synth'] - - im0 = torch.as_tensor(im).unsqueeze(0).unsqueeze(0).to(DEVICE).to(torch.float64) - model = po.simul.PortillaSimoncelli(im0.shape[-2:], - n_scales=4, - n_orientations=4, - spatial_corr_width=9, - ).to(DEVICE).to(torch.float64) + im = f["im"] + im_init = f["im_init"] + im_synth = f["im_synth"] + rep_synth = f["rep_synth"] + + im0 = ( + torch.as_tensor(im) + .unsqueeze(0) + .unsqueeze(0) + .to(DEVICE) + .to(torch.float64) + ) + model = ( + po.simul.PortillaSimoncelli( + im0.shape[-2:], + n_scales=4, + n_orientations=4, + spatial_corr_width=9, + ) + .to(DEVICE) + .to(torch.float64) + ) po.tools.set_seed(1) im_init = torch.as_tensor(im_init).unsqueeze(0).unsqueeze(0) - met = po.synth.MetamerCTF(im0, model, initial_image=im_init, - loss_function=po.tools.optim.l2_norm, - range_penalty_lambda=0, - coarse_to_fine='together') + met = po.synth.MetamerCTF( + im0, + model, + initial_image=im_init, + loss_function=po.tools.optim.l2_norm, + range_penalty_lambda=0, + coarse_to_fine="together", + ) # this is the same as the default optimizer, but we explicitly # instantiate it anyway, in case we change the defaults at some point - optim = torch.optim.Adam([met.metamer], lr=.01, - amsgrad=True) - met.synthesize(max_iter=200, optimizer=optim, - change_scale_criterion=None, - ctf_iters_to_check=15) + optim = torch.optim.Adam([met.metamer], lr=0.01, amsgrad=True) + met.synthesize( + max_iter=200, + optimizer=optim, + change_scale_criterion=None, + ctf_iters_to_check=15, + ) output = met.metamer if run_test: np.testing.assert_allclose( - po.to_numpy(output).squeeze(), im_synth.squeeze(), rtol=1e-4, atol=1e-4, + po.to_numpy(output).squeeze(), + im_synth.squeeze(), + rtol=1e-4, + atol=1e-4, ) np.testing.assert_allclose( - po.to_numpy(model(output)).squeeze(), rep_synth.squeeze(), rtol=1e-4, atol=1e-4 + po.to_numpy(model(output)).squeeze(), + rep_synth.squeeze(), + rtol=1e-4, + atol=1e-4, ) else: return met - @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) @@ -689,10 +856,10 @@ def test_portilla_simoncelli_scales( n_scales, n_orientations, spatial_corr_width, - portilla_simoncelli_scales + portilla_simoncelli_scales, ): with np.load(portilla_simoncelli_scales, allow_pickle=True) as f: - key = f'scale-{n_scales}_ori-{n_orientations}_width-{spatial_corr_width}' + key = f"scale-{n_scales}_ori-{n_orientations}_width-{spatial_corr_width}" saved = f[key] model = po.simul.PortillaSimoncelli( @@ -700,7 +867,7 @@ def test_portilla_simoncelli_scales( n_scales=n_scales, n_orientations=n_orientations, spatial_corr_width=spatial_corr_width, - ).to(DEVICE) + ).to(DEVICE) output = model._representation_scales @@ -712,14 +879,20 @@ def test_other_size_images(self, n_scales, img_size): im0 = po.load_images(IMG_DIR / "256" / "nuts.pgm").to(DEVICE) im0 = im0[..., :img_size, :img_size] if any([(img_size / 2**i) % 2 for i in range(n_scales)]): - expectation = pytest.raises(ValueError, match='Because of how the Portilla-Simoncelli model handles multiscale') + expectation = pytest.raises( + ValueError, + match=( + "Because of how the Portilla-Simoncelli model handles" + " multiscale" + ), + ) else: expectation = does_not_raise() with expectation: model = po.simul.PortillaSimoncelli( im0.shape[-2:], n_scales=n_scales, - ).to(DEVICE) + ).to(DEVICE) model(im0) @pytest.mark.parametrize("img_size", [160, 128]) @@ -731,44 +904,61 @@ def test_nonsquare_images(self, img_size): # with height 4, spatial_corr_width=9 is too big for final scale # and image size 128 spatial_corr_width=7, - ).to(DEVICE) + ).to(DEVICE) model(im0) @pytest.mark.parametrize("batch_channel", [(1, 3), (2, 1), (2, 3)]) @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) - def test_multibatchchannel(self, batch_channel, n_scales, n_orientations, - spatial_corr_width, einstein_img): + def test_multibatchchannel( + self, + batch_channel, + n_scales, + n_orientations, + spatial_corr_width, + einstein_img, + ): model = po.simul.PortillaSimoncelli( einstein_img.shape[-2:], n_scales=n_scales, n_orientations=n_orientations, spatial_corr_width=spatial_corr_width, - ).to(DEVICE) + ).to(DEVICE) rep = model(einstein_img.repeat((*batch_channel, 1, 1))) if rep.shape[:2] != batch_channel: - raise ValueError("Output doesn't have same number of batch/channel dims as input!") + raise ValueError( + "Output doesn't have same number of batch/channel dims as" + " input!" + ) @pytest.mark.parametrize("batch_channel", [(1, 1), (1, 3), (2, 1), (2, 3)]) @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) - def test_plot_representation(self, batch_channel, n_scales, n_orientations, - spatial_corr_width, einstein_img): + def test_plot_representation( + self, + batch_channel, + n_scales, + n_orientations, + spatial_corr_width, + einstein_img, + ): model = po.simul.PortillaSimoncelli( einstein_img.shape[-2:], n_scales=n_scales, n_orientations=n_orientations, spatial_corr_width=spatial_corr_width, - ).to(DEVICE) - model.plot_representation(model(einstein_img.repeat((*batch_channel, 1, 1))), - title="Representation") + ).to(DEVICE) + model.plot_representation( + model(einstein_img.repeat((*batch_channel, 1, 1))), + title="Representation", + ) def test_update_plot(self, einstein_img): model = po.simul.PortillaSimoncelli( einstein_img.shape[-2:], - ).to(DEVICE) + ).to(DEVICE) _, axes = model.plot_representation(model(einstein_img)) orig_y = axes[0].containers[0].markerline.get_ydata() img = po.load_images(IMG_DIR / "256" / "nuts.pgm").to(DEVICE) @@ -781,9 +971,14 @@ def test_update_plot(self, einstein_img): @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) - def test_plot_representation_dim_assumption(self, batch_channel, n_scales, - n_orientations, spatial_corr_width, - einstein_img): + def test_plot_representation_dim_assumption( + self, + batch_channel, + n_scales, + n_orientations, + spatial_corr_width, + einstein_img, + ): # there's an assumption I make in plot_representation that I want to # ensure is tested model = po.simul.PortillaSimoncelli( @@ -791,16 +986,18 @@ def test_plot_representation_dim_assumption(self, batch_channel, n_scales, n_scales=n_scales, n_orientations=n_orientations, spatial_corr_width=spatial_corr_width, - ).to(DEVICE) + ).to(DEVICE) rep = model(einstein_img.repeat((*batch_channel, 1, 1))) rep = model.convert_to_dict(rep[0].unsqueeze(0).mean(1, keepdim=True)) if any([v.ndim < 3 for v in rep.values()]): - raise ValueError("Somehow this doesn't have at least 3 dimensions!") + raise ValueError( + "Somehow this doesn't have at least 3 dimensions!" + ) if any([v.shape[:2] != (1, 1) for v in rep.values()]): raise ValueError("Somehow this has an extra batch or channel!") # fft doesn't support float16, so we can't support it - @pytest.mark.parametrize('dtype', [torch.float32, torch.float64]) + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) def test_dtypes(self, dtype, einstein_img): model = po.simul.PortillaSimoncelli(einstein_img.shape[-2:]).to(DEVICE) model(einstein_img.to(dtype)) @@ -808,8 +1005,9 @@ def test_dtypes(self, dtype, einstein_img): @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) - def test_scales_shapes(self, n_scales, n_orientations, spatial_corr_width, - einstein_img): + def test_scales_shapes( + self, n_scales, n_orientations, spatial_corr_width, einstein_img + ): # test that the shapes we use to assign scale labels to each statistic # and determine redundant stats are accurate model = po.simul.PortillaSimoncelli( @@ -817,15 +1015,17 @@ def test_scales_shapes(self, n_scales, n_orientations, spatial_corr_width, n_scales=n_scales, n_orientations=n_orientations, spatial_corr_width=spatial_corr_width, - ).to(DEVICE) + ).to(DEVICE) # this hack is to prevent model from removing redundant stats model._necessary_stats_mask = None rep = model(einstein_img) # and then we get them back into their original shapes - unpacked_rep = einops.unpack(rep, model._pack_info, 'b c *') + unpacked_rep = einops.unpack(rep, model._pack_info, "b c *") # because _necessary_stats_dict is an ordered dictionary, its elements # will be in the same order as in unpackaged_rep - for unp_v, dict_v in zip(unpacked_rep, model._necessary_stats_dict.values()): + for unp_v, dict_v in zip( + unpacked_rep, model._necessary_stats_dict.values() + ): # when we have a single scale, _necessary_stats_dict will contain # keys for the cross_scale correlations, but there are no # corresponding values. Thus, skip. @@ -843,8 +1043,9 @@ def test_scales_shapes(self, n_scales, n_orientations, spatial_corr_width, @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) @pytest.mark.parametrize("im", ["curie", "einstein", "metal", "nuts"]) - def test_redundancies(self, n_scales, n_orientations, spatial_corr_width, - im): + def test_redundancies( + self, n_scales, n_orientations, spatial_corr_width, im + ): # test that the computed statistics have the redundancies we think they # do im = po.load_images(IMG_DIR / "256" / f"{im}.pgm") @@ -854,14 +1055,16 @@ def test_redundancies(self, n_scales, n_orientations, spatial_corr_width, n_scales=n_scales, n_orientations=n_orientations, spatial_corr_width=spatial_corr_width, - ).to(DEVICE) + ).to(DEVICE) # this hack is to prevent model from removing redundant stats model._necessary_stats_mask = None rep = model(im) # and then we get them back into their original shapes (with lots of # redundancies) - unpacked_rep = einops.unpack(rep, model._pack_info, 'b c *') - for unp_v, (k, nec_v) in zip(unpacked_rep, model._necessary_stats_dict.items()): + unpacked_rep = einops.unpack(rep, model._pack_info, "b c *") + for unp_v, (k, nec_v) in zip( + unpacked_rep, model._necessary_stats_dict.items() + ): # find the redundant values for this stat red_v = torch.logical_not(nec_v) # then there are no redundant values here @@ -875,19 +1078,25 @@ def test_redundancies(self, n_scales, n_orientations, spatial_corr_width, if red_idx.shape[-1] == 3: # auto_correlation_magnitude has an extra dimension # compared to the others ignore batch and channel - assert k == 'auto_correlation_magnitude', f"Somehow got extra dimension for {k}!" + assert ( + k == "auto_correlation_magnitude" + ), f"Somehow got extra dimension for {k}!" # then drop the duplicates red_idx = torch.unique(red_idx[..., :2], dim=0) val = unp_v[0, 0, ..., sc] - if k == 'cross_orientation_correlation_magnitude': + if k == "cross_orientation_correlation_magnitude": # Symmetry M_{i,j} = M_{j,i}. for i in red_idx: unp_vals.append(val[i[0], i[1]]) mask_vals.append(val[i[1], i[0]]) - elif k.startswith('auto_correlation'): + elif k.startswith("auto_correlation"): # center values of autocorrelations should be 1 - ctr_vals.append(val[model.spatial_corr_width//2, - model.spatial_corr_width//2]) + ctr_vals.append( + val[ + model.spatial_corr_width // 2, + model.spatial_corr_width // 2, + ] + ) # Symmetry M_{i,j} = M_{n-i+1, n-j+1} for i in red_idx: unp_vals.append(val[i[0], i[1]]) @@ -898,23 +1107,30 @@ def test_redundancies(self, n_scales, n_orientations, spatial_corr_width, offset = 0 else: offset = 1 - mask_vals.append(val[-(i[0]+offset), -(i[1]+offset)]) + mask_vals.append( + val[-(i[0] + offset), -(i[1] + offset)] + ) else: - raise ValueError(f"stat {k} unexpectedly has redundant values!") - #and check for equality + raise ValueError( + f"stat {k} unexpectedly has redundant values!" + ) + # and check for equality if ctr_vals: ctr_vals = torch.stack(ctr_vals) torch.equal(ctr_vals, torch.ones_like(ctr_vals)) unp_vals = torch.stack(unp_vals) mask_vals = torch.stack(mask_vals) - torch.testing.assert_close(unp_vals, mask_vals, atol=1e-6, rtol=1e-7) + torch.testing.assert_close( + unp_vals, mask_vals, atol=1e-6, rtol=1e-7 + ) @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) @pytest.mark.parametrize("im", ["curie", "einstein", "metal", "nuts"]) - def test_crosscorrs(self, n_scales, n_orientations, spatial_corr_width, - im): + def test_crosscorrs( + self, n_scales, n_orientations, spatial_corr_width, im + ): # test that cross-correlations we compute are actual cross correlations im = po.load_images(IMG_DIR / "256" / f"{im}.pgm") im = im.to(torch.float64).to(DEVICE) @@ -923,14 +1139,14 @@ def test_crosscorrs(self, n_scales, n_orientations, spatial_corr_width, n_scales=n_scales, n_orientations=n_orientations, spatial_corr_width=spatial_corr_width, - ).to(DEVICE) + ).to(DEVICE) # this hack is to prevent model from removing redundant stats, which # insert NaNs, making the comparison difficult model._necessary_stats_mask = None rep = model(im) # and then we get them back into their original shapes (with lots of # redundancies) - unpacked_rep = einops.unpack(rep, model._pack_info, 'b c *') + unpacked_rep = einops.unpack(rep, model._pack_info, "b c *") keys = list(model._necessary_stats_dict.keys()) # need to get the intermediates necessary for testing # cross-correlations @@ -940,19 +1156,20 @@ def test_crosscorrs(self, n_scales, n_orientations, spatial_corr_width, # the cross-orientation correlations torch_corrs = [] for m in mags: - m = einops.rearrange(m, 'b c o h w -> (b c o) (h w)') + m = einops.rearrange(m, "b c o h w -> (b c o) (h w)") torch_corrs.append(torch.corrcoef(m).unsqueeze(0).unsqueeze(0)) torch_corr = torch.stack(torch_corrs, -1) - idx = keys.index('cross_orientation_correlation_magnitude') - torch.testing.assert_close(unpacked_rep[idx], - torch_corr, atol=0, rtol=1e-12) + idx = keys.index("cross_orientation_correlation_magnitude") + torch.testing.assert_close( + unpacked_rep[idx], torch_corr, atol=0, rtol=1e-12 + ) # only have cross-scale correlations when there's more than one scale if n_scales > 1: # cross-scale magnitude correlations torch_corrs = [] for m, d in zip(mags[:-1], doub_mags): concat = torch.cat([m, d], dim=2) - concat = einops.rearrange(concat, 'b c o h w -> (b c o) (h w)') + concat = einops.rearrange(concat, "b c o h w -> (b c o) (h w)") # this matrix contains the 4 sub-matrices, each of shape # (n_orientations, n_orientations), only one of which we want: # the correlations between the magnitudes at this scale and the @@ -960,14 +1177,15 @@ def test_crosscorrs(self, n_scales, n_orientations, spatial_corr_width, c = torch.corrcoef(concat)[:n_orientations, n_orientations:] torch_corrs.append(c.unsqueeze(0).unsqueeze(0)) torch_corr = torch.stack(torch_corrs, -1) - idx = keys.index('cross_scale_correlation_magnitude') - torch.testing.assert_close(unpacked_rep[idx], - torch_corr, atol=0, rtol=1e-12) + idx = keys.index("cross_scale_correlation_magnitude") + torch.testing.assert_close( + unpacked_rep[idx], torch_corr, atol=0, rtol=1e-12 + ) # cross-scale real correlations torch_corrs = [] for r, s in zip(reals[:-1], doub_sep): concat = torch.cat([r, s], dim=2) - concat = einops.rearrange(concat, 'b c o h w -> (b c o) (h w)') + concat = einops.rearrange(concat, "b c o h w -> (b c o) (h w)") # this matrix contains the 4 sub-matrices, only one of which we # want: the correlations between the real coeffs at this scale # and the doubled real and imaginary coeffs at the next scale. @@ -977,9 +1195,10 @@ def test_crosscorrs(self, n_scales, n_orientations, spatial_corr_width, c = torch.corrcoef(concat)[:n_orientations, n_orientations:] torch_corrs.append(c.unsqueeze(0).unsqueeze(0)) torch_corr = torch.stack(torch_corrs, -1) - idx = keys.index('cross_scale_correlation_real') - torch.testing.assert_close(unpacked_rep[idx], - torch_corr, atol=1e-5, rtol=2e-5) + idx = keys.index("cross_scale_correlation_real") + torch.testing.assert_close( + unpacked_rep[idx], torch_corr, atol=1e-5, rtol=2e-5 + ) def test_convert_to_dict_error_diff_model(self, einstein_img): ps = po.simul.PortillaSimoncelli( @@ -991,7 +1210,9 @@ def test_convert_to_dict_error_diff_model(self, einstein_img): einstein_img.shape[-2:], n_scales=2, ).to(DEVICE) - with pytest.raises(ValueError, match="representation tensor is the wrong length"): + with pytest.raises( + ValueError, match="representation tensor is the wrong length" + ): ps.convert_to_dict(rep) def test_convert_to_dict_error(self, einstein_img): @@ -999,15 +1220,20 @@ def test_convert_to_dict_error(self, einstein_img): einstein_img.shape[-2:], ).to(DEVICE) rep = ps(einstein_img) - with pytest.raises(ValueError, match="representation tensor is the wrong length"): + with pytest.raises( + ValueError, match="representation tensor is the wrong length" + ): ps.convert_to_dict(rep[..., :-10]) + class TestFilters: - @pytest.mark.parametrize("std", [5., torch.as_tensor(1., device=DEVICE), -1., 0.]) + @pytest.mark.parametrize( + "std", [5.0, torch.as_tensor(1.0, device=DEVICE), -1.0, 0.0] + ) @pytest.mark.parametrize("kernel_size", [(31, 31), (3, 2), (7, 7), 5]) @pytest.mark.parametrize("out_channels", [1, 3, 10]) def test_circular_gaussian2d_shape(self, std, kernel_size, out_channels): - if std <= 0.: + if std <= 0.0: with pytest.raises(AssertionError): circular_gaussian2d((7, 7), std) else: @@ -1015,16 +1241,18 @@ def test_circular_gaussian2d_shape(self, std, kernel_size, out_channels): if isinstance(kernel_size, int): kernel_size = (kernel_size, kernel_size) assert filt.shape == (out_channels, 1, *kernel_size) - assert filt.sum().isclose(torch.ones(1, device=DEVICE) * out_channels) + assert filt.sum().isclose( + torch.ones(1, device=DEVICE) * out_channels + ) def test_circular_gaussian2d_wrong_std_length(self): - std = torch.as_tensor([1., 2.], device=DEVICE) + std = torch.as_tensor([1.0, 2.0], device=DEVICE) out_channels = 3 with pytest.raises(AssertionError): circular_gaussian2d((7, 7), std, out_channels) @pytest.mark.parametrize("kernel_size", [5, 11, 20]) - @pytest.mark.parametrize("std", [1., 20., 0.]) + @pytest.mark.parametrize("std", [1.0, 20.0, 0.0]) def test_gaussian1d(self, kernel_size, std): if std <= 0: with pytest.raises(AssertionError): diff --git a/tests/test_steerable_pyr.py b/tests/test_steerable_pyr.py index a2e5ec9e..572f986f 100644 --- a/tests/test_steerable_pyr.py +++ b/tests/test_steerable_pyr.py @@ -11,7 +11,7 @@ def check_pyr_coeffs(coeff_1, coeff_2, rtol=1e-3, atol=1e-3): - ''' + """ function that checks if two sets of pyramid coefficients are the same We set an absolute and relative tolerance and the following function checks if abs(coeff1-coeff2) <= atol + rtol*abs(coeff1) @@ -19,7 +19,7 @@ def check_pyr_coeffs(coeff_1, coeff_2, rtol=1e-3, atol=1e-3): coeff1: first dictionary of pyramid coefficients coeff2: second dictionary of pyramid coefficients Both coeffs must obviously have the same number of scales, orientations etc. - ''' + """ for k in coeff_1.keys(): if torch.is_tensor(coeff_1[k]): @@ -30,20 +30,21 @@ def check_pyr_coeffs(coeff_1, coeff_2, rtol=1e-3, atol=1e-3): coeff_2_np = to_numpy(coeff_2[k].squeeze()) else: coeff_2_np = coeff_2[k] - - - np.testing.assert_allclose(coeff_1_np, coeff_2_np, rtol=rtol, atol=atol) + + np.testing.assert_allclose( + coeff_1_np, coeff_2_np, rtol=rtol, atol=atol + ) def check_band_energies(coeff_1, coeff_2, rtol=1e-4, atol=1e-4): - ''' + """ function that checks if the energy in each band of two pyramids are the same. We set an absolute and relative tolerance and the function checks for each band if abs(coeff_1-coeff_2) <= atol + rtol*abs(coeff_1) Args: coeff_1: first dictionary of torch tensors corresponding to each band coeff_2: second dictionary of torch tensors corresponding to each band - ''' + """ for i in range(len(coeff_1.items())): k1 = list(coeff_1.keys())[i] @@ -53,53 +54,71 @@ def check_band_energies(coeff_1, coeff_2, rtol=1e-4, atol=1e-4): band_1 = band_1.squeeze() band_2 = band_2.squeeze() - np.testing.assert_allclose(np.sum(np.abs(band_1)**2),np.sum(np.abs(band_2)**2), rtol=rtol, atol=atol) + np.testing.assert_allclose( + np.sum(np.abs(band_1) ** 2), + np.sum(np.abs(band_2) ** 2), + rtol=rtol, + atol=atol, + ) -def check_parseval(im ,coeff, rtol=1e-4, atol=0): - ''' +def check_parseval(im, coeff, rtol=1e-4, atol=0): + """ function that checks if the pyramid is parseval, i.e. energy of coeffs is the same as the energy in the original image. Args: input image: image stimulus as torch.Tensor coeff: dictionary of torch tensors corresponding to each band - ''' + """ total_band_energy = 0 - im_energy = np.sum(to_numpy(im)**2) - for k,v in coeff.items(): + im_energy = np.sum(to_numpy(im) ** 2) + for k, v in coeff.items(): band = to_numpy(coeff[k]) band = band.squeeze() - total_band_energy += np.sum(np.abs(band)**2) + total_band_energy += np.sum(np.abs(band) ** 2) - np.testing.assert_allclose(total_band_energy, im_energy, rtol=rtol, atol=atol) + np.testing.assert_allclose( + total_band_energy, im_energy, rtol=rtol, atol=atol + ) class TestSteerablePyramid(object): - @pytest.fixture(scope='class', params=[f'{im}-{shape}' for im in ['einstein', 'curie'] - for shape in [None, 224, '128_1', '128_2']]) + @pytest.fixture( + scope="class", + params=[ + f"{im}-{shape}" + for im in ["einstein", "curie"] + for shape in [None, 224, "128_1", "128_2"] + ], + ) def img(self, request): - im, shape = request.param.split('-') - img = po.load_images(IMG_DIR / "256" / f'{im}.pgm').to(DEVICE) - if shape == '224': + im, shape = request.param.split("-") + img = po.load_images(IMG_DIR / "256" / f"{im}.pgm").to(DEVICE) + if shape == "224": img = img[..., :224, :224] - elif shape == '128_1': + elif shape == "128_1": img = img[..., :128, :] - elif shape == '128_2': + elif shape == "128_2": img = img[..., :128] return img - @pytest.fixture(scope='class', params=[f'{shape}' for shape in [None, 224, '128_1', '128_2' ]]) + @pytest.fixture( + scope="class", + params=[f"{shape}" for shape in [None, 224, "128_1", "128_2"]], + ) def multichannel_img(self, request): shape = request.param # use fixture for img and use color_wheel instead. - img = po.load_images(IMG_DIR / "mixed" / 'flowers.jpg', as_gray=False).to(DEVICE) - if shape == '224': + img = po.load_images( + IMG_DIR / "mixed" / "flowers.jpg", as_gray=False + ).to(DEVICE) + if shape == "224": img = img[..., :224, :224] - elif shape == '128_1': + elif shape == "128_1": img = img[..., :128, :] - elif shape == '128_2': + elif shape == "128_2": img = img[..., :128] return img @@ -108,9 +127,11 @@ def multichannel_img(self, request): # you want to test both the einstein and curie images, as well as the # different sizes. Otherwise, this will generate a bunch of tests that use # the spyr with those strange shapes - @pytest.fixture(scope='class') + @pytest.fixture(scope="class") def spyr(self, img, request): - height, order, is_complex, downsample, tightframe = request.param.split('-') + height, order, is_complex, downsample, tightframe = ( + request.param.split("-") + ) try: height = int(height) except ValueError: @@ -118,14 +139,22 @@ def spyr(self, img, request): pass # need to use eval to get from 'False' (string) to False (bool); # bool('False') == True, annoyingly enough - pyr = po.simul.SteerablePyramidFreq(img.shape[-2:], height, int(order), is_complex=eval(is_complex), - downsample=eval(downsample), tight_frame=eval(tightframe)) + pyr = po.simul.SteerablePyramidFreq( + img.shape[-2:], + height, + int(order), + is_complex=eval(is_complex), + downsample=eval(downsample), + tight_frame=eval(tightframe), + ) pyr.to(DEVICE) return pyr - @pytest.fixture(scope='class') + @pytest.fixture(scope="class") def spyr_multi(self, multichannel_img, request): - height, order, is_complex, downsample, tightframe = request.param.split('-') + height, order, is_complex, downsample, tightframe = ( + request.param.split("-") + ) try: height = int(height) except ValueError: @@ -133,57 +162,101 @@ def spyr_multi(self, multichannel_img, request): pass # need to use eval to get from 'False' (string) to False (bool); # bool('False') == True, annoyingly enough - pyr = po.simul.SteerablePyramidFreq(multichannel_img.shape[-2:], height, int(order), is_complex=eval(is_complex), - downsample=eval(downsample), tight_frame=eval(tightframe)) + pyr = po.simul.SteerablePyramidFreq( + multichannel_img.shape[-2:], + height, + int(order), + is_complex=eval(is_complex), + downsample=eval(downsample), + tight_frame=eval(tightframe), + ) pyr.to(DEVICE) return pyr # can't use one of the spyr fixtures here because we need to instantiate separately for each of these shapes - @pytest.mark.parametrize("height", ['auto', 1, 3, 4, 5]) + @pytest.mark.parametrize("height", ["auto", 1, 3, 4, 5]) @pytest.mark.parametrize("order", [1, 2, 3]) - @pytest.mark.parametrize('is_complex', [True, False]) - @pytest.mark.parametrize("im_shape", [None, (255, 255), (256, 128), (128, 256), (255, 256), - (256, 255)]) + @pytest.mark.parametrize("is_complex", [True, False]) + @pytest.mark.parametrize( + "im_shape", + [None, (255, 255), (256, 128), (128, 256), (255, 256), (256, 255)], + ) def test_pyramid(self, basic_stim, height, order, is_complex, im_shape): if im_shape is not None: - basic_stim = basic_stim[..., :im_shape[0], :im_shape[1]] - spc = po.simul.SteerablePyramidFreq(basic_stim.shape[-2:], height=height, order=order, - is_complex=is_complex).to(DEVICE) + basic_stim = basic_stim[..., : im_shape[0], : im_shape[1]] + spc = po.simul.SteerablePyramidFreq( + basic_stim.shape[-2:], + height=height, + order=order, + is_complex=is_complex, + ).to(DEVICE) spc(basic_stim) - @pytest.mark.parametrize('spyr', [f'{h}-{o}-{c}-{d}-True' for h, o, c, d in product(['auto', 1, 2, 3], - [1, 2, 3], - [True, False], - [True, False])], - indirect=True) + @pytest.mark.parametrize( + "spyr", + [ + f"{h}-{o}-{c}-{d}-True" + for h, o, c, d in product( + ["auto", 1, 2, 3], [1, 2, 3], [True, False], [True, False] + ) + ], + indirect=True, + ) def test_tight_frame(self, img, spyr): pyr_coeffs = spyr.forward(img) check_parseval(img, pyr_coeffs) - @pytest.mark.parametrize('spyr', [f'{h}-{o}-{c}-True-{t}' for h, o, c, t in product([3, 4, 5], - [1, 2, 3], - [True, False],[True, False])], - indirect=True) + @pytest.mark.parametrize( + "spyr", + [ + f"{h}-{o}-{c}-True-{t}" + for h, o, c, t in product( + [3, 4, 5], [1, 2, 3], [True, False], [True, False] + ) + ], + indirect=True, + ) def test_not_downsample(self, img, spyr): pyr_coeffs = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 + height = ( + max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 + ) # couldn't come up with a way to get this with fixtures, so we # instantiate it each time. - spyr_not_downsample = po.simul.SteerablePyramidFreq(img.shape[-2:], height, spyr.order, - is_complex=spyr.is_complex, - downsample=False, tight_frame=spyr.tight_frame) + spyr_not_downsample = po.simul.SteerablePyramidFreq( + img.shape[-2:], + height, + spyr.order, + is_complex=spyr.is_complex, + downsample=False, + tight_frame=spyr.tight_frame, + ) spyr_not_downsample.to(DEVICE) pyr_coeffs_nd = spyr_not_downsample.forward(img) check_band_energies(pyr_coeffs, pyr_coeffs_nd) - @pytest.mark.parametrize("scales", [[0], [1], [0, 1, 2], [2], None, ['residual_highpass', 'residual_lowpass'], - ['residual_highpass', 0, 1, 'residual_lowpass']]) - @pytest.mark.parametrize('spyr', [f'{h}-{o}-{c}-False-False' for h, o, c in product([3, 4, 5], - [1, 2, 3], - [True, False])], - indirect=True) + @pytest.mark.parametrize( + "scales", + [ + [0], + [1], + [0, 1, 2], + [2], + None, + ["residual_highpass", "residual_lowpass"], + ["residual_highpass", 0, 1, "residual_lowpass"], + ], + ) + @pytest.mark.parametrize( + "spyr", + [ + f"{h}-{o}-{c}-False-False" + for h, o, c in product([3, 4, 5], [1, 2, 3], [True, False]) + ], + indirect=True, + ) def test_pyr_to_tensor(self, img, spyr, scales, rtol=1e-12, atol=1e-12): pyr_coeff_dict = spyr.forward(img, scales=scales) if spyr.is_complex: @@ -191,90 +264,167 @@ def test_pyr_to_tensor(self, img, spyr, scales, rtol=1e-12, atol=1e-12): else: split_complex = [False] for val in split_complex: - pyr_tensor, pyr_info = spyr.convert_pyr_to_tensor(pyr_coeff_dict, split_complex=val) + pyr_tensor, pyr_info = spyr.convert_pyr_to_tensor( + pyr_coeff_dict, split_complex=val + ) pyr_coeff_dict2 = spyr.convert_tensor_to_pyr(pyr_tensor, *pyr_info) check_pyr_coeffs(pyr_coeff_dict, pyr_coeff_dict2, rtol, atol) - @pytest.mark.parametrize('spyr', [f'{h}-{o}-{c}-True-False' for h, o, c in product([3, 4, 5], - [1, 2, 3], - [True, False])], - indirect=True) + @pytest.mark.parametrize( + "spyr", + [ + f"{h}-{o}-{c}-True-False" + for h, o, c in product([3, 4, 5], [1, 2, 3], [True, False]) + ], + indirect=True, + ) def test_torch_vs_numpy_pyr(self, img, spyr): torch_spc = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = max([k[0] for k in torch_spc.keys() if isinstance(k[0], int)]) + 1 - pyrtools_sp = pt.pyramids.SteerablePyramidFreq(to_numpy(img.squeeze()), height=height, order=spyr.order, - is_complex=spyr.is_complex) + height = ( + max([k[0] for k in torch_spc.keys() if isinstance(k[0], int)]) + 1 + ) + pyrtools_sp = pt.pyramids.SteerablePyramidFreq( + to_numpy(img.squeeze()), + height=height, + order=spyr.order, + is_complex=spyr.is_complex, + ) pyrtools_spc = pyrtools_sp.pyr_coeffs check_pyr_coeffs(pyrtools_spc, torch_spc) - @pytest.mark.parametrize('spyr', [f'{h}-{o}-{c}-{d}-{tf}' for h, o, c, d, tf in - product(['auto', 1, 3, 4, 5], [1, 2, 3], - [True, False], [True,False], [True,False])], - indirect=True) + @pytest.mark.parametrize( + "spyr", + [ + f"{h}-{o}-{c}-{d}-{tf}" + for h, o, c, d, tf in product( + ["auto", 1, 3, 4, 5], + [1, 2, 3], + [True, False], + [True, False], + [True, False], + ) + ], + indirect=True, + ) def test_complete_recon(self, img, spyr): pyr_coeffs = spyr.forward(img) recon = to_numpy(spyr.recon_pyr(pyr_coeffs)) np.testing.assert_allclose(recon, to_numpy(img), rtol=1e-4, atol=1e-4) - @pytest.mark.parametrize('spyr_multi', [f'{h}-{o}-{c}-{d}-{tf}' for h, o, c, d, tf in - product(['auto', 1, 3, 4, 5], [1, 2, 3], - [True, False], [True,False], [True,False])], - indirect=True) + @pytest.mark.parametrize( + "spyr_multi", + [ + f"{h}-{o}-{c}-{d}-{tf}" + for h, o, c, d, tf in product( + ["auto", 1, 3, 4, 5], + [1, 2, 3], + [True, False], + [True, False], + [True, False], + ) + ], + indirect=True, + ) def test_complete_recon_multi(self, multichannel_img, spyr_multi): pyr_coeffs = spyr_multi.forward(multichannel_img) recon = to_numpy(spyr_multi.recon_pyr(pyr_coeffs)) - np.testing.assert_allclose(recon, to_numpy(multichannel_img), rtol=1e-4, atol=1e-4) + np.testing.assert_allclose( + recon, to_numpy(multichannel_img), rtol=1e-4, atol=1e-4 + ) - @pytest.mark.parametrize('spyr', [f'{h}-{o}-{c}-{d}-{tf}' for h, o, c, d, tf in - product(['auto'], [3], [True, False], - [True, False], [True, False])], - indirect=True) + @pytest.mark.parametrize( + "spyr", + [ + f"{h}-{o}-{c}-{d}-{tf}" + for h, o, c, d, tf in product( + ["auto"], [3], [True, False], [True, False], [True, False] + ) + ], + indirect=True, + ) def test_partial_recon(self, img, spyr): pyr_coeffs = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 - pt_spyr = pt.pyramids.SteerablePyramidFreq(to_numpy(img.squeeze()), height=height, order=spyr.order, - is_complex=spyr.is_complex) - recon_levels = [[0], [1,3], [1,3,4]] - recon_bands = [[1],[1,3]] - for levels, bands in product(['all'] + recon_levels, ['all'] + recon_bands): - po_recon = to_numpy(spyr.recon_pyr(pyr_coeffs, levels, bands).squeeze()) + height = ( + max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 + ) + pt_spyr = pt.pyramids.SteerablePyramidFreq( + to_numpy(img.squeeze()), + height=height, + order=spyr.order, + is_complex=spyr.is_complex, + ) + recon_levels = [[0], [1, 3], [1, 3, 4]] + recon_bands = [[1], [1, 3]] + for levels, bands in product( + ["all"] + recon_levels, ["all"] + recon_bands + ): + po_recon = to_numpy( + spyr.recon_pyr(pyr_coeffs, levels, bands).squeeze() + ) pt_recon = pt_spyr.recon_pyr(levels, bands) - np.testing.assert_allclose(po_recon, pt_recon,rtol=1e-4, atol=1e-4) + np.testing.assert_allclose( + po_recon, pt_recon, rtol=1e-4, atol=1e-4 + ) - @pytest.mark.parametrize('spyr', [f'{h}-{o}-{c}-True-False' for h, o, c in product(['auto', 1, 3, 4], - [1, 2, 3], - [True, False])], - indirect=True) + @pytest.mark.parametrize( + "spyr", + [ + f"{h}-{o}-{c}-True-False" + for h, o, c in product(["auto", 1, 3, 4], [1, 2, 3], [True, False]) + ], + indirect=True, + ) def test_recon_match_pyrtools(self, img, spyr, rtol=1e-6, atol=1e-6): # this should fail if and only if test_complete_recon does, but # may as well include it just in case pyr_coeffs = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 - pt_pyr = pt.pyramids.SteerablePyramidFreq(to_numpy(img.squeeze()), height=height, order=spyr.order, - is_complex=spyr.is_complex) + height = ( + max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 + ) + pt_pyr = pt.pyramids.SteerablePyramidFreq( + to_numpy(img.squeeze()), + height=height, + order=spyr.order, + is_complex=spyr.is_complex, + ) po_recon = po.to_numpy(spyr.recon_pyr(pyr_coeffs).squeeze()) pt_recon = pt_pyr.recon_pyr() np.testing.assert_allclose(po_recon, pt_recon, rtol=rtol, atol=atol) - @pytest.mark.parametrize("scales", [[0], [4], [0, 1, 2], [0, 3, 4], - ['residual_highpass', 'residual_lowpass'], - ['residual_highpass', 0, 1, 'residual_lowpass']]) - @pytest.mark.parametrize('spyr', [f'auto-3-{c}-{d}-False' for c, d in product([True, False], - [True, False])], - indirect=True) + @pytest.mark.parametrize( + "scales", + [ + [0], + [4], + [0, 1, 2], + [0, 3, 4], + ["residual_highpass", "residual_lowpass"], + ["residual_highpass", 0, 1, "residual_lowpass"], + ], + ) + @pytest.mark.parametrize( + "spyr", + [ + f"auto-3-{c}-{d}-False" + for c, d in product([True, False], [True, False]) + ], + indirect=True, + ) def test_scales_arg(self, img, spyr, scales): pyr_coeffs = spyr.forward(img) reduced_pyr_coeffs = spyr.forward(img, scales) for k, v in reduced_pyr_coeffs.items(): if (v != pyr_coeffs[k]).any(): - raise Exception("Reduced pyr_coeffs should be same as original, but at least key " - f"{k} is not") + raise Exception( + "Reduced pyr_coeffs should be same as original, but at" + f" least key {k} is not" + ) # recon_pyr should always fail with pytest.raises(Exception): @@ -282,23 +432,35 @@ def test_scales_arg(self, img, spyr, scales): with pytest.raises(Exception): spyr.recon_pyr(scales) - @pytest.mark.parametrize('order', range(17)) + @pytest.mark.parametrize("order", range(17)) def test_order_values(self, img, order): if order in [0, 16]: - expectation = pytest.raises(ValueError, match='order must be an integer in the range') + expectation = pytest.raises( + ValueError, match="order must be an integer in the range" + ) else: expectation = does_not_raise() with expectation: - pyr = po.simul.SteerablePyramidFreq(img.shape[-2:], order=order).to(DEVICE) + pyr = po.simul.SteerablePyramidFreq( + img.shape[-2:], order=order + ).to(DEVICE) pyr(img) - @pytest.mark.parametrize('order', range(1, 16)) + @pytest.mark.parametrize("order", range(1, 16)) def test_buffers(self, order): pyr = po.simul.SteerablePyramidFreq((256, 256), order=order) buffers = [k for k, _ in pyr.named_buffers()] - names = ['lo0mask', 'hi0mask'] + names = ["lo0mask", "hi0mask"] for s in range(pyr.num_scales): - names.extend([f'_himasks_scale_{s}', f'_lomasks_scale_{s}', - f'_anglemasks_scale_{s}', f'_anglemasks_recon_scale_{s}']) - assert len(buffers) == len(names), "pyramid doesn't have the right number of buffers!" - assert set(buffers) == set(names), "pyramid doesn't have the right buffers!" + names.extend([ + f"_himasks_scale_{s}", + f"_lomasks_scale_{s}", + f"_anglemasks_scale_{s}", + f"_anglemasks_recon_scale_{s}", + ]) + assert len(buffers) == len( + names + ), "pyramid doesn't have the right number of buffers!" + assert set(buffers) == set( + names + ), "pyramid doesn't have the right buffers!" diff --git a/tests/test_tools.py b/tests/test_tools.py index 541bbf66..d7fb9430 100644 --- a/tests/test_tools.py +++ b/tests/test_tools.py @@ -14,9 +14,13 @@ class TestData(object): def test_load_images_fail(self): - with pytest.raises(ValueError, match='All images must be the same shape'): - po.load_images([IMG_DIR / '256' / 'einstein.pgm', - IMG_DIR / 'mixed' / 'bubbles.png']) + with pytest.raises( + ValueError, match="All images must be the same shape" + ): + po.load_images([ + IMG_DIR / "256" / "einstein.pgm", + IMG_DIR / "mixed" / "bubbles.png", + ]) class TestSignal(object): @@ -33,7 +37,9 @@ def test_coordinate_identity_transform_rectangular(self): x = torch.randn(dims, device=DEVICE) y = torch.randn(dims, device=DEVICE) - z = po.tools.polar_to_rectangular(*po.tools.rectangular_to_polar(torch.complex(x, y))) + z = po.tools.polar_to_rectangular( + *po.tools.rectangular_to_polar(torch.complex(x, y)) + ) assert torch.linalg.vector_norm((x - z.real).flatten(), ord=2) < 1e-3 assert torch.linalg.vector_norm((y - z.imag).flatten(), ord=2) < 1e-3 @@ -46,7 +52,9 @@ def test_coordinate_identity_transform_polar(self): a = a / a.max() b = po.tools.rescale(torch.randn(dims, device=DEVICE), -pi / 2, pi / 2) - A, B = po.tools.rectangular_to_polar(po.tools.polar_to_rectangular(a, b)) + A, B = po.tools.rectangular_to_polar( + po.tools.polar_to_rectangular(a, b) + ) assert torch.linalg.vector_norm((a - A).flatten(), ord=2) < 1e-3 assert torch.linalg.vector_norm((b - B).flatten(), ord=2) < 1e-3 @@ -59,27 +67,33 @@ def test_autocorrelation(self, n): a = po.tools.center_crop(a, n) # autocorr with zero delay is variance - assert (torch.abs( - torch.var(x, dim=(2, 3)) - a[..., n//2, n//2]) - < 1e-5).all() + assert ( + torch.abs(torch.var(x, dim=(2, 3)) - a[..., n // 2, n // 2]) < 1e-5 + ).all() # autocorr can be computed in signal domain directly with roll - h = randint(-(n//2), ((n+1)//2)) - assert (torch.abs( + h = randint(-(n // 2), ((n + 1) // 2)) + assert ( + torch.abs( (x_centered * torch.roll(x_centered, h, dims=2)).sum((2, 3)) - / (x.shape[-2]*x.shape[-1]) - - a[..., n//2+h, n//2]) - < 1e-5).all() - - w = randint(-(n//2), ((n+1)//2)) - assert (torch.abs( + / (x.shape[-2] * x.shape[-1]) + - a[..., n // 2 + h, n // 2] + ) + < 1e-5 + ).all() + + w = randint(-(n // 2), ((n + 1) // 2)) + assert ( + torch.abs( (x_centered * torch.roll(x_centered, w, dims=3)).sum((2, 3)) - / (x.shape[-2]*x.shape[-1]) - - a[..., n//2, n//2+w]) - < 1e-5).all() - - @pytest.mark.parametrize('size_A', [1, 3]) - @pytest.mark.parametrize('size_B', [1, 2, 3]) + / (x.shape[-2] * x.shape[-1]) + - a[..., n // 2, n // 2 + w] + ) + < 1e-5 + ).all() + + @pytest.mark.parametrize("size_A", [1, 3]) + @pytest.mark.parametrize("size_B", [1, 2, 3]) def test_add_noise(self, einstein_img, size_A, size_B): A = einstein_img.repeat(size_A, 1, 1, 1) B = size_B * [4] @@ -89,52 +103,79 @@ def test_add_noise(self, einstein_img, size_A, size_B): else: assert po.tools.add_noise(A, B).shape[0] == max(size_A, size_B) - - @pytest.mark.parametrize('factor', [.5, 1, 1.5, 2, 1.1]) - @pytest.mark.parametrize('img_size', [256, 128, 200]) + @pytest.mark.parametrize("factor", [0.5, 1, 1.5, 2, 1.1]) + @pytest.mark.parametrize("img_size", [256, 128, 200]) def test_expand(self, factor, img_size, einstein_img): einstein_img = einstein_img.clone()[..., :img_size] if int(factor * img_size) != factor * img_size: - expectation = pytest.raises(ValueError, match='factor \* x.shape\[-1\] must be') - elif int(factor * einstein_img.shape[-2]) != factor * einstein_img.shape[-2]: - expectation = pytest.raises(ValueError, match='factor \* x.shape\[-2\] must be') + expectation = pytest.raises( + ValueError, match="factor \* x.shape\[-1\] must be" + ) + elif ( + int(factor * einstein_img.shape[-2]) + != factor * einstein_img.shape[-2] + ): + expectation = pytest.raises( + ValueError, match="factor \* x.shape\[-2\] must be" + ) elif factor <= 1: - expectation = pytest.raises(ValueError, match='factor must be strictly greater') + expectation = pytest.raises( + ValueError, match="factor must be strictly greater" + ) else: expectation = does_not_raise() with expectation: expanded = po.tools.expand(einstein_img, factor) - np.testing.assert_equal(expanded.shape[-2:], [factor * s for s in einstein_img.shape[-2:]]) + np.testing.assert_equal( + expanded.shape[-2:], + [factor * s for s in einstein_img.shape[-2:]], + ) - @pytest.mark.parametrize('factor', [.5, 1, 1.5, 2, 1.1]) - @pytest.mark.parametrize('img_size', [256, 128, 200]) + @pytest.mark.parametrize("factor", [0.5, 1, 1.5, 2, 1.1]) + @pytest.mark.parametrize("img_size", [256, 128, 200]) def test_shrink(self, factor, img_size, einstein_img): einstein_img = einstein_img.clone()[..., :img_size] if int(img_size / factor) != img_size / factor: - expectation = pytest.raises(ValueError, match='x.shape\[-1\]/factor must be') - elif int(einstein_img.shape[-2] / factor) != einstein_img.shape[-2] / factor: - expectation = pytest.raises(ValueError, match='x.shape\[-2\]/factor must be') + expectation = pytest.raises( + ValueError, match="x.shape\[-1\]/factor must be" + ) + elif ( + int(einstein_img.shape[-2] / factor) + != einstein_img.shape[-2] / factor + ): + expectation = pytest.raises( + ValueError, match="x.shape\[-2\]/factor must be" + ) elif factor <= 1: - expectation = pytest.raises(ValueError, match='factor must be strictly greater') + expectation = pytest.raises( + ValueError, match="factor must be strictly greater" + ) else: expectation = does_not_raise() with expectation: shrunk = po.tools.shrink(einstein_img, factor) - np.testing.assert_equal(shrunk.shape[-2:], [s / factor for s in einstein_img.shape[-2:]]) + np.testing.assert_equal( + shrunk.shape[-2:], + [s / factor for s in einstein_img.shape[-2:]], + ) @pytest.mark.parametrize("batch_channel", [[1, 3], [2, 1], [2, 3]]) def test_shrink_batch_channel(self, batch_channel, einstein_img): - shrunk = po.tools.shrink(einstein_img.repeat((*batch_channel, 1, 1)), 2) + shrunk = po.tools.shrink( + einstein_img.repeat((*batch_channel, 1, 1)), 2 + ) size = batch_channel + [s / 2 for s in einstein_img.shape[-2:]] np.testing.assert_equal(shrunk.shape, size) @pytest.mark.parametrize("batch_channel", [[1, 3], [2, 1], [2, 3]]) def test_expand_batch_channel(self, batch_channel, einstein_img): - expanded = po.tools.expand(einstein_img.repeat((*batch_channel, 1, 1)), 2) + expanded = po.tools.expand( + einstein_img.repeat((*batch_channel, 1, 1)), 2 + ) size = batch_channel + [2 * s for s in einstein_img.shape[-2:]] np.testing.assert_equal(expanded.shape, size) - @pytest.mark.parametrize('factor', [1.5, 2]) + @pytest.mark.parametrize("factor", [1.5, 2]) @pytest.mark.parametrize("img", ["curie", "einstein", "metal", "nuts"]) def test_expand_shrink(self, img, factor): # expand then shrink will be the same as the original image, up to this @@ -143,7 +184,7 @@ def test_expand_shrink(self, img, factor): modified = po.tools.shrink(po.tools.expand(img, factor), factor) torch.testing.assert_close(img, modified, atol=2e-2, rtol=1e-6) - @pytest.mark.parametrize("phase", [0, np.pi/2, np.pi]) + @pytest.mark.parametrize("phase", [0, np.pi / 2, np.pi]) def test_modulate_phase_correlation(self, phase): # here we create an image that has sinusoids at two frequencies, with # some phase offset. Because their frequencies are an octave apart, @@ -154,7 +195,7 @@ def test_modulate_phase_correlation(self, phase): # frequency one (this trick is used in th PS texture model) X = torch.arange(256).unsqueeze(1).repeat(1, 256) / 256 * 2 * torch.pi X = X.unsqueeze(0).unsqueeze(0) - X = torch.sin(8*X) + torch.sin(16*X+phase) + X = torch.sin(8 * X) + torch.sin(16 * X + phase) pyr = po.simul.SteerablePyramidFreq(X.shape[-2:], is_complex=True) pyr_coeffs = pyr(X) @@ -165,10 +206,10 @@ def test_modulate_phase_correlation(self, phase): # this is the correlation as computed in the PS texture model, which is # where modulate phase is used - corr = einops.einsum(a.real, b.real, 'b c h w, b c h w -> b c') + corr = einops.einsum(a.real, b.real, "b c h w, b c h w -> b c") corr = corr / (torch.mul(*a.shape[-2:])) / (a.std() * b.std()) - tgt_corr = {0: .4999, np.pi/2: 0, np.pi: -.4999}[phase] + tgt_corr = {0: 0.4999, np.pi / 2: 0, np.pi: -0.4999}[phase] np.testing.assert_allclose(corr, tgt_corr, rtol=1e-5, atol=1e-5) @@ -176,14 +217,16 @@ def test_modulate_phase_noreal(self): X = torch.arange(256).unsqueeze(1).repeat(1, 256) / 256 * 2 * torch.pi X = X.unsqueeze(0).unsqueeze(0) - with pytest.raises(TypeError, match="x must be a complex-valued tensor"): + with pytest.raises( + TypeError, match="x must be a complex-valued tensor" + ): po.tools.modulate_phase(X) @pytest.mark.parametrize("batch_channel", [(1, 3), (2, 1), (2, 3)]) def test_modulate_phase_batch_channel(self, batch_channel): X = torch.arange(256).unsqueeze(1).repeat(1, 256) / 256 * 2 * torch.pi X = X.unsqueeze(0).unsqueeze(0).repeat((*batch_channel, 1, 1)) - X = torch.sin(8*X) + torch.sin(16*X) + X = torch.sin(8 * X) + torch.sin(16 * X) pyr = po.simul.SteerablePyramidFreq(X.shape[-2:], is_complex=True) pyr_coeffs = pyr(X) @@ -200,6 +243,7 @@ def test_modulate_phase_batch_channel(self, batch_channel): np.testing.assert_array_equal(a, a.roll(1, 1)) np.testing.assert_array_equal(a, a.roll(1, 0)) + class TestStats(object): def test_stats(self): @@ -208,8 +252,10 @@ def test_stats(self): x = torch.randn(B, D) m = torch.mean(x, dim=1, keepdim=True) v = po.tools.variance(x, mean=m, dim=1, keepdim=True) - assert (torch.abs(v - torch.var(x, dim=1, keepdim=True, unbiased=False) - ) < 1e-5).all() + assert ( + torch.abs(v - torch.var(x, dim=1, keepdim=True, unbiased=False)) + < 1e-5 + ).all() s = po.tools.skew(x, mean=m, var=v, dim=1) k = po.tools.kurtosis(x, mean=m, var=v, dim=1) assert torch.abs(k.mean() - 3) < 1e-1 @@ -245,12 +291,15 @@ def test_kurt_multidim(self, batch_channel): kurt = po.tools.kurtosis(x, dim=(-1, -2)) np.testing.assert_equal(kurt.shape, batch_channel) + class TestDownsampleUpsample(object): - @pytest.mark.parametrize('odd', [0, 1]) - @pytest.mark.parametrize('size', [9, 10, 11, 12]) + @pytest.mark.parametrize("odd", [0, 1]) + @pytest.mark.parametrize("size", [9, 10, 11, 12]) def test_filter(self, odd, size): - img = torch.zeros([1, 1, 24 + odd, 25], device=DEVICE, dtype=torch.float32) + img = torch.zeros( + [1, 1, 24 + odd, 25], device=DEVICE, dtype=torch.float32 + ) img[0, 0, 12, 12] = 1 filt = np.zeros([size, size + 1]) filt[5, 5] = 1 @@ -258,11 +307,15 @@ def test_filter(self, odd, size): filt = torch.as_tensor(filt, dtype=torch.float32, device=DEVICE) img_down = po.tools.correlate_downsample(img, filt=filt) img_up = po.tools.upsample_convolve(img_down, odd=(odd, 1), filt=filt) - assert np.unravel_index(img_up.cpu().numpy().argmax(), img_up.shape) == (0, 0, 12, 12) + assert np.unravel_index( + img_up.cpu().numpy().argmax(), img_up.shape + ) == (0, 0, 12, 12) img_down = po.tools.blur_downsample(img) img_up = po.tools.upsample_blur(img_down, odd=(odd, 1)) - assert np.unravel_index(img_up.cpu().numpy().argmax(), img_up.shape) == (0, 0, 12, 12) + assert np.unravel_index( + img_up.cpu().numpy().argmax(), img_up.shape + ) == (0, 0, 12, 12) def test_multichannel(self): img = torch.randn([10, 3, 24, 25], device=DEVICE, dtype=torch.float32) @@ -279,15 +332,33 @@ def test_multichannel(self): class TestValidate(object): # https://docs.pytest.org/en/4.6.x/example/parametrize.html#parametrizing-conditional-raising - @pytest.mark.parametrize('shape,expectation', [ - ((1, 1, 16, 16), does_not_raise()), - ((1, 3, 16, 16), does_not_raise()), - ((2, 1, 16, 16), does_not_raise()), - ((2, 3, 16, 16), does_not_raise()), - ((1, 1, 1, 16, 16), pytest.raises(ValueError, match="input_tensor must be torch.Size")), - ((1, 16, 16), pytest.raises(ValueError, match="input_tensor must be torch.Size")), - ((16, 16), pytest.raises(ValueError, match="input_tensor must be torch.Size")), - ]) + @pytest.mark.parametrize( + "shape,expectation", + [ + ((1, 1, 16, 16), does_not_raise()), + ((1, 3, 16, 16), does_not_raise()), + ((2, 1, 16, 16), does_not_raise()), + ((2, 3, 16, 16), does_not_raise()), + ( + (1, 1, 1, 16, 16), + pytest.raises( + ValueError, match="input_tensor must be torch.Size" + ), + ), + ( + (1, 16, 16), + pytest.raises( + ValueError, match="input_tensor must be torch.Size" + ), + ), + ( + (16, 16), + pytest.raises( + ValueError, match="input_tensor must be torch.Size" + ), + ), + ], + ) def test_input_shape(self, shape, expectation): img = torch.rand(*shape) with expectation: @@ -295,27 +366,48 @@ def test_input_shape(self, shape, expectation): def test_input_no_batch(self): img = torch.rand(2, 1, 16, 16) - with pytest.raises(ValueError, match="input_tensor batch dimension must be 1"): + with pytest.raises( + ValueError, match="input_tensor batch dimension must be 1" + ): po.tools.validate.validate_input(img, no_batch=True) - @pytest.mark.parametrize('minmax,expectation', [ - ('min',pytest.raises(ValueError, match="input_tensor range must lie within")), - ('max',pytest.raises(ValueError, match="input_tensor range must lie within")), - ('range',pytest.raises(ValueError, match=r"allowed_range\[0\] must be strictly less")), - ]) + @pytest.mark.parametrize( + "minmax,expectation", + [ + ( + "min", + pytest.raises( + ValueError, match="input_tensor range must lie within" + ), + ), + ( + "max", + pytest.raises( + ValueError, match="input_tensor range must lie within" + ), + ), + ( + "range", + pytest.raises( + ValueError, + match=r"allowed_range\[0\] must be strictly less", + ), + ), + ], + ) def test_input_allowed_range(self, minmax, expectation): img = torch.rand(1, 1, 16, 16) allowed_range = (0, 1) - if minmax == 'min': + if minmax == "min": img -= 1 - elif minmax == 'max': + elif minmax == "max": img += 1 - elif minmax == 'range': + elif minmax == "range": allowed_range = (1, 0) with expectation: po.tools.validate.validate_input(img, allowed_range=allowed_range) - @pytest.mark.parametrize('model', ['frontend.OnOff'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff"], indirect=True) def test_model_learnable(self, model): with pytest.raises(ValueError, match="model adds gradient to input"): po.tools.validate.validate_model(model, device=DEVICE) @@ -324,11 +416,14 @@ def test_model_numpy_comp(self): class TestModel(torch.nn.Module): def __init__(self): super().__init__() + def forward(self, img): return np.fft.fft(img) model = TestModel() - with pytest.raises(ValueError, match="model does not return a torch.Tensor object"): + with pytest.raises( + ValueError, match="model does not return a torch.Tensor object" + ): # don't pass device here because the model just uses numpy, which # only works on cpu po.tools.validate.validate_model(model) @@ -337,22 +432,29 @@ def test_model_detach(self): class TestModel(torch.nn.Module): def __init__(self): super().__init__() + def forward(self, img): return img.detach() model = TestModel() - with pytest.raises(ValueError, match="model strips gradient from input"): + with pytest.raises( + ValueError, match="model strips gradient from input" + ): po.tools.validate.validate_model(model, device=DEVICE) def test_model_numpy_and_back(self): class TestModel(torch.nn.Module): def __init__(self): super().__init__() + def forward(self, img): return torch.from_numpy(np.fft.fft(img)) model = TestModel() - with pytest.raises(ValueError, match="model tries to cast the input into something other"): + with pytest.raises( + ValueError, + match="model tries to cast the input into something other", + ): # don't pass device here because the model just uses numpy, which # only works on cpu po.tools.validate.validate_model(model) @@ -361,54 +463,70 @@ def test_model_precision(self): class TestModel(torch.nn.Module): def __init__(self): super().__init__() + def forward(self, img): return img.to(torch.float16) model = TestModel() - with pytest.raises(TypeError, match="model changes precision of input"): + with pytest.raises( + TypeError, match="model changes precision of input" + ): po.tools.validate.validate_model(model, device=DEVICE) - @pytest.mark.parametrize('direction', ['squeeze', 'unsqueeze']) + @pytest.mark.parametrize("direction", ["squeeze", "unsqueeze"]) def test_model_output_dim(self, direction): class TestModel(torch.nn.Module): def __init__(self): super().__init__() + def forward(self, img): - if direction == 'squeeze': + if direction == "squeeze": return img.squeeze() - elif direction == 'unsqueeze': + elif direction == "unsqueeze": return img.unsqueeze(0) model = TestModel() - with pytest.raises(ValueError, match="When given a 4d input, model output"): + with pytest.raises( + ValueError, match="When given a 4d input, model output" + ): po.tools.validate.validate_model(model, device=DEVICE) - @pytest.mark.skipif(DEVICE.type == 'cpu', reason="Only makes sense to test on cuda") + @pytest.mark.skipif( + DEVICE.type == "cpu", reason="Only makes sense to test on cuda" + ) def test_model_device(self): class TestModel(torch.nn.Module): def __init__(self): super().__init__() + def forward(self, img): - return img.to('cpu') + return img.to("cpu") model = TestModel() - with pytest.raises(RuntimeError, match="model changes device of input"): + with pytest.raises( + RuntimeError, match="model changes device of input" + ): po.tools.validate.validate_model(model, device=DEVICE) - @pytest.mark.parametrize("model", ['ColorModel'], indirect=True) + @pytest.mark.parametrize("model", ["ColorModel"], indirect=True) def test_model_image_shape(self, model): img_shape = (1, 3, 16, 16) - po.tools.validate.validate_model(model, image_shape=img_shape, device=DEVICE) + po.tools.validate.validate_model( + model, image_shape=img_shape, device=DEVICE + ) def test_validate_ctf_scales(self): class TestModel(torch.nn.Module): def __init__(self): super().__init__() + def forward(self, img): return img model = TestModel() - with pytest.raises(AttributeError, match="model has no scales attribute"): + with pytest.raises( + AttributeError, match="model has no scales attribute" + ): po.tools.validate.validate_coarse_to_fine(model, device=DEVICE) def test_validate_ctf_arg(self): @@ -416,11 +534,15 @@ class TestModel(torch.nn.Module): def __init__(self): super().__init__() self.scales = [0, 1, 2] + def forward(self, img): return img model = TestModel() - with pytest.raises(TypeError, match="model forward method does not accept scales argument"): + with pytest.raises( + TypeError, + match="model forward method does not accept scales argument", + ): po.tools.validate.validate_coarse_to_fine(model, device=DEVICE) def test_validate_ctf_shape(self): @@ -428,33 +550,44 @@ class TestModel(torch.nn.Module): def __init__(self): super().__init__() self.scales = [0, 1, 2] + def forward(self, img, scales=[]): return img model = TestModel() - with pytest.raises(ValueError, match="Output of model forward method doesn't change shape"): + with pytest.raises( + ValueError, + match="Output of model forward method doesn't change shape", + ): po.tools.validate.validate_coarse_to_fine(model, device=DEVICE) def test_validate_ctf_pass(self): model = po.simul.PortillaSimoncelli((256, 256)).to(DEVICE) - po.tools.validate.validate_coarse_to_fine(model, image_shape=(1, 1, *model.image_shape), - device=DEVICE) + po.tools.validate.validate_coarse_to_fine( + model, image_shape=(1, 1, *model.image_shape), device=DEVICE + ) def test_validate_metric_inputs(self): metric = lambda x: x - with pytest.raises(TypeError, match="metric should be callable and accept two"): + with pytest.raises( + TypeError, match="metric should be callable and accept two" + ): po.tools.validate.validate_metric(metric, device=DEVICE) def test_validate_metric_output_shape(self): - metric = lambda x, y: x-y - with pytest.raises(ValueError, match="metric should return a scalar value but output"): + metric = lambda x, y: x - y + with pytest.raises( + ValueError, match="metric should return a scalar value but output" + ): po.tools.validate.validate_metric(metric, device=DEVICE) def test_validate_metric_identical(self): - metric = lambda x, y : (x+y).mean() - with pytest.raises(ValueError, match="metric should return <= 5e-7 on two identical"): + metric = lambda x, y: (x + y).mean() + with pytest.raises( + ValueError, match="metric should return <= 5e-7 on two identical" + ): po.tools.validate.validate_metric(metric, device=DEVICE) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_remove_grad(self, model): po.tools.validate.validate_model(model, device=DEVICE) diff --git a/tests/utils.py b/tests/utils.py index af296add..fc871ab3 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -1,11 +1,14 @@ -"""Helper functions for testing. -""" +"""Helper functions for testing.""" + import torch import re import plenoptic as po import pyrtools as pt import numpy as np -from test_models import TestPortillaSimoncelli, get_portilla_simoncelli_synthesize_filename +from test_models import ( + TestPortillaSimoncelli, + get_portilla_simoncelli_synthesize_filename, +) from typing import Optional @@ -35,34 +38,54 @@ def update_ps_synthesis_test_file(torch_version: Optional[str] = None): Metamer object for inspection """ - ps_synth_file = po.data.fetch_data(get_portilla_simoncelli_synthesize_filename(torch_version)) - print(f'Loading from {ps_synth_file}') + ps_synth_file = po.data.fetch_data( + get_portilla_simoncelli_synthesize_filename(torch_version) + ) + print(f"Loading from {ps_synth_file}") with np.load(ps_synth_file) as f: - im = f['im'] - im_init = f['im_init'] - im_synth = f['im_synth'] - rep_synth = f['rep_synth'] + im = f["im"] + im_init = f["im_init"] + im_synth = f["im_synth"] + rep_synth = f["rep_synth"] met = TestPortillaSimoncelli().test_ps_synthesis(ps_synth_file, False) - torch_v = torch.__version__.split('+')[0] - file_name_parts = re.findall('(.*portilla_simoncelli_synthesize)(_gpu)?(_torch_v)?([0-9.]*)(_ps-refactor)?.npz', - ps_synth_file)[0] - output_file_name = ''.join(file_name_parts[:2]) + f'_torch_v{torch_v}{file_name_parts[-1]}.npz' + torch_v = torch.__version__.split("+")[0] + file_name_parts = re.findall( + "(.*portilla_simoncelli_synthesize)(_gpu)?(_torch_v)?([0-9.]*)(_ps-refactor)?.npz", + ps_synth_file, + )[0] + output_file_name = ( + "".join(file_name_parts[:2]) + + f"_torch_v{torch_v}{file_name_parts[-1]}.npz" + ) output = po.to_numpy(met.metamer).squeeze() rep = po.to_numpy(met.model(met.metamer)).squeeze() try: - np.testing.assert_allclose(output, im_synth.squeeze(), rtol=1e-4, atol=1e-4) - np.testing.assert_allclose(rep, rep_synth.squeeze(), rtol=1e-4, atol=1e-4) - print("Current synthesis same as saved version, so not saving current synthesis.") + np.testing.assert_allclose( + output, im_synth.squeeze(), rtol=1e-4, atol=1e-4 + ) + np.testing.assert_allclose( + rep, rep_synth.squeeze(), rtol=1e-4, atol=1e-4 + ) + print( + "Current synthesis same as saved version, so not saving current" + " synthesis." + ) # only do all this if the tests would've failed except AssertionError: print(f"Saving at {output_file_name}") - np.savez(output_file_name, im=im, im_init=im_init, im_synth=output, - rep_synth=rep) - fig = pt.imshow([output, im_synth.squeeze()], - title=[f'New metamer (torch {torch_v})', - 'Old metamer']) - fig.savefig(output_file_name.replace('.npz', '.png')) + np.savez( + output_file_name, + im=im, + im_init=im_init, + im_synth=output, + rep_synth=rep, + ) + fig = pt.imshow( + [output, im_synth.squeeze()], + title=[f"New metamer (torch {torch_v})", "Old metamer"], + ) + fig.savefig(output_file_name.replace(".npz", ".png")) return met From d367c221413a4327722631b376e461326b8388fa Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Wed, 14 Aug 2024 09:49:48 -0400 Subject: [PATCH 049/134] too long lines shortened to 88 characters in data and metric --- src/plenoptic/metric/perceptual_distance.py | 18 ++++--- .../laplacian_pyramid.py | 7 +-- .../steerable_pyramid_freq.py | 53 +++++++++++-------- 3 files changed, 46 insertions(+), 32 deletions(-) diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index 21f56b55..f8fbfb6f 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -411,18 +411,19 @@ def normalized_laplacian_pyramid(img): def nlpd(img1, img2): """Normalized Laplacian Pyramid Distance - As described in [1]_, this is an image quality metric based on the transformations associated with the early - visual system: local luminance subtraction and local contrast gain control + As described in [1]_, this is an image quality metric based on the transformations + associated with the early visual system: local luminance subtraction and local + contrast gain control. A laplacian pyramid subtracts a local estimate of the mean luminance at six scales. - Then a local gain control divides these centered coefficients by a weighted sum of absolute values - in spatial neighborhood. + Then a local gain control divides these centered coefficients by a weighted sum of + absolute values in spatial neighborhood. These weights parameters were optimized for redundancy reduction over an training database of (undistorted) natural images. - Note that we compute root mean squared error for each scale, and then average over these, - effectively giving larger weight to the lower frequency coefficients + Note that we compute root mean squared error for each scale, and then average over + these, effectively giving larger weight to the lower frequency coefficients (which are fewer in number, due to subsampling). Parameters @@ -445,8 +446,9 @@ def nlpd(img1, img2): References ---------- - .. [1] Laparra, V., Ballé, J., Berardino, A. and Simoncelli, E.P., 2016. Perceptual image quality - assessment using a normalized Laplacian pyramid. Electronic Imaging, 2016(16), pp.1-6. + .. [1] Laparra, V., Ballé, J., Berardino, A. and Simoncelli, E.P., 2016. Perceptual + image quality assessment using a normalized Laplacian pyramid. Electronic Imaging, + 2016(16), pp.1-6. """ if not img1.ndim == img2.ndim == 4: diff --git a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py index ac7b03b3..bf2f690c 100644 --- a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py +++ b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py @@ -17,9 +17,10 @@ class LaplacianPyramid(nn.Module): n_scales: int number of scales to compute scale_filter: bool, optional - If true, the norm of the downsampling/upsampling filter is 1. If false (default), it is 2. - If the norm is 1, the image is multiplied by 4 during the upsampling operation; the net effect - is that the `n`th scale of the pyramid is divided by `2^n`. + If true, the norm of the downsampling/upsampling filter is 1. If false + (default), it is 2. + If the norm is 1, the image is multiplied by 4 during the upsampling operation; + the net effect is that the `n`th scale of the pyramid is divided by `2^n`. References ---------- diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 1be64b70..1a83a906 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -339,10 +339,13 @@ def forward( himask = getattr(self, f"_himasks_scale_{i}") # compute filter output at each orientation for b in range(self.num_orientations): - # band pass filtering is done in the fourier space as multiplying by the fft of a gaussian derivative. - # The oriented dft is computed as a product of the fft of the low-passed component, - # the precomputed anglemask (specifies orientation), and the precomputed hipass mask (creating a bandpass filter) - # the complex_const variable comes from the Fourier transform of a gaussian derivative. + # band pass filtering is done in the fourier space as multiplying + # by the fft of a gaussian derivative. + # The oriented dft is computed as a product of the fft of the + # low-passed component, the precomputed anglemask (specifies + # orientation), and the precomputed hipass mask (creating a bandpass + # filter) the complex_const variable comes from the Fourier + # transform of a gaussian derivative. # Based on the order of the gaussian, this constant changes. anglemask = getattr(self, f"_anglemasks_scale_{i}")[b] @@ -351,7 +354,8 @@ def forward( banddft = complex_const * lodft * anglemask * himask # fft output is then shifted to center frequencies band = fft.ifftshift(banddft) - # ifft is applied to recover the filtered representation in spatial domain + # ifft is applied to recover the filtered representation in spatial + # domain band = fft.ifft2(band, dim=(-2, -1), norm=self.fft_norm) # for real pyramid, take the real component of the complex band @@ -359,8 +363,8 @@ def forward( pyr_coeffs[(i, b)] = band.real else: # Because the input signal is real, to maintain a tight frame - # if the complex pyramid is used, magnitudes need to be divided by sqrt(2) - # because energy is doubled. + # if the complex pyramid is used, magnitudes need to be divided + # by sqrt(2) because energy is doubled. if self.tight_frame: band = band / np.sqrt(2) @@ -373,9 +377,11 @@ def forward( lomask = getattr(self, f"_lomasks_scale_{i}") lodft = lodft * lomask - # because we don't subsample here, if we are not using orthonormalization that - # we need to manually account for the subsampling, so that energy in each band remains the same - # the energy is cut by factor of 4 so we need to scale magnitudes by factor of 2 + # Since we don't subsample here, if we are not using + # orthonormalization that we need to manually account for the + # subsampling, so that energy in each band remains the same + # the energy is cut by factor of 4 so we need to scale magnitudes + # by factor of 2. if self.fft_norm != "ortho": lodft = 2 * lodft @@ -617,8 +623,8 @@ def _recon_levels_check( if "residual_lowpass" in levels: levs_tmp = levs_tmp + ["residual_lowpass"] levels = levs_tmp - # not all pyramids have residual highpass / lowpass, but it's easier to construct the list - # including them, then remove them if necessary. + # not all pyramids have residual highpass / lowpass, but it's easier + # to construct the list including them, then remove them if necessary. if ( "residual_lowpass" not in self.pyr_size.keys() and "residual_lowpass" in levels @@ -634,9 +640,10 @@ def _recon_levels_check( def _recon_bands_check(self, bands: Literal["all"] | list[int]) -> list[int]: """Check whether bands arg is valid for reconstruction and return valid version - When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies - which orientations to include. This makes sure those orientations are valid and gets them - in the form we expect for the rest of the reconstruction. If the user passes `'all'`, this + When reconstructing the input image (i.e., when calling `recon_pyr()`), + the user specifies which orientations to include. This makes sure those + orientations are valid and gets them in the form we expect for the rest + of the reconstruction. If the user passes `'all'`, this constructs the appropriate list (based on the values of `pyr_coeffs`). Parameters @@ -679,7 +686,8 @@ def _recon_keys( bands: Literal["all"] | list[int], max_orientations: int | None = None, ) -> list[KEYS_TYPE]: - """Make a list of all the relevant keys from `pyr_coeffs` to use in pyramid reconstruction + """Make a list of all the relevant keys from `pyr_coeffs` to use in pyramid + reconstruction When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies some subset of the pyramid coefficients to include @@ -738,7 +746,8 @@ def recon_pyr( levels: Literal["all"] | list[SCALES_TYPE] = "all", bands: Literal["all"] | list[int] = "all", ) -> Tensor: - """Reconstruct the image or batch of images, optionally using subset of pyramid coefficients. + """Reconstruct the image or batch of images, optionally using subset of + pyramid coefficients. NOTE: in order to call this function, you need to have previously called `self.forward(x)`, where `x` is the tensor you @@ -894,7 +903,8 @@ def _recon_levels( # Recursively reconstruct by going to the next scale reslevdft = self._recon_levels(pyr_coeffs, recon_keys, scale + 1) - # in not downsampled case, rescale the magnitudes of the reconstructed dft at each level by factor of 2 to account for the scaling in the forward + # in not downsampled case, rescale the magnitudes of the reconstructed + # dft at each level by factor of 2 to account for the scaling in the forward if (not self.tight_frame) and (not self.downsample): reslevdft = reslevdft / 2 # create output for reconstruction result @@ -914,8 +924,8 @@ def steer_coeffs( ) -> tuple[dict, dict]: """Steer pyramid coefficients to the specified angles - This allows you to have filters that have the Gaussian derivative order specified in - construction, but arbitrary angles or number of orientations. + This allows you to have filters that have the Gaussian derivative order + specified in construction, but arbitrary angles or number of orientations. Parameters ---------- @@ -924,7 +934,8 @@ def steer_coeffs( angles : list of angles (in radians) to steer the pyramid coefficients to even_phase : - specifies whether the harmonics are cosine or sine phase aligned about those positions. + specifies whether the harmonics are cosine or sine phase aligned + about those positions. Returns ------- From 5b76b6a90958463179126f0bf31571edc20bf720 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 15 Aug 2024 09:35:34 -0400 Subject: [PATCH 050/134] . --- src/plenoptic/simulate/models/frontend.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index edd378b8..026208bd 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -63,8 +63,8 @@ class LinearNonlinear(nn.Module): References ---------- - .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of hierarchical - representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 + .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions + of hierarchical representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ @@ -147,8 +147,8 @@ class LuminanceGainControl(nn.Module): References ---------- - .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of hierarchical - representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 + .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of + hierarchical representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ @@ -257,8 +257,8 @@ class LuminanceContrastGainControl(nn.Module): References ---------- - .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of hierarchical - representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 + .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of + hierarchical representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ From f3eb287d09de5224641b33f710618bd736214901 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 15 Aug 2024 09:57:05 -0400 Subject: [PATCH 051/134] some more fixes --- noxfile.py | 1 - .../simulate/canonical_computations/steerable_pyramid_freq.py | 2 +- src/plenoptic/simulate/models/frontend.py | 2 +- src/plenoptic/simulate/models/portilla_simoncelli.py | 2 +- src/plenoptic/synthesize/eigendistortion.py | 4 ++-- src/plenoptic/synthesize/geodesic.py | 2 +- src/plenoptic/synthesize/mad_competition.py | 4 ++-- src/plenoptic/synthesize/metamer.py | 4 ++-- 8 files changed, 10 insertions(+), 11 deletions(-) diff --git a/noxfile.py b/noxfile.py index b175e108..9a4c5c63 100644 --- a/noxfile.py +++ b/noxfile.py @@ -1,5 +1,4 @@ import nox -import sys from pathlib import Path diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 1a83a906..698bf6b7 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -15,7 +15,7 @@ from einops import rearrange from scipy.special import factorial from torch import Tensor -from typing_extensions import Literal +from typing import Literal from numpy.typing import NDArray from ...tools.signal import interpolate1d, raised_cosine, steer diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 026208bd..2dacf3fd 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -10,7 +10,7 @@ .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ -from typing import Callable +from collections.abc import Callable import torch import torch.nn as nn diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index fe4b482a..39a61253 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -18,7 +18,7 @@ import torch.fft import torch.nn as nn from torch import Tensor -from typing_extensions import Literal +from typing import Literal from ...tools import signal, stats from ...tools.data import to_numpy diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 40ac8a8d..6c755230 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -1,6 +1,6 @@ -from typing import Callable +from collections.abc import Callable import warnings -from typing_extensions import Literal +from typing import Literal import matplotlib.pyplot from matplotlib.figure import Figure diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index 95fc8e37..fad74460 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -6,7 +6,7 @@ import torch.autograd as autograd from torch import Tensor from tqdm.auto import tqdm -from typing_extensions import Literal +from typing import Literal from .synthesis import OptimizedSynthesis from ..tools.data import to_numpy diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 45cccab7..cdf29626 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -5,8 +5,8 @@ from torch import Tensor from tqdm.auto import tqdm from ..tools import optim, display, data -from typing import Callable -from typing_extensions import Literal +from collections.abc import Callable +from typing import Literal from .synthesis import OptimizedSynthesis import warnings import matplotlib as mpl diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index 4f62dc79..edee0479 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -13,8 +13,8 @@ validate_coarse_to_fine, ) from ..tools.convergence import coarse_to_fine_enough, loss_convergence -from typing import Callable -from typing_extensions import Literal +from collections.abc import Callable +from typing import Literal from .synthesis import OptimizedSynthesis import warnings import matplotlib as mpl From 46bc83478626d1121a24613523deb67c3d4534eb Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 15 Aug 2024 12:18:39 -0400 Subject: [PATCH 052/134] removed .keys() from dictionary iteration, replaced if-else with 1-liners, used f-strings, shortened if statements with boolean expressions, added contextlib for with statements, and refactored lambda expressions into methods. --- examples/02_Eigendistortions.ipynb | 2 +- examples/03_Steerable_Pyramid.ipynb | 4 +-- examples/08_MAD_Competition.ipynb | 3 ++- examples/Demo_Eigendistortion.ipynb | 3 ++- src/plenoptic/data/fetch.py | 5 +--- .../canonical_computations/filters.py | 5 +--- .../canonical_computations/non_linearities.py | 8 +++--- .../steerable_pyramid_freq.py | 16 ++++++------ src/plenoptic/synthesize/mad_competition.py | 25 ++++++------------- src/plenoptic/synthesize/metamer.py | 20 ++++++--------- src/plenoptic/synthesize/synthesis.py | 15 +++-------- src/plenoptic/tools/signal.py | 2 +- src/plenoptic/tools/validate.py | 5 +--- 13 files changed, 42 insertions(+), 71 deletions(-) diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 641af0d5..065f7d18 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -128,7 +128,7 @@ " eigenvectors of M.T @ M\"\"\"\n", "\n", " def __init__(self, n, m):\n", - " super(LinearModel, self).__init__()\n", + " super().__init__()\n", " torch.manual_seed(0)\n", " self.M = nn.Linear(n, m, bias=False)\n", "\n", diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index 63818db6..08d259af 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -119,7 +119,7 @@ "\n", "# ... and then reconstruct this dummy image to visualize the filter.\n", "reconList = []\n", - "for k in pyr_coeffs.keys():\n", + "for k in pyr_coeffs:\n", " # we ignore the residual_highpass and residual_lowpass, since we're focusing on the filters here\n", " if isinstance(k, tuple):\n", " reconList.append(pyr.recon_pyr(pyr_coeffs, [k[0]], [k[1]]))\n", @@ -2295,7 +2295,7 @@ "source": [ "pyr_coeffs_fixed_1 = pyr_fixed(im_batch)\n", "pyr_coeffs_fixed_2 = pyr_fixed.convert_tensor_to_pyr(pyr_coeffs_fixed, *pyr_info)\n", - "for k in pyr_coeffs_fixed_1.keys():\n", + "for k in pyr_coeffs_fixed_1:\n", " print(torch.allclose(pyr_coeffs_fixed_2[k], pyr_coeffs_fixed_1[k]))" ] }, diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index 836351cf..ea136555 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -97,7 +97,8 @@ "metadata": {}, "outputs": [], "source": [ - "model1 = lambda *args: 1 - po.metric.ssim(*args, weighted=True, pad=\"reflect\")\n", + "def model1(*args):\n", + " return 1 - po.metric.ssim(*args, weighted=True, pad=\"reflect\")\n", "model2 = po.metric.mse" ] }, diff --git a/examples/Demo_Eigendistortion.ipynb b/examples/Demo_Eigendistortion.ipynb index 3ee9fd8a..eeb2f8de 100644 --- a/examples/Demo_Eigendistortion.ipynb +++ b/examples/Demo_Eigendistortion.ipynb @@ -625,7 +625,8 @@ ")\n", "\n", "# create an image processing function to unnormalize the image and avg the channels to grayscale\n", - "unnormalize = lambda x: (x * image.std() + image.mean()).mean(1, keepdims=True)\n", + "def unnormalize(x):\n", + " return (x * image.std() + image.mean()).mean(1, keepdims=True)\n", "alpha_max, alpha_min = 15.0, 100.0\n", "\n", "v_max = po.synth.eigendistortion.display_eigendistortion(\n", diff --git a/src/plenoptic/data/fetch.py b/src/plenoptic/data/fetch.py index f1e2b49a..d6f244e8 100644 --- a/src/plenoptic/data/fetch.py +++ b/src/plenoptic/data/fetch.py @@ -137,10 +137,7 @@ def fetch_data(dataset_name: str) -> pathlib.Path: " Please use pip or " "conda to install 'pooch'." ) - if dataset_name.endswith(".tar.gz"): - processor = pooch.Untar() - else: - processor = None + processor = pooch.Untar() if dataset_name.endswith(".tar.gz") else None fname = retriever.fetch(dataset_name, progressbar=True, processor=processor) if dataset_name.endswith(".tar.gz"): fname = find_shared_directory([pathlib.Path(f) for f in fname]) diff --git a/src/plenoptic/simulate/canonical_computations/filters.py b/src/plenoptic/simulate/canonical_computations/filters.py index 464a15e9..c8bff447 100644 --- a/src/plenoptic/simulate/canonical_computations/filters.py +++ b/src/plenoptic/simulate/canonical_computations/filters.py @@ -59,10 +59,7 @@ def circular_gaussian2d( Circular gaussian kernel, normalized by total pixel-sum (_not_ by 2pi*std). `filt` has `Size([out_channels=n_channels, in_channels=1, height, width])`. """ - if isinstance(std, float): - device = torch.device("cpu") - else: - device = std.device + device = torch.device("cpu") if isinstance(std, float) else std.device if isinstance(kernel_size, int): kernel_size = (kernel_size, kernel_size) diff --git a/src/plenoptic/simulate/canonical_computations/non_linearities.py b/src/plenoptic/simulate/canonical_computations/non_linearities.py index 279216f9..aa626497 100644 --- a/src/plenoptic/simulate/canonical_computations/non_linearities.py +++ b/src/plenoptic/simulate/canonical_computations/non_linearities.py @@ -26,7 +26,7 @@ def rectangular_to_polar_dict(coeff_dict, residuals=False): """ energy = {} state = {} - for key in coeff_dict.keys(): + for key in coeff_dict: # ignore residuals if isinstance(key, tuple) or not key.startswith("residual"): energy[key], state[key] = rectangular_to_polar(coeff_dict[key]) @@ -60,7 +60,7 @@ def polar_to_rectangular_dict(energy, state, residuals=True): """ coeff_dict = {} - for key in energy.keys(): + for key in energy: # ignore residuals if isinstance(key, tuple) or not key.startswith("residual"): @@ -189,7 +189,7 @@ def local_gain_control_dict(coeff_dict, residuals=True): energy = {} state = {} - for key in coeff_dict.keys(): + for key in coeff_dict: if isinstance(key, tuple) or not key.startswith("residual"): energy[key], state[key] = local_gain_control(coeff_dict[key]) @@ -229,7 +229,7 @@ def local_gain_release_dict(energy, state, residuals=True): """ coeff_dict = {} - for key in energy.keys(): + for key in energy: if isinstance(key, tuple) or not key.startswith("residual"): coeff_dict[key] = local_gain_release(energy[key], state[key]) diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 698bf6b7..9566c82b 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -476,11 +476,11 @@ def convert_pyr_to_tensor( else: coeff_list_bands.append(coeffs) - if "residual_highpass" in pyr_coeffs.keys(): + if "residual_highpass" in pyr_coeffs: coeff_list_bands.insert(0, coeff_list_resid[0]) - if "residual_lowpass" in pyr_coeffs.keys(): + if "residual_lowpass" in pyr_coeffs: coeff_list_bands.append(coeff_list_resid[1]) - elif "residual_lowpass" in pyr_coeffs.keys(): + elif "residual_lowpass" in pyr_coeffs: coeff_list_bands.append(coeff_list_resid[0]) coeff_list.extend(coeff_list_bands) @@ -563,7 +563,7 @@ def convert_tensor_to_pyr( else: band = pyr_tensor[:, i, ...].unsqueeze(1) i += 1 - if k not in pyr_coeffs.keys(): + if k not in pyr_coeffs: pyr_coeffs[k] = band else: pyr_coeffs[k] = torch.cat([pyr_coeffs[k], band], dim=1) @@ -626,12 +626,12 @@ def _recon_levels_check( # not all pyramids have residual highpass / lowpass, but it's easier # to construct the list including them, then remove them if necessary. if ( - "residual_lowpass" not in self.pyr_size.keys() + "residual_lowpass" not in self.pyr_size and "residual_lowpass" in levels ): levels.pop(-1) if ( - "residual_highpass" not in self.pyr_size.keys() + "residual_highpass" not in self.pyr_size and "residual_highpass" in levels ): levels.pop(0) @@ -779,7 +779,7 @@ def recon_pyr( # to include all levels for s in self.scales: if isinstance(s, str): - if s not in pyr_coeffs.keys(): + if s not in pyr_coeffs: raise Exception( f"scale {s} not in pyr_coeffs! pyr_coeffs must include" " all scales, so make sure forward() was called with" @@ -787,7 +787,7 @@ def recon_pyr( ) else: for b in range(self.num_orientations): - if (s, b) not in pyr_coeffs.keys(): + if (s, b) not in pyr_coeffs: raise Exception( f"scale {s} not in pyr_coeffs! pyr_coeffs must" " include all scales, so make sure forward() was" diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index cdf29626..65b5c05b 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -15,6 +15,7 @@ from pyrtools.tools.display import make_figure as pt_make_figure from ..tools.validate import validate_input, validate_metric from ..tools.convergence import loss_convergence +import contextlib class MADCompetition(OptimizedSynthesis): @@ -479,14 +480,10 @@ def to(self, *args, **kwargs): super().to(*args, attrs=attrs, **kwargs) # if the metrics are Modules, then we should pass them as well. If # they're functions then nothing needs to be done. - try: + with contextlib.suppress(AttributeError): self.reference_metric.to(*args, **kwargs) - except AttributeError: - pass - try: + with contextlib.suppress(AttributeError): self.optimized_metric.to(*args, **kwargs) - except AttributeError: - pass def load( self, @@ -710,18 +707,12 @@ def display_mad_image( The matplotlib axes containing the plot. """ - if iteration is None: - image = mad.mad_image - else: - image = mad.saved_mad_image[iteration] + image = mad.mad_image if iteration is None else mad.saved_mad_image[iteration] if batch_idx is None: raise ValueError("batch_idx must be an integer!") # we're only plotting one image here, so if the user wants multiple # channels, they must be RGB - if channel_idx is None and image.shape[1] > 1: - as_rgb = True - else: - as_rgb = False + as_rgb = bool(channel_idx is None and image.shape[1] > 1) if ax is None: ax = plt.gca() display.imshow( @@ -927,17 +918,17 @@ def _setup_synthesis_fig( if "display_mad_image" in included_plots: n_subplots += 1 width_ratios.append(display_mad_image_width) - if "display_mad_image" not in axes_idx.keys(): + if "display_mad_image" not in axes_idx: axes_idx["display_mad_image"] = data._find_min_int(axes_idx.values()) if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if "plot_loss" not in axes_idx.keys(): + if "plot_loss" not in axes_idx: axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) if "plot_pixel_values" in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if "plot_pixel_values" not in axes_idx.keys(): + if "plot_pixel_values" not in axes_idx: axes_idx["plot_pixel_values"] = data._find_min_int(axes_idx.values()) if fig is None: width_ratios = np.array(width_ratios) diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index edee0479..ab6fd097 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -1078,18 +1078,12 @@ def display_metamer( The matplotlib axes containing the plot. """ - if iteration is None: - image = metamer.metamer - else: - image = metamer.saved_metamer[iteration] + image = metamer.metamer if iteration is None else metamer.saved_metamer[iteration] if batch_idx is None: raise ValueError("batch_idx must be an integer!") # we're only plotting one image here, so if the user wants multiple # channels, they must be RGB - if channel_idx is None and image.shape[1] > 1: - as_rgb = True - else: - as_rgb = False + as_rgb = bool(channel_idx is None and image.shape[1] > 1) if ax is None: ax = plt.gca() display.imshow( @@ -1394,24 +1388,24 @@ def _setup_synthesis_fig( if "display_metamer" in included_plots: n_subplots += 1 width_ratios.append(display_metamer_width) - if "display_metamer" not in axes_idx.keys(): + if "display_metamer" not in axes_idx: axes_idx["display_metamer"] = data._find_min_int(axes_idx.values()) if "plot_loss" in included_plots: n_subplots += 1 width_ratios.append(plot_loss_width) - if "plot_loss" not in axes_idx.keys(): + if "plot_loss" not in axes_idx: axes_idx["plot_loss"] = data._find_min_int(axes_idx.values()) if "plot_representation_error" in included_plots: n_subplots += 1 width_ratios.append(plot_representation_error_width) - if "plot_representation_error" not in axes_idx.keys(): + if "plot_representation_error" not in axes_idx: axes_idx["plot_representation_error"] = data._find_min_int( axes_idx.values() ) if "plot_pixel_values" in included_plots: n_subplots += 1 width_ratios.append(plot_pixel_values_width) - if "plot_pixel_values" not in axes_idx.keys(): + if "plot_pixel_values" not in axes_idx: axes_idx["plot_pixel_values"] = data._find_min_int(axes_idx.values()) if fig is None: width_ratios = np.array(width_ratios) @@ -1764,7 +1758,7 @@ def animate( ylim_rescale_interval = int(metamer.saved_metamer.shape[0] - 1) ylim = None else: - raise ValueError("Don't know how to handle ylim %s!" % ylim) + raise ValueError(f"Don't know how to handle ylim {ylim}!") except AttributeError: # this way we'll never rescale ylim_rescale_interval = len(metamer.saved_metamer) + 1 diff --git a/src/plenoptic/synthesize/synthesis.py b/src/plenoptic/synthesize/synthesis.py index 96c21869..d9c2988a 100644 --- a/src/plenoptic/synthesize/synthesis.py +++ b/src/plenoptic/synthesize/synthesis.py @@ -119,10 +119,7 @@ def load( # the initial underscore. This is because this function # needs to be able to set the attribute, which can only be # done with the hidden version. - if k.startswith("_"): - display_k = k[1:] - else: - display_k = k + display_k = k[1:] if k.startswith("_") else k if not hasattr(self, k): raise AttributeError( "All values of `check_attributes` should be " @@ -172,10 +169,7 @@ def load( ) for k in check_loss_functions: # same as above - if k.startswith("_"): - display_k = k[1:] - else: - display_k = k + display_k = k[1:] if k.startswith("_") else k # this way, we know it's the right shape tensor_a, tensor_b = torch.rand(2, *self._image_shape).to(device) saved_loss = tmp_dict[k](tensor_a, tensor_b) @@ -406,9 +400,8 @@ def store_progress(self, store_progress: bool | int): True or int>0, ``self.saved_metamer`` contains the stored images. """ - if store_progress: - if store_progress is True: - store_progress = 1 + if store_progress and store_progress is True: + store_progress = 1 if self.store_progress is not None and store_progress != self.store_progress: # we require store_progress to be the same because otherwise the # subsampling relationship between attrs that are stored every diff --git a/src/plenoptic/tools/signal.py b/src/plenoptic/tools/signal.py index 4c04c721..33657b92 100644 --- a/src/plenoptic/tools/signal.py +++ b/src/plenoptic/tools/signal.py @@ -226,7 +226,7 @@ def steer( num = basis.shape[-1] device = basis.device - if isinstance(angle, (int, float)): + if isinstance(angle, int | float): angle = np.array([angle]) else: if angle.shape[0] != basis.shape[0] or angle.shape[1] != 1: diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index 71fffe8d..b8c5d265 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -55,10 +55,7 @@ def validate_input( + f" allowed but got type {input_tensor.dtype}" ) if input_tensor.ndimension() != 4: - if no_batch: - n_batch = 1 - else: - n_batch = "n_batch" + n_batch = 1 if no_batch else "n_batch" # numpy raises ValueError when operands cannot be broadcast together, # so it seems reasonable here raise ValueError( From e10f8dd682ff13c170a33236318e27b61b887f89 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 13 Sep 2024 10:21:34 -0400 Subject: [PATCH 053/134] ignored SIM105 or do we want to use contextlib package instead of try-except-pass blocks? --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index ff8f02cc..6fc3508c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -139,6 +139,7 @@ select = [ # isort #"I", ] +ignore = ["SIM105"] [tool.ruff.lint.pydocstyle] convention = "numpy" From d375f3250b1046dbaa8db4a7b7195dcf015eb497 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 17 Sep 2024 17:17:44 -0400 Subject: [PATCH 054/134] ambigious variable name in external refactored --- src/plenoptic/tools/external.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/plenoptic/tools/external.py b/src/plenoptic/tools/external.py index 545da3d0..860a3987 100644 --- a/src/plenoptic/tools/external.py +++ b/src/plenoptic/tools/external.py @@ -96,18 +96,18 @@ def plot_MAD_results( "im_fixssim_minmse", "im_fixssim_maxmse", ] - for l in noise_levels: + for level in noise_levels: mat = sio.loadmat( op.join( op.expanduser(results_dir), - f"{original_image}_L{l}_results.mat", + f"{original_image}_L{level}_results.mat", ), squeeze_me=True, ) # remove these metadata keys [mat.pop(k) for k in ["__header__", "__version__", "__globals__"]] key_titles = [ - f"Noise level: {l}", + f"Noise level: {level}", f"Best SSIM: {mat['maxssim']:.05f}", f"Worst SSIM: {mat['minssim']:.05f}", f"Best MSE: {mat['minmse']:.05f}", @@ -125,8 +125,8 @@ def plot_MAD_results( titles.append(t) super_titles.append(s) # this then just contains the loss information - mat.update({"noise_level": l, "original_image": original_image}) - results[f"L{l}"] = mat + mat.update({"noise_level": level, "original_image": original_image}) + results[f"L{level}"] = mat images = images.transpose((2, 0, 1)) if vrange.startswith("row"): vrange_list = [] From 07fd3ef99fbe583b84d101edda30ab0afbc3ff0e Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 17 Sep 2024 17:49:21 -0400 Subject: [PATCH 055/134] tests test_metric and test_models fail --- src/plenoptic/tools/display.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/plenoptic/tools/display.py b/src/plenoptic/tools/display.py index 35f5b60c..70050ef3 100644 --- a/src/plenoptic/tools/display.py +++ b/src/plenoptic/tools/display.py @@ -437,7 +437,8 @@ def pyrshow( <1, must be 1/d where d is a a divisor of the size of the largest image. show_residuals : `bool` - whether to display the residual bands (lowpass, highpass depending on the pyramid type) + whether to display the residual bands (lowpass, highpass depending on the + pyramid type) cmap : matplotlib colormap, optional colormap to use when showing these images plot_complex : {'rectangular', 'polar', 'logpolar'} From bda1de7363cff927db8a99b3cfbc70a35cbfd9c1 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 19 Sep 2024 17:36:31 -0400 Subject: [PATCH 056/134] replacing if-else block with ternary conditional operator --- src/plenoptic/tools/data.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index b4ea6f65..0be01512 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -150,13 +150,11 @@ def load_images(paths: str | list[str], as_gray: bool = True) -> Tensor: images = images.unsqueeze(1) else: if images.ndimension() == 3: - # either this was a single color image or multiple grayscale ones - if len(paths) > 1: - # then single color image, so add the batch dimension - images = images.unsqueeze(0) - else: - # then multiple grayscales ones, so add channel dimension - images = images.unsqueeze(1) + # either this was a single color image: + # so add the batch dimension + # or multiple grayscale images: + # so add channel dimension + images = images.unsqueeze(0) if len(paths) > 1 else images.unsqueeze(1) if images.ndimension() != 4: raise ValueError( "Somehow ended up with other than 4 dimensions! Not sure how we" " got here" From 45a9890a04218cd88ca436671c1a24f660aa7c56 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 19 Sep 2024 17:38:38 -0400 Subject: [PATCH 057/134] removing too long lines --- src/plenoptic/tools/data.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index 0be01512..eea932bc 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -343,20 +343,22 @@ def polar_angle( ) -> Tensor: """Make polar angle matrix (in radians). - Compute a matrix of given size containing samples of the polar angle (in radians, CW from the - X-axis, ranging from -pi to pi), relative to given phase, about the given origin pixel. + Compute a matrix of given size containing samples of the polar angle (in radians, CW + from the X-axis, ranging from -pi to pi), relative to given phase, about the given + origin pixel. Parameters ---------- size - If an int, we assume the image should be of dimensions `(size, size)`. if a tuple, must be - a 2-tuple of ints specifying the dimensions + If an int, we assume the image should be of dimensions `(size, size)`. if a + tuple, must be a 2-tuple of ints specifying the dimensions phase The phase of the polar angle function (in radians, clockwise from the X-axis) origin - The center of the image. if an int, we assume the origin is at `(origin, origin)`. if a - tuple, must be a 2-tuple of ints specifying the origin (where `(0, 0)` is the upper left). - if None, we assume the origin lies at the center of the matrix, `(size+1)/2`. + The center of the image. if an int, we assume the origin is at + `(origin, origin)`. if a tuple, must be a 2-tuple of ints specifying the origin + (where `(0, 0)` is the upper left). If None, we assume the origin lies at the + center of the matrix, `(size+1)/2`. device The device to create this tensor on. From d7fbd6e62997cf1d001633baa3c73d5adf1da9c1 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 19 Sep 2024 17:43:15 -0400 Subject: [PATCH 058/134] replacing if-else block by returning boolean expression directly --- src/plenoptic/tools/convergence.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/plenoptic/tools/convergence.py b/src/plenoptic/tools/convergence.py index 4d418d67..f74ba76a 100644 --- a/src/plenoptic/tools/convergence.py +++ b/src/plenoptic/tools/convergence.py @@ -133,7 +133,7 @@ def pixel_change_convergence( Whether the pixel change norm has stabilized or not. """ - if len(synth.pixel_change_norm) > stop_iters_to_check: - if (synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion).all(): - return True - return False + return ( + len(synth.pixel_change_norm) > stop_iters_to_check + and (synth.pixel_change_norm[-stop_iters_to_check:] < stop_criterion).all() + ) From e62330292fb777f64ea5f6985699ed537fb5e853 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 19 Sep 2024 17:48:27 -0400 Subject: [PATCH 059/134] returning boolean expression as opposed to if-if-else block --- src/plenoptic/tools/convergence.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/plenoptic/tools/convergence.py b/src/plenoptic/tools/convergence.py index f74ba76a..c72d36de 100644 --- a/src/plenoptic/tools/convergence.py +++ b/src/plenoptic/tools/convergence.py @@ -27,6 +27,8 @@ from ..synthesize.metamer import Metamer +# ignoring E501 to keep the diagram below readable +# ruff: noqa: E501 def loss_convergence( synth: "OptimizedSynthesis", stop_criterion: float, @@ -62,10 +64,10 @@ def loss_convergence( Whether the loss has stabilized or not. """ - if len(synth.losses) > stop_iters_to_check: - if abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) < stop_criterion: - return True - return False + return ( + len(synth.losses) > stop_iters_to_check + and abs(synth.losses[-stop_iters_to_check] - synth.losses[-1]) < stop_criterion + ) def coarse_to_fine_enough(synth: "Metamer", i: int, ctf_iters_to_check: int) -> bool: From 4d29fd9173361c063977930623dbc67643ae1aa0 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Thu, 19 Sep 2024 17:58:30 -0400 Subject: [PATCH 060/134] replacing nested if-else blocks with elif for readability --- src/plenoptic/synthesize/metamer.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index ab6fd097..6abb1806 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -1012,13 +1012,13 @@ def plot_loss( """ if iteration is None: loss_idx = len(metamer.losses) - 1 + elif iteration < 0: + # in order to get the x-value of the dot to line up, + # need to use this work-around + loss_idx = len(metamer.losses) + iteration else: - if iteration < 0: - # in order to get the x-value of the dot to line up, - # need to use this work-around - loss_idx = len(metamer.losses) + iteration - else: - loss_idx = iteration + loss_idx = iteration + if ax is None: ax = plt.gca() ax.semilogy(metamer.losses, **kwargs) @@ -1237,7 +1237,8 @@ def plot_pixel_values( """ def _freedman_diaconis_bins(a): - """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" + """Calculate number of hist bins using Freedman-Diaconis rule. copied from + seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] From 4abbc0283efad607310150f56b889c41b4e7397b Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 09:58:48 -0400 Subject: [PATCH 061/134] too long lines fixed --- src/plenoptic/synthesize/autodiff.py | 47 +++++++++++++++++----------- 1 file changed, 28 insertions(+), 19 deletions(-) diff --git a/src/plenoptic/synthesize/autodiff.py b/src/plenoptic/synthesize/autodiff.py index 4e52f41f..251137eb 100755 --- a/src/plenoptic/synthesize/autodiff.py +++ b/src/plenoptic/synthesize/autodiff.py @@ -59,11 +59,13 @@ def vector_jacobian_product( Backward Mode Auto-Differentiation (`Lop` in Theano) - Note on efficiency: When this function is used in the context of power iteration for computing eigenvectors, the - vector output will be repeatedly fed back into :meth:`vector_jacobian_product()` and :meth:`jacobian_vector_product()`. - To prevent the accumulation of gradient history in this vector (especially on GPU), we need to ensure the - computation graph is not kept in memory after each iteration. We can do this by detaching the output, as well as - carefully specifying where/when to retain the created graph. + Note on efficiency: When this function is used in the context of power iteration for + computing eigenvectors, the vector output will be repeatedly fed back into :meth: + `vector_jacobian_product()` and :meth:`jacobian_vector_product()`. + To prevent the accumulation of gradient history in this vector (especially on GPU), + we need to ensure the computation graph is not kept in memory after each iteration. + We can do this by detaching the output, as well as carefully specifying where/when + to retain the created graph. Parameters ---------- @@ -74,13 +76,15 @@ def vector_jacobian_product( U Direction, shape is ``torch.Size([m, k])``, i.e. same dim as output tensor. retain_graph - Whether or not to keep graph after doing one :meth:`vector_jacobian_product`. Must be set to True if k>1. + Whether or not to keep graph after doing one :meth:`vector_jacobian_product`. + Must be set to True if k>1. create_graph - Whether or not to create computational graph. Usually should be set to True unless you're reusing the graph like - in the second step of :meth:`jacobian_vector_product`. + Whether or not to create computational graph. Usually should be set to True + unless you're reusing the graph like in the second step + of :meth:`jacobian_vector_product`. detach - As with ``create_graph``, only necessary to be True when reusing the output like we do in the 2nd step of - :meth:`jacobian_vector_product`. + As with ``create_graph``, only necessary to be True when reusing the output + like we do in the 2nd step of :meth:`jacobian_vector_product`. Returns ------- @@ -118,23 +122,27 @@ def jacobian_vector_product( ) -> Tensor: r"""Compute Jacobian Vector Product: :math:`\text{jvp} = (\partial y/\partial x) v` - Forward Mode Auto-Differentiation (``Rop`` in Theano). PyTorch does not natively support this operation; this - function essentially calls backward mode autodiff twice, as described in [1]. + Forward Mode Auto-Differentiation (``Rop`` in Theano). PyTorch does not natively + support this operation; this function essentially calls backward mode autodiff + twice, as described in [1]. - See :meth:`vector_jacobian_product()` docstring on why we and pass arguments for ``retain_graph`` and - ``create_graph``. + See :meth:`vector_jacobian_product()` docstring on why we and pass arguments for + ``retain_graph`` and ``create_graph``. Parameters ---------- y Model output with gradient attached, shape is torch.Size([m, 1]) x - Model input with gradient attached, shape is torch.Size([n, 1]), i.e. same dim as input tensor + Model input with gradient attached, shape is torch.Size([n, 1]), i.e. same dim + as input tensor V - Directions in which to compute product, shape is torch.Size([n, k]) where k is number of vectors to compute + Directions in which to compute product, shape is torch.Size([n, k]) where k is + number of vectors to compute dummy_vec - Vector with which to do jvp trick [1]. If argument exists, then use some pre-allocated, cached vector, - otherwise create a new one and move to device in this method. + Vector with which to do jvp trick [1]. If argument exists, then use some + pre-allocated, cached vector, otherwise create a new one and move to device in + this method. Returns ------- @@ -151,7 +159,8 @@ def jacobian_vector_product( if dummy_vec is None: dummy_vec = torch.ones_like(y, requires_grad=True) - # do vjp twice to get jvp; set detach = False first; dummy_vec must be non-zero and is only there as a helper + # do vjp twice to get jvp; set detach = False first; dummy_vec must be non-zero and + # is only there as a helper g = vector_jacobian_product( y, x, dummy_vec, retain_graph=True, create_graph=True, detach=False ) From 309e040aaf06cf0cfe36b8b110af341520336b51 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 11:41:18 -0400 Subject: [PATCH 062/134] in optimizer_step in metamer.py condensed if statements and added check for index out of bound --- src/plenoptic/synthesize/metamer.py | 60 ++++++++++++++++------------- 1 file changed, 34 insertions(+), 26 deletions(-) diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index 6abb1806..4bff3241 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -758,32 +758,40 @@ def _optimizer_step( """ last_iter_metamer = self.metamer.clone() - # The first check here is because the last scale will be 'all', and - # we never remove it. Otherwise, check to see if it looks like loss - # has stopped declining and, if so, switch to the next scale. Then - # we're checking if self.scales_loss is long enough to check - # ctf_iters_to_check back. - if len(self.scales) > 1 and len(self.scales_loss) >= ctf_iters_to_check: - # Now we check whether loss has decreased less than - # change_scale_criterion - if (change_scale_criterion is None) or abs( - self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check] - ) < change_scale_criterion: - # and finally we check whether we've been optimizing this - # scale for ctf_iters_to_check - if ( - len(self.losses) - self.scales_timing[self.scales[0]][0] - >= ctf_iters_to_check - ): - self._scales_timing[self.scales[0]].append(len(self.losses) - 1) - self._scales_finished.append(self._scales.pop(0)) - self._scales_timing[self.scales[0]].append(len(self.losses)) - # reset optimizer's lr. - for pg in self.optimizer.param_groups: - pg["lr"] = pg["initial_lr"] - # reset ctf target representation, so we update it on - # next pass - self._ctf_target_representation = None + + # Check if conditions hold for switching scales: + # - Check if loss has decreased below the change_scale_criterion and + # - if we've been optimizing this scale for the required number of iterations + # - The first check here is because the last scale will be 'all', and + # we never remove it + + if ( + len(self.scales) > 1 + and len(self.scales_loss) >= ctf_iters_to_check + and ( + change_scale_criterion is None + or abs(self.scales_loss[-1] - self.scales_loss[-ctf_iters_to_check]) + < change_scale_criterion + ) + and ( + len(self.losses) - self.scales_timing[self.scales[0]][0] + >= ctf_iters_to_check + ) + ): + self._scales_timing[self.scales[0]].append(len(self.losses) - 1) + self._scales_finished.append(self._scales.pop(0)) + + # Only append if scales list is still non-empty after the pop + if self.scales: + self._scales_timing[self.scales[0]].append(len(self.losses)) + + # Reset optimizer's learning rate + for pg in self.optimizer.param_groups: + pg["lr"] = pg["initial_lr"] + + # Reset ctf target representation for the next update + self._ctf_target_representation = None + loss, overall_loss = self.optimizer.step(self._closure) self._scales_loss.append(loss.item()) self._losses.append(overall_loss.item()) From 302e97ebbd7b9afbcef77d7db0fd14ece23776c5 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 11:50:37 -0400 Subject: [PATCH 063/134] simplified decision tree conditions in check_convergence --- src/plenoptic/synthesize/metamer.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index 4bff3241..cacb8b6c 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -297,7 +297,7 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): Have we been synthesizing for ``stop_iters_to_check`` iterations? | | no yes - | '---->Is ``abs(synth.loss[-1] - synth.losses[-stop_iters_to_check]) < stop_criterion``? + | '----> Is the change in loss < stop_criterion over ``stop_iters_to_check``? | no | | | yes <-------' | @@ -510,7 +510,8 @@ def image(self): @property def target_representation(self): - """Model representation of ``image``, the goal of synthesis is for ``model(metamer)`` to match this value.""" + """Model representation of ``image``, the goal of synthesis is for + ``model(metamer)`` to match this value.""" return self._target_representation @property @@ -883,15 +884,16 @@ def _check_convergence( stop_iters_to_check: int, ctf_iters_to_check: int, ) -> bool: - r"""Check whether the loss has stabilized and whether we've synthesized all scales. + r"""Check whether the loss has stabilized and whether we've synthesized all + scales. Have we been synthesizing for ``stop_iters_to_check`` iterations? | | no yes - | '---->Is ``abs(self.loss[-1] - self.losses[-stop_iters_to_check] < stop_criterion``? + | '---->Is the change in loss < stop_criterion over ``stop_iters_to_check``? | no | | | yes - |-------' '---->Have we synthesized all scales and done so for ``ctf_iters_to_check`` iterations? + |-------' '---->Are all scales synthesized for `ctf_iters_to_check` iterations? | no | | | yes |---------------' '----> return ``True`` From 3fba75b111432baaa565505ea5a99a33dbd3cd43 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 11:55:00 -0400 Subject: [PATCH 064/134] metamers.py refactoring finnished and all tests in test_metamers.py pass --- src/plenoptic/synthesize/metamer.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index cacb8b6c..39924e7a 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -1804,8 +1804,8 @@ def animate( fig.axes[i] for i in axes_idx["plot_representation_error"] ] except TypeError: - # in this case, axes_idx['plot_representation_error'] is not iterable and so is - # a single value + # in this case, axes_idx['plot_representation_error'] is not iterable and + # so is a single value rep_error_axes = [fig.axes[axes_idx["plot_representation_error"]]] else: rep_error_axes = [] @@ -1848,9 +1848,12 @@ def movie_plot(i): ) # again, we know that rep_error_axes contains all the axes # with the representation ratio info - if ((i + 1) % ylim_rescale_interval) == 0: - if metamer.target_representation.ndimension() == 3: - display.rescale_ylim(rep_error_axes, rep_error) + if ( + (i + 1) % ylim_rescale_interval == 0 + and metamer.target_representation.ndimension() == 3 + ): + display.rescale_ylim(rep_error_axes, rep_error) + if "plot_pixel_values" in included_plots: # this is the dumbest way to do this, but it's simple -- # clearing the axes can cause problems if the user has, for From 73db7cfc8126845da50f13d25ab5d121306d6d5a Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 12:08:43 -0400 Subject: [PATCH 065/134] checking if module is available without importing it unnecessarily --- src/plenoptic/tools/display.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/plenoptic/tools/display.py b/src/plenoptic/tools/display.py index 70050ef3..71c7587f 100644 --- a/src/plenoptic/tools/display.py +++ b/src/plenoptic/tools/display.py @@ -6,11 +6,15 @@ import pyrtools as pt import matplotlib.pyplot as plt from .data import to_numpy +import importlib.util -try: - from IPython.display import HTML -except ImportError: - warnings.warn("Unable to import IPython.display.HTML") + +# Check if IPython.display.HTML is available +if importlib.util.find_spec("IPython.display"): + # ignore F401 + from IPython.display import HTML # noqa: F401 +else: + warnings.warn("Unable to find IPython.display.HTML") def imshow( From 0c720a6b56dd25baa092ca56adda1cb72fee6920 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 12:29:25 -0400 Subject: [PATCH 066/134] ignoring import not being at top of file for fetch.py --- src/plenoptic/data/fetch.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/plenoptic/data/fetch.py b/src/plenoptic/data/fetch.py index d6f244e8..a2867b46 100644 --- a/src/plenoptic/data/fetch.py +++ b/src/plenoptic/data/fetch.py @@ -91,7 +91,8 @@ } DOWNLOADABLE_FILES = list(REGISTRY_URLS.keys()) -import pathlib +# ignore E402 +import pathlib # noqa: E402 try: import pooch From d8e1f6aea3448adcf761cb4385826f4ec78c2d15 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:34:14 -0400 Subject: [PATCH 067/134] updating union syntax to python 3.10 bar version, unrelated 420 sha-errors and 2 failed tests asserting x < some threshold --- src/plenoptic/simulate/models/portilla_simoncelli.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index 39a61253..994ce737 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -8,7 +8,6 @@ """ from collections import OrderedDict -from typing import Union import einops import matplotlib as mpl @@ -31,7 +30,7 @@ SCALES_TYPE as PYR_SCALES_TYPE, ) -SCALES_TYPE = Union[Literal["pixel_statistics"], PYR_SCALES_TYPE] +SCALES_TYPE = Literal["pixel_statistics"] | PYR_SCALES_TYPE class PortillaSimoncelli(nn.Module): @@ -1122,7 +1121,8 @@ def plot_representation( return fig, axes def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict: - r"""Convert the data into a dictionary representation that is more convenient for plotting. + r"""Convert the data into a dictionary representation that is more convenient + for plotting. Intended as a helper function for plot_representation. From 7d77488f3bbaa00963569bd761ebc9aaf92dc91e Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:38:39 -0400 Subject: [PATCH 068/134] ignoring unused imports linting error F401 in tools init file --- src/plenoptic/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index a62bb3da..c022e660 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,3 +1,5 @@ +# ignore F401 +# ruff: noqa: F401 from . import simulate as simul from . import synthesize as synth from . import metric From 8555474c5f37276f07fec050c32afb3650b32e57 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:40:22 -0400 Subject: [PATCH 069/134] ignoring unused imports linting error F401 in metric init file --- src/plenoptic/metric/__init__.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/plenoptic/metric/__init__.py b/src/plenoptic/metric/__init__.py index 6f4e6f5e..0ae9b9a2 100644 --- a/src/plenoptic/metric/__init__.py +++ b/src/plenoptic/metric/__init__.py @@ -1,3 +1,6 @@ +# ignore F401 +# ruff: noqa: F401 + from .perceptual_distance import ssim, ms_ssim, nlpd, ssim_map from .model_metric import model_metric from .naive import mse From bd9b0ec3b30106e4be1ead8ffa145803ea991f06 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:46:57 -0400 Subject: [PATCH 070/134] ignoring wildcard imports linting error F403 in canonical computations init file --- src/plenoptic/simulate/canonical_computations/__init__.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/plenoptic/simulate/canonical_computations/__init__.py b/src/plenoptic/simulate/canonical_computations/__init__.py index b51ca84b..9d866e12 100644 --- a/src/plenoptic/simulate/canonical_computations/__init__.py +++ b/src/plenoptic/simulate/canonical_computations/__init__.py @@ -1,3 +1,6 @@ +# ignore F401 +# ruff: noqa: F401, F403 + from .laplacian_pyramid import LaplacianPyramid from .steerable_pyramid_freq import SteerablePyramidFreq from .non_linearities import * From d1ab31924707be9918d348086c2898db51b040a5 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:50:25 -0400 Subject: [PATCH 071/134] ignoring wildcard imports linting error F403 and unused imports F401 in tools init file --- src/plenoptic/tools/__init__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index 2c815b31..f2b10336 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,5 +1,5 @@ -from .data import * -from .conv import * +# ignore F401 (unused import) and F403 (from module import *) +# ruff: noqa: F401, F403 from .signal import * from .stats import * from .display import * From d028c67efd54e685b28d051d40ea26e94d856ab7 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:53:27 -0400 Subject: [PATCH 072/134] added predicate ignore-init-module-imports to tool.ruff.lint in pyproject.toml and set it to true --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 6fc3508c..f74f504f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -140,6 +140,7 @@ select = [ #"I", ] ignore = ["SIM105"] +ignore-init-module-imports = true [tool.ruff.lint.pydocstyle] convention = "numpy" From eabaf307087579e629785f0e672dc32c82c35265 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:57:20 -0400 Subject: [PATCH 073/134] removed predicate ignore-init-module-imports since deprecated --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index f74f504f..6fc3508c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -140,7 +140,6 @@ select = [ #"I", ] ignore = ["SIM105"] -ignore-init-module-imports = true [tool.ruff.lint.pydocstyle] convention = "numpy" From 1952d404e96b9333e31d4cd04e004c57bdfb1a5f Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 13:59:59 -0400 Subject: [PATCH 074/134] ignoring unused imports F401 and wildcard imports F403 --- src/plenoptic/__init__.py | 2 +- src/plenoptic/simulate/canonical_computations/__init__.py | 2 +- src/plenoptic/simulate/models/__init__.py | 2 ++ 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index c022e660..dabb811e 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,4 +1,4 @@ -# ignore F401 +# ignore F401 (unused import) # ruff: noqa: F401 from . import simulate as simul from . import synthesize as synth diff --git a/src/plenoptic/simulate/canonical_computations/__init__.py b/src/plenoptic/simulate/canonical_computations/__init__.py index 9d866e12..333f26b6 100644 --- a/src/plenoptic/simulate/canonical_computations/__init__.py +++ b/src/plenoptic/simulate/canonical_computations/__init__.py @@ -1,4 +1,4 @@ -# ignore F401 +# ignore F401 (unused import) and F403 (from module import *) # ruff: noqa: F401, F403 from .laplacian_pyramid import LaplacianPyramid diff --git a/src/plenoptic/simulate/models/__init__.py b/src/plenoptic/simulate/models/__init__.py index fbdea9c5..64837f31 100644 --- a/src/plenoptic/simulate/models/__init__.py +++ b/src/plenoptic/simulate/models/__init__.py @@ -1,3 +1,5 @@ +# ignore F401 (unused import) and F403 (from module import *) +# ruff: noqa: F401, F403 from .frontend import * from .naive import * from .portilla_simoncelli import PortillaSimoncelli From 5f54512b3d7b0e98a7306772a9db247fd758149b Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:01:12 -0400 Subject: [PATCH 075/134] ignoring unused imports F401 in synthesize init file --- src/plenoptic/synthesize/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/plenoptic/synthesize/__init__.py b/src/plenoptic/synthesize/__init__.py index f9d7e0f3..e3fb7899 100644 --- a/src/plenoptic/synthesize/__init__.py +++ b/src/plenoptic/synthesize/__init__.py @@ -1,3 +1,5 @@ +# ignore F401 (unused import) +# ruff: noqa: F401 from .eigendistortion import Eigendistortion from .metamer import Metamer, MetamerCTF from .geodesic import Geodesic From daa38ee0600ae8534b33b098de2d90ffc14ebeeb Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:03:40 -0400 Subject: [PATCH 076/134] ignoring wildcard imports F401 in simlute init file --- src/plenoptic/simulate/__init__.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/plenoptic/simulate/__init__.py b/src/plenoptic/simulate/__init__.py index 9659b0ce..7086770a 100644 --- a/src/plenoptic/simulate/__init__.py +++ b/src/plenoptic/simulate/__init__.py @@ -1,2 +1,5 @@ +# ignore F403 (from module import *) +# ruff: noqa: F403 + from .models import * from .canonical_computations import * From 1203e891cca656fade74856d8fc58042bad34067 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:06:42 -0400 Subject: [PATCH 077/134] resolving linting error E402 imports not at top of cell --- examples/Display.ipynb | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/Display.ipynb b/examples/Display.ipynb index c0c6a7a1..5ec2812e 100644 --- a/examples/Display.ipynb +++ b/examples/Display.ipynb @@ -20,6 +20,9 @@ "source": [ "import plenoptic as po\n", "import matplotlib.pyplot as plt\n", + "import torch\n", + "import numpy as np\n", + "\n", "\n", "# so that relativfe sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", @@ -29,8 +32,6 @@ "plt.rcParams[\"animation.writer\"] = \"ffmpeg\"\n", "plt.rcParams[\"animation.ffmpeg_args\"] = [\"-threads\", \"1\"]\n", "\n", - "import torch\n", - "import numpy as np\n", "\n", "%load_ext autoreload\n", "%autoreload 2\n", From 4e0fa0d5c4c6fdc3bdcc76e10d32f2d4e96f3132 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:10:43 -0400 Subject: [PATCH 078/134] replacing union with pipe operator which resolves UP007 in steerable_pyramid_freq.py --- .../steerable_pyramid_freq.py | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 9566c82b..e2d8faba 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -21,8 +21,9 @@ from ...tools.signal import interpolate1d, raised_cosine, steer complex_types = [torch.cdouble, torch.cfloat] -SCALES_TYPE = Union[int, Literal["residual_lowpass", "residual_highpass"]] -KEYS_TYPE = Union[tuple[int, int], Literal["residual_lowpass", "residual_highpass"]] + +SCALES_TYPE = int | Literal["residual_lowpass", "residual_highpass"] +KEYS_TYPE = tuple[int, int] | Literal["residual_lowpass", "residual_highpass"] class SteerablePyramidFreq(nn.Module): @@ -625,15 +626,9 @@ def _recon_levels_check( levels = levs_tmp # not all pyramids have residual highpass / lowpass, but it's easier # to construct the list including them, then remove them if necessary. - if ( - "residual_lowpass" not in self.pyr_size - and "residual_lowpass" in levels - ): + if "residual_lowpass" not in self.pyr_size and "residual_lowpass" in levels: levels.pop(-1) - if ( - "residual_highpass" not in self.pyr_size - and "residual_highpass" in levels - ): + if "residual_highpass" not in self.pyr_size and "residual_highpass" in levels: levels.pop(0) return levels From f08c14278da377f3cd5f45e7d9c89532fa79e742 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:12:32 -0400 Subject: [PATCH 079/134] cutting line lenght --- .../canonical_computations/steerable_pyramid_freq.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index e2d8faba..3389f38d 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -6,8 +6,6 @@ import warnings from collections import OrderedDict -from typing import Union - import numpy as np import torch import torch.fft as fft @@ -491,8 +489,8 @@ def convert_pyr_to_tensor( pyr_info = tuple([num_channels, split_complex, pyr_keys]) except RuntimeError: raise Exception( - """feature maps could not be concatenated into tensor. - Check that you are using coefficients that are not downsampled across scales. + """feature maps could not be concatenated into tensor. Check that you + are using coefficients that are not downsampled across scales. This is done with the 'downsample=False' argument for the pyramid""" ) @@ -574,7 +572,8 @@ def convert_tensor_to_pyr( def _recon_levels_check( self, levels: Literal["all"] | list[SCALES_TYPE] ) -> list[SCALES_TYPE]: - r"""Check whether levels arg is valid for reconstruction and return valid version + r""" + Check whether levels arg is valid for reconstruction and return valid version When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies which levels to include. This makes sure those From a5fb657e6baa313520691f1b16d36de088118313 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:26:48 -0400 Subject: [PATCH 080/134] making if-blocks more readable and cutting long lines in mad_comptetition.py --- src/plenoptic/synthesize/mad_competition.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 65b5c05b..0fa62f05 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -308,7 +308,8 @@ def objective_function( ) def _optimizer_step(self, pbar: tqdm) -> Tensor: - r"""Compute and propagate gradients, then step the optimizer to update mad_image. + r"""Compute and propagate gradients, then step the optimizer to update + mad_image. Parameters ---------- @@ -363,7 +364,7 @@ def _check_convergence(self, stop_criterion, stop_iters_to_check): Have we been synthesizing for ``stop_iters_to_check`` iterations? | | no yes - | '---->Is ``abs(synth.loss[-1] - synth.losses[-stop_iters_to_check]) < stop_criterion``? + | '---->Is abs(synth.loss[-1] - synth.loss[-stop_iters_to_check]) < stop_crit? | no | | | yes <-------' | @@ -632,13 +633,11 @@ def plot_loss( """ if iteration is None: loss_idx = len(mad.losses) - 1 + elif iteration < 0: + loss_idx = len(mad.losses) + iteration # Work-around for x-value alignment else: - if iteration < 0: - # in order to get the x-value of the dot to line up, - # need to use this work-around - loss_idx = len(mad.losses) + iteration - else: - loss_idx = iteration + loss_idx = iteration + if axes is None: axes = plt.gca() if not hasattr(axes, "__iter__"): @@ -772,7 +771,8 @@ def plot_pixel_values( """ def _freedman_diaconis_bins(a): - """Calculate number of hist bins using Freedman-Diaconis rule. copied from seaborn.""" + """Calculate number of hist bins using Freedman-Diaconis rule. copied from + seaborn.""" # From https://stats.stackexchange.com/questions/798/ a = np.asarray(a) iqr = np.diff(np.percentile(a, [0.25, 0.75]))[0] @@ -1451,7 +1451,8 @@ def plot_loss_all( **metric1_kwargs, **max_kwargs, ) - # we pass the axes backwards here because the fixed and synthesis metrics are the opposite as they are in the instances above. + # we pass the axes backwards here because the fixed and synthesis metrics are + # the opposite as they are in the instances above. plot_loss( mad_metric2_min, axes=axes[::-1], From 4150226a40adcfd9b7d009ce4097b8dfe1b09ae0 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:29:20 -0400 Subject: [PATCH 081/134] placing imports to top of cell and shortening too long lines --- examples/07_Simple_MAD.ipynb | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/examples/07_Simple_MAD.ipynb b/examples/07_Simple_MAD.ipynb index c9151477..41187b46 100644 --- a/examples/07_Simple_MAD.ipynb +++ b/examples/07_Simple_MAD.ipynb @@ -29,11 +29,11 @@ "import torch\n", "import pyrtools as pt\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import itertools\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", - "import numpy as np\n", - "import itertools\n", "\n", "%load_ext autoreload\n", "%autoreload 2" @@ -124,7 +124,8 @@ "# this gets us all four possibilities\n", "for t, (m1, m2) in itertools.product([\"min\", \"max\"], zip(metrics, metrics[::-1])):\n", " name = f\"{m1.__name__}_{t}\"\n", - " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values!\n", + " # we set the seed like this to ensure that all four MADCompetition instances have\n", + " # the same initial_signal. Try different seed values!\n", " po.tools.set_seed(10)\n", " all_mad[name] = po.synth.MADCompetition(img, m1, m2, t, metric_tradeoff_lambda=1e4)\n", " optim = torch.optim.Adam([all_mad[name].mad_image], lr=0.0001)\n", @@ -376,7 +377,8 @@ " )\n", "\n", "\n", - "# by setting the image to lie between 0 and 255 and be slightly within the max possible range, we make the optimizatio a bit easier.\n", + "# by setting the image to lie between 0 and 255 and be slightly within the max possible\n", + "# range, we make the optimizatio a bit easier.\n", "img = 255 * create_checkerboard((64, 64), 16, [0.1, 0.9])\n", "po.imshow(img, vrange=(0, 255), zoom=4)\n", "# you could also do this with another natural image, give it a try!" @@ -469,7 +471,8 @@ "# this gets us all four possibilities\n", "for t, (m1, m2) in itertools.product([\"min\", \"max\"], zip(metrics, metrics[::-1])):\n", " name = f\"{m1.__name__}_{t}\"\n", - " # we set the seed like this to ensure that all four MADCompetition instances have the same initial_signal. Try different seed values!\n", + " # we set the seed like this to ensure that all four MADCompetition instances have\n", + " # the same initial_signal. Try different seed values!\n", " po.tools.set_seed(0)\n", " all_mad[name] = po.synth.MADCompetition(\n", " img,\n", From b2c5a18566a6070cad7384174c343f94ff5d8f45 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:32:30 -0400 Subject: [PATCH 082/134] fixing too long lines and placing imports at top of cell in notebookds 08 and 06. --- examples/06_Metamer.ipynb | 12 +++++++----- examples/08_MAD_Competition.ipynb | 5 ++++- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/examples/06_Metamer.ipynb b/examples/06_Metamer.ipynb index 972df828..e972d2d9 100644 --- a/examples/06_Metamer.ipynb +++ b/examples/06_Metamer.ipynb @@ -25,6 +25,7 @@ "import imageio\n", "import torch\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", @@ -33,7 +34,7 @@ "# use single-threaded ffmpeg for animation writer\n", "plt.rcParams[\"animation.writer\"] = \"ffmpeg\"\n", "plt.rcParams[\"animation.ffmpeg_args\"] = [\"-threads\", \"1\"]\n", - "import numpy as np\n", + "\n", "\n", "%load_ext autoreload\n", "%autoreload 2" @@ -234,7 +235,7 @@ "# model response error plot has two subplots, so we increase its relative width\n", "po.synth.metamer.plot_synthesis_status(\n", " met, width_ratios={\"plot_representation_error\": 2}\n", - ");" + ")" ] }, { @@ -264,7 +265,7 @@ "fig, axes = plt.subplots(1, 3, figsize=(25, 5), gridspec_kw={\"width_ratios\": [1, 1, 2]})\n", "po.synth.metamer.display_metamer(met, ax=axes[0])\n", "po.synth.metamer.plot_loss(met, ax=axes[1])\n", - "po.synth.metamer.plot_representation_error(met, ax=axes[2]);" + "po.synth.metamer.plot_representation_error(met, ax=axes[2])" ] }, { @@ -336,7 +337,7 @@ "source": [ "po.synth.metamer.plot_synthesis_status(\n", " met, iteration=-10, width_ratios={\"plot_representation_error\": 2}\n", - ");" + ")" ] }, { @@ -10513,7 +10514,8 @@ " img, ps, loss_function=po.tools.optim.l2_norm, coarse_to_fine=\"together\"\n", ")\n", "met.synthesize(store_progress=True, max_iter=100)\n", - "# we don't show our synthesized image here, because it hasn't gone through all the scales, and so hasn't finished synthesizing" + "# we don't show our synthesized image here, because it hasn't gone through all the\n", + "# scales, and so hasn't finished synthesizing" ] }, { diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index ea136555..2fb5aa2b 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -37,10 +37,11 @@ "source": [ "import plenoptic as po\n", "import matplotlib.pyplot as plt\n", + "import warnings\n", + "\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", - "import warnings\n", "\n", "%load_ext autoreload\n", "%autoreload 2" @@ -99,6 +100,8 @@ "source": [ "def model1(*args):\n", " return 1 - po.metric.ssim(*args, weighted=True, pad=\"reflect\")\n", + "\n", + "\n", "model2 = po.metric.mse" ] }, From 718440d7b7d64a6fd4e4d7beb744374f87cdbf2f Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:36:05 -0400 Subject: [PATCH 083/134] reordering imports and fixing too long lines in notebook geodesics --- examples/05_Geodesics.ipynb | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index 2e479445..6057b619 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -38,18 +38,11 @@ "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "\n", - "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams[\"figure.dpi\"] = 72\n", - "%matplotlib inline\n", - "\n", "import pyrtools as pt\n", "import plenoptic as po\n", "from plenoptic.tools import to_numpy\n", - "\n", - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", "import torch\n", "import torch.nn as nn\n", "\n", @@ -64,8 +57,14 @@ " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\"\n", " )\n", - "import torchvision.transforms as transforms\n", - "from torchvision import models\n", + "\n", + "# so that relative sizes of axes created by po.imshow and others look right\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", + "%matplotlib inline\n", + "\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "dtype = torch.float32\n", @@ -172,7 +171,8 @@ "\n", "\n", "model = Fourier(\"amp\")\n", - "# model = Fourier('polar') # note: need pytorch>=1.8 to take gradients through torch.angle" + "# model = Fourier('polar') # note: need pytorch>=1.8 to take gradients through\n", + "# torch.angle" ] }, { @@ -232,7 +232,7 @@ "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", - "po.synth.geodesic.plot_deviation_from_line(moog, vid, ax=axes[1]);" + "po.synth.geodesic.plot_deviation_from_line(moog, vid, ax=axes[1])" ] }, { @@ -441,7 +441,7 @@ "source": [ "model = po.simul.OnOff(kernel_size=(31, 31), pretrained=True)\n", "po.tools.remove_grad(model)\n", - "po.imshow(model(imgA), zoom=8);" + "po.imshow(model(imgA), zoom=8)" ] }, { @@ -498,7 +498,7 @@ "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", - "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" + "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1])" ] }, { @@ -664,7 +664,7 @@ "print(\"diff\")\n", "pt.imshow(list(geodesic - pixelfade), vrange=\"auto1\", title=None, zoom=4)\n", "print(\"pixelfade\")\n", - "pt.imshow(list(pixelfade), vrange=\"auto1\", title=None, zoom=4);" + "pt.imshow(list(pixelfade), vrange=\"auto1\", title=None, zoom=4)" ] }, { @@ -749,7 +749,7 @@ "po.imshow([imgA, imgB], as_rgb=True)\n", "diff = imgA - imgB\n", "po.imshow(diff)\n", - "pt.image_compare(po.to_numpy(imgA, True), po.to_numpy(imgB, True));" + "pt.image_compare(po.to_numpy(imgA, True), po.to_numpy(imgB, True))" ] }, { @@ -883,6 +883,7 @@ } ], "source": [ + "# noqa: E501\n", "!curl https://gist.githubusercontent.com/yrevar/942d3a0ac09ec9e5eb3a/raw/238f720ff059c1f82f368259d1ca4ffa5dd8f9f5/imagenet1000_clsidx_to_labels.txt -o ../data/imagenet1000_clsidx_to_labels.txt" ] }, From 47aa63dc971d877c4173bc3b0c3ea26604457b3a Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 14:37:45 -0400 Subject: [PATCH 084/134] . --- examples/05_Geodesics.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index 6057b619..189e83ef 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -973,7 +973,7 @@ "source": [ "fig, axes = plt.subplots(2, 1, figsize=(5, 8))\n", "po.synth.geodesic.plot_loss(moog, ax=axes[0])\n", - "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1]);" + "po.synth.geodesic.plot_deviation_from_line(moog, ax=axes[1])" ] }, { From 07ff3822886ef045eee0d4f2f54c3d26de9af72d Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 16:33:22 -0400 Subject: [PATCH 085/134] shortening lines in eigendistortions.py --- src/plenoptic/synthesize/eigendistortion.py | 157 ++++++++++++-------- src/plenoptic/synthesize/geodesic.py | 15 +- src/plenoptic/tools/conv.py | 3 +- 3 files changed, 105 insertions(+), 70 deletions(-) diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index 6c755230..a13b6782 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -56,8 +56,8 @@ def fisher_info_matrix_vector_product( def fisher_info_matrix_eigenvalue( y: Tensor, x: Tensor, v: Tensor, dummy_vec: Tensor | None = None ) -> Tensor: - r"""Compute the eigenvalues of the Fisher Information Matrix corresponding to eigenvectors in v - :math:`\lambda= v^T F v` + r"""Compute the eigenvalues of the Fisher Information Matrix corresponding to + eigenvectors in v:math:`\lambda= v^T F v` """ if dummy_vec is None: dummy_vec = torch.ones_like(y, requires_grad=True) @@ -70,13 +70,14 @@ def fisher_info_matrix_eigenvalue( class Eigendistortion(Synthesis): - r"""Synthesis object to compute eigendistortions induced by a model on a given input image. + r"""Synthesis object to compute eigendistortions induced by a model on a given + input image. Parameters ---------- image - Image, torch.Size(batch=1, channel, height, width). We currently do not support batches of images, - as each image requires its own optimization. + Image, torch.Size(batch=1, channel, height, width). We currently do not + support batches of images, as each image requires its own optimization. model Torch model with defined forward and backward operations. @@ -87,28 +88,35 @@ class Eigendistortion(Synthesis): im_height: int im_width: int jacobian: Tensor - Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``. + Is only set when :func:`synthesize` is run with ``method='exact'``. Default to + ``None``. eigendistortions: Tensor Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue, with Size((n_distortions, n_channels, im_height, im_width)). eigenvalues: Tensor - Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order. + Tensor of eigenvalues corresponding to each eigendistortion, listed in + decreasing order. eigenindex: listlike Index of each eigenvector/eigenvalue. Notes ----- - This is a method for comparing image representations in terms of their ability to explain perceptual sensitivity - in humans. It estimates eigenvectors of the FIM. A model, :math:`y = f(x)`, is a deterministic (and differentiable) - mapping from the input pixels :math:`x \in \mathbb{R}^n` to a mean output response vector :math:`y\in \mathbb{ - R}^m`, where we assume additive white Gaussian noise in the response space. + This is a method for comparing image representations in terms of their ability to + explain perceptual sensitivity in humans. It estimates eigenvectors of the FIM. + A model, :math:`y = f(x)`, is a deterministic (and differentiable) + mapping from the input pixels :math:`x \in \mathbb{R}^n` to a mean output + response vector :math:`y\in \mathbb{R}^m`, where we assume additive white + Gaussian noise in the response space. The Jacobian matrix at x is: - :math:`J(x) = J = dydx`, :math:`J\in\mathbb{R}^{m \times n}` (ie. output_dim x input_dim) - is the matrix of all first-order partial derivatives of the vector-valued function f. - The Fisher Information Matrix (FIM) at x, under white Gaussian noise in the response space, is: + :math:`J(x) = J = dydx`, + :math:`J\in\mathbb{R}^{m \times n}` (ie. output_dim x input_dim) + The matrix consists of all partial derivatives of the vector-valued function f. + The Fisher Information Matrix (FIM) at x, under white Gaussian noise in the + response space, is: :math:`F = J^T J` - It is a quadratic approximation of the discriminability of distortions relative to :math:`x`. + It is a quadratic approximation of the discriminability of distortions + relative to :math:`x`. References ---------- @@ -175,27 +183,31 @@ def synthesize( q: int = 2, stop_criterion: float = 1e-7, ): - r"""Compute eigendistortions of Fisher Information Matrix with given input image. + r""" + Compute eigendistortions of Fisher Information Matrix with given input image. Parameters ---------- method Eigensolver method. 'exact' tries to do eigendecomposition directly ( - not recommended for very large inputs). 'power' (default) uses the power method to compute first and - last eigendistortions, with maximum number of iterations dictated by n_steps. 'randomized_svd' uses - randomized SVD to approximate the top k eigendistortions and their corresponding eigenvalues. + not recommended for very large inputs). 'power' (default) uses the power + method to compute first and last eigendistortions, with maximum number of + iterations dictated by n_steps. 'randomized_svd' uses randomized SVD to + approximate the top k eigendistortions and their corresponding eigenvalues. k How many vectors to return using block power method or svd. max_iter - Maximum number of steps to run for ``method='power'`` in eigenvalue computation. Ignored - for other methods. + Maximum number of steps to run for ``method='power'`` in eigenvalue + computation. Ignored for other methods. p - Oversampling parameter for randomized SVD. k+p vectors will be sampled, and k will be returned. See - docstring of ``_synthesize_randomized_svd`` for more details including algorithm reference. + Oversampling parameter for randomized SVD. k+p vectors will be sampled, + and k will be returned. See docstring of ``_synthesize_randomized_svd`` + for more details including algorithm reference. q - Matrix power parameter for randomized SVD. This is an effective trick for the algorithm to converge to - the correct eigenvectors when the eigenspectrum does not decay quickly. See - ``_synthesize_randomized_svd`` for more details including algorithm reference. + Matrix power parameter for randomized SVD. This is an effective trick for + the algorithm to converge to the correct eigenvectors when the + eigenspectrum does not decay quickly. See ``_synthesize_randomized_svd`` + for more details including algorithm reference. stop_criterion Used if ``method='power'`` to check for convergence. If the L2-norm of the eigenvalues has changed by less than this value from one @@ -258,16 +270,18 @@ def synthesize( def _synthesize_exact(self) -> tuple[Tensor, Tensor]: r"""Eigendecomposition of explicitly computed Fisher Information Matrix. - To be used when the input is small (e.g. less than 70x70 image on cluster or 30x30 on your own machine). This - method obviates the power iteration and its related algorithms (e.g. Lanczos). This method computes the - Fisher Information Matrix by explicitly computing the Jacobian of the representation wrt the input. + To be used when the input is small (e.g. less than 70x70 image on cluster or + 30x30 on your own machine). This method obviates the power iteration and its + related algorithms (e.g. Lanczos). This method computes the Fisher Information + Matrix by explicitly computing the Jacobian of the representation wrt the input. Returns ------- eig_vals Eigenvalues in decreasing order. eig_vecs - Eigenvectors in 2D tensor, whose cols are eigenvectors (i.e. eigendistortions) corresponding to eigenvalues. + Eigenvectors in 2D tensor, whose cols are eigenvectors + (i.e. eigendistortions) corresponding to eigenvalues. """ J = self.compute_jacobian() @@ -278,7 +292,8 @@ def _synthesize_exact(self) -> tuple[Tensor, Tensor]: return eig_vals, eig_vecs def compute_jacobian(self) -> Tensor: - r"""Calls autodiff.jacobian and returns jacobian. Will throw error if input too big. + r""" + Calls autodiff.jacobian and returns jacobian. Will throw error if input too big. Returns ------- @@ -297,23 +312,26 @@ def compute_jacobian(self) -> Tensor: def _synthesize_power( self, k: int, shift: Tensor | float, tol: float, max_iter: int ) -> tuple[Tensor, Tensor]: - r"""Use power method (or orthogonal iteration when k>1) to obtain largest (smallest) eigenvalue/vector pairs. + r"""Use power method (or orthogonal iteration when k>1) to obtain largest + (smallest) eigenvalue/vector pairs. - Apply the algorithm to approximate the extremal eigenvalues and eigenvectors of the Fisher - Information Matrix, without explicitly representing that matrix. + Apply the algorithm to approximate the extremal eigenvalues and eigenvectors + of the Fisher Information Matrix, without explicitly representing that matrix. - This method repeatedly calls ``fisher_info_matrix_vector_product()`` with a single (`k=1`), or multiple - (`k>1`) vectors. + This method repeatedly calls ``fisher_info_matrix_vector_product()`` with a + single (`k=1`), or multiple (`k>1`) vectors. Parameters ---------- k - Number of top and bottom eigendistortions to synthesize; i.e. if k=2, then the top 2 and bottom 2 will - be returned. When `k>1`, multiple eigendistortions are synthesized, and each power iteration step is - followed by a QR orthogonalization step to ensure the vectors are orthonormal. + Number of top and bottom eigendistortions to synthesize; i.e. if k=2, + then the top 2 and bottom 2 will be returned. When `k>1`, multiple + eigendistortions are synthesized, and each power iteration step is followed + by a QR orthogonalization step to ensure the vectors are orthonormal. shift - When `shift=0`, this function estimates the top `k` eigenvalue/vector pairs. When `shift` is set to the - estimated top eigenvalue this function will estimate the smallest eigenval/eigenvector pairs. + When `shift=0`, this function estimates the top `k` eigenvalue/vector + pairs. When `shift` is set to the estimated top eigenvalue this function + will estimate the smallest eigenval/eigenvector pairs. tol Tolerance value. max_iter @@ -324,11 +342,13 @@ def _synthesize_power( lmbda Eigenvalue corresponding to final vector of power iteration. v - Final eigenvector(s) (i.e. eigendistortions) of power (orthogonal) iteration procedure. + Final eigenvector(s) (i.e. eigendistortions) of power (orthogonal) + iteration procedure. References ---------- - [1] Orthogonal iteration; Algorithm 8.2.8 Golub and Van Loan, Matrix Computations, 3rd Ed. + [1] Orthogonal iteration; Algorithm 8.2.8 Golub and Van Loan, Matrix + Computations, 3rd Ed. """ x, y = self._image_flat, self._representation_flat @@ -378,8 +398,8 @@ def _synthesize_randomized_svd( ) -> tuple[Tensor, Tensor, Tensor]: r"""Synthesize eigendistortions using randomized truncated SVD. - This method approximates the column space of the Fisher Info Matrix, projects the FIM into that column space, - then computes its SVD. + This method approximates the column space of the Fisher Info Matrix, projects + the FIM into that column space, then computes its SVD. Parameters ---------- @@ -388,8 +408,8 @@ def _synthesize_randomized_svd( p Oversampling parameter, recommended to be 5. q - Matrix power iteration. Used to squeeze the eigen spectrum for more accurate approximation. - Recommended to be 2. + Matrix power iteration. Used to squeeze the eigen spectrum for more + accurate approximation. Recommended to be 2. Returns ------- @@ -403,8 +423,9 @@ def _synthesize_randomized_svd( References ----- - [1] Halko, Martinsson, Tropp, Finding structure with randomness: Probabilistic algorithms for constructing - approximate matrix decompositions, SIAM Rev. 53:2, pp. 217-288 https://arxiv.org/abs/0909.4061 (2011) + [1] Halko, Martinsson, Tropp, Finding structure with randomness: + Probabilistic algorithms for constructing approximate matrix decompositions, + SIAM Rev. 53:2, pp. 217-288 https://arxiv.org/abs/0909.4061 (2011) """ @@ -444,8 +465,9 @@ def _vector_to_image(self, vecs: Tensor) -> list[Tensor]: Parameters ---------- vecs - Eigendistortion tensor with ``torch.Size([N, num_distortions])``. Each distortion will be reshaped into the - original image shape and placed in a list. + Eigendistortion tensor with ``torch.Size([N, num_distortions])``. + Each distortion will be reshaped into the original image shape and + placed in a list. Returns ------- @@ -596,17 +618,20 @@ def image(self): @property def jacobian(self): - """Is only set when :func:`synthesize` is run with ``method='exact'``. Default to ``None``.""" + """Is only set when :func:`synthesize` is run with ``method='exact'``. + Default to ``None``.""" return self._jacobian @property def eigendistortions(self): - """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by eigenvalue.""" + """Tensor of eigendistortions (eigenvectors of Fisher matrix), ordered by + eigenvalue.""" return self._eigendistortions @property def eigenvalues(self): - """Tensor of eigenvalues corresponding to each eigendistortion, listed in decreasing order.""" + """Tensor of eigenvalues corresponding to each eigendistortion, listed in + decreasing order.""" return self._eigenvalues @property @@ -627,27 +652,31 @@ def display_eigendistortion( ) -> Figure: r"""Displays specified eigendistortion added to the image. - If image or eigendistortions have 3 channels, then it is assumed to be a color image and it is converted to - grayscale. This is merely for display convenience and may change in the future. + If image or eigendistortions have 3 channels, then it is assumed to be a color + image and it is converted to grayscale. This is merely for display convenience + and may change in the future. Parameters ---------- eigendistortion Eigendistortion object whose synthesized eigendistortion we want to display eigenindex - Index of eigendistortion to plot. E.g. If there are 10 eigenvectors, 0 will index the first one, and - -1 or 9 will index the last one. + Index of eigendistortion to plot. E.g. If there are 10 eigenvectors, 0 will + index the first one, and -1 or 9 will index the last one. alpha - Amount by which to scale eigendistortion for `image + (alpha * eigendistortion)` for display. + Amount by which to scale eigendistortion for `image + (alpha * eigendistortion)` + for display. process_image - A function to process the image+alpha*distortion before clamping between 0,1. E.g. multiplying by the - stdev ImageNet then adding the mean of ImageNet to undo image preprocessing. + A function to process the image+alpha*distortion before clamping between 0,1. + E.g. multiplying by the stdev ImageNet then adding the mean of ImageNet to undo + image preprocessing. ax Axis handle on which to plot. plot_complex - Parameter for :meth:`plenoptic.imshow` determining how to handle complex values. Defaults to 'rectangular', - which plots real and complex components as separate images. Can also be 'polar' or 'logpolar'; see that - method's docstring for details. + Parameter for :meth:`plenoptic.imshow` determining how to handle complex values. + Defaults to 'rectangular', which plots real and complex components as separate + images. Can also be 'polar' or 'logpolar'; see that method's docstring + for details. kwargs Additional arguments for :meth:`po.imshow()`. diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index fad74460..b94af4b6 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -225,7 +225,8 @@ def objective_function(self, geodesic: Tensor | None = None) -> Tensor: - ``self._geodesic_representation = self.model(geodesic)`` - - ``self._most_recent_step_energy = self._calculate_step_energy(self._geodesic_representation)`` + - ``self._most_recent_step_energy = self._calculate_step_energy( + self._geodesic_representation)`` These are cached because we might store them (if ``self.store_progress is True``) and don't want to recalcualte them @@ -301,7 +302,8 @@ def _check_convergence( Have we been synthesizing for ``stop_iters_to_check`` iterations? | | no yes - | '---->Is ``(self.pixel_change_norm[-stop_iters_to_check:] < stop_criterion).all()``? + | '---->Is ``(self.pixel_change_norm[-stop_iters_to_check:] < s + | | top_criterion).all()``? | no | | | yes <-------' | @@ -327,7 +329,8 @@ def _check_convergence( return pixel_change_convergence(self, stop_criterion, stop_iters_to_check) def calculate_jerkiness(self, geodesic: Tensor | None = None) -> Tensor: - """Compute the alignment of representation's acceleration to model local curvature. + """ + Compute the alignment of representation's acceleration to model local curvature. This is the first order optimality condition for a geodesic, and can be used to assess the validity of the solution obtained by optimization. @@ -573,7 +576,8 @@ def geodesic(self): @property def step_energy(self): - """Squared L2 norm of transition between geodesic frames in representation space. + """ + Squared L2 norm of transition between geodesic frames in representation space. Has shape ``(np.ceil(synth_iter/store_progress), n_steps)``, where ``synth_iter`` is the number of iterations of synthesis that have @@ -584,7 +588,8 @@ def step_energy(self): @property def dev_from_line(self): - """Deviation of representation each from of ``self.geodesic`` from a straight line. + """Deviation of representation each from of ``self.geodesic`` from a straight + line. Has shape ``(np.ceil(synth_iter/store_progress), n_steps+1, 2)``, where ``synth_iter`` is the number of iterations of synthesis that have diff --git a/src/plenoptic/tools/conv.py b/src/plenoptic/tools/conv.py index c4231d40..05095aef 100644 --- a/src/plenoptic/tools/conv.py +++ b/src/plenoptic/tools/conv.py @@ -79,7 +79,8 @@ def blur_downsample(x, n_scales=1, filtname="binom5", scale_filter=True): x: torch.Tensor of shape (batch, channel, height, width) Image, or batch of images. Channels are treated in the same way as batches. n_scales: int, optional. Should be non-negative. - Apply the blur and downsample procedure recursively `n_scales` times. Default to 1. + Apply the blur and downsample procedure recursively `n_scales` times. Default to + 1. filtname: str, optional Name of the filter. See `pt.named_filter` for options. Default to "binom5". scale_filter: bool, optional From 12daada14986654b90588c14ae28da9160b53aa8 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 16:43:04 -0400 Subject: [PATCH 086/134] too long lines fixed in notebook metamer-portilla-simoncelli --- examples/Metamer-Portilla-Simoncelli.ipynb | 97 +++++++++++++--------- src/plenoptic/data/data_utils.py | 17 ++-- 2 files changed, 66 insertions(+), 48 deletions(-) diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index 853df937..8d219a3e 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -24,7 +24,8 @@ "%autoreload \n", "\n", "# We need to download some additional images for this notebook. In order to do so,\n", - "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError\n", + "# we use an optional dependency, pooch. If the following raises an ImportError or\n", + "# ModuleNotFoundError\n", "# then install pooch in your plenoptic environment and restart your kernel.\n", "DATA_PATH = po.data.fetch_data(\"portilla_simoncelli_images.tar.gz\")\n", "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", @@ -46,8 +47,9 @@ }, "outputs": [], "source": [ - "# These variables control how long metamer synthesis runs for. The values present here will result in completed synthesis,\n", - "# but you may want to decrease these numbers if you're on a machine with limited resources.\n", + "# These variables control how long metamer synthesis runs for. The values present\n", + "# here will result in completed synthesis, but you may want to decrease these numbers\n", + "# if you're on a machine with limited resources.\n", "short_synth_max_iter = 1000\n", "long_synth_max_iter = 3000\n", "longest_synth_max_iter = 4000" @@ -212,7 +214,7 @@ ], "source": [ "img = po.tools.load_images(DATA_PATH / \"fig4a.jpg\")\n", - "po.imshow(img);" + "po.imshow(img)" ] }, { @@ -312,7 +314,7 @@ "# representation_error plot has three subplots, so we increase its relative width\n", "po.synth.metamer.plot_synthesis_status(\n", " met, width_ratios={\"plot_representation_error\": 3.1}\n", - ");" + ")" ] }, { @@ -341,7 +343,7 @@ } ], "source": [ - "po.imshow(img);" + "po.imshow(img)" ] }, { @@ -394,8 +396,8 @@ "o = met.synthesize(\n", " max_iter=short_synth_max_iter,\n", " store_progress=True,\n", - " # setting change_scale_criterion=None means that we change scales every ctf_iters_to_check,\n", - " # see the metamer notebook for details.\n", + " # setting change_scale_criterion=None means that we change scales every\n", + " # ctf_iters_to_check, see the metamer notebook for details.\n", " change_scale_criterion=None,\n", " ctf_iters_to_check=7,\n", ")" @@ -559,11 +561,13 @@ " im_shape: int\n", " the size of the images being processed by the model\n", " remove_keys: list\n", - " The dictionary keys for the statistics we will \"remove\". In practice we set them to zero.\n", + " The dictionary keys for the statistics we will \"remove\". In practice we set\n", + " them to zero.\n", " Possible keys: [\"pixel_statistics\", \"auto_correlation_magnitude\",\n", - " \"skew_reconstructed\", \"kurtosis_reconstructed\", \"auto_correlation_reconstructed\",\n", - " \"std_reconstructed\", \"magnitude_std\", \"cross_orientation_correlation_magnitude\",\n", - " \"cross_scale_correlation_magnitude\" \"cross_scale_correlation_real\", \"var_highpass_residual\"]\n", + " \"skew_reconstructed\", \"kurtosis_reconstructed\",\n", + " \"auto_correlation_reconstructed\", \"std_reconstructed\", \"magnitude_std\",\n", + " \"cross_orientation_correlation_magnitude\", \"cross_scale_correlation_magnitude\",\n", + " \"cross_scale_correlation_real\", \"var_highpass_residual\"]\n", " \"\"\"\n", "\n", " def __init__(\n", @@ -575,7 +579,8 @@ " self.remove_keys = remove_keys\n", "\n", " def forward(self, image, scales=None):\n", - " r\"\"\"Generate Texture Statistics representation of an image with `remove_keys` removed.\n", + " r\"\"\"Generate Texture Statistics representation of an image with `remove_keys`\n", + " removed.\n", "\n", " Parameters\n", " ----------\n", @@ -589,7 +594,8 @@ " Returns\n", " -------\n", " representation: torch.Tensor\n", - " 3d tensor of shape (batch, channel, stats) containing the measured texture stats.\n", + " 3d tensor of shape (batch, channel, stats) containing the measured texture\n", + " stats.\n", "\n", " \"\"\"\n", " # create the representation tensor (with all scales)\n", @@ -605,8 +611,8 @@ " stats_dict[kk][key] *= 0\n", " else:\n", " stats_dict[kk] *= 0\n", - " # then convert back to tensor and remove any scales we don't want (for coarse-to-fine)\n", - " # -- see discussion above.\n", + " # then convert back to tensor and remove any scales we don't want\n", + " # (for coarse-to-fine) -- see discussion above.\n", " stats_vec = self.convert_to_tensor(stats_dict)\n", " if scales is not None:\n", " stats_vec = self.remove_scales(stats_vec, scales)\n", @@ -745,9 +751,9 @@ } ], "source": [ - "# which statistics to remove. note that, in the original paper, std_reconstructed is implicitly contained within\n", - "# auto_correlation_reconstructed, view the section on differences between plenoptic and matlab implementation\n", - "# for details\n", + "# which statistics to remove. note that, in the original paper, std_reconstructed is\n", + "# implicitly contained within auto_correlation_reconstructed, view the section on\n", + "# differences between plenoptic and matlab implementation for details\n", "remove_statistics = [\"auto_correlation_reconstructed\", \"std_reconstructed\"]\n", "\n", "# run on fig4a or fig4b to replicate paper\n", @@ -790,7 +796,7 @@ " \"Without Correlation Statistics\",\n", " ],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -839,7 +845,7 @@ " figsize=(15, 5),\n", " ylim=(-4, 4),\n", ")\n", - "fig.suptitle(\"Full statistics\");" + "fig.suptitle(\"Full statistics\")" ] }, { @@ -871,9 +877,9 @@ } ], "source": [ - "# which statistics to remove. note that, in the original paper, magnitude_std is implicitly contained within\n", - "# auto_correlation_magnitude, view the section on differences between plenoptic and matlab implementation\n", - "# for details\n", + "# which statistics to remove. note that, in the original paper, magnitude_std is\n", + "# implicitly contained within auto_correlation_magnitude, view the section on\n", + "# differences between plenoptic and matlab implementation for details.\n", "remove_statistics = [\n", " \"magnitude_std\",\n", " \"cross_orientation_correlation_magnitude\",\n", @@ -1041,7 +1047,7 @@ " \"Without Cross-Scale Phase Statistics\",\n", " ],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -1090,7 +1096,7 @@ " figsize=(15, 5),\n", " ylim=(-1.2, 1.2),\n", ")\n", - "fig.suptitle(\"Full statistics\");" + "fig.suptitle(\"Full statistics\")" ] }, { @@ -1159,7 +1165,7 @@ " [metamer.image, metamer.metamer],\n", " title=[\"Target image\", \"Synthesized Metamer\"],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -1315,7 +1321,7 @@ " [metamer.image, metamer.metamer],\n", " title=[\"Target image\", \"Synthesized Metamer\"],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -1429,7 +1435,7 @@ " [metamer.image, metamer.metamer],\n", " title=[\"Target image\", \"Synthesized metamer\"],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -1467,7 +1473,8 @@ " Additional Parameters\n", " ----------\n", " mask: Tensor\n", - " boolean mask with True in the part of the image that will be filled in during synthesis\n", + " boolean mask with True in the part of the image that will be filled in during\n", + " synthesis\n", " target: Tensor\n", " image target for synthesis\n", "\n", @@ -1487,7 +1494,8 @@ " self.target = target\n", "\n", " def forward(self, image, scales=None):\n", - " r\"\"\"Generate Texture Statistics representation of an image using the target for the masked portion\n", + " r\"\"\"Generate Texture Statistics representation of an image using the target for\n", + " the masked portion\n", "\n", " Parameters\n", " ----------\n", @@ -1512,7 +1520,8 @@ " return super().forward(image, scales=scales)\n", "\n", " def texture_masked_image(self, image):\n", - " r\"\"\"Fill in part of the image (designated by the mask) with the saved target image\n", + " r\"\"\"Fill in part of the image (designated by the mask) with the saved target\n", + " image\n", "\n", " Parameters\n", " ------------\n", @@ -1689,7 +1698,8 @@ " )\n", " # the difference between this and the regular version of Metamer is that\n", " # the regular version requires synthesized_signal and target_signal to have\n", - " # the same shape, and here target_signal is (2, 1, 256, 256), not (1, 1, 256, 256)\n", + " # the same shape, and here target_signal is\n", + " # (2, 1, 256, 256), not (1, 1, 256, 256)\n", " metamer = initial_image.clone().detach()\n", " metamer = metamer.to(dtype=self.image.dtype, device=self.image.device)\n", " metamer.requires_grad_()\n", @@ -1823,7 +1833,7 @@ " [metamer.image, metamer.metamer],\n", " title=[\"Target image\", \"Synthesized Metamer\"],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -1875,7 +1885,7 @@ " [metamer.image, metamer.metamer],\n", " title=[\"Target image\", \"Synthesized Metamer\"],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -2092,11 +2102,14 @@ " ~torch.isnan(stats_dict[\"auto_correlation_reconstructed\"])\n", ")\n", "real_variances = torch.sum(~torch.isnan(stats_dict[\"std_reconstructed\"]))\n", + "\n", + "\n", "print(\n", - " f\"Raw coefficient correlation: {real_coefficient_corr_num + real_variances} parameters, \"\n", - " \"compared to 125 in paper\"\n", + " f\"Raw coefficient correlation: {real_coefficient_corr_num + real_variances} \"\n", + " f\"parameters, compared to 125 in the paper\"\n", ")\n", "\n", + "\n", "# Sum coefficient magnitude statistics\n", "coeff_magnitude_stats_num = (\n", " torch.sum(~torch.isnan(stats_dict[\"auto_correlation_magnitude\"]))\n", @@ -2106,7 +2119,8 @@ "coeff_magnitude_variances = torch.sum(~torch.isnan(stats_dict[\"magnitude_std\"]))\n", "\n", "print(\n", - " f\"Coefficient magnitude statistics: {coeff_magnitude_stats_num + coeff_magnitude_variances} \"\n", + " f\"Coefficient magnitude statistics: {coeff_magnitude_stats_num + \n", + " coeff_magnitude_variances} \"\n", " \"parameters, compared to 472 in paper\"\n", ")\n", "\n", @@ -2188,8 +2202,8 @@ " magnitude_means = [mag.mean((-2, -1)) for mag in magnitude_pyr_coeffs]\n", " return einops.pack([stats, *magnitude_means], \"b c *\")[0]\n", "\n", - " # overwriting these following two methods allows us to use the plot_representation method\n", - " # with the modified model, making examining it easier.\n", + " # overwriting these following two methods allows us to use the plot_representation\n", + " # method with the modified model, making examining it easier.\n", " def convert_to_dict(self, representation_tensor: torch.Tensor) -> OrderedDict:\n", " \"\"\"Convert tensor of stats to dictionary.\"\"\"\n", " n_mag_means = self.n_scales * self.n_orientations\n", @@ -2204,7 +2218,8 @@ " return rep\n", "\n", " def _representation_for_plotting(self, rep: OrderedDict) -> OrderedDict:\n", - " r\"\"\"Convert the data into a dictionary representation that is more convenient for plotting.\n", + " r\"\"\"Convert the data into a dictionary representation that is more convenient\n", + " for plotting.\n", "\n", " Intended as a helper function for plot_representation.\n", " \"\"\"\n", diff --git a/src/plenoptic/data/data_utils.py b/src/plenoptic/data/data_utils.py index 70b2bc18..d9988832 100644 --- a/src/plenoptic/data/data_utils.py +++ b/src/plenoptic/data/data_utils.py @@ -12,7 +12,8 @@ def get_path(item_name: str) -> Traversable: Parameters ---------- item_name - The name of the item to find the file for, without specifying the file extension. + The name of the item to find the file for, without specifying the file + extension. Returns ------- @@ -26,8 +27,9 @@ def get_path(item_name: str) -> Traversable: Notes ----- - This function uses glob to search for files in the current directory matching the `item_name`. - It is assumed that there is only one file matching the name regardless of its extension. + This function uses glob to search for files in the current directory matching the + `item_name`. It is assumed that there is only one file matching the name + regardless of its extension. """ fhs = [ file @@ -53,13 +55,14 @@ def get(*item_names: str, as_gray: None | bool = None): Returns ------- - The loaded image object. The exact return type depends on the `load_images` function implementation. + The loaded image object. The exact return type depends on the `load_images` + function implementation. Notes ----- - This function first retrieves the full filename using `get_filename` and then loads the image - using `load_images` from the `tools.data` module. It supports loading images as grayscale if - they have a `.pgm` extension. + This function first retrieves the full filename using `get_filename` and then + loads the image using `load_images` from the `tools.data` module. It supports + loading images as grayscale if they have a `.pgm` extension. """ paths = [get_path(name) for name in item_names] From bd34ed063fb3ff93cf090c030957b420c5e41241 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 16:44:47 -0400 Subject: [PATCH 087/134] too long lines fixed in notebook metamer-portilla-simoncelli --- examples/Metamer-Portilla-Simoncelli.ipynb | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index 8d219a3e..989984ab 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -381,7 +381,8 @@ } ], "source": [ - "# send image and PS model to GPU, if available. then im_init and Metamer will also use GPU\n", + "# send image and PS model to GPU, if available. then im_init and Metamer will also\n", + "# use GPU\n", "img = img.to(DEVICE)\n", "model = po.simul.PortillaSimoncelli(img.shape[-2:]).to(DEVICE)\n", "im_init = (torch.rand_like(img) - 0.5) * 0.1 + img.mean()\n", @@ -431,7 +432,7 @@ " [met.image, met.metamer],\n", " title=[\"Target image\", \"Synthesized metamer\"],\n", " vrange=\"auto1\",\n", - ");" + ")" ] }, { @@ -462,7 +463,7 @@ "source": [ "po.synth.metamer.plot_synthesis_status(\n", " met, width_ratios={\"plot_representation_error\": 3.1}\n", - ");" + ")" ] }, { @@ -544,17 +545,18 @@ }, "outputs": [], "source": [ - "# The following class extends the PortillaSimoncelli model so that you can specify which\n", - "# statistics you would like to remove. We have created this model so that we can examine\n", - "# the consequences of the absence of specific statistics.\n", - "#\n", + "# The following class extends the PortillaSimoncelli model so that you can specify\n", + "# which statistics you would like to remove. We have created this model so that we\n", + "# can examine the consequences of the absence of specific statistics.\n", + "\n", "# Be sure to run this cell.\n", "\n", "from collections import OrderedDict\n", "\n", "\n", "class PortillaSimoncelliRemove(po.simul.PortillaSimoncelli):\n", - " r\"\"\"Model for measuring a subset of texture statistics reported by PortillaSimoncelli\n", + " r\"\"\"Model for measuring a subset of texture statistics reported by\n", + " PortillaSimoncelli\n", "\n", " Parameters\n", " ----------\n", From bfda72cce98f6b29f91076f7895174968368e8db Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 16:49:37 -0400 Subject: [PATCH 088/134] too long lines fixed in notebooks --- examples/02_Eigendistortions.ipynb | 33 +++++++++++++++++------------ examples/Display.ipynb | 9 ++++---- examples/Synthesis_extensions.ipynb | 8 +++---- 3 files changed, 28 insertions(+), 22 deletions(-) diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 065f7d18..5ec65f8e 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -45,12 +45,14 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", - "\n", - "# so that relative sizes of axes created by po.imshow and others look right\n", - "plt.rcParams[\"figure.dpi\"] = 72\n", "import torch\n", "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", "from torch import nn\n", + "import plenoptic as po\n", + "\n", + "# so that relative sizes of axes created by po.imshow and others look right\n", + "plt.rcParams[\"figure.dpi\"] = 72\n", + "\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment\n", @@ -62,8 +64,7 @@ " \"optional dependency torchvision not found!\"\n", " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\"\n", - " )\n", - "import plenoptic as po" + " )" ] }, { @@ -124,8 +125,8 @@ "source": [ "class LinearModel(nn.Module):\n", " \"\"\"The simplest model we can make.\n", - " Its Jacobian should be the weight matrix of M, and the eigenvectors of the Fisher matrix are therefore the\n", - " eigenvectors of M.T @ M\"\"\"\n", + " Its Jacobian should be the weight matrix of M, and the eigenvectors of the\n", + " Fisher matrix are therefore the eigenvectors of M.T @ M\"\"\"\n", "\n", " def __init__(self, n, m):\n", " super().__init__()\n", @@ -137,7 +138,9 @@ " return y\n", "\n", "\n", - "n = 25 # input vector dim (can you predict what the eigenvec/vals would be when n Date: Fri, 27 Sep 2024 16:51:38 -0400 Subject: [PATCH 089/134] too long lines fixed in notebooks --- examples/09_Original_MAD.ipynb | 7 ++++--- examples/Synthesis_extensions.ipynb | 6 +++--- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/examples/09_Original_MAD.ipynb b/examples/09_Original_MAD.ipynb index d451d989..60194da2 100644 --- a/examples/09_Original_MAD.ipynb +++ b/examples/09_Original_MAD.ipynb @@ -142,9 +142,10 @@ } ], "source": [ - "# We need to download some additional data for this portion of the notebook. In order to do so,\n", - "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError\n", - "# then install pooch in your plenoptic environment and restart your kernel.\n", + "# We need to download some additional data for this portion of the notebook.\n", + "# In order to do so, we use an optional dependency, pooch. If the following raises an\n", + "# ImportError or ModuleNotFoundError then install pooch in your plenoptic\n", + "# environment and restart your kernel.\n", "fig, results = po.tools.external.plot_MAD_results(\"samp6\", [128], vrange=\"row1\", zoom=3)" ] }, diff --git a/examples/Synthesis_extensions.ipynb b/examples/Synthesis_extensions.ipynb index f4ae31f7..c1bc9f1d 100644 --- a/examples/Synthesis_extensions.ipynb +++ b/examples/Synthesis_extensions.ipynb @@ -205,13 +205,13 @@ ], "source": [ "with warnings.catch_warnings():\n", - " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", - " # which will happen briefly during synthesis.\n", + " # we suppress the warning telling us that our image falls outside of the (0, 1)\n", + " # range, which will happen briefly during synthesis.\n", " warnings.simplefilter(\"ignore\")\n", " old_mad.synthesize(store_progress=True)\n", "po.synth.mad_competition.plot_synthesis_status(\n", " old_mad, included_plots=[\"display_mad_image\", \"plot_loss\"]\n", - ");" + ")" ] }, { From 6413588b79bc01481e7c13f281432aced85126c1 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 16:52:57 -0400 Subject: [PATCH 090/134] too long lines fixed in notebooks --- examples/08_MAD_Competition.ipynb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index 2fb5aa2b..0aeb04ef 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -171,8 +171,8 @@ ], "source": [ "with warnings.catch_warnings():\n", - " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", - " # which will happen briefly during synthesis.\n", + " # we suppress the warning telling us that our image falls outside of the (0, 1)\n", + " # range, which will happen briefly during synthesis.\n", " warnings.simplefilter(\"ignore\")\n", " mad.synthesize(max_iter=200)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad)" @@ -261,8 +261,8 @@ ], "source": [ "with warnings.catch_warnings():\n", - " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", - " # which will happen briefly during synthesis.\n", + " # we suppress the warning telling us that our image falls outside of the (0, 1)\n", + " # range, which will happen briefly during synthesis.\n", " warnings.simplefilter(\"ignore\")\n", " mad_ssim_max.synthesize(max_iter=300)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_ssim_max)" @@ -308,8 +308,8 @@ " metric_tradeoff_lambda=1,\n", ")\n", "with warnings.catch_warnings():\n", - " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", - " # which will happen briefly during synthesis.\n", + " # we suppress the warning telling us that our image falls outside of the (0, 1)\n", + " # range, which will happen briefly during synthesis.\n", " warnings.simplefilter(\"ignore\")\n", " mad_mse_min.synthesize(max_iter=400, stop_criterion=1e-6)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_mse_min)" @@ -357,8 +357,8 @@ " metric_tradeoff_lambda=10,\n", ")\n", "with warnings.catch_warnings():\n", - " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", - " # which will happen briefly during synthesis.\n", + " # we suppress the warning telling us that our image falls outside of the (0, 1)\n", + " # range, which will happen briefly during synthesis.\n", " warnings.simplefilter(\"ignore\")\n", " mad_mse_max.synthesize(max_iter=200, stop_criterion=1e-6)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_mse_max)" From bb9c581d7f5f9b320d8f604f806422210d2cf790 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 16:54:07 -0400 Subject: [PATCH 091/134] too long lines fixed in notebooks --- examples/Demo_Eigendistortion.ipynb | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/examples/Demo_Eigendistortion.ipynb b/examples/Demo_Eigendistortion.ipynb index eeb2f8de..a2aed610 100644 --- a/examples/Demo_Eigendistortion.ipynb +++ b/examples/Demo_Eigendistortion.ipynb @@ -46,6 +46,9 @@ "source": [ "from plenoptic.synthesize import Eigendistortion\n", "from plenoptic.simulate.models import OnOff\n", + "import torch\n", + "from torch import nn\n", + "import plenoptic as po\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment\n", @@ -58,9 +61,7 @@ " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\"\n", " )\n", - "import torch\n", - "from torch import nn\n", - "import plenoptic as po\n", + "\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(\"device: \", device)" @@ -624,9 +625,13 @@ " zoom=zoom,\n", ")\n", "\n", - "# create an image processing function to unnormalize the image and avg the channels to grayscale\n", + "\n", + "# create an image processing function to unnormalize the image and avg the channels to\n", + "# grayscale\n", "def unnormalize(x):\n", " return (x * image.std() + image.mean()).mean(1, keepdims=True)\n", + "\n", + "\n", "alpha_max, alpha_min = 15.0, 100.0\n", "\n", "v_max = po.synth.eigendistortion.display_eigendistortion(\n", From b1e771bd38b92150f2012176f717d6762607b3c2 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 16:56:20 -0400 Subject: [PATCH 092/134] too long lines fixed in notebooks --- examples/03_Steerable_Pyramid.ipynb | 48 +++++++++++++++++------------ 1 file changed, 29 insertions(+), 19 deletions(-) diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index 08d259af..424bb6ac 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -21,6 +21,15 @@ "source": [ "import numpy as np\n", "import torch\n", + "import torchvision.transforms as transforms\n", + "import torch.nn.functional as F\n", + "from torch import nn\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import plenoptic as po\n", + "from plenoptic.simulate import SteerablePyramidFreq\n", + "from plenoptic.tools.data import to_numpy\n", + "from tqdm.auto import tqdm\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment\n", @@ -33,18 +42,10 @@ " \" please install it in your plenoptic environment \"\n", " \"and restart the notebook kernel\"\n", " )\n", - "import torchvision.transforms as transforms\n", - "import torch.nn.functional as F\n", - "from torch import nn\n", - "import matplotlib.pyplot as plt\n", "\n", - "import plenoptic as po\n", - "from plenoptic.simulate import SteerablePyramidFreq\n", - "from plenoptic.tools.data import to_numpy\n", "\n", "dtype = torch.float32\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "from tqdm.auto import tqdm\n", "\n", "%load_ext autoreload\n", "\n", @@ -120,11 +121,12 @@ "# ... and then reconstruct this dummy image to visualize the filter.\n", "reconList = []\n", "for k in pyr_coeffs:\n", - " # we ignore the residual_highpass and residual_lowpass, since we're focusing on the filters here\n", + " # we ignore the residual_highpass and residual_lowpass, since we're focusing on the\n", + " # filters here\n", " if isinstance(k, tuple):\n", " reconList.append(pyr.recon_pyr(pyr_coeffs, [k[0]], [k[1]]))\n", "\n", - "po.imshow(reconList, col_wrap=order + 1, vrange=\"indep1\", zoom=2);" + "po.imshow(reconList, col_wrap=order + 1, vrange=\"indep1\", zoom=2)" ] }, { @@ -330,7 +332,8 @@ } ], "source": [ - "# the same visualization machinery works for complex pyramidswhat is shown is the magnitude of the coefficients\n", + "# the same visualization machinery works for complex pyramidswhat is shown is the\n", + "# magnitude of the coefficients\n", "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=0)\n", "po.pyrshow(pyr_coeffs_complex, zoom=0.5, batch_idx=1)" ] @@ -2168,13 +2171,15 @@ } ], "source": [ - "# note that steering is currently only implemeted for real pyramids, so the `is_complex` argument must be False (as it is by default)\n", + "# note that steering is currently only implemeted for real pyramids, so the `is_complex`\n", + "# argument must be False (as it is by default)\n", "pyr = SteerablePyramidFreq(height=3, image_shape=[256, 256], order=3, twidth=1).to(\n", " device\n", ")\n", "coeffs = pyr(im_batch)\n", "\n", - "# play around with different scales! Coarser scales tend to make the steering a bit more obvious.\n", + "# play around with different scales! Coarser scales tend to make the steering a bit\n", + "# more obvious.\n", "target_scale = 2\n", "N_steer = 64\n", "M = torch.zeros(1, 1, N_steer, 256 // 2**target_scale, 256 // 2**target_scale)\n", @@ -2182,7 +2187,8 @@ " steer_angle = steering_offset * 2 * np.pi\n", " steered_coeffs, steering_weights = pyr.steer_coeffs(\n", " coeffs, [steer_angle]\n", - " ) # (the steering coefficients are also returned by pyr.steer_coeffs steered_coeffs_ij = oig_coeffs_ij @ steering_weights)\n", + " ) # (the steering coefficients are also returned by pyr.steer_coeffs\n", + " # steered_coeffs_ij = oig_coeffs_ij @ steering_weights)\n", " M[0, 0, i] = steered_coeffs[(target_scale, 4)][\n", " 0, 0\n", " ] # we are always looking at the same band, but the steering angle changes\n", @@ -2240,7 +2246,8 @@ "pyr_coeffs_fixed, pyr_info = pyr_fixed.convert_pyr_to_tensor(\n", " pyr_fixed(im_batch), split_complex=False\n", ")\n", - "# we can also split the complex coefficients into real and imaginary parts as separate channels.\n", + "# we can also split the complex coefficients into real and imaginary parts as\n", + "# separate channels.\n", "pyr_coeffs_split, _ = pyr_fixed.convert_pyr_to_tensor(\n", " pyr_fixed(im_batch), split_complex=True\n", ")\n", @@ -2335,7 +2342,7 @@ ], "source": [ "po.pyrshow(pyr_coeffs_complex, zoom=0.5)\n", - "po.pyrshow(pyr_coeffs_fixed_1, zoom=0.5);" + "po.pyrshow(pyr_coeffs_fixed_1, zoom=0.5)" ] }, { @@ -2404,7 +2411,8 @@ " v2 = to_numpy(pyr_coeffs_not_downsample[k])\n", " v1 = v1.squeeze()\n", " v2 = v2.squeeze()\n", - " # check if energies match in each band between downsampled and fixed size pyramid responses\n", + " # check if energies match in each band between downsampled and fixed size pyramid\n", + " # responses\n", " print(\n", " np.allclose(\n", " np.sum(np.abs(v1) ** 2),\n", @@ -2568,7 +2576,8 @@ " downsample=False,\n", " )\n", "\n", - " # num_channels = num_scales * num_orientations (+ 2 residual bands) (* 2 if complex)\n", + " # num_channels = num_scales * num_orientations (+ 2 residual bands)\n", + " # (* 2 if complex)\n", " channels_per = 2 if self.is_complex else 1\n", " self.pyr_channels = ((self.order + 1) * self.scales + 2) * channels_per\n", "\n", @@ -2578,7 +2587,8 @@ " out_channels=self.output_dim,\n", " stride=2,\n", " )\n", - " # the input ndim here has to do with the dimensionality of self.conv's output, so will have to change\n", + " # the input ndim here has to do with the dimensionality of self.conv's output,\n", + " # so will have to change\n", " # if kernel_size or output_dim do\n", " self.fc = nn.Linear(self.output_dim * 12**2, 10)\n", "\n", From cca52209e7c045c836154a2d862d43a90cc8ea3b Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:01:26 -0400 Subject: [PATCH 093/134] replacing misleading characters l --- examples/05_Geodesics.ipynb | 22 ++++++++++++---------- examples/08_MAD_Competition.ipynb | 2 +- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index 189e83ef..c763c2e6 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -402,7 +402,7 @@ " title=None,\n", " col_wrap=3,\n", " zoom=4,\n", - ");" + ")" ] }, { @@ -737,15 +737,16 @@ ], "source": [ "# We have some optional example images that we'll download for this. In order to do so,\n", - "# we use an optional dependency, pooch. If the following raises an ImportError or ModuleNotFoundError for you,\n", + "# we use an optional dependency, pooch. If the following raises an ImportError or\n", + "# ModuleNotFoundError for you,\n", "# then install pooch in your plenoptic environment and restart your kernel.\n", "sample_image_dir = po.data.fetch_data(\"sample_images.tar.gz\")\n", "imgA = po.load_images(sample_image_dir / \"frontwindow_affine.jpeg\", as_gray=False)\n", "imgB = po.load_images(sample_image_dir / \"frontwindow.jpeg\", as_gray=False)\n", "u = 300\n", - "l = 90\n", - "imgA = imgA[..., u : u + 224, l : l + 224]\n", - "imgB = imgB[..., u : u + 224, l : l + 224]\n", + "v = 90\n", + "imgA = imgA[..., u : u + 224, v : v + 224]\n", + "imgB = imgB[..., u : u + 224, v : v + 224]\n", "po.imshow([imgA, imgB], as_rgb=True)\n", "diff = imgA - imgB\n", "po.imshow(diff)\n", @@ -799,10 +800,10 @@ " # then it's resnet18\n", " features = (\n", " [model.conv1, model.bn1, model.relu, model.maxpool]\n", - " + [l for l in model.layer1]\n", - " + [l for l in model.layer2]\n", - " + [l for l in model.layer3]\n", - " + [l for l in model.layer4]\n", + " + [v for v in model.layer1]\n", + " + [v for v in model.layer2]\n", + " + [v for v in model.layer3]\n", + " + [v for v in model.layer4]\n", " + [model.avgpool, model.fc]\n", " )\n", " self.features = nn.ModuleList(features).eval()\n", @@ -883,8 +884,9 @@ } ], "source": [ + "# ignore E501 (line too long)\n", "# noqa: E501\n", - "!curl https://gist.githubusercontent.com/yrevar/942d3a0ac09ec9e5eb3a/raw/238f720ff059c1f82f368259d1ca4ffa5dd8f9f5/imagenet1000_clsidx_to_labels.txt -o ../data/imagenet1000_clsidx_to_labels.txt" + "!curl https://gist.githubusercontent.com/yrevar/942d3a0ac09ec9e5eb3a/raw/238f720ff059c1f82f368259d1ca4ffa5dd8f9f5/imagenet1000_clsidx_to_labels.txt -o ../data/imagenet1000_clsidx_to_labels.txt " ] }, { diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index 0aeb04ef..b485ad5d 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -464,7 +464,7 @@ "source": [ "po.synth.mad_competition.plot_loss_all(\n", " mad, mad_mse_min, mad_ssim_max, mad_mse_max, \"SDSIM\"\n", - ");" + ")" ] } ], From aec45b7576252cbeeb2a764d3194e667b84c64bf Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:03:22 -0400 Subject: [PATCH 094/134] replacing ambigious l with layer --- examples/02_Eigendistortions.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 5ec65f8e..4cde592a 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -691,10 +691,10 @@ " # then it's resnet18\n", " features = (\n", " [model.conv1, model.bn1, model.relu, model.maxpool]\n", - " + [l for l in model.layer1]\n", - " + [l for l in model.layer2]\n", - " + [l for l in model.layer3]\n", - " + [l for l in model.layer4]\n", + " + [layer for layer in model.layer1]\n", + " + [layer for layer in model.layer2]\n", + " + [layer for layer in model.layer3]\n", + " + [layer for layer in model.layer4]\n", " + [model.avgpool, model.fc]\n", " )\n", " self.features = nn.ModuleList(features).eval()\n", @@ -1083,7 +1083,7 @@ ")\n", "po.synth.eigendistortion.display_eigendistortion(\n", " ed_resnetb, -1, as_rgb=True, zoom=2, title=\"bottom eigendist\"\n", - ");" + ")" ] }, { From f47db30154ebb950c8d041f4e5c9ef7bc7038de2 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:05:35 -0400 Subject: [PATCH 095/134] shortening lines --- examples/08_MAD_Competition.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index b485ad5d..d6b04fc5 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -220,8 +220,8 @@ " metric_tradeoff_lambda=1e6,\n", ")\n", "with warnings.catch_warnings():\n", - " # we suppress the warning telling us that our image falls outside of the (0, 1) range,\n", - " # which will happen briefly during synthesis.\n", + " # we suppress the warning telling us that our image falls outside of the\n", + " # (0, 1) range, which will happen briefly during synthesis.\n", " warnings.simplefilter(\"ignore\")\n", " mad_ssim_max.synthesize(max_iter=200)\n", "fig = po.synth.mad_competition.plot_synthesis_status(mad_ssim_max)" From 1d34294a35fc6ae6830850429d41793e33956a46 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:08:05 -0400 Subject: [PATCH 096/134] replacing ambigious variable names --- examples/05_Geodesics.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index c763c2e6..f14d4152 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -378,27 +378,27 @@ " zoom=4,\n", ")\n", "size = geodesic.shape[-1]\n", - "h, m, l = (size // 2 + size // 4, size // 2, size // 2 - size // 4)\n", + "high, mid, low = (size // 2 + size // 4, size // 2, size // 2 - size // 4) #\n", "\n", "# for a in fig.get_axes()[0]:\n", "a = fig.get_axes()[0]\n", - "for line in (h, m, l):\n", + "for line in (high, mid, low):\n", " a.axhline(line, lw=2)\n", "\n", "pt.imshow(\n", - " [video[:, l], pixelfade[:, l], geodesic[:, l]],\n", + " [video[:, low], pixelfade[:, low], geodesic[:, low]],\n", " title=None,\n", " col_wrap=3,\n", " zoom=4,\n", ")\n", "pt.imshow(\n", - " [video[:, m], pixelfade[:, m], geodesic[:, m]],\n", + " [video[:, mid], pixelfade[:, mid], geodesic[:, mid]],\n", " title=None,\n", " col_wrap=3,\n", " zoom=4,\n", ")\n", "pt.imshow(\n", - " [video[:, h], pixelfade[:, h], geodesic[:, h]],\n", + " [video[:, high], pixelfade[:, high], geodesic[:, high]],\n", " title=None,\n", " col_wrap=3,\n", " zoom=4,\n", From 380112f8c0c14cd1463d29c1057ba92ea057ef19 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:08:46 -0400 Subject: [PATCH 097/134] . --- examples/05_Geodesics.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index f14d4152..7ca755bb 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -858,7 +858,7 @@ "predB = po.to_numpy(models.vgg16(pretrained=True)(imgB))[0]\n", "\n", "plt.plot(predA)\n", - "plt.plot(predB);" + "plt.plot(predB)" ] }, { From eb561144e01b246927ec0793db4aab2892638c59 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:10:20 -0400 Subject: [PATCH 098/134] fixing too long lines --- examples/00_quickstart.ipynb | 6 ++++-- examples/04_Perceptual_distance.ipynb | 3 ++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index 1500e3bc..7f96cb2c 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -90,7 +90,8 @@ "\n", "# Simple rectified Gaussian convolutional model\n", "class SimpleModel(torch.nn.Module):\n", - " # in __init__, we create the object, initializing the convolutional weights and nonlinearity\n", + " # in __init__, we create the object, initializing the convolutional weights and\n", + " # nonlinearity\n", " def __init__(self, kernel_size=(7, 7)):\n", " super().__init__()\n", " self.kernel_size = kernel_size\n", @@ -99,7 +100,8 @@ " )\n", " self.conv.weight.data[0, 0] = circular_gaussian2d(kernel_size, 3.0)\n", "\n", - " # the forward pass of the model defines how to get from an image to the representation\n", + " # the forward pass of the model defines how to get from an image to the model's\n", + " # representation\n", " def forward(self, x):\n", " # use circular padding so our output is the same size as our input\n", " x = po.tools.conv.same_padding(x, self.kernel_size, pad_mode=\"circular\")\n", diff --git a/examples/04_Perceptual_distance.ipynb b/examples/04_Perceptual_distance.ipynb index 7bc8d04b..164cfe37 100644 --- a/examples/04_Perceptual_distance.ipynb +++ b/examples/04_Perceptual_distance.ipynb @@ -379,7 +379,8 @@ "val1 = po.metric.ssim(img_demo[[0]], img_demo[[1]])\n", "val2 = po.metric.ssim(\n", " img_demo[[0]] * 255, img_demo[[1]] * 255\n", - ") # This produces a wrong result and triggers a warning: Image range falls outside [0, 1].\n", + ") # This produces a wrong result and triggers a warning: Image range falls\n", + "# outside [0, 1].\n", "print(f\"True SSIM: {float(val1):.4f}, rescaled image SSIM: {float(val2):.4f}\")" ] }, From e6f10f2d21ab9b32565dc614a8f6332d4502f8af Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:22:06 -0400 Subject: [PATCH 099/134] ignoring too long lines in notebook 05 does not work for curl statement --- examples/05_Geodesics.ipynb | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index 7ca755bb..7a2a600f 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -50,7 +50,7 @@ "# if this fails, install torchvision in your plenoptic environment\n", "# and restart the notebook kernel.\n", "try:\n", - " import torchvision\n", + " import torchvision # noqa F401\n", "except ModuleNotFoundError:\n", " raise ModuleNotFoundError(\n", " \"optional dependency torchvision not found!\"\n", @@ -885,8 +885,7 @@ ], "source": [ "# ignore E501 (line too long)\n", - "# noqa: E501\n", - "!curl https://gist.githubusercontent.com/yrevar/942d3a0ac09ec9e5eb3a/raw/238f720ff059c1f82f368259d1ca4ffa5dd8f9f5/imagenet1000_clsidx_to_labels.txt -o ../data/imagenet1000_clsidx_to_labels.txt " + "!curl https://gist.githubusercontent.com/yrevar/942d3a0ac09ec9e5eb3a/raw/238f720ff059c1f82f368259d1ca4ffa5dd8f9f5/imagenet1000_clsidx_to_labels.txt -o ../data/imagenet1000_clsidx_to_labels.txt # noqa: E501" ] }, { From 4e62eae968757fe33eaef7028d0cc318f09bbb9d Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Fri, 27 Sep 2024 17:26:19 -0400 Subject: [PATCH 100/134] added isort linter and fixed 44 isort errors --- examples/00_quickstart.ipynb | 5 +++-- examples/02_Eigendistortions.ipynb | 3 ++- examples/03_Steerable_Pyramid.ipynb | 6 ++--- examples/04_Perceptual_distance.ipynb | 10 +++++---- examples/05_Geodesics.ipynb | 11 +++++----- examples/06_Metamer.ipynb | 5 +++-- examples/07_Simple_MAD.ipynb | 12 +++++----- examples/08_MAD_Competition.ipynb | 5 +++-- examples/Demo_Eigendistortion.ipynb | 5 +++-- examples/Display.ipynb | 4 ++-- examples/Metamer-Portilla-Simoncelli.ipynb | 3 ++- examples/Synthesis_extensions.ipynb | 10 +++++---- noxfile.py | 3 ++- pyproject.toml | 2 +- src/plenoptic/__init__.py | 10 +++------ src/plenoptic/data/__init__.py | 5 +++-- src/plenoptic/data/data_utils.py | 1 - src/plenoptic/metric/__init__.py | 4 ++-- src/plenoptic/metric/classes.py | 1 + src/plenoptic/metric/perceptual_distance.py | 6 ++--- src/plenoptic/simulate/__init__.py | 2 +- .../canonical_computations/__init__.py | 4 ++-- .../laplacian_pyramid.py | 1 + .../canonical_computations/non_linearities.py | 3 ++- .../steerable_pyramid_freq.py | 5 +++-- src/plenoptic/simulate/models/frontend.py | 7 +++--- src/plenoptic/simulate/models/naive.py | 3 ++- .../simulate/models/portilla_simoncelli.py | 6 ++--- src/plenoptic/synthesize/__init__.py | 2 +- src/plenoptic/synthesize/autodiff.py | 3 ++- src/plenoptic/synthesize/eigendistortion.py | 12 +++++----- src/plenoptic/synthesize/geodesic.py | 13 ++++++----- src/plenoptic/synthesize/mad_competition.py | 22 ++++++++++--------- src/plenoptic/synthesize/metamer.py | 21 +++++++++--------- src/plenoptic/synthesize/simple_metamer.py | 5 +++-- src/plenoptic/synthesize/synthesis.py | 1 + src/plenoptic/tools/__init__.py | 10 ++++----- src/plenoptic/tools/conv.py | 7 +++--- src/plenoptic/tools/convergence.py | 2 +- src/plenoptic/tools/data.py | 4 ++-- src/plenoptic/tools/display.py | 9 ++++---- src/plenoptic/tools/external.py | 1 + src/plenoptic/tools/optim.py | 2 +- src/plenoptic/tools/signal.py | 2 +- src/plenoptic/tools/straightness.py | 1 + src/plenoptic/tools/validate.py | 5 +++-- 46 files changed, 144 insertions(+), 120 deletions(-) diff --git a/examples/00_quickstart.ipynb b/examples/00_quickstart.ipynb index 7f96cb2c..0317c2d1 100644 --- a/examples/00_quickstart.ipynb +++ b/examples/00_quickstart.ipynb @@ -15,9 +15,10 @@ "metadata": {}, "outputs": [], "source": [ - "import plenoptic as po\n", - "import torch\n", "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "import plenoptic as po\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", diff --git a/examples/02_Eigendistortions.ipynb b/examples/02_Eigendistortions.ipynb index 4cde592a..eb104884 100644 --- a/examples/02_Eigendistortions.ipynb +++ b/examples/02_Eigendistortions.ipynb @@ -46,9 +46,10 @@ "source": [ "import matplotlib.pyplot as plt\n", "import torch\n", - "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", "from torch import nn\n", + "\n", "import plenoptic as po\n", + "from plenoptic.synthesize.eigendistortion import Eigendistortion\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", diff --git a/examples/03_Steerable_Pyramid.ipynb b/examples/03_Steerable_Pyramid.ipynb index 424bb6ac..435c9d40 100644 --- a/examples/03_Steerable_Pyramid.ipynb +++ b/examples/03_Steerable_Pyramid.ipynb @@ -19,17 +19,17 @@ "metadata": {}, "outputs": [], "source": [ + "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", - "import torchvision.transforms as transforms\n", "import torch.nn.functional as F\n", + "import torchvision.transforms as transforms\n", "from torch import nn\n", - "import matplotlib.pyplot as plt\n", + "from tqdm.auto import tqdm\n", "\n", "import plenoptic as po\n", "from plenoptic.simulate import SteerablePyramidFreq\n", "from plenoptic.tools.data import to_numpy\n", - "from tqdm.auto import tqdm\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment\n", diff --git a/examples/04_Perceptual_distance.ipynb b/examples/04_Perceptual_distance.ipynb index 164cfe37..2fc1f58f 100644 --- a/examples/04_Perceptual_distance.ipynb +++ b/examples/04_Perceptual_distance.ipynb @@ -28,13 +28,15 @@ "outputs": [], "source": [ "import os\n", + "\n", "import imageio\n", - "import plenoptic as po\n", - "import numpy as np\n", - "from scipy.stats import pearsonr, spearmanr\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "import torch\n", - "from PIL import Image" + "from PIL import Image\n", + "from scipy.stats import pearsonr, spearmanr\n", + "\n", + "import plenoptic as po" ] }, { diff --git a/examples/05_Geodesics.ipynb b/examples/05_Geodesics.ipynb index 7a2a600f..8c7d805b 100644 --- a/examples/05_Geodesics.ipynb +++ b/examples/05_Geodesics.ipynb @@ -36,15 +36,16 @@ } ], "source": [ - "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "import pyrtools as pt\n", - "import plenoptic as po\n", - "from plenoptic.tools import to_numpy\n", - "import torchvision.transforms as transforms\n", - "from torchvision import models\n", "import torch\n", "import torch.nn as nn\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "\n", + "import plenoptic as po\n", + "from plenoptic.tools import to_numpy\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment\n", diff --git a/examples/06_Metamer.ipynb b/examples/06_Metamer.ipynb index e972d2d9..c82a0d05 100644 --- a/examples/06_Metamer.ipynb +++ b/examples/06_Metamer.ipynb @@ -21,11 +21,12 @@ "metadata": {}, "outputs": [], "source": [ - "import plenoptic as po\n", "import imageio\n", - "import torch\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import torch\n", + "\n", + "import plenoptic as po\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", diff --git a/examples/07_Simple_MAD.ipynb b/examples/07_Simple_MAD.ipynb index 41187b46..367fe2d6 100644 --- a/examples/07_Simple_MAD.ipynb +++ b/examples/07_Simple_MAD.ipynb @@ -24,13 +24,15 @@ } ], "source": [ - "import plenoptic as po\n", - "from plenoptic.tools import to_numpy\n", - "import torch\n", - "import pyrtools as pt\n", + "import itertools\n", + "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import itertools\n", + "import pyrtools as pt\n", + "import torch\n", + "\n", + "import plenoptic as po\n", + "from plenoptic.tools import to_numpy\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", diff --git a/examples/08_MAD_Competition.ipynb b/examples/08_MAD_Competition.ipynb index d6b04fc5..470929cf 100644 --- a/examples/08_MAD_Competition.ipynb +++ b/examples/08_MAD_Competition.ipynb @@ -35,10 +35,11 @@ } ], "source": [ - "import plenoptic as po\n", - "import matplotlib.pyplot as plt\n", "import warnings\n", "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import plenoptic as po\n", "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", diff --git a/examples/Demo_Eigendistortion.ipynb b/examples/Demo_Eigendistortion.ipynb index a2aed610..84d48712 100644 --- a/examples/Demo_Eigendistortion.ipynb +++ b/examples/Demo_Eigendistortion.ipynb @@ -44,11 +44,12 @@ } ], "source": [ - "from plenoptic.synthesize import Eigendistortion\n", - "from plenoptic.simulate.models import OnOff\n", "import torch\n", "from torch import nn\n", + "\n", "import plenoptic as po\n", + "from plenoptic.simulate.models import OnOff\n", + "from plenoptic.synthesize import Eigendistortion\n", "\n", "# this notebook uses torchvision, which is an optional dependency.\n", "# if this fails, install torchvision in your plenoptic environment\n", diff --git a/examples/Display.ipynb b/examples/Display.ipynb index e22a0ad6..ae4512bc 100644 --- a/examples/Display.ipynb +++ b/examples/Display.ipynb @@ -18,11 +18,11 @@ "metadata": {}, "outputs": [], "source": [ - "import plenoptic as po\n", "import matplotlib.pyplot as plt\n", - "import torch\n", "import numpy as np\n", + "import torch\n", "\n", + "import plenoptic as po\n", "\n", "# so that relativfe sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index 989984ab..68f342ad 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -15,10 +15,11 @@ } ], "source": [ + "import einops\n", "import matplotlib.pyplot as plt\n", "import torch\n", + "\n", "import plenoptic as po\n", - "import einops\n", "\n", "%load_ext autoreload\n", "%autoreload \n", diff --git a/examples/Synthesis_extensions.ipynb b/examples/Synthesis_extensions.ipynb index c1bc9f1d..69341447 100644 --- a/examples/Synthesis_extensions.ipynb +++ b/examples/Synthesis_extensions.ipynb @@ -21,14 +21,16 @@ }, "outputs": [], "source": [ - "import plenoptic as po\n", - "from torch import Tensor\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", "import warnings\n", "from collections.abc import Callable\n", "from typing import Literal\n", "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from torch import Tensor\n", + "\n", + "import plenoptic as po\n", + "\n", "# so that relative sizes of axes created by po.imshow and others look right\n", "plt.rcParams[\"figure.dpi\"] = 72\n", "\n", diff --git a/noxfile.py b/noxfile.py index 9a4c5c63..ccf2d6bd 100644 --- a/noxfile.py +++ b/noxfile.py @@ -1,6 +1,7 @@ -import nox from pathlib import Path +import nox + @nox.session(name="lint") def lint(session): diff --git a/pyproject.toml b/pyproject.toml index 6fc3508c..501b3f88 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -137,7 +137,7 @@ select = [ # flake8-simplify "SIM", # isort - #"I", + "I", ] ignore = ["SIM105"] diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index dabb811e..e00e8ed7 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,12 +1,8 @@ # ignore F401 (unused import) # ruff: noqa: F401 +from . import data, metric, tools from . import simulate as simul from . import synthesize as synth -from . import metric -from . import tools -from . import data - -from .tools.display import imshow, animshow, pyrshow -from .tools.data import to_numpy, load_images - +from .tools.data import load_images, to_numpy +from .tools.display import animshow, imshow, pyrshow from .version import version as __version__ diff --git a/src/plenoptic/data/__init__.py b/src/plenoptic/data/__init__.py index 5931ef38..fd974a06 100644 --- a/src/plenoptic/data/__init__.py +++ b/src/plenoptic/data/__init__.py @@ -1,7 +1,8 @@ -from . import data_utils -from .fetch import fetch_data, DOWNLOADABLE_FILES import torch +from . import data_utils +from .fetch import DOWNLOADABLE_FILES, fetch_data + __all__ = [ "einstein", "curie", diff --git a/src/plenoptic/data/data_utils.py b/src/plenoptic/data/data_utils.py index d9988832..36e47086 100644 --- a/src/plenoptic/data/data_utils.py +++ b/src/plenoptic/data/data_utils.py @@ -1,7 +1,6 @@ from importlib import resources from importlib.abc import Traversable - from ..tools.data import load_images diff --git a/src/plenoptic/metric/__init__.py b/src/plenoptic/metric/__init__.py index 0ae9b9a2..72ccb671 100644 --- a/src/plenoptic/metric/__init__.py +++ b/src/plenoptic/metric/__init__.py @@ -1,7 +1,7 @@ # ignore F401 # ruff: noqa: F401 -from .perceptual_distance import ssim, ms_ssim, nlpd, ssim_map +from .classes import NLP from .model_metric import model_metric from .naive import mse -from .classes import NLP +from .perceptual_distance import ms_ssim, nlpd, ssim, ssim_map diff --git a/src/plenoptic/metric/classes.py b/src/plenoptic/metric/classes.py index d4fd1762..104ce79b 100644 --- a/src/plenoptic/metric/classes.py +++ b/src/plenoptic/metric/classes.py @@ -1,4 +1,5 @@ import torch + from .perceptual_distance import normalized_laplacian_pyramid diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index f8fbfb6f..8aa2a316 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -1,14 +1,14 @@ +import os +import warnings + import numpy as np import torch import torch.nn.functional as F -import warnings from ..simulate.canonical_computations import LaplacianPyramid from ..simulate.canonical_computations.filters import circular_gaussian2d from ..tools.conv import same_padding -import os - DIRNAME = os.path.dirname(__file__) diff --git a/src/plenoptic/simulate/__init__.py b/src/plenoptic/simulate/__init__.py index 7086770a..79b545da 100644 --- a/src/plenoptic/simulate/__init__.py +++ b/src/plenoptic/simulate/__init__.py @@ -1,5 +1,5 @@ # ignore F403 (from module import *) # ruff: noqa: F403 -from .models import * from .canonical_computations import * +from .models import * diff --git a/src/plenoptic/simulate/canonical_computations/__init__.py b/src/plenoptic/simulate/canonical_computations/__init__.py index 333f26b6..fe476b20 100644 --- a/src/plenoptic/simulate/canonical_computations/__init__.py +++ b/src/plenoptic/simulate/canonical_computations/__init__.py @@ -1,7 +1,7 @@ # ignore F401 (unused import) and F403 (from module import *) # ruff: noqa: F401, F403 +from .filters import * from .laplacian_pyramid import LaplacianPyramid -from .steerable_pyramid_freq import SteerablePyramidFreq from .non_linearities import * -from .filters import * +from .steerable_pyramid_freq import SteerablePyramidFreq diff --git a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py index bf2f690c..03e56f4a 100644 --- a/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py +++ b/src/plenoptic/simulate/canonical_computations/laplacian_pyramid.py @@ -1,5 +1,6 @@ import torch import torch.nn as nn + from ...tools.conv import blur_downsample, upsample_blur diff --git a/src/plenoptic/simulate/canonical_computations/non_linearities.py b/src/plenoptic/simulate/canonical_computations/non_linearities.py index aa626497..1662ca69 100644 --- a/src/plenoptic/simulate/canonical_computations/non_linearities.py +++ b/src/plenoptic/simulate/canonical_computations/non_linearities.py @@ -1,6 +1,7 @@ import torch + from ...tools.conv import blur_downsample, upsample_blur -from ...tools.signal import rectangular_to_polar, polar_to_rectangular +from ...tools.signal import polar_to_rectangular, rectangular_to_polar def rectangular_to_polar_dict(coeff_dict, residuals=False): diff --git a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py index 3389f38d..8110e085 100644 --- a/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py +++ b/src/plenoptic/simulate/canonical_computations/steerable_pyramid_freq.py @@ -6,15 +6,16 @@ import warnings from collections import OrderedDict +from typing import Literal + import numpy as np import torch import torch.fft as fft import torch.nn as nn from einops import rearrange +from numpy.typing import NDArray from scipy.special import factorial from torch import Tensor -from typing import Literal -from numpy.typing import NDArray from ...tools.signal import interpolate1d, raised_cosine, steer diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index 2dacf3fd..6c03d8cd 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -10,19 +10,18 @@ .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html """ +from collections import OrderedDict from collections.abc import Callable +from warnings import warn import torch import torch.nn as nn import torch.nn.functional as F from torch import Tensor -from .naive import Gaussian, CenterSurround from ...tools.display import imshow from ...tools.signal import make_disk -from collections import OrderedDict -from warnings import warn - +from .naive import CenterSurround, Gaussian __all__ = [ "LinearNonlinear", diff --git a/src/plenoptic/simulate/models/naive.py b/src/plenoptic/simulate/models/naive.py index a306f42f..531168c4 100644 --- a/src/plenoptic/simulate/models/naive.py +++ b/src/plenoptic/simulate/models/naive.py @@ -1,5 +1,6 @@ import torch -from torch import nn as nn, Tensor +from torch import Tensor +from torch import nn as nn from torch.nn import functional as F from ...tools.conv import same_padding diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index 994ce737..37678e4c 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -8,6 +8,7 @@ """ from collections import OrderedDict +from typing import Literal import einops import matplotlib as mpl @@ -17,17 +18,16 @@ import torch.fft import torch.nn as nn from torch import Tensor -from typing import Literal from ...tools import signal, stats from ...tools.data import to_numpy from ...tools.display import clean_stem_plot, clean_up_axes, update_stem from ...tools.validate import validate_input from ..canonical_computations.steerable_pyramid_freq import ( - SteerablePyramidFreq, + SCALES_TYPE as PYR_SCALES_TYPE, ) from ..canonical_computations.steerable_pyramid_freq import ( - SCALES_TYPE as PYR_SCALES_TYPE, + SteerablePyramidFreq, ) SCALES_TYPE = Literal["pixel_statistics"] | PYR_SCALES_TYPE diff --git a/src/plenoptic/synthesize/__init__.py b/src/plenoptic/synthesize/__init__.py index e3fb7899..da2d7369 100644 --- a/src/plenoptic/synthesize/__init__.py +++ b/src/plenoptic/synthesize/__init__.py @@ -1,7 +1,7 @@ # ignore F401 (unused import) # ruff: noqa: F401 from .eigendistortion import Eigendistortion -from .metamer import Metamer, MetamerCTF from .geodesic import Geodesic from .mad_competition import MADCompetition +from .metamer import Metamer, MetamerCTF from .simple_metamer import SimpleMetamer diff --git a/src/plenoptic/synthesize/autodiff.py b/src/plenoptic/synthesize/autodiff.py index 251137eb..86624675 100755 --- a/src/plenoptic/synthesize/autodiff.py +++ b/src/plenoptic/synthesize/autodiff.py @@ -1,6 +1,7 @@ +import warnings + import torch from torch import Tensor -import warnings def jacobian(y: Tensor, x: Tensor) -> Tensor: diff --git a/src/plenoptic/synthesize/eigendistortion.py b/src/plenoptic/synthesize/eigendistortion.py index a13b6782..9c9ad9a2 100755 --- a/src/plenoptic/synthesize/eigendistortion.py +++ b/src/plenoptic/synthesize/eigendistortion.py @@ -1,22 +1,22 @@ -from collections.abc import Callable import warnings +from collections.abc import Callable from typing import Literal import matplotlib.pyplot -from matplotlib.figure import Figure import numpy as np import torch +from matplotlib.figure import Figure from torch import Tensor from tqdm.auto import tqdm -from .synthesis import Synthesis +from ..tools.display import imshow +from ..tools.validate import validate_input, validate_model from .autodiff import ( jacobian, - vector_jacobian_product, jacobian_vector_product, + vector_jacobian_product, ) -from ..tools.display import imshow -from ..tools.validate import validate_input, validate_model +from .synthesis import Synthesis def fisher_info_matrix_vector_product( diff --git a/src/plenoptic/synthesize/geodesic.py b/src/plenoptic/synthesize/geodesic.py index b94af4b6..ff22b725 100644 --- a/src/plenoptic/synthesize/geodesic.py +++ b/src/plenoptic/synthesize/geodesic.py @@ -1,23 +1,24 @@ -from collections import OrderedDict import warnings -import matplotlib.pyplot as plt +from collections import OrderedDict +from typing import Literal + import matplotlib as mpl +import matplotlib.pyplot as plt import torch import torch.autograd as autograd from torch import Tensor from tqdm.auto import tqdm -from typing import Literal -from .synthesis import OptimizedSynthesis +from ..tools.convergence import pixel_change_convergence from ..tools.data import to_numpy from ..tools.optim import penalize_range -from ..tools.validate import validate_input, validate_model -from ..tools.convergence import pixel_change_convergence from ..tools.straightness import ( deviation_from_line, make_straight_line, sample_brownian_bridge, ) +from ..tools.validate import validate_input, validate_model +from .synthesis import OptimizedSynthesis class Geodesic(OptimizedSynthesis): diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 0fa62f05..ed3bc411 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -1,21 +1,23 @@ """Run MAD Competition.""" -import torch -import numpy as np -from torch import Tensor -from tqdm.auto import tqdm -from ..tools import optim, display, data +import contextlib +import warnings +from collections import OrderedDict from collections.abc import Callable from typing import Literal -from .synthesis import OptimizedSynthesis -import warnings + import matplotlib as mpl import matplotlib.pyplot as plt -from collections import OrderedDict +import numpy as np +import torch from pyrtools.tools.display import make_figure as pt_make_figure -from ..tools.validate import validate_input, validate_metric +from torch import Tensor +from tqdm.auto import tqdm + +from ..tools import data, display, optim from ..tools.convergence import loss_convergence -import contextlib +from ..tools.validate import validate_input, validate_metric +from .synthesis import OptimizedSynthesis class MADCompetition(OptimizedSynthesis): diff --git a/src/plenoptic/synthesize/metamer.py b/src/plenoptic/synthesize/metamer.py index 39924e7a..d8ae6906 100644 --- a/src/plenoptic/synthesize/metamer.py +++ b/src/plenoptic/synthesize/metamer.py @@ -1,25 +1,26 @@ """Synthesize model metamers.""" -import torch import re +import warnings +from collections import OrderedDict +from collections.abc import Callable +from typing import Literal + +import matplotlib as mpl +import matplotlib.pyplot as plt import numpy as np +import torch from torch import Tensor from tqdm.auto import tqdm -from ..tools import optim, display, signal, data +from ..tools import data, display, optim, signal +from ..tools.convergence import coarse_to_fine_enough, loss_convergence from ..tools.validate import ( + validate_coarse_to_fine, validate_input, validate_model, - validate_coarse_to_fine, ) -from ..tools.convergence import coarse_to_fine_enough, loss_convergence -from collections.abc import Callable -from typing import Literal from .synthesis import OptimizedSynthesis -import warnings -import matplotlib as mpl -import matplotlib.pyplot as plt -from collections import OrderedDict class Metamer(OptimizedSynthesis): diff --git a/src/plenoptic/synthesize/simple_metamer.py b/src/plenoptic/synthesize/simple_metamer.py index be040d89..950afac0 100644 --- a/src/plenoptic/synthesize/simple_metamer.py +++ b/src/plenoptic/synthesize/simple_metamer.py @@ -2,9 +2,10 @@ import torch from tqdm.auto import tqdm -from .synthesis import Synthesis -from ..tools.validate import validate_input, validate_model + from ..tools import optim +from ..tools.validate import validate_input, validate_model +from .synthesis import Synthesis class SimpleMetamer(Synthesis): diff --git a/src/plenoptic/synthesize/synthesis.py b/src/plenoptic/synthesize/synthesis.py index d9c2988a..bbb47641 100644 --- a/src/plenoptic/synthesize/synthesis.py +++ b/src/plenoptic/synthesize/synthesis.py @@ -2,6 +2,7 @@ import abc import warnings + import torch diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index f2b10336..cba3efc6 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,12 +1,10 @@ # ignore F401 (unused import) and F403 (from module import *) # ruff: noqa: F401, F403 +from . import validate +from .display import * +from .external import * +from .optim import * from .signal import * from .stats import * -from .display import * from .straightness import * - -from .optim import * -from .external import * from .validate import remove_grad - -from . import validate diff --git a/src/plenoptic/tools/conv.py b/src/plenoptic/tools/conv.py index 05095aef..6003a2d4 100644 --- a/src/plenoptic/tools/conv.py +++ b/src/plenoptic/tools/conv.py @@ -1,9 +1,10 @@ +import math + import numpy as np +import pyrtools as pt import torch -from torch import Tensor import torch.nn.functional as F -import pyrtools as pt -import math +from torch import Tensor def correlate_downsample(image, filt, padding_mode="reflect"): diff --git a/src/plenoptic/tools/convergence.py b/src/plenoptic/tools/convergence.py index c72d36de..3048ca88 100644 --- a/src/plenoptic/tools/convergence.py +++ b/src/plenoptic/tools/convergence.py @@ -23,8 +23,8 @@ from typing import TYPE_CHECKING if TYPE_CHECKING: - from ..synthesize.synthesis import OptimizedSynthesis from ..synthesize.metamer import Metamer + from ..synthesize.synthesis import OptimizedSynthesis # ignoring E501 to keep the diagram below readable diff --git a/src/plenoptic/tools/data.py b/src/plenoptic/tools/data.py index eea932bc..b727e6a1 100644 --- a/src/plenoptic/tools/data.py +++ b/src/plenoptic/tools/data.py @@ -1,12 +1,12 @@ +import os.path as op import pathlib import warnings import imageio import numpy as np -import os.path as op +import torch from pyrtools import synthetic_images from skimage import color -import torch from torch import Tensor from .signal import rescale diff --git a/src/plenoptic/tools/display.py b/src/plenoptic/tools/display.py index 71c7587f..bd0f684f 100644 --- a/src/plenoptic/tools/display.py +++ b/src/plenoptic/tools/display.py @@ -1,13 +1,14 @@ """various helpful utilities for plotting or displaying information""" +import importlib.util import warnings -import torch + +import matplotlib.pyplot as plt import numpy as np import pyrtools as pt -import matplotlib.pyplot as plt -from .data import to_numpy -import importlib.util +import torch +from .data import to_numpy # Check if IPython.display.HTML is available if importlib.util.find_spec("IPython.display"): diff --git a/src/plenoptic/tools/external.py b/src/plenoptic/tools/external.py index 860a3987..af3834b1 100644 --- a/src/plenoptic/tools/external.py +++ b/src/plenoptic/tools/external.py @@ -11,6 +11,7 @@ import numpy as np import pyrtools as pt import scipy.io as sio + from ..data import fetch_data diff --git a/src/plenoptic/tools/optim.py b/src/plenoptic/tools/optim.py index 19ea5359..cc911244 100644 --- a/src/plenoptic/tools/optim.py +++ b/src/plenoptic/tools/optim.py @@ -1,8 +1,8 @@ """Tools related to optimization such as more objective functions.""" +import numpy as np import torch from torch import Tensor -import numpy as np def set_seed(seed: int | None = None) -> None: diff --git a/src/plenoptic/tools/signal.py b/src/plenoptic/tools/signal.py index 33657b92..af0f0389 100644 --- a/src/plenoptic/tools/signal.py +++ b/src/plenoptic/tools/signal.py @@ -1,7 +1,7 @@ import numpy as np import torch -from torch import Tensor from pyrtools.pyramids.steer import steer_to_harmonics_mtx +from torch import Tensor def minimum(x: Tensor, dim: list[int] | None = None, keepdim: bool = False) -> Tensor: diff --git a/src/plenoptic/tools/straightness.py b/src/plenoptic/tools/straightness.py index 02bf8dee..e397fb7c 100644 --- a/src/plenoptic/tools/straightness.py +++ b/src/plenoptic/tools/straightness.py @@ -1,5 +1,6 @@ import torch from torch import Tensor + from .validate import validate_input diff --git a/src/plenoptic/tools/validate.py b/src/plenoptic/tools/validate.py index b8c5d265..e16d70d5 100644 --- a/src/plenoptic/tools/validate.py +++ b/src/plenoptic/tools/validate.py @@ -1,9 +1,10 @@ """Functions to validate synthesis inputs.""" -import torch -import warnings import itertools +import warnings from collections.abc import Callable + +import torch from torch import Tensor From 1bc6ed1530a367fd1c7f949af1755199573498b6 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 12:13:34 -0400 Subject: [PATCH 101/134] reformatting --- pyproject.toml | 2 +- src/plenoptic/simulate/models/portilla_simoncelli.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 501b3f88..18823c0a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -133,7 +133,7 @@ select = [ # pyupgrade "UP", # flake8-bugbear - #"B", + # "B", # flake8-simplify "SIM", # isort diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index 37678e4c..4e4a0df3 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -238,9 +238,9 @@ def _create_scales_shape_dict(self) -> OrderedDict: dtype=int, ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") - shape_dict["cross_orientation_correlation_magnitude"] = ( - cross_orientation_corr_mag - ) + shape_dict[ + "cross_orientation_correlation_magnitude" + ] = cross_orientation_corr_mag mags_std = np.ones((self.n_orientations, self.n_scales), dtype=int) mags_std *= einops.rearrange(scales, "s -> 1 s") From a4e2f57c3f469b53a9c19355a72cb2b539f014c4 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 13:30:55 -0400 Subject: [PATCH 102/134] tests run again and circular import error resolved --- src/plenoptic/__init__.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index e00e8ed7..13907a79 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,8 +1,12 @@ # ignore F401 (unused import) # ruff: noqa: F401 -from . import data, metric, tools +# ruff: noqa: I001 (isort) import order matters to avoid circular dependencies and tests to fail + from . import simulate as simul from . import synthesize as synth + +# needs to be imported after simulate and synthesize and before tools: +from . import data, metric, tools from .tools.data import load_images, to_numpy from .tools.display import animshow, imshow, pyrshow from .version import version as __version__ From 244948dc5b48149b554d51b9100b592f54ec830a Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 14:38:25 -0400 Subject: [PATCH 103/134] adding missing import data to init file --- src/plenoptic/tools/__init__.py | 3 ++- tests/test_tools.py | 1 - 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index cba3efc6..ba387875 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,6 +1,7 @@ -# ignore F401 (unused import) and F403 (from module import *) +# ignore F401 (unused import) and F403 (import * is bad practice) # ruff: noqa: F401, F403 from . import validate +from .data import * from .display import * from .external import * from .optim import * diff --git a/tests/test_tools.py b/tests/test_tools.py index 29c26c56..f85c243a 100644 --- a/tests/test_tools.py +++ b/tests/test_tools.py @@ -2,7 +2,6 @@ import numpy as np import scipy.ndimage import plenoptic as po -import os.path as op import pytest import einops import torch From 9d572e7564650b037a0e5ac536b50b09a38277ee Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 14:41:54 -0400 Subject: [PATCH 104/134] fixing linting error --- src/plenoptic/synthesize/mad_competition.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/plenoptic/synthesize/mad_competition.py b/src/plenoptic/synthesize/mad_competition.py index 00bdf5b1..cb3c47ab 100644 --- a/src/plenoptic/synthesize/mad_competition.py +++ b/src/plenoptic/synthesize/mad_competition.py @@ -1341,10 +1341,7 @@ def display_mad_image_all( ] # we're only plotting one image here, so if the user wants multiple # channels, they must be RGB - if ( - kwargs.get("channel_idx", None) is None - and mad_metric1_min.initial_image.shape[1] > 1 - ): + if kwargs.get("channel_idx") is None and mad_metric1_min.initial_image.shape[1] > 1: as_rgb = True else: as_rgb = False From 3c1b3db82477c0f35ff857235dfa0ef57532d880 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 14:52:46 -0400 Subject: [PATCH 105/134] ruff version updated to 0.6.8, same as on cluster --- .pre-commit-config.yaml | 2 +- pyproject.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index cfab6f21..786232ed 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,6 @@ repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.1.4 + rev: v0.6.8 hooks: # Run the formatter. - id: ruff-format diff --git a/pyproject.toml b/pyproject.toml index 8ae75b20..37e4225a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -58,7 +58,7 @@ dev = [ 'pytest-xdist', "pooch>=1.2.0", "nox", - "ruff>=0.5.1", + "ruff>=0.6.8", ] nb = [ From 9975ef0b655381e3109de8d31a5aca47c767883e Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 14:55:56 -0400 Subject: [PATCH 106/134] adding missing import conv to init in tools --- src/plenoptic/tools/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index ba387875..12a4c457 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,6 +1,7 @@ # ignore F401 (unused import) and F403 (import * is bad practice) # ruff: noqa: F401, F403 from . import validate +from .conv import * from .data import * from .display import * from .external import * From a159b1d79bef73535ce0cf6bea10174cb636cd61 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 15:02:25 -0400 Subject: [PATCH 107/134] formatting fix --- src/plenoptic/simulate/models/portilla_simoncelli.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/plenoptic/simulate/models/portilla_simoncelli.py b/src/plenoptic/simulate/models/portilla_simoncelli.py index 14565228..cef04614 100644 --- a/src/plenoptic/simulate/models/portilla_simoncelli.py +++ b/src/plenoptic/simulate/models/portilla_simoncelli.py @@ -238,9 +238,9 @@ def _create_scales_shape_dict(self) -> OrderedDict: dtype=int, ) cross_orientation_corr_mag *= einops.rearrange(scales, "s -> 1 1 s") - shape_dict[ - "cross_orientation_correlation_magnitude" - ] = cross_orientation_corr_mag + shape_dict["cross_orientation_correlation_magnitude"] = ( + cross_orientation_corr_mag + ) mags_std = np.ones((self.n_orientations, self.n_scales), dtype=int) mags_std *= einops.rearrange(scales, "s -> 1 s") From 5c9e28d5ea968a191dcafa3a527acdc283caefac Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Sat, 28 Sep 2024 15:31:14 -0400 Subject: [PATCH 108/134] editing string to mitigate notebook error for versions 3.10 and 3.11 --- examples/Metamer-Portilla-Simoncelli.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/examples/Metamer-Portilla-Simoncelli.ipynb b/examples/Metamer-Portilla-Simoncelli.ipynb index d0c21696..924c5255 100644 --- a/examples/Metamer-Portilla-Simoncelli.ipynb +++ b/examples/Metamer-Portilla-Simoncelli.ipynb @@ -2122,8 +2122,8 @@ "coeff_magnitude_variances = torch.sum(~torch.isnan(stats_dict[\"magnitude_std\"]))\n", "\n", "print(\n", - " f\"Coefficient magnitude statistics: {coeff_magnitude_stats_num + \n", - " coeff_magnitude_variances} \"\n", + " \"Coefficient magnitude statistics: \"\n", + " f\"{coeff_magnitude_stats_num + coeff_magnitude_variances} \"\n", " \"parameters, compared to 472 in paper\"\n", ")\n", "\n", @@ -2359,7 +2359,7 @@ "kernelspec": { "display_name": "plenoptic", "language": "python", - "name": "plenoptic" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -2371,7 +2371,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.10.10" } }, "nbformat": 4, From 605034466ad2934ad02982a192fff9b154da2c01 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 1 Oct 2024 13:37:54 -0400 Subject: [PATCH 109/134] updated 3 cns links from http to https --- src/plenoptic/simulate/models/frontend.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/plenoptic/simulate/models/frontend.py b/src/plenoptic/simulate/models/frontend.py index d3b79325..8b71f89d 100644 --- a/src/plenoptic/simulate/models/frontend.py +++ b/src/plenoptic/simulate/models/frontend.py @@ -71,7 +71,7 @@ class LinearNonlinear(nn.Module): ---------- .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of hierarchical representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 - .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html + .. [2] https://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html .. [3] A Berardino, Hierarchically normalized models of visual distortion sensitivity: Physiology, perception, and application; Ph.D. Thesis, 2018; https://www.cns.nyu.edu/pub/lcv/berardino-phd.pdf @@ -190,7 +190,7 @@ class LuminanceGainControl(nn.Module): ---------- .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of hierarchical representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 - .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html + .. [2] https://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html .. [3] A Berardino, Hierarchically normalized models of visual distortion sensitivity: Physiology, perception, and application; Ph.D. Thesis, 2018; https://www.cns.nyu.edu/pub/lcv/berardino-phd.pdf @@ -342,7 +342,7 @@ class LuminanceContrastGainControl(nn.Module): ---------- .. [1] A Berardino, J Ballé, V Laparra, EP Simoncelli, Eigen-distortions of hierarchical representations, NeurIPS 2017; https://arxiv.org/abs/1710.02266 - .. [2] http://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html + .. [2] https://www.cns.nyu.edu/~lcv/eigendistortions/ModelsIQA.html .. [3] A Berardino, Hierarchically normalized models of visual distortion sensitivity: Physiology, perception, and application; Ph.D. Thesis, 2018; https://www.cns.nyu.edu/pub/lcv/berardino-phd.pdf From fb2f5a04a8c52f9e558c66416eaac95623f5f3e2 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 1 Oct 2024 13:40:58 -0400 Subject: [PATCH 110/134] imports sorted in init --- src/plenoptic/__init__.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index 13907a79..1f1df123 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,12 +1,9 @@ # ignore F401 (unused import) # ruff: noqa: F401 -# ruff: noqa: I001 (isort) import order matters to avoid circular dependencies and tests to fail +from . import data, metric, tools from . import simulate as simul from . import synthesize as synth - -# needs to be imported after simulate and synthesize and before tools: -from . import data, metric, tools from .tools.data import load_images, to_numpy from .tools.display import animshow, imshow, pyrshow from .version import version as __version__ From 3951c7940ff86b13f6a16f609ab0ffa5ef51327d Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 1 Oct 2024 13:53:59 -0400 Subject: [PATCH 111/134] isort ignored in init file, otherwise errors due to circulr inputs --- src/plenoptic/__init__.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index 1f1df123..13907a79 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,9 +1,12 @@ # ignore F401 (unused import) # ruff: noqa: F401 +# ruff: noqa: I001 (isort) import order matters to avoid circular dependencies and tests to fail -from . import data, metric, tools from . import simulate as simul from . import synthesize as synth + +# needs to be imported after simulate and synthesize and before tools: +from . import data, metric, tools from .tools.data import load_images, to_numpy from .tools.display import animshow, imshow, pyrshow from .version import version as __version__ From c2912b0ac18d952d0e6a5884b590792c6a8444df Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 1 Oct 2024 14:18:09 -0400 Subject: [PATCH 112/134] unused imports uncommented --- src/plenoptic/__init__.py | 19 +++++++++---------- src/plenoptic/metric/__init__.py | 11 ++++------- .../canonical_computations/__init__.py | 9 +++++---- src/plenoptic/simulate/models/__init__.py | 6 +++--- src/plenoptic/synthesize/__init__.py | 12 +++++------- src/plenoptic/tools/__init__.py | 8 ++++---- 6 files changed, 30 insertions(+), 35 deletions(-) diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index 13907a79..43d20d18 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,12 +1,11 @@ -# ignore F401 (unused import) -# ruff: noqa: F401 -# ruff: noqa: I001 (isort) import order matters to avoid circular dependencies and tests to fail +# # ruff: noqa: I001 (isort) import order matters to avoid circular dependencies and +# tests to fail -from . import simulate as simul -from . import synthesize as synth +# from . import simulate as simul +# from . import synthesize as synth -# needs to be imported after simulate and synthesize and before tools: -from . import data, metric, tools -from .tools.data import load_images, to_numpy -from .tools.display import animshow, imshow, pyrshow -from .version import version as __version__ +# # needs to be imported after simulate and synthesize and before tools: +# from . import data, metric, tools +# from .tools.data import load_images, to_numpy +# from .tools.display import animshow, imshow, pyrshow +# from .version import version as __version__ diff --git a/src/plenoptic/metric/__init__.py b/src/plenoptic/metric/__init__.py index 72ccb671..e322cf27 100644 --- a/src/plenoptic/metric/__init__.py +++ b/src/plenoptic/metric/__init__.py @@ -1,7 +1,4 @@ -# ignore F401 -# ruff: noqa: F401 - -from .classes import NLP -from .model_metric import model_metric -from .naive import mse -from .perceptual_distance import ms_ssim, nlpd, ssim, ssim_map +# from .classes import NLP +# from .model_metric import model_metric +# from .naive import mse +# from .perceptual_distance import ms_ssim, nlpd, ssim, ssim_map diff --git a/src/plenoptic/simulate/canonical_computations/__init__.py b/src/plenoptic/simulate/canonical_computations/__init__.py index fe476b20..9e09b683 100644 --- a/src/plenoptic/simulate/canonical_computations/__init__.py +++ b/src/plenoptic/simulate/canonical_computations/__init__.py @@ -1,7 +1,8 @@ -# ignore F401 (unused import) and F403 (from module import *) -# ruff: noqa: F401, F403 +# ignore F403 (from module import *) +# ruff: noqa: F403 from .filters import * -from .laplacian_pyramid import LaplacianPyramid + +# from .laplacian_pyramid import LaplacianPyramid from .non_linearities import * -from .steerable_pyramid_freq import SteerablePyramidFreq +# from .steerable_pyramid_freq import SteerablePyramidFreq diff --git a/src/plenoptic/simulate/models/__init__.py b/src/plenoptic/simulate/models/__init__.py index 64837f31..e9f446ff 100644 --- a/src/plenoptic/simulate/models/__init__.py +++ b/src/plenoptic/simulate/models/__init__.py @@ -1,5 +1,5 @@ -# ignore F401 (unused import) and F403 (from module import *) -# ruff: noqa: F401, F403 +# ignore F403 (from module import *) +# ruff: noqa: F403 from .frontend import * from .naive import * -from .portilla_simoncelli import PortillaSimoncelli +# from .portilla_simoncelli import PortillaSimoncelli diff --git a/src/plenoptic/synthesize/__init__.py b/src/plenoptic/synthesize/__init__.py index da2d7369..27d72769 100644 --- a/src/plenoptic/synthesize/__init__.py +++ b/src/plenoptic/synthesize/__init__.py @@ -1,7 +1,5 @@ -# ignore F401 (unused import) -# ruff: noqa: F401 -from .eigendistortion import Eigendistortion -from .geodesic import Geodesic -from .mad_competition import MADCompetition -from .metamer import Metamer, MetamerCTF -from .simple_metamer import SimpleMetamer +# from .eigendistortion import Eigendistortion +# from .geodesic import Geodesic +# from .mad_competition import MADCompetition +# from .metamer import Metamerruff chec, MetamerCTF +# from .simple_metamer import SimpleMetamer diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index 12a4c457..81b18ee7 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,6 +1,6 @@ -# ignore F401 (unused import) and F403 (import * is bad practice) -# ruff: noqa: F401, F403 -from . import validate +# ignore F403 (import * is bad practice) +# ruff: noqa: F403 +# from . import validate from .conv import * from .data import * from .display import * @@ -9,4 +9,4 @@ from .signal import * from .stats import * from .straightness import * -from .validate import remove_grad +# from .validate import remove_grad From e13a7ade580b76576e4709787d0007c2a7819304 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 1 Oct 2024 14:24:26 -0400 Subject: [PATCH 113/134] when unused imports are removed, tests fail, so included them again --- src/plenoptic/__init__.py | 19 ++++++++++--------- src/plenoptic/metric/__init__.py | 11 +++++++---- .../canonical_computations/__init__.py | 9 ++++----- src/plenoptic/simulate/models/__init__.py | 6 +++--- src/plenoptic/synthesize/__init__.py | 12 +++++++----- src/plenoptic/tools/__init__.py | 8 ++++---- 6 files changed, 35 insertions(+), 30 deletions(-) diff --git a/src/plenoptic/__init__.py b/src/plenoptic/__init__.py index 43d20d18..13907a79 100644 --- a/src/plenoptic/__init__.py +++ b/src/plenoptic/__init__.py @@ -1,11 +1,12 @@ -# # ruff: noqa: I001 (isort) import order matters to avoid circular dependencies and -# tests to fail +# ignore F401 (unused import) +# ruff: noqa: F401 +# ruff: noqa: I001 (isort) import order matters to avoid circular dependencies and tests to fail -# from . import simulate as simul -# from . import synthesize as synth +from . import simulate as simul +from . import synthesize as synth -# # needs to be imported after simulate and synthesize and before tools: -# from . import data, metric, tools -# from .tools.data import load_images, to_numpy -# from .tools.display import animshow, imshow, pyrshow -# from .version import version as __version__ +# needs to be imported after simulate and synthesize and before tools: +from . import data, metric, tools +from .tools.data import load_images, to_numpy +from .tools.display import animshow, imshow, pyrshow +from .version import version as __version__ diff --git a/src/plenoptic/metric/__init__.py b/src/plenoptic/metric/__init__.py index e322cf27..72ccb671 100644 --- a/src/plenoptic/metric/__init__.py +++ b/src/plenoptic/metric/__init__.py @@ -1,4 +1,7 @@ -# from .classes import NLP -# from .model_metric import model_metric -# from .naive import mse -# from .perceptual_distance import ms_ssim, nlpd, ssim, ssim_map +# ignore F401 +# ruff: noqa: F401 + +from .classes import NLP +from .model_metric import model_metric +from .naive import mse +from .perceptual_distance import ms_ssim, nlpd, ssim, ssim_map diff --git a/src/plenoptic/simulate/canonical_computations/__init__.py b/src/plenoptic/simulate/canonical_computations/__init__.py index 9e09b683..fe476b20 100644 --- a/src/plenoptic/simulate/canonical_computations/__init__.py +++ b/src/plenoptic/simulate/canonical_computations/__init__.py @@ -1,8 +1,7 @@ -# ignore F403 (from module import *) -# ruff: noqa: F403 +# ignore F401 (unused import) and F403 (from module import *) +# ruff: noqa: F401, F403 from .filters import * - -# from .laplacian_pyramid import LaplacianPyramid +from .laplacian_pyramid import LaplacianPyramid from .non_linearities import * -# from .steerable_pyramid_freq import SteerablePyramidFreq +from .steerable_pyramid_freq import SteerablePyramidFreq diff --git a/src/plenoptic/simulate/models/__init__.py b/src/plenoptic/simulate/models/__init__.py index e9f446ff..64837f31 100644 --- a/src/plenoptic/simulate/models/__init__.py +++ b/src/plenoptic/simulate/models/__init__.py @@ -1,5 +1,5 @@ -# ignore F403 (from module import *) -# ruff: noqa: F403 +# ignore F401 (unused import) and F403 (from module import *) +# ruff: noqa: F401, F403 from .frontend import * from .naive import * -# from .portilla_simoncelli import PortillaSimoncelli +from .portilla_simoncelli import PortillaSimoncelli diff --git a/src/plenoptic/synthesize/__init__.py b/src/plenoptic/synthesize/__init__.py index 27d72769..da2d7369 100644 --- a/src/plenoptic/synthesize/__init__.py +++ b/src/plenoptic/synthesize/__init__.py @@ -1,5 +1,7 @@ -# from .eigendistortion import Eigendistortion -# from .geodesic import Geodesic -# from .mad_competition import MADCompetition -# from .metamer import Metamerruff chec, MetamerCTF -# from .simple_metamer import SimpleMetamer +# ignore F401 (unused import) +# ruff: noqa: F401 +from .eigendistortion import Eigendistortion +from .geodesic import Geodesic +from .mad_competition import MADCompetition +from .metamer import Metamer, MetamerCTF +from .simple_metamer import SimpleMetamer diff --git a/src/plenoptic/tools/__init__.py b/src/plenoptic/tools/__init__.py index 81b18ee7..12a4c457 100644 --- a/src/plenoptic/tools/__init__.py +++ b/src/plenoptic/tools/__init__.py @@ -1,6 +1,6 @@ -# ignore F403 (import * is bad practice) -# ruff: noqa: F403 -# from . import validate +# ignore F401 (unused import) and F403 (import * is bad practice) +# ruff: noqa: F401, F403 +from . import validate from .conv import * from .data import * from .display import * @@ -9,4 +9,4 @@ from .signal import * from .stats import * from .straightness import * -# from .validate import remove_grad +from .validate import remove_grad From 54ebe8536e18cb9be12570a242c819920e4f953d Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 1 Oct 2024 16:35:51 -0400 Subject: [PATCH 114/134] reformatting tests and updating contributing file --- CONTRIBUTING.md | 58 +++++++++- pyproject.toml | 18 ++- tests/conftest.py | 25 ++--- tests/test_data_get.py | 8 +- tests/test_display.py | 140 +++++++----------------- tests/test_eigendistortion.py | 34 ++---- tests/test_geodesic.py | 85 ++++----------- tests/test_mad.py | 73 +++++-------- tests/test_metamers.py | 59 ++++------ tests/test_metric.py | 59 ++++------ tests/test_models.py | 200 ++++++++++++++-------------------- tests/test_steerable_pyr.py | 78 +++++-------- tests/test_tools.py | 155 ++++++++++---------------- tests/utils.py | 42 ++++--- 14 files changed, 412 insertions(+), 622 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 8916d3ca..a5197b7e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -126,7 +126,54 @@ At this point, we will be notified of the pull request and will read it over. We If your changes are integrated, you will be added as a Github contributor and as one of the authors of the package. Thank you for being part of `plenoptic`! -### Style guide +### Code Quality and Linting +We use [Ruff](https://docs.astral.sh/ruff/) for linting and formatting our Python code to maintain a consistent code style and catch potential errors early. To ensure your contributions meet these standards, please follow the guidelines below: + +#### Using Ruff + +Ruff is a fast and comprehensive Python formatter and linter that checks for common style and code quality issues. It combines multiple tools, like Pyflakes, pycodestyle, isort, and other linting rules into one efficient tool, which are specified in `pyproject.toml`. Before submitting your code, make sure to run Ruff to catch any issues. + +**Using Ruff for [Formatting](https://docs.astral.sh/ruff/formatter/#philosophy):** + +`ruff format` is the primary entrypoint to the formatter. It accepts a list of files or directories, and formats all discovered Python files: +```bash +ruff format # Format all files in the current directory. +ruff format path/to/code/ # Format all files in `path/to/code` (and any subdirectories). +ruff format path/to/file.py # Format a single file. +``` +For the full list of supported options, run `ruff format --help`. + +**Using Ruff for [Linting](https://docs.astral.sh/ruff/linter/):** + +To run Ruff on your code: +```bash +ruff check . +``` +It'll then tell you which lines are violating linting rules and may suggest that some errors are automatically fixable. + +To automatically fix lintint errors, run: + +```bash +ruff --fix . +``` + +Be careful with **unsafe fixes**, safe fixes are symbolized with the tools emoji and are listed [here](https://docs.astral.sh/ruff/rules/)! + +#### Ignoring Ruff Linting +You may want to suppress lint errors, for example when too long lines (code `E501`) are desired because otherwise the url might not be readable anymore. +You can do this by adding the following to the end of the line: + +```bash +# noqa: E501 +``` +If you want to suppress an error across an entire file, do this: +```bash +# ruff: noqa: E501 +``` + +For more details, refer to the [documentation](https://docs.astral.sh/ruff/linter/#error-suppression). + +#### Style guide - Longer, descriptive names are preferred (e.g., `x` is not an appropriate name for a variable), especially for anything user-facing, such as methods, @@ -135,6 +182,7 @@ If your changes are integrated, you will be added as a Github contributor and as (see [below](#docstrings) for details). Hidden ones do not *need* to have complete docstrings, but they probably should. + ### Adding models or synthesis methods In addition to the above, see the documentation for a description of @@ -220,12 +268,18 @@ If you want to run just the tests, add the following option, nox -s tests ``` -and for running only the linters, +for running only the linters, ```bash nox -s linters ``` +and for testing only the coverage, run: + +```bash +nox -s coverage +``` + `nox` offers a variety of configuration options, you can learn more about it from their [documentation](https://nox.thea.codes/en/stable/config.html). diff --git a/pyproject.toml b/pyproject.toml index 37e4225a..df62ab5b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -122,9 +122,25 @@ exclude = [ "docs", ] -# Set the maximum line length. +# Set the maximum line length (same as Black) line-length = 88 +indent-width = 4 # same as Black + +[tool.ruff.format] +# Like Black, use double quotes for strings. +quote-style = "double" + +# Like Black, indent with spaces, rather than tabs. +indent-style = "space" + +# Like Black, respect magic trailing commas. +skip-magic-trailing-comma = false + +# Like Black, automatically detect the appropriate line ending. +line-ending = "auto" + + [tool.ruff.lint] select = [ # pycodestyle diff --git a/tests/conftest.py b/tests/conftest.py index a2dac8d1..4e9e2fdd 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -3,7 +3,7 @@ import torch DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") -IMG_DIR = po.data.fetch_data('test_images.tar.gz') +IMG_DIR = po.data.fetch_data("test_images.tar.gz") torch.set_num_threads(1) # torch uses all avail threads which will slow tests torch.manual_seed(0) @@ -44,9 +44,7 @@ def einstein_img_small(einstein_img): @pytest.fixture(scope="package") def color_img(): - img = po.load_images( - IMG_DIR / "256" / "color_wheel.jpg", as_gray=False - ).to(DEVICE) + img = po.load_images(IMG_DIR / "256" / "color_wheel.jpg", as_gray=False).to(DEVICE) return img[..., :256, :256] @@ -67,8 +65,8 @@ def __init__(self, *args, **kwargs): def forward(self, *args, **kwargs): coeffs = super().forward(*args, **kwargs) - pyr_tensor, _ = ( - po.simul.SteerablePyramidFreq.convert_pyr_to_tensor(coeffs) + pyr_tensor, _ = po.simul.SteerablePyramidFreq.convert_pyr_to_tensor( + coeffs ) return pyr_tensor @@ -121,13 +119,9 @@ def forward(self, *args, **kwargs): elif name == "frontend.LuminanceContrastGainControl": return po.simul.LuminanceContrastGainControl((31, 31)).to(DEVICE) elif name == "frontend.OnOff": - return po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to( - DEVICE - ) + return po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to(DEVICE) elif name == "frontend.OnOff.nograd": - mdl = po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to( - DEVICE - ) + mdl = po.simul.OnOff((31, 31), pretrained=True, cache_filt=True).to(DEVICE) po.tools.remove_grad(mdl) return mdl elif name == "VideoModel": @@ -142,19 +136,20 @@ def forward(self, *args, **kwargs): rep = super().forward(*args, **kwargs) return rep.mean(0) - model = VideoModel((31, 31), pretrained=True, cache_filt=True).to( - DEVICE - ) + model = VideoModel((31, 31), pretrained=True, cache_filt=True).to(DEVICE) po.tools.remove_grad(model) return model elif name == "PortillaSimoncelli": return po.simul.PortillaSimoncelli((256, 256)) elif name == "NonModule": + class NonModule: def __init__(self): self.name = "nonmodule" + def __call__(self, x): return 1 * x + return NonModule() diff --git a/tests/test_data_get.py b/tests/test_data_get.py index 2575e54b..e8d130b2 100644 --- a/tests/test_data_get.py +++ b/tests/test_data_get.py @@ -4,8 +4,10 @@ import plenoptic as po -@pytest.mark.parametrize("item_name", [img for img in dir(po.data) - if img not in ['fetch_data', 'DOWNLOADABLE_FILES']]) +@pytest.mark.parametrize( + "item_name", + [img for img in dir(po.data) if img not in ["fetch_data", "DOWNLOADABLE_FILES"]], +) def test_data_module(item_name): """Test that data module works.""" assert isinstance(eval(f"po.data.{item_name}()"), Tensor) @@ -19,7 +21,7 @@ def test_data_module(item_name): ("curie", (1, 1, 256, 256)), ("einstein", (1, 1, 256, 256)), ("reptile_skin", (1, 1, 256, 256)), - ] + ], ) def test_data_get_shape(item_name, img_shape): """Check if the shape of the retrieved image matches the expected dimensions.""" diff --git a/tests/test_display.py b/tests/test_display.py index d438283e..e35c2548 100644 --- a/tests/test_display.py +++ b/tests/test_display.py @@ -15,7 +15,6 @@ class TestDisplay(object): - def test_update_plot_line(self): x = np.linspace(0, 100) y1 = np.random.rand(*x.shape) @@ -37,10 +36,7 @@ def test_update_plot_line_multi_axes(self, how): if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, *y1.shape) elif how == "dict": - y2 = { - i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) - for i in range(2) - } + y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) for i in range(2)} fig, axes = plt.subplots(1, 2) for ax in axes: ax.plot(x, y1, "-o", label="hi") @@ -68,10 +64,7 @@ def test_update_plot_line_multi_channel(self, how): if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, len(x)) elif how == "dict-multi": - y2 = { - i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) - for i in range(2) - } + y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) for i in range(2)} elif how == "dict-single": y2 = {0: torch.as_tensor(y2[0]).reshape(1, 1, len(x))} fig, ax = plt.subplots(1, 1) @@ -112,10 +105,7 @@ def test_update_plot_stem_multi_axes(self, how): if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, *y1.shape) elif how == "dict": - y2 = { - i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) - for i in range(2) - } + y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, *y1.shape) for i in range(2)} fig, axes = plt.subplots(1, 2) for ax in axes: ax.stem(x, y1, label="hi") @@ -143,19 +133,14 @@ def test_update_plot_stem_multi_channel(self, how): if how == "tensor": y2 = torch.as_tensor(y2).reshape(1, 2, len(x)) elif how == "dict-multi": - y2 = { - i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) - for i in range(2) - } + y2 = {i: torch.as_tensor(y2[i]).reshape(1, 1, len(x)) for i in range(2)} elif how == "dict-single": y2 = {0: torch.as_tensor(y2[0]).reshape(1, 1, len(x))} fig, ax = plt.subplots(1, 1) for i in range(2): ax.stem(x, y1[i], label=str(i)) po.tools.update_plot(ax, y2) - assert ( - len(ax.containers) == 2 - ), "Incorrect number of stems were plotted!" + assert len(ax.containers) == 2, "Incorrect number of stems were plotted!" for i in range(2): ax_y = ax.containers[i].markerline.get_ydata() if how == "tensor": @@ -188,8 +173,7 @@ def test_update_plot_image_multi_axes(self, how): y2 = torch.as_tensor(y2) elif how == "dict": y2 = { - i: torch.as_tensor(y2[0, i]).reshape(1, 1, 100, 100) - for i in range(2) + i: torch.as_tensor(y2[0, i]).reshape(1, 1, 100, 100) for i in range(2) } fig = pt.imshow([y for y in y1.squeeze()]) po.tools.update_plot(fig.axes, y2) @@ -211,16 +195,14 @@ def test_update_plot_scatter(self): y2 = np.random.rand(*x2.shape) fig, ax = plt.subplots(1, 1) ax.scatter(x1, y1) - data = torch.stack( - (torch.as_tensor(x2), torch.as_tensor(y2)), -1 - ).reshape(1, 1, len(x2), 2) + data = torch.stack((torch.as_tensor(x2), torch.as_tensor(y2)), -1).reshape( + 1, 1, len(x2), 2 + ) po.tools.update_plot(ax, data) assert len(ax.collections) == 1, "Too many scatter plots created" ax_data = ax.collections[0].get_offsets() if not np.allclose(ax_data, data): - raise Exception( - "Didn't update points of the scatter plot correctly!" - ) + raise Exception("Didn't update points of the scatter plot correctly!") plt.close("all") @pytest.mark.parametrize("how", ["dict", "tensor"]) @@ -230,9 +212,9 @@ def test_update_plot_scatter_multi_axes(self, how): y1 = np.random.rand(*x1.shape) y2 = np.random.rand(2, *y1.shape) if how == "tensor": - data = torch.stack( - (torch.as_tensor(x2), torch.as_tensor(y2)), -1 - ).reshape(1, 2, len(x1), 2) + data = torch.stack((torch.as_tensor(x2), torch.as_tensor(y2)), -1).reshape( + 1, 2, len(x1), 2 + ) elif how == "dict": data = { i: torch.stack( @@ -252,9 +234,7 @@ def test_update_plot_scatter_multi_axes(self, how): else: data_check = data[i] if not np.allclose(ax_data, data_check): - raise Exception( - "Didn't update points of the scatter plot correctly!" - ) + raise Exception("Didn't update points of the scatter plot correctly!") plt.close("all") @pytest.mark.parametrize("how", ["dict-single", "dict-multi", "tensor"]) @@ -268,9 +248,9 @@ def test_update_plot_scatter_multi_channel(self, how): y1 = np.random.rand(*x1.shape) y2 = np.random.rand(*x2.shape) if how == "tensor": - data = torch.stack( - (torch.as_tensor(x2), torch.as_tensor(y2)), -1 - ).reshape(1, 2, x1.shape[-1], 2) + data = torch.stack((torch.as_tensor(x2), torch.as_tensor(y2)), -1).reshape( + 1, 2, x1.shape[-1], 2 + ) elif how == "dict-multi": data = { i: torch.stack( @@ -288,9 +268,7 @@ def test_update_plot_scatter_multi_channel(self, how): for i in range(2): ax.scatter(x1[i], y1[i], label=i) po.tools.update_plot(ax, data) - assert ( - len(ax.collections) == 2 - ), "Incorrect number of scatter plots created" + assert len(ax.collections) == 2, "Incorrect number of scatter plots created" for i in range(2): ax_data = ax.collections[i].get_offsets() if how == "tensor": @@ -298,14 +276,10 @@ def test_update_plot_scatter_multi_channel(self, how): elif how == "dict-multi": data_check = data[i] elif how == "dict-single": - tmp = torch.stack( - (torch.as_tensor(x1), torch.as_tensor(y1)), -1 - ) + tmp = torch.stack((torch.as_tensor(x1), torch.as_tensor(y1)), -1) data_check = {0: data[0], 1: tmp[1]}[i] if not np.allclose(ax_data, data_check): - raise Exception( - "Didn't update points of the scatter plot correctly!" - ) + raise Exception("Didn't update points of the scatter plot correctly!") def test_update_plot_mixed_multi_axes(self): x1 = np.linspace(0, 1, 100) @@ -327,36 +301,26 @@ def test_update_plot_mixed_multi_axes(self): po.tools.update_plot(axes, data) for i, ax in enumerate(axes): if i == 0: - assert ( - len(ax.collections) == 1 - ), "Too many scatter plots created" + assert len(ax.collections) == 1, "Too many scatter plots created" assert len(ax.lines) == 0, "Too many lines created" ax_data = ax.collections[0].get_offsets() else: - assert ( - len(ax.collections) == 0 - ), "Too many scatter plots created" + assert len(ax.collections) == 0, "Too many scatter plots created" assert len(ax.lines) == 1, "Too many lines created" _, ax_data = ax.lines[0].get_data() if not np.allclose(ax_data, data[i]): - raise Exception( - "Didn't update points of the scatter plot correctly!" - ) + raise Exception("Didn't update points of the scatter plot correctly!") plt.close("all") @pytest.mark.parametrize("as_rgb", [True, False]) @pytest.mark.parametrize("channel_idx", [None, 0, [0, 1]]) @pytest.mark.parametrize("batch_idx", [None, 0, [0, 1]]) - @pytest.mark.parametrize( - "is_complex", [False, "logpolar", "rectangular", "polar"] - ) + @pytest.mark.parametrize("is_complex", [False, "logpolar", "rectangular", "polar"]) @pytest.mark.parametrize("mini_im", [True, False]) # test the edge cases where we try to plot a tensor that's (b, c, 1, w) or # (b, c, h, 1) @pytest.mark.parametrize("one_dim", [False, "h", "w"]) - def test_imshow( - self, as_rgb, channel_idx, batch_idx, is_complex, mini_im, one_dim - ): + def test_imshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_im, one_dim): fails = False if one_dim == "h": im_shape = [2, 4, 1, 5] @@ -447,9 +411,7 @@ def steerpyr(self, request): @pytest.mark.parametrize("channel_idx", [None, 0, [0, 1]]) @pytest.mark.parametrize("batch_idx", [None, 0, [0, 1]]) @pytest.mark.parametrize("show_residuals", [True, False]) - def test_pyrshow( - self, steerpyr, channel_idx, batch_idx, show_residuals, curie_img - ): + def test_pyrshow(self, steerpyr, channel_idx, batch_idx, show_residuals, curie_img): fails = False if not isinstance(channel_idx, int) or not isinstance(batch_idx, int): fails = True @@ -459,9 +421,7 @@ def test_pyrshow( if show_residuals: n_axes += 2 img = curie_img.clone() - img = img[ - ..., : steerpyr.lo0mask.shape[-2], : steerpyr.lo0mask.shape[-1] - ] + img = img[..., : steerpyr.lo0mask.shape[-2], : steerpyr.lo0mask.shape[-1]] coeffs = steerpyr(img) if not fails: # unfortunately, can't figure out how to properly parametrize this @@ -484,9 +444,7 @@ def test_pyrshow( plt.close("all") else: with pytest.raises(TypeError): - po.pyrshow( - coeffs, batch_idx=batch_idx, channel_idx=channel_idx - ) + po.pyrshow(coeffs, batch_idx=batch_idx, channel_idx=channel_idx) def test_display_test_signals(self): po.imshow(po.tools.make_synthetic_stimuli(128)) @@ -495,13 +453,9 @@ def test_display_test_signals(self): @pytest.mark.parametrize("as_rgb", [True, False]) @pytest.mark.parametrize("channel_idx", [None, 0, [0, 1]]) @pytest.mark.parametrize("batch_idx", [None, 0, [0, 1]]) - @pytest.mark.parametrize( - "is_complex", [False, "logpolar", "rectangular", "polar"] - ) + @pytest.mark.parametrize("is_complex", [False, "logpolar", "rectangular", "polar"]) @pytest.mark.parametrize("mini_vid", [True, False]) - def test_animshow( - self, as_rgb, channel_idx, batch_idx, is_complex, mini_vid - ): + def test_animshow(self, as_rgb, channel_idx, batch_idx, is_complex, mini_vid): fails = False if is_complex: # this is 2 (the two complex components) * 4 (the four channels) * @@ -667,9 +621,7 @@ def template_test_synthesis_all_plot( plt.close("all") -def template_test_synthesis_custom_fig( - synthesis_object, func, fig_creation, tmp_path -): +def template_test_synthesis_custom_fig(synthesis_object, func, fig_creation, tmp_path): # template function to test whether we can create our own figure and pass # it to the plotting and animating functions, specifying some or all of the # locations for the plots. Any synthesis object that has had synthesis() @@ -716,14 +668,11 @@ def template_test_synthesis_custom_fig( class TestMADDisplay(object): - @pytest.fixture(scope="class", params=["rgb", "grayscale"]) def synthesized_mad(self, request): # make the images really small so nothing takes as long if request.param == "rgb": - img = po.load_images( - IMG_DIR / "256" / "color_wheel.jpg", False - ).to(DEVICE) + img = po.load_images(IMG_DIR / "256" / "color_wheel.jpg", False).to(DEVICE) img = img[..., :16, :16] else: img = po.load_images(IMG_DIR / "256" / "nuts.pgm").to(DEVICE) @@ -820,15 +769,9 @@ def test_helper_funcs(self, all_mad, func): @pytest.mark.parametrize("func", ["plot", "animate"]) # plot_representation_error is an allowed value for metamer, but not MAD. # the second is just a typo - @pytest.mark.parametrize( - "val", ["plot_representation_error", "plot_mad_image"] - ) - @pytest.mark.parametrize( - "variable", ["included_plots", "width_ratios", "axes_idx"] - ) - def test_allowed_plots_exception( - self, synthesized_mad, func, val, variable - ): + @pytest.mark.parametrize("val", ["plot_representation_error", "plot_mad_image"]) + @pytest.mark.parametrize("variable", ["included_plots", "width_ratios", "axes_idx"]) + def test_allowed_plots_exception(self, synthesized_mad, func, val, variable): if func == "plot": func = po.synth.mad_competition.plot_synthesis_status elif func == "animate": @@ -845,15 +788,12 @@ def test_allowed_plots_exception( class TestMetamerDisplay(object): - @pytest.fixture(scope="class", params=["rgb", "grayscale"]) def synthesized_met(self, request): img = request.param # make the images really small so nothing takes as long if img == "rgb": - img = po.load_images( - IMG_DIR / "256" / "color_wheel.jpg", False - ).to(DEVICE) + img = po.load_images(IMG_DIR / "256" / "color_wheel.jpg", False).to(DEVICE) img = img[..., :16, :16] else: img = po.load_images(IMG_DIR / "256" / "nuts.pgm").to(DEVICE) @@ -932,12 +872,8 @@ def test_custom_fig(self, synthesized_met, func, fig_creation, tmp_path): # display_mad_image is an allowed value for MAD but not metamer. # the second is just a typo @pytest.mark.parametrize("val", ["display_mad_image", "plot_metamer"]) - @pytest.mark.parametrize( - "variable", ["included_plots", "width_ratios", "axes_idx"] - ) - def test_allowed_plots_exception( - self, synthesized_met, func, val, variable - ): + @pytest.mark.parametrize("variable", ["included_plots", "width_ratios", "axes_idx"]) + def test_allowed_plots_exception(self, synthesized_met, func, val, variable): if func == "plot": func = po.synth.metamer.plot_synthesis_status elif func == "animate": diff --git a/tests/test_eigendistortion.py b/tests/test_eigendistortion.py index 7d6e9a7f..99d6f749 100644 --- a/tests/test_eigendistortion.py +++ b/tests/test_eigendistortion.py @@ -19,7 +19,6 @@ class TestEigendistortionSynthesis: - @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_method_assertion(self, einstein_img, model): einstein_img = einstein_img[..., :SMALL_DIM, :SMALL_DIM] @@ -105,7 +104,7 @@ def test_method_randomized_svd(self, model, einstein_img): assert ed.eigenindex.allclose(torch.arange(k)) assert len(ed.eigenvalues) == k - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_method_accuracy(self, model, einstein_img): # test pow and svd against ground-truth jacobian (exact) method einstein_img = einstein_img[..., 125 : 125 + 25, 125 : 125 + 25] @@ -154,9 +153,7 @@ def test_display(self, model, einstein_img, color_img, method, k): if method == "power": display_eigendistortion(eigendist, eigenindex=-1) display_eigendistortion(eigendist, eigenindex=-2) - elif ( - method == "randomized_svd" - ): # svd only has top k not bottom k eigendists + elif method == "randomized_svd": # svd only has top k not bottom k eigendists with pytest.raises(AssertionError): display_eigendistortion(eigendist, eigenindex=-1) plt.close("all") @@ -184,9 +181,7 @@ def test_save_load(self, einstein_img, model, fail, method, tmp_path): remove_grad(model) expectation = pytest.raises( RuntimeError, - match=( - "Attribute representation_flat have different shapes" - ), + match=("Attribute representation_flat have different shapes"), ) ed_copy = Eigendistortion(img, model) with expectation: @@ -209,12 +204,12 @@ def test_save_load(self, einstein_img, model, fail, method, tmp_path): # check that can resume ed_copy.synthesize(max_iter=4, method=method) - @pytest.mark.parametrize('model', ['Identity', 'NonModule'], indirect=True) - @pytest.mark.parametrize('to_type', ['dtype', 'device']) + @pytest.mark.parametrize("model", ["Identity", "NonModule"], indirect=True) + @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, curie_img, model, to_type): ed = Eigendistortion(curie_img, model) - ed.synthesize(max_iter=5, method='power') - if to_type == 'dtype': + ed.synthesize(max_iter=5, method="power") + if to_type == "dtype": # can't use the power method on a float16 tensor, so we use float64 instead # here. ed.to(torch.float64) @@ -224,11 +219,9 @@ def test_to(self, curie_img, model, to_type): elif to_type == "device" and DEVICE.type != "cpu": ed.to("cpu") ed.eigendistortions - ed.image - ed.synthesize(max_iter=5, method='power') + ed.synthesize(max_iter=5, method="power") - @pytest.mark.skipif( - DEVICE.type == "cpu", reason="Only makes sense to test on cuda" - ) + @pytest.mark.skipif(DEVICE.type == "cpu", reason="Only makes sense to test on cuda") @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_map_location(self, curie_img, model, tmp_path): curie_img = curie_img.to(DEVICE) @@ -239,9 +232,7 @@ def test_map_location(self, curie_img, model, tmp_path): # calling load with map_location effectively switches everything # over to that device ed_copy = Eigendistortion(curie_img, model) - ed_copy.load( - op.join(tmp_path, "test_eig_map_location.pt"), map_location="cpu" - ) + ed_copy.load(op.join(tmp_path, "test_eig_map_location.pt"), map_location="cpu") assert ed_copy.eigendistortions.device.type == "cpu" assert ed_copy.image.device.type == "cpu" ed_copy.synthesize(max_iter=4, method="power") @@ -262,7 +253,6 @@ def test_change_precision_save_load(self, einstein_img, model, tmp_path): class TestAutodiffFunctions: - @pytest.fixture(scope="class") def state(self, einstein_img): """variables to be reused across tests in this class""" @@ -313,9 +303,7 @@ def test_jac_vec_prod(self, state): def test_fisher_vec_prod(self, state): x, y, x_dim, y_dim, k = state - V, _ = torch.linalg.qr( - torch.ones((x_dim, k), device=DEVICE), "reduced" - ) + V, _ = torch.linalg.qr(torch.ones((x_dim, k), device=DEVICE), "reduced") U = V.clone() Jv = autodiff.jacobian_vector_product(y, x, V) Fv = autodiff.vector_jacobian_product(y, x, Jv) diff --git a/tests/test_geodesic.py b/tests/test_geodesic.py index 8ef5a6cc..77d1b47a 100644 --- a/tests/test_geodesic.py +++ b/tests/test_geodesic.py @@ -8,7 +8,6 @@ class TestSequences(object): - def test_deviation_from_line_and_brownian_bridge(self): """this probabilistic test passes with high probability in high dimensions, but for reproducibility we @@ -53,9 +52,7 @@ def test_brownian_bridge( *einstein_img.shape[1:], ), "sample_brownian_bridge returned a tensor of the wrong shape!" - @pytest.mark.parametrize( - "fail", ["batch", "same_shape", "n_steps", "max_norm"] - ) + @pytest.mark.parametrize("fail", ["batch", "same_shape", "n_steps", "max_norm"]) def test_brownian_bridge_fail(self, einstein_img, curie_img, fail): n_steps = 2 max_norm = 1 @@ -73,24 +70,18 @@ def test_brownian_bridge_fail(self, einstein_img, curie_img, fail): ) elif fail == "n_steps": n_steps = 0 - expectation = pytest.raises( - ValueError, match="n_steps must be positive" - ) + expectation = pytest.raises(ValueError, match="n_steps must be positive") elif fail == "max_norm": max_norm = -1 expectation = pytest.raises( ValueError, match="max_norm must be non-negative" ) with expectation: - po.tools.sample_brownian_bridge( - einstein_img, curie_img, n_steps, max_norm - ) + po.tools.sample_brownian_bridge(einstein_img, curie_img, n_steps, max_norm) @pytest.mark.parametrize("n_steps", [1, 10]) @pytest.mark.parametrize("multichannel", [False, True]) - def test_straight_line( - self, einstein_img, curie_img, n_steps, multichannel - ): + def test_straight_line(self, einstein_img, curie_img, n_steps, multichannel): if multichannel: einstein_img = einstein_img.repeat(1, 3, 1, 1) curie_img = curie_img.repeat(1, 3, 1, 1) @@ -117,9 +108,7 @@ def test_straight_line_fail(self, einstein_img, curie_img, fail): ) elif fail == "n_steps": n_steps = 0 - expectation = pytest.raises( - ValueError, match="n_steps must be positive" - ) + expectation = pytest.raises(ValueError, match="n_steps must be positive") with expectation: po.tools.make_straight_line(einstein_img, curie_img, n_steps) @@ -127,9 +116,7 @@ def test_straight_line_fail(self, einstein_img, curie_img, fail): @pytest.mark.parametrize("multichannel", [False, True]) def test_translation_sequence(self, einstein_img, n_steps, multichannel): if n_steps == 0: - expectation = pytest.raises( - ValueError, match="n_steps must be positive" - ) + expectation = pytest.raises(ValueError, match="n_steps must be positive") else: expectation = does_not_raise() if multichannel: @@ -165,25 +152,18 @@ def test_preserve_device(self, einstein_img, func): class TestGeodesic(object): - @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) @pytest.mark.parametrize("init", ["straight", "bridge"]) @pytest.mark.parametrize("optimizer", [None, "SGD"]) @pytest.mark.parametrize("n_steps", [5, 10]) - def test_texture( - self, einstein_img_small, model, init, optimizer, n_steps - ): + def test_texture(self, einstein_img_small, model, init, optimizer, n_steps): sequence = po.tools.translation_sequence(einstein_img_small, n_steps) - moog = po.synth.Geodesic( - sequence[:1], sequence[-1:], model, n_steps, init - ) + moog = po.synth.Geodesic(sequence[:1], sequence[-1:], model, n_steps, init) if optimizer == "SGD": optimizer = torch.optim.SGD([moog._geodesic], lr=0.01) moog.synthesize(max_iter=5, optimizer=optimizer) po.synth.geodesic.plot_loss(moog) - po.synth.geodesic.plot_deviation_from_line( - moog, natural_video=sequence - ) + po.synth.geodesic.plot_deviation_from_line(moog, natural_video=sequence) moog.calculate_jerkiness() @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) @@ -257,17 +237,14 @@ def test_save_load(self, einstein_small_seq, model, fail, tmp_path): init = "bridge" expectation = pytest.raises( ValueError, - match=( - "Saved and initialized initial_sequence are different" - ), + match=("Saved and initialized initial_sequence are different"), ) elif fail == "range_penalty": range_penalty = 0.5 expectation = pytest.raises( ValueError, match=( - "Saved and initialized range_penalty_lambda are" - " different" + "Saved and initialized range_penalty_lambda are" " different" ), ) moog_copy = po.synth.Geodesic( @@ -297,9 +274,7 @@ def test_save_load(self, einstein_small_seq, model, fail, tmp_path): map_location=DEVICE, ) for k in ["image_a", "image_b", "pixelfade", "geodesic"]: - if not getattr(moog, k).allclose( - getattr(moog_copy, k), rtol=1e-2 - ): + if not getattr(moog, k).allclose(getattr(moog_copy, k), rtol=1e-2): raise ValueError( "Something went wrong with saving and loading!" f" {k} not the same" @@ -307,14 +282,10 @@ def test_save_load(self, einstein_small_seq, model, fail, tmp_path): # check that can resume moog_copy.synthesize(max_iter=4) - @pytest.mark.skipif( - DEVICE.type == "cpu", reason="Only makes sense to test on cuda" - ) + @pytest.mark.skipif(DEVICE.type == "cpu", reason="Only makes sense to test on cuda") @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_map_location(self, einstein_small_seq, model, tmp_path): - moog = po.synth.Geodesic( - einstein_small_seq[:1], einstein_small_seq[-1:], model - ) + moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], model) moog.synthesize(max_iter=4, store_progress=True) moog.save(op.join(tmp_path, "test_geodesic_map_location.pt")) # calling load with map_location effectively switches everything @@ -333,9 +304,7 @@ def test_map_location(self, einstein_small_seq, model, tmp_path): @pytest.mark.parametrize("model", ["Identity"], indirect=True) @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, einstein_small_seq, model, to_type): - moog = po.synth.Geodesic( - einstein_small_seq[:1], einstein_small_seq[-1:], model - ) + moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], model) moog.synthesize(max_iter=5) if to_type == "dtype": moog.to(torch.float16) @@ -347,14 +316,10 @@ def test_to(self, einstein_small_seq, model, to_type): moog.geodesic - moog.image_a @pytest.mark.parametrize("model", ["Identity"], indirect=True) - def test_change_precision_save_load( - self, einstein_small_seq, model, tmp_path - ): + def test_change_precision_save_load(self, einstein_small_seq, model, tmp_path): # Identity model doesn't change when you call .to() with a dtype # (unlike those models that have weights) so we use it here - moog = po.synth.Geodesic( - einstein_small_seq[:1], einstein_small_seq[-1:], model - ) + moog = po.synth.Geodesic(einstein_small_seq[:1], einstein_small_seq[-1:], model) moog.synthesize(max_iter=5) moog.to(torch.float64) assert moog.geodesic.dtype == torch.float64, "dtype incorrect!" @@ -367,9 +332,7 @@ def test_change_precision_save_load( # this determines whether we mix across channels or treat them separately, # both of which are supported - @pytest.mark.parametrize( - "model", ["ColorModel", "Identity"], indirect=True - ) + @pytest.mark.parametrize("model", ["ColorModel", "Identity"], indirect=True) def test_multichannel(self, color_img, model): img = color_img[..., :64, :64] seq = po.tools.translation_sequence(img, 5) @@ -381,9 +344,7 @@ def test_multichannel(self, color_img, model): ) @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) - @pytest.mark.parametrize( - "func", ["objective_function", "calculate_jerkiness"] - ) + @pytest.mark.parametrize("func", ["objective_function", "calculate_jerkiness"]) def test_funcs_external_tensor(self, einstein_small_seq, model, func): moog = po.synth.Geodesic( einstein_small_seq[:1], einstein_small_seq[-1:], model, 5 @@ -414,9 +375,7 @@ def test_nan_loss(self, model, einstein_small_seq): moog = po.synth.Geodesic(seq[:1], seq[-1:], model, 5) moog.synthesize(max_iter=5) moog.image_a[..., 0, 0] = torch.nan - with pytest.raises( - ValueError, match="Found a NaN in loss during optimization" - ): + with pytest.raises(ValueError, match="Found a NaN in loss during optimization"): moog.synthesize(max_iter=1) @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) @@ -457,9 +416,7 @@ def test_stop_criterion(self, einstein_small_seq, model): moog = po.synth.Geodesic( einstein_small_seq[:1], einstein_small_seq[-1:], model, 5 ) - moog.synthesize( - max_iter=10, stop_criterion=0.06, stop_iters_to_check=1 - ) + moog.synthesize(max_iter=10, stop_criterion=0.06, stop_iters_to_check=1) assert ( abs(moog.pixel_change_norm[-1:]) < 0.06 ).all(), "Didn't stop when hit criterion!" diff --git a/tests/test_mad.py b/tests/test_mad.py index 32eb346f..7bd0361a 100644 --- a/tests/test_mad.py +++ b/tests/test_mad.py @@ -33,19 +33,20 @@ class ModuleMetric(torch.nn.Module): def __init__(self): super().__init__() self.mdl = po.metric.NLP() + def forward(self, x, y): return (self.mdl(x) - self.mdl(y)).abs().mean() class NonModuleMetric: def __init__(self): - self.name = 'nonmodule' + self.name = "nonmodule" + def __call__(self, x, y): - return (x-y).abs().sum() + return (x - y).abs().sum() class TestMAD(object): - @pytest.mark.parametrize("target", ["min", "max"]) @pytest.mark.parametrize("model_order", ["mse-ssim", "ssim-mse"]) @pytest.mark.parametrize("store_progress", [False, True, 2]) @@ -94,18 +95,14 @@ def test_save_load(self, curie_img, fail, rgb, tmp_path): metric = dis_ssim expectation = pytest.raises( ValueError, - match=( - "Saved and initialized optimized_metric are different" - ), + match=("Saved and initialized optimized_metric are different"), ) elif fail == "metric2": # this works with either rgb or grayscale images metric2 = rgb_mse expectation = pytest.raises( ValueError, - match=( - "Saved and initialized reference_metric are different" - ), + match=("Saved and initialized reference_metric are different"), ) elif fail == "target": target = "max" @@ -118,8 +115,7 @@ def test_save_load(self, curie_img, fail, rgb, tmp_path): expectation = pytest.raises( ValueError, match=( - "Saved and initialized metric_tradeoff_lambda are" - " different" + "Saved and initialized metric_tradeoff_lambda are" " different" ), ) mad_copy = po.synth.MADCompetition( @@ -163,18 +159,17 @@ def test_optimizer_opts(self, curie_img, optimizer): if optimizer == "Adam" or optimizer == "Scheduler": optimizer = torch.optim.Adam([mad.mad_image]) if optimizer == "Scheduler": - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( - optimizer - ) + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer) mad.synthesize(max_iter=5, optimizer=optimizer, scheduler=scheduler) - @pytest.mark.parametrize('metric', [po.metric.mse, ModuleMetric(), NonModuleMetric()]) - @pytest.mark.parametrize('to_type', ['dtype', 'device']) + @pytest.mark.parametrize( + "metric", [po.metric.mse, ModuleMetric(), NonModuleMetric()] + ) + @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, curie_img, metric, to_type): - mad = po.synth.MADCompetition(curie_img, metric, - po.tools.optim.l2_norm, 'min') + mad = po.synth.MADCompetition(curie_img, metric, po.tools.optim.l2_norm, "min") mad.synthesize(max_iter=5) - if to_type == 'dtype': + if to_type == "dtype": mad.to(torch.float64) assert mad.initial_image.dtype == torch.float64 assert mad.image.dtype == torch.float64 @@ -188,9 +183,7 @@ def test_to(self, curie_img, metric, to_type): mad.mad_image - mad.image mad.synthesize(max_iter=5) - @pytest.mark.skipif( - DEVICE.type == "cpu", reason="Only makes sense to test on cuda" - ) + @pytest.mark.skipif(DEVICE.type == "cpu", reason="Only makes sense to test on cuda") def test_map_location(self, curie_img, tmp_path): curie_img = curie_img mad = po.synth.MADCompetition( @@ -203,9 +196,7 @@ def test_map_location(self, curie_img, tmp_path): curie_img, po.metric.mse, po.tools.optim.l2_norm, "min" ) assert mad_copy.image.device.type == "cpu" - mad_copy.load( - op.join(tmp_path, "test_mad_map_location.pt"), map_location="cpu" - ) + mad_copy.load(op.join(tmp_path, "test_mad_map_location.pt"), map_location="cpu") assert mad_copy.mad_image.device.type == "cpu" mad_copy.synthesize(max_iter=4, store_progress=True) @@ -228,9 +219,7 @@ def test_batch_synthesis(self, curie_img, einstein_img): @pytest.mark.parametrize("store_progress", [True, 2, 3]) def test_store_rep(self, einstein_img, store_progress): - mad = po.synth.MADCompetition( - einstein_img, po.metric.mse, dis_ssim, "min" - ) + mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, "min") max_iter = 3 if store_progress == 3: max_iter = 6 @@ -244,12 +233,10 @@ def test_store_rep(self, einstein_img, store_progress): # these have a +1 because we calculate them during initialization as # well (so we know our starting point). assert len(mad.optimized_metric_loss) == max_iter + 1, ( - "Didn't end up with enough optimized metric losses after first" - " synth!" + "Didn't end up with enough optimized metric losses after first" " synth!" ) assert len(mad.reference_metric_loss) == max_iter + 1, ( - "Didn't end up with enough reference metric losses after first" - " synth!" + "Didn't end up with enough reference metric losses after first" " synth!" ) mad.synthesize(max_iter=max_iter, store_progress=store_progress) assert len(mad.saved_mad_image) == np.ceil( @@ -259,18 +246,14 @@ def test_store_rep(self, einstein_img, store_progress): len(mad.losses) == 2 * max_iter ), "Didn't end up with enough losses after second synth!" assert len(mad.optimized_metric_loss) == 2 * max_iter + 1, ( - "Didn't end up with enough optimized metric losses after second" - " synth!" + "Didn't end up with enough optimized metric losses after second" " synth!" ) assert len(mad.reference_metric_loss) == 2 * max_iter + 1, ( - "Didn't end up with enough reference metric losses after second" - " synth!" + "Didn't end up with enough reference metric losses after second" " synth!" ) def test_continue(self, einstein_img): - mad = po.synth.MADCompetition( - einstein_img, po.metric.mse, dis_ssim, "min" - ) + mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, "min") mad.synthesize(max_iter=3, store_progress=True) mad.synthesize(max_iter=3, store_progress=True) @@ -280,17 +263,13 @@ def test_nan_loss(self, einstein_img): mad = po.synth.MADCompetition(img, po.metric.mse, dis_ssim, "min") mad.synthesize(max_iter=5) mad.image[..., 0, 0] = torch.nan - with pytest.raises( - ValueError, match="Found a NaN in loss during optimization" - ): + with pytest.raises(ValueError, match="Found a NaN in loss during optimization"): mad.synthesize(max_iter=1) def test_change_precision_save_load(self, einstein_img, tmp_path): # Identity model doesn't change when you call .to() with a dtype # (unlike those models that have weights) so we use it here - mad = po.synth.MADCompetition( - einstein_img, po.metric.mse, dis_ssim, "min" - ) + mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, "min") mad.synthesize(max_iter=5) mad.to(torch.float64) assert mad.mad_image.dtype == torch.float64, "dtype incorrect!" @@ -306,9 +285,7 @@ def test_stop_criterion(self, einstein_img): # checking that this hits the criterion and stops early, so set seed # for reproducibility po.tools.set_seed(0) - mad = po.synth.MADCompetition( - einstein_img, po.metric.mse, dis_ssim, "min" - ) + mad = po.synth.MADCompetition(einstein_img, po.metric.mse, dis_ssim, "min") mad.synthesize(max_iter=15, stop_criterion=1e-3, stop_iters_to_check=5) assert ( abs(mad.losses[-5] - mad.losses[-1]) < 1e-3 diff --git a/tests/test_metamers.py b/tests/test_metamers.py index fe7df051..fb8d4584 100644 --- a/tests/test_metamers.py +++ b/tests/test_metamers.py @@ -18,7 +18,6 @@ def custom_loss(x1, x2): class TestMetamers(object): - @pytest.mark.parametrize( "model", ["frontend.LinearNonlinear.nograd"], indirect=True ) @@ -57,8 +56,7 @@ def test_save_load( expectation = pytest.raises( ValueError, match=( - "Saved and initialized target_representation are" - " different" + "Saved and initialized target_representation are" " different" ), ) elif fail == "loss": @@ -72,8 +70,7 @@ def test_save_load( expectation = pytest.raises( ValueError, match=( - "Saved and initialized range_penalty_lambda are" - " different" + "Saved and initialized range_penalty_lambda are" " different" ), ) elif fail == "dtype": @@ -114,9 +111,7 @@ def test_save_load( "metamer", "target_representation", ]: - if not getattr(met, k).allclose( - getattr(met_copy, k), rtol=1e-2 - ): + if not getattr(met, k).allclose(getattr(met_copy, k), rtol=1e-2): raise ValueError( "Something went wrong with saving and loading! %s not" " the same" % k @@ -173,9 +168,7 @@ def test_continue(self, einstein_img, model): @pytest.mark.parametrize("model", ["SPyr"], indirect=True) @pytest.mark.parametrize("coarse_to_fine", ["separate", "together"]) - def test_coarse_to_fine( - self, einstein_img, model, coarse_to_fine, tmp_path - ): + def test_coarse_to_fine(self, einstein_img, model, coarse_to_fine, tmp_path): metamer = po.synth.MetamerCTF( einstein_img, model, coarse_to_fine=coarse_to_fine ) @@ -185,17 +178,13 @@ def test_coarse_to_fine( change_scale_criterion=10, ctf_iters_to_check=1, ) - assert ( - len(metamer.scales_finished) > 0 - ), "Didn't actually switch scales!" + assert len(metamer.scales_finished) > 0, "Didn't actually switch scales!" metamer.save(op.join(tmp_path, "test_metamer_ctf.pt")) metamer_copy = po.synth.MetamerCTF( einstein_img, model, coarse_to_fine=coarse_to_fine ) - metamer_copy.load( - op.join(tmp_path, "test_metamer_ctf.pt"), map_location=DEVICE - ) + metamer_copy.load(op.join(tmp_path, "test_metamer_ctf.pt"), map_location=DEVICE) # check the ctf-related attributes all saved correctly for k in [ "coarse_to_fine", @@ -225,14 +214,10 @@ def test_optimizer(self, curie_img, model, optimizer): if optimizer == "Adam" or optimizer == "Scheduler": optimizer = torch.optim.Adam([met.metamer]) if optimizer == "Scheduler": - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( - optimizer - ) + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer) met.synthesize(max_iter=5, optimizer=optimizer, scheduler=scheduler) - @pytest.mark.skipif( - DEVICE.type == "cpu", reason="Only makes sense to test on cuda" - ) + @pytest.mark.skipif(DEVICE.type == "cpu", reason="Only makes sense to test on cuda") @pytest.mark.parametrize("model", ["Identity"], indirect=True) def test_map_location(self, curie_img, model, tmp_path): curie_img = curie_img.to(DEVICE) @@ -251,8 +236,8 @@ def test_map_location(self, curie_img, model, tmp_path): assert met_copy.image.device.type == "cpu" met_copy.synthesize(max_iter=4, store_progress=True) - @pytest.mark.parametrize('model', ['Identity', 'NonModule'], indirect=True) - @pytest.mark.parametrize('to_type', ['dtype', 'device']) + @pytest.mark.parametrize("model", ["Identity", "NonModule"], indirect=True) + @pytest.mark.parametrize("to_type", ["dtype", "device"]) def test_to(self, curie_img, model, to_type): met = po.synth.Metamer(curie_img, model) met.synthesize(max_iter=5) @@ -268,9 +253,7 @@ def test_to(self, curie_img, model, to_type): # this determines whether we mix across channels or treat them separately, # both of which are supported - @pytest.mark.parametrize( - "model", ["ColorModel", "Identity"], indirect=True - ) + @pytest.mark.parametrize("model", ["ColorModel", "Identity"], indirect=True) def test_multichannel(self, model, color_img): met = po.synth.Metamer(color_img, model) met.synthesize(max_iter=5) @@ -280,9 +263,7 @@ def test_multichannel(self, model, color_img): # this determines whether we mix across batches (e.g., a video model) or # treat them separately, both of which are supported - @pytest.mark.parametrize( - "model", ["VideoModel", "Identity"], indirect=True - ) + @pytest.mark.parametrize("model", ["VideoModel", "Identity"], indirect=True) def test_multibatch(self, model, einstein_img, curie_img): img = torch.cat([curie_img, einstein_img], dim=0) met = po.synth.Metamer(img, model) @@ -311,9 +292,7 @@ def test_nan_loss(self, model, einstein_img): met = po.synth.Metamer(img, model) met.synthesize(max_iter=5) met.target_representation[..., 0, 0] = torch.nan - with pytest.raises( - ValueError, match="Found a NaN in loss during optimization" - ): + with pytest.raises(ValueError, match="Found a NaN in loss during optimization"): met.synthesize(max_iter=1) @pytest.mark.parametrize("model", ["Identity"], indirect=True) @@ -326,9 +305,7 @@ def test_change_precision_save_load(self, model, einstein_img, tmp_path): assert met.metamer.dtype == torch.float64, "dtype incorrect!" met.save(op.join(tmp_path, "test_metamer_change_prec_save_load.pt")) met_copy = po.synth.Metamer(einstein_img.to(torch.float64), model) - met_copy.load( - op.join(tmp_path, "test_metamer_change_prec_save_load.pt") - ) + met_copy.load(op.join(tmp_path, "test_metamer_change_prec_save_load.pt")) met_copy.synthesize(max_iter=5) assert met_copy.metamer.dtype == torch.float64, "dtype incorrect!" @@ -340,5 +317,9 @@ def test_stop_criterion(self, einstein_img, model): met = po.synth.Metamer(einstein_img, model) # takes different numbers of iter to converge on GPU and CPU met.synthesize(max_iter=35, stop_criterion=1e-5, stop_iters_to_check=5) - assert abs(met.losses[-5]-met.losses[-1]) < 1e-5, "Didn't stop when hit criterion!" - assert abs(met.losses[-6]-met.losses[-2]) > 1e-5, "Stopped after hit criterion!" + assert ( + abs(met.losses[-5] - met.losses[-1]) < 1e-5 + ), "Didn't stop when hit criterion!" + assert ( + abs(met.losses[-6] - met.losses[-2]) > 1e-5 + ), "Stopped after hit criterion!" diff --git a/tests/test_metric.py b/tests/test_metric.py index 36d07ec4..3fa6b3f5 100644 --- a/tests/test_metric.py +++ b/tests/test_metric.py @@ -49,19 +49,14 @@ def test_load_images(paths, as_gray): images = po.tools.data.load_images(paths, as_gray) else: images = po.tools.data.load_images(paths, as_gray) - assert ( - images.ndimension() == 4 - ), "load_images did not return a 4d tensor!" + assert images.ndimension() == 4, "load_images did not return a 4d tensor!" class TestPerceptualMetrics(object): - @pytest.mark.parametrize("weighted", [True, False]) def test_ssim_grad(self, einstein_img, curie_img, weighted): curie_img.requires_grad_() - assert po.metric.ssim( - einstein_img, curie_img, weighted=weighted - ).requires_grad + assert po.metric.ssim(einstein_img, curie_img, weighted=weighted).requires_grad curie_img.requires_grad_(False) def test_msssim_grad(self, einstein_img, curie_img): @@ -70,15 +65,9 @@ def test_msssim_grad(self, einstein_img, curie_img): curie_img.requires_grad_(False) @pytest.mark.parametrize("func_name", ["ssim", "ms-ssim", "nlpd"]) - @pytest.mark.parametrize( - "size_A", [(), (3,), (1, 1), (6, 3), (6, 1), (6, 4)] - ) - @pytest.mark.parametrize( - "size_B", [(), (3,), (1, 1), (6, 3), (3, 1), (1, 4)] - ) - def test_batch_handling( - self, einstein_img, curie_img, func_name, size_A, size_B - ): + @pytest.mark.parametrize("size_A", [(), (3,), (1, 1), (6, 3), (6, 1), (6, 4)]) + @pytest.mark.parametrize("size_B", [(), (3,), (1, 1), (6, 3), (3, 1), (1, 4)]) + def test_batch_handling(self, einstein_img, curie_img, func_name, size_A, size_B): func = { "ssim": po.metric.ssim, "ms-ssim": po.metric.ms_ssim, @@ -147,9 +136,9 @@ def test_add_noise(self, einstein_img, noise_lvl, noise_as_tensor): @pytest.fixture def ssim_base_img(self, ssim_images, ssim_analysis): - return po.load_images( - os.path.join(ssim_images, ssim_analysis["base_img"]) - ).to(DEVICE) + return po.load_images(os.path.join(ssim_images, ssim_analysis["base_img"])).to( + DEVICE + ) @pytest.mark.parametrize("weighted", [True, False]) @pytest.mark.parametrize("other_img", np.arange(1, 11)) @@ -157,9 +146,9 @@ def test_ssim_analysis( self, weighted, other_img, ssim_images, ssim_analysis, ssim_base_img ): mat_type = {True: "weighted", False: "standard"}[weighted] - other = po.load_images( - os.path.join(ssim_images, f"samp{other_img}.tif") - ).to(DEVICE) + other = po.load_images(os.path.join(ssim_images, f"samp{other_img}.tif")).to( + DEVICE + ) # dynamic range is 1 for these images, because po.load_images # automatically re-ranges them. They were comptued with # dynamic_range=255 in MATLAB, and by correctly setting this value, @@ -181,44 +170,34 @@ def test_msssim_analysis(self, msssim_images): device=DEVICE, ) computed_values = torch.zeros_like(true_values) - base_img = po.load_images( - os.path.join(msssim_images, "samp0.tiff") - ).to(DEVICE) + base_img = po.load_images(os.path.join(msssim_images, "samp0.tiff")).to(DEVICE) for i in range(len(true_values)): - other_img = po.load_images( - os.path.join(msssim_images, f"samp{i}.tiff") - ).to(DEVICE) + other_img = po.load_images(os.path.join(msssim_images, f"samp{i}.tiff")).to( + DEVICE + ) computed_values[i] = po.metric.ms_ssim(base_img, other_img) assert torch.allclose(true_values, computed_values) def test_nlpd_grad(self, einstein_img, curie_img): curie_img.requires_grad_() assert po.metric.nlpd(einstein_img, curie_img).requires_grad - curie_img.requires_grad_( - False - ) # return to previous state for pytest fixtures + curie_img.requires_grad_(False) # return to previous state for pytest fixtures @pytest.mark.parametrize("model", ["frontend.OnOff"], indirect=True) def test_model_metric_grad(self, einstein_img, curie_img, model): curie_img.requires_grad_() - assert po.metric.model_metric( - einstein_img, curie_img, model - ).requires_grad + assert po.metric.model_metric(einstein_img, curie_img, model).requires_grad curie_img.requires_grad_(False) def test_ssim_dtype(self, einstein_img, curie_img): - po.metric.ssim( - einstein_img.to(torch.float64), curie_img.to(torch.float64) - ) + po.metric.ssim(einstein_img.to(torch.float64), curie_img.to(torch.float64)) def test_ssim_dtype_exception(self, einstein_img, curie_img): with pytest.raises(ValueError, match="must have same dtype"): po.metric.ssim(einstein_img.to(torch.float64), curie_img) def test_msssim_dtype(self, einstein_img, curie_img): - po.metric.ms_ssim( - einstein_img.to(torch.float64), curie_img.to(torch.float64) - ) + po.metric.ms_ssim(einstein_img.to(torch.float64), curie_img.to(torch.float64)) def test_msssim_dtype_exception(self, einstein_img, curie_img): with pytest.raises(ValueError, match="must have same dtype"): diff --git a/tests/test_models.py b/tests/test_models.py index ef9795c2..ada9f12f 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -47,14 +47,14 @@ def portilla_simoncelli_matlab_test_vectors(): @pytest.fixture() def portilla_simoncelli_test_vectors(): - return po.data.fetch_data( - "portilla_simoncelli_test_vectors_refactor.tar.gz" - ) + return po.data.fetch_data("portilla_simoncelli_test_vectors_refactor.tar.gz") @pytest.fixture() def portilla_simoncelli_synthesize(): - return po.data.fetch_data('portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor-2.npz') + return po.data.fetch_data( + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor-2.npz" + ) @pytest.fixture() @@ -107,9 +107,7 @@ def test_cpu(model, einstein_img): @pytest.mark.parametrize("model", ALL_MODELS, indirect=True) def test_validate_model(model): po.tools.remove_grad(model) - po.tools.validate.validate_model( - model, device=DEVICE, image_shape=(1, 1, 256, 256) - ) + po.tools.validate.validate_model(model, device=DEVICE, image_shape=(1, 1, 256, 256)) class TestNonLinearities(object): @@ -160,7 +158,6 @@ def test_local_gain_control_dict(self, basic_stim): class TestLaplacianPyramid(object): - def test_grad(self, basic_stim): lpyr = po.simul.LaplacianPyramid().to(DEVICE) y = lpyr.forward(basic_stim) @@ -181,9 +178,7 @@ def test_match_pyrtools(self, curie_img, n_scales): img = curie_img[:, :, 0:253, 0:234] lpyr_po = po.simul.LaplacianPyramid(n_scales=n_scales).to(DEVICE) y_po = lpyr_po(img) - lpyr_pt = pt.pyramids.LaplacianPyramid( - img.squeeze().cpu(), height=n_scales - ) + lpyr_pt = pt.pyramids.LaplacianPyramid(img.squeeze().cpu(), height=n_scales) y_pt = [lpyr_pt.pyr_coeffs[(i, 0)] for i in range(n_scales)] assert len(y_po) == len(y_pt) for x_po, x_pt in zip(y_po, y_pt): @@ -197,7 +192,6 @@ def test_match_pyrtools(self, curie_img, n_scales): class TestFrontEnd: - all_models = [ "frontend.LinearNonlinear", "frontend.LuminanceGainControl", @@ -242,20 +236,34 @@ def test_kernel_size(self, mdl, einstein_img): kernel_size = 31 if mdl == "frontend.LinearNonlinear": model = po.simul.LinearNonlinear(kernel_size, pretrained=True).to(DEVICE) - model2 = po.simul.LinearNonlinear((kernel_size, kernel_size), pretrained=True).to(DEVICE) + model2 = po.simul.LinearNonlinear( + (kernel_size, kernel_size), pretrained=True + ).to(DEVICE) elif mdl == "frontend.LuminanceGainControl": - model = po.simul.LuminanceGainControl(kernel_size, pretrained=True).to(DEVICE) - model2 = po.simul.LuminanceGainControl((kernel_size, kernel_size), pretrained=True).to(DEVICE) + model = po.simul.LuminanceGainControl(kernel_size, pretrained=True).to( + DEVICE + ) + model2 = po.simul.LuminanceGainControl( + (kernel_size, kernel_size), pretrained=True + ).to(DEVICE) elif mdl == "frontend.LuminanceContrastGainControl": - model = po.simul.LuminanceContrastGainControl(kernel_size, pretrained=True).to(DEVICE) - model2 = po.simul.LuminanceContrastGainControl((kernel_size, kernel_size), pretrained=True).to(DEVICE) + model = po.simul.LuminanceContrastGainControl( + kernel_size, pretrained=True + ).to(DEVICE) + model2 = po.simul.LuminanceContrastGainControl( + (kernel_size, kernel_size), pretrained=True + ).to(DEVICE) elif mdl == "frontend.OnOff": model = po.simul.OnOff(kernel_size, pretrained=True).to(DEVICE) - model2 = po.simul.OnOff((kernel_size, kernel_size), pretrained=True).to(DEVICE) - assert torch.allclose(model(einstein_img), model2(einstein_img)), "Kernels somehow different!" + model2 = po.simul.OnOff((kernel_size, kernel_size), pretrained=True).to( + DEVICE + ) + assert torch.allclose( + model(einstein_img), model2(einstein_img) + ), "Kernels somehow different!" -class TestNaive(object): +class TestNaive(object): all_models = [ "naive.Identity", "naive.Linear", @@ -269,33 +277,32 @@ def test_gradient_flow(self, model): y = model(img) assert y.requires_grad - @pytest.mark.parametrize("mdl",["naive.Linear", "naive.Gaussian", "naive.CenterSurround"]) + @pytest.mark.parametrize( + "mdl", ["naive.Linear", "naive.Gaussian", "naive.CenterSurround"] + ) def test_kernel_size(self, mdl, einstein_img): kernel_size = 10 if mdl == "naive.Gaussian": - model = po.simul.Gaussian(kernel_size, 1.).to(DEVICE) - model2 = po.simul.Gaussian((kernel_size, kernel_size), 1.).to(DEVICE) + model = po.simul.Gaussian(kernel_size, 1.0).to(DEVICE) + model2 = po.simul.Gaussian((kernel_size, kernel_size), 1.0).to(DEVICE) elif mdl == "naive.Linear": model = po.simul.Linear(kernel_size).to(DEVICE) model2 = po.simul.Linear((kernel_size, kernel_size)).to(DEVICE) elif mdl == "naive.CenterSurround": model = po.simul.CenterSurround(kernel_size).to(DEVICE) model2 = po.simul.CenterSurround((kernel_size, kernel_size)).to(DEVICE) - assert torch.allclose(model(einstein_img), model2(einstein_img)), "Kernels somehow different!" - + assert torch.allclose( + model(einstein_img), model2(einstein_img) + ), "Kernels somehow different!" @pytest.mark.parametrize("mdl", ["naive.Gaussian", "naive.CenterSurround"]) @pytest.mark.parametrize("cache_filt", [False, True]) def test_cache_filt(self, cache_filt, mdl): img = torch.ones(1, 1, 100, 100).to(DEVICE).requires_grad_() if mdl == "naive.Gaussian": - model = po.simul.Gaussian((31, 31), 1.0, cache_filt=cache_filt).to( - DEVICE - ) + model = po.simul.Gaussian((31, 31), 1.0, cache_filt=cache_filt).to(DEVICE) elif mdl == "naive.CenterSurround": - model = po.simul.CenterSurround( - (31, 31), cache_filt=cache_filt - ).to(DEVICE) + model = po.simul.CenterSurround((31, 31), cache_filt=cache_filt).to(DEVICE) y = model(img) # forward pass should cache filt if True @@ -307,13 +314,8 @@ def test_cache_filt(self, cache_filt, mdl): @pytest.mark.parametrize("center_std", [1.0, torch.as_tensor([1.0, 2.0])]) @pytest.mark.parametrize("out_channels", [1, 2, 3]) @pytest.mark.parametrize("on_center", [True, [True, False]]) - def test_CenterSurround_channels( - self, center_std, out_channels, on_center - ): - if ( - not isinstance(center_std, float) - and len(center_std) != out_channels - ): + def test_CenterSurround_channels(self, center_std, out_channels, on_center): + if not isinstance(center_std, float) and len(center_std) != out_channels: with pytest.raises(AssertionError): model = po.simul.CenterSurround( (31, 31), center_std=center_std, out_channels=out_channels @@ -365,11 +367,7 @@ def convert_matlab_ps_rep_to_dict( rep["magnitude_means"] = OrderedDict() keys = ( ["residual_highpass"] - + [ - (sc, ori) - for sc in range(n_scales) - for ori in range(n_orientations) - ] + + [(sc, ori) for sc in range(n_scales) for ori in range(n_orientations)] + ["residual_lowpass"] ) for ii, k in enumerate(keys): @@ -385,9 +383,11 @@ def convert_matlab_ps_rep_to_dict( ) # in the plenoptic version, auto_correlation_magnitude shape has n_scales and # n_orientations flipped relative to the matlab representation - rep["auto_correlation_magnitude"] = vec[ - ..., n_filled : (n_filled + np.prod(nn)) - ].unflatten(-1, nn).transpose(-1, -2) + rep["auto_correlation_magnitude"] = ( + vec[..., n_filled : (n_filled + np.prod(nn))] + .unflatten(-1, nn) + .transpose(-1, -2) + ) n_filled += np.prod(nn) # skew_reconstructed & kurtosis_reconstructed @@ -422,9 +422,9 @@ def convert_matlab_ps_rep_to_dict( if use_true_correlations: nn = (n_orientations, n_scales) - rep["magnitude_std"] = vec[ - ..., n_filled : (n_filled + np.prod(nn)) - ].unflatten(-1, nn) + rep["magnitude_std"] = vec[..., n_filled : (n_filled + np.prod(nn))].unflatten( + -1, nn + ) n_filled += np.prod(nn) else: # place a dummy entry, so the order of keys is correct @@ -479,18 +479,14 @@ def construct_normalizing_dict( mags_var = torch.stack([m.var((-2, -1), correction=0) for m in mags], -1) normalizing_dict = {} - com = einops.einsum( - mags_var, mags_var, "b c o1 s, b c o2 s -> b c o1 o2 s" - ) + com = einops.einsum(mags_var, mags_var, "b c o1 s, b c o2 s -> b c o1 o2 s") normalizing_dict["cross_orientation_correlation_magnitude"] = com.pow(0.5) if plen_ps.n_scales > 1: doub_mags_var = torch.stack( [m.var((-2, -1), correction=0) for m in doub_mags], -1 ) - reals_var = torch.stack( - [r.var((-2, -1), correction=0) for r in reals], -1 - ) + reals_var = torch.stack([r.var((-2, -1), correction=0) for r in reals], -1) doub_sep_var = torch.stack( [s.var((-2, -1), correction=0) for s in doub_sep], -1 ) @@ -570,9 +566,7 @@ def remove_redundant_and_normalize( # See docstring for why we make these specific stats negative matlab_rep["cross_scale_correlation_real"][ ..., : plen_ps.n_orientations, : - ] = -matlab_rep["cross_scale_correlation_real"][ - ..., : plen_ps.n_orientations, : - ] + ] = -matlab_rep["cross_scale_correlation_real"][..., : plen_ps.n_orientations, :] if not use_true_correlations: # Create std_reconstructed @@ -643,7 +637,6 @@ def test_ps_torch_v_matlab( im, portilla_simoncelli_matlab_test_vectors, ): - # the matlab outputs were computed on images with values between 0 and # 255 (not 0 and 1, which is what po.load_images does by default). Note # that for the einstein-9-2-4, einstein-9-3-4, einstein-9-4-4, @@ -682,15 +675,11 @@ def test_ps_torch_v_matlab( False, ) norm_dict = construct_normalizing_dict(ps, im0) - matlab_rep = remove_redundant_and_normalize( - matlab_rep, False, ps, norm_dict - ) + matlab_rep = remove_redundant_and_normalize(matlab_rep, False, ps, norm_dict) matlab_rep = po.to_numpy(matlab_rep).squeeze() python_vector = po.to_numpy(python_vector).squeeze() - np.testing.assert_allclose( - python_vector, matlab_rep, rtol=1e-4, atol=1e-4 - ) + np.testing.assert_allclose(python_vector, matlab_rep, rtol=1e-4, atol=1e-4) # tests for whether output matches the saved python output. This implicitly # tests that Portilla_simoncelli.forward() returns an object of the correct @@ -707,7 +696,6 @@ def test_ps_torch_output( im, portilla_simoncelli_test_vectors, ): - im0 = po.load_images(IMG_DIR / "256" / f"{im}.pgm") im0 = im0.to(torch.float64).to(DEVICE) ps = ( @@ -779,13 +767,7 @@ def test_ps_synthesis(self, portilla_simoncelli_synthesize, run_test=True): im_synth = f["im_synth"] rep_synth = f["rep_synth"] - im0 = ( - torch.as_tensor(im) - .unsqueeze(0) - .unsqueeze(0) - .to(DEVICE) - .to(torch.float64) - ) + im0 = torch.as_tensor(im).unsqueeze(0).unsqueeze(0).to(DEVICE).to(torch.float64) model = ( po.simul.PortillaSimoncelli( im0.shape[-2:], @@ -870,8 +852,7 @@ def test_other_size_images(self, n_scales, img_size): expectation = pytest.raises( ValueError, match=( - "Because of how the Portilla-Simoncelli model handles" - " multiscale" + "Because of how the Portilla-Simoncelli model handles" " multiscale" ), ) else: @@ -916,8 +897,7 @@ def test_multibatchchannel( rep = model(einstein_img.repeat((*batch_channel, 1, 1))) if rep.shape[:2] != batch_channel: raise ValueError( - "Output doesn't have same number of batch/channel dims as" - " input!" + "Output doesn't have same number of batch/channel dims as" " input!" ) @pytest.mark.parametrize("batch_channel", [(1, 1), (1, 3), (2, 1), (2, 3)]) @@ -978,9 +958,7 @@ def test_plot_representation_dim_assumption( rep = model(einstein_img.repeat((*batch_channel, 1, 1))) rep = model.convert_to_dict(rep[0].unsqueeze(0).mean(1, keepdim=True)) if any([v.ndim < 3 for v in rep.values()]): - raise ValueError( - "Somehow this doesn't have at least 3 dimensions!" - ) + raise ValueError("Somehow this doesn't have at least 3 dimensions!") if any([v.shape[:2] != (1, 1) for v in rep.values()]): raise ValueError("Somehow this has an extra batch or channel!") @@ -1011,9 +989,7 @@ def test_scales_shapes( unpacked_rep = einops.unpack(rep, model._pack_info, "b c *") # because _necessary_stats_dict is an ordered dictionary, its elements # will be in the same order as in unpackaged_rep - for unp_v, dict_v in zip( - unpacked_rep, model._necessary_stats_dict.values() - ): + for unp_v, dict_v in zip(unpacked_rep, model._necessary_stats_dict.values()): # when we have a single scale, _necessary_stats_dict will contain # keys for the cross_scale correlations, but there are no # corresponding values. Thus, skip. @@ -1031,9 +1007,7 @@ def test_scales_shapes( @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) @pytest.mark.parametrize("im", ["curie", "einstein", "metal", "nuts"]) - def test_redundancies( - self, n_scales, n_orientations, spatial_corr_width, im - ): + def test_redundancies(self, n_scales, n_orientations, spatial_corr_width, im): # test that the computed statistics have the redundancies we think they # do im = po.load_images(IMG_DIR / "256" / f"{im}.pgm") @@ -1050,9 +1024,7 @@ def test_redundancies( # and then we get them back into their original shapes (with lots of # redundancies) unpacked_rep = einops.unpack(rep, model._pack_info, "b c *") - for unp_v, (k, nec_v) in zip( - unpacked_rep, model._necessary_stats_dict.items() - ): + for unp_v, (k, nec_v) in zip(unpacked_rep, model._necessary_stats_dict.items()): # find the redundant values for this stat red_v = torch.logical_not(nec_v) # then there are no redundant values here @@ -1095,30 +1067,22 @@ def test_redundancies( offset = 0 else: offset = 1 - mask_vals.append( - val[-(i[0] + offset), -(i[1] + offset)] - ) + mask_vals.append(val[-(i[0] + offset), -(i[1] + offset)]) else: - raise ValueError( - f"stat {k} unexpectedly has redundant values!" - ) + raise ValueError(f"stat {k} unexpectedly has redundant values!") # and check for equality if ctr_vals: ctr_vals = torch.stack(ctr_vals) torch.equal(ctr_vals, torch.ones_like(ctr_vals)) unp_vals = torch.stack(unp_vals) mask_vals = torch.stack(mask_vals) - torch.testing.assert_close( - unp_vals, mask_vals, atol=1e-6, rtol=1e-7 - ) + torch.testing.assert_close(unp_vals, mask_vals, atol=1e-6, rtol=1e-7) @pytest.mark.parametrize("n_scales", [1, 2, 3, 4]) @pytest.mark.parametrize("n_orientations", [2, 3, 4]) @pytest.mark.parametrize("spatial_corr_width", range(3, 10)) @pytest.mark.parametrize("im", ["curie", "einstein", "metal", "nuts"]) - def test_crosscorrs( - self, n_scales, n_orientations, spatial_corr_width, im - ): + def test_crosscorrs(self, n_scales, n_orientations, spatial_corr_width, im): # test that cross-correlations we compute are actual cross correlations im = po.load_images(IMG_DIR / "256" / f"{im}.pgm") im = im.to(torch.float64).to(DEVICE) @@ -1148,9 +1112,7 @@ def test_crosscorrs( torch_corrs.append(torch.corrcoef(m).unsqueeze(0).unsqueeze(0)) torch_corr = torch.stack(torch_corrs, -1) idx = keys.index("cross_orientation_correlation_magnitude") - torch.testing.assert_close( - unpacked_rep[idx], torch_corr, atol=0, rtol=1e-12 - ) + torch.testing.assert_close(unpacked_rep[idx], torch_corr, atol=0, rtol=1e-12) # only have cross-scale correlations when there's more than one scale if n_scales > 1: # cross-scale magnitude correlations @@ -1229,9 +1191,7 @@ def test_circular_gaussian2d_shape(self, std, kernel_size, out_channels): if isinstance(kernel_size, int): kernel_size = (kernel_size, kernel_size) assert filt.shape == (out_channels, 1, *kernel_size) - assert filt.sum().isclose( - torch.ones(1, device=DEVICE) * out_channels - ) + assert filt.sum().isclose(torch.ones(1, device=DEVICE) * out_channels) def test_circular_gaussian2d_wrong_std_length(self): std = torch.as_tensor([1.0, 2.0], device=DEVICE) @@ -1240,16 +1200,22 @@ def test_circular_gaussian2d_wrong_std_length(self): circular_gaussian2d((7, 7), std, out_channels) @pytest.mark.parametrize("kernel_size", [5, 11, 20]) - @pytest.mark.parametrize("std,expectation", [ - (1., does_not_raise()), - (20., does_not_raise()), - (0., pytest.raises(ValueError, match="must be positive")), - (1, does_not_raise()), - ([1, 1], pytest.raises(ValueError, match="must have only one element")), - (torch.tensor(1), does_not_raise()), - (torch.tensor([1]), does_not_raise()), - (torch.tensor([1, 1]), pytest.raises(ValueError, match="must have only one element")), - ]) + @pytest.mark.parametrize( + "std,expectation", + [ + (1.0, does_not_raise()), + (20.0, does_not_raise()), + (0.0, pytest.raises(ValueError, match="must be positive")), + (1, does_not_raise()), + ([1, 1], pytest.raises(ValueError, match="must have only one element")), + (torch.tensor(1), does_not_raise()), + (torch.tensor([1]), does_not_raise()), + ( + torch.tensor([1, 1]), + pytest.raises(ValueError, match="must have only one element"), + ), + ], + ) def test_gaussian1d(self, kernel_size, std, expectation): with expectation: filt = gaussian1d(kernel_size, std) diff --git a/tests/test_steerable_pyr.py b/tests/test_steerable_pyr.py index 572f986f..84922dd6 100644 --- a/tests/test_steerable_pyr.py +++ b/tests/test_steerable_pyr.py @@ -31,9 +31,7 @@ def check_pyr_coeffs(coeff_1, coeff_2, rtol=1e-3, atol=1e-3): else: coeff_2_np = coeff_2[k] - np.testing.assert_allclose( - coeff_1_np, coeff_2_np, rtol=rtol, atol=atol - ) + np.testing.assert_allclose(coeff_1_np, coeff_2_np, rtol=rtol, atol=atol) def check_band_energies(coeff_1, coeff_2, rtol=1e-4, atol=1e-4): @@ -78,13 +76,10 @@ def check_parseval(im, coeff, rtol=1e-4, atol=0): total_band_energy += np.sum(np.abs(band) ** 2) - np.testing.assert_allclose( - total_band_energy, im_energy, rtol=rtol, atol=atol - ) + np.testing.assert_allclose(total_band_energy, im_energy, rtol=rtol, atol=atol) class TestSteerablePyramid(object): - @pytest.fixture( scope="class", params=[ @@ -111,9 +106,9 @@ def img(self, request): def multichannel_img(self, request): shape = request.param # use fixture for img and use color_wheel instead. - img = po.load_images( - IMG_DIR / "mixed" / "flowers.jpg", as_gray=False - ).to(DEVICE) + img = po.load_images(IMG_DIR / "mixed" / "flowers.jpg", as_gray=False).to( + DEVICE + ) if shape == "224": img = img[..., :224, :224] elif shape == "128_1": @@ -129,9 +124,7 @@ def multichannel_img(self, request): # the spyr with those strange shapes @pytest.fixture(scope="class") def spyr(self, img, request): - height, order, is_complex, downsample, tightframe = ( - request.param.split("-") - ) + height, order, is_complex, downsample, tightframe = request.param.split("-") try: height = int(height) except ValueError: @@ -152,9 +145,7 @@ def spyr(self, img, request): @pytest.fixture(scope="class") def spyr_multi(self, multichannel_img, request): - height, order, is_complex, downsample, tightframe = ( - request.param.split("-") - ) + height, order, is_complex, downsample, tightframe = request.param.split("-") try: height = int(height) except ValueError: @@ -220,9 +211,7 @@ def test_not_downsample(self, img, spyr): pyr_coeffs = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = ( - max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 - ) + height = max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 # couldn't come up with a way to get this with fixtures, so we # instantiate it each time. spyr_not_downsample = po.simul.SteerablePyramidFreq( @@ -282,9 +271,7 @@ def test_torch_vs_numpy_pyr(self, img, spyr): torch_spc = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = ( - max([k[0] for k in torch_spc.keys() if isinstance(k[0], int)]) + 1 - ) + height = max([k[0] for k in torch_spc.keys() if isinstance(k[0], int)]) + 1 pyrtools_sp = pt.pyramids.SteerablePyramidFreq( to_numpy(img.squeeze()), height=height, @@ -348,9 +335,7 @@ def test_partial_recon(self, img, spyr): pyr_coeffs = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = ( - max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 - ) + height = max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 pt_spyr = pt.pyramids.SteerablePyramidFreq( to_numpy(img.squeeze()), height=height, @@ -359,16 +344,10 @@ def test_partial_recon(self, img, spyr): ) recon_levels = [[0], [1, 3], [1, 3, 4]] recon_bands = [[1], [1, 3]] - for levels, bands in product( - ["all"] + recon_levels, ["all"] + recon_bands - ): - po_recon = to_numpy( - spyr.recon_pyr(pyr_coeffs, levels, bands).squeeze() - ) + for levels, bands in product(["all"] + recon_levels, ["all"] + recon_bands): + po_recon = to_numpy(spyr.recon_pyr(pyr_coeffs, levels, bands).squeeze()) pt_recon = pt_spyr.recon_pyr(levels, bands) - np.testing.assert_allclose( - po_recon, pt_recon, rtol=1e-4, atol=1e-4 - ) + np.testing.assert_allclose(po_recon, pt_recon, rtol=1e-4, atol=1e-4) @pytest.mark.parametrize( "spyr", @@ -384,9 +363,7 @@ def test_recon_match_pyrtools(self, img, spyr, rtol=1e-6, atol=1e-6): pyr_coeffs = spyr.forward(img) # need to add 1 because our heights are 0-indexed (i.e., the lowest # height has k[0]==0) - height = ( - max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 - ) + height = max([k[0] for k in pyr_coeffs.keys() if isinstance(k[0], int)]) + 1 pt_pyr = pt.pyramids.SteerablePyramidFreq( to_numpy(img.squeeze()), height=height, @@ -410,10 +387,7 @@ def test_recon_match_pyrtools(self, img, spyr, rtol=1e-6, atol=1e-6): ) @pytest.mark.parametrize( "spyr", - [ - f"auto-3-{c}-{d}-False" - for c, d in product([True, False], [True, False]) - ], + [f"auto-3-{c}-{d}-False" for c, d in product([True, False], [True, False])], indirect=True, ) def test_scales_arg(self, img, spyr, scales): @@ -441,9 +415,7 @@ def test_order_values(self, img, order): else: expectation = does_not_raise() with expectation: - pyr = po.simul.SteerablePyramidFreq( - img.shape[-2:], order=order - ).to(DEVICE) + pyr = po.simul.SteerablePyramidFreq(img.shape[-2:], order=order).to(DEVICE) pyr(img) @pytest.mark.parametrize("order", range(1, 16)) @@ -452,15 +424,15 @@ def test_buffers(self, order): buffers = [k for k, _ in pyr.named_buffers()] names = ["lo0mask", "hi0mask"] for s in range(pyr.num_scales): - names.extend([ - f"_himasks_scale_{s}", - f"_lomasks_scale_{s}", - f"_anglemasks_scale_{s}", - f"_anglemasks_recon_scale_{s}", - ]) + names.extend( + [ + f"_himasks_scale_{s}", + f"_lomasks_scale_{s}", + f"_anglemasks_scale_{s}", + f"_anglemasks_recon_scale_{s}", + ] + ) assert len(buffers) == len( names ), "pyramid doesn't have the right number of buffers!" - assert set(buffers) == set( - names - ), "pyramid doesn't have the right buffers!" + assert set(buffers) == set(names), "pyramid doesn't have the right buffers!" diff --git a/tests/test_tools.py b/tests/test_tools.py index f85c243a..633cd324 100644 --- a/tests/test_tools.py +++ b/tests/test_tools.py @@ -11,19 +11,17 @@ class TestData(object): - def test_load_images_fail(self): - with pytest.raises( - ValueError, match="All images must be the same shape" - ): - po.load_images([ - IMG_DIR / "256" / "einstein.pgm", - IMG_DIR / "mixed" / "bubbles.png", - ]) + with pytest.raises(ValueError, match="All images must be the same shape"): + po.load_images( + [ + IMG_DIR / "256" / "einstein.pgm", + IMG_DIR / "mixed" / "bubbles.png", + ] + ) class TestSignal(object): - def test_polar_amplitude_zero(self): a = torch.rand(10, device=DEVICE) * -1 b = po.tools.rescale(torch.randn(10, device=DEVICE), -pi / 2, pi / 2) @@ -51,9 +49,7 @@ def test_coordinate_identity_transform_polar(self): a = a / a.max() b = po.tools.rescale(torch.randn(dims, device=DEVICE), -pi / 2, pi / 2) - A, B = po.tools.rectangular_to_polar( - po.tools.polar_to_rectangular(a, b) - ) + A, B = po.tools.rectangular_to_polar(po.tools.polar_to_rectangular(a, b)) assert torch.linalg.vector_norm((a - A).flatten(), ord=2) < 1e-3 assert torch.linalg.vector_norm((b - B).flatten(), ord=2) < 1e-3 @@ -85,13 +81,15 @@ def test_autocorrelation(self, n): assert ( torch.abs( (x_centered * torch.roll(x_centered, w, dims=3)).sum((2, 3)) - / (x.shape[-2]*x.shape[-1]) - - a[..., n//2, n//2+w]) - < 1e-5).all() + / (x.shape[-2] * x.shape[-1]) + - a[..., n // 2, n // 2 + w] + ) + < 1e-5 + ).all() - @pytest.mark.parametrize('size_A', [1, 3]) - @pytest.mark.parametrize('size_B', [1, 2, 3]) - @pytest.mark.parametrize('dtype', [torch.float16, torch.float32, torch.float64]) + @pytest.mark.parametrize("size_A", [1, 3]) + @pytest.mark.parametrize("size_B", [1, 2, 3]) + @pytest.mark.parametrize("dtype", [torch.float16, torch.float32, torch.float64]) def test_add_noise(self, einstein_img, size_A, size_B, dtype): A = einstein_img.repeat(size_A, 1, 1, 1).to(dtype) B = size_B * [4] @@ -109,10 +107,7 @@ def test_expand(self, factor, img_size, einstein_img): expectation = pytest.raises( ValueError, match="factor \* x.shape\[-1\] must be" ) - elif ( - int(factor * einstein_img.shape[-2]) - != factor * einstein_img.shape[-2] - ): + elif int(factor * einstein_img.shape[-2]) != factor * einstein_img.shape[-2]: expectation = pytest.raises( ValueError, match="factor \* x.shape\[-2\] must be" ) @@ -137,10 +132,7 @@ def test_shrink(self, factor, img_size, einstein_img): expectation = pytest.raises( ValueError, match="x.shape\[-1\]/factor must be" ) - elif ( - int(einstein_img.shape[-2] / factor) - != einstein_img.shape[-2] / factor - ): + elif int(einstein_img.shape[-2] / factor) != einstein_img.shape[-2] / factor: expectation = pytest.raises( ValueError, match="x.shape\[-2\]/factor must be" ) @@ -159,17 +151,13 @@ def test_shrink(self, factor, img_size, einstein_img): @pytest.mark.parametrize("batch_channel", [[1, 3], [2, 1], [2, 3]]) def test_shrink_batch_channel(self, batch_channel, einstein_img): - shrunk = po.tools.shrink( - einstein_img.repeat((*batch_channel, 1, 1)), 2 - ) + shrunk = po.tools.shrink(einstein_img.repeat((*batch_channel, 1, 1)), 2) size = batch_channel + [s / 2 for s in einstein_img.shape[-2:]] np.testing.assert_equal(shrunk.shape, size) @pytest.mark.parametrize("batch_channel", [[1, 3], [2, 1], [2, 3]]) def test_expand_batch_channel(self, batch_channel, einstein_img): - expanded = po.tools.expand( - einstein_img.repeat((*batch_channel, 1, 1)), 2 - ) + expanded = po.tools.expand(einstein_img.repeat((*batch_channel, 1, 1)), 2) size = batch_channel + [2 * s for s in einstein_img.shape[-2:]] np.testing.assert_equal(expanded.shape, size) @@ -215,9 +203,7 @@ def test_modulate_phase_noreal(self): X = torch.arange(256).unsqueeze(1).repeat(1, 256) / 256 * 2 * torch.pi X = X.unsqueeze(0).unsqueeze(0) - with pytest.raises( - TypeError, match="x must be a complex-valued tensor" - ): + with pytest.raises(TypeError, match="x must be a complex-valued tensor"): po.tools.modulate_phase(X) @pytest.mark.parametrize("batch_channel", [(1, 3), (2, 1), (2, 3)]) @@ -243,7 +229,6 @@ def test_modulate_phase_batch_channel(self, batch_channel): class TestStats(object): - def test_stats(self): torch.manual_seed(0) B, D = 32, 512 @@ -251,8 +236,7 @@ def test_stats(self): m = torch.mean(x, dim=1, keepdim=True) v = po.tools.variance(x, mean=m, dim=1, keepdim=True) assert ( - torch.abs(v - torch.var(x, dim=1, keepdim=True, unbiased=False)) - < 1e-5 + torch.abs(v - torch.var(x, dim=1, keepdim=True, unbiased=False)) < 1e-5 ).all() s = po.tools.skew(x, mean=m, var=v, dim=1) k = po.tools.kurtosis(x, mean=m, var=v, dim=1) @@ -291,10 +275,9 @@ def test_kurt_multidim(self, batch_channel): class TestDownsampleUpsample(object): - - @pytest.mark.parametrize('odd', [0, 1]) - @pytest.mark.parametrize('size', [9, 10, 11, 12]) - @pytest.mark.parametrize('dtype', [torch.float32, torch.float64]) + @pytest.mark.parametrize("odd", [0, 1]) + @pytest.mark.parametrize("size", [9, 10, 11, 12]) + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) def test_filter(self, odd, size, dtype): img = torch.zeros([1, 1, 24 + odd, 25], device=DEVICE, dtype=dtype) img[0, 0, 12, 12] = 1 @@ -304,15 +287,21 @@ def test_filter(self, odd, size, dtype): filt = torch.as_tensor(filt, dtype=dtype, device=DEVICE) img_down = po.tools.correlate_downsample(img, filt=filt) img_up = po.tools.upsample_convolve(img_down, odd=(odd, 1), filt=filt) - assert np.unravel_index( - img_up.cpu().numpy().argmax(), img_up.shape - ) == (0, 0, 12, 12) + assert np.unravel_index(img_up.cpu().numpy().argmax(), img_up.shape) == ( + 0, + 0, + 12, + 12, + ) img_down = po.tools.blur_downsample(img) img_up = po.tools.upsample_blur(img_down, odd=(odd, 1)) - assert np.unravel_index( - img_up.cpu().numpy().argmax(), img_up.shape - ) == (0, 0, 12, 12) + assert np.unravel_index(img_up.cpu().numpy().argmax(), img_up.shape) == ( + 0, + 0, + 12, + 12, + ) def test_multichannel(self): img = torch.randn([10, 3, 24, 25], device=DEVICE, dtype=torch.float32) @@ -327,7 +316,6 @@ def test_multichannel(self): class TestValidate(object): - # https://docs.pytest.org/en/4.6.x/example/parametrize.html#parametrizing-conditional-raising @pytest.mark.parametrize( "shape,expectation", @@ -338,21 +326,15 @@ class TestValidate(object): ((2, 3, 16, 16), does_not_raise()), ( (1, 1, 1, 16, 16), - pytest.raises( - ValueError, match="input_tensor must be torch.Size" - ), + pytest.raises(ValueError, match="input_tensor must be torch.Size"), ), ( (1, 16, 16), - pytest.raises( - ValueError, match="input_tensor must be torch.Size" - ), + pytest.raises(ValueError, match="input_tensor must be torch.Size"), ), ( (16, 16), - pytest.raises( - ValueError, match="input_tensor must be torch.Size" - ), + pytest.raises(ValueError, match="input_tensor must be torch.Size"), ), ], ) @@ -363,9 +345,7 @@ def test_input_shape(self, shape, expectation): def test_input_no_batch(self): img = torch.rand(2, 1, 16, 16) - with pytest.raises( - ValueError, match="input_tensor batch dimension must be 1" - ): + with pytest.raises(ValueError, match="input_tensor batch dimension must be 1"): po.tools.validate.validate_input(img, no_batch=True) @pytest.mark.parametrize( @@ -373,15 +353,11 @@ def test_input_no_batch(self): [ ( "min", - pytest.raises( - ValueError, match="input_tensor range must lie within" - ), + pytest.raises(ValueError, match="input_tensor range must lie within"), ), ( "max", - pytest.raises( - ValueError, match="input_tensor range must lie within" - ), + pytest.raises(ValueError, match="input_tensor range must lie within"), ), ( "range", @@ -434,9 +410,7 @@ def forward(self, img): return img.detach() model = TestModel() - with pytest.raises( - ValueError, match="model strips gradient from input" - ): + with pytest.raises(ValueError, match="model strips gradient from input"): po.tools.validate.validate_model(model, device=DEVICE) def test_model_numpy_and_back(self): @@ -465,9 +439,7 @@ def forward(self, img): return img.to(torch.float16) model = TestModel() - with pytest.raises( - TypeError, match="model changes precision of input" - ): + with pytest.raises(TypeError, match="model changes precision of input"): po.tools.validate.validate_model(model, device=DEVICE) @pytest.mark.parametrize("direction", ["squeeze", "unsqueeze"]) @@ -483,14 +455,10 @@ def forward(self, img): return img.unsqueeze(0) model = TestModel() - with pytest.raises( - ValueError, match="When given a 4d input, model output" - ): + with pytest.raises(ValueError, match="When given a 4d input, model output"): po.tools.validate.validate_model(model, device=DEVICE) - @pytest.mark.skipif( - DEVICE.type == "cpu", reason="Only makes sense to test on cuda" - ) + @pytest.mark.skipif(DEVICE.type == "cpu", reason="Only makes sense to test on cuda") def test_model_device(self): class TestModel(torch.nn.Module): def __init__(self): @@ -500,17 +468,13 @@ def forward(self, img): return img.to("cpu") model = TestModel() - with pytest.raises( - RuntimeError, match="model changes device of input" - ): + with pytest.raises(RuntimeError, match="model changes device of input"): po.tools.validate.validate_model(model, device=DEVICE) @pytest.mark.parametrize("model", ["ColorModel"], indirect=True) def test_model_image_shape(self, model): img_shape = (1, 3, 16, 16) - po.tools.validate.validate_model( - model, image_shape=img_shape, device=DEVICE - ) + po.tools.validate.validate_model(model, image_shape=img_shape, device=DEVICE) def test_validate_ctf_scales(self): class TestModel(torch.nn.Module): @@ -521,9 +485,7 @@ def forward(self, img): return img model = TestModel() - with pytest.raises( - AttributeError, match="model has no scales attribute" - ): + with pytest.raises(AttributeError, match="model has no scales attribute"): po.tools.validate.validate_coarse_to_fine(model, device=DEVICE) def test_validate_ctf_arg(self): @@ -566,9 +528,7 @@ def test_validate_ctf_pass(self): def test_validate_metric_inputs(self): metric = lambda x: x - with pytest.raises( - TypeError, match="metric should be callable and accept two" - ): + with pytest.raises(TypeError, match="metric should be callable and accept two"): po.tools.validate.validate_metric(metric, device=DEVICE) def test_validate_metric_output_shape(self): @@ -586,23 +546,24 @@ def test_validate_metric_identical(self): po.tools.validate.validate_metric(metric, device=DEVICE) def test_validate_metric_nonnegative(self): - metric = lambda x, y : (x-y).sum() - with pytest.raises(ValueError, match="metric should always return non-negative"): + metric = lambda x, y: (x - y).sum() + with pytest.raises( + ValueError, match="metric should always return non-negative" + ): po.tools.validate.validate_metric(metric, device=DEVICE) - @pytest.mark.parametrize('model', ['frontend.OnOff.nograd'], indirect=True) + @pytest.mark.parametrize("model", ["frontend.OnOff.nograd"], indirect=True) def test_remove_grad(self, model): po.tools.validate.validate_model(model, device=DEVICE) class TestOptim(object): - def test_penalize_range_above(self): - img = .5 * torch.ones((1, 1, 4, 4)) + img = 0.5 * torch.ones((1, 1, 4, 4)) img[..., 0, :] = 2 assert po.tools.optim.penalize_range(img).item() == 4 def test_penalize_range_below(self): - img = .5 * torch.ones((1, 1, 4, 4)) + img = 0.5 * torch.ones((1, 1, 4, 4)) img[..., 0, :] = -1 assert po.tools.optim.penalize_range(img).item() == 4 diff --git a/tests/utils.py b/tests/utils.py index a5d21e22..c785ac19 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -36,8 +36,10 @@ def update_ps_synthesis_test_file(torch_version: Optional[str] = None): Metamer object for inspection """ - ps_synth_file = po.data.fetch_data('portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor-2.npz') - print(f'Loading from {ps_synth_file}') + ps_synth_file = po.data.fetch_data( + "portilla_simoncelli_synthesize_torch_v1.12.0_ps-refactor-2.npz" + ) + print(f"Loading from {ps_synth_file}") with np.load(ps_synth_file) as f: im = f["im"] @@ -47,19 +49,19 @@ def update_ps_synthesis_test_file(torch_version: Optional[str] = None): met = TestPortillaSimoncelli().test_ps_synthesis(ps_synth_file, False) - torch_v = torch.__version__.split('+')[0] - file_name_parts = re.findall('(.*portilla_simoncelli_synthesize)(_gpu)?(_torch_v)?([0-9.]*)(_ps-refactor)?(-2)?.npz', - ps_synth_file.name)[0] - output_file_name = ''.join(file_name_parts[:2]) + f'_torch_v{torch_v}{file_name_parts[-1]}.npz' + torch_v = torch.__version__.split("+")[0] + file_name_parts = re.findall( + "(.*portilla_simoncelli_synthesize)(_gpu)?(_torch_v)?([0-9.]*)(_ps-refactor)?(-2)?.npz", + ps_synth_file.name, + )[0] + output_file_name = ( + "".join(file_name_parts[:2]) + f"_torch_v{torch_v}{file_name_parts[-1]}.npz" + ) output = po.to_numpy(met.metamer).squeeze() rep = po.to_numpy(met.model(met.metamer)).squeeze() try: - np.testing.assert_allclose( - output, im_synth.squeeze(), rtol=1e-4, atol=1e-4 - ) - np.testing.assert_allclose( - rep, rep_synth.squeeze(), rtol=1e-4, atol=1e-4 - ) + np.testing.assert_allclose(output, im_synth.squeeze(), rtol=1e-4, atol=1e-4) + np.testing.assert_allclose(rep, rep_synth.squeeze(), rtol=1e-4, atol=1e-4) print( "Current synthesis same as saved version, so not saving current" " synthesis." @@ -94,7 +96,7 @@ def update_ps_torch_output(save_dir): n_scales = [1, 2, 3, 4] n_orientations = [2, 3, 4] spatial_corr_width = range(3, 10) - IMG_DIR = po.data.fetch_data('test_images.tar.gz') + IMG_DIR = po.data.fetch_data("test_images.tar.gz") im_names = ["curie", "einstein", "metal", "nuts"] ims = po.load_images([IMG_DIR / "256" / f"{im}.pgm" for im in im_names]) for scale in n_scales: @@ -108,10 +110,14 @@ def update_ps_torch_output(save_dir): spatial_corr_width=width, ).to(torch.float64) output = po.to_numpy(ps(im.unsqueeze(0))) - fname = save_dir / f"{name}_scales-{scale}_ori-{ori}_spat-{width}.npy" + fname = ( + save_dir / f"{name}_scales-{scale}_ori-{ori}_spat-{width}.npy" + ) np.save(fname, output) - print(f"All outputs have been saved in directory {save_dir}, now go to {save_dir.parent} " - f"and run `tar czf {save_dir.name} --directory={save_dir.with_suffix('.tar.gz').name}/ .`") + print( + f"All outputs have been saved in directory {save_dir}, now go to {save_dir.parent} " + f"and run `tar czf {save_dir.name} --directory={save_dir.with_suffix('.tar.gz').name}/ .`" + ) def update_ps_scales(save_path): @@ -122,7 +128,7 @@ def update_ps_scales(save_path): """ save_path = pathlib.Path(save_path) - if save_path.suffix != '.npz': + if save_path.suffix != ".npz": raise ValueError(f"save_path must have suffix .npz but got {save_path.suffix}!") save_path.parent.mkdir(parents=True, exist_ok=True) n_scales = [1, 2, 3, 4] @@ -138,6 +144,6 @@ def update_ps_scales(save_path): n_orientations=ori, spatial_corr_width=width, ) - key = f'scale-{scale}_ori-{ori}_width-{width}' + key = f"scale-{scale}_ori-{ori}_width-{width}" output[key] = ps._representation_scales np.savez(save_path, **output) From a7771333041b1bc1bfd3affa0911a54a44396f5e Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Tue, 1 Oct 2024 16:53:19 -0400 Subject: [PATCH 115/134] contributing file update completed --- CONTRIBUTING.md | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index a5197b7e..aafc388f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -173,7 +173,7 @@ If you want to suppress an error across an entire file, do this: For more details, refer to the [documentation](https://docs.astral.sh/ruff/linter/#error-suppression). -#### Style guide +#### General Style Guide Recommendations: - Longer, descriptive names are preferred (e.g., `x` is not an appropriate name for a variable), especially for anything user-facing, such as methods, @@ -182,6 +182,16 @@ For more details, refer to the [documentation](https://docs.astral.sh/ruff/linte (see [below](#docstrings) for details). Hidden ones do not *need* to have complete docstrings, but they probably should. +#### Pre-Commit Hooks: Identifying simple issues before submission to code review (and how to ignore those) +Pre-commit hooks are useful for the developer to check if all the linting and formatting rules (see Ruff above) are honored _before_ committing. That is, when you commit, pre-commit hooks are run and auto-fixed where applicable (e.g., trailing whitespace). You then need to add _again_ if you want these changes to be included in your commit. + +Should you want to ignore pre-commit hooks, you can add `--no-verify` to your commit message like this: +```bash +git commit -m --no-verify +``` + +All of the above only applies, if you have the pre-commit package manager installed using +`pip install pre-commit`. ### Adding models or synthesis methods From e6e2906d463e81be7aee0756a5259ac847da2a77 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 10:58:23 -0400 Subject: [PATCH 116/134] deleting pypi environment in deploy.yml which slipped in from a merge but doesn't belong into this PR --- .github/workflows/deploy.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index f55d24a6..95d09344 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -83,7 +83,6 @@ jobs: name: Upload release to Test PyPI needs: [build] runs-on: ubuntu-latest - environment: pypi permissions: id-token: write # IMPORTANT: this permission is mandatory for trusted publishing steps: From 3d89cc7d04e15d1491485a6e7e383a39928860a3 Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:01:15 -0400 Subject: [PATCH 117/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index aafc388f..1033633d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -126,7 +126,7 @@ At this point, we will be notified of the pull request and will read it over. We If your changes are integrated, you will be added as a Github contributor and as one of the authors of the package. Thank you for being part of `plenoptic`! -### Code Quality and Linting +### Code Style and Linting We use [Ruff](https://docs.astral.sh/ruff/) for linting and formatting our Python code to maintain a consistent code style and catch potential errors early. To ensure your contributions meet these standards, please follow the guidelines below: #### Using Ruff From 2d95a3ce3198e5cb026427b6da9fbec8eb313fca Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:03:17 -0400 Subject: [PATCH 118/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1033633d..f140000a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -127,7 +127,7 @@ At this point, we will be notified of the pull request and will read it over. We If your changes are integrated, you will be added as a Github contributor and as one of the authors of the package. Thank you for being part of `plenoptic`! ### Code Style and Linting -We use [Ruff](https://docs.astral.sh/ruff/) for linting and formatting our Python code to maintain a consistent code style and catch potential errors early. To ensure your contributions meet these standards, please follow the guidelines below: +We use [Ruff](https://docs.astral.sh/ruff/) for linting and formatting our Python code to maintain a consistent code style and catch potential errors early. We run ruff as part of our CI and non-compliant code will not be merged! #### Using Ruff From f8be38af125d730d1958cb60849d3c861a9f27ed Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:03:54 -0400 Subject: [PATCH 119/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index f140000a..fd68e9a0 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -131,7 +131,7 @@ We use [Ruff](https://docs.astral.sh/ruff/) for linting and formatting our Pytho #### Using Ruff -Ruff is a fast and comprehensive Python formatter and linter that checks for common style and code quality issues. It combines multiple tools, like Pyflakes, pycodestyle, isort, and other linting rules into one efficient tool, which are specified in `pyproject.toml`. Before submitting your code, make sure to run Ruff to catch any issues. +Ruff is a fast and comprehensive Python formatter and linter that checks for common style and code quality issues. It combines multiple tools, like black, Pyflakes, pycodestyle, isort, and other linting rules into one efficient tool, which are specified in `pyproject.toml`. Before submitting your code, make sure to run Ruff to catch any issues. See other sections of this document for how to use `nox` and `pre-commit` to simplify this process. **Using Ruff for [Formatting](https://docs.astral.sh/ruff/formatter/#philosophy):** From ef059ff9b5f46d9d9bd79173d7c7fedb90c0d533 Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:05:06 -0400 Subject: [PATCH 120/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index fd68e9a0..4a349602 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -133,7 +133,11 @@ We use [Ruff](https://docs.astral.sh/ruff/) for linting and formatting our Pytho Ruff is a fast and comprehensive Python formatter and linter that checks for common style and code quality issues. It combines multiple tools, like black, Pyflakes, pycodestyle, isort, and other linting rules into one efficient tool, which are specified in `pyproject.toml`. Before submitting your code, make sure to run Ruff to catch any issues. See other sections of this document for how to use `nox` and `pre-commit` to simplify this process. -**Using Ruff for [Formatting](https://docs.astral.sh/ruff/formatter/#philosophy):** +Ruff has two components, a [formatter](https://docs.astral.sh/ruff/formatter/) and a [linter](https://docs.astral.sh/ruff/linter/). Formatters and linters are both static analysis tools, but formatters "quickly check and reformat your code for stylistic consistency without changing the runtime behavior of the code", while linters "detect not just stylistic inconsistency but also potential logical bugs, and often suggest code fixes" (per [GitHub's readme project](https://github.com/readme/guides/formatters-linters-compilers)). There are many choices of formatters and linters in python; ruff aims to combine the features of many of them while being very fast. + +For both the formatter and the linter, you can run ruff without any additional arguments; our configuration option are stored in the `pyproject.toml` file and so don't need to be specified explicitly. + +##### Formatting: `ruff format` is the primary entrypoint to the formatter. It accepts a list of files or directories, and formats all discovered Python files: ```bash From 3c2d04326afcf8a41ff2d194a09b2c47c01b6127 Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:05:42 -0400 Subject: [PATCH 121/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 4a349602..b5d75f19 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -147,7 +147,7 @@ ruff format path/to/file.py # Format a single file. ``` For the full list of supported options, run `ruff format --help`. -**Using Ruff for [Linting](https://docs.astral.sh/ruff/linter/):** +##### Using Ruff for Linting: To run Ruff on your code: ```bash From 7f45b90fd73538521d72c463b80ab4c2dcee56c6 Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:06:23 -0400 Subject: [PATCH 122/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b5d75f19..25791205 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -187,7 +187,7 @@ For more details, refer to the [documentation](https://docs.astral.sh/ruff/linte complete docstrings, but they probably should. #### Pre-Commit Hooks: Identifying simple issues before submission to code review (and how to ignore those) -Pre-commit hooks are useful for the developer to check if all the linting and formatting rules (see Ruff above) are honored _before_ committing. That is, when you commit, pre-commit hooks are run and auto-fixed where applicable (e.g., trailing whitespace). You then need to add _again_ if you want these changes to be included in your commit. +Pre-commit hooks are useful for the developer to check if all the linting and formatting rules (see Ruff above) are honored _before_ committing. That is, when you commit, pre-commit hooks are run and auto-fixed where possible (e.g., trailing whitespace). You then need to add _again_ if you want these changes to be included in your commit. If the problem is not automatically fixable, you will need to manually update your code before you are able to commit. Should you want to ignore pre-commit hooks, you can add `--no-verify` to your commit message like this: ```bash From 83da52a0e46d647b429e4d07b466d90d73155d35 Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:06:53 -0400 Subject: [PATCH 123/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 25791205..f2d8252b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -194,8 +194,11 @@ Should you want to ignore pre-commit hooks, you can add `--no-verify` to your co git commit -m --no-verify ``` -All of the above only applies, if you have the pre-commit package manager installed using -`pip install pre-commit`. +In order to use pre-commit, you must install the `pre-commit` package into your development environment, and then install the hooks: + +```bash +pip install pre-commit +pre-commit install ### Adding models or synthesis methods From dad2a56883ee33a48503f69bc7aae6f223c7f98e Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:07:15 -0400 Subject: [PATCH 124/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index f2d8252b..0120a801 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -300,6 +300,8 @@ nox -s coverage `nox` offers a variety of configuration options, you can learn more about it from their [documentation](https://nox.thea.codes/en/stable/config.html). +Note that nox works particularly well with pyenv, discussed later in this file, which makes it easy to install the multiple python versions used in testing. + #### Multi-python version testing with pyenv Sometimes, before opening a pull-request that will trigger the `.github/workflow/ci.yml` continuous integration workflow, you may want to test your changes over all the supported python versions locally. From 64a1911fbc7e331bd8726b35e688961bb8f8386a Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 11:07:36 -0400 Subject: [PATCH 125/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 0120a801..5ac64de8 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -307,7 +307,7 @@ Sometimes, before opening a pull-request that will trigger the `.github/workflow integration workflow, you may want to test your changes over all the supported python versions locally. Handling multiple installed python versions on the same machine can be challenging and confusing. -[`pyenv`](https://github.com/pyenv/pyenv) is a great tool that really comes to the rescue. +[`pyenv`](https://github.com/pyenv/pyenv) is a great tool that really comes to the rescue. Note that `pyenv` just handles python versions --- virtual environments have to be handled separately, using [`pyenv-virtualenv`](https://github.com/pyenv/pyenv-virtualenv)! This tool doesn't come with the package dependencies and has to be installed separately. Installation instructions are system specific but the package readme is very details, see From b28b63fd90debe53ebf61537f15557cd489fec29 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 11:23:56 -0400 Subject: [PATCH 126/134] replacing os.path.join with pathlib and / operator to concatenate paths --- src/plenoptic/metric/perceptual_distance.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/plenoptic/metric/perceptual_distance.py b/src/plenoptic/metric/perceptual_distance.py index c5c36ede..97b1ba01 100644 --- a/src/plenoptic/metric/perceptual_distance.py +++ b/src/plenoptic/metric/perceptual_distance.py @@ -1,6 +1,6 @@ -import os import warnings from importlib import resources +from pathlib import Path import numpy as np import torch @@ -384,8 +384,9 @@ def normalized_laplacian_pyramid(img): (_, channel, height, width) = img.size() N_scales = 6 - spatialpooling_filters = np.load(os.path.join(DIRNAME, "DN_filts.npy")) - sigmas = np.load(os.path.join(DIRNAME, "DN_sigmas.npy")) + spatialpooling_filters = np.load(Path(DIRNAME) / "DN_filts.npy") + + sigmas = np.load(Path(DIRNAME) / "DN_sigmas.npy") L = LaplacianPyramid(n_scales=N_scales, scale_filter=True) laplacian_activations = L.forward(img) @@ -448,9 +449,8 @@ def nlpd(img1, img2): References ---------- .. [1] Laparra, V., Ballé, J., Berardino, A. and Simoncelli, E.P., 2016. Perceptual - image quality assessment using a normalized Laplacian pyramid. Electronic Imaging, - 2016(16), pp.1-6. - """ + image quality assessment using a normalized Laplacian pyramid. Electronic + Imaging, 2016(16), pp.1-6.""" if not img1.ndim == img2.ndim == 4: raise Exception( From 7faf97accb44a2d37a9ff4e4f8626e7629d68ee8 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 11:45:03 -0400 Subject: [PATCH 127/134] removing ignore in nox lint session --- noxfile.py | 2 +- pyproject.toml | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/noxfile.py b/noxfile.py index ccf2d6bd..d5115d63 100644 --- a/noxfile.py +++ b/noxfile.py @@ -7,7 +7,7 @@ def lint(session): # run linters session.install("ruff") - session.run("ruff", "check", "--ignore", "D") + session.run("ruff", "check") @nox.session(name="tests", python=["3.10", "3.11", "3.12"]) diff --git a/pyproject.toml b/pyproject.toml index df62ab5b..6c87520a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -150,8 +150,6 @@ select = [ "F", # pyupgrade "UP", - # flake8-bugbear - # "B", # flake8-simplify "SIM", # isort From e58e76c006aaeebb8028067d03f3e6130c2266a2 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 11:48:02 -0400 Subject: [PATCH 128/134] nox removed from mandatory installments --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 6c87520a..3dd52ef3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,7 +57,6 @@ dev = [ 'pytest-cov', 'pytest-xdist', "pooch>=1.2.0", - "nox", "ruff>=0.6.8", ] From 1d72d25987816fe54836f044a0f5ddc6a8e5d6d6 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 11:49:09 -0400 Subject: [PATCH 129/134] moved import pathlib to top of fetch.py file --- src/plenoptic/data/fetch.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/plenoptic/data/fetch.py b/src/plenoptic/data/fetch.py index 84a47ddc..36a9fb66 100644 --- a/src/plenoptic/data/fetch.py +++ b/src/plenoptic/data/fetch.py @@ -1,4 +1,7 @@ #!/usr/bin/env python3 + +import pathlib + """Fetch data using pooch. This is inspired by scipy's datasets module. @@ -57,8 +60,6 @@ } DOWNLOADABLE_FILES = list(REGISTRY_URLS.keys()) -# ignore E402 -import pathlib # noqa: E402 try: import pooch From 89138f800ea84192595121dc2e61d159ad8f13b5 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 12:00:08 -0400 Subject: [PATCH 130/134] adding two singleton dimensinos using the unsqueeze function twice, replacing the None, None expression, for better readability --- src/plenoptic/metric/classes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plenoptic/metric/classes.py b/src/plenoptic/metric/classes.py index 104ce79b..24c51883 100644 --- a/src/plenoptic/metric/classes.py +++ b/src/plenoptic/metric/classes.py @@ -45,4 +45,4 @@ def forward(self, image): # vector, we need to flatten each of them and then unsqueeze so # it is 3d - return torch.cat([i.flatten() for i in activations])[None, None, :] + return torch.cat([i.flatten() for i in activations]).unsqueeze(0).unsqueeze(0) From ccd53a911f95f5b34e5fafd2fbd311021c6f4434 Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 12:07:45 -0400 Subject: [PATCH 131/134] added examples to tool.ruff in pyproject.toml --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 3dd52ef3..a9afcea9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -87,7 +87,7 @@ testpaths = ["tests"] [tool.ruff] extend-include = ["*.ipynb"] -src = ["src", "tests"] +src = ["src", "tests", "examples"] # Exclude a variety of commonly ignored directories. exclude = [ ".bzr", From bbf89290c22f5d03417598f86ba8d6ca8b9c801f Mon Sep 17 00:00:00 2001 From: Hanna Dettki Date: Mon, 14 Oct 2024 12:12:19 -0400 Subject: [PATCH 132/134] removed pydocstyle inting from pyproject.toml as we are currently not using this linter --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index a9afcea9..9c0cfec6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -156,5 +156,4 @@ select = [ ] ignore = ["SIM105"] -[tool.ruff.lint.pydocstyle] convention = "numpy" From 044dd7030144ec9dc1050e1bff92a38b604c50e8 Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 12:19:39 -0400 Subject: [PATCH 133/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 5ac64de8..b16c3194 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -164,7 +164,7 @@ ruff --fix . Be careful with **unsafe fixes**, safe fixes are symbolized with the tools emoji and are listed [here](https://docs.astral.sh/ruff/rules/)! #### Ignoring Ruff Linting -You may want to suppress lint errors, for example when too long lines (code `E501`) are desired because otherwise the url might not be readable anymore. +In some cases, it may be acceptable to suppress lint errors, for example when too long lines (code `E501`) are desired because otherwise the url might not be readable anymore. These ignores will be evaluated on a case-by-case basis. You can do this by adding the following to the end of the line: ```bash From a1a35426ccf73b3ed476068ee0a338d1539052f1 Mon Sep 17 00:00:00 2001 From: hmd101 <33073354+hmd101@users.noreply.github.com> Date: Mon, 14 Oct 2024 12:22:16 -0400 Subject: [PATCH 134/134] Update CONTRIBUTING.md Co-authored-by: William F. Broderick --- CONTRIBUTING.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b16c3194..08739f83 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -355,9 +355,7 @@ If you want to run `nox` on multiple python versions, all you need to do is: Note that `noxfile.py` lists the available option as keyword arguments in a session specific manner. -If you have multiple python version installed, we recommend to manage your virtual environments -through `pyenv`. For that you'll need to install the extension -[`pyenv-virtualenv`](https://github.com/pyenv/pyenv-virtualenv). +As mentioned earlier, if you have multiple python version installed, we recommend you manage your virtual environments through `pyenv` using the [`pyenv-virtualenv`](https://github.com/pyenv/pyenv-virtualenv) extension. This tool works with most of the environment managers including (`venv` and `conda`). Creating an environment with it is as simple as calling,