code: def decompose_forecast_by_component(
      model, forecast_dist, parameter_samples
  ):
      """Decompose a forecast distribution into contributions from each component.
  
      Args:
        model: An instance of `tfp.sts.Sum` representing a structural time series
          model.
        forecast_dist: A `Distribution` instance returned by `tfp.sts.forecast()`.
          (specifically, must be a `tfd.MixtureSameFamily` over a
          `tfd.LinearGaussianStateSpaceModel` parameterized by posterior samples).
        parameter_samples: Python `list` of `Tensors` representing posterior samples
          of model parameters, with shapes `[concat([[num_posterior_draws],
          param.prior.batch_shape, param.prior.event_shape]) for param in
          model.parameters]`. This may optionally also be a map (Python `dict`) of
          parameter names to `Tensor` values.
      Returns:
        component_forecasts: A `collections.OrderedDict` instance mapping
          component StructuralTimeSeries instances (elements of `model.components`)
          to `tfd.Distribution` instances representing the marginal forecast for
          each component. Each distribution has batch and event shape matching
          `forecast_dist` (specifically, the event shape is
          `[num_steps_forecast]`).
  
      #### Examples
  
      Suppose we've built a model, fit it to data, and constructed a forecast
      distribution:
  
      ```python
        day_of_week = tfp.sts.Seasonal(
            num_seasons=7,
            observed_time_series=observed_time_series,
            name='day_of_week')
        local_linear_trend = tfp.sts.LocalLinearTrend(
            observed_time_series=observed_time_series,
            name='local_linear_trend')
        model = tfp.sts.Sum(components=[day_of_week, local_linear_trend],
                            observed_time_series=observed_time_series)
  
        num_steps_forecast = 50
        samples, kernel_results = tfp.sts.fit_with_hmc(model, observed_time_series)
        forecast_dist = tfp.sts.forecast(model, observed_time_series,
                                     parameter_samples=samples,
                                     num_steps_forecast=num_steps_forecast)
      ```
  
      To extract the forecast for individual components, pass the forecast
      distribution into `decompose_forecast_by_components`:
  
      ```python
        component_forecasts = decompose_forecast_by_component(
          model, forecast_dist, samples)
  
        # Component mean and stddev have shape `[num_steps_forecast]`.
        day_of_week_effect_mean = forecast_components[day_of_week].mean()
        day_of_week_effect_stddev = forecast_components[day_of_week].stddev()
      ```
  
      Using the component forecasts, we can visualize the uncertainty for each
      component:
  
      ```
      from matplotlib import pylab as plt
      num_components = len(component_forecasts)
      xs = np.arange(num_steps_forecast)
      fig = plt.figure(figsize=(12, 3 * num_components))
      for i, (component, component_dist) in enumerate(component_forecasts.items()):
  
        # If in graph mode, replace `.numpy()` with `.eval()` or `sess.run()`.
        component_mean = component_dist.mean().numpy()
        component_stddev = component_dist.stddev().numpy()
  
        ax = fig.add_subplot(num_components, 1, 1 + i)
        ax.plot(xs, component_mean, lw=2)
        ax.fill_between(xs,
                        component_mean - 2 * component_stddev,
                        component_mean + 2 * component_stddev,
                        alpha=0.5)
        ax.set_title(component.name)
      ```
  
      """
  
      with tf.name_scope("decompose_forecast_by_component"):
          try:
              forecast_lgssm = forecast_dist.components_distribution
              (
                  forecast_latent_mean,
                  _,
              ) = (
                  forecast_lgssm._joint_mean()
              )  # pylint: disable=protected-access
              (
                  forecast_latent_covs,
                  _,
              ) = (
                  forecast_lgssm._joint_covariances()
              )  # pylint: disable=protected-access
          except AttributeError as e:
              raise ValueError(
                  "Forecast distribution must be a MixtureSameFamily of"
                  "LinearGaussianStateSpaceModel distributions, such as returned by"
                  "`tfp.sts.forecast()`. (saw exception: {})".format(e)
              )
  
          # Since `parameter_samples` will have sample shape `[num_posterior_draws]`,
          # we need to move the `num_posterior_draws` dimension of the forecast
          # moments from the trailing batch dimension, where it's currently put by
          # `sts.forecast`, back to the leading (sample shape) dimension.
          forecast_latent_mean = dist_util.move_dimension(
              forecast_latent_mean, source_idx=-3, dest_idx=0
          )
          forecast_latent_covs = dist_util.move_dimension(
              forecast_latent_covs, source_idx=-4, dest_idx=0
          )
          return _decompose_from_posterior_marginals(
              model,
              forecast_latent_mean,
              forecast_latent_covs,
              parameter_samples,
              initial_step=forecast_lgssm.initial_step,
          )
  
file_path: probability/tensorflow_probability/python/sts/decomposition.py
imports: import collections
  import tensorflow.compat.v2
  from tensorflow_probability.python.experimental import util
  from tensorflow_probability.python.internal import distribution_util
  from tensorflow_probability.python.sts.internal import util
label_desc: Use image node_id 4 for calling a global function with example usage: decompose_forecast_by_component(model, forecast_dist, parameter_samples) and returns: _decompose_from_posterior_marginals