diff --git a/tensorflow/contrib/distributions/BUILD b/tensorflow/contrib/distributions/BUILD index 451a34320e0..44263dc8aed 100644 --- a/tensorflow/contrib/distributions/BUILD +++ b/tensorflow/contrib/distributions/BUILD @@ -55,9 +55,9 @@ cuda_py_tests( ) cuda_py_tests( - name = "gaussian_test", + name = "normal_test", size = "small", - srcs = ["python/kernel_tests/gaussian_test.py"], + srcs = ["python/kernel_tests/normal_test.py"], additional_deps = [ ":distributions_py", "//tensorflow/python:framework_test_lib", @@ -98,9 +98,9 @@ cuda_py_tests( ) cuda_py_tests( - name = "gaussian_conjugate_posteriors_test", + name = "normal_conjugate_posteriors_test", size = "small", - srcs = ["python/kernel_tests/gaussian_conjugate_posteriors_test.py"], + srcs = ["python/kernel_tests/normal_conjugate_posteriors_test.py"], additional_deps = [ ":distributions_py", "//tensorflow/python:platform_test", diff --git a/tensorflow/contrib/distributions/__init__.py b/tensorflow/contrib/distributions/__init__.py index 2c8a0343b28..7fa8c0fb0c6 100644 --- a/tensorflow/contrib/distributions/__init__.py +++ b/tensorflow/contrib/distributions/__init__.py @@ -30,7 +30,7 @@ initialized with parameters that define the distributions. @@Chi2 @@Exponential @@Gamma -@@Gaussian +@@Normal @@StudentT @@Uniform @@ -44,10 +44,10 @@ initialized with parameters that define the distributions. Functions that transform conjugate prior/likelihood pairs to distributions representing the posterior or posterior predictive. -### Gaussian likelihood with conjugate prior. +### Normal likelihood with conjugate prior. -@@gaussian_conjugates_known_sigma_posterior -@@gaussian_congugates_known_sigma_predictive +@@normal_conjugates_known_sigma_posterior +@@normal_congugates_known_sigma_predictive """ from __future__ import absolute_import from __future__ import division @@ -60,8 +60,8 @@ from tensorflow.contrib.distributions.python.ops.dirichlet_multinomial import * from tensorflow.contrib.distributions.python.ops.distribution import * from tensorflow.contrib.distributions.python.ops.exponential import * from tensorflow.contrib.distributions.python.ops.gamma import * -from tensorflow.contrib.distributions.python.ops.gaussian import * -from tensorflow.contrib.distributions.python.ops.gaussian_conjugate_posteriors import * from tensorflow.contrib.distributions.python.ops.mvn import * +from tensorflow.contrib.distributions.python.ops.normal import * +from tensorflow.contrib.distributions.python.ops.normal_conjugate_posteriors import * from tensorflow.contrib.distributions.python.ops.student_t import * from tensorflow.contrib.distributions.python.ops.uniform import * diff --git a/tensorflow/contrib/distributions/python/kernel_tests/gaussian_conjugate_posteriors_test.py b/tensorflow/contrib/distributions/python/kernel_tests/normal_conjugate_posteriors_test.py similarity index 74% rename from tensorflow/contrib/distributions/python/kernel_tests/gaussian_conjugate_posteriors_test.py rename to tensorflow/contrib/distributions/python/kernel_tests/normal_conjugate_posteriors_test.py index c3a2464b5bd..1d03396bf68 100644 --- a/tensorflow/contrib/distributions/python/kernel_tests/gaussian_conjugate_posteriors_test.py +++ b/tensorflow/contrib/distributions/python/kernel_tests/normal_conjugate_posteriors_test.py @@ -25,9 +25,9 @@ import tensorflow as tf distributions = tf.contrib.distributions -class GaussianTest(tf.test.TestCase): +class NormalTest(tf.test.TestCase): - def testGaussianConjugateKnownSigmaPosterior(self): + def testNormalConjugateKnownSigmaPosterior(self): with tf.Session(): mu0 = tf.constant([3.0]) sigma0 = tf.constant([math.sqrt(10.0)]) @@ -35,16 +35,16 @@ class GaussianTest(tf.test.TestCase): x = tf.constant([-2.5, 2.5, 4.0, 0.0, -1.0, 2.0]) s = tf.reduce_sum(x) n = tf.size(x) - prior = distributions.Gaussian(mu=mu0, sigma=sigma0) - posterior = distributions.gaussian_conjugates_known_sigma_posterior( + prior = distributions.Normal(mu=mu0, sigma=sigma0) + posterior = distributions.normal_conjugates_known_sigma_posterior( prior=prior, sigma=sigma, s=s, n=n) # Smoke test - self.assertTrue(isinstance(posterior, distributions.Gaussian)) + self.assertTrue(isinstance(posterior, distributions.Normal)) posterior_log_pdf = posterior.log_pdf(x).eval() self.assertEqual(posterior_log_pdf.shape, (6,)) - def testGaussianConjugateKnownSigmaPosteriorND(self): + def testNormalConjugateKnownSigmaPosteriorND(self): with tf.Session(): batch_size = 6 mu0 = tf.constant([[3.0, -3.0]] * batch_size) @@ -54,16 +54,16 @@ class GaussianTest(tf.test.TestCase): tf.constant([[-2.5, 2.5, 4.0, 0.0, -1.0, 2.0]], dtype=tf.float32)) s = tf.reduce_sum(x) n = tf.size(x) - prior = distributions.Gaussian(mu=mu0, sigma=sigma0) - posterior = distributions.gaussian_conjugates_known_sigma_posterior( + prior = distributions.Normal(mu=mu0, sigma=sigma0) + posterior = distributions.normal_conjugates_known_sigma_posterior( prior=prior, sigma=sigma, s=s, n=n) # Smoke test - self.assertTrue(isinstance(posterior, distributions.Gaussian)) + self.assertTrue(isinstance(posterior, distributions.Normal)) posterior_log_pdf = posterior.log_pdf(x).eval() self.assertEqual(posterior_log_pdf.shape, (6, 2)) - def testGaussianConjugateKnownSigmaNDPosteriorND(self): + def testNormalConjugateKnownSigmaNDPosteriorND(self): with tf.Session(): batch_size = 6 mu0 = tf.constant([[3.0, -3.0]] * batch_size) @@ -75,19 +75,19 @@ class GaussianTest(tf.test.TestCase): s = tf.reduce_sum(x, reduction_indices=[1]) x = tf.transpose(x) # Reshape to shape (6, 2) n = tf.constant([6] * 2) - prior = distributions.Gaussian(mu=mu0, sigma=sigma0) - posterior = distributions.gaussian_conjugates_known_sigma_posterior( + prior = distributions.Normal(mu=mu0, sigma=sigma0) + posterior = distributions.normal_conjugates_known_sigma_posterior( prior=prior, sigma=sigma, s=s, n=n) # Smoke test - self.assertTrue(isinstance(posterior, distributions.Gaussian)) + self.assertTrue(isinstance(posterior, distributions.Normal)) # Calculate log_pdf under the 2 models posterior_log_pdf = posterior.log_pdf(x) self.assertEqual(posterior_log_pdf.get_shape(), (6, 2)) self.assertEqual(posterior_log_pdf.eval().shape, (6, 2)) - def testGaussianConjugateKnownSigmaPredictive(self): + def testNormalConjugateKnownSigmaPredictive(self): with tf.Session(): batch_size = 6 mu0 = tf.constant([3.0] * batch_size) @@ -96,12 +96,12 @@ class GaussianTest(tf.test.TestCase): x = tf.constant([-2.5, 2.5, 4.0, 0.0, -1.0, 2.0]) s = tf.reduce_sum(x) n = tf.size(x) - prior = distributions.Gaussian(mu=mu0, sigma=sigma0) - predictive = distributions.gaussian_congugates_known_sigma_predictive( + prior = distributions.Normal(mu=mu0, sigma=sigma0) + predictive = distributions.normal_congugates_known_sigma_predictive( prior=prior, sigma=sigma, s=s, n=n) # Smoke test - self.assertTrue(isinstance(predictive, distributions.Gaussian)) + self.assertTrue(isinstance(predictive, distributions.Normal)) predictive_log_pdf = predictive.log_pdf(x).eval() self.assertEqual(predictive_log_pdf.shape, (6,)) diff --git a/tensorflow/contrib/distributions/python/kernel_tests/gaussian_test.py b/tensorflow/contrib/distributions/python/kernel_tests/normal_test.py similarity index 79% rename from tensorflow/contrib/distributions/python/kernel_tests/gaussian_test.py rename to tensorflow/contrib/distributions/python/kernel_tests/normal_test.py index f0a82df901c..0e9f8a40cca 100644 --- a/tensorflow/contrib/distributions/python/kernel_tests/gaussian_test.py +++ b/tensorflow/contrib/distributions/python/kernel_tests/normal_test.py @@ -24,9 +24,9 @@ import numpy as np import tensorflow as tf -class GaussianTest(tf.test.TestCase): +class NormalTest(tf.test.TestCase): - def testGaussianLogPDF(self): + def testNormalLogPDF(self): with tf.Session(): batch_size = 6 mu = tf.constant([3.0] * batch_size) @@ -34,18 +34,18 @@ class GaussianTest(tf.test.TestCase): mu_v = 3.0 sigma_v = np.sqrt(10.0) x = np.array([-2.5, 2.5, 4.0, 0.0, -1.0, 2.0], dtype=np.float32) - gaussian = tf.contrib.distributions.Gaussian(mu=mu, sigma=sigma) + normal = tf.contrib.distributions.Normal(mu=mu, sigma=sigma) expected_log_pdf = np.log( 1 / np.sqrt(2 * np.pi) / sigma_v * np.exp(-1.0 / (2 * sigma_v**2) * (x - mu_v)**2)) - log_pdf = gaussian.log_pdf(x) + log_pdf = normal.log_pdf(x) self.assertAllClose(expected_log_pdf, log_pdf.eval()) - pdf = gaussian.pdf(x) + pdf = normal.pdf(x) self.assertAllClose(np.exp(expected_log_pdf), pdf.eval()) - def testGaussianLogPDFMultidimensional(self): + def testNormalLogPDFMultidimensional(self): with tf.Session(): batch_size = 6 mu = tf.constant([[3.0, -3.0]] * batch_size) @@ -53,22 +53,22 @@ class GaussianTest(tf.test.TestCase): mu_v = np.array([3.0, -3.0]) sigma_v = np.array([np.sqrt(10.0), np.sqrt(15.0)]) x = np.array([[-2.5, 2.5, 4.0, 0.0, -1.0, 2.0]], dtype=np.float32).T - gaussian = tf.contrib.distributions.Gaussian(mu=mu, sigma=sigma) + normal = tf.contrib.distributions.Normal(mu=mu, sigma=sigma) expected_log_pdf = np.log( 1 / np.sqrt(2 * np.pi) / sigma_v * np.exp(-1.0 / (2 * sigma_v**2) * (x - mu_v)**2)) - log_pdf = gaussian.log_pdf(x) + log_pdf = normal.log_pdf(x) log_pdf_values = log_pdf.eval() self.assertEqual(log_pdf.get_shape(), (6, 2)) self.assertAllClose(expected_log_pdf, log_pdf_values) - pdf = gaussian.pdf(x) + pdf = normal.pdf(x) pdf_values = pdf.eval() self.assertEqual(pdf.get_shape(), (6, 2)) self.assertAllClose(np.exp(expected_log_pdf), pdf_values) - def testGaussianCDF(self): + def testNormalCDF(self): with tf.Session(): batch_size = 6 mu = tf.constant([3.0] * batch_size) @@ -77,40 +77,40 @@ class GaussianTest(tf.test.TestCase): sigma_v = np.sqrt(10.0) x = np.array([-2.5, 2.5, 4.0, 0.0, -1.0, 2.0], dtype=np.float32) - gaussian = tf.contrib.distributions.Gaussian(mu=mu, sigma=sigma) + normal = tf.contrib.distributions.Normal(mu=mu, sigma=sigma) erf_fn = np.vectorize(math.erf) # From Wikipedia expected_cdf = 0.5 * (1.0 + erf_fn((x - mu_v)/(sigma_v*np.sqrt(2)))) - cdf = gaussian.cdf(x) + cdf = normal.cdf(x) self.assertAllClose(expected_cdf, cdf.eval()) - def testGaussianEntropy(self): + def testNormalEntropy(self): with tf.Session(): mu_v = np.array([1.0, 1.0, 1.0]) sigma_v = np.array([[1.0, 2.0, 3.0]]).T - gaussian = tf.contrib.distributions.Gaussian(mu=mu_v, sigma=sigma_v) + normal = tf.contrib.distributions.Normal(mu=mu_v, sigma=sigma_v) sigma_broadcast = mu_v * sigma_v expected_entropy = 0.5 * np.log(2*np.pi*np.exp(1)*sigma_broadcast**2) - self.assertAllClose(expected_entropy, gaussian.entropy().eval()) + self.assertAllClose(expected_entropy, normal.entropy().eval()) - def testGaussianSample(self): + def testNormalSample(self): with tf.Session(): mu = tf.constant(3.0) sigma = tf.constant(math.sqrt(10.0)) mu_v = 3.0 sigma_v = np.sqrt(10.0) n = tf.constant(100000) - gaussian = tf.contrib.distributions.Gaussian(mu=mu, sigma=sigma) - samples = gaussian.sample(n, seed=137) + normal = tf.contrib.distributions.Normal(mu=mu, sigma=sigma) + samples = normal.sample(n, seed=137) sample_values = samples.eval() self.assertEqual(sample_values.shape, (100000,)) self.assertAllClose(sample_values.mean(), mu_v, atol=1e-2) self.assertAllClose(sample_values.std(), sigma_v, atol=1e-1) - def testGaussianSampleMultiDimensional(self): + def testNormalSampleMultiDimensional(self): with tf.Session(): batch_size = 2 mu = tf.constant([[3.0, -3.0]] * batch_size) @@ -118,8 +118,8 @@ class GaussianTest(tf.test.TestCase): mu_v = [3.0, -3.0] sigma_v = [np.sqrt(10.0), np.sqrt(15.0)] n = tf.constant(100000) - gaussian = tf.contrib.distributions.Gaussian(mu=mu, sigma=sigma) - samples = gaussian.sample(n, seed=137) + normal = tf.contrib.distributions.Normal(mu=mu, sigma=sigma) + samples = normal.sample(n, seed=137) sample_values = samples.eval() self.assertEqual(samples.get_shape(), (100000, batch_size, 2)) self.assertAllClose(sample_values[:, 0, 0].mean(), mu_v[0], atol=1e-2) @@ -129,13 +129,13 @@ class GaussianTest(tf.test.TestCase): def testNegativeSigmaFails(self): with tf.Session(): - gaussian = tf.contrib.distributions.Gaussian( + normal = tf.contrib.distributions.Normal( mu=[1.], sigma=[-5.], name='G') with self.assertRaisesOpError( r'should contain only positive values'): - gaussian.mean.eval() + normal.mean.eval() if __name__ == '__main__': tf.test.main() diff --git a/tensorflow/contrib/distributions/python/ops/gaussian.py b/tensorflow/contrib/distributions/python/ops/normal.py similarity index 82% rename from tensorflow/contrib/distributions/python/ops/gaussian.py rename to tensorflow/contrib/distributions/python/ops/normal.py index 8e2049444af..dc08a0e1dec 100644 --- a/tensorflow/contrib/distributions/python/ops/gaussian.py +++ b/tensorflow/contrib/distributions/python/ops/normal.py @@ -38,8 +38,8 @@ def _assert_all_positive(x): ["Tensor %s should contain only positive values: " % x.name, x]) -class Gaussian(object): - """The scalar Gaussian distribution with mean and stddev parameters mu, sigma. +class Normal(object): + """The scalar Normal distribution with mean and stddev parameters mu, sigma. #### Mathematical details @@ -52,15 +52,15 @@ class Gaussian(object): Examples of initialization of one or a batch of distributions. ```python - # Define a single scalar Gaussian distribution. - dist = tf.contrib.distributions.Gaussian(mu=0, sigma=3) + # Define a single scalar Normal distribution. + dist = tf.contrib.distributions.Normal(mu=0, sigma=3) # Evaluate the cdf at 1, returning a scalar. dist.cdf(1) - # Define a batch of two scalar valued Gaussians. + # Define a batch of two scalar valued Normals. # The first has mean 1 and standard deviation 11, the second 2 and 22. - dist = tf.contrib.distributions.Gaussian(mu=[1, 2.], sigma=[11, 22.]) + dist = tf.contrib.distributions.Normal(mu=[1, 2.], sigma=[11, 22.]) # Evaluate the pdf of the first distribution on 0, and the second on 1.5, # returning a length two tensor. @@ -73,9 +73,9 @@ class Gaussian(object): Arguments are broadcast when possible. ```python - # Define a batch of two scalar valued Gaussians. + # Define a batch of two scalar valued Normals. # Both have mean 1, but different standard deviations. - dist = tf.contrib.distributions.Gaussian(mu=1, sigma=[11, 22.]) + dist = tf.contrib.distributions.Normal(mu=1, sigma=[11, 22.]) # Evaluate the pdf of both distributions on the same point, 3.0, # returning a length 2 tensor. @@ -85,7 +85,7 @@ class Gaussian(object): """ def __init__(self, mu, sigma, name=None): - """Construct Gaussian distributions with mean and stddev `mu` and `sigma`. + """Construct Normal distributions with mean and stddev `mu` and `sigma`. The parameters `mu` and `sigma` must be shaped in a way that supports broadcasting (e.g. `mu + sigma` is a valid operation). @@ -99,7 +99,7 @@ class Gaussian(object): Raises: TypeError: if mu and sigma are different dtypes. """ - with ops.op_scope([mu, sigma], name, "Gaussian"): + with ops.op_scope([mu, sigma], name, "Normal"): mu = ops.convert_to_tensor(mu) sigma = ops.convert_to_tensor(sigma) with ops.control_dependencies([_assert_all_positive(sigma)]): @@ -125,7 +125,7 @@ class Gaussian(object): return self._mu * array_ops.ones_like(self._sigma) def log_pdf(self, x, name=None): - """Log pdf of observations in `x` under these Gaussian distribution(s). + """Log pdf of observations in `x` under these Normal distribution(s). Args: x: tensor of dtype `dtype`, must be broadcastable with `mu` and `sigma`. @@ -134,7 +134,7 @@ class Gaussian(object): Returns: log_pdf: tensor of dtype `dtype`, the log-PDFs of `x`. """ - with ops.op_scope([self._mu, self._sigma, x], name, "GaussianLogPdf"): + with ops.op_scope([self._mu, self._sigma, x], name, "NormalLogPdf"): x = ops.convert_to_tensor(x) if x.dtype != self.dtype: raise TypeError("Input x dtype does not match dtype: %s vs. %s" @@ -144,7 +144,7 @@ class Gaussian(object): -0.5*math_ops.square((x - self._mu) / self._sigma)) def cdf(self, x, name=None): - """CDF of observations in `x` under these Gaussian distribution(s). + """CDF of observations in `x` under these Normal distribution(s). Args: x: tensor of dtype `dtype`, must be broadcastable with `mu` and `sigma`. @@ -153,7 +153,7 @@ class Gaussian(object): Returns: cdf: tensor of dtype `dtype`, the CDFs of `x`. """ - with ops.op_scope([self._mu, self._sigma, x], name, "GaussianCdf"): + with ops.op_scope([self._mu, self._sigma, x], name, "NormalCdf"): x = ops.convert_to_tensor(x) if x.dtype != self.dtype: raise TypeError("Input x dtype does not match dtype: %s vs. %s" @@ -162,7 +162,7 @@ class Gaussian(object): 1.0/(math.sqrt(2.0) * self._sigma)*(x - self._mu))) def log_cdf(self, x, name=None): - """Log CDF of observations `x` under these Gaussian distribution(s). + """Log CDF of observations `x` under these Normal distribution(s). Args: x: tensor of dtype `dtype`, must be broadcastable with `mu` and `sigma`. @@ -171,11 +171,11 @@ class Gaussian(object): Returns: log_cdf: tensor of dtype `dtype`, the log-CDFs of `x`. """ - with ops.op_scope([self._mu, self._sigma, x], name, "GaussianLogCdf"): + with ops.op_scope([self._mu, self._sigma, x], name, "NormalLogCdf"): return math_ops.log(self.cdf(x)) def pdf(self, x, name=None): - """The PDF of observations in `x` under these Gaussian distribution(s). + """The PDF of observations in `x` under these Normal distribution(s). Args: x: tensor of dtype `dtype`, must be broadcastable with `mu` and `sigma`. @@ -184,11 +184,11 @@ class Gaussian(object): Returns: pdf: tensor of dtype `dtype`, the pdf values of `x`. """ - with ops.op_scope([self._mu, self._sigma, x], name, "GaussianPdf"): + with ops.op_scope([self._mu, self._sigma, x], name, "NormalPdf"): return math_ops.exp(self.log_pdf(x)) def entropy(self, name=None): - """The entropy of Gaussian distribution(s). + """The entropy of Normal distribution(s). Args: name: The name to give this op. @@ -196,7 +196,7 @@ class Gaussian(object): Returns: entropy: tensor of dtype `dtype`, the entropy. """ - with ops.op_scope([self._mu, self._sigma], name, "GaussianEntropy"): + with ops.op_scope([self._mu, self._sigma], name, "NormalEntropy"): two_pi_e1 = constant_op.constant( 2 * math.pi * math.exp(1), dtype=self.dtype) # Use broadcasting rules to calculate the full broadcast sigma. @@ -204,7 +204,7 @@ class Gaussian(object): return 0.5 * math_ops.log(two_pi_e1 * math_ops.square(sigma)) def sample(self, n, seed=None, name=None): - """Sample `n` observations from the Gaussian Distributions. + """Sample `n` observations from the Normal Distributions. Args: n: `Scalar`, type int32, the number of observations to sample. @@ -215,7 +215,7 @@ class Gaussian(object): samples: `[n, ...]`, a `Tensor` of `n` samples for each of the distributions determined by broadcasting the hyperparameters. """ - with ops.op_scope([self._mu, self._sigma, n], name, "GaussianSample"): + with ops.op_scope([self._mu, self._sigma, n], name, "NormalSample"): broadcast_shape = (self._mu + self._sigma).get_shape() n = ops.convert_to_tensor(n) shape = array_ops.concat( diff --git a/tensorflow/contrib/distributions/python/ops/gaussian_conjugate_posteriors.py b/tensorflow/contrib/distributions/python/ops/normal_conjugate_posteriors.py similarity index 73% rename from tensorflow/contrib/distributions/python/ops/gaussian_conjugate_posteriors.py rename to tensorflow/contrib/distributions/python/ops/normal_conjugate_posteriors.py index c0089964152..45ddd3ada36 100644 --- a/tensorflow/contrib/distributions/python/ops/gaussian_conjugate_posteriors.py +++ b/tensorflow/contrib/distributions/python/ops/normal_conjugate_posteriors.py @@ -12,32 +12,32 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""The Gaussian distribution: conjugate posterior closed form calculations.""" +"""The Normal distribution: conjugate posterior closed form calculations.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function -from tensorflow.contrib.distributions.python.ops.gaussian import Gaussian # pylint: disable=line-too-long +from tensorflow.contrib.distributions.python.ops.normal import Normal # pylint: disable=line-too-long from tensorflow.python.ops import math_ops -def gaussian_conjugates_known_sigma_posterior(prior, sigma, s, n): - """Posterior Gaussian distribution with conjugate prior on the mean. +def normal_conjugates_known_sigma_posterior(prior, sigma, s, n): + """Posterior Normal distribution with conjugate prior on the mean. This model assumes that `n` observations (with sum `s`) come from a - Gaussian with unknown mean `mu` (described by the Gaussian `prior`) + Normal with unknown mean `mu` (described by the Normal `prior`) and known variance `sigma^2`. The "known sigma posterior" is the distribution of the unknown `mu`. - Accepts a prior Gaussian distribution object, having parameters + Accepts a prior Normal distribution object, having parameters `mu0` and `sigma0`, as well as known `sigma` values of the predictive - distribution(s) (also assumed Gaussian), + distribution(s) (also assumed Normal), and statistical estimates `s` (the sum(s) of the observations) and `n` (the number(s) of observations). - Returns a posterior (also Gaussian) distribution object, with parameters + Returns a posterior (also Normal) distribution object, with parameters `(mu', sigma'^2)`, where: ``` @@ -50,7 +50,7 @@ def gaussian_conjugates_known_sigma_posterior(prior, sigma, s, n): will broadcast in the case of multidimensional sets of parameters. Args: - prior: `Gaussian` object of type `dtype`: + prior: `Normal` object of type `dtype`: the prior distribution having parameters `(mu0, sigma0)`. sigma: tensor of type `dtype`, taking values `sigma > 0`. The known stddev parameter(s). @@ -58,15 +58,15 @@ def gaussian_conjugates_known_sigma_posterior(prior, sigma, s, n): n: Tensor of type `int`. The number(s) of observations. Returns: - A new Gaussian posterior distribution object for the unknown observation + A new Normal posterior distribution object for the unknown observation mean `mu`. Raises: TypeError: if dtype of `s` does not match `dtype`, or `prior` is not a - Gaussian object. + Normal object. """ - if not isinstance(prior, Gaussian): - raise TypeError("Expected prior to be an instance of type Gaussian") + if not isinstance(prior, Normal): + raise TypeError("Expected prior to be an instance of type Normal") if s.dtype != prior.dtype: raise TypeError( @@ -77,27 +77,27 @@ def gaussian_conjugates_known_sigma_posterior(prior, sigma, s, n): sigma0_2 = math_ops.square(prior.sigma) sigma_2 = math_ops.square(sigma) sigmap_2 = 1.0/(1/sigma0_2 + n/sigma_2) - return Gaussian( + return Normal( mu=(prior.mu/sigma0_2 + s/sigma_2) * sigmap_2, sigma=math_ops.sqrt(sigmap_2)) -def gaussian_congugates_known_sigma_predictive(prior, sigma, s, n): - """Posterior predictive Gaussian distribution w. conjugate prior on the mean. +def normal_congugates_known_sigma_predictive(prior, sigma, s, n): + """Posterior predictive Normal distribution w. conjugate prior on the mean. This model assumes that `n` observations (with sum `s`) come from a - Gaussian with unknown mean `mu` (described by the Gaussian `prior`) + Normal with unknown mean `mu` (described by the Normal `prior`) and known variance `sigma^2`. The "known sigma predictive" is the distribution of new observations, conditioned on the existing observations and our prior. - Accepts a prior Gaussian distribution object, having parameters + Accepts a prior Normal distribution object, having parameters `mu0` and `sigma0`, as well as known `sigma` values of the predictive - distribution(s) (also assumed Gaussian), + distribution(s) (also assumed Normal), and statistical estimates `s` (the sum(s) of the observations) and `n` (the number(s) of observations). - Calculates the Gaussian distribution(s) `p(x | sigma^2)`: + Calculates the Normal distribution(s) `p(x | sigma^2)`: ``` p(x | sigma^2) = int N(x | mu, sigma^2) N(mu | prior.mu, prior.sigma^2) dmu @@ -117,7 +117,7 @@ def gaussian_congugates_known_sigma_predictive(prior, sigma, s, n): will broadcast in the case of multidimensional sets of parameters. Args: - prior: `Gaussian` object of type `dtype`: + prior: `Normal` object of type `dtype`: the prior distribution having parameters `(mu0, sigma0)`. sigma: tensor of type `dtype`, taking values `sigma > 0`. The known stddev parameter(s). @@ -125,14 +125,14 @@ def gaussian_congugates_known_sigma_predictive(prior, sigma, s, n): n: Tensor of type `int`. The number(s) of observations. Returns: - A new Gaussian predictive distribution object. + A new Normal predictive distribution object. Raises: TypeError: if dtype of `s` does not match `dtype`, or `prior` is not a - Gaussian object. + Normal object. """ - if not isinstance(prior, Gaussian): - raise TypeError("Expected prior to be an instance of type Gaussian") + if not isinstance(prior, Normal): + raise TypeError("Expected prior to be an instance of type Normal") if s.dtype != prior.dtype: raise TypeError( @@ -143,6 +143,6 @@ def gaussian_congugates_known_sigma_predictive(prior, sigma, s, n): sigma0_2 = math_ops.square(prior.sigma) sigma_2 = math_ops.square(sigma) sigmap_2 = 1.0/(1/sigma0_2 + n/sigma_2) - return Gaussian( + return Normal( mu=(prior.mu/sigma0_2 + s/sigma_2) * sigmap_2, sigma=math_ops.sqrt(sigmap_2 + sigma_2))