From d4bce29e7b180645164607935d3bf49689a41a19 Mon Sep 17 00:00:00 2001 From: Kristian Hartikainen Date: Mon, 29 Mar 2021 18:57:54 +0300 Subject: [PATCH 001/153] Fix BatchNormalization docstring --- .../python/bijectors/batch_normalization.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/tensorflow_probability/python/bijectors/batch_normalization.py b/tensorflow_probability/python/bijectors/batch_normalization.py index e73b01f010..1dbd3e6d77 100644 --- a/tensorflow_probability/python/bijectors/batch_normalization.py +++ b/tensorflow_probability/python/bijectors/batch_normalization.py @@ -90,14 +90,13 @@ class BatchNormalization(bijector.Bijector): computed at training-time. De-normalization is useful for sampling. ```python - - dist = tfd.TransformedDistribution( - distribution=tfd.Normal()), + distribution = tfd.TransformedDistribution( + distribution=tfd.Normal(loc=[0.0], scale=[1.0]), bijector=tfb.BatchNormalization()) - y = tfd.MultivariateNormalDiag(loc=1., scale=2.).sample(100) # ~ N(1, 2) - x = dist.bijector.inverse(y) # ~ N(0, 1) - y = dist.sample() # ~ N(1, 2) + y = tfd.Normal(loc=[1.0], scale=[2.0]).sample(100) # ~ N(1, 2) + x = distribution.bijector.inverse(y) # ~ N(0, 1) + y_ = distribution.sample(100) # ~ N(1, 2) ``` During training time, `BatchNormalization.inverse` and From c50ac5b9e58a54fd7a3cfd6fbb87f8987ef7328d Mon Sep 17 00:00:00 2001 From: Vishnuvardhan Janapati <46058173+jvishnuvardhan@users.noreply.github.com> Date: Fri, 4 Feb 2022 07:32:23 -0800 Subject: [PATCH 002/153] Fix Multivariate Student's t-distribution docstring Python example within the docstring was not closed and hence the TF page was not rendered correctly --- .../python/distributions/multivariate_student_t.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tensorflow_probability/python/distributions/multivariate_student_t.py b/tensorflow_probability/python/distributions/multivariate_student_t.py index 9c93408a9f..764e428aa8 100644 --- a/tensorflow_probability/python/distributions/multivariate_student_t.py +++ b/tensorflow_probability/python/distributions/multivariate_student_t.py @@ -102,6 +102,8 @@ class MultivariateStudentTLinearOperator( # Compute the pdf of an`R^3` observation; return a scalar. mvt.prob([-1., 0, 1]) # shape: [] + + ``` """ From 763d04c97a30f39fd6f94855dcab0bb337078efe Mon Sep 17 00:00:00 2001 From: Vishnuvardhan Janapati <46058173+jvishnuvardhan@users.noreply.github.com> Date: Fri, 4 Feb 2022 09:05:42 -0800 Subject: [PATCH 003/153] Update multivariate_student_t.py --- .../python/distributions/multivariate_student_t.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tensorflow_probability/python/distributions/multivariate_student_t.py b/tensorflow_probability/python/distributions/multivariate_student_t.py index 764e428aa8..6a193aefc4 100644 --- a/tensorflow_probability/python/distributions/multivariate_student_t.py +++ b/tensorflow_probability/python/distributions/multivariate_student_t.py @@ -102,7 +102,6 @@ class MultivariateStudentTLinearOperator( # Compute the pdf of an`R^3` observation; return a scalar. mvt.prob([-1., 0, 1]) # shape: [] - ``` """ From 360949bf9c847a9fe1cef08ff97d64e0cf891beb Mon Sep 17 00:00:00 2001 From: Vishnuvardhan Janapati <46058173+jvishnuvardhan@users.noreply.github.com> Date: Fri, 4 Feb 2022 10:18:13 -0800 Subject: [PATCH 004/153] Update multivariate_student_t.py --- .../python/distributions/multivariate_student_t.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tensorflow_probability/python/distributions/multivariate_student_t.py b/tensorflow_probability/python/distributions/multivariate_student_t.py index 6a193aefc4..adfbecd386 100644 --- a/tensorflow_probability/python/distributions/multivariate_student_t.py +++ b/tensorflow_probability/python/distributions/multivariate_student_t.py @@ -103,7 +103,6 @@ class MultivariateStudentTLinearOperator( # Compute the pdf of an`R^3` observation; return a scalar. mvt.prob([-1., 0, 1]) # shape: [] ``` - """ def __init__(self, From fb003b2609bda8fe93b508e7916634f1a8b0240c Mon Sep 17 00:00:00 2001 From: Vaidotas Simkus Date: Fri, 11 Feb 2022 10:25:40 +0000 Subject: [PATCH 005/153] Fixed typos in ContinuousBernoulli --- .../python/distributions/continuous_bernoulli.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tensorflow_probability/python/distributions/continuous_bernoulli.py b/tensorflow_probability/python/distributions/continuous_bernoulli.py index be6493df36..4d8e5c427f 100644 --- a/tensorflow_probability/python/distributions/continuous_bernoulli.py +++ b/tensorflow_probability/python/distributions/continuous_bernoulli.py @@ -59,7 +59,7 @@ def _log_xexp_ratio(x): x_squared = tf.math.square(x) - result = (dtype(np.log(2.)) + x_squared / 112. - + result = (dtype(np.log(2.)) + x_squared / 12. - 7 * tf.math.square(x_squared) / 1440.) middle_region = (x > small_cutoff) & (x < large_cutoff) safe_x_medium = tf.where(middle_region, x, dtype(1.)) @@ -200,9 +200,9 @@ def _log_normalizer(self, logits=None): # The normalizer is 2 * atanh(1 - 2 * probs) / (1 - 2 * probs), with the # removable singularity at probs = 0.5 removed (and replaced with 2). # We do this computation in logit space to be more numerically stable. - # Note that 2 * atanh(1 - 2 / (1 + exp(-logits))) = logits. + # Note that 2 * atanh(1 - 2 / (1 + exp(-logits))) = -logits. # Thus we end up with - # logits / (1 - 2 / (1 + exp(-logits))) = + # -logits / (1 - 2 / (1 + exp(-logits))) = # logits / ((-exp(-logits) + 1) / (exp(-logits) + 1)) = # (exp(-logits) + 1) * logits / (-exp(-logits) + 1) = # (1 + exp(logits)) * logits / (exp(logits) - 1) @@ -312,7 +312,7 @@ def _mean(self, logits=None): # 1 / (1 + exp(-logits)) / (2 / (1 + exp(-logits)) - 1) = # 1 / (2 - 1 - exp(-logits)) = # 1 / (1 - exp(-logits)) - # The second term becomes 1 / logits. + # The second term becomes - 1 / logits. # Thus we have mean = 1 / (1 - exp(-logits)) - 1 / logits. # When logits is close to zero, we can compute the Laurent series for the From 11959bcc1f027b104babca936bc10ce181427238 Mon Sep 17 00:00:00 2001 From: Vaidotas Simkus Date: Fri, 11 Feb 2022 11:14:08 +0000 Subject: [PATCH 006/153] Fix grad stability of mean (and kl) of the ContinuousBernoulli --- .../distributions/continuous_bernoulli.py | 31 ++++++++++++++----- .../continuous_bernoulli_test.py | 7 +++++ 2 files changed, 30 insertions(+), 8 deletions(-) diff --git a/tensorflow_probability/python/distributions/continuous_bernoulli.py b/tensorflow_probability/python/distributions/continuous_bernoulli.py index 4d8e5c427f..8e822904d8 100644 --- a/tensorflow_probability/python/distributions/continuous_bernoulli.py +++ b/tensorflow_probability/python/distributions/continuous_bernoulli.py @@ -320,6 +320,12 @@ def _mean(self, logits=None): # 1 / x + 1 / 2 + x / 12 - x**3 / 720 + x**5 / 30240 + O(x**7). # Thus we get the pole at zero canceling out with the second term. + # For large negative logits, the denominator (1 - exp(-logits)) in + # the first term yields inf values. Whilst the ratio still returns + # zero as it should, the gradients of this ratio become nan. + # Thus, noting that 1 / (1 - exp(-logits)) quickly tends towards 0 + # for large negative logits, the mean tends towards - 1 / logits. + dtype = dtype_util.as_numpy_dtype(self.dtype) eps = np.finfo(dtype).eps @@ -329,14 +335,23 @@ def _mean(self, logits=None): small_cutoff = np.power(eps * 30240, 1 / 5.) result = dtype(0.5) + logits / 12. - logits * tf.math.square(logits) / 720 - safe_logits_large = tf.where( - tf.math.abs(logits) > small_cutoff, logits, dtype(1.)) - return tf.where( - tf.math.abs(logits) > small_cutoff, - -(tf.math.reciprocal( - tf.math.expm1(-safe_logits_large)) + - tf.math.reciprocal(safe_logits_large)), - result) + large_cutoff = -np.log(eps) + + safe_logits_mask = ((tf.math.abs(logits) > small_cutoff) + & (logits > -large_cutoff)) + safe_logits = tf.where(safe_logits_mask, logits, dtype(1.)) + result = tf.where( + safe_logits_mask, + -(tf.math.reciprocal( + tf.math.expm1(-safe_logits)) + + tf.math.reciprocal(safe_logits)), + result) + + large_neg_mask = logits <= -large_cutoff + logits_large_neg = tf.where(large_neg_mask, logits, 1.) + return tf.where(large_neg_mask, + -tf.math.reciprocal(logits_large_neg), + result) def _variance(self): # The variance is var = probs (probs - 1) / (2 * probs - 1)**2 + diff --git a/tensorflow_probability/python/distributions/continuous_bernoulli_test.py b/tensorflow_probability/python/distributions/continuous_bernoulli_test.py index 2613bd118c..d8716dd9d0 100644 --- a/tensorflow_probability/python/distributions/continuous_bernoulli_test.py +++ b/tensorflow_probability/python/distributions/continuous_bernoulli_test.py @@ -356,6 +356,13 @@ def testMeanNearHalfStable(self): self.assertFalse(np.any(np.isinf(mean_))) self.assertFalse(np.any(np.isnan(mean_))) + @test_util.numpy_disable_gradient_test + def testMeanGradsAreNotNaN(self): + logits = np.linspace(-100, 100, 20)[..., np.newaxis].astype(np.float32) + _, grad_logits = tfp.math.value_and_gradient( + lambda x: tfd.ContinuousBernoulli(logits=x).mean(), logits) + self.assertAllNotNan(self.evaluate(grad_logits)) + def testVarianceAndStd(self): prob = [[0.2, 0.7], [0.8, 0.4]] dist = tfd.ContinuousBernoulli(probs=prob, validate_args=True) From e10aba94d26bc5e364ec7ea03bdfae53eadf191b Mon Sep 17 00:00:00 2001 From: Vishnuvardhan Janapati <46058173+jvishnuvardhan@users.noreply.github.com> Date: Fri, 18 Feb 2022 01:21:15 -0800 Subject: [PATCH 007/153] Correctly rendering iterated_filter by correcting backticks Backtics are not formatted well which is resulting in rendering issues. This PR updates those backticks. --- .../python/experimental/sequential/iterated_filter.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/experimental/sequential/iterated_filter.py b/tensorflow_probability/python/experimental/sequential/iterated_filter.py index 089a26659c..dcc2f6dbf3 100644 --- a/tensorflow_probability/python/experimental/sequential/iterated_filter.py +++ b/tensorflow_probability/python/experimental/sequential/iterated_filter.py @@ -773,7 +773,7 @@ def estimate_parameters(self, Args: observations: observed `Tensor` value(s) on which to condition the parameter estimate. - num_iterations: `int `Tensor` number of filtering iterations to run. + num_iterations: int `Tensor` number of filtering iterations to run. num_particles: scalar int `Tensor` number of particles to use. initial_perturbation_scale: scalar float `Tensor`, or any structure of float `Tensor`s broadcasting to the same shape as the (unconstrained) From 240afa27623872dcf1902632604190f48101100d Mon Sep 17 00:00:00 2001 From: Vishnuvardhan Janapati <46058173+jvishnuvardhan@users.noreply.github.com> Date: Fri, 18 Feb 2022 01:33:47 -0800 Subject: [PATCH 008/153] Update differential_evolution.py Formatted backticks to render the page correctly to display `differential_evolution` correctly --- .../python/optimizer/differential_evolution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/optimizer/differential_evolution.py b/tensorflow_probability/python/optimizer/differential_evolution.py index 9283ee02cb..79c5103303 100644 --- a/tensorflow_probability/python/optimizer/differential_evolution.py +++ b/tensorflow_probability/python/optimizer/differential_evolution.py @@ -144,7 +144,7 @@ def one_step( population is a `Tensor` of shape [n]. If the population is a python list of `Tensor`s then each `Tensor` in the list should have the first axis of a common size, say `n` and `objective_function(*population)` - should return a `Tensor of shape [n]. The population must have at least + should return a `Tensor` of shape [n]. The population must have at least 4 members for the algorithm to work correctly. population_values: A `Tensor` of rank 1 and real dtype. The result of applying `objective_function` to the `population`. If not supplied it is From b36bb16a43717e6d7826283b16e123a437a5efea Mon Sep 17 00:00:00 2001 From: mohantym <86464649+mohantym@users.noreply.github.com> Date: Mon, 21 Feb 2022 20:57:41 +0530 Subject: [PATCH 009/153] Fixed typo in kernel_bias.py Updated "Recomendations" to "Recommendations" --- .../python/experimental/nn/util/kernel_bias.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/experimental/nn/util/kernel_bias.py b/tensorflow_probability/python/experimental/nn/util/kernel_bias.py index e17e7e628f..e365aa8def 100644 --- a/tensorflow_probability/python/experimental/nn/util/kernel_bias.py +++ b/tensorflow_probability/python/experimental/nn/util/kernel_bias.py @@ -76,7 +76,7 @@ def make_kernel_bias( kernel: ... bias: ... - #### Recomendations: + #### Recommendations: ```python # tf.nn.relu ==> tf.initializers.he_* From 0ca065fb526b50ce38b68f7d5b803f02c78c8f16 Mon Sep 17 00:00:00 2001 From: liuxl Date: Tue, 22 Feb 2022 13:57:32 -0800 Subject: [PATCH 010/153] Add name scope to tfp dense variational layer's prior & posterior functions, to avoid duplicate tensor names and one is able to export the model correctly. PiperOrigin-RevId: 430289528 --- .../python/layers/dense_variational_v2.py | 18 ++++++++++-------- .../python/layers/dense_variational_v2_test.py | 11 ++++++++++- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/tensorflow_probability/python/layers/dense_variational_v2.py b/tensorflow_probability/python/layers/dense_variational_v2.py index 87ea963cc1..99e3be7e07 100644 --- a/tensorflow_probability/python/layers/dense_variational_v2.py +++ b/tensorflow_probability/python/layers/dense_variational_v2.py @@ -99,14 +99,16 @@ def build(self, input_shape): self.input_spec = tf.keras.layers.InputSpec( min_ndim=2, axes={-1: last_dim}) - self._posterior = self._make_posterior_fn( - last_dim * self.units, - self.units if self.use_bias else 0, - dtype) - self._prior = self._make_prior_fn( - last_dim * self.units, - self.units if self.use_bias else 0, - dtype) + with tf.name_scope('posterior'): + self._posterior = self._make_posterior_fn( + last_dim * self.units, + self.units if self.use_bias else 0, + dtype) + with tf.name_scope('prior'): + self._prior = self._make_prior_fn( + last_dim * self.units, + self.units if self.use_bias else 0, + dtype) self.built = True diff --git a/tensorflow_probability/python/layers/dense_variational_v2_test.py b/tensorflow_probability/python/layers/dense_variational_v2_test.py index 66203db243..24216252a4 100644 --- a/tensorflow_probability/python/layers/dense_variational_v2_test.py +++ b/tensorflow_probability/python/layers/dense_variational_v2_test.py @@ -87,9 +87,18 @@ def test_end_to_end(self): loss=negloglik) model.fit(x, y, epochs=2, verbose=False) + self.assertLen(model.layers, 2) + self.assertLen(model.layers[0].variables, 2) + self.assertEmpty(model.layers[1].variables) + + posterior, prior = model.layers[0].variables + self.assertNotEqual(prior.name, posterior.name) + self.assertContainsSubsequence(posterior.name, '/posterior/') + self.assertContainsSubsequence(prior.name, '/prior/') + # Profit. yhat = model(x_tst) - assert isinstance(yhat, tfd.Distribution) + self.assertIsInstance(yhat, tfd.Distribution) if __name__ == '__main__': From cc4cf7c253da42ae4a22ed276fbb89aae087edf3 Mon Sep 17 00:00:00 2001 From: ursk Date: Wed, 23 Feb 2022 10:54:04 -0800 Subject: [PATCH 011/153] Mark `distribution_test` and `mcmc/with_reductions_test` as medium to prevent timeouts. PiperOrigin-RevId: 430491685 --- tensorflow_probability/python/distributions/BUILD | 1 + tensorflow_probability/python/experimental/mcmc/BUILD | 1 + 2 files changed, 2 insertions(+) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index b207bf8833..35d00b2287 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -2634,6 +2634,7 @@ multi_substrate_py_test( multi_substrate_py_test( name = "distribution_test", + size = "medium", srcs = ["distribution_test.py"], jax_size = "medium", numpy_tags = ["notap"], diff --git a/tensorflow_probability/python/experimental/mcmc/BUILD b/tensorflow_probability/python/experimental/mcmc/BUILD index 21063e28b1..7926f4923b 100644 --- a/tensorflow_probability/python/experimental/mcmc/BUILD +++ b/tensorflow_probability/python/experimental/mcmc/BUILD @@ -658,6 +658,7 @@ multi_substrate_py_library( multi_substrate_py_test( name = "with_reductions_test", + size = "medium", srcs = ["with_reductions_test.py"], shard_count = 2, deps = [ From d73a833756fa866b0f9834b2bc0c8b7ac4ebb842 Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Wed, 23 Feb 2022 20:13:08 -0300 Subject: [PATCH 012/153] Add Skew Normal distribution --- .../python/distributions/BUILD | 34 ++ .../python/distributions/__init__.py | 2 + .../python/distributions/skew_normal.py | 475 ++++++++++++++++++ .../python/distributions/skew_normal_test.py | 450 +++++++++++++++++ 4 files changed, 961 insertions(+) create mode 100644 tensorflow_probability/python/distributions/skew_normal.py create mode 100644 tensorflow_probability/python/distributions/skew_normal_test.py diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index b207bf8833..7f59f59bc9 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -139,6 +139,7 @@ multi_substrate_py_library( ":sigmoid_beta", ":sinh_arcsinh", ":skellam", + ":skew_normal", ":spherical_uniform", ":stopping_ratio_logistic", ":student_t", @@ -1979,6 +1980,28 @@ multi_substrate_py_library( ], ) +multi_substrate_py_library( + name = "skew_normal", + srcs = ["skew_normal.py"], + deps = [ + ":distribution", + # numpy dep, + # tensorflow dep, + "//tensorflow_probability/python/bijectors:identity", + "//tensorflow_probability/python/bijectors:softplus", + "//tensorflow_probability/python/internal:assert_util", + "//tensorflow_probability/python/internal:dtype_util", + "//tensorflow_probability/python/internal:parameter_properties", + "//tensorflow_probability/python/internal:prefer_static", + "//tensorflow_probability/python/internal:reparameterization", + "//tensorflow_probability/python/internal:samplers", + "//tensorflow_probability/python/internal:special_math", + "//tensorflow_probability/python/internal:tensor_util", + "//tensorflow_probability/python/math", + "//tensorflow_probability/python/math:numeric", + ], +) + multi_substrate_py_library( name = "stopping_ratio_logistic", srcs = ["stopping_ratio_logistic.py"], @@ -3790,6 +3813,17 @@ multi_substrate_py_test( ], ) +multi_substrate_py_test( + name = "skew_normal_test", + srcs = ["skew_normal_test.py"], + deps = [ + # numpy dep, + # tensorflow dep, + "//tensorflow_probability", + "//tensorflow_probability/python/internal:test_util", + ], +) + multi_substrate_py_test( name = "stopping_ratio_logistic_test", srcs = ["stopping_ratio_logistic_test.py"], diff --git a/tensorflow_probability/python/distributions/__init__.py b/tensorflow_probability/python/distributions/__init__.py index 94edd05236..67c7f85663 100644 --- a/tensorflow_probability/python/distributions/__init__.py +++ b/tensorflow_probability/python/distributions/__init__.py @@ -117,6 +117,7 @@ from tensorflow_probability.python.distributions.sigmoid_beta import SigmoidBeta from tensorflow_probability.python.distributions.sinh_arcsinh import SinhArcsinh from tensorflow_probability.python.distributions.skellam import Skellam +from tensorflow_probability.python.distributions.skew_normal import SkewNormal from tensorflow_probability.python.distributions.spherical_uniform import SphericalUniform from tensorflow_probability.python.distributions.stopping_ratio_logistic import StoppingRatioLogistic from tensorflow_probability.python.distributions.student_t import StudentT @@ -270,6 +271,7 @@ 'SigmoidBeta', 'SinhArcsinh', 'Skellam', + 'SkewNormal', 'SphericalUniform', 'StoppingRatioLogistic', 'StudentT', diff --git a/tensorflow_probability/python/distributions/skew_normal.py b/tensorflow_probability/python/distributions/skew_normal.py new file mode 100644 index 0000000000..7651b6c055 --- /dev/null +++ b/tensorflow_probability/python/distributions/skew_normal.py @@ -0,0 +1,475 @@ +# Copyright 2022 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""The Skew Normal distribution class.""" + +# Dependency imports +import numpy as np + +import tensorflow.compat.v2 as tf + +from tensorflow_probability.python import math as tfp_math +from tensorflow_probability.python.bijectors import identity as identity_bijector +from tensorflow_probability.python.bijectors import softplus as softplus_bijector +from tensorflow_probability.python.distributions import distribution +from tensorflow_probability.python.internal import assert_util +from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import parameter_properties +from tensorflow_probability.python.internal import prefer_static as ps +from tensorflow_probability.python.internal import reparameterization +from tensorflow_probability.python.internal import samplers +from tensorflow_probability.python.internal import special_math +from tensorflow_probability.python.internal import tensor_util +from tensorflow_probability.python.math.numeric import log1psquare + +__all__ = [ + 'SkewNormal', +] + + +def standardize(value, loc, scale, skewness): + """Apply mean-variance-skewness standardization to input `value`. + + Note that scale and skewness can be negative. + + Args: + value: Floating-point tensor; the value(s) to be standardized. + loc: Floating-point tensor; the location(s) of the distribution(s). + scale: Floating-point tensor; the scale(s) of the distribution(s). + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + + Returns: + A tensor with shape broadcast according to the arguments. + """ + return (value - loc) / tf.math.abs(scale) * tf.math.abs( + tf.where(value < loc, x=skewness, y=tf.math.reciprocal(skewness))) + + +def cdf(value, loc, scale, skewness): + """Compute cumulative distribution function of Skew Normal distribution. + + Note that scale and skewness can be negative. + + Args: + value: Floating-point tensor; where to compute the cdf. + loc: Floating-point tensor; the location(s) of the distribution(s). + scale: Floating-point tensor; the scale(s) of the distribution(s). + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + + Returns: + A tensor with shape broadcast according to the arguments. + """ + one = tf.constant(1., dtype=loc.dtype) + two = tf.constant(2., dtype=loc.dtype) + + z = standardize(value, loc=loc, scale=scale, skewness=skewness) + normal_cdf = tf.cast(special_math.ndtr(z), dtype=loc.dtype) + + squared_skewness = tf.math.square(skewness) + return tf.math.reciprocal(one + squared_skewness) * tf.where( + z < 0., + x=two * normal_cdf, + y=one - squared_skewness + two * squared_skewness * normal_cdf) + + +def quantile(value, loc, scale, skewness): + """Compute quantile function (inverse cdf) of Skew Normal distribution. + + Note that scale and skewness can be negative. + + Args: + value: Floating-point tensor; where to compute the quantile function. + loc: Floating-point tensor; the location(s) of the distribution(s). + scale: Floating-point tensor; the scale(s) of the distribution(s). + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + + Returns: + A tensor with shape broadcast according to the arguments. + """ + half = tf.constant(0.5, dtype=loc.dtype) + one = tf.constant(1., dtype=loc.dtype) + two = tf.constant(2., dtype=loc.dtype) + + squared_skewness = tf.math.square(skewness) + cond = value < tf.math.reciprocal(one + squared_skewness) + + # Here we use the following fact: + # X ~ Normal(loc=0, scale=1) => 2 * X**2 ~ Gamma(alpha=0.5, beta=1) + rsquared_skewness = tf.math.reciprocal(squared_skewness) + probs = (one - value * (one + squared_skewness)) * tf.where( + cond, x=one, y=-rsquared_skewness) + gamma_quantile = tfp_math.igammainv(half, p=probs) + + abs_skewness = tf.math.abs(skewness) + adj_skewness = tf.where( + cond, x=-tf.math.reciprocal(abs_skewness), y=abs_skewness) + adj_scale = tf.math.abs(scale) * adj_skewness + + return loc + adj_scale * tf.cast( + tf.math.sqrt(two * gamma_quantile), dtype=loc.dtype) + + +class SkewNormal(distribution.AutoCompositeTensorDistribution): + """The Skew Normal distribution. + + The Skew Normal generalizes the Normal distribution with an additional shape + parameter. It is parameterized by location `loc`, scale `scale`, and shape + `skewness`. If the skewness is above one, the distribution becomes positively + skewed (or right-skewed). If the skewness is greater than zero and less than + one, the distribution becomes negatively skewed (or left-skewed). A skewness + equal to one results in a Normal distribution. + + #### Mathematical details + + The probability density function (pdf) is, + + ```none + pdf(x; loc, scale, skewness) = + k * normal_pdf(y * skewness; 0, 1) when x < loc, and + k * normal_pdf(y / skewness; 0, 1) when x >= loc + where + k = (2 * skewness) / ((1 + skewness**2) * scale) + y = (x - loc) / scale + ``` + + where `loc` is the location, `scale` is the scale, `skewness` is the shape + parameter, and `normal_pdf(x; 0, 1)` is the pdf of the Normal distribution + with zero mean and unit variance. + + The cumulative distribution function (cdf) is, + + ```none + cdf(x; loc, scale, skewness) = + k0 * normal_cdf(y * skewness; 0, 1) when x < loc, and + k1 + k2 * normal_cdf(y / skewness; 0, 1) when x >= loc + where + k0 = 2 / (1 + skewness**2) + k1 = (1 - skewness**2) / (1 + skewness**2) + k2 = (2 * skewness**2) / (1 + skewness**2) + y = (x - loc) / scale + ``` + + where `normal_cdf(x; 0, 1)` is the cdf of the Normal distribution with zero + mean and unit variance. + + The quantile function (inverse cdf) is, + + ```none + quantile(p; loc, scale, skewness) = + loc + s0 * normal_quantile(q0) when p <= 1 / (1 + skewness**2), and + loc + s1 * normal_quantile(q1) when p > 1 / (1 + skewness**2) + where + s0 = scale / skewness + s1 = scale * skewness + q0 = (p * (1 + skewness**2)) / 2 + q1 = (p * (1 + skewness**2) - 1 + skewness**2) / (2 * skewness**2) + y = (x - loc) / scale + ``` + + where `normal_quantile(x; 0, 1)` is the quantile function of the Normal + distribution with zero mean and unit variance. + + The mean and variance are, respectively, + + ```none + mean(loc, scale, skewness) = loc + scale * E(Y) + variance(loc, scale, skewness) = scale**2 * ( + skewness**2 + 1 / skewness**2 - 1 - E(Y)**2) + where + E(Y) = sqrt(2) / sqrt(pi) * (skewness - 1 / skewness) + ``` + + The Skew Normal distribution is a member of the [location-scale family]( + https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be + constructed as, + + ```none + Z ~ Normal(loc=0, scale=1) + W ~ Bernoulli(probs=1 / (1 + skewness**2)) + Y = (1 - W) * |Z| * skewness - W * |Z| / skewness + X = loc + scale * Y + ``` + + #### Examples + + Example of initialization of one distribution. + + ```python + import tensorflow_probability as tfp + tfd = tfp.distributions + + # Define a single scalar Skew Normal distribution. + dist = tfd.SkewNormal(loc=3., scale=10., skewness=0.75) + + # Evaluate the cdf at 1, returning a scalar. + dist.cdf(1.) + ``` + + Example of initialization of a batch of distributions. Arguments are + broadcast when possible. + + ```python + # Define a batch of three scalar valued Skew Normals. + # They have mean 3, scale 10, but different skewnesses. + dist = tfd.SkewNormal(loc=3., scale=10., skewness=[0.75, 1., 1.33]) + + # Get 2 samples, returning a 2 x 3 tensor. + value = dist.sample(2) + + # Evaluate the pdf of the distributions on the same points, value, + # returning a 2 x 3 tensor. + dist.prob(value) + ``` + + #### References + + [1]: Nabor O. Castillo et al. On the Fernández-Steel distribution: Inference + and application. _Computational Statistics & Data Analysis_, 55(11), + 2951-2961, 2011. + + [2]: Carmen Fernández and Mark F. J. Steel. On Bayesian modeling of fat tails + and skewness. _Journal of the American Statistical Association_, 93(441), + 359-371, 1998. + + [3]: Robert A. Rigby et al. _Distributions for modeling location, scale, and + shape: Using GAMLSS in R_. Chapman and Hall/CRC, 2019. + + """ + + def __init__(self, + loc, + scale, + skewness, + validate_args=False, + allow_nan_stats=True, + name='SkewNormal'): + """Construct Skew Normal distributions. + + The Skew Normal is parametrized with location `loc`, scale `scale`, and + shape parameter `skewness`. The parameters must be shaped in a way that + supports broadcasting (e.g. `loc + scale` is a valid operation). + + Args: + loc: Floating point tensor; the location(s) of the distribution(s). + scale: Floating point tensor; the scale(s) of the distribution(s). Must + contain only positive values. + skewness: Floating point tensor; the skewness(es) of the distribution(s). + Must contain only positive values. + validate_args: Python `bool`, default `False`. When `True`, distribution + parameters are checked for validity despite possibly degrading runtime + performance. When `False`, invalid inputs may silently render incorrect + outputs. + allow_nan_stats: Python `bool`, default `True`. When `True`, statistics + (e.g., mean, mode, variance) use the value "`NaN`" to indicate the + result is undefined. When `False`, an exception is raised if one or + more of the statistic's batch members are undefined. + name: Python `str` name prefixed to Ops created by this class. + + Raises: + TypeError: if `loc`, `scale`, and `skewness` have different `dtype`. + """ + parameters = dict(locals()) + with tf.name_scope(name) as name: + dtype = dtype_util.common_dtype( + [loc, scale, skewness], dtype_hint=tf.float32) + self._loc = tensor_util.convert_nonref_to_tensor( + loc, dtype=dtype, name='loc') + self._scale = tensor_util.convert_nonref_to_tensor( + scale, dtype=dtype, name='scale') + self._skewness = tensor_util.convert_nonref_to_tensor( + skewness, dtype=dtype, name='skewness') + super(SkewNormal, self).__init__( + dtype=dtype, + reparameterization_type=reparameterization.FULLY_REPARAMETERIZED, + validate_args=validate_args, + allow_nan_stats=allow_nan_stats, + parameters=parameters, + name=name) + + @classmethod + def _parameter_properties(cls, dtype, num_classes=None): + # pylint: disable=g-long-lambda + return dict( + loc=parameter_properties.ParameterProperties(), + scale=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), + skewness=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) + # pylint: enable=g-long-lambda + + @property + def loc(self): + """Distribution parameter for the location.""" + return self._loc + + @property + def scale(self): + """Distribution parameter for the scale.""" + return self._scale + + @property + def skewness(self): + """Distribution parameter for the skewness.""" + return self._skewness + + def _event_shape_tensor(self): + return tf.constant([], dtype=tf.int32) + + def _event_shape(self): + return tf.TensorShape([]) + + def _sample_n(self, n, seed=None): + loc = tf.convert_to_tensor(self.loc) + scale = tf.convert_to_tensor(self.scale) + skewness = tf.convert_to_tensor(self.skewness) + + batch_shape = self._batch_shape_tensor( + loc=loc, scale=scale, skewness=skewness) + sample_shape = ps.concat([[n], batch_shape], axis=0) + + uniform_seed, normal_seed = samplers.split_seed(seed, salt='skew_normal') + uniform_sample = samplers.uniform( + sample_shape, maxval=1., dtype=self.dtype, seed=uniform_seed) + normal_sample = samplers.normal( + sample_shape, dtype=self.dtype, seed=normal_seed) + + sample = tf.abs(normal_sample) * tf.where( + uniform_sample < tf.math.reciprocal(1. + skewness**2), + x=-tf.math.reciprocal(skewness), + y=skewness) + + return loc + scale * sample + + def _log_prob(self, value): + value = tf.convert_to_tensor(value, dtype_hint=self.dtype) + loc = tf.convert_to_tensor(self.loc) + scale = tf.convert_to_tensor(self.scale) + skewness = tf.convert_to_tensor(self.skewness) + + half = tf.constant(0.5, dtype=self.dtype) + two = tf.constant(2., dtype=self.dtype) + pi = tf.constant(np.pi, dtype=self.dtype) + + z = standardize(value, loc=loc, scale=scale, skewness=skewness) + + log_unnormalized = -half * tf.math.square(z) + log_normalization = ( + tf.cast(log1psquare(skewness), dtype=self.dtype) - + tf.math.log(two * skewness) + + tf.math.log(scale) + + half * tf.math.log(two * pi)) + + return log_unnormalized - log_normalization + + def _cdf(self, value): + value = tf.convert_to_tensor(value, dtype_hint=self.dtype) + loc = tf.convert_to_tensor(self.loc) + scale = tf.convert_to_tensor(self.scale) + skewness = tf.convert_to_tensor(self.skewness) + + return cdf(value, loc=loc, scale=scale, skewness=skewness) + + def _survival_function(self, value): + value = tf.convert_to_tensor(value, dtype_hint=self.dtype) + loc = tf.convert_to_tensor(self.loc) + scale = tf.convert_to_tensor(self.scale) + skewness = tf.convert_to_tensor(self.skewness) + + # Here we use the following property of this distribution: + # sf = 1. - cdf(value; loc, scale, skewness) + # = cdf(-value; -loc, scale, 1. / skewness) + return cdf(-value, loc=-loc, scale=scale, + skewness=tf.math.reciprocal(skewness)) + + def _quantile(self, value): + value = tf.convert_to_tensor(value, dtype_hint=self.dtype) + loc = tf.convert_to_tensor(self.loc) + scale = tf.convert_to_tensor(self.scale) + skewness = tf.convert_to_tensor(self.skewness) + + return quantile(value, loc=loc, scale=scale, skewness=skewness) + + def _mean(self): + loc = tf.convert_to_tensor(self.loc) + scale = tf.convert_to_tensor(self.scale) + skewness = tf.convert_to_tensor(self.skewness) + + two = tf.constant(2., dtype=self.dtype) + pi = tf.constant(np.pi, dtype=self.dtype) + + m = tf.math.sqrt(two / pi) * (skewness - tf.math.reciprocal(skewness)) + mean = loc + scale * m + + batch_shape = self._batch_shape_tensor( + loc=loc, scale=scale, skewness=skewness) + + return tf.broadcast_to(mean, shape=batch_shape) + + def _variance(self): + scale = tf.convert_to_tensor(self.scale) + skewness = tf.convert_to_tensor(self.skewness) + + one = tf.constant(1., dtype=self.dtype) + two = tf.constant(2., dtype=self.dtype) + pi = tf.constant(np.pi, dtype=self.dtype) + + m = tf.math.sqrt(two / pi) * (skewness - tf.math.reciprocal(skewness)) + squared_skewness = tf.math.square(skewness) + v = (squared_skewness + tf.math.reciprocal(squared_skewness) - one - + tf.math.square(m)) + variance = tf.square(scale) * v + + batch_shape = self._batch_shape_tensor(scale=scale, skewness=skewness) + + return tf.broadcast_to(variance, shape=batch_shape) + + def _mode(self): + loc = tf.convert_to_tensor(self.loc) + return tf.broadcast_to(loc, shape=self._batch_shape_tensor(loc=loc)) + + def _default_event_space_bijector(self): + return identity_bijector.Identity(validate_args=self.validate_args) + + def _parameter_control_dependencies(self, is_init): + assertions = [] + if is_init: + # _batch_shape() will raise error if it can statically prove that `loc`, + # `scale`, and `skewness` have incompatible shapes. + try: + self._batch_shape() + except ValueError: + raise ValueError('Arguments `loc`, `scale` and `skewness` ' + 'must have compatible shapes; ' + f'loc.shape={self.loc.shape}, ' + f'scale.shape={self.scale.shape}, ' + f'skewness.shape={self.skewness.shape}.') + # We don't bother checking the shapes in the dynamic case because + # all member functions access the three arguments anyway. + + if not self.validate_args: + assert not assertions # Should never happen. + return [] + + if is_init != tensor_util.is_ref(self.scale): + assertions.append( + assert_util.assert_positive( + self.scale, message='Argument `scale` must be positive.')) + if is_init != tensor_util.is_ref(self.skewness): + assertions.append( + assert_util.assert_positive( + self.skewness, message='Argument `skewness` must be positive.')) + + return assertions diff --git a/tensorflow_probability/python/distributions/skew_normal_test.py b/tensorflow_probability/python/distributions/skew_normal_test.py new file mode 100644 index 0000000000..3de06d029e --- /dev/null +++ b/tensorflow_probability/python/distributions/skew_normal_test.py @@ -0,0 +1,450 @@ +# Copyright 2022 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Tests for Skew Normal distribution.""" + +# Dependency imports +import numpy as np + +import tensorflow.compat.v2 as tf +import tensorflow_probability as tfp + +from tensorflow_probability.python.internal import test_util +from tensorflow.python.framework import test_util as tf_test_util # pylint: disable=g-direct-tensorflow-import + +tfd = tfp.distributions + + +@test_util.test_all_tf_execution_regimes +class _SkewNormalTest(object): + + def make_skew_normal(self): + if self.dtype is np.float32: + # Raw Python literals should always be interpreted as float32. + dist = tfd.SkewNormal( + loc=3., scale=10., skewness=0.75, validate_args=True) + elif self.dtype is np.float64: + dist = tfd.SkewNormal( + loc=tf.constant(3., dtype=self.dtype), + scale=tf.constant(10., dtype=self.dtype), + skewness=tf.constant(0.75, dtype=self.dtype), + validate_args=True) + + return dist + + def make_skew_normals(self): + if self.dtype is np.float32: + # Raw Python literals should always be interpreted as float32. + dist = tfd.SkewNormal( + loc=3., scale=10., skewness=[0.75, 1., 1.33], validate_args=True) + elif self.dtype is np.float64: + dist = tfd.SkewNormal( + loc=tf.constant(3., dtype=self.dtype), + scale=tf.constant(10., dtype=self.dtype), + skewness=tf.constant([0.75, 1., 1.33], dtype=self.dtype), + validate_args=True) + + return dist + + def helper_param_shapes(self, sample_shape, expected): + param_shapes = tfd.SkewNormal.param_shapes(sample_shape) + mu_shape = param_shapes['loc'] + sigma_shape = param_shapes['scale'] + skewness_shape = param_shapes['skewness'] + + self.assertAllEqual(expected, self.evaluate(mu_shape)) + self.assertAllEqual(expected, self.evaluate(sigma_shape)) + self.assertAllEqual(expected, self.evaluate(skewness_shape)) + + mu = tf.zeros(mu_shape) + sigma = tf.ones(sigma_shape) + skewness = tf.ones(skewness_shape) + seed = test_util.test_seed() + samples = tfd.SkewNormal( + mu, sigma, skewness, validate_args=True).sample(seed=seed) + + self.assertAllEqual(expected, self.evaluate(tf.shape(samples))) + + def helper_param_static_shapes(self, sample_shape, expected): + param_shapes = tfd.SkewNormal.param_static_shapes(sample_shape) + mu_shape = param_shapes['loc'] + sigma_shape = param_shapes['scale'] + skewness_shape = param_shapes['skewness'] + + self.assertEqual(expected, mu_shape) + self.assertEqual(expected, sigma_shape) + self.assertEqual(expected, skewness_shape) + + def testParamShapes(self): + sample_shape = [10, 3, 4] + self.helper_param_shapes(sample_shape, sample_shape) + self.helper_param_shapes(tf.constant(sample_shape), sample_shape) + + def testParamStaticShapes(self): + sample_shape = [10, 3, 4] + self.helper_param_static_shapes(sample_shape, sample_shape) + self.helper_param_static_shapes( + tf.TensorShape(sample_shape), sample_shape) + + def testSampleLikeArgsGetDistDType(self): + dist = self.make_skew_normal() + + self.assertEqual(self.dtype, dist.dtype) + + seed = test_util.test_seed() + self.assertEqual(self.dtype, dist.sample(1, seed=seed).dtype) + + for method in ('prob', 'cdf', 'survival_function', 'quantile', + 'log_prob', 'log_cdf', 'log_survival_function'): + self.assertEqual(self.dtype, getattr(dist, method)(1).dtype) + + for method in ('mean', 'variance', 'mode'): + self.assertEqual(self.dtype, getattr(dist, method)().dtype) + + def testShape(self): + for dist in (self.make_skew_normal(), self.make_skew_normals()): + expected_batch_shape = dist.skewness.shape + self.assertEqual( + list(self.evaluate(dist.batch_shape_tensor())), + list(expected_batch_shape)) + self.assertEqual(dist.batch_shape, expected_batch_shape) + self.assertAllEqual(self.evaluate(dist.event_shape_tensor()), []) + self.assertEqual(dist.event_shape, tf.TensorShape([])) + + n = 10 + sample = dist.sample(n, seed=test_util.test_seed()) + results = [sample] + + for method in ('prob', 'cdf', 'survival_function', + 'log_prob', 'log_cdf', 'log_survival_function'): + results.append(getattr(dist, method)(sample)) + + probs = dist.cdf(sample) + results.append(dist.quantile(probs)) + + for result in results: + self.assertAllEqual( + [n] + list(self.evaluate(dist.batch_shape_tensor())), result.shape) + self.assertAllEqual( + [n] + list(self.evaluate(dist.batch_shape_tensor())), + self.evaluate(result).shape) + self.assertAllEqual([n] + dist.batch_shape, result.shape) + self.assertAllEqual( + [n] + dist.batch_shape, self.evaluate(result).shape) + + for method in ('mean', 'variance', 'mode'): + result = getattr(dist, method)() + self.assertAllEqual( + self.evaluate(dist.batch_shape_tensor()), result.shape) + self.assertAllEqual( + self.evaluate(dist.batch_shape_tensor()), + self.evaluate(result).shape) + self.assertAllEqual(dist.batch_shape, result.shape) + self.assertAllEqual(dist.batch_shape, self.evaluate(result).shape) + + def testSample(self): + dist = self.make_skew_normals() + + seed_stream = test_util.test_seed_stream() + + n = 100_000 + one = tf.constant(1., dtype=self.dtype) + + sample = dist.sample(n, seed=seed_stream()) + + uniform_sample = tf.random.uniform( + sample.shape, maxval=1., dtype=self.dtype, seed=seed_stream()) + sign = tf.where(uniform_sample < 0.5, -one, one) + normal_sample = self.evaluate(sign * tfd.skew_normal.standardize( + sample, loc=dist.loc, scale=dist.scale, skewness=dist.skewness)) + + # Note that the standard error for the sample mean is ~ sigma / sqrt(n). + # The sample variance similarly is dependent on scale and n. + # Thus, the tolerances below are very sensitive to number of samples + # as well as the variances chosen. + self.assertAllEqual(normal_sample.shape, [n] + dist.batch_shape) + self.assertAllClose(np.mean(normal_sample), 0.0, atol=0.1) + self.assertAllClose(np.std(normal_sample), 1.0, atol=0.1) + + def testLogPDF(self): + dist = self.make_skew_normals() + + x = np.array([[-35.], [3.], [20.]], dtype=self.dtype) + + log_pdf = self.evaluate(dist.log_prob(x)) + # The following values were calculated using the R package gamlss.dist. + # Package version: 5.3-2. Distribution: SN2. + expected_log_pdf = np.array([ + [-7.323596, -10.44152, -16.03311], + [-3.262346, -3.221524, -3.261648], + [-5.831235, -4.666524, -4.078539], + ], dtype=self.dtype) + + self.assertAllEqual(log_pdf.shape, expected_log_pdf.shape) + self.assertAllClose(log_pdf, expected_log_pdf) + + def testCDF(self): + dist = self.make_skew_normals() + + x = np.array([[-35.], [3.], [20.]], dtype=self.dtype) + + cdf = self.evaluate(dist.cdf(x)) + # The following values were calculated using the R package 'gamlss.dist'. + # Package version: 5.3-2. Distribution: SN2. + expected_cdf = np.array([ + [2.798031e-03, 7.234804e-05, 1.562540e-07], + [6.400000e-01, 5.000000e-01, 3.611542e-01], + [9.915722e-01, 9.554345e-01, 8.714767e-01], + ], dtype=self.dtype) + + self.assertAllEqual(cdf.shape, expected_cdf.shape) + self.assertAllClose(cdf, expected_cdf) + + def testSurvivalFunction(self): + dist = self.make_skew_normals() + + x = np.array([[-35.], [3.], [20.]], dtype=self.dtype) + + sf = self.evaluate(dist.survival_function(x)) + # The following values were calculated using the R package 'gamlss.dist'. + # Package version: 5.3-2. Distribution: SN2. + expected_sf = np.array([ + [9.972020e-01, 9.999277e-01, 9.999998e-01], + [3.600000e-01, 5.000000e-01, 6.388458e-01], + [8.427815e-03, 4.456546e-02, 1.285233e-01], + ], dtype=self.dtype) + + self.assertAllEqual(sf.shape, expected_sf.shape) + self.assertAllClose(sf, expected_sf) + + def testQuantile(self): + dist = self.make_skew_normals() + + x = np.array([[0.000001], [0.5], [0.999999]], dtype=self.dtype) + + quantile = self.evaluate(dist.quantile(x)) + # The following values were calculated using the R package 'gamlss.dist'. + # Package version: 5.3-2. Distribution: SN2. + expected_quantile = np.array([ + [-61.040950, -44.53424, -32.24254], + [-0.7025392, 3.0000000, 6.6688350], + [38.1495200, 50.534240, 66.876050], + ], dtype=self.dtype) + + self.assertAllEqual(quantile.shape, expected_quantile.shape) + self.assertAllClose( + a=quantile, + b=expected_quantile, + rtol=1e-03 if self.dtype == np.float32 else 1e-06) + + def testMean(self): + dist = self.make_skew_normals() + + mean = self.evaluate(dist.mean()) + expected_mean = np.array([-1.6543264, 3., 7.612733], dtype=self.dtype) + + self.assertAllEqual(mean.shape, expected_mean.shape) + self.assertAllClose(mean, expected_mean) + + def testVariance(self): + dist = self.make_skew_normals() + + variance = self.evaluate(dist.variance()) + expected_variance = np.array( + [112.365005, 100., 112.14502], dtype=self.dtype) + + self.assertAllEqual(variance.shape, expected_variance.shape) + self.assertAllClose(variance, expected_variance) + + def testMode(self): + dist = self.make_skew_normals() + + mode = self.evaluate(dist.mode()) + expected_mode = np.array([3., 3., 3.], dtype=self.dtype) + + self.assertAllEqual(mode.shape, expected_mode.shape) + self.assertAllClose(mode, expected_mode) + + @test_util.numpy_disable_gradient_test + def testFiniteGradientAtDifficultPoints(self): + def make_fn(attr): + x = np.array([-100, -20, -5., 0., 5., 20, 100]).astype(self.dtype) + return lambda m, s, g: getattr( # pylint: disable=g-long-lambda + tfd.SkewNormal(m, scale=s, skewness=g, validate_args=True), attr)(x) + + loc = tf.constant(0., self.dtype) + scale = tf.constant(1., self.dtype) + + # TODO: add 'log_cdf' and 'log_survival_function'. + # 'log_cdf' currently fails at -100 in fp64 and at -100, -20 in fp32. + # 'log_survival_function' currently fails at 100, 20 in fp64 and at 100, + # 20, 5 in fp32. + # We've already tried the following ideas to solve these problems: + # * Implementing the log_cdf method directly using the Log Normal + # distribution function (log_ndtr) when value < loc; + # * Implementing the cdf method using the Gamma distribution function; and + # * Implementing the cdf method using the Student's t distribution function + # when value < loc. + for skewness in [0.75, 1., 1.33]: + for attr in ('prob', 'cdf', 'survival_function', 'log_prob'): + value, grads = self.evaluate( + tfp.math.value_and_gradient( + make_fn(attr), + [loc, scale, tf.constant(skewness, self.dtype)])) + self.assertAllFinite(value) + self.assertAllFinite(grads[0]) # d/d loc + self.assertAllFinite(grads[1]) # d/d scale + self.assertAllFinite(grads[2]) # d/d skewness + + @test_util.numpy_disable_gradient_test + def testQuantileFiniteGradientAtDifficultPoints(self): + def quantile(loc, scale, skewness, probs): + dist = tfd.SkewNormal( + loc, scale=scale, skewness=skewness, validate_args=True) + return dist.quantile(probs) + + x = -17. if self.dtype == np.float32 else -33. + loc = tf.constant(0., self.dtype) + scale = tf.constant(1., self.dtype) + probs = tf.constant( + [np.exp(x), np.exp(-2.), 1. - np.exp(-2.), 1. - np.exp(x)], + dtype=self.dtype) + + for skewness in [0.75, 1., 1.33]: + value, grads = tfp.math.value_and_gradient( + quantile, [loc, scale, tf.constant(skewness, self.dtype), probs]) + self.assertAllFinite(value) + self.assertAllFinite(grads[0]) # d/d loc + self.assertAllFinite(grads[1]) # d/d scale + self.assertAllFinite(grads[2]) # d/d skewness + self.assertAllFinite(grads[3]) # d/d probs + + @test_util.numpy_disable_gradient_test + def testFullyReparameterized(self): + n = 100 + def sampler(loc, scale, skewness): + dist = tfd.SkewNormal( + loc, scale=scale, skewness=skewness, validate_args=True) + return dist.sample(n, seed=test_util.test_seed()) + + loc = tf.constant(0., self.dtype) + scale = tf.constant(1., self.dtype) + + for skewness in [0.75, 1., 1.33]: + _, grads = tfp.math.value_and_gradient( + sampler, [loc, scale, tf.constant(skewness, self.dtype)]) + self.assertIsNotNone(grads[0]) # d/d loc + self.assertIsNotNone(grads[1]) # d/d scale + self.assertIsNotNone(grads[2]) # d/d skewness + + def testNegativeScaleSkewnessFails(self): + with self.assertRaisesOpError('Argument `scale` must be positive.'): + dist = tfd.SkewNormal( + loc=[0.], scale=[-1.], skewness=[1.], validate_args=True) + self.evaluate(dist.mean()) + + with self.assertRaisesOpError('Argument `skewness` must be positive.'): + dist = tfd.SkewNormal( + loc=[0.], scale=[1.], skewness=[-1.], validate_args=True) + self.evaluate(dist.mean()) + + @test_util.jax_disable_variable_test + @test_util.numpy_disable_test_missing_functionality( + 'NumpyVariable does not handle unknown shapes') + def testShapeWithPlaceholders(self): + loc = tf.Variable(self.dtype(0), shape=tf.TensorShape(None)) + scale = tf.Variable(self.dtype([1., 2.]), shape=tf.TensorShape(None)) + skewness = tf.Variable( + self.dtype([[0.75, 1.33]]).T, shape=tf.TensorShape(None)) + self.evaluate([loc.initializer, scale.initializer, skewness.initializer]) + dist = tfd.SkewNormal( + loc=loc, scale=scale, skewness=skewness, validate_args=True) + + # get_batch_shape should return an '' tensor (graph mode only). + self.assertEqual(dist.event_shape, ()) + self.assertEqual(dist.batch_shape, tf.TensorShape(None)) + self.assertAllEqual(self.evaluate(dist.event_shape_tensor()), []) + self.assertAllEqual(self.evaluate(dist.batch_shape_tensor()), [2, 2]) + + def testVariableSkewness(self): + loc = tf.constant(0., self.dtype) + scale = tf.constant(1., self.dtype) + skewness = tf.Variable(1., dtype=self.dtype) + dist = tfd.SkewNormal( + loc=loc, scale=scale, skewness=skewness, validate_args=True) + + self.evaluate([v.initializer for v in dist.variables]) + self.assertIs(skewness, dist.skewness) + self.assertEqual(0., self.evaluate(dist.mean())) + + with self.assertRaisesOpError('Argument `skewness` must be positive.'): + with tf.control_dependencies([skewness.assign(-1.)]): + self.evaluate(dist.mean()) + + def testIncompatibleArgShapesGraph(self): + skewness = tf.Variable( + tf.ones([2, 3], dtype=self.dtype), shape=tf.TensorShape(None)) + self.evaluate(skewness.initializer) + + with self.assertRaisesRegexp(Exception, r'compatible shapes'): + dist = tfd.SkewNormal( + loc=tf.zeros([4, 1], dtype=self.dtype), + scale=tf.ones([4, 1], dtype=self.dtype), + skewness=skewness, + validate_args=True) + self.evaluate(dist.mean()) + + +class SkewNormalEagerGCTest(test_util.TestCase): + + @tf_test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True) + def testMeanAndMode(self): + dist = tfd.SkewNormal( + loc=3., scale=10., skewness=[0.75, 1., 1.33], validate_args=True) + + self.assertAllEqual((3,), dist.mean().shape) + expected_mean = np.array([-1.6543264, 3., 7.612733], dtype=np.float32) + self.assertAllClose(expected_mean, self.evaluate(dist.mean())) + + self.assertAllEqual((3,), dist.mode().shape) + expected_mode = np.array([3., 3., 3.], dtype=np.float32) + self.assertAllEqual(expected_mode, self.evaluate(dist.mode())) + + +@test_util.test_all_tf_execution_regimes +class SkewNormalTestStaticShapeFloat32(test_util.TestCase, _SkewNormalTest): + dtype = np.float32 + use_static_shape = True + + +@test_util.test_all_tf_execution_regimes +class SkewNormalTestDynamicShapeFloat32(test_util.TestCase, _SkewNormalTest): + dtype = np.float32 + use_static_shape = False + + +@test_util.test_all_tf_execution_regimes +class SkewNormalTestStaticShapeFloat64(test_util.TestCase, _SkewNormalTest): + dtype = np.float64 + use_static_shape = True + + +@test_util.test_all_tf_execution_regimes +class SkewNormalTestDynamicShapeFloat64(test_util.TestCase, _SkewNormalTest): + dtype = np.float64 + use_static_shape = False + + +if __name__ == '__main__': + test_util.main() From b4afb71c60e0b61127cbab4b7d39f3e962b558ad Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Wed, 23 Feb 2022 20:57:12 -0300 Subject: [PATCH 013/153] Remove intermediate variable --- tensorflow_probability/python/distributions/skew_normal.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tensorflow_probability/python/distributions/skew_normal.py b/tensorflow_probability/python/distributions/skew_normal.py index 7651b6c055..9530e74305 100644 --- a/tensorflow_probability/python/distributions/skew_normal.py +++ b/tensorflow_probability/python/distributions/skew_normal.py @@ -106,9 +106,8 @@ def quantile(value, loc, scale, skewness): # Here we use the following fact: # X ~ Normal(loc=0, scale=1) => 2 * X**2 ~ Gamma(alpha=0.5, beta=1) - rsquared_skewness = tf.math.reciprocal(squared_skewness) probs = (one - value * (one + squared_skewness)) * tf.where( - cond, x=one, y=-rsquared_skewness) + cond, x=one, y=-tf.math.reciprocal(squared_skewness)) gamma_quantile = tfp_math.igammainv(half, p=probs) abs_skewness = tf.math.abs(skewness) From 24cb2546fa07e31fd6df12d6449642d7ef817613 Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Wed, 23 Feb 2022 21:03:11 -0300 Subject: [PATCH 014/153] Remove intermediate variable --- tensorflow_probability/python/distributions/skew_normal.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tensorflow_probability/python/distributions/skew_normal.py b/tensorflow_probability/python/distributions/skew_normal.py index 9530e74305..1606d9742b 100644 --- a/tensorflow_probability/python/distributions/skew_normal.py +++ b/tensorflow_probability/python/distributions/skew_normal.py @@ -111,9 +111,8 @@ def quantile(value, loc, scale, skewness): gamma_quantile = tfp_math.igammainv(half, p=probs) abs_skewness = tf.math.abs(skewness) - adj_skewness = tf.where( + adj_scale = tf.math.abs(scale) * tf.where( cond, x=-tf.math.reciprocal(abs_skewness), y=abs_skewness) - adj_scale = tf.math.abs(scale) * adj_skewness return loc + adj_scale * tf.cast( tf.math.sqrt(two * gamma_quantile), dtype=loc.dtype) From cdb9ac0b91a0edd82a2e912631f4d4f1e1e442a8 Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Thu, 24 Feb 2022 00:38:43 -0800 Subject: [PATCH 015/153] Add tfp.experimental.distributions.MultiTaskGaussianProcessRegressionModel PiperOrigin-RevId: 430637783 --- .../python/experimental/distributions/BUILD | 28 ++ .../experimental/distributions/__init__.py | 2 + ...itask_gaussian_process_regression_model.py | 448 ++++++++++++++++++ ..._gaussian_process_regression_model_test.py | 401 ++++++++++++++++ 4 files changed, 879 insertions(+) create mode 100644 tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py create mode 100644 tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py diff --git a/tensorflow_probability/python/experimental/distributions/BUILD b/tensorflow_probability/python/experimental/distributions/BUILD index 44dd3e3665..ecf01bc52a 100644 --- a/tensorflow_probability/python/experimental/distributions/BUILD +++ b/tensorflow_probability/python/experimental/distributions/BUILD @@ -37,6 +37,7 @@ multi_substrate_py_library( ":joint_distribution_pinned", ":marginal_fns", ":multitask_gaussian_process", + ":multitask_gaussian_process_regression_model", ":mvn_precision_factor_linop", "//tensorflow_probability/python/distributions:log_prob_ratio", ], @@ -170,6 +171,33 @@ multi_substrate_py_test( ], ) +multi_substrate_py_library( + name = "multitask_gaussian_process_regression_model", + srcs = ["multitask_gaussian_process_regression_model.py"], + deps = [ + # numpy dep, + # tensorflow dep, + "//tensorflow_probability/python/distributions:cholesky_util", + "//tensorflow_probability/python/internal:dtype_util", + "//tensorflow_probability/python/math/psd_kernels/internal:util", + ], +) + +multi_substrate_py_test( + name = "multitask_gaussian_process_regression_model_test", + size = "medium", + srcs = ["multitask_gaussian_process_regression_model_test.py"], + shard_count = 2, + deps = [ + # absl/testing:parameterized dep, + # numpy dep, + # tensorflow dep, + "//tensorflow_probability", + "//tensorflow_probability/python/experimental", + "//tensorflow_probability/python/internal:test_util", + ], +) + multi_substrate_py_library( name = "mvn_precision_factor_linop", srcs = ["mvn_precision_factor_linop.py"], diff --git a/tensorflow_probability/python/experimental/distributions/__init__.py b/tensorflow_probability/python/experimental/distributions/__init__.py index 663cfbea7c..21a441cf71 100644 --- a/tensorflow_probability/python/experimental/distributions/__init__.py +++ b/tensorflow_probability/python/experimental/distributions/__init__.py @@ -20,6 +20,7 @@ from tensorflow_probability.python.experimental.distributions.increment_log_prob import IncrementLogProb from tensorflow_probability.python.experimental.distributions.joint_distribution_pinned import JointDistributionPinned from tensorflow_probability.python.experimental.distributions.multitask_gaussian_process import MultiTaskGaussianProcess +from tensorflow_probability.python.experimental.distributions.multitask_gaussian_process_regression_model import MultiTaskGaussianProcessRegressionModel from tensorflow_probability.python.experimental.distributions.mvn_precision_factor_linop import MultivariateNormalPrecisionFactorLinearOperator @@ -29,5 +30,6 @@ 'JointDistributionPinned', 'marginal_fns', 'MultiTaskGaussianProcess', + 'MultiTaskGaussianProcessRegressionModel', 'MultivariateNormalPrecisionFactorLinearOperator', ] diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py new file mode 100644 index 0000000000..a66bf46359 --- /dev/null +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py @@ -0,0 +1,448 @@ +# Copyright 2021 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""The MultiTaskGaussianProcessRegressionModel distribution class.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import functools + +# Dependency imports + +import tensorflow.compat.v2 as tf +from tensorflow_probability.python.distributions import cholesky_util +from tensorflow_probability.python.distributions import distribution +from tensorflow_probability.python.distributions import mvn_linear_operator +from tensorflow_probability.python.experimental.psd_kernels import multitask_kernel +from tensorflow_probability.python.internal import distribution_util +from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import prefer_static as ps +from tensorflow_probability.python.internal import reparameterization +from tensorflow_probability.python.internal import tensor_util +from tensorflow_probability.python.internal import tensorshape_util +from tensorflow_probability.python.math.psd_kernels.internal import util as psd_kernels_util + + +def _vec(x): + # Vec takes in a (batch) of matrices of shape B1 + [n, k] and returns + # a (batch) of vectors of shape B1 + [n * k]. + return tf.reshape(x, ps.concat([ps.shape(x)[:-2], [-1]], axis=0)) + + +def _unvec(x, matrix_shape): + # Unvec takes in a (batch) of matrices of shape B1 + [n * k] and returns + # a (batch) of vectors of shape B1 + [n, k], where n and k are specified + # by matrix_shape. + return tf.reshape(x, ps.concat([ps.shape(x)[:-1], matrix_shape], axis=0)) + + +def _add_diagonal_shift(m, c): + return tf.linalg.set_diag(m, tf.linalg.diag_part(m) + c[..., tf.newaxis]) + + +class MultiTaskGaussianProcessRegressionModel(distribution.Distribution): + """Posterior predictive in a conjugate Multi-task GP regression model.""" + + def __init__(self, + kernel, + observation_index_points, + observations, + observations_is_missing=None, + index_points=None, + mean_fn=None, + observation_noise_variance=None, + predictive_noise_variance=None, + cholesky_fn=None, + validate_args=False, + allow_nan_stats=False, + name='MultiTaskGaussianProcessRegressionModelWithCholesky'): + """Construct a MultiTaskGaussianProcessRegressionModelWithCholesky instance. + + WARNING: This method assumes `index_points` is the only varying parameter + (i.e. is a `Variable` / changes after initialization) and hence is not + tape-safe. + + Args: + kernel: `MultiTaskKernel`-like instance representing the GP's covariance + function. + observation_index_points: `float` `Tensor` representing finite collection, + or batch of collections, of points in the index set for which some data + has been observed. Shape has the form `[b1, ..., bB, e, f1, ..., fF]` + where `F` is the number of feature dimensions and must equal + `kernel.feature_ndims`, and `e` is the number (size) of index points in + each batch. `[b1, ..., bB, e]` must be broadcastable with the shape of + `observations`, and `[b1, ..., bB]` must be broadcastable with the + shapes of all other batched parameters (`kernel.batch_shape`, + `index_points`, etc). + observations: `float` `Tensor` representing collection, or batch of + collections, of observations corresponding to + `observation_index_points`. Shape has the form `[b1, ..., bB, e, t]`, + which must be broadcastable with the batch and example shapes of + `observation_index_points`. The batch shape `[b1, ..., bB]` must be + broadcastable with the shapes of all other batched parameters + (`kernel.batch_shape`, `index_points`, etc.). + observations_is_missing: `bool` `Tensor` of shape `[..., e, t]`, + representing a batch of boolean masks. When + `observations_is_missing` is not `None`, this distribution is + conditioned only on the observations for which the + corresponding elements of `observations_is_missing` are `False`. + index_points: `float` `Tensor` representing finite collection, or batch of + collections, of points in the index set over which the GP is defined. + Shape has the form `[b1, ..., bB, e, f1, ..., fF]` where `F` is the + number of feature dimensions and must equal `kernel.feature_ndims` and + `e` is the number (size) of index points in each batch. Ultimately this + distribution corresponds to an `e`-dimensional multivariate normal. The + batch shape must be broadcastable with `kernel.batch_shape`. + mean_fn: Python `callable` that acts on `index_points` to produce a (batch + of) collection of mean values at `index_points`. Takes a `Tensor` of + shape `[b1, ..., bB, e, f1, ..., fF]` and returns a `Tensor` whose shape + is broadcastable with `[b1, ..., bB, e, t]`, where `t` is the number of + tasks. + observation_noise_variance: `float` `Tensor` representing the variance of + the noise in the Normal likelihood distribution of the model. May be + batched, in which case the batch shape must be broadcastable with the + shapes of all other batched parameters (`kernel.batch_shape`, + `index_points`, etc.). + Default value: `None` + predictive_noise_variance: `float` `Tensor` representing the variance in + the posterior predictive model. If `None`, we simply re-use + `observation_noise_variance` for the posterior predictive noise. If set + explicitly, however, we use this value. This allows us, for example, to + omit predictive noise variance (by setting this to zero) to obtain + noiseless posterior predictions of function values, conditioned on noisy + observations. + cholesky_fn: Callable which takes a single (batch) matrix argument and + returns a Cholesky-like lower triangular factor. Default value: `None`, + in which case `make_cholesky_with_jitter_fn(1e-6)` is used. + validate_args: Python `bool`, default `False`. When `True` distribution + parameters are checked for validity despite possibly degrading runtime + performance. When `False` invalid inputs may silently render incorrect + outputs. + Default value: `False`. + allow_nan_stats: Python `bool`, default `True`. When `True`, statistics + (e.g., mean, mode, variance) use the value `NaN` to indicate the result + is undefined. When `False`, an exception is raised if one or more of the + statistic's batch members are undefined. + Default value: `False`. + name: Python `str` name prefixed to Ops created by this class. + Default value: 'MultiTaskGaussianProcessRegressionModel'. + """ + parameters = dict(locals()) + with tf.name_scope(name) as name: + + if not isinstance(kernel, multitask_kernel.MultiTaskKernel): + raise ValueError('`kernel` must be a `MultiTaskKernel`.') + + dtype = dtype_util.common_dtype([ + index_points, observation_index_points, observations, + observation_noise_variance, predictive_noise_variance + ], tf.float32) + index_points = tensor_util.convert_nonref_to_tensor( + index_points, dtype=dtype, name='index_points') + observation_index_points = tf.convert_to_tensor( + observation_index_points, + dtype=dtype, + name='observation_index_points') + observations = tf.convert_to_tensor( + observations, dtype=dtype, name='observations') + if observations_is_missing is not None: + observations_is_missing = tf.convert_to_tensor( + observations_is_missing, dtype=tf.bool) + if observation_noise_variance is not None: + observation_noise_variance = tf.convert_to_tensor( + observation_noise_variance, + dtype=dtype, + name='observation_noise_variance') + predictive_noise_variance = tensor_util.convert_nonref_to_tensor( + predictive_noise_variance, + dtype=dtype, + name='predictive_noise_variance') + if predictive_noise_variance is None: + predictive_noise_variance = observation_noise_variance + if cholesky_fn is None: + self._cholesky_fn = cholesky_util.make_cholesky_with_jitter_fn() + else: + if not callable(cholesky_fn): + raise ValueError('`cholesky_fn` must be a Python callable') + self._cholesky_fn = cholesky_fn + + self._kernel = kernel + self._index_points = index_points + + # Scalar or vector the size of the number of tasks. + if mean_fn is not None: + if not callable(mean_fn): + raise ValueError('`mean_fn` must be a Python callable') + self._mean_fn = mean_fn + self._observation_noise_variance = observation_noise_variance + self._predictive_noise_variance = predictive_noise_variance + self._index_ponts = index_points + self._observation_index_points = observation_index_points + self._observations = observations + self._observations_is_missing = observations_is_missing + + observation_covariance = self.kernel.matrix_over_all_tasks( + observation_index_points, observation_index_points) + + if observation_noise_variance is not None: + observation_covariance = observation_covariance.to_dense() + broadcast_shape = distribution_util.get_broadcast_shape( + observation_covariance, observation_noise_variance[..., tf.newaxis, + tf.newaxis]) + observation_covariance = tf.broadcast_to(observation_covariance, + broadcast_shape) + observation_covariance = _add_diagonal_shift(observation_covariance, + observation_noise_variance) + observation_covariance = tf.linalg.LinearOperatorFullMatrix( + observation_covariance, + is_non_singular=True, + is_positive_definite=True) + + if observations_is_missing is not None: + vec_observations_is_missing = _vec(observations_is_missing) + observation_covariance = tf.linalg.LinearOperatorFullMatrix( + psd_kernels_util.mask_matrix( + observation_covariance.to_dense(), + mask=~vec_observations_is_missing), + is_non_singular=True, + is_positive_definite=True) + + self._observation_cholesky = cholesky_util.cholesky_from_fn( + observation_covariance, self._cholesky_fn) + + # Note that the conditional mean is + # k(x, o) @ (k(o, o) + sigma**2)^-1 obs. We can precompute the latter + # term since it won't change per iteration. + if mean_fn: + vec_observations = _vec(observations - + mean_fn(observation_index_points)) + else: + vec_observations = _vec(observations) + if observations_is_missing is not None: + vec_observations = tf.where(~vec_observations_is_missing, + vec_observations, + tf.zeros([], dtype=vec_observations.dtype)) + self._solve_on_obs = self._observation_cholesky.solvevec( + self._observation_cholesky.solvevec(vec_observations), adjoint=True) + super(MultiTaskGaussianProcessRegressionModel, self).__init__( + dtype=dtype, + reparameterization_type=(reparameterization.FULLY_REPARAMETERIZED), + validate_args=validate_args, + allow_nan_stats=allow_nan_stats, + parameters=parameters, + name=name) + + @property + def mean_fn(self): + # Default to a constant zero function, borrowing the dtype from + # the class for consisency. + if self._mean_fn is not None: + return self._mean_fn + + def _mean_fn(x): + # Shape B1 + [E, N], where E is the number of index points, and N is the + # number of tasks. + res = tf.zeros( + tf.concat([ + tf.shape(x)[:-self.kernel.feature_ndims], [self.kernel.num_tasks] + ], + axis=0), + dtype=self.dtype) + return res + + return _mean_fn + + def _conditional_mean_fn(self, x): + """Conditional mean.""" + k_x_obs_linop = self.kernel.matrix_over_all_tasks( + x, self._observation_index_points) + if self._observations_is_missing is not None: + k_x_obs_linop = tf.linalg.LinearOperatorFullMatrix( + tf.where(_vec(tf.math.logical_not( + self._observations_is_missing))[..., tf.newaxis, :], + k_x_obs_linop.to_dense(), + tf.zeros([], dtype=k_x_obs_linop.dtype))) + + mean_x = self.mean_fn(x) # pylint:disable=not-callable + batch_shape = self._batch_shape_tensor(index_points=x) + event_shape = self._event_shape_tensor(index_points=x) + mean_x = ps.broadcast_to(mean_x, + ps.concat([batch_shape, event_shape], axis=0)) + mean_x = _vec(mean_x) + return mean_x + k_x_obs_linop.matvec(self._solve_on_obs) + + @property + def kernel(self): + return self._kernel + + @property + def observation_index_points(self): + return self._observation_index_points + + @property + def observation_cholesky(self): + return self._observation_cholesky + + @property + def observations(self): + return self._observations + + @property + def index_points(self): + return self._index_points + + @property + def observation_noise_variance(self): + return self._observation_noise_variance + + @property + def predictive_noise_variance(self): + return self._predictive_noise_variance + + @property + def cholesky_fn(self): + return self._cholesky_fn + + def _event_shape(self): + # The examples index is one position to the left of the feature dims. + index_points = self.index_points + + if index_points is None: + return tf.TensorShape([None, self.kernel.num_tasks]) + examples_index = -(self.kernel.feature_ndims + 1) + shape = tensorshape_util.concatenate( + index_points.shape[examples_index:examples_index + 1], + (self.kernel.num_tasks,)) + if tensorshape_util.rank(shape) is None: + return tensorshape_util.concatenate( + [index_points.shape[examples_index:examples_index + 1]], + [self.kernel.num_tasks]) + return shape + + def _batch_shape_tensor(self, index_points=None): + index_points = self._get_index_points(index_points) + return functools.reduce(ps.broadcast_shape, [ + ps.shape( + self.observation_index_points)[:-(self.kernel.feature_ndims + 1)], + ps.shape(index_points)[:-(self.kernel.feature_ndims + 1)], + self.kernel.batch_shape_tensor(), + ps.shape(self.observations)[:-2], + ps.shape(self.observation_noise_variance) + ]) + + def _event_shape_tensor(self, index_points=None): + index_points = self._get_index_points(index_points) + return tf.concat( + [[tf.shape(index_points)[-(self.kernel.feature_ndims + 1)]], + [self.kernel.num_tasks]], + axis=0) + + def _compute_flattened_covariance(self, index_points=None): + # This is of shape KN x KN, where K is the number of outputs + # Compute this explicitly via the Schur Complement of the vector kernel. + # The reason this is written explicitly as opposed to using a GPRM + # internally for reshaping is there is potential for efficiency gains when + # `observation_noise_variance = 0.`. + index_points = self._get_index_points(index_points) + kxx = self.kernel.matrix_over_all_tasks(index_points, index_points) + + kxz = self.kernel.matrix_over_all_tasks( + index_points, self.observation_index_points).to_dense() + if self._observations_is_missing is not None: + kxz = tf.where(_vec(tf.math.logical_not( + self._observations_is_missing))[..., tf.newaxis, :], + kxz, + tf.zeros([], dtype=kxz.dtype)) + cholinv_kzx = self.observation_cholesky.solve(kxz, adjoint_arg=True) + kxz_kzzinv_kzx = tf.linalg.matmul( + cholinv_kzx, cholinv_kzx, transpose_a=True) + + flattened_covariance = kxx.to_dense() - kxz_kzzinv_kzx + if self.predictive_noise_variance is None: + return flattened_covariance + broadcast_shape = distribution_util.get_broadcast_shape( + flattened_covariance, self.predictive_noise_variance[..., tf.newaxis, + tf.newaxis]) + flattened_covariance = tf.broadcast_to(flattened_covariance, + broadcast_shape) + return _add_diagonal_shift(flattened_covariance, + self.predictive_noise_variance) + + def _get_flattened_marginal_distribution(self, index_points=None): + # This returns a MVN of event size [N * E], where N is the number of tasks + # and E is the number of index points. + with self._name_and_control_scope('get_flattened_marginal_distribution'): + index_points = self._get_index_points(index_points) + covariance = self._compute_flattened_covariance(index_points) + loc = self._conditional_mean_fn(index_points) + scale = tf.linalg.LinearOperatorLowerTriangular( + self._cholesky_fn(covariance), + is_non_singular=True, + name='GaussianProcessScaleLinearOperator') + return mvn_linear_operator.MultivariateNormalLinearOperator( + loc=loc, + scale=scale, + validate_args=self._validate_args, + allow_nan_stats=self._allow_nan_stats, + name='marginal_distribution') + + def _log_prob(self, value, index_points=None): + return self._get_flattened_marginal_distribution( + index_points=index_points).log_prob(_vec(value)) + + def _mean(self, index_points=None): + # The mean is of shape B1 + [E, N], where E is the number of index points, + # and N is the number of tasks. + return _unvec( + self._get_flattened_marginal_distribution( + index_points=index_points).mean(), [-1, self.kernel.num_tasks]) + + def _sample_n(self, n, seed=None, index_points=None): + # Samples is of shape [n] + B1 + [E, N], where E is the number of index + # points, and N is the number of tasks. + samples = self._get_flattened_marginal_distribution( + index_points=index_points).sample( + n, seed=seed) + return _unvec(samples, [-1, self.kernel.num_tasks]) + + def _get_index_points(self, index_points=None): + """Return `index_points` if not None, else `self._index_points`. + + Args: + index_points: if given, this is what is returned; else, + `self._index_points` + + Returns: + index_points: the given arg, if not None, else the class member + `self._index_points`. + + Rases: + ValueError: if `index_points` and `self._index_points` are both `None`. + """ + if self._index_points is None and index_points is None: + raise ValueError( + 'This MultiTaskGaussianProcessRegressionModel instance was not ' + 'instantiated with a value for index_points. One must therefore be ' + 'provided when calling sample, log_prob, and other such methods. In ' + 'particular, one can\'t compute KL divergences to/from an instance ' + 'of `MultiTaskGaussianProcessRegressionModel` with unspecified ' + '`index_points` directly. Instead, use the ' + '`get_marginal_distribution` function, which takes `index_points` as ' + 'an argument and returns a `Normal` or ' + '`MultivariateNormalLinearOperator` instance, whose KL can be ' + 'computed.') + return tf.convert_to_tensor( + index_points if index_points is not None else self._index_points) diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py new file mode 100644 index 0000000000..75c77d1370 --- /dev/null +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py @@ -0,0 +1,401 @@ +# Copyright 2021 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Tests for MultiTaskGaussianProcessRegressionModel.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +# Dependency imports + +from absl.testing import parameterized +import numpy as np + +import tensorflow.compat.v2 as tf + +import tensorflow_probability as tfp +from tensorflow_probability.python import experimental as tfe +from tensorflow_probability.python.internal import test_util + +tfd = tfp.distributions +tfk = tfp.math.psd_kernels + + +@test_util.test_all_tf_execution_regimes +class MultiTaskGaussianProcessRegressionModelTest( + test_util.TestCase): + # TODO(b/202181168): Add shape inference tests with None shapes. + + def testMeanShapeBroadcasts(self): + observation_index_points = tf.Variable( + np.random.random((10, 5)), dtype=np.float32) + observations = tf.Variable(np.random.random((10, 3)), dtype=np.float32) + index_points = tf.Variable(np.random.random((4, 5)), dtype=np.float32) + kernel = tfk.ExponentiatedQuadratic() + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=3, base_kernel=kernel) + mean = tf.Variable(np.random.random((3,)), dtype=np.float32) + gp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + multi_task_kernel, + observation_index_points=observation_index_points, + observations=observations, + index_points=index_points, + mean_fn=lambda _: mean, + observation_noise_variance=np.float32(1e-2)) + self.assertAllEqual(self.evaluate(gp.event_shape_tensor()), [4, 3]) + + @parameterized.parameters(1, 3, 5) + def testShapes(self, num_tasks): + # 3x3 grid of index points in R^2 and flatten to 9x2 + index_points = np.linspace(-4., 4., 3, dtype=np.float64) + index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) + index_points = np.reshape(index_points, [-1, 2]) + + batched_index_points = np.stack([index_points]*6) + # ==> shape = [6, 9, 2] + + # ==> shape = [9, 2] + observations = np.linspace(-20., 20., num_tasks * 9).reshape(9, num_tasks) + + test_index_points = np.random.uniform(-6., 6., [5, 2]) + # ==> shape = [3, 1, 5, 2] + + # Kernel with batch_shape [2, 4, 3, 1, 1] + amplitude = np.array([1., 2.], np.float64).reshape([2, 1, 1, 1]) + length_scale = np.array([1., 2., 3., 4.], np.float64).reshape([1, 4, 1, 1]) + observation_noise_variance = np.array( + [1e-5, 1e-6, 1e-5], np.float64).reshape([1, 1, 3, 1]) + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + gp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + multi_task_kernel, + observation_index_points=batched_index_points, + observations=observations, + index_points=test_index_points, + observation_noise_variance=observation_noise_variance, + predictive_noise_variance=0., + validate_args=True) + + batch_shape = [2, 4, 3, 6] + event_shape = [5, num_tasks] + sample_shape = [5, 3] + + samples = gp.sample(sample_shape, seed=test_util.test_seed()) + + self.assertAllEqual(self.evaluate(gp.batch_shape_tensor()), batch_shape) + self.assertAllEqual(self.evaluate(gp.event_shape_tensor()), event_shape) + self.assertAllEqual( + self.evaluate(samples).shape, + sample_shape + batch_shape + event_shape) + self.assertAllEqual( + self.evaluate(gp.log_prob(samples)).shape, + sample_shape + batch_shape) + self.assertAllEqual( + self.evaluate(tf.shape(gp.mean())), batch_shape + event_shape) + + @parameterized.parameters(1, 3, 5) + def testBindingIndexPoints(self, num_tasks): + amplitude = np.float64(0.5) + length_scale = np.float64(2.) + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + + # 5x5 grid of index points in R^2 and flatten to 9x2 + index_points = np.linspace(-4., 4., 3, dtype=np.float64) + index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) + observation_index_points = np.reshape(index_points, [-1, 2]) + # ==> shape = [9, 2] + + observations = np.linspace(-20., 20., 9 * num_tasks).reshape(9, num_tasks) + + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + observation_noise_variance = np.float64(1e-2) + mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + kernel=multi_task_kernel, + observation_index_points=observation_index_points, + observations=observations, + observation_noise_variance=observation_noise_variance, + validate_args=True) + gp = tfd.GaussianProcessRegressionModel( + kernel=kernel, + observation_index_points=observation_index_points, + # Batch of num_task observations. + observations=tf.linalg.matrix_transpose(observations), + observation_noise_variance=observation_noise_variance, + validate_args=True) + + test_points = np.random.uniform(-1., 1., [10, 2]) + test_observations = np.random.uniform(-1., 1., [10, num_tasks]) + + multi_task_log_prob = mtgp.log_prob( + test_observations, index_points=test_points) + # Reduce over the first dimension which is tasks. + single_task_log_prob = tf.reduce_sum( + gp.log_prob( + tf.linalg.matrix_transpose(test_observations), + index_points=test_points), axis=0) + self.assertAllClose( + self.evaluate(single_task_log_prob), + self.evaluate(multi_task_log_prob), rtol=1e-5) + + multi_task_mean_ = self.evaluate(mtgp.mean(index_points=test_points)) + # Reshape so that task dimension is last. + single_task_mean_ = np.swapaxes( + self.evaluate(gp.mean(index_points=test_points)), + -1, -2) + self.assertAllClose( + single_task_mean_, multi_task_mean_, rtol=1e-5) + + @parameterized.parameters(1, 3, 5) + def testLogProbMatchesGPNoiseless(self, num_tasks): + # Check that the independent kernel parameterization matches using a + # single-task GP. + + # 5x5 grid of index points in R^2 and flatten to 9x2 + index_points = np.linspace(-4., 4., 3, dtype=np.float32) + index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) + index_points = np.reshape(index_points, [-1, 2]) + # ==> shape = [9, 2] + + amplitude = np.float32(0.5) + length_scale = np.float32(2.) + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + observation_noise_variance = None + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + + observations = np.linspace( + -20., 20., 9 * num_tasks).reshape(9, num_tasks).astype(np.float32) + + test_points = np.random.uniform(-1., 1., [10, 2]).astype(np.float32) + test_observations = np.random.uniform( + -20., 20., [10, num_tasks]).astype(np.float32) + + mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + multi_task_kernel, + observation_index_points=index_points, + index_points=test_points, + observations=observations, + observation_noise_variance=observation_noise_variance, + validate_args=True) + + # For the single task GP, we move the task dimension to the front of the + # batch shape. + gp = tfd.GaussianProcessRegressionModel( + kernel, + observation_index_points=index_points, + index_points=test_points, + observations=tf.linalg.matrix_transpose(observations), + observation_noise_variance=0., + validate_args=True) + multitask_log_prob = mtgp.log_prob(test_observations) + single_task_log_prob = tf.reduce_sum( + gp.log_prob( + tf.linalg.matrix_transpose(test_observations)), axis=0) + self.assertAllClose( + self.evaluate(single_task_log_prob), + self.evaluate(multitask_log_prob), rtol=4e-3) + + multi_task_mean_ = self.evaluate(mtgp.mean()) + # Reshape so that task dimension is last. + single_task_mean_ = np.swapaxes( + self.evaluate(gp.mean()), -1, -2) + self.assertAllClose( + single_task_mean_, multi_task_mean_, rtol=1e-5) + + @parameterized.parameters(1, 3, 5) + def testLogProbMatchesGP(self, num_tasks): + # Check that the independent kernel parameterization matches using a + # single-task GP. + + # 5x5 grid of index points in R^2 and flatten to 9x2 + index_points = np.linspace(-4., 4., 3, dtype=np.float32) + index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) + index_points = np.reshape(index_points, [-1, 2]) + # ==> shape = [9, 2] + + amplitude = np.float32(0.5) + length_scale = np.float32(2.) + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + observation_noise_variance = np.float32(1e-2) + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + + observations = np.linspace( + -20., 20., 9 * num_tasks).reshape(9, num_tasks).astype(np.float32) + + test_points = np.random.uniform(-1., 1., [10, 2]).astype(np.float32) + test_observations = np.random.uniform( + -20., 20., [10, num_tasks]).astype(np.float32) + + mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + multi_task_kernel, + observation_index_points=index_points, + index_points=test_points, + observations=observations, + observation_noise_variance=observation_noise_variance, + validate_args=True) + + # For the single task GP, we move the task dimension to the front of the + # batch shape. + gp = tfd.GaussianProcessRegressionModel( + kernel, + observation_index_points=index_points, + index_points=test_points, + observations=tf.linalg.matrix_transpose(observations), + observation_noise_variance=observation_noise_variance, + validate_args=True) + # Print batch of covariance matrices. + multitask_log_prob = mtgp.log_prob(test_observations) + single_task_log_prob = tf.reduce_sum( + gp.log_prob( + tf.linalg.matrix_transpose(test_observations)), axis=0) + self.assertAllClose( + self.evaluate(single_task_log_prob), + self.evaluate(multitask_log_prob), rtol=4e-3) + + multi_task_mean_ = self.evaluate(mtgp.mean()) + # Reshape so that task dimension is last. + single_task_mean_ = np.swapaxes( + self.evaluate(gp.mean()), + -1, -2) + self.assertAllClose( + single_task_mean_, multi_task_mean_, rtol=1e-5) + + @parameterized.parameters(1, 3, 5) + def testNonTrivialMeanMatchesGP(self, num_tasks): + # Check that the independent kernel parameterization matches using a + # single-task GP. + + # 5x5 grid of index points in R^2 and flatten to 9x2 + index_points = np.linspace(-4., 4., 3, dtype=np.float32) + index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) + index_points = np.reshape(index_points, [-1, 2]) + # ==> shape = [9, 2] + + amplitude = np.float32(0.5) + length_scale = np.float32(2.) + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + observation_noise_variance = np.float32(1e-2) + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + + observations = np.linspace( + -20., 20., 9 * num_tasks).reshape(9, num_tasks).astype(np.float32) + + test_points = np.random.uniform(-1., 1., [10, 2]).astype(np.float32) + test_observations = np.random.uniform( + -20., 20., [10, num_tasks]).astype(np.float32) + + # Constant mean per task. + mean_fn = lambda x: tf.linspace(1., 3., num_tasks) + + mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + multi_task_kernel, + observation_index_points=index_points, + index_points=test_points, + observations=observations, + observation_noise_variance=observation_noise_variance, + mean_fn=mean_fn, + validate_args=True) + + # For the single task GP, we move the task dimension to the front of the + # batch shape. + gp = tfd.GaussianProcessRegressionModel( + kernel, + observation_index_points=index_points, + index_points=test_points, + observations=tf.linalg.matrix_transpose(observations), + observation_noise_variance=observation_noise_variance, + mean_fn=lambda x: tf.linspace(1., 3., num_tasks)[..., tf.newaxis], + validate_args=True) + # Print batch of covariance matrices. + multitask_log_prob = mtgp.log_prob(test_observations) + single_task_log_prob = tf.reduce_sum( + gp.log_prob( + tf.linalg.matrix_transpose(test_observations)), axis=0) + self.assertAllClose( + self.evaluate(single_task_log_prob), + self.evaluate(multitask_log_prob), rtol=4e-3) + + multi_task_mean_ = self.evaluate(mtgp.mean()) + # Reshape so that task dimension is last. + single_task_mean_ = np.swapaxes( + self.evaluate(gp.mean()), + -1, -2) + self.assertAllClose( + single_task_mean_, multi_task_mean_, rtol=1e-5) + + def testMasking(self): + seed_idx, seed_obs, seed_test, seed_sample = ( + tfp.random.split_seed(test_util.test_seed(), 4)) + index_points = tfd.Uniform(-1., 1.).sample((4, 3, 2, 2), seed=seed_idx) + observations = tfd.Uniform(-1., 1.).sample((4, 3, 2), seed=seed_obs) + test_points = tfd.Uniform(-1., 1.).sample((4, 5, 2, 2), seed=seed_test) + + observations_is_missing = np.array([ + [[True, True], [False, True], [True, False]], + [[False, True], [False, True], [False, True]], + [[False, False], [True, True], [True, False]], + [[True, False], [False, True], [False, False]] + ]) + observations = tf.where(~observations_is_missing, observations, np.nan) + + amplitude = tf.convert_to_tensor([0.5, 1.0, 1.75, 3.5]) + length_scale = tf.convert_to_tensor([0.3, 0.6, 0.9, 1.2]) + kernel = tfe.psd_kernels.Independent( + 2, + tfp.math.psd_kernels.ExponentiatedQuadratic( + amplitude, length_scale, feature_ndims=2), + validate_args=True) + + def mean_fn(x): + return (tf.math.reduce_sum(x, axis=[-1, -2])[..., tf.newaxis] + * tf.convert_to_tensor([-0.5, 2.0])) + + mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + kernel, + observation_index_points=index_points, + observations=observations, + observations_is_missing=observations_is_missing, + index_points=test_points, + predictive_noise_variance=0.05, + mean_fn=mean_fn, + validate_args=True) + + # Compare to a GPRM where the task dimension has been moved to be the + # rightmost batch dimension. + gp = tfp.distributions.GaussianProcessRegressionModel.precompute_regression_model( + kernel.base_kernel[..., tf.newaxis], + observation_index_points=index_points[:, tf.newaxis], + observations=tf.linalg.matrix_transpose(observations), + observations_mask=~tf.linalg.matrix_transpose(observations_is_missing), + index_points=test_points[:, tf.newaxis], + predictive_noise_variance=0.05, + mean_fn=lambda x: tf.linalg.matrix_transpose(mean_fn(x[:, 0])), + validate_args=True) + + x = mtgp.sample(2, seed=seed_sample) + self.assertAllNotNan(mtgp.log_prob(x)) + self.assertAllClose( + tf.math.reduce_sum(gp.log_prob(tf.linalg.matrix_transpose(x)), axis=-1), + mtgp.log_prob(x)) + + self.assertAllNotNan(mtgp.mean()) + self.assertAllClose(tf.linalg.matrix_transpose(gp.mean()), mtgp.mean()) + +if __name__ == '__main__': + test_util.main() From d8c2ab1c695be259ca3dc13752f25cbd53bff9d0 Mon Sep 17 00:00:00 2001 From: fmuham Date: Fri, 25 Feb 2022 12:12:05 -0800 Subject: [PATCH 016/153] tf_probability: Introduce replacement most_specific_common_supertype based on most_specific_compatible_type PiperOrigin-RevId: 431001320 --- .../python/internal/auto_composite_tensor.py | 16 ++++++++++++++++ .../python/util/deferred_tensor.py | 16 ++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/tensorflow_probability/python/internal/auto_composite_tensor.py b/tensorflow_probability/python/internal/auto_composite_tensor.py index ff9480f982..0f49e70159 100644 --- a/tensorflow_probability/python/internal/auto_composite_tensor.py +++ b/tensorflow_probability/python/internal/auto_composite_tensor.py @@ -295,9 +295,25 @@ def _deserialize(cls, encoded): f' but got {version}.') return cls(*encoded[1:]) + def most_specific_common_supertype(self, others): + """Returns the most specific supertype of `self` and `others`. + + Args: + others: A Sequence of `TypeSpec`. + + Returns `None` if a supertype does not exist. + """ + try: + return functools.reduce(lambda a, b: a.most_specific_compatible_type(b), + others, self) + except (TypeError, ValueError): + return None + def most_specific_compatible_type(self, other): """Returns the most specific TypeSpec compatible with `self` and `other`. + Deprecated. + Args: other: A `TypeSpec`. diff --git a/tensorflow_probability/python/util/deferred_tensor.py b/tensorflow_probability/python/util/deferred_tensor.py index 6f1384db77..13218bceb2 100644 --- a/tensorflow_probability/python/util/deferred_tensor.py +++ b/tensorflow_probability/python/util/deferred_tensor.py @@ -590,9 +590,25 @@ def dtype(self): def transform_or_spec(self): return self._transform_or_spec + def most_specific_common_supertype(self, others): + """Returns the most specific supertype of `self` and `others`. + + Args: + others: A Sequence of `TypeSpec`. + + Returns `None` if a supertype does not exist. + """ + try: + return functools.reduce(lambda a, b: a.most_specific_compatible_type(b), + others, self) + except (TypeError, ValueError): + return None + def most_specific_compatible_type(self, other): """Returns the most specific TypeSpec compatible with `self` and `other`. + Deprecated. + Args: other: A `TypeSpec`. From 37cdd4e28341603875e34f019506e2461eff4374 Mon Sep 17 00:00:00 2001 From: phawkins Date: Mon, 28 Feb 2022 11:25:55 -0800 Subject: [PATCH 017/153] [XLA:CPU] Relax test tolerances for tests using XLA:CPU. An upcoming change to XLA:CPU will disable reassociation on floating point operators by default which is an unsound fast math optimization. This change is being made to fix numerical errors in softmax computations caused by reassocation. After that change, we will enable reassociation only in reduction operators where it is very important for performance and the XLA operator contract allows that. Since this change alters the order of operations, it may cause small numerical changes leading to test failures. This change relaxes test tolerances to make tests pass. PiperOrigin-RevId: 431483624 --- .../experimental/sequential/extended_kalman_filter_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/experimental/sequential/extended_kalman_filter_test.py b/tensorflow_probability/python/experimental/sequential/extended_kalman_filter_test.py index 2ad652febe..2544694e6c 100644 --- a/tensorflow_probability/python/experimental/sequential/extended_kalman_filter_test.py +++ b/tensorflow_probability/python/experimental/sequential/extended_kalman_filter_test.py @@ -104,7 +104,7 @@ def observation_fn(x): if tf.executing_eagerly(): for result, nested_result in zip(results, nested_results): - self.assertAllEqualNested( + self.assertAllCloseNested( tf.nest.map_structure(lambda _: result, observations_struct), # pylint: disable=cell-var-from-loop nested_result) From dc24b078363b88fb1706b65c8f4b528983d0b179 Mon Sep 17 00:00:00 2001 From: axch Date: Tue, 1 Mar 2022 16:42:25 -0800 Subject: [PATCH 018/153] Be stricter about passing Tensors to tf.broadcast_to in unit tests. Why? The documentation of tf.broadcast_to does not explicitly stipulate that the input may be a nested list; and as of https://github.com/google/jax/pull/9724, it seems JAX does not like nested lists as arguments to jnp.broadcast_to. PiperOrigin-RevId: 431805774 --- .../python/distributions/batch_broadcast_test.py | 15 +++++++++------ .../distributions/hidden_markov_model_test.py | 9 +++++---- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/tensorflow_probability/python/distributions/batch_broadcast_test.py b/tensorflow_probability/python/distributions/batch_broadcast_test.py index d094a53564..da1e5cd611 100644 --- a/tensorflow_probability/python/distributions/batch_broadcast_test.py +++ b/tensorflow_probability/python/distributions/batch_broadcast_test.py @@ -126,7 +126,8 @@ def test_mean(self): d = tfd.BatchBroadcast(tfd.Independent(tfd.Normal([0., 1, 2], .5), reinterpreted_batch_ndims=1), [2]) - self.assertAllEqual(tf.broadcast_to([0., 1, 2], [2, 3]), d.mean()) + expected = tf.broadcast_to(tf.constant([0., 1, 2]), [2, 3]) + self.assertAllEqual(expected, d.mean()) def test_stddev(self): self.assertAllEqual(tf.fill([2, 3], .5), @@ -140,19 +141,21 @@ def test_entropy(self): def test_var(self): d = tfd.BatchBroadcast(tfd.Normal(0., [[.5], [1.]]), [2, 3]) - self.assertAllEqual(tf.broadcast_to([[.25], [1.]], [2, 3]), d.variance()) + expected = tf.broadcast_to(tf.constant([[.25], [1.]]), [2, 3]) + self.assertAllEqual(expected, d.variance()) def test_cov(self): d = tfd.BatchBroadcast(tfd.MultivariateNormalDiag(tf.zeros(2), [.5, 1.]), [5, 3]) - self.assertAllEqual(tf.broadcast_to([[.25, 0], [0, 1]], [5, 3, 2, 2]), - d.covariance()) + expected = tf.broadcast_to(tf.constant([[.25, 0], [0, 1]]), [5, 3, 2, 2]) + self.assertAllEqual(expected, d.covariance()) def test_quantile(self): d = tfd.BatchBroadcast(tfd.Normal(loc=[0., 1, 2], scale=.5), [2, 1]) - self.assertAllEqual(tf.broadcast_to([0., 1, 2], [2, 3]), d.quantile(.5)) + expected = tf.broadcast_to(tf.constant([0., 1, 2]), [2, 3]) + self.assertAllEqual(expected, d.quantile(.5)) x = d.quantile([[.45], [.55]]) - self.assertAllEqual(tf.broadcast_to([0., 1, 2], [2, 3]), tf.round(x)) + self.assertAllEqual(expected, tf.round(x)) self.assertAllTrue(x[0] < x[1]) def test_bug170030378(self): diff --git a/tensorflow_probability/python/distributions/hidden_markov_model_test.py b/tensorflow_probability/python/distributions/hidden_markov_model_test.py index 7f94ab624f..52647f2bf9 100644 --- a/tensorflow_probability/python/distributions/hidden_markov_model_test.py +++ b/tensorflow_probability/python/distributions/hidden_markov_model_test.py @@ -358,11 +358,12 @@ def test_coin_toss_batch(self): num_steps=num_steps, validate_args=True) - examples = [tf.zeros(5, dtype=tf.int32), tf.ones(5, dtype=tf.int32)] + examples = tf.stack( + [tf.zeros(5, dtype=tf.int32), tf.ones(5, dtype=tf.int32)], axis=0) examples = tf.broadcast_to(examples, [7, 3, 2, 5]) computed_log_prob = model.log_prob(examples) - expected_log_prob = tf.broadcast_to([np.log(.5**5)], [7, 3, 2]) + expected_log_prob = tf.broadcast_to(tf.constant([np.log(.5**5)]), [7, 3, 2]) self.assertAllClose(computed_log_prob, expected_log_prob, rtol=1e-4, atol=0.0) @@ -483,7 +484,7 @@ def test_single_sequence_posterior_marginals(self): num_steps=num_steps, validate_args=True) - observations = [0, 1, 1, 1, 1, 1, 2] + observations = tf.constant([0, 1, 1, 1, 1, 1, 2]) probs = self.evaluate( model.posterior_marginals(observations).probs_parameter()) @@ -973,7 +974,7 @@ def test_posterior_marginals_edge_case_no_transitions(self): inferred_marginals = self.evaluate( model.posterior_marginals( - observations=[[[0]], [[1]]], + observations=tf.constant([[[0]], [[1]]]), mask=[[[[True]]], [[[False]]]]).probs_parameter()) # Result is a [2,2,2] batch of sequences of length 1 of From 4826f4310bfa5f9d2155e92ce7d474f13aebc3bf Mon Sep 17 00:00:00 2001 From: axch Date: Wed, 2 Mar 2022 04:49:08 -0800 Subject: [PATCH 019/153] Update generated tensor_shape.py to track upstream. PiperOrigin-RevId: 431909617 --- .../python/internal/backend/numpy/gen/tensor_shape.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py b/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py index 80cc87c972..d02b0a92a6 100755 --- a/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py @@ -1412,7 +1412,7 @@ def __eq__(self, other): >>> p_a.__eq__(p_b) True >>> t_a.__eq__(p_a) - True + False >>> p_a.__eq__(p_c) False From c83ecac2ea42d8b17e033e4bda44a255f78daf86 Mon Sep 17 00:00:00 2001 From: siege Date: Fri, 4 Mar 2022 10:51:15 -0800 Subject: [PATCH 020/153] Fix a rare race condition when tracing tf.Variables in tfp.math.minimize inside TF1 graph mode. PiperOrigin-RevId: 432484975 --- tensorflow_probability/python/math/minimize.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/tensorflow_probability/python/math/minimize.py b/tensorflow_probability/python/math/minimize.py index 240199af80..b9f575230f 100644 --- a/tensorflow_probability/python/math/minimize.py +++ b/tensorflow_probability/python/math/minimize.py @@ -191,10 +191,14 @@ def run_optimization_loop(): loop_traced_values) return final_step_traceable_values.parameters, traced_values - final_parameters, traced_values = ps.cond( - num_steps > 1, - run_optimization_loop, - lambda: (initial_parameters, initial_traced_values)) + # When variables are involved, we want to make sure the initial trace is + # sequenced before the rest of the optimization loop. Otherwise, it's + # possible for the loop to *complete* before initial_trace_values are + # executed, causing nonsensical traces. + with tf.control_dependencies(tf.nest.flatten(initial_traced_values)): + final_parameters, traced_values = ps.cond( + num_steps > 1, run_optimization_loop, + lambda: (initial_parameters, initial_traced_values)) if not return_full_length_trace: traced_values = _truncate_at_has_converged(traced_values) @@ -619,5 +623,3 @@ def minimize(loss_fn, seed=seed, name=name) return traced_values - - From 9277fdf99fd0ecd5731d4897c2300da1edc05cfa Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Fri, 4 Mar 2022 23:12:21 -0300 Subject: [PATCH 021/153] Review changes --- .../python/distributions/skew_normal.py | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/tensorflow_probability/python/distributions/skew_normal.py b/tensorflow_probability/python/distributions/skew_normal.py index 1606d9742b..f926e85239 100644 --- a/tensorflow_probability/python/distributions/skew_normal.py +++ b/tensorflow_probability/python/distributions/skew_normal.py @@ -53,7 +53,7 @@ def standardize(value, loc, scale, skewness): A tensor with shape broadcast according to the arguments. """ return (value - loc) / tf.math.abs(scale) * tf.math.abs( - tf.where(value < loc, x=skewness, y=tf.math.reciprocal(skewness))) + tf.where(value < loc, skewness, tf.math.reciprocal(skewness))) def cdf(value, loc, scale, skewness): @@ -79,8 +79,8 @@ def cdf(value, loc, scale, skewness): squared_skewness = tf.math.square(skewness) return tf.math.reciprocal(one + squared_skewness) * tf.where( z < 0., - x=two * normal_cdf, - y=one - squared_skewness + two * squared_skewness * normal_cdf) + two * normal_cdf, + one - squared_skewness + two * squared_skewness * normal_cdf) def quantile(value, loc, scale, skewness): @@ -107,12 +107,12 @@ def quantile(value, loc, scale, skewness): # Here we use the following fact: # X ~ Normal(loc=0, scale=1) => 2 * X**2 ~ Gamma(alpha=0.5, beta=1) probs = (one - value * (one + squared_skewness)) * tf.where( - cond, x=one, y=-tf.math.reciprocal(squared_skewness)) + cond, one, -tf.math.reciprocal(squared_skewness)) gamma_quantile = tfp_math.igammainv(half, p=probs) abs_skewness = tf.math.abs(skewness) adj_scale = tf.math.abs(scale) * tf.where( - cond, x=-tf.math.reciprocal(abs_skewness), y=abs_skewness) + cond, -tf.math.reciprocal(abs_skewness), abs_skewness) return loc + adj_scale * tf.cast( tf.math.sqrt(two * gamma_quantile), dtype=loc.dtype) @@ -297,7 +297,6 @@ def __init__(self, @classmethod def _parameter_properties(cls, dtype, num_classes=None): - # pylint: disable=g-long-lambda return dict( loc=parameter_properties.ParameterProperties(), scale=parameter_properties.ParameterProperties( @@ -306,7 +305,6 @@ def _parameter_properties(cls, dtype, num_classes=None): skewness=parameter_properties.ParameterProperties( default_constraining_bijector_fn=( lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) - # pylint: enable=g-long-lambda @property def loc(self): @@ -346,8 +344,8 @@ def _sample_n(self, n, seed=None): sample = tf.abs(normal_sample) * tf.where( uniform_sample < tf.math.reciprocal(1. + skewness**2), - x=-tf.math.reciprocal(skewness), - y=skewness) + -tf.math.reciprocal(skewness), + skewness) return loc + scale * sample From 2aaad64be8476b898a963944e496e1ee3060cf19 Mon Sep 17 00:00:00 2001 From: fmuham Date: Mon, 7 Mar 2022 12:33:53 -0800 Subject: [PATCH 022/153] Implement logic to make tf_probability TypeSpecs hierarchical PiperOrigin-RevId: 433011791 --- .../python/internal/auto_composite_tensor.py | 82 ++++++++++++++- .../internal/auto_composite_tensor_test.py | 33 ++++--- .../python/util/deferred_tensor.py | 99 ++++++++++++++++++- .../python/util/deferred_tensor_test.py | 17 ++-- 4 files changed, 201 insertions(+), 30 deletions(-) diff --git a/tensorflow_probability/python/internal/auto_composite_tensor.py b/tensorflow_probability/python/internal/auto_composite_tensor.py index 0f49e70159..d81751681e 100644 --- a/tensorflow_probability/python/internal/auto_composite_tensor.py +++ b/tensorflow_probability/python/internal/auto_composite_tensor.py @@ -295,6 +295,36 @@ def _deserialize(cls, encoded): f' but got {version}.') return cls(*encoded[1:]) + def is_subtype_of(self, other): + """Returns True if `self` is subtype of `other`. + + Args: + other: A `TypeSpec`. + """ + # pylint: disable=protected-access + if type(self) is not type( + other) or self._callable_params != other._callable_params: + return False + + try: + tf.nest.assert_same_structure(self._comparable[:-1], + other._comparable[:-1]) + except (TypeError, ValueError): + return False + + self_elements = tf.nest.flatten(self._comparable[:-1]) + other_elements = tf.nest.flatten(other._comparable[:-1]) + + def is_subtype_or_equal(a, b): + try: + return a.is_subtype_of(b) + except AttributeError: + return a == b + + return all( + is_subtype_or_equal(self_element, other_element) + for (self_element, other_element) in zip(self_elements, other_elements)) + def most_specific_common_supertype(self, others): """Returns the most specific supertype of `self` and `others`. @@ -303,16 +333,47 @@ def most_specific_common_supertype(self, others): Returns `None` if a supertype does not exist. """ + # pylint: disable=protected-access + if not all( + type(self) is type(other) and + self._callable_params == other._callable_params for other in others): + return None + try: - return functools.reduce(lambda a, b: a.most_specific_compatible_type(b), - others, self) + for other in others: + tf.nest.assert_same_structure(self._comparable[:-1], + other._comparable[:-1]) except (TypeError, ValueError): return None + self_elements = tf.nest.flatten(self._comparable[:-1]) + others_elements = [ + tf.nest.flatten(other._comparable[:-1]) for other in others + ] + + def common_supertype_or_equal(a, bs): + try: + return a.most_specific_common_supertype(bs) + except AttributeError: + return a if all(a == b for b in bs) else None + + common_elements = [None] * len(self_elements) + for i, self_element in enumerate(self_elements): + common_elements[i] = common_supertype_or_equal( + self_element, + [other_elements[i] for other_elements in others_elements]) + if self_element is not None and common_elements[i] is None: + return None + common_comparable = tf.nest.pack_sequence_as(self._comparable[:-1], + common_elements) + + return type(self)(*common_comparable[1:], self._callable_params) + + # TODO(b/221472813): Delete this once default is deprecated. def most_specific_compatible_type(self, other): """Returns the most specific TypeSpec compatible with `self` and `other`. - Deprecated. + Deprecated. Use most_specific_common_supertype instead. Args: other: A `TypeSpec`. @@ -374,6 +435,21 @@ def relax(value): return self._copy( param_specs=tf.nest.map_structure(relax, self._param_specs)) + def _without_tensor_names(self): + """Returns a TypeSpec compatible with `self`, with tensor names removed. + + Returns: + A `TypeSpec` that is compatible with `self`, where the name of any + `TensorSpec` is set to `None`. + """ + def rename(value): + if isinstance(value, tf.TypeSpec): + return value._without_tensor_names() # pylint: disable=protected-access + else: + return value + return self._copy( + param_specs=tf.nest.map_structure(rename, self._param_specs)) + def __get_cmp_key(self): return (type(self), self._TypeSpec__make_cmp_key(self._comparable)) diff --git a/tensorflow_probability/python/internal/auto_composite_tensor_test.py b/tensorflow_probability/python/internal/auto_composite_tensor_test.py index 329fc2695e..087a212389 100644 --- a/tensorflow_probability/python/internal/auto_composite_tensor_test.py +++ b/tensorflow_probability/python/internal/auto_composite_tensor_test.py @@ -570,28 +570,29 @@ def testInequality(self, v1, v2): ('WithCallable', _TestTypeSpec( param_specs={'a': tf.TensorSpec([3, None], tf.float32), - 'b': tfb.Scale( - tf.Variable(2., shape=None))._type_spec}, + 'b': tfb.Scale(3.)._type_spec}, omit_kwargs=('name', 'foo'), callable_params={'f': tf.math.exp}), _TestTypeSpec( - param_specs={'a': tf.TensorSpec([3, None], tf.float32), - 'b': tfb.Scale(3.)._type_spec}, + param_specs={'a': tf.TensorSpec([None, None], tf.float32), + 'b': tfb.Scale(2.)._type_spec}, omit_kwargs=('name', 'foo'), callable_params={'f': tf.math.exp})), ('DifferentNonIdentifyingKwargsValues', - _TestTypeSpec( - param_specs={'x': tf.TensorSpec(None, tf.float64)}, - non_tensor_params={'name': 'MyAutoCT'}, - non_identifying_kwargs=('name')), _TestTypeSpec( param_specs={'x': tf.TensorSpec([], tf.float64)}, non_tensor_params={'name': 'OtherAutoCT'}, + non_identifying_kwargs=('name')), + _TestTypeSpec( + param_specs={'x': tf.TensorSpec(None, tf.float64)}, + non_tensor_params={'name': 'MyAutoCT'}, non_identifying_kwargs=('name'))), ) def testIsCompatibleWith(self, v1, v2): self.assertTrue(v1.is_compatible_with(v2)) self.assertTrue(v2.is_compatible_with(v1)) + self.assertTrue(v1.is_subtype_of(v2)) + self.assertFalse(v2.is_subtype_of(v1)) @parameterized.named_parameters( ('IncompatibleTensorSpecs', @@ -632,6 +633,8 @@ def testIsCompatibleWith(self, v1, v2): def testIsNotCompatibleWith(self, v1, v2): self.assertFalse(v1.is_compatible_with(v2)) self.assertFalse(v2.is_compatible_with(v1)) + self.assertFalse(v1.is_subtype_of(v2)) + self.assertFalse(v2.is_subtype_of(v1)) @parameterized.named_parameters( ('WithoutCallable', @@ -660,9 +663,9 @@ def testIsNotCompatibleWith(self, v1, v2): tf.Variable(2., shape=None))._type_spec}, callable_params={'f': tf.math.exp})), ) - def testMostSpecificCompatibleType(self, v1, v2, expected): - self.assertEqual(v1.most_specific_compatible_type(v2), expected) - self.assertEqual(v2.most_specific_compatible_type(v1), expected) + def testMostSpecificCommonSupertype(self, v1, v2, expected): + self.assertEqual(v1.most_specific_common_supertype([v2]), expected) + self.assertEqual(v2.most_specific_common_supertype([v1]), expected) @parameterized.named_parameters( ('DifferentParamSpecs', @@ -690,11 +693,9 @@ def testMostSpecificCompatibleType(self, v1, v2, expected): 'b': tfb.Scale(tf.Variable(3.))._type_spec}, callable_params={'f': tf.math.softplus})), ) - def testMostSpecificCompatibleTypeException(self, v1, v2): - with self.assertRaises(ValueError): - v1.most_specific_compatible_type(v2) - with self.assertRaises(ValueError): - v2.most_specific_compatible_type(v1) + def testMostSpecificCommonSupertypeNone(self, v1, v2): + self.assertIsNone(v1.most_specific_common_supertype([v2])) + self.assertIsNone(v2.most_specific_common_supertype([v1])) @parameterized.named_parameters( ('WithoutCallable', diff --git a/tensorflow_probability/python/util/deferred_tensor.py b/tensorflow_probability/python/util/deferred_tensor.py index 13218bceb2..d7dc931b82 100644 --- a/tensorflow_probability/python/util/deferred_tensor.py +++ b/tensorflow_probability/python/util/deferred_tensor.py @@ -590,6 +590,39 @@ def dtype(self): def transform_or_spec(self): return self._transform_or_spec + def is_subtype_of(self, other): + """Returns True if `self` is subtype of `other`. + + Args: + other: A `TypeSpec`. + """ + if type(self) is not type(other): + return False + + if (not self._transform_is_composite and + self.transform_or_spec != other.transform_or_spec): + return False + + # pylint: disable=protected-access + try: + tf.nest.assert_same_structure((self._specs, self._unique_id_params), + (other._specs, other._unique_id_params)) + except (TypeError, ValueError): + return False + + self_elements = tf.nest.flatten((self._specs, self._unique_id_params)) + other_elements = tf.nest.flatten((other._specs, other._unique_id_params)) + + def is_subtype_or_equal(a, b): + try: + return a.is_subtype_of(b) + except AttributeError: + return a == b + + return all( + is_subtype_or_equal(self_element, other_element) + for (self_element, other_element) in zip(self_elements, other_elements)) + def most_specific_common_supertype(self, others): """Returns the most specific supertype of `self` and `others`. @@ -598,16 +631,52 @@ def most_specific_common_supertype(self, others): Returns `None` if a supertype does not exist. """ + # pylint: disable=protected-access + if not all(type(self) is type(other) for other in others): + return None + try: - return functools.reduce(lambda a, b: a.most_specific_compatible_type(b), - others, self) + for other in others: + tf.nest.assert_same_structure((self._specs, self._unique_id_params), + (other._specs, other._unique_id_params)) except (TypeError, ValueError): return None + self_elements = tf.nest.flatten((self._specs, self._unique_id_params)) + others_elements = [ + tf.nest.flatten((other._specs, other._unique_id_params)) + for other in others + ] + + def common_supertype_or_equal(a, bs): + try: + return a.most_specific_common_supertype(bs) + except AttributeError: + return a if all(a == b for b in bs) else None + + common_elements = [None] * len(self_elements) + for i, self_element in enumerate(self_elements): + common_elements[i] = common_supertype_or_equal( + self_element, + [other_elements[i] for other_elements in others_elements]) + if self_element is not None and common_elements[i] is None: + return None + specs, params = tf.nest.pack_sequence_as( + (self._specs, self._unique_id_params), common_elements) + + kwargs = dict(specs, **params) + if not self._transform_is_composite: + if not all(self.transform_or_spec == other.transform_or_spec + for other in others): + return None + kwargs['transform_or_spec'] = self.transform_or_spec + return type(self)(**kwargs, name=None) + + # TODO(b/221472813): Delete this once default is deprecated. def most_specific_compatible_type(self, other): """Returns the most specific TypeSpec compatible with `self` and `other`. - Deprecated. + Deprecated. Use most_specific_common_supertype instead. Args: other: A `TypeSpec`. @@ -677,6 +746,30 @@ def relax(value): **self._unique_id_params, name=self.name))) + def _without_tensor_names(self): + """Returns a TypeSpec compatible with `self`, with tensor names removed. + + Returns: + A `TypeSpec` that is compatible with `self`, where the name of any + `TensorSpec` is set to `None`. + """ + def rename(value): + if isinstance(value, tf.TypeSpec): + return value._without_tensor_names() # pylint: disable=protected-access + else: + return value + + specs = self._specs.copy() + transform_or_spec = specs.pop( + 'transform_or_spec', self.transform_or_spec) + return type(self)( + **tf.nest.map_structure( + rename, + dict(specs, + transform_or_spec=transform_or_spec, + **self._unique_id_params, + name=None))) + def _get_batched_input_spec(self, batch_size): """Returns the batched `input_spec` for the given `batch_size`.""" if isinstance(self._input_spec, type_spec.BatchableTypeSpec): diff --git a/tensorflow_probability/python/util/deferred_tensor_test.py b/tensorflow_probability/python/util/deferred_tensor_test.py index 2dc3d0984b..732bbd88c6 100644 --- a/tensorflow_probability/python/util/deferred_tensor_test.py +++ b/tensorflow_probability/python/util/deferred_tensor_test.py @@ -700,6 +700,7 @@ def testInequality(self, v1, v2): def testIsCompatibleWith(self, v1, v2): self.assertTrue(v1.is_compatible_with(v2)) self.assertTrue(v2.is_compatible_with(v1)) + self.assertTrue(v1.is_subtype_of(v2)) @parameterized.named_parameters( ('IncompatibleInputSpecs', @@ -748,6 +749,8 @@ def testIsCompatibleWith(self, v1, v2): def testIsNotCompatibleWith(self, v1, v2): self.assertFalse(v1.is_compatible_with(v2)) self.assertFalse(v2.is_compatible_with(v1)) + self.assertFalse(v1.is_subtype_of(v2)) + self.assertFalse(v2.is_subtype_of(v1)) @parameterized.named_parameters( ('DeferredTensor', @@ -785,9 +788,9 @@ def testIsNotCompatibleWith(self, v1, v2): input_spec=resource_variable_ops.VariableSpec(None, tf.float32), transform_or_spec=tf.math.sigmoid)) ) - def testMostSpecificCompatibleType(self, v1, v2, expected): - self.assertEqual(v1.most_specific_compatible_type(v2), expected) - self.assertEqual(v2.most_specific_compatible_type(v1), expected) + def testMostSpecificCommonSupertype(self, v1, v2, expected): + self.assertEqual(v1.most_specific_common_supertype([v2]), expected) + self.assertEqual(v2.most_specific_common_supertype([v1]), expected) @parameterized.named_parameters( ('IncompatibleInputSpecs', @@ -824,11 +827,9 @@ def testMostSpecificCompatibleType(self, v1, v2, expected): dtype=tf.float64, name='two')), ) - def testMostSpecificCompatibleTypeException(self, v1, v2): - with self.assertRaises(ValueError): - v1.most_specific_compatible_type(v2) - with self.assertRaises(ValueError): - v2.most_specific_compatible_type(v1) + def testMostSpecificCommonSupertypeNone(self, v1, v2): + self.assertIsNone(v1.most_specific_common_supertype([v2])) + self.assertIsNone(v2.most_specific_common_supertype([v1])) @parameterized.named_parameters( ('DeferredTensor', From ad6896b8a728d3d468320e531ff4c84d542efe25 Mon Sep 17 00:00:00 2001 From: slebedev Date: Mon, 7 Mar 2022 17:28:04 -0800 Subject: [PATCH 023/153] Removed references to g-no-augmented-assignment in pylint directives PiperOrigin-RevId: 433081526 --- tensorflow_probability/python/distributions/mixture_test.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/distributions/mixture_test.py b/tensorflow_probability/python/distributions/mixture_test.py index f2217788e6..420868dd00 100644 --- a/tensorflow_probability/python/distributions/mixture_test.py +++ b/tensorflow_probability/python/distributions/mixture_test.py @@ -323,7 +323,7 @@ def testStddevShapeUnivariate(self): # Broadcast cat probs over event dimensions. for _ in range(len(event_shape_res)): cat_probs_values = np.expand_dims(cat_probs_values, len(batch_shape)) - cat_probs_values = cat_probs_values + np.zeros_like(stacked_dev_res) # pylint: disable=g-no-augmented-assignment + cat_probs_values = cat_probs_values + np.zeros_like(stacked_dev_res) # Perform stddev computation on a flattened batch. flat_batch_manual_dev = _mixture_stddev_np( @@ -364,7 +364,7 @@ def testStddevShapeMultivariate(self): # Broadcast cat probs over event dimensions. for _ in range(len(event_shape_res)): cat_probs_values = np.expand_dims(cat_probs_values, len(batch_shape)) - cat_probs_values = cat_probs_values + np.zeros_like(stacked_dev_res) # pylint: disable=g-no-augmented-assignment + cat_probs_values = cat_probs_values + np.zeros_like(stacked_dev_res) # Perform stddev computation on a flattened batch. flat_batch_manual_dev = _mixture_stddev_np( From 96a83ea4cbe214d3b8e07c4eff6bb1fe5411309d Mon Sep 17 00:00:00 2001 From: axch Date: Tue, 8 Mar 2022 11:13:22 -0800 Subject: [PATCH 024/153] Increase numerical tolerances to pacify Hypothesis. PiperOrigin-RevId: 433260944 --- .../platform_compatibility_test.py | 21 +++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/tensorflow_probability/python/distributions/platform_compatibility_test.py b/tensorflow_probability/python/distributions/platform_compatibility_test.py index c2b391bd91..6c9d113193 100644 --- a/tensorflow_probability/python/distributions/platform_compatibility_test.py +++ b/tensorflow_probability/python/distributions/platform_compatibility_test.py @@ -123,7 +123,7 @@ VECTORIZED_LOGPROB_ATOL = collections.defaultdict(lambda: 1e-6) VECTORIZED_LOGPROB_ATOL.update({ 'Beta': 1e-5, - 'BetaBinomial': 1e-5, + 'BetaBinomial': 3e-5, 'BetaQuotient': 2e-5, 'CholeskyLKJ': 1e-4, 'GammaGamma': 2e-5, @@ -137,6 +137,7 @@ 'Beta': 1e-5, 'GammaGamma': 1e-4, 'JohnsonSU': 1e-5, + 'MultivariateNormalDiagPlusLowRankCovariance': 1e-5, 'NegativeBinomial': 1e-5, 'PERT': 1e-5, 'PowerSpherical': 5e-5, @@ -149,19 +150,27 @@ 'BetaBinomial': 5e-6, 'BetaQuotient': 1e-4, 'Binomial': 5e-6, - 'Categorical': 7e-6, # sparse_softmax_cross_entropy_with_logits + 'Categorical': 1e-5, # sparse_softmax_cross_entropy_with_logits + 'Chi': 1e-5, + 'CholeskyLKJ': 1e-5, + 'ContinuousBernoulli': 1e-5, 'DeterminantalPointProcess': 2e-5, + 'Dirichlet': 1e-5, # TODO(b/211121663) 'DirichletMultinomial': 5e-4, 'ExpGamma': 2e-3, # TODO(b/166257329) - 'ExpInverseGamma': 1.5e-3, # TODO(b/166257329) + 'ExpInverseGamma': 3e-3, # TODO(b/166257329) 'ExpRelaxedOneHotCategorical': 3e-5, 'FiniteDiscrete': 1e-5, # sparse_softmax_cross_entropy_with_logits + 'GammaGamma': 1e-5, 'HalfCauchy': 2e-6, + 'HalfStudentT': 1e-5, 'InverseGamma': 1e-4, + 'JohnsonSU': 1e-5, 'Kumaraswamy': 4e-5, 'Logistic': 3e-6, 'Multinomial': 2e-4, 'OneHotCategorical': 1e-5, + 'PERT': 1e-5, 'PowerSpherical': 2e-5, 'RelaxedBernoulli': 2e-5, 'SigmoidBeta': 5e-4, @@ -179,7 +188,8 @@ 'Chi': 2e-4, 'Chi2': 5e-5, 'CholeskyLKJ': 1e-4, - 'ContinuousBernoulli': 2e-6, + 'ContinuousBernoulli': 1e-5, + 'DeterminantalPointProcess': 5e-5, 'Dirichlet': 1e-2, # TODO(b/211121663) 'DirichletMultinomial': 5e-4, 'ExpRelaxedOneHotCategorical': 1e-3, # TODO(b/163118820) @@ -188,8 +198,10 @@ 'FiniteDiscrete': 6e-6, 'GammaGamma': 5e-4, 'Geometric': 5e-5, + 'HalfStudentT': 1e-5, 'InverseGamma': 5e-3, 'JohnsonSU': 1e-2, + 'LambertWNormal': 1e-5, 'LKJ': .07, 'Multinomial': 3e-4, 'MultivariateNormalDiag': 5e-6, @@ -203,6 +215,7 @@ 'RelaxedBernoulli': 3e-3, 'RelaxedOneHotCategorical': 2e-3, # TODO(b/163118820) 'SigmoidBeta': 5e-4, + 'StudentT': 1e-5, 'TruncatedCauchy': 5e-5, 'VonMises': 2e-2, # TODO(b/160000258): 'VonMisesFisher': 5e-3, From d38854a4fc5a8fc3316f43883420ffc4507cc0bf Mon Sep 17 00:00:00 2001 From: axch Date: Tue, 8 Mar 2022 12:04:05 -0800 Subject: [PATCH 025/153] Actually, no reason not to allow injecting a 0-D vector into a 1-D simplex (which is the number 1) with IteratedSigmidCentered. Modify `inverse_event_shape` to accept a 1-D output shape instead of raising an exception. PiperOrigin-RevId: 433274436 --- .../python/bijectors/iterated_sigmoid_centered.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tensorflow_probability/python/bijectors/iterated_sigmoid_centered.py b/tensorflow_probability/python/bijectors/iterated_sigmoid_centered.py index a545fcf5e6..f0d8ce86c6 100644 --- a/tensorflow_probability/python/bijectors/iterated_sigmoid_centered.py +++ b/tensorflow_probability/python/bijectors/iterated_sigmoid_centered.py @@ -93,15 +93,15 @@ def _forward_event_shape_tensor(self, input_shape): def _inverse_event_shape(self, output_shape): if not output_shape[-1:].is_fully_defined(): return output_shape - if output_shape[-1] <= 1: - raise ValueError('output_shape[-1] = %d <= 1' % output_shape[-1]) + if output_shape[-1] < 1: + raise ValueError('output_shape[-1] = %d < 1' % output_shape[-1]) return output_shape[:-1].concatenate(output_shape[-1] - 1) def _inverse_event_shape_tensor(self, output_shape): if self.validate_args: - # It is not possible for a negative shape so we need only check <= 1. + # It is not possible for a negative shape so we need only check < 1. dependencies = [assert_util.assert_greater( - output_shape[-1], 1, message='Need last dimension greater than 1.')] + output_shape[-1], 0, message='Need last dimension greater than 0.')] else: dependencies = [] with tf.control_dependencies(dependencies): From 315953988240589f9d8066800e0516f3dcf52baf Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Tue, 8 Mar 2022 22:20:03 -0300 Subject: [PATCH 026/153] Change distribution name --- .../python/distributions/BUILD | 68 ++++++++-------- .../python/distributions/__init__.py | 4 +- .../{skew_normal.py => two_piece_normal.py} | 67 +++++++++------- ...ormal_test.py => two_piece_normal_test.py} | 77 ++++++++++--------- 4 files changed, 115 insertions(+), 101 deletions(-) rename tensorflow_probability/python/distributions/{skew_normal.py => two_piece_normal.py} (86%) rename tensorflow_probability/python/distributions/{skew_normal_test.py => two_piece_normal_test.py} (89%) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index 7f59f59bc9..2eafad1003 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -139,7 +139,6 @@ multi_substrate_py_library( ":sigmoid_beta", ":sinh_arcsinh", ":skellam", - ":skew_normal", ":spherical_uniform", ":stopping_ratio_logistic", ":student_t", @@ -149,6 +148,7 @@ multi_substrate_py_library( ":triangular", ":truncated_cauchy", ":truncated_normal", + ":two_piece_normal", ":uniform", ":variational_gaussian_process", ":von_mises", @@ -1980,28 +1980,6 @@ multi_substrate_py_library( ], ) -multi_substrate_py_library( - name = "skew_normal", - srcs = ["skew_normal.py"], - deps = [ - ":distribution", - # numpy dep, - # tensorflow dep, - "//tensorflow_probability/python/bijectors:identity", - "//tensorflow_probability/python/bijectors:softplus", - "//tensorflow_probability/python/internal:assert_util", - "//tensorflow_probability/python/internal:dtype_util", - "//tensorflow_probability/python/internal:parameter_properties", - "//tensorflow_probability/python/internal:prefer_static", - "//tensorflow_probability/python/internal:reparameterization", - "//tensorflow_probability/python/internal:samplers", - "//tensorflow_probability/python/internal:special_math", - "//tensorflow_probability/python/internal:tensor_util", - "//tensorflow_probability/python/math", - "//tensorflow_probability/python/math:numeric", - ], -) - multi_substrate_py_library( name = "stopping_ratio_logistic", srcs = ["stopping_ratio_logistic.py"], @@ -2177,6 +2155,28 @@ multi_substrate_py_library( ], ) +multi_substrate_py_library( + name = "two_piece_normal", + srcs = ["two_piece_normal.py"], + deps = [ + ":distribution", + # numpy dep, + # tensorflow dep, + "//tensorflow_probability/python/bijectors:identity", + "//tensorflow_probability/python/bijectors:softplus", + "//tensorflow_probability/python/internal:assert_util", + "//tensorflow_probability/python/internal:dtype_util", + "//tensorflow_probability/python/internal:parameter_properties", + "//tensorflow_probability/python/internal:prefer_static", + "//tensorflow_probability/python/internal:reparameterization", + "//tensorflow_probability/python/internal:samplers", + "//tensorflow_probability/python/internal:special_math", + "//tensorflow_probability/python/internal:tensor_util", + "//tensorflow_probability/python/math", + "//tensorflow_probability/python/math:numeric", + ], +) + multi_substrate_py_library( name = "uniform", srcs = ["uniform.py"], @@ -3813,17 +3813,6 @@ multi_substrate_py_test( ], ) -multi_substrate_py_test( - name = "skew_normal_test", - srcs = ["skew_normal_test.py"], - deps = [ - # numpy dep, - # tensorflow dep, - "//tensorflow_probability", - "//tensorflow_probability/python/internal:test_util", - ], -) - multi_substrate_py_test( name = "stopping_ratio_logistic_test", srcs = ["stopping_ratio_logistic_test.py"], @@ -3956,6 +3945,17 @@ multi_substrate_py_test( ], ) +multi_substrate_py_test( + name = "two_piece_normal_test", + srcs = ["two_piece_normal_test.py"], + deps = [ + # numpy dep, + # tensorflow dep, + "//tensorflow_probability", + "//tensorflow_probability/python/internal:test_util", + ], +) + multi_substrate_py_test( name = "uniform_test", srcs = ["uniform_test.py"], diff --git a/tensorflow_probability/python/distributions/__init__.py b/tensorflow_probability/python/distributions/__init__.py index 67c7f85663..db64ace22a 100644 --- a/tensorflow_probability/python/distributions/__init__.py +++ b/tensorflow_probability/python/distributions/__init__.py @@ -117,7 +117,6 @@ from tensorflow_probability.python.distributions.sigmoid_beta import SigmoidBeta from tensorflow_probability.python.distributions.sinh_arcsinh import SinhArcsinh from tensorflow_probability.python.distributions.skellam import Skellam -from tensorflow_probability.python.distributions.skew_normal import SkewNormal from tensorflow_probability.python.distributions.spherical_uniform import SphericalUniform from tensorflow_probability.python.distributions.stopping_ratio_logistic import StoppingRatioLogistic from tensorflow_probability.python.distributions.student_t import StudentT @@ -127,6 +126,7 @@ from tensorflow_probability.python.distributions.triangular import Triangular from tensorflow_probability.python.distributions.truncated_cauchy import TruncatedCauchy from tensorflow_probability.python.distributions.truncated_normal import TruncatedNormal +from tensorflow_probability.python.distributions.two_piece_normal import TwoPieceNormal from tensorflow_probability.python.distributions.uniform import Uniform from tensorflow_probability.python.distributions.variational_gaussian_process import VariationalGaussianProcess from tensorflow_probability.python.distributions.von_mises import VonMises @@ -271,7 +271,6 @@ 'SigmoidBeta', 'SinhArcsinh', 'Skellam', - 'SkewNormal', 'SphericalUniform', 'StoppingRatioLogistic', 'StudentT', @@ -281,6 +280,7 @@ 'Triangular', 'TruncatedCauchy', 'TruncatedNormal', + 'TwoPieceNormal', 'Uniform', 'VariationalGaussianProcess', 'VectorDeterministic', diff --git a/tensorflow_probability/python/distributions/skew_normal.py b/tensorflow_probability/python/distributions/two_piece_normal.py similarity index 86% rename from tensorflow_probability/python/distributions/skew_normal.py rename to tensorflow_probability/python/distributions/two_piece_normal.py index f926e85239..9b40bddf4a 100644 --- a/tensorflow_probability/python/distributions/skew_normal.py +++ b/tensorflow_probability/python/distributions/two_piece_normal.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -"""The Skew Normal distribution class.""" +"""The Two-Piece Normal distribution class.""" # Dependency imports import numpy as np @@ -34,7 +34,7 @@ from tensorflow_probability.python.math.numeric import log1psquare __all__ = [ - 'SkewNormal', + 'TwoPieceNormal', ] @@ -57,7 +57,7 @@ def standardize(value, loc, scale, skewness): def cdf(value, loc, scale, skewness): - """Compute cumulative distribution function of Skew Normal distribution. + """Compute cumulative distribution function of Two-Piece Normal distribution. Note that scale and skewness can be negative. @@ -84,7 +84,7 @@ def cdf(value, loc, scale, skewness): def quantile(value, loc, scale, skewness): - """Compute quantile function (inverse cdf) of Skew Normal distribution. + """Compute quantile function (inverse cdf) of Two-Piece Normal distribution. Note that scale and skewness can be negative. @@ -118,15 +118,23 @@ def quantile(value, loc, scale, skewness): tf.math.sqrt(two * gamma_quantile), dtype=loc.dtype) -class SkewNormal(distribution.AutoCompositeTensorDistribution): - """The Skew Normal distribution. +class TwoPieceNormal(distribution.AutoCompositeTensorDistribution): + """The Two-Piece Normal distribution. - The Skew Normal generalizes the Normal distribution with an additional shape - parameter. It is parameterized by location `loc`, scale `scale`, and shape - `skewness`. If the skewness is above one, the distribution becomes positively - skewed (or right-skewed). If the skewness is greater than zero and less than - one, the distribution becomes negatively skewed (or left-skewed). A skewness - equal to one results in a Normal distribution. + The Two-Piece Normal generalizes the Normal distribution with an additional + shape parameter. Under the general formulation proposed by [Fernández and + Steel (1998)][2], it is parameterized by location `loc`, scale `scale`, and + shape `skewness`. If `skewness` is above one, the distribution becomes right- + skewed (or positively skewed). If `skewness` is greater than zero and less + than one, the distribution becomes left-skewed (or negatively skewed). The + Normal distribution is retrieved when `skewness` is equal to one. + + This distribution is also called the Fernández-Steel Skew Normal distribution + [(Castillo et al., 2011)][1], the Skew Normal Type 2 distribution [(Rigby et + al., 2019, Section 18.3.5, p380)][3], and the [Split Normal distribution]( + https://en.wikipedia.org/wiki/Split_normal_distribution). The Fernández and + Steel's formulation is mathematically equivalent to the main parameterization + discussed in the last reference. #### Mathematical details @@ -165,13 +173,13 @@ class SkewNormal(distribution.AutoCompositeTensorDistribution): ```none quantile(p; loc, scale, skewness) = - loc + s0 * normal_quantile(q0) when p <= 1 / (1 + skewness**2), and - loc + s1 * normal_quantile(q1) when p > 1 / (1 + skewness**2) + loc + s0 * normal_quantile(x0) when p <= 1 / (1 + skewness**2), and + loc + s1 * normal_quantile(x1) when p > 1 / (1 + skewness**2) where s0 = scale / skewness s1 = scale * skewness - q0 = (p * (1 + skewness**2)) / 2 - q1 = (p * (1 + skewness**2) - 1 + skewness**2) / (2 * skewness**2) + x0 = (p * (1 + skewness**2)) / 2 + x1 = (p * (1 + skewness**2) - 1 + skewness**2) / (2 * skewness**2) y = (x - loc) / scale ``` @@ -188,9 +196,9 @@ class SkewNormal(distribution.AutoCompositeTensorDistribution): E(Y) = sqrt(2) / sqrt(pi) * (skewness - 1 / skewness) ``` - The Skew Normal distribution is a member of the [location-scale family]( - https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be - constructed as, + The Two-Piece Normal distribution is a member of the [location-scale family]( + https://en.wikipedia.org/wiki/Location-scale_family): it can be constructed + as, ```none Z ~ Normal(loc=0, scale=1) @@ -207,8 +215,8 @@ class SkewNormal(distribution.AutoCompositeTensorDistribution): import tensorflow_probability as tfp tfd = tfp.distributions - # Define a single scalar Skew Normal distribution. - dist = tfd.SkewNormal(loc=3., scale=10., skewness=0.75) + # Define a single scalar Two-Piece Normal distribution. + dist = tfd.TwoPieceNormal(loc=3., scale=10., skewness=0.75) # Evaluate the cdf at 1, returning a scalar. dist.cdf(1.) @@ -218,9 +226,9 @@ class SkewNormal(distribution.AutoCompositeTensorDistribution): broadcast when possible. ```python - # Define a batch of three scalar valued Skew Normals. + # Define a batch of three scalar valued Two-Piece Normals. # They have mean 3, scale 10, but different skewnesses. - dist = tfd.SkewNormal(loc=3., scale=10., skewness=[0.75, 1., 1.33]) + dist = tfd.TwoPieceNormal(loc=3., scale=10., skewness=[0.75, 1., 1.33]) # Get 2 samples, returning a 2 x 3 tensor. value = dist.sample(2) @@ -251,11 +259,11 @@ def __init__(self, skewness, validate_args=False, allow_nan_stats=True, - name='SkewNormal'): - """Construct Skew Normal distributions. + name='TwoPieceNormal'): + """Construct Two-Piece Normal distributions. - The Skew Normal is parametrized with location `loc`, scale `scale`, and - shape parameter `skewness`. The parameters must be shaped in a way that + The Two-Piece Normal is parametrized with location `loc`, scale `scale`, + and shape parameter `skewness`. The parameters must be shaped in a way that supports broadcasting (e.g. `loc + scale` is a valid operation). Args: @@ -287,7 +295,7 @@ def __init__(self, scale, dtype=dtype, name='scale') self._skewness = tensor_util.convert_nonref_to_tensor( skewness, dtype=dtype, name='skewness') - super(SkewNormal, self).__init__( + super(TwoPieceNormal, self).__init__( dtype=dtype, reparameterization_type=reparameterization.FULLY_REPARAMETERIZED, validate_args=validate_args, @@ -336,7 +344,8 @@ def _sample_n(self, n, seed=None): loc=loc, scale=scale, skewness=skewness) sample_shape = ps.concat([[n], batch_shape], axis=0) - uniform_seed, normal_seed = samplers.split_seed(seed, salt='skew_normal') + uniform_seed, normal_seed = samplers.split_seed( + seed, salt='two_piece_normal') uniform_sample = samplers.uniform( sample_shape, maxval=1., dtype=self.dtype, seed=uniform_seed) normal_sample = samplers.normal( diff --git a/tensorflow_probability/python/distributions/skew_normal_test.py b/tensorflow_probability/python/distributions/two_piece_normal_test.py similarity index 89% rename from tensorflow_probability/python/distributions/skew_normal_test.py rename to tensorflow_probability/python/distributions/two_piece_normal_test.py index 3de06d029e..07cd206fef 100644 --- a/tensorflow_probability/python/distributions/skew_normal_test.py +++ b/tensorflow_probability/python/distributions/two_piece_normal_test.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -"""Tests for Skew Normal distribution.""" +"""Tests for Two-Piece Normal distribution.""" # Dependency imports import numpy as np @@ -27,15 +27,15 @@ @test_util.test_all_tf_execution_regimes -class _SkewNormalTest(object): +class _TwoPieceNormalTest(object): - def make_skew_normal(self): + def make_two_piece_normal(self): if self.dtype is np.float32: # Raw Python literals should always be interpreted as float32. - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=3., scale=10., skewness=0.75, validate_args=True) elif self.dtype is np.float64: - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=tf.constant(3., dtype=self.dtype), scale=tf.constant(10., dtype=self.dtype), skewness=tf.constant(0.75, dtype=self.dtype), @@ -43,13 +43,13 @@ def make_skew_normal(self): return dist - def make_skew_normals(self): + def make_two_piece_normals(self): if self.dtype is np.float32: # Raw Python literals should always be interpreted as float32. - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=3., scale=10., skewness=[0.75, 1., 1.33], validate_args=True) elif self.dtype is np.float64: - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=tf.constant(3., dtype=self.dtype), scale=tf.constant(10., dtype=self.dtype), skewness=tf.constant([0.75, 1., 1.33], dtype=self.dtype), @@ -58,7 +58,7 @@ def make_skew_normals(self): return dist def helper_param_shapes(self, sample_shape, expected): - param_shapes = tfd.SkewNormal.param_shapes(sample_shape) + param_shapes = tfd.TwoPieceNormal.param_shapes(sample_shape) mu_shape = param_shapes['loc'] sigma_shape = param_shapes['scale'] skewness_shape = param_shapes['skewness'] @@ -71,13 +71,13 @@ def helper_param_shapes(self, sample_shape, expected): sigma = tf.ones(sigma_shape) skewness = tf.ones(skewness_shape) seed = test_util.test_seed() - samples = tfd.SkewNormal( + samples = tfd.TwoPieceNormal( mu, sigma, skewness, validate_args=True).sample(seed=seed) self.assertAllEqual(expected, self.evaluate(tf.shape(samples))) def helper_param_static_shapes(self, sample_shape, expected): - param_shapes = tfd.SkewNormal.param_static_shapes(sample_shape) + param_shapes = tfd.TwoPieceNormal.param_static_shapes(sample_shape) mu_shape = param_shapes['loc'] sigma_shape = param_shapes['scale'] skewness_shape = param_shapes['skewness'] @@ -98,7 +98,7 @@ def testParamStaticShapes(self): tf.TensorShape(sample_shape), sample_shape) def testSampleLikeArgsGetDistDType(self): - dist = self.make_skew_normal() + dist = self.make_two_piece_normal() self.assertEqual(self.dtype, dist.dtype) @@ -113,7 +113,7 @@ def testSampleLikeArgsGetDistDType(self): self.assertEqual(self.dtype, getattr(dist, method)().dtype) def testShape(self): - for dist in (self.make_skew_normal(), self.make_skew_normals()): + for dist in (self.make_two_piece_normal(), self.make_two_piece_normals()): expected_batch_shape = dist.skewness.shape self.assertEqual( list(self.evaluate(dist.batch_shape_tensor())), @@ -154,7 +154,7 @@ def testShape(self): self.assertAllEqual(dist.batch_shape, self.evaluate(result).shape) def testSample(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() seed_stream = test_util.test_seed_stream() @@ -166,7 +166,7 @@ def testSample(self): uniform_sample = tf.random.uniform( sample.shape, maxval=1., dtype=self.dtype, seed=seed_stream()) sign = tf.where(uniform_sample < 0.5, -one, one) - normal_sample = self.evaluate(sign * tfd.skew_normal.standardize( + normal_sample = self.evaluate(sign * tfd.two_piece_normal.standardize( sample, loc=dist.loc, scale=dist.scale, skewness=dist.skewness)) # Note that the standard error for the sample mean is ~ sigma / sqrt(n). @@ -178,7 +178,7 @@ def testSample(self): self.assertAllClose(np.std(normal_sample), 1.0, atol=0.1) def testLogPDF(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() x = np.array([[-35.], [3.], [20.]], dtype=self.dtype) @@ -195,7 +195,7 @@ def testLogPDF(self): self.assertAllClose(log_pdf, expected_log_pdf) def testCDF(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() x = np.array([[-35.], [3.], [20.]], dtype=self.dtype) @@ -212,7 +212,7 @@ def testCDF(self): self.assertAllClose(cdf, expected_cdf) def testSurvivalFunction(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() x = np.array([[-35.], [3.], [20.]], dtype=self.dtype) @@ -229,7 +229,7 @@ def testSurvivalFunction(self): self.assertAllClose(sf, expected_sf) def testQuantile(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() x = np.array([[0.000001], [0.5], [0.999999]], dtype=self.dtype) @@ -249,7 +249,7 @@ def testQuantile(self): rtol=1e-03 if self.dtype == np.float32 else 1e-06) def testMean(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() mean = self.evaluate(dist.mean()) expected_mean = np.array([-1.6543264, 3., 7.612733], dtype=self.dtype) @@ -258,7 +258,7 @@ def testMean(self): self.assertAllClose(mean, expected_mean) def testVariance(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() variance = self.evaluate(dist.variance()) expected_variance = np.array( @@ -268,7 +268,7 @@ def testVariance(self): self.assertAllClose(variance, expected_variance) def testMode(self): - dist = self.make_skew_normals() + dist = self.make_two_piece_normals() mode = self.evaluate(dist.mode()) expected_mode = np.array([3., 3., 3.], dtype=self.dtype) @@ -281,7 +281,8 @@ def testFiniteGradientAtDifficultPoints(self): def make_fn(attr): x = np.array([-100, -20, -5., 0., 5., 20, 100]).astype(self.dtype) return lambda m, s, g: getattr( # pylint: disable=g-long-lambda - tfd.SkewNormal(m, scale=s, skewness=g, validate_args=True), attr)(x) + tfd.TwoPieceNormal(m, scale=s, skewness=g, validate_args=True), + attr)(x) loc = tf.constant(0., self.dtype) scale = tf.constant(1., self.dtype) @@ -310,7 +311,7 @@ def make_fn(attr): @test_util.numpy_disable_gradient_test def testQuantileFiniteGradientAtDifficultPoints(self): def quantile(loc, scale, skewness, probs): - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc, scale=scale, skewness=skewness, validate_args=True) return dist.quantile(probs) @@ -334,7 +335,7 @@ def quantile(loc, scale, skewness, probs): def testFullyReparameterized(self): n = 100 def sampler(loc, scale, skewness): - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc, scale=scale, skewness=skewness, validate_args=True) return dist.sample(n, seed=test_util.test_seed()) @@ -350,12 +351,12 @@ def sampler(loc, scale, skewness): def testNegativeScaleSkewnessFails(self): with self.assertRaisesOpError('Argument `scale` must be positive.'): - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=[0.], scale=[-1.], skewness=[1.], validate_args=True) self.evaluate(dist.mean()) with self.assertRaisesOpError('Argument `skewness` must be positive.'): - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=[0.], scale=[1.], skewness=[-1.], validate_args=True) self.evaluate(dist.mean()) @@ -368,7 +369,7 @@ def testShapeWithPlaceholders(self): skewness = tf.Variable( self.dtype([[0.75, 1.33]]).T, shape=tf.TensorShape(None)) self.evaluate([loc.initializer, scale.initializer, skewness.initializer]) - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=loc, scale=scale, skewness=skewness, validate_args=True) # get_batch_shape should return an '' tensor (graph mode only). @@ -381,7 +382,7 @@ def testVariableSkewness(self): loc = tf.constant(0., self.dtype) scale = tf.constant(1., self.dtype) skewness = tf.Variable(1., dtype=self.dtype) - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=loc, scale=scale, skewness=skewness, validate_args=True) self.evaluate([v.initializer for v in dist.variables]) @@ -398,7 +399,7 @@ def testIncompatibleArgShapesGraph(self): self.evaluate(skewness.initializer) with self.assertRaisesRegexp(Exception, r'compatible shapes'): - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=tf.zeros([4, 1], dtype=self.dtype), scale=tf.ones([4, 1], dtype=self.dtype), skewness=skewness, @@ -406,11 +407,11 @@ def testIncompatibleArgShapesGraph(self): self.evaluate(dist.mean()) -class SkewNormalEagerGCTest(test_util.TestCase): +class TwoPieceNormalEagerGCTest(test_util.TestCase): @tf_test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True) def testMeanAndMode(self): - dist = tfd.SkewNormal( + dist = tfd.TwoPieceNormal( loc=3., scale=10., skewness=[0.75, 1., 1.33], validate_args=True) self.assertAllEqual((3,), dist.mean().shape) @@ -423,25 +424,29 @@ def testMeanAndMode(self): @test_util.test_all_tf_execution_regimes -class SkewNormalTestStaticShapeFloat32(test_util.TestCase, _SkewNormalTest): +class TwoPieceNormalTestStaticShapeFloat32(test_util.TestCase, + _TwoPieceNormalTest): dtype = np.float32 use_static_shape = True @test_util.test_all_tf_execution_regimes -class SkewNormalTestDynamicShapeFloat32(test_util.TestCase, _SkewNormalTest): +class TwoPieceNormalTestDynamicShapeFloat32(test_util.TestCase, + _TwoPieceNormalTest): dtype = np.float32 use_static_shape = False @test_util.test_all_tf_execution_regimes -class SkewNormalTestStaticShapeFloat64(test_util.TestCase, _SkewNormalTest): +class TwoPieceNormalTestStaticShapeFloat64(test_util.TestCase, + _TwoPieceNormalTest): dtype = np.float64 use_static_shape = True @test_util.test_all_tf_execution_regimes -class SkewNormalTestDynamicShapeFloat64(test_util.TestCase, _SkewNormalTest): +class TwoPieceNormalTestDynamicShapeFloat64(test_util.TestCase, + _TwoPieceNormalTest): dtype = np.float64 use_static_shape = False From b6c6c6de4c671f7fdb0c48510587479de82226b2 Mon Sep 17 00:00:00 2001 From: axch Date: Thu, 10 Mar 2022 09:19:09 -0800 Subject: [PATCH 027/153] Update autogenerated numpy-backed linear_operator module. PiperOrigin-RevId: 433771114 --- .../backend/numpy/gen/linear_operator.py | 25 ++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py index 0dc143d3a9..601f9d3ca3 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py @@ -1210,7 +1210,7 @@ def _type_spec(self): pass -class _LinearOperatorSpec(type_spec.TypeSpec): +class _LinearOperatorSpec(type_spec.BatchableTypeSpec): """A tf.TypeSpec for `LinearOperator` objects.""" __slots__ = ("_param_specs", "_non_tensor_params", "_prefer_static_fields") @@ -1285,6 +1285,29 @@ def _serialize(self): self._non_tensor_params, self._prefer_static_fields) + def _copy(self, **overrides): + kwargs = { + "param_specs": self._param_specs, + "non_tensor_params": self._non_tensor_params, + "prefer_static_fields": self._prefer_static_fields + } + kwargs.update(overrides) + return type(self)(**kwargs) + + def _batch(self, batch_size): + """Returns a TypeSpec representing a batch of objects with this TypeSpec.""" + return self._copy( + param_specs=nest.map_structure( + lambda spec: spec._batch(batch_size), # pylint: disable=protected-access + self._param_specs)) + + def _unbatch(self, batch_size): + """Returns a TypeSpec representing a single element of this TypeSpec.""" + return self._copy( + param_specs=nest.map_structure( + lambda spec: spec._unbatch(), # pylint: disable=protected-access + self._param_specs)) + def make_composite_tensor(cls, module_name="tf.linalg"): """Class decorator to convert `LinearOperator`s to `CompositeTensor`.""" From ff698f1dcf0eeb73b6541d48f5f9e0756c10907e Mon Sep 17 00:00:00 2001 From: Matt Hoffman Date: Thu, 10 Mar 2022 12:16:43 -0800 Subject: [PATCH 028/153] Add a colab implementing MEADS to discussion. This colab is a companion to the AISTATS 2022 paper "Tuning-Free Generalized Hamiltonian Monte Carlo. PiperOrigin-RevId: 433819415 --- discussion/meads/README.md | 6 + discussion/meads/meads.ipynb | 1336 ++++++++++++++++++++++++++++++++++ 2 files changed, 1342 insertions(+) create mode 100644 discussion/meads/README.md create mode 100644 discussion/meads/meads.ipynb diff --git a/discussion/meads/README.md b/discussion/meads/README.md new file mode 100644 index 0000000000..03ebb2a674 --- /dev/null +++ b/discussion/meads/README.md @@ -0,0 +1,6 @@ +# Tuning-Free Generalized Hamiltonian Monte Carlo + +The notebook meads.ipynb (best run via Google Colab or Jupyter) implements and +demonstrates the Maximum-Eigenvalue Adaptation of Damping and Step size (MEADS) +algorithm from the paper "Tuning-Free Generalized Hamiltonian Monte Carlo" (to +appear at AISTATS 2022). \ No newline at end of file diff --git a/discussion/meads/meads.ipynb b/discussion/meads/meads.ipynb new file mode 100644 index 0000000000..8067fac5da --- /dev/null +++ b/discussion/meads/meads.ipynb @@ -0,0 +1,1336 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "MEADS.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Copyright 2022 The TensorFlow Probability authors" + ], + "metadata": { + "id": "ZbAGLo-ldhTh" + } + }, + { + "cell_type": "code", + "source": [ + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ], + "metadata": { + "id": "3fnPI-eWddXe" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Install dependencies" + ], + "metadata": { + "id": "rfLrMa7YdwtU" + } + }, + { + "cell_type": "code", + "source": [ + "!rm -Rf probability\n", + "!rm -Rf fun_mc\n", + "!rm -Rf inference_gym\n", + "!git clone --depth 1 https://github.com/tensorflow/probability.git\n", + "!mv probability/spinoffs/fun_mc/fun_mc .\n", + "!mv probability/spinoffs/inference_gym/inference_gym .\n", + "!pip install optax immutabledict" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "g2JvIt-3cbBS", + "outputId": "5d094030-85cd-490a-b13f-e819c0dd7932" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cloning into 'probability'...\n", + "remote: Enumerating objects: 1590, done.\u001b[K\n", + "remote: Counting objects: 100% (1590/1590), done.\u001b[K\n", + "remote: Compressing objects: 100% (1367/1367), done.\u001b[K\n", + "remote: Total 1590 (delta 393), reused 689 (delta 215), pack-reused 0\u001b[K\n", + "Receiving objects: 100% (1590/1590), 37.74 MiB | 12.01 MiB/s, done.\n", + "Resolving deltas: 100% (393/393), done.\n", + "Requirement already satisfied: optax in /usr/local/lib/python3.7/dist-packages (0.1.1)\n", + "Requirement already satisfied: immutabledict in /usr/local/lib/python3.7/dist-packages (2.2.1)\n", + "Requirement already satisfied: absl-py>=0.7.1 in /usr/local/lib/python3.7/dist-packages (from optax) (1.0.0)\n", + "Requirement already satisfied: jax>=0.1.55 in /usr/local/lib/python3.7/dist-packages (from optax) (0.3.1)\n", + "Requirement already satisfied: chex>=0.0.4 in /usr/local/lib/python3.7/dist-packages (from optax) (0.1.1)\n", + "Requirement already satisfied: numpy>=1.18.0 in /usr/local/lib/python3.7/dist-packages (from optax) (1.21.5)\n", + "Requirement already satisfied: jaxlib>=0.1.37 in /usr/local/lib/python3.7/dist-packages (from optax) (0.3.0+cuda11.cudnn805)\n", + "Requirement already satisfied: typing-extensions>=3.10.0 in /usr/local/lib/python3.7/dist-packages (from optax) (3.10.0.2)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from absl-py>=0.7.1->optax) (1.15.0)\n", + "Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.7/dist-packages (from chex>=0.0.4->optax) (0.11.2)\n", + "Requirement already satisfied: dm-tree>=0.1.5 in /usr/local/lib/python3.7/dist-packages (from chex>=0.0.4->optax) (0.1.6)\n", + "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.7/dist-packages (from jax>=0.1.55->optax) (3.3.0)\n", + "Requirement already satisfied: scipy>=1.2.1 in /usr/local/lib/python3.7/dist-packages (from jax>=0.1.55->optax) (1.4.1)\n", + "Requirement already satisfied: flatbuffers<3.0,>=1.12 in /usr/local/lib/python3.7/dist-packages (from jaxlib>=0.1.37->optax) (2.0)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Imports" + ], + "metadata": { + "id": "c7PEZBWPdy9X" + } + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "gdI_RrACcIWP" + }, + "outputs": [], + "source": [ + "import functools\n", + "import fun_mc.using_jax as fun_mc\n", + "import inference_gym.using_jax as gym\n", + "import tensorflow_probability.substrates.jax as tfp\n", + "\n", + "import numpy as np\n", + "\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from jax import lax, vmap, random, jit, value_and_grad\n", + "\n", + "import optax\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# MEADS implementation" + ], + "metadata": { + "id": "OFcuXb27d-Dy" + } + }, + { + "cell_type": "code", + "source": [ + "def estimate_largest_eigenvalue_of_covariance(x, remove_mean=True):\n", + " \"\"\"Estimate the largest eigenvalue of a covariance matrix given a sample.\n", + " \n", + " Implements Algorithm 2 from [1].\n", + "\n", + " We assume the rows of the input matrix `x` are i.i.d. draws from some\n", + " distribution with (unknown) covariance matrix `sigma`. We want an estimate of\n", + " the largest eigenvalue of `sigma`, but we cannot directly observe `sigma`.\n", + " The naive estimator\n", + " ```\n", + " sigma_hat = x.T.dot(x) / (x.shape[0] - 1)\n", + " max_eig = np.linalg.eigvalsh(sigma_hat).max()\n", + " ```\n", + " can be quite biased if the number of rows in x is not quite large, even\n", + " though `sigma_hat` is unbiased. Instead, we compute the ratio of the sum\n", + " of `sigma_hat`'s squared eigenvalues of to the sum of its eigenvalues.\n", + " Although this estimator is asymptotically biased, it tends to be much more\n", + " accurate than the naive estimator above unless `x` has a very large number\n", + " of rows.\n", + "\n", + " [1] M.D. Hoffman and P. Sountsov, \"Tuning-Free Generalized Hamiltonian Monte\n", + " Carlo,\" AISTATS 2022.\n", + "\n", + " Args:\n", + " x: A matrix whose rows are independent draws from the distribution whose\n", + " covariance we are interested in.\n", + " remove_mean: A boolean flag indicating whether or not to replace `x` with\n", + " `x - x.mean(0)`.\n", + " \n", + " Returns:\n", + " max_eig: An estimate of the largest eigenvalue of the covariance of the\n", + " distribution that generated `x`.\n", + " \"\"\"\n", + " x = x - remove_mean * x.mean(0)\n", + " trace_est = (x**2).sum() / x.shape[0]\n", + " # Note that this has a cost that's quadratic in num_chains. This should only\n", + " # be an issue if cost_per_gradient < num_chains*num_dimensions. In this\n", + " # presumably uncommon event, we could potentially use the Hutchinson\n", + " # trace estimator.\n", + " trace_sq_est = (x.dot(x.T)**2).sum() / x.shape[0]**2\n", + " return trace_sq_est / trace_est\n", + "\n", + "\n", + "def meads_update(phmc_state, key, fold_to_skip, iteration, target_log_prob_fn,\n", + " diagonal_preconditioning=True,\n", + " step_size_multiplier=0.5,\n", + " damping_slowdown=1.):\n", + " \"\"\"Apply one step of a self-controlled generalized HMC update.\n", + "\n", + " Args:\n", + " phmc_state: `fun_mc.prefab.PersistentHamiltonianMonteCarloState` containing\n", + " the current states of the chains. Members of phmc_state should\n", + " have leading dimensions [num_folds, num_chains // num_folds].\n", + " key: `jax.random.PRNGKey` used to drive the chains.\n", + " fold_to_skip: Integer saying which fold to leave unchanged this update.\n", + " Should be initialized to `jnp.zeros(num_folds, np.int32)`.\n", + " iteration: Integer saying how many steps we've taken so far.\n", + " Should be initialized to `jnp.zeros(num_folds, np.int32)`.\n", + " target_log_prob_fn: Callable returning unnormalized log-density.\n", + " diagonal_preconditioning: Boolean saying whether or not to apply diagonal\n", + " preconditioning based on estimates of each dimension's relative scale.\n", + " step_size_multiplier: Float saying how much to multiply our estimate of the\n", + " largest eigenvalue of the Hessian by to get a step size.\n", + " damping_slowdown: Float saying how much to increase damping by in early\n", + " iterations. Damping floor is damping_slowdown/iteration.\n", + "\n", + " Returns:\n", + " Updated `phmc_state`, a new `key`, `chain_to_skip` incremented by 1 mod\n", + " `num_folds`, and `iteration` incremented by 1.\n", + " \"\"\"\n", + " momentum_key, new_key = random.split(key, 2)\n", + "\n", + " num_folds = phmc_state.state.shape[0]\n", + " chains_per_fold = phmc_state.state.shape[1]\n", + " num_chains = num_folds * chains_per_fold\n", + " num_dimensions = phmc_state.state.shape[-1]\n", + "\n", + " # Randomly refold the walkers.\n", + " perm = random.permutation(random.PRNGKey(iteration // 4), num_chains)\n", + " # TODO(mhoffman): This should really done with a scatter.\n", + " unperm = jnp.eye(num_chains)[perm].argmax(0)\n", + " def refold(x, perm):\n", + " return x.reshape((num_chains,) + x.shape[2:])[perm].reshape(x.shape)\n", + " phmc_state = jax.tree_map(functools.partial(refold, perm=perm), phmc_state)\n", + "\n", + " if diagonal_preconditioning:\n", + " scale_estimates = phmc_state.state.std(1, keepdims=True)\n", + " else:\n", + " scale_estimates = jnp.ones([num_folds, 1, num_dimensions])\n", + " # Apply preconditioning within-fold to estimate step size and damping.\n", + " self_preconditioned_state = phmc_state.state / scale_estimates\n", + " self_preconditioned_grads = phmc_state.state_grads * scale_estimates\n", + " # Apply preconditioning across folds to do the actual update.\n", + " rolled_scale_estimates = jnp.roll(scale_estimates, 1, 0)\n", + "\n", + " # Set step size for each fold based on the fold to its left.\n", + " step_size = step_size_multiplier / jnp.sqrt(\n", + " vmap(functools.partial(estimate_largest_eigenvalue_of_covariance,\n", + " remove_mean=False))(self_preconditioned_grads))\n", + " step_size = jnp.minimum(1., step_size)\n", + " step_size = jnp.roll(step_size, 1)\n", + "\n", + " # Set damping.\n", + " damping = step_size / jnp.sqrt(\n", + " vmap(estimate_largest_eigenvalue_of_covariance)(\n", + " self_preconditioned_state))\n", + " # Put a floor on the amount of damping in early iterations.\n", + " damping = jnp.maximum(damping_slowdown/iteration, damping)\n", + "\n", + " noise_fraction = (1 - jnp.exp(-2 * damping))**0.5\n", + " mh_drift = 0.5 * noise_fraction**2\n", + "\n", + " # TODO(mhoffman): Consider using lax.gather instead of jnp.roll logic.\n", + " # An advantage of roll is that it makes it clear to XLA that there's not\n", + " # actually any dynamic sizing going on here.\n", + " def select_folds(x):\n", + " return jnp.roll(jnp.roll(x, -fold_to_skip, 0)[1:], fold_to_skip, 0)\n", + "\n", + " def rejoin_folds(updated, original):\n", + " return jnp.roll(jnp.concatenate([original[fold_to_skip][jnp.newaxis],\n", + " jnp.roll(updated, -fold_to_skip, 0)], 0),\n", + " fold_to_skip, 0)\n", + "\n", + " active_fold_state, phmc_extra = fun_mc.prefab.persistent_hamiltonian_monte_carlo_step(\n", + " jax.tree_map(select_folds, phmc_state),\n", + " target_log_prob_fn=target_log_prob_fn,\n", + " step_size=select_folds(step_size[:, jnp.newaxis, jnp.newaxis] *\n", + " rolled_scale_estimates),\n", + " num_integrator_steps=1,\n", + " noise_fraction=select_folds(noise_fraction)[:, jnp.newaxis, jnp.newaxis],\n", + " mh_drift=select_folds(mh_drift)[:, jnp.newaxis],\n", + " seed=momentum_key)\n", + " phmc_state = jax.tree_multimap(rejoin_folds, active_fold_state, phmc_state)\n", + "\n", + " # Revert the ordering of the walkers.\n", + " phmc_state = jax.tree_map(functools.partial(refold, perm=unperm), phmc_state)\n", + "\n", + " traced = {\n", + " 'z_chain': phmc_state.state,\n", + " 'is_accepted': phmc_extra.is_accepted,\n", + " 'damping': damping,\n", + " 'step_size': step_size,\n", + " 'level': phmc_state.pmh_state.level,\n", + " }\n", + "\n", + " return ((phmc_state, new_key, (fold_to_skip + 1) % num_folds, iteration+1),\n", + " traced)\n", + "\n", + "\n", + "def adam_initialize(x, target_log_prob_fn, num_steps=100, learning_rate=0.05):\n", + " \"\"\"Use Adam optimizer to get a reasonable initialization for HMC algorithms.\n", + "\n", + " Args:\n", + " x: Where to initialize Adam.\n", + " target_log_prob_fn: Unnormalized target log-density.\n", + " num_steps: How many steps of Adam to run.\n", + " learning_rate: What learning rate to pass to Adam.\n", + "\n", + " Returns:\n", + " Optimized version of x.\n", + " \"\"\"\n", + " optimizer = optax.adam(learning_rate)\n", + " @jit\n", + " def update_step(x, adam_state):\n", + " def g_fn(x):\n", + " return jax.tree_map(lambda x: -x, value_and_grad(target_log_prob_fn)(x))\n", + " tlp, g = g_fn(x)\n", + " updates, adam_state = optimizer.update(g, adam_state)\n", + " return optax.apply_updates(x, updates), adam_state, tlp\n", + "\n", + " adam_state = optimizer.init(x)\n", + " for i in range(num_steps):\n", + " x, adam_state, tlp = update_step(x, adam_state)\n", + " print('Adam iteration/NLL: %d\\t%f' % (i, tlp))\n", + " return x" + ], + "metadata": { + "id": "ekcZDuN7d52S" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@functools.partial(jit, static_argnums=(1, 2, 3, 4, 5))\n", + "def run_meads(initial_pos,\n", + " target_log_prob_fn,\n", + " num_steps,\n", + " num_chains,\n", + " num_folds,\n", + " thinning=10):\n", + " \"\"\"Run MEADS to generate samples from an unnormalized density.\n", + "\n", + " Args:\n", + " initial_pos: Array with shape [num_dimensions] to initialize chains around.\n", + " target_log_prob_fn: Unnormalized target log-density function.\n", + " num_steps: Integer number of iterations to run.\n", + " num_chains: Integer number of chains to use.\n", + " num_folds: Integer number of folds to break the chains into when estimating\n", + " appropriate control parameters.\n", + "\n", + " Returns:\n", + " samples: Array with shape [num_steps, num_chains, num_dimensions] containing\n", + " the sequence of states of the chains.\n", + " \"\"\"\n", + " seed = random.PRNGKey(0)\n", + " state_seed, m_seed, slice_seed, mcmc_seed = random.split(seed, 4)\n", + "\n", + " # Set up initial states for the chains.\n", + " num_dimensions = initial_pos.shape[-1]\n", + " chains_per_fold = num_chains // num_folds\n", + " state_shape = [num_folds, chains_per_fold, num_dimensions]\n", + " initial_pos = initial_pos + 0.01 * random.normal(state_seed, state_shape)\n", + " initial_m = random.normal(m_seed, initial_pos.shape)\n", + " initial_u = 2*random.uniform(slice_seed, state_shape[:-1]) - 1\n", + " initial_state = fun_mc.prefab.persistent_hamiltonian_monte_carlo_init(\n", + " initial_pos, target_log_prob_fn, initial_m, initial_u)\n", + "\n", + " curried_update = functools.partial(\n", + " meads_update,\n", + " target_log_prob_fn=target_log_prob_fn,\n", + " diagonal_preconditioning=True,\n", + " step_size_multiplier=0.5,\n", + " damping_slowdown=1.)\n", + " # Nested call to fun_mc.trace implements thinning.\n", + " return fun_mc.trace((initial_state, mcmc_seed, 0, 0),\n", + " lambda *state: fun_mc.trace(\n", + " state, curried_update, thinning, trace_mask=False),\n", + " num_steps//thinning)[1]\n", + "\n", + "# Since MEADS is a tuning-free algorithm, you should be able to swap out\n", + "# GermanCreditNumericSparseLogisticRegression for any other inference gym\n", + "# target distribution without additional tuning (although you might need to\n", + "# increase `num_steps`.\n", + "target = gym.targets.VectorModel(\n", + " gym.targets.GermanCreditNumericSparseLogisticRegression())\n", + "target_log_prob_fn = fun_mc.transform_log_prob_fn(\n", + " lambda x: (target.unnormalized_log_prob(x), ()),\n", + " target.default_event_space_bijector)\n", + "num_dimensions = target.event_shape[0]\n", + "num_steps = 1000\n", + "thinning = 10\n", + "num_chains = 128\n", + "num_folds = 4" + ], + "metadata": { + "id": "sKp-UxXplVwp", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "adb5455a-f464-4eda-a080-9b31d17f6ec2" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:6690: UserWarning: Explicitly requested dtype float64 requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"astype\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:6690: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"astype\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3611: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"array\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3742: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"zeros\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3611: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"array\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3742: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"zeros\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3750: UserWarning: Explicitly requested dtype requested in ones is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"ones\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:6690: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"astype\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3611: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"array\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3742: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"zeros\")\n", + "/usr/local/lib/python3.7/dist-packages/jax/_src/numpy/lax_numpy.py:3750: UserWarning: Explicitly requested dtype requested in ones is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"ones\")\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "%%time\n", + "\n", + "# Note that the first run triggers compilation (which takes a few seconds) and \n", + "# dataset download (which can also take a little time). For \"easy\" problems this\n", + "# can dominate the runtime. To get a better sense of how much time is actually\n", + "# spent on compute, just run this cell twice.\n", + "initial_state = adam_initialize(jnp.zeros(target.event_shape),\n", + " lambda x: target_log_prob_fn(x)[0])\n", + "result = run_meads(initial_state,\n", + " target_log_prob_fn,\n", + " num_steps, num_chains, num_folds, thinning)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AEImri62HQcM", + "outputId": "35847b26-0c71-4f13-c5a3-fb3346c1f9bc" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Adam iteration/NLL: 0\t753.013062\n", + "Adam iteration/NLL: 1\t700.834106\n", + "Adam iteration/NLL: 2\t659.783264\n", + "Adam iteration/NLL: 3\t630.853027\n", + "Adam iteration/NLL: 4\t610.618652\n", + "Adam iteration/NLL: 5\t596.124023\n", + "Adam iteration/NLL: 6\t584.096558\n", + "Adam iteration/NLL: 7\t571.852722\n", + "Adam iteration/NLL: 8\t559.079285\n", + "Adam iteration/NLL: 9\t547.278748\n", + "Adam iteration/NLL: 10\t538.225037\n", + "Adam iteration/NLL: 11\t533.297974\n", + "Adam iteration/NLL: 12\t533.058044\n", + "Adam iteration/NLL: 13\t536.620178\n", + "Adam iteration/NLL: 14\t541.386230\n", + "Adam iteration/NLL: 15\t544.342285\n", + "Adam iteration/NLL: 16\t544.214661\n", + "Adam iteration/NLL: 17\t541.702454\n", + "Adam iteration/NLL: 18\t538.296875\n", + "Adam iteration/NLL: 19\t535.241821\n", + "Adam iteration/NLL: 20\t533.131226\n", + "Adam iteration/NLL: 21\t532.007263\n", + "Adam iteration/NLL: 22\t531.632935\n", + "Adam iteration/NLL: 23\t531.708191\n", + "Adam iteration/NLL: 24\t531.978943\n", + "Adam iteration/NLL: 25\t532.268494\n", + "Adam iteration/NLL: 26\t532.473450\n", + "Adam iteration/NLL: 27\t532.545105\n", + "Adam iteration/NLL: 28\t532.467651\n", + "Adam iteration/NLL: 29\t532.242371\n", + "Adam iteration/NLL: 30\t531.881836\n", + "Adam iteration/NLL: 31\t531.415527\n", + "Adam iteration/NLL: 32\t530.898560\n", + "Adam iteration/NLL: 33\t530.408386\n", + "Adam iteration/NLL: 34\t530.025330\n", + "Adam iteration/NLL: 35\t529.803711\n", + "Adam iteration/NLL: 36\t529.750122\n", + "Adam iteration/NLL: 37\t529.822144\n", + "Adam iteration/NLL: 38\t529.946106\n", + "Adam iteration/NLL: 39\t530.044678\n", + "Adam iteration/NLL: 40\t530.063477\n", + "Adam iteration/NLL: 41\t529.987305\n", + "Adam iteration/NLL: 42\t529.839355\n", + "Adam iteration/NLL: 43\t529.664673\n", + "Adam iteration/NLL: 44\t529.507996\n", + "Adam iteration/NLL: 45\t529.396912\n", + "Adam iteration/NLL: 46\t529.338196\n", + "Adam iteration/NLL: 47\t529.322144\n", + "Adam iteration/NLL: 48\t529.329346\n", + "Adam iteration/NLL: 49\t529.338318\n", + "Adam iteration/NLL: 50\t529.331787\n", + "Adam iteration/NLL: 51\t529.302002\n", + "Adam iteration/NLL: 52\t529.251770\n", + "Adam iteration/NLL: 53\t529.190979\n", + "Adam iteration/NLL: 54\t529.131287\n", + "Adam iteration/NLL: 55\t529.081421\n", + "Adam iteration/NLL: 56\t529.046326\n", + "Adam iteration/NLL: 57\t529.025818\n", + "Adam iteration/NLL: 58\t529.014465\n", + "Adam iteration/NLL: 59\t529.005005\n", + "Adam iteration/NLL: 60\t528.991272\n", + "Adam iteration/NLL: 61\t528.971130\n", + "Adam iteration/NLL: 62\t528.945312\n", + "Adam iteration/NLL: 63\t528.917114\n", + "Adam iteration/NLL: 64\t528.890503\n", + "Adam iteration/NLL: 65\t528.868591\n", + "Adam iteration/NLL: 66\t528.852356\n", + "Adam iteration/NLL: 67\t528.840454\n", + "Adam iteration/NLL: 68\t528.830872\n", + "Adam iteration/NLL: 69\t528.821716\n", + "Adam iteration/NLL: 70\t528.811401\n", + "Adam iteration/NLL: 71\t528.798828\n", + "Adam iteration/NLL: 72\t528.784119\n", + "Adam iteration/NLL: 73\t528.768372\n", + "Adam iteration/NLL: 74\t528.753174\n", + "Adam iteration/NLL: 75\t528.739563\n", + "Adam iteration/NLL: 76\t528.728821\n", + "Adam iteration/NLL: 77\t528.721008\n", + "Adam iteration/NLL: 78\t528.714966\n", + "Adam iteration/NLL: 79\t528.709045\n", + "Adam iteration/NLL: 80\t528.701843\n", + "Adam iteration/NLL: 81\t528.692627\n", + "Adam iteration/NLL: 82\t528.682068\n", + "Adam iteration/NLL: 83\t528.671387\n", + "Adam iteration/NLL: 84\t528.661865\n", + "Adam iteration/NLL: 85\t528.654480\n", + "Adam iteration/NLL: 86\t528.648621\n", + "Adam iteration/NLL: 87\t528.643555\n", + "Adam iteration/NLL: 88\t528.638245\n", + "Adam iteration/NLL: 89\t528.632324\n", + "Adam iteration/NLL: 90\t528.625610\n", + "Adam iteration/NLL: 91\t528.618652\n", + "Adam iteration/NLL: 92\t528.611633\n", + "Adam iteration/NLL: 93\t528.604980\n", + "Adam iteration/NLL: 94\t528.598938\n", + "Adam iteration/NLL: 95\t528.593445\n", + "Adam iteration/NLL: 96\t528.588623\n", + "Adam iteration/NLL: 97\t528.583923\n", + "Adam iteration/NLL: 98\t528.579224\n", + "Adam iteration/NLL: 99\t528.574280\n", + "CPU times: user 3.1 s, sys: 141 ms, total: 3.24 s\n", + "Wall time: 2.87 s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "The chains converge to their stationary distribution pretty quickly." + ], + "metadata": { + "id": "rMydHIasQ2dy" + } + }, + { + "cell_type": "code", + "source": [ + "t = np.arange(0, num_steps, thinning)\n", + "\n", + "plt.plot(t, result['z_chain'].reshape([num_steps // thinning, -1, num_dimensions])[:, :, 0],\n", + " 'b', alpha=0.5)\n", + "plt.plot(t, result['z_chain'].reshape([num_steps // thinning, -1, num_dimensions])[:, :, 0].mean(1),\n", + " 'k', linewidth=5, label='mean estimate')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Chain States')\n", + "plt.legend(loc='best')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "id": "a7GvcgSeDsxc", + "outputId": "2a3b8849-6e5b-44f8-8207-133b61aea163" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "The control parameters converge even faster, and are relatively consistent across folds (control parameters for different folds are shown in different colors)." + ], + "metadata": { + "id": "Kbc9I5FMRzio" + } + }, + { + "cell_type": "code", + "source": [ + "plt.plot(t, result['step_size'])\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Step Size Parameter $\\epsilon$')\n", + "plt.ylim(0, None)\n", + "plt.show()\n", + "\n", + "plt.plot(t, result['damping'])\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Damping Parameter $\\gamma$')\n", + "plt.ylim(0, None)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 542 + }, + "id": "6QEUJr-TPGlw", + "outputId": "e16a52d8-bc8b-4eec-e79f-c4bf01a030cb" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "The standard-deviation estimates (used for preconditioning) are a bit noisier, but nonetheless converge to a useful range reasonably quickly." + ], + "metadata": { + "id": "FKHb7W3VjfQW" + } + }, + { + "cell_type": "code", + "source": [ + "std_dev_ests = result['z_chain'].std(2)\n", + "for dimension in range(num_dimensions):\n", + " plt.plot(t, std_dev_ests[:, :, dimension])\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Std. dev estimate {}'.format(dimension))\n", + " plt.ylim(0, None)\n", + " plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ejpASlEjSRBP", + "outputId": "b7f7d2cd-2623-4250-a45b-98ca9cb325d0" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd1gUZ/7AP+8uu8DSOwoIKNgrIMbeozHRJCbR9Hrp/Xe5lLtLu+TSuymmR3OJMcVoosZesCECVmwgShWQ3rfO749BiuzCUjVxPs+zz+rM22bZne+83yokSUJBQUFB4eJFdb4XoKCgoKBwflEEgYKCgsJFjiIIFBQUFC5yFEGgoKCgcJGjCAIFBQWFixyH872AtuLr6yuFhYWd72UoKCgo/KlISkoqlCTJz9q5P50gCAsLIzEx8XwvQ0FBQeFPhRAiw9Y5RTWkoKCgcJGjCAIFBQWFixxFECgoKChc5CiCQEFBQeEiRxEECgoKChc5iiBQUFBQuMhRBIGCgoLCRY4iCBQUFBT+BPxw9AdOlZ3qkrEVQaCgoKBwgXO46DCv7H6Fn4//3CXjK4JAQUFB4QJGkiReT3gdLycv7h12b5fMoQgCBQUFhQuYtafWklyQzCMjHsFN69YlcyiCQEFBQeECpcZUw9tJb9Pfuz9XRVzVZfMogkBBQUHhAuWbQ9+QV5XHUyOfQq1Sd9k8iiBQUFBQuACpMFTw1aGvuDT0UmICY7p0LkUQKCgoKFyA7MjdQa25lhsH3NjlcymCQEFBQeECJC4rDg9HD4b5DevyuRRBoKCgoHCBYbaY2ZazjfFB43FQdX39sD9dhTIFha6gaudOqnbupObAQWqPHsXv4YfxvuXm870shYuU/Wf2U6ovZWLIxG6ZT9kRKFz0lP6yjMw776J40WIstbU4eHtTuHAhltra7l+M2dj9cypccGzN3oqDcGBsz7HdMp8iCBQuaqri4zn9/PO4jB1L38Q9hP+4lMAXXsBcVETZ8uXdu5j8FHg1BOI/6d55FS44tmZtJTogussCyM5FEQQKFy369HSyH3kUx/Awgt57F5WjIwC6UbE4DR1K0ZdfIZlM3begE5vBVANrnlaEwUVMVkUWJ8pOdJtaCBRBoHCRYqmuJuve+xBaLSELF6J2a3jyEkLg87e7MGZlUbFuXfctKjcZ3INgwJw6YbCw++ZWuGCIy44DYFLwpG6bUxEEChcl5WvXYczKIuiN19EEBTU77zZ1KtqwMAo//wJJkrpnUTlJEBwD134FA2bDmqcgfWv3zK1wwbAlawvhHuGEuId025yKIFC4KCn7bQWakBB0o0dbPS/Uanz+dhf6I0eo2rGz6xdUVQQlp6BnFKg1MPcLcHCGY6u7fm6FC4ZyQzmJ+YnduhsARRAoXIQY8/Kojt+Nx5w5CCFstnOfMwcHb3eKPny36xeVmyy/B0XL7xonCB0j2w0ULhp+P/E7JouJGWEzunVeRRAoXHSUr1wJkoTHnNm2G1nMqDY+i3evLKr3pVD9y3tdu6icJEBAz+ENx3pPgsJjUJ7btXMrXBBIksSPx35ksM9gBvkO6ta5FUGgcFEhSRJlK1bgPGIE2tBQ640MVbD0Zti9EK9581A7qyj88H3Y/CpYLF2zsJwk8OsPjo3cBftMlt/Tt3TNnAoXFIn5iaSXpTO///xun1sRBAoXFfojR9CnpuFx5RzrDWrLYNFsOL4GLnsT1dz38P7b/VSddqJ2+Vuw4fnOX5QkyYLgrFroLP6DQOerCIKLhKXHluKudWdm2Mxun1sRBAoXFWUrfkNoNLjPtPJjM1TBd/Pg9AGY9y2MugcAr1tuReXqSmHOQEj4DKoK7ZvMUAV5B8FibrldaQZUF0FQVNPjKhX0nigLgu7yXFI4L5ypPsPGjI1cFXEVTg5O3T6/IggULhokk4myVatwnTQJtadn05MmPfxwE2QnwDWfw4Ar6k+p3d3xuukmKlKK0BeZIPGr1iczGWShsnAcvBEuj71/qfUbek6S/H7ujgCg92SozIeCI224UoU/G8tSl2GSTMzrN++8zK8knVP401KxaTMlPyxBN3IkruPG4di/f4teQKXLlmEuLMTj6nNK/pkM8POdkL4ZrvwIBl3drK/3bbdSvHgx6X/4wx9fgXox2uBgXKdNxW3aNJyHDUOo6p6rJAn++AdkbIfxf4fKAvmp/uhK+aY+9pGmg+ckg9oRAqwYCHtPkt/Tt0DAQHs/GoU/ESaLiZ+O/8ToHqMJdbdht+piumxHIIQIEUJsFkIcFkKkCCEetdJGCCE+EEKkCSEOCCGirI2loHAuxrw8cp9+mpqkZM68/Q4nr57LiUtnYMjKst6+oICCN99CN2oUrpMnN5zQV8KS+fJN+rI3YIT1jKMO3t4Ev/8evjdeju+gSnwuj0UTHEzxosVk3HAjmbfe1pCOIuFzSPoGxj0OU5+DKz+ERw/IAmb9s3Dw56aD5yRDj2Fy/MC5eIaAT4RiJ/gLk5yfTH51Ptf2vfa8raErdwQm4O+SJCULIdyAJCHEekmSDjdqcxkQWfcaBXxS966gYBPJYiH3mWeQjEZ6L/8V4exM1bbt5L/xBll330Poku9x8PJq0if/5f8i6fX0ePGFhl1DVSF8dx2c3gdzPoSoW1qc13XCBFzHj4dP48GcAq/HY66ooPTHnyh46y2KXn8a33H+sOU16HsZTHmuobNKBVcthIp8WH4/uAVC2Dgwm+T5o26zPXHvSbBvibxzcdC2+vlkl1Tz/IoUhoV48sjUyFbbK5xf4k/HoxZqxvQcc97W0GU7AkmSTkuSlFz37wrgCHBuLP+VwGJJJh7wFEL06Ko1Kfw1KPnfd1Tviifg6afRhoai8ffH85q5hHz0IcbcXLIffKhJCumKjRupWLcO3wcfRBsWJh/UV8BXM6HgMMz/rlUhUI8QMPphOHMUtr2Feuuz+JS8hltIDYXfraT219dlo+81n8s3/8ZonOD678ArDL6dC59OgB9uBGN1c0NxY3pPBmMVZMW3urzle3O47L1tbDxawOJdp7BYFCPzhc7uvN0M8h2Eq9b1vK2hW4zFQogwYASw+5xTQUDjvXw2zYUFQoh7hBCJQojEM2fOdNUyFf4E6E+coODtt3GdNAnPedc1OaeLiaHn669Rk5xM9iOPUPTFFxQuXEjei//BsV8/fO68o6Fx/EIoSoUbl0L/WW1bxOC54NYTNr0sq3lCxxD4zD9QublxOmM80m1/NI0HaLJIb7hlOcTcKbuGFh4HF395d2CL8PHg7AW/3g/F6TabPbfiEI8t3UffQDcemxZJYaWBI3nlbbs2hW6l0lBJSmEKowLPryKky43FQghX4BfgMUmS2vWtlCTpM+AzgJiYGOUR5yKm6LPPEVotPV5+qblhWJJwH94T07xR5P+0jaq4bQCo3N0IfvlDhKZOB19TCrsWQL/LG4yxbUGtgZt+gorTEDYeNE44AIEv9iHnsccp+vJLfO+7z3Z/jyC47DX753PygFt/g8VXwtez4LbfwbepyieruJrFuzK4fmQIL181mOIqA+9tSGVbaiGDenq0/RoVuoWk/CTMkplRPc6vIOjSHYEQQoMsBL6TJGmZlSY5QOMUe8F1xxQUmiFJElV7EnAZMwYHX9+mJzPj4Z0B8OkEvFW/0u92Qb/r8ul/XS59LzuOs/lgQ9v4j+XAsUlPt38xgYMhcrqs7qnDfeZM3KZPo+izz7Ho9e0f2xo9hsLtq8BikoVBYVqT0z8lZSMEPDw1Ege1Cn93J/oHurEtVdlBX8jsztuNVqXtlgL1LdGVXkMC+BI4IknSOzaa/QbcWuc9dAlQJknS6a5ak8KfG2NODqbc0+hiRzY9IUmw9p8gVHDlx/D346ieOozquRzEfZsQvSfAiocgdT1UF8Ouj+Wc/z2GdvoaPefNx1Jd3TUZSwMGysLAWA07368/bLZI/JyYxbgIX4I8neuPj4/0Zc/JEmoMrQS0KZw3dp/ezQj/EecliKwxXbkjGAvcAkwRQuyre80SQtwnhDi7b14NpANpwOfAA124HoULnepiqLWtPaxO2AOAbuQ5giB9ixyUNeEfMOImcAuQj2uc5SCt67+Tn+B/vBV+fwQMlTDpmS65BJdRsajc3LquoI1fP4i8FI79UR+xvD2tkNyyWuaPbJq/fnykHwazhd0ni7pmLQodoqimiOMlx8+7Wgi60EYgSdJ2wHZ0j9xGAh7sqjUo/InIOyjn+PHuDXdtaO5xA1Tv2YPaywvHiIimJ7a9LRtvh99ofWxHN7jpZ/hyOhz5HQbN7bLgLKHV4jZlMhWbNyMZjQ12ic6k/+WQsgyyE6HXKH7ck4WXTsP0gQFNmsWGe6N1ULEttZBJ/fw7fx0KHWJPvvxgE9sj9jyvREkxoXAhkHcIFs2R/eRzkuSbnBWqExLQxcQ0RPACZO6GU9tgzMPg4Gh7Dld/uHkZDLwKpj7byRfQFLdLL8VSVkZVQkLXTBA5HVQaOLaK4ioD6w7ncdWIIBwd1E2aOWnUjAr3VuwEFyi7T+/GVePKIJ/uTTltDUUQKJxf8lNg8RxwcIJ74yBwCGx8Uc790whjbi7GnJzmaqFtb4HOB6JbCMg6i08fmLdI3nV0IS5jxyJ0OirWre+aCZw8ZHfTo6tYvjcHo1liXoz1sobjI305nl9JXlmt1fMK54+E0wnEBMTgoDr/mX4UQaBw/rCYYckNoNbC7SvBNwKmvwSlmXKWz0ZU76mzD4xqtI0+vR9S18ElD4DWpTtX3iIqJydcJ0ygYuNGJHPXGGql/pdDURobt29jaLAHA3q4W203PtIPQNkV2EHx4sWcfv4F8v77CgVvvUXNoZQum+t05WkyKzIvCLUQKIJA4XxyMk5OwTzjv/LTOsjFWCKmQdybsvG4jqqEBNQeHjhGNvKf3/URaN1g5N+6eeGt437pdMyFhdTs3dvpY286ms9d8bLO/xJDPE/O6G+zbf9AN3xdHYlLtTN19kVK7bFj5L/yKuWrV1O2fDlFX3/D6WefReqi9N9rTq0BYGzQ2C4Zv60ogkDh/LF/CTh6yIFdjZn+HzkFxLa36w9V70nEubF9oKoIUn6FYdeD8zkppS8AXCZMRGi1lHey99DSPZnc+U0iJ/TuFLkP5MEexxgX6WuzvRCCUeHeHMgu7dR1/NUo/uorhE5HxIb19NuTQOC//4X+yBFqDx3q9LkskoWfjv9ElH8UvT26Vk1pL4ogUDg/1JbD4d/kdA2ac3yoAwbBsBtgzxdQkY8xLw9jZiYujeMH9n4LZgOMvKt7120nalcXXMaOpWL9hk57qlxzKI9nlh1kQl8/1j8+EZ/ouahyEqEir8V+kQGuZBZXU2tU4gmsYczLo2zVajyvvQa1hxyF7X7FFQhnZ0qWLu30+eJPx5NVkXXeag9YQxEECueHwyvAVGPb5XP83+Ub/c4PGuwDI0eSVVzNgaxiSPoaQseC/4BuXHTbcJ04AdPp0xhtpMZuCztPFPLIkr0MC/Fk4c1RaB1UDTmSjq1usW+kvxuSBGkFlR1ex1+R4sXfgiThfWuDw4HazQ33y2dRvmo15srO/dx+OvYTXo5eTA+d3qnjdgRFECicH/YvAe8+EDzS+nmfPjBkHiR+ReWGdajc3PilzIlL343jg88+hZJTcuK2CxhdTAwgq7U6QlGlnnsWJxHmq+Pr20ei09Z5mfgPlGsV7G/5qbVvgJzVMrWgokPr+CtirqigdOlS3GfMQBvcNN+l1/z5SDU1lP/+e6fNV1BdwOaszVwVcRVadespxbsLRRAodD/FJyFjh7wbaKGiGOP/TnWuifK1G4gfMI5/rThC30A35rOOGq23nCbiAkbbpw9qT0+qEzsmCJYl51CpN7Hghig8dY1uHkJA1K1yeuqCozb7h/m64KASpOYrO4JzKf3xJyxVVXjf1fyhwmnwYBwHDKBk6Y+dpt5blroMs2Q+r0VorKEIAoXuZ/8PgJANvS0geYSRdzAEtc7MFz2jeGH2QH69IZgp6n2sUE1DslbR6wJCCIFzTHSHBIEkSSxNzCKqlyf9Aq2kth52oxxclrzY5hgatYpwXxeOK4KgCabCQooXLUJ3ySU4D2oe1CWEwGv+PPRHj1J74EDH57OY+Pn4z4zuMZpe7r06PF5noggChe5FkuDADxA+ATyCW2xa9PU36Atq6BFdypd+33J77ouoFl2BABaUjuVQzoWfa18XE4MxKwtjfn67+idnlpBWUNksj1A9rn6yrWD/EjDaDhrrG+BGmqIaqsdUXEzG7bdjrqjA/+//Z7Od+xVXIHQ6Sn76qcNzbsnaQn51/gVlJD6LIggUupfidFm/P7BltY4hM5PCjz9GP2YiGwOj6VsRD7l7IXAItVd8RJEmgB/2ZHbPmjuALka2gbR3V/BDQhYuWjVXDO1pu1H07VBTLNddtkGEvysZiucQAKaSEjLvuBNjdg4hCxfiPGSIzbZqV1fcpkyhctNmJIul3XNaJAsf7/+YUPdQJoVMavc4XYUiCBS6l7NF2MMn2Wwimc2c/vezCAcH1k+9iaelh6h+IhMe3Q83fI8u5kZmDe7Bb/tyqTaYumXZ7cWpfz9UOl27BEFFrZGVB04ze1hPXBxbSEMQPgk8QyHpG5tN+gYonkMAFoOBrL/djeHkSYI/+hCXUa1H9rpOnIC5uJjalMOttrXF2lNrSS1J5YFhD1wQKSXORREECt3LyThwD2qIJLZC4UcfUZ2QQMC//sUfeWZie/uhc21aZWv+yBAq9CZWH2zZh/58IxwccI6KoqYdgmDlgdPUGM3Ms6UWOotKJddcPrUNik5YbRJZ5zl0sQuCsl+XU5uSQs833sB1rH1RvS7jxoEQVMZtbdecJouJj/d9TIRnBDPDZ7ZrjK5GEQQK3YfFIguC8Ik2vYUqt22n8JOFeMydS/nEGaSfqWJyP79m7WLDvQn3deG73RmYL/AC7bqYGPSpaZhKSlptW20wUVSpp6C8lh/2ZNE3wJURIXZETg+/GYTaptE4zEf2HDqef/HaCSSjkaLPPsNp6FDcZlxqdz8HLy+chg6hMi6uXfP+fuJ3TpWf4qERD6ESF+Yt98JclcJfk/xDsi47fILV08a8PHKffBLHiAgCn/03W44XAFjNpS+E4M6xYezNLOWmL+IpKO/e7JrJmSXsy7IvbYNupBxPUJOc3GK7lNwyhrywjuiXNxD7ykb2Z5UyLyakeW1ma7j3gL4zYd93cjrvc9A6qAjzdSH1It4RlK1chTEnB9/77rPvM22E64QJ1B44aJcwb4zRbGTh/oUM9BnIlJApberbnSiCQKH7OFn3RNV7otXTeS/+B0mvJ+j991E5O7P5aAFhPjrCfa1nFr1ldBhvXjuUfVmlzPpgG9u7KbFardHMPYsT+duiRLvKQDoNGYLQalsNLFtzKA9Jknh+9kD+e/Vg3pk3jJsvCW3WrmLzZkzFxc0HiL4dqs7A8T+sjt83wJXUi3RHIJnNFH36KY4DBuA6eVKb+7tOmAiSRNX27W3qtzJ9JblVuTw84uE2C5/uRBEECt3Hya3gEwnuDR4wFouEJMmv6j17cJ8zG8fe4dQazew8UdRqZa3rYkL47aFxeOm03PZ1Aodzu96l9JfkbAorDRRW6vlffEar7VVaLc5Dh7ZqMN50tIDoUC/uGBvOTaNCmRsVjJOmabGZ4u++I/v+Byj+ZlHzASKmgnuwTaNxpL/bRZtzqHzNGgynTrVrNwDgNGggah8fKre2TT205tQagl2DGdvzwsgyagtFECh0D2YjZOxsohY6VVjFpLe28NLKI5jy8rBUVuLUrx8A8elF6E0WJvdvvcRi3wA3frpvNJ7OGv61/CCWLrQZmC0Sn8elMyzYg3ERvizcesIuzyXnkTHUHj6MucL6E3l+eS0pueUtXm9lXBz5/30FgNrDVjxYVGo50vjEJtlF9xwiA1yxSHDizMWlHpIsFooWfoo2og9u06e1awyhUuE6bhxV27fbXWOiTF9GwukEpodNv6B3A6AIAgV7yU+B5Q+AsaZ9/XOS5aLxdWqhE2cqmf/ZLjKLq/ludwZFB48A1Ncb2Hy0ACeNilHh3nYN76nT8q/LB7A3s5Qf9nQ8yZst1h/O41RRNfdO7MPj0/tSVGVg8a7WdwWuY8aAxULVzl1Wz285JttDJtvYAdUeO0bOY4/j2K8fbjNmUHvURkqJETeDUFk1GvcNkCOTL7ZUE4Uffog+NRXf++9vWua0jbhOnIC5tJTagwftar85azMmycSlofYbps8XiiBQsI9N/5UNkfu+a1//k1sBAWHjSc2v4PrP4jFbJBbcMAK9yULiFllt4hgRQUmVgWXJOUzp799MNdISV48I4pLe3ry+5iiFlfrWO7QRSZL4ZGs6oT46ZgwKJDrUi4l9/fh06wkq9S3vCpyHD0fl6krV9m1Wz28+eoYeHk70t5JGwlJbS9b996NydSXkk4/RRUdhLizEWFDQfCCPIIicAXv/J+/CGnHWc+hiSj5X/scfFH78CR5z5+I+a1aHxnIZOxZUKru9hzZkbKCHS4/Oq0m87R3I7ljeKlvYFARCCFchxH+EEClCiDIhxBkhRLwQ4vYuWYnChUtxupzqWKhgxwdgbkcQ10m5HrHFyYvbv5bTSv9wzyXMHtaT0b19yN9/GLW/P2pPTz7anEaVwcRj0/q2aQohBC9fNZhqg4lXVh9p+xpbIeFkMfuzSvnb+N6oVfJW//HpfSmpNrJo56mW16bR4DJmDJVx25olMDOYLGxPK2RSP3+rKoSaffsw5Z4m8Lln0QQG4jRATr2tt7UriL4NKvPh+Jomh896DtmVc8iK59GfjZqUFHKf+SfOI0YQ+MLzHVbPqD08cB42jModO1ptW2moZGfuTqaFTusctVDRCbmWd2rX1MFuaUfwHZAOzABeBD4AbgEmCyFe6ZLVKFyY7P5M1j/PelMuLZnya9v6G2sgazf0nkh6YSU5pTU8cWlfIvzlp9/bxoThV5hNZY9eZJdUs3hXBnOjgutVGW0hwt+Nu8f3ZllyDqcKq9rc3xZ6k5l31h/H20XLddENOZKGh3gyqZ8fX+84hcncNAVB4qli3ttwvP7/LuPHYcrPR5+a2qxdpd7EFBv2geqEPaBSobvkEgAc+8ulKWuP2BAEEdPBrSfsW9LsVKS/KydacyHd8QG8HioXDvqTYiopIfvBh1B7exG84ANU2s5J+ew8dAj6Y8dbtRNszd6K0WLsPLVQwudycsGYOzpnvHNoSRCESZL0jSRJ2ZIkvQPMkSQpFbgDmNslq1G48Kgtk6uBDZoL0XeCX3/Y/q6cPM5esvfIRWbCxpN4SvbDjglr0P1P7etDaGUB+xx8eHd9Kgj5Sbu9zI2S88onnLTiYtkOqg0m/rYokd0ni3lyRr9m6qobYntRWKkn7pwC8f9dfYT3NqRyKKcMANfx4wGo2tZUPbTpaAFatYqxET7W509MxGnAANSucnSw2s0NTXAwtUds7HrUDtB3hhxpfM7urZePjuySGtsG9TPHYNNL8t/3x1vlG9CfkKLPPsdUUEDwggU4+Nou5dlWHPv1R6qtxZDRcp6r9Rnr8Xf2Z6jf0I5Pqq+QVX2Drga3wI6PZ4WWBEGVEGIcgBBiDlAMIEmSBbiwTeAKncfe/8lG3tEPyKkMxj4GBSmQ2oZavKd2yGqlXpeQlFGCl05D70axAVJuDlqzkV0WD5btzea20aEEeTq3e8m9fV3x1GlIzOi4ICirMXLLlwnsSCvkjWuGcn1s8/TBk/v546XT8EtSTv2xlNwy9mbKAWdLEuSbhiYwEMe+famMayoINh8rYFRv74aCM42wGAzU7N9fX+TmLE4DBqC3JQhANsrry+VEfY0I9tJhMFs4Y82GYjHDigdB6wIP7paFyeonYONLbRP85xljQQEl33+Px+wrrKaX7ghO/WWvNv0x2/Ufqo3VbM/ZztTQqZ0TSbxvCRgqYNR9HR/LBi2t8j7gHSFECfAk8DCAEMIP+KjLVqRw4WAxw+6F0Gs09BwhHxtyLXiEyIYre8nYAYFDwMmDpIwSokO9muhNa+tUJblePXHVOvDApIgOLVulEkT38iIxo21RoAAms4XnVhzi6o93MO2drUx4YzMHskv58MYomzl/tA4qrhwexPrD+ZRVywba73Zn4uigYtoAf1bsy6WqzpjsMn4c1cnJmCtltVVmUTUnzlTZVAvVHjiApNeji21ayc1xQH8MGRn14zQjTN59yEb6BoK9ZAGbXVLdvM/uT+Xd22VvgFcozP8ORtwC296CuLesz3MBUvT5F0gmE74PPNDpY2sjIsDBgdqjx2y22ZazDb1Z3zmlKC0WSPgUgmIgOLrj49nApiCQJOmAJEmxkiR5SZI0TpKk43XHz0iS9EGXrUjhwuHYaijNhEvubzim1sCYh+WqWOl2JOEy6eWbS+g4iir1pBdWER3a1CX0rM78zpum8OZ1w/By6bg+NzrMi/QzVRRXtc3o+d6GVBbvysDRQUWkvyszBwXy7V2jmDWkR4v9ro0OxmC28PuBXCr1JlbszWH2sJ7cN7EPlXoTKw/kAuA6fgIYjVTvjgdgW5qsTprYt3k+JWhIX+0cFdXkeL3B+LiNG5KLLwQMaSYIQuoFwTluwDlJskoocgYMuU4+pnaAOQtg6PWw+WXY206PsW7EmJdH6Q8/4HH1VWhDm0dldxSVVotjeLhtQz0Qlx2Hh6MHUf5RNtvYzYlNUJQGo+7t+FgtcOHlQ1W4cDiwFFwDoN/lTY9H3SYbFDe8AHdvarncZE4SmGohbCxJGWftA15NmuhTU9GEhHDN2MhOW3pMnbBJyihh+sAAu/rsTCvkoy1pzIsJ5o1rh7VpvkE93ekX4MbPSdlIQJXBzE2jejE8xJNIf1eWJGQxf2QvdFEjUOl0VMZtw23qVBJOFuPn5mgzjUZ1wh4c+/bFwavpZ3ZWENQePoIuysYNJ3wC7PlCNtZrZAEQ5KkDIKu4WtY9Jy2SCwXlHQRnL7ji3aZ/TyFkYVCZB78/IuuoI6a26bPpTgoXLkQC/O6/v9W27cWxf3+q9+yxek6SJHbm7mR0j9GoVfa7Pttk90L5Nzjwqo6P1QJKHIGCdfSVsqvagDnyk2FjNBq+mKcAACAASURBVE4w+RnITYbDK1oe51Sdq12v0SRllqBRC4YENU0prU9NxbFv+43D1hga7IFGLey2ExRV6nls6T56+7rwwpy265WFEFwTHcS+rFI+2pTGoJ7uDA/xRAjBDbG92JdVyuHccoRWi270aCq3xWGqrCThZDGx4d5WXQwlo5Hqffua2QcAHAICUHt5UXu0FTuBWQ9ZCfWHnLVqfF0d5R3B74/Cun/J3iiXvQEPJcpxCM0m08K8b2VHgR9vhcK0Nn8+3YEhI4PSX5bhee01aIKsXEcn4dS/H6a8PMylzZMOHi85TmFNIWN6junYJLXlsOxeSFsPI++W/wZdiCIIFKyTulZ+kh9k40lk2A3gN0BWJ9iIK9ifVYrl1DbwHwQ6b5JOlTA4yKOJ143FYMBwKgPHyI7ZBc7FSaNmcJAHSadatxOYzBb+/tN+SmuMLLghyqrR1h6uGh6EWiXIK6/lplGh9Tf3uVFBaB1U9RXV3GfOwJR7mtRRl/Doqne58vAGavbtQzI0VWPVHj6MVF3dzD4AsuBxGtAfvS0XUoDQMXJqait2Av2ZdNkNeMzDcM9mWfXg0oJ3jZM73PijbPRf/cQFZzw2l5eTdf8DqHQ6fO/rOqMqyJ5DgFU7wc7cnQCM7jm6/RNkxsPCsXDwR5j4NIx7vP1j2UmrgkAIoRNCPCuE+Lzu/5FCiCu6fGUK55eU5eDiLxuKraFSw9TnZP3l3m+bnY5PL+Kaj7ZiOrUbwsaiN5k5kFNGTGhTFYfh5EkwmepTS3QmMaFeHMgpQ2+y7fNtNFt4bOk+thw7w3NXDGRgT/d2z+fv7sTEvn64OTpw5fCGxHqeOi2XD+nBr8k51BjMeMyeTa/FiyicdS2uhhpCfv6aU9ffwLHYUWTeeRe1x+TYg7PqB120dSOhY/8B6I8fRzIarZ7H0Q2CopvZcoK9nBlfuFQWEpc8aP8FegTBlH9D+mY4vNz+fl2MZDCQ/cijGLKyCF7wAZoA+1SB7cWpn7x7tWaf2Zm7kwjPCAJd2unmWZEHi2YDAu5cK++8z92RdwH27Ai+BvTA2TtCDvByl61I4fxjqJLVQgPnyDd8W/S7DEIugS2vgaGpF8p7G44zRJxEK9VyWDuEQznlGEyW5obi47KhuCsEQXSoNwaTpd6P/1z0JjMPfpfMygOn+ees/lZTPreV164Zwk/3j25WWnJejFxRbW2KXFHNJTaWlaPm8q/Ln6JPXBxB77+P57zrqD1+nFM33ED5mjVU70lEGx6Og591Q7LTgAFIRiP69JO2F9R7oqzCq234DCJcjcw0bkQacp1cx6AtxNwle4Ct+adsYzjPSJLE6RdfpDo+nh4v/QeX2NZLT3YUBz8/1D4+zXYENaYakvOTrauFClNlu9pvD8tqH1tk7ZZjbq75EkK6/lrOYo8g6CNJ0huAEUCSpGqUOIK/NsfXgqmmdQOVEPKuoDJPNjjWsetEEfHpxTw1oAiAf+xxJe647B0THdrcUIyDA45hYZ16CY3nSrSiHjKaLdz3bRLrDufz4pxB3DPBdunMtuDv5kT/wOa7ilHh3gR7OfNzUnb9sYRTxYwM80br74f7jEsJ/Oc/CV/2C079+pHz2ONU7thh1T5wFqcBZyOMm2cird67l+qkJNlgLFnkzK91TC5fgU7oKRraDk8UtQNc/g5U5MLW19vev5OpWLOGsl+W4fvA/Xhe1bUG1cY49evXzHMoMS8Rg8XQVBAUHIEFMfBhDKx/Vk4GuLmFxAw5ybLNJnBIF63cOvYIAoMQwhmQAIQQfZB3CAp/VQ6vkNVCoXYYvELHyG6Ke76q1xu/v/E4/m6OjBSHqfGI4HC5Ix9tTiPUR4efm2OT7vrUVBzDwxCdlAKgMX5ujoT56KzGE3y94ySbj53hpasGc9uYsE6f+1xUKsG10cHsOFFITmkNBeW1nCysapZdVePvT+iib/CcPx9MJrlerg204eEIZ2dq9u9vclwym8l++BEybrqZvMWbsOAkuwKbjWCsYUDWEjaZh3NS3Tw4zi5CYuX4gvhP5Ejk80jZb7/j0KMHvg891K3zOvbvjz4tDcnUYB/bmbsTR7Uj0QGNVHm7F0J5Lsx6Cx47JO+oEj6F3H3WB85JgsDBskNGN2KPIHgBWAOECCG+AzYCT3XlohTOI4ZqOWp4wOyW1UJnEULOf5J/EHKS6ncDD0wIRZ21G+fICdw2OgyTRWq2GzCXllKzbx+OkZ3rMdSY6FBvkjNKmiR6yy2t4b0NqUzt78/No9p5M2wH10QFI0mwLCmbhFOyN1OslTTbQqulx4sv0Gf9OtwutR2UJNRqXMePp2L9hia5b6oTkzAXFqIbNYqSJUs5ub4HtRu/h9fD4MvpaPXFfG6+3HpQmb1MexHUjuc10MxcUUHV9u24X3pph9JLtwen/v2QDAbZxlXHztydRAdE4+RQdxOXJFnFGjEFYu8GzxB5B63zgVX/JwdsNsZikQVEz06IP2gjrX56kiStQ84tdDuwBIiRJGlzF69L4XyRuhaM1TDwSvv7DJ0HWldI/Kp+N3CTtFIOi+97Gf+Y0Y/J/fy4ekSDS58kSZx+9jnMlZV433lnF1yIzMgwL4qqDKxNya8/9uLvKVgkiRfmDOrWgiEh3jpG9/bh5+RsdqcXo9OqGdSCcVob0nq9YvdZszAXFjbxa69Yuwbh5ETIJx/T6+uvsKg9yEqKRBo8D0wGzH2ms8sykOzidtaWAHDxgZF3wqGf5ey054HKLVuQjEbcZszo9rnP9RzKq8ojvSy9qVoo/xCU58hBemdx9oQZr8hP/udWkitKlX8zQV0XQWwLe7yGNkqSVCRJ0ipJklZKklQohNhoR7+vhBAFQohDNs5Pqktvva/u9Vx7LkChE8k/DKueAI9eENqG0nqObjDkOkwHfuFweiZPxajQbH0V+l8BkdNxcXTg6ztiGR/ZYPQs/flnKtavx/+xR3Ee3Nxvv9xQTpneupG3LcwcHEj/QDfu+18Sr685ytqUPNam5PPI1EhCvHUdHr+tXBsdTEZRNcuSs4kO9cJB3bEnWdeJE1DpdJSvWg3IaqHydetxnSAfdxk9msAXnsdUWEa5aho8lID6lp/xc3NqHl3cVkY/JOuzt7/bsXHaSfnatTgEBOA8vG3Bf52BY+9whEZTn3PorNtoE0FwfK38HnlOBtIh18m2m40vQlWjOts5SfL7hSQIhBBOQghvwFcI4SWE8K57hQH2RGt8A8xspc02SZKG173+Y++iFbqAvIOw6Ao5hcQty9rssrbNYzYOllr+2SOZq7NekSNZL3/HatSxPv0k+a+8im70JXjf0TytrsFs4LY/buORTY+0+3LO4qnTsvzBsVw/MoRPtpzgvv8lEenvyt/G9e7w2O3hsiGBuGjVVBnMxIbZV32tJVTOzrhOnUrFunVIBkO9Wsh9ZsNTqOukSWjDwij++ut6FVmwlzPZpR1QDYEcZRx1i5wUrSy79fadiLmyiqq4bbidB7UQyPUltBER9TuCDRkbCHQJJMKzUTxM6nroMRzcznFnFQJmvi57cu1vlCo8J1neWft2vgdda7T0Cd4LJAH9697PvlYAH7Y2sCRJcdRlLFW4wMk7JPsuOzjB7ava/EXckVbInWv1pDr0Y375V6iy98Blrzf7AZiKiyn+/nuy7r8PlVZLz9des/oj/urQV6SVpnGg8AB6c8f9Epw0al67Zijvzh9GuI8Lr10zBK3D+Yml1GkduHyo7LJpzT7QHtxnXYa5rIyqXbtktZCjI64TJ9afFyoV3rffRm1KCjV1uYtCvHQd3xEAjH0UkGDngo6P1QYqt25BMhiaCLzuxmnAAGoPHeJMVQE7c3dyRe8rGlR51cWQnSBncLVGwEAIHgn7vm8IzstJkpM7dkZqijbSUtK59yVJCgeekCSptyRJ4XWvYZIktSoI7GS0EGK/EOIPIYTNuH4hxD1CiEQhROKZM2dsNfvLYCoqIv/VV62XIuwKNv9XDi66fRX4tM2N8mRhFfcsTqS3rytB0x9EmA2yTnTo/Po2puJish9+mNTxE8j/z0uotFqC3nvXauDPybKTfHbgM3q49MBkMXG4yEqR9nZy9YhgNj0xqVksQ3dz/6QIbh0dStQ5xvP24jp2LCp3d8p+X9mgFnJpmrvI48orUXt6UvT1N4C8I8gtrcFsqy6BvXj2kv/WSYugspu+r0DFmrU4+PnhPGJEt815LrqYGMylpWzeugizZGZ279kNJ9M2ym6756qFGjPsBig4DKf3y8kZ8w5CUPcbisE+Y/ECIcRgIcQ8IcStZ1+dMHcyECpJ0jBgAWAzVFGSpM8kSYqRJCnGz0ZwzV+J4m+/pXjRYrLuuRdzZRcXGreY5XxA/S8H7/A2d39r7TEk4Js7R6KLvh4mPSMnKat7MtKnpXFq3nwq47bhc+cdhK9YQe/ff8dldPOIZUmSeCn+JZzUTiyYIj9hHjhzoEOXdyES7uvCf64cjKaD9oGzCK0Wt0unU75qlawWuqy5Rlbl7IzXjTdQuXkz+pMnCfbSYTRL5JfXdnwB4x6X4072/q99/df9GzbZH6NqqaqiMi4Ot+nTu0ctlHfQan4ll1FywFfmltUM9hlMb89G6sbUtaDzRa/3ovj775Eslmb9GTxX9rza971sWLYYz4t9AOwzFj+PfKNeAEwG3gDmdHRiSZLKJUmqrPv3akAjhOi8UkJ/UiSzmbLlK9CGhaFPSyP74YexGLqwfmzeAdCXNeSvbwOHcspYdfA0d40Lp4eHMzg4wqSn61VCldu2cer6G7Doawn9djH+f/97fXi+NZanLWdP3h4ej3mcft79CHINYv+Z/TbbKzTgcfnlIEnN1EKN8brxRoRGQ/GiRY3qEnSCesg3EoJj4dCytvctzYJdH7VJiFTGxSHp9bh1tVpIkiB+IXw6Eb66FEoympzWBAVBzwD8juYzJ6LRLdFihrQNVIkYTl1/A/n/eYkqa3WOnb3kB7CDP0LGLvnYeXAdBfviCK4FpgJ5kiTdAQwDPFru0jpCiEBRp1ATQsTWraWoo+P+2anaFY8pLw+/xx6lx8svUb0rntNPP2P9iaIzOLVdfg+zHbhkizfWHsNTp+HuCc0Nr4asLLLufwBNcDDhP/6I89CWS/ZJksSnBz5lqN9Qrom8BoBhfsPYX7C/WbF3heboYmNxCAjAdcrkZmqhszj4+uI2cwblf6whyEMO7OtQLEFjBl8jx5K0NcBszxeyCqXiNJSftqtL+R9rUPv62szB1CkYa2H5A7DmKegzWU6s+MNNcvqVRmRGuDMwU2Jmr0ZCKXsPJYf0ZH5zCE1gAGpfX0q++976PMNvhJoS2cbi4g8ewdbbdTH2CIKauvKUJiGEO1AAWC/V1AghxBJgF9BPCJEthLhLCHGfEOJsasBrgUNCiP3AB8D1kvKLp2zZL6g9PHCdMgXPq67C7/HHKV+9msq4uK6Z8OQ28IloNeeM3mTmaF55fa3b+PQi4o6f4f6JfXB30jRrX7p0KUgSIZ8uRNOj9Xw2h4sPk1OZw7WR19aX9xvmN4yCmgLyqvLacWEXF0KtJuzHpfT4T8vOdy5jxmApK8P3TBbQSTsCkOvpChUc+sX+PoZqSF4EXmHy/88pq2kNc2UllVu34j5zJkLdhUbVn26D/d/Lqs4bf4Jrv5JLtC5/oN64a7KY2Oibj2stOJ9q+I6WfvYGeXs8cYkdSej33+M17zoqt27FkG3Fs6r3ZHANlNO0BEW3XNujC7FHECQKITyBz5G9hpKRb/AtIknSDZIk9ZAkSSNJUrAkSV9KkrRQkqSFdec/lCRpUJ3x+RJJkna2NuZfHXNZGRUbNuI+ezaqupQL3rffhtBobBbC6NiEJsjcZVMtVFRTxKbMTeSW1jBv4S5mvreNSW9t4dOtJ3h9zVEC3B2tpmewGAyU/rIMtylT7M4EuTFjI2qhZnLI5Ppjw/xk/3BFPWQfmoAA1G5uLbZxGSmntDYnJxPg7th5OwK3AHlXeegX+1NUH/xRfhqe9bYsROwQBJWbNiHp9bjPmtXBBbeAoVp2/Rz9kKzqVKkgchpMe0HOurpdLtO6M3cn8T3lHULVbrnmg5S9l8LVB3EK9SLk8y9Qu7nJ6UJUKkqWLGk+l9oBhtU5VpwnQzHYZyx+QJKk0rob+HTgtjoVkUInU7ZqFZLBgOfcq+uPqRwdcRo8mJqk5M6fMG+/XODchlpowd4FPLr5Ua74eAUnzlTxjxn9CPRw4tU/jrI3s5RHpkY2qS1wloq1azGXlOB5/Xwro1pnQ+YGYgJj8HTyrD/W17svTmonRRB0IpqgIDQ9e1K9Zw/BXjqyOhJdfC6Dr5XTkp+24+8lSXKN5MAhcsUzvwF2CYLyVatx6Nmja4PI8g6AZG7+uxjzCAyaC5v+C1l7WHNyDRZfTzShoVTv3g2SRPn7j2GsdsD3sWcQDnIsjiYgALdp0yj7+RcstVaM81G3gc4XIqZ13TW1gl0mdyHEUCHEHCAKiBBCzO3aZV2clP2yDMcBA3AaOLDJcV10FDUpKda/RB2h3j7QfEegN+tZlb4GAEePYyx/cCwPTo7gx3tHs/axCbw6dwjzY6xrCEuW/IAmtJdVzyBrnCg9wcmyk0zr1fSHoFFpGOgz8C/pOXQ+0Y0cSXViIsGeTmR11o4A6vJTaexTD53aJrtOjrpPVocEjZDTZbewmzCXllK5Ywful13Wtd5CZyN8zzXcCgGz3wP3nrDsbhLz9hAbGIvLqFFUJyYiHVpO0bYctD29cZ3RtLyr1403Yi4ro3z1H83n8+kDT564sHcEQoivgK+Aa4DZdS+lME07+WbHSS7/YBt5ZU1v6rXHjlGbkoLn1Vc36+McFQVGI7WHrGbraD8nt4Fv3+aRj8CPKWupNVchJA2DInKI8HetP9cv0I0bYntZTY9Qe+w4NcnJeM2/3u4f64aMDQBM6TWl2blh/sM4XHy4UwLLFGR0sSMxl5Qw2FRMTmkNVXrrFebaPrC3/HSf8qucQO1cik7I8QZr/wUr/09Ovjb4WvlczxFQXQRlWTaHL1+/HkymrlULgSwIPEKs/i5w8oCrP+V0eRanq/OIDohGFxuLpbKSojf/jb5Ug8/9jzX77utiR+IYGUHx/77FkJGBpaqq+djnEXt+qZfU+fDfJknSHXWvrssS9hfmUE4ZL686QkpuObd/nUB5bUNlqcKFCxE6He6zm8vYs0Ez1cmtb53tpgX7QK3RzAcJS8HkzlUR15BckEiV0b4vbskPSxBaLR5X258bfmPmRob7Dcdf59/s3DDfYZgsJo4UNa/Nu+ToEu5bfx/mc7M4KrSIrs5OMKjgBJIER/NaKJTSVgZfI9/Ms3Y3PV50AhaOh98fkT2FHJzk1Mxn0y2fffrOsa0CLV+9Gm1oaLMdc6eTk9Ty03nYWJKHyUkZo7IOoqvdAsCZPWYcvD1wv7J5wkYhBF633IL+8BFOzJjJsegYDsdeQlX6qS64gLZjjyDYJYTo4k/+r0+t0czjS/fh46plwQ0jSCuo5L5vkzCYLNQcPETFH2vwuf02HLyaR5s6eHmh7d2bmqSkDq0h7vgZXl9zlLfXHeOH334HQ6VV+8DzK3dT43CIycEzmB1xKUaLkfjceKtjShYLFRs3UvT1N+S/9jrlK37D/bLLrF6HNbIrsjlSfIRpodb1o8P8rRuMN2Zu5NXdr7IjdwfJBV1gP/kLowkJwSEgAP+TKQCk5HaiIOg3C5y95Rt+TV0dCLMRfvmbnMfq/p3wz9Nw/3Y5oOosAYNktZINO4HpzBmqdyfgfvmsrs0YW1UIJadaDeza6xuKiwR9d36C5vDXaL3VIAm87rir3tHjXDyvu47Q/31Lz9dfI332zYjyMl574Uu+2JbeebuydmKPIFiMLAyOCSEOCCEOCiEUpW0beXPtMVILKnnz2mHMHtaTN64dys4TRTz50z4K3n4LtZdXi+mYddFRVO/b1+54Ar3JzGNL97Fw6wkWbErjVKKs/y/wHUmVsYoak2w0XJuSx7LjqxHCwoMj5zPcfzhuGje2Zm+1Om7Vtm1kP/gQBa+/TskPP6AJCcHnnrvtXtfGTDmR7dReU62e93X2Jcg1iIS8BEwW+cdytPgoz2x7hoE+A3FUO9aPoWAfQgh0I0di2ZeMt05DSo59gkCyWDDm5bUc1+HoCvP/J99Ml94ip07Y8pqs/5/9Xt0N38ptx8FRPpfbXKhLkkTx4sVgsXSDWqhu/lYEQdKZfQwPjEV992b4Zw6us29G5e6O13zbDhJCCHQxMWRET+RRzQhKPPwYUZzOy6uOMO71TZw408VZBFrAHkHwJXALcibRs/aB2S32UGjCrhNFfLn9JLeODmVCXzlFxtyoYP5vel8y12+hOn43vvfdi9rV1eYYzlHRWMrKMJw40a41bDhcQHGVga9vH8mp1y4nuk86twaEcPm6W7jk+0uY+tNUlh5ZwTPLDuLue4AIz0j6efdDo9IwLmgccdlxWKTmQqhyxw6EoyORO7bTb28yvVcsx7GP/fmKNmZuZID3AILdbAfSjA8aT1x2HNN/ns4be97goY0P4a51Z8GUBYzpOYYNGRuUoLM2ohs5EnNhEeOdqzmU23K6b2NODmcWfEjatGmkTZpMziOPYiostN0hbCxc+bFsEP7fNbK75fCb5ViDlgiKgtz9TewLksFA3nPPUfT5F7jPmoVjREQLA3QCOUmyK2uP4TablOnLSCtNY0SPWHnNDo74Pf4YvVf+jtrddn0JgGqDicd+2Ie/myM9J45l8JkT/HLvKMprTSzfm9PZV2M39giCM5Ik/SZJ0klJkjLOvrp8ZX8hlu7JxNdVyzOXDWhy/L4J4dx7bA3Frj64z7++xTF0UXV2gna6kf6wJ5OeHk5yTQCTgUWmLI47O1BRGsK8PnfT26M3Lyf8m1rvzzE4nGROnwZZPyFkAkW1RaQUpjQbt3pXPLroKBx8fNq1ZU8tSWWEf8uJw54c+STvTnqXIb5DWHJ0CeWGcj6c+iF+Oj+mhU4jvzqflKLma1OwzVk7wajyDI7nV2AwNdx8LXo9xYsWkfP3JzgxYyZpU6dR+PHHOIaF433nnVRu2UL6FbMpW7nK9gRDr4Mp/5aFgWcoXPaazaZVepOsGuk5Qk53UiJX/TKVlJB5198o/elnfO69l55vvdk5F98SOUng11/e2dhgX4FcZjIqoMGOoHJyQuPf3MZ1Li+tPMLJoirenjcczzGjMJeVMchQxIgQT7YeP38JNe1JOr9XCPE98DuNahVLktSOxCIXJyfOVDGghzvO2qY+9zXr1tKrKIs3o26g8GghVw63XeZB06sXal9favYm49UG/3yArOJqtqcV8siUSNQqgZSVRJpGzSy/aH7Lvp79B124afTVJKS8i7P/JiQEs8IbtuDjg8ajEiq2ZG9hiF9DUW1TYSH61FTcZ7dvg1hpqKTSWEmgS2CL7TRqDdNCpzEtdBqltaXUmmvr+0wMnoiDcGBDxgYG+w5u1zouRrThYah9fYnITcXoF0FqQQWDesqZYwo/+YSihZ/K/vqDBuFx7TV4zJol59YBPOdeTe6//kXuE09gqarCa/4865OMfwJcA6DXaLl4kRWSM0u479sknLVqfp07CG+Q1TM+fch77nlq9u+n55tv4NHO71ibkCRZEPRvWf2UXJCMg8qBIb5tKzCfeKqYJQmZ3DuxN6P7+GB0koVx9e4EJva9hLfXH6ewUo+vq2MrI3U+9uwInJEFwKUo7qNtRpIk0s9U0sev6ROGZDJRuOBDtBER5I2cyNvrjjd5KjsXIQS6qKh27Qh+SpRd8uaNlP3+T6etoUqlon+v8TxxaT8SM0p46qdDDNBdw/ezvuf9ye8T4NLgOufh6MFwv+HEZTdNc1EVL3uGuIy+pM1rAiioltMWtyYIGuPp5NmkvYejByMDR7IhU1EPtQXZThCD29H9qCRLvZ1AkiTKV67CZexYIjdtInjBAnzvvrteCAA4RkQQ9v33uIwZQ/5rr6FvVLf3nEkg6lab9S1+TMzi+k/j0TqoKCjXc+vvFUgOTpC7F336SSo2bMD7rju7RwiAbNeoKYagmBabJecnM8hnUENtYjuJT5dTqT00WVZvaYKC0AQHU70ngYn9ZJXx9tQWVG5diD2RxXdYeSnuo3aSX66nymCmj39TQVC2ciWGU6fwe+Rh/nHZADKLq1maaNuHGsA5agTG7GyM+fbnfTdbJH5MzGZCpB9BnnLGybSsbQBEBgzjupgQBvRwBwFvXzeMQX4DmdxrcrNxJoZM5GjxUQprGr6oVfG7ULm7t9ud72wOoQCdfWkobDEtdBoZ5RmcKG2f/eRixX3GTCgqZFzRcVLq7AS1+/djzM7G/YqWn/WEWk2PV19BaLXkPvU0ktHYrI0kSfy4J4u0gkoskoVFKYvq1SqvrznKkz8fIDbcm5UPj2PhLdEcLagmVYRjyUmi+OuvERoN3jff3PkXbgs7SkXWmmo5VHSoiVrIXo7mVRDi7Yxbo9xcuthYqhP2MCjQDW8XLVuOdV9Nh8a0VKryybr3BUKID859dd8S/9yc9QTo49uQEVIyGin86GMcBw7Abfp0JvXzY2SYFx9sTOVMhe3AqbPZFtuSdyju+Bnyymu5vm43gLGW1FK52Hgfzz6oVYLFd8ay/IGxTYLGzmW4n2w8a1wopnpXPLrYke1O/pVfLReUb7z7aA+TQyYjEGzI3NChcS423KZOwcHPj2uy4utdSMtWrZbrG0xvPd2BJiCAHi++QO2BAxQu/LTZ+R8Ts3jylwPc8mU8/9nxKm8lvsVH+z5i+d4cPtlyghtiQ/jmjpF46rRM7OvH2/OGsbMmhKrUAxQvX47LlVfi4OPT6ddtk5xkcHAG/wE2mxwqPITJYiLKv32CoH9gU2OyLnYk5rIyjCfSmBDpS1xqYX1ix+6kpR3B2QieRJqWqjz7UrCD9LOCMLCWkgAAIABJREFUoNFNtnT5coxZWfg9/DBCCIQQ/PvygVTUGrl24U4yi6yH/TsNHIiDvz/lf1gJU7fBkoRMfFy0TB1Qd7PNTiBNoyJA64G7Vv5S+rk5MrBny94O/b37IxD1RllDVhbGnBxcLrEvjYQ18qrlHYG/c+tGtpbw0/kx3H+44kbaRoRGg+e8efTNOERRajpmg5HyP/7AddKkFj3YGuM+cyYeV86hcOFCag40eJUfy6vg+d9SGBrsQanjKn458QM+Tj4k5yfzz+XJxIZ589KVg5tEp185PIhBUWOpOa4Go5HbKyN5Z10b01p3hJwk6DFMjnewwdmYldYcHM6l1mjmZGEVAwKb2krOJgGs3i2rh4qrDK16cXUFLZWq/L3un9WSJC1q/AI6MUHJX5sTZ6pw0arxd5MNQBaDgcJPPsFp2FBcJ02qbzfMdID48C/4oOofSAui0b87Aspzm4wl1GrcZ82iMi4Oc1nrX5bU/ArWH8nn+tiQhhq9J7eRqtUQ6WP7qccaOo2OMI+w+gjfqp1yAtr22gcA8qvy8XHyQdPCD89epodO52jxUY4WH+3wWBcTnvPmIalUTDm+nfSNcZgLC8mIDeHNPW9SbrAvviDg3//GwceHvBdeRDKbqTaYeOj7ZFwcHZg++ggOPhswlMbQV30HBosBR5csPrhhhNUUJVFDR1GS6oJqeD/ChvXng01p9WqrLuXoKrnGcGjLDzZ7C/YS4RmBh2PbSrKkFVRitkj0O2dH0NhOMCHSDyFg67Hu9x6yx1j8jJ3HFKxw4kwlffxd610ry5b9iin3NH4PPyIfM9bKuVcWzcaz9AiRwT3IUAXjWJZO8b7fm43nfsUVYDRSvm5dq3N/uDkNZ42au8Y1FI4xndxKukZLpHfbBAHAQJ+B9aqhqvhdOPj7o+3dvCiNveRX53dYLXSWKyOuxEXjwpcHv+yU8S4WNAH+MG4Sl2bsIXPJF+gdVTxc+w2LDy/mltW3kFXRYLc6eOYgHyR/0CzdiNrNjYCnn6L28GFKli7lhd9SSC8/SsjAr/ns0AdMD53O3JDH+P/2zjs8qjLtw/c7M+m9kgoJEEISegu9KCICglJsiKCsXdd11V1dV9ey6vq5u66ubrGjsioCCogICkpvoQdCD6mk917m/f44k5CQSTIJCQOZ976uucicOXPmOTlhnvM+5fds2O+KlILJQ4sJ8DCfaC3cegxjtY6wyd35+62DcHUw8N/NZzv1d0DSDlh+j1a+Ov6pZneTUnIs9xgxPs2OV2+W4xnFAPQNbFo95Tx8OGV79uLtbEf/YI9my0hrcnI6rSCipRzBDUKIfwLBF+UHPgGs2w99FXE2u7S+YkhKSf4XX+AYHY3LmNGQfRLenwQ734Hhv4JH4nD+1RrCHvqWLOnJ+YNNY96OMdHYh4dT1FINN5oDWnMonQUje+DtYmp5rywhOfMQ1QJ6e7W9MSfKO4rMskxySrMp27Ubl1EjL6ndP7Ms85ITxXW427tzS+QtbEjaQHJRcocc01YIXnQn7tVlBO05yKFoJ56f+Gfeu+49cspzmL92PqvPrOaRjY9wx/d38P6R93nv8HtNjuF2ww04jxpJ1pv/4JdTf8M5/F3yq9P406g/8cb4N3hhZj+m9wsn0DGC85VHmrWlYPVanAIMODmm4eFkxx2x3fnucHqz4dJLJvMofHGbJjJ3x9dgb366G0B2eTZ5FXlEtXE1DXD8fBEOBh1hPk2P7zxiBLWFhVSePMmEPn7sT86nsKxx8l0ajZy5fipZf2m+H+NSaGlFkI6WH6igcW5gNdDJw0K7BmVVNaQVlNPTlCiuOHKEyhMn8LzlFkRqnDYHtTQb5i+H6X8De2cAuvu6kOQ2GL+8vVRUNfa5QgjcZ0ynbM8eqjMzzX9wdTmbVn3Gq3Yf8bvjt8CSmZpGfMouThm0L+4IT/MlfS0R7aNVB53a9xO1+fk4X0J+ALTQUEc5AoC7ou/CIAx8fPTjDjumLZAS4UqqKSc764E3uKn3TYwKGsXSaUtxd3Dn2W3PciDrAL8e/Gumhk3l82Ofc76k8VhJIQQBzz1HTVkpi/bHcW3QbL67+Tvm9pmLXqfHwaDn3TuGcGOfCcTnxFNS1VROoTo9ncqEBNwGd4fzWr5h8dhwDDod72/twFVBfpImfLfsLvhoKtg5w4KV4NJyYrou7BjVjtX0icxi+nRzQ69reuPkPFRLPJcfOsyEPn4YJby39Uyju//q1FSMpaXYt6Frvy20lCM4ZMoH9G6QG1gNnJZS5neKNV2JuI+pXP4gbpTVJ4oLvv4a4eSEe18nWHKjNrx68Y8QcV2Tt3vHXIs/+Wze2VjsraK6tn5QedHa7y+8UJwB+z6B/92G8fUw7k19mpsNO9AH9oPMeG0A99onOe3giE7oCPcIb/Mp1f0HyP9lEwAuo9vvCMqqyyiqKuqw0BBoukQ39b6JVadXkV1mvS7Nq4nK2kr+uP05vh3nxtFuPXEffUGEMMwjjKXTlvLnMX9m/Zz13DvgXp4Y9gRCCN4+0LRw8JxnNWtGCCYdkfzRfQZu9k3DILGBsdTKWvZlNq03Kf75ZwBcJ4yB0iwozqCbuyM3Dw5mWVwKOSUdIEWelwjvxsLaJyA1DvrOgIVrwLN7q289lnsMgSDSO7LNH5twvpjIAPNNdXYhIehcXalIOMaQ7l7MGhTEuz+f4YmvD1FZoynrVhzTcnOOUZ2j/2lJjuBHIYS7EMIbbUzl+0KINzvFmq5CbTX8/ApeJ5fxrf1z9LXLpLaklMLv1uI+KAj9qkXgFwn3bABv81/IPYdPBeDM3h/qt/18IosBL25geaYOx/79KfruO02tcfli+Hs0rHkMso6y3X0699Q+Q+Gjx+H2L+DR/TDqYShM4bRHN7q7dW9zMwyAq70rPdx74Lj7KA7RURaPoTRHXTNZR64IABbFLKJW1vLZsc869LhdlX8d/BdnCs8QcN3TPDnqIZILqxq97uHgwazes3C1125mAlwCWBC9gO/OftdI1qOytpKntz7N6tEeFDu6UPH5p2Y/b5D/IBz0Duw631TNtmTjJuzDw3EYNEHbkKGFkO6b0JOqWiOfbD9n+YklboF/jWo6LW33f8FYAw9sg8ePws3/brbh7WISchPo4d4DF7vmw0fmyCmpJKekkr7NOAKh0+HYty8VCQnodIJ/3DqIxyf3YeX+NOa/v5v80ioqjieAXo9Dn7av5C3BEkfgIaUsAmYDn0opYwHzUpEKjTOboDSbvcF34SlKCP9mBkWvzkeWl+PpsguiZ8Ki78DVr9lDCJ/elNn7EVIYR3xaIScyinn0fweoqjHy2roEdNdeS8WxY1T+dTKcXA8jH4QHd7J+8gYWpM+h18iZ+HuZKhucPOH6V+Cxw5xy86a3Z29kTU27Jp4Ntu9Nt7P5uDWoeGoPdaWjbekqtoRQ91CuD7uer058xf5MJU/dEgeyDvDJ0U+YEzGHW/tpq9K95/Jafd/ifovxdvTmr3v/SnZZNinFKby5701OF5zGWHI7p4dMovjnn6nOatoc5aB3YJD/IHZnNJ5XUFtcTOnevbheMwkCTFIhpi/xXn6uXB8dwHtbz/La9wkUlFVdfNjGpB+EL+7QJqCtf/bC1LOKQjjwmSZ/HdC/zYPij+cdb19YyJQojgpsvkTbITqKyhMnkbW1CCF4bHIE79wxmEOpBby18RSVCcdx6NkTnUPnyE9Y4ggMQohA4Bbgu06xoqtx6Atw8uZz5zt5wOlvCK9wCn6Jx6GbC07Pb4N5nzSrvVKPEBh6jWOULoF3Np5i8ZK9ONvr+d+vYqmsNrK1LAeEpLB2Evz2KFz/CqcI5bfLDjEwxIMnpjRdvla4+JBckkaERy+SFi4iaf6dba5CGJFkQCdBjmpZprc1Mku1/EaAc8c6AoBHBj2Cl6MXC39YyCu7XrF4qE5XRUrZRDl2e9p2HvjxAQJdAnly2JP09nPFw8mOuHOtR31d7V15cOCDxGXGcc3X1zBt5TSWJixlVs85ZGaGUz31RqipoXDlN2bfHxsQy6n8U+SW59ZvK922DaqrcbvmGm0KmFeYNjvYxMs39WNG/0De23qWca//zAfN5Qxyz2iKp05eMPa3mujdaVN/yf5PtRkcIx9q9Rzrf0+nc7jhra3c/uFG0kvT25UoTjivleE2FxoCLeQjKyqoaiDXMWNAENP6B7JifyrlCQk4RPVt82dbiiWO4CVgPXBGSrlXCNETONVpFl3tlBfA8e+h/1xO5VTh0i2cinH/piLPDs/Fv0b4W34x7XtPwE8UcDLhANnFlbx/1zBG9/bl/gk9Cc9fi1OwoPBgDtLOlcLyau4ziXf9Z8FQs0PlzxaeRSIZvCmV8n37qDh6lNLtO9p0ej2OZFPgAqcDNQeyN2Mvk5ZN4mxB25J5dV3F/i6X1kxmju7u3Vk5cyV3Rt3JVye+Ys7qORRUFHT451wtPL/jeSZ+NZE3971JanEqK06u4OGNDxPqFsqSqUtwtXdFpxMM6+FFXFLrKwKAuX3m8uLoF3lu5HP8ecyfeXvS20zp9gAAvQZH4zxyJAVff212fkZsYCwAezL21G8r3vQzei8vnAaZ5J8DBtSHhgDyqs8RFbWXFQ8NZlB3T/68NoGTmcWND1yaA5/dBEhY8A1MfEZTPv3pBaip0sJCPcZCUPMS03Wk5pfx4Of7mP/BborKq9mfoY2J9bVve7n0iYxifF0dWhSTq5NpqUhoPIlvfmwPdIX51GZldVp+ACzTGvpaSjlASvmg6flZKeWcTrPoaufYKqitxNj/Ns7maGJzBSu/1cY3zpzZtmOZxkhOcT7F328ZxMBQTwAeGSgYoz/KgV4x1GRm8s37K7nnk72k5JXxr/lDCfRwMnu40wWnCcyVeH5m6h718yXv0yUWmyOrq7GPO8b+XoJj+ccpqiriD9v+QE55DptSNrXp1DJLM/Fy8MJB3zlLXWc7Z34/4ve8Nekt0krSmoQibImDWQcxomn9TFs5jRd2vsDIoJEsuWFJo2T9sDBvzmSXkmtBUtagMzA7Yja3RN7CrN6zmNR9EgnntZVXTJA7XrfMozotzeyNRrRPNK52rmxN1TSvZHU1JZs34zpx4gW5ksABkHcWKoqQUvL8jud5+8DbPL7jdqbEpqATRr471LjhkoNLoSAZ7lgGvr3BYA/XPAeZR2DFYm2E5qjWVwOF5dXM/tcOfjmRzZNT+rDxiQncNlaz66UVBcSdy2vTSlqTlmg5AuDQMxxhb1+fFK5jeJgX44W2SnO05opACNFHCLFRCBFvej5ACPHHTrPoaufQl+Dbh3SXvlRUG+nt5UDR2rW4Tb4Wvadn247l3RPcAvl9VA7TBwTWb3Y49ClGYeB1jxsptHche9lyzmaX8Nrs/owI9272cKdyT/DQ9xKdgyMBL72I1+23U7plK5VnLbubL9u3H1lcwrn+viTkJvDq7lfJLsvGx9GHPef3tH6ABnRkM1lLjA4ejUEYOJF3GaUKriBqjDWkFqcyN2IuP8z5gfsH3s99A+7jnWveaZL0HBamjRfdl9S+osCj6UUEezrh5WKP2+TJ6L29KVj2VZP9DDoDM3rO4PvE7zlTcIayffsxFhVp+YE6ArQRpWTGszVtK8dyj3F3v7sJcQvh//a9iF+fT1hzOLnxF3LCGm2gTEgD9dB+c7R8QMJq7f9Tn6mtnsdf1iWQW1rFV/eP5JFrInC001NOMn6OAdjhytz/7OTav2/m7z+ebLW/odYoOZnZuiMQdnY49OnTZEUghGCGs7bySfQIatX29mJJaOh9tE7iagAp5WGg5SkqtkpeIiTvgIG3cTZH+wOJSDxMbUEBHmYGWreKEBA2FpG49ULCq7oCDixF13car91zA/ZTpzE+O4G9jwxn3rDQFg/nvGozkalGuv3hGez8/fG69VaEvT15n1lWYVPyyy8IOzt0wwfzS8ovrD27lvsH3M8N4TdwIOsAVbWtJPEa0JHNZC3hoHcgzCPMZqUnzpeep0bW0MO9BwEuATw86GEeHfwoBl3TUST9gz2w1+uIa6cjiE8vJMakWSXs7fG4+SaKN/1MVVIS1RkZVJ45U69S+uCgB3E2OPO3uL9RvHEjwt4e19GjLxwsQNP6l+mH+PfBfxPsGsyjgx/lsxs+49nYZynTnSTN+CPHTPF3itIhdS9EXSRZrdPB5Be1n0c+BLqWBRJ3nc3liz0p/GpsOANCLty4JeQl0N8vmnWPjeeVm/vRzc2Rf246xfS3t7YogXEut5TKGiN9W0gU1+EYFUVFQkKT1UZk8XmynL1YmtB5UhuWOAJnKeXFt3uqs9gch5cBAvrfUq866rXtJ/Q+PriMGdO+Y4aN02qqE9ZoziBhjaaZPuxuJvX1J/qeOzTJibUtdxpXVVcyYMNZMqO61Tslg48P7jfOoPDbVdQWtB5DL/nlF5xjY4kI7k+VsYoBvgO4d8C9jAgYQUVtRZMB8y3R0c1kLdHXuy8n8m1zRVDXZR3q1vJNAoCjnZ4BIR4WVQ5dTGllDYk5pfQLvqDB4zVvHtTWalPOJk7i7PQZnLv1Nmpyc/F29Oa+AfdRsWkzeUuX4nrtNehcGqxQ3ALAxY9tqVuIz43n3v73YqezQyd03Nb3NkYFjsPedxNfHzDdQSeY6liizdxw9b4WHtwJwxa3eA4V1bU8s/II3b2d+c3kPhfOrbqUpKIkonyi8HC2Y35sD764bySbn5yEq6OBRR/vbXZlUJcobm1FAOAYHYWxsJCa9MYhr9pTJynv0YtVB9Mormgq990RWOIIcoQQvQAJIISYC5xv+S02yukfIXQEeIZyJruEIFFJ1fYteMyYgTBYMgzODJE3gEd3WLYAPpwC297UKirCJwLg2LcvjjExFKxseWBc/LZv8S6W2E+f0kgWwvuuu5Dl5RQsX97i+ysTE6k6dw7XSROZEDKBGJ8YXh33KgadgaEBQ9EJXaPkX4vHqq0kvzL/soSGQHMEWWVZ5FfYXh9kUpE2VbaHew+L9h8W5k18WiHlVbVt+pyE80VISf2KAMA+LIygN97A/6knCXjpRbo9+yyVZ8+SNP9OqtPSmJUZzOOrjKSE2OP/4guNDygEslt//lOSQJBLEDN7Nc6vPRP7FEJXw5rkj7Q76ITV2ojJ5noCukVrq4MW+OemUyTmlPLqzf0bTRM8kXcCiazvrK+ju48zny0eQXWtkbs+2m224W3D0UzcHQ1EdGtdzdUxSqtIahgeMpaVUZWYSMiwgZRV1fLtwfTm3n5JWOIIHgb+C/QVQqQBvwEe6BRrrmak1LSDTEvak5klzMo/BtU1eNx8U/uP6+oPj8bB9L9D8XnIOgpD7270R+0xZzaVCQlUHDvW7GEyvl9FjQ5iZt3VaLtjZCTOI0eSt/R/yNrm//MXrloFgNvEiUR4RfDljC/rv1zc7d2J9o62OE9QVzp6uVYEfby0u7vLvSowSiNl1dYV6k0pTsHJ4ISvk69F+w8P86K6VnIotW1VVvFpWtii4YoAwOPGGfgsXozXLbfgveBOun/4ATW5uZy77XYyf/MExp6hPD+nmlUZTUUUd/gEclhXy69iFjZRqA33CCfW90YqnXax9uBPkLS9aVioDRRXVPP+1kRuHhzM2IjGv6uEPO2Lua9302Rtb383Plw4nIyiChYviaO2wSyB/NIqfojP4ObBwTgYWp/Z4RAZCTpdo4Rx5cmTICXdYwcxrX8Arg7tm/3RGpZUDZ2VUk4G/IC+Usqxani9GUqytMHbvn2QUnIio5hRZ/bgEBmJY9/Ws/3pJel8efxLao1mvowNDjB8sdYhvOAbrUu4AR7TpyMcHMj/smliDrQ6cvedR0np7Y6HX0iT171uv52a8+cp2brV7PtrCwrI/+xz3K6/vtHIwobEBsZyOPuwRV98HTWQxlLqJAEud8L45V0vM+ObGeav6WUiqSiJ7m7dLRYHHNpDSxjHtTE8FJ9ehK+rQ73cenM4Dx1Kj88/QyKxj+hNzKdfEdVjGH/d+1dO5p+s3y+nPIcXig4TXF3DTU7m5R9eGPs4GJ1479BfkNIIUW2symvAxoQsqmqM3Dmy6Wcl5Cbg4+iDn5P5BtChPbx49eb+HEop4LvDF+7YVx5Io6rWyG0jWpevANA5OWEfHt5oRVD3s1NUFP+aP5SbBzf9/9sRWLIiAEBKWSqlLG59Txslx/Ql49uHjKIKXLPS8Es5ZVGS+FT+Ke78/k5e2f2KWQ2Wegz20OuaJoMz9B4eeMyaReG331KTm9vkbdlH9+OTU0X1OPNNYG7XTELv60vBV8vMvp67ZAnG0lJ8H2q+9G5E4AhqZE394I6WqBtR2RnNZObwdvTG38n/siaMd6bvZPnJ5WSXZ3O64PRl+9yLSS5Opru7ZV9EAJ7O9vTp5trmhHF8mpYotsThOEZG0nv9esK/+gqDlxf/N/7/cLVz5dGNj5JbnktlbSWP/fwYhbWV/D0rG7v0g2aPE+LpTbhuLokii1cDuyO79WuTzQ1Ze+Q8gR6ODA71avLa0dyjRPlEtXhuNw0KJrKbG2/9dIqaWiNSSr7am8zAUM8WO4ovpi5hXEdFwnF0Hh4YgjqvYgja4AgUrZBjupvx7cPx88VMTolD6nS4z5je4tsOZR9i0Q+LAK2sblv6tnZ9vPeiRcjqavKX/q/Ja6dXfY4R6DnDfLGXsLPDc/ZsSjZvpjojo9FrtQUF5H/6GW7XX49jZB+z7wdtYpOdzs6i8FB9M5lzxzeTNUekd+RlCw2VVZfx4s4X6+8g25JE70hqjDWkFafR3c1yRwAwtIc3+87lNwpztERFdS2ns0roF2z5F57O2Rlhp93Q+Dv78/Y1b5NXkcdvfv4Nz217jsPZh3l13GtEOwVCWlyzx7m7zzTmFxTzpSO8Hvd/7dLrL66oZvOJbG7oF4juInXQ/Ip8ThecZmi3ljvpdTrB49f14WxOKd8cSGN/cgEnM0sujIi1EMeoKGoyMqjJ1xxxRUICjn37XpLcuyUoR9BRZJ8Ee1dwD+L06TRuPLsDp4mTsPM3/2V3tvAs/z70b+7dcC8eDh58esOnDPEfwra09jkCh57huF5zDfn/+x/G8vJGrxk37+JsiIHoyOYrlzxvmQdSUrB8RaPtlqwGAJwMTgz0G2hWTOxiMkszcbd3x9nOudV9O4q+3n1JLEiksrYDFCxb4Z8H/klaSRpvTHgDH0cfqzmC8yUXSkfbwrAeXhRX1nA6q6lUtDl2ns2lxigZ0r3p3bSlxPjG8Oexf+Zg9kHWnVvHY0MeY3KPyRAyFFKbXyWPFYf4fX4+451HszRhKW/EvdFmZ/BTQiZVtcZGvTp11OlVteYIAK6P6Ua/YHfe3nSKz3cl4Wyv58aBbbuTd4zWEsZpj/+WpLvv1hxBVNtlLdqKJQ1lh4UQfzBVDimaI+ekVrEgBK4rl+JUU0nQ44812e1w9mHmrJ7DrG9n8a+D/2Kg30A+veFTQtxCGBs8llP5p+pDJ23F5567qS0ooOCbCxovlamp+CQXkBvbG30LNdT2ISG4jBlDwfLl9UljS1cDdYwIHMHxvOMUVrZc73y5mska0se7DzWyhjMFZzr1cw5lH2JpwlJujbyVod2GMtBvIAezzIc2OpvkYq10tC2hIYBB3bX6+YMploWH1hxMx93R0CTJ2lauD7ue50Y+xwMDH2BxP1OpZ/AwKEzWcnBm8MvbTxmOOBvv4/a+t/PZsc+Iy2x+BQGQV9G4M3jt4QxTWKhpw2dcZhwOegf6+bQedhJC8MR1kaTklfPNgTRmDgzC1aFt1YKO/QfgEBVFTWYmsqIS1/HjL63YxEIsWRHciNY3sEwIsVcI8aQQom1/WbZAzknwjaQ6I4OY3es51m8MDhFNS9le3/s6+RX5PD3iaX6a+xPvT3m/vqJjbLCmBb8jvW36P3U4DRmC48AB5H2ypP7LPHHNlwD4XD+t1fd73jKPmowMSrZsoWTLFpLuWmjRaqCO2IBYJLLVMtLL1UzWkL5eWsK+sxPGHx75EG9Hb34z5DeAJrucXJzcSGDtclFXOtrW0FC4jwvujgYOprReOVReVcv6oxlM6x9oUWVMa9wSeQsPD3r4Qiikrks41fyXu0jdQ5JjFAfSSnh86OM4G5xZc6bpiNc6UopTuO7r63h196sAFFVUs+VkNtP6Nw0LAezL3MdAv4EWz9WeGOnHEJMjvbWNYSEAvasLPb9ZSa913xP2xf8I/de7OEa2ff5BW7GkaihJSvl/UsqhwB3AACCxlbfZFpXFUJQGvhFkvvMuGCUZNy9ostuR7CMczj7M4v6LmR81v8ldcW/P3vg7+7c7PCSEwOeexVQnJ5P62GMk338/VR/9j3P+MHxo66V1bpMmoffzJf2JJ0m5736MFRWEvPNPi1YDAP39+uNi58L2tO0t7pdRmnHZHUGoWyhOBqdOzRNU1Vax6/wuJveYXK/fP8hfEzhrLjyUWpzKY5sea3UV1R6Si5PbVDpah04nGBjqyYHk1h3BxuOZlFbVMnNQJyUzAweCzmA+T1BVChnxlPoN5nRWCVXVBib3mMyPST82GwJcdXoVVcYqvjzxJesS1/HTsebDQsVVxZzIP2FRWKgOIQSvzR7A76f2ZZCZFcaVikU5AiFEDyHE74Avgb7A7zrVqquNXK0qpLLKi+KV37A2fBQ9+jWdCfx5wue42rlyU2/zSz0hBOOCx7EzfSfVxvZ1ELpNvhbHAQMoP3CQmuxsErvb8/P0YIt0/4WdHT6LFqFzcaHbs8/S67s1uE2ebPFn2+nsGBk4ku3p25uN06YUp5BXkUeEV+cM2GgOvU5PhFdEm1cEiYWJFn9J78/aT3lNOeOCx9Vvi/aJxqAzcDDbfHho9ZnVbErZxE9JTedTXyrJRcltKh1tyOBQT05mFlNa2bKIwOqD6fi7ORAb3vKYx3Zj5wTdYsyvCNL2g6zFuZcmTXEopYDpPadTUl3wYoScAAAgAElEQVTCltQtTXavNday6swqYgNjGew/mBd2vMDyw/sJaiYsdCDrAEZpZFi3YU1ea4nIADcenNir0xO8HYklOYLdwDeAHpgnpRwhpfxbp1t2NZGtVQxlr9yJ0c6OLyOvJeqilvLM0kw2nNvATb1vanHC0ZjgMZRUl3A4+3Cz+zSksraSjNIMjucdp6y6DKHXE77sK3w3rual+9z548xShsz6lcWn4rN4MRFbt+C94E6Evb3F72tof0ZpBmcLzQvZ7UzfCcDooNFmX+9M+nr11bpELUwmGqWRhesW8sKOFyzaf2vqVux0dgwPGF6/zUHvQLRPNIeyzK8I6lZ/P6f8bNFntIW2lo42ZFB3T4wSjqQ17wQLy6r55UQ2Nw4MMjuLt8MIHqZN4rtY0jpVC0F2HzgeIeBAcgGxAbH4Ovmy9mxTyZXdGbvJKM1gbsRcXh/7OkajgUOVb3N9f2+zX9r7Mvdh0Bno79e/U07rSsKSFcFdUsohUsrXpJQWi84LIT4SQmTVqZaaeV0IId4WQpw2JaSHWGz1lUbOSSqL7Cn+eQenxk6j3NmDcN/GX/ZfnfiKWlnLHVF3tHiokYEjMQhDi+GhipoKPj36Kdcuu5Zhnw/juuXXMW/NPCZ8NYHf/vJbVpxcwR1r7yA+J56/jPsLt/W9fBqBY4K0yqTm7N+RvoMglyDC3MMum011RHpHUlxdTHqpZW36yUXJ5FfmsyllU5Nh7ebYmraV4QHDm1RDDfIbxNHco1TXNl7l5VfkE58Tj5PBiV3nd3VoF3Jd6WhbK4bqGBhSlzBuPjz0w9HzVNUamdVZYaE6QoZBZdGFEu06UvaCT2/cvLoR4e/KgZR89Do9U8OmsiV1S5OV3LenvsXd3p3+XqP53bJk8s7NReeYRY3nKrMfG5cZRz+ffjgZzMu6dyUscQQFQogPhRDrAIQQ0UKIltWbND4BWtJ8vQGIMD3uA/5twTGvTHJOkHO6G8LJiR+irqG3vysG/YVfbUVNBctPLmdi6MRWxb/c7N0Y6D/QbJxdSsmyE8uYvnI6b8S9QbhnOL8e/Gv+NOpPvDHhDWb1nsW+zH28sPMFqmqr+GTqJ0zv2XIfQ0cT5BpET4+eZu2vNlaz+/xuRgWNssqyOcYnBoBd6a2XuALE52r3MEZpZNlJ8812daQUp5BYmNgoLFTHQL+BVNZWNmlo25G+A4nk/gH3U1lbWb9a6gjqSkfbmiiuw8fVge7ezhxqwRGsPpROmI8z/S+Slehwgk2hmYZ5Aim1FUHICAAGh3pxILkAKSUzes6g2ljNj0k/1u9eWFnIxuSNXBs6ldn/2sOexDxenjKHRTEL+fbMivrZCHWUVZdxLOcYwwLaFha6WrHEEXyCNqGszu2fRNMbahEp5RagpT71WWgzkKWUchfgaRqJedVRdfo4Radq8brtNg4USfoGNg4LrUtcR35lPndG3WnR8cYGjyUhL6FRPFtKyWt7XuPlXS8T7BbMR9d/xAdTPuDeAfcyt89cpoZN5Y8j/8imeZtYOm0pK2eupJ9v+zstL4UxwWOIy4xrcocbnxNPSXUJY4LbqcR6iUT7RBPpFclnxz5rMrrRHEdzjuKod2RCyARWnFzRYg9C3QpoXEhTR1CXML44T7A9bTteDl4siF6Am71bm4f7tERSsaliqJ2hIYBBoZ7NrggyiyrYcSaXmYOCO9+p+/QGB4/GeYK8s1CWq4k8AoO7e1JYXk1iTinRPtGEuYc1Cg+tS1xHlbGKwqzB5JRUsez+UdwR251HBj9Cb8/ePL/j+UZT7A5lH6JG1rQpUXw1Y4kj8JVSLgOMAFLKGqAjxFOCgZQGz1NN25oghLhPCBEnhIjLzs7ugI/uQGpryNmeizDo0d86n8yiSqICGndY/nDuB8LcwxrFjltiWvg0vB29WbBuARvObah3Al8c/4KF0QtZMnVJs8fS6/QM8BuAp6P1KhbGBo2l2ljdpJ57e9p2dEJXP6rwciOEYGHMQs4UnrGoMis+J54onyjujL6T/Mp81p9b3+y+W1O3EuoWajYU4+/sT5BLUKN+AqM0sj19O6ODR2Ovt2d8yHi2pG6hxtgxCu/tLR1tyMBQT84XVpBZVNHktf/t1noUZg82rz3Voeh0EDyk8Yogda/2b70j0JrZDqYUIIRges/pxGXG8db+t1iXuI4Vp1YQ7hbB2jjBbcND66f9OegdeG3caxRUFvDyrpfr80f7MvehEzoG+w/u/PO7ArDEEZQKIXy4IEM9Eui8CQlmkFK+J6UcJqUc5udnXvjJWlQd3UVhogOek4dyqkYT3Gq4IiivKScuI45xIeMsvnMKcg1i2YxlRHhG8MTmJ1iwbgFfHP+Cu6Lv4olhT1zx1QhDA4biqHdsEh7amb6T/r79cbe3XIqgo5kaPpVuzt345OgnLe5XY6zheN5xYnxiiA2IpadHT75I+MLsvhU1FezN2Gs2LFTHQH+tsazuiyYhL4G8irz6nMo1oddQUFnAgawD7Tuxi0gpTsHZ4Nzm0tGG1JU/XlxGWllTy9LdyUyK9CfMt/nChw4lfLw2w/ikyRmn7AF7N016Gujt74qrg6He1tkRs4nxieHj+I/53ZbfaWG5kuE4GPSNZg2A1nX+0MCH2JC0gXs33MvDGx9mxakVRHlHtVjY0ZWwxBH8FlgN9BJCbAc+BR7tgM9OAxoGzENM264qct//ACHAZ+GdHM/QhlBENqgY2puxlypjVX2zmKV0c+nGx1M/Zl6feRzKPsSC6AU8OezJK94JgHaXNSxgGNvTLziCwspC4nPj67/4rIWdzo4F0QvYm7GXozlHm93vTMEZKmoriPGNQQjB7X1vJz43niPZR5rsG5cZR0VthdmwUB3jQ8aTVZ7FuwffBWBbqrYiqaueGhM8BjudXYdVDyUVJdHdvX2lo3XEBLljpxdNwkPfHzlPTkkli0aHXaKVbWDkQ9CtP3zzgGka2R5NfsLULa/XCQaGenDA1A3t7+zPlzO+ZM/8PSy/cTmPxrzK4WMxPDixF35mFFLv7nc3cyLmUFxdTE55Dv7O/q0WdnQlLGko2w9MAEYD9wMxpnGVl8pq4C5T9dBIoFBKeVUNvCk/epSCn/bg2asUu74jOH6+GB8Xe/xcL/yhbUvbhpPBqV2xRnu9Pc+Pep4f5/7IU8OeuiqcQB1jg8eSVJRESpEW/dt5fidGaWRU0CgrWwZzIubgaufa4qrgaK7mJOqkBW7sdSMudi68deCtJj0e68+tx1Hv2GK9+fTw6cyOmM1/D/+X1WdWsz19OzE+Mfg4afX3LnYuxAbG8nPyz+0STmtIZW0lh7IOEel1aR2pjnZ6ogLdG0lNSCn5ePs5evm5MO4SJSXahJ0jzPsYairh60WQebQ+UVzH4FAvEs4XNxqqY6+3J8KzD2t3eRHo4cLisT3NHt6gM/DC6Bf4asZX9Y+Lh+F0ZZp1BEKI2XUPYCYQCfQBbjRtaxEhxBfATiBSCJEqhFgshHhACFE31OZ74CxwGm0usmU6BlcI0mgk48WX0LsY8BvlwukiPWuPnGdID69GX9jb0rYxPGA4DvqWddpbIsAl4KpyAgDjgschEDy48UHWnl3LttRtuNm7WS2B3RBXe1fm9ZnHhqQNJBaab5I/mnMUNzu3+mSri50Lvxv+O3af380LO16o/7L+4MgHfHv6W27qfROOBsdmP1MIwR9H/pHYgFj+tONPHMo+1CRpPil0EqklqZwqOHVJ5/dLyi8UVxczrWfrsiKtMSjUk8OphfVKpAdSCjicWsii0WGX/2/SNwKm/xVSdoM01ucH6hjZ04dao+TzXY3HpXy+O4lDqYU8OSWy0eQxxQVaWhHcaHosBj4E5pseHwD3tHZgKeXtUspAKaWdlDJESvmhlPI/Usr/mF6XUsqHpZS9pJT9pZQtK0VdYRQs+5qKw4fpNs4ZAnvzwOf7cDDoeGlWTP0+SUVJpBSntDks1BXo7t6dd659B3u9PU9vfZpVZ1ZpPRJmhqZbg/lR83ExuLDoh0X1CpMNic+NJ9onGp248F9kdsRsHhr0EKvPrOat/W/xSfwnvLX/LaaFT+PpEU+3+pl2Ojv+NvFvhLqFYpTGJjmFa7tfi17ozTZDtYU1Z9bg7+RPbMClJ+VH9fShrKqW2f/azo4zOSzZcQ43BwOzh3TOgJRWGXQHDLgN9A4XdIhMjOntw3XR3XhjwwlOZmqjUxJzSnn1+wQm9PFj9pDLkNi+SmnWEUgp75ZS3g3YAdFSyjlSyjlAjGmbzVKTm0vWm2/iPHwYbl5n+LkoiLPZJfzz9sEEelxoPqmrTBkbZHuOALS4+PIbl/PG+DcY4j+EuRFzrW1SPd1cuvH59M9xs3dj8YbFrDh5QX67qraKk/knifGNafK+BwY8wLw+8/gw/kP+tu9v3BB2A6+MfaVFZdeGeDh48N517/H8qOcZ4Deg0Ws+Tj6MCR7Dd2e/a/dUs9zyXLanbWd6r+kW29QSU/sF8MbcAWQXV3LH+7tZdTCdW4aH4tJGVc0OZda78PBucGose63p/PTH1cHAb5cdpKK6lieWHcRer+P1OQOuulX15cSSqxl6Uew+E7Bp9dGsv/4NY2kpAQ/MRffjar7ODOSp6/syunfjmOm2tG30cO9BqHvbVQi7CjqhY2r4VKaGt9RbaB16evRk6bSl/H7L73lh5wsUVBawuP9iTuSdoMZYYzaMJYTg2dhnqZW1CLRwT1tXOQEuAczrM8/sazf2upEtqVvYk7GnXfmUH879QI2s4cae7Z/f2xAhBPOGhXLjwCA+25nEuvjz3D0mrEOO3W70BvAON/uSr6sDr97cjwc+389N727neEYxb902iACP5sN2CsscwUYhxHqgrnbuVqDjFbKuEqqSkij89lu8Fy0Co5YIdQqP5YEJjZNQFTUVxGXEMTui1XSKwop4OHjwzrXv8Idtf+Af+/9BqFsoeRVaH2RdJ/LF6HV6Xhz9YqfYMzFkIm52bqw5s6ZdjmD1mdVEeUd1uKifo52ee8f35N7x5pOtVxJT+wUye3AwKw+kMb1/IDPbOBzGFmnVEUgpHxFC3AyMN216T0r5TUvv6crkfvwxwmDA5567SVvxMHrpy4IpI5ssO/dl7qOitsIm8wNXGwadgZfHvMz5kvP8YdsfiPSKxNvRm0CXy9/o7mhwZErYFL5P/J4/Vv+xTVPczhSc4VjuMX43XIkDvzArht7dXLljxKWV0NoKFslQSym/kVI+bnrYrBOoycmhcOU3eNx0E3pfX5yy9nPaPsrsiL5taduw19nbjFbJ1Y6D3oF/TPoHvk6+HM45TIxPjNW+QGb2mkl5TTk/Jbdt4b3mzBr0Qs8N4Td0kmVXD+6Odjw0sTeezm1X0LVF1MziNpC3dCmyuhrvu+/myPET+Buzce3VdDUgpWRz6maGBw63CeXCroKPkw/vXvsu7vbujAgY0fobOonB/oMJdg1m9ZnVFr/HKI2sTVzLqKBRl9RNrLBNlCOwEGNpKfn/+wK3ydfi0DOcuG0bAIgZ0XRwS2JhIinFKUwKmXS5zVRcIr08e7Fx3kYWxiy0mg1CCGb2msme83tIL7FMMvtIzhEySjPUakDRLpQjsJCC5csxFhbis3gxuSWVGJN3UyPscOreVJSqTiZgQuiEy22mogNwNDhaPa48s9dM7HR2PLzxYbLLWhda3HBuAwadgYmhEzvfOEWXo12OQAjxQgfbcUUjpSRvyac4DRuK06BBfL0vlQHiFNX+A8DQtGN4c+pmoryjLBoPqVCYI8QthH9P/jdpJWks/GFhiysDKSU/Jv3I6KDRVhX0U1y9tHdFsK9DrbjCqUxIoDo9Hc/ZcwBYsecsg3SJOIWPbLJvXkUeh7IPqTszxSUzInAE7095n4LKAu5adxdpJeY1GY/kHOF86Xmm9JhymS1UdBXa5QiklGs62pArmZIt2iBs1/HjSM4twykvAXuqILTpTICtqVsxSqMKCyk6hIF+A/n4+o/Jq8jj82Ofm92nLiw0qbvKSSnaR7N9BEKIf2KaQWAOKeWvO8WiK5CSzVtw7NcPg68v23YnM1h3WnshpKkj2Jy6GX8nf6K9oy+zlYquSqR3JKODRvNj0o88NfypRvpHdWGhUYGjVFhI0W5aWhHEoYWAHIEhwCnTYxBgM8W5Nfn5lB86hOt4rZ9u++kcRjucRboFgUdj4a2q2iq2p21nQugEqycbFV2L68OuJ7Msk8PZjRXg43PiSS9N57oe11nJMkVXoNkVgZRyCYAQ4kFgrGlEJUKI/wBbm3tfV6N0+w4wGnGdMB6jUbL7dAav6hMQIaOb7Ls3Yy9lNWUqP6DocCaGTsROZ8eGpA31M5ABfkz6EYMwcE33a6xoneJqx5IcgRfQcM3patpmE5Rs2YzeywvHfv04dr6I8ZWb8ajJgUHzm+y7KXkTTgYnq83kVXRd3Ozd6sNDRmkEtAE0686tIzYoFg8HDytbqLiascQR/AU4IIT4RAixBNgPvNa5Zl0ZSKOR0q3bcBk7FqHXs+1UFg8ZVlPtFwN9rm+0b3xOPCtPreS6Htdd0hAahaI5poRNIaM0gyM52rjMdw++S0ZpBndF3WVlyxRXO5aIzn0shFgH1N3m/l5KmdG5Zl0ZVMTHU5ufX58fqDryLb116dSMfwkJ1GUBSqpKeGrzU/g6+yrBL0WnMTF0IgadgR/P/YiUkiVHlzAnYg6jg5uGKRWKttDqikAIsVFKmSGlXGV6ZAghNl4O46xNyeYtIAQuY8dQUVXDtTmfk+jYnVmnPmb26tlsTd2KlJKXd71Memk6r497XS3RFZ2Gu707o4NGsz5pPc9tf45uzt14ctiT1jZL0QVoqXzUEXAGfIUQXly4AXYHbGLmW8mWLTgNHIjBy4sTm5cTLc5xb4+JpJckE+ASwEMbH6KPVx9O5p/koUEPMaTbEGubrOjiTOkxhS2pWl/Le9e9h6u9q5UtUnQFWloR3I9WPtrX9G/dYxXwTuebZl1qcnKoOHIEl/HjwFiL5943+cC1G7urzvLokEdZfdNqnhnxDNll2cQGxnJf//usbbLCBpjUfRLOBmdujby1XYNrFApztFQ++hbwlhDiUSnlPy+jTVcEJVu0Clm3CRPg+6corzzBu8HBjA4ayaKYReiEjjui7mBe5DwEokPmwyoUreFu7866OevwdPC0timKLkSzKwIhxHAhRECdExBC3CWEWCWEeFsI4X35TLQOJb/8gsHfH4e89VTHfciv/MKx07vxythXGnV22uns2jyzVqG4FLwdvRv9DSoUl0pLf03/BaoAhBDj0cpIPwUKgfc63zTrIauqKN22DdcB3REbX+Q/PUaQ61DBPZFPqaEfCoWiy9HSraxeSpln+vlWtFnFK4AVQoiDnW+a9SiLi8NYVoZr1U9k9xjFR7pcakv6cvfgGdY2TaFQKDqcllYEeiFEnaO4FtjU4LWuGwsx1lK85DWEXuIyMpa/h/ejRtYQYZiPo53KAygUiq5HS47gC2CzEGIVUI5JX0gI0RstPNT1MBqRXy2gJO44zn38OXDDH/guaT3VueMZFxZlbesUCoWiU2ipaugVU+NYILBBSlknSa0DHr0cxl12Mg5TuXc91aX+nJswgn/segkve3+ScyYS27PL58cVCoWN0mKIR0q5y8y2k51njnUpTdnF+yW+XA/8WfcD+ppuDHG+n3ThwNAeNqOzp1AobAxVg9aAnSm/EHJOR0l3Xz5Z+B0/zf2JlPQQ+od44GzfddMiCoXCtlGOoAF7Mk/SNwVCp95EmEcYFdVGDqcWEBvuY23TFAqFotNQjsCErCwl43w5egluI7XW/f3J+VTXSpUfUCgUXRrlCEycS9yId6YOKcBxwAAAdp/NRSdgmMoPKBSKLoxyBCZ2JK4jIl2i7x6M3lVTdNyVmEe/YA/cHO2sbJ1CoVB0HsoRmNiec4TIdInbMG3+TnxaIQeTC4gNV2EhhULRtVGOAKiqrSI5pwCXcnAaMJAjqYXM/2A3fm4OLBwdZm3zFAqFolNRjgDYn7qN0HStXy65Wzh3fLALN0cDX943khAvZytbp1AoFJ1LpzoCIcRUIcQJIcRpIcTTZl5fJITIFkIcND1+1Zn2NMeO02voky7B3o67Nmbj5WzPV/ePItRbOQGFQtH16bQuKSGEHngXuA5IBfYKIVZLKY9dtOtXUspHOssOS9ietZ+HUo2c9grBycmBL+8bSZCnkzVNUigUistGZ64IRgCnpZRnpZRVwJfArE78vHaRU55DYlkuAdmCI57hfLhomHICCoXCpuhMRxAMpDR4nor5ofdzhBCHhRDLhRCh5g4khLhPCBEnhIjLzs7uUCMPZh4iLBN0Rph400Rigjw69PgKhUJxpWPtZPEaIExKOQD4EVhibicp5XtSymFSymF+fn4dasAvp7fTJ80IwPBpEzr02AqFQnE10JmOIA1oeIcfYtpWj5QyV0pZaXr6ATC0E+0xy8ns/QxONaLz9sSum//l/niFQqGwOp3pCPYCEUKIcCGEPXAbsLrhDkKIwAZPZwIJnWhPE6SUJFem0PO8xHnggMv50QqFQnHF0GlVQ1LKGiHEI8B6QA98JKU8KoR4CYiTUq4Gfi2EmAnUAHnAos6yxxwZpRnoyypxLdLhPHT45fxohUKhuGLoVJF9KeX3wPcXbXu+wc/PAM90pg0tcTT3KD2ytEYyx379rGWGQqFQWBVrJ4utysHMI4TmaI7AoVcvK1ujUCgU1sGmHcGB9P1EZxnByR69r6+1zVEoFAqrYLOOQErJmaIThOVI9KFBCCGsbZJCoVBYBZt1BOdLz1Mqy/HOA5eoaGubo1AoFFbDZh3B0dyjuJVJDBU6HPv2t7Y5CoVCYTVs1hEcyz1Gd5NahUNvlShWKBS2i806gsNZ8QzKrAVUxZBCobBtbNIRSCk5lhtPVHYN0t6AITCw9TcpFApFF8UmHUFaSRolNSUE5oI+JFBVDCkUCpvGJh3BqfxTALjmCVwi+1rZGoVCobAuNukIUopTcKqQiHI9jlFKWkKhUNg2NukIkouT6V1fMdTbusYoFAqFlbFJR5BUmEy/rBoAHHr2tLI1CoVCYV1s0hGcK0ikd3Yt0qDHLiTE2uYoFAqFVbE5R1BtrCarIpOAXNAH+iMMnarErVAoFFc8NucIMkoyMCLxyNcpjSGFQqHABh1BcnEy9tUSu2IdDn2irG2OQqFQWB2bcwSJhckE5YJAaQwpFAoF2KAjiE89TN90IwAOkZFWtkahUCisj805guScYwxMNSLcXLAPC7O2OQqFQmF1bM4RZFdm0DMdnAcPURpDCoVCgY05AqM0UllRile+wHnoMGubo1AoFFcENuUIUgrPE5YuAXAaNMjK1igUCsWVgU05gj0Jm+mTJpE6gVN/JTanUCgUYGOO4EzSTvqkgewRjM7Z2drmKBQKxRWBTTmCnPzjRKRLvEaOsbYpCoVCccVgU47APisTx2pwGaISxQqFQlGHzTiCsooKPDOrAHAaPNjK1igUCsWVg804grNH9+KTKShzNWAXHGRtcxQKheKKwWYcQUnmfnqmQWmfENVIplAoFA2wGTF+x16D8CiA4mFDrG2KQqFQXFHYzIogb+9OALyHjbKyJQqFQnFlYTMrgtjRc0l/QBI6fKK1TVEoFIorCptxBC49exPxm2esbYZCoVBccdhMaEihUCgU5lGOQKFQKGwc5QgUCoXCxulURyCEmCqEOCGEOC2EeNrM6w5CiK9Mr+8WQoR1pj0KhUKhaEqnOQIhhB54F7gBiAZuF0JEX7TbYiBfStkbeBN4vbPsUSgUCoV5OnNFMAI4LaU8K6WsAr4EZl20zyxgienn5cC1QrX9KhQKxWWlM8tHg4GUBs9Tgdjm9pFS1gghCgEfIKfhTkKI+4D7TE9LhBAn2mmT78XHthFs8bxt8ZzBNs/bFs8Z2n7ePZp74aroI5BSvge8d6nHEULESSltToPaFs/bFs8ZbPO8bfGcoWPPuzNDQ2lAaIPnIaZtZvcRQhgADyC3E21SKBQKxUV0piPYC0QIIcKFEPbAbcDqi/ZZDSw0/TwX2CSllJ1ok0KhUCguotNCQ6aY/yPAekAPfCSlPCqEeAmIk1KuBj4EPhNCnAby0JxFZ3LJ4aWrFFs8b1s8Z7DN87bFc4YOPG+hbsAVCoXCtlGdxQqFQmHjKEegUCgUNo7NOILW5C6uVoQQoUKIn4UQx4QQR4UQj5m2ewshfhRCnDL962XaLoQQb5t+D4eFEFftyDYhhF4IcUAI8Z3pebhJquS0SbrE3rS9y0iZCCE8hRDLhRDHhRAJQohRNnKtHzf9fccLIb4QQjh2testhPhICJElhIhvsK3N11YIsdC0/ykhxEJzn3UxNuEILJS7uFqpAZ6QUkYDI4GHTef2NLBRShkBbDQ9B+13EGF63Af8+/Kb3GE8BiQ0eP468KZJsiQfTcIEupaUyVvAD1LKvsBAtPPv0tdaCBEM/BoYJqXsh1Z8chtd73p/Aky9aFubrq0Qwhv4E1rz7gjgT3XOo0WklF3+AYwC1jd4/gzwjLXt6qRzXQVcB5wAAk3bAoETpp//C9zeYP/6/a6mB1pfykbgGuA7QKB1WRouvuZolWujTD8bTPsJa59DO87ZA0i82HYbuNZ1CgTepuv3HXB9V7zeQBgQ395rC9wO/LfB9kb7NfewiRUB5uUugq1kS6dhWgIPBnYD3aSU500vZQDdTD93ld/FP4DfAUbTcx+gQEpZY3re8LwaSZkAdVImVxvhQDbwsSkk9oEQwoUufq2llGnAX4Fk4Dza9dtH17/e0PZr265rbiuOoMsjhHAFVgC/kVIWNXxNarcGXaZOWAgxA8iSUu6zti2XGQMwBPi3lHIwUMqFUAHQ9a41gCm0MQvNEQYBLjQNoXR5OvPa2oojsETu4qpFCGGH5gSWSilXmjZnCiECTa8HAlmm7f0MKyMAAAOCSURBVF3hdzEGmCmEOIemansNWuzc0yRVAo3Pq6tImaQCqVLK3abny9EcQ1e+1gCTgUQpZbaUshpYifY30NWvN7T92rbrmtuKI7BE7uKqRAgh0Dq0E6SUf2/wUkP5joVouYO67XeZqg5GAoUNlp5XBVLKZ6SUIVLKMLRruUlKOR/4GU2qBJqe81UvZSKlzABShBCRpk3XAsfowtfaRDIwUgjhbPp7rzvvLn29TbT12q4HpgghvEwrqSmmbS1j7eTIZUzCTANOAmeAZ61tTwee11i05eJh4KDpMQ0tJroROAX8BHib9hdoFVRngCNolRhWP49LOP+JwHemn3sCe4DTwNeAg2m7o+n5adPrPa1t9yWc7yAgznS9vwW8bOFaAy8Cx4F44DPAoatdb+ALtBxINdrqb3F7ri1wj+ncTwN3W/LZSmJCoVAobBxbCQ0pFAqFohmUI1AoFAobRzkChUKhsHGUI1AoFAobRzkChUKhsHGUI1DYLEKIEtO/YUKIOzr42H+46PmOjjy+QtGRKEegUGhCX21yBA06WpujkSOQUo5uo00KxWVDOQKFAv4CjBNCHDTp3uuFEG8IIfaatN7vBxBCTBRCbBVCrEbrbEUI8a0QYp9JK/8+07a/AE6m4y01batbfQjTseOFEEeEELc2OPYv4sKsgaWmLlqFotPptOH1CsVVxNPAk1LKGQCmL/RCKeVwIYQDsF0IscG07xCgn5Qy0fT8HillnhDCCdgrhFghpXxaCPGIlHKQmc+ajdYdPBDwNb1ni+m1wUAMkA5sR9PT2dbxp6tQNEatCBSKpkxB03E5iCbp7YM2AARgTwMnAPBrIcQhYBea2FcELTMW+EJKWSulzAQ2A8MbHDtVSmlEkwoJ65CzUShaQa0IFIqmCOBRKWUjsS4hxEQ06eeGzyejDUEpE0L8gqZz014qG/xci/r/qbhMqBWBQgHFgFuD5+uBB03y3ggh+pgGwFyMB9pIxDIhRF+0UaF1VNe9/yK2Area8hB+wHg0YTSFwmqoOw6FQlPyrDWFeD5Bm20QBuw3JWyzgZvMvO8H4AEhRALaqMBdDV57DzgshNgvNYnsOr5BG6t4CE019ndSygyTI1EorIJSH1UoFAobR4WGFAqFwsZRjkChUChsHOUIFAqFwsZRjkChUChsHOUIFAqFwsZRjkChUChsHOUIFAqFwsb5f0aWQXg+8RSoAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOyddXgU19rAf7O7cdkYMYhjCRaCu5QiRUuBAoUqddfb9vbWbl1vv1uh1IvcluJQpLgmuAcIIR7iutG18/0xIRCyGyMJbZnf8+yTMHPmnHdIMu+cVyUhBAoKCgoKNy6q6y2AgoKCgsL1RVEECgoKCjc4iiJQUFBQuMFRFIGCgoLCDY6iCBQUFBRucDTXW4DG4uXlJYKDg6+3GAoKCgp/KQ4fPpwrhGhj6dxfThEEBwdz6NCh6y2GgoKCwl8KSZKSrZ1TTEMKCgoKNziKIlBQUFC4wVEUgYKCgsINjqIIFBQUFG5wFEWgoKCgcIOjKAIFBQWFGxxFESgoKCjc4Pzl8ggUFBRuPIwFBZRFR6Ny1aJ2c0Pt7IQwGhEGA2qtFht//+st4l8aRREoKCj86cn+4EOKVq60fFKSaPfVl7gMH96qMv2dUBSBgoLCnxpzWRnFmzbhesstuM+5A1NBAeaSEiQbGyRbW3K++JKL/3iRkOXLsG3X7nqL+5dEUQQKCgp/anRbtiDKynCfPQvHqKha5+06dSLxtmmkP/EkQf9bgsrO7jpI+ddGcRYrKCi0Otkff0Lejz82aGzRqtXYtGuHgwUlAGAbEID/e+9RERtL1tvvNKOUNw6KIlBQUGhVTDodeT/8QPaHH1Fx9mydYw1ZWZRGR6OdNAlJZf1x5TJyBJ4PPEDh0qWUnzzZ3CJXYyopwVRU1GLzXy8URaCgoNCqlO7dC0YjklpNxmuvIUwmq2OL164FIdBOnlTvvJ733QtqNbqtW5tT3BqkP/EEKfPub7H5rxeKIlBQUGhVSrZvR63V4vvGG1QcP0HBr79aHCeEoHDVKhx69sQ2KKjeedVaLY5RUZTs2NncIgNgSE+ndF80FSdPYkhPb5E1rheKIlBQUGg1hMlEyc5dOA0dinbKZJwGDiDnk08xZGXXGlsRG4s+/gLayZMbPL/z8OFUnj2LISOjOcUGoGjd79Xf63bsaPb5ryeKIlBQUGg1yo+fwFRYiMuI4UiShO9rryH0erLefbfW2MJflyLZ2OA6bmyD53ceMRyAkp3NuysQQlC0Zg0OvXphExRIyfYdzTr/9UZRBAoKCq1GyfbtoNHgNHgwALZBQXg++AC6jRsp3bevelzFuXMULluG2/TpqLXaBs9vGxKCTaD1B7Uwm9Ft2465vLxRclfExqK/cAHtpEm4jBhJ2f79mEpKGzXHnxlFESgoKLQaJTt24NirF2pX1+pjnvPmYRMQQOZbbyP0eoQQZP37LdSurrR54vFGzS9JEs7Dh1EaE1PrYW8uLSX9ySdJe+QR8n74oVHzFq9ZI+9Oxo7BecQIhMEgO73/JiiKQEFBoVXQp6VTef48zleVglDZ2eHz8kvoExLIX7gQ3YYNlB06RJunnkLt5tbodVyGD0dUVlIaHVN9zJCRQdKcuei2bkPt7k7prt0Nnk8YjRT9vh7n4cOrHNI9Ubm6yrubvwmKIlBQUGgVSqocrC5VdvwrcRkxAucRI8j54kuy3nsfu4hw3KZPa9I6jr17o3J0rF5Pt3UridNnYEhNJWD+V7jPmkX5CdlX0RBKo6Mx5ebiOmkiAJKNDc5Dh1Kyc2edoa9/JRRFoKCg0CqUbN+ObXAwtsHBFs/7vPwSGI0Ys7PxfeUVJLW6SetItrY4DR5MyfbtpD31NGmPPobG05PgX/6H89ChOA0ZDGYzpdHRDZqvaM1aVFotzsOGVR9zHjEcU0EB5cePN0nGKzEWFJD68CNUxMVd81xNRVEECgoKLY4hM5PSmBhcRt1kdYxtQAB+77yD9wsvWKwp1Bichw/HmJNDybZttHnqKUKW/YZd+/YAOHTrhkqrpWT3nnrnEWYzpbt24TJiBCpb28vzDxkCGk2zmIeK166jZPt2Lj7/Ama9/prnawpK0TkFBYUWp+CXX8Bsxu322+scp50wvlnWcx03FkNaGq4TxmMXGlrjnKTR4DRwAKW7dyOEQJIkq/NUnjuHqagIp4EDahxXu7ri2Ls3ui1bafPMM3XOUR9F69ahdnen8tw5cj//Au9nnm7yXE1F2REoKCi0KObKSgqX/obz8OHYBgS0ypoqBwfaPPF4LSVwCefBQzDm5FBZjzmmNGY/AI79+tU65zr+FvSJiVRcg3lIn5xMxYkTeM6bh/a2qeR9+y1lR482eb6moigCBQWFFqV4wwZM+fm4z7njeotSzaU8htLddUcPlcXEYBscjI2PT61zruPGITk4ULh8eZPlKFq3DiQJ1/G34PPSS9j4+pLx4kuYy8qaPGdTUBSBgoJCiyGEoGDRYmxDQ3EaOPB6i1ONjY83dh071uknEEYjZYcO4di/9m4AQO3sjOvYsRT/vh5zaeOTy4QQFK/7Hcc+fbDx9UXt7Izf22+hT06maO26Rs93LSiKQEFBocWoOH6cilOncL9j9jXZ0VsCpyGDKTtyxGqGcMXp05hLS3Hq39/qHG63Ta3qoPZHvesJITDm5FyePzYWfWIirlf4RRz790el1VJx6lQj7uTaURSBgoJCi5G/aDEqJye0k6dcb1Fq4TxkCBgMlB3Yb/F8tX+gb1+rczj06oVtcHC95iEhBFlvvc35IUPJePU1TCWlFK9dBzY2uI4eXT1OkiTsw8OpOHOmCXfUdBRFoKCg0CKYSkoo3rQJ7ZQpqJ2drrc4tXCIikJydKR0j2XzUNn+GOw6dkTj4WF1DkmS0N42lfLDh6lMTLQ4RghB9nvvU7B4MY69e1O4bBmJU6ZQtGYNzkOH1sqetg8PpzIuDmEwNP3mGomiCBQUFFqE0j17wGBoVPXQ5kQIUed5la0tjn16U7p3X61zZr2essNHrPoHrkQ7eTKo1RStWGFRhpxPPiH/p59wnzuXwIU/E7RoEahUmPLzLYbL2keEI/R6KhMsK5aWoMUUgSRJAZIkbZckKVaSpNOSJD1pYcxwSZKKJEk6VvV5taXkUVBQaF1027ahdnPDITKy1deOy9Ix8L1tbDubVec450GD0Ccno0+r2Wim/NgxRGVlnf6BS9h4e+M8dCiFq1YhrkoIK16zhrxvvsVt1kx8Xn4JSZJwjOpJ6KqVtPvyS1zGjKk1n314OAAVZ2LrXbu5aMkdgRF4VggRAfQHHpUkKcLCuN1CiMiqz5stKI+CgkIrIYxGSnfuwnnYUCRN6+et/nowlYyiCp7+9ThpBdZDMS9FMpXuq1lJtCxmP6hUOPbu3aD13GfNxJSTS/Efm6uPCSHI+/Y77Dp3xvdf/6rhLFc5OuIycoTFPsy2ISFI9vZUtqKfoMUUgRAiQwhxpOp7HXAGaNtS6ykoKPx5KD96FFNREc4jRrb62iazYO3xi/QMdMNsFjy65Ch6o9niWNuwMDQ+PrXMQ6UxMdhHRNQol10XToMHYxsURMHChdXHyvYfoPL8eTzmzrX4wLeGpFZj36kTFaf/HjuCaiRJCgZ6Apbc8wMkSTouSdIGSZK6WLn+AUmSDkmSdCjnivArBQWFPye67TvAxganwYNafe39CXlk6yqZNziUD6Z153hqIe9tOGtxrCRJOA0cSGlMTHUl0Ypz5yg/cqTOuki15lGpcJ8zh/Ljxyk/cQKA/EULUbu71wgPbSh2EeFUnD2LMFtWYM1NiysCSZKcgeXAU0KI4qtOHwGChBA9gP8CqyzNIYRYIIToLYTo3aZNm5YVWEFB4Zop2bYNp759UTs7t/raq49dxMlWzU3h3ozr5sfdA4P5fm8iBxLzLY53GjQIc1ERFbHyG3jet98hOTriPnNmo9bV3joFlZMT+YsWoU9Lo2TrNtxmzEBlZ9foe7APD8dcUoIhLa3R1zaFFlUEkiTZICuBxUKIWi51IUSxEKKk6vv1gI0kSV4tKZOCgkLLUpmYiD4pCecRI1p8rZS8Mr7dnUClUX6brzSaWH8qgzFdfLG3kctYvzC2ExqVxM64bItzOA2QHcKle/eiT0uneP163GfMaHRTHLWzM9qpUynesJGcz/4PVCrcZ89q0n3Zh8vu1IrY1vETtGTUkAR8B5wRQnxiZYxv1TgkSepbJU9eS8mkoKDQ8lzqF2ypAU1zsjc+l4mf7+Gt38/w1C/HMJrM7DiXg67CyKRI/+pxjrYaIvxdOZxcYHEejacndhHhlO7dR/4PP4BKhcfddzVJJo87ZoPBQPHatbiOGW2xRlFDsOvYAdTqVkssa0l3/iBgLnBSkqRjVcdeBgIBhBDzgWnAw5IkGYFyYKaoL/hXQUHhT03Jtm3YdeqETduWiQ0RQvDjviTe+v0MYW2cuKNfIF/uuMBLK05Sqjfi6WTLoPY1DQtRge78ejAVg8mMjbr2+6/zwIHk/fQz5SdPop04ERtf3ybJZhscjNOwoZTu3IX7nLlNmgPk9p127du3WghpiykCIcQeoM7iIkKIz4HPW0oGBQWF1sVUXEzZ0aN43j+vReYXQvDvdWf4fm8io8J9+M/MSJztNGjUKv5v63kA7hwQVOthHxXkzo/7kjiboaNbO22teZ0GDSLv2+8QBgOe9917TTL6/OMflA4ciEPPa8ufsA8Pp2Rv/c1zmgOlMY2CgkKDEEKgv3ChutOXJcoOHQaTqUUqjZrNglfXnGJRTAp3Dwzm1QkRqFTyu+bTozqgqzDw074kpka1q3VtryB3AI6kFFhUBA5RUagcHXEcOAC7sDCrMvy4N5FlR9JQq1RoVBIDwzx5dnSnGmPsQkOt9kFoDPYR4RStWoUhOxsbb+9rnq8ulBITCgp1kPGvV8l6/4NWrw//Z6R4/XoSJkykZNcuq2PKDhxAsrPDoUePZl3bZBa8tOIki2JSeGhYGK9NvKwEQA4DfXVCBDEv30RkQG0nr7/WHl9Xe6t+ApWdHUG//A//t9+uU47F+1PI0VXi5mBDfqme+TsvUK5vmQb2lzKMWyOxTFEECgpW0CcnU/jbb+T/8AMJU26l9MCB6y3SdUMIQd533wGQv3CR1XGlB/bjEBnZpJBJa1QaTTz5y1F+PZTKEzd14B9jO1ksaS1JEt4u9hbnkCSJXkHuVhUBgH3Hjqi1tXcLl6gwmLiQU8LtvQP46d6+vDYxAoNJcCjZcljqtWIXHg6SRPnxEy0y/5UoikBBwQq6LVsA8P/gfQBS7ryLlAceIPebbyg7crRVq0Neb8r2H6Ay9gx2HdpTuns3+qSkWmNMRUVUnjmLY98+TV5nb3wu3+1JJK+kEoCicgN3fneAdScyeGlcZ565uWOT+xr0DHQjvbCcrOKKJl1/LlOHWUCEv5xt3CfYA41KIvpCywQ6qp2dse/WjdLo6BaZ/0oURaCgYAXdH5uxj4hAO2kSoatW4vnAAxhS08j5+BOSZ88mee6dmK8qMvZXxazXWy2jDJD/ww+oPTxo99VXoNFQ8L9fao0pO3wYhMCpjvr9dZGcV8oDPx/i3+tiGfDuNp785SjT5+/jSEoBn82M5MFh1m33DaHaT1DHrqAuYjPkfNgIP3nX4GSnoUeAG/taSBEAOA0cQPmJE5h0uhZbAxRFoKBgEUNWNuXHj+My+mZALhLm/czThG1YT4e9e/B55RXKjx0j6513rrOkzUPma6+TcMt48r77rlb55soLFyjZuRP32bOxbdcO19GjKVyxopbfpGz/fiQ7O+yb4B8wmMw8+csx1CqJhff1ZXa/QLadzSajsIKf7unL5MhrD0Xt4q/FVqOq0zxUF7EXi3Gx09DO3aH62IBQT06mF1FSabxm+SzhPGgQmEyU7bfcPKe5UBSBgoIFdFtls5DLqFG1zmk8PfGYcwee8+6j8JdfKVxlsTLKn5Jdabv4+fTPNR72FbGxFK1ahcbHh+wPPyLjlVdqlFPO//EnJDu76ixZ9zl3YNbp5MbrQKWpkq+Of0VRzD4cevZEZWvbaLn+b+t5jqUW8s7Ubgzp0IbXJ3XhwMuj2PXCCAa2b55iA7YaFT3aaTmc0vQdQbifaw0n9YAwT0xmwUEr5SuuFYcePZAcHSnZu7f+wdeAEj6qoGCBki1bsA0JwbaOUMI2Tz1F+clTZL72OvadOlVHefxZSSpK4rmdz1FuLAfgzi53IoQg8/0PqHCy4fm55XyYOREWrqDy7Dnsu3dD4+5O0erVaKdMqe7U5dCzJ3adO1OweAnaadN4M/pNtp5azbA4E+6Pj2u0XAcS8/liezzTerVjQvfLGcEOtmocbNXNc/NVRAW58/2eRCoMpuoSFA3BbBacyShmRu+AGsd7Bbljq1YRnZDHiM7NH+Ip2dri1LcvpftqN89pTpQdgYLCVZgKCyk9cBCXUaPqdExKGg1tP/4ItZsbqY8+iiEjoxWlbBxGs5GX97yMjcqGwW0H89Ghj9iRuoPiHdsp37+fJQOMCBcn7g3cTNbzsxD6SnQbNpL75VcAeNx9d/VckiThfsdsKs+dY+OCl1lzYQ1d0iQkAU796u/odSW6CgNP/3qMAA9HXp9ksfhwsxIV6I7BJDiVXtSo65LzyyjTm4jwq1mW2t5GTc9AN/ZdyG1OMWvgNHAghuQU9C1YgE5RBAoKV6HbsQOMxmr/QF1ovLwI+OpLzLoSUu6+B2MDyqRXGCvIKWvdcurfnPyGk7kn+deAf/HJ8E8I9wznxR3Pc+qN57noDhH3PcWqKavo6d2TxzW/sevd2+gYE03nUyfpeGA/dqEhNebTTpqEqVtHAj9bzbyszkwqCqVSAzZdLPWess4ba2PJKCrn09vlDOGW5pLDuLEO3tiLVY5i/9r9CQaEeXL6YjFFZS0TRXaplLellprNhaIIFBSqMFdUYMjKpnj9ejS+vth37dqg6+wjIgj4+msM2dmk3DcPU2FhrTFZpVm8f+B9Zq2bxYAlAxi9fDSpxanNfQsWOZV7iq+Pf8340PGMCRqDKiWTD4vH8uQKIx6ZZejuv5V7Iu/HxdaF+aPmMzpoNB8f/piEwgQkjQaVfe3Y/CJRxtMT8kkOsmf0j7GE7U/jXDuJ86UN77O78VQmyw6n8eiI9kQFujfnLVvFy9mOqEA3Np3ObNR1sRlFaFQSHXxql9UeGOaFELA/MQ+EgIpiKEiCjOOQuAvi/oDUA5B7HioatxMBuWOZxteX0hb0Eyg+AoUbHnNZGQkTJ2FIv9y31n3u3EbFqztG9STgi89JffAhLoy7BZt27dB4eODQsydeDz3I0rilLD6zmCifKGaHz2Zh7ELWJqzlkchHWuKWavCfg5/QL9OZR5LsiH/1JoxVJqxIrStlUwYw+Z7L2bS2alte6vcSW1K2sD5xPY/1fMzinNtStpFJIUELvsfxn/+l7OBBYiNVGLKOEOFZ/64gW1fByytP0rWtK0/c1KF5brSBjOvqx9vrz5CSV0agp2ODrom9WEx7b2fsNLX9Cj08jbxt+yP9Vj0NKwrBVGl9IpUGhr4AQ54FdcMev5Ik4TRoILrNWxAmE5K6ef0moCgCBQVKY2IwpKfjPncudmFhqN3cmtRZy2ngQAK++YailSsw5uVTGR8vh13OmkliUSKBroH8OPZHAM7ln2Ndwjoe7vFwkxOkGoKuUsewL/fT+7yZMrvVOA0ejPPDD+HYu7fcG9fC2l4OXvTx7cOGxA08GvmoxTE703bi5+RHl4DeiK/nU7BkCSdsf0GXfYQ5EXPqleu11acpqTTy6YxIi9VAW5KxXX15e/0ZNp3O5P6hDasJFJtRXKuiKUY9HPwGux3vM1OlY7cYwNC+vVA5twFHD7B3A3staOzlnUB5PsRthB3vwPk/4Navwct63aYrcRo4kKLlK6g4darZy3eAoggUFCjZvgOVkxM+zz+H1ITQxytx6t8Pp/6yw7Q0OpqUe+6l/MRJEosSCXG9bGefGDaRV/a+wvGc40R6X1uVyro4vuo7ep83o58zkW5Pv4bKyalB190Scguv7XuN2LxYunjVdOJWmiqJyYhhUtgkJElCcnTEc948Ou++wL6L+xBC1KncEnNL2XAqkydu6kAHH5drur+mEODhSBd/VzacymiQIsgtqSSruLKWo5iVD8DpldB+FNsDHmfehlLmlAfy79Fdrd9/9xnQeQKsexrmD4bpP0Cn+iOtnAYOBEmiZO/eFlEEio9A4YZGCEHJrl04DRp0zUrgauy7dQNJouz4MZKLkwnRXlYEo4JGYa+2Z038aojfCqbmdzQKvR7bLxdz0UtF+POvN1gJANwUeBMalYb1ietrnTuYeZByYznDA4bXOB7lE0V+RT7Jxcl1zr0wOhkbtcSc/oENlqe5GdvFlyMphQ0qN3Emw4KjOHGXrASGvgBzljNq2HAeGhbGopgUvtxxoe4Ju06FR2LAOxx+nQMnl9Urg8bdHa9HHsGxZ896xzYFRREo3NBUnj2LMSsL5+HDm31utbMztmGhFB49iMFsqKEInGycGBk4kk0J69AvmgrfjoJsyw3Wm0reokW4ZJVw/Pae2No1zBZ+Ca2dliFth7AxcSMmc83qmjtTd+KgcaCPb82aQr28ewFwJPuI1XnL9EZ+O5zKuK5+VgvEtQbjusmNZxriND59KWLo0o7AZISNL4E2EIY8Uz3uhTGdmBLpz4ebzvHrwZRaGdo1cPWDO1dDQD9YPg8O/1SvHG0efwynAQPqHdcUFEWg8LdAb9JzvuB8o68r2bEDAOehQ5pZIhmHHj0wnDwNQhCsDa5xbmLYRIpNFezy8IGiNPh6KOx4Hw58A5tfg9WPQVG65YnrwZiXR84XX3AkVCJwzJQmzXFLyC1kl2fXeLALIdiVtov+fv2xU9esMBqiDcHdzp3DWYetzrnq6EV0FUbuGhjUJJmai/beLoS1cWLjqfoVQezFYtq6OeDmWLVjPPITZJ2C0f8Gm8vlJlQqiQ+m9WBQe0/+sfwkA97dxssrT3IwyUrWsb0r3LEM2t8Ea5+AC9ub49aaRKMUgSRJLR/ioKDQSCpNlTy29TGmr51ObnnjEntKduzEvls3NF7NU8bgahy690BVXIpPATV8BAD93cPxMppY4x0kmwo63Cw7Etc/B9FfwLHFsOPdJq2b/dHHmCsq+HmUisFtBzdpjmEBw3DQONQwD50vPM/F0osMazes1nhJkujp3ZMjWZZ3BEIIfo5Ooou/a6uFi9bFuK5+7E/MJ7/UeuHAkkoju8/nXO5xUF4A296CoEEQMbnWeFuNiu/u6sOH07oTGeDGqqPpzFwQQ3phueUFbB1h5hJw8ob98+sW+NxGKGuZUhZWFYEkSc9c9XkWePPSv1tEGoUbmse3Ps6re19t1DUGs4Hndz5PdEY0JmHieM7xBl9rzM+n/MQJnIfVfqg1Fw49ugMQmeOIm33NhimaC9u5pbSU3focCjU2cPsieOwQPHsOXsmG3vfB8V/k3UIjyPvxR4pWruTgSH8cwzrg69S0/rsOGgdGBIxgc/JmivWyeWRXmtyUZkg7yzuoKJ8o0krSyC7LrnXuQGI+ZzN13DkgqEUjpRrK2K6+mMyCzbHWdwU/7UuioMwgO5VNBtjwD1kZjH0PrNyDvY2a6b0DmD+3F789NACTWXAgsY4ENo0dRN0JcZugwIp/pfgiYulc2F5345ymUteO4A2gH+AMuFR9VVd93/qufoW/NcnFyexI28Gq+FUkFCU06BqzMPOvvf9ie+p2nu31LBqVhhM5DW/iUbp7NwjRIv6BS9i1b4/eVkWPHAs2+rPrGGG2wyhMnMg9IT9YvDqAiy+oVDDoCUDAvv82eL3ijZvIfv8DHG++if/2yW3ybuAS0ztOp0RfwtTVU4m+GM3O1J1EeEbg7Wi5rk4vH9lPYMk89HN0MloHGyb1aJmm9o2li78rwZ6OrD520eL54goDC3YlcFNnbyLdKuGnSXDiVxj2D/Dr3qA1Ovu64mKv4UB9Rel63S3//A//aPG02PMfTCYTv9nd2qB1G0tdiqBL1Xkn4EMhxBtAgRDijarvFRSajdXxq1FJKmzVtvxw6ger40wlJVQmyIpiwYkF/J7wO09GPcndXe8m3CO8UTsC3Y4dqNt4YR/RcsXiJI2GJD81IWlXRQUZKuD8ZjqFyGUszuWfq32xWyB0v112JJbULkkhjEYSp97GhVvGk/nmm+QvXMTFF17AITKSxCcnoRdGBrVtfD7ElfT27c3CcQtxtHHkgc0PcCznmEWz0CU6e3TG096T3xN+r3G80mhi85kspkT6y4Xktr0FMV9dk2zXiiRJ3NqzHdEJeVy82nSTdogDyz5mtH4zb7Y7CAuGwcWjMPVbGPFSg9dQqyR6B7nXrwjcAqDDGDi6UM5PuBJdJuLwjyw3DgG3lvGtWFUEQogUIcR0YB+wWZKkaS0igcINj1mYWZewjgH+A7itw22su7COjBLLBdzSn36GhEmTSVm7lO9OfsfooNHM6zYPgB5tenA69zRGc/214YXBQOmevTgPHYqkarmYiaLKIs74GXFPLarZxCZxJ+hLcIm4lXbO7TibbyViaPDTYKyAmC9rndJt305FbCwqZ2cKV60m6+23sfH3p92XX7An9wAOGgeivKOu+R66tenG0glLmRsxFycbJ8YEj7E6VqPScFvH29iVtov0ksuO7pNpReiNZgaEecmmlT2fypE3CTuvWb5r4daebRECVh27wikfvwXx/RhGxb/LhzYLaLvnJdl8M28LdJ/e6DX6hHhwIae0uuua9YH3QWkOnFlT8/je/0OYjHwrTWFcN79Gr98Q6v0LEEKsBkYjm4larvydwg3LwcyDZJRmMDlsMnd3uRuAn2Jrh9OVxuyndPdu1M7O6F58nagzep7pfdld1b1NdypMFZw/sxK+Ggwp1pt5lOzdi1mnw2XkyGa/nytJLErkvL+Eymiq2YT8zFqwc4WQoXTy6ERcQZzlCbw6yE7Jg99Cec0aRoX/+x8aPz+Clyym0/4Ygpf+StCSxWjc3TmSfYQonyhs1c2TG2GvseeFPi8QPSuaMLe6O4VN7zgdSZJYFnc5Pv5gktwDoE+wu1x7x2yUs29XPAClLVe5sz4CPVfDg+cAACAASURBVB3pE+zOiiPpcrjnxWPw653k2IcwpPJTzs+OgSeOwqMHwLdhtaeupl+IXL770v+BVcJukt/4D31/+VhJNuLQ96xjMF26tFxhvga9CgkhSoUQzwshhraIFAo3NKvjV+Ni48KIgBH4OfsxIWwCy+OWk1d+2cEmhCD7k0/Q+PpiWPgx530FT6wy4rLvdPWY7m1ku+3xI19D1kn4ebL80LFA0fLlqD09cR7asr/SlxQBQPnxKrOV2QTnNkCH0aCxpZNHJ5KLkykzlFmeZMizUFksh5VWUZmQSOm+aNxvn4Gk0SDZ2ODQvTsaDw/MwkxKcQph2mtr7WiJhjh5fZ18GdZuGCvOr0BvkndBB5PyCWvjhKezHZxdC86+MHeVvDtY9YhcrO06cWvPdsRnl3Du7ClYPB29nRtTi5+mR7dIOnQMB49QeUfQRLq1dcNOo6rfPKRSQe97IXkv7P5YTjTc+T4YK/m0chJTo9o1WYb6aNKeWJKkDc0tiMKNSamhlC0pWxgTMgZ7jZxgdG/Xe6k0VfLMjmd4Zscz3LfpPv77nzlUnDiBx6OP8EH813x1pxf2Xbtw8fkXMBbIb1r+Tv542blzoihB/oNq0xHz4lkUL3itRsctY24uuu070E6ahGRj06L3l1SchE5rg8bHm/LjsiPbeGwj5alFED4BgM7unREI67sCv+6y0oj5EvSlABT++gvY2OB22221hmeXZVNpqiTI9frF6s/sNJP8iny2JG/BbBYcSsqnT7AHGMrlB1zn8fJ9jX4Lzm+C/V9fN1nHd/PDTg3uq+/CbNJzj+EfmJ18eXNy03YAV2OrUREZ4GY9n+BKes6FNp1h65uwaCoc/JYY55GUOQfXrnXUjNQVPhpl5dMLaLniKAo3FH8k/UG5sZzJYZdjskO0IczoNIOk4iTiC+MxGvR0XXGcNE+Yqv+MI9lHuK//47T991uIykqKVq8G5LfV7pIDJ+xt5bfou9aRn9mZ9E+WkvvR69XzF61eA0YjbtNqP0Sbm8SiRIJcgnDo3oPSvXtJun0m52c/R9LmNlQi17np7NEZsOIwvsSQ5+SiZYd/xFxWRuGKlbjefDOaNm1qDb1U4iHQ9fqVcOjv359Al0B+Pfcrcdk6iiuMsiK4sA0MZdVKkL73yyaRHe9WK7nWRutow0PBWfhUXOB75wc4UNKGz++IwsOp+UqO9Avx4PTFBvQ2dvKER/fDc/Fw11pKR3/Ck/nTmNKzLWpVy4Xc1rUjOAh8BHx81ecjwK2O6xQUGoQQgpXxKwlyDaJHm5qFtF7p/wo7b9/Jmilr+KxiMn45JhwfmUdX3x4MbjuYqR2mYt+xIw6RkRQu/U227xor6Z6TRLKNDQV2TpiFDfknBEiCvMWrqExMRAhB4fLlOERGYldHG8rmIrEokRBtCE6DBmIqLESU5uMZoQMJirftBmRTiqutK2cL6igxEdgPgofAvv9SvHYNZp2uuofw1VxSBEEu129HoJJUzOg0gyPZR1h/Vk4w6xviAWfWyRU5g6vyECRJDsesKISji6+bvDNs91Ii7Pk4rTP/vCW82RPe+oR4YBZwOLmB/ZKd20DIUJZxE9lmV6ZGtWzIbV2K4AzwoBBixNUf4Pp5dxT+NqxLWMfR7KPcEX6HVdtzRWwsme+8i0NUFANnP8MXN33BV6O+QqOSnWZu06ejT0ig/MgROLOWHiXyH9rJ3JMU/rYMU0EBbe8fiaQykfnPFyg/egx9QkKr7AYMZgNpujRCtCG4zZhBx/3RhIwvw3uoB469eqH7YxMg72Q6e3QmLt+KaegSQ55FFGdQ8MN87Dp0wKFXL4vDUnWp2Kps8XHyae5bahRT2k/BRmXD1tSN+Lja0U5rA3EboONYUF9hkgvsB+36QvTnsv+ktdGX4Z++iV02gxgXFcZdA4ObfYmoQHfUKqnRTe5XHE0nws+Vzr61O6M1J3UpgtfrOP94fRNLkhQgSdJ2SZJiJUk6LUnSkxbGSJIk/Z8kSfGSJJ2QJOnaY90U/hLklufy3oH3iGwTye2dbrc4xpCVRerDj6DWamn7n08tKgvXcWPl8MmlS+Hgd0Q4+KKW1JzIOELe99/j2Ls3rg+/jXdUJWVHTnHxxReRHB1xGdv4JuuNwqgnfv83GIWRYHsvJJUKdeJ62Yl906u4jBlL5fl4Ki/IlSo7unckriCuVoG3GoQOp0LVlYqkLNxun2FVeSYXJxPgEoBKug6lxMxmOUcg+ku0pXl08uhEWvlZ+gR7ICXvk53DnSfUvm7g41CYLEdTtTZn1yHpdYye/TSfzIhskaxnJzsNXf1dOdAQP0EVFwvLOZ5ayORI/2aX52rqyiNYJoSwaLQUQqxqwNxG4FkhRATQH3hUkqSrWxeNAzpUfR4Arm+GiUKr8c7+d6gwVvDGoDcsPrDMpaWkPvwwZp2OgK++xMbbciarytER14kTKN6wEVN8NI6976Oje0eM67dizMzE88EHwcEdt1lzcPDUY0hJwXXsWNTODS/J3CjKC2H7u4j/dCVj95sABK97ETa/Kj8g/aOgy1RcRo8GQPeHHNXU2aMzFaYKknV1lHCWJAoyQ1BpzGg7WI+ySSlOuX7+gfjNsOtD2PQS/F9PItLPoLZJ4HabHXKylMZeLrJ2NZ3Hg3sI7Pu/1o8gOrYEtIFogq8t+a4++gR7cCy1kApDw3Y9e87LhpfhnSz/7jcnLfbKIITIEEIcqfpeh2xqutrQNRn4WcjEAG6SJLVMxoTCn4bNyZvZnLyZhyMfJlRruTFIxhtvUHn2HP6ffIx95851zuc+fTpCr6coxQUi59DDoyuRmxKw6xJR3WlMGvQYvv3LsPVyxGPOHc1+T9X8/izsfJ9sp068r5JzFJy9B8tlIorT5YqVKhU2Pt44REVRvOmyIoC6HcbGggKK955EG+GA+uB/5bfvqzALM6m61OsXMRTzJbj4yzWTxrxLsHDBoBL4x70NJ3+D9qPA1oISVqlhwKOQfhjOb4aji+DHCbD0zpaVtygdEnZAj5ly+GYLMjLcG73RzEOLDlOur18Z7I7PxdvFjo4W+iQ3N62yd5QkKRjoCVyd4dMWuLKDdxq1lQWSJD0gSdIhSZIO5eTUTrVX+OtgNBt5b/97hHuEVyePVZOwA2LXUH78OMVr1uL5wP24NKAOkH2HEOw9TeSd9yDlyReZ9NxafPLN6GaNubzNd/HFfsRMwsakYN+uhSpfGsrh3Ab0kXdyS9FcMrziMZcHsdTnVTkhadavEHy59o/rmNFUnj2LPimJUG0oGpXGeoYxcu6D0Otxv+cByD0HZ1bXGpNZmonerL8+O4Ks0/LPsO/9ciLcgEfY7/EyACfGvQO3fQfj3rd+feQd4OABS6bD6iqlELtabgbfXJgMclbzid9kM9XJpYCQFcFVlOhL2Ji4kRd3v8hvcb9d89IDw7x4d2o3dsblcNf3B9BVWG9GZDYL9sXnMri9V6sU6GtxRSBJkjOwHHhKCNGkn6gQYoEQorcQoncbC+FyCn8djmUfI7s8m/u63Vft8AXk2jtL70L8OpfsZ+5A7eqE5333NmzSM2vx6FiEqUKuw68dMpxvJ9nzm89VZpaBT8jOyEYUcWsUF7aBoZRFxd0od/sRe42K9tL97LuQKz8YO42tMdzlZrnOUPGmP7BR29DerT3nCizvCITJRMEvv+LYpw92Yx4Ezw6w66Nau4LrGjEU8xVoHOQCalWcTbVHJeyI1edCt2mgrSMpytYRxn8MfR+A+zbDjIXy8YxjzSfjxhdhy+uwYh58EAY7P5Sbw3hejiCrMFbwzz3/ZOivQ3l+1/NsSNzAp4c/pcJYfzez+pjVN5DPZvbkSEoBMxfE8PuJDIrKaiuEM5nF5JXqWzR34ErqVQSSJDlKkvQvSZK+qfp3B0mSLHh7LF5rg6wEFgshVlgYkg4EXPHvdlXHFP6mbE/djo3KpnZVzHProaKQUvfbKUs34dU+HfVPo+DEUrkjVF0c+RltpC+djx4ldOUKAj/4EJcpk9mU/Ac6ve7yOI8QuWfsoe8tFnG7ZmLXYLTT8mHuEdQOqfx78BsMDw3nVHqRxT92G39/7Ht0R7dJjh7q5N7JqmmodM8eDGlpcsioSg1Dn5Obo8TVzO1M1ckb7FbfEZTmyj+ryFly6QigtNJIfHYZPnbtOZ13up4Jqug6FW75EAL6gn9VW8aLR5tHxgPfyKU6Bj4O922BwU/J7SIHP109pERfwsNbHmbthbVM6ziNn8b+xFejvkKn17ElZUuziDGphz8L7uxFemE5jy45Qs9//8GM+dGk5l/OLN8bL/sHBnf4kygC4AegErjUIy0deKu+iyR5P/MdcEYI8YmVYWuAO6uih/oDRUIIy9XGFP7yCCHYnrqdfn79cLK5yk58bAnCuS3Z2zKxCQjA/fnPQKWBFffDF33k+HNL5F2ApN1yPfcrbLzTOk6jwlTB+oSreu4OeVYu4hb9efPenFEPcRv41qELGs89TAmbxpjgMQxq74VZQIyVevSuo8dQERuLPjWVzh6dyS3Ptdhcp2DJ/1C38cLlpipHa9dpsnN15wc1nKvJxcnYqe2sloluMQ79AKZK6PdQ9aH47BIAOrpHcDb/LIbG9mV28pRr76Rbb33ZYC5sk3sJdBwHo96AgD5w06tw/9bq5vH5Ffncu+lejmUf470h7/Fyv5eJ8omiv19/2jm3Y+X5ldcuRxUjO/tw6J+jWPbQAB4b0Z6T6UW8t/GyWXD3+Vw6eDvj49o67TwbogjChBAfAAYAIUQZ0BCj1SBgLjBSkqRjVZ9bJEl6SJKkS78t64EEIB74BlA6oP2NiS+MJ1WXyoiAETVPFF+EC1spquxHZdx5vJ95GqnnDHhoD9y+WDY3LLsX8hNrT3rkZ5DU0GN2jcNdPLvQyb0Ty88vrzneq4P81nnw2+bt9pS0i8rKIr51ysfdJoB/9v8HAJEBbjjYqNkXbzn1xmWMXMlTt2kTXb3kkgZXP3AqExIo2bUL9+nTkWyrsl3VGrlfbsYxWRlknACTgZTilNYPHb14FA5+IzuC23SqPhyXJe/G+rWNxGA2WC+hURf+Pa99R1CaB0vvlks33PaNvKO6CqPZyP1/3E9CUQKfjfyMW0JvqT6nklTc2uFWDmQeILU4tda1TUWjVtE72INnRnfi/iEh/H4ig5NpRVQYTBxIzG+13QA0TBHoJUlyAASAJElhyDuEOhFC7BFCSEKI7kKIyKrPeiHEfCHE/KoxQgjxqBAiTAjRTQhx6JruRuFPzfZUuSfr8IDhNY6bDiwk+5gTGf87hH23btUPR1QquRTBnOXy7uCPV2pOaDLIoX8dx8jNwK9AkiRu63gbZ/LP1DZLDHkO9CX1twZsDGfW8r3Wk0rbMl4d8M/qukm2GhV9QjzYd8HyjsC2XVvsu3aleOMmerTpwdjgsXxx7Isa7R5zP/8cycEB9zlzal7cfSb4RcrtLb8eAu8GkJx1rOUihoSAxN3y23XiLtmR++MEWDBcdpQP+0eN4XFZOuw0KoYFyelBp3JPNX7NtlFyfkFpHR2+6iNhO1QWwcTPwM5yT60NiRuIK4jj7cFvM7Rd7UKEk8Mmo5JUrIxvvl3BlcwbGoq7ow0fbDrLkeQCKo1mBreSfwAapgheBzYCAZIkLQa2Av+o8woFBQtsT9lON69uNcwWxevXk/DCT+SdcUE7cSIB87+q3R/A1U+2iZ9dJz+ELnFqOZRmQ9RdFtcbHzoee7U9y+Ou2hX4RED4RIiZDxVFVuUtKjfw7NLj9Tc4N5vIPPc732qd8VH3ZlRIzXj0gWGenM8uIbvYsrPRdewYKk6dwpCezmsDXqOtc1ue3/U8BRUFVJw7R/H6DXjcOReNh0fNCzW28MAOuUzybd9hCuhDmr6AQE0LNRA8/j/4aQIsvBV+miiHduYnyIXjnj4l2/WvIC6rhLA2zgS4tMXdzp1TeU1QBJf8BBnXsCtI2iOX/L4011WYzCYWnFhAR/eO3Bx0s8UxPk4+DG47mFXxqxrU76KxuNrb8OiI9uw+n8unW+LQqCT6hXo2+zrWaEg/gj+AqcDdwP+A3kKI7S0sl8LfjKzSLE7lnWJkoBxbL4Qgd/580p95Fo19JcFv3oX/u++g8bTyyz/gUdkmvuFF2R6/9zNY9TD4dJVNEhZwtXVldPBofk/4naLKqx74Q56V3xJPLrN47cXCcmbMj2b5kTQWxiTVfXMpMfzX3oQBiX8NfKHW6UFh8pudtV2By1g5mki36Q+cbZ35aNhHFFQU8M89/yTn//6LysUFz3vusby2JMllkrtNI2PsWxgkiaDE6OZPyjKb5NLIPt3g3k1w9+9wz0Z48rjsfLXX1rrkfJaOjj7OSJJEF68uTdsR+FXVoEq/RkUQOEA2p1lgc/JmkoqTeKD7A3Wa1KZ2mEpOeQ570/c2XZY6mNM/CD+tPQeTCugZ6NZivQcs0ZCooa1CiDwhxO9CiHVCiFxJkra2hnAKf35S88t4a10sBaX6OsftSN0BwIiAEQizmay33ibnP5/hGuVH8LgyHCY/WvdCGjsY844cPz9/kJypGz4R7t1o9Q8cYHb4bPQmPXdvvLtGxyz8IkEbIMe9X8XZzGKmfrmPi4Xl9A324GhKIUZT7eStSxw7+gNrXJzxMY9kWGjttpcR/q5oHWzkMFIL2LZrh32XLhRXRQ+Fe4bzQp8XSD+0i5KtW/G4527U2toP2qtJMcrVOwMvnpD7HTQnsashLx6GPguB/eV8iKABNWsGXYGuwsDFogo6+Mi7k65eXUkoSrDec8Ea9lo5VLapfgJdJuSdr5G/cSVmYebrE18Tqg21uhu4xNB2Q/G092TFeUsBkNeOvY2ap0d1BGBw+9YNk6+rDLW9JEkegJckSe6SJHlUfYKxkPSlcOMRn61j+vxovt2TyJc74uscuz11O4EugYS4hnDxxRcpWLwYj9nT8Y84i9TtVqu22xp0GieXLM67IJsjpv9U73VdPLsw/+b5ZJVlMfv32ZzMOSmfkCQIGSZHHF1R3+dAYj7Tv4oGYOlDA7ijfyBlehNnM3WWpofss/yYsQMno4on+j5hcYhaJdE/1IO98XlylVQLuIwdQ8WJExjSZWV1e6fbuWefHWWOajzubFh2bYouBYBA1yA5Xt5w7XHvgLy72P2J/EAOn9SgS85fihi6pAg8u2IWZs7kn6nrMsv494SLTYwcSq56e7dSPmJbyjbiC+O5v/v99TrYbVQ2jAoaRXRGNAZzIyOgGsjUqLa8Mj6cO/q3bvhvXXf+IHAY6Fz19dJnNdDMsXcKfzVOpRcx4+sYTEIwuL0XC2OSydFZjiEoqixif+Z+RgSMoGTjRorXrMXr0UfxiSxEMutl+39DkCSY8TM8dlA2RzQw47KfXz8W3bIIB40D92y6h11pu+QTocPl7NJMuWHM1jNZzP1uP96udqx4ZCDhfq70Dpbt8kdSLJQPNpth3VPE2tkiDF24pUuwVRmGdGhDemE5cVklFs+7VjnIizf9gTCZyPn0P3SKK2NFP8Hp8oQG3WdycTIOGge8x3wgO1j3WIvabiRxm+RieUOesRhxY4nzVRFDnaoUQRevLsA1OIx1GVDchMjypD1g6wK+PWqdEkKw4MQCglyDGBs81sLFtenn149yY3nT7qMBaNQq5g0Jxcu56R3RmkJdRec+E0KEAM8JIUKFECFVnx5CCEUR3MCcz9Ixa0EMDjZqfntwAG9O7oLeaGbBrgsWx69PXI/RbGS870iy3n0P+y5d8LptmFyErO/9so27odg518gCbSih2lCWjF9CmFsYT25/ki3JWyB0GACm+O0sPZjKAwsP08nXhd8eGoi/mwMA/lp7fF3tOWSp3+zRnylNjSFDoybUo0udjUNGR/ggSbDhlOWHmW1gIHYR4RStW0vaI4+St2ABTrfdyo6Bziw5u6RB95iik0NHpbAR0P12Oaw0bhP7LuTW7/C2hhCw+yNwC4RuDW/cHpdVgoONmnbu8v+jl4MXPo4+Td8RQNPMQ0l7qkxYtc2H+y7u40z+Ge7relWWex309e2LhERMRkzjZfkT0xBn8X8lSeoqSdIMSZLuvPRpDeEUalKmN/LgwkPV8dnXi692XsAsBMseHkCwlxOhbZyZEtmWhTHJ5JbU3hWsPL+ScI9w3H/eiDE3F9/XX0fa9oZs1hn6fKvJ7WHvwbejv6WrZ1ee2/kc7xzeTLptCAe2reCF5SfoF+LBkvv71+hMJUkSvYLcazcU0WXBH69y1Ed+0xwQ2KXOtb1d7ekT5MGGk9YfyK5jxlIZe4aSvXvxfe1VAt56mwkdp7ApaZPFJLOrSSpKuhw6OuE/4NcdsexePl2ylocWHea7PRbyMOojJRrSDsKgp6z6AywRl6WjvbczqiuUY5hbGAmFDdvd1MC3O0iqxisCXRbkxln1D/xw+ge8HbwZHzq+wVNq7bR09ujMgYwDjZPlT05DnMWvAf+t+owAPgAaZihUaFYOJhWw6XQWX2yv2x5/Lv9c7SiZZiJHV8m64xlM69UOP61D9fHHRrav2hXU/EM/k3eGM/lnmCX1o2DxYtxnzcTBMVsuVzz0+epyBK2Fi60LX9/8NR1cu7Ek8X0+dPCml3SO+TO78OM9fS1GakQFuZNeWE7uhaOw9//kZus/jANjOb9ohwMwvmP9rTTGdfPlXJaOCzmWzUPaW6fgPHIkQT98j/usWUiSxKzOszCajSyLsxzddImcshxSdCl08+omH7B1hJlLqJTs+MjwDgP84N/rYq3u2qwStwlUNhaLstV5WZaODldVzQzVhpJUnIRZWHe8W8TWEdqEN14RJO+Rv1pQBKfzTrM/Yz9zIuZgq25cS8p+fv04nnOccmN54+T5E9OQPIJpwE1AphDiHqAHUH8Ig0Kzczy1EIANJzMtvnkDLItbxvS10/no0EctIsPi/cnoTeZaXZwu7Qp+jk6qIduq+FXYSjZ0+ykatYcHbZ56Si765RYoFxe7DjjaOBKgfxxKu7DVI4OXvVwY6hSHrcbyn0PvIHckzDj9djts/pdcJlnbDm6dz8HiXFTCnlD3AIvXXsnYrr4AVs00Nt7eBHz5BY59+lQfC9YGM8h/EL+d+61OB+XBzIOAbLq4hHBty8t2L+GnKmCx9xLGd/fjnfVn+XZ3I97Kk/ZA216WS0dboajcQFZxZbWj+BIh2hDKjeVkljbBTNW2ymHcmLDYOvwDP576EWcbZ6Z1nNZoUfr59cNgNnA0q5lqIP0JaIgiKBdCmAGjJEmuQDY1C8UptBLHUwtxd7RBbzKz9FDtVPeFsQt5I/oN1JKa/Rn7a0WoFK5cRdG635u8fqXRxKKYFEZ0akNom9o10h8b2Z5Ko5mf9iXJ402VrEtYxyTngRhOnsbr/nmoDTmQcRwGPCaHhF4HSiqNbDyVz3ifF3m6xyNsdnJk9oE3uFhy0eL4CH9Xetsk4VCRBZM+h+fPw11ryAwYT7EpFW/7oAaVCvbTOhAV6Mb6k41zes4On012eTZbU6xHbR/IPICLjUt1XwOQd5Arsv05H3onqrgNfDahLUM6ePHljgtWo5dqUKmT38KtmFascclRfHUd/TA32bdzobCRuxIA7y5Qlid/GkrSHjnU9Sr/QJoujT+S/2B6x+m42DY++S7KOwqNSkNM5t/HT9AQRXBIkiQ35FpAh4EjQHSLSqVQCyEEx9MKGdnZh/6hHizZn4LJfPmP+duT3/LBwQ+4Oehmnu71NBmlGTXi5oVeT9Y775D11lsIfd0x/9b4/UQGuSWV3DMoxOL50DbOjAr3YVFMMuV6E9tTtlOsL+YWg/xwcoiMhPiqh1mHumO2W5LfT1ykTG9iRp9A7o18mK/NXmQZdLy852WLZgsbtYpZrqcwoZI7aVWxMy4btX0mXdvU3TjnSm7p5sfpi8Uk55U2+JrBbQfj6+TL6vja/QcucSDzAL18e6G+Iqrnh72JuDnaEDbyHhAmNGfXMKKTN/mlenKs7ChrkLofhKnRiuBSZFQH75oP2UtNiBKKmuAn8JLj68ltYL2iOvwDP8f+jEpScUd40xoUOdo40t2r+9/KT9AQZ/EjQojCqvpANwN3VZmIFFqR9MJyckv0RAZomdM/iLSCcnbFyaWUM0sz+ezIZ4wJHsMHQz9ggL9cKPZQ1uXSTaX792PW6TAVFlKye3eD1oxJyGPeTwf534EUCsv0/LA3ifbezgypoxjWvMEhFJQZWHo4keXnl+Pn5EdgpgnUauw6dZJ9Ax5hjYsUamaWHkqjvbczUYFuAPQPGcMLeXkczjps1RY/xHyQQ+ZOVNhctopuiYtDUpfTx//qDqzWuWQe2tCIKB6VpGJi6ET2XdxHdll2rfMZJRmk6lLp59uv+lhqfhmbTmcyq28g9u26gXcEnFxGZ1/54RyXadlPUYOkPbJ/4KrSEfURl6XDyVZNWzeHGsfd7d1xt3MnsagJTmuvDvLXhiqCIz/JX6964UgvSWfl+ZVMCJ2Aj5NP4+Woop9fP2LzYlvMF9faNKhEoSRJ3SVJmgREAe0lSZrasmIpXM3xVPkXrkeAG6MjfGnjYsfCGLkJyaYkOSP1iZ5PoFFpCHMLw93OvdpuDFC8aRMqJyfUXl4Uraq/5bQQgn+vi2X7uRxeWnGS3m9t4WR6EXcPDLZoBik1lLIodhEfnnoQbec3+CjuVmIyYpjcfjL62DPYhYbKIeiJu62WhGgN4rNLOJxcwIze7S7fR+gwpuhK6OcaxqeHP61tw85PpE35Bf4w9ar205jMggPpsQB0cO/Q4PXbuTvSo52WDY00D00Mm4hZmPk9obZp70Cm/Gbax/eyb+Hn6CQkSeLOAVVRRF1vg9QYOjvI8p/NbECPqCb4BwDOZ+to7+NSI2LoEqFuoU3bEWgD5H7HuefrH1teAPs+h07jwedyNJfRbOTFXS+iUWl4qMdDdUxQP/38+iEQHMr8e9TJ273S0QAAIABJREFUbEjU0PfA98BtwMSqT4Ma0yg0H8fTCrFVq+js64qtRsXMPgFsP5dNan4ZGxI30MWzS3UzEpWkordv7+pfUmEwULJ5C84jRqCdMAHdjp0YCyzExV/BjrgcTl8s5t2p3Vj3+GDuHRzCmC4+TI2qmVRebiznP4f/w82/3cz7B9/HTmNHH69RVObczMyQZ7mnyz1UxMZiHxEhZ3kay6+rIvjtcCpqlcStPa/olNW2N5LKhtfs22M0G3k75u2aNvRzck+DzeZe7E+US1efSi+ijDQAOrp3bJQM47v7cTytiJkLoll34iJ6Y/1RNCHaELq36c6aC2tq2fcPZB7Azc6tWiGV6038ejCVsV19L0d2dZOdoh6Ja/Fytq0/BLmyRO4D0EizEMimoY7elvvshmpDuVDYQB/FlahUcmZzQ3YE0V/IdaRGvFzj8IITCziWc4x/9f8XbZ2vrThCd6/uOGgc2J95dffdvyYNyaLoL4Ro+N5XoUU4llpIhL9rdWTLrL6BfLE9ngXR+zmdd5rnetfMzu3l04vNyZtJL0nH7UQypqIiXMaMxjYggP9v777jo6rSx49/zpT0TipJgITQIUDovaigKGBvuJbVtevadXdd1y3+LLt+1bWsFbF3UUQUpHdIaCFAICGB9Ep6n5nz++NOQnomjQHmvF+veZG5c2fm3Nwwz9xTnufUsmWUrlqF35KWfaQWaaGspow31ycT6uPKFWNDMep1jAxtOVGssq6SB9Y/QGxOLBf1v4hbRtxCdEA0dWYLMw9u4NBRd5yGVWDKz8dl+DBtfEDvbNOHy//9dozyahPPLOy5P706s4Xv9mQyd2ggAZ6NBqoNThAwlPDCE9w/9n7+E/cf1qWt48L+1oCVuAoChuFtGcz//XaMbckFeLka0Tvn4O8aiLdz5ybR3To1ApNF8vmuNO7/fB/BXi4s+/0EhgZ7tfu8xQMX88+d/+TwqcOM6KN905VSsjtnNxOCJzSkSPgpPovSahM3T26Ujtp3AIRNgIPfMThoCkfbSplRL31nl8YH0k9Vkl9Ww9CQ1o8l0juS0tpSCqsL8XftZJplfxtyDlWe0kpmDr8cgkc2bN6bu5d34t9h0cBFTWoNdJVRbyQmMIbtWduRUp6RusK9yZauoR1CCBUI7MhktnAwo4Qx4T4N2/r6uDJzcAA/p2jJxeYPmN/kOfXdBHE5cZSuXoNwc8Njxgxchg7FeehQSn5c0eJ9pJQ8sfkJ5n+3gD0ZGdw1KxKjvvU/kYq6Cu5Zew9xuXE8P+N5Xp79MtEB0YA2uHrr1AFsP17I0a3aVYnL8OGQvFbL+eLk1u7xFlXU8vam4yzdlsp+a1dMT1ifmEdBeQ3Xjm9l0lvQCMhN4KZhN9HXvS8/HrcOzFaegrTtMHQBH942gcfnDyGntJrfDufi7pnPED/bu4XqORl03Ds7ik2Pz+HDW7XzdOvSWLJL2p+XPn/AfJx0TqxIPn3u0svSyanIaTJt9NOdJxkc5MHEiGZrNEZeDbkHmeZdyLHcciyWdr6Vn9iq1YDo5PjAigPazKt5w1vvf68fMO7aOMFgLXVGezmUtr0GtRUw+ylKakrYlrmNtw+8zeObHyfUI5Q/T/pz28/tpIv6X8TJ0pO9lm7iTLIlEHyMFgyOCiHihRAHhRDxvd0w5bSkvHKq6sxNAgHAdePDqXbaS6TnSILdg5s8FuUThY+zD3uyYyn77Tc8Zs1E56IVS/FevJjq+HhqUpr21a4+sZrVJ1ZTYSrFO3hL6x+YaFcCd/92NwfyD/DizBdbXZlZ/9zUHVqyMOe+HlrmUBu6hb7bm0GtyYKns4EXf0ls0o1gsUjKa7qWD/7TnScJ8XZhzpBWMjsGj4SybPRVxcwIm8Gu7F3UmmshaQ1ICwy5FH8PZ+6bE8XGx2bz1V0TsBhzGezTuW6hxvQ6wZyhgXx42wTKa0zcujSW0uq21wp4O3szO3w2q1JXNZR9rB8fmBiifWAfSC8mPqOEmya3MqV1xBUgdMyq3URVnZn0onYygXZhfEBKyfd7M5g4wI9wv9aDfaSPFgi6NIXUf5B2Lk61McZQng+736V05OW8cOJHZn01i7vX3s1b+9/C29mb/8z6T8sSqd0wb8A8nPXOp7809ICSmhKe3/U8GWUZPfaatrAlEHyAVnLyYk6PDyzszUYpTdUPUI5uFgj6h5Sid8mF8pYFN3RCx7igcRTu3Ir51KmGpGYA3pddCno9JT+c/gMuqCrguV3PMdBrGHUlY8FrG8W1rRd4X568nP35+3lp5kttJuvydXfSZo0kHcWpf3/02dYZx1HtTxuVUvLZrjTG9ffl0XmD2ZFSyOYkLb1CWXUd176zgwtf3kRVrbnd12nuREEFW5IKuH5CPwytXeXUDyrmJjAzbCZVpipt1lXiz+AR3KSoiRACf98yTJa6Tg0Ut2VYiBfv/G4cx/PLuevjPe2OGSyOWkxxTTHP7XqODWkb2JSxCX9XfyK8tCm9n+48iZuTnivGttIH7hkEETMZmvYlU3UJp7uHLBat5vB3d2jppitPdWl84FBWKcfzK7i8tfe2CnILwt3o3itTSOXhH1nhLFhYl8znRz7nykFX8v6899l2wza+X/Q9w/v0bMeGp5MnF/S7gF9Sf9G+NHRTRV0F9669l88TP+eDhA96oIW2syUQ5EspV0gpU6WUJ+tvvd4ypcGBjGK8XAwM6NP0W9batNUIBIeSBrS60nhC8ASi9uWBszMeM2Y0bDcEBOAxfTrF332HpboaKSX/2vkvKusq8a+6GWPpJQidlpmxNWtOrGGQ7yDmDZjXbruHBnvinZGKc/34gHe/09MA27DjeCGpBRUsmdSPGyf1J8zXlRd+SaSkqo5blu5mb1oROaXVfLunc7VjP9+dhl4nuH5iG2shg6ypGXIPMSF4Ak46J7akb9Iqog2erw1WNpJUpM1e6YlAADAtyp+Xro5mR0phuym9p/adyqywWfyQ/AMPbniQjekbmRA8ASEExZW1rDiQxeVjQ/F0aSMv0GWvILyC+cT4PO6xr2vfrj9eBCsf0moYfH0zvDKyS+MDy/dl4qTXcemokDb3EUIQ4RXRtUBQn2ywjZlDHyd/x18C+hDm1Y8vLvuCZ6Y8w6SQSV1aNGarxQMXU1pb2lBvo6tqzDX8cf0fOVR4iEG+g1h9YjU1ZhvWevQQWwLBPiHE50KIG4QQV9bfer1lSoP96SWMDvdBCEFZbRnx+fH8dPwnfkr5ieg+4zHVubN8b2aL540PGs+YFEn5mIHo3JteEvvd/nvMhYUUf/sdK1NWsi5tHbePvIfNh/VcOWoUVw+6muVJy0krTWvyvLzKPPbl7euwiAfAKG+Bf1kBxkEDtQIwURd0mDr6s91peLsaWTAqBCeDjkfnDeZIdinzX9lMfEYJby0Zx5hwH97bktpkQV17quvMfBOXzrzhQQR5ubS+k0cAuAdCbgKuBlcmhExg68l1Wm3jqAta7H6s6Bh6oW/o8+4JV8aEsWh0X97acJzkvNYHcw06A29c8AY7btzBRxd/xFMTn+KBMQ8A8O2eDGpMFm6a1E7NYr9I9H9Yz0bDVKadeANeH6et9F74X3jyJCz5VjvekDEQPtnmtpvMFlYcyGLO0AC83dpPThfpE0lqcRfGCJzctWmkrVwRHC1M5LXadObofflkwacNg+m9bVLIJALdArvVPWS2mHls42PsytnFP6f9k0fHPUpZbRlbMmxb79MTbAkErmjF6uehpo+ecZW1Jo7lljEm3IdjRce48JsLWbJqCX/e+mfyK/O5ZdQNxPTz4au49BZT8gY6hxJcDLE+p1rMjXebMAHXcePIeect/rX1WWICY3CpmE2tycJ1E/pxZ/SdGHQG3jrwVpPnrUtbh0Qyv3/TwenWjKjMBaC27rj2gdpB4rL8shpWJ+Rw9bgwXIzaCtnFo0MZFuJFYUUNby2J4eKRwdw9K5K0U5U2p1ZedTCboso6bprczgckaOMEudrA34zQGZyoyiXNYIQBM1rsmlSURH+v/p1OWNaRZxYOx81Zz1PfHWx3MNfV4EpMUAxLhi0h3Eu7yvkqNp2Yfj4M79v+7COcPfgi/FnedP6Dllr63p0w7hYtFcOgi+C6T+CuTR0O6je2/Xgh+WU1rXdJNRPpHUleVR5ltV3IouvfcgpptamapzY+grfZwt8HXd9hgZmepNfpWRi5kG2Z22zKENuaHdk72JixkcfHP87CgQuZFDIJf1d/fjr+Uw+3tm22rCy+rZXb789E4xTYlXoKs0UyOsybF3e/iFFv5L9z/suPl//I7iW7uaj/RVw3IZzkvHL2pjWdYVOXcgKAg57FXLniSlalrGp4TAiBvPkqRP4pFhx145XZr/B1XBbRYd4M7+tFgFsANw67kVUpq5rMilhzYg0DvQc2DPoBYG598LZfgXY14XdqhfZh2q/9b5hfx6VjskhumHi6OpNOJ1h22wRWPjCDeSO0AfGLhgczoI8b7262bT76pztPEunvztSBHRQDDxoBeYlgNjEzdCYAW4IHtsiQWllXya6cXcQEdZxxtLP8PZx5+tLhxJ0s4rPdaR0/wSq7pIqkvHIWtNMt09iQEC9eKZtLzaL/gXf3Cw7+sC8TLxcDs4cEdrhvt1NNFCQ1ST736t5XSS5P518FhfhGdfwFpactilqEWZpbXexni03pm3A1uHLd0OsA7apvQcQCNmdupri652bNtae9UpVPWP99XQjx3+a3M9I6hc92puHv4YTJ9SC7c3Zz35j7mNNvDpHekQ3fRi+N7ouHs4F3NjWdiVGTrPU1P3ndG0R4R/Dklie55ZdbePvA2+zI2sGDFR9wIkTPdbuNpOdaSMwp47oJp/vQ7xh1B34ufjy/63ks0kJBVQF7cvc0HRtIj4V/R8LRX1u03S3tOBWuLriLApjVsqh7cyv2ZzFxgB9RzRYjBXm5MCT4dD+vXif4w8xIDmSUsDPlVLuveSS7lL1pxdw4qV/Hc72DRoG5BgqTCXf2YUBdHVs8WvYvb0jfQJWpiksjbM9j3xlXxYQyPcqfF39J7HBKab3tyVoytqkDbZubPyTYC5NFkpJve86jtlTWmvj1UA6XRoc0XMm1p/5LRJdqE/gPwlJXQcLJDXx86GMe2vAQnx35jCWGQKYZfO2SuiTSO5Jo/+gudQ9JKdmcsZnJIZNx1p9e27Jw4EJMFlND1oDe1t4VQX0poTialqqsvym9LLO4ivWJuVw9PohX975MlE8U1wxuWSXKw9nA3bMiWXM4l92ppz8Ya5KTEEYj/YdN4qOLP+KRcY9Qaarkrf1vcedvd5JZkUXIfQ8iM7LZtfQbXI16Fo3u2/B8TydPHh73MPEF8aw4voJ1J7VuoSbjAzvfguoSWPGANtukkdrDh/HxqyTJaXir3SuNlVbXcSyvjOnt5DFq7KqYMPq4O3WYX/+H/ZkYdIIrY8La3Q9oMnOIk9uZUVlFbG1hi7zzK1NWEuIe0itXBKBdrT13xUgsUvLwV/ttGgvZdrwAP3enhlxCHakvIdkTRY7WJ+ZRWWtm0WjbrixCPUJx0jl16Yogzd2H20ICuWHTH/l33L9JPJXItYOv4aHsDG1w204LuxZELiCpKIkTJSc69bzk4mSyKrKYFTaryfYhvkOI8onip5Qz0z3UXqnK+hZUSik/anwD2pmArNgquSiZlSkr2+ze+GKX1jXg5LeNzPJMnpz4ZJsl9W6fHkmwlwvP/Xy4oW+5JjkZp8hIhMGAQWfgtpG38c3Cb9hy/RZenfMqS+cvZfSVd2CMimLQz59xVaRbi9kmCwcuJDogmlf2vMKK4yuI8I4gyidKe7A8D478pE0JrSqCVadXN5tLSqg9kYq3bzlvWK7s8D9ofHoJUsLYfj7t7lfPxajn1qkD2HA0v81VslJKVh7IZvog/yZVx9rkP1hLspabACmbmFFjplaamuRsKqwqZEfWDi6NvLRX+6L793Hn74tGsDPlFP9rZxYRaMe5PbmQKZF9Ws3v05oIf3eMekFiRyuMbbDyQDYBns4tF7C1waAz0N+7f6fWElikhU8Pf8pVe18gyejE00GzWXfNOn696lf+OuhGXMpzoH/rBerPhLnhcwFYn76+U8/blLEJgBlhTb8oCSFYOHAhB/IPtJiw0Rts+Uv+k43bFBvF58fz4PoHuWLFFfxpy594btdzLdIf15osfBF7kjFD0/kqaRlzw+cyOaTtPnZXJz2PzR/CgYwSVloTmtUmJeMcFdViX29nby7odwFjAscgdDoSb7gPn+pSbvjqpSY5iCyVlZgyMvnzpD9TVF1EfEE8F/W/6HQXy75PwVIH8/8fzHoSEr6DQ8vBYqbgpb+ChLrBofxYPoyiivbnWe9LK0KIlmsl2vO7Kf1xNepbVEVreM30YjKLq1gY3bfVx1swOEHAEMhJgJSNjAuMwc3gxheJXzScn19P/IpZmnutW6ixq8dps4heWZvEnpNtd4GlFlSQU1rN1KgOxkAacTLoiPT34Fg3A0F5jYkNR/O4dFRIuzWbm4vyiepUIFiasJQXY19kQvBElueXcZ3FhUA363jECevsmg6uOntTiEcIw/sMZ31a5wLB5ozNDO8z/PSxNLIgYgE6oeN/B/7X+dxMndTeGMElQojXgdBm4wPLgK4t7XRwdeY6ntn2DEtWLWFP7h7uGX0Pvxv+O746+hXP7TwdDOosdbyy/QeqAl4miTcJdAvkiYkd97FfMVabYfPSr4lUlZZRl5WF86CWgaCxvNJqnk01sPSS+9BnpZN+xx+oTUsj//U3SJ4zl+OXLCAyy8JVg68CYF5/6/iAxQJ7PtT+8wUMhukPa4uufvojtc8OpWj5GrwH1pJ/ydNAx98896UXExXggVdb899b4ePmxPUTw/lxfyZZxS370n86kIWTQcdFIzqRbjhoJKTvhrxDOA2cw4MxD7I1cytLE5YC8HPKzwz1G0qUb/u/154ghOBfV4ykr48LD36xv81guu24Nj4wzcbxgXpDgj1JyCrBZO5k6chG1h7OpcZk4bJo2wap6w3yGURWRRbltTakw0abpDA6YDRvXvAmQX5RTWcOndiqLfqrX2dgJ3PD5xKfH09+ZesLMZsrqi7iQP6BFt1C9YLdg7k7+m5Wpqzkh+SOMwZ3R3tXBFlo4wPVNB0bWAF0ODQvhFgqhMgTQrSaiEMIMVsIUSKE2G+9PdP55p87iqqL+MNvf2B58nJuH3k7a65ew71j7uXx8Y/z+5G/5+tjX/PQhoe4Z+09TP9iOp+m/g2joYZ/Tf0Xyxcvtylbol4n+MuCYWQUVfHux2sBWr0iqFdntnDf53upqDHxwOM3Evb6f6k+dozj8+ZT8OabuI4bh8Hfn6wnnuSxkQ/w/rz3GeI3RHvy8fVQnAbjraUp9Aa4/G1w9SXvUAAYnQh4ex3Bo7XAcbSdtMdSSvalFdncLdTY7dMjkMDSZoXZzRbJz/HZzBkS0KngQtAILXMlQORsbhx6I5dEXMLr+17n66Nfc7Dg4Bm5Gqjn5WLkv9ePJa+smkte29JQg6Kx7ckF9PV2oX8f26d7AiwYFUxuaQ2fd2J2UnMr47MI9nIhpp9vp55X3714vKTjq4KCqgKOnDrCzLCZ2tWo/2DIP6bNHJJSy2o7YJrdxgfqze03F4lkQ/oGm/bfmrkVi7QwM2xmm/vcGX0nk4In8f92/T+Si9rvIuyO9sYIDljHA6IajQ2sAJKllO3nMNYsQ0tL0Z4tUsox1ts/bG71OeZk6Ulu/PlGDuYf5IUZL/DQuIcacp4IIXgo5iH+MOoPbMrYRGZ5JtND5lOVsYS7o95h8aDFbY4LtGb6IH9umdKfhG37ASgKbHuQ9KVfE4k9UcQLV41icJAnHrNmEf7mG/jeeAORK38i/K036fv8/6M2NZWy1/7HpJDThU+IWwpu/jC0UbaRwKFUzlhG2aEi+txxJ8bwAQR6OuPrZmz3iuBkYSVFlXWM7eSHCWj5/RdGh/DF7jRKKk/n6dmdeoq8shoWjraxW6hefcZKV18IjkYIwbNTniXSO5J/7vwnAsElEZd0up3dMbafL9/dMxUPFwM3L93NX5YfpLJWuyi3WCQ7UgqZGuXf6QyY80cEM3VgH15ec4xTHXTdtaakqo7Nxwq4NDrE5rGJevUrsm35cNuRpaUnmR5qXekcOAzKsuCNCdq4VFl2l9Jl97Qonyj6efazeZxgc8Zm+rj0aTf1hV6n54WZL+BudOfRTY9SWdc7w7O2jBH8JoTwEkL4oZWpfE8I8UpHT5JSbgban9vnIP6+4++U1ZXxwfwPWk3QJoTgwZgHiVsSx4rLV2DJvxKnmjFcP771kpAdvt/ikdzaV1KrN7Lw21Re+CWRT3aeZO3hXNYn5vJ1XDrP/3KE97akcvOU/iwec/pqw2PmTIKfeabhSsJ9yhR8b/4dRZ9+Svm2bdpOJZlw7BeI+R1Sb8SUn091YiLl27aR+/zzGAIC6HP77xuObUiwZ7uBYF+69r2iK1cEAHfOHEhFrZlPd53OfPJTfBZuTnrmDu14XnsTQdZAEDETrGUf3YzaOgt3ozuTQyZ3q7JVV0WH+bDygen8YUYEn+9O46b3d1FWXcfh7FKKK+uY1onxgXpCCJ5dNILyGhP/WXO008//7XAutebOdwsB9PXoi6vBleTijgPBlswt+Ln4na7HPOEPcOnL2vqHuA8BARGtd6+cSUII5vaby67sXa0ulquz1LE5YzOxObEcKzrGtsxtzAyb2eGkA39Xf16Y+QKpJam8uvfVXmm7LV81vaWUpUKIO4CPpZR/68Hso1OEEAfQuqEek1Ieam0nIcSdwJ0A/fr1a22Xs9bB/IPE5sTy2PjHGBM4pt19jXoj6acqWXEgi1unDsDXlpkubQgvzaEqMpKhoT68tyWl1SmI06L68JdLh3X4WoGPPELFtu1kPfIobhMnYKAAXaY7NWmpVD07E3NB0xWVfV96EZ3b6W6KocFefB2XjsUiW/3muC+tGHcnfYsat7Ya3teLmYMDGo5z1uAAfjmYzYXDgnBzsv1qCgCPQJhyPwxtunh+gPcAflj8A64G1zae2PtcjHr+culwxvX35f7P9/G7D3Y3lA21df1Ac4ODPLl5Sn+WbT/BjRP7tVp3oi0r47MI9XFtkRXXFjqhI8oniqTi9iuOmS1mdmTtYEbojNMfmE5uMOEO7VZ5Ckoy7D4+UG9uv7ksO7SMrZlbW1w5fn30a17Y/UKTbW2NDzQ3OWQy/5z2z3YnjHSHLf9LDEKIEOBa4C89+N57gf5SynIhxALgB6DVDF5SyneBdwHGjx/fu8PnPWxpwlI8nTy5evDVNu3/7uYUdALumNG1q4F6NcnJeIwfz1d3TcFskRSW15BVoiWY8/dwpo+Hk80fkjoXF8JefYW8/7xMTWoqFWmpWGo9cRpYiMf06biMGIEhKBCDry+GkBCcwpp2Rw0N9qSyVkt73L9PyzTA+9KKGR3u06lZJ839ZcEwnvgunlfWHuP/ftMGEjvdLVRv/nOtbm6e6tteLh4ZwltLBPd9vpf96cUMDHBvO4eSDR66cDAr9mfx1x8T+OrOKQ3Fj9pTXFnL1qQCbp8e0eWiLFE+UQ3TJ9tyuPAwxTXFp7uFmnPza7Hy256i/aPp49KH9WnrmwQCKSXfHvuWYX7DeGT8IxRVF2GymJgdPtvm114ctbgXWqyx5ZPgH8BqYJuUMlYIEQnYUDi0fVLK0kY/rxJCvCWE8JdSdi1hx1kotSSVdWnruGPUHTblQc8vq+HruHSuHBt2usRgF5jLyzFlZzd07+h1gkAvFwK78WHhPGgQ4e+8DWYT8sVIGLYQccWbNj23vlpVYk5Zi0BQVWvmSHYpd83q3orQIcGe/HjfNArKa9h4NJ+Mokpmt1Z34Dwxb0Qwb980jns+3dv57q9mvF2N/G3RCB78Yh/3f76XN5fEtFmQqN7OlFOYLJKL2ihAY4sonyiWJy+nsKqQPq6td21tzdqKQDCl75Quv8+ZpNfpmR0+m19Sf6GkpqShet2B/AMkFyfz96l/77Vv9d1hS66hb6SU0VLKe6z3U6SUV3X3jYUQwcL6VUIIMdHalsLuvu7Z5KNDH2HUGblx2I027f/htlRqzZZWPxTN5RWUbdhA/htvUnWo1R60BrXW1BIdTR3tkuwDiNoSRNQcm58yOMgDo16wPblljE/IKsFkkYwN7/xAcWv8PZy5elwYD104uMMPs3PdBcOC2PrUHB6bP6Tbr7VodF+eXTicNYdzeejL/R1OKd2bVoSTQceosM6V6Wysfgpue+sJtmZuZaT/SHxdeubv40y4YegNVJmqeCf+nYZt3xz7Bneje5v1O+ytwysCIcRg4H9AkJRypBAiGlgkpfxXB8/7ApgN+AshMoC/AUYAKeXbwNXAPUIIE1AFXC97e9XEGZRfmc+K4yu4IuoKm2qzllbX8cmOkywYGUKEvzuVsbFUJx6l5ngyNYlHqUpIAJM2U6TgjTfwuuwyAv74IE7hLfPr1+cYam/qaJelbtT+7cTgnJuTgUWjQ/k6LoM/Xji4ySrffWnaQPGYLg4UO7pAz65f5TV36zStlvK/fj6CRPKXS4drxYVaEXfiFNGh3jgbOs4t1JZBPlpPcFJxUkOFtcaKq4tJKEjgrui7uvwe9jDEbwhXDrqSL458wbWDr8XXxZfVJ1azeOBi3Iydm+J7ptjSNfQe8DjwDoCUMl4I8TnQbiCQUt7QweNvAG/Y2M5zzueJn2OWZm4dcatN+38dm05ZjYm7Zw2kfMMGMu69DwCdlxfOUVH0+f3vcZ86BeeBAzn1yaec+vhjSlevJvDhh/G77dYm/bQ1SckIFxeMzfrqMddppf4MznRZyiYIHKHl7++Eu2dF8t3eDD7afoKHLzpd3nFfWjH9/Nzw9+hGm5Qec8eMSMwWyQu/JvJLQg6zBwdwy9QBTbKKVteZSch1NiO4AAAgAElEQVQs5bZpA7r1Xv6u/ng7e7c5c2hn9k4s0sK0UPuljuiq+8fez68nfuXluJeZ3HcyNeYam8cJ7cGWQOAmpdzdbEBIrSxuh5SSVSmrmB46vSFXfEf7f7E7jbH9fBgV5k3Wm2vReXsTueJHDIGBLQbjAh95GN8lS8j917/Ie+klao4dI/gff0fnpH3TrklOxjkyEtG4qpbFAh9eAjkHtXTQEbO0XPQ+HbevQV01pO+C8Z3PQj4oyJMLhwXy0Y4T3DUrEjcnA0m5ZWxJKmiz0LliH3fNGsil0SF8FZvOV7Hp3PphLD/dP72hGyghs4Ras4WY/t3rrhFCEOUT1eZagu1Z2/Fy8mJkn5Hdeh978Hf1587oO3llzyvsz9/PiD4jGNan4xl69mJLJ2qBEGIgIAGEEFcD2b3aqnPc4cLDZFVk2VTFCyDuZBHH8yu4YUI/pNlM+aZNeMyYgTEoqM0ZGcagQEJfexX/+++n5IcfSLv5FnL//W9O3nwLFbt3txwf2P8pZMTCoHlake91f4dll4KlE7V/03eBqbrLc7bvnjWQ4so6vopNJ6+smls/jMXVSc8j87peAF7pHWG+bjw6bwhrHp6JUS/4KT6r4bE9J7XuvHHdDASgDRgnFye3mktnX94+YgJj0Ou63v1kTzcNu4lQj1CKa4rP6qsBsC0Q3IfWLTRUCJEJPATc3autOsf9dvI3DMLAnHDbBlS/2JWGh7OBy0aHUH3wIOZTp/CYPbvD5wmdjoD77yP01VepPnqUoo8/wVJVhe81V9Pnrkb9qtUlsO4fWunBaz+Ge7fDNcug+CQc60S+89RNIPTQf6rtz2lk/AA/Jgzw5b3NKdzxURxFlbV8eOsEwnzPzn5TRcvnND3Kn5/jsxs+rPecLGJAn57pzhvkM4jyunJyrdXs6p2qPsWJ0hOMDRrb7fewFye9E3+d/FdiAmPO+Gr0zuqwa0hKmQJcKIRwB3RSyu7nrT2PSSlZm7aWCcETGqaOtaekso6fD2Zz9bgw3JwM5G3YCHo9HjNsXzLvdfF8PGbOAIOhoXuoiU0vQUWBVo+2/gpj6ELwCoXd78LQBba9UcomCB0HLh2UQmzH3bMGcvtHceSUVvPezeM7tYBJsY/Lovvy6DcH2JdezNhwH/acLGJWD03NrZ85lFSU1GSdxv48LUXK2MBzNxAATAuddk6Mcdg8v05KWaGCQMeSipM4WXqSC/tfaNP+y/dpBcfryzOWb9iAW0wMeu/OfUDq3NxaDwIFSbDrbYj5HfRttLJZb9ASxqVs0PbpSHUJZO2FyO4t5Z8zJJDrJ4Tzn2tGc8EwNTZwLrhoRBBOeh0/x2dzsrCSwopaxvfvmUVc9cnnmg8Y78vbh1FnbDcPj9Jzzu+J1naw9uRaBFrOkY5IKfkyNp1Rod6MDPWmLjOTmmPH8Jhj+xz9dhWdgOV3g9EN5raS3DXmVtA7Qez7Hb/WiW3ajKNu5nTR6QQvXBVtW8Uw5azg5WJk5uAAfo7PJvaElj6sJ8YHQKuNEega2GogGNFnRJPyjUrvUYGgh/128jdigmLwN7hrVbvasS+9mMScsoargbKNGwFsGh9oV1211h305iTIOwILX219uqdHAAy/HPZ/DjUdXOwl/gzOXhDecr63cv67LDqEnNJqPtiaiqeLgUHN6kp3xwj/EezM2onJok1GrDHXcLjw8DnfLXQu6TAQCCHihRB/ts4cUtpxouQEycXJXBQ6Ez64CF4fDwVtZ1dcnZCDUS9YOFrL3li+cRNO/fvjHNmNPEMWCyxbABueg8EXw/2xMLKdheAT74SaUoj/qu19TLWQ+BMMWdC9NQjKOevC4UE4GXQk5pQR08+302mn23NF1BXkVeU15B06VHCIOktdh0kalZ5jyxXBQrR1A18LIWKFEI8JIc6tFKBnyNo0rRjMBQm/QO4hsJjg0yugtPXZtjtSChkT7oOnixFLRQWVO3d2/2rgxBbI3AOX/Buu/UhL1duesPEQMgZ2vasFkdakbtLGCEZc0b22KecsD2cDc6wDxD3VLVRvRtgMAt0C+eboN4DWLQSoQHAG2ZJr6KSU8iUp5TjgRiAaSO3gaQ5HSsnPKT8TbfQj+OgamP883PyDlib306ugqrjJ/qXVdSRkljAlUku2Vb59O7KurvvjA3s/AhdvbXDYFkJoaZcLjsLRn1vf59BycPaGgT00dqGck+rrVthapN5WBp2BqwZdxfas7WSUZbA/bz8DvAbg53L2ZBU939k0RiCE6C+EeAL4EhgKdFxA18HszdtLcnEyV2YlwbhbYdJdWg3f6z7V6qt+eaPWxWIVd+IUFgmTrYGgbM1v6L29cRsX0/VGVBTCkZ8g+nowdiJ76YgrwDcCNv9HK/3XmKkWEldqU0xVt5BDu2RkMD/cN41JPRwIAK4cdCVCCL459g378vep8YEzzJYxgl3AckAPXCOlnCilfLnXW3aO+eroV3hKuMRrECz4z+n5+gPnwBVva3VVVz3a8EG743ghTnodMf19sdTWUr5hAx4XXoAwdqK+bnPxX4K5Fsbd0rnn6Q0w4xHI3g/H1zV9LGWj6hZSAC0lxJhwny7XH2hPsHswM8Nm8vmRzympKVGB4Ayz5YrgZilljJTyeeviMqWZwqpCfjvxG4tKy3AbdR3om32Yj7oaZjwKez+G3e8BWj73Mf18cDHqqdi+HUt5OV7z53e9EVLCno8gdLxWgL2zoq8HrzDtqqCx+m6hSNUtpPSuawZfQ7W5GlDjA2eaLYGgWAjxgRDiFwAhxHAhxO293K5zyvLk5ZikiWvLymBgG+sH5jwNgy+BX5+i/Mg6DmWdHh8oW70Gnacn7pNtKFiRl6ilhUj4Hg58CUXWOr3pu7R+/s5eDdQzOMG0P0LaDm3NAFi7hX6GoZdqjytKL5rWdxp93fvi6+zLAK8B9m6OQ7El++gy4ENOl6k8BnwFfNBLbTqnmC1mvjn6DRN1HkS6BEJAG0VCdDq48l34YB7O39/CNHEfkyMnI+vqKFu/Hs+5cxCtrQxu7MQ2LVEcjfvxhdb9ZK4DJw8YcWXXDybmd7D537DyYS1DaVUR1KhuIeXM0Ov0/GPaPyipKemV7ielbbYEAn8p5ddCiD8BSClNQohOpKw8v23L2kZWRRaPFFVA1CWnxwZa4+IFS77h1DuXs8z4IpZsDyqyx2IpKcGzo24hKWHts+AZAtd9Ak7u2rbDP8K+T6A0E8bdBs7dWOhjdIULnoGNz8OxX7WVxH3HQuTsrr+monTCpJBJ9m6CQ7IlEFQIIfpwOg31ZKCkV1t1Dvnm6Df4O3kztzitSbfQLwezOZZbzv1zo5oWZfcJ516X53lCvsqktU9TcGwUOmcD7nIX7MuGMTe2HkyO/QoZu+GyV7W5//WChsOsJ7SuoaAeyNse8zvbp54qinJesCUQPAKsAAYKIbYBAWhlJh1eaW0pW7O2cpPHIIwkQMRsQKvg9PQPCRRW1HKysIKXro7GYK2fW1JZx96cOnbM/T8m6pZT9sNHeARVo9vygvaibn1gSLO6phYLrPsn+EXC2JtaNkTX9dTQiqIotiwo2wvMAqYCdwEjpJTxvd2wc8HmjM2YLCYuOJWvZfZ01wZ/f9yfSWFFLZdFh/D9vkz++NV+6swWakxmfj6YjZQwZWAAle5zMVcLPB99B/6cDd7hsP31lm+U8C3kHYI5f2k5I0lRFKWb2rwiEEK0Neo4WAiBlPL7XmrTOWN92noCXPoQnXgApj8MaCuM39+SyvAQL16/YSyjw3x4btUR9pwooqC8BpNF4ulsIDrMm7y//w+9tzceM2aAkxtMvgdW/1lLERE6TnsTU62WNyhoVPcGghVFUdrQXtfQQuu/gWhXA+ut9+cA2wGHDgTVpmq2Zm5lkV80OrmvYXxgc1IBSXnlvHzNaIQQ/GFmJN5uRtYcymFQkCcj+noxvr8fdevXUrlrF8F/ewadm7VCV8zNsPFF2PZfLU8QwOo/aemkl3yrzTxSFEXpYW0GAinlbQBCiDXAcClltvV+CNqUUoe2PWs7VaYq5lbVatM2wyYA8MHWVAI9nVk4um/DvteOD+fa8aeLxFsqKzn+4ks4DxuGz7XXnn5RZ0+tWMz2/8KpVG2Vb+z7MPVBGGRb/WNFUZTOsuUrZnh9ELDKBRw+++i6tHV4OnkyIX0/DJgBBieO5pSx+Vg+t0wdgJOh7V9twXvvYcrOJvjpvyD0zQpzT7pbqwv84/3wy5MwaD5c+GyvHouiKI7NlllD64QQq4EvrPevA9b2XpPOfnWWOjZlbGJ24HiMRz+CSfcCsGx7Ki5GHTdO7IepsJDyjRupzcigLjMTWVWNsW8IhoAATn2wFK+FC3EbN67li3uFQPS1sP8z8B8CV72vzQpSFEXpJbYUr79fCHEFMNO66V0p5fLebdbZbU/uHkpqSrhAZ60rHDkLk9nCLwk5XDIyBG8jpF53C7XJx0GnwxgcjHB1pXzbNmRlJToPDwIfe7TtN5j5uFYx7MJnu1UoXlEUxRa2XBFg/eB36A//xtadXIeL3oWpBengEQQBQ9l7oojiyjouGh5EwVtvUZt8nNDXXtNSR1gzikopMRdrdQkMvu0U9/CL0FYPK4qinAE2BQLlNIu0sD5tPdNCp+Ea9zNEzgIhWHskF6NeMMmcT9577+N9xRV4zZ/X5LlCiPYDgKIoih302nxEIcRSIUSeECKhjceFEOK/Qohka13kblRkOXPi8+PJq8rjQp9hUJEHEbMAWHskl6n9vSn5+7Po/XwJeupJO7dUURTFNr05MX0ZcHE7j18CDLLe7gT+14tt6TFrT67FoDMwq7JK2xA5i5T8clLyK1hycis1R44Q8re/off2tm9DFUVRbNSlQCCEeLajfaSUm4FT7eyyGPhYanYCPtY1CmctKSVr09YyJWQKnid3auUdffqx7kgeAP12rcN96lQ8L7zQzi1VFEWxXVevCPb0wHuHAumN7mdYt7UghLhTCBEnhIjLz8/vgbfumsOnDpNZnslF4XO10pORp7uFJnqakRnpuM+YYbf2KYqidEWXAoGU8qeebkgH7/eulHK8lHJ8QEDAmXzrJtaeXIte6Jlj7AM1pRAxi+LKWuJOFnG5TrsqcBs/voNXURRFObu0l3TudZqWwmpCSvlgN987EwhvdD/Muu2sdDSnlO+P/kIf/XB++/EHrgHijdEcP5qH2SKJLkxB5+6Oy7Ch9m6qoihKp7Q3fTTO+u80YDhaeUqAa4DDPfDeK4D7hRBfApOAkmapLM4aFTUmLn/vewz9MrHkT2Jw9XqOyP4s+vAoTnodAZ7OuG6PxzguBmFQM3IVRTm3tJd07iMAIcQ9wHQppcl6/21gS0cvLIT4ApgN+AshMoC/AUbra78NrAIWAMlAJXBbdw6kN61PzMPsegAjgg3XXkzg0teomfYIL/qO4sf9WVzU14naT47jvXixvZuqKIrSabZ8ffUFvDg9A8jDuq1dUsobOnhcAvfZ8P52t+pgNi7ehxgbOJbAXe+AkzvO0+7jOvc+XDehH6Vr1pAJuE1Q4wOKopx7bBksfgHYJ4RYJoT4CNgLPN+7zTp7VNaa2JCUinTKZobPEDi0XMsQaq1GBlAZG4dwccF1xAg7tlRRFKVrbEk696EQ4he0fnyAJ6WUOb3brLPHhsR86gxpGIHRqbvB2QumNL2QqYyLw3XsGISTk30aqSiK0g0dXhEIIdZJKXOklD9abzlCiHVnonFng1UJ2Xh6ZyEQDE/aCJPvBTe/hsfNJSXUJCaqaaOKopyz2ps+6gK4oQ32+gLC+pAXbSz8Ot9U1ZpZfySPvkNz8TI54e7spdUVbqRy716QErcJE+zUSkVRlO5pr2voLuAhoC/aSuL6QFAKvNHL7TorbDqWR1WdiSrLMaaVFWolI119muxTGRuHMBpxjY62UysVRVG6p73po68BrwkhHpBSvn4G23TW+PlgDsFehZRZKhlp9IWpDzR5XJrNlG/ahMvoaHQuLnZqpaIoSve0OUYghJgghAiuDwJCiJuFED9aU0f7tfW880WNycz6I7lc67cCgFHTngSDc5N9ir78ktrjx/G76SZ7NFFRFKVHtDdY/A5QCyCEmIk2jfRjoAR4t/ebZl+7U08RUZeEqXYPzuiIGn5lk8dNhYXkv/oa7lOn4Dl/vp1aqSiK0n3tBQK9lLJ+Edl1aLWKv5NS/hWI6v2m2dfWI+m86PQ+CW7uDOszHKPO2OTxvP+8jKW6mqCnn0YI0carKIqinP3aDQRCiPoxhAuA9Y0eO78T6pjrmHXgCaLESY44OzMycEyThyv37qVk+XL63HorzpGRdmqkoihKz2jvA/0LYJMQogCowppfSAgRhdY9dH6yWKj45m6mmmP5atBdVJt+YZT/KKoTEynfvIXqhAQqd+/GEByM/z1327u1iqIo3dberKHnrAvHQoA11txAoF1FPNDW8855a57GPfFbXq67Gteh0ZDwC8OL3Ei99Vqoq8PYrx/uU6fgd9tt6Nzc7N1aRVGUbmu3i8daQrL5tmO91xw7K0iGnW+ywXMRy+tuZG71Jvz13lj+8Sp6H28ivv0WY1CQvVupKIrSo87vvv7OytgNwCslM5gdE0hCYQK37Xan5uhRwv73lgoCiqKcl7pas/j8lLkHs8GdhNoQpgz0RBxKYvxv6XhfdSWec+bYu3WKoii9QgWCxjLiSHcdikFvwNMjg3t+MmEJ8CXoT3+yd8sURVF6jQoE9eqqIDeBnbUDmBjhx4nDWwg9BX3uvQe9h4e9W6coitJrVCColx0PFhPry/oxa3AApw5o4wW+MRPt3DBFUZTepQJBvcw4APZZopg3IhDd0VRMTnq1YExRlPOeCgT1MuLIE/6E94vApM8lLLOGushQhEFNrFIU5fymAoFVXVossaZIFo8J5UDOPiJywWPUaHs3S1EUpdepQABQno+xLJ0DMooFo0JIObgVlzoIGDvZ3i1TFEXpdSoQADIjFgBz33EEeDpTlrAfANcRI+3ZLEVRlDNCBQIg98g2TFLH8HEzKa4uxjMlD7OTAeeBaqBYUZTznwoEQGXKLo7RjwujI4gviCciR0JUfzVQrCiKQ3D4QGA2mwksO0S+10i8XY3stw4U+4weZ++mKYqinBEOHwiSDu/Dg0q8orSB4fTDO3GtBY+RasaQoiiOoVcDgRDiYiHEUSFEshDiqVYev1UIkS+E2G+93dGb7WlN4fG9AAQPmYTJYqL2cCIALiNHnOmmKIqi2EWvdYILIfTAm8BFQAYQK4RYIaU83GzXr6SU9/dWOzpiyk7AJHUERUazIX0TYZk1SCcjzgMH2qtJiqIoZ1RvXhFMBJKllClSylrgS2BxL75fl7gXJ5JlCEfn5MKyQ8sYmu+E69BhaqBYURSH0ZuBIBRIb3Q/w7qtuauEEPFCiG+FEOG92J4WpJSEVKdQ7DmI/Xn7OZC3j4hciavqFlIUxYHYe7D4J2CAlDIa+A34qLWdhBB3CiHihBBx+fn5PfbmmTm5hIp8LIHD+ejQRwwpcUdfVYuLWkimKIoD6c1AkAk0/oYfZt3WQEpZKKWssd59H2h1zqaU8l0p5Xgp5fiAgIAea2DWsT0AlIaEsy5tHTdUaTOF3CZO6LH3UBRFOdv1ZiCIBQYJISKEEE7A9cCKxjsIIUIa3V0EHOnF9rRQnhYPwHqOY9AZGJ2uw9A3BGNY2JlshqIoil31WiCQUpqA+4HVaB/wX0spDwkh/iGEWGTd7UEhxCEhxAHgQeDW3mpPawz5h8jUebAycx0LIy7DvDce9wkTEUKcyWYoiqLYVa9OjZFSrgJWNdv2TKOf/wTYrSCwb3kyGzzDqDFXcrkuBnPRN7hNmmSv5iiKotiFvQeL7aaiuo4B5hMc8fJBL/T0TSoCwG2iKk2pKIpjcdhAkJJ8BE9RRaoLDPYdTF3cXoyhoTiFtTbDVVEU5fzlsIGgMGUvFiBFFjHSbwSVu2NVt5CiKA7JYQNBXVYCaQYDFeYqxlX4Yy4pwX2S6hZSFMXxOGwgcCs6ylbXQAAGHq/StqnxAUVRHJBDBgKLRRJSfZwDHr64GlxxO5iKsV8/jCEhHT9ZURTlPOOQgSAz/xT9yeK4i54RvsOoiotT3UKKojgshwwEJxL3YhGSE6KM+UecsZSW4jZpsr2bpSiKYhcOmWu5/PhOjjkZiUg3Ef3ldtwmTcJr/jx7N0tRFMUuHDIQuOfGsb/Ol8d/NKMPDiXstVcRRqO9m6UoimIXDhcIakxmBpQfQrfJBaPFQv933kXv42PvZimKotiNw40RHEtOwjujnD4FZtbdMhKXyEh7N0lRFMWuHO6KIO/QJrxyXChxA89Zs+3dHEVRFLtzuCsCXdpOynOcORAhGBk4yt7NURRFsTuHCwRBqfvQ1eg4NNDIuKBWC6IpiqI4FIcKBLmFp+iTXQiAYcp43Ixudm6RoiiK/TnUGMHJA5vxynXieDBMHj7f3s1RFEU5KzjUFUH1kU1Y8o0ciBTMDJtp7+YoiqKcFRwqEHjF70JIQdHoCILdg+3dHEVRlLOCwwSC2joTbhm5VDpD1LRL7N0cRVGUs4bDjBGkHNlDbY6Bg/0FMyPm2rs5iqIoZw2HuSKoiV2HsUJH8mAPhvkNs3dzFEVRzhoOEwjCgkZi0oHPrDkIIezdHEVRlLOGwwSCI2P9uO1hPZPGXmbvpiiKopxVHCYQBLoFcvmo65kYoiqRKYqiNOYwg8WDfQfz9OSn7d0MRVGUs47DXBEoiqIorVOBQFEUxcH1aiAQQlwshDgqhEgWQjzVyuPOQoivrI/vEkIM6M32KIqiKC31WiAQQuiBN4FLgOHADUKI4c12ux0oklJGAa8AL/ZWexRFUZTW9eYVwUQgWUqZIqWsBb4EFjfbZzHwkfXnb4ELhJrkryiKckb15qyhUCC90f0MYFJb+0gpTUKIEqAPUNB4JyHEncCd1rvlQoijXWyTf/PXdhCOeNyOeMzgmMftiMcMnT/u/m09cE5MH5VSvgu8293XEULESSnH90CTzimOeNyOeMzgmMftiMcMPXvcvdk1lAmEN7ofZt3W6j5CCAPgDRT2YpsURVGUZnozEMQCg4QQEUIIJ+B6YEWzfVYAt1h/vhpYL6WUvdgmRVEUpZle6xqy9vnfD6wG9MBSKeUhIcQ/gDgp5QrgA+ATIUQycAotWPSmbncvnaMc8bgd8ZjBMY/bEY8ZevC4hfoCriiK4tjUymJFURQHpwKBoiiKg3OYQNBRuotzlRAiXAixQQhxWAhxSAjxR+t2PyHEb0KIJOu/vtbtQgjxX+vvIV4IEWPfI+g6IYReCLFPCLHSej/Cmqok2Zq6xMm6/bxJZSKE8BFCfCuESBRCHBFCTHGQc/2w9e87QQjxhRDC5Xw730KIpUKIPCFEQqNtnT63QohbrPsnCSFuae29mnOIQGBjuotzlQl4VEo5HJgM3Gc9tqeAdVLKQcA6633QfgeDrLc7gf+d+Sb3mD8CRxrdfxF4xZqypAgthQmcX6lMXgN+lVIOBUajHf95fa6FEKHAg8B4KeVItMkn13P+ne9lwMXNtnXq3Aoh/IC/oS3enQj8rT54tEtKed7fgCnA6kb3/wT8yd7t6qVj/RG4CDgKhFi3hQBHrT+/A9zQaP+G/c6lG9q6lHXAXGAlINBWWRqan3O0mWtTrD8brPsJex9DF47ZG0ht3nYHONf1GQj8rOdvJTD/fDzfwAAgoavnFrgBeKfR9ib7tXVziCsCWk93EWqntvQa6yXwWGAXECSlzLY+lAMEWX8+X34XrwJPABbr/T5AsZTSZL3f+LiapDIB6lOZnGsigHzgQ2uX2PtCCHfO83MtpcwE/gOkAdlo528P5//5hs6f2y6dc0cJBOc9IYQH8B3wkJSytPFjUvtqcN7MExZCXAbkSSn32LstZ5gBiAH+J6UcC1RwuqsAOP/ONYC1a2MxWiDsC7jTsgvlvNeb59ZRAoEt6S7OWUIII1oQ+ExK+b11c64QIsT6eAiQZ91+PvwupgGLhBAn0LLazkXrO/expiqBpsd1vqQyyQAypJS7rPe/RQsM5/O5BrgQSJVS5ksp64Dv0f4GzvfzDZ0/t106544SCGxJd3FOEkIItBXaR6SU/9foocbpO25BGzuo336zddbBZKCk0aXnOUFK+ScpZZiUcgDauVwvpVwCbEBLVQItj/mcT2UipcwB0oUQQ6ybLgAOcx6fa6s0YLIQws36915/3Of1+bbq7LldDcwTQvhar6TmWbe1z96DI2dwEGYBcAw4DvzF3u3pweOajna5GA/st94WoPWJrgOSgLWAn3V/gTaD6jhwEG0mht2PoxvHPxtYaf05EtgNJAPfAM7W7S7W+8nWxyPt3e5uHO8YIM56vn8AfB3hXAN/BxKBBOATwPl8O9/AF2hjIHVoV3+3d+XcAr+3HnsycJst761STCiKojg4R+kaUhRFUdqgAoGiKIqDU4FAURTFwalAoCiK4uBUIFAURXFwKhAoDksIUW79d4AQ4sYefu0/N7u/vSdfX1F6kgoEiqIl+upUIGi0orUtTQKBlHJqJ9ukKGeMCgSKAi8AM4QQ+6157/VCiH8LIWKtud7vAhBCzBZCbBFCrEBb2YoQ4gchxB5rrvw7rdteAFytr/eZdVv91YewvnaCEOKgEOK6Rq+9UZyuNfCZdRWtovS6XiteryjnkKeAx6SUlwFYP9BLpJQThBDOwDYhxBrrvjHASCllqvX+76WUp4QQrkCsEOI7KeVTQoj7pZRjWnmvK9FWB48G/K3P2Wx9bCwwAsgCtqHl09na84erKE2pKwJFaWkeWh6X/WgpvfugFQAB2N0oCAA8KIQ4AOxES/Y1iPZNB76QUpqllLnAJmBCo9fOkFJa0FKFDOiRo1GUDqgrAkVpSQAPSCmbJOsSQsxGS/3c+P6FaEVQKoUQG9Hy3HRVTaOfzRtODZ0AAAC/SURBVKj/n8oZoq4IFAXKAM9G91cD91jTeyOEGGwtANOcN1pJxEohxFC0UqH16uqf38wW4DrrOEQAMBMtMZqi2I36xqEoWiZPs7WLZxlabYMBwF7rgG0+cHkrz/sVuFsIcQStVODORo+9C8QLIfZKLUV2veVoZRUPoGWNfUJKmWMNJIpiFyr7qKIoioNTXUOKoigOTgUCRVEUB6cCgaIoioNTgUBRFMXBqUCgKIri4FQgUBRFcXAqECiKoji4/w9katsHHCHwEAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3gc1dWH39kq7ar33mzZcrfljgs2uBtsMM0GQujFECAJJQkl9ITwhQAJvYZiMGBjDG7YYBtXuXf13nvdXub7Y6SV1rsqLpJM2Pd5/Ajmzty5K+3Mufec3zlXEEURDx48ePDw60XW3wPw4MGDBw/9i8cQePDgwcOvHI8h8ODBg4dfOR5D4MGDBw+/cjyGwIMHDx5+5Sj6ewBnSkhIiJiQkNDfw/DgwYOHXxQHDx6sEUUx1F3bL84QJCQkcODAgf4ehgcPHjz8ohAEobCzNo9ryIMHDx5+5XgMgQcPHjz8yvEYAg8ePHj4leMxBB48ePDwK8djCDx48ODhV47HEHjw4MHDrxyPIfDg4TRsLS2Idnt/D8ODhz7jF5dH4MFDb2KpqCB37jxkPj74TJ2Cdvp0/ObNQ5DL+3toHjz0Gh5D4MFDB5o2bkQ0mdBcfDEt23+m8du1WCurCL71lv4emgcPvYbHNeTBQweaN/2AOiWFmNdeJXnXTtTJA9Ht3t3fw/LgoVfpNUMgCMIHgiBUCYJwopN2QRCE1wRByBEE4ZggCKm9NRYPHnqCpaICw+HD+M2bC4Agl+M9diyGw4cRbbZ+Hp0HD71Hb64IPgLmddE+H0hu/Xcn8GYvjsWDh25p/uEHAHznzHUc04wdi12nw5SV1V/D8uCh1+k1QyCK4s9AXRenLAY+FiX2AgGCIET21ng8eOiOpk0/oB40CHVSouOYJlVaqOoPHeqvYXnw0Ov0Z4wgGiju8P8lrcdcEAThTkEQDgiCcKC6urpPBve/juHoUUy5uf09jAsGS2UVhkOH8J07x+m4IioKRUQEhoMeQ+ChZ7Rs307l31/EbjD091B6zC8iWCyK4juiKI4TRXFcaKjbctoezgC70UjRnXdRcu99iFZrfw/ngqB582YQRfzmOXszBUFAkzoG/cGDiKLYT6Pz8Eui7pNPqfvoIwpvvhlrbW1/D6dH9KchKAViO/x/TOsxD71M0/oN2BsbMRcU0LR+fX8P54KgeeNGVAMHoB4wwKXNO3Us1spKrGVl/TAyD780TFlZqJOTMWVmUXDd0l/Eyrs/DcFa4KZW9dAkoFEUxfJ+HM+vhvoVK6SX3uDB1Lz51q9eEWOpqkJ/8CB+c91rGzRjPXECDz3DWl+PtaoK/yuuIP7j/2I3GCi67fYLfjXZm/LRz4E9wGBBEEoEQbhNEIS7BUG4u/WU9UAekAO8CyzvrbF4aMdw/DjGEycIXLaMkHvuwZyfT9P6Df09rH6l4auvJLfQZQvdtqsHDUKm1aI/eLCPR+bhl4YpU1KXqQcPxnvkSELuuQdrRQXWqgs7ttlrmcWiKC7rpl0E7u2t+3twT/2Kz5FpNPgvXoxMo0GdnEzNm2/it2D+r7KMgmg20/DFSrRTp6JOTHR7jiCX4z16NIZDh/t4dB5+abTJjL0GDwJAPSAJAHN+HsrwsH4bV3f8IoLFHs4P1vp6mtavx2/xIuQ+PggyGSHL78Gcl0fTxo39Pbx+oWnzZqzV1QT95sYuz/Mem4opOxtbY2MfjczDLxFjVibyoCDkISEAqJIkQ2DKy+vPYXWLxxD8imj8Zg2iyUTg0vbFmu/cuaiTB1L98r+wtbT04+j6h/pPPkUZH4d22rQuz9OkjgVRxHDkSB+NzMMvEVNmFupBgxAEAQBFWBgyjQZzrscQeLhAaFi1Cu+xYx3LVgBBJiPi6aexlJdT+cLf+nF0fY/hxEkMR44QdP31CLKuHwXvkSNALkd/2OMe8uAe0WbDlJPj/HwJAqqkJMz5HkPg4QLA1qLDnJuLz7SpLm2a1FSC77yDxtWraWots/BroP7TTxE0GvyXLOn2XJlGgyouDvMvQArooX+wFBcjGgyoBw12Oq4ekIQpL7+fRtUzPIbgV4I5JxuQFDDuCL33XryGDaPiyb9iqarqy6H1C9a6OprWr8d/8SLkvr49ukaVdOE/0B76D2ObYui0Z0yVmIS1ogJbi64/htUjPIbgV4Ixy/2XtA1BqSTqpX9gNxopvvMumjZv/p/OL2j5+WdEs5mAq6/u8TXqpETMRUWebGwPbjFlZoJMhnqgc1KiqrV2lbmgoB9G1TM8huBXgikrG5lGgzIqqtNz1ElJRL30D2xNjZT+7n5y58yl8bvv+3CU7dh1OkSzudf6Nxw8iMzPD68hQ3p8jSoxCSwWLCUlvTYuD79cTNlZqOLjkXl7Ox1XJ7VLSC9UPIbgV4IpOxtV8sBug6J+s2cz8IcfiH7tVWR+fpT/5S/Y9fo+GiVYysupeP4FsqZMpezxx8+5P4PVQFp5mktmp/7AQTRjxnT7++hIW1VSj3vIgzuMrYqh01HGxYFcfkGXmvAYgj6mxWSlpsXUp/cURRFTVhZenbiFTkdQKPCbM4ewh/6IaLGg27evl0coUf3av8mZM5f6zz9HGRVF0/oN5xyv+Ovuv3L7D7fzfNrz2OySq8taW4s5Px/vcWPPqC9Va8LZhTyz89A/2HU6LEVFqAe7PmMylQpVTAzmC3gC4TEEfcxz35/i6jd392ntEVtNDbb6etTJPTMEbWjGjUPw9ka3Y2cvjawdu9FIzVtvoZ08iYGbNhL7xutgtdK4atVZ9/lj4Y9syN/AsOBhrMxcycM/P4zJZkJ/QCoVoRk37oz6k/v7Iw8JueCTgzz0PaacHAC8Bg92236hS0g9hqCPSS9voqBWT35N3ykITNltiqHkM7pOplajnTCBlp07emNYTpiys8FuJ+Dqq1FGR6NKSEB70WTqv/zqrILWDcYGnt37LClBKXyy4BMeHvcwmws3s3zLcloO7EPw8sJ72LAz7ledkHBBz+y6RBRhzxtw5PP+Hsn/HMbMTECqMeQO9YAkzAWFF6zQwGMI+pjCOsnfviu37+qUd6cY6grttGlYCoswFxae72E5YczIAMArJcVxLGDpUqzl5bRs//mM+3th3ws0mhp5bspzKGVKbhp2E4+Of5R9FfuoT9uN98iRCCrVGfcrzex+oYZg299g05/hu/uhvqC/R/M/hSkzq0sxhioxCdFiwVJ6YVba9xiCPqRRb6FBbwFgV3ZNn93XlJWNPCQERVDQGV/bloDW0svuIVNGpvQgxcQ4jvlecgmKsDDqv+h+Bquz6NhUsIk3j7zJ77f+ng35G7hz1J0MDmqfoU2Nnoq3SUTIKUBzhvGBNlRJidgaGrDW15/V9f3Gjpdh+4sw7EoQ5LDl6f4e0f8M5oICGteswXv8uE7FByqH0ODCdA95DEEfUlgnuYNCfFTsyavFZu+bOIEUKD4zt1Abqvh4lPFx6Hb0rnvImJGBevBgpwdJUCgIuOYadDt2Yu5GsvnKwVd4aPtDvHn0TdLr0lmSvITbR9zudE60bzQpZTIEu4j32LMzBA4p4AX6QLtl71vw49Mw/Gq46n2Y8gCcXA3FfSMC6CuMmZlUPPd8n7pf7CYTJb//A6JCAQ8+0ul5bZVtL1S3oscQ9CGFtZJb6JpxsTQaLJws6/1KlqLdjiknB3Xy2RkCAJ+p09Dt24fd1DtqJ1EUMWVm4jUkxaUt4NprQCajYeXKLvvYVbaLi6IuIu2GNDZetZGnL3oapUzpdI5SpmR8hRa7TEAzevRZjfWXUk3Swb53YeOjkHIZXPkWyOQw5X7wiYCNf5biBr2I0Wrs1f7bEEWRiqeepv7TT9EfONAn9wSo/PvfMaWn896U37Ds20KsNrvb8+QBAciDgzHlXZgSUo8h6EOKWuMDy8bHAbArp/fjBJbiYkSj8aziA21op01FNBgw9NLGLJbSUuwtLagHuxoCZXg4PtOm0bhuXadKq5LmEoqbi5keMx1vhbfbc9oYUixSFu2FTKs9q7EqIyMR1OoLdmbnxL53Yf1DMHghXP0hyFsNo0oLlz4JpQfghLMqy1JZReVLL1HxzLPnfPv9FfuZ+sVUNhVsOue+uqNl+3YMrQUBmzb1/v0AGr/7jobPv6Bx0XV8rUqgtMHA1szON6BRJyZesN8bjyHoQwpqdIT6qokL1jA43JddOb0fJziXQHEb2gkTEJTKXosTmByBYveKC9/Zs7GWlWM8dcpt+97yvQBMjpzc5X3sZjMRRc0cj7aetXxXkMtRJSRc+K6hAx+0G4FrPgLFaYHxUcsgfDjs/jcgbddZ/sQT5M6aRd37H1C/YgXm4uKzvn1eQx4PbH0Ak83E4arerdgq2u1Uv/IqythYfC69lObNW3q1PIpoNlP50kuUPfwI3qmpPBU2nQGhWiL8vPhkb+eiCqlWVd4FuW2lxxD0IYV1ehKCNQBcNDCY/QV1GC29W8/HlJ0NguB2U/aeItNo0IwfR8uOM1fv9ARjeoZUo6UTY+VzyUyQyWjessVt+56yPYR5h5Ho736HsTYMh48gt9g5EW2jSn/2iWqqxERMBRfmzA4Aux02PQ6JF7s3AgAyGQyYCVXpYLdR8cwzNH67Fv+rryL23XcBqR7T2VBrqGX5j8tRyVTE+8WTVZ+F3Wym/ouVWCrPf0HD5o0bMWVkEHr/7/C/bCG2mhoMvbS/tLmggIJl11P3/gcEXHcdxx54howaAw/OGsT1E+P4Oauagk6k4aqkROyNjdguQKGBxxD0IUW1euKCJJfE1IEhmKx2DhX27pfClJWNMjYWmUZzTv1op07DnJOLpbz8PI2sHWNmhtsaLW0oAgPRjBtHixtDYBftpFWkMUcYRsPKlYgWi9s+RLud6tdew+7nw4k4gaLmorMerzopEUtxCfZerIV0TtTng0UHI652bwTaCB0CNhP2klPoft5BwNLriPzrX/GZNhVlXNxZJRKabWbu/+l+ag21/OfS/zA+YjxNmacouO46Kp56itq33zqHD+aKaLFQ/eprqAcNwm/hQnymT0dQq2na1Dvl1EseeBBzSQnR/36N0Cef5JUdxaRE+LJwRCRLx8eikAl8luZ+VeAIGF+A8mOPIegjjBYbFU1G4ltXBBMSg5DLBHbl9q57yJSVdcaJZO7QTpkCgG737nPu63RMGZmoO3ELteE7axam7ByXCo7pdek0mhqZ+UMlFU89TcH1N7jNeWj8Zg2GgwfRPnA3Bi+BgqYCl3N6iioxCex2LL2cW3HWVKVLP8O6SZgLk2IyLZvXIprN+M6a5WjymTYNXVraGQsEvs76mmM1x3hu6nMMDxnO5AM6Hn+nEXN5OaqBA2jZueuM+uuOxu/XYS4sJPTBBxBkMmRaLT7Tp9H8ww+IdveB27PF1tiIKTOT4FtvxW/2bNYcKSOvRseDswYhkwmE+Xkxd3gEXx4ocbvSV3kMgYe2QHGbIfD1UjI6NqBXA8bW6mrMBQV4DR16zn2pByUjDw1Bt+v8Psi25mYsJSV4uQkUd8R31qUALu6hvWV7QRTxO1mMeugQzEVF5F25hPqvvnK8CKz19VS99BLeqanELv0tKpmKoqazXxGozqL43KHKQ6zLW4fF5n7Fcl5pMwShXRtXQqT25m27kQcFoekgqW0TCJyJAsdoNfLe8fcYGz6WOfFzMOXmEvv6d2TGCNS8/RiBS5dhKTq/yYnNmzZJsYGZMx3HfOfMxVpVdd63FTWcOAG07lYHrEgrJCXCl7nDwh3n/GZSPI0GC98dLXO5XhkdjaBUYvIYgl8vbdLR+OB2tcrExCCOlzb2WpygacMGsNvxmzv3nPsSBAGfi6ag273nvM60TK2p+e6kox1RRkXhNWwYzZudDcGe8j1MMccj1tUTdMMNJH27Bu8RI6h44knyr7qalh07qH75ZWzNzUT89UnkcgVxfnHntCJQJyQAPSs+V9RUxINbH+S3G3/Ln3b8iSu+vYLNhZt7N2BYdRIC4kHt0/V5ah/sPrG0HCvE55KZCHK5o0k7cSKCSoXu557nj3yZ+SXVhmruHX0vgiDQ/NNPALyxUEaGrBKfqdKqsmXn+REd2M1mdGlpkjuodY9gAJ+ZMxCUSprPs3rIePw4AF7Dh2O3i2RUNDMpKdjp3hMTg0gO8+GzNNeJhiCXo4yPw5xf0OV9KnQV53XcPcFjCPqIwlopgBQf1O6rHxblj80uklPVO5vGN373PeqhQ84pUNwR7dSp2BoaMJ5KPy/9ARgzWmu0pHRtCAB8Z8/CcPSoI+BotBo5XHmYS2pCAdBMnIgyIoK4Dz8g6qWXsDc3U3zHnTR89TVBN93kKAgW5xt3TisCmVaLMirKMfbOWJu7lsXfLmZ32W5+N+Z3vDbzNVRyFX/Y9geW/7i894xBVTqE96yOkl4Xg91kw2/2bKfjMm9vNOPH9/ilrbfoef/E+0yMnMj4iPEAtGzdhnroELyjYsiqy0IZH48yNhbdeXIPGQ4eRDQY0LYamDbkPj5op06ladP5dQ8Zjh1HlZSE3NeXknoDerONlAjn3e0EQWDBiEiOlTSgM7kmtqkTE7t0DR2sPMjsr2ezo6T363t1xGMI+ojCWj2+XgoCNO1JTkMipS/RqfKm834/c0EBxuPH8b/s8vPWp/YiSZ55Pt1DpswM5AEBKMLCuj23zYfd8tOPAByqOoTZbmZQnhllVBSq1vIUgkyG/+WXMWD9OsIfewy/BfMJve9eRz/x/vEUNxc7ylKfDZrx49GnpXX5ovky80sS/BJYv2Q9d468k5lxM/nq8q+4bfht7CzdSU5Dzlnfv1OsJqjNgbCebbjTXCBDprCjmTDepc1n+jTMubk9qo+zMnMldcY67ht9nzSM+noMR47gO2MmyYHJZNZnIggC2qlT0KWlnZdNh1p27ERQKtFOmODS5jt7NtaKCkfBxXNFFEUMx47hPUJyC2VUSM/s4AjXbU5HxwZgF+FEqWvCqCoxCXNxcaeihi2F0or3s4zPzsu4e4rHEPQRknRU67SMjA/WolHJOVV2/g1B4/frQBDwWzD/vPWpCA5GPXRIjwzBvvw6pv9jK8dKGro8z5iRiXpIitPvpTNUAwagi/Rn+8d/Z8HqBTy28zGUghzv43loJk50OV9QqQj6zY1Ev/yyUwJZgl8CFruFct3ZK6A0kydhq6/H1JqncTp20U5WfRYTIiYQ4h3iOK6QKViashSAXaXnblAb9GbsHUuV1GSD3Qph3ceFRJuN5pOV+EQZkelcX/baadMAaOmmvIjeoufDEx8yJXoKo8OkjO2W7dvBbsdn5kwGBw6moKkAk82Ez9SpiHo9+kPucwvOpDyEbscOvMeNdZsc6D16FADGEyd73F9XWMvLsdXU4NUaH8isaAYgOdzVEIyM8QfgqJvvvioxEaxWtyVTRFFke8l25IKcXaW7KG46+zyOM8VjCPqIwlodccHOEk65TGBwhC/p53lFIIoiTd9/j2b8eJQREee1b58pU9AfPoxd13kZ7Xqdmfs/P0xRnZ63t3fuRxdtNqkOUjeB4jasdisbh5gYnG/mYl0sI0JG8FDgtdgbG9FMdJ0Vdkacr5TZXdh09kFL7eTW1dGevW7bS5tLMVgNDAp0zY2I0EYwMGAgO8vOzVeeXdnMhBd+5Mb306hqbi3l4FAMdW8IDIcOYWvS4xtjbL+uA6rERJTR0bR0EyfYWbqTelM9tw2/zXGsZes2FKGheA0byqDAQdhFO7kNuWgmTgKFAt2u9s9uLiqi9v0PKLrtdjLHjafguqVYa7pW01laZ/s+U6e5bVclJCDTaDCePNFlPz3FcEyKD3iPHAlARmUzsUHe+KgVLucG+6iJDfLmaLHrikCdmADgNk5Q0FRAcXMxt424DYWg4MusL8/L2HuCxxD0AVabndJ6g1N8oI0hkX6klzedV3+x8eQpzAUF+F1+2Xnrsw3tlClgsaDbv99tuyiKPPz1MWp1Ji5NCWPjyQrKGgxuzzUXFCCaTN0GitvYV7GPtaMs2DVe3HDAm9cueY159ZI7yJ17oDMS/BOAczMEyvBwVImJ6PbucdueVS+tFNwZApAqoR6qPITecnbbgIqiyDPfn0Ill3GoqJ4Fr+5kd04NVJ0CmQKCB3bbR/OWLQgqFdpIE1RnuLQLgoB2+jR0e/diN3ZeM+h4zXGUMiWjQqVZuGg2o9u5E58ZMxBkMkcF2My6TOQ+WjRjxjhkpM0//UTeosVUvfQSlooK/C+/DGNWFgVLl3WpytK1xi60rdVxXcYuk+E1dCiGk+dnRWA4fgxBqXTsN5BV0czgcL9Ozx8VE8CR4k5WBLiXkP5cIiXwXZ18NZfEXcI3Od/0Wa0mjyHoA8oajFjtIgnBrkvYoZF+NBmtlHbysjwbmr77DkGpxG/OnPPWZxveqakIXl7odu3GXFhI6UMPk3PJpY6yzB/vKWRLeiWPzkvhqUXDEEWRTztJuzemSy8fdUrP/NlbirYg+GgJuuF6mn/4AVNePrq0fShjYzutA++OYK9gNArNORkCAO3kSRj2H3Dr782sz0RAYGCg+xfylOgpWOwWDlSeXYG0H9Or2JFdwx9mD+Lbe6fi763gxvfTqMg+BMHJXSeStaLbsxfNuHHIQ+PcrggA/ObOQ9Trad68udN+jlUfY0jQEFRy6Z66/fux63QOSWeMTwzeCm+HcdROnYopPZ2at96i5L7foR44kAFbtjBg3fdEPvss8f/9CLteT+GyZTSsWk3Ljh3oDx92Kv3dsmMnivDwLospeg0bhikjs1N//JlgPHYc9ZAhyFQqTFYbeTU6l0BxR0bHBlDaYKC62TkPQ+7vjzwoCLObzPSfS34mOTCZSJ9IlqYspdHUyMaCjec89p7gMQR9QEGrYuh01xBIKwKA9PLm83Iv0W6naf16tBdPR+7vf1767IhMpUIzYTyNq1aRu2AhTZs2YSkrQ7dzFwU1Op5fn84lKWHcNjWR2CANs4eG8/m+IrcSWVNGujTLSuq6NASAzW7jp6KfmBYzjdCbb0VQqah95x30+/efkVsIpJluvF88hc3nZgg0Eydh1+sxtMoKO5JVn0W8X3ynRfBSw1LxVnizs7QH7qGGInhtDJQfA8BktfHculMMCNXym8nxDI7wZe19UxkRE4C98hTW0O4Nq62pCVN2Nt5jU6XAspsVAYBmwniUsbE0fO1+y1Cr3Up6XTojQkc4jrVs3YagVqOdPAkAuUzOwICBZNdLgdu2PS6qX3kV7dQpxP/3I1Qx0Y7rvUeOJOGLz5EHBFD+2GMU33EnhcuuJ3f2HEkJZLWi270b7bSpXcaWvIYPRzSZznnTeNFmw3DypMMtlFulw2YXGdSFIRgVGwDgNkamSkx0ySVoMjdxqPIQF8dcDMC48HEk+SexMmMlTeYmthZt5cV9L3K82vW7dj7wGII+oPC0ZLKOpET4Igict4CxKSMDa3W1ixzwfOI3dx6ixULg9dczcMsWZP7+6PbuIS2/FrPVzuMLhzge0JsvSqReb2HtEdcEG2N6BurkZASl0qXtdI5UH6HOWMesuFkogoMJuOoqGteswd7UhNZNoLg74v3iKWw8xxXBxAkgCOj2uLqHMusyO3ULAajkKiZETOhZwDh7M9Tlwd43AfhoVwEFtXqevHwYSrn0CGvVCp6YHUsUVRzQdx8XMhw9CqKIJjUVQlOkILObZDdBJiPgqiXo09IwF7lKbnMacjBYDYwIkQyBKIq0bN2KdvJkp5IhgwIHkVmfiSiKqFNS8E5NJeC664h9/XW3wV5VXByJ360l6bu1xH++gpi33kSVlETpAw9Qcu992JubO40PtOHVuhWp8RzdQ6bcXES93pFIllkpPatdrQiGRfkhlwkcdeseSnCJEewu241VtDI9ZjogTVauG3wdJ2pPMO2Lady/9X6+zPyS7Ibzo4I6HY8h6AOKanWoFDLCfb1c2rRqBQnB2vMWMNalSZuNaCZNcm3c/x7kn7s+2X/JlQw+dJCIx/6CMjwM7cSJ6HbvobBGh0ImENchFjIpKYiUCF8+3F3gFAcRRRFjenqP8gdAktUpZUqmxUgPf/Btt4JCCtRpJpydISjTlZ1Tpq88IACvIUPQnxYw1ll0lLSUdGkIQHIPFTUXdZ/TUNTa/8nVNNZV8++fcrg0JYyLB4U6nTbOuxKAFQVaGvRdyzMNhw+DTCbNckNTwG6RjI0b/K+8UtoTYtVql7Zj1dIqZWSINFtuk5t2zPQFyRA0mBqoNlQjyGQkrPiMyKef6nISIFOpUCcnoxkzBt8ZM0j49BOCfnuTpEiSyRwrjs5QJcQj02rP2RA4EslGtCmGWlDKBRJDOi9lrlEpSA7z4UiJu4BxIrbaWmyN7W07Snbgr/Z3/B4BFg9czOIBi7lr5F18MPcDdl+/myXJS87ps3SGxxD0AQW1euKCNMhk7pexQyP9zlsugT4tTdpVLDzcuaHiOKz7I3xxveRqOAcEQXB6gLUXTcZaXk5Ddj4xgd4o5DKnc2++KIH08ibS8uscx63V1djq6pz2KO6MR78+ylfpG5gcORmtUnr4lNHRBFxzNV4jR6IM7z4H4XTi/eKxi3aKW85NoqeZPAn90aPY9e1B3zYXSMdtMt0xNUpykewq62ZVULRXKhBnNVK09X1aTFaWz3QTe6iSynQfMUXxxrau3SH6Q4dRpwyWZuOtNYc6ixMow8PRTptK4zffuMg7j9ccJ1AdSIyvFLRvq0Xlc1qSV9vvoi1OcDYIKhXhf/4zsW+/ReSzz3Tr+nQEjHsoIa3QVVBrqHWZsDQeOYjMzw9VfDwAmRVNDAj1cazGOmN0bABHixtchCCnB4xtdhs7SnYwLXoaclmH7G6lluemPsfy0csZHzEetVzdo89xNvSqIRAEYZ4gCJmCIOQIgvAnN+1xgiBsFQThsCAIxwRBWNCb4+kvijuUn3bHkEhfiur0NBvPLaglWq3oDxxwq6lnxz9B5SvtSLX6LjjTZKq8bbD6Tmmzk8pTUqnjVtqklNqTB51KaLRxxZhogrQq3v25fcbp2IOgG8VQZZORVSf2YqKWproUp4cq4oknSFj5xZl9jlZifWMBSeZ5LmgnTQaLBf3B9rLH3SmGHGPwiyXON65r91BjCeDs2Z0AACAASURBVDQWwdibIXocYZmfEeitYHSrD9qJqnRQapgwegwf7S7oVIAgWq0Yjh1DMyZVOhAyGBA6jRMABFx1FdaqKpdM4+PVxxkeMtzhCtTt2i1NRKKjnc5LDpSCuhl1nd+jp/hcfDEBV13Vo3OlgHFGtwHj0pZSFqxewIwvZzBt5TRuWH8DS9YuYfKKSWRs+4aMMAs/FW9FFEUyK5rdJpKdzqjYABoNFkd5mTZUCa21qlrdQydqT1Bvqne4hfqDXjMEgiDIgdeB+cBQYJkgCKeLmx8HvhRFcQywFHijt8bTX4iiSFGdnlg30tE2hkZJAeOMinMLGBvT07G3tLgGT2uy4eQamHAHLHgJinbDrld63nFzBXx1C5xYLW128uZkeGMimKTxKuPiUERGEp17wm0cxEsp56bJ8fyYUUV2pXRNT0tLrD1Shsz3JAIydh4N570d7UE2QSbrUSKaO8I00iriXPYlANCMTQWl0ilOkFmXia/Sl0htZLfXT4mewr6KfZ27qNrcQnGTsI+9mXBzEbfEliN3t7qsOgmhKfx+bgqI8NEu9/JLY2am5PNOHSMdUGkgML7TFQGA74wZyIOCaFzVHjRuMbeQ15jnCBSLrbJizUWuGwT5qfyI843jRE27rr+2xcSKtCJu+XAf/91d0Om9zwWv4cMRzeZuA8afpX+GKIr8fuzvmRs/Fy+5F9HaaB45lURcNZwY4cuD2x5k2bobqDAW9MwQxEjG+vTEMlVsDCgUjhVB2+9kXPi4s/mI54XeXBFMAHJEUcwTRdEMfAEsPu0cEWgT4/oDrhHFXzg1LWb0ZpvbHII22pVD5+Ye0qelAW409TteBoUXTL4XRi2FYVfC1heg0L0G3gm7HdYsB4sB7tkNDxyFeS9CTRYc+gSQ3D+KCRMZWplNfKBrHATgpskJeCllvNO6KjBlpKOMiUHu2/UD9c3hUnwDsxgbPpYFQwfywoZ0Np449z0RQr0l//q5GgKZRoN20iSavvvOsT9BVn0WyYHJPTJSI0JGYLAaKGlxzTQFoGgPqHwgfDgnAmfRJGq40u6m1r7dLq3UwocSHeDNqFh/DhW5z+o2tGb1asaMaT8YOsThWnKHoFLhv3gxzVu3OWScJ2pPICI6/NqGY8cQ9Xq0F13k/rOGjuB4jeRv/9OqY4x/fgt/+eY4Bwrr+evak+fl73o6XsOkuafxROeJZS3mFlZnr2ZOwhxuHX4rT0x+gvfnvs/z1ssZsuoI/osX8chzW3hq8lMUNBaiDv++y0BxG4PCffBSylzyCQSlElVMjMMQ5DTk4K/2d8pA72t60xBEAx0dsCWtxzryFHCjIAglwHrgd+46EgThTkEQDgiCcKC6uvM9QS9Eiuo6l462EeHnRaBGec7KIV3aPlQDBqAI7RBErC+EYyth3C2gDQFBgMv+JW1e/uE8eG+W5O4xuga1ANj3DuT+CHOehdBBEJgAk+6GuMmQ9ibYJJ9x09DR+FoMDGxw72oJ0qq4dlwsa46UUtFoxJie0a1bKLOimVOVlZjlZUyIHM8/rx3F0Eg/Xtzoptjbrlfh06ucXFZdoZQrCfIKolJf2aPzuyLo5t9ira6mae1aR2mJ7uIDbbT51kuaOzEEhXsgdgLIFWzNbWG1bRox5ZtBd1r58kP/BX0NDLgEkAoaniprwmZ3TVQ0HD6EIiLCOfcibpJk3Js6n4v5zZ0DViv6vdIqpU3KODxkOCC5hZDJOk3uGxEygip9FSerivhifzHzhkew/v5p7H9sFqNjA/j9yqNu6/OcC6p4KWDcVWLZ6uzV6Cw6bhp6k+OY8dQpyv70J7xHjSLimWdQypVcNegqUnxnIPcuJCGke3+9Qi5jRLR/J8qhREcuQU59DgMDBnY7cTAXFmJrOv/laKD/g8XLgI9EUYwBFgCfCILgMiZRFN8RRXGcKIrjQkNDXTq5kGnbh6BtZzJ3CILgyDA+W0SLBf3Bg5KksSO7XgGZHC7qYGO9A+HObTD7WTDrJXfPfxe5vkSr0mHzk5A8B8bf7tw2+T4p6JzxHQBFcZJULyKnc53z7VOTsNlFPt6ajrmgAHVKCo0Gi9uXFUirAaW2EBAZGzYWL6WcRaOiyK/ROSfqZG+WxpmzBYrdl3xwR7gm3HVFYGyCd2ZCUVqP+9FedBHqoUOoff8DSpqK0Vv13cYH2miLVRQ3uwlaG+qlWXqc5GrZmlnFgdArEWwWWPf79r9XSzVs+SskTINhkqpkRLQ/BouNvGrXyrb6w0fQpI5xPjhonvQzq/PSzV7DhyPz86OltdbUsZpjJPgl4K+Wgra6PXvwGj680yBum8HYmCUp226ZksjQKD+8lHLeuWksgRold3x8gKqm85dNK8hkeA0bhvGk+9WOzW5jRcYKUsNSGRYifYdFs5mS+36HPCCAmP/8G5m6/aUvNw1EkFmot/YsN2FkTAAn3RhkVVIi5sIi7FYruQ25DAyQgv+Wyioqnn2O6tdfp/mnnzBmZVH74UfkX30NuXPn0fj992fza+iW3jQEpUBsh/+PaT3WkduALwFEUdwDeAH9tz7qBQpr9QgCxAS6TyxqY1iUH+nlzXx7pPSsyk0YTpxA1OvRdJyNZW+Bg/+F0TeA32mZtz6hMOV+WL4bFr8O5Ufg+Fft7XYbrLlHqmm/+HVpJdGRwfMhKAl2/wdEkTybmjy/SFRHD3Y6xrhgDfNHRLJ38z4QRV7Og1FP/8Ccf21n3bFyp+JpdrvIt0dKSYiuRCEoHH7o8YlBABwsbFUgNZZIQeywYaDUwLGe12cJ04S5GoK8bVB2CNLX9rgfQRAIuf12zPn5FK+TfOg9NQTBXsF4K7zdG4Li/YAIcZOo05k5WtLAgKFjpdXZqW9h2wvSeT88Lhn0hS87/k7Do6WX8Yky5xm2pbwca3k53qNPMwShg6U9DLowBIJCgXbSJHS7dmO32zlefdyRP2BracFw7JijQq07UoJSUMgU7C8/ilwmMDyq3WCE+Xrx3m/H02iw8PR3nbuozoauAsY/Ff9EaUup02qgeft2LGVlRDzxhPPqGmiojQVR6HFGeEqELyar3VGG3jGmoUMRzWYK//UizeYmkgOSsTU1UXzHHdSvXEnNf16nZPm95C9aTNWLL4IoEvbII/heeulZ/Aa6p1NDIAiCSuiwVhEEYaYgCH8UBKGn5Sz3A8mCICQKgqBCCgaf/nQVAZe29j8EyRD8snw/3VBUqyfCzwsvpbzL826ZksiQKD8e+OIIt3y0n5L6M6tBo98n1f5xGIKyw/DlTRA+FGY/0/XFo66HyFHw03NSGWOQXEJlh2H+P8DHjTxTJodJy6H0ABSnUVirIztmCKbDh7qsS3PX9CQiaiT5aklwDPfOHIAgCNy74hCX/2cn3x4pRW+2sje/lvJGI2qfIoYGD3Vk6A6P8ketkLEvvx6sZvjqZikR6tqPIWUhnFojHe8B4ZpwV9dQ3lbpZ4n7Wkqd4TtnDsrYWBSfrUUQcczwukMQBKJ9ot3HCIr2SHWDoseyI7saUYSZKWHSaiz1Jvj5JVj/MBz7AqY+KLnuWhkQqsVLKeN4ifMqU9+6qbt3aurpA5FWBXnbpHhQJ2inTMFaXk7pqX3UGmsdBlq/bx/YbGgnu48PAKjlaqkSaUsGKRG+eKucn4mhUX5cPjKKnTk1zhVVkSqc1hvPbn9vr+HDEM1mtxVPPzn1CTE+McyIneE41rj6GxShofhMd05Ys9jspJdZ8ZfHsb+yZ9+PtqByVqWzEMRv/nwCrrka4/ufcs1OOwM1cZTcex+mvDxi336LwQf2E79iBZF/+xsDNm4gcdXXBN96i6ss/DzR1YpgPxAAIAjCw8DzgDfwB0EQ/tZdx6IoWoH7gE1AOpI66KQgCM8IgrCo9bQ/AncIgnAU+By4WezVrZv6nu4UQ21EBXiz+p6LePKyoezLr2P+KzvOaMMafVoa6uRkFEFBUJcPn10DmmC44Wvw6rw4FgAyGcx6WpIp7n8fGorhx2dh4GwY3oVMb/T14BUAu/9NYZ2eqpTRiGYzLVu3dnrJyJgA7o62ga8fH/95EQ/PTWHTg9N5+dpRtJisPPDFEcY9t4U/rTqOj5dImSGL1PD2l5ZKIWN0bAAHCutg58vSC3vxvyFkIIy4VnKn5Lhucu+OME0YDaYGTLYObqbc1rGXHemxQQFpthx86y345VYyozYMjbL7v3kbsb6x7mMERXskA63Ssi2zmiCtipHR/tJLe8E/JVfQvnekuM20PzpdqpDLGBLp57IiMBw+guDtjZe7PaIHzQWrocukQ+0U6UWft/kbAEaGSoFi3e49CN7eeI8Z3eVnHRY8nBbyGR3r/js5aUAQjQYL6RXOBuzRHY+yYNV8Dm5/Bv57Obx7CaR/J8mhu8F3xgwUoaFU/eMfiLZ22fTR6qMcrjrMDUNucOj3rdXVtPz8M/5XLEZQOFcWPV7aiN5sY3hwKkerjmK2df/9GBjmgyBISWgdEWQyIp5+mqqZI7hmp4jfXU+j37+fqL+9gM+UKci0WjSpYwi48gpUCQmIosiaw6XntSZZR7oyBHJRFNtM8HXApaIoPockB13Yk85FUVwviuIgURQHiKL4fOuxJ0VRXNv636dEUZwiiuIoURRHi6LoRg7xy6awTt+lYqgjcpnArVMT2fDANJQKGfetONSjbSxFsxn94cNS/oCxqTVoaoUbV4FvD8tQD5gJSTOlWeba+wARFv7T1SXUEZUWxt8GGetoqSlBHCPVpan7+JMub+Vbmo+mwx4EcpnAktQYtv5xBivvnMTi0dE06M1cPMKIxW4hNcx59johMYiTZY3YD38qGathV7Z/Bk0wHO+Ze8hFQlpfAPX5ED8FbCYpCe8M8L/ySpq1Mq7Z1OJUIK07YnxjKGkucXYJWoxQehDiJmO3i2zPqmZ6ckh7UqJCBdd9AsOvQlz0Js079lD6hz9S8867jhLhI6KlgHHH2bU+LQ3vUaNcXnIAJEwFpRayOi90poqJQRUfj37nTiK1kQwJkuoa6fbsQTNuHDJV18XuwtWDEGQmYsLcT3ImJgYDkJbXnnxY3FzM9uJtmCwt3J23kp26EkncsPJGSezQTTxHptUS9sgjGE+epKGD/PWTPW9w2zYFl6vaZZuNa9eCzYb/la4ZvPtaEyLnDpiC0WZ0ksJ2hkalIDZQ47IiAMkYbF42kL2jvbHmFxL2yCP4X+5+I6nSBgMPrjzCTxnnpnLrjK4MQZMgCMNb/7sGyW0DoOjmOg+tGMw2qptNTiUXekJ8sJb/u2YkGRXNPP7dLp7a/VSXZQgMx48jGgxS/sCGR6WX2dIVTq6CHjH7aTDUSe6BSx6XtOXdMeASQCTMkEtsqA9Bv7kRw+HDGI4dc3u6aLNhysxyqxiSyQQmJgXztyUjOPrXOYxOll6mY8Kc/dnjEoIYIuYhayxuNwIAcqUULM3cIBnEbgjXSMtshyFoWw1Mf1j6eYbuoWbBxBvzIahcR+HSZZiLe5a1HOsbi9FmpMbQoQZ/+VGwmSFuEj+cqqROZ5bcQh0QvQKo011Mzq2PU7L8Xpp3Svsz58yaTe37HzAixJsWk9VR9NBcUIApOxvfmTPcD0Shloxp1qYuZ9qKyeOJyKpjQcwcZIIMS1kZ5txcR2JhV1j1kkpK5i39bix2CzdtuIk3jkgpRFEB3sQFadib166K+urAa8hEkRXqwST6J/E7X/h+/l8RL39NUjl9coUUI+kCv8sW4j1uLNUv/wtbQwNZGbuZ++LPzN1jpObeB7E1NiKKIg2rVuM9ZozbQohpebUMCNVyScIkBAT2V/Ts+zEo3NetIQDIbsplz81jSVq/nuBbb+m0j7ailEMju5etng1dvdDvBj4TBOFjoAo4IAjCh8BO4IVeGc3/GA7FkBvpqN1komXnLnR73c9mLkkJ5/apiazN+Z5V2atY+v1Stha5d7no9u4FQUDrVw1HV0gvsvjOfbWdEjkKJt4jvdwn3NWza0KlF/ogoYT4IC3+S5Yg02o7XRXo9x9ANBrxHt21C0EQBA5WHWRgwEACvJyzaFPjApgv348duRS07sjIa8FqhIzu1RUuK4K8reAbBUkzwC/6jA1BZl0mB5NlNL/0R2wNDRRct9RtZdLTcascqpXKVFRpkvnz6mMMjfRj3nDn1Z1+/34q//Z3moK9WH3LQK67R8/RF67Ha+hQql56iWFr3gcklwZI+w9A+5afbhk0F5pKoLJzueWpASq8LDCvOQHRaqXssccQlEp8L5nZ6TVtFFVqwe5FpUnKvv4y80sOVx1mRcYKh6tlYmIQ+wrqsNtFzKZm1hRuZIYZUpZ8xHuXfcaIkBH8eddjXFe2jo2TfoPNoocK9xOPNgRBIOKJJ7A1NVH+xJM03XofQS3g+4ffYS4ro/SPD2E4fBhzXh7+S650ud5mFzlQUM/EpGD81f4MChx0BnECH/JrdJiszqt7m91GXkMeA4OTu63Am17ehCDA4Ihu3LxnSaeGQBTFY0Aqku/+IFLW70ZgliiKK3plNP9jFDmqjkrSUVEUaVy3jqLb7yBrwkSKb7+doptvpupfr7hVCj0yL4XAoHKw+hGuieb+rffz6qFXXc7V703Da3Ay8q1/huix7TPas2H+3+HG1SB34zpwhzYEsyqQgUIp8cEa5D4+BFx9FU0bN2KpdNXoN377LTKtFp8ZM7rs1ma3cbTqqMtqAMBXrWCR6iCn1CNAE+TcGDNe8pn3QD0Upu1gCOw2yNsuzYgFAWLGnbEhSK+TMnMHXnw58Z9/jkyjofiuu7E1d50xHuMjzZKdDEFDEaIg44ENVZisdv5z/RjUCufgavWHH9CikXHHvCL2DoJgbRhbtIXEvf8eAddcjWzzBgLtRk625qc0b96C17BhLuUfnEhu3cOiC/fQN75Z2GQQeKyQqv/7J/o9e4l46ilUCQldfk6AoyVN+JDIiZoTNBgbeOPIG4Rrwmk0NbK9ZDsAk5KCadBbyKxs5ofND1EvwLWj7wK1L34qP96f8z7PXPQMBquBh3M+55roCJqLdnd7b6/Bgwm8/nqaN2/GYjKw/4lFxNy5nIgnn0C3cycl996H4O2N33xXPcypsiaaTVYmtqrWxkWM42jV0R4VLRwU7ovVLpJf46wcKm0pxWgzkhzQ+Z4KbaSXNxEfpHG7I9r5oEsXjyiKNlEUN4ii+Kooiv8URXGlKIpdb0LrwUGbZCwuSIP+0CEKrltK2R8fwlxURMC11xL79lsEXHsttW+/Tdmjj7ps6K1SyND4liGYBtCUdxcLExfx3vH3OFJ9xHGO3WDAcOQIGv8qST2z5F3JRXIunGHZhmrvJJJlpY7yEoE33gg2G/UrPnc6z67X07xpE77z5zmVKHZHdkM2LZYWp0Bx+w0zibWXsMowFovttNwHQZBUUHlb4bsHwdz5lpq+Sl+8Fd5U6Cok+ayxQYqTgGRQGgqhpec+2Yy6DMK8wwjxDkGdlEj0q69gq6+n5s23urwu2icamSBzVg41FNGsDGVPQTPPXTGcpFAfp2vMhYXot/3MptEiT8/8G2uvWMulcZdyvOY4NruNwGXLEI1GltUf53hJI5bKSgxHj+LbXXly3wiIGtOpIajQVbC38SjNg6Np+GIldR99ROCNNxJwVfdVMfVmK5kVTST5DiG7PpuXD76MzqLj9UtfJ8w7jLU5kqhwYpL0ss04lsZXpduIE9RMGn+vox+lXMmVyVeyZvEa/j7t7+QplTxb8G2PZNehD9xP5oKhPPVbFVfM/z0AgddcQ+ANN2Crr8dvzhzkPj4u16XlS66qthjG+PDxUpygtvs4QZtyKPO0EjJtJaV7ojBLL29yVCDoDc7K1y8IwobzPZD/RYrr9PiqFVjff4vC62/AWlFBxAvPEfv9GiIe+ws+F19MxNNPEfrggzSt/Y68K5dQ+JubKFh2PcX3LKc8+yg1xiquHn4RBTVmivOkio75je01ZAw/b0S0WNCqc2H+ixA84IzH2WRuotF09hmdxYpYBslK8W2drahiY/G59BIaVq7EbmhXOTT/+CN2vZ6AxadXGnHlYKWUjzA2bKxrY/paRAS+N6e6z8ae+nuY8gAc/Ajeni7JYN0gCEJ7UllbfCBphvQzZrz0s6TnO4hl1GWQEtwe+/AeNgz/q5ZQ98knLhuRdEQpVxKhiXBaETRX5JJpDGBJajRLUmNcrqn79DNEmcD2CRrmJsxFEARGhY1Cb9WT05CD19CheI0ayfSMnZwobaB5c6tbaE4P9qlImikFqi2uMuCN+RsREQm9eBb25mY0EyYQ/ugj3fcJHC9pxC7C+KhRWEUr3+R8w7WDr2Vw0GAuG3AZO0p3UGOoISZQw4AAGcFHH+GQl4prR9yKzDXPFLlMzsKkhSxXRrHBVseanDXdjqFObuS51EImjbuCCG27qy38T48S9vBDhD5wv9vr0vLriA/WEOEvhUrHhkvfy57ECZJCfFDIBJc4QU59DgADArp+ZnUmK4V1+v4xBIIgpHbybyzQtYPXAyAphgZr7NS9/wG+s2cxYOMG3ozO5Kp112CwSi9IQRAIufsuol56CXlgAIgigpca/YED1N5wG0OKRBalTOKpy4eyK8OKgLxdapj+Hbr3HgJBxPvu1yH1N2c8xqKmIhavWczyLcvP+nNmWKPwQwct7a6g4JtvxtbQQPVr/3Yca1zzLcroaLzHunm5n8ahykNEaiOJ9HFTuC19LZao8VQTyP6COtd2hUrKnbjpWymI+P5cSVLrBkdSWd42CB8hJdqBFC+RKXrsHjJYDeQ15jlUNI7+H3wQmUpF1Yv/6PL6NuUQgNFiQ1+VT60ygmcXD3c519bcTOOqVRweqSF54ATHFpGjQ6XH8kiVtGIMXLoM/+pSEkoyqd6wCVVSEuqkpO4/TMRwEO2OOEVH1uevZ3jwcOKv+y3+S5YQ/cq/erSxEOCoubMgWaqO66/2597R0kx/8YDF2EQb6/LWgSjykupt1msbUQkKFg+5vst+b4tfwASDkb+lveA0SXLHywdfxi7auW34bU7HBaWS4Ntuc7vlqd0usr+gzuEWAgjwCiA5MNkxYekKlUJGQoiWrEpnpVRuQy7RPtHdSo0zKpoRRfptRbAf+D/gn6f9+z9a8ws8dE1RnZ65hfsQTSZC7vsdMo2GveV7KWwq5O2jbzud63/5ZSR8+inxn35C/IcfkvDlSgxaJU98biN6ywlunBjHDRMTsZkDOF6ZK+ncV96IrlqL9/BhyFOvOePxlbeUc/sPt1NjqOFYzTHyGt1vTNIdB/WtSS4dyhhrxo0j8Ppl1H34Ic1bt2KprES3Zw/+ixchyLpeiFrsFvZV7HPMupyoy4eK46iGLyYuSMOP6VWcLGukUW9xdQ0kXQy3t+YU7PyX23tJhqBCqvI5YEZ7g9IbIkb02BBk12djF+0uhkAREkLI8uW0bNtGy47O9fmxvrGOFcHrW9IJsdcwdMhwtG58wg1fr8Ku17NytIGLotpFAdE+0QR7BXO0+igAfvPnIfr6sTTrJ2yHD3bvFmojrLVIcFU624u3s3D1Qu7afBfP7nmW9Lp05ifORxkZSdQLz0t5Kz3kcFEDsUHeDAqNZtGARTw+8XFHeYqkgCRGhIxgTc4axJ//jx8UR1jno2VBwlIXscDpyGPG80J1LWpBxiM/P9Kp335/xX6+z/uem4fdTJxfXI/HnVXVTIPewoRWt1AbQ4OG9nh/hcFulEPZDdk9dguBVK6+t+jqiUwH7hJFcebp/5DkpB66wGYXKavVkXr4RzQTJuA1eBBN5ibyG/PxUfrw35P/dSwN3aFOTOTD+weRn+xLzTPPkzNrFnfn/UhYjQ859UVw9AtsNjXGKhuaqWdex7xaX83tP9xOi7mF1y99HZkgk2ZjZ4jJamNvS+ssutq5GFzYo4+iHjKE8j/9mdp33wO7Hf9Fi9z04syesj00mBqYmzDXtTFdqm3EkMuYMjCEPXm1LHxtJ6Oe+YHL/7PT1Rj4R0tZuEdWuN2Qp21FYLdbpJyEjsSMh9JDPdq7oa3OfkfXUBtBv7kRZXwcVf98udPrY3xjqDPWcaConG93HEQuiMQlufYlWq3Uf/IJuuEJFEQIToZAEARGhY5yxJBkXl4EXHkFqdVZCHZ7zw1B0ACQKaHqFFuLt1Klr6LeWM/a3LV4K7yZlzivR92IopT/sCKtiHd/zmN/QR1jYgMBeH7q8y79LB6wmJyGHJafepvP/H0x104lSdaDCU7UaMLtIk8HpJJRl8HHpz52OcVit/BC2gtEaaO4Y+Qd3fdpbHT83dtyGjquCEDaY6HGUNOjjOdB4dKeI3qzVKTRYrNQ0FjQY0Pg56UgOqDruNq50JUheKqLdrdVQj20U9lkZHTpCTT11QTecAMAJ2skSd7jkx5Hq9Ly7N5nOw1w2ew2DuozOPboZUS//E/USQNoee8d/vNxLoMPF8KJVegVE8BuRzux6y37TqdCV8HtP9xOtaGaN2a9wfSY6UyImMD6vPU9Crjl1Ofw2M7HuO/H+7hp/c20xKymSennUs9eplYT/fI/ES0W6j/9FO/Ro3ukLPk+73v81f5MiZri2pj9g+TCCUzg6UXDWHvfFN68IZVlE2I5UdrkUMg4MfVB6edO1z0YwjRhWEU79QFxUqZuR2LGg0XnvjxzwU6psmsr6XXp+Kn8iNK6uhYElYqAK67AlJHhSPY6nbYqpH/5bhtDvFpfLAGus1bjyZNYysrYO9GfcE04if7OssPRYaMpbi6m1iAFN4OXLgWgRhuImNyziqgoVBCSDFXp5DbkMixkGF9e/iV7r9/L9uu2O2S3XaE3W/nd54f57Qf7+Ms3x3l+fTr1ejOXDun82nnxc1CKIjs13twx7BaCzVezr6AHiXkqLYQN5ZK6Ci6JvYS3jr5FaYtzWbMV6SvIacjh0QmPOsqVdEpzBbwyQirVjhQojg7wdqkQ0Kb2aduRrisGR/ggJay8rwAAIABJREFUijiqBRQ2FWIVrQwM7JkhSIn0O+u9N3pCV/LRr0VRdFPvF0RR7D4q8yunsFbPorxd2ELC8L1UKg3clok4LWYafxj7Bw5VHeLb3G/dXp/fmI/eqmdk+Gj8Fiwg7r13GfjTj5QmRHDvOgNV+Y3oWyIRVKpu0/o7ktuQy43rb6RKX8Ubl77B6DDp2oVJCylpKXG4FTqj1lDLPT/ew49FP7bOFBtR+GSREZLksiIAaWUT8fTTAARcc3W349Nb9Gwr3sbc+LkoT1c/2axSELM1R0KlkDEyJoD5IyL545zBCAL8mO5G5eMfA2NugMOfQKPzCyK8VXRUOXSBVGqjIzGtGae5PzkfLz8mVWtdeaMj8Sq9Np0hQUM6fVhVA6UH3pTn3v3WlkuQ11DE8jGtn9uNITC01tXf4FvARVEXudxvVOgoAMffUZ2UiHnxNXw+cCYfdLJRjVvChiBWnXKqjCmXybt/iQL5NTqufH0364+X8/Dcwez58yUce2oO2c8vYPHozqWr/uVHeaS2nsfjFnL/uD8wNj6IY272/HVL9FgoPcifxj+KIAj8Pe3vjqaTtSd544g04ZkZ232uAz89J60I9r9LS3Mju3JqXVYD0L7rWk82lB8U7qwcymmQvAHdrQjsdpGMimaG9mJ8ADwZwj3mTEsgVR5PZ0x1Nl5XXeNI5z9ec5wEvwT8VH5cMfAKxoSN4V8H/+Vc66aVtg082qo7AigjIyl/7G7KgqFmRxBN+3PwTk11KpPbFUeqjnDThpuwiTY+mvcR4yLaU+tnxc1CLVezPn99p9db7BYe2v4Q9cZ6Ppj7AV9e/iUXBz4AQFVAxP+z997hbVZ3///raHrJe694xokzyZ6ssELZK+xS6KS7paXw0NLdLzz90Qc6gTIKlLLLDAQIZEISZ5A9HTuOtx1vW7bW+f1xJE/JVobjJD6v69KVSLolHa/7c5/PeL+hbrffidSoyy8j9+OPibpm6BbD5WXLsbvsfCnHj4pJzQ5wdih9/n7ER1iZmhHNJ3sC+Ass+JEqgK59tM/DSWWqBlCbOXPga2KyIftsWPGQcnkDFYze9m6Iq7fB/o9wepzsb9zPuNjA/gpWXyA44F++2DdLYAlpZFJ4MyAgcmC3UOeOnciYKMpC2vqkhXwUxhViMpj6BPQpD/0a92VX8/cVxX3luwcjsZDa1gpana1DdrX0pq61iyv/soba1k7+decsvn1eHilRoUSGmP27qvVm60vc6DCyZMGDgMqJVzTZae4IwsI1bTp0NpPS1cHdU+5mRfkKlh5cyiObHuGW924h3BzOz2b9bOir6urtsOUFtTvsbObzN/9Os93J7fOyBhwaHxpPtDU6qB3BmLhwLCYD+707gtKWUgCyIge+b29UOsk9rPUB0IEgKFwNDeyfM5eWD4OXQrK+9wYOg4n0W9XWXErJ9voe2V6DMPCtKd+iobOBD0sHvu+2+m3YzDbGRPaVeZiZV8DvlhjpCjHhqq4e6D8wCPeuupdISyTPLX5ugHFKhCWCc9LPYVnpMpwe/394fyz6IxtrNvLg3AcpjFMFxYo6dYVYExGpBN/a/ZePLOlpQW1t3yt5j9Tw1O6dSh98hdt0Pydt4ILxSWwtb/avZx8zRrmzbf5XTwrL7SJxj+qXrxV+DG2EgKsfV6mS1+5Uyqzr/6FmDq7+B0RlwKqHKWk6iMPj8Fsf8GHJyECYzXQd8H/SiLJGYZRhxES1KumMyFT1uf3o3LGDhqwYhDAwO2WgN3WIKYTxseO7O4d83HvJOLpcHh5dHqR5fGIhxRa1MwlWSRVg1b46WjpdPPOVWSzMPwrvEEc77HobJlylCvX0cu6rHloupHv3VrGRWwpvIS86j3tX38szO57hqryrePOqN7t3XQGREpbdD6HRsOR5nImTyTrwPF+amOzXI1oIQV50XlA7AqNBkJ8Y0b0jONx6mMSwREJM/h39fPQUivWOYMRp/fAj3M3NtK9eM/TBqJN+wpbP2TZmMiEJyl6hpqOGent9tzkHwOyU2WRFZvHy3pcHvMeO+h1MjJ84oH86s24vjTbBnxcXEn7uuUQGEKnqT3NXM5XtldxQcEPAP4hLcy6lobOBteUDLSw/KPmAF/e8yG2Ft3F5bs9n7q1yYCKCcpN3nYMYoA/FEfsR1lWu49KcS/32jVNeBBFJflMmAOd7tXg+3RtgCOzc+5Ra6nNXwZFiOPAxcc1VGBC8u3P3gMlPQJ2Qr/ybuvp/69vw6e+UXPOk61XtobyIPXtVprR/x1BvhMmEJSeHrgP+GwSklLgdcVhDGlVR28/X6OnooKu4mN0JDgrjCokJifH7XlMSprDryK4+AT0nIYJbZmfynw2HOVAbhDd24ngOeNtCj2ZHsO7gEWLCzEol9WjY/a6qx0y5sfuhwqOxcE0YpwTzKjZhNpj57fzfMi91Hk9d9BS/nPdLIi1BnEj3fQAlq9TvSWgMb4dcTr4o54GJgXtj8mPyOdB4IKiMQW/NobKWMjJtQ3cu7a5qwSB6UkvDxZCBQAgRJoT4uRDiSe/9fCHEZcO6qlOMlg/UVWMwujGgxL3C25qozZ/c/Zgv1eOT7QW1K7ih4Aa21m3t7joB1ZO+v3F/t9Z7byJ2vUO0W/JZbARH7v89lvSB6QN/+Pqr+xcXe7MwbSEmwvjuO//koQ/2dF9ZOz1O/m/z/zE+djw/mv6j7uM7HC4O1rcTbU6mwuO9Cj+OQPBB6Qe4pZsvZQcQtz28Qe0GAuwsxiXbSIsO5WN/dQJQtYLb31Jibs9dCWsfxRSegM0cy4bDJVz117V8dsDPH/24S5X20vZXQRh6VFmn3goRyeze+xYhxpAht/nWvDwc+/0HgsrmTpxdMTgN9QEDQeeePeDx8HlUrd+0kI8piVPodHeyr6Hv1f/3FuUTZjZy17828nJRWUBl206nm4OuOA6EhBIrLMSGBN8iur6kgVnZsT0qqcGy9T/KGCejp/Eh0WYlNtwSXCAwGNVEtHcAcEL8BB6/8HFmpQS5Y/a44cOfQ1w+zLiTg3VtPHBgLG2maFJ2/yvgy/Jj8ulwdVDZPrTd+oTUSKqaOzlQ20ZZa1lQLay7qlrJSYgY0s/keAlmR/AM0AX4pAUrgN8O24pOMVz19XRs2ECHFTr37sXTMbRhTOPnXhP5mT0pjO112zEbzAOcq67IvYIQY0ifXcGuI7twS3ef+gAA9ibYt4w0SzQGSyMr9gbv4eMLBDlRgQeK3G4jjqZpEL6VJ9etYsFDn/KHpbt568BbVLRV8J2zvoPJ0NPX7ht0SY9Ip9xeB9ao4woES0uWUhBT4L+Toq1Oqar6qQ/4EEJw/rhE1uyvDyzfnTgObn9TqZOWfQZTb8ZCDMLUQoLNym1Pb+CFdYcGvu7CXyul0yseUwEFwBxC1ayvsMbZwNjw1G5N+0BY8/NwVlb67RzaVdmCxxFLq6sWV0uF/0DgLRQfSJKDFj27B8vq+qaH4iKs/O3WaYRbTNz7+nYWPPQJrxQNVEj96WvbOP+R1ewwhZLmkOwPoJzZn8omO2UNHd0yDH6RUs2CbHu1R9iupVIN9E25sU/BXlm42rqVN4ckfbrK8buCrIP0WfwXaoDu7HtwCxN/eH8PBlMIYsadsHepkij3w9F0Dl11VhoWk4F/rNpJQ2fD0Kkqhl9awkcwgSBXSvkw4ASQUnYAw9fHdIrR+tFH4PHw37kGhJQs/eCvQ76mauVnNFhtFM7qSQNtr9/OuNhx3VOgPqKsUSzOXsx7B9+j1dFKbUctDxc9jMlg6rN7AJThittBZvw4rKFNrNh3FIGgpQSzwUxqxMD2Rh8r99XRXnM+NksUk6d+zOKJiTy+ah+PbvwHk+InsTCtb3ulr1VzbFwmVW1VuBPG+u0cCoa6jjq21W3zPzsAveoDg1/hLRqfiN3p7iNjPICUKXDra0pKYebXcDlshIS08t+753F2fjwPvLmD97ZV9X2NOQSuf7bbqEdKySt7X+Gqw/+lxmTizsN71axCf9/nXlhyVYrFX+fQrsoWpDMOt3RTaRT+O4a276Al0kTymMI+Kcb+JIcnk2HLYHnZ8gHPLcxP4L3vLeDFr84mOz6c+/67vY9h/KZDjby9tZKLChM5bBbkdLRx4Z9WccPjn7N0exWu/tpOvfDp8czJ6RcIpFTttv/9JjxSCI9NhTe+Cn+fB/++wdumKWHykgHvOT45kr01rYN+bjcpU8HjHNDGHBTezrCDkbO59u+f8dGuGr59fh7h876mdhubB84mQE/9xNcFNBjxEVaun57OO7tUQB8qNdRsd1LRZB/2QjEEFwgcQohQQAIIIXJRO4RRQcv7H9CRHseKySr2fbb8XwHloEGdIOTWzeyMz2ZaltpSuz1udh7ZOfAK38uScUuwu+w8uvlRbn7vZkqbS3n0vEcHbslL14DFRnrCJNyGBraVH6GhPTgXrZKmEsZEjulzRd+f93dUERMSxX2z7mV/825mTN5NVvZumpw13FrwtQHF3l2VzUSFmhkXn4VLuqiJyzrmHcGaClV/OTs9wHBc+QYl+ZA6eKvsnJw4wixG/22kvcmYBbe/iYxKp7ktHEwt2ELM/PPLM0mPCeXVTf69BKSUrKtaxx0f3MFv1v2GSQmTeOPsR1gUmqo8np88V6Ww/NDdOeQnPbSrqpnkELVb22W1qEJ0P5q2bmJvkpvrC64fsvB+bf61FFUXUdw0sEtJCMG8vHj+eftMYsIs3Pv6NlxuDx6P5Dfv7iLRZuVnl6XQafAwydnOrxYlUdlk5+5/b+ac/13RLRXRn3XFDer3wSuyhpSw8Wn4y0x49kuwZylkzlGpta+vgPP+RwX4Lc9Dxmy/OlnjUyJxuDz+6zf9SfZeOB2loRAABz+l3jaOS/65h0NH2nn0xql865xcVSNKmqB2DH6IsESQGp4a9ITxVxfm4DapC7ihUkM7vQF6QupR1luOgWACwS9R8tMZQoh/A8uBe4dzUacKrro6OoqK2Ds1jrDEVIypKUyrt/HTVT8NqDHiLC8ntOkI9bkTuyVji5uLsbvsAa/iJsRNYGLcRF7e+zISyXOLn/N/Qjy0FsbMJSMyE4kHTE2s3BecOmZJS8mg9YEul5vlu2u5qDCZy3IvZV7qPP7yxZ8h+iM89gw+KBr4y7irsoUJqZHdw1AVtkRor4P2Qa7GQfVo9yuura5YTWJYYmDT98NFSvLBPHgfe4jZyIK8eJbtrGZL2dDDSBVNduz2CFx00OHswGgQXDY5lTX76wcE2c8qP+OWpbfwtQ+/xuHWwzw490GevPBJ0nMvgrs+Vsqv7fXw9CWw7u8DvkZLRgbCYqGr2F8gaGFiwjjMwshOi2XAjsDd1oY4XMnhNEvgGkovrs6/GrPB7LcRwUdUmJlfXTGBnZUtPL22hHe2VfLF4SZ+cnEBlfZSAHKdTr6cZ2flT87jydtnIAQsefxzlq9eBc9e1qdLbH3Jkb71gfIiePeHYLXBVX+HH++B65+BmV9V+fxzfgo/3AGXP6aCgx98aZFdwdQJYrNVwbhmaEXQPnS1IQ9v4LXGfBbkx/PhD8/hyqm9utziCwbd6ebF5AWVGgLIjg9nXLq6jo6x+NHR6sUWb8Cdmj78ij5DBgKvfeQ1wB0ob4IZUsrAl8RnEC0ffghS8nGunboj8bRmFTCpLpTk8GS+/uHXeb9koAhri9doJqxXfcA3SBZoRwDw/enf54LMC3jx0hcHtHYC0FoD9fsga0H3iTc2qoWPdw0dCBxuB+Wt5YMGgjX762nrcrF4UjJCCB6Y8wBu6eZIZy2XpH2Zt7dWsXx3T4++y+3pHnTxrac83PsLu39Z4MW018P/Nw42PdP9kNPj5PPKz1mYttD/la7bBZWbh0wL+bhjfhZ2h5ur//YZ1/xtLR/sqArY1bGtvBmPU51sfAY1V0xJxeWRvL+jJz10uPUw3/742zR0NvCLub/gg2s/4Lqx1/Ws12BQpjh3f666ij74GbzxtT4y2MJkwpKdPaBzqNnu5HCDnYmpsRSYo9hptfTUIbwc2VqEkJA4bW5QfsixIbFcnHUxbxe/Tbsz8NX0pZOSuWB8Eo98tI/fL93NhNRIrp2W3i1/kudQqRajQXBhYRJvfXs+U9Kj2bnsKShdjdz6EgDVzZ2UHunoO3i19T9gCoUvv638rS1+1m0Jh+lfVkHeD3mJEZiNIrg6gcGort6PdkdwaC3C42S1ZyI/v6yQBFu/uZyEAmXW0+V/DfnR+ZQ2lwblTQCQlWzH44rg3S/8CCb24ovDTeTEhxMVdpyy8kEQTNfQcinlESnle1LKd6WU9UKIgcnHM5DWD5Zhzs1hY1g17a1JfBGeiqeyimdnP8rE+In8dNVPeWLbE31OMpUrP6PZEsa42T2/2Nvrt2OzDJwJ6M2clDn86bw/kRSe5P+AQ97W1awF3UWmgnQnK/bWDnA+6k9ZSxlu6R40ECzdXk1kiIl5uardNcOWwYNzH2RJwRJ+f8l1FCTZeODNHd1F2OK6drpcHiakRZIcnqz09K2hSv5hzf8FzpUf+FgNhW18uvuhL2q/oM3ZxsL0hf5fM8ggmT/m5cbz+f2LePDyQurbHHzzhc3c/e/NNHUMTKNtPdyE0aMCmC8QjE+xkZsQzjtbezpBntj2BEaDkecWP8f1Y68fUOvpJiQKlrwA5/8ctr+mpo974a9zaI/3andCaiQTpJVdViueflPVW1a9BsDC8+8I6nsAsKRgCe3O9kE1pIQQ/OaqCZgMBmpauvj5ZYUYDIIDTQeIC4kj2hrVR2IjLsLKC1+dzZU2dQVc/5nKnQ+oD7i6YMcbMP4ytSM4RiwmA7kJEcF1DoEKKNXbgzK176b4UxzCQqVtKll+3ARJ8F6Y1ftP/+TH5OOSru4hsaFo99QQbkjiqdUHB/ppeJFS8sXhJr/zC8PBYDLUIUKIWCBeCBEjhIj13rKAQSyOzgxcR47QsXEj9oVTkUjcnaksl+okadlXxpMXPcmXcr7En7f8mWd3Ptvzui2b2BGXw4wcdazL42LF4RXMSJpxfFoh3voAyVNIDEvEYrCQENtKu8PNuoODX1mUtAzeOupwefhoVzUXFCZhMfX8SlyeezkPzHkAq9nILy4vpKq5kzc2K4mGnZU9+UuzwUxKeIoyVlnwA6jfqzot/LH/I/Vv9XYl1QCsLl+NyWBiTkoAzaQhBsn8EWE18ZX52Xx6z7nct3gcH+2qYfGjqwcUkbeWN5EbqwJ0cbPKpwshuHxKKutLGqhu7uRQyyHeKX6H68deH5TODgYDnH0PnPszVYRs7jGc8dc55Et7FKZGMtHhoN0gKG0u7X5eSknDlg00x1gYlzdwiCwQUxKmMD52PC/tfWnQPveUqFAeu2kq9y0e130i75aWSCwcUHy1uNrI7NxDoymBhLa9FK1X31dbiKmnw2XfMmX002su4FgpTIk8ukDQ1aJMhYJEFn9CkRzPrPxU/3+jXjtW6vwHAl/BONj0UFlrGRMTc6ls7uSDHdV+j6loslPX2sXUzBEOBMA3UBaV47z/+m5vAX8Z/qWNLI6DB0FKSseoyT9PZxqbQpKQBgOd27ZjMVr4w4I/MDtlNi/ueRG3x42zspLQI7VUZY0nPkJtL1eXK7ONq/MG+qAeFaVrYMxcMJowCANptjSkqYEwi5GPdvn/ZfLRPUMQ6T8QfFZcT0uni0snBs5ZzsuNY0p6FI+vKsbl9rCrsgWryUBOvLLhTItIU0JfhVcpq8g1jwy8KvO41Ykx/2IwWlTqAFUfmJ40nXBzuP8PP7xh0EGywTAaBN84J5c37p5HiNnILf9c390l4/ZItpc3Mz01m7iQOLbX9aQULpucipTw3vYqHt/6OGaDmbsm3RXoY/zj7TBiT88VudWP5tCuyhbiI6wk2kKY0KIC1c4jPZ7Bm2o2kXS4DeP4APWTAAghWFKwhP2N+9lS69+cx8f545L4xjmqWOuRHoqbi9UgWeJ4FQh67/AOrUVIN2GXP4QLI9vff4JP9tQyOzu2R0Zi28vqZ5Z97lGt2R/jUyKpbe3iSFsQPSpHWzBurkDU72WFcwIL8uP9HxOTrdRYAzRC5ETlYBKmoCaM7S47tR21zEobS1ZcGM8E0H/yFeRHfEfgtafMBu6RUuZIKbO9tylSyjM+EDirVH54j7keo7QxJjqFLpOV9pTM7sEyIQTX5V9HdXs166vX07ZBXblap/do+Lyx/w0SQhMCpz2CoVd9wEd6RDqVbeWcnZ/Ax7tqB73iK2kuITk8OWBu+YMd1URYTYH/EFBf67fOzeXQkQ6W7qhmZ2UL45JtmIzqV6g7EBhNyh2sYpOa0uxN5RawN6hcesFi2PYylU2HONB0YEBrajcdDbD3faX5cxw7qsnp0bx593zCLUYeXa7+YIvr2mh3uJmaEcPkhMlsq+8xQM9LjKAwJZLXt23mvZL3uHHcjcSHBv7++CU+X11N+qSz6dVC2is9tKuqhcLUSHC7yGmsIFSYuutKAMt3vkVKI6TPPOeov+7F2YuxmW08+NmDA2QnAlHVXoXdZVeBIHMudDVDaa+f5cEVYArFWvglnNkXcBmrqWux98wPdDSoHcGk64P3vh6EbqmJYOoEiePV0F+wgeDgCgDWyknMzwvw8zWaIC4vYGrIbDSTFZU1qKy8D5/5UGZkBnfMy2JzWZPfpoYvypqwmAyMGyaz+v4EUyz+sxBiohDiBiHE7b7byVjcSOKsUlfZWyjHbU9lfm4845Jt7I/NpHPbtu4T73mZ52Gz2HjzwJtUrfqcVnMoeXOUAmRNew2rKlZxZd6Vg7ZtDkmv+oCPDFsG5W3lLBqfSHVLJzsqAm+dDzYfDLgbcHskH+6q4bxxiUNOL15UmExOQjh/X1HsPXn1dBKl29Kpt9cr57UpN6urwTX99Pf3fwQIyD0fpt4CHUdYs/WfAIED5ed/BUersp88TqLCzNy1IIePdtWws7KZrd6rrikZUUxOmMyhlkM0dfa0Rl4xNZWDrjcxCQthHRfw+6W7g+pE6sP4y1W3l7eTypKZqTqHvAVjh8vD/po2JafQWolRuhkfmtzthevyuHC9qZoSomYendw4QJg5jEfOe4Qudxe3v387v133W1odg59QfS2nedF5MO4yCI2Foqd6Dji4UrWBmkMInXkLiTRyhW1/j8T0jtdVP/8JSAtBjyFLUOkhS5g6aQcdCD6lyRCNMXkCseEB6j4ACWMHbY0uiC1gx5EdQ0pNlLUqT4zMyEyum5GBzWrimbWlA4774nATk9Ki+qRqh5NgisUPAn/23s4DHgaGdhc5zXFWV2GIjGRXRzFdHSkUJNtYkBfPWnMS7uZmnIdVn7nVaOXS7Ev55NByOjd8zs64bGbmKLGtt4rfwiM9XJM3tOrmoJSu7a4P+Ei3pdPubGd6jgWDIGB6SEpJSXMJOdH+J4o3ljbQ0O7g4gkBitS9MBgE3zwnl91VLTTbnUxI7blaSYtQZaPKtko1fDX32+pq61Av3aIDHyuVyLBYyF0E4YmsLltOWkSa/0DV0aBE3gqvUt0gJ4A75mdhCzHx2PL9bC1vIsJqIic+olu+ufeuYN5YM6bIrbTVzeKhpeU8ufogNz25zr8MRSDGXaZUT701E2E0Ks0hbwtpcV0bDrdH7Qi8xjkTovPY27AXp8fJxqK3uezTduzzpwRl8emPOSlzePPKN7ll/C28uu9V7vjgjkE7iXzDUbnRuepnedatKr3VUqW0+ut2K/c3UB1SIVH83/g95CR4Td+3vgRJEwN2Ah0tcRFWEm3Woy8YD4XHgyxewSrXBOblD1H7SRinpov9+DgDTEucRr29vo/vtD98O4IMWwYRVhM3zMxg6fYqqpt73tfp9rC9ovmkpYUguDmC64BFQLWU8ivAFGD4JxxGGFdVNe7EGNzSjaczlYIkGwvHJrDLO+hj39pzwrg672rSKroIra9lV85ZpMeE4pEe3tj/BrOTZ5MROfQo+aCUrlFXYL222T7Z4jZ3DTPGxPLR7lpcbg+vFB3m4j+t4nmvTEJNRw12lz3gjmDZzhosJgPnFgRRBAWumppGitfAu3cg6G4h9fkpz7hLDUW9/V1w2tUVccUmyPe6ZBlN2Cdfy3pXMwuTZvov0n32mGq/PPdnQa0tGKJCzdy1IJtlO2v4YEcNk9OjMBgEE+ImYBAGttX1/Fz3tKxDCMnvL/wKG+5fxIb7LyAzNoyvPFvEmv1BBoOUKRCV2Sc91LtzyDedXZjSY+wzMXk6Xe4uDjTsx/HbP+E0QcHv/nhczQZh5jDunXUvf130V4qbirl31b24Azivba/bTlpEWreNJNPvAOlWg1++dF/OuepfkxUmXKO+vtfuUsNjFRv9TgkfD+NTIoObJQAVCJoPqwuJwWgoRnTUscZdyMK8IZRS48d6fZz9p39mJKl08KaaTdBWCzV+zIxQHXxR1qju7+2X52bhlpLn15V2H7OnqpUul+eUCwR2KaUHcAkhIoFa4DjPbKc+zupq2mLUCc/dmca45EhmZcVSFZ1CV1gErct7OmgL4wr5UnEULgOw8ByEEGyo3kBFWwXX5B/nbqCtVnXh9EoLAd1X+Hsa9nBhYRK7q1q48E+r+Onr26ht7eTnb+7g1Y2Hu32I/XUMSSlZtrOaBXnx3cNvQ2ExGfjhBWNJirT2yV/6dgTlbd5AYI2AK/6s9Fs+/T0c/BSQkHdB92vWJBdgNxhY1OXnhNReD+ufgInXqLzvCeQr87OxhZiob+tisndYJ8wcRn50fp9A8EnZJ2TaMrlm4nQSI0NIsFn5z9fmkB0fzl3/KuLz4iEG50DVNcZfrr5+bx966OTJOCsrse/cyaZDjdisJrLjw9XJNDaXCZnnAlD+3D9J2F/PFzdOIzw5OHHBoViQtoD7Z9/PyvKVPLJpoHWmR3ooqiliZnKvDq24XJXO2/QsHFiuFFyTe8mfTP+yEvI7vF6lZc7/Ocz+xgl+FaaCAAAgAElEQVRZr4+zMqPZW9NKsz2IXn3fTmSowTLvSb1EZDIjy7+Saze+zqF6/4Nl2VHZxFhj2FS9EV64Fv51md8W6rLWvqqjmXFhXDg+iRfXl9HWpWwsvzis0o+nWiDYKISIBp5EdQ1tBgbqFJ9hOKuqqLV5MBJKYmgKUWFmQi1GpuXEszZ/Lq0ff4yzxjvMJSXTdzrYmiNIy2/nneJ3eGTjI0RaIlk0ZtHxLWSn1wyun41ipi2ThNAENtZs5KIJSZiNAqNB8I9bp/P5fYtYmB/Pva9vY+luZVDiLzW0q6qFiiZ7UGmh3twwM4N19y0i1NJTU4gLiSPUFNqzIwDIPU9dTX7+F/jszyrXnHpW99MfNu0iRgpm7P10YIfRZ4+p2YFzTvwQe1SomTvnq8A4Jb1nczs5YTLb67fjkR5aHa2sr17PosxFfa7E4yJUMIiPsPL4Kv8mMwMYf7k6Ue5XvhNRV1+FITychqeeZkPJEWZmx2K0H4HS1TDhKjIjx5DZGU78sx/wRbZg7C1fP3FfPHBDwQ3cOv5Wntv1HK/ve73Pc/sa99Hc1cys5H4zGzPugpYKpcCavVANb/lIPQseqFVTwjf9R7XOmoIzSwqW2dlxSAmbDg1xlQ+9OoeGCgTq5xeXOX5odc+4PFWEDjBhLIRgWtI0Nh1eoSTLO474tTg93Hp4gNjcN87Jpdnu5BvPb6TT6WbL4SbiIyykxwyfR3F/gikW3y2lbJJS/gO4EPiyN0V0xuLp6MDT3MyhkHaMrnTGJfecLBbmJ/BC4nRwu2l65RUA7F98QVhDG2vGG3iq+Cfcv+Z+ajtquWfGPViNx/EH0VqjbPOyz4a0aX2eEkIwI3kGRdVFZMaGsebe81n2g7O5ZGIyIWYjj982nbMyY3h9xxYMMpQ7n9rNeX9cwRO9Tl7LdtZgEMrQ5Wjpn6YQQvR0DvXmwt+ALVWZueQt6j6BdLo6WVm+kkUxEzDV7lIdRT46GmDDP2HSdT3DPCeYr5+dw/9cOp7ze3noTk6YTJuzjZLmElaVr8LlcXF+5vkDXhsTbuG8cQlsLG0MTgwtYxaEJ3Snh4w2G9E3LqHlgw9oKy1jVnasek56oPAqhBDcsN2G2Sl56fJI5g4iOX2s3DPjHmYlz+LRzY/28S1YX6Um4/vsCEDVAmypKkWUc+7ANxxCefV4OSszGrNRsL4kiEAQkaiaFYaoE9ir99IoI5haEFiRtxtziGqLHkRqYnpkLuXOFqrTvBc7pX39SxxuB1XtVQM0hqanR/Dv+bUcKt7Dd17czOZDjUzNiB5Wj+L+BFWSFkJMFkJcAUwD8oQQx5nvOLVxVqvC6z7zETpak3tEtICF+fFUhcfTOnkGTa+8gnQ6aXlvKQ6jmeqcm/jWlG/x0pde4pMbPuHq/OOcHVh2H7g64Ut/8ts6OSt5FvX2ekpbSkmKDOljBRhmMfH0HTOJjW7E7EkmJsxKdJiZ3y/dw4c71df34c5qZmTFEhdxYq7e0iPSe1JDPkIilXQzAgou7X54TcUa7C47F025C0whKv/sY/3jyqRk4Y9PyLr8EW418bWzc7Caek5gPrXXbXXbWF62nITQhIEKsF5mZ8fR1uUKLm9tMKp22QPL1SwFEHv77Uhh4JoDq5Qsw643ITYHkifhcTiYsqGeTfmCs6ZeMtC7+QRgNBi5efzNNHY1sqGqRySvqLqIMZFjSA5P7vcCE8zwXv/lBOH7e4IJMRuZkh7N+iGGJ7sJomDcUb2PEpnMzKHSQj4G0xySkul71LDk5jl3Km+F0tV9Dqloq8AjPQNVRzc+zdyNP2CN9fvcV3wbNzY/xfT0iODWdIIIpmvoaeBp4Frgcu/tjDGmcbg8rNpXh9vTk5rwzRBURbhwejuGfBSmRJIeE8rrGXNx1dXRsuxDGpe+z/qk8Vwz9Rbunno3E+In+HfYOhr2f6za8M6+B+L9WwX6rtqKqov8Ph8ZYsISWs8lYyfzrztn8dLX5zAlPYofv7KVT/fWsqe6lYsnJPt97bGQZkujorViYAtd3iL40W6l5+/lw9IPibHGMDPzXCi8UskxODpUHn39P1TQOMG1gaHIiszCZrFRVF3Emoo1nJdxXsCf4+wcpakzqNx1bzLmqIlXby+6OSmJkrMWcnHZBsaLeihZrbqjhKD1o4+wtnTy0VmCS7MvHeKNj52FaQuxmW3dPtUuj4uNNRsHpoV8LPghfPUTvyqhJ4NZ2bHsqGim3ZtLH5TkSard0xVYndfcVMIhmRK8umfCWFVXcPv5/N3vULB/JeEGM5vaDqlU7qG1feoEvo6iPqkhKWHTv5Q0y8V/wBKXyTdN73CxWB/cmk4QwZyt5kgpZ0gpvyyl/Ir3dmcwby6EuEQIsVcIcUAI4bf1wzufsEsIsVMI8eJRrf4EsGpfHbc/vYEfvvxFt+6Hy7sjqI8Ed0dOn0BgcNl5PeS3tJgrcScmU/P730NjAyvTph5TisUvjg5470eqU2H+9wMelmnLJDEsMWAg2Fy7mXp7PdOSVFrJajLyt1unYzYZ+PpzysnposITtGbUjqDD1UFjl59e+8iU7l1Np6uTFeUrOD/zfDVfcdat6iS5511VkOxsUmbzJxmDMDA5fjLvl7yP3WX3mxbykWgLISc+PPgrVJ88htdBC+CVnLOxup20/v0hlXKZcBUATS+9jDk9nQe++1rwDlvHgMVoYdGYRXxS9gld7i52H9lNu7M9cCAwmpX5ywgxOycOl0eypcy/DHYfUqaoWYaqAEN0jg4iHTW0hWcG7/6VME69Z2O/aWAp4dPfYUws5KzkWapzKGuB8vDuVSc42KQaN/oEgsrNULtT7bbm3k3Gd5biMYeTYz8GKe3jIJhA8LkQovBo31gIYQT+CiwGCoGb+r+PECIfuA+YL6WcAPzgaD/neKnzjq2/vbWSbzy/iU6nG2dlFVKAKzoVgyeGvMRe27T1/yCpcRPfC3mP5WMX4m5ooMtspX3aLFKjT1BxZ8sLSivlsj8NWnQTQjAzeSZF1UV+B1le3P0ikZZIFmcv7n4sLTqUP990Fm6PZEJqJBmxQytZBovvF/xQy+A6L2sr1qq0UNZF6oExC1T+tegpNUCWtRAygtcVOpFMTpiMS7qwmW2BT4heZufEsqG0oc9uMiBxecrBrUIFgsZ2BysdNuomzaLx/XU4jFmQPJmu4mI6ioqIXnID4+KHf0e0OGsxbc42VpevZkO1ShHNSJ4xxKtGhuljYjAI2FASxC4s+xxAdBvO9Ec2qJOyKdH/btsv8d56Vf/00KHP1O5jzt1MT55BcXMxjSleyflDa9XnScnbB99mXOw44kJ7Gfdsfk4ptE66Tt03mjBkzIKydcGv6wQQTCB4DhUM9gohtgkhtgshtg35KpgFHJBSHpRSOoCXgCv7HfM14K9SykYAKWVw4vonkKYOVSh74Evj+XRvLbc/vYGWssM0hwssjCc7Prwnj9zRoJQ1rVGMl8WsiYzEY7awJnki508+eh2cgOz/UHmn9msZ9cfMpJkc6TzSLSzno6a9huVly7km/xpCTX0D1Py8eB6/bQa/uSqwy9WxUBin4nxveQR/LDu0jGhrdM+J1mBQ/r+H10FrFSw8+bsBH76awML0hUPm5mdnx9Ha6QrSU9egCv7lyseiqFTtJCK/eju4nZS+JbDv2KEaEMxmoq85OWW4WSmziA2J5f2S99lQvYG86Lyjl9I4SURYTUxMiwquYBzm7VA74F8oue6QmtmIyTiKa9wEr9ZT/wnjjU+rID/xWqYnqR3T5q7aPnWCzbWb2d+4nxsLek1bO9ph++sqZRrSKz2VOVfZeNqD2PmcIIIJBE8BtwGX0FMfuDyI16UBvcfsyhmoWjoWGCuEWCuEWCeEuMTfGwkhvi6E2CiE2FhXF7w9YzA0dTiwmAzctSCbR288iy1ljWzc9AV1NklbUzYFSb0kdNf+n0ph3PQfpNHK9VFF/Pjc7/P4pCu48ESlWJydqtsgN3Baoje+k2lRVd/00Cv7XsEjPdxQcIPf111YmMS0zCCLZEGSEJZAUlgS2+sDb2sdbgcrD69kUeaivrIbU28GhPrjHYFiZPcyEqZSEFPAdWOvG/JYX50gqBMTqPRQ7U5wtLO+pAGrycCEmEOMuaAOQ0Qkh27/Mk2vvU7khRdiihvE9/cEYjKYuGjMRawsX8mW2i0Du4VOMWZlxbLlcNOQ0uuAqk1VbFQpmn7UH1Kifln5/psB/GK1QWQ6lKzsaXduq4Ndb8HUm8ASxoS4CViN1p70UKmqE7y852VsZhuX5vSq+ex8U8mnTOun2DNmLiD7Ot15PPDej9VQ5jAQTCCok1K+LaUskVIe8t1O0OebgHzgXOAm4EnvzEIfpJRPeOsUMxIShpgAPEqaOpzEhJkRQnDFlFTe/e5CEjobOBIpqK5J66kPNFeobpbJSyBrPqLwSq40rqEkPIaopPg+nUXHRdnn4LKrX+IgSLelkxSWRFFNTyBwuB28tu81zkk/JyiD7BPJ5ITJfVQ8+7OnYQ8drg4WpPXb7USlwbX/hCv/elzicsdLhCWC1654LagTYkpUKJmxYawPtmCcPkO1iFZ+wfqSI6olcvd/sWaNIeuV17BkZ+Fpbyf6xhM7lTsUi7MX0+Xuwu6yMzs5eJnrkWB2ThwOl4eth5uHPjh3kfp+H1w54Kmumv3UySjyMo6yWWLut9V09fp/qPtfvKDqBtNVR5XFaGFywmTWVKzBkTkH7A3Ul3/OR2UfcWXelX1355ufUzv/zH4aUmnTlS1r2Wc9j5WugqJ/QoN/tdLjJZhAsEUI8aIQ4iYhxDW+WxCvq6DvBHK697HelANvSymdUsoSYB8qMJw0GjscRIf2iE2NTYogrq2DjugY4kKjexQ5V/4/9Ut13v3q/rTbsbrauCliC1dODaBjfiwUf6Ikb4NIC4GqE8xKntWnTrCsdBkNnQ3cNP6mE7Omo2Bi/ETK28pp7PQvzubbLfh1a5t03QnTFDpZzM5WdQJPMHWCNJU26Cxdx67KFs5Pk6pbaOJ1mBITyXr+ecY8/xzhs4avQOyPqYlTSQ5PRiBO2fqAD1+rZ1B1gvQZYI2E4oHpIWtLKXWWjG713KCZ8y3V0fbhz1Wab+MzqsaVOK77kCUFSyhpLuGndWtwAa9tfwaXx8WN43qlher2qlTotNsGXvhYwlWxu3edYMsLKn00bmib0mMhmO9CKMqs/iKOrn20CMgXQmQLISzAjcDb/Y55E7UbQAgRj0oVHeQk0mR3Et3LCq71SBUWh4e0vAI2/fxClT5pLlc/iBl3QYzXZSxrAcTm8IvUjfz4whM49FT8ibpCsATQ5vfDzOSZNHQ28MLuF3hpz0s8veNpsiKzAhu9DCO+E3yg9NCO+h0khiYGdmI7zZidE0dTh5N9tUFIJIfHQ0wWLQfW4ZFwgfwMkN2FQkN4eB+L05OFQRj42qSvcU3+NT36Qqco0WEWxiXbgkvHGc1qGLO47+S6y+0hwXGYrsiso1+AEGrXakuG569STR0z+s7XXpx1MffNuo/l1Z/zQGomr9ZvZl7qvL4OhasfAaMVpgS4WMucq9JAzk5VK9j9jpL1HsKz+1gJZrL4K35uQ7aPSildwHeAZcBu4BUp5U4hxK+9w2l4nzsihNgFfAr8REoZ5D77xNDU4egTCLbvVHbMGfm9Jnl3vK52A7O+1vOYEHDWbRjK1mJoGEJqwNnZx7s2IK3VSh8lyLSQj9kpszEKIw8XPczv1v+OA00HuHPincc/y3AM+MTbAhWMd9TvYGL8iS1SjyQ+j951wegOAaTPJKRmC2ajIKvqfdU/PkzT00fDDQU38Mt5vxzpZQTF3Nw41pc0UB+MUU3u+UqArr7HNKa4vIoE0Yw16RiTD2GxcN3TSgIlLF5JiPTj5vE38/1p3+c9K9TiZElWr9pA9XZl3DP7G2oK2h+Zc5UsSeUWdf5xdao262EioNKYEOKnUsqHhRB/Bgbse6WU3xvqzaWUS4Gl/R77Ra//S+BH3tuIoGoEPamh/Xs+ZzaQV9Dranr7q5A2Y+AgzdSblQTExqfhkt/7/wCPG579EnQ2wzdXDx7Rfa1uuUcXCFIjUnn36ndxepzYLDZsFtvxSVscB2HmMHKjc/vIOfto7mqmtKWUK/P6N4+dvmTEhpEWHcqaA0e4Y35gT+hu0mYQuf1Vbk2txFCxERY9OPyLPMO4dc4Ynv2slH99VsqPLxoiiPouqoqXd3f9lO7bRgEQN+Y40pAZs+DG/4DJErDF+6uTvoq7pYLN2//NORv+DXlXqAvIjx5UaZ7BuuN8dYOyz9VuIGkSpEw99vUOwWCXjD6j0o30tar03U57pJQ0dTiJ6rUjqC5RV7Jhqd520No9KoJPun7gG9iS1eMbn1Yqof7Y9KzqXDiyX20HB6P4E6VJk3T0V8zptnSyo7KJD40fsSDgY1L8JHbUDzTp8Nkvnkk7AoBLJiazcl8tTR2Bp1h91EWp1Nm3up5RD/jsLDVBk5sQwUWFSTz3+aFuxc6AxGRBbG6fNtKGw6r9M3HMcc5pjL3Iv+5SL74x/0Een/ojjPuXqQLzwRUqKC38MYQO0rUXHq8GSre8oIbOzrp1WJsoBrOq9Amod0gp/9X7BnQM24pOInanG4fb070jqO2oxVNTi8dowBTvbd/b/qpSHZwYoD5+9k/A3QVrHx34XPsRWP5rVUyadAOs+VNAA2w8HhUIcs9XPeenMZPiJ9Hc1dxXiZSe+YIJcadXQXgorpmWhtMteWdb1ZDHLm9MokuaSGzZAemzempOmqPim17Fzpc2lA19cN4i1ZLtNZVx1ak0kYgNQmzuRDD7Gz0F5nd/qHw6ZgWhKJs5FxqKlb/3ZP9t4CeKYM449wX52GlHo3eYLDrUjJSShzY8REKLwJiYgDAaVYFp+6sq6gfK5cXnqZbSoqeUWmhvlv9Kaedc+r9w8e+Ujd67PxwouQxQvVVJ1x5lWuhUxFcw7p8e2l6/neyobGyWE9Rqe4pQmBJJQZKN/24uH/LYTw40ccDgPQHp3cAxc1ZmDLOzY/nn6hIcriEUYPMvVi3Z6/9Bp9NNRNshWixJ6u/xZOArMEckQsNBOO9/lJrpUGTOVf8WXKrqEsNIwEAghFjsrQ+kCSEe63V7FghC9enUx7eVjw6z8OaBN/nw0IdM8qQSkuY1ASkvUl0Bk4aIxmf/RBV2Pnus57GKTapPePY3IalQ/RJc8CvlP/zp71U66ZPfwRtfh8fPhqcXA2LIrebpQG50LqGm0D4FYykl2+u2+28bPc0RQnDNtDQ2lzVRUh+4KcDh8rD2QD2NcWepXeaE41SnHeV889xcqls6eeuL/l3p/chbpIQNl/+ag5uXkyWqcUYHUc85kYTFKq+Gc34W/NV97nlq9zD7m8O7NgYpFgOVqPrAFfStCbQCx+8kfgrgk5fopJo/bPgDs5JnEd9ahjk3RR2w7RUlkTxU725cbs+uIO8CJRGx9SV18u9tszjty7D1P7DqYXVfGJTGe0IBzFgAWfPBdvq3VZoMJsbHju+zI6jpqOFI55Ezrj7g46qz0njogz38d3M5PwpQwNxY2kC7w41r/g8h7s4z4mc9kpw7NoFxyTYeX3WQa6al95Fh74MQyi2vahsZy+8G0YY1df7JXSyo2YCUKUMf58OWrMx+TgIBA4GUciuwVQjxopTSCSCEiAEyfNpApzsqELh4Zv/vMBvM/Hbeb2iquYTIlGRwO2Hnf5WOfEjkkO/F2feolrDnr1IDYQWXqIJQ79caDHDzK8oZKTIFwhP7+BCfSUxOmMyLu1/E6XZiNpoHHyQ7A0iKDGF+XjxvbKngBxeMxWAQtHY6cbg83X4PK/bVYTEamFmYD0Fag2oCI4Tg7vPy+N5/tvDutkqunNpfwaYXIVFw/bNYn7gAi3BC4tiTt9DTgGBqBB8JISKFELEom8onhRB/GuZ1nRQaOxwYI/ZzsGUP98++n3i7CZxOTCkpsOc96KgP3oQ7Lheu+htc+ke4Zx8seaGPLWM3odFKyjcy9YwNAqBO+A6PgxXlKwBVHzAbzIyNOXP/AK+ZlkZ5o52Pdtfwx2V7mfuHTzjvjyvY4B1+WrG3lpnZMYTrIHDCuGxSCuOSbfzpo31DusVVh4/jV87b1J2koxZUPqMJJhBESSlbgGuA56SUs4HTv6IJNNudCKPK6U5OmNztQ2BOToF1f1OtZ/kXBf+GU25UQ2fDXNg5HZifNp/8mHx+svInvLznZXbU72Bc7DgsRsvQLz5NuXhCMmEWI994fhN/XXGAs8fGE2+zcutT63lqTQn7ato4d2yApgPNMWEwCH504VhKj3Tw+hDF+k/31vJv9wWU3LhyRIUNT0WCCQQmIUQKcAPw7jCv56TS2O7AYlYFY5vZhqNECTpZQtrg8HpVpBlmL9YzlXBzOM8vfp75afP57frfsrF64xlbH/ARZjHxowvHcs20NJb94Gz+dst0Xv/mPCalRfGbd5VBybkFJ1Y0UaOUdKdkRPPY8gODqpJ+uqeWtOhQsgqmjKiw4alIMIHg1ygpiGIpZZEQIgfYP8RrTgua7E5CrSoQhFvC6TpQDGYzlsOvK7GqYRzpHg2Em8N57LzHuK3wNiTylJc4PhF8dWEOj9wwlbFe+fKYcAv//upsLpucwowx/UyONCcEIQT3XDSWiiY7/1nvf66gy+Vm7YF6zi1IOKmm8KcLQyYrpZSvAq/2un8Q5V982tPU4cBicWI0hWI2mOkqLsaakYbY87ZSGbSeWf3uI4HRYOSnM3/KLeNvITU8daSXMyKEmI385eZpQx+oOWYW5MUzJyeWv3xazE2zM3vMpLxsLG2k3eHmvAKdmvNHMOb1Y4UQy4UQO7z3JwshHhj+pQ0/TR1OzOYuws1K6bOr+ACWKBcgg5v80wRNWkSavhLTDBtCCO5akEN9WxcbSwc2NX66pxaLycC8vJNj+HO6EUxq6EnUJLETQEq5DSUpfdrT2OHAaOoiwhyBp7MT5+FyrJ4SpSaoR/81mtOKeblxWIwGVu4b6GL46d5a5uTEEWbRHVv+CCYQhEkpN/R77IyYLG62OxGGTmwWG47SUvB4sIa3wowhVbY1Gs0pRrjVxMzsGFbs7SsAWXakg+K6ds7ThfqABBMI6oUQuXilqIUQ1wFDq2ud4viUR6WhkwhzBF3FylPAEunudpLSaDSnF+eOTWRfTRuVTfbux/67RUlQXDBeT3IHIphA8G3gcWCcEKIC+AEw/OIXw0xblwuXR+LGToQlAkdxMQiwZGXqIrFGc5pyjveq35cecnskLxeVsTA/nozYkyQydxoSjEPZQSnlBUACME5KueAEmtePGD6dIafswGax0XWgGEskGNKHz/xBo9EML/mJEaRGhbByrwoEK/bWUtncyc2zMkd4Zac2QQvfSynbpZRBGLOeHvgCgcPTQbg5nK79+7BE2CF58givTKPRHCtCCM4pSGTtgXqcbg8vri8jwWblgkKdFhqM09sB5Tho7HAAbhyeTiJFGI6yMqxRrqNTB9RoNKcc54xNoLXLxXvbqvh0by03zEjHbBy1p7qgGLXfnSa7EwzK/DruiAPcHqyROhBoNKc78/PiMBkED769EwncOFOnhYYimIGybUKI+72dQ2cMTR0OhFFZ18VUtQFgTYvTgnEazWmOLcTM9DExNNudnJ2foIvEQRDMjuBy1NzAK0KIIiHEPUKI0z7ENnWoGQIAW0UzAJYCXR/QaM4EzvVKSdw8+7Q/VZ0UgtEaOgQ8DDwshMgHfg48BJzWspyNHQ7CQlTBOKSsBnO4C0Om7hjSaM4EbpmTSWSoSc8OBElQ89ZCiDHAEu/NDfx0OBd1MmjucBIe6qIDMJcc1oVijeYMIjLEzC2ztUxMsAwZCIQQ6wEzSoH0eq/66GlPY4eD0BAHnR6JqKzHkueCFJ0a0mg0o49gdgS3Syn3DvtKTjJNdichIU4SmwCXB2tCCNhSRnpZGo1Gc9IJpljcJIR4SgjxPoAQolAIcdcwr2vYURLUDtKOSACsuXnatUij0YxKggkEz6IcynyuIvtQekOnNU0dDsymLuLaVc3blKvTQhqNZnQSTCCIl1K+AngApJQuVMH4tMXjkTTbnRhMXSTYvYEgf8YIr0qj0WhGhmACQbsQIo4eGeo5QPOwrmqYae104ZGAoZP4NjBaPIjUSSO9LI1GoxkRgikW/wh4G8gVQqxFqZBeN6yrGmaUzhB4sBPdLjGGuCFydPrpajQaTTADZZuFEOcABYAA9kopncO+smGkya6W76KDqDYPplChPQg0Gs2oJWAgEEJcE+CpsUIIpJRvDPXmQohLgEdRU8j/lFL+vwDHXQu8BsyUUm4cetnHh29H4JQd2NrcmOKtumNIo9GMWgbbEVzu/TcRmAd84r1/HvAZMGggEEIYgb8CFwLlQJEQ4m0p5a5+x9mA7wPrj3r1x0iz14ug091BaLsHY27UyfpojUajOeUIWCyWUn5FSvkV1FRxoZTyWinltcAE72NDMQs44HU4cwAvAVf6Oe43KO2izqNe/THS7E0NuTvbsDjAFBt9sj5ao9FoTjmC6RrKkFL2NquvAYKR9EsDDve6X+59rBshxDTv+7832BsJIb4uhNgohNhYV1cXxEcPTovdCXgwN7UDYIpPOO731Gg0mtOVYLqGlgshlgH/8d5fAnx8vB8shDAAjwB3DHWslPIJ4AmAGTNmyOP97JZOJ6EWN1Ht6q1MSbpjSKPRjF6C6Rr6jhDiauBs70NPSCn/G8R7VwAZve6nex/zYQMmAiuEKtQmA28LIa4Y7oJxi91FRLiT6BYVCIypGUO8QqPRaM5cgpKh9p74gzn596YIyBdCZKMCwI3Azb3esxmI990XQqwA7jkZXUMtnU7CQ1xEeRNeprS84f5IjUajOWUZNs9irxTFd1A6RbuBV6SUO4UQvxZCXDFcnxsM3YFAlQgwZStSDzIAAA5pSURBVOSP5HI0Go1mRAlqR3CsSCmXAkv7PfaLAMeeO5xr6U2L3YXV5iC6TSKtHkRM+sn6aI1GoznlGLYdwalMS6cTi9lBdAcYQgGTdaSXpNFoNCPGMQUCIcQvT/A6TiotdidmcxdRbRKjzTLSy9FoNJoR5Vh3BJtO6CpOIlJKWjpdGI1dRLeDJTJspJek0Wg0I8oxBQIp5TsneiEni3aHG7dHIoxdRHWANUbLS2g0mtHNYKJzf8brQeAPKeX3hmVFw0yLV17C7Gwm1KGnijUajWawHcFGVAooBJgG7PfepgKnbWK9pVMFgvCWegBMiUkjuRyNRqMZcQLuCKSU/wIQQnwLWOCdC0AI8Q9g9clZ3omnxe4CIKS5EQBTip4q1mg0o5tgagQxQGSv+xHex05LfKkha0sLAKa07JFcjkaj0Yw4wQyU/T9gixDiU5RD2dnAr4Z1VcOILzVkbekAwJhRMJLL0Wg0mhEnGNG5Z4QQ7wOzvQ/dK6WsHt5lDR++HUFIqwOJxJSaM8Ir0mg0mpFlyNSQEGK5lLJaSvmW91YthFh+MhY3HLR0emsEbS4coQJh1VPFGo1mdDNY+2gIEAbECyFiUGkhUPWCtECvO9VpsTsJsxgIa/fgCB+VChsajUbTh8FSQ98AfgCkotpIfYGgBfjLMK9r2GjpdGILhah2iVvLS2g0Gs2g7aOPAo8KIb4rpfzzSVzTsNJidxER6iSqHWR86EgvR6PRaEacgLkRIcRMIUSyLwgIIW4XQrwlhHhMCBF78pZ4YmnpdBJjaSO6HUS0baSXo9FoNCPOYEnyxwEHgBDibFQb6XNAM17/4NORlk4nKVQT4gRTXNxIL0ej0WhGnMFqBEYpZYP3/0tQXsWvA68LIb4Y/qUNDy12F8lGZZ1sSUwZ4dVoNBrNyDPYjsAohPAFikXAJ72eG1Zns+GkpdNJVEcdANaUMSO8Go1Goxl5Bjuh/wdYKYSoB+x49YWEEHmo9NBph8cjabE7ifBudMIzx47wijQajWbkGaxr6HfewbEU4EMppU+S2gB892Qs7kTT7nDhkWBuVzpDsVkTR3hFGo1GM/IMmuKRUq7z89i+4VvO8OKbKja1deAREJaYOsIr0mg0mpFnVI3W+nSGTK0OWsNBGI0jvCKNRqMZeUZlILC2ubBH6CCg0Wg0MNoCgTc1FNou6Yo0j/BqNBqN5tRgdAUCuxMzLiLawROt5SU0Go0GRlsg6HSSKGuI7ABDTNRIL0ej0WhOCUZXILC7yHSXAmBJTBjZxWg0Gs0pwugKBJ1OMl1VAIRp03qNRqMBRlsgsDtJcB0BwKanijUajQYYbYGg00lUl3eqOOesEV6NRqPRnBqMrkBgdxFub8cjIC5D7wg0Go0GhjkQCCEuEULsFUIcEEL8zM/zPxJC7BJCbBNCLBdCDKscaEunk5AOB83hYDGHDOdHaTQazWnDsAUCIYQR+CuwGCgEbhJCFPY7bAswQ0o5GXgNeHi41gO+QOCiPUIMfbBGo9GMEoZzRzALOCClPCildAAvAVf2PkBK+amUssN7dx2QPozrocXuIrTdQ5fttLVT0Gg0mhPOcAaCNOBwr/vl3scCcRfwvr8nhBBfF0JsFEJsrKurO6bFeDyS1k4H4W3girIe03toNBrNmcgpUSwWQtwKzAD+19/zUsonpJQzpJQzEhKObRCszeHC5m7FZgeiI459sRqNRnOGMZw5kgqg99RWuvexPgghLgD+BzhHStk1XItpsTvJcR4CwBQfO1wfo9FoNKcdw7kjKALyhRDZQggLcCPwdu8DhBBnAY8DV0gpa4dxLbTYXaQ7VKYqNEmb1ms0Go2PYQsEUkoX8B1gGbAbeEVKuVMI8WshxBXew/4XiABeFUJ8IYR4O8DbHTctnU4SnTUAhKfnDNfHaDQazWnHsLbPSCmXAkv7PfaLXv+/YDg/vzctdicxXY0ARGdrr2KNRqPxcUoUi08GLZ0ubF3eqeIxU0Z6ORqNRnPKMHoCgd1JuL2TpnCIDY8f6eVoNBrNKcOomaxKjgrB2OmiNUJgNGi/Yo1Go/ExanYEl05KIazDgz1i1HzJGo1GExSj6qwY2iZxaNN6jUaj6cOoCQSyq5NwO8josJFeikaj0ZxSjJpA4CzbC4AhVpvWazQaTW9GTSBoPrgdAOsxahVpNBrNmcqoCQRNh9WOICw1c4RXotFoNKcWoyYQtFWWARCZWTDCK9FoNJpTi1ETCFqN7exJh9gxk0Z6KRqNRnNKMWoCQdkVl/KL20wkRA+rLbJGo9GcdoyaQJAXX8iSgiVEWiNHeikajUZzSjFqJCbmpMxhTsqckV6GRqPRnHKMmh2BRqPRaPyjA4FGo9GMcnQg0Gg0mlGODgQajUYzytGBQKPRaEY5OhBoNBrNKEcHAo1Goxnl6ECg0Wg0oxwdCDQajWaUowOBRqPRjHJ0INBoNJpRjg4EGo1GM8rRgUCj0WhGOToQaDQazShHBwKNRqMZ5ehAoNFoNKMcHQg0Go1mlKMDgUaj0YxyhjUQCCEuEULsFUIcEEL8zM/zViHEy97n1wshsoZzPRqNRqMZyLAFAiGEEfgrsBgoBG4SQhT2O+wuoFFKmQf8CXhouNaj+f/bu/cYqcozjuPfX9iK1yBgYyiaLiZY05ooRC3US4gXNMaoaUzUNinRJlSj9RIbA/qHsX9pNN7+MZJ6iyE0Kd4If4gVtV4aFVDEVUTW0lSsCGpLqyYK+PjH+46cHXaRXWZ2Muf9fZLJzvues2fPM8/Cs+fMnOeYmQ2unUcEJwD9EfGPiPga+DNwXtM65wEP5+eLgdMkqY37ZGZmTXrauO3JwAeV8Ubg50OtExHbJW0FJgKfVFeSNBeYm4efS1o3wn06pHnbhSgx7hJjhjLjLjFmGH7cPx5qQTsLQctExAJgwd5uR9LKiDiuBbvUVUqMu8SYocy4S4wZWht3O08NfQgcXhkflucGXUdSDzAO+LSN+2RmZk3aWQhWAFMlTZG0D3ARsKRpnSXAnPz8AuDZiIg27pOZmTVp26mhfM7/SmAZMAZ4ICLelvRHYGVELAHuBx6R1A98RioW7bTXp5e6VIlxlxgzlBl3iTFDC+OW/wA3Myubryw2MyucC4GZWeGKKQTf1+6iW0k6XNJzkt6R9Lakq/P8BEl/lbQ+fx2f5yXpnvw6rJE0vbMRjJykMZLekLQ0j6fkViX9uXXJPnm+Nq1MJB0sabGkdyWtlTSz7rmWdG3+3e6TtEjSvnXMtaQHJG2W1FeZG3ZuJc3J66+XNGewn9WsiEKwh+0uutV24LqI+CkwA7gixzYPWB4RU4HleQzpNZiaH3OBe0d/l1vmamBtZXwrcGduWfIfUgsTqFcrk7uBpyLiKOAYUvy1zbWkycBVwHERcTTpgycXUc9cPwSc1TQ3rNxKmgDcRLp49wTgpkbx2K2IqP0DmAksq4znA/M7vV9tivVJ4AxgHTApz00C1uXn9wEXV9b/br1uepCuS1kOnAosBUS6yrKnOeekT67NzM978nrqdAwjiHkcsKF53+uca3Z2H5iQc7cUOLOuuQZ6gb6R5ha4GLivMj9gvaEeRRwRMHi7i8kd2pe2yYfB04BXgUMj4qO8aBNwaH5el9fiLuB64Js8ngj8NyK253E1rgGtTIBGK5NuMwXYAjyYT4n9SdIB1DjXEfEhcDvwL+AjUu5WUf9cNww3tyPKeSmFoPYkHQg8ClwTEf+rLov0p0FtPics6Rxgc0Ss6vS+jLIeYDpwb0RMA75g56kCoJa5Hk9qTjkF+BFwALuePilCO3NbSiHYk3YXXUvSD0hFYGFEPJanP5Y0KS+fBGzO83V4LU4EzpX0T1JX21NJ584Pzq1KYGBcdWllshHYGBGv5vFiUmGoc65PBzZExJaI2AY8Rsp/3XPdMNzcjijnpRSCPWl30ZUkiXSF9tqIuKOyqNq+Yw7pvYPG/G/ypw5mAFsrh55dISLmR8RhEdFLyuWzEfFr4DlSqxLYNeaub2USEZuADyT9JE+dBrxDjXNNOiU0Q9L++Xe9EXOtc10x3NwuA2ZLGp+Ppmbnud3r9Jsjo/gmzNnAe8D7wI2d3p8WxnUS6XBxDbA6P84mnRddDqwHngEm5PVF+gTV+8BbpE9jdDyOvYh/FrA0Pz8CeA3oB/4CjM3z++Zxf15+RKf3ey/iPRZYmfP9BDC+7rkGbgbeBfqAR4Cxdcw1sIj0Psg20tHfb0eSW+DSHH8/cMme/Gy3mDAzK1wpp4bMzGwILgRmZoVzITAzK5wLgZlZ4VwIzMwK50JgxZL0ef7aK+lXLd72DU3jv7dy+2at5EJglhp9DasQVK5qHcqAQhARvxjmPpmNGhcCM7gFOFnS6tz7foyk2yStyL3efwcgaZakFyUtIV3diqQnJK3K/fLn5rlbgP3y9hbmucbRh/K2+yS9JenCyraf1857DSzMV9KatV3bbl5v1kXmAX+IiHMA8n/oWyPieEljgZclPZ3XnQ4cHREb8vjSiPhM0n7ACkmPRsQ8SVdGxLGD/Kxfkq4OPgY4JH/PC3nZNOBnwL+Bl0k9dV5qfbhmA/mIwGxXs0l9XFaTWnpPJN0ABOC1ShEAuErSm8ArpGZfU9m9k4BFEbEjIj4G/gYcX9n2xoj4htQqpLcl0Zh9Dx8RmO1KwO8jYkCzLkmzSK2fq+PTSTdC+VLS86ReNyP1VeX5Dvzv00aJjwjM4P/AQZXxMuDy3N4bSUfmG8A0G0e6LeKXko4i3Sq0YVvj+5u8CFyY34f4IXAKqTmaWcf4Lw6z1MlzRz7F8xDp3ga9wOv5DdstwPmDfN9TwGWS1pJuFfhKZdkCYI2k1yO1yG54nHRrxTdJXWOvj4hNuZCYdYS7j5qZFc6nhszMCudCYGZWOBcCM7PCuRCYmRXOhcDMrHAuBGZmhXMhMDMr3LdECQBdNhcVjQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydZXgUV9uA79nNbtzdjYQAgUAI7hQKlCLF69RLqVJ/+5YCdXkr1KFfqbdQXEtxlwgQCBri7rLZJGvz/ZhkkxAHUqR7X1cuyJyZs2c2u/OcxwVRFDFhwoQJE/9eZNd6ASZMmDBh4tpiEgQmTJgw8S/HJAhMmDBh4l+OSRCYMGHCxL8ckyAwYcKEiX85Ztd6Ae3FxcVFDAgIuNbLMGHChIkbitjY2AJRFF2bGrvhBEFAQAAxMTHXehkmTJgwcUMhCEJqc2Mm05AJEyZM/MsxCQITJkyY+JdjEgQmTJgw8S/HJAhMmDBh4l+OSRCYMGHCxL8ckyAwYcKEiX85JkFgwoQJE20kIauUrJLKa72Mq45JEJgwYcJEG/g7IYdJXxzgwR+iMRhurvL9JkFgwoQJE62w/XQuc3+Lw9Faydmccradyb3WS7qqmASBCRMmTFxC/YZd207n8sSvcXTxtOPvZ4cS4GzF4h0XuJmaepkEgQkTJkzUQ5uVReLoW9n5/tdM+vIAj/wUQ6iHDT8/2A9HayVzR3QiIauMnWfzrvVSrxomQWDChAkTNRgqK0mf+yS6jAyE5T+jqqxmwYSuLH90APZWCgAm9/LG18mSz24ircAkCEyYMGECyRyUPf8Nqs+eZatfXzzUxazrb87sQYFYm9fV51TIZcwd3on4jFJ2n8+/hiu+epgEgQkTJv61VJ09izo6GnVcHAVffkXZhg1k3nEvX0ZMATt7SlatbPK6KZE+eDtY8vmOC//wijuGG64MtQkTJi4f0WAAQJCZ9oCVJ0+RMn16g2O2o0ezqfsY7C8W4Th5EsW//46uuBgzR8cG5ynNZDw6NIg31icQk1JEVIDTP7n0q47p03CT896WsxxJKrzWy7hpMIgGcipyiM6JprS69LLmiM+P5/2j71OmKbvKq2saURSpjI8nZ9GbXBg4iPQ5c24a2/aVUPTDD8hsbPD97jt8v/sOv2Xf4/2/j4hNL6W3vwMO06aCVkvpunVNXj89ygcHKwXf7k36h1d+9TFpBDcxGcVqvtlzkbSiCvoFOV/r5dzQiKLIkzuf5Ej2Ear11QCMCRjDR8M+avdcn8R+QkxuDHsy9vDJ8E/o7NT5ai/XiKjXk/7Io1QcPIigVGIeFkbFnr2odu/GdsSIDnvd6x1tTg5lW7fidM892AweZDyeV15FWpGae/v7YxEahGVEBCUrV+J0//0IgtBgDiulGfcNCGDxjgsk5qno5GbzT9/GVcOkEdzEHLooaQJHk4tMO8Ar5ET+CfZm7GW473Be7/86I31HsjdjL5W69pUbSCtLIyY3hnEB46jSVXHP5nvYlLSpg1YNxb/9TsXBg7g8/RQh+/cR8OsvKAMCyPvgQ0SttsNe93qn+NffwGDA8Z57GhyPSy0GINJfMgU5zJiOJvEi6iNHm5zn/gH+mJvJ+G7fja0VmATBTUytIChQaUgqqLjGq7mx2Zy8GaVMyYIBC5jReQazwmZRqavkYObBds2zNnEtMkHG81HPs2LCCro6d+WVfa/ww6kfrvqatdnZ5H/yCdaDBuEyZw5yOzsEhQK3l15Ek5xM8YoVV/01bwQMajXFK1ZgO2oUSh/vBmOxqcUozWSEe9sBYDd2LDJbW9Jmz+b8kCGkPfgQqn37jOc725gzPcqH1XGZ5JVX/aP3cTUxCYKbFFEUOZRUSBdP6QMdnVx0jVd046Iz6NiaspVhvsOwUUrqf5RHFPbm9mxL29auedYlrmOQ1yDcrd1xsXThu1u/Y2zAWP4X+z++OPbFVdPcRFEk5823EA0GPBa80cCsYTNiBFb9+lHw+Rfoy/4ZP8X1ROm6dRhKS3GafX+jsZjUYnp422NuJgdAZm1NwPLluL3yMjaDh1Cdkkzm8y+gK6r7Pj08OAitwcAPB1L+qVu46pgEwU1KSqGa7NIq7urnh7O1kqMmQXDZHMk+QlFVEeMDxxuPKWQKRviOYE/6HjR6TZvmOZh1kLzKPKaETKmbR67gvSHvMSVkCt/Gf8sH0R9cFWFQvm0bqp07cX3qSZS+vg3GBEHA/eWX0JeWkvv++4iatq3/ZkA0GCj68ScsunfHslevBmNVWj2nMkvpHdAwQsg8KBDn2bPxevcd/JYuxaBWk/e//xnHA1ysuSXMnTXHMm9YE2yHCgJBEMYKgnBOEIREQRBeaeacGYIgnBYEIUEQhN86cj3/JmrNQoOCnekb6MTRlA4SBBmxsPE50Kg7Zv7rgM3Jm7FV2DLYZ3CD46P9R6PSqjicfbhN86y5sAYnCyeG+QxrcFwuk7NgwAJmdp7JL2d+4WzR2StaryiK5L3/AeZhYTjdd1+T51h07YrTffdRumo1FydMoHzHjhv2IdYe1DExaFJScLr3nkbO35OZpWj1IlH+zYeCmgcH4zz7fkpXrUZ97Jjx+NBQF7JLq8govjFLVHeYIBAEQQ58CYwDugJ3CoLQ9ZJzQoBXgUGiKHYDnu2o9fzbOHixAHc7cwJdrOkT4ERGcSWZV7uOes4p+OUOiPkeTjWdeHOjU6WrYnvqdkb5j8Jcbt5grL9nf2wUNmxP3d7qPIWVhexO382EoAko5IpG44Ig8GiPRwE4mtO0Y7KtaFJS0GZm4jhrFoKi8WvV4v7qK/guXYJgpiBj7pNkv/LqFb3ujYBq9x5QKLAZeUujsdhaR7GfQ4tzuMyZg5m7O7lvvoWo1wPQL1CKyjt8g4Zqd6RG0BdIFEUxSRRFDfAHMOmScx4BvhRFsRhAFMWbp4rTNUQURQ4nFTIw2AVBEOgbKO1wrqqfoCgJfpkCCitwCoLo/7t6c19H7MnYg1qnZnzQ+EZjSrmSoT5D2ZW+C51B1+I86y6uQyfqGpiFLsXNyo0AuwCOZB+5ojWro6MBsOrbp8HxxLxy7lxymHc3nzEesxkyhKC1a3CYPo3S9evRFRdf0Wtf76j27MG6TxRyG+tGY7GpxQS5WONsY97ElXXIrK1xf/klqk6fpqTG4R7iZoOjlYIjN6gJtiMFgTeQXu/3jJpj9QkFQgVBOCAIwmFBEMY2NZEgCI8KghAjCEJMfv7NUdujI7mQp6JApWFATe5AF087bM3Nrp55qCwbfpoMei3cuxb6zYHs45AZd3Xmv47YnLQZV0tXotyjmhwf7T+akuoSYnJjmp0jT53H0vilDPQaSJBDUIuv18+zH7G5sWgNlx/aqY6JQe7igjIwEACd3sDXuy9y2+L9HEoqZN3xrAbnCwoF9ndMAVFEfeTKhND1jCYjA83Fi9gMG9ZoTBRF4lKLjWGjrWE7bhwW4eGUrF0LgEwmbbhuVF/ctXYWmwEhwHDgTmCpIAiN9DJRFJeIohglimKUq6vrP7zEG49a/8CAYEkQyGUCvQMcr86HtCwbfrwd1IVwz0pwC4OImZJmEHNzaQVni86yN3MvYwLGIJfJmzxnkPcgLM0s2XBxQ7PzvHvkXbQGLa/1e63V1+zj0Qe1Ts3pwtOXtWZRFFFHx2AVFYUgCGh0Bu5fdpT3/zrLiM6uzBkeTE5ZFXllDUMdLXt0R2ZjQ8WB9oXD3kiodu8BaFIQpBdVUlihIdKvbYJAEAQse/RAk5Rs9K30DXQmrUhNdumN5yfoSEGQCdQPV/CpOVafDGC9KIpaURSTgfNIgsHEFXDwYgE+jpb4OlkZj/UNdCIxT0WhqvryJ64VAuU5cM8q8O4tHbewh+7T4eQqqLw5TAsFlQU8tfMpnC2ceaj7Q82eZ2lmyYzQGay/uJ6tKVsbje9I28H2tO3MiZiDn51fq6/bx0My5xzNvjw/gTYzE112NlZ9JA3m7U2nOZBYyDt3dOebe3ozMswNgPiMhuUxBDMzrPr3o+LAgZvWaazaswdlQADKgIBGYyczpfeju7d9m+dTBgVhKC9HX1AAQL8aE+yRpA7SCo7/BtWqDpm6IwVBNBAiCEKgIAhKYBaw/pJz1iJpAwiC4IJkKrqxU/SuMQaDyJHkIgYGNywpUfshjU65zAd1eQ78ML5OCPj1bzje5yHQVcKJPy5v/usIrV7LvN3zKKkqYfHIxbhYurR4/jORzxDhGsH8A/NJKq37+Ko0Kt458g6hjqHc163p6J1LcbJwItQx9LIdxupoyURlFdWH1XEZ/HgolYcGB3JXPz8EQaCblx0yAeIzG9dJsh44EG1WFtrU1Mt67esZg1qN+siRJrUBkASBQi4Q6tH2MhHmQZLprTopGagxwVqYcSS5AxzGh76EtXMg+rurPzcdKAhEUdQBTwJbgTPAClEUEwRBWCQIwsSa07YChYIgnAZ2AS+Konhjut2vEworNJSotXStSSSrpbu3A+ZmMjbGZ13ejm/3u1CWCfesbiwEADwjwDtKiiC6wXeUbx95m2N5x3hz0Jt0de7a6vkKuYKPhn2EudycebvmkaXK4s/zf/LI34+Qr85nwYAFKGTNR+9cSl+PvhzLO9bm/IT6qKOjkdvbk2jlyqurT9Iv0IlXxoUZx62UZoS42RKfUdLoWptBUs0d1cGbzzxUcfgwokaDzfCmBUFCVimdPWyNiWRtQRkk+Xs0yZLwl8sE+gQ4XX2H8fHfYet/oOskGPjU1Z27hg71EYiiuFkUxVBRFINFUXy75th8URTX1/xfFEVxniiKXUVR7C6K4o2/nbzGFKulh4ezjTmGigoyn38B1b79xrK5G+Oz+eFgSvsmNejhzEbofBv49Wv+vKgHoeA8JO+9/Bu4xiSVJrHqwioe6PYAYwObjF1oEg9rDz4Y9gHJZcmMWTWGRYcWodKqWDBwAd1du7drDX09+lKtr+ZE/on2Lh91dDSWUVE892c8jlZKvrgrEoW84de8h489JzNKG20IFH5+KLy9b0o/gWr3HmTW1lj17t1oTBRFTmaWEu7VdrMQgJm7O4KVFdVJdVpgv0AnkvIrrl65iXNbYN1cCBoOU5ZCM76qK+VaO4tNXGUKVZIgcLKQk/niS5Rt2kTRsmUAPDcqlFu7uvPmxtPsPteOSN20w6AugK4TWz4vfApYOkH00std/jUnJkcyrUwLndbua/t79ufNQW/ycPeHWXH7CtZPXt9iuGhz9PbojUyQtds8pM3JQZuejia8JxfyVDw+LAhX28ahkD187Cms0DTKKxEEAeuBA1EfOYKoazkc9kZCFEVUe/diPXAgglLZaDyjuJIStZbwdvgHQHq/zAMD0dSYhgBjld9WAzNyT8PKh5q3+avy4O//wor7JW175i9g1nJY65VgEgQ3GbUagdNv36HauRNlQADq6GgMajUymcAnM3vS2cOOp347RmJeedsmPbMe5ObQaXTL5yksIfI+OLsJSjOu8E6uDTE5MbhZuuFr69v6yU0wMXgiz0Q+QxfnLo0yV9uKndKOrk5d2+0wrvUPnHMLBqQolqbo4SMF5p3MaMJPMGggBpWKyviT7Xrt65nq8+fR5eQ0axY6dRmO4lqUQUFo6mkE4V52WCnlrTuME9ZISZiX2vx11ZIA+LSH5BfoNlnyyZnbtntt7cEkCG4yCis03JpyBJb/guNdd+Ex/3VErZaKmvhwa3Mzvrs/iqCyLL79fV8rsyHZ+89sgE63gHkbHGlRD0r/xiy7gru4NoiiSExuDL09el/2Q/xq0cezD/EF8ai1bS/doY6ORmZry37REVsLMzp7NP3wCPO0RSEXONGUIOjfHwSBigMHLnvt1xsV+/cDYD14SJPjJzNLMZMJzb5fLWEeFIg2KwtDpaRdmcll9PZ3bN1hnFMjaA8ubqgV7H4PDn4uCYC50TBlCVh1fPczkyC4yahMz+TJE6uxHDgQ9/+8imVUFIKlJRX1Sud6Wsp4Y8/XDFz9desTZsVJTuIuE9q2AEd/CB0LsT9Iu5sbiPTydPIr85tNHvsn6efRD51BR1xe25L0pPyBaKwiIzmSWkKUvyNyWdPCzNxMTpiHHSczGzuM5Q4OWISHU7puHVkvv0zqffeT/tjjGKpu3BLLFQcOYB4SgsLdrcnxU1llhLjbYqFov/1dGVjrMK5nHgp04nyuiuKKFpz9OSfBNUzKx6nVCnJOSYKh591wxzfg0qnd67lcTILgJsPt7zUIiHi/9SaCmRkypRLrfv1Q7d1ndA6WbdmCpbqckLwkcjNa8RWc2QAyM+nh3lb6PiL5FBLWXsGd/PPUZgdfD4Ig0j0SpUzJway2OW7L1q9Hk5yMMGAwF/Mr6BPY8i6yu4898RmlGAyNI7zsxt+GNieHiuhoDNVVqPbsofD77y/rPq41hspK1DGxWA8a1OS4KIqcyiylu7ddk+OtobwkhBTqTHIxqc2EaquLoCwDet4FnUZJD/+qMlj/FFg4wK1vXdZargSTILiJ0JeUEHR4GzHBUSi8vIzHrYcOQZuRgSYlBZC6VolW1shFA8lbWiiYJopwej0EDGmfeho4HJxD4OiSy7uRa0RsbixOFk4E2ge2eq6o1RobwXcElmaW9HbvzaGsQ62eq8nIIGfRm1hFRXGql9R+sl8rgiDCx57yKh2pRY1NT86zZxN2Mp6QnTsJXL4c23FjKfx2CZqMS/NBr3/UMbGIGk2zgiCrtIqiCs1l+QcAlP7+IJM18BP08LFHKZcR3VxJl5x46V+PHjDsFUkr+PF2Sfse9/4/Ygq6FJMguIko/uMPFNpqDve5rcFxm6FDAajYt4/Kk6eoio/HYe5cSpTWVO5tIdQz7wwUXWy7WagWmUzSCjJjIDu+vbdxzYjJiaG3e+v+AVEUSZ4yhawXXujQLNyBXgNJLEkkpyKn+bXodGS99DLIZHi9/x5H00oxN5PR3bvlCpq1403lEwAN3gP3l14CmYy899+/jLvoWNZcWMNDWx8iT920Zltx4ACCUolVVOOwUahzmHe7TEEgMzdH4eNDdXKdILBQyInwtW8+n6DWP+DRHXz7SFpB9gkpGCN86mWt40oxCYJ/AoOhw5OsDFVVFP38C2f8wtH5NyxspvTxQRkYiGrvPop/+w3Bygr3GdM4498dh5MxzYcKnl4LCBB2e/sXVCs8Um+MmPQsVRZZFVn0dm/6gVGf6vMXqL6QSNnmLZQsX95haxrgNQCgRa2gcOlSKuPi8Jg/H4W3N9EpRfT0dUBp1vJXO9TdBnMzWaNSE02h8PTE5bHHpGY3+68fJ3JCYQKLDi/iaM7RZoVBxYEDWPaORGZp2eQcpzJLkcuERgmY7eHSEFKQSrokZJai1jTx3cqOB1svsK7JWB+1EIJvgds/hmsUpGASBP8Eqx+Gxb06NNGqdO1a9IWFrOtyC47WjWOlbYYOQX30KGWbN2M/cQJyW1tKIvpiUVVB5YkmEpc0FZITq9MosHVv/4LsvMDGQ1J3bwBic2OBtvkHVLt2AWDZqxe5775H1fnzHbKmUMdQXCxdmhUE2uxs8r/8Crvx47GfcDuqah0JWaXGsuMtYSaX0c3LjmNpbSs54vTgAyj8/ch9++3roum9SqPixT0v4mzhzOIRi8lT5zUSBtq8PKovXDBmTDfFqaxSQtxsLstRXIsyOBhNSoqxNwFAnwAndAaRY2lNaFw5J8GzR93vHuFw72pwaL0WVUdhEgQdTcEFOLUKyrPhxwmw6fmrXjhK1Osp/H4ZFj26c8hGak15KdZDhiJqNIjV1TjeeRcANoMGoxNkFG7b2XjSmGWS7XLYS5e/MO9IyDrW+nnXATG5Mdgp7QhxbL3moWrXLizCw/H5fDEyW1sy580zhg9eTQRBYKDXQA5lH0Jv0DcaL/nzT9DrcZv3HABxqcUYROkh1BaGd3YjLq2kTQ2LZEolbs/NQ5OcTMU1LkEhiiILDy0kS5XFB0M/YITfCL4Z/Q156jxmbpzJ49se57X9r7H1zw8AWnUUd2tnRvGlmAcFIlZXo83ONh7r7e+ITGgisUxbKWXfe7Qv27yjMQmCjubINyBXwtyj0H+u1MDl/0ZLO+6rhDo2Fm1aGtZ33YNGLzapEVj1kcJILaN6Y9E5FIAunTw45RxE6c5dDU/WVsKBzyBwGPj2vfyFeUVKgrDq+m+QHpsbS6R7JDKh5a+ErrCQyvh4bEYMx8zFBa/33kOTeJG8Dz8CYMeZXPZfKLhq6xroNZCS6pJG7StFrZaSP1diPXQICm+pzUd0ShEygTbX1J/cU7pu3fG2OYFtR45Abm9P6frmS27/E2xI2sBfKX8xt+dcIt0jAejl1oulty6lu0t3SqtLOZx9mKydm9Hb22DeuXOT8yQXVFCg0lx2xFAtxppD9RzGthYKunjaNRYEeWdA1JsEwb8KdZFUOrb7DCm+fuw7cNdy6cOw5eWr9jKqnbsQFAqqeks2ZacmBIHM3Bzfr7/G6+23jce6edlzxKMr8rRkNBn1MoFjf4SKPBh2hWv06gWIUtOa65g8dR6pZaltMwvt3gOiiO0IKTrHZvAgHO+9l+Lff2fRh3/y0I8xPPhDtLHt4ZXS31Mq8HdpGGn57t3o8vNxnDnLeOxochHdvOyxMTdr09x+zlb09ndkTVzbmq4LSiW2t42jfMcO9Kqrt5GpRRRFFsctZvWF1S2e98vpXwhzCmtUHryHaw8Wj1zM77f/zt9TttIzVcapIHkDu3tuRS7P7XqO43nH+Wr3RZRmMsZ197yiddc2AKpfcwgkP8Gx9GI0unrRZfUjhq4jTIKgI4n7CbRq6D+n7ljoGBjyPBz7GU5eeZ9fURQp37kTq/79KUaqcOlk1VgQAFj37yeFu9XgZK0kNbQXUNe0A20VHPgU/AdBQJ1Krc3KoujXXyn+/XeK//yzbeYBL2nuBp3LtJXw20xIj27HXXYs21K3ATDIS7rfqvPnG9h766PavQszd3fMu3QxHrs44W6KLWzpuWoJT48IwsPegjm/xJJbduVJWM6WznRx6sKBrIZO2pI/lmPm6YnNMCkiTKs3cDy9pM1moVru6OXNhTwVp7PbprXZT5iIWFVF+bZt7XqdtvDVia9YenIpH8V8RJWu6ffuYslFzhSdYXKnyS1qb9rzF7BV6dnvVc7h7MPG4+8dfY/tadt5aOvDrL+wlXv6+eNqq2T1hdWM+nMUv535rd3rNnN0RO7o2NhhHOBEldbAqax6Dvmck2BuBw7+tIZGZ2B5dBqq6o6v+2QSBB2FXivF0QcOlZxB9Rn+Kvj2hw3PQuHFK3oZTWIi2rQ0bG8ZSVFNJqOTTdOCoClcwzqRa+9G2caN0q7w2M+SP6Oeb0AdE0PylKnkvvkWOQsXkfP6fNIeehhtXivJaNbO0ge+vp/g/F/Sz+nrJ9lsU9ImOjt2ppNjJ6qTkkmeNJmCL79sdJ6huhrVgYPYDB/eILzypc0XWd1/GiElGcwuPMaS+3pTXqXj8V9iqdY1LVDaw0CvgZzIO0FJleR41KSlSSUgJozip7O/8EH0Bzyz42UE9x+xdWxfO4/x3T1RyAXWHmubeciyV08Uvr6Ubbi0tciVsf7ier458Q09XXtSrinn79S/mzxvU9Im5IKcMQFjWpyvNgAiO9SJHxJ+AGBP+h62p23ngW4PYCn6ovT6BSv3HTzw1wO8cfANqvRVvB/9fpuT+EDqXbE3Yy/ZLjLSTuxvMBYV0ESv8JyT4B4uhVi3wrtbzvDyqpN8s/vKnhFtwSQIOooz66XSDP2faDwmN4Op30klZVc+CLr2152vpbzGvm8zYkSdIGhGI2iKcG97VgQOofL4ccrWrZWyHH36SP4BoGTNWlIfeBC5gwOBa9cQsm8vvku+BVGkMq4NjmCvXg0jh2q1oOz2l1juCFLLUjlZcNLYnL58+3YQRQqX/YDukv7Y6qPRiGo1NiOGG49lllSSWVJJt7unYjWgP/mffEonMw3/mxHBsbQS5q9NuOJcg+G+w9GJOkasGMFdm+5i0yfPopfBQ8rf+CjmI1aeX8mJ/FjkVqn8kryAY3ltd9A7WisZ3tmNdcez0DeRZXwpgiBgP2ECFYcOo83NvZLbMhKdE80bB9+gn2c/vh/zPf52/qw831hbNogGNiVtor9X/1abBWmSUxDMzRnX/z4OZh3keN5x3jnyDsH2wdzm+wBZZ+/Dx7w3P55ZQmJJIgsHLuSvKX8RZB/Ei3teJL0svcX5Af44+wfDVwxn7o657HMtwuZ8FlXZdf2gXW3NCXK1rvMTGPRSGQnP1s1CWxNyWHYghc7qXP44nEyV9so3FC1hEgQdxZEl4BQEIc3sXBx8YfJXkv18x8LLfpnynTuwCA9H4e5+WRpBuLcdW/z7oQ/rSu67b6PPS4dBzyAC+YsXk/3qq1j17k3A8j+wCAvDzNUV6wEDECwsqDzWhtBQ70goSYOKAqgqhQvbQJBJsdTXQQObzUmbERAYFzgOgPId21H4+CBqtRR83bAWk2rXLgQLC6kwWw21u70+gc54vD4fQ1UVeZ98wm3dPXlyRCeWx6Tzf/sbmgzaSzedG3/84MiSHy25e8lFfHedITHckcdueZW/p/7N0buPMtTyM2SZL+Bp48HcHXO5UHwBkEwpbx1+q8Weynf08iavvJqDF9vm5LabcDuIImUbN13RfQGotWpe3PMifrZ+fDz8YxRyBdNCpnEs7xiJxYkNzj2Wd4ysiizGB45vdV5NaipKf3+mh83A0sySJ7Y/QVZFFq8PeJ1vdqVgLrfkx9u/5MNhHxrLhdsobVg8cjGCIPD0rqep0DbvBynXlPNx7McE2gfyxcgviLj/OWQipCz/ocF5fQOciE4pkoRsUTJoK1p1FGcUq3nxzxNMEPL49O8PuW//r2w8kdXiNVeKSRB0BCXpkH5YKh7VkgoYNh76PAKHvpAekO1El59P1Yl4bG8ZCUCRWoNCLmDbRmchQLiXPaIgI2HG4+jLKsg754PYaQw5CxZS8NXX2E+bit/SJcjt60LsBIUCy+7dUce2QRB4SVEdZB2Tmtvoq6UaK9WlUJzS4NS5O+ayJP6fK0shiiKbkjfRx6MPHtYeaHNzqToRj8O0aThMn0bxij/R1LRt1KSlUbbtb6wHDkGeHR8AACAASURBVERmYWGc42hKEbbmZnTxtMM8KBDH6dMpW78BXXEx80aHMi7cg7c3n2H76eZ3z03V+6mPau8+ZNn5eHTqQVelPw6uvtz6ypfc3eVuPG0kR+fJzBIivHz4dvS3WMgteHzb4zyx/Qkmr5vM8nPLmX9gfrONbkaGuWFrYcaauLaZh8wDA7Ho0YPSDVcePfTb2d8orCpk0aBF2Cml6J1JnSahkClYeaGhVrApaROWZpbc4ndLq/PWCgJ7c3umhkylXFvOHZ3ugKpA1p/I4r6B/rjbWjE2YCzOlnXlun1tfflo2EcklSbxzYlvmp1/c9JmKnWVvNL3FYb5DqNn5FhO+0LV+k0NNMABwc6UVek4nVUG6VIF4JYEgVZv4Knfj2EQ4Sm9JMxHp8eQ9sXXHZrFbhIEHcHpddK/3e5o/dxb3wK3brDmcakfcDsor0lsshlZIwhUGhytlO0qoexmZ4GbrTkF1Vk4hagoOa0n7eFHKVm+HOdHH8XzzTcRFI3bLFpGRlJ15gwGdStlkj0jAEESBKdWSj6DqJpoj3rmoaKqIvZm7OXzY5832r1WaCvaVY65rSQUJpBalmo0C6l2SvkUtqNuwfWJJxAUCvI/+4yyv/4iecpUxGoNzg8/3GCOmJQiIutV+nS8cxaiVkvp6jXIZAIfz+hJuJc9T/9xjISsxlm83+y5yJAPdlGibt48qI6LRe7sjM83XxP45wo6bfsbq8hexvEqrZ5zOeV097HH28abr0d9TaW+koTCBJ7s+SSb79iMu7U7L+x5wehnqI+FQs7ECC82xmeTXNC2aCD7SROpPnuWi7ffTt5HH6E+1v58kTJNGctOLWOYzzAiXCOMxx0tHBnlN4qYQ2soO3MKkGzxW1O2MsJ3BFYKqxbnFXU6NBkZKAMkh+wjPR7hwfAHmRk0h0d+isXPyYo5w4Kbvb6/Z39u8buFdYnr0OobJ8+JosjKCyvp7NiZbs7dAPCx8SE6yh7zrCIq4+o2SAOCnHGmFNnm52D9k2DvK1UdbYbv9ydzLK2Edyd0Rty9A7sJEyjsP4Jxh9dw4teWo6muBJMg6AgS1kjhYc7Nf9iMKCxg+jIpr2DNY+0yl6h27kLh7Y15qJQXUKTWNBk62hqRfo5EpP2Icz8lZq5uqI8cwe2Vl3Gb91yzQsUqshfo9a03MLGwA5cQuPA3JO2Raqm4d5MqmubU1SE6XXgakFo+Lji4gBP5JzCIBv48/yej/hzFs7uebfd9tcbGpI0oZApG+Y8CoHz7DpT+/iiDgzFzdcVp9v2Ubd5C5rPPoQwOImjN6gYP4OIKDedzVfQJqIvbNw8JwbJ3b0pWrEA0GLBUyvnu/ijsLRU8+EN0gwftwcQC3v/rLJkllWxoQfWvjDuGVWRks3+LcznlaPUiPWrq5XR26syWKVvYNm0bj0U8hq+dL/8b9j8KKwv5z/7/YBAbF8t7ZlQI5mYy5q871aadp+PMmbi/9hpmrq4U/vAjqXfe1UhDUGt0LNyQQFJ+0wmUP5/+mTJNGXN7zm00NlMfyWvflZHy4ANkFqeyMWkjZZoybg9qvdyJNisLtFpjhJyThRMPdJnLU7+dwyCKLHugLw6t+NGmhEyhuLqYXem7Go2dLjzN2aKzTAudZvybCIKAflgfqpQCJavrHthu6X+x1+J5Omethb6PwWN7wcychMIEXt77cgNfRHZpJZ/tuMCoLm4MK76AoawM+4kT6bn4Q866BCJ/byGVJzumYZBJEFxtilOlYmtt0QZqce0MI/8LSbsh91SbLjGo1VQcOoTNyJHGD2NRxeUJgruD1QwWY0kPuwvf75bi98MynGfPbvEay549AdrmJ/CKhIxoKZGm+zSp5Z5rlwYaQa0g+H7M97hZufHMzmd4+O+HWXRoEUq5kkPZh8gob9j1TBRFdHrpoaYvLTVWV20LOoOOLclbGOYzDDulHfqyMiqOHMFm1C3G99P5oYew6N4dp4ceJODnn42JW7XUlhm+NGTTceYMNKmpqGuaAbnbWbDsgT5o9SJ3LjlMcoHU0/bpP44T5GJNqLsNf8Y23dFNm5uLNiMDy96Rzd5LfG2HLZ868529uT1Ked1noZtLN17s8yL7MvfxY8KPjeZws7XghTGd2XehgM0n6zRTg0FsMnxRMDPD4e67ufDie7zzyKecdvInfeGb6ArrGrJ8tDmBwp9+Ydv8jyhZtYrynbuoPHkKbW4eRap8fkr4idH+o+ni3KXB3NUXL2L7n88wmMlQFKt4653bmH9wPk4WTvT36n/pUhpRa85TBgRIv+sMPPZzLBlFlSy5N4pAF+tW5xjgOQAPaw9WJzbehf95/k8s5BZGTbKWcN8oDnSB0s1bMFRUSHW2Vj9CsVUgE/QfUD36bbByokJbwfO7n2dz8mZmbJzB9lSpAvBbm86gN4i8MaEbZes3IHd2xnpAf2zsrLkw93WyLJ0oSO6Yzn8mQXC1MZqFJrfvuohZkhM1YU2bTi/8fhlidTV24+r6BBRfjiAwGBiUvpRKlHyjHolFaGgDZ2hzyO3tMQ8JaZufwLvmIebaRdIGQIqcyD5h1IASChLwt/PH19aXL275gip9FWcLz7JgwAJ+H/87AgIbkhruON/ZfIaxn+2jODqGpImTSJoytU2JTiVVJby671WKqoqMO0zV3n2g02E7alTdPdrYEPjnCtxffLHJXrcxKUUo5TIifBtW+rQdMwa5vT3Fy1cYj4V52PHrw/3Q6A3cueQwc36JQ1Wt5et7ejOzjx/xGaWcy2ncOrTWzNBU0/VaTmaU4GStxNuh6cJqtczqPIvhvsP55sQ3FFc1Tni7p78/3bzsWLQxAVW1jqPJRUz4Yj/93t7OxUt29Yl55Yz5dC8P/xRDUqXAhlH3Y1CrSXxdCnyITszDa/HbzDm5lqG7lpP92n/JeOIJUqZPJ3HYMLL7DuPujSrmdnuswbza7GzSHn4EzMyw/+kbqnxceOSMJ28Peoslo5egkDU2U16KJqVGENRoBN/uuciR5CI+mNajTXWYAOQyOZM7TeZg5kGyVXWlIyq0FWxJ3sLYwLHYKht2NOvp1pNdPWRQWUnZyp/hj7vAwZ/zo7/njNbTWHfo3SPvkl2RzftD3ifQPpDndj/H038vYFN8Jk8M74SXXItq927sxt+GYCb5+2be2oMnRs5jk31om9bfXkyC4GqTsAY8e0oRQ+3B2kXKOUhY06p5qDo5mcJvv8XutnFYRdbtFAtbEAQV2gp2rZxF5sanQFNjbzcYYNM8ZGfWcdBzNmvOVVFa2faCYpaRkVQeP95s8pWRWodx93oldj0joCLf6Bc5XXSark5dAQh2CGb1xNVsnLKRqaFT8bLxoq9HXzZc3NDAbLHjTC5hh7eSOXu21B9ArUa1q2HdJJ1BR1JJEqllqeRU5LAzbSd3rL+D7anbmdtzLiP9JP9K+Y7tyF1csIyIoK0cTSmih499o4JlMnNz7CdPpnz7dnQFdZE4XTzrhEFsajFvTe5OqLstk3t6YSYTWBXXeLenjo1DsLTEIqx5u3J8Rindve1b9Q0JgsCzkc9Sqatk2anGrUTlMoG3JoeTV17NhM/3M+PbQxRVaFCYyZi3/DjaGu1LVa3j0Z9jKVZr+GxWT3bf68z35s+T3s0Xcec2stZv5sKTzzAo6yTmzzzPXXe8xx/PLSZgxXJ8vvoSx9dfYW+EGaOPGTB7/h10xcWIej0lq1aRMnMWhvJy/JYuoVP3IQQ8PBfLxExGlfnS2anpUhGXoklNRWZlhdzFhbRCNV/sSmR8D08m9/Ju/eJ6TO4kbebWJtblvGxJ3oJap2ZqSONy0V2dupLiq0TlYUfpj4uljd3dK+gdFoxMkEyBf6f8zbqL63i4+8PcFnQbP479kZmhs9iVvQpX3wM8NiyIsq1bEbVa7CdMNM7t72zNyrlDeGRIO58rbcQkCK4mxSlSzHx7zEL16TYFipJajLEXRZGchYsQzM1xe+UV43Gd3kBppbaBINAZdKxLXMec7XMY8sdgnq5I4KGc7RQtGQKZsbBpHsQug8HzcLvtNTQ6Axvj2x6mZhXZC4NKRXViYqMxUa+n6vRp6cHtEwWTvoJ+9TKsPWseuNknKKoqIqcih67OXY3DXjZeOFnU7d4mdppIenm6MUa+qEJDv/3rmBu/hhiXUAq/+hkzT09jSGNBZQFL4pcwbvU4Jq2bxO1rbmf0ytE8s+sZnCyc+P3233k84nEEQcCg0VCxZy+2I0citCHRB6BSo+dkRmnjTmCphyD6OxyGdwOdjpLVDTW8Lp52rHx8AJ/N6sm03j4AONuYMzLMjdVxmcaHbS3quFgsIyKadNjXruN8bjk9fNpWOC3YIZjbgm7j97O/U1DZOFy0l58j9/b3J6e0iudGhbLz+eG8e0d3TmSU8sXORERR5OVV8aQUVPD5nZFM6umN4vwmZNoKbgs7SLW9guKXXqBXynHUjzxN0JyHmTSgE7+main2C8F25Eh2RNjy1ViRYw/cReWxY6TMnEXy5Mlkv/Zf9K5uWH7xDRY1mdv2Eycis7en6IfG5qzm0KSmoqhxFL+x/hRmMoHXx3dt5arGeNt409+zP2sS16A36NmWuo2vT3xNJ4dODZzbtSjkCsJdu3MiWIs624Bhyo/gFIS9pYLuPg7sSTrPwkMLCXcO5/GIx43XdJLfg7Y0Ao3NFs4Wn6Rsw0aUAQFYhHdr9Ldprv3oldKhgkAQhLGCIJwTBCFREIRXmhifLQhCviAIx2t+Hm5qnhuG2taM7TUL1dJlAgjyFs1DZRs2oD58GNd5z6Fwq+vBWqyWdvK1guBQ1iGmb5jOfw/8l5TSFGY5RvB2fiEFSnOes6hGu3SkUQhwy3zCfewJdbdhZTO26qawrNFG6kdJiHo9pRs2kDT+dpKnTKVk5Uqp1kuvu8Hcpu5i93BAgOwTRv9AN5eGH/z6jPIbhaWZJesvShmtx85mMjVxD1X9h/DT7U/y4tYULG8dg+rAAbbGr2T0ytF8fuxzAuwCWDRwEe8MfoeFAxfyzuB3+GP8H4Q51e2wS/5YjkGtxm5sy9mq9TmeXoLOIDZwFFNRAL/PhE3PY771HqzcNRQt/QJ9ScNInSBXGyb1bLg7ndbbhwJVNXvP1yWx6VUVVJ8910Dru5TT2aUYROjh03IjmvrMiZiD1qDlu5PfNTm+YEI34l4fzTOjQrBUyhnX3ZMpkd58sSuR19aeYlN8Ni+M6cyA4Jqwy4s7wTsKYcxCQvtlI5iLHL9tFr2flwT/w0MCEYHv9iVzMV/FRwf/wKBxYEFZJIb/fYWhogKDRgML3+WOLg/y6OEKo+Yns7LCccZ0yrdvb3OHNE1KCuYBAWxNyGXXuXyeGx2Kh71F6xc2wZTQKWRXZDN53WTm7Z6HrcKWhQMXNqt99XTryRG3ahAFqlWS6UgURVw9j3NRuQidQce7Q941mrhEUeTnw2n4Ge7F08aTd9c/jzo6GruJE9oV/XeldJggEARBDnwJjAO6AncKgtCUWF4uimLPmp+mP5k3CqfXSWYQx4DLu97KCYKGN2se0hUXk/ve+1j06IHjzJkNxoprwg8drOS8uOdFHt32KJW6Sj4e/jGbp2zmJZWWiTJHFg1+mziFwFud+yGOfB1umQ+CgCAITOvtw7G0kkb24OZQ+Pggd3VBHRuHKIqU/f03SRMmkvXiSwgKBeYhIRQs/rzpEFNzG3DuBDnxRkFQ/+Hc6K1RWDHafzRbU7ZSpauiYOVqrHVVBD39BB9M70lmSSXLbcNAp2PfLx/S2bEz6yevZ+mtS7kj5A4mBE9gSsgUJgRPQCGv213rCgvJ//xzrAcOxGrAgDbdN0iVPgUBevvX0wi2vyFFf923Hmb8hNv4UPSqarLnv95qJM6IMDdcbJQNBHHlieNgMLTsKK5pLNNWjQDA386ficETWXFuRZPdz2QyAUtlQ3PXgond8LCz4LcjadwS5sbjQ2si4iqLJe0yeCQMfhbzJ36iy+Qspk2pE5A+jlZMivDi96NpTP12KzrlOcYEjMPeypxnE/T4/LUVl5XreDzNHq1B5GxOOdEpdT4Mx7vvBkGg+NdfW703UaNBm5kJ3r4s2pBAmIctswcGtPm9uZSRviNxs3SjQlvBggELWDlxJT1cm88M7unak/Ne0gO88uQp0srSeOjvhzhS/g36Ki/mdfuaAPu69RxPLyEhq4z7+ofxwdAPcLwobQRshg677DVfDh2pEfQFEkVRTBJFUQP8AUzqwNe7tmjUkkkneOSVzRM+BUpSGzV0EfV6sl56GX15OZ4LFyDIG35RC1WSIMjRxPNXyl88EP4A6yavY7T/aAS9VgrdDBnFbUHjeaT7I6zWZPObq2eDyoyTe3ojE2BVG7UCQRCw6hVJxeHDpMyaRebTz4Ag4P3pJwSuW4vHwoXo8vMp+rEZtb7GYVzrKL7U+XYpE4MnotKq2JW6A69dG0j1CMY+sidRAU7cPyCALzPkqNztiThRzit9X2lT7+G8Tz7BUFmJ+39fa9cOLDqliM7utthb1giV9KNw7BeppEjQMOg6Ccvp/8E1vJzyv7e3moWrkMuY3NOb7WdyScyTBHFlbBzIZFhG9Gz2upMZpbjZmuNu174d72MRjyEitpg0VR87CwWf39WLiRFefDyjJ7JaE0XyXhANxs+9PGwcglsXFBcbJkg+NiyYSq0ec4dTIBiYEzWdj6ZHcD5Xxfs7k3luZTxZJZX88EBf7CzM+OlQivFahYcHtqNHU7pmTav+KE1GJhgMnBBtySqtYtGkcMzkl/+YU8qVrJ60mi1TtzA1dCpmspaTNXva+lNkCxpbBWcObGDahmmcLTzLa33no896jAsZDf9OPx9OxcbcjMm9vOnh2oPJ5lLZ93irwqam7zA6UhB4A/ULdmTUHLuUqYIgxAuCsFIQBN+mJhIE4VFBEGIEQYjJv6T+y3VD7ikpPNK7+d1bmwgbDzJFI/NQwZdfUrFvHx6vvWa0n9anViM4lL8RJwsnnur5FOZyc2kw/TBoyqWeqMCTvZ5kqM9QPon9hJTSFOMcbnYWDAlxZWN89qXTN4tVVG/0BQXocnLxfPstgtatxW7sWASZDKvIXtiOHkXh0u8ahBUa8YyA0nROF5xq4B9ojj4effC09mT3n5/iUpJL9qi6fcUDgwIQ5Sq2hqjplibSDa9W56uMj6d01Wqc7r0X86C2O+FEUeR4egm9a+v+G/Sw+QWw9WzYyMe3H849RCwDHMlZtKhB45KmeGBwIPaWCu7//ii5ZVWo4+KwCAtDbtN8uGN8Zmm7tIFavG28uTPsTlZdWMVfyX+16ZpIP0cW39kLe6t6/oqLu0BpK/mBagm9VQqdrNeHorOHLWueGEig/zlCHEMIcQxhWKgrswcG8OOhVHady2f+hG4MDnFhRpQvf53KIa9e9Va7MbeiLymh8njLJc01qSkA7Km0JMjFus1RQi1hb25f911qBUdVIQFaHSc99KhPxhPpHsmaSWuY1WU6vf2cOHCx7ntQVKFhY3w2d/TyNpYO76qyp8BOYFfBP9v8p82CQBAEG0EQIgVBaLsxsnU2AAGiKPYAtgFNbh1FUVwiimKUKIpRrq6uV/HlryK1pZa9erV8XmtYOkq7q4S1IIr8cCCZZ55eLJV7mDIFh5kzmryssEKDYFZKXP5BpoRMaWD+4MI2SbgESeqmTJDxxoA3UMqVvHHwjQYJRiPD3EgrUpNa2LYMU4cZM/D+9FOCt/6Fw9SpxnC3Wlyfm4ehupqCL79qfLFnBEUyGTmVecYMzZaQCTJe7fsqUXtyKLSBM1GlaA2Sb8Tf2Rq/4APsDwNBhPK/Wn64iQYDOW++hdzFGZe5TRQGbIHs0irKq3SE1fa5jV0maYNj3gbzelqNmRIheAheAytAryfrP/9p0URks28HP+36kMkHlvPf91ZQefy40Q/TFOdzy7mYr2q1UX1zPBf5HL3cevH6gdc5V3Su/ROIIlzcAYFDoP7nLWQMGHRSXkw9XBxVJBSdbFAr6JVxYfQNdOKBQQHc009q1XhPf390BpHfjqYZz7MePBgUCmOb0OaozSHYVqpkdNfLaLF6pRReYHBlJSleZngXCXzR70PcraV1jAhz5Ux2Ge9ulvIF/oxJR6MzcE//upLU+pQ01J4O7Enf06ElJS6lWUEgCMJX9f4/GDgN/A84KQjCbW2YOxOov8P3qTlmRBTFQlEUq2t+/Q5ovXP49UrWMalHr13LO9EPt55l8pcHGpUn3nU2j0d+iuFIUqHkNC5NZ9naLXy5/AD37FxGVWAIHvNfb9Z8UVyhQeFwFBGxcWhb4nbwH9DgIeVm5cZLfV4iLi+OP87+YTw+OESq6rivjV22ZBYW2I0d06D+Tn3MgwJr6vasMH5JjXj04LS55Nxui0YAMLDah/BkHZvDPdmS+yPjVo3jxT0vsiR+CSXyvSTL+6ML7ETpppZNMaqdO6k6eRK3ec8jt7Fp8dxLqY33D/OwlQrp7XwLAoZIUV+XEjwSpSEFtycfRH3oMGXrmy7fXLpxE1kvv4xSBuOTDzFv9buIVVWYNWMWKqrQ8NCP0bjYmDOzT5OKdKso5Ao+Hv4xduZ2PLPrmSZzC1qkKEkqKHipOdS3L5jbw4WtDQ5vTtoMwG2BdY8PC4WcFY8N4I0J3Yyf7QAXa4aFuvLbkTRjFJXc1hbrPn2M1XabQ5OSgt7aliIzq2sjCAouMK9ExZyZHyCIItUJp41DswcGcm9/f77dm8TsZUf55UgqfQOd6OxR51TWJCdjFRxChiqD5LIrK1bYHlrSCOpnFb0JTBZFcQQwDFjUhrmjgRBBEAIFQVACs4AG3wJBEOq3BpoInGnTqq9HsuJa1QZEUWRVbCbH00v4fEddyGVOaRXPLj/OttO5zFxymBeOSqaA8zHbedIsHRtdFTunP9XswxagQFWJuWM0g7wH4WPrUzdQmgF5p41mofpMCp7EIK9BfBr3KZkqSUYHuVjjZW9xVdstusx5AnQ6yrZcsku3ciLBURKcLTmK61P0669ozZTEBT3L4hGL6eHag+P5x/n82OdYKqwwV43hSHBfqk7EG2vSN0XxihWYublhP6H1kgWXci5XEgShbraw/1PJYTrm7Qb+FiPBUoE0h27mWEZEkPv+B42iiMr++ousl1/GqndvgtatpfP+veQ9+DTb/KKYl2zZKLNXozPw+M+x5JVVs/S+qMuOiAFwsXThsxGfka/OZ/6B+e27+GJNzsalgkCugE4jJU3UID3IRVFkc/JmIt0ijYXyWuK+Af7klVezNaHOmW0zciSapCSqk5t/QGpSUylwcMPZWkkvv7a17LyqFCaicAzAvpdk6686VVcSQmkm483J4bw3pTtHkopIL6rk3nragC4vH0NFBb7d+gGwN33vP7bstpqG7ERRjAMQRTGpLdeJoqgDngS2Ij3gV4iimCAIwiJBEGozJZ4WBCFBEIQTwNPA7PbewHVBVZnUm7cV/8CZ7HJyyqrwtLfg6z0XOZVZiiiKvLjyBBqdgc1PD+E/t4WxI9eaAtGOe7yyGaUopczanr2VLRfauqA6CmZlzAi9xHSUKKWvE9JYEAiCwPwB8xEQ+Cj6I+OxwSEuHLxY0Kb69G1B4e6GeZcuVBw61GjstI0jAVo9tvK2PcxUe/dxzKsrXTr7McJvBB8P/5ht07axc/pO1k5aw5SIMD63CkdwcCT/s8+anEObnU3Fvv3YT53SyJTVFs7llONpb4G9Lh8Ofw3dp9flRVyKczDY+yEk78Jj4QL0paXkffwJIJmnin75lcznX8CyZ098v/laSoRycGDYS3Pw/+A9DuRUcfd3R4xF6fLLq3lldTxHU4r4cHoEPX3baRZacT+8HwBfD4Jfp0Pcz4S7hHNn2J3sz9rfZJG1ZknaDfZ+TSdPhowBVS7kSML4cPZhkkqTmNSpbfEiwzu74etkyfLoOjejbU0fCNWu3c1ep0lJ5ZyZI7d0ceuwmPsWKUwE5xDMHB1R+PhQebJxyZhZff3447H+zBkezJhuHsbjmhoB59qlJyGOIezNvD4EQViNE/ckECoIgiOAIAgyoE11DERR3CyKYqgoisGiKL5dc2y+KIrra/7/qiiK3URRjBBFcYQoimdbnvE6JfsEILaqEew6J3X0+vmhvjhZK3lxZTz/tz+ZfRcK+M/4LnT1suPRocHsfXkkZv796aY7Q/Xp06j9gjmdVdpic4pUzXbkBgeG+AxpOHBhG9j5NFvx0MvGiykhU9ibsddY4XNwiCtlVTriMxpXqrxcrAcMoDIuDkNlZYPjpwUNXaqrGnYxawZtZia6rCxi7QPqHLU1uFq54mHtwcw+vpTKlCTfOpWKg4eoOHK00Twlq6T6MQ5Tp13WvZzLKSfU3RZ2vyfZwkf+t/mTBQGCR0DyXixCgnG67z5KVqygdN06Uu+7j9y33sJ64EB8v/0WmXVDp/Cknt58fXckZ7LKmPzlAUZ9vIc+b29ndVwmT98SwsSI1h3iDUjaI3WG84oEBz/IPQ1/vQLaSsJdwtEZdFwsbWM3LL1WihgKHtG0JtRpFCAYy6t/d/I7XC1d21Q0DqQs55Gd3YhNLTbWk1J4e2MeFmasEnsphqoqtDk5pFo6MbqrR5PndCgGvdRx0KUTABbdw6lqpkhcpJ8jL48NQ2lW9wjWpEiCQBkYyDCfYcTlxlGmaVsL0SulJUHQBZgA3A6EA7XB5U5AO3XIm5zah1grgmD3uTy6e9vTyc2WtyeHcya7jLc2nWFYqKvRUQZga6HAofMQDPnJVCclYdm1K1q92GQZY5CyaMtlCXjIhjYMbyvLlqI6QkY3/WWtYYTvCDQGDYeypB37oJpEoatpHrIeMABRq21Qm+h43nFyNKVEVVVLD5VWUMfGAnDSJYiogKbV/i6edkT42POlbQRmbm7kf/ppA6dbbSkD6wEDUPq0r+QASBncifkqBtkXSG09+zzcud9jxwAAIABJREFUet5Ip1ugugwyYnB9ci5mHh5kvfwK1ecv4PnOO/gu+bbZyKBbu3nwf7OjMJPL8HG05JVxYax/chDzRrez5owoSg2Q7Hxg1m9w5+8w6XPQqODCNqNp7kxh89ZZrUHLsbxj0vuZGSvdU3Ph0jaukoZ8fisn8k9wNOco93e7v0EhvNbo5eeIWqPnfG5dXovNiOGo4+LQFTf2Z2jS0hBEkTx7NwZ3armDWYdQmi7123CWBIFleHe0WVnoiopauVCiOikJwcoKM3d3hvoMRS/q29U280poVhCIoph6yY+25niBKIodVxj7RiQrTlKRrZv/8JWoNcSmFjOisxT1dGs3D6ZG+uBiY86H03o0dgL79ae6VAF6Pd59JYdhXGrTO/TkUmkn4WleL6xUFKUSEqIeBj7V4vJ7uffCVmHL7ozdgFTyoJuXHfsSr54gsOodiaBQUHGo7oO97NQy7M3tud3Kv22CIDqaagtrCl18CHFrPudgci9vThVWI5/9MJXHjqHas8c4VnHwILrsbBxmTL+s+0gpVKPRGbg9byko/p+9Mw+Pqjr/+OedmUz2hISQkJUECLvsuwKKuCsotlar1WpbW1urVVtrF+2uVlv9abWta13qXlFxRUERRZFd9iVA9n0P2ZM5vz/ODGTPJMwkJHM+zzNPcpe599xcuO897/J9g2HhL7r/UspCrTtz6GMswcHE/+1+Ir59BSPfeZshyy/ptn5hQeowVt+6iGeunc2PFo3quoq4oRoOrtYB7MPHr5t97+qH9+m/1NLnAMkLIWgo7H6DpLAkAm2B7C/rPHvo+T3Pc/X7V3PTxzdRmr4WgPqEWTyx4wkuWHEBn2V/1voLqedAzhae3PZPwv3D+eaYnv3NpyXp69yWdfyhH7p4MTgcVH/2Wbv9XWJzMeNT2xXE9Qklzrjf0FRAzwiATmcFbWk4ko49eQRisTA5ajLh/uF9FifoKmsoTETuEZHnReTbbbZ1kAvow+Rug/iuZwPrDhbjUHD6uOOyEH/75mQ+u/0MojsqBoqdQl2FVpOMmTGFhIhAtmZ2nNWRWanT7OJCWmSP7Hod9r8HZ/ym274IfhY/Tks4jXXZ62h2aPfTaalRbMsso7oDCeLeYAkKInDatGNxgvSKdD7J+oRvjf0WQSmLdPempvouj1H25Ua2DxnBWafEden/nTtSz2i2T1qAX2IiRQ88eEwPqfzV17BGRuoHSi/Yn1/F6ZZtxBV8DAtuheCh3X8pMALiZ+pUSyBo5kyG33VXK4mQE6a5CV69Gu4dAS9cCuvuh+eW6Z/NTfDxn/QDakqL/8pWG4xfCgc+wNJYy9iIsewr7dw7+1H6R0QFRrE+dz2XHnmFZ2KSuHj193l428NUNVRx8yc3szZr7fEvjDmbg3421uZ9wZXjruy2oUxbkiKDiAy2H1PtBAiYOBHbsGEdZg9lbdhCM8K0+d33BPYKxU5DEOU0BBMmgkiHcYKOaDh8GP8UHW+xWqwsiF/A5zmfH/s/6U26cg39BxDgdeByEXldRFxVFd3rFPsKNaVabK47t9C+QiKC/JjS4m1OpH0p/zFs/tTVD8fiL/jFxzM9KaLVf4iWHC7PQCkrCa5sjOpieP92iJ8B89o3/eiIMxLPoLSulJ3F+u1lwehhNDYrvjriuQrH4Hlzqd+zl6ayMp7d8yx+Fj+uGHeFTr1sqtM9CzqhMicfyc4kI34Md13Ydarp2JhQwgJsbMquJPr2X1B/6BCHL7yIw8uXU/XJJ4RffHGHstLucCinkD/6PYMjagzMu9H9L47Rb8dt23N6jB2vaImTaVfBVSvgF4d174eP/wyPLYCifTqWYW0THJ+0HBpr4MAqxkaOZX/p/g4b1+RX57OrZBdXjr+Sly54ifDmJv4eBAG2AJ44+wnevuRtxkaM5ZZPbmF1xmqUUtQMTeWJqGgCsfDt8d9ud8zuEBGmJQ5hW4sXILFYCFm8mKPr1mnNfydKKY6u+pAd0aM5fXr3FeVeoeQg+IdBsJ71W0OCsY8a6daMwFFXR2NuLvaU42NfmLCQsvqyY/8nvUlXhmCUUuoOpdSbSqmlwFbgYxFx4xXIhzgWH+g8Y8jhUKw9UMSiMcN6lMlQV2YnYEg90lTH9KQh5FfWkVvuDLaWHoF/zIRP72dv0SFUQwRxQ4KhsQ7euUVnMi17FCzuTZFPjT8Vm9iOvdHNTI7A32Zxu57AHYKdWj756z5iZdpKlo5eSlRgFIyYr10nR9pP9108/7ju83D+Vee3rmztAItFmJkcycYjpYSddRapn64l5te/QixWxGYjopduIYDR+x8jSYqwXPAA2HpgTCY7taF2vNr1fr2hqQE+vVfLn1/4oI5JBA+F5U/AOXdD0X69bUIHGTsjToWQGNi9gnGR4zjaePRYKnFL1mTq2cySpCWM9Y/i5awsHos9h9cueo25sXMJ9w/n8bMfZ2LURG5deyvTnp/GnJfn8X6Alcuqagh3MyusLdOShnCoqJqKmuPZTOFLL0LV1FD54XEZi4PrtxJWkkfTgsVEhbhXBexxStJ0fKCFqy9w0inU7tzZbXFYQ0YGKIU9JfnYuhkxuqzKpcXlTboyBP7ODCEAnFk/TwDrAN8zBjlb4GgH8hYuTaDO0geBr7PLKa1u4Ixx7rsCVGMj9XmVBAxpgJytx3Kij7mHvviH/of3yZ8pzfuMsKZAzqlaAQ9Phb0r4YxfQXR7KYrOCLOHMSNmxjFDEOBnZXZKJK9uyuKyx77kppe28cqmzK4P0g0BkyZhCQlh76pXaHQ0cs2Ea/SGwCH679dJnOCdHbkc3biRJnsAM89yTxhuVnIkh4qqKT5ajy0qisirryblf68xdvOmY52rekzRfs4qf4UNoWfpatqeMCRRz3y+fqlH7UjdYttzurBr8Z2tkwJE9Izwhi/g2692nDBgsWoDcfAjxofqhIWO3ENrMtcwKnyUFkzL20aAUswffVGr5IRQeyiPnfUYN0y5gesmXcctM27hjyMv46biQkj/vFeX5vp3v71FBlvg9OnYR4yg4vXXj637/MmXaRYL599wRa/O4xGK0465hVwEzphOc2kpDYe6zsZypY62lDoZFjiMIFsQ6ZXpHh9qW7oyBG8DrRypSqlngNuAzjttD0aOFsKTS+CB8fC/6yB9PdQf1f+hc7frt4DAzgN4n+wvwiKwMNV9eYz6w0dQjU0ERDRC1gbGx4bhb7No91B1MWx/AaZ/h7rlz5BndbC0aQ8Ba34LkaPg6re0vHQPOT3xdA5VHDrWR/XmM1O18VKw8Ugpv3x9J/vye5/OJjYbAbNn4r91H2ckntFKhZGUhdo11NBaqVQpxX0f7GdWZQahM6e7nffv0pjZnN46Y6M3dQMumt/9BTXKztfjf967A0y5QlfjZrVPae01jbWw7m+QOFfPBDoiehyEdlFlO3E5NNUxuiANq1jY99UjsPKmYwartK6ULQVbOHOE8/g5rllw+6rnYL9gbph6AzdNv4nrJl3HJXN/jt0WCAfc0zNqy+SEcERo7R4SIXz5cmo2b6YhM5PPDxQxYueXVI6fQlRCP1QTgw7SV2Yfyxhy4ZoFV2/4quuvOw2Bq6sa6OtMCU9ppQfmLbrKGrpdKbW6g/UfKKVSO/rOoKX0sFZYHHm6LtB65ny4Jx7+GKmzMbqID5QcredFZyl5RA/aSNbt1dPBgJHxkPkVdpuFyQnhekaw6SntU593I6/UplJjEUKHnw7Xvg/XvqvH2Qst80WJWovIlT00MzmSR749nVd/NI/3b16Av83C819mdHGE1rQUDXNROimBYeUOvhFyWusNKQvBoY1eS3bnVlKaX0xsSQ4hs2e5fe5T4sMJ8LOw8UgPZRM6ozwLa/qn/LtpKUmJI7rfvyMmLAW/ID0r6C31R+Htm/XDP2cLbHwCqvLgzDt7dc8BSJwDoXH4v/tzUurr2FeyG7Y+e0w/a23WWhzKwZIkZxvP3K068BzghtidX6D+97j/g17NhEID/BgTHdouPhZ+8TKwWChb8QbPPLeKuOoSUr/Vyz4gnqDE+cbfxhDYExLwi4+nekP7YsqW1B8+gi0uFktQ64B6cnhyv88IDC7KnS6Rc++BW/fBpU/Bkj/Agtu07PCpN3f4NaUUv35jJ5W1Tfxh6aQenbJuzx4kIAD7KXN1Ro3DwbSkCNJyilEbH9epecPG8trXWo1x8rzrtK/9BEgMTWT0kNG8d/i9dpkKEcF2lk2NY8XWHLfaWa5PK2b23Wva1SJsS9KByNF728wskuaBxdbOPfTuzjxOKdVvS0EzZ+IudpuFqYlD2JjuoWB3mvZHf+iYcUwbpsf4h2odqd0rdCynN6y7H7Y8o7OAnlgMH92pH7TJp3XzxS6wWGD+jRA1mnFRk9gXmQC2QF0nAazOWE18SPxxGZCcrT1T2R17HlRkQsHuXg1vWtIQtmeV42hR6e4XE0PwqaeS/9rrjNj+OcpqJeLs9tXzXVJVAI/Ogcyu39bdoqR1xlBLgubNpWbjpi4ltBuOHME/uX2QOzksmbzqvGPFnt7CGAJ3KHO+BYcngD1IZ2Oc9jOdhXHu3TD8lA6/9vrWHFbtLuDn54zp8cOjfs9eAsaORUYuhLpyeOsnzIm1cCGfIjXFqPk3cqjoKPuK9UMyMax3wmNtuWbiNewq2cXD2x5ut+3qecnUNja71a/gn2v1f4y3v27d+vJTy0Hy4gKp/d9brQNo9mCdYtnCECileH9nHuc05SJ2OwGTe5YWODs5kj25lVTV9UA2oTMOfkSZPY5sawIjhnYuC90tUy7XQnUH3u/5d4sOwJePwNSr4OcHYfmTMOsHcN79vR+Pi3k/gR+uY9yYpRTWlVA6/gLY9TpHqwvZkLeBM5PO1PUOlXlwNL9nKrtjnJ3fenPNaENQUdvIkTaKuJbzL8ReUsSyI+sJmT8PW0QPtYU2P6Wzqfa82f2+3eEyBJHtU7WD587DUVlJ3Z6Og75KKRoOH8begRS6y32aWXVi8bnuMIbAHcozdGaFX6DbX8kuq+EPK3czOzmS753Ws4bTyuGgbt8+AiZOgEmXan//jldYvGYpvwh8mx2OFO7cPoSXvsrE5l+CBQvxIT2vku2Ii0dfzGVjLuPpXU/z/pHW/3EnxYczPWkI/92Q0ertrC27cipYn1ZCsN3KR3sLjmkW1TbVsqNkJ8UXzKT+4EFqNh1PF3U4FJ82TUDlbNMPSmBPXiXpxdVMzt9P4JQpWHqY8jkrJRKHgq2dpN26TVM9HF7LZvtMUmNCT0zDJmURhMbB1y93v29LlIL3f6EN5pLfQ0g0TP4mXPA3GNbDKuMucL3170uZA/WVrPrqARodjZyZ5IwPuJIjusiSa0focL3//t4aAv2Ab+seeqB6OJX2IPyamwg797yeHbSpATb/R//ey0B2K4oP6Kpte/taieC5WkSu+ssN7baBU2yupqZVxpCLlDA9S/B2nKBbQyAiQSJyp4g84VxOFZGeSzYOZMozYIj7fuGK2kZufHEbDqX4+2VTWj04Kj/6iJInu+7I2ZiVhePoUfzHj9d530t+Bz9YgwQNJbKpkCNjruO/X2Xx5OdHGB5VTWxIbI9K97vjjtl3MD16Onetv6tdBsk185M5XFzN511UHT+27jAh/jbuumgCpdUNbHIGbLcVbqPJ0UTcJZdjDQ+n7IUXj33nP1+k88/0eAQHJbt1sdD7O/NJrcolMDudsPN7+B8dreditQibjrhX4t8pGeuhsYZ3aidpjaETwWLVM8qDHx0zeG6x500t8rb4Ti3f4CWOGQI/K18MG8Hdme8ycejE483ac7bqvtqdzII7Zex5OqZRuA/2vQdr/gR733ErbjB6WAih/rZWAeNPDxSxYlcRpfPPRPz9CT2zhwWCe96E6kIdZM/fCbUn8LLgaNb3JrHjGJYtKgr/1FRqOogTKKWoWqUD6R01R0oK05lc3pakdmdG8B+gHnDl7eUAf/baiE5GyjO1SJcbFFbVcfnjG9idW8HfL5tKYuTxNwTV2EjBn/9C4d8foCGz86le7Q5dQBIwvkXhVNw0uH4tXLeKZVf+lD8tm0iAn4WwkIrWstMewM/qx99P/zth/mHcvu72Vi6ccycNJyrE3qqVYEuySmt4d0cuV85J4sLJcdhtlmNSwpvyN2ETG9MT5xL+jUupWr2axvx80gqPct8H+7CNmEWtsrNl7RtatnhnHleV70T8/Ag7350WGK0J9rcxKS6MjSdqCA5+hMMawKrq1FYFgb1m7Hla+qOlBERXNFTDqt/oh+/M6078/F0Q7h9ObHAs7xx5l5tCLaQ0NPDvWb/G6qpHyd0K0RM6fPPtkrFOQ/7POfDyFfDZ3+CVK+HJM7uVF7FYhKlJQ1i5PZffr9zNF2nF/OaNnYwaFszp999FyptvYB3Sw/vy1b91wPuMXwNKx+F6S9ZGqC6CcZ2/HwfNnUvNlq046o9XzzdkZJD1ve9TcPc9BEyZTODU9llYgbZAYoNj+39GgC4suw9waQ3VoCuOfQNHs9b0d8MQZJXW8M1/f0l6cTVPXTOLcye1VkCs/PBDmgoKQClK//vfjk9XW0vRI//ALz6egDFtAk82OyTNBRG+My+ZXb8/h7LGPJJC3TNSPSEqMIobptzAkYojHCo/ngPtb7Ny+awk1uwr7DAr6KnPj2C1CNeemkKwv42FqVF8uLsApRQb8zcyMWoiQX5BRFxxBTgclL70Mre9up0gu5UHr5xDadQMkiq2cM/7+8gsrGDawU2ELDkTa3jP2zGCrifYnl3OoaKj3e/cGQc/pCByBnX4M2+UB0poEmbpCtS0dkl5HbP/fajMgbP/4naB4IkwNnIsB8sOkhiayBP5RQzZ847eoJRbciodEjMJFt2h42rffQ9+lQNLH4GqfHj2Ivj0vi6/fueFEzh1dBQvbczk209+RXZZLfcsn0xgaAj+KT2sJM7eomcns6/XTXQsfifmHtr3DljtkHp2p7sEz5uLqq+ndruW5S5f8QaHL1pK7ddfE/Pb35L84otYAjt2PaeEp3g9c8gdQ9AgIoGAAhCRUegZgm9QmaulhiO6dw3d8MIWymsa+e/357BwTPvpe9lzz+M3IomwCy6g4vUVNB9t/3AqfPBBGjMyif3LX7qVQahuqqK8vtwrhgBgQbwumvo0u/Wb60VT4lAKVu8tbLW+rLqBVzZlsWxq/LFmKWdPHE5OeS2bMvLZXbyb2cN1ww57QgIhp59O3osvsyejhD9ffArRoQHETj2HcZYsVqzbxuyCffhVVTDkkkt6fQ2XzkggyG7lwoc/54WvMnre/q/kEJSk8YXMICrETmp0z7qZdYjV2TY0bY17KZX739eyBck9LGLrJWePOJvp0dN58txniEhZBJuf1n0XDn+im/D0ph2riC5yXPgLSD4V/ENg+nfgp1t106QN/+pSa2pMTCj//s4Mttx5Fg9dPpWHr5jW+37EGx/TfZanXqHjfvEztPuvNygFe9/WsZ+AsE53C5o1CywWqjd8SfG//kXer39N0MwZjHzvPSKvuhKxdm7gk8OSSa9I92rrSncMwe+BD4BEEXkBWAP80msjOtlwpY52MyOoaWhid24l157aXisfdKP02q+/JvLKq4j87jU4qqupWNG6QX31xo2UPfc8EVdeeSzA1BXZVTp7x1MZQ22JCY5hfOR41mW3nrqPiQkhKTKID/fkt1r/vy3Z1DY28/0Fx9/QloyPwSLw4o61NKtmZg0/7kdNX3A+/lUV3GTN4ILJWifJ4uyrvMBvD98s/hrbsGEEz+99Wuz42DBW/WwhM5Mj+M0bu7j++S00NLXX0ukU51v7i2VjmDNyaLdKoW4zeokuQCrqpldwc6OOJ4w5R6d59gEXjbqIZ897lqGBQ7VoYUC47lvwvNMg9yRQ3B1+ATDnR1Bb6lYwOcTfxrKp8T3vxeDiaCHsWgHTrjzeujX5VF0YWt+LWWPBLh1DHN912NQaGkrAKZMoffo/FD30MOHLlpH473/jF9O92kByeDI1TTUU1hR2u29vcafT2IfAcnT3sJeAmUqprhuHDiaOGYKuZwT78qtQCibEdvxWUPrc81iCgwlffgmBp5xC4NSplP73vyhnKz9HTQ15v/ktfomJRN/mXlVwVpWuAE4M9Y4hAC18tb1oOxX1xwObIsJZE2L4Iq3kWBtFpRT/25LN1MQhjBt+/G8QGWxndkokG3I3YrPYmBqt/aBfHS7hB7uF/Mh4zt36LqrRmeIZOwUCwrkjKYdx6TsIX7b0hKqBAWLCAnj22tn84pyxfLSngNV7C9z/8sEPaRgyki1Vkcz3hFvIhbOFZbfuocwvob4CxvQ8WO4REmbCT7fATdvh/L/BwtthuIfVPUedoTOptr/g2eN2xM7/6cLFlrGWEafqmE1v4gR73wEExnYfwwo59TRUfT1Df/hDYu+9x23hw+SwZACvuofcyRpa42wy/65S6h2lVLGIrPHaiE42yjMA0TUEXbAnVxdITYhrbwgaCwqp/OADApadzz/2P8m/v/43kVd/h8bMTKrWrKH8zTc5svxSGrOyiLv7L+2qCzvDlVucEOLZYHFLFiYsxKEcrM9pPXU+e0IMDc0OPt2v9Zd25lSwv6CKb8xoP5ZzJg6nkn0M9x9LdkkTX2eV8/1nN5MwNIRxd95OU2Ym5S7dGIsVkhfg9+VGaG4m/GLPVItaLMKPFo1iWKg/K7fndv8F0PIN6Z9zOFznScwb6UFDMCRRd43rzhDsfx+s/vph2Z9EpsDsH8Di33h+ZmKxajdN2mrtivUmO1/VAnzDxh5flzhbZ0L1xj20920dtwvp/s1+6A+vJ/m1V4m+5Wc9mlmmhHs/hbSrfgQBIhIJRIlIhIhEOj/JgGeS1gcC5ZkQGgu2rhUN9+RVEhZgI35I+4BP/n//g2pu4icR7/HUrqf45/Z/UjV/EraYGHJuupm8O36FBASQ8K9/al+im2RWZhIdGN1jnfeeMClqEpEBke3iBDNGRBAR5MdHTvfQa5uz8bdZuKiDKfuisSFYA3I4lDmcsx5cx7JH1xMW6Mfz35vN8HPPInDGDIoefRRHja6ebIyYQenXDQSMH4P/6NHtjtdbrBbhwsmxfLy/kEp3isyyN0FTHR83TiQmzJ+UqBMoJOuI0Uv0w6ehuuPtSmlDMHKRrh8YzEy9Usu4nIj8RncUHdDB7slt+nr7h2rdpIwedgMrPQyFu7vMFmqJxd+fwFN6mHYLRAdFE2gL7LcZwQ+BLcA450/X5y3gEa+N6GSjLMOtjKG9eZWMjw1rZ+mbiooofe55No4RJk45k8eWPAbAW+nvMOyWnxE0ezYJ/3yUlDdWEHpGz976sqqyvBYfcGERC6fFn8bnOZ/T5DjepMZmtXDm+Bg+3ldIdX0TK7/O5ZyJwwkPbC8RvbP8CxDF3y68jAcum8LPlqTy0g/mEhseiIgQfdttNBcVU/rcczTm55N5/zs01VuIuaz7OElPWToljoYmB6t25Xe/c/p6lFh4pSCeeZ6MD7gYfSY0N2gRw44o2g9lR46nXg5mho7SLpptL3hendXFzle13PmkS9tvG3GqziRqrG2/rTP2OrOpuokPnCgWsZAcluzVWoKuROceUkqlAD9XSo1USqU4P1OUUr5jCMozu80YanYo9uVVdegWyv+//8PS2Ezldcv468K/Mj9+PvPj5vNG2huELr2IEc8+Q+jixb16yGRVZXk1PuBiUcIiKhsq2VG0o9X6sybEUFnXxF/e20tFbWOHbiGA9468R3xIPBeNncfy6Qn8bMkYkoYen8UETZ9GyOLFlDz5FBlXfYem8iqSzoMga+fdsnrL1MQhJEUGsfJrN1wQ6Z9THzWJjGo/z6SNtiVpvtb06cw9tP89/XPMuZ4/98nItKug9BBkdlyBe0IopXtBpCzSlc5tGXGqNspdNEdqhcOhmwHFnNJ9z2oP4Moc8hbuBIv/ISKTROQyEbna9fHaiE4mmpt0/nY3M4KMkmpqG5sZ3yZQXLdvH5Ur3mDVDGHStOOCWMtTl5Nfnc+XeV0rEnZFTWMNRbVFXksdbcn8uPnYxNbOPbQwdRgBfhZe/CqT2PAATu2gYXhxbTEb8jZwfsr5XRq76Ft+hqOmhubKSpL+8zRBZyyFA6t6Vn3rBiLC0ilxrE8rpqiqiyzoRt0x7VCQDm7PG+mFZuh+AbqvQdpHHb8FH/hA+7PDepkhM9CYsAzsIcfE7jxK1kYd73M1CGpL0tzj+7nDzld1xtCpN3lmfN2QHJ5M7tFc6pp6KVbYDe4Ei38H/MP5OQO4D1jqldGcbFRm62yCbgzBnjxnoLiFIVBKUXDvX2kK9uf1U63Hug2BbgsZ4R/BioMrej20tHItcuVt1xBAiD2EGTEz2qWRBtqtnDZa10tcOj2hQw2eVemrcCgHF4y8oMtz+KemkvjYv0l++WXtR538LS21vfdtz12Ik6VT43AoeG9nXuc75WyG5nrW1o8lfkggiZHu60z1iHEXal/zx39qbQyqCvRDyRfcQi7swVp+Y9frugWsJ9n5qp59debGCRyitYK6S+cF7T5a8yed4TbpG54dZyckhyWjUF4Tn3Mn/P8N4EwgXyl1LTAFcKvMU0TOFZH9IpImInd0sd+lIqJExH2d4b7AzdTRvXmV2CxCaszxYqOjn6ylZsMGPj0rhsT48YT7H/+T+Vn9WDpqKZ9kfkJJbe9kkt85/A52i515se517DpR5sXNI608rVUaKcCyqVpGoiu30NiIsYwa0l6VsS0hCxbgP9JZgxA/AyJHeqW145iYUMYND+3aPZT+OQrh5YJ45o3yQnzAxbTvwPRr4LO/H6+uzdoIT5+ji7A6ai85mJn1ff0C4MlU0uZGXTsw7vzjtQMdMWwsFO3t/nhfPaZfEs/+c5/VdrhUSL3lHnLnKmqVUg6gSUTCgEKg29dQEbECjwLnAROAK0SkXddxEQkFbgY8IAqoS/vRAAAgAElEQVTuYdwsJtuTW8no6BD8bbo6sHrDBvJ+8xv8UpJ5bmwBc2LbBz2Xpy6nSTXx9qGev/HWNdXxzuF3WDJiSSsD400mRk0EYHdJa035CyfHsvm3S0juIKMmqyqLHUU7OH9kz3WCENGzgiPrvJJSeNGUOLZklJFd1onOe/rnNAybRFatnZkdFAh6DIsFLvw/mPJtWHs3vHCZNgKOZvjuuz1qNzooGH6KFoLb9JT2w3uCbc/rgrVTLut6v+jxUHxQ/+07o6YUPntA9wNJWeiZ8blBclgySaFJNKsuxnYCuGMINovIEHS/4i3oJvbuOLdnA2lKqcNKqQbgZaCj15s/AX8FvOP8OhHKMnSWQXc1BM6MIaUUJU8+SeZ138MaGUnpH35InTS1qqZ1MXLISKZFT2NFWs/dQ6szV1PVUMWlqR1kP3iJ8ZH6gdS2kbaIEBbQcTN5l4z1ecm9dG+c8k1A6SIgD7PY2T96S0YHHcwa6yBrIzlDtDtvYpyXja3FAsse0dd7cBVMvhxuWH/CjYYGLLN/oLOlDn184scq2g8f/Fo37+lCCwjQdR1NdVCW3vk+6+6Hhio4648nPrYeEOQXxLvL3+W8FO+4Ct0JFv9YKVWulPo3cBZwjdNF1B3xQFaL5Wza1B+IyHQgUSn1blcHEpHrRWSziGwuKuqggby3KM+EsHitDdMJJUfrKaisZ8LwUHJ/+UsK//Z3Qs8+m5RXX2GDLROrtI4PtOTsEWdzpOIIeUe78FV3wIqDK0gMTWTm8L7zpIX7h5MYmtjOEHSGUop3D7/L9OjpxIbE9u6kQ0fpZjVecA+Njg7BbrUci++0ImcLNNez3TIJaxuXn9ewWOGSx+DGLXDJv7rUrRn0jF+qtZU2dS3X3i2NdbrHuD1I/227c+O4Zl9FnWSrKaUzhSZeovtADyLccnCJyGQRWQpMB0aLyPITPbGIWIAHgNu621cp9bhSaqZSauawYd7TYm9Hefc1BBsyMkAamLZ1NZUr3ybqxz8m/sEHsAQHH1PbDPbruBjINVPYXLDZ7SFlVGawKX8Ty1OXY5G+7Ss0cehEdhe7124wrTyNwxWHOT+lF26hlkz+FhTshAL3DJC7+FktjI4OOVYR3or0zwFhdc0oRg8LIcDP+4qfgDYGUZ4roBuw2Ow6bnLgg+PdAXvDR3fpzJ6L/9VxymhbopwNfgo7iROUZ0JNyaCcqbmTNfQ08DRwKXCR8+NOBUUOrWMJCc51LkKBScBaEUkH5gIrT6qAcXlml4Hi+uZ6fr/1u0wIuZ+gpx8lZNEion56IyJCdWM1u4t3M2d450VRqRGphNnD2JTvZu4y8MbBN7CIhaWj+j5xa8LQCeRW51JW131D+A15Ohd8UeKiEzvppOW6/H/HKyd2nA6YEBfG3ryq9hvSP4Php7ClwNFhbYihD5h5rY4TbX66d98//KlWGZ1zw/FWmd0RENZ15lDOFv0zvuMZ/kDGnVfKuc638WuUUtc6P+50x9gEpIpIiojYgcuBla6NSqkKpVSUUipZKZUMbACWKqXcfz32Jk0NOkjZxYzgq7yvcNRXcsu75ZTbG1n/3ePyvFsLttKkOo4PuLCIhRkxM9yeETQ6Gnnr0FssjF9IdFD32iaeZuJQHTB2xz20OX8ziaGJDA92402sK4KjtM7Onjc9XnE6PjaM4qP1resJmuohexO18fO0y68TEUGDlwlP0EJuW5+Fhi4at2dvhvUPtf+3se5+LWS35Pc9O2/0uM4zh3K36r4D0RN7dswBgDuG4MuOsn26QynVBNwIrAL2Aq8qpXaLyB+dbqaTm4osQHVoCGq//pqyl18m/ZGHuW0FxJfCZ9dN4y8HHuHity7mnq/u4bUDr7VS2+yMWcNnkVWVRX5195IHG3I3UFxbzCWpvdfnPxHGD+04YNwWh3KwuWAzM2M8NLkbf5EO4BW455Zy+7CxOpVwb8s4Qfrn0FTHoVA9djMj6Efm/lj3P9jRSX/nrE3w3DLtAtrz1vH12Vv0rG7ej3XRXk8YNq7zzKGcbTqryea5trAnC+7o+z6HNgb56IY0AiilVLdatEqp94D32qy7q5N9T3djLH2HK3W0jbxEze49pF9+BaIUs4BGi1DwzWu4/ce3k5r2BqvSV/FG2hvUNtUye/hsAm1dFyK5HpabCzZz4ciuPW6fZn9KoC2QU+NP7fVlnQih9lBGhI1ol0LaloNlB6lsqOxyNtQjxl4Ab/9Md4IaPskzx+R4AeCevMrjjYT2vw+2QDY4JgLpZkbQn4yYryurN/wLpn+3dbA3bwe8cKkOKocnwkd3aikOvwBY/3/gHw4zvtvzc7bMHBraovbF0Qx522HKFSd4UScn7hiCp4DvADsBDyX2DgDa1BA4HIoPdudTf8tvibMF8ofll1GQ+Dy3zb6bb0/WE5zlqctZnrqcxuZGdpfsJja4+2yZMRFjCLWHsjm/a0OglGJd9jrmxs7F39q1Eqo3mRA5gW1F27rcx+Xq8tiMIGQYJM3TVcand1qX2GOGBNmJDQ84PiNQSgcoRy1mZ2EDceEBRAQPvre/AYMIzPsJrPgBHFoDqU6ZlsJ98PzFusvYNSv1Q/vZi+DLR2DCxfrfyWm3dF081hktM4daGoLig9BwFOI92JTnJMId11CRUmqlUuqIUirD9fH6yPqZ7PT9NGFh6v/tYv49a5h/78c8+eBLjMveS/0V3+W08xxIQAAXj1/S7rt+Vj+mRk8lJjim2/NYLVZmRHcfJ0grTyOvOo+FCX1XxNIRE6Mmkl+df6wi2qEc5B5tXfC1KX8T8SHxvU8b7YjxF+oMkFLPKjBOiA07bggKdmmX4Njz2JNbadxCJwMTLtYy8F86dS5ztsIz54PFpo3AkCRd2DXuQl3otfp32o8/50e9O5+rT0HbzKHcrfqnJ7uznUS4Ywi2iciLInKFiCx3fbw+sn5kc3op23Z8TZFEccmMEcwfHcXMpHDuzF6DX0IC82/7AWuyVjM/br5HegHMHD6TjMoMCqo775zlEnxz9RHuLyYM1eEiV5zg7q/u5tzXz2VLgc6ocMUHPOYWcuHSfN/3jkcPOz42jENF1dQ1NjtbJQp1KUs4VHTUuIVOBmx2XWB2eC189bh+87cHw7Xvt35jP/tPuvPYvnd0k5vQ7l/COsQ/1Jk51KaWIGerFsSLSu31pZzMuGMIAtGxgbPpWfrogGR7Vjnf/c8mkq0lDI0fze8umsjfvjmFPwdnE5B5mOhbb2Fv5UEKawpZMqL9bKA3uFNP8Fn2Z4yPHO/WLMObtKwwfuPgG7yy/xVEhAc2P4BS6pgekccNQcQI3SLRwyJ042PDaHYoDhYc1bLPCTPZfzQQhzKB4pOGGdeCXxC8/wsdD7huVWsjAFqXat5P9Exh/gkqgkaP68AQbNHxCksf1ZT0Md3GCNysIh4UFFTWcfVTXxEZbGeCpRxrlJ4GOurrKXroIQJOOYXQ885jzdaHsImNRQknmCPvZGzEWEL9QtlcsLlDlc6K+gq2F23n+6d83yPnOxFC7CEkhyXzQfoHZFZmMid2Duckn8Mfv/wjH2V8RFGtrvz2WHygJeMvgk/u1sqcvX3ja3tIZ+bQkSNpnJK7DRbf2UJNtm90nAzdEBQJC27TfQqWP66XO2LxnboXsRuNpLpk2DidPeZo1g/+pgbtNpzzwxM77klMV60qb3f+/IeIPNz203dD7DvWpxVTWdfEP781EevR/GP/oMpff52m/Hyib7sVh3KwOnM1s4bP8pjgm9ViZXrMdDbndzwj+DzncxzK4THDc6JMGDqBtPI0hgYO5b6F97F89HJGDxnNQ1sfYkPuBuJD4okL8YKG/rgLAQX7u1Qk6REjhgYTZLciBz/QK8aez57cSkL9bSREeEl62tBzFv4crvpf50YA9EP7RI0A6IBxS82hgl26ac0gjQ9A164hV7RkM61bVbo+g47duZUE+FkYF1SJq4ZANTRQ8uSTBE6fTtCcOdy/+X4yKjNYnurZMMmC+AWkV6a3axIPsC57HZEBkUyK8lzq5Ikwa/gsAm2BPHj6g0QGRGK1WLllxi1kVmWyNnttp9pKJ0z0eO0C2Ou5OIHVIowdHkpcwVpdRR49XosIxoVh6aC/gsEHGObUEXK5h1yB4kFYUeyiq1aVLmdsjVLq2ZYfoItSv4HLrpwKxseGYat0auUNSaLi7bdpys0j6oYf8eK+F3lh7wtcPeFqzk3xbPvAS1IvISk0ib9u+iuNjuON1ZscTazPXc9p8af1ubZQZ1yaeilrL1t7TJoatCFzyWl4PD7gQkQrSGZ8oafrHmJytB8T67ehxpxLTWMze/MqTaDYl3FlDn16n+5jkLURgoZ6ZrZxkuLOk+VXbq4b0Dgcij25lUyKCz9WQ6BC4il+/HECJk5k84gm7tt0H4sTF3PrjFs9fn671c7ts27nSMURXtr70rH1n2R9QkV9Rb+njbZERNplS4kIt8++nRkxM7yb2ZS8AJpqj+u+eIDLq54lgEYeLZrCnLvXUNPQ3GHbTYOP4B8KFz2sew/871qtcxU3Xb+IDFI6DRaLyHnA+UB8m5hAGNDk7YH1NZmlNVTVNzEpPkwbArFSuX4HjRmZHP3Tz7j9s18yPnI89yy4B6uXMgcWJizk1PhT+dfX/+KCkRfwUcZH3LvxXkYPGd3vaaPuMCZiDM+c+4x3TzJiPiA6mDfCA93ZDn3M+Iz/8kzT2Tx0IILzJkVz1dwRzE7pwhdtGPzMuAamXaV7Iux4pc9aUvYXXWUN5aLjA0tpHROoAm7x5qD6g125ugXjxLhwyMxEhcVR/MQTOFIS+FH9U8QEx/DImY94pG6gM0SE22fdzqVvXcqV711JztEcFiUs4t4F93r1vAOKoEgtM5G+Dhb94sSOVVMKb/4YFTWW0Ysf4MukaKJC+q9q23CSYbHqamZXRfMgplNDoJT6GvhaRF5USjUCiEgEupFM9zrEA4xdOZX4WYUxMaFQnkld7XAa0g7x9LIgooJjeeqcp4gK9L67YGT4SK4cfyXP7nmWayddy83TbvbaDGTAkrxAyxM31YOtlw9upeDtm6G6GPn2K5wW2233VYNh0OJOjOAjEQkTkUh0m8onRORBL4+rz9mdW8HY4aHYbRYoz6S0RGvMZI+L5Mmzn+xT2edbZtzCW8ve4tYZtxoj0BHJp+n0vhOJExxeC3tXwuLfQOwUjw3NYBiIuGMIwpVSlcBy4Dml1BzgTO8Oq29RSrErp0IHipvqoSqPwpxqisPg5+fdfeKa+j3EarEycsjIPj3ngMIVJzjyWe+Pset1LVo25waPDctgGKi4YwhsIhILXAZ4VujlJCGvoo6ymkYmxodDRTagIKOCA/FyTFvHcBIRGKF14dN7aQianZo0487vuV69wTAIcccQ/BHdXOaQUmqTiIwEDnp3WH3LrhxXoFhnDDXWWggoq6dwZESn/YYN/UzKQp3f3VjX8+8e+VQ3PJlwsefHZTAMQLo1BEqp15RSk5VSNziXDyulLvX+0PqOXbmVWATGD9eGoLZYxwdk4ph+HpmhU5JPg+Z6yOlFZ9Pdb4B/GIxa7PlxGQwDEHea148RkTUissu5PFlEfuv9ofUdu3MqGB0dQqDdCuWZVJb602iFiMmDt6R8wJM0D8TS8zhBc6OWqBh7nnELGQxO3HENPYGuJG4EUErtQDeiHzTsynUGigHKM6koD+bwcBgzCJtUDxoCh2hZ6p7GCQ5/CnXlMLF/+j4bDCcj7hiCIKXUxjbrBk1lcWFVHQWV9TpQDKiSDCiEA/HCuMhx/Tw6Q5ekLIDsTdDQA+kr4xYyGNrhjiEoFpFRgAIQkW8AeV4dVR+yN68KcAaKgbpDWViaITspqM/TRg09ZOTpWh4480v39m9q0NlCY8/vfSGawTAIcad5/U+Ax4FxIpIDHAGu9Oqo+pDc8loAEiODoKme2qwKIBxOGYsMYpGpQUHSPLD46eKw0Z2UtpQcgjV/0GnBFTlOt5DJFjIYWuJOh7LDwBIRCQYsSqkq7w+r7yiqqgdgWIg/VByhptiPklAhPmVyP4/M0C32YEico9NBO2PLMzo4nLIQRo/T/QxGD37tGIOhJ7gzIwBAKVXd04OLyLnAQ4AVeFIpdW+b7T9CzziagaPA9UqpPT09z4lQWFVHRJDfMWmJqhJ/DiRqJU3DAGDk6fDJX6C6BIKHtt+e/pk2Fle/2dcjMxgGDF7rdCIiVuBR4DxgAnCFiLQt031RKXWKUmoqcB/wgLfG0xmFlfUMD/Kj7sAByt96F6qtJlA8kBi5CFBajbQtteWQ97UOKhsMhk5xe0bQC2YDaU7XEiLyMrAMOPbG79QwchGMMyDdl9gOHeDeFX/lyJO641WTTbFrpI1RQ0b19VAMvSFuutYMOvxp+5TQjC9AObRbyGAwdEq3hkBEdgAvA68opQ714NjxQFaL5WxgTgfH/wlwK2AHOszpE5HrgesBkpI82y4u6she7I0NxP7lzwQWvcltbMUeNwq71e7R8xi8hNWmq4wPr22/Lf0zsAVAgpdaZxoMgwR3XEMXoesGXhWRTSLycxHx2NNYKfWoUmoU8Eugw4plpdTjSqmZSqmZw4YN89SpUUoRXpxHY0AQ4cuX4x9Qxt4AG2MjxnrsHIY+YOTpUHYEyjJarz/yGSTONqmiBkM3uKM1lKGUuk8pNQP4NjAZnULaHTlAy24fCc51nfEy0Kd5fRW1jcRWFVIXm4CIUFaRQaE4jCEYaIw8Xf9smT1UXQIFO41byGBwA7eCxSIyQkRuRz+sxwG3u/G1TUCqiKSIiB0tS7GyzXFTWyxeQB+rmhZW1ZNwtBCVMAIczRyqKwYgNSK1m28aTiqGjYWQ4TpO4CLjc/0z2RgCg6E73IkRfAX4Aa8B33QFf7tDKdUkIjeiJaytwNNKqd0i8kdgs1JqJXCjiCxB6xiVAdf08jp6RWFBGcNqK6hLSYaqfIqdZjEmKKYvh2E4UUR09tCBD7R7KGKEdgv5BUP89P4encFw0uNO1tDVSqn9vTm4Uuo94L026+5q8fvNvTmup6g8eIihQGjqKKjIosiq20L2RW9ig4dZcJs2BP+9FL73IRxZByPmgdWvv0dmMJz0uOMaKheRp0TkfQARmSAi3/PyuPqE2sM61DF0fCqUZ1FstWATK+H+4f08MkOPGTYWrngFyjPhuaVQvF83uTcYDN3ijiF4Bu3eiXMuHwB+5q0B9SUqMwMHQvjokVCRSbHVSlRglNEYGqiMmAeXPgn5u/SyCRQbDG7hjiGIUkq9CjhA+/7RkhADHnteFqUhkVgCAvSMwB7AsKDo/h6W4USYsBSWPQLjLoTYKf09GoNhQOBOjKBaRIZyXIZ6LlDh1VH1ESGFOZQNjdULFdkU+fkTH9iBXo1hYDHtKv0xGAxu4Y4huBWd9jlKRNYDw4BveHVUfYBSisjSAgqnj9crKrIoCYGpgZ4rWDMYDIaBgDsy1FtFZBEwFhBgv1Kq0esj8zJNBQX4N9XTFJ8IStFYnkVpyFCTMWQwGHyOTg2BiCzvZNMYEUEptcJLY+oTKg+kAWAdkQy1ZZQ66gCTOmowGHyPrmYEFzl/RgPzgY+dy2cAXwAD2hCU7dOGIGjkSCjXGUNgDIHBYPA9OjUESqlrAUTkQ2CCUirPuRyLTikd0FQfOkyz1U7EiHio+Ipiq06gGmZiBAaDwcdwJ3000WUEnBQAntWC7gea0tPJCRlGdLhOHS2ymRmBwWDwTdzJGlojIquAl5zL3wJWe29IfYMlJ5PskFhODQ2AimyK/QIAGGrSRw0Gg4/hTtbQjSJyCeAq03xcKfWGd4flXRx1dfiXFJI3bgoRQX66qjgwjHD/ENOQxmAw+Bxutap0PvgH9MO/JQ0ZmYhSVEbFaTmJ8iyKAwKICjBuIYPB4Ht4rXn9yUxDejoA9XHOvjkVWRTbrEQFGUNgMBh8D580BE2FhQDYhg+HhmqoKaEYhwkUGwwGn8QnDUFzhZZKChsWCRXZKKC4uc6kjhoMBp+kV4ZARH7v4XH0KY3l5VTbAhg2JAjKMqiyCPWqycwIDAaDT9LbGcEWj46ij6kpKaPKHkh0aABkfE6xzR8wNQQGg8E36ZUhUEq97emB9CX1pWVU+QURHeoPB1dTHHcKYAyBwWDwTboSnfsHzh4EHaGUuskrI+oDGssrqLIHMdpaBoW7KZ5zNRQWmBiBwWDwSbqaEWxGu4ACgOnAQednKjCgq65UpTYEccXrASiK0GmkpqrYYDD4Il2Jzj0LICI3AKc5W1QiIv8GPuub4XkHS1UVR6MSCc36BELjKLFZsVvshNnD+ntoBoPB0Oe4EyOIAFo+IUOc6wYkSilsNVU0BAZiPfIpjD6T4toS07TeYDD4LO4YgnuBbSLyjIg8C2wF7nHn4CJyrojsF5E0Ebmjg+23isgeEdkhImtEZETPht9zHNXVWBwOhgXXQX0lpJ5FUW2RqSo2GAw+S7eGQCn1H2AOWmtoBTBPKfVMd98TESvwKHAeMAG4QkQmtNltGzBTKTUZ+B9wX49G3wuay3UxWbJ/IVhsMPJ0imuLjc6QwWDwWbo1BCKyRimVr5R6y/nJF5E1bhx7NpCmlDqslGoAXgaWtdxBKfWJUqrGubgBSOjpBfQUR6U2BCP9MiFxDgSEU1xbzLAgkzFkMBh8k04NgYgEiEgkECUiESIS6fwkA/FuHDseyGqxnN3N974HvN/JWK4Xkc0isrmoqMiNU3eOS14i1pILo8+ksbmR8vpykzFkMBh8lq5kqH8I/AyIQ6eRuiKplcAjnhyEiFwFzAQWdbRdKfU48DjAzJkzO61tcAeXIbDYHTB6CSV1JYApJjMYDL5LV+mjDwEPichPlVL/6MWxc4DEFssJznWtEJElwG+ARUqp+l6cp0fUlZQBYPV3QNQYiisOAaZXscFg8F26cg3NEpHhLiMgIleLyFsi8rDTZdQdm4BUEUkRETtwObCyzTmmAY8BS5VShb2/DPc5WlwKQHNgMPgFkl+dDxhDYDAYfJeugsWPAQ0AIrIQnUb6HFCB003TFc4CtBuBVcBe4FWl1G4R+aOILHXudj+6LuE1EdkuIis7OZzHqC0pw2EVmsJiANhRvAM/ix+jI0Z7+9QGg8FwUtJVjMCqlCp1/v4tdK/i14HXRWS7OwdXSr0HvNdm3V0tfl/Sw/GeMPWlZfjbwRGsDcG2gm1MHDoRf6t/Xw/FYDAYTgq6mhFYRcRlKM4EPm6xza1exycjTeUV2OzNSNhw6prq2FWyi2kx0/p7WAaDwdBvdPVAfwn4VESKgVqc+kIiMhrtHhqQOCorsdub8AuPY3fJbpocTUyPnt7fwzIYDIZ+o6usob84C8digQ+VUq60TQvw074YnDewVJVhszdjj4hjW+E2AKYOm9rPozIYDIb+o0sXj1JqQwfrDnhvON7H72gl1igHltDhbM1fzajwUQwJGNLfwzIYDIZ+w+ea1/vV1mD1VzhCYtheuN3EBwwGg8/jU4bAUVeHtakJq91BGvVUNVaZ+IDBYPB5fMoQNFdUAmC1O9hWrYucp0WbGYHBYPBtfMwQlOufAXa2luwiOjCa+BB39PMMBoNh8OJThqDR2YugMTicbYXbmB4z3XQlMxgMPo9PGYKqIl0oXRgeTl51nnELGQwGAz5mCI4Wacnp/UMCARMfMBgMBvAxQ1DtVB49NMSOTWxGaM5gMBjwMUPQWJQPojgS2MyIsBH4Wfz6e0gGg8HQ7/iUIVAlBVjtDrKoYeSQkf09HIPBYDgp8ClDIBUlWOwOchvKGD3EuIUMBoMBfMwQWKoqaAwAB8rMCAwGg8GJTxkCa001Nc7+M6PDzYzAYDAYwMcMga22jrIgC1axMiJsRH8Px2AwGE4KfMoQWOoaKQyykRSWhJ/VZAwZDAYD+JAhUE1NWBod5AdZTKDYYDAYWuAzhqC5qgqA/CDFyHATKDYYDAYXPmMIagq1vERVIGZGYDAYDC3wGUNQnp0OwNFATOqowWAwtMCrhkBEzhWR/SKSJiJ3dLB9oYhsFZEmEfmGN8dSm30EgJoAITks2ZunMhgMhgGF1wyBiFiBR4HzgAnAFSIyoc1umcB3gRe9NQ4XDQXZAASGRWK32r19OoPBYBgw2Lx47NlAmlLqMICIvAwsA/a4dlBKpTu3Obw4DgAcxXkAREaZ+gGDwWBoiTddQ/FAVovlbOe6HiMi14vIZhHZXFRU1KvBNFhq2ZcAIxIm9er7BoPBMFgZEMFipdTjSqmZSqmZw4YN69Ux0i+9mru+Y2NcrDEEBoPB0BJvGoIcILHFcoJzXb8QGtUMYJrRGAwGQxu8aQg2AakikiIiduByYKUXz9cl2UezsYiF5PDk/hqCwWAwnJR4zRAopZqAG4FVwF7gVaXUbhH5o4gsBRCRWSKSDXwTeExEdntrPN8/5fus+9Y6/K3+3jqFwWAwDEi8mTWEUuo94L026+5q8fsmtMuoTwj3D++rUxkMBsOAYUAEiw0Gg8HgPYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcYwhMBgMBh/HGAKDwWDwcbxqCETkXBHZLyJpInJHB9v9ReQV5/avRCTZm+MxGAwGQ3u8ZghExAo8CpwHTACuEJEJbXb7HlCmlBoNPAj81VvjMRgMBkPHeHNGMBtIU0odVko1AC8Dy9rsswx41vn7/4AzRUS8OCaDwWAwtMHmxWPHA1ktlrOBOZ3to5RqEpEKYChQ3HInEbkeuN65eFRE9vdyTFFtj+0j+OJ1++I1g29ety9eM/T8ukd0tsGbhm1E1mYAAAZYSURBVMBjKKUeBx4/0eOIyGal1EwPDGlA4YvX7YvXDL553b54zeDZ6/amaygHSGyxnOBc1+E+ImIDwoESL47JYDAYDG3wpiHYBKSKSIqI2IHLgZVt9lkJXOP8/RvAx0op5cUxGQwGg6ENXnMNOX3+NwKrACvwtFJqt4j8EdislFoJPAU8LyJpQCnaWHiTE3YvDVB88bp98ZrBN6/bF68ZPHjdYl7ADQaDwbcxlcUGg8Hg4xhDYDAYDD6OzxiC7uQuBioikigin4jIHhHZLSI3O9dHishHInLQ+TPCuV5E5GHn32GHiEzv3yvoPSJiFZFtIvKOcznFKVWS5pQusTvXDxopExEZIiL/E5F9IrJXROYN9nstIrc4/23vEpGXRCRgMN5rEXlaRApFZFeLdT2+tyJyjXP/gyJyTUfnaotPGAI35S4GKk3AbUqpCcBc4CfOa7sDWKOUSgXWOJdB/w1SnZ/rgX/1/ZA9xs3A3hbLfwUedEqWlKElTGBwSZk8BHyglBoHTEFf/6C91yISD9wEzFRKTUInnlzO4LzXzwDntlnXo3srIpHA79DFu7OB37mMR5copQb9B5gHrGqx/CvgV/09Li9d61vAWcB+INa5LhbY7/z9MeCKFvsf228gfdB1KWuAxcA7gKCrLG1t7zk6c22e83ebcz/p72voxTWHA0fajn0w32uOqw9EOu/dO8A5g/VeA8nArt7eW+AK4LEW61vt19nHJ2YEdCx3Ed9PY/EazmnwNOArIEYplefclA/EOH8fLH+L/wNuBxzO5aFAuVKqybnc8rpaSZkALimTgUYKUAT8x+kSe1JEghnE91oplQP8DcgE8tD3bguD/1676Om97dU99xVDMOgRkRDgdeBnSqnKltuUfjUYNHnCInIhUKiU2tLfY+ljbMB04F9KqWlANcddBcCgvNcRaHHKFCAOCKa9+8Qn8Oa99RVD4I7cxYBFRPzQRuAFpdQK5+oCEYl1bo8FCp3rB8Pf4lRgqYiko1VtF6N950OcUiXQ+roGi5RJNpCtlPrKufw/tGEYzPd6CXBEKVWklGoEVqDv/2C/1y56em97dc99xRC4I3cxIBERQVdo71VKPdBiU0v5jmvQsQPX+qudWQdzgYoWU88BgVLqV0qpBKVUMvpefqyUuhL4BC1VAu2vecBLmSil8oEsERnrXHUmsIdBfK/RLqG5IhLk/LfuuuZBfa9b0NN7uwo4W0QinLOps53ruqa/gyN9GIQ5HzgAHAJ+09/j8eB1nYaeLu4Atjs/56P9omuAg8BqINK5v6AzqA4BO9HZGP1+HSdw/acD7zh/HwlsBNKA1wB/5/oA53Kac/vI/h73CVzvVGCz836/CUQM9nsN/AHYB+wCngf8B+O9Bl5Cx0Ea0bO/7/Xm3gLXOa8/DbjWnXMbiQmDwWDwcXzFNWQwGAyGTjCGwGAwGHwcYwgMBoPBxzGGwGAwGHwcYwgMBoPBxzGGwOCziMhR589kEfm2h4/96zbLX3jy+AaDJzGGwGDQQl89MgQtqlo7o5UhUErN7+GYDIY+wxgCgwHuBRaIyHan9r1VRO4XkU1OrfcfAojI6SLymYisRFe3IiJvisgWp17+9c519wKBzuO94Fznmn2I89i7RGSniHyrxbHXyvFeAy84K2kNBq/jteb1BsMA4g7g50qpCwGcD/QKpdQsEfEH1ovIh859pwOTlFJHnMvXKaVKRSQQ2CQiryul7hCRG5VSUzs413J0dfAUIMr5nXXObdOAiUAusB6tqfO55y/XYGiNmREYDO05G63jsh0t6T0U3QAEYGMLIwBwk4h8DWxAi32l0jWnAS8ppZqVUgXAp8CsFsfOVko50FIhyR65GoOhG8yMwGBojwA/VUq1EusSkdPR0s8tl5egG6HUiMhatNZNb6lv8Xsz5v+noY8wMwKDAaqA0BbLq4AbnPLeiMgYZwOYtoSj2yLWiMg4dKtQF42u77fhM+BbzjjEMGAhWhzNYOg3zBuHwaCVPJudLp5n0L0NkoGtzoBtEXBxB9/7APjR/7d3xzQAAjEYRlvTiMEENphIYMECLspwkOCAoe+tJ+BLbvibmWeMU4Hr522OiCMztxoT2a8lxmnFPcZq7FRV1xMS+IX1UYDmfA0BNCcEAM0JAUBzQgDQnBAANCcEAM0JAUBzN6VpQKZdpuexAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hVRd6A37k35aZ3UkinBAgt9CqiojSluvaytrX3rsu6xdX97HUVLGvBgqCggFTpIBIgJISSkEZCes9Nbr/z/XFCIOQmuQmJiJ73efKQnJkzMyfcnN/MrwopJSoqKioqf1w053oBKioqKirnFlUQqKioqPzBUQWBioqKyh8cVRCoqKio/MFRBYGKiorKHxyXc72AjhIcHCxjY2PP9TJUVFRUziv27t1bLqUMcdR23gmC2NhYkpOTz/UyVFRUVM4rhBB5rbV1q2pICDFVCHFUCHFMCPGkg/ZoIcQmIcR+IUSqEGJ6d65HRUVFRaUl3SYIhBBa4B1gGjAAuEYIMeCMbs8CS6SUScDVwLvdtR4VFRUVFcd054lgFHBMSpktpTQDXwGzzugjAd/G7/2Awm5cj4qKioqKA7pTEPQE8k/7uaDx2uk8B1wvhCgAVgP3ORpICHGHECJZCJFcVlbWHWtVUVFR+cNyrt1HrwH+J6WMBKYDnwkhWqxJSrlQSjlCSjkiJMSh0VtFRUVFpZN0pyA4AUSd9nNk47XTuRVYAiCl3AXogOBuXJOKioqKyhl0pyDYA/QRQsQJIdxQjMHfn9HnOHAxgBCiP4ogUHU/KioqKr8i3SYIpJRW4F5gLXAYxTsoXQjxDyHEFY3dHgFuF0IcAL4EbpZqXmwVFcx5eeRefz3WiopzvRSVPwDdGlAmpVyNYgQ+/dqC074/BIzvzjWoqJyP1KxciSF5L/U7d+J3+eXnejkqv3POtbFYRUXFAfU7dgJgOJB6jlei8kdAFQQqKr8xbHV1GA4cAMCQqgoCle5HFQQqKr8xGnbvBpsN3ZDBmA4fxm42n+slqfzOUQWBispvDP2OHQhPTwJvvBFpsWA6fPhcL0nld44qCFRUfmPU79iJ16hReA4fDoAhNe0cr0jl944qCFRUfkOYjx/Hcvw4XhMm4BoWhkuPHqqdQKXbUQWBispviPqdireQ1/hxAHgMGYwh9cC5XJLKHwBVEKio/Iao37ED14gI3Bqr8OkGD8aSdxxrVdW5XZjK7xpVEKh0O9Jup3b1auwGw7leym8aabVSv+tnvMaPR2+y8s6mY2j6JwJgTFPtBCrdhyoIVLqdmu+/58TDj1CzfPm5XspvGkNqGna9Hq/x41mSXMBLa4/ybqEbCKEajFW6FVUQqHQrdrOZ8jffAqBh//5zvJrfNidtAZ4jR7A2vRiAD/eXYIuJU+0EKt2KKghUupXqL7/EUliIa0QEhv0p53o5v2nMWdloAwKocfcmObeSWyfE0dPfg5/dwjCkpqHmY1TpLlRBoNJt2OrqKP/ve3iNG0vAdddhyc8/r7Np1qxaRe26dd1m6zBlZeHeqxcbDpdglzAnqSf/mTeYvZ4R2KursRw/3i3zqqiogkCl26j46CNs1dWEPPwIHklDATCknJ+nAkNaGoWPPMqJ+x8gY/wECh56CNOxY102vpQSU1YWbr17sTa9hJ7+HiRG+DK+dzCxF4wGIGfzzi6bT0XldFRBoNItmLKzqfzfJ/hOn4bHwER0iYng6nreCoLSV19FGxBA1Pvv4XfF5dRv30HhE092mbrGVl6OvaYGouPYnlnOpYmhCCEAuOnai6hx86RoiyoIVLoHVRCodDkN+/eTd821aDw8CHnoIQA07u7oBvQ/Lw3G+h07aNj1M8F33Yn3pEmEP/ccPR59FGN6Og179nTJHKasbAAOuwVhttm5LDGsqS3M35Nj4X3xSD8/hajKbx9VEKh0KXU//cTxm/+Mxt+P2K++xC3qVNlqz6FDMR5MR1os53CFHUPa7ZS9+hquERH4X31103W/WVegDQig8uP/dck8pixFzbSuwZNALzdGxgY2a28YMATfmnJMBQVdMp+KyumogkClyzAePkzBvffhnpBA7Jdf4hYd3azdY+hQpNGI8cjRc7TCjlO3bh3G9HSC778PjZtb03WNTkfANdeg37QJU3ZO0/XqZd9S+dnnSLu9Q/OYs7LQeHuzqsDMlP6haDWiWXvAuDEAFG7afhZPo6LimG4VBEKIqUKIo0KIY0KIJx20vyaESGn8yhBCVHfnelS6F8OBA2C3E/n6a7gEBrZo90hKUvqdJ+ohabdT9vobuPfp7bBcZMB11yLc3Kj85BMAyt97n6JnnqHk+efJv+02LKWlTs9lysrG1DOGOrONywaGtmjvP3YoNW5elG5T7QQqXU+3CQIhhBZ4B5gGDACuEUIMOL2PlPIhKeVQKeVQ4C3g2+5aj0r3Yz6ej3BzwyUszGG7a1gYLmFh543B2JydjTk3l4Abb0RotS3aXYKC8Jt1BTXLl1PywouUvf46vjNnEvb3v9Owbz85s+dQv2uXU3OZsrIo8AvFzUXDuF7BLdr7hfuS3qM32tT9ajyBSpfTnSeCUcAxKWW2lNIMfAXMaqP/NcCX3bgelW7Gkp+Pa2QkQtP6x8ojaeh5IwhO1gs+WRfAEYE334w0maj85BP85swh4j8vEnDVn4hb+g1aHx+K/vZcu/NYq6qwlZeTqglgZGwAOlcHQkerobrvQLyqy7GodgKVLqY7BUFPIP+0nwsar7VACBEDxAE/tdJ+hxAiWQiRXFZW1uULVekazAUFzYzDjvAcOhRLYSGWEufVJucKw4EDaHx8mjKBOsK9Vy8Cb72FoNtvJ/z5fzWdHNx798b3isux5OdjNxrbnMecrXgM7cXf4WngJJ6jlXiCqh3OnTJUVJzlt2IsvhpYKqW0OWqUUi6UUo6QUo4ICQn5lZem4gxSSuVE0I4g8BjaGFjmwE7wW/MmMhw4gMfgwW2ecABCH3uMHo883KKfe1wcSIk5L6/N+01ZWQDk+YQyoXfrgiBh1CCq3L0pVuMJVLqY7hQEJ4DT3wqRjdcccTWqWui8xlZdjV2vxy0qEoAVKSeY+H8/caiwtlk/Xf/+aHx90W/a1Oy6tFjInnk5BQ8+hLQ53A/8qtjr6zFlZuIxZEinx3CLjwdO7fhbw5yVhcXVHVNgMAN7+rXaLyk6kNTgXtj3J6t2ApUupTsFwR6gjxAiTgjhhvKy//7MTkKIfkAAoJ53z2Ms+YoW0CUykrc2ZvLAVynkVxr4dFdus37CzQ2fSy6hbuNG7CZT03X9jh2Y8/KoW7OGkuf/fc5fdIaD6WC34zH0LARBTAwIgakdQWA6lkWhbw/G9A5p4TZ6OgFebhTF9kdXXaHmHVLpUrpNEEgprcC9wFrgMLBESpkuhPiHEOKK07peDXwlz/VfvkqnyCyp4z9rjvDDj0qE7euHGnhlfQZzk3pyxZAIVqYWYTA33+H7Tp+OXa+nfvspn/iaFSvQ+vsTeNONVH3xBZUfffSrPseZGA4oaZ91gwZ1egyNhweuERGYT4szcERD5jGOeYS0qRY6ieuwEco9+/Z1el0qKmfi0p2DSylXA6vPuLbgjJ+f6841qHQPZqud97Zk8fZPx7Da7Vx5JJ1BwOI8Kw9clsiDl/Rhd04l3x8oZE16EXOSIpvu9RozGm1AALWrVuNz8cXYamvRb/wJ/yuvpMcTT2AtK6P0pZdxjYzC97JLz8nzGQ4cwC0mBpeAgLMaxy0+HlNO6ycCm16PLC0hv/8wpjkhCHoNG4BFo6U07Qj+c85qaSoqTfxWjMUq5xG55fVc8fZ2Xl2fwWUDw/jlmUu4r58OERTM1gXTeGhKX4QQjI4LJDrQk2+Sm7s7ChcXfC69lLrNm7EbDNSuXYs0m/GbPQuh0RD+wgu49+lNxUcfnpPnk1IqhuKzUAudxD0+DnNObquRxiftB3VhkcQHe7U73rC4YE54BVN9JOOs16aichJVEKh0CCklj35zgKIaIx/cOIK3rkki2Nsd24kT6KKjCPXVNfUVQjB/eCQ7syooqGpoNo7vtGnIhgb0W7ZQs2IFbnFx6AYOBJQEdT6XTcWYmnZOirZbCwuxlZejOwtD8Unc4uKRBgPW4mKH7caMTABCB/VvyjbaFvEhXpzwDUPkt+2JpPL7ozu156ogUOkQ3+47QXJeFc9M788lA06lQjAX5OMW3dJ1dO6wnggBy/Y2dxjzHDkCbUgwFR99jCF5L36zZjV7EXpPugCkbGZH+LU4aR/wGNwFgiA+DqBZPqLTKdywiWo3LwaPHuCw/UxctRrqwyLxLC/Gbjaf9fpUzg/qTVaS/rmepXu7J5hQFQQqTlNjsPDCj4dJivZn/vBTOn9pNmMtKsY1sqUgiAzwZFyvIJbuy8duP7WjEVotvpdehjFVid71u6J5Lh9dYiLawED0W7d109O0juHAAYS7O7qEvmc9lnsbLqT2hgbkzu1s7zmYcX1a5hdqDW1sHBopMefmnvX6VM4PUgtqqG6wEOTt1n7nTqAKAhWneW19BpX1Zv45ayCa09wczSdOgJS4RkU6vO/K4VHkVxrYnNE8mth3xnQAPEeNwjUiolmb0GjwmjCe+u3bf/W4AsOBVHQDByJcXc96LG1QEBpfXzKTD/LC6sPN2uo2bUJrNnEoYXQzlVp7+PfrA0D14cyzXp/K+UFKvpKPc2ikf7eMrwoCFac4eKKGT3flcv2YmBZBTydz37SWXmLqwDDiQ7x4fGkapbWn0i14DB2K3+zZBN91p8P7vC+YhK2qCuPBg13zEE4gzWaMhw6dVSDZ6QghcIuL40TqERZuy6bGcCp6uvbHH6n28MOrjVxGjug5uB92BMVph9vvrPK7ICW/itggTwK81BOByjlCb7LywFf7CfRy45EpCS3azY3BZK2ll9C5annv+uHUm6zc++V+rDbFg0ZoNES8+AJeY8c6vM9r/DjQaH5V9ZDxaAbSbMZjcOfjB86kLCCMHtXFSAn7jivGb5tej37rNjaHD2ZwTMdcVBNiQij19Eef2XU1k1V+26TkVzM0qntOA6AKApV2kFLyxLJUcsrrefPqJPw8W6pLLPkFCHd3XNrIA9U31Ifn5wzkl5xKXl7nnOujS0AAHoMHo9+6tdPr7yjGdOX0cdKDqSvYZfEmyFiLr81Icm4lAPqNG8FsZkvkEIZ08Lgf7qej0C8McVz1HPojUFRjoKTWpAoClXPHRztyWZVaxGOX9WNcKwFP5vzjuEZFtuv+OHdYJNeOjua9LVnszCp3an6vCyZiPHgQa2Vlh9feGYzp6Wj9/HDt6TBRbodJK6hhl9UHgIm6BpJzlRNBzerVGAJCyAhsqWprDyEEhvAovMsKO1wJTeX8I+V4o30g+uyCG9tCFQQqDpFSsuZgES+sPsyUAaHcOSm+1b6W/ALcHHgMOWLBzAF4uWlZc9CxX/2ZeE/8dd1IDQfTFUOxEz797ZK9mcpvH2FsgKLCmUAJKfnVGCoqqd+xk9Q+I+kT6ouXe8cD/LUxsbhZzYqhXuV3TUp+NW5aDf3DfbptDlUQqDTDaLHx9Z7jXPb6Vu78fB+xwV688qchrb4Ym9JPO4ghcITOVcuwmAD25DoXKKZLHIA2KIi69RucfobOYjcaMWVmdplayPLj00yq/Ib7fZeAkEw+9A4jbSlkvr0QrFa+DxzAkKiOnQZOctJzqDjtSJes9XzEbjIpAYk/rERared6Od3G/vxqBkT44u7SsmBRV6EKApVm/G1FOk8sS0Or0fDKlUNYdf8EfHWtu1HaKiuxNzQ4fSIAGBETyJHiWmqN7dcfEBoN/nPnUrd+PYa0NKfn6Aymo0fBakU3MPHsB6vKw7UsnX9bryX/1v24RYZjqPTiXzs+wPXLT9BOnMQ+91CGdFLv23Oossbi1D+eIDAeOkT+vfeSMWYs+X+5k8LHHiNn/pUYGmNSfk9YbXbSCmq61T4AqiBQOQ27XbL+cAmXD4lg9f0TmDc8st1diKXJY8hxDIEjRsQGKB40ec6dCoL+cgfaoCBKXnix+8Ls7TYMjW6qHl1wIpBHlVyLlZFTiI6Jxy0hEWORjYZKd8JGVmO7JBSE6LCh+CQJfSKpdvP6w3kO2fR68u+9F8PeffjPmU3UooX0fP11bFVV5F51NSUvvXTOU5h3JRklegwWG0nRqiBQ+ZXILNVTWW/mgj7BTuvIjUeUHWl7JSpPZ2iUP1qNYK+TgkDr7U3IA/dj2LePurVrnZ7HKex22PkW/DsC48r30Pr74hIWdtbDNqT+QKa9J8OSlLTR/nPn4jdrFt/c9yrJvQbT7/AbhLnoSQjrnN7Xz9OV4oBwNH+wnEOlL72MtbiEqP++S9iCBXhPnIjv1MuIX7US3xkzqPzwo99VTeemQDL1RKDya7Gr0ZNnTHyQU/3tJhMVCxfhPqB/UzUuZ/BydyExwpc9uc57AvnPm4d7QgKlL73crKBNh0j/Dt4cBj8+AUUHoKESvrwa1j0LEUkYc0rQeZQilt0KhrNIdmeowqPwZzbYh3NpopI6wueii4j4z4skJA3gLdMMBJKrArNw1Xb+T9AQFoVPScHvagfcFvW7dlH99dcE3nRTU8nTk2i9vQm88QagUcX3OyElv4pALzeiAz27dR5VEPyB+HRXLhsPl7Taviu7gsgAD6Kc/NBVffEllsJCQh97rN26vmcyIiaQlPxqzFbn3B+FVkvoU09iOXGCyk8+7dBcAKQthaW3gt0KyR/B+xfAq/0hexNMewn7Vcsw1briMWS4IjB2vt3xOU6SuR4NNk6ETibY271Z04jYAA7KOKqkN5Ndz87moY2Lw8tUj7HMOVfc8xmbvp6iZ57FLTaWkAfud9jHvU8fEALjkd+TIKhmSKRf13ixtYEqCP4gFNUY+Nv36dz+aTLf7W95dLbbJbtzKhnr5GnAVlND+Xvv4TVhQquRwW0xMjYAo8VOemGN0/d4jRmD14QJVH35Zeu7YCnhl0Xw2VzY9gqUHILUJfDt7RA9Bu7aCY8chRmvwIDZcOt6GH0HxqMZYLeju+JuiJsE6d8qY3WCugMrKJX+9E6a1KKtV4g3fp7u7LAPpF/9nk7PAeCf0BuA/P2HOj3G+UL5u+9iKSoi/N/Po9E5zsuk8fDALSbmd3MiOFZaR2apnqFR3Rc/cJJuFQRCiKlCiKNCiGNCiCdb6fMnIcQhIUS6EOKL7lzPH5nvUwqREgb19OPhJQdYdkY62yPFdVQ3WBjbyzlBULFoEfbaWno8+kin1jM8VvlwJzvpRnoSn0suwVpUhDknt2WjsQaW3AirH4Wyo7DxH/DfsYoQiBkP130D7t7gGQgjb4O570OEomI4mc9IlzgQBs6DymwoSun4g1lNuOf+xAZbEpcNimjRLIRgeEwAW+yD0RnLoLTzL/GeSYpRu/aTj7GWlXV6nN86drOZ6mXL8Jl6GZ7DhrXZ1z0hAeN5LgiOldbxwFf7ufS1rehctE3qxe6k2wSBEEILvANMAwYA1wghBpzRpw/wFDBeSpkIPNhd6/mj893+EwyN8uerO8Yyvlcwjy49wPL9p4KRdmVXAM7ZByyFhVR++hl+s2ah69evU+vp4aMjNsizQ3YCaMw/BNTv3Nm8ofSIou45sgqm/AMeTIOHD8PM12DyM3DtEnBrvQKYMf0gLiEhuIb2gP4zQeMKB5d1+LnI2YabrYGswEmE+3k47DInKRJTdONpIeunjs/RSJ+B8Xw+9Ap0B/aSNWMmVV8v+V1GGus3bcZeU4P/3Lnt9tX1S8By/Dj2+vpfYWVdz5HiWqa+vo116SXcPjGebU9Mpn+4b7fP250nglHAMSlltpTSDHwFzDqjz+3AO1LKKgApZSkqXc7holqOFNcxd1hPPNy0fHDTCEbFBvL0d2nkVyqVw3ZlVRAT5EmEv+OX1+nUrFiBtFgIuf++s1rXiNhAkvOqOmTsdIuKwjUqqqUgWP0omOrgz6th/AOg0YBvBIy4BSY9Dm5t2z1ORhQD4BEAvS+Bg98qXkXt8PjWx7ll7S3k1eahP7CcBulO+NDWay3PGBzOm3+ZCSH94NjGdsdvDXcXLd433cxdkx9G9O5D8d/+RtXnizs93pnYpZ239r/F9auvx2A1dNm4HaVmxQpcQkLwGjeu3b7uCUpSRFPm+Zmie316CVa7ZMMjk3hqev8WNqbuojsFQU8g/7SfCxqvnU5foK8QYocQ4mchxFRHAwkh7hBCJAshkst+x0fg7mL5/hO4aAQzByuqCp2rllevGopGCJ78NhWrzc4vORVO2weMhw7jFh3dooZARxkZG0BlvZns8o7t3rzGjaNh926kpTEgregA5G6DcfcrdoAOYtPXY87ORpd4WiDZwHlQewLyd7d5r8VmYUPeBvYU72H+irl8l/8Dq+wjuXRIXPsT97oI8naCpfMv2RvHxlLoG8rS657GLSaG+l/aXq+z6M16HvjpARamLuRA2QG+P/Z9l4zbUayVlei3bsX3issR2vYja3WNguB8NRjvyCqnf7gvPZ3YkHUlbQoCIUS0EMK/8ftYIcR8IUTXpWUEF6APcCFwDbDo5HynI6VcKKUcIaUcEdJGhkuVltjskuUpJ7gwIYTA03KZ9/T34Knp/dhxrIIF36dTa7Q6bR8wHjmCe//+Z722EbGBAOzJ6aB6aOxY7PX1pyKNd70Lrl4w/OZOrcOQkgJSNk89nTANXDzaVQ9lVGVgsVt4fOTjjJBu/F+gL+9EBRMd5ITnVa+LwWZShEEn6envwdTEML7ak49L//6YDp19jYJCfSHXr76ebSe28fTopxkUPIhPD32Kzf7rFggCqF25EqxW/GadqUxwjEtEBBpvb0wZ558gMFps7MurZryTf4ddSauCoNG4uwX4WQhxG7AGRd//tRDiYSfGPgGcHmUU2XjtdAqA76WUFillDpCBIhhUuoifsysoqTUxO6llNs1rR0UzrlcQX+w+DjhnH7Dp9Vjy89H1a1mXoKPEB3sR4uPOjqyKDt3nNWY0CEH9jp1QWwgHl8KwG8Cjc0E3+q1bEG5ueI4ceeqiuzf0vQwOLQdb63ls0soVYXSxzZV3sw/RuzqUal0q1cbq9ieOGQda97OyEwD8eXwstUYrGT4RWAoLsVU7MXcbvJz8MsUNxbw/5X2u6XcNNyXexPG642zO33xW43aG6uXL0Q0YgK6vc2VDhRCKwfg8PBEk51ZhttkZ30qW3+6krRPBDShG3vHAa8BEKeWtKLr/W5wYew/QRwgRJ4RwA64GzjxfLkc5DSCECEZRFbUs7qrSab7ddwIfdxcu6d/S80AIwX/mDcbTTUt8sJdT5RJPuua5d9JIfOb8E/sEsz2zDJvdeTuB1t8f3cCBip3gl0Vgt8Fox1XOnKF+6zY8R49G43HGcXzgPKgvg9zW6yGklacRqAukx8YXyCMcF69bsUkr6/LWtT+xmyfEjD1rQTA8JoBBPf1YrvcGTkV7t0e9pb6FwCo3lLPp+Cbm95nP6PDRAFwcfTE9vXvyv/T/ndU6O4rxaAamQ4fxmz27Q/fpEhIwHT163gXa7cgqx0UjGBkX+KvP3ZYgsEkpDUA1YAAqAKSUTil0pZRW4F5gLXAYWCKlTBdC/EMIcUVjt7VAhRDiELAJeExK2bHtoUqrWG121qYXM3VgGDpXx/rVqEBPPrhpBC/Mda4i18mXTGe9hc5kUt8QqhospJ1wPp4AFDuBITUV286PFC+fQCd08g4wHz+OOTcX74kTWzb2mQKeQbDjjVbvTytPY7DGE5fqXP5muZnnZ84g3i+eVdmrnFtA/IWKC2l95z/2Qgj+PD6WbSgnOqMT6qHi+mLmfT+Pa1Zdg9lmbrr+Q9YPWKWVuX1Oeei4aFy4YcANpJSlkFLaCZfaTiDNZio//hhcXPCdOaND97onJGCvr8dyorCbVtc97MyqYEiUP96dSEt+trQlCPY1+vV/C2wEPhFCXCeE+BBwyvlZSrlaStlXStlLSvl847UFUsrvG7+XUsqHpZQDpJSDpJRfneXzqJxGemEtepOVSQlt21XG9QpmtJOGYtORI2j9/XEJ7Rrf5ol9QhACtmZ0zAnAa9w4sNloyDfA2HudukdaLErg2GmcLIPpPemClje4esAFj0H2Zoe79jpzHTk1OQwsPMyPtlHEjb6cvmG+zIifwb7SfRTqnXgRhTYK4DLndvFSSvYU78Fia565debgCKw+vjT4BWE81PafZ4WhgtvX3U65oZwCfQFfHvmyaexvM79lWI9hxPs3Txkyp/ccfN18+ST9E6fW2Vmk3U7NylVkzZhJzfLl+F85H5fAju2QdQmKGsl09PzJzFpjsJBWcG7sA9C2ILgN+AH4EkVN9F9gLHAU+HP3L00FGvP9d7L4yEkf/ZGxXXfUNB45inu/fh0Oea+3OD5IBnq5MbinH1s6KAg8koYiXAT1tT0hanS7/W21tRy/4w5yZs2i7qdNTdf1W7fgFhODW0yM4xtH3AL+0bD+b2C3Y7HZ2Z5ZzoIVB7nzk48BCDO484LLXTx0ifICmh43HYDVOavbf5CQRluLE4JASslLyS9xy9pbeCvlrWZtbi4a+ob6kB8UhfFw6yeCGlMNf1n/F4rrFRvAuIhxLExdSI2phr0le8mtzWVe33kt7vN09eSqhKvYeHwjRfqi9p+rk5x4+BEKH30UjZcXUYsWEbZgQYfHaEo14SiwzFQHG/5+drmkuoHd2RXYJa1WAcRigHdGK+lPuoFWBYGU0iql/FJK+VXj9zullPdKKf/PWfWQytlTt2YNxy6Z4rTe93T25FYSHejplO7fGaTViikjo8NqoZTSFCZ+NZHPD33usP2CviHsP15FTYPj+gR2u6S4xsjevCpWphZyuKgWjakSzxAD+kJX2tMEmwtOkHvttTQk70UbEkzpyy8jrVbsRiMNu3/B6wIHp4GTuLjDRX+F4lSWfvI6I5/fwPUf7mZ5ci4DGpTd8ZGeC3jlpgub6jlH+kSS1COJlVkr29dT+0WCm7cSCd0Ob6e8zWeHPiPEI4TFhxa3OHEkhPqQ7hWGOScHu6GlS6qUkke2PEJ2TTZvTH6D4aHDeWj4Q9SZ6/jw4Icsy1yGj6sPU2KmOJx/Tp85SKRzAq4TmGo9zvIAACAASURBVHNzqVuzhsCbbiLu22V4T5zQqRw7Gi8vXKOjMDkyGO94E7a/Cod/6IIVdx07syrQuWpaTzeduU7ZLOi6JwtpW15DvkKIF4QQnwkhrj2j7d1uWY1KC/SbN4OU1HzfsQ+ulJLk3CpGxHZdnhJzbi7SZELX33lBYLPbeOGXF7DYLby29zWyqrNa9JnUNwS7VIxljrh78T7GvLCRef/dyb1f7Oemj37BemQ1vtEGLGV1GJKTW51/344U0mfPw1paRvQHHxD+3HOYs7OpXrqUhl9+QZpMeLclCIBfvC8iU8QyOvddZsa7sOySOvYnfkWJazWx7kE8ccN1LU5dM+JmkFWTxdGqdl7wQkBw33ZPBB+kfcDC1IXM6zOPxdMXI4Tgzf1vNuvTN8yHNM8wsNsd5ttZmb2S3UW7eXLUk4zrqQRn9Qvsx8z4mSw+tJj1eeuZHj8dDxfHPuxRPlEMCRnCqhwn7R8dpHrZMtBqCbzllg4nMTwTXd+Elr8DfRnsekf5vnD/WY3f1ezMKmdkbGDr9T8OfguewRDrwJbVBbT12/4YEMAy4GohxDIhxMkwt45H7ah0GCkl9Tt3AVC7enWH0gdkl9dTUW9mVBerhaB1jyG9Wc//Dv6PGtMpw+/yY8s5VHGIx0c+jperF09vfxqLvfnOf2iUPz46F4d2gsNFtaxJL+ZPIyL56OYR/HvOIErrTFQkf4fvwBA03t5UL13qcD0bD5ew7sX30DTUY3ljIV6jR+F90UV4jhhB2VtvU7v6R4ROh+eokQ7vB3hjQyZXL9rNe243ESXK+NexOQzf/hc0GT+S5hPIwJ6OE+5dGnspLsLFOaNxSL82TwTbT2znjX1vMCN+Bn8d81fCvcO5ccCNrMpeRXp5elO/hFAfsvwUN2HDGXaCWnMtLye/zKDgQczvO79Z271Jio3FZDMxr09LtdDpzIifQWZVJhlVGW326yjSYqH6u+V4T5qkpPk4S9xjwzAfz8NemnPq4rZXwGqAwF5wYt9Zz9FVlNYZySjRM65XK2ohkx4y1kLibNB2jyG5LUHQS0r5pJRyuZTyCmAf8JMQ4txYM/6AmI8dw1pWhufYMViLizHs3ev0vSeDtEZ0oSAwHTmMcHXFPc6xh86XR77klb2vcMOPN1BQV0CtuZY39r3BsB7DuL7/9fx17F85VHGID9I+aHafi1bDhN7BbMkoa6FK+WRnLjpXDU9P789F/UK5emQUCQGCgJJdaAbNxPfymdSuWYuttrbZfcv2FnDHZ3sZWZbBwaB4DrsqvwchBD2eeBxbRQU1y5fjNXo0GnfHYfzphTW8tiGDGYMj+PtD98HFC+DCp+GmHyi5P5lyu5FBwY69rQJ0AUyInMD3Wd9jtBrb/sWGJIC+2KHe2mq38vKel4n2ieaf4/6JVqPsGG8ZeAuBukBeTn656XfWN8ybMg9/LF4+mM6wE7y9/22qTdU8O+ZZNKL5n32EdwT3JN3D1Nip9A9qO1Dw0phL0Qotq7O7Vj1Ut3kztvJy/OfPb7+zE+i0eSDB8NIsqD4O1fmQ/CEMvRb6Xw4l6WDtZF2LLubHtGIAJvZpRRBkrFEEWGL7uZY6S1uCwF2IU5+YRq+fRcBWQBUGXUBaQQ2vrs9gw6ESyvUtP5Qn8+mEPfMMwsODmlXOH8n35CoFLXqFtJ5oraMYjxzFrXdvhJtbizYpJcuPLSfOL44KQwXXrb6OZ7c/S425hqdGP4UQgikxU5gRP4OFBxayt6S5UJvUN4SiGiPHSvVN16obzCxPOcGcpJ74eypzajSCx3rl44aF3OAL8Z8/H2kykb/kOxZuzeKJpanM/+9OHvnmAFOCJBHVRRyI6MfhorqmcT0GDcJ3huKS6OXIW6iRb5ILcNNq+OesRLx1rjDxEbjwCYi7gLQapURka4IA4Ib+N1BprOT7rHbSM/RofPmWtdxlf5v5LVk1WTw8/GFctadqR3u7eXP3kLtJLklmUdoirHYrId7uBHi5URYW08yFNL0ina+Pfs1VCVcxIGhAizlAESwvTXqp7XUCQR5BjI0Yy+qc1dhl5xPcfXzwYw6UHWj6uXrpUlx69MD7gq5RfXhq00ED9bn1yI+mYVjxkNIw6UmISAK7BUoOdslcZ4PJauO9LVmMiAkgMaKV5HIHvwWfcIjueLp3Z2lLEPwAXHT6BSnl/4BHALOjG1Scp95k5c7P9/Lmxkxu+zSZEf/awOx3djQLrKrfuQu3mBjce/fGZ/Jk6tasPZVfpx325FYyIiagSwtaGI8cadVQvL90P8frjnPrwFv5bPpneLh4sClfCUzqF3jqnqdGPUVPn57cse4Ofsz5sen6BX0VF9dVaac8UpYk52O02LlxbGyzuS6w76FaerMoLwSPxES0Cf04+uFn/HvVYTYeKUEjBHdO6sU/eypCpSpxOIeKmscp9HjsUXynT8d3qsP0VpisNpannODSxNAmIXQ6aeVpuGhcSAhsPcJ6ZNhIBgUP4uODH2O1tx6d3JrnkN6s552UdxgeOpyLoi9qcdu8vvO4OPripsRwGVUZ9A314ZhfT0wZGUiLhfy6fJ7e9jQB7gFNKqCzZUb8DIrqizodU1BtrObVva/ySvIrWG123l2yA/227fjNnYNw6QLVR3052oo0POJDqTf1w2jQ45Gznuy4q8E/Cno2prL+DdgJliQXUFRj5IFL+jj+WzXWwLH1Su2Ms7SbtEVbXkOPSyk3OLi+RkqppoE4S15ae5TCGgOf3zqab+4cyzWjokjJryarTHl5SbOZ+j178Byn7AJ8Z87EVl3dMuumA0pqjRyvbGBUF0YoWsvKsJWXt5paYvmx5Xi6eDIlZgrxfvEsnr6Y+5Lu44HhDzTr5+fux2fTPmNg8EAe3/o47x94HyklEf4eTE4I4Y2NmSzenYfNLvl0Vx6j4gKbp+G1WXDLXk924ASWpZSQW17PFyFJRFedYPmUIJKfncKSO8fy5LR+mHbuxCUsjODEBA4X1TVTO7mGhdHz1Vda9VHfcKiU6gYLfxrhuBZzalkq/QL64aZtKSROIoTg1oG3UqAvYH3e+lb74Ret5DU6w07wQdoHVBoreWzEYw5fEi4aF1678DVemvQSRfVFXL3yaup9v2SvhwvSYmHHziXc89l8pizL47WcMXhbu0a/fFHURXi4ePDjkRWduj+lTBEg+0v3c9eS1RR8sQRht3eZWogsxT3Ya/wEDJk5XFf5MF/YLubOvIupN1nBL0oJFDxxbgWByWrjv5uOMSzanwmtuY0eWQ02sxLl3o2oFcrOAXvzqvhkVy43jolhQp9gRsYGcscFvQDY11jQ3ZCaimxoaEq96z1hPBo/P2pWtq8eOhk/0FX2AYvdwrYtiuune7+WOuQGSwNrc9dyWexleLoqydaCPIK4Y/Ad+Lq1PO4G6AJYdOkiLo+/nLdT3mZZppLY7b/XD2dyQg+e+e4g9yzeR0GVgZvHxTa/+fguMFYTMmIuRoudmW9tZ0XgQKS7O6HbThW2l1Yr9bt24TVhPAMi/KgxWCiqaUdXfxpLkvOJ8NO1yPsipeTt/W+zt2QvEyIntDvO5OjJxPrG8mHah627kmo0ENLcc+hY1TE+O/QZl8dfTmJwouP7UITN1NiprJi1gnl953HCspO8xDUAlP3zXzz/Th0Xp9jR/W8FWTMUe8rZpl5wN0kWrPPl8ruX8OHaf/P63tdZlLqIBkuDU/fvK92Hi8YFDS5sLf6BKYUppPbogyb87LLZNpG1ETwC0E6+AiElkXoz4de/R0adK2/+lKl4akUMg8JzazBeureAwhojD1zSt/WT+8FlykYhckS3rkUVBL8yJquNJ5alEuHnwWNTT6lMYoM88fd0Zf9xJfdL/c6doNHgNVoJlhJubvheOoW6jRvbLbqRcqQQDxdN6zpHJ6kx1fDegfe4bOllbNygGHhPhLm26Lc+bz0N1gZm9XYuQySAm9aN5yc8Tw+PHuwvVXZmOlct710/nJmDw1mTXky4n45LB5wWwdxQCbvfB607USNmMCo2EIPFxks3j8d/2jRqvv8ec4ESfGdITcVeV4f3hIlNJ4rDRbUt1uGIwmoDWzPLmD88Eq3m1B+oXdp58ZcXeT/1feb2mcudg9vPb6QRGm4ZeAtHq46yo3BH6x1P8xxKKU3hpjU34ePmw/3DHNfnPRN/nT/PjnmW18cuI9c8A4O7hr6FgoA5c+i9fh0xiz9H6+vLiQcfpPhvzzk1piOMR46QO38+vXafwNUGKesW8+mhT3lz/5u8ndKyznOd0YL9jDxSe4r24UUspppEgr1TCKstZX9QLzJK9C3u7zBSKlHg8ZN5MdcFvauOW3VlTE7owZXDI/lwW45ih+o5TBG85nMTEmW22nl3UxZDo/y54EwjsZRQlApbXlJqaifOVoRXN6IKgl+ZdzdlcaxUz/NzBjbLKSKEICnKn/35yomgfucudIMGovU99TL3mzMX2dBA3s1/xlJc3Gxcabej376D/LvvYc7fbuTO8l9w1Xb+v9dgNXD7utt5J+Ud+gb0ZV5JNHk9BN+WrG3Rd/mx5UT7RDOsR9tlBM9ECEGcfxy5NblN19xcNLxxdRKPXtqXf80eiItWA7VF8OOT8FoiHFkJY+4Ed2/eujaJFfeM55IBoYTcfx9Co6Ho6aeRdjv127crgnTsGPo1CoJDhc4Jgm/3FSAlzB/eXC30911/54sjX3DjgBt5buxzTR487TEzfiahnqEsTF3YuoE1JAFqC9iUtYrb1t1GgC6Az6Z/RphXmFNznGRoZASm6gtIf/hVeq9aReS/nsc1LAzP4cOJW7aUgOuuo3rJEgwHDjS7z1pW1m7QYsO+/eT+6Srs9fVE/+9/aLy9edrnT+y7YR9X9r2SLw5/0cyttLTOyMjnNzD2xY0sWHGQDYdKePq7faSVHaSsLILpsXPoUaa8iHN9w5o++w7Z9S6sfqz9X0BJOuhLyPAZxZKUIvT9h+CVthcpJU9M64enm5bnvk9Hhg8FaVdeuOeAxbvzOFFt4MEzbQPV+fD6YHh/Imz6l2LYHnVHt6+n3TeFEMJTCPFXIcSixp/7CCFmdvvKfofkVzbw3y1ZXD4kggsTWvpKJ0UHkFmqp7qsEkNaWouKTJ7Dkoh8+y3MWVnkzJtP/c+7qd+1i5IX/0PW1Gnk33Yb+v0plHgGMvHABqS1DQNlG0gpWbBjAUcqj/Dm5Dd5s/9f0R3OpWx8Qgt3yPy6fJJLkpnVe1anDNOxvrHk1OQ0U1doNYJ7L+rDxf1Dld3R5/NgzyIYMAvu2qWUogRCfXUM7OkHgGtEBKFPPUnDL79QtfgL9Nu24zFkCFo/P7zdXYgO9ORwcfuCwG6XLEkuYEx8YLOaAj8X/cy3md9yy8BbeHTEox16VletK3cNuYv9pfv5+ODHzdoqDBV8dPAjnqlN5eqIUB7c/hR9/Pvw6bRPifJxbJ9oCz8PV8L9dOzThbZw8xUuLoQ89BDa4GBKXvxP0+/cVltL7nXXk3vlnzAcTHc0LADVy5Yi3N2JW/4dXmNGoxs4EGNjTYj7k+7Hx82H539+vmncnccqMFrs9ArxZklyPrd9msyyg7sRGhsLpkzjlcvnMkyvqC+rQ6OaTsMtqMyBDX+DXxa29P+vL4fM00yZWUrFtyVVffDRuTDwiilYCgux5OUR7O3OI5cmsP1YOZ8fb1Sb/goGY8uJE1R98w0FDz1E/p13caK8lpfXHmVin2Am9T0jD1jOVqg5DlNfhEcy4LYNioG7m3Fmy/gxYELJMwRKTYF/dduKfsf8e/VhtELw9HTHnjfDogOQEo7+uBlsNrzGtnQX87nkEmKXfI3W25vjN9/M8T/fQtXixbhFRdHjP//h0fn/4OsRc/CoKqdu06aWkzjBorRFrMldwwPDHmBy9GTq1ijePf2uvI06c10zw+fre1/HRePCFb2uaG24Nonzi6POUkeFsZXsm7nboTQdZr4Oc96DUMfujwB+8+bhNekCSl95BePBg3hNGN/UNiDct5kLaWvkVtRzvLKBK4acqt8gpeT1va8T7hXOPUPv6ZTAm9tnLlNipvDW/reaVGH5tflcv/p6Xtv7Gj/r8/C12/lzyGg+vOxDAnWdt+/0DfXhaLHjZ9V6exFy/30Y9u+nbu06pN1O4RNPYiksRPj6ceLBB7HVtMwEK+129Fu24j1xAi5Bive4x6BBGDMysJtM+Ov8eXDYg+wr3cfK7JWAEi3r5+HK57eOZt9fp/DpLaO4Z5pyipraeyxCCCaYYjC6gm9/G7sL97A0YymZVWeUmdzwHGhcwN1PSQ/RtCgJ39wMi+fBumeb1EIypD/LsyQXJvTA92SN611KYOb1Y2KYMTicv/5UQb17jy63E9hqayl/fyF5N/+ZrGnTOTpsOMcuvoTivy6gfucu9Js38/Gb32CTkudnD2r5WSo6oKQcGfUX8On+ovUncUYQ9JJS/h9gAZBSNqBEHKt0gJ1Z5fx4sJi7L+zValHzwVF+CAHGH1agDQrCc+hQh/3ce/cm9psl9Hj8cSLffZe+u38m+sMPeN+1D+llRq66/2pcIsI7Vb92c/5m3tr/FjPiZ3DLQKXsRM3q1eiGDGZE0nSifaJZmqFE8q7NXcu6vHXcPeTuDqswThLnq+xac2pyHHdI/lDJrzKofY8SIQTh//inEucgZbPU0v3DfcmtqFe8Rtogp7FsZkKYT9O1dXnrSK9I556h97TpJdTe2v4+7u+Ee4Xz2JbH2FW4i+t/vB69Rc/i6YvZOH8DC8tqedAlrMng3lkSwnw4VqbHanOshvKfNw/3vn0pffllyt95F/2mTXyWNJv/jFdUjoVPPd3CoGxMS8NWXo735MlN13SDBoLFgqlRpTSnzxwGBw/mleRXqDPXsTNLKX+q0Qg83Vy4oG8ImbVpxPrGEuShCJPocjgRLDis+T+q/d/g77v+zivJr5yaOG+XUhxo/AMw6nY4vPJUvMXBZUqJ0ohhsPMt+O5OyNtFaY/xlOvNXNK/B26xsbhEhDd522k1gtevGsr0QWFsb4imOusXyvUmjhbXsSe3EqOlc1XYrFVVlL78MscmX0TZa69h1+tx79sXv/nzCH32WeJX/kCfbVuxefngv/MnHp7S13EVu6IDEDaoW11FHeHMbGYhhAcoub2EEL1QTggqTmK12fnHD4eIDPDg9gviW+3nq3NltM5ISNoe/P90pcPArZNofX0JuuXP+Fw0GY2nJ7uyKli0LZvrRkdzUWJPAq65hobduztUxFtKyat7X6W3f2+eG/scQghM2TlKcZDp0xFCMK/vPPaV7iO5OJnnf36exKBE/jyw88lo4/wUQZBbm9uysa5ESQ6WdL2SEtoJXEN7EPHCv/G+5OJmNYj7h/sgJRxpZad8kpOCID5YCcSz2C28tf8tevv3Zmb82WlEfdx8ePnCl6k0VnLH+jtw17rzybRPGBwyWEkdENzHqeRz7dE31Aez1U5epWMvHqHV0uPxx7EUFFD+zjtsikxiafRYftKE4vPgw+h/+onKDz9sdk/d5s2KzWXCKU8pj8GDATCkKYFZGqHhiVFPUGGs4Kv0lRRV6XnI/F8oUIIHpZSklKYwtMepDY7tWA5hg8fwp7h7aDh+C/38hlNY35hMz26HtU+DTwSMuw/G3AUuOqU+hLEW1j4D4UMV9cmkJyH1K7CZ2GIbhFYjuLBvD4QQeI0bR/3Pu5tUpa5axQ5lDBmMf0MeF/1rBZe9vpUr39vF5W9td9qWdDqFjz5GxUcf4z1pEnHffUvc0m+IfON1wp5+msDrr8O9d2/qbIJt4YOYUJzOzcMcbJzsNihOg/AhHZ7/bHFGEDyHUqYySgixGKU2wRPduajfG1/uyedIcR3PTO/faoGYk8wr2I1dCPyvusrp8fUmK48sSSEuyItnZijunf7z5yPc3Khc7Pyp4EDZAXJqcrhhwA3oXJSMpbWrV4MQ+DQGXs3qNQsXjQt3b7wbvUXP8xOex0XTjn96XTG8OxYKWiaHC/UKRafVOT4R7PsU7FYlFXQH8Ln4YqLefrtZsfMBEc55DuWU1+Pn4UpAY33n5ceWk1ebxwPDHnDaONwWiUGJLBi7gDHhY/h02qfE+522MQhJcLouAaCU6dzykqIjP20HnxCqnGYy2hB63hPGkz1gNBn+kdTc9SjvXjccgOOTZuJz2WWUvvEm5vz8pv76TZvxGJaES8CpJIYuoaFoQ4Ixpp0yuA4KHkSgLpBNebvpJ46TkP8NfDYbCpLJqc2h2lRNUo8kAKwVFdgqKohLuoCHRt+GvaEvWmsYxfXFyonk4FJFdXPxAnDzAq9gGHaj8sJf+RDoS2DGq6DRwuSnYMYrED+ZTwsjGRUb2JQN1nvcOOx1dc3Sc7tqNUy/TIkuf2mcnbevTeL1q4ZSY7Aw+50dfLAtu4W3U2tYioqo37mT4Lvuouerr6BrpZ73O5uOsSZsMO5WE8atW1p2qMgCS/1vUxBIKdcBc4GbUWoTjJBSdk75/Afl8115DI3yZ+rAttUndoOBfvs2sSN8IPlab6fHX7g1m8IaIy9dOQRPN+Wl7BIQgO/MmdSs+L5FHp7WWJa5DE8XT6bGKi99KSW1q1fjOWIEro2FaII8grgo6iIMVgN3D72bXv692h947/+UKlz7W6ah1ggNsX6xLQWBzarcFz8ZgpyYox16+nvgq3NpVxDkVtQT23gasNltvJfyHkk9kpgUOems13CS2b1ns+jSRS3VaSH9oDqvfZfGhkpYvwDeTFI8SxbPg0WTleAjKendwxsh2j/9/HP4tfx0/4s8NW8YQxvTHx8qriP06acRWi1lbyk1DyxFRZiOHMHnNLUQKOouj0GDMaSmNbuW1COJzJpURng2era5uMNnc0g5uhyg6URw8rTq3qcP3u4uJIT6UF3nhcFqoLahHDb+U3kpDj5tUzTuPuXfg0th+E0QOfxU28jbyJ/5BQdLTVzc/5Qzhm6w8mI1pjc3hLvGjASNK5fpDjJzcASzk3qy5sELmJQQwr9WHebV9c4l1qv5YSVIid/s1t2nS+uMfLorl96XTMQlNNRxPFBRoyfXb1EQCCE2SikrpJSrpJQrpZTlQoiNv8bifg8U1xg5WlLH1IFh7RoZa1auxKVezw/x41v3oDiD0loji7ZmM2NwOMNjmqecDrjuWqTBQPWSJe2OozfrWZu7lmmxU9FJF6SUmI4exZydje+M6c363jP0Hm4fdDs3J97c/gJtFuWFDnD0R+W4fwaxvrGKC+mBr5QaxGUZkLkWagtg5K3tz+EEQgj6hftyqL0TQVl9k1qoqL6IUkMps3vP7tJUHa1yMpfMng8ct5sbYNur8OZQJa/+gNlw7164/E0lYd1X18Cut/Fw09IrxJvUgtY/QyW1RorrLAyJVozSwd7uhPi4c6ioFtfQHgTecAO1P6zEePSokgod8L7wwhbjeAwaiDknB1vdKaEzrMcwjJQx2D8ftO6K6sYjgH1738ff1bvJLmTKUATBycL0SdH+FJYrJ9Hi5EWK98zFf2uuL/ePUk4F3qFK2xlsOFwCwJTT4k9ce0ag9fPDmH5G5Tadn1IqNH1F04kq0MuNhTcMZ/bQCBZuzSa/FfXaSaSU1KxYgcewYbhFte7d897mbCw2yX2XJOA7bRr6bduwVZ/x/1OUoqi+gltPW9JdtFWPQCeECASChRABQojAxq9YoGdr950xxlQhxFEhxDEhxJMO2m8WQpQJIVIav27r7IP8VtmaqaRWvqBP2+UipZRULf4C94QE8iL6su+44lNdVGNg+f4TlNY6jop9fWMmVrudxy9r+eHxSEzE64KJlL/7XyxFbVeVWpO7BoPVwPxVNRwdPIQjiQPJvfJPoNXic+mlzfrG+8dz/7D721cJARxdDXVFyktLXwxFLd314vziOKE/gWnF3bD6UXhnJHx9g6Ib7jut/TmcZEC4L0eL61o98hstNgprjMQGKYLgeN1xAKJ9ortsDW0SN1F53s3/gZrTqtLZ7YowfWsYbPw7RI2BO7fD3PchuLeyM753L0SOgv2KKnBETAB786pafdbUAsUzaEiUX9O10z2rgm67FY2PD2Wvvkbdpk24RkfjFt/SvqUbpNgJjAdPJXALcVW84kxueUrEdEAs3LySFDcXhhrNiMaXrikzA62/P9pgJaAqKSoAfb1yEi458CnETIBeLXMsMf0VuG8feLb0rNpwuITePbyJCTqVbFEIgS5xgOMSnomzFYFzmveQEIInp/VHqxG8+GPbqjpj+iHMWVn4XdG611xJrZHPd+cxN6knscFe+M6cCRYLtevWNe9YdABCEx2mmrbarTy7/VmSi1uvvXE2tHUi+AuwF+jX+O/JrxVAyxDCMxBCaIF3gGnAAOAaIYQj37+vpZRDG79a2Qqdv2zNKCPEx53+4T5t9jPs3YvpyBECrruWoTEB/JxVwTPfpTHp/zbz4NcpjHlhIzd+9AsrUk40eTYcK9Xz9Z58rhsd0+yDfzphCxYg7XaK//mvNlMLfJf5Hb39e+O+6wC6xESC7ridgGuvIfzvz3W4Zmwz9nyo5HaZ8QoIraK+OIM4vzgkkuNaDcxdBJe/oXgJTf13l+ZfHxDhS4PZRna5Y9VLXoWy+4trzNiaX6voyKN9fyVBADDtRZA2xUgKyolqxd3wwwNKycw//wjXLYGwgc3v07rAoCuh7DCUHWVEbCC1RiuZpY6jdVMLqtFqBAPCTwmC/uG+HCutw2y1o/XzI+j229Bv2UL9jp34TL7Q4anIY6BikD9pMAYoLgtC2t3ItpdCD+VPPk8jyXPRMKK6BA4oNZJNGZm49+nTJBiSov2RVmU9xZY6uPivjiNqNRpwb6k6rTVa2J1dySX9W7pd6gYMUBLxmc/Il5kwXXFNTV/e7HKYn46/TIpnVVpRU8oWR9R8vwLh6orvNMfJCwH+uzkLu11y30VKijZd4gDcYmOpPV09dDKaMRFMSwAAIABJREFUuBW1UGZVJiuyVlDaUNrqPGdDW0nn3pBSxgGPSinjpZRxjV9DpJTtCgJgFHBMSpktpTQDXwHO5yD4HWCzS7YfK2din+B2VQt169cjdDr8Lr+cpCh/ssvrWZKcz/wRkXxz51jumdybrFI9D3yVwsjnN/Ds8jT+9v1BPFy13HdR71bHdYuMJOS++9D/9BN16x0nPsusyiS1PJWrfC/CWlSM35w59HjwQUKfeursEoGVZUDOFhh+s2Loix6rqIfOINY3FoAcDx9InKP0n7tQ+b4LGdGoOtud4zhmIadceWnGnXYi0Gl1hHi0fZrrUgJiYeKjisvkkVXw9f+zd97hUVXpH/+cmUx6D2kkgUAIkFBClSJVBRFFsDfsivoT3bWX3XVdV7fouq7ruqyubdcVsbKgouhSBAGRXhIIqaQQUkjvyeT8/jiTPkkmkEk9n+eZJ7n3nrk5NzeZ9563fN/l6oNz/i/hjo0wdGbb742+HBAQ+9+Ga9170vqH2KGMIkYGeuDi2DygXmOWDVLgvsuX4+DvD2azVbcQgNHbG9PQIc0Cxj8mF+BcE8YBo7nBEKxNWItRGLnEYwT871lkRRFVCQk4DQlQK51/zCLizFaCHBwxSkmWfyQM6Vz/q20ncqmtk1wU1bpY0zk6GllTQ1ViYvMDrr7KPRS3rlnAHWDFnOEEeTrz2y/jrK6sZE0NxV9+hfv8+Ri9lAErq6rliU8Pc9Gfv+eJTw+zencaq3encfXk0IZ0USEEnpddRvmePY0B+YJUqCqizieK/P980EpGZn+OWrHUB9q7GluCxa8JIcYKIa4VQtxS/7Lh3CFAepPtDKy7lK4SQhwWQnwqhLDqZBNCrBBC7BVC7M3N7VyT857kSGYRheU1rasHrVBx5CjO0dEYXFxYPmMoTywazbbH5/O7K8YxNdyXRxaOYvvj81l99zQuigrkk70Z7Eg8w71zh+Pnbr2xSj2+t96CU1QU2c+/0MyXC416Qg4GB+bkq3m6Tu6cVESb7H0HDCbl0wUYvVgVhxWkNhs21OJ6SQmIAGNrLaOuYtggN4I8ndmZ1JYhUCuC8EHqHzatJI0wz7DuiQ80ZeYD4Dsc1tyoOlNd+meY+1jHejMeQcrYxq5lqJ8rg9yd2JvaWrZBSsnhjEJiQr2a7Y+2rFrr4ygGFxcCn3oSl4kTcZ08udV56nEZN75hRWCuk/yYnM94pyASHE0U+w6jtq6WdUnrmB0ym4BLXoayHGrWPUddeTlOp9ZCdSlUl2H4eDkbDQ8TYDZzOqhzfbFBiTm6mIxMCGvd19c5Whkkq+6h6KUqSJ/VXFbb1dGBxxeN4nBGEde+sYulr+9g7ktb+NNGleJbumMH5vz8hiBxQnYJS1/fwcf70gnwcOLro1k8vfYIEsn985s/rHlfczXCwYEz/7Q4QSyB4rwtKWQ//zx5q1Y1G38g5wBBbkEEuwd3+vdiC7YEi38NvGZ5zQdeBM6ujLQ1XwDhUsrxwHfAv6wNklK+KaWcIqWc4u/fjU9n58i2E7kIQdsSsxZkbS2VcXG4jFPL/QAPZ+6zUnhmMAhmRgzilesm8NMvLuKtW6Zwz9yOM2qEgwPBz/2G2ry8hj+8U6WneP7H51nw6QK+Pfkty6OWI44cx+DujpMleGcTJdmqmKeuRSFOdTkcXK2eUt0tT2ijLP7+Fu4h15LTBNXWkuredf2VrSGEYGaEHz8mnbH6hJeaV8Ygdyc8nJUxSi9O7774QFNMznDZK+AeBNe827mA+ZhlkHsMkXeCKUN9rK4I0vMrKCyvYXxo8w/McD83nBwMzTKrPBcvJvzD1e3WtLiMG0vt6dPUZOcQd6qYoooaLnJxQwrBQaOZ7RnbyavI48rIK1WWz4SbqNqi3ENOQe5w53dw/x5YtgqzkzfGGjcyOurqZoWjmUVED/ZU+lQtMA0ZgsHNzbohGH2Zclu2cA8BLJsQwv3OWficTsXT2YEgT2f+tiWRf+9MoWD1aoze3rjPmsW6g5lc/rcdFJZX8587p7H67ukceGYhXz4wi8/um0mYb/PiMVNgIF5XXUnR2rVKNyzrELVVJvI/24gwmcj/9/vUnFL1FFJKDmQfsNtqAGyrI7gauBA4LaW8HYgBvNp/C6CkKJo+4Yda9jVgyUaqL057C2j7saMPsu1ELmMHe3X4xF6VmIisrMR5bNvdrlri5WLiouhAm4XlXMaNw3XaeZRu3w7A/Zvu5/OEz1kUvojPLv+MR6Y8QsW+fbhMnNgs/75DvnpYlfcfb5EOd+RjqCqCqU3i/77DwT9KBZCbkriJYTU1pHB22kidYUaEH2fKqjmR0zq1MiWvjGGW1UCdrCO9JP2s9H66hOHz4JHjnXePRTVxD4X7kJ5fQXaLRINDlmyi8S1WBA5GA6ODPGxWaa3H9bzzAMj/17/YnqhW7IscqnCQkv2laXye8Dn+Lv7MDrVUel/4a6pK1EOO08/Wge8wFeOYcCPx12whpXo06cWnOjWHujpJ7KlixrahuCsMBpyjolpnDoHFPTRXueNauIdkcRGXffoqj37xMm9McmT13dO5cHQAqX94ibJt2/G+8y6e/foEP1tzkHEhXnz14OwG6XKjQTA2xKuVwa3H7667kXV1nHnnHcg6RF5KGLK6mrA3/gFA7quvAnCq7BQ5FTmdFnXsDLZ8ilRIKeuAWiGEJ5BD8w/4ttgDRAohhgkhHIHrgWY9+4QQTdc5lwPNG632YYoraziQXsicke2vBgAqLMJd9SsCe+E6dSpVx4+TnnmMxMJEHp78MM+d/xwjfUZiLiykKiGxc26hxP8pNVBhUIJg9Uip5KKDxrVurzfqEji5U+XC15O0mXCDC6nlWeesld8RMy3/pDsTW7uHUs6UNWQM5ZTnUF1X3XOGAM5OetgzuME9VN+PoqV76HBGIY4OhmYyGvVEWVJsO3MfnKOi8L7uOvLffZfUrbsYHeSBb2ES0TiyKW0T2zK3sXTE0sYsM49AqgIvwyEoCGNQeLNzxYR6I8zeFFTldqoVZnJeGeXV5gYRQqvzHDOGyvh462KM0cuUyzKruSpryaZNUFuLcHUl/e4VVMce5bd1sVxzYgvfjpjJPdWj+Neuk9w1axgf3D2NQE9nm+fsGBqC1+WXU/jxJ1QcPkzhkSq8r7wCt5kz8b3lZorWf0FlXBz7s+0bHwDbDMFeIYQ3ql/xPlQT+10dvUlKWQusBDaiPuA/llLGCiGeE0LUu5YeFELECiEOAQ+iitb6BTsT8zDXSeaObB24aknl4SMYPD0xDR1q1zm5TZ0KUnJ00ycAnB/SKMpWvl+ldbbnC25GbTV8/QT4RsC8p5TmS7blaSt1uyogO++e1h9moy9VWTGWzBFqqyF1O8N8R1FWU0ZuhX1jQCHeLoT7ubaKE5RW1ZJbUtWQMZRWbEkd7c6Moa7C4h4aY8rC2WRo5R46lFFEdLCn1dVkVLAnheU1nG4jXbktAh57DIfgwVz8xZvMDXODnDgmuQSTWpxKnazjihHNVzZVSak4jWrtgnRxNBLkFkQdteRXtp2t05KjmSodtn1DEI2srKQ6xUoV++jLVM3Drteb7S7+ZiOm0FCGffIxRm9v0m67naKXXsQ4Zx7/nnot8dmlvHbDRH55WfRZyb77rbgbWV1N2jdGMBgYdP/9lv0rMHp6kvOnlzmQcwB3kzsjvNtOCjlXbAkW/5+UslBK+Q9gAXCrxUXUIVLKDVLKkVLKCCnlC5Z9z0gp11u+f0pKOcaSiTRfStmJ+vrezfcn8nB3cmDiEOvLwqZUHD2Ky9ixDUHJanM1+7P3U2XuWkkn5/HjEU5OFO3eyWC3wQ3ZOgAV+/eByYTzOBvdU7tXwZlEuOSPyv3j4Ny4Ktj9Brj4WheKGzwJIi5UlbFJmyHjJ6guZZil21eb4nNdyIyIQexOPtNMlC3VklI6rKdqCLoSi3vIdGwtE8K8m60IzHWSo5lFrQLF9dgqxdESo7sbufc/zuCyPBZ9/z5UFjLJT/0tTQ2a2sygSrOZ6pQUnCKsf7BF+6uxJ4syrR63xtHMIpwcDEQGtF2R327A2M0PZq5ULs203QCqNeyuXXhesghTcDBD3nsPo48PrlOmMOKvr7Duwdl89/BclsScfWc1p2HD8JwxhroaAz6XL8AUpKrNjZ6eDPq/+yjbuZP83TuICYjpEomTtrDJhAkhxlue4icBI4QQV9ptRv2E3clnmD7ct8OnhLrKSqpOnGj2AfzpiU+59ZtbmbNmDo9ve5wtaVtsXqpXm6t5YNMD7M7a3eqYwckJ55jxeMWlMzNkZrNsmPJ9+3EZMwaDsw1L2+Is+P5FVfwUuUD5WMddDYc/UrnQ8RtUCqg1oTiDAa55T1VPfnQL/LgKhJHwkUr3pWmTGnsxM8KPkqpaYpuIi9WLzTXUEJSkYzKYCHTtPingLsMzGEZcBHvfYVqYG3FZxQ2qq0m5pZRXm9v0W4+2uIvORnhti3Mo60fMxvnbjZTnOjI5/AJC3EO4NfrWZuNqsk4ja2pwDLe+Ap4SqgrXfkq3/aHgSGYRo4OtB4rrcRw2DOHsbN0QAMx6WBUxfv041Jkb3EIeF6saAcfQECI2fMWQf72HwdmZUB9XQrxtE0NsEynxH5WF5wgDfo/8stkhr2XLAHCLz2Civ/3cQmBb1tA7wDvAVcASy0s3pmmHovIakvPKmDik4yyYymPHwGxuFh+IPROLt5M3lwy7hB9P/ciDWx7kqR+eatYQpi02pm5ka8ZW3jpivTavODqUIafrmOXVGAuoq6yk4uhRXKfY6BY6+IFK+Vv0u8Z9562AmnL48HpAtJ/p4uypiqKc3FWMIXQqgT4jcDO5NTQ2tyfThysJ5KbuoXpDMNS30RCEeoTa9SnMrpz/IJTlsrhuK+Y6ycF0FSA+ZPnatKK4KR7OJtXEx4beDS3ZnpDH0UtuwujlSu4RDzwHT+Gbq75hblhznaaatJMAOA6xbgjmRajCq4OnbDMEdXWSuFPFjAtpvzWrMBpxHj3aesAY1N/jgudUGumB/yi3UFgYzmMa62CFoyOiKyWiT+7AsfwwIc8+goOvX7NDRi8vzH5ehOZJJgXaL1AMtq0IpltSN2+VUt5ueXVODnKAcThT/bNZy2duSX2Hp/pSfYD4/HjGDhrLszOfZfO1m1k5YSVfJX/Frd/cyumy022dCiklHxxTEgO7s3aTVdpaVuJQiBmDhHGnGit2K48cgZoaXCbZaAiyj6rCJ98mkgPBMUr6oDgToi4Dr9D2z+EVCjd+3NBrQAjBshHL+CblG9JL0tt/b/215B5iQ3LrSuWO8PdwYlSgBzuT8hr2peaVEezl3FBglVac1jfdQvWEz4bgCYxIeg+DqOP9XSdZeyCDb+OycXdyYPigtl0oUcEeHM4sbLOfgTVyS6o4frqE6dEhDJo9mPIcJ8qOJFodW52m3G5trQjCfQJAmkgqyLDpZ5/ML6ekqpaxg9tPZiysLOS4fzX5R/ZxPK+NvJRxV0PYdMwbfkPZrp14LrrYvnUkO14FN3+IucH6nIPcCcuDsYPsm0hiiyHY1YY0hKYN6p+62gtc1VNx5CgOAQGYAlVQucZcQ1JREqN8lHaQg8GBe2Lu4a/z/8rJ4pNc/+X1bbpPDucdJvZMLLePuR2JZH3S+lZjNrqnUGsUyP2NkgDl+5RevMtE641wWpEdBwFjWu+fcT8gYPr/2Xae4PHwaEJDiukdY+/AIAxtrmZa8ofdf+AXP/yCU6WdSzUElUa6JzWf6lr1YZdypoxhFrE5KaUqJuvJjKFzRQg4/0GM+UncH5TAN7GneeijQ3wXl83EId4YDG1/uC2MDiI9v4IV7++jvLoxw2ZPaj6vfHeCiurWzVt2JCqjOifSH+9hhTi4O5D32mtWXZrVJ9MQTk44BFhPpBBC4Gb0I7ssG7MNUtAdBYprzDX87cDfuPizi9lgise5SrJt10fWTyYELH6RkoQKqDXjMa8xoQJzjXJlJnaR5mZ2LCR8C9PuabPfRopvLWFnBM6G9lPQzxVbDMG/UcYg3lIBfEQI0TMdn/sIB9OLGO7vhpdLx1WylUeONIsPJBclU1tXy2jf5pWV84fM54PFH2CWZh7a+hDlNa1VET849gEeJg/ujbmXqUFTWZe0rtk/YkFlAYeLj1MaGUz5nj2AcgsVb/wWp8gRzbTm26SmUgWJrbWMjL4cHonvnDSAg2NDZlGAawDXjLqG9Ynrm60KkouSW33Yp5ekc/TMUWplLf+KtVqH2C6zIwdRWVPHPe/vJSm3lJS8RvnpM5VnqKit6NuGACBqKXgP4WG3r9n/qwVsfmQua/9vJn+9vn1/81WTQ3nhirFsjc/hxn/u5mB6Iff9Zx/X/GMXr25K4I739rTq9LYtIRcfVxNjgtwwFJzA7+IxlO/dS/nu1rGq6pMncRwS1q6LJcA1ELOhgOMd9JlOKUrhv4mf4WgUjAy0rue16tAq3jj8BrNCZvHAbX+nzgBD/rYec6l1HSaCYyiunITJ3YzzzgdUz+ScY/DWhfDNk/DxrarJ/Lmy469gcoMp1t2o1eZqDrvn41hdR20HopHnii2G4G3gZmARjfGBJfacVF9GSuWPndBGMK4p5uJiqlNTm8UHjuerxKmRvq1T6yK8I/jjnD+SVJjEb3b9ptmHfE55Dt+lfseyyGW4mlxZGrGU9JL0Bo0SgF2ndiGReEybTmVcHObiYk499jhVx48zaOUDtl1gXrxK/wxoY5F4jn1Wm64KpJS8H/c+V627inv/d2+zvPKNqRsBmBE8g88TPu9UqiHABaMDeHrxaPakFnDxK9soLK9pzBjqy6mjTTE6wIwHEBk/4Zu9k+GD3Jg4xKeh6U573DRtKKuWT+ZYVjHLXt/B1vhcHl4wkhevGs9Pqfnc+s5PlFTWAOpv/oeEPGaOGIShIBlqK/G+fBEOgYHkvva3VquC6rSTmNqID9QT4R2KMBValciop8Zcw0NbHuKn0jcJCz2Jo0Prj7PEgkTejX2XJcOX8PK8l4kcP4fEh5cRkl5B0q03t+rPLKUk9+9/p+xwMp5LliDKcuDNefDGHKUIu/hPIOuUCOC51LzkpzT2VLCiogqwN3svKX7qb76VRlIXY4shyJVSrpdSpkgpT9a/7DqrPkxWUSV5pVXE2BIfsEj3Nl0RxBfE42x0ZqiH9X+UmYNnsnLiSjakbGBN/JqG/Z+c+ASzNHPDKOVrXDB0Aa4OrqxLXNcwZsepHXg5eTF0zmIwm0m/ewUl331H4FNP4nnxwlY/yyr1tQKB9vFZ1q8K1iWuY+Xmlby458WGxjXbMrY1jPsm5Rti/GN4ctqTVJmr+E9c66Y37SGEYMWcCLY8Oo9rpoRiNAgmWYTa+nTqaEsm3gSufvDvpfDHofDPC+HIpza99eIxQXy4Yjr3zo1g62PzePDCSK6dGsZrN0zkYHohV/59J3f9aw9XrdpJTkkVs0cMUjUkgGHEbPzuWUHFvn2U7/6p4Zyyro6atHQch7T/ux3uE4LBoYSvj2Y2c0XVmut4+4cUnll3lH8efoekoiQwu1LmtpYac02zc9TJOp778TncTe48OvXRhv1jr76LP19hoCY+gbTb76Bs507qysqoq6ri1ONPkPfX1/BaupRBT/0e7t6sVF9HXwr371Z9kxf8BpI2qaSJeoqzVCe+jpBS9d14c56qW2jHjfp1ytcUBKlK96rEpI7PfQ7YovF7QAixGqUL1JDYLqX83G6z6sM0ZmXYUD9gEepyGdv4oRqfH0+kT2S72Sp3jbuLw7mHefGnF/lv4n/xdPQk9kwsc0LnEOap3BmuJlcWhi9kY+pGbom+hQ+Pf8iGlA0sGLoAt0mTwGSi4tAhfO+4A99bbNEQtJATq/6AmwaKu5g7xt7BJ/GfsCNzB49MfoSbom/i0s8v5b3Y95gXNo/komTiC+J58rwnGe41nAuHXMia+DXcMfYO3B1t7+wGKnD8+yvH8/wy1ecW1IrAKIx2E/jqVhzdlJZPwreQlwDJW+GrR1QBlanjVOFJQ3yY1CL7bfG4YExGAy9+c5zMwkq8XBy4PGaw6sD3xVYlO+47HO+rQsn5/R8o3b4Nt+nTAKjNzkZWV+PYQfFkkHsQCMnutFQWvFLFc0vH4O/uzJOfHyb2VDHCdAb3gjeY4DebnYciIOw91sSv4ebomxvO8XnC5xzIOcBvz/8tvs6NT93DvYaTNSmMrwN9uOzdeNLuuBOMRoy+Pphz8/B/6CH8VtytgsR+EXDv9uaTm3Kn0iX65mlwdIcjnyhVXfdAWLnHqkQ2AKW5sO5+1XQpbBosfV012rFCtbmaTSc3MX/0AoyDtlGV1POGwAVlAJo+MkpAGwIrHMwoxGQUHfYfAFXYYgoLa5CwlVISXxDPgqEL2n2fQRh4YdYLvHbgNTJLMympLmGw22DuHn93s3HLRizjv4n/5Yr1V2AymFg2Yhn3T7gfg4sLXpdeijA5EPDoI527wOxY1Vu3C/sEtCTANYDXL3odd5N7Q7bEzdE38+KeFzmSe4QfMn9AIBp+T3eNu4v/pf2Pd46+w4SACSQUJOBgcOCW6FtszvgwNgmeppekM9h9MCaD/ZRQuxW/CPC7T32f/D38+3I4th7GX3vWp1wQHdisCxighAdTtqmsMSEwODnhFB1F5aHGkGL1SUvG0ND2VwRBrqqw6rdXhfDeFsEd7+1FCPB3d+L1Gyfy75RfEZdvYOdPszDXeDLO9zxWHVrFZcMvw8fZh7gzcfx535+ZGjSVpRHN1e+FEMwKmcXHletZufV/1B6Oo3z/PqqOx+N1xTI8F3awOjYYYOlr8PeZ8Mmtqnhy4k2qx/YPr6g+Ci0x18LHt6gGOBf/XgWI23nY2565nZKaEhYPW4zTiFN2dw11+N9saxWxRnE4XZXvOzl0nH9eefxYs0bX2eXZFFUVNWQMtYeXkxe/nP7LdsdMCpjEkuFL8HLy4rYxtxHo1viPO/gPv+/wZ1glOw4i5nc87hyZHtw84Hxl5JWsOriK92LfI6EwgSlBUwhwVVknYwaNYXrwdP555J/N3jN20FgmB3ZexzCtpI+njrZH+GzwGaY6np2DIbBK1kGoLFR9pi24jI+h8NNPkbW1CAcHqhtqCNr//Qa7qdWYn3cFGx68mHd3pHCmrJqVF4zgx9NbiCv8iRVjH+KrolAyCyv45YwnuHHDtTz9w9OU15SzP2c/HiYPfjX9V1YfBuaEzuGj+I/YX3acmbNn4T57Vueu1Xc43LgGSnNUJbfJWSVS7HwNJt2s0qub8v0fIG2narxkw+99Q/IGfJ19mRY8jbyILRStXYuU0m6prG0aAiHE41LKF4UQr6FWAM2QUj5olxn1Ycx1kiOZRVw5qeNOnubSUmpOpuFtqR4E5RYCGOXbNT1LhRD8bvbvOh5oK+X5qt1kW4FiO+JmcuOaUdfwztF3AFgetbzZ8WdnPsuuU7sY7jWcUI9Qrlx/Je/Hvd9pQyClJL04nfHDx3c8uC9iMKj+EJt+o1xFgyK77tzJW9XXYY0FZC7jx1Pw/vtUJSTgHBVFTVoawmTCwSKl0BZBbup4VlkWjg6GZnLrq4+vJtwznPsm38KKiYKi8hoCPJ25dtS1fHj8Q8I8wnhsymMsHbEULyfrKaVTg6biZHRie8Z2Zg5up9lPewyf13z7omdVgeS3v4Lr3m/cn7QFtv0JJi63yQiU1ZTxfcb3XDHiChwMDjhFjqCuvJzarCxMg89ezqI92gsW11dc7KV5q8r6l6YFybmllFbVEmNDxlBVvPrQd2qyImjIGPLpRD+AzlBToQJaLYJqNpMdq74GWqkh6AZuHH0jDgYHjMLYyn0W4h7C1SOvZlLgJAJcA7h25LVsTtvc0G7SVvIq8iipKen7qaPtMeEm1Z5xf+fTbtsleSsEjgP3xp4hLhNU68UKi3uo+uRJTGFhHUqduzu6425yb1VAmV2Wzf7s/Vw6/FL1IelgJMCi+PnYlMf4YPEHfHnFl9wy5pY2jQCAi4MLU4Om8kPmD2dzpdbxClEyFcfWqw//4iylW/T5CuVOveRFm06zOW0zVeYqFg9fDIBThDKC9owTtNeq8gvLt+VSyn81fQGtk9g1DWX8NmUMHVMf+k1dQ/EF8YR5hOFmst5/+JwoOQ1/nQQvj4LfDoI/DIFtL3XuHDn1GUM9YwgC3QK5fcztXDPyGnyc2695uGH0DRgNRv5zrHPZRF8mfwlw9k+JfQGPQCUHfnA11HaRsGF1OaT9qHT9m2AKDcXo40PFISXvXH0yrUO3UD1BbkGtDMG3J79FIlkU3rpHsMloYrz/eAzCNgmI2SGzSS1ObUgX7hJmrlRZRu8vgz+PhncWQlUJXP2uCtzbwNcpXxPsFkyMvzKijiOUOJ89M4ds+Y09ZeO+Ac+hjEI8nBwYPqjjG155/BhGH59m1ZXx+fGtCsm6BHMtfHqn8t8ufEHJRnsPVVWS5k40g8k+qgJj7j0nxPbgpAf5xfRfdDjO39WfxcMWszZxLUVVRR2OBzDXmfko/iOmBE5hhI/9JH97BZNug/IzrRsKnS1pu8Bc3Sp+JITAJSaGisOHkVJSnZbWYcZQPSO8R7Avex/F1Y1FZd+kfEOUbxThXuHnPOU5oXMA9QTeZZhclKji3Cfg0pfh+tUqk8haAaYV8ivz2XVqF5cMu6TBoDn4+GD086MqMaHr5tmCNg2BEOISS3wgRAjx1yav96AbWkn1QQ6mFzIu1Kvd8v16qo4dxzlqdEPwp7ymnPSSdPu4hbb+Dk7+oNofzlwJ856EOY+pD4LU7R2/v57sOLUa6O4evmfJzdE3U1FbwWcJn9k0fsepHWSWZnLd6OvsPLNeQMR8leb546rWbUbPhuStYHRs3YgIcIkZT3VSEtVJScjKSkwdZAzVc8fYOyiuLm6oHM8oyeBw3mEuDr/43OcLhHqEMn7QeL5K6SJjWE/IZJj/tJKe1ywNAAAgAElEQVROGX1pmymi1njryFuYpZnLI5p3A3aKiKC6h1YEp1DxgUqaxwbWA11zJ/oRZ0qriD1VzHnDrFcJNkXW1FB14gROoxvdQicKTiCRXb8iSPgOtr+sAoQx1zfuj1ygytvj1rX93qbU1aky+x5yC50No31HMy1oGh/EfcCR3CMdjv8o/iMGuQziwrALu2F2PYzBqB4IMn6C7X8+9/Mlb1G58VbcH87jVeC96Cv1gduW6mhLovyiuDj8Yt6Pe5+8iryGavKuMgQAi4cv5nj+cRIL7JueaQspRSl8eOxDroy8kgjv5r3InUaMoCopyW4d/NqLERyyxANGNIkNrAcSpZRt130PULYl5CKlki7oiKrkFGRNTbP4wNE8VVxmS+qozcStg0/vUFXALQNVJhcYeTEc+8I291DhSagp65GMoXNh5cSVVJgruHHDjdz+ze3szNxpdVxGSQbbM7Zz9cirMRn7Sf1AR0y4CcZdY1kxWv+92ERZHpw+0jqLxoLL+PEgBMVfqPhLRzUETVk5YSXV5mrePvI2G1M3Mn7QeEI9OlC27QSLwhdhFMauXxWcBS/teQlnB2cemNha7sVxRAR1paXUZmfb5WfbEiP4TgjhKYTwRbWp/KcQ4hVbTi6EWGQRq0sUQjzZzrirhBBSCDHFxnn3OjYfz2WQu1OHUrgAVcdVQpZzlHr6zyzNZNWhVUT7RTekzZ0TNZXw5cOqgMVvBNywxrq64ZhlUJ4HJ3c07ivJhvzk1mN7OGPobJkQMIHvrv6Ox6Y8RnpJOvf87x72nN7TatwnJz7BIAxcFXlVD8yyhxBCuQt9wlUMqax1H2ebSPtRfR02x+pho4cHjsOHU5ORAQ4OmIJtr9gO9wpn6YilrDm+hmP5x7p0NQDg5+LHjMEz+Cr5q071SD5bauqsZ+xtz9jO9szt3BtzL34ufq2O13dzs1fA2BZD4CWlLAauBP4tpZwGdLh2FkIYgdeBS4Bo4AZrctZCCA/gZ0BrmcI+Qq25jm0ncpk3yr/D+EB6cTon932PcHLCMTycanM1j2x9BCklf5rzJxUzkFIJXNlKnVm1h1z/IKy+Dv42Ffa+DTMfgDs2tu2jHLEATK4Q91+1XXJaaaC8u7i13/i0pTrU3w7BbDvjZnLjljG38MUVX+Dn7Mebh99sdrzKXMXahLXMD5vfNYa4L+HkoTJayvPgq4fO7hynD4MwtKs/5RJjyYAJCUE4dK4q/b6Y+xBCIBBdbggALh1+KVllWRzIOdDl527Kf+L+w/yP55NU2PzDvKauhpf2vsRQz6HcOPpGq+91ilSGoDrJPi4sWwyBgxAiGLgW+LIT5z4P5UZKllJWA2uApVbG/Rb4IyoW0Sc5mF5IUUUN80e17xbakraFq7+4muO7v+FUoIljRSd4cc+LxJ6J5bezftugE8Tet+GVaOXbt8UnuP1l1V4vfoNqDBMwGm76FBY+r2Se28LRtdE9VF0Ga26CklNQktU8iCwlxK5VgcC2dFT6AC4OLtw25jZ+zPqRw7mNsgdvHHqDgqoCboq6qQdn14MMnqBai57YeHaB46xDqvWoo2ubQ1wscQJTG81o2iPILYgHJj7AtaOubVYd31VcEHYBLg4uDanD9qC8ppw3D79JUVURj2x9pEFGXkrJCz++QEpRCo9OebRNt6SDry8RG7/BZ/lyq8fPFVsMwXPARiBJSrlHCDEcsCWPKQRoWs2TYdnXgBBiEhAmpex5B905sCU+B6NBMCtykNXjUkrePPwmP9vyM8I9hxJ1xokE/1qu+/I6Por/iFujb+XCIU0WWbH/BWGETc/B+pVQW932Dz+5C7b+HsZdq5q83PsD3PSJCgbbQvQyKMuF9y6DzL1w5Vvg6KGEtOo5tR/yTrTZRakvce2oa/Fy8uKfh5UcReyZWN45+g7LRixjSlCf9UyeO0HjobYSClI7/96sQ6rJUDu4xKjjtgaKW3L72Ns7lFQ5W1xNrlww5AK+Tf2WanM7/2vnwOcJn1NQVcD/Tfg/kouSeWH3C0gp+eOeP/JZwmfcPe5u5oXNa/ccjkOHdliId7bYojX0CfBJk+1kVP/ic0IIYQD+DNxmw9gVwAqAITYWo3Qnm4/nMnmoT5uNaF7d/ypvH32bxcMW86th95JeupjLFz1O1ZgScspz+NnknzUOrihUOdnnP6jS8b7/IxSmwXUfqF6/TSnPh8/uUjUBl/357NI6IxeAg4v6sJ/3NIy/BpI2Q9x6WPyy0lA5+CE4OKuYQh/H1eTK8qjlvH7wdY7mHeWZnc/g5+zHY1Mf6+mp9SwBlsSFnGNKpM5WSnPUCjI4pt1hTpGRuM+di8f8eWc/Rzty2fDL+Cr5K57d+SwXh1/M1KCpuJraXuF0hmpzNe/GvsuUwCncF3MfUkpWHVpFdnk2u7N2szxqudUAcXdiS/P6kUKITUKIo5bt8UIIW0xzJtDUOR1q2VePBzAW2CqESAWmA+utBYyllG9a+iZP8ff3b3m4RzldVMmxrOJ2s4W+TvmaOaFz+MPsPyATVENur7ETeHDSgzw/6/nmKpdJm6GuFkZeonKRr3hDZXT85yqobNKtqc4M6x9Q2j9Xv6N8vWeDoxvMegim3QdzH1f7xl8DVcVKuri2SjXQGH0pOHccCO8L3Bh1I+4md+757h4SChJ4ZsYzeDq23/i83+NvyVbLbaOXb1tkWVxsQe2vCISDA2Fv/AO3mb2zYnt68HSWDF/Cdye/Y+XmlcxaM4vnf3yekuqScz73F0lfkFOew93jlDrwPePvYVrwNHZn7eaqyKt4fOrj9u2LbAO2RG3+CTwGvAEgpTxs6U/wfAfv2wNECiGGoQzA9UBDJERKWQQ0+FKEEFuBR6WUeztzAT3N1vgcgDbjA7nluZwqO8VNUTchhKDy2DEQAueRbRSOndioqndDLfYw5nr1Yf3JbfCfK2H5Z+qfb+NTKmVvwW8hZNK5XcS8J5pvh88BtwDlHhICKgr6hVuoHk9HT64ffT1vHXmLJcOXMDdsbsdv6u84eagCs5zjnXvfaSUdQdC49sf1chwMDvxu9u/49cxfcyDnAN+mfssnJz5hS9oWnp72NCEeIWzL2MaOzB1MHzyd+2Lus+m8tXW1vH30bcb4jWHGYFVsZzQYeXnuy+w8tZOFQxf2uBEA2wyBq5TypxaT7TDxXEpZK4RYiYovGIF3pJSxQojngL1Sytad1fsgW+JzGOzlzMhA60HUQ7nqHyUmIAZZXU3xhq9xGjkSg5sVGYo6s3oKj1zYXKs8aglc+2/VK/W1ycqn7xUGV70NY+2Q7mh0gLFXwt53lRFwD2wmLdwfuGPsHbiZ3Lh2VBdLMfdl/EdDbicNQdYhlX7q0rG+Vl/AyejE9ODpTA+ezpWRV/Lrnb/m51t/3nA8yC2Ivx/8O1G+Ua18+tXmarZnbuer5K9IKUpp0AxLL0nnL/P+0uwD38vJi0uGXdIt12QLthiCPCFEBBYpaiHE1YBNnZSllBuADS32PdPG2Hm2nLM3UWuuY0fiGZbEDG7Tqh/KPYTJYCLKN4ozb71HdVISof9YZf2EGXuhIl9l8rRk9KVK2vabJ2HavTDjfuu1AV3FuGtg9z9U9tCMlXZtRNMTeDh6cNe4u3p6Gr2LgNGQ8r0qMLT1fmcd7jA+0FcZO2gsay5bw/rE9RiEgdmhs/F09GT5huX8cscv+XTJpwS5BVFlruKNQ2/wUfxHFFcX4+vsS4x/DBW1FZTVlLFw6ELmD+ndD1K23O37gTeB0UKITCAFGKB5ds2Jzy6htKqW6cPblpU4lHuIaL9oyMohb9UqPBZchMe8edYHn/hayQNHXGD9+KhL1Ks7CJmsGpgUpMAE67nNmn5GQLQSjitIsa1PQWWRGjvRPimNvQGTwcRVI5uvul+a+xLXfnEtT2x7gocmP8SzO58lqSiJBUMXcGXklUwPno6DoW89ONmSNZQMXCSEcAMMUspzj570E/afVEobLXu61lNjriE2L5brR11H9vMvgMFA4NNPt33CExtVrn5vWGYLAXMehdQf+lw1seYsqS8WzDlmmyE4bdFvCp5gvzn1QoZ6DuWX03/J0z88zc1f30ygayCrLlrFrJBOdjnrRdhstqSUZfacSF9k38kCAjycCPWx7qI5nn+cGnMVMw5WUbp1KwGPP952eX3BSaX3v/AFO864k0xc3q+f9jQtaMgcOg5c3u5QQMUHoMMagv7IkoglpBanUlxVzIOTHsTD8Syz9noJfWv90svYl1bA5KE+DfGBkq1bqUpIwOjlhdHTi9xtH/O3/5nxK16NU3QUvje386Ga8K36OrJ1ww2NpltwdFM1KTk2ppBmHQKPYHDvWGixP9LTuf9diTYEZ0lOcSXp+RXcOiMcAHNhIZk/+zmyqrHjU6BBcGyEMzG/eg6PCy9EmNpRtUzdrjKBBvXzhiia3k1AlO2ZQ/04UDzQ6NAQCCEOo3SCPpJS2q8zQh9jnyU+MHmoig8Ufr4WWVVF+JoPcQgMxFxUxA2772f40AlcPW9J+yeTUhWNRQwAHXxN78Z/NCRuUn2t25Pjri6HvHiV2qzp89iiNbQEVTfwsRBijxDiUSFE79N56Gb2nSzA0cHAmMFeyLo6CtaswWXyZFwmTMAUHEzxEF8SyWnoO9ouZxJVbcDQ3ll1qRlABERBXY11KfKm5MSBrNMrgn5Ch4ZASnlSSvmilHIyqjJ4PCqFdECzL62AmFAvHB0MlP3wAzVpafjc0Fh927SQrEPq+wFoQ6DpaZpmDrVHukU1fvBE+85H0y3YsiJACDFUCPE4ykU0GnjcrrPq5VTWmDmaWcQki1uo4IPVGAcNwnNho+LnoZzGQrIOObkL3PxVExmNpicZNBIQHccJUn9QdSZeIe2P0/QJbIkR7AZMKAXSayx1BQOaI5lF1JglU4b6Up2RQem2bfjdew/CsVH7f3/OfqL9onE0ttMPoJ6TO9VqoBdojmgGOI6uSjKivRVBnRlSd8AYa+1FNH0RW1YEt0gpJ0kpf6+NgGJfQyGZN4Vr1oDBgM911zUcP112miN5R5gbaoOYWWEaFKXB0PPtNV2NpnN0lDl0+ghUFUH47O6bk8au2GIICoUQbwshvgYQQkQLIe6087x6NftOFjBskBu+Lg4Ufr4WjwvmYwpqbHG4MXUjgG1t9U7uUl91fEDTWwgcA3kJqmudNeq714X33UpaTXNsMQTvoRREB1u2TwA/b3N0P0dKyf6TBUwa4kPFwYOY8/PxvPSyZmM2pm4kyjeKIZ42JFed3AFOXkrnRaPpDYSeB9IMmfusH0/9AXwjwHOw9eOaPocthmCQlPJjoA6UvDRwFo1N+wc5JVWcKatmfKgXJZs3g8mE26xGt05maSZH8o7Y3mQ7bRcMmd5cdlqj6UnCpqqvabtbHzPXqpjWMO0W6k/YYgjKhBB+NMpQTweK7DqrXsyJbKW5FxnoTumWrbhNnYrRvbEXQafcQqW5qhewdgtpehMuPuAfBek/tj52+rDqXqfjA/0KWwzBw8B6IEIIsQP4N9B/RDY6SUJ2KQDDK/OpTk7G/YLmktEbUzcy1m8soR6hHZ8sbaf6qgPFmt7GkGmQvgfq6prv1/GBfoktBWX7gbnATOAeYIyU8rC9J9ZbScgpxcfVhOknVQTWtBl3WnEacWfibFsNnEmC718ER3ddnanpfYRNV5lBLXsYp/4AfpHgEWT9fZo+SZt1BEKIK9s4NFIIgZTyczvNqVeTmFNCZIAHpZu34DRyJKaQxoKab08qBdGF4QvbP0nsWlj3gIoLXP0uONhQa6DRdCdDpqmv6bsb+1GYa1WW2/hrem5eGrvQ3opgieV1J/A2qivZTcBbwB22nFwIsUgIES+ESBRCPGnl+L1CiCNCiINCiB+EEL06dUZKyYnsUqI9oXz/ftwvmN/s2IaUDYz3H89g93ayKXa/oRrRB4yGe7fDyA6MhkbTE/gMU9XuTQPGWYegukS7hfohbRoCKeXtUsrbUVXF0VLKq6SUVwFjLPvaRQhhBF4HLgGigRusfNCvllKOk1JOAF4E/nyW19Et5JZWUVRRw+SsY2A24zG/0RDszd5LQkECV4y4ov2THFwNgyfB7V+D94DX7tP0VoSAsGnNA8b731OtVMPn9Ni0NPbBlmBxmJSyabP6bMCWT7DzgEQpZbKUshqlU9SsJl1KWdxk0w1LZlJvJdESKA47vg/joEE4jxunlstnknj/p5fxNjhxmdvwtk9QXQ7ZRyFifvsSvxpNb2DIdChIhZJsOHUA9r8P0+4Fd/+enpmmi7GlMc0mIcRG4EPL9nXA/2x4XwiQ3mQ7A5jWcpAQ4n5UZpIjYLVruxBiBbACYMiQnnuKTsgpxaGuFucDP+G+6GJExh749HbSy7PZGhrMXUXFOH/7S7h9g/UTnDoAdbWqYEej6e2ETVdf03bBj6vAbRDMHdB6k/0WW7KGVgL/AGIsrzellF2WPiqlfF1KGQE8AfyyjTFvSimnSCmn+Pv33NPIiewSZhYmI0tL8Qgzw3uXgtHE6glLMBocuH7kNeqfpjTX+gnqpXtDp3bfpDWasyU4BhycYfPzykV04TPg7NXTs9LYAZtkqKWUa6WUD1lea208dyYQ1mQ71LKvLdYAy2w8d4+QkFPKwrxYDM4OuGX8HSLmU3r7V6wtPs6iYZcQMOFW1awjvo0VQcYeJTXt5te9E9dozgYHRxXPOpOgjMKEm3p6Rho7YZMhOEv2AJFCiGFCCEfgelRhWgNCiMgmm5cCCXaczzmTcrqI8cn78AgqxnD+/XDDR3yevpmymjKWRy+HoHGq+ffxL1u/WUpI/0m7hTR9i6Ez1NdLXtQyKP0YuzWvl1LWCiFWogTrjMA7UspYIcRzwF4p5XpgpRDiIqAGKAButdd8zpUzpVUMSY3FVFmJR4QRLvgFZiSrj69mUsAkxvhZcq2jlsBPb0JlUfNldH4ylOc16rhoNH2BmQ9CxAUqcKzpt9jNEABIKTcAG1rse6bJ9z+z58/vSk5kl7Lw1E8YHOpwW3w9OLqx+eR3ZJZm8uiURxsHRi2BXX+DhO9g3NWN+zP2qK9hreLlGk3vxcVb1w0MAM7KNSSEeLaL59HrSTpVwIysWNxDqjCcfy8A78e9T4h7CPPDGusJCD0P3ALg2BfNT5C+Gxw9GnvCajQaTS/hbGMEbQiV91/Kd27HVG3GY+ZY8B7CkdwjHMg5wPKo5Rib+k4NBhh9qVoR1FQ07k/fA6GTtZ9Vo9H0Os7KEEgpv+h4VP9BSknA7vfAoQ736x8B1GrA3eTOFZFWKomjLoOaMkjeqrarSiAnVruFNBpNr6Q90bnXaKfSV0r5oF1m1At5Y/erTEzJ4adII+VeHgwuzeLbk9+yPGo5bia31m8In6O6jv3wiur/WpCq0kp1xpBGo+mFtBcs3mv5ej5KK+gjy/Y1QJw9J9Wb2JD4JY5/eBOPCsnOSR785du7ifZTkkk3Rt1o/U0OjrDwOfjmKfjb1Ma4QOjkbpq1RqPR2E6bhkBK+S8AIcR9wCxLi0qEEP8AtnfP9HqWQ7mHOPT7p1h2XOITU8qNyz7GMeefbM3YysXhF7evMjr5NohcqKoyD65WPYldfLpt7hqNRmMrtqSP+gCeQL5l292yr1+z5/QePn5tJXfsqMUYKTgxcihTRkYze+yrfHvyW6YETun4JJ6DYdnfVS62FpnTaDS9FFsMwR+AA0KILYAA5gC/seusepDymnL+sv8vfL13Na+vq0OMjSAyajsb3Jcxx0n9uhaFL+rcSQN0yqhGo+m9dGgIpJTvCiG+plE59Akp5Wn7TqtnSCtO457v7lFFYszGVLuVIYsjqUvbQdFQ3UBGo9H0TzpMHxVCbJJSnpZSrrO8TgshNnXH5LqT/Mp87vvffZTWlPLOxe+wqHoUODhgLNjGT+bRjBg2rKenqNFoNHahTUMghHAWQvgCg4QQPkIIX8srHNVroN9QUVvBA5sfILs8m9cueI0pQVOojIvDKTwUp5JENtSdR0yod09PU6PRaOxCe66he4CfA4NRlcTCsr8Y+Jud59VtmOvMPLX9KY7kHuGVea8wIWACUkoq4+JwH+ULwFZxHs8EefTwTDUajcY+tJc++irwqhDiASnla904p25lx6kdbErbxKNTHuXCoRcCUJuTi/nMGZxNFRw3RRMQOAyT0Z6K3RqNRtNztOcamiqECKo3AkKIW4QQ64QQf7W4jPoFKUUpACwb0dgTpzIuFgBnhzTWVk3WbiGNRtOvae8x9w2gGkAIMQeVRvpvoAh40/5T6x7SS9LxcPTAy6mxd0BlXBwIcPauYUvNWGLCdHs+jUbTf2kvRmCUUtYXkV2H6lX8GfCZEOKg/afWPWSWZhLqHtpsX2XcMRz93ah1cSehNIQJYXpFoNFo+i/trQiMQoh6Q3EhsLnJMbs2tOlOMkoyCPVoaQjicPauItllDF6uTgzxde2h2Wk0Go39ac8QfAh8L4RYB1Rg0RcSQoxAuYf6PHWyjlOlp5qtCGrz86nNysLZ9Qy7akYSE+qNEKKds2g0Gk3fpk1DIKV8AXgEeA8lOiebvOcBW04uhFgkhIgXQiQKIZ60cvxhIUScEOKwEGKTEGJo5y/h7Mktz6W6rpoQ98ayiMq4YwA4+9TwTXE4MdotpNFo+jnt5kRKKX+UUq6VUpY12XdCSrm/oxMLIYzA68AlKBnrG4QQ0S2GHQCmSCnHA58CL3b2As6FjNIMgGauoco4pbDt4CM5JIczd6R/d05Jo9Fouh17JsefByRKKZOllNXAGmBp0wFSyi1SynLL5o9AKN1IZmkm0NwQlB45Cu4GYh3C+eN15zF5aL8XWtVoNAMcexqCECC9yXYG7UtT3Al8be2AEGKFEGKvEGJvbm5ul00woyQDgSDYLRiA0qpaMnbvx827HO9Rs1k6oV8paWg0Go1VekW5rBBiOTAFeMnacSnlm1LKKVLKKf7+XeeqySzNJNAtEEejIwCvrz+AX3Eerr7VDJ98UZf9HI1Go+nN2NMQZAJhTbZDLfuaIYS4CPgFcLmUssqO82lFRklGQ8bQiewSfty4E1CBYt1oXqPRDBTsaQj2AJFCiGFCCEfgemB90wFCiImoCubLpZQ5dpyLVTJKMghxD0FKybPrYxlXrILHLiPCwG1Qd09Ho9FoegS7GQJLj+OVwEbgGPCxlDJWCPGcEOJyy7CXUK0vPxFCHBRCrG/jdF1OlbmKnIocQj1C+epIFjuTzrDImIejZx3GkTO6axoajUbT49i1QlhKuQHY0GLfM02+7zFHfH3GkL9zMC98fozoIA8GbTuOi28lDJneU9PSaDSabqdXBIt7gswSZQgyc13JKqrk1+f5Ys4vxNmvGoboFYFGoxk4DFhDUF9MlpHrgpujkVEFaQC4DPUG3+E9OTWNRqPpVgauISjJwNnoTFyGJCbMm6pDhxBGifPE80FrC2k0mgHEgDUEmaWZBLsP5nhWCROHeFOxbzfOPtWIiDk9PTWNRqPpVgasIcgoycDTGEhtnWRikBuVJxJxGVQD4bN6emoajUbTrQxIQyClVDGCWtVxc0xFNrLGjEuoO/gM6+HZaTQaTffSbxrMdIaiqiLKasooMXsS5uuC0wmlOOoy+TwdH9BoNAOOAbkiqM8YOpXnysQwHyr27MDBxYwp5sIenplGo9F0PwPaEJwp9FCB4kOHcPGr1vEBjUYzIBmQhiCtWNUM1FX7MsFDUpNThEuIi44PaDSaAcmANASpRam4GvxwNDgTcuAHAFzGj9fxAY1GMyAZmIagOBVq/LnQsYj8l/+EW2AlLnMX9/S0NBqNpkcYcIZASklqcSq1Zzy4/bs3MbqaGDyjEBExr6enptFoND3CgDME+ZX5lFQVs2JzGu5nsgm5yAGHiEngM7Snp6bRaDQ9woAzBCeLTzIlQTInJRPXW67F1eE4jLu6p6el0Wg0PcaAMwSpxalMTJJUODox9DwHQED0sp6elkaj0fQYA84QHM1JICoNyiLHIuI+V7UDnsE9PS2NRqPpMexqCIQQi4QQ8UKIRCHEk1aOzxFC7BdC1AohusU/c/xELKH5kpBJw+BMIoy9qjt+rEaj0fRa7GYIhBBG4HXgEiAauEEIEd1iWBpwG7DaXvNoiXt8MgBBg86AwQGil3bXj9ZoNJpeiT1F584DEqWUyQBCiDXAUiCufoCUMtVyrM6O82ggPb+EkRmF1JiMuBRvhYgLwNW3O360RqPR9Frs6RoKAdKbbGdY9nUaIcQKIcReIcTe3Nzcs57QRwcPE5Vupny4P6IsE8bqbCGNRqPpE8FiKeWbUsopUsop/v7+Z32e7Uf3Ep4NbiECTG4wWlcTazQajT1dQ5lAWJPtUMu+HuFUYQUuCQcxAIOMJ2D8teDk0VPT0Wg0ml6DPVcEe4BIIcQwIYQjcD2w3o4/r12+Pnqasbnp1BrA36sUpt7ZU1PRaDSaXoXdDIGUshZYCWwEjgEfSyljhRDPCSEuBxBCTBVCZADXAG8IIWLtNZ/zR/gxKa+A00ECQ/hUCBpnrx+l0Wg0fQq7tqqUUm4ANrTY90yT7/egXEZ2Z6SXidpT5RybUKtXAxqNRtOEPhEs7goK9u3GWAeGwVpSQqPRaJoyYJrXZ2/9Cgl4T5kOJueeno5Go9H0GgbMiiBtTBG/uNXIkGm39fRUNBqNplcxcAxBWBTJgwVDhpzf01PRaDSaXsWAMQR3T/45W6/7HiejU09PRaPRaHoVA8YQCCHwdda6QhqNRtOSAWMINBqNRmMdbQg0Go1mgKMNgUaj0QxwtCHQaDSaAY42BBqNRjPA0YZAo9FoBjjaEGg0Gs0ARxsCjUajGeBoQ6DRaDQDHG0INBqNZoCjDYFGo9EMcLQh0Gg0mgGOXQ2BEGKRECJeCJEohHjSynEnIcRHluO7hRDh9pyPRqPRaFpjN0MghDACrwOXANHADUKI6NWexQ8AAAb0SURBVBbD7gQKpJQjgFeAP9prPhqNRqOxjj1XBOcBiVLKZCllNbAGWNpizFLgX5bvPwUuFEIIO85Jo9FoNC2wZ8/iECC9yXYGMK2tMVLKWiFEEeAH5DUdJIRYAaywbJYKIeLPck6DWp57gDAQr3sgXjMMzOseiNcMnb/uoW0d6BPN66WUbwJvnut5hBB7pZRTumBKfYqBeN0D8ZphYF73QLxm6NrrtqdrKBMIa7IdatlndYwQwgHwAs7YcU4ajUajaYE9DcEeIFIIMUwI4QhcD6xvMWY9cKvl+6uBzVJKacc5aTQajaYFdnMNWXz+K4GNgBF4R0oZK4R4DtgrpVwPvA28L4RIBPJRxsKenLN7qY8yEK97IF4zDMzrHojXDF143UI/gGs0Gs3ARlcWazQazQBHGwKNRqMZ4AwYQ9CR3EVfRQgRJoTYIoSIE0LECiF+ZtnvK4T4TgiRYPnqY9kvhBB/tfweDgshJvXsFZw9QgijEOKAEOJLy/Ywi1RJokW6xNGyv99ImQghvIUQnwohjgshjgkhZvT3ey2EeMjyt31UCPGhEMK5P95rIcQ7QogcIcTRJvs6fW+FELdaxicIIW619rNaMiAMgY1yF32VWuARKWU0MB2433JtTwKbpJSRwCbLNqjfQaTltQJY1f1T7jJ+Bhxrsv1H4BWLZEkBSsIE+peUyavAN1LK0UAM6vr77b0WQoQADwJTpJRjUYkn19M/7/V7wKIW+zp1b4UQvsCvUcW75wG/rjce7SKl7PcvYAawscn2U8BTPT0vO13rOmABEA8EW/YFA/GW798AbmgyvmFcX3qh6lI2ARcAXwICVWXp0PKeozLXZli+d7CMEz19DWdxzV5ASsu59+d7TaP6gK/l3n0JXNxf7zUQDhw923sL3AC80WR/s3FtvQbEigDrchchPTQXu2FZBk8EdgOBUsosy6HTQKDl+/7yu/gL8DhQZ9n2AwqllLWW7abX1UzKBKiXMulrDANygXctLrG3hBBu9ON7LaXMBP4EpAFZqHu3j/5/r+vp7L09q3s+UAxBv0cI4Q58BvxcSlnc9JhUjwb9Jk9YCHEZkCOl3NfTc+lmHIBJwCop5USgjEZXAdAv77UPSpxyGDAYcKO1+2RAYM97O1AMgS1yF30WIYQJZQQ+kFJ+btmdLYQIthwPBnIs+/vD7+J84HIhRCpK1fYClO/c2yJVAs2vq79ImWQAGVLK3ZbtT1GGoT/f64uAFCllrpSyBvgcdf/7+72up7P39qzu+UAxBLbIXfRJhBACVaF9TEr55yaHmsp33IqKHdTvv8WSdTAdKGqy9OwTSCmfklKGSinDUfdys5TyJmALSqoEWl9zn5cykVKeBtKFEKMsuy4E4ujH9xrlEpouhHC1/K3XX3O/vtdN6Oy93QgsFEL4WFZTCy372qengyPdGIRZDJwAkoBf9PR8uvC6ZqGWi4eBg5bXYpRfdBOQAPwP8LWMF6gMqiTgCCobo8ev4xyufx7wpeX74cBPQCLwCeBk2e9s2U60HB/e0/M+h+udAOy13O//Aj79/V4DvwGOA0eB9wGn/nivgQ9RcZAa1OrvzrO5t8AdlutPBG635WdriQnN/7d396xRhFEUx/8HC0khFmq/jSIo+AJpRCWFWFmITcDSwhdQK5HgJwj4DaxsgpUoVmoVjQnBYEhUsLQRUQRBlIDIei3uszi7SZTIJEGe82uys7vzbLZIzs4sc66ZVa6WU0NmZrYKB4GZWeUcBGZmlXMQmJlVzkFgZlY5B4FVS9K38rMj6WzLa98Y2J5pc32zNjkIzLLoa01B0LiqdTV9QRARR9b4O5ltGAeBGYwDxyQtlO77LZJuSporXe8XACSNSJqS9IC8uhVJ9yW9KH3558t948BQWW+i3Nc7+lBZ+7WkV5JGG2tP6vesgYlyJa3Zulu34fVm/5Ex4FpEnAIo/9C/RMSwpK3AtKTH5bmHgf0R8bZsn4uIz5KGgDlJdyNiTNLliDi4wmudIa8OPgDsLPs8LY8dAvYB74FpslPnWftv16yfjwjMljtJ9rgskJXeO8gBIADPGyEAcFXSIjBLln3t5s+OAnciohsRH4EnwHBj7XcR8ZOsCum08m7M/sJHBGbLCbgSEX1lXZJGyOrn5vYJchDKkqRJsuvmX31v3O7iv0/bID4iMIOvwLbG9iPgUqn3RtKeMgBm0HZyLOKSpL3kqNCeH739B0wBo+V7iF3AcbIczWzT+BOHWTZ5dsspntvkbIMOMF++sP0EnF5hv4fARUlvyFGBs43HbgEvJc1HVmT33CNHKy6SrbHXI+JDCRKzTeH2UTOzyvnUkJlZ5RwEZmaVcxCYmVXOQWBmVjkHgZlZ5RwEZmaVcxCYmVXuF0qFZH3CC45/AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hUVdrAf2cyk957T0gBErpAaNJVBAtix4q7rmsvq66431pXd9XVXeuqsJZVKXZQQIr0EkIPIQklvfdeJtPO98dNG1KRBIXc3/PkGXLve889E2bOe89bhZQSFRUVFZWBi+bXnoCKioqKyq+LqghUVFRUBjiqIlBRUVEZ4KiKQEVFRWWAoyoCFRUVlQGO9teewJni7e0tw8PDf+1pqKioqJxXHDx4sExK6dPZufNOEYSHh3PgwIFfexoqKioq5xVCiOyuzqmmIRUVFZUBjqoIVFRUVAY4qiJQUVFRGeCoikBFRUVlgKMqAhUVFZUBjqoIVFRUVAY4qiJQUVFRGeCoikBFRWVgUpkF/7sKjiz/tWfyq3PeJZSpqKionDUNFfDF9VB+CjJ3QNYumPdPsHX6tWf2q6DuCFRUVAYWxkZYfhNU5cCitTD9KWVXsHQWVOf/2rP7VVAVgYqKyoVPUy2UHIe0zfD1XZC3H65bCuEXw8y/wO3fQekJOPTZrz3TXwXVNKSionJhk3cAProMpLnt2NzXIHZ+2++Rs8BzEJSmnvv5/QZQFYGKisqFzfG1IAQs+C+4BYNHGLgGdpTziYESVRGoqKioXHhkboegcTDyhu7lfGPg5HowNYHW7tzM7TeC6iNQUVG5cGmshILDEDGjZ1nfGMV8VHaqv2f1m6NfFYEQ4nIhxAkhRJoQYnEn50OFEFuFEIeFEEeFEPP6cz4qKioDjKxdIC0QMb1nWd8Y5bX0eP/O6TdIvykCIYQN8B4wF4gFFgohYk8T+yvwlZRyDHAz8J/+mo+KisoAJGM76JwU01BPeEWBsBmQfoL+3BHEAWlSygwppQFYCcw/TUYCrs3/dgMK+nE+KioqA42MbRA2GbS2Pctq7cArUlUEfUwQkNvu97zmY+15HrhNCJEHrAMe6mwgIcQ9QogDQogDpaWl/TFXFRWVC43qfCVzOGJG76/xjRmQIaS/trN4IfCplDIYmAd8LoToMCcp5RIp5Tgp5Tgfn057L6uoqKhYk7ldee2Nf6AFnxioyARDQ//M6TdKfyqCfCCk3e/Bzcfa83vgKwApZTxgD3j345xUVFQGChnbwNEbfIf1/hrfGEBC2cn+mtVvkv5UBPuBaCHEICGELYoz+IfTZHKA2QBCiBgURaDaflRUVM4OKRVFEDEdNGewzLVEDg0wP0G/KQIppQl4ENgApKJEByULIV4UQlzdLPY48AchRCKwAlgkpZT9NScVFZUBQukJqCuGQWdgFgLwjAAb2wHnJ+jXzGIp5ToUJ3D7Y8+2+3cKMKU/56CiojIASd+ivEbMOLPrbHTgFa3uCFRUVFTOe05tBO8hSl2hM8U3RqlUOoBQFYGKisqFRVMdZO+G6Et/2fW+Q6E6RyldPUBQFYGKisqFReYOMBsg+rJfdr1PS6mJE303p984qiJQUVG5sDi1EWydIXTSL7t+AEYOqYpARUXlwkFKOLVJcRL3pqxEZ3iEg9YBSlL6cGK/bVRFoKKicuFQkgo1eb/cLASgsVH8BMXJfTev3ziqIlBRUblwOLVRef2ljuIWfIepOwIVFRWV85JTm8BvROetKM8Ev1ioL4W6kr6Z128cVRGoqKhcGOirISf+7HcDAH7N9YkGiHlIVQQqKioXBmmblVaTZ+MfaKGlUN0AMQ+pikBl4FCUBLvfBrPp156JSn9w+AtwCYDg8Wc/lrMPOPlA8cBQBP1aa0hF5TdBbRFseUlZKJDgMwQGz/m1Z6XSl5SnQ/pmmPE02PTRsuY3DIqP9c1Yv3FURaByYZN3AP53tZJpOvE+OPg/OLleVQQXGgc+Bo0WLrqz78b0HQYHPgKLWQkpBR7Y/AB7C/bibOuMs86ZiQETeXzc4zjqHPvuvr8CqiJQubBJXKm8PpCg9KOtyoGTG5XEIyF+3bmp9A2GBmW3N/RKcA3ou3H9hoFJr3Qs846iQl/BzrydxAXEEeoSSoW+gq9Pfs3B4oO8MeMNIt0j++7e5xjVR6By3lL6zrukzZlD/pN/pnLFCoz5pzfAQyk+FjpBUQKg7ARq8gaME3BAcOxb0FdB3B/6dly/WOW12Ty0t2AvEskjYx7h2UnP8ubMN/ng0g+obKpk4dqFbMre1Lf3P4eoikDlvKQpM5OyDz9EaHXU742n6IUXybh6PsaiojahhgplwQ9r1/KiJaLk5PpzO2GV/kFK2L9UKRQX1setTXyGgtC0PjTsLtiNm50bsV6xrSKTAyfz9VVfE+4azkt7X8IiLX07h3NEvyoCIcTlQogTQog0IcTiTs7/WwhxpPnnpBCiqj/no3LhUPL6G2hsbQn736dE79jBoO+/Q5rNFP/9H21C2XuU1/YLhIs/BIxWzEMq5z/5B6EwEcb/vu9NfToH8IyE4mSklMQXxDMxYCI2zf6CFnwdfbk15lYq9BWcqDg/K5b2myIQQtgA7wFzgVhgoRAitr2MlPIxKeVoKeVo4B3gu/6aj8qFQ/2+fdRt3ozXPfeg9fZGCIF9TAze991H7caN1G3frghm7wGtPQRdZD3A4DmQt0/ZMaic3yR/r7SWHHlT/4zvFwvFyZyqOkVpYylTAjvfdUwOnAwou4bzkf7cEcQBaVLKDCmlAVgJzO9GfiFK32IVlS6RFgslr7yKNiAAz0XWESJedy3CNjKSor+9hKWxEbJ3KTHlWjvrQQbPAWmBtJ/P4cxV+oWiJKVstL1r/4zvOwwqs4jP2QbApMDOS1v7OPow1HMou/J39c88+pn+VARBQG673/Oaj3VACBEGDAK2dHH+HiHEASHEgdLS0j6fqMr5Q82PP6JPScH3sUfR2NtbnRO2tvg/+yzGvDzK3n1LWSQ6sxsHjAEnXzi54RzNWqVfkFJx5PqN6L97+A0DJLtzthDpFom/k3+XolMCp5BYkkit4fzrbPZbcRbfDHwjpTR3dlJKuURKOU5KOc7Hx+ccT03lt0TlV19jFx2F65VXdnreaUIcbvPnU/7p5+grNBA2uaOQRqM4jdM2qVnG5zN1xdBQDv7D++8efrHoheBg5XEmB3XyWWrHlKApmKSJfYX7+m8+/UR/KoJ8IKTd78HNxzrjZlSzkEoPSLMZfUoKjhMnITRdf3R9Fz+F1smWgr2eWHxGdi40eI5SpGzXv/tptir9TlFz1q9fPyoC93AOOrlhkOZWP0BXjPYZjZPO6bz0E/SnItgPRAshBgkhbFEW+x9OFxJCDAU8gPh+nIvKBUBTejqysRGH4cO6ldN6eBBwiRNN1VpK/7O0c6GhV8CIG2HrS7DpOcXMoHJ+UZykvPbnjkCjYY+nH7bAWL+x3YrqbHRM8J/A7vzdyPPs89RvikBKaQIeBDYAqcBXUspkIcSLQoir24neDKyU59tfTuWcoz+mlAS2H97DF99Qj7N9Ku4XR1Hx6afU7+tkq66xgQUfwrjfwe43Yc1jYDk/Y8AHLEXHwDUYHDz69TZ7dIKxTWYctA49yk4JmkJBfQGZNZn9Oqe+pl99BFLKdVLKwVLKSCnly83HnpVS/tBO5nkpZYccAxWV09EfO4bG0RHb8PDuBXP3gcWE3yP3ogsNoXDx01j0+o5yGg1c8S+Y8igc/ASSz3308q78XSxav4gGY8M5v/d5T/Gx/t0NAIV1haRZGphSVwN1PQeqTAlSghN25/eteUiaTBQ8tZiG/fv7dNwWfivOYhWVHmlMPoZ9bCzCxqZ7wew9IDRooqcS8NxzGAsKqFm7rnNZIWD2c+ASqMSkn0OklLx16C0OFh9k5YmV5/Te5z1GPZSd6l//ALAjbwcAUxsboaTnJjVBzkGEu4b3uSLQp6ZSvXo1pn6KmlQVgcp5gTQaaUo93rNZCCA3QVkg7F1xnDQJu+goKpZ90bXdVqOB2KuVNodNfRf69+6WU9z+UQJVDYZOz8cXxnO84jhudm58euxTdVdwJpQeV5rQ9POOYGf+ToKdAhhkNEFJaq+umRw4mYPFBzGajX02j/r4vQA4xsX12ZjtURWBynlBU1oa0mDoWRFYzErZgRDlCyOEwOPWW2lKSaXx8JGur4u9BsxNfZZbIKXki7057DxVxi1LE6io76gMPjn2CT4OPrw5400qmyrVXcGZ0NInoB9zCPQmPQmFCUwLmYlw9O5128rx/uPRm/Ukl/ddm8uGvXuxi45G6+3dZ2O2R1UEKucFjceUL77DiB4UQUkKGOogZELrIberrkLj4kLlsmVdXxcyAZz9IWVVX0yXtJI6imr0LBgTRHppHTcviae0tqn1fGp5KnsL93Jb7G2M8x/HlKAp6q7gTCg6BjpH8BzUb7fYX7QfvVnP1OCpSvZyL3cEF/kpJU0OFB/ok3lYDAYaDh3CceLEPhmvM1RFoHJeoD+WjMbFBV1oaPeCuQnKa0jbFlrj5IT7tQuo2bABY0lJ59dZmYfqznq+O06VAfD4ZYP5ZNF4cisauefztoXhk+RPcNI5ccPgGwC4b9R96q7gTCg+pizOmh78RWfBjrwdOGgdGO8/XskwLkntVWSZp70nkW6RHCjqG0WgT0xE6vU4TZzQs/AvRFUEKucF+mPHsB8+DNFThcncfeDsB+5hVoc9Fi4Ek4mqr7/u+trY+UojklNnX5l0x8lSInycCPZwZHKUN3dPHcSR3CoMJgt5tXlszNrIjYNvxMXWBYBRPqNadwWNpsazvv8FjZRK+ZB+dBRLKdmZv5MJ/hOws7ED31gw1kN1Tq+uH+c/jsMlhzFZus5cN1qMZNdksyNvB2sz1raWsD7dl1W/NwE0GhzH90Ev5i5QFYHKbx6LwYD+5EkceusoDonrUJLYNjwcp6lTqVr5JdLYhRMvdJJSg+gszENGs5EafSMJmeVMi24rhxLm5YSUkF/VyPdpSnTSrTG3Wl17R8wdVDZVsr+of0IELxhqCpRGNP795x/IrM4kvy5fMQuBogig183sx/mNo8HUwPGK452eTyhMYPLyyVz5/ZU8sPkBFu9czPrM9TTs30/67EtoOHS4VbY+YS/2sbHYuPZTYT1URaByHtB04gQYjdgP60ER1BZDZZaVf6A97guuwVRaiv54519ONDYQc5ViHjLU/6K5/mn7n/jDhgfRGy1MG9zm2Av1VHra5lQ0cKTkCEM9h+Ln5Gd17Vj/sdjb2LOnYM8vuveAobj/S0u0ho0GtSiCocprLzvbtWQhd2Ue+jT5U1xtXXlpykt8PvdzItwi+Gz/B+Q/tRhjQQFFL/0NaTZjaWigMfEoTpP6zz8AqiJQOQ/QNzuKe4wYymvOIO5CEdhGKu0qjXl5XY8x7BowNkB6p4Vwu6XB2MDu/N2kVu1Hp2tkwiCv1nMtiiCrvJaksiRG+YzqcL2djR1j/ceqiqAnippLS/h1X2rkbNiRv4Noj2gCnJt7INu5gHto14rA1ASlJ5WHEaMeH0cfwlzDOnUYlzSUsKdgD/Oj5jM/aj6jfUdz94i7mfptGsaiQjzvuoumlFSqvvtO2RkYjThO+JUUgRBihBBirxAiVwixRAjh0e7c+VdeT+W8pfHYMWzc3dEFBbL+WCHfHepiIc9NUJqUBHRcZAF0QcEAGLpTBEHN9WRKrTtNNWVkkn7llZS+/XaXlx4oPoDRYkQiiQrLx8lO23rO18UOW62GY6UnaDQ1MrKLYniTAyaTWZ1JYV1h13Mc6GRsA+8h/daDoLqpmsPFh9t2Ay34Dus8cqixEpbMgPfGwxuD4WU/+Pdwxll0HCo+gNliXVR5TcYaLNLC/Ki29ixTM+2ZdVSya5YvPk8+gcPYsZT++01qN20CnQ7Hi8b0wztto7sdwfvA88AI4CSwSwjR3AEcXb/OSkWlHY0HD2E/cgSNRjOLv0vi5bWpnSeH5e6DwDEdG9E0Y+PshI27O8a8rorgArZO4OAJNW0y+pQUsm+7DUNWNmX/eZ+qVZ37EHbn78bOxg6LyQl7N2tFotEIQjwcOFWlxJZ3pQhaShSou4IuqCmArF0wbEG/3WJLzhZM0sRlYZdZn/CNgbKTYGqXE2JshBULoTwNLn8VrngDZj0D3tGMzdhLrbGeUyuuh5TVYNQjpWR12mpG+4wmzFUJaDDk5lLy3As0DvLnPxeVsa94H35/eRpzZSVVX36Jw6iRaBwd++39QveKwEVKuV5KWSWlfB2lgNx6IcREQC0Qp3JOaMrIxJCVhfP06XxzMI+qBiPl9QbSSk4L8TQ1QcFhq7DRztAFB3dvGgJwC4JqRabhwAGy77gTYW9HxKrvcZwwgaJnnqXxSMfktD0Fewh1GIG5biiFho4RI6GejhQ1ncDT3pNg5+BObx3hFoGvo6+qCLoieRUgYfh1/XaLDdkbCHIOsmpSDyimKItJWfRB6WXx7d2Qs1cpYDjxXhh/N0x7Am7/nnELlQeGA1XH4as74PXBHFv7IBnVGcyPmo80myn/9FMyrp6P1OuJ/tc7eDr78t+j/8Vh2DDcrrsWAKd+NgtBDz4CIYRby7+llFuB64DPgbAuL1JR6UPqtmwGwHH6DP67M7PV1r4387R+w4VHwWzo0j/QQu8UQQhU52Opryf3j/ei9fUlfPly7KKiCHrz32j9/cl96CGMRUWtl+TX5ZNVkwWNg3EwDqfeVEdiaaLVsKGejtSTzkjvkV2GwQohmBw4mb2FezuYFFSAY98q0UI+g/tl+OqmahIKErgs7LKO/0e+McprSYqSZfzVHXB8Dcx9FYZf22GsgOAJBDkHcTB2Dtz+PQyayurMtdhpdFziPJashbdQ8sqrOMXFEbHmR1xihnPnsDtJKEoguSwZ38cew3nGDFyvvKJf3mt7ulMErwIx7Q9IKY8Cs1GbzKucI2q3bMUuNoZtVRpyKhpYPHco/q72JGSUWwu2JJIFd78jsA0OwlBQgDR3s8i6BUN1Hg0HD2Kpr8f/r/+Hzl9pUaj18CDkP+8h6xsofvnvrZe0FBlLywlmasgUtELL9rztVsP6uJnBtpTB7t07OacETqHGUNOnJQouCCoyIf8ADL++327RYhaaEz6n40mvaNBoYf3T8P5kyNgKl7wAE/7Y5Xhj/cayK383b1QeJm320/zk7MQsjSvGVT+hT0oi8PXXCf7gfXQBilP62uhrsdXYsiZjDVovL0I+eB+7Qf2XPd1Cl4pASrlcSrm3/TEhhK+UMkdK+Yd+n5nKgMdUXk7j4cO4zJrNkh0ZhHo6MmeYPxMiPEnIrLD2E+TtU6I6XPy6HhDQBYeA0YipqwxjANcgaKqmfvdO0OlwGGPtqLOLjsbj1lup3bwZY77iS9hTsAcPW19qajy4akQEY/3HsiN3h9V1ZttsAHw04UrlzC6YEDABgTgvO131Ky1lwjt5+u4rNmRvIMgpEO+P11nF8gOgtVUeNISA2c/CY8lw8aPdjvfg6AeZGjyVz1M+Z8G6hdRoNFxTcIqa+HjqA8NwmTfPaufhYuvC1OCprM9af053hN1FDXme9uMF7BNCeAghPM/ZDFUGLHXbtoGU5MaO5VBOFb+/eBA2GsGEQV6U1jaRWdYu1j//EASN63FMXbBim+/WPOSmyDQkxCuOOoeODUk8Ft4MQOWKFZgsJhIKE3CRw3C01TI12pvpwdNJr04ntza39ZoqSxpSCoYnr4X34hQHYid42HsQ6xVLfIHatK8FKSXGpG8U0597D2VGfiEtZqFbK2Oo+Phjyt59p6PQnT/AYykw9XFw7HkZDHAO4F8z/sXG6zdy/+j7uS54FnG1degTj7DFNpCk/OoO18wdNJeyxjL2F5+7xMLuTENlwMF2PweAIOBQ8797RAhxuRDihBAiTQjRafMZIcSNQogUIUSyEGL5mU1f5UKmdstWtIEBfFSow81Bxw3jlAV6QoTyBUxo8RPUFkN1LgT3rAhsg4MAMHQXOeQWjNkg0J/MwCmuc5+DLjAQl0suofLrb0jKO0CdsY6CwlBmDvHFXmfDtOBpQFtiEkBu/XEsTf4E528DaVEcjRnbOx1/cuBkjpYepdbQd2Wxz1cK6gq4ZfUCrrCrIjVqWutxk8XEu4ff5d5N99JkbupmhN6xJWcLJouRsRuU7mL18XsxFp4WxmujAxttJ1d3j6+jL/eNuo/nZ7+F0W40GoOJZK9w9mdVdJCdHjwdR60jP2X+9Ivexy+hO0XwJHACuFpKOUhKOQjIa/53RE8DCyFsgPeAuUAssFAIEXuaTDTwNDBFSjkM6H6fpTJgsDQ2Ur97Ny4zZ5GYV830wT442ipfwAhvJ7yd7dr8BPnNzyW92BFoAwNBiB53BA2ltmCROE7o2vnsefttWKqryfzqfwg0VJaHMWe44ksIcw0j3DWcdRnraDI3YZEWUsqP4W70xb0xB2Y8DZ6RsPIWJdrpNOIC4jBLM8fKjvX4ni5k4gviuWnNTWTV5GAG7shdxcasjZQ1lnHPpnv48OiH7C7YzZfHvzzre23I3sD0Um/EsZN43nUXSEn1j2vO/k2cRoVJSYzUeZk7VQT2Wntmh85mU/YmDObOe1n0Nd35CN4A7gaeFUL8SwjhwpmFjcYBaVLKDCmlAVgJzD9N5g/Ae1LKyuZ7dmO4VRlI1MfvRer12M+YSUFVI2FebXHUQghrP0HeAcWJF9B5bH57NLa2aP38ulcEzv40lNgjtBocRneenAbgMG4cdkOH4LEmHk+bSGyFMzOHtNUXunPYnRwtO8rv1v+OfUX7qDXWMqHFrzHiBrj9OyVnYdkNUGf90Y9yjwIgozqjx/d0ofLl8S+59+d78XbwZoXRnS9lAEM8h/L49seZv2o+SaVJvDTlJSYFTGJp0tKz2j3l1uaSUJDATfE2aH188Hn0ERwuuojq1av7vBF9zik9No4WbvM/zIGsyk7Hnxcxj1pDLbvyd7Ud7IOquF3RbfiolDJPSnkDsA3YBJxJVkMQkNvu97zmY+0ZDAwWQuxuzmK+vLOBhBD3CCEOCCEOlPZTqzaV3xa1WzajcXamMmoYFtlWoqGFCYM8KazWk1vRqDSi8RsGup6biwPogoO6zy620VJf5oRDqAsau86T00BRSKVXxOFf1ETo0WAujvbGxb4t1/L6wdfz7xn/5lTVKe7bdB8A84xF5IpA8IoE10C49SvQV8N6a8upl70XbnZupFWl9eo9XWikVabxyv5XmBw4mWVzPiW0IJla++EsDPk7k3zm4qr15d7otzBWj2WW7yKqmqr45Ngnv+heUkpejH+R2EIbvFMK8LzrLjR2drhdMx9DenpriZO+QEqJNjWZcl8vphr3YKyvJL20Y12rCQET8LDzaDMP1ZfDv4fBwf/12Vza06taQ83N5mcCl/Tx/bVANDADWAgsFUK4d3L/JVLKcVLKcT4+PqefVrnAkFJSv30HztOmklOrVArtqAiUOj57M0oV00ovzEIt2AZ1n0tgrqqiqRwcg7r/ekgpecf7CHWOGiYfLObyYf4dZC4Ju4TP536Or6MvPg7eTKtLYrNpJCZzc1173xiY9qQSH39ifet1Qggi3SLJqBp4OwKLtPB8/PM465x5aMQzfPTNRjRmPf9KceGBZUls3DGd1IN387fvK3ni60QWr6xkqMtUvkj9gtKGM39QXJOxhr2Fe3k4KRAbd3c8broRANfLL0fY2lK9qnOn/i+hLiML5/pqymMnYmMxMFGT0ql5SKfRcVn4ZWzL3aY0K4p/V3lg6CFP5pfS66JzUspGKeWZqMZ8IKTd78HNx9qTB/wgpTRKKTNRSllEn8E9VC5ADJlZmEpLcZw4kZwKpWNXmJeTlUy0rzMejjqyjh+BpppeOYpb0AUHYyopwWLo3P5av1+J1nDy6t7UsDN/J4k1qWQOi2Fc8UlmR3ceRTLEcwjfzf+O5bEPYGdpYqt5FIXV+jaBKY8qZY7X/gn0Na2HI90jSatK63PTxG+dL098SWJpInGud3LNO4mUnlCyrB+8/WbWPHQxqx6YwqoHprDh0Wlsf3IGs4b6cvDIBJpMBj48+uEZ3atCX8Fr+19jjj4K1wOn8LzzDjROymfNxtUV59mzqFm7FmkwIKXk+8N5HOhk4e4tyRuU4AH3y65F6hyZZXe8U0UAMG/QPPRmPV8lfQL7lihlNVqqoPYx/Vl9dD8QLYQYJISwBW4GfjhNZhXKbgAhhDeKqWjgPQKpWNGwT6lp6KQ5Rm5FA7ZaDb4u1iYaTXMYqT6rOZGspVhcL9CFBIOUrTkAHe6fsA9ha4ODfVGXHamklHyQ+AGBToFsd52Ek0mP/fGkLu/ppHPCP3c/Fhs79lpiWhUcoMSnX/2OUkdn8wuthyPdI6kx1FCuL+9kxL5Bb9KzNWcrz+x+hn/u/+cvH6jhly+O7SmqL+KtQ28xxHUs3+7wZ1q0D0+NaABHL4YMHc7wIDdGh7gzOsSdIf4uhHk58d4tFzE2MBpD1Xi+PvF1r30FRouRV/e9Sp2xjrv3OmHj5obH7bdbybhfcw3mqipqtu/guR+SeezLRB5ecRiDqedOZZ1RtieBWp0jY2dOQIROYpo2uUtFMMZ3DDNCZvBu0hIyZRNM//Mvumdv6DdFIKU0odQn2gCkAl9JKZOFEC8KIa5uFtsAlAshUoCtwJNSyv771KucFzQk7EXrYEaX9Da2eXsI9XREo+lYkuHmuBAimo5j0LooWZ+9xLY1l6ArRZCA4+BgBAaobzM1fHXiK5alLiO1PJUdeTtIKktirPv1bHYYhNTqqNvWeShoK6c2YQiZQhO21ooAlB3NhHth/3+hROmXEOmu1HhMr0rv9Xs7E5YeXcq0L6fx8NaHWZuxls9SPmvNkD4jEpbAaxGQevYRNq8feB2T2cSJ5MsYFujGu7eMwak0UVH0XZTlcLC14b93jsdPNxILFo4Wd+1XkVKyNmMtj219jGkrp7Eucx1/sp2HjD+I592/x8bZ2UreacoUNJ6ebP5wBZ/FZzNziA8F1XpWHekm/LibezudTKYkbAgOdjqImE6gMYemigKK2u8QmxFC8Nzoh7G3mO0ieIUAACAASURBVPhraBRm7/4pqwG9UARCCEchxDNCiKXNv0cLIa7szeBSynVSysFSykgp5cvNx55t9jkgFf4kpYyVUo6QUqoNWwc4Ukrq98bj6NuEsNFyW9GrDO7gNVKYPtiHiXZZJMkILPTQwrIdrUll+R39BMaCAppOncJxdHMZiObic7vzd/O3vX/jlX2vcOOaG3lwy4MEOAWwN3EQ4cHeOE2coCTAdUVFBlSkYzt0Djob0VERgJKkpNHBIcUhGOmmKIL+cBjvKdjD24ffZoL/BJZcuoRdN+8ixCWE1w+83iGj1WjpoqMbKHkQ6xcDEjY9C+ZuZFvQ18An8+Dgp1aHm8xNbMvdhm3jJDB58f6tY7G3NEDp8R53fG4OOv56mVI2+rujiV3KJRQlsHjnYpLKkpgTPoc3Z7zJtJ/ysfHywvPWWzvIC62WZN9ofNOO8ewVMXy8aDzDAl15f1s6ZsuZmexOnsjBv6YEh7FKc3sGKTkRkzTJ7OtiV+B9eAV/KavkqKWez1I+O6P7nQm92RF8AjQBk5p/zwde6rcZqQxoDJmZmCurcfI1IK9+B19zCb+vX9qprDA2EmHJYk/TIDalFvf6HlpfX4ROhyE3t8O5sqVLQafD7Yp5yoGaPAxmA//Y9w/CXMNYs2ANr0x9hVuG3sK8gEfIKG3iwVlRuEyfjiErC0N2duc3PbkBAE30pQR7OHauCJx9IOZKOLIcjHq8HbxxtXXtc4dxlb6KZ3Y9Q4RbBP+c/k8mBU7CUefIoxc9SlpVGqvTFeeo0WLk6Z1PM/ur2ZQ0dBLZXZkFX98J3tFw3UdQkd5hce+UdU9C9m7Y9JyVT+RIyRGazE0Ul4Tzxg2jCPVybM6xkL0y/U0JHwLAzqzjWLpYpHfk7cDOxo41C9bw/OTnmVjoTMPeBLzv+UOnpZ6La/Rssg/BS1/DrUECIQQPzIwis6yedUln1jMieb3iHxhyycXKAf+RSHt3putSOvc7VGZDwhLmhl7CJaGX8O7hd/ttd9gbRRAppXwNMAJIKRvgDB6/VFTOgBb/gGOIHRWRC/jQfCVjy39sXUitKExEI83kO8bw/rb0XjtVhUaDLjCwg2nIWFBA1Tff4n7dteiGNNcXqs7js5TPyK7JZnHcYsJcw7gi4gqeGr+Y9ftdiPBxYu7wAJxnTAegbnsn5qGcvbD5b8pi5hVJiKcjuZ0pAoCxi5R+vKk/KJFD7pGkV/fdl19KyYt7X6SiqYJXpr6Cvda+9dylYZcyymcU7xx+hwp9BY9seYQ1GWuoMdTw7uF3rQcy1MOKW5RG8jcvV8pCh0+Fba9AU5uNvqCuoLUpOwBHv4KjKyH2GuV97m9T8l8kbkJKDXeMnsllLRFY+QeV114oAgetA646b2pMhexJ79zCvDt/N+P8xmGvtUdKSenbb6P188P95ps7ld91qoxEb2Vn1rBP8UddPsyfSB8n3tt6Zo78hsSjmDQ2BE5o3hFobBCDpjJNm8K+04soVmTCp1eARoOY/Qx/nfhX3O3cSSnvXavMM6U3isAghHCgOZmsuTnN2edzq/Qao/mXOabOR+oTEtA6a9ANHkF2ZSP/Nl1PrdsQWHUfVJ9ml21eJMZOuYwjuVVtJSd6QWflqMuWLAHA+557wMEDdI4UVaSx5OgSZoXM4uKgi1tlNx8v4XhRLQ/OjMJGI7ANCcE2MrKjeSjvIHxxPbgGwM0rAAj1dCC7vKHzRSR8GngMggNKTHyEWwTpVb1Xcj2xOn01m7I38dCYh4jxsioujBCCJ8Y9QVljGVevuppd+bt4dtKz3BZzG6vSVlk3Yj+yHEqSlZ2AV6Riv7/0BWgog91KF7f0qnTmfTePZanLqNUbufblZRhWPwohE5Xroi+DPe9CUx3Z5fVsy96DgyWCv8wd3Xaf/IPK36MXdX0AojzCsLWvZFlCx51ZQV0BGdUZTAmagjSZKHr2ORoPHcL7vvu6zBfZnVaG3jcQrZ8f9QmKItBoBPfPiOJ4US1bjvc+B9YuO41K3xA0trZtBwdNx9tcgr4kjeqGZrNaeTp8eiUY6uCOH8A7Gi8HL9Zeu5arIq/q9f3OhN4ogueB9UCIEGIZsBl4ql9mo9KBn1OKGfrMeh5YdogjuVW/9nR6jdki2ZNWxk9Jhaw6nM/ao4U9RlpIKWlI2IejdwMiaAy5FQ0Y0FE+d4nSeOabu9ps0OXpkPABeEZy1eRReDvb8v623j85n64IjPn5VH37He7XX4euuQwFbsH8s+IAFmnhz3HWERsfbE8nxNOBq0cFth5znj6d+v0HMNc1JwgVJcEXC8DJC+78sbUy6vBAN6objZwo7iS6RaNRdgU5e8g5cZhI90iqmqqo0J99VE6doY43DrzBRb4XcWfsnZ3KjPYdzeXhl1NvrOe1aa9xw+AbuGfUPbjZufH6/tfbFNLxteAVBdHtUouCxio7g/h3oaaQ5anLMUszy1OX893BLP7S9CZ6k6Ti8veUej3TF0NjBaaEJdy3fBfY5XFdzEx0Nu2WpfxDZxQRFu4Whp1DBRtTiimpsXbAtmTpTvYaS97Dj1D19dd43ftH3JvzBk5HSsmutDImR3njOCGOhoR9re//6tGBBHs48Or64+iNPVcJLa5uJLgsF0vkaUENETMAxU+wJ70MilMUJWBsUD4zgW1Ksf3ura/pURFIKTcC1wKLgBXAuOYmNSrngA+3nSLSXMPOE8Vc895ubl4ST1XDuak/8ktJKajhuvf3cMt/E7hv2SEe/fIIDyw/xGvrj3d7nSEjA3NFBU6+jRAwmuxyxXziHzkCrn5b6Tnw8/PKl+WTucqX5fqPsdfZcEtcKDtOlVJZ37u/jS44CHN1NeZaZTEu+3AJAvD+Y1tt+TIXPzZaqrgj9g6CnNuS4ptMZhJzq7hqZCDadouW84zpYDRSv3s3Dfv3U/jYvZQctle+0K5tCmNWjC8Am5K78GuMvhWz0LLx81dZvlPZfPeFbfh/Kf+jqqmKP8f9GRuNTZdyL1/8MmsXrOXyQUqiv6utK/eNuo+EogSlx4K+WmkXOWRex4tnPQNmAzU7XuPHjB8Jcg4iry6P+P1vMU5zkpfMd/D6vkZFNngsMuoSmna8RVbNPhCSOZHt+gTXFCotQ89AEYS4hKCX1ZjR89UBax/Q7vzdhOn8sXn0Jeq2bsXv2WfwffTRLpsEpZXUUVLbxNRob5wmTMRcUUHTKaV8uM5Gw0vXDOdkcR1/W9OzuSbpaDruhno8Rp3Wi8IrCukSwHRdCoUHVsNHlyoFCRetURrwnCN6EzW0WUpZLqVcK6VcI6UsE0JsPheTG+gcyyjm0m/e4a3VL/D1hhf4LP8H7HZs5n+7Mq0FT26Aj+ZA7rkrW9sZTSYz/1iXylXv7iK3ooHXrh/JT49MZcvj07l+bDCf7MniZGdPwc20bL0dfQ0QOIacigb8XO2w19koT5px9yhPmx9dBkIDi9a1PjFNH+KLlBB/uq21C2xDlFzHrJsXkjZnDlXffIP7DTe0NqABSHRUQglbKom2kFlWj8kiGeLvYnXcccwYNC4u5D/xBNm330HVkQrKE22oP27tVPR1sWd0iDs/d+Hg/jHdyE+msdxku4vKciW56eVNW3nz55O8vy2dz/dmU99k6vTarqjQV/BZ8mdcGnYpw7y6b4xja2NLoHOg1bEbhtxAuGs4bxx4A9PJDWAxwtBOOmd5DoJRC1mV9j2Npkb+Oe2fuNl6UW+7nVqnMJzG38rKfTkcL6pBSslnuptwMlUxLSAeR60jw72Ht41VcEh5PQNFEOqilKieENJA6jdrWjO4jWYjCUUJ3JgfTOPhwwS+9iqet9zS7Vg7T5UBMCXKu7X4YEPCvtbzM4b48sdpESxLyOnRcZy/X4lkCos7rQm9EIhB05klDnJn9tNIr0i4Z6tSMuUc0l0/AvvmvgPeLT0Imn/C6VgzSKWPMVVWUnbvPUwpSMLpjjtxmTUL/6wUFh9YRulnnylmlrpS+Ob3sPxGyN0L21/91eZrNFt4YNlhPtyRwQ1jg9n8+HRuHBdCTIArET7O/GVeDM52Wp7/IblLe3fDvv1o3e3RebmARzg55Q2EebbLKL7sJSXF3skL7vrJKstyVLAbznZadqWV9Wq+jnFxOM+ahW1oKA7DR+B5++34PPyQlcwRrQWdlMQ2h3G2cLJYKf412M9aEQidDq/f3YXTxIkE/u2vRF9TiNbLmeJXXunQEe3SWD8S86opPs18cTSviie+TiTJay4ullq2XOuLrXAkozqDN38+xavrj/PMqmO8t/XMQkqXHl2K3qznwdEPntF1Leg0Oh4a8xBZNVnsTlkJjt4QPL5TWfPFj7LC2YExOg9G+IxgSMMgjjhB8eTf88ilQ3Gx1/HSmlSe/yGZ5w47keI2jVxLJuPdo9Fp2mo1nUkxwRZCXRVFcEfSzzy4ZQk/f/4jAEdKj1BvrGfk4Sp0oaG4XtlzBPzutDLCvRwJ9nDENjgIXVBQq8O4hSfmDGF0iDtPfXu06wAAoD5F2TW4DI/teDJqNrbSwEbzWJIv+9Jq93iu6G5H8EeUPgRDse5LsBp4t5vrVM4SY2EhGTfehHteBrtufYzQvywm8B9/J3r7dprGTeK6wz+yc/VqpblJ6g8w4y9KDHraJsV2fo4xWySPf5XIz6nFvHD1MF65biTujrZWMp5OtjwxZwh70stZ28nTkzSbaUhIwClAIgJHgVBi7UPa1xjS2im7gAcPKE+e7dDaaJgY4cWuU71TBFpPT0L+8x4h7/+HoDdex+/pxdi4WycsJJpqiG0yYFtvPeap4lpsNIIIH+uyFwDe991H6NIluF0UiNZO4nf3TTQdP07Vd9bdXS+LVfwFm1LadgUltXr+8NkBvJ3t+OPNShcux+o0YryjGRdtIP3v80h98XIuH+bP5/HZ1OitY/abMjKxNHWM4yisK+TLE19ydeTVRLj3WEG+S2aGzsTTzoNVVckw5HLowry0qyGfPJ2WWwqzKC/K4fa8I9hIyXfaRtwdbXlkdjS70sr4X3w290yLwPW2V8jRaZmUkwiNzX6wwkTFIe0/stfFBEExDQWXSgZtU57cy5evQG80syt/F171NtgdOYnblVd0aQ5qwWi2sDejnIujvVuPOU6cQP2+/ch22eY6Gw3vLFSe8p/69minY1ksEvusdGo9/TokrAEw/HqqFq7hAdMjbE7vvwqj3dFdGeq3mnsQPCGljGjpSSClHCWlVBVBP1Lyxr8wFJew+OJ7mXVPW1ib0GiIee1lpMYG/7efw2I2wR93wIynIO6PSjLSviXndK5SSv7v+yR+SCzgz5cP4c7J4V3K3hIXSmyAKy+vTe1g2mg8fBhzZSXOnqUQOBq90UxRjb5DsTlstEpzkE6YGu1NTkUDOeVdP5n1FqPZSHJjMaOamlqTylo4UVRLuJcjdtqu7ewUKeUmXG5YhMNFF1H65luY69q+5FG+zoR5OZK9ei2Fzz6HxWjkr98fo6rByNI7xuHpFwr27lCSQqR7JBnVGdhoBA62Njw4K4raJhOfx7dFxtSs30DGlVeS/6fHO+y4Pjj6AQD3j7r/rP4mOo2OK7xGsc1eR2XEjC7llqUuw9fei9l1dRiW38oMmcE0p2hWpf9Ag7GB2yeFMWuoL09cNpin5w5lX9UJACZWlcDqB5QCfB/NUXYDV711RnN01Dpy91YbjPZami67glG5SXy57iC783dzQ24AWCy92g0cya2i3mDm4qg2ReA0YQKW6mqajlv7ukI8HXlwZhR70ss51YnpM6OsjrDKvI6O4hY0GtyHTGVEsCdbT/w6lfh74yx+RwgxvLmT2B0tP+dicgMRQ1YWNevWsTF6Kl5xY4k+zfxgFxiA+YqJaIqNZDZdoVSvBCUiZfi1cHiZVRx3f/PVgVxW7s/lwZlR3D8jqks5S0MDNhrBi/OHUVit57tD1otr7aafETodTv71EDCavMqWYnO9r3w+pflLuzu9d7uC7kitSMUgTYzWNykOy3acKqnrYBbqQFESuAYhnL3xe/ppzOXllP77TaSx7Sn+wfydXPv9O1R99RXbvv2ZjSnF/OnSwcQGuipRS74xUHKcSLdIKvQVrZFDw4PcmD7Yh493ZdJoMFO3cxf5Tz6JjYcHdZs3U7Nmbes9agw1rElfw4KoBQQ4B5z13+WaBgMmIVhL55+xzOpM4gvjWRB9M2VhVxNQc5RyjTeLpiym1ljLO4ffQSMkHy8az4OzohFCEF8Qj4+DDxHTn4Hja+Cb3ynmoHu2npFZCKBu6zZi0w3snBNI7JOPoJGS7C8+4UTlCeKONmIfG4tdRM+7ol2nytAImBTRbkfQ7Ceob+cnaOH6scHobAQr9nVMUjx6ooDA+nI8Rg3vcK49s4b4kphXRXnduY/O742z+DngneafmcBrwNXdXqTyiyn7cAkWrY7PQqZw56TwjgINFYz12IjFV0Pd9wkYi9s9QcT9EQy1cGTFOZmrlJKlOzMZFujK45d1XQelKS2NkxMnkf/Ek4zxscPb2Y7EvGqrcWo3bcJpeCg2OgmBY1ojhkJO3xF0Q6SPE/6u9r02D3VHYqni3BtlMFk1mtcbzWSX13dQ0B0oSmqN+nAYMRz3G66nctkyTs2cRckbb1Dw5J8Zvn4F24JGY9HqOPzljwwPcuX3F7czefnGQGkqkW7KwnWy8mTrqQdmRlFeb2Ddyg3kPfwwdlFRRKz5EYdRoyh+6SVMzX07NmZtxGAxsCB6wVn/TZCSwek7iRUOrMpc16nIp0krENKGN7/3YOGJi2mUtlSOe4QxAXHcMPgGvkj9gvs330+VvorShlL+b9f/sT5rPdOCpyEmPQDj71ZqLt35Izj7ntn0DAaKX32Fan8XVo8yKAEBcROZlb6XoDKJc3oxrlf1Lg5/d1oZI4LdcXNs233q/Pywi46mfOlSGo8csZL3crZjzjB/vj2U1yGcNPegYjIKGNt1kyOAWUOVgIdtJ859z5Xe5BFcD8wGiqSUdwGjALd+ndUAxZCXR/UPP7Br6MV4BPszO8avo9DPz6HRV3L4pkexNejJ/7Ht6Y/gsUpd/n0fdlk1sy/ZcaqMtJI6fjdlULc218oVK5EWCzVr15J980Iutm/gWLum3U2pqRgLCnCJslPMIR7h7cpP914RCCGYEuXN7vSyLksM9JYjJUcIdArE12eYErbaTFpJHRYJQ7pTBMZGKDtpFf7n//zzBH/wPg6jRlH+8SfUrFmD1yOP8OG0RRz2imRUbhKvXjfSKhwVnxjQVzPSwQ+tRmtVEC5ukCeXepgJe/2vaH19CV26BK2HBwH/+DuWxkYKn38BKSU/pv/IILdBPUYK9YrCI1CTzzUBF3Oi8gSp5alWp8vq6/j+1Cos9SO4Z8ooXv79NYgnTxE172GEEDw76Vmen/Q8+4v2c92P13Hl91fyU+ZP/G747/jz+D8ru6Ar3oC5ryr+oDOk/KOPMGbnkLNoFkVNpTSaGglZdBteDXoe+EGAELjO6yTk9TQOZldwKKeS6e38Ay0EvfUWGmdnsu9cRM1P1j2Fb4kLpbrRyPpjRVbHG5IVR7FDbCeO4nYMC3TFx8WOLb+Ceag3iqBRSmkBTEIIV6AE6z4DKn1E+ZKlSKFhScBk7pseic3pFTdz98Ohz2DS/Uy+cSGlDm7kbY+3lplwL5SnKY7jfubjXZn4uNhx5aiuTQ6WhgaqV6/Gde5cQpYuxVRayu++eAHblKM0mZQnp5pNm0CjwdmrGAIUR3F2eQOOtjZ4Odl2OXZnTI32pqrBSEphTc/C3ZBYmsgon1EQNhny9oNJyU84VaKYRAb7deL0a6EkFaTZShEIGxtcZswg5L13idq6hYh16/C9715mDfUj3i+GoLoyok5PGms2+7lU5hDnH8eWnC2t9n9pMvFg/OdgkSQ98iJab2XRsouIwOeRR6jbvJnM5R9xqOQQV0Vc1aNztFek/ADChnnjHkKn0bEqbVXrKZPZwl1fLUVqGnkk7g7+fPlQpkR5Y+9s7YC/bvB1fDb3Mxy0DsQFxLFq/ioeG/sYjrozaX7YkcakY5S+9x9c5l6Oy3Sl3EdebR5NccMpc4WoYhMnAwZjcO8+Q7lGb+SRlUcI8nDgD9M6mpDsIgYR/uVK7IcNI/+xP1G5sq1O5sQIL8K9HFm+L6f1mN5oxjEngyZnV7S+3TfV0mgEM4f4sONk6TmvJtAbRXCguWvYUpSooUNAfPeXqJwpxsJCqr7/jn0xU7Dz9+OaMadF6Eqp1Kp38oHpi4nwcSYrIBq71CRr52DsfPCMgLVPKIk//URaSS3bT5Zy+8Swbp2mNT/9hKWuDo+bbsT54ikM+vYbcPfgif1fcPKkYnuv+/lnHMeMRFud3NqBKbeigVBPxzNewCZHKZ3Ldp6FeaiovojihmJG+Y6C0Elg0itPwyihozobQbh3x4ihtgGa+xJ0kRCk8/XFLkIxAS2aEo73pbMBqNu6xVqwxf9TksqskFnk1Oa09jAue/8DbI8fY9XM2/j3sXqrhcNz0Z04TpiA/uV/MTnFwpURvSoW3D1SwrFvIGIGbh6DmBU6i7WZa2k0NSKl5IUfU0jX/4ynbTB3j+u+keFw7+GsWbCGd2a90xrueTZYGhsp+POf0Xp5EfDcc625BDm1OWzJ38bmUcoyt85vFI9/ldhtuY5nVh2jsFrPmzeNsWo72h6thwehn3yMw9ixysNb83gajeDmuFD2ZVaQ1vzAkFxQQ0RVPpbIwb36LM8c4kut3kRCRt/0d+gtvXEW3y+lrJJSfgBcCtzZbCJS6UMqly1DWiT/CZjMH6dHYqs97b8mYxtk7YSpT4Cd8jQqR47Gua6Khsx2dVW0trBgieLg/Kn/KoF8vDsLW62GWyZ0/0WuXPkltlGROIxVkoJ0QUE4v/QPPPS11P3jJZoyM2k6lYbLYEclo3LkTYCStNUhYqgX+LrYM8TPhd29zCfojCOlyqI/2mc0hE5UDmYrXbJOFdcyyNvJugzC6RQlga0LuIf3eK+Rwe688IfZ2MXEULv1tIR9J29F8ZemMiNkBgBbcrbQcPAgZe+/j9v8+cy47zZyKhr4/nCbQ1vY2BD83rtkhNrx8A8WHLce7PV775K8/VCVAyNuAOCmITdR01TDI1se4cekbJYdjsfGMYe7R93SN7uPM6Dk9TcwZGYS+I+/Y+PuTrCLUmY8tyaXDVkbSJkdjvdDDzHh7ptZn1zEu1s6z8H4/nAeq48U8PCsaMaGeXR7T42dHW5XXoGxoABju4qzLU7j1zec5MPt6by9IYWw2iI8RnbvKG5h5lBf3Bx0rNyf07NwH9KrxjRCiJHNzWQuAqKEENf28rrLhRAnhBBpQojFnZxfJIQoFUIcaf65+8ymf2EgzWaqV//AqUEjsfgGcNP40yxvUsKWv4FrMIxr08Eh0ycDcHzTTmv5kPFKH9zEFXDMOn69L6isN/DdoTwWjA7C27lrW25jcjL6pCQ8brzJanEInzyOL0fMw33/TgoWKx8LF91hpRiZdxT5VY1klNUzPrx3hcZO5+Job/ZlVXSoNdNbEksSsbexZ7DnYMVh6RWlVBAFThTX9hwxVHwM/IcrdYN6icvMGTQeOoypstL6hM9QKEnFz8mP4V7D2ZX2M/lPPokuKAi/Z55hdowvI4LceGfLKatdQVJDGs9fZ6Rx+CAKnnqKmvXrOSuSvgatfWs28Xj/8bw45UX2Fu7lhX2P4xUYj52NHVdHnts4krrdu6lctgyPO27HabLyfXCzc8Pdzp1DJYc4UHyA6UPn4fPA/dw1aygLxgTxxqaTHMy2fuKuajDwzKpkxod78MDMyM5u1YGW+9XHtxlIvJ3tuHx4AOuTi/jHT8epSDmJzmLGc3TvFIG9zoZrLwpiQ3IRZecweqg3UUMfAx8D1wFXNf/0uNcUQtgA7wFzgVhgoRCiM2/Jl1LK0c0//z2TyV8o1O+Jx1RaylceI7h76iClpEJ7TqxTqjDOWGzlRBs7/SJqbB0p35NAB6Y9oTiO1zwGZX3b2GT5vhz0Rgt3XRzerVzVl18h7O1xm2+9OGg0glMzryEjaAj6xKPYDxmEzpAOY5TGINuanWUzh3ZvU+2K2yeGgYRXfuq+tlFXJJYmMsx7WFuWa+gkyImnoclAbkVj94rAYoGiY2dcJ8Z55kywWKjfeZpS942F0hMgJbNCZxG+/himgkICX30FG2cnhBA8ekk0uRWNfH+obVewJmMNONgzeOn/cBgxgqLnnsdc9QuLFppNkPw9DJ4D9q6th6+JuoYFwY/TpD2F3n4/l4dfjpvduYsjkQYDxX97CdvwcHz/9Cerc6EuoWzL3YZFWpgTNgdQggleXjAcd0cd/91pXaZl5f5c6ppMvDh/uLXDvht0oaHoAgOp37PH6vir141g/aNTOfr8ZXw+XdlZ2MfEdDZEp9w6IRSjWfLNwY6Nk/qL3rzjiVLKcVLKO6WUdzX//K4X18UBaVLKDCmlAVgJzD+r2V6glHzzHfW2DqRHjeK2iWHWJy1m2PKS8lQ6aqHVKTdHO/KDB3feK9dGB9cuAYsJ3h2rJOjsW3rWOQYGk4XP4rO4OMqbof6uXcqZ6+qpWbMG17lzsXHruDjEBrvzj9E3Y+PtjVuMHegclebcwNbjpQR7OBDp041DthvCvZ24e+ogvjuc3+HJryeq9FWklqcqjuIWwiaDvorcE4eBHhzFVVlKCO8ZKgL7YcOw8fHuaB7yHaqUI67OZaZ7HFclWKiOG4LjRRe1iswa6svIYDfe2arsCvQmPT9l/sSskFm4uvvg/+KLmGtrKX37nd5NRl/d3BCmmcztSsvO4ddbiRlMFrYcDMG7cRE+Dr7cFnvbGb3ns6Vi+XIMWVn4Ln4Kjb11Zc4Q1xAkkki3SKI82vJbHG213Dw+lA3JReRXKcXvTGYLn8dnMzHCk5iArj/TpyOEwGnKZOr3JliVEHG01TLU3xVXex36YsgPGwAAIABJREFUlBSEgwO2YWHdjGRNlK8LceGerNiX0xr9ZjRbeP6H5G7LWJwNvVEE8V08yfdEENA+uyKPzmsUXSeEOCqE+EYI0Wk0khDiHiHEASHEgdLScx9j25/UlldRu3kzO4PH8MHvJuNsp7UWSPoaSlJg5l+UrNrT0Iwcg091CWXZBR0H94qE++OVipBNtbDuCaWu/1mwLqmQ4pom63j3Tqj8/DMsDQ143LKw0/PDAt3I07mgWfE1nq77FSe3nQtNJjO708qYOcT3rGzND8yMwt/VnmdXJ/e6pWDt/7d33+FRVekDx79vyqT3hARCSEIndAggvQqyoKKgiGV1bWvBsvayq7vuWn6rq+u61rWBilhAAUEBKdJ7CYQOaQQIaaSXmcz5/XEnkJA2ASYJyfk8Tx5y79x751wuzJnT3rc0j/t+vQ8RYXzU+HMv2MYJ8g8b39ZrbRHUMVBcE3FywmfUaArWrEWVVoig2sr2X+/0fnznrcSjFH4aU7kiqtgq+GpTEsuSlpFbmsvUzlMBcO/SmYAZM8ieO5figwfrLsxPj8FHo2Dtm7ZB4nng5mvkD6jgm20ppGQV8eKYW1lxw690Dexa/fUcwJKVRca77+E1bBjetllCFZUPGE+ImlDltdsGGx/K5Suzf91/mtQzRdwxpPZ/09XxGjwYa14exXv3Vvt6Udxu3LvHIM61rEKvxs2D2pGUWciGo5mYy6w8Mncnn29ItDuWVn3ZUxHMxqgMDto+sPeISPVBNepvERCllOoFLAdmVXeQUuojW6skNiTkwroLmiJzmZUP/vExJkspsffeQp+I85LzlhbCipegTV+IqX5BUORoo59yz9IaEqf7tzO6iR7YYMQj2r/I6Gq4AEopPl53jPYhXozsXM1zsJbBsdVYsrLI/PgTvMeOxaNn9R+I3dsY37xydv1gfIPua3yb3JKQRZG57IK7hcp5ubnw/KRuxJ/I5estdQ+8FZgLuP/X+zmYfZC3Rr1Ved59QDR4h+F2YjMmFycig+qYMSTOxhqAevKZMAFrQQE5ixad2xlifLhajuwg64svOTWoPYud48krrdyyG92lFSM6h/DKzwf4LG4OUb5RDAwbeO4yD83E2deXtL//49wU1LKyqjNo8tNh3wJjkHrF32DRw8a/mW5Xg+u5b91FpWW8s+IwA6ICGNU5pMEHiNPfeQdrYSGhzzxd7Xt3DeyKi7icDaVdUbi/BxO6h/H1lmSKSsuYtSGRcH8PxnWr3wI2AM/BRgbf87uHAKylpZTs249Hr9oXklXnqh5hBHi6MntjIo/M3cmSPaf486RuzBh48bOsqmNPRfAJcBtwFefGB+xZnpdK5fUGbW37zrKFty4fEfkYsD/ebDPw5vJDRGxdTUloOMOuHV31gI3/NWb/THilxoHHHiMHUOxsImujHSGor3gAXDzOZpCqry0JWexNzeWuYdE4nb/GAYx+5NnXkvnqU1iLimj1p0drvFbHVt6YXJwIOvw9BERB5FDA6BYyuThVWtp/oSb3as0V7QN5Y9lB8msJ21xaVsrMFTPZm7GX10e8zsiI875hikDkYFqf2UmHEO+q6zsqSt4EwZ0rfWjay2voENx79CDj/Q/OhaLw8AefNmTOW4EqLibooQexWC38klh58FdEeHt6HwL90zmSG8+kqOsrfUA6+/sT8uijFG7bxslnniHpjj9waMBAkn9/e+XKYNdXRojp2xfBsMeMdSsluUYY8Ao+XZ/A6bwSnhjfpcErgeKDhzjzzbcEzJiBW8fqw5qMjhjN8huWE+1X/bf8PwyNJqfIzP/9coCNxzK5bXCk3WMDFbkEBOAW042CDVVn1JccOIAym/HoVb8wGWAMGk/t15Zl+9LOVgJ3D7/wgIF1sefO05VSC5VSCUqppPIfO87bCnQSkWgRMQE3AQsrHiAiFVciXQNUXqrYjGXml7B42Q56Zxyl7U1Tq/5nyj0J696CbtcYfdQ1cHV3Iz2iI14H99adztArGPrdBnHfVE37aIdP1iXg7+nK9X3bVn/AsVWYC5zJXrIevynX1vifFIyojUNCSojK3Qa9bzY+bDEGige3D8LDVL+mdHVEhMfHd+FMoZml5632rOjbg9+yLW0bfx/6d8ZF1jAHvt1ggsrSuSKwluiQh5cbU3z7VN8dZk95gx94APPx4+QsPNcqKHGOJntTKn5TptC730R6hfTi/V3vU2iu3F8c4GXiij6HUFYXVm1vdzYWfzn/G6bh3rMnOT8txpqbi0ef3hRu3XouXILVaiSfbzfEWMMw7kW45r/G2ED0ucoxI7+E91cfZVy3UAa1D7qge70Y6e/8BycfH0JmPljjMSJCsEfNXyYGRAUQ09qXzzck4ubixPTYC18j6z1kCIW7dmEtKKi0v2i30XHi0bv+FQHArVdEEuzt5vBKAOyrCHaKyBwRmSEi15f/1HWSUsoCzASWYnzAf6uUiheRl2xTUQEeFpF4EdkNPIyRBa1F+HhdAsOPGbN9fK+uZsrdqn8YA71X/q3Oa7n06UvbrOMcTaoh41VFg2ca8/U3vVev8iZmFLB8fxq3Doqs+UM6YQ3p+wNBKUJ+V3cf+VQPI/GIsg0SJ2YUcCyjgDFd699Er0lsZAARgR78uKv6iq/QXMj/9vyPgWEDa80He8jdmP43zuNw9QdYSox1G0EdYdCFj8N4jx6Fe0wMGR9+iLJYMKedJuXbNJxcrIQ8eD8iwpOxT5JelM6nez+tdG6BuYCNacvpEziKzUeK+XDNsUqvi7MzkV99SZdtW4meP4+277yDk48PWbNnGwck/AbZCZWmKNPvNpj2SaXxqbeWH6LIXMYzExtuTKBcSUIC+StWEnjLzVXChteHiHDH0CgArusbTkA9V7BX5Dl4MJjNFG6vvF6jKC4Ol5AQXCokO6qPqGAvtj4/1uGVANhXEXhgJKsfTz2mjwIopZYopTorpToopV627XtBKbXQ9vuzSqnuttDWo5VSFzbf7zKTXVDKt78dYFrSBrxHjsTU9rwx9FN7jCiig/5orBKuQ/SYYTij2Lxwdd1vHhBpNPO3fQaF9s2osVoVLy/Zj4uT8PvBNcx+yE6k6OhJco6aCOjhhOuBT4yBxloMLFrDfmsEqS5GC+PstNEul64iEBGu6xPO+iMZVZLAAMw5MIes4iwe6vtQNWef89lhT06oIIbsewl+fqbq392m9yDrqC1OzoV/qIgIwTMfxJycTPacOaTccw9lhRYiRmbi6m70opbnFZ4VP4tTBedaOouPLabQUshTQ/7A8E7BfLExqcpAuZPJhJOHEd/fycsL/2nTyFu2HPPJk7D9M/AINFqhNTiclsfXW5K5ZVA7Ora6sFldFyPr81mIqysBt9xy0de6tk8b7hkezcwxNbdc7eHZvz9iMlGwvvI4QVHcbtx797qorrOG6nazZ2XxH6r5sWf6qFaDT9cnMObgWtyL8gmurnm7ey44m4xVxHaIHD4Is4srGStW25VIm2GPgrnAmE5qh3dXHWH5vjSendiNVr7V932XrJ1Pym+BuIaGEHTf/cZK1IQ1NV809yStsnfxc9kg5u8wktv/sDOV9iFetKtHoDl7TOkbjlXBwl2VZ1blluby2d7PGB4+nD6t+tRwNuQVm1kQl8anXT9G+txsBPV7uw8s+zMkbTTyFfz2OnSZBB1rD69gD+/Ro3GL6UbaK69SkpBA+D+ewiPQbKwnsXm0/6NYlZX/7PgP5jIza4+vZVb8LLoFdqNncE9uGdSOU7nF/Hao9gBmAbfcAkqR/fnHRkL6PjfXOr7xypL9eJlceGRsDbH1HciSmUnODz/gN2UKLkEX3yXl5uLM85NiaBtwcf/enNzd8YztT97qVWeT1liyszEnJV/QQHFjqC1V5VO2P98Rkf+c/9NwRWxecgrNfL36IDMS1uA1Yni1s2rUkV8pbDfIGCi0g5OHB6r/IHon72bhTjv6/kO7Q9fJsP7tKklXzrfyQBpv/nqI6/qG8wdbU/p8pcePk/z3WeDsRLtZs3EZfg94h8Ka141MU1v+B4sfN0IUlNu/EEGxXAbz5vJDPDhnB7uP5zCp58XHzD9f+xBvekf4VwrDAPDFvi/ILc2tszXw464TFJaWcfWwfnDNf+D+DRA9HDZ9AJ9dBW/3NrrxJrx8ScorIkZSdQ8P2rz6Kt6Tb4EOY2Dtv85m8Ar3Due2mNtYdGwRI78dyQMrHiCrOIuZfWciIozpGkqwt4m51cTHr8jUNhyfsWM58/08rKVl0L/m6DG/HUpn1cF0HhzTkaBaVpQ7SvZXc1BmM4F33NHg710Xv+uuw5yUfLZVULzHmEZ8IQPFjaHqxPRzygdutzVEQVqK/609xqiDa/AoyifkwWpaAzmp/FiUwqs+pSwuTCfE075plO2unoBp8zo+/3ENNwy4pe4m5YSX4d0r4JdnYfoX1R6SkFHAI3N3EdPal1eu61ntNS1ZWST/4U6spSVE3tvn3MKZwTNh+V/gwwqJ39Pi4Y7FRorDfQuwhnTlT+P74e3UmmBvb3zdXQn1dcwHzHV92vDXRfs4eCqPLmE+ZBdnn03m3i2o5qmeSim+2pRE9za+9GprWxjXqhvc9BUU58KRX+HQUogaWiV95sXwHjGCLps3ISZbN9O4vxl/l+veOjtudHfPu9mbsZdQr1DGR45ncJvBmJyN400uTkzt35aP1yZwOq+YVj41f8sPvGUGecuXsz+1M6okhOqCIeQWm3l2XhztQ7y4o5YsdI5iLSoie84cvMeMORuwrynxnTCBtP/7J9lffon38GHGQLEI7j3sCy3R2GpLVVk+baFQKTWr4g/gmOVtzdyulDN8vmIfNyeswWvYMDx6V9NsPLqSH3y8KFIWliYutfvaPqNHo0Ros28rqw/ZseguIMpYX7B/IRz+tcrLhaUW7vtiO85Owge39q80QFxoLiQ+Ix6AnAULMaekEDE8A/crJp67wMB7YOwLMPUTeCQOpnwAyRth03scPr6RN3PjmeAHj2+4nZ158+kc6kOYn7vD+kSv7t0GZyc52yr4PP5ziixFPNin5pknADtTznDgVB43D2pXtWzuvkZWuOs/hH6XPmnf2UoAjExdvabD5g/OtuK8Td58POFjXh72MiMjRp6tBMpNj42gzKqYt732VmJa/l7c/M1kxjtz9TtrefK73WfjNFkyMshbsYKXFu0jLa+EN2/sUzUESgM488MPlJ05Q9BdTbNXWkwmAm68kfw1ayhNTqZo927cOnbE2buWNSdNiD2Dxc/auU+rRUGJhUfn7uSGE1vxKMwj+MHq88eePLSEnbbl8j8n/lztMdVxCQrCo08fRqTt4+O1x+o+AWDIQxDUyVhxbD43kKqU4tn5ezh0Oo//3NS3SpawL/Z9wU2Lb2J96nqK98ThGuyLZ7AZoit8+3f1MBaw9ZxmDFD3vgm6TmbJxteZtuJevvDzoVNgFyJ8Ith8sppYSZdYkLcbIzuHsGBXKukFGXx94GsmRk+kg3/tAcbmbE7Gy+TMtX2qWxTfwMY8b8z4WvWKXYe3D/FmYHQg32xNrnFqcVGJBeuG/2Lp5EZI7hmejizjx12pjH5jNR/8dpSTr7/B8Qdnsn7NLh4Y1aHqoscGkvPjAtxjYvDo27dR3t8e/tOng7Mz2V99RdGePbhf4LTRxlDbGMFEEXkHCD9vfOBzoObVOVq1Xlq0j6SsQqam78ajXz88q/sHbS3jl3SjJ25qp6nEpcdxPM/+wFO+48YSmX2cw3GHK2UAq5GLG0x6w5gyuPZfZ3fP3pjEgl0neGxcZ0ZUs4J48ynjg/sv6/9Cwe7duIc6g187o5VRExGW9bmO54J86VtUzMoCD9773WzGRY5jT8Yeii0XFim0Pq7rG87JnGL+sf49SspKuK/3fbUen5lfwk9xJ7imT3jV0B+Nwb8dDLwXds0xkt/YYcbACBIzC9lUHt8+/kdjMoLNd999QQdrIjLtXsTdnWtP7mD5n0YyuEMw/12wg6yfjAHq6/MO8dCYhh8gBjCfPk1xXBw+48c3+OK1+nANbYXv+PFkz/kaa07OZTM+ALW3CE5gjA8UYySkKf9ZCFQN4KHV6Je9J/lmWwpPxrjjnHQM36uqLnsHIHUHP7s50cOzDff0usc4N9H+8ME+Y40EJ0NP72f+DjsXjLUfBb1uMgZ2Dy1jR3I2/1i8j7FdW/Hg6KrT6krKSth9ejdD2gzBkplFWeoJPDxOG62Bav6TKqUwl5n5NelXnt7yMr18ongvLZ2AGGMpSmxoLBarhT0Z1QTOu8QmdA+jlX8Jq04sYHL7yTWuOi330dpjlFqsdcZValDDHzfGWCp8mNdmYo/W+Lq78Oz8OFbGJaIWPgQ//BH1y3MsiUsl6uAn5LkE0WnSffhOmEDu4sW083Li49tj+TTsFKYyM5nuvkw+c6BqjowGkr96NQDeY6pZfd/EBNx669lV4dV2/TZRtY0R7LaNB3SsMDawECOiaHZN52mVFZWW8eLCeHqE+zKtwAgH7XNl9VMMEw/8wH43E1d1mkK4dzi9Q3rzc4L93UOmqChMHTowPusgq+uYNljJ5DchrAdq3l38b/4vtPJx580b+1QbRiIuPY5Sayk3d72ZhzyMMYHdrYordwsBy5OWM2LuCHrP7k2/L/vxp9V/IiYohveunovn7xfB0IcBY068IGxPuwTJU+pgcnGiU+dtWLEwrnXt89Az80uYvSGJa3q3aZT58jXyDISoYZWmktbG3dWZD27rj5OT8NPc95GSXA77DEI2vYvPdzcywnkP7kPvBxc3/KdNxVpQQN6yZSirlaAVi3Hv04eIe/4AB/ZhTq3/avRLIX/lKlzbtsWtU+O0SOrDo28f3GNiEE/PWlfWNzX2VPHLRcRXRAIx0lT+T0TecnC5mo3PNySSllvCXybFULBiBe49e+Lauvopkr+krEQUXNXJ+LY8MXoih7IPcfTMUbvfz2fMGCKPH+B0ajpJmQV1nwBg8oKbvsYirjyZ9VceHhqCn2f1afq2ndqGkzjRN7QvI3JbYxV4qYsv36ozmK3GN6Ev9n3B46sfJ9w7nHt73cvDfR/muUHP8cGVH+Bt8jamXpqMQTRfky+dAzo3SEVwuvA0BwqWovL6s2SHudZjP1p7jBJLGTMbqTukVl0mQcYhyKhhlfN5hnQIZumjI3gqdBvJhHJ19iPMC7yX4c57Ua6euA66CwCP2FhcI9txZt58CjdtojQpicCbZ9D6aiPhe+4yx+fBPp+1sJCCjRvxHjO6SXcLlRMRWr/6KuH/eqPeEUcbkz0VgZ9SKhe4HpitlBoEjHVssZqHM4WlvLf6CGO6tqKfewnFe/bgM/7Kao9VhVn8XHaGfu4hhHqFAkYIXSdxYkmCfd/+AHzGjkGsVq44Fc+qA/VoFfhH8E7Ii0Q4pTP1xBs1HrY1bStdA7via/KlJD4el1aeRDjB33f/lyk/TuGpNU/xz63/ZGy7sXx21WfM7DuTe3rdw4yuM/AxVR++uX9of3an7z5bkZzPYrVQZrVjoVwdViavpNRaypVtbmLBrhOczqt+XKLJtgbKdbHNzjqw2O5TXM8kEJa9jTaj7mHXi1cx9eHX4ZbvkWmfGq0MjA8x/+uup3DLFk7/+22c/f3xmTABU7t2uMV0I2+p/bPYLpWCjRtRJSX4jBnT4O99ody7dMZndNPvxqrInorAxRYc7kbgJweXp1l5f/VR8kssPHVVF/J+NaZo+l5ZfUVwKP4bjplcmRh5LuZ7sEcwA8IG8EvCL3UHlLNx79ULU4cOzEhYw+r9dsQesjmZU8S7R0PYGzwJl4TV1YaHKB8fGBA6AKUUxXF78Am2MtvUgf+O+S/uLu78nPAzt8Xcxhsj38Ddxb4InP1D+1NkKWJ/ZtUBUKuyctfSu5i5cqbdfwc12ZOxhyD3IB4aPhiz1cqXG5OwWhWbj2Xy2s8H+HJTEntTc3h/9dGm2xoA8I+AsF52dw8BRlRRccKl3y3npn92uvJcpWLjN+VacHKiOC4Ov6nX4+RmrOvwHT+Bol27MJ+qOXifI+StXImTjw+e/VtUYOIGZ09F8BJG4LijSqmtItIesK9N2oKdOFPEZxsSub5vW7qG+ZK3bDlunTtjioqqerDVyuq4WYhSXNmr8jzpSdGTSM5LZl3qOrveV5ycCJn5IG2yT+K8diVFpTV/kzZbzeSW5pJWkMa7azchplTy27fltDmv2jhE5eMDA8IGYE5NpSw7Gw+vTCSsFyMjRvLd1d+xaMoinhrwFM5O9jeL+4Ua2baq6x5amriUHad3sC51HatSVlV5vT72ZOyhZ3BPOrTyYWzXUD7bkMjIN1Yx/aNNfLjmKH/+cS+T31nHx+sSmm5roFzXSZCyBfLtaPWVWYyZRh3HgW+bWg91DQvDa9hQECFg+vSz+30mGF9Q8hqwe0iVlZG/ajXeI0YgrtV3VWqXhj2xhr5TSvVSSt1v2z6mlJpa13kt3du/HgYFf7qyE5aMDAq3b8enhtYAe78nsfg0oSY/Ar0qB1yb1H4S7Xza8c+t/8RcVnu/djmfCROwREYzPf4XNhyq+g3OXGbm7mV30++Lfgz9eijjvh/HgsyH8Yj+Dw+k/8SMNqEUnY6vct7WU1vPjg8Uxxkhdt39C89m43ISJ6L8ouwqY0XBHsFE+UZVqQjMVjPv7HyHTgGdiPaL5q3tb9XYfVSX3NJcEnIS6BlilPX+UR0oMVtpF+jJmzf2Zu9fJ7DmydG8fVMfHhzdgWcm1j+xTIPq8jtAwSE7ZpUdXQF5J6HvbXZdOvSZZ2nzxuuY2p1LguIWHY1b587kLmu47qGiuDjKsrIui9lClzt7ktd3FpEVIrLXtt1LRP7s+KJdvjLyS/hhZyrTB0TQNsCTvBUrQSl8xo+venBpIfz6V1I8fWkX2KXKyyZnE08PfJrE3ETmHJhj1/uLkxPhjz5MRH46id/+WOX1f+/4N5tPbubWbrfyZO8/8X8/R/Pe2658sDCK93b1wOe0M18d+qbKeVtPnRsfKNqzF3F1wd3fDKEXv4y+f2h/dpzegVWdi6E//9B8UvJSeLTfozze/3EScxP5/tD3F3T98pXQPYKNsvaPDODgP67iq7uv4Pp+bfFyc6FdkCfX9gnnyQldCfOrf2KZBhXW01i7ccCO7qEds8EzGDrXMG35PG7to/GbNKnKfp8J4ynavgNzmv1djhcjf+UqcHHBe/jwBnm/lsyerqH/YawkNgMopeIwksxoNfh2WwqlZVZuH2LE3clb+guuke1w61xNn7MtC1mKmycRvtWnoRvRdgTDw4fz/u73ySiyL2dpwFUTSAuNpOPPc7Gaz32LXnN8DbP3zWZ6l+k8Ffsk/T/cRfSuw5wM7UJrZSJk5X5enGth9vH1nCk+c/a8krIS4tLjzqY/LNoTh3tbP8TVZGTkukj9Q/uTV5rH4Wyj17HQXMgHcR/Qr1U/hocPZ0TbEQwMG8j7u96vkqbRHuXrFMorAmi4EL8OIWL07x9bBaW1zA7LPQEHfzZWdl9EeGwAv8mTQSlyFi6s++CLZMnO5sx33+E1ZDDOvvYnlNcujD0VgadSast5+/TK4hqUWRVfbUpmcPsgOrbywZyWRsHGTfhNmlxNFrITsO4t8rtOIsucR4RPzVmSnhrwFCVlJby1/S1O5J9gR9oOVqesxmKt/lGICPkz7qRVXgaHv/gWgLSCNJ5f9zydAzrzROwT7HrmRZxWLef7/lOInf0/2s+fR8QH7+NeIvQ4aOajPR+dvV7F8QFlsVAcvw/3YKuRU/ciP2DAqAgAPtj9AbPjZ/PqllfJKMrg0f6PIiJGtrHYx8kuyeaTPZ/U+/p7MvYQ5RuFr6kZfah0/R1YiuGDYfBmDLwSXjW0+PbPjbAUA+666LczRUbi0b8/OfN/uOiB+7qc/te/KMvPp9UT9oVi1y6OPRVBhoh0ABSAiEwDTtpzcRG5ypb0/oiIPFPLcVNFRIlIrF2lbsJWHzxN6pmiswlcchctAqXwu7aaZB9r3gCrhZRBxgBxuxpaBABRflHcFnMbC48uZMK8Cdz+y+08tPIh5h6oeYVp3+mTOeTflpPvf8i0d9cx9ftHyCspohP3s/jZt3Bf+D2reo7l7ndfoH2IMTDqOWgQrv4mbtwJcw/MJSUvhRVJK3hl8ys4izN9W/Wl5OhRVFERHl4ZZ8cHLlYb7zb0a9WPFckreH3b6/x45EfGRIyhb6tzoThigmK4MvJK5h+eX6/ppEop9qQbA8XNSuRQ6HkjBHcxVogHRsPKv58b6LeUGhVBpyvtSnBkD//rr6M0IYHi3bsvyfWqU7hjBznfzyPw9t/j3vniW5ta3ewJoPIg8BHQVURSgQSgzvRAIuIMvAtcCRwHtorIQqXUvvOO8wEeARwfeawBzN6YRKivG+NiQlFKcebHH/Ho2/dceOZyxblGmIAe00gW40OtthYBwH297iPQLRBvkzdhXmH8L+5/fLb3M27ocgNuzlXDN4cHeLLppt8T+sErdE/4lYM94zHlXMPm7ce5ZfmX7O3UnxmfvUGA97n+cHFywn9oJ8yL4wnLhqkLp1JkKTIGrEf8Ex+TD9k7dwJc0ooAYNbEWZRZyyiwFJBXmkeIR9U4R+OjxrM8aTlxGXGVKonanCo4RWZx5tmB4mbD2RWmVmgBpMXD+0ONuFETXjYiy+anwYB7Ltlb+ky4ilP/eJkz83/Ao0/NyXwulDKbOfXiX3Fp07r6MO2aQ9gza+iYUmocEAJ0VUoNszN5/UCMcBTHlFKlwFzg2mqO+zvwfxgxjS5rSZkF/HYonRkD2+Hq7ETxvn2UHjmK37XV3HbcN0aWsAF3kZJnJA+pqyLwdPXkjh53MK3zNIaFD+P+Pvdzuug0C44sqPGc6x++BVP79kzcvQwXcWbZPY8xq2Adrt5eTPns35UqgXJ+V40CUTye0oUOfh14bfhrLJiygPFR41FKkf24kXJ5AAAgAElEQVTNt5jaheHqXXZJBoorcnZyxtfkS7h3eJWwygBD2wzFxcmlXlNJ4zKMGU7NrkVwvtDu0OcW2PIRZCfB1o+NQICXIGtaOWdvL3zHX0nukiVYiyv/l1VKUbBhA6lPPUXxfvuC4p0v87PPKTl8mLDnn8fJ89JmqtNqZncUKaVUgVKqPqN04UDF9EjHbfvOEpF+QIRSqtYlkiJyr4hsE5Ft6el2xNpvJF9tTsbFSZgx0OjiyV24EHF1xXfiebM1lIJtnxqLgsL7k5KXQqB7IF6u9YtdPihsEL1CevHJnk9qnFYpTk74330nfinZ/D6nB6YNuyhYv55WD83ENTi42nNcO/XFu3UJEeuOMeeqL5jUfhIuTkbjsXDzZkr27ydodGcjxlxYwybe8DH5EBsay+qU1XafszdjL65OrnQJqDorq9kZ/RyIE8y/x8j/EHsXOF3aYHF+112PNT+fvOXGIkmlFPnr15N0y60k33kXuQsXkXTb76skc6+Nslo5/da/SX/zTXyuHHc2gKLWMBonnCAgIk7Am8DjdR2rlPpIKRWrlIoNCbEvY1dDs5RZ+X77ca6MCSXU1x1lNpPz02K8x4zB2c+v8sHJm+D0PmMAT4SUvBTa+dQ8PlATEeGPvf7IiYIT/HS05kXf23t5ctoPxq7IJO3V1zB17EDAjBk1Xzi4E/7tCynLziV/TeW8w5mffopzUBC+UaXgFwEeAfUu98UaFTGKhJwEknLtaZgaA8XdArvh6twCFiX5hcMV90PKZnBxh763XvK38Bw4ANc2bTjzzTdkffElx66+mpS77sZ84gRhL75Ah6W/4BISQvJdd5P/2291Xq8sL4/j9z9A5ocf4n/DNNr86191nqNdWo6sCFKBin0dbW37yvkAPYDVIpIIXAEsvFwHjDcczSSroJQpfY1GT/769ZRlZlY/SLztE3DzhZ43AJCcm1xnt1BNhocPp1tgNz7e8zFZxVmk5KZwMOtgpdlE8xMXsHq4H64HEjEfP07Yc8/VvlLTKwTvaBMuvm5kf/nV2YTcJUeOULBmLQG33IxTZvwlHR+oj1ERowDsahVYrBb2Ze6rNG202Rv6KHiFGInobXGELiVxcsJvyhQKt20j7eWXcfLwpPXL/6DDsqUEzJiBKTKSyC+/wNQ+mpQHZ3JkzFgODR/OoaHDyHj//UozjswnTpA4/Sby168n7MUXCHvpJZxMFz8LTaufOgeLRSQOo3//G6WU/WEwYSvQSUSiMSqAm4Cby19USuUAZ/smRGQ18IRS6rLMkbw47iTebi6MtCVyyVmwAOeAALyHDat8YEEG7FsA/e8AkxfFlmLSCtOI8L2wiqC8VfDo6kcZ+c3Is/t7h/TmjZFG8LgNqRv44w1/wGXbQjz69MFryJC6LoqEdCAw1srplRs4PvMh2vzzn2R+/jni7k7AtCnw/vMQU92Qj+OFe4fTOaAzq1NWc3v322s99uiZoxRZiprfQHFtPPxh5jZwdVwfe+DvbwNnJ7xHjsKjR/cqr7sEBRE5axYZ//0vZTm5iKsr5lOnSH/7P5hPnCTsxRcoTUgg+e57sBYW0u7TT/AaONBh5dVqZ8+soauB6cC3ImIFvgG+VUol13aSUsoiIjMx4hQ5A58qpeJF5CVgm1LK8atSGkipxcov8ae4MiYUd1dnVGkpBb+twffqqyvnnQXY+SWUlRp9t0BqvtFIutAWAcDodqN5cfCLlJSV4GPyIb80n7d3vM2Ni26kf2h/FIprYqbRZtHdZ4OI1SmoE4EdNyKDnyfttddIvGk65qRk/KZNxcV80pib3kgtAjBaBZ/s+YQzxWfwd685fWJ52IpmP1B8Pg/HppR09vevc1aPs48Poc+ey2qrlCL932+T+eGHlKakULx/P04mE5Fffol7Fz1NtDHVWRHYZgj9E/iniHQC/oIxy6fOqGJKqSXAkvP2vVDDsaPsKG+TtP5IBjlFZib3MvIMFO7YgbWwEO+RI6seHP8DtB0ArboCnJ0xdCFjBOWcxIlpnadV2je4zWAeW/0Yvyb/yqCwQfWvaII6Inu+I/Chqbh1aM/xPz2GslgIuv12SLUFHmvggeKKRrUdxUdxH7E2dS1Xd7i6xuN+PPIjnQM6X9Tfr3ZpiAit/vQoLqGtSPv7PzBFRhLx8ceY2jaBfNAtnF2JWEUkEqNVMB0oA55yZKEuN4viTuDj7sKwTkZPV/7q3xBXV7yuGFT5wNyTcHIXjH3x7K7kXKNhdak/qKL9ovnqd1/xefznZ/vU6yXItoYw6xheQ4YQPW8e5pRkTOGh8MPbRmsgoPFSOHYP7k6wRzCrU1bXWBHsy9zH/qz9PDvw2cs7nEQzE3jzzXjGxuLaujXOPtXnqNAalj1jBJsBV+A74Aal1DGHl+oyUmwuY3l8GhN6hOHmYjSS8teswXPgwKrzoA/bIjdWCP6VnJeMj6sPfm7nzSy6BDxdPXmgzwMXdnKwLS5SxmEI7Y6pbbjxzW3tm5CTAlPeqzZHcUNxEidGRYxiybElFFuKq819MO/QPNyc3ZjcYXIjlFCrjV4x3LTYM2vo90qpfkqpV3UlUNXawxnklVjOdguVpqRQeuwY3iNHVD344C/g3w5anQtxfDzvOBG+EU3vG2tgB+PPzCPn9uWfNiqCLpOq5ChuDFdGXkmhpZD1J9ZXea3QXMjihMVMiJrQvOILaZoD2FMRnBGRT0TkZwARiRGRi49g1Uz8FHcCf09Xhna0dQvZ5t1XGR8wF8Gx1UZroMKHfnLehU8ddSg3b/BpA5kVJoqtehksRXDlS41XrgoGhg3E382fpYlVY+QvTVxKgbmAqZ106gxNq4s9FcHnGDN/ylMbHQIedVSBLidlVsXK/acZHxOKq7PxV5n/22+YIiOrxhZKWGN8iFboFjJbzZzMP9l0BzKDOsDxrbDjC9j4rhHXfuC9ENyxsUsGgIuTC2PbjeW3lN8otlQOd/D94e9p79fe7nhEmtaS2VMRBCulvgWsYEwLxRgwbvEOpeWRV2JhcIcgAKxFRRRu3oJXtd1CP4PJG6LOrSs4lX8Ki7I0zRYBQJu+kHkYFs6Epc8ZLYQRTzZ2qSqZEDXB6B5KPdc9dCj7EHHpcUztNLXpdblpWhNkz6yhAhEJ4lwY6iuAHIeW6jKxM9lI3NI3wgizULhlC6qkBO8R53ULKQWHlkKH0eBybh6/vcHmGs24v0LsneDkYvx4BIBr08rcNSBsAAFuASxNWsrYyLFYlZV/bfsXbs5utU4r1TTtHHsqgseAhUAHEVmPEYV0Wu2ntAw7krMJ9DIRGWTMDsr/bQ3i4YHngPOiZJyKg7wT0Llyhs/kPGPqaJOtCJycjRj3TZiLkwtjI8ey+Nhiii3FzIqfxYYTG3hh8AsEuDd8HCRNuxzZs6Bsh4iMBLoAAhxUSl1YBvFmZmdyNn0j/BERVFkZeatW4TV4cOXVuwUZRt86Ap0q5yxOyk3C3dmdEM+mGUjvcjEhagLfH/qet7a/xdyDc5nUfhLTOunvKppmrxorAhG5voaXOosISqn5DirTZeFMYSlH0wu4vl9bAArWrcNy8iR+Tz8N1jIjU9SeeZBji8TR8UrwrvyBvz9rP50DO+MkjRYEtlmIDY0lwC2AOQfmEO0XzQtXvKDHBjStHmprEZR3sLYChgArbdujgQ1Ai64IdqWUjw8YMV2yv/0O56AgfIZfAd/cBgcXQ+eJMPAeCO8H4ZW7i8qsZezL3MeUjlMavOzNjYuTCxOiJrDg6ALeHPkmng4MtqZpzVGNFYFS6g8AIrIMiFFKnbRtt8aYUtqi7Ug+g4eUMnDrI5hXlpK/Kp6g6VcjX08zplxOfB0G3Vvj+Ym5iRRZiugeVDVyo1Z/j8U+xl097yLMK6yxi6Jplx17BosjyisBmzSgiU58bzi7kjL5wPtjXA6uJ/1IG7Aq/HP/Z8yuuXFWnSGa92bsBWhZcfIdyMPFAw8Xj8YuhqZdluypCFaIyFLga9v2dOBXxxWp6bNaFYOPf8xI1qHG/pUzvy3CKzYU04zxRjdQ6951XiM+Mx4PFw+ifKMcX2BN07Ra2DNraKaIXAeUr5L6SCn1g2OL1bSlbfiS+/mehIgphJT1xXLyI0KffhpiJ9h9jfjMeGKCYnB2qjOat6ZpmkPZFYba9sHfoj/8zyrKJmTlE2y2diV40ltkv/QXY5B4zGi7L2G2mjmYdZDpXaY7sKCapmn2cei8RRG5SkQOisgREXmmmtfvE5E9IrJLRNaJSIwjy3NJxP+Ii7WYt5zuIGR/HPkrVxIw/caqmchqcfTMUUrKSvRAsaZpTYLDKgIRcQbeBSYCMcCMaj7o5yileiql+mBkQXvTUeW5ZHbPJckpgqDA9px6/nncunQh6I9/rNcl9ECxpmlNiSNbBAOBI0qpY0qpUmAuUGkqjVIqt8KmF7Z4Rk1W1jFI2cTckiHMWPEZ1sJCwt/8l/15gG3iM+PxMfk03dASmqa1KBdUEYjIX+04LBxIqbB93Lbv/Gs9KCJHMVoED9fwfveKyDYR2Zaenn4BJb5E4r5FIZTudybo4G5Cn38Otw4d6n2Z+Ix4ugd116tfNU1rEi60RbD9UhVAKfWuUqoD8DTw5xqO+UgpFauUig0JaaS4PErB7rkkOPVmyv41eI2fgP+0+sezKSkr4XD2YT0+oGlak3FBFYFSapEdh6UCFfs+2tr21WQu0HTjLaRsgewEDu72R4DWzzx1Qd/oD2UdwqIsdA/WFYGmaU1DbUHn3qGWPnulVLXdOBVsBTqJSDRGBXATcPN579FJKXXYtjkJOExTtftrLFYvwg4kcip2BD3atKn7nGrszbQNFAfpgWJN05qG2tYRbLP9ORRj1s83tu0bgH11XVgpZRGRmRhpLp2BT5VS8SLyErBNKbUQmCki4wAzkA3cfmG34WCWUoj/gZST3XAvO4H37XfU63SlFPsy97E4YTGLjy0myD1Ix8TRNK3JqC3o3CwAEbkfGGZLUYmIfACstefiSqklwJLz9r1Q4fdHLqDMDe/EDqz5Z8jfns2u0K5MGxFb9zkVvLblNeYcmIOLkwvDw4dzZ4879UCxpmlNhj0riwMAXyDLtu1t29dyJG0gJ9ETl8Ii4n53DbeZ7A8LYbaaWXB0AWMixvDS0Jfwc/NzYEE1TdPqz56K4DVgp4iswshQNgL4m0NL1cSoxA1kHgrgYEAEocMG1+vcXad3UWAu4JqO1+hKQNO0JsmeoHOficjPwCDbrqeVUqccW6wmxFpGSdw2zLke/NRvMLd3CKrX6WuOr8HFyYXBretXgWiapjWUOqePisgKpdQppdQC288pEVnREIVrEk7vo+hkCQAHgtvTP7J+vWJrj68lNjRWZ83SNK3Jqm36qDvgCQSLSABGtxAY4wVVVgg3W0kbKco0UejuSasu7fE02RWwFYDU/FSO5hzl+k41pX/WNE1rfLV9qv0ReBRog7GSuLwiyAX+6+ByNR1J6yk640m8fySDOgTX69S1x43JVcPbDndEyTRN0y6J2qaPvg28LSIPKaXeacAyNR1KUXZkI6XZzuzrFskYW6J6e61NXUuET4TOQqZpWpNW4xiBiAwQkbDySkBEfi8iC0TkPyIS2HBFbERZxyhOzgbgYEA7Ytr42n1qsaWYLSe3MDx8uF4zoGlak1bbYPGHQCmAiIzAmEY6G8gBPnJ80ZqAZGN8QCGcCIsm3N/+5Ojb0rZRXFasu4U0TWvyahsjcFZKlS8im46Rq3geME9Edjm+aE1A0kaKzniRHhBGdFSo3d/sLVYLvyT8gruzO7Gh9VuFrGma1tBqrQhExMUWWmIscK+d5zUbKmk9RZkm9raKIKZ13YvBDmQdYMGRBfyc8DOZxZn8Lvp3uLu4N0BJNU3TLlxtH+hfA7+JSAZQhC2+kIh0xOgeat7yTmFOSaasMJS9fhGMae1T7WHmMjPLkpYx98BcdqXvwtXJlZFtRzK5/WRGtB3RwIXWNE2rv9pmDb1sWzjWGlimlCoPSe0EPNQQhWtUSespyjAS0h8MaMdM20CxUorXtrzG3sy9ZBRmkF6Ujtlqpp1PO54a8BTXdNChJDRNu7zU2sWjlNpUzb5DjitOE5K4jqIzXlhMbqQGtKZTK6NFsPP0TuYcmEOPoB70C+1HsEcwg1oPYkibITiJI1NAa5qmOUaL6Ou/IInrKcr140SrdrQP88fkYnzIzz88H08XTz6Z8IkOG6FpWrPg0K+wInKViBwUkSMi8kw1rz8mIvtEJE5EVohIpCPLY7f801jTDlJyuoQ4vwhiWhvdQgXmApYlLWNi9ERdCWia1mw4rCIQEWfgXWAiRoazGSISc95hO4FYpVQv4Hvgn44qT70krackxxVlsbLbs/XZhWRLE5dSZCniuk7XNXIBNU3TLh1HtggGAkeUUseUUqUYyemvrXiAUmqVUqrQtrkJI8F940tcT0meFwAJfm3oZpsx9MPhH2jv155ewb0as3SapmmXlCMrgnAgpcL2cWqPWnoX8HN1L4jIvSKyTUS2paenX8Ii1iBxHSVl4ZS5unHSK4iY1r4cyznGrvRdXNfxOh0yQtO0ZqVJTHMRkVuBWOD16l5XSn2klIpVSsWGhIQ4tjAFGZC+n5I8DzKD29A6wAt/TxM/HvkRZ3FmcofJjn1/TdO0BubIWUOpQESF7ba2fZWIyDjgeWCkUqrEgeWxT9J6AIrTCjgWHEm31r5YrBYWHlnIiLYjCPaoXyhqTdO0ps6RLYKtQCcRiRYRE3ATsLDiASLSFyO43TVKqdMOLIv9EtdjKfOiLCuHPaZgYtr4sjt9N5nFmUxur1sDmqY1Pw6rCGwximYCS4H9wLdKqXgReUlErrEd9jrgDXwnIrtEZGENl2s4Sespce0OQKJvGL3b+rE+dT3O4szgNjrvsKZpzY9DF5QppZYAS87b90KF38c58v3rrTAL0vZSoq4DjpPXOpIRnUP4cMk6eof0xsdUfbwhTdO0y1mTGCxuMg4adVZ2pis5Jk9+N7IHOaVZ7M/az7DwYY1cOE3TNMfQFUFF2z+H4M6cOnyaJN/WzBgUyYYTGwB0RaBpWrOlK4JyafFwfCulvW7DIzUJa3QHwvzcWZe6jiD3ILoEdmnsEmqapjmErgjKbZ8FziZ+ze6Oh6WEToN6U2YtY8OJDQwNH6oji2qa1mzpTzcAcxHEzYVu17BmzQEAYob0JT4znpySHN0tpGlas6YrAoB9C6A4h0MR16OOHQXArXNn1qeuRxAGt9bTRjVNa750RQCw/XNUYHte3BVIl8I0nNuE4+ztxboT6+gZ3BN/d//GLqGmaZrD6IogcT0kbyQh8gY2JmTR25yJR5fOpBWksTdjr+4W0jSt2Wu5FYFSsPUTmH0tyj+SPyf2oZ2PK56nUzF16shf1v8Fk5OJSe0nNXZJNU3THKplVgSWElgwExY/Bu1HsnzYN2w4qXgyxh0sFrZ4nmLjyY08NfAp2vm2a+zSapqmOVTLrAh2zIZdX8KIJ7FMn8trq9Po1MqbwbmJALxjXsq4duOY1mla45ZT0zStAbTMiuDICgiIhjF/Zs62VI5lFPDEhC6cWb2C08GuWMNC+OuQv+oENJqmtQgtryIoM0PiWugwmtN5xby+9CBDOwaSY1lO4ZYt7GiveG34a/i5+TV2STVN0xqEQ6OPNknHt0JpPnQYw6tLDlBizaG01SwWzdtNzzK49ta/0T4strFLqWma1mBaXovg6CoQJ7bQgx92phDdbSGJuYd5oOgKxN2dqJF6lpCmaS1LC6wIVmJt05/nfk6mVfg2TpTu5onYJwiJO47noIE4ubk1dgk1TdMalEMrAhG5SkQOisgREXmmmtdHiMgOEbGIiOOn6BRlw4kd7HTty7GcI5j9FjGy7UimuA/CnJSM9/ARDi+CpmlaU+OwikBEnIF3gYlADDBDRGLOOywZuAOY46hyVJKwFpSVtxJbExz9Pb5uPvxtyN8oWGckrPcerlcRa5rW8jhysHggcEQpdQxAROYC1wL7yg9QSiXaXrM6sBznHF1JsZMn293TcZHjvD7kvwR5BJG8dg2uke0wRUY2SDE0TdOaEkd2DYUDKRW2j9v21ZuI3Csi20RkW3p6+gUXyHx4JWst3QhqvZdugd0YGTESa0kJhZu36G4hTdNarMtisFgp9ZFSKlYpFRsSEnJhF8lKwDU3ieWmDuRYE7m247WUHEvgxNPPoIqL8R4x/NIWWtM07TLhyK6hVCCiwnZb275GcWTTIjoCWV08Cch0ZsjHWzn28yuImxtBf/wjXsP0+ICmaS2TIyuCrUAnEYnGqABuAm524PvV6oRLBHGmSRwp281zy70pObSSoDv/QOCdd+ISGNhYxdI0TWt0DusaUkpZgJnAUmA/8K1SKl5EXhKRawBEZICIHAduAD4UkXhHlWfE+OsIvu0++m9IJzI+k1bPPE2rJ57QlYCmaS2eQ0NMKKWWAEvO2/dChd+3YnQZNYjfNnzNbSuteA4bSsDNjdY40TRNa1Iui8HiSyGnIIt+H6wBdzfavPKKjiyqaZpm02Iqgp1vvkD7k1Zcnn0I11atGrs4mqZpTUaLiT7qc/0UdpPD9OvvbOyiaJqmNSktpiLo330c/buPa+xiaJqmNTktpmtI0zRNq56uCDRN01o4XRFomqa1cLoi0DRNa+F0RaBpmtbC6YpA0zSthdMVgaZpWgunKwJN07QWTlcEmqZpLZyuCDRN01o4XRFomqa1cLoi0DRNa+EcWhGIyFUiclBEjojIM9W87iYi39he3ywiUY4sj6ZpmlaVwyoCEXEG3gUmAjHADBGJOe+wu4BspVRH4C3g/xxVHk3TNK16jmwRDASOKKWOKaVKgbnAtecdcy0wy/b798BY0anDNE3TGpQj8xGEAykVto8Dg2o6RillEZEcIAjIqHiQiNwL3GvbzBeRgxdYpuDzr91CtMT7bon3DC3zvlviPUP97zuyphcui8Q0SqmPgI8u9joisk0pFXsJinRZaYn33RLvGVrmfbfEe4ZLe9+O7BpKBSIqbLe17av2GBFxAfyATAeWSdM0TTuPIyuCrUAnEYkWERNwE7DwvGMWArfbfp8GrFRKKQeWSdM0TTuPw7qGbH3+M4GlgDPwqVIqXkReArYppRYCnwBfiMgRIAujsnCki+5euky1xPtuifcMLfO+W+I9wyW8b9FfwDVN01o2vbJY0zSthdMVgaZpWgvXYiqCusJdXK5EJEJEVonIPhGJF5FHbPsDRWS5iBy2/Rlg2y8i8h/b30OciPRr3Du4cCLiLCI7ReQn23a0LVTJEVvoEpNtf7MJZSIi/iLyvYgcEJH9IjK4uT9rEfmT7d/2XhH5WkTcm+OzFpFPReS0iOytsK/ez1ZEbrcdf1hEbq/uvc7XIioCO8NdXK4swONKqRjgCuBB2709A6xQSnUCVti2wfg76GT7uRd4v+GLfMk8AuyvsP1/wFu2kCXZGCFMoHmFMnkb+EUp1RXojXH/zfZZi0g48DAQq5TqgTHx5Caa57P+HLjqvH31erYiEgi8iLF4dyDwYnnlUSulVLP/AQYDSytsPws829jlctC9LgCuBA4CrW37WgMHbb9/CMyocPzZ4y6nH4x1KSuAMcBPgGCssnQ5/5ljzFwbbPvdxXacNPY9XMA9+wEJ55e9OT9rzkUfCLQ9u5+ACc31WQNRwN4LfbbADODDCvsrHVfTT4toEVB9uIvwRiqLw9iawX2BzUCoUuqk7aVTQKjt9+byd/Fv4CnAatsOAs4opSy27Yr3VSmUCVAeyuRyEw2kA5/ZusQ+FhEvmvGzVkqlAm8AycBJjGe3neb/rMvV99le0DNvKRVBsyci3sA84FGlVG7F15Tx1aDZzBMWkcnAaaXU9sYuSwNzAfoB7yul+gIFnOsqAJrlsw7ACE4ZDbQBvKjafdIiOPLZtpSKwJ5wF5ctEXHFqAS+UkrNt+1OE5HWttdbA6dt+5vD38VQ4BoRScSIajsGo+/c3xaqBCrfV3MJZXIcOK6U2mzb/h6jYmjOz3ockKCUSldKmYH5GM+/uT/rcvV9thf0zFtKRWBPuIvLkogIxgrt/UqpNyu8VDF8x+0YYwfl+39vm3VwBZBToel5WVBKPauUaquUisJ4liuVUrcAqzBClUDVe77sQ5kopU4BKSLSxbZrLLCPZvysMbqErhART9u/9fJ7btbPuoL6PtulwHgRCbC1psbb9tWusQdHGnAQ5nfAIeAo8Hxjl+cS3tcwjOZiHLDL9vM7jH7RFcBh4Fcg0Ha8YMygOgrswZiN0ej3cRH3Pwr4yfZ7e2ALcAT4DnCz7Xe3bR+xvd6+sct9EffbB9hme94/AgHN/VkDfwMOAHuBLwC35visga8xxkHMGK2/uy7k2QJ32u7/CPAHe95bh5jQNE1r4VpK15CmaZpWA10RaJqmtXC6ItA0TWvhdEWgaZrWwumKQNM0rYXTFYHWYolIvu3PKBG5+RJf+7nztjdcyutr2qWkKwJNMwJ91asiqLCqtSaVKgKl1JB6lknTGoyuCDQNXgOGi8guW+x7ZxF5XUS22mK9/xFAREaJyFoRWYixuhUR+VFEttvi5d9r2/ca4GG73le2feWtD7Fde6+I7BGR6RWuvVrO5Rr4yraSVtMczmHJ6zXtMvIM8IRSajKA7QM9Ryk1QETcgPUissx2bD+gh1IqwbZ9p1IqS0Q8gK0iMk8p9YyIzFRK9anmva7HWB3cGwi2nbPG9lpfoDtwAliPEVNn3aW/XU2rTLcINK2q8RhxXHZhhPQOwkgAArClQiUA8LCI7AY2YQT76kTthgFfK6XKlFJpwG/AgArXPq6UsmKECom6JHejaXXQLQJNq0qAh5RSlYJ1icgojNDPFbfHYSRCKRSR1Rixbi5USYXfy9D/P7UGolsEmgZ5gE+F7aXA/bbw3ohIZ1sCmPP5YaRFLBSRrhipQsuZyzX/xBsAAACVSURBVM8/z1pgum0cIgQYgREcTdMajf7GoWlGJM8yWxfP5xi5DaKAHbYB23RgSjXn/QLcJyL7MVIFbqrw2kdAnIjsUEaI7HI/YKRW3I0RNfYppdQpW0WiaY1CRx/VNE1r4XTXkKZpWgunKwJN07QWTlcEmqZpLZyuCDRN01o4XRFomqa1cLoi0DRNa+F0RaBpmtbC/T9cdSkm7j7fTwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "id": "ia7VsP7gUMT-" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From bf1f09d297f767ef1078ca38f4dff335588cb20e Mon Sep 17 00:00:00 2001 From: axch Date: Thu, 10 Mar 2022 14:36:46 -0800 Subject: [PATCH 029/153] Loosen timeout on distributions:masked_test. PiperOrigin-RevId: 433854158 --- tensorflow_probability/python/distributions/BUILD | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index 35d00b2287..0c0467b6f0 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -3274,6 +3274,7 @@ multi_substrate_py_test( multi_substrate_py_test( name = "masked_test", + size = "medium", srcs = ["masked_test.py"], deps = [ # numpy dep, From fca161b831e90bf666ac12c321c792f0a178ae0e Mon Sep 17 00:00:00 2001 From: phandu Date: Mon, 14 Mar 2022 10:49:08 -0700 Subject: [PATCH 030/153] Clarify docstring of log_probs of systematic_resampling PiperOrigin-RevId: 434507882 --- .../python/experimental/mcmc/weighted_resampling.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/experimental/mcmc/weighted_resampling.py b/tensorflow_probability/python/experimental/mcmc/weighted_resampling.py index fc7a10c880..672899f31b 100644 --- a/tensorflow_probability/python/experimental/mcmc/weighted_resampling.py +++ b/tensorflow_probability/python/experimental/mcmc/weighted_resampling.py @@ -249,7 +249,8 @@ def resample_systematic(log_probs, event_size, sample_shape, The value returned from this function is similar to sampling with ```python expanded_sample_shape = tf.concat([[event_size], sample_shape]), axis=-1) - tfd.Categorical(logits=log_probs).sample(expanded_sample_shape)` + logits = dist_util.move_dimension(log_probs, source_idx=0, dest_idx=-1) + tfd.Categorical(logits=logits).sample(expanded_sample_shape) ``` but with values sorted along the first axis. It can be considered to be sampling events made up of a length-`event_size` vector of draws from @@ -267,6 +268,9 @@ def resample_systematic(log_probs, event_size, sample_shape, Args: log_probs: A tensor-valued batch of discrete log probability distributions. + It is expected that those log probabilities are normalized along the + first dimension (such that ``sum(exp(log_probs), axis=0) == 1``). + The remaining dimensions are batch dimensions. event_size: the dimension of the vector considered a single draw. sample_shape: the `sample_shape` determining the number of draws. seed: PRNG seed; see `tfp.random.sanitize_seed` for details. From 52c743f7c3ba47e4c5e429cdd758ca9c2bb52ad9 Mon Sep 17 00:00:00 2001 From: siege Date: Mon, 14 Mar 2022 12:09:39 -0700 Subject: [PATCH 031/153] Speed up importance_resample_test.tf by removing AutoBatched JDs. Those are slow due to while_loop fallbacks for stateless PRNGS: b/179683537 PiperOrigin-RevId: 434531437 --- .../distributions/importance_resample.py | 26 ++++++++++++++++--- .../distributions/importance_resample_test.py | 16 +++++++----- 2 files changed, 31 insertions(+), 11 deletions(-) diff --git a/tensorflow_probability/python/experimental/distributions/importance_resample.py b/tensorflow_probability/python/experimental/distributions/importance_resample.py index a10d2645f3..27ef487c86 100644 --- a/tensorflow_probability/python/experimental/distributions/importance_resample.py +++ b/tensorflow_probability/python/experimental/distributions/importance_resample.py @@ -14,7 +14,10 @@ # limitations under the License. # ============================================================================ -import tensorflow as tf +import functools + +import tensorflow.compat.v2 as tf + from tensorflow_probability.python.distributions import categorical from tensorflow_probability.python.distributions import distribution as distribution_lib from tensorflow_probability.python.internal import assert_util @@ -310,7 +313,13 @@ def _check_weights_shape(self, log_weights, sample_shape): 'the proposal is not producing independent samples for some ' 'batch dimension(s) expected by `self.target_log_prob_fn`.') sample_and_batch_shape = ps.concat( - [sample_shape, self.proposal_distribution.batch_shape_tensor()], axis=0) + [ + sample_shape, + _get_joint_batch_shape( + self.proposal_distribution.batch_shape_tensor()) + ], + axis=0, + ) sample_and_batch_shape_ = tf.get_static_value(sample_and_batch_shape) if (sample_and_batch_shape_ is not None and not tensorshape_util.is_compatible_with(log_weights.shape, @@ -410,8 +419,9 @@ def _log_prob(self, # other values that were *not* chosen during resampling. # Estimate the total weight of these discarded proposals using # `sample_size` Monte Carlo draws. - x_sample_ndims = (ps.rank(x_log_weight) - - ps.rank_from_shape(self.batch_shape_tensor())) + x_sample_ndims = ( + ps.rank(x_log_weight) - + ps.rank_from_shape(_get_joint_batch_shape(self.batch_shape_tensor()))) _, log_weights_of_proposals_not_chosen = self._propose_with_log_weights( sample_shape=ps.concat( [ @@ -642,3 +652,11 @@ def weighted_reduce_sum(x, axis=0): return tf.reduce_sum(aligned_weights * tf.cast(x, weights.dtype), axis=axis) return weighted_reduce_sum + + +def _get_joint_batch_shape(batch_shape_tensor): + if tf.nest.is_nested(batch_shape_tensor): + return functools.reduce(ps.broadcast_shape, + tf.nest.flatten(batch_shape_tensor)) + else: + return batch_shape_tensor diff --git a/tensorflow_probability/python/experimental/distributions/importance_resample_test.py b/tensorflow_probability/python/experimental/distributions/importance_resample_test.py index 8892866fa7..6412cd4187 100644 --- a/tensorflow_probability/python/experimental/distributions/importance_resample_test.py +++ b/tensorflow_probability/python/experimental/distributions/importance_resample_test.py @@ -135,20 +135,22 @@ def test_log_prob_approaches_target_distribution(self): resampled.log_prob(xs, seed=seed), atol=0.1) - @test_util.numpy_disable_test_missing_functionality('vectorized_map') def test_supports_joint_events(self): + root = tfd.JointDistributionCoroutine.Root - @tfd.JointDistributionCoroutineAutoBatched + @tfd.JointDistributionCoroutine def target(): - x = yield tfd.Normal(-1., 1.0, name='x') - yield tfd.MultivariateNormalTriL(loc=[x + 2], + x = yield root(tfd.Normal(-1., 1.0, name='x')) + yield tfd.MultivariateNormalTriL(loc=(x + 2)[..., tf.newaxis], scale_tril=[[0.5]], name='y') - @tfd.JointDistributionCoroutineAutoBatched + @tfd.JointDistributionCoroutine def proposal(): - yield tfd.StudentT(df=2, loc=0., scale=2., name='x') - yield tfd.StudentT(df=2, loc=[0.], scale=[2.], name='y') + yield root(tfd.StudentT(df=2, loc=0., scale=2., name='x')) + yield root( + tfd.Independent( + tfd.StudentT(df=2, loc=[0.], scale=[2.]), 1, name='y')) resampled = tfed.ImportanceResample( proposal, From 1b7edc60cc9da335b0b4c95744373765112bb91a Mon Sep 17 00:00:00 2001 From: axch Date: Tue, 15 Mar 2022 10:03:26 -0700 Subject: [PATCH 032/153] Delete math/random_ops_test.py; subsumed by random/random_ops_test.py. PiperOrigin-RevId: 434781935 --- tensorflow_probability/python/math/BUILD | 13 --- .../python/math/random_ops_test.py | 107 ------------------ 2 files changed, 120 deletions(-) delete mode 100644 tensorflow_probability/python/math/random_ops_test.py diff --git a/tensorflow_probability/python/math/BUILD b/tensorflow_probability/python/math/BUILD index be1cab8661..f922ed2931 100644 --- a/tensorflow_probability/python/math/BUILD +++ b/tensorflow_probability/python/math/BUILD @@ -366,19 +366,6 @@ multi_substrate_py_test( ], ) -multi_substrate_py_test( - name = "random_ops_test", - size = "small", - srcs = ["random_ops_test.py"], - deps = [ - # numpy dep, - # tensorflow dep, - "//tensorflow_probability", - "//tensorflow_probability/python/internal:dtype_util", - "//tensorflow_probability/python/internal:test_util", - ], -) - multi_substrate_py_library( name = "diag_jacobian", srcs = [ diff --git a/tensorflow_probability/python/math/random_ops_test.py b/tensorflow_probability/python/math/random_ops_test.py deleted file mode 100644 index c5648dde7c..0000000000 --- a/tensorflow_probability/python/math/random_ops_test.py +++ /dev/null @@ -1,107 +0,0 @@ -# Copyright 2018 The TensorFlow Probability Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# ============================================================================ -"""Tests for generating random samples.""" - -# Dependency imports -import numpy as np - -import tensorflow.compat.v1 as tf1 -import tensorflow.compat.v2 as tf -import tensorflow_probability as tfp - -from tensorflow_probability.python.internal import dtype_util -from tensorflow_probability.python.internal import test_util - - -class _RandomRademacher(object): - - def test_expected_value(self): - shape_ = np.array([2, 3, int(1e3)], np.int32) - shape = ( - tf.constant(shape_) if self.use_static_shape else - tf1.placeholder_with_default(shape_, shape=None)) - x = tfp.math.random_rademacher(shape, self.dtype, - seed=test_util.test_seed()) - if self.use_static_shape: - self.assertAllEqual(shape_, x.shape) - x_ = self.evaluate(x) - self.assertEqual(self.dtype, dtype_util.as_numpy_dtype(x.dtype)) - self.assertAllEqual(shape_, x_.shape) - self.assertAllEqual([-1., 1], np.unique(np.reshape(x_, [-1]))) - self.assertAllClose( - np.zeros(shape_[:-1]), - np.mean(x_, axis=-1), - atol=0.07, rtol=0.) - - -@test_util.test_all_tf_execution_regimes -class RandomRademacherDynamic32(test_util.TestCase, _RandomRademacher): - dtype = np.float32 - use_static_shape = False - - -@test_util.test_all_tf_execution_regimes -class RandomRademacherDynamic64(test_util.TestCase, _RandomRademacher): - dtype = np.float64 - use_static_shape = True - - -class _RandomRayleigh(object): - - def test_expected_value(self): - shape_ = np.array([2, int(1e3)], np.int32) - shape = ( - tf.constant(shape_) if self.use_static_shape else - tf1.placeholder_with_default(shape_, shape=None)) - # This shape will require broadcasting before sampling. - scale_ = np.linspace(0.1, 0.5, 3 * 2).astype(self.dtype).reshape(3, 2) - scale = ( - tf.constant(scale_) if self.use_static_shape else - tf1.placeholder_with_default(scale_, shape=None)) - x = tfp.math.random_rayleigh(shape, - scale=scale[..., tf.newaxis], - dtype=self.dtype, - seed=test_util.test_seed()) - self.assertEqual(self.dtype, dtype_util.as_numpy_dtype(x.dtype)) - final_shape_ = [3, 2, int(1e3)] - if self.use_static_shape: - self.assertAllEqual(final_shape_, x.shape) - sample_mean = tf.reduce_mean(x, axis=-1, keepdims=True) - sample_var = tf.reduce_mean( - tf.math.squared_difference(x, sample_mean), axis=-1) - [x_, sample_mean_, sample_var_] = self.evaluate([ - x, sample_mean[..., 0], sample_var]) - self.assertAllEqual(final_shape_, x_.shape) - self.assertAllEqual(np.ones_like(x_, dtype=np.bool_), x_ > 0.) - self.assertAllClose(np.sqrt(np.pi / 2.) * scale_, sample_mean_, - atol=0.05, rtol=0.) - self.assertAllClose(0.5 * (4. - np.pi) * scale_**2., sample_var_, - atol=0.05, rtol=0.) - - -@test_util.test_all_tf_execution_regimes -class RandomRayleighDynamic32(test_util.TestCase, _RandomRayleigh): - dtype = np.float32 - use_static_shape = False - - -@test_util.test_all_tf_execution_regimes -class RandomRayleighDynamic64(test_util.TestCase, _RandomRayleigh): - dtype = np.float64 - use_static_shape = True - - -if __name__ == '__main__': - test_util.main() From 7ff84999ae82873717662778eade652367388163 Mon Sep 17 00:00:00 2001 From: sharadmv Date: Tue, 15 Mar 2022 11:15:38 -0700 Subject: [PATCH 033/153] Fix omnistaging bug in AIS PiperOrigin-RevId: 434804127 --- tensorflow_probability/python/mcmc/BUILD | 2 ++ .../python/mcmc/sample_annealed_importance.py | 9 +++++---- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/tensorflow_probability/python/mcmc/BUILD b/tensorflow_probability/python/mcmc/BUILD index 68d0586d53..0931743d4a 100644 --- a/tensorflow_probability/python/mcmc/BUILD +++ b/tensorflow_probability/python/mcmc/BUILD @@ -381,6 +381,8 @@ multi_substrate_py_library( # numpy dep, # tensorflow dep, "//tensorflow_probability/python/internal:dtype_util", + "//tensorflow_probability/python/internal:prefer_static", + "//tensorflow_probability/python/internal:samplers", "//tensorflow_probability/python/mcmc/internal", ], ) diff --git a/tensorflow_probability/python/mcmc/sample_annealed_importance.py b/tensorflow_probability/python/mcmc/sample_annealed_importance.py index e7c824ba2f..c7fb8f4681 100644 --- a/tensorflow_probability/python/mcmc/sample_annealed_importance.py +++ b/tensorflow_probability/python/mcmc/sample_annealed_importance.py @@ -21,6 +21,7 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.mcmc.internal import util as mcmc_util @@ -258,7 +259,7 @@ def _bootstrap_results(init_state): convex_combined_log_prob = mh_results.accepted_results.target_log_prob dtype = dtype_util.as_numpy_dtype(convex_combined_log_prob.dtype) - shape = tf.shape(convex_combined_log_prob) + shape = ps.shape(convex_combined_log_prob) proposal_log_prob = tf.fill(shape, dtype(np.nan), name='bootstrap_proposal_log_prob') target_log_prob = tf.fill(shape, dtype(np.nan), @@ -275,9 +276,9 @@ def _bootstrap_results(init_state): mh_results = _find_inner_mh_results(inner_results) ais_weights = tf.zeros( - shape=tf.broadcast_dynamic_shape( - tf.shape(mh_results.proposed_results.target_log_prob), - tf.shape(mh_results.accepted_results.target_log_prob)), + shape=ps.broadcast_shape( + ps.shape(mh_results.proposed_results.target_log_prob), + ps.shape(mh_results.accepted_results.target_log_prob)), dtype=mh_results.proposed_results.target_log_prob.dtype) [_, _, ais_weights, current_state, kernel_results] = tf.while_loop( From c7ab80d17726c71740b3aed4bd9a021031c54bef Mon Sep 17 00:00:00 2001 From: Christopher Suter Date: Tue, 15 Mar 2022 17:48:58 -0700 Subject: [PATCH 034/153] Add flag to GaussianProcess, such that it can retain an event_shape of [1]. Previously, if the number of (per-batch) index_points was statically determinable and found to be 1, we would yield a Normal marginal distribution, instead of an MVN. In some cases, users want to have a consistent event rank, irrespective of # of index_points. We enable this behavior backward compatibly by introducing a flag, `always_yield_multivariate_normal`, set by default to False. PiperOrigin-RevId: 434905157 --- .../python/distributions/gaussian_process.py | 9 +++++++++ .../gaussian_process_regression_model.py | 6 ++++++ .../distributions/gaussian_process_test.py | 17 +++++++++++++++++ 3 files changed, 32 insertions(+) diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index cb5101790c..f319e85d84 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -250,6 +250,7 @@ def __init__(self, marginal_fn=None, cholesky_fn=None, jitter=1e-6, + always_yield_multivariate_normal=False, validate_args=False, allow_nan_stats=False, parameters=None, @@ -294,6 +295,10 @@ def __init__(self, `marginal_fn` and `cholesky_fn` is None. This argument is ignored if `cholesky_fn` is set. Default value: `1e-6`. + always_yield_multivariate_normal: If `False` (the default), we produce a + scalar `Normal` distribution when the number of `index_points` is + statically known to be `1`. If `True`, we avoid this behavior, ensuring + that the event shape will retain the `1` from `index_points`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect @@ -353,6 +358,7 @@ def __init__(self, else: self._marginal_fn = marginal_fn + self._always_yield_multivariate_normal = always_yield_multivariate_normal with tf.name_scope('init'): super(GaussianProcess, self).__init__( dtype=dtype, @@ -375,6 +381,9 @@ def _is_univariate_marginal(self, index_points): multivariate. In the case of dynamic shape in the number of index points, defaults to "multivariate" since that's the best we can do. """ + if self._always_yield_multivariate_normal: + return False + num_index_points = tf.compat.dimension_value( index_points.shape[-(self.kernel.feature_ndims + 1)]) if num_index_points is None: diff --git a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py index f5b4679076..316c1e700a 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py +++ b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py @@ -390,6 +390,7 @@ def __init__(self, mean_fn=None, cholesky_fn=None, jitter=1e-6, + always_yield_multivariate_normal=False, validate_args=False, allow_nan_stats=False, name='GaussianProcessRegressionModel', @@ -456,6 +457,10 @@ def __init__(self, matrix to ensure positive definiteness of the covariance matrix. This argument is ignored if `cholesky_fn` is set. Default value: `1e-6`. + always_yield_multivariate_normal: If `False` (the default), we produce a + scalar `Normal` distribution when the number of `index_points` is + statically known to be `1`. If `True`, we avoid this behavior, ensuring + that the event shape will retain the `1` from `index_points`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect @@ -571,6 +576,7 @@ def conditional_mean_fn(x): index_points=index_points, cholesky_fn=cholesky_fn, jitter=jitter, + always_yield_multivariate_normal=always_yield_multivariate_normal, # What the GP super class calls "observation noise variance" we call # here the "predictive noise variance". We use the observation noise # variance for the fit/solve process above, and predictive for diff --git a/tensorflow_probability/python/distributions/gaussian_process_test.py b/tensorflow_probability/python/distributions/gaussian_process_test.py index d93ff89c6e..bb70a35b6d 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_test.py +++ b/tensorflow_probability/python/distributions/gaussian_process_test.py @@ -401,6 +401,23 @@ def testUnivariateLogProbWithIsMissing(self): tf.convert_to_tensor([[lp[0, 0], 0.0], [0.0, 0.0], [0., lp[2, 1]]]), gp.log_prob(x, is_missing=[[False, True], [True, True], [True, False]])) + def testAlwaysYieldMultivariateNormal(self): + gp = tfd.GaussianProcess( + kernel=psd_kernels.ExponentiatedQuadratic(), + index_points=tf.ones([5, 1, 2]), + always_yield_multivariate_normal=False, + ) + self.assertAllEqual([5], self.evaluate(gp.batch_shape_tensor())) + self.assertAllEqual([], self.evaluate(gp.event_shape_tensor())) + + gp = tfd.GaussianProcess( + kernel=psd_kernels.ExponentiatedQuadratic(), + index_points=tf.ones([5, 1, 2]), + always_yield_multivariate_normal=True, + ) + self.assertAllEqual([5], self.evaluate(gp.batch_shape_tensor())) + self.assertAllEqual([1], self.evaluate(gp.event_shape_tensor())) + @test_util.test_all_tf_execution_regimes class GaussianProcessStaticTest(_GaussianProcessTest, test_util.TestCase): From 23c395440fb060fd01fa9f56203348227a1aeada Mon Sep 17 00:00:00 2001 From: pravnar Date: Wed, 16 Mar 2022 01:39:04 -0700 Subject: [PATCH 035/153] Handle local measures in TransformedDistribution. This change continues to set up the framework for tracking base measures and computing corrections on transformed densities. In `TransformedDistribution` we update `log_prob` to call a version of `experimental_local_measure` that keeps track of the base measure. We use the backwards-compatibility argument to control this rollout. Note that this change reverses the bijector method called by `transformed_distribution._log_prob` from `inverse_log_det_jacobian` to `forward_log_det_jacobian`, which (i) shifted the numerics, and (ii) affected which functions get exercised by the test suite. As a result, in this change we (i) loosen tolerances in some tests, (ii) find and fix a dtype correctness bug in `moyal_cdf`, and (iii) disable one test under TF1. PiperOrigin-RevId: 434982467 --- .../python/bijectors/moyal_cdf.py | 9 ++-- .../distributions/transformed_distribution.py | 37 ++++++++++++-- .../bijectors/distribution_bijectors_test.py | 50 +++++++++++-------- .../experimental/util/jit_public_methods.py | 4 +- .../python/sts/forecast_test.py | 5 +- 5 files changed, 72 insertions(+), 33 deletions(-) diff --git a/tensorflow_probability/python/bijectors/moyal_cdf.py b/tensorflow_probability/python/bijectors/moyal_cdf.py index ddc821300d..12de908153 100644 --- a/tensorflow_probability/python/bijectors/moyal_cdf.py +++ b/tensorflow_probability/python/bijectors/moyal_cdf.py @@ -109,14 +109,15 @@ def _forward(self, x): def _inverse(self, y): with tf.control_dependencies(self._maybe_assert_valid_y(y)): + np_dtype = dtype_util.as_numpy_dtype(y.dtype) return (self.loc - self.scale * - (np.log(2.) + 2. * tf.math.log(tfp_math.erfcinv(y)))) + (np.log(np_dtype(2.)) + 2. * tf.math.log(tfp_math.erfcinv(y)))) def _inverse_log_det_jacobian(self, y): with tf.control_dependencies(self._maybe_assert_valid_y(y)): - return (tf.math.square(tfp_math.erfcinv(y)) + - tf.math.log(self.scale) + 0.5 * np.log(np.pi) - - tf.math.log(tfp_math.erfcinv(y))) + np_dtype = dtype_util.as_numpy_dtype(y.dtype) + return (tf.math.square(tfp_math.erfcinv(y)) + tf.math.log(self.scale) + + 0.5 * np.log(np_dtype(np.pi)) - tf.math.log(tfp_math.erfcinv(y))) def _forward_log_det_jacobian(self, x): scale = tf.convert_to_tensor(self.scale) diff --git a/tensorflow_probability/python/distributions/transformed_distribution.py b/tensorflow_probability/python/distributions/transformed_distribution.py index 117dc772be..30dcb7d192 100644 --- a/tensorflow_probability/python/distributions/transformed_distribution.py +++ b/tensorflow_probability/python/distributions/transformed_distribution.py @@ -354,6 +354,13 @@ def _sample_and_log_prob(self, sample_shape, seed, **kwargs): tf.cast(fldj, base_distribution_log_prob.dtype)) def _log_prob(self, y, **kwargs): + if self.bijector._is_injective: # pylint: disable=protected-access + log_prob, _ = self.experimental_local_measure( + y, backward_compat=True, **kwargs) + return log_prob + + # TODO(pravnar, axch): Support base measure handling for non-injective + # bijectors. distribution_kwargs, bijector_kwargs = self._kwargs_split_fn(kwargs) # For caching to work, it is imperative that the bijector is the first to @@ -366,9 +373,6 @@ def _log_prob(self, y, **kwargs): ildj = self.bijector.inverse_log_det_jacobian( y, event_ndims=event_ndims, **bijector_kwargs) - if self.bijector._is_injective: # pylint: disable=protected-access - base_log_prob = self.distribution.log_prob(x, **distribution_kwargs) - return base_log_prob + tf.cast(ildj, base_log_prob.dtype) # Compute log_prob on each element of the inverse image. lp_on_fibers = [] @@ -596,6 +600,32 @@ def _default_event_space_bijector(self): self.distribution.experimental_default_event_space_bijector()) # pylint: enable=not-callable + def experimental_local_measure(self, y, backward_compat=False, **kwargs): + distribution_kwargs, bijector_kwargs = self._kwargs_split_fn(kwargs) + + # For caching to work, it is imperative that the bijector is the first to + # modify the input. + x = self.bijector.inverse(y, **bijector_kwargs) + event_ndims = self.bijector.inverse_event_ndims( + tf.nest.map_structure(ps.rank_from_shape, self._event_shape_tensor(), + self.event_shape), **bijector_kwargs) + + if self.bijector._is_injective: # pylint: disable=protected-access + local_measure_fn = self.distribution.experimental_local_measure + density_corr_fn = self.bijector.experimental_compute_density_correction + base_log_prob, tangent_space = local_measure_fn( + x, backward_compat=backward_compat, **distribution_kwargs) + correction, new_tangent_space = density_corr_fn( + x, + tangent_space, + backward_compat=backward_compat, + event_ndims=event_ndims, + **bijector_kwargs) + log_prob = base_log_prob - tf.cast(correction, base_log_prob.dtype) + return log_prob, new_tangent_space + else: + raise NotImplementedError + class TransformedDistribution( _TransformedDistribution, distribution_lib.AutoCompositeTensorDistribution): @@ -671,4 +701,3 @@ def _transformed_log_prob_ratio(p, x, q, y, name=None): ildj_ratio = ldj_ratio.inverse_log_det_jacobian_ratio( p.bijector, x, q.bijector, y, event_ndims) return base_log_prob_ratio + tf.cast(ildj_ratio, base_log_prob_ratio.dtype) - diff --git a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py index a1edd1b496..f0a001c3f3 100644 --- a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py +++ b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py @@ -42,12 +42,12 @@ 'LambertWNormal', # CDF gradient incorrect at 0. 'SigmoidBeta', # inverse CDF numerical precision issues for large x 'StudentT', # CDF gradient incorrect at 0 (and unstable near zero). - ) +) if JAX_MODE: PRECONDITIONING_FAILS_DISTS = ( 'VonMises', # Abstract eval for 'von_mises_cdf_jvp' not implemented. - ) + PRECONDITIONING_FAILS_DISTS + ) + PRECONDITIONING_FAILS_DISTS def _constrained_zeros_fn(shape, dtype, constraint_fn): @@ -60,15 +60,18 @@ class DistributionBijectorsTest(test_util.TestCase): def assertDistributionIsApproximatelyStandardNormal(self, dist, + rtol=1e-6, logprob_atol=1e-2, grad_atol=1e-2): """Verifies that dist's lps and gradients match those of Normal(0., 1.).""" batch_shape = dist.batch_shape_tensor() + def make_reference_values(event_shape): dist_shape = ps.concat([batch_shape, event_shape], axis=0) x = tf.reshape([-4., -2., 0., 2., 4.], ps.concat([[5], ps.ones_like(dist_shape)], axis=0)) return tf.broadcast_to(x, ps.concat([[5], dist_shape], axis=0)) + flat_event_shape = tf.nest.flatten(dist.event_shape_tensor()) zs = [make_reference_values(s) for s in flat_event_shape] lp_dist, grad_dist = tfp.math.value_and_gradient( @@ -83,11 +86,14 @@ def reference_value_and_gradient(z, event_shape): reference_vals_and_grads = [ reference_value_and_gradient(z, event_shape) for (z, event_shape) in zip(zs, flat_event_shape)] + lps_reference = [lp for lp, grad in reference_vals_and_grads] - self.assertAllClose(sum(lps_reference), lp_dist, atol=logprob_atol) + self.assertAllClose( + sum(lps_reference), lp_dist, rtol=rtol, atol=logprob_atol) grads_reference = [grad for lp, grad in reference_vals_and_grads] - self.assertAllCloseNested(grads_reference, grad_dist, atol=grad_atol) + self.assertAllCloseNested( + grads_reference, grad_dist, rtol=rtol, atol=grad_atol) @parameterized.named_parameters( {'testcase_name': dname, 'dist_name': dname} @@ -101,10 +107,11 @@ def test_all_distributions_either_work_or_raise_error(self, dist_name, data): if dist_name in PRECONDITIONING_FAILS_DISTS: self.skipTest('Known failure.') - dist = data.draw(dhps.base_distributions( - dist_name=dist_name, - enable_vars=False, - param_strategy_fn=_constrained_zeros_fn)) + dist = data.draw( + dhps.base_distributions( + dist_name=dist_name, + enable_vars=False, + param_strategy_fn=_constrained_zeros_fn)) try: b = tfp.experimental.bijectors.make_distribution_bijector(dist) except NotImplementedError: @@ -114,22 +121,20 @@ def test_all_distributions_either_work_or_raise_error(self, dist_name, data): @test_util.numpy_disable_gradient_test def test_multivariate_normal(self): - d = tfd.MultivariateNormalFullCovariance(loc=[4., 8.], - covariance_matrix=[[11., 0.099], - [0.099, 0.1]]) + d = tfd.MultivariateNormalFullCovariance( + loc=[4., 8.], covariance_matrix=[[11., 0.099], [0.099, 0.1]]) b = tfp.experimental.bijectors.make_distribution_bijector(d) - self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d)) + self.assertDistributionIsApproximatelyStandardNormal(tfb.Invert(b)(d)) @test_util.numpy_disable_gradient_test def test_markov_chain(self): d = tfd.MarkovChain( initial_state_prior=tfd.Uniform(low=0., high=1.), transition_fn=lambda _, x: tfd.Uniform(low=0., high=tf.nn.softplus(x)), - num_steps=10) + num_steps=3) b = tfp.experimental.bijectors.make_distribution_bijector(d) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d)) + tfb.Invert(b)(d), rtol=1e-4) @test_util.numpy_disable_gradient_test def test_markov_chain_joint(self): @@ -145,7 +150,7 @@ def test_markov_chain_joint(self): num_steps=10) b = tfp.experimental.bijectors.make_distribution_bijector(d) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d)) + tfb.Invert(b)(d), rtol=1e-4) @test_util.numpy_disable_gradient_test def test_nested_joint_distribution(self): @@ -153,13 +158,14 @@ def test_nested_joint_distribution(self): def model(): x = yield tfd.Normal(loc=-2., scale=1.) yield tfd.JointDistributionSequentialAutoBatched([ - tfd.Uniform(low=1. + tf.exp(x), - high=1 + tf.exp(x) + tf.nn.softplus(x)), + tfd.Uniform(low=1. - tf.exp(x), + high=2. + tf.exp(x) + tf.nn.softplus(x)), lambda v: tfd.Exponential(v)]) # pylint: disable=unnecessary-lambda + dist = tfd.JointDistributionCoroutineAutoBatched(model) b = tfp.experimental.bijectors.make_distribution_bijector(dist) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(dist)) + tfb.Invert(b)(dist), rtol=1e-4) @test_util.numpy_disable_gradient_test @test_util.jax_disable_test_missing_functionality( @@ -171,6 +177,7 @@ def model_with_funnel(): z = yield tfd.Normal(loc=-1., scale=2., name='z') x = yield tfd.Normal(loc=[0.], scale=tf.exp(z), name='x') yield tfd.Poisson(log_rate=x, name='y') + pinned_model = model_with_funnel.experimental_pin(y=[1]) surrogate_posterior = tfp.experimental.vi.build_asvi_surrogate_posterior( pinned_model) @@ -191,15 +198,16 @@ def do_sample(): kernel=tfp.mcmc.DualAveragingStepSizeAdaptation( tfp.mcmc.TransformedTransitionKernel( tfp.mcmc.NoUTurnSampler( - pinned_model.unnormalized_log_prob, - step_size=0.1), + pinned_model.unnormalized_log_prob, step_size=0.1), bijector=bijector), num_adaptation_steps=5), current_state=surrogate_posterior.sample(), num_burnin_steps=5, trace_fn=lambda _0, _1: [], num_results=10) + do_sample() + if __name__ == '__main__': test_util.main() diff --git a/tensorflow_probability/python/experimental/util/jit_public_methods.py b/tensorflow_probability/python/experimental/util/jit_public_methods.py index f8290bb3c5..9272853687 100644 --- a/tensorflow_probability/python/experimental/util/jit_public_methods.py +++ b/tensorflow_probability/python/experimental/util/jit_public_methods.py @@ -36,6 +36,7 @@ 'dtype', 'kl_divergence', # Wrapping applied explicitly in `_traced_kl_divergence`. 'experimental_default_event_space_bijector', + 'experimental_local_measure', # tfb.Bijector # TODO(davmre): Test wrapping bijectors. 'forward_event_shape', @@ -45,7 +46,8 @@ 'forward_dtype', 'inverse_dtype', 'forward_event_ndims', - 'inverse_event_ndims' + 'inverse_event_ndims', + 'experimental_compute_density_correction', ) if NUMPY_MODE: diff --git a/tensorflow_probability/python/sts/forecast_test.py b/tensorflow_probability/python/sts/forecast_test.py index ed60c2e4bf..6ff7a3572a 100644 --- a/tensorflow_probability/python/sts/forecast_test.py +++ b/tensorflow_probability/python/sts/forecast_test.py @@ -168,9 +168,8 @@ def test_forecast_correctness(self): @test_util.jax_disable_test_missing_functionality('fit_with_hmc') def test_forecast_from_hmc(self): - if not (tf1.control_flow_v2_enabled() or self.use_static_shape): - self.skipTest('test_forecast_from_hmc does not currently work with TF1 ' - 'and dynamic shapes') + if not tf1.control_flow_v2_enabled(): + self.skipTest('test_forecast_from_hmc does not currently work with TF1') # test that we can directly plug in the output of an HMC chain as # the input to `forecast`, as done in the example, with no `sess.run` call. From cede3ed9c37863ef61149435beffff02c39551ed Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Wed, 16 Mar 2022 03:11:42 -0700 Subject: [PATCH 036/153] Deprecate `observations_mask` argument in favour of `observations_is_missing` argument in GPRM. PiperOrigin-RevId: 434998707 --- .../python/distributions/gaussian_process.py | 2 +- .../gaussian_process_regression_model.py | 41 ++++-- .../gaussian_process_regression_model_test.py | 23 ++-- ...itask_gaussian_process_regression_model.py | 2 +- .../python/math/psd_kernels/internal/util.py | 14 +- .../math/psd_kernels/schur_complement.py | 124 +++++++++++++----- 6 files changed, 144 insertions(+), 62 deletions(-) diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index f319e85d84..67ce1ed565 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -454,7 +454,7 @@ def _get_marginal_distribution(self, index_points=None, is_missing=None): if is_univariate_marginal: covariance = tf.where(is_missing, 1., covariance) else: - covariance = psd_kernels_util.mask_matrix(covariance, ~is_missing) # pylint:disable=invalid-unary-operand-type + covariance = psd_kernels_util.mask_matrix(covariance, is_missing) # pylint:disable=invalid-unary-operand-type # If we're sure the number of index points is 1, we can just construct a # scalar Normal. This has computational benefits and supports things like diff --git a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py index 316c1e700a..6fbe5396db 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py +++ b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py @@ -28,6 +28,7 @@ from tensorflow_probability.python.internal import tensor_util from tensorflow_probability.python.internal import tensorshape_util from tensorflow_probability.python.math import psd_kernels as tfpk +from tensorflow.python.util import deprecation # pylint: disable=g-direct-tensorflow-import __all__ = [ @@ -587,11 +588,17 @@ def conditional_mean_fn(x): self._parameters = parameters @staticmethod + @deprecation.deprecated_args( + '2022-06-23', + ('The `observations_mask` flag is deprecated; instead use ' + '`observations_is_missing` (with the opposite sense).'), + 'observations_mask') def precompute_regression_model( kernel, observation_index_points, observations, observations_mask=None, + observations_is_missing=None, index_points=None, observation_noise_variance=0., predictive_noise_variance=None, @@ -649,10 +656,16 @@ def precompute_regression_model( `None`, which corresponds to the empty set of observations, and simply results in the prior predictive model (a GP with noise of variance `predictive_noise_variance`). - observations_mask: `bool` `Tensor` of shape `[..., e]`, representing + observations_mask: Deprecated. Prefer `observations_is_missing`. + `bool` `Tensor` of shape `[..., e]`, representing a batch of boolean masks. When `observation_masks` is not `None`, the returned distribution is conditioned only on the observations for which the corresponding elements of `observations_masks` are `True`. + observations_is_missing: `bool` `Tensor` of shape `[..., e]`, + representing a batch of boolean masks. When `observations_is_missing` + is not `None`, the returned distribution is conditioned only on the + observations for which the corresponding elements of + `observations_is_missing` are `True`. index_points: `float` `Tensor` representing finite collection, or batch of collections, of points in the index set over which the GP is defined. Shape has the form `[b1, ..., bB, e, f1, ..., fF]` where `F` is the @@ -719,8 +732,15 @@ def precompute_regression_model( observation_noise_variance, dtype=dtype) observations = tf.convert_to_tensor(observations, dtype=dtype) + if ((observations_is_missing is not None) and + (observations_mask is not None)): + raise ValueError('Expect only one of `observations_is_missing` and ' + '`observations_mask` to be set') + if observations_mask is not None: - observations_mask = tf.convert_to_tensor(observations_mask) + observations_is_missing = ~tf.convert_to_tensor(observations_mask) + if observations_is_missing is not None: + observations_is_missing = tf.convert_to_tensor(observations_is_missing) if cholesky_fn is None: cholesky_fn = cholesky_util.make_cholesky_with_jitter_fn(jitter) @@ -728,7 +748,7 @@ def precompute_regression_model( conditional_kernel = tfpk.SchurComplement.with_precomputed_divisor( base_kernel=kernel, fixed_inputs=observation_index_points, - fixed_inputs_mask=observations_mask, + fixed_inputs_is_missing=observations_is_missing, cholesky_fn=cholesky_fn, diag_shift=observation_noise_variance) @@ -742,17 +762,18 @@ def precompute_regression_model( raise ValueError('`mean_fn` must be a Python callable') diff = observations - mean_fn(observation_index_points) - if observations_mask is not None: - diff = tf.where(observations_mask, diff, tf.zeros([], dtype=diff.dtype)) + if observations_is_missing is not None: + diff = tf.where( + observations_is_missing, tf.zeros([], dtype=diff.dtype), diff) solve_on_observation = observation_cholesky_operator.solvevec( observation_cholesky_operator.solvevec(diff), adjoint=True) def conditional_mean_fn(x): k_x_obs = kernel.matrix(x, observation_index_points) - if observations_mask is not None: - k_x_obs = tf.where(observations_mask[..., tf.newaxis, :], - k_x_obs, - tf.zeros([], dtype=k_x_obs.dtype)) + if observations_is_missing is not None: + k_x_obs = tf.where(observations_is_missing[..., tf.newaxis, :], + tf.zeros([], dtype=k_x_obs.dtype), + k_x_obs) return mean_fn(x) + tf.linalg.matvec(k_x_obs, solve_on_observation) gprm = GaussianProcessRegressionModel( @@ -798,7 +819,7 @@ def _parameter_properties(cls, dtype, num_classes=None): event_ndims=lambda self: self.kernel.feature_ndims + 1, shape_fn=parameter_properties.SHAPE_FN_NOT_IMPLEMENTED, ), - observations_mask=parameter_properties.ParameterProperties( + observations_is_missing=parameter_properties.ParameterProperties( event_ndims=1, shape_fn=parameter_properties.SHAPE_FN_NOT_IMPLEMENTED, ), diff --git a/tensorflow_probability/python/distributions/gaussian_process_regression_model_test.py b/tensorflow_probability/python/distributions/gaussian_process_regression_model_test.py index 6511b5777b..91c109a84c 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_regression_model_test.py +++ b/tensorflow_probability/python/distributions/gaussian_process_regression_model_test.py @@ -227,19 +227,19 @@ def testPrecomputedWithMasking(self): observation_noise_variance = np.array([[1e-2], [1e-4], [1e-6]], np.float64) rng = test_util.test_np_rng() - observations_mask = np.array([ + observations_is_missing = np.array([ [False, True, False, True, False, True], - [True, True, True, True, True, True], + [False, False, False, False, False, False], [True, True, False, False, True, True], ]).reshape((3, 1, 6)) observation_index_points = np.where( - observations_mask[..., np.newaxis], - rng.uniform(-1., 1., (3, 1, 6, 2)).astype(np.float64), - np.nan) + observations_is_missing[..., np.newaxis], + np.nan, + rng.uniform(-1., 1., (3, 1, 6, 2)).astype(np.float64)) observations = np.where( - observations_mask, - rng.uniform(-1., 1., (3, 1, 6)).astype(np.float64), - np.nan) + observations_is_missing, + np.nan, + rng.uniform(-1., 1., (3, 1, 6)).astype(np.float64)) index_points = rng.uniform(-1., 1., (5, 2)).astype(np.float64) @@ -249,7 +249,7 @@ def testPrecomputedWithMasking(self): index_points=index_points, observation_index_points=observation_index_points, observations=observations, - observations_mask=observations_mask, + observations_is_missing=observations_is_missing, observation_noise_variance=observation_noise_variance, validate_args=True) @@ -263,9 +263,10 @@ def testPrecomputedWithMasking(self): x = gprm.sample(seed=test_util.test_seed()) for i in range(3): observation_index_points_i = tf.gather( - observation_index_points[i, 0], observations_mask[i, 0].nonzero()[0]) + observation_index_points[i, 0], + (~observations_is_missing[i, 0]).nonzero()[0]) observations_i = tf.gather( - observations[i, 0], observations_mask[i, 0].nonzero()[0]) + observations[i, 0], (~observations_is_missing[i, 0]).nonzero()[0]) gprm_i = tfd.GaussianProcessRegressionModel.precompute_regression_model( kernel=kernel[i], index_points=index_points, diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py index a66bf46359..60e44ba414 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py @@ -216,7 +216,7 @@ def __init__(self, observation_covariance = tf.linalg.LinearOperatorFullMatrix( psd_kernels_util.mask_matrix( observation_covariance.to_dense(), - mask=~vec_observations_is_missing), + is_missing=vec_observations_is_missing), is_non_singular=True, is_positive_definite=True) diff --git a/tensorflow_probability/python/math/psd_kernels/internal/util.py b/tensorflow_probability/python/math/psd_kernels/internal/util.py index e0be7eba09..039be12489 100644 --- a/tensorflow_probability/python/math/psd_kernels/internal/util.py +++ b/tensorflow_probability/python/math/psd_kernels/internal/util.py @@ -287,27 +287,27 @@ def pairwise_square_distance_tensor( tf.shape(pairwise)[:-2], x1_example_shape, x2_example_shape], axis=0)) -def mask_matrix(x, mask=None): +def mask_matrix(x, is_missing=None): """Copies a matrix, replacing masked-out rows/cols from the identity matrix. Args: x: A Tensor of shape `[..., n, n]`, representing a batch of n-by-n matrices. - mask: A boolean Tensor of shape `[..., n]`, representing a batch of masks. - If `mask` is None, `x` is returned. + is_missing: A boolean Tensor of shape `[..., n]`, representing a batch of + masks. If `is_missing` is None, `x` is returned. Returns: A Tensor of shape `[..., n, n]`, representing a batch of n-by-n matrices. For each batch member `r`, element `r[i, j]` equals `eye(n)[i, j]` if - dimension `i` or `j` is False in the corresponding input mask. Otherwise, + dimension `i` or `j` is True in the corresponding input mask. Otherwise, `r[i, j]` equals the corresponding element from `x`. """ - if mask is None: + if is_missing is None: return x x = tf.convert_to_tensor(x) - mask = tf.convert_to_tensor(mask, dtype=tf.bool) + is_missing = tf.convert_to_tensor(is_missing, dtype=tf.bool) n = ps.dimension_size(x, -1) - return tf.where(~mask[..., tf.newaxis] | ~mask[..., tf.newaxis, :], + return tf.where(is_missing[..., tf.newaxis] | is_missing[..., tf.newaxis, :], tf.eye(n, dtype=x.dtype), x) diff --git a/tensorflow_probability/python/math/psd_kernels/schur_complement.py b/tensorflow_probability/python/math/psd_kernels/schur_complement.py index dac9c00455..5edfd2cf1e 100644 --- a/tensorflow_probability/python/math/psd_kernels/schur_complement.py +++ b/tensorflow_probability/python/math/psd_kernels/schur_complement.py @@ -21,6 +21,7 @@ from tensorflow_probability.python.internal import tensor_util from tensorflow_probability.python.math.psd_kernels import positive_semidefinite_kernel as psd_kernel from tensorflow_probability.python.math.psd_kernels.internal import util +from tensorflow.python.util import deprecation # pylint: disable=g-direct-tensorflow-import __all__ = [ @@ -175,10 +176,16 @@ def posterior_mean_fn(x): """ # pylint:disable=invalid-name + @deprecation.deprecated_args( + '2022-06-23', + ('The `fixed_inputs_mask` flag is deprecated; instead use ' + '`fixed_inputs_is_missing` (with the opposite sense).'), + 'fixed_inputs_mask') def __init__(self, base_kernel, fixed_inputs, fixed_inputs_mask=None, + fixed_inputs_is_missing=None, diag_shift=None, cholesky_fn=None, validate_args=False, @@ -207,10 +214,14 @@ def __init__(self, decomposition of the k(Z, Z) matrix. The batch shape elements of `fixed_inputs` must be broadcast compatible with `base_kernel.batch_shape`. - fixed_inputs_mask: A boolean Tensor of shape `[..., N]`. When `mask` is - not None and an element of `mask` is `False`, this kernel will return - values computed as if the divisor matrix did not contain the + fixed_inputs_mask: Deprecated. A boolean Tensor of shape `[..., N]`. When + `mask` is not None and an element of `mask` is `False`, this kernel + will return values computed as if the divisor matrix did not contain the corresponding row or column. + fixed_inputs_is_missing: A boolean Tensor of shape `[..., N]`. + When `is_missing` is not None and an element of `mask` is `True`, + this kernel will return values computed as if the divisor matrix did + not contain the corresponding row or column. diag_shift: A floating point scalar to be added to the diagonal of the divisor_matrix before computing its Cholesky. cholesky_fn: Callable which takes a single (batch) matrix argument and @@ -243,8 +254,15 @@ def __init__(self, diag_shift, dtype=dtype, name='diag_shift') self._fixed_inputs = tensor_util.convert_nonref_to_tensor( fixed_inputs, dtype=dtype, name='fixed_inputs') + if ((fixed_inputs_mask is not None) and + (fixed_inputs_is_missing is not None)): + raise ValueError('Expected at most one of `fixed_inputs_mask` or ' + '`fixed_inputs_is_missing`') self._fixed_inputs_mask = tensor_util.convert_nonref_to_tensor( fixed_inputs_mask, dtype=tf.bool, name='fixed_inputs_mask') + self._fixed_inputs_is_missing = tensor_util.convert_nonref_to_tensor( + fixed_inputs_is_missing, + dtype=tf.bool, name='fixed_inputs_is_missing') self._cholesky_bijector = invert.Invert( cholesky_outer_product.CholeskyOuterProduct()) self._precomputed_divisor_matrix_cholesky = _precomputed_divisor_matrix_cholesky @@ -265,10 +283,16 @@ def __init__(self, parameters=parameters) @staticmethod + @deprecation.deprecated_args( + '2022-06-23', + ('The `fixed_inputs_mask` flag is deprecated; instead use ' + '`fixed_inputs_is_missing` (with the opposite sense).'), + 'fixed_inputs_mask') def with_precomputed_divisor( base_kernel, fixed_inputs, fixed_inputs_mask=None, + fixed_inputs_is_missing=None, diag_shift=None, cholesky_fn=None, validate_args=False, @@ -306,10 +330,14 @@ def with_precomputed_divisor( decomposition of the k(Z, Z) matrix. The batch shape elements of `fixed_inputs` must be broadcast compatible with `base_kernel.batch_shape`. - fixed_inputs_mask: A boolean Tensor of shape `[..., N]`. When `mask` is - not None and an element of `mask` is False, the returned kernel will - return values computed as if the divisor matrix did not contain the - corresponding row or column. + fixed_inputs_mask: Deprecated. A boolean Tensor of shape `[..., N]`. When + `mask` is not None and an element of `mask` is `False`, the returned + kernel will return values computed as if the divisor matrix did not + contain the corresponding row or column. + fixed_inputs_is_missing: A boolean Tensor of shape `[..., N]`. When + `is_missing` is not None and an element of `is_missing` is `True`, the + returned kernel will return values computed as if the divisor matrix + did not contain the corresponding row or column. diag_shift: A floating point scalar to be added to the diagonal of the divisor_matrix before computing its Cholesky. cholesky_fn: Callable which takes a single (batch) matrix argument and @@ -325,8 +353,16 @@ def with_precomputed_divisor( dtype = dtype_util.common_dtype( [base_kernel, fixed_inputs, diag_shift], tf.float32) fixed_inputs = tf.convert_to_tensor(fixed_inputs, dtype) + if ((fixed_inputs_mask is not None) and + (fixed_inputs_is_missing is not None)): + raise ValueError('Expected at most one of `fixed_inputs_mask` or ' + '`fixed_inputs_is_missing`') if fixed_inputs_mask is not None: - fixed_inputs_mask = tf.convert_to_tensor(fixed_inputs_mask, tf.bool) + fixed_inputs_is_missing = ~tf.convert_to_tensor( + fixed_inputs_mask, tf.bool) + if fixed_inputs_is_missing is not None: + fixed_inputs_is_missing = tf.convert_to_tensor( + fixed_inputs_is_missing, tf.bool) if diag_shift is not None: diag_shift = tf.convert_to_tensor(diag_shift, dtype) @@ -340,12 +376,12 @@ def with_precomputed_divisor( _compute_divisor_matrix(base_kernel, diag_shift=diag_shift, fixed_inputs=fixed_inputs), - mask=fixed_inputs_mask)) + is_missing=fixed_inputs_is_missing)) schur_complement = SchurComplement( base_kernel=base_kernel, fixed_inputs=fixed_inputs, - fixed_inputs_mask=fixed_inputs_mask, + fixed_inputs_is_missing=fixed_inputs_is_missing, diag_shift=diag_shift, cholesky_fn=cholesky_fn, validate_args=validate_args, @@ -365,6 +401,14 @@ def _is_fixed_inputs_empty(self): return True return False + def _get_fixed_inputs_is_missing(self): + fixed_inputs_is_missing = self._fixed_inputs_is_missing + if fixed_inputs_is_missing is not None: + fixed_inputs_is_missing = tf.convert_to_tensor(fixed_inputs_is_missing) + if self._fixed_inputs_mask is not None: + fixed_inputs_is_missing = ~tf.convert_to_tensor(self._fixed_inputs_mask) + return fixed_inputs_is_missing + def _apply(self, x1, x2, example_ndims): # In the shape annotations below, # @@ -381,23 +425,24 @@ def _apply(self, x1, x2, example_ndims): return k12 fixed_inputs = tf.convert_to_tensor(self._fixed_inputs) - if self._fixed_inputs_mask is not None: - fixed_mask = tf.convert_to_tensor(self._fixed_inputs_mask) - fixed_mask = util.pad_shape_with_ones(fixed_mask, example_ndims, -2) + fixed_inputs_is_missing = self._get_fixed_inputs_is_missing() + if fixed_inputs_is_missing is not None: + fixed_inputs_is_missing = util.pad_shape_with_ones( + fixed_inputs_is_missing, example_ndims, -2) # Shape: bc(Bk, B1, Bz) + E1 + [ez] k1z = self.base_kernel.tensor(x1, fixed_inputs, x1_example_ndims=example_ndims, x2_example_ndims=1) - if self._fixed_inputs_mask is not None: - k1z = tf.where(fixed_mask, k1z, tf.zeros([], k1z.dtype)) + if fixed_inputs_is_missing is not None: + k1z = tf.where(fixed_inputs_is_missing, tf.zeros([], k1z.dtype), k1z) # Shape: bc(Bk, B2, Bz) + E2 + [ez] k2z = self.base_kernel.tensor(x2, fixed_inputs, x1_example_ndims=example_ndims, x2_example_ndims=1) - if self._fixed_inputs_mask is not None: - k2z = tf.where(fixed_mask, k2z, tf.zeros([], k2z.dtype)) + if fixed_inputs_is_missing is not None: + k2z = tf.where(fixed_inputs_is_missing, tf.zeros([], k2z.dtype), k2z) # Shape: bc(Bz, Bk) + [ez, ez] div_mat_chol = self._divisor_matrix_cholesky( @@ -430,19 +475,19 @@ def _matrix(self, x1, x2): return k12 fixed_inputs = tf.convert_to_tensor(self._fixed_inputs) - if self._fixed_inputs_mask is not None: - fixed_mask = tf.convert_to_tensor(self._fixed_inputs_mask) - fixed_mask = fixed_mask[..., tf.newaxis, :] + fixed_inputs_is_missing = self._get_fixed_inputs_is_missing() + if fixed_inputs_is_missing is not None: + fixed_inputs_is_missing = fixed_inputs_is_missing[..., tf.newaxis, :] # Shape: bc(Bk, B1, Bz) + [e1] + [ez] k1z = self.base_kernel.matrix(x1, fixed_inputs) - if self._fixed_inputs_mask is not None: - k1z = tf.where(fixed_mask, k1z, tf.zeros([], k1z.dtype)) + if fixed_inputs_is_missing is not None: + k1z = tf.where(fixed_inputs_is_missing, tf.zeros([], k1z.dtype), k1z) # Shape: bc(Bk, B2, Bz) + [e2] + [ez] k2z = self.base_kernel.matrix(x2, fixed_inputs) - if self._fixed_inputs_mask is not None: - k2z = tf.where(fixed_mask, k2z, tf.zeros([], k2z.dtype)) + if fixed_inputs_is_missing is not None: + k2z = tf.where(fixed_inputs_is_missing, tf.zeros([], k2z.dtype), k2z) # Shape: bc(Bz, Bk) + [ez, ez] div_mat_chol = self._divisor_matrix_cholesky( @@ -488,17 +533,19 @@ def _parameter_properties(cls, dtype): event_ndims=lambda self: self.base_kernel.feature_ndims + 1), fixed_inputs_mask=parameter_properties.ParameterProperties( event_ndims=1), + fixed_inputs_is_missing=parameter_properties.ParameterProperties( + event_ndims=1), diag_shift=parameter_properties.ParameterProperties( default_constraining_bijector_fn=( lambda: softplus.Softplus(low=dtype_util.eps(dtype)))), _precomputed_divisor_matrix_cholesky=( parameter_properties.ParameterProperties(event_ndims=2))) - def _divisor_matrix(self, fixed_inputs=None, fixed_inputs_mask=None): + def _divisor_matrix(self, fixed_inputs=None, fixed_inputs_is_missing=None): fixed_inputs = tf.convert_to_tensor( self._fixed_inputs if fixed_inputs is None else fixed_inputs) - if fixed_inputs_mask is None: - fixed_inputs_mask = self._fixed_inputs_mask + if fixed_inputs_is_missing is None: + fixed_inputs_is_missing = self._get_fixed_inputs_is_missing() # NOTE: Replacing masked-out rows/columns of the divisor matrix with # rows/columns from the identity matrix is equivalent to using a divisor # matrix in which those rows and columns have been dropped. @@ -506,18 +553,31 @@ def _divisor_matrix(self, fixed_inputs=None, fixed_inputs_mask=None): _compute_divisor_matrix(self._base_kernel, diag_shift=self._diag_shift, fixed_inputs=fixed_inputs), - mask=fixed_inputs_mask) + is_missing=fixed_inputs_is_missing) def divisor_matrix(self): return self._divisor_matrix() - def _divisor_matrix_cholesky(self, fixed_inputs=None, fixed_inputs_mask=None): + def _divisor_matrix_cholesky( + self, + fixed_inputs=None, + fixed_inputs_is_missing=None): if self._precomputed_divisor_matrix_cholesky is not None: return self._precomputed_divisor_matrix_cholesky return self.cholesky_bijector.forward( - self._divisor_matrix(fixed_inputs, fixed_inputs_mask)) + self._divisor_matrix(fixed_inputs, fixed_inputs_is_missing)) - def divisor_matrix_cholesky(self, fixed_inputs=None, fixed_inputs_mask=None): + def divisor_matrix_cholesky( + self, + fixed_inputs=None, + fixed_inputs_mask=None, + fixed_inputs_is_missing=None): if self._precomputed_divisor_matrix_cholesky is not None: return self._precomputed_divisor_matrix_cholesky - return self._divisor_matrix_cholesky(fixed_inputs, fixed_inputs_mask) + if ((fixed_inputs_mask is not None) and + (fixed_inputs_is_missing is not None)): + raise ValueError('Expected only one of `fixed_inputs_mask` or ' + '`fixed_inputs_is_missing` to be set.') + if fixed_inputs_mask is not None: + fixed_inputs_is_missing = ~tf.convert_to_tensor(fixed_inputs_mask) + return self._divisor_matrix_cholesky(fixed_inputs, fixed_inputs_is_missing) From 24d598da93d13c8ad5fdbdd2d580bc367fe2da2e Mon Sep 17 00:00:00 2001 From: pravnar Date: Wed, 16 Mar 2022 04:37:57 -0700 Subject: [PATCH 037/153] Internal change PiperOrigin-RevId: 435013697 --- .../python/bijectors/moyal_cdf.py | 9 ++-- .../distributions/transformed_distribution.py | 37 ++------------ .../bijectors/distribution_bijectors_test.py | 50 ++++++++----------- .../experimental/util/jit_public_methods.py | 4 +- .../python/sts/forecast_test.py | 5 +- 5 files changed, 33 insertions(+), 72 deletions(-) diff --git a/tensorflow_probability/python/bijectors/moyal_cdf.py b/tensorflow_probability/python/bijectors/moyal_cdf.py index 12de908153..ddc821300d 100644 --- a/tensorflow_probability/python/bijectors/moyal_cdf.py +++ b/tensorflow_probability/python/bijectors/moyal_cdf.py @@ -109,15 +109,14 @@ def _forward(self, x): def _inverse(self, y): with tf.control_dependencies(self._maybe_assert_valid_y(y)): - np_dtype = dtype_util.as_numpy_dtype(y.dtype) return (self.loc - self.scale * - (np.log(np_dtype(2.)) + 2. * tf.math.log(tfp_math.erfcinv(y)))) + (np.log(2.) + 2. * tf.math.log(tfp_math.erfcinv(y)))) def _inverse_log_det_jacobian(self, y): with tf.control_dependencies(self._maybe_assert_valid_y(y)): - np_dtype = dtype_util.as_numpy_dtype(y.dtype) - return (tf.math.square(tfp_math.erfcinv(y)) + tf.math.log(self.scale) + - 0.5 * np.log(np_dtype(np.pi)) - tf.math.log(tfp_math.erfcinv(y))) + return (tf.math.square(tfp_math.erfcinv(y)) + + tf.math.log(self.scale) + 0.5 * np.log(np.pi) - + tf.math.log(tfp_math.erfcinv(y))) def _forward_log_det_jacobian(self, x): scale = tf.convert_to_tensor(self.scale) diff --git a/tensorflow_probability/python/distributions/transformed_distribution.py b/tensorflow_probability/python/distributions/transformed_distribution.py index 30dcb7d192..117dc772be 100644 --- a/tensorflow_probability/python/distributions/transformed_distribution.py +++ b/tensorflow_probability/python/distributions/transformed_distribution.py @@ -354,13 +354,6 @@ def _sample_and_log_prob(self, sample_shape, seed, **kwargs): tf.cast(fldj, base_distribution_log_prob.dtype)) def _log_prob(self, y, **kwargs): - if self.bijector._is_injective: # pylint: disable=protected-access - log_prob, _ = self.experimental_local_measure( - y, backward_compat=True, **kwargs) - return log_prob - - # TODO(pravnar, axch): Support base measure handling for non-injective - # bijectors. distribution_kwargs, bijector_kwargs = self._kwargs_split_fn(kwargs) # For caching to work, it is imperative that the bijector is the first to @@ -373,6 +366,9 @@ def _log_prob(self, y, **kwargs): ildj = self.bijector.inverse_log_det_jacobian( y, event_ndims=event_ndims, **bijector_kwargs) + if self.bijector._is_injective: # pylint: disable=protected-access + base_log_prob = self.distribution.log_prob(x, **distribution_kwargs) + return base_log_prob + tf.cast(ildj, base_log_prob.dtype) # Compute log_prob on each element of the inverse image. lp_on_fibers = [] @@ -600,32 +596,6 @@ def _default_event_space_bijector(self): self.distribution.experimental_default_event_space_bijector()) # pylint: enable=not-callable - def experimental_local_measure(self, y, backward_compat=False, **kwargs): - distribution_kwargs, bijector_kwargs = self._kwargs_split_fn(kwargs) - - # For caching to work, it is imperative that the bijector is the first to - # modify the input. - x = self.bijector.inverse(y, **bijector_kwargs) - event_ndims = self.bijector.inverse_event_ndims( - tf.nest.map_structure(ps.rank_from_shape, self._event_shape_tensor(), - self.event_shape), **bijector_kwargs) - - if self.bijector._is_injective: # pylint: disable=protected-access - local_measure_fn = self.distribution.experimental_local_measure - density_corr_fn = self.bijector.experimental_compute_density_correction - base_log_prob, tangent_space = local_measure_fn( - x, backward_compat=backward_compat, **distribution_kwargs) - correction, new_tangent_space = density_corr_fn( - x, - tangent_space, - backward_compat=backward_compat, - event_ndims=event_ndims, - **bijector_kwargs) - log_prob = base_log_prob - tf.cast(correction, base_log_prob.dtype) - return log_prob, new_tangent_space - else: - raise NotImplementedError - class TransformedDistribution( _TransformedDistribution, distribution_lib.AutoCompositeTensorDistribution): @@ -701,3 +671,4 @@ def _transformed_log_prob_ratio(p, x, q, y, name=None): ildj_ratio = ldj_ratio.inverse_log_det_jacobian_ratio( p.bijector, x, q.bijector, y, event_ndims) return base_log_prob_ratio + tf.cast(ildj_ratio, base_log_prob_ratio.dtype) + diff --git a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py index f0a001c3f3..a1edd1b496 100644 --- a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py +++ b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py @@ -42,12 +42,12 @@ 'LambertWNormal', # CDF gradient incorrect at 0. 'SigmoidBeta', # inverse CDF numerical precision issues for large x 'StudentT', # CDF gradient incorrect at 0 (and unstable near zero). -) + ) if JAX_MODE: PRECONDITIONING_FAILS_DISTS = ( 'VonMises', # Abstract eval for 'von_mises_cdf_jvp' not implemented. - ) + PRECONDITIONING_FAILS_DISTS + ) + PRECONDITIONING_FAILS_DISTS def _constrained_zeros_fn(shape, dtype, constraint_fn): @@ -60,18 +60,15 @@ class DistributionBijectorsTest(test_util.TestCase): def assertDistributionIsApproximatelyStandardNormal(self, dist, - rtol=1e-6, logprob_atol=1e-2, grad_atol=1e-2): """Verifies that dist's lps and gradients match those of Normal(0., 1.).""" batch_shape = dist.batch_shape_tensor() - def make_reference_values(event_shape): dist_shape = ps.concat([batch_shape, event_shape], axis=0) x = tf.reshape([-4., -2., 0., 2., 4.], ps.concat([[5], ps.ones_like(dist_shape)], axis=0)) return tf.broadcast_to(x, ps.concat([[5], dist_shape], axis=0)) - flat_event_shape = tf.nest.flatten(dist.event_shape_tensor()) zs = [make_reference_values(s) for s in flat_event_shape] lp_dist, grad_dist = tfp.math.value_and_gradient( @@ -86,14 +83,11 @@ def reference_value_and_gradient(z, event_shape): reference_vals_and_grads = [ reference_value_and_gradient(z, event_shape) for (z, event_shape) in zip(zs, flat_event_shape)] - lps_reference = [lp for lp, grad in reference_vals_and_grads] - self.assertAllClose( - sum(lps_reference), lp_dist, rtol=rtol, atol=logprob_atol) + self.assertAllClose(sum(lps_reference), lp_dist, atol=logprob_atol) grads_reference = [grad for lp, grad in reference_vals_and_grads] - self.assertAllCloseNested( - grads_reference, grad_dist, rtol=rtol, atol=grad_atol) + self.assertAllCloseNested(grads_reference, grad_dist, atol=grad_atol) @parameterized.named_parameters( {'testcase_name': dname, 'dist_name': dname} @@ -107,11 +101,10 @@ def test_all_distributions_either_work_or_raise_error(self, dist_name, data): if dist_name in PRECONDITIONING_FAILS_DISTS: self.skipTest('Known failure.') - dist = data.draw( - dhps.base_distributions( - dist_name=dist_name, - enable_vars=False, - param_strategy_fn=_constrained_zeros_fn)) + dist = data.draw(dhps.base_distributions( + dist_name=dist_name, + enable_vars=False, + param_strategy_fn=_constrained_zeros_fn)) try: b = tfp.experimental.bijectors.make_distribution_bijector(dist) except NotImplementedError: @@ -121,20 +114,22 @@ def test_all_distributions_either_work_or_raise_error(self, dist_name, data): @test_util.numpy_disable_gradient_test def test_multivariate_normal(self): - d = tfd.MultivariateNormalFullCovariance( - loc=[4., 8.], covariance_matrix=[[11., 0.099], [0.099, 0.1]]) + d = tfd.MultivariateNormalFullCovariance(loc=[4., 8.], + covariance_matrix=[[11., 0.099], + [0.099, 0.1]]) b = tfp.experimental.bijectors.make_distribution_bijector(d) - self.assertDistributionIsApproximatelyStandardNormal(tfb.Invert(b)(d)) + self.assertDistributionIsApproximatelyStandardNormal( + tfb.Invert(b)(d)) @test_util.numpy_disable_gradient_test def test_markov_chain(self): d = tfd.MarkovChain( initial_state_prior=tfd.Uniform(low=0., high=1.), transition_fn=lambda _, x: tfd.Uniform(low=0., high=tf.nn.softplus(x)), - num_steps=3) + num_steps=10) b = tfp.experimental.bijectors.make_distribution_bijector(d) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d), rtol=1e-4) + tfb.Invert(b)(d)) @test_util.numpy_disable_gradient_test def test_markov_chain_joint(self): @@ -150,7 +145,7 @@ def test_markov_chain_joint(self): num_steps=10) b = tfp.experimental.bijectors.make_distribution_bijector(d) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d), rtol=1e-4) + tfb.Invert(b)(d)) @test_util.numpy_disable_gradient_test def test_nested_joint_distribution(self): @@ -158,14 +153,13 @@ def test_nested_joint_distribution(self): def model(): x = yield tfd.Normal(loc=-2., scale=1.) yield tfd.JointDistributionSequentialAutoBatched([ - tfd.Uniform(low=1. - tf.exp(x), - high=2. + tf.exp(x) + tf.nn.softplus(x)), + tfd.Uniform(low=1. + tf.exp(x), + high=1 + tf.exp(x) + tf.nn.softplus(x)), lambda v: tfd.Exponential(v)]) # pylint: disable=unnecessary-lambda - dist = tfd.JointDistributionCoroutineAutoBatched(model) b = tfp.experimental.bijectors.make_distribution_bijector(dist) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(dist), rtol=1e-4) + tfb.Invert(b)(dist)) @test_util.numpy_disable_gradient_test @test_util.jax_disable_test_missing_functionality( @@ -177,7 +171,6 @@ def model_with_funnel(): z = yield tfd.Normal(loc=-1., scale=2., name='z') x = yield tfd.Normal(loc=[0.], scale=tf.exp(z), name='x') yield tfd.Poisson(log_rate=x, name='y') - pinned_model = model_with_funnel.experimental_pin(y=[1]) surrogate_posterior = tfp.experimental.vi.build_asvi_surrogate_posterior( pinned_model) @@ -198,16 +191,15 @@ def do_sample(): kernel=tfp.mcmc.DualAveragingStepSizeAdaptation( tfp.mcmc.TransformedTransitionKernel( tfp.mcmc.NoUTurnSampler( - pinned_model.unnormalized_log_prob, step_size=0.1), + pinned_model.unnormalized_log_prob, + step_size=0.1), bijector=bijector), num_adaptation_steps=5), current_state=surrogate_posterior.sample(), num_burnin_steps=5, trace_fn=lambda _0, _1: [], num_results=10) - do_sample() - if __name__ == '__main__': test_util.main() diff --git a/tensorflow_probability/python/experimental/util/jit_public_methods.py b/tensorflow_probability/python/experimental/util/jit_public_methods.py index 9272853687..f8290bb3c5 100644 --- a/tensorflow_probability/python/experimental/util/jit_public_methods.py +++ b/tensorflow_probability/python/experimental/util/jit_public_methods.py @@ -36,7 +36,6 @@ 'dtype', 'kl_divergence', # Wrapping applied explicitly in `_traced_kl_divergence`. 'experimental_default_event_space_bijector', - 'experimental_local_measure', # tfb.Bijector # TODO(davmre): Test wrapping bijectors. 'forward_event_shape', @@ -46,8 +45,7 @@ 'forward_dtype', 'inverse_dtype', 'forward_event_ndims', - 'inverse_event_ndims', - 'experimental_compute_density_correction', + 'inverse_event_ndims' ) if NUMPY_MODE: diff --git a/tensorflow_probability/python/sts/forecast_test.py b/tensorflow_probability/python/sts/forecast_test.py index 6ff7a3572a..ed60c2e4bf 100644 --- a/tensorflow_probability/python/sts/forecast_test.py +++ b/tensorflow_probability/python/sts/forecast_test.py @@ -168,8 +168,9 @@ def test_forecast_correctness(self): @test_util.jax_disable_test_missing_functionality('fit_with_hmc') def test_forecast_from_hmc(self): - if not tf1.control_flow_v2_enabled(): - self.skipTest('test_forecast_from_hmc does not currently work with TF1') + if not (tf1.control_flow_v2_enabled() or self.use_static_shape): + self.skipTest('test_forecast_from_hmc does not currently work with TF1 ' + 'and dynamic shapes') # test that we can directly plug in the output of an HMC chain as # the input to `forecast`, as done in the example, with no `sess.run` call. From fc6502a1af70107597ce2ce670011f6fda6c37ec Mon Sep 17 00:00:00 2001 From: phandu Date: Thu, 17 Mar 2022 11:55:37 -0700 Subject: [PATCH 038/153] [Oryx] Fix typos in docstrings PiperOrigin-RevId: 435407983 --- spinoffs/oryx/oryx/core/interpreters/harvest.py | 4 ++-- spinoffs/oryx/oryx/core/ppl/transformations.py | 11 ++++++----- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/spinoffs/oryx/oryx/core/interpreters/harvest.py b/spinoffs/oryx/oryx/core/interpreters/harvest.py index 8b9b9d15ed..ac770e7687 100644 --- a/spinoffs/oryx/oryx/core/interpreters/harvest.py +++ b/spinoffs/oryx/oryx/core/interpreters/harvest.py @@ -270,8 +270,8 @@ def nest(f, *, scope: str): Harvested values live in one dynamic name scope (for a particular tag), and in strict mode, values with the same name cannot be collected or injected - more than once. nest(f, scope=) will take all tagged values in `f` and - put them into a nested dictionary with key . This enables having + more than once. `nest(f, scope=[name])` will take all tagged values in `f` and + put them into a nested dictionary with key `[name]`. This enables having duplicate names in one namespace provided they are in different scopes. This is different from using a separate tag to namespace, as it enables creating nested/hierarchical structure within a single tag's namespace. diff --git a/spinoffs/oryx/oryx/core/ppl/transformations.py b/spinoffs/oryx/oryx/core/ppl/transformations.py index 5337a8b041..d8f4dafd8a 100644 --- a/spinoffs/oryx/oryx/core/ppl/transformations.py +++ b/spinoffs/oryx/oryx/core/ppl/transformations.py @@ -53,7 +53,7 @@ def f(key, z): work on JAX types (e.g. DeviceArrays and tracers). We also register an implementation for function types, where it returns the original function but when provided the name, tags the output of the function. The registry enables -objects such as TensorFlow Probability distributions to register as as random +objects such as TensorFlow Probability distributions to register as a random variable-like with Oryx. Tagging a value in a probabilistic program as a random variable enables it to @@ -200,7 +200,7 @@ def f(key): return z + random_variable(random.normal, name='x')(k2) conditional(f, ['z'])(random.PRNGKey(0), 0.) # => -1.25153887 conditional(f, ['z'])(random.PRNGKey(0), 1.) # => -0.25153887 -conditional(f, ['z'. 'x'])(random.PRNGKey(0), 1., 2.) # => 3. +conditional(f, ['z', 'x'])(random.PRNGKey(0), 1., 2.) # => 3. ``` @@ -272,8 +272,8 @@ def random_variable(obj, Args: obj: A JAX type to be tagged. - name (str): A string name to tag input value, cannot be `None`. - plate (str): A string named axis for this random variable's plate. + name: A string name to tag input value, cannot be `None`. + plate: A string named axis for this random variable's plate. Returns: The input value. @@ -312,7 +312,8 @@ def model(key): except NameError: print('No named axis present!') # If we vmap with a named axis, we produce independent samples. - vmap(model, axis_name='foo')(random.split(random.PRNGKey(0), 3)) # + vmap(model, axis_name='foo')(random.split(random.PRNGKey(0), 3)) + # ==> [0.58776844, -0.4009751, 0.01193586] ``` Args: From ad261a44f3cdd445559a4bf4d5154811237ee097 Mon Sep 17 00:00:00 2001 From: siege Date: Thu, 17 Mar 2022 16:53:44 -0700 Subject: [PATCH 039/153] Fix LogisticRegressionTest.testGermanCreditHMC. The sampler appears to have hit a resonance, so reducing the number of leapfrog steps appears to fix things. PiperOrigin-RevId: 435486123 --- .../inference_gym/targets/logistic_regression_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py b/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py index bebfd00956..89604e7ebf 100644 --- a/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py @@ -108,7 +108,7 @@ def testGermanCreditHMC(self): model, num_chains=4, num_steps=4000, - num_leapfrog_steps=15, + num_leapfrog_steps=5, step_size=0.03, ) From 4b41658a37ff5f164ab32af94e80c412603dfd97 Mon Sep 17 00:00:00 2001 From: Christopher Suter Date: Thu, 17 Mar 2022 21:20:10 -0700 Subject: [PATCH 040/153] Fix error message for undefined `mode` of `TransformedDistribution` PiperOrigin-RevId: 435534113 --- .../python/distributions/transformed_distribution.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/distributions/transformed_distribution.py b/tensorflow_probability/python/distributions/transformed_distribution.py index 117dc772be..45686d870b 100644 --- a/tensorflow_probability/python/distributions/transformed_distribution.py +++ b/tensorflow_probability/python/distributions/transformed_distribution.py @@ -475,8 +475,8 @@ def _mean(self, **kwargs): def _mean_mode_impl(self, attr, kwargs): if not self.bijector.is_constant_jacobian: - raise NotImplementedError('`mean` is not implemented for non-affine ' - '`bijectors`.') + raise NotImplementedError( + f'`{attr}` is not implemented for non-affine `bijectors`.') distribution_kwargs, bijector_kwargs = self._kwargs_split_fn(kwargs) x = getattr(self.distribution, attr)(**distribution_kwargs) From 2c2b0d212b39ff1d84fd200019c4318be25d0aff Mon Sep 17 00:00:00 2001 From: siege Date: Thu, 17 Mar 2022 21:31:00 -0700 Subject: [PATCH 041/153] Add experimental support for custom JAX PRNGs. The core issue is that when custom PRNGs are enabled, the seeds become instances of PRNGKeyArrays, which act as defective np.ndarrays: - They have no dtype field (!?) - Most of the numpy api is not implemented for them - They have a custom pytree registration logic - You cannot normally access the actual integers comprising the seeds My general strategy was to push as much of the complexity into the Numpy backend, where I had to rewrite a few of the implementations, with an eye towards general ndarray compatibility improving in the future. Most of the remaining changes deal with introspecting seeds (e.g. for seeding numpy's prngs) which is in general not allowed. I soft-deprecated calling sanitize_seed on two-tuples, where the idea was to specify the length-2 arrays comprising seeds directly: this operation is a bit suspect for JAX, as we're violating their API encapsulation. I removed all instances of this in TFP. It's probably a good idea to completely remove this feature eventually. People should use `jax.random.PRNGKey` instead of constructing 2 element arrays manually. Since custom PRNGs are still experimental I ran the TFP test use using the RBG PRNG manually, and added only a small amount of test coverage for the custom PRNGs in the core samplers.py library. While not everything passed, the vast majority of TFP will work with these fixes. PiperOrigin-RevId: 435535713 --- tensorflow_probability/python/build_defs.bzl | 30 +++++---- .../internal/statistical_testing_test.py | 2 +- .../diagonal_mass_matrix_adaptation_test.py | 12 ++-- .../sequential_monte_carlo_kernel_test.py | 9 ++- .../sequential/iterated_filter.py | 2 +- tensorflow_probability/python/internal/BUILD | 19 ++++++ .../python/internal/backend/numpy/BUILD | 1 + .../internal/backend/numpy/functional_ops.py | 38 +++++------ .../internal/backend/numpy/numpy_array.py | 23 +++++-- .../python/internal/backend/numpy/ops.py | 8 +++ .../python/internal/backend/numpy/test_lib.py | 3 +- .../python/internal/backend/numpy/v2.py | 6 +- .../python/internal/distribute_test_lib.py | 7 +- .../python/internal/samplers.py | 34 +++++++++- .../python/internal/samplers_test.py | 65 ++++++++++++++----- .../python/internal/test_util.py | 42 +++++++++--- .../python/internal/test_util_test.py | 24 ++++--- .../psd_kernels/exponential_curve_test.py | 6 +- tensorflow_probability/python/mcmc/BUILD | 1 + .../python/mcmc/hmc_test.py | 9 ++- .../python/mcmc/internal/util_test.py | 2 +- .../python/mcmc/sample_halton_sequence.py | 3 +- .../python/sts/decomposition_test.py | 5 +- tensorflow_probability/python/util/BUILD | 1 + .../python/util/seed_stream_test.py | 48 +++++--------- 25 files changed, 264 insertions(+), 136 deletions(-) diff --git a/tensorflow_probability/python/build_defs.bzl b/tensorflow_probability/python/build_defs.bzl index 71f6752ddb..83abc709af 100644 --- a/tensorflow_probability/python/build_defs.bzl +++ b/tensorflow_probability/python/build_defs.bzl @@ -330,20 +330,22 @@ def multi_substrate_py_test( tags.append("multi_substrate") test_targets = [] - native.py_test( - name = "{}.tf".format(name), - size = size, - srcs = srcs, - main = main or "{}.py".format(name), - deps = deps, - tags = tags + tf_tags, - srcs_version = srcs_version, - python_version = python_version, - timeout = timeout, - shard_count = shard_count, - args = args, - ) - test_targets.append(":{}.tf".format(name)) + + if "tf" not in disabled_substrates: + native.py_test( + name = "{}.tf".format(name), + size = size, + srcs = srcs, + main = main or "{}.py".format(name), + deps = deps, + tags = tags + tf_tags, + srcs_version = srcs_version, + python_version = python_version, + timeout = timeout, + shard_count = shard_count, + args = args, + ) + test_targets.append(":{}.tf".format(name)) if "numpy" not in disabled_substrates: numpy_srcs = _substrate_srcs(srcs, "numpy") diff --git a/tensorflow_probability/python/distributions/internal/statistical_testing_test.py b/tensorflow_probability/python/distributions/internal/statistical_testing_test.py index c823883704..274b4db35a 100644 --- a/tensorflow_probability/python/distributions/internal/statistical_testing_test.py +++ b/tensorflow_probability/python/distributions/internal/statistical_testing_test.py @@ -489,7 +489,7 @@ def test_do_maximum_mean(self, dtype): @parameterized.parameters(np.float32, np.float64) def test_random_projections(self, dtype): strm = test_util.test_seed_stream() - rng = np.random.RandomState(seed=strm() % 2**31) + rng = test_util.test_np_rng(strm()) num_samples = 57000 # Validate experiment design diff --git a/tensorflow_probability/python/experimental/distribute/diagonal_mass_matrix_adaptation_test.py b/tensorflow_probability/python/experimental/distribute/diagonal_mass_matrix_adaptation_test.py index 4cc2396254..ae03cc36f7 100644 --- a/tensorflow_probability/python/experimental/distribute/diagonal_mass_matrix_adaptation_test.py +++ b/tensorflow_probability/python/experimental/distribute/diagonal_mass_matrix_adaptation_test.py @@ -86,7 +86,8 @@ def run(seed): num_samples=10., mean=tf.zeros(3), variance=tf.ones(3))) pkr = kernel.bootstrap_results(state) - def body(draw_pkr, seed): + def body(draw_pkr, i): + seed = tf.gather(seeds, i) _, pkr = draw_pkr draw_seed, step_seed = samplers.split_seed(seed) draw = dist.sample(seed=draw_seed) @@ -95,7 +96,8 @@ def body(draw_pkr, seed): (_, pkr), draws = loop_util.trace_scan(body, (tf.zeros(dist.event_shape), pkr), - seeds, lambda v: v[0]) + tf.range(len(seeds)), + lambda v: v[0]) return draws, pkr @@ -124,7 +126,8 @@ def run(seed): tfp.experimental.stats.RunningVariance.from_stats( num_samples=10., mean=tf.zeros(3), variance=tf.ones(3))) pkr = kernel.bootstrap_results(state) - def body(draw_pkr, seed): + def body(draw_pkr, i): + seed = tf.gather(seeds, i) _, pkr = draw_pkr draw_seed, step_seed = samplers.split_seed(seed) draw = dist.sample(seed=draw_seed) @@ -133,7 +136,8 @@ def body(draw_pkr, seed): (_, pkr), draws = loop_util.trace_scan(body, (tf.zeros(dist.event_shape), pkr), - seeds, lambda v: v[0]) + tf.range(len(seeds)), + lambda v: v[0]) return draws, pkr draws, pkr = self.strategy_run(run, (self.key,), in_axes=None) diff --git a/tensorflow_probability/python/experimental/mcmc/sequential_monte_carlo_kernel_test.py b/tensorflow_probability/python/experimental/mcmc/sequential_monte_carlo_kernel_test.py index 0d0e6103f3..bc1dc936cd 100644 --- a/tensorflow_probability/python/experimental/mcmc/sequential_monte_carlo_kernel_test.py +++ b/tensorflow_probability/python/experimental/mcmc/sequential_monte_carlo_kernel_test.py @@ -84,9 +84,16 @@ def propose_and_update_log_weights_fn(_, weighted_particles, seed=None): (tf.nest.map_structure(tf.convert_to_tensor, state2), tf.nest.map_structure(tf.convert_to_tensor, results2))) + def compare_fn(x, y): + # TODO(b/223267515): PRNGKeyArrays have no dtype. + if hasattr(x, 'dtype'): + self.assertAllClose(x, y) + else: + self.assertSeedsEqual(x, y) + # Results should match. self.assertAllCloseNested(state, state2) - self.assertAllCloseNested(results, results2) + self.assertAllAssertsNested(compare_fn, results, results2) @test_util.numpy_disable_variable_test def testMarginalLikelihoodGradientIsDefined(self): diff --git a/tensorflow_probability/python/experimental/sequential/iterated_filter.py b/tensorflow_probability/python/experimental/sequential/iterated_filter.py index dcc2f6dbf3..d46b598e2a 100644 --- a/tensorflow_probability/python/experimental/sequential/iterated_filter.py +++ b/tensorflow_probability/python/experimental/sequential/iterated_filter.py @@ -566,7 +566,7 @@ def parameterized_infection_observations(_, state, parameters): # auto-vectorization enabled in `joint_prior_on_parameters_and_state`. num_particles_canary = 13 - canary_seed = samplers.sanitize_seed([0, 1]) + canary_seed = samplers.zeros_seed() def _get_shape_1(x): if hasattr(x, 'state'): x = x.state diff --git a/tensorflow_probability/python/internal/BUILD b/tensorflow_probability/python/internal/BUILD index e4c1a39cdd..9a912a834d 100644 --- a/tensorflow_probability/python/internal/BUILD +++ b/tensorflow_probability/python/internal/BUILD @@ -502,6 +502,24 @@ multi_substrate_py_test( ], ) +multi_substrate_py_test( + name = "samplers_rbg_test", + size = "small", + srcs = ["samplers_test.py"], + args = ["--test_tfp_jax_prng=rbg"], + disabled_substrates = [ + "tf", + "numpy", + ], + main = "samplers_test.py", + deps = [ + ":samplers", + # numpy dep, + # tensorflow dep, + "//tensorflow_probability/python/internal:test_util", + ], +) + multi_substrate_py_library( name = "special_math", srcs = ["special_math.py"], @@ -679,6 +697,7 @@ multi_substrate_py_library( srcs = ["test_util.py"], deps = [ ":dtype_util", + ":samplers", ":test_combinations", # absl/flags dep, # hypothesis dep, diff --git a/tensorflow_probability/python/internal/backend/numpy/BUILD b/tensorflow_probability/python/internal/backend/numpy/BUILD index 62625e4d99..a87d62613b 100644 --- a/tensorflow_probability/python/internal/backend/numpy/BUILD +++ b/tensorflow_probability/python/internal/backend/numpy/BUILD @@ -385,6 +385,7 @@ py_library( name = "test_lib", srcs = ["test_lib.py"], deps = [ + ":nest", # absl/logging dep, # absl/testing:absltest dep, # numpy dep, diff --git a/tensorflow_probability/python/internal/backend/numpy/functional_ops.py b/tensorflow_probability/python/internal/backend/numpy/functional_ops.py index 885438eedc..595e53fd7c 100644 --- a/tensorflow_probability/python/internal/backend/numpy/functional_ops.py +++ b/tensorflow_probability/python/internal/backend/numpy/functional_ops.py @@ -122,38 +122,35 @@ def _scan( # pylint: disable=unused-argument elems = nest.map_structure(lambda x: x[::-1], elems) if initializer is None: - if nest.is_nested(elems): - raise NotImplementedError - initializer = elems[0] - elems = elems[1:] - prepend = [[initializer]] + initializer = nest.map_structure( + lambda x: x[0], elems, expand_composites=True) + elems = nest.map_structure(lambda x: x[1:], elems, expand_composites=True) + prepend = initializer else: prepend = None - def func(arg, x): - return nest.flatten(fn(nest.pack_sequence_as(initializer, arg), - nest.pack_sequence_as(elems, x))) - - arg = nest.flatten(initializer) if JAX_MODE: from jax import lax # pylint: disable=g-import-not-at-top def scan_body(arg, x): - arg = func(arg, x) + arg = fn(arg, x) return arg, arg - _, out = lax.scan(scan_body, arg, nest.flatten(elems)) + + _, out = lax.scan(scan_body, initializer, elems) else: - out = [[] for _ in range(len(arg))] - for x in zip(*nest.flatten(elems)): - arg = func(arg, x) - for i, z in enumerate(arg): - out[i].append(z) + length = len(nest.flatten(elems)[0]) + arg = initializer + out = [] + for i in range(length): + arg = fn(arg, nest.map_structure(lambda x: x[i], elems)) # pylint: disable=cell-var-from-loop + out.append(arg) + out = nest.map_structure(lambda *x: np.stack(x, axis=0), *out) if prepend is not None: - out = [pre + list(o) for (pre, o) in zip(prepend, out)] + out = nest.map_structure( + lambda p, o: np.concatenate([p[np.newaxis], o], axis=0), prepend, out) ordering = (lambda x: x[::-1]) if reverse else (lambda x: x) - return nest.pack_sequence_as( - initializer, [ordering(np.array(o)) for o in out]) + return nest.map_structure(ordering, out, expand_composites=True) # --- Begin Public Functions -------------------------------------------------- @@ -185,4 +182,3 @@ def pfor(fn, n): scan = utils.copy_docstring( 'tf.scan', _scan) - diff --git a/tensorflow_probability/python/internal/backend/numpy/numpy_array.py b/tensorflow_probability/python/internal/backend/numpy/numpy_array.py index f7bc9be824..de47723460 100644 --- a/tensorflow_probability/python/internal/backend/numpy/numpy_array.py +++ b/tensorflow_probability/python/internal/backend/numpy/numpy_array.py @@ -89,6 +89,7 @@ def _gather( # pylint: disable=unused-argument batch_dims=0, name=None): """gather.""" + params = ops.convert_to_tensor(params) indices = ops.convert_to_tensor(indices, dtype_hint=np.int32) if validate_indices is not None: raise NotImplementedError( @@ -103,8 +104,8 @@ def _gather( # pylint: disable=unused-argument # ndarray and use in-place updates. For the Jax backend, this function # vmaps `np.take`. if JAX_MODE: - params = np.asarray(params) - indices = np.asarray(indices) + if batch_dims == 0 and axis == 0: + return params[indices] take = lambda params, indices: np.take(params, indices, # pylint: disable=g-long-lambda axis=axis - batch_dims) take = functools.reduce( @@ -360,6 +361,17 @@ def _split(value, num_or_size_splits, axis=0, num=None, name='split'): # pylint return np.split(value, indices_or_sections, axis) +def _stack(values, axis=0, name='stack'): + del name + values = [ops.convert_to_tensor(x) for x in values] + if values: + return np.stack(values, axis=axis) + else: + if axis != 0: + raise IndexError(f'Axis {axis} is out of range.') + return np.zeros([0], np.float32) + + def _transpose(a, perm=None, conjugate=False, name='transpose'): # pylint: disable=unused-argument x = np.transpose(ops.convert_to_tensor(a), perm) return np.conjugate(x) if conjugate else x @@ -367,7 +379,9 @@ def _transpose(a, perm=None, conjugate=False, name='transpose'): # pylint: disa def _unstack(value, num=None, axis=0, name='unstack'): del name - value = np.array(value) + value = ops.convert_to_tensor(value) + if axis == 0: + return list(value) return list( np.squeeze(x, axis=axis) for x in np.split(value, value.shape[axis] if num is None else num, axis)) @@ -480,8 +494,7 @@ def _zeros_like(input, dtype=None, name=None): # pylint: disable=redefined-buil lambda input, axis=None, name=None: np.squeeze(input, _astuple(axis))) stack = utils.copy_docstring( - 'tf.stack', lambda values, axis=0, name='stack': np.moveaxis( # pylint: disable=g-long-lambda - ops.convert_to_tensor(values), 0, axis)) + 'tf.stack', _stack) tile = utils.copy_docstring( 'tf.tile', diff --git a/tensorflow_probability/python/internal/backend/numpy/ops.py b/tensorflow_probability/python/internal/backend/numpy/ops.py index a6bec1fbc2..cfbfa4838c 100644 --- a/tensorflow_probability/python/internal/backend/numpy/ops.py +++ b/tensorflow_probability/python/internal/backend/numpy/ops.py @@ -212,6 +212,14 @@ def _is_int64(value): def _default_convert_to_tensor(value, dtype=None): """Default tensor conversion function for array, bool, int, float, and complex.""" + if JAX_MODE: + # TODO(b/223267515): We shouldn't need to specialize here. + if 'PRNGKeyArray' in str(type(value)): + return value + if isinstance(value, (list, tuple)) and value: + if 'PRNGKeyArray' in str(type(value[0])): + return np.stack(value, axis=0) + inferred_dtype = _infer_dtype(value, np.float32) # When a dtype is provided, we can go ahead and try converting to the dtype # and force overflow/underflow if an int64 is converted to an int32. diff --git a/tensorflow_probability/python/internal/backend/numpy/test_lib.py b/tensorflow_probability/python/internal/backend/numpy/test_lib.py index 50490aa2f6..d282ec00c8 100644 --- a/tensorflow_probability/python/internal/backend/numpy/test_lib.py +++ b/tensorflow_probability/python/internal/backend/numpy/test_lib.py @@ -21,6 +21,7 @@ from absl import logging from absl.testing import absltest import numpy as onp # Avoid JAX rewrite. # pylint: disable=reimported +from tensorflow_probability.python.internal.backend.numpy import nest try: # If TF is not imported, we return dummy `TestCase` and `Benchmark` classes @@ -57,7 +58,7 @@ def _evaluate(x): if x is None: return x return onp.array(x) - return tf.nest.map_structure(_evaluate, x) + return nest.map_structure(_evaluate, x, expand_composites=True) def _GetNdArray(self, a): return onp.array(a) diff --git a/tensorflow_probability/python/internal/backend/numpy/v2.py b/tensorflow_probability/python/internal/backend/numpy/v2.py index 52914c59fc..aa423edd0d 100644 --- a/tensorflow_probability/python/internal/backend/numpy/v2.py +++ b/tensorflow_probability/python/internal/backend/numpy/v2.py @@ -17,8 +17,6 @@ import collections import functools -import numpy as np - # pylint: disable=unused-import from tensorflow_probability.python.internal.backend.numpy import __internal__ from tensorflow_probability.python.internal.backend.numpy import _utils as utils @@ -72,8 +70,10 @@ def _function(func=None, input_signature=None, autograph=True, # pylint: disabl def non_jittable(arg): # Use static args for callables and for bools, which will sometimes # be used in a `if` block and fail if they are tracers. + # We use `type(True)` rather than `bool` because `bool` got overriden by + # an import above. return (arg is not None and - (callable(arg) or np.asarray(arg).dtype == np.bool_)) + (callable(arg) or isinstance(arg, type(True)))) def jit_decorator(f): cache = {} diff --git a/tensorflow_probability/python/internal/distribute_test_lib.py b/tensorflow_probability/python/internal/distribute_test_lib.py index 494a461fca..b82e154865 100644 --- a/tensorflow_probability/python/internal/distribute_test_lib.py +++ b/tensorflow_probability/python/internal/distribute_test_lib.py @@ -47,8 +47,11 @@ def setUp(self): def per_replica_to_tensor(self, value, axis=0): if JAX_MODE: # JAX, by default, stacks outputs along the first axis. - return tf.nest.map_structure( - lambda v: distribution_util.move_dimension(v, 0, axis), value) + if axis == 0: + return value + else: + return tf.nest.map_structure( + lambda v: distribution_util.move_dimension(v, 0, axis), value) return tf.nest.map_structure( lambda per_replica: tf.stack(per_replica.values, axis=axis), value) diff --git a/tensorflow_probability/python/internal/samplers.py b/tensorflow_probability/python/internal/samplers.py index 88343c5381..bd28e52921 100644 --- a/tensorflow_probability/python/internal/samplers.py +++ b/tensorflow_probability/python/internal/samplers.py @@ -27,7 +27,7 @@ from tensorflow_probability.python.internal import prefer_static as ps -# ** See PRNGS.md for more detailed discussion about this packge. ** +# ** See PRNGS.md for more detailed discussion about this package. ** __all__ = [ 'categorical', @@ -49,6 +49,9 @@ def zeros_seed(): + if JAX_MODE: + import jax # pylint: disable=g-import-not-at-top + return jax.random.PRNGKey(0) return tf.constant([0, 0], dtype=SEED_DTYPE) @@ -64,13 +67,16 @@ def sanitize_seed(seed, salt=None, name=None): for details. Operationally, `sanitize_seed` maps any seed flavor to a - "stateless-compatible" seed, namely a `int32[2]` Tensor. To wit: + "stateless-compatible" seed. Under TensorFlow and NumPy this means: - If the `seed` argument is an `int` or `None`, we use `tf.random.uniform` to _statefully_ draw a pair of unbounded `int32`s and wrap them into a Tensor. - If the `seed` argument is a stateless-compatible seed already, we just cast it to an `int32[2]` Tensor. + Under JAX, this function only accepts outputs from `jax.random.PRNGKey`, being + a no-op except for the salting behavior described below. + This, any function that accepts a `seed` argument can be written in stateless-seed style internally, and acquires TFP's seed-type-directed stateless/stateful switching behavior by just @@ -136,6 +142,28 @@ def sanitize_seed(seed, salt=None, name=None): return tf.convert_to_tensor(seed, dtype=SEED_DTYPE, name='seed') +def get_integer_seed(seed): + """Returns an integer seed in [0, 2**31). + + Args: + seed: A seed suitable to be passed to `sanitize_seed`. + + Returns: + integer_seed: A Python integer (if seed was a Python integer or we're in + JAX) or an integer Tensor. + """ + if isinstance(seed, six.integer_types): + return seed % (2**31) + seed = sanitize_seed(seed) + integer_seed = tf.random.stateless_uniform( + shape=[], seed=seed, minval=0, maxval=2**31, dtype=tf.int32) + if JAX_MODE: + # This function isn't ever used in a jit context, so we can eagerly convert + # it to an integer to simplify caller's code. + integer_seed = int(integer_seed) + return integer_seed + + def fold_in(seed, salt): """Folds salt into seed to form a new seed.""" if JAX_MODE: @@ -181,7 +209,7 @@ def split_seed(seed, n=2, salt=None, name=None): seed = sanitize_seed(seed, salt=salt) if JAX_MODE: from jax import random as jaxrand # pylint: disable=g-import-not-at-top - return jaxrand.split(seed, n) + return jaxrand.split(seed, int(n)) seeds = tf.random.stateless_uniform( [n, 2], seed=seed, minval=None, maxval=None, dtype=SEED_DTYPE) if isinstance(n, six.integer_types): diff --git a/tensorflow_probability/python/internal/samplers_test.py b/tensorflow_probability/python/internal/samplers_test.py index 95fbcaf308..ca8e08dade 100644 --- a/tensorflow_probability/python/internal/samplers_test.py +++ b/tensorflow_probability/python/internal/samplers_test.py @@ -14,16 +14,33 @@ # ============================================================================ """Tests for TFP-internal random samplers.""" +from absl import flags from absl.testing import parameterized +import numpy as np import tensorflow.compat.v2 as tf from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_util +flags.DEFINE_enum('test_tfp_jax_prng', 'default', ['default', 'rbg'], + 'Which PRNG implementation to test with.') + +FLAGS = flags.FLAGS +JAX_MODE = False +NUMPY_MODE = False + @test_util.test_all_tf_execution_regimes class RandomTest(test_util.TestCase): + def setUp(self): + super().setUp() + + if JAX_MODE and FLAGS.test_tfp_jax_prng != 'default': + from jax.config import config # pylint: disable=g-import-not-at-top + config.update('jax_enable_custom_prng', True) + config.update('jax_default_prng_impl', FLAGS.test_tfp_jax_prng) + @test_util.substrate_disable_stateful_random_test def test_sanitize_int(self): seed1 = samplers.sanitize_seed(seed=123) @@ -53,28 +70,38 @@ def test_sanitize_tensor_or_tensorlike(self): seed = test_util.test_seed(sampler_type='stateless') seed1 = samplers.sanitize_seed(seed=self.evaluate(seed)) seed2 = samplers.sanitize_seed(seed) - self.assertAllEqual(seed1, seed2) + seed1, seed2 = self.evaluate([seed1, seed2]) + self.assertSeedsEqual(seed1, seed2) + + seed3 = samplers.sanitize_seed([0, 1]) + seed4 = samplers.sanitize_seed(np.array([0, 1])) + seed3, seed4 = self.evaluate([seed3, seed4]) + self.assertSeedsEqual(seed3, seed4) def test_split(self): seed = test_util.test_seed(sampler_type='stateless') seed1, seed2 = samplers.split_seed(seed) seed3, seed4 = samplers.split_seed(seed) - self.assertNotAllEqual(seed, seed1) - self.assertNotAllEqual(seed, seed2) - self.assertNotAllEqual(seed1, seed2) - self.assertAllEqual(self.evaluate([seed1, seed2]), - self.evaluate([seed3, seed4])) + seed, seed1, seed2, seed3, seed4 = self.evaluate( + [seed, seed1, seed2, seed3, seed4]) + self.assertSeedsNotEqual(seed, seed1) + self.assertSeedsNotEqual(seed, seed2) + self.assertSeedsNotEqual(seed1, seed2) + self.assertSeedsEqual(seed1, seed3) + self.assertSeedsEqual(seed2, seed4) def test_salted_split(self): seed = test_util.test_seed(sampler_type='stateless') seed1, seed2 = samplers.split_seed(seed, salt='normal') seed3, seed4 = samplers.split_seed(seed, salt='lognormal') - self.assertNotAllEqual(seed, seed1) - self.assertNotAllEqual(seed, seed2) - self.assertNotAllEqual(seed1, seed2) - self.assertNotAllEqual(seed1, seed3) - self.assertNotAllEqual(seed2, seed4) - self.assertNotAllEqual(seed3, seed4) + seed, seed1, seed2, seed3, seed4 = self.evaluate( + [seed, seed1, seed2, seed3, seed4]) + self.assertSeedsNotEqual(seed, seed1) + self.assertSeedsNotEqual(seed, seed2) + self.assertSeedsNotEqual(seed1, seed2) + self.assertSeedsNotEqual(seed1, seed3) + self.assertSeedsNotEqual(seed2, seed4) + self.assertSeedsNotEqual(seed3, seed4) @parameterized.named_parameters( dict(testcase_name='_categorical', @@ -99,15 +126,19 @@ def test_salted_split(self): sampler=samplers.uniform, kwargs=dict(shape=[2]))) def test_sampler(self, sampler, kwargs): - s1 = sampler(seed=(1, 2), **kwargs) - s2 = sampler(seed=(1, 2), **kwargs) + if FLAGS.test_tfp_jax_prng == 'rbg' and sampler == samplers.gamma: + self.skipTest('gamma sampler not implemented for rbg PRNG.') + seed = test_util.test_seed(sampler_type='stateless') + s1 = sampler(seed=seed, **kwargs) + s2 = sampler(seed=seed, **kwargs) self.assertAllEqual(s1, s2) - self.verify_tf_behavior_match(sampler, kwargs) - @test_util.substrate_disable_stateful_random_test - def verify_tf_behavior_match(self, sampler, kwargs): # We don't test these scenarios for numpy, jax, where we don't support # stateful sampling. + if not JAX_MODE and not NUMPY_MODE: + self.verify_tf_behavior_match(sampler, kwargs) + + def verify_tf_behavior_match(self, sampler, kwargs): s1 = sampler(seed=123, **kwargs) s2 = sampler(seed=123, **kwargs) tf_sampler = getattr(tf.random, sampler.__name__) diff --git a/tensorflow_probability/python/internal/test_util.py b/tensorflow_probability/python/internal/test_util.py index ebaa79473b..66eac99316 100644 --- a/tensorflow_probability/python/internal/test_util.py +++ b/tensorflow_probability/python/internal/test_util.py @@ -31,6 +31,7 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python.bijectors import bijector from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_combinations from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.util.seed_stream import SeedStream @@ -172,6 +173,22 @@ def _one_part(*structure): # Drop the final two newlines. raise AssertionError(final_msg[:-2]) + def assertSeedsEqual(self, x, y, msg=None): + """Asserts that two PRNG seeds are equal.""" + self.assertAllEqual( + tf.nest.flatten(x, expand_composites=True), + tf.nest.flatten(y, expand_composites=True), + msg=msg) + + def assertSeedsNotEqual(self, x, y, msg=None): + """Asserts that two PRNG seeds are not equal.""" + self.assertFalse( + np.all( + np.equal( + tf.nest.flatten(x, expand_composites=True), + tf.nest.flatten(y, expand_composites=True))), + msg=msg) + def assertAllEqualNested(self, a, b, check_types=False, shallow=None): """Assert that analogous entries in two nested structures are equivalent. @@ -797,8 +814,9 @@ def test_seed(hardcoded_seed=None, set_eager_seed: Python bool. If true (default), invoke `tf.random.set_seed` in Eager mode to get more reproducibility. Should become unnecessary once b/68017812 is resolved. - sampler_type: 'stateful' or 'stateless'. 'stateless' means we return a seed - pair. + sampler_type: 'stateful', 'stateless' or 'integer'. 'stateless' + returns a seed suitable to pass to stateful PRNGs. 'integer' is returns a + seed suitable for PRNGs which expect single-integer seeds (e.g. numpy). Returns: seed: 17, unless otherwise specified by arguments or command line flags. @@ -816,19 +834,25 @@ def test_seed(hardcoded_seed=None, logging.warning('Using seed %s', answer) elif hardcoded_seed is not None: answer = hardcoded_seed - if JAX_MODE and np.shape(answer) == (2,): + if JAX_MODE and not isinstance(answer, int): # Workaround for test_seed(hardcoded_seed=test_seed()), which can happen # e.g. with the run_test_sample_consistent_log_prob methods above. - answer = answer[-1] + answer = samplers.get_integer_seed(answer) else: answer = 17 if sampler_type == 'stateless' or JAX_MODE: - answer = tf.constant([0, answer % (2**32 - 1)], dtype=tf.uint32) - if not JAX_MODE: + answer = answer % (2**32 - 1) + if JAX_MODE: + import jax # pylint: disable=g-import-not-at-top + answer = jax.random.PRNGKey(answer) + else: + answer = tf.constant([0, answer], dtype=tf.uint32) answer = tf.bitcast(answer, tf.int32) # TODO(b/68017812): Remove this clause once eager correctly supports seeding. elif tf.executing_eagerly() and set_eager_seed: tf.random.set_seed(answer) + if sampler_type == 'integer': + answer = samplers.get_integer_seed(answer) return answer @@ -900,10 +924,8 @@ def test_np_rng(hardcoded_seed=None): rng: A `np.random.RandomState` instance seeded with 17, unless otherwise specified by arguments or command line flags. """ - raw_seed = test_seed(hardcoded_seed=hardcoded_seed) - # Jax backend doesn't have the random module; but it shouldn't be needed, - # because this helper should only be used to generate test data. - return np.random.RandomState(seed=raw_seed % 2**32) + raw_seed = test_seed(hardcoded_seed=hardcoded_seed, sampler_type='integer') + return np.random.RandomState(seed=raw_seed) def floats_near(target, how_many, dtype=np.float32): diff --git a/tensorflow_probability/python/internal/test_util_test.py b/tensorflow_probability/python/internal/test_util_test.py index 3c56e081fd..957f2e85df 100644 --- a/tensorflow_probability/python/internal/test_util_test.py +++ b/tensorflow_probability/python/internal/test_util_test.py @@ -56,31 +56,29 @@ def testTypeCorrectness(self): def testSameness(self): with flagsaver.flagsaver(vary_seed=False): - self.assertAllEqual(test_util.test_seed(), test_util.test_seed()) - self.assertAllEqual(test_util.test_seed_stream()(), - test_util.test_seed_stream()()) + self.assertSeedsEqual(test_util.test_seed(), test_util.test_seed()) + self.assertSeedsEqual(test_util.test_seed_stream()(), + test_util.test_seed_stream()()) with flagsaver.flagsaver(fixed_seed=None): x = 47 expected = _maybe_jax(x) - self.assertAllEqual(expected, test_util.test_seed(hardcoded_seed=x)) + self.assertSeedsEqual(expected, test_util.test_seed(hardcoded_seed=x)) def testVariation(self): with flagsaver.flagsaver(vary_seed=True, fixed_seed=None): - self.assertFalse( - np.all(test_util.test_seed() == test_util.test_seed())) - self.assertFalse( - np.all(test_util.test_seed_stream()() == - test_util.test_seed_stream()())) + self.assertSeedsNotEqual(test_util.test_seed(), test_util.test_seed()) + self.assertSeedsNotEqual(test_util.test_seed_stream()(), + test_util.test_seed_stream()()) x = 47 expect_not = _maybe_jax(x) - self.assertFalse( - np.all(expect_not == test_util.test_seed(hardcoded_seed=x))) + self.assertSeedsNotEqual(expect_not, + test_util.test_seed(hardcoded_seed=x)) def testFixing(self): expected = _maybe_jax(58) with flagsaver.flagsaver(fixed_seed=58): - self.assertAllEqual(expected, test_util.test_seed()) - self.assertAllEqual(expected, test_util.test_seed(hardcoded_seed=47)) + self.assertSeedsEqual(expected, test_util.test_seed()) + self.assertSeedsEqual(expected, test_util.test_seed(hardcoded_seed=47)) class _TestCaseTest(object): diff --git a/tensorflow_probability/python/math/psd_kernels/exponential_curve_test.py b/tensorflow_probability/python/math/psd_kernels/exponential_curve_test.py index 2027121b15..e37d1d2c7e 100644 --- a/tensorflow_probability/python/math/psd_kernels/exponential_curve_test.py +++ b/tensorflow_probability/python/math/psd_kernels/exponential_curve_test.py @@ -60,11 +60,11 @@ def testValuesAreCorrect(self, dtype, batch_size): concentration = np.array(5., dtype=dtype) rate = np.array(.2, dtype=dtype) - np.random.seed(test_util.test_seed()) + rng = test_util.test_np_rng() k = tfp.math.psd_kernels.ExponentialCurve(concentration, rate) for _ in range(5): - x = np.random.uniform(0, 2, size=[batch_size, 3]).astype(dtype) - y = np.random.uniform(0, 2, size=[batch_size, 1]).astype(dtype) + x = rng.uniform(0, 2, size=[batch_size, 3]).astype(dtype) + y = rng.uniform(0, 2, size=[batch_size, 1]).astype(dtype) self.assertAllClose( self._numpyKernel(concentration, rate, x.sum(-1, keepdims=True), diff --git a/tensorflow_probability/python/mcmc/BUILD b/tensorflow_probability/python/mcmc/BUILD index 0931743d4a..f256d48e47 100644 --- a/tensorflow_probability/python/mcmc/BUILD +++ b/tensorflow_probability/python/mcmc/BUILD @@ -407,6 +407,7 @@ multi_substrate_py_library( # numpy dep, # tensorflow dep, "//tensorflow_probability/python/internal:dtype_util", + "//tensorflow_probability/python/internal:prefer_static", ], ) diff --git a/tensorflow_probability/python/mcmc/hmc_test.py b/tensorflow_probability/python/mcmc/hmc_test.py index d5aaccfb09..fa5cfd13a2 100644 --- a/tensorflow_probability/python/mcmc/hmc_test.py +++ b/tensorflow_probability/python/mcmc/hmc_test.py @@ -1154,11 +1154,18 @@ def testReproducibleSingleStepStatelessSeed(self): k.target_log_prob_fn(states[n - 1]), tr_nm1.accepted_results.target_log_prob) + def compare_fn(x, y): + # TODO(b/223267515): PRNGKeyArrays have no dtype. + if hasattr(x, 'dtype'): + self.assertAllClose(x, y) + else: + self.assertSeedsEqual(x, y) + # Rerun the kernel with the seed that it reported it used state, kr = k.one_step(states[n - 1], tr_nm1, seed=tr_n.seed) # Check that the results are the same self.assertAllClose(state, states[n]) - self.assertAllAssertsNested(self.assertAllClose, kr, tr_n) + self.assertAllAssertsNested(compare_fn, kr, tr_n) @test_util.test_all_tf_execution_regimes diff --git a/tensorflow_probability/python/mcmc/internal/util_test.py b/tensorflow_probability/python/mcmc/internal/util_test.py index 21c17d1c7b..0e58985e3f 100644 --- a/tensorflow_probability/python/mcmc/internal/util_test.py +++ b/tensorflow_probability/python/mcmc/internal/util_test.py @@ -193,7 +193,7 @@ def testGradientWorksForMultivariateNormalTriL(self): if not tf.executing_eagerly(): self.skipTest('Gradients get None values in graph mode.') d = tfd.MultivariateNormalTriL(scale_tril=tf.eye(2)) - x = d.sample(seed=(0, 0)) + x = d.sample(seed=test_util.test_seed()) fn_result, grads = util.maybe_call_fn_and_grads(d.log_prob, x) self.assertAllEqual(False, fn_result is None) self.assertAllEqual([False], [g is None for g in grads]) diff --git a/tensorflow_probability/python/mcmc/sample_halton_sequence.py b/tensorflow_probability/python/mcmc/sample_halton_sequence.py index 3aafa4c57d..f9d6cf2ce0 100644 --- a/tensorflow_probability/python/mcmc/sample_halton_sequence.py +++ b/tensorflow_probability/python/mcmc/sample_halton_sequence.py @@ -20,6 +20,7 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import samplers @@ -287,7 +288,7 @@ def _get_permutations(num_results, dims, seed=None): permutations: A `Tensor` of shape `[num_results, sum(dims)]` and the same dtype as `dims`. """ - seeds = samplers.split_seed(seed, n=tf.size(dims)) + seeds = samplers.split_seed(seed, n=ps.size(dims)) def generate_one(dim, seed): return tf.argsort(samplers.uniform([num_results, dim], seed=seed), axis=-1) diff --git a/tensorflow_probability/python/sts/decomposition_test.py b/tensorflow_probability/python/sts/decomposition_test.py index 268c02045d..26bbbfe34e 100644 --- a/tensorflow_probability/python/sts/decomposition_test.py +++ b/tensorflow_probability/python/sts/decomposition_test.py @@ -37,10 +37,9 @@ def _build_model_and_params(self, param_batch_shape, num_posterior_draws=10): seed = test_util.test_seed_stream() - np.random.seed(seed() % (2**32)) + rng = test_util.test_np_rng(seed()) observed_time_series = self._build_tensor( - np.random.randn(*(param_batch_shape + - [num_timesteps]))) + rng.randn(*(param_batch_shape + [num_timesteps]))) # Build an STS model with multiple components day_of_week = tfp.sts.Seasonal( diff --git a/tensorflow_probability/python/util/BUILD b/tensorflow_probability/python/util/BUILD index fb97c707e0..e0f2e27076 100644 --- a/tensorflow_probability/python/util/BUILD +++ b/tensorflow_probability/python/util/BUILD @@ -76,6 +76,7 @@ multi_substrate_py_test( deps = [ # tensorflow dep, "//tensorflow_probability", + "//tensorflow_probability/python/internal:samplers", "//tensorflow_probability/python/internal:test_util", ], ) diff --git a/tensorflow_probability/python/util/seed_stream_test.py b/tensorflow_probability/python/util/seed_stream_test.py index 301868762f..2dcfc98dcc 100644 --- a/tensorflow_probability/python/util/seed_stream_test.py +++ b/tensorflow_probability/python/util/seed_stream_test.py @@ -14,28 +14,12 @@ # ============================================================================ """Tests for the SeedStream class.""" -import numpy as np - import tensorflow_probability as tfp +from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_util -def _ensure_tuple(value): - """JAX/non-JAX compatibility. - - Helps with compatibilty between the scalar `int` seeds from vanilla - `SeedStream` and the `(2,)`-shaped `DeviceArray` from JAX `SeedStream`. - - Args: - value: `int` or `DeviceArray` to be converted. - - Returns: - `tuple` of one or two scalars. - """ - return tuple(np.reshape(np.asarray(value), [-1])) - - @test_util.test_all_tf_execution_regimes class SeedStreamTest(test_util.TestCase): @@ -47,30 +31,32 @@ def testNonRepetition(self): # PRNG is negligible; this test catches bugs that prevent state # updates. strm = tfp.util.SeedStream(seed=4, salt='salt') - output = [_ensure_tuple(strm()) for _ in range(50)] + output = [samplers.get_integer_seed(strm()) for _ in range(50)] self.assertEqual(sorted(output), sorted(list(set(output)))) def testReproducibility(self): strm1 = tfp.util.SeedStream(seed=4, salt='salt') strm2 = tfp.util.SeedStream(seed=4, salt='salt') strm3 = tfp.util.SeedStream(seed=4, salt='salt') - outputs = [_ensure_tuple(strm1()) for _ in range(50)] - self.assertEqual(outputs, [_ensure_tuple(strm2()) for _ in range(50)]) - self.assertEqual(outputs, [_ensure_tuple(strm3()) for _ in range(50)]) + outputs = [samplers.get_integer_seed(strm1()) for _ in range(50)] + self.assertEqual(outputs, + [samplers.get_integer_seed(strm2()) for _ in range(50)]) + self.assertEqual(outputs, + [samplers.get_integer_seed(strm3()) for _ in range(50)]) def testSeededDistinctness(self): strm1 = tfp.util.SeedStream(seed=4, salt='salt') strm2 = tfp.util.SeedStream(seed=5, salt='salt') self.assertAllUnique( - [_ensure_tuple(strm1()) for _ in range(50)] + - [_ensure_tuple(strm2()) for _ in range(50)]) + [samplers.get_integer_seed(strm1()) for _ in range(50)] + + [samplers.get_integer_seed(strm2()) for _ in range(50)]) def testSaltedDistinctness(self): strm1 = tfp.util.SeedStream(seed=4, salt='salt') strm2 = tfp.util.SeedStream(seed=4, salt='another salt') self.assertAllUnique( - [_ensure_tuple(strm1()) for _ in range(50)] + - [_ensure_tuple(strm2()) for _ in range(50)]) + [samplers.get_integer_seed(strm1()) for _ in range(50)] + + [samplers.get_integer_seed(strm2()) for _ in range(50)]) def testNestingRobustness(self): # SeedStreams started from generated seeds should not collide with @@ -78,18 +64,18 @@ def testNestingRobustness(self): strm1 = tfp.util.SeedStream(seed=4, salt='salt') strm2 = tfp.util.SeedStream(strm1(), salt='salt') strm3 = tfp.util.SeedStream(strm1(), salt='salt') - outputs = [_ensure_tuple(strm1()) for _ in range(50)] + outputs = [samplers.get_integer_seed(strm1()) for _ in range(50)] self.assertAllUnique( - outputs + [_ensure_tuple(strm2()) for _ in range(50)] + - [_ensure_tuple(strm3()) for _ in range(50)]) + outputs + [samplers.get_integer_seed(strm2()) for _ in range(50)] + + [samplers.get_integer_seed(strm3()) for _ in range(50)]) def testInitFromOtherSeedStream(self): strm1 = tfp.util.SeedStream(seed=4, salt='salt') strm2 = tfp.util.SeedStream(strm1, salt='salt') strm3 = tfp.util.SeedStream(strm1, salt='another salt') - out1 = [_ensure_tuple(strm1()) for _ in range(50)] - out2 = [_ensure_tuple(strm2()) for _ in range(50)] - out3 = [_ensure_tuple(strm3()) for _ in range(50)] + out1 = [samplers.get_integer_seed(strm1()) for _ in range(50)] + out2 = [samplers.get_integer_seed(strm2()) for _ in range(50)] + out3 = [samplers.get_integer_seed(strm3()) for _ in range(50)] self.assertAllEqual(out1, out2) self.assertAllUnique(out1 + out3) From fa84edf18189d5493f426547dcf334627f969646 Mon Sep 17 00:00:00 2001 From: fmuham Date: Fri, 18 Mar 2022 09:47:18 -0700 Subject: [PATCH 042/153] Delete redundant most_specific_compatible_type PiperOrigin-RevId: 435663524 --- .../python/internal/auto_composite_tensor.py | 27 --------------- .../python/util/deferred_tensor.py | 33 ------------------- 2 files changed, 60 deletions(-) diff --git a/tensorflow_probability/python/internal/auto_composite_tensor.py b/tensorflow_probability/python/internal/auto_composite_tensor.py index d81751681e..b1c04241b9 100644 --- a/tensorflow_probability/python/internal/auto_composite_tensor.py +++ b/tensorflow_probability/python/internal/auto_composite_tensor.py @@ -369,33 +369,6 @@ def common_supertype_or_equal(a, bs): return type(self)(*common_comparable[1:], self._callable_params) - # TODO(b/221472813): Delete this once default is deprecated. - def most_specific_compatible_type(self, other): - """Returns the most specific TypeSpec compatible with `self` and `other`. - - Deprecated. Use most_specific_common_supertype instead. - - Args: - other: A `TypeSpec`. - - Raises: - ValueError: If there is no TypeSpec that is compatible with both `self` - and `other`. - ValueError: If the `_callable_params` attributes of `self` and `other` are - not equal. - """ - if type(self) is not type(other): - raise ValueError( - f'No TypeSpec is compatible with both {self} and {other}.') - # pylint: disable=protected-access - if self._callable_params != other._callable_params: - raise ValueError(f'Callable parameters must be identical. Saw ' - f'{self._callable_params} and {other._callable_params}.') - merged = self._TypeSpec__most_specific_compatible_type_serialization( - self._comparable[:-1], other._comparable[:-1]) - # pylint: enable=protected-access - return type(self)(*merged[1:], self._callable_params) - def is_compatible_with(self, spec_or_value): """Returns true if `spec_or_value` is compatible with this TypeSpec.""" if not isinstance(spec_or_value, tf.TypeSpec): diff --git a/tensorflow_probability/python/util/deferred_tensor.py b/tensorflow_probability/python/util/deferred_tensor.py index d7dc931b82..88d132185b 100644 --- a/tensorflow_probability/python/util/deferred_tensor.py +++ b/tensorflow_probability/python/util/deferred_tensor.py @@ -672,39 +672,6 @@ def common_supertype_or_equal(a, bs): kwargs['transform_or_spec'] = self.transform_or_spec return type(self)(**kwargs, name=None) - # TODO(b/221472813): Delete this once default is deprecated. - def most_specific_compatible_type(self, other): - """Returns the most specific TypeSpec compatible with `self` and `other`. - - Deprecated. Use most_specific_common_supertype instead. - - Args: - other: A `TypeSpec`. - - Returns: - compatible_spec: The `TypeSpec` most compatible with `self` and `other`. - - Raises: - ValueError: If there is no TypeSpec that is compatible with both `self` - and `other`. - ValueError: If `self._transform_fn` is not a `CompositeTensor` and not - equal to `other._transform_fn`. - """ - if type(self) is not type(other): - raise ValueError( - f'No TypeSpec is compatible with both {self} and {other}.') - specs, params = self._TypeSpec__most_specific_compatible_type_serialization( - (self._specs, self._unique_id_params), - (other._specs, other._unique_id_params)) # pylint: disable=protected-access - kwargs = dict(specs, **params) - if not self._transform_is_composite: - if self.transform_or_spec != other.transform_or_spec: - raise ValueError( - f'{self.transform_or_spec} and {other.transform_or_spec} must be ' - f'identical.') - kwargs['transform_or_spec'] = self.transform_or_spec - return type(self)(**kwargs, name=None) - def is_compatible_with(self, spec_or_value): """Returns True if `spec_or_value` is compatible with this TypeSpec.""" if not isinstance(spec_or_value, tf.TypeSpec): From cfe750fa8149c7590502f5875a0375f11cc612bc Mon Sep 17 00:00:00 2001 From: colcarroll Date: Mon, 21 Mar 2022 12:16:44 -0700 Subject: [PATCH 043/153] Update SpikeSlabSampler to accept an argument weighting the default weights precision prior. PiperOrigin-RevId: 436273226 --- .../experimental/sts_gibbs/spike_and_slab.py | 16 +++++++--- .../sts_gibbs/spike_and_slab_test.py | 31 +++++++++++++++++-- 2 files changed, 39 insertions(+), 8 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index 62a21129e5..c08d4edf26 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -213,6 +213,7 @@ def __init__(self, design_matrix, nonzero_prior_prob=0.5, weights_prior_precision=None, + default_pseudo_observations=1., observation_noise_variance_prior_concentration=0.005, observation_noise_variance_prior_scale=0.0025, observation_noise_variance_upper_bound=None): @@ -229,10 +230,15 @@ def __init__(self, precision matrix(s) over the weights, of shape `[num_features, num_features]`. If not specified, defaults to the Zellner g-prior specified in `[1]` as - `Omega^{-1} = (X'X + diag(X'X)) / (2 * num_outputs)`, - in which we've plugged in the suggested defaults of `kappa = 1` and - `w = 0.5`. + `Omega^{-1} = kappa * (X'X + diag(X'X)) / (2 * num_outputs)`, + in which we've plugged in the suggested default of `w = 0.5`. The + parameter `kappa` is controlled by the `default_pseudo_observations` + argument. Default value: `None`. + default_pseudo_observations: scalar float `Tensor` + Controls the number of pseudo-observations for the prior precision + matrix over the weights. Corresponds to `kappa` in [1]. See also + `weights_prior_precision`. observation_noise_variance_prior_concentration: scalar float `Tensor` concentration parameter of the inverse gamma prior on the noise variance. Corresponds to `nu / 2` in [1]. @@ -270,8 +276,8 @@ def __init__(self, if weights_prior_precision is None: # Default prior: 'Zellner’s g−prior' from section 3.2.1 of [1]: # `omega^{-1} = kappa * (w X'X + (1 − w) diag(X'X))/n` - # with defaults `kappa = 1` and `w = 0.5`. - weights_prior_precision = tf.linalg.set_diag( + # with default `w = 0.5`. + weights_prior_precision = default_pseudo_observations * tf.linalg.set_diag( 0.5 * x_transpose_x, tf.linalg.diag_part(x_transpose_x)) / num_outputs diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py index 6f33aa55db..04a5200335 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py @@ -83,7 +83,30 @@ def _random_regression_task(self, num_outputs, num_features, batch_shape=(), batch_shape + [num_outputs], seed=noise_seed)) return design_matrix, weights, targets - def test_posterior_on_nonzero_subset_matches_bayesian_regression(self): + def test_sampler_respects_pseudo_observations(self): + design_matrix = self.evaluate( + samplers.uniform([2, 20, 5], seed=test_util.test_seed())) + first_obs = 2. + second_obs = 10. + first_sampler = spike_and_slab.SpikeSlabSampler( + design_matrix, + default_pseudo_observations=first_obs) + second_sampler = spike_and_slab.SpikeSlabSampler( + design_matrix, + default_pseudo_observations=second_obs) + + self.assertNotAllClose( + first_sampler.weights_prior_precision, + second_sampler.weights_prior_precision) + self.assertAllClose( + first_sampler.weights_prior_precision / first_obs, + second_sampler.weights_prior_precision / second_obs) + + @parameterized.named_parameters( + ('default_precision', 1.), + ('ten_pseudo_obs', 10.)) + def test_posterior_on_nonzero_subset_matches_bayesian_regression( + self, default_pseudo_observations): # Generate a synthetic regression task. design_matrix, _, targets = self.evaluate( self._random_regression_task( @@ -100,7 +123,9 @@ def test_posterior_on_nonzero_subset_matches_bayesian_regression(self): axis=ps.rank(x) - 1) # Compute the weight posterior mean and precision for these nonzeros. - sampler = spike_and_slab.SpikeSlabSampler(design_matrix) + sampler = spike_and_slab.SpikeSlabSampler( + design_matrix, + default_pseudo_observations=default_pseudo_observations) initial_state = sampler._initialize_sampler_state( targets=targets, nonzeros=nonzeros) @@ -125,7 +150,7 @@ def test_posterior_on_nonzero_subset_matches_bayesian_regression(self): restricted_weights_posterior_mean) self.assertAllClose( nonzero_submatrix(initial_state.conditional_posterior_precision_chol), - tf.linalg.cholesky(restricted_weights_posterior_prec.to_dense())) + tf.linalg.cholesky(restricted_weights_posterior_prec).to_dense()) def test_noise_variance_posterior_matches_expected(self): # Generate a synthetic regression task. From 02efab48517e04ac42f42e767532be2c63ba38e2 Mon Sep 17 00:00:00 2001 From: yileiyang Date: Tue, 22 Mar 2022 00:02:15 -0700 Subject: [PATCH 044/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 436398821 --- .../inference_gym/inference_gym/tools/stan/brownian_motion.py | 1 - .../inference_gym/tools/stan/item_response_theory.py | 1 - .../inference_gym/tools/stan/log_gaussian_cox_process.py | 1 - .../inference_gym/tools/stan/logistic_regression.py | 1 - spinoffs/inference_gym/inference_gym/tools/stan/lorenz_system.py | 1 - .../inference_gym/inference_gym/tools/stan/probit_regression.py | 1 - .../inference_gym/tools/stan/radon_contextual_effects.py | 1 - .../tools/stan/radon_contextual_effects_halfnormal.py | 1 - .../inference_gym/tools/stan/sparse_logistic_regression.py | 1 - spinoffs/inference_gym/inference_gym/tools/stan/stan_model.py | 1 - .../inference_gym/tools/stan/stochastic_volatility.py | 1 - spinoffs/inference_gym/inference_gym/tools/stan/targets.py | 1 - spinoffs/inference_gym/inference_gym/tools/stan/util.py | 1 - 13 files changed, 13 deletions(-) diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/brownian_motion.py b/spinoffs/inference_gym/inference_gym/tools/stan/brownian_motion.py index c49b23c1a6..d918e98e00 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/brownian_motion.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/brownian_motion.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/item_response_theory.py b/spinoffs/inference_gym/inference_gym/tools/stan/item_response_theory.py index 8cffac831f..84a921016c 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/item_response_theory.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/item_response_theory.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/log_gaussian_cox_process.py b/spinoffs/inference_gym/inference_gym/tools/stan/log_gaussian_cox_process.py index 24ff0fc697..e0d9c9c614 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/log_gaussian_cox_process.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/log_gaussian_cox_process.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/logistic_regression.py b/spinoffs/inference_gym/inference_gym/tools/stan/logistic_regression.py index a457ac20c9..92e637b649 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/logistic_regression.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/logistic_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/lorenz_system.py b/spinoffs/inference_gym/inference_gym/tools/stan/lorenz_system.py index ee49e6ec41..c364df62d6 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/lorenz_system.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/lorenz_system.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/probit_regression.py b/spinoffs/inference_gym/inference_gym/tools/stan/probit_regression.py index deccf6354d..f556bdd4a9 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/probit_regression.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/probit_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects.py b/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects.py index 070d045a21..ea7fc02989 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects_halfnormal.py b/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects_halfnormal.py index 097825c1dd..b84d18390e 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects_halfnormal.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/radon_contextual_effects_halfnormal.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/sparse_logistic_regression.py b/spinoffs/inference_gym/inference_gym/tools/stan/sparse_logistic_regression.py index a91f93c2c3..c27a6ccd5c 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/sparse_logistic_regression.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/sparse_logistic_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/stan_model.py b/spinoffs/inference_gym/inference_gym/tools/stan/stan_model.py index 6a9968be3d..2f68055f89 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/stan_model.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/stan_model.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/stochastic_volatility.py b/spinoffs/inference_gym/inference_gym/tools/stan/stochastic_volatility.py index 75006bf3d0..78f85a87e5 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/stochastic_volatility.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/stochastic_volatility.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/targets.py b/spinoffs/inference_gym/inference_gym/tools/stan/targets.py index af68b637ce..46c570ce17 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/targets.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/targets.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/stan/util.py b/spinoffs/inference_gym/inference_gym/tools/stan/util.py index 7bf1df87c1..f80f54d41a 100644 --- a/spinoffs/inference_gym/inference_gym/tools/stan/util.py +++ b/spinoffs/inference_gym/inference_gym/tools/stan/util.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); From 22929cf6e00bbeb892056dc344198d4fcb4e0d94 Mon Sep 17 00:00:00 2001 From: Googler Date: Tue, 22 Mar 2022 08:59:07 -0700 Subject: [PATCH 045/153] Expose SpikeSlabSampler argument weighting the default weights precision prior to the GibbsSampler interface Includes some reformatting PiperOrigin-RevId: 436487098 --- .../experimental/sts_gibbs/gibbs_sampler.py | 300 ++++++++++-------- 1 file changed, 160 insertions(+), 140 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index f7a932af62..14f61bb72b 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -82,17 +82,19 @@ class is somewhat general, in that we assume that any seasonal/holiday variation # parameters *in the same order* as they are listed in `model.parameters`. This # is currently enforced by construction in `build_gibbs_fittable_model`. GibbsSamplerState = collections.namedtuple( # pylint: disable=unexpected-keyword-arg - 'GibbsSamplerState', - ['observation_noise_scale', - 'level_scale', - 'weights', - 'level', - 'seed', - 'slope_scale', - 'slope',]) + 'GibbsSamplerState', [ + 'observation_noise_scale', + 'level_scale', + 'weights', + 'level', + 'seed', + 'slope_scale', + 'slope', + ]) # Make the two slope-related quantities optional, for backwards compatibility. -GibbsSamplerState.__new__.__defaults__ = (0., # slope_scale - 0.) # slope +GibbsSamplerState.__new__.__defaults__ = ( + 0., # slope_scale + 0.) # slope # TODO(b/151571025): revert to `tfd.InverseGamma` once its sampler is XLA-able. @@ -100,8 +102,8 @@ class XLACompilableInverseGamma(tfd.InverseGamma): def _sample_n(self, n, seed=None): return 1. / tfd.Gamma( - concentration=self.concentration, - rate=self.scale).sample(n, seed=seed) + concentration=self.concentration, rate=self.scale).sample( + n, seed=seed) class DummySpikeAndSlabPrior(tfd.Distribution): @@ -122,9 +124,8 @@ def event_shape(self): def _parameter_control_dependencies(self, is_init): if not is_init: - raise ValueError( - 'Cannot explicitly operate on a spike-and-slab prior; ' - 'only Gibbs sampling is supported.') + raise ValueError('Cannot explicitly operate on a spike-and-slab prior; ' + 'only Gibbs sampling is supported.') return [] def _default_event_space_bijector(self): @@ -145,13 +146,14 @@ def __init__(self, weights_prior_precision = weights_prior.precision() elif weights_prior is not None: inverse_scale = weights_prior.scale.inverse() - weights_prior_precision = inverse_scale.matmul(inverse_scale, - adjoint=True).to_dense() + weights_prior_precision = inverse_scale.matmul( + inverse_scale, adjoint=True).to_dense() self._weights_prior_precision = weights_prior_precision self._sparse_weights_nonzero_prob = sparse_weights_nonzero_prob - super().__init__(design_matrix=design_matrix, - weights_prior=DummySpikeAndSlabPrior(), - name=name) + super().__init__( + design_matrix=design_matrix, + weights_prior=DummySpikeAndSlabPrior(), + name=name) def _tile_normal_to_mvn_diag(normal_dist, dim): @@ -162,9 +164,8 @@ def _tile_normal_to_mvn_diag(normal_dist, dim): def _is_multivariate_normal(dist): - return (isinstance(dist, tfd.MultivariateNormalLinearOperator) or - isinstance(dist, - tfde.MultivariateNormalPrecisionFactorLinearOperator)) + return (isinstance(dist, tfd.MultivariateNormalLinearOperator) or isinstance( + dist, tfde.MultivariateNormalPrecisionFactorLinearOperator)) def build_model_for_gibbs_fitting(observed_time_series, @@ -189,9 +190,9 @@ def build_model_for_gibbs_fitting(observed_time_series, specifying an observed time series. May optionally be an instance of `tfp.sts.MaskedTimeSeries`, which includes a mask `Tensor` to specify timesteps with missing observations. - design_matrix: float `Tensor` of shape `concat([batch_shape, - [num_timesteps, num_features]])`. This may also optionally be - an instance of `tf.linalg.LinearOperator`. + design_matrix: float `Tensor` of shape `concat([batch_shape, [num_timesteps, + num_features]])`. This may also optionally be an instance of + `tf.linalg.LinearOperator`. weights_prior: Optional distribution instance specifying a normal prior on weights. This may be a multivariate normal instance with event shape `[num_features]`, or a scalar normal distribution with event shape `[]`. @@ -208,9 +209,9 @@ def build_model_for_gibbs_fitting(observed_time_series, representing a prior on the observation noise variance ( `observation_noise_scale**2`). May have batch shape broadcastable to the batch shape of `observed_time_series`. - slope_variance_prior: Optional instance of `tfd.InverseGamma` representing - a prior on slope variance (`slope_scale**2`) of a local linear trend - model. May have batch shape broadcastable to the batch shape of + slope_variance_prior: Optional instance of `tfd.InverseGamma` representing a + prior on slope variance (`slope_scale**2`) of a local linear trend model. + May have batch shape broadcastable to the batch shape of `observed_time_series`. If specified, a local linear trend model is used rather than a local level model. Default value: `None`. @@ -220,6 +221,7 @@ def build_model_for_gibbs_fitting(observed_time_series, `sparse_weights_nonzero_prob` is the prior probability of the 'slab' component. Default value: `None`. + Returns: model: A `tfp.sts.StructuralTimeSeries` model instance. """ @@ -267,26 +269,30 @@ def build_model_for_gibbs_fitting(observed_time_series, sparse_weights_nonzero_prob=sparse_weights_nonzero_prob, name='sparse_regression') else: - regression = sts.LinearRegression(design_matrix=design_matrix, - weights_prior=weights_prior, - name='regression') - model = sts.Sum([local_variation, regression], - observed_time_series=observed_time_series, - observation_noise_scale_prior=sqrt( - observation_noise_variance_prior), - # The Gibbs sampling steps in this file do not account for an - # offset to the observed series. Instead, we assume the - # observed series has already been centered and - # scale-normalized. - constant_offset=0.) + regression = sts.LinearRegression( + design_matrix=design_matrix, + weights_prior=weights_prior, + name='regression') + model = sts.Sum( + [local_variation, regression], + observed_time_series=observed_time_series, + observation_noise_scale_prior=sqrt(observation_noise_variance_prior), + # The Gibbs sampling steps in this file do not account for an + # offset to the observed series. Instead, we assume the + # observed series has already been centered and + # scale-normalized. + constant_offset=0.) model.supports_gibbs_sampling = True return model def _get_design_matrix(model): """Returns the design matrix for an STS model with a regression component.""" - design_matrices = [component.design_matrix for component in model.components - if hasattr(component, 'design_matrix')] + design_matrices = [ + component.design_matrix + for component in model.components + if hasattr(component, 'design_matrix') + ] if not design_matrices: raise ValueError('Model does not contain a regression component.') if len(design_matrices) > 1: @@ -300,15 +306,16 @@ def fit_with_gibbs_sampling(model, num_results=2000, num_warmup_steps=200, initial_state=None, - seed=None): + seed=None, + default_pseudo_observations=None): """Fits parameters for an STS model using Gibbs sampling. Args: model: A `tfp.sts.StructuralTimeSeries` model instance return by `build_model_for_gibbs_fitting`. - observed_time_series: `float` `Tensor` of shape [..., T, 1]` - (omitting the trailing unit dimension is also supported when `T > 1`), - specifying an observed time series. May optionally be an instance of + observed_time_series: `float` `Tensor` of shape [..., T, 1]` (omitting the + trailing unit dimension is also supported when `T > 1`), specifying an + observed time series. May optionally be an instance of `tfp.sts.MaskedTimeSeries`, which includes a mask `Tensor` to specify timesteps with missing observations. num_chains: Optional int to indicate the number of parallel MCMC chains. @@ -318,6 +325,10 @@ def fit_with_gibbs_sampling(model, initial_state: A `GibbsSamplerState` structure of the initial states of the MCMC chains. seed: Optional `Python` `int` seed controlling the sampled values. + default_pseudo_observations: Optional scalar float `Tensor` Controls the + number of pseudo-observations for the prior precision matrix over the + weights. + Returns: model: A `GibbsSamplerState` structure of posterior samples. """ @@ -328,11 +339,8 @@ def fit_with_gibbs_sampling(model, if not tf.nest.is_nested(num_chains): num_chains = [num_chains] - [ - observed_time_series, - is_missing - ] = sts_util.canonicalize_observed_time_series_with_mask( - observed_time_series) + [observed_time_series, is_missing + ] = sts_util.canonicalize_observed_time_series_with_mask(observed_time_series) dtype = observed_time_series.dtype # The canonicalized time series always has trailing dimension `1`, @@ -341,8 +349,7 @@ def fit_with_gibbs_sampling(model, # remove this dimension. observed_time_series = observed_time_series[..., 0] batch_shape = prefer_static.concat( - [num_chains, - prefer_static.shape(observed_time_series)[:-1]], axis=-1) + [num_chains, prefer_static.shape(observed_time_series)[:-1]], axis=-1) level_slope_shape = prefer_static.concat( [num_chains, prefer_static.shape(observed_time_series)], axis=-1) @@ -359,9 +366,10 @@ def fit_with_gibbs_sampling(model, observation_noise_scale=tf.ones(batch_shape, dtype=dtype), level_scale=tf.ones(batch_shape, dtype=dtype), slope_scale=initial_slope_scale, - weights=tf.zeros(prefer_static.concat([ - batch_shape, - _get_design_matrix(model).shape[-1:]], axis=0), dtype=dtype), + weights=tf.zeros( + prefer_static.concat( + [batch_shape, _get_design_matrix(model).shape[-1:]], axis=0), + dtype=dtype), level=tf.zeros(level_slope_shape, dtype=dtype), slope=initial_slope, seed=None) # Set below. @@ -373,13 +381,12 @@ def fit_with_gibbs_sampling(model, initial_state = initial_state._replace( seed=samplers.sanitize_seed(seed, salt='initial_GibbsSamplerState')) - sampler_loop_body = _build_sampler_loop_body(model, - observed_time_series, - is_missing) + sampler_loop_body = _build_sampler_loop_body(model, observed_time_series, + is_missing, + default_pseudo_observations) samples = tf.scan(sampler_loop_body, - np.arange(num_warmup_steps + num_results), - initial_state) + np.arange(num_warmup_steps + num_results), initial_state) return tf.nest.map_structure(lambda x: x[num_warmup_steps:], samples) @@ -423,17 +430,17 @@ def one_step_predictive(model, samples, to reduce complexity of the predictive distribution. For example, if `thin_every=10`, every `10`th sample will be used. Default value: `10`. + Returns: predictive_dist: A `tfd.MixtureSameFamily` instance of event shape `[num_timesteps + num_forecast_steps]` representing the predictive distribution of each timestep given previous timesteps. """ dtype = dtype_util.common_dtype([ - posterior_samples.level_scale, - posterior_samples.observation_noise_scale, - posterior_samples.level, - original_mean, - original_scale], dtype_hint=tf.float32) + posterior_samples.level_scale, posterior_samples.observation_noise_scale, + posterior_samples.level, original_mean, original_scale + ], + dtype_hint=tf.float32) num_observed_steps = prefer_static.shape(posterior_samples.level)[-1] original_mean = tf.convert_to_tensor(original_mean, dtype=dtype) @@ -449,7 +456,9 @@ def one_step_predictive(model, num_steps_from_last_observation = tf.concat([ tf.ones([num_observed_steps], dtype=dtype), - tf.range(1, num_forecast_steps + 1, dtype=dtype)], axis=0) + tf.range(1, num_forecast_steps + 1, dtype=dtype) + ], + axis=0) # The local linear trend model expects that the level at step t + 1 is equal # to the level at step t, plus the slope at time t - 1, @@ -458,29 +467,31 @@ def one_step_predictive(model, num_batch_dims = prefer_static.rank_from_shape( prefer_static.shape(thinned_samples.level)) - 2 # All else equal, the current level will remain stationary. - forecast_level = tf.tile(thinned_samples.level[..., -1:], - tf.concat([tf.ones([num_batch_dims + 1], - dtype=tf.int32), - [num_forecast_steps]], axis=0)) + forecast_level = tf.tile( + thinned_samples.level[..., -1:], + tf.concat([ + tf.ones([num_batch_dims + 1], dtype=tf.int32), [num_forecast_steps] + ], + axis=0)) # If the model includes slope, the level will steadily increase. - forecast_level += (thinned_samples.slope[..., -1:] * - tf.range(1., num_forecast_steps + 1., - dtype=forecast_level.dtype)) - - level_pred = tf.concat([thinned_samples.level[..., :1], # t == 0 - (thinned_samples.level[..., :-1] + - thinned_samples.slope[..., :-1]) # 1 <= t < T - ] + ( - [forecast_level] - if num_forecast_steps > 0 else []), - axis=-1) - - design_matrix = _get_design_matrix( - model).to_dense()[:num_observed_steps + num_forecast_steps] + forecast_level += ( + thinned_samples.slope[..., -1:] * + tf.range(1., num_forecast_steps + 1., dtype=forecast_level.dtype)) + + level_pred = tf.concat( + [ + thinned_samples.level[..., :1], # t == 0 + (thinned_samples.level[..., :-1] + thinned_samples.slope[..., :-1] + ) # 1 <= t < T + ] + ([forecast_level] if num_forecast_steps > 0 else []), + axis=-1) + + design_matrix = _get_design_matrix(model).to_dense()[:num_observed_steps + + num_forecast_steps] regression_effect = tf.linalg.matvec(design_matrix, thinned_samples.weights) - y_mean = ((level_pred + regression_effect) * - original_scale[..., tf.newaxis] + original_mean[..., tf.newaxis]) + y_mean = ((level_pred + regression_effect) * original_scale[..., tf.newaxis] + + original_mean[..., tf.newaxis]) # To derive a forecast variance, including slope uncertainty, let # `r[:k]` be iid Gaussian RVs with variance `level_scale**2` and `s[:k]` be @@ -503,15 +514,16 @@ def one_step_predictive(model, # (k - 1) * k * (2 * k - 1) / 6. # # [1] https://en.wikipedia.org/wiki/Square_pyramidal_number - variance_from_level = (thinned_samples.level_scale[..., tf.newaxis]**2 * - num_steps_from_last_observation) + variance_from_level = ( + thinned_samples.level_scale[..., tf.newaxis]**2 * + num_steps_from_last_observation) variance_from_slope = thinned_samples.slope_scale[..., tf.newaxis]**2 * ( - (num_steps_from_last_observation - 1) * - num_steps_from_last_observation * + (num_steps_from_last_observation - 1) * num_steps_from_last_observation * (2 * num_steps_from_last_observation - 1)) / 6. - y_scale = (original_scale * tf.sqrt( - thinned_samples.observation_noise_scale[..., tf.newaxis]**2 + - variance_from_level + variance_from_slope)) + y_scale = ( + original_scale * + tf.sqrt(thinned_samples.observation_noise_scale[..., tf.newaxis]**2 + + variance_from_level + variance_from_slope)) num_posterior_draws = prefer_static.shape(y_mean)[0] return tfd.MixtureSameFamily( @@ -522,8 +534,11 @@ def one_step_predictive(model, scale=dist_util.move_dimension(y_scale, 0, -1))) -def _resample_weights(design_matrix, target_residuals, observation_noise_scale, - weights_prior_scale, seed=None): +def _resample_weights(design_matrix, + target_residuals, + observation_noise_scale, + weights_prior_scale, + seed=None): """Samples regression weights from their conditional posterior. This assumes a conjugate normal regression model, @@ -538,16 +553,16 @@ def _resample_weights(design_matrix, target_residuals, observation_noise_scale, observation_noise_scale, design_matrix)`. Args: - design_matrix: Float `Tensor` design matrix of shape - `[..., num_timesteps, num_features]`. + design_matrix: Float `Tensor` design matrix of shape `[..., num_timesteps, + num_features]`. target_residuals: Float `Tensor` of shape `[..., num_observations]` observation_noise_scale: Scalar float `Tensor` (with optional batch shape) standard deviation of the iid observation noise. weights_prior_scale: Instance of `tf.linalg.LinearOperator` of shape - `[num_features, num_features]` (with optional batch shape), - specifying the scale of a multivariate Normal prior on regression - weights. + `[num_features, num_features]` (with optional batch shape), specifying the + scale of a multivariate Normal prior on regression weights. seed: Optional `Python` `int` seed controlling the sampled values. + Returns: weights: Float `Tensor` of shape `[..., num_features]`, sampled from the conditional posterior `p(weights | target_residuals, @@ -564,7 +579,9 @@ def _resample_weights(design_matrix, target_residuals, observation_noise_scale, sampled_weights = weights_prec.cholesky().solvevec( samplers.normal( shape=prefer_static.shape(weights_mean), - dtype=design_matrix.dtype, seed=seed), adjoint=True) + dtype=design_matrix.dtype, + seed=seed), + adjoint=True) return weights_mean + sampled_weights @@ -588,18 +605,19 @@ def _resample_latents(observed_residuals, Args: observed_residuals: Float `Tensor` of shape `[..., num_observations]`, specifying the centered observations `(x - loc)`. - level_scale: Float scalar `Tensor` (may contain batch dimensions) - specifying the standard deviation of the level random walk steps. + level_scale: Float scalar `Tensor` (may contain batch dimensions) specifying + the standard deviation of the level random walk steps. observation_noise_scale: Float scalar `Tensor` (may contain batch dimensions) specifying the standard deviation of the observation noise. initial_state_prior: instance of `tfd.MultivariateNormalLinearOperator`. slope_scale: Optional float scalar `Tensor` (may contain batch dimensions) - specifying the standard deviation of slope random walk steps. If - provided, a `LocalLinearTrend` model is used, otherwise, a `LocalLevel` - model is used. + specifying the standard deviation of slope random walk steps. If provided, + a `LocalLinearTrend` model is used, otherwise, a `LocalLevel` model is + used. is_missing: Optional `bool` `Tensor` missingness mask. sample_shape: Optional `int` `Tensor` shape of samples to draw. seed: `int` `Tensor` of shape `[2]` controlling stateless sampling. + Returns: latents: Float `Tensor` resampled latent level, of shape `[..., num_timesteps, latent_size]`, where `...` concatenates the @@ -621,15 +639,14 @@ def _resample_latents(observed_residuals, level_scale=level_scale, slope_scale=slope_scale) - return ssm.posterior_sample(observed_residuals[..., tf.newaxis], - sample_shape=sample_shape, - mask=is_missing, - seed=seed) + return ssm.posterior_sample( + observed_residuals[..., tf.newaxis], + sample_shape=sample_shape, + mask=is_missing, + seed=seed) -def _resample_scale(prior, observed_residuals, - is_missing=None, - seed=None): +def _resample_scale(prior, observed_residuals, is_missing=None, seed=None): """Samples a scale parameter from its conditional posterior. We assume the conjugate InverseGamma->Normal model: @@ -649,23 +666,23 @@ def _resample_scale(prior, observed_residuals, is_missing: Optional `bool` `Tensor` of shape `[..., num_observations]`. A `True` value indicates that the corresponding observation is missing. seed: Optional `Python` `int` seed controlling the sampled value. + Returns: sampled_scale: A `Tensor` sample from the posterior `p(scale | x)`. """ if is_missing is not None: - num_missing = tf.reduce_sum(tf.cast(is_missing, observed_residuals.dtype), - axis=-1) + num_missing = tf.reduce_sum( + tf.cast(is_missing, observed_residuals.dtype), axis=-1) num_observations = prefer_static.shape(observed_residuals)[-1] if is_missing is not None: - observed_residuals = tf.where(is_missing, - tf.zeros_like(observed_residuals), + observed_residuals = tf.where(is_missing, tf.zeros_like(observed_residuals), observed_residuals) num_observations -= num_missing variance_posterior = type(prior)( concentration=prior.concentration + num_observations / 2., - scale=prior.scale + tf.reduce_sum( - tf.square(observed_residuals), axis=-1) / 2.) + scale=prior.scale + + tf.reduce_sum(tf.square(observed_residuals), axis=-1) / 2.) new_scale = tf.sqrt(variance_posterior.sample(seed=seed)) # Support truncated priors. @@ -677,16 +694,21 @@ def _resample_scale(prior, observed_residuals, def _build_sampler_loop_body(model, observed_time_series, - is_missing=None): + is_missing=None, + default_pseudo_observations=None): """Builds a Gibbs sampler for the given model and observed data. Args: model: A `tf.sts.StructuralTimeSeries` model instance. This must be of the form constructed by `build_model_for_gibbs_sampling`. - observed_time_series: Float `Tensor` time series of shape - `[..., num_timesteps]`. + observed_time_series: Float `Tensor` time series of shape `[..., + num_timesteps]`. is_missing: Optional `bool` `Tensor` of shape `[..., num_timesteps]`. A `True` value indicates that the observation for that timestep is missing. + default_pseudo_observations: Optional scalar float `Tensor` Controls the + number of pseudo-observations for the prior precision matrix over the + weights. + Returns: sampler_loop_body: Python callable that performs a single cycle of Gibbs sampling. Its first argument is a `GibbsSamplerState`, and it returns a @@ -722,8 +744,7 @@ def _build_sampler_loop_body(model, # Replace design matrix with zeros at unobserved timesteps. This ensures # they will not affect the posterior on weights. design_matrix = tf.where(is_missing[..., tf.newaxis], - tf.zeros_like(design_matrix), - design_matrix) + tf.zeros_like(design_matrix), design_matrix) # Untransform scale priors -> variance priors by reaching thru Sqrt bijector. observation_noise_param = model.parameters[0] @@ -733,7 +754,8 @@ def _build_sampler_loop_body(model, observation_noise_variance_prior = observation_noise_param.prior.distribution if model_has_slope: level_scale_variance_prior, slope_scale_variance_prior = [ - p.prior.distribution for p in level_component.parameters] + p.prior.distribution for p in level_component.parameters + ] else: level_scale_variance_prior = ( level_component.parameters[0].prior.distribution) @@ -748,20 +770,18 @@ def _build_sampler_loop_body(model, observation_noise_variance_prior_scale=( observation_noise_variance_prior.scale), observation_noise_variance_upper_bound=( - observation_noise_variance_prior.upper_bound - if hasattr(observation_noise_variance_prior, 'upper_bound') - else None)) + observation_noise_variance_prior.upper_bound if hasattr( + observation_noise_variance_prior, 'upper_bound') else None), + **({ + 'default_pseudo_observations': default_pseudo_observations + } if default_pseudo_observations is not None else {})) else: - weights_prior_scale = ( - regression_component.parameters[0].prior.scale) + weights_prior_scale = (regression_component.parameters[0].prior.scale) def sampler_loop_body(previous_sample, _): """Runs one sampler iteration, resampling all model variables.""" - (weights_seed, - level_seed, - observation_noise_scale_seed, - level_scale_seed, + (weights_seed, level_seed, observation_noise_scale_seed, level_scale_seed, loop_seed) = samplers.split_seed( previous_sample.seed, n=5, salt='sampler_loop_body') # Preserve backward-compatible seed behavior by splitting slope separately. @@ -832,11 +852,11 @@ def sampler_loop_body(previous_sample, _): return GibbsSamplerState( observation_noise_scale=observation_noise_scale, level_scale=level_scale, - slope_scale=(slope_scale if model_has_slope - else previous_sample.slope_scale), + slope_scale=(slope_scale + if model_has_slope else previous_sample.slope_scale), weights=weights, level=level, - slope=(slope if model_has_slope - else previous_sample.slope), + slope=(slope if model_has_slope else previous_sample.slope), seed=loop_seed) + return sampler_loop_body From c2ac74062cce44e650c8452299e79478cdd2e15b Mon Sep 17 00:00:00 2001 From: emilyaf Date: Tue, 22 Mar 2022 11:17:38 -0700 Subject: [PATCH 046/153] Update generated LinearOperator files. PiperOrigin-RevId: 436522686 --- .../backend/numpy/gen/linear_operator_composition.py | 9 ++++++++- .../python/internal/backend/numpy/gen/tensor_shape.py | 1 + 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py index fb7432b6cb..a94f703534 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py @@ -38,6 +38,7 @@ from tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape from tensorflow_probability.python.internal.backend.numpy import numpy_array as array_ops from tensorflow_probability.python.internal.backend.numpy import debugging as check_ops +from tensorflow_probability.python.internal.backend.numpy import control_flow as control_flow_ops from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator # from tensorflow.python.util.tf_export import tf_export @@ -185,7 +186,7 @@ def __init__(self, # Auto-set and check hints. if all(operator.is_non_singular for operator in operators): - if is_non_singular is False: + if is_non_singular is False: # pylint:disable=g-bool-id-comparison raise ValueError( "The composition of non-singular operators is always non-singular.") is_non_singular = True @@ -296,6 +297,12 @@ def _solve(self, rhs, adjoint=False, adjoint_arg=False): solution = operator.solve(solution, adjoint=adjoint) return solution + def _assert_non_singular(self): + if all(operator.is_square for operator in self.operators): + asserts = [operator.assert_non_singular() for operator in self.operators] + return control_flow_ops.group(asserts) + return super(LinearOperatorComposition, self)._assert_non_singular() + @property def _composite_tensor_fields(self): return ("operators",) diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py b/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py index d02b0a92a6..4156cf394b 100755 --- a/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/tensor_shape.py @@ -297,6 +297,7 @@ def value(self): """The value of this dimension, or None if it is unknown.""" return self._value + # TODO(b/225058047): Reconsider semantics. def is_compatible_with(self, other): """Returns true if `other` is compatible with this Dimension. From 9750074326e57fcec5a51cc2d3b0d26baabec066 Mon Sep 17 00:00:00 2001 From: emilyaf Date: Tue, 22 Mar 2022 12:49:11 -0700 Subject: [PATCH 047/153] Add `experimental_from_mean_variance` factory method to tfd.LogNormal. PiperOrigin-RevId: 436545771 --- .../python/distributions/BUILD | 1 + .../python/distributions/lognormal.py | 28 +++++++++++++++ .../python/distributions/lognormal_test.py | 35 +++++++++++++++++++ 3 files changed, 64 insertions(+) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index 0edbb6d567..0972c4a032 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -1272,6 +1272,7 @@ multi_substrate_py_library( "//tensorflow_probability/python/internal:assert_util", "//tensorflow_probability/python/internal:dtype_util", "//tensorflow_probability/python/internal:parameter_properties", + "//tensorflow_probability/python/internal:tensor_util", ], ) diff --git a/tensorflow_probability/python/distributions/lognormal.py b/tensorflow_probability/python/distributions/lognormal.py index 6191fe946c..5e46082348 100644 --- a/tensorflow_probability/python/distributions/lognormal.py +++ b/tensorflow_probability/python/distributions/lognormal.py @@ -24,6 +24,9 @@ from tensorflow_probability.python.internal import assert_util from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties +from tensorflow_probability.python.internal import tensor_util +from tensorflow_probability.python.util.deferred_tensor import DeferredTensor + __all__ = [ 'LogNormal', @@ -91,6 +94,31 @@ def scale(self): experimental_is_sharded = False + @classmethod + def experimental_from_mean_variance(cls, mean, variance, **kwargs): + """Constructs a LogNormal from its mean and variance. + + **Experimental: Naming, location of this API may change.** + + Args: + mean: The mean of the constructed distribution. Must be greater than 0. + variance: The variance of the distribution. Must be greater than 0. + **kwargs: Other keyword arguments passed directly to `__init__`, e.g. + `validate_args`. + + Returns: + lognormal: A distribution with the given parameterization. + """ + dtype = dtype_util.common_dtype([mean, variance], dtype_hint=tf.float32) + mean = tensor_util.convert_nonref_to_tensor(mean, dtype=dtype) + variance = tensor_util.convert_nonref_to_tensor(variance, dtype=dtype) + + scale = DeferredTensor( + mean, lambda mean: tf.sqrt(tf.math.log1p(variance / mean ** 2))) + loc = DeferredTensor( + mean, lambda mean: tf.math.log(mean) - scale ** 2 / 2.) + return cls(loc=loc, scale=scale, **kwargs) + def _log_prob(self, x): answer = super(LogNormal, self)._log_prob(x) # The formula inherited from TransformedDistribution computes `nan` for `x diff --git a/tensorflow_probability/python/distributions/lognormal_test.py b/tensorflow_probability/python/distributions/lognormal_test.py index bf620ad8ef..209e651032 100644 --- a/tensorflow_probability/python/distributions/lognormal_test.py +++ b/tensorflow_probability/python/distributions/lognormal_test.py @@ -17,6 +17,7 @@ # Dependency imports import numpy as np +from scipy import stats as sp_stats import tensorflow.compat.v2 as tf from tensorflow_probability.python import distributions as tfd from tensorflow_probability.python.internal import test_util @@ -129,5 +130,39 @@ def testSupportBijectorOutsideRange(self): dist.experimental_default_event_space_bijector().inverse( [-4.2, -1e-6, -1.3]) + def testLogNormalFromMeanVariance(self): + loc = np.array([[[-3.], [2.]]], dtype=np.float32) + scale = np.array([[[0.1]], [[1.]]], dtype=np.float32) + x = np.array([0.1, 7., 4.], dtype=np.float32) + mean = sp_stats.lognorm.mean(s=scale, scale=np.exp(loc)) + var = sp_stats.lognorm.var(s=scale, scale=np.exp(loc)) + lognormal_mean_var = tfd.LogNormal.experimental_from_mean_variance( + mean, variance=var, validate_args=True) + expected_log_pdf = sp_stats.lognorm.logpdf(x, s=scale, scale=np.exp(loc)) + log_pdf = lognormal_mean_var.log_prob(x) + self.assertAllClose(expected_log_pdf, self.evaluate(log_pdf), rtol=2e-5) + self.assertAllClose(mean, self.evaluate(lognormal_mean_var.mean())) + self.assertAllClose(var, self.evaluate(lognormal_mean_var.variance())) + + @test_util.jax_disable_test_missing_functionality('GradientTape') + @test_util.numpy_disable_gradient_test + def testLogNormalFromMeanVarianceTapeSafe(self): + loc = np.float32(0.5) + scale = 1. + x = np.array([0.4, 5., 3.], dtype=np.float32) + + mean = tf.convert_to_tensor( + sp_stats.lognorm.mean(s=scale, scale=np.exp(loc)).astype(np.float32)) + variance = tf.convert_to_tensor( + sp_stats.lognorm.var(s=scale, scale=np.exp(loc)).astype(np.float32)) + + dist = tfd.LogNormal.experimental_from_mean_variance( + mean, variance, validate_args=True) + with tf.GradientTape() as tape: + tape.watch((mean, variance)) + lp = dist.log_prob(x) + grads = tape.gradient(lp, (mean, variance)) + self.assertAllNotNone(grads) + if __name__ == '__main__': test_util.main() From cacfcdc7f7032d04708bdcd9715292f3999723ec Mon Sep 17 00:00:00 2001 From: yileiyang Date: Tue, 22 Mar 2022 13:22:17 -0700 Subject: [PATCH 048/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 436554346 --- .../ground_truth/brownian_motion_missing_middle_observations.py | 1 - ...brownian_motion_unknown_scales_missing_middle_observations.py | 1 - .../targets/ground_truth/convection_lorenz_bridge.py | 1 - .../ground_truth/convection_lorenz_bridge_unknown_scales.py | 1 - .../inference_gym/targets/ground_truth/eight_schools.py | 1 - .../ground_truth/german_credit_numeric_logistic_regression.py | 1 - .../ground_truth/german_credit_numeric_probit_regression.py | 1 - .../german_credit_numeric_sparse_logistic_regression.py | 1 - .../targets/ground_truth/radon_contextual_effects_indiana.py | 1 - .../ground_truth/radon_contextual_effects_indiana_halfnormal.py | 1 - .../targets/ground_truth/radon_contextual_effects_minnesota.py | 1 - .../radon_contextual_effects_minnesota_halfnormal.py | 1 - .../targets/ground_truth/stochastic_volatility_log_sp500.py | 1 - .../ground_truth/stochastic_volatility_log_sp500_small.py | 1 - .../targets/ground_truth/stochastic_volatility_sp500.py | 1 - .../targets/ground_truth/stochastic_volatility_sp500_small.py | 1 - .../targets/ground_truth/synthetic_item_response_theory.py | 1 - .../targets/ground_truth/synthetic_log_gaussian_cox_process.py | 1 - 18 files changed, 18 deletions(-) diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_missing_middle_observations.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_missing_middle_observations.py index 78512e51b3..741c87f186 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_missing_middle_observations.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_missing_middle_observations.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_unknown_scales_missing_middle_observations.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_unknown_scales_missing_middle_observations.py index 0cc5b0a60e..fa79d39b25 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_unknown_scales_missing_middle_observations.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/brownian_motion_unknown_scales_missing_middle_observations.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge.py index a5c60a4d0b..c305773e86 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge_unknown_scales.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge_unknown_scales.py index f1f088a06a..fd9ef6dc05 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge_unknown_scales.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/convection_lorenz_bridge_unknown_scales.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/eight_schools.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/eight_schools.py index bb10454bef..d461646e5f 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/eight_schools.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/eight_schools.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_logistic_regression.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_logistic_regression.py index 03312a61b3..58379156df 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_logistic_regression.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_logistic_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_probit_regression.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_probit_regression.py index 6ec11be5cc..6d7409d240 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_probit_regression.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_probit_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_sparse_logistic_regression.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_sparse_logistic_regression.py index 64919fdc2f..d94598a9a1 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_sparse_logistic_regression.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/german_credit_numeric_sparse_logistic_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana.py index dee7c12d85..e64b68829a 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana_halfnormal.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana_halfnormal.py index a6b835cccc..88e98cf4ef 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana_halfnormal.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_indiana_halfnormal.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota.py index 539f219508..376190d2ad 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota.py @@ -1,4 +1,3 @@ -# Lint as: python2, python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota_halfnormal.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota_halfnormal.py index 6357e893ac..99244b099a 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota_halfnormal.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/radon_contextual_effects_minnesota_halfnormal.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500.py index 5949e7c69e..801b71cf05 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500_small.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500_small.py index 3bdffa2049..6e47ed163c 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500_small.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_log_sp500_small.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500.py index 4d089253c9..9b3acdc50b 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500_small.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500_small.py index 2463f0f07c..84ebb39ddc 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500_small.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/stochastic_volatility_sp500_small.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_item_response_theory.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_item_response_theory.py index 96fb23e122..12c772db60 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_item_response_theory.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_item_response_theory.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_log_gaussian_cox_process.py b/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_log_gaussian_cox_process.py index c28a672277..b1136c5311 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_log_gaussian_cox_process.py +++ b/spinoffs/inference_gym/inference_gym/targets/ground_truth/synthetic_log_gaussian_cox_process.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); From 972ad26dd3c046ada1f029e894a58ebf3ca6e22b Mon Sep 17 00:00:00 2001 From: yileiyang Date: Tue, 22 Mar 2022 13:24:40 -0700 Subject: [PATCH 049/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 436554886 --- spinoffs/inference_gym/inference_gym/targets/banana.py | 1 - spinoffs/inference_gym/inference_gym/targets/banana_test.py | 1 - spinoffs/inference_gym/inference_gym/targets/bayesian_model.py | 1 - .../inference_gym/inference_gym/targets/bayesian_model_test.py | 1 - spinoffs/inference_gym/inference_gym/targets/brownian_motion.py | 1 - .../inference_gym/inference_gym/targets/brownian_motion_test.py | 1 - .../inference_gym/targets/ill_conditioned_gaussian.py | 1 - .../inference_gym/targets/ill_conditioned_gaussian_test.py | 1 - .../inference_gym/inference_gym/targets/item_response_theory.py | 1 - .../inference_gym/targets/item_response_theory_test.py | 1 - .../inference_gym/targets/log_gaussian_cox_process.py | 1 - .../inference_gym/targets/log_gaussian_cox_process_test.py | 1 - .../inference_gym/inference_gym/targets/logistic_regression.py | 1 - .../inference_gym/targets/logistic_regression_test.py | 1 - spinoffs/inference_gym/inference_gym/targets/model.py | 1 - spinoffs/inference_gym/inference_gym/targets/model_test.py | 1 - spinoffs/inference_gym/inference_gym/targets/neals_funnel.py | 1 - .../inference_gym/inference_gym/targets/neals_funnel_test.py | 1 - .../inference_gym/targets/non_identifiable_quartic.py | 1 - .../inference_gym/targets/non_identifiable_quartic_test.py | 1 - .../inference_gym/inference_gym/targets/plasma_spectroscopy.py | 1 - .../inference_gym/targets/plasma_spectroscopy_test.py | 1 - .../inference_gym/inference_gym/targets/probit_regression.py | 1 - .../inference_gym/targets/probit_regression_test.py | 1 - .../inference_gym/targets/radon_contextual_effects.py | 1 - .../inference_gym/targets/radon_contextual_effects_test.py | 1 - .../inference_gym/targets/sparse_logistic_regression.py | 1 - .../inference_gym/targets/sparse_logistic_regression_test.py | 1 - .../inference_gym/inference_gym/targets/stochastic_volatility.py | 1 - .../inference_gym/targets/stochastic_volatility_test.py | 1 - spinoffs/inference_gym/inference_gym/targets/vector_model.py | 1 - .../inference_gym/inference_gym/targets/vector_model_test.py | 1 - .../inference_gym/targets/vectorized_stochastic_volatility.py | 1 - .../targets/vectorized_stochastic_volatility_test.py | 1 - 34 files changed, 34 deletions(-) diff --git a/spinoffs/inference_gym/inference_gym/targets/banana.py b/spinoffs/inference_gym/inference_gym/targets/banana.py index 806f2408c9..9d4130de71 100644 --- a/spinoffs/inference_gym/inference_gym/targets/banana.py +++ b/spinoffs/inference_gym/inference_gym/targets/banana.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/banana_test.py b/spinoffs/inference_gym/inference_gym/targets/banana_test.py index 4d09259705..04040abaf1 100644 --- a/spinoffs/inference_gym/inference_gym/targets/banana_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/banana_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/bayesian_model.py b/spinoffs/inference_gym/inference_gym/targets/bayesian_model.py index beff0b8f86..fd60c9fd7d 100644 --- a/spinoffs/inference_gym/inference_gym/targets/bayesian_model.py +++ b/spinoffs/inference_gym/inference_gym/targets/bayesian_model.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/bayesian_model_test.py b/spinoffs/inference_gym/inference_gym/targets/bayesian_model_test.py index e34c8f0519..7d70c06c9c 100644 --- a/spinoffs/inference_gym/inference_gym/targets/bayesian_model_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/bayesian_model_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/brownian_motion.py b/spinoffs/inference_gym/inference_gym/targets/brownian_motion.py index 45991b8b09..47c9d76dcd 100644 --- a/spinoffs/inference_gym/inference_gym/targets/brownian_motion.py +++ b/spinoffs/inference_gym/inference_gym/targets/brownian_motion.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/brownian_motion_test.py b/spinoffs/inference_gym/inference_gym/targets/brownian_motion_test.py index ef3858c179..bd83320a7d 100644 --- a/spinoffs/inference_gym/inference_gym/targets/brownian_motion_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/brownian_motion_test.py @@ -1,4 +1,3 @@ -# Lint as: python2, python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian.py b/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian.py index 5f12b4be06..d4e78f726a 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian.py +++ b/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian_test.py b/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian_test.py index 920a6abf3e..f6792b97c7 100644 --- a/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/ill_conditioned_gaussian_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/item_response_theory.py b/spinoffs/inference_gym/inference_gym/targets/item_response_theory.py index b147c62a15..11934ada30 100644 --- a/spinoffs/inference_gym/inference_gym/targets/item_response_theory.py +++ b/spinoffs/inference_gym/inference_gym/targets/item_response_theory.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/item_response_theory_test.py b/spinoffs/inference_gym/inference_gym/targets/item_response_theory_test.py index a65f10f400..a7239f86bb 100644 --- a/spinoffs/inference_gym/inference_gym/targets/item_response_theory_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/item_response_theory_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process.py b/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process.py index cf8e40357a..1414175ee8 100644 --- a/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process.py +++ b/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process_test.py b/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process_test.py index e5cf1f535c..00bbfaac54 100644 --- a/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/log_gaussian_cox_process_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/logistic_regression.py b/spinoffs/inference_gym/inference_gym/targets/logistic_regression.py index a070076111..701d63f05e 100644 --- a/spinoffs/inference_gym/inference_gym/targets/logistic_regression.py +++ b/spinoffs/inference_gym/inference_gym/targets/logistic_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py b/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py index 89604e7ebf..c5124a219e 100644 --- a/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/logistic_regression_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/model.py b/spinoffs/inference_gym/inference_gym/targets/model.py index a91177782b..1ccd9beefd 100644 --- a/spinoffs/inference_gym/inference_gym/targets/model.py +++ b/spinoffs/inference_gym/inference_gym/targets/model.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/model_test.py b/spinoffs/inference_gym/inference_gym/targets/model_test.py index 56dff93ea9..ad6ab79a70 100644 --- a/spinoffs/inference_gym/inference_gym/targets/model_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/model_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/neals_funnel.py b/spinoffs/inference_gym/inference_gym/targets/neals_funnel.py index 7f47845952..d56a65de48 100644 --- a/spinoffs/inference_gym/inference_gym/targets/neals_funnel.py +++ b/spinoffs/inference_gym/inference_gym/targets/neals_funnel.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/neals_funnel_test.py b/spinoffs/inference_gym/inference_gym/targets/neals_funnel_test.py index a2676e0de7..17f262cfb3 100644 --- a/spinoffs/inference_gym/inference_gym/targets/neals_funnel_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/neals_funnel_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic.py b/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic.py index 7993d04814..ce12f9c488 100644 --- a/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic.py +++ b/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic_test.py b/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic_test.py index 09ad4afecf..7a098bba6f 100644 --- a/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/non_identifiable_quartic_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy.py b/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy.py index 75f8e83138..eb0163e701 100644 --- a/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy.py +++ b/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2021 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy_test.py b/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy_test.py index 22c0a784cb..841ede812b 100644 --- a/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/plasma_spectroscopy_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2021 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/probit_regression.py b/spinoffs/inference_gym/inference_gym/targets/probit_regression.py index c76104a766..84a779dc77 100644 --- a/spinoffs/inference_gym/inference_gym/targets/probit_regression.py +++ b/spinoffs/inference_gym/inference_gym/targets/probit_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/probit_regression_test.py b/spinoffs/inference_gym/inference_gym/targets/probit_regression_test.py index b497daaf32..d0984b8ee3 100644 --- a/spinoffs/inference_gym/inference_gym/targets/probit_regression_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/probit_regression_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects.py b/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects.py index 20c4f4df4b..0d1ea96969 100644 --- a/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects.py +++ b/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects.py @@ -1,4 +1,3 @@ -# Lint as: python2, python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects_test.py b/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects_test.py index a0c4462fb7..30cf94f92d 100644 --- a/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/radon_contextual_effects_test.py @@ -1,4 +1,3 @@ -# Lint as: python2, python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression.py b/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression.py index 3e11becc79..b90815e96c 100644 --- a/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression.py +++ b/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression_test.py b/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression_test.py index 7516b571cb..33ae70a23e 100644 --- a/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/sparse_logistic_regression_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility.py b/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility.py index f596f2e5da..2ac4d15f03 100644 --- a/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility.py +++ b/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility_test.py b/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility_test.py index 50f0935933..81a0f4e198 100644 --- a/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/stochastic_volatility_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/vector_model.py b/spinoffs/inference_gym/inference_gym/targets/vector_model.py index 1bc9f48931..95d82fbe35 100644 --- a/spinoffs/inference_gym/inference_gym/targets/vector_model.py +++ b/spinoffs/inference_gym/inference_gym/targets/vector_model.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/vector_model_test.py b/spinoffs/inference_gym/inference_gym/targets/vector_model_test.py index 782e41f267..ee3a9b5beb 100644 --- a/spinoffs/inference_gym/inference_gym/targets/vector_model_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/vector_model_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility.py b/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility.py index 70605589f2..d68916fc48 100644 --- a/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility.py +++ b/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility_test.py b/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility_test.py index cbe99c153e..a53f802733 100644 --- a/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/vectorized_stochastic_volatility_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); From 6a5b459835a6a604e36336afe2e813fa8ee3f2bd Mon Sep 17 00:00:00 2001 From: yileiyang Date: Tue, 22 Mar 2022 14:48:15 -0700 Subject: [PATCH 050/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 436577066 --- spinoffs/inference_gym/inference_gym/dynamic/__init__.py | 1 - .../inference_gym/inference_gym/dynamic/backend_jax/__init__.py | 1 - .../inference_gym/dynamic/backend_numpy/__init__.py | 1 - .../inference_gym/dynamic/backend_tensorflow/__init__.py | 1 - spinoffs/inference_gym/inference_gym/tools/get_ground_truth.py | 1 - tensorflow_probability/python/bijectors/lambertw_transform.py | 1 - .../python/bijectors/lambertw_transform_test.py | 1 - .../python/experimental/nn/util/convolution_util.py | 1 - 8 files changed, 8 deletions(-) diff --git a/spinoffs/inference_gym/inference_gym/dynamic/__init__.py b/spinoffs/inference_gym/inference_gym/dynamic/__init__.py index c35eb15f9b..e9e1f29b8b 100644 --- a/spinoffs/inference_gym/inference_gym/dynamic/__init__.py +++ b/spinoffs/inference_gym/inference_gym/dynamic/__init__.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/dynamic/backend_jax/__init__.py b/spinoffs/inference_gym/inference_gym/dynamic/backend_jax/__init__.py index c35eb15f9b..e9e1f29b8b 100644 --- a/spinoffs/inference_gym/inference_gym/dynamic/backend_jax/__init__.py +++ b/spinoffs/inference_gym/inference_gym/dynamic/backend_jax/__init__.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/dynamic/backend_numpy/__init__.py b/spinoffs/inference_gym/inference_gym/dynamic/backend_numpy/__init__.py index c35eb15f9b..e9e1f29b8b 100644 --- a/spinoffs/inference_gym/inference_gym/dynamic/backend_numpy/__init__.py +++ b/spinoffs/inference_gym/inference_gym/dynamic/backend_numpy/__init__.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/dynamic/backend_tensorflow/__init__.py b/spinoffs/inference_gym/inference_gym/dynamic/backend_tensorflow/__init__.py index c35eb15f9b..e9e1f29b8b 100644 --- a/spinoffs/inference_gym/inference_gym/dynamic/backend_tensorflow/__init__.py +++ b/spinoffs/inference_gym/inference_gym/dynamic/backend_tensorflow/__init__.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/tools/get_ground_truth.py b/spinoffs/inference_gym/inference_gym/tools/get_ground_truth.py index d70456699b..9939794fc2 100644 --- a/spinoffs/inference_gym/inference_gym/tools/get_ground_truth.py +++ b/spinoffs/inference_gym/inference_gym/tools/get_ground_truth.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tensorflow_probability/python/bijectors/lambertw_transform.py b/tensorflow_probability/python/bijectors/lambertw_transform.py index aef06dc50b..38201901fe 100644 --- a/tensorflow_probability/python/bijectors/lambertw_transform.py +++ b/tensorflow_probability/python/bijectors/lambertw_transform.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tensorflow_probability/python/bijectors/lambertw_transform_test.py b/tensorflow_probability/python/bijectors/lambertw_transform_test.py index f37e1bfea4..2dc906585a 100644 --- a/tensorflow_probability/python/bijectors/lambertw_transform_test.py +++ b/tensorflow_probability/python/bijectors/lambertw_transform_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tensorflow_probability/python/experimental/nn/util/convolution_util.py b/tensorflow_probability/python/experimental/nn/util/convolution_util.py index e0f3fa1415..d6211314cd 100644 --- a/tensorflow_probability/python/experimental/nn/util/convolution_util.py +++ b/tensorflow_probability/python/experimental/nn/util/convolution_util.py @@ -1,4 +1,3 @@ -# Lint as: python2, python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); From ffdbc1872d1939ccb3d64aa8598d25bbb9df32b3 Mon Sep 17 00:00:00 2001 From: Googler Date: Wed, 23 Mar 2022 13:05:03 -0700 Subject: [PATCH 051/153] Clarify the order in which `Chain` applies bijectors. PiperOrigin-RevId: 436811088 --- tensorflow_probability/python/bijectors/chain.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/bijectors/chain.py b/tensorflow_probability/python/bijectors/chain.py index 0cb1c9354c..8f9e32a810 100644 --- a/tensorflow_probability/python/bijectors/chain.py +++ b/tensorflow_probability/python/bijectors/chain.py @@ -27,7 +27,7 @@ class _Chain(composition.Composition): - """Bijector which applies a sequence of bijectors. + """Bijector which applies a composition of bijectors. Example Use: @@ -83,7 +83,8 @@ def __init__(self, Args: bijectors: Python `list` of bijector instances. An empty list makes this - bijector equivalent to the `Identity` bijector. + bijector equivalent to the `Identity` bijector. The bijectors are + applied in sequence starting from the end of the list. validate_args: Python `bool` indicating whether arguments should be checked for correctness. validate_event_size: Checks that bijectors are not applied to inputs with From 748a12c8206c1c259e9904b5c772ba88ec0e5852 Mon Sep 17 00:00:00 2001 From: yileiyang Date: Wed, 23 Mar 2022 14:34:13 -0700 Subject: [PATCH 052/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 436831262 --- .../inference_gym/inference_gym/backends/jax_integration_test.py | 1 - .../inference_gym/backends/numpy_integration_test.py | 1 - spinoffs/inference_gym/inference_gym/backends/rewrite.py | 1 - .../inference_gym/backends/tensorflow_integration_test.py | 1 - spinoffs/inference_gym/inference_gym/backends/util.py | 1 - tensorflow_probability/python/distributions/lambertw_f.py | 1 - .../python/distributions/untestable_distributions.py | 1 - 7 files changed, 7 deletions(-) diff --git a/spinoffs/inference_gym/inference_gym/backends/jax_integration_test.py b/spinoffs/inference_gym/inference_gym/backends/jax_integration_test.py index e18798a345..58315202bf 100644 --- a/spinoffs/inference_gym/inference_gym/backends/jax_integration_test.py +++ b/spinoffs/inference_gym/inference_gym/backends/jax_integration_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/backends/numpy_integration_test.py b/spinoffs/inference_gym/inference_gym/backends/numpy_integration_test.py index 064b7201f3..3557bd75aa 100644 --- a/spinoffs/inference_gym/inference_gym/backends/numpy_integration_test.py +++ b/spinoffs/inference_gym/inference_gym/backends/numpy_integration_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/backends/rewrite.py b/spinoffs/inference_gym/inference_gym/backends/rewrite.py index 9421a3935d..96853f852c 100644 --- a/spinoffs/inference_gym/inference_gym/backends/rewrite.py +++ b/spinoffs/inference_gym/inference_gym/backends/rewrite.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/backends/tensorflow_integration_test.py b/spinoffs/inference_gym/inference_gym/backends/tensorflow_integration_test.py index 1713a0f0c6..6fa43e32e2 100644 --- a/spinoffs/inference_gym/inference_gym/backends/tensorflow_integration_test.py +++ b/spinoffs/inference_gym/inference_gym/backends/tensorflow_integration_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/backends/util.py b/spinoffs/inference_gym/inference_gym/backends/util.py index d74af897c3..dc250ffc92 100644 --- a/spinoffs/inference_gym/inference_gym/backends/util.py +++ b/spinoffs/inference_gym/inference_gym/backends/util.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tensorflow_probability/python/distributions/lambertw_f.py b/tensorflow_probability/python/distributions/lambertw_f.py index ed6c7d59df..aa2728cb9f 100644 --- a/tensorflow_probability/python/distributions/lambertw_f.py +++ b/tensorflow_probability/python/distributions/lambertw_f.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tensorflow_probability/python/distributions/untestable_distributions.py b/tensorflow_probability/python/distributions/untestable_distributions.py index 915f99f25d..4592de9895 100644 --- a/tensorflow_probability/python/distributions/untestable_distributions.py +++ b/tensorflow_probability/python/distributions/untestable_distributions.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); From 91c3f749245420a523a74add883d0aeaf30a2fa9 Mon Sep 17 00:00:00 2001 From: yileiyang Date: Wed, 23 Mar 2022 16:22:04 -0700 Subject: [PATCH 053/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 436855867 --- spinoffs/inference_gym/inference_gym/internal/array_to_source.py | 1 - .../inference_gym/inference_gym/internal/array_to_source_test.py | 1 - spinoffs/inference_gym/inference_gym/internal/data.py | 1 - spinoffs/inference_gym/inference_gym/internal/data_test.py | 1 - .../inference_gym/inference_gym/internal/datasets/__init__.py | 1 - .../datasets/brownian_motion_missing_middle_observations.py | 1 - .../inference_gym/internal/datasets/convection_lorenz_bridge.py | 1 - .../inference_gym/internal/datasets/sp500_closing_prices.py | 1 - .../internal/datasets/synthetic_item_response_theory.py | 1 - .../internal/datasets/synthetic_log_gaussian_cox_process.py | 1 - .../internal/datasets/synthetic_plasma_spectroscopy.py | 1 - .../internal/datasets/synthetic_plasma_spectroscopy_with_bump.py | 1 - .../inference_gym/internal/ground_truth_encoding.py | 1 - .../inference_gym/internal/ground_truth_encoding_test.py | 1 - spinoffs/inference_gym/inference_gym/internal/test_util.py | 1 - spinoffs/inference_gym/inference_gym/internal/test_util_test.py | 1 - 16 files changed, 16 deletions(-) diff --git a/spinoffs/inference_gym/inference_gym/internal/array_to_source.py b/spinoffs/inference_gym/inference_gym/internal/array_to_source.py index b3cc430d8e..5d94ef85f5 100644 --- a/spinoffs/inference_gym/inference_gym/internal/array_to_source.py +++ b/spinoffs/inference_gym/inference_gym/internal/array_to_source.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/array_to_source_test.py b/spinoffs/inference_gym/inference_gym/internal/array_to_source_test.py index e2186713a8..a257230e06 100644 --- a/spinoffs/inference_gym/inference_gym/internal/array_to_source_test.py +++ b/spinoffs/inference_gym/inference_gym/internal/array_to_source_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/data.py b/spinoffs/inference_gym/inference_gym/internal/data.py index 9e70f7a02e..9b885279bf 100644 --- a/spinoffs/inference_gym/inference_gym/internal/data.py +++ b/spinoffs/inference_gym/inference_gym/internal/data.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/data_test.py b/spinoffs/inference_gym/inference_gym/internal/data_test.py index 054b366249..bacfda5ea5 100644 --- a/spinoffs/inference_gym/inference_gym/internal/data_test.py +++ b/spinoffs/inference_gym/inference_gym/internal/data_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/__init__.py b/spinoffs/inference_gym/inference_gym/internal/datasets/__init__.py index d0d549c67e..e0d739c139 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/__init__.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/__init__.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/brownian_motion_missing_middle_observations.py b/spinoffs/inference_gym/inference_gym/internal/datasets/brownian_motion_missing_middle_observations.py index 6eb704e0cf..817052561a 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/brownian_motion_missing_middle_observations.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/brownian_motion_missing_middle_observations.py @@ -1,4 +1,3 @@ -# Lint as: python2, python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/convection_lorenz_bridge.py b/spinoffs/inference_gym/inference_gym/internal/datasets/convection_lorenz_bridge.py index 696b158a24..a3dcb19fc2 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/convection_lorenz_bridge.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/convection_lorenz_bridge.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/sp500_closing_prices.py b/spinoffs/inference_gym/inference_gym/internal/datasets/sp500_closing_prices.py index b9ebbb06e8..c78dce76ef 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/sp500_closing_prices.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/sp500_closing_prices.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_item_response_theory.py b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_item_response_theory.py index 0641ca625a..703cfad72c 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_item_response_theory.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_item_response_theory.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_log_gaussian_cox_process.py b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_log_gaussian_cox_process.py index 6447758e43..ddf67f5a4d 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_log_gaussian_cox_process.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_log_gaussian_cox_process.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy.py b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy.py index 9a2e392d38..84e3c7c02f 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2021 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy_with_bump.py b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy_with_bump.py index 7adfd93569..68f78b11b2 100644 --- a/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy_with_bump.py +++ b/spinoffs/inference_gym/inference_gym/internal/datasets/synthetic_plasma_spectroscopy_with_bump.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2021 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding.py b/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding.py index 79bc4d105c..83c0687094 100644 --- a/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding.py +++ b/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding_test.py b/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding_test.py index 802e96a314..a791e5720e 100644 --- a/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding_test.py +++ b/spinoffs/inference_gym/inference_gym/internal/ground_truth_encoding_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/test_util.py b/spinoffs/inference_gym/inference_gym/internal/test_util.py index 0cc263b1b9..2033708563 100644 --- a/spinoffs/inference_gym/inference_gym/internal/test_util.py +++ b/spinoffs/inference_gym/inference_gym/internal/test_util.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/spinoffs/inference_gym/inference_gym/internal/test_util_test.py b/spinoffs/inference_gym/inference_gym/internal/test_util_test.py index 94742d1751..84b91e997e 100644 --- a/spinoffs/inference_gym/inference_gym/internal/test_util_test.py +++ b/spinoffs/inference_gym/inference_gym/internal/test_util_test.py @@ -1,4 +1,3 @@ -# Lint as: python3 # Copyright 2020 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); From 4fad44a579458df4d245d522d89d595370d17d47 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Thu, 24 Mar 2022 13:47:51 -0700 Subject: [PATCH 054/153] Use stateless PRNG seed in HMC fit for sts models. PiperOrigin-RevId: 437077674 --- tensorflow_probability/python/sts/BUILD | 1 - tensorflow_probability/python/sts/fitting.py | 12 +++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/tensorflow_probability/python/sts/BUILD b/tensorflow_probability/python/sts/BUILD index 31f76da581..b83546e22a 100644 --- a/tensorflow_probability/python/sts/BUILD +++ b/tensorflow_probability/python/sts/BUILD @@ -118,7 +118,6 @@ multi_substrate_py_library( "//tensorflow_probability/python/distributions:transformed_distribution", "//tensorflow_probability/python/internal:tensorshape_util", "//tensorflow_probability/python/sts/internal", - "//tensorflow_probability/python/util", ], ) diff --git a/tensorflow_probability/python/sts/fitting.py b/tensorflow_probability/python/sts/fitting.py index ebaef8387d..d7b5af7a2e 100644 --- a/tensorflow_probability/python/sts/fitting.py +++ b/tensorflow_probability/python/sts/fitting.py @@ -19,7 +19,6 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python import mcmc -from tensorflow_probability.python import util as tfp_util from tensorflow_probability.python import vi from tensorflow_probability.python.experimental import vi as experimental_vi from tensorflow_probability.python.internal import distribution_util @@ -447,7 +446,10 @@ def fit_with_hmc(model, """ with tf.name_scope(name or 'fit_with_hmc') as name: - seed = tfp_util.SeedStream(seed, salt='StructuralTimeSeries_fit_with_hmc') + init_seed, vi_seed, hmc_seed = samplers.split_seed( + seed=seed, + n=3, + salt='StructuralTimeSeries_fit_with_hmc') observed_time_series = sts_util.pad_batch_dimension_for_multiple_chains( observed_time_series, model, chain_batch_shape=chain_batch_shape) @@ -457,7 +459,7 @@ def fit_with_hmc(model, # specified. if initial_step_size is None or initial_state is None: variational_posterior = build_factored_surrogate_posterior( - model, batch_shape=chain_batch_shape, seed=seed()) + model, batch_shape=chain_batch_shape, seed=init_seed) if variational_optimizer is None: variational_optimizer = tf1.train.AdamOptimizer( @@ -468,7 +470,7 @@ def fit_with_hmc(model, sample_size=variational_sample_size, num_steps=num_variational_steps, optimizer=variational_optimizer, - seed=seed()) + seed=vi_seed) with tf.control_dependencies([loss_curve]): if initial_state is None: @@ -499,7 +501,7 @@ def run_hmc(): state_gradients_are_stopped=True), bijector=[param.bijector for param in model.parameters]), num_adaptation_steps=int(num_warmup_steps * 0.8)), - seed=seed()) + seed=hmc_seed) samples, kernel_results = run_hmc() return samples, kernel_results From 5ade5823b72cd0c4bcb82d3f490e1eb43e5a3921 Mon Sep 17 00:00:00 2001 From: fhertschuh Date: Fri, 25 Mar 2022 12:46:17 -0700 Subject: [PATCH 055/153] Remove latent_dirichlet_allocation_distributions and vae examples, which were based on Tensorflow Estimator. PiperOrigin-RevId: 437312832 --- tensorflow_probability/examples/BUILD | 78 --- ...tent_dirichlet_allocation_distributions.py | 545 ------------------ tensorflow_probability/examples/vae.py | 526 ----------------- 3 files changed, 1149 deletions(-) delete mode 100644 tensorflow_probability/examples/latent_dirichlet_allocation_distributions.py delete mode 100644 tensorflow_probability/examples/vae.py diff --git a/tensorflow_probability/examples/BUILD b/tensorflow_probability/examples/BUILD index 92225273e3..95397b4068 100644 --- a/tensorflow_probability/examples/BUILD +++ b/tensorflow_probability/examples/BUILD @@ -120,46 +120,6 @@ py_test( ], ) -py_binary( - name = "latent_dirichlet_allocation_distributions", - srcs = ["latent_dirichlet_allocation_distributions.py"], - deps = [ - ":latent_dirichlet_allocation_distributions_lib", - ], -) - -py_library( - name = "latent_dirichlet_allocation_distributions_lib", - srcs = ["latent_dirichlet_allocation_distributions.py"], - deps = [ - # absl/flags dep, - # absl/logging dep, - # numpy dep, - # scipy dep, - # six dep, - # tensorflow dep, - "//tensorflow_probability", - "//tensorflow_probability/python/distributions", - ], -) - -py_test( - name = "latent_dirichlet_allocation_distributions_test", - size = "small", - srcs = ["latent_dirichlet_allocation_distributions.py"], - args = [ - "--fake_data", - "--max_steps=5", - "--delete_existing", - "--viz_steps=5", - "--learning_rate=1e-7", - ], - main = "latent_dirichlet_allocation_distributions.py", - deps = [ - ":latent_dirichlet_allocation_distributions_lib", - ], -) - py_binary( name = "logistic_regression", srcs = ["logistic_regression.py"], @@ -207,44 +167,6 @@ py_library( ], ) -py_binary( - name = "vae", - srcs = ["vae.py"], - deps = [ - ":vae_lib", - ], -) - -py_library( - name = "vae_lib", - srcs = ["vae.py"], - deps = [ - # absl/flags dep, - # numpy dep, - # six dep, - # tensorflow dep, - "//tensorflow_probability", - "//tensorflow_probability/python/distributions", - ], -) - -py_test( - name = "vae_test", - size = "medium", - srcs = ["vae.py"], - args = [ - "--fake_data", - "--max_steps=5", - "--delete_existing", - "--viz_steps=5", - "--learning_rate=1e-7", - ], - main = "vae.py", - deps = [ - ":vae_lib", - ], -) - py_binary( name = "vq_vae", srcs = ["vq_vae.py"], diff --git a/tensorflow_probability/examples/latent_dirichlet_allocation_distributions.py b/tensorflow_probability/examples/latent_dirichlet_allocation_distributions.py deleted file mode 100644 index a081f68773..0000000000 --- a/tensorflow_probability/examples/latent_dirichlet_allocation_distributions.py +++ /dev/null @@ -1,545 +0,0 @@ -# Copyright 2018 The TensorFlow Probability Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# ============================================================================ -"""Trains a Latent Dirichlet Allocation (LDA) model on 20 Newsgroups. - -LDA [1] is a topic model for documents represented as bag-of-words -(word counts). It attempts to find a set of topics so that every document from -the corpus is well-described by a few topics. - -Suppose that there are `V` words in the vocabulary and we want to learn `K` -topics. For each document, let `w` be its `V`-dimensional vector of word counts -and `theta` be its `K`-dimensional vector of topics. Let `Beta` be a `KxN` -matrix in which each row is a discrete distribution over words in the -corresponding topic (in other words, belong to a unit simplex). Also, let -`alpha` be the `K`-dimensional vector of prior distribution parameters -(prior topic weights). - -The model we consider here is obtained from the standard LDA by collapsing -the (non-reparameterizable) Categorical distribution over the topics -[1, Sec. 3.2; 3]. Then, the prior distribution is -`p(theta) = Dirichlet(theta | alpha)`, and the likelihood is -`p(w | theta, Beta) = OneHotCategorical(w | theta Beta)`. This means that we -sample the words from a Categorical distribution that is a weighted average -of topics, with the weights specified by `theta`. The number of samples (words) -in the document is assumed to be known, and the words are sampled independently. -We follow [2] and perform amortized variational inference similarly to -Variational Autoencoders. We use a neural network encoder to -parameterize a Dirichlet variational posterior distribution `q(theta | w)`. -Then, an evidence lower bound (ELBO) is maximized with respect to -`alpha`, `Beta` and the parameters of the variational posterior distribution. - -We use the preprocessed version of 20 newsgroups dataset from [3]. -This implementation uses the hyperparameters of [2] and reproduces the reported -results (test perplexity ~875). - -Example output for the final iteration: - -```none -elbo --567.829 - -loss -567.883 - -global_step -180000 - -reconstruction --562.065 - -topics -index=8 alpha=0.46 write article get think one like know say go make -index=21 alpha=0.29 use get thanks one write know anyone car please like -index=0 alpha=0.09 file use key program window image available information -index=43 alpha=0.08 drive use card disk system problem windows driver mac run -index=6 alpha=0.07 god one say christian jesus believe people bible think man -index=5 alpha=0.07 space year new program use research launch university nasa -index=33 alpha=0.07 government gun law people state use right weapon crime -index=36 alpha=0.05 game team play player year win season hockey league score -index=42 alpha=0.05 go say get know come one think people see tell -index=49 alpha=0.04 bike article write post get ride dod car one go - -kl -5.76408 - -perplexity -873.206 -``` - -#### References - -[1]: David M. Blei, Andrew Y. Ng, Michael I. Jordan. Latent Dirichlet - Allocation. In _Journal of Machine Learning Research_, 2003. - http://www.jmlr.org/papers/volume3/blei03a/blei03a.pdf -[2]: Michael Figurnov, Shakir Mohamed, Andriy Mnih. Implicit Reparameterization - Gradients, 2018 - https://arxiv.org/abs/1805.08498 -[3]: Akash Srivastava, Charles Sutton. Autoencoding Variational Inference For - Topic Models. In _International Conference on Learning Representations_, - 2017. - https://arxiv.org/abs/1703.01488 -""" - -import functools -import os - -# Dependency imports -from absl import flags -from absl import logging -import numpy as np -import scipy.sparse -from six.moves import cPickle as pickle -from six.moves import urllib -import tensorflow.compat.v1 as tf1 -import tensorflow.compat.v2 as tf -import tensorflow_probability as tfp - -tfb = tfp.bijectors -tfd = tfp.distributions - - -flags.DEFINE_float( - "learning_rate", default=3e-4, help="Learning rate.") -flags.DEFINE_integer( - "max_steps", default=180000, help="Number of training steps to run.") -flags.DEFINE_integer( - "num_topics", - default=50, - help="The number of topics.") -flags.DEFINE_list( - "layer_sizes", - default=["300", "300", "300"], - help="Comma-separated list denoting hidden units per layer in the encoder.") -flags.DEFINE_string( - "activation", - default="relu", - help="Activation function for all hidden layers.") -flags.DEFINE_integer( - "batch_size", - default=32, - help="Batch size.") -flags.DEFINE_float( - "prior_initial_value", default=0.7, help="The initial value for prior.") -flags.DEFINE_integer( - "prior_burn_in_steps", - default=120000, - help="The number of training steps with fixed prior.") -flags.DEFINE_string( - "data_dir", - default=os.path.join(os.getenv("TEST_TMPDIR", "/tmp"), "lda/data"), - help="Directory where data is stored (if using real data).") -flags.DEFINE_string( - "model_dir", - default=os.path.join(os.getenv("TEST_TMPDIR", "/tmp"), "lda/"), - help="Directory to put the model's fit.") -flags.DEFINE_integer( - "viz_steps", default=10000, help="Frequency at which save visualizations.") -flags.DEFINE_bool("fake_data", default=False, help="If true, uses fake data.") -flags.DEFINE_bool( - "delete_existing", - default=False, - help="If true, deletes existing directory.") - -FLAGS = flags.FLAGS - - -def _clip_dirichlet_parameters(x): - """Clips Dirichlet param for numerically stable KL and nonzero samples.""" - return tf.clip_by_value(x, .1, 1e3) - - -def make_encoder(activation, num_topics, layer_sizes): - """Create the encoder function. - - Args: - activation: Activation function to use. - num_topics: The number of topics. - layer_sizes: The number of hidden units per layer in the encoder. - - Returns: - encoder: A `callable` mapping a bag-of-words `Tensor` to a - `tfd.Distribution` instance over topics. - """ - encoder_net = tf.keras.Sequential() - for num_hidden_units in layer_sizes: - encoder_net.add( - tf.keras.layers.Dense( - num_hidden_units, - activation=activation, - kernel_initializer=tf.initializers.GlorotNormal())) - encoder_net.add( - tf.keras.layers.Dense( - num_topics, - activation=lambda x: _clip_dirichlet_parameters(tf.nn.softplus(x)), - kernel_initializer=tf.initializers.GlorotNormal())) - - def encoder(bag_of_words): - with tf.name_scope("encoder"): - return tfd.Dirichlet(concentration=encoder_net(bag_of_words), - name="topics_posterior") - - return encoder - - -def make_decoder(num_topics, num_words): - """Create the decoder function. - - Args: - num_topics: The number of topics. - num_words: The number of words. - - Returns: - decoder: A `callable` mapping a `Tensor` of encodings to a - `tfd.Distribution` instance over words. - """ - topics_words = tfp.util.TransformedVariable( - tf.nn.softmax(tf.initializers.GlorotNormal()([num_topics, num_words])), - tfb.SoftmaxCentered(), - name="topics_words") - - def decoder(topics): - word_probs = tf.matmul(topics, topics_words) - # The observations are bag of words and therefore not one-hot. However, - # log_prob of OneHotCategorical computes the probability correctly in - # this case. - return tfd.OneHotCategorical(probs=word_probs, name="bag_of_words") - - return decoder, topics_words - - -def make_prior(num_topics, initial_value): - """Create the prior distribution. - - Args: - num_topics: Number of topics. - initial_value: The starting value for the prior parameters. - - Returns: - prior: A `callable` that returns a `tf.distribution.Distribution` - instance, the prior distribution. - """ - concentration = tfp.util.TransformedVariable( - tf.fill([1, num_topics], initial_value), - tfb.Softplus(), - name="concentration") - - return tfd.Dirichlet( - concentration=tfp.util.DeferredTensor( - concentration, _clip_dirichlet_parameters), - name="topics_prior") - - -def model_fn(features, labels, mode, params, config): - """Build the model function for use in an estimator. - - Args: - features: The input features for the estimator. - labels: The labels, unused here. - mode: Signifies whether it is train or test or predict. - params: Some hyperparameters as a dictionary. - config: The RunConfig, unused here. - Returns: - EstimatorSpec: A tf.estimator.EstimatorSpec instance. - """ - del labels, config - - encoder = make_encoder(params["activation"], - params["num_topics"], - params["layer_sizes"]) - decoder, topics_words = make_decoder(params["num_topics"], - features.shape[1]) - topics_prior = make_prior(params["num_topics"], - params["prior_initial_value"]) - - alpha = topics_prior.concentration - - topics_posterior = encoder(features) - topics = topics_posterior.sample(seed=234) - random_reconstruction = decoder(topics) - - reconstruction = random_reconstruction.log_prob(features) - tf1.summary.scalar("reconstruction", tf.reduce_mean(reconstruction)) - - # Compute the KL-divergence between two Dirichlets analytically. - # The sampled KL does not work well for "sparse" distributions - # (see Appendix D of [2]). - kl = tfd.kl_divergence(topics_posterior, topics_prior) - tf1.summary.scalar("kl", tf.reduce_mean(kl)) - - # Ensure that the KL is non-negative (up to a very small slack). - # Negative KL can happen due to numerical instability. - with tf.control_dependencies( - [tf.debugging.assert_greater(kl, -1e-3, message="kl")]): - kl = tf.identity(kl) - - elbo = reconstruction - kl - avg_elbo = tf.reduce_mean(elbo) - tf1.summary.scalar("elbo", avg_elbo) - loss = -avg_elbo - - # Perform variational inference by minimizing the -ELBO. - global_step = tf1.train.get_or_create_global_step() - optimizer = tf1.train.AdamOptimizer(params["learning_rate"]) - - # This implements the "burn-in" for prior parameters (see Appendix D of [2]). - # For the first prior_burn_in_steps steps they are fixed, and then trained - # jointly with the other parameters. - grads_and_vars = optimizer.compute_gradients(loss) - grads_and_vars_except_prior = [ - x for x in grads_and_vars if x[1] not in topics_prior.variables] - - def train_op_except_prior(): - return optimizer.apply_gradients( - grads_and_vars_except_prior, - global_step=global_step) - - def train_op_all(): - return optimizer.apply_gradients( - grads_and_vars, - global_step=global_step) - - train_op = tf.cond( - pred=global_step < params["prior_burn_in_steps"], - true_fn=train_op_except_prior, - false_fn=train_op_all) - - # The perplexity is an exponent of the average negative ELBO per word. - words_per_document = tf.reduce_sum(features, axis=1) - log_perplexity = -elbo / words_per_document - tf1.summary.scalar("perplexity", tf.exp(tf.reduce_mean(log_perplexity))) - (log_perplexity_tensor, - log_perplexity_update) = tf1.metrics.mean(log_perplexity) - perplexity_tensor = tf.exp(log_perplexity_tensor) - - # Obtain the topics summary. Implemented as a py_func for simplicity. - topics = tf1.py_func( - functools.partial(get_topics_strings, vocabulary=params["vocabulary"]), - [topics_words, alpha], - tf.string, - stateful=False) - tf1.summary.text("topics", topics) - - return tf1.estimator.EstimatorSpec( - mode=mode, - loss=loss, - train_op=train_op, - eval_metric_ops={ - "elbo": tf1.metrics.mean(elbo), - "reconstruction": tf1.metrics.mean(reconstruction), - "kl": tf1.metrics.mean(kl), - "perplexity": (perplexity_tensor, log_perplexity_update), - "topics": (topics, tf.no_op()), - }, - ) - - -def get_topics_strings(topics_words, alpha, vocabulary, - topics_to_print=10, words_per_topic=10): - """Returns the summary of the learned topics. - - Args: - topics_words: KxV tensor with topics as rows and words as columns. - alpha: 1xK tensor of prior Dirichlet concentrations for the - topics. - vocabulary: A mapping of word's integer index to the corresponding string. - topics_to_print: The number of topics with highest prior weight to - summarize. - words_per_topic: Number of wodrs per topic to return. - Returns: - summary: A np.array with strings. - """ - alpha = np.squeeze(alpha, axis=0) - # Use a stable sorting algorithm so that when alpha is fixed - # we always get the same topics. - highest_weight_topics = np.argsort(-alpha, kind="mergesort") - top_words = np.argsort(-topics_words, axis=1) - - res = [] - for topic_idx in highest_weight_topics[:topics_to_print]: - l = ["index={} alpha={:.2f}".format(topic_idx, alpha[topic_idx])] - l += [vocabulary[word] for word in top_words[topic_idx, :words_per_topic]] - res.append(" ".join(l)) - - return np.array(res) - - -ROOT_PATH = "https://github.com/akashgit/autoencoding_vi_for_topic_models/raw/9db556361409ecb3a732f99b4ef207aeb8516f83/data/20news_clean" -FILE_TEMPLATE = "{split}.txt.npy" - - -def download(directory, filename): - """Download a file.""" - filepath = os.path.join(directory, filename) - if tf.io.gfile.exists(filepath): - return filepath - if not tf.io.gfile.exists(directory): - tf.io.gfile.makedirs(directory) - url = os.path.join(ROOT_PATH, filename) - print("Downloading %s to %s" % (url, filepath)) - urllib.request.urlretrieve(url, filepath) - return filepath - - -def newsgroups_dataset(directory, split_name, num_words, shuffle_and_repeat): - """Return 20 newsgroups tf.data.Dataset.""" - data = np.load(download(directory, FILE_TEMPLATE.format(split=split_name)), - allow_pickle=True, encoding="latin1") - # The last row is empty in both train and test. - data = data[:-1] - - # Each row is a list of word ids in the document. We first convert this to - # sparse COO matrix (which automatically sums the repeating words). Then, - # we convert this COO matrix to CSR format which allows for fast querying of - # documents. - num_documents = data.shape[0] - indices = np.array([(row_idx, column_idx) - for row_idx, row in enumerate(data) - for column_idx in row]) - sparse_matrix = scipy.sparse.coo_matrix( - (np.ones(indices.shape[0]), (indices[:, 0], indices[:, 1])), - shape=(num_documents, num_words), - dtype=np.float32) - sparse_matrix = sparse_matrix.tocsr() - - dataset = tf.data.Dataset.range(num_documents) - - # For training, we shuffle each epoch and repeat the epochs. - if shuffle_and_repeat: - dataset = dataset.shuffle(num_documents).repeat() - - # Returns a single document as a dense TensorFlow tensor. The dataset is - # stored as a sparse matrix outside of the graph. - def get_row_py_func(idx): - def get_row_python(idx_py): - return np.squeeze(np.array(sparse_matrix[idx_py].todense()), axis=0) - - py_func = tf1.py_func( - get_row_python, [idx], tf.float32, stateful=False) - py_func.set_shape((num_words,)) - return py_func - - dataset = dataset.map(get_row_py_func) - return dataset - - -def build_fake_input_fns(batch_size): - """Build fake data for unit testing.""" - num_words = 1000 - vocabulary = [str(i) for i in range(num_words)] - - random_sample = np.random.randint( - 10, size=(batch_size, num_words)).astype(np.float32) - - def train_input_fn(): - dataset = tf.data.Dataset.from_tensor_slices(random_sample) - dataset = dataset.batch(batch_size) - return tf1.data.make_one_shot_iterator(dataset.repeat()).get_next() - - def eval_input_fn(): - dataset = tf.data.Dataset.from_tensor_slices(random_sample) - dataset = dataset.batch(batch_size) - return tf1.data.make_one_shot_iterator(dataset).get_next() - - return train_input_fn, eval_input_fn, vocabulary - - -def build_input_fns(data_dir, batch_size): - """Builds iterators for train and evaluation data. - - Each object is represented as a bag-of-words vector. - - Args: - data_dir: Folder in which to store the data. - batch_size: Batch size for both train and evaluation. - Returns: - train_input_fn: A function that returns an iterator over the training data. - eval_input_fn: A function that returns an iterator over the evaluation data. - vocabulary: A mapping of word's integer index to the corresponding string. - """ - - with open(download(data_dir, "vocab.pkl"), "rb") as f: - words_to_idx = pickle.load(f) - num_words = len(words_to_idx) - - vocabulary = [None] * num_words - for word, idx in words_to_idx.items(): - vocabulary[idx] = word - - # Build an iterator over training batches. - def train_input_fn(): - dataset = newsgroups_dataset( - data_dir, "train", num_words, shuffle_and_repeat=True) - # Prefetching makes training about 1.5x faster. - dataset = dataset.batch(batch_size).prefetch(32) - return tf1.data.make_one_shot_iterator(dataset).get_next() - - # Build an iterator over the heldout set. - def eval_input_fn(): - dataset = newsgroups_dataset( - data_dir, "test", num_words, shuffle_and_repeat=False) - dataset = dataset.batch(batch_size) - return tf1.data.make_one_shot_iterator(dataset).get_next() - - return train_input_fn, eval_input_fn, vocabulary - - -def main(argv): - del argv # unused - - params = FLAGS.flag_values_dict() - params["layer_sizes"] = [int(units) for units in params["layer_sizes"]] - params["activation"] = getattr(tf.nn, params["activation"]) - if FLAGS.delete_existing and tf.io.gfile.exists(FLAGS.model_dir): - logging.warn("Deleting old log directory at %s", FLAGS.model_dir) - tf.io.gfile.rmtree(FLAGS.model_dir) - tf.io.gfile.makedirs(FLAGS.model_dir) - - if FLAGS.fake_data: - train_input_fn, eval_input_fn, vocabulary = build_fake_input_fns( - FLAGS.batch_size) - else: - train_input_fn, eval_input_fn, vocabulary = build_input_fns( - FLAGS.data_dir, FLAGS.batch_size) - params["vocabulary"] = vocabulary - - estimator = tf.estimator.Estimator( - model_fn, - params=params, - config=tf.estimator.RunConfig( - model_dir=FLAGS.model_dir, - save_checkpoints_steps=FLAGS.viz_steps, - ), - ) - - tf.random.set_seed(123) - for _ in range(FLAGS.max_steps // FLAGS.viz_steps): - estimator.train(train_input_fn, steps=FLAGS.viz_steps) - eval_results = estimator.evaluate(eval_input_fn) - # Print the evaluation results. The keys are strings specified in - # eval_metric_ops, and the values are NumPy scalars/arrays. - for key, value in eval_results.items(): - print(key) - if key == "topics": - # Topics description is a np.array which prints better row-by-row. - for s in value: - print(s) - else: - print(str(value)) - print("") - print("") - - -if __name__ == "__main__": - tf1.app.run() diff --git a/tensorflow_probability/examples/vae.py b/tensorflow_probability/examples/vae.py deleted file mode 100644 index 166d82355c..0000000000 --- a/tensorflow_probability/examples/vae.py +++ /dev/null @@ -1,526 +0,0 @@ -# Copyright 2018 The TensorFlow Probability Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# ============================================================================ -"""Trains a variational auto-encoder (VAE) on binarized MNIST. - -The VAE defines a generative model in which a latent code `Z` is sampled from a -prior `p(Z)`, then used to generate an observation `X` by way of a decoder -`p(X|Z)`. The full reconstruction follows - -```none - X ~ p(X) # A random image from some dataset. - Z ~ q(Z | X) # A random encoding of the original image ("encoder"). -Xhat ~ p(Xhat | Z) # A random reconstruction of the original image - # ("decoder"). -``` - -To fit the VAE, we assume an approximate representation of the posterior in the -form of an encoder `q(Z|X)`. We minimize the KL divergence between `q(Z|X)` and -the true posterior `p(Z|X)`: this is equivalent to maximizing the evidence lower -bound (ELBO), - -```none --log p(x) -= -log int dz p(x|z) p(z) -= -log int dz q(z|x) p(x|z) p(z) / q(z|x) -<= int dz q(z|x) (-log[ p(x|z) p(z) / q(z|x) ]) # Jensen's Inequality -=: KL[q(Z|x) || p(x|Z)p(Z)] -= -E_{Z~q(Z|x)}[log p(x|Z)] + KL[q(Z|x) || p(Z)] -``` - --or- - -```none --log p(x) -= KL[q(Z|x) || p(x|Z)p(Z)] - KL[q(Z|x) || p(Z|x)] -<= KL[q(Z|x) || p(x|Z)p(Z) # Positivity of KL -= -E_{Z~q(Z|x)}[log p(x|Z)] + KL[q(Z|x) || p(Z)] -``` - -The `-E_{Z~q(Z|x)}[log p(x|Z)]` term is an expected reconstruction loss and -`KL[q(Z|x) || p(Z)]` is a kind of distributional regularizer. See -[Kingma and Welling (2014)][1] for more details. - -This script supports both a (learned) mixture of Gaussians prior as well as a -fixed standard normal prior. You can enable the fixed standard normal prior by -setting `mixture_components` to 1. Note that fixing the parameters of the prior -(as opposed to fitting them with the rest of the model) incurs no loss in -generality when using only a single Gaussian. The reasoning for this is -two-fold: - - * On the generative side, the parameters from the prior can simply be absorbed - into the first linear layer of the generative net. If `z ~ N(mu, Sigma)` and - the first layer of the generative net is given by `x = Wz + b`, this can be - rewritten, - - s ~ N(0, I) - x = Wz + b - = W (As + mu) + b - = (WA) s + (W mu + b) - - where Sigma has been decomposed into A A^T = Sigma. In other words, the log - likelihood of the model (E_{Z~q(Z|x)}[log p(x|Z)]) is independent of whether - or not we learn mu and Sigma. - - * On the inference side, we can adjust any posterior approximation - q(z | x) ~ N(mu[q], Sigma[q]), with - - new_mu[p] := 0 - new_Sigma[p] := eye(d) - new_mu[q] := inv(chol(Sigma[p])) @ (mu[p] - mu[q]) - new_Sigma[q] := inv(Sigma[q]) @ Sigma[p] - - A bit of algebra on the KL divergence term `KL[q(Z|x) || p(Z)]` reveals that - it is also invariant to the prior parameters as long as Sigma[p] and - Sigma[q] are invertible. - -This script also supports using the analytic KL (KL[q(Z|x) || p(Z)]) with the -`analytic_kl` flag. Using the analytic KL is only supported when -`mixture_components` is set to 1 since otherwise no analytic form is known. - -Here we also compute tighter bounds, the IWAE [Burda et. al. (2015)][2]. - -These as well as image summaries can be seen in Tensorboard. For help using -Tensorboard see -https://www.tensorflow.org/guide/summaries_and_tensorboard -which can be run with - `python -m tensorboard.main --logdir=MODEL_DIR` - -#### References - -[1]: Diederik Kingma and Max Welling. Auto-Encoding Variational Bayes. In - _International Conference on Learning Representations_, 2014. - https://arxiv.org/abs/1312.6114 -[2]: Yuri Burda, Roger Grosse, Ruslan Salakhutdinov. Importance Weighted - Autoencoders. In _International Conference on Learning Representations_, - 2015. - https://arxiv.org/abs/1509.00519 -""" - -import functools -import os - -# Dependency imports -from absl import flags -import numpy as np -from six.moves import urllib -import tensorflow.compat.v1 as tf -import tensorflow_probability as tfp - -tfd = tfp.distributions - -IMAGE_SHAPE = [28, 28, 1] - -flags.DEFINE_float( - "learning_rate", default=0.001, help="Initial learning rate.") -flags.DEFINE_integer( - "max_steps", default=5001, help="Number of training steps to run.") -flags.DEFINE_integer( - "latent_size", - default=16, - help="Number of dimensions in the latent code (z).") -flags.DEFINE_integer("base_depth", default=32, help="Base depth for layers.") -flags.DEFINE_string( - "activation", - default="leaky_relu", - help="Activation function for all hidden layers.") -flags.DEFINE_integer( - "batch_size", - default=32, - help="Batch size.") -flags.DEFINE_integer( - "n_samples", default=16, help="Number of samples to use in encoding.") -flags.DEFINE_integer( - "mixture_components", - default=100, - help="Number of mixture components to use in the prior. Each component is " - "a diagonal normal distribution. The parameters of the components are " - "intialized randomly, and then learned along with the rest of the " - "parameters. If `analytic_kl` is True, `mixture_components` must be " - "set to `1`.") -flags.DEFINE_bool( - "analytic_kl", - default=False, - help="Whether or not to use the analytic version of the KL. When set to " - "False the E_{Z~q(Z|X)}[log p(Z)p(X|Z) - log q(Z|X)] form of the ELBO " - "will be used. Otherwise the -KL(q(Z|X) || p(Z)) + " - "E_{Z~q(Z|X)}[log p(X|Z)] form will be used. If analytic_kl is True, " - "then you must also specify `mixture_components=1`.") -flags.DEFINE_string( - "data_dir", - default=os.path.join(os.getenv("TEST_TMPDIR", "/tmp"), "vae/data"), - help="Directory where data is stored (if using real data).") -flags.DEFINE_string( - "model_dir", - default=os.path.join(os.getenv("TEST_TMPDIR", "/tmp"), "vae/"), - help="Directory to put the model's fit.") -flags.DEFINE_integer( - "viz_steps", default=500, help="Frequency at which to save visualizations.") -flags.DEFINE_bool( - "fake_data", - default=False, - help="If true, uses fake data instead of MNIST.") -flags.DEFINE_bool( - "delete_existing", - default=False, - help="If true, deletes existing `model_dir` directory.") - -FLAGS = flags.FLAGS - - -def _softplus_inverse(x): - """Helper which computes the function inverse of `tf.nn.softplus`.""" - return tf.math.log(tf.math.expm1(x)) - - -def make_encoder(activation, latent_size, base_depth): - """Creates the encoder function. - - Args: - activation: Activation function in hidden layers. - latent_size: The dimensionality of the encoding. - base_depth: The lowest depth for a layer. - - Returns: - encoder: A `callable` mapping a `Tensor` of images to a - `tfd.Distribution` instance over encodings. - """ - conv = functools.partial( - tf.keras.layers.Conv2D, padding="SAME", activation=activation) - - encoder_net = tf.keras.Sequential([ - conv(base_depth, 5, 1), - conv(base_depth, 5, 2), - conv(2 * base_depth, 5, 1), - conv(2 * base_depth, 5, 2), - conv(4 * latent_size, 7, padding="VALID"), - tf.keras.layers.Flatten(), - tf.keras.layers.Dense(2 * latent_size, activation=None), - ]) - - def encoder(images): - images = 2 * tf.cast(images, dtype=tf.float32) - 1 - net = encoder_net(images) - return tfd.MultivariateNormalDiag( - loc=net[..., :latent_size], - scale_diag=tf.nn.softplus(net[..., latent_size:] + - _softplus_inverse(1.0)), - name="code") - - return encoder - - -def make_decoder(activation, latent_size, output_shape, base_depth): - """Creates the decoder function. - - Args: - activation: Activation function in hidden layers. - latent_size: Dimensionality of the encoding. - output_shape: The output image shape. - base_depth: Smallest depth for a layer. - - Returns: - decoder: A `callable` mapping a `Tensor` of encodings to a - `tfd.Distribution` instance over images. - """ - deconv = functools.partial( - tf.keras.layers.Conv2DTranspose, padding="SAME", activation=activation) - conv = functools.partial( - tf.keras.layers.Conv2D, padding="SAME", activation=activation) - - decoder_net = tf.keras.Sequential([ - deconv(2 * base_depth, 7, padding="VALID"), - deconv(2 * base_depth, 5), - deconv(2 * base_depth, 5, 2), - deconv(base_depth, 5), - deconv(base_depth, 5, 2), - deconv(base_depth, 5), - conv(output_shape[-1], 5, activation=None), - ]) - - def decoder(codes): - original_shape = tf.shape(input=codes) - # Collapse the sample and batch dimension and convert to rank-4 tensor for - # use with a convolutional decoder network. - codes = tf.reshape(codes, (-1, 1, 1, latent_size)) - logits = decoder_net(codes) - logits = tf.reshape( - logits, shape=tf.concat([original_shape[:-1], output_shape], axis=0)) - return tfd.Independent(tfd.Bernoulli(logits=logits), - reinterpreted_batch_ndims=len(output_shape), - name="image") - - return decoder - - -def make_mixture_prior(latent_size, mixture_components): - """Creates the mixture of Gaussians prior distribution. - - Args: - latent_size: The dimensionality of the latent representation. - mixture_components: Number of elements of the mixture. - - Returns: - random_prior: A `tfd.Distribution` instance representing the distribution - over encodings in the absence of any evidence. - """ - if mixture_components == 1: - # See the module docstring for why we don't learn the parameters here. - return tfd.MultivariateNormalDiag( - loc=tf.zeros([latent_size]), - scale_identity_multiplier=1.0) - - loc = tf.compat.v1.get_variable( - name="loc", shape=[mixture_components, latent_size]) - raw_scale_diag = tf.compat.v1.get_variable( - name="raw_scale_diag", shape=[mixture_components, latent_size]) - mixture_logits = tf.compat.v1.get_variable( - name="mixture_logits", shape=[mixture_components]) - - return tfd.MixtureSameFamily( - components_distribution=tfd.MultivariateNormalDiag( - loc=loc, - scale_diag=tf.nn.softplus(raw_scale_diag)), - mixture_distribution=tfd.Categorical(logits=mixture_logits), - name="prior") - - -def pack_images(images, rows, cols): - """Helper utility to make a field of images.""" - shape = tf.shape(input=images) - width = shape[-3] - height = shape[-2] - depth = shape[-1] - images = tf.reshape(images, (-1, width, height, depth)) - batch = tf.shape(input=images)[0] - rows = tf.minimum(rows, batch) - cols = tf.minimum(batch // rows, cols) - images = images[:rows * cols] - images = tf.reshape(images, (rows, cols, width, height, depth)) - images = tf.transpose(a=images, perm=[0, 2, 1, 3, 4]) - images = tf.reshape(images, [1, rows * width, cols * height, depth]) - return images - - -def image_tile_summary(name, tensor, rows=8, cols=8): - tf.compat.v1.summary.image( - name, pack_images(tensor, rows, cols), max_outputs=1) - - -def model_fn(features, labels, mode, params, config): - """Builds the model function for use in an estimator. - - Args: - features: The input features for the estimator. - labels: The labels, unused here. - mode: Signifies whether it is train or test or predict. - params: Some hyperparameters as a dictionary. - config: The RunConfig, unused here. - - Returns: - EstimatorSpec: A tf.estimator.EstimatorSpec instance. - """ - del labels, config - - if params["analytic_kl"] and params["mixture_components"] != 1: - raise NotImplementedError( - "Using `analytic_kl` is only supported when `mixture_components = 1` " - "since there's no closed form otherwise.") - - encoder = make_encoder(params["activation"], - params["latent_size"], - params["base_depth"]) - decoder = make_decoder(params["activation"], - params["latent_size"], - IMAGE_SHAPE, - params["base_depth"]) - latent_prior = make_mixture_prior(params["latent_size"], - params["mixture_components"]) - - image_tile_summary( - "input", tf.cast(features, dtype=tf.float32), rows=1, cols=16) - - approx_posterior = encoder(features) - approx_posterior_sample = approx_posterior.sample(params["n_samples"]) - decoder_likelihood = decoder(approx_posterior_sample) - image_tile_summary( - "recon/sample", - tf.cast(decoder_likelihood.sample()[:3, :16], dtype=tf.float32), - rows=3, - cols=16) - image_tile_summary( - "recon/mean", - decoder_likelihood.mean()[:3, :16], - rows=3, - cols=16) - - # `distortion` is just the negative log likelihood. - distortion = -decoder_likelihood.log_prob(features) - avg_distortion = tf.reduce_mean(input_tensor=distortion) - tf.compat.v1.summary.scalar("distortion", avg_distortion) - - if params["analytic_kl"]: - rate = tfd.kl_divergence(approx_posterior, latent_prior) - else: - rate = (approx_posterior.log_prob(approx_posterior_sample) - - latent_prior.log_prob(approx_posterior_sample)) - avg_rate = tf.reduce_mean(input_tensor=rate) - tf.compat.v1.summary.scalar("rate", avg_rate) - - elbo_local = -(rate + distortion) - - elbo = tf.reduce_mean(input_tensor=elbo_local) - loss = -elbo - tf.compat.v1.summary.scalar("elbo", elbo) - - importance_weighted_elbo = tf.reduce_mean( - input_tensor=tf.reduce_logsumexp(input_tensor=elbo_local, axis=0) - - tf.math.log(tf.cast(params["n_samples"], dtype=tf.float32))) - tf.compat.v1.summary.scalar("elbo/importance_weighted", - importance_weighted_elbo) - - # Decode samples from the prior for visualization. - random_image = decoder(latent_prior.sample(16)) - image_tile_summary( - "random/sample", - tf.cast(random_image.sample(), dtype=tf.float32), - rows=4, - cols=4) - image_tile_summary("random/mean", random_image.mean(), rows=4, cols=4) - - # Perform variational inference by minimizing the -ELBO. - global_step = tf.compat.v1.train.get_or_create_global_step() - learning_rate = tf.compat.v1.train.cosine_decay( - params["learning_rate"], global_step, params["max_steps"]) - tf.compat.v1.summary.scalar("learning_rate", learning_rate) - optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate) - train_op = optimizer.minimize(loss, global_step=global_step) - - return tf.estimator.EstimatorSpec( - mode=mode, - loss=loss, - train_op=train_op, - eval_metric_ops={ - "elbo": - tf.compat.v1.metrics.mean(elbo), - "elbo/importance_weighted": - tf.compat.v1.metrics.mean(importance_weighted_elbo), - "rate": - tf.compat.v1.metrics.mean(avg_rate), - "distortion": - tf.compat.v1.metrics.mean(avg_distortion), - }, - ) - - -ROOT_PATH = "http://www.cs.toronto.edu/~larocheh/public/datasets/binarized_mnist/" -FILE_TEMPLATE = "binarized_mnist_{split}.amat" - - -def download(directory, filename): - """Downloads a file.""" - filepath = os.path.join(directory, filename) - if tf.io.gfile.exists(filepath): - return filepath - if not tf.io.gfile.exists(directory): - tf.io.gfile.makedirs(directory) - url = os.path.join(ROOT_PATH, filename) - print("Downloading %s to %s" % (url, filepath)) - urllib.request.urlretrieve(url, filepath) - return filepath - - -def static_mnist_dataset(directory, split_name): - """Returns binary static MNIST tf.data.Dataset.""" - amat_file = download(directory, FILE_TEMPLATE.format(split=split_name)) - dataset = tf.data.TextLineDataset(amat_file) - str_to_arr = lambda string: np.array([c == b"1" for c in string.split()]) - - def _parser(s): - booltensor = tf.compat.v1.py_func(str_to_arr, [s], tf.bool) - reshaped = tf.reshape(booltensor, [28, 28, 1]) - return tf.cast(reshaped, dtype=tf.float32), tf.constant(0, tf.int32) - - return dataset.map(_parser) - - -def build_fake_input_fns(batch_size): - """Builds fake MNIST-style data for unit testing.""" - random_sample = np.random.rand(batch_size, *IMAGE_SHAPE).astype("float32") - - def train_input_fn(): - dataset = tf.data.Dataset.from_tensor_slices( - random_sample).map(lambda row: (row, 0)).batch(batch_size).repeat() - return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next() - - def eval_input_fn(): - dataset = tf.data.Dataset.from_tensor_slices( - random_sample).map(lambda row: (row, 0)).batch(batch_size) - return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next() - - return train_input_fn, eval_input_fn - - -def build_input_fns(data_dir, batch_size): - """Builds an Iterator switching between train and heldout data.""" - - # Build an iterator over training batches. - def train_input_fn(): - dataset = static_mnist_dataset(data_dir, "train") - dataset = dataset.shuffle(50000).repeat().batch(batch_size) - return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next() - - # Build an iterator over the heldout set. - def eval_input_fn(): - eval_dataset = static_mnist_dataset(data_dir, "valid") - eval_dataset = eval_dataset.batch(batch_size) - return tf.compat.v1.data.make_one_shot_iterator(eval_dataset).get_next() - - return train_input_fn, eval_input_fn - - -def main(argv): - del argv # unused - - params = FLAGS.flag_values_dict() - params["activation"] = getattr(tf.nn, params["activation"]) - if FLAGS.delete_existing and tf.io.gfile.exists(FLAGS.model_dir): - tf.compat.v1.logging.warn("Deleting old log directory at {}".format( - FLAGS.model_dir)) - tf.io.gfile.rmtree(FLAGS.model_dir) - tf.io.gfile.makedirs(FLAGS.model_dir) - - if FLAGS.fake_data: - train_input_fn, eval_input_fn = build_fake_input_fns(FLAGS.batch_size) - else: - train_input_fn, eval_input_fn = build_input_fns(FLAGS.data_dir, - FLAGS.batch_size) - - estimator = tf.estimator.Estimator( - model_fn, - params=params, - config=tf.estimator.RunConfig( - model_dir=FLAGS.model_dir, - save_checkpoints_steps=FLAGS.viz_steps, - ), - ) - - for _ in range(FLAGS.max_steps // FLAGS.viz_steps): - estimator.train(train_input_fn, steps=FLAGS.viz_steps) - eval_results = estimator.evaluate(eval_input_fn) - print("Evaluation_results:\n\t%s\n" % eval_results) - - -if __name__ == "__main__": - tf.compat.v1.app.run() From 953f0634f06da443e9356bcb16a9725a8582ad9c Mon Sep 17 00:00:00 2001 From: emilyaf Date: Sat, 26 Mar 2022 11:10:53 -0700 Subject: [PATCH 056/153] Replace jax.core.partial with functools.partial in Oryx. PiperOrigin-RevId: 437476282 --- spinoffs/oryx/oryx/core/state/function.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spinoffs/oryx/oryx/core/state/function.py b/spinoffs/oryx/oryx/core/state/function.py index 451c849ae7..503477a08a 100644 --- a/spinoffs/oryx/oryx/core/state/function.py +++ b/spinoffs/oryx/oryx/core/state/function.py @@ -121,7 +121,7 @@ def write(v, val): if subjaxpr: subfuns = [ lu.wrap_init( - jax_core.partial(eval_jaxpr_with_kwargs, subjaxpr, (), **kwargs)) + functools.partial(eval_jaxpr_with_kwargs, subjaxpr, (), **kwargs)) ] else: subfuns = [] From cd27c8183273761162e02cd8e7611a1fe8c15c84 Mon Sep 17 00:00:00 2001 From: fmuham Date: Mon, 28 Mar 2022 06:34:59 -0700 Subject: [PATCH 057/153] Migrate experimental_relax_shapes to reduce_retracing PiperOrigin-RevId: 437742142 --- discussion/examples/windowed_sampling.ipynb | 4 ++-- .../window_tune_nuts_sampling.py | 14 +++++++------- .../TFP_Release_Notebook_0_13_0.ipynb | 2 +- .../python/distributions/gamma.py | 2 +- .../python/internal/backend/numpy/v2.py | 2 +- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/discussion/examples/windowed_sampling.ipynb b/discussion/examples/windowed_sampling.ipynb index 626a61e7f4..b0f9c7e526 100644 --- a/discussion/examples/windowed_sampling.ipynb +++ b/discussion/examples/windowed_sampling.ipynb @@ -1837,9 +1837,9 @@ "WARNING:tensorflow:Note that RandomStandardNormal inside pfor op may not give same output as inside a sequential loop.\n", "Fast window 75\n", "Slow window 25\n", - "WARNING:tensorflow:5 out of the last 5 calls to \u003cfunction slow_window at 0x7f9456031ea0\u003e triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", + "WARNING:tensorflow:5 out of the last 5 calls to \u003cfunction slow_window at 0x7f9456031ea0\u003e triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", "Slow window 50\n", - "WARNING:tensorflow:6 out of the last 6 calls to \u003cfunction slow_window at 0x7f9456031ea0\u003e triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", + "WARNING:tensorflow:6 out of the last 6 calls to \u003cfunction slow_window at 0x7f9456031ea0\u003e triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", "Slow window 100\n", "Slow window 200\n", "Fast window 75\n", diff --git a/discussion/turnkey_inference_candidate/window_tune_nuts_sampling.py b/discussion/turnkey_inference_candidate/window_tune_nuts_sampling.py index 377f08e9b8..360988ae3f 100644 --- a/discussion/turnkey_inference_candidate/window_tune_nuts_sampling.py +++ b/discussion/turnkey_inference_candidate/window_tune_nuts_sampling.py @@ -46,7 +46,7 @@ def _sample_posterior(target_log_prob_unconstrained, parallel_iterations=10, jit_compile=True, use_input_signature=False, - experimental_relax_shapes=False): + reduce_retracing=False): """MCMC sampling with HMC/NUTS using an expanding epoch tuning scheme.""" seed_stream = tfp.util.SeedStream(seed, 'window_tune_nuts_sampling') @@ -117,7 +117,7 @@ def _sample_posterior(target_log_prob_unconstrained, input_signature=input_signature, autograph=False, jit_compile=jit_compile, - experimental_relax_shapes=experimental_relax_shapes) + reduce_retracing=reduce_retracing) def fast_adaptation_interval(num_steps, previous_state): """Step size only adaptation interval. @@ -179,7 +179,7 @@ def body_fn_window2( input_signature=input_signature, autograph=False, jit_compile=jit_compile, - experimental_relax_shapes=experimental_relax_shapes) + reduce_retracing=reduce_retracing) def slow_adaptation_interval(num_steps, previous_n, previous_state, previous_mean, previous_cov): """Interval that tunes the mass matrix and step size simultaneously. @@ -328,7 +328,7 @@ def window_tune_nuts_sampling(target_log_prob, parallel_iterations=10, jit_compile=True, use_input_signature=True, - experimental_relax_shapes=False): + reduce_retracing=False): """Sample from a density with NUTS and an expanding window tuning scheme. This function implements a turnkey MCMC sampling routine using NUTS and an @@ -347,7 +347,7 @@ def window_tune_nuts_sampling(target_log_prob, of the tuning epoch (window 1, 2, and 3 in Stan [1]) run with two @tf.function compiled functions. The user can control the compilation options using the kwargs `jit_compile`, `use_input_signature`, and - `experimental_relax_shapes`. Setting all to True would compile to XLA and + `reduce_retracing`. Setting all to True would compile to XLA and potentially avoid the small overhead of function recompilation (note that it is not yet the case in XLA right now). It is not yet clear whether doing it this way is better than just wrapping the full inference routine in @@ -403,7 +403,7 @@ def window_tune_nuts_sampling(target_log_prob, function is always compiled by XLA. use_input_signature: If True, generate an input_signature kwarg to pass to tf.function decorator. - experimental_relax_shapes: kwarg pass to tf.function decorator. When True, + reduce_retracing: kwarg pass to tf.function decorator. When True, tf.function may generate fewer, graphs that are less specialized on input shapes. @@ -564,6 +564,6 @@ def target_log_prob_unconstrained_concated(x): parallel_iterations=parallel_iterations, jit_compile=jit_compile, use_input_signature=use_input_signature, - experimental_relax_shapes=experimental_relax_shapes) + reduce_retracing=reduce_retracing) return forward_transform( split_and_reshape(nuts_samples)), diagnostic, conditioning_bijector diff --git a/tensorflow_probability/examples/jupyter_notebooks/TFP_Release_Notebook_0_13_0.ipynb b/tensorflow_probability/examples/jupyter_notebooks/TFP_Release_Notebook_0_13_0.ipynb index 5c598532aa..22413dec4b 100644 --- a/tensorflow_probability/examples/jupyter_notebooks/TFP_Release_Notebook_0_13_0.ipynb +++ b/tensorflow_probability/examples/jupyter_notebooks/TFP_Release_Notebook_0_13_0.ipynb @@ -954,7 +954,7 @@ " c1=,\n", " counts=\n", ")\n", - "WARNING:tensorflow:6 out of the last 6 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", + "WARNING:tensorflow:6 out of the last 6 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", "StructTuple(\n", " c0=,\n", " c1=,\n", diff --git a/tensorflow_probability/python/distributions/gamma.py b/tensorflow_probability/python/distributions/gamma.py index 086195c73d..10450386da 100644 --- a/tensorflow_probability/python/distributions/gamma.py +++ b/tensorflow_probability/python/distributions/gamma.py @@ -510,7 +510,7 @@ def _random_gamma_noncpu( # tf.function required to access Grappler's implementation_selector. @implementation_selection.never_runs_functions_eagerly # TODO(b/163029794): Shape relaxation breaks XLA. -@tf.function(autograph=False, experimental_relax_shapes=False) +@tf.function(autograph=False, reduce_retracing=False) def _random_gamma_no_gradient( shape, concentration, rate, log_rate, seed, log_space): """Sample a gamma, CPU specialized to stateless_gamma. diff --git a/tensorflow_probability/python/internal/backend/numpy/v2.py b/tensorflow_probability/python/internal/backend/numpy/v2.py index aa423edd0d..11945482a2 100644 --- a/tensorflow_probability/python/internal/backend/numpy/v2.py +++ b/tensorflow_probability/python/internal/backend/numpy/v2.py @@ -60,7 +60,7 @@ def _function(func=None, input_signature=None, autograph=True, # pylint: disable=unused-argument experimental_autograph_options=None, # pylint: disable=unused-argument - experimental_relax_shapes=False, jit_compile=None): # pylint: disable=unused-argument + reduce_retracing=False, jit_compile=None): # pylint: disable=unused-argument """Like `tf.function`, for JAX.""" transform = lambda fn: fn if jit_compile: From 5738ca794a609e41b20f06a0c7a5315358134aca Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Tue, 29 Mar 2022 13:48:39 -0300 Subject: [PATCH 058/153] Reorganize file --- .../python/distributions/two_piece_normal.py | 174 +++++++++--------- 1 file changed, 87 insertions(+), 87 deletions(-) diff --git a/tensorflow_probability/python/distributions/two_piece_normal.py b/tensorflow_probability/python/distributions/two_piece_normal.py index 9971d0c966..4c77077b23 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal.py +++ b/tensorflow_probability/python/distributions/two_piece_normal.py @@ -40,93 +40,6 @@ NUMPY_MODE = False -def _numpy_cast(x, dtype): - # TODO(b/223684173): Many special math routines don't respect the input dtype. - if NUMPY_MODE: - return tf.cast(x, dtype) - else: - return x - - -def standardize(value, loc, scale, skewness): - """Apply mean-variance-skewness standardization to input `value`. - - Note that scale and skewness can be negative. - - Args: - value: Floating-point tensor; the value(s) to be standardized. - loc: Floating-point tensor; the location(s) of the distribution(s). - scale: Floating-point tensor; the scale(s) of the distribution(s). - skewness: Floating-point tensor; the skewness(es) of the distribution(s). - - Returns: - A tensor with shape broadcast according to the arguments. - """ - return (value - loc) / tf.math.abs(scale) * tf.math.abs( - tf.where(value < loc, skewness, tf.math.reciprocal(skewness))) - - -def cdf(value, loc, scale, skewness): - """Compute cumulative distribution function of Two-Piece Normal distribution. - - Note that scale and skewness can be negative. - - Args: - value: Floating-point tensor; where to compute the cdf. - loc: Floating-point tensor; the location(s) of the distribution(s). - scale: Floating-point tensor; the scale(s) of the distribution(s). - skewness: Floating-point tensor; the skewness(es) of the distribution(s). - - Returns: - A tensor with shape broadcast according to the arguments. - """ - one = tf.constant(1., dtype=loc.dtype) - two = tf.constant(2., dtype=loc.dtype) - - z = standardize(value, loc=loc, scale=scale, skewness=skewness) - normal_cdf = _numpy_cast(special_math.ndtr(z), loc.dtype) - - squared_skewness = tf.math.square(skewness) - return tf.math.reciprocal(one + squared_skewness) * tf.where( - z < 0., - two * normal_cdf, - one - squared_skewness + two * squared_skewness * normal_cdf) - - -def quantile(value, loc, scale, skewness): - """Compute quantile function (inverse cdf) of Two-Piece Normal distribution. - - Note that scale and skewness can be negative. - - Args: - value: Floating-point tensor; where to compute the quantile function. - loc: Floating-point tensor; the location(s) of the distribution(s). - scale: Floating-point tensor; the scale(s) of the distribution(s). - skewness: Floating-point tensor; the skewness(es) of the distribution(s). - - Returns: - A tensor with shape broadcast according to the arguments. - """ - half = tf.constant(0.5, dtype=loc.dtype) - one = tf.constant(1., dtype=loc.dtype) - two = tf.constant(2., dtype=loc.dtype) - - squared_skewness = tf.math.square(skewness) - cond = value < tf.math.reciprocal(one + squared_skewness) - - # Here we use the following fact: - # X ~ Normal(loc=0, scale=1) => 2 * X**2 ~ Gamma(alpha=0.5, beta=1) - probs = (one - value * (one + squared_skewness)) * tf.where( - cond, one, -tf.math.reciprocal(squared_skewness)) - gamma_quantile = _numpy_cast(tfp_math.igammainv(half, p=probs), loc.dtype) - - abs_skewness = tf.math.abs(skewness) - adj_scale = tf.math.abs(scale) * tf.where( - cond, -tf.math.reciprocal(abs_skewness), abs_skewness) - - return loc + adj_scale * tf.math.sqrt(two * gamma_quantile) - - class TwoPieceNormal(distribution.AutoCompositeTensorDistribution): """The Two-Piece Normal distribution. @@ -490,3 +403,90 @@ def _parameter_control_dependencies(self, is_init): self.skewness, message='Argument `skewness` must be positive.')) return assertions + + +def _numpy_cast(x, dtype): + # TODO(b/223684173): Many special math routines don't respect the input dtype. + if NUMPY_MODE: + return tf.cast(x, dtype) + else: + return x + + +def standardize(value, loc, scale, skewness): + """Apply mean-variance-skewness standardization to input `value`. + + Note that scale and skewness can be negative. + + Args: + value: Floating-point tensor; the value(s) to be standardized. + loc: Floating-point tensor; the location(s) of the distribution(s). + scale: Floating-point tensor; the scale(s) of the distribution(s). + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + + Returns: + A tensor with shape broadcast according to the arguments. + """ + return (value - loc) / tf.math.abs(scale) * tf.math.abs( + tf.where(value < loc, skewness, tf.math.reciprocal(skewness))) + + +def cdf(value, loc, scale, skewness): + """Compute cumulative distribution function of Two-Piece Normal distribution. + + Note that scale and skewness can be negative. + + Args: + value: Floating-point tensor; where to compute the cdf. + loc: Floating-point tensor; the location(s) of the distribution(s). + scale: Floating-point tensor; the scale(s) of the distribution(s). + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + + Returns: + A tensor with shape broadcast according to the arguments. + """ + one = tf.constant(1., dtype=loc.dtype) + two = tf.constant(2., dtype=loc.dtype) + + z = standardize(value, loc=loc, scale=scale, skewness=skewness) + normal_cdf = _numpy_cast(special_math.ndtr(z), loc.dtype) + + squared_skewness = tf.math.square(skewness) + return tf.math.reciprocal(one + squared_skewness) * tf.where( + z < 0., + two * normal_cdf, + one - squared_skewness + two * squared_skewness * normal_cdf) + + +def quantile(value, loc, scale, skewness): + """Compute quantile function (inverse cdf) of Two-Piece Normal distribution. + + Note that scale and skewness can be negative. + + Args: + value: Floating-point tensor; where to compute the quantile function. + loc: Floating-point tensor; the location(s) of the distribution(s). + scale: Floating-point tensor; the scale(s) of the distribution(s). + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + + Returns: + A tensor with shape broadcast according to the arguments. + """ + half = tf.constant(0.5, dtype=loc.dtype) + one = tf.constant(1., dtype=loc.dtype) + two = tf.constant(2., dtype=loc.dtype) + + squared_skewness = tf.math.square(skewness) + cond = value < tf.math.reciprocal(one + squared_skewness) + + # Here we use the following fact: + # X ~ Normal(loc=0, scale=1) => 2 * X**2 ~ Gamma(alpha=0.5, beta=1) + probs = (one - value * (one + squared_skewness)) * tf.where( + cond, one, -tf.math.reciprocal(squared_skewness)) + gamma_quantile = _numpy_cast(tfp_math.igammainv(half, p=probs), loc.dtype) + + abs_skewness = tf.math.abs(skewness) + adj_scale = tf.math.abs(scale) * tf.where( + cond, -tf.math.reciprocal(abs_skewness), abs_skewness) + + return loc + adj_scale * tf.math.sqrt(two * gamma_quantile) From 8b366fca06a167475b5da7ff6bbd03751a91eba0 Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Tue, 29 Mar 2022 14:07:53 -0300 Subject: [PATCH 059/153] Add implicit gradient --- .../python/distributions/BUILD | 1 + .../python/distributions/two_piece_normal.py | 210 +++++++++++++++++- 2 files changed, 199 insertions(+), 12 deletions(-) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index 0edbb6d567..ebfa3bd3f3 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -2165,6 +2165,7 @@ multi_substrate_py_library( "//tensorflow_probability/python/bijectors:identity", "//tensorflow_probability/python/bijectors:softplus", "//tensorflow_probability/python/internal:assert_util", + "//tensorflow_probability/python/internal:custom_gradient", "//tensorflow_probability/python/internal:dtype_util", "//tensorflow_probability/python/internal:parameter_properties", "//tensorflow_probability/python/internal:prefer_static", diff --git a/tensorflow_probability/python/distributions/two_piece_normal.py b/tensorflow_probability/python/distributions/two_piece_normal.py index 4c77077b23..e836908648 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal.py +++ b/tensorflow_probability/python/distributions/two_piece_normal.py @@ -24,6 +24,7 @@ from tensorflow_probability.python.bijectors import softplus as softplus_bijector from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.internal import assert_util +from tensorflow_probability.python.internal import custom_gradient as tfp_custom_gradient from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties from tensorflow_probability.python.internal import prefer_static as ps @@ -269,19 +270,10 @@ def _sample_n(self, n, seed=None): loc=loc, scale=scale, skewness=skewness) sample_shape = ps.concat([[n], batch_shape], axis=0) - uniform_seed, normal_seed = samplers.split_seed( - seed, salt='two_piece_normal') - uniform_sample = samplers.uniform( - sample_shape, maxval=1., dtype=self.dtype, seed=uniform_seed) - normal_sample = samplers.normal( - sample_shape, dtype=self.dtype, seed=normal_seed) + samples = random_two_piece_normal( + sample_shape, skewness=skewness, seed=seed) - sample = tf.abs(normal_sample) * tf.where( - uniform_sample < tf.math.reciprocal(1. + skewness**2), - -tf.math.reciprocal(skewness), - skewness) - - return loc + scale * sample + return loc + scale * samples def _log_prob(self, value): value = tf.convert_to_tensor(value, dtype_hint=self.dtype) @@ -490,3 +482,197 @@ def quantile(value, loc, scale, skewness): cond, -tf.math.reciprocal(abs_skewness), abs_skewness) return loc + adj_scale * tf.math.sqrt(two * gamma_quantile) + + +def _two_piece_normal_sample_no_gradient(shape, skewness, seed): + """Generate samples from Two-Piece Normal distribution. + + The distribution is the Two-Piece Normal distribution with location zero, + scale one, and skewness `skewness`. To change the location and scale, use: + + ```none + loc + scale * samples + ``` + + Args: + shape: 0D or 1D int32 Tensor. Shape of the generated samples. + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + + Returns: + A tensor with prepended dimensions `shape`. + """ + uniform_seed, normal_seed = samplers.split_seed( + seed, salt='two_piece_normal_split') + uniform_samples = samplers.uniform( + shape, maxval=1., dtype=skewness.dtype, seed=uniform_seed) + normal_samples = samplers.normal( + shape, dtype=skewness.dtype, seed=normal_seed) + + return tf.abs(normal_samples) * tf.where( + uniform_samples < tf.math.reciprocal(1. + skewness**2), + -tf.math.reciprocal(skewness), + skewness) + + +def _two_piece_normal_sample_gradient(skewness, samples): + """Compute the gradients of Two-Piece Normal samples w.r.t. skewness. + + This function computes the implicit reparameterization gradients [1]: + + ```none + dz / dskewness = -(dF(z; skewness) / dskewness) / p(z; skewness) + ``` + + where `F(z; skewness)` and `p(z; skewness)` are the cdf and the pdf of the + Two-Piece Normal distribution with location zero, scale one, and skewness + `skewness`. + + Args: + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + samples: Floating-point tensor; the samples of the distribution(s). + + Returns: + A tensor with shape broadcast according to the arguments. + + Reference: + [1]: Michael Figurnov, Shakir Mohamed, and Andriy Mnih. + Implicit Reparameterization Gradients. In _Advances in Neural + Information Processing Systems_, 31, 2018. + https://arxiv.org/abs/1805.08498 + """ + one = tf.constant(1., dtype=skewness.dtype) + two = tf.constant(2., dtype=skewness.dtype) + pi = tf.constant(np.pi, dtype=skewness.dtype) + four = tf.constant(4., dtype=skewness.dtype) + + left_piece = samples < 0. + z = samples * tf.where(left_piece, skewness, tf.math.reciprocal(skewness)) + + double_skewness = two * skewness + squared_skewness = tf.math.square(skewness) + scale = tf.math.reciprocal(one + squared_skewness) + squared_scale = tf.math.square(scale) + + ndtr_term = four * skewness * _numpy_cast( + special_math.ndtr(z), skewness.dtype) + exp_term = scale * tf.math.sqrt(two / pi) * tf.math.exp( + -tf.math.square(z) / two) + samples_term = samples * exp_term + + grad_left_piece = samples_term - squared_scale * ndtr_term + grad_right_piece0 = scale * (ndtr_term - double_skewness) - samples_term + grad_right_piece1 = squared_scale * (double_skewness + squared_skewness * ( + ndtr_term - double_skewness)) + grad_right_piece = grad_right_piece0 - grad_right_piece1 + + cdf_grad = tf.where(left_piece, grad_left_piece, grad_right_piece) + prob = skewness * exp_term + + return -cdf_grad / prob + + +def _two_piece_normal_sample_fwd(shape, skewness, seed): + """Compute output, aux (collaborates with _two_piece_normal_sample_bwd).""" + samples = _two_piece_normal_sample_no_gradient(shape, skewness, seed) + return samples, (skewness, samples) + + +def _two_piece_normal_sample_bwd(_, aux, dy): + """The gradients of Two Piece Normal samples w.r.t. skewness.""" + skewness, samples = aux + broadcast_skewness = tf.broadcast_to(skewness, ps.shape(samples)) + + grad = dy * _two_piece_normal_sample_gradient(broadcast_skewness, samples) + # Sum over the sample dimensions. Assume that they are always the first + # ones. + num_sample_dimensions = (tf.rank(broadcast_skewness) - + tf.rank(skewness)) + + # None gradients for seed + return tf.reduce_sum(grad, axis=tf.range(num_sample_dimensions)), None + + +def _two_piece_normal_sample_jvp(shape, primals, tangents): + """Compute primals and tangents using implicit derivative.""" + skewness, seed = primals + dskewness, dseed = tangents + del dseed + + broadcast_skewness = tf.broadcast_to(skewness, shape) + broadcast_dskewness = tf.broadcast_to(dskewness, shape) + + samples = _two_piece_normal_sample_no_gradient(shape, skewness, seed) + dsamples = broadcast_dskewness * _two_piece_normal_sample_gradient( + broadcast_skewness, samples) + + return samples, dsamples + + +@tfp_custom_gradient.custom_gradient( + vjp_fwd=_two_piece_normal_sample_fwd, + vjp_bwd=_two_piece_normal_sample_bwd, + jvp_fn=_two_piece_normal_sample_jvp, + nondiff_argnums=(0,)) +def _two_piece_normal_sample_with_gradient(shape, skewness, seed): + """Generate samples from Two-Piece Normal distribution. + + The distribution is the Two-Piece Normal distribution with location zero, + scale one, and skewness `skewness`. To change the location and scale, use: + + ```none + loc + scale * samples + ``` + + The samples are pathwise differentiable using the approach of [1]. + + Args: + shape: 0D or 1D int32 Tensor. Shape of the generated samples. + skewness: Floating-point tensor; the skewness(es) of the distribution(s). + seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + + Returns: + A tensor with prepended dimensions `shape`. + + References: + [1]: Michael Figurnov, Shakir Mohamed, and Andriy Mnih. + Implicit Reparameterization Gradients. In _Advances in Neural + Information Processing Systems_, 31, 2018. + https://arxiv.org/abs/1805.08498 + """ + return _two_piece_normal_sample_no_gradient(shape, skewness, seed) + + +def random_two_piece_normal(shape, skewness, seed=None): + """Generate samples from Two-Piece Normal distribution. + + The distribution is the Two-Piece Normal distribution with location zero, + scale one, and skewness `skewness`. To change the location and scale, use: + + ```none + loc + scale * samples + ``` + + The samples are pathwise differentiable using the approach of [1]. + + Note that skewness can be negative. + + Args: + shape: The output sample shape. + skewness: The skewness(es) of the distribution(s). + seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + + Returns: + A tensor with prepended dimensions `shape`. + + References: + [1]: Michael Figurnov, Shakir Mohamed, and Andriy Mnih. + Implicit Reparameterization Gradients. In _Advances in Neural + Information Processing Systems_, 31, 2018. + https://arxiv.org/abs/1805.08498 + """ + shape = ps.convert_to_shape_tensor(shape, dtype_hint=tf.int32) + skewness = tf.convert_to_tensor(skewness) + seed = samplers.sanitize_seed(seed, salt='two_piece_normal') + + return _two_piece_normal_sample_with_gradient(shape, tf.abs(skewness), seed) From 44d5efb33cf53c983f639ac8d1405185a88e8694 Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Tue, 29 Mar 2022 19:52:23 -0300 Subject: [PATCH 060/153] Convert args to tensor --- .../python/distributions/two_piece_normal.py | 31 ++++++++++++++----- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/tensorflow_probability/python/distributions/two_piece_normal.py b/tensorflow_probability/python/distributions/two_piece_normal.py index e836908648..7b60dbcfcb 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal.py +++ b/tensorflow_probability/python/distributions/two_piece_normal.py @@ -419,6 +419,11 @@ def standardize(value, loc, scale, skewness): Returns: A tensor with shape broadcast according to the arguments. """ + value = tf.convert_to_tensor(value) + loc = tf.convert_to_tensor(loc) + scale = tf.convert_to_tensor(scale) + skewness = tf.convert_to_tensor(skewness) + return (value - loc) / tf.math.abs(scale) * tf.math.abs( tf.where(value < loc, skewness, tf.math.reciprocal(skewness))) @@ -437,11 +442,17 @@ def cdf(value, loc, scale, skewness): Returns: A tensor with shape broadcast according to the arguments. """ - one = tf.constant(1., dtype=loc.dtype) - two = tf.constant(2., dtype=loc.dtype) + value = tf.convert_to_tensor(value) + loc = tf.convert_to_tensor(loc) + scale = tf.convert_to_tensor(scale) + skewness = tf.convert_to_tensor(skewness) + dtype = value.dtype + + one = tf.constant(1., dtype=dtype) + two = tf.constant(2., dtype=dtype) z = standardize(value, loc=loc, scale=scale, skewness=skewness) - normal_cdf = _numpy_cast(special_math.ndtr(z), loc.dtype) + normal_cdf = _numpy_cast(special_math.ndtr(z), dtype) squared_skewness = tf.math.square(skewness) return tf.math.reciprocal(one + squared_skewness) * tf.where( @@ -464,9 +475,15 @@ def quantile(value, loc, scale, skewness): Returns: A tensor with shape broadcast according to the arguments. """ - half = tf.constant(0.5, dtype=loc.dtype) - one = tf.constant(1., dtype=loc.dtype) - two = tf.constant(2., dtype=loc.dtype) + value = tf.convert_to_tensor(value) + loc = tf.convert_to_tensor(loc) + scale = tf.convert_to_tensor(scale) + skewness = tf.convert_to_tensor(skewness) + dtype = value.dtype + + half = tf.constant(0.5, dtype=dtype) + one = tf.constant(1., dtype=dtype) + two = tf.constant(2., dtype=dtype) squared_skewness = tf.math.square(skewness) cond = value < tf.math.reciprocal(one + squared_skewness) @@ -475,7 +492,7 @@ def quantile(value, loc, scale, skewness): # X ~ Normal(loc=0, scale=1) => 2 * X**2 ~ Gamma(alpha=0.5, beta=1) probs = (one - value * (one + squared_skewness)) * tf.where( cond, one, -tf.math.reciprocal(squared_skewness)) - gamma_quantile = _numpy_cast(tfp_math.igammainv(half, p=probs), loc.dtype) + gamma_quantile = _numpy_cast(tfp_math.igammainv(half, p=probs), dtype) abs_skewness = tf.math.abs(skewness) adj_scale = tf.math.abs(scale) * tf.where( From 0c3e32ed929fc1e93ee919d02d493ead64c3131b Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Tue, 29 Mar 2022 21:33:57 -0300 Subject: [PATCH 061/153] Improve sample test --- .../distributions/two_piece_normal_test.py | 42 ++++++++++--------- 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/tensorflow_probability/python/distributions/two_piece_normal_test.py b/tensorflow_probability/python/distributions/two_piece_normal_test.py index afae5883f7..4b33346c18 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal_test.py +++ b/tensorflow_probability/python/distributions/two_piece_normal_test.py @@ -15,6 +15,7 @@ """Tests for Two-Piece Normal distribution.""" # Dependency imports +import itertools import numpy as np import tensorflow.compat.v2 as tf @@ -154,28 +155,29 @@ def testShape(self): self.assertAllEqual(dist.batch_shape, self.evaluate(result).shape) def testSample(self): - dist = self.make_two_piece_normals() - - seed_stream = test_util.test_seed_stream() - - n = 100_000 one = tf.constant(1., dtype=self.dtype) + seed_stream = test_util.test_seed_stream() - sample = dist.sample(n, seed=seed_stream()) - - uniform_sample = tf.random.uniform( - sample.shape, maxval=1., dtype=self.dtype, seed=seed_stream()) - sign = tf.where(uniform_sample < 0.5, -one, one) - normal_sample = self.evaluate(sign * tfd.two_piece_normal.standardize( - sample, loc=dist.loc, scale=dist.scale, skewness=dist.skewness)) - - # Note that the standard error for the sample mean is ~ sigma / sqrt(n). - # The sample variance similarly is dependent on scale and n. - # Thus, the tolerances below are very sensitive to number of samples - # as well as the variances chosen. - self.assertAllEqual(normal_sample.shape, [n] + dist.batch_shape) - self.assertAllClose(np.mean(normal_sample), 0.0, atol=0.1) - self.assertAllClose(np.std(normal_sample), 1.0, atol=0.1) + dists = (self.make_two_piece_normal(), self.make_two_piece_normals()) + n = int(3e2) + sample_shapes = ([n, n], [n * n]) + + for dist, sample_shape in itertools.product(dists, sample_shapes): + sample = dist.sample(sample_shape, seed=seed_stream()) + + uniform_sample = tf.random.uniform( + sample.shape, maxval=1., dtype=self.dtype, seed=seed_stream()) + sign = tf.where(uniform_sample < 0.5, -one, one) + normal_sample = self.evaluate(sign * tfd.two_piece_normal.standardize( + sample, loc=dist.loc, scale=dist.scale, skewness=dist.skewness)) + + # Note that the standard error for the sample mean is ~ sigma / sqrt(n). + # The sample variance similarly is dependent on scale and n. + # Thus, the tolerances below are very sensitive to number of samples + # as well as the variances chosen. + self.assertAllEqual(normal_sample.shape, sample_shape + dist.batch_shape) + self.assertAllClose(np.mean(normal_sample), 0.0, atol=0.1) + self.assertAllClose(np.std(normal_sample), 1.0, atol=0.1) def testLogPDF(self): dist = self.make_two_piece_normals() From a3400edcf2026ad654f57831dd15fc8c7a196a9a Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Wed, 30 Mar 2022 13:29:21 -0300 Subject: [PATCH 062/153] Add numerical test --- .../distributions/two_piece_normal_test.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tensorflow_probability/python/distributions/two_piece_normal_test.py b/tensorflow_probability/python/distributions/two_piece_normal_test.py index 4b33346c18..e38a073f37 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal_test.py +++ b/tensorflow_probability/python/distributions/two_piece_normal_test.py @@ -350,6 +350,22 @@ def sampler(loc, scale, skewness): self.assertIsNotNone(grads[1]) # d/d scale self.assertIsNotNone(grads[2]) # d/d skewness + @test_util.numpy_disable_gradient_test + def testDifferentiableSampleNumerically(self): + def sampler(loc, scale, skewness): + dist = tfd.TwoPieceNormal( + loc, scale=scale, skewness=skewness, validate_args=True) + n = int(2e5) + return tf.reduce_mean(dist.sample(n, seed=test_util.test_seed())) + + loc = tf.constant(0.1, self.dtype) + scale = tf.constant(1.1, self.dtype) + + for skewness in [0.75, 1., 1.33]: + err = self.compute_max_gradient_error( + sampler, [loc, scale, tf.constant(skewness, self.dtype)], delta=0.1) + self.assertLess(err, 0.05) + def testNegativeScaleSkewnessFails(self): with self.assertRaisesOpError('Argument `scale` must be positive.'): dist = tfd.TwoPieceNormal( From ef2a9cbd8a973ee986edb0ad9213c0d2361260d2 Mon Sep 17 00:00:00 2001 From: axch Date: Wed, 30 Mar 2022 13:58:59 -0700 Subject: [PATCH 063/153] Add `assertAllMeansClose` to `tfp.TestCase` for testing sampling code. When writing a test of the form - draw some samples - compute the empirical mean - assert that it's close to expected it's useful to let the test framework itself compute that mean, because then it can use the before-reduction samples to estimate the test's probability of failure, and recommend how many samples to draw to control that probability. The new `assertAllMeansClose` method on tfp.TestCase does this, and provides diagnostics on request. PiperOrigin-RevId: 438389673 --- .../python/distributions/internal/BUILD | 2 +- .../correlation_matrix_volumes_lib.py | 4 +- .../python/distributions/von_mises_test.py | 6 +- tensorflow_probability/python/internal/BUILD | 18 +- .../internal/empirical_statistical_testing.py | 598 ++++++++++++++++++ .../empirical_statistical_testing_test.py | 81 +++ .../python/internal/test_util.py | 122 +++- .../python/internal/test_util_scipy.py | 69 -- .../substrates/meta/rewrite.py | 5 +- 9 files changed, 822 insertions(+), 83 deletions(-) create mode 100644 tensorflow_probability/python/internal/empirical_statistical_testing.py create mode 100644 tensorflow_probability/python/internal/empirical_statistical_testing_test.py delete mode 100644 tensorflow_probability/python/internal/test_util_scipy.py diff --git a/tensorflow_probability/python/distributions/internal/BUILD b/tensorflow_probability/python/distributions/internal/BUILD index 9cac37813e..00f2820489 100644 --- a/tensorflow_probability/python/distributions/internal/BUILD +++ b/tensorflow_probability/python/distributions/internal/BUILD @@ -74,8 +74,8 @@ py_library( # numpy dep, # tensorflow dep, "//tensorflow_probability/python/distributions:uniform", + "//tensorflow_probability/python/internal:empirical_statistical_testing", "//tensorflow_probability/python/internal:prefer_static", - "//tensorflow_probability/python/internal:test_util_scipy", "//tensorflow_probability/python/math:linalg", ], ) diff --git a/tensorflow_probability/python/distributions/internal/correlation_matrix_volumes_lib.py b/tensorflow_probability/python/distributions/internal/correlation_matrix_volumes_lib.py index 5d343b2b52..bc771b615e 100644 --- a/tensorflow_probability/python/distributions/internal/correlation_matrix_volumes_lib.py +++ b/tensorflow_probability/python/distributions/internal/correlation_matrix_volumes_lib.py @@ -37,8 +37,8 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python.distributions import uniform +from tensorflow_probability.python.internal import empirical_statistical_testing from tensorflow_probability.python.internal import prefer_static -from tensorflow_probability.python.internal import test_util_scipy from tensorflow_probability.python.math.linalg import fill_triangular __all__ = [ @@ -254,7 +254,7 @@ def _clopper_pearson_confidence_interval(samples, error_rate): msg = ("Purportedly Bernoulli distribution had distinct samples" " {}, {}, and {}".format(uniques[0], uniques[1], uniques[2])) raise ValueError(msg) - low_p, high_p = test_util_scipy.binomial_confidence_interval( + low_p, high_p = empirical_statistical_testing.binomial_confidence_interval( successes, n, error_rate) low_interval = low + (high - low) * low_p high_interval = low + (high - low) * high_p diff --git a/tensorflow_probability/python/distributions/von_mises_test.py b/tensorflow_probability/python/distributions/von_mises_test.py index 500923b08e..006fc9f549 100644 --- a/tensorflow_probability/python/distributions/von_mises_test.py +++ b/tensorflow_probability/python/distributions/von_mises_test.py @@ -258,8 +258,7 @@ def testVonMisesVonMisesKL(self): kl_actual = tfd.kl_divergence(d1, d2) x = d1.sample(int(1e5), seed=test_util.test_seed(hardcoded_seed=0)) - kl_sample = tf.reduce_mean( - d1.log_prob(x) - d2.log_prob(x), axis=0) + kl_sample = d1.log_prob(x) - d2.log_prob(x) kl_same = tfd.kl_divergence(d1, d1) [kl_actual_val, kl_sample_val, @@ -269,7 +268,8 @@ def testVonMisesVonMisesKL(self): kl_expected = np.array([[0.15402061, 0.02212654, 0.00282222], [0.15402061, 0.02212654, 0.00671171]]) self.assertAllClose(kl_actual_val, kl_expected) - self.assertAllClose(kl_actual_val, kl_sample_val, atol=0., rtol=1e-1) + self.assertAllMeansClose( + kl_sample_val, kl_actual_val, axis=0, atol=0., rtol=1e-1) self.assertAllClose(kl_same_val, np.zeros((1, 3))) def testVonMisesSampleMoments(self): diff --git a/tensorflow_probability/python/internal/BUILD b/tensorflow_probability/python/internal/BUILD index 9a912a834d..439a903491 100644 --- a/tensorflow_probability/python/internal/BUILD +++ b/tensorflow_probability/python/internal/BUILD @@ -705,6 +705,7 @@ multi_substrate_py_library( # six dep, # tensorflow dep, "//tensorflow_probability/python/bijectors:bijector", + "//tensorflow_probability/python/internal:empirical_statistical_testing", "//tensorflow_probability/python/internal/backend/numpy", "//tensorflow_probability/python/util:seed_stream", ], @@ -724,19 +725,26 @@ multi_substrate_py_test( ], ) -# Not part of test_util to segregate the scipy dependency. Though, -# maybe that segregation is futile, since TF (apparently) depends on -# scipy anyway (through Keras). multi_substrate_py_library( - name = "test_util_scipy", + name = "empirical_statistical_testing", # testonly = 1, # DisableOnExport - srcs = ["test_util_scipy.py"], + srcs = ["empirical_statistical_testing.py"], deps = [ # numpy dep, # scipy dep, ], ) +multi_substrate_py_test( + name = "empirical_statistical_testing_test", + srcs = ["empirical_statistical_testing_test.py"], + deps = [ + ":empirical_statistical_testing", + "//tensorflow_probability", + "//tensorflow_probability/python/internal:test_util", + ], +) + multi_substrate_py_library( name = "test_combinations", # testonly = 1, # DisableOnExport diff --git a/tensorflow_probability/python/internal/empirical_statistical_testing.py b/tensorflow_probability/python/internal/empirical_statistical_testing.py new file mode 100644 index 0000000000..5c0a76d482 --- /dev/null +++ b/tensorflow_probability/python/internal/empirical_statistical_testing.py @@ -0,0 +1,598 @@ +# Copyright 2021 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Utilities for setting tolerances for stochastic TFP tests.""" + +import collections + +import numpy as np +import scipy.optimize as optimize +import scipy.stats as stats + +__all__ = [ + 'binomial_confidence_interval', + 'brief_report', + 'full_report', +] + + +# Confidence interval one particular error rate that is justified by a +# _BootstrapResult. +_BootstrapConfidenceInterval = collections.namedtuple( + '_BootstrapConfidenceInterval', + ['low_p', 'high_p']) + + +class _BootstrapResult(collections.namedtuple( + '_BootstrapResult', + ['failures', 'trials'])): + """Result of bootstrapping test success or failure.""" + __slots__ = () + + def for_error_rate(self, error_rate): + """Confidence interval at the given `error_rate` on the true p(fail).""" + low_p, high_p = binomial_confidence_interval( + self.failures, self.trials, error_rate) + return _BootstrapConfidenceInterval(low_p, high_p) + + +# Suggested new test parameters to achieve a desired p(fail) for the +# test, assuming Gaussianity. +_GaussianOneErrorRateResult = collections.namedtuple( + '_GaussianOneErrorRateResult', + ['new_atol', + 'new_rtol', + 'out_of_bounds', + 'too_tight', + 'too_broad', + 'samples_factor',]) + + +class _GaussianResult(collections.namedtuple( + '_GaussianResult', + ['loc', + 'scale', + 'k_s_limit', + 'too_low_p', + 'too_high_p', + 'expected', + 'lb', + 'ub',])): + """Result of fitting a Gaussian for mean(empirical distribution).""" + __slots__ = () + + def for_error_rate(self, error_rate): + """Specific recommendations to achieve the given `error_rate`.""" + dist = stats.norm(loc=self.loc, scale=self.scale) + # Predict a reasonable tolerance + if self.too_high_p > self.too_low_p: + # Assume the upper limit is binding + new_ub = dist.isf(error_rate / 2.0) + new_atol = new_ub - self.expected + else: + # Assume the lower limit is binding + new_lb = dist.ppf(error_rate / 2.0) + new_atol = self.expected - new_lb + new_rtol = new_atol / np.abs(self.expected) + + # Predict a reasonable number of samples + if self.loc >= self.ub or self.loc <= self.lb: + # No increase in the sample size will make this pass, unless it + # also shifts the mean, which we cannot predict. + return _GaussianOneErrorRateResult( + new_atol, new_rtol, out_of_bounds=True, + too_tight=False, too_broad=False, samples_factor=None) + else: + # Given that loc is in bounds, this function is monotonically + # increasing in the scale factor (because the too_low_p and + # too_high_p terms are individually increasing toward 0.5). + def error_rate_good(scale_factor): + dist = stats.norm(loc=self.loc, scale=self.scale * scale_factor) + too_low_p = dist.cdf(self.lb) + too_high_p = dist.sf(self.ub) + return too_low_p + too_high_p - error_rate + if error_rate_good(1000.) < 0.: + # Even a million times fewer samples do not risk exiting the tolerances. + return _GaussianOneErrorRateResult( + new_atol, new_rtol, out_of_bounds=False, + too_tight=True, too_broad=False, samples_factor=None) + elif error_rate_good(0.001) > 0.: + # Even a huge number of samples predicts a bad error rate. + return _GaussianOneErrorRateResult( + new_atol, new_rtol, out_of_bounds=False, + too_tight=False, too_broad=True, samples_factor=None) + else: + scale_factor = optimize.brentq(error_rate_good, 0.001, 1000., rtol=1e-9) + return _GaussianOneErrorRateResult( + new_atol, new_rtol, out_of_bounds=False, + too_tight=False, too_broad=False, + samples_factor=scale_factor ** -2.) + + +# All results for one batch member, suitable for rendering. +_Result = collections.namedtuple( + '_Result', + ['batch_indices', + 'reduction_size', + 'expected', + 'tolerance', + 'bootstrap', + 'gaussian',]) + + +# TODO(cgs): Test this independently of its use in +# distributions/internal/correlation_matrix_volumes_lib +def binomial_confidence_interval(successes, trials, error_rate): + """Computes a confidence interval on the true p of a binomial. + + Assumes: + - The given `successes` count outcomes of an iid Bernoulli trial + with unknown probability p, that was repeated `trials` times. + + Guarantees: + - The probability (over the randomness of drawing the given sample) + that the true p is outside the returned interval is no more than + the given `error_rate`. + + Args: + successes: Python or numpy `int` number of successes. + trials: Python or numpy `int` number of trials. + error_rate: Python `float` admissible rate of mistakes. + + Returns: + low_p: Lower bound of confidence interval. + high_p: Upper bound of confidence interval. + + Raises: + ValueError: If scipy is not available. + + """ + def p_small_enough(p): + # This is positive iff p is smaller than the desired upper bound. + log_prob = stats.binom.logcdf(successes, trials, p) + return log_prob - np.log(error_rate / 2.) + def p_big_enough(p): + # This is positive iff p is larger than the desired lower bound. + # Scipy's survival function for discrete random variables excludes + # the argument, but I want it included for this purpose. + log_prob = stats.binom.logsf(successes-1, trials, p) + return log_prob - np.log(error_rate / 2.) + if successes < trials: + high_p = optimize.brentq( + p_small_enough, successes / float(trials), 1., rtol=1e-9) + else: + high_p = 1. + if successes > 0: + low_p = optimize.brentq( + p_big_enough, 0., successes / float(trials), rtol=1e-9) + else: + low_p = 0. + return low_p, high_p + + +def _choose_num_bootstraps(sample_size, mean_size, fuel): + """Choose how many bootstraps to do. + + The fuel is the total number floats we get to draw from + `np.random.choice`, which is a proxy for the amount of time we're + allowed to spend bootstrapping. We choose how many bootstraps to + do to make sure we fit in our budget. + + Args: + sample_size: Size of sample we are bootstrapping from. + mean_size: Number of samples reduced to form each mean estimate. + fuel: Total number of floats chosen in the bootstrap, as a proxy + for total work spent bootstrapping. + + Returns: + num_bootstraps: Number of bootstraps to do. + """ + # We ignore the sample size here because the asymptotics of + # np.random.choice should be O(n log n + k) where n is the input + # size and k is the output size, and the fuel limit is only binding + # in the regime where k >> n. + num_bootstraps = int(fuel / mean_size) + # However, we always have at least as many bootstraps as we've + # already drawn samples, because in that limit we can just slice the + # existing array. + if num_bootstraps * mean_size <= sample_size: + num_bootstraps = int(sample_size / mean_size) + return num_bootstraps + + +def _bootstrap_means(samples, mean_size, fuel): + """Compute bootstrapped means.""" + num_bootstraps = _choose_num_bootstraps(len(samples), mean_size, fuel) + if num_bootstraps * mean_size <= len(samples): + # Inputs are huge relative to fuel; fake a bootstrap by just slicing + # the input array + return np.mean(np.reshape(samples, newshape=(-1, mean_size)), axis=-1) + # Compute this in batches to never materialize an over-large + # intermediate array. + n_batches = 10 + if n_batches > num_bootstraps: + n_batches = num_bootstraps + batches = [] + for _ in range(n_batches): + batch_size = int(num_bootstraps / n_batches) + batch = np.mean( + np.random.choice(samples, size=(batch_size, mean_size), replace=True), + axis=-1) + batches.append(batch) + return np.concatenate(batches, axis=0) + + +def _evaluate_bootstrap(means, lb, ub): + in_bounds = (means > lb) & (means < ub) + trials = len(in_bounds) + successes = np.count_nonzero(in_bounds) + failures = trials - successes + return _BootstrapResult(failures, trials) + + +def _fit_gaussian(samples, mean_size): + """Fit a Gaussian to represent the mean of `mean_size` of the `samples`.""" + loc = np.mean(samples) + scale_one = np.sqrt(np.mean((samples - loc)**2)) + scale = scale_one / np.sqrt(mean_size) + rho = np.mean(np.abs(samples - loc) ** 3) + # Upper bound from Wikipedia + # https://en.wikipedia.org/wiki/Berry%E2%80%93Esseen_theorem + berry_esseen_c = 0.4748 + # From the Berry-Esseen theorem + k_s_limit = berry_esseen_c * rho / (np.sqrt(mean_size) * (scale_one ** 3)) + return loc, scale, k_s_limit + + +def _evaluate_assuming_gaussian(loc, scale, k_s_limit, expected, lb, ub): + dist = stats.norm(loc=loc, scale=scale) + too_low_p = dist.cdf(lb) + too_high_p = dist.sf(ub) + return _GaussianResult(loc, scale, k_s_limit, too_low_p, too_high_p, + expected, lb, ub) + + +def _evaluate_one_batch_member(to_reduce, expected, reduction_size, tolerance): + """As `_evaluate_means_assertion` but for one batch member.""" + lb = expected - tolerance + ub = expected + tolerance + + # This is our budget of draws from np.random.choice. Chosen to + # avoid the bootstraps being much more expensive than the code under + # test. + fuel = 30000000 + bootstrapped_means = _bootstrap_means(to_reduce, reduction_size, fuel) + bootstrap_result = _evaluate_bootstrap(bootstrapped_means, lb, ub) + loc, scale, k_s_limit = _fit_gaussian(to_reduce, reduction_size) + gauss_result = _evaluate_assuming_gaussian( + loc, scale, k_s_limit, expected, lb, ub) + return bootstrap_result, gauss_result + + +def _evaluate_means_assertion(to_reduce, expected, axis, atol, rtol): + """Evaluates `assertAllMeansClose` assertion quality. + + The results of the evaluation are packed into a list of `_Result` + objects (one per batch member), which can then be post-processed for + presentation depending on the medium. + + Args: + to_reduce: Numpy array of samples, presumed IID along `axis`. + Other dimensions are taken to be batch dimensions. + expected: Numpy array of expected mean values. Must broadcast + with the reduction of `to_reduce` along `axis`. + axis: Python `int` giving the reduction axis. + atol: Python `float`, absolute tolerance for the means. + rtol: Python `float`, relative tolerance for the means. + + Returns: + results: A Python list of `_Result` objects, one for each batch member. + """ + assert isinstance(axis, int), 'TODO(cgs): Handle multiple reduction axes' + + # Normalize so we correctly handle negative axes below. + axis = axis if axis >= 0 else axis + len(to_reduce.shape) + + # Compute reduction size + reduction_size = to_reduce.shape[axis] + + # Pull the axis to be reduced to the front, so we can iterate over + # the others + permutation = np.concatenate([ + [axis], + np.arange(0, axis, dtype=np.int32), + np.arange(axis + 1, len(to_reduce.shape), dtype=np.int32), + ], axis=0) + to_reduce = np.transpose(to_reduce, permutation) + + # Broadcast everything. The subtlety is that we protect the top + # axis of to_reduce, because that's now the reduction axis. For + # that we need to broadcast underneath it. + batch_example = np.zeros(to_reduce.shape[1:], dtype=to_reduce.dtype) + for array in [expected, atol, rtol]: + batch_example = batch_example + np.zeros_like( + array, dtype=batch_example.dtype) + # Rank-expand to_reduce, in case the batch had more dimensions. + # Doing this explicitly to keep the reduction axis on top and to + # avoid broadcasting it. + while len(to_reduce.shape) <= len(batch_example.shape): + to_reduce = to_reduce[:, np.newaxis, ...] + + to_reduce = to_reduce + batch_example + expected = expected + batch_example + atol = atol + batch_example + rtol = rtol + batch_example + + # Iterate over batch members + results = [] + for indices in np.ndindex(to_reduce.shape[1:]): + sub_to_reduce = to_reduce + sub_expected = expected + sub_atol = atol + sub_rtol = rtol + + for index in indices: + sub_to_reduce = sub_to_reduce[:, index, ...] + sub_expected = sub_expected[index, ...] + sub_atol = sub_atol[index, ...] + sub_rtol = sub_rtol[index, ...] + + tolerance = sub_atol + sub_rtol * np.abs(sub_expected) + bootstrap, gaussian = _evaluate_one_batch_member( + sub_to_reduce, sub_expected, reduction_size, tolerance) + results.append(_Result( + indices, reduction_size, sub_expected, tolerance, bootstrap, gaussian)) + + return results + + +def _format_bootstrap_report(result): + """Formats a `_BootstrapResult` as a complete report str. + + The information presented includes: + - The results of a bootstrap to test how often the test fails + - A confidence interval on the probability of the + `assertAllMeansClose` failing, assuming the empirical distribution + is close to the true distribution + + This differs conceptually from the `_gaussian_report` because it + doesn't assume that the distribution on means Gaussianizes, so + remains valid in a low-sample setting. On the other hand, when + trustworthy, `_gaussian_report` is more informative. + + Args: + result: A `_BootstrapResult` capturing the fit. + + Returns: + report: A Python `str` suitable for being printed or added to an + assertion message. + + """ + report = ( + f'\n{result.failures} of {result.trials} bootstrapped trials fail.' + '\nAssuming that the empirical distribution is the true distribution:') + for rate in [1e-3, 1e-9]: + one_rate = result.for_error_rate(rate) + report += ( + f'\n- With confidence 1 - {rate}, p(fail) >= {one_rate.low_p:.3g}.' + f'\n- With confidence 1 - {rate}, p(fail) <= {one_rate.high_p:.3g}.') + return report + + +def _format_gaussian_report(result): + """Formats a `_GaussianResult` as a complete report str. + + The information presented includes: + - The parameters of the Gaussian fit + - The extrapolated probability of the `assertAllMeansClose` failing, + assuming the distribution of means is Gaussian + - Suggested changes to the tolerance and, if possible, number of + samples that should bring the failure rate to a desired point + + Args: + result: A `_GaussianResult` capturing the fit. + + Returns: + report: A Python `str` suitable for being printed or added to an + assertion message. + """ + report = '\nAssuming also that the true distribution on means is Gaussian:' + report += f'\n- Mean ~ N(loc={result.loc:.3g}, scale={result.scale:.3g}).' + p_fail = result.too_low_p + result.too_high_p + report += f'\n- p(fail) = {p_fail:.3g}.' + for error_rate in [1e-3, 1e-9]: + one_rate = result.for_error_rate(error_rate) + if p_fail > error_rate: + report += f'\n- To lower to {error_rate}, try ' + else: + report += f'\n- To raise to {error_rate}, try ' + report += f'atol {one_rate.new_atol:.3g} or rtol {one_rate.new_rtol:.3g}' + + if one_rate.out_of_bounds: + # No increase in the sample size will make this pass, unless it + # also shifts the mean, which we cannot predict. + report += '.' + else: + if one_rate.too_tight: + # Even a million times fewer samples do not risk exiting the tolerances. + report += '; the Gaussian is too tight on the scale of the tolerances.' + elif one_rate.too_broad: + # Even a huge number of samples predicts a bad error rate. + report += '; the Gaussian is too broad on the scale of the tolerances.' + else: + report += ( + f', or {one_rate.samples_factor:.3g} times the samples.') + return report + + +def _format_full_report(results): + """Formats the given list of `_Result`s as a complete report str. + + This version is more prolix than `_format_brief_report`, but does not + suppress any information, and does not suffer from any statistical + bias. + + Args: + results: A list of `_Result` for a batch `assertAllMeansClose` + evaluation. + + Returns: + report: A Python `str` suitable for being printed or added to an + assertion message. + """ + report = '' + for result in results: + report += f'\n\nAt index {result.batch_indices}' + report += f'\nExpected mean({result.reduction_size} draws)' + report += f' in {result.expected:.3g} +- {result.tolerance:.3g};' + report += _format_bootstrap_report(result.bootstrap) + report += _format_gaussian_report(result.gaussian) + + return report + + +def _format_brief_report_one(result): + """Formats the given `Result` as a condensed report str.""" + report = f'\nExpected mean({result.reduction_size} draws)' + report += f' in {result.expected:.3g} +- {result.tolerance:.3g};' + report += f' got mean ~ N(loc={result.gaussian.loc:.3g}, scale={result.gaussian.scale:.3g}),' + p_fail = result.gaussian.too_low_p + result.gaussian.too_high_p + report += f' p(fail) = {p_fail:.3g}.' + for target_rate in [0.001, 1e-9]: + for_rate = result.gaussian.for_error_rate(target_rate) + if p_fail > target_rate: + report += f'\nTo lower to {target_rate},' + else: + report += f'\nTo raise to {target_rate},' + report += f' try atol {for_rate.new_atol:.3g} or rtol {for_rate.new_rtol:.3g}' + if for_rate.out_of_bounds or for_rate.too_tight or for_rate.too_broad: + report += '.' + else: + report += f', or {for_rate.samples_factor:.3g} times the samples.' + return report + + +def _format_brief_report(results): + """Formats the gives list of `_Result`s as a condensed report str. + + Part of the condensing is that `brief_report` only describes the + most likely to fail batch member. This introduces some statistical + skew: the samples being bootstrapped from are not for the true + distribution of the batch member under test, but from the + distribution conditioned on that batch member having turned to be + the worst in the batch. This may grow problematic for a large batch + of `assertAllMeansClose`, where multiple members have a + non-negligible true probability of failure. If that source of error + is not worth the brevity, there's always `full_report`. + + Args: + results: A list of `_Result` for a batch `assertAllMeansClose` + evaluation. + + Returns: + report: A Python `str` suitable for being printed or added to an + assertion message. + """ + worst = results[0] + report = '' + if len(results) > 1: + for result in results: + p_fail = result.gaussian.too_low_p + result.gaussian.too_high_p + if p_fail > worst.gaussian.too_low_p + worst.gaussian.too_high_p: + worst = result + report += f'At index {worst.batch_indices}' + return report + _format_brief_report_one(worst) + + +def brief_report(to_reduce, expected, axis, atol, rtol): + """Evaluates `assertAllMeansClose` assertion quality and reports briefly. + + Specifically, uses a Gaussian approximation to estimate + - The probability of the assertion failing + - How to change the parameters to control the failure probability + + The evaluation assumes that the elements of `to_reduce` are IID + along the given `axis`, and that the empirical distribution they + represent is a good approximation of the true one-element + distribution. The analysis also assumes that the reduction axis is + large enough that the distribution on the computed mean is well + approximated as a Gaussian. + + The brief report only describes the most likely to fail batch + member. This introduces some statistical skew: the samples being + bootstrapped from are not for the true distribution of the batch + member under test, but from the distribution conditioned on that + batch member having turned to be the worst in the batch. This may + grow problematic for a large batch of `assertAllMeansClose`, where + multiple members have a non-negligible true probability of failure. + If that source of error is not worth the brevity, there's always + `full_report`. + + Args: + to_reduce: Numpy array of samples, presumed IID along `axis`. + Other dimensions are taken to be batch dimensions. + expected: Numpy array of expected mean values. Must broadcast + with the reduction of `to_reduce` along `axis`. + axis: Python `int` giving the reduction axis. + atol: Python `float`, absolute tolerance for the means. + rtol: Python `float`, relative tolerance for the means. + + Returns: + report: A Python `str` suitable for being printed or added to an + assertion message. + """ + result = _evaluate_means_assertion(to_reduce, expected, axis, atol, rtol) + return _format_brief_report(result) + + +def full_report(to_reduce, expected, axis, atol, rtol): + """Evaluates `assertAllMeansClose` assertion quality and reports. + + This version is more prolix than `brief_report`, but does not + suppress any information, and does not suffer from any statistical + bias. + + Specifically, uses both a bootstrap and a Gaussian approximation to + estimate + - The probability of the assertion failing + - How to change the parameters to control the failure probability + + The difference between the bootstrap and the Gaussian is that the + bootstrap does not assume the distribution on means Gaussianizes, so + remains more trustworthy in low-sample settings. + + The evaluation assumes that the elements of `to_reduce` are IID + along the given `axis`, and that the empirical distribution they + represent is a good approximation of the true one-element + distribution. The Gaussian analysis also assumes that the reduction + axis is large enough that the distribution on the computed mean is + well approximated as a Gaussian. + + The full report describes all members of a batch. + + Args: + to_reduce: Numpy array of samples, presumed IID along `axis`. + Other dimensions are taken to be batch dimensions. + expected: Numpy array of expected mean values. Must broadcast + with the reduction of `to_reduce` along `axis`. + axis: Python `int` giving the reduction axis. + atol: Python `float`, absolute tolerance for the means. + rtol: Python `float`, relative tolerance for the means. + + Returns: + report: A Python `str` suitable for being printed or added to an + assertion message. + """ + result = _evaluate_means_assertion(to_reduce, expected, axis, atol, rtol) + return _format_full_report(result) diff --git a/tensorflow_probability/python/internal/empirical_statistical_testing_test.py b/tensorflow_probability/python/internal/empirical_statistical_testing_test.py new file mode 100644 index 0000000000..9418a7b966 --- /dev/null +++ b/tensorflow_probability/python/internal/empirical_statistical_testing_test.py @@ -0,0 +1,81 @@ +# Copyright 2022 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Tests for tensorflow_probability.python.internal.empirical_statistical_testing.""" + +import tensorflow_probability as tfp + +from tensorflow_probability.python.internal import empirical_statistical_testing as emp +from tensorflow_probability.python.internal import test_util + +tfd = tfp.distributions + + +class EmpiricalStatisticalTestingTest(test_util.TestCase): + + def test_ok(self): + # True mean is 0, true stddev is 0.001 + samples = tfd.Normal(0., 1.).sample(1000000, seed=test_util.test_seed()) + # TODO(axch): Add seeds for the randomness inside the bootstrap this does. + results = emp._evaluate_means_assertion( + self.evaluate(samples), expected=0, axis=0, atol=0.003, rtol=1e-6) + self.assertEqual(len(results), 1) # One batch member + result = results[0] + self.assertIsInstance(result, emp._Result) + + # True failure probability should be 0.0027, which is the + # two-sided 3-sigma failure rate. + # Test that the 1e-9 confidence interval contains it. + self.assertLess(result.bootstrap.for_error_rate(1e-9).low_p, 0.0027) + self.assertGreater(result.bootstrap.for_error_rate(1e-9).high_p, 0.0027) + + # If I want a (two-sided) failure rate that's more like 5.6e-7, I + # should go to 5 sigma. + suggestion = result.gaussian.for_error_rate(5.6e-7) + self.assertFalse(suggestion.out_of_bounds) + self.assertFalse(suggestion.too_tight) + self.assertFalse(suggestion.too_broad) + # However, randomness in the original sample makes the suggestion imprecise. + self.assertAllClose(suggestion.new_atol, 0.005, rtol=0.3) + + # The report computation functions don't crash + self.assertIsInstance(emp._format_brief_report(results), str) + self.assertIsInstance(emp._format_full_report(results), str) + + def test_out_of_bounds(self): + samples = tfd.Normal(10., 0.1).sample(10000, seed=test_util.test_seed()) + results = emp._evaluate_means_assertion( + self.evaluate(samples), expected=0, axis=0, atol=0.003, rtol=1e-6) + result = results[0] + + # The true failure probabiliy should be almost 1 + self.assertGreater(result.bootstrap.for_error_rate(1e-9).low_p, 0.9) + + # Fixing the test by moving the tolerance should be fairly extreme + suggestion = result.gaussian.for_error_rate(5.6e-7) + self.assertGreater(suggestion.new_atol, 9.) + + # It shouldn't be possible to fix this by increasing the number of + # samples, because the empirical mean is out of bounds + self.assertTrue(suggestion.out_of_bounds) + + def test_batch(self): + samples = tfd.Normal(0., 0.1).sample(100, seed=test_util.test_seed()) + results = emp._evaluate_means_assertion( + self.evaluate(samples), expected=[[0], [1], [2]], axis=0, + atol=[0.003, 0.004, 0.005], rtol=1e-6) + self.assertEqual(len(results), 9) + +if __name__ == '__main__': + test_util.main() diff --git a/tensorflow_probability/python/internal/test_util.py b/tensorflow_probability/python/internal/test_util.py index 66eac99316..6e54d97895 100644 --- a/tensorflow_probability/python/internal/test_util.py +++ b/tensorflow_probability/python/internal/test_util.py @@ -31,6 +31,7 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python.bijectors import bijector from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import empirical_statistical_testing from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_combinations from tensorflow_probability.python.internal.backend.numpy import ops @@ -78,11 +79,17 @@ flags.DEFINE_string('fixed_seed', None, ('PRNG seed to initialize every test with. ' - 'Takes precedence over --vary-seed when both appear.'), + 'Takes precedence over --vary_seed when both appear.'), allow_override=True, allow_override_cpp=False, allow_hide_cpp=True) +flags.DEFINE_enum('analyze_calibration', 'none', + ['none', 'brief', 'full'], + ('If set, auto-fails assertAllMeansClose and prints ' + 'a report of how failure-prone the test is.'), + allow_override=True) + FLAGS = flags.FLAGS @@ -338,6 +345,119 @@ def assertAllIs(self, a, b): .format([i for i, x in enumerate(each_is) if not x])) raise AssertionError(msg) + def assertAllMeansClose( + self, to_reduce, expected, axis, atol=1e-6, rtol=1e-6, msg=None): + """Assert means of `to_reduce` along `axis` as `expected`, with diagnostics. + + Operationally, this is equivalent to + + ``` + means = tf.reduce_mean(to_reduce, axis) + assertAllClose(means, expected, atol, rtol, msg) + ``` + + except that by intercepting samples before the reduction is + carried out, `assertAllMeansClose` can diagnose the statistical + significance of failures. + + Specifically, `to_reduce` is assumed to be sampled IID along + `axis`. Based on this, it's possible to estimate the probability + of `assertAllMeansClose` failing as the upstream PRNG seed is + varied, and suggest parameter changes to control that probability. + To assess a particular test statistically, run it with + + ``` + --test_arg=--vary_seed --test_arg=--analyze_calibration=brief + ``` + + or + + ``` + --test_arg=--vary_seed --test_arg=--analyze_calibration=full + ``` + + To avoid bias in the reported diagnostics, either value of + `--analyze_calibration` force-fails the assertion; diagnostics are + reported independently of whether the current sample's mean is + close to `expected` or not. + + Caveats: + + - `--vary_seed` is important to prevent bias: if + `--analyze_calibration` is not passed, `assertAllMeansClose` + only fails if the mean of `to_reduce` is far from `expected`. A + seed that is brought to your attention by this happening is by + construction unlucky, and diagnostics reported from it (e.g., by + passing `--analyze_calibration` but not `--vary_seed`) will be + overly pessimistic. + + - The report produced by `assertAllMeansClose` only assesses + significance; i.e., assuming the test and the code under test + are correct, how should the parameters of the test be set to + control accidental failures. Sometimes, a bug will manifest as + absurd suggestions for making the test pass---it's up to the + user to notice this happening. + + - The report makes assumptions it does not test: + + - that the elements of `to_reduce` actually are IID along `axis`; + + - that there are enough of them that the empirical distribution + observed by one call to `assertAllMeansClose` is a good + approximation to the true generating distribution; and + + - in the case of the Gaussian extrapolation, that there are + enough samples that the distribution on means is approximately + Gaussian. + + - The suggestions in the report are extrapolations based on a + random sample. They may vary across runs and are not guaranteed + to be accurate. In particular, if increasing the number of + samples a test draws, it's reasonable to rerun the diagnostics, + because they now have more information to work with. + + Args: + to_reduce: Tensor of samples, presumed IID along `axis`. + Other dimensions are taken to be batch dimensions. + expected: Tensor of expected mean values. Must broadcast + with the reduction of `to_reduce` along `axis`. + axis: Python `int` giving the reduction axis. + atol: Tensor of absolute tolerances for the means. Must + broadcast with the reduction of `to_reduce` along `axis`. + rtol: Tensor of relative tolerances for the means. Must + broadcast with the reduction of `to_reduce` along `axis`. + msg: Optional string to insert into the failure message, + if any. + + """ + mean = tf.reduce_mean(to_reduce, axis=axis) + if FLAGS.analyze_calibration == 'none': + msg = (msg or '') + '\nTo assess statistically, run with' + msg += '\n --test_arg=--vary_seed --test_arg=--analyze_calibration=brief' + msg += '\nor' + msg += '\n --test_arg=--vary_seed --test_arg=--analyze_calibration=full' + self.assertAllClose(mean, expected, atol=atol, rtol=rtol, msg=msg) + else: + to_reduce = self._GetNdArray(to_reduce) + expected = self._GetNdArray(expected) + if msg is None: + msg = '' + else: + msg += '\n' + if FLAGS.analyze_calibration == 'brief': + msg += empirical_statistical_testing.brief_report( + to_reduce, expected, axis, atol, rtol) + msg += ('\nFor more information, run with ' + '--test_arg=--analyze_calibration=full.') + else: + msg += empirical_statistical_testing.full_report( + to_reduce, expected, axis, atol, rtol) + if not FLAGS.vary_seed and FLAGS.fixed_seed is None: + msg += '\nWARNING: Above report may be biased as --vary_seed=' + msg += 'False and --fixed_seed is not set. ' + msg += 'See docstring of `assertAllMeansClose`.' + raise AssertionError(msg) + def evaluate_dict(self, dictionary): """Invokes `self.evaluate` on the `Tensor`s in `dictionary`. diff --git a/tensorflow_probability/python/internal/test_util_scipy.py b/tensorflow_probability/python/internal/test_util_scipy.py deleted file mode 100644 index 87036653f5..0000000000 --- a/tensorflow_probability/python/internal/test_util_scipy.py +++ /dev/null @@ -1,69 +0,0 @@ -# Copyright 2021 The TensorFlow Probability Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# ============================================================================ -"""Utilities for testing TFP code that depend on scipy.""" - -import numpy as np -import scipy.optimize as optimize -import scipy.stats as stats - -__all__ = [ - 'binomial_confidence_interval', -] - - -# TODO(axch): Test this independently of its use in -# distributions/internal/correlation_matrix_volumes_lib -def binomial_confidence_interval(successes, trials, error_rate): - """Computes a confidence interval on the true p of a binomial. - - Assumes: - - The given `successes` count outcomes of an iid Bernoulli trial - with unknown probability p, that was repeated `trials` times. - - Guarantees: - - The probability (over the randomness of drawing the given sample) - that the true p is outside the returned interval is no more than - the given `error_rate`. - - Args: - successes: Python or numpy `int` number of successes. - trials: Python or numpy `int` number of trials. - error_rate: Python `float` admissible rate of mistakes. - - Returns: - low_p: Lower bound of confidence interval. - high_p: Upper bound of confidence interval. - - Raises: - ValueError: If scipy is not available. - - """ - def p_small_enough(p): - log_prob = stats.binom.logcdf(successes, trials, p) - return log_prob - np.log(error_rate / 2.) - def p_big_enough(p): - log_prob = stats.binom.logsf(successes, trials, p) - return log_prob - np.log(error_rate / 2.) - if successes < trials: - high_p = optimize.brentq( - p_small_enough, successes / float(trials), 1., rtol=1e-9) - else: - high_p = 1. - if successes > 0: - low_p = optimize.brentq( - p_big_enough, 0., successes / float(trials), rtol=1e-9) - else: - low_p = 0. - return low_p, high_p diff --git a/tensorflow_probability/substrates/meta/rewrite.py b/tensorflow_probability/substrates/meta/rewrite.py index 4771cb4c6f..e71a75bf4e 100644 --- a/tensorflow_probability/substrates/meta/rewrite.py +++ b/tensorflow_probability/substrates/meta/rewrite.py @@ -100,8 +100,9 @@ 'batched_rejection_sampler', 'batch_shape_lib', 'broadcast_util', 'cache_util', 'callable_util', 'custom_gradient', 'distribution_util', - 'distribute_lib', 'distribute_test_lib', - 'dtype_util', 'hypothesis_testlib', 'implementation_selection', + 'distribute_lib', 'distribute_test_lib', 'dtype_util', + 'empirical_statistical_testing', + 'hypothesis_testlib', 'implementation_selection', 'loop_util', 'monte_carlo', 'name_util', 'nest_util', 'numerics_testing', 'parameter_properties', 'prefer_static', 'samplers', 'slicing', 'special_math', 'structural_tuple', From f07b8045df069025d23cdbf44bad3261cb3b1a2c Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Wed, 30 Mar 2022 23:03:11 -0300 Subject: [PATCH 064/153] Add dependency --- tensorflow_probability/python/distributions/BUILD | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index ebfa3bd3f3..b4fc987fa4 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -3956,6 +3956,7 @@ multi_substrate_py_test( # numpy dep, # tensorflow dep, "//tensorflow_probability", + "//tensorflow_probability/python/internal:prefer_static", "//tensorflow_probability/python/internal:test_util", ], ) From bb53a2f80169e5a8b5d4a5019bc172d7f72c29d3 Mon Sep 17 00:00:00 2001 From: jburnim Date: Thu, 31 Mar 2022 08:57:48 -0700 Subject: [PATCH 065/153] Update TFP to depend on TF 2.9. Parts of TFP now rely on post-2.8 changes in TensorFlow. PiperOrigin-RevId: 438579715 --- tensorflow_probability/python/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/__init__.py b/tensorflow_probability/python/__init__.py index a3d47aa56a..ca138f7cc5 100644 --- a/tensorflow_probability/python/__init__.py +++ b/tensorflow_probability/python/__init__.py @@ -51,7 +51,7 @@ def _validate_tf_environment(package): # # Update this whenever we need to depend on a newer TensorFlow release. # - required_tensorflow_version = '2.8' + required_tensorflow_version = '2.9' # required_tensorflow_version = '1.15' # Needed internally -- DisableOnExport if (distutils.version.LooseVersion(tf.__version__) < From 51e3b9f52402c51018176ee8cef6c8fcc1cb3ec3 Mon Sep 17 00:00:00 2001 From: axch Date: Fri, 1 Apr 2022 11:23:24 -0700 Subject: [PATCH 066/153] Use assertAllMeansClose(samples) instead of assertAllClose(reduce_mean(samples)) for IID samples. Affected tests still pass. Grovelling the logs from a full run indicates that we have 88 individual assertions for which the sample given by the handcoded test seed implies a > 10% probability of chance failure, with an observed maxiumum of 46%. Presumably the test for which that maximum was observed (stopping_ratio_logistic_test) is one for which the default test seed is unlucky, but still. PiperOrigin-RevId: 438868730 --- .../bijectors/masked_autoregressive_test.py | 2 +- .../python/distributions/cauchy_test.py | 9 +-- .../python/distributions/chi2_test.py | 8 +-- .../python/distributions/chi_test.py | 8 +-- .../dirichlet_multinomial_test.py | 18 +++--- .../python/distributions/dirichlet_test.py | 7 ++- .../python/distributions/exp_gamma_test.py | 17 ++--- .../python/distributions/exponential_test.py | 6 +- .../python/distributions/gamma_test.py | 17 ++--- .../python/distributions/half_normal_test.py | 8 +-- .../python/distributions/independent_test.py | 16 ++--- .../python/distributions/laplace_test.py | 8 +-- .../python/distributions/lkj_test.py | 7 ++- .../python/distributions/logitnormal_test.py | 29 ++++----- .../python/distributions/lognormal_test.py | 8 +-- .../python/distributions/moyal_test.py | 6 +- .../python/distributions/multinomial_test.py | 18 +++--- .../mvn_diag_plus_low_rank_covariance_test.py | 8 +-- ..._update_linear_operator_covariance_test.py | 8 ++- .../python/distributions/normal_test.py | 7 ++- .../distributions/onehot_categorical_test.py | 22 +++---- .../distributions/ordered_logistic_test.py | 9 ++- .../python/distributions/pareto_test.py | 8 +-- .../python/distributions/poisson_test.py | 15 +++-- .../distributions/power_spherical_test.py | 20 +++--- .../distributions/spherical_uniform_test.py | 13 ++-- .../stopping_ratio_logistic_test.py | 5 +- .../transformed_distribution_test.py | 13 ++-- .../python/distributions/uniform_test.py | 8 +-- .../distributions/von_mises_fisher_test.py | 25 ++++---- .../python/distributions/von_mises_test.py | 22 ++++--- .../python/distributions/weibull_test.py | 16 ++--- .../python/distributions/wishart_test.py | 6 +- .../mvn_precision_factor_linop_test.py | 7 ++- .../mcmc/weighted_resampling_test.py | 63 ++++++++++--------- .../sts_gibbs/gibbs_sampler_test.py | 6 ++ .../python/layers/distribution_layer_test.py | 6 +- .../python/random/random_ops_test.py | 7 +-- 38 files changed, 254 insertions(+), 232 deletions(-) diff --git a/tensorflow_probability/python/bijectors/masked_autoregressive_test.py b/tensorflow_probability/python/bijectors/masked_autoregressive_test.py index dab7b6a138..bdb6a1f5ca 100644 --- a/tensorflow_probability/python/bijectors/masked_autoregressive_test.py +++ b/tensorflow_probability/python/bijectors/masked_autoregressive_test.py @@ -781,7 +781,7 @@ def test_doc_string_2(self): bijector_kwargs={"conditional_input": cond * np.ones((n_samples, 1))}, seed=seed()) # Assert mean is close to conditional mean - self.assertAllClose(tf.reduce_mean(samples), mean_1, atol=1.) + self.assertAllMeansClose(samples[..., 0], mean_1, axis=0, atol=1.) def test_doc_string_images_case_1(self): # Generate fake images. diff --git a/tensorflow_probability/python/distributions/cauchy_test.py b/tensorflow_probability/python/distributions/cauchy_test.py index f8f6958cb6..95d8999eab 100644 --- a/tensorflow_probability/python/distributions/cauchy_test.py +++ b/tensorflow_probability/python/distributions/cauchy_test.py @@ -469,14 +469,15 @@ def testCauchyCauchyKLWithMC(self): reverse_kl_val = self.evaluate(reverse_kl) x = c_a.sample(int(1e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(c_a.log_prob(x) - c_b.log_prob(x), axis=0) - kl_sample_val = self.evaluate(kl_sample) + kl_samples = c_a.log_prob(x) - c_b.log_prob(x) + kl_samples_ = self.evaluate(kl_samples) self.assertEqual(kl.shape, (batch_size,)) # The Cauchy KL is symmetric - self.assertAllClose(kl_val, kl_sample_val, atol=0.0, rtol=1e-2) - self.assertAllClose(reverse_kl_val, kl_sample_val, atol=0.0, rtol=1e-2) + self.assertAllMeansClose(kl_samples_, kl_val, axis=0, atol=0.0, rtol=1e-2) + self.assertAllMeansClose( + kl_samples_, reverse_kl_val, axis=0, atol=0.0, rtol=1e-2) if __name__ == '__main__': test_util.main() diff --git a/tensorflow_probability/python/distributions/chi2_test.py b/tensorflow_probability/python/distributions/chi2_test.py index 8941248829..d43a602daa 100644 --- a/tensorflow_probability/python/distributions/chi2_test.py +++ b/tensorflow_probability/python/distributions/chi2_test.py @@ -124,11 +124,11 @@ def testChi2Chi2KL(self): kl = tfd.kl_divergence(a, b) x = a.sample(int(1e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) + kl_samples = a.log_prob(x) - b.log_prob(x) - kl_, kl_sample_ = self.evaluate([kl, kl_sample]) - self.assertAllClose(true_kl, kl_, atol=0., rtol=5e-13) - self.assertAllClose(true_kl, kl_sample_, atol=0., rtol=.08) + kl_, kl_samples_ = self.evaluate([kl, kl_samples]) + self.assertAllClose(kl_, true_kl, atol=0., rtol=5e-13) + self.assertAllMeansClose(kl_samples_, true_kl, axis=0, atol=0., rtol=.08) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(zero_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/chi_test.py b/tensorflow_probability/python/distributions/chi_test.py index b2fef4a8a5..dc0f410d4f 100644 --- a/tensorflow_probability/python/distributions/chi_test.py +++ b/tensorflow_probability/python/distributions/chi_test.py @@ -119,11 +119,11 @@ def testChiChiKL(self): x = a.sample( int(8e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) + kl_samples = a.log_prob(x) - b.log_prob(x) - kl_, kl_sample_ = self.evaluate([kl, kl_sample]) - self.assertAllClose(true_kl, kl_, atol=0., rtol=1e-12) - self.assertAllClose(true_kl, kl_sample_, atol=0., rtol=5e-2) + kl_, kl_samples_ = self.evaluate([kl, kl_samples]) + self.assertAllClose(kl_, true_kl, atol=0., rtol=1e-12) + self.assertAllMeansClose(kl_samples_, true_kl, axis=0, atol=0., rtol=5e-2) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(zero_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/dirichlet_multinomial_test.py b/tensorflow_probability/python/distributions/dirichlet_multinomial_test.py index 92bafc1f17..2e6bff7e21 100644 --- a/tensorflow_probability/python/distributions/dirichlet_multinomial_test.py +++ b/tensorflow_probability/python/distributions/dirichlet_multinomial_test.py @@ -209,7 +209,7 @@ def testCovarianceFromSampling(self): sample_var = tf.linalg.diag_part(sample_cov) sample_stddev = tf.sqrt(sample_var) [ - sample_mean_, + x_, sample_cov_, sample_var_, sample_stddev_, @@ -218,7 +218,7 @@ def testCovarianceFromSampling(self): analytic_var, analytic_stddev, ] = self.evaluate([ - sample_mean, + x, sample_cov, sample_var, sample_stddev, @@ -233,7 +233,7 @@ def testCovarianceFromSampling(self): # If the sampled quantities are normally distributed, a 5% failure rate # corresponds to a z-score of about 2; doubling this should give a z-score # of 4, which corresponds to a failure rate of 6.4e-5 - self.assertAllClose(sample_mean_, analytic_mean, rtol=0.1) + self.assertAllMeansClose(x_, analytic_mean, axis=0, rtol=0.1) self.assertAllClose(sample_cov_, analytic_cov, rtol=0.3) self.assertAllClose(sample_var_, analytic_var, rtol=0.2) self.assertAllClose(sample_stddev_, analytic_stddev, rtol=0.1) @@ -408,18 +408,18 @@ def testSampleUnbiasedNonScalarBatch(self): sample_covariance = tf.matmul( x_centered, x_centered, adjoint_b=True) / n [ - sample_mean_, + x_, sample_covariance_, actual_mean_, actual_covariance_, ] = self.evaluate([ - sample_mean, + x, sample_covariance, dist.mean(), dist.covariance(), ]) self.assertAllEqual([4, 3, 2], sample_mean.shape) - self.assertAllClose(actual_mean_, sample_mean_, atol=0., rtol=0.20) + self.assertAllMeansClose(x_, actual_mean_, axis=0, atol=0., rtol=0.20) self.assertAllEqual([4, 3, 2, 2], sample_covariance.shape) self.assertAllClose( actual_covariance_, sample_covariance_, atol=0., rtol=0.20) @@ -439,18 +439,18 @@ def testSampleUnbiasedScalarBatch(self): sample_covariance = tf.linalg.matmul( x_centered, x_centered, adjoint_a=True) / n [ - sample_mean_, + x_, sample_covariance_, actual_mean_, actual_covariance_, ] = self.evaluate([ - sample_mean, + x, sample_covariance, dist.mean(), dist.covariance(), ]) self.assertAllEqual([4], sample_mean.shape) - self.assertAllClose(actual_mean_, sample_mean_, atol=0., rtol=0.25) + self.assertAllMeansClose(x_, actual_mean_, axis=0, atol=0., rtol=0.25) self.assertAllEqual([4, 4], sample_covariance.shape) self.assertAllClose( actual_covariance_, sample_covariance_, atol=0., rtol=0.25) diff --git a/tensorflow_probability/python/distributions/dirichlet_test.py b/tensorflow_probability/python/distributions/dirichlet_test.py index c51636763a..a51746dedc 100644 --- a/tensorflow_probability/python/distributions/dirichlet_test.py +++ b/tensorflow_probability/python/distributions/dirichlet_test.py @@ -261,10 +261,10 @@ def testDirichletDirichletKL(self): d1 = tfd.Dirichlet(conc1) d2 = tfd.Dirichlet(conc2) x = d1.sample(int(1e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(d1.log_prob(x) - d2.log_prob(x), axis=0) + kl_samples = d1.log_prob(x) - d2.log_prob(x) kl_actual = tfd.kl_divergence(d1, d2) - kl_sample_val = self.evaluate(kl_sample) + kl_samples_ = self.evaluate(kl_samples) kl_actual_val = self.evaluate(kl_actual) self.assertEqual(conc1.shape[:-1], kl_actual.shape) @@ -278,7 +278,8 @@ def testDirichletDirichletKL(self): np.sum(conc1, -1, keepdims=True))), -1)) self.assertAllClose(kl_expected, kl_actual_val, atol=0., rtol=1e-5) - self.assertAllClose(kl_sample_val, kl_actual_val, atol=0., rtol=1e-1) + self.assertAllMeansClose( + kl_samples_, kl_actual_val, axis=0, atol=0., rtol=1e-1) # Make sure KL(d1||d1) is 0 kl_same = self.evaluate(tfd.kl_divergence(d1, d1)) diff --git a/tensorflow_probability/python/distributions/exp_gamma_test.py b/tensorflow_probability/python/distributions/exp_gamma_test.py index d4d96b2902..c7a40ff554 100644 --- a/tensorflow_probability/python/distributions/exp_gamma_test.py +++ b/tensorflow_probability/python/distributions/exp_gamma_test.py @@ -448,11 +448,11 @@ def testExpGammaExpGammaKL(self): # Same as Gamma-Gamma KL. for d0, d1 in (g0, g1), (g0lr, g1), (g0, g1lr), (g0lr, g1lr): x = d0.sample(int(1e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(d0.log_prob(x) - d1.log_prob(x), axis=0) + kl_samples = d0.log_prob(x) - d1.log_prob(x) kl_actual = tfd.kl_divergence(d0, d1) # Execute graph. - [kl_sample_, kl_actual_] = self.evaluate([kl_sample, kl_actual]) + [kl_samples_, kl_actual_] = self.evaluate([kl_samples, kl_actual]) self.assertEqual(rate0.shape, kl_actual.shape) @@ -465,7 +465,8 @@ def testExpGammaExpGammaKL(self): # Same as Gamma-Gamma KL. + concentration0 * (rate1 / rate0 - 1.)) self.assertAllClose(kl_expected, kl_actual_, atol=0., rtol=1e-6) - self.assertAllClose(kl_sample_, kl_actual_, atol=0., rtol=1e-1) + self.assertAllMeansClose( + kl_samples_, kl_actual_, axis=0, atol=0., rtol=1e-1) @test_util.tf_tape_safety_test def testGradientThroughConcentration(self): @@ -565,9 +566,10 @@ def testSampleLowConcentration(self): d.cdf, false_fail_rate=1e-9)) - self.assertAllClose( - self.evaluate(tf.math.reduce_mean(samples, axis=0)), + self.assertAllMeansClose( + self.evaluate(samples), d.mean(), + axis=0, rtol=0.03) self.assertAllClose( self.evaluate(tf.math.reduce_variance(samples, axis=0)), @@ -590,9 +592,10 @@ def testSampleHighConcentration(self): self.evaluate( st.assert_true_cdf_equal_by_dkwm(samples, d.cdf, false_fail_rate=1e-9)) - self.assertAllClose( - self.evaluate(tf.math.reduce_mean(samples, axis=0)), + self.assertAllMeansClose( + self.evaluate(samples), d.mean(), + axis=0, rtol=0.01) self.assertAllClose( self.evaluate(tf.math.reduce_variance(samples, axis=0)), diff --git a/tensorflow_probability/python/distributions/exponential_test.py b/tensorflow_probability/python/distributions/exponential_test.py index 3ca2227c49..dde7f8bfd1 100644 --- a/tensorflow_probability/python/distributions/exponential_test.py +++ b/tensorflow_probability/python/distributions/exponential_test.py @@ -166,11 +166,11 @@ def testExponentialExponentialKL(self): kl = tfd.kl_divergence(a, b) x = a.sample(int(4e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) + kl_samples = a.log_prob(x) - b.log_prob(x) - kl_, kl_sample_ = self.evaluate([kl, kl_sample]) + kl_, kl_samples_ = self.evaluate([kl, kl_samples]) self.assertAllClose(true_kl, kl_, atol=0., rtol=1e-12) - self.assertAllClose(true_kl, kl_sample_, atol=0., rtol=8e-2) + self.assertAllMeansClose(kl_samples_, true_kl, axis=0, atol=0., rtol=8e-2) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(zero_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/gamma_test.py b/tensorflow_probability/python/distributions/gamma_test.py index ca373dfe50..573b78f579 100644 --- a/tensorflow_probability/python/distributions/gamma_test.py +++ b/tensorflow_probability/python/distributions/gamma_test.py @@ -534,11 +534,11 @@ def testGammaGammaKL(self): for d0, d1 in (g0, g1), (g0lr, g1), (g0, g1lr), (g0lr, g1lr): x = d0.sample(int(1e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(d0.log_prob(x) - d1.log_prob(x), axis=0) + kl_samples = d0.log_prob(x) - d1.log_prob(x) kl_actual = tfd.kl_divergence(d0, d1) # Execute graph. - [kl_sample_, kl_actual_] = self.evaluate([kl_sample, kl_actual]) + [kl_samples_, kl_actual_] = self.evaluate([kl_samples, kl_actual]) self.assertEqual(rate0.shape, kl_actual.shape) @@ -551,7 +551,8 @@ def testGammaGammaKL(self): + concentration0 * (rate1 / rate0 - 1.)) self.assertAllClose(kl_expected, kl_actual_, atol=0., rtol=1e-6) - self.assertAllClose(kl_sample_, kl_actual_, atol=0., rtol=1e-1) + self.assertAllMeansClose( + kl_samples_, kl_actual_, axis=0, atol=0., rtol=1e-1) @test_util.tf_tape_safety_test def testGradientThroughConcentration(self): @@ -722,9 +723,10 @@ def testSampleGammaLowConcentration(self): gamma.cdf, false_fail_rate=1e-9)) - self.assertAllClose( - self.evaluate(tf.math.reduce_mean(samples, axis=0)), + self.assertAllMeansClose( + self.evaluate(samples), sp_stats.gamma.mean(concentration, scale=1 / rate), + axis=0, rtol=0.04) self.assertAllClose( self.evaluate(tf.math.reduce_variance(samples, axis=0)), @@ -755,9 +757,10 @@ def testSampleGammaHighConcentration(self): gamma.cdf, false_fail_rate=1e-9)) - self.assertAllClose( - self.evaluate(tf.math.reduce_mean(samples, axis=0)), + self.assertAllMeansClose( + self.evaluate(samples), sp_stats.gamma.mean(concentration, scale=1 / rate), + axis=0, rtol=0.01) self.assertAllClose( self.evaluate(tf.math.reduce_variance(samples, axis=0)), diff --git a/tensorflow_probability/python/distributions/half_normal_test.py b/tensorflow_probability/python/distributions/half_normal_test.py index 238c7c8c4f..2c903a971a 100644 --- a/tensorflow_probability/python/distributions/half_normal_test.py +++ b/tensorflow_probability/python/distributions/half_normal_test.py @@ -319,11 +319,11 @@ def testHalfNormalHalfNormalKL(self): kl = tfd.kl_divergence(a, b) x = a.sample(int(4e5), seed=test_util.test_seed(hardcoded_seed=0)) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) + kl_samples = a.log_prob(x) - b.log_prob(x) - kl_, kl_sample_ = self.evaluate([kl, kl_sample]) - self.assertAllClose(true_kl, kl_, atol=2e-15) - self.assertAllClose(true_kl, kl_sample_, atol=0., rtol=5e-2) + kl_, kl_samples_ = self.evaluate([kl, kl_samples]) + self.assertAllClose(kl_, true_kl, atol=2e-15) + self.assertAllMeansClose(kl_samples_, true_kl, axis=0, atol=0., rtol=5e-2) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(zero_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/independent_test.py b/tensorflow_probability/python/distributions/independent_test.py index 22d1bf2de4..e9c0dd159e 100644 --- a/tensorflow_probability/python/distributions/independent_test.py +++ b/tensorflow_probability/python/distributions/independent_test.py @@ -116,23 +116,23 @@ def testSampleConsistentStats(self): sample_var = tf.reduce_mean( tf.math.squared_difference(x, sample_mean), axis=0) sample_std = tf.sqrt(sample_var) - sample_entropy = -tf.reduce_mean(ind.log_prob(x), axis=0) + entropy_samples = -ind.log_prob(x) [ - sample_mean_, + samples_, sample_var_, sample_std_, - sample_entropy_, + entropy_samples_, actual_mean_, actual_var_, actual_std_, actual_entropy_, actual_mode_, ] = self.evaluate([ - sample_mean, + x, sample_var, sample_std, - sample_entropy, + entropy_samples, ind.mean(), ind.variance(), ind.stddev(), @@ -142,11 +142,13 @@ def testSampleConsistentStats(self): # Bounds chosen so that the probability of each sample mean/variance/stddev # differing by more than the given tolerance is roughly 1e-6. - self.assertAllClose(sample_mean_, actual_mean_, rtol=0.049, atol=0.) + self.assertAllMeansClose( + samples_, actual_mean_, axis=0, rtol=0.049, atol=0.) self.assertAllClose(sample_var_, actual_var_, rtol=0.07, atol=0.) self.assertAllClose(sample_std_, actual_std_, rtol=0.035, atol=0.) - self.assertAllClose(sample_entropy_, actual_entropy_, rtol=0.015, atol=0.) + self.assertAllMeansClose( + entropy_samples_, actual_entropy_, axis=0, rtol=0.015, atol=0.) self.assertAllClose(loc, actual_mode_, rtol=1e-6, atol=0.) def testEventNdimsIsStaticWhenPossible(self): diff --git a/tensorflow_probability/python/distributions/laplace_test.py b/tensorflow_probability/python/distributions/laplace_test.py index be4dcd3528..54155a4e16 100644 --- a/tensorflow_probability/python/distributions/laplace_test.py +++ b/tensorflow_probability/python/distributions/laplace_test.py @@ -337,11 +337,11 @@ def testLaplaceLaplaceKL(self): kl = tfd.kl_divergence(a, b) x = a.sample(int(1e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) + kl_samples = a.log_prob(x) - b.log_prob(x) - true_kl_, kl_, kl_sample_ = self.evaluate([true_kl, kl, kl_sample]) - self.assertAllClose(true_kl_, kl_, atol=1e-5, rtol=1e-5) - self.assertAllClose(true_kl_, kl_sample_, atol=0., rtol=1e-1) + true_kl_, kl_, kl_samples_ = self.evaluate([true_kl, kl, kl_samples]) + self.assertAllClose(kl_, true_kl_, atol=1e-5, rtol=1e-5) + self.assertAllMeansClose(kl_samples_, true_kl_, axis=0, atol=0., rtol=1e-1) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(true_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/lkj_test.py b/tensorflow_probability/python/distributions/lkj_test.py index 221acac3d1..296c7f52d9 100644 --- a/tensorflow_probability/python/distributions/lkj_test.py +++ b/tensorflow_probability/python/distributions/lkj_test.py @@ -457,9 +457,10 @@ def verify_expectations(self, dimension, dtype): sample_mean = tf.reduce_mean(x, axis=0) sample_var = tf.reduce_mean( tf.math.squared_difference(x, sample_mean), axis=0) - sample_mean, sample_var = self.evaluate([sample_mean, sample_var]) - self.assertAllClose( - np.zeros_like(sample_mean), sample_mean, atol=3e-3, rtol=1e-3) + samples, sample_mean, sample_var = self.evaluate( + [x, sample_mean, sample_var]) + self.assertAllMeansClose( + samples, np.zeros_like(sample_mean), axis=0, atol=3e-3, rtol=1e-3) expected_var = np.tril(np.ones([dimension, dimension], dtype=dtype)) expected_var = expected_var / np.arange(1, dimension + 1)[..., None] self.assertAllClose(expected_var, sample_var, atol=2e-3, rtol=1e-2) diff --git a/tensorflow_probability/python/distributions/logitnormal_test.py b/tensorflow_probability/python/distributions/logitnormal_test.py index fed0821af9..ebee70dd95 100644 --- a/tensorflow_probability/python/distributions/logitnormal_test.py +++ b/tensorflow_probability/python/distributions/logitnormal_test.py @@ -69,24 +69,21 @@ def testLogitNormalMeanApprox(self): loc, scale = [-1.5, 0., 1.5], 0.4 dist = tfd.LogitNormal(loc=loc, scale=scale, validate_args=True) x = dist.sample(int(10e3), seed=test_util.test_seed()) - mean_sample = tf.reduce_mean(x, axis=0) - [mean_sample_, mean_approx_] = self.evaluate([ - mean_sample, dist.mean_approx()]) - self.assertAllClose(mean_sample_, mean_approx_, atol=1e-4, rtol=0.01) + [x_, mean_approx_] = self.evaluate([x, dist.mean_approx()]) + self.assertAllMeansClose(x_, mean_approx_, axis=0, atol=1e-4, rtol=0.01) def testLogitNormalMeanLogProbApprox(self): loc, scale = [-1.5, 0., 1.5], 0.4 dist = tfd.LogitNormal(loc=loc, scale=scale, validate_args=True) x = dist.sample(int(10e3), seed=test_util.test_seed()) y = tf.constant([0., 0.1, 0.5, 1.], dist.dtype)[:, tf.newaxis] - mean_sample = tf.reduce_mean( - tfd.Bernoulli(probs=x).log_prob(y[..., tf.newaxis]), - axis=1) - [mean_sample_, mean_approx_, mean_approx_default_] = self.evaluate([ - mean_sample, dist.mean_log_prob_approx(y), dist.mean_log_prob_approx()]) - self.assertAllClose(mean_sample_, mean_approx_, atol=1e-4, rtol=0.02) - self.assertAllClose(mean_sample_[-1], mean_approx_default_, - atol=1e-4, rtol=0.02) + samples = tfd.Bernoulli(probs=x).log_prob(y[..., tf.newaxis]) + [samples_, mean_approx_, mean_approx_default_] = self.evaluate([ + samples, dist.mean_log_prob_approx(y), dist.mean_log_prob_approx()]) + self.assertAllMeansClose( + samples_, mean_approx_, axis=1, atol=1e-4, rtol=0.02) + self.assertAllMeansClose( + samples_[-1, :], mean_approx_default_, axis=0, atol=1e-4, rtol=0.02) def testLogitNormalVarianceApprox(self): seed_stream = test_util.test_seed_stream() @@ -150,14 +147,14 @@ def testLogitNormalLogitNormalKL(self): (sigma_a**2 / sigma_b**2) - 1 - 2 * np.log(sigma_a / sigma_b))) x = ln_a.sample(int(1e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(ln_a.log_prob(x) - ln_b.log_prob(x), axis=0) - kl_sample_ = self.evaluate(kl_sample) + kl_samples = ln_a.log_prob(x) - ln_b.log_prob(x) + kl_samples_ = self.evaluate(kl_samples) self.assertEqual(kl.shape, (batch_size,)) self.assertAllClose(kl_val, kl_expected_from_normal) self.assertAllClose(kl_val, kl_expected_from_formula) - self.assertAllClose( - kl_expected_from_formula, kl_sample_, atol=0.0, rtol=1e-2) + self.assertAllMeansClose( + kl_samples_, kl_expected_from_formula, axis=0, atol=0.0, rtol=1e-2) # TODO(b/144948687) Avoid `nan` at boundary. Ideally we'd do this test: # def testPdfAtBoundary(self): diff --git a/tensorflow_probability/python/distributions/lognormal_test.py b/tensorflow_probability/python/distributions/lognormal_test.py index 209e651032..5b3f26dc7c 100644 --- a/tensorflow_probability/python/distributions/lognormal_test.py +++ b/tensorflow_probability/python/distributions/lognormal_test.py @@ -102,14 +102,14 @@ def testLogNormalLogNormalKL(self): (sigma_a**2 / sigma_b**2) - 1 - 2 * np.log(sigma_a / sigma_b))) x = ln_a.sample(int(2e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(ln_a.log_prob(x) - ln_b.log_prob(x), axis=0) - kl_sample_ = self.evaluate(kl_sample) + kl_samples = ln_a.log_prob(x) - ln_b.log_prob(x) + kl_samples_ = self.evaluate(kl_samples) self.assertEqual(kl.shape, (batch_size,)) self.assertAllClose(kl_val, kl_expected_from_normal) self.assertAllClose(kl_val, kl_expected_from_formula) - self.assertAllClose( - kl_expected_from_formula, kl_sample_, atol=0.0, rtol=1e-2) + self.assertAllMeansClose( + kl_samples_, kl_expected_from_formula, axis=0, atol=0.0, rtol=1e-2) # TODO(b/144948687) Avoid `nan` at boundary. Ideally we'd do this test: # def testPdfAtBoundary(self): diff --git a/tensorflow_probability/python/distributions/moyal_test.py b/tensorflow_probability/python/distributions/moyal_test.py index 89b184dd8e..5ed1edfa43 100644 --- a/tensorflow_probability/python/distributions/moyal_test.py +++ b/tensorflow_probability/python/distributions/moyal_test.py @@ -265,10 +265,10 @@ def testMoyalMoyalKL(self): kl = tfd.kl_divergence(a, b) x = a.sample(int(3e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) - kl_, kl_sample_ = self.evaluate([kl, kl_sample]) + kl_samples = a.log_prob(x) - b.log_prob(x) + kl_, kl_samples_ = self.evaluate([kl, kl_samples]) - self.assertAllClose(kl_, kl_sample_, atol=1e-15, rtol=1e-1) + self.assertAllMeansClose(kl_samples_, kl_, axis=0, atol=1e-15, rtol=1e-1) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(zero_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/multinomial_test.py b/tensorflow_probability/python/distributions/multinomial_test.py index d290301559..e7bdf17e4f 100644 --- a/tensorflow_probability/python/distributions/multinomial_test.py +++ b/tensorflow_probability/python/distributions/multinomial_test.py @@ -271,7 +271,7 @@ def testCovarianceFromSampling(self): sample_var = tf.linalg.diag_part(sample_cov) sample_stddev = tf.sqrt(sample_var) [ - sample_mean_, + x_, sample_cov_, sample_var_, sample_stddev_, @@ -280,7 +280,7 @@ def testCovarianceFromSampling(self): analytic_var, analytic_stddev, ] = self.evaluate([ - sample_mean, + x, sample_cov, sample_var, sample_stddev, @@ -289,7 +289,7 @@ def testCovarianceFromSampling(self): dist.variance(), dist.stddev(), ]) - self.assertAllClose(sample_mean_, analytic_mean, atol=0.1, rtol=0.1) + self.assertAllMeansClose(x_, analytic_mean, axis=0, atol=0.1, rtol=0.1) self.assertAllClose(sample_cov_, analytic_cov, atol=0.1, rtol=0.1) self.assertAllClose(sample_var_, analytic_var, atol=0.1, rtol=0.1) self.assertAllClose(sample_stddev_, analytic_stddev, atol=0.1, rtol=0.1) @@ -307,18 +307,18 @@ def testSampleUnbiasedNonScalarBatch(self): sample_covariance = tf.matmul( x_centered, x_centered, adjoint_b=True) / n [ - sample_mean_, + x_, sample_covariance_, actual_mean_, actual_covariance_, ] = self.evaluate([ - sample_mean, + x, sample_covariance, dist.mean(), dist.covariance(), ]) self.assertAllEqual([4, 3, 2], sample_mean.shape) - self.assertAllClose(actual_mean_, sample_mean_, atol=0., rtol=0.10) + self.assertAllMeansClose(x_, actual_mean_, axis=0, atol=0., rtol=0.10) self.assertAllEqual([4, 3, 2, 2], sample_covariance.shape) self.assertAllClose( actual_covariance_, sample_covariance_, atol=0., rtol=0.20) @@ -335,18 +335,18 @@ def testSampleUnbiasedScalarBatch(self): sample_covariance = tf.matmul( x_centered, x_centered, adjoint_a=True) / n [ - sample_mean_, + x_, sample_covariance_, actual_mean_, actual_covariance_, ] = self.evaluate([ - sample_mean, + x, sample_covariance, dist.mean(), dist.covariance(), ]) self.assertAllEqual([4], sample_mean.shape) - self.assertAllClose(actual_mean_, sample_mean_, atol=0., rtol=0.10) + self.assertAllMeansClose(x_, actual_mean_, axis=0, atol=0., rtol=0.10) self.assertAllEqual([4, 4], sample_covariance.shape) self.assertAllClose( actual_covariance_, sample_covariance_, atol=0., rtol=0.20) diff --git a/tensorflow_probability/python/distributions/mvn_diag_plus_low_rank_covariance_test.py b/tensorflow_probability/python/distributions/mvn_diag_plus_low_rank_covariance_test.py index 8f4c43b3a9..c36960e46f 100644 --- a/tensorflow_probability/python/distributions/mvn_diag_plus_low_rank_covariance_test.py +++ b/tensorflow_probability/python/distributions/mvn_diag_plus_low_rank_covariance_test.py @@ -17,7 +17,6 @@ # Dependency imports import numpy as np -import tensorflow.compat.v2 as tf from tensorflow_probability.python import distributions as tfd from tensorflow_probability.python import stats as tfps from tensorflow_probability.python.internal import test_util @@ -56,8 +55,8 @@ def testSampleStatsMatchDistributionStats(self): n = 1000 samples = mvn.sample(n, seed=test_util.test_seed()) - s_mean, mean, s_cov, cov = self.evaluate([ - tf.reduce_mean(samples, axis=0), + samples_, mean, s_cov, cov = self.evaluate([ + samples, mvn.mean(), tfps.covariance(samples, sample_axis=0), mvn.covariance(), @@ -65,7 +64,8 @@ def testSampleStatsMatchDistributionStats(self): maxstddev = np.sqrt(np.max(cov)) - self.assertAllClose(s_mean, mean, atol=5 * maxstddev / np.sqrt(n)) + self.assertAllMeansClose( + samples_, mean, axis=0, atol=5 * maxstddev / np.sqrt(n)) self.assertAllClose(s_cov, cov, atol=5 * maxstddev**2 / np.sqrt(n)) diff --git a/tensorflow_probability/python/distributions/mvn_low_rank_update_linear_operator_covariance_test.py b/tensorflow_probability/python/distributions/mvn_low_rank_update_linear_operator_covariance_test.py index f6326ebbb8..9142110ac7 100644 --- a/tensorflow_probability/python/distributions/mvn_low_rank_update_linear_operator_covariance_test.py +++ b/tensorflow_probability/python/distributions/mvn_low_rank_update_linear_operator_covariance_test.py @@ -279,7 +279,8 @@ def testVersusMVNTriL( with self.subTest('Samples are correct'): n = 10000 samples = low_rank_update.sample(n, seed=test_util.test_seed()) - sample_mean, sample_var, sample_cov = self.evaluate([ + samples, sample_mean, sample_var, sample_cov = self.evaluate([ + samples, tf.reduce_mean(samples, axis=0), tfps.variance(samples, sample_axis=0), tfps.covariance(samples, sample_axis=0), @@ -289,9 +290,10 @@ def testVersusMVNTriL( self.assertAllEqual(ref_samples.shape, samples.shape) maxstddev = np.max(self.evaluate(low_rank_update.stddev())) - self.assertAllClose( - sample_mean, + self.assertAllMeansClose( + samples, self.evaluate(low_rank_update.mean()), + axis=0, atol=5 * maxstddev / np.sqrt(n)) self.assertAllClose( sample_var, diff --git a/tensorflow_probability/python/distributions/normal_test.py b/tensorflow_probability/python/distributions/normal_test.py index 0d6e391938..cbde197ec7 100644 --- a/tensorflow_probability/python/distributions/normal_test.py +++ b/tensorflow_probability/python/distributions/normal_test.py @@ -463,12 +463,13 @@ def testNormalNormalKL(self): (sigma_a**2 / sigma_b**2) - 1 - 2 * np.log(sigma_a / sigma_b))) x = n_a.sample(int(1e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(n_a.log_prob(x) - n_b.log_prob(x), axis=0) - kl_sample_ = self.evaluate(kl_sample) + kl_samples = n_a.log_prob(x) - n_b.log_prob(x) + kl_samples_ = self.evaluate(kl_samples) self.assertEqual(kl.shape, (batch_size,)) self.assertAllClose(kl_val, kl_expected) - self.assertAllClose(kl_expected, kl_sample_, atol=0.0, rtol=1e-2) + self.assertAllMeansClose( + kl_samples_, kl_expected, axis=0, atol=0.0, rtol=1e-2) def testVariableScale(self): x = tf.Variable(1.) diff --git a/tensorflow_probability/python/distributions/onehot_categorical_test.py b/tensorflow_probability/python/distributions/onehot_categorical_test.py index c398e0832b..7ce50f63a6 100644 --- a/tensorflow_probability/python/distributions/onehot_categorical_test.py +++ b/tensorflow_probability/python/distributions/onehot_categorical_test.py @@ -217,15 +217,15 @@ def np_softmax(logits): x = p.sample(int(2e4), seed=test_util.test_seed()) x = tf.cast(x, dtype=tf.float32) # Compute empirical KL(p||q). - kl_sample = tf.reduce_mean( - p.log_prob(x) - q.log_prob(x), axis=0) + kl_samples = p.log_prob(x) - q.log_prob(x) - [kl_sample_, kl_actual_, - kl_same_] = self.evaluate([kl_sample, kl_actual, kl_same]) + [kl_samples_, kl_actual_, + kl_same_] = self.evaluate([kl_samples, kl_actual, kl_same]) self.assertEqual(kl_actual.shape, (batch_size,)) self.assertAllClose(kl_same_, np.zeros_like(kl_expected)) self.assertAllClose(kl_actual_, kl_expected, atol=0., rtol=1e-4) - self.assertAllClose(kl_sample_, kl_expected, atol=1e-2, rtol=0.) + self.assertAllMeansClose( + kl_samples_, kl_expected, axis=0, atol=1e-2, rtol=0.) def testSampleUnbiasedNonScalarBatch(self): logits = self._rng.rand(4, 3, 2).astype(np.float32) @@ -237,18 +237,18 @@ def testSampleUnbiasedNonScalarBatch(self): x_centered = tf.transpose(a=x - sample_mean, perm=[1, 2, 3, 0]) sample_covariance = tf.matmul(x_centered, x_centered, adjoint_b=True) / n [ - sample_mean_, + x_, sample_covariance_, actual_mean_, actual_covariance_, ] = self.evaluate([ - sample_mean, + x, sample_covariance, dist.mean(), dist.covariance(), ]) self.assertAllEqual([4, 3, 2], sample_mean.shape) - self.assertAllClose(actual_mean_, sample_mean_, atol=0., rtol=0.07) + self.assertAllMeansClose(x_, actual_mean_, axis=0, atol=0., rtol=0.07) self.assertAllEqual([4, 3, 2, 2], sample_covariance.shape) self.assertAllClose( actual_covariance_, sample_covariance_, atol=0., rtol=0.10) @@ -263,18 +263,18 @@ def testSampleUnbiasedScalarBatch(self): x_centered = x - sample_mean sample_covariance = tf.matmul(x_centered, x_centered, adjoint_a=True) / n [ - sample_mean_, + x_, sample_covariance_, actual_mean_, actual_covariance_, ] = self.evaluate([ - sample_mean, + x, sample_covariance, dist.probs_parameter(), dist.covariance(), ]) self.assertAllEqual([3], sample_mean.shape) - self.assertAllClose(actual_mean_, sample_mean_, atol=0., rtol=0.1) + self.assertAllMeansClose(x_, actual_mean_, axis=0, atol=0., rtol=0.1) self.assertAllEqual([3, 3], sample_covariance.shape) self.assertAllClose( actual_covariance_, sample_covariance_, atol=0., rtol=0.1) diff --git a/tensorflow_probability/python/distributions/ordered_logistic_test.py b/tensorflow_probability/python/distributions/ordered_logistic_test.py index ac999ecc1e..81a9f42fe1 100644 --- a/tensorflow_probability/python/distributions/ordered_logistic_test.py +++ b/tensorflow_probability/python/distributions/ordered_logistic_test.py @@ -150,9 +150,9 @@ def testEntropyAgainstSampling(self): loc = self._random_location([]) dist = tfd.OrderedLogistic(cutpoints=cutpoints, loc=loc) samples = dist.sample(int(1e5), seed=test_util.test_seed()) - sampled_entropy = self.evaluate(-tf.reduce_mean(dist.log_prob(samples))) + entropy_samples = self.evaluate(-dist.log_prob(samples)) entropy = self.evaluate(dist.entropy()) - self.assertAllClose(sampled_entropy, entropy, atol=0.01) + self.assertAllMeansClose(entropy_samples, entropy, axis=0, atol=0.01) @parameterized.parameters(1, 10, 25) def testKLAgainstCategoricalDistribution(self, batch_size): @@ -188,11 +188,10 @@ def testKLAgainstSampling(self): b = tfd.OrderedLogistic(cutpoints=b_cutpoints, loc=loc) samples = a.sample(int(1e5), seed=test_util.test_seed()) - sampled_kl = self.evaluate( - tf.reduce_mean(a.log_prob(samples) - b.log_prob(samples))) + kl_samples = self.evaluate(a.log_prob(samples) - b.log_prob(samples)) kl = self.evaluate(tfd.kl_divergence(a, b)) - self.assertAllClose(sampled_kl, kl, atol=2e-2) + self.assertAllMeansClose(kl_samples, kl, axis=0, atol=2e-2) def testLatentLogistic(self): loc = self._random_location([2]) diff --git a/tensorflow_probability/python/distributions/pareto_test.py b/tensorflow_probability/python/distributions/pareto_test.py index c90aeeb97e..eb76ffa696 100644 --- a/tensorflow_probability/python/distributions/pareto_test.py +++ b/tensorflow_probability/python/distributions/pareto_test.py @@ -329,11 +329,11 @@ def testParetoParetoKLFinite(self): x = a.sample( int(3e5), seed=test_util.test_seed(hardcoded_seed=0, set_eager_seed=False)) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) + kl_samples = a.log_prob(x) - b.log_prob(x) - kl_, kl_sample_ = self.evaluate([kl, kl_sample]) - self.assertAllClose(true_kl, kl_, atol=2e-15) - self.assertAllClose(true_kl, kl_sample_, atol=0., rtol=1e-2) + kl_, kl_samples_ = self.evaluate([kl, kl_samples]) + self.assertAllClose(kl_, true_kl, atol=2e-15) + self.assertAllMeansClose(kl_samples_, true_kl, axis=0, atol=0., rtol=1e-2) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(true_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/poisson_test.py b/tensorflow_probability/python/distributions/poisson_test.py index 32feadc0d4..685a258870 100644 --- a/tensorflow_probability/python/distributions/poisson_test.py +++ b/tensorflow_probability/python/distributions/poisson_test.py @@ -495,9 +495,10 @@ def testSamplePoissonLowRates(self): st.left_continuous_cdf_discrete_distribution(poisson), false_fail_rate=1e-9)) - self.assertAllClose( - self.evaluate(tf.math.reduce_mean(samples, axis=0)), + self.assertAllMeansClose( + self.evaluate(samples), stats.poisson.mean(rate), + axis=0, rtol=0.01) self.assertAllClose( self.evaluate(tf.math.reduce_variance(samples, axis=0)), @@ -529,9 +530,10 @@ def testSamplePoissonHighRates(self): st.left_continuous_cdf_discrete_distribution(poisson), false_fail_rate=1e-9)) - self.assertAllClose( - self.evaluate(tf.math.reduce_mean(samples, axis=0)), + self.assertAllMeansClose( + self.evaluate(samples), stats.poisson.mean(rate), + axis=0, rtol=0.01) self.assertAllClose( self.evaluate(tf.math.reduce_variance(samples, axis=0)), @@ -571,9 +573,10 @@ def testSamplePoissonInvalidRates(self): log_rates=log_rate, output_dtype=tf.float64, seed=test_util.test_seed())) - self.assertAllClose( - self.evaluate(tf.math.reduce_mean(samples, axis=0)), + self.assertAllMeansClose( + samples, stats.poisson.mean(rate), + axis=0, rtol=0.01) self.assertAllClose( self.evaluate(tf.math.reduce_variance(samples, axis=0)), diff --git a/tensorflow_probability/python/distributions/power_spherical_test.py b/tensorflow_probability/python/distributions/power_spherical_test.py index 4310902906..909c945f1a 100644 --- a/tensorflow_probability/python/distributions/power_spherical_test.py +++ b/tensorflow_probability/python/distributions/power_spherical_test.py @@ -327,10 +327,10 @@ def VerifyEntropy(self, dim): validate_args=True, allow_nan_stats=False) samples = ps.sample(int(3e4), seed=test_util.test_seed()) - sample_entropy = -tf.reduce_mean(ps.log_prob(samples), axis=0) - true_entropy, sample_entropy = self.evaluate([ - ps.entropy(), sample_entropy]) - self.assertAllClose(sample_entropy, true_entropy, rtol=3e-2) + entropy_samples = -ps.log_prob(samples) + true_entropy, entropy_samples = self.evaluate([ + ps.entropy(), entropy_samples]) + self.assertAllMeansClose(entropy_samples, true_entropy, axis=0, rtol=3e-2) def testEntropyDim2(self): self.VerifyEntropy(dim=2) @@ -498,10 +498,10 @@ def VerifyPowerSphericaUniformKL(self, dim): x = ps.sample(int(5e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(ps.log_prob(x) - su.log_prob(x), axis=0) + kl_samples = ps.log_prob(x) - su.log_prob(x) true_kl = tfp.distributions.kl_divergence(ps, su) - true_kl_, kl_sample_ = self.evaluate([true_kl, kl_sample]) - self.assertAllClose(true_kl_, kl_sample_, atol=0.0, rtol=7e-2) + true_kl_, kl_samples_ = self.evaluate([true_kl, kl_samples]) + self.assertAllMeansClose(kl_samples_, true_kl_, axis=0, atol=0.0, rtol=7e-2) def testKLPowerSphericalSphericalUniformDim2(self): self.VerifyPowerSphericaUniformZeroKL(dim=2) @@ -611,10 +611,10 @@ def VerifyPowerSphericalVonMisesFisherKL(self, dim): concentration=concentration2) x = ps.sample(int(6e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(ps.log_prob(x) - vmf.log_prob(x), axis=0) + kl_samples = ps.log_prob(x) - vmf.log_prob(x) true_kl = tfp.distributions.kl_divergence(ps, vmf) - true_kl_, kl_sample_ = self.evaluate([true_kl, kl_sample]) - self.assertAllClose(true_kl_, kl_sample_, atol=0.0, rtol=7e-2) + true_kl_, kl_samples_ = self.evaluate([true_kl, kl_samples]) + self.assertAllMeansClose(kl_samples_, true_kl_, axis=0, atol=0.0, rtol=7e-2) def testKLPowerSphericalVonMisesFisherDim2(self): self.VerifyPowerSphericalVonMisesFisherZeroKL(dim=2) diff --git a/tensorflow_probability/python/distributions/spherical_uniform_test.py b/tensorflow_probability/python/distributions/spherical_uniform_test.py index d935a3ee11..cce9c6116b 100644 --- a/tensorflow_probability/python/distributions/spherical_uniform_test.py +++ b/tensorflow_probability/python/distributions/spherical_uniform_test.py @@ -107,9 +107,7 @@ def VerifyMean(self, dim): validate_args=True, allow_nan_stats=False) samples = uniform.sample(num_samples, seed=test_util.test_seed()) - sample_mean = tf.reduce_mean(samples, axis=0) - true_mean, sample_mean = self.evaluate([ - uniform.mean(), sample_mean]) + true_mean = self.evaluate(uniform.mean()) check1 = st.assert_true_mean_equal_by_dkwm( samples=samples, low=-(1. + 1e-7), high=1. + 1e-7, expected=true_mean, false_fail_rate=1e-6) @@ -174,10 +172,11 @@ def VerifyEntropy(self, dim): validate_args=True, allow_nan_stats=False) samples = uniform.sample(int(1e3), seed=test_util.test_seed()) - sample_entropy = -tf.reduce_mean(uniform.log_prob(samples), axis=0) - true_entropy, sample_entropy = self.evaluate([ - uniform.entropy(), sample_entropy]) - self.assertAllClose(sample_entropy, true_entropy, rtol=1e-5) + entropy_samples = -uniform.log_prob(samples) + true_entropy, entropy_samples = self.evaluate([ + uniform.entropy(), entropy_samples]) + self.assertAllMeansClose( + entropy_samples, true_entropy, axis=0, rtol=1e-5) def testEntropyDim1(self): self.VerifyEntropy(dim=1) diff --git a/tensorflow_probability/python/distributions/stopping_ratio_logistic_test.py b/tensorflow_probability/python/distributions/stopping_ratio_logistic_test.py index a7acb35aca..ae642bb728 100644 --- a/tensorflow_probability/python/distributions/stopping_ratio_logistic_test.py +++ b/tensorflow_probability/python/distributions/stopping_ratio_logistic_test.py @@ -121,11 +121,10 @@ def testKLAgainstSampling(self): b = tfd.StoppingRatioLogistic(cutpoints=b_cutpoints, loc=loc) samples = a.sample(int(1e5), seed=test_util.test_seed()) - sampled_kl = self.evaluate( - tf.reduce_mean(a.log_prob(samples) - b.log_prob(samples))) + kl_samples = self.evaluate(a.log_prob(samples) - b.log_prob(samples)) kl = self.evaluate(tfd.kl_divergence(a, b)) - self.assertAllClose(sampled_kl, kl, atol=2e-2) + self.assertAllMeansClose(kl_samples, kl, axis=0, atol=2e-2) def testUnorderedCutpointsFails(self): with self.assertRaisesRegexp( diff --git a/tensorflow_probability/python/distributions/transformed_distribution_test.py b/tensorflow_probability/python/distributions/transformed_distribution_test.py index 89cb4a9e90..d588efd6ee 100644 --- a/tensorflow_probability/python/distributions/transformed_distribution_test.py +++ b/tensorflow_probability/python/distributions/transformed_distribution_test.py @@ -574,12 +574,13 @@ def testTransformedNormalNormalKL(self): kl_val = self.evaluate(kl) x = td_a.sample(int(1e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(td_a.log_prob(x) - td_b.log_prob(x), axis=0) - kl_sample_ = self.evaluate(kl_sample) + kl_samples = td_a.log_prob(x) - td_b.log_prob(x) + kl_samples_ = self.evaluate(kl_samples) self.assertEqual(kl.shape, (batch_size,)) - self.assertAllClose(kl_val, kl_expected) - self.assertAllClose(kl_expected, kl_sample_, atol=0.0, rtol=1e-2) + self.assertAllClose(kl_expected, kl_val) + self.assertAllMeansClose( + kl_samples_, kl_expected, axis=0, atol=0.0, rtol=1e-2) def testLogProbRatio(self): nsamp = 5 @@ -713,8 +714,8 @@ def testMVN(self, event_shape, shift, tril, dynamic_shape): num_samples = 7e3 y = fake_mvn.sample(int(num_samples), seed=test_util.test_seed()) x = y[0:5, ...] - self.assertAllClose(expected_mean, tf.reduce_mean(y, axis=0), - atol=0.1, rtol=0.1) + self.assertAllMeansClose(y, expected_mean, axis=0, + atol=0.1, rtol=0.1) self.assertAllClose(expected_cov, tfp.stats.covariance(y, sample_axis=0), atol=0., rtol=0.1) diff --git a/tensorflow_probability/python/distributions/uniform_test.py b/tensorflow_probability/python/distributions/uniform_test.py index f0869ccc7c..61503faae7 100644 --- a/tensorflow_probability/python/distributions/uniform_test.py +++ b/tensorflow_probability/python/distributions/uniform_test.py @@ -294,11 +294,11 @@ def testUniformUniformKLFinite(self): # This is essentially an approximated integral from the direct definition # of KL divergence. x = a.sample(int(1e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) + kl_samples = a.log_prob(x) - b.log_prob(x) - kl_, kl_sample_ = self.evaluate([kl, kl_sample]) - self.assertAllClose(true_kl, kl_, atol=2e-15) - self.assertAllClose(true_kl, kl_sample_, atol=0.0, rtol=1e-1) + kl_, kl_samples_ = self.evaluate([kl, kl_samples]) + self.assertAllClose(kl_, true_kl, atol=2e-15) + self.assertAllMeansClose(kl_samples_, true_kl, axis=0, atol=0.0, rtol=1e-1) zero_kl = tfd.kl_divergence(a, a) true_zero_kl_, zero_kl_ = self.evaluate([tf.zeros_like(true_kl), zero_kl]) diff --git a/tensorflow_probability/python/distributions/von_mises_fisher_test.py b/tensorflow_probability/python/distributions/von_mises_fisher_test.py index 527f1fa041..1648956808 100644 --- a/tensorflow_probability/python/distributions/von_mises_fisher_test.py +++ b/tensorflow_probability/python/distributions/von_mises_fisher_test.py @@ -280,13 +280,11 @@ def VerifyVonMisesFisherUniformZeroKL(self, dim): x = vmf.sample(int(5e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(vmf.log_prob(x) - su.log_prob(x), axis=0) + kl_samples = vmf.log_prob(x) - su.log_prob(x) true_kl = tfp.distributions.kl_divergence(vmf, su) - vmf_entropy = vmf.entropy() - su_entropy = su.entropy() - print(self.evaluate([vmf_entropy, su_entropy])) - true_kl_, kl_sample_ = self.evaluate([true_kl, kl_sample]) - self.assertAllClose(true_kl_, kl_sample_, atol=5e-8, rtol=1e-1) + true_kl_, kl_samples_ = self.evaluate([true_kl, kl_samples]) + self.assertAllMeansClose( + kl_samples_, true_kl_, axis=0, atol=5e-8, rtol=1e-1) self.assertAllClose(true_kl_, np.zeros_like(true_kl_), atol=1e-4) def VerifyVonMisesFisherUniformKL(self, dim): @@ -311,10 +309,11 @@ def VerifyVonMisesFisherUniformKL(self, dim): x = vmf.sample(int(5e4), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(vmf.log_prob(x) - su.log_prob(x), axis=0) + kl_samples = vmf.log_prob(x) - su.log_prob(x) true_kl = tfp.distributions.kl_divergence(vmf, su) - true_kl_, kl_sample_ = self.evaluate([true_kl, kl_sample]) - self.assertAllClose(true_kl_, kl_sample_, atol=0.0, rtol=0.3) + true_kl_, kl_samples_ = self.evaluate([true_kl, kl_samples]) + self.assertAllMeansClose( + kl_samples_, true_kl_, axis=0, atol=0.0, rtol=0.3) @parameterized.parameters(2, 3, 5, 10, 20) def testKLVonMisesFisherSphericalUniformDim(self, dim): @@ -341,10 +340,10 @@ def VerifyEntropy(self, dim): validate_args=True, allow_nan_stats=False) samples = vmf.sample(int(3e4), seed=test_util.test_seed()) - sample_entropy = -tf.reduce_mean(vmf.log_prob(samples), axis=0) - true_entropy, sample_entropy = self.evaluate([ - vmf.entropy(), sample_entropy]) - self.assertAllClose(sample_entropy, true_entropy, rtol=3e-2) + entropy_samples = -vmf.log_prob(samples) + true_entropy, entropy_samples = self.evaluate([ + vmf.entropy(), entropy_samples]) + self.assertAllMeansClose(entropy_samples, true_entropy, axis=0, rtol=3e-2) @parameterized.parameters(2, 3, 5, 10, 20) def testEntropyDim(self, dim): diff --git a/tensorflow_probability/python/distributions/von_mises_test.py b/tensorflow_probability/python/distributions/von_mises_test.py index 006fc9f549..46ed06924e 100644 --- a/tensorflow_probability/python/distributions/von_mises_test.py +++ b/tensorflow_probability/python/distributions/von_mises_test.py @@ -291,17 +291,20 @@ def testVonMisesSampleMoments(self): expected_variance = von_mises.variance() standardized_samples = samples - tf.expand_dims(von_mises.mean(), 0) - actual_variance = 1. - tf.reduce_mean( - tf.cos(standardized_samples), axis=0) + variance_samples = 1. - tf.cos(standardized_samples) [ expected_mean_val, expected_variance_val, actual_mean_val, - actual_variance_val + variance_samples_ ] = self.evaluate( - [expected_mean, expected_variance, actual_mean, actual_variance]) + [expected_mean, expected_variance, actual_mean, variance_samples]) - self.assertAllClose(expected_mean_val, actual_mean_val, rtol=0.1) - self.assertAllClose(expected_variance_val, actual_variance_val, rtol=0.1) + # TODO(axch, cgs): atan2(means) is not mean(atan2), but maybe there + # is a formulation of what this is testing that does use IID samples + # and is amenable to assertAllMeansClose? + self.assertAllClose(actual_mean_val, expected_mean_val, rtol=0.1) + self.assertAllMeansClose( + variance_samples_, expected_variance_val, axis=0, rtol=0.1) def testVonMisesSampleVarianceUniform(self): von_mises = tfd.VonMises( @@ -314,11 +317,10 @@ def testVonMisesSampleVarianceUniform(self): # so only checking the variance. expected_variance = 1. standardized_samples = samples - tf.expand_dims(von_mises.mean(), 0) - actual_variance = 1. - tf.reduce_mean( - tf.cos(standardized_samples), axis=0) + variance_samples = 1. - tf.cos(standardized_samples) - self.assertAllClose( - expected_variance, self.evaluate(actual_variance), rtol=0.1) + self.assertAllMeansClose( + self.evaluate(variance_samples), expected_variance, axis=0, rtol=0.1) def testVonMisesSampleKsTest(self): concentrations_v = np.logspace(-3, 3, 50) diff --git a/tensorflow_probability/python/distributions/weibull_test.py b/tensorflow_probability/python/distributions/weibull_test.py index 767acb0771..4959a92ec9 100644 --- a/tensorflow_probability/python/distributions/weibull_test.py +++ b/tensorflow_probability/python/distributions/weibull_test.py @@ -281,11 +281,12 @@ def testWeibullWeibullKL(self): np.exp(np.math.lgamma(b_concentration / a_concentration + 1.))) - 1.) x = a.sample(int(1e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) - kl_sample_val = self.evaluate(kl_sample) + kl_samples = a.log_prob(x) - b.log_prob(x) + kl_samples_ = self.evaluate(kl_samples) - self.assertAllClose(expected_kl, kl_sample_val, atol=0.0, rtol=1e-2) - self.assertAllClose(expected_kl, self.evaluate(kl)) + self.assertAllMeansClose( + kl_samples_, expected_kl, axis=0, atol=0.0, rtol=1e-2) + self.assertAllClose(self.evaluate(kl), expected_kl) def testWeibullGammaKL(self): a_concentration = np.array([3.]) @@ -301,10 +302,11 @@ def testWeibullGammaKL(self): kl = tfd.kl_divergence(a, b) x = a.sample(int(1e5), seed=test_util.test_seed()) - kl_sample = tf.reduce_mean(a.log_prob(x) - b.log_prob(x), axis=0) - kl_sample_val = self.evaluate(kl_sample) + kl_samples = a.log_prob(x) - b.log_prob(x) + kl_samples_ = self.evaluate(kl_samples) - self.assertAllClose(kl_sample_val, self.evaluate(kl), atol=0.0, rtol=1e-2) + self.assertAllMeansClose( + kl_samples_, self.evaluate(kl), axis=0, atol=0.0, rtol=1e-2) def testWeibullGammaKLAgreeWeibullWeibull(self): a_concentration = np.array([3.]) diff --git a/tensorflow_probability/python/distributions/wishart_test.py b/tensorflow_probability/python/distributions/wishart_test.py index 35161c6362..f61c4b8631 100644 --- a/tensorflow_probability/python/distributions/wishart_test.py +++ b/tensorflow_probability/python/distributions/wishart_test.py @@ -177,9 +177,9 @@ def testSample(self): x = chol_w.sample(10000, seed=test_util.test_seed(hardcoded_seed=42)) self.assertAllEqual((10000, 3, 3), x.shape) - moment1_estimate = self.evaluate(tf.reduce_mean(x, axis=[0])) - self.assertAllClose( - self.evaluate(chol_w.mean()), moment1_estimate, rtol=0.05) + x_, moment1_estimate = self.evaluate([x, tf.reduce_mean(x, axis=[0])]) + self.assertAllMeansClose( + x_, self.evaluate(chol_w.mean()), axis=0, rtol=0.05) # The Variance estimate uses the squares rather than outer-products # because Wishart.Variance is the diagonal of the Wishart covariance diff --git a/tensorflow_probability/python/experimental/distributions/mvn_precision_factor_linop_test.py b/tensorflow_probability/python/experimental/distributions/mvn_precision_factor_linop_test.py index 9c6ea7defe..4a59e21d5d 100644 --- a/tensorflow_probability/python/experimental/distributions/mvn_precision_factor_linop_test.py +++ b/tensorflow_probability/python/experimental/distributions/mvn_precision_factor_linop_test.py @@ -124,14 +124,15 @@ def test_log_prob_and_sample( 'stddev': tf.sqrt(cov.diag_part()), 'var': cov.diag_part(), 'cov': cov.to_dense(), - 'sample_mean': tf.reduce_mean(samples, axis=0), + 'samples': samples, 'sample_var': tfp.stats.variance(samples, sample_axis=0), 'sample_cov': tfp.stats.covariance(samples, sample_axis=0), }) - self.assertAllClose( - arrs['sample_mean'], + self.assertAllMeansClose( + arrs['samples'], loc if loc is not None else np.zeros_like(arrs['cov'][..., 0]), + axis=0, atol=5 * np.max(arrs['stddev']) / np.sqrt(n_samples)) self.assertAllClose( arrs['sample_var'], diff --git a/tensorflow_probability/python/experimental/mcmc/weighted_resampling_test.py b/tensorflow_probability/python/experimental/mcmc/weighted_resampling_test.py index d4dd365e3c..aff19faa06 100644 --- a/tensorflow_probability/python/experimental/mcmc/weighted_resampling_test.py +++ b/tensorflow_probability/python/experimental/mcmc/weighted_resampling_test.py @@ -143,19 +143,19 @@ def test_systematic_resampler_means(self): # TODO(dpiponi): reimplement this test in vectorized form rather than with # loops. for i in range(num_distributions): - histogram = tf.reduce_mean( - _scatter_nd_batch(resampled[:, i, :, tf.newaxis], - tf.ones((num_samples, num_particles), - dtype=self.dtype), - (num_samples, num_probs), - batch_dims=1), - axis=0) - means = histogram / num_particles - means_, probs_ = self.evaluate([means, probs[i]]) + samples = _scatter_nd_batch( + resampled[:, i, :, tf.newaxis], + tf.ones((num_samples, num_particles), + dtype=self.dtype), + (num_samples, num_probs), + batch_dims=1) + # N.B.: _scatter_nd_batch returns numpy arrays in Eager mode + wsamples = tf.convert_to_tensor(samples) / num_particles + wsamples_, probs_ = self.evaluate([wsamples, probs[i]]) # TODO(dpiponi): it should be possible to compute the exact distribution # of these means and choose `atol` in a more principled way. - self.assertAllClose(means_, probs_, atol=0.01) + self.assertAllMeansClose(wsamples_, probs_, axis=0, atol=0.01) # TODO(b/153689734): rewrite so as not to use `move_dimension`. def test_minimum_error_resampler_means(self): @@ -187,16 +187,17 @@ def test_minimum_error_resampler_means(self): # TODO(dpiponi): reimplement this test in vectorized form rather than with # loops. for i in range(num_distributions): - histogram = tf.reduce_mean( - _scatter_nd_batch(resampled[:, i, :, tf.newaxis], - tf.ones((num_samples, num_particles)), - (num_samples, num_probs), - batch_dims=1), - axis=0) - means = histogram / num_particles - means_, probs_ = self.evaluate([means, probs[i]]) - - self.assertAllClose(means_, probs_, atol=1.0 / num_particles) + samples = _scatter_nd_batch( + resampled[:, i, :, tf.newaxis], + tf.ones((num_samples, num_particles)), + (num_samples, num_probs), + batch_dims=1) + # N.B.: _scatter_nd_batch returns numpy arrays in Eager mode + wsamples = tf.convert_to_tensor(samples) / num_particles + wsamples_, probs_ = self.evaluate([wsamples, probs[i]]) + + self.assertAllMeansClose( + wsamples_, probs_, axis=0, atol=1.0 / num_particles) # TODO(b/153689734): rewrite so as not to use `move_dimension`. def test_stratified_resampler_means(self): @@ -228,16 +229,16 @@ def test_stratified_resampler_means(self): # TODO(dpiponi): reimplement this test in vectorized form rather than with # loops. for i in range(num_distributions): - histogram = tf.reduce_mean( - _scatter_nd_batch(resampled[:, i, :, tf.newaxis], - tf.ones((num_samples, num_particles)), - (num_samples, num_probs), - batch_dims=1), - axis=0) - means = histogram / num_particles - means_, probs_ = self.evaluate([means, probs[i]]) + samples = _scatter_nd_batch( + resampled[:, i, :, tf.newaxis], + tf.ones((num_samples, num_particles)), + (num_samples, num_probs), + batch_dims=1) + # N.B.: _scatter_nd_batch returns numpy arrays in Eager mode + wsamples = tf.convert_to_tensor(samples) / num_particles + wsamples_, probs_ = self.evaluate([wsamples, probs[i]]) - self.assertAllClose(means_, probs_, atol=0.1) + self.assertAllMeansClose(wsamples_, probs_, axis=0, atol=0.1) def test_resample_using_extremal_log_points(self): if self.use_xla and tf.executing_eagerly(): @@ -281,7 +282,7 @@ def resample_with_target_distribution(self): particles, log_weights, resample_fn=resample_systematic, seed=test_util.test_seed(sampler_type='stateless')) - self.assertAllClose(tf.reduce_mean(new_particles), 20., atol=1e-2) + self.assertAllMeansClose(new_particles, 20., axis=0, atol=1e-2) self.assertAllClose( tf.reduce_sum(tf.nn.softmax(new_log_weights) * new_particles), 20., @@ -293,7 +294,7 @@ def resample_with_target_distribution(self): resample_fn=resample_systematic, target_log_weights=tfd.Poisson(30).log_prob(particles), seed=test_util.test_seed(sampler_type='stateless')) - self.assertAllClose(tf.reduce_mean(new_particles), 20., atol=1e-2) + self.assertAllMeansClose(new_particles, 20., axis=0, atol=1e-2) self.assertAllClose( tf.reduce_sum(tf.nn.softmax(new_log_weights) * new_particles), 30., atol=1.) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index 5288ee69d1..37a46bed73 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -370,6 +370,9 @@ def test_sampled_latents_have_correct_marginals(self, use_slope): tfp.stats.covariance(latents_samples, sample_axis=0, event_axis=-1))) + # TODO(axch, cgs): Can we use assertAllMeansClose here? The + # latents_samples are presumably not IID across axis=0, so the + # statistical assumptions are not satisfied. self.assertAllClose(latents_means_, posterior_means_, atol=0.1) self.assertAllClose(latents_covs_, @@ -490,6 +493,9 @@ def do_sampling(): axis=-2) # Increasing `num_timesteps` relative to `num_features` would give more # precise weight estimates, at the cost of longer test runtime. + # TODO(axch, cgs): Can we use assertAllMeansClose here too? The + # samples are presumably not IID across axis=0, so the + # statistical assumptions are not satisfied. self.assertAllClose(mean_weights, true_weights, atol=0.3) self.assertAllClose(nonzero_probs, [0., 0., 1., 0., 1.], atol=0.2) diff --git a/tensorflow_probability/python/layers/distribution_layer_test.py b/tensorflow_probability/python/layers/distribution_layer_test.py index 3620c040c0..c791060c39 100644 --- a/tensorflow_probability/python/layers/distribution_layer_test.py +++ b/tensorflow_probability/python/layers/distribution_layer_test.py @@ -711,17 +711,17 @@ def _check_distribution(self, t, x): t_back_, x_mean_, x_log_mean_, - sample_mean_, + samples_, ] = self.evaluate([ t, t_back, x.mean(), x.log_mean(), - tf.reduce_mean(x.sample(int(10e3), seed=42), axis=0), + x.sample(int(10e3), seed=42), ]) self.assertAllClose(t_, t_back_, atol=1e-6, rtol=1e-5) self.assertAllClose(x_mean_, np.exp(x_log_mean_), atol=1e-6, rtol=1e-5) - self.assertAllClose(sample_mean_, x_mean_, atol=1e-3, rtol=0.1) + self.assertAllMeansClose(samples_, x_mean_, axis=0, atol=1e-3, rtol=0.1) def test_new(self): k = 2 # num components diff --git a/tensorflow_probability/python/random/random_ops_test.py b/tensorflow_probability/python/random/random_ops_test.py index 1045c87c7b..bb2af58f63 100644 --- a/tensorflow_probability/python/random/random_ops_test.py +++ b/tensorflow_probability/python/random/random_ops_test.py @@ -80,12 +80,11 @@ def test_expected_value(self): sample_mean = tf.reduce_mean(x, axis=-1, keepdims=True) sample_var = tf.reduce_mean( tf.math.squared_difference(x, sample_mean), axis=-1) - [x_, sample_mean_, sample_var_] = self.evaluate([ - x, sample_mean[..., 0], sample_var]) + [x_, sample_var_] = self.evaluate([x, sample_var]) self.assertAllEqual(final_shape_, x_.shape) self.assertAllEqual(np.ones_like(x_, dtype=np.bool_), x_ > 0.) - self.assertAllClose(np.sqrt(np.pi / 2.) * scale_, sample_mean_, - atol=0.05, rtol=0.) + self.assertAllMeansClose( + x_, np.sqrt(np.pi / 2.) * scale_, axis=-1, atol=0.05, rtol=0.) self.assertAllClose(0.5 * (4. - np.pi) * scale_**2., sample_var_, atol=0.05, rtol=0.) From a466b3bf9c7bf02ad77a378952685db9e545526f Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Fri, 1 Apr 2022 14:28:46 -0700 Subject: [PATCH 067/153] Remove `tfb.Ordered` bijector and `finite_nondiscrete` flags in Distributions. PiperOrigin-RevId: 438911859 --- tensorflow_probability/python/bijectors/BUILD | 26 ----- .../python/bijectors/__init__.py | 2 - .../python/bijectors/ordered.py | 100 ------------------ .../python/bijectors/ordered_test.py | 98 ----------------- .../python/distributions/BUILD | 6 +- .../python/distributions/finite_discrete.py | 6 +- .../python/distributions/ordered_logistic.py | 6 +- .../python/distributions/poisson.py | 42 +------- .../distributions/stopping_ratio_logistic.py | 7 +- .../stopping_ratio_logistic_test.py | 4 +- .../python/distributions/zipf.py | 43 +------- 11 files changed, 15 insertions(+), 325 deletions(-) delete mode 100644 tensorflow_probability/python/bijectors/ordered.py delete mode 100644 tensorflow_probability/python/bijectors/ordered_test.py diff --git a/tensorflow_probability/python/bijectors/BUILD b/tensorflow_probability/python/bijectors/BUILD index f54bcf446e..17ba25de19 100644 --- a/tensorflow_probability/python/bijectors/BUILD +++ b/tensorflow_probability/python/bijectors/BUILD @@ -76,7 +76,6 @@ multi_substrate_py_library( ":matrix_inverse_tril", ":moyal_cdf", ":normal_cdf", - ":ordered", ":pad", ":permute", ":power", @@ -659,17 +658,6 @@ multi_substrate_py_library( ], ) -multi_substrate_py_library( - name = "ordered", - srcs = ["ordered.py"], - deps = [ - ":bijector", - # tensorflow dep, - "//tensorflow_probability/python/internal:assert_util", - "//tensorflow_probability/python/internal:distribution_util", - ], -) - multi_substrate_py_library( name = "pad", srcs = ["pad.py"], @@ -1632,20 +1620,6 @@ multi_substrate_py_test( ], ) -multi_substrate_py_test( - name = "ordered_test", - size = "small", - srcs = ["ordered_test.py"], - deps = [ - ":bijector_test_util", - # numpy dep, - # tensorflow dep, - "//tensorflow_probability", - "//tensorflow_probability/python/internal:tensorshape_util", - "//tensorflow_probability/python/internal:test_util", - ], -) - multi_substrate_py_test( name = "pad_test", size = "small", diff --git a/tensorflow_probability/python/bijectors/__init__.py b/tensorflow_probability/python/bijectors/__init__.py index 63137dab2f..f998bcd13d 100644 --- a/tensorflow_probability/python/bijectors/__init__.py +++ b/tensorflow_probability/python/bijectors/__init__.py @@ -59,7 +59,6 @@ from tensorflow_probability.python.bijectors.matrix_inverse_tril import MatrixInverseTriL from tensorflow_probability.python.bijectors.moyal_cdf import MoyalCDF from tensorflow_probability.python.bijectors.normal_cdf import NormalCDF -from tensorflow_probability.python.bijectors.ordered import Ordered from tensorflow_probability.python.bijectors.pad import Pad from tensorflow_probability.python.bijectors.permute import Permute from tensorflow_probability.python.bijectors.power import Power @@ -143,7 +142,6 @@ "MatvecLU", "MoyalCDF", "NormalCDF", - "Ordered", "Pad", "Permute", "Power", diff --git a/tensorflow_probability/python/bijectors/ordered.py b/tensorflow_probability/python/bijectors/ordered.py deleted file mode 100644 index 6aae3ba41a..0000000000 --- a/tensorflow_probability/python/bijectors/ordered.py +++ /dev/null @@ -1,100 +0,0 @@ -# Copyright 2018 The TensorFlow Probability Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# ============================================================================ -"""Ordered bijector.""" - -import tensorflow.compat.v2 as tf - -from tensorflow_probability.python.bijectors import bijector -from tensorflow_probability.python.internal import assert_util -from tensorflow.python.util import deprecation # pylint: disable=g-direct-tensorflow-import - - -__all__ = [ - 'Ordered', -] - - -class Ordered(bijector.AutoCompositeTensorBijector): - """Maps a vector of increasing elements to an unconstrained vector. - - Both the domain and the codomain of the mapping is [-inf, inf], however, - the input of the forward mapping must be strictly increasing. - - On the last dimension of the tensor, Ordered bijector performs: - `y[0] = x[0]` - `y[1:] = tf.log(x[1:] - x[:-1])` - - #### Example Use: - - ```python - bijectors.Ordered().forward([2, 3, 4]) - # Result: [2., 0., 0.] - - bijectors.Ordered().inverse([0.06428002, -1.07774478, -0.71530371]) - # Result: [0.06428002, 0.40464228, 0.8936858] - ``` - """ - - @deprecation.deprecated( - '2021-01-09', '`Ordered` bijector is deprecated; please use ' - '`tfb.Invert(tfb.Ascending())` instead.', - warn_once=True) - def __init__(self, validate_args=False, name='ordered'): - parameters = dict(locals()) - with tf.name_scope(name) as name: - super(Ordered, self).__init__( - forward_min_event_ndims=1, - validate_args=validate_args, - parameters=parameters, - name=name) - - @classmethod - def _parameter_properties(cls, dtype): - return dict() - - def _forward(self, x): - with tf.control_dependencies(self._assertions(x)): - y0 = x[..., :1] - yk = tf.math.log(x[..., 1:] - x[..., :-1]) - y = tf.concat([y0, yk], axis=-1) - return y - - def _inverse(self, y): - x0 = y[..., :1] - xk = tf.exp(y[..., 1:]) - x = tf.concat([x0, xk], axis=-1) - return tf.cumsum(x, axis=-1) - - def _inverse_log_det_jacobian(self, y): - # The Jacobian of the inverse mapping is lower - # triangular, with the diagonal elements being: - # J[i,i] = 1 if i=1, and - # exp(y_i) if 1 Date: Fri, 1 Apr 2022 14:37:38 -0700 Subject: [PATCH 068/153] Use stateless truncated normal sampler everywhere. This ensures faster sampling / gradient computations in Graph mode as well as XLA-able stateless sampling. PiperOrigin-RevId: 438913885 --- .../python/distributions/BUILD | 1 - .../python/distributions/truncated_normal.py | 101 ++---------------- .../distributions/truncated_normal_test.py | 10 +- 3 files changed, 16 insertions(+), 96 deletions(-) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index efb7f4f400..f38fc43e3a 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -3935,7 +3935,6 @@ multi_substrate_py_test( name = "truncated_normal_test", srcs = ["truncated_normal_test.py"], jax_size = "medium", - numpy_tags = ["notap"], shard_count = 10, deps = [ # absl/testing:parameterized dep, diff --git a/tensorflow_probability/python/distributions/truncated_normal.py b/tensorflow_probability/python/distributions/truncated_normal.py index 681cf82af9..ee5a5ca964 100644 --- a/tensorflow_probability/python/distributions/truncated_normal.py +++ b/tensorflow_probability/python/distributions/truncated_normal.py @@ -17,7 +17,6 @@ # Dependency imports import numpy as np -import tensorflow.compat.v1 as tf1 import tensorflow.compat.v2 as tf from tensorflow_probability.python.bijectors import sigmoid as sigmoid_bijector @@ -32,8 +31,6 @@ from tensorflow_probability.python.internal import special_math from tensorflow_probability.python.internal import tensor_util from tensorflow_probability.python.math.generic import log_sub_exp as _log_sub_exp -from tensorflow.python.ops import control_flow_util # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.ops import random_ops # pylint: disable=g-direct-tensorflow-import __all__ = [ @@ -251,97 +248,13 @@ def _sample_n(self, n, seed=None): batch_shape = self._batch_shape_tensor( loc=loc, scale=scale, low=low, high=high) sample_and_batch_shape = ps.concat([[n], batch_shape], 0) - # TODO(b/162522020): Use this behavior unconditionally. - if (tf.executing_eagerly() or - not control_flow_util.GraphOrParentsInXlaContext( - tf1.get_default_graph())): - return tf.random.stateless_parameterized_truncated_normal( - shape=sample_and_batch_shape, - means=loc, - stddevs=scale, - minvals=low, - maxvals=high, - seed=samplers.sanitize_seed(seed)) - - flat_batch_and_sample_shape = tf.stack([tf.reduce_prod(batch_shape), n]) - # In order to be reparameterizable we sample on the truncated_normal of - # unit variance and mean and scale (but with the standardized - # truncation bounds). - - @tf.custom_gradient - def _std_samples_with_gradients(lower, upper): - """Standard truncated Normal with gradient support for low, high.""" - # Note: Unlike the convention in TFP, parameterized_truncated_normal - # returns a tensor with the final dimension being the sample dimension. - std_samples = random_ops.parameterized_truncated_normal( - shape=flat_batch_and_sample_shape, - means=0.0, - stddevs=1.0, - minvals=lower, - maxvals=upper, - dtype=self.dtype, - seed=seed) - - def grad(dy): - """Computes a derivative for the min and max parameters. - - This function implements the derivative wrt the truncation bounds, which - get blocked by the sampler. We use a custom expression for numerical - stability instead of automatic differentiation on CDF for implicit - gradients. - - Args: - dy: output gradients - - Returns: - The standard normal samples and the gradients wrt the upper - bound and lower bound. - """ - # std_samples has an extra dimension (the sample dimension), expand - # lower and upper so they broadcast along this dimension. - # See note above regarding parameterized_truncated_normal, the sample - # dimension is the final dimension. - lower_broadcast = lower[..., tf.newaxis] - upper_broadcast = upper[..., tf.newaxis] - - cdf_samples = ( - _normal_cdf_difference(std_samples, lower_broadcast) / - _normal_cdf_difference(upper_broadcast, lower_broadcast)) - - # tiny, eps are tolerance parameters to ensure we stay away from giving - # a zero arg to the log CDF expression. - - tiny = np.finfo(dtype_util.as_numpy_dtype(self.dtype)).tiny - eps = np.finfo(dtype_util.as_numpy_dtype(self.dtype)).eps - cdf_samples = tf.clip_by_value(cdf_samples, tiny, 1 - eps) - - du = tf.exp(0.5 * (std_samples**2 - upper_broadcast**2) + - tf.math.log(cdf_samples)) - dl = tf.exp(0.5 * (std_samples**2 - lower_broadcast**2) + - tf.math.log1p(-cdf_samples)) - - # Reduce the gradient across the samples - grad_u = tf.reduce_sum(dy * du, axis=-1) - grad_l = tf.reduce_sum(dy * dl, axis=-1) - return [grad_l, grad_u] - - return std_samples, grad - - std_low, std_high = self._standardized_low_and_high( - low=low, high=high, loc=loc, scale=scale) - low_high_shp = tf.broadcast_dynamic_shape( - tf.shape(std_low), tf.shape(std_high)) - std_low = tf.broadcast_to(std_low, low_high_shp) - std_high = tf.broadcast_to(std_high, low_high_shp) - - std_samples = _std_samples_with_gradients( - tf.reshape(std_low, [-1]), tf.reshape(std_high, [-1])) - - # The returned shape is [flat_batch x n] - std_samples = tf.transpose(std_samples, perm=[1, 0]) - - std_samples = tf.reshape(std_samples, sample_and_batch_shape) - return std_samples * scale[tf.newaxis] + loc[tf.newaxis] + return tf.random.stateless_parameterized_truncated_normal( + shape=sample_and_batch_shape, + means=loc, + stddevs=scale, + minvals=low, + maxvals=high, + seed=samplers.sanitize_seed(seed)) def _log_prob(self, x): np_dtype = dtype_util.as_numpy_dtype(x.dtype) diff --git a/tensorflow_probability/python/distributions/truncated_normal_test.py b/tensorflow_probability/python/distributions/truncated_normal_test.py index 0d1ecd9384..d0ca08283e 100644 --- a/tensorflow_probability/python/distributions/truncated_normal_test.py +++ b/tensorflow_probability/python/distributions/truncated_normal_test.py @@ -302,6 +302,7 @@ def testMode(self, loc, scale, low, high): expected_mode = loc self.assertAlmostEqual(mode, expected_mode) + @test_util.numpy_disable_gradient_test @parameterized.parameters((np.float32), (np.float64)) def testReparametrizable(self, dtype=np.float32): loc = dtype(0.1) @@ -322,6 +323,7 @@ def f(loc, scale, low, high): # These gradients are noisy due to sampling. self.assertLess(err, 0.05) + @test_util.numpy_disable_gradient_test def testReparametrizableBatch(self): def samples_sum(loc): dist = tfp.distributions.TruncatedNormal( @@ -332,6 +334,7 @@ def samples_sum(loc): _, dy_loc = self.evaluate(tfp.math.value_and_gradient(samples_sum, loc)) self.assertAllGreaterEqual(dy_loc, 0.) + @test_util.numpy_disable_gradient_test @parameterized.parameters( itertools.product((np.float32, np.float64), ('prob', 'log_prob', 'cdf', 'log_cdf', @@ -355,6 +358,7 @@ def f(loc, scale): err = self.compute_max_gradient_error(f, [loc, scale]) self.assertLess(err, 1e-2) + @test_util.numpy_disable_gradient_test @parameterized.parameters( itertools.product((np.float32, np.float64), ('entropy', 'mean', 'variance', 'mode')) @@ -405,6 +409,8 @@ def f(loc): @test_util.test_graph_mode_only class TruncatedNormalTestGraphMode(_TruncatedNormalTestCase): + @test_util.numpy_disable_test_missing_functionality( + 'This is a regression test for TF-graph mode.') @parameterized.named_parameters( {'testcase_name': '_float32', 'dtype': tf.float32}, {'testcase_name': '_float64', 'dtype': tf.float64}) @@ -420,8 +426,10 @@ def testReproduceVmap1(self, dtype): batch_lp = dist.log_prob(sample) pfor_lp = tf.vectorized_map(dist.log_prob, sample) batch_lp_, pfor_lp_ = self.evaluate((batch_lp, pfor_lp)) - self.assertAllClose(batch_lp_, pfor_lp_, atol=1e-6) + self.assertAllClose(batch_lp_, pfor_lp_, atol=2e-6) + @test_util.numpy_disable_test_missing_functionality( + 'This is a regression test for TF-graph mode.') @parameterized.named_parameters( {'testcase_name': '_float32', 'dtype': tf.float32}, {'testcase_name': '_float64', 'dtype': tf.float64}) From a43776812f860a1f62232786b209e158c29ea1cd Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Sat, 2 Apr 2022 13:15:43 -0300 Subject: [PATCH 069/153] Add tests --- .../python/distributions/BUILD | 1 - .../distributions/two_piece_normal_test.py | 47 ++++++++++++++++--- 2 files changed, 40 insertions(+), 8 deletions(-) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index b4fc987fa4..ebfa3bd3f3 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -3956,7 +3956,6 @@ multi_substrate_py_test( # numpy dep, # tensorflow dep, "//tensorflow_probability", - "//tensorflow_probability/python/internal:prefer_static", "//tensorflow_probability/python/internal:test_util", ], ) diff --git a/tensorflow_probability/python/distributions/two_piece_normal_test.py b/tensorflow_probability/python/distributions/two_piece_normal_test.py index e38a073f37..f5cb7747a5 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal_test.py +++ b/tensorflow_probability/python/distributions/two_piece_normal_test.py @@ -352,20 +352,53 @@ def sampler(loc, scale, skewness): @test_util.numpy_disable_gradient_test def testDifferentiableSampleNumerically(self): - def sampler(loc, scale, skewness): + """Test the gradients of the samples w.r.t. skewness.""" + sample_shape = [int(2e5)] + seed = test_util.test_seed() + + def sampler(skewness): + loc = tf.constant(0., self.dtype) + scale = tf.constant(1., self.dtype) dist = tfd.TwoPieceNormal( loc, scale=scale, skewness=skewness, validate_args=True) - n = int(2e5) - return tf.reduce_mean(dist.sample(n, seed=test_util.test_seed())) - - loc = tf.constant(0.1, self.dtype) - scale = tf.constant(1.1, self.dtype) + return tf.reduce_mean(dist.sample(sample_shape, seed=seed)) for skewness in [0.75, 1., 1.33]: err = self.compute_max_gradient_error( - sampler, [loc, scale, tf.constant(skewness, self.dtype)], delta=0.1) + sampler, [tf.constant(skewness, self.dtype)], delta=0.1) self.assertLess(err, 0.05) + @test_util.numpy_disable_gradient_test + def testDifferentiableSampleAnalytically(self): + """Test the gradients of the samples w.r.t. loc and scale.""" + n = 100 + sample_shape = [n, n] + n_samples = np.prod(sample_shape) + + n_params = 20 + loc = tf.constant( + np.linspace(-3., stop=3., num=n_params), dtype=self.dtype) + scale = tf.constant( + np.linspace(0.1, stop=10., num=n_params), dtype=self.dtype) + skewness = tf.constant( + np.linspace(0.75, stop=1.33, num=n_params), dtype=self.dtype) + + seed = test_util.test_seed() + + def sampler(loc, scale): + dist = tfd.TwoPieceNormal( + loc=loc, scale=scale, skewness=skewness, validate_args=True) + return dist.sample(sample_shape, seed=seed) + + samples, dsamples = tfp.math.value_and_gradient(sampler, [loc, scale]) + dloc_auto, dscale_auto = [grad / n_samples for grad in dsamples] + + dloc_calc = tf.ones([n_params], dtype=self.dtype) + dscale_calc = tf.reduce_mean((samples - loc) / scale, axis=[0, 1]) + + self.assertAllClose(dloc_auto, dloc_calc) + self.assertAllClose(dscale_auto, dscale_calc) + def testNegativeScaleSkewnessFails(self): with self.assertRaisesOpError('Argument `scale` must be positive.'): dist = tfd.TwoPieceNormal( From 8803a57d61048afa7b1a5c71c5d3b8753efb0354 Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Sat, 2 Apr 2022 13:24:22 -0300 Subject: [PATCH 070/153] Change reparameterization type --- .../python/distributions/two_piece_normal.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tensorflow_probability/python/distributions/two_piece_normal.py b/tensorflow_probability/python/distributions/two_piece_normal.py index 7b60dbcfcb..570ca1e78d 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal.py +++ b/tensorflow_probability/python/distributions/two_piece_normal.py @@ -221,9 +221,7 @@ def __init__(self, skewness, dtype=dtype, name='skewness') super().__init__( dtype=dtype, - # skewness contributes to a discrete choice. The other two variables - # are fine. - reparameterization_type=reparameterization.NOT_REPARAMETERIZED, + reparameterization_type=reparameterization.FULLY_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, From 210420be14626ec5b6041969ee5086a3fcd647f5 Mon Sep 17 00:00:00 2001 From: jburnim Date: Mon, 4 Apr 2022 10:40:05 -0700 Subject: [PATCH 071/153] Fix small bug with upper bounds in Gibbs sampling with a spike-and-slab prior. PiperOrigin-RevId: 439354638 --- .../python/experimental/sts_gibbs/gibbs_sampler.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index 14f61bb72b..f1656304f3 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -770,8 +770,11 @@ def _build_sampler_loop_body(model, observation_noise_variance_prior_scale=( observation_noise_variance_prior.scale), observation_noise_variance_upper_bound=( - observation_noise_variance_prior.upper_bound if hasattr( - observation_noise_variance_prior, 'upper_bound') else None), + # The given bound is for the scale, so it must be squared to get the + # upper bound for the variance. + tf.math.square(observation_noise_variance_prior.upper_bound) + if hasattr(observation_noise_variance_prior, 'upper_bound') + else None), **({ 'default_pseudo_observations': default_pseudo_observations } if default_pseudo_observations is not None else {})) From ecf89cc21249f9e71dde0e69c5d6d0f26c5fc556 Mon Sep 17 00:00:00 2001 From: emilyaf Date: Tue, 5 Apr 2022 12:53:37 -0700 Subject: [PATCH 072/153] Updates to the Numpy/Jax backends to support Bayesopt. PiperOrigin-RevId: 439652550 --- .../python/internal/backend/numpy/numpy_array.py | 8 +++++++- .../python/internal/backend/numpy/numpy_math.py | 10 +++++----- .../python/internal/backend/numpy/ops.py | 9 +++++++++ 3 files changed, 21 insertions(+), 6 deletions(-) diff --git a/tensorflow_probability/python/internal/backend/numpy/numpy_array.py b/tensorflow_probability/python/internal/backend/numpy/numpy_array.py index de47723460..c15cfc295f 100644 --- a/tensorflow_probability/python/internal/backend/numpy/numpy_array.py +++ b/tensorflow_probability/python/internal/backend/numpy/numpy_array.py @@ -387,6 +387,12 @@ def _unstack(value, num=None, axis=0, name='unstack'): for x in np.split(value, value.shape[axis] if num is None else num, axis)) +def _where(condition, x=None, y=None, name='where'): # pylint: disable=unused-argument + if x is None and y is None: + return np.stack(np.asarray(condition).nonzero(), axis=-1) + return np.where(condition, x, y) + + def _zeros_like(input, dtype=None, name=None): # pylint: disable=redefined-builtin,unused-argument return np.zeros_like(input, dtype=utils.numpy_dtype(dtype)) @@ -510,7 +516,7 @@ def _zeros_like(input, dtype=None, name=None): # pylint: disable=redefined-buil where = utils.copy_docstring( 'tf.where', - lambda condition, x=None, y=None, name=None: np.where(condition, x, y)) + _where) zeros = utils.copy_docstring( 'tf.zeros', diff --git a/tensorflow_probability/python/internal/backend/numpy/numpy_math.py b/tensorflow_probability/python/internal/backend/numpy/numpy_math.py index aa7f9ae29d..72f763b88f 100644 --- a/tensorflow_probability/python/internal/backend/numpy/numpy_math.py +++ b/tensorflow_probability/python/internal/backend/numpy/numpy_math.py @@ -15,6 +15,7 @@ """Numpy implementations of TensorFlow functions.""" import collections +import functools import numpy as np from tensorflow_probability.python.internal.backend.numpy import _utils as utils @@ -114,7 +115,7 @@ 'reciprocal_no_nan', 'reduce_all', 'reduce_any', - # 'reduce_euclidean_norm', + 'reduce_euclidean_norm', 'reduce_logsumexp', 'reduce_max', 'reduce_mean', @@ -826,10 +827,9 @@ def _apply_reduction(op, input_tensor, axis=None, keepdims=False, name=None, # 'tf.math.reduce_any', utils.partial(_apply_reduction, np.any)) -# reduce_euclidean_norm = utils.copy_docstring( -# 'tf.math.reduce_euclidean_norm', -# lambda input_tensor, axis=None, keepdims=False, name=None: ( -# np.reduce_euclidean_norm)) +reduce_euclidean_norm = utils.copy_docstring( + 'tf.math.reduce_euclidean_norm', + utils.partial(_apply_reduction, functools.partial(np.linalg.norm, ord=2))) reduce_logsumexp = utils.copy_docstring( 'tf.math.reduce_logsumexp', diff --git a/tensorflow_probability/python/internal/backend/numpy/ops.py b/tensorflow_probability/python/internal/backend/numpy/ops.py index cfbfa4838c..93444819c9 100644 --- a/tensorflow_probability/python/internal/backend/numpy/ops.py +++ b/tensorflow_probability/python/internal/backend/numpy/ops.py @@ -51,6 +51,7 @@ 'is_tensor', 'name_scope', 'newaxis', + 'recompute_grad', 'register_tensor_conversion_function', 'stop_gradient', 'GradientTape', @@ -532,6 +533,14 @@ def __exit__(self, type_arg, value_arg, traceback_arg): newaxis = np.newaxis +if JAX_MODE: + from jax import remat # pylint: disable=g-import-not-at-top + recompute_grad = utils.copy_docstring( + 'tf.recompute_grad', + remat) +else: + recompute_grad = lambda x: x + if JAX_MODE: from jax import lax # pylint: disable=g-import-not-at-top stop_gradient = utils.copy_docstring( From d5a19c170458ae91b3868a5e7192de7ffc699815 Mon Sep 17 00:00:00 2001 From: emilyaf Date: Tue, 5 Apr 2022 14:06:06 -0700 Subject: [PATCH 073/153] Plumb `always_yield_multivariate_normal` through `tfd.GaussianProcessRegressionModel.precompute_regression_model`. PiperOrigin-RevId: 439671650 --- .../python/distributions/gaussian_process.py | 4 +++- .../distributions/gaussian_process_regression_model.py | 6 ++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index 67ce1ed565..3061fb4249 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -736,7 +736,9 @@ def posterior_predictive( 'mean_fn': self.mean_fn, 'jitter': self.jitter, 'validate_args': self.validate_args, - 'allow_nan_stats': self.allow_nan_stats + 'allow_nan_stats': self.allow_nan_stats, + 'always_yield_multivariate_normal': + self._always_yield_multivariate_normal } argument_dict.update(**kwargs) diff --git a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py index 6fbe5396db..4a2bc1ef4e 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py +++ b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py @@ -605,6 +605,7 @@ def precompute_regression_model( mean_fn=None, cholesky_fn=None, jitter=1e-6, + always_yield_multivariate_normal=False, validate_args=False, allow_nan_stats=False, name='PrecomputedGaussianProcessRegressionModel'): @@ -699,6 +700,10 @@ def precompute_regression_model( jitter: `float` scalar `Tensor` added to the diagonal of the covariance matrix to ensure positive definiteness of the covariance matrix. Default value: `1e-6`. + always_yield_multivariate_normal: If `False` (the default), we produce a + scalar `Normal` distribution when the number of `index_points` is + statically known to be `1`. If `True`, we avoid this behavior, ensuring + that the event shape will retain the `1` from `index_points`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect @@ -785,6 +790,7 @@ def conditional_mean_fn(x): predictive_noise_variance=predictive_noise_variance, cholesky_fn=cholesky_fn, jitter=jitter, + always_yield_multivariate_normal=always_yield_multivariate_normal, _conditional_kernel=conditional_kernel, _conditional_mean_fn=conditional_mean_fn, validate_args=validate_args, From f3f88d5a16599a7a0e3df2f304d848aa23b3440f Mon Sep 17 00:00:00 2001 From: emilyaf Date: Tue, 5 Apr 2022 17:35:41 -0700 Subject: [PATCH 074/153] Plumb `always_yield_multivariate_normal` through `tfd.GaussianProcessRegressionModel.precompute_regression_model`. PiperOrigin-RevId: 439716984 --- .../python/distributions/gaussian_process.py | 4 +--- .../distributions/gaussian_process_regression_model.py | 6 ------ 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index 3061fb4249..67ce1ed565 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -736,9 +736,7 @@ def posterior_predictive( 'mean_fn': self.mean_fn, 'jitter': self.jitter, 'validate_args': self.validate_args, - 'allow_nan_stats': self.allow_nan_stats, - 'always_yield_multivariate_normal': - self._always_yield_multivariate_normal + 'allow_nan_stats': self.allow_nan_stats } argument_dict.update(**kwargs) diff --git a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py index 4a2bc1ef4e..6fbe5396db 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py +++ b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py @@ -605,7 +605,6 @@ def precompute_regression_model( mean_fn=None, cholesky_fn=None, jitter=1e-6, - always_yield_multivariate_normal=False, validate_args=False, allow_nan_stats=False, name='PrecomputedGaussianProcessRegressionModel'): @@ -700,10 +699,6 @@ def precompute_regression_model( jitter: `float` scalar `Tensor` added to the diagonal of the covariance matrix to ensure positive definiteness of the covariance matrix. Default value: `1e-6`. - always_yield_multivariate_normal: If `False` (the default), we produce a - scalar `Normal` distribution when the number of `index_points` is - statically known to be `1`. If `True`, we avoid this behavior, ensuring - that the event shape will retain the `1` from `index_points`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect @@ -790,7 +785,6 @@ def conditional_mean_fn(x): predictive_noise_variance=predictive_noise_variance, cholesky_fn=cholesky_fn, jitter=jitter, - always_yield_multivariate_normal=always_yield_multivariate_normal, _conditional_kernel=conditional_kernel, _conditional_mean_fn=conditional_mean_fn, validate_args=validate_args, From 5e908fca569120401df3ace319f018094915c92a Mon Sep 17 00:00:00 2001 From: emilyaf Date: Tue, 5 Apr 2022 18:23:03 -0700 Subject: [PATCH 075/153] Enable JAX/Numpy support for AdditiveKernel. Minor fixes to avoid dtype/dynamic shape errors in JAX/Numpy backends. PiperOrigin-RevId: 439724658 --- .../python/distributions/multivariate_student_t.py | 3 ++- tensorflow_probability/python/experimental/psd_kernels/BUILD | 2 -- tensorflow_probability/python/math/psd_kernels/matern.py | 2 +- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/tensorflow_probability/python/distributions/multivariate_student_t.py b/tensorflow_probability/python/distributions/multivariate_student_t.py index adfbecd386..43097ff303 100644 --- a/tensorflow_probability/python/distributions/multivariate_student_t.py +++ b/tensorflow_probability/python/distributions/multivariate_student_t.py @@ -26,6 +26,7 @@ from tensorflow_probability.python.internal import distribution_util from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties +from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import reparameterization from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import tensor_util @@ -228,7 +229,7 @@ def _event_shape(self): return self.scale.range_dimension def _sample_shape(self): - return tf.concat([self.batch_shape_tensor(), self.event_shape_tensor()], -1) + return ps.concat([self.batch_shape_tensor(), self.event_shape_tensor()], -1) def _sample_n(self, n, seed=None): # Like with the univariate Student's t, sampling can be implemented as a diff --git a/tensorflow_probability/python/experimental/psd_kernels/BUILD b/tensorflow_probability/python/experimental/psd_kernels/BUILD index 753d119e67..2c6827d0ee 100644 --- a/tensorflow_probability/python/experimental/psd_kernels/BUILD +++ b/tensorflow_probability/python/experimental/psd_kernels/BUILD @@ -58,8 +58,6 @@ multi_substrate_py_test( name = "additive_kernel_test", size = "medium", srcs = ["additive_kernel_test.py"], - jax_tags = ["notap"], - numpy_tags = ["notap"], shard_count = 4, tags = ["tf1-broken"], deps = [ diff --git a/tensorflow_probability/python/math/psd_kernels/matern.py b/tensorflow_probability/python/math/psd_kernels/matern.py index 902458a435..648fb64a66 100644 --- a/tensorflow_probability/python/math/psd_kernels/matern.py +++ b/tensorflow_probability/python/math/psd_kernels/matern.py @@ -474,7 +474,7 @@ def _apply_with_distance( inverse_length_scale = util.pad_shape_with_ones( inverse_length_scale, ndims=example_ndims) norm = norm * inverse_length_scale - series_term = np.sqrt(5) * norm + series_term = tf.math.sqrt(tf.constant(5., dtype=norm.dtype)) * norm log_result = tf.math.log1p(series_term + series_term**2 / 3.) - series_term if self.amplitude is not None: From 913085acf56c19436ed59f863eb2985d973d90a5 Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Tue, 5 Apr 2022 19:50:34 -0700 Subject: [PATCH 076/153] Fix Softfloor docstring and bijector. - Fix docstring so that high temperatures reflect an identity mapping, and low temperatures reflect flooring. - Fix bijector so that it acts like the identity at high temperatures, instead of a shifted identity function. PiperOrigin-RevId: 439737159 --- .../python/bijectors/softfloor.py | 25 +++++++++++++------ .../python/bijectors/softfloor_test.py | 17 ++++++++++++- 2 files changed, 33 insertions(+), 9 deletions(-) diff --git a/tensorflow_probability/python/bijectors/softfloor.py b/tensorflow_probability/python/bijectors/softfloor.py index 2b409144de..9792cb3a2f 100644 --- a/tensorflow_probability/python/bijectors/softfloor.py +++ b/tensorflow_probability/python/bijectors/softfloor.py @@ -41,9 +41,10 @@ class Softfloor(bijector.AutoCompositeTensorBijector): This `Bijector` has the following properties: * This `Bijector` is a map between `R` to `R`. - * For `t` close to `0`, this bijector mimics the identity function. - * For `t` approaching `infinity`, this bijector converges pointwise + * For `t` close to `0`, this bijector converges pointwise to `tf.math.floor` (except at integer points). + * For `t` approaching `infinity`, this bijector mimics the identity + function. Note that for lower temperatures `t`, this bijector becomes more numerically unstable. In particular, the inverse for this bijector is not numerically @@ -149,7 +150,7 @@ def _forward(self, x): # the two endpoints will have the same value for derivatives. # The below calculations are just # (sigmoid((f - 0.5) / t) - sigmoid(-0.5 / t)) / - # (sigmoid(0.5 / t) - sigmoid(0.5 / t)) + # (sigmoid(0.5 / t) - sigmoid(-0.5 / t)) # We use log_sum_exp and log_sub_exp to make this calculation more # numerically stable. @@ -169,7 +170,11 @@ def _forward(self, x): log_denominator, tfp_math.log_sub_exp(tf.ones([], self.dtype) / t, one_half / t)) rescaled_part = tf.math.exp(log_numerator - log_denominator) - return integer_part + rescaled_part + # We add a term sigmoid(0.5 / t). When t->infinity, this will be 0.5, + # which will correctly shift the function so that this acts like the + # identity. When t->0, this will approach 0, so that the function + # correctly approximates a floor function. + return integer_part + rescaled_part + tf.math.sigmoid(-0.5 / t) def _inverse(self, y): # We undo the transformation from [0, 1] -> [0, 1]. @@ -196,10 +201,14 @@ def _inverse(self, y): tf.equal(fractional_part, 0.), one_half / t, log_denominator) - new_fractional_part = (t * (log_numerator - log_denominator) + one_half) - # We finally shift this up since the original transformation was from - # [0.5, 1.5] to [0, 1]. - new_fractional_part = new_fractional_part + one_half + # The result should be t * log(a / b) + 0.5. We shift this up by 0.5 + # since the original transformation was from [0.5, 1.5] to [0, 1]. + # Finally we subtract of sigmoid(-0.5 / t) to invert the forward + # transformation so that this acts like the identity. We can take advantage + # of 1 - sigmoid(-0.5 / t) = sigmoid(0.5 / t). + + new_fractional_part = ( + t * (log_numerator - log_denominator) + tf.math.sigmoid(0.5 / t)) return tf.math.floor(y) + new_fractional_part def _forward_log_det_jacobian(self, x): diff --git a/tensorflow_probability/python/bijectors/softfloor_test.py b/tensorflow_probability/python/bijectors/softfloor_test.py index fd52ea4087..b635c12f7e 100644 --- a/tensorflow_probability/python/bijectors/softfloor_test.py +++ b/tensorflow_probability/python/bijectors/softfloor_test.py @@ -47,7 +47,7 @@ def setUp(self): def testBijectorApproximatesFloorLowTemperature(self): # Let's make this look floor. floor = tfb.Softfloor(self.dtype(1e-4)) - # We chose a high temperature, and truncated range so that + # We chose a low temperature, and truncated range so that # we are likely to be retrieving 2. pos_values = np.linspace(2.01, 2.99, 100).astype(self.dtype) neg_values = np.linspace(-2.99, -2.01, 100).astype(self.dtype) @@ -58,6 +58,21 @@ def testBijectorApproximatesFloorLowTemperature(self): self.evaluate(floor.forward(neg_values)), np.floor(neg_values)) + def testBijectorApproximatesIdentityHighTemperature(self): + # Let's make this look like the identity. + floor = tfb.Softfloor(self.dtype(1e4)) + pos_values = np.linspace(2.01, 2.99, 100).astype(self.dtype) + neg_values = np.linspace(-2.99, -2.01, 100).astype(self.dtype) + self.assertAllClose( + self.evaluate(floor.forward(pos_values)), pos_values, rtol=1e-5) + self.assertAllClose( + self.evaluate(floor.forward(neg_values)), neg_values, rtol=1e-5) + + self.assertAllClose( + self.evaluate(floor.inverse(pos_values)), pos_values, rtol=5e-4) + self.assertAllClose( + self.evaluate(floor.inverse(neg_values)), neg_values, rtol=5e-4) + def testBijectorEndpointsAtLimit(self): # Check that we don't get NaN at half-integer and the floor matches. floor = tfb.Softfloor(self.dtype(1e-5)) From 1dea11db046c46bd353ea170649ff23421657169 Mon Sep 17 00:00:00 2001 From: emilyaf Date: Tue, 5 Apr 2022 22:35:10 -0700 Subject: [PATCH 077/153] Fix CompositeTensor behavior for tfd.GaussianProcess. PiperOrigin-RevId: 439757342 --- .../python/distributions/BUILD | 3 ++ .../python/distributions/gaussian_process.py | 37 +++++++++++++++++-- .../gaussian_process_regression_model.py | 5 ++- .../distributions/gaussian_process_test.py | 25 +++++++++++++ .../variational_gaussian_process.py | 4 +- 5 files changed, 69 insertions(+), 5 deletions(-) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index f38fc43e3a..83840f4c83 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -728,6 +728,7 @@ multi_substrate_py_library( # numpy dep, # tensorflow dep, "//tensorflow_probability/python/bijectors:identity", + "//tensorflow_probability/python/internal:auto_composite_tensor", "//tensorflow_probability/python/internal:distribution_util", "//tensorflow_probability/python/internal:dtype_util", "//tensorflow_probability/python/internal:prefer_static", @@ -743,6 +744,7 @@ multi_substrate_py_library( srcs = ["gaussian_process_regression_model.py"], deps = [ ":cholesky_util", + ":distribution", ":gaussian_process", # tensorflow dep, "//tensorflow_probability/python/internal:distribution_util", @@ -2219,6 +2221,7 @@ multi_substrate_py_library( name = "variational_gaussian_process", srcs = ["variational_gaussian_process.py"], deps = [ + ":distribution", ":gaussian_process", ":independent", ":kullback_leibler", diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index 67ce1ed565..9cec69e21f 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -27,6 +27,7 @@ from tensorflow_probability.python.distributions import kullback_leibler from tensorflow_probability.python.distributions import mvn_linear_operator from tensorflow_probability.python.distributions import normal +from tensorflow_probability.python.internal import auto_composite_tensor from tensorflow_probability.python.internal import distribution_util from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties @@ -84,7 +85,8 @@ def marginal_fn( return marginal_fn -class GaussianProcess(distribution.AutoCompositeTensorDistribution): +class GaussianProcess( + distribution.Distribution, tf.__internal__.CompositeTensor): """Marginal distribution of a Gaussian process at finitely many points. A Gaussian process (GP) is an indexed collection of random variables, any @@ -237,6 +239,7 @@ def optimize(): ``` """ + # pylint:disable=invalid-name @deprecation.deprecated_args( '2021-05-10', @@ -254,7 +257,8 @@ def __init__(self, validate_args=False, allow_nan_stats=False, parameters=None, - name='GaussianProcess'): + name='GaussianProcess', + _check_marginal_cholesky_fn=True): """Instantiate a GaussianProcess Distribution. Args: @@ -312,6 +316,7 @@ def __init__(self, parameters: For subclasses, a dict of constructor arguments. name: Python `str` name prefixed to Ops created by this class. Default value: "GaussianProcess". + _check_marginal_cholesky_fn: Internal parameter -- do not use. Raises: ValueError: if `mean_fn` is not `None` and is not callable. @@ -347,7 +352,8 @@ def __init__(self, self._jitter = jitter self._cholesky_fn = cholesky_fn - if marginal_fn is not None and cholesky_fn is not None: + if (_check_marginal_cholesky_fn and + marginal_fn is not None and cholesky_fn is not None): raise ValueError( 'At most one of `marginal_fn` and `cholesky_fn` should be set.') if marginal_fn is None: @@ -367,6 +373,7 @@ def __init__(self, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name) + # pylint:enable=invalid-name def _is_univariate_marginal(self, index_points): """True if the given index_points would yield a univariate marginal. @@ -743,6 +750,30 @@ def posterior_predictive( return gprm.GaussianProcessRegressionModel.precompute_regression_model( **argument_dict) + @property + def _type_spec(self): + return _GaussianProcessTypeSpec.from_instance( + self, + omit_kwargs=('parameters', '_check_marginal_cholesky_fn'), + non_identifying_kwargs=('name',)) + + +@auto_composite_tensor.type_spec_register( + 'tfp.distributions.GaussianProcess_ACTTypeSpec') +class _GaussianProcessTypeSpec( + auto_composite_tensor._AutoCompositeTensorTypeSpec): # pylint: disable=protected-access + """TypeSpec for GaussianProcess.""" + + @property + def value_type(self): + return GaussianProcess + + def _from_components(self, components): + # Disable the check that at most one of `marginal_fn` and `cholesky_fn` is + # passed to the constructor, since both may have been set internally. + components['_check_marginal_cholesky_fn'] = False + return super(_GaussianProcessTypeSpec, self)._from_components(components) + def _assert_kl_compatible(marginal, other): if ((isinstance(marginal, normal.Normal) and diff --git a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py index 6fbe5396db..b0592f9fbb 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py +++ b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py @@ -21,6 +21,7 @@ from tensorflow_probability.python.bijectors import softplus as softplus_bijector from tensorflow_probability.python.distributions import cholesky_util +from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.distributions import gaussian_process from tensorflow_probability.python.internal import batch_shape_lib from tensorflow_probability.python.internal import dtype_util @@ -103,7 +104,9 @@ def _validate_observation_data( index_point_count, observation_count)) -class GaussianProcessRegressionModel(gaussian_process.GaussianProcess): +class GaussianProcessRegressionModel( + gaussian_process.GaussianProcess, + distribution.AutoCompositeTensorDistribution): """Posterior predictive distribution in a conjugate GP regression model. This class represents the distribution over function values at a set of points diff --git a/tensorflow_probability/python/distributions/gaussian_process_test.py b/tensorflow_probability/python/distributions/gaussian_process_test.py index bb70a35b6d..dbc7a82c67 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_test.py +++ b/tensorflow_probability/python/distributions/gaussian_process_test.py @@ -418,6 +418,31 @@ def testAlwaysYieldMultivariateNormal(self): self.assertAllEqual([5], self.evaluate(gp.batch_shape_tensor())) self.assertAllEqual([1], self.evaluate(gp.event_shape_tensor())) + @test_util.disable_test_for_backend( + disable_numpy=True, disable_jax=True, + reason="Numpy and JAX have no notion of CompositeTensor.") + def testCompositeTensor(self): + index_points = np.random.uniform(-1., 1., 10)[..., np.newaxis] + gp = tfd.GaussianProcess( + kernel=psd_kernels.ExponentiatedQuadratic(), + index_points=index_points) + + flat = tf.nest.flatten(gp, expand_composites=True) + unflat = tf.nest.pack_sequence_as( + gp, flat, expand_composites=True) + self.assertIsInstance(unflat, tfd.GaussianProcess) + + x = self.evaluate(gp.sample(3, seed=test_util.test_seed())) + actual = self.evaluate(gp.log_prob(x)) + + self.assertAllClose(self.evaluate(unflat.log_prob(x)), actual) + + @tf.function + def call_log_prob(d): + return d.log_prob(x) + self.assertAllClose(actual, call_log_prob(gp)) + self.assertAllClose(actual, call_log_prob(unflat)) + @test_util.test_all_tf_execution_regimes class GaussianProcessStaticTest(_GaussianProcessTest, test_util.TestCase): diff --git a/tensorflow_probability/python/distributions/variational_gaussian_process.py b/tensorflow_probability/python/distributions/variational_gaussian_process.py index 59bd561f00..48478e8577 100644 --- a/tensorflow_probability/python/distributions/variational_gaussian_process.py +++ b/tensorflow_probability/python/distributions/variational_gaussian_process.py @@ -20,6 +20,7 @@ from tensorflow_probability.python import util as tfp_util from tensorflow_probability.python.bijectors import fill_scale_tril as fill_scale_tril_bijector from tensorflow_probability.python.bijectors import softplus as softplus_bijector +from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.distributions import gaussian_process from tensorflow_probability.python.distributions import independent from tensorflow_probability.python.distributions import kullback_leibler @@ -303,7 +304,8 @@ def _solve_cholesky_factored_system_vec(cholesky_factor, rhs, name=None): return lin_op.solvevec(lin_op.solvevec(rhs), adjoint=True) -class VariationalGaussianProcess(gaussian_process.GaussianProcess): +class VariationalGaussianProcess(gaussian_process.GaussianProcess, + distribution.AutoCompositeTensorDistribution): """Posterior predictive of a variational Gaussian process. This distribution implements the variational Gaussian process (VGP), as From 0ad3a84d36a086f58794e8da69d723b3877b0768 Mon Sep 17 00:00:00 2001 From: Adam Sorrenti Date: Wed, 6 Apr 2022 10:27:29 -0400 Subject: [PATCH 078/153] import tensorflow.compat.v2 Use compat v2 import similarly to other tfp notebooks E.g https://github.com/tensorflow/probability/blob/main/tensorflow_probability/examples/jupyter_notebooks/Structural_Time_Series_Modeling_Case_Studies_Atmospheric_CO2_and_Electricity_Demand.ipynb --- tensorflow_probability/g3doc/_index.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/g3doc/_index.ipynb b/tensorflow_probability/g3doc/_index.ipynb index 1ed7ba679e..9b111c8b45 100644 --- a/tensorflow_probability/g3doc/_index.ipynb +++ b/tensorflow_probability/g3doc/_index.ipynb @@ -113,10 +113,10 @@ }, "cell_type": "code", "source": [ - "import tensorflow as tf\n", + "import tensorflow.compat.v2 as tf\n", "import tensorflow_probability as tfp\n", "\n", - "tf.enable_eager_execution()\n", + "tf.enable_v2_behavior()\n", "\n", "print(tf.__version__)" ], From c45d8720ddada5f20ebddd78d550579f59e4cb6e Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Wed, 6 Apr 2022 10:19:03 -0700 Subject: [PATCH 079/153] Improve efficiency of Multi-task Gaussian Process in the presence of observation noise. - In the case of an Independent Kernel, this adds observation noise to the inner kernel matrix, and takes the cholesky (reducing naive O((NT)^3) time to O(N^3 + T^3) time where N is the number of data points, and T the number of tasks). - In the case of a Separable Kernel, this takes an eigendecomposition of the task and inner kernel matrix, reusing the eigenvectors / eigenvalues. This reduces time complexity also from O((NT)^3) time to O(N^3 + T^3) time. PiperOrigin-RevId: 439873869 --- .../python/experimental/BUILD | 1 - .../multitask_gaussian_process.py | 90 +++++++++++-- .../multitask_gaussian_process_test.py | 103 ++++++++++++++- .../python/experimental/linalg/BUILD | 37 +++++- .../python/experimental/linalg/__init__.py | 2 + .../linalg/linear_operator_unitary.py | 123 ++++++++++++++++++ .../linalg/linear_operator_unitary_test.py | 93 +++++++++++++ 7 files changed, 433 insertions(+), 16 deletions(-) create mode 100644 tensorflow_probability/python/experimental/linalg/linear_operator_unitary.py create mode 100644 tensorflow_probability/python/experimental/linalg/linear_operator_unitary_test.py diff --git a/tensorflow_probability/python/experimental/BUILD b/tensorflow_probability/python/experimental/BUILD index ff5dd1701e..cc42b64c57 100644 --- a/tensorflow_probability/python/experimental/BUILD +++ b/tensorflow_probability/python/experimental/BUILD @@ -37,7 +37,6 @@ multi_substrate_py_library( ], substrates_omit_deps = [ "//tensorflow_probability/python/experimental/auto_batching", - "//tensorflow_probability/python/experimental/linalg", "//tensorflow_probability/python/experimental/marginalize", "//tensorflow_probability/python/experimental/nn", "//tensorflow_probability/python/experimental/sts_gibbs", diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py index 39dc181aca..7d65a69678 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py @@ -24,6 +24,7 @@ from tensorflow_probability.python.distributions import cholesky_util from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.distributions import mvn_linear_operator +from tensorflow_probability.python.experimental.linalg import linear_operator_unitary from tensorflow_probability.python.experimental.psd_kernels import multitask_kernel from tensorflow_probability.python.internal import distribution_util from tensorflow_probability.python.internal import dtype_util @@ -192,13 +193,81 @@ def _event_shape_tensor(self, index_points=None): [ps.shape(index_points)[-(self.kernel.feature_ndims + 1)]], [self.kernel.num_tasks]], axis=0) - def _compute_flattened_covariance(self, index_points=None): + def _compute_flattened_scale(self, index_points=None): # This is of shape KN x KN, where K is the number of outputs index_points = self._get_index_points(index_points) kernel_matrix = self.kernel.matrix_over_all_tasks( index_points, index_points) if self.observation_noise_variance is None: - return kernel_matrix + return cholesky_util.cholesky_from_fn(kernel_matrix, self._cholesky_fn) + + # We can add the observation noise to each block. + if isinstance(self.kernel, multitask_kernel.Independent): + # The Independent kernel matrix is realized as a kronecker product of the + # kernel over inputs, and an identity matrix per task (representing + # independent tasks). Update the diagonal of the first matrix and take the + # cholesky of it (since the cholesky of the second matrix will remain the + # identity matrix.) + base_kernel_matrix = kernel_matrix.operators[0].to_dense() + + broadcast_shape = distribution_util.get_broadcast_shape( + base_kernel_matrix, + self.observation_noise_variance[..., tf.newaxis, tf.newaxis]) + base_kernel_matrix = tf.broadcast_to(base_kernel_matrix, broadcast_shape) + base_kernel_matrix = tf.linalg.set_diag( + base_kernel_matrix, + tf.linalg.diag_part(base_kernel_matrix) + + self.observation_noise_variance[..., tf.newaxis]) + base_kernel_matrix = tf.linalg.LinearOperatorFullMatrix( + base_kernel_matrix) + kernel_matrix = tf.linalg.LinearOperatorKronecker( + operators=[base_kernel_matrix] + kernel_matrix.operators[1:]) + return cholesky_util.cholesky_from_fn(kernel_matrix, self._cholesky_fn) + + if isinstance(self.kernel, multitask_kernel.Separable): + # When `kernel_matrix` is a kronecker product, we can compute + # an eigenvalue decomposition to get a matrix square-root, which will + # be faster than densifying the kronecker product. + + # Let K = A X B. Let A (and B) have an eigenvalue decomposition of + # U @ D @ U^T, where U is an orthogonal matrix. Then, + # K = (U_A @ D_A @ U_A^T) X (U_B @ D_B @ U_B^T) = + # (U_A X U_B) @ (D_A X D_B) @ (U_A X U_B)^T + # Thus, a matrix square root of K would be + # (U_A X U_B) @ (sqrt(D_A) X sqrt(D_B)) which offers + # efficient matmul and solves. + + # Now, if we update the diagonal by `v * I`, we have + # (U_A X U_B) @ (sqrt((D_A X D_B + vI)) @ (U_A X U_B)^T + # which still admits an efficient matmul and solve. + + kronecker_diags = [] + kronecker_orths = [] + for block in kernel_matrix.operators: + diag, orth = tf.linalg.eigh(block.to_dense()) + kronecker_diags.append(tf.linalg.LinearOperatorDiag(diag)) + kronecker_orths.append( + linear_operator_unitary.LinearOperatorUnitary(orth)) + + full_diag = tf.linalg.LinearOperatorKronecker(kronecker_diags).diag_part() + full_diag = full_diag + self.observation_noise_variance[..., tf.newaxis] + scale_diag = tf.math.sqrt(full_diag) + diag_operator = tf.linalg.LinearOperatorDiag( + scale_diag, + is_square=True, + is_non_singular=True, + is_positive_definite=True) + + orthogonal_operator = tf.linalg.LinearOperatorKronecker( + kronecker_orths, is_square=True, is_non_singular=True) + # This is efficient as a scale matrix. When used for matmuls, we take + # advantage of the kronecker product and diagonal operator. When used for + # solves, we take advantage of the orthogonal and diagonal structure, + # which essentially reduces to the matmul case. + return orthogonal_operator.matmul(diag_operator) + + # By default densify the kernel matrix and add noise. + kernel_matrix = kernel_matrix.to_dense() broadcast_shape = distribution_util.get_broadcast_shape( kernel_matrix, @@ -208,26 +277,21 @@ def _compute_flattened_covariance(self, index_points=None): kernel_matrix, tf.linalg.diag_part(kernel_matrix) + self.observation_noise_variance[..., tf.newaxis]) - kernel_matrix = tf.linalg.LinearOperatorFullMatrix( - kernel_matrix, - is_non_singular=True, - is_positive_definite=True) - return kernel_matrix + kernel_matrix = tf.linalg.LinearOperatorFullMatrix(kernel_matrix) + kernel_cholesky = cholesky_util.cholesky_from_fn( + kernel_matrix, self._cholesky_fn) + return kernel_cholesky def _get_flattened_marginal_distribution(self, index_points=None): # This returns a MVN of event size [N * E], where N is the number of tasks # and E is the number of index points. with self._name_and_control_scope('get_flattened_marginal_distribution'): index_points = self._get_index_points(index_points) - covariance = self._compute_flattened_covariance(index_points) + scale = self._compute_flattened_scale(index_points) batch_shape = self._batch_shape_tensor(index_points=index_points) event_shape = self._event_shape_tensor(index_points=index_points) - # Now take the cholesky but specialize to cases where we have block-diag - # and kronecker. - covariance_cholesky = cholesky_util.cholesky_from_fn( - covariance, self._cholesky_fn) loc = self._mean_fn(index_points) # Ensure that we broadcast the mean function result to ensure we support # constant mean functions (constant over all tasks, and a constant @@ -237,7 +301,7 @@ def _get_flattened_marginal_distribution(self, index_points=None): loc = _vec(loc) return mvn_linear_operator.MultivariateNormalLinearOperator( loc=loc, - scale=covariance_cholesky, + scale=scale, validate_args=self._validate_args, allow_nan_stats=self._allow_nan_stats, name='marginal_distribution') diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py index ea9fe5cf6e..9b978bf4dd 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py @@ -26,12 +26,65 @@ import tensorflow_probability as tfp from tensorflow_probability.python import experimental as tfe +from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import parameter_properties +from tensorflow_probability.python.internal import tensor_util from tensorflow_probability.python.internal import test_util tfd = tfp.distributions tfk = tfp.math.psd_kernels +class InefficientSeparable(tfe.psd_kernels.MultiTaskKernel): + """A version of the Separable kernel that's inefficient.""" + + def __init__(self, + num_tasks, + base_kernel, + task_kernel_matrix_linop, + name='InefficientSeparable', + validate_args=False): + + parameters = dict(locals()) + with tf.name_scope(name): + dtype = dtype_util.common_dtype( + [task_kernel_matrix_linop, base_kernel], tf.float32) + self._base_kernel = base_kernel + self._task_kernel_matrix_linop = tensor_util.convert_nonref_to_tensor( + task_kernel_matrix_linop, dtype, name='task_kernel_matrix_linop') + super(InefficientSeparable, self).__init__( + num_tasks=num_tasks, + dtype=dtype, + feature_ndims=base_kernel.feature_ndims, + name=name, + validate_args=validate_args, + parameters=parameters) + + @property + def base_kernel(self): + return self._base_kernel + + @property + def task_kernel_matrix_linop(self): + return self._task_kernel_matrix_linop + + @classmethod + def _parameter_properties(cls, dtype, num_classes=None): + return dict( + base_kernel=parameter_properties.BatchedComponentProperties(), + task_kernel_matrix_linop=( + parameter_properties.BatchedComponentProperties())) + + def _matrix_over_all_tasks(self, x1, x2): + # Because the kernel computations are independent of task, + # we can use a Kronecker product of an identity matrix. + base_kernel_matrix = tf.linalg.LinearOperatorFullMatrix( + self.base_kernel.matrix(x1, x2)) + operator = tf.linalg.LinearOperatorKronecker( + [base_kernel_matrix, self._task_kernel_matrix_linop]) + return tf.linalg.LinearOperatorFullMatrix(operator.to_dense()) + + @test_util.test_all_tf_execution_regimes class MultiTaskGaussianProcessTest(test_util.TestCase): @@ -253,10 +306,58 @@ def sample_no_noise(): self.assertAllEqual(log_prob_no_noise(observations).shape, [2, 4, 1, 6]) self.assertAllEqual(sample_no_noise().shape, [2, 4, 1, 6, 25, 3]) + def testMultiTaskBlockSeparable(self): + # Check that the naive implementation matches any optimizations for a + # Separable Kernel. + + # 5x5 grid of index points in R^2 and flatten to 25x2 + index_points = np.linspace(-10., 10., 5, dtype=np.float64) + index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) + index_points = np.reshape(index_points, [-1, 2]) + # ==> shape = [25, 2] + + # Kernel with batch_shape [2, 4, 3, 1] + amplitude = np.array([1., 2.], np.float64).reshape([2, 1, 1, 1]) + length_scale = np.array([1., 2., 3., 4.], np.float64).reshape([1, 4, 1, 1]) + observation_noise_variance = np.array( + [1e-3, 1e-2, 1e-1], np.float64).reshape([1, 1, 3, 1]) + batched_index_points = np.stack([index_points]*6) + # ==> shape = [6, 25, 2] + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + # Ensure Symmetric + Strictly Diagonally Dominant -> Positive Definite. + task_kernel_matrix = np.array([[6., 2., 3.], + [2., 7., 4.], + [3., 4., 8.]], + dtype=np.float64) + task_kernel_matrix_linop = tf.linalg.LinearOperatorFullMatrix( + task_kernel_matrix) + multi_task_kernel = tfe.psd_kernels.Separable( + num_tasks=3, task_kernel_matrix_linop=task_kernel_matrix_linop, + base_kernel=kernel) + multitask_gp = tfe.distributions.MultiTaskGaussianProcess( + multi_task_kernel, + batched_index_points, + observation_noise_variance=observation_noise_variance, + validate_args=True) + naive_multi_task_kernel = InefficientSeparable( + num_tasks=3, task_kernel_matrix_linop=task_kernel_matrix_linop, + base_kernel=kernel) + actual_multitask_gp = tfe.distributions.MultiTaskGaussianProcess( + naive_multi_task_kernel, + batched_index_points, + observation_noise_variance=observation_noise_variance, + validate_args=False) + + observations = np.linspace(-20., 20., 75).reshape(25, 3).astype(np.float64) + multitask_log_prob = multitask_gp.log_prob(observations) + actual_multitask_log_prob = actual_multitask_gp.log_prob(observations) + self.assertAllClose( + self.evaluate(actual_multitask_log_prob), + self.evaluate(multitask_log_prob), rtol=4e-3) + def testLogProbMatchesGP(self): # Check that the independent kernel parameterization matches using a # single-task GP. - # 5x5 grid of index points in R^2 and flatten to 25x2 index_points = np.linspace(-4., 4., 5, dtype=np.float32) index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) diff --git a/tensorflow_probability/python/experimental/linalg/BUILD b/tensorflow_probability/python/experimental/linalg/BUILD index 98db379002..b5df0226f5 100644 --- a/tensorflow_probability/python/experimental/linalg/BUILD +++ b/tensorflow_probability/python/experimental/linalg/BUILD @@ -17,17 +17,28 @@ licenses(["notice"]) +load( + "//tensorflow_probability/python:build_defs.bzl", + "multi_substrate_py_library", + "multi_substrate_py_test", +) + package( default_visibility = [ "//tensorflow_probability:__subpackages__", ], ) -py_library( +multi_substrate_py_library( name = "linalg", srcs = ["__init__.py"], + substrates_omit_deps = [ + ":linear_operator_psd_kernel", + ":no_pivot_ldl", + ], deps = [ ":linear_operator_psd_kernel", + ":linear_operator_unitary", ":no_pivot_ldl", "//tensorflow_probability/python/internal:all_util", ], @@ -58,6 +69,30 @@ py_test( ], ) +multi_substrate_py_library( + name = "linear_operator_unitary", + srcs = ["linear_operator_unitary.py"], + deps = [ + # numpy dep, + # tensorflow dep, + "//tensorflow_probability/python/internal:dtype_util", + "//tensorflow_probability/python/internal:prefer_static", + "//tensorflow_probability/python/internal:tensor_util", + ], +) + +multi_substrate_py_test( + name = "linear_operator_unitary_test", + size = "small", + srcs = ["linear_operator_unitary_test.py"], + deps = [ + # numpy dep, + # tensorflow dep, + "//tensorflow_probability", + "//tensorflow_probability/python/internal:test_util", + ], +) + py_library( name = "no_pivot_ldl", srcs = ["no_pivot_ldl.py"], diff --git a/tensorflow_probability/python/experimental/linalg/__init__.py b/tensorflow_probability/python/experimental/linalg/__init__.py index e248522db9..2e1fea5c8f 100644 --- a/tensorflow_probability/python/experimental/linalg/__init__.py +++ b/tensorflow_probability/python/experimental/linalg/__init__.py @@ -15,6 +15,7 @@ """Experimental tools for linear algebra.""" from tensorflow_probability.python.experimental.linalg.linear_operator_psd_kernel import LinearOperatorPSDKernel +from tensorflow_probability.python.experimental.linalg.linear_operator_unitary import LinearOperatorUnitary from tensorflow_probability.python.experimental.linalg.no_pivot_ldl import no_pivot_ldl from tensorflow_probability.python.experimental.linalg.no_pivot_ldl import simple_robustified_cholesky from tensorflow_probability.python.internal import all_util @@ -22,6 +23,7 @@ _allowed_symbols = [ 'LinearOperatorPSDKernel', + 'LinearOperatorUnitary', 'no_pivot_ldl', 'simple_robustified_cholesky', ] diff --git a/tensorflow_probability/python/experimental/linalg/linear_operator_unitary.py b/tensorflow_probability/python/experimental/linalg/linear_operator_unitary.py new file mode 100644 index 0000000000..b8644df645 --- /dev/null +++ b/tensorflow_probability/python/experimental/linalg/linear_operator_unitary.py @@ -0,0 +1,123 @@ +# Copyright 2022 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""A kernel covariance matrix LinearOperator.""" + +import tensorflow.compat.v2 as tf + +from tensorflow_probability.python.internal import tensor_util + + +class LinearOperatorUnitary(tf.linalg.LinearOperator): + """Encapsulates a Unitary Linear Operator.""" + + def __init__(self, + matrix, + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=None, + name='LinearOperatorUnitary'): + r"""Initialize a `LinearOperatorUnitary`. + + A Unitary Operator is one for which U* = U^-1. That is, the inverse of this + operator is equivalent to the conjugate transpose of the operator. In the + case that this operator is of real dtype, this corresponds to an orthogonal + operator. + + This is useful as it reduces the complexity of `solve` to that of a + `matmul` with the transpose operator. + + Args: + matrix: Shape `[B1,...,Bb, N, N]` `Tensor` with `b >= 0` `N >= 0`. + The orthogonal matrix. + is_non_singular: Expect that this operator is non-singular. + is_self_adjoint: Expect that this operator is equal to its hermitian + transpose. If `diag.dtype` is real, this is auto-set to `True`. + is_positive_definite: Expect that this operator is positive definite, + meaning the quadratic form `x^H A x` has positive real part for all + nonzero `x`. Note that we do not require the operator to be + self-adjoint to be positive-definite. See: + https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices + is_square: Expect that this operator acts like square [batch] matrices. + name: A name for this `LinearOperator`. + """ + parameters = dict( + matrix=matrix, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + name=name + ) + + with tf.name_scope(name): + self._matrix = tensor_util.convert_nonref_to_tensor(matrix, name='matrix') + + if is_square is False: # pylint:disable=g-bool-id-comparison + raise ValueError('Unitary operators are square.') + is_square = True + + # Add checks for unitary matrix + if (self._matrix.shape[-1] is not None and + self._matrix.shape[-2] is not None): + if self._matrix.shape[-2] != self._matrix.shape[-1]: + raise ValueError( + 'Expected square matrix, got mismatched dimensions {} {}'.format( + self._matrix.shape[-2], self._matrix.shape[-1])) + + super(LinearOperatorUnitary, self).__init__( + dtype=self._matrix.dtype, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + parameters=parameters, + name=name) + + def _shape(self): + return self._matrix.shape + + def _shape_tensor(self): + return tf.shape(self._matrix) + + @property + def matrix(self): + return self._matrix + + def _matmul(self, x, adjoint=False, adjoint_arg=False): + return tf.linalg.matmul( + self._matrix, x, adjoint_a=adjoint, adjoint_b=adjoint_arg) + + def _solve(self, rhs, adjoint=False, adjoint_arg=False): + return tf.linalg.matmul( + self._matrix, rhs, adjoint_a=(not adjoint), adjoint_b=adjoint_arg) + + def _to_dense(self): + return self._matrix + + def _log_abs_determinant(self): + # A unitary operator has eigenvalues with unit norm, and hence log|det(U)| + # is 1. + return tf.zeros(shape=self.batch_shape_tensor(), dtype=self.dtype) + + def _cond(self): + return tf.ones(shape=self.batch_shape_tensor(), dtype=self.dtype) + + def _assert_non_singular(self): + return tf.no_op('assert_non_singular') + + @property + def _composite_tensor_fields(self): + return ('matrix',) diff --git a/tensorflow_probability/python/experimental/linalg/linear_operator_unitary_test.py b/tensorflow_probability/python/experimental/linalg/linear_operator_unitary_test.py new file mode 100644 index 0000000000..361117519e --- /dev/null +++ b/tensorflow_probability/python/experimental/linalg/linear_operator_unitary_test.py @@ -0,0 +1,93 @@ +# Copyright 2022 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Tests for Unitary linop.""" + + +# Dependency imports + +import tensorflow.compat.v2 as tf +import tensorflow_probability as tfp + +from tensorflow_probability.python.internal import test_util + + +@test_util.test_all_tf_execution_regimes +class LinearOperatorUnitaryTest(test_util.TestCase): + """Tests for tfp.experimental.linalg.LinearOperatorUnitary.""" + + def test_unitary_linop_raises_non_square(self): + with self.assertRaisesRegex(ValueError, 'Expected square matrix'): + x = tf.random.stateless_normal( + [12, 13], seed=test_util.test_seed(sampler_type='stateless')) + tfp.experimental.linalg.LinearOperatorUnitary(x) + + def test_shape(self): + x = tf.random.stateless_normal( + [5, 13, 13], seed=test_util.test_seed(sampler_type='stateless')) + q, _ = tf.linalg.qr(x) + operator = tfp.experimental.linalg.LinearOperatorUnitary(q) + self.assertEqual([5], operator.batch_shape) + + def test_log_det(self): + x = tf.random.stateless_normal( + [5, 13, 13], seed=test_util.test_seed(sampler_type='stateless')) + q, _ = tf.linalg.qr(x) + operator = tfp.experimental.linalg.LinearOperatorUnitary(q) + true_logdet, expected_logdet = self.evaluate([ + tf.linalg.slogdet(q)[1], operator.log_abs_determinant()]) + self.assertAllClose(expected_logdet, true_logdet) + + def test_matmul(self): + x = tf.random.stateless_normal( + [7, 1, 13, 13], seed=test_util.test_seed(sampler_type='stateless')) + q, _ = tf.linalg.qr(x) + operator = tfp.experimental.linalg.LinearOperatorUnitary(q) + y = tf.random.stateless_normal( + [13, 13], seed=test_util.test_seed(sampler_type='stateless')) + self.assertAllClose( + self.evaluate(tf.linalg.matmul(q, y)), + self.evaluate(operator.matmul(y))) + + self.assertAllClose( + self.evaluate(tf.linalg.matmul(q, y, adjoint_b=True)), + self.evaluate(operator.matmul(y, adjoint_arg=True))) + + self.assertAllClose( + self.evaluate(tf.linalg.matmul(q, y, adjoint_a=True)), + self.evaluate(operator.matmul(y, adjoint=True))) + + self.assertAllClose( + self.evaluate(tf.linalg.matmul(q, y, adjoint_a=True, adjoint_b=True)), + self.evaluate(operator.matmul(y, adjoint=True, adjoint_arg=True))) + + def test_solve(self): + x = tf.random.stateless_normal( + [7, 1, 13, 13], seed=test_util.test_seed(sampler_type='stateless')) + q, _ = tf.linalg.qr(x) + operator = tfp.experimental.linalg.LinearOperatorUnitary(q) + y = tf.random.stateless_normal( + [13, 3], seed=test_util.test_seed(sampler_type='stateless')) + broadcasted_y = tf.broadcast_to(y, [7, 1, 13, 3]) + self.assertAllClose( + self.evaluate(tf.linalg.solve(q, broadcasted_y)), + self.evaluate(operator.solve(y))) + + self.assertAllClose( + self.evaluate(tf.linalg.solve(q, broadcasted_y, adjoint=True)), + self.evaluate(operator.solve(y, adjoint=True))) + + +if __name__ == '__main__': + test_util.main() From 3911f4463cdcca6cc118633742430885fb0c88cb Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Thu, 7 Apr 2022 13:08:45 -0700 Subject: [PATCH 080/153] Use `parameter_properties` in `MultitaskGaussianProcessRegressionModel`. - Simplify batch shape inference as well as add `.batch_shape` impl. PiperOrigin-RevId: 440181592 --- .../python/distributions/gaussian_process.py | 13 +++++ .../gaussian_process_regression_model.py | 25 -------- ...itask_gaussian_process_regression_model.py | 58 ++++++++++++++----- ..._gaussian_process_regression_model_test.py | 2 + 4 files changed, 60 insertions(+), 38 deletions(-) diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index 9cec69e21f..8c78e26635 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -28,6 +28,7 @@ from tensorflow_probability.python.distributions import mvn_linear_operator from tensorflow_probability.python.distributions import normal from tensorflow_probability.python.internal import auto_composite_tensor +from tensorflow_probability.python.internal import batch_shape_lib from tensorflow_probability.python.internal import distribution_util from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties @@ -620,6 +621,18 @@ def _event_shape(self, index_points=None): return tf.TensorShape([None]) return shape + def _batch_shape(self, index_points=None): + kwargs = {} + if index_points is not None: + kwargs = {'index_points': index_points} + return batch_shape_lib.inferred_batch_shape(self, **kwargs) + + def _batch_shape_tensor(self, index_points=None): + kwargs = {} + if index_points is not None: + kwargs = {'index_points': index_points} + return batch_shape_lib.inferred_batch_shape_tensor(self, **kwargs) + def _sample_n(self, n, seed=None, index_points=None): return self.get_marginal_distribution(index_points).sample(n, seed=seed) diff --git a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py index b0592f9fbb..2ad12bf5af 100644 --- a/tensorflow_probability/python/distributions/gaussian_process_regression_model.py +++ b/tensorflow_probability/python/distributions/gaussian_process_regression_model.py @@ -14,8 +14,6 @@ # ============================================================================ """The GaussianProcessRegressionModel distribution class.""" -import functools - # Dependency imports import tensorflow.compat.v2 as tf @@ -23,7 +21,6 @@ from tensorflow_probability.python.distributions import cholesky_util from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.distributions import gaussian_process -from tensorflow_probability.python.internal import batch_shape_lib from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties from tensorflow_probability.python.internal import tensor_util @@ -837,25 +834,3 @@ def _parameter_properties(cls, dtype, num_classes=None): shape_fn=lambda sample_shape: sample_shape[:-1], default_constraining_bijector_fn=( lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) - - def _batch_shape_tensor(self, index_points=None): - kwargs = {} - if index_points is not None: - kwargs = {'index_points': index_points} - return batch_shape_lib.inferred_batch_shape_tensor(self, **kwargs) - - def _batch_shape(self, index_points=None): - index_points = ( - index_points if index_points is not None else self._index_points) - batch_shapes_of_components = [ - index_points.shape[:-(self.kernel.feature_ndims + 1)], - self.kernel.batch_shape, self.observation_noise_variance.shape - ] - if self.observations is not None: - num_obs = tf.compat.dimension_value(self.observations.shape[-1]) - # We only need to add observations, since observation_index_points - # is used in the SchurComplement kernel. - if num_obs is None or num_obs != 0: - batch_shapes_of_components.append(self.observations.shape[:-1]) - return functools.reduce( - tf.broadcast_static_shape, batch_shapes_of_components) diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py index 60e44ba414..3c5f8a1c15 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py @@ -18,17 +18,18 @@ from __future__ import division from __future__ import print_function -import functools - # Dependency imports import tensorflow.compat.v2 as tf +from tensorflow_probability.python.bijectors import softplus as softplus_bijector from tensorflow_probability.python.distributions import cholesky_util from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.distributions import mvn_linear_operator from tensorflow_probability.python.experimental.psd_kernels import multitask_kernel +from tensorflow_probability.python.internal import batch_shape_lib from tensorflow_probability.python.internal import distribution_util from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import parameter_properties from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import reparameterization from tensorflow_probability.python.internal import tensor_util @@ -316,6 +317,36 @@ def predictive_noise_variance(self): def cholesky_fn(self): return self._cholesky_fn + @classmethod + def _parameter_properties(cls, dtype, num_classes=None): + return dict( + index_points=parameter_properties.ParameterProperties( + event_ndims=lambda self: self.kernel.feature_ndims + 1, + shape_fn=parameter_properties.SHAPE_FN_NOT_IMPLEMENTED, + ), + observations=parameter_properties.ParameterProperties( + event_ndims=2, + shape_fn=parameter_properties.SHAPE_FN_NOT_IMPLEMENTED), + observation_index_points=parameter_properties.ParameterProperties( + event_ndims=lambda self: self.kernel.feature_ndims + 1, + shape_fn=parameter_properties.SHAPE_FN_NOT_IMPLEMENTED, + ), + observations_is_missing=parameter_properties.ParameterProperties( + event_ndims=2, + shape_fn=parameter_properties.SHAPE_FN_NOT_IMPLEMENTED, + ), + kernel=parameter_properties.BatchedComponentProperties(), + observation_noise_variance=parameter_properties.ParameterProperties( + event_ndims=0, + shape_fn=lambda sample_shape: sample_shape[:-1], + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), + predictive_noise_variance=parameter_properties.ParameterProperties( + event_ndims=0, + shape_fn=lambda sample_shape: sample_shape[:-1], + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) + def _event_shape(self): # The examples index is one position to the left of the feature dims. index_points = self.index_points @@ -332,17 +363,6 @@ def _event_shape(self): [self.kernel.num_tasks]) return shape - def _batch_shape_tensor(self, index_points=None): - index_points = self._get_index_points(index_points) - return functools.reduce(ps.broadcast_shape, [ - ps.shape( - self.observation_index_points)[:-(self.kernel.feature_ndims + 1)], - ps.shape(index_points)[:-(self.kernel.feature_ndims + 1)], - self.kernel.batch_shape_tensor(), - ps.shape(self.observations)[:-2], - ps.shape(self.observation_noise_variance) - ]) - def _event_shape_tensor(self, index_points=None): index_points = self._get_index_points(index_points) return tf.concat( @@ -350,6 +370,18 @@ def _event_shape_tensor(self, index_points=None): [self.kernel.num_tasks]], axis=0) + def _batch_shape(self, index_points=None): + kwargs = {} + if index_points is not None: + kwargs = {'index_points': index_points} + return batch_shape_lib.inferred_batch_shape(self, **kwargs) + + def _batch_shape_tensor(self, index_points=None): + kwargs = {} + if index_points is not None: + kwargs = {'index_points': index_points} + return batch_shape_lib.inferred_batch_shape_tensor(self, **kwargs) + def _compute_flattened_covariance(self, index_points=None): # This is of shape KN x KN, where K is the number of outputs # Compute this explicitly via the Schur Complement of the vector kernel. diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py index 75c77d1370..6928f5ab0d 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py @@ -95,6 +95,8 @@ def testShapes(self, num_tasks): samples = gp.sample(sample_shape, seed=test_util.test_seed()) + self.assertAllEqual(gp.batch_shape, batch_shape) + self.assertAllEqual(gp.event_shape, event_shape) self.assertAllEqual(self.evaluate(gp.batch_shape_tensor()), batch_shape) self.assertAllEqual(self.evaluate(gp.event_shape_tensor()), event_shape) self.assertAllEqual( From fe09323881fff1662f1e597b1bb19f27df7bffb7 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Fri, 8 Apr 2022 11:29:04 -0700 Subject: [PATCH 081/153] Use square root of inverse variance for precision factor. PiperOrigin-RevId: 440413322 --- .../python/experimental/sts_gibbs/spike_and_slab.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index c08d4edf26..e530ed8ddc 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -551,9 +551,11 @@ def posterior_jd(): # Note that the posterior precision varies inversely with the # noise variance: in worlds with high noise we're also # more uncertain about the values of the weights. + # TODO(colcarroll): Tests pass even without a square root on the + # observation_noise_variance. Should add a test that would fail. precision_factor=tf.linalg.LinearOperatorLowerTriangular( sampler_state.conditional_posterior_precision_chol / - observation_noise_variance[..., tf.newaxis, tf.newaxis]), + tf.sqrt(observation_noise_variance[..., tf.newaxis, tf.newaxis])), nonzeros=sampler_state.nonzeros, name='weights') From 4e686e560562c008eae4a392a4267444035fe387 Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Fri, 8 Apr 2022 16:32:00 -0300 Subject: [PATCH 082/153] Fix operations applied to shapes --- .../python/distributions/two_piece_normal.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tensorflow_probability/python/distributions/two_piece_normal.py b/tensorflow_probability/python/distributions/two_piece_normal.py index 570ca1e78d..48e2f3d35b 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal.py +++ b/tensorflow_probability/python/distributions/two_piece_normal.py @@ -601,11 +601,11 @@ def _two_piece_normal_sample_bwd(_, aux, dy): grad = dy * _two_piece_normal_sample_gradient(broadcast_skewness, samples) # Sum over the sample dimensions. Assume that they are always the first # ones. - num_sample_dimensions = (tf.rank(broadcast_skewness) - - tf.rank(skewness)) + num_sample_dimensions = (ps.rank(broadcast_skewness) - + ps.rank(skewness)) # None gradients for seed - return tf.reduce_sum(grad, axis=tf.range(num_sample_dimensions)), None + return tf.reduce_sum(grad, axis=ps.range(num_sample_dimensions)), None def _two_piece_normal_sample_jvp(shape, primals, tangents): From 9d7389099b9139c01c37a1506ef6c6f689125a82 Mon Sep 17 00:00:00 2001 From: Leandro Campos <15185896+leandrolcampos@users.noreply.github.com> Date: Fri, 8 Apr 2022 17:26:01 -0300 Subject: [PATCH 083/153] Add nonlinearities --- .../distributions/two_piece_normal_test.py | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/tensorflow_probability/python/distributions/two_piece_normal_test.py b/tensorflow_probability/python/distributions/two_piece_normal_test.py index f5cb7747a5..48f06513bd 100644 --- a/tensorflow_probability/python/distributions/two_piece_normal_test.py +++ b/tensorflow_probability/python/distributions/two_piece_normal_test.py @@ -356,16 +356,16 @@ def testDifferentiableSampleNumerically(self): sample_shape = [int(2e5)] seed = test_util.test_seed() - def sampler(skewness): + def get_abs_sample_mean(skewness): loc = tf.constant(0., self.dtype) scale = tf.constant(1., self.dtype) dist = tfd.TwoPieceNormal( loc, scale=scale, skewness=skewness, validate_args=True) - return tf.reduce_mean(dist.sample(sample_shape, seed=seed)) + return tf.reduce_mean(tf.abs(dist.sample(sample_shape, seed=seed))) for skewness in [0.75, 1., 1.33]: err = self.compute_max_gradient_error( - sampler, [tf.constant(skewness, self.dtype)], delta=0.1) + get_abs_sample_mean, [tf.constant(skewness, self.dtype)], delta=0.1) self.assertLess(err, 0.05) @test_util.numpy_disable_gradient_test @@ -385,16 +385,18 @@ def testDifferentiableSampleAnalytically(self): seed = test_util.test_seed() - def sampler(loc, scale): + def get_exp_samples(loc, scale): dist = tfd.TwoPieceNormal( loc=loc, scale=scale, skewness=skewness, validate_args=True) - return dist.sample(sample_shape, seed=seed) + return tf.math.exp(dist.sample(sample_shape, seed=seed)) - samples, dsamples = tfp.math.value_and_gradient(sampler, [loc, scale]) + exp_samples, dsamples = tfp.math.value_and_gradient( + get_exp_samples, [loc, scale]) dloc_auto, dscale_auto = [grad / n_samples for grad in dsamples] - dloc_calc = tf.ones([n_params], dtype=self.dtype) - dscale_calc = tf.reduce_mean((samples - loc) / scale, axis=[0, 1]) + dloc_calc = tf.reduce_mean(exp_samples, axis=[0, 1]) + dscale_calc = tf.reduce_mean( + (tf.math.log(exp_samples) - loc) / scale * exp_samples, axis=[0, 1]) self.assertAllClose(dloc_auto, dloc_calc) self.assertAllClose(dscale_auto, dscale_calc) From bd74bdfc333c43a1d2a684ad63855d749c33fbd4 Mon Sep 17 00:00:00 2001 From: phawkins Date: Fri, 8 Apr 2022 13:30:47 -0700 Subject: [PATCH 084/153] [JAX] Add an MHLO lowering rule to Oryx. PiperOrigin-RevId: 440440530 --- spinoffs/oryx/oryx/core/primitive.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/spinoffs/oryx/oryx/core/primitive.py b/spinoffs/oryx/oryx/core/primitive.py index b5ba7f1561..edf2451fc1 100644 --- a/spinoffs/oryx/oryx/core/primitive.py +++ b/spinoffs/oryx/oryx/core/primitive.py @@ -25,6 +25,7 @@ from jax import util as jax_util from jax.interpreters import ad from jax.interpreters import batching +from jax.interpreters import mlir from jax.interpreters import partial_eval as pe from jax.interpreters import xla from jax.lib import xla_client as xc @@ -161,6 +162,12 @@ def _xla(c, *xla_args, **params): xla.translations[self] = _xla + def _mlir(c, *mlir_args, **params): + lowering = mlir.lower_fun(self.impl, multiple_results=True) + return lowering(c, *mlir_args, **params) + + mlir.register_lowering(self, _mlir) + def call_bind(prim, **params): """Binds a primitive to a function call.""" From f81ed49135b15188af898c61fc52f5e70a58d1df Mon Sep 17 00:00:00 2001 From: colcarroll Date: Mon, 11 Apr 2022 11:33:34 -0700 Subject: [PATCH 085/153] Retain shape information through a reduce_sum. PiperOrigin-RevId: 440949677 --- .../python/experimental/sts_gibbs/spike_and_slab.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index e530ed8ddc..a0346e486b 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -646,6 +646,7 @@ def _symmetric_update_chol(chol, idx, value): """Sets the value of a row and column in a Cholesky-factorized matrix.""" # TODO(davmre): is a more efficient direct implementation possible? old_value = tf.reduce_sum(chol * chol[..., idx : idx + 1, :], axis=-1) + old_value = tf.ensure_shape(old_value, value.shape) return _symmetric_increment_chol(chol, idx, increment=value - old_value) From 85ea8e92af5e9152d155d0723e1a0b1fbaeedb67 Mon Sep 17 00:00:00 2001 From: vanderplas Date: Mon, 11 Apr 2022 14:05:42 -0700 Subject: [PATCH 086/153] Migrate away from private jax.test_util PiperOrigin-RevId: 440991262 --- spinoffs/oryx/oryx/experimental/nn/pooling_test.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/spinoffs/oryx/oryx/experimental/nn/pooling_test.py b/spinoffs/oryx/oryx/experimental/nn/pooling_test.py index e97ff632fd..d3d8f9237d 100644 --- a/spinoffs/oryx/oryx/experimental/nn/pooling_test.py +++ b/spinoffs/oryx/oryx/experimental/nn/pooling_test.py @@ -18,7 +18,6 @@ from absl.testing import parameterized import jax from jax import random -from jax import test_util as jtu import numpy as np from oryx.core import state @@ -72,7 +71,7 @@ def setUp(self): super().setUp() self._seed = random.PRNGKey(0) - @parameterized.named_parameters(jtu.cases_from_list(shape4d_parameters())) + @parameterized.named_parameters(shape4d_parameters()) def test_shapes4d(self, window_shape, padding, strides, in_shape, pool_class): net_init = pool_class(window_shape, strides, padding) net_rng, data_rng = random.split(self._seed) @@ -82,7 +81,7 @@ def test_shapes4d(self, window_shape, padding, strides, in_shape, pool_class): result = layer(x) self.assertEqual(result.shape, out_shape) - @parameterized.named_parameters(jtu.cases_from_list(shape3d_parameters())) + @parameterized.named_parameters(shape3d_parameters()) def test_shapes3d(self, window_shape, padding, strides, in_shape, pool_class): net_init = pool_class(window_shape, strides, padding) net_rng, data_rng = random.split(self._seed) From 179edde29684a32aa36d0b627020305a459298ff Mon Sep 17 00:00:00 2001 From: Sharad Vikram Date: Mon, 11 Apr 2022 22:04:39 -0700 Subject: [PATCH 087/153] Copybara import of the project: -- ef2021392eedb9242636241d42625eed51c696d4 by Sharad Vikram : Adds simple effect types to jaxprs PiperOrigin-RevId: 441083960 --- spinoffs/oryx/oryx/core/interpreters/unzip.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/spinoffs/oryx/oryx/core/interpreters/unzip.py b/spinoffs/oryx/oryx/core/interpreters/unzip.py index c8c145f083..f9d79998e1 100644 --- a/spinoffs/oryx/oryx/core/interpreters/unzip.py +++ b/spinoffs/oryx/oryx/core/interpreters/unzip.py @@ -85,6 +85,7 @@ def custom_rule(*tracers, **params): recipe = out_tracer.recipe out_tracer.recipe = pe.new_eqn_recipe(recipe.invars, out_tracers, recipe.primitive, recipe.params, + recipe.effects, recipe.source_info) # pytype: disable=wrong-arg-types return out_tracers @@ -217,7 +218,7 @@ def default_process_primitive(self, primitive, tracers, params): assert False key = all(t.is_key() for t in tracers) avals = [t.aval for t in tracers] - ans = primitive.abstract_eval(*avals, **params) + ans, effects = primitive.abstract_eval(*avals, **params) if not primitive.multiple_results: ans = [ans] out_tracers = [ @@ -226,7 +227,7 @@ def default_process_primitive(self, primitive, tracers, params): ] # Passing in UnzipTracer, which pytype does not recognize as JaxprTracer eqn = pe.new_eqn_recipe(tracers, out_tracers, primitive, params, - source_info_util.current()) # pytype: disable=wrong-arg-types + effects, source_info_util.current()) # pytype: disable=wrong-arg-types for t in out_tracers: t.recipe = eqn @@ -384,7 +385,7 @@ def _bound_output_tracers(self, primitive, params, jaxpr, consts, env, del new_params['out_axes_thunk'] eqn = pe.new_eqn_recipe( tuple(const_tracers + env_tracers + in_tracers), out_tracers, primitive, - new_params, source_info_util.current()) # pytype: disable=wrong-arg-types + new_params, lifted_jaxpr.effects, source_info_util.current()) # pytype: disable=wrong-arg-types for t in out_tracers: t.recipe = eqn return out_tracers @@ -662,12 +663,14 @@ def getconstvar(c): return var processed_eqn_ids = set() + effects = set() for t in sorted_tracers: recipe = t.recipe if isinstance(recipe, pe.JaxprEqnRecipe): if recipe.eqn_id not in processed_eqn_ids: eqns.append(pe.recipe_to_eqn(getvar, recipe)) processed_eqn_ids.add(recipe.eqn_id) + effects.update(recipe.effects) elif isinstance(recipe, pe.LambdaBinding): if not any(t is in_tracer for in_tracer in in_tracers): raise VariableError(f'Found unknown input tracer: {t}') @@ -688,7 +691,7 @@ def getconstvar(c): const_vars, const_vals = jax_util.unzip2(consts.items()) # The env_vars are pre-pended to the invars jaxpr = jax_core.Jaxpr(const_vars, list(it.chain(env_vars, invars)), - safe_map(getvar, out_tracers), eqns) + safe_map(getvar, out_tracers), eqns, effects) return jaxpr, const_vals, env_vals From 3786c76e24b5a73e0f44cfd17ba5ea9ab15016b8 Mon Sep 17 00:00:00 2001 From: ltsaprounis Date: Tue, 12 Apr 2022 18:49:30 +0100 Subject: [PATCH 088/153] added quatile method in Empirical dist --- .../python/distributions/empirical.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/distributions/empirical.py b/tensorflow_probability/python/distributions/empirical.py index a5f88a89f8..28de0d401b 100644 --- a/tensorflow_probability/python/distributions/empirical.py +++ b/tensorflow_probability/python/distributions/empirical.py @@ -25,7 +25,7 @@ from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import tensor_util from tensorflow_probability.python.internal import tensorshape_util - +from tensorflow_probability.python.stats import percentile __all__ = [ 'Empirical' @@ -217,6 +217,18 @@ def _stddev(self): r = samples - tf.expand_dims(self._mean(samples), axis=axis) var = tf.reduce_mean(tf.square(r), axis=axis) return tf.sqrt(var) + + def _quantile(self, value, samples=None, **kwargs): + if value > 1 or value < 0: + raise ValueError( + "Quantile values in tensorflow_probability." + "distributions.Empirical.quantile must be between 0 and 1." + ) + + if samples is None: + samples = tf.convert_to_tensor(self._samples) + + return percentile(x=samples, q=value * 100, axis=self._samples_axis, **kwargs) def _sample_n(self, n, seed=None): samples = tf.convert_to_tensor(self._samples) From 92bbe70fc9bc8d5afb535c6cbb4aefb0ca6bf46f Mon Sep 17 00:00:00 2001 From: ltsaprounis Date: Tue, 12 Apr 2022 18:52:25 +0100 Subject: [PATCH 089/153] added quantile test in EmpiricalScalarTest --- .../python/distributions/empirical_test.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tensorflow_probability/python/distributions/empirical_test.py b/tensorflow_probability/python/distributions/empirical_test.py index 3bae459af5..dd848902a0 100644 --- a/tensorflow_probability/python/distributions/empirical_test.py +++ b/tensorflow_probability/python/distributions/empirical_test.py @@ -265,6 +265,23 @@ def testVarianceAndStd(self): self.assertAllClose(self.evaluate(dist.stddev()), np.sqrt(expected_variance)) + def test_empirical_quantiles(self): + samples = [ + [1, 1, 1, 2, 3, 3, 3], + [[1.0, 1.1, 1.2, 1.3, 1.4], [2.0, 2.1, 2.2, 2.3, 2.4]], + ] + + expected_quantiles = {0.5: [2, [1.2, 2.2]], 0.75: [3, 1.3, 2.3]} + + for q, q_val in expected_quantiles.items(): + for i in range(len(samples)): + input_ = tf.convert_to_tensor(value=samples[i], dtype=np.float32) + input_ph = tf1.placeholder_with_default( + input_, shape=input_.shape if self.static_shape else None + ) + dist = tfd.Empirical(samples=input_ph, validate_args=True) + self.assertAllClose(self.evaluate(dist.quantile(q)), q_val) + @test_util.test_all_tf_execution_regimes class EmpiricalVectorTest(test_util.VectorDistributionTestHelpers): From 463448b7e38f56043ce0fadf67b287d9d1269f59 Mon Sep 17 00:00:00 2001 From: ltsaprounis Date: Tue, 12 Apr 2022 18:57:40 +0100 Subject: [PATCH 090/153] add error unit test for quanitles --- .../python/distributions/empirical_test.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tensorflow_probability/python/distributions/empirical_test.py b/tensorflow_probability/python/distributions/empirical_test.py index dd848902a0..b94764ab00 100644 --- a/tensorflow_probability/python/distributions/empirical_test.py +++ b/tensorflow_probability/python/distributions/empirical_test.py @@ -281,6 +281,12 @@ def test_empirical_quantiles(self): ) dist = tfd.Empirical(samples=input_ph, validate_args=True) self.assertAllClose(self.evaluate(dist.quantile(q)), q_val) + + invalid_value = 1.5 + with self.assertRaises(ValueError): + dist = tfd.Empirical( + samples=sample, validate_args=True + ).quantile(invalid_value) @test_util.test_all_tf_execution_regimes From b2b624c0a8e013470a815716644bdeae12200a83 Mon Sep 17 00:00:00 2001 From: phawkins Date: Tue, 12 Apr 2022 13:29:03 -0700 Subject: [PATCH 091/153] [JAX] Add MHLO lowerings to Oryx. Change in preparation for deleting _xla_call_translation_rule. PiperOrigin-RevId: 441275842 --- spinoffs/oryx/oryx/core/interpreters/harvest.py | 15 ++++++++------- spinoffs/oryx/oryx/core/primitive.py | 17 +++++++++++++++-- 2 files changed, 23 insertions(+), 9 deletions(-) diff --git a/spinoffs/oryx/oryx/core/interpreters/harvest.py b/spinoffs/oryx/oryx/core/interpreters/harvest.py index ac770e7687..452b47d121 100644 --- a/spinoffs/oryx/oryx/core/interpreters/harvest.py +++ b/spinoffs/oryx/oryx/core/interpreters/harvest.py @@ -235,15 +235,16 @@ def _nest_impl(f, *args, **_): nest_p.def_impl(_nest_impl) -def _nest_translation_rule(*args, name, call_jaxpr, scope, **_): - return xla._xla_call_translation_rule( # pylint: disable=protected-access - *args, - name=jax_util.wrap_name(name, f'nest[{scope}]'), - call_jaxpr=call_jaxpr, - donated_invars=(False,) * len(args)) +if hasattr(xla, '_xla_call_translation_rule'): + def _nest_translation_rule(*args, name, call_jaxpr, scope, **_): + return xla._xla_call_translation_rule( # pylint: disable=protected-access # type: ignore + *args, + name=jax_util.wrap_name(name, f'nest[{scope}]'), + call_jaxpr=call_jaxpr, + donated_invars=(False,) * len(args)) -xla.register_translation(nest_p, _nest_translation_rule) + xla.register_translation(nest_p, _nest_translation_rule) def _nest_lowering(ctx, *args, name, call_jaxpr, scope, **_): diff --git a/spinoffs/oryx/oryx/core/primitive.py b/spinoffs/oryx/oryx/core/primitive.py index edf2451fc1..db2071e05d 100644 --- a/spinoffs/oryx/oryx/core/primitive.py +++ b/spinoffs/oryx/oryx/core/primitive.py @@ -106,13 +106,26 @@ def rule(*args, backend, name, call_jaxpr, **params): new_params = dict(name=name, backend=backend, call_jaxpr=call_jaxpr) new_params['donated_invars'] = params.get('donated_invars', (False,) * len(args)) - return xla._xla_call_translation_rule(*args, **new_params) # pylint: disable=protected-access + return xla._xla_call_translation_rule(*args, **new_params) # pylint: disable=protected-access # type: ignore xla.call_translations[prim] = rule return rule +if hasattr(xla, '_xla_call_translation_rule'): + register_hop_transformation_rule('translation', hop_translation_rule) -register_hop_transformation_rule('translation', hop_translation_rule) + +def hop_lowering(prim): + + def rule(ctx, *args, backend, name, call_jaxpr, **_params): + return mlir._call_lowering( # pylint: disable=protected-access + name, name, call_jaxpr, backend, + ctx.module_context, ctx.avals_in, ctx.avals_out, *args) + + mlir.register_lowering(prim, rule) + return rule + +register_hop_transformation_rule('mlir', hop_lowering) def batch_fun(fun: lu.WrappedFun, in_dims): From 76dc3219679ed37d88ea56c72504a81cbf7a595a Mon Sep 17 00:00:00 2001 From: jburnim Date: Tue, 12 Apr 2022 16:13:18 -0700 Subject: [PATCH 092/153] Ensure rank-1 Cholesky updates don't modify non-lower-triangular entries. PiperOrigin-RevId: 441318325 --- tensorflow_probability/python/math/linalg.py | 9 ++++++--- tensorflow_probability/python/math/linalg_test.py | 3 +++ 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/tensorflow_probability/python/math/linalg.py b/tensorflow_probability/python/math/linalg.py index b6618df047..85900b5697 100644 --- a/tensorflow_probability/python/math/linalg.py +++ b/tensorflow_probability/python/math/linalg.py @@ -165,7 +165,7 @@ def cholesky_update(chol, update_vector, multiplier=1., name=None): def compute_new_column(accumulated_quantities, state): """Computes the next column of the updated cholesky.""" _, _, omega, b = accumulated_quantities - index, diagonal_member, col = state + index, diagonal_member, col, col_mask = state omega_at_index = omega[..., index] # Line 4 @@ -181,18 +181,21 @@ def compute_new_column(accumulated_quantities, state): new_col = new_diagonal_member[..., tf.newaxis] * ( col / diagonal_member[..., tf.newaxis] + (multiplier * omega_at_index / scaling_factor)[ - ..., tf.newaxis] * omega) + ..., tf.newaxis] * omega * col_mask) b = b + multiplier * tf.math.square(omega_at_index / diagonal_member) return new_diagonal_member, new_col, omega, b # We will scan over the columns. + cols_mask = distribution_util.move_dimension( + tf.linalg.band_part(tf.ones_like(chol), -1, 0), + source_idx=-1, dest_idx=0) chol = distribution_util.move_dimension(chol, source_idx=-1, dest_idx=0) chol_diag = distribution_util.move_dimension( chol_diag, source_idx=-1, dest_idx=0) new_diag, new_chol, _, _ = tf.scan( fn=compute_new_column, - elems=(tf.range(0, ps.shape(chol)[0]), chol_diag, chol), + elems=(tf.range(0, ps.shape(chol)[0]), chol_diag, chol, cols_mask), initializer=( tf.zeros_like(multiplier), tf.zeros_like(chol[0, ...]), diff --git a/tensorflow_probability/python/math/linalg_test.py b/tensorflow_probability/python/math/linalg_test.py index eeec26a28e..9f4ecf9a23 100644 --- a/tensorflow_probability/python/math/linalg_test.py +++ b/tensorflow_probability/python/math/linalg_test.py @@ -168,6 +168,7 @@ def _testCholeskyUpdate(self, cholesky_update_fun): mat + tf.linalg.matmul(u, u, transpose_b=True)) new_chol = cholesky_update_fun(chol, tf.squeeze(u, axis=-1)) self.assertAllClose(new_chol_expected, new_chol, rtol=1e-5, atol=2e-5) + self.assertAllEqual(tf.linalg.band_part(new_chol, -1, 0), new_chol) def testCholeskyUpdateBatches(self): rng = test_util.test_np_rng() @@ -189,6 +190,7 @@ def testCholeskyUpdateBatches(self): new_chol = tfp.math.cholesky_update( chol, tf.squeeze(u, axis=-1), multiplier=multiplier) self.assertAllClose(new_chol_expected, new_chol, rtol=1e-5, atol=2e-5) + self.assertAllEqual(tf.linalg.band_part(new_chol, -1, 0), new_chol) @hp.given(hps.data()) @tfp_hps.tfp_hp_settings() @@ -232,6 +234,7 @@ def testCholeskyUpdateRandomized(self, data): new_chol = tfp.math.cholesky_update(chol, u, multiplier=multiplier) self.assertAllClose(new_chol_expected, new_chol, rtol=1e-5, atol=2e-5) + self.assertAllEqual(tf.linalg.band_part(new_chol, -1, 0), new_chol) @test_util.test_all_tf_execution_regimes From 3261721b7989e8d68156dc05f39558c57c600e15 Mon Sep 17 00:00:00 2001 From: jburnim Date: Wed, 13 Apr 2022 11:14:31 -0700 Subject: [PATCH 093/153] Improve the numerical accuracy of the spike-and-slab sampler under XLA. PiperOrigin-RevId: 441530159 --- .../experimental/sts_gibbs/spike_and_slab.py | 36 ++++++----- .../sts_gibbs/spike_and_slab_test.py | 63 ++++++++++++------- 2 files changed, 61 insertions(+), 38 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index a0346e486b..5d8e08bdcc 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -425,12 +425,14 @@ def _flip_feature(self, sampler_state, idx): chol=sampler_state.conditional_prior_precision_chol, idx=idx, psd_matrix=self.weights_prior_precision, - new_nonzeros=new_nonzeros) + new_nonzeros=new_nonzeros, + previous_nonzeros=sampler_state.nonzeros) new_conditional_posterior_precision_chol = _update_nonzero_block_chol( chol=sampler_state.conditional_posterior_precision_chol, idx=idx, psd_matrix=self.weights_posterior_precision, - new_nonzeros=new_nonzeros) + new_nonzeros=new_nonzeros, + previous_nonzeros=sampler_state.nonzeros) new_conditional_weights_mean = tf.where( new_nonzeros, tf.linalg.cholesky_solve( @@ -603,7 +605,8 @@ def _select_nonzero_block(matrix, nonzeros): tf.where(nonzeros, tf.linalg.diag_part(masked), 1.)) -def _update_nonzero_block_chol(chol, idx, psd_matrix, new_nonzeros): +def _update_nonzero_block_chol( + chol, idx, psd_matrix, new_nonzeros, previous_nonzeros): """Efficient update to the cholesky factor of the 'slab' (nonzero) submatrix. This performs an efficient update when `nonzeros` changes by a single entry. @@ -626,28 +629,25 @@ def _update_nonzero_block_chol(chol, idx, psd_matrix, new_nonzeros): psd_matrix: (batch of) float Tensor positive semidefinite matrix(s) of shape `[num_features, num_features]`. new_nonzeros: (batch of) boolean Tensor vectors of shape `[num_features]`. + previous_nonzeros: (batch of) boolean Tensor vectors of shape + `[num_features]`. Returns: updated_chol: (batch of) float Tensor lower-triangular Cholesky factor(s) of `select_nonzero_block(psd_matrix, new_nonzeros)`. """ - row_with_new_nonzeros = tf.where(new_nonzeros, psd_matrix[..., idx, :], 0.) - eye_row = _set_vector_index(tf.zeros_like(row_with_new_nonzeros), idx, 1.) - return _symmetric_update_chol( + psd_row = tf.where(new_nonzeros, psd_matrix[..., idx, :], 0.) + eye_row = _set_vector_index(tf.zeros_like(psd_row), idx, 1.) + new_row = tf.where(new_nonzeros[..., idx, tf.newaxis], psd_row, eye_row) + # NOTE: We could also compute `old_row` from `chol`, but we believe it is + # more numerically accurate to use `psd_matrix`, as `chol` may have + # accumulated errors over multiple calls to `_update_nonzero_block_chol`. + old_row = _select_nonzero_block(psd_matrix, previous_nonzeros)[..., idx, :] + return _symmetric_increment_chol( chol, idx=idx, # Set the `idx`th row/col to its target value if the `idx`th feature is # now nonzero; otherwise set it to the identity. - value=tf.where(new_nonzeros[..., idx, tf.newaxis], - row_with_new_nonzeros, - eye_row)) - - -def _symmetric_update_chol(chol, idx, value): - """Sets the value of a row and column in a Cholesky-factorized matrix.""" - # TODO(davmre): is a more efficient direct implementation possible? - old_value = tf.reduce_sum(chol * chol[..., idx : idx + 1, :], axis=-1) - old_value = tf.ensure_shape(old_value, value.shape) - return _symmetric_increment_chol(chol, idx, increment=value - old_value) + increment=new_row - old_row) def _symmetric_increment_chol(chol, idx, increment): @@ -697,6 +697,8 @@ def _symmetric_increment_chol(chol, idx, increment): given row and column of `M`. """ with tf.name_scope('symmetric_increment_chol'): + # TODO(jburnim): Can we make this more numerically accurate by doing all + # three rank-1 Cholesky updates in a single pass? chol = tf.convert_to_tensor(chol, name='chol') increment = tf.convert_to_tensor(increment, name='increment') # Rank-1 update to increment the `idx`th row and column, with side diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py index 04a5200335..85ef7bcdcb 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py @@ -27,6 +27,8 @@ from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_util +from tensorflow_probability.python.mcmc.internal import util as mcmc_util + def _naive_symmetric_increment(m, idx, increment): m = m.copy() @@ -209,31 +211,50 @@ def test_noise_variance_posterior_matches_expected(self): ).observation_noise_variance_posterior_scale, naive_posterior.scale) - def test_updated_state_matches_initial_computation(self): - design_matrix, _, targets = self._random_regression_task( - num_outputs=2, num_features=3, batch_shape=[], - seed=test_util.test_seed()) + @parameterized.parameters( + (2, 3, 1, [], False), + (2, 3, 1, [3, 2], True), + (100, 20, 10, [4], False), + (100, 20, 10, [], True), + (40, 20, 12, [3], True)) + def test_updated_state_matches_initial_computation( + self, num_outputs, num_features, num_flips, batch_shape, use_xla): + + rng = test_util.test_np_rng() + initial_nonzeros = rng.randint( + low=0, high=2, size=batch_shape + [num_features]).astype(np.bool) + flip_idxs = rng.choice( + num_features, size=num_flips, replace=False).astype(np.int32) + if batch_shape: + should_flip = rng.randint( + low=0, high=2, size=[num_flips] + batch_shape).astype(np.bool) + else: + should_flip = np.array([True] * num_flips) + + nonzeros = initial_nonzeros.copy() + for i in range(num_flips): + nonzeros[..., flip_idxs[i]] = ( + nonzeros[..., flip_idxs[i]] != should_flip[i]) + design_matrix, _, targets = self._random_regression_task( + num_outputs=num_outputs, num_features=num_features, + batch_shape=batch_shape, seed=test_util.test_seed()) sampler = spike_and_slab.SpikeSlabSampler(design_matrix=design_matrix, nonzero_prior_prob=0.3) - all_nonzero_sampler_state = sampler._initialize_sampler_state( - targets=targets, nonzeros=tf.convert_to_tensor([True, True, True])) - - # Flipping a weight from nonzero to zero (slab to spike) should result in - # the same state as if we'd initialized with that sparsity pattern. - flipped_state_from_update = sampler._flip_feature( - all_nonzero_sampler_state, idx=0) - flipped_state_from_scratch = sampler._initialize_sampler_state( - targets=targets, nonzeros=tf.convert_to_tensor([False, True, True])) - self.assertAllCloseNested(flipped_state_from_update, - flipped_state_from_scratch) - - # Reverse direction (spike to slab). - double_flipped_state_from_update = sampler._flip_feature( - flipped_state_from_update, idx=0) - self.assertAllCloseNested(double_flipped_state_from_update, - all_nonzero_sampler_state, atol=1e-4) + @tf.function(autograph=False, jit_compile=use_xla) + def _do_flips(): + state = sampler._initialize_sampler_state( + targets=targets, nonzeros=initial_nonzeros) + def _do_flip(state, i): + new_state = sampler._flip_feature(state, tf.gather(flip_idxs, i)) + return mcmc_util.choose(tf.gather(should_flip, i), new_state, state) + return tf.foldl(_do_flip, elems=tf.range(num_flips), initializer=state) + + self.assertAllCloseNested( + sampler._initialize_sampler_state(targets, nonzeros), + _do_flips(), + atol=num_outputs * 2e-4, rtol=num_outputs * 2e-4) def test_sanity_check_sweep_over_features(self): num_outputs = 100 From 047cf0bcd45f1a4fb520be0bfd2246660775c086 Mon Sep 17 00:00:00 2001 From: Christopher Suter Date: Thu, 14 Apr 2022 08:39:31 -0700 Subject: [PATCH 094/153] Fix JointDistributionPinned test after jax becomes more strict about inputs. Previously jax was lax about lifting lists of arrays to arrays. It became more strict, at least in the scipy_special.{expit,logit} implementations, which broke a JDP test that was implicitly relying on this behavior. This change just modifies that test to pluck out the 0th entry of a list and call jax's expit on that entry instead of the whole list. PiperOrigin-RevId: 441770018 --- .../distributions/joint_distribution_pinned_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/experimental/distributions/joint_distribution_pinned_test.py b/tensorflow_probability/python/experimental/distributions/joint_distribution_pinned_test.py index 65fe6bf2dd..9ab3c9432f 100644 --- a/tensorflow_probability/python/experimental/distributions/joint_distribution_pinned_test.py +++ b/tensorflow_probability/python/experimental/distributions/joint_distribution_pinned_test.py @@ -356,7 +356,7 @@ def test_bijector(self): bij = jd.experimental_default_event_space_bijector(a=-.5, b=1.) test_input = (0.5,) self.assertIs(type(jd.dtype), type(bij.inverse(test_input))) - self.assertAllClose((2/3,), tf.math.sigmoid(bij.inverse(test_input))) + self.assertAllClose(2/3, tf.math.sigmoid(bij.inverse(test_input)[0])) @tfd.JointDistributionCoroutine def model(): From 21acd8f950a00d7ba8d7e4b9727184b138d78bb3 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Thu, 14 Apr 2022 10:30:51 -0700 Subject: [PATCH 095/153] Add option to specify initial_level_prior to `build_model_for_gibbs_fitting`. This may be useful if, for example, the observed time series does not have 0 mean. PiperOrigin-RevId: 441796828 --- .../experimental/sts_gibbs/gibbs_sampler.py | 7 +++ .../sts_gibbs/gibbs_sampler_test.py | 53 +++++++++++++++---- 2 files changed, 51 insertions(+), 9 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index f1656304f3..b51f1183c5 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -174,6 +174,7 @@ def build_model_for_gibbs_fitting(observed_time_series, level_variance_prior, observation_noise_variance_prior, slope_variance_prior=None, + initial_level_prior=None, sparse_weights_nonzero_prob=None): """Builds a StructuralTimeSeries model instance that supports Gibbs sampling. @@ -215,6 +216,10 @@ def build_model_for_gibbs_fitting(observed_time_series, `observed_time_series`. If specified, a local linear trend model is used rather than a local level model. Default value: `None`. + initial_level_prior: optional `tfd.Distribution` instance specifying a + prior on the initial level. If `None`, a heuristic default prior is + constructed based on the provided `observed_time_series`. + Default value: `None`. sparse_weights_nonzero_prob: Optional scalar float `Tensor` prior probability that any given feature has nonzero weight. If specified, this triggers a sparse regression with a spike-and-slab prior, where @@ -254,11 +259,13 @@ def build_model_for_gibbs_fitting(observed_time_series, observed_time_series=observed_time_series, level_scale_prior=sqrt(level_variance_prior), slope_scale_prior=sqrt(slope_variance_prior), + initial_level_prior=initial_level_prior, name='local_linear_trend') else: local_variation = sts.LocalLevel( observed_time_series=observed_time_series, level_scale_prior=sqrt(level_variance_prior), + initial_level_prior=initial_level_prior, name='local_level') # Regression component. diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index 37a46bed73..cbe17bc3c0 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -28,6 +28,7 @@ from tensorflow_probability.python.experimental.sts_gibbs import gibbs_sampler from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_util +from tensorflow_probability.python.sts.internal import util as sts_util from tensorflow.python.ops import parallel_for # pylint: disable=g-direct-tensorflow-import @@ -51,6 +52,7 @@ def _build_test_model(self, weights=None, weights_prior_scale=10., sparse_weights_nonzero_prob=None, + time_series_shift=0., dtype=tf.float32): seed = test_util.test_seed(sampler_type='stateless') (design_seed, @@ -79,7 +81,7 @@ def _build_test_model(self, dtype=dtype, seed=slope_seed) * true_slope_scale, axis=-1) level_residuals += slope level = tf.cumsum(level_residuals, axis=-1) - time_series = (regression + noise + level) + time_series = (regression + noise + level + time_series_shift) is_missing = samplers.uniform( list(batch_shape) + [num_timesteps], dtype=dtype, seed=is_missing_seed) < missing_prob @@ -89,9 +91,19 @@ def _build_test_model(self, scale=tf.cast(0.01 * 0.01, dtype)) observation_noise_variance_prior.upper_bound = 100.0 + observed_time_series = tfp.sts.MaskedTimeSeries( + time_series[..., tf.newaxis], is_missing) + if time_series_shift != 0.: + observed_mean, observed_stddev, observed_initial = ( + sts_util.empirical_statistics(observed_time_series)) + initial_level_prior = tfd.Normal( + loc=observed_mean + observed_initial, + scale=tf.abs(observed_initial) + observed_stddev) + else: + initial_level_prior = None + model = gibbs_sampler.build_model_for_gibbs_fitting( - observed_time_series=tfp.sts.MaskedTimeSeries( - time_series[..., tf.newaxis], is_missing), + observed_time_series=observed_time_series, design_matrix=design_matrix, weights_prior=( None if weights_prior_scale is None @@ -103,6 +115,7 @@ def _build_test_model(self, slope_variance_prior=None if true_slope_scale is None else prior_class( concentration=tf.cast(0.01, dtype), scale=tf.cast(0.01 * 0.01, dtype)), + initial_level_prior=initial_level_prior, observation_noise_variance_prior=observation_noise_variance_prior, sparse_weights_nonzero_prob=sparse_weights_nonzero_prob) return model, time_series, is_missing @@ -111,21 +124,36 @@ def _build_test_model(self, { 'testcase_name': 'LocalLinearTrend', 'use_slope': True, - 'num_chains': () + 'num_chains': (), + 'time_series_shift': 0. }, { 'testcase_name': 'LocalLinearTrend_4chains', 'use_slope': True, - 'num_chains': 4 + 'num_chains': 4, + 'time_series_shift': 0. }, { 'testcase_name': 'LocalLevel', 'use_slope': False, - 'num_chains': () + 'num_chains': (), + 'time_series_shift': 0. }, { 'testcase_name': 'LocalLevel_4chains', 'use_slope': False, - 'num_chains': 4 + 'num_chains': 4, + 'time_series_shift': 0. + }, { + 'testcase_name': 'UnscaledTimeSeries_LocalLinear', + 'use_slope': False, + 'num_chains': (), + 'time_series_shift': 100. + }, { + 'testcase_name': 'UnscaledTimeSeries_LocalLinearTrend', + 'use_slope': True, + 'num_chains': (), + 'time_series_shift': 100. }) - def test_forecasts_match_reference(self, use_slope, num_chains): + def test_forecasts_match_reference( + self, use_slope, num_chains, time_series_shift): seed = test_util.test_seed() num_observed_steps = 5 num_forecast_steps = 4 @@ -139,7 +167,8 @@ def test_forecasts_match_reference(self, use_slope, num_chains): model, observed_time_series, is_missing = self._build_test_model( num_timesteps=num_observed_steps + num_forecast_steps, true_slope_scale=0.5 if use_slope else None, - batch_shape=[3]) + batch_shape=[3], + time_series_shift=time_series_shift) @tf.function(autograph=False) def do_sampling(): @@ -173,6 +202,12 @@ def reshape_chain_and_sample(x): self.assertAllEqual(predictive_stddev.shape, [3, num_observed_steps + num_forecast_steps]) + # big tolerance, but makes sure the predictive mean initializes near + # the initial time series value + self.assertAllClose(tf.reduce_mean(predictive_mean[:, 0]), + observed_time_series[0, 0], + atol=10.) + if use_slope: parameter_samples = (samples.observation_noise_scale, samples.level_scale, From 42abd47c38ed713dff728a631668eb97ba02d0da Mon Sep 17 00:00:00 2001 From: Googler Date: Thu, 14 Apr 2022 10:36:52 -0700 Subject: [PATCH 096/153] Use softplus as NegativeBinomial's total_count bijector. PiperOrigin-RevId: 441798435 --- .../python/distributions/negative_binomial.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/distributions/negative_binomial.py b/tensorflow_probability/python/distributions/negative_binomial.py index 72b442b4c3..265740e8b7 100644 --- a/tensorflow_probability/python/distributions/negative_binomial.py +++ b/tensorflow_probability/python/distributions/negative_binomial.py @@ -18,6 +18,7 @@ from tensorflow_probability.python import math as tfp_math from tensorflow_probability.python.bijectors import sigmoid as sigmoid_bijector +from tensorflow_probability.python.bijectors import softplus as softplus_bijector from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.internal import assert_util from tensorflow_probability.python.internal import distribution_util @@ -145,8 +146,8 @@ def experimental_from_mean_dispersion(cls, mean, dispersion, **kwargs): def _parameter_properties(cls, dtype, num_classes=None): return dict( total_count=parameter_properties.ParameterProperties( - default_constraining_bijector_fn=parameter_properties - .BIJECTOR_NOT_IMPLEMENTED), + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), logits=parameter_properties.ParameterProperties(), probs=parameter_properties.ParameterProperties( default_constraining_bijector_fn=sigmoid_bijector.Sigmoid, From 2788a5a284645cce8fb471f3884d8ecd75874eeb Mon Sep 17 00:00:00 2001 From: jburnim Date: Thu, 14 Apr 2022 15:32:51 -0700 Subject: [PATCH 097/153] Enable tfp.experimental.sts_gibbs with the JAX backend. PiperOrigin-RevId: 441870974 --- .../python/experimental/sts_gibbs/BUILD | 21 +++++--- .../experimental/sts_gibbs/benchmarks_test.py | 32 ++++++++----- .../experimental/sts_gibbs/gibbs_sampler.py | 9 ++-- .../sts_gibbs/gibbs_sampler_test.py | 48 +++++++++---------- .../experimental/sts_gibbs/spike_and_slab.py | 18 ++++++- .../sts_gibbs/spike_and_slab_test.py | 28 +++++------ 6 files changed, 92 insertions(+), 64 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/BUILD b/tensorflow_probability/python/experimental/sts_gibbs/BUILD index 33d476bf2a..0459a64b20 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/BUILD +++ b/tensorflow_probability/python/experimental/sts_gibbs/BUILD @@ -15,6 +15,12 @@ # Description: # Gibbs sampling for Bayesian structural time series models +load( + "//tensorflow_probability/python:build_defs.bzl", + "multi_substrate_py_library", + "multi_substrate_py_test", +) + licenses(["notice"]) package( @@ -23,7 +29,7 @@ package( ], ) -py_library( +multi_substrate_py_library( name = "sts_gibbs", srcs = ["__init__.py"], deps = [ @@ -32,10 +38,11 @@ py_library( ], ) -py_test( +multi_substrate_py_test( name = "benchmarks_test", size = "medium", srcs = ["benchmarks_test.py"], + disabled_substrates = ["numpy"], tags = ["notap"], deps = [ # absl/testing:parameterized dep, @@ -48,7 +55,7 @@ py_test( ], ) -py_library( +multi_substrate_py_library( name = "gibbs_sampler", srcs = ["gibbs_sampler.py"], deps = [ @@ -58,10 +65,11 @@ py_library( ], ) -py_test( +multi_substrate_py_test( name = "gibbs_sampler_test", size = "medium", srcs = ["gibbs_sampler_test.py"], + disabled_substrates = ["numpy"], shard_count = 4, deps = [ # absl/testing:parameterized dep, @@ -74,7 +82,7 @@ py_test( ], ) -py_library( +multi_substrate_py_library( name = "spike_and_slab", srcs = ["spike_and_slab.py"], deps = [ @@ -93,10 +101,11 @@ py_library( ], ) -py_test( +multi_substrate_py_test( name = "spike_and_slab_test", size = "medium", srcs = ["spike_and_slab_test.py"], + disabled_substrates = ["numpy"], deps = [ # absl/testing:parameterized dep, # numpy dep, diff --git a/tensorflow_probability/python/experimental/sts_gibbs/benchmarks_test.py b/tensorflow_probability/python/experimental/sts_gibbs/benchmarks_test.py index ea4bcd4ff1..f986315aff 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/benchmarks_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/benchmarks_test.py @@ -19,7 +19,6 @@ import tensorflow.compat.v2 as tf import tensorflow_probability as tfp -from tensorflow_probability import distributions as tfd from tensorflow_probability.python.experimental.sts_gibbs import gibbs_sampler from tensorflow_probability.python.internal import test_util as tfp_test_util from tensorflow.python.framework import test_util # pylint: disable=g-direct-tensorflow-import @@ -73,22 +72,29 @@ def test_benchmark_sampling_with_xla(self): if not tf.executing_eagerly(): return seed = tfp_test_util.test_seed() - model, observed_time_series, is_missing = self._build_test_model( - num_timesteps=336, batch_shape=[]) + + @tf.function(autograph=False, jit_compile=True) + def _run(): + model, observed_time_series, is_missing = self._build_test_model( + num_timesteps=336, batch_shape=[]) + return gibbs_sampler.fit_with_gibbs_sampling( + model, + tfp.sts.MaskedTimeSeries(observed_time_series[..., tf.newaxis], + is_missing), + num_results=500, + num_warmup_steps=100, + seed=seed) t0 = time.time() - samples = tf.function( - gibbs_sampler.fit_with_gibbs_sampling, - autograph=False, - jit_compile=True)( - model, - tfp.sts.MaskedTimeSeries(observed_time_series[..., tf.newaxis], - is_missing), - num_results=500, - num_warmup_steps=100, - seed=seed) + samples = _run() + t1 = time.time() + print('Drew (100+500) samples (with JIT compilation) in time', t1-t0) + + t0 = time.time() + samples = _run() t1 = time.time() print('Drew (100+500) samples in time', t1-t0) + print('Results:', samples) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index b51f1183c5..eec3bc383c 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -235,7 +235,7 @@ def build_model_for_gibbs_fitting(observed_time_series, if isinstance(design_matrix, tf.linalg.LinearOperator): num_features = design_matrix.shape_tensor()[-1] else: - num_features = tf.shape(design_matrix)[-1] + num_features = prefer_static.dimension_size(design_matrix, -1) weights_prior = _tile_normal_to_mvn_diag(weights_prior, num_features) elif weights_prior is not None and not _is_multivariate_normal(weights_prior): raise ValueError('Weights prior must be a normal distribution or `None`.') @@ -677,9 +677,10 @@ def _resample_scale(prior, observed_residuals, is_missing=None, seed=None): Returns: sampled_scale: A `Tensor` sample from the posterior `p(scale | x)`. """ + dtype = observed_residuals.dtype + if is_missing is not None: - num_missing = tf.reduce_sum( - tf.cast(is_missing, observed_residuals.dtype), axis=-1) + num_missing = tf.reduce_sum(tf.cast(is_missing, dtype), axis=-1) num_observations = prefer_static.shape(observed_residuals)[-1] if is_missing is not None: observed_residuals = tf.where(is_missing, tf.zeros_like(observed_residuals), @@ -687,7 +688,7 @@ def _resample_scale(prior, observed_residuals, is_missing=None, seed=None): num_observations -= num_missing variance_posterior = type(prior)( - concentration=prior.concentration + num_observations / 2., + concentration=prior.concentration + tf.cast(num_observations / 2., dtype), scale=prior.scale + tf.reduce_sum(tf.square(observed_residuals), axis=-1) / 2.) new_scale = tf.sqrt(variance_posterior.sample(seed=seed)) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index cbe17bc3c0..39f0cd78cb 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -21,17 +21,12 @@ import tensorflow.compat.v2 as tf import tensorflow_probability as tfp -from tensorflow_probability import distributions as tfd - - from tensorflow_probability.python.distributions.linear_gaussian_ssm import linear_gaussian_update from tensorflow_probability.python.experimental.sts_gibbs import gibbs_sampler from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_util from tensorflow_probability.python.sts.internal import util as sts_util -from tensorflow.python.ops import parallel_for # pylint: disable=g-direct-tensorflow-import - tfd = tfp.distributions tfl = tf.linalg @@ -323,12 +318,14 @@ def test_invalid_model_raises_error(self): observed_time_series=observed_time_series) with self.assertRaisesRegexp(ValueError, 'does not support Gibbs sampling'): - gibbs_sampler.fit_with_gibbs_sampling(bad_model, observed_time_series) + gibbs_sampler.fit_with_gibbs_sampling( + bad_model, observed_time_series, seed=test_util.test_seed()) bad_model.supports_gibbs_sampling = True with self.assertRaisesRegexp( ValueError, 'Expected the first model component to be an instance of'): - gibbs_sampler.fit_with_gibbs_sampling(bad_model, observed_time_series) + gibbs_sampler.fit_with_gibbs_sampling( + bad_model, observed_time_series, seed=test_util.test_seed()) bad_model_with_correct_params = tfp.sts.Sum([ # A seasonal model with no drift has no parameters, so adding it @@ -344,7 +341,8 @@ def test_invalid_model_raises_error(self): 'Expected the first model component to be an ' 'instance of `tfp.sts.LocalLevel`'): gibbs_sampler.fit_with_gibbs_sampling(bad_model_with_correct_params, - observed_time_series) + observed_time_series, + seed=test_util.test_seed()) @parameterized.named_parameters( {'testcase_name': 'LocalLinearTrend', 'use_slope': True}, @@ -423,12 +421,13 @@ def test_sampled_scale_follows_correct_distribution(self): # Check that posterior variance samples have the moments of the correct # InverseGamma distribution. - posterior_scale_samples = parallel_for.pfor( - lambda i: gibbs_sampler._resample_scale( # pylint: disable=g-long-lambda + posterior_scale_samples = tf.vectorized_map( + lambda seed: gibbs_sampler._resample_scale( # pylint: disable=g-long-lambda prior=prior, observed_residuals=observed_samples, is_missing=is_missing, - seed=strm()), 10000) + seed=seed), + tfp.random.split_seed(strm(), tf.constant(10000))) concentration = prior.concentration + tf.reduce_sum( 1 - tf.cast(is_missing, tf.float32), axis=-1)/2. @@ -450,20 +449,19 @@ def test_sampled_weights_follow_correct_distribution(self): num_timesteps = 10 num_features = 2 batch_shape = [3, 1] - design_matrix = samplers.normal( - batch_shape + [num_timesteps, num_features], seed=design_seed) - true_weights = samplers.normal( - batch_shape + [num_features, 1], seed=true_weights_seed) * 10.0 - targets = tf.matmul(design_matrix, true_weights) - is_missing = tf.convert_to_tensor([False, False, False, True, True, - False, False, True, False, False], - dtype=tf.bool) + design_matrix = self.evaluate(samplers.normal( + batch_shape + [num_timesteps, num_features], seed=design_seed)) + true_weights = self.evaluate(samplers.normal( + batch_shape + [num_features, 1], seed=true_weights_seed) * 10.0) + targets = np.matmul(design_matrix, true_weights) + is_missing = np.array([False, False, False, True, True, + False, False, True, False, False]) prior_scale = tf.convert_to_tensor(5.) likelihood_scale = tf.convert_to_tensor(0.1) # Analytically compute the true posterior distribution on weights. - valid_design_matrix = tf.boolean_mask(design_matrix, ~is_missing, axis=-2) - valid_targets = tf.boolean_mask(targets, ~is_missing, axis=-2) + valid_design_matrix = design_matrix[..., ~is_missing, :] + valid_targets = targets[..., ~is_missing, :] num_valid_observations = tf.shape(valid_design_matrix)[-2] weights_posterior_mean, weights_posterior_cov, _ = linear_gaussian_update( prior_mean=tf.zeros([num_features, 1]), @@ -475,8 +473,8 @@ def test_sampled_weights_follow_correct_distribution(self): x_observed=valid_targets) # Check that the empirical moments of sampled weights match the true values. - sampled_weights = parallel_for.pfor( - lambda i: gibbs_sampler._resample_weights( # pylint: disable=g-long-lambda + sampled_weights = tf.vectorized_map( + lambda seed: gibbs_sampler._resample_weights( # pylint: disable=g-long-lambda design_matrix=tf.where(is_missing[..., tf.newaxis], tf.zeros_like(design_matrix), design_matrix), @@ -484,8 +482,8 @@ def test_sampled_weights_follow_correct_distribution(self): observation_noise_scale=likelihood_scale, weights_prior_scale=tf.linalg.LinearOperatorScaledIdentity( num_features, prior_scale), - seed=sampled_weights_seed), - 10000) + seed=seed), + tfp.random.split_seed(sampled_weights_seed, tf.constant(10000))) sampled_weights_mean = tf.reduce_mean(sampled_weights, axis=0) centered_weights = sampled_weights - weights_posterior_mean[..., 0] sampled_weights_cov = tf.reduce_mean(centered_weights[..., :, tf.newaxis] * diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index 5d8e08bdcc..6d51a5a5dc 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -267,6 +267,9 @@ def __init__(self, observation_noise_variance_prior_concentration, dtype=dtype) observation_noise_variance_prior_scale = tf.convert_to_tensor( observation_noise_variance_prior_scale, dtype=dtype) + if observation_noise_variance_upper_bound is not None: + observation_noise_variance_upper_bound = tf.convert_to_tensor( + observation_noise_variance_upper_bound, dtype=dtype) design_shape = ps.shape(design_matrix) num_outputs = design_shape[-2] @@ -283,7 +286,8 @@ def __init__(self, weights_posterior_precision = x_transpose_x + weights_prior_precision observation_noise_variance_posterior_concentration = ( - observation_noise_variance_prior_concentration + (num_outputs / 2.)) + observation_noise_variance_prior_concentration + + tf.convert_to_tensor(num_outputs / 2., dtype=dtype)) self.num_outputs = num_outputs self.num_features = num_features @@ -701,6 +705,8 @@ def _symmetric_increment_chol(chol, idx, increment): # three rank-1 Cholesky updates in a single pass? chol = tf.convert_to_tensor(chol, name='chol') increment = tf.convert_to_tensor(increment, name='increment') + orig_chol = chol + # Rank-1 update to increment the `idx`th row and column, with side # effects elsewhere in the matrix. chol = tfp_math.cholesky_update( @@ -715,11 +721,19 @@ def _symmetric_increment_chol(chol, idx, increment): multiplier=tf.sign(diagonal_correction)) # Final update to revert the side effects from the first step without # touching the (newly incremented) `idx`th row/col. - return tfp_math.cholesky_update( + chol = tfp_math.cholesky_update( chol, update_vector=_set_vector_index(increment, idx, 0.), multiplier=-1) + # There Cholesky decomposition should be unchanged in rows/cols before idx. + # + # TODO(b/229298550): Investigate whether this is really necessary, or if the + # test failures we see without this line are due to an underlying bug. + return tf.where((tf.range(chol.shape[-1]) < idx)[..., tf.newaxis], + orig_chol, + chol) + def _set_vector_index_unbatched(v, idx, x): """Mutation-free equivalent of `v[idx] = x.""" diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py index 85ef7bcdcb..02092b8ee4 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py @@ -20,15 +20,14 @@ import tensorflow.compat.v2 as tf -from tensorflow_probability import distributions as tfd +import tensorflow_probability as tfp from tensorflow_probability.python.experimental.sts_gibbs import spike_and_slab - -from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import test_util - from tensorflow_probability.python.mcmc.internal import util as mcmc_util +tfd = tfp.distributions + def _naive_symmetric_increment(m, idx, increment): m = m.copy() @@ -116,13 +115,10 @@ def test_posterior_on_nonzero_subset_matches_bayesian_regression( seed=test_util.test_seed())) # Utilities to extract values for nonzero-weight features. - nonzeros = tf.convert_to_tensor([True, False, True, False, True]) - nonzero_subvector = ( - lambda x: tf.boolean_mask(x, nonzeros, axis=ps.rank(x) - 1)) - nonzero_submatrix = lambda x: tf.boolean_mask( # pylint: disable=g-long-lambda - tf.boolean_mask(x, nonzeros, axis=ps.rank(x) - 2), - nonzeros, - axis=ps.rank(x) - 1) + nonzeros = np.array([True, False, True, False, True]) + nonzero_subvector = lambda x: x[..., nonzeros] + nonzero_submatrix = ( + lambda x: self.evaluate(x)[..., nonzeros][..., nonzeros, :]) # Compute the weight posterior mean and precision for these nonzeros. sampler = spike_and_slab.SpikeSlabSampler( @@ -148,11 +144,12 @@ def test_posterior_on_nonzero_subset_matches_bayesian_regression( # The sampler's posterior should match the posterior from the restricted # problem. self.assertAllClose( - nonzero_subvector(initial_state.conditional_weights_mean), + nonzero_subvector(self.evaluate( + initial_state.conditional_weights_mean)), restricted_weights_posterior_mean) self.assertAllClose( nonzero_submatrix(initial_state.conditional_posterior_precision_chol), - tf.linalg.cholesky(restricted_weights_posterior_prec).to_dense()) + tf.linalg.cholesky(restricted_weights_posterior_prec.to_dense())) def test_noise_variance_posterior_matches_expected(self): # Generate a synthetic regression task. @@ -270,7 +267,10 @@ def test_sanity_check_sweep_over_features(self): [0., 0., 0.5]]), seed=test_util.test_seed())) - sampler = spike_and_slab.SpikeSlabSampler(design_matrix) + sampler = spike_and_slab.SpikeSlabSampler( + design_matrix, + # Ensure the probability of keeping an irrelevant feature is tiny. + nonzero_prior_prob=1e-6) initial_state = sampler._initialize_sampler_state( targets=targets, nonzeros=tf.convert_to_tensor([True, True, True])) final_state = self.evaluate( From 609ffe354a154fb5e869e5c3e7a56cd066442d52 Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Thu, 14 Apr 2022 20:48:36 -0700 Subject: [PATCH 098/153] Update MTGPRM to be more efficient.. - Ensure MTGPRM is tape-safe in the constructor, but offer a cached implementation via `precompute_regression_model`. - Improve the cached version. Specifically, use the machinery in MTGP to do an eigendecomposition when adding observation noise, so as to avoid densifying the intermediate observation matrix. - Improve efficiency of MTGPRM when there is noise. Specifically, ensure that in the case of a Separable kernel and no missing observations, complexity of computing the mean is `O(N^3 + T^3)` where `N` is the number of observations, and `T` the number of tasks. - Improve efficiency of variance (and stddev) calculations, by avoiding densifying the covariance matrices in MTGP / MTGPRM. PiperOrigin-RevId: 441925275 --- .../python/distributions/gaussian_process.py | 3 - .../multitask_gaussian_process.py | 271 ++++++---- ...itask_gaussian_process_regression_model.py | 485 ++++++++++++++---- ..._gaussian_process_regression_model_test.py | 130 ++++- .../multitask_gaussian_process_test.py | 21 + 5 files changed, 721 insertions(+), 189 deletions(-) diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index 8c78e26635..13cb8fc878 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -672,9 +672,6 @@ def _mean(self, index_points=None): def _quantile(self, value, index_points=None): return self.get_marginal_distribution(index_points).quantile(value) - def _stddev(self, index_points=None): - return tf.sqrt(self._variance(index_points=index_points)) - def _variance(self, index_points=None): index_points = self._get_index_points(index_points) diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py index 7d65a69678..9fb8b33d4a 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process.py @@ -49,7 +49,135 @@ def _unvec(x, matrix_shape): [ps.shape(x)[:-1], matrix_shape], axis=0)) -class MultiTaskGaussianProcess(distribution.Distribution): +def _compute_flattened_scale( + kernel, + index_points, + cholesky_fn, + observation_noise_variance=None): + """Computes a matrix square root of the flattened covariance matrix. + + Given a multi-task kernel `k`, computes a matrix square root of the + matrix over all tasks of `index_points`. That is, compute `S` such that + `S^T @ S = k.matrix_over_all_tasks(index_points, index_points)`. + + In the case of a `Separable` or `Independent` kernel, this function tries to + do this efficiently in O(N^3 + T^3) time where `N` is the number of + `index_points` and `T` is the number of tasks. + + Args: + kernel: `MultiTaskKernel`-like instance representing the GP's covariance + function. + index_points: `float` `Tensor` representing finite collection, or batch of + collections, of points in the index set over which the GP is defined. + Shape has the form `[b1, ..., bB, e, f1, ..., fF]` where `F` is the + number of feature dimensions and must equal `kernel.feature_ndims` and + `e` is the number (size) of index points in each batch. Ultimately this + distribution corresponds to an `e`-dimensional multivariate normal. The + batch shape must be broadcastable with `kernel.batch_shape`. + cholesky_fn: Callable which takes a single (batch) matrix argument and + returns a Cholesky-like lower triangular factor. Default value: `None`, + in which case `make_cholesky_with_jitter_fn(1e-6)` is used. + observation_noise_variance: `float` `Tensor` representing the variance + of the noise in the Normal likelihood distribution of the model. May be + batched, in which case the batch shape must be broadcastable with the + shapes of all other batched parameters (`kernel.batch_shape`, + `index_points`, etc.). + Default value: `None` + Returns: + scale_operator: `LinearOperator` representing a matrix square root of + the flattened kernel matrix over all tasks. + + """ + # This is of shape KN x KN, where K is the number of outputs + kernel_matrix = kernel.matrix_over_all_tasks(index_points, index_points) + if observation_noise_variance is None: + return cholesky_util.cholesky_from_fn(kernel_matrix, cholesky_fn) + + observation_noise_variance = tf.convert_to_tensor(observation_noise_variance) + + # We can add the observation noise to each block. + if isinstance(kernel, multitask_kernel.Independent): + # The Independent kernel matrix is realized as a kronecker product of the + # kernel over inputs, and an identity matrix per task (representing + # independent tasks). Update the diagonal of the first matrix and take the + # cholesky of it (since the cholesky of the second matrix will remain the + # identity matrix.) + base_kernel_matrix = kernel_matrix.operators[0].to_dense() + + broadcast_shape = distribution_util.get_broadcast_shape( + base_kernel_matrix, + observation_noise_variance[..., tf.newaxis, tf.newaxis]) + base_kernel_matrix = tf.broadcast_to(base_kernel_matrix, broadcast_shape) + base_kernel_matrix = tf.linalg.set_diag( + base_kernel_matrix, + tf.linalg.diag_part(base_kernel_matrix) + + observation_noise_variance[..., tf.newaxis]) + base_kernel_matrix = tf.linalg.LinearOperatorFullMatrix( + base_kernel_matrix) + kernel_matrix = tf.linalg.LinearOperatorKronecker( + operators=[base_kernel_matrix] + kernel_matrix.operators[1:]) + return cholesky_util.cholesky_from_fn(kernel_matrix, cholesky_fn) + + if isinstance(kernel, multitask_kernel.Separable): + # When `kernel_matrix` is a kronecker product, we can compute + # an eigenvalue decomposition to get a matrix square-root, which will + # be faster than densifying the kronecker product. + + # Let K = A X B. Let A (and B) have an eigenvalue decomposition of + # U @ D @ U^T, where U is an orthogonal matrix. Then, + # K = (U_A @ D_A @ U_A^T) X (U_B @ D_B @ U_B^T) = + # (U_A X U_B) @ (D_A X D_B) @ (U_A X U_B)^T + # Thus, a matrix square root of K would be + # (U_A X U_B) @ (sqrt(D_A) X sqrt(D_B)) which offers + # efficient matmul and solves. + + # Now, if we update the diagonal by `v * I`, we have + # (U_A X U_B) @ (sqrt((D_A X D_B + vI)) @ (U_A X U_B)^T + # which still admits an efficient matmul and solve. + + kronecker_diags = [] + kronecker_orths = [] + for block in kernel_matrix.operators: + diag, orth = tf.linalg.eigh(block.to_dense()) + kronecker_diags.append(tf.linalg.LinearOperatorDiag(diag)) + kronecker_orths.append( + linear_operator_unitary.LinearOperatorUnitary(orth)) + + full_diag = tf.linalg.LinearOperatorKronecker(kronecker_diags).diag_part() + full_diag = full_diag + observation_noise_variance[..., tf.newaxis] + scale_diag = tf.math.sqrt(full_diag) + diag_operator = tf.linalg.LinearOperatorDiag( + scale_diag, + is_square=True, + is_non_singular=True, + is_positive_definite=True) + + orthogonal_operator = tf.linalg.LinearOperatorKronecker( + kronecker_orths, is_square=True, is_non_singular=True) + # This is efficient as a scale matrix. When used for matmuls, we take + # advantage of the kronecker product and diagonal operator. When used for + # solves, we take advantage of the orthogonal and diagonal structure, + # which essentially reduces to the matmul case. + return orthogonal_operator.matmul(diag_operator) + + # By default densify the kernel matrix and add noise. + + kernel_matrix = kernel_matrix.to_dense() + broadcast_shape = distribution_util.get_broadcast_shape( + kernel_matrix, + observation_noise_variance[..., tf.newaxis, tf.newaxis]) + kernel_matrix = tf.broadcast_to(kernel_matrix, broadcast_shape) + kernel_matrix = tf.linalg.set_diag( + kernel_matrix, + tf.linalg.diag_part(kernel_matrix) + + observation_noise_variance[..., tf.newaxis]) + kernel_matrix = tf.linalg.LinearOperatorFullMatrix(kernel_matrix) + kernel_cholesky = cholesky_util.cholesky_from_fn( + kernel_matrix, cholesky_fn) + return kernel_cholesky + + +class MultiTaskGaussianProcess(distribution.AutoCompositeTensorDistribution): """Marginal distribution of a Multitask GP at finitely many points.""" def __init__(self, @@ -193,101 +321,16 @@ def _event_shape_tensor(self, index_points=None): [ps.shape(index_points)[-(self.kernel.feature_ndims + 1)]], [self.kernel.num_tasks]], axis=0) - def _compute_flattened_scale(self, index_points=None): - # This is of shape KN x KN, where K is the number of outputs - index_points = self._get_index_points(index_points) - kernel_matrix = self.kernel.matrix_over_all_tasks( - index_points, index_points) - if self.observation_noise_variance is None: - return cholesky_util.cholesky_from_fn(kernel_matrix, self._cholesky_fn) - - # We can add the observation noise to each block. - if isinstance(self.kernel, multitask_kernel.Independent): - # The Independent kernel matrix is realized as a kronecker product of the - # kernel over inputs, and an identity matrix per task (representing - # independent tasks). Update the diagonal of the first matrix and take the - # cholesky of it (since the cholesky of the second matrix will remain the - # identity matrix.) - base_kernel_matrix = kernel_matrix.operators[0].to_dense() - - broadcast_shape = distribution_util.get_broadcast_shape( - base_kernel_matrix, - self.observation_noise_variance[..., tf.newaxis, tf.newaxis]) - base_kernel_matrix = tf.broadcast_to(base_kernel_matrix, broadcast_shape) - base_kernel_matrix = tf.linalg.set_diag( - base_kernel_matrix, - tf.linalg.diag_part(base_kernel_matrix) + - self.observation_noise_variance[..., tf.newaxis]) - base_kernel_matrix = tf.linalg.LinearOperatorFullMatrix( - base_kernel_matrix) - kernel_matrix = tf.linalg.LinearOperatorKronecker( - operators=[base_kernel_matrix] + kernel_matrix.operators[1:]) - return cholesky_util.cholesky_from_fn(kernel_matrix, self._cholesky_fn) - - if isinstance(self.kernel, multitask_kernel.Separable): - # When `kernel_matrix` is a kronecker product, we can compute - # an eigenvalue decomposition to get a matrix square-root, which will - # be faster than densifying the kronecker product. - - # Let K = A X B. Let A (and B) have an eigenvalue decomposition of - # U @ D @ U^T, where U is an orthogonal matrix. Then, - # K = (U_A @ D_A @ U_A^T) X (U_B @ D_B @ U_B^T) = - # (U_A X U_B) @ (D_A X D_B) @ (U_A X U_B)^T - # Thus, a matrix square root of K would be - # (U_A X U_B) @ (sqrt(D_A) X sqrt(D_B)) which offers - # efficient matmul and solves. - - # Now, if we update the diagonal by `v * I`, we have - # (U_A X U_B) @ (sqrt((D_A X D_B + vI)) @ (U_A X U_B)^T - # which still admits an efficient matmul and solve. - - kronecker_diags = [] - kronecker_orths = [] - for block in kernel_matrix.operators: - diag, orth = tf.linalg.eigh(block.to_dense()) - kronecker_diags.append(tf.linalg.LinearOperatorDiag(diag)) - kronecker_orths.append( - linear_operator_unitary.LinearOperatorUnitary(orth)) - - full_diag = tf.linalg.LinearOperatorKronecker(kronecker_diags).diag_part() - full_diag = full_diag + self.observation_noise_variance[..., tf.newaxis] - scale_diag = tf.math.sqrt(full_diag) - diag_operator = tf.linalg.LinearOperatorDiag( - scale_diag, - is_square=True, - is_non_singular=True, - is_positive_definite=True) - - orthogonal_operator = tf.linalg.LinearOperatorKronecker( - kronecker_orths, is_square=True, is_non_singular=True) - # This is efficient as a scale matrix. When used for matmuls, we take - # advantage of the kronecker product and diagonal operator. When used for - # solves, we take advantage of the orthogonal and diagonal structure, - # which essentially reduces to the matmul case. - return orthogonal_operator.matmul(diag_operator) - - # By default densify the kernel matrix and add noise. - - kernel_matrix = kernel_matrix.to_dense() - broadcast_shape = distribution_util.get_broadcast_shape( - kernel_matrix, - self.observation_noise_variance[..., tf.newaxis, tf.newaxis]) - kernel_matrix = tf.broadcast_to(kernel_matrix, broadcast_shape) - kernel_matrix = tf.linalg.set_diag( - kernel_matrix, - tf.linalg.diag_part(kernel_matrix) + - self.observation_noise_variance[..., tf.newaxis]) - kernel_matrix = tf.linalg.LinearOperatorFullMatrix(kernel_matrix) - kernel_cholesky = cholesky_util.cholesky_from_fn( - kernel_matrix, self._cholesky_fn) - return kernel_cholesky - def _get_flattened_marginal_distribution(self, index_points=None): # This returns a MVN of event size [N * E], where N is the number of tasks # and E is the number of index points. with self._name_and_control_scope('get_flattened_marginal_distribution'): index_points = self._get_index_points(index_points) - scale = self._compute_flattened_scale(index_points) + scale = _compute_flattened_scale( + kernel=self.kernel, + index_points=index_points, + cholesky_fn=self._cholesky_fn, + observation_noise_variance=self.observation_noise_variance) batch_shape = self._batch_shape_tensor(index_points=index_points) event_shape = self._event_shape_tensor(index_points=index_points) @@ -346,6 +389,52 @@ def _mean(self, index_points=None): index_points=index_points).mean(), [-1, self.kernel.num_tasks]) + def _variance(self, index_points=None): + index_points = self._get_index_points(index_points) + kernel_matrix = self.kernel.matrix_over_all_tasks( + index_points, index_points) + observation_noise_variance = None + if self.observation_noise_variance is not None: + observation_noise_variance = tf.convert_to_tensor( + self.observation_noise_variance) + + # We can add the observation noise to each block. + if isinstance(self.kernel, multitask_kernel.Independent): + single_task_variance = kernel_matrix.operators[0].diag_part() + if observation_noise_variance is not None: + single_task_variance = ( + single_task_variance + observation_noise_variance[..., tf.newaxis]) + # Each task has the same variance, so shape this in to an `[..., e, t]` + # shaped tensor and broadcast to batch shape + variance = tf.stack( + [single_task_variance] * self.kernel.num_tasks, axis=-1) + # Finally broadcast with batch shape. + batch_shape = self._batch_shape_tensor(index_points=index_points) + event_shape = self._event_shape_tensor(index_points=index_points) + + variance = tf.broadcast_to( + variance, ps.concat([batch_shape, event_shape], axis=0)) + return variance + + # If `kernel_matrix` has structure, `diag_part` will try to take advantage + # of that structure. In the case of a `Separable` kernel, `diag_part` will + # efficiently compute the diagonal of a kronecker product. + variance = kernel_matrix.diag_part() + if observation_noise_variance is not None: + variance = ( + variance + + observation_noise_variance[..., tf.newaxis]) + + variance = _unvec(variance, [-1, self.kernel.num_tasks]) + + # Finally broadcast with batch shape. + batch_shape = self._batch_shape_tensor(index_points=index_points) + event_shape = self._event_shape_tensor(index_points=index_points) + + variance = tf.broadcast_to( + variance, ps.concat([batch_shape, event_shape], axis=0)) + return variance + def _sample_n(self, n, index_points=None, seed=None): # Samples is of shape [n] + B1 + [E, N], where E is the number of index # points, and N is the number of tasks. diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py index 3c5f8a1c15..7b372f67fe 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model.py @@ -25,6 +25,7 @@ from tensorflow_probability.python.distributions import cholesky_util from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.distributions import mvn_linear_operator +from tensorflow_probability.python.experimental.distributions import multitask_gaussian_process as mtgp from tensorflow_probability.python.experimental.psd_kernels import multitask_kernel from tensorflow_probability.python.internal import batch_shape_lib from tensorflow_probability.python.internal import distribution_util @@ -54,9 +55,90 @@ def _add_diagonal_shift(m, c): return tf.linalg.set_diag(m, tf.linalg.diag_part(m) + c[..., tf.newaxis]) -class MultiTaskGaussianProcessRegressionModel(distribution.Distribution): +def _flattened_conditional_mean_fn_helper( + x, + kernel, + observations, + observation_index_points, + observations_is_missing, + observation_scale, + mean_fn, + solve_on_observations=None): + """Flattened Conditional mean helper.""" + observations = tf.convert_to_tensor(observations) + observation_index_points = tf.convert_to_tensor( + observation_index_points) + + k_x_obs_linop = kernel.matrix_over_all_tasks(x, observation_index_points) + if solve_on_observations is None: + vec_diff = _vec(observations - mean_fn(observation_index_points)) + + if observations_is_missing is not None: + k_x_obs_linop = tf.linalg.LinearOperatorFullMatrix( + tf.where(_vec(observations_is_missing)[..., tf.newaxis, :], + tf.zeros([], dtype=k_x_obs_linop.dtype), + k_x_obs_linop.to_dense())) + if solve_on_observations is None: + vec_diff = tf.where(_vec(observations_is_missing), + tf.zeros([], dtype=vec_diff.dtype), + vec_diff) + if solve_on_observations is None: + solve_on_observations = observation_scale.solvevec( + observation_scale.solvevec(vec_diff), adjoint=True) + + flattened_mean = k_x_obs_linop.matvec(solve_on_observations) + return _vec(mean_fn(x) + _unvec( + flattened_mean, [-1, kernel.num_tasks])) + + +def _compute_observation_scale( + kernel, + observation_index_points, + cholesky_fn, + observation_noise_variance=None, + observations_is_missing=None): + """Compute matrix square root of the kernel on observation index points.""" + if observations_is_missing is not None: + observations_is_missing = tf.convert_to_tensor(observations_is_missing) + # If observations are missing, there's nothing we can do to preserve the + # operator structure, so densify. + + observation_covariance = kernel.matrix_over_all_tasks( + observation_index_points, observation_index_points).to_dense() + + if observation_noise_variance is not None: + broadcast_shape = distribution_util.get_broadcast_shape( + observation_covariance, + observation_noise_variance[..., tf.newaxis, tf.newaxis]) + observation_covariance = tf.broadcast_to( + observation_covariance, broadcast_shape) + observation_covariance = _add_diagonal_shift( + observation_covariance, observation_noise_variance) + vec_observations_is_missing = _vec(observations_is_missing) + observation_covariance = tf.linalg.LinearOperatorFullMatrix( + psd_kernels_util.mask_matrix( + observation_covariance, + is_missing=vec_observations_is_missing), + is_non_singular=True, + is_positive_definite=True) + observation_scale = cholesky_util.cholesky_from_fn( + observation_covariance, cholesky_fn) + else: + observation_scale = mtgp._compute_flattened_scale( # pylint:disable=protected-access + kernel=kernel, + index_points=observation_index_points, + cholesky_fn=cholesky_fn, + observation_noise_variance=observation_noise_variance) + + return observation_scale + + +class MultiTaskGaussianProcessRegressionModel( + distribution.AutoCompositeTensorDistribution): """Posterior predictive in a conjugate Multi-task GP regression model.""" + # pylint:disable=invalid-name + def __init__(self, kernel, observation_index_points, @@ -69,13 +151,11 @@ def __init__(self, cholesky_fn=None, validate_args=False, allow_nan_stats=False, - name='MultiTaskGaussianProcessRegressionModelWithCholesky'): + name='MultiTaskGaussianProcessRegressionModelWithCholesky', + _flattened_conditional_mean_fn=None, + _observation_scale=None): """Construct a MultiTaskGaussianProcessRegressionModelWithCholesky instance. - WARNING: This method assumes `index_points` is the only varying parameter - (i.e. is a `Variable` / changes after initialization) and hence is not - tape-safe. - Args: kernel: `MultiTaskKernel`-like instance representing the GP's covariance function. @@ -140,6 +220,8 @@ def __init__(self, Default value: `False`. name: Python `str` name prefixed to Ops created by this class. Default value: 'MultiTaskGaussianProcessRegressionModel'. + _flattened_conditional_mean_fn: Internal parameter -- do not use. + _observation_scale: Internal parameter -- do not use. """ parameters = dict(locals()) with tf.name_scope(name) as name: @@ -153,17 +235,17 @@ def __init__(self, ], tf.float32) index_points = tensor_util.convert_nonref_to_tensor( index_points, dtype=dtype, name='index_points') - observation_index_points = tf.convert_to_tensor( + observation_index_points = tensor_util.convert_nonref_to_tensor( observation_index_points, dtype=dtype, name='observation_index_points') - observations = tf.convert_to_tensor( + observations = tensor_util.convert_nonref_to_tensor( observations, dtype=dtype, name='observations') if observations_is_missing is not None: - observations_is_missing = tf.convert_to_tensor( + observations_is_missing = tensor_util.convert_nonref_to_tensor( observations_is_missing, dtype=tf.bool) if observation_noise_variance is not None: - observation_noise_variance = tf.convert_to_tensor( + observation_noise_variance = tensor_util.convert_nonref_to_tensor( observation_noise_variance, dtype=dtype, name='observation_noise_variance') @@ -184,7 +266,16 @@ def __init__(self, self._index_points = index_points # Scalar or vector the size of the number of tasks. - if mean_fn is not None: + if mean_fn is None: + def _mean_fn(x): + # Shape B1 + [E, N], where E is the number of index points, and N is + # the number of tasks. + return tf.zeros( + tf.concat([ + tf.shape(x)[:-self.kernel.feature_ndims], + [self.kernel.num_tasks]], axis=0), dtype=self.dtype) + mean_fn = _mean_fn + else: if not callable(mean_fn): raise ValueError('`mean_fn` must be a Python callable') self._mean_fn = mean_fn @@ -195,95 +286,257 @@ def __init__(self, self._observations = observations self._observations_is_missing = observations_is_missing - observation_covariance = self.kernel.matrix_over_all_tasks( - observation_index_points, observation_index_points) + if _flattened_conditional_mean_fn is None: + + def flattened_conditional_mean_fn(x): + """Flattened Conditional mean.""" + observation_scale = _compute_observation_scale( + kernel, + observation_index_points, + self._cholesky_fn, + observation_noise_variance=self.observation_noise_variance, + observations_is_missing=observations_is_missing) + + return _flattened_conditional_mean_fn_helper( + x, + self.kernel, + self._observations, + self._observation_index_points, + observations_is_missing, + observation_scale, + mean_fn) + + _flattened_conditional_mean_fn = flattened_conditional_mean_fn + + self._flattened_conditional_mean_fn = _flattened_conditional_mean_fn + self._observation_scale = _observation_scale + + super(MultiTaskGaussianProcessRegressionModel, self).__init__( + dtype=dtype, + reparameterization_type=(reparameterization.FULLY_REPARAMETERIZED), + validate_args=validate_args, + allow_nan_stats=allow_nan_stats, + parameters=parameters, + name=name) + @staticmethod + def precompute_regression_model( + kernel, + observation_index_points, + observations, + observations_is_missing=None, + index_points=None, + observation_noise_variance=None, + predictive_noise_variance=None, + mean_fn=None, + cholesky_fn=None, + validate_args=False, + allow_nan_stats=False, + name='PrecomputedMultiTaskGaussianProcessRegressionModel'): + """Returns a MTGaussianProcessRegressionModel with precomputed quantities. + + This differs from the constructor by precomputing quantities associated with + observations in a non-tape safe way. `index_points` is the only parameter + that is allowed to vary (i.e. is a `Variable` / changes after + initialization). + + Specifically: + + * We make `observation_index_points` and `observations` mandatory + parameters. + * We precompute `kernel(observation_index_points, observation_index_points)` + along with any other associated quantities relating to the `kernel`, + `observations` and `observation_index_points`. + + A typical usecase would be optimizing kernel hyperparameters for a + `MultiTaskGaussianProcess`, and computing the posterior predictive with + respect to those optimized hyperparameters and observation / index-points + pairs. + + WARNING: This method assumes `index_points` is the only varying parameter + (i.e. is a `Variable` / changes after initialization) and hence is not + tape-safe. + + Args: + kernel: `PositiveSemidefiniteKernel`-like instance representing the + GP's covariance function. + observation_index_points: `float` `Tensor` representing finite collection, + or batch of collections, of points in the index set for which some data + has been observed. Shape has the form `[b1, ..., bB, e, f1, ..., fF]` + where `F` is the number of feature dimensions and must equal + `kernel.feature_ndims`, and `e` is the number (size) of index points in + each batch. `[b1, ..., bB, e]` must be broadcastable with the shape of + `observations`, and `[b1, ..., bB]` must be broadcastable with the + shapes of all other batched parameters (`kernel.batch_shape`, + `index_points`, etc). The default value is `None`, which corresponds to + the empty set of observations, and simply results in the prior + predictive model (a GP with noise of variance + `predictive_noise_variance`). + observations: `float` `Tensor` representing collection, or batch of + collections, of observations corresponding to + `observation_index_points`. Shape has the form `[b1, ..., bB, e, t]` + The batch shape `[b1, ..., bB]` must be + broadcastable with the shapes of all other batched parameters + (`kernel.batch_shape`, `index_points`, etc.). The default value is + `None`, which corresponds to the empty set of observations, and simply + results in the prior predictive model (a GP with noise of variance + `predictive_noise_variance`). + observations_is_missing: `bool` `Tensor` of shape `[..., e]`, + representing a batch of boolean masks. When `observations_is_missing` + is not `None`, the returned distribution is conditioned only on the + observations for which the corresponding elements of + `observations_is_missing` are `True`. + index_points: `float` `Tensor` representing finite collection, or batch of + collections, of points in the index set over which the GP is defined. + Shape has the form `[b1, ..., bB, e, f1, ..., fF]` where `F` is the + number of feature dimensions and must equal `kernel.feature_ndims` and + `e` is the number (size) of index points in each batch. Ultimately this + distribution corresponds to an `e`-dimensional multivariate normal. The + batch shape must be broadcastable with `kernel.batch_shape` and any + batch dims yielded by `mean_fn`. + observation_noise_variance: `float` `Tensor` representing the variance + of the noise in the Normal likelihood distribution of the model. May be + batched, in which case the batch shape must be broadcastable with the + shapes of all other batched parameters (`kernel.batch_shape`, + `index_points`, etc.). + Default value: `None` + predictive_noise_variance: `float` `Tensor` representing the variance in + the posterior predictive model. If `None`, we simply re-use + `observation_noise_variance` for the posterior predictive noise. If set + explicitly, however, we use this value. This allows us, for example, to + omit predictive noise variance (by setting this to zero) to obtain + noiseless posterior predictions of function values, conditioned on noisy + observations. + mean_fn: Python `callable` that acts on `index_points` to produce a + collection, or batch of collections, of mean values at `index_points`. + Takes a `Tensor` of shape `[b1, ..., bB, f1, ..., fF]` and returns a + `Tensor` whose shape is broadcastable with `[b1, ..., bB, t]`. + Default value: `None` implies the constant zero function. + cholesky_fn: Callable which takes a single (batch) matrix argument and + returns a Cholesky-like lower triangular factor. Default value: `None`, + in which case `make_cholesky_with_jitter_fn` is used with the `jitter` + parameter. + validate_args: Python `bool`, default `False`. When `True` distribution + parameters are checked for validity despite possibly degrading runtime + performance. When `False` invalid inputs may silently render incorrect + outputs. + Default value: `False`. + allow_nan_stats: Python `bool`, default `True`. When `True`, + statistics (e.g., mean, mode, variance) use the value `NaN` to + indicate the result is undefined. When `False`, an exception is raised + if one or more of the statistic's batch members are undefined. + Default value: `False`. + name: Python `str` name prefixed to Ops created by this class. + Default value: 'PrecomputedGaussianProcessRegressionModel'. + Returns + An instance of `MultiTaskGaussianProcessRegressionModel` with precomputed + quantities associated with observations. + """ + + with tf.name_scope(name) as name: + dtype = dtype_util.common_dtype([ + index_points, observation_index_points, observations, + observation_noise_variance, predictive_noise_variance, + ], tf.float32) + + # Convert-to-tensor arguments that are expected to not be Variables / not + # going to change. + observation_index_points = tf.convert_to_tensor( + observation_index_points, dtype=dtype) if observation_noise_variance is not None: - observation_covariance = observation_covariance.to_dense() - broadcast_shape = distribution_util.get_broadcast_shape( - observation_covariance, observation_noise_variance[..., tf.newaxis, - tf.newaxis]) - observation_covariance = tf.broadcast_to(observation_covariance, - broadcast_shape) - observation_covariance = _add_diagonal_shift(observation_covariance, - observation_noise_variance) - observation_covariance = tf.linalg.LinearOperatorFullMatrix( - observation_covariance, - is_non_singular=True, - is_positive_definite=True) + observation_noise_variance = tf.convert_to_tensor( + observation_noise_variance, dtype=dtype) + observations = tf.convert_to_tensor(observations, dtype=dtype) if observations_is_missing is not None: + observations_is_missing = tf.convert_to_tensor(observations_is_missing) + + if cholesky_fn is None: + cholesky_fn = cholesky_util.make_cholesky_with_jitter_fn() + else: + if not callable(cholesky_fn): + raise ValueError('`cholesky_fn` must be a Python callable') + + if mean_fn is None: + mean_fn = lambda x: tf.zeros([1], dtype=dtype) + else: + if not callable(mean_fn): + raise ValueError('`mean_fn` must be a Python callable') + + if observations_is_missing is not None: + # If observations are missing, there's nothing we can do to preserve the + # operator structure, so densify. + + observation_covariance = kernel.matrix_over_all_tasks( + observation_index_points, observation_index_points).to_dense() + + if observation_noise_variance is not None: + broadcast_shape = distribution_util.get_broadcast_shape( + observation_covariance, observation_noise_variance[ + ..., tf.newaxis, tf.newaxis]) + observation_covariance = tf.broadcast_to(observation_covariance, + broadcast_shape) + observation_covariance = _add_diagonal_shift( + observation_covariance, observation_noise_variance) vec_observations_is_missing = _vec(observations_is_missing) observation_covariance = tf.linalg.LinearOperatorFullMatrix( psd_kernels_util.mask_matrix( - observation_covariance.to_dense(), + observation_covariance, is_missing=vec_observations_is_missing), is_non_singular=True, is_positive_definite=True) - - self._observation_cholesky = cholesky_util.cholesky_from_fn( - observation_covariance, self._cholesky_fn) + observation_scale = cholesky_util.cholesky_from_fn( + observation_covariance, cholesky_fn) + else: + observation_scale = mtgp._compute_flattened_scale( # pylint:disable=protected-access + kernel=kernel, + index_points=observation_index_points, + cholesky_fn=cholesky_fn, + observation_noise_variance=observation_noise_variance) # Note that the conditional mean is # k(x, o) @ (k(o, o) + sigma**2)^-1 obs. We can precompute the latter # term since it won't change per iteration. - if mean_fn: - vec_observations = _vec(observations - - mean_fn(observation_index_points)) - else: - vec_observations = _vec(observations) + vec_diff = _vec(observations - mean_fn(observation_index_points)) + if observations_is_missing is not None: - vec_observations = tf.where(~vec_observations_is_missing, - vec_observations, - tf.zeros([], dtype=vec_observations.dtype)) - self._solve_on_obs = self._observation_cholesky.solvevec( - self._observation_cholesky.solvevec(vec_observations), adjoint=True) - super(MultiTaskGaussianProcessRegressionModel, self).__init__( - dtype=dtype, - reparameterization_type=(reparameterization.FULLY_REPARAMETERIZED), + vec_diff = tf.where(vec_observations_is_missing, + tf.zeros([], dtype=vec_diff.dtype), + vec_diff) + solve_on_observations = observation_scale.solvevec( + observation_scale.solvevec(vec_diff), adjoint=True) + + def flattened_conditional_mean_fn(x): + + return _flattened_conditional_mean_fn_helper( + x, + kernel, + observations, + observation_index_points, + observations_is_missing, + observation_scale, + mean_fn, + solve_on_observations=solve_on_observations) + + mtgprm = MultiTaskGaussianProcessRegressionModel( + kernel=kernel, + observation_index_points=observation_index_points, + observations=observations, + index_points=index_points, + observation_noise_variance=observation_noise_variance, + predictive_noise_variance=predictive_noise_variance, + cholesky_fn=cholesky_fn, + _flattened_conditional_mean_fn=flattened_conditional_mean_fn, + _observation_scale=observation_scale, validate_args=validate_args, allow_nan_stats=allow_nan_stats, - parameters=parameters, name=name) + return mtgprm + @property def mean_fn(self): - # Default to a constant zero function, borrowing the dtype from - # the class for consisency. - if self._mean_fn is not None: - return self._mean_fn - - def _mean_fn(x): - # Shape B1 + [E, N], where E is the number of index points, and N is the - # number of tasks. - res = tf.zeros( - tf.concat([ - tf.shape(x)[:-self.kernel.feature_ndims], [self.kernel.num_tasks] - ], - axis=0), - dtype=self.dtype) - return res - - return _mean_fn - - def _conditional_mean_fn(self, x): - """Conditional mean.""" - k_x_obs_linop = self.kernel.matrix_over_all_tasks( - x, self._observation_index_points) - if self._observations_is_missing is not None: - k_x_obs_linop = tf.linalg.LinearOperatorFullMatrix( - tf.where(_vec(tf.math.logical_not( - self._observations_is_missing))[..., tf.newaxis, :], - k_x_obs_linop.to_dense(), - tf.zeros([], dtype=k_x_obs_linop.dtype))) - - mean_x = self.mean_fn(x) # pylint:disable=not-callable - batch_shape = self._batch_shape_tensor(index_points=x) - event_shape = self._event_shape_tensor(index_points=x) - mean_x = ps.broadcast_to(mean_x, - ps.concat([batch_shape, event_shape], axis=0)) - mean_x = _vec(mean_x) - return mean_x + k_x_obs_linop.matvec(self._solve_on_obs) + return self._mean_fn @property def kernel(self): @@ -294,13 +547,17 @@ def observation_index_points(self): return self._observation_index_points @property - def observation_cholesky(self): - return self._observation_cholesky + def observation_scale(self): + return self._observation_scale @property def observations(self): return self._observations + @property + def observations_is_missing(self): + return self._observations_is_missing + @property def index_points(self): return self._index_points @@ -345,7 +602,8 @@ def _parameter_properties(cls, dtype, num_classes=None): event_ndims=0, shape_fn=lambda sample_shape: sample_shape[:-1], default_constraining_bijector_fn=( - lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), + _observation_scale=parameter_properties.BatchedComponentProperties()) def _event_shape(self): # The examples index is one position to the left of the feature dims. @@ -394,11 +652,20 @@ def _compute_flattened_covariance(self, index_points=None): kxz = self.kernel.matrix_over_all_tasks( index_points, self.observation_index_points).to_dense() if self._observations_is_missing is not None: - kxz = tf.where(_vec(tf.math.logical_not( - self._observations_is_missing))[..., tf.newaxis, :], - kxz, - tf.zeros([], dtype=kxz.dtype)) - cholinv_kzx = self.observation_cholesky.solve(kxz, adjoint_arg=True) + kxz = tf.where(_vec(self._observations_is_missing)[..., tf.newaxis, :], + tf.zeros([], dtype=kxz.dtype), + kxz) + if self._observation_scale is not None: + observation_scale = self._observation_scale + else: + observation_scale = _compute_observation_scale( + self.kernel, + self.observation_index_points, + self.cholesky_fn, + observation_noise_variance=self.observation_noise_variance, + observations_is_missing=self.observations_is_missing) + + cholinv_kzx = observation_scale.solve(kxz, adjoint_arg=True) kxz_kzzinv_kzx = tf.linalg.matmul( cholinv_kzx, cholinv_kzx, transpose_a=True) @@ -419,7 +686,7 @@ def _get_flattened_marginal_distribution(self, index_points=None): with self._name_and_control_scope('get_flattened_marginal_distribution'): index_points = self._get_index_points(index_points) covariance = self._compute_flattened_covariance(index_points) - loc = self._conditional_mean_fn(index_points) + loc = self._flattened_conditional_mean_fn(index_points) scale = tf.linalg.LinearOperatorLowerTriangular( self._cholesky_fn(covariance), is_non_singular=True, @@ -442,6 +709,48 @@ def _mean(self, index_points=None): self._get_flattened_marginal_distribution( index_points=index_points).mean(), [-1, self.kernel.num_tasks]) + def _variance(self, index_points=None): + # This is of shape KN x KN, where K is the number of outputs + # Compute this explicitly via the Schur Complement of the vector kernel. + # The reason this is written explicitly as opposed to using a GPRM + # internally for reshaping is there is potential for efficiency gains when + # `observation_noise_variance = 0.`. + index_points = self._get_index_points(index_points) + kxx_diag = self.kernel.matrix_over_all_tasks( + index_points, index_points).diag_part() + + kxz = self.kernel.matrix_over_all_tasks( + index_points, self.observation_index_points).to_dense() + if self.observations_is_missing is not None: + kxz = tf.where(_vec(self.observations_is_missing)[..., tf.newaxis, :], + tf.zeros([], dtype=kxz.dtype), kxz) + if self._observation_scale is not None: + observation_scale = self._observation_scale + else: + observation_scale = _compute_observation_scale( + self.kernel, + self.observation_index_points, + self._cholesky_fn, + observations_is_missing=self.observations_is_missing) + + cholinv_kzx = observation_scale.solve(kxz, adjoint_arg=True) + kxz_kzzinv_kzx_diag = tf.linalg.diag_part(tf.linalg.matmul( + cholinv_kzx, cholinv_kzx, transpose_a=True)) + + flattened_variance = kxx_diag - kxz_kzzinv_kzx_diag + if self.predictive_noise_variance is not None: + flattened_variance = ( + flattened_variance + self.predictive_noise_variance[..., tf.newaxis]) + + variance = _unvec(flattened_variance, [-1, self.kernel.num_tasks]) + + # Finally broadcast with batch shape. + batch_shape = self._batch_shape_tensor(index_points=index_points) + event_shape = self._event_shape_tensor(index_points=index_points) + + return tf.broadcast_to( + variance, ps.concat([batch_shape, event_shape], axis=0)) + def _sample_n(self, n, seed=None, index_points=None): # Samples is of shape [n] + B1 + [E, N], where E is the number of index # points, and N is the number of tasks. diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py index 6928f5ab0d..35fe4fba5c 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_regression_model_test.py @@ -31,6 +31,7 @@ tfd = tfp.distributions tfk = tfp.math.psd_kernels +tfed = tfp.experimental.distributions @test_util.test_all_tf_execution_regimes @@ -47,7 +48,7 @@ def testMeanShapeBroadcasts(self): multi_task_kernel = tfe.psd_kernels.Independent( num_tasks=3, base_kernel=kernel) mean = tf.Variable(np.random.random((3,)), dtype=np.float32) - gp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + gp = tfed.MultiTaskGaussianProcessRegressionModel( multi_task_kernel, observation_index_points=observation_index_points, observations=observations, @@ -80,7 +81,7 @@ def testShapes(self, num_tasks): kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) multi_task_kernel = tfe.psd_kernels.Independent( num_tasks=num_tasks, base_kernel=kernel) - gp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + gp = tfed.MultiTaskGaussianProcessRegressionModel( multi_task_kernel, observation_index_points=batched_index_points, observations=observations, @@ -125,7 +126,7 @@ def testBindingIndexPoints(self, num_tasks): multi_task_kernel = tfe.psd_kernels.Independent( num_tasks=num_tasks, base_kernel=kernel) observation_noise_variance = np.float64(1e-2) - mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + mtgp = tfed.MultiTaskGaussianProcessRegressionModel( kernel=multi_task_kernel, observation_index_points=observation_index_points, observations=observations, @@ -186,7 +187,7 @@ def testLogProbMatchesGPNoiseless(self, num_tasks): test_observations = np.random.uniform( -20., 20., [10, num_tasks]).astype(np.float32) - mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + mtgp = tfed.MultiTaskGaussianProcessRegressionModel( multi_task_kernel, observation_index_points=index_points, index_points=test_points, @@ -243,7 +244,7 @@ def testLogProbMatchesGP(self, num_tasks): test_observations = np.random.uniform( -20., 20., [10, num_tasks]).astype(np.float32) - mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + mtgp = tfed.MultiTaskGaussianProcessRegressionModel( multi_task_kernel, observation_index_points=index_points, index_points=test_points, @@ -305,7 +306,7 @@ def testNonTrivialMeanMatchesGP(self, num_tasks): # Constant mean per task. mean_fn = lambda x: tf.linspace(1., 3., num_tasks) - mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + mtgp = tfed.MultiTaskGaussianProcessRegressionModel( multi_task_kernel, observation_index_points=index_points, index_points=test_points, @@ -368,7 +369,7 @@ def mean_fn(x): return (tf.math.reduce_sum(x, axis=[-1, -2])[..., tf.newaxis] * tf.convert_to_tensor([-0.5, 2.0])) - mtgp = tfe.distributions.MultiTaskGaussianProcessRegressionModel( + mtgp = tfed.MultiTaskGaussianProcessRegressionModel( kernel, observation_index_points=index_points, observations=observations, @@ -399,5 +400,120 @@ def mean_fn(x): self.assertAllNotNan(mtgp.mean()) self.assertAllClose(tf.linalg.matrix_transpose(gp.mean()), mtgp.mean()) + def testMeanVarianceAndCovariancePrecomputed(self): + num_tasks = 3 + amplitude = np.array([1., 2.], np.float64).reshape([2, 1]) + length_scale = np.array([.1, .2, .3], np.float64).reshape([1, 3]) + observation_noise_variance = np.array([1e-9], np.float64) + + observation_index_points = ( + np.random.uniform(-1., 1., (1, 1, 7, 2)).astype(np.float64)) + observations = np.linspace( + -20., 20., 7 * num_tasks).reshape(7, num_tasks).astype(np.float64) + + index_points = np.random.uniform(-1., 1., (6, 2)).astype(np.float64) + + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + mtgprm = tfed.MultiTaskGaussianProcessRegressionModel( + kernel=multi_task_kernel, + index_points=index_points, + observation_index_points=observation_index_points, + observations=observations, + observation_noise_variance=observation_noise_variance, + validate_args=True) + + precomputed_mtgprm = tfed.MultiTaskGaussianProcessRegressionModel.precompute_regression_model( + kernel=multi_task_kernel, + index_points=index_points, + observation_index_points=observation_index_points, + observations=observations, + observation_noise_variance=observation_noise_variance, + validate_args=True) + + self.assertAllClose(self.evaluate(precomputed_mtgprm.variance()), + self.evaluate(mtgprm.variance())) + self.assertAllClose(self.evaluate(precomputed_mtgprm.mean()), + self.evaluate(mtgprm.mean())) + + def testPrecomputedWithMasking(self): + num_tasks = 2 + amplitude = np.array([1., 2., 3., 4.], np.float64) + length_scale = np.array([[.1], [.2], [.3]], np.float64) + observation_noise_variance = np.array([[1e-2], [1e-4], [1e-6]], np.float64) + + rng = test_util.test_np_rng() + # [4, 3, num_tasks] + observations_is_missing = np.array([ + [[True, False], [False, True], [True, False]], + [[False, True], [False, True], [False, True]], + [[False, False], [False, True], [True, False]], + [[True, False], [False, True], [False, False]] + ]) + observations = np.linspace( + -20., 20., 3 * num_tasks).reshape(3, num_tasks).astype(np.float64) + observations = tf.where(~observations_is_missing, observations, np.nan) + + index_points = np.linspace(1., 4., 25).reshape(5, 5).astype(np.float64) + + observation_index_points = rng.uniform( + -1., 1., (3, 1, 3, 5)).astype(np.float64) + + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + mtgprm = tfed.MultiTaskGaussianProcessRegressionModel.precompute_regression_model( + kernel=multi_task_kernel, + index_points=index_points, + observation_index_points=observation_index_points, + observations=observations, + observations_is_missing=observations_is_missing, + observation_noise_variance=observation_noise_variance, + validate_args=True) + + self.assertAllNotNan(mtgprm.mean()) + self.assertAllNotNan(mtgprm.variance()) + + @test_util.disable_test_for_backend( + disable_numpy=True, disable_jax=True, + reason='Numpy and JAX have no notion of CompositeTensor/saved_model') + def testPrecomputedCompositeTensor(self): + num_tasks = 3 + amplitude = np.array([1., 2.], np.float64).reshape([2, 1]) + length_scale = np.array([.1, .2, .3], np.float64).reshape([1, 3]) + observation_noise_variance = np.array([1e-9], np.float64) + + observation_index_points = ( + np.random.uniform(-1., 1., (1, 1, 7, 2)).astype(np.float64)) + observations = np.random.uniform( + -1., 1., (1, 1, 7, num_tasks)).astype(np.float64) + + index_points = np.random.uniform(-1., 1., (6, 2)).astype(np.float64) + + kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) + multi_task_kernel = tfe.psd_kernels.Independent( + num_tasks=num_tasks, base_kernel=kernel) + + precomputed_mtgprm = tfed.MultiTaskGaussianProcessRegressionModel.precompute_regression_model( + kernel=multi_task_kernel, + index_points=index_points, + observation_index_points=observation_index_points, + observations=observations, + observation_noise_variance=observation_noise_variance, + validate_args=True) + + flat = tf.nest.flatten(precomputed_mtgprm, expand_composites=True) + unflat = tf.nest.pack_sequence_as( + precomputed_mtgprm, flat, expand_composites=True) + self.assertIsInstance(unflat, tfed.MultiTaskGaussianProcessRegressionModel) + self.assertIsInstance(unflat, tf.__internal__.CompositeTensor) + # Check that we don't recompute the scale matrix on flattening / + # unflattening. In this case it's a kronecker product of a lower triangular + # and an identity, so we only check the first factor. + self.assertIs(precomputed_mtgprm._observation_scale.operators[0]._tril, # pylint:disable=protected-access + unflat._observation_scale.operators[0]._tril) # pylint:disable=protected-access + + if __name__ == '__main__': test_util.main() diff --git a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py index 9b978bf4dd..4e0c38a867 100644 --- a/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py +++ b/tensorflow_probability/python/experimental/distributions/multitask_gaussian_process_test.py @@ -127,6 +127,9 @@ def testShapes(self): self.assertAllEqual( self.evaluate(tf.shape(gp.mean())), batch_shape + event_shape) + self.assertAllEqual( + self.evaluate(tf.shape(gp.variance())), batch_shape + event_shape) + def testBindingIndexPoints(self): amplitude = np.float64(0.5) length_scale = np.float64(2.) @@ -166,6 +169,12 @@ def testBindingIndexPoints(self): self.assertAllClose( single_task_mean_, multi_task_mean_[..., i], rtol=1e-3) + multi_task_var_ = self.evaluate(mtgp.variance(index_points=index_points)) + single_task_var_ = self.evaluate(gp.variance(index_points=index_points)) + for i in range(3): + self.assertAllClose( + single_task_var_, multi_task_var_[..., i], rtol=1e-3) + def testConstantMeanFunction(self): # 5x5 grid of index points in R^2 and flatten to 25x2 index_points = np.linspace(-4., 4., 5, dtype=np.float32) @@ -355,6 +364,18 @@ def testMultiTaskBlockSeparable(self): self.evaluate(actual_multitask_log_prob), self.evaluate(multitask_log_prob), rtol=4e-3) + multitask_mean = multitask_gp.mean() + actual_multitask_mean = actual_multitask_gp.mean() + self.assertAllClose( + self.evaluate(actual_multitask_mean), + self.evaluate(multitask_mean), rtol=4e-3) + + multitask_var = multitask_gp.variance() + actual_multitask_var = actual_multitask_gp.variance() + self.assertAllClose( + self.evaluate(actual_multitask_var), + self.evaluate(multitask_var), rtol=4e-3) + def testLogProbMatchesGP(self): # Check that the independent kernel parameterization matches using a # single-task GP. From d50d9a85907b08d317dca934dbbd5beb47619cb0 Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Thu, 14 Apr 2022 21:49:44 -0700 Subject: [PATCH 099/153] Update `LinearOperatorFullMatrix` and `LinearOperatorLowerTriangular` to expose constructor arguments. PiperOrigin-RevId: 441932968 --- .../backend/numpy/gen/linear_operator_full_matrix.py | 5 +++++ .../backend/numpy/gen/linear_operator_lower_triangular.py | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py index e1f669cf0a..83b7f6dbc5 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py @@ -192,6 +192,11 @@ def _check_matrix(self, matrix): raise ValueError(f"Argument `matrix` must have at least 2 dimensions. " f"Received: {matrix}.") + @property + def matrix(self): + """The matrix defining this operator.""" + return self._matrix + def _shape(self): return tensor_shape.TensorShape(self._matrix.shape) diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py index e71b38ace4..7965254377 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py @@ -180,6 +180,11 @@ def __init__(self, parameters=parameters, name=name) + @property + def tril(self): + """The lower triangular matrix defining this operator.""" + return self._tril + def _check_tril(self, tril): """Static check of the `tril` argument.""" From 465234acab16bda0e5c6d39a42c7eb29d316e4b1 Mon Sep 17 00:00:00 2001 From: Christopher Suter Date: Mon, 18 Apr 2022 13:54:22 -0700 Subject: [PATCH 100/153] Unbreak TFP on JAX OSS tests by pinning JAX version. c.f. https://github.com/google/jax/issues/10331 PiperOrigin-RevId: 442623798 --- testing/dependency_install_lib.sh | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/testing/dependency_install_lib.sh b/testing/dependency_install_lib.sh index 45f3412103..b8541f7bf2 100644 --- a/testing/dependency_install_lib.sh +++ b/testing/dependency_install_lib.sh @@ -67,7 +67,9 @@ install_tensorflow() { install_jax() { # For the JAX backend. PIP_FLAGS=${1-} - python -m pip install $PIP_FLAGS jax jaxlib + JAX_VERSION='0.3.5' + python -m pip install \ + $PIP_FLAGS "jax==${JAX_VERSION}" "jaxlib==${JAX_VERSION}" } install_common_packages() { From e05ce3fc2e618fd2801f42819f65a4c60f1d5558 Mon Sep 17 00:00:00 2001 From: phawkins Date: Mon, 18 Apr 2022 17:20:34 -0700 Subject: [PATCH 101/153] [JAX] Remove xla.call_translations from JAX. Oryx appears to be the only user. PiperOrigin-RevId: 442671871 --- spinoffs/oryx/oryx/core/interpreters/harvest.py | 12 ------------ spinoffs/oryx/oryx/core/primitive.py | 15 --------------- 2 files changed, 27 deletions(-) diff --git a/spinoffs/oryx/oryx/core/interpreters/harvest.py b/spinoffs/oryx/oryx/core/interpreters/harvest.py index 452b47d121..3b5f3a140a 100644 --- a/spinoffs/oryx/oryx/core/interpreters/harvest.py +++ b/spinoffs/oryx/oryx/core/interpreters/harvest.py @@ -235,18 +235,6 @@ def _nest_impl(f, *args, **_): nest_p.def_impl(_nest_impl) -if hasattr(xla, '_xla_call_translation_rule'): - - def _nest_translation_rule(*args, name, call_jaxpr, scope, **_): - return xla._xla_call_translation_rule( # pylint: disable=protected-access # type: ignore - *args, - name=jax_util.wrap_name(name, f'nest[{scope}]'), - call_jaxpr=call_jaxpr, - donated_invars=(False,) * len(args)) - - xla.register_translation(nest_p, _nest_translation_rule) - - def _nest_lowering(ctx, *args, name, call_jaxpr, scope, **_): return mlir._xla_call_lower( # pylint: disable=protected-access ctx, diff --git a/spinoffs/oryx/oryx/core/primitive.py b/spinoffs/oryx/oryx/core/primitive.py index db2071e05d..4ea8d3f06c 100644 --- a/spinoffs/oryx/oryx/core/primitive.py +++ b/spinoffs/oryx/oryx/core/primitive.py @@ -100,21 +100,6 @@ def rule(*args, **kwargs): register_hop_transformation_rule('transpose', hop_transpose_rule) -def hop_translation_rule(prim): - - def rule(*args, backend, name, call_jaxpr, **params): - new_params = dict(name=name, backend=backend, call_jaxpr=call_jaxpr) - new_params['donated_invars'] = params.get('donated_invars', - (False,) * len(args)) - return xla._xla_call_translation_rule(*args, **new_params) # pylint: disable=protected-access # type: ignore - - xla.call_translations[prim] = rule - return rule - -if hasattr(xla, '_xla_call_translation_rule'): - register_hop_transformation_rule('translation', hop_translation_rule) - - def hop_lowering(prim): def rule(ctx, *args, backend, name, call_jaxpr, **_params): From 3d625961d7a6f77a5dc87a3792c7a950b2d73f1a Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Mon, 18 Apr 2022 20:09:20 -0700 Subject: [PATCH 102/153] Ensure that tfp.math.logerfc(x) is correct at zero. PiperOrigin-RevId: 442698152 --- tensorflow_probability/python/math/special.py | 4 ++-- tensorflow_probability/python/math/special_test.py | 9 +++++++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/math/special.py b/tensorflow_probability/python/math/special.py index a0e3ad72c6..799a4709b8 100644 --- a/tensorflow_probability/python/math/special.py +++ b/tensorflow_probability/python/math/special.py @@ -399,7 +399,7 @@ def logerfc(x, name=None): with tf.name_scope(name or 'logerfc'): dtype = dtype_util.common_dtype([x], tf.float32) x = tf.convert_to_tensor(x, dtype=dtype) - safe_positive_x = tf.where(x > 0., x, 1.) + safe_positive_x = tf.where(x >= 0., x, 1.) safe_negative_x = tf.where(x < 0., x, -1.) return tf.where( x < 0., @@ -425,7 +425,7 @@ def logerfcx(x, name=None): with tf.name_scope(name or 'logerfc'): dtype = dtype_util.common_dtype([x], tf.float32) x = tf.convert_to_tensor(x, dtype=dtype) - safe_positive_x = tf.where(x > 0., x, 1.) + safe_positive_x = tf.where(x >= 0., x, 1.) safe_negative_x = tf.where(x < 0., x, -1.) return tf.where( x < 0., diff --git a/tensorflow_probability/python/math/special_test.py b/tensorflow_probability/python/math/special_test.py index d08f605a31..429c2f76f0 100644 --- a/tensorflow_probability/python/math/special_test.py +++ b/tensorflow_probability/python/math/special_test.py @@ -703,6 +703,15 @@ def testLogErfcxValueAndGradientNoNaN(self, dtype): self.assertAllNotNan(logerfcx_) self.assertAllNotNan(grad_logerfcx_) + @parameterized.parameters(tf.float32, tf.float64) + def testLogErfcxAtZero(self, dtype): + x = tf.constant(0., dtype=dtype) + logerfcx_, logerfc_ = self.evaluate([ + tfp.math.logerfcx(x), + tfp.math.logerfc(x)]) + self.assertAllClose(np.log(scipy_special.erfc(0.)), logerfc_) + self.assertAllClose(np.log(scipy_special.erfcx(0.)), logerfcx_) + # See https://en.wikipedia.org/wiki/Lambert_W_function#Special_values # for a list of special values and known identities. @parameterized.named_parameters( From 8a0692abc486406ceb4cab3bbca42d693e871963 Mon Sep 17 00:00:00 2001 From: phandu Date: Tue, 19 Apr 2022 09:45:42 -0700 Subject: [PATCH 103/153] Relax JAX version of JAX OSS tests given the release of chex 0.1.3, which fixes the recent breakage. PiperOrigin-RevId: 442835961 --- testing/dependency_install_lib.sh | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/testing/dependency_install_lib.sh b/testing/dependency_install_lib.sh index b8541f7bf2..45f3412103 100644 --- a/testing/dependency_install_lib.sh +++ b/testing/dependency_install_lib.sh @@ -67,9 +67,7 @@ install_tensorflow() { install_jax() { # For the JAX backend. PIP_FLAGS=${1-} - JAX_VERSION='0.3.5' - python -m pip install \ - $PIP_FLAGS "jax==${JAX_VERSION}" "jaxlib==${JAX_VERSION}" + python -m pip install $PIP_FLAGS jax jaxlib } install_common_packages() { From e84f7926b0848dc8e86cac19696aeb3db6529265 Mon Sep 17 00:00:00 2001 From: yileiyang Date: Thu, 21 Apr 2022 11:08:29 -0700 Subject: [PATCH 104/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 443426675 --- spinoffs/oryx/oryx/core/interpreters/harvest.py | 1 - spinoffs/oryx/oryx/core/interpreters/harvest_test.py | 1 - spinoffs/oryx/oryx/core/interpreters/log_prob.py | 1 - spinoffs/oryx/oryx/core/interpreters/log_prob_test.py | 1 - spinoffs/oryx/oryx/core/interpreters/propagate.py | 1 - spinoffs/oryx/oryx/core/interpreters/unzip.py | 1 - spinoffs/oryx/oryx/core/interpreters/unzip_test.py | 1 - spinoffs/oryx/oryx/core/kwargs_util.py | 1 - spinoffs/oryx/oryx/core/kwargs_util_test.py | 1 - spinoffs/oryx/oryx/core/ppl/__init__.py | 1 - spinoffs/oryx/oryx/core/ppl/effect_handler.py | 1 - spinoffs/oryx/oryx/core/ppl/effect_handler_test.py | 1 - spinoffs/oryx/oryx/core/ppl/transformations.py | 1 - spinoffs/oryx/oryx/core/ppl/transformations_test.py | 1 - spinoffs/oryx/oryx/core/primitive.py | 1 - spinoffs/oryx/oryx/core/pytree.py | 1 - spinoffs/oryx/oryx/core/serialize.py | 1 - spinoffs/oryx/oryx/core/state/__init__.py | 1 - spinoffs/oryx/oryx/core/state/api.py | 1 - spinoffs/oryx/oryx/core/state/function.py | 1 - spinoffs/oryx/oryx/core/state/function_test.py | 1 - spinoffs/oryx/oryx/core/state/module.py | 1 - spinoffs/oryx/oryx/core/state/registrations.py | 1 - spinoffs/oryx/oryx/core/trace_util.py | 1 - 24 files changed, 24 deletions(-) diff --git a/spinoffs/oryx/oryx/core/interpreters/harvest.py b/spinoffs/oryx/oryx/core/interpreters/harvest.py index 3b5f3a140a..29ed728293 100644 --- a/spinoffs/oryx/oryx/core/interpreters/harvest.py +++ b/spinoffs/oryx/oryx/core/interpreters/harvest.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for the harvest transformation. This module contains a general-purpose set of tools for transforming diff --git a/spinoffs/oryx/oryx/core/interpreters/harvest_test.py b/spinoffs/oryx/oryx/core/interpreters/harvest_test.py index 937525afea..3bdad4c9b4 100644 --- a/spinoffs/oryx/oryx/core/interpreters/harvest_test.py +++ b/spinoffs/oryx/oryx/core/interpreters/harvest_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.interpreters.harvest.""" import functools import os diff --git a/spinoffs/oryx/oryx/core/interpreters/log_prob.py b/spinoffs/oryx/oryx/core/interpreters/log_prob.py index 3dcf012113..b469965f3c 100644 --- a/spinoffs/oryx/oryx/core/interpreters/log_prob.py +++ b/spinoffs/oryx/oryx/core/interpreters/log_prob.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for log_prob transformation.""" from jax import core as jax_core from jax import random diff --git a/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py b/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py index 8831bc9fd7..103ee23bbe 100644 --- a/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py +++ b/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.interpreters.log_prob.""" from absl.testing import absltest import jax diff --git a/spinoffs/oryx/oryx/core/interpreters/propagate.py b/spinoffs/oryx/oryx/core/interpreters/propagate.py index 23d2b3c827..295965a8b1 100644 --- a/spinoffs/oryx/oryx/core/interpreters/propagate.py +++ b/spinoffs/oryx/oryx/core/interpreters/propagate.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for the propagate custom Jaxpr interpreter. The propagate Jaxpr interpreter converts a Jaxpr to a directed graph where diff --git a/spinoffs/oryx/oryx/core/interpreters/unzip.py b/spinoffs/oryx/oryx/core/interpreters/unzip.py index f9d79998e1..6e805c0a5f 100644 --- a/spinoffs/oryx/oryx/core/interpreters/unzip.py +++ b/spinoffs/oryx/oryx/core/interpreters/unzip.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for the unzip function transformation. Unzip is a function transformation that looks diff --git a/spinoffs/oryx/oryx/core/interpreters/unzip_test.py b/spinoffs/oryx/oryx/core/interpreters/unzip_test.py index 74d1298d48..b48dbe41e7 100644 --- a/spinoffs/oryx/oryx/core/interpreters/unzip_test.py +++ b/spinoffs/oryx/oryx/core/interpreters/unzip_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.interpreters.unzip.""" import functools diff --git a/spinoffs/oryx/oryx/core/kwargs_util.py b/spinoffs/oryx/oryx/core/kwargs_util.py index 109b75c574..a65bdd8b5b 100644 --- a/spinoffs/oryx/oryx/core/kwargs_util.py +++ b/spinoffs/oryx/oryx/core/kwargs_util.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module that provides kwargs utility functions.""" import functools import inspect diff --git a/spinoffs/oryx/oryx/core/kwargs_util_test.py b/spinoffs/oryx/oryx/core/kwargs_util_test.py index e991d02410..f4050ec274 100644 --- a/spinoffs/oryx/oryx/core/kwargs_util_test.py +++ b/spinoffs/oryx/oryx/core/kwargs_util_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.kwargs_util.""" from absl.testing import absltest diff --git a/spinoffs/oryx/oryx/core/ppl/__init__.py b/spinoffs/oryx/oryx/core/ppl/__init__.py index 88f87fa233..1a3763b6c5 100644 --- a/spinoffs/oryx/oryx/core/ppl/__init__.py +++ b/spinoffs/oryx/oryx/core/ppl/__init__.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for probabilistic programming features.""" from oryx.core.ppl.effect_handler import make_effect_handler from oryx.core.ppl.transformations import block diff --git a/spinoffs/oryx/oryx/core/ppl/effect_handler.py b/spinoffs/oryx/oryx/core/ppl/effect_handler.py index b3a5f5d632..dc4765c0ca 100644 --- a/spinoffs/oryx/oryx/core/ppl/effect_handler.py +++ b/spinoffs/oryx/oryx/core/ppl/effect_handler.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Enables writing custom effect handlers for probabilistic programs. # Background diff --git a/spinoffs/oryx/oryx/core/ppl/effect_handler_test.py b/spinoffs/oryx/oryx/core/ppl/effect_handler_test.py index 80a1e2f0cc..ee248663b5 100644 --- a/spinoffs/oryx/oryx/core/ppl/effect_handler_test.py +++ b/spinoffs/oryx/oryx/core/ppl/effect_handler_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.ppl.effect_handler.""" from absl.testing import absltest import jax diff --git a/spinoffs/oryx/oryx/core/ppl/transformations.py b/spinoffs/oryx/oryx/core/ppl/transformations.py index d8f4dafd8a..72d1c0ab4d 100644 --- a/spinoffs/oryx/oryx/core/ppl/transformations.py +++ b/spinoffs/oryx/oryx/core/ppl/transformations.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for probabilistic programming transformations. ## Probabilistic programs diff --git a/spinoffs/oryx/oryx/core/ppl/transformations_test.py b/spinoffs/oryx/oryx/core/ppl/transformations_test.py index 652b9e9ff7..c3a030afdf 100644 --- a/spinoffs/oryx/oryx/core/ppl/transformations_test.py +++ b/spinoffs/oryx/oryx/core/ppl/transformations_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.ppl.transformations.""" from absl.testing import absltest diff --git a/spinoffs/oryx/oryx/core/primitive.py b/spinoffs/oryx/oryx/core/primitive.py index 4ea8d3f06c..0437fe410b 100644 --- a/spinoffs/oryx/oryx/core/primitive.py +++ b/spinoffs/oryx/oryx/core/primitive.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for higher order primitives.""" import itertools as it from typing import Callable diff --git a/spinoffs/oryx/oryx/core/pytree.py b/spinoffs/oryx/oryx/core/pytree.py index 4b136d68cc..8322226ffd 100644 --- a/spinoffs/oryx/oryx/core/pytree.py +++ b/spinoffs/oryx/oryx/core/pytree.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains the Pytree class.""" import abc from jax import tree_util diff --git a/spinoffs/oryx/oryx/core/serialize.py b/spinoffs/oryx/oryx/core/serialize.py index 87d3ce8f96..e9287054bb 100644 --- a/spinoffs/oryx/oryx/core/serialize.py +++ b/spinoffs/oryx/oryx/core/serialize.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains logic for serializing and deserializing PytreeTypes.""" import pickle diff --git a/spinoffs/oryx/oryx/core/state/__init__.py b/spinoffs/oryx/oryx/core/state/__init__.py index 4c41abecec..a18f18b4d7 100644 --- a/spinoffs/oryx/oryx/core/state/__init__.py +++ b/spinoffs/oryx/oryx/core/state/__init__.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for stateful functions.""" from oryx.core.state import registrations from oryx.core.state.api import ArraySpec diff --git a/spinoffs/oryx/oryx/core/state/api.py b/spinoffs/oryx/oryx/core/state/api.py index 42200d6d16..7ccd7e91aa 100644 --- a/spinoffs/oryx/oryx/core/state/api.py +++ b/spinoffs/oryx/oryx/core/state/api.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for single-dispatch functions for handling state. This module defines single-dispatch functions that are used to construct diff --git a/spinoffs/oryx/oryx/core/state/function.py b/spinoffs/oryx/oryx/core/state/function.py index 503477a08a..6206d87422 100644 --- a/spinoffs/oryx/oryx/core/state/function.py +++ b/spinoffs/oryx/oryx/core/state/function.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for transforming functions into FunctionModules. In order to `init` functions, we need to define a `Module` subclass for them, diff --git a/spinoffs/oryx/oryx/core/state/function_test.py b/spinoffs/oryx/oryx/core/state/function_test.py index 79a2048b23..3e0c1b3f97 100644 --- a/spinoffs/oryx/oryx/core/state/function_test.py +++ b/spinoffs/oryx/oryx/core/state/function_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.state.function.""" from absl.testing import absltest diff --git a/spinoffs/oryx/oryx/core/state/module.py b/spinoffs/oryx/oryx/core/state/module.py index 70a840aefd..6b0e38f6d7 100644 --- a/spinoffs/oryx/oryx/core/state/module.py +++ b/spinoffs/oryx/oryx/core/state/module.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains highest-level abstractions for the stateful function API.""" import abc from typing import Any, Dict, Tuple diff --git a/spinoffs/oryx/oryx/core/state/registrations.py b/spinoffs/oryx/oryx/core/state/registrations.py index 43a023e105..6d2dfb59a2 100644 --- a/spinoffs/oryx/oryx/core/state/registrations.py +++ b/spinoffs/oryx/oryx/core/state/registrations.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Registers state dispatch functions with Python data structures. In this module, we provide registrations for some Python data structures diff --git a/spinoffs/oryx/oryx/core/trace_util.py b/spinoffs/oryx/oryx/core/trace_util.py index 23b854889a..73b9e81e8d 100644 --- a/spinoffs/oryx/oryx/core/trace_util.py +++ b/spinoffs/oryx/oryx/core/trace_util.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for JAX tracing utility functions.""" import contextlib import threading From c12f6265fd3349c98b7f4807cf6024e43ad7ee25 Mon Sep 17 00:00:00 2001 From: yileiyang Date: Thu, 21 Apr 2022 12:01:47 -0700 Subject: [PATCH 105/153] Remove unused comments related to Python 2 compatibility. PiperOrigin-RevId: 443441522 --- .../inference_gym/inference_gym/targets/lorenz_system_test.py | 1 - spinoffs/oryx/oryx/bijectors/bijector_extensions.py | 1 - spinoffs/oryx/oryx/bijectors/bijector_extensions_test.py | 1 - spinoffs/oryx/oryx/core/interpreters/inverse/custom_inverse.py | 1 - spinoffs/oryx/oryx/core/interpreters/inverse/slice.py | 1 - spinoffs/oryx/oryx/core/interpreters/inverse/slice_test.py | 1 - spinoffs/oryx/oryx/distributions/distribution_extensions.py | 1 - spinoffs/oryx/oryx/distributions/distribution_extensions_test.py | 1 - spinoffs/oryx/oryx/experimental/__init__.py | 1 - spinoffs/oryx/oryx/experimental/mcmc/__init__.py | 1 - spinoffs/oryx/oryx/experimental/mcmc/kernels.py | 1 - spinoffs/oryx/oryx/experimental/mcmc/kernels_test.py | 1 - spinoffs/oryx/oryx/experimental/nn/base.py | 1 - spinoffs/oryx/oryx/experimental/nn/function.py | 1 - spinoffs/oryx/oryx/experimental/optimizers/__init__.py | 1 - spinoffs/oryx/oryx/experimental/optimizers/optix.py | 1 - spinoffs/oryx/oryx/internal/__init__.py | 1 - spinoffs/oryx/oryx/internal/test_util.py | 1 - spinoffs/oryx/oryx/util/__init__.py | 1 - spinoffs/oryx/oryx/util/summary.py | 1 - spinoffs/oryx/oryx/util/summary_test.py | 1 - .../python/experimental/util/special_methods.py | 1 - 22 files changed, 22 deletions(-) diff --git a/spinoffs/inference_gym/inference_gym/targets/lorenz_system_test.py b/spinoffs/inference_gym/inference_gym/targets/lorenz_system_test.py index 3c515a93e6..0ce07b1fae 100644 --- a/spinoffs/inference_gym/inference_gym/targets/lorenz_system_test.py +++ b/spinoffs/inference_gym/inference_gym/targets/lorenz_system_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python2, python3 """Tests for inference_gym.targets.lorenz_system.""" import functools diff --git a/spinoffs/oryx/oryx/bijectors/bijector_extensions.py b/spinoffs/oryx/oryx/bijectors/bijector_extensions.py index 179e61921e..e8dab305c7 100644 --- a/spinoffs/oryx/oryx/bijectors/bijector_extensions.py +++ b/spinoffs/oryx/oryx/bijectors/bijector_extensions.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Wraps TFP bijectors for use with Jax.""" from jax import tree_util from jax import util as jax_util diff --git a/spinoffs/oryx/oryx/bijectors/bijector_extensions_test.py b/spinoffs/oryx/oryx/bijectors/bijector_extensions_test.py index 0b1bc11572..68cd5d2a08 100644 --- a/spinoffs/oryx/oryx/bijectors/bijector_extensions_test.py +++ b/spinoffs/oryx/oryx/bijectors/bijector_extensions_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.bijectors.bijectors_extensions.""" from absl.testing import absltest diff --git a/spinoffs/oryx/oryx/core/interpreters/inverse/custom_inverse.py b/spinoffs/oryx/oryx/core/interpreters/inverse/custom_inverse.py index 69c809fb34..9b991412f2 100644 --- a/spinoffs/oryx/oryx/core/interpreters/inverse/custom_inverse.py +++ b/spinoffs/oryx/oryx/core/interpreters/inverse/custom_inverse.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains logic for defining custom inverses for functions. Automatic inversion works for only a certain class of functions (see diff --git a/spinoffs/oryx/oryx/core/interpreters/inverse/slice.py b/spinoffs/oryx/oryx/core/interpreters/inverse/slice.py index 39e8f67ac3..5048d99e08 100644 --- a/spinoffs/oryx/oryx/core/interpreters/inverse/slice.py +++ b/spinoffs/oryx/oryx/core/interpreters/inverse/slice.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains slice abstractions used in function inversion.""" from typing import Any diff --git a/spinoffs/oryx/oryx/core/interpreters/inverse/slice_test.py b/spinoffs/oryx/oryx/core/interpreters/inverse/slice_test.py index 3e1e5b1bdf..13c14db325 100644 --- a/spinoffs/oryx/oryx/core/interpreters/inverse/slice_test.py +++ b/spinoffs/oryx/oryx/core/interpreters/inverse/slice_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.core.interpreters.inverse.slice.""" from absl.testing import absltest diff --git a/spinoffs/oryx/oryx/distributions/distribution_extensions.py b/spinoffs/oryx/oryx/distributions/distribution_extensions.py index b134efdbe4..082863d43c 100644 --- a/spinoffs/oryx/oryx/distributions/distribution_extensions.py +++ b/spinoffs/oryx/oryx/distributions/distribution_extensions.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Wraps TFP distributions for use with Jax.""" import itertools as it diff --git a/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py b/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py index 99350258da..bb2c7c7b1e 100644 --- a/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py +++ b/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.distributions.distributions_extensions.""" from absl.testing import absltest diff --git a/spinoffs/oryx/oryx/experimental/__init__.py b/spinoffs/oryx/oryx/experimental/__init__.py index 9263ce1fce..21d25c2005 100644 --- a/spinoffs/oryx/oryx/experimental/__init__.py +++ b/spinoffs/oryx/oryx/experimental/__init__.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for experimental Oryx libraries.""" from oryx.experimental import matching from oryx.experimental import mcmc diff --git a/spinoffs/oryx/oryx/experimental/mcmc/__init__.py b/spinoffs/oryx/oryx/experimental/mcmc/__init__.py index 6221b4a83c..c8193b926e 100644 --- a/spinoffs/oryx/oryx/experimental/mcmc/__init__.py +++ b/spinoffs/oryx/oryx/experimental/mcmc/__init__.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for Markov Chain Monte Carlo.""" from oryx.experimental.mcmc.kernels import hmc from oryx.experimental.mcmc.kernels import mala diff --git a/spinoffs/oryx/oryx/experimental/mcmc/kernels.py b/spinoffs/oryx/oryx/experimental/mcmc/kernels.py index 1adc5850d0..321edde3da 100644 --- a/spinoffs/oryx/oryx/experimental/mcmc/kernels.py +++ b/spinoffs/oryx/oryx/experimental/mcmc/kernels.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains probabilistic program kernels for MCMC.""" import jax from jax import lax diff --git a/spinoffs/oryx/oryx/experimental/mcmc/kernels_test.py b/spinoffs/oryx/oryx/experimental/mcmc/kernels_test.py index b7a85dc4c9..2743bf9fda 100644 --- a/spinoffs/oryx/oryx/experimental/mcmc/kernels_test.py +++ b/spinoffs/oryx/oryx/experimental/mcmc/kernels_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.experimental.mcmc.kernels.""" from absl.testing import absltest from absl.testing import parameterized diff --git a/spinoffs/oryx/oryx/experimental/nn/base.py b/spinoffs/oryx/oryx/experimental/nn/base.py index 764635c2d7..c085380c3c 100644 --- a/spinoffs/oryx/oryx/experimental/nn/base.py +++ b/spinoffs/oryx/oryx/experimental/nn/base.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains the `Template` and `Layer` API for Oryx. `Module`s are an abstraction provided by Oryx that enable encapsulating both diff --git a/spinoffs/oryx/oryx/experimental/nn/function.py b/spinoffs/oryx/oryx/experimental/nn/function.py index b9d20e453f..ddf32bd274 100644 --- a/spinoffs/oryx/oryx/experimental/nn/function.py +++ b/spinoffs/oryx/oryx/experimental/nn/function.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Registers custom rules for neural networks in the stateful function API. The Oryx state API enables having a custom unzip rules when `init`-ing a diff --git a/spinoffs/oryx/oryx/experimental/optimizers/__init__.py b/spinoffs/oryx/oryx/experimental/optimizers/__init__.py index a19d779b8d..d04d8ef617 100644 --- a/spinoffs/oryx/oryx/experimental/optimizers/__init__.py +++ b/spinoffs/oryx/oryx/experimental/optimizers/__init__.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for optimizers in Oryx.""" from oryx.experimental.optimizers.optix import adam from oryx.experimental.optimizers.optix import gradient_descent diff --git a/spinoffs/oryx/oryx/experimental/optimizers/optix.py b/spinoffs/oryx/oryx/experimental/optimizers/optix.py index ccfeebfab6..2d1010ca33 100644 --- a/spinoffs/oryx/oryx/experimental/optimizers/optix.py +++ b/spinoffs/oryx/oryx/experimental/optimizers/optix.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Reimplementation of a subset of the optax library using Oryx's state system. This module is an advanced example of how to write stateful code using Oryx. For diff --git a/spinoffs/oryx/oryx/internal/__init__.py b/spinoffs/oryx/oryx/internal/__init__.py index 26bfbb1cdb..e754ce5f1e 100644 --- a/spinoffs/oryx/oryx/internal/__init__.py +++ b/spinoffs/oryx/oryx/internal/__init__.py @@ -12,6 +12,5 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Module for internal utilities like testing.""" from oryx.internal import test_util diff --git a/spinoffs/oryx/oryx/internal/test_util.py b/spinoffs/oryx/oryx/internal/test_util.py index 3263762d06..9eb4b97212 100644 --- a/spinoffs/oryx/oryx/internal/test_util.py +++ b/spinoffs/oryx/oryx/internal/test_util.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains utilities for testing.""" from absl.testing import parameterized diff --git a/spinoffs/oryx/oryx/util/__init__.py b/spinoffs/oryx/oryx/util/__init__.py index 5dd107f67f..a4bde07cb9 100644 --- a/spinoffs/oryx/oryx/util/__init__.py +++ b/spinoffs/oryx/oryx/util/__init__.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains Oryx utility functions.""" from oryx.util.summary import get_summaries from oryx.util.summary import summary diff --git a/spinoffs/oryx/oryx/util/summary.py b/spinoffs/oryx/oryx/util/summary.py index 60079440b8..4dd5d8e3c5 100644 --- a/spinoffs/oryx/oryx/util/summary.py +++ b/spinoffs/oryx/oryx/util/summary.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Contains utilities for collecting intermediate summary values.""" import functools from oryx.core.interpreters import harvest diff --git a/spinoffs/oryx/oryx/util/summary_test.py b/spinoffs/oryx/oryx/util/summary_test.py index aec61ef2f3..ed12d48fca 100644 --- a/spinoffs/oryx/oryx/util/summary_test.py +++ b/spinoffs/oryx/oryx/util/summary_test.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Tests for tensorflow_probability.spinoffs.oryx.util.summary.""" from absl.testing import absltest diff --git a/tensorflow_probability/python/experimental/util/special_methods.py b/tensorflow_probability/python/experimental/util/special_methods.py index 58c1351ec7..b5c94c7ef3 100644 --- a/tensorflow_probability/python/experimental/util/special_methods.py +++ b/tensorflow_probability/python/experimental/util/special_methods.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ -# Lint as: python3 """Annotations of special functions.""" import builtins From 572d8f80ee412574921f63c50e7aac555bf9008a Mon Sep 17 00:00:00 2001 From: maxjiang Date: Fri, 22 Apr 2022 17:31:04 -0700 Subject: [PATCH 106/153] Allow OneByOneConv bijector name to be parameterized at initialization input. PiperOrigin-RevId: 443800147 --- tensorflow_probability/python/bijectors/glow.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tensorflow_probability/python/bijectors/glow.py b/tensorflow_probability/python/bijectors/glow.py index 8f6a1f09e6..c3d22ed676 100644 --- a/tensorflow_probability/python/bijectors/glow.py +++ b/tensorflow_probability/python/bijectors/glow.py @@ -708,9 +708,10 @@ class OneByOneConv(bijector.Bijector): of the bijector. """ - def __init__(self, event_size, seed=None, dtype=tf.float32, **kwargs): + def __init__(self, event_size, seed=None, dtype=tf.float32, + name='OneByOneConv', **kwargs): parameters = dict(locals()) - with tf.name_scope('OneByOneConv') as name: + with tf.name_scope(name) as bijector_name: lower_upper, permutation = self.trainable_lu_factorization( event_size, seed=seed, dtype=dtype) self._bijector = scale_matvec_lu.ScaleMatvecLU( @@ -720,7 +721,7 @@ def __init__(self, event_size, seed=None, dtype=tf.float32, **kwargs): is_constant_jacobian=True, forward_min_event_ndims=1, parameters=parameters, - name=name) + name=bijector_name) def forward(self, x): return self._bijector.forward(x) From 3a2d9abcd1640580b60a1d6fa923ef79ad9db628 Mon Sep 17 00:00:00 2001 From: phandu Date: Sat, 23 Apr 2022 21:00:44 -0700 Subject: [PATCH 107/153] Add `slicing` linear operator and update rewrite rules for numpy backend PiperOrigin-RevId: 443992110 --- .../python/internal/backend/jax/BUILD | 1 + .../backend/meta/gen_linear_operators.py | 3 +- .../python/internal/backend/numpy/BUILD | 1 + .../backend/numpy/gen/linear_operator.py | 23 +- .../numpy/gen/linear_operator_adjoint.py | 5 + .../numpy/gen/linear_operator_block_diag.py | 5 + .../linear_operator_block_lower_triangular.py | 7 + .../numpy/gen/linear_operator_circulant.py | 17 +- .../numpy/gen/linear_operator_composition.py | 5 + .../backend/numpy/gen/linear_operator_diag.py | 5 + .../numpy/gen/linear_operator_full_matrix.py | 5 + .../numpy/gen/linear_operator_householder.py | 5 + .../numpy/gen/linear_operator_identity.py | 15 +- .../numpy/gen/linear_operator_inversion.py | 5 + .../numpy/gen/linear_operator_kronecker.py | 7 +- .../gen/linear_operator_low_rank_update.py | 10 + .../gen/linear_operator_lower_triangular.py | 5 + .../numpy/gen/linear_operator_toeplitz.py | 5 + .../numpy/gen/linear_operator_zeros.py | 12 +- .../internal/backend/numpy/gen/slicing.py | 220 ++++++++++++++++++ 20 files changed, 350 insertions(+), 11 deletions(-) create mode 100644 tensorflow_probability/python/internal/backend/numpy/gen/slicing.py diff --git a/tensorflow_probability/python/internal/backend/jax/BUILD b/tensorflow_probability/python/internal/backend/jax/BUILD index 5127b929c1..94953d1938 100644 --- a/tensorflow_probability/python/internal/backend/jax/BUILD +++ b/tensorflow_probability/python/internal/backend/jax/BUILD @@ -96,6 +96,7 @@ GEN_FILENAMES = [ "gen/linear_operator_zeros", "gen/matmul_registrations", "gen/registrations_util", + "gen/slicing", "gen/solve_registrations", ] diff --git a/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py b/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py index 6cfadb01ea..4502129771 100644 --- a/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py +++ b/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py @@ -36,6 +36,7 @@ 'framework import ops': 'ops', 'framework import common_shapes': 'ops as common_shapes', 'framework import tensor_shape': 'tensor_shape', + 'framework import tensor_util': 'ops', 'module import module': 'ops as module', 'ops import array_ops': 'numpy_array as array_ops', 'ops import check_ops': 'debugging as check_ops', @@ -90,7 +91,7 @@ def shape_tensor(shape, name=None): # pylint: disable=unused-argument,function- 'reimported', 'g-bool-id-comparison', 'g-statement-before-imports', 'bad-continuation', 'useless-import-alias', 'property-with-parameters', - 'trailing-whitespace') + 'trailing-whitespace', 'g-inconsistent-quotes') def gen_module(module_name): diff --git a/tensorflow_probability/python/internal/backend/numpy/BUILD b/tensorflow_probability/python/internal/backend/numpy/BUILD index a87d62613b..da648a3ea2 100644 --- a/tensorflow_probability/python/internal/backend/numpy/BUILD +++ b/tensorflow_probability/python/internal/backend/numpy/BUILD @@ -548,6 +548,7 @@ LINOP_FILES = [ "linear_operator_zeros", "matmul_registrations", "registrations_util", + "slicing", "solve_registrations", ] diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py index 601f9d3ca3..6238ea033b 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # @@ -42,7 +43,7 @@ from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape from tensorflow_probability.python.internal.backend.numpy import tensor_spec -# from tensorflow.python.framework import tensor_util +from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy import type_spec from tensorflow_probability.python.internal.backend.numpy import ops as module from tensorflow_probability.python.internal.backend.numpy import numpy_array as array_ops @@ -54,6 +55,7 @@ from tensorflow_probability.python.internal.backend.numpy import linalg_impl as linalg from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator_algebra from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator_util +from tensorflow_probability.python.internal.backend.numpy.gen import slicing from absl import logging as logging from tensorflow_probability.python.internal.backend.numpy import data_structures from tensorflow_probability.python.internal.backend.numpy import deprecation @@ -1209,6 +1211,25 @@ def _type_spec(self): # `@make_composite_tensor` decorator. pass + def __getitem__(self, slices): + return slicing.batch_slice(self, params_overrides={}, slices=slices) + + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + """A dict of names to number of dimensions contributing to an operator. + + This is a dictionary of parameter names to `int`s specifying the + number of right-most dimensions contributing to the **matrix** shape of the + densified operator. + If the parameter is a `Tensor`, this is mapped to an `int`. + If the parameter is a `LinearOperator` (called `A`), this specifies the + number of batch dimensions of `A` contributing to this `LinearOperator`s + matrix shape. + If the parameter is a structure, this is a structure of the same type of + `int`s. + """ + return () + class _LinearOperatorSpec(type_spec.BatchableTypeSpec): """A tf.TypeSpec for `LinearOperator` objects.""" diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_adjoint.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_adjoint.py index 0ce9d54cdf..9cc5265fa2 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_adjoint.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_adjoint.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # @@ -248,6 +249,10 @@ def _cond(self): def _composite_tensor_fields(self): return ("operator",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"operator": 0} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_diag.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_diag.py index 797c083e9b..c90dd100b3 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_diag.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_diag.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # @@ -755,6 +756,10 @@ def _eigvals(self): def _composite_tensor_fields(self): return ("operators",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"operators": [0] * len(self.operators)} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_lower_triangular.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_lower_triangular.py index 5a96e01d6e..86d8cd135f 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_lower_triangular.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_block_lower_triangular.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2020 The TensorFlow Authors. All Rights Reserved. # @@ -44,6 +45,7 @@ from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator_algebra from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator_util +from tensorflow_probability.python.internal.backend.numpy import nest # from tensorflow.python.util.tf_export import tf_export __all__ = ["LinearOperatorBlockLowerTriangular"] @@ -900,6 +902,11 @@ def _eigvals(self): def _composite_tensor_fields(self): return ("operators",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + # None of the operators contribute to the matrix shape. + return {"operators": nest.map_structure(lambda _: 0, self.operators)} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_circulant.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_circulant.py index f66b7cecbc..9574f68727 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_circulant.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_circulant.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # @@ -546,6 +547,10 @@ def _trace(self): def _composite_tensor_fields(self): return ("spectrum", "input_output_dtype") + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"spectrum": self.block_depth} + # @tf_export("linalg.LinearOperatorCirculant") # @linear_operator.make_composite_tensor @@ -955,9 +960,9 @@ def __init__(self, a real type is fine. Args: - spectrum: Shape `[B1,...,Bb, N]` `Tensor`. Allowed dtypes: `float16`, - `float32`, `float64`, `complex64`, `complex128`. Type can be different - than `input_output_dtype` + spectrum: Shape `[B1,...,Bb, N0, N1]` `Tensor`. Allowed dtypes: + `float16`, `float32`, `float64`, `complex64`, `complex128`. + Type can be different than `input_output_dtype` input_output_dtype: `dtype` for input/output. is_non_singular: Expect that this operator is non-singular. is_self_adjoint: Expect that this operator is equal to its hermitian @@ -1117,9 +1122,9 @@ def __init__(self, a real type is fine. Args: - spectrum: Shape `[B1,...,Bb, N]` `Tensor`. Allowed dtypes: `float16`, - `float32`, `float64`, `complex64`, `complex128`. Type can be different - than `input_output_dtype` + spectrum: Shape `[B1,...,Bb, N0, N1, N2]` `Tensor`. Allowed dtypes: + `float16`, `float32`, `float64`, `complex64`, `complex128`. + Type can be different than `input_output_dtype` input_output_dtype: `dtype` for input/output. is_non_singular: Expect that this operator is non-singular. is_self_adjoint: Expect that this operator is equal to its hermitian diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py index a94f703534..e0b471f078 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_composition.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # @@ -307,6 +308,10 @@ def _assert_non_singular(self): def _composite_tensor_fields(self): return ("operators",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"operators": [0] * len(self.operators)} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_diag.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_diag.py index a0d02848bf..9d688c057c 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_diag.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_diag.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # @@ -283,6 +284,10 @@ def _cond(self): def _composite_tensor_fields(self): return ("diag",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"diag": 1} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py index 83b7f6dbc5..8b867f339a 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_full_matrix.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # @@ -217,6 +218,10 @@ def _to_dense(self): def _composite_tensor_fields(self): return ("matrix",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"matrix": 2} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_householder.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_householder.py index 2a76dbcf0a..856abe0f0a 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_householder.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_householder.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # @@ -288,6 +289,10 @@ def reflection_axis(self): def _composite_tensor_fields(self): return ("reflection_axis",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"reflection_axis": 1} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_identity.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_identity.py index 3da197c511..ef7b08b8b7 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_identity.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_identity.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # @@ -37,7 +38,7 @@ from tensorflow_probability.python.internal.backend.numpy import dtype as dtypes from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape -# from tensorflow.python.framework import tensor_util +from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy import numpy_array as array_ops from tensorflow_probability.python.internal.backend.numpy import debugging as check_ops from tensorflow_probability.python.internal.backend.numpy import control_flow as control_flow_ops @@ -505,6 +506,14 @@ def _composite_tensor_prefer_static_fields(self): def _composite_tensor_fields(self): return ("num_rows", "batch_shape", "dtype", "assert_proper_shapes") + def __getitem__(self, slices): + # Slice the batch shape and return a new LinearOperatorIdentity. + # Use a proxy shape and slice it. Use this as the new batch shape + new_batch_shape = prefer_static.shape( + array_ops.ones(self._batch_shape_arg)[slices]) + parameters = dict(self.parameters, batch_shape=new_batch_shape) + return LinearOperatorIdentity(**parameters) + # @tf_export("linalg.LinearOperatorScaledIdentity") # @linear_operator.make_composite_tensor @@ -801,6 +810,10 @@ def _composite_tensor_prefer_static_fields(self): def _composite_tensor_fields(self): return ("num_rows", "multiplier", "assert_proper_shapes") + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"multiplier": 0} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_inversion.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_inversion.py index 4646368f16..115982f787 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_inversion.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_inversion.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # @@ -233,6 +234,10 @@ def _cond(self): def _composite_tensor_fields(self): return ("operator",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"operator": 0} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_kronecker.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_kronecker.py index ed303654b6..da0b0cba3b 100755 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_kronecker.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_kronecker.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # @@ -37,7 +38,7 @@ from tensorflow_probability.python.internal.backend.numpy import errors from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape -# from tensorflow.python.framework import tensor_util +from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy import numpy_array as array_ops from tensorflow_probability.python.internal.backend.numpy import debugging as check_ops from tensorflow_probability.python.internal.backend.numpy import control_flow as control_flow_ops @@ -523,6 +524,10 @@ def _assert_self_adjoint(self): def _composite_tensor_fields(self): return ("operators",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"operators": [0] * len(self.operators)} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_low_rank_update.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_low_rank_update.py index 904a4e6a88..98632fe997 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_low_rank_update.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_low_rank_update.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # @@ -518,6 +519,15 @@ def _make_capacitance(self, u, v): def _composite_tensor_fields(self): return ("base_operator", "u", "diag_update", "v", "is_diag_update_positive") + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return { + "base_operator": 0, + "u": 2, + "diag_update": 1, + "v": 2 + } + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py index 7965254377..51875d283a 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_lower_triangular.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # @@ -238,6 +239,10 @@ def _eigvals(self): def _composite_tensor_fields(self): return ("tril",) + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"tril": 2} + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_toeplitz.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_toeplitz.py index 7b159afa2e..9d13596d23 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_toeplitz.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_toeplitz.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # @@ -297,6 +298,10 @@ def row(self): def _composite_tensor_fields(self): return ("col", "row") + @property + def _experimental_parameter_ndims_to_matrix_ndims(self): + return {"col": 1, "row": 1} + def _to_complex(x): dtype = dtypes.complex64 diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_zeros.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_zeros.py index b8aaf4d556..0d07164b9e 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_zeros.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_zeros.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # @@ -38,7 +39,7 @@ from tensorflow_probability.python.internal.backend.numpy import errors from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape -# from tensorflow.python.framework import tensor_util +from tensorflow_probability.python.internal.backend.numpy import ops from tensorflow_probability.python.internal.backend.numpy import numpy_array as array_ops from tensorflow_probability.python.internal.backend.numpy import debugging as check_ops from tensorflow_probability.python.internal.backend.numpy import control_flow as control_flow_ops @@ -496,6 +497,15 @@ def _composite_tensor_fields(self): return ("num_rows", "num_columns", "batch_shape", "dtype", "assert_proper_shapes") + def __getitem__(self, slices): + # Slice the batch shape and return a new LinearOperatorIdentity. + # Use a proxy shape and slice it. Use this as the new batch shape + new_batch_shape = prefer_static.shape( + array_ops.ones(self._batch_shape_arg)[slices]) + parameters = dict(self.parameters, batch_shape=new_batch_shape) + return LinearOperatorZeros(**parameters) + + import numpy as np from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg from tensorflow_probability.python.internal.backend.numpy import ops as _ops diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/slicing.py b/tensorflow_probability/python/internal/backend/numpy/gen/slicing.py new file mode 100644 index 0000000000..1a9c795c1a --- /dev/null +++ b/tensorflow_probability/python/internal/backend/numpy/gen/slicing.py @@ -0,0 +1,220 @@ +# Copyright 2020 The TensorFlow Probability Authors. All Rights Reserved. +# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ +# THIS FILE IS AUTO-GENERATED BY `gen_linear_operators.py`. +# DO NOT MODIFY DIRECTLY. +# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ +# pylint: disable=g-import-not-at-top +# pylint: disable=g-direct-tensorflow-import +# pylint: disable=g-bad-import-order +# pylint: disable=unused-import +# pylint: disable=line-too-long +# pylint: disable=reimported +# pylint: disable=g-bool-id-comparison +# pylint: disable=g-statement-before-imports +# pylint: disable=bad-continuation +# pylint: disable=useless-import-alias +# pylint: disable=property-with-parameters +# pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes + +# Copyright 2022 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Utilities for slicing in to a `LinearOperator`.""" + +import collections +import functools +import numpy as np + +from tensorflow_probability.python.internal.backend.numpy import dtype as dtypes +from tensorflow_probability.python.internal.backend.numpy import ops +from tensorflow_probability.python.internal.backend.numpy import numpy_array as array_ops +from tensorflow_probability.python.internal.backend.numpy import nest + + +__all__ = ['batch_slice'] + + +def _prefer_static_where(condition, x, y): + args = [condition, x, y] + constant_args = [ops.get_static_value(a) for a in args] + # Do this statically. + if all(arg is not None for arg in constant_args): + condition_, x_, y_ = constant_args + return np.where(condition_, x_, y_) + return array_ops.where(condition, x, y) + + +def _broadcast_parameter_with_batch_shape( + param, param_ndims_to_matrix_ndims, batch_shape): + """Broadcasts `param` with the given batch shape, recursively.""" + if hasattr(param, 'batch_shape_tensor'): + # Recursively broadcast every parameter inside the operator. + override_dict = {} + for name, ndims in param._experimental_parameter_ndims_to_matrix_ndims.items(): # pylint:disable=protected-access,line-too-long + sub_param = getattr(param, name) + override_dict[name] = nest.map_structure_up_to( + sub_param, functools.partial( + _broadcast_parameter_with_batch_shape, + batch_shape=batch_shape), sub_param, ndims) + parameters = dict(param.parameters, **override_dict) + return type(param)(**parameters) + + base_shape = prefer_static.concat( + [batch_shape, array_ops.ones( + [param_ndims_to_matrix_ndims], dtype=dtypes.int32)], axis=0) + return _ops.broadcast_to( + param, + array_ops.broadcast_dynamic_shape(base_shape, prefer_static.shape(param))) + + +def _sanitize_slices(slices, intended_shape, deficient_shape): + """Restricts slices to avoid overflowing size-1 (broadcast) dimensions. + + Args: + slices: iterable of slices received by `__getitem__`. + intended_shape: int `Tensor` shape for which the slices were intended. + deficient_shape: int `Tensor` shape to which the slices will be applied. + Must have the same rank as `intended_shape`. + Returns: + sanitized_slices: Python `list` of slice objects. + """ + sanitized_slices = [] + idx = 0 + for slc in slices: + if slc is Ellipsis: # Switch over to negative indexing. + if idx < 0: + raise ValueError('Found multiple `...` in slices {}'.format(slices)) + num_remaining_non_newaxis_slices = sum( + s is not _ops.newaxis for s in slices[ + slices.index(Ellipsis) + 1:]) + idx = -num_remaining_non_newaxis_slices + elif slc is _ops.newaxis: + pass + else: + is_broadcast = intended_shape[idx] > deficient_shape[idx] + if isinstance(slc, slice): + # Slices are denoted by start:stop:step. + start, stop, step = slc.start, slc.stop, slc.step + if start is not None: + start = _prefer_static_where(is_broadcast, 0, start) + if stop is not None: + stop = _prefer_static_where(is_broadcast, 1, stop) + if step is not None: + step = _prefer_static_where(is_broadcast, 1, step) + slc = slice(start, stop, step) + else: # int, or int Tensor, e.g. d[d.batch_shape_tensor()[0] // 2] + slc = _prefer_static_where(is_broadcast, 0, slc) + idx = idx + 1 + sanitized_slices.append(slc) + return sanitized_slices + + +def _slice_single_param( + param, param_ndims_to_matrix_ndims, slices, batch_shape): + """Slices into the batch shape of a single parameter. + + Args: + param: The original parameter to slice; either a `Tensor` or an object + with batch shape (LinearOperator). + param_ndims_to_matrix_ndims: `int` number of right-most dimensions used for + inferring matrix shape of the `LinearOperator`. For non-Tensor + parameters, this is the number of this param's batch dimensions used by + the matrix shape of the parent object. + slices: iterable of slices received by `__getitem__`. + batch_shape: The parameterized object's batch shape `Tensor`. + + Returns: + new_param: Instance of the same type as `param`, batch-sliced according to + `slices`. + """ + # Broadcast the parammeter to have full batch rank. + param = _broadcast_parameter_with_batch_shape( + param, param_ndims_to_matrix_ndims, array_ops.ones_like(batch_shape)) + + if hasattr(param, 'batch_shape_tensor'): + param_batch_shape = param.batch_shape_tensor() + else: + param_batch_shape = prefer_static.shape(param) + # Truncate by param_ndims_to_matrix_ndims + param_batch_rank = array_ops.size(param_batch_shape) + param_batch_shape = param_batch_shape[ + :(param_batch_rank - param_ndims_to_matrix_ndims)] + + # At this point the param should have full batch rank, *unless* it's an + # atomic object like `tfb.Identity()` incapable of having any batch rank. + if (ops.get_static_value(array_ops.size(batch_shape)) != 0 and + ops.get_static_value(array_ops.size(param_batch_shape)) == 0): + return param + param_slices = _sanitize_slices( + slices, intended_shape=batch_shape, deficient_shape=param_batch_shape) + + # Extend `param_slices` (which represents slicing into the + # parameter's batch shape) with the parameter's event ndims. For example, if + # `params_ndims == 1`, then `[i, ..., j]` would become `[i, ..., j, :]`. + if param_ndims_to_matrix_ndims > 0: + if Ellipsis not in [ + slc for slc in slices if not ops.is_tensor(slc)]: + param_slices.append(Ellipsis) + param_slices = param_slices + [slice(None)] * param_ndims_to_matrix_ndims + return param.__getitem__(tuple(param_slices)) + + +def batch_slice(linop, params_overrides, slices): + """Slices `linop` along its batch dimensions. + + Args: + linop: A `LinearOperator` instance. + params_overrides: A `dict` of parameter overrides. + slices: A `slice` or `int` or `int` `Tensor` or `tf.newaxis` or `tuple` + thereof. (e.g. the argument of a `__getitem__` method). + + Returns: + new_linop: A batch-sliced `LinearOperator`. + """ + if not isinstance(slices, collections.abc.Sequence): + slices = (slices,) + if len(slices) == 1 and slices[0] is Ellipsis: + override_dict = {} + else: + batch_shape = linop.batch_shape_tensor() + override_dict = {} + for param_name, param_ndims_to_matrix_ndims in linop._experimental_parameter_ndims_to_matrix_ndims.items(): # pylint:disable=protected-access,line-too-long + param = getattr(linop, param_name) + # These represent optional `Tensor` parameters. + if param is not None: + override_dict[param_name] = nest.map_structure_up_to( + param, functools.partial( + _slice_single_param, slices=slices, batch_shape=batch_shape), + param, param_ndims_to_matrix_ndims) + override_dict.update(params_overrides) + parameters = dict(linop.parameters, **override_dict) + return type(linop)(**parameters) + +import numpy as np +from tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg +from tensorflow_probability.python.internal.backend.numpy import ops as _ops +from tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape + +from tensorflow_probability.python.internal.backend.numpy import private +distribution_util = private.LazyLoader( + "distribution_util", globals(), + "tensorflow_probability.substrates.numpy.internal.distribution_util") +tensorshape_util = private.LazyLoader( + "tensorshape_util", globals(), + "tensorflow_probability.substrates.numpy.internal.tensorshape_util") +prefer_static = private.LazyLoader( + "prefer_static", globals(), + "tensorflow_probability.substrates.numpy.internal.prefer_static") + From 4ac68084b9a2fbe3c6c634bab0a3efef32832a20 Mon Sep 17 00:00:00 2001 From: phandu Date: Mon, 25 Apr 2022 09:09:15 -0700 Subject: [PATCH 108/153] Update numpy rewritten code PiperOrigin-RevId: 444285304 --- .../python/internal/backend/numpy/gen/adjoint_registrations.py | 1 + .../python/internal/backend/numpy/gen/cholesky_registrations.py | 1 + .../python/internal/backend/numpy/gen/inverse_registrations.py | 1 + .../internal/backend/numpy/gen/linear_operator_addition.py | 1 + .../python/internal/backend/numpy/gen/linear_operator_algebra.py | 1 + .../python/internal/backend/numpy/gen/linear_operator_util.py | 1 + .../python/internal/backend/numpy/gen/matmul_registrations.py | 1 + .../python/internal/backend/numpy/gen/registrations_util.py | 1 + .../python/internal/backend/numpy/gen/solve_registrations.py | 1 + 9 files changed, 9 insertions(+) diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/adjoint_registrations.py b/tensorflow_probability/python/internal/backend/numpy/gen/adjoint_registrations.py index 78bc6c917c..f30f08ab7e 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/adjoint_registrations.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/adjoint_registrations.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/cholesky_registrations.py b/tensorflow_probability/python/internal/backend/numpy/gen/cholesky_registrations.py index db97177169..5c200ab22c 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/cholesky_registrations.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/cholesky_registrations.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/inverse_registrations.py b/tensorflow_probability/python/internal/backend/numpy/gen/inverse_registrations.py index 5bb8137dfc..acd3a7c21d 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/inverse_registrations.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/inverse_registrations.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_addition.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_addition.py index e324b4d047..f619ed2e9c 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_addition.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_addition.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_algebra.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_algebra.py index 1895c3df82..891b885c6a 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_algebra.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_algebra.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_util.py b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_util.py index d51723c3b8..62bb53f057 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_util.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_util.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/matmul_registrations.py b/tensorflow_probability/python/internal/backend/numpy/gen/matmul_registrations.py index 3e63d475d8..3380829aaf 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/matmul_registrations.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/matmul_registrations.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2018 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/registrations_util.py b/tensorflow_probability/python/internal/backend/numpy/gen/registrations_util.py index 2fb493c05b..506c4c6bbe 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/registrations_util.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/registrations_util.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # diff --git a/tensorflow_probability/python/internal/backend/numpy/gen/solve_registrations.py b/tensorflow_probability/python/internal/backend/numpy/gen/solve_registrations.py index 009089127d..5c2ae7e8aa 100644 --- a/tensorflow_probability/python/internal/backend/numpy/gen/solve_registrations.py +++ b/tensorflow_probability/python/internal/backend/numpy/gen/solve_registrations.py @@ -15,6 +15,7 @@ # pylint: disable=useless-import-alias # pylint: disable=property-with-parameters # pylint: disable=trailing-whitespace +# pylint: disable=g-inconsistent-quotes # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # From 3dba566cd1483d65e9ba74f6bd675e96407f6b07 Mon Sep 17 00:00:00 2001 From: Googler Date: Mon, 25 Apr 2022 09:11:42 -0700 Subject: [PATCH 109/153] Allow there to be no covariates in the GibbsSampler. PiperOrigin-RevId: 444286001 --- .../experimental/sts_gibbs/gibbs_sampler.py | 236 +++++++++++------- .../sts_gibbs/gibbs_sampler_test.py | 67 ++++- 2 files changed, 206 insertions(+), 97 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index eec3bc383c..d2cbd4132f 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -183,7 +183,8 @@ def build_model_for_gibbs_fitting(observed_time_series, `model.parameters` matches the parameters and ordering specified by the `GibbsSamplerState` namedtuple. Currently, this includes (only) models consisting of the sum of a LocalLevel or LocalLinearTrend component with - a LinearRegression or SpikeAndSlabSparseLinearRegression component. + (optionally) a LinearRegression or SpikeAndSlabSparseLinearRegression + component. Args: observed_time_series: optional `float` `Tensor` of shape [..., T, 1]` @@ -191,9 +192,9 @@ def build_model_for_gibbs_fitting(observed_time_series, specifying an observed time series. May optionally be an instance of `tfp.sts.MaskedTimeSeries`, which includes a mask `Tensor` to specify timesteps with missing observations. - design_matrix: float `Tensor` of shape `concat([batch_shape, [num_timesteps, - num_features]])`. This may also optionally be an instance of - `tf.linalg.LinearOperator`. + design_matrix: Optional float `Tensor` of shape `concat([batch_shape, + [num_timesteps, num_features]])`. This may also optionally be an instance + of `tf.linalg.LinearOperator`. If None, no regression is done. weights_prior: Optional distribution instance specifying a normal prior on weights. This may be a multivariate normal instance with event shape `[num_features]`, or a scalar normal distribution with event shape `[]`. @@ -230,8 +231,19 @@ def build_model_for_gibbs_fitting(observed_time_series, Returns: model: A `tfp.sts.StructuralTimeSeries` model instance. """ + if design_matrix is None: + if sparse_weights_nonzero_prob is not None: + raise ValueError( + 'Design matrix is None thus sparse_weights_nonzero_prob should ' + 'not be defined, as it will not be used.') + if weights_prior is not None: + raise ValueError( + 'Design matrix is None thus weights_prior should not be defined, ' + 'as it will not be used.') + if isinstance(weights_prior, tfd.Normal): # Canonicalize scalar normal priors as diagonal MVNs. + # design_matrix must be defined, otherwise we threw an exception earlier. if isinstance(design_matrix, tf.linalg.LinearOperator): num_features = design_matrix.shape_tensor()[-1] else: @@ -252,36 +264,43 @@ def build_model_for_gibbs_fitting(observed_time_series, 'gamma distribution.') sqrt = tfb.Invert(tfb.Square()) # Converts variance priors to scale priors. + components = [] # Level or trend component. if slope_variance_prior: - local_variation = sts.LocalLinearTrend( - observed_time_series=observed_time_series, - level_scale_prior=sqrt(level_variance_prior), - slope_scale_prior=sqrt(slope_variance_prior), - initial_level_prior=initial_level_prior, - name='local_linear_trend') + components.append( + sts.LocalLinearTrend( + observed_time_series=observed_time_series, + level_scale_prior=sqrt(level_variance_prior), + slope_scale_prior=sqrt(slope_variance_prior), + initial_level_prior=initial_level_prior, + name='local_linear_trend')) else: - local_variation = sts.LocalLevel( - observed_time_series=observed_time_series, - level_scale_prior=sqrt(level_variance_prior), - initial_level_prior=initial_level_prior, - name='local_level') + components.append( + sts.LocalLevel( + observed_time_series=observed_time_series, + level_scale_prior=sqrt(level_variance_prior), + initial_level_prior=initial_level_prior, + name='local_level')) # Regression component. - if sparse_weights_nonzero_prob is not None: - regression = SpikeAndSlabSparseLinearRegression( - design_matrix=design_matrix, - weights_prior=weights_prior, - sparse_weights_nonzero_prob=sparse_weights_nonzero_prob, - name='sparse_regression') + if design_matrix is None: + pass + elif sparse_weights_nonzero_prob is not None: + components.append( + SpikeAndSlabSparseLinearRegression( + design_matrix=design_matrix, + weights_prior=weights_prior, + sparse_weights_nonzero_prob=sparse_weights_nonzero_prob, + name='sparse_regression')) else: - regression = sts.LinearRegression( - design_matrix=design_matrix, - weights_prior=weights_prior, - name='regression') + components.append( + sts.LinearRegression( + design_matrix=design_matrix, + weights_prior=weights_prior, + name='regression')) model = sts.Sum( - [local_variation, regression], + components, observed_time_series=observed_time_series, observation_noise_scale_prior=sqrt(observation_noise_variance_prior), # The Gibbs sampling steps in this file do not account for an @@ -294,14 +313,21 @@ def build_model_for_gibbs_fitting(observed_time_series, def _get_design_matrix(model): - """Returns the design matrix for an STS model with a regression component.""" + """Returns the design matrix for an STS model with a regression component. + + If there is not a design matrix, None is returned. + + Args: + model: A `tfp.sts.StructuralTimeSeries` model instance return by + `build_model_for_gibbs_fitting`. + """ design_matrices = [ component.design_matrix for component in model.components if hasattr(component, 'design_matrix') ] if not design_matrices: - raise ValueError('Model does not contain a regression component.') + return None if len(design_matrices) > 1: raise ValueError('Model contains multiple regression components.') return design_matrices[0] @@ -369,14 +395,16 @@ def fit_with_gibbs_sampling(model, initial_slope = tf.zeros(level_slope_shape, dtype=dtype) if initial_state is None: + design_matrix = _get_design_matrix(model) + weights = tf.zeros(0, dtype=dtype) if design_matrix is None else tf.zeros( # pylint:disable=g-long-ternary + prefer_static.concat([batch_shape, design_matrix.shape[-1:]], + axis=0), + dtype=dtype) initial_state = GibbsSamplerState( observation_noise_scale=tf.ones(batch_shape, dtype=dtype), level_scale=tf.ones(batch_shape, dtype=dtype), slope_scale=initial_slope_scale, - weights=tf.zeros( - prefer_static.concat( - [batch_shape, _get_design_matrix(model).shape[-1:]], axis=0), - dtype=dtype), + weights=weights, level=tf.zeros(level_slope_shape, dtype=dtype), slope=initial_slope, seed=None) # Set below. @@ -493,9 +521,13 @@ def one_step_predictive(model, ] + ([forecast_level] if num_forecast_steps > 0 else []), axis=-1) - design_matrix = _get_design_matrix(model).to_dense()[:num_observed_steps + - num_forecast_steps] - regression_effect = tf.linalg.matvec(design_matrix, thinned_samples.weights) + design_matrix = _get_design_matrix(model) + if design_matrix is not None: + design_matrix = design_matrix.to_dense()[:num_observed_steps + + num_forecast_steps] + regression_effect = tf.linalg.matvec(design_matrix, thinned_samples.weights) + else: + regression_effect = 0 y_mean = ((level_pred + regression_effect) * original_scale[..., tf.newaxis] + original_mean[..., tf.newaxis]) @@ -731,15 +763,21 @@ def _build_sampler_loop_body(model, 'instead saw {}'.format(level_component)) model_has_slope = isinstance(level_component, sts.LocalLinearTrend) - regression_component = model.components[1] - if not (isinstance(regression_component, sts.LinearRegression) or - isinstance(regression_component, SpikeAndSlabSparseLinearRegression)): - raise ValueError('Expected the second model component to be an instance of ' - '`tfp.sts.LinearRegression` or ' - '`SpikeAndSlabSparseLinearRegression`; ' - 'instead saw {}'.format(regression_component)) - model_has_spike_slab_regression = isinstance( - regression_component, SpikeAndSlabSparseLinearRegression) + # TODO(kloveless): When we add support for more flexible models, remove + # this assumption. + regression_component = (None if len(model.components) != 2 else + model.components[1]) + if regression_component: + if not (isinstance(regression_component, sts.LinearRegression) or + isinstance(regression_component, + SpikeAndSlabSparseLinearRegression)): + raise ValueError( + 'Expected the second model component to be an instance of ' + '`tfp.sts.LinearRegression` or ' + '`SpikeAndSlabSparseLinearRegression`; ' + 'instead saw {}'.format(regression_component)) + model_has_spike_slab_regression = isinstance( + regression_component, SpikeAndSlabSparseLinearRegression) if is_missing is not None: # Ensure series does not contain NaNs. observed_time_series = tf.where(is_missing, @@ -747,12 +785,15 @@ def _build_sampler_loop_body(model, observed_time_series) num_observed_steps = prefer_static.shape(observed_time_series)[-1] - design_matrix = _get_design_matrix(model).to_dense()[:num_observed_steps] - if is_missing is not None: - # Replace design matrix with zeros at unobserved timesteps. This ensures - # they will not affect the posterior on weights. - design_matrix = tf.where(is_missing[..., tf.newaxis], - tf.zeros_like(design_matrix), design_matrix) + + design_matrix = _get_design_matrix(model) + if design_matrix is not None: + design_matrix = design_matrix.to_dense()[:num_observed_steps] + if is_missing is not None: + # Replace design matrix with zeros at unobserved timesteps. This ensures + # they will not affect the posterior on weights. + design_matrix = tf.where(is_missing[..., tf.newaxis], + tf.zeros_like(design_matrix), design_matrix) # Untransform scale priors -> variance priors by reaching thru Sqrt bijector. observation_noise_param = model.parameters[0] @@ -768,26 +809,27 @@ def _build_sampler_loop_body(model, level_scale_variance_prior = ( level_component.parameters[0].prior.distribution) - if model_has_spike_slab_regression: - spike_and_slab_sampler = spike_and_slab.SpikeSlabSampler( - design_matrix, - weights_prior_precision=regression_component._weights_prior_precision, # pylint: disable=protected-access - nonzero_prior_prob=regression_component._sparse_weights_nonzero_prob, # pylint: disable=protected-access - observation_noise_variance_prior_concentration=( - observation_noise_variance_prior.concentration), - observation_noise_variance_prior_scale=( - observation_noise_variance_prior.scale), - observation_noise_variance_upper_bound=( - # The given bound is for the scale, so it must be squared to get the - # upper bound for the variance. - tf.math.square(observation_noise_variance_prior.upper_bound) - if hasattr(observation_noise_variance_prior, 'upper_bound') - else None), - **({ - 'default_pseudo_observations': default_pseudo_observations - } if default_pseudo_observations is not None else {})) - else: - weights_prior_scale = (regression_component.parameters[0].prior.scale) + if regression_component: + if model_has_spike_slab_regression: + spike_and_slab_sampler = spike_and_slab.SpikeSlabSampler( + design_matrix, + weights_prior_precision=regression_component._weights_prior_precision, # pylint: disable=protected-access + nonzero_prior_prob=regression_component._sparse_weights_nonzero_prob, # pylint: disable=protected-access + observation_noise_variance_prior_concentration=( + observation_noise_variance_prior.concentration), + observation_noise_variance_prior_scale=( + observation_noise_variance_prior.scale), + observation_noise_variance_upper_bound=( + # The given bound is for the scale, so it must be squared to get + # the upper bound for the variance. + tf.math.square(observation_noise_variance_prior.upper_bound) + if hasattr(observation_noise_variance_prior, 'upper_bound') else + None), + **({ + 'default_pseudo_observations': default_pseudo_observations + } if default_pseudo_observations is not None else {})) + else: + weights_prior_scale = (regression_component.parameters[0].prior.scale) def sampler_loop_body(previous_sample, _): """Runs one sampler iteration, resampling all model variables.""" @@ -799,32 +841,40 @@ def sampler_loop_body(previous_sample, _): slope_scale_seed, = samplers.split_seed( previous_sample.seed, n=1, salt='sampler_loop_body_slope') - # We encourage a reasonable initialization by sampling the weights first, - # so at the first step they are regressed directly against the observed - # time series. If we instead sampled the level first it might 'explain away' - # some observed variation that we would ultimately prefer to explain through - # the regression weights, because the level can represent arbitrary - # variation, while the weights are limited to representing variation in the - # subspace given by the design matrix. - if model_has_spike_slab_regression: - (observation_noise_variance, - weights) = spike_and_slab_sampler.sample_noise_variance_and_weights( - initial_nonzeros=tf.not_equal(previous_sample.weights, 0.), - targets=observed_time_series - previous_sample.level, - seed=weights_seed) - observation_noise_scale = tf.sqrt(observation_noise_variance) + if regression_component: + # We encourage a reasonable initialization by sampling the weights first, + # so at the first step they are regressed directly against the observed + # time series. If we instead sampled the level first it might 'explain + # away' some observed variation that we would ultimately prefer to explain + # through the regression weights, because the level can represent + # arbitrary variation, while the weights are limited to representing + # variation in the subspace given by the design matrix. + if model_has_spike_slab_regression: + (observation_noise_variance, + weights) = spike_and_slab_sampler.sample_noise_variance_and_weights( + initial_nonzeros=tf.not_equal(previous_sample.weights, 0.), + targets=observed_time_series - previous_sample.level, + seed=weights_seed) + observation_noise_scale = tf.sqrt(observation_noise_variance) + else: + weights = _resample_weights( + design_matrix=design_matrix, + target_residuals=observed_time_series - previous_sample.level, + observation_noise_scale=previous_sample.observation_noise_scale, + weights_prior_scale=weights_prior_scale, + seed=weights_seed) + # Noise scale will be resampled below. + observation_noise_scale = previous_sample.observation_noise_scale + + regression_residuals = observed_time_series - tf.linalg.matvec( + design_matrix, weights) else: - weights = _resample_weights( - design_matrix=design_matrix, - target_residuals=observed_time_series - previous_sample.level, - observation_noise_scale=previous_sample.observation_noise_scale, - weights_prior_scale=weights_prior_scale, - seed=weights_seed) + # If there is no regression, then the entire timeseries is a residual. + regression_residuals = observed_time_series # Noise scale will be resampled below. observation_noise_scale = previous_sample.observation_noise_scale + weights = previous_sample.weights - regression_residuals = observed_time_series - tf.linalg.matvec( - design_matrix, weights) latents = _resample_latents( observed_residuals=regression_residuals, level_scale=previous_sample.level_scale, @@ -852,7 +902,7 @@ def sampler_loop_body(previous_sample, _): observed_residuals=slope_residuals, is_missing=None, seed=slope_scale_seed) - if not model_has_spike_slab_regression: + if regression_component and not model_has_spike_slab_regression: # Estimate noise scale from the residuals. observation_noise_scale = _resample_scale( prior=observation_noise_variance_prior, diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index 39f0cd78cb..ff071fd117 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -48,7 +48,8 @@ def _build_test_model(self, weights_prior_scale=10., sparse_weights_nonzero_prob=None, time_series_shift=0., - dtype=tf.float32): + dtype=tf.float32, + design_matrix_is_none=False): seed = test_util.test_seed(sampler_type='stateless') (design_seed, weights_seed, @@ -57,12 +58,17 @@ def _build_test_model(self, slope_seed, is_missing_seed) = samplers.split_seed(seed, 6, salt='_build_test_model') - design_matrix = samplers.normal( - [num_timesteps, num_features], dtype=dtype, seed=design_seed) if weights is None: weights = samplers.normal( list(batch_shape) + [num_features], dtype=dtype, seed=weights_seed) - regression = tf.linalg.matvec(design_matrix, weights) + if design_matrix_is_none: + design_matrix = None + regression = tf.zeros(num_timesteps, dtype) + else: + design_matrix = samplers.normal([num_timesteps, num_features], + dtype=dtype, + seed=design_seed) + regression = tf.linalg.matvec(design_matrix, weights) noise = samplers.normal( list(batch_shape) + [num_timesteps], dtype=dtype, seed=noise_seed) * true_noise_scale @@ -283,6 +289,35 @@ def do_sampling(observed_time_series, is_missing): self.assertAllEqual(predictive_mean_, predictive_mean2_) self.assertAllEqual(predictive_stddev_, predictive_stddev2_) + def test_no_covariates_support(self): + if not tf.executing_eagerly(): + return + seed = test_util.test_seed(sampler_type='stateless') + dtype = tf.float32 + model, observed_time_series, is_missing = self._build_test_model( + num_timesteps=5, + batch_shape=[3], + prior_class=gibbs_sampler.XLACompilableInverseGamma, + dtype=dtype, + design_matrix_is_none=True, + weights_prior_scale=None) + + @tf.function(jit_compile=True) + def do_sampling(observed_time_series, is_missing): + return gibbs_sampler.fit_with_gibbs_sampling( + model, + tfp.sts.MaskedTimeSeries(observed_time_series, is_missing), + num_results=4, + num_warmup_steps=1, + seed=seed) + + # This simply ensures we can get samples without throwing an error. + # TODO(kloveless): Add tests that compare the results with either another + # method of inference, or to a model with covariates, but all covariates + # are zero. + samples = do_sampling(observed_time_series[..., tf.newaxis], is_missing) + gibbs_sampler.one_step_predictive(model, samples, thin_every=1) + def test_invalid_model_spec_raises_error(self): observed_time_series = tf.ones([2]) design_matrix = tf.eye(2) @@ -310,6 +345,30 @@ def test_invalid_model_spec_raises_error(self): level_variance_prior=tfd.InverseGamma(0.01, 0.01), observation_noise_variance_prior=tfd.LogNormal(0., 3.)) + def test_invalid_optons_with_none_design_matrix_raises_error(self): + observed_time_series = tf.ones([2]) + with self.assertRaisesRegex( + ValueError, + 'Design matrix is None thus sparse_weights_nonzero_prob should ' + 'not be defined'): + gibbs_sampler.build_model_for_gibbs_fitting( + observed_time_series, + design_matrix=None, + weights_prior=None, + sparse_weights_nonzero_prob=0.4, + level_variance_prior=tfd.InverseGamma(0.01, 0.01), + observation_noise_variance_prior=tfd.InverseGamma(0.01, 0.01)) + + with self.assertRaisesRegex( + ValueError, + 'Design matrix is None thus weights_prior should not be defined'): + gibbs_sampler.build_model_for_gibbs_fitting( + observed_time_series, + design_matrix=None, + weights_prior=tfd.Normal(loc=0., scale=1.), + level_variance_prior=tfd.InverseGamma(0.01, 0.01), + observation_noise_variance_prior=tfd.InverseGamma(0.01, 0.01)) + def test_invalid_model_raises_error(self): observed_time_series = tf.convert_to_tensor([1., 0., -1., 2.]) bad_model = tfp.sts.Sum( From 72bdeeb98aa60319fddc2a20b1f62e9d1ce96053 Mon Sep 17 00:00:00 2001 From: jburnim Date: Mon, 25 Apr 2022 11:15:09 -0700 Subject: [PATCH 110/153] Implement _parameter_properties for InverseGammaWithSampleUpperBound. Also implements _parameter_properties for MVNPrecisionFactorHardZeros. PiperOrigin-RevId: 444321505 --- .../python/experimental/sts_gibbs/BUILD | 2 ++ .../experimental/sts_gibbs/spike_and_slab.py | 23 +++++++++++++++++++ 2 files changed, 25 insertions(+) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/BUILD b/tensorflow_probability/python/experimental/sts_gibbs/BUILD index 0459a64b20..5e606c98fc 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/BUILD +++ b/tensorflow_probability/python/experimental/sts_gibbs/BUILD @@ -88,11 +88,13 @@ multi_substrate_py_library( deps = [ # numpy dep, # tensorflow dep, + "//tensorflow_probability/python/bijectors:softplus", "//tensorflow_probability/python/distributions:bernoulli", "//tensorflow_probability/python/distributions:inverse_gamma", "//tensorflow_probability/python/distributions:joint_distribution_auto_batched", "//tensorflow_probability/python/distributions:sample", "//tensorflow_probability/python/experimental/distributions:mvn_precision_factor_linop", + "//tensorflow_probability/python/internal:parameter_properties", "//tensorflow_probability/python/internal:prefer_static", "//tensorflow_probability/python/internal:samplers", "//tensorflow_probability/python/internal:vectorization_util", diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index 6d51a5a5dc..12de433fd2 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -19,12 +19,14 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python import math as tfp_math +from tensorflow_probability.python.bijectors import softplus as softplus_bijector from tensorflow_probability.python.distributions import bernoulli from tensorflow_probability.python.distributions import inverse_gamma from tensorflow_probability.python.distributions import joint_distribution_auto_batched from tensorflow_probability.python.distributions import sample as sample_dist from tensorflow_probability.python.experimental.distributions import MultivariateNormalPrecisionFactorLinearOperator from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import parameter_properties from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import vectorization_util @@ -45,6 +47,19 @@ def __init__(self, concentration, scale, upper_bound, **kwargs): scale=scale, **kwargs) + @classmethod + def _parameter_properties(cls, dtype, num_classes=None): + return dict( + concentration=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), + scale=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), + upper_bound=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) + def _sample_n(self, n, seed=None): xs = super()._sample_n(n, seed=seed) if self._upper_bound is not None: @@ -71,6 +86,14 @@ def _call_sample_n(self, *args, **kwargs): def _log_prob(self, *args, **kwargs): raise NotImplementedError('Log prob is not currently implemented.') + @classmethod + def _parameter_properties(cls, dtype, num_classes=None): + return dict( + loc=parameter_properties.ParameterProperties(event_ndims=1), + precision_factor=parameter_properties.BatchedComponentProperties(), + precision=parameter_properties.BatchedComponentProperties(), + nonzeros=parameter_properties.BatchedComponentProperties(event_ndims=1)) + class SpikeSlabSamplerState(collections.namedtuple( 'SpikeSlabSamplerState', From c1270e154f0b8b186366c09945afef290966d709 Mon Sep 17 00:00:00 2001 From: jburnim Date: Wed, 27 Apr 2022 13:05:16 -0700 Subject: [PATCH 111/153] Update `tfp.sts.forecast` to work under JAX jit. Similarly update `tfp.sts.one_step_predictive` and `tfp.sts.impute_missing_values`. PiperOrigin-RevId: 444944562 --- .../python/experimental/BUILD | 2 +- tensorflow_probability/python/sts/BUILD | 1 + tensorflow_probability/python/sts/forecast.py | 17 ++-- .../python/sts/forecast_test.py | 87 ++++++++++++------- 4 files changed, 68 insertions(+), 39 deletions(-) diff --git a/tensorflow_probability/python/experimental/BUILD b/tensorflow_probability/python/experimental/BUILD index cc42b64c57..7de372e54f 100644 --- a/tensorflow_probability/python/experimental/BUILD +++ b/tensorflow_probability/python/experimental/BUILD @@ -34,12 +34,12 @@ multi_substrate_py_library( numpy_omit_deps = [ "//tensorflow_probability/python/experimental/distribute", "//tensorflow_probability/python/experimental/stats", + "//tensorflow_probability/python/experimental/sts_gibbs", ], substrates_omit_deps = [ "//tensorflow_probability/python/experimental/auto_batching", "//tensorflow_probability/python/experimental/marginalize", "//tensorflow_probability/python/experimental/nn", - "//tensorflow_probability/python/experimental/sts_gibbs", "//tensorflow_probability/python/experimental/substrates", "//tensorflow_probability/python/internal:auto_composite_tensor", "//tensorflow_probability/python/experimental/util:composite_tensor", diff --git a/tensorflow_probability/python/sts/BUILD b/tensorflow_probability/python/sts/BUILD index b83546e22a..dcc9de4cdc 100644 --- a/tensorflow_probability/python/sts/BUILD +++ b/tensorflow_probability/python/sts/BUILD @@ -144,6 +144,7 @@ multi_substrate_py_library( # numpy dep, # tensorflow dep, "//tensorflow_probability/python/experimental/util", + "//tensorflow_probability/python/internal:prefer_static", "//tensorflow_probability/python/sts/internal", ], ) diff --git a/tensorflow_probability/python/sts/forecast.py b/tensorflow_probability/python/sts/forecast.py index 9505ff71ed..455369ce90 100644 --- a/tensorflow_probability/python/sts/forecast.py +++ b/tensorflow_probability/python/sts/forecast.py @@ -19,6 +19,7 @@ from tensorflow_probability.python import distributions as tfd from tensorflow_probability.python.experimental import util as tfe_util from tensorflow_probability.python.internal import distribution_util as dist_util +from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.sts.internal import util as sts_util from tensorflow.python.util import deprecation # pylint: disable=g-direct-tensorflow-import @@ -171,8 +172,7 @@ def plot_one_step_predictive(observed_time_series, # Run filtering over the training timesteps to extract the # predictive means and variances. - num_timesteps = dist_util.prefer_static_value( - tf.shape(observed_time_series))[-2] + num_timesteps = ps.dimension_size(observed_time_series, -2) lgssm = tfe_util.JitPublicMethods( model.make_state_space_model(num_timesteps=num_timesteps, param_vals=parameter_samples), @@ -328,8 +328,7 @@ def plot_forecast(observed_time_series, # filtering distribution, pushed through the transition model). # This is the prior for the forecast model ("today's prior # is yesterday's posterior"). - num_observed_steps = dist_util.prefer_static_value( - tf.shape(observed_time_series))[-2] + num_observed_steps = ps.dimension_size(observed_time_series, -2) observed_data_ssm = tfe_util.JitPublicMethods( model.make_state_space_model(num_timesteps=num_observed_steps, param_vals=parameter_samples), @@ -394,8 +393,11 @@ def plot_forecast(observed_time_series, # Avoid eager-mode loops when querying the forecast. forecast_ssm = tfe_util.JitPublicMethods(forecast_ssm, trace_only=True) - num_posterior_draws = dist_util.prefer_static_value( - forecast_ssm.batch_shape_tensor())[-1] + num_posterior_draws = ( + tf.compat.dimension_value(forecast_ssm.batch_shape[-1])) + if num_posterior_draws is None: + num_posterior_draws = ( + dist_util.prefer_static_value(forecast_ssm.batch_shape_tensor()[-1])) return tfd.MixtureSameFamily( mixture_distribution=tfd.Categorical( logits=tf.zeros([num_posterior_draws], dtype=forecast_ssm.dtype)), @@ -505,8 +507,7 @@ def impute_missing_values(model, # Run smoothing over the training timesteps to extract the # predictive means and variances. - num_timesteps = dist_util.prefer_static_value( - tf.shape(observed_time_series))[-2] + num_timesteps = ps.dimension_size(observed_time_series, -2) lgssm = tfe_util.JitPublicMethods( model.make_state_space_model(num_timesteps=num_timesteps, param_vals=parameter_samples), diff --git a/tensorflow_probability/python/sts/forecast_test.py b/tensorflow_probability/python/sts/forecast_test.py index ed60c2e4bf..785f5ad0e2 100644 --- a/tensorflow_probability/python/sts/forecast_test.py +++ b/tensorflow_probability/python/sts/forecast_test.py @@ -59,10 +59,15 @@ def test_one_step_predictive_correctness(self): 'observation_noise_scale': self._build_tensor( [observation_noise_scale])} - onestep_dist = tfp.sts.one_step_predictive(model, observed_time_series, - timesteps_are_event_shape=False, - parameter_samples=params) - onestep_mean, onestep_scale = onestep_dist.mean(), onestep_dist.stddev() + @tf.function(autograph=False, jit_compile=tf.executing_eagerly()) + def _run(): + onestep_dist = tfp.sts.one_step_predictive( + model, + observed_time_series, + timesteps_are_event_shape=False, + parameter_samples=params) + return onestep_dist.mean(), onestep_dist.stddev() + onestep_mean, onestep_scale = _run() # Since Seasonal is just a set of interleaved random walks, it's # straightforward to compute the forecast analytically. @@ -99,16 +104,22 @@ def test_one_step_predictive_with_batch_shape(self): seed=test_util.test_seed()) for param in model.parameters] - onestep_dist = tfp.sts.one_step_predictive(model, observed_time_series, - timesteps_are_event_shape=False, - parameter_samples=prior_samples) + @tf.function(autograph=False, jit_compile=tf.executing_eagerly()) + def _run(): + d = tfp.sts.one_step_predictive( + model, + observed_time_series, + timesteps_are_event_shape=False, + parameter_samples=prior_samples) + d_mean = d.mean() + return d, d_mean, d.log_prob(d_mean) + onestep_dist, onestep_mean, onestep_mean_log_prob = _run() self.evaluate(tf1.global_variables_initializer()) self.assertAllEqual(onestep_dist.batch_shape_tensor(), batch_shape + [num_timesteps]) - onestep_mean = onestep_dist.mean() self.assertAllEqual(tf.shape(onestep_mean), batch_shape + [num_timesteps]) - self.assertAllEqual(tf.shape(onestep_dist.log_prob(onestep_mean)), + self.assertAllEqual(tf.shape(onestep_mean_log_prob), batch_shape + [num_timesteps]) def test_forecast_correctness(self): @@ -126,12 +137,14 @@ def test_forecast_correctness(self): 'observation_noise_scale': self._build_tensor( [observation_noise_scale])} - forecast_dist = tfp.sts.forecast(model, observed_time_series, - parameter_samples=params, - num_steps_forecast=8, - include_observation_noise=True) - forecast_mean = forecast_dist.mean()[..., 0] - forecast_scale = forecast_dist.stddev()[..., 0] + @tf.function(autograph=False, jit_compile=tf.executing_eagerly()) + def _run(): + forecast_dist = tfp.sts.forecast(model, observed_time_series, + parameter_samples=params, + num_steps_forecast=8, + include_observation_noise=True) + return forecast_dist.mean()[..., 0], forecast_dist.stddev()[..., 0] + forecast_mean, forecast_scale = _run() # Since Seasonal is just a set of interleaved random walks, it's # straightforward to compute the forecast analytically. @@ -225,14 +238,22 @@ def test_forecast_with_batch_shape(self): param.prior.sample(num_param_samples, seed=test_util.test_seed()) for param in model.parameters] - forecast_dist = tfp.sts.forecast(model, observed_time_series, - parameter_samples=prior_samples, - num_steps_forecast=num_steps_forecast) + @tf.function(autograph=False, jit_compile=tf.executing_eagerly()) + def _run(): + d = tfp.sts.forecast(model, observed_time_series, + parameter_samples=prior_samples, + num_steps_forecast=num_steps_forecast) + d_mean = d.mean() + # NOTE: `d` is wrapped by `JitPublicMethods`, and thus cannot currently + # be returned from a `tf.function`-ed function. + return d.batch_shape_tensor(), d_mean, d.log_prob(d_mean) + forecast_batch_shape, forecast_mean, forecast_mean_log_prob = _run() self.evaluate(tf1.global_variables_initializer()) - self.assertAllEqual(forecast_dist.batch_shape_tensor(), batch_shape) - self.assertAllEqual(tf.shape(forecast_dist.mean()), + self.assertAllEqual(forecast_batch_shape, batch_shape) + self.assertAllEqual(tf.shape(forecast_mean), batch_shape + [num_steps_forecast, 1]) + self.assertAllEqual(tf.shape(forecast_mean_log_prob), batch_shape) def test_methods_handle_masked_inputs(self): num_param_samples = 5 @@ -296,20 +317,26 @@ def test_impute_missing(self): self._build_tensor([drift_scale]), 'observation_noise_scale': self._build_tensor( [noise_scale])} - imputed_series_dist = tfp.sts.impute_missing_values( - model, observed_time_series, parameter_samples, - timesteps_are_event_shape=False) - imputed_noisy_series_dist = tfp.sts.impute_missing_values( - model, observed_time_series, parameter_samples, - timesteps_are_event_shape=False, - include_observation_noise=True) + + @tf.function(autograph=False, jit_compile=tf.executing_eagerly()) + def _run(): + imputed_series_dist = tfp.sts.impute_missing_values( + model, observed_time_series, parameter_samples, + timesteps_are_event_shape=False) + imputed_noisy_series_dist = tfp.sts.impute_missing_values( + model, observed_time_series, parameter_samples, + timesteps_are_event_shape=False, + include_observation_noise=True) + mean, stddev = imputed_series_dist.mean(), imputed_series_dist.stddev() + noisy_mean, noisy_stddev = [imputed_noisy_series_dist.mean(), + imputed_noisy_series_dist.stddev()] + return (imputed_noisy_series_dist, mean, stddev, noisy_mean, noisy_stddev) + (imputed_noisy_series_dist, mean, stddev, noisy_mean, noisy_stddev) = _run() + self.assertAllEqual(imputed_noisy_series_dist.batch_shape_tensor(), [num_timesteps]) # Compare imputed mean to expected mean. - mean, stddev = imputed_series_dist.mean(), imputed_series_dist.stddev() - noisy_mean, noisy_stddev = [imputed_noisy_series_dist.mean(), - imputed_noisy_series_dist.stddev()] self.assertAllClose(mean, [-1., 1., 2., 2.4, -1., 1., 2.], atol=1e-2) self.assertAllClose(mean, noisy_mean, atol=1e-2) From f9e77d469e0ef84fd5b0c96cade1a22f2e10417e Mon Sep 17 00:00:00 2001 From: kloveless Date: Thu, 28 Apr 2022 20:44:26 -0700 Subject: [PATCH 112/153] Reduce the number of Cholesky updates from 3 to 2, as an efficiency gain. PiperOrigin-RevId: 445316489 --- .../experimental/sts_gibbs/spike_and_slab.py | 50 +++++++++++-------- 1 file changed, 30 insertions(+), 20 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index 12de433fd2..5fea29a376 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -690,7 +690,8 @@ def _symmetric_increment_chol(chol, idx, increment): M[idx, idx] -= increment[idx] ``` - in Cholesky space, where `increment` is a vector of length `m`. + in Cholesky space, but in an optimized form as 2 steps, where `increment` is + a vector of length `m`. That is, this function adds `increment` to the `idx`th row, and (by symmetry) also to the `idx`th column. For example: @@ -708,7 +709,7 @@ def _symmetric_increment_chol(chol, idx, increment): # [0., -0.3, 2.]] ``` - This is implemented efficiently as three consecutive rank-1 updates of + This is implemented efficiently as two consecutive rank-1 updates of `chol(M)`. Args: @@ -724,30 +725,39 @@ def _symmetric_increment_chol(chol, idx, increment): given row and column of `M`. """ with tf.name_scope('symmetric_increment_chol'): - # TODO(jburnim): Can we make this more numerically accurate by doing all - # three rank-1 Cholesky updates in a single pass? + # TODO(jburnim): Can we make this more numerically accurate by doing both + # rank-1 Cholesky updates in a single pass? chol = tf.convert_to_tensor(chol, name='chol') increment = tf.convert_to_tensor(increment, name='increment') orig_chol = chol - # Rank-1 update to increment the `idx`th row and column, with side - # effects elsewhere in the matrix. - chol = tfp_math.cholesky_update( - chol, update_vector=_set_vector_index(increment, idx, 1.), multiplier=1) - # Second update to correct the diagonal entry `M[idx, idx]`. - diagonal_correction = increment[..., idx] - 1. + # This does an update of the row and column in 2 rank-1 updates. + # Consider an example update vector of v = [x, y, z]. Thus v @ v.T is: + # [[x^2, xy, xz], + # [xy, y^2, yz], + # [xz, yz, z^2]] + # cholesky_update will compute the return the updated cholesky given + # this being added to the original matrix. + # + # Say we want update row and column 1, then the needed offset matrix is: + # [[0, x, 0], + # [x, y, z], + # [0, z, 0]] + # which is rank 2 and will require at least two rank 1 operations. + # + # If we do two updates, by adding v1 and subtracting v2, where + # v1 = [x, (y + 1)/2, z] + # v2 = [x, (y - 1)/2, z] + # this accomplishes the goal, since: + # [[0, x, 0], + # [x, y, z], = v1 @ v1.T - v2 @ v2.T + # [0, z, 0]] + a = (increment[..., idx] + 1.) / 2. + b = (increment[..., idx] - 1.) / 2. chol = tfp_math.cholesky_update( - chol, - update_vector=_set_vector_index(tf.zeros_like(increment), - idx, - tf.sqrt(tf.abs(diagonal_correction))), - multiplier=tf.sign(diagonal_correction)) - # Final update to revert the side effects from the first step without - # touching the (newly incremented) `idx`th row/col. + chol, update_vector=_set_vector_index(increment, idx, a), multiplier=1) chol = tfp_math.cholesky_update( - chol, - update_vector=_set_vector_index(increment, idx, 0.), - multiplier=-1) + chol, update_vector=_set_vector_index(increment, idx, b), multiplier=-1) # There Cholesky decomposition should be unchanged in rows/cols before idx. # From 485cd10059fa1df68e827bdddf02b4170dc2ac7a Mon Sep 17 00:00:00 2001 From: sharadmv Date: Fri, 29 Apr 2022 12:43:47 -0700 Subject: [PATCH 113/153] [Oryx] Fix unzip to use updated `JaxprEqnRecipe` fields PiperOrigin-RevId: 445482876 --- spinoffs/oryx/oryx/core/interpreters/unzip.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spinoffs/oryx/oryx/core/interpreters/unzip.py b/spinoffs/oryx/oryx/core/interpreters/unzip.py index 6e805c0a5f..3b1dafb7b9 100644 --- a/spinoffs/oryx/oryx/core/interpreters/unzip.py +++ b/spinoffs/oryx/oryx/core/interpreters/unzip.py @@ -425,7 +425,7 @@ def aval(self): @property def parents(self): if isinstance(self.recipe, pe.JaxprEqnRecipe): - return self.recipe.invars + return self.recipe.in_tracers else: return [] From 9adcbb2ed55cc424d17b8f82240b2398425c2566 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Fri, 29 Apr 2022 12:51:19 -0700 Subject: [PATCH 114/153] Start with features enabled if they have a probability of 1 or higher PiperOrigin-RevId: 445484479 --- .../experimental/sts_gibbs/gibbs_sampler.py | 12 ++++++- .../sts_gibbs/gibbs_sampler_test.py | 35 ++++++++++++++++++- 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index d2cbd4132f..c753700a68 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -828,6 +828,14 @@ def _build_sampler_loop_body(model, **({ 'default_pseudo_observations': default_pseudo_observations } if default_pseudo_observations is not None else {})) + # In case the nonzero probability is exactly one, any proposal with any + # zero weights will have log prob of -infinity, so we will pin the + # proposals to one. + # TODO(colcarroll): Can we short-circuit the feature selection loop in + # case this is `True`? + pin_to_nonzero = tf.greater_equal( + regression_component._sparse_weights_nonzero_prob, 1.) # pylint: disable=protected-access + else: weights_prior_scale = (regression_component.parameters[0].prior.scale) @@ -852,10 +860,12 @@ def sampler_loop_body(previous_sample, _): if model_has_spike_slab_regression: (observation_noise_variance, weights) = spike_and_slab_sampler.sample_noise_variance_and_weights( - initial_nonzeros=tf.not_equal(previous_sample.weights, 0.), + initial_nonzeros=tf.math.logical_or( + tf.not_equal(previous_sample.weights, 0.), pin_to_nonzero), targets=observed_time_series - previous_sample.level, seed=weights_seed) observation_noise_scale = tf.sqrt(observation_noise_variance) + else: weights = _resample_weights( design_matrix=design_matrix, diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index ff071fd117..b188f04f03 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -345,7 +345,7 @@ def test_invalid_model_spec_raises_error(self): level_variance_prior=tfd.InverseGamma(0.01, 0.01), observation_noise_variance_prior=tfd.LogNormal(0., 3.)) - def test_invalid_optons_with_none_design_matrix_raises_error(self): + def test_invalid_options_with_none_design_matrix_raises_error(self): observed_time_series = tf.ones([2]) with self.assertRaisesRegex( ValueError, @@ -558,6 +558,39 @@ def test_sampled_weights_follow_correct_distribution(self): self.assertAllClose(sampled_weights_cov_, weights_posterior_cov_, atol=0.01, rtol=0.05) + def test_sparse_weights_nonzero_prob_of_one_works(self): + true_weights = tf.constant([0., 0., 2., 0., -2.]) + model, observed_time_series, _ = self._build_test_model( + num_timesteps=20, + num_features=5, + missing_prob=0., + true_noise_scale=0.1, + weights=true_weights, + weights_prior_scale=None, # Default g-prior. + sparse_weights_nonzero_prob=1.) + + @tf.function(autograph=False) + def do_sampling(): + return gibbs_sampler.fit_with_gibbs_sampling( + model, + observed_time_series, + num_results=100, + num_warmup_steps=100, + seed=test_util.test_seed(sampler_type='stateless')) + + samples = self.evaluate(do_sampling()) + mean_weights = tf.reduce_mean(samples.weights, axis=-2) + nonzero_probs = tf.reduce_mean( + tf.cast(tf.not_equal(samples.weights, 0.), tf.float32), + axis=-2) + # Increasing `num_timesteps` relative to `num_features` would give more + # precise weight estimates, at the cost of longer test runtime. + # TODO(axch, cgs): Can we use assertAllMeansClose here too? The + # samples are presumably not IID across axis=0, so the + # statistical assumptions are not satisfied. + self.assertAllClose(mean_weights, true_weights, atol=0.3) + self.assertAllClose(nonzero_probs, [1., 1., 1., 1., 1.]) + def test_sparse_regression_recovers_plausible_weights(self): true_weights = tf.constant([0., 0., 2., 0., -2.]) model, observed_time_series, _ = self._build_test_model( From d4716a1f04be3a8fdbc5dd5a44cd35b4517361ac Mon Sep 17 00:00:00 2001 From: colcarroll Date: Mon, 2 May 2022 11:38:56 -0700 Subject: [PATCH 115/153] Resample `observation_noise_scale` in case there is no regression component. PiperOrigin-RevId: 445988335 --- .../experimental/sts_gibbs/gibbs_sampler.py | 2 +- .../sts_gibbs/gibbs_sampler_test.py | 77 ++++++++++++++----- 2 files changed, 59 insertions(+), 20 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index c753700a68..e0f46c9396 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -912,7 +912,7 @@ def sampler_loop_body(previous_sample, _): observed_residuals=slope_residuals, is_missing=None, seed=slope_scale_seed) - if regression_component and not model_has_spike_slab_regression: + if not (regression_component and model_has_spike_slab_regression): # Estimate noise scale from the residuals. observation_noise_scale = _resample_scale( prior=observation_noise_variance_prior, diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index b188f04f03..80328a7281 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -49,8 +49,10 @@ def _build_test_model(self, sparse_weights_nonzero_prob=None, time_series_shift=0., dtype=tf.float32, - design_matrix_is_none=False): - seed = test_util.test_seed(sampler_type='stateless') + design_matrix=False, + seed=None): + if seed is None: + seed = test_util.test_seed(sampler_type='stateless') (design_seed, weights_seed, noise_seed, @@ -61,13 +63,13 @@ def _build_test_model(self, if weights is None: weights = samplers.normal( list(batch_shape) + [num_features], dtype=dtype, seed=weights_seed) - if design_matrix_is_none: - design_matrix = None + if design_matrix is None: regression = tf.zeros(num_timesteps, dtype) else: - design_matrix = samplers.normal([num_timesteps, num_features], - dtype=dtype, - seed=design_seed) + if isinstance(design_matrix, bool) and not design_matrix: + design_matrix = samplers.normal([num_timesteps, num_features], + dtype=dtype, + seed=design_seed) regression = tf.linalg.matvec(design_matrix, weights) noise = samplers.normal( list(batch_shape) + [num_timesteps], @@ -289,34 +291,71 @@ def do_sampling(observed_time_series, is_missing): self.assertAllEqual(predictive_mean_, predictive_mean2_) self.assertAllEqual(predictive_stddev_, predictive_stddev2_) - def test_no_covariates_support(self): + def test_no_covariates_is_similar_to_zero_design_matrix(self): if not tf.executing_eagerly(): return seed = test_util.test_seed(sampler_type='stateless') + build_model_seed, sample_seed = samplers.split_seed(seed) dtype = tf.float32 + num_timesteps = 5 + num_features = 2 + seed = test_util.test_seed(sampler_type='stateless') model, observed_time_series, is_missing = self._build_test_model( - num_timesteps=5, + num_timesteps=num_timesteps, + num_features=num_features, batch_shape=[3], prior_class=gibbs_sampler.XLACompilableInverseGamma, + time_series_shift=10., dtype=dtype, - design_matrix_is_none=True, - weights_prior_scale=None) + design_matrix=None, + weights_prior_scale=None, + seed=build_model_seed) @tf.function(jit_compile=True) def do_sampling(observed_time_series, is_missing): return gibbs_sampler.fit_with_gibbs_sampling( model, tfp.sts.MaskedTimeSeries(observed_time_series, is_missing), - num_results=4, - num_warmup_steps=1, - seed=seed) + num_results=30, + num_warmup_steps=10, + seed=sample_seed) - # This simply ensures we can get samples without throwing an error. - # TODO(kloveless): Add tests that compare the results with either another - # method of inference, or to a model with covariates, but all covariates - # are zero. samples = do_sampling(observed_time_series[..., tf.newaxis], is_missing) - gibbs_sampler.one_step_predictive(model, samples, thin_every=1) + + dummy_model, observed_time_series, is_missing = self._build_test_model( + num_timesteps=num_timesteps, + num_features=num_features, + batch_shape=[3], + prior_class=gibbs_sampler.XLACompilableInverseGamma, + dtype=dtype, + time_series_shift=10., + design_matrix=tf.zeros([num_timesteps, num_features]), + weights_prior_scale=None, + sparse_weights_nonzero_prob=0.5, + seed=build_model_seed) # reuse seed! + + @tf.function(jit_compile=True) + def do_sampling_again(observed_time_series, is_missing): + return gibbs_sampler.fit_with_gibbs_sampling( + dummy_model, + tfp.sts.MaskedTimeSeries(observed_time_series, is_missing), + num_results=30, + num_warmup_steps=10, + seed=sample_seed) + + new_samples = do_sampling_again(observed_time_series[..., tf.newaxis], + is_missing) + for key in ('observation_noise_scale', 'level_scale', 'level', + 'slope_scale', 'slope'): + first_mean = tf.reduce_mean(getattr(samples, key), axis=0) + second_mean = tf.reduce_mean(getattr(new_samples, key), axis=0) + self.assertAllClose(first_mean, second_mean, atol=0.15, + msg=f'{key} mean differ') + + first_std = tf.math.reduce_std(getattr(samples, key), axis=0) + second_std = tf.math.reduce_std(getattr(new_samples, key), axis=0) + self.assertAllClose(first_std, second_std, atol=0.2, + msg=f'{key} stddev differ') def test_invalid_model_spec_raises_error(self): observed_time_series = tf.ones([2]) From fae5c70dfa56b5860f43411a1f8234626e567cf0 Mon Sep 17 00:00:00 2001 From: sharadmv Date: Mon, 2 May 2022 21:03:40 -0700 Subject: [PATCH 116/153] [Oryx] Delete the `unzip` transformation `unzip` can be implemented with `harvest`. PiperOrigin-RevId: 446101576 --- .../examples/notebooks/a_tour_of_oryx.ipynb | 74 -- spinoffs/oryx/oryx/core/BUILD | 1 - spinoffs/oryx/oryx/core/__init__.py | 2 - spinoffs/oryx/oryx/core/interpreters/BUILD | 30 - .../oryx/oryx/core/interpreters/__init__.py | 1 - .../oryx/core/interpreters/log_prob_test.py | 12 - spinoffs/oryx/oryx/core/interpreters/unzip.py | 760 ------------------ .../oryx/oryx/core/interpreters/unzip_test.py | 353 -------- spinoffs/oryx/oryx/core/state/BUILD | 1 - spinoffs/oryx/oryx/core/state/__init__.py | 1 - spinoffs/oryx/oryx/core/state/function.py | 1 - spinoffs/oryx/oryx/distributions/BUILD | 1 - .../distributions/distribution_extensions.py | 2 - .../distribution_extensions_test.py | 13 - spinoffs/oryx/oryx/experimental/nn/BUILD | 1 - 15 files changed, 1253 deletions(-) delete mode 100644 spinoffs/oryx/oryx/core/interpreters/unzip.py delete mode 100644 spinoffs/oryx/oryx/core/interpreters/unzip_test.py diff --git a/spinoffs/oryx/examples/notebooks/a_tour_of_oryx.ipynb b/spinoffs/oryx/examples/notebooks/a_tour_of_oryx.ipynb index 05a2ec4ad9..6287c08955 100644 --- a/spinoffs/oryx/examples/notebooks/a_tour_of_oryx.ipynb +++ b/spinoffs/oryx/examples/notebooks/a_tour_of_oryx.ipynb @@ -156,7 +156,6 @@ "plant = oryx.core.plant\n", "reap = oryx.core.reap\n", "sow = oryx.core.sow\n", - "unzip = oryx.core.unzip\n", "\n", "nn = oryx.experimental.nn\n", "mcmc = oryx.experimental.mcmc\n", @@ -233,79 +232,6 @@ "execution_count": null, "outputs": [] }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "ffR6Emmm5OVI" - }, - "source": [ - "### Unzip\n", - "`oryx.core.unzip` splits a function in two along a set of values tagged as intermediates, then returning the functions `init_f` and `apply_f`. `init_f` takes in a key argument and returns the intermediates. `apply_f` returns a function that takes in the intermediates and returns the original function's output." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab_type": "code", - "id": "ojFVr_ZKm0UX", - "colab": {} - }, - "source": [ - "def f(key, x):\n", - " w = sow(random.normal(key), tag='variable', name='w')\n", - " return w * x\n", - "init_f, apply_f = unzip(f, tag='variable')(random.PRNGKey(0), 1.)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jUJ5isbLjGy8", - "colab_type": "text" - }, - "source": [ - "The `init_f` function runs `f` but only returns its variables." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "26VUK0nTjLcO", - "colab_type": "code", - "colab": {} - }, - "source": [ - "init_f(random.PRNGKey(0))" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0KWemKR2jOn6", - "colab_type": "text" - }, - "source": [ - "`apply_f` takes a set of variables as its first input and executes `f` with the given set of variables." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "SpKFfQZqiDAR", - "colab_type": "code", - "colab": {} - }, - "source": [ - "apply_f(dict(w=2.), 2.) # Runs f with `w = 2`.\n" - ], - "execution_count": null, - "outputs": [] - }, { "cell_type": "markdown", "metadata": { diff --git a/spinoffs/oryx/oryx/core/BUILD b/spinoffs/oryx/oryx/core/BUILD index feb28d55c4..f81b7f932c 100644 --- a/spinoffs/oryx/oryx/core/BUILD +++ b/spinoffs/oryx/oryx/core/BUILD @@ -31,7 +31,6 @@ py_library( "//oryx/core/interpreters", "//oryx/core/interpreters:harvest", "//oryx/core/interpreters:log_prob", - "//oryx/core/interpreters:unzip", "//oryx/core/interpreters/inverse:core", "//oryx/core/interpreters/inverse:custom_inverse", "//oryx/core/ppl", diff --git a/spinoffs/oryx/oryx/core/__init__.py b/spinoffs/oryx/oryx/core/__init__.py index 4ee3a0985b..40f37ba104 100644 --- a/spinoffs/oryx/oryx/core/__init__.py +++ b/spinoffs/oryx/oryx/core/__init__.py @@ -33,8 +33,6 @@ from oryx.core.interpreters.inverse.custom_inverse import NonInvertibleError from oryx.core.interpreters.log_prob import log_prob from oryx.core.interpreters.log_prob import log_prob_registry -from oryx.core.interpreters.unzip import unzip -from oryx.core.interpreters.unzip import unzip_registry from oryx.core.primitive import call_bind from oryx.core.primitive import FlatPrimitive from oryx.core.primitive import HigherOrderPrimitive diff --git a/spinoffs/oryx/oryx/core/interpreters/BUILD b/spinoffs/oryx/oryx/core/interpreters/BUILD index f59d9702f2..1f69f230bf 100644 --- a/spinoffs/oryx/oryx/core/interpreters/BUILD +++ b/spinoffs/oryx/oryx/core/interpreters/BUILD @@ -27,23 +27,10 @@ py_library( ":harvest", ":log_prob", ":propagate", - ":unzip", "//oryx/core/interpreters/inverse", ], ) -# pytype_strict -py_library( - name = "unzip", - srcs = ["unzip.py"], - deps = [ - ":harvest", - # jax dep, - # numpy dep, - "//oryx/core:trace_util", - ], -) - # pytype_strict py_library( name = "propagate", @@ -78,22 +65,6 @@ py_library( ], ) -# py_strict -py_test( - name = "unzip_test", - srcs = ["unzip_test.py"], - deps = [ - ":harvest", - ":unzip", - # absl/testing:absltest dep, - # jax dep, - # numpy dep, - "//oryx/core:trace_util", - "//oryx/core/state", - "//oryx/internal:test_util", - ], -) - # py_strict py_test( name = "propagate_test", @@ -131,7 +102,6 @@ py_test( # absl/testing:absltest dep, # jax dep, "//oryx/bijectors", - "//oryx/core", "//oryx/core/state", "//oryx/distributions", "//oryx/internal:test_util", diff --git a/spinoffs/oryx/oryx/core/interpreters/__init__.py b/spinoffs/oryx/oryx/core/interpreters/__init__.py index 9fb1532a62..ad55c0e00a 100644 --- a/spinoffs/oryx/oryx/core/interpreters/__init__.py +++ b/spinoffs/oryx/oryx/core/interpreters/__init__.py @@ -17,4 +17,3 @@ from oryx.core.interpreters import inverse from oryx.core.interpreters import log_prob from oryx.core.interpreters import propagate -from oryx.core.interpreters import unzip diff --git a/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py b/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py index 103ee23bbe..0a9e8353f9 100644 --- a/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py +++ b/spinoffs/oryx/oryx/core/interpreters/log_prob_test.py @@ -22,7 +22,6 @@ import jax.numpy as np from oryx import bijectors as bb -from oryx import core from oryx import distributions as bd from oryx.core import state from oryx.core.interpreters.log_prob import log_prob @@ -129,17 +128,6 @@ def f(rng, x): f_lp = log_prob(f) self.assertEqual(f_lp(0.1, 1.0), bd.Normal(0., 1.).log_prob(-0.9)) - def test_unzip(self): - - def f(rng): - k1, k2 = random.split(rng) - z = random_normal(k1, name='z') - return random_normal(k2, name='x') + z - - init, _ = core.unzip(f, tag=state.VARIABLE)(random.PRNGKey(0)) - f_lp = log_prob(init) - f_lp(init(random.PRNGKey(0))) - def test_log_prob_in_call(self): def f(rng): diff --git a/spinoffs/oryx/oryx/core/interpreters/unzip.py b/spinoffs/oryx/oryx/core/interpreters/unzip.py deleted file mode 100644 index 3b1dafb7b9..0000000000 --- a/spinoffs/oryx/oryx/core/interpreters/unzip.py +++ /dev/null @@ -1,760 +0,0 @@ -# Copyright 2020 The TensorFlow Probability Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# ============================================================================ -"""Module for the unzip function transformation. - -Unzip is a function transformation that looks -for 'variable' instantiations and pulls out -concretized variables for partial evaluation. -Primitives that return variables are registered -in the unzip_registry. - -Unzip returns two functions: - 1. `init` - maps inputs to variables - 2. `apply` - maps variables and inputs to output -""" -import contextlib -import itertools as it - -import dataclasses -from jax import abstract_arrays -from jax import api_util -from jax import core as jax_core -from jax import custom_derivatives as cd -from jax import linear_util as lu -from jax import tree_util -from jax import util as jax_util -from jax._src import source_info_util -from jax.interpreters import partial_eval as pe -import numpy as onp - -from oryx.core import trace_util -from oryx.core.interpreters import harvest - -__all__ = [ - 'VariableError', - 'UnzipTrace', - 'UnzipTracer', - 'unzip', - 'unzip_registry', -] - -safe_map = jax_core.safe_map -safe_zip = jax_core.safe_zip - -unzip_registry = {} -block_registry = set() - - -def mapped_aval(*args, **kwargs): - return jax_core.mapped_aval(*args, **kwargs) - - -class VariableError(Exception): - """Raised if unable to unzip a function.""" - - -class UnzipCustomRules: - """defaultdict-like class that defers to pe.custom_partial_eval_rules.""" - - def __init__(self, rules): - self.rules = rules - - def __getitem__(self, key): - if key not in self.rules: - - def custom_rule(*tracers, **params): - out_jaxpr_tracers = pe.custom_partial_eval_rules[key](*tracers, - **params) - out_tracers = [UnzipTracer( - out_tracer._trace, out_tracer.pval, out_tracer.recipe, # pylint: disable=protected-access - False, None) for out_tracer in out_jaxpr_tracers] - for out_tracer in out_tracers: - recipe = out_tracer.recipe - out_tracer.recipe = pe.new_eqn_recipe(recipe.invars, out_tracers, - recipe.primitive, recipe.params, - recipe.effects, - recipe.source_info) # pytype: disable=wrong-arg-types - return out_tracers - - return custom_rule - return self.rules[key] - - def __setitem__(self, key, val): - self.rules[key] = val - - def __contains__(self, key): - return key in self.rules or key in pe.custom_partial_eval_rules - - def update(self, new_rules): - return self.rules.update(new_rules) - - def copy(self): - return UnzipCustomRules(self.rules.copy()) - - -custom_rules = UnzipCustomRules({}) -custom_rule_stack = [custom_rules] - -current_custom_rules = lambda: custom_rule_stack[-1] - - -@contextlib.contextmanager -def new_custom_rules(rules): - new_rules = current_custom_rules().copy() - new_rules.update(rules) - custom_rule_stack.append(new_rules) - yield - custom_rule_stack.pop(-1) - - -class VariableRecipe: - - def __init__(self, name, in_tracers, out_tracers): - self.name = name - self.in_tracers = in_tracers - self.out_tracers = out_tracers - - -@dataclasses.dataclass(frozen=True) -class UnzipSettings: - tag: str - block: bool - - -@dataclasses.dataclass -class UnzipContext: - settings: UnzipSettings - - -class UnzipTrace(jax_core.Trace): - """Contains logic for handling UnzipTracers when tracing a function. - - The UnzipTrace is very similar to jax.interpreters.partial_eval.JaxprTrace, - where it adds additional recipes into the tracers that track the variables - produced while tracing. Variables are defined as outputs of the `variable` - primitive that are also tagged as "keys". Inputs to the trace are designated - as keys using `trace.new_arg` and if all the inputs to any primitive are - "keys", the outputs are also "keys". - """ - - def pure(self, val): - return self.new_const(val) - - def lift(self, val): - return self.new_const(val) - - def sublift(self, val): - return UnzipTracer(self, val.pval, pe.FreeVar(val), True) - - def new_const(self, val): - if isinstance(val, jax_core.Tracer) and val._trace.level == self.level: # pylint: disable=protected-access - raise Exception - return UnzipTracer(self, pe.PartialVal.known(val), jax_core.unit, True) - - def new_instantiated_literal(self, val): - aval = trace_util.get_shaped_aval(val) - return UnzipTracer(self, - pe.PartialVal.unknown(aval), - jax_core.Literal(val, aval), True) - - def new_instantiated_const(self, val): - return UnzipTracer(self, - pe.PartialVal.unknown(trace_util.get_shaped_aval(val)), - pe.ConstVar(val), True) - - def new_arg(self, pval, key): - return UnzipTracer(self, pval, pe.LambdaBinding(), key) - - def instantiate_const(self, tracer): - pv, const = tracer.pval - if isinstance(pv, jax_core.AbstractValue): - return tracer - elif not pv: - if type(const) in jax_core.literalable_types and not onp.shape(const): # pylint: disable=unidiomatic-typecheck - return self.new_instantiated_literal(const) - else: - return self.new_instantiated_const(const) - else: - raise TypeError(pv) - - def instantiate_const_abstracted(self, tracer): - pv, const = tracer.pval - if isinstance(pv, jax_core.AbstractValue): - return tracer - elif pv is None: - aval = abstract_arrays.raise_to_shaped( - trace_util.get_shaped_aval(const), onp.isscalar(const)) - return UnzipTracer(self, pe.PartialVal.unknown(aval), pe.ConstVar(const), - tracer.is_key()) - else: - raise TypeError(pv) - - def process_primitive(self, primitive, tracers, params): - if primitive in current_custom_rules(): - return current_custom_rules()[primitive](self, *tracers, **params) - return self.default_process_primitive(primitive, tracers, params) - - def default_process_primitive(self, primitive, tracers, params): - """Partially evaluate primitives and saves variable recipes.""" - pvs, consts = jax_util.unzip2(t.pval for t in tracers) - if all(pv is None for pv in pvs): - return primitive.bind(*consts, **params) - settings = trace_util.get_dynamic_context(self).settings - tracers = safe_map(self.instantiate_const, tracers) - if any(not isinstance(t, UnzipTracer) for t in tracers): - assert False - key = all(t.is_key() for t in tracers) - avals = [t.aval for t in tracers] - ans, effects = primitive.abstract_eval(*avals, **params) - if not primitive.multiple_results: - ans = [ans] - out_tracers = [ - UnzipTracer(self, pe.PartialVal((aval, jax_core.unit)), None, key) - for aval in ans - ] - # Passing in UnzipTracer, which pytype does not recognize as JaxprTracer - eqn = pe.new_eqn_recipe(tracers, out_tracers, primitive, params, - effects, source_info_util.current()) # pytype: disable=wrong-arg-types - for t in out_tracers: - t.recipe = eqn - - is_variable = ( - key and primitive is harvest.sow_p and params['tag'] == settings.tag) - # This block is where UnzipTrace mainly differs from pe.JaxprTrace. Where - # JaxprTrace will just return out_tracers, UnzipTrace will record an - # additional VariableRecipe into the tracers, which will be used after - # the trace is complete to construct init/apply Jaxprs. - if is_variable: - name, var_in_tracers, var_out_tracers = unzip_registry[primitive]( - tracers, out_tracers, **params) - variable_recipe = VariableRecipe(name, var_in_tracers, var_out_tracers) - for t in out_tracers: - t.variable_recipe = variable_recipe - - if primitive.multiple_results: - return out_tracers - return out_tracers[0] - - def process_call(self, call_primitive, f, tracers, params): - return self.handle_call_primitive(call_primitive, f, tracers, params, False) - - def process_map(self, call_primitive, f, tracers, params): - return self.handle_call_primitive(call_primitive, f, tracers, params, True) - - def handle_call_primitive(self, call_primitive, f, tracers, params, is_map): - """Handler for call_primitives, like jit or layer_call. - - When an UnzipTracer hits a call primitive, there is either a variable - inside of the call primitive, in which case the input - function needs to be unzipped into two, or there are no variables - in the function, so the call_primitive is recorded in the trace as-is. - - We use `unzip_eval_wrapper`, which returns whether or not an unzip - was successful or not. If it was successful, we record two new - Jaxprs into the trace (one for init, one for apply). Otherwise, we - just record the Jaxpr corresponding to the function call. - - Args: - call_primitive: a call primitive like xla_call - f: a jax.linear_util wrapped function to be called - tracers: inputs to the function - params: parameters of the primitives - is_map: whether or not the primitive is a map primitive (e.g. xla_pmap) - - Returns: - A list of output tracers - """ - name = params.get('name', f.__name__) - settings = trace_util.get_dynamic_context(self).settings - tracers = safe_map(self.instantiate_const_abstracted, tracers) - if call_primitive in current_custom_rules(): - return current_custom_rules()[call_primitive](self, f, *tracers, **params) - if call_primitive in pe.call_partial_eval_rules: - raise NotImplementedError - in_pvals = [t.pval for t in tracers] - if is_map: - unknown = pe.PartialVal.unknown - in_pvals = [pval if pval.is_known() or in_axis is None else - unknown(mapped_aval(params['axis_size'], in_axis, pval[0])) - for pval, in_axis in zip(in_pvals, params['in_axes'])] - out_axes_thunk = params['out_axes_thunk'] - @jax_util.as_hashable_function(closure=('unzip', out_axes_thunk)) - def new_out_axes_thunk(): - out_axes = out_axes_thunk() - assert all(out_axis == 0 for out_axis in out_axes) - _, num_outputs, _ = aux() - return (0,) * num_outputs - new_params = dict(params, out_axes_thunk=new_out_axes_thunk) - else: - new_params = params - pvs, in_consts = jax_util.unzip2(t.pval for t in tracers) - keys = tuple(t.is_key() for t in tracers) - new_settings = UnzipSettings(settings.tag, call_primitive in block_registry) - fun, aux = unzip_eval(f, self, keys, tuple(pvs), new_settings) - out_flat = call_primitive.bind(fun, *in_consts, **new_params) - success, _, results = aux() - if not success: - out_pvs, out_keys, jaxpr, env = results - out_pv_consts, consts = jax_util.split_list(out_flat, [len(out_pvs)]) - out_tracers = self._bound_output_tracers(call_primitive, new_params, - jaxpr, consts, env, tracers, - out_pvs, out_pv_consts, - out_keys, name, is_map) - return out_tracers - init_name = jax_util.wrap_name(name, 'init') - apply_name = jax_util.wrap_name(name, 'apply') - init_pvs, num_init_consts, apply_pvs = results[0] - init_jaxpr, apply_jaxpr = results[1] - init_env, apply_env = results[2] - variable_names, variable_tree, apply_keys = results[3] - - key_tracers = [t for t in tracers if t.is_key()] - abstract_tracers = [t for t in tracers if not t.is_key()] - all_init_consts, all_apply_consts = jax_util.split_list( - out_flat, [len(init_pvs) + num_init_consts]) - init_pv_consts, init_consts = jax_util.split_list(all_init_consts, - [len(init_pvs)]) - apply_pv_consts, apply_consts = jax_util.split_list(all_apply_consts, - [len(apply_pvs)]) - - variable_tracers = self._bound_output_tracers( - call_primitive, new_params, init_jaxpr, init_consts, init_env, - key_tracers, init_pvs, init_pv_consts, [True] * len(init_pvs), - init_name, is_map) - - unflat_variables = tree_util.tree_unflatten(variable_tree, variable_tracers) - if call_primitive is harvest.nest_p: - variable_dict = harvest.sow( - dict(safe_zip(variable_names, unflat_variables)), - tag=settings.tag, - name=new_params['scope'], - mode='strict') - unflat_variables = tuple(variable_dict[name] for name in variable_names) - else: - unflat_variables = [ - harvest.sow( # pylint: disable=g-complex-comprehension - unflat_variable, - tag=settings.tag, - name=name, - mode='strict') for unflat_variable, name in safe_zip( - unflat_variables, variable_names) - ] - variable_tracers = tree_util.tree_leaves(unflat_variables) - - out_tracers = self._bound_output_tracers( - call_primitive, new_params, apply_jaxpr, apply_consts, apply_env, - variable_tracers + abstract_tracers, apply_pvs, apply_pv_consts, - apply_keys, apply_name, is_map) - return out_tracers - - def _bound_output_tracers(self, primitive, params, jaxpr, consts, env, - in_tracers, out_pvs, out_consts, out_keys, name, - is_map): - """Takes a traced function and binds the Jaxpr to output tracers.""" - lifted_jaxpr = pe.convert_constvars_jaxpr(jaxpr) - const_tracers = safe_map(self.new_instantiated_const, consts) - env_tracers = safe_map(self.instantiate_const, env) - out_tracers = [ - UnzipTracer(self, pe.PartialVal((pv, const)), None, key) - for pv, const, key in safe_zip(out_pvs, out_consts, out_keys) - ] - new_params = dict(params, name=name, call_jaxpr=lifted_jaxpr) - if 'donated_invars' in params: - new_donated_invars = ( - (False,) * len(const_tracers) + (False,) * len(env_tracers) + - tuple(v for v, t in zip(params['donated_invars'], in_tracers) - if not t.pval.is_known())) - new_params['donated_invars'] = new_donated_invars - if is_map: - out_axes = params['out_axes_thunk']() - assert all(out_axis == 0 for out_axis in out_axes) - new_params['out_axes'] = (0,) * len(out_tracers) - del new_params['out_axes_thunk'] - eqn = pe.new_eqn_recipe( - tuple(const_tracers + env_tracers + in_tracers), out_tracers, primitive, - new_params, lifted_jaxpr.effects, source_info_util.current()) # pytype: disable=wrong-arg-types - for t in out_tracers: - t.recipe = eqn - return out_tracers - - def post_process_call(self, call_primitive, out_tracers, params): - raise NotImplementedError - - -def unzip_eval(f, trace, keys, pvs, settings): - f = unzip_to_init_apply_subjaxprs(f, trace.main, settings, keys) - return unzip_eval_wrapper(f, pvs) - - -class UnzipTracer(jax_core.Tracer): - """Tracer whose state encapsulates if the inputs are keys.""" - - def __init__(self, trace, pval, recipe, key, variable_recipe=None): - self._trace = trace - self.pval = pval - self.recipe = recipe - self.key = key - self.variable_recipe = variable_recipe - - def is_key(self): - return self.key - - @property - def aval(self): - pv, const = self.pval - if isinstance(pv, jax_core.AbstractValue): - return pv - elif pv is None: - return trace_util.get_shaped_aval(const) - else: - raise TypeError(pv) - return self.val - - @property - def parents(self): - if isinstance(self.recipe, pe.JaxprEqnRecipe): - return self.recipe.in_tracers - else: - return [] - - def is_pure(self): - pv, _ = self.pval - return pv is None - - def full_lower(self): - if self.is_pure(): - _, const = self.pval - return jax_core.full_lower(const) - return self - - def __repr__(self): - return 'Traced[{}]<{}:{}>'.format(self.is_key(), self.aval, self._trace) - - -@lu.transformation_with_aux -def unzip_eval_wrapper(pvs, *consts): - """Function transformation that returns init/apply jaxprs and metadata.""" - args = (safe_map(pe.PartialVal, safe_zip(pvs, consts)),) - success, result = yield args, {} - if success: - init_out, apply_out, pvals, metadata = result - init_jaxpr, init_consts, init_env = init_out - apply_jaxpr, apply_consts, apply_env = apply_out - init_pvals, apply_pvals = pvals - init_pvs, init_pv_consts = jax_util.unzip2(init_pvals) - apply_pvs, apply_pv_consts = jax_util.unzip2(apply_pvals) - - out = ( - tuple(init_pv_consts) + tuple(init_consts) + tuple(apply_pv_consts) + - tuple(apply_consts)) - yield out, (success, len(out), - ((init_pvs, len(init_consts), apply_pvs), - (init_jaxpr, apply_jaxpr), - (init_env, apply_env), - metadata)) - else: - jaxpr, (out_pvals, out_keys, consts, env) = result - out_pvs, out_consts = jax_util.unzip2(out_pvals) - out = tuple(out_consts) + tuple(consts) - yield out, (success, len(out), (out_pvs, out_keys, jaxpr, env)) - - -@lu.transformation -def unzip_to_init_apply_subjaxprs(master, settings, keys, pvals): - """Function transformation that returns init/apply jaxprs.""" - trace = UnzipTrace(master, jax_core.cur_sublevel()) - # Setting up input UnzipTracer objects - in_tracers = safe_map(lambda a: trace.new_arg(a[0], a[1]), zip(pvals, keys)) - key_tracers = [t for t in in_tracers if t.key] - abstract_tracers = [t for t in in_tracers if not t.key] - # Passing input tracers into function - # to get output tracers - context = UnzipContext(settings) - with trace_util.new_dynamic_context(master, context): - ans = yield in_tracers, {} - out_tracers = safe_map(trace.full_raise, safe_map(jax_core.full_lower, ans)) - out_pvals = [t.pval for t in out_tracers] - - all_tracers = jax_util.toposort(out_tracers) - variable_tracers = [t for t in all_tracers if t.variable_recipe] - if not settings.block: - try: - # This try/catch tests whether or not the variables define a cut of the - # computation graph. `pe.tracers_to_jaxpr` throws an AssertionError - # if that is the case. - old_recipes = [t.recipe for t in variable_tracers] - for t in variable_tracers: - t.recipe = pe.LambdaBinding() - _tracers_to_jaxpr(variable_tracers + abstract_tracers, out_tracers) - except VariableError: - success = False - else: - success = True - finally: - # Restore the old recipes if it fails - for t, old_recipe in safe_zip(variable_tracers, old_recipes): # pytype: disable=name-error # py39-upgrade - t.recipe = old_recipe - else: - success = False - if not success: - jaxpr, consts, env = _tracers_to_jaxpr(in_tracers, out_tracers) - out_keys = [t.is_key() for t in out_tracers] - yield success, (jaxpr, (out_pvals, out_keys, consts, env)) - return - - variable_recipes = {} - for t in all_tracers: - if t.variable_recipe: - name = t.variable_recipe.name - if (name in variable_recipes and - variable_recipes[name] is not t.variable_recipe): - raise ValueError('Cannot use duplicate variable name: {}'.format(name)) - variable_recipes[name] = t.variable_recipe - - variables = { - name: (recipe.in_tracers, recipe.out_tracers) - for name, recipe in variable_recipes.items() - } - variable_names, variable_tracers = jax_util.unzip2(variables.items()) - var_in_tracers, var_out_tracers = jax_util.unzip2(variable_tracers) - flat_var_in_tracers, variable_tree = tree_util.tree_flatten(var_in_tracers) - var_pvals = [t.pval for t in flat_var_in_tracers] - flat_var_out_tracers, _ = tree_util.tree_flatten(var_out_tracers) - init_jaxpr, init_consts, init_env = _tracers_to_jaxpr(key_tracers, - flat_var_in_tracers) - for t in flat_var_out_tracers: - t.recipe = pe.LambdaBinding() - apply_jaxpr, apply_consts, apply_env = _tracers_to_jaxpr( - flat_var_out_tracers + abstract_tracers, out_tracers) - if None in variable_names: - raise ValueError('Must provide name for variable.') - out_keys = [t.is_key() for t in out_tracers] - yield success, ((init_jaxpr, init_consts, - init_env), (apply_jaxpr, apply_consts, apply_env), - (var_pvals, out_pvals), (variable_names, variable_tree, - out_keys)) - - -def flatten_args_into_keys(avals, key_args): - """Flattens avals and returns a list indicating which are keys.""" - flat_avals, in_tree = tree_util.tree_flatten(avals) - - def is_key_aval(i): - return lambda _: i in key_args - - flat_keys, _ = tree_util.tree_flatten([ - tree_util.tree_map(is_key_aval(i), aval) for i, aval in enumerate(avals) - ]) - return flat_avals, flat_keys, in_tree - - -def unzip(f, *, tag: str, key_args=0): - """Unzip function transformation.""" - if tag is None: - raise ValueError('Must provide sow tag to unzip.') - if key_args is None: - key_args = () - if isinstance(key_args, int): - key_args = (key_args,) - key_args = set(key_args) - - def wrapped(*args, **kwargs): - """Callable returned by unzip.""" - with jax_core.new_main(UnzipTrace) as master: - # Preparing args to be traced - fun = lu.wrap_init(f, kwargs) - avals = tree_util.tree_map(trace_util.get_shaped_aval, args) - flat_avals, flat_keys, in_tree = (flatten_args_into_keys(avals, key_args)) - flat_pvals = [pe.PartialVal.unknown(aval) for aval in flat_avals] - flat_fun, out_tree = api_util.flatten_fun_nokwargs(fun, in_tree) - - # Trace to jaxpr - settings = UnzipSettings(tag, False) - fun = unzip_to_init_apply_subjaxprs(flat_fun, master, settings) # pylint: disable=no-value-for-parameter - success, results = fun.call_wrapped(flat_keys, flat_pvals) - if not success: - raise ValueError('Variables do not cut dependence graph.') - init_out, apply_out, _, metadata = results - init_jaxpr, init_consts, init_env = init_out - assert not init_env - - apply_jaxpr, apply_consts, apply_env = apply_out - assert not apply_env - - names, variable_tree, _ = metadata - out_tree = out_tree() - - # Final functions - def init(*args): - flat_args, _ = tree_util.tree_flatten(args) - flat_params = jax_core.eval_jaxpr(init_jaxpr, init_consts, *flat_args) - flat_variables = tree_util.tree_unflatten(variable_tree, flat_params) - return {name: var for name, var in safe_zip(names, flat_variables)} - - def apply(params, *args): - flat_variables, _ = tree_util.tree_flatten( - [params[name] for name in names]) - flat_args, _ = tree_util.tree_flatten(args) - out = jax_core.eval_jaxpr(apply_jaxpr, apply_consts, - *(flat_variables + flat_args)) - return tree_util.tree_unflatten(out_tree, out) - - del master - return init, apply - - return wrapped - - -def _tracers_to_jaxpr(in_tracers, out_tracers): - """Constructs Jaxpr given tracers for inputs and outputs. - - Copied from jax.interpreters.partial_eval.tracers_to_jaxpr but modified to - raise an VariableError when unknown in_tracers are found, rather than the - default AssertionError. - - Args: - in_tracers: the tracers that were created for the function inputs - out_tracers: the tracers that were output by the function. - - Returns: - a triple of a `Jaxpr`, a list of constant values corresponding to - the `constvars` in the returned Jaxps, and a list of environment values. - The vars for the environment values have been pre-pended to the Jaxpr's - `invars`. - - Raises: - VariableError: if an unknown input tracer is found - """ - newvar = jax_core.gensym(None) - t_to_var = {} - - def getvar(t): - var = t_to_var.get(id(t)) - if var is None: - var = newvar(t.pval.get_aval()) - t_to_var[id(t)] = var - return var - - sorted_tracers = jax_util.toposort(out_tracers) - invars = safe_map(getvar, in_tracers) - eqns = [] - env = {} - consts = {} - const_to_var = {} - - def getconstvar(c): - var = const_to_var.get(id(c)) - if var is None: - var = newvar(jax_core.get_aval(c)) - const_to_var[id(c)] = var - return var - - processed_eqn_ids = set() - effects = set() - for t in sorted_tracers: - recipe = t.recipe - if isinstance(recipe, pe.JaxprEqnRecipe): - if recipe.eqn_id not in processed_eqn_ids: - eqns.append(pe.recipe_to_eqn(getvar, recipe)) - processed_eqn_ids.add(recipe.eqn_id) - effects.update(recipe.effects) - elif isinstance(recipe, pe.LambdaBinding): - if not any(t is in_tracer for in_tracer in in_tracers): - raise VariableError(f'Found unknown input tracer: {t}') - assert in_tracers, 'Lambda binding with no args' - elif isinstance(recipe, pe.FreeVar): - env[getvar(t)] = recipe.val - elif isinstance(recipe, pe.ConstVar): - v = t_to_var[id(t)] = getconstvar(recipe.val) - consts[v] = recipe.val - elif isinstance(recipe, jax_core.Literal): - t_to_var[id(t)] = recipe - elif recipe is jax_core.unit: - t_to_var[id(t)] = jax_core.unitvar - else: - raise TypeError(recipe) - - env_vars, env_vals = jax_util.unzip2(env.items()) - const_vars, const_vals = jax_util.unzip2(consts.items()) - # The env_vars are pre-pended to the invars - jaxpr = jax_core.Jaxpr(const_vars, list(it.chain(env_vars, invars)), - safe_map(getvar, out_tracers), eqns, effects) - return jaxpr, const_vals, env_vals - - -def sow_unzip(in_tracers, out_tracers, name=None, tree=None, tag=None, **_): - del tag - if tree: - in_tracers = tree_util.tree_unflatten(tree, in_tracers) - out_tracers = tree_util.tree_unflatten(tree, out_tracers) - return name, in_tracers, out_tracers - - -unzip_registry[harvest.sow_p] = sow_unzip - - -def _custom_jvp_call_unzip(trace, fun, *tracers, **params): - del trace - return custom_jvp_call_jaxpr(fun, params['jvp'], *tracers) - - -custom_rules[cd.custom_jvp_call_p] = _custom_jvp_call_unzip - - -def _custom_vjp_call_unzip(trace, fun, *tracers, **params): - del trace - return custom_vjp_call_jaxpr(fun, params['fwd'], params['bwd'], *tracers, - **params) - - -custom_rules[cd.custom_vjp_call_p] = _custom_vjp_call_unzip - - -def custom_jvp_call_jaxpr(fun, jvp, *args): - """A convenience wrapper to apply the custom_jvp_call_jaxpr primitive.""" - in_avals = [ - abstract_arrays.raise_to_shaped(jax_core.get_aval(x)) for x in args - ] - fun_jaxpr, consts = cd._initial_style_jaxpr( # pylint: disable=protected-access - fun, in_avals) # consts can be tracers! - closed_fun_jaxpr = jax_core.ClosedJaxpr( - pe.convert_constvars_jaxpr(fun_jaxpr), ()) - jvp_jaxpr_thunk = pe._memoize( # pylint: disable=protected-access - lambda: cd._initial_style_jaxpr(jvp, in_avals * 2)) # pylint: disable=protected-access - return cd.custom_jvp_call_jaxpr_p.bind( - *consts, - *args, - fun_jaxpr=closed_fun_jaxpr, - jvp_jaxpr_thunk=jvp_jaxpr_thunk, - num_consts=len(consts)) - - -def custom_vjp_call_jaxpr(fun, fwd, bwd, *args, out_trees): - in_avals = [ - abstract_arrays.raise_to_shaped(jax_core.get_aval(x)) for x in args - ] - fun_jaxpr, consts = cd._initial_style_jaxpr( # pylint: disable=protected-access - fun, in_avals) # consts can be tracers! - closed_fun_jaxpr = jax_core.ClosedJaxpr( - pe.convert_constvars_jaxpr(fun_jaxpr), ()) - fwd_jaxpr_thunk = pe._memoize(lambda: cd._initial_style_jaxpr(fwd, in_avals)) # pylint: disable=protected-access - return cd.custom_vjp_call_jaxpr_p.bind( - *consts, - *args, - fun_jaxpr=closed_fun_jaxpr, - fwd_jaxpr_thunk=fwd_jaxpr_thunk, - bwd=bwd, - out_trees=out_trees, - num_consts=len(consts)) diff --git a/spinoffs/oryx/oryx/core/interpreters/unzip_test.py b/spinoffs/oryx/oryx/core/interpreters/unzip_test.py deleted file mode 100644 index b48dbe41e7..0000000000 --- a/spinoffs/oryx/oryx/core/interpreters/unzip_test.py +++ /dev/null @@ -1,353 +0,0 @@ -# Copyright 2020 The TensorFlow Probability Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# ============================================================================ -"""Tests for tensorflow_probability.spinoffs.oryx.core.interpreters.unzip.""" - -import functools -import os - -from absl.testing import absltest -import jax -from jax import core as jax_core -from jax import linear_util as lu -import jax.numpy as np -import numpy as onp - -from oryx.core import state -from oryx.core import trace_util -from oryx.core.interpreters import harvest -from oryx.core.interpreters import unzip -from oryx.internal import test_util - -variable = state.variable -unzip_variable = functools.partial(unzip.unzip, tag=state.VARIABLE) - - -def call_impl(f, *args, **params): - del params - with jax_core.new_sublevel(): - return f.call_wrapped(*args) -call_p = jax_core.CallPrimitive('call') -call_bind = call_p.bind -call_p.def_impl(call_impl) - - -def call(f): - def wrapped(*args, **kwargs): - fun = lu.wrap_init(f, kwargs) - flat_args, in_tree = jax.tree_flatten(args) - flat_fun, out_tree = jax.flatten_fun_nokwargs(fun, in_tree) - ans = call_p.bind(flat_fun, *flat_args) - return jax.tree_unflatten(out_tree(), ans) - return wrapped - - -def empty(): - return - - -def single(x): - return x - - -def single_variable(x): - y = variable(x, name='x') - return y - - -def single_variable_plus_one(x): - y = variable(x + 1, name='x') - return y + 1 - - -def two_variable_0(x, y): - z = variable(x + 1, name='x') - return y + z - - -def two_variable_1(x, y): - z = variable(y + 1, name='x') - return x + z - - -def two_variable(x, y): - return variable(x, name='x') + variable(y, name='y') - - -def pytree(x, y): - params = variable({'a': x, 'b': x + 1}, name='ab') - return params['a'] + params['b'] + y - - -class UnzipTest(test_util.TestCase): - - def test_empty(self): - init, apply = unzip_variable(empty)() - self.assertDictEqual(init(), {}) - self.assertIsNone(apply(init())) - - def test_single(self): - with self.assertRaisesRegex( - ValueError, 'Variables do not cut dependence graph.'): - unzip_variable(single)(np.ones(5)) - - init, apply = unzip_variable(single, key_args=None)(np.ones(5)) - self.assertDictEqual(init(), {}) - onp.testing.assert_allclose(apply(init(), np.ones(5)), np.ones(5)) - - def test_single_variable(self): - init, apply = unzip_variable(single_variable, key_args=None)(np.ones(5)) - self.assertDictEqual(init(), {}) - onp.testing.assert_allclose(apply(init(), np.ones(5)), np.ones(5)) - - init, apply = unzip_variable(single_variable)(np.ones(5)) - params = init(np.ones(5)) - truth = {'x': np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(apply(params), np.ones(5)) - - def test_single_variable_plus_one(self): - init, apply = unzip_variable( - single_variable_plus_one, key_args=None)( - np.ones(5)) - self.assertDictEqual(init(), {}) - onp.testing.assert_allclose(apply(init(), np.ones(5)), 3 * np.ones(5)) - - init, apply = unzip_variable(single_variable_plus_one)(np.ones(5)) - params = init(np.ones(5)) - truth = {'x': 2 * np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(apply(params), 3 * np.ones(5)) - - def test_two_variable_0(self): - init, apply = unzip_variable(two_variable_0)(np.ones(5), np.ones(5)) - params = init(np.ones(5)) - truth = {'x': 2 * np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(apply(params, np.ones(5)), 3 * np.ones(5)) - - with self.assertRaisesRegex( - ValueError, 'Variables do not cut dependence graph.'): - unzip_variable(two_variable_0, key_args=1)(np.ones(5), np.ones(5)) - - def test_two_variable_1(self): - with self.assertRaisesRegex( - ValueError, 'Variables do not cut dependence graph.'): - unzip_variable(two_variable_1)(np.ones(5), np.ones(5)) - - init, apply = unzip_variable( - two_variable_1, key_args=1)(np.ones(5), np.ones(5)) - params = init(np.ones(5)) - truth = {'x': 2 * np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(apply(params, np.ones(5)), 3 * np.ones(5)) - - def test_two_variable(self): - init, apply = unzip_variable( - two_variable, key_args=0)(np.ones(5), np.ones(5)) - params = init(np.ones(5)) - truth = {'x': np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(apply(params, np.ones(5)), 2 * np.ones(5)) - - init, apply = unzip_variable( - two_variable, key_args=1)(np.ones(5), np.ones(5)) - params = init(np.ones(5)) - truth = {'y': np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(apply(params, np.ones(5)), 2 * np.ones(5)) - - def test_nested_two_variable(self): - init, apply = unzip_variable(two_variable)(np.ones(5), np.ones(5)) - bound = functools.partial(apply, init(np.ones(5))) - bound_init, bound_apply = unzip_variable(bound)(np.ones(5)) - - params = bound_init(np.ones(5)) - truth = {'y': np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(bound_apply(params), 2 * np.ones(5)) - - init, apply = unzip_variable( - two_variable, key_args=1)(np.ones(5), np.ones(5)) - bound = functools.partial(apply, init(np.ones(5))) - bound_init, bound_apply = unzip_variable(bound)(np.ones(5)) - - params = bound_init(np.ones(5)) - truth = {'x': np.ones(5)} - self.assertLen(params, len(truth)) - for name in truth: - onp.testing.assert_allclose(params[name], truth[name]) - onp.testing.assert_allclose(bound_apply(params), 2 * np.ones(5)) - - def test_pytree(self): - init, apply = unzip_variable(pytree)(np.ones(5), np.ones(5)) - params = init(np.ones(5)) - onp.testing.assert_allclose(params['ab']['a'], np.ones(5)) - onp.testing.assert_allclose(params['ab']['b'], 2 * np.ones(5)) - onp.testing.assert_allclose(apply(params, np.ones(5)), 4 * np.ones(5)) - - def test_should_error_if_no_name_provided(self): - def no_name(x): - return variable(x, name=None) - - with self.assertRaisesRegex(ValueError, 'Must provide name for variable.'): - unzip_variable(no_name)(np.ones(5)) - - def test_should_error_if_duplicate_names(self): - def duplicate_names(x): - y1 = variable(x, name='y') - y2 = variable(x + 1., name='y') - return y1 + y2 - with self.assertRaisesRegex( - ValueError, 'Cannot use duplicate variable name: y'): - unzip_variable(duplicate_names)(np.ones(5)) - - def test_should_unzip_function_with_jit_successfully(self): - def function_with_jit(x): - x = jax.jit(lambda x: x)(x) - x = variable(x, name='x') - return x - - init, apply = unzip_variable(function_with_jit)(1.) - self.assertEqual(apply(init(1.)), 1.) - - def test_should_unzip_variables_inside_jit(self): - def nested_jit(x): - @jax.jit - def bar(y): - return variable(y, name='bar') - - init, _ = unzip_variable(bar)(x + 1.) - return variable(init(x + 1.), name='foo') - self.assertDictEqual(nested_jit(1.), {'bar': 2.}) - init = unzip_variable(nested_jit)(1.)[0] - self.assertDictEqual(init(1.), {'foo': {'bar': 2.}}) - - def test_should_not_inline_calls_without_variables(self): - def inline_call(x): - x = call(lambda x: x + 1)(x) - x = variable(x, name='x') - return call(lambda x: x + 1)(x) - - init, apply = unzip_variable(inline_call)(1.) - self.assertDictEqual(init(1.), {'x': 2.}) - init_jaxpr = trace_util.stage(init)(1.)[0] - self.assertIn(call_p, {eqn.primitive for eqn in init_jaxpr.jaxpr.eqns}) - apply_jaxpr = trace_util.stage(apply)(init(1.))[0] - self.assertIn(call_p, {eqn.primitive for eqn in apply_jaxpr.jaxpr.eqns}) - - def test_unzip_tracers_should_pass_through_call_after_variable(self): - def inline_call(x): - x = call(lambda x: variable(x, name='x'))(x) - return call(lambda x: x + 1)(x) - - init, apply = unzip_variable(inline_call)(1.) - self.assertDictEqual(init(1.), {'x': 1.}) - self.assertEqual(apply(init(1.)), 2.) - - def test_should_lift_tracers_from_closed_variables(self): - def closure(x): - @call - def inner(y): - return variable(y + x, name='y') - return inner(x) - - init, apply = unzip_variable(closure)(1.) - self.assertDictEqual(init(1.), {'y': 2.}) - self.assertEqual(apply(init(1.)), 2.) - - def test_should_variable_jitted_function_successfully(self): - - @jax.jit - def jitted(x): - return variable(x + 1., name='x') - - init, apply = unzip_variable(jitted)(1.) - self.assertDictEqual(init(1.), {'x': 2.}) - self.assertEqual(apply(init(1.)), 2.) - - def test_should_unzip_nested_jits_successfully(self): - @jax.jit - def jitted(x): - return variable(jax.jit(lambda x: x)(x + 1.), name='x') - - init, apply = unzip_variable(jitted)(1.) - self.assertDictEqual(init(1.), {'x': 2.}) - self.assertEqual(apply(init(1.)), 2.) - - def test_unzip_should_nest_and_unzip_jitted_functions(self): - @jax.jit - def nested(x): - def foo(x): - return variable(x + 1., name='x') - - init, _ = unzip_variable(foo)(x) - result = init(x) - - @jax.jit - def bar(x, result): - return variable(result['x'], name='x') + variable(x + 1., name='x2') - - init, _ = unzip_variable(bar)(x, result) - r = variable(init(x), name='r') - return r - self.assertDictEqual(nested(1.), {'x2': 2.}) - init, apply = unzip_variable(nested)(1.) - self.assertDictEqual(init(1.), {'r': {'x2': 2}}) - self.assertEqual(apply(init(1.)), {'x2': 2.}) - - def test_should_unzip_pmap(self): - @jax.pmap - def f(x): - x = variable(x, name='x') - return x - onp.testing.assert_allclose(f(np.ones(2)), np.ones(2)) - init, apply = unzip_variable(f)(np.ones(2)) - onp.testing.assert_allclose(init(np.ones(2))['x'], np.ones(2)) - onp.testing.assert_allclose(apply(init(np.ones(2))), np.ones(2)) - - def test_unzip_of_nest_should_nest_variables(self): - def f(x): - x = variable(x, name='x') - return x - init, apply = unzip_variable(harvest.nest(f, scope='f'))(1.) - self.assertDictEqual(init(1.), {'f': {'x': 1}}) - self.assertEqual(apply({'f': {'x': 2.}}), 2.) - - def g(x): - y = harvest.nest(f, scope='f1')(x + 1.) - z = harvest.nest(f, scope='f2')(y + 1.) - return z - init, apply = unzip_variable(g)(1.) - self.assertDictEqual(init(1.), {'f1': {'x': 2}, 'f2': {'x': 3.}}) - self.assertEqual(apply({'f1': {'x': 4.}, 'f2': {'x': 100.}}), 100.) - - -if __name__ == '__main__': - os.environ['XLA_FLAGS'] = '--xla_force_host_platform_device_count=2' - absltest.main() diff --git a/spinoffs/oryx/oryx/core/state/BUILD b/spinoffs/oryx/oryx/core/state/BUILD index e6471ec482..1b0d9f3544 100644 --- a/spinoffs/oryx/oryx/core/state/BUILD +++ b/spinoffs/oryx/oryx/core/state/BUILD @@ -52,7 +52,6 @@ py_library( "//oryx/core:kwargs_util", "//oryx/core:trace_util", "//oryx/core/interpreters:harvest", - "//oryx/core/interpreters:unzip", "//oryx/core/interpreters/inverse:custom_inverse", ], ) diff --git a/spinoffs/oryx/oryx/core/state/__init__.py b/spinoffs/oryx/oryx/core/state/__init__.py index a18f18b4d7..2fc39451cc 100644 --- a/spinoffs/oryx/oryx/core/state/__init__.py +++ b/spinoffs/oryx/oryx/core/state/__init__.py @@ -22,7 +22,6 @@ from oryx.core.state.api import Shape from oryx.core.state.api import spec from oryx.core.state.api import update -from oryx.core.state.function import custom_unzip_rules from oryx.core.state.function import kwargs_rules from oryx.core.state.module import assign from oryx.core.state.module import ASSIGN diff --git a/spinoffs/oryx/oryx/core/state/function.py b/spinoffs/oryx/oryx/core/state/function.py index 6206d87422..4f863dfa17 100644 --- a/spinoffs/oryx/oryx/core/state/function.py +++ b/spinoffs/oryx/oryx/core/state/function.py @@ -60,7 +60,6 @@ safe_zip = jax_util.safe_zip Key = Any -custom_unzip_rules = {} kwargs_rules = {} diff --git a/spinoffs/oryx/oryx/distributions/BUILD b/spinoffs/oryx/oryx/distributions/BUILD index a626830695..6198dae8c3 100644 --- a/spinoffs/oryx/oryx/distributions/BUILD +++ b/spinoffs/oryx/oryx/distributions/BUILD @@ -39,7 +39,6 @@ py_library( "//oryx/core:trace_util", "//oryx/core/interpreters:harvest", "//oryx/core/interpreters:log_prob", - "//oryx/core/interpreters:unzip", "//oryx/core/interpreters/inverse", "//oryx/core/ppl", # tensorflow_probability/substrates:jax dep, diff --git a/spinoffs/oryx/oryx/distributions/distribution_extensions.py b/spinoffs/oryx/oryx/distributions/distribution_extensions.py index 082863d43c..fc4860732a 100644 --- a/spinoffs/oryx/oryx/distributions/distribution_extensions.py +++ b/spinoffs/oryx/oryx/distributions/distribution_extensions.py @@ -27,7 +27,6 @@ from oryx.core.interpreters import harvest from oryx.core.interpreters import inverse from oryx.core.interpreters import log_prob -from oryx.core.interpreters import unzip from tensorflow_probability.substrates import jax as tfp tfd = tfp.distributions @@ -36,7 +35,6 @@ InverseAndILDJ = inverse.core.InverseAndILDJ random_variable_p = primitive.InitialStylePrimitive('random_variable') -unzip.block_registry.add(random_variable_p) def random_variable_log_prob_rule(flat_incells, flat_outcells, *, num_consts, diff --git a/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py b/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py index bb2c7c7b1e..bd5d62109e 100644 --- a/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py +++ b/spinoffs/oryx/oryx/distributions/distribution_extensions_test.py @@ -121,19 +121,6 @@ def sample(key): p.log_prob(sample(random.PRNGKey(0))), ppl.log_prob(sample)(sample(random.PRNGKey(0)))) - @parameterized.named_parameters(DISTRIBUTIONS) - def test_unzip_transformation(self, dist, args, kwargs, out, flat): - del out, flat - args = args() - kwargs = kwargs() - p = dist(*args, **kwargs) - - def model(key): - return ppl.random_variable(p, name='x')(key) - - init = core.unzip(model, tag=ppl.RANDOM_VARIABLE)(random.PRNGKey(0))[0] - self.assertLen(init(random.PRNGKey(0)), 1) - def test_joint_distribution(self): def model(key): diff --git a/spinoffs/oryx/oryx/experimental/nn/BUILD b/spinoffs/oryx/oryx/experimental/nn/BUILD index a78f6a7713..12120891f8 100644 --- a/spinoffs/oryx/oryx/experimental/nn/BUILD +++ b/spinoffs/oryx/oryx/experimental/nn/BUILD @@ -57,7 +57,6 @@ py_library( # jax:stax dep, "//oryx/core:kwargs_util", "//oryx/core:primitive", - "//oryx/core/interpreters:unzip", "//oryx/core/interpreters/inverse:core", "//oryx/core/state", ], From aa9ba145dc6bec775eed12bd1314e099f34dbf1b Mon Sep 17 00:00:00 2001 From: kloveless Date: Tue, 3 May 2022 08:36:56 -0700 Subject: [PATCH 117/153] Add support for zero step prediction, that uses the local-level of the timestep rather than previous local level + local linear trend. PiperOrigin-RevId: 446201376 --- .../experimental/sts_gibbs/gibbs_sampler.py | 23 +++++++++++-------- .../sts_gibbs/gibbs_sampler_test.py | 20 ++++++++++++---- 2 files changed, 30 insertions(+), 13 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index e0f46c9396..4e59e68b04 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -430,7 +430,8 @@ def one_step_predictive(model, num_forecast_steps=0, original_mean=0., original_scale=1., - thin_every=10): + thin_every=10, + use_zero_step_prediction=False): """Constructs a one-step-ahead predictive distribution at every timestep. Unlike the generic `tfp.sts.one_step_predictive`, this method uses the @@ -465,6 +466,9 @@ def one_step_predictive(model, samples, to reduce complexity of the predictive distribution. For example, if `thin_every=10`, every `10`th sample will be used. Default value: `10`. + use_zero_step_prediction: If true, instead of using the local level + and trend from the timestep before, just use the local level from the + same timestep. Returns: predictive_dist: A `tfd.MixtureSameFamily` instance of event shape @@ -489,11 +493,11 @@ def one_step_predictive(model, slope=tf.zeros_like(thinned_samples.level), slope_scale=tf.zeros_like(thinned_samples.level_scale)) - num_steps_from_last_observation = tf.concat([ - tf.ones([num_observed_steps], dtype=dtype), - tf.range(1, num_forecast_steps + 1, dtype=dtype) - ], - axis=0) + num_steps_from_last_observation = tf.concat( + [(tf.zeros([num_observed_steps], dtype=dtype) if use_zero_step_prediction + else tf.ones([num_observed_steps], dtype=dtype)), + tf.range(1, num_forecast_steps + 1, dtype=dtype)], + axis=0) # The local linear trend model expects that the level at step t + 1 is equal # to the level at step t, plus the slope at time t - 1, @@ -514,11 +518,12 @@ def one_step_predictive(model, tf.range(1., num_forecast_steps + 1., dtype=forecast_level.dtype)) level_pred = tf.concat( - [ + ([thinned_samples.level] if use_zero_step_prediction else [ thinned_samples.level[..., :1], # t == 0 (thinned_samples.level[..., :-1] + thinned_samples.slope[..., :-1] - ) # 1 <= t < T - ] + ([forecast_level] if num_forecast_steps > 0 else []), + ) # 1 <= t < T. Constructs the next level from previous level + # and previous slope. + ]) + ([forecast_level] if num_forecast_steps > 0 else []), axis=-1) design_matrix = _get_design_matrix(model) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index 80328a7281..20be087719 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -139,6 +139,12 @@ def _build_test_model(self, 'use_slope': False, 'num_chains': (), 'time_series_shift': 0. + }, { + 'testcase_name': 'LocalLevel_ZeroStepPrediction', + 'use_slope': False, + 'num_chains': (), + 'time_series_shift': 0., + 'use_zero_step_prediction': True, }, { 'testcase_name': 'LocalLevel_4chains', 'use_slope': False, @@ -155,8 +161,11 @@ def _build_test_model(self, 'num_chains': (), 'time_series_shift': 100. }) - def test_forecasts_match_reference( - self, use_slope, num_chains, time_series_shift): + def test_forecasts_match_reference(self, + use_slope, + num_chains, + time_series_shift, + use_zero_step_prediction=False): seed = test_util.test_seed() num_observed_steps = 5 num_forecast_steps = 4 @@ -196,8 +205,11 @@ def reshape_chain_and_sample(x): samples = tf.nest.map_structure(reshape_chain_and_sample, samples) predictive_dist = gibbs_sampler.one_step_predictive( - model, samples, num_forecast_steps=num_forecast_steps, - thin_every=1) + model, + samples, + num_forecast_steps=num_forecast_steps, + thin_every=1, + use_zero_step_prediction=use_zero_step_prediction) predictive_mean, predictive_stddev = self.evaluate(( predictive_dist.mean(), predictive_dist.stddev())) self.assertAllEqual(predictive_mean.shape, From dba70016efe5822155990b7dbd3042bfedb78c68 Mon Sep 17 00:00:00 2001 From: siege Date: Tue, 3 May 2022 10:28:50 -0700 Subject: [PATCH 118/153] Interpet num_or_size_splits in tfb.Splits a shape tensor. PiperOrigin-RevId: 446228180 --- tensorflow_probability/python/bijectors/split.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/bijectors/split.py b/tensorflow_probability/python/bijectors/split.py index 16ff526ebd..6943036ce0 100644 --- a/tensorflow_probability/python/bijectors/split.py +++ b/tensorflow_probability/python/bijectors/split.py @@ -79,7 +79,10 @@ def __init__( self._split_sizes = None else: self._split_sizes = tensor_util.convert_nonref_to_tensor( - num_or_size_splits, name='num_or_size_splits', dtype=tf.int32) + num_or_size_splits, + name='num_or_size_splits', + dtype=tf.int32, + as_shape_tensor=True) if tensorshape_util.rank(self._split_sizes.shape) != 1: raise ValueError( From e06d48185f66514667384e11a5195ba69956c667 Mon Sep 17 00:00:00 2001 From: siege Date: Tue, 3 May 2022 14:03:22 -0700 Subject: [PATCH 119/153] Increase timeout for kendalls_tau_test. PiperOrigin-RevId: 446283825 --- tensorflow_probability/python/stats/BUILD | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorflow_probability/python/stats/BUILD b/tensorflow_probability/python/stats/BUILD index a6d59396aa..44c3a4d2a1 100644 --- a/tensorflow_probability/python/stats/BUILD +++ b/tensorflow_probability/python/stats/BUILD @@ -223,6 +223,7 @@ multi_substrate_py_library( multi_substrate_py_test( name = "kendalls_tau_test", + size = "medium", srcs = ["kendalls_tau_test.py"], jax_tags = ["notap"], deps = [ From b31b0f7ae76241eb6fe1e3349d732a3250ac6b2b Mon Sep 17 00:00:00 2001 From: scottzhu Date: Wed, 4 May 2022 00:17:49 -0700 Subject: [PATCH 120/153] Prepare for upcoming keras initializer change. PiperOrigin-RevId: 446382946 --- tensorflow_probability/python/bijectors/glow.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/tensorflow_probability/python/bijectors/glow.py b/tensorflow_probability/python/bijectors/glow.py index c3d22ed676..a2b4d9727e 100644 --- a/tensorflow_probability/python/bijectors/glow.py +++ b/tensorflow_probability/python/bijectors/glow.py @@ -856,11 +856,6 @@ def __init__(self, input_shape, num_hidden=400, kernel_shape=3): """Default network for glow bijector.""" # Default is scale and shift, so 2c outputs. this_nchan = input_shape[-1] * 2 - conv = functools.partial( - tfkl.Conv2D, - padding='same', - kernel_initializer=tf.initializers.he_normal(), - activation='relu') conv_last = functools.partial( tfkl.Conv2D, padding='same', @@ -868,8 +863,12 @@ def __init__(self, input_shape, num_hidden=400, kernel_shape=3): bias_initializer=tf.initializers.zeros()) super(GlowDefaultNetwork, self).__init__([ tfkl.Input(shape=input_shape), - conv(num_hidden, kernel_shape), - conv(num_hidden, 1), + tfkl.Conv2D(num_hidden, kernel_shape, padding='same', + kernel_initializer=tf.initializers.he_normal(), + activation='relu'), + tfkl.Conv2D(num_hidden, 1, padding='same', + kernel_initializer=tf.initializers.he_normal(), + activation='relu'), conv_last(this_nchan, kernel_shape) ]) From feb28a20ad899d520b8ad3b6e60b55b7760d7002 Mon Sep 17 00:00:00 2001 From: sharadmv Date: Wed, 4 May 2022 10:51:17 -0700 Subject: [PATCH 121/153] [Oryx] Move `extract_call_jaxpr` to `trace_util` and remove usage of `unit`. PiperOrigin-RevId: 446498421 --- spinoffs/oryx/oryx/core/interpreters/BUILD | 1 + spinoffs/oryx/oryx/core/interpreters/inverse/core.py | 4 ---- spinoffs/oryx/oryx/core/interpreters/propagate.py | 4 +++- spinoffs/oryx/oryx/core/ppl/effect_handler.py | 5 +++-- spinoffs/oryx/oryx/core/state/function.py | 3 +-- spinoffs/oryx/oryx/core/trace_util.py | 12 ++++++++++-- .../oryx/oryx/experimental/matching/jax_rewrite.py | 3 ++- 7 files changed, 20 insertions(+), 12 deletions(-) diff --git a/spinoffs/oryx/oryx/core/interpreters/BUILD b/spinoffs/oryx/oryx/core/interpreters/BUILD index 1f69f230bf..e402009815 100644 --- a/spinoffs/oryx/oryx/core/interpreters/BUILD +++ b/spinoffs/oryx/oryx/core/interpreters/BUILD @@ -39,6 +39,7 @@ py_library( ":harvest", # jax dep, "//oryx/core:pytree", + "//oryx/core:trace_util", ], ) diff --git a/spinoffs/oryx/oryx/core/interpreters/inverse/core.py b/spinoffs/oryx/oryx/core/interpreters/inverse/core.py index edbc67ec40..04d1a1479a 100644 --- a/spinoffs/oryx/oryx/core/interpreters/inverse/core.py +++ b/spinoffs/oryx/oryx/core/interpreters/inverse/core.py @@ -75,8 +75,6 @@ def top(self) -> bool: """ if len(self.slices) != 1: return False - if self.aval == jax_core.abstract_unit: - return True return list(self.slices)[0].value.shape == self.aval.shape def bottom(self) -> bool: @@ -142,8 +140,6 @@ def unknown(cls, aval): @classmethod def new(cls, val): - if val is jax_core.unit: - return InverseAndILDJ.unknown(jax_core.abstract_unit) val = np.array(val) aval = jax_core.get_aval(val) aval = abstract_arrays.raise_to_shaped(aval) diff --git a/spinoffs/oryx/oryx/core/interpreters/propagate.py b/spinoffs/oryx/oryx/core/interpreters/propagate.py index 295965a8b1..a41b58fd83 100644 --- a/spinoffs/oryx/oryx/core/interpreters/propagate.py +++ b/spinoffs/oryx/oryx/core/interpreters/propagate.py @@ -38,6 +38,7 @@ from jax.interpreters import xla from oryx.core import pytree +from oryx.core import trace_util from oryx.core.interpreters import harvest __all__ = [ @@ -281,7 +282,8 @@ def propagate(cell_type: Type[Cell], incells = safe_map(env.read, eqn.invars) outcells = safe_map(env.read, eqn.outvars) - call_jaxpr, params = jax_core.extract_call_jaxpr(eqn.primitive, eqn.params) + call_jaxpr, params = trace_util.extract_call_jaxpr( + eqn.primitive, eqn.params) if call_jaxpr: subfuns = [ lu.wrap_init( diff --git a/spinoffs/oryx/oryx/core/ppl/effect_handler.py b/spinoffs/oryx/oryx/core/ppl/effect_handler.py index dc4765c0ca..cbda82e640 100644 --- a/spinoffs/oryx/oryx/core/ppl/effect_handler.py +++ b/spinoffs/oryx/oryx/core/ppl/effect_handler.py @@ -140,7 +140,7 @@ class Environment: """ def __init__(self): - self.env = {jax_core.unitvar: jax_core.unit} + self.env = {} def read(self, var: VarOrLiteral) -> Value: """Reads a value from an environment.""" @@ -187,7 +187,8 @@ def eval_jaxpr_with_state(jaxpr: jax_core.Jaxpr, rules: Rules, for eqn in jaxpr.eqns: invals = jax_util.safe_map(env.read, eqn.invars) - call_jaxpr, params = jax_core.extract_call_jaxpr(eqn.primitive, eqn.params) + call_jaxpr, params = trace_util.extract_call_jaxpr( + eqn.primitive, eqn.params) if call_jaxpr: call_rule = _effect_handler_call_rules.get( eqn.primitive, diff --git a/spinoffs/oryx/oryx/core/state/function.py b/spinoffs/oryx/oryx/core/state/function.py index 4f863dfa17..15a34d2141 100644 --- a/spinoffs/oryx/oryx/core/state/function.py +++ b/spinoffs/oryx/oryx/core/state/function.py @@ -110,12 +110,11 @@ def write(v, val): env[v] = val env = {} - write(jax_core.unitvar, jax_core.unit) safe_map(write, jaxpr.constvars, consts) safe_map(write, jaxpr.invars, args) for eqn in jaxpr.eqns: in_vals = safe_map(read, eqn.invars) - subjaxpr, params = jax_core.extract_call_jaxpr(eqn.primitive, eqn.params) + subjaxpr, params = trace_util.extract_call_jaxpr(eqn.primitive, eqn.params) if subjaxpr: subfuns = [ lu.wrap_init( diff --git a/spinoffs/oryx/oryx/core/trace_util.py b/spinoffs/oryx/oryx/core/trace_util.py index 73b9e81e8d..1314e84b13 100644 --- a/spinoffs/oryx/oryx/core/trace_util.py +++ b/spinoffs/oryx/oryx/core/trace_util.py @@ -50,7 +50,7 @@ def get_shaped_aval(x): def pv_like(x, abstract=True): """Converts a JAX value type into a JAX `PartialVal`.""" if abstract: - return pe.PartialVal((get_shaped_aval(x), jax_core.unit)) + return pe.PartialVal.unknown(get_shaped_aval(x)) else: return pe.PartialVal((None, x)) # pytype: disable=wrong-arg-types @@ -70,7 +70,7 @@ def wrapped(*args, **kwargs): flat_fun, flat_avals) else: - pvals = [pe.PartialVal((aval, jax_core.unit)) for aval in flat_avals] + pvals = [pe.PartialVal.unknown(aval) for aval in flat_avals] jaxpr, _, consts = pe.trace_to_jaxpr( flat_fun, pvals, @@ -119,3 +119,11 @@ def get_dynamic_context(trace: jax_core.Trace) -> Any: if trace.main not in _thread_local_state.dynamic_contexts: raise ValueError(f'No dynamic context registered for trace: {trace}') return _thread_local_state.dynamic_contexts[trace.main][-1] + + +def extract_call_jaxpr(primitive, params): + if not (primitive.call_primitive or primitive.map_primitive): + return None, params + else: + params = dict(params) + return params.pop('call_jaxpr'), params diff --git a/spinoffs/oryx/oryx/experimental/matching/jax_rewrite.py b/spinoffs/oryx/oryx/experimental/matching/jax_rewrite.py index 0de07996c7..93d3afea00 100644 --- a/spinoffs/oryx/oryx/experimental/matching/jax_rewrite.py +++ b/spinoffs/oryx/oryx/experimental/matching/jax_rewrite.py @@ -736,7 +736,8 @@ def write_env(var: jax_core.Var, val: Any) -> None: for eqn in jaxpr.eqns: operands = tuple(jax_util.safe_map(read_env, eqn.invars)) - call_jaxpr, params = jax_core.extract_call_jaxpr(eqn.primitive, eqn.params) + call_jaxpr, params = trace_util.extract_call_jaxpr( + eqn.primitive, eqn.params) if call_jaxpr: call_expression = BoundExpression(jaxpr_to_expressions(call_jaxpr), {}) variable_names = tuple(map(str, call_jaxpr.invars)) From 2e4d4c181df8672e67b1a4a59d64d77acc264089 Mon Sep 17 00:00:00 2001 From: tagoma <23656943+tagomatech@users.noreply.github.com> Date: Thu, 5 May 2022 15:19:00 +0200 Subject: [PATCH 122/153] Update structural_time_series.py Updated joint distribution example following https://github.com/tensorflow/probability/issues/1558 --- tensorflow_probability/python/sts/structural_time_series.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/sts/structural_time_series.py b/tensorflow_probability/python/sts/structural_time_series.py index ac6165318e..89e125bc0e 100644 --- a/tensorflow_probability/python/sts/structural_time_series.py +++ b/tensorflow_probability/python/sts/structural_time_series.py @@ -319,8 +319,8 @@ def joint_distribution(self, import tensorflow_probability as tfp # Sample and plot 100 trajectories from the prior. - model = tfp.sts.LocalLinearTrendModel() - prior_samples = model.joint_distribution().sample([100]) + model = tfp.sts.LocalLinearTrend() + prior_samples = model.joint_distribution(num_timesteps=200).sample([100]) plt.plot( tf.linalg.matrix_transpose(prior_samples['observed_time_series'][..., 0])) ``` From 1960c2704e86561048427b34dae38d54ac6c7853 Mon Sep 17 00:00:00 2001 From: siege Date: Thu, 5 May 2022 11:40:46 -0700 Subject: [PATCH 123/153] Use approximate equality in dynamic_regression_test. It's been failing in OSS CI. PiperOrigin-RevId: 446774875 --- .../python/sts/components/dynamic_regression_test.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tensorflow_probability/python/sts/components/dynamic_regression_test.py b/tensorflow_probability/python/sts/components/dynamic_regression_test.py index 2684e65e14..3c6b16f542 100644 --- a/tensorflow_probability/python/sts/components/dynamic_regression_test.py +++ b/tensorflow_probability/python/sts/components/dynamic_regression_test.py @@ -51,9 +51,11 @@ def test_basic_statistics_no_latent_variance(self): predicted_time_series = tf.linalg.matmul( design_matrix, initial_state_loc[..., tf.newaxis]) - self.assertAllEqual(self.evaluate(ssm.mean()), predicted_time_series) - self.assertAllEqual(*self.evaluate((ssm.stddev(), - tf.zeros_like(predicted_time_series)))) + self.assertAllClose( + self.evaluate(ssm.mean()), predicted_time_series, atol=1e-5) + self.assertAllClose( + *self.evaluate((ssm.stddev(), tf.zeros_like(predicted_time_series))), + atol=1e-5) def test_initial_state_broadcasts_over_batch(self): batch_shape = [4, 3] From ab45fd99ccb9c1fa70fac0665de5190c4c2328cd Mon Sep 17 00:00:00 2001 From: kloveless Date: Fri, 6 May 2022 11:09:37 -0700 Subject: [PATCH 124/153] Dynamically choose the precision of DummySpikeAndSlabPrior, which allows SpikeAndSlabSparseLinearRegression to be used with types other than float64. PiperOrigin-RevId: 447027711 --- .../python/experimental/sts_gibbs/gibbs_sampler.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index 4e59e68b04..24f18a6ecc 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -109,9 +109,9 @@ def _sample_n(self, n, seed=None): class DummySpikeAndSlabPrior(tfd.Distribution): """Dummy prior on sparse regression weights.""" - def __init__(self): + def __init__(self, dtype=tf.float32): super().__init__( - dtype=tf.float32, + dtype=dtype, reparameterization_type=tfd.FULLY_REPARAMETERIZED, validate_args=False, allow_nan_stats=True, @@ -152,7 +152,8 @@ def __init__(self, self._sparse_weights_nonzero_prob = sparse_weights_nonzero_prob super().__init__( design_matrix=design_matrix, - weights_prior=DummySpikeAndSlabPrior(), + weights_prior=DummySpikeAndSlabPrior( + dtype=dtype_util.common_dtype([design_matrix])), name=name) From d7325346c637f457a6ed10c72ccadec337a401eb Mon Sep 17 00:00:00 2001 From: ltsaprounis Date: Sat, 7 May 2022 21:10:44 +0100 Subject: [PATCH 125/153] removed function import as per styleguide --- tensorflow_probability/python/distributions/empirical.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/distributions/empirical.py b/tensorflow_probability/python/distributions/empirical.py index 28de0d401b..294bd2454e 100644 --- a/tensorflow_probability/python/distributions/empirical.py +++ b/tensorflow_probability/python/distributions/empirical.py @@ -25,7 +25,7 @@ from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import tensor_util from tensorflow_probability.python.internal import tensorshape_util -from tensorflow_probability.python.stats import percentile +from tensorflow_probability.python import stats __all__ = [ 'Empirical' @@ -228,7 +228,7 @@ def _quantile(self, value, samples=None, **kwargs): if samples is None: samples = tf.convert_to_tensor(self._samples) - return percentile(x=samples, q=value * 100, axis=self._samples_axis, **kwargs) + return stats.percentile(x=samples, q=value * 100, axis=self._samples_axis, **kwargs) def _sample_n(self, n, seed=None): samples = tf.convert_to_tensor(self._samples) From a08bc82fcce44cd7e7396c05c90c977b0eb0ef01 Mon Sep 17 00:00:00 2001 From: ltsaprounis Date: Sat, 7 May 2022 21:11:41 +0100 Subject: [PATCH 126/153] remove values check, happens in base class --- tensorflow_probability/python/distributions/empirical.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/tensorflow_probability/python/distributions/empirical.py b/tensorflow_probability/python/distributions/empirical.py index 294bd2454e..bf0f90eaf1 100644 --- a/tensorflow_probability/python/distributions/empirical.py +++ b/tensorflow_probability/python/distributions/empirical.py @@ -219,12 +219,6 @@ def _stddev(self): return tf.sqrt(var) def _quantile(self, value, samples=None, **kwargs): - if value > 1 or value < 0: - raise ValueError( - "Quantile values in tensorflow_probability." - "distributions.Empirical.quantile must be between 0 and 1." - ) - if samples is None: samples = tf.convert_to_tensor(self._samples) From b56052f0c05f89ccb0fe5f6371686c347f72f39b Mon Sep 17 00:00:00 2001 From: ltsaprounis Date: Sat, 7 May 2022 21:13:59 +0100 Subject: [PATCH 127/153] remove test for ValueError --- .../python/distributions/empirical_test.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/tensorflow_probability/python/distributions/empirical_test.py b/tensorflow_probability/python/distributions/empirical_test.py index b94764ab00..dd848902a0 100644 --- a/tensorflow_probability/python/distributions/empirical_test.py +++ b/tensorflow_probability/python/distributions/empirical_test.py @@ -281,12 +281,6 @@ def test_empirical_quantiles(self): ) dist = tfd.Empirical(samples=input_ph, validate_args=True) self.assertAllClose(self.evaluate(dist.quantile(q)), q_val) - - invalid_value = 1.5 - with self.assertRaises(ValueError): - dist = tfd.Empirical( - samples=sample, validate_args=True - ).quantile(invalid_value) @test_util.test_all_tf_execution_regimes From 616d5eea0804ed40e46117601ce96e0e63459862 Mon Sep 17 00:00:00 2001 From: ltsaprounis Date: Sat, 7 May 2022 21:16:55 +0100 Subject: [PATCH 128/153] chenges to pass linting checks --- tensorflow_probability/python/distributions/empirical.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/distributions/empirical.py b/tensorflow_probability/python/distributions/empirical.py index bf0f90eaf1..ce7ee3818c 100644 --- a/tensorflow_probability/python/distributions/empirical.py +++ b/tensorflow_probability/python/distributions/empirical.py @@ -217,12 +217,14 @@ def _stddev(self): r = samples - tf.expand_dims(self._mean(samples), axis=axis) var = tf.reduce_mean(tf.square(r), axis=axis) return tf.sqrt(var) - + def _quantile(self, value, samples=None, **kwargs): if samples is None: samples = tf.convert_to_tensor(self._samples) - return stats.percentile(x=samples, q=value * 100, axis=self._samples_axis, **kwargs) + return stats.percentile( + x=samples, q=value * 100, axis=self._samples_axis, **kwargs + ) def _sample_n(self, n, seed=None): samples = tf.convert_to_tensor(self._samples) From c51f3c2e90cdb080db627fdda404b55891715b57 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Wed, 11 May 2022 08:07:26 -0700 Subject: [PATCH 129/153] Add a dynamic Cholesky option for the spike and slab sampler. This selects the submatrix from a design matrix of active weights, and computes the Cholesky only on that submatrix. In case the design matrix is large and the problem is sparse, this may save time on O(n^3) Cholesky updates. Due to introducing a dynamic shape into the computation, this does not work with xla compilation (and so JAX), or with batching (which would need a ragged array). PiperOrigin-RevId: 447996071 --- .../python/experimental/sts_gibbs/BUILD | 43 +- .../sts_gibbs/dynamic_spike_and_slab.py | 593 ++++++++++++++++++ .../sts_gibbs/dynamic_spike_and_slab_test.py | 343 ++++++++++ .../experimental/sts_gibbs/gibbs_sampler.py | 36 +- .../sts_gibbs/gibbs_sampler_test.py | 23 +- 5 files changed, 1028 insertions(+), 10 deletions(-) create mode 100644 tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py create mode 100644 tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py diff --git a/tensorflow_probability/python/experimental/sts_gibbs/BUILD b/tensorflow_probability/python/experimental/sts_gibbs/BUILD index 5e606c98fc..4449fb5796 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/BUILD +++ b/tensorflow_probability/python/experimental/sts_gibbs/BUILD @@ -33,6 +33,7 @@ multi_substrate_py_library( name = "sts_gibbs", srcs = ["__init__.py"], deps = [ + ":dynamic_spike_and_slab", ":gibbs_sampler", ":spike_and_slab", ], @@ -67,7 +68,7 @@ multi_substrate_py_library( multi_substrate_py_test( name = "gibbs_sampler_test", - size = "medium", + size = "large", srcs = ["gibbs_sampler_test.py"], disabled_substrates = ["numpy"], shard_count = 4, @@ -82,6 +83,46 @@ multi_substrate_py_test( ], ) +multi_substrate_py_library( + name = "dynamic_spike_and_slab", + srcs = ["dynamic_spike_and_slab.py"], + deps = [ + # numpy dep, + # tensorflow dep, + "//tensorflow_probability/python/bijectors:softplus", + "//tensorflow_probability/python/distributions:bernoulli", + "//tensorflow_probability/python/distributions:inverse_gamma", + "//tensorflow_probability/python/distributions:joint_distribution_auto_batched", + "//tensorflow_probability/python/distributions:sample", + "//tensorflow_probability/python/experimental/distributions:mvn_precision_factor_linop", + "//tensorflow_probability/python/internal:parameter_properties", + "//tensorflow_probability/python/internal:prefer_static", + "//tensorflow_probability/python/internal:samplers", + "//tensorflow_probability/python/internal:vectorization_util", + "//tensorflow_probability/python/math", + "//tensorflow_probability/python/mcmc/internal:util", + ], +) + +multi_substrate_py_test( + name = "dynamic_spike_and_slab_test", + size = "medium", + srcs = ["dynamic_spike_and_slab_test.py"], + disabled_substrates = [ + "numpy", + "jax", + ], + deps = [ + # absl/testing:parameterized dep, + # numpy dep, + # tensorflow dep, + "//tensorflow_probability", + "//tensorflow_probability/python/experimental/sts_gibbs", + "//tensorflow_probability/python/internal:test_util", +# "//third_party/tensorflow/compiler/jit:xla_cpu_jit", # DisableOnExport + ], +) + multi_substrate_py_library( name = "spike_and_slab", srcs = ["spike_and_slab.py"], diff --git a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py new file mode 100644 index 0000000000..94309faae9 --- /dev/null +++ b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py @@ -0,0 +1,593 @@ +# Copyright 2022 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Sampler for sparse regression with spike-and-slab prior.""" + +import collections + +import tensorflow.compat.v2 as tf + +from tensorflow_probability.python.bijectors import softplus as softplus_bijector +from tensorflow_probability.python.distributions import bernoulli +from tensorflow_probability.python.distributions import inverse_gamma +from tensorflow_probability.python.distributions import joint_distribution_auto_batched +from tensorflow_probability.python.distributions import sample as sample_dist +from tensorflow_probability.python.experimental.distributions import MultivariateNormalPrecisionFactorLinearOperator +from tensorflow_probability.python.internal import dtype_util +from tensorflow_probability.python.internal import parameter_properties +from tensorflow_probability.python.internal import prefer_static as ps +from tensorflow_probability.python.internal import samplers +from tensorflow_probability.python.internal import vectorization_util +from tensorflow_probability.python.mcmc.internal import util as mcmc_util + +__all__ = [ + 'DynamicSpikeSlabSampler' +] + + +class InverseGammaWithSampleUpperBound(inverse_gamma.InverseGamma): + """Inverse gamma distribution with an upper bound on sampled values.""" + + def __init__(self, concentration, scale, upper_bound, **kwargs): + self._upper_bound = upper_bound + super().__init__(concentration=concentration, + scale=scale, + **kwargs) + + @classmethod + def _parameter_properties(cls, dtype, num_classes=None): + return dict( + concentration=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), + scale=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype)))), + upper_bound=parameter_properties.ParameterProperties( + default_constraining_bijector_fn=( + lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) + + def _sample_n(self, n, seed=None): + xs = super()._sample_n(n, seed=seed) + if self._upper_bound is not None: + xs = tf.minimum(xs, self._upper_bound) + return xs + + +class MVNPrecisionFactorHardZeros( + MultivariateNormalPrecisionFactorLinearOperator): + """Multivariate normal that forces some sample dimensions to zero. + + This is equivalent to setting `loc[d] = 0.` and `precision_factor[d, d]=`inf` + in the zeroed dimensions, but is numerically better behaved. + + This class is meant to work specifically with the DynamicSpikeSlabSampler, + and so does not conform to a TensorFlow probability distribution API. In + particular, the loc and precision_factor are expected to be the nonzero + entries, and samples are broadcast back out to a full shape. This means: + - Querying the `event_shape` will give a wrong answer. + - Sampling for more than 1 element will throw an exception. + """ + + def __init__(self, loc, precision_factor, nonzeros, **kwargs): + self._indices = ps.where(nonzeros) + self._size = ps.dimension_size(nonzeros, -1) + super().__init__(loc=loc, precision_factor=precision_factor, **kwargs) + + def _call_sample_n(self, *args, **kwargs): + xs = super()._call_sample_n(*args, **kwargs) + return tf.scatter_nd( + indices=self._indices, + updates=xs, + shape=[self._size]) + + def _log_prob(self, *args, **kwargs): + raise NotImplementedError('Log prob is not currently implemented.') + + @classmethod + def _parameter_properties(cls, dtype, num_classes=None): + return dict( + loc=parameter_properties.ParameterProperties(event_ndims=1), + precision_factor=parameter_properties.BatchedComponentProperties(), + precision=parameter_properties.BatchedComponentProperties(), + nonzeros=parameter_properties.BatchedComponentProperties(event_ndims=1)) + + +class DynamicSpikeSlabSamplerState(collections.namedtuple( + 'DynamicSpikeSlabSamplerState', + ['x_transpose_y', + 'y_transpose_y', + 'nonzeros', + 'observation_noise_variance_posterior_scale', + 'unnormalized_log_prob'])): + """Quantities maintained during a sweep of the spike and slab sampler. + + This state is generated and consumed by internal sampler methods. It is not + intended to be publicly exposed. + + Elements: + x_transpose_y: float `Tensor` of shape `[num_features]`, + encoding the current regression targets. Equal to + `matvec(design_matrix, targets, adjoint_a=True)`. Note that this is + does not depend on the sparsity pattern and so is constant during a + given sweep. + y_transpose_y: scalar float `Tensor` equal to + `tf.reduce_sum(target ** 2)`, which is constant for a given sweep. + nonzeros: boolean `Tensor` of shape `[num_features]` + indicating the current sparsity pattern (`gamma` in [1]). A value of + `True` indicates that the corresponding feature has nonzero weight. + observation_noise_variance_posterior_scale: scalar float + `Tensor` representing the scale parameter of the inverse gamma + posterior on the observation noise variance (`SS_gamma / 2` in [1]). + Note that the concentration parameter is fixed given `num_outputs` and + so does not appear in the sampler state. + unnormalized_log_prob: scale float `Tensor` score for the sparsity pattern + represented by this state (eqn (8) in [1]). + + #### References + + [1] Steven L. Scott and Hal Varian. Predicting the Present with Bayesian + Structural Time Series. __International Journal of Mathematical Modelling + and Numerical Optimisation 5.1-2 (2014): 4-23.__ + https://people.ischool.berkeley.edu/~hal/Papers/2013/pred-present-with-bsts.pdf + """ + pass + + +class DynamicSpikeSlabSampler: + """Sampler for Bayesian regression with a spike-and-slab prior on weights. + + This implementation follows the sampler described in section 3.2 + of Scott and Varian, 2013 [1]. It differs from the SpikeSlabSampler in that + it selects the submatrix of the design matrix that is active (given by the + sparsity pattern of the coefficients), before computing a Cholesky + decomposition. This may provide a speedup by performing a Cholesky on a (much) + smaller matrix, at the cost of not being able to jit compile the program, or + to batch (since each batch element may have a different sparsity pattern, so + the dynamically sized matrices would all be different sizes). + + ### Model + + This sampler assumes the regression model + + ``` + y ~ Normal(loc=matvec(design_matrix, # `X` in [1]. + weights), # `beta` in `[1]`. + scale=observation_noise_scale) # `sigma_epsilon` in [1]. + ``` + + where the design matrix has shape `[num_outputs, num_features]`, with a + conjugate InverseGamma prior on the noise variance (eqn (6) of [1]): + + ``` + observation_noise_scale**2 ~ InverseGamma( + concentration=observation_noise_variance_prior_concentration, + scale=observation_noise_variance_prior_scale) + ``` + + and a spike-and-slab prior on the weights (eqns (5) and (6) of [1]): + + ``` + slab_weights ~ MultivariateNormal( + loc=0., # `b` from [1]. + precision=(weights_prior_precision # `Omega^{-1}` from [1]. + / observation_noise_scale**2)) + nonzeros ~ Bernoulli(probs=nonzero_prior_prob) # `gamma` from [1]. + weights = slab_weights * nonzeros + ``` + + ### Example + + Constructing a sampler instance specifies the model priors: + + ```python + sampler = spike_and_slab.DynamicSpikeSlabSampler( + design_matrix=design_matrix, + observation_noise_variance_prior_concentration=1., + observation_noise_variance_prior_scale=1. + nonzero_prior_prob=0.1) + ``` + + The sampler instance itself is stateless, though some internal methods take + or accept `DynamicSpikeSlabSamplerState` tuples representing posterior + quantities maintained within a sampling pass. The sampler is + invoked by passing the regression targets (`y`) and the initial sparsity + pattern (`nonzeros`): + + ``` + (observation_noise_variance, + weights) = sampler.sample_noise_variance_and_weights( + targets=y, initial_nonzeros=tf.ones([num_features], dtype=tf.bool)) + ``` + + This implements the stochastic search variable selection (SSVS) algorithm [2], + sweeping over the features in random order to resample their sparsity + indicators one by one. It then returns a sample from the joint posterior + on the regression weights and the observation noise variance, conditioned + on the resampled sparsity pattern. + + #### References + + [1] Steven L. Scott and Hal Varian. Predicting the Present with Bayesian + Structural Time Series. __International Journal of Mathematical Modelling + and Numerical Optimisation 5.1-2 (2014): 4-23.__ + https://people.ischool.berkeley.edu/~hal/Papers/2013/pred-present-with-bsts.pdf + + [2] George, E. I. and McCulloch, R. E. Approaches for Bayesian variable + selection. __Statistica Sinica 7, 339–374 (1997)__. + """ + + def __init__(self, + design_matrix, + nonzero_prior_prob=0.5, + weights_prior_precision=None, + default_pseudo_observations=1., + observation_noise_variance_prior_concentration=0.005, + observation_noise_variance_prior_scale=0.0025, + observation_noise_variance_upper_bound=None): + """Initializes priors for the spike and slab sampler. + + Args: + design_matrix: float `Tensor` regression design matrix (`X` in [1]) having + shape `[num_outputs, num_features]`. + nonzero_prior_prob: scalar float `Tensor` prior probability of the 'slab', + i.e., prior probability that any given feature has nonzero weight (`pi` + in [1]). + Default value: `0.5`. + weights_prior_precision: float `Tensor` complete prior precision matrix + over the weights, of shape `[num_features, num_features]`. If not + specified, defaults to the Zellner g-prior specified in `[1]` as + `Omega^{-1} = kappa * (X'X + diag(X'X)) / (2 * num_outputs)`, + in which we've plugged in the suggested default of `w = 0.5`. The + parameter `kappa` is controlled by the `default_pseudo_observations` + argument. + Default value: `None`. + default_pseudo_observations: scalar float `Tensor` + Controls the number of pseudo-observations for the prior precision + matrix over the weights. Corresponds to `kappa` in [1]. See also + `weights_prior_precision`. + observation_noise_variance_prior_concentration: scalar float `Tensor` + concentration parameter of the inverse gamma prior on the noise + variance. Corresponds to `nu / 2` in [1]. + Default value: 0.005. + observation_noise_variance_prior_scale: scalar float `Tensor` + scale parameter of the inverse gamma prior on the noise + variance. Corresponds to `ss / 2` in [1]. + Default value: 0.0025. + observation_noise_variance_upper_bound: optional scalar float `Tensor` + maximum value of sampled observation noise variance. Specifying a bound + can help avoid divergence when the sampler is initialized far from the + posterior. + Default value: `None`. + """ + with tf.name_scope('spike_slab_sampler'): + dtype = dtype_util.common_dtype([ + design_matrix, + nonzero_prior_prob, + weights_prior_precision, + observation_noise_variance_prior_concentration, + observation_noise_variance_prior_scale, + observation_noise_variance_upper_bound], dtype_hint=tf.float32) + design_matrix = tf.convert_to_tensor(design_matrix, dtype=dtype) + nonzero_prior_prob = tf.convert_to_tensor(nonzero_prior_prob, dtype=dtype) + observation_noise_variance_prior_concentration = tf.convert_to_tensor( + observation_noise_variance_prior_concentration, dtype=dtype) + observation_noise_variance_prior_scale = tf.convert_to_tensor( + observation_noise_variance_prior_scale, dtype=dtype) + if observation_noise_variance_upper_bound is not None: + observation_noise_variance_upper_bound = tf.convert_to_tensor( + observation_noise_variance_upper_bound, dtype=dtype) + + design_shape = ps.shape(design_matrix) + if len(design_shape) > 2: + raise ValueError(f'DynamicSpikeSlabSampler does not support batched ' + f'computation, but the design matrix has shape ' + f'{design_matrix.shape}') + num_outputs = design_shape[-2] + num_features = design_shape[-1] + + x_transpose_x = tf.matmul(design_matrix, design_matrix, adjoint_a=True) + if weights_prior_precision is None: + # Default prior: 'Zellner’s g−prior' from section 3.2.1 of [1]: + # `omega^{-1} = kappa * (w X'X + (1 − w) diag(X'X))/n` + # with default `w = 0.5`. + weights_prior_precision = default_pseudo_observations * tf.linalg.set_diag( + 0.5 * x_transpose_x, + tf.linalg.diag_part(x_transpose_x)) / num_outputs + + weights_posterior_precision = x_transpose_x + weights_prior_precision + observation_noise_variance_posterior_concentration = ( + observation_noise_variance_prior_concentration + + tf.convert_to_tensor(num_outputs / 2., dtype=dtype)) + + self.num_outputs = num_outputs + self.num_features = num_features + self.design_matrix = design_matrix + self.dtype = dtype + self.nonzeros_prior = sample_dist.Sample( + bernoulli.Bernoulli(probs=nonzero_prior_prob), + sample_shape=[num_features]) + self.weights_prior_precision = weights_prior_precision + self.weights_posterior_precision = weights_posterior_precision + self.observation_noise_variance_prior_concentration = ( + observation_noise_variance_prior_concentration) + self.observation_noise_variance_prior_scale = ( + observation_noise_variance_prior_scale) + self.observation_noise_variance_upper_bound = ( + observation_noise_variance_upper_bound) + self.observation_noise_variance_posterior_concentration = ( + observation_noise_variance_posterior_concentration) + + def sample_noise_variance_and_weights(self, targets, initial_nonzeros, seed): + """(Re)samples regression parameters under the spike-and-slab model. + + Args: + targets: float Tensor regression target (y-value), of shape + `[num_outputs]`. + initial_nonzeros: boolean Tensor vector of shape `[num_features]`. + seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + Returns: + observation_noise_variance: scalar float Tensor posterior sample of + the observation noise variance, given the resampled sparsity pattern. + weights: float Tensor posterior sample(s) of the weight vector given the + resampled sparsity pattern (encoded as zeros in the weight vector) + *and* the sampled observation noise variance. Has shape + `[num_features]`. + """ + feature_sweep_seed, resample_seed = samplers.split_seed(seed, n=2) + initial_state = self._initialize_sampler_state(targets=targets, + nonzeros=initial_nonzeros) + # Loop over the features to update their sparsity indicators. + final_state = self._resample_all_features(initial_state, + seed=feature_sweep_seed) + # Finally, sample parameters given the updated sparsity indicators. + return self._get_conditional_posterior(final_state).sample( + seed=resample_seed) + + def _initialize_sampler_state(self, targets, nonzeros): + """Precompute quantities needed to sample with given targets. + + This method computes a sampler state (including factorized precision + matrices) from scratch for a given sparsity pattern. This requires + time proportional to `num_features**3`. If a sampler state is already + available for an off-by-one sparsity pattern, the `_flip_feature` method + (which takes time proportional to `num_features**2`) is + generally more efficient. + + Args: + targets: float Tensor regression outputs of shape `[num_outputs]`. + nonzeros: boolean Tensor vectors of shape `[num_features]`. + Returns: + sampler_state: instance of `DynamicSpikeSlabSamplerState` collecting + Tensor quantities relevant to the sampler. See + `DynamicSpikeSlabSamplerState` for details. + """ + with tf.name_scope('initialize_sampler_state'): + targets = tf.convert_to_tensor(targets, dtype=self.dtype) + nonzeros = tf.convert_to_tensor(nonzeros, dtype=tf.bool) + indices = ps.where(nonzeros)[:, 0] + + x_transpose_y = tf.linalg.matvec( + self.design_matrix, targets, adjoint_a=True) + + y_transpose_y = tf.reduce_sum(targets**2, axis=-1) + conditional_prior_precision_chol = tf.linalg.cholesky( + tf.gather( + tf.gather(self.weights_prior_precision, indices), + indices, axis=1)) + conditional_posterior_precision_chol = tf.linalg.cholesky( + tf.gather( + tf.gather(self.weights_posterior_precision, indices), + indices, + axis=1)) + sub_x_transpose_y = tf.gather(x_transpose_y, indices) + conditional_weights_mean = tf.linalg.cholesky_solve( + conditional_posterior_precision_chol, + sub_x_transpose_y[..., tf.newaxis])[..., 0] + return self._compute_log_prob( + x_transpose_y=x_transpose_y, + y_transpose_y=y_transpose_y, + nonzeros=nonzeros, + conditional_prior_precision_chol=conditional_prior_precision_chol, + conditional_posterior_precision_chol=conditional_posterior_precision_chol, + observation_noise_variance_posterior_scale=( + self.observation_noise_variance_prior_scale + # ss / 2 + (y_transpose_y - + tf.reduce_sum( # beta_gamma' V_gamma^{-1} beta_gamma + conditional_weights_mean * sub_x_transpose_y, + axis=-1)) + / 2)) + + def _flip_feature(self, sampler_state, idx): + """Proposes flipping the sparsity indicator of the `idx`th feature. + + This method computes the sampler state (including factorized precision + matrices) for a given sparsity pattern, given the state for a + related sparsity pattern that differs in a single position. This is + achieved using rank-1 Cholesky updates running in time + proportional to `num_features**2`, and so is typically more efficient than + recomputing the equivalent state from scratch using + `_initialize_sampler_state`. + + Args: + sampler_state: instance of `DynamicSpikeSlabSamplerState` collecting + Tensor quantities relevant to the sampler. See the + `DynamicSpikeSlabSamplerState` definition for details. + idx: scalar int `Tensor` index in `[0, num_features)`. + Returns: + updated_sampler_state: instance of `DynamicSpikeSlabSamplerState` + equivalent to `self._initialize_sampler_state(targets, new_nonzeros)`, + where `new_nonzeros` is equal to `nonzeros` with the `idx`th entry + negated. + """ + with tf.name_scope('flip_feature_indicator'): + was_nonzero = tf.gather(sampler_state.nonzeros, idx, axis=-1) + new_nonzeros = _set_vector_index( + sampler_state.nonzeros, idx, tf.logical_not(was_nonzero)) + # Update the weight posterior mean and precision for the new nonzeros. + # (and also update the prior, used to compute the marginal likelihood). + indices = tf.where(new_nonzeros)[:, 0] + conditional_prior_precision_chol = tf.linalg.cholesky( + tf.gather( + tf.gather(self.weights_prior_precision, indices), + indices, axis=1)) + conditional_posterior_precision_chol = tf.linalg.cholesky( + tf.gather( + tf.gather(self.weights_posterior_precision, indices), + indices, axis=1)) + sub_x_transpose_y = tf.gather(sampler_state.x_transpose_y, indices) + conditional_weights_mean = tf.linalg.cholesky_solve( + conditional_posterior_precision_chol, + sub_x_transpose_y[..., tf.newaxis])[..., 0] + return self._compute_log_prob( + nonzeros=new_nonzeros, + y_transpose_y=sampler_state.y_transpose_y, + conditional_prior_precision_chol=conditional_prior_precision_chol, + conditional_posterior_precision_chol=( + conditional_posterior_precision_chol), + observation_noise_variance_posterior_scale=( + self.observation_noise_variance_prior_scale + + (sampler_state.y_transpose_y - + tf.reduce_sum( + conditional_weights_mean * sub_x_transpose_y, + axis=-1)) / 2), + x_transpose_y=sampler_state.x_transpose_y) + + def _resample_all_features(self, initial_sampler_state, seed): + """Loops over all features to resample their sparsity indicators. + + The sampler loops over the features in random order, where each iteration + updates the `nonzeros` indicator for that particular (single) feature + weight. This update is a collapsed Gibbs sampling step, i.e., it samples + from the posterior on the current sparsity indicator given the remaining + indicators, after marginalizing (collapsing) out the observation noise + variance and the continuous regression weights under their conjugate priors. + + Args: + initial_sampler_state: instance of `DynamicSpikeSlabSamplerState` + collecting Tensor quantities relevant to the sampler. See + `DynamicSpikeSlabSamplerState` for details. + seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + Returns: + final sampler_state: instance of `DynamicSpikeSlabSamplerState` in which + the sparsity indicators for all features have been resampled. + """ + with tf.name_scope('resample_all_features'): + feature_seed, loop_seed = samplers.split_seed(seed, n=2) + + # Visit features in random order. + feature_permutation = tf.argsort( + tf.random.stateless_uniform([self.num_features], seed=feature_seed)) + + @tf.function(autograph=False) + def resample_one_feature(step, seed, sampler_state): + seed, next_seed = samplers.split_seed(seed, n=2) + idx = tf.gather(feature_permutation, step) + + # Maybe flip this weight's sparsity indicator. + proposed_sampler_state = self._flip_feature(sampler_state, idx=idx) + should_flip = bernoulli.Bernoulli( + logits=(proposed_sampler_state.unnormalized_log_prob - + sampler_state.unnormalized_log_prob), + dtype=tf.bool).sample(seed=seed) + return step + 1, next_seed, mcmc_util.choose(should_flip, + proposed_sampler_state, + sampler_state) + + _, _, final_sampler_state = tf.while_loop( + cond=lambda step, *args: step < self.num_features, + body=resample_one_feature, + loop_vars=(0, loop_seed, initial_sampler_state)) + return final_sampler_state + + def _compute_log_prob( + self, + x_transpose_y, + y_transpose_y, + nonzeros, + conditional_prior_precision_chol, + conditional_posterior_precision_chol, + observation_noise_variance_posterior_scale): # pylint: disable=g-doc-args + """Computes an unnormalized log prob of a sampler state. + + This corresponds to equation (8) in [1]. It scores a sparsity pattern by + the marginal likelihood of the observed targets (ignoring constant terms + that do not depend on the sparsity pattern) multiplied by the prior + probability of the sparsity pattern. + + Args: + See `DynamicSpikeSlabSamplerState`. + Returns: + sampler_state: a `DynamicSpikeSlabSamplerState` instance containing the + given args and the corresponding unnormalized log prob. + """ + return DynamicSpikeSlabSamplerState( + x_transpose_y=x_transpose_y, + y_transpose_y=y_transpose_y, + nonzeros=nonzeros, + observation_noise_variance_posterior_scale=( + observation_noise_variance_posterior_scale), + unnormalized_log_prob=( # Equation (8) of [1]. + _half_logdet(conditional_prior_precision_chol) - + _half_logdet(conditional_posterior_precision_chol) + + self.nonzeros_prior.log_prob(nonzeros) - + (self.observation_noise_variance_posterior_concentration - 1 + ) * tf.math.log(2 * observation_noise_variance_posterior_scale))) + + def _get_conditional_posterior(self, sampler_state): + """Builds the joint posterior for a sparsity pattern (eqn (7) from [1]).""" + indices = ps.where(sampler_state.nonzeros)[:, 0] + conditional_posterior_precision_chol = tf.linalg.cholesky( + tf.gather( + tf.gather(self.weights_posterior_precision, indices), + indices, + axis=1)) + conditional_weights_mean = tf.linalg.cholesky_solve( + conditional_posterior_precision_chol, + tf.gather( + sampler_state.x_transpose_y, indices)[..., tf.newaxis])[..., 0] + @joint_distribution_auto_batched.JointDistributionCoroutineAutoBatched + def posterior_jd(): + observation_noise_variance = yield InverseGammaWithSampleUpperBound( + concentration=( + self.observation_noise_variance_posterior_concentration), + scale=sampler_state.observation_noise_variance_posterior_scale, + upper_bound=self.observation_noise_variance_upper_bound, + name='observation_noise_variance') + yield MVNPrecisionFactorHardZeros( + loc=conditional_weights_mean, + # Note that the posterior precision varies inversely with the + # noise variance: in worlds with high noise we're also + # more uncertain about the values of the weights. + # TODO(colcarroll): Tests pass even without a square root on the + # observation_noise_variance. Should add a test that would fail. + precision_factor=tf.linalg.LinearOperatorLowerTriangular( + conditional_posterior_precision_chol / + tf.sqrt(observation_noise_variance[..., tf.newaxis, tf.newaxis])), + nonzeros=sampler_state.nonzeros, + name='weights') + + return posterior_jd + + +def _set_vector_index_unbatched(v, idx, x): + """Mutation-free equivalent of `v[idx] = x.""" + return tf.tensor_scatter_nd_update(v, indices=[[idx]], updates=[x]) + +_set_vector_index = vectorization_util.make_rank_polymorphic( + _set_vector_index_unbatched, core_ndims=[1, 0, 0]) + + +def _half_logdet(chol): + return tf.reduce_sum(tf.math.log(tf.linalg.diag_part(chol)), axis=-1) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py new file mode 100644 index 0000000000..27a4359cae --- /dev/null +++ b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py @@ -0,0 +1,343 @@ +# Copyright 2021 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +"""Tests for spike and slab sampler.""" + +from absl.testing import parameterized + +import numpy as np + +import tensorflow.compat.v2 as tf + +import tensorflow_probability as tfp +from tensorflow_probability.python.experimental.sts_gibbs import dynamic_spike_and_slab +from tensorflow_probability.python.internal import samplers +from tensorflow_probability.python.internal import test_util +from tensorflow_probability.python.mcmc.internal import util as mcmc_util + +tfd = tfp.distributions + + +def _naive_symmetric_increment(m, idx, increment): + m = m.copy() + m[..., idx, :] += increment + m[..., :, idx] += increment + m[..., idx, idx] -= increment[..., idx] + return m + + +def _compute_conditional_weights_mean(nonzeros, weights_posterior_precision, + x_transpose_y): + indices = tf.where(nonzeros)[:, 0] + conditional_posterior_precision_chol = tf.linalg.cholesky( + tf.gather( + tf.gather(weights_posterior_precision, indices), + indices, axis=1)) + return tf.linalg.cholesky_solve( + conditional_posterior_precision_chol, + tf.gather(x_transpose_y, indices)[..., tf.newaxis])[..., 0] + + +class SpikeAndSlabTest(test_util.TestCase): + + def _random_regression_task(self, num_outputs, num_features, + weights=None, observation_noise_scale=0.1, + seed=None): + design_seed, weights_seed, noise_seed = samplers.split_seed(seed, n=3) + + design_matrix = samplers.uniform([num_outputs, num_features], + seed=design_seed) + if weights is None: + weights = samplers.normal([num_features], seed=weights_seed) + targets = (tf.linalg.matvec(design_matrix, weights) + + observation_noise_scale * samplers.normal( + [num_outputs], seed=noise_seed)) + return design_matrix, weights, targets + + def test_sampler_respects_pseudo_observations(self): + design_matrix = self.evaluate( + samplers.uniform([20, 5], seed=test_util.test_seed())) + first_obs = 2. + second_obs = 10. + first_sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix, + default_pseudo_observations=first_obs) + second_sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix, + default_pseudo_observations=second_obs) + + self.assertNotAllClose( + first_sampler.weights_prior_precision, + second_sampler.weights_prior_precision) + self.assertAllClose( + first_sampler.weights_prior_precision / first_obs, + second_sampler.weights_prior_precision / second_obs) + + @parameterized.named_parameters( + ('default_precision', 1.), + ('ten_pseudo_obs', 10.)) + def test_posterior_on_nonzero_subset_matches_bayesian_regression( + self, default_pseudo_observations): + # Generate a synthetic regression task. + design_matrix, _, targets = self.evaluate( + self._random_regression_task( + num_features=5, num_outputs=20, + seed=test_util.test_seed())) + + # Utilities to extract values for nonzero-weight features. + nonzeros = np.array([True, False, True, False, True]) + nonzero_subvector = lambda x: x[..., nonzeros] + nonzero_submatrix = ( + lambda x: self.evaluate(x)[..., nonzeros][..., nonzeros, :]) + + # Compute the weight posterior mean and precision for these nonzeros. + sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix, + default_pseudo_observations=default_pseudo_observations) + initial_state = sampler._initialize_sampler_state( + targets=targets, nonzeros=nonzeros) + + # Compute the analytic posterior for the regression problem restricted to + # only the selected features. Note that by slicing a submatrix of the + # prior precision we are implicitly *conditioning* on having observed the + # other weights to be zero (which is sensible in this case), versus slicing + # into the covariance which would give the marginal (unconditional) prior + # on the selected weights. + (restricted_weights_posterior_mean, + _) = tfd.mvn_conjugate_linear_update( + prior_scale=tf.linalg.cholesky( + tf.linalg.inv(nonzero_submatrix(sampler.weights_prior_precision))), + linear_transformation=nonzero_subvector(design_matrix), + likelihood_scale=tf.eye(20), + observation=targets) + + # The sampler's posterior should match the posterior from the restricted + # problem. + conditional_weights_mean = _compute_conditional_weights_mean( + initial_state.nonzeros, + sampler.weights_posterior_precision, + initial_state.x_transpose_y) + self.assertAllClose( + self.evaluate( + conditional_weights_mean), + restricted_weights_posterior_mean) + + def test_noise_variance_posterior_matches_expected(self): + # Generate a synthetic regression task. + num_features = 5 + num_outputs = 20 + design_matrix, _, targets = self.evaluate( + self._random_regression_task( + num_features=num_features, num_outputs=num_outputs, + seed=test_util.test_seed())) + + observation_noise_variance_prior_concentration = 0.03 + observation_noise_variance_prior_scale = 0.015 + # Posterior on noise variance if all weights are zero. + naive_posterior = tfd.InverseGamma( + concentration=(observation_noise_variance_prior_concentration + + num_outputs / 2.), + scale=(observation_noise_variance_prior_scale + tf.reduce_sum( + tf.square(targets), axis=-1) / 2.)) + + # Compare to sampler with weights constrained to near-zero. + # We can do this by reducing the width of the slab (here), + # or by reducing the probability of the slab (below). Both should give + # equivalent noise posteriors. + tight_slab_sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix, + weights_prior_precision=tf.eye(num_features) * 1e6, + observation_noise_variance_prior_concentration=( + observation_noise_variance_prior_concentration), + observation_noise_variance_prior_scale=( + observation_noise_variance_prior_scale)) + self.assertAllClose( + tight_slab_sampler.observation_noise_variance_posterior_concentration, + naive_posterior.concentration) + self.assertAllClose( + tight_slab_sampler._initialize_sampler_state( + targets=targets, + nonzeros=tf.ones([num_features], dtype=tf.bool) + ).observation_noise_variance_posterior_scale, + naive_posterior.scale, + atol=1e-2) + + downweighted_slab_sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix, + observation_noise_variance_prior_concentration=( + observation_noise_variance_prior_concentration), + observation_noise_variance_prior_scale=( + observation_noise_variance_prior_scale)) + self.assertAllClose( + (downweighted_slab_sampler. + observation_noise_variance_posterior_concentration), + naive_posterior.concentration) + self.assertAllClose( + downweighted_slab_sampler._initialize_sampler_state( + targets=targets, + nonzeros=tf.zeros([num_features], dtype=tf.bool) + ).observation_noise_variance_posterior_scale, + naive_posterior.scale) + + @parameterized.parameters( + (2, 3, 1), + (2, 3, 1), + (100, 20, 10), + (100, 20, 10), + (40, 20, 12)) + def test_updated_state_matches_initial_computation( + self, num_outputs, num_features, num_flips): + + rng = test_util.test_np_rng() + initial_nonzeros = rng.randint( + low=0, high=2, size=[num_features]).astype(np.bool) + flip_idxs = rng.choice( + num_features, size=num_flips, replace=False).astype(np.int32) + should_flip = np.array([True] * num_flips) + + nonzeros = initial_nonzeros.copy() + for i in range(num_flips): + nonzeros[..., flip_idxs[i]] = ( + nonzeros[..., flip_idxs[i]] != should_flip[i]) + + design_matrix, _, targets = self._random_regression_task( + num_outputs=num_outputs, num_features=num_features, + seed=test_util.test_seed()) + sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix=design_matrix, nonzero_prior_prob=0.3) + + @tf.function(autograph=False, jit_compile=False) + def _do_flips(): + state = sampler._initialize_sampler_state( + targets=targets, nonzeros=initial_nonzeros) + def _do_flip(state, i): + new_state = sampler._flip_feature(state, tf.gather(flip_idxs, i)) + return mcmc_util.choose(tf.gather(should_flip, i), new_state, state) + return tf.foldl(_do_flip, elems=tf.range(num_flips), initializer=state) + + self.assertAllCloseNested( + sampler._initialize_sampler_state(targets, nonzeros), + _do_flips(), + atol=1e-6, rtol=1e-6) + + def test_sanity_check_sweep_over_features(self): + num_outputs = 100 + num_features = 3 + design_matrix, true_weights, targets = self.evaluate( + self._random_regression_task( + num_outputs=num_outputs, + num_features=num_features, + # Specify weights with a clear sparsity pattern. + weights=tf.convert_to_tensor([10., 0., -10.]), + seed=test_util.test_seed())) + + sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix, + # Ensure the probability of keeping an irrelevant feature is tiny. + nonzero_prior_prob=1e-6) + initial_state = sampler._initialize_sampler_state( + targets=targets, nonzeros=tf.convert_to_tensor([True, True, True])) + final_state = self.evaluate( + sampler._resample_all_features( + initial_state, seed=test_util.test_seed())) + + # Check that we recovered the true sparsity pattern and approximate weights. + conditional_weights_mean = _compute_conditional_weights_mean( + final_state.nonzeros, + sampler.weights_posterior_precision, + final_state.x_transpose_y) + self.assertAllEqual(final_state.nonzeros, [True, False, True]) + indices = tf.where(final_state.nonzeros) + conditional_weights_mean = tf.scatter_nd( + indices, conditional_weights_mean, true_weights.shape) + self.assertAllClose(conditional_weights_mean, + true_weights, rtol=0.05, atol=0.15) + + posterior = sampler._get_conditional_posterior(final_state) + posterior_variances, posterior_weights = self.evaluate( + posterior.sample(seed=test_util.test_seed())) + self.assertAllFinite(posterior_variances) + self.assertAllFinite(posterior_weights) + + def test_samples_from_weights_prior(self): + nonzero_prior_prob = 0.7 + num_outputs, num_features = 200, 4 + + # Setting the design matrix to zero, the targets provide no information + # about weights, so the sampler should sample from the prior. + design_matrix = tf.zeros([num_outputs, num_features]) + targets = 0.42 * samplers.normal([num_outputs], seed=test_util.test_seed()) + sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler( + design_matrix=design_matrix, + weights_prior_precision=tf.eye(num_features), + nonzero_prior_prob=nonzero_prior_prob) + + # Draw 100 posterior samples. Since all state needed for the + # internal feature sweep is a function of the sparsity pattern, it's + # sufficient to pass the sparsity pattern (by way of the weights) as + # the outer-loop state. + @tf.function(autograph=False) + def loop_body(var_weights_seed, _): + _, weights, seed = var_weights_seed + seed, next_seed = samplers.split_seed(seed, n=2) + variance, weights = sampler.sample_noise_variance_and_weights( + initial_nonzeros=tf.not_equal(weights, 0.), + targets=targets, + seed=seed) + return variance, weights, next_seed + + init_seed = test_util.test_seed(sampler_type='stateless') + variance_samples, weight_samples, _ = tf.scan( + fn=loop_body, + initializer=(1., tf.ones([num_features]), init_seed), + elems=tf.range(100)) + + # With the default (relatively uninformative) prior, the noise variance + # posterior mean should be close to the most-likely value. + self.assertAllClose(tf.reduce_mean(variance_samples), + tf.math.reduce_std(targets)**2, + atol=0.03) + # Since there is no evidence for the weights, the sparsity of our samples + # should match the prior. + nonzero_weight_samples = tf.cast(tf.not_equal(weight_samples, 0.), + tf.float32) + self.assertAllClose(nonzero_prior_prob, + tf.reduce_mean(nonzero_weight_samples), + atol=0.03) + + def test_deterministic_given_seed(self): + design_matrix, _, targets = self.evaluate( + self._random_regression_task( + num_outputs=3, num_features=4, + seed=test_util.test_seed())) + + sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler(design_matrix) + + initial_nonzeros = tf.convert_to_tensor([True, False, False, True]) + seed = test_util.test_seed(sampler_type='stateless') + + @tf.function(autograph=False, jit_compile=False) + def do_sample(seed): + return sampler.sample_noise_variance_and_weights( + targets, initial_nonzeros, seed=seed) + variance1, weights1 = self.evaluate(do_sample(seed)) + variance2, weights2 = self.evaluate(do_sample(seed)) + self.assertAllFinite(variance1) + self.assertAllClose(variance1, variance2) + self.assertAllFinite(weights1) + self.assertAllClose(weights1, weights2) + + +if __name__ == '__main__': + test_util.main() diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index 24f18a6ecc..6b22f14b10 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -67,6 +67,7 @@ class is somewhat general, in that we assume that any seasonal/holiday variation from tensorflow_probability.python import sts from tensorflow_probability.python.distributions import normal_conjugate_posteriors from tensorflow_probability.python.experimental import distributions as tfde +from tensorflow_probability.python.experimental.sts_gibbs import dynamic_spike_and_slab from tensorflow_probability.python.experimental.sts_gibbs import spike_and_slab from tensorflow_probability.python.internal import distribution_util as dist_util from tensorflow_probability.python.internal import dtype_util @@ -75,6 +76,8 @@ class is somewhat general, in that we assume that any seasonal/holiday variation from tensorflow_probability.python.sts import components as sts_components from tensorflow_probability.python.sts.internal import util as sts_util +JAX_MODE = False + # The sampler state stores current values for each model parameter, # and auxiliary quantities such as the latent level. It should have the property # that `model.make_state_space_model(num_timesteps, GibbsSamplerState(...))` @@ -341,7 +344,8 @@ def fit_with_gibbs_sampling(model, num_warmup_steps=200, initial_state=None, seed=None, - default_pseudo_observations=None): + default_pseudo_observations=None, + experimental_use_dynamic_cholesky=False): """Fits parameters for an STS model using Gibbs sampling. Args: @@ -362,6 +366,13 @@ def fit_with_gibbs_sampling(model, default_pseudo_observations: Optional scalar float `Tensor` Controls the number of pseudo-observations for the prior precision matrix over the weights. + experimental_use_dynamic_cholesky: Optional bool - in case of spike and slab + sampling, will dynamically select the subset of the design matrix with + active features to perform the Cholesky decomposition. This may provide + a speedup when the number of true features is small compared to the size + of the design matrix. *Note*: If this is true, neither batch shape nor + `jit_compile` is supported. + Returns: model: A `GibbsSamplerState` structure of posterior samples. @@ -417,9 +428,9 @@ def fit_with_gibbs_sampling(model, initial_state = initial_state._replace( seed=samplers.sanitize_seed(seed, salt='initial_GibbsSamplerState')) - sampler_loop_body = _build_sampler_loop_body(model, observed_time_series, - is_missing, - default_pseudo_observations) + sampler_loop_body = _build_sampler_loop_body( + model, observed_time_series, is_missing, default_pseudo_observations, + experimental_use_dynamic_cholesky) samples = tf.scan(sampler_loop_body, np.arange(num_warmup_steps + num_results), initial_state) @@ -741,7 +752,8 @@ def _resample_scale(prior, observed_residuals, is_missing=None, seed=None): def _build_sampler_loop_body(model, observed_time_series, is_missing=None, - default_pseudo_observations=None): + default_pseudo_observations=None, + experimental_use_dynamic_cholesky=False): """Builds a Gibbs sampler for the given model and observed data. Args: @@ -754,6 +766,11 @@ def _build_sampler_loop_body(model, default_pseudo_observations: Optional scalar float `Tensor` Controls the number of pseudo-observations for the prior precision matrix over the weights. + experimental_use_dynamic_cholesky: Optional bool - in case of spike and slab + sampling, will dynamically select the subset of the design matrix with + active features to perform the Cholesky decomposition. This may provide + a speedup when the number of true features is small compared to the size + of the design matrix. Returns: sampler_loop_body: Python callable that performs a single cycle of Gibbs @@ -761,6 +778,8 @@ def _build_sampler_loop_body(model, new `GibbsSamplerState`. The second argument (passed by `tf.scan`) is ignored. """ + if JAX_MODE and experimental_use_dynamic_cholesky: + raise ValueError('Dynamic Cholesky decomposition not supported in JAX') level_component = model.components[0] if not (isinstance(level_component, sts.LocalLevel) or isinstance(level_component, sts.LocalLinearTrend)): @@ -817,7 +836,12 @@ def _build_sampler_loop_body(model, if regression_component: if model_has_spike_slab_regression: - spike_and_slab_sampler = spike_and_slab.SpikeSlabSampler( + if experimental_use_dynamic_cholesky: + sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler + else: + sampler = spike_and_slab.SpikeSlabSampler + + spike_and_slab_sampler = sampler( design_matrix, weights_prior_precision=regression_component._weights_prior_precision, # pylint: disable=protected-access nonzero_prior_prob=regression_component._sparse_weights_nonzero_prob, # pylint: disable=protected-access diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index 20be087719..761a185409 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -31,6 +31,8 @@ tfd = tfp.distributions tfl = tf.linalg +JAX_MODE = False + @test_util.test_graph_and_eager_modes class GibbsSamplerTests(test_util.TestCase): @@ -642,7 +644,16 @@ def do_sampling(): self.assertAllClose(mean_weights, true_weights, atol=0.3) self.assertAllClose(nonzero_probs, [1., 1., 1., 1., 1.]) - def test_sparse_regression_recovers_plausible_weights(self): + @parameterized.named_parameters( + { + 'testcase_name': 'Rank1Updates', + 'use_dyanamic_cholesky': False, + }, { + 'testcase_name': 'DynamicCholesky', + 'use_dyanamic_cholesky': True, + }) + def test_sparse_regression_recovers_plausible_weights( + self, use_dyanamic_cholesky): true_weights = tf.constant([0., 0., 2., 0., -2.]) model, observed_time_series, _ = self._build_test_model( num_timesteps=20, @@ -660,9 +671,15 @@ def do_sampling(): observed_time_series, num_results=100, num_warmup_steps=100, - seed=test_util.test_seed(sampler_type='stateless')) + seed=test_util.test_seed(sampler_type='stateless'), + experimental_use_dynamic_cholesky=use_dyanamic_cholesky) - samples = self.evaluate(do_sampling()) + if JAX_MODE and use_dyanamic_cholesky: + with self.assertRaises(ValueError): + self.evaluate(do_sampling()) + return + else: + samples = self.evaluate(do_sampling()) mean_weights = tf.reduce_mean(samples.weights, axis=-2) nonzero_probs = tf.reduce_mean( tf.cast(tf.not_equal(samples.weights, 0.), tf.float32), From b1f0a9e914237967e261b475e87ac054b2f43678 Mon Sep 17 00:00:00 2001 From: Christopher Suter Date: Wed, 11 May 2022 11:16:58 -0700 Subject: [PATCH 130/153] Encode max dimension requirement on LKJ dists. Making the dimension bigger than 2**16 overflows int32 array sizes. Fixes: #1561 PiperOrigin-RevId: 448040441 --- tensorflow_probability/python/distributions/cholesky_lkj.py | 4 ++++ tensorflow_probability/python/distributions/lkj.py | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/tensorflow_probability/python/distributions/cholesky_lkj.py b/tensorflow_probability/python/distributions/cholesky_lkj.py index 49fe537d3f..0da47bf7af 100644 --- a/tensorflow_probability/python/distributions/cholesky_lkj.py +++ b/tensorflow_probability/python/distributions/cholesky_lkj.py @@ -107,6 +107,10 @@ def __init__(self, if dimension < 0: raise ValueError( 'There are no negative-dimension correlation matrices.') + if dimension > 65536: + raise ValueError( + ('Given dimension ({}) is greater than 65536, and will overflow ' + 'int32 array sizes.').format(dimension)) parameters = dict(locals()) with tf.name_scope(name): dtype = dtype_util.common_dtype([concentration], tf.float32) diff --git a/tensorflow_probability/python/distributions/lkj.py b/tensorflow_probability/python/distributions/lkj.py index 54c4a45260..5617aaabc6 100644 --- a/tensorflow_probability/python/distributions/lkj.py +++ b/tensorflow_probability/python/distributions/lkj.py @@ -364,6 +364,10 @@ def __init__(self, if dimension < 0: raise ValueError( 'There are no negative-dimension correlation matrices.') + if dimension > 65536: + raise ValueError( + ('Given dimension ({}) is greater than 65536, and will overflow ' + 'int32 array sizes.').format(dimension)) parameters = dict(locals()) self._input_output_cholesky = input_output_cholesky with tf.name_scope(name): From a4963ae4b5f55be83e182e8e4eb83c48b27cd8d4 Mon Sep 17 00:00:00 2001 From: langmore Date: Fri, 13 May 2022 15:50:43 -0700 Subject: [PATCH 131/153] BUGFIX: ensemble_kalman_filter_update was perturbing too many terms. This fix makes the update step the same as section 3.1 in [1] and 4.2.3 in [2]. New test added (compares to Kalman Filter). Verified that without this fix the EnKF was failing horribly: http://screen/6J8b9N4fPuuBtTj and http://sponge2/5aae3d43-e0f8-4b05-9871-ff9fdd5e12a2 [1] https://www.tandfonline.com/doi/abs/10.1080/00031305.2016.1141709?journalCode=utas20 [2] https://arxiv.org/abs/1506.07825 PiperOrigin-RevId: 448594324 --- .../python/experimental/sequential/BUILD | 1 + .../sequential/ensemble_kalman_filter.py | 46 ++- .../sequential/ensemble_kalman_filter_test.py | 373 ++++++++++++++++-- 3 files changed, 377 insertions(+), 43 deletions(-) diff --git a/tensorflow_probability/python/experimental/sequential/BUILD b/tensorflow_probability/python/experimental/sequential/BUILD index b7fa5f33bf..32a75e3eea 100644 --- a/tensorflow_probability/python/experimental/sequential/BUILD +++ b/tensorflow_probability/python/experimental/sequential/BUILD @@ -95,6 +95,7 @@ multi_substrate_py_test( name = "ensemble_kalman_filter_test", size = "medium", srcs = ["ensemble_kalman_filter_test.py"], + shard_count = 3, deps = [ ":ensemble_kalman_filter", # numpy dep, diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py index 6c7bc087ab..28505b8317 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py @@ -104,6 +104,7 @@ def ensemble_kalman_filter_predict( particles, and scale up the sample covariance. name: Python `str` name for ops created by this method. Default value: `None` (i.e., `'ensemble_kalman_filter_predict'`). + Returns: next_state: `EnsembleKalmanFilterState` representing particles after applying `transition_fn`. @@ -148,8 +149,9 @@ def ensemble_kalman_filter_update( version of the traditional Kalman Filter. This method is the 'update' equation associated with the Ensemble - Kalman Filter. In expectation, the ensemble covariance will match that - of the true posterior (under a Linear Gaussian State Space Model). + Kalman Filter. As the ensemble size goes to infinity, the EnKF sample mean and + covariance match that of the true posterior (under a Linear Gaussian State + Space Model). Args: state: Instance of `EnsembleKalmanFilterState`. @@ -162,12 +164,22 @@ def ensemble_kalman_filter_update( seed: PRNG seed; see `tfp.random.sanitize_seed` for details. name: Python `str` name for ops created by this method. Default value: `None` (i.e., `'ensemble_kalman_filter_update'`). + Returns: next_state: `EnsembleKalmanFilterState` representing particles at next timestep, after applying Kalman update equations. """ with tf.name_scope(name or 'ensemble_kalman_filter_update'): + # In the example below, we let + # Y be the real observations, so Y.shape = [observation_size] + # X be an ensemble particles with X.shape = [ensemble_size, state_size] + # G be the observation function, + # so G(X).shape = [ensemble_size, state_size]. + # In practice, batch dims may appear between the ensemble and state dims. + + # In the traditional EnKF, observation_particles_dist ~ N(G(X), Γ). + # However, our API would allow any Gaussian. observation_particles_dist, extra = observation_fn( state.step, state.particles, state.extra) @@ -182,14 +194,29 @@ def ensemble_kalman_filter_update( raise ValueError('Expected `observation_fn` to return an instance of ' '`MultivariateNormalLinearOperator`') - observation_particles = observation_particles_dist.sample(seed=seed) - observation_particles_covariance = _covariance(observation_particles) + # predicted_observation_particles = G(X) + E[η], + # and is shape [ensemble_size] + [observation_size]. + # Note that .mean() is the distribution mean, and the distribution is + # centered at the predicted observations. This is *not* the ensemble mean. + predicted_observation_particles = observation_particles_dist.mean() + # With μ the ensemble average operator. For V a batch of column vectors, + # let Vᵀ be a batch of row vectors. + # Cov(G(X)) = (G(X) - μ(G(X))) (G(X) - μ(G(X)))ᵀ + observation_particles_covariance = _covariance( + predicted_observation_particles) + + # covariance_between_state_and_predicted_observations + # Cov(X, G(X)) = (X - μ(X))(G(X) - μ(G(X)))ᵀ covariance_between_state_and_predicted_observations = tf.nest.map_structure( - lambda x: _covariance(x, observation_particles), state.particles) + lambda x: _covariance(x, predicted_observation_particles), + state.particles) - observation_particles_diff = observation - observation_particles + # observation_particles_diff = Y - G(X) - η + observation_particles_diff = ( + observation - observation_particles_dist.sample(seed=seed)) + # = Cov(G(X)) + Γ observation_particles_covariance = ( observation_particles_covariance + observation_particles_dist.covariance()) @@ -212,15 +239,22 @@ def ensemble_kalman_filter_update( # observations is large. We can use the Sherman-Woodbury-Morrison # identity in this case. + # added_term = [Cov(G(X)) + Γ]⁻¹ [Y - G(X) - η] observation_particles_cholesky = tf.linalg.cholesky( observation_particles_covariance) added_term = tf.squeeze(tf.linalg.cholesky_solve( observation_particles_cholesky, observation_particles_diff[..., tf.newaxis]), axis=-1) + # added_term + # = covariance_between_state_and_predicted_observations @ added_term + # = Cov(X, G(X)) [Cov(G(X)) + Γ]⁻¹ [Y - G(X) - η] + # = (X - μ(X))(G(X) - μ(G(X)))ᵀ [Cov(G(X)) + Γ]⁻¹ [Y - G(X) - η] added_term = tf.nest.map_structure( lambda x: tf.linalg.matvec(x, added_term), covariance_between_state_and_predicted_observations) + + # new_particles = X + damping * added_term new_particles = tf.nest.map_structure( lambda x, a: x + damping * a, state.particles, added_term) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py index 3113ee802e..91f7255878 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py @@ -14,6 +14,7 @@ # ============================================================================ """Tests for the Ensemble Kalman Filter.""" +import collections # Dependency imports import numpy as np @@ -21,12 +22,14 @@ import tensorflow.compat.v2 as tf import tensorflow_probability as tfp +from tensorflow_probability.python.internal import test_combinations from tensorflow_probability.python.internal import test_util - tfd = tfp.distributions tfs = tfp.experimental.sequential +NUMPY_MODE = False + @test_util.test_all_tf_execution_regimes class EnsembleKalmanFilterTest(test_util.TestCase): @@ -53,8 +56,8 @@ def observation_fn(_, particles, extra): return tfd.MultivariateNormalDiag(loc=particles, scale_diag=[1e-2]), extra # Initialize the ensemble. - particles = self.evaluate(tf.random.normal( - shape=[100, 1], seed=test_util.test_seed())) + particles = self.evaluate( + tf.random.normal(shape=[100, 1], seed=test_util.test_seed())) state = tfs.EnsembleKalmanFilterState( step=0, particles=particles, extra={'unchanged': 1}) @@ -103,13 +106,17 @@ def test_ensemble_kalman_filter_linear_model(self): # so we are estimating a constant. def transition_fn(_, particles, extra): - particles = {'x': particles['x'] + particles['xdot'], - 'xdot': particles['xdot']} + particles = { + 'x': particles['x'] + particles['xdot'], + 'xdot': particles['xdot'] + } extra['transition_count'] += 1 - return tfd.JointDistributionNamed(dict( - x=tfd.MultivariateNormalDiag(loc=particles['x'], scale_diag=[1e-11]), - xdot=tfd.MultivariateNormalDiag( - particles['xdot'], scale_diag=[1e-11]))), extra + return tfd.JointDistributionNamed( + dict( + x=tfd.MultivariateNormalDiag( + loc=particles['x'], scale_diag=[1e-11]), + xdot=tfd.MultivariateNormalDiag( + particles['xdot'], scale_diag=[1e-11]))), extra def observation_fn(_, particles, extra): extra['observation_count'] += 1 @@ -120,15 +127,21 @@ def observation_fn(_, particles, extra): # Initialize the ensemble. particles = { - 'x': self.evaluate(tf.random.normal( - shape=[300, 5, 1], seed=seed_stream())), - 'xdot': self.evaluate(tf.random.normal( - shape=[300, 5, 1], seed=seed_stream())) + 'x': + self.evaluate( + tf.random.normal(shape=[300, 5, 1], seed=seed_stream())), + 'xdot': + self.evaluate( + tf.random.normal(shape=[300, 5, 1], seed=seed_stream())) } state = tfs.EnsembleKalmanFilterState( - step=0, particles=particles, extra={ - 'observation_count': 0, 'transition_count': 0}) + step=0, + particles=particles, + extra={ + 'observation_count': 0, + 'transition_count': 0 + }) for i in range(5): state = tfs.ensemble_kalman_filter_predict( @@ -148,8 +161,10 @@ def observation_fn(_, particles, extra): self.assertIn('observation_count', state.extra) self.assertEqual(i + 1, state.extra['observation_count']) - self.assertAllClose([4.] * 5, self.evaluate( - tf.reduce_mean(state.particles['x'], axis=[0, -1])), rtol=0.05) + self.assertAllClose( + [4.] * 5, + self.evaluate(tf.reduce_mean(state.particles['x'], axis=[0, -1])), + rtol=0.05) def test_ensemble_kalman_filter_constant_model_multivariate(self): @@ -164,8 +179,9 @@ def observation_fn(_, particles, extra): seed_stream = test_util.test_seed_stream() # Initialize the ensemble. - particles = self.evaluate(tf.random.normal( - shape=[300, 3, 2], seed=seed_stream(), dtype=tf.float64)) + particles = self.evaluate( + tf.random.normal( + shape=[300, 3, 2], seed=seed_stream(), dtype=tf.float64)) state = tfs.EnsembleKalmanFilterState( step=0, particles=particles, extra={'unchanged': 1}) @@ -183,19 +199,25 @@ def observation_fn(_, particles, extra): observation_fn=observation_fn, seed=seed_stream()) - self.assertAllClose([[0., 0.]] * 3, self.evaluate( - tf.reduce_mean(state.particles, axis=0)), atol=1e-2) + self.assertAllClose( + [[0., 0.]] * 3, + self.evaluate(tf.reduce_mean(state.particles, axis=0)), + atol=1e-2) def test_ensemble_kalman_filter_linear_model_multivariate(self): def transition_fn(_, particles, extra): - particles = {'x': particles['x'] + particles['xdot'], - 'xdot': particles['xdot']} + particles = { + 'x': particles['x'] + particles['xdot'], + 'xdot': particles['xdot'] + } extra['transition_count'] += 1 - return tfd.JointDistributionNamed(dict( - x=tfd.MultivariateNormalDiag(particles['x'], scale_diag=[1e-11] * 2), - xdot=tfd.MultivariateNormalDiag( - particles['xdot'], scale_diag=[1e-11] * 2))), extra + return tfd.JointDistributionNamed( + dict( + x=tfd.MultivariateNormalDiag( + particles['x'], scale_diag=[1e-11] * 2), + xdot=tfd.MultivariateNormalDiag( + particles['xdot'], scale_diag=[1e-11] * 2))), extra def observation_fn(_, particles, extra): extra['observation_count'] += 1 @@ -207,15 +229,25 @@ def observation_fn(_, particles, extra): # Initialize the ensemble. particles_shape = (300, 3, 2) particles = { - 'x': self.evaluate(tf.random.normal( - shape=particles_shape, seed=seed_stream(), dtype=tf.float64)), - 'xdot': self.evaluate(tf.random.normal( - shape=particles_shape, seed=seed_stream(), dtype=tf.float64)) + 'x': + self.evaluate( + tf.random.normal( + shape=particles_shape, seed=seed_stream(), + dtype=tf.float64)), + 'xdot': + self.evaluate( + tf.random.normal( + shape=particles_shape, seed=seed_stream(), + dtype=tf.float64)) } state = tfs.EnsembleKalmanFilterState( - step=0, particles=particles, extra={ - 'observation_count': 0, 'transition_count': 0}) + step=0, + particles=particles, + extra={ + 'observation_count': 0, + 'transition_count': 0 + }) for i in range(10): # Predict. @@ -253,12 +285,279 @@ def observation_fn(_, particles, extra): observation=observation, observation_fn=observation_fn, seed=seed_stream()) - print(self.evaluate( - tf.reduce_mean(state.particles['x'], axis=0))) + print(self.evaluate(tf.reduce_mean(state.particles['x'], axis=0))) self.assertEqual(3 * i + 3, state.extra['observation_count']) - self.assertAllClose([[9., 18.]] * 3, self.evaluate( - tf.reduce_mean(state.particles['x'], axis=0)), rtol=0.05) + self.assertAllClose( + [[9., 18.]] * 3, + self.evaluate(tf.reduce_mean(state.particles['x'], axis=0)), + rtol=0.05) + + +# Parameters defining a linear/Gaussian state space model. +LinearModelParams = collections.namedtuple('LinearModelParams', [ + 'dtype', + 'n_states', + 'n_observations', + 'prior_mean', + 'prior_cov', + 'transition_mat', + 'observation_mat', + 'transition_cov', + 'observation_noise_cov', +]) + +# Parameters specific to an EnKF. Used together with LinearModelParams. +EnKFParams = collections.namedtuple( + 'EnKFParams', ['n_ensemble', 'state', 'observation_fn', 'transition_fn']) + + +@test_util.test_all_tf_execution_regimes +class KalmanFilterVersusEnKFTest(test_util.TestCase): + """Compare KF to EnKF with large ensemble sizes. + + If the model is linear and Gaussian the EnKF sample mean/cov and marginal + likelihood converges to that of a KF in the large ensemble limit. + + This class tests that they are the same. It does that by implementing a + one-step KF. It also does some simple checks on the KF, to make sure we didn't + just replicate misunderstanding in the EnKF. + """ + + def _random_spd_matrix(self, n, noise_level, seed, dtype): + """Random SPD matrix with inflated diagonal.""" + wigner_mat = ( + tf.random.normal(shape=[n, n], seed=seed, dtype=dtype) / + tf.sqrt(tf.cast(n, dtype))) + eye = tf.linalg.eye(n, dtype=dtype) + return noise_level**2 * ( + tf.linalg.matmul(wigner_mat, wigner_mat, adjoint_b=True) + 0.5 * eye) + + def _get_linear_model_params( + self, + noise_level, + n_states, + n_observations, + seed_stream, + dtype, + ): + """Get parameters defining a linear state space model (for KF & EnKF).""" + + def _normal(shape): + return tf.random.normal(shape, seed=seed_stream(), dtype=dtype) + + def _uniform(shape): + return tf.random.uniform( + # Setting minval > 0 helps test with rtol. + shape, + minval=1.0, + maxval=2.0, + seed=seed_stream(), + dtype=dtype) + + return LinearModelParams( + dtype=dtype, + n_states=n_states, + n_observations=n_observations, + prior_mean=_uniform([n_states]), + prior_cov=self._random_spd_matrix( + n_states, 1.0, seed_stream(), dtype=dtype), + transition_mat=_normal([n_states, n_states]), + observation_mat=_normal([n_observations, n_states]), + transition_cov=self._random_spd_matrix( + n_states, noise_level, seed_stream(), dtype=dtype), + observation_noise_cov=self._random_spd_matrix( + n_observations, noise_level, seed_stream(), dtype=dtype), + ) + + def _kalman_filter_solve(self, observation, linear_model_params): + """Solve one assimilation step using a KF.""" + # See http://screen/tnjSAEuo5nPKmYt for equations. + # pylint: disable=unnecessary-lambda + p = linear_model_params # Simple & Sweet + + # With A, B matrices and x a vector, we define the operations... + a_x = lambda a, x: tf.linalg.matvec(a, x) # Ax + a_b = lambda a, b: tf.linalg.matmul(a, b) # AB + a_bt = lambda a, b: tf.linalg.matmul(a, b, adjoint_b=True) # ABᵀ + a_b_at = lambda c, d: a_b(c, a_bt(d, c)) # ABAᵀ + + predictive_mean = a_x(p.transition_mat, p.prior_mean) + predictive_cov = a_b_at(p.transition_mat, p.prior_cov) + p.transition_cov + + kalman_gain = a_b( + a_bt(predictive_cov, p.observation_mat), + tf.linalg.inv( + a_b_at(p.observation_mat, predictive_cov) + + p.observation_noise_cov)) + updated_mean = ( + predictive_mean + + a_x(kalman_gain, observation - a_x(p.observation_mat, predictive_mean))) + updated_cov = a_b( + tf.linalg.eye(p.n_states, dtype=p.dtype) - + a_b(kalman_gain, p.observation_mat), predictive_cov) + + # p(Y | X_{predictive}) + marginal_dist = tfd.MultivariateNormalTriL( + loc=a_x(p.observation_mat, predictive_mean), + scale_tril=tf.linalg.cholesky( + a_b_at(p.observation_mat, predictive_cov) + + p.observation_noise_cov), + ) + + return dict( + predictive_mean=predictive_mean, + predictive_cov=predictive_cov, + predictive_stddev=tf.sqrt(tf.linalg.diag_part(predictive_cov)), + updated_mean=updated_mean, + updated_cov=updated_cov, + updated_stddev=tf.sqrt(tf.linalg.diag_part(updated_cov)), + log_marginal_likelihood=marginal_dist.log_prob(observation), + ) + # pylint: enable=unnecessary-lambda + + def _get_enkf_params( + self, + n_ensemble, + linear_model_params, + prior_dist, + seed_stream, + dtype, + ): + """Get parameters specific to EnKF reconstructions.""" + particles = prior_dist.sample(n_ensemble, seed=seed_stream()) + state = tfs.EnsembleKalmanFilterState(step=0, particles=particles, extra={}) + + def observation_fn(_, particles, extra): + observation_particles_dist = tfd.MultivariateNormalTriL( + loc=tf.linalg.matvec(linear_model_params.observation_mat, particles), + scale_tril=tf.linalg.cholesky( + linear_model_params.observation_noise_cov)) + return observation_particles_dist, extra + + def transition_fn(_, particles, extra): + new_particles_dist = tfd.MultivariateNormalTriL( + loc=tf.linalg.matvec(linear_model_params.transition_mat, particles), + scale_tril=tf.linalg.cholesky(linear_model_params.transition_cov)) + return new_particles_dist, extra + + return EnKFParams( + state=state, + n_ensemble=n_ensemble, + observation_fn=observation_fn, + transition_fn=transition_fn, + ) + + def _enkf_solve(self, observation, enkf_params, predict_kwargs, update_kwargs, + log_marginal_likelihood_kwargs, seed_stream): + """Solve one data assimilation step using an EnKF.""" + predicted_state = tfs.ensemble_kalman_filter_predict( + enkf_params.state, + enkf_params.transition_fn, + seed=seed_stream(), + **predict_kwargs) + updated_state = tfs.ensemble_kalman_filter_update( + predicted_state, + observation, + enkf_params.observation_fn, + seed=seed_stream(), + **update_kwargs) + log_marginal_likelihood = tfs.ensemble_kalman_filter_log_marginal_likelihood( + predicted_state, + observation, + enkf_params.observation_fn, + seed=seed_stream(), + **log_marginal_likelihood_kwargs) + + return dict( + predictive_mean=tf.reduce_mean(predicted_state.particles, axis=0), + predictive_cov=tfp.stats.covariance(predicted_state.particles), + predictive_stddev=tfp.stats.stddev(predicted_state.particles), + updated_mean=tf.reduce_mean(updated_state.particles, axis=0), + updated_cov=tfp.stats.covariance(updated_state.particles), + updated_stddev=tfp.stats.stddev(updated_state.particles), + log_marginal_likelihood=log_marginal_likelihood, + ) + + @test_combinations.generate( + test_combinations.combine( + noise_level=[0.001, 0.1, 1.0], + n_states=[2, 5], + n_observations=[2, 5], + )) + def test_same_solution(self, noise_level, n_states, n_observations): + """Check that the KF and EnKF solutions are the same.""" + # Tests pass with n_ensemble = 1e7. The KF vs. EnKF tolerance is + # proportional to 1 / sqrt(n_ensemble), so this shows good agreement. + n_ensemble = int(1e4) if NUMPY_MODE else int(1e6) + + salt = str(noise_level) + str(n_states) + str(n_observations) + seed_stream = test_util.test_seed_stream(salt) + dtype = tf.float64 + predict_kwargs = {} + update_kwargs = {} + log_marginal_likelihood_kwargs = {} + + linear_model_params = self._get_linear_model_params( + noise_level=noise_level, + n_states=n_states, + n_observations=n_observations, + seed_stream=seed_stream, + dtype=dtype) + + # Ensure that our observation comes from a state that ~ prior. + prior_dist = tfd.MultivariateNormalTriL( + loc=linear_model_params.prior_mean, + scale_tril=tf.linalg.cholesky(linear_model_params.prior_cov)) + true_state = prior_dist.sample(seed=seed_stream()) + observation = tf.linalg.matvec(linear_model_params.observation_mat, + true_state) + + kf_soln = self._kalman_filter_solve(observation, linear_model_params) + + enkf_params = self._get_enkf_params(n_ensemble, linear_model_params, + prior_dist, seed_stream, dtype) + enkf_soln = self._enkf_solve(observation, enkf_params, predict_kwargs, + update_kwargs, log_marginal_likelihood_kwargs, + seed_stream) + + # In the low noise limit, the spectral norm of the posterior covariance is + # bounded by reconstruction_tol**2. + # http://screen/96UV8kiXMvp8QSM + reconstruction_tol = noise_level / tf.reduce_min( + tf.linalg.svd(linear_model_params.observation_mat, compute_uv=False)) + + # Evaluate at the same time, so both use the same randomness! + # Do not use anything that was not evaluated here! + true_state, reconstruction_tol, kf_soln, enkf_soln = self.evaluate( + [true_state, reconstruction_tol, kf_soln, enkf_soln]) + + max_updated_scale = self.evaluate( + tf.sqrt( + tf.reduce_max( + tf.linalg.svd(kf_soln['updated_cov'], compute_uv=False)))) + + if noise_level < 0.2 and n_states == n_observations: + # Check that the theoretical error bound is obeyed. + # We use max_updated_scale below to check reconstruction error, but + # without this check here, it's possible that max_updated_scale is large + # due to some error in the kalman filter...which would invalidate checks + # below. + slop = 2. + 5 * noise_level + self.assertLess(max_updated_scale, slop * reconstruction_tol) + + # The KF should reconstruct the correct value up to 5 stddevs. + # The relevant stddev is that of a χ² random variable. + reconstruction_error = np.linalg.norm( + kf_soln['updated_mean'] - true_state, axis=-1) + self.assertLess(reconstruction_error, + 5 * np.sqrt(2 * n_states) * max_updated_scale) + + # We know the EnKF converges at rate 1 / Sqrt(n_ensemble). The factor in + # front is set empirically. + tol_scale = 1 / np.sqrt(n_ensemble) # 1 / Sqrt(1e6) = 0.001 + self.assertAllCloseNested( + kf_soln, enkf_soln, atol=20 * tol_scale, rtol=50 * tol_scale) if __name__ == '__main__': From 61ad84fa42d52e1771c5b245dfa63cdb0c0fee64 Mon Sep 17 00:00:00 2001 From: langmore Date: Mon, 16 May 2022 11:20:09 -0700 Subject: [PATCH 132/153] Add docstring comment clarifying what batch_interp_regular_nd_grid does. PiperOrigin-RevId: 449009095 --- tensorflow_probability/python/math/interpolation.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/math/interpolation.py b/tensorflow_probability/python/math/interpolation.py index 2cce32fc59..0e5174e5a8 100644 --- a/tensorflow_probability/python/math/interpolation.py +++ b/tensorflow_probability/python/math/interpolation.py @@ -493,7 +493,9 @@ def batch_interp_regular_nd_grid(x, """Multi-linear interpolation on a regular (constant spacing) grid. Given [a batch of] reference values, this function computes a multi-linear - interpolant and evaluates it on [a batch of] of new `x` values. + interpolant and evaluates it on [a batch of] of new `x` values. This is a + multi-dimensional generalization of [Bilinear Interpolation]( + https://en.wikipedia.org/wiki/Bilinear_interpolation). The interpolant is built from reference values indexed by `nd` dimensions of `y_ref`, starting at `axis`. From 91f7426f9eaf64f3e69e9651ce4ddac108398108 Mon Sep 17 00:00:00 2001 From: langmore Date: Wed, 18 May 2022 15:53:27 -0700 Subject: [PATCH 133/153] Documentation update for TFP/experimenta/sequential/EnKF PiperOrigin-RevId: 449597861 --- .../sequential/ensemble_kalman_filter.py | 92 ++++++++++++++----- 1 file changed, 69 insertions(+), 23 deletions(-) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py index 28505b8317..91bbfae563 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py @@ -81,15 +81,24 @@ def ensemble_kalman_filter_predict( seed=None, inflate_fn=None, name=None): - """Ensemble Kalman Filter Prediction. + """Ensemble Kalman filter prediction step. The [Ensemble Kalman Filter]( https://en.wikipedia.org/wiki/Ensemble_Kalman_filter) is a Monte Carlo - version of the traditional Kalman Filter. + version of the traditional Kalman Filter. See also [2]. It assumes the model - This method is the 'prediction' equation associated with the Ensemble - Kalman Filter. This takes in an optional `inflate_fn` to perform covariance - inflation on the ensemble [2]. + ``` + X[t] ~ transition_fn(X[t-1]) + Y[t] ~ observation_fn(X[t]) + ``` + + Given the ensemble `state.particles` sampled from `P(X[t-1] | Y[t-1])`, this + function produces the predicted (a.k.a. forecast or background) ensemble + sampled from `P(X[t] | Y[t-1])`. This is the predicted next state *before* + assimilating the observation `Y[t]`. + + Typically, with `F` some deterministic mapping, `transition_fn(X)` returns a + normal distribution centered at `F(X)`. Args: state: Instance of `EnsembleKalmanFilterState`. @@ -98,10 +107,10 @@ def ensemble_kalman_filter_predict( Each component should be an instance of `MultivariateNormalLinearOperator`. seed: PRNG seed; see `tfp.random.sanitize_seed` for details. - inflate_fn: Function that takes in the `particles` and returns a - new set of `particles`. Used for inflating the covariance of points. - Note this function should try to preserve the sample mean of the - particles, and scale up the sample covariance. + inflate_fn: Function that takes in the `particles` and returns a new set of + `particles`. Used for inflating the covariance of points. Note this + function should try to preserve the sample mean of the particles, and + scale up the sample covariance [3]. name: Python `str` name for ops created by this method. Default value: `None` (i.e., `'ensemble_kalman_filter_predict'`). @@ -115,7 +124,11 @@ def ensemble_kalman_filter_predict( quasi-geostrophic model using Monte Carlo methods to forecast error statistics. Journal of Geophysical Research, 1994. - [2] Jeffrey L. Anderson and Stephen L. Anderson. A Monte Carlo Implementation + [2] Matthias Katzfuss, Jonathan R. Stroud & Christopher K. Wikle + Understanding the Ensemble Kalman Filter. + The Americal Statistician, 2016. + + [3] Jeffrey L. Anderson and Stephen L. Anderson. A Monte Carlo Implementation of the Nonlinear Filtering Problem to Produce Ensemble Assimilations and Forecasts. Monthly Weather Review, 1999. @@ -142,16 +155,23 @@ def ensemble_kalman_filter_update( damping=1., seed=None, name=None): - """Ensemble Kalman Filter Update. + """Ensemble Kalman filter update step. The [Ensemble Kalman Filter]( https://en.wikipedia.org/wiki/Ensemble_Kalman_filter) is a Monte Carlo - version of the traditional Kalman Filter. + version of the traditional Kalman Filter. See also [2]. It assumes the model + + ``` + X[t] ~ transition_fn(X[t-1]) + Y[t] ~ observation_fn(X[t]) + ``` + + Given the ensemble `state.particles` sampled from `P(X[t] | Y[t-1])`, this + function assimilates obervation `Y[t]` to produce the updated ensemble sampled + from `P(X[t] | Y[t])`. - This method is the 'update' equation associated with the Ensemble - Kalman Filter. As the ensemble size goes to infinity, the EnKF sample mean and - covariance match that of the true posterior (under a Linear Gaussian State - Space Model). + Typically, with `G` some deterministic observation mapping, + `observation_fn(X)` returns a normal distribution centered at `G(X)`. Args: state: Instance of `EnsembleKalmanFilterState`. @@ -168,6 +188,16 @@ def ensemble_kalman_filter_update( Returns: next_state: `EnsembleKalmanFilterState` representing particles at next timestep, after applying Kalman update equations. + + #### References + + [1] Geir Evensen. Sequential data assimilation with a nonlinear + quasi-geostrophic model using Monte Carlo methods to forecast error + statistics. Journal of Geophysical Research, 1994. + + [2] Matthias Katzfuss, Jonathan R. Stroud & Christopher K. Wikle + Understanding the Ensemble Kalman Filter. + The Americal Statistician, 2016. """ with tf.name_scope(name or 'ensemble_kalman_filter_update'): @@ -195,7 +225,7 @@ def ensemble_kalman_filter_update( '`MultivariateNormalLinearOperator`') # predicted_observation_particles = G(X) + E[η], - # and is shape [ensemble_size] + [observation_size]. + # and is shape [n_ensemble] + [observation_size] # Note that .mean() is the distribution mean, and the distribution is # centered at the predicted observations. This is *not* the ensemble mean. predicted_observation_particles = observation_particles_dist.mean() @@ -268,17 +298,23 @@ def ensemble_kalman_filter_log_marginal_likelihood( observation_fn, seed=None, name=None): - """Ensemble Kalman Filter Log Marginal Likelihood. + """Ensemble Kalman filter log marginal likelihood. The [Ensemble Kalman Filter]( https://en.wikipedia.org/wiki/Ensemble_Kalman_filter) is a Monte Carlo - version of the traditional Kalman Filter. + version of the traditional Kalman Filter. See also [2]. It assumes the model + + ``` + X[t] ~ transition_fn(X[t-1]) + Y[t] ~ observation_fn(X[t]) + ``` This method estimates (logarithm of) the marginal likelihood of the - observation at step `k`, `Y_k`, given previous observations from steps - `1` to `k-1`, `Y_{1:k}`. In other words, `Log[p(Y_k | Y_{1:k})]`. - This function's approximation to `p(Y_k | Y_{1:k})` is correct under a - Linear Gaussian state space model assumption, as ensemble size --> infinity. + observation at step `t`, `Y[t]`, given `state`. Typically, `state` is the + predictive ensemble at time `t`. In that case, this function approximates + `Log[p(Y[t] | Y[t-1], Y[t-2],...)]` + The approximation is correct under a Linear Gaussian state space model + assumption, as ensemble size --> infinity. Args: state: Instance of `EnsembleKalmanFilterState` at step `k`, @@ -295,6 +331,16 @@ def ensemble_kalman_filter_log_marginal_likelihood( Returns: log_marginal_likelihood: `Tensor` with same dtype as `state`. + + #### References + + [1] Geir Evensen. Sequential data assimilation with a nonlinear + quasi-geostrophic model using Monte Carlo methods to forecast error + statistics. Journal of Geophysical Research, 1994. + + [2] Matthias Katzfuss, Jonathan R. Stroud & Christopher K. Wikle + Understanding the Ensemble Kalman Filter. + The Americal Statistician, 2016. """ with tf.name_scope(name or 'ensemble_kalman_filter_log_marginal_likelihood'): From ffe050ca936dbe83c49a7f77f3be05a18d5f79e0 Mon Sep 17 00:00:00 2001 From: emilyaf Date: Thu, 19 May 2022 22:19:11 -0700 Subject: [PATCH 134/153] Use a static empty tensor for `event_shape` when GaussianProcess has a univariate marginal. PiperOrigin-RevId: 449906086 --- tensorflow_probability/python/distributions/gaussian_process.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_probability/python/distributions/gaussian_process.py b/tensorflow_probability/python/distributions/gaussian_process.py index 13cb8fc878..e3ad3d7896 100644 --- a/tensorflow_probability/python/distributions/gaussian_process.py +++ b/tensorflow_probability/python/distributions/gaussian_process.py @@ -602,7 +602,7 @@ def _log_prob(self, value, index_points=None, is_missing=None): def _event_shape_tensor(self, index_points=None): index_points = self._get_index_points(index_points) if self._is_univariate_marginal(index_points): - return tf.constant([], dtype=tf.int32) + return ps.constant([], dtype=tf.int32) else: # The examples index is one position to the left of the feature dims. examples_index = -(self.kernel.feature_ndims + 1) From 8ce12fb50d6c5f3850eecb92f90df209e44ad281 Mon Sep 17 00:00:00 2001 From: langmore Date: Mon, 23 May 2022 11:26:55 -0700 Subject: [PATCH 135/153] Extract covariance from MVN in an efficient way. Previously, we called `dist.covariance()`, which broadcasts the covariance matrix across the ensemble. In turn this required a `n_ensemble` size Cholesky (of identical matrices). PiperOrigin-RevId: 450485969 --- .../sequential/ensemble_kalman_filter.py | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py index 91bbfae563..1abaf71631 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py @@ -249,7 +249,15 @@ def ensemble_kalman_filter_update( # = Cov(G(X)) + Γ observation_particles_covariance = ( observation_particles_covariance + - observation_particles_dist.covariance()) + # Calling _linop_covariance(...).to_dense() rather than + # observation_particles_dist.covariance() means the shape is + # [observation_size, observation_size] rather than + # [ensemble_size] + [observation_size, observation_size]. + # Both work, since this matrix is used to do mat-vecs with ensembles + # of vectors...however, doing things this way ensures we do an + # efficient batch-matmul and (more importantly) don't have to do a + # separate Cholesky for every ensemble member! + _linop_covariance(observation_particles_dist).to_dense()) # We specialize the univariate case. # TODO(srvasude): Refactor linear_gaussian_ssm, normal_conjugate_posteriors @@ -363,3 +371,20 @@ def ensemble_kalman_filter_log_marginal_likelihood( scale_tril=tf.linalg.cholesky(_covariance(observation_particles))) return observation_dist.log_prob(observation) + + +def _linop_covariance(dist): + """LinearOperator backing Cov(dist), without unnecessary broadcasting.""" + # This helps, even if we immediately call .to_dense(). Why? + # Simply calling dist.covariance() would broadcast up to the full batch shape. + # Instead, we want the shape to be that of the linear operator only. + # This (i) saves memory and (ii) allows operations done with this operator + # to be more efficient. + if hasattr(dist, 'cov_operator'): + cov = dist.cov_operator + else: + cov = dist.scale.matmul(dist.scale.H) + # TODO(b/132466537) composition doesn't preserve SPD so we have to hard-set. + cov._is_positive_definite = True # pylint: disable=protected-access + cov._is_self_adjoint = True # pylint: disable=protected-access + return cov From 89d248c420b8ecabfd9d6de4a1aa8d3886920049 Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Mon, 23 May 2022 14:43:51 -0700 Subject: [PATCH 136/153] Improvements to Variational Gaussian Process. - Add VGPKernel.matrix() method to the vgp kernel for more efficient inner kernel use. - Add `cholesky_fn` argument to allow for custom cholesky functions. - Rewrite VGPKernel.apply() to avoid a solve when computing VGP variance, and a transpose. PiperOrigin-RevId: 450529221 --- .../stochastic_process_properties_test.py | 2 +- .../variational_gaussian_process.py | 99 ++++++++++++++----- .../variational_gaussian_process_test.py | 36 +++++++ 3 files changed, 109 insertions(+), 28 deletions(-) diff --git a/tensorflow_probability/python/distributions/stochastic_process_properties_test.py b/tensorflow_probability/python/distributions/stochastic_process_properties_test.py index 8529ae16af..38d3cc0154 100644 --- a/tensorflow_probability/python/distributions/stochastic_process_properties_test.py +++ b/tensorflow_probability/python/distributions/stochastic_process_properties_test.py @@ -45,7 +45,7 @@ MAX_CONVERSIONS_BY_CLASS = dict( GaussianProcessRegressionModel=4, StudentTProcessRegressionModel=4, - VariationalGaussianProcess=9) + VariationalGaussianProcess=10) def _stochastic_process_specific_hp_settings(test_method): diff --git a/tensorflow_probability/python/distributions/variational_gaussian_process.py b/tensorflow_probability/python/distributions/variational_gaussian_process.py index 48478e8577..a16c08be70 100644 --- a/tensorflow_probability/python/distributions/variational_gaussian_process.py +++ b/tensorflow_probability/python/distributions/variational_gaussian_process.py @@ -20,6 +20,7 @@ from tensorflow_probability.python import util as tfp_util from tensorflow_probability.python.bijectors import fill_scale_tril as fill_scale_tril_bijector from tensorflow_probability.python.bijectors import softplus as softplus_bijector +from tensorflow_probability.python.distributions import cholesky_util from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.distributions import gaussian_process from tensorflow_probability.python.distributions import independent @@ -88,6 +89,7 @@ def __init__(self, base_kernel, inducing_index_points, variational_scale, + cholesky_fn=None, jitter=1e-6, name='VariationalKernel'): """Construct a _VariationalKernel instance. @@ -107,8 +109,13 @@ def __init__(self, number of examples in `inducing_index_points`. Batch dimensions must be broadcast-compatible with the batch shape of `base_kernel` and `inducing_index_points`. + cholesky_fn: Callable which takes a single (batch) matrix argument and + returns a Cholesky-like lower triangular factor. Default value: `None`, + in which case `make_cholesky_with_jitter_fn` is used with the `jitter` + parameter. jitter: `float` scalar `Tensor` added to the diagonal of the covariance matrix to ensure positive definiteness of the covariance matrix. + This argument is ignored if `cholesky_fn` is set. Default value: `1e-6`. name: Python `str` name prefixed to `Op`A created by this class. Default value: `"VariationalKernel"` @@ -124,12 +131,16 @@ def __init__(self, inducing_index_points, dtype=dtype, name='inducing_index_points') self._variational_scale = tensor_util.convert_nonref_to_tensor( variational_scale, dtype=dtype, name='variational_scale') + self._cholesky_fn = cholesky_fn + + if cholesky_fn is None: + self._cholesky_fn = cholesky_util.make_cholesky_with_jitter_fn(jitter) self._jitter = tensor_util.convert_nonref_to_tensor( jitter, dtype=dtype, name='jitter') def _compute_chol_kzz(z): kzz = base_kernel.matrix(z, z) - result = tf.linalg.cholesky(_add_diagonal_shift(kzz, self._jitter)) + result = self._cholesky_fn(kzz) return result # Somewhat confusingly, but for the sake of brevity, we use `var` to refer @@ -193,13 +204,15 @@ def _apply(self, x1, x2, example_ndims=1): # Shape: bc(Bk, B1, B2) + bc(E1, E2) k12 = self._base_kernel.apply(x1, x2, example_ndims) + inducing_index_points = tf.convert_to_tensor(self._inducing_index_points) + # Shape: bc(Bk, B1, Bz) + E1 + [ez] - k1z = self._base_kernel.tensor(x1, self._inducing_index_points, + k1z = self._base_kernel.tensor(x1, inducing_index_points, x1_example_ndims=example_ndims, x2_example_ndims=1) # Shape: bc(Bk, B2, Bz) + E2 + [ez] - k2z = self._base_kernel.tensor(x2, self._inducing_index_points, + k2z = self._base_kernel.tensor(x2, inducing_index_points, x1_example_ndims=example_ndims, x2_example_ndims=1) @@ -207,19 +220,20 @@ def _apply(self, x1, x2, example_ndims=1): self._chol_kzz, example_ndims - 1, -3) kzzchol_linop = tf.linalg.LinearOperatorLowerTriangular(chol_kzz) - # Shape: bc(Bz, Bk, B2) + E2 + [ez] - kzzinv_kz2 = tf.linalg.matrix_transpose( - # Shape: bc(Bz, Bk, B2) + E2[:-1] + [ez] + E2[-1] - kzzchol_linop.solve( - # Shape: bc(Bz, Bk, B2) + E2[:-1] + [ez] + E2[-1] - kzzchol_linop.solve(k2z, adjoint_arg=True), - adjoint=True)) + # Write out both solves explicitly. This is so that in the case x1 == x2, + # CSE can ensure that only one solve / kernel computation is done. + kzz_chol_inv_kz2 = kzzchol_linop.solve(k2z, adjoint_arg=True) + kzz_chol_inv_kz1 = kzzchol_linop.solve(k1z, adjoint_arg=True) + + # Note: example_ndims will be 1 since this is only used in the + # `VariationalGaussianProcess` for stddev computations, hence + # we can explicitly use `axis=-2`. # Shape: bc(Bz, Bk, B1, B2) + bc(E1, E2) k1z_kzzinv_kz2 = tf.reduce_sum( - # Shape: bc(Bz, Bk, B1, B2) + bc(E1, E2) + [ez] - input_tensor=k1z * kzzinv_kz2, - axis=-1) + # Shape: bc(Bz, Bk, B1, B2) + [ez] + bc(E1, E2) + input_tensor=kzz_chol_inv_kz2 * kzz_chol_inv_kz1, + axis=-(example_ndims + 1)) # Do this c2t only once kzzinv_var_kzzinv = tf.convert_to_tensor(self._kzzinv_var_kzzinv) @@ -250,6 +264,32 @@ def _apply(self, x1, x2, example_ndims=1): return result + def _matrix(self, x1, x2): + k12 = self.base_kernel.matrix(x1, x2) + + inducing_index_points = tf.convert_to_tensor(self._inducing_index_points) + + k1z = self._base_kernel.matrix(x1, inducing_index_points) + k2z = self._base_kernel.matrix(x2, inducing_index_points) + + chol_kzz = self._chol_kzz + kzzchol_linop = tf.linalg.LinearOperatorLowerTriangular(chol_kzz) + + kzz_chol_inv_kz2 = kzzchol_linop.solve(k2z, adjoint_arg=True) + kzz_chol_inv_kz1 = kzzchol_linop.solve(k1z, adjoint_arg=True) + + k1z_kzzinv_kz2 = tf.linalg.matmul( + kzz_chol_inv_kz1, kzz_chol_inv_kz2, transpose_a=True) + + kzzinv_var_kzzinv = tf.convert_to_tensor(self._kzzinv_var_kzzinv) + + kzzinv_var_kzzinv_kz2 = tf.linalg.matmul( + kzzinv_var_kzzinv, k2z, adjoint_b=True) + + k1z_kzzinv_var_kzzinv_kz2 = tf.linalg.matmul(k1z, kzzinv_var_kzzinv_kz2) + + return k12 - k1z_kzzinv_kz2 + k1z_kzzinv_var_kzzinv_kz2 + def _make_posterior_predictive_mean_fn( kernel, @@ -261,13 +301,13 @@ def _make_posterior_predictive_mean_fn( def _post_pred_mean_fn(index_points): """The variatioanl posterior predictive mean function.""" + z = tf.convert_to_tensor(inducing_index_points) kzt = tf.linalg.LinearOperatorFullMatrix( - kernel.matrix(inducing_index_points, index_points)) + kernel.matrix(z, index_points)) kzzinv_varloc = _solve_cholesky_factored_system_vec( chol_kzz_fn(), - (variational_inducing_observations_loc - - mean_fn(inducing_index_points)), + (variational_inducing_observations_loc - mean_fn(z)), name='kzzinv_varloc') return (mean_fn(index_points) + @@ -276,11 +316,6 @@ def _post_pred_mean_fn(index_points): return _post_pred_mean_fn -def _add_diagonal_shift(matrix, shift): - return tf.linalg.set_diag( - matrix, tf.linalg.diag_part(matrix) + shift, name='add_diagonal_shift') - - def _solve_cholesky_factored_system( cholesky_factor, rhs, name=None): with tf.name_scope( @@ -732,6 +767,7 @@ def __init__(self, mean_fn=None, observation_noise_variance=None, predictive_noise_variance=None, + cholesky_fn=None, jitter=1e-6, validate_args=False, allow_nan_stats=False, @@ -784,6 +820,10 @@ def __init__(self, example, to omit predictive noise variance (by setting this to zero) to obtain noiseless posterior predictions of function values, conditioned on noisy observations. + cholesky_fn: Callable which takes a single (batch) matrix argument and + returns a Cholesky-like lower triangular factor. Default value: `None`, + in which case `make_cholesky_with_jitter_fn` is used with the `jitter` + parameter. jitter: `float` scalar `Tensor` added to the diagonal of the covariance matrix to ensure positive definiteness of the covariance matrix. Default value: `1e-6`. @@ -838,8 +878,6 @@ def __init__(self, name='predictive_noise_variance') if predictive_noise_variance is None: predictive_noise_variance = observation_noise_variance - jitter = tensor_util.convert_nonref_to_tensor( - jitter, dtype=dtype, name='jitter') self._kernel = kernel self._index_points = index_points @@ -880,6 +918,7 @@ def __init__(self, kernel, inducing_index_points, variational_inducing_observations_scale, + cholesky_fn=cholesky_fn, jitter=jitter) posterior_predictive_mean_fn = _make_posterior_predictive_mean_fn( @@ -894,6 +933,7 @@ def __init__(self, kernel=variational_kernel, mean_fn=posterior_predictive_mean_fn, index_points=index_points, + cholesky_fn=cholesky_fn, jitter=jitter, # What the GP super class calls "observation noise variance" we call # here the "predictive noise variance". We use the observation noise @@ -1198,6 +1238,7 @@ def optimal_variational_posterior( observations, observation_noise_variance, mean_fn=None, + cholesky_fn=None, jitter=1e-6, name=None): """Model selection for optimal variational hyperparameters. @@ -1239,6 +1280,10 @@ def optimal_variational_posterior( shape `[b1, ..., bB, f1, ..., fF]` and returns a `Tensor` whose shape is (broadcastable with) `[b1, ..., bB]`. Default value: `None` implies constant zero function. + cholesky_fn: Callable which takes a single (batch) matrix argument and + returns a Cholesky-like lower triangular factor. Default value: `None`, + in which case `make_cholesky_with_jitter_fn` is used with the `jitter` + parameter. jitter: `float` scalar `Tensor` added to the diagonal of the covariance matrix to ensure positive definiteness of the covariance matrix. Default value: `1e-6`. @@ -1277,6 +1322,8 @@ def optimal_variational_posterior( dtype=dtype, name='observation_noise_variance') jitter = tf.convert_to_tensor(jitter, dtype=dtype, name='jitter') + if cholesky_fn is None: + cholesky_fn = cholesky_util.make_cholesky_with_jitter_fn(jitter) # Default to a constant zero function. if mean_fn is None: @@ -1291,11 +1338,9 @@ def optimal_variational_posterior( noise_var_inv = tf.math.reciprocal(observation_noise_variance) - sigma_inv = _add_diagonal_shift( - kzz + noise_var_inv * tf.matmul(kzx, kzx, adjoint_b=True), - jitter) + sigma_inv = kzz + noise_var_inv * tf.matmul(kzx, kzx, adjoint_b=True) - chol_sigma_inv = tf.linalg.cholesky(sigma_inv) + chol_sigma_inv = cholesky_fn(sigma_inv) kzx_lin_op = tf.linalg.LinearOperatorFullMatrix(kzx) kzx_obs = kzx_lin_op.matvec( diff --git a/tensorflow_probability/python/distributions/variational_gaussian_process_test.py b/tensorflow_probability/python/distributions/variational_gaussian_process_test.py index 7d9843c299..cf2cb45335 100644 --- a/tensorflow_probability/python/distributions/variational_gaussian_process_test.py +++ b/tensorflow_probability/python/distributions/variational_gaussian_process_test.py @@ -275,6 +275,42 @@ def testVariationalLossShapes(self, is_static): observation_index_points=observation_index_points) self.assertAllEqual(vgp.batch_shape_tensor(), tf.shape(loss)) + def testCustomCholeskyFn(self): + def test_cholesky(x): + test_cholesky.cholesky_count += 1 + return tf.linalg.cholesky(tf.linalg.set_diag( + x, tf.linalg.diag_part(x) + 3.)) + test_cholesky.cholesky_count = 0 + + index_points = np.linspace(-4., 4., 5, dtype=np.float64)[..., np.newaxis] + inducing_index_points = np.linspace(-4., 4., 3, dtype=np.float64)[ + ..., np.newaxis] + + variational_inducing_observations_loc = np.zeros([3], dtype=np.float64) + variational_inducing_observations_scale = np.eye(3, dtype=np.float64) + + amplitude = np.float64(1.) + length_scale = np.float64(1.) + + jitter = np.float64(1e-6) + kernel = tfp.math.psd_kernels.ExponentiatedQuadratic( + amplitude, length_scale) + + vgp = tfd.VariationalGaussianProcess( + kernel=kernel, + index_points=index_points, + inducing_index_points=inducing_index_points, + variational_inducing_observations_loc=( + variational_inducing_observations_loc), + variational_inducing_observations_scale=( + variational_inducing_observations_scale), + observation_noise_variance=1e-6, + cholesky_fn=test_cholesky, + jitter=jitter) + self.evaluate(vgp.get_marginal_distribution().stddev()) + # Assert that the custom cholesky function is called at least once. + self.assertGreaterEqual(test_cholesky.cholesky_count, 1) + def testBernoulliLikelihood(self): kernel = tfp.math.psd_kernels.ExponentiatedQuadratic() num_predictive_points = 10 From 3a6f248c5b1fc389cb77226e92d51c170e132ab9 Mon Sep 17 00:00:00 2001 From: siege Date: Tue, 24 May 2022 16:36:43 -0700 Subject: [PATCH 137/153] FunMC: Use tree_util.tree_map instead of tree_util.tree_multimap to silence warning. PiperOrigin-RevId: 450797057 --- spinoffs/fun_mc/fun_mc/dynamic/backend_jax/util.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/spinoffs/fun_mc/fun_mc/dynamic/backend_jax/util.py b/spinoffs/fun_mc/fun_mc/dynamic/backend_jax/util.py index ea167aa344..2b2682fb16 100644 --- a/spinoffs/fun_mc/fun_mc/dynamic/backend_jax/util.py +++ b/spinoffs/fun_mc/fun_mc/dynamic/backend_jax/util.py @@ -47,7 +47,7 @@ def map_tree(fn, tree, *args): """Maps `fn` over the leaves of a nested structure.""" - return tree_util.tree_multimap(fn, tree, *args) + return tree_util.tree_map(fn, tree, *args) def flatten_tree(tree): @@ -66,7 +66,7 @@ def map_tree_up_to(shallow, fn, tree, *rest): def wrapper(_, *rest): return fn(*rest) - return tree_util.tree_multimap(wrapper, shallow, tree, *rest) + return tree_util.tree_map(wrapper, shallow, tree, *rest) def get_shallow_tree(is_leaf, tree): @@ -76,7 +76,7 @@ def get_shallow_tree(is_leaf, tree): def assert_same_shallow_tree(shallow, tree): """Asserts that `tree` has the same shallow structure as `shallow`.""" - # Do a dummy multimap for the side-effect of verifying that the structures are + # Do a dummy map for the side-effect of verifying that the structures are # the same. This doesn't catch all the errors we actually care about, sadly. map_tree_up_to(shallow, lambda *args: (), tree) From 5a059fcb3fc73d97985c0adb25526f4fadb8439d Mon Sep 17 00:00:00 2001 From: emilyaf Date: Wed, 25 May 2022 14:52:55 -0700 Subject: [PATCH 138/153] Pin hypothesis version as a temporary fix for OSS test failures. PiperOrigin-RevId: 451021110 --- testing/dependency_install_lib.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/testing/dependency_install_lib.sh b/testing/dependency_install_lib.sh index 45f3412103..575a228dbb 100644 --- a/testing/dependency_install_lib.sh +++ b/testing/dependency_install_lib.sh @@ -80,7 +80,8 @@ install_common_packages() { install_test_only_packages() { # The following unofficial dependencies are used only by tests. PIP_FLAGS=${1-} - python -m pip install $PIP_FLAGS hypothesis matplotlib mock mpmath scipy pandas optax + # TODO(b/233927309): Unpin hypothesis version. + python -m pip install $PIP_FLAGS hypothesis==6.46.7 matplotlib mock mpmath scipy pandas optax } dump_versions() { From 9f3f3902dc4a92870dabe22010b15411562c6401 Mon Sep 17 00:00:00 2001 From: pravnar Date: Wed, 25 May 2022 16:53:16 -0700 Subject: [PATCH 139/153] Internal change PiperOrigin-RevId: 451046918 --- .../python/bijectors/moyal_cdf.py | 9 ++-- .../distributions/transformed_distribution.py | 37 ++++++++++++-- .../bijectors/distribution_bijectors_test.py | 50 +++++++++++-------- .../experimental/util/jit_public_methods.py | 4 +- .../python/sts/forecast_test.py | 5 +- 5 files changed, 72 insertions(+), 33 deletions(-) diff --git a/tensorflow_probability/python/bijectors/moyal_cdf.py b/tensorflow_probability/python/bijectors/moyal_cdf.py index ddc821300d..dc604a94fd 100644 --- a/tensorflow_probability/python/bijectors/moyal_cdf.py +++ b/tensorflow_probability/python/bijectors/moyal_cdf.py @@ -109,14 +109,15 @@ def _forward(self, x): def _inverse(self, y): with tf.control_dependencies(self._maybe_assert_valid_y(y)): + np_dtype = dtype_util.as_numpy_dtype(y.dtype) return (self.loc - self.scale * - (np.log(2.) + 2. * tf.math.log(tfp_math.erfcinv(y)))) + (np.log(np_dtype(2.)) + 2. * tf.math.log(tfp_math.erfcinv(y)))) def _inverse_log_det_jacobian(self, y): with tf.control_dependencies(self._maybe_assert_valid_y(y)): - return (tf.math.square(tfp_math.erfcinv(y)) + - tf.math.log(self.scale) + 0.5 * np.log(np.pi) - - tf.math.log(tfp_math.erfcinv(y))) + np_dtype = dtype_util.as_numpy_dtype(y.dtype) + return (tf.math.square(tfp_math.erfcinv(y)) + tf.math.log(self.scale) + + 0.5 * np_dtype(np.log(np.pi)) - tf.math.log(tfp_math.erfcinv(y))) def _forward_log_det_jacobian(self, x): scale = tf.convert_to_tensor(self.scale) diff --git a/tensorflow_probability/python/distributions/transformed_distribution.py b/tensorflow_probability/python/distributions/transformed_distribution.py index 45686d870b..d7a2c40286 100644 --- a/tensorflow_probability/python/distributions/transformed_distribution.py +++ b/tensorflow_probability/python/distributions/transformed_distribution.py @@ -354,6 +354,13 @@ def _sample_and_log_prob(self, sample_shape, seed, **kwargs): tf.cast(fldj, base_distribution_log_prob.dtype)) def _log_prob(self, y, **kwargs): + if self.bijector._is_injective: # pylint: disable=protected-access + log_prob, _ = self.experimental_local_measure( + y, backward_compat=True, **kwargs) + return log_prob + + # TODO(b/197680518): Support base measure handling for non-injective + # bijectors. distribution_kwargs, bijector_kwargs = self._kwargs_split_fn(kwargs) # For caching to work, it is imperative that the bijector is the first to @@ -366,9 +373,6 @@ def _log_prob(self, y, **kwargs): ildj = self.bijector.inverse_log_det_jacobian( y, event_ndims=event_ndims, **bijector_kwargs) - if self.bijector._is_injective: # pylint: disable=protected-access - base_log_prob = self.distribution.log_prob(x, **distribution_kwargs) - return base_log_prob + tf.cast(ildj, base_log_prob.dtype) # Compute log_prob on each element of the inverse image. lp_on_fibers = [] @@ -596,6 +600,32 @@ def _default_event_space_bijector(self): self.distribution.experimental_default_event_space_bijector()) # pylint: enable=not-callable + def experimental_local_measure(self, y, backward_compat=False, **kwargs): + distribution_kwargs, bijector_kwargs = self._kwargs_split_fn(kwargs) + + # For caching to work, it is imperative that the bijector is the first to + # modify the input. + x = self.bijector.inverse(y, **bijector_kwargs) + event_ndims = self.bijector.inverse_event_ndims( + tf.nest.map_structure(ps.rank_from_shape, self._event_shape_tensor(), + self.event_shape), **bijector_kwargs) + + if self.bijector._is_injective: # pylint: disable=protected-access + local_measure_fn = self.distribution.experimental_local_measure + density_corr_fn = self.bijector.experimental_compute_density_correction + base_log_prob, tangent_space = local_measure_fn( + x, backward_compat=backward_compat, **distribution_kwargs) + correction, new_tangent_space = density_corr_fn( + x, + tangent_space, + backward_compat=backward_compat, + event_ndims=event_ndims, + **bijector_kwargs) + log_prob = base_log_prob - tf.cast(correction, base_log_prob.dtype) + return log_prob, new_tangent_space + else: + raise NotImplementedError + class TransformedDistribution( _TransformedDistribution, distribution_lib.AutoCompositeTensorDistribution): @@ -671,4 +701,3 @@ def _transformed_log_prob_ratio(p, x, q, y, name=None): ildj_ratio = ldj_ratio.inverse_log_det_jacobian_ratio( p.bijector, x, q.bijector, y, event_ndims) return base_log_prob_ratio + tf.cast(ildj_ratio, base_log_prob_ratio.dtype) - diff --git a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py index a1edd1b496..f0a001c3f3 100644 --- a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py +++ b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py @@ -42,12 +42,12 @@ 'LambertWNormal', # CDF gradient incorrect at 0. 'SigmoidBeta', # inverse CDF numerical precision issues for large x 'StudentT', # CDF gradient incorrect at 0 (and unstable near zero). - ) +) if JAX_MODE: PRECONDITIONING_FAILS_DISTS = ( 'VonMises', # Abstract eval for 'von_mises_cdf_jvp' not implemented. - ) + PRECONDITIONING_FAILS_DISTS + ) + PRECONDITIONING_FAILS_DISTS def _constrained_zeros_fn(shape, dtype, constraint_fn): @@ -60,15 +60,18 @@ class DistributionBijectorsTest(test_util.TestCase): def assertDistributionIsApproximatelyStandardNormal(self, dist, + rtol=1e-6, logprob_atol=1e-2, grad_atol=1e-2): """Verifies that dist's lps and gradients match those of Normal(0., 1.).""" batch_shape = dist.batch_shape_tensor() + def make_reference_values(event_shape): dist_shape = ps.concat([batch_shape, event_shape], axis=0) x = tf.reshape([-4., -2., 0., 2., 4.], ps.concat([[5], ps.ones_like(dist_shape)], axis=0)) return tf.broadcast_to(x, ps.concat([[5], dist_shape], axis=0)) + flat_event_shape = tf.nest.flatten(dist.event_shape_tensor()) zs = [make_reference_values(s) for s in flat_event_shape] lp_dist, grad_dist = tfp.math.value_and_gradient( @@ -83,11 +86,14 @@ def reference_value_and_gradient(z, event_shape): reference_vals_and_grads = [ reference_value_and_gradient(z, event_shape) for (z, event_shape) in zip(zs, flat_event_shape)] + lps_reference = [lp for lp, grad in reference_vals_and_grads] - self.assertAllClose(sum(lps_reference), lp_dist, atol=logprob_atol) + self.assertAllClose( + sum(lps_reference), lp_dist, rtol=rtol, atol=logprob_atol) grads_reference = [grad for lp, grad in reference_vals_and_grads] - self.assertAllCloseNested(grads_reference, grad_dist, atol=grad_atol) + self.assertAllCloseNested( + grads_reference, grad_dist, rtol=rtol, atol=grad_atol) @parameterized.named_parameters( {'testcase_name': dname, 'dist_name': dname} @@ -101,10 +107,11 @@ def test_all_distributions_either_work_or_raise_error(self, dist_name, data): if dist_name in PRECONDITIONING_FAILS_DISTS: self.skipTest('Known failure.') - dist = data.draw(dhps.base_distributions( - dist_name=dist_name, - enable_vars=False, - param_strategy_fn=_constrained_zeros_fn)) + dist = data.draw( + dhps.base_distributions( + dist_name=dist_name, + enable_vars=False, + param_strategy_fn=_constrained_zeros_fn)) try: b = tfp.experimental.bijectors.make_distribution_bijector(dist) except NotImplementedError: @@ -114,22 +121,20 @@ def test_all_distributions_either_work_or_raise_error(self, dist_name, data): @test_util.numpy_disable_gradient_test def test_multivariate_normal(self): - d = tfd.MultivariateNormalFullCovariance(loc=[4., 8.], - covariance_matrix=[[11., 0.099], - [0.099, 0.1]]) + d = tfd.MultivariateNormalFullCovariance( + loc=[4., 8.], covariance_matrix=[[11., 0.099], [0.099, 0.1]]) b = tfp.experimental.bijectors.make_distribution_bijector(d) - self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d)) + self.assertDistributionIsApproximatelyStandardNormal(tfb.Invert(b)(d)) @test_util.numpy_disable_gradient_test def test_markov_chain(self): d = tfd.MarkovChain( initial_state_prior=tfd.Uniform(low=0., high=1.), transition_fn=lambda _, x: tfd.Uniform(low=0., high=tf.nn.softplus(x)), - num_steps=10) + num_steps=3) b = tfp.experimental.bijectors.make_distribution_bijector(d) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d)) + tfb.Invert(b)(d), rtol=1e-4) @test_util.numpy_disable_gradient_test def test_markov_chain_joint(self): @@ -145,7 +150,7 @@ def test_markov_chain_joint(self): num_steps=10) b = tfp.experimental.bijectors.make_distribution_bijector(d) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(d)) + tfb.Invert(b)(d), rtol=1e-4) @test_util.numpy_disable_gradient_test def test_nested_joint_distribution(self): @@ -153,13 +158,14 @@ def test_nested_joint_distribution(self): def model(): x = yield tfd.Normal(loc=-2., scale=1.) yield tfd.JointDistributionSequentialAutoBatched([ - tfd.Uniform(low=1. + tf.exp(x), - high=1 + tf.exp(x) + tf.nn.softplus(x)), + tfd.Uniform(low=1. - tf.exp(x), + high=2. + tf.exp(x) + tf.nn.softplus(x)), lambda v: tfd.Exponential(v)]) # pylint: disable=unnecessary-lambda + dist = tfd.JointDistributionCoroutineAutoBatched(model) b = tfp.experimental.bijectors.make_distribution_bijector(dist) self.assertDistributionIsApproximatelyStandardNormal( - tfb.Invert(b)(dist)) + tfb.Invert(b)(dist), rtol=1e-4) @test_util.numpy_disable_gradient_test @test_util.jax_disable_test_missing_functionality( @@ -171,6 +177,7 @@ def model_with_funnel(): z = yield tfd.Normal(loc=-1., scale=2., name='z') x = yield tfd.Normal(loc=[0.], scale=tf.exp(z), name='x') yield tfd.Poisson(log_rate=x, name='y') + pinned_model = model_with_funnel.experimental_pin(y=[1]) surrogate_posterior = tfp.experimental.vi.build_asvi_surrogate_posterior( pinned_model) @@ -191,15 +198,16 @@ def do_sample(): kernel=tfp.mcmc.DualAveragingStepSizeAdaptation( tfp.mcmc.TransformedTransitionKernel( tfp.mcmc.NoUTurnSampler( - pinned_model.unnormalized_log_prob, - step_size=0.1), + pinned_model.unnormalized_log_prob, step_size=0.1), bijector=bijector), num_adaptation_steps=5), current_state=surrogate_posterior.sample(), num_burnin_steps=5, trace_fn=lambda _0, _1: [], num_results=10) + do_sample() + if __name__ == '__main__': test_util.main() diff --git a/tensorflow_probability/python/experimental/util/jit_public_methods.py b/tensorflow_probability/python/experimental/util/jit_public_methods.py index f8290bb3c5..9272853687 100644 --- a/tensorflow_probability/python/experimental/util/jit_public_methods.py +++ b/tensorflow_probability/python/experimental/util/jit_public_methods.py @@ -36,6 +36,7 @@ 'dtype', 'kl_divergence', # Wrapping applied explicitly in `_traced_kl_divergence`. 'experimental_default_event_space_bijector', + 'experimental_local_measure', # tfb.Bijector # TODO(davmre): Test wrapping bijectors. 'forward_event_shape', @@ -45,7 +46,8 @@ 'forward_dtype', 'inverse_dtype', 'forward_event_ndims', - 'inverse_event_ndims' + 'inverse_event_ndims', + 'experimental_compute_density_correction', ) if NUMPY_MODE: diff --git a/tensorflow_probability/python/sts/forecast_test.py b/tensorflow_probability/python/sts/forecast_test.py index 785f5ad0e2..60ed4fd9e4 100644 --- a/tensorflow_probability/python/sts/forecast_test.py +++ b/tensorflow_probability/python/sts/forecast_test.py @@ -181,9 +181,8 @@ def _run(): @test_util.jax_disable_test_missing_functionality('fit_with_hmc') def test_forecast_from_hmc(self): - if not (tf1.control_flow_v2_enabled() or self.use_static_shape): - self.skipTest('test_forecast_from_hmc does not currently work with TF1 ' - 'and dynamic shapes') + if not tf1.control_flow_v2_enabled(): + self.skipTest('test_forecast_from_hmc does not currently work with TF1') # test that we can directly plug in the output of an HMC chain as # the input to `forecast`, as done in the example, with no `sess.run` call. From 0a2f117e6a1fb935eb60ca0096f83dbcea683fb7 Mon Sep 17 00:00:00 2001 From: emilyaf Date: Wed, 25 May 2022 17:15:11 -0700 Subject: [PATCH 140/153] Fix in the script that finds the most recent tf-nightly version. PiperOrigin-RevId: 451050955 --- testing/dependency_install_lib.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/testing/dependency_install_lib.sh b/testing/dependency_install_lib.sh index 575a228dbb..d6a735c0ce 100644 --- a/testing/dependency_install_lib.sh +++ b/testing/dependency_install_lib.sh @@ -22,6 +22,7 @@ PYTHON_PARSE_PACKAGE_JSON=" import sys import json import argparse +import pkg_resources import sysconfig @@ -46,7 +47,7 @@ for release, release_info in package_data['releases'].items(): for wheel_info in release_info): continue releases.append(release) -print(sorted(releases)[-1]) +print(sorted(releases, key=pkg_resources.parse_version)[-1]) " find_good_tf_nightly_version_str() { From e27dcc5ee66d20fb7029c2406d94aebe9bcaf212 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Thu, 26 May 2022 08:57:54 -0700 Subject: [PATCH 141/153] Remove `check_types` from `nest.map_up_to`. This should not change the behavior, but eliminates warnings (the warning tells you that the argument does nothing). See https://github.com/tensorflow/probability/issues/1523 for a description of the problem. PiperOrigin-RevId: 451173112 --- tensorflow_probability/python/internal/backend/numpy/nest.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/internal/backend/numpy/nest.py b/tensorflow_probability/python/internal/backend/numpy/nest.py index a52a30ff76..463aa44f67 100644 --- a/tensorflow_probability/python/internal/backend/numpy/nest.py +++ b/tensorflow_probability/python/internal/backend/numpy/nest.py @@ -327,8 +327,9 @@ def map_structure_with_tuple_paths_up_to(shallow_structure, func, *structures, if not structures: raise ValueError('Cannot map over no sequences') + # Internal `tree` does not accept check_types here; see b/198436438. check_types = kwargs.get('check_types', True) -# kwargs.pop('check_types', None) # DisableOnExport + kwargs.pop('check_types', None) if expand_composites: raise NotImplementedError( From 68f626fde3ee8b58c1aa0113c3dd86ced894e05e Mon Sep 17 00:00:00 2001 From: emilyaf Date: Thu, 26 May 2022 19:11:40 -0700 Subject: [PATCH 142/153] Disallow subnormal floats in `numpy_test` and unpin hypothesis version. PiperOrigin-RevId: 451291890 --- .../internal/backend/numpy/numpy_test.py | 45 +++++++++++++++---- testing/dependency_install_lib.sh | 3 +- 2 files changed, 37 insertions(+), 11 deletions(-) diff --git a/tensorflow_probability/python/internal/backend/numpy/numpy_test.py b/tensorflow_probability/python/internal/backend/numpy/numpy_test.py index 8a8acf8912..20ed3c4dfb 100644 --- a/tensorflow_probability/python/internal/backend/numpy/numpy_test.py +++ b/tensorflow_probability/python/internal/backend/numpy/numpy_test.py @@ -55,6 +55,7 @@ ALLOW_NAN = False ALLOW_INFINITY = False +ALLOW_SUBNORMAL = False JAX_MODE = False NUMPY_MODE = not JAX_MODE @@ -81,6 +82,12 @@ def _getattr(obj, name): return functools.reduce(getattr, names, obj) +def _maybe_get_subnormal_kwarg(allow_subnormal=ALLOW_SUBNORMAL): + if hp.__version_info__ >= (6, 30): + return {'allow_subnormal': allow_subnormal} + return {} + + class TestCase(dict): """`dict` object containing test strategies for a single function.""" @@ -121,6 +128,7 @@ def floats(draw, max_value=1e16, allow_nan=ALLOW_NAN, allow_infinity=ALLOW_INFINITY, + allow_subnormal=ALLOW_SUBNORMAL, dtype=None): if dtype is None: dtype = np.float32 if FLAGS.use_tpu else np.float64 @@ -128,11 +136,13 @@ def floats(draw, min_value = onp.array(min_value, dtype=dtype).item() if max_value is not None: max_value = onp.array(max_value, dtype=dtype).item() + subnormal_kwarg = _maybe_get_subnormal_kwarg(allow_subnormal) return draw(hps.floats(min_value=min_value, max_value=max_value, allow_nan=allow_nan, allow_infinity=allow_infinity, - width=np.dtype(dtype).itemsize * 8)) + width=np.dtype(dtype).itemsize * 8, + **subnormal_kwarg)) def integers(min_value=-2**30, max_value=2**30): @@ -604,11 +614,15 @@ def top_k_params(draw): def histogram_fixed_width_bins_params(draw): # TODO(b/187125431): the `min_side=2` and `unique` check can be removed if # https://github.com/tensorflow/tensorflow/pull/38899 is re-implemented. + subnormal_kwarg = _maybe_get_subnormal_kwarg() values = draw(single_arrays( dtype=np.float32, shape=shapes(min_dims=1, min_side=2), unique=True, - elements=hps.floats(min_value=-1e5, max_value=1e5, width=32) + # Avoid intervals containing 0 due to NP/TF discrepancy for bin boundaries + # near 0. + elements=hps.floats(min_value=0., max_value=1e10, width=32, + **subnormal_kwarg), )) vmin, vmax = np.min(values), np.max(values) value_min = draw(hps.one_of( @@ -699,10 +713,12 @@ def sparse_xent_params(draw): shape=hps.just(tuple()), dtype=np.int32, elements=hps.integers(0, num_classes - 1)) + subnormal_kwarg = _maybe_get_subnormal_kwarg() logits = single_arrays( batch_shape=batch_shape, shape=hps.just((num_classes,)), - elements=hps.floats(min_value=-1e5, max_value=1e5, width=32)) + elements=hps.floats(min_value=-1e5, max_value=1e5, width=32, + **subnormal_kwarg)) return draw( hps.fixed_dictionaries(dict( labels=labels, logits=logits)).map(Kwargs)) @@ -714,10 +730,12 @@ def xent_params(draw): batch_shape = draw(shapes(min_dims=1)) labels = batched_probabilities( batch_shape=batch_shape, num_classes=num_classes) + subnormal_kwarg = _maybe_get_subnormal_kwarg() logits = single_arrays( batch_shape=batch_shape, shape=hps.just((num_classes,)), - elements=hps.floats(min_value=-1e5, max_value=1e5, width=32)) + elements=hps.floats(min_value=-1e5, max_value=1e5, width=32, + **subnormal_kwarg)) return draw( hps.fixed_dictionaries(dict( labels=labels, logits=logits)).map(Kwargs)) @@ -965,7 +983,9 @@ def _not_implemented(*args, **kwargs): # keywords=None, # defaults=(False, True, None)) TestCase( - 'linalg.svd', [single_arrays(shape=shapes(min_dims=2))], + 'linalg.svd', [single_arrays( + shape=shapes(min_dims=2), + elements=floats(min_value=-1e10, max_value=1e10))], post_processor=_svd_post_process), TestCase( 'linalg.qr', [ @@ -1177,8 +1197,11 @@ def _not_implemented(*args, **kwargs): xla_const_args=(1, 2, 3)), TestCase( 'math.cumsum', [ - hps.tuples(array_axis_tuples(), hps.booleans(), - hps.booleans()).map(lambda x: x[0] + (x[1], x[2])) + hps.tuples( + array_axis_tuples( + elements=floats(min_value=-1e12, max_value=1e12)), + hps.booleans(), + hps.booleans()).map(lambda x: x[0] + (x[1], x[2])) ], xla_const_args=(1, 2, 3)), ] @@ -1222,7 +1245,8 @@ def _not_implemented(*args, **kwargs): TestCase('math.cos', [single_arrays()]), TestCase('math.cosh', [single_arrays(elements=floats(-100., 100.))]), TestCase('math.digamma', - [single_arrays(elements=non_zero_floats(-1e4, 1e4))]), + [single_arrays(elements=non_zero_floats(-1e4, 1e4))], + rtol=5e-5), TestCase('math.erf', [single_arrays()]), TestCase('math.erfc', [single_arrays()]), TestCase('math.erfinv', [single_arrays(elements=floats(-1., 1.))]), @@ -1274,7 +1298,10 @@ def _not_implemented(*args, **kwargs): TestCase('math.divide_no_nan', [n_same_shape(n=2)]), TestCase('math.equal', [n_same_shape(n=2)]), TestCase('math.floordiv', - [n_same_shape(n=2, elements=[floats(), non_zero_floats()])]), + # Clip numerator above zero to avoid NP/TF discrepancy in rounding + # negative subnormal floats. + [n_same_shape( + n=2, elements=[positive_floats(), non_zero_floats()])]), TestCase('math.floormod', [n_same_shape(n=2, elements=[floats(), non_zero_floats()])]), TestCase('math.greater', [n_same_shape(n=2)]), diff --git a/testing/dependency_install_lib.sh b/testing/dependency_install_lib.sh index d6a735c0ce..d80ff28f54 100644 --- a/testing/dependency_install_lib.sh +++ b/testing/dependency_install_lib.sh @@ -81,8 +81,7 @@ install_common_packages() { install_test_only_packages() { # The following unofficial dependencies are used only by tests. PIP_FLAGS=${1-} - # TODO(b/233927309): Unpin hypothesis version. - python -m pip install $PIP_FLAGS hypothesis==6.46.7 matplotlib mock mpmath scipy pandas optax + python -m pip install $PIP_FLAGS hypothesis matplotlib mock mpmath scipy pandas optax } dump_versions() { From ac62542b264acce24ed7abee5ae3afecabe63547 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Fri, 27 May 2022 13:31:19 -0700 Subject: [PATCH 143/153] Support MultivariateNormalPrecisionFactorLinearOperator as a weight prior. PiperOrigin-RevId: 451466503 --- .../python/experimental/sts_gibbs/gibbs_sampler.py | 8 +++++--- .../experimental/sts_gibbs/gibbs_sampler_test.py | 13 +++++++++++++ 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index 6b22f14b10..eb55767500 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -140,13 +140,16 @@ class SpikeAndSlabSparseLinearRegression(sts_components.LinearRegression): def __init__(self, design_matrix, - weights_prior=None, + weights_prior, sparse_weights_nonzero_prob=0.5, name=None): # Extract precision matrix from a multivariate normal prior. weights_prior_precision = None if hasattr(weights_prior, 'precision'): - weights_prior_precision = weights_prior.precision() + if isinstance(weights_prior.precision, tf.linalg.LinearOperator): + weights_prior_precision = weights_prior.precision.to_dense() + else: + weights_prior_precision = weights_prior.precision() elif weights_prior is not None: inverse_scale = weights_prior.scale.inverse() weights_prior_precision = inverse_scale.matmul( @@ -840,7 +843,6 @@ def _build_sampler_loop_body(model, sampler = dynamic_spike_and_slab.DynamicSpikeSlabSampler else: sampler = spike_and_slab.SpikeSlabSampler - spike_and_slab_sampler = sampler( design_matrix, weights_prior_precision=regression_component._weights_prior_precision, # pylint: disable=protected-access diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py index 761a185409..fe1f505ab2 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler_test.py @@ -29,6 +29,7 @@ tfd = tfp.distributions +tfde = tfp.experimental.distributions tfl = tf.linalg JAX_MODE = False @@ -398,6 +399,18 @@ def test_invalid_model_spec_raises_error(self): level_variance_prior=tfd.InverseGamma(0.01, 0.01), observation_noise_variance_prior=tfd.LogNormal(0., 3.)) + def test_model_with_linop_precision_works(self): + observed_time_series = tf.ones([2]) + design_matrix = tf.eye(2) + sampler = gibbs_sampler.build_model_for_gibbs_fitting( + observed_time_series, + design_matrix=design_matrix, + weights_prior=tfde.MultivariateNormalPrecisionFactorLinearOperator( + precision_factor=tf.linalg.LinearOperatorDiag(tf.ones(2))), + level_variance_prior=tfd.InverseGamma(0.01, 0.01), + observation_noise_variance_prior=tfd.InverseGamma(0.01, 0.01)) + self.assertIsNotNone(sampler) + def test_invalid_options_with_none_design_matrix_raises_error(self): observed_time_series = tf.ones([2]) with self.assertRaisesRegex( From bc6c411b0fbd83141f303f91a27343fe3c43a797 Mon Sep 17 00:00:00 2001 From: langmore Date: Sun, 29 May 2022 16:09:07 -0700 Subject: [PATCH 144/153] Add a perturbed_observations option to ensemble_kalman_filter_log_marginal_likelihood. If False, the observation covariance is computed in a less-stochastic manner that guarantees an SPD result, even with small ensemble sizes. The name "perturbed observations" is chosen because this corresponds to the (well-known) "perturbed observation" *update* step. There is no well-known name for this technique as applied to marginal likelihood (as I've done here), but borrowing the same name seems appropriate. PiperOrigin-RevId: 451771148 --- .../sequential/ensemble_kalman_filter.py | 55 +++++++++++++++---- .../sequential/ensemble_kalman_filter_test.py | 46 +++++++++++++++- 2 files changed, 89 insertions(+), 12 deletions(-) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py index 1abaf71631..c8a10a35e9 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py @@ -29,6 +29,10 @@ ] +class InsufficientEnsembleSizeError(Exception): + """Raise when the ensemble size is insufficient for a function.""" + + # Sample covariance. Handles differing shapes. def _covariance(x, y=None): """Sample covariance, assuming samples are the leftmost axis.""" @@ -304,6 +308,7 @@ def ensemble_kalman_filter_log_marginal_likelihood( state, observation, observation_fn, + perturbed_observations=True, seed=None, name=None): """Ensemble Kalman filter log marginal likelihood. @@ -332,6 +337,11 @@ def ensemble_kalman_filter_log_marginal_likelihood( observation_fn: callable returning an instance of `tfd.MultivariateNormalLinearOperator` along with an extra information to be returned in the `EnsembleKalmanFilterState`. + perturbed_observations: Whether the marginal distribution `p(Y[t] | ...)` + is estimated using samples from the `observation_fn`'s distribution. If + `False`, the distribution's covariance matrix is used directly. This + latter choice is less common in the literature, but works even if the + ensemble size is smaller than the number of observations. seed: PRNG seed; see `tfp.random.sanitize_seed` for details. name: Python `str` name for ops created by this method. Default value: `None` @@ -340,6 +350,10 @@ def ensemble_kalman_filter_log_marginal_likelihood( Returns: log_marginal_likelihood: `Tensor` with same dtype as `state`. + Raises: + InsufficientEnsembleSizeError: If `perturbed_observations=True` and the + ensemble size is not at least one greater than the number of observations. + #### References [1] Geir Evensen. Sequential data assimilation with a nonlinear @@ -360,16 +374,37 @@ def ensemble_kalman_filter_log_marginal_likelihood( observation = tf.convert_to_tensor(observation, dtype=common_dtype) - if not isinstance(observation_particles_dist, - distributions.MultivariateNormalLinearOperator): - raise ValueError('Expected `observation_fn` to return an instance of ' - '`MultivariateNormalLinearOperator`') - - observation_particles = observation_particles_dist.sample(seed=seed) - observation_dist = distributions.MultivariateNormalTriL( - loc=tf.reduce_mean(observation_particles, axis=0), - scale_tril=tf.linalg.cholesky(_covariance(observation_particles))) - + if perturbed_observations: + # With G the observation operator and B the batch shape, + # observation_particles = G(X) + η, where η ~ Normal(0, Γ). + # Both are shape [n_ensemble] + B + [n_observations] + observation_particles = observation_particles_dist.sample(seed=seed) + n_observations = observation_particles_dist.event_shape[0] + n_ensemble = observation_particles_dist.batch_shape[0] + if (n_ensemble is not None and n_observations is not None and + n_ensemble < n_observations + 1): + raise InsufficientEnsembleSizeError( + f'When `perturbed_observations=True`, ensemble size ({n_ensemble}) ' + 'must be at least one greater than the number of observations ' + f'({n_observations}), but it was not.') + observation_dist = distributions.MultivariateNormalTriL( + loc=tf.reduce_mean(observation_particles, axis=0), + # Cholesky(Cov(G(X) + η)), where Cov(..) is the ensemble covariance. + scale_tril=tf.linalg.cholesky(_covariance(observation_particles))) + else: + # predicted_observation = G(X), + # and is shape [n_ensemble] + B. + predicted_observation = observation_particles_dist.mean() + observation_dist = distributions.MultivariateNormalTriL( + loc=tf.reduce_mean(predicted_observation, axis=0), # ensemble mean + # Cholesky(Cov(G(X)) + Γ), where Cov(..) is the ensemble covariance. + scale_tril=tf.linalg.cholesky( + _covariance(predicted_observation) + + _linop_covariance(observation_particles_dist).to_dense())) + + # Above we computed observation_dist, the distribution of observations given + # the predictive distribution of states (e.g. states from previous time). + # Here we evaluate the log_prob on the actual observations. return observation_dist.log_prob(observation) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py index 91f7255878..1f0d253ba0 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py @@ -269,6 +269,7 @@ def observation_fn(_, particles, extra): self.assertAllEqual(particles_shape[1:-1], log_ml.shape) self.assertIn('observation_count', state.extra) self.assertEqual(3 * i + 1, state.extra['observation_count']) + self.assertFalse(np.any(np.isnan(self.evaluate(log_ml)))) log_ml_krazy_obs = tfs.ensemble_kalman_filter_log_marginal_likelihood( state, @@ -293,6 +294,38 @@ def observation_fn(_, particles, extra): self.evaluate(tf.reduce_mean(state.particles['x'], axis=0)), rtol=0.05) + def test_log_marginal_likelihood_with_small_ensemble_no_perturb_obs(self): + # With perturbed_observations=False, we should be able to handle the small + # ensemble without NaN. + + # Initialize an ensemble with that is smaller than the event size. + seed_stream = test_util.test_seed_stream() + n_ensemble = 3 + event_size = 5 + self.assertLess(n_ensemble, event_size) + particles_shape = (n_ensemble, event_size) + + particles = { + 'x': + self.evaluate( + tf.random.normal(shape=particles_shape, seed=seed_stream())), + } + + def observation_fn(_, particles, extra): + return tfd.MultivariateNormalDiag( + loc=particles['x'], scale_diag=[1e-2] * event_size), extra + + # Marginal likelihood. + log_ml = tfs.ensemble_kalman_filter_log_marginal_likelihood( + state=tfs.EnsembleKalmanFilterState( + step=0, particles=particles, extra={}), + observation=tf.random.normal(shape=(event_size,), seed=seed_stream()), + observation_fn=observation_fn, + perturbed_observations=False, + seed=test_util.test_seed()) + self.assertAllEqual(particles_shape[1:-1], log_ml.shape) + self.assertFalse(np.any(np.isnan(self.evaluate(log_ml)))) + # Parameters defining a linear/Gaussian state space model. LinearModelParams = collections.namedtuple('LinearModelParams', [ @@ -484,8 +517,15 @@ def _enkf_solve(self, observation, enkf_params, predict_kwargs, update_kwargs, noise_level=[0.001, 0.1, 1.0], n_states=[2, 5], n_observations=[2, 5], + perturbed_observations=[False, True], )) - def test_same_solution(self, noise_level, n_states, n_observations): + def test_same_solution( + self, + noise_level, + n_states, + n_observations, + perturbed_observations, + ): """Check that the KF and EnKF solutions are the same.""" # Tests pass with n_ensemble = 1e7. The KF vs. EnKF tolerance is # proportional to 1 / sqrt(n_ensemble), so this shows good agreement. @@ -496,7 +536,9 @@ def test_same_solution(self, noise_level, n_states, n_observations): dtype = tf.float64 predict_kwargs = {} update_kwargs = {} - log_marginal_likelihood_kwargs = {} + log_marginal_likelihood_kwargs = { + 'perturbed_observations': perturbed_observations + } linear_model_params = self._get_linear_model_params( noise_level=noise_level, From a60be6e6a90b0acfa8475bc7c690f7a986e23620 Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Tue, 31 May 2022 11:35:12 -0700 Subject: [PATCH 145/153] Add tfp_math.betainc. - Add gradients for every parameter for betainc. PiperOrigin-RevId: 452099765 --- .../python/distributions/beta.py | 14 +- .../python/distributions/binomial.py | 2 +- .../python/distributions/negative_binomial.py | 8 +- .../python/distributions/sigmoid_beta.py | 13 +- .../python/distributions/student_t.py | 3 +- .../bijectors/distribution_bijectors_test.py | 1 + tensorflow_probability/python/math/BUILD | 2 +- .../python/math/__init__.py | 2 + tensorflow_probability/python/math/special.py | 347 ++++++++++++++++-- .../python/math/special_test.py | 64 +++- 10 files changed, 389 insertions(+), 67 deletions(-) diff --git a/tensorflow_probability/python/distributions/beta.py b/tensorflow_probability/python/distributions/beta.py index 17271d977d..6c6d35cbae 100644 --- a/tensorflow_probability/python/distributions/beta.py +++ b/tensorflow_probability/python/distributions/beta.py @@ -14,8 +14,6 @@ # ============================================================================ """The Beta distribution class.""" -import functools - # Dependency imports import numpy as np import tensorflow.compat.v2 as tf @@ -30,7 +28,6 @@ from tensorflow_probability.python.internal import distribution_util from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties -from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import reparameterization from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import tensor_util @@ -330,17 +327,8 @@ def _log_cdf(self, x): def _cdf(self, x): concentration1 = tf.convert_to_tensor(self.concentration1) concentration0 = tf.convert_to_tensor(self.concentration0) - shape = functools.reduce( - ps.broadcast_shape, - [ps.shape(concentration1), - ps.shape(concentration0), - ps.shape(x)]) - concentration1 = tf.broadcast_to(concentration1, shape) - concentration0 = tf.broadcast_to(concentration0, shape) - x = tf.broadcast_to(x, shape) - safe_x = tf.where(tf.logical_and(x >= 0, x < 1), x, 0.5) - answer = tf.math.betainc(concentration1, concentration0, safe_x) + answer = tfp_math.betainc(concentration1, concentration0, safe_x) return distribution_util.extend_cdf_outside_support( x, answer, low=0., high=1.) diff --git a/tensorflow_probability/python/distributions/binomial.py b/tensorflow_probability/python/distributions/binomial.py index 1cd90c4ea5..7c1e5b7c10 100644 --- a/tensorflow_probability/python/distributions/binomial.py +++ b/tensorflow_probability/python/distributions/binomial.py @@ -62,7 +62,7 @@ def _bdtr(k, n, p): # where(unsafe, safe_output, betainc(where(unsafe, safe_input, input))) ones = tf.ones_like(n - k) safe_dn = tf.where(tf.logical_or(k < 0, k >= n), ones, n - k) - dk = tf.math.betainc(a=safe_dn, b=k + 1, x=1 - p) + dk = tfp_math.betainc(a=safe_dn, b=k + 1, x=1 - p) return distribution_util.extend_cdf_outside_support(k, dk, low=0, high=n) diff --git a/tensorflow_probability/python/distributions/negative_binomial.py b/tensorflow_probability/python/distributions/negative_binomial.py index 265740e8b7..77cdef9cab 100644 --- a/tensorflow_probability/python/distributions/negative_binomial.py +++ b/tensorflow_probability/python/distributions/negative_binomial.py @@ -195,13 +195,9 @@ def _sample_n(self, n, seed=None): def _cdf(self, x): logits = self._logits_parameter_no_checks() total_count = tf.convert_to_tensor(self.total_count) - shape = self._batch_shape_tensor( - logits=logits, total_count=total_count) safe_x = tf.where(x >= 0, x, 0.) - answer = tf.math.betainc( - tf.broadcast_to(total_count, shape), - tf.broadcast_to(1. + safe_x, shape), - tf.broadcast_to(tf.sigmoid(-logits), shape)) + answer = tfp_math.betainc( + total_count, 1. + safe_x, tf.sigmoid(-logits)) return distribution_util.extend_cdf_outside_support(x, answer, low=0) def _log_prob(self, x): diff --git a/tensorflow_probability/python/distributions/sigmoid_beta.py b/tensorflow_probability/python/distributions/sigmoid_beta.py index 76e814d44c..79d9fec689 100644 --- a/tensorflow_probability/python/distributions/sigmoid_beta.py +++ b/tensorflow_probability/python/distributions/sigmoid_beta.py @@ -14,8 +14,6 @@ # ============================================================================ """The SigmoidBeta distribution class.""" -import functools - # Dependency imports import tensorflow.compat.v2 as tf @@ -27,7 +25,6 @@ from tensorflow_probability.python.internal import assert_util from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties -from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import reparameterization from tensorflow_probability.python.internal import samplers from tensorflow_probability.python.internal import tensor_util @@ -245,15 +242,7 @@ def _cdf(self, x): concentration1 = tf.convert_to_tensor(self.concentration1) concentration0 = tf.convert_to_tensor(self.concentration0) sig_x = tf.math.sigmoid(x) - shape = functools.reduce(ps.broadcast_shape, [ - ps.shape(concentration1), - ps.shape(concentration0), - ps.shape(sig_x) - ]) - concentration1 = tf.broadcast_to(concentration1, shape) - concentration0 = tf.broadcast_to(concentration0, shape) - sig_x = tf.broadcast_to(sig_x, shape) - return tf.math.betainc(concentration1, concentration0, sig_x) + return tfp_math.betainc(concentration1, concentration0, sig_x) def _mode(self): return tf.math.log(self.concentration1 / self.concentration0) diff --git a/tensorflow_probability/python/distributions/student_t.py b/tensorflow_probability/python/distributions/student_t.py index 9ff0939356..1daf0c6ba5 100644 --- a/tensorflow_probability/python/distributions/student_t.py +++ b/tensorflow_probability/python/distributions/student_t.py @@ -116,8 +116,7 @@ def cdf(x, df, loc, scale): """ y = (x - loc) / tf.abs(scale) x_t = df / (y**2. + df) - neg_cdf = 0.5 * tf.math.betainc( - 0.5 * tf.broadcast_to(df, ps.shape(x_t)), 0.5, x_t) + neg_cdf = 0.5 * tfp_math.betainc(0.5 * df, 0.5, x_t) return tf.where(y < 0., neg_cdf, 1. - neg_cdf) diff --git a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py index f0a001c3f3..d12e97c955 100644 --- a/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py +++ b/tensorflow_probability/python/experimental/bijectors/distribution_bijectors_test.py @@ -46,6 +46,7 @@ if JAX_MODE: PRECONDITIONING_FAILS_DISTS = ( + 'PERT', # Testing triggers second derivative path in JAX mode. 'VonMises', # Abstract eval for 'von_mises_cdf_jvp' not implemented. ) + PRECONDITIONING_FAILS_DISTS diff --git a/tensorflow_probability/python/math/BUILD b/tensorflow_probability/python/math/BUILD index f922ed2931..8ce961b925 100644 --- a/tensorflow_probability/python/math/BUILD +++ b/tensorflow_probability/python/math/BUILD @@ -482,7 +482,7 @@ multi_substrate_py_test( name = "special_test", size = "medium", srcs = ["special_test.py"], - shard_count = 3, + shard_count = 6, deps = [ # absl/testing:parameterized dep, # numpy dep, diff --git a/tensorflow_probability/python/math/__init__.py b/tensorflow_probability/python/math/__init__.py index 7e0cf46973..f06606d94a 100644 --- a/tensorflow_probability/python/math/__init__.py +++ b/tensorflow_probability/python/math/__init__.py @@ -67,6 +67,7 @@ from tensorflow_probability.python.math.scan_associative import scan_associative from tensorflow_probability.python.math.sparse import dense_to_sparse from tensorflow_probability.python.math.special import atan_difference +from tensorflow_probability.python.math.special import betainc from tensorflow_probability.python.math.special import dawsn from tensorflow_probability.python.math.special import erfcinv from tensorflow_probability.python.math.special import erfcx @@ -93,6 +94,7 @@ _allowed_symbols = [ 'atan_difference', + 'betainc', 'batch_interp_regular_1d_grid', 'batch_interp_regular_nd_grid', 'bessel_iv_ratio', diff --git a/tensorflow_probability/python/math/special.py b/tensorflow_probability/python/math/special.py index 799a4709b8..a9c8aa0242 100644 --- a/tensorflow_probability/python/math/special.py +++ b/tensorflow_probability/python/math/special.py @@ -14,17 +14,20 @@ # ============================================================================ """Implements special functions in TensorFlow.""" +import functools + # Dependency imports import numpy as np import tensorflow.compat.v2 as tf from tensorflow_probability.python.internal import custom_gradient as tfp_custom_gradient from tensorflow_probability.python.internal import dtype_util -from tensorflow_probability.python.internal import prefer_static +from tensorflow_probability.python.internal import prefer_static as ps from tensorflow_probability.python.internal import tensorshape_util __all__ = [ 'atan_difference', + 'betainc', 'dawsn', 'erfcinv', 'erfcx', @@ -84,6 +87,290 @@ def atan_difference(x, y, name=None): return difference +def _betainc_naive(a, b, x): + """Returns the regularized incomplete beta function elementwise.""" + dtype = dtype_util.common_dtype([a, b, x], tf.float32) + a = tf.convert_to_tensor(a, dtype=dtype) + b = tf.convert_to_tensor(b, dtype=dtype) + x = tf.convert_to_tensor(x, dtype=dtype) + broadcast_shape = ps.broadcast_shape( + ps.shape(a), ps.shape(b)) + broadcast_shape = ps.broadcast_shape( + broadcast_shape, ps.shape(x)) + a = tf.broadcast_to(a, broadcast_shape) + b = tf.broadcast_to(b, broadcast_shape) + x = tf.broadcast_to(x, broadcast_shape) + return tf.math.betainc(a, b, x) + +# Derivative implementation based on +# [1] R. Boik, J. Robinson-Cox, +# Derivatives of the Incomplete Beta Function +# https://www.jstatsoft.org/article/view/v003i01/beta.der.pdf + + +def partial_numerator(a, b, x, i): + """Partial numerator used in continued fraction expansion of betainc.""" + f = b * x / (a * (1 - x)) + result = (a + b + i - 2.) * (a + i - 1) * (b - i) / ( + (a + 2 * i - 3.) * tf.math.square(a + 2 * i - 2.) * (a + 2 * i - 1.)) + result = result * tf.math.square(a * f / b) * (i - 1.) + return tf.where( + tf.math.equal(i, 1.), + a * f * (b - 1.) / (b * (a + 1.)), + result) + + +def partial_denominator(a, b, x, i): + """Partial denominator used in continued fraction expansion of betainc.""" + f = b * x / (a * (1 - x)) + numerator = 2 * (a * f + 2 * b) * i * (i + a - 1.) + a * b * (a - 2. - a * f) + denominator = b * (a + 2 * i - 2) * (a + 2 * i) + return numerator / denominator + + +def partial_numerator_da(a, b, x, i): + """Derivative of betainc partial numerators with respect to a.""" + f = b * x / (a * (1 - x)) + result_numerator = 8 * i ** 3 * (a + b - 1.) + result_numerator = result_numerator + 2 * tf.math.square(i) * ( + 8 * tf.math.square(a) + (10 * b - 22.) * a + 13. - 12. * b) + result_numerator = result_numerator + 2 * i * ( + 5 * a ** 3 + (7 * b - 23) * tf.math.square(a) + + (-20. * b + 33) * a - 14. + 12. * b) + result_numerator = result_numerator + 2 * a ** 4 + (-13. + 3 * b) * a ** 3 + result_numerator = result_numerator + ( + (-14 * b + 30) * tf.math.square(a) + (-29. + 19 * b) * a + 10. - 8 * b) + result_denominator = tf.math.square(b * (a + 2 * i - 3.) * (a + 2 * i - 1.)) + result_denominator = result_denominator * (a + 2 * i - 2.) ** 3 + result = result_numerator / result_denominator + result = -(i - 1.) * (b - i) * tf.math.square(f * a) * result + return tf.where( + tf.math.equal(i, 1.), + -a * f * (b - 1.) / (b * tf.math.square(a + 1.)), + result) + + +def partial_denominator_da(a, b, x, i): + """Derivative of betainc partial denominators with respect to a.""" + f = b * x / (a * (1 - x)) + result_numerator = (a * f / b) * ( + 4. * (1 - a - b) * tf.math.square(i) - + (4 * (1 - a - b) + 2 * tf.math.square(a)) * i + + tf.math.square(a) * b) + result_denominator = tf.math.square((a + 2 * i - 2) * (a + 2 * i)) + return result_numerator / result_denominator + + +def partial_numerator_db(a, b, x, i): + """Derivative of betainc partial numerators with respect to b.""" + f = b * x / (a * (1 - x)) + numerator = ( + tf.math.square(a * f / b) * (i - 1.) * (a + i - 1.) * (2 * b + a - 2.)) + denominator = ( + (a + 2 * i - 3.) * tf.math.square(a + 2 * i - 2.) * (a + 2 * i - 1.)) + return tf.where( + tf.math.equal(i, 1.), + a * f / (b * (a + 1)), + numerator / denominator) + + +def partial_denominator_db(a, b, x, i): + """Derivative of betainc partial denominators with respect to b.""" + f = b * x / (a * (1 - x)) + return -f * tf.math.square(a) / (b * (a + 2 * i - 2.) * (a + 2 * i)) + + +def _betainc_der_helper(a, b, x, compute_partial_a=True): + """Shared code for computing partial derivatives of betainc.""" + dtype = dtype_util.common_dtype([a, b, x], tf.float32) + a = tf.convert_to_tensor(a, dtype=dtype) + b = tf.convert_to_tensor(b, dtype=dtype) + x = tf.convert_to_tensor(x, dtype=dtype) + + if compute_partial_a: + numerator_der_fn = partial_numerator_da + denominator_der_fn = partial_denominator_da + else: + numerator_der_fn = partial_numerator_db + denominator_der_fn = partial_denominator_db + + def _continued_fraction_one_step( + iteration_count, + numerator, + previous_numerator, + dnumerator, + previous_dnumerator, + denominator, + previous_denominator, + ddenominator, + previous_ddenominator): + partial_num = partial_numerator(a, b, x, iteration_count) + partial_den = partial_denominator(a, b, x, iteration_count) + partial_num_der = numerator_der_fn(a, b, x, iteration_count) + partial_den_der = denominator_der_fn(a, b, x, iteration_count) + + # A_n = a_n * A_{n - 2} + b_n * A_{n - 1} + new_numerator = (previous_numerator * partial_num + + numerator * partial_den) + # dA_n / ds = (da_n/ds * A_{n - 2} + a_n * dA_{n - 2}/ds) + + # (db_n/ds * A_{n - 1} + b_n * dA_{n - 1}/ds) + new_dnumerator = (partial_num_der * previous_numerator + + partial_num * previous_dnumerator + + partial_den_der * numerator + + partial_den * dnumerator) + # B_n = a_n * B_{n - 2} + b_n * B_{n - 1} + new_denominator = (previous_denominator * partial_num + + denominator * partial_den) + # dB_n / ds = (da_n/ds * B_{n - 2} + a_n * dB_{n - 2}/ds) + + # (db_n/ds * B_{n - 1} + b_n * dB_{n - 1}/ds) + new_ddenominator = (partial_num_der * previous_denominator + + partial_num * previous_ddenominator + + partial_den_der * denominator + + partial_den * ddenominator) + + return (iteration_count + 1., + new_numerator, + numerator, + new_dnumerator, + dnumerator, + new_denominator, + denominator, + new_ddenominator, + ddenominator) + + broadcast_shape = functools.reduce( + ps.broadcast_shape, [ps.shape(a), ps.shape(b), ps.shape(x)]) + + zeroth_numerator = tf.ones(broadcast_shape, dtype=dtype) + first_numerator = tf.ones(broadcast_shape, dtype=dtype) + + zeroth_dnumerator = tf.zeros(broadcast_shape, dtype=dtype) + first_dnumerator = tf.zeros(broadcast_shape, dtype=dtype) + + zeroth_denominator = tf.zeros(broadcast_shape, dtype=dtype) + first_denominator = tf.ones(broadcast_shape, dtype=dtype) + + zeroth_ddenominator = tf.zeros(broadcast_shape, dtype=dtype) + first_ddenominator = tf.zeros(broadcast_shape, dtype=dtype) + + (_, + numerator, _, + dnumerator, _, + denominator, _, + ddenominator, _) = tf.while_loop( + cond=lambda iteration_count, *_: iteration_count < 50, + body=_continued_fraction_one_step, + loop_vars=( + tf.cast(1., dtype=dtype), + first_numerator, + zeroth_numerator, + first_dnumerator, + zeroth_dnumerator, + first_denominator, + zeroth_denominator, + first_ddenominator, + zeroth_ddenominator)) + + result = numerator / denominator + if compute_partial_a: + result = result * ( + tf.math.log(x) - tf.math.reciprocal(a) + + tf.math.digamma(a + b) - tf.math.digamma(a)) + else: + result = result * ( + tf.math.log1p(-x) + + tf.math.digamma(a + b) - tf.math.digamma(b)) + + result = (result + dnumerator / denominator - + numerator * ddenominator / tf.math.square(denominator)) + + return result * tf.math.exp( + tf.math.xlogy(a, x) + tf.math.xlog1py(b - 1., -x) - + tf.math.log(a) - lbeta(a, b)) + + +def _betainc_partial_a(a, b, x): + dtype = dtype_util.common_dtype([a, b, x], tf.float32) + numpy_dtype = dtype_util.as_numpy_dtype(dtype) + result = tf.where( + x > a / (a + b), + -_betainc_der_helper(b, a, 1. - x, compute_partial_a=False), + _betainc_der_helper(a, b, x, compute_partial_a=True)) + return tf.where(tf.math.equal(x, 0.), numpy_dtype(0.), result) + + +def _betainc_partial_b(a, b, x): + dtype = dtype_util.common_dtype([a, b, x], tf.float32) + numpy_dtype = dtype_util.as_numpy_dtype(dtype) + result = tf.where( + x > a / (a + b), + -_betainc_der_helper(b, a, 1. - x, compute_partial_a=True), + _betainc_der_helper(a, b, x, compute_partial_a=False)) + return tf.where(tf.math.equal(x, 0.), numpy_dtype(0.), result) + + +def _betainc_partial_x(a, b, x): + result = tf.math.xlogy(a - 1., x) + tf.math.xlog1py(b - 1., -x) - lbeta(a, b) + return tf.math.exp(result) + + +def _betainc_fwd(a, b, x): + """Compute output, aux (collaborates with _dawsn_bwd).""" + output = _betainc_naive(a, b, x) + return output, (a, b, x) + + +def _betainc_bwd(aux, g): + """Reverse mode impl for dawsn.""" + a, b, x = aux + pa = _betainc_partial_a(a, b, x) + pb = _betainc_partial_b(a, b, x) + px = _betainc_partial_x(a, b, x) + return _fix_gradient_for_broadcasting( + [a, b, x], [pa * g, pb * g, px * g]) + + +def _betainc_jvp(primals, tangents): + """Computes JVP for dawsn (supports JAX custom derivative).""" + a, b, x = primals + da, db, dx = tangents + + y = _betainc_custom_gradient(a, b, x) + return (y, + da * _betainc_partial_a(a, b, x) + + db * _betainc_partial_b(a, b, x) + + dx * _betainc_partial_x(a, b, x)) + + +@tfp_custom_gradient.custom_gradient( + vjp_fwd=_betainc_fwd, + vjp_bwd=_betainc_bwd, + jvp_fn=_betainc_jvp) +def _betainc_custom_gradient(a, b, x): + return _betainc_naive(a, b, x) + + +def betainc(a, b, x, name=None): + """Computes Regularized Incomplete Beta element-wise. + + Args: + a: + b: + x: A Tensor with type `float32` or `float64`. + name: A name for the operation (optional). + + Returns: + betainc: dawsn evaluated at `x`. A Tensor with the same shape and same + dtype as `x`. + """ + with tf.name_scope(name or 'betainc'): + dtype = dtype_util.common_dtype([a, b, x], tf.float32) + a = tf.convert_to_tensor(a, dtype=dtype) + b = tf.convert_to_tensor(b, dtype=dtype) + x = tf.convert_to_tensor(x, dtype=dtype) + return _betainc_custom_gradient(a, b, x) + + def _dawsn_naive(x): """Returns the Dawson Integral computed at x elementwise.""" dtype = dtype_util.common_dtype([x], tf.float32) @@ -736,7 +1023,7 @@ def _igammainv_bwd(aux, g): x = _igammainv_custom_gradient(a, p) # Use the fact that igamma and igammainv are inverses to compute the gradient. pa, pp = _igammainv_partials(a, x) - return _fix_gradient_for_broadcasting(a, p, pa * g, pp * g) + return _fix_gradient_for_broadcasting([a, p], [pa * g, pp * g]) def _igammainv_jvp(primals, tangents): @@ -744,8 +1031,7 @@ def _igammainv_jvp(primals, tangents): a, p = primals da, dp = tangents # TODO(https://github.com/google/jax/issues/3768): eliminate broadcast_to? - bc_shp = prefer_static.broadcast_shape(prefer_static.shape(da), - prefer_static.shape(dp)) + bc_shp = ps.broadcast_shape(ps.shape(da), ps.shape(dp)) da = tf.broadcast_to(da, bc_shp) dp = tf.broadcast_to(dp, bc_shp) @@ -802,7 +1088,7 @@ def _igammacinv_bwd(aux, g): x = _igammacinv_custom_gradient(a, p) pa, pp = _igammainv_partials(a, x) pp = -pp - return _fix_gradient_for_broadcasting(a, p, pa * g, pp * g) + return _fix_gradient_for_broadcasting([a, p], [pa * g, pp * g]) def _igammacinv_jvp(primals, tangents): @@ -810,8 +1096,7 @@ def _igammacinv_jvp(primals, tangents): a, p = primals da, dp = tangents # TODO(https://github.com/google/jax/issues/3768): eliminate broadcast_to? - bc_shp = prefer_static.broadcast_shape(prefer_static.shape(da), - prefer_static.shape(dp)) + bc_shp = ps.broadcast_shape(ps.shape(da), ps.shape(dp)) da = tf.broadcast_to(da, bc_shp) dp = tf.broadcast_to(dp, bc_shp) @@ -1121,18 +1406,27 @@ def log_gamma_correction(x, name=None): return accum * inverse_x -def _fix_gradient_for_broadcasting(a, b, grad_a, grad_b): - """Reduces broadcast dimensions for a custom gradient.""" - if (tensorshape_util.is_fully_defined(a.shape) and - tensorshape_util.is_fully_defined(b.shape) and - a.shape == b.shape): - return [grad_a, grad_b] - a_shape = tf.shape(a) - b_shape = tf.shape(b) - ra, rb = tf.raw_ops.BroadcastGradientArgs(s0=a_shape, s1=b_shape) - grad_a = tf.reshape(tf.reduce_sum(grad_a, axis=ra), a_shape) - grad_b = tf.reshape(tf.reduce_sum(grad_b, axis=rb), b_shape) - return [grad_a, grad_b] +def _fix_gradient_for_broadcasting(primals, grads): + """Ensure `grads` have same shape as `primals`.""" + if len(primals) != len(grads): + raise ValueError('Expected same number of `x` and `grads`') + if (all(tensorshape_util.is_fully_defined(x.shape) for x in primals) and + all(x.shape == primals[0].shape for x in primals)): + return grads + # Compute the leave one out broadcast shapes, and use that to compute + # the axes. + new_grads = [] + primal_shapes = [tf.shape(x) for x in primals] + for i in range(len(primals)): + loo_primal_shapes = primal_shapes[:i] + primal_shapes[i+1:] + x_shape = tf.shape(primals[i]) + loo_broadcast_shape = functools.reduce( + tf.broadcast_dynamic_shape, loo_primal_shapes) + rx, _ = tf.raw_ops.BroadcastGradientArgs( + s0=x_shape, s1=loo_broadcast_shape) + new_grads.append( + tf.reshape(tf.reduce_sum(grads[i], axis=rx), shape=x_shape)) + return new_grads def _log_gamma_difference_big_y(x, y): @@ -1186,7 +1480,7 @@ def _log_gamma_difference_bwd(aux, g): # `_log_gamma_difference`. px = -tf.math.digamma(x + y) py = tf.math.digamma(y) + px - return _fix_gradient_for_broadcasting(x, y, px * g, py * g) + return _fix_gradient_for_broadcasting([x, y], [px * g, py * g]) def _log_gamma_difference_jvp(primals, tangents): @@ -1194,8 +1488,7 @@ def _log_gamma_difference_jvp(primals, tangents): x, y = primals dx, dy = tangents # TODO(https://github.com/google/jax/issues/3768): eliminate broadcast_to? - bc_shp = prefer_static.broadcast_shape(prefer_static.shape(dx), - prefer_static.shape(dy)) + bc_shp = ps.broadcast_shape(ps.shape(dx), ps.shape(dy)) dx = tf.broadcast_to(dx, bc_shp) dy = tf.broadcast_to(dy, bc_shp) # See note above in _log_gamma_difference_bwd. @@ -1287,7 +1580,7 @@ def _lbeta_bwd(aux, g): total_digamma = tf.math.digamma(x + y) px = tf.math.digamma(x) - total_digamma py = tf.math.digamma(y) - total_digamma - return _fix_gradient_for_broadcasting(x, y, px * g, py * g) + return _fix_gradient_for_broadcasting([x, y], [px * g, py * g]) def _lbeta_jvp(primals, tangents): @@ -1295,8 +1588,7 @@ def _lbeta_jvp(primals, tangents): x, y = primals dx, dy = tangents # TODO(https://github.com/google/jax/issues/3768): eliminate broadcast_to? - bc_shp = prefer_static.broadcast_shape(prefer_static.shape(dx), - prefer_static.shape(dy)) + bc_shp = ps.broadcast_shape(ps.shape(dx), ps.shape(dy)) dx = tf.broadcast_to(dx, bc_shp) dy = tf.broadcast_to(dy, bc_shp) total_digamma = tf.math.digamma(x + y) @@ -1784,7 +2076,7 @@ def _owens_t_bwd(aux, g): tf.math.erf(a * h / np.sqrt(2)) / (2 * np.sqrt(2 * np.pi))) pa = (tf.math.exp(-0.5 * (tf.math.square(a) + 1) * tf.math.square(h)) / (2 * np.pi * (tf.math.square(a) + 1.))) - return _fix_gradient_for_broadcasting(h, a, ph * g, pa * g) + return _fix_gradient_for_broadcasting([h, a], [ph * g, pa * g]) def _owens_t_jvp(primals, tangents): @@ -1792,8 +2084,7 @@ def _owens_t_jvp(primals, tangents): h, a = primals dh, da = tangents # TODO(https://github.com/google/jax/issues/3768): eliminate broadcast_to? - bc_shp = prefer_static.broadcast_shape(prefer_static.shape(dh), - prefer_static.shape(da)) + bc_shp = ps.broadcast_shape(ps.shape(dh), ps.shape(da)) dh = tf.broadcast_to(dh, bc_shp) da = tf.broadcast_to(da, bc_shp) ph = (-tf.math.exp(-0.5 * tf.math.square(h)) * diff --git a/tensorflow_probability/python/math/special_test.py b/tensorflow_probability/python/math/special_test.py index 429c2f76f0..3ee1bcdcbe 100644 --- a/tensorflow_probability/python/math/special_test.py +++ b/tensorflow_probability/python/math/special_test.py @@ -169,6 +169,54 @@ def testGradientOutsideAndOnEdgeOfSupport(self, dtype): self.assertAllEqual(dy_dx_, np.zeros((6,))) +@test_util.test_graph_and_eager_modes +class BetaincTest(test_util.TestCase): + + def testBetainc(self): + strm = test_util.test_seed_stream() + a = tfp.distributions.HalfCauchy( + loc=np.float64(1.), scale=15.).sample(2000, strm()) + a = self.evaluate(a) + b = tfp.distributions.HalfCauchy( + loc=np.float64(1.), scale=15.).sample(2000, strm()) + b = self.evaluate(b) + x = tfp.distributions.Uniform( + high=np.float64(1.)).sample(2000, strm()) + x = self.evaluate(x) + + self.assertAllClose( + scipy_special.betainc(a, b, x), + self.evaluate(tfp_math.betainc(a, b, x)), rtol=1e-6) + + def testBetaincBroadcast(self): + a = np.ones([3, 2], dtype=np.float32) + b = np.ones([5, 1, 1], dtype=np.float32) + x = np.ones([7, 1, 1, 2], dtype=np.float32) + self.assertAllEqual([7, 5, 3, 2], tfp_math.betainc(a, b, x).shape) + + @test_util.numpy_disable_gradient_test + def testBetaincGradient(self): + a = np.logspace(-2., 2., 11)[..., np.newaxis] + b = np.logspace(-2., 2., 11)[..., np.newaxis] + # Avoid the end points where the gradient can veer off to infinity. + x = np.linspace(0.1, 0.7, 23) + + # Wrap in tf.function for faster computations. + betainc = tf.function(tfp_math.betainc) + + err = self.compute_max_gradient_error( + lambda z: betainc(a, b, z), [x], delta=1e-4) + self.assertLess(err, 2e-5) + + err = self.compute_max_gradient_error( + lambda z: betainc(z, b, x), [a], delta=1e-4) + self.assertLess(err, 8e-4) + + err = self.compute_max_gradient_error( + lambda z: betainc(a, z, x), [b], delta=1e-4) + self.assertLess(err, 8e-4) + + @test_util.test_graph_and_eager_modes class DawsnTest(test_util.TestCase): @@ -306,12 +354,16 @@ def testIgammainvGradient(self): a = np.logspace(-2., 2., 11)[..., np.newaxis] # Avoid the end points where the gradient can veer off to infinity. p = np.linspace(0.1, 0.7, 23) + + # Wrap in tf.function for faster computations. + igammainv = tf.function(tfp_math.igammainv) + err = self.compute_max_gradient_error( - lambda x: tfp.math.igammainv(a, x), [p], delta=1e-4) + lambda x: igammainv(a, x), [p], delta=1e-4) self.assertLess(err, 2e-5) err = self.compute_max_gradient_error( - lambda x: tfp.math.igammainv(x, p), [a], delta=1e-4) + lambda x: igammainv(x, p), [a], delta=1e-4) self.assertLess(err, 2e-5) @test_util.numpy_disable_gradient_test @@ -319,12 +371,16 @@ def testIgammacinvGradient(self): a = np.logspace(-2., 2., 11)[..., np.newaxis] # Avoid the end points where the gradient can veer off to infinity. p = np.linspace(0.1, 0.7, 23) + + # Wrap in tf.function for faster computations. + igammacinv = tf.function(tfp_math.igammacinv) + err = self.compute_max_gradient_error( - lambda x: tfp.math.igammacinv(a, x), [p], delta=1e-4) + lambda x: igammacinv(a, x), [p], delta=1e-4) self.assertLess(err, 2e-5) err = self.compute_max_gradient_error( - lambda x: tfp.math.igammacinv(x, p), [a], delta=1e-4) + lambda x: igammacinv(x, p), [a], delta=1e-4) self.assertLess(err, 2e-5) @test_util.numpy_disable_gradient_test From c05c91a5f629682abb78f0985aa3c71175579f8e Mon Sep 17 00:00:00 2001 From: langmore Date: Tue, 31 May 2022 14:56:23 -0700 Subject: [PATCH 146/153] Ensemble Kalman filter is now efficient in the case of ensemble size << observation size and an "easy to invert" modeled observation covariance. Add `low_rank_ensemble` kwarg to `ensemble_kalman_filter_update` and `ensemble_kalman_filter_log_marginal_likelihood`. Setting to `True` means the observation covariance is represented using a LinearOperatorLowRankUpdate. This is efficient in a common case of (i) ensemble size << observation size and (ii) modeled observation covariance is "easy to invert". PiperOrigin-RevId: 452147406 --- .../sequential/ensemble_kalman_filter.py | 172 ++++++++++++++---- .../sequential/ensemble_kalman_filter_test.py | 115 +++++++++++- 2 files changed, 244 insertions(+), 43 deletions(-) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py index c8a10a35e9..9c9cd71a4f 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py @@ -18,6 +18,8 @@ import tensorflow.compat.v2 as tf from tensorflow_probability.python import distributions +from tensorflow_probability.python.distributions import mvn_low_rank_update_linear_operator_covariance +from tensorflow_probability.python.internal import distribution_util from tensorflow_probability.python.internal import dtype_util __all__ = [ @@ -28,6 +30,10 @@ 'inflate_by_scaled_identity_fn', ] +MVNLowRankCov = ( + mvn_low_rank_update_linear_operator_covariance + .MultivariateNormalLowRankUpdateLinearOperatorCovariance) + class InsufficientEnsembleSizeError(Exception): """Raise when the ensemble size is insufficient for a function.""" @@ -157,6 +163,7 @@ def ensemble_kalman_filter_update( observation, observation_fn, damping=1., + low_rank_ensemble=False, seed=None, name=None): """Ensemble Kalman filter update step. @@ -185,6 +192,11 @@ def ensemble_kalman_filter_update( to be returned in the `EnsembleKalmanFilterState`. damping: Floating-point `Tensor` representing how much to damp the update by. Used to mitigate filter divergence. Default value: 1. + low_rank_ensemble: Whether to use a LinearOperatorLowRankUpdate (rather than + a dense Tensor) to represent the observation covariance. The "low rank" is + the ensemble size. This is useful only if (i) the ensemble size is much + less than the number of observations, and (ii) the LinearOperator + associated with the observation_fn has an efficient inverse seed: PRNG seed; see `tfp.random.sanitize_seed` for details. name: Python `str` name for ops created by this method. Default value: `None` (i.e., `'ensemble_kalman_filter_update'`). @@ -234,12 +246,6 @@ def ensemble_kalman_filter_update( # centered at the predicted observations. This is *not* the ensemble mean. predicted_observation_particles = observation_particles_dist.mean() - # With μ the ensemble average operator. For V a batch of column vectors, - # let Vᵀ be a batch of row vectors. - # Cov(G(X)) = (G(X) - μ(G(X))) (G(X) - μ(G(X)))ᵀ - observation_particles_covariance = _covariance( - predicted_observation_particles) - # covariance_between_state_and_predicted_observations # Cov(X, G(X)) = (X - μ(X))(G(X) - μ(G(X)))ᵀ covariance_between_state_and_predicted_observations = tf.nest.map_structure( @@ -250,43 +256,63 @@ def ensemble_kalman_filter_update( observation_particles_diff = ( observation - observation_particles_dist.sample(seed=seed)) - # = Cov(G(X)) + Γ - observation_particles_covariance = ( - observation_particles_covariance + - # Calling _linop_covariance(...).to_dense() rather than - # observation_particles_dist.covariance() means the shape is - # [observation_size, observation_size] rather than - # [ensemble_size] + [observation_size, observation_size]. - # Both work, since this matrix is used to do mat-vecs with ensembles - # of vectors...however, doing things this way ensures we do an - # efficient batch-matmul and (more importantly) don't have to do a - # separate Cholesky for every ensemble member! - _linop_covariance(observation_particles_dist).to_dense()) + # observation_particles_covariance ~ Cov(G(X)) + Γ + if low_rank_ensemble: + # observation_particles_covariance ~ LinearOperatorLowRankUpdate + observation_particles_covariance = _observation_particles_cov_linop( + predicted_observation_particles=predicted_observation_particles, + ensemble_mean_observations=tf.reduce_mean( + predicted_observation_particles, axis=0), + observation_cov=_linop_covariance(observation_particles_dist), + ) + else: + # observation_particles_covariance ~ LinearOperatorFullMatrix + observation_particles_covariance_matrix = ( + # With μ the ensemble average operator. For V a batch of column + # vectors, let Vᵀ be a batch of row vectors. Then + # _covariance(predicted_observation_particles) + # = Cov(G(X)) = (G(X) - μ(G(X))) (G(X) - μ(G(X)))ᵀ + _covariance(predicted_observation_particles) + + + # Calling _linop_covariance(...).to_dense() rather than + # observation_particles_dist.covariance() means the shape is + # [observation_size, observation_size] rather than + # [ensemble_size] + [observation_size, observation_size]. + # Both work, since this matrix is used to do mat-vecs with ensembles + # of vectors...however, doing things this way ensures we do an + # efficient batch-matmul and (more importantly) don't have to do a + # separate Cholesky for every ensemble member! + _linop_covariance(observation_particles_dist).to_dense() + ) + observation_particles_covariance = tf.linalg.LinearOperatorFullMatrix( + observation_particles_covariance_matrix, + # SPD because _linop_covariance(observation_particles_dist) is SPD + # and _covariance(predicted_observation_particles) is SSD + is_self_adjoint=True, + is_positive_definite=True, + ) # We specialize the univariate case. # TODO(srvasude): Refactor linear_gaussian_ssm, normal_conjugate_posteriors # and this code so we have a central place for normal conjugacy code. - if observation_size_is_static_and_scalar: + # Note that we do not use this code path if `low_rank_ensemble`, since our + # API specifies we will use a LinearOperatorLowRankUpdate. This code path + # would be a bit more efficient, but the user is warned in the docstring not + # to set `low_rank_ensemble=True` if the observation dimension is low. + if observation_size_is_static_and_scalar and not low_rank_ensemble: # In the univariate observation case, the Kalman gain is given by: # K = cov(X, Y) / (var(Y) + var_noise). That is we just divide # by the particle covariance plus the observation noise. kalman_gain = tf.nest.map_structure( - lambda x: x / observation_particles_covariance, + lambda x: x / observation_particles_covariance_matrix, covariance_between_state_and_predicted_observations) new_particles = tf.nest.map_structure( lambda x, g: x + damping * tf.linalg.matvec( # pylint:disable=g-long-lambda g, observation_particles_diff), state.particles, kalman_gain) else: - # TODO(b/153489530): Handle the case where the dimensionality of the - # observations is large. We can use the Sherman-Woodbury-Morrison - # identity in this case. - # added_term = [Cov(G(X)) + Γ]⁻¹ [Y - G(X) - η] - observation_particles_cholesky = tf.linalg.cholesky( - observation_particles_covariance) - added_term = tf.squeeze(tf.linalg.cholesky_solve( - observation_particles_cholesky, - observation_particles_diff[..., tf.newaxis]), axis=-1) + added_term = observation_particles_covariance.solvevec( + observation_particles_diff) # added_term # = covariance_between_state_and_predicted_observations @ added_term @@ -309,6 +335,7 @@ def ensemble_kalman_filter_log_marginal_likelihood( observation, observation_fn, perturbed_observations=True, + low_rank_ensemble=False, seed=None, name=None): """Ensemble Kalman filter log marginal likelihood. @@ -342,6 +369,11 @@ def ensemble_kalman_filter_log_marginal_likelihood( `False`, the distribution's covariance matrix is used directly. This latter choice is less common in the literature, but works even if the ensemble size is smaller than the number of observations. + low_rank_ensemble: Whether to use a LinearOperatorLowRankUpdate (rather than + a dense Tensor) to represent the observation covariance. The "low rank" is + the ensemble size. This is useful only if (i) the ensemble size is much + less than the number of observations, and (ii) the LinearOperator + associated with the observation_fn has an efficient inverse seed: PRNG seed; see `tfp.random.sanitize_seed` for details. name: Python `str` name for ops created by this method. Default value: `None` @@ -374,6 +406,10 @@ def ensemble_kalman_filter_log_marginal_likelihood( observation = tf.convert_to_tensor(observation, dtype=common_dtype) + if low_rank_ensemble and perturbed_observations: + raise ValueError( + 'A low rank update cannot be used with `perturbed_observations=True`') + if perturbed_observations: # With G the observation operator and B the batch shape, # observation_particles = G(X) + η, where η ~ Normal(0, Γ). @@ -392,15 +428,27 @@ def ensemble_kalman_filter_log_marginal_likelihood( # Cholesky(Cov(G(X) + η)), where Cov(..) is the ensemble covariance. scale_tril=tf.linalg.cholesky(_covariance(observation_particles))) else: - # predicted_observation = G(X), - # and is shape [n_ensemble] + B. - predicted_observation = observation_particles_dist.mean() - observation_dist = distributions.MultivariateNormalTriL( - loc=tf.reduce_mean(predicted_observation, axis=0), # ensemble mean - # Cholesky(Cov(G(X)) + Γ), where Cov(..) is the ensemble covariance. - scale_tril=tf.linalg.cholesky( - _covariance(predicted_observation) + - _linop_covariance(observation_particles_dist).to_dense())) + if low_rank_ensemble: # low_rank_ensemble and not perturbed_observations. + predicted_observation_particles = observation_particles_dist.mean() + ensemble_mean_observations = tf.reduce_mean( + predicted_observation_particles, axis=0) + observation_dist = MVNLowRankCov( + loc=ensemble_mean_observations, + cov_operator=_observation_particles_cov_linop( + predicted_observation_particles=predicted_observation_particles, + ensemble_mean_observations=ensemble_mean_observations, + observation_cov=_linop_covariance(observation_particles_dist), + )) + else: # not low_rank_ensemble and not perturbed_observations. + # predicted_observation = G(X), + # and is shape [n_ensemble] + B. + predicted_observations = observation_particles_dist.mean() + observation_dist = distributions.MultivariateNormalTriL( + loc=tf.reduce_mean(predicted_observations, axis=0), # ensemble mean + # Cholesky(Cov(G(X)) + Γ), where Cov(..) is the ensemble covariance. + scale_tril=tf.linalg.cholesky( + _covariance(predicted_observations) + + _linop_covariance(observation_particles_dist).to_dense())) # Above we computed observation_dist, the distribution of observations given # the predictive distribution of states (e.g. states from previous time). @@ -423,3 +471,51 @@ def _linop_covariance(dist): cov._is_positive_definite = True # pylint: disable=protected-access cov._is_self_adjoint = True # pylint: disable=protected-access return cov + + +def _observation_particles_cov_linop( + predicted_observation_particles, + ensemble_mean_observations, + observation_cov, +): + """LinearOperatorLowRankUpdate holding observation noise covariance. + + All arguments can be derived from `observation_particles_dist`. We pass them + as arguments to have a simpler graph, and encourage calling `.sample` once. + + Args: + predicted_observation_particles: Ensemble of state particles fed through the + observation function. `observation_particles_dist.mean()` + ensemble_mean_observations: Ensemble mean (mean across `axis=0`) of + `predicted_observation_particles`. + observation_cov: `LinearOperator` defining the observation noise covariance. + `_linop_covariance(observation_particles_dist)`. + + Returns: + LinearOperatorLowRankUpdate with covariance the sum of `observation_cov` + and the ensemble covariance of `predicted_observation_particles`. + """ + # In our usual docstring notation, let B be a batch shape, X be the ensemble + # of states, and G(X) the deterministic observation transformation of X. Then, + # predicted_observations_particles = G(X) (an ensemble) + # shape = [n_ensemble] + B + [n_observations] + # ensemble_mean_observations = + # tf.reduce_mean(predicted_observations, axis=0) # Ensemble mean + + # Create matrix U with shape B + [n_observations, n_ensemble] so that, with + # Cov the ensemble covariance, Cov(G(X)) = UUᵀ. + centered_observations = ( + predicted_observation_particles - + ensemble_mean_observations + ) + n_ensemble = tf.cast( + tf.shape(centered_observations)[0], centered_observations.dtype) + u = distribution_util.rotate_transpose( + centered_observations / tf.sqrt(n_ensemble), -1) + + # cov_operator ~ Γ + Cov(G(X)) + return tf.linalg.LinearOperatorLowRankUpdate( + base_operator=observation_cov, # = Γ + u=u, # UUᵀ = Cov(G(X)) + is_self_adjoint=True, + is_positive_definite=True) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py index 1f0d253ba0..5f82f73fb2 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter_test.py @@ -17,6 +17,7 @@ import collections # Dependency imports +from absl.testing import parameterized import numpy as np import tensorflow.compat.v2 as tf @@ -346,15 +347,16 @@ def observation_fn(_, particles, extra): @test_util.test_all_tf_execution_regimes -class KalmanFilterVersusEnKFTest(test_util.TestCase): - """Compare KF to EnKF with large ensemble sizes. +class ComparingMethodsTest(test_util.TestCase): + """Compare various KF EnKF versions. If the model is linear and Gaussian the EnKF sample mean/cov and marginal likelihood converges to that of a KF in the large ensemble limit. - This class tests that they are the same. It does that by implementing a one-step KF. It also does some simple checks on the KF, to make sure we didn't just replicate misunderstanding in the EnKF. + + This class also checks that various flavors of the EnKF are the same. """ def _random_spd_matrix(self, n, noise_level, seed, dtype): @@ -519,7 +521,7 @@ def _enkf_solve(self, observation, enkf_params, predict_kwargs, update_kwargs, n_observations=[2, 5], perturbed_observations=[False, True], )) - def test_same_solution( + def test_kf_vs_enkf( self, noise_level, n_states, @@ -537,7 +539,7 @@ def test_same_solution( predict_kwargs = {} update_kwargs = {} log_marginal_likelihood_kwargs = { - 'perturbed_observations': perturbed_observations + 'perturbed_observations': perturbed_observations, } linear_model_params = self._get_linear_model_params( @@ -601,6 +603,109 @@ def test_same_solution( self.assertAllCloseNested( kf_soln, enkf_soln, atol=20 * tol_scale, rtol=50 * tol_scale) + @parameterized.named_parameters( + dict( + testcase_name='low_rank_ensemble', + kwargs_1=dict( + predict={}, + update={ + 'low_rank_ensemble': False, + }, + log_marginal_likelihood={ + 'low_rank_ensemble': False, + 'perturbed_observations': False + }, + ), + kwargs_2=dict( + predict={}, + update={ + 'low_rank_ensemble': True, + }, + log_marginal_likelihood={ + 'low_rank_ensemble': True, + 'perturbed_observations': False + }, + ), + ), + dict( + testcase_name='low_rank_ensemble_1d_obs', + # n_observations = 1 invokes a special code path. + n_observations=1, + kwargs_1=dict( + predict={}, + update={ + 'low_rank_ensemble': False, + }, + log_marginal_likelihood={ + 'low_rank_ensemble': False, + 'perturbed_observations': False + }, + ), + kwargs_2=dict( + predict={}, + update={ + 'low_rank_ensemble': True, + }, + log_marginal_likelihood={ + 'low_rank_ensemble': True, + 'perturbed_observations': False + }, + ), + ), + ) + def test_cases_where_different_kwargs_give_same_enkf_result( + self, + kwargs_1, + kwargs_2, + n_states=5, + n_observations=5, + n_ensemble=10, + ): + """Check that two sets of kwargs give same result.""" + # In most cases, `test_kf_vs_enkf` is more complete, since it tests + # correctness. However, `test_kf_vs_enkf` requires a huge ensemble. + # This test is useful when you cannot use a huge ensemble and/or you want to + # compare to a method already checked for correctness by `test_kf_vs_enkf`. + salt = str(n_ensemble) + str(n_states) + str(n_observations) + seed_stream = test_util.test_seed_stream(salt) + dtype = tf.float64 + + linear_model_params = self._get_linear_model_params( + noise_level=0.1, + n_states=n_states, + n_observations=n_observations, + seed_stream=seed_stream, + dtype=dtype) + + # Ensure that our observation comes from a state that ~ prior. + prior_dist = tfd.MultivariateNormalTriL( + loc=linear_model_params.prior_mean, + scale_tril=tf.linalg.cholesky(linear_model_params.prior_cov)) + true_state = prior_dist.sample(seed=seed_stream()) + observation = tf.linalg.matvec(linear_model_params.observation_mat, + true_state) + + enkf_params = self._get_enkf_params(n_ensemble, linear_model_params, + prior_dist, seed_stream, dtype) + + # Use the exact same seeds for each. + enkf_soln_1 = self._enkf_solve(observation, enkf_params, + kwargs_1['predict'], kwargs_1['update'], + kwargs_1['log_marginal_likelihood'], + test_util.test_seed_stream(salt)) + enkf_soln_2 = self._enkf_solve(observation, enkf_params, + kwargs_2['predict'], kwargs_2['update'], + kwargs_2['log_marginal_likelihood'], + test_util.test_seed_stream(salt)) + + # Evaluate at the same time, so both use the same randomness! + # Do not use anything that was not evaluated here! + enkf_soln_1, enkf_soln_2 = self.evaluate([enkf_soln_1, enkf_soln_2]) + + # We used the same seed, so solutions should be identical up to tolerance of + # different solver methods. + self.assertAllCloseNested(enkf_soln_1, enkf_soln_2) + if __name__ == '__main__': test_util.main() From 13952c86c00d2b30501c7d08963b1c9d1f3e4e07 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Wed, 1 Jun 2022 11:59:04 -0700 Subject: [PATCH 147/153] Some small fixes for spike and slab Gibbs sampling. These mainly effect cases with not much data, by addressing how the priors are set: - the prior is set more carefully to account for missing data, - targets for spike and slab samplers are zero'd out where they are missing, - an optional and nonstandard update to the weight posterior precision is added, to support recreating a sampler from the literature. PiperOrigin-RevId: 452351044 --- .../python/experimental/sts_gibbs/BUILD | 1 + .../sts_gibbs/dynamic_spike_and_slab.py | 188 +++++++++------- .../sts_gibbs/dynamic_spike_and_slab_test.py | 34 +-- .../experimental/sts_gibbs/gibbs_sampler.py | 45 +++- .../experimental/sts_gibbs/spike_and_slab.py | 209 ++++++++++-------- .../sts_gibbs/spike_and_slab_test.py | 19 +- 6 files changed, 283 insertions(+), 213 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/BUILD b/tensorflow_probability/python/experimental/sts_gibbs/BUILD index 4449fb5796..2a12f3d68c 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/BUILD +++ b/tensorflow_probability/python/experimental/sts_gibbs/BUILD @@ -135,6 +135,7 @@ multi_substrate_py_library( "//tensorflow_probability/python/distributions:joint_distribution_auto_batched", "//tensorflow_probability/python/distributions:sample", "//tensorflow_probability/python/experimental/distributions:mvn_precision_factor_linop", + "//tensorflow_probability/python/internal:broadcast_util", "//tensorflow_probability/python/internal:parameter_properties", "//tensorflow_probability/python/internal:prefer_static", "//tensorflow_probability/python/internal:samplers", diff --git a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py index 94309faae9..8876357f99 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py @@ -31,9 +31,7 @@ from tensorflow_probability.python.internal import vectorization_util from tensorflow_probability.python.mcmc.internal import util as mcmc_util -__all__ = [ - 'DynamicSpikeSlabSampler' -] +__all__ = ['DynamicSpikeSlabSampler'] class InverseGammaWithSampleUpperBound(inverse_gamma.InverseGamma): @@ -41,9 +39,7 @@ class InverseGammaWithSampleUpperBound(inverse_gamma.InverseGamma): def __init__(self, concentration, scale, upper_bound, **kwargs): self._upper_bound = upper_bound - super().__init__(concentration=concentration, - scale=scale, - **kwargs) + super().__init__(concentration=concentration, scale=scale, **kwargs) @classmethod def _parameter_properties(cls, dtype, num_classes=None): @@ -87,10 +83,7 @@ def __init__(self, loc, precision_factor, nonzeros, **kwargs): def _call_sample_n(self, *args, **kwargs): xs = super()._call_sample_n(*args, **kwargs) - return tf.scatter_nd( - indices=self._indices, - updates=xs, - shape=[self._size]) + return tf.scatter_nd(indices=self._indices, updates=xs, shape=[self._size]) def _log_prob(self, *args, **kwargs): raise NotImplementedError('Log prob is not currently implemented.') @@ -104,13 +97,15 @@ def _parameter_properties(cls, dtype, num_classes=None): nonzeros=parameter_properties.BatchedComponentProperties(event_ndims=1)) -class DynamicSpikeSlabSamplerState(collections.namedtuple( - 'DynamicSpikeSlabSamplerState', - ['x_transpose_y', - 'y_transpose_y', - 'nonzeros', - 'observation_noise_variance_posterior_scale', - 'unnormalized_log_prob'])): +class DynamicSpikeSlabSamplerState( + collections.namedtuple('DynamicSpikeSlabSamplerState', [ + 'x_transpose_y', + 'y_transpose_y', + 'nonzeros', + 'weights_posterior_precision', + 'observation_noise_variance_posterior_scale', + 'unnormalized_log_prob' + ])): """Quantities maintained during a sweep of the spike and slab sampler. This state is generated and consumed by internal sampler methods. It is not @@ -127,6 +122,10 @@ class DynamicSpikeSlabSamplerState(collections.namedtuple( nonzeros: boolean `Tensor` of shape `[num_features]` indicating the current sparsity pattern (`gamma` in [1]). A value of `True` indicates that the corresponding feature has nonzero weight. + weights_posterior_precision: (batch of) float `Tensor`(s) of shape + `[num_features]`. This may optionally vary with the observation noise, + so is stored in the state, rather than the class. (`V^-1` in [1]) + sampled posterior (`SS_gamma / 2` in [1]). observation_noise_variance_posterior_scale: scalar float `Tensor` representing the scale parameter of the inverse gamma posterior on the observation noise variance (`SS_gamma / 2` in [1]). @@ -235,7 +234,8 @@ def __init__(self, default_pseudo_observations=1., observation_noise_variance_prior_concentration=0.005, observation_noise_variance_prior_scale=0.0025, - observation_noise_variance_upper_bound=None): + observation_noise_variance_upper_bound=None, + num_missing=0.): """Initializes priors for the spike and slab sampler. Args: @@ -243,48 +243,45 @@ def __init__(self, shape `[num_outputs, num_features]`. nonzero_prior_prob: scalar float `Tensor` prior probability of the 'slab', i.e., prior probability that any given feature has nonzero weight (`pi` - in [1]). - Default value: `0.5`. + in [1]). Default value: `0.5`. weights_prior_precision: float `Tensor` complete prior precision matrix over the weights, of shape `[num_features, num_features]`. If not specified, defaults to the Zellner g-prior specified in `[1]` as - `Omega^{-1} = kappa * (X'X + diag(X'X)) / (2 * num_outputs)`, - in which we've plugged in the suggested default of `w = 0.5`. The - parameter `kappa` is controlled by the `default_pseudo_observations` - argument. + `Omega^{-1} = kappa * (X'X + diag(X'X)) / (2 * num_outputs)`, in which + we've plugged in the suggested default of `w = 0.5`. The parameter + `kappa` is controlled by the `default_pseudo_observations` argument. Default value: `None`. - default_pseudo_observations: scalar float `Tensor` - Controls the number of pseudo-observations for the prior precision - matrix over the weights. Corresponds to `kappa` in [1]. See also - `weights_prior_precision`. + default_pseudo_observations: scalar float `Tensor` Controls the number of + pseudo-observations for the prior precision matrix over the weights. + Corresponds to `kappa` in [1]. See also `weights_prior_precision`. observation_noise_variance_prior_concentration: scalar float `Tensor` concentration parameter of the inverse gamma prior on the noise - variance. Corresponds to `nu / 2` in [1]. - Default value: 0.005. - observation_noise_variance_prior_scale: scalar float `Tensor` - scale parameter of the inverse gamma prior on the noise - variance. Corresponds to `ss / 2` in [1]. - Default value: 0.0025. + variance. Corresponds to `nu / 2` in [1]. Default value: 0.005. + observation_noise_variance_prior_scale: scalar float `Tensor` scale + parameter of the inverse gamma prior on the noise variance. Corresponds + to `ss / 2` in [1]. Default value: 0.0025. observation_noise_variance_upper_bound: optional scalar float `Tensor` maximum value of sampled observation noise variance. Specifying a bound can help avoid divergence when the sampler is initialized far from the - posterior. - Default value: `None`. + posterior. Default value: `None`. + num_missing: Optional scalar float `Tensor`. Corrects for how many missing + values are are coded as zero in the design matrix. """ with tf.name_scope('spike_slab_sampler'): dtype = dtype_util.common_dtype([ - design_matrix, - nonzero_prior_prob, - weights_prior_precision, + design_matrix, nonzero_prior_prob, weights_prior_precision, observation_noise_variance_prior_concentration, observation_noise_variance_prior_scale, - observation_noise_variance_upper_bound], dtype_hint=tf.float32) + observation_noise_variance_upper_bound, num_missing + ], + dtype_hint=tf.float32) design_matrix = tf.convert_to_tensor(design_matrix, dtype=dtype) nonzero_prior_prob = tf.convert_to_tensor(nonzero_prior_prob, dtype=dtype) observation_noise_variance_prior_concentration = tf.convert_to_tensor( observation_noise_variance_prior_concentration, dtype=dtype) observation_noise_variance_prior_scale = tf.convert_to_tensor( observation_noise_variance_prior_scale, dtype=dtype) + num_missing = tf.convert_to_tensor(num_missing, dtype=dtype) if observation_noise_variance_upper_bound is not None: observation_noise_variance_upper_bound = tf.convert_to_tensor( observation_noise_variance_upper_bound, dtype=dtype) @@ -294,7 +291,7 @@ def __init__(self, raise ValueError(f'DynamicSpikeSlabSampler does not support batched ' f'computation, but the design matrix has shape ' f'{design_matrix.shape}') - num_outputs = design_shape[-2] + num_outputs = tf.cast(design_shape[-2], dtype=dtype) - num_missing num_features = design_shape[-1] x_transpose_x = tf.matmul(design_matrix, design_matrix, adjoint_a=True) @@ -306,20 +303,19 @@ def __init__(self, 0.5 * x_transpose_x, tf.linalg.diag_part(x_transpose_x)) / num_outputs - weights_posterior_precision = x_transpose_x + weights_prior_precision observation_noise_variance_posterior_concentration = ( - observation_noise_variance_prior_concentration - + tf.convert_to_tensor(num_outputs / 2., dtype=dtype)) + observation_noise_variance_prior_concentration + + tf.convert_to_tensor(num_outputs / 2., dtype=dtype)) self.num_outputs = num_outputs self.num_features = num_features self.design_matrix = design_matrix + self.x_transpose_x = x_transpose_x self.dtype = dtype self.nonzeros_prior = sample_dist.Sample( bernoulli.Bernoulli(probs=nonzero_prior_prob), sample_shape=[num_features]) self.weights_prior_precision = weights_prior_precision - self.weights_posterior_precision = weights_posterior_precision self.observation_noise_variance_prior_concentration = ( observation_noise_variance_prior_concentration) self.observation_noise_variance_prior_scale = ( @@ -329,7 +325,11 @@ def __init__(self, self.observation_noise_variance_posterior_concentration = ( observation_noise_variance_posterior_concentration) - def sample_noise_variance_and_weights(self, targets, initial_nonzeros, seed): + def sample_noise_variance_and_weights(self, + targets, + initial_nonzeros, + seed, + previous_observation_noise_variance=1.): """(Re)samples regression parameters under the spike-and-slab model. Args: @@ -337,6 +337,11 @@ def sample_noise_variance_and_weights(self, targets, initial_nonzeros, seed): `[num_outputs]`. initial_nonzeros: boolean Tensor vector of shape `[num_features]`. seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + previous_observation_noise_variance: Optional float to scale the + `weights_prior_precision`. It is not recommended to use a number + other than 1 here, but it is here to allow matching existing + implementations. + Returns: observation_noise_variance: scalar float Tensor posterior sample of the observation noise variance, given the resampled sparsity pattern. @@ -345,17 +350,22 @@ def sample_noise_variance_and_weights(self, targets, initial_nonzeros, seed): *and* the sampled observation noise variance. Has shape `[num_features]`. """ + previous_observation_noise_variance = tf.convert_to_tensor( + previous_observation_noise_variance, dtype=self.dtype) feature_sweep_seed, resample_seed = samplers.split_seed(seed, n=2) - initial_state = self._initialize_sampler_state(targets=targets, - nonzeros=initial_nonzeros) + initial_state = self._initialize_sampler_state( + targets=targets, + observation_noise_variance=previous_observation_noise_variance, + nonzeros=initial_nonzeros) # Loop over the features to update their sparsity indicators. - final_state = self._resample_all_features(initial_state, - seed=feature_sweep_seed) + final_state = self._resample_all_features( + initial_state, seed=feature_sweep_seed) # Finally, sample parameters given the updated sparsity indicators. return self._get_conditional_posterior(final_state).sample( seed=resample_seed) - def _initialize_sampler_state(self, targets, nonzeros): + def _initialize_sampler_state(self, targets, nonzeros, + observation_noise_variance): """Precompute quantities needed to sample with given targets. This method computes a sampler state (including factorized precision @@ -368,6 +378,9 @@ def _initialize_sampler_state(self, targets, nonzeros): Args: targets: float Tensor regression outputs of shape `[num_outputs]`. nonzeros: boolean Tensor vectors of shape `[num_features]`. + observation_noise_variance: float Tensor of to scale the posterior + precision. + Returns: sampler_state: instance of `DynamicSpikeSlabSamplerState` collecting Tensor quantities relevant to the sampler. See @@ -381,16 +394,15 @@ def _initialize_sampler_state(self, targets, nonzeros): x_transpose_y = tf.linalg.matvec( self.design_matrix, targets, adjoint_a=True) + weights_posterior_precision = self.x_transpose_x + self.weights_prior_precision * observation_noise_variance y_transpose_y = tf.reduce_sum(targets**2, axis=-1) conditional_prior_precision_chol = tf.linalg.cholesky( tf.gather( - tf.gather(self.weights_prior_precision, indices), - indices, axis=1)) + tf.gather(self.weights_prior_precision, indices), indices, + axis=1)) conditional_posterior_precision_chol = tf.linalg.cholesky( tf.gather( - tf.gather(self.weights_posterior_precision, indices), - indices, - axis=1)) + tf.gather(weights_posterior_precision, indices), indices, axis=1)) sub_x_transpose_y = tf.gather(x_transpose_y, indices) conditional_weights_mean = tf.linalg.cholesky_solve( conditional_posterior_precision_chol, @@ -401,13 +413,14 @@ def _initialize_sampler_state(self, targets, nonzeros): nonzeros=nonzeros, conditional_prior_precision_chol=conditional_prior_precision_chol, conditional_posterior_precision_chol=conditional_posterior_precision_chol, + weights_posterior_precision=weights_posterior_precision, observation_noise_variance_posterior_scale=( self.observation_noise_variance_prior_scale + # ss / 2 - (y_transpose_y - - tf.reduce_sum( # beta_gamma' V_gamma^{-1} beta_gamma - conditional_weights_mean * sub_x_transpose_y, - axis=-1)) - / 2)) + ( + y_transpose_y - + tf.reduce_sum( # beta_gamma' V_gamma^{-1} beta_gamma + conditional_weights_mean * sub_x_transpose_y, + axis=-1)) / 2)) def _flip_feature(self, sampler_state, idx): """Proposes flipping the sparsity indicator of the `idx`th feature. @@ -425,6 +438,7 @@ def _flip_feature(self, sampler_state, idx): Tensor quantities relevant to the sampler. See the `DynamicSpikeSlabSamplerState` definition for details. idx: scalar int `Tensor` index in `[0, num_features)`. + Returns: updated_sampler_state: instance of `DynamicSpikeSlabSamplerState` equivalent to `self._initialize_sampler_state(targets, new_nonzeros)`, @@ -433,19 +447,20 @@ def _flip_feature(self, sampler_state, idx): """ with tf.name_scope('flip_feature_indicator'): was_nonzero = tf.gather(sampler_state.nonzeros, idx, axis=-1) - new_nonzeros = _set_vector_index( - sampler_state.nonzeros, idx, tf.logical_not(was_nonzero)) + new_nonzeros = _set_vector_index(sampler_state.nonzeros, idx, + tf.logical_not(was_nonzero)) # Update the weight posterior mean and precision for the new nonzeros. # (and also update the prior, used to compute the marginal likelihood). indices = tf.where(new_nonzeros)[:, 0] conditional_prior_precision_chol = tf.linalg.cholesky( tf.gather( - tf.gather(self.weights_prior_precision, indices), - indices, axis=1)) + tf.gather(self.weights_prior_precision, indices), indices, + axis=1)) conditional_posterior_precision_chol = tf.linalg.cholesky( tf.gather( - tf.gather(self.weights_posterior_precision, indices), - indices, axis=1)) + tf.gather(sampler_state.weights_posterior_precision, indices), + indices, + axis=1)) sub_x_transpose_y = tf.gather(sampler_state.x_transpose_y, indices) conditional_weights_mean = tf.linalg.cholesky_solve( conditional_posterior_precision_chol, @@ -456,12 +471,11 @@ def _flip_feature(self, sampler_state, idx): conditional_prior_precision_chol=conditional_prior_precision_chol, conditional_posterior_precision_chol=( conditional_posterior_precision_chol), + weights_posterior_precision=sampler_state.weights_posterior_precision, observation_noise_variance_posterior_scale=( self.observation_noise_variance_prior_scale + - (sampler_state.y_transpose_y - - tf.reduce_sum( - conditional_weights_mean * sub_x_transpose_y, - axis=-1)) / 2), + (sampler_state.y_transpose_y - tf.reduce_sum( + conditional_weights_mean * sub_x_transpose_y, axis=-1)) / 2), x_transpose_y=sampler_state.x_transpose_y) def _resample_all_features(self, initial_sampler_state, seed): @@ -479,6 +493,7 @@ def _resample_all_features(self, initial_sampler_state, seed): collecting Tensor quantities relevant to the sampler. See `DynamicSpikeSlabSamplerState` for details. seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + Returns: final sampler_state: instance of `DynamicSpikeSlabSamplerState` in which the sparsity indicators for all features have been resampled. @@ -511,14 +526,11 @@ def resample_one_feature(step, seed, sampler_state): loop_vars=(0, loop_seed, initial_sampler_state)) return final_sampler_state - def _compute_log_prob( - self, - x_transpose_y, - y_transpose_y, - nonzeros, - conditional_prior_precision_chol, - conditional_posterior_precision_chol, - observation_noise_variance_posterior_scale): # pylint: disable=g-doc-args + def _compute_log_prob(self, x_transpose_y, y_transpose_y, nonzeros, + conditional_prior_precision_chol, + conditional_posterior_precision_chol, + weights_posterior_precision, + observation_noise_variance_posterior_scale): # pylint: disable=g-doc-args """Computes an unnormalized log prob of a sampler state. This corresponds to equation (8) in [1]. It scores a sparsity pattern by @@ -526,8 +538,8 @@ def _compute_log_prob( that do not depend on the sparsity pattern) multiplied by the prior probability of the sparsity pattern. - Args: - See `DynamicSpikeSlabSamplerState`. + Args: See `DynamicSpikeSlabSamplerState`. + Returns: sampler_state: a `DynamicSpikeSlabSamplerState` instance containing the given args and the corresponding unnormalized log prob. @@ -536,27 +548,29 @@ def _compute_log_prob( x_transpose_y=x_transpose_y, y_transpose_y=y_transpose_y, nonzeros=nonzeros, + weights_posterior_precision=weights_posterior_precision, observation_noise_variance_posterior_scale=( observation_noise_variance_posterior_scale), unnormalized_log_prob=( # Equation (8) of [1]. _half_logdet(conditional_prior_precision_chol) - _half_logdet(conditional_posterior_precision_chol) + self.nonzeros_prior.log_prob(nonzeros) - - (self.observation_noise_variance_posterior_concentration - 1 - ) * tf.math.log(2 * observation_noise_variance_posterior_scale))) + (self.observation_noise_variance_posterior_concentration - 1) * + tf.math.log(2 * observation_noise_variance_posterior_scale))) def _get_conditional_posterior(self, sampler_state): """Builds the joint posterior for a sparsity pattern (eqn (7) from [1]).""" indices = ps.where(sampler_state.nonzeros)[:, 0] conditional_posterior_precision_chol = tf.linalg.cholesky( tf.gather( - tf.gather(self.weights_posterior_precision, indices), + tf.gather(sampler_state.weights_posterior_precision, indices), indices, axis=1)) conditional_weights_mean = tf.linalg.cholesky_solve( conditional_posterior_precision_chol, - tf.gather( - sampler_state.x_transpose_y, indices)[..., tf.newaxis])[..., 0] + tf.gather(sampler_state.x_transpose_y, indices)[..., tf.newaxis])[..., + 0] + @joint_distribution_auto_batched.JointDistributionCoroutineAutoBatched def posterior_jd(): observation_noise_variance = yield InverseGammaWithSampleUpperBound( @@ -565,6 +579,7 @@ def posterior_jd(): scale=sampler_state.observation_noise_variance_posterior_scale, upper_bound=self.observation_noise_variance_upper_bound, name='observation_noise_variance') + yield MVNPrecisionFactorHardZeros( loc=conditional_weights_mean, # Note that the posterior precision varies inversely with the @@ -585,6 +600,7 @@ def _set_vector_index_unbatched(v, idx, x): """Mutation-free equivalent of `v[idx] = x.""" return tf.tensor_scatter_nd_update(v, indices=[[idx]], updates=[x]) + _set_vector_index = vectorization_util.make_rank_polymorphic( _set_vector_index_unbatched, core_ndims=[1, 0, 0]) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py index 27a4359cae..d5de27f0f5 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab_test.py @@ -29,14 +29,6 @@ tfd = tfp.distributions -def _naive_symmetric_increment(m, idx, increment): - m = m.copy() - m[..., idx, :] += increment - m[..., :, idx] += increment - m[..., idx, idx] -= increment[..., idx] - return m - - def _compute_conditional_weights_mean(nonzeros, weights_posterior_precision, x_transpose_y): indices = tf.where(nonzeros)[:, 0] @@ -106,7 +98,7 @@ def test_posterior_on_nonzero_subset_matches_bayesian_regression( design_matrix, default_pseudo_observations=default_pseudo_observations) initial_state = sampler._initialize_sampler_state( - targets=targets, nonzeros=nonzeros) + targets=targets, nonzeros=nonzeros, observation_noise_variance=1.) # Compute the analytic posterior for the regression problem restricted to # only the selected features. Note that by slicing a submatrix of the @@ -124,9 +116,11 @@ def test_posterior_on_nonzero_subset_matches_bayesian_regression( # The sampler's posterior should match the posterior from the restricted # problem. + weights_posterior_precision = (sampler.x_transpose_x + + sampler.weights_prior_precision) conditional_weights_mean = _compute_conditional_weights_mean( initial_state.nonzeros, - sampler.weights_posterior_precision, + weights_posterior_precision, initial_state.x_transpose_y) self.assertAllClose( self.evaluate( @@ -168,7 +162,8 @@ def test_noise_variance_posterior_matches_expected(self): self.assertAllClose( tight_slab_sampler._initialize_sampler_state( targets=targets, - nonzeros=tf.ones([num_features], dtype=tf.bool) + nonzeros=tf.ones([num_features], dtype=tf.bool), + observation_noise_variance=1. ).observation_noise_variance_posterior_scale, naive_posterior.scale, atol=1e-2) @@ -186,7 +181,8 @@ def test_noise_variance_posterior_matches_expected(self): self.assertAllClose( downweighted_slab_sampler._initialize_sampler_state( targets=targets, - nonzeros=tf.zeros([num_features], dtype=tf.bool) + nonzeros=tf.zeros([num_features], dtype=tf.bool), + observation_noise_variance=1. ).observation_noise_variance_posterior_scale, naive_posterior.scale) @@ -220,14 +216,16 @@ def test_updated_state_matches_initial_computation( @tf.function(autograph=False, jit_compile=False) def _do_flips(): state = sampler._initialize_sampler_state( - targets=targets, nonzeros=initial_nonzeros) + targets=targets, + nonzeros=initial_nonzeros, + observation_noise_variance=1.) def _do_flip(state, i): new_state = sampler._flip_feature(state, tf.gather(flip_idxs, i)) return mcmc_util.choose(tf.gather(should_flip, i), new_state, state) return tf.foldl(_do_flip, elems=tf.range(num_flips), initializer=state) self.assertAllCloseNested( - sampler._initialize_sampler_state(targets, nonzeros), + sampler._initialize_sampler_state(targets, nonzeros, 1.), _do_flips(), atol=1e-6, rtol=1e-6) @@ -247,15 +245,19 @@ def test_sanity_check_sweep_over_features(self): # Ensure the probability of keeping an irrelevant feature is tiny. nonzero_prior_prob=1e-6) initial_state = sampler._initialize_sampler_state( - targets=targets, nonzeros=tf.convert_to_tensor([True, True, True])) + targets=targets, + nonzeros=tf.convert_to_tensor([True, True, True]), + observation_noise_variance=1.) final_state = self.evaluate( sampler._resample_all_features( initial_state, seed=test_util.test_seed())) # Check that we recovered the true sparsity pattern and approximate weights. + weights_posterior_precision = (sampler.x_transpose_x + + sampler.weights_prior_precision) conditional_weights_mean = _compute_conditional_weights_mean( final_state.nonzeros, - sampler.weights_posterior_precision, + weights_posterior_precision, final_state.x_transpose_y) self.assertAllEqual(final_state.nonzeros, [True, False, True]) indices = tf.where(final_state.nonzeros) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index eb55767500..a881b3dee9 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -348,7 +348,8 @@ def fit_with_gibbs_sampling(model, initial_state=None, seed=None, default_pseudo_observations=None, - experimental_use_dynamic_cholesky=False): + experimental_use_dynamic_cholesky=False, + experimental_use_weight_adjustment=False): """Fits parameters for an STS model using Gibbs sampling. Args: @@ -375,6 +376,9 @@ def fit_with_gibbs_sampling(model, a speedup when the number of true features is small compared to the size of the design matrix. *Note*: If this is true, neither batch shape nor `jit_compile` is supported. + experimental_use_weight_adjustment: Optional bool - use a nonstandard + update for the posterior precision of the weight in case of a spike and + slab sampler. Returns: @@ -433,7 +437,7 @@ def fit_with_gibbs_sampling(model, sampler_loop_body = _build_sampler_loop_body( model, observed_time_series, is_missing, default_pseudo_observations, - experimental_use_dynamic_cholesky) + experimental_use_dynamic_cholesky, experimental_use_weight_adjustment) samples = tf.scan(sampler_loop_body, np.arange(num_warmup_steps + num_results), initial_state) @@ -756,7 +760,8 @@ def _build_sampler_loop_body(model, observed_time_series, is_missing=None, default_pseudo_observations=None, - experimental_use_dynamic_cholesky=False): + experimental_use_dynamic_cholesky=False, + experimental_use_weight_adjustment=False): """Builds a Gibbs sampler for the given model and observed data. Args: @@ -774,6 +779,9 @@ def _build_sampler_loop_body(model, active features to perform the Cholesky decomposition. This may provide a speedup when the number of true features is small compared to the size of the design matrix. + experimental_use_weight_adjustment: Optional bool - use a nonstandard + update for the posterior precision of the weight in case of a spike and + slab sampler. Returns: sampler_loop_body: Python callable that performs a single cycle of Gibbs @@ -811,17 +819,22 @@ def _build_sampler_loop_body(model, observed_time_series = tf.where(is_missing, tf.zeros_like(observed_time_series), observed_time_series) - num_observed_steps = prefer_static.shape(observed_time_series)[-1] design_matrix = _get_design_matrix(model) + num_missing = 0. if design_matrix is not None: design_matrix = design_matrix.to_dense()[:num_observed_steps] - if is_missing is not None: + if is_missing is None: + num_missing = 0. + is_missing = tf.zeros(num_observed_steps, dtype=bool) + else: # Replace design matrix with zeros at unobserved timesteps. This ensures # they will not affect the posterior on weights. design_matrix = tf.where(is_missing[..., tf.newaxis], tf.zeros_like(design_matrix), design_matrix) + num_missing = tf.reduce_sum( + tf.cast(is_missing, design_matrix.dtype), axis=-1) # Untransform scale priors -> variance priors by reaching thru Sqrt bijector. observation_noise_param = model.parameters[0] @@ -857,6 +870,7 @@ def _build_sampler_loop_body(model, tf.math.square(observation_noise_variance_prior.upper_bound) if hasattr(observation_noise_variance_prior, 'upper_bound') else None), + num_missing=num_missing, **({ 'default_pseudo_observations': default_pseudo_observations } if default_pseudo_observations is not None else {})) @@ -890,12 +904,21 @@ def sampler_loop_body(previous_sample, _): # arbitrary variation, while the weights are limited to representing # variation in the subspace given by the design matrix. if model_has_spike_slab_regression: - (observation_noise_variance, - weights) = spike_and_slab_sampler.sample_noise_variance_and_weights( - initial_nonzeros=tf.math.logical_or( - tf.not_equal(previous_sample.weights, 0.), pin_to_nonzero), - targets=observed_time_series - previous_sample.level, - seed=weights_seed) + if experimental_use_weight_adjustment: + previous_observation_noise_variance = tf.square( + previous_sample.observation_noise_scale) + else: + previous_observation_noise_variance = 1. + targets = tf.where(is_missing, + tf.zeros_like(observed_time_series), + observed_time_series - previous_sample.level) + (observation_noise_variance, weights + ) = spike_and_slab_sampler.sample_noise_variance_and_weights( + initial_nonzeros=tf.math.logical_or( + tf.not_equal(previous_sample.weights, 0.), pin_to_nonzero), + previous_observation_noise_variance=previous_observation_noise_variance, + targets=targets, + seed=weights_seed) observation_noise_scale = tf.sqrt(observation_noise_variance) else: diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py index 5fea29a376..0262dbde37 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab.py @@ -25,6 +25,7 @@ from tensorflow_probability.python.distributions import joint_distribution_auto_batched from tensorflow_probability.python.distributions import sample as sample_dist from tensorflow_probability.python.experimental.distributions import MultivariateNormalPrecisionFactorLinearOperator +from tensorflow_probability.python.internal import broadcast_util from tensorflow_probability.python.internal import dtype_util from tensorflow_probability.python.internal import parameter_properties from tensorflow_probability.python.internal import prefer_static as ps @@ -32,10 +33,7 @@ from tensorflow_probability.python.internal import vectorization_util from tensorflow_probability.python.mcmc.internal import util as mcmc_util - -__all__ = [ - 'SpikeSlabSampler' -] +__all__ = ['SpikeSlabSampler'] class InverseGammaWithSampleUpperBound(inverse_gamma.InverseGamma): @@ -43,9 +41,7 @@ class InverseGammaWithSampleUpperBound(inverse_gamma.InverseGamma): def __init__(self, concentration, scale, upper_bound, **kwargs): self._upper_bound = upper_bound - super().__init__(concentration=concentration, - scale=scale, - **kwargs) + super().__init__(concentration=concentration, scale=scale, **kwargs) @classmethod def _parameter_properties(cls, dtype, num_classes=None): @@ -95,15 +91,17 @@ def _parameter_properties(cls, dtype, num_classes=None): nonzeros=parameter_properties.BatchedComponentProperties(event_ndims=1)) -class SpikeSlabSamplerState(collections.namedtuple( - 'SpikeSlabSamplerState', - ['x_transpose_y', - 'nonzeros', - 'conditional_prior_precision_chol', - 'conditional_posterior_precision_chol', - 'conditional_weights_mean', - 'observation_noise_variance_posterior_scale', - 'unnormalized_log_prob'])): +class SpikeSlabSamplerState( + collections.namedtuple('SpikeSlabSamplerState', [ + 'x_transpose_y', + 'nonzeros', + 'conditional_prior_precision_chol', + 'conditional_posterior_precision_chol', + 'conditional_weights_mean', + 'weights_posterior_precision', + 'observation_noise_variance_posterior_scale', + 'unnormalized_log_prob' + ])): """Quantities maintained during a sweep of the spike and slab sampler. This state is generated and consumed by internal sampler methods. It is not @@ -134,6 +132,10 @@ class SpikeSlabSamplerState(collections.namedtuple( `[num_features]`, giving the posterior mean weight vector (`beta_gamma` in [1]). This has nonzero values in locations where `nonzeros` is True, and zeros elsewhere. + weights_posterior_precision: (batch of) float `Tensor`(s) of shape + `[num_features]`. This may optionally vary with the observation noise, + so is stored in the state, rather than the class. (`V^-1` in [1]) + sampled posterior (`SS_gamma / 2` in [1]). observation_noise_variance_posterior_scale: (batch of) scalar float `Tensor`s representing the scale parameter of the inverse gamma posterior on the observation noise variance (`SS_gamma / 2` in [1]). @@ -239,63 +241,60 @@ def __init__(self, default_pseudo_observations=1., observation_noise_variance_prior_concentration=0.005, observation_noise_variance_prior_scale=0.0025, - observation_noise_variance_upper_bound=None): + observation_noise_variance_upper_bound=None, + num_missing=0.): """Initializes priors for the spike and slab sampler. Args: - design_matrix: (batch of) float `Tensor`(s) regression design matrix - (`X` in [1]) having shape `[num_outputs, num_features]`. + design_matrix: (batch of) float `Tensor`(s) regression design matrix (`X` + in [1]) having shape `[num_outputs, num_features]`. nonzero_prior_prob: scalar float `Tensor` prior probability of the 'slab', i.e., prior probability that any given feature has nonzero weight (`pi` - in [1]). - Default value: `0.5`. + in [1]). Default value: `0.5`. weights_prior_precision: (batch of) float `Tensor` complete prior - precision matrix(s) over the weights, of shape - `[num_features, num_features]`. If not specified, defaults to the - Zellner g-prior specified in `[1]` as - `Omega^{-1} = kappa * (X'X + diag(X'X)) / (2 * num_outputs)`, - in which we've plugged in the suggested default of `w = 0.5`. The - parameter `kappa` is controlled by the `default_pseudo_observations` - argument. - Default value: `None`. - default_pseudo_observations: scalar float `Tensor` - Controls the number of pseudo-observations for the prior precision - matrix over the weights. Corresponds to `kappa` in [1]. See also - `weights_prior_precision`. + precision matrix(s) over the weights, of shape `[num_features, + num_features]`. If not specified, defaults to the Zellner g-prior + specified in `[1]` as `Omega^{-1} = kappa * (X'X + diag(X'X)) / (2 * + num_outputs)`, in which we've plugged in the suggested default of `w = + 0.5`. The parameter `kappa` is controlled by the + `default_pseudo_observations` argument. Default value: `None`. + default_pseudo_observations: scalar float `Tensor` Controls the number of + pseudo-observations for the prior precision matrix over the weights. + Corresponds to `kappa` in [1]. See also `weights_prior_precision`. observation_noise_variance_prior_concentration: scalar float `Tensor` concentration parameter of the inverse gamma prior on the noise - variance. Corresponds to `nu / 2` in [1]. - Default value: 0.005. - observation_noise_variance_prior_scale: scalar float `Tensor` - scale parameter of the inverse gamma prior on the noise - variance. Corresponds to `ss / 2` in [1]. - Default value: 0.0025. + variance. Corresponds to `nu / 2` in [1]. Default value: 0.005. + observation_noise_variance_prior_scale: scalar float `Tensor` scale + parameter of the inverse gamma prior on the noise variance. Corresponds + to `ss / 2` in [1]. Default value: 0.0025. observation_noise_variance_upper_bound: optional scalar float `Tensor` maximum value of sampled observation noise variance. Specifying a bound can help avoid divergence when the sampler is initialized far from the - posterior. - Default value: `None`. + posterior. Default value: `None`. + num_missing: Optional scalar float `Tensor`. Corrects for how many missing + values are are coded as zero in the design matrix. """ with tf.name_scope('spike_slab_sampler'): dtype = dtype_util.common_dtype([ - design_matrix, - nonzero_prior_prob, - weights_prior_precision, + design_matrix, nonzero_prior_prob, weights_prior_precision, observation_noise_variance_prior_concentration, observation_noise_variance_prior_scale, - observation_noise_variance_upper_bound], dtype_hint=tf.float32) + observation_noise_variance_upper_bound, num_missing + ], + dtype_hint=tf.float32) design_matrix = tf.convert_to_tensor(design_matrix, dtype=dtype) nonzero_prior_prob = tf.convert_to_tensor(nonzero_prior_prob, dtype=dtype) observation_noise_variance_prior_concentration = tf.convert_to_tensor( observation_noise_variance_prior_concentration, dtype=dtype) observation_noise_variance_prior_scale = tf.convert_to_tensor( observation_noise_variance_prior_scale, dtype=dtype) + num_missing = tf.convert_to_tensor(num_missing, dtype=dtype) if observation_noise_variance_upper_bound is not None: observation_noise_variance_upper_bound = tf.convert_to_tensor( observation_noise_variance_upper_bound, dtype=dtype) design_shape = ps.shape(design_matrix) - num_outputs = design_shape[-2] + num_outputs = tf.cast(design_shape[-2], dtype=dtype) - num_missing num_features = design_shape[-1] x_transpose_x = tf.matmul(design_matrix, design_matrix, adjoint_a=True) @@ -303,24 +302,25 @@ def __init__(self, # Default prior: 'Zellner’s g−prior' from section 3.2.1 of [1]: # `omega^{-1} = kappa * (w X'X + (1 − w) diag(X'X))/n` # with default `w = 0.5`. + padded_inputs = broadcast_util.left_justified_expand_dims_like( + num_outputs, x_transpose_x) weights_prior_precision = default_pseudo_observations * tf.linalg.set_diag( 0.5 * x_transpose_x, - tf.linalg.diag_part(x_transpose_x)) / num_outputs + tf.linalg.diag_part(x_transpose_x)) / padded_inputs - weights_posterior_precision = x_transpose_x + weights_prior_precision observation_noise_variance_posterior_concentration = ( - observation_noise_variance_prior_concentration - + tf.convert_to_tensor(num_outputs / 2., dtype=dtype)) + observation_noise_variance_prior_concentration + + tf.convert_to_tensor(num_outputs / 2., dtype=dtype)) self.num_outputs = num_outputs self.num_features = num_features self.design_matrix = design_matrix + self.x_transpose_x = x_transpose_x self.dtype = dtype self.nonzeros_prior = sample_dist.Sample( bernoulli.Bernoulli(probs=nonzero_prior_prob), sample_shape=[num_features]) self.weights_prior_precision = weights_prior_precision - self.weights_posterior_precision = weights_posterior_precision self.observation_noise_variance_prior_concentration = ( observation_noise_variance_prior_concentration) self.observation_noise_variance_prior_scale = ( @@ -330,7 +330,11 @@ def __init__(self, self.observation_noise_variance_posterior_concentration = ( observation_noise_variance_posterior_concentration) - def sample_noise_variance_and_weights(self, targets, initial_nonzeros, seed): + def sample_noise_variance_and_weights(self, + targets, + initial_nonzeros, + seed, + previous_observation_noise_variance=1.): """(Re)samples regression parameters under the spike-and-slab model. Args: @@ -339,6 +343,9 @@ def sample_noise_variance_and_weights(self, targets, initial_nonzeros, seed): initial_nonzeros: (batch of) boolean Tensor vector(s) of shape `[num_features]`. seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + previous_observation_noise_variance: Optional float to scale the + `weights_prior_precision`. This behavior is not recommended. + Returns: observation_noise_variance: (batch of) scalar float Tensor posterior sample(s) of the observation noise variance, given the resampled @@ -348,17 +355,22 @@ def sample_noise_variance_and_weights(self, targets, initial_nonzeros, seed): weight vector) *and* the sampled observation noise variance. Has shape `[num_features]`. """ + previous_observation_noise_variance = tf.convert_to_tensor( + previous_observation_noise_variance, dtype=self.dtype) feature_sweep_seed, resample_seed = samplers.split_seed(seed, n=2) - initial_state = self._initialize_sampler_state(targets=targets, - nonzeros=initial_nonzeros) + initial_state = self._initialize_sampler_state( + targets=targets, + observation_noise_variance=previous_observation_noise_variance, + nonzeros=initial_nonzeros) # Loop over the features to update their sparsity indicators. - final_state = self._resample_all_features(initial_state, - seed=feature_sweep_seed) + final_state = self._resample_all_features( + initial_state, seed=feature_sweep_seed) # Finally, sample parameters given the updated sparsity indicators. return self._get_conditional_posterior(final_state).sample( seed=resample_seed) - def _initialize_sampler_state(self, targets, nonzeros): + def _initialize_sampler_state(self, targets, nonzeros, + observation_noise_variance): """Precompute quantities needed to sample with given targets. This method computes a sampler state (including factorized precision @@ -372,6 +384,9 @@ def _initialize_sampler_state(self, targets, nonzeros): targets: (batch of) float Tensor regression outputs of shape `[num_outputs]`. nonzeros: (batch of) boolean Tensor vectors of shape `[num_features]`. + observation_noise_variance: float Tensor of to scale the posterior + precision. + Returns: sampler_state: instance of `SpikeSlabSamplerState` collecting (potentially batched) Tensor quantities relevant to the sampler. See @@ -388,32 +403,34 @@ def _initialize_sampler_state(self, targets, nonzeros): batch_shape = ps.shape(x_transpose_y)[:-1] nonzeros = tf.broadcast_to( nonzeros, - ps.broadcast_shape(ps.shape(nonzeros), - ps.concat([batch_shape, [1]], axis=0))) + ps.broadcast_shape( + ps.shape(nonzeros), ps.concat([batch_shape, [1]], axis=0))) + weights_posterior_precision = self.x_transpose_x + self.weights_prior_precision * observation_noise_variance conditional_prior_precision_chol = tf.linalg.cholesky( _select_nonzero_block(self.weights_prior_precision, nonzeros)) conditional_posterior_precision_chol = tf.linalg.cholesky( - _select_nonzero_block(self.weights_posterior_precision, nonzeros)) + _select_nonzero_block(weights_posterior_precision, + nonzeros)) conditional_weights_mean = tf.where( nonzeros, tf.linalg.cholesky_solve(conditional_posterior_precision_chol, - x_transpose_y[..., tf.newaxis])[..., 0], - 0.) + x_transpose_y[..., tf.newaxis])[..., 0], 0.) return self._compute_log_prob( x_transpose_y=x_transpose_y, nonzeros=nonzeros, conditional_prior_precision_chol=conditional_prior_precision_chol, conditional_posterior_precision_chol=conditional_posterior_precision_chol, + weights_posterior_precision=weights_posterior_precision, conditional_weights_mean=conditional_weights_mean, observation_noise_variance_posterior_scale=( # SS_gamma / 2 from eqn (7) of [1]. self.observation_noise_variance_prior_scale + # ss / 2 - (tf.reduce_sum(targets**2, axis=-1) - # y'y - tf.reduce_sum( # beta_gamma' V_gamma^{-1} beta_gamma - conditional_weights_mean * x_transpose_y, - axis=-1)) - / 2)) + ( + tf.reduce_sum(targets**2, axis=-1) - # y'y + tf.reduce_sum( # beta_gamma' V_gamma^{-1} beta_gamma + conditional_weights_mean * x_transpose_y, + axis=-1)) / 2)) def _flip_feature(self, sampler_state, idx): """Proposes flipping the sparsity indicator of the `idx`th feature. @@ -432,6 +449,7 @@ def _flip_feature(self, sampler_state, idx): `SpikeSlabSamplerState` definition for details. idx: scalar int `Tensor` index in `[0, num_features)`. This is a single value shared across all batch elements. + Returns: updated_sampler_state: instance of `SpikeSlabSamplerState` equivalent to `self._initialize_sampler_state(targets, new_nonzeros)`, where @@ -440,8 +458,8 @@ def _flip_feature(self, sampler_state, idx): """ with tf.name_scope('flip_feature_indicator'): was_nonzero = tf.gather(sampler_state.nonzeros, idx, axis=-1) - new_nonzeros = _set_vector_index( - sampler_state.nonzeros, idx, tf.logical_not(was_nonzero)) + new_nonzeros = _set_vector_index(sampler_state.nonzeros, idx, + tf.logical_not(was_nonzero)) # Update the weight posterior mean and precision for the new nonzeros. # (and also update the prior, used to compute the marginal likelihood). @@ -457,14 +475,15 @@ def _flip_feature(self, sampler_state, idx): new_conditional_posterior_precision_chol = _update_nonzero_block_chol( chol=sampler_state.conditional_posterior_precision_chol, idx=idx, - psd_matrix=self.weights_posterior_precision, + psd_matrix=sampler_state.weights_posterior_precision, new_nonzeros=new_nonzeros, previous_nonzeros=sampler_state.nonzeros) new_conditional_weights_mean = tf.where( new_nonzeros, - tf.linalg.cholesky_solve( - new_conditional_posterior_precision_chol, - sampler_state.x_transpose_y[..., tf.newaxis])[..., 0], + tf.linalg.cholesky_solve(new_conditional_posterior_precision_chol, + sampler_state.x_transpose_y[..., + tf.newaxis])[..., + 0], 0.) return self._compute_log_prob( nonzeros=new_nonzeros, @@ -473,6 +492,7 @@ def _flip_feature(self, sampler_state, idx): conditional_posterior_precision_chol=( new_conditional_posterior_precision_chol), conditional_weights_mean=new_conditional_weights_mean, + weights_posterior_precision=sampler_state.weights_posterior_precision, observation_noise_variance_posterior_scale=( sampler_state.observation_noise_variance_posterior_scale - tf.reduce_sum( @@ -497,6 +517,7 @@ def _resample_all_features(self, initial_sampler_state, seed): (potentially batched) Tensor quantities relevant to the sampler. See `SpikeSlabSamplerState` for details. seed: PRNG seed; see `tfp.random.sanitize_seed` for details. + Returns: final sampler_state: instance of `SpikeSlabSamplerState` in which the sparsity indicators for all features have been resampled. @@ -529,14 +550,12 @@ def resample_one_feature(step, seed, sampler_state): loop_vars=(0, loop_seed, initial_sampler_state)) return final_sampler_state - def _compute_log_prob( - self, - x_transpose_y, - nonzeros, - conditional_prior_precision_chol, - conditional_posterior_precision_chol, - conditional_weights_mean, - observation_noise_variance_posterior_scale): # pylint: disable=g-doc-args + def _compute_log_prob(self, x_transpose_y, nonzeros, + conditional_prior_precision_chol, + conditional_posterior_precision_chol, + conditional_weights_mean, + weights_posterior_precision, + observation_noise_variance_posterior_scale): # pylint: disable=g-doc-args """Computes an unnormalized log prob of a sampler state. This corresponds to equation (8) in [1]. It scores a sparsity pattern by @@ -544,8 +563,8 @@ def _compute_log_prob( that do not depend on the sparsity pattern) multiplied by the prior probability of the sparsity pattern. - Args: - See `SpikeSlabSamplerState`. + Args: See `SpikeSlabSamplerState`. + Returns: sampler_state: a `SpikeSlabSamplerState` instance containing the given args and the corresponding unnormalized log prob. @@ -556,17 +575,19 @@ def _compute_log_prob( conditional_prior_precision_chol=conditional_prior_precision_chol, conditional_posterior_precision_chol=conditional_posterior_precision_chol, conditional_weights_mean=conditional_weights_mean, + weights_posterior_precision=weights_posterior_precision, observation_noise_variance_posterior_scale=( observation_noise_variance_posterior_scale), unnormalized_log_prob=( # Equation (8) of [1]. _half_logdet(conditional_prior_precision_chol) - _half_logdet(conditional_posterior_precision_chol) + self.nonzeros_prior.log_prob(nonzeros) - - (self.observation_noise_variance_posterior_concentration - 1 - ) * tf.math.log(2 * observation_noise_variance_posterior_scale))) + (self.observation_noise_variance_posterior_concentration - 1) * + tf.math.log(2 * observation_noise_variance_posterior_scale))) def _get_conditional_posterior(self, sampler_state): """Builds the joint posterior for a sparsity pattern (eqn (7) from [1]).""" + @joint_distribution_auto_batched.JointDistributionCoroutineAutoBatched def posterior_jd(): observation_noise_variance = yield InverseGammaWithSampleUpperBound( @@ -612,9 +633,10 @@ def _select_nonzero_block(matrix, nonzeros): the features are left at their original indices (not permuted). Args: - matrix: (batch of) float Tensor matrix(s) of shape - `[num_features, num_features]`. + matrix: (batch of) float Tensor matrix(s) of shape `[num_features, + num_features]`. nonzeros: (batch of) boolean Tensor vectors of shape `[num_features]`. + Returns: block_matrix: (batch of) float Tensor matrix(s) of the same shape as `matrix`, in which `block_matrix[i, j] = matrix[i, j] if @@ -624,16 +646,15 @@ def _select_nonzero_block(matrix, nonzeros): """ # Zero out all entries in the not-selected rows. masked = tf.where(nonzeros[..., tf.newaxis], - tf.where(nonzeros[..., tf.newaxis, :], matrix, 0.), - 0.) + tf.where(nonzeros[..., tf.newaxis, :], matrix, 0.), 0.) # Restore a value of 1 on the diagonal of the not-selected rows. This avoids # numerical issues by ensuring that the matrix still has full rank. return tf.linalg.set_diag(masked, tf.where(nonzeros, tf.linalg.diag_part(masked), 1.)) -def _update_nonzero_block_chol( - chol, idx, psd_matrix, new_nonzeros, previous_nonzeros): +def _update_nonzero_block_chol(chol, idx, psd_matrix, new_nonzeros, + previous_nonzeros): """Efficient update to the cholesky factor of the 'slab' (nonzero) submatrix. This performs an efficient update when `nonzeros` changes by a single entry. @@ -658,6 +679,7 @@ def _update_nonzero_block_chol( new_nonzeros: (batch of) boolean Tensor vectors of shape `[num_features]`. previous_nonzeros: (batch of) boolean Tensor vectors of shape `[num_features]`. + Returns: updated_chol: (batch of) float Tensor lower-triangular Cholesky factor(s) of `select_nonzero_block(psd_matrix, new_nonzeros)`. @@ -719,6 +741,7 @@ def _symmetric_increment_chol(chol, idx, increment): update. increment: (batch of) float `Tensor` vector(s) to add to the given row and column of `M`. + Returns: updated_chol: float `Tensor` lower-triangular Cholesky factor of the symmetric matrix resulting from adding `increment` to the @@ -764,14 +787,14 @@ def _symmetric_increment_chol(chol, idx, increment): # TODO(b/229298550): Investigate whether this is really necessary, or if the # test failures we see without this line are due to an underlying bug. return tf.where((tf.range(chol.shape[-1]) < idx)[..., tf.newaxis], - orig_chol, - chol) + orig_chol, chol) def _set_vector_index_unbatched(v, idx, x): """Mutation-free equivalent of `v[idx] = x.""" return tf.tensor_scatter_nd_update(v, indices=[[idx]], updates=[x]) + _set_vector_index = vectorization_util.make_rank_polymorphic( _set_vector_index_unbatched, core_ndims=[1, 0, 0]) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py index 02092b8ee4..000e1ba79d 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/spike_and_slab_test.py @@ -125,7 +125,7 @@ def test_posterior_on_nonzero_subset_matches_bayesian_regression( design_matrix, default_pseudo_observations=default_pseudo_observations) initial_state = sampler._initialize_sampler_state( - targets=targets, nonzeros=nonzeros) + targets=targets, nonzeros=nonzeros, observation_noise_variance=1.) # Compute the analytic posterior for the regression problem restricted to # only the selected features. Note that by slicing a submatrix of the @@ -186,7 +186,8 @@ def test_noise_variance_posterior_matches_expected(self): self.assertAllClose( tight_slab_sampler._initialize_sampler_state( targets=targets, - nonzeros=tf.ones([num_features], dtype=tf.bool) + nonzeros=tf.ones([num_features], dtype=tf.bool), + observation_noise_variance=1. ).observation_noise_variance_posterior_scale, naive_posterior.scale, atol=1e-2) @@ -204,7 +205,8 @@ def test_noise_variance_posterior_matches_expected(self): self.assertAllClose( downweighted_slab_sampler._initialize_sampler_state( targets=targets, - nonzeros=tf.zeros([num_features], dtype=tf.bool) + nonzeros=tf.zeros([num_features], dtype=tf.bool), + observation_noise_variance=1. ).observation_noise_variance_posterior_scale, naive_posterior.scale) @@ -242,14 +244,16 @@ def test_updated_state_matches_initial_computation( @tf.function(autograph=False, jit_compile=use_xla) def _do_flips(): state = sampler._initialize_sampler_state( - targets=targets, nonzeros=initial_nonzeros) + targets=targets, + nonzeros=initial_nonzeros, + observation_noise_variance=1.) def _do_flip(state, i): new_state = sampler._flip_feature(state, tf.gather(flip_idxs, i)) return mcmc_util.choose(tf.gather(should_flip, i), new_state, state) return tf.foldl(_do_flip, elems=tf.range(num_flips), initializer=state) self.assertAllCloseNested( - sampler._initialize_sampler_state(targets, nonzeros), + sampler._initialize_sampler_state(targets, nonzeros, 1.), _do_flips(), atol=num_outputs * 2e-4, rtol=num_outputs * 2e-4) @@ -272,7 +276,9 @@ def test_sanity_check_sweep_over_features(self): # Ensure the probability of keeping an irrelevant feature is tiny. nonzero_prior_prob=1e-6) initial_state = sampler._initialize_sampler_state( - targets=targets, nonzeros=tf.convert_to_tensor([True, True, True])) + targets=targets, + nonzeros=tf.convert_to_tensor([True, True, True]), + observation_noise_variance=1.) final_state = self.evaluate( sampler._resample_all_features( initial_state, seed=test_util.test_seed())) @@ -369,4 +375,3 @@ def do_sample(seed): if __name__ == '__main__': test_util.main() - From d0b9d34b6ab5c383457a3fe78ab216535ba46880 Mon Sep 17 00:00:00 2001 From: siege Date: Wed, 1 Jun 2022 14:55:21 -0700 Subject: [PATCH 148/153] Make tfd.Gamma.sample use log_space sampling under XLA/JAX. Benchmarks have shown that log_space sampling is a bit slower in Graph mode, so we keep the old behavior for that configuration. This should help JAX the most, which typically does not have 64 bit dtype enabled. The old default assumed it was, causing warnings and reduced numerical precision. PiperOrigin-RevId: 452391450 --- tensorflow_probability/python/distributions/gamma.py | 7 ++++++- .../python/internal/implementation_selection.py | 5 +++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/tensorflow_probability/python/distributions/gamma.py b/tensorflow_probability/python/distributions/gamma.py index 10450386da..5737117819 100644 --- a/tensorflow_probability/python/distributions/gamma.py +++ b/tensorflow_probability/python/distributions/gamma.py @@ -265,14 +265,19 @@ def _log_rate_parameter(self): caveats.""") def _sample_n(self, n, seed=None): seed = samplers.sanitize_seed(seed, salt='gamma') + log_space = implementation_selection.is_xla() - return random_gamma( + res = random_gamma( shape=ps.convert_to_shape_tensor([n]), concentration=tf.convert_to_tensor(self.concentration), rate=None if self.rate is None else tf.convert_to_tensor(self.rate), log_rate=(None if self.log_rate is None else tf.convert_to_tensor(self.log_rate)), + log_space=log_space, seed=seed) + if log_space: + res = tf.math.exp(res) + return res def _log_prob(self, x, rate=None): concentration = tf.convert_to_tensor(self.concentration) diff --git a/tensorflow_probability/python/internal/implementation_selection.py b/tensorflow_probability/python/internal/implementation_selection.py index 9aa1afb558..4c600eb1b7 100644 --- a/tensorflow_probability/python/internal/implementation_selection.py +++ b/tensorflow_probability/python/internal/implementation_selection.py @@ -22,6 +22,7 @@ __all__ = [ 'implementation_selecting', + 'is_xla', 'never_runs_functions_eagerly', ] @@ -47,7 +48,7 @@ NUMPY_MODE = False -def _is_xla(): +def is_xla(): """Returns `True` when we are tracing a function for XLA compilation.""" if JAX_MODE: return True @@ -134,7 +135,7 @@ def stub_fn(**kwargs): def impl_selecting_fn(**kwargs): """The wrapper function to be returned.""" - if _is_xla(): # JAX, XLA breakout. + if is_xla(): # JAX, XLA breakout. return default_fn(**kwargs) if NUMPY_MODE: # Numpy breakout. return cpu_fn(**kwargs) From 4547374bd32c5431c29ca2930ec01961c5e45abd Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Wed, 1 Jun 2022 20:50:44 -0700 Subject: [PATCH 149/153] Add local measure to discrete distributions. This ensures Discrete distributions transform correctly under bijectors. ```python dist = tfp.distributions.Bernoulli(probs=0.5, dtype=tf.float32) transformed_dist = tfp.bijectors.Scale(2.)(dist) transformed_dist.prob(0.) # Expect this to be 0.5, but if we apply a det jacobian correction of 1 / 2, this would be 0.25 ``` PiperOrigin-RevId: 452449290 --- .../python/distributions/BUILD | 3 ++ .../python/distributions/bernoulli.py | 4 +- .../python/distributions/beta_binomial.py | 4 +- .../python/distributions/binomial.py | 4 +- .../python/distributions/categorical.py | 4 +- .../distributions/dirichlet_multinomial.py | 4 +- .../python/distributions/distribution.py | 42 +++++++++++++++++ .../distribution_properties_test.py | 47 ++++++++++++++++++- .../python/distributions/dpp.py | 4 +- .../python/distributions/empirical.py | 4 +- .../python/distributions/finite_discrete.py | 4 +- .../python/distributions/geometric.py | 4 +- .../distributions/hypothesis_testlib.py | 23 ++++++++- .../python/distributions/multinomial.py | 4 +- .../python/distributions/negative_binomial.py | 4 +- .../python/distributions/plackett_luce.py | 7 ++- .../distributions/plackett_luce_test.py | 6 +++ .../python/distributions/poisson.py | 4 +- .../python/distributions/probit_bernoulli.py | 4 +- .../distributions/quantized_distribution.py | 4 +- .../python/distributions/skellam.py | 4 +- .../python/distributions/zipf.py | 4 +- 22 files changed, 172 insertions(+), 20 deletions(-) diff --git a/tensorflow_probability/python/distributions/BUILD b/tensorflow_probability/python/distributions/BUILD index bbf7446cf5..ab459003a2 100644 --- a/tensorflow_probability/python/distributions/BUILD +++ b/tensorflow_probability/python/distributions/BUILD @@ -309,6 +309,7 @@ multi_substrate_py_library( # numpy dep, # tensorflow dep, "//tensorflow_probability/python/bijectors:sigmoid", + "//tensorflow_probability/python/experimental/tangent_spaces", "//tensorflow_probability/python/internal:assert_util", "//tensorflow_probability/python/internal:batched_rejection_sampler", "//tensorflow_probability/python/internal:distribution_util", @@ -1565,6 +1566,7 @@ multi_substrate_py_library( ":distribution", # tensorflow dep, "//tensorflow_probability/python/bijectors:softmax_centered", + "//tensorflow_probability/python/experimental/tangent_spaces", "//tensorflow_probability/python/internal:assert_util", "//tensorflow_probability/python/internal:distribution_util", "//tensorflow_probability/python/internal:dtype_util", @@ -1584,6 +1586,7 @@ multi_substrate_py_library( ":gamma", # tensorflow dep, "//tensorflow_probability/python/bijectors:sigmoid", + "//tensorflow_probability/python/experimental/tangent_spaces", "//tensorflow_probability/python/internal:assert_util", "//tensorflow_probability/python/internal:distribution_util", "//tensorflow_probability/python/internal:dtype_util", diff --git a/tensorflow_probability/python/distributions/bernoulli.py b/tensorflow_probability/python/distributions/bernoulli.py index f97b7d699f..52c27ffec1 100644 --- a/tensorflow_probability/python/distributions/bernoulli.py +++ b/tensorflow_probability/python/distributions/bernoulli.py @@ -28,7 +28,9 @@ from tensorflow_probability.python.internal import tensor_util -class Bernoulli(distribution.AutoCompositeTensorDistribution): +class Bernoulli( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Bernoulli distribution. The Bernoulli distribution with `probs` parameter, i.e., the probability of a diff --git a/tensorflow_probability/python/distributions/beta_binomial.py b/tensorflow_probability/python/distributions/beta_binomial.py index 3345dd2db0..16c694d7d0 100644 --- a/tensorflow_probability/python/distributions/beta_binomial.py +++ b/tensorflow_probability/python/distributions/beta_binomial.py @@ -46,7 +46,9 @@ """ -class BetaBinomial(distribution.AutoCompositeTensorDistribution): +class BetaBinomial( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Beta-Binomial compound distribution. The Beta-Binomial distribution is parameterized by (a batch of) `total_count` diff --git a/tensorflow_probability/python/distributions/binomial.py b/tensorflow_probability/python/distributions/binomial.py index 7c1e5b7c10..e3904f1e3d 100644 --- a/tensorflow_probability/python/distributions/binomial.py +++ b/tensorflow_probability/python/distributions/binomial.py @@ -262,7 +262,9 @@ def _random_binomial( return sampler_impl(**params) -class Binomial(distribution.AutoCompositeTensorDistribution): +class Binomial( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Binomial distribution. This distribution is parameterized by `probs`, a (batch of) probabilities for diff --git a/tensorflow_probability/python/distributions/categorical.py b/tensorflow_probability/python/distributions/categorical.py index 5e690d57b0..20fcdd3232 100644 --- a/tensorflow_probability/python/distributions/categorical.py +++ b/tensorflow_probability/python/distributions/categorical.py @@ -58,7 +58,9 @@ def _broadcast_cat_event_and_params(event, params, base_dtype): return event, params -class Categorical(distribution.AutoCompositeTensorDistribution): +class Categorical( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Categorical distribution over integers. The Categorical distribution is parameterized by either probabilities or diff --git a/tensorflow_probability/python/distributions/dirichlet_multinomial.py b/tensorflow_probability/python/distributions/dirichlet_multinomial.py index 158118de1c..43393e572d 100644 --- a/tensorflow_probability/python/distributions/dirichlet_multinomial.py +++ b/tensorflow_probability/python/distributions/dirichlet_multinomial.py @@ -51,7 +51,9 @@ with `self.concentration` and `self.total_count`.""" -class DirichletMultinomial(distribution.AutoCompositeTensorDistribution): +class DirichletMultinomial( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Dirichlet-Multinomial compound distribution. The Dirichlet-Multinomial distribution is parameterized by a (batch of) diff --git a/tensorflow_probability/python/distributions/distribution.py b/tensorflow_probability/python/distributions/distribution.py index b5fd24fafb..82b0c87715 100644 --- a/tensorflow_probability/python/distributions/distribution.py +++ b/tensorflow_probability/python/distributions/distribution.py @@ -2119,6 +2119,48 @@ class MyDistribution(tfb.AutoCompositeTensorDistribution): pass +class DiscreteDistributionMixin(object): + """Mixin for Distributions over discrete spaces. + + This mixin identifies a `Distribution` as a discrete distribution, which in + turn ensures that it is transformed properly under `TransformedDistribution`. + + Normally, for a continuous distribution `dist` by a bijector `bij`, we have + the following formula for the `log_prob`: + `dist.log_prob(bij.inverse(y)) + bij.inverse_log_det_jacobian(y)`. + For a discrete distribution, we don't apply the `inverse_log_det_jacobian` + correction (hence just `dist.log_prob(bij.inverse(y))`). This difference + comes from transforming a probability density vs. probabilities. + + As an example, we could take a Bernoulli distribution ( + whose samples are `0` or `1`) and square it via `tfb.Square`. Samples from + this new distribution are still `0` or `1` and one would expect that the + probabilities for `0` and `1` are unchanged after this transformation. + + ```python + dist = tfp.distributions.Bernoulli(probs=0.5) + dist.prob(1.) # expect 0.5 + transformed_dist = tfp.bijectors.Square()(dist) + transformed_dist.prob(1.) # expect 0.5 + ``` + + If we apply the jacobian correction, we would instead get the wrong answer + + ```python + # If we compute with the jacobian correction explicitly, we get the wrong + # answer. + bij = tfp.bijectors.Square() + prob_at_1 = dist.log_prob(bij.inverse(1.)) + bij.inverse_log_det_jacobian(1.) + prob_at_1 = tf.math.exp(prob_at_1) # This is 0.25 + ``` + """ + + @property + def _experimental_tangent_space(self): + from tensorflow_probability.python.experimental import tangent_spaces # pylint: disable=g-import-not-at-top + return tangent_spaces.ZeroSpace() + + class _PrettyDict(dict): """`dict` with stable `repr`, `str`.""" diff --git a/tensorflow_probability/python/distributions/distribution_properties_test.py b/tensorflow_probability/python/distributions/distribution_properties_test.py index 15554f61fb..e36913be2f 100644 --- a/tensorflow_probability/python/distributions/distribution_properties_test.py +++ b/tensorflow_probability/python/distributions/distribution_properties_test.py @@ -91,6 +91,12 @@ }) +DISCRETE_BUT_NOT_TRANSFORMABLE = [ + # Samples are integers so can't be transformed by a float bijector. + 'DeterminantalPointProcess', +] + + @test_util.test_all_tf_execution_regimes class StatisticConsistentShapesTest(test_util.TestCase): @@ -230,6 +236,43 @@ def testDistribution(self, dist_name, data): self.assertAllEqual(s1, s2) +@test_util.test_all_tf_execution_regimes +class TestDiscreteDistributions(test_util.TestCase): + + @parameterized.named_parameters( + {'testcase_name': dname, 'dist_name': dname} + for dname in sorted(list(set(dhps.DISCRETE_DISTS) - + set(DISCRETE_BUT_NOT_TRANSFORMABLE)))) + @hp.given(hps.data()) + @tfp_hps.tfp_hp_settings() + def testNoJacobianCorrection(self, dist_name, data): + + # Disable validate args since transforming with Softplus and inverting + # might make arguments not as close to integers. + dist = data.draw(dhps.distributions( + dist_name=dist_name, + enable_vars=False, + validate_args=False)) + + # Ensure that these are distributions over floats so we can apply the + # Softplus bijector. + if 'dtype' in dist.parameters: + dist = dist.copy(dtype=tf.float32) + bij = tfb.Softplus() + transformed_dist = tfd.TransformedDistribution(dist, bijector=bij) + + seed = test_util.test_seed() + samples = transformed_dist.sample(7, seed=seed) + # Break bijector caching. + samples = self.evaluate( + samples + tf.constant(0., dtype=samples.dtype)) + + # Check that no jacobian correction is added for a discrete distribution. + self.assertAllClose( + self.evaluate(dist.log_prob(bij.inverse(samples))), + self.evaluate(transformed_dist.log_prob(samples))) + + @test_util.test_all_tf_execution_regimes class SampleAndLogProbTest(test_util.TestCase): @@ -630,8 +673,8 @@ class TestMixingGraphAndEagerModes(test_util.TestCase): @parameterized.named_parameters( {'testcase_name': dname, 'dist_name': dname} - for dname in sorted(list(dhps.INSTANTIABLE_BASE_DISTS.keys()) + - list(dhps.INSTANTIABLE_META_DISTS)) + for dname in sorted(list(dhps.INSTANTIABLE_BASE_DISTS.keys()) + + list(dhps.INSTANTIABLE_META_DISTS)) ) @hp.given(hps.data()) @tfp_hps.tfp_hp_settings() diff --git a/tensorflow_probability/python/distributions/dpp.py b/tensorflow_probability/python/distributions/dpp.py index 51cda590ef..24b348b7dc 100644 --- a/tensorflow_probability/python/distributions/dpp.py +++ b/tensorflow_probability/python/distributions/dpp.py @@ -240,7 +240,9 @@ def body(i, vecs, cur_sample, seed): return tf.cast(sample, tf.int32) -class DeterminantalPointProcess(distribution.AutoCompositeTensorDistribution): +class DeterminantalPointProcess( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Determinantal point process (DPP) distribution. The DPP disribution parameterized by the eigenvalues and eigenvectors of the diff --git a/tensorflow_probability/python/distributions/empirical.py b/tensorflow_probability/python/distributions/empirical.py index 18bb1d2a45..bbe84778d0 100644 --- a/tensorflow_probability/python/distributions/empirical.py +++ b/tensorflow_probability/python/distributions/empirical.py @@ -52,7 +52,9 @@ def _broadcast_event_and_samples(event, samples, event_ndims): return event, samples -class Empirical(distribution.AutoCompositeTensorDistribution): +class Empirical( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Empirical distribution. The Empirical distribution is parameterized by a [batch] multiset of samples. diff --git a/tensorflow_probability/python/distributions/finite_discrete.py b/tensorflow_probability/python/distributions/finite_discrete.py index a7b88bebaa..3de479bfb1 100644 --- a/tensorflow_probability/python/distributions/finite_discrete.py +++ b/tensorflow_probability/python/distributions/finite_discrete.py @@ -36,7 +36,9 @@ ] -class FiniteDiscrete(distribution.AutoCompositeTensorDistribution): +class FiniteDiscrete( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """The finite discrete distribution. The FiniteDiscrete distribution is parameterized by either probabilities or diff --git a/tensorflow_probability/python/distributions/geometric.py b/tensorflow_probability/python/distributions/geometric.py index f5fc5cfc57..66425d4990 100644 --- a/tensorflow_probability/python/distributions/geometric.py +++ b/tensorflow_probability/python/distributions/geometric.py @@ -30,7 +30,9 @@ from tensorflow_probability.python.internal import tensor_util -class Geometric(distribution.AutoCompositeTensorDistribution): +class Geometric( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Geometric distribution. The Geometric distribution is parameterized by p, the probability of a diff --git a/tensorflow_probability/python/distributions/hypothesis_testlib.py b/tensorflow_probability/python/distributions/hypothesis_testlib.py index c64461b374..94315e2b4d 100644 --- a/tensorflow_probability/python/distributions/hypothesis_testlib.py +++ b/tensorflow_probability/python/distributions/hypothesis_testlib.py @@ -29,6 +29,7 @@ from tensorflow_probability.python import distributions as tfd from tensorflow_probability.python import util as tfp_util from tensorflow_probability.python.bijectors import hypothesis_testlib as bijector_hps +from tensorflow_probability.python.distributions import distribution from tensorflow_probability.python.experimental import distributions as tfed from tensorflow_probability.python.internal import hypothesis_testlib as tfp_hps from tensorflow_probability.python.internal import tensorshape_util @@ -49,7 +50,6 @@ 'MultivariateNormalTriL', ) - # SPECIAL_DISTS are distributions that should not be drawn by # `base_distributions`, because they are parameterized by one or more # sub-distributions themselves. This list is used to suppress warnings from @@ -463,6 +463,27 @@ def _instantiable_base_dists(): del _instantiable_base_dists +def _discrete_dists(): + """Computes the table of Discrete Distributions. + + Returns: + discrete_dists: A Python list of discrete distributions. + """ + result = [] + for dist_name in dir(tfd): + dist_class = getattr(tfd, dist_name) + if (not inspect.isclass(dist_class) or + not issubclass(dist_class, tfd.Distribution)): + continue + + if issubclass(dist_class, distribution.DiscreteDistributionMixin): + result.append(dist_name) + return result + +DISCRETE_DISTS = _discrete_dists() +del _discrete_dists + + INSTANTIABLE_META_DISTS = ( 'BatchBroadcast', 'BatchReshape', diff --git a/tensorflow_probability/python/distributions/multinomial.py b/tensorflow_probability/python/distributions/multinomial.py index 5061911017..c9b1ca8193 100644 --- a/tensorflow_probability/python/distributions/multinomial.py +++ b/tensorflow_probability/python/distributions/multinomial.py @@ -51,7 +51,9 @@ with `self.probs` and `self.total_count`.""" -class Multinomial(distribution.AutoCompositeTensorDistribution): +class Multinomial( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Multinomial distribution. This Multinomial distribution is parameterized by `probs`, a (batch of) diff --git a/tensorflow_probability/python/distributions/negative_binomial.py b/tensorflow_probability/python/distributions/negative_binomial.py index 77cdef9cab..0e203ffaa6 100644 --- a/tensorflow_probability/python/distributions/negative_binomial.py +++ b/tensorflow_probability/python/distributions/negative_binomial.py @@ -30,7 +30,9 @@ from tensorflow_probability.python.util.deferred_tensor import DeferredTensor -class NegativeBinomial(distribution.AutoCompositeTensorDistribution): +class NegativeBinomial( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """NegativeBinomial distribution. The NegativeBinomial distribution is related to the experiment of performing diff --git a/tensorflow_probability/python/distributions/plackett_luce.py b/tensorflow_probability/python/distributions/plackett_luce.py index 794eaeef5c..f62a66be1e 100644 --- a/tensorflow_probability/python/distributions/plackett_luce.py +++ b/tensorflow_probability/python/distributions/plackett_luce.py @@ -27,7 +27,9 @@ from tensorflow_probability.python.internal import tensorshape_util -class PlackettLuce(distribution.AutoCompositeTensorDistribution): +class PlackettLuce( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Plackett-Luce distribution over permutations. The Plackett-Luce distribution is defined over permutations of @@ -220,6 +222,9 @@ def _log_prob(self, x): scores_shape = ps.shape(scores)[:-1] scores_2d = tf.reshape(scores, [-1, event_size]) x_2d = tf.reshape(x, [-1, event_size]) + # Ensure that these are indices that we can use in a gather. + if dtype_util.is_floating(x_2d.dtype): + x_2d = tf.cast(x_2d, tf.int32) rearranged_scores = tf.gather(scores_2d, x_2d, batch_dims=1) normalization_terms = tf.cumsum(rearranged_scores, axis=-1, reverse=True) diff --git a/tensorflow_probability/python/distributions/plackett_luce_test.py b/tensorflow_probability/python/distributions/plackett_luce_test.py index 001addc9e6..813b557315 100644 --- a/tensorflow_probability/python/distributions/plackett_luce_test.py +++ b/tensorflow_probability/python/distributions/plackett_luce_test.py @@ -146,6 +146,12 @@ def testAssertValidSample(self): with self.assertRaisesOpError('Sample must be a permutation'): self.evaluate(dist.log_prob([1, 0, 1])) + def testFloatingSamples(self): + scores = np.array([[[0.1, 2.3, 5.], [4.2, 0.5, 3.1]]]) + dist = tfd.PlackettLuce(scores, dtype=tf.float64, validate_args=True) + # Expect no errors from computing log_prob of a sample. + self.evaluate(dist.log_prob(dist.sample(seed=test_util.test_seed()))) + @test_util.test_all_tf_execution_regimes class PlackettLuceFromVariableTest(test_util.TestCase): diff --git a/tensorflow_probability/python/distributions/poisson.py b/tensorflow_probability/python/distributions/poisson.py index d3ee933130..4b759e657a 100644 --- a/tensorflow_probability/python/distributions/poisson.py +++ b/tensorflow_probability/python/distributions/poisson.py @@ -136,7 +136,9 @@ def random_poisson( return sampler_impl(**params) -class Poisson(distribution.AutoCompositeTensorDistribution): +class Poisson( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Poisson distribution. The Poisson distribution is parameterized by an event `rate` parameter. diff --git a/tensorflow_probability/python/distributions/probit_bernoulli.py b/tensorflow_probability/python/distributions/probit_bernoulli.py index 796bcd36be..f51255e939 100644 --- a/tensorflow_probability/python/distributions/probit_bernoulli.py +++ b/tensorflow_probability/python/distributions/probit_bernoulli.py @@ -29,7 +29,9 @@ from tensorflow_probability.python.internal import tensor_util -class ProbitBernoulli(distribution.AutoCompositeTensorDistribution): +class ProbitBernoulli( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """ProbitBernoulli distribution. The ProbitBernoulli distribution with `probs` parameter, i.e., the probability diff --git a/tensorflow_probability/python/distributions/quantized_distribution.py b/tensorflow_probability/python/distributions/quantized_distribution.py index 5381ca15eb..e7b5214e4b 100644 --- a/tensorflow_probability/python/distributions/quantized_distribution.py +++ b/tensorflow_probability/python/distributions/quantized_distribution.py @@ -108,7 +108,9 @@ """ -class _QuantizedDistribution(distributions.Distribution): +class _QuantizedDistribution( + distributions.DiscreteDistributionMixin, + distributions.Distribution): """Distribution representing the quantization `Y = ceiling(X)`. #### Definition in Terms of Sampling diff --git a/tensorflow_probability/python/distributions/skellam.py b/tensorflow_probability/python/distributions/skellam.py index 3f9d313ce5..a03f579231 100644 --- a/tensorflow_probability/python/distributions/skellam.py +++ b/tensorflow_probability/python/distributions/skellam.py @@ -35,7 +35,9 @@ ] -class Skellam(distribution.AutoCompositeTensorDistribution): +class Skellam( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Skellam distribution. The Skellam distribution is parameterized by two rate parameters, diff --git a/tensorflow_probability/python/distributions/zipf.py b/tensorflow_probability/python/distributions/zipf.py index ef543ea5e5..262f2a1675 100644 --- a/tensorflow_probability/python/distributions/zipf.py +++ b/tensorflow_probability/python/distributions/zipf.py @@ -34,7 +34,9 @@ ] -class Zipf(distribution.AutoCompositeTensorDistribution): +class Zipf( + distribution.DiscreteDistributionMixin, + distribution.AutoCompositeTensorDistribution): """Zipf distribution. The Zipf distribution is parameterized by a `power` parameter. From 12e0f6bc9f1b017bdcca5693c53cd0f4091552b9 Mon Sep 17 00:00:00 2001 From: colcarroll Date: Thu, 2 Jun 2022 10:47:04 -0700 Subject: [PATCH 150/153] Improve dynamic Cholesky performance by compiling private functions. PiperOrigin-RevId: 452573333 --- .../python/experimental/sts_gibbs/BUILD | 1 + .../sts_gibbs/dynamic_spike_and_slab.py | 7 ++++- .../experimental/sts_gibbs/gibbs_sampler.py | 31 ++++++++++++++----- 3 files changed, 31 insertions(+), 8 deletions(-) diff --git a/tensorflow_probability/python/experimental/sts_gibbs/BUILD b/tensorflow_probability/python/experimental/sts_gibbs/BUILD index 2a12f3d68c..c99fd7ab6f 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/BUILD +++ b/tensorflow_probability/python/experimental/sts_gibbs/BUILD @@ -91,6 +91,7 @@ multi_substrate_py_library( # tensorflow dep, "//tensorflow_probability/python/bijectors:softplus", "//tensorflow_probability/python/distributions:bernoulli", + "//tensorflow_probability/python/distributions:gamma", "//tensorflow_probability/python/distributions:inverse_gamma", "//tensorflow_probability/python/distributions:joint_distribution_auto_batched", "//tensorflow_probability/python/distributions:sample", diff --git a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py index 8876357f99..b3e3614404 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/dynamic_spike_and_slab.py @@ -20,6 +20,7 @@ from tensorflow_probability.python.bijectors import softplus as softplus_bijector from tensorflow_probability.python.distributions import bernoulli +from tensorflow_probability.python.distributions import gamma from tensorflow_probability.python.distributions import inverse_gamma from tensorflow_probability.python.distributions import joint_distribution_auto_batched from tensorflow_probability.python.distributions import sample as sample_dist @@ -55,7 +56,11 @@ def _parameter_properties(cls, dtype, num_classes=None): lambda: softplus_bijector.Softplus(low=dtype_util.eps(dtype))))) def _sample_n(self, n, seed=None): - xs = super()._sample_n(n, seed=seed) + # TODO(b/151571025): revert to `super()._sample_n` once the InverseGamma + # sampler is XLA-able. + xs = 1. / gamma.Gamma( + concentration=self.concentration, rate=self.scale).sample( + n, seed=seed) if self._upper_bound is not None: xs = tf.minimum(xs, self._upper_bound) return xs diff --git a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py index a881b3dee9..3ceda6f51f 100644 --- a/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py +++ b/tensorflow_probability/python/experimental/sts_gibbs/gibbs_sampler.py @@ -380,7 +380,6 @@ def fit_with_gibbs_sampling(model, update for the posterior precision of the weight in case of a spike and slab sampler. - Returns: model: A `GibbsSamplerState` structure of posterior samples. """ @@ -436,8 +435,13 @@ def fit_with_gibbs_sampling(model, seed=samplers.sanitize_seed(seed, salt='initial_GibbsSamplerState')) sampler_loop_body = _build_sampler_loop_body( - model, observed_time_series, is_missing, default_pseudo_observations, - experimental_use_dynamic_cholesky, experimental_use_weight_adjustment) + model=model, + observed_time_series=observed_time_series, + is_missing=is_missing, + default_pseudo_observations=default_pseudo_observations, + experimental_use_dynamic_cholesky=experimental_use_dynamic_cholesky, + experimental_use_weight_adjustment=experimental_use_weight_adjustment + ) samples = tf.scan(sampler_loop_body, np.arange(num_warmup_steps + num_results), initial_state) @@ -885,6 +889,19 @@ def _build_sampler_loop_body(model, else: weights_prior_scale = (regression_component.parameters[0].prior.scale) + # Sub-selects in `forward_filter_sequential` take up a lot of the runtime + # with a dynamic Cholesky, but compiling here seems to help. + # TODO(b/234726324): Should this always be compiled? + if experimental_use_dynamic_cholesky: + resample_latents = tf.function( + jit_compile=True, autograph=False)( + _resample_latents) + resample_scale = tf.function( + jit_compile=True, autograph=False)( + _resample_scale) + else: + resample_latents = _resample_latents + resample_scale = _resample_scale def sampler_loop_body(previous_sample, _): """Runs one sampler iteration, resampling all model variables.""" @@ -940,7 +957,7 @@ def sampler_loop_body(previous_sample, _): observation_noise_scale = previous_sample.observation_noise_scale weights = previous_sample.weights - latents = _resample_latents( + latents = resample_latents( observed_residuals=regression_residuals, level_scale=previous_sample.level_scale, slope_scale=previous_sample.slope_scale if model_has_slope else None, @@ -956,20 +973,20 @@ def sampler_loop_body(previous_sample, _): slope_residuals = slope[..., 1:] - slope[..., :-1] # Estimate level scale from the empirical changes in level. - level_scale = _resample_scale( + level_scale = resample_scale( prior=level_scale_variance_prior, observed_residuals=level_residuals, is_missing=None, seed=level_scale_seed) if model_has_slope: - slope_scale = _resample_scale( + slope_scale = resample_scale( prior=slope_scale_variance_prior, observed_residuals=slope_residuals, is_missing=None, seed=slope_scale_seed) if not (regression_component and model_has_spike_slab_regression): # Estimate noise scale from the residuals. - observation_noise_scale = _resample_scale( + observation_noise_scale = resample_scale( prior=observation_noise_variance_prior, observed_residuals=regression_residuals - level, is_missing=is_missing, From 0a10dd49d15663831e0907288952eda36937d442 Mon Sep 17 00:00:00 2001 From: kathywu Date: Thu, 2 Jun 2022 21:05:31 -0700 Subject: [PATCH 151/153] Fix TensorFlow checkpoint and trackable imports. PiperOrigin-RevId: 452684705 --- .../python/internal/backend/meta/gen_linear_operators.py | 5 +++++ .../python/layers/internal/distribution_tensor_coercible.py | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py b/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py index 4502129771..972bf050d6 100644 --- a/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py +++ b/tensorflow_probability/python/internal/backend/meta/gen_linear_operators.py @@ -134,6 +134,11 @@ def gen_module(module_name): 'from tensorflow.python.ops import variables', 'from tensorflow_probability.python.internal.backend.numpy ' 'import variables') + code = code.replace( + 'from tensorflow.python.trackable ' + 'import data_structures', + 'from tensorflow_probability.python.internal.backend.numpy ' + 'import data_structures') code = code.replace( 'from tensorflow.python.training.tracking ' 'import data_structures', diff --git a/tensorflow_probability/python/layers/internal/distribution_tensor_coercible.py b/tensorflow_probability/python/layers/internal/distribution_tensor_coercible.py index 30dbac9d28..e2c7f5ccb5 100644 --- a/tensorflow_probability/python/layers/internal/distribution_tensor_coercible.py +++ b/tensorflow_probability/python/layers/internal/distribution_tensor_coercible.py @@ -24,7 +24,7 @@ from tensorflow_probability.python.internal import parameter_properties from tensorflow_probability.python.util.deferred_tensor import TensorMetaClass from tensorflow.python.framework import composite_tensor # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.training.tracking import data_structures # pylint: disable=g-direct-tensorflow-import +from tensorflow.python.trackable import data_structures # pylint: disable=g-direct-tensorflow-import __all__ = [] # We intend nothing public. From f8107c1db3c113e07df8b25c0021d901aa59eaf0 Mon Sep 17 00:00:00 2001 From: langmore Date: Fri, 3 Jun 2022 09:18:44 -0700 Subject: [PATCH 152/153] DOCFIX: Correct Markov state distribution notation in EnKF. The distributions are e.g. P(X[t] | Y[t], ...), NOT P(X[t] | Y[t]). PiperOrigin-RevId: 452779681 --- .../sequential/ensemble_kalman_filter.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py index 9c9cd71a4f..482a06874d 100644 --- a/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py +++ b/tensorflow_probability/python/experimental/sequential/ensemble_kalman_filter.py @@ -102,10 +102,10 @@ def ensemble_kalman_filter_predict( Y[t] ~ observation_fn(X[t]) ``` - Given the ensemble `state.particles` sampled from `P(X[t-1] | Y[t-1])`, this - function produces the predicted (a.k.a. forecast or background) ensemble - sampled from `P(X[t] | Y[t-1])`. This is the predicted next state *before* - assimilating the observation `Y[t]`. + Given the ensemble `state.particles` sampled from `P(X[t-1] | Y[t-1], ...)`, + this function produces the predicted (a.k.a. forecast or background) ensemble + sampled from `P(X[t] | Y[t-1], ...)`. This is the predicted next state + *before* assimilating the observation `Y[t]`. Typically, with `F` some deterministic mapping, `transition_fn(X)` returns a normal distribution centered at `F(X)`. @@ -177,9 +177,9 @@ def ensemble_kalman_filter_update( Y[t] ~ observation_fn(X[t]) ``` - Given the ensemble `state.particles` sampled from `P(X[t] | Y[t-1])`, this - function assimilates obervation `Y[t]` to produce the updated ensemble sampled - from `P(X[t] | Y[t])`. + Given the ensemble `state.particles` sampled from `P(X[t] | Y[t-1], ...)`, + this function assimilates obervation `Y[t]` to produce the updated ensemble + sampled from `P(X[t] | Y[t], ...)`. Typically, with `G` some deterministic observation mapping, `observation_fn(X)` returns a normal distribution centered at `G(X)`. From 8e72c1176aba6473af5258d6a7ca6aea22b0a0ff Mon Sep 17 00:00:00 2001 From: jburnim Date: Mon, 6 Jun 2022 08:15:43 -0700 Subject: [PATCH 153/153] Fix failure in windowed_sampling_test.jax in OSS. PiperOrigin-RevId: 453202511 --- .../python/experimental/mcmc/windowed_sampling.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tensorflow_probability/python/experimental/mcmc/windowed_sampling.py b/tensorflow_probability/python/experimental/mcmc/windowed_sampling.py index ad79cbd219..ab30e69471 100644 --- a/tensorflow_probability/python/experimental/mcmc/windowed_sampling.py +++ b/tensorflow_probability/python/experimental/mcmc/windowed_sampling.py @@ -269,8 +269,9 @@ def step_broadcast(step_size): shard_axis_names = pinned_model.experimental_shard_axis_names if any(tf.nest.flatten(shard_axis_names)): shard_axis_names = nest.flatten_up_to( - initial_transformed_position, pinned_model._model_flatten( # pylint: disable=protected-access - shard_axis_names)) + initial_transformed_position, + list(pinned_model._model_flatten(shard_axis_names))) # pylint: disable=protected-access + else: # No active shard axis names shard_axis_names = None