code: def mscoco_generator(
      data_dir,
      tmp_dir,
      training,
      how_many,
      start_from=0,
      eos_list=None,
      vocab_filename=None,
  ):
      """Image generator for MSCOCO captioning problem with token-wise captions.
  
      Args:
        data_dir: path to the data directory.
        tmp_dir: path to temporary storage directory.
        training: a Boolean; if true, we use the train set, otherwise the test set.
        how_many: how many images and labels to generate.
        start_from: from which image to start.
        eos_list: optional list of end of sentence tokens, otherwise use default
          value `1`.
        vocab_filename: file within `tmp_dir` to read vocabulary from.
  
      Yields:
        A dictionary representing the images with the following fields:
        * image/encoded: the string encoding the image as JPEG,
        * image/format: the string "jpeg" representing image format,
        * image/class/label: a list of integers representing the caption,
        * image/height: an integer representing the height,
        * image/width: an integer representing the width.
        Every field is actually a list of the corresponding type.
      """
      eos_list = [1] if eos_list is None else eos_list
  
      def get_vocab():
          """Get vocab for caption text encoder."""
          if data_dir is not None and vocab_filename is not None:
              vocab_filepath = os.path.join(data_dir, vocab_filename)
              if tf.gfile.Exists(vocab_filepath):
                  tf.logging.info(
                      "Found vocab file: %s", vocab_filepath
                  )
                  vocab_symbolizer = text_encoder.SubwordTextEncoder(
                      vocab_filepath
                  )
                  return vocab_symbolizer
              else:
                  raise ValueError(
                      "Vocab file does not exist: %s" % vocab_filepath
                  )
          return None
  
      vocab_symbolizer = get_vocab()
      _get_mscoco(tmp_dir)
      caption_filepath = (
          _MSCOCO_TRAIN_CAPTION_FILE
          if training
          else _MSCOCO_EVAL_CAPTION_FILE
      )
      caption_filepath = os.path.join(tmp_dir, caption_filepath)
      prefix = _MSCOCO_TRAIN_PREFIX if training else _MSCOCO_EVAL_PREFIX
      caption_file = io.open(caption_filepath)
      caption_json = json.load(caption_file)
      # Dictionary from image_id to ((filename, height, width), captions).
      image_dict = {}
      for image in caption_json["images"]:
          image_dict[image["id"]] = [
              (image["file_name"], image["height"], image["width"]),
              [],
          ]
      annotations = caption_json["annotations"]
      annotation_count = len(annotations)
      image_count = len(image_dict)
      tf.logging.info(
          "Processing %d images and %d labels\n"
          % (image_count, annotation_count)
      )
      for annotation in annotations:
          image_id = annotation["image_id"]
          image_dict[image_id][1].append(annotation["caption"])
  
      data = list(image_dict.values())[
          start_from : start_from + how_many
      ]
      random.shuffle(data)
      for image_info, labels in data:
          image_filename = image_info[0]
          image_filepath = os.path.join(tmp_dir, prefix, image_filename)
          with tf.gfile.Open(image_filepath, "rb") as f:
              encoded_image_data = f.read()
              height, width = image_info[1], image_info[2]
              for label in labels:
                  if vocab_filename is None or vocab_symbolizer is None:
                      label = [ord(c) for c in label] + eos_list
                  else:
                      label = vocab_symbolizer.encode(label) + eos_list
                  yield {
                      "image/encoded": [encoded_image_data],
                      "image/format": ["jpeg"],
                      "image/class/label": label,
                      "image/height": [height],
                      "image/width": [width],
                  }
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import io
  import json
  import os
  import random
  import zipfile
  from tensor2tensor.data_generators import generator_utils
  from tensor2tensor.data_generators import image_utils
  from tensor2tensor.data_generators import imagenet
  from tensor2tensor.data_generators import problem
  from tensor2tensor.data_generators import text_encoder
  from tensor2tensor.data_generators import translate_ende
  from tensor2tensor.utils import registry
  import tensorflow.compat.v1
label_desc: Use image node_id 2 for calling a global function with example usage: mscoco_generator(data_dir, tmp_dir, training, how_many, start_from, eos_list, vocab_filename) and returns: None, vocab_symbolizer