code: def cache_bottlenecks(
      sess,
      image_lists,
      image_dir,
      bottleneck_dir,
      jpeg_data_tensor,
      decoded_image_tensor,
      resized_input_tensor,
      bottleneck_tensor,
      module_name,
  ):
      """Ensures all the training, testing, and validation bottlenecks are cached.
  
      Because we're likely to read the same image multiple times (if there are no
      distortions applied during training) it can speed things up a lot if we
      calculate the bottleneck layer values once for each image during
      preprocessing, and then just read those cached values repeatedly during
      training. Here we go through all the images we've found, calculate those
      values, and save them off.
  
      Args:
        sess: The current active TensorFlow Session.
        image_lists: OrderedDict of training images for each label.
        image_dir: Root folder string of the subfolders containing the training
        images.
        bottleneck_dir: Folder string holding cached files of bottleneck values.
        jpeg_data_tensor: Input tensor for jpeg data from file.
        decoded_image_tensor: The output of decoding and resizing the image.
        resized_input_tensor: The input node of the recognition graph.
        bottleneck_tensor: The penultimate output layer of the graph.
        module_name: The name of the image module being used.
  
      Returns:
        Nothing.
      """
      how_many_bottlenecks = 0
      ensure_dir_exists(bottleneck_dir)
      for label_name, label_lists in image_lists.items():
          for category in ["training", "testing", "validation"]:
              category_list = label_lists[category]
              for index, unused_base_name in enumerate(category_list):
                  get_or_create_bottleneck(
                      sess,
                      image_lists,
                      label_name,
                      index,
                      image_dir,
                      category,
                      bottleneck_dir,
                      jpeg_data_tensor,
                      decoded_image_tensor,
                      resized_input_tensor,
                      bottleneck_tensor,
                      module_name,
                  )
  
                  how_many_bottlenecks += 1
                  if how_many_bottlenecks % 100 == 0:
                      logging.info(
                          "%s bottleneck files created.",
                          how_many_bottlenecks,
                      )
  
imports: from absl import logging
  import argparse
  import collections
  from datetime import datetime
  import hashlib
  import os.path
  import random
  import re
  import sys
  import numpy
  import tensorflow
  import tensorflow_hub
  from tensorflow.contrib import quantize
label_desc: Use image node_id 9 for calling a global function with example usage: cache_bottlenecks(sess, image_lists, image_dir, bottleneck_dir, jpeg_data_tensor, decoded_image_tensor, resized_input_tensor, bottleneck_tensor, module_name) without return types