chore: adding a test with DL

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:c24aec589f5004924933388404ed735703dd743ae5fad0fc1c24f6ab413107ef
+size 30194

compiled_model/server.zip

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

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,191 @@
+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")
+
+    n_bits = 4
+
+    model_dev = compile_torch_model(model_dev, X_train, rounding_threshold_bits=6, p_error=0.1)
+
+    # Accuracy in simulation
+    accs = test_with_concrete(
+        model_dev,
+        test_dataloader,
+        use_sim=True,
+    )
+
+    print(f"Simulated FHE execution for {n_bits} bit model_devwork accuracy: {accs:.2f}")
+
+    # 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
+import time
+
+import numpy as np
+import torch
+import torch.utils
+from sklearn.datasets import load_digits
+from sklearn.model_selection import train_test_split
+from torch import nn
+from torch.utils.data import DataLoader, TensorDataset
+from tqdm import tqdm
+
+from concrete.ml.torch.compile import compile_torch_model
+
+X, y = load_digits(return_X_y=True)
+
+# The sklearn Digits data-set, though it contains digit images, keeps these images in vectors
+# so we need to reshape them to 2D first. The images are 8x8 px in size and monochrome
+X = np.expand_dims(X.reshape((-1, 8, 8)), 1)
+
+X_train, X_test, Y_train, Y_test = train_test_split(
+    X, y, test_size=0.25, shuffle=True, random_state=42
+)
+
+
+class TinyCNN(nn.Module):
+    """A very small CNN to classify the sklearn digits data-set."""
+
+    def __init__(self, n_classes) -> None:
+        """Construct the CNN with a configurable number of classes."""
+        super().__init__()
+
+        # This model_devwork has a total complexity of 1216 MAC
+        self.conv1 = nn.Conv2d(1, 8, 3, stride=1, padding=0)
+        self.conv2 = nn.Conv2d(8, 16, 3, stride=2, padding=0)
+        self.conv3 = nn.Conv2d(16, 32, 2, stride=1, padding=0)
+        self.fc1 = nn.Linear(32, n_classes)
+
+    def forward(self, x):
+        """Run inference on the tiny CNN, apply the decision layer on the reshaped conv output."""
+        x = self.conv1(x)
+        x = torch.relu(x)
+        x = self.conv2(x)
+        x = torch.relu(x)
+        x = self.conv3(x)
+        x = torch.relu(x)
+        x = x.flatten(1)
+        x = self.fc1(x)
+        return x
+
+
+torch.manual_seed(42)
+
+
+def train_one_epoch(model_dev, optimizer, train_loader):
+    # Cross Entropy loss for classification when not using a softmax layer in the model_devwork
+    loss = nn.CrossEntropyLoss()
+
+    model_dev.train()
+    avg_loss = 0
+    for data, target in train_loader:
+        optimizer.zero_grad()
+        output = model_dev(data)
+        loss_model_dev = loss(output, target.long())
+        loss_model_dev.backward()
+        optimizer.step()
+        avg_loss += loss_model_dev.item()
+
+    return avg_loss / len(train_loader)
+
+
+def test_torch(model_dev, test_loader):
+    """Test the model_devwork: measure accuracy on the test set."""
+
+    # Freeze normalization layers
+    model_dev.eval()
+
+    all_y_pred = np.zeros((len(test_loader)), dtype=np.int64)
+    all_targets = np.zeros((len(test_loader)), dtype=np.int64)
+
+    # Iterate over the batches
+    idx = 0
+    for data, target in test_loader:
+        # Accumulate the ground truth labels
+        endidx = idx + target.shape[0]
+        all_targets[idx:endidx] = target.numpy()
+
+        # Run forward and get the predicted class id
+        output = model_dev(data).argmax(1).detach().numpy()
+        all_y_pred[idx:endidx] = output
+
+        idx += target.shape[0]
+
+    # Print out the accuracy as a percentage
+    n_correct = np.sum(all_targets == all_y_pred)
+    print(
+        f"Test accuracy for fp32 weights and activations: "
+        f"{n_correct / len(test_loader) * 100:.2f}%"
+    )
+
+
+def test_with_concrete(quantized_module, test_loader, use_sim):
+    """Test a neural model_devwork that is quantized and compiled with Concrete ML."""
+
+    # Casting the inputs into int64 is recommended
+    all_y_pred = np.zeros((len(test_loader)), dtype=np.int64)
+    all_targets = np.zeros((len(test_loader)), dtype=np.int64)
+
+    # Iterate over the test batches and accumulate predictions and ground truth labels in a vector
+    idx = 0
+    for data, target in tqdm(test_loader):
+        data = data.numpy()
+        target = target.numpy()
+
+        fhe_mode = "simulate" if use_sim else "execute"
+
+        # Quantize the inputs and cast to appropriate data type
+        y_pred = quantized_module.forward(data, fhe=fhe_mode)
+
+        endidx = idx + target.shape[0]
+
+        # Accumulate the ground truth labels
+        all_targets[idx:endidx] = target
+
+        # Get the predicted class id and accumulate the predictions
+        y_pred = np.argmax(y_pred, axis=1)
+        all_y_pred[idx:endidx] = y_pred
+
+        # Update the index
+        idx += target.shape[0]
+
+    # Compute and report results
+    n_correct = np.sum(all_targets == all_y_pred)
+
+    return n_correct / len(test_loader)
+
+
+# Create the tiny CNN with 10 output classes
+N_EPOCHS = 50
+
+# Create a train data loader
+train_dataset = TensorDataset(torch.Tensor(X_train), torch.Tensor(Y_train))
+train_dataloader = DataLoader(train_dataset, batch_size=64)
+
+# Create a test data loader to supply batches for model_devwork evaluation (test)
+test_dataset = TensorDataset(torch.Tensor(X_test), torch.Tensor(Y_test))
+test_dataloader = DataLoader(test_dataset)
+
+# Train the model_devwork with Adam, output the test set accuracy every epoch
+model_dev = TinyCNN(10)
+losses_bits = []
+optimizer = torch.optim.Adam(model_dev.parameters())
+for _ in tqdm(range(N_EPOCHS), desc="Training"):
+    losses_bits.append(train_one_epoch(model_dev, optimizer, train_dataloader))
+
+# 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

@@ -0,0 +1,82 @@
+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")
+
+        # Simulate a database of keys
+        self.key_database = {}
+
+    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 method
+        method = data.pop("method", data)
+
+        if method == "save_key":
+
+            # Get keys
+            evaluation_keys = from_json(data.pop("evaluation_keys", data))
+
+            uid = np.random.randint(2**32)
+
+            while uid in self.key_database.keys():
+                uid = np.random.randint(2**32)
+
+            self.key_database[uid] = evaluation_keys
+
+            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)
+
+            assert uid in self.key_database.keys(), f"{uid} not in DB, {self.key_database.keys()=}"
+
+            # Get inputs
+            encrypted_inputs = from_json(data.pop("encrypted_inputs", data))
+
+            # Find key in the database
+            evaluation_keys = self.key_database[uid]
+
+            # Run CML prediction
+            encrypted_prediction = self.fhemodel_server.run(encrypted_inputs, evaluation_keys)
+
+            return to_json(encrypted_prediction)
+
+        else:
+
+            return

play_with_endpoint.py

@@ -0,0 +1,149 @@
+import numpy as np
+import time
+import os, sys
+
+from pathlib import Path
+
+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 entry point
+API_URL = "https://XXXXXXX.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)
+
+    if "error" in response:
+        assert False, f"Got an error: {response=}"
+
+    return response.json()
+
+
+path_to_model = Path("compiled_model")
+
+# BEGIN: replace this part with your privacy-preserving application
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+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()
+
+# Save the key in the database
+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)})"
+    )
+    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 = True
+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
+    payload = {
+        "inputs": "fake",
+        "encrypted_inputs": to_json(encrypted_inputs),
+        "method": "inference",
+        "uid": uid,
+    }
+
+    if is_first:
+        print(f"Size of the payload: {sys.getsizeof(payload) / 1024} kilobytes")
+        is_first = False
+
+    # Run the inference on HF servers
+    duration -= time.time()
+    duration_inference = -time.time()
+    encrypted_prediction = query(payload)
+    duration += time.time()
+    duration_inference += time.time()
+
+    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]} in {duration_inference:.3f} seconds"
+        )
+
+    # 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:.3f} seconds")
+print(f"Duration per inference: {duration / nb_samples:.3f} seconds")
+# END: replace this part with your privacy-preserving application

requirements.txt

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