final_TFF.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dpGtWBWkDSFC"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2heEYHCmQdVq"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9BJSLeoHUd-y"
   },
   "source": [
    "# Install Dependency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "i6Dkf9BZQdeE"
   },
   "outputs": [],
   "source": [
    "!pip install --quiet --upgrade tensorflow_federated\n",
    "!pip install --quiet --upgrade nest_asyncio\n",
    "\n",
    "import nest_asyncio\n",
    "nest_asyncio.apply()\n",
    "\n",
    "%load_ext tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "4PjlDuZoVdo8",
    "outputId": "c9f412cd-109d-4062-c593-6edf185b0eb3",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'Hello, World!'"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import collections\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import tensorflow_federated as tff\n",
    "\n",
    "np.random.seed(0)\n",
    "\n",
    "tff.federated_computation(lambda: 'Hello, World!')()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "q3i2yhVRtdsP",
    "outputId": "64d8e7fa-8098-41f6-a94d-18956e98331e",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import config\n",
    "\n",
    "gpus = config.list_physical_devices('GPU')\n",
    "print(gpus)\n",
    "if gpus:\n",
    "  try:\n",
    "    for gpu in gpus:\n",
    "        config.experimental.set_memory_growth(gpu, True)\n",
    "  except RuntimeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y1weSRaqGACa"
   },
   "source": [
    "# Connect to Google drive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "_O26z4d-DcZ7",
    "outputId": "f2bce385-069f-4842-a4f4-bba9f2d6a7e2",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/gdrive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "QTdNvQTjGMOq"
   },
   "outputs": [],
   "source": [
    "PATH_TO_DATA = \"/content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA\"\n",
    "PRAPROCESSING_DATA = \"{}/Preprocessed\".format(PATH_TO_DATA)\n",
    "RAW_DATA = \"{}/Raw Data\".format(PATH_TO_DATA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CMYw3L7NFPFS"
   },
   "source": [
    "# Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "FmkOGQXADccz",
    "outputId": "059ce775-f8d1-41f3-dac0-7fe13b482cdd",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 9943/144538 [00:00<00:02, 51519.60it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject1.csv with total line  144538\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 144538/144538 [00:02<00:00, 48351.33it/s]\n",
      "  3%|▎         | 3924/113461 [00:00<00:02, 38581.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject2.csv with total line  113461\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 113461/113461 [00:03<00:00, 30376.55it/s]\n",
      "  4%|▍         | 4632/105164 [00:00<00:02, 46316.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject3.csv with total line  105164\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 105164/105164 [00:02<00:00, 48037.31it/s]\n",
      "  5%|▍         | 4936/99840 [00:00<00:01, 49357.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject4.csv with total line  99840\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 99840/99840 [00:02<00:00, 47259.35it/s]\n",
      "  4%|▍         | 4514/104293 [00:00<00:02, 45135.52it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject5.csv with total line  104293\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 104293/104293 [00:02<00:00, 48817.16it/s]\n",
      "  6%|▌         | 5016/84531 [00:00<00:01, 50154.55it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject6.csv with total line  84531\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 84531/84531 [00:01<00:00, 48164.07it/s]\n",
      "  6%|▌         | 5200/88627 [00:00<00:01, 51991.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject7.csv with total line  88627\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 88627/88627 [00:01<00:00, 47333.69it/s]\n",
      "  4%|▍         | 4728/114124 [00:00<00:02, 47279.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject8.csv with total line  114124\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 114124/114124 [00:02<00:00, 47522.75it/s]\n",
      "  4%|▍         | 4619/119246 [00:00<00:02, 46185.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject9.csv with total line  119246\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 119246/119246 [00:02<00:00, 46370.81it/s]\n",
      "  6%|▌         | 4606/83046 [00:00<00:01, 46054.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Load data from  /content/gdrive/My Drive/Colab Notebooks/data/TFF-DATA/Preprocessed/mHealth_subject10.csv with total line  83046\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 83046/83046 [00:01<00:00, 47904.63it/s]\n"
     ]
    }
   ],
   "source": [
    "from __future__ import absolute_import, division, print_function\n",
    "\n",
    "import os\n",
    "import glob\n",
    "import tqdm\n",
    "import numpy as np\n",
    "\n",
    "def getUserKey():\n",
    "  data = []\n",
    "  for filename in glob.glob(os.path.join(FILE_USED, '*.csv')):\n",
    "    file = filename.split(\"/\")[-1]\n",
    "    data.append(file)\n",
    "  return data\n",
    "\n",
    "def convertToNumpy(data):\n",
    "  x = np.array(data)\n",
    "  x = x.astype(np.float)\n",
    "  return x\n",
    "\n",
    "def mapValueToData(lines):\n",
    "  for i in tqdm.tqdm(range(len(lines))):\n",
    "      item = lines[i]\n",
    "      data = item.split(\",\")\n",
    "      x = convertToNumpy(data[:-1])\n",
    "      y = int(data[-1])\n",
    "      yield x, y\n",
    "\n",
    "def readFileToArray(filename):\n",
    "  x_data = []\n",
    "  y_data = []\n",
    "  with open(filename, \"r\") as fi:\n",
    "    lines = fi.readlines()\n",
    "    print()\n",
    "    print(\"Load data from \", filename, \"with total line \", len(lines))\n",
    "    for x, y in mapValueToData(lines):\n",
    "      x_data.append(x)\n",
    "      y_data.append(y)\n",
    "  return x_data, y_data\n",
    "\n",
    "FILE_USED = PRAPROCESSING_DATA\n",
    "X = {}\n",
    "Y = {}\n",
    "for filename in glob.glob(os.path.join(FILE_USED, '*.csv')):\n",
    "  file = filename.split(\"/\")[-1]\n",
    "  x_train, y_train = readFileToArray(filename)\n",
    "  X[file] = x_train\n",
    "  Y[file] = y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "thbPE4D7GkHh",
    "outputId": "c76c3d26-d88f-47fc-9661-2b0c8b3421bc",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([-9.8184e+00,  9.9710e-03,  2.9563e-01,  4.1863e-03,  4.1863e-03,\n",
      "        6.3077e-01,  1.0390e-01, -8.4053e-01, -6.8762e-01, -3.7000e-01,\n",
      "       -3.6327e-01,  2.9963e-01, -8.6499e+00, -4.5781e+00,  1.8776e-01,\n",
      "       -4.4902e-01, -1.0103e+00,  3.4483e-02, -2.3500e+00, -1.6102e+00,\n",
      "       -3.0899e-02]), array([-9.8489e+00,  5.2404e-01,  3.7348e-01,  4.1863e-03,  1.6745e-02,\n",
      "        6.8389e-01,  8.5343e-02, -8.3865e-01, -6.8369e-01, -1.9799e-01,\n",
      "       -1.8151e-01,  5.8298e-01, -8.6275e+00, -4.3198e+00,  2.3595e-02,\n",
      "       -4.4902e-01, -1.0103e+00,  3.4483e-02, -2.1632e+00, -8.8254e-01,\n",
      "        3.2657e-01])]\n",
      " Total data from user 'mHealth_subject1.csv' is [144538]\n"
     ]
    }
   ],
   "source": [
    "userkey = getUserKey()\n",
    "user = 0 # first user\n",
    "print(X[userkey[user]][:2])\n",
    "print(\" Total data from user '{}' is [{}]\".format(userkey[user], len(X[userkey[user]])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "03lybpldDcfX"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "UeidxafAH6Fw"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-QESMw7EH6Ua"
   },
   "source": [
    "# Split Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "4x9c023GICPQ",
    "outputId": "a7db65d6-73d9-4eb9-8c48-53d45129ee3f",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'mHealth_subject10.csv' 115630 28908\n",
      "'mHealth_subject10.csv' 90768 22693\n",
      "'mHealth_subject10.csv' 84131 21033\n",
      "'mHealth_subject10.csv' 79872 19968\n",
      "'mHealth_subject10.csv' 83434 20859\n",
      "'mHealth_subject10.csv' 67624 16907\n",
      "'mHealth_subject10.csv' 70901 17726\n",
      "'mHealth_subject10.csv' 91299 22825\n",
      "'mHealth_subject10.csv' 95396 23850\n",
      "'mHealth_subject10.csv' 66436 16610\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "X_TRAIN = {}\n",
    "Y_TRAIN = {}\n",
    "X_TEST = {}\n",
    "Y_TEST = {}\n",
    "\n",
    "test_size = 0.2\n",
    "\n",
    "userkey = getUserKey()\n",
    "for user in userkey:\n",
    "  x_user = X[user]\n",
    "  y_user = Y[user]\n",
    "  x_train_user, x_test_user, y_train_user, y_test_user = train_test_split(x_user, y_user, test_size=test_size, random_state=2019)\n",
    "  X_TRAIN[user] = x_train_user\n",
    "  Y_TRAIN[user] = y_train_user\n",
    "  X_TEST[user] = x_test_user\n",
    "  Y_TEST[user] = y_test_user\n",
    "  # print(user, len(y_user), y_user[0], x_user[0], len(x_train_user), len(x_test_user))\n",
    "  print(\"'{}' {} {}\".format(file, len(x_train_user), len(x_test_user)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "QfzLkAFxJEr_",
    "outputId": "db7e0b65-6216-42c3-e27d-70d278c53daf",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total data -> x_train_all:845491 y_train_all:845491 x_test_all:211379 y_test_all:211379\n"
     ]
    }
   ],
   "source": [
    "\n",
    "userkey = getUserKey()\n",
    "x_train_all = X_TRAIN[userkey[0]]\n",
    "y_train_all = Y_TRAIN[userkey[0]]\n",
    "x_test_all = X_TEST[userkey[0]]\n",
    "y_test_all = Y_TEST[userkey[0]]\n",
    "for user in userkey[1:]:\n",
    "  x_train_all = np.concatenate((x_train_all, X_TRAIN[user]))\n",
    "  y_train_all = np.concatenate((y_train_all, Y_TRAIN[user]))\n",
    "  x_test_all = np.concatenate((x_test_all, X_TEST[user]))\n",
    "  y_test_all = np.concatenate((y_test_all, Y_TEST[user]))\n",
    "print(\"Total data -> x_train_all:{} y_train_all:{} x_test_all:{} y_test_all:{}\".format(len(x_train_all), len(y_train_all), len(x_test_all), len(y_test_all)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "2_td3WzQLCvj"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "1jakrpFENzSi"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "Y5w64eWJNzfu"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6IkHA-T6NznE"
   },
   "source": [
    "# Mapping to Training Format, TFF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "P9D_toqCN54i"
   },
   "outputs": [],
   "source": [
    "import collections\n",
    "from tensorflow_federated import python as tff\n",
    "\n",
    "userkey = getUserKey()\n",
    "client_train_dataset = collections.OrderedDict()\n",
    "for user in userkey:\n",
    "  data = collections.OrderedDict((('label', Y_TRAIN[user]), ('sensor_data', X_TRAIN[user])))\n",
    "  client_train_dataset[user] = data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "8944cZ8e3YSy"
   },
   "outputs": [],
   "source": [
    "userkey = getUserKey()\n",
    "client_test_dataset = collections.OrderedDict()\n",
    "for user in userkey:\n",
    "  data = collections.OrderedDict((('label', Y_TEST[user]), ('sensor_data', X_TEST[user])))\n",
    "  client_test_dataset[user] = data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "wiFDeJPXOjh6",
    "outputId": "c3a93728-1463-4721-bd6c-0b22d708bba1",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow_federated.python.simulation.from_tensor_slices_client_data.FromTensorSlicesClientData at 0x7f5cefeab5f8>"
      ]
     },
     "execution_count": 12,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset = tff.simulation.FromTensorSlicesClientData(client_train_dataset)\n",
    "train_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "GtqwFs5t3hcb",
    "outputId": "563de050-4777-40a6-b8ce-c93611d5078d",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow_federated.python.simulation.from_tensor_slices_client_data.FromTensorSlicesClientData at 0x7f5cf057a908>"
      ]
     },
     "execution_count": 13,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_dataset = tff.simulation.FromTensorSlicesClientData(client_test_dataset)\n",
    "test_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "c7MufaOLQVFr",
    "outputId": "3802a14a-f31e-4b06-8d25-3d6160c24f6c",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 14,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_dataset.client_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "v1eLArsUQqXv",
    "outputId": "c3f26c51-d8be-4a5a-a7f2-867cb74ea842",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['mHealth_subject1.csv',\n",
       " 'mHealth_subject2.csv',\n",
       " 'mHealth_subject3.csv',\n",
       " 'mHealth_subject4.csv',\n",
       " 'mHealth_subject5.csv',\n",
       " 'mHealth_subject6.csv',\n",
       " 'mHealth_subject7.csv',\n",
       " 'mHealth_subject8.csv',\n",
       " 'mHealth_subject9.csv',\n",
       " 'mHealth_subject10.csv']"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset.client_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "n7u7EA9AQ3bD",
    "outputId": "142963f3-97ff-469c-ecdf-f095a278d4eb",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('label', TensorSpec(shape=(), dtype=tf.int32, name=None)),\n",
       "             ('sensor_data',\n",
       "              TensorSpec(shape=(21,), dtype=tf.float64, name=None))])"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset.element_type_structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "lLrHg56VQ7PR",
    "outputId": "fd6de0f8-3c39-4424-b619-c0e54d03f8b3",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 17,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_dataset = train_dataset.create_tf_dataset_for_client(\n",
    "    train_dataset.client_ids[0])\n",
    "\n",
    "example_element = next(iter(example_dataset))\n",
    "\n",
    "example_element['label'].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "aDAJRGjnRYUP",
    "outputId": "c1ce4f9c-c2b6-42a7-8403-0f2add2821d8",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-12.206  ,   1.6892 ,  -5.3638 ,  -0.13815,  -0.31397,  -7.1242 ,\n",
       "        -0.41558,  -0.90807,  -0.37721,  67.614  , -46.364  ,  -3.486  ,\n",
       "        -4.0507 , -15.319  ,   3.1299 ,  -0.77647,  -0.61191,   0.49784,\n",
       "        -7.8533 , -13.335  , -34.681  ])"
      ]
     },
     "execution_count": 18,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_element['sensor_data'].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "Al712tleRjoj"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "SZ-KGuIWRt5m"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xgw807GXRuGj"
   },
   "source": [
    "# Exploring Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "zuoU2iGTRv9a",
    "outputId": "deb1ac18-33c3-488b-d642-f9a503660948",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 478.0
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 6 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# from matplotlib import pyplot as plt\n",
    "\n",
    "# # Number of examples per layer for a sample of clients\n",
    "# f = plt.figure(figsize=(12, 7))\n",
    "# f.suptitle('Label Counts for a Sample of Clients')\n",
    "# for i in range(6):\n",
    "#   client_dataset = train_dataset.create_tf_dataset_for_client(\n",
    "#       train_dataset.client_ids[i])\n",
    "#   plot_data = collections.defaultdict(list)\n",
    "#   for example in client_dataset:\n",
    "#     # Append counts individually per label to make plots\n",
    "#     # more colorful instead of one color per plot.\n",
    "#     label = example['label'].numpy()\n",
    "#     plot_data[label].append(label)\n",
    "#   plt.subplot(2, 3, i+1)\n",
    "#   plt.title('Client {}'.format(i))\n",
    "#   for j in range(10):\n",
    "#     plt.hist(\n",
    "#         plot_data[j],\n",
    "#         density=False,\n",
    "#         bins=[0, 1, 2, 3, 4, 5, 6, 7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "GuqSelXlR8LP"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "LZI3dB7dStJG"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "vMwJye0CStMW"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sUlUWfXwStTM"
   },
   "source": [
    "# Prepocessing Input Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "NfsvkuljSx1O"
   },
   "outputs": [],
   "source": [
    "NUM_CLIENTS = 8\n",
    "NUM_EPOCHS = 5\n",
    "BATCH_SIZE = 20\n",
    "SHUFFLE_BUFFER = 100\n",
    "PREFETCH_BUFFER = 10\n",
    "\n",
    "def preprocess(dataset):\n",
    "\n",
    "  def batch_format_fn(element):\n",
    "    \"\"\"Flatten a batch `sensor_data` and return the features as an `OrderedDict`.\"\"\"\n",
    "    return collections.OrderedDict(\n",
    "        x=tf.reshape(element['sensor_data'], [-1, 21]),\n",
    "        y=tf.reshape(element['label'], [-1, 1]))\n",
    "\n",
    "  return dataset.repeat(NUM_EPOCHS).shuffle(SHUFFLE_BUFFER).batch(\n",
    "      BATCH_SIZE).map(batch_format_fn).prefetch(PREFETCH_BUFFER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "xM4FoPVbTEMR",
    "outputId": "22d4e0bf-d90a-4507-e1c8-2c7241afb88f",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('x',\n",
       "              array([[-1.5568e+01, -3.7494e-01,  1.7241e+00, -3.5583e-01, -8.7912e-02,\n",
       "                       5.3496e+00, -5.2876e-01, -7.0919e-01, -6.2083e-01, -6.5222e+01,\n",
       "                      -9.6229e+01,  4.4114e+01, -6.4065e+00, -1.1639e+01,  2.0951e+00,\n",
       "                       2.9020e-01, -9.3224e-01, -5.4095e-01,  6.1043e+00, -3.5893e+01,\n",
       "                      -6.2335e+01],\n",
       "                     [-6.3561e+00,  1.6410e+00, -6.8207e+00,  2.5118e-01,  6.2794e-02,\n",
       "                       6.1740e-01, -3.7291e-01, -5.8912e-01,  6.0904e-01,  1.9805e-01,\n",
       "                       3.6499e-01, -5.8481e-01, -7.0132e+00, -1.2517e-01,  6.4833e+00,\n",
       "                      -1.5333e+00,  1.1992e+00,  5.0000e-01,  3.6266e-01,  3.5939e-01,\n",
       "                       3.6593e-03],\n",
       "                     [-8.8891e+00,  1.0543e-02, -2.8727e+00, -5.8608e-02, -1.3815e-01,\n",
       "                       2.1152e-01, -1.3173e-01, -6.7730e-01,  6.7976e-01, -4.5573e+00,\n",
       "                       4.4492e+00,  1.4897e+00, -7.1359e+00, -5.0878e+00,  2.2248e+00,\n",
       "                      -1.0863e+00,  3.0801e-02,  7.3922e-01,  5.5942e-01, -5.1778e+01,\n",
       "                      -2.2937e+01],\n",
       "                     [-8.7445e+00,  1.3651e+00, -2.8350e+00,  6.4050e-01,  6.2794e-01,\n",
       "                      -5.6395e-01, -2.0779e-01, -7.1107e-01,  4.9116e-01,  3.7000e-01,\n",
       "                       3.6327e-01, -2.9963e-01, -4.9652e+00, -2.2109e+00,  7.9103e+00,\n",
       "                      -1.4020e+00,  7.3511e-01,  8.0172e-01,  1.7585e-01, -3.6827e-01,\n",
       "                      -3.5381e-01],\n",
       "                     [-6.4923e+00, -1.6483e+00, -7.3168e+00,  1.0675e+00,  8.4982e-01,\n",
       "                      -2.3669e+00, -2.3006e-01, -6.5854e-01, -8.7230e-01,  2.6857e+00,\n",
       "                      -3.9383e-01, -1.1305e+01, -9.6676e+00, -5.3164e+00, -3.6408e+00,\n",
       "                      -1.3725e-01, -1.0842e+00, -1.8534e-01, -9.6539e+00, -3.1817e+01,\n",
       "                       3.9114e+01],\n",
       "                     [-9.3292e+00,  2.9659e-01,  1.4162e+00, -2.0931e-02,  7.9540e-02,\n",
       "                       1.0143e+00,  2.1336e-01, -6.6229e-01,  6.8762e-01, -1.0146e+00,\n",
       "                      -9.0728e-01, -2.2794e+00, -3.4765e+00, -8.7520e+00,  8.0198e-01,\n",
       "                      -7.8627e-01, -5.3799e-01,  5.8190e-01, -1.4619e+00, -2.5660e+00,\n",
       "                      -3.9747e+00],\n",
       "                     [-9.5537e+00, -9.2410e-02,  1.7075e+00, -6.5306e-01, -6.2376e-01,\n",
       "                       1.0194e+00, -3.5436e-01, -9.2495e-01, -4.0472e-01,  3.7444e-01,\n",
       "                       7.3020e-01, -4.4769e-01, -5.2583e+00,  3.4911e+00,  8.1121e+00,\n",
       "                      -9.6275e-01,  2.7926e-01,  4.6336e-01,  2.1486e+00, -5.7892e-01,\n",
       "                      -1.9446e+01],\n",
       "                     [-9.9271e+00,  3.9763e-01,  8.1473e-01,  7.1167e-02,  1.0047e-01,\n",
       "                       5.4505e-01, -2.1707e-01, -8.8368e-01, -5.0688e-01,  5.5933e-01,\n",
       "                       5.4487e-01, -5.9384e-01, -3.2589e+00, -8.8741e+00,  1.5875e+00,\n",
       "                      -7.8431e-02, -9.3018e-01, -3.4483e-01,  1.8126e-01,  1.7247e-01,\n",
       "                      -7.2012e-01],\n",
       "                     [-7.7246e+00, -1.3384e-01, -4.0152e-01, -8.3726e-02,  1.6745e-02,\n",
       "                      -6.0304e+00, -1.6698e-02, -1.0225e+00,  3.7328e-02,  4.5972e+01,\n",
       "                       2.5595e+01,  7.9155e+00, -2.6782e+00, -8.5255e+00,  1.4487e+00,\n",
       "                      -8.0392e-01, -5.2977e-01,  5.2155e-01,  1.4000e+01,  1.7614e+01,\n",
       "                      -3.1452e+00],\n",
       "                     [-9.6989e+00,  6.0301e-01,  1.7174e+00, -4.1026e-01,  5.0235e-02,\n",
       "                       9.9327e-01, -3.5807e-01, -7.5610e-01,  3.9489e-01,  3.7017e-01,\n",
       "                       9.1373e-01, -3.0514e-01, -7.4366e+00, -1.0509e+01,  4.0579e+00,\n",
       "                      -8.5686e-01, -5.9754e-01,  1.8750e-01, -1.3746e+01,  9.7621e+01,\n",
       "                      -7.0204e+01],\n",
       "                     [-1.3096e+01, -1.7662e+00,  1.9042e+00,  5.4422e-02,  2.9304e-02,\n",
       "                       2.8782e+00,  5.7328e-01, -7.8987e-01, -1.6110e-01,  6.0570e+01,\n",
       "                       5.2422e+01, -2.7421e+01, -5.2751e+00, -7.0581e+00,  3.1888e+00,\n",
       "                      -5.0588e-01, -6.6119e-01,  7.6078e-01,  3.0683e+00, -1.6326e+01,\n",
       "                       5.8347e+01],\n",
       "                     [-9.1353e+00,  1.9813e-01,  2.3652e+00, -1.6745e-02, -7.5353e-02,\n",
       "                       8.7749e-01,  5.0649e-01, -8.4053e-01, -5.4420e-01,  3.8305e-01,\n",
       "                       5.4663e-01, -7.3463e-01, -5.1553e+00, -7.3139e+00,  3.6135e+00,\n",
       "                       1.7255e-01, -7.1869e-01,  3.9440e-01,  1.8129e-01,  1.7608e-01,\n",
       "                      -3.5915e-01],\n",
       "                     [-9.1168e+00,  1.2952e+00, -2.2729e+00,  5.5259e-01,  4.7724e-01,\n",
       "                      -3.0023e-01, -2.2635e-01, -7.1482e-01,  5.1081e-01,  1.9372e-01,\n",
       "                       3.6504e-01, -4.4043e-01, -5.1150e+00, -1.8721e+00,  7.7918e+00,\n",
       "                      -1.4000e+00,  7.7618e-01,  7.7802e-01, -5.3495e-01,  3.6457e-01,\n",
       "                      -3.7536e-01],\n",
       "                     [-1.5426e+01, -1.4486e+00, -6.9304e+00,  1.8001e-01,  3.7677e-02,\n",
       "                      -4.3850e+00,  4.2486e-01, -7.6360e-01, -6.0707e-01, -1.0795e+01,\n",
       "                      -7.7323e+01,  7.7035e+01, -5.6170e+00, -1.0778e+01, -1.8410e+00,\n",
       "                      -4.6863e-01, -7.0226e-01,  7.8233e-01,  1.3284e+01,  5.3754e+01,\n",
       "                      -3.7817e+01],\n",
       "                     [-9.8390e+00, -1.9903e+00, -3.7370e+00, -2.9304e-02, -1.8838e-01,\n",
       "                       2.6358e+00,  8.9796e-01, -1.5009e-01, -8.6444e-02, -8.2491e+01,\n",
       "                       3.3669e+01,  1.4437e-02, -1.0958e+00,  1.0128e+01,  4.8189e+00,\n",
       "                       3.7647e-01,  1.6016e-01,  6.0345e-01, -2.6587e+01,  7.0251e+01,\n",
       "                       1.7458e+02],\n",
       "                     [-9.8067e+00, -6.8860e-02,  1.0959e-01,  1.2559e-01,  1.5071e-01,\n",
       "                       6.9500e-01, -2.6160e-01, -8.8555e-01, -4.7151e-01,  1.3325e-02,\n",
       "                       1.1008e+00, -4.4417e-01, -3.0271e+00, -9.1671e+00,  1.2916e+00,\n",
       "                       4.5098e-02, -9.9795e-01, -4.3534e-01,  7.5762e-01,  3.9488e+00,\n",
       "                      -3.6344e+00],\n",
       "                     [-9.9162e+00,  3.3841e+00, -1.8638e+00,  0.0000e+00,  2.5118e-02,\n",
       "                      -5.8953e+00,  1.0390e-01, -8.4240e-01, -5.4813e-01, -7.9764e+00,\n",
       "                       9.1456e+01,  4.3257e+01,  2.1181e+00, -1.3175e+01,  4.5581e-01,\n",
       "                      -6.0980e-01, -7.1253e-01,  4.3534e-01,  5.5587e+00, -1.8631e+01,\n",
       "                       2.9900e+01],\n",
       "                     [-9.1107e+00,  4.8432e-01,  3.3062e-02,  1.5071e-01,  3.6421e-01,\n",
       "                      -7.1563e+00,  4.0816e-01, -6.3790e-01, -7.7210e-01,  6.9235e+01,\n",
       "                       2.1326e+01, -1.4777e+02, -3.1127e+00, -8.6536e+00,  1.6402e+00,\n",
       "                      -9.2157e-02, -8.3162e-01,  9.2241e-01, -3.5206e+00,  2.4955e+01,\n",
       "                       4.1918e+01],\n",
       "                     [-6.0726e+00,  5.9755e-01, -8.2515e+00, -1.2140e-01, -1.5489e-01,\n",
       "                       2.7942e+00, -4.8423e-01, -6.5854e-01,  5.9528e-01, -1.5781e-01,\n",
       "                      -6.2370e+00,  5.2603e+00, -3.5426e+00, -5.9127e+00,  5.7252e+00,\n",
       "                      -6.8235e-01,  9.4456e-02,  1.0668e+00, -2.7804e+00,  9.2117e+00,\n",
       "                       2.9094e+01],\n",
       "                     [-9.1367e+00,  2.2873e+00,  5.2164e-01,  3.7677e-02,  3.7677e-02,\n",
       "                      -5.6442e+00,  4.1744e-01, -6.8668e-01, -3.3988e-01,  8.2926e-01,\n",
       "                      -5.5875e-01,  2.4421e+00, -4.2629e+00, -3.5007e+00,  7.9291e+00,\n",
       "                       2.4706e-01, -4.5585e-01,  1.1853e+00, -7.5823e+00, -4.1861e+00,\n",
       "                      -8.7740e+00]])),\n",
       "             ('y', array([[0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [1],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0],\n",
       "                     [0]], dtype=int32))])"
      ]
     },
     "execution_count": 21,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "preprocessed_example_dataset = preprocess(example_dataset)\n",
    "\n",
    "sample_batch = tf.nest.map_structure(lambda x: x.numpy(),\n",
    "                                     next(iter(preprocessed_example_dataset)))\n",
    "\n",
    "sample_batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "nkIoOGTYTKal"
   },
   "outputs": [],
   "source": [
    "def make_federated_data(client_data, client_ids):\n",
    "  return [\n",
    "      preprocess(client_data.create_tf_dataset_for_client(x))\n",
    "      for x in client_ids\n",
    "  ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "iZQvp2VHTf8d",
    "outputId": "fcc3474d-57e2-47b4-ae8f-36488c245805",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of client datasets: 8\n",
      "First dataset: <PrefetchDataset shapes: OrderedDict([(x, (None, 21)), (y, (None, 1))]), types: OrderedDict([(x, tf.float64), (y, tf.int32)])>\n"
     ]
    }
   ],
   "source": [
    "sample_clients = train_dataset.client_ids[0:NUM_CLIENTS]\n",
    "\n",
    "federated_train_data = make_federated_data(train_dataset, sample_clients)\n",
    "\n",
    "print('Number of client datasets: {l}'.format(l=len(federated_train_data)))\n",
    "print('First dataset: {d}'.format(d=federated_train_data[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "A762SwScTjHa"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "0usULtjwTyLW",
    "outputId": "dbe6cb7e-7e03-403b-bbe3-f0def219dc15",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of client datasets: 8\n",
      "First dataset: <PrefetchDataset shapes: OrderedDict([(x, (None, 21)), (y, (None, 1))]), types: OrderedDict([(x, tf.float64), (y, tf.int32)])>\n"
     ]
    }
   ],
   "source": [
    "sample_clients = train_dataset.client_ids[0:NUM_CLIENTS]\n",
    "\n",
    "federated_test_data = make_federated_data(train_dataset, sample_clients)\n",
    "\n",
    "print('Number of client datasets: {l}'.format(l=len(federated_train_data)))\n",
    "print('First dataset: {d}'.format(d=federated_train_data[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "L54FYPx5TyVb"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5Ah6BBRMTyfJ"
   },
   "source": [
    "# Create Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "p_kz-JRFT0fa"
   },
   "outputs": [],
   "source": [
    "def create_keras_model():\n",
    "  return tf.keras.models.Sequential([\n",
    "      tf.keras.layers.Input(shape=(21,)),\n",
    "      tf.keras.layers.Dense(10, kernel_initializer='zeros'),\n",
    "      tf.keras.layers.Softmax(),\n",
    "  ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "XOOMP0TlT3pi"
   },
   "outputs": [],
   "source": [
    "def model_fn():\n",
    "  # We _must_ create a new model here, and _not_ capture it from an external\n",
    "  # scope. TFF will call this within different graph contexts.\n",
    "  keras_model = create_keras_model()\n",
    "  return tff.learning.from_keras_model(\n",
    "      keras_model,\n",
    "      input_spec=preprocessed_example_dataset.element_spec,\n",
    "      loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n",
    "      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "X1WN-SauT4OV"
   },
   "outputs": [],
   "source": [
    "iterative_process = tff.learning.build_federated_averaging_process(\n",
    "    model_fn,\n",
    "    client_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=0.02),\n",
    "    server_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=1.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "6k-9YDruT6SA",
    "outputId": "64112661-d22b-48f8-b2a4-1fa74dde3488",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35.0
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'( -> <model=<trainable=<float32[21,10],float32[10]>,non_trainable=<>>,optimizer_state=<int64>,delta_aggregate_state=<value_sum_process=<>,weight_sum_process=<>>,model_broadcast_state=<>>@SERVER)'"
      ]
     },
     "execution_count": 28,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(iterative_process.initialize.type_signature)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "mvfa-7_nUAmO"
   },
   "outputs": [],
   "source": [
    "state = iterative_process.initialize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "ltHtPls1UDkW"
   },
   "outputs": [],
   "source": [
    "# state, metrics = iterative_process.next(state, federated_train_data)\n",
    "# print('round  1, metrics={}'.format(metrics))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "6_qqyp63WPv-"
   },
   "outputs": [],
   "source": [
    "# NUM_ROUNDS = 50\n",
    "# for round_num in range(2, NUM_ROUNDS):\n",
    "#   state, metrics = iterative_process.next(state, federated_train_data)\n",
    "#   print('round {:2d}, metrics={}'.format(round_num, metrics))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "C6uYf4y6WbQY"
   },
   "outputs": [],
   "source": [
    "# NUM_ROUNDS = 100\n",
    "# for round_num in range(50, NUM_ROUNDS):\n",
    "#   state, metrics = iterative_process.next(state, federated_train_data)\n",
    "#   print('round {:2d}, metrics={}'.format(round_num, metrics))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "4XL9XPoBk7Yu"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "qNriJNoel2gf",
    "outputId": "5b527f13-f65d-41c6-c8e9-8a815716c6f0",
    "colab": {
     "base_uri": "https://localhost:8080/"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round  1, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.76195705), ('loss', 2.4642746)]))])\n",
      "Eval loss : 2.6734390258789062 and Eval accuracy : 0.7615887522697449\n",
      "round  2, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7697308), ('loss', 2.338925)]))])\n",
      "Eval loss : 2.492234468460083 and Eval accuracy : 0.7871789932250977\n",
      "round  3, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7731957), ('loss', 2.284483)]))])\n",
      "Eval loss : 2.3966786861419678 and Eval accuracy : 0.7837328314781189\n",
      "round  4, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.77565044), ('loss', 2.2517004)]))])\n",
      "Eval loss : 2.2869629859924316 and Eval accuracy : 0.800194263458252\n",
      "round  5, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.77737087), ('loss', 2.2284474)]))])\n",
      "Eval loss : 2.370581865310669 and Eval accuracy : 0.7924213409423828\n",
      "round  6, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7790281), ('loss', 2.211661)]))])\n",
      "Eval loss : 2.3221654891967773 and Eval accuracy : 0.7967481017112732\n",
      "round  7, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7799851), ('loss', 2.1967876)]))])\n",
      "Eval loss : 2.3471171855926514 and Eval accuracy : 0.792203426361084\n",
      "round  8, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7805833), ('loss', 2.1908028)]))])\n",
      "Eval loss : 2.279813289642334 and Eval accuracy : 0.7987081408500671\n",
      "round  9, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.781367), ('loss', 2.1812477)]))])\n",
      "Eval loss : 2.309821128845215 and Eval accuracy : 0.7960079312324524\n",
      "round 10, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7820352), ('loss', 2.174446)]))])\n",
      "Eval loss : 2.2087936401367188 and Eval accuracy : 0.8089149594306946\n",
      "round 11, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7826133), ('loss', 2.1695266)]))])\n",
      "Eval loss : 2.3247318267822266 and Eval accuracy : 0.7897357940673828\n",
      "round 12, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7831173), ('loss', 2.165228)]))])\n",
      "Eval loss : 2.232426166534424 and Eval accuracy : 0.8013439178466797\n",
      "round 13, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7832557), ('loss', 2.1630604)]))])\n",
      "Eval loss : 2.21218204498291 and Eval accuracy : 0.8042722940444946\n",
      "round 14, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7837577), ('loss', 2.1573706)]))])\n",
      "Eval loss : 2.3020029067993164 and Eval accuracy : 0.801360011100769\n",
      "round 15, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.78405726), ('loss', 2.1547287)]))])\n",
      "Eval loss : 2.1878368854522705 and Eval accuracy : 0.8047081828117371\n",
      "round 16, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.78415996), ('loss', 2.1535625)]))])\n",
      "Eval loss : 2.330658197402954 and Eval accuracy : 0.7971839904785156\n",
      "round 17, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7846368), ('loss', 2.1441493)]))])\n",
      "Eval loss : 2.310044527053833 and Eval accuracy : 0.7944325804710388\n",
      "round 18, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7847418), ('loss', 2.1481102)]))])\n",
      "Eval loss : 2.2446699142456055 and Eval accuracy : 0.8060231804847717\n",
      "round 19, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.7848231), ('loss', 2.1419728)]))])\n",
      "Eval loss : 2.203329563140869 and Eval accuracy : 0.8076350688934326\n",
      "round 20, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('value_sum_process', ()), ('weight_sum_process', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.78494805), ('loss', 2.1443348)]))])\n",
      "Eval loss : 2.2333199977874756 and Eval accuracy : 0.8068569302558899\n"
     ]
    }
   ],
   "source": [
    "tff_train_acc = []\n",
    "tff_val_acc = []\n",
    "tff_train_loss = []\n",
    "tff_val_loss = []\n",
    "\n",
    "NUM_ROUNDS = 20\n",
    "\n",
    "eval_model = None\n",
    "for round_num in range(1, NUM_ROUNDS+1):\n",
    "    state, tff_metrics = iterative_process.next(state, federated_train_data)\n",
    "    \n",
    "    eval_model = model_fn\n",
    "    evaluation = tff.learning.build_federated_evaluation(eval_model)\n",
    "    test_metrics = evaluation(state.model, federated_test_data)\n",
    "\n",
    "    print('round {:2d}, metrics={}'.format(round_num, tff_metrics))\n",
    "    print(f\"Eval loss : {test_metrics['loss']} and Eval accuracy : {test_metrics['sparse_categorical_accuracy']}\")\n",
    "    # print(tff_metrics)\n",
    "    # print(test_metrics)\n",
    "    tff_train_acc.append(float(tff_metrics['train']['sparse_categorical_accuracy']))\n",
    "    tff_val_acc.append(test_metrics['sparse_categorical_accuracy'])\n",
    "    tff_train_loss.append(float(tff_metrics['train']['loss']))\n",
    "    tff_val_loss.append(test_metrics['loss'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "id": "DHyiirZwSQDu"
   },
   "outputs": [],
   "source": [
    "# this_dir = Path.cwd()\n",
    "# model_dir = this_dir / \"saved_models\" / experiment_name / method\n",
    "\n",
    "# eval_model().saved_models(model_dir / (experiment_name + \".h5\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "Rg-l_gNBl2no"
   },
   "outputs": [],
   "source": [
    "metric_collection = {\"sparse_categorical_accuracy\": tff_train_acc,\n",
    "                     \"val_sparse_categorical_accuracy\": tff_val_acc,\n",
    "                     \"loss\": tff_train_loss,\n",
    "                     \"val_loss\": tff_val_loss}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "JNknAPstl2t9",
    "outputId": "808f0e75-2525-4c40-ce9e-ffdfe753192e",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 763.0
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def plot_graph(X, y, format = '-', label=''):\n",
    "    plt.plot(X, y, format, label=label)\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Value\")\n",
    "    plt.grid(True)\n",
    "\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "plot_graph(list(range(1, 21)), tff_train_acc, label='Train Accuracy')\n",
    "plot_graph(list(range(1, 21)), tff_val_acc, label='Validation Accuracy')\n",
    "plt.legend()\n",
    "plt.savefig(\"federated_model_Accuracy.png\")\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plot_graph(list(range(1, 21)), tff_train_loss, label='Train loss')\n",
    "plot_graph(list(range(1, 21)), tff_val_loss, label='Validation loss')\n",
    "plt.legend()\n",
    "plt.savefig(\"federated_model_loss.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "HA0NXY4Il21R"
   },
   "outputs": [],
   "source": [
    "# saving metric values to text file\n",
    "from pathlib import Path\n",
    "\n",
    "experiment_name = \"sensor\"\n",
    "method = \"tff_training\"\n",
    "\n",
    "this_dir = Path.cwd()\n",
    "model_dir = this_dir / \"saved_models\" / experiment_name / method\n",
    "output_dir = this_dir / \"results\" / experiment_name / method\n",
    "\n",
    "if not model_dir.exists():\n",
    "    model_dir.mkdir(parents=True)\n",
    "\n",
    "if not output_dir.exists():\n",
    "    output_dir.mkdir(parents=True)\n",
    "    \n",
    "txt_file_path = output_dir / (experiment_name + \".txt\")\n",
    "with open(txt_file_path.as_posix(), \"w\") as handle:\n",
    "    content = []\n",
    "    for key, val in metric_collection.items():\n",
    "        line_content = key\n",
    "        val = [str(k) for k in val]\n",
    "        line_content = line_content + \" \" + \" \".join(val)\n",
    "        content.append(line_content)\n",
    "    handle.write(\"\\n\".join(content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "6uaYMCg9l28w"
   },
   "outputs": [],
   "source": [
    "# tff_metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TgL0MhMBl3N5"
   },
   "source": [
    "## Refference\n",
    "1. https://www.tensorflow.org/federated/tutorials/federated_learning_for_image_classification\n",
    "1. https://colab.research.google.com/github/tensorflow/federated/blob/master/docs/tutorials/federated_learning_for_image_classification.ipynb#scrollTo=qrJkQuCRJP9C\n",
    "1. https://github.com/CS-savvy/experiment_with_tf_federated/blob/master/train_tff.py\n",
    "1. https://stackoverflow.com/questions/54316779/change-size-of-train-and-test-set-from-mnist-dataset\n",
    "1. https://www.tensorflow.org/federated/api_docs/python/tff/learning/build_federated_averaging_process\n",
    "1. https://stackoverflow.com/questions/58004272/is-there-a-reasonable-way-to-create-tff-clients-datat-sets\n",
    "1. https://stackoverflow.com/questions/54316779/change-size-of-train-and-test-set-from-mnist-dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PMCA3X0rl3h1"
   },
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "final-TFF.ipynb",
   "provenance": [],
   "collapsed_sections": [],
   "toc_visible": true
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "TPU"
 },
 "nbformat": 4,
 "nbformat_minor": 0
}