ML_Encryption.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install crypten"
      ],
      "metadata": {
        "id": "SOLtHvZmS3hi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tjm8URkE1zwk"
      },
      "source": [
        "### Creating Encrypted Tensors\n",
        "CrypTen provides a ```crypten.cryptensor``` factory function, similar to ```torch.tensor```, to make creating ```CrypTensors``` easy.\n",
        "\n",
        "Let's begin by creating a ```torch``` tensor and encrypting it using ```crypten.cryptensor```. To decrypt a ```CrypTensor```, use ```get_plain_text()``` to return the original tensor.  (```CrypTensors``` can also be created directly from a list or an array.)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "krODn-TL1zwl",
        "outputId": "e47bdffe-32c7-4b5c-d72c-454765378d98"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MPCTensor(\n",
            "\t_tensor=tensor([[ 65536, 131072],\n",
            "        [196608, 262144]])\n",
            "\tplain_text=HIDDEN\n",
            "\tptype=ptype.arithmetic\n",
            ")\n",
            "tensor([[1., 2.],\n",
            "        [3., 4.]])\n",
            "MPCTensor(\n",
            "\t_tensor=tensor([262144, 327680, 393216])\n",
            "\tplain_text=HIDDEN\n",
            "\tptype=ptype.arithmetic\n",
            ")\n",
            "tensor([4., 5., 6.])\n"
          ]
        }
      ],
      "source": [
        "# Create torch tensor\n",
        "x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])\n",
        "\n",
        "# Encrypt x\n",
        "x_enc = crypten.cryptensor(x)\n",
        "\n",
        "crypten.print(x_enc)\n",
        "# Decrypt x\n",
        "x_dec = x_enc.get_plain_text()\n",
        "crypten.print(x_dec)\n",
        "\n",
        "\n",
        "# Create python list\n",
        "y = [4.0, 5.0, 6.0]\n",
        "\n",
        "# Encrypt y\n",
        "y_enc = crypten.cryptensor(y)\n",
        "crypten.print(y_enc)\n",
        "# Decrypt y\n",
        "y_dec = y_enc.get_plain_text(y_enc)\n",
        "crypten.print(y_dec)"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WRPpmHppXDrI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NHdu-SI51zwm"
      },
      "source": [
        "## Operations on Encrypted Tensors\n",
        "Now let's look at what we can do with our ```CrypTensors```.\n",
        "\n",
        "#### Arithmetic Operations\n",
        "We can carry out regular arithmetic operations between ```CrypTensors```, as well as between ```CrypTensors``` and plaintext tensors. Note that these operations never reveal any information about encrypted tensors (internally or externally) and return an encrypted tensor output."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AEC0TKfm1zwn",
        "outputId": "0ff4fc27-8e02-4eff-c23e-29d7a217853b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Public  addition: tensor([3., 4., 5.])\n",
            "Private addition: tensor([3., 4., 5.])\n",
            "\n",
            "Public  subtraction: tensor([-1.,  0.,  1.])\n",
            "Private subtraction: tensor([-1.,  0.,  1.])\n",
            "\n",
            "Public  multiplication: tensor([2., 4., 6.])\n",
            "Private multiplication: tensor([2., 4., 6.])\n",
            "\n",
            "Public  division: tensor([0.5000, 1.0000, 1.5000])\n",
            "Private division: tensor([0.5000, 1.0000, 1.5000])\n"
          ]
        }
      ],
      "source": [
        "#Arithmetic operations between CrypTensors and plaintext tensors\n",
        "x_enc = crypten.cryptensor([1.0, 2.0, 3.0])\n",
        "\n",
        "y = 2.0\n",
        "y_enc = crypten.cryptensor(2.0)\n",
        "\n",
        "\n",
        "# Addition\n",
        "z_enc1 = x_enc + y     # Public\n",
        "z_enc2 = x_enc + y_enc  # Private\n",
        "crypten.print(\"\\nPublic  addition:\", z_enc1.get_plain_text())\n",
        "crypten.print(\"Private addition:\", z_enc2.get_plain_text())\n",
        "\n",
        "\n",
        "# Subtraction\n",
        "z_enc1 = x_enc - y     # Public\n",
        "z_enc2 = x_enc - y_enc  # Private\n",
        "crypten.print(\"\\nPublic  subtraction:\", z_enc1.get_plain_text())\n",
        "print(\"Private subtraction:\", z_enc2.get_plain_text())\n",
        "\n",
        "# Multiplication\n",
        "z_enc1 = x_enc * y     # Public\n",
        "z_enc2 = x_enc * y_enc  # Private\n",
        "print(\"\\nPublic  multiplication:\", z_enc1.get_plain_text())\n",
        "print(\"Private multiplication:\", z_enc2.get_plain_text())\n",
        "\n",
        "# Division\n",
        "z_enc1 = x_enc / y      # Public\n",
        "z_enc2 = x_enc / y_enc  # Private\n",
        "print(\"\\nPublic  division:\", z_enc1.get_plain_text())\n",
        "print(\"Private division:\", z_enc2.get_plain_text())"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training custom pytorch model using Crypten"
      ],
      "metadata": {
        "id": "hxDlNAxjxdm0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import crypten\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# Load the CIFAR-10 dataset\n",
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,download=True, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,shuffle=True, num_workers=2)\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False,download=True, transform=transform)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=64,shuffle=False, num_workers=2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4YOWCCdniRk",
        "outputId": "448b2cc3-442b-41cf-86fd-dbb0d705281d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the model architecture\n",
        "class Net(torch.nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.conv1 = torch.nn.Conv2d(3, 6, 5)\n",
        "        self.pool = torch.nn.MaxPool2d(2, 2)\n",
        "        self.conv2 = torch.nn.Conv2d(6, 16, 5)\n",
        "        self.fc1 = torch.nn.Linear(16 * 5 * 5, 120)\n",
        "        self.fc2 = torch.nn.Linear(120, 84)\n",
        "        self.fc3 = torch.nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(torch.nn.functional.relu(self.conv1(x)))\n",
        "        x = self.pool(torch.nn.functional.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 16 * 5 * 5)\n",
        "        x = torch.nn.functional.relu(self.fc1(x))\n",
        "        x = torch.nn.functional.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "MJdUuzo-VIEt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Encrypt the model\n",
        "# set device to GPU if available, otherwise use CPU\n",
        "device = torch.device(\"cpu\")\n",
        "\n",
        "# initialize Crypten to use the same device\n",
        "crypten.init(device=device)\n",
        "\n",
        "dummy_input = torch.randn(1, 3, 32, 32).to(device)\n",
        "\n",
        "# Define the loss function and optimizer\n",
        "criterion = crypten.nn.CrossEntropyLoss().to(device)\n",
        "optimizer = crypten.optim.SGD\n",
        "\n",
        "# Train the model on encrypted data\n",
        "model = Net().to(device)\n",
        "encrypted_model = crypten.nn.from_pytorch(model, dummy_input.float()).to(device)\n",
        "encrypted_model.encrypt()\n",
        "optimizer = optimizer(encrypted_model.parameters(), lr=0.001, momentum=0.9)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kg66PoMBlr82",
        "outputId": "ce8358c9-a17e-47ae-bd75-a3cd53de0bff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "============= Diagnostic Run torch.onnx.export version 2.0.0+cu118 =============\n",
            "verbose: False, log level: Level.ERROR\n",
            "======================= 0 NONE 0 NOTE 0 WARNING 0 ERROR ========================\n",
            "\n",
            "============= Diagnostic Run torch.onnx.export version 2.0.0+cu118 =============\n",
            "verbose: False, log level: Level.ERROR\n",
            "======================= 0 NONE 0 NOTE 0 WARNING 0 ERROR ========================\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.9/dist-packages/crypten/__init__.py:64: RuntimeWarning: CrypTen is already initialized.\n",
            "  warnings.warn(\"CrypTen is already initialized.\", RuntimeWarning)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tqdm import tqdm\n",
        "import torch.nn.functional as F\n",
        "\n",
        "epochs =3\n",
        "for epoch in range(epochs):\n",
        "    running_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for i, (images, labels) in enumerate(tqdm(trainloader)):\n",
        "        encrypted_inputs = crypten.cryptensor(images.to(device))  # move input tensor to GPU\n",
        "        encrypted_labels = crypten.cryptensor(F.one_hot(labels.to(device), num_classes=10).to(device))\n",
        "        optimizer.zero_grad()\n",
        "        encrypted_outputs = encrypted_model(encrypted_inputs)\n",
        "        encrypted_loss = criterion(encrypted_outputs, encrypted_labels)\n",
        "        encrypted_loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        running_loss += encrypted_loss.get_plain_text().item()\n",
        "        _, predicted = encrypted_outputs.get_plain_text().max(1)\n",
        "        total += encrypted_labels.get_plain_text().size(0)\n",
        "        correct += predicted.eq(labels).sum().item()\n",
        "\n",
        "    epoch_loss = running_loss / len(trainloader)\n",
        "    epoch_acc = 100 * correct / total\n",
        "\n",
        "    print(f\"Epoch {epoch+1}/{epochs}, Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.2f}%\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AwQUyS5Crnpd",
        "outputId": "6b31cffd-af2c-4f97-a6e1-b9e8da3af539"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 782/782 [37:54<00:00,  2.91s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3, Loss: 2.3120, Accuracy: 10.60%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 782/782 [36:55<00:00,  2.83s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 2/3, Loss: 2.3109, Accuracy: 11.73%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 782/782 [36:47<00:00,  2.82s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 3/3, Loss: 2.3107, Accuracy: 12.49%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "image = testset[5][0][1]\n",
        "\n",
        "# Plot the image\n",
        "plt.imshow(image, cmap='gray')\n",
        "plt.axis('off')\n",
        "plt.show()\n",
        "\n",
        "# Print the label of the image\n",
        "print(\"Label for image is:\", testset[5][1])\n",
        "prediction = encrypted_model(crypten.cryptensor(testset[5][0].reshape([1,3,32,32]))).get_plain_text().argmax()\n",
        "print('Predicted label is:', int(prediction))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 442
        },
        "id": "F7YUi5R0Siya",
        "outputId": "191874cf-fe0a-4332-8550-e6cba9ca9fe1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Label for image is: 6\n",
            "Predicted label is: 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "correct = 0\n",
        "for image,label in tqdm(testset):\n",
        "  prediction = encrypted_model(crypten.cryptensor(image.reshape([1,3,32,32]))).get_plain_text().argmax()\n",
        "  if prediction == label:\n",
        "    correct = correct+1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tMYTRLNdKgeE",
        "outputId": "8de0cfd8-5380-4f59-f9b5-9e5b73d8c449"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 10000/10000 [24:11<00:00,  6.89it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Average test Accuracy :',float(correct / 10000))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p6-czjQXK80x",
        "outputId": "0383f8e9-4621-47b6-80bc-3e7a87673144"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average test Accuracy : 0.1345\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training Classifier model using Crypten"
      ],
      "metadata": {
        "id": "vwSqbb7fOx6h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "import torch\n",
        "import torchvision\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "#python 3.7 is required\n",
        "#assert sys.version_info[0] == 3 and sys.version_info[1] == 7, \"python 3.7 is required\"\n",
        "\n",
        "import crypten\n",
        "crypten.init()\n",
        "\n",
        "%matplotlib inline"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a498fe2f-ff9e-451f-b9c9-1c13a31720ef",
        "id": "RVgqcPJ2Ox6h"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.9/dist-packages/crypten/__init__.py:64: RuntimeWarning: CrypTen is already initialized.\n",
            "  warnings.warn(\"CrypTen is already initialized.\", RuntimeWarning)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "digits = torchvision.datasets.MNIST(root = '/temp/data', train = True, transform=torchvision.transforms.ToTensor(), download=True)\n",
        "\n",
        "digits_test = torchvision.datasets.MNIST(root = '/temp/data', train = False, transform=torchvision.transforms.ToTensor(), download=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9df09ce5-ef57-49b6-e816-0c98b774b528",
        "id": "Qh3Ym_3POx6i"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to /temp/data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9912422/9912422 [00:00<00:00, 188703454.67it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting /temp/data/MNIST/raw/train-images-idx3-ubyte.gz to /temp/data/MNIST/raw\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to /temp/data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 28881/28881 [00:00<00:00, 25268188.12it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting /temp/data/MNIST/raw/train-labels-idx1-ubyte.gz to /temp/data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to /temp/data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1648877/1648877 [00:00<00:00, 83204699.25it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting /temp/data/MNIST/raw/t10k-images-idx3-ubyte.gz to /temp/data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to /temp/data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4542/4542 [00:00<00:00, 17209149.75it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting /temp/data/MNIST/raw/t10k-labels-idx1-ubyte.gz to /temp/data/MNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ploting an imgae from MNIST data set and associate label"
      ],
      "metadata": {
        "id": "ujRm9FjdV1D6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(digits[1][0][0], cmap='gray', interpolation='none')\n",
        "print(\"label for image is \", digits[0][1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 448
        },
        "outputId": "30a4069b-0181-483e-83a3-32d7cd6b53e2",
        "id": "lronnBUqOx6i"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "label for image is  5\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "digits[1][1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f67ff53c-c64e-4b4c-ac55-6dbc8ab1f178",
        "id": "ND_DS_8HOx6i"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Preprocessing data for training"
      ],
      "metadata": {
        "id": "UVW9w_PxV_RS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def take_samples(digits, n_samples=1000):\n",
        "    \"\"\"Returns images and labels based on sample size\"\"\"\n",
        "    images, labels = [], []\n",
        "\n",
        "    for i, digit in enumerate(digits):\n",
        "        if i == n_samples:\n",
        "            break\n",
        "        # Prepare samples\n",
        "        image, label = digit\n",
        "        images.append(image)\n",
        "        temp = torch.nn.functional.one_hot(torch.tensor(label),10)\n",
        "        labels.append(temp)\n",
        "    images = torch.cat(images)\n",
        "    labels = torch.stack(labels)\n",
        "    return images, labels"
      ],
      "metadata": {
        "id": "Mk1_NjIUOx6i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare training samples using take_samples()\n",
        "images, labels = take_samples(digits, 1000)"
      ],
      "metadata": {
        "id": "Zi9qUIRhOx6i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare testing samples using take_samples()\n",
        "images_test, labels_test = take_samples(digits, 100)"
      ],
      "metadata": {
        "id": "GYa-9UBFOx6i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(images[5], cmap='gray', interpolation='none')\n",
        "print(\"label for image is \", labels[5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 448
        },
        "outputId": "dc23c996-0d12-40bc-c0ff-7d10447b6a42",
        "id": "2ylnPj6WOx6j"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "label for image is  tensor([0, 0, 1, 0, 0, 0, 0, 0, 0, 0])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Encrypting image and labels for training"
      ],
      "metadata": {
        "id": "GkaVBdqlWEZ9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Please encrypt the images and labels using crypten.cryptensor() function\n",
        "images_enc = crypten.cryptensor(images)\n",
        "labels_enc = crypten.cryptensor(labels)"
      ],
      "metadata": {
        "id": "3iJ2-g_qOx6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "encrypted image is stored in MPCTensor: encrypted using the secure MPC protocol. In order to support the mathematical"
      ],
      "metadata": {
        "id": "pYvZkxcaWJZ_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "images_enc[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aad41288-ef21-4ac3-aac7-b1e0d73346e2",
        "id": "5LFPAWl8Ox6j"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MPCTensor(\n",
              "\t_tensor=tensor([[    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,   771,  4626,  4626,  4626, 32382, 34952, 44975,  6682,\n",
              "         42662, 65536, 63479, 32639,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,  7710,  9252,\n",
              "         24158, 39578, 43690, 65021, 65021, 65021, 65021, 65021, 57825, 44204,\n",
              "         65021, 62194, 50115, 16448,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0, 12593, 61166, 65021,\n",
              "         65021, 65021, 65021, 65021, 65021, 65021, 65021, 64507, 23901, 21074,\n",
              "         21074, 14392, 10023,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,  4626, 56283, 65021,\n",
              "         65021, 65021, 65021, 65021, 50886, 46774, 63479, 61937,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0, 20560, 40092,\n",
              "         27499, 65021, 65021, 52685,  2827,     0, 11051, 39578,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,  3598,\n",
              "           257, 39578, 65021, 23130,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0, 35723, 65021, 48830,   514,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,  2827, 48830, 65021, 17990,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,  8995, 61937, 57825, 41120, 27756,   257,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0, 20817, 61680, 65021, 65021, 30583,  6425,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0, 11565, 47802, 65021, 65021, 38550,  6939,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,  4112, 23901, 64764, 65021, 48059,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0, 63993, 65021, 63993,\n",
              "         16448,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0, 11822, 33410, 47031, 65021, 65021, 53199,\n",
              "           514,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0, 10023, 38036, 58853, 65021, 65021, 65021, 64250, 46774,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "          6168, 29298, 56797, 65021, 65021, 65021, 65021, 51657, 20046,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,  5911, 16962,\n",
              "         54741, 65021, 65021, 65021, 65021, 50886, 20817,   514,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,  4626, 43947, 56283, 65021,\n",
              "         65021, 65021, 65021, 50115, 20560,  2313,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0, 14135, 44204, 58082, 65021, 65021, 65021,\n",
              "         65021, 62708, 34181,  2827,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0, 34952, 65021, 65021, 65021, 54484, 34695,\n",
              "         33924,  4112,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0],\n",
              "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
              "             0,     0,     0,     0,     0,     0,     0,     0]])\n",
              "\tplain_text=HIDDEN\n",
              "\tptype=ptype.arithmetic\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Plotting decrypted pixels of encrypted image"
      ],
      "metadata": {
        "id": "PVMuveXaYUsk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(images_enc.get_plain_text()[0], cmap='gray', interpolation='none')\n",
        "print(\"label for image is \", labels_enc.get_plain_text()[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 448
        },
        "outputId": "956eb191-5ad7-4c21-ff29-cfbbc2603369",
        "id": "vAo3ncFTOx6j"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "label for image is  tensor([0., 0., 0., 0., 0., 1., 0., 0., 0., 0.])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# prepare encrypt testing samples\n",
        "images_test_enc = crypten.cryptensor(images_test)\n",
        "labels_test_enc = crypten.cryptensor(labels_test)"
      ],
      "metadata": {
        "id": "UFX5zGKROx6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creating a simple Logistic regression model using crypten provided nn module\n",
        "\n",
        "\n",
        "The model takes in a flattened image tensor of size 784, and passes it through three fully connected layers with 256, 128, and 10 output units respectively. This allows the model to transform the input image into a 2D tensor of logits representing the probability distribution over the 10 possible digit classes"
      ],
      "metadata": {
        "id": "ymonjkrGYbp3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class LogisticRegression(crypten.nn.Module):\n",
        "\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        # images are 28x28 pixels\n",
        "        self.linear1 = crypten.nn.Linear(28 * 28, 256)\n",
        "        self.linear2= crypten.nn.Linear(256,128)\n",
        "        self.linear3= crypten.nn.Linear(128,10)\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = x.view(-1,784)\n",
        "        x = self.linear1(x)\n",
        "        x = self.linear2(x)\n",
        "        return self.linear3(x)\n",
        ""
      ],
      "metadata": {
        "id": "ndtDXBt8Ox6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Encrypting the crypten model"
      ],
      "metadata": {
        "id": "Pmlnp9BhYjIx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = LogisticRegression().encrypt()"
      ],
      "metadata": {
        "id": "XkOvzofVOx6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tesing the model functionality"
      ],
      "metadata": {
        "id": "B-Iy0Vr3Ym_Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model(images_enc.reshape([-1,28*28]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b3fcd33-d115-4a36-d3f9-8eef0b25f9d5",
        "id": "tzvHQEUpOx6j"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MPCTensor(\n",
              "\t_tensor=tensor([[ -9551,   3334, -12409,  ..., -10518,  -1740, -13630],\n",
              "        [ -7734,   3826,  -4487,  ..., -12209,     72,  -6832],\n",
              "        [ -3774,   5319,  -1444,  ...,  -7907,   6479,  -5489],\n",
              "        ...,\n",
              "        [ -1009,   7983,  -2998,  ..., -12763,   -197,  -6966],\n",
              "        [ -5696,   8636,  -7547,  ...,  -9947,  -1567,  -2560],\n",
              "        [ -5468,   7714,  -2079,  ...,  -6587,   3345,  -5343]])\n",
              "\tplain_text=HIDDEN\n",
              "\tptype=ptype.arithmetic\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Training the model"
      ],
      "metadata": {
        "id": "Z4yka7A4YpxA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def train_model(model, X, y, epochs=60, learning_rate=0.03):\n",
        "    criterion = crypten.nn.CrossEntropyLoss() #-sum(p * log(q))\n",
        "\n",
        "    for epoch in range(epochs):\n",
        "        model.zero_grad()\n",
        "        # calculate the loss\n",
        "        output = model(X)\n",
        "        loss = criterion(output, y)\n",
        "        print(f\"epoch {epoch} loss: {loss.get_plain_text()}\")\n",
        "        loss.backward()\n",
        "        model.update_parameters(learning_rate)\n",
        "    return model"
      ],
      "metadata": {
        "id": "yiZ0jHbAOx6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = train_model(model, images_enc.reshape(-1,784), labels_enc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c384fe9-a2d1-4279-f636-f47664cdd092",
        "id": "yPkZfj67Ox6k"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch 0 loss: 2.315460205078125\n",
            "epoch 1 loss: 2.3122711181640625\n",
            "epoch 2 loss: 2.3091888427734375\n",
            "epoch 3 loss: 2.3060150146484375\n",
            "epoch 4 loss: 2.3029632568359375\n",
            "epoch 5 loss: 2.29986572265625\n",
            "epoch 6 loss: 2.29681396484375\n",
            "epoch 7 loss: 2.293670654296875\n",
            "epoch 8 loss: 2.290679931640625\n",
            "epoch 9 loss: 2.2875823974609375\n",
            "epoch 10 loss: 2.28460693359375\n",
            "epoch 11 loss: 2.281494140625\n",
            "epoch 12 loss: 2.27850341796875\n",
            "epoch 13 loss: 2.275604248046875\n",
            "epoch 14 loss: 2.2725067138671875\n",
            "epoch 15 loss: 2.269561767578125\n",
            "epoch 16 loss: 2.2666168212890625\n",
            "epoch 17 loss: 2.2635955810546875\n",
            "epoch 18 loss: 2.260772705078125\n",
            "epoch 19 loss: 2.2577667236328125\n",
            "epoch 20 loss: 2.2547149658203125\n",
            "epoch 21 loss: 2.2518157958984375\n",
            "epoch 22 loss: 2.2489013671875\n",
            "epoch 23 loss: 2.245849609375\n",
            "epoch 24 loss: 2.242919921875\n",
            "epoch 25 loss: 2.239776611328125\n",
            "epoch 26 loss: 2.236785888671875\n",
            "epoch 27 loss: 2.2337646484375\n",
            "epoch 28 loss: 2.230621337890625\n",
            "epoch 29 loss: 2.2275848388671875\n",
            "epoch 30 loss: 2.2243804931640625\n",
            "epoch 31 loss: 2.2213592529296875\n",
            "epoch 32 loss: 2.218170166015625\n",
            "epoch 33 loss: 2.2150726318359375\n",
            "epoch 34 loss: 2.2118988037109375\n",
            "epoch 35 loss: 2.2087249755859375\n",
            "epoch 36 loss: 2.205535888671875\n",
            "epoch 37 loss: 2.202392578125\n",
            "epoch 38 loss: 2.1992034912109375\n",
            "epoch 39 loss: 2.195892333984375\n",
            "epoch 40 loss: 2.1926116943359375\n",
            "epoch 41 loss: 2.18914794921875\n",
            "epoch 42 loss: 2.185882568359375\n",
            "epoch 43 loss: 2.18255615234375\n",
            "epoch 44 loss: 2.1790924072265625\n",
            "epoch 45 loss: 2.17578125\n",
            "epoch 46 loss: 2.1722412109375\n",
            "epoch 47 loss: 2.168853759765625\n",
            "epoch 48 loss: 2.16534423828125\n",
            "epoch 49 loss: 2.161773681640625\n",
            "epoch 50 loss: 2.158233642578125\n",
            "epoch 51 loss: 2.1546478271484375\n",
            "epoch 52 loss: 2.15106201171875\n",
            "epoch 53 loss: 2.1474456787109375\n",
            "epoch 54 loss: 2.1436767578125\n",
            "epoch 55 loss: 2.139923095703125\n",
            "epoch 56 loss: 2.13623046875\n",
            "epoch 57 loss: 2.1323699951171875\n",
            "epoch 58 loss: 2.1285400390625\n",
            "epoch 59 loss: 2.124664306640625\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Make predictions on a test data image which is not used for training"
      ],
      "metadata": {
        "id": "dTWJctblZnl6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "prediction = model(crypten.cryptensor(images[3]).reshape(-1,28*28))\n",
        "prediction.get_plain_text().argmax()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ceea2e2d-d5da-49d2-805a-7b15ce094b3e",
        "id": "yqdrw-I8Ox6k"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(1)"
            ]
          },
          "metadata": {},
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(images[3], cmap='gray', interpolation='none')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 448
        },
        "outputId": "9ebb77f5-e87a-47b1-8e09-ca119acb0489",
        "id": "5fRgBEmGOx6k"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7ff7e90bd5b0>"
            ]
          },
          "metadata": {},
          "execution_count": 119
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Computing total average accuracy on entire test dataset"
      ],
      "metadata": {
        "id": "GBg7dajZZtnF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def avg_test_accuracy(model, X, y):\n",
        "    # calculate predicted labels and then calculate the accuracy with the groundtruth ones.\n",
        "    correct = 0\n",
        "    outputs = model(X.reshape(-1, 28*28))\n",
        "    predicted = outputs.get_plain_text()\n",
        "    labels = y.get_plain_text()\n",
        "    for i,j in zip(predicted,labels):\n",
        "      if i.argmax() == j.argmax():\n",
        "        correct = correct+1\n",
        "    print('Average test Accuracy :',float(correct / y.shape[0]))"
      ],
      "metadata": {
        "id": "G0XO8rPZOx6k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "avg_test_accuracy(model, images_test_enc.reshape([-1,28*28]), labels_test_enc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e27b36da-67e3-4208-b557-a9679e9a044e",
        "id": "fuMVesJtOx6k"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average test Accuracy : 0.69\n"
          ]
        }
      ]
    }
  ]
}