sparse-convolution 0.1.1__tar.gz

sparse_convolution-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 RichieHakim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sparse_convolution-0.1.1/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt

sparse_convolution-0.1.1/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: sparse_convolution
+Version: 0.1.1
+Summary: Sparse convolution in python using Toeplitz convolution matrix multiplication.
+Home-page: https://github.com/RichieHakim/sparse_convolution
+Author: Richard Hakim
+Author-email: richhakim@gmail.com
+License: MIT
+Keywords: sparse convolution Toeplitz python
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy
+Requires-Dist: numpy
+
+# sparse_convolution
+Sparse convolution in python. \
+Uses Toeplitz convolutional matrix multiplication to perform sparse convolution. \
+This allows for extremely fast convolution when: 
+- The kernel is small (<= 30x30)
+- The input array is sparse (<= 1% density)
+- Many arrays are convolved with the same kernel
+
+## Install: 
+`git clone https://github.com/RichieHakim/sparse_convolution` \
+`cd sparse_convolution` \
+`pip install -e .` 
+
+
+## Basic usage: 
+Convolve a single sparse 2D array with a 2D kernel.
+```
+import sparse_convolution as sc
+import numpy as np
+import scipy.sparse
+
+# Create a single sparse matrix
+A = scipy.sparse.rand(100, 100, density=0.1)
+
+# Create a dense kernel
+B = np.random.rand(3, 3)
+
+# Prepare class
+conv = Toeplitz_convolution2d(
+    x_shape=A.shape,
+    k=B,
+    mode='same',
+    dtype=np.float32,
+)
+
+# Convolve
+C = conv(
+    x=A,
+    batching=False,
+    mode='same',
+).toarray()
+```
+
+
+## Batching usage: 
+Convolve multiple sparse 2D arrays with a 2D kernel. \
+The input arrays must be reshaped into flattened vectors and stacked into a single sparse array of shape: `(n_arrays, height * width)`. 
+```
+import sparse_convolution as sc
+import numpy as np
+import scipy.sparse
+
+# Create multiple sparse matrices
+# note that the shape of A will be (3, 100**2)
+A = scipy.sparse.vstack([
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+]).tocsr()
+
+# Create a dense kernel
+B = np.random.rand(3, 3)
+
+# Prepare class
+conv = sc.Toeplitz_convolution2d(
+    x_shape=(100, 100),  # note that the input shape here is (100, 100)
+    k=B,
+    mode='same',
+    dtype=np.float32,
+)
+
+# Convolve
+C = conv(
+    x=A,
+    batching=True,
+    mode='same',
+)
+
+# Reshape the output back to (3, 100, 100)
+C_reshaped = np.stack([c.reshape(100, 100).toarray() for c in C], axis=0)
+```
+
+## References
+- See: https://stackoverflow.com/a/51865516 and https://github.com/alisaaalehi/convolution_as_multiplication
+    for a nice illustration.
+- See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.convolution_matrix.html 
+    for 1D version.
+- See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.matmul_toeplitz.html#scipy.linalg.matmul_toeplitz 
+    for potential ways to make this implementation faster.
+

sparse_convolution-0.1.1/README.md

@@ -0,0 +1,90 @@
+# sparse_convolution
+Sparse convolution in python. \
+Uses Toeplitz convolutional matrix multiplication to perform sparse convolution. \
+This allows for extremely fast convolution when: 
+- The kernel is small (<= 30x30)
+- The input array is sparse (<= 1% density)
+- Many arrays are convolved with the same kernel
+
+## Install: 
+`git clone https://github.com/RichieHakim/sparse_convolution` \
+`cd sparse_convolution` \
+`pip install -e .` 
+
+
+## Basic usage: 
+Convolve a single sparse 2D array with a 2D kernel.
+```
+import sparse_convolution as sc
+import numpy as np
+import scipy.sparse
+
+# Create a single sparse matrix
+A = scipy.sparse.rand(100, 100, density=0.1)
+
+# Create a dense kernel
+B = np.random.rand(3, 3)
+
+# Prepare class
+conv = Toeplitz_convolution2d(
+    x_shape=A.shape,
+    k=B,
+    mode='same',
+    dtype=np.float32,
+)
+
+# Convolve
+C = conv(
+    x=A,
+    batching=False,
+    mode='same',
+).toarray()
+```
+
+
+## Batching usage: 
+Convolve multiple sparse 2D arrays with a 2D kernel. \
+The input arrays must be reshaped into flattened vectors and stacked into a single sparse array of shape: `(n_arrays, height * width)`. 
+```
+import sparse_convolution as sc
+import numpy as np
+import scipy.sparse
+
+# Create multiple sparse matrices
+# note that the shape of A will be (3, 100**2)
+A = scipy.sparse.vstack([
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+]).tocsr()
+
+# Create a dense kernel
+B = np.random.rand(3, 3)
+
+# Prepare class
+conv = sc.Toeplitz_convolution2d(
+    x_shape=(100, 100),  # note that the input shape here is (100, 100)
+    k=B,
+    mode='same',
+    dtype=np.float32,
+)
+
+# Convolve
+C = conv(
+    x=A,
+    batching=True,
+    mode='same',
+)
+
+# Reshape the output back to (3, 100, 100)
+C_reshaped = np.stack([c.reshape(100, 100).toarray() for c in C], axis=0)
+```
+
+## References
+- See: https://stackoverflow.com/a/51865516 and https://github.com/alisaaalehi/convolution_as_multiplication
+    for a nice illustration.
+- See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.convolution_matrix.html 
+    for 1D version.
+- See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.matmul_toeplitz.html#scipy.linalg.matmul_toeplitz 
+    for potential ways to make this implementation faster.
+

sparse_convolution-0.1.1/requirements.txt

@@ -0,0 +1,2 @@
+scipy
+numpy

sparse_convolution-0.1.1/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description_file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

sparse_convolution-0.1.1/setup.py

@@ -0,0 +1,118 @@
+## setup.py file for roicat
+from pathlib import Path
+
+from distutils.core import setup
+
+## Get the parent directory of this file
+dir_parent = Path(__file__).parent
+
+## Get requirements from requirements.txt
+def read_requirements():
+    with open(str(dir_parent / "requirements.txt"), "r") as req:
+        content = req.read()  ## read the file
+        requirements = content.split("\n") ## make a list of requirements split by (\n) which is the new line character
+
+    ## Filter out any empty strings from the list
+    requirements = [req for req in requirements if req]
+    ## Filter out any lines starting with #
+    requirements = [req for req in requirements if not req.startswith("#")]
+    ## Remove any commas, quotation marks, and spaces from each requirement
+    requirements = [req.replace(",", "").replace("\"", "").replace("\'", "").strip() for req in requirements]
+
+    return requirements
+deps_all = read_requirements()
+
+
+## Dependencies: latest versions of requirements
+### remove everything starting and after the first =,>,<,! sign
+deps_names = [req.split('=')[0].split('>')[0].split('<')[0].split('!')[0] for req in deps_all]
+deps_all_dict = dict(zip(deps_names, deps_all))
+deps_all_latest = dict(zip(deps_names, deps_names))
+
+
+## Get README.md
+with open(str(dir_parent / "README.md"), "r") as f:
+    readme = f.read()
+
+## Get version number
+with open(str(dir_parent / "sparse_convolution" / "__init__.py"), "r") as f:
+    for line in f:
+        if line.startswith("__version__"):
+            version = line.split("=")[1].strip().replace("\"", "").replace("\'", "")
+            break
+
+
+
+setup(
+    name='sparse_convolution',
+    version=version,
+
+    description='Sparse convolution in python using Toeplitz convolution matrix multiplication.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+
+    # The project's main homepage.
+    url='https://github.com/RichieHakim/sparse_convolution',
+
+    # Author details
+    author='Richard Hakim',
+    author_email='richhakim@gmail.com',
+
+    # Choose your license
+    license='MIT',
+
+    # Supported platforms
+    platforms=['Any'],
+
+    # See https://pypi.python.org/pypi?%3Aaction=list_classifiers
+    classifiers=[
+        # How mature is this project? Common values are
+        #   3 - Alpha
+        #   4 - Beta
+        #   5 - Production/Stable
+        'Development Status :: 5 - Production/Stable',
+
+        # Indicate who your project is intended for
+        'Intended Audience :: Science/Research',
+        'Topic :: Scientific/Engineering :: Bio-Informatics',
+
+        # Pick your license as you wish (should match "license" above)
+        # 'License :: OSI Approved :: MIT License',
+
+        # Specify the Python versions you support here. In particular, ensure
+        # that you indicate whether you support Python 2, Python 3 or both.
+        # 'Programming Language :: Python :: 2',
+        # 'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        # 'Programming Language :: Python :: 3.6',
+        # 'Programming Language :: Python :: 3.7'
+    ],
+
+    # What does your project relate to?
+    keywords='sparse convolution Toeplitz python',
+
+    # You can just specify the packages manually here if your project is
+    # simple. Or you can use find_packages().
+    packages=['sparse_convolution'],
+
+    # Alternatively, if you want to distribute just a my_module.py, uncomment
+    # this:
+    #   py_modules=["my_module"],
+
+    # List run-time dependencies here.  These will be installed by pip when
+    # your project is installed. For an analysis of "install_requires" vs pip's
+    # requirements files see:
+    # https://packaging.python.org/en/latest/requirements.html
+    install_requires=list(deps_all_dict.values()),
+
+    include_package_data=True,
+)
+
+
+
+
+
+
+
+
+

sparse_convolution-0.1.1/sparse_convolution/__init__.py

@@ -0,0 +1,3 @@
+from sparse_convolution.sparse_convolution import Toeplitz_convolution2d
+
+__version__ = '0.1.1'

sparse_convolution-0.1.1/sparse_convolution/sparse_convolution.py

@@ -0,0 +1,172 @@
+import scipy.sparse
+import numpy as np
+
+class Toeplitz_convolution2d:
+    """
+    Convolve a 2D array with a 2D kernel using the Toeplitz matrix 
+     multiplication method.
+    Allows for SPARSE 'x' inputs. 'k' should remain dense.
+    Ideal when 'x' is very sparse (density<0.01), 'x' is small
+     (shape <(1000,1000)), 'k' is small (shape <(100,100)), and
+     the batch size is large (e.g. 1000+).
+    Generally faster than scipy.signal.convolve2d when convolving mutliple
+     arrays with the same kernel. Maintains low memory footprint by
+     storing the toeplitz matrix as a sparse matrix.
+
+    See: https://stackoverflow.com/a/51865516 and https://github.com/alisaaalehi/convolution_as_multiplication
+     for a nice illustration.
+    See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.convolution_matrix.html 
+     for 1D version.
+    See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.matmul_toeplitz.html#scipy.linalg.matmul_toeplitz 
+     for potential ways to make this implementation faster.
+
+    Test with: tests.test_toeplitz_convolution2d()
+    RH 2022
+    """
+    def __init__(
+        self,
+        x_shape,
+        k,
+        mode='same',
+        dtype=None,
+    ):
+        """
+        Initialize the convolution object.
+        Makes the Toeplitz matrix and stores it.
+
+        Args:
+            x_shape (tuple):
+                The shape of the 2D array to be convolved.
+            k (np.ndarray):
+                2D kernel to convolve with
+            mode (str):
+                'full', 'same' or 'valid'
+                see scipy.signal.convolve2d for details
+            dtype (np.dtype):
+                The data type to use for the Toeplitz matrix.
+                Ideally, this matches the data type of the input array.
+                If None, then the data type of the kernel is used.
+        """
+        self.k = k = np.flipud(k.copy())
+        self.mode = mode
+        self.x_shape = x_shape
+        self.dtype = k.dtype if dtype is None else dtype
+
+        if mode == 'valid':
+            assert x_shape[0] >= k.shape[0] and x_shape[1] >= k.shape[1], "x must be larger than k in both dimensions for mode='valid'"
+
+        self.so = so = size_output_array = ( (k.shape[0] + x_shape[0] -1), (k.shape[1] + x_shape[1] -1))  ## 'size out' is the size of the output array
+
+        ## make the toeplitz matrices
+        t = toeplitz_matrices = [scipy.sparse.diags(
+            diagonals=np.ones((k.shape[1], x_shape[1]), dtype=self.dtype) * k_i[::-1][:,None], 
+            offsets=np.arange(-k.shape[1]+1, 1), 
+            shape=(so[1], x_shape[1]),
+            dtype=self.dtype,
+        ) for k_i in k[::-1]]  ## make the toeplitz matrices for the rows of the kernel
+        tc = toeplitz_concatenated = scipy.sparse.vstack(t + [scipy.sparse.dia_matrix((t[0].shape), dtype=self.dtype)]*(x_shape[0]-1))  ## add empty matrices to the bottom of the block due to padding, then concatenate
+
+        ## make the double block toeplitz matrix
+        self.dt = double_toeplitz = scipy.sparse.hstack([self._roll_sparse(
+            x=tc, 
+            shift=(ii>0)*ii*(so[1])  ## shift the blocks by the size of the output array
+        ) for ii in range(x_shape[0])]).tocsr()
+    
+    def __call__(
+        self,
+        x,
+        batching=True,
+        mode=None,
+    ):
+        """
+        Convolve the input array with the kernel.
+
+        Args:
+            x (np.ndarray or scipy.sparse.csc_matrix or scipy.sparse.csr_matrix):
+                Input array(s) (i.e. image(s)) to convolve with the kernel
+                If batching==False: Single 2D array to convolve with the kernel.
+                    shape: (self.x_shape[0], self.x_shape[1])
+                    type: np.ndarray or scipy.sparse.csc_matrix or scipy.sparse.csr_matrix
+                If batching==True: Multiple 2D arrays that have been flattened
+                 into row vectors (with order='C').
+                    shape: (n_arrays, self.x_shape[0]*self.x_shape[1])
+                    type: np.ndarray or scipy.sparse.csc_matrix or scipy.sparse.csr_matrix
+            batching (bool):
+                If False, x is a single 2D array.
+                If True, x is a 2D array where each row is a flattened 2D array.
+            mode (str):
+                'full', 'same' or 'valid'
+                see scipy.signal.convolve2d for details
+                Overrides the mode set in __init__.
+
+        Returns:
+            out (np.ndarray or scipy.sparse.csr_matrix):
+                If batching==True: Multiple convolved 2D arrays that have been flattened
+                 into row vectors (with order='C').
+                    shape: (n_arrays, height*width)
+                    type: np.ndarray or scipy.sparse.csc_matrix
+                If batching==False: Single convolved 2D array of shape (height, width)
+        """
+        # if batching:
+        #     if x.shape[0] > 9999:
+        #         print("RH WARNING: scipy.sparse.lil_matrix doesn't seem to work well with arrays with large numbers of rows. Consider breaking your job into smaller batches.")
+        if mode is None:
+            mode = self.mode  ## use the mode that was set in the init if not specified
+        issparse = scipy.sparse.issparse(x)
+        
+        if batching:
+            x_v = x.T  ## transpose into column vectors
+        else:
+            x_v = x.reshape(-1, 1)  ## reshape 2D array into a column vector
+        
+        if issparse:
+            x_v = x_v.tocsc()
+        
+        out_v = self.dt @ x_v  ## if sparse, then 'out_v' will be a csc matrix
+            
+        ## crop the output to the correct size
+        if mode == 'full':
+            p_t = 0
+            p_b = self.so[0]+1
+            p_l = 0
+            p_r = self.so[1]+1
+        if mode == 'same':
+            p_t = (self.k.shape[0]-1)//2
+            p_b = -(self.k.shape[0]-1)//2
+            p_l = (self.k.shape[1]-1)//2
+            p_r = -(self.k.shape[1]-1)//2
+
+            p_b = self.x_shape[0]+1 if p_b==0 else p_b
+            p_r = self.x_shape[1]+1 if p_r==0 else p_r
+        if mode == 'valid':
+            p_t = (self.k.shape[0]-1)
+            p_b = -(self.k.shape[0]-1)
+            p_l = (self.k.shape[1]-1)
+            p_r = -(self.k.shape[1]-1)
+
+            p_b = self.x_shape[0]+1 if p_b==0 else p_b
+            p_r = self.x_shape[1]+1 if p_r==0 else p_r
+        
+        if batching:
+            idx_crop = np.zeros((self.so), dtype=np.bool_)
+            idx_crop[p_t:p_b, p_l:p_r] = True
+            idx_crop = idx_crop.reshape(-1)
+            out = out_v[idx_crop,:].T
+        else:
+            if issparse:
+                out = out_v.reshape((self.so)).tocsc()[p_t:p_b, p_l:p_r]
+            else:
+                out = out_v.reshape((self.so))[p_t:p_b, p_l:p_r]  ## reshape back into 2D array and crop
+        return out
+    
+    def _roll_sparse(
+        self,
+        x,
+        shift,
+    ):
+        """
+        Roll columns of a sparse matrix.
+        """
+        out = x.copy()
+        out.row += shift
+        return out

sparse_convolution-0.1.1/sparse_convolution.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: sparse_convolution
+Version: 0.1.1
+Summary: Sparse convolution in python using Toeplitz convolution matrix multiplication.
+Home-page: https://github.com/RichieHakim/sparse_convolution
+Author: Richard Hakim
+Author-email: richhakim@gmail.com
+License: MIT
+Keywords: sparse convolution Toeplitz python
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy
+Requires-Dist: numpy
+
+# sparse_convolution
+Sparse convolution in python. \
+Uses Toeplitz convolutional matrix multiplication to perform sparse convolution. \
+This allows for extremely fast convolution when: 
+- The kernel is small (<= 30x30)
+- The input array is sparse (<= 1% density)
+- Many arrays are convolved with the same kernel
+
+## Install: 
+`git clone https://github.com/RichieHakim/sparse_convolution` \
+`cd sparse_convolution` \
+`pip install -e .` 
+
+
+## Basic usage: 
+Convolve a single sparse 2D array with a 2D kernel.
+```
+import sparse_convolution as sc
+import numpy as np
+import scipy.sparse
+
+# Create a single sparse matrix
+A = scipy.sparse.rand(100, 100, density=0.1)
+
+# Create a dense kernel
+B = np.random.rand(3, 3)
+
+# Prepare class
+conv = Toeplitz_convolution2d(
+    x_shape=A.shape,
+    k=B,
+    mode='same',
+    dtype=np.float32,
+)
+
+# Convolve
+C = conv(
+    x=A,
+    batching=False,
+    mode='same',
+).toarray()
+```
+
+
+## Batching usage: 
+Convolve multiple sparse 2D arrays with a 2D kernel. \
+The input arrays must be reshaped into flattened vectors and stacked into a single sparse array of shape: `(n_arrays, height * width)`. 
+```
+import sparse_convolution as sc
+import numpy as np
+import scipy.sparse
+
+# Create multiple sparse matrices
+# note that the shape of A will be (3, 100**2)
+A = scipy.sparse.vstack([
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+    scipy.sparse.rand(100, 100, density=0.1).reshape(1, -1),
+]).tocsr()
+
+# Create a dense kernel
+B = np.random.rand(3, 3)
+
+# Prepare class
+conv = sc.Toeplitz_convolution2d(
+    x_shape=(100, 100),  # note that the input shape here is (100, 100)
+    k=B,
+    mode='same',
+    dtype=np.float32,
+)
+
+# Convolve
+C = conv(
+    x=A,
+    batching=True,
+    mode='same',
+)
+
+# Reshape the output back to (3, 100, 100)
+C_reshaped = np.stack([c.reshape(100, 100).toarray() for c in C], axis=0)
+```
+
+## References
+- See: https://stackoverflow.com/a/51865516 and https://github.com/alisaaalehi/convolution_as_multiplication
+    for a nice illustration.
+- See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.convolution_matrix.html 
+    for 1D version.
+- See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.matmul_toeplitz.html#scipy.linalg.matmul_toeplitz 
+    for potential ways to make this implementation faster.
+

sparse_convolution-0.1.1/sparse_convolution.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+requirements.txt
+setup.cfg
+setup.py
+sparse_convolution/__init__.py
+sparse_convolution/sparse_convolution.py
+sparse_convolution.egg-info/PKG-INFO
+sparse_convolution.egg-info/SOURCES.txt
+sparse_convolution.egg-info/dependency_links.txt
+sparse_convolution.egg-info/requires.txt
+sparse_convolution.egg-info/top_level.txt
+tests/test_unit.py

sparse_convolution-0.1.1/sparse_convolution.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sparse_convolution-0.1.1/sparse_convolution.egg-info/requires.txt

@@ -0,0 +1,2 @@
+scipy
+numpy

sparse_convolution-0.1.1/sparse_convolution.egg-info/top_level.txt

@@ -0,0 +1 @@
+sparse_convolution

sparse_convolution-0.1.1/tests/test_unit.py

@@ -0,0 +1,98 @@
+import traceback
+import time
+
+import numpy as np
+import scipy.signal
+
+from sparse_convolution import Toeplitz_convolution2d
+
+def test_toeplitz_convolution2d():
+    """
+    Test toeplitz_convolution2d
+    Tests for modes, shapes, values, and for sparse matrices against
+     scipy.signal.convolve2d.
+
+    RH 2022
+    """
+    ## test toepltiz convolution
+
+    print(f'testing with batching=False')
+
+    stt = shapes_to_try = np.meshgrid(np.arange(1, 7), np.arange(1, 7), np.arange(1, 7), np.arange(1, 7))
+    stt = [s.reshape(-1) for s in stt]
+
+    for mode in ['full', 'same', 'valid']:
+        for ii in range(len(stt[0])):
+            x = np.random.rand(stt[0][ii], stt[1][ii])
+            k = np.random.rand(stt[2][ii], stt[3][ii])
+    #         print(stt[0][ii], stt[1][ii], stt[2][ii], stt[3][ii])
+
+            try:
+                t = Toeplitz_convolution2d(x_shape=x.shape, k=k, mode=mode, dtype=None)
+                out_t2d = t(x, batching=False, mode=mode)
+                out_t2d_s = t(scipy.sparse.csr_matrix(x), batching=False, mode=mode)
+                out_sp = scipy.signal.convolve2d(x, k, mode=mode)
+            except Exception as e:
+                if mode == 'valid' and (stt[0][ii] < stt[2][ii] or stt[1][ii] < stt[3][ii]):
+                    if 'x must be larger than k' in str(e):
+                        continue
+                print(f'A) test failed with shapes:  x: {x.shape}, k: {k.shape} and mode: {mode} and Exception: {e}  {traceback.format_exc()}')
+                success = False
+                break
+            try:
+                if np.allclose(out_t2d, out_t2d_s.A) and np.allclose(out_t2d, out_sp) and np.allclose(out_sp, out_t2d_s.A):
+                    success = True
+                    continue
+            except Exception as e:
+                print(f'B) test failed with shapes:  x: {x.shape}, k: {k.shape} and mode: {mode} and Exception: {e}  {traceback.format_exc()}')
+                success = False
+                break
+
+            else:
+                print(f'C) test failed with batching==False, shapes:  x: {x.shape}, k: {k.shape} and mode: {mode}')
+                success = False
+                break       
+
+    print(f'testing with batching=True')
+
+    for mode in ['full', 'same', 'valid']:
+        for ii in range(len(stt[0])):
+            x = np.stack([np.random.rand(stt[0][ii], stt[1][ii]).reshape(-1) for jj in range(3)], axis=0)
+            k = np.random.rand(stt[2][ii], stt[3][ii])
+    #         print(stt[0][ii], stt[1][ii], stt[2][ii], stt[3][ii])
+
+            try:
+                t = Toeplitz_convolution2d(x_shape=(stt[0][ii], stt[1][ii]), k=k, mode=mode, dtype=None)
+                out_sp = np.stack([scipy.signal.convolve2d(x_i.reshape(stt[0][ii], stt[1][ii]), k, mode=mode) for x_i in x], axis=0)
+                out_t2d = t(x, batching=True, mode=mode).reshape(3, out_sp.shape[1], out_sp.shape[2])
+                out_t2d_s = t(scipy.sparse.csr_matrix(x), batching=True, mode=mode).toarray().reshape(3, out_sp.shape[1], out_sp.shape[2])
+            except Exception as e:
+                if mode == 'valid' and (stt[0][ii] < stt[2][ii] or stt[1][ii] < stt[3][ii]):
+                    if 'x must be larger than k' in str(e):
+                        continue
+                else:
+                    print(f'A) test failed with shapes:  x: {x.shape}, k: {k.shape} and mode: {mode} and Exception: {e}  {traceback.format_exc()}')
+                success = False
+                break
+            try:
+                if np.allclose(out_t2d, out_t2d_s) and np.allclose(out_t2d, out_sp) and np.allclose(out_sp, out_t2d_s):
+                    success = True
+                    continue
+            except Exception as e:
+                print(f'B) test failed with shapes:  x: {x.shape}, k: {k.shape} and mode: {mode} and Exception: {e}  {traceback.format_exc()}')
+                success = False
+                break
+
+            else:
+                print(f'C) test failed with batching==False, shapes:  x: {x.shape}, k: {k.shape} and mode: {mode}')
+                print(f"Failure analysis: \n")
+                print(f"Shapes: x: {x.shape}, k: {k.shape}, out_t2d: {out_t2d.shape}, out_t2d_s: {out_t2d_s.shape}, out_sp: {out_sp.shape}")
+                print(f"out_t2d: {out_t2d}")
+                print(f"out_t2d_s: {out_t2d_s}")
+                print(f"out_sp: {out_sp}")
+
+                success = False
+                break           
+    print(f'success with all shapes and modes') if success else None
+    assert success, 'test failed'
+    # return success