convert compute_frame and localize to filter

Author: mdeff

pygsp/filters/abspline.py

@@ -34,7 +34,6 @@ class Abspline(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Abspline(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/expwin.py

@@ -27,7 +27,6 @@ class Expwin(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Expwin(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/filter.py

@@ -528,8 +528,9 @@ def localize(self, i, **kwargs):
 
         Examples
         --------
-        Visualize heat diffusion on a grid.
+        Visualize heat diffusion on a grid by localizing the heat kernel.
 
+        >>> import matplotlib
         >>> N = 20
         >>> G = graphs.Grid2d(N)
         >>> G.estimate_lmax()
@@ -540,7 +541,7 @@ def localize(self, i, **kwargs):
         """
         s = np.zeros(self.G.N)
         s[i] = 1
-        return np.sqrt(self.G.N) * self.analysis(s, **kwargs)
+        return np.sqrt(self.G.N) * self.filter(s, **kwargs)
 
     def approx(self, m, N):
         r"""
@@ -662,37 +663,31 @@ def compute_frame(self, **kwargs):
 
         Examples
         --------
-        >>>
-        >>> G = graphs.Logo()
+        Filtering signals as a matrix multiplication.
+
+        >>> G = graphs.Sensor(N=1000, seed=42)
         >>> G.estimate_lmax()
+        >>> f = filters.MexicanHat(G, Nf=6)
+        >>> s = np.random.uniform(size=G.N)
         >>>
-        >>> f = filters.MexicanHat(G)
         >>> frame = f.compute_frame()
-        >>> print('{} nodes, matrix is {} x {}'.format(G.N, *frame.shape))
-        1130 nodes, matrix is 1130 x 6780
-        >>>
-        >>> s = np.random.uniform(size=G.N)
-        >>> c1 = frame.T.dot(s)
-        >>> c2 = f.analysis(s)
+        >>> frame.shape
+        (1000, 1000, 6)
+        >>> frame = frame.reshape(G.N, -1).T
+        >>> s1 = np.dot(frame, s)
+        >>> s1 = s1.reshape(G.N, 1, -1)
         >>>
-        >>> np.linalg.norm(c1 - c2) < 1e-10
+        >>> s2 = f.filter(s)
+        >>> np.all((s1 - s2) < 1e-10)
         True
 
         """
-
-        N = self.G.N
-
-        if N > 2000:
+        if self.G.N > 2000:
             _logger.warning('Creating a big matrix, you can use other means.')
 
-        Ft = self.analysis(np.identity(N), **kwargs)
-        F = np.empty(Ft.T.shape)
-        tmpN = np.arange(N, dtype=int)
-
-        for i in range(self.Nf):
-            F[:, N * i + tmpN] = Ft[N * i + tmpN]
-
-        return F
+        # Filter one delta per vertex.
+        s = np.identity(self.G.N)
+        return self.filter(s, **kwargs)
 
     def can_dual(self):
         r"""

pygsp/filters/halfcosine.py

@@ -25,7 +25,6 @@ class HalfCosine(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.HalfCosine(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/heat.py

@@ -55,7 +55,6 @@ class Heat(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Heat(G, tau=[5, 10, 100])
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/held.py

@@ -39,7 +39,6 @@ class Held(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Held(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/itersine.py

@@ -30,7 +30,6 @@ class Itersine(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.HalfCosine(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/mexicanhat.py

@@ -49,7 +49,6 @@ class MexicanHat(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.MexicanHat(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/meyer.py

@@ -36,7 +36,6 @@ class Meyer(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Meyer(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/papadakis.py

@@ -35,7 +35,6 @@ class Papadakis(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Papadakis(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/regular.py

@@ -43,7 +43,6 @@ class Regular(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Regular(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/simoncelli.py

@@ -35,7 +35,6 @@ class Simoncelli(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.Simoncelli(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/filters/simpletight.py

@@ -36,7 +36,6 @@ class SimpleTight(Filter):
     >>> G.set_coordinates('line1D')
     >>> g = filters.SimpleTight(G)
     >>> s = g.localize(G.N // 2)
-    >>> s = utils.vec2mat(s, g.Nf)
     >>> fig, axes = plt.subplots(1, 2)
     >>> g.plot(ax=axes[0])
     >>> G.plot_signal(s, ax=axes[1])

pygsp/tests/test_filters.py

@@ -9,7 +9,7 @@
 
 import numpy as np
 
-from pygsp import graphs, filters
+from pygsp import graphs, filters, utils
 
 
 class TestCase(unittest.TestCase):
@@ -73,11 +73,13 @@ def _test_methods(self, f, tight):
                           self._signal, method='lanczos')
 
         if f.Nf < 10:
-            F = f.compute_frame(method='chebyshev')
-            c_frame = F.T.dot(self._signal)
+            F = f.compute_frame(method='chebyshev').reshape(self._G.N, -1)
+            c_frame = F.T.dot(self._signal).reshape(self._G.N, 1, -1)
+            c_cheby = utils.vec2mat(c_cheby, f.Nf).reshape((self._G.N, 1, -1))
             np.testing.assert_allclose(c_frame, c_cheby)
-            F = f.compute_frame(method='exact')
-            c_frame = F.T.dot(self._signal)
+            F = f.compute_frame(method='exact').reshape(self._G.N, -1)
+            c_frame = F.T.dot(self._signal).reshape(self._G.N, 1, -1)
+            c_exact = utils.vec2mat(c_exact, f.Nf).reshape((self._G.N, 1, -1))
             np.testing.assert_allclose(c_frame, c_exact)
 
         self._test_synthesis(f)
@@ -107,11 +109,11 @@ def test_localize(self):
         # Should be equal to a row / column of the filtering operator.
         gL = G.U.dot(np.diag(g.evaluate(G.e)[0]).dot(G.U.T))
         s2 = np.sqrt(G.N) * gL[NODE, :]
-        np.testing.assert_allclose(s1, s2)
+        np.testing.assert_allclose(s1.squeeze(), s2)
 
         # That is actually a row / column of the analysis operator.
         F = g.compute_frame(method='exact')
-        np.testing.assert_allclose(F, gL)
+        np.testing.assert_allclose(F.squeeze(), gL)
 
     def test_custom_filter(self):
         def kernel(x):