copulas 0.12.4.dev3__py3-none-any.whl

copulas/univariate/gamma.py

@@ -0,0 +1,38 @@
+"""GammaUnivariate module."""
+
+import numpy as np
+from scipy.stats import gamma
+
+from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+
+
+class GammaUnivariate(ScipyModel):
+    """Wrapper around scipy.stats.gamma.
+
+    Documentation: https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gamma.html
+    """
+
+    PARAMETRIC = ParametricType.PARAMETRIC
+    BOUNDED = BoundedType.SEMI_BOUNDED
+    MODEL_CLASS = gamma
+
+    def _fit_constant(self, X):
+        self._params = {
+            'a': 0.0,
+            'loc': np.unique(X)[0],
+            'scale': 0.0,
+        }
+
+    def _fit(self, X):
+        a, loc, scale = gamma.fit(X)
+        self._params = {
+            'a': a,
+            'loc': loc,
+            'scale': scale,
+        }
+
+    def _is_constant(self):
+        return self._params['scale'] == 0
+
+    def _extract_constant(self):
+        return self._params['loc']

copulas/univariate/gaussian.py

@@ -0,0 +1,27 @@
+"""GaussianUnivariate module."""
+
+import numpy as np
+from scipy.stats import norm
+
+from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+
+
+class GaussianUnivariate(ScipyModel):
+    """Gaussian univariate model."""
+
+    PARAMETRIC = ParametricType.PARAMETRIC
+    BOUNDED = BoundedType.UNBOUNDED
+
+    MODEL_CLASS = norm
+
+    def _fit_constant(self, X):
+        self._params = {'loc': np.unique(X)[0], 'scale': 0}
+
+    def _fit(self, X):
+        self._params = {'loc': np.mean(X), 'scale': np.std(X)}
+
+    def _is_constant(self):
+        return self._params['scale'] == 0
+
+    def _extract_constant(self):
+        return self._params['loc']

copulas/univariate/gaussian_kde.py

@@ -0,0 +1,192 @@
+"""GaussianKDE module."""
+
+import numpy as np
+from scipy.special import ndtr
+from scipy.stats import gaussian_kde
+
+from copulas.optimize import bisect, chandrupatla
+from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+from copulas.utils import EPSILON, random_state, store_args, validate_random_state
+
+
+class GaussianKDE(ScipyModel):
+    """A wrapper for gaussian Kernel density estimation.
+
+    It was implemented in scipy.stats toolbox. gaussian_kde is slower than statsmodels
+    but allows more flexibility.
+
+    When a sample_size is provided the fit method will sample the
+    data, and mask the real information. Also, ensure the number of
+    entries will be always the value of sample_size.
+
+    Args:
+        sample_size(int): amount of parameters to sample
+    """
+
+    PARAMETRIC = ParametricType.NON_PARAMETRIC
+    BOUNDED = BoundedType.UNBOUNDED
+    MODEL_CLASS = gaussian_kde
+
+    @store_args
+    def __init__(self, sample_size=None, random_state=None, bw_method=None, weights=None):
+        self.random_state = validate_random_state(random_state)
+        self._sample_size = sample_size
+        self.bw_method = bw_method
+        self.weights = weights
+
+    def _get_model(self):
+        dataset = self._params['dataset']
+        self._sample_size = self._sample_size or len(dataset)
+        return gaussian_kde(dataset, bw_method=self.bw_method, weights=self.weights)
+
+    def _get_bounds(self):
+        X = self._params['dataset']
+        lower = np.min(X) - (5 * np.std(X))
+        upper = np.max(X) + (5 * np.std(X))
+
+        return lower, upper
+
+    def probability_density(self, X):
+        """Compute the probability density for each point in X.
+
+        Arguments:
+            X (numpy.ndarray):
+                Values for which the probability density will be computed.
+                It must have shape (n, 1).
+
+        Returns:
+            numpy.ndarray:
+                Probability density values for points in X.
+
+        Raises:
+            NotFittedError:
+                if the model is not fitted.
+        """
+        self.check_fit()
+        return self._model.evaluate(X)
+
+    @random_state
+    def sample(self, n_samples=1):
+        """Sample values from this model.
+
+        Argument:
+            n_samples (int):
+                Number of values to sample
+
+        Returns:
+            numpy.ndarray:
+                Array of shape (n_samples, 1) with values randomly
+                sampled from this model distribution.
+
+        Raises:
+            NotFittedError:
+                if the model is not fitted.
+        """
+        self.check_fit()
+        return self._model.resample(size=n_samples)[0]
+
+    def cumulative_distribution(self, X):
+        """Compute the cumulative distribution value for each point in X.
+
+        Arguments:
+            X (numpy.ndarray):
+                Values for which the cumulative distribution will be computed.
+                It must have shape (n, 1).
+
+        Returns:
+            numpy.ndarray:
+                Cumulative distribution values for points in X.
+
+        Raises:
+            NotFittedError:
+                if the model is not fitted.
+        """
+        self.check_fit()
+        X = np.array(X)
+        stdev = np.sqrt(self._model.covariance[0, 0])
+        lower = ndtr((self._get_bounds()[0] - self._model.dataset) / stdev)[0]
+        uppers = ndtr((X[:, None] - self._model.dataset) / stdev)
+        return (uppers - lower).dot(self._model.weights)
+
+    def percent_point(self, U, method='chandrupatla'):
+        """Compute the inverse cumulative distribution value for each point in U.
+
+        Arguments:
+            U (numpy.ndarray):
+                Values for which the cumulative distribution will be computed.
+                It must have shape (n, 1) and values must be in [0,1].
+            method (str):
+                Whether to use the `chandrupatla` or `bisect` solver.
+
+        Returns:
+            numpy.ndarray:
+                Inverse cumulative distribution values for points in U.
+
+        Raises:
+            NotFittedError:
+                if the model is not fitted.
+        """
+        self.check_fit()
+
+        if len(U.shape) > 1:
+            raise ValueError(f'Expected 1d array, got {(U,)}.')
+
+        if np.any(U > 1.0) or np.any(U < 0.0):
+            raise ValueError('Expected values in range [0.0, 1.0].')
+
+        is_one = U >= 1.0 - EPSILON
+        is_zero = U <= EPSILON
+        is_valid = ~(is_zero | is_one)
+
+        lower, upper = self._get_bounds()
+
+        def _f(X):
+            return self.cumulative_distribution(X) - U[is_valid]
+
+        X = np.zeros(U.shape)
+        X[is_one] = float('inf')
+        X[is_zero] = float('-inf')
+        if is_valid.any():
+            lower = np.full(U[is_valid].shape, lower)
+            upper = np.full(U[is_valid].shape, upper)
+            if method == 'bisect':
+                X[is_valid] = bisect(_f, lower, upper)
+            else:
+                X[is_valid] = chandrupatla(_f, lower, upper)
+
+        return X
+
+    def _fit_constant(self, X):
+        sample_size = self._sample_size or len(X)
+        constant = np.unique(X)[0]
+        self._params = {
+            'dataset': [constant] * sample_size,
+        }
+
+    def _fit(self, X):
+        if self._sample_size:
+            X = gaussian_kde(X, bw_method=self.bw_method, weights=self.weights).resample(
+                self._sample_size
+            )
+        self._params = {'dataset': X.tolist()}
+        self._model = self._get_model()
+
+    def _is_constant(self):
+        return len(np.unique(self._params['dataset'])) == 1
+
+    def _extract_constant(self):
+        return self._params['dataset'][0]
+
+    def _set_params(self, params):
+        """Set the parameters of this univariate.
+
+        Args:
+            params (dict):
+                Parameters to recreate this instance.
+        """
+        self._params = params.copy()
+        if self._is_constant():
+            constant = self._extract_constant()
+            self._set_constant_value(constant)
+        else:
+            self._model = self._get_model()

copulas/univariate/log_laplace.py

@@ -0,0 +1,38 @@
+"""LogLaplace module."""
+
+import numpy as np
+from scipy.stats import loglaplace
+
+from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+
+
+class LogLaplace(ScipyModel):
+    """Wrapper around scipy.stats.loglaplace.
+
+    Documentation: https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.loglaplace.html
+    """
+
+    PARAMETRIC = ParametricType.PARAMETRIC
+    BOUNDED = BoundedType.SEMI_BOUNDED
+    MODEL_CLASS = loglaplace
+
+    def _fit_constant(self, X):
+        self._params = {
+            'c': 2.0,
+            'loc': np.unique(X)[0],
+            'scale': 0.0,
+        }
+
+    def _fit(self, X):
+        c, loc, scale = loglaplace.fit(X)
+        self._params = {
+            'c': c,
+            'loc': loc,
+            'scale': scale,
+        }
+
+    def _is_constant(self):
+        return self._params['scale'] == 0
+
+    def _extract_constant(self):
+        return self._params['loc']

copulas/univariate/selection.py

@@ -0,0 +1,36 @@
+"""Univariate selection function."""
+
+import numpy as np
+from scipy.stats import kstest
+
+from copulas.utils import get_instance
+
+
+def select_univariate(X, candidates):
+    """Select the best univariate class for this data.
+
+    Args:
+        X (pandas.DataFrame):
+            Data for which be best univariate must be found.
+        candidates (list[Univariate]):
+            List of Univariate subclasses (or instances of those) to choose from.
+
+    Returns:
+        Univariate:
+            Instance of the selected candidate.
+    """
+    best_ks = np.inf
+    best_model = None
+    for model in candidates:
+        try:
+            instance = get_instance(model)
+            instance.fit(X)
+            ks, _ = kstest(X, instance.cdf)
+            if ks < best_ks:
+                best_ks = ks
+                best_model = model
+        except Exception:
+            # Distribution not supported
+            pass
+
+    return get_instance(best_model)

copulas/univariate/student_t.py

@@ -0,0 +1,31 @@
+"""StudentTUnivariate module."""
+
+from scipy.stats import t
+
+from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+
+
+class StudentTUnivariate(ScipyModel):
+    """Wrapper around scipy.stats.t.
+
+    Documentation: https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.t.html
+    """
+
+    PARAMETRIC = ParametricType.PARAMETRIC
+    BOUNDED = BoundedType.UNBOUNDED
+
+    MODEL_CLASS = t
+
+    def _fit_constant(self, X):
+        self._fit(X)
+        self._params['scale'] = 0
+
+    def _fit(self, X):
+        dataframe, loc, scale = t.fit(X)
+        self._params = {'df': dataframe, 'loc': loc, 'scale': scale}
+
+    def _is_constant(self):
+        return self._params['scale'] == 0
+
+    def _extract_constant(self):
+        return self._params['loc']

copulas/univariate/truncated_gaussian.py

@@ -0,0 +1,66 @@
+"""TruncatedGaussian module."""
+
+import warnings
+
+import numpy as np
+from scipy.optimize import fmin_slsqp
+from scipy.stats import truncnorm
+
+from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+from copulas.utils import EPSILON, store_args, validate_random_state
+
+
+class TruncatedGaussian(ScipyModel):
+    """Wrapper around scipy.stats.truncnorm.
+
+    Documentation: https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.truncnorm.html
+    """
+
+    PARAMETRIC = ParametricType.PARAMETRIC
+    BOUNDED = BoundedType.BOUNDED
+    MODEL_CLASS = truncnorm
+
+    @store_args
+    def __init__(self, minimum=None, maximum=None, random_state=None):
+        self.random_state = validate_random_state(random_state)
+        self.min = minimum
+        self.max = maximum
+
+    def _fit_constant(self, X):
+        constant = np.unique(X)[0]
+        self._params = {'a': constant, 'b': constant, 'loc': constant, 'scale': 0.0}
+
+    def _fit(self, X):
+        if self.min is None:
+            self.min = X.min() - EPSILON
+
+        if self.max is None:
+            self.max = X.max() + EPSILON
+
+        def nnlf(params):
+            loc, scale = params
+            a = (self.min - loc) / scale
+            b = (self.max - loc) / scale
+            return truncnorm.nnlf((a, b, loc, scale), X)
+
+        initial_params = X.mean(), X.std()
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', category=RuntimeWarning)
+            optimal = fmin_slsqp(
+                nnlf,
+                initial_params,
+                iprint=False,
+                bounds=[(self.min, self.max), (0.0, (self.max - self.min) ** 2)],
+            )
+
+        loc, scale = optimal
+        a = (self.min - loc) / scale
+        b = (self.max - loc) / scale
+
+        self._params = {'a': a, 'b': b, 'loc': loc, 'scale': scale}
+
+    def _is_constant(self):
+        return self._params['a'] == self._params['b']
+
+    def _extract_constant(self):
+        return self._params['loc']

copulas/univariate/uniform.py

@@ -0,0 +1,27 @@
+"""UniformUnivariate module."""
+
+import numpy as np
+from scipy.stats import uniform
+
+from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+
+
+class UniformUnivariate(ScipyModel):
+    """Uniform univariate model."""
+
+    PARAMETRIC = ParametricType.PARAMETRIC
+    BOUNDED = BoundedType.BOUNDED
+
+    MODEL_CLASS = uniform
+
+    def _fit_constant(self, X):
+        self._params = {'loc': np.min(X), 'scale': np.max(X) - np.min(X)}
+
+    def _fit(self, X):
+        self._params = {'loc': np.min(X), 'scale': np.max(X) - np.min(X)}
+
+    def _is_constant(self):
+        return self._params['scale'] == 0
+
+    def _extract_constant(self):
+        return self._params['loc']

copulas/utils.py

@@ -0,0 +1,248 @@
+"""Utils module."""
+
+import contextlib
+import importlib
+from copy import deepcopy
+from functools import wraps
+
+import numpy as np
+import pandas as pd
+
+EPSILON = np.finfo(np.float32).eps
+
+
+@contextlib.contextmanager
+def set_random_state(random_state, set_model_random_state):
+    """Context manager for managing the random state.
+
+    Args:
+        random_state (int or np.random.RandomState):
+            The random seed or RandomState.
+        set_model_random_state (function):
+            Function to set the random state on the model.
+    """
+    original_state = np.random.get_state()
+    np.random.set_state(random_state.get_state())
+
+    try:
+        yield
+    finally:
+        current_random_state = np.random.RandomState()
+        current_random_state.set_state(np.random.get_state())
+        set_model_random_state(current_random_state)
+        np.random.set_state(original_state)
+
+
+def random_state(function):
+    """Set the random state before calling the function.
+
+    Args:
+        function (Callable):
+            The function to wrap around.
+    """
+
+    @wraps(function)
+    def wrapper(self, *args, **kwargs):
+        if self.random_state is None:
+            return function(self, *args, **kwargs)
+        else:
+            with set_random_state(self.random_state, self.set_random_state):
+                return function(self, *args, **kwargs)
+
+    return wrapper
+
+
+def validate_random_state(random_state):
+    """Validate random state argument.
+
+    Args:
+        random_state (int, numpy.random.RandomState, tuple, or None):
+            Seed or RandomState for the random generator.
+
+    Output:
+        numpy.random.RandomState
+    """
+    if random_state is None:
+        return None
+
+    if isinstance(random_state, int):
+        return np.random.RandomState(seed=random_state)
+    elif isinstance(random_state, np.random.RandomState):
+        return random_state
+    else:
+        raise TypeError(
+            f'`random_state` {random_state} expected to be an int '
+            'or `np.random.RandomState` object.'
+        )
+
+
+def get_instance(obj, **kwargs):
+    """Create new instance of the ``obj`` argument.
+
+    Args:
+        obj (str, type, instance):
+    """
+    instance = None
+    if isinstance(obj, str):
+        package, name = obj.rsplit('.', 1)
+        instance = getattr(importlib.import_module(package), name)(**kwargs)
+    elif isinstance(obj, type):
+        instance = obj(**kwargs)
+    else:
+        if kwargs:
+            instance = obj.__class__(**kwargs)
+        else:
+            args = getattr(obj, '__args__', ())
+            kwargs = getattr(obj, '__kwargs__', {})
+            instance = obj.__class__(*args, **kwargs)
+
+    return instance
+
+
+def store_args(__init__):
+    """Save ``*args`` and ``**kwargs`` used in the ``__init__`` of a copula.
+
+    Args:
+        __init__(callable): ``__init__`` function to store their arguments.
+
+    Returns:
+        callable: Decorated ``__init__`` function.
+    """
+
+    @wraps(__init__)
+    def new__init__(self, *args, **kwargs):
+        args_copy = deepcopy(args)
+        kwargs_copy = deepcopy(kwargs)
+        __init__(self, *args, **kwargs)
+        self.__args__ = args_copy
+        self.__kwargs__ = kwargs_copy
+
+    return new__init__
+
+
+def get_qualified_name(_object):
+    """Return the Fully Qualified Name from an instance or class."""
+    module = _object.__module__
+    if hasattr(_object, '__name__'):
+        _class = _object.__name__
+    else:
+        _class = _object.__class__.__name__
+
+    return module + '.' + _class
+
+
+def vectorize(function):
+    """Allow a method that only accepts scalars to accept vectors too.
+
+    This decorator has two different behaviors depending on the dimensionality of the
+    array passed as an argument:
+
+    **1-d array**
+
+    It will work under the assumption that the `function` argument is a callable
+    with signature::
+
+        function(self, X, *args, **kwargs)
+
+    where X is an scalar magnitude.
+
+    In this case the arguments of the input array will be given one at a time, and
+    both the input and output of the decorated function will have shape (n,).
+
+    **2-d array**
+
+    It will work under the assumption that the `function` argument is a callable with signature::
+
+        function(self, X0, ..., Xj, *args, **kwargs)
+
+    where `Xi` are scalar magnitudes.
+
+    It will pass the contents of each row unpacked on each call. The input is espected to have
+    shape (n, j), the output a shape of (n,)
+
+    It will return a function that is guaranteed to return a `numpy.array`.
+
+    Args:
+        function(callable): Function that only accept and return scalars.
+
+    Returns:
+        callable: Decorated function that can accept and return :attr:`numpy.array`.
+
+    """
+
+    @wraps(function)
+    def decorated(self, X, *args, **kwargs):
+        if not isinstance(X, np.ndarray):
+            return function(self, X, *args, **kwargs)
+
+        if len(X.shape) == 1:
+            X = X.reshape([-1, 1])
+
+        if len(X.shape) == 2:
+            return np.fromiter(
+                (function(self, *x, *args, **kwargs) for x in X), np.dtype('float64')
+            )
+        else:
+            raise ValueError('Arrays of dimensionality higher than 2 are not supported.')
+
+    return decorated
+
+
+def scalarize(function):
+    """Allow methods that only accepts 1-d vectors to work with scalars.
+
+    Args:
+        function(callable): Function that accepts and returns vectors.
+
+    Returns:
+        callable: Decorated function that accepts and returns scalars.
+    """
+
+    @wraps(function)
+    def decorated(self, X, *args, **kwargs):
+        scalar = not isinstance(X, np.ndarray)
+
+        if scalar:
+            X = np.array([X])
+
+        result = function(self, X, *args, **kwargs)
+        if scalar:
+            result = result[0]
+
+        return result
+
+    return decorated
+
+
+def check_valid_values(function):
+    """Raise an exception if the given values are not supported.
+
+    Args:
+        function(callable): Method whose unique argument is a numpy.array-like object.
+
+    Returns:
+        callable: Decorated function
+
+    Raises:
+        ValueError: If there are missing or invalid values or if the dataset is empty.
+    """
+
+    @wraps(function)
+    def decorated(self, X, *args, **kwargs):
+        if isinstance(X, pd.DataFrame):
+            W = X.to_numpy()
+        else:
+            W = X
+
+        if not len(W):
+            raise ValueError('Your dataset is empty.')
+
+        if not (np.issubdtype(W.dtype, np.floating) or np.issubdtype(W.dtype, np.integer)):
+            raise ValueError('There are non-numerical values in your data.')
+
+        if np.isnan(W).any().any():
+            raise ValueError('There are nan values in your data.')
+
+        return function(self, X, *args, **kwargs)
+
+    return decorated