class_docstr: Main model class.
class_docstr_tok: ["Main","model","class","."]
docstr: Decompresses an image.
docstr_tok: ["Decompresses","an","image","."]
code: def decompress(self, x_shape, y_shape, z_shape, z_string, *y_strings):
      """Decompresses an image."""
      assert len(y_strings) == self.num_slices
  
      z_hat = self.em_z.decompress(z_string, z_shape)
  
      # Build the decoder (synthesis) half of the hierarchical autoencoder.
      latent_scales = self.hyper_synthesis_scale_transform(z_hat)
      latent_means = self.hyper_synthesis_mean_transform(z_hat)
  
      # En/Decode each slice conditioned on hyperprior and previous slices.
      y_hat_slices = []
      for slice_index, y_string in enumerate(y_strings):
          # Model may condition on only a subset of previous slices.
          support_slices = (
              y_hat_slices
              if self.max_support_slices < 0
              else y_hat_slices[: self.max_support_slices]
          )
  
          # Predict mu and sigma for the current slice.
          mean_support = tf.concat(
              [latent_means] + support_slices, axis=-1
          )
          mu = self.cc_mean_transforms[slice_index](mean_support)
          mu = mu[:, : y_shape[0], : y_shape[1], :]
  
          # Note that in this implementation, `sigma` represents scale indices,
          # not actual scale values.
          scale_support = tf.concat(
              [latent_scales] + support_slices, axis=-1
          )
          sigma = self.cc_scale_transforms[slice_index](scale_support)
          sigma = sigma[:, : y_shape[0], : y_shape[1], :]
  
          y_hat_slice = self.em_y.decompress(y_string, sigma, loc=mu)
  
          # Add latent residual prediction (LRP).
          lrp_support = tf.concat([mean_support, y_hat_slice], axis=-1)
          lrp = self.lrp_transforms[slice_index](lrp_support)
          lrp = 0.5 * tf.math.tanh(lrp)
          y_hat_slice += lrp
  
          y_hat_slices.append(y_hat_slice)
  
      # Merge slices and generate the image reconstruction.
      y_hat = tf.concat(y_hat_slices, axis=-1)
      x_hat = self.synthesis_transform(y_hat)
      # Remove batch dimension, and crop away any extraneous padding.
      x_hat = x_hat[0, : x_shape[0], : x_shape[1], :]
      # Then cast back to 8-bit integer.
      return tf.saturate_cast(tf.round(x_hat), tf.uint8)
  
imports: import argparse
  import functools
  import glob
  import sys
  from absl import app
  from absl.flags import argparse_flags
  import tensorflow
  import tensorflow_compression
  import tensorflow_datasets
label_desc: Use image node_id 9 for calling the MS2020Model obj's underlying member method code with example usage: obj.decompress(x_shape, y_shape, z_shape, z_string) and returns: tf