Add Cumulative Distribution Function, Inverse CDF methods to Distributions

test/test_distributions.py

@@ -2309,6 +2309,28 @@ def test_variance_stddev(self):
                 self.assertEqual(pytorch_dist.variance, scipy_dist.var(), allow_inf=True, message=pytorch_dist)
                 self.assertEqual(pytorch_dist.stddev, scipy_dist.var() ** 0.5, message=pytorch_dist)
 
+    def test_cdf(self):
+        set_rng_seed(0)  # see Note [Randomized statistical tests]
+        for pytorch_dist, scipy_dist in self.distribution_pairs:
+            samples = pytorch_dist.sample((5,))
+            try:
+                self.assertEqual(pytorch_dist.cdf(samples),
+                                 scipy_dist.cdf(samples),
+                                 message=pytorch_dist)
+            except NotImplementedError:
+                pass
+
+    def test_icdf(self):
+        set_rng_seed(0)  # see Note [Randomized statistical tests]
+        for pytorch_dist, scipy_dist in self.distribution_pairs:
+            samples = Variable(torch.rand((5,) + pytorch_dist.batch_shape))
+            try:
+                self.assertEqual(pytorch_dist.icdf(samples),
+                                 scipy_dist.ppf(samples),
+                                 message=pytorch_dist)
+            except NotImplementedError:
+                pass
+
 
 class TestTransforms(TestCase):
     def setUp(self):

torch/distributions/cauchy.py

@@ -53,5 +53,13 @@ def log_prob(self, value):
         self._validate_log_prob_arg(value)
         return -math.log(math.pi) - self.scale.log() - (1 + ((value - self.loc) / self.scale)**2).log()
 
+    def cdf(self, value):
+        self._validate_log_prob_arg(value)
+        return torch.atan((value - self.loc) / self.scale) / math.pi + 0.5
+
+    def icdf(self, value):
+        self._validate_log_prob_arg(value)
+        return torch.tan(math.pi * (value - 0.5)) * self.scale + self.loc
+
     def entropy(self):
         return math.log(4 * math.pi) + self.scale.log()

torch/distributions/distribution.py

@@ -101,6 +101,26 @@ def log_prob(self, value):
         """
         raise NotImplementedError
 
+    def cdf(self, value):
+        """
+        Returns the cumulative density/mass function evaluated at
+        `value`.
+
+        Args:
+            value (Tensor or Variable):
+        """
+        raise NotImplementedError
+
+    def icdf(self, value):
+        """
+        Returns the inverse cumulative density/mass function evaluated at
+        `value`.
+
+        Args:
+            value (Tensor or Variable):
+        """
+        raise NotImplementedError
+
     def enumerate_support(self):
         """
         Returns tensor containing all values supported by a discrete

torch/distributions/exponential.py

@@ -49,5 +49,13 @@ def log_prob(self, value):
         self._validate_log_prob_arg(value)
         return self.rate.log() - self.rate * value
 
+    def cdf(self, value):
+        self._validate_log_prob_arg(value)
+        return 1 - torch.exp(-self.rate * value)
+
+    def icdf(self, value):
+        self._validate_log_prob_arg(value)
+        return -torch.log(1 - value) / self.rate
+
     def entropy(self):
         return 1.0 - torch.log(self.rate)

torch/distributions/laplace.py

@@ -55,5 +55,13 @@ def log_prob(self, value):
         self._validate_log_prob_arg(value)
         return -torch.log(2 * self.scale) - torch.abs(value - self.loc) / self.scale
 
+    def cdf(self, value):
+        self._validate_log_prob_arg(value)
+        term = torch.exp((value - self.loc) / self.scale)
+        result = value.new()
+        result[value < self.loc] = 0.5 * term
+        result[value >= self.loc] = 1 - 0.5 / term
+        return result
+
     def entropy(self):
         return 1 + torch.log(2 * self.scale)

torch/distributions/normal.py

@@ -64,5 +64,13 @@ def log_prob(self, value):
         log_scale = math.log(self.scale) if isinstance(self.scale, Number) else self.scale.log()
         return -((value - self.loc) ** 2) / (2 * var) - log_scale - math.log(math.sqrt(2 * math.pi))
 
+    def cdf(self, value):
+        self._validate_log_prob_arg(value)
+        return 0.5 * (1 + torch.erf((value - self.loc) * self.scale.reciprocal() / math.sqrt(2)))
+
+    def icdf(self, value):
+        self._validate_log_prob_arg(value)
+        return self.loc + self.scale * torch.erfinv(2 * value - 1) * math.sqrt(2)
+
     def entropy(self):
         return 0.5 + 0.5 * math.log(2 * math.pi) + torch.log(self.scale)

torch/distributions/pareto.py

@@ -59,5 +59,13 @@ def log_prob(self, value):
         self._validate_log_prob_arg(value)
         return torch.log(self.alpha / value) + self.alpha * (self.scale / value).log()
 
+    def cdf(self, value):
+        self._validate_log_prob_arg(value)
+        return 1 - (self.scale / value).pow(self.alpha)
+
+    def icdf(self, value):
+        self._validate_log_prob_arg(value)
+        return self.scale / (1 - value).pow(self.alpha.reciprocal())
+
     def entropy(self):
         return ((self.scale / self.alpha).log() + (1 + self.alpha.reciprocal()))