Remove some deprecations:

- (since 2022-06-23) `observations_mask` from `tfd.GaussianProcessRegressionModel`: use `observations_is_missing` (with the opposite sense) instead.
- (since 2022-06-23) `fixed_inputs_mask` from `tfp.math.psd_kernels.SchurComplement`: use `fixed_inputs_is_missing` (with the opposite sense) instead.
- (since 2022-03-01) `variational_loss_fn` from `tfp.vi.fit_surrogate_posterior`: use the `discrepancy_fn` argument to specify a custom divergence, or pass a custom loss directly to `tfp.math.minimize`.
- (since 2022-11-01) `bias_variance` and `slope_variance` from `tfp.math.psd_kernels.Polynomial` and `tfp.math.psd_kernels.Linear`: use `bias_amplitude` and `slope_amplitude` instead.
- (since 2021-11-01) `use_pfor_to_compute_jacobian` from `tfp.math.ode.base.Solver`: it had no effect.
- (since 2020-01-01) `scale_identity_multiplier` from `tfd.MutivariateNormalDiag`: Using `scale_diag=np.ones([batch_shape, event_shape]) * np.array(scale_identity_multiplier)[..., None]` will generally work.
- (since 2019-05-22) `step_size_update_fn` from `tfp.mcmc.HamiltonianMonteCarlo`: use `tfp.mcmc.SimpleStepSizeAdaptation` instead.

PiperOrigin-RevId: 503277939

Author: ColCarroll

tensorflow_probability/examples/jupyter_notebooks/Linear_Mixed_Effects_Models.ipynb

@@ -277,8 +277,8 @@ def kernel_fn(eq_params, poly_params):
     kernel_args = (
         dict(length_scale=tf.random.uniform([], .5, 1.5, dtype=tf.float64),
              amplitude=tf.random.uniform([], 1.5, 2.5, dtype=tf.float64)),
-        dict(bias_variance=tf.random.uniform([feature_dim], .5, 1.5,
-                                             dtype=tf.float64),
+        dict(bias_amplitude=tf.random.uniform([feature_dim], .5, 1.5,
+                                              dtype=tf.float64),
              shift=tf.random.normal([feature_dim], dtype=tf.float64)))
 
     x1 = tf.random.normal([5, feature_dim], dtype=tf.float64)

tensorflow_probability/examples/jupyter_notebooks/Multilevel_Modeling_Primer.ipynb

@@ -104,6 +104,7 @@ def testMixtureTargetLogProb(self, make_kernel_fn, optimal_accept):
     mixture_weight = tf.constant([w, 1. - w], tf.float64)
     mu = np.ones(nd) * .5
     component_loc = tf.cast(np.asarray([mu, -mu]), tf.float64)
+    scale_diag = tf.tile(tf.constant([[.1], [.2]], dtype=tf.float64), [1, nd])
 
     proposal = sample.Sample(
         normal.Normal(tf.constant(0., tf.float64), 10.), sample_shape=nd)
@@ -112,8 +113,7 @@ def testMixtureTargetLogProb(self, make_kernel_fn, optimal_accept):
     likelihood_dist = mixture_same_family.MixtureSameFamily(
         mixture_distribution=categorical.Categorical(probs=mixture_weight),
         components_distribution=mvn_diag.MultivariateNormalDiag(
-            loc=component_loc,
-            scale_diag=[[.1], [.2]] * tf.ones_like(component_loc)))
+            loc=component_loc, scale_diag=scale_diag))
 
     # Uniform prior
     init_log_prob = tf.zeros_like(proposal.log_prob(init_state))
@@ -144,19 +144,17 @@ def testMixtureMultiBatch(self):
     mu = np.ones(nd) * .5
     loc = tf.cast(np.asarray([mu, -mu]), tf.float64)
     component_loc = tf.repeat(loc[tf.newaxis, ...], n_batch, axis=0)
+    scale_diag = tf.tile(tf.constant([[.1], [.2]], dtype=tf.float64), [1, nd])
 
     likelihood_dist = mixture_same_family.MixtureSameFamily(
         mixture_distribution=categorical.Categorical(probs=mixture_weight),
         components_distribution=mvn_diag.MultivariateNormalDiag(
-            loc=component_loc,
-            scale_diag=tf.constant([[.1], [.2]], tf.float64) *
-            tf.ones_like(component_loc)))
+            loc=component_loc, scale_diag=scale_diag))
 
     proposal = sample.Sample(
         normal.Normal(tf.constant(0., tf.float64), 10.), sample_shape=nd)
     init_state = proposal.sample([5000, n_batch], seed=seed)
     log_prob_fn = likelihood_dist.log_prob
-    print(log_prob_fn(init_state).shape)
 
     # Uniform prior
     init_log_prob = tf.zeros_like(log_prob_fn(init_state))

tensorflow_probability/examples/jupyter_notebooks/Understanding_TensorFlow_Distributions_Shapes.ipynb

@@ -26,7 +26,6 @@
 from tensorflow_probability.python.math import gradient as tfp_gradient
 from tensorflow_probability.python.math.ode import runge_kutta_util as rk_util
 from tensorflow_probability.python.math.ode import util
-from tensorflow.python.util import deprecation  # pylint: disable=g-direct-tensorflow-import
 
 # TODO(b/138303336): Support MATLAB-style events.
 
@@ -42,16 +41,10 @@
 class Solver(object):
   """Base class for an ODE solver."""
 
-  @deprecation.deprecated_args(
-      '2021-11-01',
-      'use_pfor_to_compute_jacobian is deprecated, and does nothing.',
-      'use_pfor_to_compute_jacobian')
   def __init__(self,
                make_adjoint_solver_fn,
                validate_args,
-               name,
-               use_pfor_to_compute_jacobian=True):
-    del use_pfor_to_compute_jacobian
+               name):
     self._validate_args = validate_args
     self._name = name
     if make_adjoint_solver_fn is None:

tensorflow_probability/python/experimental/linalg/linear_operator_psd_kernel_test.py

@@ -22,7 +22,6 @@
 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__ = [
     'Constant',
@@ -55,14 +54,7 @@ class Polynomial(psd_kernel.AutoCompositeTensorPsdKernel):
 
   """
 
-  @deprecation.deprecated_args(
-      '2022-11-01',
-      '`bias_variance` and `slope_variance` are deprecated. Please use '
-      '`bias_amplitude` and `slope_amplitude` instead.',
-      'bias_variance', 'slope_variance')
   def __init__(self,
-               bias_variance=None,
-               slope_variance=None,
                bias_amplitude=None,
                slope_amplitude=None,
                shift=None,
@@ -74,18 +66,6 @@ def __init__(self,
     """Construct a Polynomial kernel instance.
 
     Args:
-      bias_variance: Deprecated. Non-negative floating point `Tensor` that
-        controls the variance from the origin. If bias = 0, there is no
-        variance and the fitted function goes through the origin.  Must be
-        broadcastable with `slope_variance`, `shift`, `exponent`, and inputs
-        to `apply` and `matrix` methods. A value of `None` is treated like 0.
-        Default Value: `None`
-      slope_variance: Deprecated. Non-negative floating point `Tensor` that
-        controls the variance of the regression line slope that is the basis
-        for the polynomial. Must be broadcastable with `bias_variance`, `shift`,
-        `exponent`, and inputs to `apply` and `matrix` methods. A value of
-        `None` is treated like 1.
-        Default Value: `None`
       bias_amplitude: Non-negative floating point `Tensor` that controls the
         stddev from the origin. If bias = 0, there is no stddev and the
         fitted function goes through the origin.  Must be broadcastable with
@@ -124,16 +104,10 @@ def __init__(self,
     parameters = dict(locals()) if parameters is None else parameters
     with tf.name_scope(name):
       dtype = util.maybe_get_common_dtype(
-          [bias_variance,
-           slope_variance,
-           bias_amplitude,
+          [bias_amplitude,
            slope_amplitude,
            shift,
            exponent])
-      self._bias_variance = tensor_util.convert_nonref_to_tensor(
-          bias_variance, name='bias_variance', dtype=dtype)
-      self._slope_variance = tensor_util.convert_nonref_to_tensor(
-          slope_variance, name='slope_variance', dtype=dtype)
       self._bias_amplitude = tensor_util.convert_nonref_to_tensor(
           bias_amplitude, name='bias_amplitude', dtype=dtype)
       self._slope_amplitude = tensor_util.convert_nonref_to_tensor(
@@ -156,30 +130,14 @@ def _parameter_properties(cls, dtype):
         bias_amplitude=parameter_properties.ParameterProperties(
             default_constraining_bijector_fn=(
                 lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
-        bias_variance=parameter_properties.ParameterProperties(
-            default_constraining_bijector_fn=(
-                lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
         exponent=parameter_properties.ParameterProperties(
             default_constraining_bijector_fn=(
                 lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
         slope_amplitude=parameter_properties.ParameterProperties(
             default_constraining_bijector_fn=(
                 lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
-        slope_variance=parameter_properties.ParameterProperties(
-            default_constraining_bijector_fn=(
-                lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
         shift=parameter_properties.ParameterProperties())
 
-  @property
-  def bias_variance(self):
-    """Variance on bias parameter."""
-    return self._bias_variance
-
-  @property
-  def slope_variance(self):
-    """Variance on slope parameter."""
-    return self._slope_variance
-
   @property
   def bias_amplitude(self):
     """Stddev on bias parameter."""
@@ -200,16 +158,6 @@ def exponent(self):
     """Exponent of the polynomial term."""
     return self._exponent
 
-  def _get_bias_amplitude(self):
-    if self.bias_amplitude is not None:
-      return self.bias_amplitude
-    return self.bias_variance
-
-  def _get_slope_amplitude(self):
-    if self.slope_amplitude is not None:
-      return self.slope_amplitude
-    return self.slope_variance
-
   def _apply(self, x1, x2, example_ndims=0):
     if self.shift is None:
       dot_prod = util.sum_rightmost_ndims_preserving_shape(
@@ -226,13 +174,13 @@ def _apply(self, x1, x2, example_ndims=0):
       exponent = util.pad_shape_with_ones(exponent, example_ndims)
       dot_prod = dot_prod ** exponent
 
-    slope_amplitude = self._get_slope_amplitude()
+    slope_amplitude = self.slope_amplitude
     if slope_amplitude is not None:
       slope_amplitude = tf.convert_to_tensor(slope_amplitude)
       slope_amplitude = util.pad_shape_with_ones(slope_amplitude, example_ndims)
       dot_prod = dot_prod * slope_amplitude**2.
 
-    bias_amplitude = self._get_bias_amplitude()
+    bias_amplitude = self.bias_amplitude
     if bias_amplitude is not None:
       bias_amplitude = tf.convert_to_tensor(bias_amplitude)
       bias_amplitude = util.pad_shape_with_ones(bias_amplitude, example_ndims)
@@ -247,8 +195,8 @@ def _parameter_control_dependencies(self, is_init):
     ok_to_check = lambda x: (  # pylint:disable=g-long-lambda
         x is not None) and (is_init != tensor_util.is_ref(x))
 
-    bias_amplitude = self._get_bias_amplitude()
-    slope_amplitude = self._get_slope_amplitude()
+    bias_amplitude = self.bias_amplitude
+    slope_amplitude = self.slope_amplitude
 
     if ok_to_check(self.exponent):
       exponent = tf.convert_to_tensor(self.exponent)
@@ -296,14 +244,7 @@ class Linear(Polynomial):
     ```
   """
 
-  @deprecation.deprecated_args(
-      '2022-11-01',
-      '`bias_variance` and `slope_variance` are deprecated. Please use '
-      '`bias_amplitude` and `slope_amplitude` instead.',
-      'bias_variance', 'slope_variance')
   def __init__(self,
-               bias_variance=None,
-               slope_variance=None,
                bias_amplitude=None,
                slope_amplitude=None,
                shift=None,
@@ -314,17 +255,6 @@ def __init__(self,
     """Construct a Linear kernel instance.
 
     Args:
-      bias_variance: Positive floating point `Tensor` that controls the variance
-        from the origin. If bias = 0, there is no variance and the fitted
-        function goes through the origin (also known as the homogeneous linear
-        kernel). Must be broadcastable with `slope_variance`, `shift` and inputs
-        to `apply` and `matrix` methods. A value of `None` is treated like 0.
-        Default Value: `None`
-      slope_variance: Positive floating point `Tensor` that controls the
-        variance of the regression line slope. Must be broadcastable with
-        `bias_variance`, `shift`, and inputs to `apply` and `matrix` methods. A
-        value of `None` is treated like 1.
-        Default Value: `None`
       bias_amplitude: Non-negative floating point `Tensor` that controls the
         stddev from the origin. If bias = 0, there is no stddev and the
         fitted function goes through the origin.  Must be broadcastable with
@@ -354,8 +284,6 @@ def __init__(self,
     """
     parameters = dict(locals()) if parameters is None else parameters
     super(Linear, self).__init__(
-        bias_variance=bias_variance,
-        slope_variance=slope_variance,
         bias_amplitude=bias_amplitude,
         slope_amplitude=slope_amplitude,
         shift=shift,
@@ -372,15 +300,9 @@ def _parameter_properties(cls, dtype):
         bias_amplitude=parameter_properties.ParameterProperties(
             default_constraining_bijector_fn=(
                 lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
-        bias_variance=parameter_properties.ParameterProperties(
-            default_constraining_bijector_fn=(
-                lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
         slope_amplitude=parameter_properties.ParameterProperties(
             default_constraining_bijector_fn=(
                 lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
-        slope_variance=parameter_properties.ParameterProperties(
-            default_constraining_bijector_fn=(
-                lambda: softplus.Softplus(low=dtype_util.eps(dtype)))),
         shift=parameter_properties.ParameterProperties())
 
 

tensorflow_probability/python/experimental/mcmc/sample_sequential_monte_carlo_test.py

@@ -22,7 +22,6 @@
 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__ = [
@@ -177,15 +176,9 @@ 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,
@@ -216,10 +209,6 @@ def __init__(self,
         computing the Cholesky 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: 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
@@ -268,12 +257,6 @@ def __init__(self,
       self._fixed_inputs = nest_util.convert_to_nested_tensor(
           fixed_inputs, dtype=dtype, name='fixed_inputs', convert_ref=False,
           allow_packing=True)
-      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')
@@ -297,15 +280,9 @@ 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,
@@ -345,10 +322,6 @@ def with_precomputed_divisor(
         computing the Cholesky 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: 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
@@ -381,13 +354,6 @@ def with_precomputed_divisor(
       float_dtype = dtype
     fixed_inputs = nest_util.convert_to_nested_tensor(
         fixed_inputs, dtype=dtype, allow_packing=True)
-    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_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)
@@ -434,8 +400,6 @@ 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):
@@ -561,8 +525,6 @@ def _parameter_properties(cls, dtype):
         fixed_inputs=parameter_properties.ParameterProperties(
             event_ndims=lambda self: tf.nest.map_structure(  # pylint: disable=g-long-lambda
                 lambda nd: nd + 1, self.base_kernel.feature_ndims)),
-        fixed_inputs_mask=parameter_properties.ParameterProperties(
-            event_ndims=1),
         fixed_inputs_is_missing=parameter_properties.ParameterProperties(
             event_ndims=1),
         diag_shift=parameter_properties.ParameterProperties(
@@ -601,14 +563,7 @@ def _divisor_matrix_cholesky(
   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
-    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)