Section 3 - Securing Federated Learning.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.1"
    },
    "colab": {
      "name": "Section 3 - Securing Federated Learning.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/agungsantoso/private-ai/blob/master/Section%203%20-%20Securing%20Federated%20Learning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-LW7ThWecnWu",
        "colab_type": "text"
      },
      "source": [
        "# Section: Securing Federated Learning\n",
        "\n",
        "- Lesson 1: Trusted Aggregator\n",
        "- Lesson 2: Intro to Additive Secret Sharing\n",
        "- Lesson 3: Intro to Fixed Precision Encoding\n",
        "- Lesson 4: Secret Sharing + Fixed Precision in PySyft\n",
        "- Final Project: Federated Learning wtih Encrypted Gradient Aggregation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xg8T00XicnWv",
        "colab_type": "text"
      },
      "source": [
        "# Lesson: Federated Learning with a Trusted Aggregator\n",
        "\n",
        "In the last section, we learned how to train a model on a distributed dataset using Federated Learning. In particular, the last project aggregated gradients directly from one data owner to another. \n",
        "\n",
        "However, while in some cases it could be ideal to do this, what would be even better is to be able to choose a neutral third party to perform the aggregation.\n",
        "\n",
        "As it turns out, we can use the same tools we used previously to accomplish this."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HTt6n_MicnWw",
        "colab_type": "text"
      },
      "source": [
        "# Project: Federated Learning with a Trusted Aggregator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dze-SOiccnWx",
        "colab_type": "text"
      },
      "source": [
        "### Step 1: Create Data Owners"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "av42bA6xxf9W",
        "colab_type": "code",
        "outputId": "a24651a4-df7d-422d-9553-f3785cc7e96a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "!pip install syft"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting syft\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/38/2e/16bdefc78eb089e1efa9704c33b8f76f035a30dc935bedd7cbb22f6dabaa/syft-0.1.21a1-py3-none-any.whl (219kB)\n",
            "\u001b[K     |████████████████████████████████| 225kB 4.8MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.14.0 in /usr/local/lib/python3.6/dist-packages (from syft) (1.16.4)\n",
            "Collecting zstd>=1.4.0.0 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/22/37/6a7ba746ebddbd6cd06de84367515d6bc239acd94fb3e0b1c85788176ca2/zstd-1.4.1.0.tar.gz (454kB)\n",
            "\u001b[K     |████████████████████████████████| 460kB 38.7MB/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 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 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 43.2MB/s \n",
            "\u001b[?25hCollecting 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 46.7MB/s \n",
            "\u001b[?25hRequirement already satisfied: torch>=1.1 in /usr/local/lib/python3.6/dist-packages (from syft) (1.1.0)\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: Flask>=1.0.2 in /usr/local/lib/python3.6/dist-packages (from syft) (1.1.1)\n",
            "Requirement already satisfied: tblib>=1.4.0 in /usr/local/lib/python3.6/dist-packages (from syft) (1.4.0)\n",
            "Collecting tf-encrypted>=0.5.4 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/55/ff/7dbd5fc77fcec0df1798268a6b72a2ab0150b854761bc39c77d566798f0b/tf_encrypted-0.5.7-py3-none-manylinux1_x86_64.whl (2.1MB)\n",
            "\u001b[K     |████████████████████████████████| 2.1MB 33.7MB/s \n",
            "\u001b[?25hCollecting websockets>=7.0 (from syft)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/c1/d2/bf72435a7d56f94b57efdeae26c76bf0d16f409fd44ff595da745c3fbefd/websockets-8.0.1-cp36-cp36m-manylinux1_x86_64.whl (72kB)\n",
            "\u001b[K     |████████████████████████████████| 81kB 27.1MB/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 47.6MB/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",
            "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 20.3MB/s \n",
            "\u001b[?25hRequirement 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",
            "Requirement already satisfied: Jinja2>=2.10.1 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: Werkzeug>=0.15 in /usr/local/lib/python3.6/dist-packages (from Flask>=1.0.2->syft) (0.15.5)\n",
            "Requirement 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 49.9MB/s \n",
            "\u001b[?25hRequirement already satisfied: olefile in /usr/local/lib/python3.6/dist-packages (from pillow>=4.1.1->torchvision>=0.3.0->syft) (0.46)\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/bd/b8/0fc389ca5c445051b37b17802f80bbf1b51c1e3b48b772ee608efbb90583/python_engineio-3.8.2.post1-py2.py3-none-any.whl (119kB)\n",
            "\u001b[K     |████████████████████████████████| 122kB 39.5MB/s \n",
            "\u001b[?25hRequirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.6/dist-packages (from Jinja2>=2.10.1->Flask>=1.0.2->syft) (1.1.1)\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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: setuptools>=41.0.0 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) (41.0.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/66/3f/ee/ac08c81af7c1b24a80c746df669ea3cb37542d27877d66ccf4\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: zstd, python-engineio, python-socketio, flask-socketio, lz4, websocket-client, pyyaml, tf-encrypted, websockets, msgpack, 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.post1 python-socketio-4.2.0 pyyaml-5.1.1 syft-0.1.21a1 tf-encrypted-0.5.7 websocket-client-0.56.0 websockets-8.0.1 zstd-1.4.1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vsa3tHhEcnWy",
        "colab_type": "code",
        "outputId": "5e1db8d7-9720-45e7-dc8c-3121098f11f9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 213
        }
      },
      "source": [
        "import syft as sy\n",
        "import torch as th\n",
        "hook = sy.TorchHook(th)\n",
        "from torch import nn, optim\n",
        "\n",
        "# create a couple workers\n",
        "\n",
        "bob = sy.VirtualWorker(hook, id=\"bob\")\n",
        "alice = sy.VirtualWorker(hook, id=\"alice\")\n",
        "secure_worker = sy.VirtualWorker(hook, id=\"secure_worker\")\n",
        "\n",
        "bob.add_workers([alice, secure_worker])\n",
        "alice.add_workers([bob, secure_worker])\n",
        "secure_worker.add_workers([alice, bob])\n",
        "\n",
        "# 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)\n",
        "\n",
        "# get pointers to training data on each worker by\n",
        "# sending some training data to bob and alice\n",
        "bobs_data = data[0:2].send(bob)\n",
        "bobs_target = target[0:2].send(bob)\n",
        "\n",
        "alices_data = data[2:].send(alice)\n",
        "alices_target = target[2:].send(alice)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING: Logging before flag parsing goes to stderr.\n",
            "W0726 03:06:52.820909 140619399284608 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",
            "W0726 03:06:52.840463 140619399284608 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",
            "W0726 03:06:57.394903 140619399284608 base.py:628] Worker alice already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0726 03:06:57.396134 140619399284608 base.py:628] Worker secure_worker already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0726 03:06:57.397412 140619399284608 base.py:628] Worker bob already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0726 03:06:57.399439 140619399284608 base.py:628] Worker secure_worker already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0726 03:06:57.400659 140619399284608 base.py:628] Worker alice already exists. Replacing old worker which could cause                     unexpected behavior\n",
            "W0726 03:06:57.401824 140619399284608 base.py:628] Worker bob already exists. Replacing old worker which could cause                     unexpected behavior\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JF_S72VxcnW3",
        "colab_type": "text"
      },
      "source": [
        "### Step 2: Create Our Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IeUvpmRWcnW4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Iniitalize A Toy Model\n",
        "model = nn.Linear(2,1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CDh4Qp4CcnW7",
        "colab_type": "text"
      },
      "source": [
        "### Step 3: Send a Copy of The Model to Alice and Bob"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUpJqF8RcnW8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bobs_model = model.copy().send(bob)\n",
        "alices_model = model.copy().send(alice)\n",
        "\n",
        "bobs_opt = optim.SGD(params=bobs_model.parameters(),lr=0.1)\n",
        "alices_opt = optim.SGD(params=alices_model.parameters(),lr=0.1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yoFOE0DWcnW_",
        "colab_type": "text"
      },
      "source": [
        "### Step 4: Train Bob's and Alice's Models (in parallel)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1dz_BedqcnXA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(10):\n",
        "\n",
        "    # Train Bob's Model\n",
        "    bobs_opt.zero_grad()\n",
        "    bobs_pred = bobs_model(bobs_data)\n",
        "    bobs_loss = ((bobs_pred - bobs_target)**2).sum()\n",
        "    bobs_loss.backward()\n",
        "\n",
        "    bobs_opt.step()\n",
        "    bobs_loss = bobs_loss.get().data\n",
        "\n",
        "    # Train Alice's Model\n",
        "    alices_opt.zero_grad()\n",
        "    alices_pred = alices_model(alices_data)\n",
        "    alices_loss = ((alices_pred - alices_target)**2).sum()\n",
        "    alices_loss.backward()\n",
        "\n",
        "    alices_opt.step()\n",
        "    alices_loss = alices_loss.get().data\n",
        "    alices_loss"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_vlGbztXcnXD",
        "colab_type": "text"
      },
      "source": [
        "### Step 5: Send Both Updated Models to a Secure Worker"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "INTqofkycnXD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "alices_model.move(secure_worker)\n",
        "bobs_model.move(secure_worker)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "whf3XB2GcnXG",
        "colab_type": "text"
      },
      "source": [
        "### Step 6: Average The Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c9gGOHOYcnXH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "with th.no_grad():\n",
        "\n",
        "    model.weight.set_(((alices_model.weight.data + bobs_model.weight.data) / 2).get())\n",
        "    model.bias.set_(((alices_model.bias.data + bobs_model.bias.data) / 2).get())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J1UNc2JJcnXL",
        "colab_type": "text"
      },
      "source": [
        "### Step 7: Rinse and Repeat"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CQZKXWeWcnXM",
        "colab_type": "code",
        "outputId": "a62eb9fb-9fca-49ce-d650-628191765f49",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 193
        }
      },
      "source": [
        "iterations = 10\n",
        "worker_iters = 5\n",
        "\n",
        "for a_iter in range(iterations):\n",
        "\n",
        "    bobs_model = model.copy().send(bob)\n",
        "    alices_model = model.copy().send(alice)\n",
        "\n",
        "    bobs_opt = optim.SGD(params=bobs_model.parameters(), lr=0.1)\n",
        "    alices_opt = optim.SGD(params=alices_model.parameters(), lr=0.1)\n",
        "\n",
        "    for wi in range(worker_iters):\n",
        "        # Train Bob's Model\n",
        "        bobs_opt.zero_grad()\n",
        "        bobs_pred = bobs_model(bobs_data)\n",
        "        bobs_loss = ((bobs_pred - bobs_target) ** 2).sum()\n",
        "        bobs_loss.backward()\n",
        "\n",
        "        bobs_opt.step()\n",
        "        bobs_loss = bobs_loss.get().data\n",
        "\n",
        "        # Train Alice's Model\n",
        "        alices_opt.zero_grad()\n",
        "        alices_pred = alices_model(alices_data)\n",
        "        alices_loss = ((alices_pred - alices_target) ** 2).sum()\n",
        "        alices_loss.backward()\n",
        "\n",
        "        alices_opt.step()\n",
        "        alices_loss = alices_loss.get().data\n",
        "\n",
        "    alices_model.move(secure_worker)\n",
        "    bobs_model.move(secure_worker)\n",
        "\n",
        "    with th.no_grad():\n",
        "\n",
        "        model.weight.set_(((alices_model.weight.data + bobs_model.weight.data) / 2).get())\n",
        "        model.bias.set_(((alices_model.bias.data + bobs_model.bias.data) / 2).get())\n",
        "    \n",
        "    print(\"Bob:\" + str(bobs_loss) + \" Alice:\" + str(alices_loss))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Bob:tensor(0.0035) Alice:tensor(0.0045)\n",
            "Bob:tensor(0.0037) Alice:tensor(0.0020)\n",
            "Bob:tensor(0.0035) Alice:tensor(0.0010)\n",
            "Bob:tensor(0.0032) Alice:tensor(0.0006)\n",
            "Bob:tensor(0.0027) Alice:tensor(0.0003)\n",
            "Bob:tensor(0.0023) Alice:tensor(0.0002)\n",
            "Bob:tensor(0.0019) Alice:tensor(0.0001)\n",
            "Bob:tensor(0.0015) Alice:tensor(6.9339e-05)\n",
            "Bob:tensor(0.0012) Alice:tensor(4.5438e-05)\n",
            "Bob:tensor(0.0009) Alice:tensor(3.0719e-05)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wTKmV08dcnXQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "preds = model(data)\n",
        "loss = ((preds - target) ** 2).sum()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ygDDjQ0mcnXT",
        "colab_type": "code",
        "outputId": "4be8835c-cd8a-488b-b30b-3c3ac43a0a56",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 175
        }
      },
      "source": [
        "print(preds)\n",
        "print(target)\n",
        "print(loss.data)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[0.0874],\n",
            "        [0.0725],\n",
            "        [0.9083],\n",
            "        [0.8934]], grad_fn=<AddmmBackward>)\n",
            "tensor([[0.],\n",
            "        [0.],\n",
            "        [1.],\n",
            "        [1.]], requires_grad=True)\n",
            "tensor(0.0327)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "moMUpJUecnXW",
        "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": "WmbzKs_PcnXX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g-KCXGjzcnXZ",
        "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": "TqqicfuLcnXa",
        "colab_type": "code",
        "outputId": "bbb95e26-63a1-464f-c587-ce8040eeaa15",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "bob_x_share = 2\n",
        "alice_x_share = 3\n",
        "\n",
        "decrypted_x = bob_x_share + alice_x_share\n",
        "decrypted_x"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d-v-YxdocnXe",
        "colab_type": "text"
      },
      "source": [
        "Note that neither Bob nor Alice 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 Alice and Bob can still compute using this value! They can perform arithmetic over the hidden value! Let's say Bob and Alice 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": "spuXoDolcnXe",
        "colab_type": "code",
        "outputId": "a851a6a4-ac81-49fa-b04d-3e75bd45cc25",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "bob_x_share = 2 * 2\n",
        "alice_x_share = 3 * 2\n",
        "\n",
        "decrypted_x = bob_x_share + alice_x_share\n",
        "decrypted_x"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BQ5jA4ZTcnXi",
        "colab_type": "text"
      },
      "source": [
        "This even works for addition between two shared values!!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GTBrJBX4cnXi",
        "colab_type": "code",
        "outputId": "9fd9252c-7933-45cf-cf16-41e30f8eed60",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# encrypted \"5\"\n",
        "bob_x_share = 2\n",
        "alice_x_share = 3\n",
        "\n",
        "# encrypted \"7\"\n",
        "bob_y_share = 5\n",
        "alice_y_share = 2\n",
        "\n",
        "# encrypted 5 + 7\n",
        "bob_z_share = bob_x_share + bob_y_share\n",
        "alice_z_share = alice_x_share + alice_y_share\n",
        "\n",
        "decrypted_z = bob_z_share + alice_z_share\n",
        "decrypted_z"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cu1ud3JYcnXm",
        "colab_type": "text"
      },
      "source": [
        "As you can see, we just added two numbers together while they were still encrypted!!!\n",
        "\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. Thus, if Bob has a share \"3\" then he knows that the encrypted value is at least 3.\n",
        "\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": "RBNclckicnXo",
        "colab_type": "code",
        "outputId": "481d01de-aa6a-4120-dbc5-2bc103f45ade",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = 5\n",
        "\n",
        "Q = 23740629843760239486723\n",
        "\n",
        "bob_x_share = 23552870267 # <- a random number\n",
        "alice_x_share = Q - bob_x_share + x\n",
        "alice_x_share"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "23740629843736686616461"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hgJa9yazcnXu",
        "colab_type": "code",
        "outputId": "770a9d63-c2fd-4f33-dfb1-30c62ecc75bc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "(bob_x_share + alice_x_share) % Q"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "65LCMPu8cnXy",
        "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": "92owwYa9cnXz",
        "colab_type": "text"
      },
      "source": [
        "# Project: Build Methods for Encrypt, Decrypt, and Add \n",
        "\n",
        "In this project, you must take the lessons we learned in the last section and write general methods for encrypt, decrypt, and add. Store shares for a variable in a tuple like so."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zTwbTfcncnX0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_share = (2,5,7)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e4ivR_0qcnX5",
        "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": "Lrt0ewklcnX5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import random\n",
        "\n",
        "Q = 23740629843760239486723\n",
        "\n",
        "def encrypt(x, n_share=3):\n",
        "    \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",
        "def decrypt(shares):\n",
        "    return sum(shares) % Q"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OxYljM_hcnX8",
        "colab_type": "code",
        "outputId": "750a0990-1d1c-40d7-90a6-3306baf558e6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "shares = encrypt(3)\n",
        "shares"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2930948717843213301665, 22673218089946476669295, 21877092879730789002489)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6XflVt5dcnX_",
        "colab_type": "code",
        "outputId": "023de96e-dbd2-4c8b-9ec2-1dce5d6da40b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "decrypt(shares)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "40CA_ze8cnYD",
        "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": "pf0x5cmrcnYF",
        "colab_type": "code",
        "outputId": "5ea532e0-7e09-48bf-e4f6-20f8bfdd768d",
        "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": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C6_HRq6zcnYI",
        "colab_type": "text"
      },
      "source": [
        "# Lesson: Intro to Fixed Precision Encoding\n",
        "\n",
        "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. 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": "kj4WnROBcnYJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "BASE=10\n",
        "PRECISION=4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xRm4T6vHcnYL",
        "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": "_7nUkomlcnYO",
        "colab_type": "code",
        "outputId": "c5b8adc3-75cb-408b-d371-de2293f70772",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "encode(3.5)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "35000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vVOjduO2cnYR",
        "colab_type": "code",
        "outputId": "2cd94f30-be59-49c3-fd46-9a25907430ae",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "decode(35000)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZFDtbCXTcnYU",
        "colab_type": "code",
        "outputId": "918af24a-efc8-4cdf-8b63-0f38eaeaffd5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = encrypt(encode(5.5))\n",
        "y = encrypt(encode(2.3))\n",
        "z = add(x,y)\n",
        "decode(decrypt(z))"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7.8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TIFQqOFYcnYW",
        "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": "code",
      "metadata": {
        "id": "zm3Oica3cnYX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bob = bob.clear_objects()\n",
        "alice = alice.clear_objects()\n",
        "secure_worker = secure_worker.clear_objects()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4UDkxgwicnYZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = th.tensor([1,2,3,4,5])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7mRG0muDcnYb",
        "colab_type": "text"
      },
      "source": [
        "### Secret Sharing Using PySyft\n",
        "\n",
        "We can share using the simple .share() method!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cc58ViBIcnYj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = x.share(bob, alice, secure_worker)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LWQGA81gcnYl",
        "colab_type": "code",
        "outputId": "e450323e-d0ee-4ad0-bf84-49635ed6ce4a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "bob._objects"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{49928791969: tensor([3155144475414701403,   38603345198376778, 4323451298283060722,\n",
              "          381665905306091871,  710006497836325542])}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8bIuw7S6cnYo",
        "colab_type": "text"
      },
      "source": [
        "and as you can see, Bob 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": "znDdVIFGcnYp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = x + x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hjj3ZHyqcnYr",
        "colab_type": "code",
        "outputId": "1b29d8ab-9d43-448b-d672-a1350e8a54e7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        }
      },
      "source": [
        "y"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Wrapper)>[AdditiveSharingTensor]\n",
              "\t-> (Wrapper)>[PointerTensor | me:3042886726 -> bob:11744107805]\n",
              "\t-> (Wrapper)>[PointerTensor | me:45076325706 -> alice:18218913607]\n",
              "\t-> (Wrapper)>[PointerTensor | me:64506422896 -> secure_worker:37546561259]\n",
              "\t*crypto provider: me*"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "puKB6ZTocnYt",
        "colab_type": "code",
        "outputId": "edf58e43-de5f-4ae7-8ccd-906d6c28e614",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "y.get()"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 2,  4,  6,  8, 10])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7h-ZYauacnYx",
        "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": "uAbo5cRtcnYz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = th.tensor([0.1,0.2,0.3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QdXvXBu7cnY1",
        "colab_type": "code",
        "outputId": "f8c81f9d-a88a-4ab9-b85f-fe339c2132c5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.1000, 0.2000, 0.3000])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XwVIpQ17cnY4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = x.fix_prec()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E2po41CDcnY7",
        "colab_type": "code",
        "outputId": "d1a01108-1f62-42a6-d53f-83d8715a6d53",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x.child.child"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([100, 200, 300])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QgtALcbtcnY-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = x + x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6f2OkZ9WcnZB",
        "colab_type": "code",
        "outputId": "a295e971-fe95-4544-d558-068cc2d8e499",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "y = y.float_prec()\n",
        "y"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.2000, 0.4000, 0.6000])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2x-9v2CBcnZD",
        "colab_type": "text"
      },
      "source": [
        "### Shared Fixed Precision\n",
        "\n",
        "And of course, we can combine the two!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Of1IvxevcnZF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = th.tensor([0.1, 0.2, 0.3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jc9Bom-AcnZH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = x.fix_prec().share(bob, alice, secure_worker)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "12wbblapcnZI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = x + x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZY8brBsScnZM",
        "colab_type": "code",
        "outputId": "504db0bd-db14-4557-f904-0757afd9127b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "y.get().float_prec()"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.2000, 0.4000, 0.6000])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnyuO1cwcnZP",
        "colab_type": "text"
      },
      "source": [
        "Make sure to make the point that people can see the model averages in the clear."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4DFWlxxScnZQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ylCF0MjlcnZR",
        "colab_type": "text"
      },
      "source": [
        "# Final Project: Federated Learning with Encrypted Gradient Aggregation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XU9lAMejcnZS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "15xxya3ycnZT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}