Initial commit

Author: v0lta

.github/workflows/tests.yml

@@ -0,0 +1,27 @@
+name: Tests
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  tests:
+    name: tests
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest ]
+        python-version: [3.9, 3.11]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: pip install nox
+      - name: Test with pytest
+        run:
+          nox -s test

.gitignore

@@ -0,0 +1,39 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Compiled object files
+*.o
+*.obj
+
+# Compiled dynamic libraries
+*.so
+*.dylib
+
+# Compiled static libraries
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+
+# Build directories
+build/
+bin/
+dist/
+
+# IDE specific files
+.vscode/
+.idea/
+
+# Dependency directories
+vendor/
+
+# test cache files
+.pytest_cache/
+.nox
+
+# egg-infos
+sympad.egg-info/

LICENSE

@@ -0,0 +1,5 @@
+                 NO LIMIT PUBLIC LICENSE
+Terms and conditions for copying, distribution, modification
+or anything else.
+
+  0. No limit to do anything with this work and this license.

README.md

@@ -0,0 +1,17 @@
+# Symmetric padding for Pytorch
+
+Welcome to the `sympad_pytorch` repository!
+
+## Description
+
+This repository implements a `symmetric` padding extension for PyTorch. Symmetric padding, for example, is the default in `pywt` (https://pywavelets.readthedocs.io). Providing this functionality as a C++ module in PyTorch will allow us to speed up Wavelet computations in PyTorch.
+
+## Testing and Verification
+
+Follow these steps:
+
+1. Clone the repository: `git clone https://github.com/your-username/cpp_pad.git`.
+2. Navigate to the project directory: `cd sympad_pytorch `.
+3. Run the tests with `nox -s test`.
+
+

noxfile.py

@@ -0,0 +1,58 @@
+"""This file contains the configuration for Nox sessions.
+
+This file defines the following Nox sessions:
+- test: Installs dependencies, runs setup.py, and runs pytest.
+- format: Fixes common convention problems automatically using black and isort.
+- lint: Checks code conventions using flake8.
+- typing: Checks type hints using mypy.
+"""
+
+import nox
+
+
+@nox.session(name="test")
+def test_pad(session):
+    session.install("pytest")
+    session.install("numpy")
+    session.install("torch")
+    session.install("build")
+    session.run("python", "-m", "build", "--no-isolation")
+    session.install("dist/sympad-0.0.1.tar.gz")
+    session.run("pytest")
+
+
+@nox.session(name="format")
+def format(session):
+    """Fix common convention problems automatically."""
+    session.install("black")
+    session.install("isort")
+    session.run("isort", ".")
+    session.run("black", ".")
+
+
+@nox.session(name="lint")
+def lint(session):
+    """Check code conventions."""
+    session.install("flake8")
+    session.install(
+        "flake8-black",
+        "flake8-docstrings",
+        "flake8-bugbear",
+        "flake8-broken-line",
+        "pep8-naming",
+        "pydocstyle",
+        "darglint",
+    )
+    session.run("flake8", "test", "noxfile.py")
+
+    session.install("sphinx", "doc8")
+    session.run("doc8", "--max-line-length", "120", "docs/")
+
+
+@nox.session(name="typing")
+def mypy(session):
+    """Check type hints."""
+    session.install("torch")
+    session.install("mypy")
+
+    session.run("mypy", "--ignore-missing-imports", "test")

setup.py

@@ -0,0 +1,10 @@
+from setuptools import Extension, setup
+from torch.utils import cpp_extension
+
+setup(
+    name="sympad",
+    version="0.0.1",
+    ext_modules=[cpp_extension.CppExtension("sympad", ["src/sympad.cpp"])],
+    cmdclass={"build_ext": cpp_extension.BuildExtension},
+    install_requires=["torch"]
+)

src/sympad.cpp

@@ -0,0 +1,84 @@
+#include <torch/extension.h>
+
+#include <iostream>
+using namespace torch::indexing;
+using namespace std;
+
+/**
+ * Pads a 1-dimensional tensor symmetrically.
+ * This is a helper function for _pad_symmetric.
+ *
+ * @param signal The input tensor to be padded.
+ * @param padl The number of zeros to pad on the left side of the tensor.
+ * @param padr The number of zeros to pad on the right side of the tensor.
+ * @param dim The dimension along which to pad the tensor.
+ * 
+ * @return The padded tensor.
+ */
+torch::Tensor _pad_symmetric_1d(torch::Tensor signal, pair<int, int> pad_tuple, int dim)
+{   int padl = pad_tuple.first;
+    int padr = pad_tuple.second;
+    int dimlen = signal.size(dim);
+    // If the padding is greater than the dimension length,
+    // pad recursively until we have enough values.
+    if (padl > dimlen || padr > dimlen)
+    {
+        if (padl > dimlen)
+        {
+            signal = _pad_symmetric_1d(signal, make_pair(dimlen, 0), dim);
+            padl = padl - dimlen;
+        }
+        else
+        {
+            signal = _pad_symmetric_1d(signal, make_pair(0, dimlen), dim);
+            padr = padr - dimlen;
+        }
+        return _pad_symmetric_1d(signal, make_pair(padl, padr), dim);
+    }
+    else
+    {
+        vector<torch::Tensor> cat_list = {signal};
+        if (padl > 0)
+        {
+            cat_list.insert(cat_list.begin(), signal.slice(dim, 0, padl).flip(dim));
+        }
+        if (padr > 0)
+        {
+            cat_list.push_back(signal.slice(dim, dimlen-padr, dimlen).flip(dim));
+        }
+        return torch::cat(cat_list, dim);
+    }
+}
+
+
+/**
+ * Pads a given signal symmetrically along multiple dimensions.
+ *
+ * @param signal The input signal to be padded.
+ * @param pad_lists A vector of pairs representing the padding amounts for each dimension.
+ *                  Each pair contains the left and right padding amounts for a dimension.
+ * @return The padded signal.
+ * @throws std::invalid_argument if the input signal has fewer dimensions than the specified padding dimensions.
+ */
+torch::Tensor pad_symmetric(torch::Tensor signal, vector<pair<int, int>> pad_lists)
+{
+    int pad_dims = pad_lists.size();
+    if (signal.dim() < pad_dims)
+    {
+        throw std::invalid_argument("not enough dimensions to pad.");
+    }
+
+    int dims = signal.dim() - 1;
+    reverse(pad_lists.begin(), pad_lists.end());
+    for (int pos = 0; pos < pad_dims; pos++)
+    {
+        int current_axis = dims - pos;
+        signal = _pad_symmetric_1d(signal, pad_lists[pos], current_axis);
+    }
+    return signal;
+}
+
+PYBIND11_MODULE(sympad, m) {
+  m.def("pad_symmetric", &pad_symmetric, "A function that pads a tensor symmetrically");
+  m.def("_pad_symmetric_1d", &_pad_symmetric_1d, "A function that pads a tensor symmetrically in 1D.");
+}

test/test_sympad.py

@@ -0,0 +1,68 @@
+"""Test the sympad modules 1D, 2D and 3D padding."""
+
+import numpy as np
+import pytest
+import torch
+from sympad import _pad_symmetric_1d, pad_symmetric
+
+
+@pytest.mark.parametrize("size", [[5], [6], [9], [3]])
+@pytest.mark.parametrize(
+    "pad_list",
+    [(1, 4), (2, 2), (3, 3), (4, 1), (5, 0), (0, 5), (0, 0), (1, 1), (3, 1), (1, 3)],
+)
+def test_pad_symmetric_1d(size: list[int], pad_list: tuple[int, int]) -> None:
+    """Test high-dimensional symetric padding."""
+    array = np.random.randint(0, 9, size=size)
+    my_pad = _pad_symmetric_1d(torch.from_numpy(array), pad_list, 0)
+    np_pad = np.pad(array, pad_list, mode="symmetric")
+    assert np.allclose(my_pad.numpy(), np_pad)
+
+
+@pytest.mark.parametrize("size", [[6, 5], [5, 6], [5, 5], [9, 9], [3, 3], [4, 4]])
+@pytest.mark.parametrize("pad_list", [[(1, 4), (4, 1)], [(2, 2), (3, 3)]])
+def test_pad_symmetric_2d(size: list[int], pad_list: list[tuple[int, int]]) -> None:
+    """Test high-dimensional symetric padding."""
+    array = np.random.randint(0, 9, size=size)
+    my_pad = pad_symmetric(torch.from_numpy(array), pad_list)
+    np_pad = np.pad(array, pad_list, mode="symmetric")
+    assert np.allclose(my_pad.numpy(), np_pad)
+
+
+@pytest.mark.parametrize("size", [[3, 6, 5], [1, 6, 7]])
+@pytest.mark.parametrize(
+    "pad_list", [[(0, 0), (1, 4), (4, 1)], [(1, 1), (2, 2), (3, 3)]]
+)
+def test_pad_symmetric_3d(size: list[int], pad_list: list[tuple[int, int]]) -> None:
+    """Test high-dimensional symetric padding."""
+    array = np.random.randint(0, 9, size=size)
+    my_pad = pad_symmetric(torch.from_numpy(array), pad_list)
+    np_pad = np.pad(array, pad_list, mode="symmetric")
+    assert np.allclose(my_pad.numpy(), np_pad)
+
+
+def test_pad_symmetric_small() -> None:
+    """Test high-dimensional symetric padding."""
+    array = np.random.randint(0, 9, size=(2, 2))
+    my_pad = pad_symmetric(torch.from_numpy(array), ((1, 1), (1, 1)))
+    np_pad = np.pad(array, ((1, 1), (1, 1)), mode="symmetric")
+    assert np.allclose(my_pad.numpy(), np_pad)
+
+
+@pytest.mark.parametrize(
+    "pad_list",
+    [
+        ((6, 6), (6, 6)),
+        ((5, 6), (6, 5)),
+        ((6, 5), (5, 6)),
+        ((5, 5), (5, 5)),
+        ((7, 7), (7, 7)),
+    ],
+)
+@pytest.mark.parametrize("size", [(3, 3), (4, 4), (2, 2), (1, 1), (2, 1), (2, 1)])
+def test_pad_symmetric_wrap(pad_list, size: tuple[int, int]) -> None:
+    """Test high-dimensional symetric padding."""
+    array = np.random.randint(0, 9, size=size)
+    my_pad = pad_symmetric(torch.from_numpy(array), pad_list)
+    np_pad = np.pad(array, pad_list, mode="symmetric")
+    assert np.allclose(my_pad.numpy(), np_pad)