Separate the functions from three scripts for analyzing the entropy autoencoders

Author: Thierry Dumas

kodak_tensorflow/activating_eae.py

@@ -9,70 +9,12 @@
 import os
 import tensorflow as tf
 
-import eae.graph.constants as csts
+import eae.analysis
 import parsing.parsing
 import tools.tools as tls
 from eae.graph.EntropyAutoencoder import EntropyAutoencoder
 from eae.graph.IsolatedDecoder import IsolatedDecoder
 
-def activating_eae(isolated_decoder, h_in, w_in, bin_widths, idx_map, activation,
-                   path_to_restore, path_to_map_mean, path_to_crop):
-    """Activates one latent variable and deactivates the others.
-    
-    One latent variable is activated and the others
-    are deactivated. Then, the latent variable feature
-    maps are quantized. Finally, the quantized latent
-    variable feature maps are passed through the decoder
-    of the entropy autoencoder.
-    
-    Parameters
-    ----------
-    isolated_decoder : IsolatedDecoder
-        Decoder of the entropy autoencoder.
-    h_in : int
-        Height of the images returned by the
-        isolated decoder.
-    w_in : int
-        Width of the images returned by the
-        isolated decoder.
-    bin_widths : numpy.ndarray
-        1D array with data-type `numpy.float32`.
-        Quantization bin widths at the end of the
-        training.
-    idx_map : int
-        Index of the latent variable feature map
-        containing the activated latent variable.
-        Note that the activated latent variable is
-        at the position [1, 1] in this map.
-    activation : float
-        Activation value.
-    path_to_restore : str
-        Path to the model to be restored. The
-        path must end with ".ckpt".
-    path_to_map_mean : str
-        Path to the file in which the latent
-        variable feature map means are saved.
-        The path must end with ".npy".
-    path_to_crop : str
-        Path to the saved crop of the decoder
-        output. The path must end with ".png".
-    
-    """
-    map_mean = numpy.load(path_to_map_mean)
-    with tf.Session() as sess:
-        isolated_decoder.initialization(sess, path_to_restore)
-        y_float32 = numpy.tile(numpy.reshape(map_mean, (1, 1, 1, csts.NB_MAPS_3)),
-                               (1, h_in//csts.STRIDE_PROD, w_in//csts.STRIDE_PROD, 1))
-        y_float32[0, 1, 1, idx_map] = activation
-        quantized_y_float32 = tls.quantize_per_map(y_float32, bin_widths)
-        reconstruction_float32 = sess.run(
-            isolated_decoder.node_reconstruction,
-            feed_dict={isolated_decoder.node_quantized_y:quantized_y_float32}
-        )
-        reconstruction_uint8 = numpy.squeeze(tls.cast_bt601(reconstruction_float32), axis=(0, 3))
-        tls.save_image(path_to_crop,
-                       reconstruction_uint8[0:64, 0:64])
-
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Analyzes a trained entropy autoencoder by activating one latent variable and deactivating the others.')
     parser.add_argument('bin_width_init',
@@ -88,12 +30,12 @@ def activating_eae(isolated_decoder, h_in, w_in, bin_widths, idx_map, activation
                         help='if given, the quantization bin widths were learned at training time',
                         action='store_true',
                         default=False)
-    parser.add_argument('--idx_map',
+    parser.add_argument('--idx_map_activation',
                         help='index of the latent variable feature map containing the activated latent variable',
                         type=parsing.parsing.int_positive,
                         default=49,
                         metavar='')
-    parser.add_argument('--activation',
+    parser.add_argument('--activation_value',
                         help='activation value',
                         type=float,
                         default=8.,
@@ -118,7 +60,8 @@ def activating_eae(isolated_decoder, h_in, w_in, bin_widths, idx_map, activation
     if not os.path.isdir(path_to_directory_crop):
         os.makedirs(path_to_directory_crop)
     path_to_crop = os.path.join(path_to_directory_crop,
-                                'activating_map_{0}_{1}.png'.format(args.idx_map + 1, tls.float_to_str(args.activation)))
+                                'activating_map_{0}_{1}.png'.format(args.idx_map_activation + 1, tls.float_to_str(args.activation_value)))
+    map_mean = numpy.load(path_to_map_mean)
 
     # A single entropy autoencoder is created.
     entropy_ae = EntropyAutoencoder(1,
@@ -140,14 +83,20 @@ def activating_eae(isolated_decoder, h_in, w_in, bin_widths, idx_map, activation
                                        h_in,
                                        w_in,
                                        args.learn_bin_widths)
-    activating_eae(isolated_decoder,
-                   h_in,
-                   w_in,
-                   bin_widths,
-                   args.idx_map,
-                   args.activation,
-                   path_to_restore,
-                   path_to_map_mean,
-                   path_to_crop)
+    with tf.Session() as sess:
+        isolated_decoder.initialization(sess, path_to_restore)
+        eae.analysis.activate_latent_variable(sess,
+                                              isolated_decoder,
+                                              h_in,
+                                              w_in,
+                                              bin_widths,
+                                              1,
+                                              1,
+                                              args.idx_map_activation,
+                                              args.activation_value,
+                                              map_mean,
+                                              64,
+                                              64,
+                                              path_to_crop)
 
 

kodak_tensorflow/eae/analysis.py

@@ -0,0 +1,236 @@
+"""A library that contains functions for analyzing the trained entropy autoencoders."""
+
+import matplotlib
+try:
+    import PyQt5
+    matplotlib.use('Qt5Agg')
+except ImportError:
+    matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import numpy
+import os
+import scipy.stats
+
+import eae.graph.constants as csts
+import tools.tools as tls
+
+def activate_latent_variable(sess, isolated_decoder, h_in, w_in, bin_widths, row_activation, col_activation,
+                             idx_map_activation, activation_value, map_mean, height_crop, width_crop, path_to_crop):
+    """Activates one latent variable and deactivates the others.
+    
+    One latent variable is activated and the others
+    are deactivated. Then, the latent variable feature
+    maps are quantized. Finally, the quantized latent
+    variable feature maps are passed through the decoder
+    of the entropy autoencoder.
+    
+    Parameters
+    ----------
+    sess : Session
+        Session that runs the graph.
+    isolated_decoder : IsolatedDecoder
+        Decoder of the entropy autoencoder. The graph
+        of the decoder is built to process one example
+        at a time.
+    h_in : int
+        Height of the images returned by the
+        isolated decoder.
+    w_in : int
+        Width of the images returned by the
+        isolated decoder.
+    bin_widths : numpy.ndarray
+        1D array with data-type `numpy.float32`.
+        Quantization bin widths at the end of the
+        training.
+    row_activation : int
+        Row of the activated latent variable in the
+        latent variable feature map of index `idx_map_activation`.
+    col_activation : int
+        Column of the activated latent variable in the
+        latent variable feature map of index `idx_map_activation`.
+    idx_map_activation : int
+        Index of the latent variable feature map
+        containing the activated latent variable.
+    activation_value : float
+        Activation value.
+    map_mean : numpy.ndarray
+        1D array with data-type `numpy.float32`.
+        Latent variable feature map means.
+    height_crop : int
+        Height of the crop of the decoder output.
+    width_crop : int
+        Width of the crop of the decoder output.
+    path_to_crop : str
+        Path to the saved crop of the decoder
+        output. The path ends with ".png".
+    
+    """
+    y_float32 = numpy.tile(numpy.reshape(map_mean, (1, 1, 1, csts.NB_MAPS_3)),
+                           (1, h_in//csts.STRIDE_PROD, w_in//csts.STRIDE_PROD, 1))
+    y_float32[0, row_activation, col_activation, idx_map_activation] = activation_value
+    quantized_y_float32 = tls.quantize_per_map(y_float32, bin_widths)
+    reconstruction_float32 = sess.run(
+        isolated_decoder.node_reconstruction,
+        feed_dict={isolated_decoder.node_quantized_y:quantized_y_float32}
+    )
+    reconstruction_uint8 = numpy.squeeze(tls.cast_bt601(reconstruction_float32), axis=(0, 3))
+    tls.save_image(path_to_crop,
+                   reconstruction_uint8[0:height_crop, 0:width_crop])
+
+def fit_maps(y_float32, idx_map_exception, path_to_histogram_locations, path_to_histogram_scales, paths):
+    """Fits a Laplace density to the normed histogram of each latent variable feature map.
+    
+    Parameters
+    ----------
+    y_float32 : numpy.ndarray
+        4D array with data-type `numpy.float32`.
+        Latent variables. `y_float32[i, :, :, j]`
+        is the jth latent variable feature map of
+        the ith example.
+    idx_map_exception : int
+        Index of the latent variable feature map
+        that is not compressed as the other maps.
+    path_to_histogram_locations : str
+        Path to the histogram of the Laplace locations. The
+        path ends with ".png".
+    path_to_histogram_scales : str
+        Path to the histogram of the Laplace scales. The
+        path ends with ".png".
+    paths : list
+        `paths[i]` is the path to the fitted normed histogram
+        for the ith latent variable feature map. Each path ends
+        with ".png".
+    
+    Raises
+    ------
+    ValueError
+        If `len(paths)` is not equal to `y_float32.shape[3]`.
+    
+    """
+    if len(paths) != y_float32.shape[3]:
+        raise ValueError('`len(paths)` is not equal to `y_float32.shape[3]`.')
+    locations = []
+    scales = []
+    for i in range(y_float32.shape[3]):
+        map_float32 = y_float32[:, :, :, i]
+        edge_left = numpy.floor(numpy.amin(map_float32)).item()
+        edge_right = numpy.ceil(numpy.amax(map_float32)).item()
+        
+        # The grid below contains 50 points
+        # per unit interval.
+        grid = numpy.linspace(edge_left,
+                              edge_right,
+                              num=50*int(edge_right - edge_left) + 1)
+        
+        # Let's assume that `map_float32` contains i.i.d samples
+        # from an unknown probability density function. The two
+        # equations below result from the minimization of the
+        # Kullback-Lieber divergence of the unknown probability
+        # density function from our statistical model (Laplace
+        # density of location `laplace_location` and scale
+        # `laplace_scale`). Note that this minimization is
+        # equivalent to the maximum likelihood estimator.
+        # To dive into the details, see:
+        # "Estimating distributions and densities". 36-402,
+        # advanced data analysis, CMU, 27 January 2011.
+        laplace_location = numpy.mean(map_float32).item()
+        laplace_scale = numpy.mean(numpy.absolute(map_float32 - laplace_location)).item()
+        laplace_pdf = scipy.stats.laplace.pdf(grid,
+                                              loc=laplace_location,
+                                              scale=laplace_scale)
+        handle = [plt.plot(grid, laplace_pdf, color='red')[0]]
+        hist, bin_edges = numpy.histogram(map_float32,
+                                          bins=60,
+                                          density=True)
+        plt.bar(bin_edges[0:60],
+                hist,
+                width=bin_edges[1] - bin_edges[0],
+                align='edge',
+                color='blue')
+        plt.title('Latent variable feature map {}'.format(i + 1))
+        plt.legend(handle,
+                   [r'$f( . ; {0}, {1})$'.format(str(round(laplace_location, 2)), str(round(laplace_scale, 2)))],
+                   prop={'size': 30},
+                   loc=9)
+        plt.savefig(paths[i])
+        plt.clf()
+        if i != idx_map_exception:
+            locations.append(laplace_location)
+            scales.append(laplace_scale)
+    
+    # `nb_kept` must be equal to `y_float32.shape[3] - 1`.
+    nb_kept = len(locations)
+    tls.histogram(numpy.array(locations),
+                  'Histogram of {} locations'.format(nb_kept),
+                  path_to_histogram_locations)
+    tls.histogram(numpy.array(scales),
+                  'Histogram of {} scales'.format(nb_kept),
+                  path_to_histogram_scales)
+
+def mask_maps(y_float32, sess, isolated_decoder, bin_widths, idx_unmasked_map, map_mean, height_crop, width_crop, paths):
+    """Masks all the latent variable feature maps except one.
+    
+    All the latent variable feature maps except one
+    are masked. Then, the latent variable feature maps
+    are quantized. Finally, the quantized latent
+    variable feature maps are passed through the
+    decoder of the entropy autoencoder.
+    
+    Parameters
+    ----------
+    y_float32 : numpy.ndarray
+        4D array with data-type `numpy.float32`.
+        Latent variables. `y_float32[i, :, :, j]`
+        is the jth latent variable feature map of
+        the ith example.
+    sess : Session
+        Session that runs the graph.
+    isolated_decoder : IsolatedDecoder
+        Decoder of the entropy autoencoder. The graph
+        of the decoder is built to process one example
+        at a time.
+    bin_widths : numpy.ndarray
+        1D array with data-type `numpy.float32`.
+        Quantization bin widths at the end of the
+        training.
+    idx_unmasked_map : int
+        Index of the unmasked latent variable
+        feature map.
+    map_mean : numpy.ndarray
+        1D array with data-type `numpy.float32`.
+        Latent variable feature map means.
+    height_crop : int
+        Height of the crop of the decoder output.
+    width_crop : int
+        Width of the crop of the decoder output.
+    paths : list
+        The ith string in this list is the path
+        to the ith saved crop of the decoder output.
+        Each path ends with ".png".
+    
+    Raises
+    ------
+    ValueError
+        If `len(paths)` is not equal to `y_float32.shape[0]`.
+    
+    """
+    if len(paths) != y_float32.shape[0]:
+        raise ValueError('`len(paths)` is not equal to `y_float32.shape[0]`.')
+        
+    # The same latent variable feature map is
+    # iteratively overwritten in the loop below.
+    masked_y_float32 = numpy.tile(numpy.reshape(map_mean, (1, 1, 1, y_float32.shape[3])),
+                                  (1, y_float32.shape[1], y_float32.shape[2], 1))
+    for i in range(y_float32.shape[0]):
+        masked_y_float32[0, :, :, idx_unmasked_map] = y_float32[i, :, :, idx_unmasked_map]
+        quantized_y_float32 = tls.quantize_per_map(masked_y_float32, bin_widths)
+        reconstruction_float32 = sess.run(
+            isolated_decoder.node_reconstruction,
+            feed_dict={isolated_decoder.node_quantized_y:quantized_y_float32}
+        )
+        reconstruction_uint8 = numpy.squeeze(tls.cast_bt601(reconstruction_float32),
+                                             axis=(0, 3))
+        tls.save_image(paths[i],
+                       reconstruction_uint8[0:height_crop, 0:width_crop])
+
+