update ignore.

Author: v0lta

.gitignore

@@ -1,3 +1,6 @@
+virtual_env/
+
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md

@@ -1,12 +1,12 @@
-# Symmetric padding for Pytorch
+# Exercise three extending Pytorch
 
-Welcome to the `sympad_pytorch` repository!
+In this exercise you will use setuptools to compile a pytorch extension with PyTorch's `cpp_extension`
+module. 
 
-## 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.
+The task is to implement `symmetric` padding extension for PyTorch. Symmetric padding, for example, is the default in `pywt` (https://pywavelets.readthedocs.io). PyTorch lacks this functionality. In this exercise, we will provide it.
 
-## Testing and Verification
+### Testing and Verification
 
 Follow these steps:
 
@@ -15,3 +15,32 @@ Follow these steps:
 3. Run the tests with `nox -s test`.
 
 
+### Implementing your module in c++.
+
+Symmetric padding extends a signal by mirroring samples. This mode is also known as half-sample symmetric [[pywt-docs](https://pywavelets.readthedocs.io/en/latest/ref/signal-extension-modes.html) ]. 
+The idea is to repeat samples in reverse order at the boundary.
+
+```
+... x2 x1 | x1 x2 ... xn | xn xn-1 ...
+```
+
+Implement this boundary extension mode in the `src/sympad.cpp` file's `_pad_symmetric_1d`-function by resolving the `TODO`'s in the code.
+
+
+### Using your Pytorch module
+
+1. create a virtual environment `python -m venv virtual_env` or a conda environment.
+2. activate the environment `source virtual_env/bin/activate`
+3. Install your module
+	- pip install torch numpy build
+	- python -m build --no-isolation
+	- pip install dist/sympad-0.0.1-cp312-cp312-linux_x86_64.whl
+
+4. Run your module start the python interpreter with `python`.
+5. `import torch, sympad` and `import numpy as np`.
+6. Pad a tensor using your own method.
+	- Run `array = np.arange(9).reshape(3,3)`
+	- `print(array)`
+	- Run `sympad.pad_symmetric(torch.from_numpy(array), [(1,1), (1,1)])`
+
+

noxfile.py

@@ -17,7 +17,7 @@ def test_pad(session):
     session.install("torch")
     session.install("build")
     session.run("python", "-m", "build", "--no-isolation")
-    session.install("dist/sympad-0.0.1.tar.gz")
+    session.install("dist/sympad-0.0.1-cp312-cp312-linux_x86_64.whl")
     session.run("pytest")
 
 
@@ -54,5 +54,4 @@ def mypy(session):
     """Check type hints."""
     session.install("torch")
     session.install("mypy")
-
     session.run("mypy", "--ignore-missing-imports", "test")

setup.py

@@ -1,4 +1,4 @@
-from setuptools import Extension, setup
+from setuptools import setup
 from torch.utils import cpp_extension
 
 setup(

src/sympad.cpp

@@ -23,30 +23,32 @@ torch::Tensor _pad_symmetric_1d(torch::Tensor signal, pair<int, int> pad_tuple,
     // pad recursively until we have enough values.
     if (padl > dimlen || padr > dimlen)
     {
+        // make_pair allows you to call _pad_symmetric_1d.
+        // https://en.cppreference.com/w/cpp/utility/pair/make_pair .
+
         if (padl > dimlen)
         {
-            signal = _pad_symmetric_1d(signal, make_pair(dimlen, 0), dim);
-            padl = padl - dimlen;
+            // TODO: pad as many values as possible and adjust padl.
+
         }
         else
         {
-            signal = _pad_symmetric_1d(signal, make_pair(0, dimlen), dim);
-            padr = padr - dimlen;
+            // TODO: pad as many values as possible and adjust padr.
         }
-        return _pad_symmetric_1d(signal, make_pair(padl, padr), dim);
+        //TODO: Return i.e. with a call of _pad_symmetric_1d instead of signal.
+        return signal;
     }
     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);
+        // use i.e. the vectors insert and push_pack methods to implement symmetric padding.
+        // torch tensors provide the slice( dimension, start, stop) function as well as
+        // the flip(dimesnion) functions, which will help you. 
+
+        // TODO: implement me.
+
+        // return a tensor by calling torch::cat instead of signal
+        return signal;
     }
 }
 
@@ -69,15 +71,12 @@ torch::Tensor pad_symmetric(torch::Tensor signal, vector<pair<int, int>> pad_lis
     }
 
     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);
-    }
+    //take a look at https://cplusplus.com/reference/algorithm/reverse/ .
+    // loop through the dimension vector and pad the specified dimension using _pad_symmetric_1d.
     return signal;
 }
 
+// This code defines the python bindings for your function.
 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

@@ -9,7 +9,8 @@
 @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)],
+    [(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."""
@@ -19,9 +20,11 @@ def test_pad_symmetric_1d(size: list[int], pad_list: tuple[int, int]) -> None:
     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("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:
+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)
@@ -33,7 +36,8 @@ def test_pad_symmetric_2d(size: list[int], pad_list: list[tuple[int, int]]) -> N
 @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:
+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)
@@ -59,7 +63,8 @@ def test_pad_symmetric_small() -> None:
         ((7, 7), (7, 7)),
     ],
 )
-@pytest.mark.parametrize("size", [(3, 3), (4, 4), (2, 2), (1, 1), (2, 1), (2, 1)])
+@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)