demos/linear_regression_demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encrypted Linear Regression Tutorial\n",
    "This Jupyter notebook provides an introduction to using EncryptedLinearRegression from the venumML library, built on top of venumpy.\n",
    "\n",
    "Note: This is a basic example and might require additional libraries for data manipulation and visualization depending on your specific needs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('..')\n",
    "\n",
    "import venumpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Plaintext Linear Regression with scikit-learn\n",
    "Before diving into EncryptedLinearRegression, let's explore unencrypted linear regression using scikit-learn (sklearn). Sklearn provides a widely used implementation of linear regression with the LinearRegression class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scikit-Learn Coefficients: [55.58970623 15.4175784 ]\n",
      "Scikit-Learn Intercept: 0.04137759409549702\n",
      "6.21 ns ± 0.0105 ns per loop (mean ± std. dev. of 7 runs, 100,000,000 loops each)\n",
      "Scikit-Learn Predictions: [-34.44463524  47.28440292]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.datasets import make_regression\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Step 1: Generate Sample Data\n",
    "X, y = make_regression(n_samples=10, n_features=2, noise=0.1)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "sk_lr = LinearRegression()\n",
    "sk_lr.fit(X_train, y_train)\n",
    "\n",
    "print(\"Scikit-Learn Coefficients:\", sk_lr.coef_)\n",
    "print(\"Scikit-Learn Intercept:\", sk_lr.intercept_)\n",
    "\n",
    "# Compare with Scikit-Learn predictions\n",
    "sk_lr_predictions = sk_lr.predict(X_test)\n",
    "\n",
    "%timeit sk_lr_predictions\n",
    "print(\"Scikit-Learn Predictions:\", sk_lr_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The steps for plaintext linear regression are:\n",
    "\n",
    "- We import LinearRegression from sklearn.linear_model.\n",
    "- We create an instance of LinearRegression and train it on the data using fit(X, y).\n",
    "- We define new data (X_new) for prediction.\n",
    "- We use the trained model's predict(X_new) method to get the predicted target value.\n",
    "- We print the predicted value for the new data point.\n",
    "- This section demonstrates how to use scikit-learn's LinearRegression for prediction, similar to how we'll use EncryptedLinearRegression in the next sections."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VenumML EncryptedLinearRegression Class\n",
    "This class implements a linear regression model with support for encrypted data. It allows you to perform encrypted predictions without revealing the underlying model parameters or the data itself.\n",
    "\n",
    "#### Encryption Approach:\n",
    "\n",
    "This class is designed to enable computations over encrypted data by using Fully Homomorphic Encryption (FHE). FHE enables computations on encrypted data, allowing the model to perform linear regression without decrypting the input data.\n",
    "\n",
    "#### Class Attributes:\n",
    "\n",
    "context: Venumpy context object used for encryption and decryption. This can be defined as an argument in the constructor or as a class attribute depending on how you want to manage the encryption context for your models.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encrypted Linear Regression with venumpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from venumMLlib.linear_models.regression.linear_regression import EncryptedLinearRegression\n",
    "from venumMLlib.venum_tools import encrypt_array\n",
    "\n",
    "# Create venumpy context with 128 bits of security\n",
    "ctx = venumpy.SecretContext.new_with_security(128)\n",
    "ctx.precision = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array([[1, 2], [2, 3], [3, 5], [4, 7], [5, 11]])  # Features\n",
    "y = np.array([2, 4, 5, 4, 5])\n",
    "       \n",
    "# 1D array\n",
    "model = EncryptedLinearRegression(ctx)\n",
    "model.fit(X, y)\n",
    "model.encrypt_coefficients(ctx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VENum Linear Regression Coefficients: [55.58970623 15.4175784 ]\n",
      "VENum Linear Regression Intercept: 0.04137759409550057\n",
      "6.33 ns ± 0.0212 ns per loop (mean ± std. dev. of 7 runs, 100,000,000 loops each)\n",
      "Decrypted VENum Predictions: [-34.444632527844, 47.284414057984]\n"
     ]
    }
   ],
   "source": [
    "# Step 1: Sample Data from previous sklearn is used\n",
    "\n",
    "# Step 2: Train EncryptedLinearRegression and Scikit-Learn LinearRegression\n",
    "my_lr = EncryptedLinearRegression(ctx)\n",
    "my_lr.fit(X_train, y_train)\n",
    "\n",
    "# Compare the Coefficients and Intercept\n",
    "print(\"VENum Linear Regression Coefficients:\", my_lr.coef_)\n",
    "print(\"VENum Linear Regression Intercept:\", my_lr.intercept_)\n",
    "\n",
    "# Test Inference\n",
    "my_lr.encrypt_coefficients(ctx)\n",
    "\n",
    "cipher_X = encrypt_array(X_test,ctx)\n",
    "\n",
    "# Now cipher_X is a flat list of encrypted features\n",
    "my_lr_predictions = my_lr.predict(cipher_X,ctx)\n",
    "\n",
    "# Decrypt predictions\n",
    "decrypted_predictions = [pred.decrypt() for pred in my_lr_predictions]\n",
    "\n",
    "# Compare with Scikit-Learn predictions\n",
    "sk_lr_predictions = sk_lr.predict(X_test)\n",
    "\n",
    "%timeit my_lr_predictions\n",
    "# Output comparisons (Note: The decrypted predictions need to be reshaped or processed further to match the format of sk_lr_predictions)\n",
    "print(\"Decrypted VENum Predictions:\", decrypted_predictions)"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}