Add a graph learning module

.travis.yml

@@ -20,9 +20,10 @@ addons:
     - ubuntu-toolchain-r-test
     - sourceline: 'deb http://downloads.skewed.de/apt/trusty trusty universe'
     packages:
+    - libqt5gui5  # pyqt5>5.11 otherwise cannot load the xcb platform plugin
+    - libflann-dev
     - python3-graph-tool
     - python-graph-tool
-    - libqt5gui5  # pyqt5>5.11 fails to load the xcb platform plugin without it
 
 install:
   - pip install --upgrade pip setuptools wheel  # install with latest tools

README.rst

@@ -39,6 +39,15 @@ A (mostly unmaintained) `Matlab version <https://epfl-lts2.github.io/gspbox-html
 .. |conda| image:: https://anaconda.org/conda-forge/pygsp/badges/installer/conda.svg
    :target: https://anaconda.org/conda-forge/pygsp
 
+
+The PyGSP is a Python package to ease
+`Signal Processing on Graphs <https://arxiv.org/abs/1211.0053>`_.
+The documentation is available on
+`Read the Docs <https://pygsp.readthedocs.io>`_
+and development takes place on
+`GitHub <https://github.com/epfl-lts2/pygsp>`_.
+A (mostly unmaintained) `Matlab version <https://epfl-lts2.github.io/gspbox-html>`_ exists.
+
 The PyGSP facilitates a wide variety of operations on graphs, like computing
 their Fourier basis, filtering or interpolating signals, plotting graphs,
 signals, and filters. Its core is spectral graph theory, and many of the

doc/history.rst

@@ -26,12 +26,17 @@ Unreleased
 * New implementation of the Sensor graph that is simpler and scales better.
 * A new learning module with three functions to solve standard semi-supervised
   classification and regression problems.
+* A much improved, fixed, documented, and tested NNGraph. The user can now
+  select the backend and similarity kernel. The radius can be estimated and
+  features standardized. (PR #43)
 * Import and export graphs and their signals to NetworkX and graph-tool.
 * Save and load graphs and theirs signals to / from GraphML, GML, and GEXF.
 * Documentation: path graph linked to DCT, ring graph linked to DFT.
 * We now have a gallery of examples! That is convenient for users to get a
   taste of what the library can do, and to start working from a code snippet.
 * Merged all the extra requirements in a single dev requirement.
+* A function to learn the graph from the signal has been added with doc and tests. 
+  This function can be used simply using the graph ``LearnGraph``
 
 Experimental filter API (to be tested and validated):
 

doc/references.bib

@@ -220,3 +220,20 @@ @article{grassi2018timevertex
   year={2018},
   journal={IEEE Transactions on Signal Processing},
 }
+
+@inproceedings{
+        kalofolias2018large,
+        title={Large Scale Graph Learning From Smooth Signals},
+        author={Vassilis Kalofolias and Nathanaël Perraudin},
+        booktitle={International Conference on Learning Representations},
+        year={2019},
+        url={https://openreview.net/forum?id=ryGkSo0qYm},
+        }
+
+@inproceedings{kalofolias2016learn,
+  title={How to learn a graph from smooth signals},
+  author={Kalofolias, Vassilis},
+  booktitle={Artificial Intelligence and Statistics},
+  pages={920--929},
+  year={2016}
+}

doc/tutorials/graph_learning.py

@@ -0,0 +1,139 @@
+import numpy as np
+import pygsp
+from matplotlib import pyplot as plt
+
+#%%
+n_signals = 4
+def f1(x, y): return (-np.sin((2-x-y)**2)/2 + np.cos(y*3))/2
+def f2(x, y): return np.cos((x+y)**2);
+def f3(x, y): return ((x-.5)**2 + (y-.5)**3 + x - y)*3;
+def f4(x, y): return np.sin(3*((x-.5)**2+(y-.5)**2));
+
+
+
+#%%
+n_nodes = 300
+coords = np.random.uniform(size=(n_nodes, 2))
+
+# the vectors of smooth signals will be stored as columns of X
+X = np.zeros((n_nodes, n_signals))
+for i, f in enumerate((f1, f2, f3, f4)):
+    X[:, i] = f(coords[:, 0], coords[:, 1])
+
+
+
+#%%
+plt.figure(figsize=(16, 10))
+for i, f in enumerate((f1, f2, f3, f4)):
+    plt.subplot(2, 2, i+1);
+    plt.scatter(coords[:, 0], coords[:, 1], 500, X[:, i], '.');
+    plt.title('smooth signal {}'.format(i+1));
+    plt.axis('off');
+    plt.colorbar();
+
+
+#%%
+
+k = 5
+param_opt = {'maxit':2000}
+
+G1 = pygsp.graphs.LearnedFromSmoothSignals(X[:, 0], coords=coords, k=k, param_opt=param_opt)
+G2 = pygsp.graphs.LearnedFromSmoothSignals(X[:, 1], coords=coords, k=k, param_opt=param_opt)
+G3 = pygsp.graphs.LearnedFromSmoothSignals(X[:, 2], coords=coords, k=k, param_opt=param_opt)
+G4 = pygsp.graphs.LearnedFromSmoothSignals(X[:, 3], coords=coords, k=k, param_opt=param_opt)
+
+#%%
+
+
+# G1.set_coordinates()
+plt.figure(figsize=(18, 16))
+for i, G in enumerate((G1, G2, G3, G4)):
+    _, _, weights = G.get_edge_list()
+    ax = plt.subplot(2, 2, i+1);
+    G.plot(vertex_size=50, edge_width=weights, ax=ax)
+    plt.xticks([])
+    plt.yticks([])
+    plt.title('n_vertices = {}, n_edges = {}, k = {:.1f}'.format(G.n_vertices, G.n_edges, G.n_edges * 2 / G.n_vertices))
+
+
+
+#%%
+
+G_all = pygsp.graphs.LearnedFromSmoothSignals(X, coords=coords, k=k, param_opt=param_opt)
+plt.figure(figsize=(8, 6))
+ax = plt.axes()
+G_all.plot(vertex_size=0, ax=ax)
+plt.xticks([]), plt.yticks([])
+plt.title('n_vertices = {}, n_edges = {}, k = {:.1f}'.format(G_all.n_vertices, G_all.n_edges, G_all.n_edges * 2 / G_all.n_vertices))
+
+
+
+#%%
+
+G_coords = pygsp.graphs.LearnedFromSmoothSignals(coords, coords=coords, k=k, param_opt=param_opt)
+plt.figure(figsize=(8, 6))
+ax = plt.axes()
+G_coords.plot(vertex_size=0, ax=ax, edges=True)
+
+
+
+
+#%%
+
+
+import scipy
+Z = scipy.spatial.distance_matrix(X, X)**2
+plt.imshow(Z)
+print(np.count_nonzero(Z))
+edge_mask = (Z < 1 / np.sqrt(n_nodes)).astype(np.int)
+np.fill_diagonal(edge_mask, 0)
+print(np.count_nonzero(edge_mask))
+edge_mask[:3,:3]
+
+
+
+#%%
+
+G_all = pygsp.graphs.LearnedFromSmoothSignals(X, coords=coords, k=k, 
+                                              param_opt=param_opt, 
+                                              sparse=True, edge_mask=edge_mask)
+plt.figure(figsize=(8, 6))
+ax = plt.axes()
+G_all.plot(vertex_size=0, ax=ax)
+plt.xticks([]), plt.yticks([])
+plt.title('n_vertices = {}, n_edges = {}, k = {:.1f}'.format(G_all.n_vertices, G_all.n_edges, G_all.n_edges * 2 / G_all.n_vertices))
+
+
+
+
+#%%
+
+
+
+
+
+
+#%%
+
+
+
+
+
+
+#%%
+
+
+
+
+
+
+#%%
+
+
+
+
+
+
+#%%
+
+

doc/tutorials/optimization.rst

@@ -85,7 +85,7 @@ We start with the graph TV regularization. We will use the :class:`pyunlocbox.so
     >>> prob1 = pyunlocbox.solvers.solve([d, r, f], solver=solver,
     ...                                  x0=x0, rtol=0, maxit=1000)
     Solution found after 1000 iterations:
-        objective function f(sol) = 2.250584e+02
+        objective function f(sol) = 2.256055e+02
         stopping criterion: MAXIT
     >>>
     >>> fig, ax = G.plot(prob1['sol'])
@@ -107,7 +107,7 @@ This figure shows the label signal recovered by graph total variation regulariza
     >>> prob2 = pyunlocbox.solvers.solve([r, f], solver=solver,
     ...                                  x0=x0, rtol=0, maxit=1000)
     Solution found after 1000 iterations:
-        objective function f(sol) = 6.504290e+01
+        objective function f(sol) = 4.376481e+01
         stopping criterion: MAXIT
     >>>
     >>> fig, ax = G.plot(prob2['sol'])

playground.ipynb

@@ -40,7 +40,7 @@
    "source": [
     "G = graphs.Logo()\n",
     "G.estimate_lmax()\n",
-    "g = filters.Heat(G, tau=100)"
+    "g = filters.Heat(G, scale=100)"
    ]
   },
   {
@@ -117,7 +117,25 @@
    ]
   }
  ],
- "metadata": {},
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.5"
+  }
+ },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }