FL_Attack_Test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import precision_score, recall_score, f1_score\n",
    "import pandas as pd\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_second_data():\n",
    "    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "\n",
    "    # Shuffle the training data\n",
    "    indices = np.arange(x_train.shape[0])\n",
    "    np.random.shuffle(indices)\n",
    "    x_train = x_train[indices]\n",
    "    y_train = y_train[indices]\n",
    "\n",
    "    # Normalize the data\n",
    "    X_train = x_train.reshape(-1, 28, 28, 1).astype('float32') / 255.0\n",
    "    X_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255.0\n",
    "\n",
    "    y_train = tf.keras.utils.to_categorical(y_train, 10)\n",
    "    y_test = tf.keras.utils.to_categorical(y_test, 10)\n",
    "\n",
    "    return X_train, y_train, X_test, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_second_data_non_iid():\n",
    "\n",
    "    def create_non_iid_data(x, y):\n",
    "\n",
    "        num_partitions=3\n",
    "\n",
    "        partitions = [[] for _ in range(num_partitions)]\n",
    "        labels = [[] for _ in range(num_partitions)]\n",
    "\n",
    "        class_distribution = [\n",
    "            [0, 1, 2, 3],\n",
    "            [4, 5, 6],\n",
    "            [7, 8, 9]\n",
    "        ]\n",
    "\n",
    "        for i in range(num_partitions):\n",
    "\n",
    "            indices = np.where(np.isin(y, class_distribution[i]))[0]\n",
    "            x_partition, _, y_partition, _ = train_test_split(x[indices], y[indices], test_size=0.5, random_state=42)\n",
    "            partitions[i] = x_partition\n",
    "            labels[i] = y_partition\n",
    "\n",
    "        return partitions, labels\n",
    "\n",
    "\n",
    "    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "\n",
    "    partitions, labels = create_non_iid_data(x_train, y_train)\n",
    "\n",
    "    x_train_non_iid = np.concatenate(partitions)\n",
    "    y_train_non_iid = np.concatenate(labels)\n",
    "\n",
    "    X_train = x_train_non_iid.reshape(-1, 28, 28, 1).astype('float32') / 255.0\n",
    "    X_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255.0\n",
    "\n",
    "    y_train = tf.keras.utils.to_categorical(y_train_non_iid, 10)\n",
    "    y_test = tf.keras.utils.to_categorical(y_test, 10)\n",
    "\n",
    "\n",
    "    return X_train, y_train, X_test, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_poisoning():\n",
    "\n",
    "    def flip_labels(y_train, label1, label2):\n",
    "\n",
    "        flipped_y_train = np.copy(y_train)\n",
    "        flipped_y_train[y_train == label1] = label2\n",
    "        flipped_y_train[y_train == label2] = label1\n",
    "        return flipped_y_train\n",
    "\n",
    "    def create_non_iid_partitions(x, y, num_partitions=3):\n",
    "\n",
    "        partitions = [[] for _ in range(num_partitions)]\n",
    "        labels = [[] for _ in range(num_partitions)]\n",
    "\n",
    "        class_distribution = [\n",
    "            [0, 1, 2, 3],\n",
    "            [4, 5, 6],\n",
    "            [7, 8, 9]\n",
    "        ]\n",
    "\n",
    "        for i in range(num_partitions):\n",
    "\n",
    "            indices = np.where(np.isin(y, class_distribution[i]))[0]\n",
    "            x_partition, _, y_partition, _ = train_test_split(x[indices], y[indices], test_size=0.5, random_state=42)\n",
    "            partitions[i] = x_partition\n",
    "            labels[i] = y_partition\n",
    "\n",
    "        return partitions, labels\n",
    "\n",
    "    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "\n",
    "    flipped_y_train = flip_labels(y_train, 1, 9)\n",
    "\n",
    "    partitions, labels = create_non_iid_partitions(x_train, flipped_y_train)\n",
    "\n",
    "    x_train_non_iid = np.concatenate(partitions)\n",
    "    y_train_non_iid = np.concatenate(labels)\n",
    "\n",
    "    x_train_non_iid = x_train_non_iid.reshape(-1, 28, 28, 1).astype('float32') / 255.0\n",
    "    x_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255.0\n",
    "\n",
    "    flipped_y_train_cat = tf.keras.utils.to_categorical(y_train_non_iid, 10)\n",
    "    y_test_cat = tf.keras.utils.to_categorical(y_test, 10)\n",
    "\n",
    "    return x_train_non_iid, flipped_y_train_cat, x_test, y_test_cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_second_model():\n",
    "\n",
    "    model = keras.Sequential([\n",
    "        layers.Conv2D(16, kernel_size=(5, 5), padding='same', input_shape=(28, 28, 1)),\n",
    "        layers.BatchNormalization(),\n",
    "        layers.ReLU(),\n",
    "        layers.MaxPooling2D(pool_size=(2, 2)),\n",
    "\n",
    "        layers.Conv2D(32, kernel_size=(5, 5), padding='same'),\n",
    "        layers.BatchNormalization(),\n",
    "        layers.ReLU(),\n",
    "        layers.MaxPooling2D(pool_size=(2, 2)),\n",
    "\n",
    "        layers.Flatten(),\n",
    "        layers.Dense(10)\n",
    "    ])\n",
    "\n",
    "    return model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Client:\n",
    "\n",
    "    def __init__(self, model, data):\n",
    "        self.model = model\n",
    "        self.data = data\n",
    "        self.local_weights = self.model.get_weights()\n",
    "\n",
    "    def train(self, epochs=5, batch_size=16):\n",
    "        self.model.set_weights(self.local_weights)\n",
    "        self.model.compile(optimizer='adam', loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy'])\n",
    "        self.model.fit(self.data[0], self.data[1], epochs=epochs, batch_size=batch_size, verbose=0)\n",
    "        self.local_weights = self.model.get_weights()\n",
    "        return self.local_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Server:\n",
    "    def __init__(self, model):\n",
    "        self.model = model\n",
    "\n",
    "    def aggregate_weights(self, client_weights):\n",
    "        new_weights = []\n",
    "        for weights in zip(*client_weights):\n",
    "            new_weights.append(np.mean(weights, axis=0))\n",
    "        self.model.set_weights(new_weights)\n",
    "\n",
    "    def evaluate(self, test_data):\n",
    "        self.model.compile(optimizer='adam', loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy'])\n",
    "        loss, accuracy = self.model.evaluate(test_data[0], test_data[1], verbose=0)\n",
    "        y_pred = np.argmax(self.model.predict(test_data[0]), axis=1)\n",
    "        y_true = np.argmax(test_data[1], axis=1)\n",
    "        recall = recall_score(y_true, y_pred, average='macro')\n",
    "        return loss, accuracy, recall\n",
    "\n",
    "    def get_metrics_per_class(self, test_data):\n",
    "        y_pred = np.argmax(self.model.predict(test_data[0]), axis=1)\n",
    "        y_true = np.argmax(test_data[1], axis=1)\n",
    "        precision_per_class = precision_score(y_true, y_pred, average=None, zero_division=0)\n",
    "        recall_per_class = recall_score(y_true, y_pred, average=None)\n",
    "        f1_per_class = f1_score(y_true, y_pred, average=None)\n",
    "        return precision_per_class, recall_per_class, f1_per_class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_clients(num_clients, num_poisoned_clients):\n",
    "\n",
    "    normal_data = (X_train, y_train)\n",
    "    poisoned_data = data_poisoning()\n",
    "\n",
    "    clients = []\n",
    "\n",
    "    for i in range(num_clients):\n",
    "\n",
    "        if i < num_poisoned_clients:\n",
    "\n",
    "            print(\"Poisoned Client\")\n",
    "\n",
    "            indices = np.arange(poisoned_data[0].shape[0])\n",
    "            np.random.shuffle(indices)\n",
    "            client_data = (poisoned_data[0][indices][i::num_clients], poisoned_data[1][indices][i::num_clients])\n",
    "        else:\n",
    "            indices = np.arange(normal_data[0].shape[0])\n",
    "            np.random.shuffle(indices)\n",
    "            client_data = (normal_data[0][indices][i::num_clients], normal_data[1][indices][i::num_clients])\n",
    "        clients.append(Client(get_second_model(), client_data))\n",
    "\n",
    "    return clients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, X_test, y_test = get_second_data_non_iid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Poisoned Client\n"
     ]
    }
   ],
   "source": [
    "num_clients = 7\n",
    "num_poisoned_clients = 1\n",
    "clients_per_round = 4\n",
    "\n",
    "clients = initialize_clients(num_clients, num_poisoned_clients)\n",
    "\n",
    "server = Server(get_second_model())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 2s 7ms/step\n",
      "313/313 [==============================] - 2s 6ms/step\n",
      "Round 1\n",
      "313/313 [==============================] - 8s 23ms/step\n",
      "313/313 [==============================] - 6s 19ms/step\n",
      "Round 2\n",
      "313/313 [==============================] - 5s 15ms/step\n",
      "313/313 [==============================] - 5s 16ms/step\n",
      "Round 3\n",
      "313/313 [==============================] - 3s 10ms/step\n",
      " 84/313 [=======>......................] - ETA: 2s"
     ]
    }
   ],
   "source": [
    "num_rounds = 5\n",
    "epochs = 5\n",
    "batch_size = 16\n",
    "loss_history = []\n",
    "accuracy_history = []\n",
    "recall_history = []\n",
    "precision_history = []\n",
    "recall_history_per_class = []\n",
    "f1_history = []\n",
    "\n",
    "for round_num in range(num_rounds):\n",
    "    selected_clients = random.sample(clients, clients_per_round)\n",
    "    client_weights = [client.train(epochs=epochs) for client in selected_clients]\n",
    "    server.aggregate_weights(client_weights)\n",
    "    loss, accuracy, recall = server.evaluate((X_test, y_test))\n",
    "    precision_per_class, recall_per_class, f1_per_class = server.get_metrics_per_class((X_test, y_test))\n",
    "\n",
    "    accuracy_history.append(accuracy)\n",
    "    loss_history.append(loss)\n",
    "    recall_history.append(recall)\n",
    "    precision_history.append(precision_per_class)\n",
    "    recall_history_per_class.append(recall_per_class)\n",
    "    f1_history.append(f1_per_class)\n",
    "\n",
    "    print(f\"Round {round_num+1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_accuracy = accuracy_history[-1]\n",
    "final_recall = recall_history[-1]\n",
    "final_precision_per_class = precision_history[-1]\n",
    "final_recall_per_class = recall_history_per_class[-1]\n",
    "accuracy_class_1 = final_precision_per_class[1]\n",
    "accuracy_class_9 = final_precision_per_class[9]\n",
    "recall_class_1 = final_recall_per_class[1]\n",
    "recall_class_9 = final_recall_per_class[9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Final Accuracy: {final_accuracy}\")\n",
    "print(f\"Final Recall: {final_recall}\")\n",
    "print(f\"Final Accuracy for Class 1: {accuracy_class_1}\")\n",
    "print(f\"Final Accuracy for Class 9: {accuracy_class_9}\")\n",
    "print(f\"Final Recall for Class 1: {recall_class_1}\")\n",
    "print(f\"Final Recall for Class 9: {recall_class_9}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounds = range(1, num_rounds + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(18, 10))\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(rounds, accuracy_history, label='Accuracy')\n",
    "plt.xlabel('Round')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Model Accuracy Over Rounds')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(18, 10))\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(rounds, accuracy_history, label='Loss')\n",
    "plt.xlabel('Round')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Model Loss Over Rounds')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(18, 10))\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(rounds, recall_history, label='Recall')\n",
    "plt.xlabel('Round')\n",
    "plt.ylabel('Recall')\n",
    "plt.title('Model Recall Over Rounds')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(18, 10))\n",
    "plt.subplot(2, 2, 3)\n",
    "precision_history = np.array(precision_history)\n",
    "for i in range(precision_history.shape[1]):\n",
    "    plt.plot(rounds, precision_history[:, i], label=f'Class {i}')\n",
    "plt.xlabel('Round')\n",
    "plt.ylabel('Precision')\n",
    "plt.title('Class Precision Over Rounds')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(18, 10))\n",
    "plt.subplot(2, 2, 4)\n",
    "recall_history_per_class = np.array(recall_history_per_class)\n",
    "for i in range(recall_history_per_class.shape[1]):\n",
    "    plt.plot(rounds, recall_history_per_class[:, i], label=f'Class {i}')\n",
    "plt.xlabel('Round')\n",
    "plt.ylabel('Recall')\n",
    "plt.title('Class Recall Over Rounds')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}