torch-geopooling 1.0.1__cp310-cp310-macosx_11_0_arm64.whl → 1.1.0__cp310-cp310-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

@@ -1,3 +1,3 @@
 from typing import Final
 
-__version__: Final[str] = "1.0.1"
+__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_test.py → functional/pooling_test.py}

@@ -16,7 +16,7 @@
 import pytest
 import torch
 
-from torch_geopooling.functional import (
+from torch_geopooling.functional.pooling import (
     AdaptiveFunction,
     adaptive_quad_pool2d,
     adaptive_avg_quad_pool2d,

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_test.py → nn/pooling_test.py}

@@ -22,7 +22,7 @@ from torch import nn
 from torch.optim import SGD
 from torch.nn import L1Loss
 
-from torch_geopooling.nn import (
+from torch_geopooling.nn.pooling import (
     AdaptiveAvgQuadPool2d,
     AdaptiveMaxQuadPool2d,
     AdaptiveQuadPool2d,

{torch_geopooling-1.0.1.dist-info → torch_geopooling-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: torch-geopooling
-Version: 1.0.1
+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
@@ -700,10 +700,10 @@ 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: 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: numpy<2.0.0,>=1.4.0; extra == "test"
 
 # Torch Geopooling - The geospatial pooling library for PyTorch
 

torch_geopooling-1.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+torch_geopooling/_C.cpython-310-darwin.so,sha256=NBiqaH54-7eg2hYxR3YNHaz9gDwn545vPEK6jst4MRk,562264
+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=ouErvQ11jObv_Zc_3angaSrUe1BdXm5BVGaL2Y171WY,110
+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.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-torch_geopooling/_C.cpython-310-darwin.so,sha256=O__bz8PpcIS9IOUEMfhrDToA2bM-HU8bCpxmvSV_EBI,517944
-torch_geopooling/__init__.py,sha256=g3zAIxXO6CdrT0zoTlfM3K86LeTWJcgIsqPTqYmhBMQ,60
-torch_geopooling/functional.py,sha256=MuJfPW_RC4slgzWBO2ngQIBTzlZXeW7DBqV3ooIOSw4,12060
-torch_geopooling/functional_test.py,sha256=Sfv6bSe4DIB-y1xYVwavZoyIdu0bwARGdr8woOx7F7U,2997
-torch_geopooling/nn.py,sha256=_NnGB45dWTZy4MQokFfmJL3as-EPVU3liwOuAmWbv1Y,14219
-torch_geopooling/nn_test.py,sha256=zKoyK1f9SUJGhR8pt4wvocmVICoA6nPWPeUMvKKbwY8,4786
-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.1.dist-info/LICENSE,sha256=jLc4eyvG8hqxH4AdKAjK2DwXoP68qjHiGfq8eP5ubBI,35069
-torch_geopooling-1.0.1.dist-info/METADATA,sha256=CgOBHIw38QEgF4TIAVvnVYWz-RlPgW_60AbdJkK_J-E,44364
-torch_geopooling-1.0.1.dist-info/WHEEL,sha256=ouErvQ11jObv_Zc_3angaSrUe1BdXm5BVGaL2Y171WY,110
-torch_geopooling-1.0.1.dist-info/dependency_links.txt,sha256=JqLDcYHtEaQB51V72n3gAJvRd36bpoPk9qgTbot-Lx4,37
-torch_geopooling-1.0.1.dist-info/top_level.txt,sha256=3geTL2nsLvybdtr1psWIE6h63B1LuyIIyWWv0rDafTk,17
-torch_geopooling-1.0.1.dist-info/RECORD,,