From 5f8fd0087dc799d7cb56a0097553bc2877a112fb Mon Sep 17 00:00:00 2001 From: Robin Straub Date: Wed, 5 Apr 2023 15:16:07 +0200 Subject: [PATCH 1/3] docs: add tutorial on svm using linearsvc --- concrete-ml/svm.ipynb | 450 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 450 insertions(+) create mode 100644 concrete-ml/svm.ipynb diff --git a/concrete-ml/svm.ipynb b/concrete-ml/svm.ipynb new file mode 100644 index 0000000..d862a0f --- /dev/null +++ b/concrete-ml/svm.ipynb @@ -0,0 +1,450 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d07c3896", + "metadata": {}, + "source": [ + "# Support Vector Machine (SVM) classification using Concrete-ML\n", + "\n", + "In this tutorial, we will show how to create, train, and evaluate a Support Vector Machine (SVM) model using the Concrete-ML library, an open-source privacy-preserving machine learning framework based on fully homomorphic encryption (FHE).\n", + "\n", + "This tutorial is cut in 2 parts:\n", + "1. A quick setup of a LinearSVC model with Concrete-ML\n", + "2. A more in-depth approach taking a closer look to the concrete-ml specifics\n" + ] + }, + { + "cell_type": "markdown", + "id": "404fb028", + "metadata": {}, + "source": [ + "## Introduction" + ] + }, + { + "cell_type": "markdown", + "id": "d3654d52", + "metadata": {}, + "source": [ + "### Concrete-ML and useful links\n", + "\n", + "> Concrete-ML is an open-source, privacy-preserving, machine learning inference framework based on fully homomorphic encryption (FHE). It enables data scientists without any prior knowledge of cryptography to automatically turn machine learning models into their FHE equivalent, using familiar APIs from Scikit-learn and PyTorch.\n", + "> \n", + "> — [Zama documentation](https://docs.zama.ai/concrete-ml/)\n", + "\n", + "This tutorial does not require extensive knowledge of Concrete-ML. Newcomers might nonetheless be interested in reading some of the introductory sections of the official documentation, such as:\n", + "\n", + "- [What is Concrete-ML](https://docs.zama.ai/concrete-ml/)\n", + "- [Key Concepts](https://docs.zama.ai/concrete-ml/getting-started/concepts)\n", + "\n", + "### Support Vector Machine\n", + "\n", + "SVM is a machine learning algorithm for classification and regression. LinearSVC is an efficient implementation of SVM\n", + "that works best when the data is linearly separable. In this tutorial, we will use the [iris dataset](https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html) which is a common example for demonstrating how to work with SVMs.\n", + "\n", + "Concrete-ML exposes a LinearSVC class which implements the\n", + "[scikit-learn LinearSVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) interface, so you should feel right at home.\n", + "\n", + "### Setup code\n", + "\n", + "Just as in any machine learning project, let's start by importing some libraries and setting the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ea5f1461", + "metadata": {}, + "outputs": [], + "source": [ + "# display visualizations and plots in the notebook itself\n", + "%matplotlib inline\n", + "\n", + "# import numpy and matplotlib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# import the iris dataset from sklearn, as well as some utilities and the LinearSVC for reference\n", + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.svm import LinearSVC as SklearnLinearSVC\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "# import the concrete-ml LinearSVC implementation\n", + "from concrete.ml.sklearn.svm import LinearSVC as ConcreteLinearSVC\n", + "\n", + "# Load the iris dataset and select the first 2 features \n", + "iris = datasets.load_iris()\n", + "\n", + "# Split the dataset into a training and a testing set\n", + "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "id": "12e827d0", + "metadata": {}, + "source": [ + "## Part 1: Train a simple model with Concrete-ML\n", + "\n", + "Let's first start by quickly scaffolding a Concrete-ML LinearSVC code, so we can see how easy and familiar it is.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "88e9b7fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scikit-learn Accuracy: 0.9833\n", + "Concrete-ML Quantized Accuracy: 0.6833\n", + "Concrete-ML FHE Accuracy: 0.6833\n" + ] + } + ], + "source": [ + "# Train a model with scikit-learn LinearSVC, perform prediction and compute the accuracy\n", + "svm_sklearn = SklearnLinearSVC()\n", + "svm_sklearn.fit(X_train, y_train)\n", + "y_pred_sklearn = svm_sklearn.predict(X_test)\n", + "accuracy_sklearn = accuracy_score(y_test, y_pred_sklearn)\n", + "\n", + "# Perform the same steps with the Concrete-ML LinearSVC implementation\n", + "svm_concrete = ConcreteLinearSVC()\n", + "svm_concrete.fit(X_train, y_train)\n", + "y_pred_concrete_clear = svm_concrete.predict(X_test)\n", + "accuracy_concrete_clear = accuracy_score(y_test, y_pred_concrete_clear)\n", + "\n", + "# A circuit needs to be compiled to enable FHE execution\n", + "circuit = svm_concrete.compile(X_train)\n", + "circuit.client.keygen(force=False)\n", + "# Now that a circuit is compiled, the svm_concrete can predict value with FHE\n", + "y_pred_concrete_fhe = svm_concrete.predict(X_test, execute_in_fhe=True)\n", + "accuracy_concrete_fhe = accuracy_score(y_test, y_pred_concrete_fhe)\n", + "\n", + "print(f\"Scikit-learn Accuracy: {accuracy_sklearn:.4f}\")\n", + "print(f\"Concrete-ML Quantized Accuracy: {accuracy_concrete_clear:.4f}\")\n", + "print(f\"Concrete-ML FHE Accuracy: {accuracy_concrete_fhe:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cbf7e0dd", + "metadata": {}, + "source": [ + "### Code explanation\n", + "\n", + "Let's have a more in-depth look at the code.\n", + "\n", + "#### First, we have a regular scikit-learn LinearSVC example.\n", + "\n", + "```python\n", + "# Load the iris dataset and select the first 2 features \n", + "iris = datasets.load_iris()\n", + "\n", + "# Split the dataset into a training and a testing set\n", + "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=42)\n", + "\n", + "# Train a model with scikit-learn LinearSVC, perform prediction and compute the accuracy\n", + "svm_sklearn = SklearnLinearSVC()\n", + "svm_sklearn.fit(X_train, y_train)\n", + "y_pred_sklearn = svm_sklearn.predict(X_test)\n", + "accuracy_sklearn = accuracy_score(y_test, y_pred_sklearn)\n", + "```\n", + "\n", + "Hopefully should not be confused by this, otherwise you may want to read the [official scikit-learn SVM documentation](https://scikit-learn.org/stable/modules/svm.html#svm-classification). \n", + "\n", + "The algorithm can be tweaked with the parameters exposed by the LinearSVC class, refer to the [LinearSVC API documentation](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) as to what can be customized.\n", + "\n", + "#### Second, we have a Concrete-ML implementation,which behaves just like the scikit-learn one.\n", + "\n", + "```python\n", + "# Perform the same steps with the Concrete-ML LinearSVC implementation\n", + "svm_concrete = ConcreteLinearSVC()\n", + "svm_concrete.fit(X_train, y_train)\n", + "y_pred_concrete_clear = svm_concrete.predict(X_test)\n", + "accuracy_concrete_clear = accuracy_score(y_test, y_pred_concrete_clear)\n", + "```\n", + "\n", + "One thing to note here is not only the model is trained using clear data, but the prediction are also performed in a *plain environment*, there is no encryption at this stage.\n", + "\n", + "In order to perform prediction in a FHE environment, the model first has to be compiled into a circuit.\n", + "\n", + "#### Third, the model is compiled to enable FHE execution\n", + "\n", + "```python\n", + "# A circuit needs to be compiled to enable FHE execution\n", + "circuit = svm_concrete.compile(X_train)\n", + "circuit.client.keygen(force=False)\n", + "# Now that a circuit is compiled, the svm_concrete can predict value with FHE\n", + "y_pred_concrete_fhe = svm_concrete.predict(X_test, execute_in_fhe=True)\n", + "accuracy_concrete_fhe = accuracy_score(y_test, y_pred_concrete_fhe)\n", + "```\n", + "\n", + "Now that the model is compiled, computing predictions with FHE is just a matter of passing an `execution_in_fhe` parameter set to `True`.\n", + "\n", + "\n", + "#### Accuracy\n", + "\n", + "Finally, we can measure the accuracy of our 3 different predictions:\n", + "\n", + "```python\n", + "print(f\"Scikit-learn Accuracy: {accuracy_sklearn:.4f}\")\n", + "print(f\"Concrete-ML Clear Accuracy: {accuracy_concrete_clear:.4f}\")\n", + "print(f\"Concrete-ML FHE Accuracy: {accuracy_concrete_fhe:.4f}\")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "51afbfe2", + "metadata": {}, + "source": [ + "### Key takeaways\n", + "\n", + "#### Simplicity of execution\n", + "\n", + "For a high-level use-case, Concrete-ML offers a very similar interface to scikit-learn. The main difference is *a model needs to be compiled to allow execution in FHE*.\n", + "\n", + "#### Model Accuracy\n", + "\n", + "Concrete-ML prediction accuracy is slightly under scikit-learn implementation. This is because of [quantization](https://docs.zama.ai/concrete-ml/advanced-topics/quantization): number precision needs to be fixed-size for the model to be evaluated in FHE. This can be alleviated down to where the accuracy difference is none or negligible.\n", + "\n", + "#### Execution time\n", + "\n", + "The execution is slower with Concrete-ML, especially when compiling the model. Enabling and using encryption indeed uses a lot more resources than training and using a model using plain data. The speed can be increased by *reducing the precision of the data* (understand diminish the fixed-size number precision). Depending on the project, you thus have to choose between:\n", + "\n", + "- a slower model that performs accurate predictions\n", + "- a faster model that performs less accurate predictions" + ] + }, + { + "cell_type": "markdown", + "id": "cdc4c4d2", + "metadata": {}, + "source": [ + "## Part 2: In-Depth model development\n", + "\n", + "A more in-depth approach, showing how to effectively develop with concrete-ml. This will quote and follow the steps of [model development](https://docs.zama.ai/concrete-ml/getting-started/concepts#i.-model-development)\n", + "\n", + "Especially:\n", + "- the effects of quantization and finding the good bit number\n", + "- setup the virtual library to speed up the development workflow\n", + "- use inference to use the model with encrypted data\n", + "\n", + "---\n", + "\n", + "### Step a: training the model\n", + "\n", + "Nothing new under the sun here, we need to train a relevant model for our machine-learning problem. As we relied previously on the Iris example and improving it is outside the scope of this tutorial, we can just take back what we used so far." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80f701f3", + "metadata": {}, + "outputs": [], + "source": [ + "# setup and train a scikit-learn LinearSVC model, just as before\n", + "svm_sklearn = SklearnLinearSVC()\n", + "svm_sklearn.fit(X_train, y_train)\n", + "# predict some test data and measure the model accuracy\n", + "y_pred_sklearn = svm_sklearn.predict(X_test)\n", + "accuracy = accuracy_score(y_test, y_pred_sklearn)\n", + "\n", + "print(f\"Scikit-learn Accuracy: {accuracy_sklearn:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ce2920d8", + "metadata": {}, + "source": [ + "Not too shabby.\n", + "\n", + "### Step b: quantize the model\n", + "\n", + "So far we conveniently avoided most of Concrete-ML specificities for the sake of simplicity. The first Concrete-ML specific step of developping a model is to quantize it, which soberly means to turn the model into an integer equivalent.\n", + "\n", + "Although you are strongly encouraged to read the [Zama introduction to quantization](https://docs.zama.ai/concrete-ml/advanced-topics/quantization), the key takeaway is **a model needs to be reduced to a *discrete*, smaller set in order for the encryption to happen**. Otherwise the data becomes too large to be manipulated in FHE. \n", + "\n", + "As of v0.6.0 the maximum bit size is 8. The lighter the bit size the more efficient the concrete-ml model is. Thus the goal of the quantization step is to find the lowest bit size value that offers an acceptable accuracy, so the model efficiency is maximized." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7d66066", + "metadata": {}, + "outputs": [], + "source": [ + "# compute the accuracy of a n_bit quantized linear ranging from 2 to 8 bits\n", + "for n_bits in range(2, 9):\n", + " svm_concrete = ConcreteLinearSVC(n_bits)\n", + " svm_concrete.fit(X_train, y_train)\n", + " y_pred = svm_concrete.predict(X_test)\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + " print(f\"{n_bits} Bits Quantized Accuracy: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "122bd347", + "metadata": {}, + "source": [ + "### Step c: simulate the model execution\n", + "\n", + "Executing models with FHE can prove to be a slow process, depending on:\n", + "- the data-set size\n", + "- the model itself\n", + "- the hardware executing the model\n", + "\n", + "Concrete-ML allows to simulate FHE model execution using the [virtual library](https://docs.zama.ai/concrete-ml/advanced-topics/compilation#simulation-with-the-virtual-library). This speeds up the development process considerably by avoiding long-running compilation to be repeated every time.\n", + "\n", + "> Testing FHE models on very large data-sets can take a long time. Furthermore, not all models are compatible with FHE constraints out-of-the-box. Simulation using the Virtual Library allows you to execute a model that was quantized, to measure the accuracy it would have in FHE, but also to determine the modifications required to make it FHE compatible.\n", + ">\n", + "> — [Zama documentation](https://docs.zama.ai/concrete-ml/getting-started/concepts#i.-model-development)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74f5bf79", + "metadata": {}, + "outputs": [], + "source": [ + "# import the configuration from concrete-numpy\n", + "from concrete.numpy import Configuration\n", + "\n", + "# define a configuration\n", + "COMPIL_CONFIG_VL = Configuration(\n", + " dump_artifacts_on_unexpected_failures=False,\n", + " enable_unsafe_features=True,\n", + ")\n", + "\n", + "# arbitrarily set the bit size to 8\n", + "n_bits = 8\n", + "svm_concrete = ConcreteLinearSVC(n_bits)\n", + "svm_concrete.fit(X_train, y_train)\n", + "\n", + "# compile the model with virtual lib enabled and with the defined configuration\n", + "circuit = svm_concrete.compile(X_train, use_virtual_lib=True, configuration=COMPIL_CONFIG_VL)\n", + "\n", + "# the model can now be executed with FHE\n", + "y_pred = svm_concrete.predict(X_test, execute_in_fhe=True)\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(f\"{n_bits} Bits FHE Accuracy: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e1721c59", + "metadata": {}, + "source": [ + "*The virtual library enables some unsafe features, so it should understandably not be used for production*\n", + "\n", + "So far so good, the model is compiled and executed much quicker with the virtual library, allowing us to run it with different configurations.\n", + "\n", + "In a more complex scenario, we would want to fine-tune a lot of model parameters, however here for the sake of simplicity we kept the model to its default configuration and are only left to play with the bit size.\n", + "\n", + "We can now put the two previous parts together and make sure our quantized model prediction stay accurate in FHE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b4c9814", + "metadata": {}, + "outputs": [], + "source": [ + "for n_bits in range(2, 9):\n", + " svm_concrete = ConcreteLinearSVC(n_bits)\n", + " svm_concrete.fit(X_train, y_train)\n", + " svm_concrete.compile(X_train, use_virtual_lib=True, configuration=COMPIL_CONFIG_VL) # the model is now compiled\n", + " y_pred = svm_concrete.predict(X_test, execute_in_fhe=True) # the execution is done in FHE\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + " print(f\"{n_bits} Bits Quantized Accuracy: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1785f094", + "metadata": {}, + "source": [ + "The model predictions in FHE (with virtual library) are aligned with the predictions of the plain, quantized model.\n", + "\n", + "We now need to settle for a bit size. Depending on the model use case we might want to favor speed or accuracy. We can consider 2 different use-case of our iris recognition model. One is a \"machine-learning as a service\" model, in which users would request our model to analyze their data. In such a context we might want to favorise speed (thus execution time and reduce computation cost) and select a smaller bitsize, such as 4. On the contrary we can also invision our model as being used by scientists to classify irises, where computation costs are not as much of an issue, but requires the best possible accuracy. This scenario would lead us to select a bitsize to 6, as it is the lowest bitsize that provides the best accuracy (0.9833).\n", + "\n", + "In both scenarios, by putting a little more time in testing and selecting our bitsize, we managed to reduce it from 25% to 50%, avoiding unnecessary computation efforts and speeding up the production model.\n", + "\n", + "### Step d: compile the model\n", + "\n", + "Now that we have selected a relevant bit-size we can compile the model, without virtual lib, so we can use it in production" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "861502da", + "metadata": {}, + "outputs": [], + "source": [ + "# set up and train a 6bit quantized LinearSVC model\n", + "svm_concrete = ConcreteLinearSVC(4)\n", + "svm_concrete.fit(X_train, y_train)\n", + "\n", + "# compile the model and generate a key\n", + "circuit = svm_concrete.compile(X_train)\n", + "circuit.client.keygen(force=False)\n", + "\n", + "# predict the test set to verify the compiled model accuracy\n", + "y_pred = svm_concrete.predict(X_test, execute_in_fhe=True)\n", + "accuracy = accuracy_score(y_test, y_pred)" + ] + }, + { + "cell_type": "markdown", + "id": "00a2461e", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "Setting up FHE with Concrete-ML on a LinearSVC model is very simple, in the regard that Concrete-ML provides an implementation of the [scikit-learn LinearSVC interface](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html). As a matter of fact, a working FHE model can be setup with just a few lines of code.\n", + "\n", + "Setting up a model with FHE benefits nonetheless from some additional work. For LinearSVC models, the main point is to select a relevant bit-size for [quantizing](https://docs.zama.ai/concrete-ml/advanced-topics/quantization) the model. Some additional tools can smooth up the development workflow, such as alleviating the [compilation](https://docs.zama.ai/concrete-ml/advanced-topics/compilation) time by making use of the [virtual library](https://docs.zama.ai/concrete-ml/advanced-topics/compilation#simulation-with-the-virtual-library) \n", + "\n", + "Once the model is carefully trained and quantized, it is ready to be deployed and used in production. Here are some useful links that cover this subject:\n", + "- [Inference in the Cloud](https://docs.zama.ai/concrete-ml/getting-started/cloud) summarize the steps for cloud deployment\n", + "- [Production Deployment](https://docs.zama.ai/concrete-ml/advanced-topics/client_server) offers a high-level view of how to deploy a Concrete-ML model in a client/server setting.\n", + "- [Client Server in Concrete ML](https://github.com/zama-ai/concrete-ml/blob/release/0.6.x/docs/advanced_examples/ClientServer.ipynb) provides a more hands-on approach as another tutorial." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9276e48a9d0a956d5b273cfcf10b090a72953af8 Mon Sep 17 00:00:00 2001 From: Robin Straub Date: Tue, 18 Apr 2023 18:48:24 +0200 Subject: [PATCH 2/3] fix: address @kcelia review --- concrete-ml/svm.ipynb | 616 +++++++++++++++++++++++++++++++----------- 1 file changed, 462 insertions(+), 154 deletions(-) diff --git a/concrete-ml/svm.ipynb b/concrete-ml/svm.ipynb index d862a0f..e4170e1 100644 --- a/concrete-ml/svm.ipynb +++ b/concrete-ml/svm.ipynb @@ -41,7 +41,7 @@ "### Support Vector Machine\n", "\n", "SVM is a machine learning algorithm for classification and regression. LinearSVC is an efficient implementation of SVM\n", - "that works best when the data is linearly separable. In this tutorial, we will use the [iris dataset](https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html) which is a common example for demonstrating how to work with SVMs.\n", + "that works best when the data is linearly separable. In this tutorial, we will use the [pulsar star dataset](https://www.kaggle.com/datasets/colearninglounge/predicting-pulsar-starintermediate) whose goal is to help determine wether a neutron star is a pulsar star.\n", "\n", "Concrete-ML exposes a LinearSVC class which implements the\n", "[scikit-learn LinearSVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) interface, so you should feel right at home.\n", @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "id": "ea5f1461", "metadata": {}, "outputs": [], @@ -62,23 +62,267 @@ "%matplotlib inline\n", "\n", "# import numpy and matplotlib\n", - "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", "\n", "# import the iris dataset from sklearn, as well as some utilities and the LinearSVC for reference\n", "from sklearn import datasets\n", - "from sklearn.model_selection import train_test_split\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.metrics import make_scorer, f1_score\n", "from sklearn.svm import LinearSVC as SklearnLinearSVC\n", "from sklearn.metrics import accuracy_score\n", + "from sklearn.preprocessing import StandardScaler\n", "\n", "# import the concrete-ml LinearSVC implementation\n", - "from concrete.ml.sklearn.svm import LinearSVC as ConcreteLinearSVC\n", + "from concrete.ml.sklearn.svm import LinearSVC as ConcreteLinearSVC" + ] + }, + { + "cell_type": "markdown", + "id": "f17b4d03", + "metadata": {}, + "source": [ + "Let's also define a visualization function that plots the decision boundary over the 2 principal components." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "125ef967", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_decision_boundary(clf, X, y, title='LinearSVC Decision Boundary', xlabel='First Principal Component', ylabel='Second Principal Component'):\n", + " # Perform PCA to reduce the dimensionality to 2\n", + " pca = PCA(n_components=2)\n", + " X_pca = pca.fit_transform(X)\n", + "\n", + " # Create the mesh grid\n", + " x_min, x_max = X_pca[:, 0].min() - 1, X_pca[:, 0].max() + 1\n", + " y_min, y_max = X_pca[:, 1].min() - 1, X_pca[:, 1].max() + 1\n", + " xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02))\n", + "\n", + " # Transform the mesh grid points back to the original feature space\n", + " mesh_points = pca.inverse_transform(np.c_[xx.ravel(), yy.ravel()])\n", + "\n", + " # Make predictions using the classifier\n", + " Z = clf.predict(mesh_points)\n", + " Z = Z.reshape(xx.shape)\n", + "\n", + " # Plot the decision boundary\n", + " fig, ax = plt.subplots()\n", + " ax.contourf(xx, yy, Z, alpha=0.8)\n", + " scatter = ax.scatter(X_pca[:, 0], X_pca[:, 1], c=y, edgecolors='k', marker='o', s=50)\n", + "\n", + " # Calculate the accuracy\n", + " accuracy = accuracy_score(y, clf.predict(X))\n", + "\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + " plt.title(f'{title} (Accuracy: {accuracy:.4f})')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a9646f34", + "metadata": {}, + "source": [ + "We need to import and preprocess the dataset and make some adjustments to it." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "51ff667a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Mean of the integrated profileStandard deviation of the integrated profileExcess kurtosis of the integrated profileSkewness of the integrated profileMean of the DM-SNR curveStandard deviation of the DM-SNR curveExcess kurtosis of the DM-SNR curveSkewness of the DM-SNR curvetarget_class
0121.15625048.3729710.375485-0.0131653.16889618.3993677.44987465.1592980.0
176.96875036.1755570.7128983.3887192.39966617.5709979.414652102.7229750.0
2130.58593853.2295340.133408-0.2972422.74331122.3625538.50836474.0313240.0
3156.39843848.865942-0.215989-0.17129417.471572NaN2.9580667.1978420.0
484.80468836.1176590.8250133.2741252.79013420.6180098.40500876.2911280.0
\n", + "
" + ], + "text/plain": [ + " Mean of the integrated profile \\\n", + "0 121.156250 \n", + "1 76.968750 \n", + "2 130.585938 \n", + "3 156.398438 \n", + "4 84.804688 \n", + "\n", + " Standard deviation of the integrated profile \\\n", + "0 48.372971 \n", + "1 36.175557 \n", + "2 53.229534 \n", + "3 48.865942 \n", + "4 36.117659 \n", + "\n", + " Excess kurtosis of the integrated profile \\\n", + "0 0.375485 \n", + "1 0.712898 \n", + "2 0.133408 \n", + "3 -0.215989 \n", + "4 0.825013 \n", + "\n", + " Skewness of the integrated profile Mean of the DM-SNR curve \\\n", + "0 -0.013165 3.168896 \n", + "1 3.388719 2.399666 \n", + "2 -0.297242 2.743311 \n", + "3 -0.171294 17.471572 \n", + "4 3.274125 2.790134 \n", + "\n", + " Standard deviation of the DM-SNR curve \\\n", + "0 18.399367 \n", + "1 17.570997 \n", + "2 22.362553 \n", + "3 NaN \n", + "4 20.618009 \n", + "\n", + " Excess kurtosis of the DM-SNR curve Skewness of the DM-SNR curve \\\n", + "0 7.449874 65.159298 \n", + "1 9.414652 102.722975 \n", + "2 8.508364 74.031324 \n", + "3 2.958066 7.197842 \n", + "4 8.405008 76.291128 \n", + "\n", + " target_class \n", + "0 0.0 \n", + "1 0.0 \n", + "2 0.0 \n", + "3 0.0 \n", + "4 0.0 " + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get the data\n", + "df = pd.read_csv(\"https://gist.githubusercontent.com/robinstraub/72f1cb27829dba85f49f68210979f561/raw/b9982ae654967028f6f4010bd235d850d38fe25b/pulsar-star-dataset.csv\")\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "074883c5", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the features and labels \n", + "X = df.drop(columns=['target_class'])\n", + "y = df['target_class']\n", + "\n", + "# Replace N/A values with the mean of the respective feature\n", + "X.fillna(X.mean(), inplace=True)\n", + "\n", + "# Split the data into train and test sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", "\n", - "# Load the iris dataset and select the first 2 features \n", - "iris = datasets.load_iris()\n", + "# Scale the data\n", + "scaler = StandardScaler()\n", + "X_train = scaler.fit_transform(X_train)\n", + "X_test = scaler.transform(X_test)\n", "\n", - "# Split the dataset into a training and a testing set\n", - "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=42)" + "# Convert the floating labels to integer labels for both train and test sets\n", + "y_train = y_train.astype(int)\n", + "y_test = y_test.astype(int)" ] }, { @@ -94,110 +338,116 @@ { "cell_type": "code", "execution_count": 5, - "id": "88e9b7fc", + "id": "38613861", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Scikit-learn Accuracy: 0.9833\n", - "Concrete-ML Quantized Accuracy: 0.6833\n", - "Concrete-ML FHE Accuracy: 0.6833\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "# Train a model with scikit-learn LinearSVC, perform prediction and compute the accuracy\n", - "svm_sklearn = SklearnLinearSVC()\n", + "svm_sklearn = SklearnLinearSVC(max_iter=100)\n", "svm_sklearn.fit(X_train, y_train)\n", - "y_pred_sklearn = svm_sklearn.predict(X_test)\n", - "accuracy_sklearn = accuracy_score(y_test, y_pred_sklearn)\n", - "\n", - "# Perform the same steps with the Concrete-ML LinearSVC implementation\n", - "svm_concrete = ConcreteLinearSVC()\n", - "svm_concrete.fit(X_train, y_train)\n", - "y_pred_concrete_clear = svm_concrete.predict(X_test)\n", - "accuracy_concrete_clear = accuracy_score(y_test, y_pred_concrete_clear)\n", - "\n", - "# A circuit needs to be compiled to enable FHE execution\n", - "circuit = svm_concrete.compile(X_train)\n", - "circuit.client.keygen(force=False)\n", - "# Now that a circuit is compiled, the svm_concrete can predict value with FHE\n", - "y_pred_concrete_fhe = svm_concrete.predict(X_test, execute_in_fhe=True)\n", - "accuracy_concrete_fhe = accuracy_score(y_test, y_pred_concrete_fhe)\n", - "\n", - "print(f\"Scikit-learn Accuracy: {accuracy_sklearn:.4f}\")\n", - "print(f\"Concrete-ML Quantized Accuracy: {accuracy_concrete_clear:.4f}\")\n", - "print(f\"Concrete-ML FHE Accuracy: {accuracy_concrete_fhe:.4f}\")" + "# plot the boundary\n", + "plot_decision_boundary(svm_sklearn, X_test, y_test)" ] }, { "cell_type": "markdown", - "id": "cbf7e0dd", + "id": "78a757a2", "metadata": {}, "source": [ - "### Code explanation\n", - "\n", - "Let's have a more in-depth look at the code.\n", - "\n", - "#### First, we have a regular scikit-learn LinearSVC example.\n", - "\n", - "```python\n", - "# Load the iris dataset and select the first 2 features \n", - "iris = datasets.load_iris()\n", - "\n", - "# Split the dataset into a training and a testing set\n", - "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=42)\n", - "\n", - "# Train a model with scikit-learn LinearSVC, perform prediction and compute the accuracy\n", - "svm_sklearn = SklearnLinearSVC()\n", - "svm_sklearn.fit(X_train, y_train)\n", - "y_pred_sklearn = svm_sklearn.predict(X_test)\n", - "accuracy_sklearn = accuracy_score(y_test, y_pred_sklearn)\n", - "```\n", - "\n", "Hopefully should not be confused by this, otherwise you may want to read the [official scikit-learn SVM documentation](https://scikit-learn.org/stable/modules/svm.html#svm-classification). \n", "\n", - "The algorithm can be tweaked with the parameters exposed by the LinearSVC class, refer to the [LinearSVC API documentation](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) as to what can be customized.\n", + "The algorithm can be tweaked with the parameters exposed by the LinearSVC class, refer to the [LinearSVC API documentation](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) as to what can be customized. \n", "\n", - "#### Second, we have a Concrete-ML implementation,which behaves just like the scikit-learn one.\n", - "\n", - "```python\n", + "We plotted the 2 main components of the dataset, however do note that the latter has 8 features so this is a simplified representation." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b2004595", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ "# Perform the same steps with the Concrete-ML LinearSVC implementation\n", - "svm_concrete = ConcreteLinearSVC()\n", + "svm_concrete = ConcreteLinearSVC(max_iter=100, n_bits=8)\n", "svm_concrete.fit(X_train, y_train)\n", - "y_pred_concrete_clear = svm_concrete.predict(X_test)\n", - "accuracy_concrete_clear = accuracy_score(y_test, y_pred_concrete_clear)\n", - "```\n", + "# plot the boundary\n", + "plot_decision_boundary(svm_concrete, X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "id": "05104312", + "metadata": {}, + "source": [ + "The decision boundary is not a straight line anymore and appears \"noisy\", which is caused by the data being quantized. The prediction remains accurate nonetheless. Here the prediction is equal to the scikit-learn implementation, however reducing the bit size can induce a drop in accuracy, as the quantization reduces the data precision.\n", "\n", "One thing to note here is not only the model is trained using clear data, but the prediction are also performed in a *plain environment*, there is no encryption at this stage.\n", "\n", - "In order to perform prediction in a FHE environment, the model first has to be compiled into a circuit.\n", - "\n", - "#### Third, the model is compiled to enable FHE execution\n", - "\n", - "```python\n", + "In order to perform prediction in a FHE environment, the model first has to be compiled into a circuit." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a854f839", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: The generated random seed is not crypto secure\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FHE Accuracy: 0.9765\n" + ] + } + ], + "source": [ "# A circuit needs to be compiled to enable FHE execution\n", "circuit = svm_concrete.compile(X_train)\n", - "circuit.client.keygen(force=False)\n", "# Now that a circuit is compiled, the svm_concrete can predict value with FHE\n", - "y_pred_concrete_fhe = svm_concrete.predict(X_test, execute_in_fhe=True)\n", - "accuracy_concrete_fhe = accuracy_score(y_test, y_pred_concrete_fhe)\n", - "```\n", - "\n", - "Now that the model is compiled, computing predictions with FHE is just a matter of passing an `execution_in_fhe` parameter set to `True`.\n", - "\n", - "\n", - "#### Accuracy\n", - "\n", - "Finally, we can measure the accuracy of our 3 different predictions:\n", + "y_pred = svm_concrete.predict(X_test, fhe=\"execute\")\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "# print the accuracy\n", + "print(f\"FHE Accuracy: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9a4de0e7", + "metadata": {}, + "source": [ + "Now that the model is compiled, computing predictions with FHE is just a matter of passing a `fhe` parameter to `execute`.\n", "\n", - "```python\n", - "print(f\"Scikit-learn Accuracy: {accuracy_sklearn:.4f}\")\n", - "print(f\"Concrete-ML Clear Accuracy: {accuracy_concrete_clear:.4f}\")\n", - "print(f\"Concrete-ML FHE Accuracy: {accuracy_concrete_fhe:.4f}\")\n", - "```" + "Note that the accuracy of the predictions over FHE are the same as over plain (quantized) data -- FHE execution does not alter the model accuracy." ] }, { @@ -213,7 +463,7 @@ "\n", "#### Model Accuracy\n", "\n", - "Concrete-ML prediction accuracy is slightly under scikit-learn implementation. This is because of [quantization](https://docs.zama.ai/concrete-ml/advanced-topics/quantization): number precision needs to be fixed-size for the model to be evaluated in FHE. This can be alleviated down to where the accuracy difference is none or negligible.\n", + "Concrete-ML prediction accuracy can be slightly worse than a regular scikit-learn implementation. This is because of [quantization](https://docs.zama.ai/concrete-ml/advanced-topics/quantization): number precision needs to be fixed-size for the model to be evaluated in FHE. This can be alleviated down to where the accuracy difference is none or negligible (which is the case here with a 8 bit size).\n", "\n", "#### Execution time\n", "\n", @@ -230,7 +480,7 @@ "source": [ "## Part 2: In-Depth model development\n", "\n", - "A more in-depth approach, showing how to effectively develop with concrete-ml. This will quote and follow the steps of [model development](https://docs.zama.ai/concrete-ml/getting-started/concepts#i.-model-development)\n", + "Let's work on a more in-depth approach, showing how to effectively develop with concrete-ml. This will follow the steps of [model development](https://docs.zama.ai/concrete-ml/getting-started/concepts#i.-model-development)\n", "\n", "Especially:\n", "- the effects of quantization and finding the good bit number\n", @@ -241,22 +491,30 @@ "\n", "### Step a: training the model\n", "\n", - "Nothing new under the sun here, we need to train a relevant model for our machine-learning problem. As we relied previously on the Iris example and improving it is outside the scope of this tutorial, we can just take back what we used so far." + "Nothing new under the sun here, we need to train a relevant model for our machine-learning problem. We can just take back what we used so far." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "80f701f3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scikit-learn Accuracy: 0.9769\n" + ] + } + ], "source": [ "# setup and train a scikit-learn LinearSVC model, just as before\n", "svm_sklearn = SklearnLinearSVC()\n", "svm_sklearn.fit(X_train, y_train)\n", "# predict some test data and measure the model accuracy\n", "y_pred_sklearn = svm_sklearn.predict(X_test)\n", - "accuracy = accuracy_score(y_test, y_pred_sklearn)\n", + "accuracy_sklearn = accuracy_score(y_test, y_pred_sklearn)\n", "\n", "print(f\"Scikit-learn Accuracy: {accuracy_sklearn:.4f}\")" ] @@ -274,15 +532,29 @@ "\n", "Although you are strongly encouraged to read the [Zama introduction to quantization](https://docs.zama.ai/concrete-ml/advanced-topics/quantization), the key takeaway is **a model needs to be reduced to a *discrete*, smaller set in order for the encryption to happen**. Otherwise the data becomes too large to be manipulated in FHE. \n", "\n", - "As of v0.6.0 the maximum bit size is 8. The lighter the bit size the more efficient the concrete-ml model is. Thus the goal of the quantization step is to find the lowest bit size value that offers an acceptable accuracy, so the model efficiency is maximized." + "As of v1.0 the maximum bit size is 8. The lighter the bit size the more efficient the concrete-ml model is. Thus the goal of the quantization step is to find the lowest bit size value that offers an acceptable accuracy, so the model efficiency is maximized." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "c7d66066", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2 Bits Quantized Accuracy: 0.9525\n", + "3 Bits Quantized Accuracy: 0.9745\n", + "4 Bits Quantized Accuracy: 0.9745\n", + "5 Bits Quantized Accuracy: 0.9761\n", + "6 Bits Quantized Accuracy: 0.9761\n", + "7 Bits Quantized Accuracy: 0.9769\n", + "8 Bits Quantized Accuracy: 0.9765\n" + ] + } + ], "source": [ "# compute the accuracy of a n_bit quantized linear ranging from 2 to 8 bits\n", "for n_bits in range(2, 9):\n", @@ -293,6 +565,68 @@ " print(f\"{n_bits} Bits Quantized Accuracy: {accuracy:.4f}\")" ] }, + { + "cell_type": "markdown", + "id": "e11c0952", + "metadata": {}, + "source": [ + "We can see that the accuracy increase with the bit size, although it remains quite good even for lower bit sizes.\n", + "\n", + "Let's work on a more objective way of selecting the best n_bit parameter alongside some common parameters for LinearSVC" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d660eceb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters found: {'C': 0.001, 'dual': False, 'n_bits': 2, 'penalty': 'l1'}\n", + "Best F1 score: 0.9413217451878824\n" + ] + } + ], + "source": [ + "svm = ConcreteLinearSVC()\n", + "\n", + "# Define the parameter grid for the grid search\n", + "param_grid = param_grid = [\n", + " {\n", + " 'C': np.logspace(-3, 3, 7),\n", + " 'n_bits': range(2, 9),\n", + " 'penalty': ['l1', 'l2'],\n", + " 'dual': [False, True],\n", + " },\n", + "]\n", + "\n", + "# Use the F1 score as the metric to optimize, as it provides a balanced trade-off between precision and recall\n", + "scorer = make_scorer(f1_score, average='weighted')\n", + "\n", + "# Set up the grid search with the custom scoring function\n", + "grid_search = GridSearchCV(svm, param_grid, scoring=scorer, cv=5, n_jobs=-1)\n", + "\n", + "# Fit the grid search to the data\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "# Print the best parameters found\n", + "print(f\"Best parameters found: {grid_search.best_params_}\")\n", + "\n", + "# Print the best score\n", + "print(f\"Best F1 score: {grid_search.best_score_}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4751c145", + "metadata": {}, + "source": [ + "We now have a model that is a bit less accurate, but way faster. Depending on the use case we might want to favor more accuracy or speed in which case we would select a different scorer." + ] + }, { "cell_type": "markdown", "id": "122bd347", @@ -305,7 +639,7 @@ "- the model itself\n", "- the hardware executing the model\n", "\n", - "Concrete-ML allows to simulate FHE model execution using the [virtual library](https://docs.zama.ai/concrete-ml/advanced-topics/compilation#simulation-with-the-virtual-library). This speeds up the development process considerably by avoiding long-running compilation to be repeated every time.\n", + "Concrete-ML allows simulating FHE model execution using the [virtual library](https://docs.zama.ai/concrete-ml/advanced-topics/compilation#simulation-with-the-virtual-library). This speeds up the development process considerably by avoiding long-running compilation to be repeated every time.\n", "\n", "> Testing FHE models on very large data-sets can take a long time. Furthermore, not all models are compatible with FHE constraints out-of-the-box. Simulation using the Virtual Library allows you to execute a model that was quantized, to measure the accuracy it would have in FHE, but also to determine the modifications required to make it FHE compatible.\n", ">\n", @@ -314,32 +648,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "74f5bf79", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FHE Accuracy with VirtualLib: 0.9489\n" + ] + } + ], "source": [ - "# import the configuration from concrete-numpy\n", - "from concrete.numpy import Configuration\n", - "\n", - "# define a configuration\n", - "COMPIL_CONFIG_VL = Configuration(\n", - " dump_artifacts_on_unexpected_failures=False,\n", - " enable_unsafe_features=True,\n", - ")\n", - "\n", "# arbitrarily set the bit size to 8\n", "n_bits = 8\n", - "svm_concrete = ConcreteLinearSVC(n_bits)\n", + "svm_concrete = ConcreteLinearSVC(n_bits=2, C=0.001, dual=False, penalty='l1')\n", "svm_concrete.fit(X_train, y_train)\n", "\n", "# compile the model with virtual lib enabled and with the defined configuration\n", - "circuit = svm_concrete.compile(X_train, use_virtual_lib=True, configuration=COMPIL_CONFIG_VL)\n", + "circuit = svm_concrete.compile(X_train)\n", "\n", "# the model can now be executed with FHE\n", - "y_pred = svm_concrete.predict(X_test, execute_in_fhe=True)\n", + "y_pred = svm_concrete.predict(X_test, fhe=\"simulate\")\n", "accuracy = accuracy_score(y_test, y_pred)\n", - "print(f\"{n_bits} Bits FHE Accuracy: {accuracy:.4f}\")" + "print(f\"FHE Accuracy with VirtualLib: {accuracy:.4f}\")" ] }, { @@ -349,63 +682,38 @@ "source": [ "*The virtual library enables some unsafe features, so it should understandably not be used for production*\n", "\n", - "So far so good, the model is compiled and executed much quicker with the virtual library, allowing us to run it with different configurations.\n", - "\n", - "In a more complex scenario, we would want to fine-tune a lot of model parameters, however here for the sake of simplicity we kept the model to its default configuration and are only left to play with the bit size.\n", - "\n", - "We can now put the two previous parts together and make sure our quantized model prediction stay accurate in FHE" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8b4c9814", - "metadata": {}, - "outputs": [], - "source": [ - "for n_bits in range(2, 9):\n", - " svm_concrete = ConcreteLinearSVC(n_bits)\n", - " svm_concrete.fit(X_train, y_train)\n", - " svm_concrete.compile(X_train, use_virtual_lib=True, configuration=COMPIL_CONFIG_VL) # the model is now compiled\n", - " y_pred = svm_concrete.predict(X_test, execute_in_fhe=True) # the execution is done in FHE\n", - " accuracy = accuracy_score(y_test, y_pred)\n", - " print(f\"{n_bits} Bits Quantized Accuracy: {accuracy:.4f}\")" + "So far so good, the model is compiled and executed much quicker with the virtual library, allowing us to run it more efficiently in development environments." ] }, { "cell_type": "markdown", - "id": "1785f094", + "id": "0f3bb9e8", "metadata": {}, "source": [ - "The model predictions in FHE (with virtual library) are aligned with the predictions of the plain, quantized model.\n", - "\n", - "We now need to settle for a bit size. Depending on the model use case we might want to favor speed or accuracy. We can consider 2 different use-case of our iris recognition model. One is a \"machine-learning as a service\" model, in which users would request our model to analyze their data. In such a context we might want to favorise speed (thus execution time and reduce computation cost) and select a smaller bitsize, such as 4. On the contrary we can also invision our model as being used by scientists to classify irises, where computation costs are not as much of an issue, but requires the best possible accuracy. This scenario would lead us to select a bitsize to 6, as it is the lowest bitsize that provides the best accuracy (0.9833).\n", - "\n", - "In both scenarios, by putting a little more time in testing and selecting our bitsize, we managed to reduce it from 25% to 50%, avoiding unnecessary computation efforts and speeding up the production model.\n", - "\n", "### Step d: compile the model\n", "\n", - "Now that we have selected a relevant bit-size we can compile the model, without virtual lib, so we can use it in production" + "Now that we have selected a relevant bit size and parameters we can compile the model, without virtual lib, so we can use it in production" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "861502da", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FHE Accuracy without VirtualLib: 0.9489\n" + ] + } + ], "source": [ - "# set up and train a 6bit quantized LinearSVC model\n", - "svm_concrete = ConcreteLinearSVC(4)\n", - "svm_concrete.fit(X_train, y_train)\n", - "\n", - "# compile the model and generate a key\n", - "circuit = svm_concrete.compile(X_train)\n", - "circuit.client.keygen(force=False)\n", - "\n", "# predict the test set to verify the compiled model accuracy\n", - "y_pred = svm_concrete.predict(X_test, execute_in_fhe=True)\n", - "accuracy = accuracy_score(y_test, y_pred)" + "y_pred = svm_concrete.predict(X_test, fhe=\"execute\")\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(f\"FHE Accuracy without VirtualLib: {accuracy:.4f}\")" ] }, { @@ -442,7 +750,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.10.7" } }, "nbformat": 4, From 79189d6dc54b4b378d78e7a1f289b07d17a33058 Mon Sep 17 00:00:00 2001 From: Robin Straub Date: Thu, 20 Apr 2023 12:12:13 +0200 Subject: [PATCH 3/3] fix: address @kcelia second review --- concrete-ml/svm.ipynb | 276 +++++++++++++++++++++++++++++------------- 1 file changed, 189 insertions(+), 87 deletions(-) diff --git a/concrete-ml/svm.ipynb b/concrete-ml/svm.ipynb index e4170e1..fbf2cee 100644 --- a/concrete-ml/svm.ipynb +++ b/concrete-ml/svm.ipynb @@ -7,11 +7,11 @@ "source": [ "# Support Vector Machine (SVM) classification using Concrete-ML\n", "\n", - "In this tutorial, we will show how to create, train, and evaluate a Support Vector Machine (SVM) model using the Concrete-ML library, an open-source privacy-preserving machine learning framework based on fully homomorphic encryption (FHE).\n", + " In this tutorial, we show how to create, train, and evaluate a Support Vector Machine (SVM) model using Concrete-ML library for a classification task.\n", "\n", - "This tutorial is cut in 2 parts:\n", - "1. A quick setup of a LinearSVC model with Concrete-ML\n", - "2. A more in-depth approach taking a closer look to the concrete-ml specifics\n" + "It is cut in 2 parts:\n", + "1. a quick setup of a LinearSVC model with Concrete-ML\n", + "2. a more in-depth approach taking a closer look to the concrete-ml specifics\n" ] }, { @@ -41,19 +41,19 @@ "### Support Vector Machine\n", "\n", "SVM is a machine learning algorithm for classification and regression. LinearSVC is an efficient implementation of SVM\n", - "that works best when the data is linearly separable. In this tutorial, we will use the [pulsar star dataset](https://www.kaggle.com/datasets/colearninglounge/predicting-pulsar-starintermediate) whose goal is to help determine wether a neutron star is a pulsar star.\n", + "that works best when the data is linearly separable. In this tutorial, we use the [pulsar star dataset](https://www.kaggle.com/datasets/colearninglounge/predicting-pulsar-starintermediate) to determine whether a neutron star can be classified as a pulsar star.\n", "\n", "Concrete-ML exposes a LinearSVC class which implements the\n", "[scikit-learn LinearSVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) interface, so you should feel right at home.\n", "\n", "### Setup code\n", "\n", - "Just as in any machine learning project, let's start by importing some libraries and setting the dataset." + "Just as in any machine learning project, some libraries need to be imported." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "ea5f1461", "metadata": {}, "outputs": [], @@ -84,7 +84,7 @@ "id": "f17b4d03", "metadata": {}, "source": [ - "Let's also define a visualization function that plots the decision boundary over the 2 principal components." + "The following code defines a visualization function that plots the decision boundary over the 2 principal components." ] }, { @@ -130,12 +130,12 @@ "id": "a9646f34", "metadata": {}, "source": [ - "We need to import and preprocess the dataset and make some adjustments to it." + "Import and preprocess the dataset and make some adjustments to it." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 3, "id": "51ff667a", "metadata": {}, "outputs": [ @@ -287,7 +287,7 @@ "4 0.0 " ] }, - "execution_count": 20, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -300,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 4, "id": "074883c5", "metadata": {}, "outputs": [], @@ -332,7 +332,7 @@ "source": [ "## Part 1: Train a simple model with Concrete-ML\n", "\n", - "Let's first start by quickly scaffolding a Concrete-ML LinearSVC code, so we can see how easy and familiar it is.\n" + "The following code quickly scaffolds a Concrete-ML LinearSVC code, which should sound familiar.\n" ] }, { @@ -343,7 +343,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -369,7 +369,7 @@ "\n", "The algorithm can be tweaked with the parameters exposed by the LinearSVC class, refer to the [LinearSVC API documentation](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) as to what can be customized. \n", "\n", - "We plotted the 2 main components of the dataset, however do note that the latter has 8 features so this is a simplified representation." + "2 main components of the dataset are plotted, however do note that the latter has 8 features so this is a simplified representation." ] }, { @@ -380,7 +380,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -426,7 +426,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "FHE Accuracy: 0.9765\n" + "FHE Accuracy: 0.9765 (bit width: 17)\n" ] } ], @@ -437,7 +437,7 @@ "y_pred = svm_concrete.predict(X_test, fhe=\"execute\")\n", "accuracy = accuracy_score(y_test, y_pred)\n", "# print the accuracy\n", - "print(f\"FHE Accuracy: {accuracy:.4f}\")" + "print(f\"FHE Accuracy: {accuracy:.4f} (bit width: {circuit.graph.maximum_integer_bit_width()})\")" ] }, { @@ -467,10 +467,7 @@ "\n", "#### Execution time\n", "\n", - "The execution is slower with Concrete-ML, especially when compiling the model. Enabling and using encryption indeed uses a lot more resources than training and using a model using plain data. The speed can be increased by *reducing the precision of the data* (understand diminish the fixed-size number precision). Depending on the project, you thus have to choose between:\n", - "\n", - "- a slower model that performs accurate predictions\n", - "- a faster model that performs less accurate predictions" + "The execution speed can be slower in Concrete-ML, especially during compilation and FHE inference phases, because enabling FHE operations uses more resources than regular inference on plain data. However, the speed can be improved by decreasing the precision of the data and model's weights thanks to the n_bits parameter. But, depending on the project, there is a trade-off between a slower but more accurate model and a faster but less accurate model." ] }, { @@ -480,18 +477,18 @@ "source": [ "## Part 2: In-Depth model development\n", "\n", - "Let's work on a more in-depth approach, showing how to effectively develop with concrete-ml. This will follow the steps of [model development](https://docs.zama.ai/concrete-ml/getting-started/concepts#i.-model-development)\n", + "This is on a more in-depth approach, showing how to effectively develop with concrete-ml. This follows the steps of [model development](https://docs.zama.ai/concrete-ml/getting-started/concepts#i.-model-development)\n", "\n", "Especially:\n", "- the effects of quantization and finding the good bit number\n", - "- setup the virtual library to speed up the development workflow\n", + "- setup the fhe simulation to speed up the development workflow\n", "- use inference to use the model with encrypted data\n", "\n", "---\n", "\n", "### Step a: training the model\n", "\n", - "Nothing new under the sun here, we need to train a relevant model for our machine-learning problem. We can just take back what we used so far." + "Nothing new under the sun here, a relevant model needs to be trained for this machine-learning problem. We can just take back what we used so far." ] }, { @@ -528,41 +525,11 @@ "\n", "### Step b: quantize the model\n", "\n", - "So far we conveniently avoided most of Concrete-ML specificities for the sake of simplicity. The first Concrete-ML specific step of developping a model is to quantize it, which soberly means to turn the model into an integer equivalent.\n", + "So far most of Concrete-ML specificities have conveniently been avoided for the sake of simplicity. The first Concrete-ML specific step of developping a model is to quantize it, which soberly means to turn the model into an integer equivalent.\n", "\n", - "Although you are strongly encouraged to read the [Zama introduction to quantization](https://docs.zama.ai/concrete-ml/advanced-topics/quantization), the key takeaway is **a model needs to be reduced to a *discrete*, smaller set in order for the encryption to happen**. Otherwise the data becomes too large to be manipulated in FHE. \n", + "Although it is strongly encouraged to read the [Zama introduction to quantization](https://docs.zama.ai/concrete-ml/advanced-topics/quantization), the key takeaway is **a model needs to be reduced to a *discrete*, smaller set in order for the encryption to happen**. Otherwise the data becomes too large to be manipulated in FHE. \n", "\n", - "As of v1.0 the maximum bit size is 8. The lighter the bit size the more efficient the concrete-ml model is. Thus the goal of the quantization step is to find the lowest bit size value that offers an acceptable accuracy, so the model efficiency is maximized." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c7d66066", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2 Bits Quantized Accuracy: 0.9525\n", - "3 Bits Quantized Accuracy: 0.9745\n", - "4 Bits Quantized Accuracy: 0.9745\n", - "5 Bits Quantized Accuracy: 0.9761\n", - "6 Bits Quantized Accuracy: 0.9761\n", - "7 Bits Quantized Accuracy: 0.9769\n", - "8 Bits Quantized Accuracy: 0.9765\n" - ] - } - ], - "source": [ - "# compute the accuracy of a n_bit quantized linear ranging from 2 to 8 bits\n", - "for n_bits in range(2, 9):\n", - " svm_concrete = ConcreteLinearSVC(n_bits)\n", - " svm_concrete.fit(X_train, y_train)\n", - " y_pred = svm_concrete.predict(X_test)\n", - " accuracy = accuracy_score(y_test, y_pred)\n", - " print(f\"{n_bits} Bits Quantized Accuracy: {accuracy:.4f}\")" + "As of v1.0 the maximum bit size is 16. The lighter the bit size the more efficient the concrete-ml model is. Thus the goal of the quantization step is to find the lowest bit size value that offers an acceptable accuracy, so the model efficiency is maximized." ] }, { @@ -577,17 +544,144 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 9, "id": "d660eceb", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best parameters found: {'C': 0.001, 'dual': False, 'n_bits': 2, 'penalty': 'l1'}\n", - "Best F1 score: 0.9413217451878824\n" - ] + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
param_n_bitsparam_Cparam_penaltyparam_dualmean_test_score
20.001000l2False0.945603
31.000000l1False0.971102
40.010000l2False0.970423
5100.000000l1False0.973795
6100.000000l2True0.973389
710.000000l2True0.973885
810.000000l2False0.973025
910.000000l2True0.973180
101.000000l2True0.972929
11100.000000l2True0.973612
1210.000000l2True0.973413
13100.000000l2True0.973046
1410.000000l2True0.972835
1510.000000l2True0.973039
1610.000000l2True0.972948
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -597,7 +691,7 @@ "param_grid = param_grid = [\n", " {\n", " 'C': np.logspace(-3, 3, 7),\n", - " 'n_bits': range(2, 9),\n", + " 'n_bits': range(2, 17),\n", " 'penalty': ['l1', 'l2'],\n", " 'dual': [False, True],\n", " },\n", @@ -612,11 +706,21 @@ "# Fit the grid search to the data\n", "grid_search.fit(X_train, y_train)\n", "\n", - "# Print the best parameters found\n", - "print(f\"Best parameters found: {grid_search.best_params_}\")\n", + "# Convert the grid search results into a pandas DataFrame\n", + "results_df = pd.DataFrame(grid_search.cv_results_)\n", + "\n", + "# Define a custom function to highlight a specific row based on n_bits value\n", + "def highlight_row(row, n_bits_value=3, color='green'):\n", + " return ['background-color: {}'.format(color) if row['param_n_bits'] == n_bits_value else '' for _ in row]\n", "\n", - "# Print the best score\n", - "print(f\"Best F1 score: {grid_search.best_score_}\")" + "# Find the best hyperparameter combination for each n_bits value\n", + "best_results = results_df.loc[results_df.groupby('param_n_bits')['mean_test_score'].idxmax()]\n", + "best_results = best_results[['param_n_bits', 'param_C', 'param_penalty', 'param_dual', 'mean_test_score']]\n", + "best_results.reset_index(drop=True, inplace=True)\n", + "best_results_styled = best_results.style.apply(highlight_row, n_bits_value=3, axis=1).hide_index()\n", + "\n", + "# Display the best results DataFrame\n", + "best_results_styled" ] }, { @@ -624,7 +728,7 @@ "id": "4751c145", "metadata": {}, "source": [ - "We now have a model that is a bit less accurate, but way faster. Depending on the use case we might want to favor more accuracy or speed in which case we would select a different scorer." + "Here, n_bits = 3 is the best compromise between latency and performance." ] }, { @@ -639,16 +743,16 @@ "- the model itself\n", "- the hardware executing the model\n", "\n", - "Concrete-ML allows simulating FHE model execution using the [virtual library](https://docs.zama.ai/concrete-ml/advanced-topics/compilation#simulation-with-the-virtual-library). This speeds up the development process considerably by avoiding long-running compilation to be repeated every time.\n", + "Setting up a model in Concrete-ML requires some additional work compared to standard models. For instance, users must select the quantization bit-width for both the model's weight and input data, which can be complex and time-consuming while using real FHE inference. However, Concrete-ML provides an FHE simulation mode that allows users to identify optimal hyper-parameters with the best trade-off between latency and performance.\n", "\n", - "> Testing FHE models on very large data-sets can take a long time. Furthermore, not all models are compatible with FHE constraints out-of-the-box. Simulation using the Virtual Library allows you to execute a model that was quantized, to measure the accuracy it would have in FHE, but also to determine the modifications required to make it FHE compatible.\n", + "> Testing FHE models on very large data-sets can take a long time. Furthermore, not all models are compatible with FHE constraints out-of-the-box. Simulation using the FHE simulation allows you to execute a model that was quantized, to measure the accuracy it would have in FHE, but also to determine the modifications required to make it FHE compatible.\n", ">\n", "> — [Zama documentation](https://docs.zama.ai/concrete-ml/getting-started/concepts#i.-model-development)\n" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "id": "74f5bf79", "metadata": {}, "outputs": [ @@ -656,23 +760,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "FHE Accuracy with VirtualLib: 0.9489\n" + "Accuracy with FHE simulation: 0.9745\n" ] } ], "source": [ - "# arbitrarily set the bit size to 8\n", - "n_bits = 8\n", - "svm_concrete = ConcreteLinearSVC(n_bits=2, C=0.001, dual=False, penalty='l1')\n", + "svm_concrete = ConcreteLinearSVC(n_bits=3, C=1, dual=False, penalty='l1')\n", "svm_concrete.fit(X_train, y_train)\n", "\n", - "# compile the model with virtual lib enabled and with the defined configuration\n", + "# compile the model\n", "circuit = svm_concrete.compile(X_train)\n", "\n", "# the model can now be executed with FHE\n", "y_pred = svm_concrete.predict(X_test, fhe=\"simulate\")\n", "accuracy = accuracy_score(y_test, y_pred)\n", - "print(f\"FHE Accuracy with VirtualLib: {accuracy:.4f}\")" + "print(f\"Accuracy with FHE simulation: {accuracy:.4f}\")" ] }, { @@ -680,7 +782,7 @@ "id": "e1721c59", "metadata": {}, "source": [ - "*The virtual library enables some unsafe features, so it should understandably not be used for production*\n", + "*The FHE simulation enables some unsafe features, so it should understandably not be used for production*\n", "\n", "So far so good, the model is compiled and executed much quicker with the virtual library, allowing us to run it more efficiently in development environments." ] @@ -692,20 +794,20 @@ "source": [ "### Step d: compile the model\n", "\n", - "Now that we have selected a relevant bit size and parameters we can compile the model, without virtual lib, so we can use it in production" + "Now that we have selected a relevant bit size and parameters we can compile the model, with FHE execution instead of FHE simulation, so we can use it in production" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "861502da", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "FHE Accuracy without VirtualLib: 0.9489\n" + "WARNING: The generated random seed is not crypto secure\n" ] } ], @@ -713,7 +815,7 @@ "# predict the test set to verify the compiled model accuracy\n", "y_pred = svm_concrete.predict(X_test, fhe=\"execute\")\n", "accuracy = accuracy_score(y_test, y_pred)\n", - "print(f\"FHE Accuracy without VirtualLib: {accuracy:.4f}\")" + "print(f\"Accuracy with FHE execution: {accuracy:.4f}\")" ] }, { @@ -725,7 +827,7 @@ "\n", "Setting up FHE with Concrete-ML on a LinearSVC model is very simple, in the regard that Concrete-ML provides an implementation of the [scikit-learn LinearSVC interface](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html). As a matter of fact, a working FHE model can be setup with just a few lines of code.\n", "\n", - "Setting up a model with FHE benefits nonetheless from some additional work. For LinearSVC models, the main point is to select a relevant bit-size for [quantizing](https://docs.zama.ai/concrete-ml/advanced-topics/quantization) the model. Some additional tools can smooth up the development workflow, such as alleviating the [compilation](https://docs.zama.ai/concrete-ml/advanced-topics/compilation) time by making use of the [virtual library](https://docs.zama.ai/concrete-ml/advanced-topics/compilation#simulation-with-the-virtual-library) \n", + "Setting up a model with FHE benefits nonetheless from some additional work. For LinearSVC models, the main point is to select a relevant bit-size for [quantizing](https://docs.zama.ai/concrete-ml/advanced-topics/quantization) the model. Some additional tools can smooth up the development workflow, such as alleviating the [compilation](https://docs.zama.ai/concrete-ml/advanced-topics/compilation) time by making use of the [FHE simulation](https://docs.zama.ai/concrete-ml/advanced-topics/compilation#fhe-simulation) \n", "\n", "Once the model is carefully trained and quantized, it is ready to be deployed and used in production. Here are some useful links that cover this subject:\n", "- [Inference in the Cloud](https://docs.zama.ai/concrete-ml/getting-started/cloud) summarize the steps for cloud deployment\n",