notebooks/tenseal_ckks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e232eab5-b1ff-45d6-af2b-3cd8ea96ab43",
   "metadata": {},
   "source": [
    "# TenSEAL CKKS - Introduction\n",
    "\n",
    "Homomorphic Encryption  is an encryption technique that allows computations to be made on ciphertexts and generates results that when decrypted, correspond to the results of the same computations made on plaintexts. \n",
    "\n",
    "**[CKKS - Cheon-Kim-Kim-Song](https://www.inferati.com/blog/fhe-schemes-ckks)** which is Homomorphic Encryption for Arithmetic of Approximate Numbers (HEAAN), was proposed to offer homomorphic computation on real numbers. The main idea is to consider the noise, a.k.a. error $ e$ , which is introduced in Ring-Learning with Errors (Ring-LWE) based FHE schemes for security purposes, as part of the message $\\mu $ (which we call here payload) we want to encrypt. The payload and the noise are combined to generate the plaintext ($\\mu + e$) that we encrypt.\n",
    "\n",
    "Next we will look at the most important object of the library, the TenSEALContext for CKKS HE Scheme :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1bc2206a-a319-4d5f-a807-4b511af481fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tenseal as ts\n",
    "import numpy as np\n",
    "import time as time\n",
    "%load_ext memory_profiler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2a625668-c234-4979-b289-95e1351212aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup TenSEAL context\n",
    "context = ts.context(\n",
    "            ts.SCHEME_TYPE.CKKS,\n",
    "            poly_modulus_degree=8192,\n",
    "            coeff_mod_bit_sizes=[60, 40, 40, 60]\n",
    "          )\n",
    "\"\"\"\n",
    "Genrate Galois Keys : Evaluation keys for the homomorphic rotation operation,\n",
    "which is the cyclic shift operations for rows of the encrypted matrix in one\n",
    "ciphertext of the BFV scheme and for encrypted message vector in that of the \n",
    "CKKS scheme.\n",
    "\"\"\"\n",
    "context.generate_galois_keys()\n",
    "context.global_scale = 2**40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f0c3ad4e-6ee5-43c5-bafb-598d0ee756ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add two vectors\n",
    "v1 = [5, 1, 2, 3, 4]\n",
    "v2 = [4, 3, 2, 1, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "83e951db-eb70-4199-bf75-0a8750d5cba6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encrypt the vectors using the CKKS scheme\n",
    "enc_v1 = ts.ckks_vector(context, v1)\n",
    "enc_v2 = ts.ckks_vector(context, v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be517816-eacd-4fe0-b1a5-c7a682942cb7",
   "metadata": {},
   "source": [
    "## Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "11bff1bc-813c-4193-a190-d690a1094106",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9.00000000168854,\n",
       " 3.999999998110309,\n",
       " 3.999999999964051,\n",
       " 4.000000000037462,\n",
       " 9.000000001457845]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_result = enc_v1 + enc_v2\n",
    "add_result.decrypt() # ~ [9,4,4,4,9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5cbc256-b143-48f6-90ef-b568b0652b77",
   "metadata": {},
   "source": [
    "### Time taken to perform addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5a2877ce-de62-4457-8b6c-3146af8f05d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homomorphic Addition takes:\n",
      "56.4 µs ± 358 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "peak memory: 174.73 MiB, increment: 0.11 MiB\n",
      "Vector Addition takes:\n",
      "1.56 µs ± 6.23 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "peak memory: 174.94 MiB, increment: 0.00 MiB\n",
      "Vector Addition is 36.068307582849556 times faster than Homomorphic Addition\n"
     ]
    }
   ],
   "source": [
    "print(\"Homomorphic Addition takes:\")\n",
    "he_add =  %timeit -o (enc_v1 + enc_v2)\n",
    "he_add_mem =  %memit -o (enc_v1 + enc_v2)\n",
    "\n",
    "print(\"Vector Addition takes:\")\n",
    "v_add = %timeit -o (np.array(v1) + np.array(v2))\n",
    "v_add_mem = %memit -o (np.array(v1) + np.array(v2))\n",
    "\n",
    "res = he_add.best / v_add.best\n",
    "\n",
    "print(\"Vector Addition is {} times faster than Homomorphic Addition\".format(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c86c206-f274-4470-a429-2b29ec354e23",
   "metadata": {},
   "source": [
    "## Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b6e568f6-3f28-420c-a85c-f792faafff13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2,  0,  2, -1])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subp_result = np.array(v1) - np.array(v2)\n",
    "subp_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a06e08d8-69cb-49c9-91ec-9580cef7b19c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.9999999930663853,\n",
       " -2.0000000009764403,\n",
       " 2.2837109425744018e-09,\n",
       " 2.000000000272445,\n",
       " -0.9999999986212919]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sub_result = enc_v1 - enc_v2\n",
    "sub_result.decrypt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f9ea8c7-b7cf-4397-bac3-e7e48e8317c4",
   "metadata": {},
   "source": [
    "### Time taken to perform Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "168d1ebe-a8a3-4e7e-948c-eda48d754bb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homomorphic Subtraction takes:\n",
      "52.4 µs ± 228 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "peak memory: 175.69 MiB, increment: 0.00 MiB\n",
      "Vector Subtraction takes:\n",
      "1.61 µs ± 11.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "peak memory: 175.86 MiB, increment: 0.00 MiB\n",
      "Vector Subtraction is 32.6571262505289 times faster than Homomorphic Subtraction\n"
     ]
    }
   ],
   "source": [
    "print(\"Homomorphic Subtraction takes:\")\n",
    "he_sub =  %timeit -o (enc_v2 - enc_v1)\n",
    "he_sub_mem =  %memit -o (enc_v2 - enc_v1)\n",
    "\n",
    "\n",
    "print(\"Vector Subtraction takes:\")\n",
    "v_sub = %timeit -o (np.array(v2) - np.array(v1))\n",
    "v_sub_mem = %memit -o (np.array(v2) - np.array(v1))\n",
    "\n",
    "res = he_sub.best / v_sub.best\n",
    "print(\"Vector Subtraction is {} times faster than Homomorphic Subtraction\".format(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec5f8aa3-2b8c-41b8-aeec-ff0ff66c23e4",
   "metadata": {},
   "source": [
    "## Negation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "92525c8e-aa56-430d-af81-0340e0117bb6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-4.999999997377462,\n",
       " -0.9999999985669354,\n",
       " -2.0000000011238805,\n",
       " -3.0000000001549534,\n",
       " -4.000000001418278]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neg_result = -enc_v1\n",
    "neg_result.decrypt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f7a6414-23dd-4f84-8c57-f5ae7e1f69bd",
   "metadata": {},
   "source": [
    "### Time taken to perform Negation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3aae75a7-b748-4820-ba14-f5b2288c84c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homomorphic Negation takes:\n",
      "39.5 µs ± 214 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "peak memory: 176.54 MiB, increment: 0.00 MiB\n",
      "Vector Subtraction takes:\n",
      "934 ns ± 5.37 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "peak memory: 176.54 MiB, increment: 0.00 MiB\n",
      "Vector Negation is 42.27770425793887 times faster than Homomorphic Negation\n"
     ]
    }
   ],
   "source": [
    "print(\"Homomorphic Negation takes:\")\n",
    "he_neg =  %timeit -o (-enc_v1)\n",
    "he_neg_mem =  %memit -o (-enc_v1)\n",
    "\n",
    "print(\"Vector Subtraction takes:\")\n",
    "v_neg = %timeit -o (-np.array(v1))\n",
    "v_neg_mem = %memit -o (-np.array(v1))\n",
    "\n",
    "res = he_neg.best / v_neg.best\n",
    "print(\"Vector Negation is {} times faster than Homomorphic Negation\".format(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85d5488f-b242-4513-a988-5599e8b3fc81",
   "metadata": {},
   "source": [
    "## Power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1dfd1f73-f5af-4044-8da7-0ab095b69cf6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[625.000585293541,\n",
       " 1.0000009341151213,\n",
       " 16.00001505487296,\n",
       " 81.00007606110789,\n",
       " 256.00024063446153]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power_res = enc_v1 ** 4\n",
    "power_res._decrypt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcd1b1b0-b757-4738-be6e-c93514cd99eb",
   "metadata": {},
   "source": [
    "### Time taken to calculate exponents and powers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6242c013-a880-45d3-93c3-2f0789432a70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homomorphic Negation takes:\n",
      "6.07 ms ± 58.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "peak memory: 178.18 MiB, increment: 0.00 MiB\n",
      "Vector Subtraction takes:\n",
      "1.76 µs ± 7.83 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "peak memory: 178.18 MiB, increment: 0.00 MiB\n",
      "Vector Negation is 3435.589111884566 times faster than Homomorphic Negation\n"
     ]
    }
   ],
   "source": [
    "print(\"Homomorphic Negation takes:\")\n",
    "he_pow =  %timeit -o (enc_v1 ** 4)\n",
    "he_pow_mem =  %memit -o (enc_v1 ** 4)\n",
    "\n",
    "print(\"Vector Subtraction takes:\")\n",
    "v_pow = %timeit -o (np.array(v1) ** 4)\n",
    "v_pow_mem = %memit -o (np.array(v1) ** 4)\n",
    "\n",
    "res = he_pow.best / v_pow.best\n",
    "print(\"Vector Negation is {} times faster than Homomorphic Negation\".format(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "993d0358-f3c6-40c0-ba42-f1182a4b76ff",
   "metadata": {},
   "source": [
    "## Dot Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0d10023f-248f-4f76-9b6d-eda3c43886bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[50.00000864874787]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = enc_v1.dot(enc_v2)\n",
    "result.decrypt() # ~ [50]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cb4b15b-725f-4c17-9e8d-7ce20ef79a6c",
   "metadata": {},
   "source": [
    "### Time taken to perform Dot Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f0d1ed24-5605-49a4-8500-cc88ecf0a220",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homomorphic Dot Product takes:\n",
      "9.28 ms ± 76 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "peak memory: 180.00 MiB, increment: 0.00 MiB\n",
      "Vector Dot Product takes:\n",
      "1.9 µs ± 18.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "peak memory: 180.00 MiB, increment: 0.00 MiB\n",
      "Vector Dot Product is 4863.666414601436 times faster than Homomorphic Dot Product\n"
     ]
    }
   ],
   "source": [
    "print(\"Homomorphic Dot Product takes:\")\n",
    "he_dp =  %timeit -o (enc_v1.dot(enc_v2))\n",
    "he_dp_mem =  %memit -o (enc_v1.dot(enc_v2))\n",
    "\n",
    "print(\"Vector Dot Product takes:\")\n",
    "v_dp = %timeit -o (np.array(v1).dot(np.array(v2)))\n",
    "v_dp_mem = %memit -o (np.array(v1).dot(np.array(v2)))\n",
    "\n",
    "res = he_dp.best / v_dp.best\n",
    "\n",
    "print(\"Vector Dot Product is {} times faster than Homomorphic Dot Product\".format(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "957f43ce-deb2-4c7d-9e3a-525e92905e3b",
   "metadata": {},
   "source": [
    "## Matrix Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0735c644-cc2c-42c2-afda-0a11ed3d17c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = [\n",
    "  [79, 0.15, 18],\n",
    "  [21, -5, 64],\n",
    "  [-18, -98, -3],\n",
    "  [1, 9, 87],\n",
    "  [88, 65 , 1],\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3f50a866-37f1-4fd3-a27c-af381c717a88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[735.0000984405782, 86.75001162554906, 413.0000555187746]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = enc_v1.matmul(matrix)\n",
    "result.decrypt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3223ba22-8273-4292-804e-a15872c79f6d",
   "metadata": {},
   "source": [
    "### Time taken to perform Matrix Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "104a4b69-9829-45de-b463-05246d7f51a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homomorphic Matrix Multiplication takes:\n",
      "20.7 ms ± 161 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "peak memory: 195.84 MiB, increment: 0.92 MiB\n",
      "Vector Matrix Multiplication takes:\n",
      "5.72 µs ± 107 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "peak memory: 195.91 MiB, increment: 0.00 MiB\n",
      "Vector Matrix Multiplication is 3644.0243077417385 times faster than HomomorphicMatrix Multiplication\n"
     ]
    }
   ],
   "source": [
    "print(\"Homomorphic Matrix Multiplication takes:\")\n",
    "he_mm =  %timeit -o (enc_v1.matmul(matrix))\n",
    "he_mm_mem =  %memit -o (enc_v1.matmul(matrix))\n",
    "\n",
    "print(\"Vector Matrix Multiplication takes:\")\n",
    "v_mm = %timeit -o (np.matmul(v1,matrix))\n",
    "v_mm_mem = %memit -o (np.matmul(v1,matrix))\n",
    "\n",
    "res = he_mm.best / v_mm.best\n",
    "\n",
    "print(\"Vector Matrix Multiplication is {} times faster than HomomorphicMatrix Multiplication\".format(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "864cd3b4-62f6-43de-ad41-4aa7b9f12205",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea912153-98e0-4451-a601-249eaa3d5527",
   "metadata": {},
   "source": [
    "In this notebook, we saw various capabilities and operations that are supported by CKKS scheme. These include - addition, subtraction, negation, power, multiplication, dot product, polynomial evaluation and matrix multiplication. In the future work, we can start looking into another capability of the CKKSvector that allows image block to columns operation and can be used for CNN for classification. "
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}