LR_Covid_19.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "LR_Covid-19.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Sprivacy/DP-Utility-in-ML/blob/main/LR_Covid_19.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KspMQ2eyEgeb",
        "outputId": "d5733fd6-4e72-4228-dab4-31abc543e647"
      },
      "source": [
        "#Mount Data on your google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/gdrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ORYjzyRMCXh0"
      },
      "source": [
        "!pip install tensorflow_privacy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gzh6Hrx1CfY9",
        "outputId": "ffcac642-e745-49c5-bb1b-0a83b2fd29be"
      },
      "source": [
        "#Neccessary Libraries for DP-SGD\n",
        "try:\n",
        "  # %tensorflow_version only exists in Colab.\n",
        "  %tensorflow_version 1.x\n",
        "except Exception:\n",
        "  pass\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "tf.compat.v1.logging.set_verbosity(tf.logging.ERROR)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TensorFlow 1.x selected.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "05A7eRXsUK9p"
      },
      "source": [
        "#importing libraries\n",
        "#from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy\n",
        "#from tensorflow_privacy.privacy.optimizers.dp_optimizer import DPGradientDescentGaussianOptimizer\n",
        "from tensorflow.keras.datasets import cifar10\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n",
        "from tensorflow.keras.losses import sparse_categorical_crossentropy\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import datasets, layers, models\n",
        "import matplotlib.pyplot as plt\n",
        "import sys\n",
        "from matplotlib import pyplot\n",
        "from keras.datasets import cifar10\n",
        "from keras.utils import to_categorical\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Conv2D\n",
        "from keras.layers import MaxPooling2D\n",
        "from keras.layers import Dense\n",
        "from keras.layers import Flatten\n",
        "from keras.layers import Dropout\n",
        "from keras.optimizers import SGD\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
        "from sklearn.model_selection import train_test_split\n",
        "import tensorflow as tf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rn-a7VJXUWLu"
      },
      "source": [
        "df = pd.read_csv('/content/gdrive/My Drive/Medical/covid.csv', low_memory=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-pMFw6mVVthD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 142
        },
        "outputId": "1024786a-2879-4522-9a58-f999d12b5a95"
      },
      "source": [
        "df.isnull().sum()\n",
        "df.drop(columns={'entry_date','date_died','date_symptoms','id'},axis=1,inplace=True)\n",
        "df['covid_res'].value_counts().to_frame()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>covid_res</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>279035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>220657</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>66910</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   covid_res\n",
              "2     279035\n",
              "1     220657\n",
              "3      66910"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "smTxqd7xWDGQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 142
        },
        "outputId": "74cce90d-07e7-4e41-bb2f-95b92d8537ef"
      },
      "source": [
        "df['covid_res'].replace([1,2,3],[1,0,2],inplace=True)\n",
        "df['covid_res'].value_counts().to_frame()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>covid_res</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>279035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>220657</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>66910</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   covid_res\n",
              "0     279035\n",
              "1     220657\n",
              "2      66910"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DpmQ6dcfXvgq"
      },
      "source": [
        "df.rename(columns={'covid_res':'Chance'},inplace=True)\n",
        "#only take positive or negative patient, ignore awaiting patient\n",
        "df=df[df['Chance']!=2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QC5yO-RdX8w7"
      },
      "source": [
        "df=df[df['intubed']!=97]\n",
        "df['intubed'].value_counts().sort_index().plot.bar()\n",
        "df=df[df['intubed']!=99]\n",
        "df['intubed'].value_counts().to_frame()\n",
        "df=df[df['pneumonia']!=99]\n",
        "df=df[df['pregnancy']!=97]\n",
        "df=df[df['pregnancy']!=98]\n",
        "df=df[df['diabetes']!=98]\n",
        "df=df[df['copd']!=98]\n",
        "df=df[df['asthma']!=98]\n",
        "df=df[df['inmsupr']!=98]\n",
        "df=df[df['hypertension']!=98]\n",
        "df=df[df['other_disease']!=98]\n",
        "df=df[df['cardiovascular']!=98]\n",
        "df=df[df['obesity']!=98]\n",
        "df=df[df['renal_chronic']!=98]\n",
        "df=df[df['tobacco']!=98]\n",
        "df=df[df['contact_other_covid']!=99]\n",
        "df=df[df['icu']!=99]\n",
        "df=df[df['icu']!=97]\n",
        "df.reset_index(drop=True,inplace=True)\n",
        "df.head(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VYbSZvhYZHvR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4b4d4173-dd3c-4157-fea8-3f624dcfd3dd"
      },
      "source": [
        "features=['sex', 'patient_type', 'intubed', 'pneumonia', 'age', 'pregnancy',\n",
        "       'diabetes', 'copd', 'asthma', 'inmsupr', 'hypertension',\n",
        "       'other_disease', 'cardiovascular', 'obesity', 'renal_chronic',\n",
        "       'tobacco', 'contact_other_covid', 'icu']\n",
        "list(enumerate(features))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(0, 'sex'),\n",
              " (1, 'patient_type'),\n",
              " (2, 'intubed'),\n",
              " (3, 'pneumonia'),\n",
              " (4, 'age'),\n",
              " (5, 'pregnancy'),\n",
              " (6, 'diabetes'),\n",
              " (7, 'copd'),\n",
              " (8, 'asthma'),\n",
              " (9, 'inmsupr'),\n",
              " (10, 'hypertension'),\n",
              " (11, 'other_disease'),\n",
              " (12, 'cardiovascular'),\n",
              " (13, 'obesity'),\n",
              " (14, 'renal_chronic'),\n",
              " (15, 'tobacco'),\n",
              " (16, 'contact_other_covid'),\n",
              " (17, 'icu')]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8nVKF1HAZNjt"
      },
      "source": [
        "X=df[['sex', 'patient_type', 'intubed', 'pneumonia', 'age', 'pregnancy',\n",
        "       'diabetes', 'copd', 'asthma', 'inmsupr', 'hypertension',\n",
        "       'other_disease', 'cardiovascular', 'obesity', 'renal_chronic',\n",
        "       'tobacco', 'contact_other_covid', 'icu']]\n",
        "y=df['Chance']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vCxr0GwJZZPa"
      },
      "source": [
        "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
        "scaler = StandardScaler()\n",
        "X = scaler.fit_transform(X)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n3LbeRlMZmOj"
      },
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, random_state=42)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OyiyM-RUTaAG"
      },
      "source": [
        "Input Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BjG57OLATcAV"
      },
      "source": [
        "n=5000\n",
        "xtrain=X_train[0:n]\n",
        "ytrain=y_train[0:n]\n",
        "xtest=X_test[0:n]\n",
        "ytest=y_test[0:n]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wAfxHIhaTegy"
      },
      "source": [
        "#Non-private accuracy \n",
        "from sklearn.linear_model import LogisticRegression\n",
        "model = LogisticRegression(penalty='l2',max_iter=100,C=10000).fit(xtrain, ytrain)\n",
        "np_in=model.score(xtest, ytest)\n",
        "np_in"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Soib0qaTTkZv"
      },
      "source": [
        "ep=[0.01, 0.1,1,10,100,1000,10000]\n",
        "ni=len(ep)\n",
        "acc_in=np.zeros(ni)\n",
        "for i in range(ni):\n",
        "  epi=ep[i]\n",
        "  delta=.0001\n",
        "  C=1\n",
        "  z=3*np.log(5000)\n",
        "  z1=z**2\n",
        "  sigma=z1*(8*np.log(2/(delta/2))+4*epi)/(epi**2)\n",
        "  #sigma=calc_sigma(ep[i],delta,18,1/C)\n",
        "  nsi=np.random.normal(loc=0.0, scale=sigma/n)\n",
        "  print(nsi)\n",
        "  X_in=xtrain-nsi\n",
        "  model_in = LogisticRegression(penalty='l2',max_iter=100,C=10000).fit(X_in, ytrain)\n",
        "  acc_in[i]=model_in.score(xtest, ytest)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jwcRjWVc9cVS"
      },
      "source": [
        "Objective Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rt1LF3569l6P"
      },
      "source": [
        "!pip install diffprivlib"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b6yMb6Cz9xT3"
      },
      "source": [
        "from diffprivlib.models import LogisticRegression\n",
        "ep=[0.01, 0.1,1,10,100,1000,10000]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0_paBH_L-XAz"
      },
      "source": [
        "n=5000\n",
        "xtrain=X_train[0:n]\n",
        "ytrain=y_train[0:n]\n",
        "xtest=X_test[0:n]\n",
        "ytest=y_test[0:n]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nvCYKeDB92k0"
      },
      "source": [
        "#objective Perturbation\n",
        "n=len(ep)\n",
        "acc_obj=np.zeros(n)\n",
        "for i in range(len(ep)):\n",
        "     obj_model=LogisticRegression(data_norm=12, epsilon=ep[i],penalty='l2',max_iter=100,C=10000).fit(xtrain, ytrain)\n",
        "     acc_obj[i]=obj_model.score(xtest,ytest)    #take model accuracy for different privacy budget"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXsSlyvy-Bo2"
      },
      "source": [
        "acc_obj"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uO0Nk0iaSVlb"
      },
      "source": [
        "#simple logistic regression/non-private\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "model = LogisticRegression(penalty='l2',max_iter=100,C=10000).fit(xtrain, ytrain)\n",
        "non_p=model.score(xtest, ytest)\n",
        "print(non_p)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlyr7ykh_yZL"
      },
      "source": [
        "Gradient Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KJmnLf9OAH5o"
      },
      "source": [
        "from keras.regularizers import l2\n",
        "def SGD_lg(noise_multiplier,x_train,y_train,x_test,y_test):\n",
        "   epochs = 100\n",
        "   batch_size = 250\n",
        "   l2_norm_clip = 1.5\n",
        "   #noise_multiplier = .88\n",
        "   num_microbatches = 125\n",
        "   learning_rate = 0.01\n",
        "   x_train_s=x_train\n",
        "   y_train_s=y_train\n",
        "   x_test=x_test\n",
        "   y_test_s=y_test\n",
        "   n=len(y_train)\n",
        "   delta=1e-4\n",
        "   #noise_multiplier=.5\n",
        "   if batch_size % num_microbatches != 0:\n",
        "     raise ValueError('Batch size should be an integer multiple of the number of microbatches')\n",
        "   \n",
        "   eps=compute_dp_sgd_privacy.compute_dp_sgd_privacy(n=n, batch_size=250, noise_multiplier=noise_multiplier, epochs=epochs, delta=1e-4)\n",
        "   print(eps)\n",
        "\n",
        "   model = tf.keras.Sequential([tf.keras.layers.Flatten(),\n",
        "                               tf.keras.layers.Dense(18, activation = tf.nn.relu), \n",
        "                                   tf.keras.layers.Dense(units=2, activation='sigmoid',kernel_regularizer=l2(.0001))\n",
        "       ])\n",
        "   #model=build_lg_model()\n",
        "   print(\"compplete\")\n",
        "   optimizer = DPGradientDescentGaussianOptimizer(\n",
        "            l2_norm_clip=l2_norm_clip,\n",
        "            noise_multiplier=noise_multiplier,\n",
        "            num_microbatches=num_microbatches,\n",
        "            learning_rate=learning_rate)\n",
        "   \n",
        "   loss = tf.keras.losses.CategoricalCrossentropy(\n",
        "    from_logits=True, reduction=tf.losses.Reduction.NONE)\n",
        "   model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n",
        "   model.fit(x_train_s, y_train_s,\n",
        "          epochs=epochs,\n",
        "          validation_data=(x_test[0:1000], y_test_s[0:1000]),\n",
        "          batch_size=batch_size)\n",
        "   return model,eps[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DZEQXqz8BFxA"
      },
      "source": [
        "#model=SGD_lg(1,x_train[0:15000],trainY[0:15000],x_test,testY)\n",
        "def calc_labelAcc(Model,xtest,ytest):\n",
        "  from sklearn.metrics import accuracy_score\n",
        "  ypred=Model.predict_classes(xtest)\n",
        "  acc=accuracy_score(label(ytest), ypred)\n",
        "  return acc\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FjrkbBmzBNwg"
      },
      "source": [
        "trainY=to_categorical(y_train)\n",
        "testY=to_categorical(y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XTrDSHEfKsDz"
      },
      "source": [
        "x_train=X_train.reshape(X_train.shape[0],len(X_train[0]),1)\n",
        "x_test=X_test.reshape(X_test.shape[0],len(X_test[0]),1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S4P1UQed1Zvr"
      },
      "source": [
        "noise_mul=[450,66,7.9,1.298,.488,.2765,.1827]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yUUQUfnmBLUx"
      },
      "source": [
        "###training and testing data\n",
        "n=5000\n",
        "xtrain_agg=x_train[0:n]\n",
        "ytrain_agg=trainY[0:n]\n",
        "#ytrain_agg=ytrain_agg.to_numpy()\n",
        "#ytrain_pred=model_np.predict_proba(xtrain_agg)\n",
        "xtest_agg=x_test[0:n]\n",
        "ytest_agg=testY[0:n]\n",
        "#ytest_agg=ytest_agg.to_numpy()\n",
        "#ytest_pred=model_np.predict_proba(xtest_agg)\n",
        "target_train_agg = (xtrain_agg,ytrain_agg)\n",
        "target_test_agg = (xtest_agg,ytest_agg)\n",
        "#target_train_data_agg, target_test_data_agg = sample_data(target_train_agg, target_test_agg, NUM_TARGET)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pyIT6rnkOUIy"
      },
      "source": [
        "def label(my_list):\n",
        "  import numpy as np\n",
        "  my_array=np.array(my_list)\n",
        "  p=np.zeros(my_array.shape)\n",
        "  b=my_array.max(-1)\n",
        "  condition = my_array == b[..., np.newaxis]\n",
        "  c = np.where(condition, 1, 0)\n",
        "  final=np.multiply(c, my_array)\n",
        "  #my_sum=np.sum(final,axis=0)\n",
        "  labels=np.argmax(final, axis=1)\n",
        "  return labels"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wvIRppnUBfRm"
      },
      "source": [
        "ep1=np.zeros(len(noise_mul))  #calculate epsilon\n",
        "acc_sgd= np.zeros(len(noise_mul))\n",
        "model_index =0\n",
        "for i in range(len(noise_mul)):\n",
        "  modelSGD,ep1[i]=SGD_lg(noise_mul[i],xtrain_agg,ytrain_agg,xtest_agg,ytest_agg)\n",
        "  acc_sgd[i]=calc_labelAcc(modelSGD,xtest_agg,ytest_agg)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hl9c9NPgSAwR"
      },
      "source": [
        "#non-private\n",
        "#non-private accuracy\n",
        "model_np = tf.keras.Sequential([tf.keras.layers.Flatten(), \n",
        "                                    tf.keras.layers.Dense(18, activation = tf.nn.relu), \n",
        "                                    tf.keras.layers.Dense(units=2, activation='sigmoid',kernel_regularizer=l2(.0001))\n",
        "       ])\n",
        "loss = tf.keras.losses.CategoricalCrossentropy(\n",
        "    from_logits=True, reduction=tf.losses.Reduction.NONE)\n",
        "model_np.compile(optimizer='sgd', loss=loss, metrics=['accuracy'])\n",
        "model_np.fit(xtrain_agg, ytrain_agg,\n",
        "          epochs=100,\n",
        "          validation_data=(x_test[0:1000], testY[0:1000]),\n",
        "          batch_size=250)\n",
        "\n",
        "np_sgd=calc_labelAcc(model_np,xtest_agg,ytest_agg)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h28TFQS-SzR_"
      },
      "source": [
        "PATE"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qxivvBXXS0ZZ",
        "outputId": "4756f9e7-60f9-4331-f494-e5d6f3162ed5"
      },
      "source": [
        "#split datasets into multiple teacher\n",
        "#Divide the images into 5 \n",
        "# split x_train to 10 disjoint datasets\n",
        "#store each dataset variable name is the list Xtrain\n",
        "import numpy as np\n",
        "M=30\n",
        "j=0\n",
        "k=len(xtrain_agg)/M\n",
        "#print(x_train)\n",
        "for x in range(0,M):\n",
        "             globals()['x_train_split%s' % x]=xtrain[int(j):int(k+j)]\n",
        "             globals()['y_train_split%s' % x]=ytrain[int(j):int(k+j)]\n",
        "             j=k+j\n",
        "             #print(j)\n",
        "             \n",
        "print(x_train_split29.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(167, 18)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BXBbFx_HS-ip"
      },
      "source": [
        "for iter in range(M):\n",
        "     from sklearn.linear_model import LogisticRegression\n",
        "     model = LogisticRegression(random_state=0,penalty='l2',max_iter=100,C=10000)\n",
        "     model.fit(globals()['x_train_split%s' % iter], globals()['y_train_split%s' % iter])\n",
        "     globals()['model%s' % iter]=model\n",
        "     "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vEkZnjy1TGOA"
      },
      "source": [
        "#function for vote counting\n",
        "def vote(my_list):\n",
        "  import numpy as np\n",
        "  my_array=np.array(my_list)\n",
        "  p=np.zeros(my_array.shape)\n",
        "  b=my_array.max(-1)\n",
        "  condition = my_array == b[..., np.newaxis]\n",
        "  c = np.where(condition, 1, 0)\n",
        "  final=np.multiply(c, my_array)\n",
        "  #my_sum=np.sum(final,axis=0)\n",
        "  labels=np.argmax(final, axis=1)\n",
        "  return c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_HTAyX0KTJKB"
      },
      "source": [
        "sum=np.zeros([len(ytest),2])\n",
        "for iter in range(M):\n",
        "  New_model=globals()['model%s' % iter]\n",
        "  y=np.zeros([len(ytest),7])\n",
        "  y=New_model.predict_proba(xtest)\n",
        "  #print(y.shape)\n",
        "  y=vote(y)\n",
        "  sum=y+sum"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ju9NovWxTOMX"
      },
      "source": [
        "#create the labels\n",
        "from sklearn.metrics import accuracy_score\n",
        "lab=label(sum)\n",
        "#clear accuracy\n",
        "#y_true=label(ytest)\n",
        "accnp=accuracy_score(ytest,lab)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L_2saCLkUGvT"
      },
      "source": [
        "ep=[.01,.1,1,10,100,1000,10000]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XUtTfayRT8GT"
      },
      "source": [
        "#add noise \n",
        "def add_noise_sum(noise,sum,experiment,ypred):\n",
        "  sum_s=sum\n",
        "  predt=np.zeros(experiment)\n",
        "  for i1 in range(experiment):\n",
        "    sum_s=np.zeros(sum.shape)\n",
        "    sum_f=sum+np.random.laplace(loc=0.0, scale=1/noise)\n",
        "    sum2=label(sum_f)\n",
        "    predt[i1]=accuracy_score(ypred,sum2)\n",
        "    #print(i)\n",
        "  pred=np.average(predt)\n",
        "  #print(predt)\n",
        "  #print(pred)\n",
        "  return pred"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ytB5qCR_T_gx"
      },
      "source": [
        "acc_pate=np.zeros(len(ep))\n",
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.metrics import average_precision_score\n",
        "#Noise after Aggregation Method\n",
        "for i in range(0,len(ep)):\n",
        "                          sum_s=np.zeros(sum.shape)\n",
        "                          sum_n=sum\n",
        "                          #sum_s=sum_n+np.random.laplace(loc=0.0, scale=1/noise[i])\n",
        "                          predF=add_noise_sum(ep[i],sum_n,100,ytest)\n",
        "                          acc_pate[i]=predF\n",
        "print(acc_pate)\n",
        "print(ep)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ExBriT_jUzJu"
      },
      "source": [
        "Output Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e9yGZDuAU1eb"
      },
      "source": [
        "#non-private accuracy\n",
        "def build_lg_model():\n",
        "    import keras\n",
        "    from keras.models import Sequential\n",
        "    from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout\n",
        "    # build the model\n",
        "    model = Sequential()\n",
        "    model.add(Dense(units=2, activation='sigmoid',kernel_regularizer=l2(.0001)))\n",
        "    model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])\n",
        "    return model\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QLZWwFTYVMUg",
        "outputId": "f1ed3a6a-9d61-4384-fabf-70719dfc658a"
      },
      "source": [
        "model_np=build_lg_model()\n",
        "model_np.fit(xtrain,ytrain_agg, epochs=100, verbose=0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.callbacks.History at 0x7fd9e33d4390>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "26nmmsoAVoUR",
        "outputId": "f5f1141b-8084-46ce-cd6f-62af4c35e008"
      },
      "source": [
        "model_np.save(\"my_model\")\n",
        "weight=model_np.get_weights()\n",
        "np_out=calc_labelAcc(model_np,xtest,testY[0:n])\n",
        "print(np_out)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.669\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uN-NRr_9Viuj"
      },
      "source": [
        "#output perturbation\n",
        "ep=[.01,.1,1,10,100,1000,10000] \n",
        "delta=.0001   #privacy budget\n",
        "n1=5000\n",
        "acc_out=np.zeros(len(ep))\n",
        "from tensorflow import keras\n",
        "for i in range(len(ep)):\n",
        "  #add noise to the weights\n",
        "  #noise=(2/(n1*ep[i]*.0001)) \n",
        "  s=2/(n1*.0001)  #lambda=.0001\n",
        "  model1=keras.models.load_model(\"my_model\")\n",
        "  w=model1.get_weights()\n",
        "  #print(w[0])\n",
        "  W=w\n",
        "  sigma = np.sqrt(2 * np.log(1.25 / delta)) * (s / ep[i])\n",
        "  #ns=np.random.laplace(loc=0.0, scale=noise)\n",
        "  ns=np.random.normal(loc=0.0, scale=sigma)\n",
        "  print(ns)\n",
        "  #print(ns)\n",
        "  for j in range(2):\n",
        "       W[j]=W[j]+ns\n",
        "  #print(W[0])\n",
        "  model2=keras.models.load_model(\"my_model\")\n",
        "  model2.set_weights(W)\n",
        "  acc_out[i]=calc_labelAcc(model2,xtest,testY[0:n])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z2MUS9TaUPBy"
      },
      "source": [
        "Graph"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "CXL8wdrsUQb7",
        "outputId": "879de2e8-1f4a-413f-f1ea-d65d1b4fd2da"
      },
      "source": [
        "import pandas as pd \n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns #grafikleştirme için\n",
        "import matplotlib.pyplot as plt \n",
        "from google.colab import files\n",
        "test1 = plt.figure()\n",
        "plt.semilogx(ep,non_p-acc_obj,color=\"black\",marker='D',label='Objective Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,np_sgd-acc_sgd,color=\"black\",marker='*',label='Gradient Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,np_out-acc_out,color=\"black\",marker='<',label='Output Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,accnp-acc_pate,color=\"black\",marker='o',label='Prediction Perturbation',linewidth=1.5)\n",
        "#plt.semilogx(ep,non_p-acc_in,color=\"orange\",marker='.',linestyle=\"--\",label='Input',linewidth=1.5)\n",
        "#plt.plot(ep,non_p,color=\"red\",marker='*',linestyle=\"--\",label='Non-Private Model',linewidth=2)\n",
        "plt.legend(loc=1,fontsize=12)\n",
        "plt.xlabel(\"Privacy Budget($\\epsilon$)\",fontsize=13)\n",
        "plt.ylabel(\"Utility Loss\",fontsize=15)\n",
        "#plt.xscale('symlog', linthreshy=0.1)\n",
        "#plt.ylim([-.1,1])\n",
        "plt.xticks(size = 10)\n",
        "plt.yticks(size = 8)\n",
        "plt.ylim([-.05,1])\n",
        "#y.set_color(\"black\")\n",
        "plt.rcParams[\"axes.edgecolor\"] = \"black\"\n",
        "plt.rcParams[\"axes.linewidth\"] = 1\n",
        "plt.rcParams['axes.facecolor'] = 'white'\n",
        "#test1.set_facecolor('white')\n",
        "test1.show()\n",
        "test1.savefig('logistic_perturb_acc_medical2.pdf')\n",
        "#files.download('logistic_perturb_acc_medical2.pdf')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_0264002c-eb6e-4979-81e7-b6f77bc1c1b0\", \"logistic_perturb_acc_medical2.pdf\", 19134)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GkCdixPb7m6v"
      },
      "source": [
        "print(non_p-acc_obj)\n",
        "print(np_sgd-acc_sgd)\n",
        "print(np_out-acc_out)\n",
        "print(accnp-acc_pate)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nsbntg-YfhOg"
      },
      "source": [
        "Attack The model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MDlSyaW4fi2a"
      },
      "source": [
        "#Assign necessary variables for attacking the model\n",
        "import argparse\n",
        "import csv\n",
        "import numpy as np\n",
        "from sklearn.utils import resample, shuffle\n",
        "\n",
        "import keras\n",
        "import numpy as np\n",
        "from sklearn.utils import resample\n",
        "\n",
        "LEARNING_RATE = 0.001\n",
        "EPOCH = 100\n",
        "#EPOCH = 30\n",
        "DATA_SIZE = 10000\n",
        "TRAINING_SIZE = 5000\n",
        "TEST_SIZE = 5000\n",
        "NUM_TARGET = 1\n",
        "#NUM_SHADOW = 100\n",
        "NUM_SHADOW = 10\n",
        "IN = 1\n",
        "OUT = 0\n",
        "VERBOSE = 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-mpKOiEFpy6i"
      },
      "source": [
        "#call required libraries\n",
        "from tensorflow.keras.datasets import cifar10\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n",
        "from tensorflow.keras.losses import sparse_categorical_crossentropy\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import datasets, layers, models\n",
        "import matplotlib.pyplot as plt\n",
        "from keras.utils import to_categorical \n",
        "import sys\n",
        "from matplotlib import pyplot\n",
        "from keras.datasets import cifar10\n",
        "from keras.utils import to_categorical\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Conv2D\n",
        "from keras.layers import MaxPooling2D\n",
        "from keras.layers import Dense\n",
        "from keras.layers import Flatten\n",
        "from keras.layers import Dropout\n",
        "from keras.optimizers import SGD"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PWcARiIXTlNf"
      },
      "source": [
        "#Define model configuaration\n",
        "# Model configuration\n",
        "batch_size = 250\n",
        "#img_width, img_height, img_num_channels = 32, 32, 3\n",
        "#loss_function = sparse_categorical_crossentropy\n",
        "no_classes = 2\n",
        "no_epochs = 250\n",
        "optimizer = Adam()\n",
        "validation_split = 0.2\n",
        "verbosity = 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DfkHipshY_M-"
      },
      "source": [
        "#data sampling\n",
        "def sample_data(train_data,test_data,num_sets):\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    new_x_train, new_y_train = [], []\n",
        "    new_x_test, new_y_test = [], []\n",
        "    for i in range(num_sets):\n",
        "        x_temp, y_temp = resample(x_train, y_train, n_samples=n, random_state=0)\n",
        "        new_x_train.append(x_temp)\n",
        "        new_y_train.append(y_temp)\n",
        "        x_temp, y_temp = resample(x_test, y_test, n_samples=n, random_state=0)\n",
        "        new_x_test.append(x_temp)\n",
        "        new_y_test.append(y_temp)\n",
        "    return (new_x_train, new_y_train), (new_x_test, new_y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbq08GdnZHR3"
      },
      "source": [
        "def get_trained_keras_models(keras_model, train_data, test_data, num_models):\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    models = []\n",
        "    for i in range(num_models):\n",
        "        models.append(keras.models.clone_model(keras_model))\n",
        "        models[i].compile(optimizer='sgd', loss='binary_crossentropy', metrics=['binary_accuracy'])\n",
        "        models[i].fit(x_train[i], y_train[i], batch_size=32, epochs=EPOCH, verbose=VERBOSE, shuffle=True)\n",
        "        score = models[i].evaluate(x_test[i], y_test[i], verbose=VERBOSE)\n",
        "        print('\\n', 'Model ', i, ' test accuracy:', score[1])\n",
        "    return models"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YP6gOZk3ZPQJ"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "def get_trained_keras_models_lg(train_data, test_data, num_models):\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    models = []\n",
        "    for i in range(num_models):\n",
        "        #models.append(keras.models.clone_model(keras_model))\n",
        "        #models[i].compile(optimizer='sgd', loss='binary_crossentropy', metrics=['binary_accuracy'])\n",
        "        #models[i].fit(x_train[i], y_train[i], batch_size=32, epochs=EPOCH, verbose=VERBOSE, shuffle=True)\n",
        "        models.append(LogisticRegression(random_state=0))\n",
        "        models[i].fit(x_train[i], y_train[i])\n",
        "        score = models[i].score(x_test[i], y_test[i])\n",
        "        print('\\n', 'Model ', i, ' test accuracy:', score)\n",
        "    return models"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t58m87VAZQ1K"
      },
      "source": [
        "def get_trained_keras_models_target(keras_model, train_data, test_data, num_models):\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    models = []\n",
        "    for i in range(num_models):\n",
        "        models.append(keras.models.clone_model(keras_model))\n",
        "        models[i].compile(optimizer='sgd', loss='binary_crossentropy', metrics=['binary_accuracy'])\n",
        "        models[i].fit(x_train[i], y_train[i], batch_size=32, epochs=EPOCH, verbose=VERBOSE, shuffle=True)\n",
        "        score = models[i].evaluate(x_test[i], y_test[i], verbose=VERBOSE)\n",
        "        print('\\n', 'Model ', i, ' test accuracy:', score[1])\n",
        "    return models"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BXGIYs-VZXfa"
      },
      "source": [
        "#collect the attack dataset from shadow models\n",
        "def get_attack_dataset(models, train_data, test_data, num_models, data_size):\n",
        "    # generate dataset for the attack model\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    num_classes = len(y_train[0][0])\n",
        "    x_data, y_data = [[] for i in range(num_classes)], [[] for i in range(num_classes)]\n",
        "    for i in range(num_models):\n",
        "        # IN data\n",
        "        x_temp, y_temp = resample(x_train[i], y_train[i], n_samples=data_size, random_state=0)\n",
        "        for j in range(data_size):\n",
        "            y_idx = np.argmax(y_temp[j])\n",
        "            x_data[y_idx].append(models[i].predict(x_temp[j:j+1])[0])\n",
        "            #print(y_idx)\n",
        "            y_data[y_idx].append(IN)\n",
        "            print(\"starts1\",j)\n",
        "        # OUT data\n",
        "        x_temp, y_temp = resample(x_test[i], y_test[i], n_samples=data_size, random_state=0)\n",
        "        for j in range(data_size):\n",
        "            y_idx = np.argmax(y_temp[j])\n",
        "            p=models[i].predict(x_temp[j:j+1])[0]\n",
        "            x_data[y_idx].append(p)\n",
        "            y_data[y_idx].append(OUT)\n",
        "            print(\"starts2\",j)\n",
        "    return x_data, y_data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6wZ2-fVyZY7J"
      },
      "source": [
        "#collect the attack dataset from shadow models: Logistic Regression\n",
        "def get_attack_dataset_lg(models, train_data, test_data, num_models, data_size):\n",
        "    # generate dataset for the attack model\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    num_classes = 2\n",
        "    x_data, y_data = [[] for i in range(num_classes)], [[] for i in range(num_classes)]\n",
        "    for i in range(num_models):\n",
        "        # IN data\n",
        "        x_temp, y_temp = resample(x_train[i], y_train[i], n_samples=data_size, random_state=0)\n",
        "        for j in range(data_size):\n",
        "            y_idx = y_temp[j]\n",
        "            x_data[y_idx].append(models[i].predict_proba(x_temp[j:j+1])[0])\n",
        "            #print(y_idx)\n",
        "            y_data[y_idx].append(IN)\n",
        "            print(\"starts1\",j)\n",
        "        # OUT data\n",
        "        x_temp, y_temp = resample(x_test[i], y_test[i], n_samples=data_size, random_state=0)\n",
        "        for j in range(data_size):\n",
        "            y_idx = y_temp[j]\n",
        "            p=models[i].predict_proba(x_temp[j:j+1])[0]\n",
        "            x_data[y_idx].append(p)\n",
        "            y_data[y_idx].append(OUT)\n",
        "            print(\"starts2\",j)\n",
        "    return x_data, y_data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "42AAod5xZwoQ"
      },
      "source": [
        "#generate the report\n",
        "def get_leakage(models, test_data):\n",
        "    from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
        "    from sklearn.metrics import average_precision_score\n",
        "    from sklearn import metrics\n",
        "    from sklearn.metrics import confusion_matrix\n",
        "    (x_test, y_true) = test_data\n",
        "    acc_scores = []\n",
        "    pre_scores = []\n",
        "    rec_scores = []\n",
        "    fp=np.zeros(len(models))\n",
        "    tp=np.zeros(len(models))\n",
        "    tn=np.zeros(len(models))\n",
        "    fn=np.zeros(len(models))\n",
        "    for i in range(len(models)):\n",
        "        y_pred = models[i].predict(x_test[i])\n",
        "        # _LOG_PRINT(y_pred)\n",
        "        acc_scores.append(accuracy_score(y_true[i], y_pred))\n",
        "        pre_scores.append(average_precision_score(y_true[i], y_pred))\n",
        "        rec_scores.append(recall_score(y_true[i], y_pred))\n",
        "        tn[i], fp[i], fn[i], tp[i] = confusion_matrix(y_true[i], y_pred).ravel()\n",
        "    return np.sum(tn),np.sum(tp),np.sum(fn),np.sum(fp)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I14H1qE5ZzJt"
      },
      "source": [
        "#attack classifier:SVM\n",
        "def get_trained_svm_models(train_data, test_data, num_models):\n",
        "    from sklearn import svm\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    models = []\n",
        "    for i in range(num_models):\n",
        "        print('Training svm model : ', i)\n",
        "        models.append(svm.SVC(gamma='scale',kernel='linear',verbose=VERBOSE))\n",
        "        models[i].fit(x_train[i], y_train[i])\n",
        "        score = models[i].score(x_test[i],y_test[i])\n",
        "        #print(i)\n",
        "        print('SVM model ', i, 'score : ',score)\n",
        "    return models,score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xRFcvSzccWhI"
      },
      "source": [
        "y_train=y_train.to_numpy()\n",
        "y_test=y_test.to_numpy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nmq54CcHZ3bF"
      },
      "source": [
        "shadow_train = (X_train[n:n*2],y_train[n:n*2])\n",
        "shadow_test = (X_test[n:n*2],y_test[n:n*2])\n",
        "shadow_train_data, shadow_test_data = sample_data(shadow_train, shadow_test, NUM_SHADOW)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_qwM2HC_aHB9"
      },
      "source": [
        "#when we use logistic regression model from sklearn\n",
        "shadow_models = get_trained_keras_models_lg(shadow_train_data, shadow_test_data, NUM_SHADOW)\n",
        "attack_train = get_attack_dataset_lg(shadow_models, shadow_train_data, shadow_test_data, NUM_SHADOW, TEST_SIZE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2nFyMLh4dxvK"
      },
      "source": [
        "def lk(tn,tp,fn,fp):\n",
        "  tpr=(tp/(tp+fn))\n",
        "  fpr=(fp/(fp+tn))\n",
        "  return tpr-fpr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8XyG5qlMd6f0"
      },
      "source": [
        "##attack classifier:RF\n",
        "def get_trained_RF_models(train_data, test_data, num_models):\n",
        "    from sklearn.ensemble import RandomForestClassifier\n",
        "    (x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    models = []\n",
        "    score=np.zeros(num_models)\n",
        "    #RF=RandomForestClassifier(random_state=0)\n",
        "    for i in range(num_models):\n",
        "        print('Training RF model : ', i)\n",
        "        models.append(RandomForestClassifier(random_state=0))\n",
        "        models[i].fit(x_train[i], y_train[i])\n",
        "        score[i] = models[i].score(x_test[i],y_test[i])\n",
        "        print('Random Forest model ', i, 'score : ',score)\n",
        "    return models, score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NJke65TSfZeM"
      },
      "source": [
        "n=5000\n",
        "xtrain=X_train[0:n]\n",
        "ytrain=y_train[0:n]\n",
        "#ytrain_agg=ytrain_agg.to_numpy()\n",
        "#ytrain_pred=model_np.predict_proba(xtrain_agg)\n",
        "xtest=X_test[0:n]\n",
        "ytest=y_test[0:n]\n",
        "#ytest_agg=ytest_agg.to_numpy()\n",
        "#ytest_pred=model_np.predict_proba(xtest_agg)\n",
        "target_train_agg = (xtrain,ytrain)\n",
        "target_test_agg = (xtest,ytest)\n",
        "target_train_data, target_test_data = sample_data(target_train_agg, target_test_agg, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RudOfovgeR45"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "target_model=[]\n",
        "model= LogisticRegression(penalty='l2',max_iter=100,C=10000).fit(xtrain, ytrain)\n",
        "target_model.append(model)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NC0u933id-jI"
      },
      "source": [
        "#logistic regression\n",
        "#non_private_model\n",
        "attack_test_agg=get_attack_dataset_lg(target_model, target_train_data, target_test_data, 1, TEST_SIZE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UISD61X2g1j1"
      },
      "source": [
        "#non_private\n",
        "attack_model,scores = get_trained_RF_models(attack_train,attack_test_agg, 2)\n",
        "#scores=get_score_svm_models(attack_model,attack_train)\n",
        "tn,tp,fn,fp=get_leakage(attack_model, attack_test_agg)\n",
        "l1=lk(tn,tp,fn,fp)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0au0oFO8TsYQ"
      },
      "source": [
        "Privacy Leakage for Input Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbgI-ndvTvRi"
      },
      "source": [
        "def Input_pert_train(epi,xtrain,ytrain,xtest,ytest):\n",
        "  delta=.0001\n",
        "  C=1\n",
        "  z=3*np.log(5000)\n",
        "  z1=z**2\n",
        "  sigma=z1*(8*np.log(2/(delta/2))+4*epi)/(epi**2)\n",
        "  #sigma=calc_sigma(ep[i],delta,18,1/C)\n",
        "  nsi=np.random.normal(loc=0.0, scale=sigma/n)\n",
        "  print(nsi)\n",
        "  X_in=xtrain-nsi\n",
        "  target_train_aggin = (X_in,ytrain)\n",
        "  target_test_aggin = (xtest,ytest)\n",
        "  target_train_datain, target_test_datain = sample_data(target_train_aggin, target_test_aggin, 1)\n",
        "  return X_in,target_train_datain,target_test_datain"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CxzdWcCDZTaU"
      },
      "source": [
        "p=len(ep)\n",
        "lin=np.zeros(p)\n",
        "tn0=np.zeros(p)\n",
        "tp0=np.zeros(p)\n",
        "fn0=np.zeros(p)\n",
        "fp0=np.zeros(p)\n",
        "\n",
        "for i in range(len(ep)):\n",
        "     target_model=[]\n",
        "     X_in,target_train_datain,target_test_datain=Input_pert_train(ep[i],xtrain,ytrain,xtest,ytest)\n",
        "     in_model=LogisticRegression(penalty='l2',max_iter=100,C=10000).fit(X_in, ytrain)\n",
        "     target_model.append(in_model)\n",
        "     attack_test_agg=get_attack_dataset_lg(target_model, target_train_datain, target_test_datain, 1, TEST_SIZE)\n",
        "     tn0[i],tp0[i],fn0[i],fp0[i]=get_leakage(attack_model, attack_test_agg)\n",
        "     lin[i]=lk(tn0[i],tp0[i],fn0[i],fp0[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m0Zx85y-cPtv"
      },
      "source": [
        "print(lin)\n",
        "print(tn0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X5qK5QRIh7tk"
      },
      "source": [
        "privacy leakage for Objective Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MNiKpTYnhn8Y"
      },
      "source": [
        "from diffprivlib.models import LogisticRegression\n",
        "p=len(ep)\n",
        "lobj=np.zeros(p)\n",
        "tn1=np.zeros(p)\n",
        "tp1=np.zeros(p)\n",
        "fn1=np.zeros(p)\n",
        "fp1=np.zeros(p)\n",
        "for i in range(len(ep)):\n",
        "     target_model=[]\n",
        "     obj_model=LogisticRegression(data_norm=1, epsilon=ep[i],penalty='l2',max_iter=100,C=10000).fit(xtrain, ytrain)\n",
        "     target_model.append(obj_model)\n",
        "     attack_test_agg=get_attack_dataset_lg(target_model, target_train_data, target_test_data, 1, TEST_SIZE)\n",
        "     tn1[i],tp1[i],fn1[i],fp1[i]=get_leakage(attack_model, attack_test_agg)\n",
        "     lobj[i]=lk(tn1[i],tp1[i],fn1[i],fp1[i])\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RcekgnnhCIGm"
      },
      "source": [
        "print(lobj)\n",
        "print(tp1)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "naYnftwxqgJ3"
      },
      "source": [
        "Privacy Leakage: Gradient Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NLaHaQkKqj18"
      },
      "source": [
        "for i in range(len(noise_mul)):\n",
        "  modelSGD,ep[i]=SGD_lg(noise_mul[i],xtrain_agg,ytrain_agg,xtest_agg,ytest_agg)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LT4K4HwzrC2z"
      },
      "source": [
        "p=len(ep)\n",
        "lgd=np.zeros(p)\n",
        "tn2=np.zeros(p)\n",
        "tp2=np.zeros(p)\n",
        "fn2=np.zeros(p)\n",
        "fp2=np.zeros(p)\n",
        "for i in range(len(ep)):\n",
        "     target_model=[]\n",
        "     modelSGD,e=SGD_lg(noise_mul[i],xtrain_agg,ytrain_agg,xtest_agg,ytest_agg)\n",
        "     target_model.append(modelSGD)\n",
        "     attack_test_agg=get_attack_dataset_lg(target_model, target_train_data, target_test_data, 1, TEST_SIZE)\n",
        "     tn2[i],tp2[i],fn2[i],fp2[i]=get_leakage(attack_model, attack_test_agg)\n",
        "     lgd[i]=lk(tn2[i],tp2[i],fn2[i],fp2[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6geocUasjOat"
      },
      "source": [
        "print(lgd)\n",
        "print(tp2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gP0Lh9GcxzYR"
      },
      "source": [
        "Output Perturbation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ynqoeQyYx1Zk"
      },
      "source": [
        "from tensorflow import keras\n",
        "def output_pert(ep):\n",
        "  #add noise to the weights\n",
        "  #noise=(2/(n1*ep[i]*.0001))\n",
        "  n1=5000 \n",
        "  delta=.0001\n",
        "  s=2/(n1*.0001)  #lambda=.0001\n",
        "  model1=keras.models.load_model(\"my_model\")\n",
        "  w=model1.get_weights()\n",
        "  #print(w[0])\n",
        "  W=w\n",
        "  sigma = np.sqrt(2 * np.log(1.25 / delta)) * (s / ep)\n",
        "  #ns=np.random.laplace(loc=0.0, scale=noise)\n",
        "  ns=np.random.normal(loc=0.0, scale=sigma)\n",
        "  print(ns)\n",
        "  #print(ns)\n",
        "  for j in range(2):\n",
        "       W[j]=W[j]+ns\n",
        "  #print(W[0])\n",
        "  model2=keras.models.load_model(\"my_model\")\n",
        "  model2.set_weights(W)\n",
        "  #acc_out[i]=calc_labelAcc(model2,xtest,testY[0:n])\n",
        "  return model2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bDPHBPmsyDY1"
      },
      "source": [
        "p=len(ep)\n",
        "lout=np.zeros(p)\n",
        "tn3=np.zeros(p)\n",
        "tp3=np.zeros(p)\n",
        "fn3=np.zeros(p)\n",
        "fp3=np.zeros(p)\n",
        "for i in range(len(ep)):\n",
        "     target_model=[]\n",
        "     model_out=output_pert(ep[i])\n",
        "     target_model.append(model_out)\n",
        "     attack_test_agg=get_attack_dataset_lg(target_model, target_train_data, target_test_data, 1, TEST_SIZE)\n",
        "     tn3[i],tp3[i],fn3[i],fp3[i]=get_leakage(attack_model, attack_test_agg)\n",
        "     lout[i]=lk(tn3[i],tp3[i],fn3[i],fp3[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FH2kGW0aAAMm",
        "outputId": "7cfdc3b3-de8f-4635-f371-d1123ee26b41"
      },
      "source": [
        "print(lout)\n",
        "print(tp3)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0.017   0.017   0.0088 -0.0248  0.0126  0.008   0.0148]\n",
            "[ 745.  746.  741. 1514. 1935. 2417. 2377.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XY7JQ3_ck7wR"
      },
      "source": [
        "[ 0.017   0.017   0.0088 -0.0248  0.0126  0.008   0.0148]\n",
        "[ 745.  746.  741. 1514. 1935. 2417. 2377.]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xZT5LWUAQjL"
      },
      "source": [
        "PATE_attack"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CpeBYlOZATA_"
      },
      "source": [
        "def PATE(ep,xtest1,ytest1):\n",
        "            sum_t=np.zeros([len(ytest1),2])\n",
        "            for k1 in range(100):\n",
        "               sum=PATE_sum(xtest1,ytest1)\n",
        "               sum_s=np.zeros(sum.shape)\n",
        "               sum_n=sum\n",
        "               sum_s=sum_n+np.random.laplace(loc=0.0, scale=1/ep)\n",
        "               sum_t=sum_s+sum_t\n",
        "\n",
        "            return sum_t/100\n",
        "          \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T-pNuO2cCXaf"
      },
      "source": [
        "def PATE_sum(xtest1,ytest1):\n",
        "  sum=np.zeros([len(ytest1),2])\n",
        "  for iter in range(M):\n",
        "    New_model=globals()['model%s' % iter]\n",
        "    y=np.zeros([len(ytest1),2])\n",
        "    y=New_model.predict_proba(xtest1)\n",
        "  #print(y.shape)\n",
        "    y=vote(y)\n",
        "    sum=y+sum\n",
        "  return sum"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbQgi1IEB8g3"
      },
      "source": [
        "#Get the prediction vectors from the DP model\n",
        "def get_attack_dataset_combined_lg(x_train, x_test, train_pred, y_train, y_test, test_pred):\n",
        "    # generate dataset for the attack model\n",
        "    #(x_train, y_train), (x_test, y_test) = train_data, test_data\n",
        "    data_size=len(y_train)\n",
        "    num_class = 2\n",
        "    x_data, y_data = [[] for _ in range(num_class)], [[] for _ in range(num_class)]\n",
        "    #for i in range(num_models):\n",
        "        # IN data\n",
        "    #x_temp, y_temp = resample(x_train, y_train, n_samples=data_size, random_state=0)\n",
        "    for j in range(data_size):\n",
        "            y_idx = y_train[j]\n",
        "            x_data[y_idx].append(train_pred[j])\n",
        "            #print(train_pred[j])\n",
        "            #x_data[y_idx].append(models.predict(x_temp[j:j+1])[0])\n",
        "            y_data[y_idx].append(IN)\n",
        "        # OUT data\n",
        "    #x_temp, y_temp = resample(x_test, y_test, n_samples=data_size, random_state=0)\n",
        "    for j in range(data_size):\n",
        "            y_idx = y_test[j]\n",
        "            #x_data[y_idx].append(models.predict(x_temp[j:j+1])[0])\n",
        "            x_data[y_idx].append(test_pred[j])\n",
        "            y_data[y_idx].append(OUT)\n",
        "    return x_data, y_data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BX9cwJeQBtSS"
      },
      "source": [
        "p=len(ep)\n",
        "lpate=np.zeros(p)\n",
        "tn4=np.zeros(p)\n",
        "tp4=np.zeros(p)\n",
        "fn4=np.zeros(p)\n",
        "fp4=np.zeros(p)\n",
        "for i in range(len(ep)):\n",
        "     ytrain_pred=PATE(ep[i],xtrain,ytrain)\n",
        "     ytest_pred=PATE(ep[i],xtest,ytest)\n",
        "     attack_test_agg=get_attack_dataset_combined_lg(xtrain,xtest,ytrain_pred,ytrain,ytest,ytest_pred)\n",
        "     tn4[i],tp4[i],fn4[i],fp4[i]=get_leakage(attack_model, attack_test_agg)\n",
        "     lpate[i]=lk(tn4[i],tp4[i],fn4[i],fp4[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hdOm8Y7_gtDG"
      },
      "source": [
        "print(lpate)\n",
        "print(tp4)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JAX-TxTqiEK3"
      },
      "source": [
        "[-0.2476  0.0046  0.0196  0.005   0.006   0.006   0.006 ]\n",
        "[ 794. 2055. 1840. 1835. 1840. 1840. 1840.]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t9Q98JenqIGJ"
      },
      "source": [
        "Graph"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "xhW_mzGgqHT5",
        "outputId": "4222e1e1-1ae4-48a3-ecb8-4e39f91b4269"
      },
      "source": [
        "import pandas as pd \n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns #grafikleştirme için\n",
        "import matplotlib.pyplot as plt \n",
        "from google.colab import files\n",
        "test1 = plt.figure()\n",
        "plt.semilogx(ep,lobj,color=\"black\",marker='D',label='Objective Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,lgd,color=\"black\",marker='*',label='Gradient Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,lout,color=\"black\",marker='<',label='Output Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,lpate,color=\"black\",marker='o',label='Prediction Perturbation',linewidth=1.5)\n",
        "#plt.semilogx(ep,non_p-acc_in,color=\"orange\",marker='.',linestyle=\"--\",label='Input',linewidth=1.5)\n",
        "#plt.plot(ep,non_p,color=\"red\",marker='*',linestyle=\"--\",label='Non-Private Model',linewidth=2)\n",
        "plt.legend(loc=1,fontsize=12)\n",
        "plt.xlabel(\"Privacy Budget($\\epsilon$)\",fontsize=13)\n",
        "plt.ylabel(\"Privacy Leakage\",fontsize=15)\n",
        "#plt.xscale('symlog', linthreshy=0.1)\n",
        "#plt.ylim([-.1,1])\n",
        "plt.xticks(size = 10)\n",
        "plt.yticks(size = 8)\n",
        "plt.ylim([-.04,.25])\n",
        "#y.set_color(\"black\")\n",
        "plt.rcParams[\"axes.edgecolor\"] = \"black\"\n",
        "plt.rcParams[\"axes.linewidth\"] = 1\n",
        "plt.rcParams['axes.facecolor'] = 'white'\n",
        "#test1.set_facecolor('white')\n",
        "test1.show()\n",
        "test1.savefig('logistic_perturb_leakage_medical2.pdf')\n",
        "files.download('logistic_perturb_leakage_medical2.pdf')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_2b20d73d-eb3c-4c0c-a59f-40b978738de7\", \"logistic_perturb_leakage_medical2.pdf\", 17965)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "wKoJ9birIQUa",
        "outputId": "b1863505-1888-41cb-df2a-dbd6f4539cf4"
      },
      "source": [
        "import pandas as pd \n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns #grafikleştirme için\n",
        "import matplotlib.pyplot as plt \n",
        "from google.colab import files\n",
        "test1 = plt.figure()\n",
        "plt.semilogx(ep,tp1,color=\"black\",marker='D',label='Objective Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,tp2,color=\"black\",marker='*',label='Gradient Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,tp3,color=\"black\",marker='<',label='Output Perturbation',linewidth=1.5)\n",
        "plt.semilogx(ep,tp4,color=\"black\",marker='o',label='Prediction Perturbation',linewidth=1.5)\n",
        "#plt.semilogx(ep,non_p-acc_in,color=\"orange\",marker='.',linestyle=\"--\",label='Input',linewidth=1.5)\n",
        "#plt.plot(ep,non_p,color=\"red\",marker='*',linestyle=\"--\",label='Non-Private Model',linewidth=2)\n",
        "plt.legend(loc=1,fontsize=10)\n",
        "plt.xlabel(\"Privacy Budget($\\epsilon$)\",fontsize=13)\n",
        "plt.ylabel(\"True Revealed Data (True Positive)\",fontsize=12)\n",
        "#plt.xscale('symlog', linthreshy=0.1)\n",
        "#plt.ylim([-.1,1])\n",
        "plt.xticks(size = 10)\n",
        "plt.yticks(size = 8)\n",
        "plt.ylim([0,5000])\n",
        "#y.set_color(\"black\")\n",
        "plt.rcParams[\"axes.edgecolor\"] = \"black\"\n",
        "plt.rcParams[\"axes.linewidth\"] = 1\n",
        "plt.rcParams['axes.facecolor'] = 'white'\n",
        "#test1.set_facecolor('white')\n",
        "test1.show()\n",
        "test1.savefig('logistic_perturb_tp_medical.pdf')\n",
        "files.download('logistic_perturb_tp_medical.pdf')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_5e484d7a-0f3d-45f9-9c07-d9129946ede6\", \"logistic_perturb_tp_medical.pdf\", 18767)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}