Our series about a simple CNN trained on the MNIST data turns back to some coding.

A simple CNN for the MNIST dataset – VII – outline of steps to visualize image patterns which trigger filter maps

A simple CNN for the MNIST dataset – VI – classification by activation patterns and the role of the CNN’s MLP part

A simple CNN for the MNIST dataset – V – about the difference of activation patterns and features

A simple CNN for the MNIST dataset – IV – Visualizing the activation output of convolutional layers and maps

A simple CNN for the MNIST dataset – III – inclusion of a learning-rate scheduler, momentum and a L2-regularizer

A simple CNN for the MNIST datasets – II – building the CNN with Keras and a first test

A simple CNN for the MNIST datasets – I – CNN basics

In the last article I discussed an optimization algorithm which should be able to create images of pixel patterns which trigger selected feature maps of a CNN strongly. In this article we shall focus on the required code elements. I again want to emphasize that I apply and *modify* some basic ideas which I read in a book of F. Chollet and in a contribution of a guy called Mohamed to a discussion at kaggle.com (see my last article for references). A careful reader will notice differences not only with respect to coding; there are major differences regarding the normalization of intermediate data and the construction of input images. To motivate the latter point I first want to point out that OIPs are idealized technical abstractions and that not all maps may react to purely statistical data on short length scales.

# Images of OIPs which trigger feature maps are artificial technical abstractions!

In the last articles I made an explicit distinction between two types of patterns which we can analyze in the context of CNNs:

- FCP: A pattern which emerges within and across activation maps of a chosen (deep) convolutional layer due to filter operations which the CNN applied to a specific input image.
- OIP: A pattern which is present within the pixel value distribution of an input image and to which a CNN map reacts strongly.

Regarding OIPs there are some points which we should keep in mind:

- We do something
*artificial*when we create an image of an elementary OIP pattern to which a*chosen*feature map reacts. Such an OIP is already an abstraction in the sense that it reflects an*idealized*pattern - i.e. a specific geometrical correlation between pixel values of an input image which passes a very specific filter combinations. We forget about all other figurative elements of the input image which may trigger*other*maps. - There is an additional subtle point regarding our present approach to OIP-visualization:

Our algorithm - if it works - will lead to OIP images which trigger a map's neurons maximally**on average**. What does "average" mean with respect to the image area? A map always covers the whole input image area. Now let us assume that a filter combination of lower layers reacts to an elementary pattern*limited in size*and located somewhere on the input image. But some filters or filter combinations may be capable of detecting such a pattern atof an input image.**multiple locations**

One example would be a crossing of two relatively thin lines. Such a crossing could appear at many places in an input image. In fact, a trained CNN has seen several thousand images of handwritten "4"s where the crossing of the horizontal and the vertical line actually appeared at many different locations and may have learned about this when establishing filters. Under such conditions it is obvious that a map gets optimally activated if a relatively small elementary pattern*appears multiple times*within the image which our algorithm*artificially*constructs out of initial random data.

So our algorithm will with a high probability lead to OIP images which consist of a combination or a superposition of elementary patterns at multiple locations. In this sense an OIP image constructed due to the rule of a maximum average activation is another type of idealization. In a real MNIST image the re-occurrence of elementary patterns may not be present at all. Therefore, we should be careful and not directly associate the visualization of a pattern created by our algorithm with an elementary OIP or "feature". - The last argument can in some cases also be reverted: There may be unique
*large scale*patterns which can only be detected by filters of higher (i.e. deeper) convolutional levels which filter coarsely and with respect to relatively large areas of the image. In our approach such unique patterns may*only*appear in OIP images constructed for maps of the deepest convolutional layer.

# Independence of the statistical data of the input image?

In the last article I showed you already some interesting patterns for certain maps which emerged from randomly varying pixel values in an input image. The fluctuations were forced into patterns by the discussed optimization loop. An example of the resulting evolution of the pixel values is shown below: With more and more steps of the optimization loop an OIP-pattern emerges out of the initial "chaos".

Images were taken at optimization steps 0, 9, 18, 36, 72, 144, 288, 599 of a loop. Convergence is given by a change of the loss values between two different steps divided by the present loss value :

3.6/41 => 3.9/76 => 3.3/143 => 2.3/240 => 0.8/346 => 0.15/398 => 0.03/418

As we work with gradient ascent in OIP detection a lower loss means a lower activation of the map.

If we change the wavelength of the initial input fluctuations we get a somewhat, though not fundamentally different result (actually with a lower loss value of 381):

This gives us confidence in the general usability of the method. However, I would like to point out that during your own experiments you may also experience the contrary:

For some maps and for some initial statistical input data varying at short length scales, only, the optimization process will not converge. It will not even start to do so. Instead you may experience a *zero activation* of the selected map during all steps of the optimization for a given random input.

You should not be too surprised by this fact. Our CNN was optimized to react to patterns present in written digits. As digits have specific elements (features?) as straight lines, bows, circles, line-crossings, etc., we should expect that not all input will trigger the activation of a selected map which reacts on pixel value variations at relatively large length scales. Therefore, it is helpful to be able to vary the statistical input pattern *at different length scales* when you start your hunt for a nice visualization of an OIP and/or elementary feature.

All in all we cannot exclude a dependency on the statistical initial input image fluctuations. Our algorithm will find a maximum with respect to the specific input data fluctuations presented to him. Due to this point we should always be aware of the fact that the visualizations produced by our algorithm will probably mark a local maximum in the multidimensional parameter or representation space - not a global one. But also a local maximum may reveal significant sub-structures a specific filter combination is sensitive to.

# Libraries

To build a suitable code we need to import some libraries, which you first must install into your virtual Python environment:

import numpy as np import scipy import time import sys import math from sklearn.preprocessing import StandardScaler import tensorflow as tf from tensorflow import keras as K from tensorflow.python.keras import backend as B from tensorflow.keras import models from tensorflow.keras import layers from tensorflow.keras import regularizers from tensorflow.keras import optimizers from tensorflow.keras.optimizers import schedules from tensorflow.keras.utils import to_categorical from tensorflow.keras.datasets import mnist from tensorflow.python.client import device_lib import matplotlib as mpl from matplotlib import pyplot as plt from matplotlib.colors import ListedColormap import matplotlib.patches as mpat import os from os import path as path

# Basic code elements to construct OIP patterns from statistical input image data

To develop some code for OIP visualizations we follow the outline of steps discussed in the last article. To encapsulate the required functionality we set up a Python class. The following code fragment gives an overview about some variables which we are going to use. In the comments and explanations I sometimes used the word "reference" to mark a difference between

- addresses to some intermediate Tensorflow 2 [TF2] objects handled by a "
**watch()**"-method of TF2's GradientTape-object for eager calculation of gradients *and*eventual return objects (of a function based on keras' backend) filled with values which we can*directly*use during the optimization iterations for corrections.

This is only a reminder of complex internal TF2 background operations based on complex layer models; I do not want to stress any difference in the sense of pointers and objects. Actually, I do not even know the precise programming patterns used behind TF2's watch()-mechanism; but according to the documentation it basically records all operations involving the "watched" objects. The objective is the ability to produce gradient values of defined functions with respect to any variable changes *instantaneously* in eager execution later on.

# class to produce images of OIPs for a chosen CNN-map # ******************************************************* class My_OIP: ''' Version 0.2, 01.09.2020 ~~~~~~~~~~~~~~~~~~~~~~~~~ This class allows for the creation and the display of OIP-patterns to which a selected map of a CNN-model reacts Functions: ~~~~~~~~~~ 1) _load_cnn_model() => load cnn-model 2) _build_oip_model() => build an oip-model to create OIP-images 3) _setup_gradient_tape() => Implements TF2 GradientTape to watch input data for eager gradient calculation 4) _oip_strat_0_optimization_loop(): => Method implementing a simple strategy to create OIP-images based on superposition of random data on large distance scales 5) _oip_strat_1_optimization_loop(): (NOT YET DEVELOPED) => Method implementing a complex strategy to create OIP-images based on partially evolved intermediate image getting enriched by small scale fluctuations 6) _derive_OIP(): => Method used externally to start the creation of an OIP for a chosen map 7) _build_initial_img_data() => Method to construct an initial image based on a superposition by random date on 4 different length scales Requirements / Preconditions: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In the present version * a CNN-model is assumed which works with standardized (!) input images, * a CNN-Modell trained on MNIST data is assumed , * exactly 4 length scales for random data fluctations are used to compose initial statistical image data (roughly with a factor of 2 between them) ''' def __init__(self, cnn_model_file = 'cnn_best.h5', layer_name = 'Conv2D_3', map_index = 0, img_dim = 28, b_build_oip_model = True ): ''' Input: ~~~~~~ cnn_model_file: Name of a file containing a full CNN-model can later be overwritten by _load_cnn_model() layer_name: We can define a layer name we are interested in already when starting; s. below map_index: We may define a map we are interested in already when starting; s. below img_dim: The dimension of the assumed quadratic images Major internal variables: ************************** _cnn_model: A reference to the CNN model object _layer_name: The name of convolutional layer (can be overwritten by method _build_oip_model() ) _map_index: index of the map in the layer's output array (can later be overwritten by other methods) _r_cnn_inputs: A reference to the input tensor of the CNN model (here: 1 image - NOT a batch of images) _layer_output: Tensor with all maps of a certain layer _oip_submodel: A new model connecting the input of the cnn-model with a certain map _tape: An instance of TF2's GradientTape-object Watches input, output, loss of a model and calculates gradients in TF2 eager mode _r_oip_outputs: A reference to the output of the new OIP-model _r_oip_grads: Reference to gradient tensors for the new OIP-model _r_oip_loss: Reference to a loss defined by operations on the OIP-output _val_oip_loss: Reference to a loss defined by operations on the OIP-output _iterate: Keras backend function to invoke the new OIP-model and calculate both loss and gradient values (in TF2 eager mode) This is the function to be used in the optimization loop for OIPs Parameters controlling the optimization loop: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ _oip_strategy: 0, 1 - There are two strategies to evolve OIP patterns out of statistical data - only the first strategy is supported in this version 0: Simple superposition of fluctuations at different length scales 1: Evolution over partially evolved images based on longer scale variations enriched with fluctuations on shorter length scales Both strategies can be combined with a precursor calculation _b_oip_precursor: True/False - Use a precursor analysis of long range variations regarding loss => search for optimum variations for a given map (Some initial input images do not trigger a map at all or sub-optimally => We test out multiple initial fluctuation patterns). _ay_epochs: A list of 4 optimization epochs to be used whilst evolving the img data via strategy 1 and intermediate images _n_epochs: Number of optimization epochs to be used with strategy 0 _n_steps: Defines at how many intermediate points we show images and report on the optimization process _epsilon: Factor to control the amount of correction imposed by the gradient values of the OIP-model Input image data of the OIP-model and references to it ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ _initial_precursor_img The initial image to start a precursor optimization with. Would normally be an image of only long range fluctuations. _precursor_image: The evolved image updated during the precursor loop _initial_inp_img_data: A tensor representing the data of the input image _inp_img_data: A tensor representing the data of the input img during optimization _img_dim: We assume quadratic images to work with with dimension _img_dim along each axis For the time being we only support MNIST images Parameters controlling the composition of random initial image data ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ _li_dim_steps: A list of the intermediate dimensions for random data; these data are smoothly scaled to the image dimensions _ay_facts: A Numpy array of 4 factors to control the amount of contribution of the statistical variations on the 4 length scales to the initial image ''' # Input data and variable initializations # **************************************** # the model self._cnn_model_file = cnn_model_file self._cnn_model = None # the layer self._layer_name = layer_name # the map self._map_index = map_index # References to objects and the OIP sub-model # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self._r_cnn_inputs = None # reference to input of the CNN_model # also used in the OIP-model self._layer_output = None self._oip_submodel = None self._tape = None # TF2 GradientTape variable # some "references" self._r_oip_outputs = None # output of the OIP-submodel to be watched self._r_oip_grads = None # gradients determined by GradientTape self._r_oip_loss = None # respective values self._val_oip_grads = None self._val_oip_loss = None # The Keras function to produce concrete outputs of the new OIP-model self._iterate = None # The strategy to produce an OIP pattern out of statistical input images # ~~~~~~~~~~~~~~~~~~~~~~~~~--------~~~~~~ # 0: Simple superposition of fluctuations at different length scales # 1: Move over 4 interediate images - partially optimized self._oip_strategy = 0 # Parameters controlling the OIP-optimization process # ~~~~~~~~~~~~~~~~~~~~~~~~~--------~~~~~~ # Use a precursor analysis ? self._b_oip_precursor = False # number of epochs for optimization strategy 1 self._ay_epochs = np.array((20, 40, 80, 400)) len_epochs = len(self._ay_epochs) # number of epochs for optimization strategy 0 self._n_epochs = self._ay_epochs[len_epochs-1] self._n_steps = 7 # divides the number of n_epochs into n_steps # to produce intermediate outputs # size of corrections by gradients self._epsilon = 0.01 # step-size for gradient correction # Input images and references to it # ~~~~~~~~ # precursor image self._initial_precursor_img = None self._precursor_img = None # The evetually used input image - a superposition of initial random fluctuations self._initial_inp_img_data = None # The initial data constructed self._inp_img_data = None # The data used and varied for optimization # image dimension self._img_dim = img_dim # = 28 => MNIST images for the time being # Parameters controlling the setup of an initial image # ~~~~~~~~~~~~~~~~~~~~~~~~~--------~~~~~~~~~~~~~~~~~~~ # The length scales for initial input fluctuations self._li_dim_steps = ( (3, 3), (7,7), (14,14), (28,28) ) # Parameters for fluctuations - used both in strategy 0 and strategy 1 self._ay_facts = np.array( (0.5, 0.5, 0.5, 0.5) ) # ******************************************************** # Model setup - load the cnn-model and build the oip-model # ************ if path.isfile(self._cnn_model_file): # We trigger the initial load of a model self._load_cnn_model(file_of_cnn_model = self._cnn_model_file, b_print_cnn_model = True) # We trigger the build of a new sub-model based on the CNN model used for OIP search self._build_oip_model(layer_name = self._layer_name, b_print_oip_model = True ) else: print("<\nWarning: The standard file " + self._cnn_model_file + " for the cnn-model could not be found!\n " + " Please use method _load_cnn_model() to load a valid model") return

The purpose of most of the variables will become clearer as we walk though the class's methods below.

# Loading the original trained CNN model

Let us say we have a trained CNN-model with all final weight parameters for node-connections saved in some h5-file (see the 4th article of this series for more info). We then can load the CNN-model and derive sub-models from its layer elements. The following method performs the loading task for us:

# # Method to load a specific CNN model # ********************************** def _load_cnn_model(self, file_of_cnn_model='cnn_best.h5', b_print_cnn_model=True ): # Check existence of the file if not path.isfile(self._cnn_model_file): print("<\nWarning: The file " + file_of_cnn_model + " for the cnn-model could not be found!\n" + "Please change the parameter \"file_of_cnn_model\"" + " to load a valid model") # load the CNN model self._cnn_model_file = file_of_cnn_model self._cnn_model = models.load_model(self._cnn_model_file) # Inform about the model and its file file 7 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~ print("Used file to load a ´ model = ", self._cnn_model_file) # we print out the models structure if b_print_cnn_model: print("Structure of the loaded CNN-model:\n") self._cnn_model.summary() # handle/references to the models input => more precise the input image # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Note: As we only have one image instead of a batch # we pick only the first tensor element! # The inputs will be needed for buildng the oip-model self._r_cnn_inputs = self._cnn_model.inputs[0] # !!! We have a btach with just ONE image # print out the shape - it should be known fro the original cnn-model print("shape of cnn-model inputs = ", self._r_cnn_inputs.shape) return

Actually, I used this function already in the class' "__init__()"-method - provided the standard file for the last CNN exists. (In a more advanced version you would in addition check that the name of the standard CNN-model meets your expectations.)

The code is straightforward. You see that the structure of the original CNN-model is printed out if requested by the user.

Note also that we assigned the first element of the input tensor of the CNN-model, i.e. a single image tensor, to the variable "self._r_cnn_inputs". This tensor will become a major ingredient in a new Keras model which we are going to build in a minute and which we shall use to calculate gradient components of a loss function with respect to all pixel values of the input image. The gradient's component values will in turn be used during *gradient ascent* to correct the pixel values. Repeated corrections should lead to a systematic approach of a maximum of our loss function, which describes the map's activation. (Remember: Such a maximum may depend on the input image fluctuations).

# Build a new Keras model based on the input tensor and a chosen layer

The next method is more interesting. We need to build a new Keras layer "model" based on the input layer and a deeper layer of the original CNN-model. (We already used the same kind of "trick" when we tried to visualize the activation output of a convolutional layer of the CNN.)

# # Method to construct a model to optimize input for OIP-detection # *************************************** def _build_oip_model(self, layer_name = 'Conv2D_3', b_print_oip_model=True ): ''' We need a Conv layer to build a working model for input image optimization. We get the Conv layer by the layer's name. The new model connects the first input element of the CNN to the output maps of the named Conv layer CNN ''' # free some RAM - hopefully del self._oip_submodel self._layer_name = layer_name if self._cnn_model == None: print("Error: cnn_model not yet defined.") sys.exit() # We build a new model based ion the model inputs and the output self._layer_output = self._cnn_model.get_layer(self._layer_name).output # We do not acre at the moment about the composition of the input # We trust in that we handle only one image - and not a batch model_name = "mod_oip__" + layer_name self._oip_submodel = models.Model( [self._r_cnn_inputs], [self._layer_output], name = model_name) # We print out the oip model structure if b_print_oip_model: print("Structure of the constructed OIP-sub-model:\n") self._oip_submodel.summary() return

We use the tensor for a single input image and the output of layer (= a collection of maps) of the original CNN-model as the definition elements of the new Keras model.

# TF2's GradientTape() - watch the change of variables which have an impact on model gradients and the loss function

What do we have so far? We have defined a new Keras model connecting input and output data of a layer of the original model. TF2 can determine related gradients by the node connections defined in the original model. However, we cannot rely on a graph analysis by Tensorflow as we were used to with TF1. TF2 uses *eager mode* - i.e. it calculates gradients directly. What does "directly" mean? Well - as soon as changes to variables occur which have an impact on the gradient values. This in turn means that "something" has to watch out for such changes. TF2 offers a special object for this purpose: **tf.GradientTape**. See:

https://www.tensorflow.org/guide/eager

https://www.tensorflow.org / api_docs/python/tf/GradientTape

So, as a next step, we set up a method to take care of "GradientTape()".

# # Method to watch gradients # ************************* def _setup_gradient_tape(self): ''' For TF2 eager execution we need to watch input changes and trigger gradient evaluation ''' # Working with TF2 GradientTape self._tape = None # Watch out for input, output variables with respect to gradient chnages with tf.GradientTape() as self._tape: # Input # ~~~~~~~ self._tape.watch(self._r_cnn_inputs) # Output # ~~~~~~~ self._r_oip_outputs = self._oip_submodel(self._r_cnn_inputs) # Loss # ~~~~~~~ self._r_oip_loss = tf.reduce_mean(self._r_oip_outputs[0, :, :, self._map_index]) print(self._r_oip_loss) print("shape of oip_loss = ", self._r_oip_loss.shape)

Note that the **loss definition** included in the code fragment is specific for a chosen map. This implies that we have to call this method every time we chose a different map for which we want to create OIP visualizations.

The advantage of the above code element is that "_tape()" can produce gradient values for the relation of the input data and loss data of a model automatically whenever we change the input image data. Gradient values can be called by

self._r_oip_grads = self._tape.gradient(self._r_oip_loss, self._r_cnn_inputs)

# Gradient ascent

As already discussed in my last article we apply a *gradient ascent* method to our "loss" function whose outcome *rises* with the activation of the neurons of a map. The following code sets up a method which first calls "_setup_gradient_tape()" and afterwards applies a normalization to the gradient values which "_tape()" produces. It then defines a convenience function and eventually calls a method which runs the optimization loop.

# # Method to derive OIP from a given initial input image # ******************** def _derive_OIP(self, map_index = 1, n_epochs = None, n_steps = 4, epsilon = 0.01, conv_criterion = 5.e-4, b_stop_with_convergence = False ): ''' V0.3, 31.08.2020 This method starts the process of producing an OIP of statistical input image data Requirements: An initial input image with statistical fluctuations of pixel values ------------- must have been created. Restrictions: This version only supports the most simple strategy - "strategy 0": ------------- Optimize in one loop - starting from a superposition of fluctuations No precursor, no intermediate evolution of input image data Input: ------ map_index: We can chose a map here (overwrites previous settings) n_epochs: Number of optimization steps (overwrites previous settings) n_steps: Defines number of intervals (with length n_epochs/ n_steps) for reporting This number also sets a requirement for providing n_step external axis-frames to display intermediate images of the emerging OIP => see _oip_strat_0_optimization_loop() epsilon: Size for corrections by gradient values conv_criterion: A small threshold number for (difference of loss-values / present loss value ) b_stop_with_convergence: Boolean which decides whether we stop a loop if the conv-criterion is fulfilled ''' self._map_index = map_index self._n_epochs = n_epochs self._n_steps = n_steps self._epsilon = epsilon # number of epochs for optimization strategy 0 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ if n_epochs == None: len_epochs = len(self._ay_epochs) self._n_epochs = self._ay_epochs[len_epochs-1] else: self._n_epochs = n_epochs # Rest some variables self._val_oip_grads = None self._val_oip_loss = None self._iterate = None # Setup the TF2 GradientTape watch # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self._setup_gradient_tape() print("GradientTape watch activated ") # Gradient handling - so far we only deal with addresses # ~~~~~~~~~~~~~~~~~~ self._r_oip_grads = self._tape.gradient(self._r_oip_loss, self._r_cnn_inputs) #print("shape of grads = ", self._r_oip_grads.shape) # normalization of the gradient self._r_oip_grads /= (B.sqrt(B.mean(B.square(self._r_oip_grads))) + 1.e-7) #grads = tf.image.per_image_standardization(grads) # define an abstract recallable Keras function # producing loss and gradients for corrected img data # the first list of addresses points to the input data, the last to the output data self._iterate = B.function( [self._r_cnn_inputs], [self._r_oip_loss, self._r_oip_grads] ) # get the initial image into a variable for optimization self._inp_img_data = None self._inp_img_data = self._initial_inp_img_data # Optimization loop for strategy 0 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ if self._oip_strategy == 0: self._oip_strat_0_optimization_loop( conv_criterion = conv_criterion, b_stop_with_convergence = b_stop_with_convergence )

Gradient value normalization is done here with respect to the L2-norm of the gradient. I.e., we adjust the length of the gradient to a unit length. Why does such a normalization help us with respect to convergence? You remember from a previous article series about MLPs that we had to care about a reasonable balance of an adaptive application of gradient values *and* a systematic reduction of the learning rate when approaching the global minimum of a cost function. The various available adaptive gradient methods care about speed and a proper deceleration of the steps by which we move across the cost hyperplane. When we approached a minimum we needed to care about overshooting. In our present gradient ascent case we have no such adaptive fine-tuning available. What we can do, however, is to control the length of the gradient vector such that changes remain of the same order as long as we do not change the step-size factor (epsilon). I.e.:

- We do not wildly accelerate our path on the loss hyperplane when some local pixel areas want to drive us into a certain direction.
- We reduce the chance of creating pixel values out of normal boundaries.

The last point fits well with a situation where the CNN has been trained on normalized or standardizes input images. Due to the normalization the size of pixel value corrections now depends significantly on the factor "epsilon". We should choose it small enough with respect to the pixel values.

Another interesting statement in the above code fragment is

self._iterate = B.function( [self._r_cnn_inputs], [self._r_oip_loss, self._r_oip_grads] )

Here we use the Keras Backend to define a convenience function which relates input data with dependent outputs, whose calculations we previously defined by suitable statements. The list which is used as the first parameter of this function "_iterate()" defines the input variables, the list used as a second parameter defines the output variables which will internally be calculated via the GradientTape-functionality defined before. The "_iterate()"-function makes it much easier for us to build the optimization loop.

# The optimization loop for the construction of images that visualize OIPs and features

The optimization loop must systematically correct the pixel values to approach a maximum of the loss function. The following method "_oip_strat_0_optimization_loop()" does this job for us. (The "0" in the method's name refers to a first simple approach.)

# # Method to optimize an emerging OIP out of statistical input image data # (simple strategy - just optimize, no precursor, no intermediate pattern evolution # ******************************** def _oip_strat_0_optimization_loop(self, conv_criterion = 5.e-4, b_stop_with_convergence = False ): ''' V 0.2, 28.08.2020 Purpose: This method controls the optimization loop for OIP reconstruction of an initial input image with a statistical distribution of pixel values. It also provides intermediate output in the form of printed data and images. Parameter: conv_criterion: A small threshold number for (difference of loss-values / present loss value ) b_stop_with_convergence: Booelan which decides whether we stop a loop if the conv-criterion is fulfilled This method produces some intermediate output during the optimization loop in form of images. It uses an external grid of plot frames and their axes-objects. The addresses of the axis-objects must provided by an external list "li_axa[]". We need a seqence of >= n_steps axis-frames length(li_axa) >= n_steps). With Jupyter the grid for plots can externally be provided by statements like # figure # ----------- #sizing fig_size = plt.rcParams["figure.figsize"] fig_size[0] = 16 fig_size[1] = 8 fig_a = plt.figure() axa_1 = fig_a.add_subplot(241) axa_2 = fig_a.add_subplot(242) axa_3 = fig_a.add_subplot(243) axa_4 = fig_a.add_subplot(244) axa_5 = fig_a.add_subplot(245) axa_6 = fig_a.add_subplot(246) axa_7 = fig_a.add_subplot(247) axa_8 = fig_a.add_subplot(248) li_axa = [axa_1, axa_2, axa_3, axa_4, axa_5, axa_6, axa_7, axa_8] ''' # Check that we really have an input image tensor if ( (self._inp_img_data == None) or (self._inp_img_data.shape[1] != self._img_dim) or (self._inp_img_data.shape[2] != self._img_dim) ) : print("There is no initial input image or it does not fit dimension requirements (28,28)") sys.exit() # Print some information print("*************\nStart of optimization loop\n*************") print("Strategy: Simple initial mixture of long and short range variations") print("Number of epochs = ", self._n_epochs) print("Epsilon = ", self._epsilon) print("*************") # some initial value loss_old = 0.0 # Preparation of intermediate reporting / img printing # -------------------------------------- # Number of intermediate reporting points during the loop steps = math.ceil(self._n_epochs / self._n_steps ) # Logarithmic spacing of steps (most things happen initially) n_el = math.floor(self._n_epochs / 2**(self._n_steps) ) li_int = [] for j in range(self._n_steps): li_int.append(n_el*2**j) print("li_int = ", li_int) # A counter for intermediate reporting n_rep = 0 # Array for intermediate image data li_imgs = np.zeros((self._img_dim, self._img_dim, 1), dtype=np.float32) # Convergence? - A list for steps meeting the convergence criterion # ~~~~~~~~~~~~ li_conv = [] # optimization loop # ******************* # A counter for steps with zero loss and gradient values n_zeros = 0 for j in range(self._n_epochs): # Get output values of our Keras iteration function # ~~~~~~~~~~~~~~~~~~~ self._val_oip_loss, self._val_oip_grads = self._iterate([self._inp_img_data]) # loss difference to last step - shuold steadily become smaller loss_diff = self._val_oip_loss - loss_old #print("loss_val = ", loss_val) #print("loss_diff = ", loss_diff) loss_old = self._val_oip_loss if j > 10 and (loss_diff/(self._val_oip_loss + 1.-7)) < conv_criterion: li_conv.append(j) lenc = len(li_conv) # print("conv - step = ", j) # stop only after the criterion has been met in 4 successive steps if b_stop_with_convergence and lenc > 5 and li_conv[-4] == j-4: return grads_val = self._val_oip_grads # the gradients average value avg_grads_val = (tf.reduce_mean(grads_val)).numpy() # Check if our map reacts at all # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ if self._val_oip_loss == 0.0 and avg_grads_val == 0.0: print( "0-values, j= ", j, " loss = ", self._val_oip_loss, " avg_loss = ", avg_grads_val ) n_zeros += 1 if n_zeros > 10: print("More than 10 times zero values - Try a different initial random distribution of pixel values") return # gradient ascent => Correction of the input image data # ~~~~~~~~~~~~~~~ self._inp_img_data += grads_val * self._epsilon # Standardize the corrected image - we won't get a convergence otherwise # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self._inp_img_data = tf.image.per_image_standardization(self._inp_img_data) # Some output at intermediate points # Note: We us logarithmic intervals because most changes # appear in the intial third of the loop's range if (j == 0) or (j in li_int) or (j == self._n_epochs-1) : # print some info print("\nstep " + str(j) + " finalized") #print("Shape of grads = ", grads_val.shape) print("present loss_val = ", self._val_oip_loss) print("loss_diff = ", loss_diff) # display the intermediate image data in an external grid imgn = self._inp_img_data[0,:,:,0].numpy() #print("Shape of intermediate img = ", imgn.shape) li_axa[n_rep].imshow(imgn, cmap=plt.cm.viridis) # counter n_rep += 1 return

The code is easy to understand: We use our convenience function "self._iterate()" to produce actual loss and gradient values within the loop. Then we change the pixel values of our input image and feed the changed image back into the loop. Note the positive sign of the correction! All complicated gradient calculations are automatically and "eagerly" done internally thanks to "GradientTape".

We said above that we limited the gradient values. How big is the size of the resulting corrections compared to the image data? If and when we use standardized image data and scale our gradient to unit length size then the relative size of the changes are of the order of the step size "epsilon" for the correction. In our case we set epsilon to 5.e-4.

The careful reader has noticed that I standardized the image data after the correction with the (normalized) gradient. Well, this step proved to be absolutely necessary to get convergence in the sense that we really approach an extremum of the cost function. Reasons are:

- My CNN was trained on standardized MNIST input images.
- We did not include any normalization layers into our CNN.
- Without counter-measures our normalized gradient values would eventually drive unlimited activation values.

The last point deserves some explanation:

We used the ReLU-function as the activation function of nodes in the inner layers of our CNN. For positive input values ReLU actually is a linear function. Now let us assume that we have found a rather optimal input pattern which via a succession of basically linear operations drives an activation pattern of a map's neurons. What happens if we just add constant small values to each pixel per iteration step? The output values after the sequence of linear transformations will just grow! With our method and the ReLU activation function we walk around a surface until we reach a linear ramp and climb it up. Without compensatory steps we will not find a real maximum because there is none. The situation is very different at the convolutional layers than at the eventual output layer of the CNN's MLP-part.

You may ask yourself why we experienced nothing of this during the classification training? First answer: We did not optimize input data but *weights* during the training. Second answer: During training we did NOT maximize potentially unbound activation values but minimized a cost function based on output values of the last a MLP-layer. And these values were produced by a sigmoid function! The sigmoid function limits any input to the range ]0, +1[. In addition, the cost function (categorial_crossentropy) is designed to be convex for deviations of limited calculated values from a limited target vector.

The consequence is that we have to limit the values of the (corrected) input data *and* the related gradients in our present optimization procedure at the same time! This is done by the standardization of the image data. Remember that the correction values are around of the relative order of 5.e-4. In the end this is the order of the fluctuations which are unavoidable in the final OIP image; but now we have a chance to converge to a related small region around a real maximum.

The last block in the code deals with intermediate output - not only printed data on the loss function but also in form of intermediate images of the hopefully emerging pattern. These images can be provided in an external grid of figures in e.g. a Jupyter environment. The important point is that we define a suitable number of Matplotlib's axis-objects and deliver their addresses via an external array "li_axa[]". I am well aware of that the plotting solution coded here is a very basic one and it requires some ahead planning of the user - feel free to program it in a better way.

# Initial input image data - with variations on different length scales

We lack just one further ingredient: We need a method to construct an input image with statistical data. I have discussed already that it may be helpful to vary data on different length scales. A very simple approach to tackle this problem manually is the following one:

We use squares - each with a different small and limited number of cells; e.g. a (4x4)-, a (7x7)-, a (14x14)- and (28x28)-square. Note that (28x28) is the original size of the MNIST images. For other samples we may need different sizes of such squares and more of them. We then fill the cells with random numbers between [-1, 1]. We smoothly scale the variations of the smaller squares up to the real input image size; here: (28x28). We can do this by applying a bicubic interpolation to the data. In the end we add up all random data and normalize or standardize the resulting distribution of pixel values. See the code below for details:

# # Method to build an initial image from a superposition of random data on different length scales # *********************************** def _build_initial_img_data( self, strategy = 0, li_epochs = (20, 50, 100, 400), li_facts = (0.5, 0.5, 0.5, 0.5), li_dim_steps = ( (3,3), (7,7), (14,14), (28,28) ), b_smoothing = False): ''' V0.2, 31.08.2020 Purpose: ~~~~~~~~ This method constructs an initial input image with a statistical distribution of pixel-values. We use 4 length scales to mix fluctuations with different "wave-length" by a simple approach: We fill four squares with a different number of cells below the number of pixels in each dimension of the real input image; e.g. (4x4), (7x7, (14x14), (28,28) <= (28,28). We fill the cells with random numbers in [-1.0, 1.]. We smootly scale the resulting pattern up to (28,28) (or what ever the input image dimensions are) by bicubic interpolations and eventually add up all values. As a final step we standardize the pixel value distribution. Limitations ~~~~~~~~~~~ This version works with 4 length scales. it only supports a simple strategy for evolving OIP patterns. ''' self._oip_strategy = strategy self._ay_facts = np.array(li_facts) self._ay_epochs = np.array(li_epochs) self._li_dim_steps = li_dim_steps fluct_data = None # Strategy 0: Simple superposition of random patterns at 4 different wave-length # ~~~~~~~~~~ if self._oip_strategy == 0: dim_1_1 = self._li_dim_steps[0][0] dim_1_2 = self._li_dim_steps[0][1] dim_2_1 = self._li_dim_steps[1][0] dim_2_2 = self._li_dim_steps[1][1] dim_3_1 = self._li_dim_steps[2][0] dim_3_2 = self._li_dim_steps[2][1] dim_4_1 = self._li_dim_steps[3][0] dim_4_2 = self._li_dim_steps[3][1] fact1 = self._ay_facts[0] fact2 = self._ay_facts[1] fact3 = self._ay_facts[2] fact4 = self._ay_facts[3] # print some parameter information # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ print("\nInitial image composition - strategy 0:\n Superposition of 4 different wavelength patterns") print("Parameters:\n", fact1, " => (" + str(dim_1_1) +", " + str(dim_1_2) + ") :: ", fact2, " => (" + str(dim_2_1) +", " + str(dim_2_2) + ") :: ", fact3, " => (" + str(dim_3_1) +", " + str(dim_3_2) + ") :: ", fact4, " => (" + str(dim_4_1) +", " + str(dim_4_2) + ")" ) # fluctuations fluct1 = 2.0 * ( np.random.random((1, dim_1_1, dim_1_2, 1)) - 0.5 ) fluct2 = 2.0 * ( np.random.random((1, dim_2_1, dim_2_2, 1)) - 0.5 ) fluct3 = 2.0 * ( np.random.random((1, dim_3_1, dim_3_2, 1)) - 0.5 ) fluct4 = 2.0 * ( np.random.random((1, dim_4_1, dim_4_2, 1)) - 0.5 ) # Scaling with bicubic interpolation to the required image size fluct1_scale = tf.image.resize(fluct1, [28,28], method="bicubic", antialias=True) fluct2_scale = tf.image.resize(fluct2, [28,28], method="bicubic", antialias=True) fluct3_scale = tf.image.resize(fluct3, [28,28], method="bicubic", antialias=True) fluct4_scale = fluct4 # superposition fluct_data = fact1*fluct1_scale + fact2*fluct2_scale + fact3*fluct3_scale + fact4*fluct4_scale # get the standardized plus smoothed and unsmoothed image # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # TF2 provides a function performing standardization of image data function fluct_data_unsmoothed = tf.image.per_image_standardization(fluct_data) fluct_data_smoothed = tf.image.per_image_standardization( tf.image.resize( fluct_data, [28,28], method="bicubic", antialias=True) ) if b_smoothing: self._initial_inp_img_data = fluct_data_smoothed else: self._initial_inp_img_data = fluct_data_unsmoothed # There should be no difference img_init_unsmoothed = fluct_data_unsmoothed[0,:,:,0].numpy() img_init_smoothed = fluct_data_smoothed[0,:,:,0].numpy() ax1_1.imshow(img_init_unsmoothed, cmap=plt.cm.viridis) ax1_2.imshow(img_init_smoothed, cmap=plt.cm.viridis) print("Initial images plotted") return self._initial_inp_img_data

The factors fact1, fact2 and fact3 determine the relative amplitudes of the fluctuations at the different length scales. Thus the user is e.g. able to suppress short-scale fluctuations completely.

I only took exactly four squares to simulate fluctuation on different length scales. A better code would make the number of squares and length scales parameterizable. Or it would work with a Fourier series right from the start. I was too lazy for such elaborated things. The plots again require the definition of some external Matplotlib figures with axis-objects. You can provide a suitable figure in a Jupyter cell.

# Conclusion

In this article we have build a simple class to *create* OIPs for a specific CNN map out of an input image with a random distribution of pixel values. The algorithm should have made it clear that this a *constructive* work performed during iteration:

- We start from the "detection" of slight traces of a pattern in the initial statistical pixel value distribution; the

pattern actually is a statistical pixel correlation which triggers the chosen map, - then we amplify the
*recognized*pattern elements - and suppress pixel values which are not relevant into a homogeneous background.

So the headline of this article is a bit misleading: **We do not only "detect" a map related OIP; we also "create" it.**

Our new Python class makes use of a given trained CNN-model and follows the outline of steps discussed in a previous article. The class has many limitations - in its present version it is only usable for MNIST images and the user has to know a lot about internals. However, I hope that my readers nevertheless have understood the basic ingredients. From there it is only a small step towards are more general and more capable version.

I have also underlined in this article that the images produced by the coded methods may only represent local maxima of the loss function for average map activation and idealized patterns composed of re-occuring elementary sub-structures. In the next article

A simple CNN for the MNIST dataset – IX – filter visualization at a convolutional layer

I am going to apply the code to most of the maps of the highest, i.e. inner-most convolutional layer of my trained CNN. We shall discover a whole zoo of simple and complex input image patterns. But we shall also confirm the suspicion that our optimization algorithm for finding an OIP for a specific map does *not* react to each and every kind of initial statistical pixel value fluctuation presented to the CNN.