add some function

Author: ackness

README.md

@@ -1,2 +1,98 @@
 # clifford_algebra_pytorch
 Simple pytorch implement to compute basic Clifford algebra (Geometric algebra) operation.
+
+## Usage
+
+### Use ga.GA
+
+```python
+import torch
+from ga import GA
+
+ga = GA(3)
+x = 3 + ga[1] + 2 * ga[2] - 2 * ga[3] + ga[1, 2] - ga[2, 3] + 2.5 * ga[1, 3] - ga[1, 2, 3]
+print(x)
+r = x * (~x) * ga.I
+print(r)
+q = ga.tensor_to_mv(torch.tensor([1, 1, 1, 1]))
+print(q)
+
+# output
+# 3.0 + 1.0*[e1] + 2.0*[e2] + 1.0*[e1,e2] + -2.0*[e3] + 2.5*[e1,e3] + -1.0*[e2,e3] + -1.0*[e1,e2,e3]
+# -15.0*[e1,e2] + -19.0*[e1,e3] + 2.0*[e2,e3] + 27.25*[e1,e2,e3]
+# 1 + 1*[e1] + 1*[e2] + 1*[e1,e2]
+
+```
+
+### Use mv.MultiVector
+
+```python
+from mv import MultiVector
+a = MultiVector(4, device='cpu')
+a.set_values(torch.tensor([1., 1, 2, 3, 4]), torch.tensor([0, 1, 2, 3, 4]))
+b = MultiVector(4, device='cpu')
+b.set_values(torch.tensor([1., -1]), torch.tensor([1, 2]))
+c = MultiVector(4, device='cpu')
+c.set_values(torch.ones(16, dtype=torch.float32), torch.arange(16))
+print(a + b)
+print(a - b)
+print(a * b)
+print(a / 2)
+
+# output
+# 1.0 + 2.0*[e1] + 1.0*[e2] + 3.0*[e1,e2] + 4.0*[e3]
+# 1.0 + 3.0*[e2] + 3.0*[e1,e2] + 4.0*[e3]
+# -1.0 + -2.0*[e1] + -4.0*[e2] + -3.0*[e1,e2] + -4.0*[e1,e3] + 4.0*[e2,e3]
+# 0.5 + 0.5*[e1] + 1.0*[e2] + 1.5*[e1,e2] + 2.0*[e3]
+
+```
+
+### A simple Linear layer using geometry product
+
+```python
+from layers import CFLiner
+bs = 2
+shape = 8
+module = CFLiner(shape, out_channels=4, bias=True)
+input = torch.ones((bs, shape))
+print('\n input \n', input, '\n input shape \n', input.shape)
+output = module(input)
+print('\n output \n', output, '\n output.shape \n',  output.shape)
+
+# output
+#  input 
+#  tensor([[1., 1., 1., 1., 1., 1., 1., 1.],
+#         [1., 1., 1., 1., 1., 1., 1., 1.]]) 
+#  input shape 
+#  torch.Size([2, 8])
+
+#  output 
+#  tensor([[[ 0.0007,  0.0007,  0.0165,  0.0165, -0.0502, -0.0502, -0.0285,
+#           -0.0285],
+#          [-0.0107, -0.0107, -0.0236, -0.0236, -0.0301, -0.0301,  0.0165,
+#            0.0165],
+#          [-0.0160, -0.0160,  0.0046,  0.0046, -0.0592, -0.0592,  0.0104,
+#            0.0104],
+#          [ 0.0799,  0.0799, -0.0691, -0.0691,  0.0050,  0.0050,  0.0024,
+#            0.0024]],
+
+#         [[ 0.0007,  0.0007,  0.0165,  0.0165, -0.0502, -0.0502, -0.0285,
+#           -0.0285],
+#          [-0.0107, -0.0107, -0.0236, -0.0236, -0.0301, -0.0301,  0.0165,
+#            0.0165],
+#          [-0.0160, -0.0160,  0.0046,  0.0046, -0.0592, -0.0592,  0.0104,
+#            0.0104],
+#          [ 0.0799,  0.0799, -0.0691, -0.0691,  0.0050,  0.0050,  0.0024,
+#            0.0024]]], grad_fn=<AddBackward0>) 
+#  output.shape 
+#  torch.Size([2, 4, 8])
+
+```
+
+## Other
+
+
+## Reference
+
+Original vanilla python implement: https://github.com/tdvance/GeometricAlgebra
+

ga.py

@@ -0,0 +1,62 @@
+from numbers import Number
+from mv import MultiVector
+import math
+
+
+class GA:
+    def __init__(self, n):
+        self._dim = n
+
+    @property
+    def n(self):
+        return self._dim
+
+    def scalar(self, s=0.):
+        x = MultiVector(self.n)
+        x[0] = s
+        return x
+
+    def blade(self, coef, *indices):
+        x = self.scalar(coef)
+        for i in indices:
+            y = MultiVector(self.n)
+            y[2 ** (i - 1)] = 1.
+            x *= y
+        return x
+
+    @property
+    def I(self):
+        x = MultiVector(self.n)
+        x[-1] = 1.
+        return x
+
+    def __getitem__(self, index):
+        if isinstance(index, tuple):
+            return self.blade(1., *index)
+        return self.blade(1., index)
+
+    @classmethod
+    def tensor_to_mv(cls, t, dim=None):
+        if dim:
+            shape = dim
+        else:
+            shape = math.ceil(math.sqrt(len(t)))
+        x = MultiVector(dim=shape, data=t)
+        return x
+
+    @classmethod
+    def mv_to_tensor(cls, mv):
+        return mv._data
+
+
+if __name__ == '__main__':
+    import torch
+
+    ga = GA(3)
+    x = 3 + ga[1] + 2 * ga[2] - 2 * ga[3] + ga[1, 2] - ga[2, 3] + 2.5 * ga[1, 3] - ga[1, 2, 3]
+    print(x)
+    r = x * (~x) * ga.I
+    print(r)
+
+    q = ga.tensor_to_mv(torch.tensor([1, 1, 1, 1]))
+    print(q)

layers.py

@@ -0,0 +1,110 @@
+import sys
+import torch
+
+
+def _precalculate_reversion_sign(dim=256):
+    r = []
+    for i in range(dim):
+        a = bin(i).count('1')
+        a = a % 4
+        if a == 2 or a == 3:
+            r.append(-1.)
+        else:
+            r.append(1.)
+    return torch.tensor(r)
+
+
+def _blade_combine(a, b):
+    if a == 0:
+        return b, 1
+    if b == 0:
+        return a, 1
+    c = a ^ b
+    s = 1
+    p = max(a, b)
+    # d = MultiVector._rank(a)
+    d = bin(a).count('1')
+    e = 1
+    while e <= p:
+        if e & a:
+            d -= 1
+        if (d & 1) and (e & b):
+            s = -s
+        e *= 2
+    return c, s
+
+
+def _precalculate_combine(dim=256):
+    rs = torch.zeros((dim, dim), dtype=int)
+    rk = torch.zeros((dim, dim), dtype=int)
+    for i in range(dim):
+        for j in range(dim):
+            k, s = _blade_combine(i, j)
+            rs[i, j] = s
+            rk[i, j] = k
+    return rs, rk
+
+
+class CFLiner(Module):
+    def __init__(self, in_channels=8, out_channels=4, bias=True):
+        '''
+        input shape = [B, SHAPE]
+        if out_channels = N, the output shape will be [B, N, SHAPE]
+        '''
+        super(CFLiner, self).__init__()
+        self.shape = in_channels
+        self.out_channels = out_channels
+        self.use_bias = bias
+        self.weight = torch.nn.Parameter(torch.randn(out_channels, self.shape))
+
+        if self.use_bias:
+            self.bias = torch.nn.Parameter(torch.randn(self.shape))
+
+        self._init_params()
+
+    def _init_params(self):
+        torch.nn.init.normal_(self.weight, 0, 0.01)
+        if self.use_bias:
+            torch.nn.init.zeros_(self.bias)
+
+        # pre-calculate some used tensor
+        rs, rk = _precalculate_combine(self.shape)
+        signs = _precalculate_reversion_sign(self.shape)
+        self.register_buffer('rs', rs)
+        self.register_buffer('rk', rk)
+        self.register_buffer('signs', signs)
+
+    def A_geoProduct_B(self, A, B):
+        # b is weight
+        bs, shape = A.shape
+        R = torch.zeros((bs, self.out_channels, shape), device=A.device)
+        for k in range(self.out_channels):
+            for i in range(self.shape):
+                for j in range(self.shape):
+                    R[:, k, self.rk[i, j]] += A[:, i] * B[k, j] * self.rs[i, j]
+        return R
+
+    def forward(self, input):
+        b, s = input.shape
+        if s != self.shape:
+            sys.exit(f'Wrong Input Features. Please use tensor with {self.shape} Input Features')
+        output = self.A_geoProduct_B(input, self.weight)
+        if self.use_bias:
+            output += self.bias
+        return output
+
+
+if __name__ == '__main__':
+    bs = 2
+    shape = 8
+    module = CFLiner(shape, out_channels=4, bias=True)
+    input = torch.ones((bs, shape))
+    print('\n input \n', input, '\n input shape \n', input.shape)
+    output = module(input)
+    print('\n output \n', output, '\n output.shape \n',  output.shape)
+
+    # from torch.autograd.gradcheck import gradcheck
+    # moduleConv = CFLiner(shape, 3)
+    # input = torch.randn((bs, shape), dtype=torch.double, requires_grad=True)
+    # test = gradcheck(moduleConv, input, eps=1e-2, atol=1e-2)
+    # print("Are the gradients correct: ", test)