Federated Learning-Malware detection 2022 (DWFedAvg).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7c75c9f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")  # \"error\", \"ignore\", \"always\", \"default\", \"module\" or \"once\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "173907af",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import os\n",
    "# from imutils import paths\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Activation\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.optimizers import SGD\n",
    "\n",
    "from sklearn import preprocessing\n",
    "\n",
    "from federated_utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "be5ae943",
   "metadata": {},
   "outputs": [],
   "source": [
    "#declear path to your data\n",
    "drebin_data_path = 'data/drebin.csv'\n",
    "malgenome_data_path = 'data/malgenome.csv'\n",
    "kronodroid_data_path = 'data/kronodroid.csv'\n",
    "TUANDROMD_data_path='data/TUANDROMD.csv'\n",
    "\n",
    "\n",
    "\n",
    "Drebin_data = pd.read_csv(drebin_data_path, header = None)\n",
    "\n",
    "Malgenome_data = pd.read_csv(malgenome_data_path)\n",
    "\n",
    "Tuandromd_data=pd.read_csv(TUANDROMD_data_path)\n",
    "\n",
    "kronodroid_data=pd.read_csv(kronodroid_data_path)\n",
    "Kronodroid_data = kronodroid_data.iloc[:,range(1,kronodroid_data.shape[1])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4bf76d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===================================================================================================\n",
      "Working with: Drebin\n",
      "===================================================================================================\n",
      "---------------------------------------------\n",
      "No. of Clients: 5\n",
      "No. of Rounds: 10\n",
      "---------------------------------------------\n",
      "|=======================|\n",
      "|   DWFedAvg  2022      |\n",
      "|=======================|\n",
      "94/94 [==============================] - 0s 1ms/step\n",
      "comm_round: 0 | global_acc: 97.640% | global_loss: 0.5783339142799377 | global_f1: 0.967741935483871 | global_precision: 0.9752747252747253 | global_recall: 0.9603246167718665 | global_auc: 0.9958746262448415| flobal_FPR: 0.03967538322813345 \n"
     ]
    }
   ],
   "source": [
    "n_clients = [5,10,15]\n",
    "n_round = [10,20]\n",
    "\n",
    "all_avg =[]\n",
    "\n",
    "all_std =[]\n",
    "\n",
    "# dataset = ['Drebin', 'Malgenome', 'Kronodroid', 'Tuandromd' ]\n",
    "dataset = ['Drebin', 'Malgenome', 'Kronodroid' ]\n",
    "\n",
    "\n",
    "\n",
    "for d in range(0,len(dataset)):\n",
    "    if d == 0:\n",
    "        use_data = Drebin_data\n",
    "    elif d==1:\n",
    "        use_data = Malgenome_data\n",
    "    elif d==2:\n",
    "        use_data = Kronodroid_data\n",
    "    elif d==3:\n",
    "        use_data = Tuandromd_data\n",
    "        \n",
    "        \n",
    "    print('===================================================================================================')\n",
    "    print('Working with:',dataset[d])\n",
    "    print('===================================================================================================')\n",
    "\n",
    "    for r in n_round: #number of rounds loop\n",
    "        comms_round = r\n",
    "        for cl in n_clients: #number of clients loop\n",
    "            number_of_clients = cl\n",
    "\n",
    "            # from sklearn.utils import shuffle\n",
    "            # use_data = shuffle(use_data)\n",
    "            # use_data\n",
    "            print('---------------------------------------------')\n",
    "            print('No. of Clients:', number_of_clients)\n",
    "            print('No. of Rounds:', comms_round)\n",
    "            print('---------------------------------------------')\n",
    "\n",
    "\n",
    "            features = np.array(use_data.iloc[:,range(0,use_data.shape[1]-1)]) #feature set\n",
    "\n",
    "            labels = use_data.iloc[:,-1] #labels --> B : Benign and S\n",
    "\n",
    "\n",
    "            #Do feature scaling \n",
    "\n",
    "\n",
    "            X = preprocessing.StandardScaler().fit(features).transform(features)\n",
    "\n",
    "\n",
    "            #binarize the labels\n",
    "            lb = LabelBinarizer()\n",
    "            y = lb.fit_transform(labels)\n",
    "\n",
    "\n",
    "            #split data into training and test set\n",
    "            X_train, X_test, y_train, y_test = train_test_split(X, \n",
    "                                                                y, shuffle=True,\n",
    "                                                                test_size=0.2, \n",
    "                                                                random_state=100)\n",
    "\n",
    "\n",
    "\n",
    "            #create clients -- Horizontal FL\n",
    "            clients = create_clients(X_train, y_train, num_clients=number_of_clients, initial='client')\n",
    "\n",
    "            #process and batch the training data for each client\n",
    "            clients_batched = dict()\n",
    "            for (client_name, data) in clients.items():\n",
    "                clients_batched[client_name] = batch_data(data)\n",
    "\n",
    "\n",
    "                #process and batch the test set  \n",
    "            test_batched = tf.data.Dataset.from_tensor_slices((X_test, y_test)).batch(len(y_test))\n",
    "\n",
    "\n",
    "\n",
    "            #==============================================\n",
    "            # DW-FedAvg 2022\n",
    "            #==============================================\n",
    "            #-----------------------------------------------\n",
    "\n",
    "\n",
    "            all_results=list()\n",
    "\n",
    "            #create optimizer\n",
    "            lr = 0.01 \n",
    "            loss='binary_crossentropy'\n",
    "            metrics = ['accuracy']\n",
    "            optimizer = SGD(learning_rate=lr, \n",
    "                            decay=lr / comms_round, \n",
    "                            momentum=0.9\n",
    "                           )\n",
    "\n",
    "            #initialize global model\n",
    "            smlp_global = SimpleMLP()\n",
    "            global_model = smlp_global.build(X.shape[1],1)\n",
    "\n",
    "            global_DWFed_Avg_index = np.ones((1,number_of_clients))/number_of_clients # [0.3 0.3 0.3]\n",
    "\n",
    "            prev_local_model_test_performance = []\n",
    "\n",
    "            current_local_model_test_performance = []\n",
    "\n",
    "            beta= 0.2\n",
    "            #-----------------------------------------------\n",
    "\n",
    "\n",
    "            print('|=======================|')\n",
    "            print('|   DWFedAvg  2022      |')\n",
    "            print('|=======================|')\n",
    "\n",
    "            #commence global training loop\n",
    "            for comm_round in range(comms_round):\n",
    "\n",
    "                # get the global model's weights - will serve as the initial weights for all local models\n",
    "                global_weights = global_model.get_weights()\n",
    "\n",
    "                #initial list to collect local model weights after scalling\n",
    "                scaled_local_weight_list = list()\n",
    "\n",
    "                #randomize client data - using keys\n",
    "                client_names= list(clients_batched.keys())\n",
    "                random.shuffle(client_names)\n",
    "\n",
    "                #loop through each client and create new local model\n",
    "                for client in client_names:\n",
    "                    smlp_local = SimpleMLP()\n",
    "                    local_model = smlp_local.build(X.shape[1],1)\n",
    "                    local_model.compile(loss=loss, \n",
    "                                  optimizer=optimizer, \n",
    "                                  metrics=metrics)\n",
    "\n",
    "                    #set local model weight to the weight of the global model\n",
    "                    local_model.set_weights(global_weights)\n",
    "\n",
    "                    #============================================================    \n",
    "                    # Custom Code added HERE for DWFedAvg\n",
    "                    #============================================================\n",
    "                    x_data = list()\n",
    "                    y_data = list()\n",
    "                    for local_i in clients_batched[client]:\n",
    "                        for local_j in local_i[0].numpy():\n",
    "                            x_data.append(local_j)\n",
    "                        for local_k in local_i[1].numpy():\n",
    "                            y_data.append(local_k[0])\n",
    "\n",
    "                    x_data = np.array(x_data) #x_TRAIN for corresponding client\n",
    "                    y_data = np.array(y_data) #y_TRAIN for corresponding client        \n",
    "\n",
    "                    #============================================================\n",
    "\n",
    "                    #fit local model with client's data\n",
    "                    history = local_model.fit(x_data,y_data, epochs=32, verbose=0, validation_split=0.2)\n",
    "\n",
    "                    current_local_model_test_performance.append(np.mean(history.history['val_accuracy'])) #saving local model test performmance\n",
    "\n",
    "\n",
    "\n",
    "                    #scale the model weights and add to list\n",
    "                    scaling_factor = weight_scalling_factor(clients_batched, client)\n",
    "                    scaled_weights = scale_model_weights(local_model.get_weights(), scaling_factor)\n",
    "                    scaled_local_weight_list.append(scaled_weights)\n",
    "\n",
    "                    #clear session to free memory after each communication round\n",
    "                    K.clear_session()\n",
    "\n",
    "\n",
    "\n",
    "                if comm_round ==0:\n",
    "                    prev_local_model_test_performance = current_local_model_test_performance\n",
    "\n",
    "                else:\n",
    "                    for jj in range(0,len(prev_local_model_test_performance)):\n",
    "\n",
    "                        #performance immproved\n",
    "                        if (current_local_model_test_performance[jj]>prev_local_model_test_performance[jj]):\n",
    "                            #print('YES')\n",
    "                            global_DWFed_Avg_index[jj] = global_DWFed_Avg_index[jj] + global_DWFed_Avg_index[jj]*beta\n",
    "\n",
    "                        #performance degraded\n",
    "                        elif (current_local_model_test_performance[jj]<prev_local_model_test_performance[jj]):\n",
    "                            #print('NO')\n",
    "                            global_DWFed_Avg_index[jj] = global_DWFed_Avg_index[jj] - global_DWFed_Avg_index[jj]*beta\n",
    "\n",
    "\n",
    "                            #print('NO CHANGE')\n",
    "\n",
    "                    global_DWFed_Avg_index = global_DWFed_Avg_index / sum(global_DWFed_Avg_index) #Weight scaling\n",
    "\n",
    "\n",
    "            #     print(global_DWFed_Avg_index)\n",
    "\n",
    "\n",
    "\n",
    "                #to get the average over all the local model, we simply take the sum of the scaled weights\n",
    "                average_weights = sum_scaled_weights(scaled_local_weight_list, global_DWFed_Avg_index)\n",
    "                #print(scaled_local_weight_list)\n",
    "\n",
    "                #update global model \n",
    "                global_model.set_weights(average_weights)\n",
    "\n",
    "                #test global model and print out metrics after each communications round\n",
    "                for(X_test, Y_test) in test_batched:\n",
    "                    global_acc, global_loss, global_f1, global_precision, global_recall, global_auc, global_fpr = test_model(X_test, Y_test, global_model, comm_round)\n",
    "                    all_results.append([global_acc,global_loss.numpy(),global_f1, global_precision, global_recall, global_auc, global_fpr])\n",
    "\n",
    "\n",
    "\n",
    "            all_R = pd.DataFrame(all_results, columns=['global_acc', 'global_loss', 'global_f1', 'global_precision', 'global_recall', 'global_auc', 'global_fpr'])\n",
    "            flname = 'results/round-'+str(r)+'/'+str(cl)+'-clients/DW-FedAvg-'+dataset[d]+'-results.csv'\n",
    "            all_R.to_csv(flname, index=None)\n",
    "            \n",
    "            all_avg.append(np.concatenate(([dataset[d],r,cl],np.mean(all_results,axis=0)))) #Storing avg values for each dataset\n",
    "            all_std.append(np.concatenate(([dataset[d],r,cl],np.std(all_results,axis=0)))) #Storing std values sfor each dataset\n",
    "            \n",
    "\n",
    "            \n",
    "ALL_AVG = pd.DataFrame(all_avg, columns = ['global_acc', 'global_loss', 'global_f1', 'global_precision', 'global_recall', 'global_auc', 'global_fpr'])\n",
    "ALL_AVG.to_csv('DW-FedAvg-all-avg-results.csv')\n",
    "\n",
    "ALL_STD = pd.DataFrame(all_std, columns = ['global_acc', 'global_loss', 'global_f1', 'global_precision', 'global_recall', 'global_auc', 'global_fpr'])\n",
    "ALL_STD.to_csv('DW-FedAvg-all-std-results.csv')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "548181db",
   "metadata": {},
   "outputs": [],
   "source": [
    "ALL_AVG = pd.DataFrame(all_avg, columns = ['Dataset','Rounds','no-clients','global_acc', 'global_loss', 'global_f1', 'global_precision', 'global_recall', 'global_auc', 'global_fpr'])\n",
    "ALL_AVG.to_csv('DW-FedAvg-all-avg-results.csv')\n",
    "\n",
    "ALL_STD = pd.DataFrame(all_std, columns = ['Dataset','Rounds','no-clients','global_acc', 'global_loss', 'global_f1', 'global_precision', 'global_recall', 'global_auc', 'global_fpr'])\n",
    "ALL_STD.to_csv('DW-FedAvg-all-std-results.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "2fe0c3d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABAyElEQVR4nO3deXxU9bn48c+TyUYgJCSEHQnIoqwhYVNEwbqgViiiBW1d6ILeSmvtra3eeq21P29r9Xq11VZtS9VWA7iAaLVukOIGshgQkJ2AAWQPSQgh2/P745zEIWYjM2dmkjzv12tec+ac7/nOM2dOzpNzvme+X1FVjDHGGC9EhTsAY4wxrZclGWOMMZ6xJGOMMcYzlmSMMcZ4xpKMMcYYz0SHO4BQSE5O1v79+4c7jEYdP36c9u3bhzuMBrWEGMHiDDaLM7haSpyrV68+pKppgdTRJpJM165dWbVqVbjDaFROTg4TJ04MdxgNagkxgsUZbBZncLWUOEVkV6B12OUyY4wxnmkTZzLGBFNpeSWf7C5g95HjjOidzMAuiURFSbjDMiYiWZIxphGl5ZWs2X2U5TuOsGLHYT75vICyiqqa5ckJMYztm8K4fqmM7ZvKWd0s6RhTLSxJRkQmA48CPuAvqvrbWsv7AHOBNOAI8G1VzXeXPQBc4Rb9tarOD1ngpk04UeYklRU7DrN8xxFyPy+grLKKKIEhPZK48Zw+jOuXSnrn9uTuLmD5jsMs33mYNzfsB5ykMyY9hbH9UhnXL4Wzu3W0pGParJAnGRHxAY8DFwP5wEoRWayqG/2KPQQ8q6rPiMiFwG+A60XkCiATyADigBwReUNVC0P6IUyrUlJWwZpdbrLYcZi1+QWUVypRAsN6JjFrfDpj+6UwKj2FjvExp6x7ZloHpmf1AmBPwQk3MR1mxc4jvLXRSTpJ7WIYnZ7CuH7O2c7Z3Tvis6Rj2ohwnMmMAbap6g4AEZkHTAX8k8xg4Cfu9FJgkd/8ZapaAVSIyDpgMrAgBHGbVuL4yQpW7zrKip3OmcrazwuoqFJ8UcLQnkl857y+jOubyqj0TiTWSioN6Zncjqsye3FVppN09hacYMXOw6zYcYTlOw7zzmdO0kmMj2Zs3xTG9k3lxMEKorYc9ORzBtP6QxZnMIUizjNSEkjvHP7bpCXUvTCLyNXAZFX9nvv6emCsqs7xK/M8sEJVHxWRq4CXgM5AFvBLnLOgBOBj4HFV/d863mc2MBsgLS0ta8GCyM9DxcXFdOjQIdxhNKglxAinxllaoWw9WsmmI1VsPlrJzmNVVCpECfTtGMWgFB9npUQxoJOPdtHenWEcLa1i05EqNh2pZNORSvaXWA/oxjtXnhnD9AGxAdUxadKk1ao6KpA6IrXh/6fAYyJyE7AM2ANUqupbIjIa+BA4CHwEVNZVgao+BTwFMGjQIG0J96S3hHvnW0KMxScrmLs4hxJfN5bvOMyne45RWaVERwnDeyVxc0YqY/ulktWnEx3iwvcnsL+wlMXvfkBm5siwxdBUa9Z8YnEGUSji7JbUjp7J7Tx9j6YIx1/YHqC33+te7rwaqroXuApARDoA01W1wF12P3C/u+x5YIv3IZtIVlRazqq8oyx3L3+td5NKjG8Hw3slc8sF/RjnJpWE2Mj5v6prx3gGdPKR1Scl3KE0qminxRlMLSXOYAjHX9xKYICI9MVJLjOB6/wLiEhn4IiqVgF34dxpVn3TQLKqHhaR4cBw4K1QBm/Cr7C0nFV5R2raOj7dc4wqhRifkNE7mR9MPJP4wnxmTbkgopKKMW1RyP8CVbVCROYAb+LcwjxXVTeIyH3AKlVdDEwEfiMiinO57FZ39RjgPREBKMS5tbki1J/BhNaxE05Sqb5ra72bVGJ9UWT0TmbOpP6M65fKyDM60S7WB0BOzj5LMMZEgLD8Farq68Drtebd4zf9IvBiHeuV4txhZlqxYyXlfJzn/PBx+c7DbNhbiCrERkcxsncyP7xwAGP7pZB5RifiY3zhDtcY0wD7V8+EXUFJGR/vPOL8on7nYTbu+zKpZJ6RzG1fG8C4fqlk9E62pGJMC2NJxoTc0eNlrNh5pOZ3Kpu+cJJKXHQUWX068eOvDWRcvxRGWFIxpsWzJGM8d+R4GR+7CWX5jsNs+qIIgPgYJ6n85KKBjO2XyojeScRFW1IxpjWxJGOC7lDxST7eeaSm76/N+52k0i7GR1afTvznxd0558xUhvdKJjbaRpswpjWzJGMCdrDopNum4vTbtfVAMeAklVHpnZiS0YNx/VIY1tOSijFtjSUZc9oOFJXW/EZlxc4jbHOTSkKsj1HpKUzL7MnYvqkM75VEjM+SijFtmSUZ02RvbfiCe98rYe+/3gWgfayP0X1TmJ7Zi3H9Uhja05KKMeZUlmRMo8oqqvjNG5/xtw/y6J0YxV2XDWJsv1SG9uhItCUVY0wDLMmYBu0+XMKc7DWsyz/GTeemM77DAS6+4Mxwh2WMaSEsyZh6vfHpPn724jpE4IlvZzF5aDdyciJ/rA5jTOQIKMmIyJXAP92OLE0rUVpeyf+8/hnPfrSLEb2TeezakfROSQh3WMaYFijQM5kZwCMi8hJOR5ebghCTCaOdh44z5/k1bNhbyPcn9OWOS8+y246NMc0WUJJR1W+LSEfgWuBpt9fkvwHZqloUjABN6Cxeu5f/evlTon3CX24YxUWDu4Y7JGNMCxfwv6iqWojTY/I8oDswDVgjIj8MtG4TGqXlldz18qf8KPsTBnVL5J8/mmAJxhgTFIG2yUwBZgH9gWeBMap6QEQSgI3AHwIP0Xhp+8Fibn1uDZu+KOLmC/rx00sG2W9djDFBE2ibzHTg/1R1mf9MVS0Rke8GWLfx2MJP8vnFwvXEx/j426zRTBrUJdwhGWNamUCTzL3AvuoXItIO6Kqqear6boB1G4+cKKvkl4vXs2BVPmPSU/j9tSPplhQf7rCMMa1QoEnmBeBcv9eV7rzRAdZrPLJ1fxE/eG4N2w4WM2dSf3580QD71b4xxjOBJploVS2rfqGqZSISG2CdxiMvrc7n7kXrSYj18ex3xjBhQFq4QzLGtHKB/gt70G38B0BEpgKHAqzTeGDFjsP85wtrGdE7iTdum2AJxhgTEoGeydwCPCcijwECfA7cEHBUJqgqq5RfvbqRHknx/O2mMbSLtdEnjTGhEeiPMbcD40Skg/u6OChRmaB6YdXnbNxXyO+vHWkJxhgTUgF3kCkiVwBDgHgRAUBV7wu0XhMchaXlPPTWZkb16cSVw7uHOxxjTBsTUJuMiDyB03/ZD3Eul10D9AlCXCZIHluyjUPFZdxz5WCq/wkwxphQCbTh/1xVvQE4qqq/As4BBgYelgmGnYeO87cPdnJ1Vi+G90oOdzjGmDYo0CRT6j6XiEgPoByn/zITAe7/52fE+qL42aWDwh2KMaaNCjTJvCoiycCDwBogD3g+wDpNELy/9RDvfLafH0zqT5eO9mt+Y0x4NLvhX0SigHdVtQB4SUReA+JV9ViwgjPNU1FZxX2vbaB3Sju+e17fcIdjjGnDmn0m446G+bjf65NNTTAiMllENovINhG5s47lfUTkXRFZJyI5ItLLb9nvRGSDiHwmIr8Xa83+iuyPd7NlfzG/uPxs4mPslmVjTPgEernsXRGZfjoHehHx4SSny4DBwLUiMrhWsYeAZ1V1OHAf8Bt33XOB8cBwYChOH2kXBPgZWpVjJeU8/PYWxvVL4dIh3cIdjjGmjQs0ydyM0yHmSREpFJEiESlsZJ0xwDZV3eH2ezYPmFqrzGBgiTu91G+5AvFALBAHxAD7A/wMrcoj727h2Ily7vn6ELtl2RgTdqKqoX1DkauByar6Pff19cBYVZ3jV+Z5YIWqPioiVwEvAZ1V9bCIPAR8D+d3OY+p6i/qeZ/ZwGyAtLS0rAULFnj6uYKhuLiYDh06NHv9vcVV/PcHJ5jQM5qbhsYFMbIvBRpjqFicwWVxBldLiXPSpEmrVXVUIHUEOjLm+XXNrz2IWTP8FHhMRG4ClgF7gEoR6Q+cDVS30bwtIhNU9b06YngKeApg0KBBOnHixABD8l5OTg6BxHnj3I9JiC3noZsm0rmDN0km0BhDxeIMLoszuFpKnMEQaLcyd/hNx+NcClsNXNjAOnuA3n6ve7nzaqjqXuAqALdftOmqWiAi3weWV/eRJiJv4PwA9CtJpq1ZuukA/95ykF9cfrZnCcYYY05XQG0yqnql3+NinMb4o42sthIYICJ93bFnZgKL/QuISGf3FmmAu4C57vRu4AIRiRaRGJxG/88C+QytQXllFb/+50b6dm7PjeemhzscY4ypEewhEfNxLmfVS1UrgDnAmzgJYoGqbhCR+/zGppkIbBaRLUBX4H53/ovAduBTYC2wVlVfDfJnaHGe/WgXOw4e5xeXn01stI1yaYyJHIG2yfwB544vcBJWBs4v/xukqq8Dr9ead4/f9Is4CaX2epU4d7QZ15HjZTz6zhYmDOjM187uEu5wjDHmFIG2yazym64AslX1gwDrNKfh4bc3c7yskv/+uvWybIyJPIEmmReBUvcMAxHxiUiCqpYEHpppzKYvCnl+xW6uH9eHgV0Twx2OMcZ8RcC/+Afa+b1uB7wTYJ2mCVSVX7+2kcT4GH58kY2uYIyJTIEmmXj/IZfd6YQA6zRN8PbG/Xyw7TC3XzSATu1jwx2OMcbUKdAkc1xEMqtfiEgWcCLAOk0jTlZUcv/rn9G/Swe+Nc4GIjXGRK5A22R+DLwgIntxunnphjMcs/HQ3z7IY9fhEp75zhhifHbLsjEmcgWUZFR1pYicBVQPvbhZVcsDD8vU52DRSR5bso0Lz+rCBQPTwh2OMcY0KKB/g0XkVqC9qq5X1fVABxH5QXBCM3V56M3NlJZX8osrGvzNqzHGRIRAr7V83x0ZEwBVPQp8P8A6TT3W7znGgtWfc9O56ZyZFvk9uBpjTKBJxuc/YJk7IJnd6uQBVeW+VzfSKSGWH35tQLjDMcaYJgm04f9fwHwRedJ9fTPwRoB1Rpzdh0soKa/w/H0+L6pi0xd1j/m2Ku8oH+cd4f5pQ0lqF+N5LMYYEwyBJpmf4wwMdov7eh3OHWatxhP/3s5v39gUujf8oP5RC87qlsjM0WeELhZjjAlQoHeXVYnICuBM4JtAZ5xRLFuFnM0HeOBfm7hkcFemjezp+fut37CBoUOG1Lv8nDNT8UVZ/2TGmJajWUlGRAYC17qPQ8B8AFWdFLzQwmvnoeP8KPsTzurWkUdmZpAQG+hJX+PaHd7MxGHdPX8fY0KpvLyc/Px8SktLPX+vpKQkPvss8oeYirQ44+Pj6dWrFzExwb8U39wj5yac0Si/rqrbAETk9qBFFWbFJyuY/ewqfFHCU9dnhSTBGNNa5efnk5iYSHp6uuc9hRcVFZGYGPmdxUZSnKrK4cOHyc/Pp2/fvkGvv7l3l10F7AOWisifReRrOL/4b/GqqpSfzM9lx6HjPHZdJr1TrCs2YwJRWlpKamqqDUURoUSE1NRUz840m5VkVHWRqs4EzgKW4nQv00VE/iQilwQxvpB7bOk23tq4n/+6/GzG9+8c7nCMaRUswUQ2L7+fgH4no6rHVfV5Vb0S6AV8gnPHWYv09sb9PPz2FqaN7Ml3xqeHOxxjjGnxgta7oqoeVdWnVPVrwaozlLYdKOb2+bkM7dmR31w1zP7zMqaVWbRoESLCpk3e/iThjjvuYMiQIdxxxx2nzH/66adJS0sjIyOD8ePHc8MNNzS5znvvvZeHHnqo5nVFRQVpaWnceeedQYvbK9aFL1BYWs7sZ1cRFx3Fk9ePIj7GF+6QjDFBlp2dzXnnnUd2dran7/PUU0+xbt06Hnzwwa8smzFjBrm5uXzwwQc8++yzzX6Pt99+m4EDB/LCCy+gqoGE67k2n2SqqpTb5+Wy+0gJf/xWJj2T2zW+kjGmRSkuLub999/nr3/9K/PmzauZX1lZyU9/+lOGDh3K8OHD+cMf/gDAypUrOffccxkxYgRjxoyhqKjolPpUlTvuuIOhQ4cybNgw5s+fD8CUKVMoLi4mKyurZl5jHnzwQUaPHs3w4cP55S9/WTP//vvvZ+DAgZx33nls3rz5lHWys7O57bbbOOOMM/joo4+oqqoiPT2dgoKCmjIDBgxg//79bN++nXHjxjFs2DDuvvtuOnQIbb+Hbf7e3Efe2cK7mw5w39QhjO2XGu5wjGnVfvXqBjburbvrpOYa3KMjv7yy/h8xA7zyyitMnjyZgQMHkpqayurVq8nKyuKpp54iLy+P3NxcoqOjOXLkCGVlZcyYMYP58+czevRoCgsLadfu1H8+X375ZXJzc1m7di2HDh1i9OjRnH/++SxevJgOHTqQm5tbZxzz58/n/fffp6qqittvv52ePXuydetWPv74Y1SVKVOmsGzZMtq3b8+8efPIzc2loqKCzMxMsrKyAOduvXfeeYcnn3ySgoICsrOzOffcc5k6dSoLFy5k1qxZrFixgj59+tC1a1e++93vctttt3HttdfyxBNPBGWbn442fSbzr/X7+P2SbXxzVC+utxEmjWm1srOzmTlzJgAzZ86suWT2zjvvcPPNNxMd7fy/nZKSwubNm+nevTujR48GoGPHjjXLq73//vtce+21+Hw+unbtygUXXMDKlSsbjcP/ctmsWbN46623eOuttxg5ciSZmZls2rSJrVu38t577zFt2jQSEhLo2LEjU6ZMqanjtddeY9KkSbRr147p06ezaNEiKisraxIjwLx585gxwxk/8qOPPuKaa64B4LrrrgtkMzZLmz2T2fxFET9ZsJaM3sncN3WoNfQbEwKNnXF44ciRIyxZsoRPP/0UEaGyshIRqbPNJNRUlbvuuoubb775lPmPPPJIvetkZ2fz/vvvk56eDsDhw4dZsmQJF110Edu2bePgwYMsWrSIu+++28PIm65NnskcKyln9t9X0T4umie+nWUN/ca0Yi+++CLXX389u3btIi8vj88//5y+ffvy3nvvcfHFF/Pkk09SUeH0sn7kyBEGDRrEvn37as5MioqKapZXmzBhAvPnz6eyspKDBw+ybNkyxowZc9qxXXrppcydO5fi4mIA9uzZw4EDBzj//PNZtGgRJ06coKioiFdffRWAwsJC3nvvPXbv3k1eXh55eXk8/vjjZGdnIyJMmzaNn/zkJ5x99tmkpjqX/8eNG8dLLzldSvq3R4VKm0sylVXKD+d9wt6CEzzx7Uy6JcWHOyRjjIeys7OZNm3aKfOmT59OdnY23/ve9zjjjDMYPnw4I0aM4Pnnnyc2Npb58+fzwx/+kBEjRnDxxRd/5dfw06ZNq1nnwgsv5He/+x3dup1+B/SXXHIJ1113Heeccw7Dhg3j6quvpqioiMzMTGbMmMGIESO47LLLai7dLVy4kAsvvJC4uLiaOqZOncqrr77KyZMnmTFjBv/4xz9qLpWBc1b08MMPM3z4cLZt20ZSUtJpxxkQVW31j4EDB2q137z+mfb5+Wv6/IpdGmmWLl0a7hAa1RJiVLU4gy2QODdu3Bi8QBpRWFgYsvcKRCjjPH78uFZVVamqanZ2tk6ZMqXOcnV9T8AqDfD426baZF5du5cn/r2db409g2vH2LgsxpjWb/Xq1cyZMwdVJTk5mblz54b0/cOSZERkMvAo4AP+oqq/rbW8DzAXSAOOAN9W1XwRmQT8n1/Rs4CZqrqosffcuLeQO15cy6g+ncLS+GiMMeEwYcIE1q5dG7b3D3mbjIj4gMeBy4DBwLUiMrhWsYeAZ1V1OHAf8BsAVV2qqhmqmgFcCJQAbzX2nlUKs/++iuR2sfzx25nERre5pihjwkoj/FfpbZ2X3084jrZjgG2qukNVy4B5wNRaZQYDS9zppXUsB7gaeENVSxp7wwMlVRwoOsmT12fRJdEa+o0Jpfj4eA4fPmyJJkKpO55MfLw3x8ZwXC7rCXzu9zofGFurzFqcMWseBaYBiSKSqqqH/crMBB5uyhuWVsL93xjKiN7JzQ7aGNM8vXr1Ij8/n4MHD3r+XqWlpZ4dLIMp0uKsHhnTCxLq/y5E5Gpgsqp+z319PTBWVef4lekBPAb0BZYB04GhqlrgLu8OrAN6qGp5Pe8zG5gN0KFr76xX5zW/M7pQKS4uDnm/QqerJcQIFmewWZzB1VLinDRp0mpVHRVQJYHenna6D+Ac4E2/13cBdzVQvgOQX2vebcBTTX3PAX63MEeylnA7a0uIUdXiDDaLM7haSpwE4RbmcLTJrAQGiEhfEYnFuey12L+AiHQWkerY7sK508zftUCT++u2DmOMMSY8Qp5kVLUCmAO8CXwGLFDVDSJyn4hU9wI3EdgsIluArsD91euLSDrQG/h3KOM2xhhz+kLeJhMOIlIEbG60YPh1Bg6FO4hGtIQYweIMNoszuFpKnINUNTGQCtrKL/43a6CNVyEgIqsiPc6WECNYnMFmcQZXS4oz0DrsV4nGGGM8Y0nGGGOMZ9pKknkq3AE0UUuIsyXECBZnsFmcwdVm4mwTDf/GGGPCo62cyRhjjAkDSzLGGGM802qSjIhMFpHNIrJNRO6sY3mciMx3l69wf9QZ6hh7i8hSEdkoIhtE5LY6ykwUkWMikus+7gl1nG4ceSLyqRvDV25jFMfv3e25TkQywxDjIL/tlCsihSLy41plwrI9RWSuiBwQkfV+81JE5G0R2eo+d6pn3RvdMltF5MYwxPmgiGxyv9eFIpJcz7oN7iMhiPNeEdnj991eXs+6DR4bQhDnfL8Y80Qkt551Q7I96zsOebZ/BtovTSQ8cAY/2w70A2JxenEeXKvMD4An3OmZwPwwxNkdyHSnE4EtdcQ5EXgtArZpHtC5geWXA2/g9NozDlgRAfvAF0CfSNiewPlAJrDeb97vgDvd6TuBB+pYLwXY4T53cqc7hTjOS4Bod/qBuuJsyj4SgjjvBX7ahP2iwWOD13HWWv6/wD3h3J71HYe82j9by5lMU8aomQo8406/CHxNRELarZmq7lPVNe50EU63Oj1DGUMQTcUZWE5VdTmQ7PaOHS5fA7ar6q4wxlBDVZfhjOrqz38ffAb4Rh2rXgq8rapHVPUo8DYwOZRxqupb6nT/BLAc8KYP+NNQz/ZsiqYcG4KmoTjd4803OY1+F73QwHHIk/2ztSSZusaoqX3wrinj/gEdA1JDEl0d3Mt1I4EVdSw+R0TWisgbIhKusaIVeEtEVoszbEJtTdnmoTST+v94I2F7AnRV1X3u9Bc4/fLVFmnb9Ts4Z6x1aWwfCYU57mW9ufVc3omk7TkB2K+qW+tZHvLtWes45Mn+2VqSTIsiIh2Al4Afq2phrcVrcC75jAD+ACwKcXjVzlPVTJxhsm8VkfPDFEejxOnNewrwQh2LI2V7nkKdaw8R/fsBEfkFUAE8V0+RcO8jfwLOBDKAfTiXoiJZY73Hh3R7NnQcCub+2VqSzB6cnpmr9XLn1VlGRKKBJOAwISYiMThf7HOq+nLt5apaqKrF7vTrQIyIdA5xmKjqHvf5ALAQ57KDv6Zs81C5DFijqvtrL4iU7enaX31J0X0+UEeZiNiuInIT8HXgW+4B5yuasI94SlX3q2qlqlYBf67n/SNle0bjjPY7v74yodye9RyHPNk/W0uSaXSMGvd19Z0QVwNL6vvj8Yp7TfavwGeqWufQ0SLSrbqtSETG4HxHIU2GItJeRBKrp3EagtfXKrYYuEEc44BjfqfaoVbvf4iRsD39+O+DNwKv1FHmTeASEenkXv65xJ0XMiIyGfgZMEVVS+op05R9xFO12gCn1fP+TTk2hMJFwCZVza9rYSi3ZwPHIW/2T6/vZAjVA+dupy04d5L8wp13H84fCkA8zuWUbcDHQL8wxHgezinoOiDXfVwO3ALc4paZA2zAuQtmOXBuGOLs577/WjeW6u3pH6cAj7vb+1NgVJi+9/Y4SSPJb17YtydO0tsHlONct/4uThvgu8BW4B0gxS07CviL37rfcffTbcCsMMS5Dee6e/U+Wn1XZg/g9Yb2kRDH+Xd331uHc4DsXjtO9/VXjg2hjNOd/3T1PulXNizbs4HjkCf7p3UrY4wxxjOt5XKZMcaYCGRJxhhjjGcsyRhjjPGMJRljjDGesSRjjDHGM5ZkjGkmEal0e8xdLyKvSj29FQfx/W4Skce8fA9jgs2SjDHNd0JVM1R1KE6niLeGOyBjIo0lGWOC4yPcjgJFJENElsuX47F0cufniMgod7qziOS50zeJyMsi8i93jI7fVVcqIrNEZIuIfAyM95t/jXsGtVZEloXwcxpzWizJGBMgEfHhDDVQ3V3Js8DPVXU4zi/Sf9mEajKAGcAwYIY7sFR34Fc4yeU8nDE/qt0DXKpOx59TgvE5jPGCJRljmq+dOKMcVneL/raIJAHJqvpvt8wzOANZNeZdVT2mqqXARqAPMBbIUdWD6oyF4t+54gfA0yLyfZyBuYyJSJZkjGm+E6qagZMQhMbbZCr48m8uvtayk37TlUB0QxWp6i3A3Tg94q4WkbCNjWRMQyzJGBMgdXoq/hHwn8Bx4KiITHAXXw9Un9XkAVnu9NVNqHoFcIGIpLpds19TvUBEzlTVFap6D3CQU7tfNyZiNPjfkjGmaVT1ExFZhzPswI3AEyKSgDMG+iy32EPAAnfUw382oc59InIvzk0FBTi95VZ7UEQG4JxBvYvTe68xEcd6YTbGGOMZu1xmjDHGM5ZkjDHGeMaSjDHGGM9YkjHGGOMZSzLGGGM8Y0nGGGOMZyzJGGOM8YwlGWOMMZ6xJGOMMcYzlmSMMcZ4xtMkIyKTRWSziGwTkTsbKDddRLR6QCd33l3ueptF5FK/+Xki8qk77O0qL+M3xhgTGM86yHQHcnocuBjIB1aKyGJV3VirXCJwG06Ps9XzBgMzgSFAD+AdERmoqpVukUmqesir2I0xxgSHl2cyY4BtqrrDHXBpHjC1jnK/Bh4ASv3mTQXmqepJVd0JbHPrM8YY04J42dV/T+Bzv9f5OCP91RCRTKC3qv5TRO6ote7yWuv2dKcVeEtEFHhSVZ9qLJDk5GTt379/Mz5CaB0/fpz27duHO4wGtYQYweIMNoszuFpKnKtXrz6kqmmB1BG28WREJAp4GLjpNFc9T1X3iEgXnOFuN6nqsjrqnw3MBkhLS+Ohhx4KNGTPFRcX06FDh3CH0aCWECNYnMFmcQZXS4lz0qRJuwKtw8sks4dTR+vr5c6rlggMBXJEBKAbsFhEpjS0rqpWPx8QkYU4l9G+kmTcM5ynAAYOGqQTJ04MyofyUk5ODpEeZ0uIESzOYLM4g6ulxBkMXrbJrAQGiEhfEYnFachfXL1QVY+pamdVTVfVdJzLY1NUdZVbbqaIxIlIX2AA8LGItHdvFEBE2gOXAOsbC6S4zAZmM8aYcPDsTEZVK0RkDvAm4APmquoGEbkPWKWqixtYd4OILAA2AhXArapaKSJdgYXumU808Lyq/quxWIrLLckYY0w4eNomo6qvA6/XmndPPWUn1np9P3B/rXk7gBGnG8fJSth9uIQzUhNOd1VjTBOUl5eTn59PaWlp44U9lJSUxGeffRbWGJoi0uKMj4+nV69exMTEBL3usDX8h9rCT/Zw20UDwh2GMa1Sfn4+iYmJpKen415pCIuioiISExPD9v5NFUlxqiqHDx8mPz+fvn37Br3+NtGtTLwPFn6Sj6pdNjPGC6WlpaSmpoY1wZjmERFSU1M9OwttE0mmQ6yQd7iETz4vCHcoxrRalmBaLi+/uzaRZBKihbjoKF5ekx/uUIwxpk1pE0kmSuDSId14bd0+yiqqwh2OMcYDPp+P8ePHk5GRQUZGBr/97W9DHsOmTZvIyMhg5MiRbN++/ZRl6enpDBs2jIyMDMaPH8+HH37Y5Hpr/3DzkUceIT4+nmPHjgUlbi+1mYb/aZk9Wbx2L0s3H+DSId3CHY4xJsjatWvHBx980GCDemVlJT6fr97XTV2vPosWLeLqq6/m7rvvrnP50qVL6dy5c8AN/9nZ2YwePZqXX36ZWbNmNbueUGgzSWZC/8507hDHy2vyLckY46FfvbqBjXsLg1rn4B4d+eWVQ5q1bnp6OjNmzODtt9/mZz/7GXfeeecpr1WV//mf/0FVueKKK3jggQcA5+zh5ptv5p133uHxxx/nvPPOq6kzNzeXW265hZKSEs4880zmzp3LRx99xCOPPILP5+Pdd99l6dKljca2fft2br31Vg4ePEhCQgJ//vOfOeuss9i5cyfXXXcdxcXFTJ069SvrFBcX88c//pH777+fWbNm8cQTT7B9+3YefPBBAJ5++mlWrVrFY489xq9//Wv+8Y9/kJaWRu/evcnKyuKnP/1ps7Zlc7SJy2UA0b4opmb0YMmmAxSUlIU7HGNMkJ04ceKUy2Xz58+vWZaamsqaNWuYOXPmKa/PP/98fv7zn7NkyRJyc3NZuXIlixYtApxOLMeOHcvatWtPSTAAN9xwAw888ADr1q1j2LBh/OpXv+Lyyy/nlltu4fbbb683wUyaNImMjAwmTZoEwOzZs/nDH/7A6tWreeihh/jBD34AwG233cZ//Md/8Omnn9K9e/dT6pg3bx4zZ85kwoQJbN68mf379zN9+nQWLlxYU2b+/PnMnDmTlStX8tJLL7F27VreeOMNVq0K/RBcbeZMBmDayJ789f2dvLZuH98e1yfc4RjTKjX3jCNQDV0umzFjRp2vV65cycSJE0lLczoa/ta3vsWyZcv4xje+gc/nY/r06V+p69ixYxQUFHDBBRcAcOONN3LNNdc0KUb/y2XFxcV8+OGHp6x78uRJAD744ANeeuklAK6//np+/vOf15TJzs5m4cKFREVFMX36dF544QXmzJlDv379WL58OQMGDGDTpk2MHz+eRx99lKlTpxIfH098fDxXXnllk+IMpjaVZIb06MjArh14eU2+JRlj2pDa3eo3pZv9+Pj4JrXDNFdVVRXJycnk5ubWubyu24o//fRTtm7dysUXXwxAWVkZffv2Zc6cOcycOZMFCxZw1llnMW3atIi5pbzNXC4D50u7KrMXa3YXkHfoeLjDMcaE2ZgxY/j3v//NoUOHqKysJDs7u+YMpT5JSUl06tSJ9957D4C///3vja5Tl44dO9K3b19eeOEFwPnl/dq1awEYP3488+bNA+C5556rWSc7O5t7772XvLw88vLy2Lt3L3v37mXXrl1MmzaNV155hezs7JrLguPHj+fVV1+ltLSU4uJiXnvttdOOM1BtKskATM3ogYjTzYwxpvWo3SZz5513NrpO9+7d+e1vf8ukSZMYMWIEWVlZX2lor8szzzzDHXfcwfDhw8nNzeWee+rskrFRzz33HH/9618ZMWIEQ4YM4ZVXXgHg0Ucf5fHHH2fYsGHs2fPlsWrevHlMmzbtlDqmTZvGvHnz6NSpE2effTa7du1izBhnIOHRo0czZcoUhg8fzmWXXcawYcNISkpqVqzNpqqt/jFw4ED1d92fP9IJDyzRqqoqjSRLly4NdwiNagkxqlqcwdZYnBs3bgxNII0oLCwMdwhNEso4i4qKVFX1+PHjmpWVpatXr66zXF3fIU6P+QEdf9vcmQzAVSN7sftICat3HQ13KMYY46nZs2eTkZFBZmYm06dPJzMzM6Tv36Ya/qtNHtqNuxet5+VP9jAqPSXc4RhjjGeef/75sL5/mzyTaR8XzaVDuvLa2r2UlleGOxxjWgW1Xs5bLC+/uzaZZACuyuxFYWkFSzcdCHcoxrR48fHxHD582BJNC6TueDLx8fGe1N8mL5cBjO/fmS6Jcbz8yR4uG9a98RWMMfXq1asX+fn5HDx4MKxxlJaWenawDKZIi7N6ZEwvtNkk44sSpmb04G8f5HHkeBkp7WPDHZIxLVZMTIwnoyqerpycHEaOHBnuMBrVUuIMhjZ7uQycS2YVVcpr6/aGOxRjjGmVPE0yIjJZRDaLyDYRqfeXUSIyXURUREb5zbvLXW+ziFx6unU2xdndO3JWt0ReXmM/zDTGGC94lmRExAc8DlwGDAauFZHBdZRLBG4DVvjNGwzMBIYAk4E/ioivqXWejqsye5L7eQHbDxYHUo0xxpg6eHkmMwbYpqo7VLUMmAfU1V/Dr4EHgFK/eVOBeap6UlV3Atvc+ppaZ5NNzehJlMAi62bGGGOCzsuG/57A536v84Gx/gVEJBPorar/FJE7aq27vNa6Pd3pBuv0q3s2MBsgLS2NnJycegMdnOIj+6PtjIzZS1QYey4tLi5uMM5I0BJiBIsz2CzO4GopcQZD2O4uE5Eo4GHgJi/qV9WngKcABg0apBMnTqy37NGkfG6fv5b2fYYztl+qF+E0SU5ODg3FGQlaQoxgcQabxRlcLSXOYPDyctkeoLff617uvGqJwFAgR0TygHHAYrfxv751G6uzWS4d0o2EWJ/1zGyMMUHmZZJZCQwQkb4iEovTkL+4eqGqHlPVzqqarqrpOJfHpqjqKrfcTBGJE5G+wADg48bqbK6E2GgmD+3GPz/dZ93MGGNMEDWaZMTRu7FytalqBTAHeBP4DFigqhtE5D4RmdLIuhuABcBG4F/ArapaWV+dpxtbXa4a2Yui0gre+Wx/MKozxhhDE9pkVFVF5HVg2OlWrqqvA6/Xmlfn6D6qOrHW6/uB+5tSZzCcc2Yq3TrGs3DNHr4+vEewqzfGmDapqZfL1ojIaE8jCTNflDB1ZA/+veUgh4pPhjscY4xpFZqaZMYCH4nIdhFZJyKfisg6LwMLh6tGOt3MvLrWupkxxphgaOotzJc2XqTlG9QtkSE9OrLwkz3MGh/+zv6MMaala9KZjKruApKBK91Hsjuv1Zk2sifr8o+x7UBRuEMxxpgWr0lJRkRuA54DuriPf4jID70MLFymZPQgSrBOM40xJgia2ibzXWCsqt7j3h02Dvi+d2GFT5fEeM4fmMYruXupqrJR/owxJhBNTTIC+P9KsdKd1ypNG9mTPQUnWLHzSLhDMcaYFq2pDf9/A1aIyEL39TeAv3oSUQS4ZHA3OsRF8/KafM45M3x9mRljTEvXlF/8R+F0+TILOOI+ZqnqI96GFj7tYn1cNrQbb6z/ghNl1s2MMcY0V6NJRlWrgMdVdY2q/t59fBKC2MJqWmZPik9W8LZ1M2OMMc3W1DaZd90hklttO0xt4/qm0iMpnpfX5Ic7FGOMabGammRuBl4ATopIoYgUiUihh3GFXVSU8I2RPXlv6yEOFlk3M8YY0xxNbZOZrKpRqhqrqh1VNVFVO4YgvrC6KrMnlVXKYutmxhhjmqWpbTKPhSCWiNO/SyLDeibZJTNjjGkma5NpxFWZPdmwt5B7F2+goKQs3OEYY0yLcjptMgtoQ20y1a4dcwbfGnsGz36Ux8SHcnjmwzwqKqvCHZYxxrQITU0yScBNwP9z22KGABd7FVQkiY/xcf+0YfzzRxMY3L0jv1y8gcsefY9/bzkY7tCMMSbiNTXJPI7TX9m17usi2lg7zdndO/Lc98by1PVZlFVWcePcj/nO0yvZfrA43KEZY0zEavKgZap6K1AKoKpHgVjPoopQIsIlQ7rx1u3n81+Xn8XKnUe49P+Wcd+rGzlWUh7u8IwxJuI0NcmUi4gPUAARSQMabZgQkckisllEtonInXUsv8UdZTNXRN4XkcHu/FgR+Zu7bK2ITPRbJ8etM9d9dGniZwiauGgfs88/k6V3TOSaUb3424c7mfjQUv6+fJe11xhjjJ+mJpnfAwuBLiJyP/A+8D8NreAmpceBy4DBwLXVScTP86o6TFUzgN8BD7vzvw+gqsNw2n7+1/29TrVvqWqG+zjQxM8QdJ07xPGbq4bz2g/PY1C3RP570Xqu+P37vL/1ULhCMsaYiNLUkTGfA34G/AbYB3xDVV9oZLUxwDZV3aGqZcA8YGqtev3vUGuPe6aEk5SWuGUOAAXAqKbEGg5DeiSR/f1xPPHtTErKK/j2X1fwvWdWsfPQ8XCHZowxYSWq3gzMJSJX4/QU8D339fU4bTtzapW7FfgJThvPhaq6VURm45zBXAv0Bj4BvquqL4lIDpCKM6bNSzh3vH3lQ7h1zAZIS0vLWrBggSefs7aySuXtXeW8ur2c8iq4uE8MU86MISGm8Z8YFRcX06FDhxBE2XwtIUawOIPN4gyulhLnpEmTVqtqYP/gq6onD+Bq4C9+r68HHmug/HXAM+50NPB/QC7wCvA6ztkTQE/3ORF4C7ihsVgGDhyooba/8ITe8UKupt/5mmbe95b+5b0duudoSYPrLF26NDTBBaAlxKhqcQabxRlcLSVOYJUGmAuaOmhZc+zBOQup1sudV595wJ8AVLUCuL16gYh8CGxxl+1xn4tE5Hmcy3LPBjXyIOiSGM/vrh7BDeekc99rG/m1+zirWyKTzurChWd1YWTvZKJ9TW0WM8aYlsfLJLMSGCAifXGSy0ycs5UaIjJAVbe6L68AtrrzE3Au5R0XkYuBClXdKCLRQLKqHhKRGODrwDsefoaADe2ZxPzZ49h+sJglmw6wZNMB/rxsB3/K2U5SuxguGJjGhWd14YKBaeEO1Rhjgs6zJKOqFSIyB3gT8AFzVXWDiNyHcwq2GJgjIhcB5cBR4EZ39S7AmyJShZOgrnfnx7nzY9w63wH+7NVnCBYRoX+XRPp3SWT2+WdSWFrOe1sOsWTTAXI2H2Dx2r1ECfRLimKDbmPSoC6c3T2RNthVnDGmlfHyTAZVfR2nPcV/3j1+07fVs14eMKiO+ceBrOBGGXod42O4Ynh3rhjenaoqZd2eYyzZdIDFK7fz4JubefDNzXRPimfiIOey2vj+qSTEevpVGWOMJ+zIFWZRUUJG72QyeieTGbOXwZnjyNl8kHc37Wdx7h6yP95NbHQU4/qlMqF/ZzL7dGJoz47ERfvCHboxxjTKkkyE6dIxnm+O7s03R/fmZEUlK3cerbmsdv/rnwEQGx3F8J5JZPXpRGafTmT16UTnDnFhjtwYY77KkkwEi4v2cd6Azpw3oDP3XDmYA0WlrNl1lNXu428f5PHksh0ApKcm1CScrD6dGNglkagoa9MxxoSXJZkWpEtiPJOHdmfy0O4AlJZXsmHvMVblOUln2ZaDvLzGuUs8MT6akWd0IusMJ+lknJFMhzj7uo0xoWVHnRYsPsZHVp8UsvqkAM4Pa3cfKWH1rqOs2nWUNbuO8si7W1CFKIFB3ToyuHtHBnTtwIAuHRjYNZGeye3sjMcY4xlLMq2IiNAntT19UttzVWYvAApLy8ndXcDqXUdZs/so7287yEtr8mvWiY+Jon+XDgzokugmn0QGdOlA75QEfJZ8jDEBsiTTynWMj+H8gWmc7/djz2Mnytl2oIit+4vZesB5LN9xmIWffNkhQ1x0FGemdag56+nfJZGBXTtQWeVNX3fGmNbJkkwblNQu5pTLbNWKSsvZ5iadbQeK2bK/iFV5R3kld29NGZ9An09ySE9tT5/UBPqkJNCnc3vSU9vTq1M7YqybHGOMH0sypkZifAwjz+jEyDM6nTL/+MkKth8sZuv+Yt5dtRE6JJJ3qIQVOw5zvKyyppwvSuiZ3I4+qQlfJqHU9qSnJtA7JYH4GPttjzFtjSUZ06j2cdEM75XM8F7JpBZtY+JEp9MFVeVQcRm7Dh8n73AJu93nXYeP80ruHgpLK2rqEIHuHePpk9qeHsntSGkfQ3JCLCntY+mUEEOnhFg6tY8l2Z22MyJjWgdLMqbZRIS0xDjSEuMYlZ7yleUFJWU1SSfvkPt8+Dgfbj/E0ZIySsvrH6o6MS6a5PYxpCTEkpzgJqL2sTXJqHP7WLp0jCOtQzxdOsbZWZIxEcqSjPFMckIsGQmxZPROrnP5ibJKjpaUcbSkjIKSco4cL6OgpIwjx8vdeWUcKXGmtx8spqCknOKTFXXWlRgfTVpiHF0S4+iSGM/JgpNslu2nJKIuiXEktYuxjkeNCSFLMiZs2sX6aBfbjh7J7Zq8TllFFQUlZRwsPsnBopMcKHKenelSDhSeZG1+AfsKKnhz16avrB/riyItMY7OiXGkJDiX7JLaxZCcEENyuxiSEmJIbhfrPjvLO8ZH27g/xjSTJRnTosRGR9GlYzxdOsY3WG7p0qWMOue8mkR0wC8RHSw8ycHikxwqLmObe4ZUVFr3GVK1xPhov2T0ZRLqlOC0I6W4l/Kqp6uTk501mbbOkoxplUSExPgYEuNj6JfW+FjqFZVVFJZWUFBSRsGJco6dKOdYSXnN64ISZ15BSRnHTpSz99gJCtzl9f10yBcldHLPlmpubkiIJbm9M52SEMvuLyqQLQdJiPXRLsZHQqyPhNho2sU603YDhGnpLMkYA0T7okhp79ztdjqqqpSi0gqO1LQtlXHUbVNyHuUcPe5M7z5Swtr8Ao4eL6es0u+mh9yP648rSmoSTkJsdE0i8p8XFx1FbHQUsb4oYtzn2Ogo4qKjiPF9ddkp89157dwkZ8nNBJslGWMCEBUlJCU4bTl9ad+kdVSVEvemhyXvfcSQESMpKaukpKySE+5zSVmFM11ePa/ilOWFpRXsLyylpKySsooqyiqrnOeKKiqC0CtDjE+I9zuzqjh5gi6ffUhCrM9v/pfT8dE+on1RREcJvigh2idEiZzy2hflt9x99tW8jiLaJzVJMLaORBjri7J+9logSzLGhJiI0D4umvZx0ZzR0feVnhcCVVWlTtKprKLcLwGVV1ZxsqJ6Wt3k5CSpE+VfJjn/5FY9nb+vlPiYKIpPVnCw6OQp5UvKKuq9ZBhsMW4iqisJxUVHceL4Cf68bXlNmdho3ylndrF+Z3qxtc76qp+jo6Lw+YQYN/HF+L5MgjG+KHxRXy6L9isXXfMs1hbnx5KMMa1MVJQQH+UL6m+HcnJymDhxXJ3LVJXySqVKlYoqpbJSqaiqorLKfe0+KmqeT11W4a7rfzZWXj3tPp+sZ/4p05VVlJXAyfIqikorapafrFm/sqas10kxzk1Y8TE+4mKiiIv2nTKvuLCUeZ+vdpc5y+P9y8W460Z/+RwX45wxxsVEffnsVyY+Oioi74L0NMmIyGTgUcAH/EVVf1tr+S3ArUAlUAzMVtWNIhILPAmMAqqA21Q1x10nC3gaaAe87i6zXhuNCRMRITY6Mv5zd5LhuY2Wq6g8NVGd9EtkFVXOJceKSqWisoryKvfZL3mW11pWUanuOl+eMTqPSk6WO9Ol5ZU184pOKjsPHae0ZnllTZlAEqAvSoh3E9L3J/TjPyae2fzKgsSzJCMiPuBx4GIgH1gpIotVdaNfsedV9Qm3/BTgYWAy8H0AVR0mIl2AN0RktKpWAX9yl6/ASTKTgTe8+hzGmNYn2uf8159wevd5BI2TDM+vc1l1kqpOSqXlTiIqraj8MlH5L3OfS91kVf3cv0vjd1WGgpdnMmOAbaq6A0BE5gFTgZoko6qFfuXbA9U5fDCwxC1zQEQKgFEi8jnQUVWXu3U+C3wDSzLGmFYixue0N7WWkWy9/BQ9gc/9XucDY2sXEpFbgZ8AscCF7uy1wBQRyQZ6A1nuc5Vbj3+dPet6cxGZDcwGSEtLIycnJ4CPEhrFxcURH2dLiBEszmCzOIOrpcQZDGFPlar6OPC4iFwH3A3cCMwFzgZWAbuAD3HabU6n3qeApwAGDRqkEydODGLU3nBOoSeGO4wGtYQYweIMNoszuFpKnMHgZZLZg3P2Ua2XO68+83DaW1DVCuD26gUi8iGwBTjq1tPUOgHYsmVLsYhsbnLk4dMZOBTuIBrREmIEizPYLM7gailxDgq0Ai+TzEpggIj0xUkEM4Hr/AuIyABV3eq+vALY6s5PAERVj4vIxUBF9Q0DIlIoIuNwGv5vAP7QhFg2q+qoYHwoL4nIqkiPsyXECBZnsFmcwdWS4gy0Ds+SjKpWiMgc4E2cW5jnquoGEbkPWKWqi4E5InIRUI5zlnKju3oX4E0RqcJJUNf7Vf0DvryF+Q2s0d8YYyKWp20yqvo6zm3G/vPu8Zu+rZ718qjnNE1VVwFDgxelMcYYr0Tez0O98VS4A2iilhBnS4gRLM5gsziDq83EKfZjeWOMMV5pK2cyxhhjwsCSjDHGGM+0miQjIpNFZLOIbBORO+tYHici893lK0QkPQwx9haRpSKyUUQ2iMhXbnwQkYkickxEct3HPXXVFYJY80TkUzeGr9zGKI7fu9tznYhkhiHGQX7bKde9vf3HtcqEZXuKyFwROSAi6/3mpYjI2yKy1X3uVM+6N7pltorIjXWV8TjOB0Vkk/u9LhSR5HrWbXAfCUGc94rIHr/v9vJ61m3w2BCCOOf7xZgnIrn1rBuS7Vnfcciz/VNVW/wD5xbp7UA/nO5p1gKDa5X5AfCEOz0TmB+GOLsDme50Is4PTGvHORF4LQK2aR7QuYHll+PcPi7AOGBFBOwDXwB9ImF7AucDmcB6v3m/A+50p+8EHqhjvRRgh/vcyZ3uFOI4LwGi3ekH6oqzKftICOK8F/hpE/aLBo8NXsdZa/n/AveEc3vWdxzyav9sLWcyNZ1xqmoZTu8BU2uVmQo8406/CHxNJLQjC6nqPlVd404XAZ9RT99rLcBU4Fl1LAeSRaR7GOP5GrBdVXeFMYYaqroMOFJrtv8++AxO5661XQq8rapHVPUo8DZOT+Mhi1NV31Kn1w2A5Zzay0ZY1LM9m6Ipx4agaShO93jzTSDbq/dvigaOQ57sn60lydTVGWftg3dNGfcP6BiQGpLo6uBerhuJ03NBbeeIyFoReUNEhoQ2shoKvCUiq8XpbLS2pmzzUJpJ/X+8kbA9Abqq6j53+gugax1lIm27fof6f/Dc2D4SCnPcy3pz67m8E0nbcwKwX7/s5aS2kG/PWschT/bP1pJkWhQR6QC8BPxYTx3uAGANziWfEThd5iwKcXjVzlPVTOAy4FYRqXvwiwggziB3U4AX6lgcKdvzFOpce4jo3w+IyC+ACuC5eoqEex/5E3AmkAHsw7kUFcmupeGzmJBuz4aOQ8HcP1tLkmlKZ5w1ZUQkGkgCDockOj8iEoPzxT6nqi/XXq6qhapa7E6/DsSISOcQh4mq7nGfDwALcS47+DvdDlC9dBmwRlX3114QKdvTtb/6kqL7fKCOMhGxXUXkJuDrwLfcA85XNGEf8ZSq7lfVSnUGM/xzPe8fKdszGrgKmF9fmVBuz3qOQ57sn60lydR0xun+VzsTWFyrzGK+7BvtamBJfX88XnGvyf4V+ExVH66nTLfqtiIRGYPzHYU0GYpIexFJrJ7GaQheX6vYYuAGcYwDjvmdaodavf8hRsL29OO/D94IvFJHmTeBS0Skk3v55xJ3XsiIM2z6z4ApqlpST5mm7COeqtUGOK2e92/KsSEULgI2qWp+XQtDuT0bOA55s396fSdDqB44dzttwbmT5BfuvPtw/lAA4nEup2wDPgb6hSHG83BOQdcBue7jcuAW4Ba3zBxgA85dMMuBc8MQZz/3/de6sVRvT/84BWd47e3Ap8CoMH3v7XGSRpLfvLBvT5yktw+n89d84Ls4bYDv4vQ2/g6Q4pYdBfzFb93vuPvpNmBWGOLchnPdvXofrb4rswfwekP7SIjj/Lu7763DOUB2rx2n+/orx4ZQxunOf7p6n/QrG5bt2cBxyJP907qVMcYY45nWcrnMGGNMBLIkY4wxxjOWZIwxxnjGkowxxhjPWJIxxhjjGUsyxjSTiFS6PeauF5FXpZ7eioP4fjeJyGNevocxwWZJxpjmO6GqGao6FKdTxFvDHZAxkcaSjDHB8RFuR4EikiEiy+XL8Vg6ufNzRGSUO91ZRPLc6ZtE5GUR+Zc7RsfvqisVkVkiskVEPgbG+82/xj2DWisiy0L4OY05LZZkjAmQiPhwhhqo7q7kWeDnqjoc5xfpv2xCNRnADGAYMMMdWKo78Cuc5HIezpgf1e4BLlWn488pwfgcxnjBkowxzddOnFEOq7tFf1tEkoBkVf23W+YZnIGsGvOuqh5T1VJgI9AHGAvkqOpBdcZC8e9c8QPgaRH5Ps7AXMZEJEsyxjTfCVXNwEkIQuNtMhV8+TcXX2vZSb/pSiC6oYpU9RbgbpwecVeLSNjGRjKmIZZkjAmQOj0V/wj4T+A4cFREJriLrweqz2rygCx3+uomVL0CuEBEUt2u2a+pXiAiZ6rqClW9BzjIqd2vGxMxGvxvyRjTNKr6iYiswxl24EbgCRFJwBkDfZZb7CFggTvq4T+bUOc+EbkX56aCApzecqs9KCIDcM6g3sXpvdeYiGO9MBtjjPGMXS4zxhjjGUsyxhhjPGNJxhhjjGcsyRhjjPGMJRljjDGesSRjjDHGM5ZkjDHGeOb/A0CSLzEdlVKGAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
    "# make a little extra space between the subplots\n",
    "fig.subplots_adjust(hspace=0.5)\n",
    "\n",
    "s1 = np.array(all_results) #FedAvg\n",
    "\n",
    "t = range(0,s1.shape[0])\n",
    "\n",
    "ax1.plot(t, s1[:,0],label='Acc of FedAvg')\n",
    "ax1.set_xlim(0,s1.shape[0])\n",
    "ax1.set_xlabel('Rounds')\n",
    "ax1.set_ylabel('Accuracy')\n",
    "ax1.grid(True)\n",
    "ax1.legend()\n",
    "\n",
    "\n",
    "ax2.plot(t, s1[:,1],label='Error of FedAvg')\n",
    "ax2.set_xlim(0, s1.shape[0])\n",
    "ax2.set_xlabel('Rounds')\n",
    "ax2.set_ylabel('error')\n",
    "ax2.grid(True)\n",
    "ax2.legend()\n",
    "\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fea9eee3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}