easyvvuq.comparison.validate

  1"""Validation by comparing QoI distributions.
  2"""
  3import numpy as np
  4import scipy.stats as st
  5from . import BaseComparisonElement
  6
  7
  8__copyright__ = """
  9
 10    Copyright 2018 Robin A. Richardson, David W. Wright
 11
 12    This file is part of EasyVVUQ
 13
 14    EasyVVUQ is free software: you can redistribute it and/or modify
 15    it under the terms of the Lesser GNU General Public License as published by
 16    the Free Software Foundation, either version 3 of the License, or
 17    (at your option) any later version.
 18
 19    EasyVVUQ is distributed in the hope that it will be useful,
 20    but WITHOUT ANY WARRANTY; without even the implied warranty of
 21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 22    Lesser GNU General Public License for more details.
 23
 24    You should have received a copy of the Lesser GNU General Public License
 25    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 26
 27"""
 28__author__ = 'Jalal Lakhlili'
 29__license__ = "LGPL"
 30
 31
 32class ValidateSimilarity(BaseComparisonElement):
 33
 34    def __init__(self):
 35        pass
 36
 37    def dist(self, p, q):
 38        raise NotImplementedError
 39
 40    def compare(self, dataframe1, dataframe2):
 41        """Perform comparison between two lists or arrays
 42        of discrete distributions.
 43
 44        Parameters
 45        ----------
 46        dataframe1 : NumPy array or list
 47        dataframe2 : NumPy array or list
 48
 49        Returns
 50        -------
 51        A list of distances between two lists of discrete distributions,
 52        dataframe1 and dataframe2.
 53        """
 54
 55        if len(dataframe1) != len(dataframe2):
 56            raise RuntimeError("Input dataframe sizes are not equal")
 57
 58        shape = np.shape(dataframe1)
 59        if len(shape) == 2:
 60            results = []
 61            for i in range(len(dataframe1)):
 62                p1 = np.array(dataframe1[i])
 63                p2 = np.array(dataframe2[i])
 64                d = self.dist(p1, p2)
 65                results.append(d)
 66        else:
 67            p1 = np.array(dataframe1)
 68            p2 = np.array(dataframe2)
 69            results = self.dist(p1, p2)
 70
 71        return results
 72
 73
 74class ValidateSimilarityHellinger(ValidateSimilarity):
 75    def element_name(self):
 76        return "validate_similarity_hellinger"
 77
 78    def element_version(self):
 79        return "0.1"
 80
 81    def dist(self, p, q):
 82        """ Compute Hellinger distance between two discrete probability
 83        distributions (PDF). The Hellinger distance metric gives an
 84        output in the range [0,1] with values closer to 0 meaning the
 85        PDFs are more similar.
 86
 87        Parameters
 88        ----------
 89        p : NumPy array
 90        q : NumPy array
 91
 92        Returns
 93        -------
 94        Hellinger distance between distributions p and q.
 95        https://en.wikipedia.org/wiki/Hellinger_distance
 96        """
 97        p /= p.sum()
 98        q /= q.sum()
 99        return np.sqrt(1. - np.sqrt(p * q).sum())
100
101
102class ValidateSimilarityJensenShannon(ValidateSimilarity):
103    def element_name(self):
104        return "validate_similarity_jensen_shannon"
105
106    def element_version(self):
107        return "0.1"
108
109    def dist(self, p, q):
110        """ Compute Jensen-Shannon distance between two discrete
111        probability distributions (PDF). It is based on Kullback–Leibler
112        divergence and gives an output metric un the range [0,1] with
113        values closer to 0 meaning the PDFs are more similar.
114
115        Parameters
116        ----------
117        p : NumPy array
118        q : NumPy array
119
120        Returns
121        -------
122        Jensen-Shannon divergence between distributions p and q.
123        https://en.wikipedia.org/wiki/Jensen%E2%80%93Shannon_divergence
124        https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence
125        """
126        p /= p.sum()
127        q /= q.sum()
128        m = 0.5 * (p + q)
129        div = 0.5 * (st.entropy(p, m) + st.entropy(q, m))
130        return np.sqrt(div / np.log(2))
131
132
133class ValidateSimilarityWasserstein(ValidateSimilarity):
134    def element_name(self):
135        return "validate_similarity_wasserstein"
136
137    def element_version(self):
138        return "0.1"
139
140    def dist(self, p, q):
141        """ Compute Wasserstein distance between two discrete cumulative
142        distributions (CDF). The Wasserstein distance has an
143        unrestricted range with a lower limit of 0. A smaller distance
144        indicates a stronger similarity between between CFDs.
145
146        Parameters
147        ----------
148        p : NumPy array
149        q : NumPy array
150
151        Returns
152        -------
153        Wasserstein distance between distributions p and q.
154        https://en.wikipedia.org/wiki/Wasserstein_metric
155        """
156        return st.wasserstein_distance(p, q)