Discrete Haar Wavelet Transform in 1D Using TensorFlow

The wavelet transform is a tool that cuts up data, functions, or operators into different frequency components, and then studies each component with a resolution matched to its scale. Among all the wavelets, the Haar wavelet is the simplest wavelet, and the Haar transform is an instance of a more general class of transforms known as "wavelet transforms."

Overview

The Haar wavelet is characterized by its simplicity and binary step function. Its structure is advantageous for image and signal processing, numerical analysis, and even in areas of data compression. Its primary strength lies in its ability to provide localized frequency information about a particular function or data set.

We will illustrate the 1D Discrete Haar Wavelet Transform in Python using TensorFlow, which is an end-to-end open-source platform for machine learning.

Python Implementation

Let's dive into our Python implementation of the Discrete Haar Wavelet Transform. We will construct two functions: haar1d_layer() and haar1d_inv_layer().

The first function haar1d_layer() will take a 1D array as input and apply the Haar wavelet transformation. The second function haar1d_inv_layer() will take the transformed array and invert the transformation.

Ensure that you have TensorFlow installed in your environment before proceeding. If not, install it using pip:

pip install numpy
pip install tensorflow

Now let's begin with our implementation:

def haar1d_layer(x):
    outputs = []
    len = x.shape[1]

    while len > 1:
        v_reshape = tf.reshape(x, [-1, len//2, 2])
        v_diff = v_reshape[:,:,1:2] - v_reshape[:,:,0:1]
        v_diff = tf.reshape(v_diff, [-1, len//2])
        outputs.append(v_diff)
        x = tf.reduce_mean(v_reshape, axis=2)
        len = len // 2

    outputs.append(x)
    return tf.concat(outputs, 1)

def haar1d_inv_layer(x):
    idx = 1
    len = x.shape[1]
    while idx < len:
        v_avg = x[:, -idx:]
        v_avg = tf.reshape(v_avg, [-1, idx, 1])
        v_delta = x[:, (len - (idx << 1)):(len - idx)] / 2
        v_delta = tf.stack([-v_delta, v_delta], axis=2) 
        v_out = v_avg + v_delta
        v_out = tf.reshape(v_out, [-1, idx*2])
        x = tf.concat([x[:, :-(idx << 1)], v_out], axis=1)
        idx = idx << 1
    return x

The haar1d_layer() function iterates over pairs of elements in the input vector, calculating the average and difference of each pair, and writes them into the output_vector. The haar1d_inv_layer() function does the opposite, taking the average and difference pairs from the input_vector, and calculating the original values before writing them into the output_vector.

The function stack() is used to convert the TensorArray to a Tensor.

Example Usage

Here's an example of using these functions:

v = tf.Variable([
    [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16],
    [16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1]
],dtype=tf.float32)

# Proceed transform
x = layers.Input(shape=(v.shape[1],))
y = haar1d_layer(x)
encoder = Model(x, y)
encoded = encoder.predict(v)
print(encoded)
# 1/1 [==============================] - 0s 58ms/step
#[[ 1.   1.   1.   1.   1.   1.   1.   1.   2.   2.   2.   2.   4.   4.   8.   8.5]
# [-1.  -1.  -1.  -1.  -1.  -1.  -1.  -1.  -2.  -2.  -2.  -2.  -4.  -4.  -8.   8.5]]

# Proceed invert transform
y = haar1d_inv_layer(x)
decoder = Model(x, y)
decoded = decoder.predict(encoded)
print(decoded)
#1/1 [==============================] - 0s 100ms/step
#[[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16.]
# [16. 15. 14. 13. 12. 11. 10.  9.  8.  7.  6.  5.  4.  3.  2.  1.]]

When run, you'll see the transformed vector and the result of inverting that transformed vector, which should be the same as the original input vector.

Conclusion

In this article, we have explored the Discrete Haar Wavelet Transform in 1D and its inversion, implemented using Python and TensorFlow. This implementation serves as a base to extend the functionality to 2D and 3D data, necessary for image and video processing.

As always, practice and exploration are the keys to learning and understanding. Feel free to modify the code and experiment with different inputs. Understanding how these transforms work is critical in areas such as signal processing, data compression, and even machine learning. With the advent of more complex and robust transforms, the humble Haar wavelet continues to serve as a stepping stone to understand the fascinating world of wavelets.

Have a goat day 🐐