so far so good (WIP)

Author: reinvantveer

__init__.py

@@ -0,0 +1,25 @@
+import torch
+
+
+def loss_function(reconstruction_target: torch.Tensor, model_output: torch.Tensor) -> torch.Tensor:
+    assert type(reconstruction_target).__name__ == 'Tensor', 'The reconstruction target should be a tensor'
+    assert type(model_output).__name__ == 'Tensor', 'The model output should be a tensor'
+    assert reconstruction_target.size(0) > 0, 'The reconstruction target should be a tensor with length > 0'
+    assert model_output.size(0) > 0, 'The model output should be a tensor with length > 0'
+    assert reconstruction_target.size(1) == 7, 'The reconstruction target should be a tensor of shape(?, 7)'
+    assert model_output.size(1) == 7, 'The model output should be a tensor of shape(?, 7)'
+
+    # Get rid of anything from and after the final stop
+    reconstruction_final_stop_entries = reconstruction_target[:, 6]
+    reconstruction_final_stop_index = (torch.round(reconstruction_final_stop_entries) == 1.).nonzero()
+    reconstruction_target = reconstruction_target[:reconstruction_final_stop_index]
+
+    model_output_final_stop_entries = model_output[:, 6]
+    model_output_final_stop_index = (torch.round(model_output_final_stop_entries) == 1.).nonzero()
+    model_output = model_output[:model_output_final_stop_index]
+
+    reconstruction_target, _ = torch.topk(reconstruction_target, k=reconstruction_target.shape[0], dim=0)
+    model_output, _ = torch.topk(model_output, k=model_output.shape[0], dim=0)
+    difference = torch.abs(torch.sum(reconstruction_target - model_output))
+
+    return difference

model/__init__.py

@@ -0,0 +1,48 @@
+import math
+import torch
+
+
+def efd(polygon: torch.Tensor, order=2) -> torch.Tensor:
+    """
+    Pytorch function for creating elliptic fourier descriptors. Refactored from
+    https://github.com/hbldh/pyefd/blob/master/pyefd.py thank you Henrik Blidh
+    :param order: number of harmonics for the elliptic fourier descriptors
+    :param polygon: a Pytorch tensor of shape (?, 2)
+    :return:
+    """
+    assert type(polygon).__name__ == 'Tensor', 'The polygon should be a tensor'
+
+    # Following https://discuss.pytorch.org/t/equivalent-function-like-numpy-diff-in-pytorch/35327/2
+    distances_between_nodes = polygon[1:] - polygon[:-1]
+
+    positive_distances = torch.pow(distances_between_nodes, 2)
+    positive_distances = torch.sum(positive_distances, dim=1)
+    positive_distances = torch.sqrt(positive_distances)
+
+    cumulative_distances = torch.cumsum(positive_distances, dim=0)
+    zeros = torch.zeros((1,), dtype=torch.double)
+    cumulative_distances = torch.cat((zeros, cumulative_distances))
+
+    total_distance = cumulative_distances[-1]
+    normalized_distances = (2 * math.pi * cumulative_distances) / total_distance  # pyefd: phi
+
+    efd_orders = torch.arange(1, order + 1, dtype=torch.double)
+
+    const = total_distance / (2 * efd_orders * efd_orders * math.pi * math.pi)
+    print('normalized distances:', normalized_distances.numpy())
+    print('efd_orders:', efd_orders.numpy())
+    normalized_distances_for_order = torch.dot(normalized_distances * efd_orders)
+    d_cos_phi_n = torch.cos(normalized_distances_for_order[1:]) - torch.cos(normalized_distances_for_order[:-1])
+    d_sin_phi_n = torch.sin(normalized_distances_for_order[1:]) - torch.sin(normalized_distances_for_order[:-1])
+    coefficient_a_for_order = const * torch.sum((distances_between_nodes[:, 0] / positive_distances) * d_cos_phi_n)
+    coefficient_b_for_order = const * torch.sum((distances_between_nodes[:, 0] / positive_distances) * d_sin_phi_n)
+    coefficient_c_for_order = const * torch.sum((distances_between_nodes[:, 1] / positive_distances) * d_cos_phi_n)
+    coefficient_d_for_order = const * torch.sum((distances_between_nodes[:, 1] / positive_distances) * d_sin_phi_n)
+
+    efd_coefficients = torch.stack((coefficient_a_for_order,
+                                   coefficient_b_for_order,
+                                   coefficient_c_for_order,
+                                   coefficient_d_for_order))
+    print('efd coeffs:', efd_coefficients.numpy())
+
+    return efd_coefficients

model/loss_function.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+
+def elliptic_fourier_descriptors(contour, order=2, normalize=False):
+    """Calculate elliptical Fourier descriptors for a contour.
+    :param numpy.ndarray contour: A contour array of size ``[M x 2]``.
+    :param int order: The order of Fourier coefficients to calculate.
+    :param bool normalize: If the coefficients should be normalized;
+        see references for details.
+    :return: A ``[order x 4]`` array of Fourier coefficients.
+    :rtype: :py:class:`numpy.ndarray`
+    """
+    dxy = np.diff(contour, axis=0)
+
+    dt = dxy ** 2
+    dt = dt.sum(axis=1)
+    dt = np.sqrt(dt)
+
+    t = np.cumsum(dt)
+    t = np.concatenate([([0.]), t])
+    T = t[-1]
+
+    phi = (2 * np.pi * t) / T
+    coeffs = np.zeros((order, 4))
+
+    order = 1
+    for n in range(1, order + 1):
+        const = T / (2 * n * n * np.pi * np.pi)
+        phi_n = phi * n
+        print('phi_n:', phi_n)
+        d_cos_phi_n = np.cos(phi_n[1:]) - np.cos(phi_n[:-1])
+        d_sin_phi_n = np.sin(phi_n[1:]) - np.sin(phi_n[:-1])
+        a_n = const * np.sum((dxy[:, 0] / dt) * d_cos_phi_n)
+        b_n = const * np.sum((dxy[:, 0] / dt) * d_sin_phi_n)
+        c_n = const * np.sum((dxy[:, 1] / dt) * d_cos_phi_n)
+        d_n = const * np.sum((dxy[:, 1] / dt) * d_sin_phi_n)
+
+    coeffs[n - 1, :] = a_n, b_n, c_n, d_n
+    # print('pyefd coeffs:', coeffs)
+
+    return coeffs

model/pytorch_efd.py

@@ -0,0 +1,52 @@
+import unittest
+
+import torch
+from deep_geometry import vectorizer as gv
+
+from model.loss_function import loss_function
+
+
+class TestLossFunction(unittest.TestCase):
+    def test_loss_function(self):
+        geom1 = 'POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))'
+        geom2 = 'POLYGON((1 1, 0 1, 0 0, 1 0, 1 1))'
+        geom_extra_node = 'POLYGON((0 0, 1 0, 1 1, 0 1, 0 0.5, 0 0))'
+
+        diamond = 'POLYGON((1 0, 2 1, 1 2, 0 1, 1 0))'
+
+        test_square = gv.vectorize_wkt(geom1)
+        test_square = torch.from_numpy(test_square)
+
+        test_square_extra_node = gv.vectorize_wkt(geom_extra_node)
+        test_square_extra_node = torch.from_numpy(test_square_extra_node)
+
+        output_square = gv.vectorize_wkt(geom2)
+        output_square = torch.from_numpy(output_square)
+
+        test_diamond = gv.vectorize_wkt(diamond)
+        test_diamond = torch.from_numpy(test_diamond)
+
+        with self.subTest('It accepts only tensors of length 7 on the second axis'):
+            loss_function(test_square, output_square)
+
+        with self.subTest('It returns a tensor'):
+            loss = loss_function(test_square, output_square)
+            self.assertEqual(type(loss).__name__, 'Tensor')
+
+        with self.subTest('It returns a loss of 0 for geometries that are really identical'):
+            loss = loss_function(test_square, test_square)
+            loss = loss.numpy()
+            self.assertEqual(loss, 0.)
+
+        with self.subTest('It returns a loss of 0 for geometries that are almost identical'):
+            loss = loss_function(test_square, output_square)
+            loss = loss.numpy()
+            self.assertEqual(loss, 0.)
+
+        with self.subTest('It returns a non-zero tensor for non-identical geometries'):
+            loss = loss_function(test_square, test_diamond)
+            loss = loss.numpy()
+            self.assertGreater(loss, 0.)
+
+        # with self.subTest('It returns a zero or almost zero loss for a set of same squares where one has an extra node'):
+        #     loss = loss_function(test_square, test_square_extra_node)

model/stand_in_efd.py

@@ -0,0 +1,31 @@
+import unittest
+
+import torch
+from deep_geometry import vectorizer as gv
+
+from model.stand_in_efd import elliptic_fourier_descriptors
+from model.pytorch_efd import efd
+
+
+class TestEllipticFourierDescriptor(unittest.TestCase):
+    def test_efd(self):
+        geom1 = 'POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))'
+        geom1 = gv.vectorize_wkt(geom1)
+
+        geom2 = 'POLYGON((1 1, 0 1, 0 0, 1 0, 1 1))'
+        geom_extra_node = 'POLYGON((0 0, 1 0, 1 1, 0 1, 0 0.5, 0 0))'
+
+        reference_descriptors = elliptic_fourier_descriptors(geom1[:, :2]).flatten().tolist()
+
+        with self.subTest('It does not accept a numpy ndarray'):
+            with self.assertRaises(AssertionError):
+                efd(geom1)
+
+        with self.subTest('It creates an elliptic fourier descriptor of a geometry, the same as pyefd creates'):
+            polygon_tensor = geom1[:, :2]
+            polygon_tensor = torch.from_numpy(polygon_tensor)
+
+            our_descriptors = efd(polygon_tensor).numpy()
+
+            print('torch efd:', our_descriptors)
+            self.assertListEqual(reference_descriptors, our_descriptors)