Securing_Federated_Learning_practice_with_PySyft.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Securing_Federated_Learning_practice with PySyft",
      "provenance": [],
      "collapsed_sections": [],
      "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/Joycechidi/Deep-Learning-/blob/master/Securing_Federated_Learning_practice_with_PySyft.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-bD3psBe_HqK",
        "colab_type": "text"
      },
      "source": [
        "# Federatel Learning With Trusted Aggregator\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sI0fD1t1Jo6h",
        "colab_type": "text"
      },
      "source": [
        "**Step 1: Create Data Owners**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7NYudzK5Eu4x",
        "colab_type": "code",
        "outputId": "e1326569-727d-416e-a651-037225b19558",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "!pip install syft\n",
        "\n",
        "\n",
        "import syft as sy\n",
        "import torch as th\n",
        "hook = sy.TorchHook(th)\n",
        "from torch import nn, optim"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting syft\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/36/e0/7466833685e21917a78b3e26503e675c9bc82bd81c0d9a6a90c30adf9938/syft-0.1.20a1-py3-none-any.whl (213kB)\n",
            "\u001b[K     |████████████████████████████████| 215kB 2.9MB/s \n",
            "\u001b[?25hRequirement already satisfied: Flask>=1.0.2 in /usr/local/lib/python3.6/dist-packages (from syft) (1.0.3)\n",
            "Requirement already satisfied: numpy>=1.14.0 in /usr/local/lib/python3.6/dist-packages (from syft) (1.16.4)\n",
            "Requirement already satisfied: scikit-learn>=0.21.0 in /usr/local/lib/python3.6/dist-packages (from syft) (0.21.2)\n",
            "Requirement already satisfied: torch>=1.1 in /usr/local/lib/python3.6/dist-packages (from syft) (1.1.0)\n",
            "Requirement already satisfied: tblib>=1.4.0 in /usr/local/lib/python3.6/dist-packages (from syft) (1.4.0)\n",
            "Collecting flask-socketio>=3.3.2 (from syft)\n",
            "  Downloading https://files.pythonhosted.org/packages/4b/68/fe4806d3a0a5909d274367eb9b3b87262906c1515024f46c2443a36a0c82/Flask_SocketIO-4.1.0-py2.py3-none-any.whl\n",
            "Collecting websockets>=7.0 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/43/71/8bfa882b9c502c36e5c9ef6732969533670d2b039cbf95a82ced8f762b80/websockets-7.0-cp36-cp36m-manylinux1_x86_64.whl (63kB)\n",
            "\u001b[K     |████████████████████████████████| 71kB 24.4MB/s \n",
            "\u001b[?25hCollecting tf-encrypted>=0.5.4 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/07/ce/da9916e7e78f736894b15538b702c0b213fd5d60a7fd6e481d74033a90c0/tf_encrypted-0.5.6-py3-none-manylinux1_x86_64.whl (1.4MB)\n",
            "\u001b[K     |████████████████████████████████| 1.4MB 46.6MB/s \n",
            "\u001b[?25hRequirement already satisfied: torchvision>=0.3.0 in /usr/local/lib/python3.6/dist-packages (from syft) (0.3.0)\n",
            "Collecting websocket-client>=0.56.0 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/29/19/44753eab1fdb50770ac69605527e8859468f3c0fd7dc5a76dd9c4dbd7906/websocket_client-0.56.0-py2.py3-none-any.whl (200kB)\n",
            "\u001b[K     |████████████████████████████████| 204kB 53.0MB/s \n",
            "\u001b[?25hCollecting lz4>=2.1.6 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/0a/c6/96bbb3525a63ebc53ea700cc7d37ab9045542d33b4d262d0f0408ad9bbf2/lz4-2.1.10-cp36-cp36m-manylinux1_x86_64.whl (385kB)\n",
            "\u001b[K     |████████████████████████████████| 389kB 48.5MB/s \n",
            "\u001b[?25hCollecting msgpack>=0.6.1 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/92/7e/ae9e91c1bb8d846efafd1f353476e3fd7309778b582d2fb4cea4cc15b9a2/msgpack-0.6.1-cp36-cp36m-manylinux1_x86_64.whl (248kB)\n",
            "\u001b[K     |████████████████████████████████| 256kB 49.1MB/s \n",
            "\u001b[?25hCollecting zstd>=1.4.0.0 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/8e/27/1ea8086d37424e83ab692015cc8dd7d5e37cf791e339633a40dc828dfb74/zstd-1.4.0.0.tar.gz (450kB)\n",
            "\u001b[K     |████████████████████████████████| 450kB 51.2MB/s \n",
            "\u001b[?25hRequirement already satisfied: Werkzeug>=0.14 in /usr/local/lib/python3.6/dist-packages (from Flask>=1.0.2->syft) (0.15.4)\n",
            "Requirement already satisfied: Jinja2>=2.10 in /usr/local/lib/python3.6/dist-packages (from Flask>=1.0.2->syft) (2.10.1)\n",
            "Requirement already satisfied: itsdangerous>=0.24 in /usr/local/lib/python3.6/dist-packages (from Flask>=1.0.2->syft) (1.1.0)\n",
            "Requirement already satisfied: click>=5.1 in /usr/local/lib/python3.6/dist-packages (from Flask>=1.0.2->syft) (7.0)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.6/dist-packages (from scikit-learn>=0.21.0->syft) (0.13.2)\n",
            "Requirement already satisfied: scipy>=0.17.0 in /usr/local/lib/python3.6/dist-packages (from scikit-learn>=0.21.0->syft) (1.3.0)\n",
            "Collecting python-socketio>=2.1.0 (from flask-socketio>=3.3.2->syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/26/1b/57e860a86f2a01be86ae1dacfa0cd8c4dfbfcd4593322268b61b5a07b564/python_socketio-4.2.0-py2.py3-none-any.whl (46kB)\n",
            "\u001b[K     |████████████████████████████████| 51kB 19.5MB/s \n",
            "\u001b[?25hRequirement already satisfied: tensorflow<2,>=1.12.0 in /usr/local/lib/python3.6/dist-packages (from tf-encrypted>=0.5.4->syft) (1.14.0)\n",
            "Collecting pyyaml>=5.1 (from tf-encrypted>=0.5.4->syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/a3/65/837fefac7475963d1eccf4aa684c23b95aa6c1d033a2c5965ccb11e22623/PyYAML-5.1.1.tar.gz (274kB)\n",
            "\u001b[K     |████████████████████████████████| 276kB 46.3MB/s \n",
            "\u001b[?25hRequirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from torchvision>=0.3.0->syft) (1.12.0)\n",
            "Requirement already satisfied: pillow>=4.1.1 in /usr/local/lib/python3.6/dist-packages (from torchvision>=0.3.0->syft) (4.3.0)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.6/dist-packages (from Jinja2>=2.10->Flask>=1.0.2->syft) (1.1.1)\n",
            "Collecting python-engineio>=3.8.0 (from python-socketio>=2.1.0->flask-socketio>=3.3.2->syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/59/1c/601f8ad22681ec9b86acafabc145b6bd02ca62aeac6aae4045d262a94a56/python_engineio-3.8.2-py2.py3-none-any.whl (119kB)\n",
            "\u001b[K     |████████████████████████████████| 122kB 42.3MB/s \n",
            "\u001b[?25hRequirement already satisfied: protobuf>=3.6.1 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (3.7.1)\n",
            "Requirement already satisfied: astor>=0.6.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (0.8.0)\n",
            "Requirement already satisfied: tensorboard<1.15.0,>=1.14.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (1.14.0)\n",
            "Requirement already satisfied: tensorflow-estimator<1.15.0rc0,>=1.14.0rc0 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (1.14.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (1.1.0)\n",
            "Requirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (0.7.1)\n",
            "Requirement already satisfied: keras-preprocessing>=1.0.5 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (1.1.0)\n",
            "Requirement already satisfied: keras-applications>=1.0.6 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (1.0.8)\n",
            "Requirement already satisfied: gast>=0.2.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (0.2.2)\n",
            "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (0.33.4)\n",
            "Requirement already satisfied: grpcio>=1.8.6 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (1.15.0)\n",
            "Requirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (1.11.2)\n",
            "Requirement already satisfied: google-pasta>=0.1.6 in /usr/local/lib/python3.6/dist-packages (from tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (0.1.7)\n",
            "Requirement already satisfied: olefile in /usr/local/lib/python3.6/dist-packages (from pillow>=4.1.1->torchvision>=0.3.0->syft) (0.46)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from protobuf>=3.6.1->tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (41.0.1)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tensorboard<1.15.0,>=1.14.0->tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (3.1.1)\n",
            "Requirement already satisfied: h5py in /usr/local/lib/python3.6/dist-packages (from keras-applications>=1.0.6->tensorflow<2,>=1.12.0->tf-encrypted>=0.5.4->syft) (2.8.0)\n",
            "Building wheels for collected packages: zstd, pyyaml\n",
            "  Building wheel for zstd (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Stored in directory: /root/.cache/pip/wheels/ad/9a/f4/3105b5209674ac77fcca7fede95184c62a95df0196888e0e76\n",
            "  Building wheel for pyyaml (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Stored in directory: /root/.cache/pip/wheels/16/27/a1/775c62ddea7bfa62324fd1f65847ed31c55dadb6051481ba3f\n",
            "Successfully built zstd pyyaml\n",
            "Installing collected packages: python-engineio, python-socketio, flask-socketio, websockets, pyyaml, tf-encrypted, websocket-client, lz4, msgpack, zstd, syft\n",
            "  Found existing installation: PyYAML 3.13\n",
            "    Uninstalling PyYAML-3.13:\n",
            "      Successfully uninstalled PyYAML-3.13\n",
            "  Found existing installation: msgpack 0.5.6\n",
            "    Uninstalling msgpack-0.5.6:\n",
            "      Successfully uninstalled msgpack-0.5.6\n",
            "Successfully installed flask-socketio-4.1.0 lz4-2.1.10 msgpack-0.6.1 python-engineio-3.8.2 python-socketio-4.2.0 pyyaml-5.1.1 syft-0.1.20a1 tf-encrypted-0.5.6 websocket-client-0.56.0 websockets-7.0 zstd-1.4.0.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "WARNING: Logging before flag parsing goes to stderr.\n",
            "W0701 13:39:15.529377 140142607644544 secure_random.py:26] Falling back to insecure randomness since the required custom op could not be found for the installed version of TensorFlow. Fix this by compiling custom ops. Missing file was '/usr/local/lib/python3.6/dist-packages/tf_encrypted/operations/secure_random/secure_random_module_tf_1.14.0.so'\n",
            "W0701 13:39:15.547694 140142607644544 deprecation_wrapper.py:119] From /usr/local/lib/python3.6/dist-packages/tf_encrypted/session.py:26: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n",
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4dvVMo6l3ZhP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%config IPCompleter.greedy=True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g_r2V1VG_G71",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Create a few workers\n",
        "\n",
        "chidi = sy.VirtualWorker(hook, id=\"chidi\")\n",
        "ify = sy.VirtualWorker(hook, id=\"ify\")\n",
        "secure_worker = sy.VirtualWorker(hook, id=\"secure_worker\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R2Qwggea_G_N",
        "colab_type": "code",
        "outputId": "e8964758-b0c1-4a2b-f398-b5b90081bb77",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 156
        }
      },
      "source": [
        "chidi.add_workers([ify, secure_worker])\n",
        "ify.add_workers([ify, secure_worker])\n",
        "secure_worker.add_workers([ify, chidi])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "W0701 13:39:26.984366 140142607644544 base.py:628] Worker ify already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0701 13:39:26.989235 140142607644544 base.py:628] Worker secure_worker already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0701 13:39:26.991826 140142607644544 base.py:628] Worker ify already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0701 13:39:26.993118 140142607644544 base.py:628] Worker secure_worker already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0701 13:39:26.995720 140142607644544 base.py:628] Worker ify already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0701 13:39:26.996656 140142607644544 base.py:628] Worker chidi already exists. Replacing old worker which could cause                     unexpected behavior\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<VirtualWorker id:secure_worker #objects:0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZwtytqtA2sG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#A Toy Dataset\n",
        "data = th.tensor([[0,0], [0,1],[1,0],[1,1.]], requires_grad=True)\n",
        "target = th.tensor([[0], [0],[1],[1.]], requires_grad=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t9dr12OE_HCX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# get pointers to training data on each worker by\n",
        "#sending some training data to chidi and ify\n",
        "chidis_data = data[0:2].send(chidi)\n",
        "chidis_target = target[0:2].send(chidi)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-GgfE6wu_HE4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ifys_data = data[2:].send(ify)\n",
        "ifys_target = target[2:].send(ify)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VnJ5KbrDJ11R",
        "colab_type": "text"
      },
      "source": [
        "## **Step 2: Create My Model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HUU7-VK6_HH8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Initialize A Toy Model\n",
        "model = nn.Linear(2,1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MKeJ5fOYKk6m",
        "colab_type": "text"
      },
      "source": [
        "**Step 3: Send a Copy of The Model to Ify and Chidi**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "onOph-0SKtmb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "chidi_model = model.copy().send(chidi)\n",
        "ify_model = model.copy().send(ify)\n",
        "    \n",
        "chidi_opt = optim.SGD(params=chidi_model.parameters(), lr=0.1)\n",
        "ify_opt = optim.SGD(params=ify_model.parameters(), lr=0.1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kk6cifIlKz0h",
        "colab_type": "text"
      },
      "source": [
        "**Step 4: Train Chidi's and Ify's Models (in parallel)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YoAKJ-3S1Mld",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(10):\n",
        "    \n",
        "    # Train Chidi's Model\n",
        "    chidi_opt.zero_grad()\n",
        "    chidis_pred = chidi_model(chidis_data)\n",
        "    chidis_loss = ((chidis_pred - chidis_target)**2).sum()\n",
        "    chidis_loss.backward()\n",
        "\n",
        "    chidi_opt.step()\n",
        "    chidis_loss = chidis_loss.get().data\n",
        "\n",
        "    # Train Ify's Model\n",
        "    ify_opt.zero_grad()\n",
        "    ifys_pred = ify_model(ifys_data)\n",
        "    ifys_loss = ((ifys_pred - ifys_target)**2).sum()\n",
        "    ifys_loss.backward()\n",
        "\n",
        "    ify_opt.step()\n",
        "    ifys_loss = ifys_loss.get().data\n",
        "    ifys_loss\n",
        "        \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6uWC2E12MBTw",
        "colab_type": "text"
      },
      "source": [
        "## **Step 5: Send Both Updated Models to a Secure Worker**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n_c8Duhn1MwM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ify_model.move(secure_worker)\n",
        "chidi_model.move(secure_worker)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "12zt4hpQMM8G",
        "colab_type": "text"
      },
      "source": [
        "## **Step 6: Average The Models**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UUTFUZpJ1MzD",
        "colab_type": "code",
        "outputId": "f7ebae9e-935e-40f8-8f98-9a7f0a406e28",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "with th.no_grad():\n",
        "    model.weight.set_(((ify_model.weight.data + chidi_model.weight.data) / 2).get())\n",
        "    model.bias.set_(((ify_model.bias.data + chidi_model.bias.data) / 2).get())\n",
        "\n",
        "    print(\"Chidi:\" + str(chidis_loss) + \" Ify:\" + str(ifys_loss))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Chidi:tensor(0.0083) Ify:tensor(0.0048)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yiJqw-CyNCrh",
        "colab_type": "text"
      },
      "source": [
        "## **Step 7: Rinse and Repeat**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJFN0QCk1M5n",
        "colab_type": "code",
        "outputId": "18e0c8ad-7c29-4b71-ee82-e38e6cdcb25c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        }
      },
      "source": [
        "iterations = 10\n",
        "worker_iters = 5\n",
        "\n",
        "for a_iter in range(iterations):\n",
        "\n",
        "    chidi_model = model.copy().send(chidi)\n",
        "    ify_model = model.copy().send(ify)\n",
        "\n",
        "    chidi_opt = optim.SGD(params=chidi_model.parameters(), lr=0.1)\n",
        "    ify_opt = optim.SGD(params=ify_model.parameters(), lr=0.1)\n",
        "\n",
        "    for wi in range(worker_iters):\n",
        "        # Train Bob's Model\n",
        "        chidi_opt.zero_grad()\n",
        "        chidis_pred = chidi_model(chidis_data)\n",
        "        chidis_loss = ((chidis_pred - chidis_target) ** 2).sum()\n",
        "        chidis_loss.backward()\n",
        "\n",
        "        chidi_opt.step()\n",
        "        chidis_loss = chidis_loss.get().data\n",
        "\n",
        "        # Train Alice's Model\n",
        "        ify_opt.zero_grad()\n",
        "        ifys_pred = ify_model(ifys_data)\n",
        "        ifys_loss = ((ifys_pred - ifys_target) ** 2).sum()\n",
        "        ifys_loss.backward()\n",
        "\n",
        "        ify_opt.step()\n",
        "        ifys_loss = ifys_loss.get().data\n",
        "\n",
        "    ify_model.move(secure_worker)\n",
        "    chidi_model.move(secure_worker)\n",
        "\n",
        "    with th.no_grad():\n",
        "\n",
        "        model.weight.set_(((ify_model.weight.data + chidi_model.weight.data) / 2).get())\n",
        "        model.bias.set_(((ify_model.bias.data + chidi_model.bias.data) / 2).get())\n",
        "    \n",
        "    print(\"Chidi:\" + str(chidis_loss) + \" Alice:\" + str(ifys_loss))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Chidi:tensor(0.0089) Alice:tensor(0.0043)\n",
            "Chidi:tensor(0.0039) Alice:tensor(2.0317e-05)\n",
            "Chidi:tensor(0.0029) Alice:tensor(1.2747e-05)\n",
            "Chidi:tensor(0.0022) Alice:tensor(2.0675e-05)\n",
            "Chidi:tensor(0.0016) Alice:tensor(1.9907e-05)\n",
            "Chidi:tensor(0.0012) Alice:tensor(1.7353e-05)\n",
            "Chidi:tensor(0.0010) Alice:tensor(1.4533e-05)\n",
            "Chidi:tensor(0.0007) Alice:tensor(1.1882e-05)\n",
            "Chidi:tensor(0.0006) Alice:tensor(9.5567e-06)\n",
            "Chidi:tensor(0.0004) Alice:tensor(7.5969e-06)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gEIOskbU1M87",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "preds = model(data)\n",
        "loss = ((preds - target) ** 2).sum()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TR0OqiTH1NGO",
        "colab_type": "code",
        "outputId": "f8eaf951-edb5-4972-eeeb-8a8d99646d85",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        }
      },
      "source": [
        "print(preds)\n",
        "print(target)\n",
        "print(loss.data)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[0.0575],\n",
            "        [0.0468],\n",
            "        [0.9412],\n",
            "        [0.9304]], grad_fn=<AddmmBackward>)\n",
            "tensor([[0.],\n",
            "        [0.],\n",
            "        [1.],\n",
            "        [1.]], requires_grad=True)\n",
            "tensor(0.0138)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKhcgGGw1NL6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WycLwd1w-cdK",
        "colab_type": "text"
      },
      "source": [
        "# Lesson: Intro to Additive Secret Sharing\n",
        "\n",
        "While being able to have a trusted third party to perform the aggregation is certainly nice, in an ideal setting we wouldn't have to trust anyone at all. This is where Cryptography can provide an interesting alterantive.\n",
        "\n",
        "Specifically, we're going to be looking at a simple protocol for Secure Multi-Party Computation called Additive Secret Sharing. This protocol will allow multiple parties (of size 3 or more) to aggregate their gradients without the use of a trusted 3rd party to perform the aggregation. In other words, we can add 3 numbers together from 3 different people without anyone ever learning the inputs of any other actors.\n",
        "\n",
        "Let's start by considering the number 5, which we'll put into a varible x"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aFlHYuJwAIpr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qxv4djBaALMv",
        "colab_type": "text"
      },
      "source": [
        "Let's say we wanted to SHARE the ownership of this number between two people, Alice and Bob. We could split this number into two shares, 2, and 3, and give one to Alice and one to Bob"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "39WhcdQIAIux",
        "colab_type": "code",
        "outputId": "89ec5dc5-6c5c-43d7-fc79-07545ba6cd33",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "chidi_x_share = 4 \n",
        "ify_x_share = 7\n",
        "\n",
        "decrypted_x = chidi_x_share + ify_x_share\n",
        "decrypted_x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uXpFYl94A3ww",
        "colab_type": "text"
      },
      "source": [
        "Note that neither Chidi nor Ify know the value of x. They only know the value of their own SHARE of x. Thus, the true value of X is hidden (i.e., encrypted).\n",
        "\n",
        "The truly amazing thing, however, is that Ify and Chidi can still compute using this value! They can perform arithmetic over the hidden value! Let's say Chidi and Ify wanted to multiply this value by 2! If each of them multiplied their respective share by 2, then the hidden number between them is also multiplied! Check it out!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QW-U4r2UAIza",
        "colab_type": "code",
        "outputId": "dcb1fe1d-8548-46cf-ffe7-64695833eb88",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "chidi_x_share = 4 * 2\n",
        "ify_x_share = 7 * 2\n",
        "\n",
        "decrypted_x = chidi_x_share + ify_x_share\n",
        "decrypted_x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "22"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jb3oU-SoAI2T",
        "colab_type": "code",
        "outputId": "3fab5ed3-45a0-4ba6-979c-57ebd85f5d63",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# encrypted \"11\"\n",
        "chidi_x_share = 4\n",
        "ify_x_share = 7\n",
        "\n",
        "# encrypted \"13\"\n",
        "chidi_y_share = 5\n",
        "ify_y_share = 8\n",
        "\n",
        "# encrypted 11 + 13\n",
        "chidi_z_share = chidi_x_share + chidi_y_share\n",
        "ify_z_share = ify_x_share + ify_y_share\n",
        "\n",
        "decrypted_z = chidi_z_share + ify_z_share\n",
        "decrypted_z"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cl2yecs6CKTd",
        "colab_type": "text"
      },
      "source": [
        "As you can see, we just added two numbers together while they were still encrypted!!!\n",
        "One small tweak - notice that since all our numbers are positive, it's possible for each share to reveal a little bit of information about the hidden value, namely, it's always greater than the share. \n",
        "\n",
        "Thus, if Bob has a share \"3\" then he knows that the encrypted value is at least 3.\n",
        "This would be quite bad, but can be solved through a simple fix. Decryption happens by summing all the shares together MODULUS some constant. I.e."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OECnITmTAIxl",
        "colab_type": "code",
        "outputId": "ebf6e278-5c16-4b67-b1d2-c85e6500ba8d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = 5\n",
        "\n",
        "Q = 23740629843760239486723\n",
        "\n",
        "chidi_x_share = 23552870267 # <- a random number\n",
        "ify_x_share = Q - chidi_x_share + x\n",
        "ify_x_share"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "23740629843736686616461"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F1YVV_HPAItD",
        "colab_type": "code",
        "outputId": "32a27cf7-4497-4b24-bb0a-3a9423eff455",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "(chidi_x_share + ify_x_share) % Q"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n5zBxvBaCytB",
        "colab_type": "text"
      },
      "source": [
        "So now, as you can see, both shares are wildly larger than the number being shared, meaning that individual shares no longer leak this inforation. However, all the properties we discussed earlier still hold! (addition, encryption, decryption, etc.)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iJ2T_Vx2-cIv",
        "colab_type": "text"
      },
      "source": [
        "## **Project: Build Methods for Encrpt, Decrypt, and Add**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6HD7oS8ZC3ka",
        "colab_type": "text"
      },
      "source": [
        "Write general methods for encrypt, decrypt, and add. Store shares for a variable in a tuple like so."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vDLnyUMY1NO9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_share = (2, 5, 7)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QALNKTxoDDnh",
        "colab_type": "text"
      },
      "source": [
        "Even though normally those shares would be distributed amongst several workers, you can store them in ordered tuples like this for now."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VNkp_llX1Mtj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import random\n",
        "\n",
        "Q = 23740629843760239486723\n",
        "\n",
        "def encrypt(x, n_share=3):\n",
        "    shares = list()\n",
        "    \n",
        "    for i in range(n_share-1):\n",
        "        shares.append(random.randint(0, Q))\n",
        "        \n",
        "    shares.append(Q -(sum(shares) % Q) + x)\n",
        "    \n",
        "    return tuple(shares)\n",
        "\n",
        "\n",
        "def decrypt(shares):\n",
        "    return sum(shares) % Q"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UEaKo5SYDGWB",
        "colab_type": "code",
        "outputId": "257af783-51cd-458e-8577-aa28344dd07a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "shares = encrypt(3)\n",
        "shares"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12774262275557864140754, 7955286641132276664331, 3011080927070098681641)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9pWtMsCkDGdx",
        "colab_type": "code",
        "outputId": "e9aa95b0-f781-468f-ace2-155ee233bc78",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "decrypt(shares)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e_bSRCPdDGbf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def add(a, b):\n",
        "    c = list()\n",
        "    for i in range(len(a)):\n",
        "        c.append((a[i] + b[i]) % Q)\n",
        "    return tuple(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EsjOwcDaDGZp",
        "colab_type": "code",
        "outputId": "d1e76737-50cc-4814-87e0-ab25511f27d9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = encrypt(5)\n",
        "y = encrypt(7)\n",
        "z = add(x,y)\n",
        "decrypt(z)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5WK6dPoFPWz",
        "colab_type": "text"
      },
      "source": [
        "# Lesson: Intro to Fixed Precision Encoding"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qXLWJtdWFP05",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nR0l2PprFPTR",
        "colab_type": "text"
      },
      "source": [
        "As you may remember, our goal is to aggregate gradients using this new Secret Sharing technique. However, the protocol we've just explored in the last section uses positive integers. \n",
        "\n",
        "However, our neural network weights are NOT integers. Instead, our weights are decimals (floating point numbers).\n",
        "\n",
        "Not a huge deal! We just need to use a fixed precision encoding, which lets us do computation over decimal numbers using integers!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YCYkX1zl1MrQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "BASE=10\n",
        "PRECISION=4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5lffr1VU1Mo7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def encode(x):\n",
        "    return int((x * (BASE ** PRECISION)) % Q)\n",
        "\n",
        "def decode(x):\n",
        "    return (x if x <= Q/2 else x - Q) / BASE**PRECISION"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P8C5z9bE_G5e",
        "colab_type": "code",
        "outputId": "addbea90-6eab-4d17-ab88-2854ea61c734",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "encode(0.5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j-X0vMVEGffJ",
        "colab_type": "code",
        "outputId": "43cae2ba-b315-40da-d62d-0d67391b50b3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "decode(23740629843760239486723)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cb_OEG7YG5Ko",
        "colab_type": "text"
      },
      "source": [
        "# Lesson: Secret Sharing + Fixed Precision in PySyft\n",
        "\n",
        "While writing things from scratch is certainly educational, PySyft makes a great deal of this much easier for us through its abstractions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ofugVZ9LG5Em",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bV4UjJnlGfmn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "chidi = chidi.clear_objects()\n",
        "ify = ify.clear_objects()\n",
        "secure_worker = secure_worker.clear_objects()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nxaRrcwNGfk2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = th.tensor([1, 2, 3, 4, 5])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9IVylAiExYpn",
        "colab_type": "text"
      },
      "source": [
        "## Secret Sharing using PySyft\n",
        "\n",
        "We can share using the simple .share() method"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hIbyjwHZGfik",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = x.share(chidi, ify, secure_worker)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OEbsHsWJGfcz",
        "colab_type": "code",
        "outputId": "79bf6abd-7d4a-4911-8664-d3e255655bee",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        }
      },
      "source": [
        "chidi._objects"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{36114151322: tensor([2391663088107767470, 1467480730077372073, 3326523293831324093,\n",
              "         3723216618766852754, 1964192121140691275])}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tPnNrXh2zKOB",
        "colab_type": "text"
      },
      "source": [
        "and as you can see, Chidi now has one of the shares of x! Furthermore, we can still call addition in this state, and PySyft will automatically perform the remote execution for us!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3CG6W36hGfaT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = x + x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LyBWaRDhzQy9",
        "colab_type": "code",
        "outputId": "143bcebf-24ed-40b4-964a-71a527918f7d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "y"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Wrapper)>[AdditiveSharingTensor]\n",
              "\t-> (Wrapper)>[PointerTensor | me:48409368119 -> chidi:51424139305]\n",
              "\t-> (Wrapper)>[PointerTensor | me:72132040246 -> ify:92128867856]\n",
              "\t-> (Wrapper)>[PointerTensor | me:89651171190 -> secure_worker:30806366277]\n",
              "\t*crypto provider: me*"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V1_ZSdCozREE",
        "colab_type": "code",
        "outputId": "2e5afde7-68f7-468b-b4e4-5bf6e91945ef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "y.get()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 2,  4,  6,  8, 10])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "shfdqfbNze_l",
        "colab_type": "text"
      },
      "source": [
        "## Fixed Precision using PySyft\n",
        "\n",
        "We can also convert a tensor to fixed precision using .fix_precision()"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qEQqfsvdzRaN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = th.tensor([0.1,0.2,0.3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h9eURkQCzRXp",
        "colab_type": "code",
        "outputId": "7ab0f7c2-06b2-48a6-a91b-c6976e53b74c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.1000, 0.2000, 0.3000])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t2x3HAOwzRUP",
        "colab_type": "code",
        "outputId": "b5f16423-a479-4747-cb04-05cdfdca86c8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = x.fix_prec()\n",
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Wrapper)>FixedPrecisionTensor>tensor([100, 200, 300])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-W_Z4NJTzRJ9",
        "colab_type": "code",
        "outputId": "fe87601b-51e1-4662-f4e0-18b4a11b8873",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = x.float_prec()\n",
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.1000, 0.2000, 0.3000])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mg8jCigqzRHx",
        "colab_type": "code",
        "outputId": "238c1cd0-93f0-4533-fa89-0f625c36b7f0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = th.tensor([0.1,0.2,0.3])\n",
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.1000, 0.2000, 0.3000])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jJq6xFtazRB1",
        "colab_type": "code",
        "outputId": "2337bfef-6cab-4c57-e9f1-8a8e988b5faa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = x.fix_prec()\n",
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Wrapper)>FixedPrecisionTensor>tensor([100, 200, 300])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gJGVx1JvzQ_d",
        "colab_type": "code",
        "outputId": "c0b3a7ea-ae0f-46cf-dae9-77f713e48adb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "x = th.tensor([0.1,0.2,0.3]).fix_prec().share(chidi, ify, secure_worker)\n",
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Wrapper)>FixedPrecisionTensor>(Wrapper)>[AdditiveSharingTensor]\n",
              "\t-> (Wrapper)>[PointerTensor | me:43210789932 -> chidi:63994234335]\n",
              "\t-> (Wrapper)>[PointerTensor | me:53432084992 -> ify:15574064290]\n",
              "\t-> (Wrapper)>[PointerTensor | me:10555373489 -> secure_worker:42656734454]\n",
              "\t*crypto provider: me*"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bvwrcmoTzQ9F",
        "colab_type": "code",
        "outputId": "48862455-307a-4a20-9cf8-4e875942d588",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "y = x + x\n",
        "y"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Wrapper)>FixedPrecisionTensor>(Wrapper)>[AdditiveSharingTensor]\n",
              "\t-> (Wrapper)>[PointerTensor | me:8967195833 -> chidi:73174068248]\n",
              "\t-> (Wrapper)>[PointerTensor | me:10162491514 -> ify:79982910859]\n",
              "\t-> (Wrapper)>[PointerTensor | me:62831665848 -> secure_worker:30013613246]\n",
              "\t*crypto provider: me*"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pKgka6z02IhY",
        "colab_type": "code",
        "outputId": "6034f55e-5c97-4834-a158-39d1db0a25f9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "y = y.get().float_prec()\n",
        "y"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.2000, 0.4000, 0.6000])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g5wFfNkH2WHv",
        "colab_type": "text"
      },
      "source": [
        "# Final Project: Federated learning with Encrypted Gradient Aggregation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VcX3llvR2IoF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3VMfQ-3B2IlG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Bpngii82IeU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3XP8qNZlzQ7D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cDNFln-wzQ46",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4qTkpYJ2zQ2c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}