Federated_Learning(SVM)_With_Various_Gradiant_Decent_Algos.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/aswarth123/Federated_Learning_MNIST/blob/main/Federated_Learning(SVM)_With_Various_Gradiant_Decent_Algos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XFbvzhVst7mi"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import random\n",
        "import copy\n",
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.cluster import KMeans\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.model_selection import StratifiedKFold\n",
        "from sklearn.utils import shuffle\n",
        "import time"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OEoVNkw4XOkc"
      },
      "source": [
        "## SVM class"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U2b8dHySEYuu"
      },
      "outputs": [],
      "source": [
        "class SVM:\n",
        "\n",
        "  def __init__(self, X_train, y_train, X_test, y_test, val=True, val_type='k_fold', k=5, opt='mini_batch_GD', batch_size = 30, n_iters=100, learning_rate=0.001, lambda_param=0.01):\n",
        "\n",
        "    self.lr = learning_rate\n",
        "    self.lambda_param = lambda_param\n",
        "    self.n_iters = n_iters\n",
        "\n",
        "    self.X_train = X_train\n",
        "    self.y_train = y_train\n",
        "\n",
        "    self.X_test = X_test\n",
        "    self.y_test = y_test\n",
        "\n",
        "    self.val = val\n",
        "    self.val_type=val_type\n",
        "    self.k=k\n",
        "\n",
        "    self.opt = opt\n",
        "    self.batch_size = batch_size\n",
        "\n",
        "    self.w = np.array([])\n",
        "    self.b = None\n",
        "\n",
        "  def grad(self,x,y):\n",
        "    if y * (np.dot(x, self.w) - self.b) >= 1:\n",
        "      dw = self.lr * (2 * self.lambda_param * self.w)\n",
        "      db = 0\n",
        "    else:\n",
        "      dw = self.lr * (2 * self.lambda_param * self.w - np.dot(x, y))\n",
        "      db = self.lr * y\n",
        "\n",
        "    return (dw,db)\n",
        "  \n",
        "  def loss(self):\n",
        "    return np.mean([max(0, 1-x*y) for x, y in zip(np.where(np.concatenate(self.y_train,axis=None) <= 0, -1, 1), self.predict())])\n",
        "\n",
        "  def stochastic_GD(self, X_train, y_train, X_val=None, y_val=None):\n",
        "    n_samples, n_features = X_train.shape  \n",
        "    y_ = np.where(y_train <= 0, -1, 1)\n",
        "          \n",
        "    if self.w.size == 0 and self.b is None :\n",
        "      self.w = np.zeros(n_features)\n",
        "      self.b = 0\n",
        "\n",
        "    w_best = np.zeros(n_features)\n",
        "    b_best = 0\n",
        "\n",
        "    acc_list = [] \n",
        "    for i in range(0,self.n_iters):\n",
        "      for idx, x_i in enumerate(X_train):\n",
        "        dw,db = self.grad(x_i,y_[idx])\n",
        "        self.w -= dw\n",
        "        self.b -= db\n",
        "    \n",
        "      if i%10 == 0 and self.val:\n",
        "        approx_w = np.dot(X_val, self.w) - self.b\n",
        "        approx_w = np.sign(approx_w)\n",
        "        res_w = np.where(approx_w<0, 0, approx_w)\n",
        "\n",
        "        approx_w_best = np.dot(X_val, w_best) - b_best\n",
        "        approx_w_best = np.sign(approx_w_best)\n",
        "        res_w_best = np.where(approx_w_best<0, 0, approx_w_best)\n",
        "            \n",
        "        if (accuracy_score(y_val, res_w_best) < accuracy_score(y_val, res_w)):\n",
        "          w_best = copy.deepcopy(self.w)\n",
        "          b_best = copy.deepcopy(self.b)\n",
        "\n",
        "\n",
        "  def batch_GD(self, X_train, y_train, X_val=None, y_val=None):\n",
        "      n_samples, n_features = X_train.shape  \n",
        "      y_ = np.where(y_train <= 0, -1, 1)\n",
        "            \n",
        "      if self.w.size == 0 and self.b is None :\n",
        "        self.w = np.zeros(n_features)\n",
        "        self.b = 0\n",
        "\n",
        "      w_best = np.zeros(n_features)\n",
        "      b_best = 0\n",
        "\n",
        "      acc_list = [] \n",
        "      for i in range(0,self.n_iters):\n",
        "        dw_sum=0\n",
        "        db_sum=0\n",
        "        for idx, x_i in enumerate(X_train):\n",
        "          dw,db = self.grad(x_i,y_[idx])\n",
        "          dw_sum+=dw\n",
        "          db_sum+=db\n",
        "        self.w -= (dw_sum/n_samples)\n",
        "        self.b -= (db_sum/n_samples)\n",
        "      \n",
        "        if i%10 == 0 and self.val:\n",
        "          approx_w = np.dot(X_val, self.w) - self.b\n",
        "          approx_w = np.sign(approx_w)\n",
        "          res_w = np.where(approx_w<0, 0, approx_w)\n",
        "\n",
        "          approx_w_best = np.dot(X_val, w_best) - b_best\n",
        "          approx_w_best = np.sign(approx_w_best)\n",
        "          res_w_best = np.where(approx_w_best<0, 0, approx_w_best)\n",
        "              \n",
        "          if (accuracy_score(y_val, res_w_best) < accuracy_score(y_val, res_w)):\n",
        "            w_best = copy.deepcopy(self.w)\n",
        "            b_best = copy.deepcopy(self.b)\n",
        "\n",
        "\n",
        "  def mini_batch_GD(self, X_train, y_train, X_val=None, y_val=None):\n",
        "      n_samples, n_features = X_train.shape  \n",
        "      y_ = np.where(y_train <= 0, -1, 1)\n",
        "            \n",
        "      if self.w.size == 0 and self.b is None :\n",
        "        self.w = np.zeros(n_features)\n",
        "        self.b = 0\n",
        "\n",
        "      w_best = np.zeros(n_features)\n",
        "      b_best = 0\n",
        "\n",
        "      acc_list = [] \n",
        "\n",
        "      # print(self.n_iters)\n",
        "      \n",
        "      for i in range(0,self.n_iters):\n",
        "        # print(i)\n",
        "        dw_sum=0.0\n",
        "        db_sum=0.0\n",
        "        s=0\n",
        "        for idx, x_i in enumerate(X_train):\n",
        "          dw,db = self.grad(x_i,y_[idx])\n",
        "          dw_sum+=dw\n",
        "          db_sum+=db\n",
        "          s += 1\n",
        "          if s%self.batch_size==0:\n",
        "            self.w -= (dw_sum/self.batch_size)\n",
        "            self.b -= (db_sum/self.batch_size)\n",
        "      \n",
        "        if i%10 == 0 and self.val:\n",
        "          approx_w = np.dot(X_val, self.w) - self.b\n",
        "          approx_w = np.sign(approx_w)\n",
        "          res_w = np.where(approx_w<0, 0, approx_w)\n",
        "\n",
        "          approx_w_best = np.dot(X_val, w_best) - b_best\n",
        "          approx_w_best = np.sign(approx_w_best)\n",
        "          res_w_best = np.where(approx_w_best<0, 0, approx_w_best)\n",
        "              \n",
        "          if (accuracy_score(y_val, res_w_best) < accuracy_score(y_val, res_w)):\n",
        "            w_best = copy.deepcopy(self.w)\n",
        "            b_best = copy.deepcopy(self.b)\n",
        "\n",
        "\n",
        "  def cross_validation(self, val_split):\n",
        "\n",
        "    X_train = np.concatenate((self.X_train[0],self.X_train[1]),axis=0)\n",
        "    y_train = np.concatenate((self.y_train[0],self.y_train[1]),axis=0)\n",
        "\n",
        "    X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=val_split, random_state=1, stratify=y_train)\n",
        "\n",
        "    eval(\"self.\"+self.opt+\"(X_train, y_train, X_val, y_val)\")\n",
        "\n",
        "\n",
        "  def k_fold_cross_validation(self):\n",
        "\n",
        "    X = np.concatenate((self.X_train[0],self.X_train[1]),axis=0)\n",
        "    y = np.concatenate((self.y_train[0],self.y_train[1]),axis=0)\n",
        "\n",
        "    w_list = []\n",
        "    b_list = []\n",
        "    acc_list = []\n",
        "\n",
        "    if self.w.size == 0 and self.b == None:\n",
        "      w = np.zeros(self.X_train[0].shape[1])\n",
        "      b = 0\n",
        "    else:\n",
        "      w = copy.deepcopy(self.w)\n",
        "      b = self.b\n",
        "\n",
        "    skf = StratifiedKFold(n_splits=self.k, shuffle=True)\n",
        "\n",
        "    for train_index, val_index in skf.split(X,y):\n",
        "      \n",
        "      X_train, X_val = X[train_index], X[val_index]\n",
        "      y_train, y_val = y[train_index], y[val_index]\n",
        "\n",
        "      eval(\"self.\"+self.opt+\"(X_train, y_train, X_val, y_val)\")\n",
        "\n",
        "      print(self.accuracy())\n",
        "      w_list.append(self.w)\n",
        "      b_list.append(self.b)\n",
        "\n",
        "      test_w = np.dot(X_val, self.w) - self.b\n",
        "      test_w = np.sign(test_w)\n",
        "      res_val = np.where(test_w<0,0,test_w)\n",
        "\n",
        "      acc_list.append(accuracy_score(y_val, res_val))\n",
        "    \n",
        "      self.w = copy.deepcopy(w)\n",
        "      self.b = b\n",
        "\n",
        "    self.w = copy.deepcopy(w_list[acc_list.index(max(acc_list))])\n",
        "    self.b = b_list[acc_list.index(max(acc_list))]\n",
        "  \n",
        "\n",
        "  def fit(self):\n",
        "    if self.val_type == 'k_fold' and self.val:\n",
        "      self.k_fold_cross_validation()\n",
        "    \n",
        "    elif self.val_type == 'cross_val' and self.val:\n",
        "      self.cross_validation(0.2)\n",
        "    \n",
        "    elif not self.val:\n",
        "      X_train = np.concatenate((self.X_train[0],self.X_train[1]),axis=0)\n",
        "      y_train = np.concatenate((self.y_train[0],self.y_train[1]),axis=0)\n",
        "      X_train, y_train= shuffle(X_train, y_train)\n",
        "      eval(\"self.\"+self.opt+\"(X_train, y_train)\")\n",
        "\n",
        "  def predict(self):\n",
        "     approx = np.dot(self.X_test, self.w) - self.b\n",
        "     approx = np.sign(approx)\n",
        "     return np.where(approx<0, 0, approx)\n",
        "\n",
        "  def accuracy(self):\n",
        "    return accuracy_score(self.y_test, self.predict())*100\n",
        "\n",
        "  # def loss(self):\n",
        "  #   # print(np.concatenate(self.y_train,axis=None))\n",
        "  #   # print(np.vstack(self.x_train).shape)#, np.where(np.sign(np.dot(self.x_train, w) - b))<0, 0, 1).shape)\n",
        "  #   return np.mean([max(0, 1-x*y) for x, y in zip(np.where(np.concatenate(self.y_train,axis=None) <= 0, -1, 1), np.where(np.sign(np.dot(self.X_train, self.w) - self.b)<0, -1, 1 ))])\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IF9H95MnXXGq"
      },
      "source": [
        "## Federated SVM class"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ss0Pq4z-vrBI"
      },
      "outputs": [],
      "source": [
        "class Federated_SVM:\n",
        "\n",
        "  def __init__(self,x_train ,y_train, n_clients=3, val=True, val_type='k_fold', k=5, opt='mini_batch_GD', batch_size = 30, learning_rate=0.001, lambda_param=0.01, n_iters=100):\n",
        "    self.n_clients = n_clients\n",
        "    self.learning_rate = learning_rate\n",
        "    self.lambda_param = lambda_param\n",
        "    self.n_iters = n_iters\n",
        "    self.val = val\n",
        "    self.val_type = val_type\n",
        "    self.client_distribution = []\n",
        "    self.k = k\n",
        "    self.opt = opt\n",
        "    self.batch_size = batch_size\n",
        "    self.X_test = None\n",
        "    self.y_test = None\n",
        "    self.x_train = x_train\n",
        "    self.y_train = y_train\n",
        "    self.Loss = []\n",
        "    self.Loss_clients = [[0],[0],[0]]\n",
        "    self.timefit = []\n",
        "    \n",
        "  def create_clients(self, X_train, y_train, X_test, y_test):\n",
        "    self.clients=[]\n",
        "    for i in range(self.n_clients):\n",
        "      self.client_distribution.append(X_train[i][0].shape[0] + X_train[i][1].shape[0])\n",
        "      self.clients.append(SVM(X_train[i],y_train[i], X_test, y_test, self.val, self.val_type, self.k, self.opt, self.batch_size, self.n_iters, self.learning_rate, self.lambda_param))\n",
        "    self.X_test = copy.deepcopy(X_test)\n",
        "    self.y_test = copy.deepcopy(y_test)\n",
        "  \n",
        "\n",
        "  def average_aggregator(self, parameter_list):\n",
        "    w = np.zeros(parameter_list[0].shape[0])\n",
        "    b = 0\n",
        "    for i in range(0,2*self.n_clients,2):\n",
        "        w = np.add(w,parameter_list[i]*self.client_distribution[i//2]/sum(self.client_distribution))\n",
        "        b = b + parameter_list[i+1]*self.client_distribution[i//2]/sum(self.client_distribution)\n",
        "    return (w, b)\n",
        "\n",
        "  def highest_aggregator(self, parameter_list):\n",
        "    score = 0\n",
        "\n",
        "    for i in range(0,self.n_clients):\n",
        "      acc = self.clients[i].accuracy()\n",
        "      if (acc > score):\n",
        "        w = copy.deepcopy(self.clients[i].w)\n",
        "        b = self.clients[i].b\n",
        "        score = acc\n",
        "\n",
        "    return (w,b)\n",
        "\n",
        "  def random_aggregator(self,parameter_list):\n",
        "    n = random.randint(0,self.n_clients)\n",
        "    w = np.zeros(parameter_list[0].shape[0])\n",
        "    b = 0\n",
        "    for i in range(0,2*self.n_clients,2):\n",
        "      if i//2 != n:\n",
        "        w = np.add(w,parameter_list[i]*self.client_distribution[i//2]/sum(self.client_distribution))\n",
        "        b = b + parameter_list[i+1]*self.client_distribution[i//2]/sum(self.client_distribution)\n",
        "      else:\n",
        "        continue\n",
        "    return (w, b)\n",
        "  \n",
        "  def loss(self,w,b):\n",
        "    # print(np.concatenate(self.y_train,axis=None))\n",
        "    # print(np.vstack(self.x_train).shape)#, np.where(np.sign(np.dot(self.x_train, w) - b))<0, 0, 1).shape)\n",
        "    return np.mean([max(0, 1-x*y) for x, y in zip(np.where(np.concatenate(self.y_train,axis=None) <= 0, -1, 1), np.where(np.sign(np.dot(np.vstack(self.x_train), w) - b)<0, -1, 1 ))])\n",
        "\n",
        "  def fit(self, g_iters, aggregator):\n",
        "    w_best = np.zeros(self.X_test.shape[1])\n",
        "    b_best = 0\n",
        "    for i in range(0,g_iters):\n",
        "      print('global round',i+1)\n",
        "      for j in range(0,self.n_clients):\n",
        "        if i==0:\n",
        "          self.clients[j].fit()\n",
        "        else:\n",
        "          self.clients[j].w = copy.deepcopy(w_agg)\n",
        "          self.clients[j].b = copy.deepcopy(b_agg)\n",
        "          self.clients[j].fit()\n",
        "        self.Loss_clients[j].append(self.clients[j].loss())\n",
        "        print('client',j+1,self.clients[j].accuracy())          \n",
        "      parameter_list = []\n",
        "      for k in range(0,self.n_clients):\n",
        "        parameter_list.append(self.clients[k].w)\n",
        "        parameter_list.append(self.clients[k].b)\n",
        "      w_agg, b_agg = aggregator(parameter_list)\n",
        "      # print(\"agg\",self.accuracy(w_agg,b_agg),\"best\",self.accuracy(w_best,b_best))\n",
        "      if self.accuracy(w_agg,b_agg)>self.accuracy(w_best,b_best) or i==0:\n",
        "        w_best=copy.deepcopy(w_agg)\n",
        "        b_best=copy.deepcopy(b_agg)\n",
        "      self.Loss.append(self.loss(w_best,b_best))\n",
        "      self.timefit.append(time.time())\n",
        "      print('global test acc',self.accuracy(w_agg,b_agg))\n",
        "\n",
        "  def predict(self,w,b):\n",
        "     approx = np.dot(self.X_test, w) - b\n",
        "     approx = np.sign(approx)\n",
        "     return np.where(approx<0, 0, 1)\n",
        "  \n",
        "  def accuracy(self,w,b):\n",
        "    return accuracy_score(self.y_test, self.predict(w,b))*100"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zKRqSYOeXdPx"
      },
      "source": [
        "## Utility functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nzD8VkRKszE_"
      },
      "outputs": [],
      "source": [
        "def create_kmeans_clusters(X, Y, n_clusters = 3, random_state = 0):\n",
        "  clusters = KMeans(n_clusters=n_clusters, random_state=random_state).fit_predict(X)\n",
        "  result = []\n",
        "  for i in range(n_clusters):\n",
        "    result.append(X[clusters == i])\n",
        "    result.append(Y[clusters == i])\n",
        "  return tuple(result)  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6zQ6k0OHKCkr"
      },
      "outputs": [],
      "source": [
        "def load_mnist_return_required_digits(n1, n2):\n",
        "  # Loading the mnist dataset and concatenating train - test sets\n",
        "  (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
        "  x_total = np.concatenate((x_train, x_test), axis=0)\n",
        "  y_total = np.concatenate((y_train, y_test), axis=0)\n",
        "\n",
        "  # Normalizing and reshaping the data\n",
        "  x_total = x_total/255 \n",
        "  x_total = x_total.reshape(x_total.shape[0],784)\n",
        "\n",
        "  x_n1 = x_total[y_total == n1]\n",
        "  y_n1 = y_total[y_total == n1]\n",
        "\n",
        "  x_n2 = x_total[y_total == n2]\n",
        "  y_n2 = y_total[y_total == n2]\n",
        "\n",
        "  return [(x_n1, y_n1),(x_n2, y_n2)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jhhe-PIa_Ery"
      },
      "outputs": [],
      "source": [
        "def get_clients(class1, class2, n_clients = 3):\n",
        "\n",
        "  clients_X = []\n",
        "  clients_y = []\n",
        "\n",
        "  clientsXtest = []\n",
        "  clientsYtest = []\n",
        "\n",
        "  clusters_1 = KMeans(n_clusters=n_clients, random_state=0).fit_predict(class1)\n",
        "  clusters_2 = KMeans(n_clusters=n_clients, random_state=0).fit_predict(class2)\n",
        "\n",
        "  for i in range(n_clients):\n",
        "\n",
        "    X_train0, X_test0, y_train0, y_test0 = train_test_split(class1[clusters_1 == i],np.zeros((class1[clusters_1 == i].shape[0],)),test_size=0.2)\n",
        "    X_train1, X_test1, y_train1, y_test1 = train_test_split(class2[clusters_2 == i],np.ones((class2[clusters_2 == i].shape[0],)),test_size=0.2)\n",
        "\n",
        "    clients_X.append([X_train0, X_train1])\n",
        "    clients_y.append([y_train0, y_train1])\n",
        "\n",
        "    clientsXtest.extend([X_test0,X_test1])\n",
        "    clientsYtest.extend([y_test0,y_test1])\n",
        "\n",
        "  X_test = np.concatenate(clientsXtest,axis=0)\n",
        "  y_test = np.concatenate(clientsYtest,axis=0)\n",
        "\n",
        "  return clients_X,clients_y,X_test,y_test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "csOruCRE_Hxh"
      },
      "outputs": [],
      "source": [
        "def get_total_from_clients(clients_X,clients_y):\n",
        "  x_train0 = [i[0] for i in clients_X]\n",
        "  x_train0 = np.concatenate(x_train0, axis=0)\n",
        "  x_train1 = [i[1] for i in clients_X]\n",
        "  x_train1 = np.concatenate(x_train1, axis=0)\n",
        "  y_train0 = [i[0] for i in clients_y]\n",
        "  y_train0 = np.concatenate(y_train0, axis=0)\n",
        "  y_train1 = [i[1] for i in clients_y]\n",
        "  y_train1 = np.concatenate(y_train1, axis=0)\n",
        "\n",
        "  return ([x_train0,x_train1],[y_train0,y_train1])    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZYTCp6khPHN"
      },
      "source": [
        "# Digits 0 and 6"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SSMoNotAhz8A"
      },
      "source": [
        "### Loading the data of 0 and 6"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tV5qcnb_MM3v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "748d9d3d-6327-4ae9-ae9c-5284a8b8a9c7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 0s 0us/step\n",
            "11501568/11490434 [==============================] - 0s 0us/step\n"
          ]
        }
      ],
      "source": [
        "data = load_mnist_return_required_digits(0, 6)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hsFsh5QIiJRc"
      },
      "source": [
        "### Dividing the data of digits 0 and 6 into clusters using the KMeans algorithm\n",
        "The images of 0 and 6 are divided into 3 three clusters each."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tYP43OPf8zpF",
        "outputId": "63cf7f8c-1438-409f-ea1c-3314fb255b6f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Cluster 3')"
            ]
          },
          "metadata": {},
          "execution_count": 9
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "x_0_c1, y_0_c1, x_0_c2, y_0_c2, x_0_c3, y_0_c3 = create_kmeans_clusters(data[0][0], data[0][1])\n",
        "fig, axs = plt.subplots(1, 3)\n",
        "axs[0].imshow(x_0_c1[0].reshape(28,28),cmap='gray')\n",
        "axs[0].set_title('Cluster 1')\n",
        "axs[1].imshow(x_0_c2[0].reshape(28,28),cmap='gray')\n",
        "axs[1].set_title('Cluster 2')\n",
        "axs[2].imshow(x_0_c3[0].reshape(28,28),cmap='gray')\n",
        "axs[2].set_title('Cluster 3')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n7ZcxVxK8ezZ",
        "outputId": "2a83621f-33a1-4000-8e7d-3d0b7e91d5e3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Cluster 3')"
            ]
          },
          "metadata": {},
          "execution_count": 10
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "x_6_c1, y_6_c1, x_6_c2, y_6_c2, x_6_c3, y_6_c3 = create_kmeans_clusters(data[1][0], data[1][1])\n",
        "fig, axs = plt.subplots(1, 3)\n",
        "axs[0].imshow(x_6_c1[0].reshape(28,28),cmap='gray')\n",
        "axs[0].set_title('Cluster 1')\n",
        "axs[1].imshow(x_6_c2[0].reshape(28,28),cmap='gray')\n",
        "axs[1].set_title('Cluster 2')\n",
        "axs[2].imshow(x_6_c3[0].reshape(28,28),cmap='gray')\n",
        "axs[2].set_title('Cluster 3')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VxJzKmEnj-RY"
      },
      "source": [
        "### Creation of individual train sets for the clients, global train set for the SVM model and a global test set containing the data from all the clusters\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k0pd1_3lBBtT"
      },
      "outputs": [],
      "source": [
        "clients_X,clients_y,X_test,y_test = get_clients(data[0][0], data[1][0], n_clients = 3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y53Sxte4BbWJ"
      },
      "outputs": [],
      "source": [
        "xtrain_gl, ytrain_gl = get_total_from_clients(clients_X,clients_y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mqQTKxHflCp0"
      },
      "source": [
        "### Federated learning model and SVM model training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3rbHU9CGq9Kc"
      },
      "source": [
        "## fed_sgd_batch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QH8r63zXqYsB"
      },
      "outputs": [],
      "source": [
        "class Federated_SVM_sgd_batch:\n",
        "\n",
        "  def __init__(self,x_train, y_train, n_clients=3, val=True, val_type='k_fold', k=5, opt='mini_batch_GD', batch_size = 30, learning_rate=0.001, lambda_param=0.01, n_iters=100):\n",
        "    self.n_clients = n_clients\n",
        "    self.learning_rate = learning_rate\n",
        "    self.lambda_param = lambda_param\n",
        "    self.n_iters = n_iters\n",
        "    self.val = val\n",
        "    self.val_type = val_type\n",
        "    self.client_distribution = []\n",
        "    self.k = k\n",
        "    self.opt = opt\n",
        "    self.batch_size = batch_size\n",
        "    self.X_test = None\n",
        "    self.y_test = None\n",
        "    self.Loss = []\n",
        "    self.x_train = x_train\n",
        "    self.y_train = y_train\n",
        "    self.Loss_clients = [[0],[0],[0]]\n",
        "    self.timefit = []\n",
        "\n",
        "  def create_clients(self, X_train, y_train, X_test, y_test):\n",
        "    self.clients=[]\n",
        "    self.clients2 = []\n",
        "    for i in range(self.n_clients):\n",
        "      self.client_distribution.append(X_train[i][0].shape[0] + X_train[i][1].shape[0])\n",
        "      self.clients.append(SVM(X_train[i],y_train[i], X_test, y_test, self.val, self.val_type, self.k, self.opt, self.batch_size, self.n_iters, self.learning_rate, self.lambda_param))\n",
        "      self.clients2.append(SVM(X_train[i],y_train[i], X_test, y_test, self.val, self.val_type, self.k, \"stochastic_GD\", self.batch_size, self.n_iters, self.learning_rate, self.lambda_param))\n",
        "\n",
        "    self.X_test = copy.deepcopy(X_test)\n",
        "    self.y_test = copy.deepcopy(y_test)\n",
        "  \n",
        "\n",
        "  def average_aggregator(self, parameter_list):\n",
        "    w = np.zeros(parameter_list[0].shape[0])\n",
        "    b = 0\n",
        "    for i in range(0,2*self.n_clients,2):\n",
        "        w = np.add(w,parameter_list[i]*self.client_distribution[i//2]/sum(self.client_distribution))\n",
        "        b = b + parameter_list[i+1]*self.client_distribution[i//2]/sum(self.client_distribution)\n",
        "    return (w, b)\n",
        "\n",
        "  def highest_aggregator(self, parameter_list):\n",
        "    score = 0\n",
        "\n",
        "    for i in range(0,self.n_clients):\n",
        "      acc = self.clients[i].accuracy()\n",
        "      if (acc > score):\n",
        "        w = copy.deepcopy(self.clients[i].w)\n",
        "        b = self.clients[i].b\n",
        "        score = acc\n",
        "\n",
        "    return (w,b)\n",
        "\n",
        "  def random_aggregator(self,parameter_list):\n",
        "    n = random.randint(0,self.n_clients)\n",
        "    w = np.zeros(parameter_list[0].shape[0])\n",
        "    b = 0\n",
        "    for i in range(0,2*self.n_clients,2):\n",
        "      if i//2 != n:\n",
        "        w = np.add(w,parameter_list[i]*self.client_distribution[i//2]/sum(self.client_distribution))\n",
        "        b = b + parameter_list[i+1]*self.client_distribution[i//2]/sum(self.client_distribution)\n",
        "      else:\n",
        "        continue\n",
        "    return (w, b)\n",
        "\n",
        "  def fit(self, g_iters, aggregator):\n",
        "    w_best = np.zeros(self.X_test.shape[1])\n",
        "    b_best = 0\n",
        "    for i in range(0,g_iters):\n",
        "      print('global round',i+1)\n",
        "      for j in range(0,self.n_clients):\n",
        "        if i==0:\n",
        "          self.clients[j].fit()\n",
        "          self.clients2[j].fit()\n",
        "        else:\n",
        "          self.clients[j].w = copy.deepcopy(w_agg)\n",
        "          self.clients[j].b = copy.deepcopy(b_agg)\n",
        "          self.clients[j].fit()\n",
        "          self.clients2[j].w = copy.deepcopy(w_agg)\n",
        "          self.clients2[j].b = copy.deepcopy(b_agg)\n",
        "          self.clients2[j].fit()\n",
        "        print('client',j+1,self.clients[j].accuracy())          \n",
        "      parameter_list = []\n",
        "      for k in range(0,self.n_clients):\n",
        "        parameter_list.append(self.clients2[k].w)\n",
        "        parameter_list.append(self.clients2[k].b)\n",
        "      w_agg, b_agg = aggregator(parameter_list)\n",
        "      # print(\"agg\",self.accuracy(w_agg,b_agg),\"best\",self.accuracy(w_best,b_best))\n",
        "      if self.accuracy(w_agg,b_agg)>self.accuracy(w_best,b_best) or i==0:\n",
        "        w_best=copy.deepcopy(w_agg)\n",
        "        b_best=copy.deepcopy(b_agg)\n",
        "      self.Loss.append(self.loss(w_agg,b_agg))\n",
        "      self.timefit.append(time.time())\n",
        "      print('global test acc',self.accuracy(w_agg,b_agg))\n",
        "\n",
        "  def loss(self,w,b):\n",
        "    # print(np.concatenate(self.y_train,axis=None))\n",
        "    # print(np.vstack(self.x_train).shape)#, np.where(np.sign(np.dot(self.x_train, w) - b))<0, 0, 1).shape)\n",
        "    return np.mean([max(0, 1-x*y) for x, y in zip(np.where(np.concatenate(self.y_train,axis=None) <= 0, -1, 1), np.where(np.sign(np.dot(np.vstack(self.x_train), w) - b)<0, -1, 1 ))])\n",
        "\n",
        "  def predict(self,w,b):\n",
        "     approx = np.dot(self.X_test, w) - b\n",
        "     approx = np.sign(approx)\n",
        "     return np.where(approx<0, 0, 1)\n",
        "  \n",
        "  def accuracy(self,w,b):\n",
        "    return accuracy_score(self.y_test, self.predict(w,b))*100"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i3nxZNBjpPEA"
      },
      "source": [
        "## Batch global / SGD+Batch\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SUlclkz_psLN",
        "outputId": "53424da0-8973-4093-90cb-7f5c4c6eda6c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "global round 1\n",
            "client 1 95.61276287164611\n",
            "client 2 96.08411892675852\n",
            "client 3 90.42784626540971\n",
            "global test acc 96.88179840464105\n",
            "global round 2\n",
            "client 1 96.37418419144308\n",
            "client 2 97.31689630166788\n",
            "client 3 94.77882523567803\n",
            "global test acc 97.13560551124003\n",
            "global round 3\n",
            "client 1 96.8092820884699\n",
            "client 2 97.643219724438\n",
            "client 3 96.1203770848441\n",
            "global test acc 97.643219724438\n",
            "global round 4\n",
            "client 1 97.35315445975344\n",
            "client 2 97.67947788252357\n",
            "client 3 96.77302393038434\n",
            "global test acc 97.78825235678028\n",
            "global round 5\n",
            "client 1 97.49818709209572\n",
            "client 2 97.82451051486585\n",
            "client 3 97.06308919506888\n",
            "global test acc 97.86076867295141\n",
            "global round 6\n",
            "client 1 97.67947788252357\n",
            "client 2 97.89702683103698\n",
            "client 3 97.24437998549674\n",
            "global test acc 98.11457577955039\n",
            "global round 7\n",
            "client 1 97.71573604060913\n",
            "client 2 98.04205946337926\n",
            "client 3 97.49818709209572\n",
            "global test acc 98.25960841189267\n",
            "global round 8\n",
            "client 1 97.78825235678028\n",
            "client 2 98.18709209572154\n",
            "client 3 97.71573604060913\n",
            "global test acc 98.29586656997824\n",
            "global round 9\n",
            "client 1 97.93328498912255\n",
            "client 2 98.22335025380711\n",
            "client 3 97.78825235678028\n",
            "global test acc 98.40464104423495\n",
            "global round 10\n",
            "client 1 98.18709209572154\n",
            "client 2 98.29586656997824\n",
            "client 3 97.89702683103698\n",
            "global test acc 98.54967367657723\n",
            "global round 11\n",
            "client 1 98.29586656997824\n",
            "client 2 98.44089920232052\n",
            "client 3 97.93328498912255\n",
            "global test acc 98.5859318346628\n",
            "global round 12\n",
            "client 1 98.33212472806382\n",
            "client 2 98.5859318346628\n",
            "client 3 98.04205946337926\n",
            "global test acc 98.6947063089195\n",
            "global round 13\n",
            "client 1 98.47715736040608\n",
            "client 2 98.65844815083393\n",
            "client 3 98.33212472806382\n",
            "global test acc 98.76722262509064\n",
            "global round 14\n",
            "client 1 98.47715736040608\n",
            "client 2 98.6947063089195\n",
            "client 3 98.44089920232052\n",
            "global test acc 98.76722262509064\n",
            "global round 15\n",
            "client 1 98.47715736040608\n",
            "client 2 98.73096446700508\n",
            "client 3 98.47715736040608\n",
            "global test acc 98.80348078317621\n",
            "global round 16\n",
            "client 1 98.47715736040608\n",
            "client 2 98.76722262509064\n",
            "client 3 98.47715736040608\n",
            "global test acc 98.87599709934736\n",
            "global round 17\n",
            "client 1 98.54967367657723\n",
            "client 2 98.83973894126179\n",
            "client 3 98.54967367657723\n",
            "global test acc 98.98477157360406\n",
            "global round 18\n",
            "client 1 98.54967367657723\n",
            "client 2 98.83973894126179\n",
            "client 3 98.54967367657723\n",
            "global test acc 98.98477157360406\n",
            "global round 19\n",
            "client 1 98.62218999274836\n",
            "client 2 98.87599709934736\n",
            "client 3 98.54967367657723\n",
            "global test acc 98.98477157360406\n",
            "global round 20\n",
            "client 1 98.62218999274836\n",
            "client 2 98.91225525743292\n",
            "client 3 98.54967367657723\n",
            "global test acc 99.02102973168962\n"
          ]
        }
      ],
      "source": [
        "f_svm = Federated_SVM(xtrain_gl, ytrain_gl, n_clients = 3, val=False, n_iters=150,opt='batch_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)\n",
        "f_svm.fit(20,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zF-xCK9zpyAZ"
      },
      "outputs": [],
      "source": [
        "batch = f_svm.Loss\n",
        "bat_time = f_svm.timefit"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bat_time"
      ],
      "metadata": {
        "id": "DXp8uxcB1WuM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1c3892b0-404f-4d38-ad8e-0fe1138d47a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1647674870.7356732,\n",
              " 1647674913.1748192,\n",
              " 1647674938.9743721,\n",
              " 1647674963.9929657,\n",
              " 1647674988.454166,\n",
              " 1647675013.9713912,\n",
              " 1647675037.9502783,\n",
              " 1647675062.0588064,\n",
              " 1647675085.5493906,\n",
              " 1647675109.271684,\n",
              " 1647675132.970467,\n",
              " 1647675156.7077885,\n",
              " 1647675180.082313,\n",
              " 1647675203.0074105,\n",
              " 1647675226.0156012,\n",
              " 1647675248.9458504,\n",
              " 1647675272.0856605,\n",
              " 1647675295.0647852,\n",
              " 1647675317.8022,\n",
              " 1647675340.6358302]"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bat_time = [abs(bat_time[i]-bat_time[i+1]) for i in range(len(bat_time)-1)]"
      ],
      "metadata": {
        "id": "fCDZdIDXxauf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o9vKVg8WqNr_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "398e734c-3ec5-4b52-b275-8c8edfc18f42"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "global round 1\n",
            "client 1 94.74256707759245\n",
            "client 2 96.7005076142132\n",
            "client 3 90.9354604786077\n",
            "global test acc 97.93328498912255\n",
            "global round 2\n",
            "client 1 93.72733865119652\n",
            "client 2 96.77302393038434\n",
            "client 3 91.84191443074693\n",
            "global test acc 97.78825235678028\n",
            "global round 3\n",
            "client 1 93.69108049311095\n",
            "client 2 96.41044234952865\n",
            "client 3 92.60333575054386\n",
            "global test acc 98.11457577955039\n",
            "global round 4\n",
            "client 1 92.929659173314\n",
            "client 2 96.15663524292965\n",
            "client 3 91.00797679477883\n",
            "global test acc 97.71573604060913\n",
            "global round 5\n",
            "client 1 94.59753444525019\n",
            "client 2 96.55547498187093\n",
            "client 3 91.44307469180566\n",
            "global test acc 98.15083393763598\n",
            "global round 6\n",
            "client 1 93.07469180565627\n",
            "client 2 96.15663524292965\n",
            "client 3 92.0957215373459\n",
            "global test acc 98.07831762146483\n",
            "global round 7\n",
            "client 1 93.25598259608412\n",
            "client 2 95.64902102973168\n",
            "client 3 91.7331399564902\n",
            "global test acc 98.29586656997824\n",
            "global round 8\n",
            "client 1 94.19869470630891\n",
            "client 2 96.3379260333575\n",
            "client 3 92.82088469905729\n",
            "global test acc 98.36838288614939\n",
            "global round 9\n",
            "client 1 93.25598259608412\n",
            "client 2 96.37418419144308\n",
            "client 3 91.84191443074693\n",
            "global test acc 97.86076867295141\n",
            "global round 10\n",
            "client 1 94.27121102248006\n",
            "client 2 96.62799129804206\n",
            "client 3 90.1015228426396\n",
            "global test acc 97.82451051486585\n",
            "global round 11\n",
            "client 1 93.36475707034083\n",
            "client 2 96.73676577229877\n",
            "client 3 92.02320522117476\n",
            "global test acc 98.04205946337926\n",
            "global round 12\n",
            "client 1 93.79985496736765\n",
            "client 2 96.04786076867296\n",
            "client 3 91.55184916606235\n",
            "global test acc 98.22335025380711\n",
            "global round 13\n",
            "client 1 93.47353154459753\n",
            "client 2 95.46773023930383\n",
            "client 3 91.7331399564902\n",
            "global test acc 98.29586656997824\n",
            "global round 14\n",
            "client 1 94.27121102248006\n",
            "client 2 96.48295866569978\n",
            "client 3 91.95068890500363\n",
            "global test acc 98.15083393763598\n",
            "global round 15\n",
            "client 1 93.8723712835388\n",
            "client 2 95.93908629441624\n",
            "client 3 91.76939811457578\n",
            "global test acc 98.15083393763598\n",
            "global round 16\n",
            "client 1 93.1472081218274\n",
            "client 2 96.15663524292965\n",
            "client 3 92.74836838288614\n",
            "global test acc 98.07831762146483\n",
            "global round 17\n",
            "client 1 93.72733865119652\n",
            "client 2 96.44670050761421\n",
            "client 3 91.69688179840463\n",
            "global test acc 98.18709209572154\n",
            "global round 18\n",
            "client 1 93.94488759970994\n",
            "client 2 96.7005076142132\n",
            "client 3 92.31327048585932\n",
            "global test acc 98.15083393763598\n",
            "global round 19\n",
            "client 1 93.61856417693981\n",
            "client 2 96.84554024655547\n",
            "client 3 92.20449601160261\n",
            "global test acc 97.93328498912255\n",
            "global round 20\n",
            "client 1 93.79985496736765\n",
            "client 2 97.1718636693256\n",
            "client 3 92.3495286439449\n",
            "global test acc 97.86076867295141\n"
          ]
        }
      ],
      "source": [
        "f_svm1 = Federated_SVM(xtrain_gl, ytrain_gl, n_clients = 3, val=False, n_iters=150,opt='stochastic_GD')\n",
        "f_svm1.create_clients(clients_X,clients_y,X_test,y_test)\n",
        "f_svm1.fit(20,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gcoa8IB5sUy9"
      },
      "outputs": [],
      "source": [
        "sgd = f_svm1.Loss\n",
        "sgd_time = f_svm1.timefit"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sgd_time"
      ],
      "metadata": {
        "id": "BKpcbU9v1L4h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "103284c7-9592-49ef-dcef-85356f92b337"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1647675363.1735554,\n",
              " 1647675385.1994,\n",
              " 1647675407.4739227,\n",
              " 1647675429.8466918,\n",
              " 1647675452.0513072,\n",
              " 1647675474.0149438,\n",
              " 1647675496.08491,\n",
              " 1647675518.2054734,\n",
              " 1647675540.2960384,\n",
              " 1647675562.4729543,\n",
              " 1647675584.7332952,\n",
              " 1647675606.9908607,\n",
              " 1647675629.0118966,\n",
              " 1647675650.9575655,\n",
              " 1647675673.0938945,\n",
              " 1647675695.2870636,\n",
              " 1647675717.2091806,\n",
              " 1647675739.0881104,\n",
              " 1647675760.859217,\n",
              " 1647675782.650181]"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sgd_time = [abs(sgd_time[i]-sgd_time[i+1]) for i in range(len(sgd_time)-1)]"
      ],
      "metadata": {
        "id": "hpe-_soNwugh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7l5XlxEftLik",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "outputId": "48d86b2c-5d37-4321-9dd4-c2b424b67f7a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plt.plot(batch,label = \"BatchGD\")\n",
        "plt.plot(sgd,label = \"StochasticGD\")\n",
        "plt.xticks([i for i in range(1,21)])\n",
        "plt.xlabel(\"No. of iterations\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot([sum(sgd_time[0:x:1]) for x in range(0, len(sgd_time)+1)],sgd,label = \"StochasticGD\")\n",
        "plt.xlabel(\"Time (Sec)\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "wnhL8Qb_GWU2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "outputId": "5f610cc0-be7e-4cf9-a179-77dc1256cc30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot([sum(bat_time[0:x:1]) for x in range(0, len(bat_time)+1)],batch,label = \"BatchGD\")\n",
        "plt.xlabel(\"Time (Sec)\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "Wz6gXV2RHkpn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "outputId": "58612e5c-999b-480d-c1c2-82cfc838bb2e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujC1N29CrvmS"
      },
      "source": [
        "# Digits 3 and 8"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lQLYCuk0rvmT"
      },
      "source": [
        "### Loading the data of 3 and 8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8KR9u9htrvmT"
      },
      "outputs": [],
      "source": [
        "data = load_mnist_return_required_digits(3, 8)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUY22RmCrvmU"
      },
      "source": [
        "### Dividing the data of digits 3 and 8 into clusters using the KMeans algorithm\n",
        "The images of 3 and 8 are divided into 3 three clusters each."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "id": "DT9oR2p-rvmU",
        "outputId": "e8948176-8bc4-4c4e-f03c-0a8233ab14ef"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Cluster 3')"
            ]
          },
          "execution_count": 41,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "x_0_c1, y_0_c1, x_0_c2, y_0_c2, x_0_c3, y_0_c3 = create_kmeans_clusters(data[0][0], data[0][1])\n",
        "fig, axs = plt.subplots(1, 3)\n",
        "axs[0].imshow(x_0_c1[0].reshape(28,28),cmap='gray')\n",
        "axs[0].set_title('Cluster 1')\n",
        "axs[1].imshow(x_0_c2[0].reshape(28,28),cmap='gray')\n",
        "axs[1].set_title('Cluster 2')\n",
        "axs[2].imshow(x_0_c3[0].reshape(28,28),cmap='gray')\n",
        "axs[2].set_title('Cluster 3')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "id": "-1nzWuCMrvmW",
        "outputId": "ab84ebf8-69b3-4817-b86b-4f3fb1803e25"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Cluster 3')"
            ]
          },
          "execution_count": 42,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "x_6_c1, y_6_c1, x_6_c2, y_6_c2, x_6_c3, y_6_c3 = create_kmeans_clusters(data[1][0], data[1][1])\n",
        "fig, axs = plt.subplots(1, 3)\n",
        "axs[0].imshow(x_6_c1[0].reshape(28,28),cmap='gray')\n",
        "axs[0].set_title('Cluster 1')\n",
        "axs[1].imshow(x_6_c2[0].reshape(28,28),cmap='gray')\n",
        "axs[1].set_title('Cluster 2')\n",
        "axs[2].imshow(x_6_c3[0].reshape(28,28),cmap='gray')\n",
        "axs[2].set_title('Cluster 3')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SBm1X_wQrvmX"
      },
      "source": [
        "### Creation of individual train sets for the clients, global train set for the SVM model and a global test set containing the data from all the clusters\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iWilSUyYGE_J"
      },
      "outputs": [],
      "source": [
        "clients_X,clients_y,X_test,y_test = get_clients(data[0][0], data[1][0], n_clients = 3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j87QeVg2GWnB"
      },
      "outputs": [],
      "source": [
        "xtrain_gl, ytrain_gl = get_total_from_clients(clients_X,clients_y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lFZmdlZdrvma"
      },
      "source": [
        "### Federated learning model and SVM model training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "stZxTwj7cYz7"
      },
      "source": [
        "#### Training the models without validation & with avg aggregator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fkR3sBkGJMrv"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=False, n_iters=150,opt='stochastic_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rDbc28DtcgYC",
        "outputId": "110c4634-f7ea-404a-f436-7d2ac031ff9c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "96.67262969588552\n"
          ]
        }
      ],
      "source": [
        "clf = SVM(xtrain_gl, ytrain_gl, X_test, y_test, val=False,n_iters=1000,opt='stochastic_GD')\n",
        "clf.fit()\n",
        "print(clf.accuracy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t-_qwcG9ciO3",
        "outputId": "eb05455a-fe29-4420-d6ee-39e6fa0940e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 79.17710196779964\n",
            "client 2 81.18067978533094\n",
            "client 3 73.20214669051879\n",
            "global test acc 95.59928443649373\n",
            "global round 2\n",
            "client 1 79.35599284436495\n",
            "client 2 80.35778175313058\n",
            "client 3 72.41502683363149\n",
            "global test acc 95.59928443649373\n",
            "global round 3\n",
            "client 1 79.2128801431127\n",
            "client 2 81.18067978533094\n",
            "client 3 72.80858676207514\n",
            "global test acc 95.59928443649373\n",
            "global round 4\n",
            "client 1 78.74776386404292\n",
            "client 2 81.1449016100179\n",
            "client 3 72.73703041144901\n",
            "global test acc 95.59928443649373\n",
            "global round 5\n",
            "client 1 78.6046511627907\n",
            "client 2 80.82289803220036\n",
            "client 3 73.23792486583184\n",
            "global test acc 95.67084078711986\n",
            "global round 6\n",
            "client 1 79.24865831842575\n",
            "client 2 80.46511627906978\n",
            "client 3 72.88014311270126\n",
            "global test acc 95.67084078711986\n",
            "global round 7\n",
            "client 1 79.5706618962433\n",
            "client 2 80.82289803220036\n",
            "client 3 73.16636851520573\n",
            "global test acc 95.74239713774597\n",
            "global round 8\n",
            "client 1 79.5706618962433\n",
            "client 2 81.824686940966\n",
            "client 3 72.77280858676207\n",
            "global test acc 95.74239713774597\n",
            "global round 9\n",
            "client 1 79.39177101967799\n",
            "client 2 81.3953488372093\n",
            "client 3 73.16636851520573\n",
            "global test acc 95.74239713774597\n",
            "global round 10\n",
            "client 1 79.32021466905188\n",
            "client 2 80.64400715563507\n",
            "client 3 73.23792486583184\n",
            "global test acc 95.74239713774597\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6HgXjB1Fcmg2"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=False, n_iters=150,opt='batch_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VL_dBqImcooT",
        "outputId": "3c8d5551-ebcd-459a-c28b-8e3f4ecd1c97"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "93.52415026833631\n"
          ]
        }
      ],
      "source": [
        "clf = SVM(xtrain_gl, ytrain_gl, X_test, y_test, val=False,n_iters=1000,opt='batch_GD')\n",
        "clf.fit()\n",
        "print(clf.accuracy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A2G_gjU6cpoV",
        "outputId": "6a4880f2-6e60-412e-9416-e905225e0af3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 78.64042933810376\n",
            "client 2 82.32558139534883\n",
            "client 3 76.63685152057245\n",
            "global test acc 89.3381037567084\n",
            "global round 2\n",
            "client 1 90.80500894454383\n",
            "client 2 88.87298747763865\n",
            "client 3 83.61359570661897\n",
            "global test acc 90.80500894454383\n",
            "global round 3\n",
            "client 1 92.4865831842576\n",
            "client 2 91.0912343470483\n",
            "client 3 86.47584973166369\n",
            "global test acc 91.73524150268337\n",
            "global round 4\n",
            "client 1 93.34525939177102\n",
            "client 2 91.91413237924866\n",
            "client 3 88.51520572450805\n",
            "global test acc 92.77280858676208\n",
            "global round 5\n",
            "client 1 93.84615384615384\n",
            "client 2 92.41502683363149\n",
            "client 3 90.16100178890876\n",
            "global test acc 93.30948121645795\n",
            "global round 6\n",
            "client 1 94.13237924865831\n",
            "client 2 92.84436493738819\n",
            "client 3 91.27012522361359\n",
            "global test acc 93.59570661896244\n",
            "global round 7\n",
            "client 1 94.38282647584974\n",
            "client 2 93.34525939177102\n",
            "client 3 92.20035778175313\n",
            "global test acc 93.7030411449016\n",
            "global round 8\n",
            "client 1 94.59749552772809\n",
            "client 2 93.84615384615384\n",
            "client 3 92.84436493738819\n",
            "global test acc 93.91771019677996\n",
            "global round 9\n",
            "client 1 94.77638640429338\n",
            "client 2 94.09660107334525\n",
            "client 3 93.38103756708408\n",
            "global test acc 94.2397137745975\n",
            "global round 10\n",
            "client 1 94.8479427549195\n",
            "client 2 94.2397137745975\n",
            "client 3 93.55992844364937\n",
            "global test acc 94.45438282647585\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8CjwZIhWcryM"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=False, n_iters=150,opt='mini_batch_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hWNR0ObQcup_",
        "outputId": "9c581c4f-7b71-45d6-d622-e21049787e2d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "93.38103756708408\n"
          ]
        }
      ],
      "source": [
        "clf = SVM(xtrain_gl, ytrain_gl, X_test, y_test, val=False,n_iters=1000,opt='mini_batch_GD')\n",
        "clf.fit()\n",
        "print(clf.accuracy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s1nub4tvcwwI",
        "outputId": "0568b03d-9a42-4bdf-8897-4e2dc9e408a0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 76.56529516994634\n",
            "client 2 80.39355992844365\n",
            "client 3 73.4525939177102\n",
            "global test acc 95.74239713774597\n",
            "global round 2\n",
            "client 1 77.67441860465117\n",
            "client 2 81.18067978533094\n",
            "client 3 72.6654740608229\n",
            "global test acc 95.74239713774597\n",
            "global round 3\n",
            "client 1 79.10554561717352\n",
            "client 2 79.32021466905188\n",
            "client 3 72.4865831842576\n",
            "global test acc 95.74239713774597\n",
            "global round 4\n",
            "client 1 75.77817531305904\n",
            "client 2 79.39177101967799\n",
            "client 3 73.34525939177102\n",
            "global test acc 95.95706618962433\n",
            "global round 5\n",
            "client 1 76.49373881932021\n",
            "client 2 80.0\n",
            "client 3 73.09481216457961\n",
            "global test acc 95.95706618962433\n",
            "global round 6\n",
            "client 1 77.92486583184257\n",
            "client 2 81.32379248658317\n",
            "client 3 73.48837209302326\n",
            "global test acc 95.95706618962433\n",
            "global round 7\n",
            "client 1 80.28622540250447\n",
            "client 2 78.46153846153847\n",
            "client 3 74.70483005366727\n",
            "global test acc 95.9928443649374\n",
            "global round 8\n",
            "client 1 78.81932021466905\n",
            "client 2 81.10912343470483\n",
            "client 3 73.09481216457961\n",
            "global test acc 95.9928443649374\n",
            "global round 9\n",
            "client 1 80.53667262969589\n",
            "client 2 81.1449016100179\n",
            "client 3 74.20393559928443\n",
            "global test acc 95.9928443649374\n",
            "global round 10\n",
            "client 1 78.31842576028623\n",
            "client 2 81.32379248658317\n",
            "client 3 73.73881932021466\n",
            "global test acc 95.9928443649374\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v_0EbN8Sc6E-"
      },
      "source": [
        "#### Training the models with various validation & with avg aggregator & with batch GD"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "niGk8cvmc4mr"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=False, n_iters=150,opt='batch_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PDLL5jXXc9sM",
        "outputId": "25508a73-721c-450e-d840-472cadd8c1a0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "93.52415026833631\n"
          ]
        }
      ],
      "source": [
        "clf = SVM(xtrain_gl, ytrain_gl, X_test, y_test, val=False, n_iters=1000,opt='batch_GD')\n",
        "clf.fit()\n",
        "print(clf.accuracy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dVw1HGsTdAE6",
        "outputId": "c335df6f-87d8-4f9b-89bb-2cd0ccb41ea8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 78.64042933810376\n",
            "client 2 82.32558139534883\n",
            "client 3 76.63685152057245\n",
            "global test acc 89.3381037567084\n",
            "global round 2\n",
            "client 1 90.80500894454383\n",
            "client 2 88.87298747763865\n",
            "client 3 83.61359570661897\n",
            "global test acc 90.80500894454383\n",
            "global round 3\n",
            "client 1 92.4865831842576\n",
            "client 2 91.0912343470483\n",
            "client 3 86.47584973166369\n",
            "global test acc 91.73524150268337\n",
            "global round 4\n",
            "client 1 93.34525939177102\n",
            "client 2 91.91413237924866\n",
            "client 3 88.51520572450805\n",
            "global test acc 92.77280858676208\n",
            "global round 5\n",
            "client 1 93.84615384615384\n",
            "client 2 92.41502683363149\n",
            "client 3 90.16100178890876\n",
            "global test acc 93.30948121645795\n",
            "global round 6\n",
            "client 1 94.13237924865831\n",
            "client 2 92.84436493738819\n",
            "client 3 91.27012522361359\n",
            "global test acc 93.59570661896244\n",
            "global round 7\n",
            "client 1 94.38282647584974\n",
            "client 2 93.34525939177102\n",
            "client 3 92.20035778175313\n",
            "global test acc 93.7030411449016\n",
            "global round 8\n",
            "client 1 94.59749552772809\n",
            "client 2 93.84615384615384\n",
            "client 3 92.84436493738819\n",
            "global test acc 93.91771019677996\n",
            "global round 9\n",
            "client 1 94.77638640429338\n",
            "client 2 94.09660107334525\n",
            "client 3 93.38103756708408\n",
            "global test acc 94.2397137745975\n",
            "global round 10\n",
            "client 1 94.8479427549195\n",
            "client 2 94.2397137745975\n",
            "client 3 93.55992844364937\n",
            "global test acc 94.45438282647585\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pGS4WcFadCfI"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=True, n_iters=150,opt='batch_GD', val_type='cross_val')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T1MlRfeXdFCE",
        "outputId": "2b7ad168-92bf-4397-8d98-9837e290c2a6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "93.77459749552773\n"
          ]
        }
      ],
      "source": [
        "clf = SVM(xtrain_gl, ytrain_gl, X_test, y_test, val=True, n_iters=1000,opt='batch_GD', val_type='cross_val')\n",
        "clf.fit()\n",
        "print(clf.accuracy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7zKlJDnZdHRp",
        "outputId": "3dd69707-596a-47a7-d538-7a1eab258a0b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 78.2468694096601\n",
            "client 2 82.46869409660107\n",
            "client 3 76.6010733452594\n",
            "global test acc 89.37388193202148\n",
            "global round 2\n",
            "client 1 90.62611806797854\n",
            "client 2 89.12343470483005\n",
            "client 3 83.50626118067979\n",
            "global test acc 90.76923076923077\n",
            "global round 3\n",
            "client 1 92.41502683363149\n",
            "client 2 90.94812164579606\n",
            "client 3 86.47584973166369\n",
            "global test acc 91.80679785330949\n",
            "global round 4\n",
            "client 1 93.20214669051879\n",
            "client 2 91.98568872987478\n",
            "client 3 88.479427549195\n",
            "global test acc 92.80858676207512\n",
            "global round 5\n",
            "client 1 93.81037567084078\n",
            "client 2 92.27191413237925\n",
            "client 3 90.08944543828264\n",
            "global test acc 93.38103756708408\n",
            "global round 6\n",
            "client 1 94.20393559928443\n",
            "client 2 92.91592128801432\n",
            "client 3 91.4490161001789\n",
            "global test acc 93.7030411449016\n",
            "global round 7\n",
            "client 1 94.4901610017889\n",
            "client 2 93.38103756708408\n",
            "client 3 92.37924865831843\n",
            "global test acc 93.77459749552773\n",
            "global round 8\n",
            "client 1 94.59749552772809\n",
            "client 2 93.84615384615384\n",
            "client 3 93.02325581395348\n",
            "global test acc 94.09660107334525\n",
            "global round 9\n",
            "client 1 94.77638640429338\n",
            "client 2 94.2397137745975\n",
            "client 3 93.45259391771019\n",
            "global test acc 94.34704830053667\n",
            "global round 10\n",
            "client 1 94.81216457960645\n",
            "client 2 94.41860465116278\n",
            "client 3 93.7030411449016\n",
            "global test acc 94.56171735241503\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yWxOON2YdLTt"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=True, n_iters=150, val_type='k_fold',opt='batch_GD', k=5)\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "55fBGgNVdQda",
        "outputId": "83960ee8-7cff-41fe-de04-e035ef27be8d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "93.55992844364937\n",
            "93.52415026833631\n",
            "93.66726296958855\n",
            "93.6314847942755\n",
            "93.6314847942755\n",
            "93.6314847942755\n"
          ]
        }
      ],
      "source": [
        "clf = SVM(xtrain_gl, ytrain_gl, X_test, y_test, n_iters=1000, val=True,opt='batch_GD', val_type='k_fold', k=5)\n",
        "clf.fit()\n",
        "print(clf.accuracy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4IQuarcSdZme",
        "outputId": "24d12d0e-c96a-41fa-e24c-a76007d04ada"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "79.85688729874776\n",
            "80.28622540250447\n",
            "80.14311270125224\n",
            "80.35778175313058\n",
            "80.10733452593918\n",
            "client 1 80.28622540250447\n",
            "83.5778175313059\n",
            "83.29159212880143\n",
            "83.43470483005366\n",
            "83.29159212880143\n",
            "83.3273703041145\n",
            "client 2 83.29159212880143\n",
            "75.95706618962433\n",
            "75.88550983899822\n",
            "76.02862254025044\n",
            "76.06440071556351\n",
            "75.99284436493738\n",
            "client 3 76.06440071556351\n",
            "global test acc 89.48121645796064\n",
            "global round 2\n",
            "90.87656529516994\n",
            "90.76923076923077\n",
            "90.7334525939177\n",
            "90.91234347048301\n",
            "90.69767441860465\n",
            "client 1 90.91234347048301\n",
            "89.19499105545617\n",
            "89.30232558139535\n",
            "89.30232558139535\n",
            "89.23076923076924\n",
            "89.23076923076924\n",
            "client 2 89.30232558139535\n",
            "83.18425760286226\n",
            "83.07692307692308\n",
            "83.14847942754919\n",
            "83.11270125223614\n",
            "83.11270125223614\n",
            "client 3 83.07692307692308\n",
            "global test acc 90.59033989266547\n",
            "global round 3\n",
            "92.45080500894454\n",
            "92.41502683363149\n",
            "92.37924865831843\n",
            "92.41502683363149\n",
            "92.3076923076923\n",
            "client 1 92.37924865831843\n",
            "91.01967799642217\n",
            "90.98389982110913\n",
            "91.12701252236135\n",
            "90.94812164579606\n",
            "91.0912343470483\n",
            "client 2 91.12701252236135\n",
            "86.65474060822898\n",
            "86.65474060822898\n",
            "86.58318425760287\n",
            "86.61896243291592\n",
            "86.7262969588551\n",
            "client 3 86.61896243291592\n",
            "global test acc 91.4490161001789\n",
            "global round 4\n",
            "92.77280858676208\n",
            "92.80858676207512\n",
            "92.77280858676208\n",
            "92.80858676207512\n",
            "92.73703041144901\n",
            "client 1 92.77280858676208\n",
            "91.80679785330949\n",
            "91.8783542039356\n",
            "91.84257602862253\n",
            "91.80679785330949\n",
            "91.84257602862253\n",
            "client 2 91.80679785330949\n",
            "88.40787119856887\n",
            "88.37209302325581\n",
            "88.30053667262969\n",
            "88.33631484794276\n",
            "88.26475849731665\n",
            "client 3 88.37209302325581\n",
            "global test acc 92.09302325581396\n",
            "global round 5\n",
            "93.09481216457961\n",
            "93.16636851520572\n",
            "93.13059033989266\n",
            "93.13059033989266\n",
            "93.09481216457961\n",
            "client 1 93.13059033989266\n",
            "92.34347048300536\n",
            "92.3076923076923\n",
            "92.3076923076923\n",
            "92.45080500894454\n",
            "92.34347048300536\n",
            "client 2 92.3076923076923\n",
            "89.98211091234347\n",
            "90.01788908765653\n",
            "89.98211091234347\n",
            "90.01788908765653\n",
            "89.94633273703042\n",
            "client 3 89.98211091234347\n",
            "global test acc 92.4865831842576\n",
            "global round 6\n",
            "93.34525939177102\n",
            "93.45259391771019\n",
            "93.41681574239715\n",
            "93.48837209302326\n",
            "93.41681574239715\n",
            "client 1 93.48837209302326\n",
            "92.91592128801432\n",
            "92.88014311270125\n",
            "92.91592128801432\n",
            "92.84436493738819\n",
            "92.84436493738819\n",
            "client 2 92.91592128801432\n",
            "90.94812164579606\n",
            "90.8407871198569\n",
            "90.91234347048301\n",
            "90.94812164579606\n",
            "90.87656529516994\n",
            "client 3 90.94812164579606\n",
            "global test acc 92.84436493738819\n",
            "global round 7\n",
            "93.66726296958855\n",
            "93.6314847942755\n",
            "93.6314847942755\n",
            "93.7030411449016\n",
            "93.73881932021467\n",
            "client 1 93.66726296958855\n",
            "93.20214669051879\n",
            "93.16636851520572\n",
            "93.23792486583184\n",
            "93.13059033989266\n",
            "93.13059033989266\n",
            "client 2 93.20214669051879\n",
            "91.59212880143113\n",
            "91.55635062611806\n",
            "91.520572450805\n",
            "91.59212880143113\n",
            "91.59212880143113\n",
            "client 3 91.520572450805\n",
            "global test acc 92.98747763864043\n",
            "global round 8\n",
            "93.88193202146691\n",
            "93.91771019677996\n",
            "94.02504472271914\n",
            "93.98926654740607\n",
            "94.02504472271914\n",
            "client 1 94.02504472271914\n",
            "93.34525939177102\n",
            "93.34525939177102\n",
            "93.34525939177102\n",
            "93.38103756708408\n",
            "93.41681574239715\n",
            "client 2 93.34525939177102\n",
            "92.02146690518784\n",
            "92.09302325581396\n",
            "92.16457960644007\n",
            "91.98568872987478\n",
            "91.94991055456173\n",
            "client 3 92.02146690518784\n",
            "global test acc 93.41681574239715\n",
            "global round 9\n",
            "94.13237924865831\n",
            "94.0608228980322\n",
            "94.0608228980322\n",
            "93.95348837209302\n",
            "93.95348837209302\n",
            "client 1 94.0608228980322\n",
            "93.66726296958855\n",
            "93.6314847942755\n",
            "93.55992844364937\n",
            "93.66726296958855\n",
            "93.6314847942755\n",
            "client 2 93.6314847942755\n",
            "92.37924865831843\n",
            "92.34347048300536\n",
            "92.52236135957065\n",
            "92.45080500894454\n",
            "92.37924865831843\n",
            "client 3 92.37924865831843\n",
            "global test acc 93.59570661896244\n",
            "global round 10\n",
            "93.95348837209302\n",
            "94.02504472271914\n",
            "93.98926654740607\n",
            "93.98926654740607\n",
            "93.98926654740607\n",
            "client 1 93.98926654740607\n",
            "93.77459749552773\n",
            "93.77459749552773\n",
            "93.73881932021467\n",
            "93.81037567084078\n",
            "93.77459749552773\n",
            "client 2 93.81037567084078\n",
            "92.59391771019678\n",
            "92.59391771019678\n",
            "92.55813953488372\n",
            "92.55813953488372\n",
            "92.62969588550985\n",
            "client 3 92.55813953488372\n",
            "global test acc 93.73881932021467\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.average_aggregator)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NSN-WJV2d1IF"
      },
      "source": [
        "#### Training models with various aggregators & without val & with batch gd\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "za38awJXdcpd"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=False, n_iters=150,opt='batch_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vfu3GFoPd9TX",
        "outputId": "d32966b4-89f3-40d8-d3c6-a79926981c9d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "93.52415026833631\n"
          ]
        }
      ],
      "source": [
        "clf = SVM(xtrain_gl, ytrain_gl, X_test, y_test, val=False, n_iters=1000,opt='batch_GD')\n",
        "clf.fit()\n",
        "print(clf.accuracy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dcRXlTmJelzp",
        "outputId": "ce8fbaff-4a28-484a-cd0f-8184b36b7ad1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 80.28622540250447\n",
            "client 2 83.36314847942755\n",
            "client 3 75.88550983899822\n",
            "global test acc 83.36314847942755\n",
            "global round 2\n",
            "client 1 89.08765652951699\n",
            "client 2 82.86225402504472\n",
            "client 3 85.79606440071557\n",
            "global test acc 89.08765652951699\n",
            "global round 3\n",
            "client 1 89.37388193202148\n",
            "client 2 87.47763864042933\n",
            "client 3 90.51878354203936\n",
            "global test acc 90.51878354203936\n",
            "global round 4\n",
            "client 1 92.4865831842576\n",
            "client 2 91.59212880143113\n",
            "client 3 88.33631484794276\n",
            "global test acc 92.4865831842576\n",
            "global round 5\n",
            "client 1 92.91592128801432\n",
            "client 2 92.98747763864043\n",
            "client 3 90.62611806797854\n",
            "global test acc 92.98747763864043\n",
            "global round 6\n",
            "client 1 93.77459749552773\n",
            "client 2 92.70125223613596\n",
            "client 3 92.16457960644007\n",
            "global test acc 93.77459749552773\n",
            "global round 7\n",
            "client 1 93.52415026833631\n",
            "client 2 92.70125223613596\n",
            "client 3 93.13059033989266\n",
            "global test acc 93.77459749552773\n",
            "global round 8\n",
            "client 1 93.02325581395348\n",
            "client 2 92.70125223613596\n",
            "client 3 93.6314847942755\n",
            "global test acc 93.77459749552773\n",
            "global round 9\n",
            "client 1 93.59570661896244\n",
            "client 2 93.7030411449016\n",
            "client 3 92.52236135957065\n",
            "global test acc 93.77459749552773\n",
            "global round 10\n",
            "client 1 94.09660107334525\n",
            "client 2 93.88193202146691\n",
            "client 3 93.30948121645795\n",
            "global test acc 94.09660107334525\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.highest_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "woUh9lAAeoAb"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=False, n_iters=150,opt='batch_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ekLuoobMesOl",
        "outputId": "85d7d16c-2a64-4c7a-9196-8f7eb18cb545"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 78.64042933810376\n",
            "client 2 82.32558139534883\n",
            "client 3 76.63685152057245\n",
            "global test acc 85.43828264758497\n",
            "global round 2\n",
            "client 1 91.16279069767442\n",
            "client 2 86.83363148479427\n",
            "client 3 81.1449016100179\n",
            "global test acc 85.79606440071557\n",
            "global round 3\n",
            "client 1 91.91413237924866\n",
            "client 2 87.62075134168158\n",
            "client 3 82.1824686940966\n",
            "global test acc 88.87298747763865\n",
            "global round 4\n",
            "client 1 92.66547406082289\n",
            "client 2 89.94633273703042\n",
            "client 3 85.83184257602863\n",
            "global test acc 90.4830053667263\n",
            "global round 5\n",
            "client 1 93.52415026833631\n",
            "client 2 91.520572450805\n",
            "client 3 87.83542039355993\n",
            "global test acc 92.84436493738819\n",
            "global round 6\n",
            "client 1 93.13059033989266\n",
            "client 2 90.76923076923077\n",
            "client 3 87.79964221824686\n",
            "global test acc 92.95169946332737\n",
            "global round 7\n",
            "client 1 91.27012522361359\n",
            "client 2 89.37388193202148\n",
            "client 3 88.08586762075134\n",
            "global test acc 92.95169946332737\n",
            "global round 8\n",
            "client 1 91.37745974955277\n",
            "client 2 91.16279069767442\n",
            "client 3 85.9391771019678\n",
            "global test acc 92.95169946332737\n",
            "global round 9\n",
            "client 1 90.26833631484794\n",
            "client 2 91.55635062611806\n",
            "client 3 84.36493738819321\n",
            "global test acc 93.45259391771019\n",
            "global round 10\n",
            "client 1 90.55456171735241\n",
            "client 2 90.26833631484794\n",
            "client 3 86.5474060822898\n",
            "global test acc 93.45259391771019\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.random_aggregator)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K2EUE4vCew6C"
      },
      "outputs": [],
      "source": [
        "f_svm = Federated_SVM(n_clients = 3, val=False, n_iters=150,opt='batch_GD')\n",
        "f_svm.create_clients(clients_X,clients_y,X_test,y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3AFNWXVuezhk",
        "outputId": "3f2e26c3-f373-4b81-8609-d7e6543079cb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "global round 1\n",
            "client 1 78.64042933810376\n",
            "client 2 82.32558139534883\n",
            "client 3 76.63685152057245\n",
            "global test acc 89.3381037567084\n",
            "global round 2\n",
            "client 1 90.80500894454383\n",
            "client 2 88.87298747763865\n",
            "client 3 83.61359570661897\n",
            "global test acc 90.80500894454383\n",
            "global round 3\n",
            "client 1 92.4865831842576\n",
            "client 2 91.0912343470483\n",
            "client 3 86.47584973166369\n",
            "global test acc 91.73524150268337\n",
            "global round 4\n",
            "client 1 93.34525939177102\n",
            "client 2 91.91413237924866\n",
            "client 3 88.51520572450805\n",
            "global test acc 92.77280858676208\n",
            "global round 5\n",
            "client 1 93.84615384615384\n",
            "client 2 92.41502683363149\n",
            "client 3 90.16100178890876\n",
            "global test acc 93.30948121645795\n",
            "global round 6\n",
            "client 1 94.13237924865831\n",
            "client 2 92.84436493738819\n",
            "client 3 91.27012522361359\n",
            "global test acc 93.59570661896244\n",
            "global round 7\n",
            "client 1 94.38282647584974\n",
            "client 2 93.34525939177102\n",
            "client 3 92.20035778175313\n",
            "global test acc 93.7030411449016\n",
            "global round 8\n",
            "client 1 94.59749552772809\n",
            "client 2 93.84615384615384\n",
            "client 3 92.84436493738819\n",
            "global test acc 93.91771019677996\n",
            "global round 9\n",
            "client 1 94.77638640429338\n",
            "client 2 94.09660107334525\n",
            "client 3 93.38103756708408\n",
            "global test acc 94.2397137745975\n",
            "global round 10\n",
            "client 1 94.8479427549195\n",
            "client 2 94.2397137745975\n",
            "client 3 93.55992844364937\n",
            "global test acc 94.45438282647585\n"
          ]
        }
      ],
      "source": [
        "f_svm.fit(10,f_svm.average_aggregator)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "OEoVNkw4XOkc",
        "zKRqSYOeXdPx",
        "SSMoNotAhz8A",
        "hsFsh5QIiJRc",
        "VxJzKmEnj-RY",
        "mqQTKxHflCp0",
        "ujC1N29CrvmS",
        "lQLYCuk0rvmT",
        "qUY22RmCrvmU",
        "SBm1X_wQrvmX",
        "lFZmdlZdrvma",
        "stZxTwj7cYz7",
        "v_0EbN8Sc6E-",
        "NSN-WJV2d1IF"
      ],
      "name": "compare-Bi-Gradiant Federated aggregation",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}