From 78cd284616f8c45f7b5f978e01ac1881965270a3 Mon Sep 17 00:00:00 2001 From: Olivier Boulant Date: Fri, 17 Mar 2023 15:07:23 +0100 Subject: [PATCH 1/2] docs: add example notebook for linearSVR --- concrete-ml/linearSVR.ipynb | 1047 +++++++++++++++++++++++++++++++++++ 1 file changed, 1047 insertions(+) create mode 100644 concrete-ml/linearSVR.ipynb diff --git a/concrete-ml/linearSVR.ipynb b/concrete-ml/linearSVR.ipynb new file mode 100644 index 0000000..944efb9 --- /dev/null +++ b/concrete-ml/linearSVR.ipynb @@ -0,0 +1,1047 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "82e9d8b1", + "metadata": {}, + "source": [ + "# Linear Regression using LinearSVR" + ] + }, + { + "cell_type": "markdown", + "id": "402b3337", + "metadata": {}, + "source": [ + "In this notebook, we show how to create, train and evaluate a linearSVR regression model using Concrete-ML library, our open-source privacy-preserving machine learning framework based on fully homomorphic encryption (FHE).\n", + "\n", + "For the sake of simplicity, we will only consider a single explanatory variable, making it easy to plot its relationship with the target variable. \n", + "\n", + "In order to identify the best set of hyperparameters for the linearSVR, we perform a grid search on the following : \n", + "\n", + "* $C$: (inverse) strength of the l2 penalization\n", + "* $\\epsilon$: margin for the support vectors\n", + "\n", + "Please refer to Scikit-Learn documentation on [linearSVR](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVR.html) for more details" + ] + }, + { + "cell_type": "markdown", + "id": "8f776973", + "metadata": {}, + "source": [ + "## Import librairies" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "dc5cd31d", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import numpy as np\n", + "\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.svm import LinearSVR as SklearnLinearSVR\n", + "from sklearn.metrics import r2_score\n", + "from sklearn.model_selection import GridSearchCV, train_test_split\n", + "from sklearn.metrics import make_scorer, mean_squared_error\n", + "\n", + "from concrete.ml.sklearn.svm import LinearSVR as ConcreteLinearSVR" + ] + }, + { + "cell_type": "markdown", + "id": "ad906125", + "metadata": {}, + "source": [ + "And some helpers for visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "123f740d", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display\n", + "\n", + "train_plot_config = {\"c\": \"black\", \"marker\": \"D\", \"s\": 15, \"label\": \"Train data\"}\n", + "test_plot_config = {\"c\": \"red\", \"marker\": \"x\", \"s\": 15, \"label\": \"Test data\"}\n", + "\n", + "def get_sklearn_plot_config(r2_score=None):\n", + " label = \"scikit-learn\"\n", + " if r2_score is not None:\n", + " label += f\", {'$R^2$'}={r2_score:.4f}\"\n", + " return {\"c\": \"blue\", \"linewidth\": 2.5, \"label\": label}\n", + "\n", + "def get_concrete_plot_config(r2_score=None):\n", + " label = \"Concrete-ML\"\n", + " if r2_score is not None:\n", + " label += f\", {'$R^2$'}={r2_score:.4f}\"\n", + " return {\"c\": \"orange\", \"linewidth\": 2.5, \"label\": label}\n" + ] + }, + { + "cell_type": "markdown", + "id": "250d74ae", + "metadata": {}, + "source": [ + "## Generate a dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "6852566a", + "metadata": {}, + "outputs": [], + "source": [ + "# pylint: disable=unbalanced-tuple-unpacking\n", + "X, y = make_regression(\n", + " n_samples=200, n_features=1, n_targets=1, bias=5.0, noise=30.0, random_state=42\n", + ")\n", + "# pylint: enable=unbalanced-tuple-unpacking\n", + "\n", + "# We split the dataset into a training and a testing set\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)\n", + "\n", + "# We sort the test set for a better visualization\n", + "sorted_indexes = np.argsort(np.squeeze(X_test))\n", + "X_test = X_test[sorted_indexes, :]\n", + "y_test = y_test[sorted_indexes]" + ] + }, + { + "cell_type": "markdown", + "id": "abb6ee60", + "metadata": {}, + "source": [ + "We display the dataset to visualize the data distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "ed6befb8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.ioff()\n", + "\n", + "plt.clf()\n", + "fig, ax = plt.subplots(1, figsize=(10, 5))\n", + "fig.patch.set_facecolor(\"white\")\n", + "ax.scatter(X_train, y_train, **train_plot_config)\n", + "ax.scatter(X_test, y_test, **test_plot_config)\n", + "ax.legend()\n", + "display(fig)" + ] + }, + { + "cell_type": "markdown", + "id": "7efdadb6", + "metadata": {}, + "source": [ + "## Identify best set of hyperparameters" + ] + }, + { + "cell_type": "markdown", + "id": "153ea6ff", + "metadata": {}, + "source": [ + "### Sklearn LinearSVR" + ] + }, + { + "cell_type": "markdown", + "id": "9d7095d8", + "metadata": {}, + "source": [ + "Create scorer with the [Mean Squared Error](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "292661ba", + "metadata": {}, + "outputs": [], + "source": [ + "grid_scorer = make_scorer(mean_squared_error, greater_is_better=False)" + ] + }, + { + "cell_type": "markdown", + "id": "cb7964d4", + "metadata": {}, + "source": [ + "We train the scikit-learn LinearSVR model on clear data.\n", + "\n", + "We use a parameter grid with several values for $\\epsilon$ and $C$. " + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "b7e9c686", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 5 folds for each of 9 candidates, totalling 45 fits\n" + ] + } + ], + "source": [ + "param_grid = {\n", + " \"epsilon\": [0.0, 1.0, 10.0],\n", + " \"C\": [0.1, 1.0, 10.0],\n", + "}\n", + "\n", + "sklearn_rgs = SklearnLinearSVR()\n", + "\n", + "gs_sklearn = GridSearchCV(\n", + " sklearn_rgs,\n", + " param_grid,\n", + " cv=5,\n", + " scoring=grid_scorer,\n", + " verbose=1,\n", + ").fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "id": "e0a075e8", + "metadata": {}, + "source": [ + "### Concrete-ML quantized linearSVR" + ] + }, + { + "cell_type": "markdown", + "id": "8b3450e2", + "metadata": {}, + "source": [ + "The typical development flow of a Concrete-ML model is the following:\n", + "\n", + "* The model is trained on clear (plaintext) data as only FHE inference is currently supported\n", + "* The resulting trained model is quantized using a `n_bits` parameter set by the user. This parameter can either be:\n", + " 1. a dictionary composed of `op_inputs` and `op_weights` keys. These parameters are given as integers representing the number of bits over which the associated data should be quantized.\n", + " 2. an integer, representing the number of bits over which each input and weight should be quantized. Default is 8.\n", + "* The quantized model is compiled to a FHE equivalent following 3 steps:\n", + " 1. create an executable operation graph\n", + " 2. check that the op-graph is FHE compatible by checking the maximum bit-width needed to execute the model\n", + " 3. determine cryptographic parameters that will help to generate the secret keys and evaluation keys. If no parameters can be found, the compilation process can't be completed and an error is thrown. The user then can either lower the value(s) chosen for `n_bits` or decrease the number of features found in the data set (using techniques such as PCA) and run the development flow once again.\n", + "* Inference can then be done on encrypted data (using `execute_in_fhe=True` when calling `.predict()` method)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "cb18e789", + "metadata": {}, + "source": [ + "We use the same grid of parameter values. We set the number of bits to 6 (see explanation below). " + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "59046f10", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 5 folds for each of 9 candidates, totalling 45 fits\n" + ] + } + ], + "source": [ + "param_grid = {\n", + " \"n_bits\": [6],\n", + " \"epsilon\": [0.0, 1.0, 10.0],\n", + " \"C\": [0.1, 1.0, 10.0],\n", + "}\n", + "\n", + "concrete_rgs = ConcreteLinearSVR()\n", + "\n", + "gs_concrete = GridSearchCV(\n", + " concrete_rgs,\n", + " param_grid,\n", + " cv=5,\n", + " scoring=grid_scorer,\n", + " verbose=1,\n", + ").fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "id": "0e51b63a", + "metadata": {}, + "source": [ + "### Compare Sklearn and Concrete-ML Quantized best models" + ] + }, + { + "cell_type": "markdown", + "id": "8cde0fe6", + "metadata": {}, + "source": [ + "#### Performance" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "1d0577a1", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean time fit sklearn: 0.001s, std time fit sklearn: 0.000s\n", + "Mean time fit concrete: 0.151s,std time fit concrete: 0.007s\n", + "Best MSE score sklearn: 944.02\n", + "Best MSE score concrete: 936.30\n" + ] + } + ], + "source": [ + "# Print mean time fit and std time fit for both models\n", + "print(\n", + " f\"Mean time fit sklearn: {np.mean(gs_sklearn.cv_results_['mean_fit_time']):.3f}s,\"\n", + " f\" std time fit sklearn: {np.std(gs_sklearn.cv_results_['mean_fit_time']):.3f}s\"\n", + ")\n", + "print(\n", + " f\"Mean time fit concrete: {np.mean(gs_concrete.cv_results_['mean_fit_time']):.3f}s,\"\n", + " f\"std time fit concrete: {np.std(gs_concrete.cv_results_['mean_fit_time']):.3f}s\"\n", + ")\n", + "\n", + "# Print best score for both models\n", + "print(f\"Best MSE score sklearn: {-gs_sklearn.best_score_:.2f}\")\n", + "print(f\"Best MSE score concrete: {-gs_concrete.best_score_:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "09aa3989", + "metadata": {}, + "source": [ + "#### Hyperparameters" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "bc2ca27a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for Concrete: {'C': 10.0, 'epsilon': 1.0, 'n_bits': 6}\n", + "Best parameters for Sklearn: {'C': 10.0, 'epsilon': 1.0}\n" + ] + } + ], + "source": [ + "# Get best hyper parameters out of gs_concrete\n", + "best_params_concrete = gs_concrete.best_params_\n", + "print(f\"Best parameters for Concrete: {best_params_concrete}\")\n", + "best_params_sklearn = gs_sklearn.best_params_\n", + "print(f\"Best parameters for Sklearn: {best_params_sklearn}\")" + ] + }, + { + "cell_type": "markdown", + "id": "900f500c", + "metadata": {}, + "source": [ + "### Train with best hyperparameter set on the complete training dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "ba940a03", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
LinearSVR(C=10.0, epsilon=1.0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearSVR(C=10.0, epsilon=1.0)" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Train concrete and sklearn LinearSVR with best hyper parameters\n", + "concrete_rgs = ConcreteLinearSVR(**best_params_concrete)\n", + "sklearn_rgs = SklearnLinearSVR(**best_params_sklearn)\n", + "\n", + "concrete_rgs.fit(X_train, y_train)\n", + "sklearn_rgs.fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "id": "3714582c", + "metadata": {}, + "source": [ + "## Concrete-ML Quantized linearSVR with FHE" + ] + }, + { + "cell_type": "markdown", + "id": "b79b2d76", + "metadata": {}, + "source": [ + "### Prerequisite" + ] + }, + { + "cell_type": "markdown", + "id": "d07a5397", + "metadata": {}, + "source": [ + "Some prerequisites should be reviewed before deep diving !\n", + "\n", + "Quantization is a technique that converts continuous data (floating point, e.g., in 32-bits) to discrete numbers within a fixed range (e.g. integer in 8-bits). This means that some information is lost during the process. However, the larger is the integers' range, the smaller the error becomes, making it acceptable to some cases.\n", + "\n", + "To learn more about quantization, please refer to this [page](https://docs.zama.ai/concrete-ml/advanced-topics/quantization).\n", + "\n", + "Regarding FHE, the input data type must be represented exclusively as integers, making the use of quantization necessary. Therefore, a linear model trained on floats is quantized into an equivalent integer model using *Post-Training Quantization*. This operation can lead to a loss of accuracy compared to the standard floating point models working on clear data.\n", + "\n", + "In practice however, this loss is usually very limited with linear FHE models as they can consider very large integers, with up to 50 bits in some cases. This means these models can quantize their inputs and weights over large number of bits (e.g. 16) while still considering data sets containing many features (e.g. 1000). We therefore often observe almost identical performance scores (e.g. R2 score) between float, quantized and FHE models.\n", + "\n", + "To learn more about the relation between the maximum bit-width reached within a model, the bits of quantization used and the dataset's number of features, please refer to this [page](https://docs.zama.ai/concrete-ml/advanced-topics/pruning)." + ] + }, + { + "cell_type": "markdown", + "id": "7fa3164d", + "metadata": {}, + "source": [ + "### Compilation" + ] + }, + { + "cell_type": "markdown", + "id": "7d12f8fd", + "metadata": {}, + "source": [ + "To perform homomorphic inference, we take the above trained quantized model and we compile it to get a FHE model.\n", + "\n", + "The compiler requires an exhaustive set of data to evaluate the maximum integer bit-width within the graph, which is needed during the FHE computations before running any predictions.\n", + "\n", + "The user can either provide the entire train dataset or a smaller but representative subset of it." + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "e19fbae2", + "metadata": {}, + "outputs": [], + "source": [ + "# Compile the model using the training data\n", + "circuit = concrete_rgs.compile(X_train)" + ] + }, + { + "cell_type": "markdown", + "id": "bba0f654", + "metadata": {}, + "source": [ + "### Generate the key" + ] + }, + { + "cell_type": "markdown", + "id": "f9d3dee0", + "metadata": {}, + "source": [ + "The compiler returns a circuit, which can then be used for key generation and predictions. More precisely, it generates:\n", + "\n", + "* a Secret Key, used for the encryption and decryption processes. This key should remain accessible only to the user.\n", + "* an Evaluation Key, used to evaluate the circuit on encrypted data. Anyone could access this key without breaching the model's security.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "309b226f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating a key for an 6-bit circuit\n" + ] + } + ], + "source": [ + "# Generate the key\n", + "print(f\"Generating a key for an {circuit.graph.maximum_integer_bit_width()}-bit circuit\")" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "785f4ac5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key generation time: 117.71 seconds\n" + ] + } + ], + "source": [ + "time_begin = time.time()\n", + "circuit.client.keygen(force=False)\n", + "print(f\"Key generation time: {time.time() - time_begin:.2f} seconds\")" + ] + }, + { + "cell_type": "markdown", + "id": "cf62d77c", + "metadata": {}, + "source": [ + "### Now let's predict using the FHE model on encrypted data" + ] + }, + { + "cell_type": "markdown", + "id": "bb1b8e4f", + "metadata": {}, + "source": [ + "Please, notice the `execute_in_fhe=True` that makes the job under the hood: before the data is sent to be applied to the model, it is encrypted with the client secret key generated above. \n", + "\n", + "As for future comparison bellow, we also predict on the very same data on both:\n", + "* the Sklearn model,\n", + "* the Concrete-ML quantized model without FHE. " + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "6c842f67", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Execution time: 15.1017 seconds per sample\n", + "Execution time: 0.0001 seconds per sample\n", + "Execution time: 0.0004 seconds per sample\n" + ] + } + ], + "source": [ + "# Now predict using the FHE-quantized model on the testing set\n", + "time_begin = time.time()\n", + "y_pred_fhe = concrete_rgs.predict(X_test, execute_in_fhe=True)\n", + "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")\n", + "\n", + "# Now predict using the Sklearn model on the testing set\n", + "time_begin = time.time()\n", + "y_pred_sklearn = sklearn_rgs.predict(X_test)\n", + "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")\n", + "\n", + "# Now predict using clear quantized Concrete-ML model on testing set\n", + "time_begin = time.time()\n", + "y_preds_quantized = concrete_rgs.predict(X_test)\n", + "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "aad88c4b", + "metadata": {}, + "source": [ + "## Compare" + ] + }, + { + "cell_type": "markdown", + "id": "e5b996f3", + "metadata": {}, + "source": [ + "### Display performance spreads" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "d725e8ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Clear FP32 sklearn model MSE: 939.063\n", + "Clear quantized model MSE: 992.598\n", + "FHE model MSE: 992.598\n", + "\n", + "Relative difference between Concrete-ml (quantized clear) and Concrete-ml (FHE) scores: 0.00%\n", + "Relative difference between scikit-learn (clear) and Concrete-ml (FHE) scores: 5.70%\n" + ] + } + ], + "source": [ + "# Print all MSE a string to explain\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "mse_sklearn = mean_squared_error(y_test, y_pred_sklearn)\n", + "mse_clear = mean_squared_error(y_test, y_preds_quantized)\n", + "mse_fhe = mean_squared_error(y_test, y_pred_fhe)\n", + "\n", + "print(\n", + " f\"Clear FP32 sklearn model MSE: {mse_sklearn:.3f}\\n\"\n", + " f\"Clear quantized model MSE: {mse_clear:.3f}\\n\"\n", + " f\"FHE model MSE: {mse_fhe:.3f}\"\n", + ")\n", + "\n", + "# Measure the error of the FHE quantized model with respect to quantized clear Concrete-ML model\n", + "concrete_score_difference = abs(mse_fhe - mse_clear) * 100 / mse_clear\n", + "print(\n", + " \"\\nRelative difference between Concrete-ml (quantized clear) and Concrete-ml (FHE) scores:\",\n", + " f\"{concrete_score_difference:.2f}%\",\n", + ")\n", + "\n", + "\n", + "# Measure the error of the FHE quantized model with respect to the sklearn float model\n", + "score_difference = abs(mse_fhe - mse_sklearn) * 100 / mse_sklearn\n", + "print(\n", + " \"Relative difference between scikit-learn (clear) and Concrete-ml (FHE) scores:\",\n", + " f\"{score_difference:.2f}%\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "1dab670d", + "metadata": {}, + "source": [ + "We can observe that scikit-learn and Concrete-ML models output very close scores. This demonstrate how the quantization process has a very limited impact on performances.\n", + "\n", + "As for the spread in performance between Concrete-ml (FHE) and scikit-learn, there are also quote to one another. \n", + "* On the below graph, we see that test dataset has points for which `X` values are outside the range of training dataset. Since, when we compiled the quantized model we used `X_train`, then those `X` values in the test dataset outside the range of what is seen in `X_train`, then the decision rule poorly generalize on those values outside the boundaries observed on `X_tain`\n", + "* Moreover, keep in mind that the current notebook has been voluntarily performed with `n_bits = 6` whereas the default value is 8. Running the current notebook with a `n_bits > 6` will lead to a significant performance improvment and will close the performance gap with scikit-learn. " + ] + }, + { + "cell_type": "markdown", + "id": "9a65a270", + "metadata": {}, + "source": [ + "### Visualize decision rule" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "1f233390", + "metadata": {}, + "outputs": [], + "source": [ + "# We densify the space representation of the original X,\n", + "# to better visualize the resulting step function in the following figure\n", + "x_space = np.linspace(X_test.min(), X_test.max(), num=300)\n", + "x_space = x_space[:, np.newaxis]\n", + "y_pred_q_space = concrete_rgs.predict(x_space)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "5dd358d4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.ioff()\n", + "\n", + "plt.clf()\n", + "fig, ax = plt.subplots(1, figsize=(12, 8))\n", + "fig.patch.set_facecolor(\"white\")\n", + "ax.scatter(X_train, y_train, **train_plot_config)\n", + "ax.scatter(X_test, y_test, **test_plot_config)\n", + "ax.plot(X_test, y_pred_sklearn, **get_sklearn_plot_config(mse_sklearn))\n", + "ax.plot(x_space, y_pred_q_space, **get_concrete_plot_config(mse_clear))\n", + "ax.legend()\n", + "display(fig)" + ] + }, + { + "cell_type": "markdown", + "id": "3bddb3fd", + "metadata": {}, + "source": [ + "## Conclusion" + ] + }, + { + "cell_type": "markdown", + "id": "1bdaa448", + "metadata": {}, + "source": [ + "In this tutorial, we have shown how easy it is to train and execute a linear regression model in FHE using Concrete-ML.\n", + "\n", + "We have also discussed the development flow of a FHE model: training, quantization, compilation and inference.\n", + "\n", + "The slight decrease in prediction quality is due to the quantization of the model's weights and input data, which makes the model poorly generalize outside of its training domain. However, this decrease remains negligible as both floating point (scikit-learn) and FHE (Concrete-ML) models give almost identical MSE scores." + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "cf1e95be", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "c08ebb8a", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the diabetes dataset\n", + "diabetes_X, diabetes_y = datasets.load_diabetes(return_X_y=True)\n", + "# Use only one feature\n", + "diabetes_X = diabetes_X[:, np.newaxis, 2]\n", + "# We split the dataset into a training and a testing set\n", + "diabetes_X_train, diabetes_X_test, diabetes_y_train, diabetes_y_test = train_test_split(diabetes_X, diabetes_y, test_size=0.4, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "85159f1b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 5 folds for each of 9 candidates, totalling 45 fits\n" + ] + } + ], + "source": [ + "param_grid = {\n", + " \"epsilon\": [0.0, 1.0, 10.0],\n", + " \"C\": [0.1, 1.0, 10.0],\n", + "}\n", + "\n", + "sklearn_rgs = SklearnLinearSVR()\n", + "\n", + "gs_sklearn = GridSearchCV(\n", + " sklearn_rgs,\n", + " param_grid,\n", + " cv=5,\n", + " scoring=grid_scorer,\n", + " verbose=1,\n", + ").fit(diabetes_X_train, diabetes_y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "d314d9e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 5 folds for each of 9 candidates, totalling 45 fits\n" + ] + } + ], + "source": [ + "param_grid = {\n", + " \"n_bits\": [6],\n", + " \"epsilon\": [0.0, 1.0, 10.0],\n", + " \"C\": [0.1, 1.0, 10.0],\n", + "}\n", + "\n", + "concrete_rgs = ConcreteLinearSVR()\n", + "\n", + "gs_concrete = GridSearchCV(\n", + " concrete_rgs,\n", + " param_grid,\n", + " cv=5,\n", + " scoring=grid_scorer,\n", + " verbose=1,\n", + ").fit(diabetes_X_train, diabetes_y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "e331a055", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean time fit sklearn: 0.001s, std time fit sklearn: 0.001s\n", + "Mean time fit concrete: 0.174s,std time fit concrete: 0.021s\n", + "Best MSE score sklearn: 6142.22\n", + "Best MSE score concrete: 6146.51\n" + ] + } + ], + "source": [ + "# Print mean time fit and std time fit for both models\n", + "print(\n", + " f\"Mean time fit sklearn: {np.mean(gs_sklearn.cv_results_['mean_fit_time']):.3f}s,\"\n", + " f\" std time fit sklearn: {np.std(gs_sklearn.cv_results_['mean_fit_time']):.3f}s\"\n", + ")\n", + "print(\n", + " f\"Mean time fit concrete: {np.mean(gs_concrete.cv_results_['mean_fit_time']):.3f}s,\"\n", + " f\"std time fit concrete: {np.std(gs_concrete.cv_results_['mean_fit_time']):.3f}s\"\n", + ")\n", + "\n", + "# Print best score for both models\n", + "print(f\"Best MSE score sklearn: {-gs_sklearn.best_score_:.2f}\")\n", + "print(f\"Best MSE score concrete: {-gs_concrete.best_score_:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "id": "5a0bbdd8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for Concrete: {'C': 10.0, 'epsilon': 0.0, 'n_bits': 6}\n", + "Best parameters for Sklearn: {'C': 10.0, 'epsilon': 1.0}\n" + ] + }, + { + "data": { + "text/html": [ + "
LinearSVR(C=10.0, epsilon=1.0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearSVR(C=10.0, epsilon=1.0)" + ] + }, + "execution_count": 127, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get best hyper parameters out of gs_concrete\n", + "best_params_concrete = gs_concrete.best_params_\n", + "print(f\"Best parameters for Concrete: {best_params_concrete}\")\n", + "best_params_sklearn = gs_sklearn.best_params_\n", + "print(f\"Best parameters for Sklearn: {best_params_sklearn}\")\n", + "\n", + "# Train concrete and sklearn LinearSVR with best hyper parameters\n", + "concrete_rgs = ConcreteLinearSVR(**best_params_concrete)\n", + "sklearn_rgs = SklearnLinearSVR(**best_params_sklearn)\n", + "\n", + "concrete_rgs.fit(diabetes_X_train, diabetes_y_train)\n", + "sklearn_rgs.fit(diabetes_X_train, diabetes_y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "e532ef07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating a key for an 6-bit circuit\n", + "Key generation time: 119.86 seconds\n", + "Execution time: 24.4823 seconds per sample\n", + "Execution time: 0.0000 seconds per sample\n", + "Execution time: 0.0002 seconds per sample\n" + ] + } + ], + "source": [ + "# Compile the model using the training data\n", + "circuit = concrete_rgs.compile(X_train)\n", + "\n", + "# Generate the key\n", + "print(f\"Generating a key for an {circuit.graph.maximum_integer_bit_width()}-bit circuit\")\n", + "\n", + "time_begin = time.time()\n", + "circuit.client.keygen(force=False)\n", + "print(f\"Key generation time: {time.time() - time_begin:.2f} seconds\")\n", + "\n", + "# Now predict using the FHE-quantized model on the testing set\n", + "time_begin = time.time()\n", + "y_pred_fhe = concrete_rgs.predict(diabetes_X_test, execute_in_fhe=True)\n", + "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")\n", + "\n", + "# Now predict using the Sklearn model on the testing set\n", + "time_begin = time.time()\n", + "y_pred_sklearn = sklearn_rgs.predict(diabetes_X_test)\n", + "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")\n", + "\n", + "# Now predict using clear quantized Concrete-ML model on testing set\n", + "time_begin = time.time()\n", + "y_preds_quantized = concrete_rgs.predict(diabetes_X_test)\n", + "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7a23ae2", + "metadata": {}, + "outputs": [], + "source": [ + "# Print all MSE a string to explain\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "mse_sklearn = mean_squared_error(diabetes_y_test, y_pred_sklearn)\n", + "mse_clear = mean_squared_error(diabetes_y_test, y_preds_quantized)\n", + "mse_fhe = mean_squared_error(diabetes_y_test, y_pred_fhe)\n", + "\n", + "print(\n", + " f\"Clear FP32 sklearn model MSE: {mse_sklearn:.3f}\\n\"\n", + " f\"Clear quantized model MSE: {mse_clear:.3f}\\n\"\n", + " f\"FHE model MSE: {mse_fhe:.3f}\"\n", + ")\n", + "\n", + "# Measure the error of the FHE quantized model with respect to quantized clear Concrete-ML model\n", + "concrete_score_difference = abs(mse_fhe - mse_clear) * 100 / mse_clear\n", + "print(\n", + " \"\\nRelative difference between Concrete-ml (quantized clear) and Concrete-ml (FHE) scores:\",\n", + " f\"{concrete_score_difference:.2f}%\",\n", + ")\n", + "\n", + "\n", + "# Measure the error of the FHE quantized model with respect to the sklearn float model\n", + "score_difference = abs(mse_fhe - mse_sklearn) * 100 / mse_sklearn\n", + "print(\n", + " \"Relative difference between scikit-learn (clear) and Concrete-ml (FHE) scores:\",\n", + " f\"{score_difference:.2f}%\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "140bce4d", + "metadata": {}, + "outputs": [], + "source": [ + "# We densify the space representation of the original X,\n", + "# to better visualize the resulting step function in the following figure\n", + "x_space = np.linspace(diabetes_X_test.min(), diabetes_X_test.max(), num=300)\n", + "x_space = x_space[:, np.newaxis]\n", + "y_pred_q_space = concrete_rgs.predict(x_space)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8315fd7", + "metadata": {}, + "outputs": [], + "source": [ + "plt.ioff()\n", + "\n", + "plt.clf()\n", + "fig, ax = plt.subplots(1, figsize=(12, 8))\n", + "fig.patch.set_facecolor(\"white\")\n", + "ax.scatter(diabetes_X_train, diabetes_y_train, **train_plot_config)\n", + "ax.scatter(diabetes_X_test, diabetes_y_test, **test_plot_config)\n", + "ax.plot(diabetes_X_test, diabetes_y_pred_sklearn, **get_sklearn_plot_config(mse_sklearn))\n", + "ax.plot(x_space, y_pred_q_space, **get_concrete_plot_config(mse_clear))\n", + "ax.legend()\n", + "display(fig)" + ] + } + ], + "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 05348df70facc0875cb83a019f43d621a8a1a598 Mon Sep 17 00:00:00 2001 From: Olivier Boulant Date: Fri, 17 Mar 2023 15:17:26 +0100 Subject: [PATCH 2/2] docs: uploading the right file --- concrete-ml/linearSVR.ipynb | 459 +++++++----------------------------- 1 file changed, 90 insertions(+), 369 deletions(-) diff --git a/concrete-ml/linearSVR.ipynb b/concrete-ml/linearSVR.ipynb index 944efb9..9948165 100644 --- a/concrete-ml/linearSVR.ipynb +++ b/concrete-ml/linearSVR.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "82e9d8b1", + "id": "1087af6d", "metadata": {}, "source": [ "# Linear Regression using LinearSVR" @@ -10,7 +10,7 @@ }, { "cell_type": "markdown", - "id": "402b3337", + "id": "b0f118fd", "metadata": {}, "source": [ "In this notebook, we show how to create, train and evaluate a linearSVR regression model using Concrete-ML library, our open-source privacy-preserving machine learning framework based on fully homomorphic encryption (FHE).\n", @@ -27,7 +27,7 @@ }, { "cell_type": "markdown", - "id": "8f776973", + "id": "244d272c", "metadata": {}, "source": [ "## Import librairies" @@ -35,8 +35,8 @@ }, { "cell_type": "code", - "execution_count": 119, - "id": "dc5cd31d", + "execution_count": 1, + "id": "9ea25662", "metadata": {}, "outputs": [], "source": [ @@ -55,7 +55,7 @@ }, { "cell_type": "markdown", - "id": "ad906125", + "id": "728a5450", "metadata": {}, "source": [ "And some helpers for visualization." @@ -63,8 +63,8 @@ }, { "cell_type": "code", - "execution_count": 82, - "id": "123f740d", + "execution_count": 2, + "id": "ba20b4ed", "metadata": {}, "outputs": [], "source": [ @@ -91,7 +91,7 @@ }, { "cell_type": "markdown", - "id": "250d74ae", + "id": "6a8e092d", "metadata": {}, "source": [ "## Generate a dataset" @@ -99,8 +99,8 @@ }, { "cell_type": "code", - "execution_count": 83, - "id": "6852566a", + "execution_count": 3, + "id": "9b2dc4be", "metadata": {}, "outputs": [], "source": [ @@ -121,7 +121,7 @@ }, { "cell_type": "markdown", - "id": "abb6ee60", + "id": "ef0975f5", "metadata": {}, "source": [ "We display the dataset to visualize the data distribution." @@ -129,8 +129,8 @@ }, { "cell_type": "code", - "execution_count": 84, - "id": "ed6befb8", + "execution_count": 4, + "id": "ae52a4e4", "metadata": {}, "outputs": [ { @@ -158,7 +158,7 @@ }, { "cell_type": "markdown", - "id": "7efdadb6", + "id": "931bce92", "metadata": {}, "source": [ "## Identify best set of hyperparameters" @@ -166,7 +166,7 @@ }, { "cell_type": "markdown", - "id": "153ea6ff", + "id": "acbf941b", "metadata": {}, "source": [ "### Sklearn LinearSVR" @@ -174,7 +174,7 @@ }, { "cell_type": "markdown", - "id": "9d7095d8", + "id": "4860fd50", "metadata": {}, "source": [ "Create scorer with the [Mean Squared Error](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html)" @@ -182,8 +182,8 @@ }, { "cell_type": "code", - "execution_count": 85, - "id": "292661ba", + "execution_count": 5, + "id": "11bb680b", "metadata": {}, "outputs": [], "source": [ @@ -192,7 +192,7 @@ }, { "cell_type": "markdown", - "id": "cb7964d4", + "id": "f864d02e", "metadata": {}, "source": [ "We train the scikit-learn LinearSVR model on clear data.\n", @@ -202,8 +202,8 @@ }, { "cell_type": "code", - "execution_count": 86, - "id": "b7e9c686", + "execution_count": 8, + "id": "449e78b4", "metadata": {}, "outputs": [ { @@ -233,7 +233,7 @@ }, { "cell_type": "markdown", - "id": "e0a075e8", + "id": "5e3e7c24", "metadata": {}, "source": [ "### Concrete-ML quantized linearSVR" @@ -241,35 +241,35 @@ }, { "cell_type": "markdown", - "id": "8b3450e2", + "id": "f82a8c7d", "metadata": {}, "source": [ "The typical development flow of a Concrete-ML model is the following:\n", "\n", "* The model is trained on clear (plaintext) data as only FHE inference is currently supported\n", - "* The resulting trained model is quantized using a `n_bits` parameter set by the user. This parameter can either be:\n", + "* The resulting trained model is quantized using a `n_bits` parameter set by the user (see documentation [here](https://docs.zama.ai/concrete-ml/developer-guide/api/concrete.ml.sklearn.svm#class-linearsvr)). This parameter can either be:\n", " 1. a dictionary composed of `op_inputs` and `op_weights` keys. These parameters are given as integers representing the number of bits over which the associated data should be quantized.\n", - " 2. an integer, representing the number of bits over which each input and weight should be quantized. Default is 8.\n", + " 2. an integer, representing the number of bits over which each input and weight should be quantized. Default is 8. We will use 6 bits for educational purposes. \n", "* The quantized model is compiled to a FHE equivalent following 3 steps:\n", " 1. create an executable operation graph\n", " 2. check that the op-graph is FHE compatible by checking the maximum bit-width needed to execute the model\n", - " 3. determine cryptographic parameters that will help to generate the secret keys and evaluation keys. If no parameters can be found, the compilation process can't be completed and an error is thrown. The user then can either lower the value(s) chosen for `n_bits` or decrease the number of features found in the data set (using techniques such as PCA) and run the development flow once again.\n", - "* Inference can then be done on encrypted data (using `execute_in_fhe=True` when calling `.predict()` method)\n", + " 3. determine cryptographic parameters that will help to generate the secret keys and evaluation keys. If no parameters can be found, the compilation process can't be completed and an error is thrown. The user then can either lower the value(s) chosen for `n_bits` or decrease the number of features found in the data set (using techniques such as [PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html)) and run the development flow once again.\n", + "* Inference can then be done on encrypted data (using `execute_in_fhe=True` when calling `.predict()` method. See bellow)\n", "\n" ] }, { "cell_type": "markdown", - "id": "cb18e789", + "id": "2f6c5f40", "metadata": {}, "source": [ - "We use the same grid of parameter values. We set the number of bits to 6 (see explanation below). " + "We use the same grid of parameter values. We set the number of bits to 6 (see explanation in following sections). " ] }, { "cell_type": "code", - "execution_count": 92, - "id": "59046f10", + "execution_count": 9, + "id": "e6126ebb", "metadata": {}, "outputs": [ { @@ -300,7 +300,7 @@ }, { "cell_type": "markdown", - "id": "0e51b63a", + "id": "991386ee", "metadata": {}, "source": [ "### Compare Sklearn and Concrete-ML Quantized best models" @@ -308,7 +308,7 @@ }, { "cell_type": "markdown", - "id": "8cde0fe6", + "id": "512f94e0", "metadata": {}, "source": [ "#### Performance" @@ -316,8 +316,8 @@ }, { "cell_type": "code", - "execution_count": 93, - "id": "1d0577a1", + "execution_count": 10, + "id": "e884473f", "metadata": { "scrolled": true }, @@ -327,9 +327,9 @@ "output_type": "stream", "text": [ "Mean time fit sklearn: 0.001s, std time fit sklearn: 0.000s\n", - "Mean time fit concrete: 0.151s,std time fit concrete: 0.007s\n", - "Best MSE score sklearn: 944.02\n", - "Best MSE score concrete: 936.30\n" + "Mean time fit concrete: 0.162s,std time fit concrete: 0.048s\n", + "Best MSE score sklearn: 943.87\n", + "Best MSE score concrete: 936.11\n" ] } ], @@ -351,7 +351,7 @@ }, { "cell_type": "markdown", - "id": "09aa3989", + "id": "03f0143f", "metadata": {}, "source": [ "#### Hyperparameters" @@ -359,8 +359,8 @@ }, { "cell_type": "code", - "execution_count": 35, - "id": "bc2ca27a", + "execution_count": 11, + "id": "7d5027bb", "metadata": {}, "outputs": [ { @@ -382,7 +382,7 @@ }, { "cell_type": "markdown", - "id": "900f500c", + "id": "326ef351", "metadata": {}, "source": [ "### Train with best hyperparameter set on the complete training dataset" @@ -390,20 +390,20 @@ }, { "cell_type": "code", - "execution_count": 94, - "id": "ba940a03", + "execution_count": 12, + "id": "23d61559", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
LinearSVR(C=10.0, epsilon=1.0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "
LinearSVR(C=10.0, epsilon=1.0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "LinearSVR(C=10.0, epsilon=1.0)" ] }, - "execution_count": 94, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -419,7 +419,7 @@ }, { "cell_type": "markdown", - "id": "3714582c", + "id": "d9251a9d", "metadata": {}, "source": [ "## Concrete-ML Quantized linearSVR with FHE" @@ -427,7 +427,7 @@ }, { "cell_type": "markdown", - "id": "b79b2d76", + "id": "64dcbfc0", "metadata": {}, "source": [ "### Prerequisite" @@ -435,7 +435,7 @@ }, { "cell_type": "markdown", - "id": "d07a5397", + "id": "8eba8bb8", "metadata": {}, "source": [ "Some prerequisites should be reviewed before deep diving !\n", @@ -446,14 +446,14 @@ "\n", "Regarding FHE, the input data type must be represented exclusively as integers, making the use of quantization necessary. Therefore, a linear model trained on floats is quantized into an equivalent integer model using *Post-Training Quantization*. This operation can lead to a loss of accuracy compared to the standard floating point models working on clear data.\n", "\n", - "In practice however, this loss is usually very limited with linear FHE models as they can consider very large integers, with up to 50 bits in some cases. This means these models can quantize their inputs and weights over large number of bits (e.g. 16) while still considering data sets containing many features (e.g. 1000). We therefore often observe almost identical performance scores (e.g. R2 score) between float, quantized and FHE models.\n", + "In practice however, this loss is usually very limited with linear FHE models as they can consider very large integers, with up to 50 bits in some cases. This means these models can quantize their inputs and weights over large number of bits (e.g. 16) while still considering data sets containing many features (e.g. 1000). We therefore often observe almost identical performance scores between float, quantized and FHE models.\n", "\n", "To learn more about the relation between the maximum bit-width reached within a model, the bits of quantization used and the dataset's number of features, please refer to this [page](https://docs.zama.ai/concrete-ml/advanced-topics/pruning)." ] }, { "cell_type": "markdown", - "id": "7fa3164d", + "id": "80e835f8", "metadata": {}, "source": [ "### Compilation" @@ -461,7 +461,7 @@ }, { "cell_type": "markdown", - "id": "7d12f8fd", + "id": "0ea0e874", "metadata": {}, "source": [ "To perform homomorphic inference, we take the above trained quantized model and we compile it to get a FHE model.\n", @@ -473,8 +473,8 @@ }, { "cell_type": "code", - "execution_count": 95, - "id": "e19fbae2", + "execution_count": 13, + "id": "c9590403", "metadata": {}, "outputs": [], "source": [ @@ -484,7 +484,7 @@ }, { "cell_type": "markdown", - "id": "bba0f654", + "id": "b33827f6", "metadata": {}, "source": [ "### Generate the key" @@ -492,7 +492,7 @@ }, { "cell_type": "markdown", - "id": "f9d3dee0", + "id": "b00a9172", "metadata": {}, "source": [ "The compiler returns a circuit, which can then be used for key generation and predictions. More precisely, it generates:\n", @@ -503,8 +503,8 @@ }, { "cell_type": "code", - "execution_count": 96, - "id": "309b226f", + "execution_count": 14, + "id": "53cc3b51", "metadata": {}, "outputs": [ { @@ -522,15 +522,15 @@ }, { "cell_type": "code", - "execution_count": 97, - "id": "785f4ac5", + "execution_count": 15, + "id": "3212b1b0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Key generation time: 117.71 seconds\n" + "Key generation time: 120.03 seconds\n" ] } ], @@ -542,7 +542,7 @@ }, { "cell_type": "markdown", - "id": "cf62d77c", + "id": "752452bc", "metadata": {}, "source": [ "### Now let's predict using the FHE model on encrypted data" @@ -550,7 +550,7 @@ }, { "cell_type": "markdown", - "id": "bb1b8e4f", + "id": "9b71e63e", "metadata": {}, "source": [ "Please, notice the `execute_in_fhe=True` that makes the job under the hood: before the data is sent to be applied to the model, it is encrypted with the client secret key generated above. \n", @@ -562,17 +562,17 @@ }, { "cell_type": "code", - "execution_count": 98, - "id": "6c842f67", + "execution_count": 16, + "id": "ccc0edcc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Execution time: 15.1017 seconds per sample\n", + "Execution time: 10.8313 seconds per sample\n", "Execution time: 0.0001 seconds per sample\n", - "Execution time: 0.0004 seconds per sample\n" + "Execution time: 0.0003 seconds per sample\n" ] } ], @@ -595,7 +595,7 @@ }, { "cell_type": "markdown", - "id": "aad88c4b", + "id": "d7e99e85", "metadata": {}, "source": [ "## Compare" @@ -603,7 +603,7 @@ }, { "cell_type": "markdown", - "id": "e5b996f3", + "id": "d8d8c76d", "metadata": {}, "source": [ "### Display performance spreads" @@ -611,20 +611,20 @@ }, { "cell_type": "code", - "execution_count": 104, - "id": "d725e8ee", + "execution_count": 17, + "id": "5dbc0d68", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Clear FP32 sklearn model MSE: 939.063\n", - "Clear quantized model MSE: 992.598\n", - "FHE model MSE: 992.598\n", + "Clear FP32 sklearn model MSE: 940.179\n", + "Clear quantized model MSE: 992.409\n", + "FHE model MSE: 992.409\n", "\n", "Relative difference between Concrete-ml (quantized clear) and Concrete-ml (FHE) scores: 0.00%\n", - "Relative difference between scikit-learn (clear) and Concrete-ml (FHE) scores: 5.70%\n" + "Relative difference between scikit-learn (clear) and Concrete-ml (FHE) scores: 5.56%\n" ] } ], @@ -660,19 +660,19 @@ }, { "cell_type": "markdown", - "id": "1dab670d", + "id": "18786764", "metadata": {}, "source": [ - "We can observe that scikit-learn and Concrete-ML models output very close scores. This demonstrate how the quantization process has a very limited impact on performances.\n", + "We can observe that scikit-learn and Concrete-ML (quantized clear) models output very close scores. This demonstrate how the quantization process has a very limited impact on performances.\n", "\n", - "As for the spread in performance between Concrete-ml (FHE) and scikit-learn, there are also quote to one another. \n", - "* On the below graph, we see that test dataset has points for which `X` values are outside the range of training dataset. Since, when we compiled the quantized model we used `X_train`, then those `X` values in the test dataset outside the range of what is seen in `X_train`, then the decision rule poorly generalize on those values outside the boundaries observed on `X_tain`\n", - "* Moreover, keep in mind that the current notebook has been voluntarily performed with `n_bits = 6` whereas the default value is 8. Running the current notebook with a `n_bits > 6` will lead to a significant performance improvment and will close the performance gap with scikit-learn. " + "As for the spread in performance between Concrete-ml (FHE) and scikit-learn, there are also close to one another. \n", + "* On the below graph, we see that test dataset has points for which `X` values are outside the range of train dataset. Since, when we compiled the quantized model we used `X_train`, those `X` values in the test dataset were not seen by the compilation process, then the decision rule poorly generalizes on those values outside the boundaries observed on `X_tain`\n", + "* Moreover, keep in mind that the current notebook has been voluntarily performed with `n_bits = 6` whereas the default value is 8. Running the current notebook with a `n_bits > 6` will lead to a significant performance increase and will close the performance gap with scikit-learn. " ] }, { "cell_type": "markdown", - "id": "9a65a270", + "id": "87023b7e", "metadata": {}, "source": [ "### Visualize decision rule" @@ -680,8 +680,8 @@ }, { "cell_type": "code", - "execution_count": 105, - "id": "1f233390", + "execution_count": 18, + "id": "205ae5c4", "metadata": {}, "outputs": [], "source": [ @@ -694,13 +694,13 @@ }, { "cell_type": "code", - "execution_count": 106, - "id": "5dd358d4", + "execution_count": 19, + "id": "1825a31e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -725,7 +725,7 @@ }, { "cell_type": "markdown", - "id": "3bddb3fd", + "id": "141bc829", "metadata": {}, "source": [ "## Conclusion" @@ -733,294 +733,15 @@ }, { "cell_type": "markdown", - "id": "1bdaa448", + "id": "c44fff29", "metadata": {}, "source": [ - "In this tutorial, we have shown how easy it is to train and execute a linear regression model in FHE using Concrete-ML.\n", + "In this tutorial, we have shown how easy it is to train and execute a linearSVR regression model in FHE using Concrete-ML.\n", "\n", "We have also discussed the development flow of a FHE model: training, quantization, compilation and inference.\n", "\n", "The slight decrease in prediction quality is due to the quantization of the model's weights and input data, which makes the model poorly generalize outside of its training domain. However, this decrease remains negligible as both floating point (scikit-learn) and FHE (Concrete-ML) models give almost identical MSE scores." ] - }, - { - "cell_type": "code", - "execution_count": 120, - "id": "cf1e95be", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn import datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 124, - "id": "c08ebb8a", - "metadata": {}, - "outputs": [], - "source": [ - "# Load the diabetes dataset\n", - "diabetes_X, diabetes_y = datasets.load_diabetes(return_X_y=True)\n", - "# Use only one feature\n", - "diabetes_X = diabetes_X[:, np.newaxis, 2]\n", - "# We split the dataset into a training and a testing set\n", - "diabetes_X_train, diabetes_X_test, diabetes_y_train, diabetes_y_test = train_test_split(diabetes_X, diabetes_y, test_size=0.4, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 125, - "id": "85159f1b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fitting 5 folds for each of 9 candidates, totalling 45 fits\n" - ] - } - ], - "source": [ - "param_grid = {\n", - " \"epsilon\": [0.0, 1.0, 10.0],\n", - " \"C\": [0.1, 1.0, 10.0],\n", - "}\n", - "\n", - "sklearn_rgs = SklearnLinearSVR()\n", - "\n", - "gs_sklearn = GridSearchCV(\n", - " sklearn_rgs,\n", - " param_grid,\n", - " cv=5,\n", - " scoring=grid_scorer,\n", - " verbose=1,\n", - ").fit(diabetes_X_train, diabetes_y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "id": "d314d9e7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fitting 5 folds for each of 9 candidates, totalling 45 fits\n" - ] - } - ], - "source": [ - "param_grid = {\n", - " \"n_bits\": [6],\n", - " \"epsilon\": [0.0, 1.0, 10.0],\n", - " \"C\": [0.1, 1.0, 10.0],\n", - "}\n", - "\n", - "concrete_rgs = ConcreteLinearSVR()\n", - "\n", - "gs_concrete = GridSearchCV(\n", - " concrete_rgs,\n", - " param_grid,\n", - " cv=5,\n", - " scoring=grid_scorer,\n", - " verbose=1,\n", - ").fit(diabetes_X_train, diabetes_y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "id": "e331a055", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mean time fit sklearn: 0.001s, std time fit sklearn: 0.001s\n", - "Mean time fit concrete: 0.174s,std time fit concrete: 0.021s\n", - "Best MSE score sklearn: 6142.22\n", - "Best MSE score concrete: 6146.51\n" - ] - } - ], - "source": [ - "# Print mean time fit and std time fit for both models\n", - "print(\n", - " f\"Mean time fit sklearn: {np.mean(gs_sklearn.cv_results_['mean_fit_time']):.3f}s,\"\n", - " f\" std time fit sklearn: {np.std(gs_sklearn.cv_results_['mean_fit_time']):.3f}s\"\n", - ")\n", - "print(\n", - " f\"Mean time fit concrete: {np.mean(gs_concrete.cv_results_['mean_fit_time']):.3f}s,\"\n", - " f\"std time fit concrete: {np.std(gs_concrete.cv_results_['mean_fit_time']):.3f}s\"\n", - ")\n", - "\n", - "# Print best score for both models\n", - "print(f\"Best MSE score sklearn: {-gs_sklearn.best_score_:.2f}\")\n", - "print(f\"Best MSE score concrete: {-gs_concrete.best_score_:.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "id": "5a0bbdd8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best parameters for Concrete: {'C': 10.0, 'epsilon': 0.0, 'n_bits': 6}\n", - "Best parameters for Sklearn: {'C': 10.0, 'epsilon': 1.0}\n" - ] - }, - { - "data": { - "text/html": [ - "
LinearSVR(C=10.0, epsilon=1.0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "LinearSVR(C=10.0, epsilon=1.0)" - ] - }, - "execution_count": 127, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Get best hyper parameters out of gs_concrete\n", - "best_params_concrete = gs_concrete.best_params_\n", - "print(f\"Best parameters for Concrete: {best_params_concrete}\")\n", - "best_params_sklearn = gs_sklearn.best_params_\n", - "print(f\"Best parameters for Sklearn: {best_params_sklearn}\")\n", - "\n", - "# Train concrete and sklearn LinearSVR with best hyper parameters\n", - "concrete_rgs = ConcreteLinearSVR(**best_params_concrete)\n", - "sklearn_rgs = SklearnLinearSVR(**best_params_sklearn)\n", - "\n", - "concrete_rgs.fit(diabetes_X_train, diabetes_y_train)\n", - "sklearn_rgs.fit(diabetes_X_train, diabetes_y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 132, - "id": "e532ef07", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generating a key for an 6-bit circuit\n", - "Key generation time: 119.86 seconds\n", - "Execution time: 24.4823 seconds per sample\n", - "Execution time: 0.0000 seconds per sample\n", - "Execution time: 0.0002 seconds per sample\n" - ] - } - ], - "source": [ - "# Compile the model using the training data\n", - "circuit = concrete_rgs.compile(X_train)\n", - "\n", - "# Generate the key\n", - "print(f\"Generating a key for an {circuit.graph.maximum_integer_bit_width()}-bit circuit\")\n", - "\n", - "time_begin = time.time()\n", - "circuit.client.keygen(force=False)\n", - "print(f\"Key generation time: {time.time() - time_begin:.2f} seconds\")\n", - "\n", - "# Now predict using the FHE-quantized model on the testing set\n", - "time_begin = time.time()\n", - "y_pred_fhe = concrete_rgs.predict(diabetes_X_test, execute_in_fhe=True)\n", - "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")\n", - "\n", - "# Now predict using the Sklearn model on the testing set\n", - "time_begin = time.time()\n", - "y_pred_sklearn = sklearn_rgs.predict(diabetes_X_test)\n", - "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")\n", - "\n", - "# Now predict using clear quantized Concrete-ML model on testing set\n", - "time_begin = time.time()\n", - "y_preds_quantized = concrete_rgs.predict(diabetes_X_test)\n", - "print(f\"Execution time: {(time.time() - time_begin) / len(X_test):.4f} seconds per sample\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b7a23ae2", - "metadata": {}, - "outputs": [], - "source": [ - "# Print all MSE a string to explain\n", - "from sklearn.metrics import accuracy_score\n", - "\n", - "mse_sklearn = mean_squared_error(diabetes_y_test, y_pred_sklearn)\n", - "mse_clear = mean_squared_error(diabetes_y_test, y_preds_quantized)\n", - "mse_fhe = mean_squared_error(diabetes_y_test, y_pred_fhe)\n", - "\n", - "print(\n", - " f\"Clear FP32 sklearn model MSE: {mse_sklearn:.3f}\\n\"\n", - " f\"Clear quantized model MSE: {mse_clear:.3f}\\n\"\n", - " f\"FHE model MSE: {mse_fhe:.3f}\"\n", - ")\n", - "\n", - "# Measure the error of the FHE quantized model with respect to quantized clear Concrete-ML model\n", - "concrete_score_difference = abs(mse_fhe - mse_clear) * 100 / mse_clear\n", - "print(\n", - " \"\\nRelative difference between Concrete-ml (quantized clear) and Concrete-ml (FHE) scores:\",\n", - " f\"{concrete_score_difference:.2f}%\",\n", - ")\n", - "\n", - "\n", - "# Measure the error of the FHE quantized model with respect to the sklearn float model\n", - "score_difference = abs(mse_fhe - mse_sklearn) * 100 / mse_sklearn\n", - "print(\n", - " \"Relative difference between scikit-learn (clear) and Concrete-ml (FHE) scores:\",\n", - " f\"{score_difference:.2f}%\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "id": "140bce4d", - "metadata": {}, - "outputs": [], - "source": [ - "# We densify the space representation of the original X,\n", - "# to better visualize the resulting step function in the following figure\n", - "x_space = np.linspace(diabetes_X_test.min(), diabetes_X_test.max(), num=300)\n", - "x_space = x_space[:, np.newaxis]\n", - "y_pred_q_space = concrete_rgs.predict(x_space)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e8315fd7", - "metadata": {}, - "outputs": [], - "source": [ - "plt.ioff()\n", - "\n", - "plt.clf()\n", - "fig, ax = plt.subplots(1, figsize=(12, 8))\n", - "fig.patch.set_facecolor(\"white\")\n", - "ax.scatter(diabetes_X_train, diabetes_y_train, **train_plot_config)\n", - "ax.scatter(diabetes_X_test, diabetes_y_test, **test_plot_config)\n", - "ax.plot(diabetes_X_test, diabetes_y_pred_sklearn, **get_sklearn_plot_config(mse_sklearn))\n", - "ax.plot(x_space, y_pred_q_space, **get_concrete_plot_config(mse_clear))\n", - "ax.legend()\n", - "display(fig)" - ] } ], "metadata": {