class_docstr: Graph for Gibbs sampling from Coconet.
docstr: Builds the tf.while_loop based sampling graph.
  
  Args:
    input_pianorolls: Optional input pianorolls override. If None, uses the
        pianorolls placeholder.
    outer_masks: Optional input outer_masks override. If None, uses the
        outer_masks placeholder.
    total_gibbs_steps: Optional input total_gibbs_steps override. If None,
        uses the total_gibbs_steps placeholder.
  Returns:
    The output op of the graph.
docstr_tok: ["Builds","the","tf.while_loop","based","sampling","graph",".","Args",":","input_pianorolls",":","Optional","input","pianorolls","override",".","If","None",",","uses","the","pianorolls","placeholder",".","outer_masks",":","Optional","input","outer_masks","override",".","If","None",",","uses","the","outer_masks","placeholder",".","total_gibbs_steps",":","Optional","input","total_gibbs_steps","override",".","If","None",",","uses","the","total_gibbs_steps","placeholder",".","Returns",":","The","output","op","of","the","graph","."]
code: def build_sample_graph(
      self,
      input_pianorolls=None,
      outer_masks=None,
      total_gibbs_steps=None,
  ):
      """Builds the tf.while_loop based sampling graph.
  
      Args:
        input_pianorolls: Optional input pianorolls override. If None, uses the
            pianorolls placeholder.
        outer_masks: Optional input outer_masks override. If None, uses the
            outer_masks placeholder.
        total_gibbs_steps: Optional input total_gibbs_steps override. If None,
            uses the total_gibbs_steps placeholder.
      Returns:
        The output op of the graph.
      """
      if input_pianorolls is None:
          input_pianorolls = self.inputs["pianorolls"]
      if outer_masks is None:
          outer_masks = self.inputs["outer_masks"]
  
      tt = tf.shape(input_pianorolls)[1]
      sample_steps = tf.to_float(self.inputs["sample_steps"])
      if total_gibbs_steps is None:
          total_gibbs_steps = self.inputs["total_gibbs_steps"]
      temperature = self.inputs["temperature"]
  
      input_pianorolls = tf.to_float(input_pianorolls)
      outer_masks = self.make_outer_masks(outer_masks, input_pianorolls)
  
      # Calculate total_gibbs_steps as steps * num_instruments if not given.
      total_gibbs_steps = tf.cond(
          tf.equal(total_gibbs_steps, 0),
          lambda: tf.to_float(tt * self.hparams.num_instruments),
          lambda: tf.to_float(total_gibbs_steps),
      )
  
      # sample_steps is set to total_gibbs_steps if not given.
      sample_steps = tf.cond(
          tf.equal(sample_steps, 0),
          lambda: total_gibbs_steps,
          lambda: tf.to_float(sample_steps),
      )
  
      def infer_step(pianorolls, step_count):
          """Called by tf.while_loop, takes a Gibbs step."""
          mask_prob = compute_mask_prob_from_yao_schedule(
              step_count, total_gibbs_steps
          )
          # 1 indicates mask out, 0 is not mask.
          masks = make_bernoulli_masks(
              tf.shape(pianorolls), mask_prob, outer_masks
          )
  
          logits = self.predict(pianorolls, masks)
          samples = sample_with_temperature(
              logits, temperature=temperature
          )
  
          outputs = pianorolls * (1 - masks) + samples * masks
  
          check_completion_op = tf.assert_equal(
              tf.where(
                  tf.equal(tf.reduce_max(masks, axis=2), 1.0),
                  tf.reduce_max(outputs, axis=2),
                  tf.reduce_max(pianorolls, axis=2),
              ),
              1.0,
          )
          with tf.control_dependencies([check_completion_op]):
              outputs = tf.identity(outputs)
  
          step_count += 1
          return outputs, step_count
  
      current_step = tf.to_float(self.inputs["current_step"])
  
      # Initializes pianorolls by evaluating the model once to fill in all gaps.
      logits = self.predict(tf.to_float(input_pianorolls), outer_masks)
      samples = sample_with_temperature(logits, temperature=temperature)
      tf.get_variable_scope().reuse_variables()
  
      self.samples, current_step = tf.while_loop(
          lambda samples, current_step: current_step < sample_steps,
          infer_step,
          [samples, current_step],
          shape_invariants=[
              tf.TensorShape([None, None, None, None]),
              tf.TensorShape(None),
          ],
          back_prop=False,
          parallel_iterations=1,
          name="coco_while",
      )
      self.samples.set_shape(input_pianorolls.shape)
      return self.samples
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import time
  from magenta.models.coconet import lib_graph
  from magenta.models.coconet import lib_hparams
  import numpy
  import tensorflow.compat.v1
label_desc: Use image node_id 5 for calling the CoconetSampleGraph obj's underlying member method code with example usage: obj.build_sample_graph(input_pianorolls, outer_masks, total_gibbs_steps) and returns: self, outputs,  step_count