LR encrypted evaluation resampled.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l_ggClmoi9Ys"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qkL6se1lmBgO",
        "outputId": "2c7c5e62-c674-4837-86b0-b41c48d1cd96"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Collecting tenseal\n",
            "  Downloading tenseal-0.3.14-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.9 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.9/4.9 MB\u001b[0m \u001b[31m15.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: tenseal\n",
            "Successfully installed tenseal-0.3.14\n"
          ]
        }
      ],
      "source": [
        "!pip install tenseal"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OYg-xnhFmFgP",
        "outputId": "5858cde3-d151-4c59-94e1-93435b9ae726"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "# Mounting Google Drive locally to read datasets - pass if working on local!\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kz1jfnZ1sZVT",
        "outputId": "5c10496c-907d-43c7-af95-e8ccafd86537"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['msk_impact_2017_clinical_data.tsv', 'combined_encoded.csv', 'test_encoded.csv', 'train_encoded.csv', 'combined_or.csv']\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "path = \"/content/drive/MyDrive/ml4health/\" # change this to your local path where you have the datasets!\n",
        "print(os.listdir(path))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "hekOxf_2i9Yt"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import tenseal as ts\n",
        "import pandas as pd\n",
        "import random\n",
        "from time import time\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.metrics import accuracy_score, f1_score, roc_auc_score\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ueZGjydOvc6c"
      },
      "source": [
        "## Data resampling and scaling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gCiGu7JUi9Yv",
        "outputId": "893fb453-98df-457f-b850-147101e6e3c5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "############# Data summary #############\n",
            "x_train has shape: torch.Size([4339, 67])\n",
            "y_train has shape: torch.Size([4339, 1])\n",
            "x_test has shape: torch.Size([1859, 67])\n",
            "y_test has shape: torch.Size([1859, 1])\n",
            "#######################################\n"
          ]
        }
      ],
      "source": [
        "torch.random.manual_seed(73)\n",
        "random.seed(73)\n",
        "\n",
        "def split_train_test(x, y, test_ratio=0.3):\n",
        "    idxs = [i for i in range(len(x))]\n",
        "    random.Random(73).shuffle(idxs)\n",
        "    # delimiter between test and train data\n",
        "    delim = int(len(x) * test_ratio)\n",
        "    test_idxs, train_idxs = idxs[:delim], idxs[delim:]\n",
        "    return x[train_idxs], y[train_idxs], x[test_idxs], y[test_idxs]\n",
        "\n",
        "def cancer_data_resampled(path):\n",
        "    data = pd.read_csv(f\"{path}combined_or.csv\")\n",
        "    grouped = data.groupby(\"Overall Survival Status\")\n",
        "    data = grouped.apply(lambda x: x.sample(grouped.size().min(), random_state=73).reset_index(drop=True))\n",
        "\n",
        "    # extract labels\n",
        "    y = torch.tensor(data[\"Overall Survival Status\"].values).float().unsqueeze(1)\n",
        "    data = data.drop(\"Overall Survival Status\", axis = 1)\n",
        "\n",
        "    # standardize data\n",
        "    scaler = StandardScaler()\n",
        "    data = scaler.fit_transform(data)\n",
        "\n",
        "    x = torch.tensor(data).float()\n",
        "    return split_train_test(x, y)\n",
        "\n",
        "x_train_resampled, y_train_resampled, x_test_resampled, y_test_resampled = cancer_data_resampled(path)\n",
        "\n",
        "print(\"############# Data summary #############\")\n",
        "print(f\"x_train has shape: {x_train_resampled.shape}\")\n",
        "print(f\"y_train has shape: {y_train_resampled.shape}\")\n",
        "print(f\"x_test has shape: {x_test_resampled.shape}\")\n",
        "print(f\"y_test has shape: {y_test_resampled.shape}\")\n",
        "print(\"#######################################\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NErcQC9Ki9Yw"
      },
      "source": [
        "## 1-layer-NN LR functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "m4FTUPjhi9Yx"
      },
      "outputs": [],
      "source": [
        "class LR(torch.nn.Module):\n",
        "\n",
        "    def __init__(self, n_features):\n",
        "        super(LR, self).__init__()\n",
        "        self.lr = torch.nn.Linear(n_features, 1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = torch.sigmoid(self.lr(x))\n",
        "        return out"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "RQsw5mIhi9Yz"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 10\n",
        "\n",
        "def train(model, optim, criterion, x, y, epochs=EPOCHS):\n",
        "    for e in range(1, epochs + 1):\n",
        "        optim.zero_grad()\n",
        "        out = model(x)\n",
        "        loss = criterion(out, y)\n",
        "        loss.backward()\n",
        "        optim.step()\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UVbUy7yCXJh7"
      },
      "source": [
        "## Plain & encrypted evaluations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "SFR2maaZi9Y0"
      },
      "outputs": [],
      "source": [
        "class EncryptedLR:\n",
        "\n",
        "    def __init__(self, torch_lr):\n",
        "        self.weight = torch_lr.lr.weight.data.tolist()[0]\n",
        "        self.bias = torch_lr.lr.bias.data.tolist()\n",
        "\n",
        "    def forward(self, enc_x):\n",
        "        enc_out = enc_x.dot(self.weight) + self.bias\n",
        "        return enc_out\n",
        "\n",
        "    def __call__(self, *args, **kwargs):\n",
        "        return self.forward(*args, **kwargs)\n",
        "\n",
        "    def encrypt(self, context):\n",
        "        self.weight = ts.ckks_vector(context, self.weight)\n",
        "        self.bias = ts.ckks_vector(context, self.bias)\n",
        "\n",
        "    def decrypt(self, context):\n",
        "        self.weight = self.weight.decrypt()\n",
        "        self.bias = self.bias.decrypt()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "Pyb2k--ni9Y0"
      },
      "outputs": [],
      "source": [
        "# parameters\n",
        "poly_mod_degree = 4096\n",
        "coeff_mod_bit_sizes = [40, 20, 40]\n",
        "# create TenSEALContext\n",
        "ctx_eval = ts.context(ts.SCHEME_TYPE.CKKS, poly_mod_degree, -1, coeff_mod_bit_sizes)\n",
        "# scale of ciphertext to use\n",
        "ctx_eval.global_scale = 2 ** 20\n",
        "# this key is needed for doing dot-product operations\n",
        "ctx_eval.generate_galois_keys()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WsUlGk6zWsM1",
        "outputId": "2416a41b-2117-4ca2-9e3d-27695e8a9c3a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "## Non-encrypted evaluation results\n",
            "Accuracy mean: 0.6206 +- (0.00468, 0.00769)\n",
            "F1-score mean: 0.61793 +- (0.00602, 0.00472)\n",
            "ROC AUC score mean: 0.6206 +- (0.00464, 0.00758)\n",
            "Time mean: 0.00015\n",
            "\n",
            "\n",
            "## Encrypted evaluation results\n",
            "Accuracy mean: 0.61786 +- (0.00463, 0.00882)\n",
            "F1-score mean: 0.64586 +- (0.00739, 0.00645)\n",
            "ROC AUC score mean: 0.61883 +- (0.00455, 0.00876)\n",
            "Time mean: 20.96297\n"
          ]
        }
      ],
      "source": [
        "accuracy_list = []\n",
        "accuracy_list_encrypted = []\n",
        "f1_list = []\n",
        "f1_list_encrypted = []\n",
        "roc_auc_list = []\n",
        "roc_auc_list_encrypted = []\n",
        "time_list = []\n",
        "time_list_encrypted = []\n",
        "\n",
        "for _ in range(10): # training and HE evaluation 50 times\n",
        "    n_features = x_train_resampled.shape[1]\n",
        "    model = LR(n_features)\n",
        "\n",
        "    optim = torch.optim.SGD(model.parameters(), lr=.5)\n",
        "    criterion = torch.nn.BCELoss()\n",
        "    trained_model = train(model, optim, criterion, x_train_resampled, y_train_resampled)\n",
        "\n",
        "    t_start = time()\n",
        "    nc_out = trained_model(x_test_resampled)\n",
        "    t_end = time()\n",
        "    time_list.append(t_end-t_start)\n",
        "    nc_out = [1 if p >= 0.5 else 0 for p in nc_out]\n",
        "\n",
        "    accuracy = accuracy_score(y_test_resampled, nc_out)\n",
        "    f1 = f1_score(y_test_resampled, nc_out)\n",
        "    roc_auc = roc_auc_score(y_test_resampled, nc_out)\n",
        "\n",
        "    accuracy_list.append(accuracy)\n",
        "    f1_list.append(f1)\n",
        "    roc_auc_list.append(roc_auc)\n",
        "\n",
        "    # encrypted evaluation of the same model\n",
        "    t_start = time()\n",
        "    eelr = EncryptedLR(trained_model)\n",
        "    enc_x_test = [ts.ckks_vector(ctx_eval, x.tolist()) for x in x_test_resampled]\n",
        "    enc_y_test = []\n",
        "\n",
        "    for enc_x in enc_x_test:\n",
        "      enc_out = eelr(enc_x)\n",
        "      out = enc_out.decrypt()\n",
        "      out = torch.tensor(out)\n",
        "      out = torch.sigmoid(out)\n",
        "      enc_y_test.append(out)\n",
        "    t_end = time()\n",
        "\n",
        "    enc_y_test = [1 if p >= 0.5 else 0 for p in enc_y_test]\n",
        "\n",
        "    accuracy = accuracy_score(y_test_resampled, enc_y_test)\n",
        "    f1 = f1_score(y_test_resampled, enc_y_test)\n",
        "    roc_auc = roc_auc_score(y_test_resampled, enc_y_test)\n",
        "\n",
        "    accuracy_list_encrypted.append(accuracy)\n",
        "    f1_list_encrypted.append(f1)\n",
        "    roc_auc_list_encrypted.append(roc_auc)\n",
        "    time_list_encrypted.append(t_end-t_start)\n",
        "\n",
        "accuracy_mean = np.mean(accuracy_list)\n",
        "f1_mean = np.mean(f1_list)\n",
        "roc_auc_mean = np.mean(roc_auc_list)\n",
        "\n",
        "accuracy_diff = accuracy_mean - min(accuracy_list), max(accuracy_list) - accuracy_mean\n",
        "f1_diff = f1_mean - min(f1_list), max(f1_list) - f1_mean\n",
        "roc_auc_diff = roc_auc_mean - min(roc_auc_list), max(roc_auc_list) - roc_auc_mean\n",
        "\n",
        "print(\"## Non-encrypted evaluation results\")\n",
        "print(\"Accuracy mean:\", round(accuracy_mean, 5), \"+-\", tuple(round(diff, 5) for diff in accuracy_diff))\n",
        "print(\"F1-score mean:\", round(f1_mean, 5), \"+-\", tuple(round(diff, 5) for diff in f1_diff))\n",
        "print(\"ROC AUC score mean:\", round(roc_auc_mean, 5), \"+-\", tuple(round(diff, 5) for diff in roc_auc_diff))\n",
        "print(\"Time mean:\", round(np.mean(time_list), 5))\n",
        "print(\"\\n\", sep = \"\")\n",
        "\n",
        "accuracy_mean = np.mean(accuracy_list_encrypted)\n",
        "f1_mean = np.mean(f1_list_encrypted)\n",
        "roc_auc_mean = np.mean(roc_auc_list_encrypted)\n",
        "\n",
        "accuracy_diff = accuracy_mean - min(accuracy_list_encrypted), max(accuracy_list_encrypted) - accuracy_mean\n",
        "f1_diff = f1_mean - min(f1_list_encrypted), max(f1_list_encrypted) - f1_mean\n",
        "roc_auc_diff = roc_auc_mean - min(roc_auc_list_encrypted), max(roc_auc_list_encrypted) - roc_auc_mean\n",
        "\n",
        "print(\"## Encrypted evaluation results\")\n",
        "print(\"Accuracy mean:\", round(accuracy_mean, 5), \"+-\", tuple(round(diff, 5) for diff in accuracy_diff))\n",
        "print(\"F1-score mean:\", round(f1_mean, 5), \"+-\", tuple(round(diff, 5) for diff in f1_diff))\n",
        "print(\"ROC AUC score mean:\", round(roc_auc_mean, 5), \"+-\", tuple(round(diff, 5) for diff in roc_auc_diff))\n",
        "print(\"Time mean:\", round(np.mean(time_list_encrypted), 5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a3-d5mHMnv_2",
        "outputId": "03c6e171-b26a-4089-f46a-be18a5e7fada"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "## Non-encrypted evaluation results\n",
            "Accuracy mean: 0.62265 +- (0.00457, 0.00726)\n",
            "F1-score mean: 0.62367 +- (0.01201, 0.00902)\n",
            "ROC AUC score mean: 0.62276 +- (0.00444, 0.00725)\n",
            "\n",
            "\n",
            "## Encrypted evaluation results\n",
            "Accuracy mean: 0.61786 +- (0.00463, 0.00882)\n",
            "F1-score mean: 0.64586 +- (0.00739, 0.00645)\n",
            "ROC AUC score mean: 0.61883 +- (0.00455, 0.00876)\n",
            "Time mean: 21.84552\n"
          ]
        }
      ],
      "source": [
        "accuracy_list = []\n",
        "accuracy_list_encrypted_w = []\n",
        "f1_list = []\n",
        "f1_list_encrypted_w = []\n",
        "roc_auc_list = []\n",
        "roc_auc_list_encrypted_w = []\n",
        "time_list_encrypted_w = []\n",
        "\n",
        "for _ in range(10): # training and HE evaluation 50 times\n",
        "    n_features = x_train_resampled.shape[1]\n",
        "    model = LR(n_features)\n",
        "\n",
        "    optim = torch.optim.SGD(model.parameters(), lr=0.5)\n",
        "    criterion = torch.nn.BCELoss()\n",
        "    trained_model = train(model, optim, criterion, x_train_resampled, y_train_resampled)\n",
        "\n",
        "    nc_out = trained_model(x_test_resampled)\n",
        "    nc_out = [1 if p >= 0.5 else 0 for p in nc_out]\n",
        "\n",
        "    accuracy = accuracy_score(y_test_resampled, nc_out)\n",
        "    f1 = f1_score(y_test_resampled, nc_out)\n",
        "    roc_auc = roc_auc_score(y_test_resampled, nc_out)\n",
        "\n",
        "    accuracy_list.append(accuracy)\n",
        "    f1_list.append(f1)\n",
        "    roc_auc_list.append(roc_auc)\n",
        "\n",
        "    # encrypted evaluation of the same model\n",
        "    t_start = time()\n",
        "    eelr = EncryptedLR(trained_model)\n",
        "    enc_x_test = [ts.ckks_vector(ctx_eval, x.tolist()) for x in x_test_resampled]\n",
        "    enc_y_test = []\n",
        "    eelr.encrypt(ctx_eval)\n",
        "    for enc_x in enc_x_test:\n",
        "      enc_out = eelr(enc_x)\n",
        "      out = enc_out.decrypt()\n",
        "      out = torch.tensor(out)\n",
        "      out = torch.sigmoid(out)\n",
        "      enc_y_test.append(out)\n",
        "    t_end = time()\n",
        "\n",
        "    enc_y_test = [1 if p >= 0.5 else 0 for p in enc_y_test]\n",
        "\n",
        "    accuracy = accuracy_score(y_test_resampled, enc_y_test)\n",
        "    f1 = f1_score(y_test_resampled, enc_y_test)\n",
        "    roc_auc = roc_auc_score(y_test_resampled, enc_y_test)\n",
        "\n",
        "    accuracy_list_encrypted_w.append(accuracy)\n",
        "    f1_list_encrypted_w.append(f1)\n",
        "    roc_auc_list_encrypted_w.append(roc_auc)\n",
        "    time_list_encrypted_w.append(t_end-t_start)\n",
        "\n",
        "accuracy_mean = np.mean(accuracy_list)\n",
        "f1_mean = np.mean(f1_list)\n",
        "roc_auc_mean = np.mean(roc_auc_list)\n",
        "\n",
        "accuracy_diff = accuracy_mean - min(accuracy_list), max(accuracy_list) - accuracy_mean\n",
        "f1_diff = f1_mean - min(f1_list), max(f1_list) - f1_mean\n",
        "roc_auc_diff = roc_auc_mean - min(roc_auc_list), max(roc_auc_list) - roc_auc_mean\n",
        "\n",
        "print(\"## Non-encrypted evaluation results\")\n",
        "print(\"Accuracy mean:\", round(accuracy_mean, 5), \"+-\", tuple(round(diff, 5) for diff in accuracy_diff))\n",
        "print(\"F1-score mean:\", round(f1_mean, 5), \"+-\", tuple(round(diff, 5) for diff in f1_diff))\n",
        "print(\"ROC AUC score mean:\", round(roc_auc_mean, 5), \"+-\", tuple(round(diff, 5) for diff in roc_auc_diff))\n",
        "print(\"\\n\", sep = \"\")\n",
        "\n",
        "accuracy_mean = np.mean(accuracy_list_encrypted)\n",
        "f1_mean = np.mean(f1_list_encrypted)\n",
        "roc_auc_mean = np.mean(roc_auc_list_encrypted)\n",
        "\n",
        "accuracy_diff = accuracy_mean - min(accuracy_list_encrypted), max(accuracy_list_encrypted) - accuracy_mean\n",
        "f1_diff = f1_mean - min(f1_list_encrypted), max(f1_list_encrypted) - f1_mean\n",
        "roc_auc_diff = roc_auc_mean - min(roc_auc_list_encrypted), max(roc_auc_list_encrypted) - roc_auc_mean\n",
        "\n",
        "print(\"## Encrypted evaluation results\")\n",
        "print(\"Accuracy mean:\", round(accuracy_mean, 5), \"+-\", tuple(round(diff, 5) for diff in accuracy_diff))\n",
        "print(\"F1-score mean:\", round(f1_mean, 5), \"+-\", tuple(round(diff, 5) for diff in f1_diff))\n",
        "print(\"ROC AUC score mean:\", round(roc_auc_mean, 5), \"+-\", tuple(round(diff, 5) for diff in roc_auc_diff))\n",
        "print(\"Time mean:\", round(np.mean(time_list_encrypted_w), 5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kC3jbYavvoSy"
      },
      "source": [
        "## Plotting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "mr4_hYBnRsfi"
      },
      "outputs": [],
      "source": [
        "f1_ = [np.mean(f1_list), np.mean(f1_list_encrypted), np.mean(f1_list_encrypted_w)]\n",
        "f1_std = [np.std(f1_list), np.std(f1_list_encrypted), np.std(f1_list_encrypted_w)]\n",
        "\n",
        "roc_ = [np.mean(roc_auc_list), np.mean(roc_auc_list_encrypted), np.mean(roc_auc_list_encrypted_w)]\n",
        "roc_std = [np.std(roc_auc_list), np.std(roc_auc_list_encrypted), np.std(roc_auc_list_encrypted_w)]\n",
        "\n",
        "acc_ = [np.mean(accuracy_list), np.mean(accuracy_list_encrypted), np.mean(accuracy_list_encrypted_w)]\n",
        "acc_std = [np.std(accuracy_list), np.std(accuracy_list_encrypted), np.std(accuracy_list_encrypted_w)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 407
        },
        "id": "b383vUt0Ti4b",
        "outputId": "0bdfb4e2-b0e4-490c-edbf-673f63bc7cb3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 600x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "model_names = ['Unencrypted', 'Encrypted', 'Encrypted with Weights']\n",
        "x = np.arange(len(model_names))\n",
        "width = 0.2\n",
        "fig, ax = plt.subplots(figsize=(6, 4))\n",
        "\n",
        "rects1 = ax.bar(x=x - width, height=f1_, width=width, label='F1', color='navy', yerr=f1_std)\n",
        "rects2 = ax.bar(x=x, height=roc_, width=width, label='ROC-AUC', color='gold', yerr=roc_std)\n",
        "rects3 = ax.bar(x=x + width, height=acc_, width=width, label='Accuracy', color='teal', yerr=acc_std)\n",
        "\n",
        "ax.set_ylabel('Scores', fontsize=10)\n",
        "ax.set_title('Evaluation with different encryptions', fontsize=10)\n",
        "ax.set_xticks(x + width / 2)\n",
        "ax.set_xticklabels(model_names, fontsize=9)\n",
        "ax.legend(loc='lower center', bbox_to_anchor=(.83, 0), fontsize=8)\n",
        "ax.tick_params(axis='y', labelsize=9)\n",
        "ax.grid(True, linestyle='--')\n",
        "fig.tight_layout()\n",
        "\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XU5REt9RrtQt"
      },
      "source": [
        "**Note:** Plots might differ slightly each run due to the noise added from encryption's precision and SGD getting stuck on local minima, which effects label assigning after decryption and horribly fails the encrypted evaluation metrics. If metrics are too much off from our example here, delete runtime and run the code again where the plot above shows the most frequent results we have observed."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.9.6 (default, Sep 26 2022, 11:37:49) \n[Clang 14.0.0 (clang-1400.0.29.202)]"
    },
    "vscode": {
      "interpreter": {
        "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}