code: def train():
      # Import data
      mnist = input_data.read_data_sets(
          FLAGS.data_dir, fake_data=FLAGS.fake_data
      )
  
      sess = tf.InteractiveSession()
      # Create a multilayer model.
  
      # Input placeholders
      with tf.name_scope("input"):
          x = tf.placeholder(tf.float32, [None, 784], name="x-input")
          y_ = tf.placeholder(tf.int64, [None], name="y-input")
  
      with tf.name_scope("input_reshape"):
          image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
          tf.summary.image("input", image_shaped_input, 10)
  
      # We can't initialize these variables to 0 - the network will get stuck.
      def weight_variable(shape):
          """Create a weight variable with appropriate initialization."""
          initial = tf.truncated_normal(shape, stddev=0.1)
          return tf.Variable(initial)
  
      def bias_variable(shape):
          """Create a bias variable with appropriate initialization."""
          initial = tf.constant(0.1, shape=shape)
          return tf.Variable(initial)
  
      def variable_summaries(var):
          """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
          with tf.name_scope("summaries"):
              mean = tf.reduce_mean(var)
              tf.summary.scalar("mean", mean)
              with tf.name_scope("stddev"):
                  stddev = tf.sqrt(
                      tf.reduce_mean(tf.square(var - mean))
                  )
              tf.summary.scalar("stddev", stddev)
              tf.summary.scalar("max", tf.reduce_max(var))
              tf.summary.scalar("min", tf.reduce_min(var))
              tf.summary.histogram("histogram", var)
  
      def nn_layer(
          input_tensor,
          input_dim,
          output_dim,
          layer_name,
          act=tf.nn.relu,
      ):
          """Reusable code for making a simple neural net layer.
  
          It does a matrix multiply, bias add, and then uses ReLU to nonlinearize.
          It also sets up name scoping so that the resultant graph is easy to read,
          and adds a number of summary ops.
          """
          # Adding a name scope ensures logical grouping of the layers in the graph.
          with tf.name_scope(layer_name):
              # This Variable will hold the state of the weights for the layer
              with tf.name_scope("weights"):
                  weights = weight_variable([input_dim, output_dim])
                  variable_summaries(weights)
              with tf.name_scope("biases"):
                  biases = bias_variable([output_dim])
                  variable_summaries(biases)
              with tf.name_scope("Wx_plus_b"):
                  preactivate = (
                      tf.matmul(input_tensor, weights) + biases
                  )
                  tf.summary.histogram("pre_activations", preactivate)
              activations = act(preactivate, name="activation")
              tf.summary.histogram("activations", activations)
              return activations
  
      hidden1 = nn_layer(x, 784, 500, "layer1")
  
      with tf.name_scope("dropout"):
          keep_prob = tf.placeholder(tf.float32)
          tf.summary.scalar("dropout_keep_probability", keep_prob)
          dropped = tf.nn.dropout(hidden1, keep_prob)
  
      # Do not apply softmax activation yet, see below.
      y = nn_layer(dropped, 500, 10, "layer2", act=tf.identity)
  
      with tf.name_scope("cross_entropy"):
          # The raw formulation of cross-entropy,
          #
          # tf.reduce_mean(-tf.reduce_sum(y_ * tf.math.log(tf.softmax(y)),
          #                                                             reduction_indices=[1]))
          #
          # can be numerically unstable.
          #
          # So here we use tf.compat.v1.losses.sparse_softmax_cross_entropy on the
          # raw logit outputs of the nn_layer above, and then average across
          # the batch.
          with tf.name_scope("total"):
              cross_entropy = tf.losses.sparse_softmax_cross_entropy(
                  labels=y_, logits=y
              )
      tf.summary.scalar("cross_entropy", cross_entropy)
  
      with tf.name_scope("train"):
          train_step = tf.train.AdamOptimizer(
              FLAGS.learning_rate
          ).minimize(cross_entropy)
  
      with tf.name_scope("accuracy"):
          with tf.name_scope("correct_prediction"):
              correct_prediction = tf.equal(tf.argmax(y, 1), y_)
          with tf.name_scope("accuracy"):
              accuracy = tf.reduce_mean(
                  tf.cast(correct_prediction, tf.float32)
              )
      tf.summary.scalar("accuracy", accuracy)
  
      # Merge all the summaries and write them out to
      # /tmp/tensorflow/mnist/logs/mnist_with_summaries (by default)
      merged = tf.summary.merge_all()
      train_writer = tf.summary.FileWriter(
          os.path.join(FLAGS.log_dir, "train"), sess.graph
      )
      test_writer = tf.summary.FileWriter(
          os.path.join(FLAGS.log_dir, "test")
      )
  
      tf.global_variables_initializer().run()
  
      # Train the model, and also write summaries.
      # Every 10th step, measure test-set accuracy, and write test summaries
      # All other steps, run train_step on training data, & add training summaries
  
      def feed_dict(train):
          """Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""
          if train or FLAGS.fake_data:
              xs, ys = mnist.train.next_batch(
                  FLAGS.batch_size, fake_data=FLAGS.fake_data
              )
              k = FLAGS.dropout
          else:
              xs, ys = mnist.test.images, mnist.test.labels
              k = 1.0
          return {x: xs, y_: ys, keep_prob: k}
  
      saver = tf.train.Saver()
      for i in range(FLAGS.max_steps):
          if i % 10 == 0:  # Record summaries and test-set accuracy
              summary, acc = sess.run(
                  [merged, accuracy], feed_dict=feed_dict(False)
              )
              test_writer.add_summary(summary, i)
              print("Accuracy at step %s: %s" % (i, acc))
          else:  # Record train set summaries, and train
              if (
                  i % FLAGS.batch_size == FLAGS.batch_size - 1
              ):  # Record execution stats
                  run_metadata = tf.RunMetadata()
                  summary, _ = sess.run(
                      [merged, train_step],
                      feed_dict=feed_dict(True),
                      run_metadata=run_metadata,
                  )
                  train_writer.add_run_metadata(
                      run_metadata, "step%04d" % i
                  )
                  train_writer.add_summary(summary, i)
                  print("Adding run metadata for", i)
              else:  # Record a summary
                  summary, _ = sess.run(
                      [merged, train_step], feed_dict=feed_dict(True)
                  )
                  # train_writer.add_summary(summary, i)
  
      save_path = saver.save(sess, FLAGS.save_path)
      print("Saved model: %s" % save_path)
      print("Flushing all images, this may take a couple of minutes")
      train_writer.close()
      test_writer.close()
      print("Finished storing all metrics & images")
  
file_path: clearml/examples/frameworks/tensorflow/legacy/tensorflow_mnist_with_summaries.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import argparse
  import os
  import sys
  import tempfile
  import tensorflow
  from tensorflow.examples.tutorials.mnist import input_data
  from clearml import Task
label_desc: Use image node_id 1 for calling a global function with example usage: train() and returns: tf, tf, dict, activations