Upload 8 files

From https://huggingface.co/zama-fhe/concrete-ml-template-alpha/tree/main, with a DT for spam detection

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

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

compiled_model/server.zip

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

compiled_model/versions.json

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

creating_models.py

@@ -0,0 +1,80 @@
+import shutil
+from pathlib import Path
+
+from concrete.ml.deployment import FHEModelDev
+
+
+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)
+
+
+# This is the spam classifier. Taken from https://github.com/zama-ai/concrete-ml/blob/main/docs/advanced_examples/DecisionTreeClassifier.ipynb
+import numpy
+from sklearn.datasets import fetch_openml
+from sklearn.model_selection import train_test_split
+
+features, classes = fetch_openml(data_id=44, as_frame=False, cache=True, return_X_y=True)
+classes = classes.astype(numpy.int64)
+
+x_train, x_test, y_train, y_test = train_test_split(
+    features,
+    classes,
+    test_size=0.15,
+    random_state=42,
+)
+
+# Find best hyper parameters with cross validation
+from sklearn.model_selection import GridSearchCV
+from concrete.ml.sklearn import DecisionTreeClassifier as ConcreteDecisionTreeClassifier
+
+# List of hyper parameters to tune
+param_grid = {
+    "max_features": [None],
+    "min_samples_leaf": [10],
+    "min_samples_split": [100],
+    "max_depth": [None],
+}
+
+grid_search = GridSearchCV(
+    ConcreteDecisionTreeClassifier(),
+    param_grid,
+    cv=10,
+    scoring="average_precision",
+    error_score="raise",
+    n_jobs=1,
+)
+
+gs_results = grid_search.fit(x_train, y_train)
+print("Best hyper parameters:", gs_results.best_params_)
+print("Best score:", gs_results.best_score_)
+
+# Build the model with best hyper parameters
+model_dev = ConcreteDecisionTreeClassifier(
+    max_features=gs_results.best_params_["max_features"],
+    min_samples_leaf=gs_results.best_params_["min_samples_leaf"],
+    min_samples_split=gs_results.best_params_["min_samples_split"],
+    max_depth=gs_results.best_params_["max_depth"],
+    n_bits=6,
+)
+model_dev = model_dev.fit(x_train, y_train)
+
+# Compute average precision on test
+from sklearn.metrics import average_precision_score
+
+# pylint: disable=no-member
+y_pred_concrete = model_dev.predict_proba(x_test)[:, 1]
+concrete_average_precision = average_precision_score(y_test, y_pred_concrete)
+
+print(f"Concrete average precision score: {concrete_average_precision:0.2f}")
+
+compile_and_make_it_deployable(model_dev, x_train)
+print("Your model is ready to be deployable.")

handler.py

@@ -0,0 +1,41 @@
+from typing import Dict, List, Any
+import numpy as np
+from concrete.ml.deployment import FHEModelServer
+
+
+def from_json(python_object):
+    if "__class__" in python_object:
+        return bytes(python_object["__value__"])
+
+
+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")
+
+
+class EndpointHandler:
+    def __init__(self, path=""):
+
+        # For server
+        self.fhemodel_server = FHEModelServer(path + "/compiled_model")
+
+    def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+         data args:
+              inputs (:obj: `str`)
+              date (:obj: `str`)
+        Return:
+              A :obj:`list` | `dict`: will be serialized and returned
+        """
+
+        # Get inputs
+        encrypted_inputs = from_json(data.pop("encrypted_inputs", data))
+
+        # Get keys
+        evaluation_keys = from_json(data.pop("evaluation_keys", data))
+
+        # Run CML prediction
+        encrypted_prediction = self.fhemodel_server.run(encrypted_inputs, evaluation_keys)
+
+        return to_json(encrypted_prediction)

play_with_endpoint.py

@@ -0,0 +1,97 @@
+import numpy as np
+import time
+import os, sys
+
+from pathlib import Path
+
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+from concrete.ml.deployment import FHEModelClient
+
+import requests
+
+
+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__"])
+
+
+# TODO: put the right link `API_URL` for your entryp point
+API_URL = "https://puqif7goarh132kl.us-east-1.aws.endpoints.huggingface.cloud"
+headers = {
+    "Authorization": "Bearer " + os.environ.get("HF_TOKEN"),
+    "Content-Type": "application/json",
+}
+
+
+def query(payload):
+    response = requests.post(API_URL, headers=headers, json=payload)
+    return response.json()
+
+
+path_to_model = Path("compiled_model")
+
+# BEGIN: replace this part with your privacy-preserving application
+x, y = make_classification(n_samples=1000, class_sep=2, n_features=30, random_state=42)
+_, X_test, _, y_test = train_test_split(x, y, test_size=0.2, random_state=42)
+
+# 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
+time_start = time.time()
+duration = 0
+is_first = True
+
+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
+    duration -= time.time()
+    encrypted_prediction = query(payload)
+    duration += time.time()
+
+    encrypted_prediction = from_json(encrypted_prediction)
+
+    if is_first:
+        is_first = False
+        print(f"Size of the payload: {sys.getsizeof(payload)} bytes")
+
+    # Decrypt the result and dequantize
+    prediction_proba = fhemodel_client.deserialize_decrypt_dequantize(encrypted_prediction)[0]
+    prediction = np.argmax(prediction_proba)
+
+    if verbose or True:
+        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}")
+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")
+# END: replace this part with your privacy-preserving application

requirements.txt

@@ -0,0 +1 @@
+concrete-ml==1.3.0