Fri, 1 Sep 2017

The Graph Signal Processing toolbox GraSP can be found here, and here (both are GIT repositories with the same content).

Installation

Before being able to use the toolbox, several third party tools need to be downloaded and made available to Matlab. To do that, go to the grasp root folder and run the command:

grasp_install

Then setup Matlab path to make the GraSP toolbox available to Matlab:

grasp_start

You are know ready to use the toolbox.

Getting Started

First, we need a graph to perform graph signal processing on. You can use the provided functions in Graphs/ or any structure you have (we will come back to that later). For example, a random sampling in 2D square, with edges weighted by a Gaussian kernel of the Euclidean distance, is obtained using grasp_plane_rnd:

g = grasp_plane_rnd(100);

The structure g contains now several fields describing this graph. To show this graph, use the grasp_show_graph function:

grasp_show_graph(gca, g);

The first signal we use in this tutorial is a delta signal obtained by grasp_delta:

delta_1 = grasp_delta(g, 1);

We can show it on the previous figure using:

grasp_show_graph(gca, g, 'node_values', delta_1);

We observe in the command above a first way of giving optional parameters to functions in the toolbox, using pairs of name and value. The other way of achieving the same goal is through a Matlab structure:

options = { 'node_values', delta_1 };
grasp_show_graph(gca, g, options);

We will use the first form in this tutorial, but sometime the second form is more efficient.

The next step is to construct the graph Fourier transform. This is done by computing the eigendecomposition of a matrix, and performed by grasp_eigendecomposition:

g = grasp_eigendecomposition(g);

This completes the data structure g with the graph Fourier transform. To perform the GFT on the delta signal we defined, we can use the grasp_fourier function:

delta_1_hat = grasp_fourier(g, delta_1);

Components of delta_1_hat are the Fourier components of the signal delta_1 ordered by increasing frequency.

Now that the GFT is defined, we can compute a more complex signal using grasp_heat_kernel:

heat = grasp_heat_kernel(g);

This signal is a low pass signal. We can then convolve the two signals using:

conv_sig = grasp_convolution(heat, delta_1);

You can find more operators in the Operators/ folder.

Graphs

We saw in the previous section that we can build a graph using the function in the folder Graphs/. Another way is to construct the GraSP structure from the adjacency matrix of the graph. If A is the adjacency matrix, then we just have to do:

g = grasp_struct();
g.A = A;

Showing the graph g on a figure then involves the field layout of the structure g. This a two column array with as many rows as vertices in the graph. The first column corresponds to the horizontal coordinate, and the second to the vertical coordinate. Coordinates are between 0 and 10. If you have access to a meaningful layout, you can use it to compute g.layout. Otherwise, use grasp_layout to do this computation automatically:

g.layout = grasp_layout(g);

This function requires GraphViz to be installed on your computer.

Manipulating graphs

You will find several functions in Graphs/Tools to refine a graph, such as computing Gaussian weights (grasp_adjacency_gaussian), thresholding edges (grasp_adjacency_thresh) or performing KNN selection of edges (grasp_adjacency_knn).

Import/Export

You can export a graph structure (adjacency matrix and layout) in two CSV files (one for the vertices and one for the edges) for use outside matlab using the function grasp_exportcsv:

grasp_exportcsv(g, 'vertices.csv', 'edges.csv');

This structure can then be imported back into Matlab using grasp_importcsv, used in another software, or used with the LaTeX package provided with GraSP (commands displaying graphs and matrices).

If you have a CSV file with the adjacency matrix and a layout, you can also use grasp_importcsv to import the graph into GraSP.

Finally, GraSP provides function to convert structure from (grasp_from_gspbox) and to (grasp_to_gspbox) the toolbox GSPbox, making them compatible with one another.

Plotting Functions

We saw the most useful function grasp_show_graph in action earlier. This function has several parameters to control how the figure is rendered. We invite you to read its documentation and experiment. Two of interest are node_values seen earlier, and show_edges that should be set to false when the number of edges is high to speed up the function.

Based on this function, we have also grasp_show_fouriermodes displaying all (or some) Fourier modes on the same figure within several subaxes.

Next, we have grasp_show_matrix that improves upon the builtin function imshow and giving control over the color scale or the size of the pixels to plot a matrix.

We also have several functions to better control figures and axes. First, Matlab offers the possibility of having titles to figure that differ from the standard Figure x where x is an integer. We use that possibility and wrap everything nicely in grasp_open_figurename.

Also, to have better control over subaxes, compared to the builtin function subplot, we provide grasp_subaxis that controls margin between axes allowing for denser figures. The function grasp_subaxis_matrix_dimensions gives also the ideal number of rows and columns given a total number of figures to maximize the size of the subaxes. Typical usage of this functions is:

[nb_rows, nb_cols] = grasp_subaxis_matrix_dimensions(n)
...
grasp_subaxis(nb_rows, nb_cols, i);
...

In Util/, the function grasp_set_blue_red_colormap will switch the color scale to a blue - white - red one. This is especially useful when the color scale (color_scale of grasp_show_graph and grasp_show_matrix) is symmetric about 0 (from -x to +x) such that 0 is white. Color intensity correspond to how big the value is, and the actual color corresponds to negative or positive values.

Category: Graph Signal Processing Tagged: