Upload 6 files

compiled_model/client.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf41c99b06817bd28d64c681a4294ca4e910e95c0b07837374420643bcec50f7
+size 7496

compiled_model/server.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20941390f0eb4c8ac177344a9e5dbdafc93d99c01d16c6ebdb2b3d278fecc36b
+size 1258

compiled_model/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.9.15"}

create_zipfiles_and_check_local_endpoint.py

@@ -0,0 +1,85 @@
+from handler import EndpointHandler
+import numpy as np
+import shutil
+
+from pathlib import Path
+
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+from concrete.ml.sklearn import LogisticRegression
+from concrete.ml.deployment import FHEModelClient, FHEModelDev
+
+
+def to_json(python_object):
+    if isinstance(python_object, bytes):
+        return {"__class__": "bytes", "__value__": list(python_object)}
+    raise TypeError(repr(python_object) + " is not JSON serializable")
+
+
+def from_json(python_object):
+    if "__class__" in python_object:
+        return bytes(python_object["__value__"])
+
+
+# Fit a model. In the future, we should find an existing model on HF repository
+path_to_model = Path("compiled_model")
+do_training_and_compilation = True
+
+x, y = make_classification(n_samples=1000, class_sep=2, n_features=30, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)
+
+if do_training_and_compilation:
+    model_dev = LogisticRegression()
+    model_dev.fit(X_train, y_train)
+
+    # Compile into FHE
+    model_dev.compile(X_train)
+
+    # Saving the model
+    shutil.rmtree(path_to_model, ignore_errors=True)
+    fhemodel_dev = FHEModelDev(path_to_model, model_dev)
+    fhemodel_dev.save(via_mlir=True)
+
+# Init the handler (compilation of the model is done on HF side)
+my_handler = EndpointHandler(path=".")
+
+# Recover parameters for client side
+fhemodel_client = FHEModelClient(path_to_model)
+
+# Generate the keys
+fhemodel_client.generate_private_and_evaluation_keys()
+evaluation_keys = fhemodel_client.get_serialized_evaluation_keys()
+
+# Test the handler
+nb_good = 0
+nb_samples = len(X_test)
+verbose = False
+
+for i in range(nb_samples):
+
+    # Quantize the input and encrypt it
+    encrypted_inputs = fhemodel_client.quantize_encrypt_serialize([X_test[i]])
+
+    # Prepare the payload, including the evaluation keys which are needed server side
+    payload = {
+        "inputs": "fake",
+        "encrypted_inputs": to_json(encrypted_inputs),
+        "evaluation_keys": to_json(evaluation_keys),
+    }
+
+    # Run the inference on HF servers
+    encrypted_prediction = my_handler(payload)
+    encrypted_prediction = from_json(encrypted_prediction)
+
+    # Decrypt the result and dequantize
+    prediction_proba = fhemodel_client.deserialize_decrypt_dequantize(encrypted_prediction)[0]
+    prediction = np.argmax(prediction_proba)
+
+    if verbose:
+        print(f"for i-th input, {prediction=} with expected {y_test[i]}")
+
+    # Measure accuracy
+    nb_good += y_test[i] == prediction
+
+print(f"Accuracy on {nb_samples} samples is {nb_good * 1. / nb_samples}")

handler.py

@@ -17,10 +17,10 @@ def to_json(python_object):
 
 
 class EndpointHandler:
-    def __init__(self, path="benoit.model"):
+    def __init__(self, path=""):
 
         # For server
-        self.fhemodel_server = FHEModelServer(path)
+        self.fhemodel_server = FHEModelServer(path + "/compiled_model")
 
     def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
         """