From 73fee25f92e8cffd18239536b716b5ab06de95e3 Mon Sep 17 00:00:00 2001 From: Andrew Dawson Date: Fri, 5 Apr 2013 08:37:16 +0100 Subject: [PATCH 1/4] NF - add experimental EOF rotation functionality --- lib/eofs/experimental/__init__.py | 17 + lib/eofs/experimental/rotation/__init__.py | 37 +++ lib/eofs/experimental/rotation/cdms.py | 252 +++++++++++++++ lib/eofs/experimental/rotation/iris.py | 253 +++++++++++++++ lib/eofs/experimental/rotation/kernels.py | 82 +++++ lib/eofs/experimental/rotation/standard.py | 306 ++++++++++++++++++ lib/eofs/tests/__init__.py | 18 +- lib/eofs/tests/data/latitude_r.npy | Bin 0 -> 152 bytes lib/eofs/tests/data/longitude_r.npy | Bin 0 -> 200 bytes .../tests/data/rotated_eigenvalues.scaled.npy | Bin 0 -> 120 bytes .../data/rotated_eigenvalues.unscaled.npy | Bin 0 -> 120 bytes lib/eofs/tests/data/rotated_eofs.scaled.npy | Bin 0 -> 21680 bytes lib/eofs/tests/data/rotated_eofs.unscaled.npy | Bin 0 -> 21680 bytes lib/eofs/tests/data/rotated_pcs.scaled.npy | Bin 0 -> 2080 bytes lib/eofs/tests/data/rotated_pcs.unscaled.npy | Bin 0 -> 2080 bytes .../tests/data/rotated_variance.scaled.npy | Bin 0 -> 100 bytes .../tests/data/rotated_variance.unscaled.npy | Bin 0 -> 100 bytes lib/eofs/tests/data/sst_r.npy | Bin 0 -> 216080 bytes lib/eofs/tests/data/time_r.npy | Bin 0 -> 480 bytes lib/eofs/tests/reference.py | 119 +++++++ lib/eofs/tests/test_rotation.py | 200 ++++++++++++ setup.py | 1 + tests.py | 1 + 23 files changed, 1278 insertions(+), 8 deletions(-) create mode 100644 lib/eofs/experimental/__init__.py create mode 100644 lib/eofs/experimental/rotation/__init__.py create mode 100644 lib/eofs/experimental/rotation/cdms.py create mode 100644 lib/eofs/experimental/rotation/iris.py create mode 100644 lib/eofs/experimental/rotation/kernels.py create mode 100644 lib/eofs/experimental/rotation/standard.py create mode 100644 lib/eofs/tests/data/latitude_r.npy create mode 100644 lib/eofs/tests/data/longitude_r.npy create mode 100644 lib/eofs/tests/data/rotated_eigenvalues.scaled.npy create mode 100644 lib/eofs/tests/data/rotated_eigenvalues.unscaled.npy create mode 100644 lib/eofs/tests/data/rotated_eofs.scaled.npy create mode 100644 lib/eofs/tests/data/rotated_eofs.unscaled.npy create mode 100644 lib/eofs/tests/data/rotated_pcs.scaled.npy create mode 100644 lib/eofs/tests/data/rotated_pcs.unscaled.npy create mode 100644 lib/eofs/tests/data/rotated_variance.scaled.npy create mode 100644 lib/eofs/tests/data/rotated_variance.unscaled.npy create mode 100644 lib/eofs/tests/data/sst_r.npy create mode 100644 lib/eofs/tests/data/time_r.npy create mode 100644 lib/eofs/tests/test_rotation.py diff --git a/lib/eofs/experimental/__init__.py b/lib/eofs/experimental/__init__.py new file mode 100644 index 0000000..efa4e5c --- /dev/null +++ b/lib/eofs/experimental/__init__.py @@ -0,0 +1,17 @@ +"""Experimental features.""" +# (c) Copyright 2013 Andrew Dawson. All Rights Reserved. +# +# This file is part of eofs. +# +# eofs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# eofs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with eofs. If not, see . diff --git a/lib/eofs/experimental/rotation/__init__.py b/lib/eofs/experimental/rotation/__init__.py new file mode 100644 index 0000000..cbd7d24 --- /dev/null +++ b/lib/eofs/experimental/rotation/__init__.py @@ -0,0 +1,37 @@ +"""Rotation of EOFs.""" +# (c) Copyright 2013 Andrew Dawson. All Rights Reserved. +# +# This file is part of eofs. +# +# eofs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# eofs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with eofs. If not, see . +from __future__ import absolute_import + +from . import standard + + +# Define the objects imported by imports of the form: +# from eofs.experimental.rotation import * +__all__ = ['standard'] + +try: + from . import cdms + __all__.append('cdms') +except ImportError: + pass + +try: + from . import iris + __all__.append('iris') +except ImportError: + pass diff --git a/lib/eofs/experimental/rotation/cdms.py b/lib/eofs/experimental/rotation/cdms.py new file mode 100644 index 0000000..3efd308 --- /dev/null +++ b/lib/eofs/experimental/rotation/cdms.py @@ -0,0 +1,252 @@ +# (c) Copyright 2013 Andrew Dawson. All Rights Reserved. +# +# This file is part of eofs. +# +# eofs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# eofs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with eofs. If not, see . +from __future__ import absolute_import +import numpy as np +import numpy.ma as ma +from cdms2 import createVariable + +from .standard import Rotator as StandardRotator + + +class Rotator(StandardRotator): + """Rotate EOFs from the `cdms2` interface.""" + + def __init__(self, *args, **kwargs): + """ + Rotator(solver, neofs, method='varimax', scaled=True) + + Create an EOF rotator. + + **Arguments:** + + *solver* + An `~eofs.cdms.Eof` instance that can generate the EOFs to + be rotated. + + *neofs* + Number of EOFs to use for the rotation. + + **Keyword arguments:** + + *method* + The method to use for rotation. Currently the only accepted + value is 'varimax'. + + *scaled* + If *True* the EOFs are multiplied by the square-root of + their eigenvalue before the rotation. If *False* the + orthonormal EOFs are used for the rotation. Defaults to + *True*. + + **Examples:** + + A varimax rotator based on the first 10 scaled EOFs:: + + solver = Eof(data, weights='area') + rotator = Rotator(solver, 10) + + A varimax rotator based on the first 5 un-scaled EOFs:: + + solver = Eof(data, weights='area') + rotator = Rotator(solver, 5, scaled=False) + + """ + super(Rotator, self).__init__(*args, **kwargs) + + def eofs(self, *args, **kwargs): + """ + eofs(neofs=None, renormalize=True) + + Rotated empirical orthogonal functions (EOFs). + + **Optional arguments:** + + *neofs* + Number of EOFs to return. Defaults to all EOFs. If the + number of EOFs requested is more than the number that are + available, then all available EOFs will be returned. + + *renormalize* + If *True* and the rotation was based on scaled EOFs then the + scaling will be removed and the returned rotated EOFs will + be scaled to unit variance. If *False* the returned rotated + EOFs will retain the scaling. + + **Returns:** + + *eofs* + A `cdms2` variable containing the ordered rotated EOFs. The + EOFs are numbered from 0 to *neofs* - 1. + + **Examples:** + + All rotated EOFs with scaling:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs() + + All rotated EOFs with scaling removed:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs(renormalize=True) + + The leading rotated EOF with scaling:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs(neofs=1) + + """ + return super(Rotator, self).eofs(*args, **kwargs) + + def varianceFraction(self, *args, **kwargs): + """ + varianceFraction(neigs=None) + + Fractional rotated EOF mode variances. + + The fraction of the total variance explained by each rotated EOF + mode, values between 0 and 1 inclusive. Only meaningful if the + *scaled* option was set to *True* when creating the `Rotator`. + + **Optional argument:** + + *neigs* + Number of eigenvalues to return the fractional variance for. + Defaults to all eigenvalues. If the number of eigenvalues + requested is more than the number that are available, then + fractional variances for all available eigenvalues will be + returned. + + **Returns:** + + *variance_fractions* + A `cdms2` variable containing the fractional variances for + each rotated EOF mode. The EOF modes are numbered from 0 to + *neigs* - 1. + + **Examples:** + + The fractional variance represented by each rotated EOF mode:: + + rotator = Rotator(solver, 10, scaled=True) + variance_fractions = rotator.varianceFraction() + + The fractional variance represented by the first rotated EOF mode:: + + rotator = Rotator(solver, 10, scaled=True) + variance_fractions = rotator.varianceFraction(neigs=1) + + """ + return super(Rotator, self).varianceFraction(*args, **kwargs) + + def pcs(self, *args, **kwargs): + """ + pcs(npcs=None, normalized=False) + + Principal component time series (PCs). + + The PC time series associated with the rotated EOFs. + + **Optional arguments:** + + *npcs* + Number of PCs to retrieve. Defaults to all the PCs. If the + number of PCs requested is more than the number that are + available, then all available PCs will be returned. + + *normalized* + If *True* the returned PCs are scaled to unit variance. If + *False* no scaling is done. Defaults to *False*. + + **Returns:** + + *pcs* + A `cdms2` variable containing the PCs. The PCs are numbered + from 0 to *npcs* - 1. + + **Examples:** + + All un-scaled PCs:: + + pcs = rotator.pcs() + + First 3 PCs scaled to unit variance:: + + pcs = rotator.pcs(npcs=3, normalized=True) + + """ + return super(Rotator, self).pcs(*args, **kwargs) + + def _solverdata(self): + """Get the raw data from the EOF solver.""" + return self._solver._solver._data + + def strip_metadata(self, var): + """Strip basic metadata from a `cdms2` variable. + + **Argument:** + + *var* + A `cdms2` variable to strip. + + **Returns:** + + *data* + An array of the raw data contained in *var*. + + *metadata* + A dictionary containing basic metadata from *var*. The + dictionary has entries: + 'dimensions': list of dimension coordinates + 'id': variable's id + 'standard_name': if *var* has a standard name + 'long_name': if *var* has a long name + + """ + metadata = {} + metadata['dimensions'] = var.getAxisList() + metadata['id'] = var.id + for name in ('standard_name', 'long_name'): + var_name = getattr(var, name, None) + if var_name is not None: + metadata[name] = var_name + return var.asma(), metadata + + def apply_metadata(self, data, metadata): + """Construct a cube from raw data and a metadata dictionary. + + **Arguments:** + + *data* + Raw data array. + + *metadata* + A dictionary of metadata returned from + `~Rotator.strip_metadata`. + + **Returns:** + + *var* + A `cdms2` variable. + + """ + dims = metadata['dimensions'] + var = createVariable(data, axes=dims, id=metadata['id']) + for name in ('standard_name', 'long_name'): + if name in metadata: + setattr(var, name, metadata[name]) + return var diff --git a/lib/eofs/experimental/rotation/iris.py b/lib/eofs/experimental/rotation/iris.py new file mode 100644 index 0000000..2eef840 --- /dev/null +++ b/lib/eofs/experimental/rotation/iris.py @@ -0,0 +1,253 @@ +"""Rotation of EOFs for the `iris` interface.""" +# (c) Copyright 2013 Andrew Dawson. All Rights Reserved. +# +# This file is part of eofs. +# +# eofs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# eofs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with eofs. If not, see . +from __future__ import absolute_import +import numpy as np +import numpy.ma as ma +from iris.cube import Cube + +from .standard import Rotator as StandardRotator + + +class Rotator(StandardRotator): + """Rotate EOFs from the `iris` interface.""" + + def __init__(self, *args, **kwargs): + """ + Rotator(solver, neofs, method='varimax', scaled=True) + + Create an EOF rotator. + + **Arguments:** + + *solver* + An `~eofs.iris.Eof` instance that can generate the EOFs to + be rotated. + + *neofs* + Number of EOFs to use for the rotation. + + **Keyword arguments:** + + *method* + The method to use for rotation. Currently the only accepted + value is 'varimax'. + + *scaled* + If *True* the EOFs are multiplied by the square-root of + their eigenvalue before the rotation. If *False* the + orthonormal EOFs are used for the rotation. Defaults to + *True*. + + **Examples:** + + A varimax rotator based on the first 10 scaled EOFs:: + + solver = Eof(data, weights='area') + rotator = Rotator(solver, 10) + + A varimax rotator based on the first 5 un-scaled EOFs:: + + solver = Eof(data, weights='area') + rotator = Rotator(solver, 5, scaled=False) + + """ + super(Rotator, self).__init__(*args, **kwargs) + + def eofs(self, *args, **kwargs): + """ + eofs(neofs=None, renormalize=True) + + Rotated empirical orthogonal functions (EOFs). + + **Optional arguments:** + + *neofs* + Number of EOFs to return. Defaults to all EOFs. If the + number of EOFs requested is more than the number that are + available, then all available EOFs will be returned. + + *renormalize* + If *True* and the rotation was based on scaled EOFs then the + scaling will be removed and the returned rotated EOFs will + be scaled to unit variance. If *False* the returned rotated + EOFs will retain the scaling. + + **Returns:** + + *eofs* + A `~iris.cube.Cube` containing the ordered rotated EOFs. The + EOFs are numbered from 0 to *neofs* - 1. + + **Examples:** + + All rotated EOFs with scaling:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs() + + All rotated EOFs with scaling removed:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs(renormalize=True) + + The leading rotated EOF with scaling:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs(neofs=1) + + """ + return super(Rotator, self).eofs(*args, **kwargs) + + def varianceFraction(self, *args, **kwargs): + """ + varianceFraction(neigs=None) + + Fractional rotated EOF mode variances. + + The fraction of the total variance explained by each rotated EOF + mode, values between 0 and 1 inclusive. Only meaningful if the + *scaled* option was set to *True* when creating the `Rotator`. + + **Optional argument:** + + *neigs* + Number of eigenvalues to return the fractional variance for. + Defaults to all eigenvalues. If the number of eigenvalues + requested is more than the number that are available, then + fractional variances for all available eigenvalues will be + returned. + + **Returns:** + + *variance_fractions* + A `~iris.cube.Cube` containing the fractional variances for + each rotated EOF mode. The EOF modes are numbered from 0 to + *neigs* - 1. + + **Examples:** + + The fractional variance represented by each rotated EOF mode:: + + rotator = Rotator(solver, 10, scaled=True) + variance_fractions = rotator.varianceFraction() + + The fractional variance represented by the first rotated EOF mode:: + + rotator = Rotator(solver, 10, scaled=True) + variance_fractions = rotator.varianceFraction(neigs=1) + + """ + return super(Rotator, self).varianceFraction(*args, **kwargs) + + def pcs(self, *args, **kwargs): + """ + pcs(npcs=None, normalized=False) + + Principal component time series (PCs). + + The PC time series associated with the rotated EOFs. + + **Optional arguments:** + + *npcs* + Number of PCs to retrieve. Defaults to all the PCs. If the + number of PCs requested is more than the number that are + available, then all available PCs will be returned. + + *normalized* + If *True* the returned PCs are scaled to unit variance. If + *False* no scaling is done. Defaults to *False*. + + **Returns:** + + *pcs* + A `~iris.cube.Cube` containing the PCs. The PCs are numbered + from 0 to *npcs* - 1. + + **Examples:** + + All un-scaled PCs:: + + pcs = rotator.pcs() + + First 3 PCs scaled to unit variance:: + + pcs = rotator.pcs(npcs=3, normalized=True) + + """ + return super(Rotator, self).pcs(*args, **kwargs) + + def _solverdata(self): + """Get the raw data from the EOF solver.""" + return self._solver._solver._data + + def strip_metadata(self, cube): + """Strip basic metadata from a `~iris.cube.Cube`. + + **Argument:** + + *cube* + A `~iris.cube.Cube` to strip. + + **Returns:** + + *data* + An array of the raw data contained in *cube*. + + *metadata* + A dictionary containing basic metadata from *cube*. The + dictionary has entries: + 'dimensions': tuple of dimension coordinates + 'standard_name': if *cube* has a standard name + 'long_name': if *cube* has a long name + 'var_name': if cube has a var_name + + """ + metadata = {} + metadata['dimensions'] = cube.dim_coords + for name in ('standard_name', 'long_name', 'var_name'): + cube_name = getattr(cube, name, None) + if cube_name is not None: + metadata[name] = cube_name + return cube.data, metadata + + def apply_metadata(self, data, metadata): + """Construct a cube from raw data and a metadata dictionary. + + **Arguments:** + + *data* + Raw data array. + + *metadata* + A dictionary of metadata returned from + `~Rotator.strip_metadata`. + + **Returns:** + + *cube* + A `~iris.cube.Cube`. + + """ + dims = metadata['dimensions'] + cube = Cube(data, + dim_coords_and_dims=zip(dims, range(len(dims)))) + for name in ('standard_name', 'long_name', 'var_name'): + if name in metadata: + setattr(cube, name, metadata[name]) + return cube diff --git a/lib/eofs/experimental/rotation/kernels.py b/lib/eofs/experimental/rotation/kernels.py new file mode 100644 index 0000000..1380a6b --- /dev/null +++ b/lib/eofs/experimental/rotation/kernels.py @@ -0,0 +1,82 @@ +"""Rotation kernels for EOF rotation.""" +# (c) Copyright 2013 Andrew Dawson. All Rights Reserved. +# +# This file is part of eofs. +# +# eofs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# eofs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with eofs. If not, see . +from __future__ import absolute_import + +import numpy as np + + +def _varimax_kernel(eofs, eps=1e-10, itermax=1000, kaisernorm=True): + """Rotation of EOFs according to the varimax criterion. + + **Arguments:** + + *eofs* + A 2-dimensional `~numpy.ndarray` with dimensions [neofs, nspace] + containing no missing values. + + **Optional arguments:** + + *epsilon* + Tolerance value used to determine convergence of the rotation + algorithm. Defaults to 1e-10. + + *itermax* + Maximum number of iterations to allow in the rotation algorithm. + + *kaisernorm* + If *True* uses Kaiser row normalization. If *False* no + normalization is used in the kernel. Defaults to *True*. + + """ + try: + neofs, nspace = eofs.shape + except ValueError: + raise ValueError('kernel requires a 2-D input') + if neofs < 2: + raise ValueError('at least 2 EOFs are required for rotation') + if kaisernorm: + # Apply Kaiser row normalization. + scale = np.sqrt((eofs ** 2).sum(axis=0)) + eofs /= scale + # Define the initial values of the rotation matrix and the convergence + # monitor. + rotation = np.eye(neofs, dtype=eofs.dtype) + delta = 0. + # Iteratively compute the rotation matrix. + for i in xrange(itermax): + z = np.dot(eofs.T, rotation) + b = np.dot(eofs, + z ** 3 - np.dot(z, np.diag((z ** 2).sum(axis=0)) / nspace)) + u, s, v = np.linalg.svd(b) + rotation = np.dot(u, v) + delta_previous = delta + delta = s.sum() + if delta < delta_previous * (1. + eps): + # Convergence is reached, stop the iteration. + break + # Apply the rotation to the input EOFs. + reofs = np.dot(eofs.T, rotation).T + if kaisernorm: + # Remove the normalization. + reofs *= scale + return reofs + + +KERNEL_MAPPING = { + 'varimax': _varimax_kernel, +} diff --git a/lib/eofs/experimental/rotation/standard.py b/lib/eofs/experimental/rotation/standard.py new file mode 100644 index 0000000..cf5b3ba --- /dev/null +++ b/lib/eofs/experimental/rotation/standard.py @@ -0,0 +1,306 @@ +"""Rotation of EOFs.""" +# (c) Copyright 2013 Andrew Dawson. All Rights Reserved. +# +# This file is part of eofs. +# +# eofs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# eofs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with eofs. If not, see . +from __future__ import absolute_import + +import numpy as np +import numpy.ma as ma + +from .kernels import KERNEL_MAPPING + + +class Rotator(object): + """Rotate EOFs from the standard `numpy` interface.""" + + def __init__(self, solver, neofs, method='varimax', scaled=True, + kernelargs=None): + """Create an EOF rotator. + + **Arguments:** + + *solver* + An `~eofs.standard.Eof` instance that can generate the EOFs + to be rotated. + + *neofs* + Number of EOFs to use for the rotation. + + **Keyword arguments:** + + *method* + The method to use for rotation. Currently the only accepted + value is 'varimax'. + + *scaled* + If *True* the EOFs are multiplied by the square-root of + their eigenvalue before the rotation. If *False* the + orthonormal EOFs are used for the rotation. Defaults to + *True*. + + **Examples:** + + A varimax rotator based on the first 10 scaled EOFs:: + + solver = Eof(data, weights=weights_array) + rotator = Rotator(solver, 10) + + A varimax rotator based on the first 5 un-scaled EOFs:: + + solver = Eof(data, weights=weights_array) + rotator = Rotator(solver, 5, scaled=False) + + """ + # This is just a reference, not a copy, so it should be lightweight. + self._solver = solver + self._scaled = scaled + self.neofs = neofs + # Retrieve the required quantities from the solver. + eofscaling = 2 if scaled else 0 + eofs = self._solver.eofs(eofscaling=eofscaling, neofs=neofs) + # Remove metadata and store it for later use. + eofs, self._eofmetadata = self.strip_metadata(eofs) + # Remove missing values and metadata and reshape to [neofs, nspace]. + eofs, self._eofinfo = self._to2d(eofs) + # Do the rotation using the appropriate kernel. + kwargs = {} + if kernelargs is not None: + try: + kwargs.update(kernelargs) + except TypeError: + raise TypeError('kernel arguments must be a ' + 'dictionary of keyword arguments') + try: + self._eofs_rot = KERNEL_MAPPING[method.lower()](eofs, **kwargs) + except KeyError: + raise ValueError("unknown rotation method: '{!s}'".format(method)) + # Compute variances of the rotated EOFs as these are used by several + # methods. + self._eofs_rot_var = (self._eofs_rot ** 2).sum(axis=1) + + def eofs(self, neofs=None, renormalize=False): + """Rotated empirical orthogonal functions (EOFs). + + **Optional arguments:** + + *neofs* + Number of EOFs to return. Defaults to all EOFs. If the + number of EOFs requested is more than the number that are + available, then all available EOFs will be returned. + + *renormalize* + If *True* and the rotation was based on scaled EOFs then the + scaling will be removed and the returned rotated EOFs will + be scaled to unit variance. If *False* the returned rotated + EOFs will retain the scaling. + + **Returns:** + + *eofs* + An array with the ordered rotated EOFs along the first + dimension. + + **Examples:** + + All rotated EOFs with scaling:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs() + + All rotated EOFs with scaling removed:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs(renormalize=True) + + The leading rotated EOF with scaling:: + + rotator = Rotator(solver, 10, scaled=True) + rotated_eofs = rotator.eofs(neofs=1) + + """ + # Determine the correct slice. + if neofs > self.neofs: + neofs = self.neofs + slicer = slice(0, neofs) + # Optionally renormalize. + if renormalize and self._scaled: + eofs_rot = self._eofs_rot / \ + np.sqrt(self._eofs_rot_var)[:, np.newaxis] + else: + eofs_rot = self._eofs_rot + eofs_rot = self._from2d(eofs_rot, self._eofinfo)[slicer] + eofs_rot = self.apply_metadata(eofs_rot, self._eofmetadata) + return eofs_rot + + def varianceFraction(self, neigs=None): + """Fractional rotated EOF mode variances. + + The fraction of the total variance explained by each rotated EOF + mode, values between 0 and 1 inclusive. Only meaningful if the + *scaled* option was set to *True* when creating the `Rotator`. + + **Optional argument:** + + *neigs* + Number of eigenvalues to return the fractional variance for. + Defaults to all eigenvalues. If the number of eigenvalues + requested is more than the number that are available, then + fractional variances for all available eigenvalues will be + returned. + + **Returns:** + + *variance_fractions* + An array containing the fractional variances. + + **Examples:** + + The fractional variance represented by each rotated EOF mode:: + + rotator = Rotator(solver, 10, scaled=True) + variance_fractions = rotator.varianceFraction() + + The fractional variance represented by the first rotated EOF mode:: + + rotator = Rotator(solver, 10, scaled=True) + variance_fractions = rotator.varianceFraction(neigs=1) + + """ + if neigs > self.neofs or neigs is None: + neigs = self.neofs + # Compute fractions of variance accounted for by each rotated mode. + eigenvalues = self._solver.eigenvalues(neigs=neigs) + variance_fractions = self._solver.varianceFraction(neigs=neigs) + ev, ev_metadata = self.strip_metadata(eigenvalues) + vf, vf_metadata = self.strip_metadata(variance_fractions) + if self._scaled: + ratio = vf[0] / ev[0] + vf_rot = self._eofs_rot_var * ratio + else: + vf_rot = np.array([1. / float(self._eofs_rot.shape[1])] * neigs) + vf_rot = self.apply_metadata(vf_rot, vf_metadata) + return vf_rot + + def eigenvalues(self, neigs=None): + """Variances of the rotated EOFs.""" + if neigs > self.neofs or neigs is None: + neigs = self.neofs + slicer = slice(0, neigs) + eigenvalues = self._solver.eigenvalues(neigs=neigs) + ev, ev_metadata = self.strip_metadata(eigenvalues) + variances = self._rot_eof_var[slicer] + variances = self.apply_metadata(variances, ev_metadata) + return variances + + def pcs(self, npcs=None, normalized=False): + """Principal component time series (PCs). + + The PC time series associated with the rotated EOFs. + + **Optional arguments:** + + *npcs* + Number of PCs to retrieve. Defaults to all the PCs. If the + number of PCs requested is more than the number that are + available, then all available PCs will be returned. + + *normalized* + If *True* the returned PCs are scaled to unit variance. If + *False* no scaling is done. Defaults to *False*. + + **Returns:** + + *pcs* + An array where the columns are the ordered PCs. + + **Examples:** + + All un-scaled PCs:: + + pcs = rotator.pcs() + + First 3 PCs scaled to unit variance:: + + pcs = rotator.pcs(npcs=3, normalized=True) + + """ + # Determine the correct slice. + if npcs > self.neofs or npcs is None: + npcs = self.neofs + slicer = slice(0, npcs) + # Extract the original field from the solver. + field, fieldinfo = self._to2d(self._solverdata()) + # Compute the PCs. + pcs = np.dot(field, self._eofs_rot.T) + if normalized: + # Optionally standardize the PCs. + pcs /= pcs.std(axis=0, ddof=1) + # Select only the required PCs. + pcs = pcs[:, slicer] + # Collect the metadata used for PCs by the solver and apply it to + # these PCs. + _, pcs_metadata = self.strip_metadata(self._solver.pcs(npcs=npcs)) + pcs = self.apply_metadata(pcs, pcs_metadata) + return pcs + + def _solverdata(self): + """Get the raw data from the EOF solver.""" + return self._solver._data + + def _to2d(self, eofs): + """Re-shape EOFs to 2D and remove missing values.""" + # Re-shape to 2D. + info = {} + neofs = eofs.shape[0] + channels = eofs.shape[1:] + nspace = np.prod(channels) + ev = eofs.reshape([neofs, nspace]) + # Remove missing values. + try: + ev = ev.filled(fill_value=np.nan) + info['filled'] = True + except AttributeError: + info['filled'] = False + nmi = np.where(np.isnan(ev[0]) == False)[0] + ev_nm = ev[:, nmi] + # Record information about the transform. + info['neofs'] = neofs + info['original_shape'] = channels + info['dtype'] = eofs.dtype + info['non_missing_locations'] = nmi + return ev_nm, info + + def _from2d(self, ev, info): + """ + Re-shape a 2D array to full shape and replace missing values. + + """ + channels = np.prod(info['original_shape']) + eofs = np.ones([info['neofs'], channels], + dtype=info['dtype']) * np.nan + eofs[:, info['non_missing_locations']] = ev + if info['filled']: + eofs = ma.array(eofs, mask=np.where(np.isnan(eofs), True, False)) + eofs = eofs.reshape((info['neofs'],) + info['original_shape']) + return eofs + + def apply_metadata(self, var, metadata): + """Convert an array to a metadata holding instance.""" + return var + + def strip_metadata(self, var): + """Convert a metadata holding instance to an array.""" + return var, None diff --git a/lib/eofs/tests/__init__.py b/lib/eofs/tests/__init__.py index e1a7ab3..f6af193 100644 --- a/lib/eofs/tests/__init__.py +++ b/lib/eofs/tests/__init__.py @@ -40,7 +40,7 @@ def _tomasked(self, value): """ return value - def assert_array_almost_equal(self, a, b): + def assert_array_almost_equal(self, a, b, **kwargs): """Assertion that two arrays compare almost equal. The arrays are converted to :class:`numpy.ma.MaskedArray` using @@ -48,15 +48,17 @@ def assert_array_almost_equal(self, a, b): comparison is made. """ - assert_array_almost_equal(self._tomasked(a), self._tomasked(b)) + assert_array_almost_equal(self._tomasked(a), self._tomasked(b), + **kwargs) - def assert_almost_equal(self, a, b): + def assert_almost_equal(self, a, b, **kwargs): """Assertion that two values compare almost equal.""" - assert_almost_equal(self._tomasked(a), self._tomasked(b)) + assert_almost_equal(self._tomasked(a), self._tomasked(b), **kwargs) - def assert_true(self, cond): + def assert_true(self, cond, **kwargs): """Assertion that a condition is True.""" - assert_true(cond) + assert_true(cond, **kwargs) - def assert_equal(self, a, b): - assert_equal(a, b) + def assert_equal(self, a, b, **kwargs): + """Assertion that two values are equal.""" + assert_equal(a, b, **kwargs) diff --git a/lib/eofs/tests/data/latitude_r.npy b/lib/eofs/tests/data/latitude_r.npy new file mode 100644 index 0000000000000000000000000000000000000000..2eecf319f5907b133c0bc5ab6587c5c21690e87a GIT binary patch literal 152 zcmbR27wQ`j$;jZwP_3SlTAW;@Zl$1ZlV+l>qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I$-7CM?b3bhIdz{S9@qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I%o20EHL3bhIdz{SAu+KGYTD-i#8VrXD-W@z99Vm=@i24V>ymIY!ZAXW!r z9UwLYVlyDN24V*wb_HTDAod615Fm~O;y55q2I34L&IRHkAT9^u8fS(B4bBV>&CUR) CJv6fb literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/rotated_eigenvalues.scaled.npy b/lib/eofs/tests/data/rotated_eigenvalues.scaled.npy new file mode 100644 index 0000000000000000000000000000000000000000..903cdd19ca7cb403492fbffe2c7db22d7a16f259 GIT binary patch literal 120 zcmbR27wQ`j$;jZwP_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I%II+{8PwF*dpt5$LT>{NCihl6UJ^EE^b9JJO89J2VS?$9IfziQDu6$f@X K8Sg{JQVswxT_ckK literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/rotated_eigenvalues.unscaled.npy b/lib/eofs/tests/data/rotated_eigenvalues.unscaled.npy new file mode 100644 index 0000000000000000000000000000000000000000..59988bf40aae19612eb84892b1c9c8ffea5460a9 GIT binary patch literal 120 zcmbR27wQ`j$;jZwP_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= oXCxM+0{I%II+{8PwF*dp>)(G6cyG_j00JNES)eqG&j#fK07!x%CjbBd literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/rotated_eofs.scaled.npy b/lib/eofs/tests/data/rotated_eofs.scaled.npy new file mode 100644 index 0000000000000000000000000000000000000000..b946707b2908d253aa3f595fc3e0dc8fd4039e1f GIT binary patch literal 21680 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 Q9YqH#LJMt~)M>$g0YW>sM*si- literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/rotated_pcs.unscaled.npy b/lib/eofs/tests/data/rotated_pcs.unscaled.npy new file mode 100644 index 0000000000000000000000000000000000000000..ad4a8d0320893b1ecbb059ca7972d3c56c944d06 GIT binary patch literal 2080 zcmXw(X*iT^1BS;e)-lG6v6N-9XGwUert;jDR74?JK4cpy%UCM)+NMZU5?PXxElZ1C z$@bhxT9EK6c{7$#3?fS<4PW1n@BDY2f3M>>Z`wNA9B~oASYjeIe3{`sVHym&#vZ?& z8ai|hKUUc3Ft6a_tT12Z|GcGFU^w%S5BK*9VgA{gMmlt(?OS!|(e(c#x^OUETGyTo z1AK0^H{T%u4X&%^#)LGanw7rV%1{P-lG5R1A_1mJ4$SN5$-)8`KhkXBa5HV1X6Da<^S zUq=OLC*#$W^U0v!xO7K|K{txm?aCmuhyiD(l*P|_%czz~og?6I(Q$L01AlEha7=7H za0XpNFYWG{E-Bpvr;0uR-9d3^Tfj~?XD9)&w;vwb{G|jUU(McZysi$}di)%_$uTtX znsLJYd*2cIxA7~cEEUk!s#;l+BLM=O+tl}_62R(@&Z_B2IdD$7b3Ttnh5tt2byBs2 zAl@&_RXQnAp$({f|gaw+W0*WsF8%ks?UG`pVM4 z7zc6`ti(9_L@>ry@$cPBgr%h|!%-77usB3AYTrOK1nI|QLVqhUTs00*sEUE-=nWVq#r zTfD@sFNjOPj2f2l4tbu-#XAM#LGh)S^uYL!$k0r{egE8gBx5w^nQzR$NS&9pX#8z5 zID1^?b6l7puw~-9?qG(I3@_3<#hgY|Q|Ch(DgPaUAFV8L9a==4pPAJp5Z96G0UVaY zUvH6CXB)+;9z3XSSlDy5<`;tCEDmR;lEJiMc7bi%7Qj3GU69a50q?UG+3Dp9AeJ=l zx+O{yWNs3%!m`;h02uDiNp^ zh4<^8pn~07a=KQJ@sY6KKZWILH;~}%;$@*CL=fGlHk%oR2NkR741;?-#3}d4-EX^# z(bVRUTcpQK#A;-lpH=b-8WY(Gs2xKHD{wl{Mv4gaqW@ECWkdyQwh9gbRRkDOs%xgU zPJ`{@optM>OK3xD5b;HgAS_LzcP(6=MLLF#H@Mx#!#ch?FZ+oi81LDXa32r zGB*B(MDBYoLcDv2FXmG@!KS>Y-yPpS9GZGMIB`+r~vw?_T4B2v|rVY6$QK@hDk_hP4;iQBD z3HZSbKdsJ@gIrEfTq*4(%JE*4x9*jIeI5f(?@f|{ubv6xq+dUJMk*nBDXAS*o(w2g zI{X~9a&xV@;zxkD{q38lY{*dG#VJFxnFdkA*NJ{ZE2wWQTYiNm4gXm$+Z@4@hWR($ zPE61+VAHnk51+9+P}en6OJye#)L^IgpYVKxTy`pMzy_}%3GH^7cI`r7Gq5+5B~n50 zr$jl%G6pnT45$Y8VIj*x$nxS$N~XcMrc*@Z)DkW#DL?30eF7b%dExk z=t0`7;Ki0v#GuaC_5@BC=A9H?swfl&zg|_>E5IMfd^dke!eb73d#L-gJ(B_lO)_=& zm198Q*tOcADj9HeY~M`bPcHJf>ih1dUO{lDMp7o@xFj$d-Idq+3E<)=-z7OIXNzmzu})5Cf>Y)eNy;7#t|^ zwR^ZogtS+9tt@W=m|9oJZvOK_Y}Mt5yM>q0yM>GVM~}E@!y(5x`Y#gLIUwt^<3bB^ z);*iIv5tdUH>;;eYoAc71joCY9-<)oXiR|`X%sz_9&wfvy^i46e?NHBBm$;REqgOX zg+Nm(=W&ViZ`3rCX(*k?N1OP{J}xgvfSGFq6UwDQZfEUl_sdeiqhOR@t4{;|w7IV5 zib9}mdLdF|zbJU?R~HgLQH`koFtgb86A#3W@h@n~4WMTdnOBo^DDXg0=5XJV2#iWb zkEq1+(aXPxiszIua4@Pq`eV@|dZ^m+OJn#Ldf=UU^thK8NV7&qEpnGo7RIywLF*et r^Kb=oqk#bHZ;G_+jrfY3K6+6>NM#;fXv8Lc`6LCuF3@tdka6_C$f(gj literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/rotated_variance.scaled.npy b/lib/eofs/tests/data/rotated_variance.scaled.npy new file mode 100644 index 0000000000000000000000000000000000000000..692b53838f7db454626079ff2f010fae1c7c5261 GIT binary patch literal 100 zcmbR27wQ`j$;jZwP_3SlTAW;@Zl$1ZlV+l>qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= qXCxM+0{I%II+{8PwF*dp>*FC^r>W`gjxXnlIA*W-@9;2xkplp}RUa|{ literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/rotated_variance.unscaled.npy b/lib/eofs/tests/data/rotated_variance.unscaled.npy new file mode 100644 index 0000000000000000000000000000000000000000..684d6583638a9aec5728bbfd18a12b7d55ad7bd4 GIT binary patch literal 100 zcmbR27wQ`j$;jZwP_3SlTAW;@Zl$1ZlV+l>qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= bXCxM+0{I%II+{8PwF*dpOMjuQ9XbX8nJgQl literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/sst_r.npy b/lib/eofs/tests/data/sst_r.npy new file mode 100644 index 0000000000000000000000000000000000000000..30fbafa441096c7bf084f0448e0c943e08f5125d GIT binary patch literal 216080 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%0A4LB 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 z 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 literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/data/time_r.npy b/lib/eofs/tests/data/time_r.npy new file mode 100644 index 0000000000000000000000000000000000000000..2981d653f4a974a0f2371be5e7cc58fd4e5a810d GIT binary patch literal 480 zcmbR27wQ`j$;jZwP_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I%I20EHL3bhIdz{LOr6NKM7fM^Ft2>l@sLQj|jp$$$!=m+1S;;Qe!>J5S+ z^o0fp-LMWSeg`Vf`5vsUz#Kv=q(bNmlc3@UAhf_c2>pQf16chI6$ss74WT1~Ahbay zgyv{~&^M+*=oM=rbi)w{9dR2%YkY#xKR7;u&AlKGp;wqe=n7v5?U4eZ6{;chkBJca z#0m&KV?Ts0xCWs;-a=>zmQP@FUr0gd1BMWKh6jYsh=S454@Ig3uio KA#}ovPYwX3zJg-_ literal 0 HcmV?d00001 diff --git a/lib/eofs/tests/reference.py b/lib/eofs/tests/reference.py index 3a27bb3..34f26f2 100644 --- a/lib/eofs/tests/reference.py +++ b/lib/eofs/tests/reference.py @@ -241,3 +241,122 @@ def reference_multivariate_solution(container_type, weights): except TypeError: solution[var] = None, None return solution + + +def _read_reference_rotated_solution(scaled): + if scaled: + ident = 'scaled' + else: + ident = 'unscaled' + field_names = ['time_r', + 'latitude_r', + 'longitude_r', + 'sst_r', + 'rotated_eigenvalues.{!s}'.format(ident), + 'rotated_eofs.{!s}'.format(ident), + 'rotated_pcs.{!s}'.format(ident), + 'rotated_variance.{!s}'.format(ident),] + fields = {name.split('.')[0]: _tomasked(_retrieve_test_field(name)) + for name in field_names} + fields['sst_r'] -= fields['sst_r'].mean(axis=0) + fields['rotated_pcs'] = fields['rotated_pcs'].transpose() + return fields + + +def reference_rotated_solution(container_type, scaled): + """Obtain a reference rotated EOF analysis solution. + + **Arguments:** + + *container_type* + Either 'standard', 'cdms', or 'iris'. + + *scaled* + If *True* use scaled EOFs, if *False* use un-scaled EOFs. + + """ + container_type = container_type.lower() + if container_type not in ('standard', 'iris', 'cdms'): + raise ValueError("unknown container type " + "'{!s}'".format(container_type)) + solution = _read_reference_rotated_solution(scaled) + time_units = 'days since 1800-1-1 00:00:00' + neofs = len(solution['rotated_eigenvalues']) + if container_type == 'cdms': + try: + time_dim = cdms2.createAxis(solution['time_r'], id='time') + time_dim.designateTime() + time_dim.units = time_units + lat_dim = cdms2.createAxis(solution['latitude_r'], id='latitude') + lat_dim.designateLatitude() + lon_dim = cdms2.createAxis(solution['longitude_r'], id='longitude') + lon_dim.designateLongitude() + eof_dim = cdms2.createAxis(np.arange(1, neofs+1), id='eof') + eof_dim.long_name = 'eof_number' + solution['sst_r'] = cdms2.createVariable( + solution['sst_r'], + axes=[time_dim, lat_dim, lon_dim], + id='sst') + solution['rotated_eigenvalues'] = cdms2.createVariable( + solution['rotated_eigenvalues'], + axes=[eof_dim], + id='eigenvalues') + solution['rotated_eofs'] = cdms2.createVariable( + solution['rotated_eofs'], + axes=[eof_dim, lat_dim, lon_dim], + id='eofs') + solution['rotated_pcs'] = cdms2.createVariable( + solution['rotated_pcs'], + axes=[time_dim, eof_dim], + id='pcs') + solution['rotated_variance'] = cdms2.createVariable( + solution['rotated_variance'], + axes=[eof_dim], + id='variance') + except NameError: + raise ValueError("cannot use container 'cdms' without the " + "cdms2 module") + elif container_type == 'iris': + try: + time_dim = DimCoord(solution['time_r'], + standard_name='time', + units=Unit(time_units, 'gregorian')) + lat_dim = DimCoord(solution['latitude_r'], + standard_name='latitude', + units='degrees_north') + lat_dim.guess_bounds() + lon_dim = DimCoord(solution['longitude_r'], + standard_name='longitude', + units='degrees_east') + lon_dim.guess_bounds() + eof_dim = DimCoord(np.arange(1, neofs+1), + long_name='eof') + solution['sst_r']= Cube( + solution['sst_r'], + dim_coords_and_dims=zip((time_dim, lat_dim, lon_dim), + range(3)), + long_name='sst') + solution['rotated_eigenvalues']= Cube( + solution['rotated_eigenvalues'], + dim_coords_and_dims=zip((eof_dim,), + range(1)), + long_name='rotated_eigenvalues') + solution['rotated_eofs']= Cube( + solution['rotated_eofs'], + dim_coords_and_dims=zip((eof_dim, lat_dim, lon_dim), + range(3)), + long_name='eofs') + solution['rotated_pcs']= Cube( + solution['rotated_pcs'], + dim_coords_and_dims=zip((time_dim, eof_dim), + range(2)), + long_name='pcs') + solution['rotated_variance']= Cube( + solution['rotated_variance'], + dim_coords_and_dims=zip((eof_dim,), + range(1)), + long_name='variance') + except NameError: + raise ValueError("cannot use container 'iris' without the " + "iris module") + return solution diff --git a/lib/eofs/tests/test_rotation.py b/lib/eofs/tests/test_rotation.py new file mode 100644 index 0000000..34af78e --- /dev/null +++ b/lib/eofs/tests/test_rotation.py @@ -0,0 +1,200 @@ +"""Test EOF rotations against reference solutions.""" +# (c) Copyright 2013 Andrew Dawson. All Rights Reserved. +# +# This file is part of eofs. +# +# eofs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# eofs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with eofs. If not, see . +from nose import SkipTest +import numpy as np +try: + from iris.cube import Cube +except: + pass + +import eofs +import eofs.experimental.rotation as rotation +from eofs.tests import EofsTest + +from utils import sign_adjustments, error +from reference import reference_rotated_solution + + +# Create a mapping from interface name to solver class. +solvers = {'standard': eofs.standard.Eof} +try: + solvers['cdms'] = eofs.cdms.Eof +except AttributeError: + pass +try: + solvers['iris'] = eofs.iris.Eof +except AttributeError: + pass + +# Create a mapping from interface name to rotator class. +rotators = {'standard': rotation.standard.Rotator} +try: + rotators['cdms'] = rotation.cdms.Rotator +except AttributeError: + pass +try: + rotators['iris'] = rotation.iris.Rotator +except AttributeError: + pass + + +class RotatorTest(EofsTest): + """Base class for all rotation test classes.""" + interface = None + scaled = None + method = None + neofs = 5 + + @classmethod + def setup_class(cls): + try: + cls.solution = reference_rotated_solution(cls.interface, + cls.scaled) + except ValueError: + raise SkipTest('library component not available ' + 'for {!s} interface'.format(cls.interface)) + try: + # use default kws for solver, already well tested for weights etc. + solver = solvers[cls.interface](cls.solution['sst_r'], ddof=0) + cls.rotator = rotators[cls.interface](solver, + cls.neofs, + method=cls.method, + scaled=cls.scaled) + except KeyError: + raise SkipTest('library component not available ' + 'for {!s} interface'.format(cls.interface)) + + def test_eofs(self): + # generate EOF tests for normalized and non-normalized EOFs + for renormalize in (False, True): + yield self.check_eofs, renormalize + + def check_eofs(self, renormalize): + # rotated EOFs should match the (possibly normalized) reference + # solution + eofs = self._tomasked( + self.rotator.eofs(neofs=self.neofs, renormalize=renormalize)) + reofs = self._tomasked(self.solution['rotated_eofs']).copy() + eofs *= sign_adjustments(eofs, reofs) + if renormalize: + variance = (reofs ** 2.).sum(axis=1).sum(axis=1) + reofs = reofs / np.sqrt(variance)[:, np.newaxis, np.newaxis] + self.assert_almost_equal(error(eofs, reofs), 0, places=3) + + def test_pcs(self): + # generate PC tests for normalized and non-normalized PCs + for normalized in (False, True): + yield self.check_pcs, normalized + + def check_pcs(self, normalized): + # rotated PCs should math the (possibly normalized) reference solution + pcs = self._tomasked( + self.rotator.pcs(npcs=self.neofs, normalized=normalized)) + rpcs = self._tomasked(self.solution['rotated_pcs']).copy() + pcs *= sign_adjustments(pcs.transpose(), rpcs.transpose()).transpose() + if normalized: + rpcs /= rpcs.std(axis=0, ddof=1) + self.assert_almost_equal(error(pcs, rpcs), 0, places=3) + + def test_varianceFraction(self): + # rotated variance fractions should match the reference solution + if not self.scaled: + # variance fraction is not meaningful when normalized EOFs are + # rotated + return + variance = self._tomasked( + self.rotator.varianceFraction(neigs=self.neofs)) * 100. + rvariance = self._tomasked(self.solution['rotated_variance']) + self.assert_array_almost_equal(variance, rvariance, decimal=3) + + +#----------------------------------------------------------------------------- +# Tests for the standard interface + + +class StandardRotatorTest(RotatorTest): + """Base class for all standard interface solution test cases.""" + interface = 'standard' + + def _tomasked(self, value): + return value + + +class TestStandardScaledVarimax(StandardRotatorTest): + """Rotation of scaled EOFs.""" + scaled = True + method = 'varimax' + + +class TestStandardUnscaledVarimax(StandardRotatorTest): + """Rotation of un-scaled EOFs.""" + scaled = False + method = 'varimax' + + +#----------------------------------------------------------------------------- +# Tests for the cdms interface + + +class CDMSRotatorTest(RotatorTest): + """Base class for all cdms interface solution test cases.""" + interface = 'cdms' + + def _tomasked(self, value): + try: + return value.asma() + except AttributeError: + return value + + +class TestCDMSRotatorScaledVarimax(CDMSRotatorTest): + """Rotation of scaled EOFs.""" + scaled = True + method = 'varimax' + + +class TestCDMSRotatorUnscaledVarimax(CDMSRotatorTest): + """Rotation of un-scaled EOFs.""" + scaled = False + method = 'varimax' + + +#----------------------------------------------------------------------------- +# Tests for the cdms interface + + +class IrisRotatorTest(RotatorTest): + """Base class for all iris interface solution test cases.""" + interface = 'iris' + + def _tomasked(self, value): + if type(value) is not Cube: + return value + return value.data + + +class TestIrisRotatorScaledVarimax(IrisRotatorTest): + """Rotation of scaled EOFs.""" + scaled = True + method = 'varimax' + + +class TestIrisRotatorUnscaledVarimax(IrisRotatorTest): + """Rotation of un-scaled EOFs.""" + scaled = False + method = 'varimax' diff --git a/setup.py b/setup.py index 053a1ac..3806450 100644 --- a/setup.py +++ b/setup.py @@ -25,6 +25,7 @@ packages = ['eofs', 'eofs.tools', 'eofs.multivariate', + 'eofs.experimental.rotation', 'eofs.examples',] package_data = {'eofs.examples': ['example_data/*']} diff --git a/tests.py b/tests.py index 55e0856..7b73b42 100644 --- a/tests.py +++ b/tests.py @@ -25,6 +25,7 @@ 'eofs.tests.test_tools', 'eofs.tests.test_multivariate_solution', 'eofs.tests.test_multivariate_error_handling', + 'eofs.tests.test_rotation', ] From 8278965a804b60bd8e990d06af63a45db98031d2 Mon Sep 17 00:00:00 2001 From: Andrew Dawson Date: Sat, 6 Apr 2013 09:59:49 +0100 Subject: [PATCH 2/4] Added experimental packaged to setup.py. --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index 3806450..013f6f7 100644 --- a/setup.py +++ b/setup.py @@ -25,6 +25,7 @@ packages = ['eofs', 'eofs.tools', 'eofs.multivariate', + 'eofs.experimental', 'eofs.experimental.rotation', 'eofs.examples',] From 8986972ed3e82888531a0543bcd792153078a88d Mon Sep 17 00:00:00 2001 From: nicrie Date: Mon, 8 Nov 2021 20:40:32 +0100 Subject: [PATCH 3/4] reorder rotated EOFs according to variance --- lib/eofs/experimental/rotation/standard.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/lib/eofs/experimental/rotation/standard.py b/lib/eofs/experimental/rotation/standard.py index cf5b3ba..75273e3 100644 --- a/lib/eofs/experimental/rotation/standard.py +++ b/lib/eofs/experimental/rotation/standard.py @@ -90,6 +90,10 @@ def __init__(self, solver, neofs, method='varimax', scaled=True, # Compute variances of the rotated EOFs as these are used by several # methods. self._eofs_rot_var = (self._eofs_rot ** 2).sum(axis=1) + self._var_idx = np.argsort(self._eofs_rot_var)[::-1] + # Reorder rotated EOFs according to their variance + self._eofs_rot = self._eofs_rot[self._var_idx] + self._eofs_rot_var = self._eofs_rot_var[self._var_idx] def eofs(self, neofs=None, renormalize=False): """Rotated empirical orthogonal functions (EOFs). From 67eafec9ca9b71966bf7da3e482b08a7b5666fc2 Mon Sep 17 00:00:00 2001 From: nicrie Date: Sat, 13 Nov 2021 23:08:24 +0000 Subject: [PATCH 4/4] add Varimax rotation functionality for standard class --- lib/eofs/experimental/rotation/kernels.py | 4 +- lib/eofs/experimental/rotation/standard.py | 353 ++++++++++++++++++++- 2 files changed, 341 insertions(+), 16 deletions(-) diff --git a/lib/eofs/experimental/rotation/kernels.py b/lib/eofs/experimental/rotation/kernels.py index 1380a6b..f823f9b 100644 --- a/lib/eofs/experimental/rotation/kernels.py +++ b/lib/eofs/experimental/rotation/kernels.py @@ -58,7 +58,7 @@ def _varimax_kernel(eofs, eps=1e-10, itermax=1000, kaisernorm=True): rotation = np.eye(neofs, dtype=eofs.dtype) delta = 0. # Iteratively compute the rotation matrix. - for i in xrange(itermax): + for i in range(itermax): z = np.dot(eofs.T, rotation) b = np.dot(eofs, z ** 3 - np.dot(z, np.diag((z ** 2).sum(axis=0)) / nspace)) @@ -74,7 +74,7 @@ def _varimax_kernel(eofs, eps=1e-10, itermax=1000, kaisernorm=True): if kaisernorm: # Remove the normalization. reofs *= scale - return reofs + return reofs, rotation KERNEL_MAPPING = { diff --git a/lib/eofs/experimental/rotation/standard.py b/lib/eofs/experimental/rotation/standard.py index 75273e3..cce12aa 100644 --- a/lib/eofs/experimental/rotation/standard.py +++ b/lib/eofs/experimental/rotation/standard.py @@ -16,11 +16,14 @@ # You should have received a copy of the GNU General Public License # along with eofs. If not, see . from __future__ import absolute_import +import collections +import warnings import numpy as np import numpy.ma as ma from .kernels import KERNEL_MAPPING +from ...tools.standard import correlation_map, covariance_map class Rotator(object): @@ -84,14 +87,15 @@ def __init__(self, solver, neofs, method='varimax', scaled=True, raise TypeError('kernel arguments must be a ' 'dictionary of keyword arguments') try: - self._eofs_rot = KERNEL_MAPPING[method.lower()](eofs, **kwargs) + self._eofs_rot, R = KERNEL_MAPPING[method.lower()](eofs, **kwargs) + self._rotation_matrix = R except KeyError: raise ValueError("unknown rotation method: '{!s}'".format(method)) # Compute variances of the rotated EOFs as these are used by several # methods. self._eofs_rot_var = (self._eofs_rot ** 2).sum(axis=1) self._var_idx = np.argsort(self._eofs_rot_var)[::-1] - # Reorder rotated EOFs according to their variance + # Reorder rotated EOFs according to their variance. self._eofs_rot = self._eofs_rot[self._var_idx] self._eofs_rot_var = self._eofs_rot_var[self._var_idx] @@ -136,7 +140,7 @@ def eofs(self, neofs=None, renormalize=False): """ # Determine the correct slice. - if neofs > self.neofs: + if (neofs is None) or neofs > self.neofs: neofs = self.neofs slicer = slice(0, neofs) # Optionally renormalize. @@ -183,8 +187,9 @@ def varianceFraction(self, neigs=None): variance_fractions = rotator.varianceFraction(neigs=1) """ - if neigs > self.neofs or neigs is None: + if (neigs is None) or (neigs > self.neofs): neigs = self.neofs + slicer = slice(0, neigs) # Compute fractions of variance accounted for by each rotated mode. eigenvalues = self._solver.eigenvalues(neigs=neigs) variance_fractions = self._solver.varianceFraction(neigs=neigs) @@ -192,7 +197,7 @@ def varianceFraction(self, neigs=None): vf, vf_metadata = self.strip_metadata(variance_fractions) if self._scaled: ratio = vf[0] / ev[0] - vf_rot = self._eofs_rot_var * ratio + vf_rot = self._eofs_rot_var[slicer] * ratio else: vf_rot = np.array([1. / float(self._eofs_rot.shape[1])] * neigs) vf_rot = self.apply_metadata(vf_rot, vf_metadata) @@ -205,7 +210,7 @@ def eigenvalues(self, neigs=None): slicer = slice(0, neigs) eigenvalues = self._solver.eigenvalues(neigs=neigs) ev, ev_metadata = self.strip_metadata(eigenvalues) - variances = self._rot_eof_var[slicer] + variances = self._eofs_rot_var[slicer] variances = self.apply_metadata(variances, ev_metadata) return variances @@ -242,16 +247,19 @@ def pcs(self, npcs=None, normalized=False): """ # Determine the correct slice. - if npcs > self.neofs or npcs is None: + if (npcs is None) or (npcs > self.neofs): npcs = self.neofs slicer = slice(0, npcs) - # Extract the original field from the solver. - field, fieldinfo = self._to2d(self._solverdata()) - # Compute the PCs. - pcs = np.dot(field, self._eofs_rot.T) - if normalized: - # Optionally standardize the PCs. - pcs /= pcs.std(axis=0, ddof=1) + # Compute the PCs: + # 1. Obtain the non-rotated PCs. + pcs = self._solver.pcs(npcs=self.neofs, pcscaling=1) + # 2. Apply the rotation matrix to standardized PCs. + pcs = np.dot(pcs, self._rotation_matrix) + # 3. Reorder according to variance. + pcs = pcs[:, self._var_idx] + if not normalized: + # Optionally scale by square root of variance of rotated EOFs. + pcs *= np.sqrt(self._eofs_rot_var) # Select only the required PCs. pcs = pcs[:, slicer] # Collect the metadata used for PCs by the solver and apply it to @@ -260,6 +268,323 @@ def pcs(self, npcs=None, normalized=False): pcs = self.apply_metadata(pcs, pcs_metadata) return pcs + def eofsAsCorrelation(self, neofs=None): + """Correlation map rotated EOFs. + + Rotated empirical orthogonal functions (EOFs) expressed as the + correlation between the rotated principal component time series (PCs) + and the time series of the `Eof` input *dataset* at each grid + point. + + .. note:: + + These are not related to the EOFs computed from the + correlation matrix. + + **Optional argument:** + + *neofs* + Number of EOFs to return. Defaults to all EOFs. If the + number of EOFs requested is more than the number that are + available, then all available EOFs will be returned. + + **Returns:** + + *eofs* + An array with the ordered EOFs along the first dimension. + + **Examples:** + + All EOFs:: + + eofs = rotator.eofsAsCorrelation() + + The leading EOF:: + + eof1 = rotator.eofsAsCorrelation(neofs=1) + + """ + # Get original dimensions of data + records = self._solver._records + originalshape = self._solver._originalshape + # Retrieve the specified number of PCs. + pcs = self.pcs(npcs=neofs, normalized=True) + # Compute the correlation of the PCs with the input field. + c = correlation_map( + pcs, + self._solverdata().reshape((records,) + originalshape)) + # The results of the correlation_map function will be a masked array. + # For consistency with other return values, this is converted to a + # numpy array filled with numpy.nan. + if not self._solver._filled: + c = c.filled(fill_value=np.nan) + return c + + def eofsAsCovariance(self, neofs=None, normalized=True): + """Covariance map rotated EOFs. + + Rotated empirical orthogonal functions (EOFs) expressed as the + covariance between the rotated principal component time series (PCs) + and the time series of the `Eof` input *dataset* at each grid + point. + + **Optional arguments:** + + *neofs* + Number of EOFs to return. Defaults to all EOFs. If the + number of EOFs requested is more than the number that are + available, then all available EOFs will be returned. + + *pcscaling* + Set the scaling of the PCs used to compute covariance. The + following values are accepted: + *normalized* + If *True* the PCs used to compute covariance are scaled to + unit variance. If *False* no scaling is done. + Defaults to *True* which is the same as scaling option *1* + for non-rotated covariance maps. + + **Returns:** + + *eofs* + An array with the ordered EOFs along the first dimension. + + **Examples:** + + All EOFs:: + + eofs = rotator.eofsAsCovariance() + + The leading EOF:: + + eof1 = rotator.eofsAsCovariance(neofs=1) + + The leading EOF using un-scaled PCs:: + + eof1 = rotator.eofsAsCovariance(neofs=1, normalized=False) + + """ + # Get original dimensions of data + records = self._solver._records + originalshape = self._solver._originalshape + # Retrieve the specified number of PCs. + pcs = self.pcs(npcs=neofs, normalized=normalized) + # Divide the input data by the weighting (if any) before computing + # the covariance maps. + data = self._solverdata().reshape((records,) + originalshape) + if self._solver._weights is not None: + with warnings.catch_warnings(): + warnings.simplefilter('ignore', RuntimeWarning) + data /= self._solver._weights + c = covariance_map(pcs, data, ddof=self._solver._ddof) + # The results of the covariance_map function will be a masked array. + # For consitsency with other return values, this is converted to a + # numpy array filled with numpy.nan. + if not self._solver._filled: + c = c.filled(fill_value=np.nan) + return c + + def reconstuctedField(self, neofs): + """Reconstructed data field based on a subset of rotated EOFs. + + If weights were passed to the `Eof` instance the returned + reconstructed field will automatically have this weighting + removed. Otherwise the returned field will have the same + weighting as the `Eof` input *dataset*. + + **Argument:** + + *neofs* + Number of EOFs to use for the reconstruction. If the + number of EOFs requested is more than the number that are + available, then all available EOFs will be used for the + reconstruction. Alternatively this argument can be an + iterable of mode numbers (where the first mode is 1) in + order to facilitate reconstruction with arbitrary modes. + + **Returns:** + + *reconstruction* + An array the same shape as the `Eof` input *dataset* + contaning the reconstruction using *neofs* EOFs. + + **Examples:** + + Reconstruct the input field using 3 rotated EOFs:: + + reconstruction = rotator.reconstructedField(3) + + Reconstruct the input field using rotated EOFs 1, 2 and 5:: + + reconstruction = rotator.reconstuctedField([1, 2, 5]) + + """ + # Determine how the PCs and EOFs will be selected. + if isinstance(neofs, collections.Iterable): + modes = [m - 1 for m in neofs] + else: + modes = slice(0, neofs) + # Create array containing rotated EOFs including not a number entries + # of original input data. + originalshape = self._solver._originalshape + channels = np.product(originalshape) + nan_idx = np.isnan(self._solver._flatE).all(axis=0) + L = self._eofs_rot[modes] + neofs = L.shape[0] + loadings = np.zeros((neofs, channels)) * np.nan + loadings[:, ~nan_idx] = L + # Project principal components onto the rotated EOFs to + # compute the reconstructed field. + P = self.pcs(npcs=None, normalized=True)[:, modes] + rval = np.dot(P, loadings) + # Reshape the reconstructed field so it has the same shape as the + # input data set. + records = self._solver._records + rval = rval.reshape((records,) + originalshape) + # Un-weight the reconstructed field if weighting was performed on + # the input data set. + if self._solver._weights is not None: + rval = rval / self._solver._weights + # Return the reconstructed field. + if self._solver._filled: + rval = ma.array(rval, mask=np.where(np.isnan(rval), True, False)) + return rval + + def projectField(self, field, neofs=None, eofscaling=0, weighted=True): + """Project a field onto the rotated EOFs. + + Given a data set, projects it onto the rotated EOFs to generate a + corresponding set of pseudo-PCs. + + **Argument:** + + *field* + A `numpy.ndarray` or `numpy.ma.MaskedArray` with two or more + dimensions containing the data to be projected onto the + EOFs. It must have the same corresponding spatial dimensions + (including missing values in the same places) as the `Eof` + input *dataset*. *field* may have a different length time + dimension to the `Eof` input *dataset* or no time dimension + at all. + + **Optional arguments:** + + *neofs* + Number of EOFs to project onto. Defaults to all EOFs. If the + number of EOFs requested is more than the number that are + available, then the field will be projected onto all + available EOFs. + + *eofscaling* + Set the scaling of the EOFs that are projected onto. The + following values are accepted: + + * *0* : Un-scaled EOFs (default). + * *1* : EOFs are divided by the square-root of their + eigenvalue. + * *2* : EOFs are multiplied by the square-root of their + eigenvalue. + + *weighted* + If *True* then *field* is weighted using the same weights + used for the EOF analysis prior to projection. If *False* + then no weighting is applied. Defaults to *True* (weighting + is applied). Generally only the default setting should be + used. + + **Returns:** + + *pseudo_pcs* + An array where the columns are the ordered pseudo-PCs. + + **Examples:** + + Project a data set onto all EOFs:: + + pseudo_pcs = solver.projectField(data) + + Project a data set onto the four leading EOFs:: + + pseudo_pcs = solver.projectField(data, neofs=4) + + """ + # Check that the shape/dimension of the data set is compatible with + # the EOFs. + solver = self._solver + solver._verify_projection_shape(field, solver._originalshape) + input_ndim = field.ndim + eof_ndim = len(solver._originalshape) + 1 + # Create a slice object for truncating the EOFs. + slicer = slice(0, neofs) + # If required, weight the data set with the same weighting that was + # used to compute the EOFs. + field = field.copy() + if weighted: + wts = solver.getWeights() + if wts is not None: + field = field * wts + # Fill missing values with NaN if this is a masked array. + try: + field = field.filled(fill_value=np.nan) + except AttributeError: + pass + # Flatten the data set into [time, space] dimensionality. + if eof_ndim > input_ndim: + field = field.reshape((1,) + field.shape) + records = field.shape[0] + channels = np.product(field.shape[1:]) + field_flat = field.reshape([records, channels]) + # Locate the non-missing values and isolate them. + if not solver._valid_nan(field_flat): + raise ValueError('missing values detected in different ' + 'locations at different times') + nonMissingIndex = np.where(np.logical_not(np.isnan(field_flat[0])))[0] + field_flat = field_flat[:, nonMissingIndex] + # Locate the non-missing values in the EOFs and check they match those + # in the data set, then isolate the non-missing values. + eofNonMissingIndex = np.where( + np.logical_not(np.isnan(solver._flatE[0])))[0] + if eofNonMissingIndex.shape != nonMissingIndex.shape or \ + (eofNonMissingIndex != nonMissingIndex).any(): + raise ValueError('field and EOFs have different ' + 'missing value locations') + # The correct projection of a new data field on the rotated EOFs + # follows the following equation: + # PC_new = x_new @ E @ L^(1/2) @ R + # where + # PC_new : standardized pseudo-PC for new input data field + # x_new : new input data field + # E : non-rotated EOFs (eigenvectors) + # L^(1/2) : Square root of diagonal matrix containing the eigenvalues + # R : rotation matrix + eofs_flat = solver._flatE[:self.neofs, eofNonMissingIndex] + projected_pcs = field_flat @ eofs_flat.T + projected_pcs /= np.sqrt(solver._L[:self.neofs]) + projected_pcs = projected_pcs @ self._rotation_matrix + # Reorder the obtained (standardized) rotated EOFs according + # to their variance. + projected_pcs = projected_pcs[:, self._var_idx] + # Select desired PCs + projected_pcs = projected_pcs[:, slicer] + # PCs are standardized. In order to match the correct eofscaling + # we have to multiply the PCs with + # the square root of the rotated variance (eofscaling == 1) + # the rotated variance (eofscaling == 2) + if eofscaling == 0: + pass + elif eofscaling == 1: + projected_pcs *= np.sqrt(self._eofs_rot_var[slicer]) + elif eofscaling == 2: + projected_pcs *= self._eofs_rot_var[slicer] + else: + raise ValueError('invalid PC scaling option: ' + '{!s}'.format(eofscaling)) + if eof_ndim > input_ndim: + # If an extra dimension was introduced, remove it before returning + # the projected PCs. + projected_pcs = projected_pcs[0] + return projected_pcs + def _solverdata(self): """Get the raw data from the EOF solver.""" return self._solver._data