code: def train(images, labels, ckpt_path, dropout=False):
      """
      This function contains the loop that actually trains the model.
      :param images: a numpy array with the input data
      :param labels: a numpy array with the output labels
      :param ckpt_path: a path (including name) where model checkpoints are saved
      :param dropout: Boolean, whether to use dropout or not
      :return: True if everything went well
      """
  
      # Check training data
      assert len(images) == len(labels)
      assert images.dtype == np.float32
      assert labels.dtype == np.int32
  
      # Set default TF graph
      with tf.Graph().as_default():
          global_step = tf.Variable(0, trainable=False)
  
          # Declare data placeholder
          train_data_node = _input_placeholder()
  
          # Create a placeholder to hold labels
          train_labels_shape = (FLAGS.batch_size,)
          train_labels_node = tf.placeholder(
              tf.int32, shape=train_labels_shape
          )
  
          print("Done Initializing Training Placeholders")
  
          # Build a Graph that computes the logits predictions from the placeholder
          if FLAGS.deeper:
              logits = inference_deeper(
                  train_data_node, dropout=dropout
              )
          else:
              logits = inference(train_data_node, dropout=dropout)
  
          # Calculate loss
          loss = loss_fun(logits, train_labels_node)
  
          # Build a Graph that trains the model with one batch of examples and
          # updates the model parameters.
          train_op = train_op_fun(loss, global_step)
  
          # Create a saver.
          saver = tf.train.Saver(tf.global_variables())
  
          print("Graph constructed and saver created")
  
          # Build an initialization operation to run below.
          init = tf.global_variables_initializer()
  
          # Create and init sessions
          sess = tf.Session(
              config=tf.ConfigProto(
                  log_device_placement=FLAGS.log_device_placement
              )
          )  # NOLINT(long-line)
          sess.run(init)
  
          print("Session ready, beginning training loop")
  
          # Initialize the number of batches
          data_length = len(images)
          nb_batches = math.ceil(data_length / FLAGS.batch_size)
  
          for step in xrange(FLAGS.max_steps):
              # for debug, save start time
              start_time = time.time()
  
              # Current batch number
              batch_nb = step % nb_batches
  
              # Current batch start and end indices
              start, end = utils.batch_indices(
                  batch_nb, data_length, FLAGS.batch_size
              )
  
              # Prepare dictionnary to feed the session with
              feed_dict = {
                  train_data_node: images[start:end],
                  train_labels_node: labels[start:end],
              }
  
              # Run training step
              _, loss_value = sess.run(
                  [train_op, loss], feed_dict=feed_dict
              )
  
              # Compute duration of training step
              duration = time.time() - start_time
  
              # Sanity check
              assert not np.isnan(
                  loss_value
              ), "Model diverged with loss = NaN"
  
              # Echo loss once in a while
              if step % 100 == 0:
                  num_examples_per_step = FLAGS.batch_size
                  examples_per_sec = num_examples_per_step / duration
                  sec_per_batch = float(duration)
  
                  format_str = (
                      "%s: step %d, loss = %.2f (%.1f examples/sec; %.3f "
                      "sec/batch)"
                  )
                  print(
                      format_str
                      % (
                          datetime.now(),
                          step,
                          loss_value,
                          examples_per_sec,
                          sec_per_batch,
                      )
                  )
  
              # Save the model checkpoint periodically.
              if step % 1000 == 0 or (step + 1) == FLAGS.max_steps:
                  saver.save(sess, ckpt_path, global_step=step)
  
      return True
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from datetime import datetime
  import math
  import numpy
  from six.moves import xrange
  import tensorflow.compat.v1
  import time
  import utils
label_desc: Use image node_id 9 for calling a global function with example usage: train(images, labels, ckpt_path, dropout) and returns: True