Announcing Concrete Numpy v0.9

import concrete.numpy as cnp
import numpy as np

@cnp.compiler({"x": "encrypted"})
def f(x):
    return np.sqrt(x).astype(np.int64)

inputset = [np.random.randint(0, 2 ** 16) for _ in range(100)]
circuit = f.compile(inputset)

assert circuit.encrypt_run_decrypt(400) == 20
assert circuit.encrypt_run_decrypt(10000) == 100
assert circuit.encrypt_run_decrypt(40401) == 201

import concrete.numpy as cnp

@cnp.circuit({"x": "encrypted"})
def circuit(x: cnp.tensor[cnp.uint8, 2, 3]):
    return x + 42

assert (circuit.encrypt_run_decrypt([[1, 2, 3], [4, 5, 6]]) == [[43, 44, 45], [46, 47, 48]]).all()

import concrete.numpy as cnp
import numpy as np

bit_width = 3
sample_size = 1000
p_error = 0.05

@cnp.compiler({"x": "encrypted"})
def function(x):
    return x**2

inputset = [np.random.randint(0, 2**bit_width, size=(sample_size,)) for _ in range(100)]
circuit = function.compile(inputset, enable_unsafe_features=True, virtual=True, p_error=p_error)

sample = np.random.randint(0, 2**bit_width, size=(sample_size,))
output = circuit.encrypt_run_decrypt(sample)

errors = 0
for i in range(sample_size):
    if output[i] != sample[i] ** 2:
        errors += 1

print(f"Expected Errors: {round(sample_size * p_error)}")
print(f"Actual Errors: {errors}")

Expected Errors: 50
Actual Errors: 52

Expected Errors: 50
Actual Errors: 41

Expected Errors: 50
Actual Errors: 48

import concrete.numpy as cnp
import numpy as np

def g(z):
    with cnp.tag("def"):
        a = 120 - z
        b = a // 4
    return b


def f(x):
    with cnp.tag("abc"):
        x = x * 2
        with cnp.tag("foo"):
            y = x + 42
        z = np.sqrt(y).astype(np.int64)

    return g(z + 3) * 2

compiler = cnp.Compiler(f, {"x": "encrypted"})
circuit = compiler.compile(inputset=range(10))

print(circuit)

 %0 = x                            # EncryptedScalar        ∈ [0, 9]
 %1 = 2                            # ClearScalar            ∈ [2, 2]            @ abc
 %2 = multiply(%0, %1)             # EncryptedScalar        ∈ [0, 18]           @ abc
 %3 = 42                           # ClearScalar            ∈ [42, 42]          @ abc.foo
 %4 = add(%2, %3)                  # EncryptedScalar        ∈ [42, 60]          @ abc.foo
 %5 = subgraph(%4)                 # EncryptedScalar        ∈ [6, 7]            @ abc
 %6 = 3                            # ClearScalar            ∈ [3, 3]
 %7 = add(%5, %6)                  # EncryptedScalar        ∈ [9, 10]
 %8 = 120                          # ClearScalar            ∈ [120, 120]        @ def
 %9 = subtract(%8, %7)             # EncryptedScalar        ∈ [110, 111]        @ def
%10 = 4                            # ClearScalar            ∈ [4, 4]            @ def
%11 = floor_divide(%9, %10)        # EncryptedScalar        ∈ [27, 27]          @ def
%12 = 2                            # ClearScalar            ∈ [2, 2]
%13 = multiply(%11, %12)           # EncryptedScalar        ∈ [54, 54]
return %13

Subgraphs:

    %5 = subgraph(%4):

        %0 = input                         # EncryptedScalar          @ abc.foo
        %1 = sqrt(%0)                      # EncryptedScalar        @ abc
        %2 = astype(%1, dtype=int_)        # EncryptedScalar          @ abc
        return %2

import concrete.numpy as cnp
import numpy as np

@cnp.compiler({"x": "encrypted"})
def f(x):
    return np.sin(x)

inputset = range(10)
circuit = f.compile(inputset)

RuntimeError: Function you are trying to compile cannot be converted to MLIR

%0 = x              # EncryptedScalar          ∈ [0, 9]
%1 = sin(%0)        # EncryptedScalar        ∈ [-0.9589242746631385, 0.9893582466233818]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ only integer operations are supported
                                                                                                  /path/to/your/python/file.py:6
return %1

import concrete.numpy as cnp
import numpy as np


@cnp.compiler({"x": "encrypted", "y": "encrypted"})
def f(x, y):
    return x * y


inputset = [(np.random.randint(0, 10), np.random.randint(0, 10)) for _ in range(100)]
circuit = f.compile(inputset, enable_unsafe_features=True, virtual=True)


assert circuit.encrypt_run_decrypt(3, 5) == 15

import concrete.numpy as cnp
import concrete.onnx as connx
import numpy as np


@cnp.compiler({"x": "encrypted"})
def f(x):
    return connx.maxpool(x, kernel_shape=(3,))


inputset = [np.random.randint(0, 10, size=(1, 1, 12)) for _ in range(100)]
circuit = f.compile(inputset, enable_unsafe_features=True, virtual=True)


sample = [[[1, 2, 2, 3, 2, 2, 2, 4, 1, 5, 2, 6]]]
assert (circuit.encrypt_run_decrypt(sample) == [2, 3, 3, 3, 2, 4, 4, 5, 5, 6]).all()

import concrete.numpy as cnp
import concrete.onnx as connx
import numpy as np


@cnp.compiler({"x": "encrypted"})
def f(x):
    return np.expand_dims(x, axis=2)


inputset = [np.random.randint(0, 10, size=(5, 4, 3, 2)) for _ in range(100)]
circuit = f.compile(inputset, enable_unsafe_features=True, virtual=True)


sample = np.random.randint(0, 10, size=(5, 4, 3, 2))
assert circuit.encrypt_run_decrypt(sample).shape == (5, 4, 1, 3, 2)

import concrete.numpy as cnp
import concrete.onnx as connx
import numpy as np


@cnp.compiler({"x": "encrypted"})
def f(x):
    return np.transpose(x, axes=(3, 0, 2, 1))


inputset = [np.random.randint(0, 10, size=(5, 4, 3, 2)) for _ in range(100)]
circuit = f.compile(inputset, enable_unsafe_features=True, virtual=True)


sample = np.random.randint(0, 10, size=(5, 4, 3, 2))
assert circuit.encrypt_run_decrypt(sample).shape == (2, 5, 3, 4)