chore: be closer to our template

README.md

@@ -1,3 +1,47 @@
 ---
 license: apache-2.0
 ---
+
+# Template for Concrete ML
+
+Concrete ML is Zama's open-source privacy-preserving ML package, based on fully homomorphic encryption (FHE). We refer the reader to fhe.org or Zama's websites for more information on FHE.
+
+This directory is used:
+- by ML practicioners, to create Concrete ML FHE-friendly models, and make them available to HF users
+- by companies, institutions or people to deploy those models over HF inference endpoints
+- by developers, to use these entry points to make applications on privacy-preserving ML
+
+## Creating models and making them available on HF
+
+This is quite easy. Fork this template (maybe use this experimental tool https://huggingface.co/spaces/huggingface-projects/repo_duplicator for that), and then:
+- install everything with: `pip install -r requirements.txt`
+- edit `creating_models.py`, and fill the part between "# BEGIN: insert your ML task here" and
+"# END: insert your ML task here"
+- run the python file: `python creating_models.py`
+
+At the end, if the script is successful, you'll have your compiled model ready in `compiled_model`. Now you can commit and push your repository (with in particular `compiled_model`, `handler.py`, `play_with_endpoint.py` and `requirements.txt`, but you can include the other files as well).
+
+We recommend you to tag your Concrete ML compiled repository with `Concrete ML FHE friendly` tag, such that people can find them easily.
+
+## Deploying a compiled model on HF inference endpoint
+
+If you find an `Concrete ML FHE friendly` repository that you would like to deploy, it is very easy.
+- click on 'Deploy' button in HF interface
+- chose "Inference endpoints"
+- chose the right model repository
+- (the rest of the options are classical to HF end points; we refer you to their documentation for more information)
+and then click on 'Create endpoint'
+
+And now, your model should be deployed, after few secunds of installation.
+
+## Using HF entry points on privacy-preserving models
+
+Now, this is the final step: using the entry point. You should:
+- if your inference endpoint is private, set an environment variable HF_TOKEN with your HF token
+- edit `play_with_endpoint.py`
+- replace `API_URL` by your entry point URL
+- replace the part between "# BEGIN: replace this part with your privacy-preserving application" and
+"# END: replace this part with your privacy-preserving application" with your application
+
+Finally, you'll be able to launch your application with `python play_with_endpoint.py`.
+

compiled_model/client.zip

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

compiled_model/server.zip

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

create_zipfiles_and_check_local_endpoint.py

@@ -1,73 +0,0 @@
-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
-
-# 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": encrypted_inputs,
-        "evaluation_keys": evaluation_keys,
-    }
-
-    # Run the inference on HF servers
-    encrypted_prediction = my_handler(payload)
-    encrypted_prediction = 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}")

creating_models.py

@@ -0,0 +1,37 @@
+import shutil
+import sys
+from pathlib import Path
+
+from concrete.ml.deployment import FHEModelDev
+from concrete.ml.deployment import FHEModelClient
+
+
+def compile_and_make_it_deployable(model_dev, X_train):
+
+    path_to_model = Path("compiled_model")
+
+    # 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)
+
+
+# BEGIN: insert your ML task here
+# Typically
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+from concrete.ml.sklearn import LogisticRegression
+
+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)
+
+model_dev = LogisticRegression()
+model_dev.fit(X_train, y_train)
+# END: insert your ML task here
+
+compile_and_make_it_deployable(model_dev, X_train)
+print("Your model is ready to be deployable.")

handler.py

@@ -49,6 +49,17 @@ class EndpointHandler:
 
             return {"uid": uid}
 
+        elif method == "append_key":
+
+            # Get key piece
+            evaluation_keys = from_json(data.pop("evaluation_keys", data))
+
+            uid = data.pop("uid", data)
+
+            self.key_database[uid] += evaluation_keys
+
+            return
+
         elif method == "inference":
 
             uid = data.pop("uid", data)

play_with_endpoint.py

@@ -53,21 +53,56 @@ fhemodel_client.generate_private_and_evaluation_keys()
 evaluation_keys = fhemodel_client.get_serialized_evaluation_keys()
 
 # Save the key in the database
-payload = {
-    "inputs": "fake",
-    "evaluation_keys": to_json(evaluation_keys),
-    "method": "save_key",
-}
-
-uid = query(payload)["uid"]
-print(f"Storing the key in the database under {uid=}")
+evaluation_keys_remaining = evaluation_keys[:]
+uid = None
+is_first = True
+is_finished = False
+i = 0
+packet_size = 1024 * 1024 * 100
+
+while not is_finished:
+
+    # Send by packets of 100M
+    if sys.getsizeof(evaluation_keys_remaining) > packet_size:
+        evaluation_keys_piece = evaluation_keys_remaining[:packet_size]
+        evaluation_keys_remaining = evaluation_keys_remaining[packet_size:]
+    else:
+        evaluation_keys_piece = evaluation_keys_remaining
+        is_finished = True
+
+    print(
+        f"Sending {i}-th piece of the key (remaining size is {sys.getsizeof(evaluation_keys_remaining) / 1024:.2f} kbytes)"
+    )
+    i += 1
+
+    if is_first:
+        is_first = False
+        payload = {
+            "inputs": "fake",
+            "evaluation_keys": to_json(evaluation_keys_piece),
+            "method": "save_key",
+        }
+
+        uid = query(payload)["uid"]
+        print(f"Storing the key in the database under {uid=}")
+
+    else:
+        payload = {
+            "inputs": "fake",
+            "evaluation_keys": to_json(evaluation_keys_piece),
+            "method": "append_key",
+            "uid": uid,
+        }
+
+        query(payload)
 
 # Test the handler
 nb_good = 0
 nb_samples = len(X_test)
-verbose = False
+verbose = True
 time_start = time.time()
 duration = 0
+is_first = True
 
 for i in range(nb_samples):
 
@@ -82,8 +117,9 @@ for i in range(nb_samples):
         "uid": uid,
     }
 
-    if verbose or True:
-        print(f"Size of the payload: {sys.getsizeof(payload) / 1024} kilobytes")
+    if is_first:
+        print(f"Size of the payload: {sys.getsizeof(payload) / 1024:.2f} kilobytes")
+        is_first = False
 
     # Run the inference on HF servers
     duration -= time.time()
@@ -98,7 +134,7 @@ for i in range(nb_samples):
     prediction_proba = fhemodel_client.deserialize_decrypt_dequantize(encrypted_prediction)[0]
     prediction = np.argmax(prediction_proba)
 
-    if verbose or True:
+    if verbose:
         print(
             f"for {i}-th input, {prediction=} with expected {Y_test[i]} in {duration_inference:.3f} seconds"
         )
@@ -107,6 +143,5 @@ for i in range(nb_samples):
     nb_good += Y_test[i] == prediction
 
 print(f"Accuracy on {nb_samples} samples is {nb_good * 1. / nb_samples}")
-print(f"Total time: {time.time() - time_start} seconds")
-print(f"Duration in inferences: {duration} seconds")
-print(f"Duration per inference: {duration / nb_samples} seconds")
+print(f"Total time: {time.time() - time_start:.3f} seconds")
+print(f"Duration per inference: {duration / nb_samples:.3f} seconds")