random_noise_analysis_differential_private_ai.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "random_noise_analysis_differential_private_ai",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/souravs17031999/private-ai/blob/master/random_noise_analysis_differential_private_ai.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-dhjfahP6gvQ",
        "colab_type": "text"
      },
      "source": [
        "#Project - V\n",
        "##W have already seen how to add noise to the database and now we will see how to add random noise to the database and effect of increasing random noise in the database and then increasing the length of database and observe the effects."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2LQDTWJzxlzL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#importing torch\n",
        "import torch"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-7aA0J56xuIv",
        "colab_type": "code",
        "outputId": "e0b5b734-8315-4dd3-fb4c-5548a3c8c261",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        }
      },
      "source": [
        "#creating random database of length 100 filled with 1's and 0's\n",
        "db = torch.rand(100) > 0.5\n",
        "db"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,\n",
              "        1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1,\n",
              "        1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n",
              "        1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1,\n",
              "        0, 0, 1, 1], dtype=torch.uint8)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CdLVWhWhxyVG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#modified query\n",
        "def query(db, noise):\n",
        "  true_stat = torch.mean(db.float())  # true mean of original database\n",
        "  \n",
        "  first_flip = (torch.rand(len(db)) < noise).float()  # now , adding bias to the first coin by adding noise as prob of coming heads\n",
        "  second_flip = (torch.rand(len(db)) > 0.5).float()    \n",
        "  \n",
        "  aug_db = db.float() * first_flip + (1 - first_flip) * second_flip  #this simply means that if the first flip comes heads  , \n",
        "  # that is 1, then simply take result of original db itself and that is done by here multiplying it by first_flip_coin result 1 or 0 keeping the data same as it is in database, and now \n",
        "  # if first flip comes tails , then it simply is taking value of second flip either 1 for heads or 0 for tails.\n",
        "  sk_result = torch.mean(aug_db.float())  # this is skewed result of mean obtained from noised database (aug_db)\n",
        "  aug_true_db = ((sk_result / noise) - 0.5) * noise / (1 - noise)  # this is now reskewing to get true statistics from noised db\n",
        "  \n",
        "  return true_stat, aug_true_db"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LKbNP15GyPfA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "true_result, private_result = query(db, 0.2) # unpacking true and private results of query "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s0mddSM40OCT",
        "colab_type": "code",
        "outputId": "c10e46ea-3267-441d-fd99-2d1d0ed8c357",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "print(\"without noise: \" + str(true_result)) \n",
        "print(\"with noise: \" + str(private_result))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "without noise: tensor(0.5800)\n",
            "with noise: tensor(0.5000)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KXoKkyAo-fH7",
        "colab_type": "text"
      },
      "source": [
        "### as we can see increasing noise results in increasing difference between true result and private result for the same dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7oqG-uLT0egG",
        "colab_type": "code",
        "outputId": "8a4765ef-223c-4785-94b4-d528b3eccbcc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "true_result, private_result = query(db, 0.4)  # adding noise 40% for biasing coin\n",
        "print(\"without noise: \" + str(true_result))\n",
        "print(\"with noise: \" + str(private_result))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "without noise: tensor(0.5800)\n",
            "with noise: tensor(0.6667)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8jV83xaC0kXE",
        "colab_type": "code",
        "outputId": "12e5c821-f70f-4dbb-9149-c093ba3447d7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "true_result, private_result = query(db, 0.6)\n",
        "print(\"without noise: \" + str(true_result))\n",
        "print(\"with noise: \" + str(private_result))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "without noise: tensor(0.5800)\n",
            "with noise: tensor(0.6500)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zDHQoFwb0p7I",
        "colab_type": "code",
        "outputId": "a4c8c286-4828-49ea-9663-f9e88f421da4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "true_result, private_result = query(db, 0.8)\n",
        "print(\"without noise: \" + str(true_result))\n",
        "print(\"with noise: \" + str(private_result))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "without noise: tensor(0.5800)\n",
            "with noise: tensor(0.7500)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BiD8s64H-tQl",
        "colab_type": "text"
      },
      "source": [
        "### Now we will see if we increase the size of dataset , then we can get pretty high accuracy with same amount of noise added (high level of privacy)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HxVXwne_0snd",
        "colab_type": "code",
        "outputId": "23345369-3048-4779-abd9-728efabe2324",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "db = torch.rand(10000) > 0.5\n",
        "true_result, private_result = query(db, 0.8)\n",
        "print(\"without noise: \" + str(true_result))\n",
        "print(\"with noise: \" + str(private_result))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "without noise: tensor(0.5102)\n",
            "with noise: tensor(0.5355)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gaE4oS3Q02ef",
        "colab_type": "code",
        "outputId": "3e1259e2-5f48-4f7a-d18d-48a6f89273ba",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "db = torch.rand(100000) > 0.5\n",
        "true_result, private_result = query(db, 0.8)\n",
        "print(\"without noise: \" + str(true_result))\n",
        "print(\"with noise: \" + str(private_result))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "without noise: tensor(0.5010)\n",
            "with noise: tensor(0.5036)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ctm6ybQr---q",
        "colab_type": "text"
      },
      "source": [
        "### Finally , we can conclude that mechanism of differential privacy works so that it filters out any sensitive data private or unique to individuals and focuses on learning more general characterstics of individuals that is same across multiple datapoints in the dataset."
      ]
    }
  ]
}