ML (Classes)

FHELogisticRegression¶

Demonstrates the FHELogisticRegression class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHELogisticRegression
import numpy as np

model = FHELogisticRegression(weights=[1, 2], bias=1)
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHELogisticRegression: all inputs were skipped'
print(f'FHELogisticRegression model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHELogisticRegression import numpy as np model = FHELogisticRegression(weights=[1, 2], bias=1) inputset = [[1, 2], [0, 0]] model.compile(inputset) _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHELogisticRegression: all inputs were skipped' print(f'FHELogisticRegression model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHELinearRegression¶

Demonstrates the FHELinearRegression class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHELinearRegression
import numpy as np

model = FHELinearRegression(weights=[1, 2], bias=1)
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHELinearRegression: all inputs were skipped'
print(f'FHELinearRegression model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHELinearRegression import numpy as np model = FHELinearRegression(weights=[1, 2], bias=1) inputset = [[1, 2], [0, 0]] model.compile(inputset) _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHELinearRegression: all inputs were skipped' print(f'FHELinearRegression model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHEDecisionTree¶

Demonstrates the FHEDecisionTree class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHEDecisionTree
import numpy as np

model = FHEDecisionTree(tree={'feature': 0, 'threshold': 1, 'left': 0, 'right': 1})
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHEDecisionTree: all inputs were skipped'
print(f'FHEDecisionTree model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHEDecisionTree import numpy as np model = FHEDecisionTree(tree={'feature': 0, 'threshold': 1, 'left': 0, 'right': 1}) inputset = [[1, 2], [0, 0]] model.compile(inputset) _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHEDecisionTree: all inputs were skipped' print(f'FHEDecisionTree model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHEPCA¶

Demonstrates the FHEPCA class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHEPCA
model = FHEPCA(components=[[1, 0], [0, 1]], means=[0, 0])
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
import numpy as np

_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHEPCA: all inputs were skipped'
print(f'FHEPCA model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHEPCA model = FHEPCA(components=[[1, 0], [0, 1]], means=[0, 0]) inputset = [[1, 2], [0, 0]] model.compile(inputset) import numpy as np _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHEPCA: all inputs were skipped' print(f'FHEPCA model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHECNN¶

Demonstrates the FHECNN class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHECNN
model = FHECNN(filters=[[[[1]]]], bias=[0])
inputset = [[[[[1]]]], [[[[0]]]]]
model.compile(inputset)
import numpy as np

_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHECNN: all inputs were skipped'
print(f'FHECNN model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHECNN model = FHECNN(filters=[[[[1]]]], bias=[0]) inputset = [[[[[1]]]], [[[[0]]]]] model.compile(inputset) import numpy as np _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHECNN: all inputs were skipped' print(f'FHECNN model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHERandomForest¶

Demonstrates the FHERandomForest class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHERandomForest
import numpy as np

model = FHERandomForest(trees=[{'feature': 0, 'threshold': 1, 'left': 0, 'right': 1}])
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHERandomForest: all inputs were skipped'
print(f'FHERandomForest model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHERandomForest import numpy as np model = FHERandomForest(trees=[{'feature': 0, 'threshold': 1, 'left': 0, 'right': 1}]) inputset = [[1, 2], [0, 0]] model.compile(inputset) _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHERandomForest: all inputs were skipped' print(f'FHERandomForest model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHEXGBoost¶

Demonstrates the FHEXGBoost class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHEXGBoost
import numpy as np

model = FHEXGBoost(trees=[{'feature': 0, 'threshold': 1, 'left': 0, 'right': 1}])
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHEXGBoost: all inputs were skipped'
print(f'FHEXGBoost model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHEXGBoost import numpy as np model = FHEXGBoost(trees=[{'feature': 0, 'threshold': 1, 'left': 0, 'right': 1}]) inputset = [[1, 2], [0, 0]] model.compile(inputset) _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHEXGBoost: all inputs were skipped' print(f'FHEXGBoost model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHESVM¶

Demonstrates the FHESVM class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHESVM
import numpy as np

model = FHESVM(weights=[1, 2], bias=1)
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHESVM: all inputs were skipped'
print(f'FHESVM model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHESVM import numpy as np model = FHESVM(weights=[1, 2], bias=1) inputset = [[1, 2], [0, 0]] model.compile(inputset) _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHESVM: all inputs were skipped' print(f'FHESVM model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHEKNN¶

Demonstrates the FHEKNN class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHEKNN
model = FHEKNN(X_train=[[0, 0], [1, 1], [0, 1]], y_train=[0, 1, 0], k=1)
inputset = [[0, 0], [1, 1]]
model.compile(inputset)
import numpy as np

_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHEKNN: all inputs were skipped'
print(f'FHEKNN model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHEKNN model = FHEKNN(X_train=[[0, 0], [1, 1], [0, 1]], y_train=[0, 1, 0], k=1) inputset = [[0, 0], [1, 1]] model.compile(inputset) import numpy as np _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHEKNN: all inputs were skipped' print(f'FHEKNN model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHEMLP¶

Demonstrates the FHEMLP class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHEMLP
model = FHEMLP([([[1, 1]], [0])])
inputset = [[1, 1], [0, 0]]
model.compile(inputset)
import numpy as np

_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHEMLP: all inputs were skipped'
print(f'FHEMLP model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHEMLP model = FHEMLP([([[1, 1]], [0])]) inputset = [[1, 1], [0, 0]] model.compile(inputset) import numpy as np _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHEMLP: all inputs were skipped' print(f'FHEMLP model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHENaiveBayes¶

Demonstrates the FHENaiveBayes class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHENaiveBayes
model = FHENaiveBayes([[[0, 1], [0, 1]], [[1, 0], [1, 0]]], [0, 0])
inputset = [[0, 0], [1, 1]]
model.compile(inputset)
import numpy as np

_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHENaiveBayes: all inputs were skipped'
print(f'FHENaiveBayes model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHENaiveBayes model = FHENaiveBayes([[[0, 1], [0, 1]], [[1, 0], [1, 0]]], [0, 0]) inputset = [[0, 0], [1, 1]] model.compile(inputset) import numpy as np _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHENaiveBayes: all inputs were skipped' print(f'FHENaiveBayes model compiled and tested successfully! ({_successes}/{len(inputset)})')

---

FHENaiveBayesTrainer¶

Demonstrates the FHENaiveBayesTrainer class. Runs fit_encrypted in simulation mode to train an encrypted model.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHENaiveBayesTrainer
import numpy as np

trainer = FHENaiveBayesTrainer()
X_train = [[1], [3]]
y_train = [0, 1]
try:
    model = trainer.fit_encrypted(X_train, y_train)
    print('FHENaiveBayesTrainer executed successfully!')
except Exception as e:
    print(f'Execution failed: {e}')

from concrete_fhe_toolkit.ml.classes import FHENaiveBayesTrainer import numpy as np trainer = FHENaiveBayesTrainer() X_train = [[1], [3]] y_train = [0, 1] try: model = trainer.fit_encrypted(X_train, y_train) print('FHENaiveBayesTrainer executed successfully!') except Exception as e: print(f'Execution failed: {e}')

---

FHEKMeans¶

Demonstrates the FHEKMeans class. Compiles and tests its simulate vs predict logic.

In [ ]:

from concrete_fhe_toolkit.ml.classes import FHEKMeans
import numpy as np

model = FHEKMeans(centroids=[[1, 1], [3, 3]], max_distance=10)
inputset = [[1, 2], [0, 0]]
model.compile(inputset)
_successes = 0
for inp in inputset:
    try:
        expected = model.simulate(inp)
        fhe_res = model.predict(inp)
        if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'):
            np.testing.assert_array_equal(fhe_res, expected)
        else:
            assert int(fhe_res) == int(expected)
    except AssertionError:
        raise
    except Exception as e:
        print(f'Skipping {inp} due to bounds or other error: {e}')
    else:
        _successes += 1
assert _successes > 0, 'FHEKMeans: all inputs were skipped'
print(f'FHEKMeans model compiled and tested successfully! ({_successes}/{len(inputset)})')

from concrete_fhe_toolkit.ml.classes import FHEKMeans import numpy as np model = FHEKMeans(centroids=[[1, 1], [3, 3]], max_distance=10) inputset = [[1, 2], [0, 0]] model.compile(inputset) _successes = 0 for inp in inputset: try: expected = model.simulate(inp) fhe_res = model.predict(inp) if isinstance(expected, (list, np.ndarray)) or hasattr(expected, '__iter__'): np.testing.assert_array_equal(fhe_res, expected) else: assert int(fhe_res) == int(expected) except AssertionError: raise except Exception as e: print(f'Skipping {inp} due to bounds or other error: {e}') else: _successes += 1 assert _successes > 0, 'FHEKMeans: all inputs were skipped' print(f'FHEKMeans model compiled and tested successfully! ({_successes}/{len(inputset)})')

---