code: def autoregressive_sample(
      model,
      inputs=None,
      batch_size=1,
      temperature=1.0,
      start_id=0,
      eos_id=1,
      max_length=100,
      accelerate=True,
      eval_mode=False,
      eval_min_length=1,
  ):
      """Returns a batch of sequences created by autoregressive sampling.
  
      This function uses `model` to generate outputs one position at a time, with
      access to inputs for the current position and all preceding positions. The
      new output becomes the next position's input, and this loop repeats until
      either the model outputs the `eos_id` value or the output sequence reaches
      `max_length` items.
  
      Args:
        model: A layer object (subclass of `trax.layers.Layer`) created in
            `'predict'` mode and initialized from trained weights. The model
            must have a structure that allows it to run as autoregressive
            one-sample-at-a-time predictor (e.g., `trax.models.TransformerLM`),
            except if `eval_mode` is set -- any model can be sampled then,
            but the sampling process may be much slower.
        inputs: Sequence of symbols the model sees as input the first time it
            generates an output. If None, the model must generate the first output
            with no input to guide it.
        batch_size: Number of sequences to generate in parallel as a batch.
        temperature: Parameter that controls the sharpness of the softmax that
            feeds the sampling process. Values range from 0.0 (all probability mass
            goes to one candidate; like an argmax) to positive infinity (all
            candidates have equal probability).
        start_id: The start symbol (ID/integer) for the autoregressive process,
            or array of shape (`batch_size`, 1) of such integers.
        eos_id: The end-of-sequence symbol (ID/integer) for the autoregressive
            process.
        max_length: Maximum length for generated sequences.
        accelerate: If True, create an accelerated version of `model` and use it
            for generating outputs.
        eval_mode: If True, assume the model is created in `eval` mode and sample
            by collecting all previous outputs and passing the whole tensor.
        eval_min_length: If set, the minimum length to pad to in eval mode.
  
      Returns:
        Tensor of integers with shape (`batch_size`, output_length) representing
        a batch of output sequences. output_length is the maximum length of the
        output sequences, where each sequence can be no longer than `max_length`.
      """
      result = []
      eos_seen = []
      counter = 0
      for sample in autoregressive_sample_stream(
          model,
          inputs,
          batch_size=batch_size,
          temperature=temperature,
          start_id=start_id,
          accelerate=accelerate,
          eval_mode=eval_mode,
          eval_min_length=eval_min_length,
      ):
          sample = sample[:, None]
          result.append(sample)
          counter += 1
          if counter >= max_length:
              return np.concatenate(result, axis=1)
          # Check at which batch positions have we already encountered EOS.
          for j in range(batch_size):
              if int(sample[j, 0]) == eos_id:
                  eos_seen.append(j)
          # If EOS has been seen on all positions, stop.
          if all([j in eos_seen for j in range(batch_size)]):
              return np.concatenate(result, axis=1)
      return np.concatenate(result, axis=1)
  
imports: import numpy
  from trax import fastmath
  from trax import layers
label_desc: Use image node_id 2 for calling a global function with example usage: autoregressive_sample(model, inputs, batch_size, temperature, start_id, eos_id, max_length, accelerate, eval_mode, eval_min_length) and returns: np, np, np