torch-geopooling 1.0.0rc3__cp39-cp39-macosx_11_0_arm64.whl → 1.1.0__cp39-cp39-macosx_11_0_arm64.whl

torch_geopooling/__bind__/python_module.cc

@@ -11,14 +11,17 @@ namespace torch_geopooling {
 
 PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
 {
-    m.def("quad_pool2d", &quad_pool2d);
-    m.def("quad_pool2d_backward", &quad_pool2d_backward);
+    m.def("avg_quad_pool2d", &avg_quad_pool2d);
+    m.def("avg_quad_pool2d_backward", &avg_quad_pool2d_backward);
 
     m.def("max_quad_pool2d", &max_quad_pool2d);
     m.def("max_quad_pool2d_backward", &max_quad_pool2d_backward);
 
-    m.def("avg_quad_pool2d", &avg_quad_pool2d);
-    m.def("avg_quad_pool2d_backward", &avg_quad_pool2d_backward);
+    m.def("quad_pool2d", &quad_pool2d);
+    m.def("quad_pool2d_backward", &quad_pool2d_backward);
+
+    m.def("embedding2d", &embedding2d);
+    m.def("embedding2d_backward", &embedding2d_backward);
 }
 
 

torch_geopooling/__init__.py

@@ -0,0 +1,3 @@
+from typing import Final
+
+__version__: Final[str] = "1.1.0"

torch_geopooling/functional/__init__.py

@@ -0,0 +1,2 @@
+from torch_geopooling.functional.embedding import *  # noqa
+from torch_geopooling.functional.pooling import *  # noqa

torch_geopooling/functional/embedding.py

@@ -0,0 +1,85 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from typing import Optional, Tuple
+
+from torch import Tensor, autograd
+from torch.autograd.function import FunctionCtx
+
+import torch_geopooling._C as _C
+from torch_geopooling.tiling import ExteriorTuple
+
+
+__all__ = ["embedding2d"]
+
+
+class Function(autograd.Function):
+    @staticmethod
+    def forward(
+        input: Tensor,
+        weight: Tensor,
+        padding: Tuple[int, int],
+        exterior: ExteriorTuple,
+    ) -> Tensor:
+        return _C.embedding2d(input, weight, padding, exterior)
+
+    @staticmethod
+    def setup_context(ctx: FunctionCtx, inputs: Tuple, outputs: Tuple) -> None:
+        input, weight, padding, exterior = inputs
+
+        ctx.save_for_backward(input, weight)
+        ctx.padding = padding
+        ctx.exterior = exterior
+
+    @staticmethod
+    def backward(ctx: FunctionCtx, grad: Tensor) -> Tuple[Optional[Tensor], ...]:
+        input, weight = ctx.saved_tensors
+        grad_weight = _C.embedding2d_backward(grad, input, weight, ctx.padding, ctx.exterior)
+        return None, grad_weight, None, None
+
+
+def embedding2d(
+    input: Tensor,
+    weight: Tensor,
+    *,
+    padding: Tuple[int, int] = (0, 0),
+    exterior: ExteriorTuple,
+) -> Tensor:
+    """
+    Retrieves spatial embeddings from a fixed-size lookup table based on 2D coordinates.
+
+    This function accepts a list of (x, y) coordinates and retrieves the corresponding
+    spatial embeddings from a provided embedding matrix. The embeddings are selected
+    based on the input coordinates, with an optional padding to include neighboring cells.
+    See :class:`torch_geopooling.nn.Embedding2d` for more details.
+
+    Args:
+        input: A list of 2D coordinates where each coordinate is represented as a tuple (x, y),
+            where x is the longitude and y is the latitude.
+        weight: A 3D tensor representing the embedding matrix. The first dimension  corresponds to
+            the maximum possible bucket for the x coordinate, the second dimension corresponds to
+            the maximum possible bucket for the y coordinate, and the third dimension corresponds
+            to the embedding size.
+        padding: The size of the neighborhood to query. Default is 0, meaning only the embedding
+            for the exact input coordinate is retrieved.
+        exterior: The geometric boundary of the learning space, specified as a tuple (X, Y, W, H),
+            where X and Y represent the origin, and W and H represent the width and height of the
+            space, respectively.
+
+    Returns:
+        Tensor: The retrieved spatial embeddings corresponding to the input coordinates.
+    """
+
+    return Function.apply(input, weight, padding, exterior)

torch_geopooling/functional/embedding_test.py

@@ -0,0 +1,31 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import torch
+from torch_geopooling.functional.embedding import embedding2d
+
+
+def test_embedding2d() -> None:
+    input = torch.rand((100, 2), dtype=torch.float64) * 10.0
+    weight = torch.rand((1024, 1024, 3), dtype=torch.float64)
+
+    result = embedding2d(
+        input,
+        weight,
+        padding=(3, 2),
+        exterior=(-10.0, -10.0, 20.0, 20.0),
+    )
+
+    assert result.size() == torch.Size([100, 7, 5, 3])

torch_geopooling/{functional.py → functional/pooling.py}

@@ -271,10 +271,12 @@ class AdaptiveFunction(autograd.Function):
         weight, input = ctx.saved_tensors
         tiles, w = cls.sparse_ravel(weight)
 
-        grad_weight_out = cls.backward_impl(grad_values, tiles, w, input, ctx.exterior, *ctx.params)  # type: ignore
-        grad_weight_out = cls.sparse_unravel(tiles, grad_weight_out, size=weight.size())
+        grad_weight_dense = cls.backward_impl(
+            grad_values, tiles, w, input, ctx.exterior, *ctx.params
+        )  # type: ignore
+        grad_weight_sparse = cls.sparse_unravel(tiles, grad_weight_dense, size=weight.size())
 
-        return grad_weight_out.coalesce(), None, None, None, None
+        return grad_weight_sparse.coalesce(), None, None, None, None
 
     @classmethod
     def func(

torch_geopooling/{functional_test.py → functional/pooling_test.py}

@@ -16,7 +16,8 @@
 import pytest
 import torch
 
-from torch_geopooling.functional import (
+from torch_geopooling.functional.pooling import (
+    AdaptiveFunction,
     adaptive_quad_pool2d,
     adaptive_avg_quad_pool2d,
     adaptive_max_quad_pool2d,
@@ -26,6 +27,20 @@ from torch_geopooling.functional import (
 )
 
 
+def test_adaptive_function_ravel() -> None:
+    size = (2, 2, 2, 1)
+    tiles = torch.tensor([[0, 0, 0], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]], dtype=torch.int64)
+
+    weight = torch.tensor([[1.0], [2.0], [3.0], [4.0], [5.0]], dtype=torch.float64)
+
+    sparse = AdaptiveFunction.sparse_unravel(tiles, weight, size=size)
+    torch.testing.assert_close(sparse.to_dense().to_sparse_coo(), sparse)
+
+    tiles_out, weight_out = AdaptiveFunction.sparse_ravel(sparse)
+    torch.testing.assert_close(tiles_out, tiles)
+    torch.testing.assert_close(weight_out, weight)
+
+
 @pytest.mark.parametrize(
     "function",
     [

torch_geopooling/nn/__init__.py

@@ -0,0 +1,2 @@
+from torch_geopooling.nn.embedding import *  # noqa
+from torch_geopooling.nn.pooling import *  # noqa

torch_geopooling/nn/embedding.py

@@ -0,0 +1,89 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from typing import Union, Tuple, cast
+
+import torch
+from torch import Tensor, nn
+
+from torch_geopooling import functional as F
+from torch_geopooling.tiling import Exterior, ExteriorTuple
+
+
+__all__ = [
+    "Embedding2d",
+]
+
+
+_Exterior = Union[Exterior, ExteriorTuple]
+
+
+class Embedding2d(nn.Module):
+    """
+    Retrieves spatial embeddings from a fixed-size lookup table based on 2D coordinates.
+
+    This module accepts a tensor of (x, y) coordinates and retrieves the corresponding
+    spatial embeddings from a provided embedding matrix. The embeddings are selected
+    based on the input coordinates, with an optional padding to include neighboring cells.
+
+    Args:
+        manifold: The size of the 2-dimensional embedding in a form (W, H, N), where
+            W is a width, H is a height, and N is a feature dimension of the embedding.
+        padding: The size of the neighborhood to query. Default is 0, meaning only the embedding
+            for the exact input coordinate is retrieved.
+        exterior: The geometric boundary of the learning space, specified as a tuple (X, Y, W, H),
+            where X and Y represent the origin, and W and H represent the width and height of the
+            space, respectively.
+
+    Shape:
+        - Input: :math:`(*, 2)`, where 2 comprises x and y coordinates.
+        - Output: :math:`(*, X_{out}, Y_{out}, N)`, where * is the input shape, \
+            :math:`N = \\text{manifold[2]}`, and
+
+            :math:`X_{out} = \\text{padding}[0] \\times 2 + 1`
+
+            :math:`Y_{out} = \\text{padding}[1] \\times 2 + 1`
+
+    Examples:
+
+    >>> # Create an embedding of EPSG:4326 rectangle into 1024x1024 embedding
+    >>> # with 3 features in each cell.
+    >>> embedding = nn.Embedding2d(
+    ...     (1024, 1024, 3),
+    ...     exterior=(-180.0, -90.0, 360.0, 180.0),
+    ...     padding=(2, 2),
+    ... )
+    >>> input = torch.rand((100, 2), dtype=torch.float64) * 60.0
+    >>> output = embedding(input)
+    """
+
+    def __init__(
+        self,
+        manifold: Tuple[int, int, int],
+        exterior: _Exterior,
+        padding: Tuple[int, int] = (0, 0),
+    ) -> None:
+        super().__init__()
+        self.exterior = cast(ExteriorTuple, tuple(map(float, exterior)))
+        self.padding = padding
+
+        self.weight = nn.Parameter(torch.empty(manifold, dtype=torch.float64))
+        nn.init.zeros_(self.weight)
+
+    def extra_repr(self) -> str:
+        return "{manifold}, exterior={exterior}, padding={padding}".format(**self.__dict__)
+
+    def forward(self, input: Tensor) -> Tensor:
+        return F.embedding2d(input, self.weight, exterior=self.exterior, padding=self.padding)

torch_geopooling/nn/embedding_test.py

@@ -0,0 +1,48 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import pytest
+import torch
+from torch import nn
+from torch.optim import SGD
+
+from torch_geopooling.nn.embedding import Embedding2d
+
+
+def test_embedding2d_optimize() -> None:
+    embedding = Embedding2d(
+        (2, 2, 1),
+        padding=(0, 0),
+        exterior=(-180.0, -90.0, 360.0, 180.0),
+    )
+
+    x_true = torch.tensor(
+        [[90.0, 45.0], [90.0, -45.0], [-90.0, -45.0], [-90.0, 45.0]], dtype=torch.float64
+    )
+    y_true = torch.tensor([[10.0], [20.0], [30.0], [40.0]], dtype=torch.float64)
+
+    optim = SGD(embedding.parameters(), lr=0.1)
+    loss_fn = nn.L1Loss()
+
+    for i in range(10000):
+        optim.zero_grad()
+
+        y_pred = embedding(x_true)
+        loss = loss_fn(y_pred[:, 0, 0, :], y_true)
+        loss.backward()
+
+        optim.step()
+
+    assert pytest.approx(0.0, abs=1e-1) == loss.detach().item()

torch_geopooling/{nn.py → nn/pooling.py}

@@ -91,7 +91,12 @@ class _AdaptiveQuadPool(nn.Module):
     def initialize_parameters(self) -> None:
         # The weight for adaptive operation should be sparse, since training operation
         # results in a dynamic change of the underlying quadtree.
-        weight_size = (self.max_depth, 1 << self.max_depth, 1 << self.max_depth, self.feature_dim)
+        weight_size = (
+            self.max_depth + 1,
+            1 << self.max_depth,
+            1 << self.max_depth,
+            self.feature_dim,
+        )
         self.weight = nn.Parameter(torch.sparse_coo_tensor(size=weight_size, dtype=torch.float64))
 
     @property

torch_geopooling/nn/pooling_test.py

@@ -0,0 +1,158 @@
+# Copyright (C) 2024, Yakau Bubnou
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from typing import Type
+
+import pytest
+import torch
+from shapely.geometry import Polygon
+from torch import nn
+from torch.optim import SGD
+from torch.nn import L1Loss
+
+from torch_geopooling.nn.pooling import (
+    AdaptiveAvgQuadPool2d,
+    AdaptiveMaxQuadPool2d,
+    AdaptiveQuadPool2d,
+    AvgQuadPool2d,
+    MaxQuadPool2d,
+    QuadPool2d,
+)
+
+
+@pytest.mark.parametrize(
+    "module_class",
+    [
+        AdaptiveQuadPool2d,
+        AdaptiveMaxQuadPool2d,
+        AdaptiveAvgQuadPool2d,
+    ],
+    ids=["id", "max", "avg"],
+)
+def test_adaptive_quad_pool2d_gradient(module_class: Type[nn.Module]) -> None:
+    pool = module_class(5, (-180, -90, 360, 180))
+
+    input = torch.rand((100, 2), dtype=torch.float64) * 90
+    y = pool(input)
+
+    assert pool.weight.grad is None
+
+    loss_fn = L1Loss()
+    loss = loss_fn(y, torch.ones_like(y))
+    loss.backward()
+
+    assert pool.weight.grad is not None
+    assert pool.weight.grad.sum().item() == pytest.approx(-1)
+
+
+def test_adaptive_quad_pool2d_optimize() -> None:
+    pool = AdaptiveQuadPool2d(1, (-180, -90, 360, 180), max_depth=1)
+
+    # Input coordinates are simply centers of the level-1 quads.
+    x_true = torch.tensor(
+        [[90.0, 45.0], [90.0, -45.0], [-90.0, -45.0], [-90.0, 45.0]], dtype=torch.float64
+    )
+    y_true = torch.tensor([[10.0], [20.0], [30.0], [40.0]], dtype=torch.float64)
+    y_tile = [[1, 1, 1], [1, 1, 0], [1, 0, 0], [1, 0, 1]]
+
+    optim = SGD(pool.parameters(), lr=0.01)
+    loss_fn = nn.L1Loss()
+
+    for i in range(20000):
+        optim.zero_grad()
+
+        y_pred = pool(x_true)
+        loss = loss_fn(y_pred, y_true)
+        loss.backward()
+
+        optim.step()
+
+    # Ensure that model converged with a small loss.
+    assert pytest.approx(0.0, abs=1e-1) == loss.detach().item()
+
+    # Ensure that weights that pooling operation learned are the same as in the
+    # target matrix (y_true).
+    weight = pool.weight.to_dense()
+
+    for i, tile in enumerate(y_tile):
+        z, x, y = tile
+        expect_weight = y_true[i].item()
+        actual_weight = weight[z, x, y].detach().item()
+
+        assert pytest.approx(expect_weight, abs=1e-1) == actual_weight, f"tile {tile} is wrong"
+
+
+@pytest.mark.parametrize(
+    "module_class",
+    [
+        QuadPool2d,
+        MaxQuadPool2d,
+        AvgQuadPool2d,
+    ],
+    ids=["id", "max", "avg"],
+)
+def test_quad_pool2d_gradient(module_class: Type[nn.Module]) -> None:
+    poly = Polygon([(0.0, 0.0), (1.0, 0.0), (1.0, 1.1), (0.0, 1.0)])
+    exterior = (0.0, 0.0, 1.0, 1.0)
+
+    pool = module_class(4, poly, exterior, max_depth=5)
+    assert pool.weight.size() == torch.Size([pool.tiles.size(0), 4])
+
+    input = torch.rand((100, 2), dtype=torch.float64)
+    y = pool(input)
+
+    assert pool.weight.grad is None
+
+    loss_fn = L1Loss()
+    loss = loss_fn(y, torch.ones_like(y))
+    loss.backward()
+
+    assert pool.weight.grad is not None
+    assert pool.weight.grad.sum().item() == pytest.approx(-1)
+
+
+def test_quad_pool2d_optimize() -> None:
+    poly = Polygon([(-180, -90), (-180, 90), (180, 90), (180, -90)])
+    pool = QuadPool2d(1, poly, (-180, -90, 360, 180), max_depth=1)
+
+    x_true = torch.tensor(
+        [[90.0, 45.0], [90.0, -45.0], [-90.0, -45.0], [-90.0, 45.0]], dtype=torch.float64
+    )
+    y_true = torch.tensor([[10.0], [20.0], [30.0], [40.0]], dtype=torch.float64)
+    y_tile = [(1, 1, 1), (1, 1, 0), (1, 0, 0), (1, 0, 1)]
+
+    optim = SGD(pool.parameters(), lr=0.01)
+    loss_fn = nn.L1Loss()
+
+    for i in range(20000):
+        optim.zero_grad()
+
+        y_pred = pool(x_true)
+        loss = loss_fn(y_pred, y_true)
+        loss.backward()
+
+        optim.step()
+
+    # Ensure that model converged with a small loss.
+    assert pytest.approx(0.0, abs=1e-1) == loss.detach().item()
+
+    actual_tiles = {}
+    for i in range(pool.tiles.size(0)):
+        tile = tuple(pool.tiles[i].detach().tolist())
+        actual_tiles[tile] = pool.weight[i, 0].detach().item()
+
+    for tile, expect_weight in zip(y_tile, y_true[:, 0].tolist()):
+        actual_weight = actual_tiles[tile]
+        assert pytest.approx(expect_weight, abs=1e-1) == actual_weight, f"tile {tile} is wrong"

{torch_geopooling-1.0.0rc3.dist-info → torch_geopooling-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: torch-geopooling
-Version: 1.0.0rc3
+Version: 1.1.0
 Summary: The geospatial pooling modules for neural networks in PyTorch
 Author-email: Yakau Bubnou <girokompass@gmail.com>
 License: GNU GENERAL PUBLIC LICENSE
@@ -680,7 +680,7 @@ License: GNU GENERAL PUBLIC LICENSE
         
 Project-URL: homepage, https://github.com/ybubnov/torch_geopooling
 Project-URL: source, https://github.com/ybubnov/torch_geopooling
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Topic :: Scientific/Engineering
@@ -699,17 +699,21 @@ Classifier: Operating System :: MacOS
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: shapely >=2.0.0
-Requires-Dist: torch <2.3.0,>=2.2.0
+Requires-Dist: shapely>=2.0.0
+Requires-Dist: torch<2.4.0,>=2.3.0
 Provides-Extra: test
-Requires-Dist: pytest >=8.0.0 ; extra == 'test'
-Requires-Dist: numpy >=1.4.0 ; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: numpy<2.0.0,>=1.4.0; extra == "test"
 
 # Torch Geopooling - The geospatial pooling library for PyTorch
 
 The Torch Geopooling library is an extension for PyTorch library that provide extra layers for
 building geospatial neural networks.
 
+Here is an example of how you can use modules from Torch Geopooling library to train neural
+networks predicting geospatial features:
+![example](docs/index.png)
+
 ## Installation
 
 The library is distributed as PyPI package, to install that package, execute the following

torch_geopooling-1.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+torch_geopooling/_C.cpython-39-darwin.so,sha256=7shxNV1Ja1RaYhY9zASNfM6zQaSMNaGgNJPCjtR60E8,562520
+torch_geopooling/__init__.py,sha256=0o5Lnb5ZcEIRNY9AljwW1ESEmQid79rcbBsDBoMT8aM,60
+torch_geopooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torch_geopooling/return_types.py,sha256=QhIKf_qxpppzuZzUrT-VacfbvZ6zKmSRu-WZOqL8wuE,898
+torch_geopooling/tiling.py,sha256=f1g0Gf__5zIOafZzDkwO62t9OqMDMBEYVtM2HXB5X0Y,2553
+torch_geopooling/transforms.py,sha256=NHPBgx1L4-1745xNO_PvLuvbMH6DWi2rs1ViuRyBQAY,3635
+torch_geopooling/transforms_test.py,sha256=Cqp4VVObBVrc8HQ7uxkpe1EsQ5NxXrCI77BiUqngLXw,1196
+torch_geopooling/__bind__/python_module.cc,sha256=LLI363riung_4LI5ugN7Pm93iuoHDRF7n4Y4RlkzLYk,675
+torch_geopooling/functional/__init__.py,sha256=BCcS22yPWITm37M-EPD-PK6WrS7grikDR8uZdoO8sZ4,118
+torch_geopooling/functional/embedding.py,sha256=ER0KB-G7SoCsWJuNEqXRC_XcLdhqaCpn5OJPpUF9pLc,3337
+torch_geopooling/functional/embedding_test.py,sha256=B5a1MP0rynX01a1RmmTJHZxMi4Y68cQoblw-kQawHJM,1094
+torch_geopooling/functional/pooling.py,sha256=MuJfPW_RC4slgzWBO2ngQIBTzlZXeW7DBqV3ooIOSw4,12060
+torch_geopooling/functional/pooling_test.py,sha256=qBT_WVbwyANolwg7-rE7KimF-bAEDB44guBl4OQuQhE,3005
+torch_geopooling/nn/__init__.py,sha256=fWrhfQu0_KzW7VUesk31Sy3n3Om2c5g5dGA3vrLcCg4,102
+torch_geopooling/nn/embedding.py,sha256=u0H1e_sqFG8ALmnfLpbFwKr_yw-z7MNExmB9-uE0SF0,3317
+torch_geopooling/nn/embedding_test.py,sha256=msUeidL9Xkf3AKCPGQH9SJAhfkS7dyqYRzsH88Pt1uY,1505
+torch_geopooling/nn/pooling.py,sha256=_NnGB45dWTZy4MQokFfmJL3as-EPVU3liwOuAmWbv1Y,14219
+torch_geopooling/nn/pooling_test.py,sha256=AqnkpaQ6LcQxh5bWkuDuBAJ2XiBc-C2zVuUp5hynzBM,4794
+torch_geopooling-1.1.0.dist-info/LICENSE,sha256=jLc4eyvG8hqxH4AdKAjK2DwXoP68qjHiGfq8eP5ubBI,35069
+torch_geopooling-1.1.0.dist-info/METADATA,sha256=SnR-sEl9o7dGaskBb2gk0CNU6AydBsta4ZcxFSpuFu8,44371
+torch_geopooling-1.1.0.dist-info/WHEEL,sha256=_exXVVrX7A7i2-EOwk1kG5BcIkGQg9kfHel4XXV7Pbs,108
+torch_geopooling-1.1.0.dist-info/dependency_links.txt,sha256=JqLDcYHtEaQB51V72n3gAJvRd36bpoPk9qgTbot-Lx4,37
+torch_geopooling-1.1.0.dist-info/top_level.txt,sha256=3geTL2nsLvybdtr1psWIE6h63B1LuyIIyWWv0rDafTk,17
+torch_geopooling-1.1.0.dist-info/RECORD,,

{torch_geopooling-1.0.0rc3.dist-info → torch_geopooling-1.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: bdist_wheel (0.44.0)
 Root-Is-Purelib: false
 Tag: cp39-cp39-macosx_11_0_arm64
 

torch_geopooling/nn_test.py

@@ -1,85 +0,0 @@
-# Copyright (C) 2024, Yakau Bubnou
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-from typing import Type
-
-import pytest
-import torch
-from shapely.geometry import Polygon
-from torch import nn
-from torch.nn import L1Loss
-
-from torch_geopooling.nn import (
-    AdaptiveAvgQuadPool2d,
-    AdaptiveMaxQuadPool2d,
-    AdaptiveQuadPool2d,
-    AvgQuadPool2d,
-    MaxQuadPool2d,
-    QuadPool2d,
-)
-
-
-@pytest.mark.parametrize(
-    "module_class",
-    [
-        AdaptiveQuadPool2d,
-        AdaptiveMaxQuadPool2d,
-        AdaptiveAvgQuadPool2d,
-    ],
-    ids=["id", "max", "avg"],
-)
-def test_adaptive_quad_pool2d_gradient(module_class: Type[nn.Module]) -> None:
-    pool = module_class(5, (-180, -90, 360, 180))
-
-    input = torch.rand((100, 2), dtype=torch.float64) * 90
-    y = pool(input)
-
-    assert pool.weight.grad is None
-
-    loss_fn = L1Loss()
-    loss = loss_fn(y, torch.ones_like(y))
-    loss.backward()
-
-    assert pool.weight.grad is not None
-    assert pool.weight.grad.sum().item() == pytest.approx(-1)
-
-
-@pytest.mark.parametrize(
-    "module_class",
-    [
-        QuadPool2d,
-        MaxQuadPool2d,
-        AvgQuadPool2d,
-    ],
-    ids=["id", "max", "avg"],
-)
-def test_quad_pool2d_gradient(module_class: Type[nn.Module]) -> None:
-    poly = Polygon([(0.0, 0.0), (1.0, 0.0), (1.0, 1.1), (0.0, 1.0)])
-    exterior = (0.0, 0.0, 1.0, 1.0)
-
-    pool = module_class(4, poly, exterior, max_depth=5)
-    assert pool.weight.size() == torch.Size([pool.tiles.size(0), 4])
-
-    input = torch.rand((100, 2), dtype=torch.float64)
-    y = pool(input)
-
-    assert pool.weight.grad is None
-
-    loss_fn = L1Loss()
-    loss = loss_fn(y, torch.ones_like(y))
-    loss.backward()
-
-    assert pool.weight.grad is not None
-    assert pool.weight.grad.sum().item() == pytest.approx(-1)

torch_geopooling-1.0.0rc3.dist-info/RECORD

@@ -1,17 +0,0 @@
-torch_geopooling/_C.cpython-39-darwin.so,sha256=oGqtH-KLCmOKFnPLATY_SaZIPlB5l7O3hPpuBlflZV8,518632
-torch_geopooling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-torch_geopooling/functional.py,sha256=rZrh30K4IlxG3lGQ1_C8wrL7MKS9yIT-NSEkcM21A_k,12028
-torch_geopooling/functional_test.py,sha256=WZ7GePj1f8jp8cxNrnrDoHXnJeEeBUNVnFySPgEDl2I,2406
-torch_geopooling/nn.py,sha256=A_pozkqIfjhmOL7BDvTV2bJBv7nXD3Wi8nAlbl_rSEs,14156
-torch_geopooling/nn_test.py,sha256=4Aj3CcI8KG0parOyruAHZCCnC51CvSacTZ0AxTs16Gc,2359
-torch_geopooling/return_types.py,sha256=QhIKf_qxpppzuZzUrT-VacfbvZ6zKmSRu-WZOqL8wuE,898
-torch_geopooling/tiling.py,sha256=f1g0Gf__5zIOafZzDkwO62t9OqMDMBEYVtM2HXB5X0Y,2553
-torch_geopooling/transforms.py,sha256=NHPBgx1L4-1745xNO_PvLuvbMH6DWi2rs1ViuRyBQAY,3635
-torch_geopooling/transforms_test.py,sha256=Cqp4VVObBVrc8HQ7uxkpe1EsQ5NxXrCI77BiUqngLXw,1196
-torch_geopooling/__bind__/python_module.cc,sha256=5K04tRT62XTVsZhY2EE4r4bBTz4mA4IwEkw5adPzo58,576
-torch_geopooling-1.0.0rc3.dist-info/LICENSE,sha256=jLc4eyvG8hqxH4AdKAjK2DwXoP68qjHiGfq8eP5ubBI,35069
-torch_geopooling-1.0.0rc3.dist-info/METADATA,sha256=e81OTHBrYbB3X4ZdjIKovz-ch5tEywdIMf4_oNNq8co,44199
-torch_geopooling-1.0.0rc3.dist-info/WHEEL,sha256=t3aNIuHimB-eyeerOmc50nLML0b4_R6yjydcdcJkGHg,108
-torch_geopooling-1.0.0rc3.dist-info/dependency_links.txt,sha256=JqLDcYHtEaQB51V72n3gAJvRd36bpoPk9qgTbot-Lx4,37
-torch_geopooling-1.0.0rc3.dist-info/top_level.txt,sha256=3geTL2nsLvybdtr1psWIE6h63B1LuyIIyWWv0rDafTk,17
-torch_geopooling-1.0.0rc3.dist-info/RECORD,,