lightphe 0.0.11__tar.gz → 0.0.12__tar.gz

{lightphe-0.0.11 → lightphe-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.11
+Version: 0.0.12
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -23,6 +23,7 @@ License-File: LICENSE
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
 [![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+[![Hacker News](https://img.shields.io/badge/dynamic/json?color=orange&label=Hacker%20News&query=score&url=https%3A%2F%2Fhacker-news.firebaseio.com%2Fv0%2Fitem%2F43024283.json&logo=y-combinator)](https://news.ycombinator.com/item?id=43024283)
 <!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
@@ -267,7 +268,7 @@ _2G = G + G
 _3G = _2G + G
 _5G = _3G + _2G
 
-_20G = 4 * G
+_20G = 4 * _5G
 _19G = _20G - G
 ```
 

{lightphe-0.0.11 → lightphe-0.0.12}/README.md

@@ -7,6 +7,7 @@
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
 [![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+[![Hacker News](https://img.shields.io/badge/dynamic/json?color=orange&label=Hacker%20News&query=score&url=https%3A%2F%2Fhacker-news.firebaseio.com%2Fv0%2Fitem%2F43024283.json&logo=y-combinator)](https://news.ycombinator.com/item?id=43024283)
 <!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
@@ -251,7 +252,7 @@ _2G = G + G
 _3G = _2G + G
 _5G = _3G + _2G
 
-_20G = 4 * G
+_20G = 4 * _5G
 _19G = _20G - G
 ```
 

{lightphe-0.0.11 → lightphe-0.0.12}/lightphe/__init__.py

@@ -1,6 +1,12 @@
 # built-in dependencies
+import time
 import json
 from typing import Optional, Union, List
+import multiprocessing
+from contextlib import closing
+
+# 3rd party dependencies
+from tqdm import tqdm
 
 # project dependencies
 from lightphe.models.Homomorphic import Homomorphic
@@ -30,7 +36,7 @@ from lightphe.elliptic_curve_forms.koblitz import Koblitz
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.11"
+VERSION = "0.0.12"
 
 
 class LightPHE:
@@ -209,46 +215,49 @@ class LightPHE:
             encrypted tensor (list of encrypted tensor object)
         """
         encrypted_tensor: List[Fraction] = []
-        for m in tensor:
-            if isinstance(m, int):
-                dividend_encrypted = self.cs.encrypt(
-                    plaintext=(m % self.cs.plaintext_modulo) * pow(10, self.precision)
-                )
-                abs_dividend_encrypted = self.cs.encrypt(
-                    plaintext=(abs(m) % self.cs.plaintext_modulo)
-                    * pow(10, self.precision)
-                )
-                divisor_encrypted = self.cs.encrypt(plaintext=pow(10, self.precision))
-                c = Fraction(
-                    dividend=dividend_encrypted,
-                    divisor=divisor_encrypted,
-                    abs_dividend=abs_dividend_encrypted,
-                    sign=1 if m >= 0 else -1,
-                )
-            elif isinstance(m, float):
-                dividend, divisor = phe_utils.fractionize(
-                    value=(m % self.cs.plaintext_modulo),
-                    modulo=self.cs.plaintext_modulo,
-                    precision=self.precision,
-                )
-                abs_dividend, _ = phe_utils.fractionize(
-                    value=(abs(m) % self.cs.plaintext_modulo),
-                    modulo=self.cs.plaintext_modulo,
-                    precision=self.precision,
-                )
-                dividend_encrypted = self.cs.encrypt(plaintext=dividend)
-                abs_dividend_encrypted = self.cs.encrypt(plaintext=abs_dividend)
-                divisor_encrypted = self.cs.encrypt(plaintext=divisor)
-                c = Fraction(
-                    dividend=dividend_encrypted,
-                    divisor=divisor_encrypted,
-                    abs_dividend=abs_dividend_encrypted,
-                    sign=1 if m >= 0 else -1,
+
+        encrypted_zero = self.cs.encrypt(plaintext=0)
+        divisor_encrypted = self.cs.encrypt(plaintext=10**self.precision)
+        is_positive_tensor = all(m >= 0 for m in tensor)
+
+        num_workers = min(len(tensor), 2 * multiprocessing.cpu_count())
+        logger.debug(f"encrypting tensors in {num_workers} parallel")
+
+        with closing(multiprocessing.Pool(num_workers)) as pool:
+            funclist = []
+
+            for m in tensor:
+                f = pool.apply_async(
+                    encrypt_something,
+                    (
+                        m,
+                        divisor_encrypted,
+                        self.cs,
+                        self.precision,
+                        encrypted_zero,
+                        is_positive_tensor,
+                    ),
                 )
-            else:
-                raise ValueError(f"unimplemented type - {type(m)}")
-            encrypted_tensor.append(c)
-        return EncryptedTensor(fractions=encrypted_tensor, cs=self.cs)
+                funclist.append(f)
+
+            tic = time.time()
+            encrypted_tensor = []
+            for f in tqdm(
+                funclist,
+                desc="Encrypting tensors",
+                disable=True if len(tensor) < 100 else False,
+            ):
+                result = f.get(timeout=10)
+                encrypted_tensor.append(result)
+
+            toc = time.time()
+            logger.debug(f"encryption took {toc - tic} seconds")
+
+            return EncryptedTensor(
+                fractions=encrypted_tensor,
+                cs=self.cs,
+                precision=self.precision,
+            )
 
     def __decrypt_tensors(
         self, encrypted_tensor: EncryptedTensor
@@ -356,6 +365,74 @@ class LightPHE:
         )
 
 
+def encrypt_something(
+    m: Union[int, float],
+    divisor_encrypted,
+    cs: Homomorphic,
+    precision: int,
+    encrypted_zero: int,
+    is_positive_tensor: bool,
+) -> Fraction:
+    if m == 0:
+        # this is very common in VGG-Face embeddings
+        c = Fraction(
+            dividend=encrypted_zero,
+            divisor=divisor_encrypted,
+            abs_dividend=encrypted_zero,
+            sign=0,
+        )
+    elif isinstance(m, int):
+        dividend_encrypted = cs.encrypt(
+            plaintext=(m % cs.plaintext_modulo) * pow(10, precision)
+        )
+        abs_dividend_encrypted = (
+            dividend_encrypted
+            if is_positive_tensor
+            else cs.encrypt(
+                plaintext=(abs(m) % cs.plaintext_modulo) * pow(10, precision)
+            )
+        )
+        # divisor_encrypted = self.cs.encrypt(plaintext=pow(10, self.precision))
+        c = Fraction(
+            dividend=dividend_encrypted,
+            divisor=divisor_encrypted,
+            abs_dividend=abs_dividend_encrypted,
+            sign=1 if m >= 0 else -1,
+        )
+    elif isinstance(m, float):
+        dividend, _ = phe_utils.fractionize(
+            value=(m % cs.plaintext_modulo),
+            modulo=cs.plaintext_modulo,
+            precision=precision,
+        )
+        abs_dividend = (
+            dividend
+            if is_positive_tensor
+            else phe_utils.fractionize(
+                value=(abs(m) % cs.plaintext_modulo),
+                modulo=cs.plaintext_modulo,
+                precision=precision,
+            )[0]
+        )
+        dividend_encrypted = cs.encrypt(plaintext=dividend)
+        abs_dividend_encrypted = (
+            dividend_encrypted
+            if is_positive_tensor
+            else cs.encrypt(plaintext=abs_dividend)
+        )
+        # divisor_encrypted = self.cs.encrypt(plaintext=_divisor)
+        c = Fraction(
+            dividend=dividend_encrypted,
+            divisor=divisor_encrypted,
+            abs_dividend=abs_dividend_encrypted,
+            sign=1 if m >= 0 else -1,
+        )
+    else:
+        raise ValueError(f"unimplemented type - {type(m)}")
+
+    return c
+
+
 class ECC:
     __version__ = VERSION
 

{lightphe-0.0.11 → lightphe-0.0.12}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -46,8 +46,8 @@ class EllipticCurveElGamal(Homomorphic):
         self.ecc = ECC(form_name=form, curve_name=curve)
 
         self.keys = keys or self.generate_keys(key_size or self.ecc.n.bit_length())
-        self.keys["public_key"]["form"] = form
-        self.keys["private_key"]["form"] = form
+        self.keys["curve"] = curve
+        self.keys["form"] = form
         self.plaintext_modulo = self.ecc.modulo
         self.ciphertext_modulo = self.ecc.modulo
 

{lightphe-0.0.11 → lightphe-0.0.12}/lightphe/models/Tensor.py

@@ -1,6 +1,7 @@
 from typing import Union, List
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons import phe_utils
+from lightphe.models.Ciphertext import Ciphertext
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="lightphe/models/Tensor.py")
@@ -43,15 +44,22 @@ class EncryptedTensor:
     Class to store encrypted tensor objects
     """
 
-    def __init__(self, fractions: List[Fraction], cs: Homomorphic):
+    def __init__(
+        self,
+        fractions: List[Fraction],
+        cs: Homomorphic,
+        precision: int = 5,
+    ):
         """
         Initialization method
         Args:
             fractions (list): list of fractions storing individual encrypted tensor items
-            cs: cryptosystem
+            cs (cryptosystem): built cryptosystem
+            precision (int): precision of the tensor
         """
         self.fractions = fractions
         self.cs = cs
+        self.precision = precision
 
     def __str__(self):
         """
@@ -68,7 +76,41 @@ class EncryptedTensor:
         """
         return self.__str__()
 
-    def __mul__(self, other: Union["EncryptedTensor", int, float]) -> "EncryptedTensor":
+    def __matmul__(self, other: Union["EncryptedTensor", list]):
+        """
+        Perform dot product of two encrypted tensors
+        """
+        if not (
+            (isinstance(other, EncryptedTensor) and isinstance(self, list))
+            or (isinstance(other, list) and isinstance(self, EncryptedTensor))
+        ):
+            raise ValueError(
+                "Dot product can be run for EncryptedTensor and List of float / int"
+            )
+
+        encrypted_tensor = self.__mul__(other=other)
+
+        sum_dividend = cast_ciphertext(
+            cs=self.cs, value=encrypted_tensor.fractions[0].abs_dividend
+        )
+        divisor = cast_ciphertext(
+            cs=self.cs, value=encrypted_tensor.fractions[0].divisor
+        )
+        for fraction in encrypted_tensor.fractions[1:]:
+            sum_dividend += cast_ciphertext(value=fraction.abs_dividend, cs=self.cs)
+
+        fraction = Fraction(
+            dividend=sum_dividend.value,
+            abs_dividend=sum_dividend.value,
+            divisor=divisor.value,
+            sign=1,
+        )
+
+        return EncryptedTensor(fractions=[fraction], cs=self.cs)
+
+    def __mul__(
+        self, other: Union["EncryptedTensor", int, float, list]
+    ) -> "EncryptedTensor":
         """
         Perform homomorphic element-wise multipliction on tensors
         or multiplication of an encrypted tensor with a constant
@@ -112,6 +154,52 @@ class EncryptedTensor:
                 fractions.append(fraction)
 
             return EncryptedTensor(fractions=fractions, cs=self.cs)
+        elif isinstance(other, list):
+            # perform element-wise multiplication of encrypted tensor with plain tensor
+            if len(self.fractions) != len(other):
+                raise ValueError(
+                    "Tensor sizes must be equal in homomorphic multiplication"
+                )
+
+            if any(i < 0 for i in other) or any(
+                fraction.sign < 0 for fraction in self.fractions
+            ):
+                raise ValueError(
+                    "all items in the plain and encrypted tensor must be positive"
+                    " to perform element wise multiplication"
+                )
+
+            dividends = []
+            divisor = None
+            for alpha, beta in zip(self.fractions, other):
+                c_abs_dividend, c_divisor = phe_utils.fractionize(
+                    value=(abs(beta) % self.cs.plaintext_modulo),
+                    modulo=self.cs.plaintext_modulo,
+                    precision=self.precision,
+                )
+
+                dividend = (
+                    cast_ciphertext(cs=self.cs, value=alpha.abs_dividend)
+                    * c_abs_dividend
+                )
+
+                if divisor is None:
+                    divisor = (
+                        cast_ciphertext(cs=self.cs, value=alpha.divisor) * c_divisor
+                    )
+
+                # dividends.append(dividend)
+                dividends.append(
+                    Fraction(
+                        dividend=dividend.value,
+                        abs_dividend=dividend.value,
+                        divisor=divisor.value,
+                        sign=1,
+                    )
+                )
+
+            return EncryptedTensor(fractions=dividends, cs=self.cs)
+
         elif isinstance(other, (int, float)):
             constant_sign = 1 if other >= 0 else -1
             other = abs(other)
@@ -142,15 +230,17 @@ class EncryptedTensor:
                 "Encrypted tensor can be multiplied by an encrypted tensor or constant"
             )
 
-    def __rmul__(self, constant: Union[int, float]) -> "EncryptedTensor":
+    def __rmul__(
+        self, multiplier: Union[int, float, "EncryptedTensor"]
+    ) -> "EncryptedTensor":
         """
-        Perform multiplication of encrypted tensor with a constant
+        Perform multiplication of encrypted tensor with a constant or plain tensor (element-wise)
         Args:
-            constant: scalar value
+            multiplier: scalar value
         Returns:
             encrypted tensor
         """
-        return self.__mul__(other=constant)
+        return self.__mul__(other=multiplier)
 
     def __add__(self, other: "EncryptedTensor") -> "EncryptedTensor":
         """
@@ -201,3 +291,13 @@ class EncryptedTensor:
             current_tensors.append(current_tensor)
 
         return EncryptedTensor(fractions=current_tensors, cs=self.cs)
+
+
+def cast_ciphertext(cs: Homomorphic, value: int) -> Ciphertext:
+    return Ciphertext(
+        algorithm_name=cs.__class__.__name__,
+        keys=cs.keys,
+        value=value,
+        form=cs.keys.get("form"),
+        curve=cs.keys.get("curve"),
+    )

{lightphe-0.0.11 → lightphe-0.0.12}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.11
+Version: 0.0.12
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -23,6 +23,7 @@ License-File: LICENSE
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
 [![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+[![Hacker News](https://img.shields.io/badge/dynamic/json?color=orange&label=Hacker%20News&query=score&url=https%3A%2F%2Fhacker-news.firebaseio.com%2Fv0%2Fitem%2F43024283.json&logo=y-combinator)](https://news.ycombinator.com/item?id=43024283)
 <!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
@@ -267,7 +268,7 @@ _2G = G + G
 _3G = _2G + G
 _5G = _3G + _2G
 
-_20G = 4 * G
+_20G = 4 * _5G
 _19G = _20G - G
 ```
 

lightphe-0.0.12/lightphe.egg-info/requires.txt

@@ -0,0 +1,3 @@
+sympy==1.12
+pytest==7.1.2
+tqdm

lightphe-0.0.11/lightphe.egg-info/requires.txt → lightphe-0.0.12/requirements.txt

@@ -1,2 +1,3 @@
 sympy==1.12
 pytest==7.1.2
+tqdm

{lightphe-0.0.11 → lightphe-0.0.12}/setup.py

@@ -8,7 +8,7 @@ with open("requirements.txt", "r", encoding="utf-8") as f:
 
 setuptools.setup(
     name="lightphe",
-    version="0.0.11",
+    version="0.0.12",
     author="Sefik Ilkin Serengil",
     author_email="serengil@gmail.com",
     description="A Lightweight Partially Homomorphic Encryption Library for Python",

{lightphe-0.0.11 → lightphe-0.0.12}/tests/test_tensors.py

@@ -1,9 +1,14 @@
-import pytest
+# built-in dependencies
 from typing import List
+import random
+
+# 3rd party dependencies
+import pytest
+
+# project dependencies
 from lightphe.commons import phe_utils
-from lightphe.models.Tensor import EncryptedTensor, Fraction
+from lightphe.models.Tensor import EncryptedTensor
 from lightphe import LightPHE
-
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="tests/test_tensors.py")
@@ -11,6 +16,7 @@ logger = Logger(module="tests/test_tensors.py")
 THRESHOLD = 1
 
 
+# pylint: disable=consider-using-enumerate
 def convert_negative_float_to_int(value: float, modulo: int) -> float:
     x, y = phe_utils.fractionize(
         value=value % modulo,
@@ -109,7 +115,9 @@ def test_homomorphic_multiply_with_int_constant():
     for i, restored_tensor in enumerate(t2):
         assert abs((t1[i] * constant) - restored_tensor) < THRESHOLD
 
-    logger.info("✅ Homomorphic multiplication with an integer constant tests succeeded")
+    logger.info(
+        "✅ Homomorphic multiplication with an integer constant tests succeeded"
+    )
 
 
 def test_homomorphic_multiply_with_positive_float_constant():
@@ -126,7 +134,9 @@ def test_homomorphic_multiply_with_positive_float_constant():
     for i, restored_tensor in enumerate(t2):
         assert abs((t1[i] * constant) - restored_tensor) < THRESHOLD
 
-    logger.info("✅ Homomorphic multiplication with a positive float constant tests succeeded")
+    logger.info(
+        "✅ Homomorphic multiplication with a positive float constant tests succeeded"
+    )
 
 
 def test_homomorphic_multiply_with_negative_float_constant():
@@ -143,7 +153,9 @@ def test_homomorphic_multiply_with_negative_float_constant():
     for i, restored_tensor in enumerate(t2):
         assert abs((t1[i] * constant) - restored_tensor) < THRESHOLD
 
-    logger.info("✅ Homomorphic multiplication with a positive float constant tests succeeded")
+    logger.info(
+        "✅ Homomorphic multiplication with a positive float constant tests succeeded"
+    )
 
 
 def test_homomorphic_addition():
@@ -160,10 +172,16 @@ def test_homomorphic_addition():
     restored_tensors = cs.decrypt(c3)
 
     for i, restored_tensor in enumerate(restored_tensors):
-        if (t1[i] >= 0 and t2[i] >= 0) or (t1[i] < 0 and t2[i] < 0) or (t1[i] + t2[i] >= 0):
+        if (
+            (t1[i] >= 0 and t2[i] >= 0)
+            or (t1[i] < 0 and t2[i] < 0)
+            or (t1[i] + t2[i] >= 0)
+        ):
             assert abs((t1[i] + t2[i]) - restored_tensor) < THRESHOLD
         elif t1[i] + t2[i] < 0:
-            expected = convert_negative_float_to_int(t1[i] + t2[i], cs.cs.plaintext_modulo)
+            expected = convert_negative_float_to_int(
+                t1[i] + t2[i], cs.cs.plaintext_modulo
+            )
             assert abs(expected - restored_tensor) < THRESHOLD
         else:
             raise ValueError("else must not be called at all")
@@ -172,3 +190,72 @@ def test_homomorphic_addition():
         _ = c1 * c2
 
     logger.info("✅ Homomorphic addition tests succeeded")
+
+
+def test_for_integer_tensor():
+    cs = LightPHE(algorithm_name="Paillier")
+
+    # suppose that these are normalized vectors
+    a = [7.1, 5.2, 5.3, 2.4, 3.5, 4.6]
+    b = [5.6, 3.7, 2.8, 4, 0, 5.9]
+
+    expected_similarity = sum(x * y for x, y in zip(a, b))
+
+    enc_a = cs.encrypt(a)
+
+    fractions = enc_a.fractions
+
+    # we expect to have same divisor for all items
+    for fraction in fractions[1:]:
+        assert fractions[0].divisor == fraction.divisor
+
+    enc_a_times_b = enc_a * b
+
+    a_times_b = cs.decrypt(enc_a_times_b)
+
+    for i in range(0, len(a)):
+        assert (
+            abs(a[i] * b[i] - a_times_b[i]) < 0.1
+        ), f"Expected {a[i] * b[i]}, got {a_times_b[i]}"
+
+    # dot product
+    encrypted_similarity = enc_a @ b
+    decrypted_similarity = cs.decrypt(encrypted_similarity)[0]
+
+    assert (
+        abs(decrypted_similarity - expected_similarity) < 0.1
+    ), f"expected {expected_similarity} but got {decrypted_similarity}"
+
+    logger.info("✅ Integer tensor tests succeeded")
+
+
+def test_real_world_embedding():
+    cs = LightPHE(algorithm_name="Paillier")
+
+    # suppose that source and target embeddings are normalized vectors
+
+    source_embedding = [float(format(random.uniform(1, 2), ".17f")) for _ in range(128)]
+    logger.info(f"source image's embedding found - {len(source_embedding)}D")
+
+    source_embedding_encrypted = cs.encrypt(source_embedding)
+    logger.info("source embedding encrypted")
+
+    target_embedding = [float(format(random.uniform(1, 2), ".17f")) for _ in range(128)]
+    logger.info(f"target image's embedding found - {len(target_embedding)}D")
+
+    # dot product to calculate encrypted similarity
+    encrypted_similarity = source_embedding_encrypted @ target_embedding
+
+    decrypted_similarity = cs.decrypt(encrypted_similarity)[0]
+
+    expected_similarity = sum(x * y for x, y in zip(source_embedding, target_embedding))
+
+    logger.info(
+        f"ℹ️ expected similarity: {expected_similarity}, got {decrypted_similarity}"
+    )
+
+    assert (
+        abs(expected_similarity - decrypted_similarity) < 0.1
+    ), f"expected {expected_similarity} but got {decrypted_similarity}"
+
+    logger.info("✅ Real world embedding test succeeded")

lightphe-0.0.11/requirements.txt

@@ -1,2 +0,0 @@
-sympy==1.12
-pytest==7.1.2