federated_learning_basic_pytorch_syft.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled12.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/eshnil2000/google-colab/blob/master/federated_learning_basic_pytorch_syft.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h4SpH203xC8m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#First, let's perform standard training\n",
        "#Install required modules\n",
        "#%%capture\n",
        "import warnings\n",
        "warnings.simplefilter('ignore')\n",
        "\n",
        "!git clone https://github.com/eshnil2000/google-colab.git\n",
        "%cd google-colab\n",
        "!pip install pytorch \n",
        "import torch\n",
        "from torch import nn\n",
        "from torch import optim\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OQEpQIMbCOA6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# PySyft Toy Dataset \n",
        "data = torch.tensor([[0,0],[0,1],[1,0],[1,1.]], requires_grad=True)\n",
        "target = torch.tensor([[0],[0],[1],[1.]], requires_grad=True)\n",
        "\n",
        "# A Toy Model\n",
        "model = nn.Linear(2,1)\n",
        "\n",
        "#Training function\n",
        "def train():\n",
        "    # Training Logic\n",
        "    opt = optim.SGD(params=model.parameters(),lr=0.1)\n",
        "    for iter in range(20):\n",
        "\n",
        "        # 1) erase previous gradients (if they exist)\n",
        "        opt.zero_grad()\n",
        "\n",
        "        # 2) make a prediction\n",
        "        pred = model(data)\n",
        "\n",
        "        # 3) calculate how much we missed\n",
        "        loss = ((pred - target)**2).sum()\n",
        "\n",
        "        # 4) figure out which weights caused us to miss\n",
        "        loss.backward()\n",
        "\n",
        "        # 5) change those weights\n",
        "        opt.step()\n",
        "\n",
        "        # 6) print our progress\n",
        "        print(loss.data)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9LhE8vA8CQoh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "9c46d3aa-02a1-4c53-fc13-25716de0f563"
      },
      "source": [
        "#Call the training function\n",
        "train()\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(0.8230)\n",
            "tensor(0.5356)\n",
            "tensor(0.3514)\n",
            "tensor(0.2316)\n",
            "tensor(0.1534)\n",
            "tensor(0.1021)\n",
            "tensor(0.0684)\n",
            "tensor(0.0461)\n",
            "tensor(0.0312)\n",
            "tensor(0.0213)\n",
            "tensor(0.0147)\n",
            "tensor(0.0102)\n",
            "tensor(0.0071)\n",
            "tensor(0.0050)\n",
            "tensor(0.0036)\n",
            "tensor(0.0026)\n",
            "tensor(0.0018)\n",
            "tensor(0.0013)\n",
            "tensor(0.0010)\n",
            "tensor(0.0007)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MSwO0nO0ZTNN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2158634d-09a9-45ab-ec96-1874789ac587"
      },
      "source": [
        "model.train()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Linear(in_features=2, out_features=1, bias=True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CGLt-38ACTUj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "663484cb-04cc-4208-e4ae-55e4980652e3"
      },
      "source": [
        "#Inspect the trained weights\n",
        "model.weight"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Parameter containing:\n",
              "tensor([[ 0.9788, -0.0073]], requires_grad=True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FTEFxZbsCy3D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Now let's implement Federated training, where we distribute the data to multiple workers, send them the model \n",
        "#so they can independently run model on their data, and share back the learned weights, without sharing/sending back the data\n",
        "\n",
        "#Install required modules\n",
        "%%capture\n",
        "import warnings\n",
        "warnings.simplefilter('ignore')\n",
        "\n",
        "!pip install syft\n",
        "import syft as sy\n",
        "hook = sy.TorchHook(torch)\n",
        "\n",
        "# create a couple workers\n",
        "\n",
        "bob = sy.VirtualWorker(hook, id=\"bob\")\n",
        "alice = sy.VirtualWorker(hook, id=\"alice\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9DOH8Bs5JhQ8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# A Toy Dataset\n",
        "data = torch.tensor([[0,0],[0,1],[1,0],[1,1.]], requires_grad=True)\n",
        "target = torch.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",
        "data_bob = data[0:2]\n",
        "target_bob = target[0:2]\n",
        "\n",
        "data_alice = data[2:]\n",
        "target_alice = target[2:]\n",
        "\n",
        "# Iniitalize A Toy Model\n",
        "model = nn.Linear(2,1)\n",
        "\n",
        "data_bob = data_bob.send(bob)\n",
        "data_alice = data_alice.send(alice)\n",
        "target_bob = target_bob.send(bob)\n",
        "target_alice = target_alice.send(alice)\n",
        "\n",
        "# organize pointers into a list\n",
        "datasets = [(data_bob,target_bob),(data_alice,target_alice)]\n",
        "\n",
        "opt = optim.SGD(params=model.parameters(),lr=0.1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jEQTaOQcJlJe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#The training function\n",
        "def train():\n",
        "    # Training Logic\n",
        "    opt = optim.SGD(params=model.parameters(),lr=0.1)\n",
        "    for iter in range(10):\n",
        "        \n",
        "        # NEW) iterate through each worker's dataset\n",
        "        for data,target in datasets:\n",
        "            \n",
        "            # NEW) send model to correct worker\n",
        "            model.send(data.location)\n",
        "\n",
        "            # 1) erase previous gradients (if they exist)\n",
        "            opt.zero_grad()\n",
        "\n",
        "            # 2) make a prediction\n",
        "            pred = model(data)\n",
        "\n",
        "            # 3) calculate how much we missed\n",
        "            loss = ((pred - target)**2).sum()\n",
        "\n",
        "            # 4) figure out which weights caused us to miss\n",
        "            loss.backward()\n",
        "\n",
        "            # 5) change those weights\n",
        "            opt.step()\n",
        "            \n",
        "            # NEW) get model (with gradients)\n",
        "            model.get()\n",
        "\n",
        "            # 6) print our progress\n",
        "            print(loss.get()) # NEW) slight edit... need to call .get() on loss\\\n",
        "    \n",
        "# federated averaging"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SvnLHMgzJmO9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "e888c128-125d-462d-a726-0b2c5bd6fd32"
      },
      "source": [
        "#Call the training function\n",
        "train()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(0.9363, requires_grad=True)\n",
            "tensor(0.9908, requires_grad=True)\n",
            "tensor(0.8230, requires_grad=True)\n",
            "tensor(0.3995, requires_grad=True)\n",
            "tensor(0.4891, requires_grad=True)\n",
            "tensor(0.2251, requires_grad=True)\n",
            "tensor(0.2836, requires_grad=True)\n",
            "tensor(0.1301, requires_grad=True)\n",
            "tensor(0.1642, requires_grad=True)\n",
            "tensor(0.0753, requires_grad=True)\n",
            "tensor(0.0950, requires_grad=True)\n",
            "tensor(0.0436, requires_grad=True)\n",
            "tensor(0.0550, requires_grad=True)\n",
            "tensor(0.0252, requires_grad=True)\n",
            "tensor(0.0318, requires_grad=True)\n",
            "tensor(0.0146, requires_grad=True)\n",
            "tensor(0.0184, requires_grad=True)\n",
            "tensor(0.0085, requires_grad=True)\n",
            "tensor(0.0107, requires_grad=True)\n",
            "tensor(0.0049, requires_grad=True)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gooL3NFMJvoB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "a3e4b3db-f4ba-4d58-a334-6fc70efc8300"
      },
      "source": [
        "#Inspect the trained weights\n",
        "model.weight"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Parameter containing:\n",
              "tensor([[0.9430, 0.0467]], requires_grad=True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RnjHn7FOUWL5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}