diff --git a/README.txt b/README.txt new file mode 100644 index 0000000..50527c1 --- /dev/null +++ b/README.txt @@ -0,0 +1,11 @@ +This repository is source code for ECML/PKDD paper "Taking Over the Stock Market: AdversarialPerturbations Against Algorithmic Traders". + +The notebook file contains the main contribution of our work. + +In order to run the notebook: +1) downlode the dataset from: https://www.kaggle.com/nickdl/snp-500-intraday-data/home. +2) split the dataset for each symbol and save each symbol to csv files in a local dir named "splited_s&p500". +3) change the path at the readSymbolData function to the local dir path. +4) run the notebook. + +Feel free to ask for any clarifications. \ No newline at end of file diff --git a/Taking Over the Stock Market.ipynb b/Taking Over the Stock Market.ipynb new file mode 100644 index 0000000..a556cc2 --- /dev/null +++ b/Taking Over the Stock Market.ipynb @@ -0,0 +1,2753 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "5iolIfS9d63E" + }, + "source": [ + "# Taking Over the Stock Market: Adversarial Perturbations Against Algorithmic Traders\n", + "\n", + "\n", + "---\n", + "\n", + "This notebook presents the main contributions of our work submitted to ECML-PKDD 2021. \n", + "\n", + "We provided the implementation of our work to help researchers understand better the existence of adversarial examples in the trading domain and to help researchers to easily extend our work.\n", + "\n", + "The main parts are:\n", + "- Read and preprocess the data\n", + "- Build and train the alpha models\n", + "- Generate a Targeted Universal Perturbation\n", + "- Evaluate and visualize the results\n", + "- Build and evaluate mitigation solutions\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KEepNy43egRf" + }, + "source": [ + "Imports:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "B_x1gXubw-v0", + "outputId": "26aa7818-6cc7-4664-ee26-fa9317da0e02" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TensorFlow 1.x selected.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mounted at /content/drive/\n" + ] + } + ], + "source": [ + "%tensorflow_version 1.x\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n", + "import keras.backend as K\n", + "from keras.models import Sequential\n", + "from keras.layers import LSTM,Dense, Dropout, BatchNormalization, Conv1D, MaxPooling1D, Flatten, Reshape\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import mean_squared_error, accuracy_score, confusion_matrix\n", + "from numpy.random import seed\n", + "from math import sqrt\n", + "import numpy as np # linear algebra\n", + "import pandas as pd # data processing\n", + "from datetime import datetime\n", + "import timeit\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kX0xRBEPe746" + }, + "source": [ + "# preprocess\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o5uk8zLeeicn" + }, + "source": [ + "Load one symbol:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "UUgWtdFFeRoO" + }, + "outputs": [], + "source": [ + "# read the data and define the columns\n", + "def readSymbolData(Symbol):\n", + " # Symbol must be the stock specific name as a string\n", + " data = pd.read_csv('path_to_our_dir/splited_s&p500/'+Symbol+'.csv',parse_dates=['Unnamed: 0.1'])\n", + " #fill nan with last val instance\n", + " data = data.fillna(method='ffill')\n", + " # for cases where the first raw is missing\n", + " X = pd.DataFrame(removeEarly(data))\n", + " X.columns = ['Date', 'Open','High','Low','Close','Volume']\n", + " return X\n", + "\n", + "# remove missing values\n", + "def removeEarly(data):\n", + " for i in range(50):\n", + " if not data.iloc[i,5] == 'close':\n", + " return data.iloc[i:, 1:]\n", + " \n", + "# parsing the hour and minute out from the time stamp\n", + "def parse_hour(time):\n", + " time = datetime.strptime(time, '%Y-%m-%d %H:%M:%S')\n", + " return time.hour - 9\n", + "\n", + "def parse_minute(time):\n", + " time = datetime.strptime(time, '%Y-%m-%d %H:%M:%S')\n", + " return time.minute\n", + "\n", + "# parsing and adding minute, hour to the data\n", + "def parseTime(X):\n", + " # parsing time to hour and minute\n", + " X['Minute'] = X['Date'].apply(parse_minute)\n", + " X['Hour'] = X['Date'].apply(parse_hour)\n", + " return X\n", + "\n", + "# aggregating the data to extract avg,std,trend,time\n", + "def np_agg_perN(data, aggN):\n", + " avg,std,trend,minute,hour,close = [],[],[],[],[],[]\n", + " for i in range(int(len(data)/aggN)):\n", + " start = i*aggN\n", + " curData = np.array(data[start:start+aggN,4], dtype=np.float64)\n", + " avg.insert(i, np.mean(curData, dtype=np.float64))\n", + " std.insert(i, np.std(curData, dtype=np.float64))\n", + " a1_param,_ = np.polyfit(range(aggN), curData, 1)\n", + " trend.insert(i, a1_param)\n", + " minute.append(data[start+aggN-1,6]) #minute\n", + " hour.append(data[start+aggN-1,7]) #hour\n", + " close.append(data[start+aggN-1,4]) # close\n", + " return np.array(avg), np.array(std), np.array(trend), np.array(minute), np.array(hour), np.array(close)\n", + "\n", + "# calculates the pseudo log return (difference between avg prices)\n", + "def np_pseudoLogReturn(data):\n", + " PLogReturn = []\n", + " for i in range(len(data)):\n", + " if(i>0):\n", + " PLogReturn.append(np.log(data[i]/data[i-1])) \n", + " return np.array(PLogReturn, dtype = np.float64)\n", + "\n", + "# evaluation for classifier: mse, acc\n", + "def eval_clf_Model(prediction, y_test):\n", + " mse = mean_squared_error(y_test, prediction)\n", + " print('mse: ' + str(mse))\n", + " acc = accuracy_score(y_test, prediction)\n", + " print('Accuracy:'+str(acc))\n", + " \n", + " return mse, acc\n", + " \n", + "#preper the time series data chanks\n", + "def np_processData(data,lookBack):\n", + " X,Y = [],[]\n", + " shapaes = []\n", + " for i in range(len(data)-lookBack): \n", + " X.append(np.matrix(data[i:(i+lookBack),:]))\n", + " Y.append(data[(i+lookBack),0]) #need to be careful with \n", + " return np.array(X),np.array(Y)\n", + " \n", + "# Full preproccess for our classification task:\n", + "def np_clf_aggAndSliceData(X, aggParam=5, lookBack=5, disjoint = False):\n", + " # Aggrigation of the data to get std and trend indicatiors\n", + " avg, std, trend, minute, hour, close = np_agg_perN(X,aggParam)\n", + " logAVG = np_pseudoLogReturn(avg)\n", + "\n", + " minute = minute.reshape(len(minute),1)\n", + " hour = hour.reshape(len(hour),1)\n", + " close = close.reshape(len(close),1)\n", + " avg = avg.reshape(len(avg),1)\n", + " X_time = np.concatenate([minute,hour,close,avg],axis=1)\n", + "\n", + " logAVG = logAVG.reshape(len(logAVG),1)\n", + " std = std[1:]\n", + " trend = trend[1:]\n", + " std = std.reshape(len(std),1)\n", + " trend = trend.reshape(len(trend),1)\n", + " procData = np.concatenate([logAVG,std,trend],axis=1)\n", + "\n", + " # create data & split by 70-30 rate \n", + " proc_x, proc_y = np_processData(procData,lookBack)\n", + " X_train = np.reshape(proc_x, (proc_x.shape[0],proc_x.shape[1]*proc_x.shape[2]))\n", + " X_time = X_time[lookBack:-1]\n", + " merged = np.concatenate([X_train,X_time],axis=1)\n", + " merged = np.array(merged,dtype=float)\n", + " proc_y = proc_y>0\n", + " proc_y = proc_y.astype(int)\n", + " proc_y = keras.utils.to_categorical(proc_y)\n", + " # shrink the data for disjoint samples if needed\n", + " if disjoint == True:\n", + " merged = np.array([merged[i*5] for i in range(int(np.floor(merged.shape[0]/5)))])\n", + " proc_y = np.array([proc_y[i*5] for i in range(int(np.floor(proc_y.shape[0]/5)))])\n", + " X_train,X_test = merged[:int(merged.shape[0]*0.7)],merged[int(merged.shape[0]*0.7):]\n", + " y_train,y_test = proc_y[:int(proc_y.shape[0]*0.7)],proc_y[int(proc_y.shape[0]*0.7):]\n", + " return X_train, X_test, y_train, y_test\n", + "\n", + "def get_train_data(rawData, aggParam, lookBack):\n", + " X_train1, X_test1, y_train1, y_test1 = np_clf_aggAndSliceData(X, aggParam, lookBack)\n", + " X_train2, X_test2, y_train2, y_test2 = np_clf_aggAndSliceData(X[1:], aggParam, lookBack)\n", + " X_train3, X_test3, y_train3, y_test3 = np_clf_aggAndSliceData(X[2:], aggParam, lookBack)\n", + " X_train4, X_test4, y_train4, y_test4 = np_clf_aggAndSliceData(X[3:], aggParam, lookBack)\n", + " X_train5, X_test5, y_train5, y_test5 = np_clf_aggAndSliceData(X[4:], aggParam, lookBack)\n", + " X_train = np.concatenate((X_train1, X_train2, X_train3, X_train4, X_train5), axis=0)\n", + " y_train = np.concatenate((y_train1,y_train2,y_train3,y_train4,y_train5), axis=0)\n", + " return X_train, y_train\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MpvyYADO30hb" + }, + "source": [ + "# model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XwtwkMYdLxp1" + }, + "outputs": [], + "source": [ + "# locking the RNG seed for better evaluation\n", + "def lockSeed():\n", + " seed(1)\n", + " tf.random.set_random_seed(2)\n", + "\n", + "# create DNN model\n", + "def create_DNN_clf(X_train, y_train, nFeatures, nEpochs):\n", + " model = Sequential()\n", + "\n", + " model.add(Dense(nFeatures, activation='tanh', input_shape=(nFeatures,)))\n", + " model.add(Dense(int(np.floor(4*nFeatures/5)), activation='tanh'))\n", + " model.add(Dense(int(np.floor(3*nFeatures/5)), activation='tanh'))\n", + " model.add(Dense(int(np.floor(2*nFeatures/5)), activation='tanh'))\n", + " model.add(Dense(int(np.floor(nFeatures/5)), activation='tanh'))\n", + "\n", + " model.add(Dense(2, activation='softmax'))\n", + "\n", + " model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n", + "\n", + " history = model.fit(X_train[:,:nFeatures],y_train,validation_split = 0.2,epochs=nEpochs,shuffle=True,verbose=0)\n", + " return model, history\n", + "\n", + "#create 1d CNN model\n", + "def create_1dCNN_clf(X_train, y_train, nFeatures, nEpochs):\n", + " model = Sequential()\n", + " model.add(Reshape((5, 3), input_shape=(15,)))\n", + " model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(5,3)))\n", + " model.add(Dense(100, activation='relu'))\n", + " model.add(Dropout(0.2))\n", + " model.add(Flatten())\n", + " model.add(Dense(100, activation='relu'))\n", + " model.add(Dense(2, activation='softmax'))\n", + " model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n", + " # fit network\n", + " history = model.fit(X_train[:,:nFeatures-2], y_train,validation_split = 0.2,epochs=nEpochs, batch_size=32,shuffle=True, verbose=0)\n", + " return model, history\n", + "\n", + "#create RNN model\n", + "def create_RNN_clf(X_train, y_train, nFeatures, nEpochs):\n", + " model = Sequential()\n", + " model.add(Reshape((5, 3), input_shape=(15,)))\n", + " model.add(LSTM(50,input_shape=(5,3),return_sequences=True))\n", + " model.add(Dropout(0.2))\n", + " model.add(LSTM(50,return_sequences=False))\n", + " model.add(Dense(50, activation='relu'))\n", + " model.add(Dense(2, activation='softmax'))\n", + " model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n", + " history = model.fit(X_train[:,:nFeatures-2], y_train,validation_split = 0.2,epochs=nEpochs, batch_size=32,shuffle=True, verbose=0)\n", + " return model, history\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8ZZfRYY7fenP" + }, + "source": [ + "# TUAP\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "p5HL_3ChlhO1" + }, + "outputs": [], + "source": [ + "# preprocces for one sample at a time\n", + "def np_clf_preprocces_one_sample(X, aggParam=5, lookBack=5):\n", + " # Aggrigation of the data to get std and trend indicatiors\n", + " avg, std, trend, minute, hour, close = np_agg_perN(X,aggParam)\n", + " logAVG = np_pseudoLogReturn(avg)\n", + "\n", + " minute = minute.reshape(len(minute),1)\n", + " hour = hour.reshape(len(hour),1)\n", + " close = close.reshape(len(close),1)\n", + " avg = avg.reshape(len(avg),1)\n", + " X_time = np.concatenate([minute,hour,close,avg],axis=1)\n", + "\n", + " logAVG = logAVG.reshape(len(logAVG),1)\n", + " std = std[1:]\n", + " trend = trend[1:]\n", + " std = std.reshape(len(std),1)\n", + " trend = trend.reshape(len(trend),1)\n", + " procData = np.concatenate([logAVG,std,trend],axis=1)\n", + "\n", + " # create data & split by 80-20 rate \n", + " proc_x, proc_y = np_processData(procData,lookBack)\n", + " X_train = np.reshape(proc_x, (proc_x.shape[0],proc_x.shape[1]*proc_x.shape[2]))\n", + " X_time = X_time[lookBack:-1]\n", + " merged = np.concatenate([X_train,X_time],axis=1)\n", + " merged = np.array(merged,dtype=float)\n", + " proc_y = proc_y>0\n", + " proc_y = proc_y.astype(int)\n", + " proc_y = keras.utils.to_categorical(proc_y, num_classes=2)\n", + "\n", + " return merged, proc_y\n", + "\n", + "# fitting the uap and creating the adversarial input data\n", + "def prep(data, UAP, aggParam=5, lookBack=5):\n", + " arr_x, arr_y = [], []\n", + " for x in data:\n", + " if type(UAP) == type(0):\n", + " _x, _y = np_clf_preprocces_one_sample(x, aggParam, lookBack)\n", + " else:\n", + " zeroPad = np.zeros(shape=x.shape, dtype=np.float32)\n", + " zeroPad[:,1:] += np.array(x[:,1:], dtype=np.float32)+UAP\n", + " _x, _y = np_clf_preprocces_one_sample(zeroPad, aggParam, lookBack)\n", + " arr_x.append(_x[0])\n", + " arr_y.append(_y[0])\n", + " arr_x = np.array(arr_x)\n", + " arr_y = np.array(arr_y)\n", + " return arr_x, arr_y\n", + "\n", + "# evaluation for untargeted attack\n", + "def eval_UAP(model, UAP, data, nFeatures):\n", + " X_ben, y = prep(data, 0)\n", + " X_adv, _ = prep(data, UAP)\n", + " orig_preds = model.predict(X_ben[:,:nFeatures])\n", + " orig_preds = np.argmax(orig_preds, axis=-1)\n", + " orig_preds = keras.utils.to_categorical(orig_preds,2)\n", + " adv_preds = model.predict(X_adv[:,:nFeatures])\n", + " adv_preds = np.argmax(adv_preds, axis=-1)\n", + " adv_preds = keras.utils.to_categorical(adv_preds,2)\n", + " accFlips = 1 - accuracy_score(orig_preds, adv_preds)\n", + " accTrue = accuracy_score(y, adv_preds)\n", + " orig_accTrue = accuracy_score(y, orig_preds)\n", + " return accFlips, accTrue, orig_accTrue\n", + "\n", + "# evaluation for targeted uap\n", + "def eval_UAP_targeted(model, UAP, data, target,aggParam, lookBack, nFeatures):\n", + " UAP = fitUAP(UAP, data[0])\n", + " X_ben, y = prep(data, 0,aggParam, lookBack)\n", + " X_adv, _ = prep(data, UAP,aggParam, lookBack)\n", + " for i in range(y.shape[0]):\n", + " y[i] = target\n", + " orig_preds = model.predict(X_ben[:,:nFeatures])\n", + " orig_preds = np.argmax(orig_preds, axis=-1)\n", + " orig_preds = keras.utils.to_categorical(orig_preds,2)\n", + " adv_preds = model.predict(X_adv[:,:nFeatures])\n", + " adv_preds = np.argmax(adv_preds, axis=-1)\n", + " adv_preds = keras.utils.to_categorical(adv_preds,2)\n", + " accFlips = 1 - accuracy_score(orig_preds, adv_preds)\n", + " acc_mal_Target = accuracy_score(y, adv_preds)\n", + " acc_ben_Target = accuracy_score(y,orig_preds)\n", + " return accFlips, acc_ben_Target,acc_mal_Target\n", + "\n", + "# eval random perturbations\n", + "def eval_rand_noise(model,data,target,size,nFeatures):\n", + " rand_perturbs = [getRandomUAP(size) for i in range(10)]\n", + " flips, acc_rnd = [],[]\n", + " for perturb in rand_perturbs:\n", + " rndFlips, acc_ben_Target,acc_rnd_Target = eval_UAP_targeted(model,perturb,data,target,5,5,nFeatures)\n", + " flips.append(rndFlips)\n", + " acc_rnd.append(acc_rnd_Target)\n", + " return np.mean(flips), np.mean(acc_rnd), acc_ben_Target\n", + "\n", + "\n", + "# add padding for different window sizes if needed\n", + "def fitUAP(UAP,x):\n", + " pad = np.zeros((x.shape[0],UAP.shape[-1]))\n", + " pad[x.shape[0]-UAP.shape[0]:,:] = UAP\n", + " return pad\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "etlgK1pilZ8M" + }, + "outputs": [], + "source": [ + "# targeted universal perturbation algorithm \n", + "def targeted_UAP(train_set, model,target_label ,isSeries = 0 ):\n", + " aggN = 5\n", + " input_shape = (35,7)\n", + " num_classes = 2\n", + " volume = np.median(np.array(train_set[:,1,4],dtype=np.float32))*0.002 #0.2% of the price\n", + " step = volume/25 # arbitrary step \n", + " \n", + " # define the perturbation surface \n", + " mask = np.zeros(input_shape,dtype=np.float32 )\n", + " for i in range(25):\n", + " mask[i+5,3] = 1.\n", + "\n", + " ######## Build the tensor graph including preprocces ###########\n", + "\n", + " # define Variables \n", + " data = tf.placeholder(tf.float32, shape=input_shape)\n", + " target = tf.placeholder(tf.float32, (1,2))\n", + " global_uap = tf.Variable(np.zeros(input_shape, dtype=np.float32))\n", + " perturbation = tf.Variable(np.zeros(input_shape, dtype=np.float32))\n", + "\n", + " x_adv = (global_uap + perturbation)*mask + data\n", + "\n", + " ########### preprocess ########################\n", + " cSlices = int(np.floor(35/aggN))\n", + " slices = tf.stack([x_adv[i*aggN:i*aggN+aggN, 3] for i in range(cSlices)])\n", + " avg = tf.reduce_mean(slices, axis=1)\n", + " std = tf.keras.backend.std(slices, axis=1)\n", + "\n", + " #compute the trend indicator\n", + " x = np.arange(1, aggN + 1, dtype = np.float32)\n", + " b1 = aggN*tf.reduce_sum(x*slices, axis=1)-tf.reduce_sum(x)*tf.reduce_sum(slices, axis=1)\n", + " trend = b1/(aggN*tf.reduce_sum(x**2) - tf.reduce_sum(x)**2)\n", + "\n", + " #fix time vars\n", + " minute = tf.stack([x_adv[i*aggN+aggN-1, 5] for i in range(cSlices)])# minute\n", + " hour = tf.stack([x_adv[i*aggN+aggN-1, 6] for i in range(cSlices)])# hour\n", + " close = tf.stack([x_adv[i*aggN+aggN-1, 3] for i in range(cSlices)])# close\n", + "\n", + " #tf pseudoLogReturn\n", + " avg_next = tf.concat([[0],tf.identity(avg)],axis=0)\n", + " avg = tf.concat([avg,[0]],axis=0)\n", + " logAVG = tf.log(avg/avg_next)[1:avg.shape[0]-1]\n", + " avg = avg[:avg.shape[0]-1]\n", + "\n", + " #concat time vars\n", + " minute = tf.reshape(minute,[minute.shape[0],1])\n", + " hour = tf.reshape(hour, [hour.shape[0],1])\n", + " close = tf.reshape(close, [close.shape[0],1])\n", + " avg = tf.reshape(avg,[avg.shape[0],1])\n", + " X_time = tf.concat([minute,hour,close,avg],axis=1)\n", + "\n", + " #concat procData\n", + " logAVG = tf.reshape(logAVG,[logAVG.shape[0],1])\n", + " std = std[1:]\n", + " trend = trend[1:]\n", + " std = tf.reshape(std, [std.shape[0],1])\n", + " trend = tf.reshape(trend, [trend.shape[0],1])\n", + " procData = tf.concat([logAVG,std,trend],axis=1)\n", + "\n", + " #create data \n", + " proc_x = tf.stack([procData[i:i+lookBack,:] for i in range(procData.shape[0]-lookBack)])\n", + " proc_y = tf.stack([procData[i+lookBack,0] for i in range(procData.shape[0]-lookBack)])\n", + " proc_y = tf.convert_to_tensor(proc_y)\n", + " proc_y = tf.to_int32(tf.clip_by_value(tf.sign(proc_y), 0,1))\n", + " proc_y = tf.one_hot(proc_y,2)\n", + "\n", + "\n", + " X_lastN = tf.reshape(proc_x, [proc_x.shape[0],proc_x.shape[1]*proc_x.shape[2]])\n", + " X_time = X_time[lookBack:-1,:]\n", + " merged = tf.concat([X_lastN,X_time],axis=1)\n", + "\n", + " sample_x = merged\n", + " sample_y = proc_y\n", + " ################################################\n", + " ########### end of preprocess ##################\n", + " if isSeries:\n", + " prediction = model(sample_x[:,:nFeatures-2])\n", + " else: prediction = model(sample_x[:,:nFeatures])\n", + "\n", + " loss = tf.keras.losses.binary_crossentropy(target, prediction)\n", + "\n", + " grad = tf.gradients(loss, perturbation)\n", + " grad = tf.where(tf.is_nan(grad), tf.zeros_like(grad)*1, grad) #replace nans with zeros\n", + "\n", + " # initialize variables\n", + " old_vars = set(x.name for x in tf.global_variables())\n", + " new_vars = [x for x in tf.global_variables() if x.name not in old_vars]\n", + "\n", + " _global_uap = np.zeros(input_shape)\n", + " sess.run(tf.initialize_variables([global_uap] + new_vars))\n", + " \n", + " # main loop:\n", + " current_fooling = 0\n", + " for epoch in range(10):\n", + " if current_fooling > 0.9: # update the UAP untill reaching 90% fooling rate\n", + " break\n", + " current_fooling = 0\n", + "\n", + " # for each data point x in the train set update the UAP to predict the desierd target\n", + " for x in train_set[:,:,1:]: \n", + " init_new_vars_op = tf.initialize_variables([perturbation])\n", + " sess.run(init_new_vars_op)\n", + " _prediction, y_true = sess.run([prediction, sample_y], {data: x, \n", + " target: target_label})\n", + " if np.argmax(_prediction, axis=-1) == np.argmax(target_label, axis=-1):\n", + " current_fooling += 1\n", + " continue\n", + " \n", + " # create the minimal perturbation needed to take x to the target class\n", + " for _ in range(10): \n", + " _grad, _perturbation, _prediction, _loss = sess.run([grad, perturbation, prediction, loss], {data: x,\n", + " target: target_label})\n", + " perturbation.load((_perturbation - np.sign(_grad)*step).squeeze(),sess)\n", + "\n", + " # update the global UAP for the minimal change and then project to controll the magnitude\n", + " if np.argmax(_prediction, axis=-1) == np.argmax(target_label, axis=-1):\n", + " _global_uap += _perturbation\n", + " _global_uap = L2_projection(_global_uap, volume*10)\n", + " global_uap.load(_global_uap, sess)\n", + " EarlyStop = 0 \n", + " break\n", + " \n", + " # calc the new fooling rate \n", + " current_fooling = current_fooling / train_set.shape[0]\n", + " return _global_uap " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6Iqj7K8tlSD1" + }, + "outputs": [], + "source": [ + "# check if the train set contain balance data points\n", + "def isPortion(data, min_p,max_p, target):\n", + " nSamples = data.shape[0]\n", + " X_ben, y = prep(data, 0,5, 5)\n", + " a = np.argmax(y, axis = -1)\n", + " unique_elements, counts_elements = np.unique(a, return_counts=True)\n", + " if target == 'up':\n", + " return (counts_elements[0]>=(min_p*nSamples)) and (counts_elements[0]<=(max_p*nSamples))\n", + " return (counts_elements[1]>=(min_p*nSamples)) and (counts_elements[1]<=(max_p*nSamples))\n", + "\n", + "# split the test set by trading days\n", + "def splitByDays(X):\n", + " last_day = datetime.strptime(X[0,0], '%Y-%m-%d %H:%M:%S').day\n", + " arr = []\n", + " new_day = []\n", + " i=0\n", + " for raw in X:\n", + " day = datetime.strptime(raw[0], '%Y-%m-%d %H:%M:%S').day\n", + " if day != last_day:\n", + " arr.append(np.array(new_day))\n", + " new_day = []\n", + " new_day.append(raw)\n", + " last_day = day\n", + " return np.array(arr)\n", + "\n", + "# sample unifomly from the data\n", + "def sampleUniform(data,nSamples):\n", + " max_idx = len(data)-35\n", + " idx_arr = np.random.uniform(0,max_idx,nSamples)\n", + " samples = [data[int(i):int(i)+35] for i in idx_arr]\n", + " return np.array(samples)\n", + "\n", + "# prepering the train and test sets creating and testing the UAP\n", + "def getSamplesByDays(X, target):\n", + " days_data = splitByDays(X[np.int(X.shape[0]*0.7):,:])\n", + " train_UAP = sampleUniform(np.concatenate((days_data[0],days_data[1],days_data[2]),axis=0),120)\n", + " while not isPortion(train_UAP,0.5,0.55, target):\n", + " train_UAP = sampleUniform(np.concatenate((days_data[0],days_data[1],days_data[2]),axis=0),120)\n", + " test_UAP = []\n", + " for i in range(6):\n", + " test_UAP.append(np.concatenate([sampleUniform(days_data[i*5+3+j],40) for j in range(5)],axis=0))\n", + " return train_UAP, test_UAP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WU80AK7A_Kem" + }, + "outputs": [], + "source": [ + "# returns target lable for up/down direction\n", + "def getTarget(direction):\n", + " target = np.ones((1,1),dtype = np.int8)\n", + " if direction == 'down':\n", + " target[0] = 0\n", + " target = keras.utils.to_categorical(target, num_classes=2)\n", + " return target\n", + "\n", + "# projection of the perturbation into a epsilon radius ball (L2 norm)\n", + "def L2_projection(perturbation, epsilon):\n", + " norm = np.sum(np.square(perturbation))\n", + " norm = np.sqrt(np.maximum(10e-12, norm))\n", + " factor = np.minimum(1, np.divide(epsilon, norm))\n", + " return perturbation*factor\n", + "\n", + "# avareging the UP/DOWN results\n", + "def procResult(evals):\n", + " evals = np.array(evals)\n", + " res = []\n", + " for i in range(3):\n", + " res.append((evals[i]+evals[i+3])/2)\n", + " return res\n", + "\n", + "# creates random noise for comparison with our attack\n", + "def getRandomUAP(size):\n", + " mask = np.zeros((35,7),dtype=np.float32 )\n", + " rand_noise = np.random.normal(0,1,25)\n", + " factor = size/np.mean(np.abs(rand_noise))\n", + " mask[5:30,3] = rand_noise*factor\n", + " return mask\n", + "\n", + "# calculate the relative size of our perturbation\n", + "# simply divide the mean perturbation size by the mean of the traind close price\n", + "def relativeSize(train_data, UAP):\n", + " trained_mean = np.mean(train_data[:,5:30,3],dtype=np.float32)\n", + " perturbation_mean = np.mean(np.abs(UAP[5:30,3]))\n", + " return perturbation_mean/trained_mean*100\n", + "\n", + "# changing only the 8 most significant gradients\n", + "def updateStep(perturbation, gradient, step):\n", + " top_significent = np.sort(np.abs(gradient[:,3]))[-9]\n", + " gradient = np.where(gradient**2 0.95: # update the UAP untill reaching 95% fooling rate\n", + " break\n", + " current_fooling = 0\n", + " # now i move for batch iterations\n", + " for batch in [train_set[i*8:i*8+8,:,1:] for i in range(int(train_set.shape[0]/8))]: \n", + " init_new_vars_op = tf.initialize_variables([perturbation])\n", + " sess.run(init_new_vars_op)\n", + " _prediction = sess.run([prediction], {data: batch, target: batch_labels})\n", + " batch_acc = accuracy_score(np.argmax(batch_labels,axis=-1), np.argmax(_prediction[0], axis=-1))\n", + " current_fooling += (batch_acc*8)\n", + " if batch_acc>0.95:\n", + " continue\n", + " # create the minimal perturbation needed to take x to the target class\n", + " for _ in range(10): \n", + " _grad, _perturbation, _prediction, _loss = sess.run([grad, perturbation, prediction, loss], {data: batch,\n", + " target: batch_labels})\n", + " perturbation.load((updateStep(_perturbation,_grad[0], step)),sess)\n", + " # update the global UAP for the minimal change and then project to controll the magnitude\n", + " _global_uap += _perturbation\n", + " _global_uap = np.clip(_global_uap,-30*step,30*step)\n", + " _global_uap = L2_projection(_global_uap, volume)\n", + " global_uap.load(_global_uap, sess)\n", + " # calc the new fooling rate \n", + " current_fooling = current_fooling / train_set.shape[0]\n", + "\n", + " return _global_uap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SXSwaUmhOF3m" + }, + "outputs": [], + "source": [ + "\n", + "def tf_preprocess(x_adv):\n", + " aggN = 5\n", + " input_shape = (35,7)\n", + " num_classes = 2\n", + "\n", + " ########### preprocess ########################\n", + " cSlices = int(np.floor(35/aggN))\n", + " slices = tf.stack([x_adv[i*aggN:i*aggN+aggN, 3] for i in range(cSlices)])\n", + " avg = tf.reduce_mean(slices, axis=1)\n", + " std = tf.keras.backend.std(slices, axis=1)\n", + "\n", + " #compute the trend indicator\n", + " x = np.arange(1, aggN + 1, dtype = np.float32)\n", + " b1 = aggN*tf.reduce_sum(x*slices, axis=1)-tf.reduce_sum(x)*tf.reduce_sum(slices, axis=1)\n", + " trend = b1/(aggN*tf.reduce_sum(x**2) - tf.reduce_sum(x)**2)\n", + "\n", + " #fix time vars\n", + " minute = tf.stack([x_adv[i*aggN+aggN-1, 5] for i in range(cSlices)])# minute\n", + " hour = tf.stack([x_adv[i*aggN+aggN-1, 6] for i in range(cSlices)])# hour\n", + " close = tf.stack([x_adv[i*aggN+aggN-1, 3] for i in range(cSlices)])# close\n", + "\n", + " #tf pseudoLogReturn\n", + " avg_next = tf.concat([[0],tf.identity(avg)],axis=0)\n", + " avg = tf.concat([avg,[0]],axis=0)\n", + " logAVG = tf.log(avg/avg_next)[1:avg.shape[0]-1]\n", + " avg = avg[:avg.shape[0]-1]\n", + "\n", + " #concat time vars\n", + " minute = tf.reshape(minute,[minute.shape[0],1])\n", + " hour = tf.reshape(hour, [hour.shape[0],1])\n", + " close = tf.reshape(close, [close.shape[0],1])\n", + " avg = tf.reshape(avg,[avg.shape[0],1])\n", + " X_time = tf.concat([minute,hour,close,avg],axis=1)\n", + "\n", + " #concat procData\n", + " logAVG = tf.reshape(logAVG,[logAVG.shape[0],1])\n", + " std = std[1:]\n", + " trend = trend[1:]\n", + " std = tf.reshape(std, [std.shape[0],1])\n", + " trend = tf.reshape(trend, [trend.shape[0],1])\n", + " procData = tf.concat([logAVG,std,trend],axis=1)\n", + "\n", + " #create data \n", + " proc_x = tf.stack([procData[i:i+lookBack,:] for i in range(procData.shape[0]-lookBack)])\n", + " proc_y = tf.stack([procData[i+lookBack,0] for i in range(procData.shape[0]-lookBack)])\n", + " proc_y = tf.convert_to_tensor(proc_y)\n", + " proc_y = tf.to_int32(tf.clip_by_value(tf.sign(proc_y), 0,1))\n", + " proc_y = tf.one_hot(proc_y,2)\n", + "\n", + "\n", + " X_lastN = tf.reshape(proc_x, [proc_x.shape[0],proc_x.shape[1]*proc_x.shape[2]])\n", + " X_time = X_time[lookBack:-1,:]\n", + " merged = tf.concat([X_lastN,X_time],axis=1)\n", + "\n", + " sample_x = merged\n", + " return sample_x" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ILTEsK2FrEOi" + }, + "source": [ + "# Full pipeline attack\n", + "\n", + "\n", + "---\n", + "The following are examples of how to run a full pipeline of our attack.\n", + "Its important to note that the models and the preprocess can be replaced with other methods as long as they are implemented with tensorflow/keras, to obtain gradients of the input.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m9mRkU37rwwz" + }, + "source": [ + "White-Box example:\n", + "- proces the data\n", + "- create three alpha models\n", + "- generate TUAP for each model \n", + "- evaluate fooling rates" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true, + "id": "_78uvC40eXEE", + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Symbol: AON\n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'readSymbolData' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 13\u001b[0m \u001b[0mevals\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 14\u001b[0m \u001b[1;31m#preprocess\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 15\u001b[1;33m \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mreadSymbolData\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mSymbol\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 16\u001b[0m \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mparseTime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 17\u001b[0m \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'readSymbolData' is not defined" + ] + } + ], + "source": [ + "# view for white-box scenario\n", + "\n", + "stocks2run = ['AON'] # list of symbols to be tested \n", + "aggParam = 5\n", + "lookBack = 5\n", + "nEpochs = 12\n", + "sizes = []\n", + "results = []\n", + "for idx, Symbol in enumerate(stocks2run):\n", + " print('Symbol: '+Symbol)\n", + " sizes = []\n", + " models = []\n", + " evals = []\n", + " #preprocess \n", + " X = readSymbolData(Symbol)\n", + " X = parseTime(X)\n", + " X = np.array(X)\n", + " # preper the data for training:\n", + " X_train, y_train = get_train_data(X, aggParam, lookBack)\n", + " #save the session for later attack\n", + " sess = tf.Session()\n", + " keras.backend.set_session(sess)\n", + " lockSeed()\n", + " #build and train the model\n", + " nFeatures = (lookBack * 3) + 2\n", + " #creating the 3 models to attack then transfer \n", + " DNN_model, history = create_DNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " models.append(DNN_model)\n", + " CNN_model, history = create_1dCNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " models.append(CNN_model)\n", + " RNN_model, history = create_RNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " models.append(RNN_model)\n", + " print(\"train done\")\n", + " \n", + " # create UAP for each model\n", + " UAPs = []\n", + " cData, test_UAP = getSamplesByDays(X, 'up')\n", + " target_label_down = getTarget('down')\n", + " target_label_up = getTarget('up')\n", + " for target in [target_label_down, target_label_up]:\n", + " UAPs.append(targeted_batch_UAP(cData, models[0],target, isSeries = 0))\n", + " UAPs.append(targeted_batch_UAP(cData, models[1],target, isSeries = 1))\n", + " UAPs.append(targeted_batch_UAP(cData, models[2],target, isSeries = 1))\n", + " sizes.append([relativeSize(cData,uap) for uap in UAPs])\n", + " base_mean_price = np.mean(cData[:,5:30,3],dtype=np.float32)\n", + " max_size = np.max(sizes[0])/100\n", + " print('perturb done')\n", + " # evaluate UAPs\n", + " tData = np.concatenate(test_UAP[:],axis=0)\n", + " scaling = np.mean(tData[:,5:30,3],dtype=np.float32)/base_mean_price\n", + " eval0, eval1, eval2 = [], [], []\n", + " i=0\n", + " _, _, model0_acc = eval_UAP(models[0], UAPs[0], tData, nFeatures)\n", + " _, _, model1_acc = eval_UAP(models[1], UAPs[0], tData, nFeatures-2)\n", + " _, _, model2_acc = eval_UAP(models[2], UAPs[0], tData, nFeatures-2)\n", + " for target in [target_label_down, target_label_up]:\n", + " acc_flips0, _, acc_mal_Target0 = eval_UAP_targeted(models[0], UAPs[0+i*3]*scaling, tData, target, aggParam, lookBack, nFeatures)\n", + " acc_flips1, _, acc_mal_Target1 = eval_UAP_targeted(models[1], UAPs[1+i*3]*scaling, tData, target, aggParam, lookBack, nFeatures-2)\n", + " acc_flips2, _, acc_mal_Target2 = eval_UAP_targeted(models[2], UAPs[2+i*3]*scaling, tData, target, aggParam, lookBack, nFeatures-2)\n", + " rnd_flips0, orig_acc0, rnd_mal_target0 = eval_rand_noise(models[0],tData,target,base_mean_price*max_size,nFeatures)\n", + " rnd_flips1, orig_acc1, rnd_mal_target1 = eval_rand_noise(models[1],tData,target,base_mean_price*max_size,nFeatures-2)\n", + " rnd_flips2, orig_acc2, rnd_mal_target2 = eval_rand_noise(models[2],tData,target,base_mean_price*max_size,nFeatures-2)\n", + " eval0.append([acc_mal_Target0, rnd_mal_target0, acc_flips0, rnd_flips0])\n", + " eval1.append([acc_mal_Target1, rnd_mal_target1, acc_flips1, rnd_flips1])\n", + " eval2.append([acc_mal_Target2, rnd_mal_target2, acc_flips2, rnd_flips2])\n", + " i+=1\n", + " results.append([Symbol, model0_acc, model1_acc, model2_acc])\n", + " results.append(sizes)\n", + " results.append([(eval0[0][i]+eval0[1][i])/2. for i in range(4)])\n", + " results.append([(eval1[0][i]+eval1[1][i])/2. for i in range(4)])\n", + " results.append([(eval2[0][i]+eval2[1][i])/2. for i in range(4)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Black-Box example:\n", + "- proces the data\n", + "- create three alpha models\n", + "- generate TUAP for each model \n", + "- evaluate each TUAP on the unseen models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "id": "C-O1d-J7u1TJ", + "outputId": "154d4baf-d855-4d72-f10a-fe5df58f6715" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train done\n", + "perturb done\n" + ] + } + ], + "source": [ + "# full run for black-box scenario\n", + "\n", + "stocks2run = ['AON' ]\n", + "aggParam = 5\n", + "lookBack = 5\n", + "nEpochs = 12\n", + "sizes = []\n", + "results = []\n", + "for idx, Symbol in enumerate(stocks2run):\n", + " models = []\n", + " evals = []\n", + " #preprocess \n", + " X = readSymbolData(Symbol)\n", + " X = parseTime(X)\n", + " X = np.array(X)\n", + " # np_agg&slice with shifted windows:\n", + " X_train, y_train = get_train_data(X,aggParam, lookBack)\n", + " #save the session for later attack\n", + " sess = tf.Session()\n", + " keras.backend.set_session(sess)\n", + " lockSeed()\n", + " #build and train the model\n", + " nFeatures = (lookBack * 3) + 2\n", + " # creating the 3 models to attack then transfer \n", + " DNN_model, history = create_DNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " models.append(DNN_model)\n", + " CNN_model, history = create_1dCNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " models.append(CNN_model)\n", + " RNN_model, history = create_RNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " models.append(RNN_model)\n", + " print(\"train done\")\n", + " # create perturbation for each model\n", + " UAPs = []\n", + " cData, test_UAP = getSamplesByDays(X, 'up')\n", + " target_label_down = getTarget('down')\n", + " target_label_up = getTarget('up')\n", + " for target in [target_label_down, target_label_up]:\n", + " UAPs.append(targeted_batch_UAP(cData, models[0],target, isSeries = 0))\n", + " UAPs.append(targeted_batch_UAP(cData, models[1],target, isSeries = 1))\n", + " UAPs.append(targeted_batch_UAP(cData, models[2],target, isSeries = 1))\n", + " sizes.append([relativeSize(cData,uap) for uap in UAPs])\n", + " base_mean_price = np.mean(cData[:,5:30,3],dtype=np.float32)\n", + " print('perturb done')\n", + " # evaluate transferability among models\n", + " tData = np.concatenate(test_UAP[:],axis=0)\n", + " for i in range(len(UAPs)):\n", + " eval0, eval1, eval2 = [], [], []\n", + " if i>2:\n", + " target = target_label_up\n", + " else: target = target_label_down\n", + " scaling = np.mean(tData[:,5:30,3],dtype=np.float32)/base_mean_price\n", + " accFlips0, acc_ben_Target0, acc_mal_Target0 = eval_UAP_targeted(models[0], UAPs[i]*scaling, tData, target, aggParam, lookBack, nFeatures)\n", + " accFlips1, acc_ben_Target1, acc_mal_Target1 = eval_UAP_targeted(models[1], UAPs[i]*scaling, tData, target, aggParam, lookBack, nFeatures-2)\n", + " accFlips2, acc_ben_Target2, acc_mal_Target2 = eval_UAP_targeted(models[2], UAPs[i]*scaling, tData, target, aggParam, lookBack, nFeatures-2)\n", + " eval0.append([accFlips0, acc_ben_Target0, acc_mal_Target0])\n", + " eval1.append([accFlips1, acc_ben_Target1, acc_mal_Target1])\n", + " eval2.append([accFlips2, acc_ben_Target2, acc_mal_Target2])\n", + " evals.append([eval0,eval1,eval2])\n", + " results.append(procResult(evals))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h6BHTsbWM9xj" + }, + "source": [ + "# Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "visualizing the our TUAP " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 312 + }, + "id": "8jrzN9-QsKNa", + "outputId": "8e9a02b0-28a8-43ac-9c93-511fd13e78d6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "#visualisation for TUAP\n", + "plt.plot([UAPs[0][i+5,3] for i in range(25)],'ro')\n", + "plt.xlabel('Feature index')\n", + "plt.ylabel('Absolut size')\n", + "plt.title('Visualization of TUAP for increase')\n", + "plt.show" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 312 + }, + "id": "hsABr_MHsKP4", + "outputId": "22b55599-44ff-4ebc-bf6b-4f75138b9220" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot([UAPs[1][i+5,3] for i in range(25)],'ro')\n", + "plt.xlabel('Feature index')\n", + "plt.ylabel('Absolut size')\n", + "plt.title('Visualization of TUAP for decrease')\n", + "plt.show" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4jdD0_c2NE-_" + }, + "outputs": [], + "source": [ + "# creating graphs based on our results:\n", + "dnn_tfr = np.array([[99.3,97.9,97.3,96.1,79.7,88.4],[58.31,50.17,55.90,52.58,48.32,54.82],[51.5,52,53,49.9,48.4,56.4]])\n", + "cnn_tfr = np.array([[99.4,97.3,96.6,96.8,78.4,85.6],[60.06,52.95,53.41,50.91,46.83,55.91],[54.60,47.7,53.7,50,48.9,55.5]])\n", + "rnn_tfr = np.array([[99.1,97.6,96.8,96.4,80.7,89],[51.79,53.61,52.64,52.99,49.48,53.89],[52,45.8,51.3,48.2,49.7,57.3]])\n", + "WB_models_eval_tfr = np.array([dnn_tfr,cnn_tfr,rnn_tfr],dtype=np.float32)\n", + "\n", + "dnn_ufr = np.array([[45,45.9,44.3,46.19,31.29,31.99],[22.05,22.96,15.11,13.83,6.63,6.8]])\n", + "cnn_ufr = np.array([[44.79,49.59,42.89,46.89,29.9,30.29],[22.78,25.04,17.84,15.84,10.61,8.96]])\n", + "rnn_ufr = np.array([[47.09,51.8,45.49,48.49,31.19,31.7],[26.12,24.89,15.88,16.49,7.98,10.17]])\n", + "WB_models_eval_ufr = np.array([dnn_ufr,cnn_ufr,rnn_ufr],dtype=np.float32)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "comparing our results to random perturbation and the original data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "bVYNSXalM9zq", + "outputId": "9f602143-4c32-47e2-fbc4-57fc29d1ec4e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "for model_res in WB_models_eval_tfr:\n", + " for row in model_res:\n", + " plt.plot(row)\n", + "plt.legend(['dnn_TUAP','dnn_rnd','dnn_orig','cnn_TUAP','cnn_rnd','cnn_orig','rnn_TUAP','rnn_rnd','rnn_orig'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "wKViAPywv7MA", + "outputId": "8439a7e7-b36a-416b-f43c-b4d5f5031eb3" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# ploting each fig\n", + "test_num = ['T1','T2','T3','T4','T5','T6']\n", + "\n", + "plt.plot(test_num, WB_models_eval_tfr[0,0,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_tfr[0,1,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_tfr[0,2,:], '-o')\n", + "\n", + "plt.legend(['TUAP','Random','Clean'], fontsize=12, bbox_to_anchor=(0.3,0.35), loc=\"lower right\")\n", + "plt.xlabel('Test Set',fontsize=13)\n", + "plt.ylabel('TFR',fontsize=13)\n", + "\n", + "\n", + "plt.savefig('tfr-dnn',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "ggT56jGPzlez", + "outputId": "5e071ed5-fe50-42c1-ff77-8e666165ccfc" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# ploting each fig\n", + "plt.plot(test_num, WB_models_eval_tfr[1,0,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_tfr[1,1,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_tfr[1,2,:], '-o')\n", + "\n", + "plt.legend(['TUAP','Random','Clean'], fontsize=12, bbox_to_anchor=(0.3,0.35), loc=\"lower right\")\n", + "plt.xlabel('Test Set',fontsize=13)\n", + "plt.ylabel('TFR',fontsize=13)\n", + "\n", + "\n", + "plt.savefig('tfr-cnn',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "NrJvtiHNzqFD", + "outputId": "2ee3149c-175d-4b51-cf86-fc9b2768a918" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# ploting each fig\n", + "plt.plot(test_num, WB_models_eval_tfr[2,0,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_tfr[2,1,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_tfr[2,2,:], '-o')\n", + "\n", + "plt.legend(['TUAP','Random','Clean'], fontsize=12, bbox_to_anchor=(0.3,0.35), loc=\"lower right\")\n", + "plt.xlabel('Test Set',fontsize=13)\n", + "plt.ylabel('TFR',fontsize=13)\n", + "\n", + "\n", + "plt.savefig('tfr-rnn',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 275 + }, + "id": "At_Jw2LRNE52", + "outputId": "abcd10cc-0f2e-455f-cff3-4b140aedf18b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 13, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIQAAAFTCAYAAABI0dcGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUZfrG8fudTHpCaCGE3nsTgh3URVdEEEXFgqKudVdFRV27W+yuorLqKuvPtYPoqqgoolhAVFZ679IhCSWQXibv7485CZMQasqZZL6f68o1M2fOnPNMkmvKfd73OcZaKwAAAAAAAIQOj9sFAAAAAAAAoGYRCAEAAAAAAIQYAiEAAAAAAIAQQyAEAAAAAAAQYgiEAAAAAAAAQgyBEAAAAAAAQIghEAIAoA4zxrxijHnI7ToCGWM2GGPOdK7/1Rjzjts1HYwxxhpjOlTBdr43xlxXFTUFbPOYf3fGmNONMVuqsh4AAFC7EAgBABAkAoOSgGVXG2N+PNZtWmtvstY+UvnqKmaMaeOEJt7q2sfRqo7wJZQZY94wxjzqdh0AAKBqEQgBAFBHGWPC3K4BAAAAwYlACACAWsQY09UZAZNhjFlmjDkv4L43jDH/MsZ8YYzJlnRG4OgOY8xnxpisgJ9iY8zVzn0nG2N+NcbsdS5PDtju98aYR4wxs40xmcaY6caYxs7dM53LDGebJxlj2htjvjXG7DLG7DTGvGuMqX8Ez22qMebWcssWG2MuqGDdKGPMO84+Mpyak4wxj0kaIOlFp54XnfVfMMZsNsbsM8bMM8YMCNhWmDHmfmPMOuf5zTPGtKxgn6c62zjduf0HY8wKY8weY8xXxpjWAeueZYxZ6fw+X5RkDvG8jzfGzHVqSzXGjHOWHzCtq4JRZFHGmPeduucbY3qXW/c+Y8xyp8b/GGOiDlJDhf9XxpgbJI2S9Gfn9/mZs/weY8xWZ7+rjDGDDvb8AABAcCIQAgCgljDGhEv6TNJ0SU0k3SrpXWNM54DVLpf0mKR4SWWmmllrh1lr46y1cZIulrRD0gxjTENJUyWNl9RI0jhJU40xjcpt9xpnvxGS7nKWD3Qu6zvb/ln+8OMJSc0kdZXUUtJfj+ApvinpioDn21tSc6e28q6SlOBsu5GkmyTlWmsfkDRL0i1OPbc46/8qqY+khpLek/RBQDgyVtJlkoZIqifpD5JyAndmjBksaaKkC6213xtjhku6X9IISYnOPic66zaW9JGkByU1lrRO0imHeN4vSHrBWltPUntJkw+xbnnDJX0Q8Lw+cf5PSoySdLaz3U5OTWUc6v/KWjtB0ruSnnZ+n8Oc/7dbJPW31sY7299wFDUDAIAgQCAEAEBw+cQZpZFhjMmQ9HLAfSdKipP0pLW2wFr7raTP5Q8zSkyx1s621hZba/Mq2oExppP84ctIa+1mSedKWmOtfdtaW2StnShppaRhAQ/7j7V2tbU2V/7Aos/BnoC1dq219mtrbb61Nl3+gOm0I3jun0rqZIzp6Ny+UtL71tqCCtYtlD8I6mCt9Vlr51lr9x2ipnestbuc5/espEhJJUHadZIetNausn6LrLW7Ah5+saRXJZ1jrf2fs+wmSU9Ya1dYa4skPS6pjzNKaIikZdbaD621hZKelz98O5hCSR2MMY2ttVnW2l8OsW558wL2M05SlPz/JyVetNZuttbulj8ovKyCbRzJ/1Ugn/y/v27GmHBr7QZr7bqjqBkAAAQBAiEAAILL+dba+iU/kv4UcF8zSZuttcUByzbKP4qmxOZDbdwYkyBpivwBSMkIombOdgKV325goJEjf4BwsH0kGWMmOVOK9kl6R/6RMofkBFjvS7rCGOORP5B4+yCrvy3pK0mTjDHbjDFPlxsZU76mu5zpXXudoC0hoKaW8o/iOZjbJU221i4NWNZa0gsBwd1u+UdGNZfzdwp4XlaH/rtcK//onZXO1Lehh1i3vMD9FEva4uz/gPvl/5sG3lfiSP6vSllr18r/O/mrpDTnb13RdgEAQBAjEAIAoPbYJqmlE5aUaCVpa8Bte7AHO497T9J3zlSgwO22Lrd6+e0eTEX7e9xZ3tOZBnWFDtFDp5w35Z/mNEhSjjMF7cCdWltorf2btbabpJMlDZU0uqKanH5Bf5Y0UlIDJ2jbG1DTZvmnVB3MxZLON8bcFrBss6QbA8M7a220tfYnSdvlD5lK9m8Cb1fwXNZYay+Tf7rWU5I+NMbESsqWFBOwnTD5p6cFCtyPR1IL+f+eB9wv/9808L4Sh/u/OuBvbK19z1p7qvz/N9apGwAA1CIEQgAA1B5z5B+d82djTLjT3HiYpElH+PjHJMVKuq3c8i/kn6p1uTHGa4y5RFI3+acNHU66pGJJ7QKWxUvKkrTXGNNc0t1HWJ+cAKhY0rM6+OggGWPOMMb0dEKSffJPuyoZ4ZJaQT1FTq1eY8zD8vcKKvGapEeMMR2NX69y/ZO2yR9Q3WaM+aOz7BVJ9xljujv1JBhjLnbumyqpuzFmhDHGK2mMpKaHeC5XGGMSnRE6Gc7iYkmr5W8afa4z+ulB+adqBeoXsJ/bJeVLCpxydrMxpoXTJ+oB+UdglXe4/6syv09jTGdjzO+MMZGS8iTlav/vHgAA1BIEQgAA1BJOL51hks6RtFP+/kKjrbUrj3ATl8nfL2aP2X+msVFOv5yhku6UtEv+0TRDrbU7j6CmHPmDptnO9KkTJf1NUl/5R+FMlb/B8tF4S1JP+aeaHUxTSR/KHwatkPSD9gdIL0i6yDmz1nj5p5ZNkz9g2Sh/iBE4lWqc/H2Rpjvb+z9J0eWe5yb5Q6F7jTHXWWs/ln9UzCRnWtxS+f8ucn5vF0t6Uv7fZ0dJsw/xXAZLWmaMyXJqv9Ram2ut3Sv/lMHX5B+tky3/lLBAUyRdImmP/D2XRjj9hEq85zyv9fJPi3u0/M6P4P/q/+TvF5RhjPlE/lDqSWfdHfKPbLrvEM8PAAAEIeOf1g4AABAcjDGjJd3gTEnCMTLGbJB0nbX2G7drAQAAwYcRQgAAIGgYY2LkHxUz4XDrAgAA4NgRCAEAgKBgjDlb/j4/qfJPdQIAAEA1YcoYAAAAAABAiGGEEAAAAAAAQIghEAIAAAAAAAgxBEIAAAAAAAAhhkAIAAAAAAAgxBAIAQAAAAAAhBgCIQAAAAAAgBBDIAQAAAAAABBiCIQAAAAAAABCDIEQAAAAAABAiCEQAgAAAAAACDEEQgAAAAAAACGGQAgAAAAAACDEEAgBAAAAAACEGAIhAAAAAACAEEMgBAAAAAAAEGIIhAAAAAAAAEIMgRAAAAAAAECIIRACAAAAAAAIMQRCAAAAAAAAIYZACAAAAAAAIMQQCAEAAAAAAIQYAiEAAAAAAIAQ43W7AElq3LixbdOmjdtlAEDQmTdv3k5rbaLbdbiN9wkAqBjvE368TwBAxQ71PhEUgVCbNm00d+5ct8sAgKBjjNnodg3BgPcJAKgY7xN+vE8AQMUO9T7BlDEAAAAAAIAQQyAEAAAAAAAQYgiEAAAAAFQbY8zrxpg0Y8zSgGUNjTFfG2PWOJcNnOXGGDPeGLPWGLPYGNPXvcoBoG47bCDECzgAAACASnhD0uByy+6VNMNa21HSDOe2JJ0jqaPzc4Okf9VQjQAQco5khNAb4gUcAHAQHDgAAByKtXampN3lFg+X9KZz/U1J5wcsf8v6/SKpvjEmuWYqBYDQcthAiBdwAMBhvCEOHAAAjk6StXa7c32HpCTnenNJmwPW2+IsAwBUsWPtIcQLOABAEgcOAACVY621kuzRPs4Yc4MxZq4xZm56eno1VAYAdVulm0rzAg4AqAAHDgAAh5JackDAuUxzlm+V1DJgvRbOsgNYaydYa1OstSmJiYnVWiwA1EXHGgjxAg4AOCIcOAAAVOBTSVc516+SNCVg+Win59yJkvYGHGAAAFShYw2EguIFfPqyHZqycKt+3bBbW/bkqNBXXF27AgAcnaA4cPDJgq36enmqNuzMlq/4qDMpAEAVMMZMlPSzpM7GmC3GmGslPSnpLGPMGklnOrcl6QtJ6yWtlfRvSX+qztrem7NJ05bu0JIte7UrK1/+YxgAEBq8h1vBeQE/XVJjY8wWSX+R/wV7svNivlHSSGf1LyQNkf8FPEfSNdVQc6mXv1+nhZszSm97jJQYH6nkhGg1rx+t5IQoJdePVrOAy8ZxkfJ4THWWBQDYf+DgSR144OAWY8wkSSeomg8cPDp1hXZm5UuSIr0etU+MU8ekOHVKileHJnHq2CROrRvFKoz3BQCoNtbayw5y16AK1rWSbq7eivzyi3y6/+MlZZZFej3+7xH1o9QsIVrN6vu/VzSrH61m9aPUrH60osLDaqI8AKh2JhhS8JSUFDt37tyjflxmXqG2783Ttoxcbd+bp+0Zudq2N0/b9+ZqW4Z/eX5R2VFD4WFGSfVKXuADAqOE/S/89WPCZQxfDgC4zxgzz1qb4nYdhxJ44EBSqvwHDj6RNFlSKzkHDqy1u43/xfVF+c9KliPpGmvtYd8AKvM+sSYtS2tTs7QmLVOrU7O0Ni1LWzNyS9eJ8HrUrnGsOibFq1MTf2DUoUm82jSKkTes0q32AKBa1Yb3iZpwLO8T1lrtySnUtozc/T9787Q14HZaZr7Kf11qGBvhD4cCAqNkJyxqXj9aiRyABhBEDvU+cdgRQsEsPipc8VHh6pQUX+H9gS/y2wOCou17c7U9I09zN+7RjsXbVVRuGkF0eJgzusj/Ql9+lFFy/WjFRdbqXx0AVJlgPfIr+d8n+rZqoL6tGpRZnpVfpLVpWVqTmqm1aVlanZqpBZv26LNF20rXCQ8zatc4Th2S4tSpSbw6JvlHFLVpHKtwgiIAqPWMMWoYG6GGsRHq0TyhwnUKioqVui/PCYv83yW2ZuRqe0auNu7K0U/rdikrv6jMY8LDjJom7A+MSkYWlYZHCVGKjwqviacIAIdUp1ONI3mR9xVb7czKLw2NyodHM9ekV3hkID7K64RFzgt8uVFGTROiGE4KAEEqLtKrPi3rq0/L+mWW5xSUBEVZWuMERku27NUXS7aXvg94PUZtG8c6AVF86WXbxrGK8BIUAUBdEuH1qGXDGLVsGHPQdfblBY4yyitz/X+/7VbqvrwDDkDHR3kPmIrmD4v8t5PqRXHwAUC1q9OB0JEI8/inkCXVi9JxB1mn0FdyZKDsKKOSy8Vb9mp3dsEBj2sUG6Hk+v6gqFmC/4U+cJRRUnwk0xEAIIjERHjVq0V99WpRNijKLfBpXbp/2tma1CytTs3S8m379OXSHaVBUZjHqE2jGHVsEq9OSXHqkBSvjk3i1C4xVpFeDhAAQF1VLypc9ZqGq0vTehXe7yu2Ss/MLzMVrWR62raMXC3YtEd7cgrLPMZj5G9zURIaJQRcrx+l5vWjlRBNmwsAlRPygdCRCA/zqEWDGLVocPAjA3mFvtI+RlvLjTLauCtbv6zbpcxyw0k9RmoSHzA1rfSFfv9oo8axzEEGALdFR4SpR/OEA0ab5hX6g6KSUUWrUzO1OjVT05fvUMnBYI+R2jSKVYcm/mbW/h5FcWqfGMdIUgAIAWEe/xSypglR6te6QYXr5BQUlY4u2r43V1sDRhot2ZKhr5blqaBcb9SYiLDS7w/7RxtFl/Y3YsYCgMMhEKoiUeFhats4Vm0bxx50nfJNsEuGkm7fm6vl2/fpmxWpBzTBjgjzKCkhsnSUUUJ0uGIivYqL9ComIkyxkV7FRngVG1nx9ahwD0cOAKCaRIWHqXuzBHVvdmBQ9NvObKehtb+Z9Zq0TM1YmSafkxR5jNSqYYw6OCOKSqaetU+MU3QEH+ABIJTERHjVoYn/gEFFrLXalV1QGhIFBkbb9uZp5co0pWfmH/C4xnGRau5MSUt2DkAnxIT7RzVFe1UvKlwJ0f7bcVFezroJhBgCoRpUmSbY2zJyNXfjHmXmFSk7v+iAecgH4zFyQiKvYiLDSoMk/6XXCY6cACkyTDER3rLrRHoV5ywvWZdpbgBwaFHhYeqaXE9dk8tOHygoKnaCokynT5H/8vtVaaWv68ZILRvEqGOTOHV0pp2VjCqKieBtGwBCkTFGjeMi1Tgu8oBpzSXyi3zaUXqWtJIzMPvDozVpWfphdbpyCnyH3E98pFf1osMVH+UtExrViw5XvSivc1l+uX/9+Cgv3xOAWoZPlkHkSJpgl8gv8ikn36es/CLlFJRc+sOi7Hyfsgucy/wi53qRsgv8t3PyfdqWkaecgiJl5fuUU1B02DeHQJFeT2mAVBo2BYRMcZFhjGICgApEeD3q3DRenZuWPTBQUFSsjbv8I4pWp2Y6I4uyNHNNugp9+w8AtGgQrY7O1LMOTmDUoUkcZ74EACjSG6bWjWLVulHFMxastdqXV6R9uYXKzCvSvrxC7cstLF3mvx24vFDbMvK0Kj+zdHn5E+2UFxsRdpDQyFsmPKponfgoL420gRrGJ8haKtIbpkhvmBrERlTJ9oqLrXIKfcrJLzogZMrKL7t8f8i0/3pmXpF27M0rfdyxjGKKKRcYxUWGKzE+Uk3iI9WkXqSaxEeVXm8cF8kbBoA6I8Lr8Y8GSorXkJ7JpcsLfcXauCtHa9NKpp35z3w2e+0uFfj2TzFuXj+6dKpBw9gIxTmhfFyUV/HOZVyk1xmp6lWklyAeAEKNMUYJ0f4pYseiuNgqu6Bof4BUQZiUmVc2WErN9I9OKgmZDvf1ICYirExQdLDwqKLAKT4qnLN9AkeJQAiSJI/HlH6BaFJF2yw/iik7cARTYNhU4IRN+T5lFRQpx1lny54cLdi0R7sqOIObMVLDmAh/YFTPCYpKw6OS21FKjI+kFweAWis8zFMa9AzusX95ka9Ym3bnlAZEa5ym1nN+26W8wuKDb9Dh9ZjSkMgfFO0PjEpDpDJBkldxkf4P5oEhU3R4GMESAIQIj8eUtsBoXj/6qB9vrVV2ga80QMosPzKp/CilvELtzCrQ+p3Zyswr0t7cwtI+fAcTFe4pExLFRnr9B9LDPYr0epyD6h7ntnPd61FkeMD1MssDb5fdToTXQ88l1HoEQqg2VTWKqdBXrJ1Z+Urbl6+0zHylZeaVXk/PzFNaZr5W78jUzqz8CkclxUd6lVgvsjQkqmjEUWJ8lOpFefliA6BW8IZ51C4xTu0S43R296Zl7ssv8ikrzx+0ZzqXpbed65l5haXLS5btzCrQhl05ynTuL3+Sg4p4jPYHSSXBUVTZkCkucn/IdOD9/vtiwsNC8oya1lr5iq2KistfFvsvfWWXt0+MpT8HgFrLmP0HoJvp2AKl3ELfAdPayt52Rik5yzLzirSrqED5RT7lFxX7fwr3X6+s8DBzyGAposJgqYIA6hCBVcQhgizeE1BZBEIIeuFhHuesCId+4yguttqTU+CERvlK25fnhEb7Q6SFmzOUlplX4RH0SK+nbFDkjDZKjIssEyg1io0IyS8uAGqHSG+YIuPC1CguslLbKSgqVnZ+uWApv7D0emZeUbngyR8y7cku0KbdOaX35xYevkedMVJcRNnAKC4qvMKRSoFBUpTXU0GgUrz/tu8gy8vcX8HygECmKPDxvoOsd8D+iisOenwHLj8aJ7RtqPeuP5Ej0gBCkjFGMRH+nqVNE6IqvT1rrQp99qBhUZnrRT7lFwZcLyp2bvsOuL8gYJ3cQp8ycgsqfGxeke+wPZkOJ8xjSsOh6PAw/fH09rrypDaV/t0gdBAIoc7weIwaxUWqUVykuiYffD1rrTLzi5xRRnn+wCjwema+1qRlafbandqXV3TA48M8Ro3jIg4YYVR+ylrjuEjmMQOotSK8HkV4Iyo9yrPIV6zsfJ8y88uOStofKBWWGamU5YRQ+3ILtXVPTuljso/i5AdHKzzMKMxj5PV4nEuz/zKsguVhntLr4WEeRYWX3OcJeEzANjyeCrZZwfLS+w9cvj49Wy/MWKMJM9frj6e3r7bfBQCECmOMIrxGEV6PKj4HdPWy1n9g4LDhU2GxCnwVLw8MmZZv26eHP12m5g2i9bsuSS48I9RGBEIIOcYY/9ziqHB1aBJ3yHXzCn1lRhiVn7K2bW+eFm3J0K7sggoT/oaxEUqMKwmNDj5ljVNJA6irvGEeJcR4lBBzbE1MS/icZqaBo5LyC31OQHOwcMVTQThTNuCpLSM+rbVanZqpcV+v0umdE9U1uZ7bJQEAKsEYo/Aw/4GFqjhbaG6BTxe98pPGTFyoT24+WR2auBFzobbhWyhwCFHhYWrZMEYtG8Yccr0iX7F2ZhWUhkXpWftHHZVMYVuXlqX0rPwyp5AuERfp1bk9k/XkhT3pYwQAFQjz7A/zQ5ExRo9d0FO/btijO95fqCm3nKJILydNAAD4RUeE6d+jU3Teiz/qujfnasrNp1b6YAzqPgIhoAp4wzxqmhB12PnMxcVWGbmFB4w4Wrk9U+/P3ayOSXG6bkC7GqoaAFCbNIyN0FMX9tS1b87VuK9X675zurpdEgAgiDSrH61Xr+ynSyf8olsmztd/ru5P42kcEoEQUIM8HqOGsRFqGBuhLgEnBrLW39DuyS9Xqm/rBurbqoF7RQIAgtagrkm6tH9LTZi5Xmd2TVL/Ng3dLgkAEET6tW6ox87vqT//d7Ee/2KlHh7Wze2SEMSIC4EgYIzR0xf1VtOEKN3y7nxl5BS4XRIAIEg9OLSbWjSI1tjJC5WVf+DJDwAAoW1k/5b6wylt9frs3zT5181ul4MgRiAEBImE6HC9dHlfpWfl687Ji2Qrex5KAECdFBfp1biRfbRlT64e/Xy52+UAAILQ/UO6aEDHxnrgkyWau2G32+UgSBEIAUGkd8v6un9IV81YmabXZv3mdjkAgCDVv01D3TCwnSb9ulkzVqS6XQ4AIMh4wzx68bK+al4/Wje9M09bM3LdLglBiEAICDJXn9xGg7s31VPTVmrexj1ulwMACFJjz+qkLk3jdc9/l2hXVr7b5QAAgkxCTLheuypF+YXFuuGtucot8LldEoIMgRAQZIwxeuqiXkquH6Vb35uvPdn0EwIAHCjSG6bnLumjvbkFeuDjpUw1BgAcoEOTeI2/7Dgt375Pd31IWwqURSAEBKEy/YQ+WKTiYl64AQAH6ppcT2PP6qxpy3bo4wVb3S4HABCEzujSRPcO7qKpi7frpe/Wul0OggiBEBCkerWorweGdNW3K9P02o/r3S4HABCkbhjYTv3bNNBfpiyjRwQAoEI3DGynC45rrmemr9b0ZTvcLgdBgkAICGJXndxG5/RoqqemrdK8jZwdAABwoDCP0bMX95HPWt3NqFIAQAWMMXpiRE/1bpGgO95fqJU79rldEoIAgRAQxEr6CTWvH61b31tAPyEAQIVaNYrRQ0O76ad1u/TGTxvcLgcAEISiwsP06pUpio306vq35mo33y1CHoEQEOTqRfn7Ce3MKqCfEADgoC7t31KDujTRU9NWam1aptvlAACCUNOEKL16ZT+l7svXze/OV6Gv2O2S4CICIaAW6NkiQQ+c6+8n9O9Z9BMCABzIGKMnLuypmIgw3fH+Ij7kAwAqdFyrBnpyRE/9vH6XHvl8udvlwEUEQkAtMfqk1jqnR1M9/RX9hAAAFWsSH6XHL+ipJVv36p/fciYZAEDFRvRtoRsHttNbP2/Uu3M2ul0OXEIgBNQSgf2EbqGfEADgIM7pmawRxzXXS9+t1cLNGW6XAwAIUn8e3EWnd07UX6Ys05z1u9wuBy4gEAJqkZJ+QrvoJwQAOIS/nNddSfGRGvv+QuUW+NwuBwAQhMI8RuMvO06tGsXoj+/O1+bdOW6XhBpGIATUMj1bJOjBof5+QhPoJwQAqEBCdLj+cXFvrd+ZrSe/XOF2OQCAIFUvKlyvjU5Rka9Y1781V9n5RW6XhBpEIATUQlee2FpDejbVP75apbkb6CcEADjQKR0a65pT2ujNnzdq1pp0t8sBAASpdolxevHyvlqdmqmxkxcyCyGEEAgBtZAxRk9e2EstGkTr1okLtJt+QgCACtwzuIvaJ8bq7g8Wa29OodvlAACC1MBOibp/SFd9tSxVL8xY43Y5qCEEQkAtVaafEEk+AKACUeFheu6SPtqZla+HP13qdjkAgCB27altdVG/Fnphxhp9sWS72+WgBhAIAbVYj+YJemhoV323Kp1+QgCACvVqUV+3/q6jpizcps8Xb3O7HABAkDLG6LELeqhvq/q6c/IiLdu21+2SUM0IhIBa7ooTW+vcnsn6x1er9Cv9hAAAFbj5jPbq3bK+HvxkqVL35bldDgAgSEV6w/TKlf1UPyZcN7w1Tzuz8t0uCdWIQAio5YwxeuLCnv5+Qu/RTwgAcCBvmEfjRvZWXqFP9/x3saxlmjEAoGJN4qM04coU7czK1x/fmaeComK3S0I1IRAC6oCSfkK7sws4MwAAoELtE+N03zld9f2qdL07Z5Pb5QCSJGPMbcaYpcaYZcaY251lDY0xXxtj1jiXDdyuEwg1PVsk6B8X99avG/boL58u5UBCHUUgBNQRPZon6KFh3fT9qnS9OpN+QgCAA115YmsN6NhYj01doQ07s90uByHOGNND0vWSjpfUW9JQY0wHSfdKmmGt7ShphnMbQA07r3cz3XxGe03832a9/ctGt8tBNSAQAuqQK05opXN7JeuZ6fQTQnDgyC8QXDweo6cv6qXwMKOxkxeqyMc0ALiqq6Q51toca22RpB8kjZA0XNKbzjpvSjrfpfqAkHfnWZ11Ztcm+ttny/XT2p1ul4MqVqlAiA/6QHAxxujJEfv7Ce2iCRxcxJFfIDglJ0TrkfN7aP6mDEaUwm1LJQ0wxjQyxsRIGiKppaQka23JOa93SEpyq0Ag1Hk8Rs9d0kftE2P1p/fma+MuRpfWJcccCPFBHwhO8WX6CS2inxDcxJFfIEid17uZzu2VrOe+Xq2lWzmtMNxhrV0h6SlJ0yVNk7RQkq/cOlZShR9mjDE3GGPmGmPmpqenV3e5QMiKjwrXv0enSJKue3OuMvMKXa4IVaUyI4T4oA8EqZJ+Qj+sTtcrM9e5XQ5CF0d+gSBljNGjw3uoYWyExk5eqLxC3+EfBFQDa+3/WWv7WWsHStojabWkVGNMsiQ5l2kHeewEa22KtTYlMYB0/OkAACAASURBVDGx5ooGQlDrRrF6+fK+Wr8zW3e8z0ls6orKBEKV+qBPog9UrytOaKWhvZL17PTV+t9v9BNCzePILxDcGsRG6KmLeml1apaenb7K7XIQoowxTZzLVvIfXH5P0qeSrnJWuUrSFHeqAxDo5A6N9fDQbvpmRZqe/Zr3jbrgmAOhyn7QJ9EHqpcxRk+M6KmWDaI1ZiL9hOAOjvwCwe2Mzk006oRWeu3H3/TL+l1ul4PQ9F9jzHJJn0m62VqbIelJSWcZY9ZIOtO5DSAIjD6ptS47vqVe+m6dpizc6nY5IWHGilT946uV1bLtSjWVrswHfQDVLz4qXC9e3le7cwp0B/2E4AKO/ALB7/4hXdWqYYzunLyIvhCocdbaAdbabtba3tbaGc6yXdbaQdbajtbaM621DHUGgoQxRn87r4f6t2mgP3+4WEu20IeuuuzMytetExfo2jfn6pvlacopKKryfVT2LGN80AeCXI/mCXp4aDfNXJ2uf/1APyHUOI78AkEuNtKrcSP7aPveXP39s+VulwMACHIRXo/+dUU/NY6L1PVvzVVaZp7bJdUp1lp9NH+Lzhz3g6Yt3a47zuykz249VTER3irfV6UCIfFBH6gVRp3QSsN6N9Oz01fRTwg1iiO/QO3Qr3UD/fH09vpg3hZNX7bD7XIAAEGucVykJozup725hbrx7XnKL+LkBFVhy54cXfWfXzV28iK1axyrL8YM0G1ndlSEt7LRTcUqO2WMD/pALWCM0eMX9FDrRrG6deJ8+gkBAA5w26BO6pZcT/d9tEQ7eZ8AABxG92YJGjeytxZsytADHy+Vv4UwjoWv2Oo/s3/T75+bqbkbduuvw7rpg5tOVsek+Grdb/XETACCjr+f0HHak1NIPyEAwAEivB49d0kfZeYV6b6PlvDBHgBwWOf0TNZtgzrqw3lb9H8//uZ2ObXSmtRMXfTKT/rbZ8vVv01DTb9joK4+pa3CPKba900gBISQ7s0S9Jdh9BOqSevSs3T3B4tUUFTsdikAcFidm8br7rM76+vlqfpw3ha3ywEA1AK3Deqowd2b6vEvVmjm6nS3y6k1CoqK9fw3qzVk/Cxt2Jmt5y7prTeu6a8WDWJqrAYCISDEXH78/n5CczjFcLWx1urdORs1dPyP+npFqtalZ7ldEgAckT+c2lbHt22ov322XJt357hdDgAgyHk8Rs+O7K1OSfG65b35Ws/n3sNasGmPhv5zlp7/Zo3O6ZGsr8eepguOayFjqn9UUCACISDEGGP0xIieat0oVmMmLaBPRDXYlZWv69+apwc+XqqUNg301e0D1TW5nttlAcARCfMYPXtxb0nSXR8wxRgAcHixkV79e3SKvGEeXffWXO3LK3S7pKCUU1Ckv3+2XCP+9ZMy84r0f1elaPxlx6lxXKQr9RAIASEoLtKrly7v6+8n9P5CPuxXoe9Wpens52dp5pp0PTS0m9685ngl1YtyuywAOCotG8bo4WHdNOe33Xp9Nj0hAACH17JhjF4e1VebduVozMQF8vEdo4yZq9P1++dm6vXZv2nUCa00/Y6BGtQ1ydWaCISAENWtWT39dVh3zVqzk35CVSCv0Ke/TFmqa/7zqxrFRujTW07Rtae2lacGmsEBQHW4uF8Lndk1SU9/tUqrUzPdLgcAUAuc2K6R/ja8u75fla6np610u5ygkJFToDsnL9Lo1/+niDCPJt94kh49v6fio8LdLo1ACAhllx3fUuc5/YR+oZ/QMVu2ba+G/fNHvfnzRv3hlLaacssp6tKUKWIAajdjjJ68sKfiI7264/2FNMcHAByRUSe01pUnttarM9fro/mhe4ICa60+X7xNZ477QVMWbtXNZ7TXF7cN0PFtG7pdWikCISCEGWP0+IieatMoVmMm0k/oaBUXW02YuU7nvzRbe3ML9fa1x+vhYd0UFR7mdmkAUCUax0XqiRE9tWzbPo2fscbtcgAAtcTDw7rpxHYNde9HS7Rg0x63y6lx2/fm6vq35uqW9xYoOSFan95yqu4+u0vQfU8gEAJCXFykVy+N6qu9ufQTOhrbMnI16rU5evyLlRrUJUlf3T5QAzomul0WAFS533dvqov6tdDL36/VvI2h96EeAHD0wsM8enlUPyXVi9SNb8/Tjr15bpdUI4qL/Wca/v24mfpx7U49MKSrPv7TyerWLDhnDxAIAVDX5Hr663n+fkIvf7/W7XKC3ueLt2nw8zO1aEuGnr6wl/51RV81iI1wuywAqDZ/GdZNyQnRunPyQuUUFLldDgCgFmgYG6HXRvdXdn6Rbnx7rvIKfW6XVK3Wp2fp0n//ogc+XqqeLRL01e0Ddf3AdvKGBW/sEryVAahRl/ZvqeF9mmnc16vpJ3QQmXmFGjt5oW55b4HaJcbpizEDNLJ/SxlD42gAdVt8VLieHdlbG3fn6PEvVrhdDgCglujcNF7PXdJHi7bs1b3/XSxr695shEJfsV7+fq0GvzBLK7bv01MX9tS7152g1o1i3S7tsAiEAEjy9xN67IL9/YTSM+knFGjuht0aMn6WPlmwVWMGddQHN52kNo2D/0UeAKrKie0a6dpT2uqdXzbp+1VpbpcDAKglft+9qe76fSd9snCbXp253u1yqtTSrXs1/MXZenraKv2ucxPNGHuaLunfqtYcMCYQAlCqfD8hH/2EVOgr1rjpqzTy1Z8lSR/cdJLGntVJ4UE89BMAqstdZ3dWp6Q4/fnDxcrIKXC7HABALXHzGR00tFeynpq2Ut+uTHW7nErLK/TpiS9XaPhLs5Wela9XruirV67spyb1otwu7ajwjQZAGV2T6+lv53XXj2t36uXvQruf0G87s3XRKz9r/LdrNaJvC30xZoD6tQ6e00QCQE2LCg/TuJF9tDu7QA9+stTtcuqEBZv26LGpy+vkNAoAKGGM0T8u6q1uyfU0ZuJCrU3LdLukY/bzul0a/PxMvfrDel3Ut4W+ueM0De6R7HZZx4RACMABLunfUuf3aabnvlmtn9eFXj8ha60m/W+Tzh0/Sxt2ZuvlUX31zMW9FR8V7nZpAOC6Hs0TdPuZHfX54u2asnCr2+XUWtsycnXbpAW64OWf9PGCbUrdx1RtAHVbdESYJoxOUVS4R9e9OVd7cwrdLumo7M0t1H0fLdZl//5FxVZ677oT9NRFvZQQU3u/IxAIAThAaT+hxrEaMym0+gntzi7QjW/P070fLVGflvU17fYBGtKzdib+AFBdbjqtvY5rVV8PfbI0ZE4lXFWy84v07PRVOuOZ7/Xl0h26+Yz2+v7u09U0oXZNMwCAY9G8frReuaKftmbk6paJ81XkK3a7pCPy1bIdOmvcD3r/1826YWA7fXX7QJ3cobHbZVUagRCACsVGevXS5X21L4T6Cc1cna7Bz8/U96vS9cCQrnrn2hOUnBDtdlkAEHS8YR6NG9lHhT6ruz9cxHSnI1BcbPXB3M0645nv9c9v1+r33Zvq2ztP091nd1FcpNft8gCgxqS0aajHzu+pWWt26vEvVrpdziGlZebpT+/O041vz1PD2Ah9cvMpun9IV0VHhLldWpXg3QfAQXVNrqe/D++ue/67RC99t1ZjBnV0u6RqkVfo01PTVuo/szeoY5M4vXHN8erWrJ7bZQFAUGvbOFb3n9tVD32yVG//slGjT2rjdklBa876XXpk6nIt3bpPfVrW17+u6Kd+rRu4XRYAuGZk/5ZasWOfXp/9m7o0jdfI/i3dLqkMa60+nLdFj05dodwCn+4+u7NuGNiuzp1YhkAIwCGNTGmpX9bv1vPfrFZKmwY6uX3tHxoZaMX2fbp90kKtSs3U1Se30b3ndFFUeN1I/AGgul1xQit9szxVj3+xQqd2aKx2iXFulxRUNu7K1hNfrNS0ZTvULCFKL1zaR8N6NZPHUztORwwA1emBIV21JjVLD3yyRO0SY5XSJjhO3rJ5d47u/3iJZq3Zqf5tGuiJEb3UoUndfH+rW/EWgCpnjNGj5/dQm8axum3SwjrTT6i42Oq1Wes1/MXZ2pVdoDeu6a+/ntedMAgAjoIxRk9f1EuR3jDdMXlRrekFUd325RXq8S9W6KxxM/XD6nSNPauTZtx5uob3aU4YBAAOb5hHL15+nJrXj9ZN78zT1oxcV+vxOd8Pfv/cTM3fuEePDO+u9284qc6GQRKBEIAjEBvp1cuj+iozr270E9qxN0+jX/+fHp26Qqd1TtRXtw/Q6Z2buF0WANRKSfWi9Oj5PbRoc4Ze/n6d2+W4qshXrHd+2agz/vG9/j1rvc7r00zf3326xgzqWGf6TQBAVaofE6HXrkpRXmGxbnhrrnILfK7UsXLHPo341096dOoKndS+kb4ee5quPKlNnQ/xCYQAHJEuTevp7+f10I9rd+rFb9e6Xc4x+3LJdg1+YabmbdyjJ0b01IQr+6lRXKTbZQFArTasdzOd17uZxs9YoyVb9rpdjitmrk7XkPGz9OAnS9W+SZw+u+VUPXNxbyXV4+xhAHAoHZrEa/xlfbR8+z7dVcMnKsgv8unZ6as0dPyP2rw7Ry9c2kf/d1WKmtUPjRPL0EMIwBG7OKWFflm/S8/PWK3+bRrUqlMtZuUX6W+fLtMH87aoV4sEPX9JH3pdAEAVemR4D835bZfumLxQn996ashMwV2blqXHpi7Xd6vS1aphjP41qq8G92gqY+r2UWUAqEq/65KkewZ30ZNfrlTXpvG65XfVfzKbeRt3657/LtHatCxdcFxzPTS0mxrGRlT7foMJgRCAI2aM0SPn99CiLRkaM2mhvrjtVDWJD/4jn/M37dEd7y/U5t05uuWMDrrtzI517gwBAOC2hJhw/eOi3hr9+v/09LRVenhYN7dLqlZ7sgv0/Der9c6cTYoJD9N953TR1ae0UaQ3NIIwAKhqNw5sp5Xb9+mZ6avVKSlev+/etFr2k5VfpH9MW6m3ftmoZgnR+s81/XVGiLaP4BsRgKPi7yfUT1n5wd9PqMhXrOe+Xq2LX/lZRT6r9288SXed3ZkwCACqycBOiRp9Umu9Pvs3/bRup9vlVIuComL934+/6bR/fKe3f9moS/u31Hd3n64bT2tPGAQAlWCM0ZMX9lKvFgm64/2FWrljX5Xv47tVafr9uB/01i8bddVJbfTVHQNDNgySCIQAHIPOTeP19/N6aPbaXUHbT2jjrmxd/OrPemHGGp3Xu5m+vH2A+gfJqSwBoC6775yuatc4VndNXqR9eYVul1NlrLX6enmqzn5+ph75fLl6t6yvL28bqMcu6KnG9KIDgCoRFR6mCVemKCbSq+vfmqvd2QVVst3d2QW6fdICXfOfXxUT6dWHN52sv57XXXGRoT1pikAIwDG5OKWFRvRtrudnrNZPa4PnKLC1VpPnbtaQF2ZpXVqWxl92nJ67pI/qRYW7XRoAhIToiDA9O7K3UjPz9ddPl7ldTpVYsX2fRr02R9e/NVfGSK9fnaK3/nC8OjeNd7s0AKhzmiZEacKV/ZS6L183vztfhb7iY96WtVZTFm7VmeN+0NQl2zVmUEdNHXOq+rVuUIUV114EQgCOiTFGj57fQ+0T4zRm0kKlZea5XZL2ZBfoT+/O158/XKyeLRI07faBOq93M7fLAoCQc1yrBrr59Pb6aP5WTVu63e1yjll6Zr7u+2ixzh0/S8u379Nfh3XTV7cP1O+6JNE0GgCq0XGtGuiJC3rq5/W79Mjny49pG9sycvWHN37VbZMWqmXDGH1+6wCNPasT03sDhPb4KACVEhPh1UuX99Xwl37U7ZMW6u1rT1CYx50PyD+u2ak7P1io3dkFuvecLrp+QDvXagEASLcO6qhvV6Xp/o+Xqm/rBrXiJAQl8gp9en32b3r5u3XKK/Tp6pPbasygDqofE1pnnwEAN13Yr4VWpWZqwsz16tw0XqNOaH1EjysutnpnzkY99eVKFVvpoaHddPXJbfhuUAFGCAGolM5N4/X34T3007pd+ue3a2p8//lFPj36+XJd8X9zFBfp1cd/OkU3ndaeF3wAcFl4mEfPjeyjrPwi3fffJbI2eE9CUMJaq6mLt+vMcT/o6WmrdGK7hpp+x0A9PKwbYRAAuOCewV10WqdE/WXKMs1Zv+uw669Ny9LIV3/Ww1OWqW/rBpp+x0Bde2pbvhscBIEQgEobmdJSF/ZtoRdmrNHsGuwntGpHpoa/OFuv/fibRp/UWp/fOkA9mifU2P4BAIfWMSle9wzuohkr0zR57ma3yzmkRZszNPLVn3Xze/MVF+nVu9edoNeu6q92iXFulwYAISvMYzT+suPUqlGM/vjufG3enVPheoW+Yr347RoNeWGW1qRl6ZmLe+utPxyvlg1jarji2oVACECVeOT87mqfGKfbaqCfUHGx1es//qZhL/6onVn5ev3qFP19eA9FRzAfGACCzTUnt9FJ7Rrp758t16ZdFX+Qd9P2vbka+/5CDX9ptn7bma0nRvTU1DEDdEqHxm6XBgCQlBAdrtdGp6jQV6zr35qr7PyiMvcv3pKhYf/8Uc9MX62zuiXpm7Gn6aJ+Lej1dgQIhABUiZgIr14e1VdZ+YW6beJC+YqrZ2pA2r48Xf3Gr/r758s1oENjTXOaewIAgpPHY/TMyN7yGKM7P6i+94ejlVNQpOe+Xq0znvleny/Zrj+e3l7f3XW6Lju+FVMLACDItEuM04uX99Xq1EyNnbxQxcVWuQU+PTZ1uc5/abb25BRowpX99NKovkqMj3S73FqDptIAqkynpHg9MryH7v5wscbPWKM7zupUpdv/atkO3fvfxcot9OnR83to1AmtSP4BoBZoXj9afz2vu+78YJFem7VeN57W3rVaioutPlm4VU9PW6Ud+/J0bs9k3XtOF6YVAECQO61Tou4f0lWPTl2huz9crF837Nam3Tm67PhWum9IF9WLCne7xFqHQAhAlbo4paV+Wb9b479do+PbNqySIffZ+UV65PPlmvTrZvVoXk/PX3KcOjShpwMA1CYj+jbX18tT9ez01RrYKVFdk+vVeA2/btitRz5frsVb9qpXiwT98/Lj1L9NwxqvA/sZY+6QdJ0kK2mJpGskJUuaJKmRpHmSrrTWFrhWJICgce2pbbVie6b+O3+L2jSK0aQbTtSJ7Rq5XVatxZQxAFXukfO7q0NinG6btEBp+yrXT2jh5gydO36W3p+7WX88vb0++uMphEEAUAsZY/TYBT1ULzpcd7y/UPlFvhrb9+bdObr53fm6+JWflbYvX+NG9tYnfzqFMMhlxpjmksZISrHW9pAUJulSSU9Jes5a20HSHknXulclgGBijNHjI3ro1Sv7adrtAwmDKolACECVK+knlJ3v05hJC46pX0SRr1j/nLFGF/7rJxX6rCZef6LuGdxFEV5etgCgtmoUF6mnLuyplTsy9fw3a6p9f5l5hXryy5UaNO4HzViZqtsGddS3d52mEX1byEOfoGDhlRRtjPFKipG0XdLvJH3o3P+mpPNdqg1AEIr0huns7k0VFc4JZSqLb1YAqkXHpHg9cn4P/bJ+t16YcXQf+jfvztGlE37Rs1+v1tBeyfritgGk/7WUMeYOY8wyY8xSY8xEY0yUMaatMWaOMWatMeZ9Y0yE23UCqDmDuibp0v4t9eoP6zR3w+5q2Yev2Gri/zbpjGe+1ys/rNPQnsn67q7TdcdZnRQTQceEYGGt3SrpGUmb5A+C9so/RSzDWltyGqEtkpq7UyEA1G0EQgCqzUX9Wuiifi30z2/X6Mc1Ow+7vrVW/523Ree8MEurdmTq+Uv66IVLj1NCNA3iaiOmAgA4mAeHdlPzBtEaO3mRssqdPriyZq/dqXPHz9J9Hy1Rm0axmnLzKRp3SR8lJ0RX6X5QecaYBpKGS2orqZmkWEmDj+LxNxhj5hpj5qanp1dTlQBQd1UqEOLIL4DD+ftwfz+h298/dD+hvTmFumXiAt35wSJ1S66nL28foPOP44BgHcBUAAAHiIv06tmL+2jznhw9NnVFlWxzfXqWrnvzV416bY6y8ov04uXH6YObTlLvlvWrZPuoFmdK+s1am26tLZT0kaRTJNV33jckqYWkrRU92Fo7wVqbYq1NSUxMrJmKAaAOOeZAiCO/AI5E+X5CRb7iA9b5ad1ODX5hpr5aukN3n91ZE284US0acPrf2o6pAAAO5fi2DXXDwHaa+L9N+nZl6jFvJyOnQH/7bJl+/9xM/bJ+t/48uLO+GXuahvZqJmPoExTkNkk60RgTY/x/rEGSlkv6TtJFzjpXSZriUn0AUKdVdsoYR34BHFbHpHg96vQTGh/QTyi/yKcnvlihUa/NUXR4mD7608m6+YwOCqPRZ53AVAAAhzP2rE7q0jRef/5wiXZnH91ZxQt9xXpj9m86/Znv9eZPG3RxSgt9d9fp+tPpHWg0WktYa+fI/71hvvynnPdImiDpHkljjTFr5T/1/P+5ViQA1GHH3FXPWrvVGFNy5DdX0nRx5BfAQVzYr4V+Wb9L//xurfq3bajkhCiNmbhQy7fv06gTWumBc7vS6LPuKZ0KIEnGmDJTAZz3ikNOBZD/i4FSUlKO/lR1AIJepDdM40b20fCXftSDnyzRS5f3PeyoHmutvluVpsemrtC69Gyd0qGRHjy3m7om16uhqlGVrLV/kfSXcovXSzrehXIAIKQc87evckd+MyR9oKM88ivpBklq1arVsZYBoBb5+/AeWrQlQ7e8t0B5hT7FRXr12ugUndktye3SUD1KpwLIf+BgkKS52j8VYJKYCgCEvG7N6mnsWZ311LSV+mThVl1wXIuDrrtqR6Yenbpcs9bsVNvGsfr36BSd2bUJU8MAADgGlZkyRhM4AEclOiJML4/qq2JrdVL7Rvry9gGEQXUYUwEAHKkbBrZTSusGenjKMm3LyD3g/p1Z+br/4yU654WZWrQ5Qw8N7aavbh+os7olEQYBAHCMKjM/gyO/AI5ahybxmvvgmYr00t8hFDAVAMCRCPMYPTuyt855YZbu/nCR3v7DCfJ4jPKLfHpj9ga9+O1a5RT6NPqkNrptUEc1iOUktgAAVFZlegjNMcaUHPktkrRA/iO/UyVNMsY86izjyC+AMgiDAADltW4Uq4eGdtN9Hy3Rmz9vUNN6UXriy5XatDtHv+vSRPcP6aoOTeLcLhMAgDqjUh1cOfILAACAqnJp/5b6enmq/vbZcklSp6Q4vfWH4zWwE+0FAACoapzSBwAAAEHBGKMnL+ypez5crEFdk3Rp/5byhlWm5SUAADgYAiEAAAAEjSbxUfrPNQw2BwCgunHIBQAAAAAAIMQQCAEAAAAAAIQYAiEAAAAAAIAQQyAEAAAAAAAQYgiEAAAAAAAAQgyBEAAAAAAAQIghEAIAAAAAAAgxBEIAAAAAAAAhhkAIAAAAAAAgxBAIAQAAAAAAhBgCIQAAAAAAgBBDIAQAAAAAABBiCIQAAAAAAABCDIEQAAAAAABAiCEQAgAAAAAACDEEQgAAAAAAACGGQAgAAAAAACDEEAgBAAAAAACEGAIhAAAAAACAEEMgBAAAAAAAEGIIhAAAAAAAAEIMgRAAAAAAAECIIRACAAAAAAAIMQRCAAAAAAAAIYZACAAAAAAAIMQQCAEAAAAAAIQYAiEAAAAAAIAQQyAEAAAAAAAQYgiEAAAAAAAAQgyBEAAAAAAAQIghEAIAAABQ44wxnY0xCwN+9hljbjfGNDTGfG2MWeNcNnC7VgCoiwiEAAAAANQ4a+0qa20fa20fSf0k5Uj6WNK9kmZYaztKmuHcBgBUMQIhAAAAAG4bJGmdtXajpOGS3nSWvynpfNeqAoA6jEAIAAAAgNsulTTRuZ5krd3uXN8hKcmdkgCgbiMQAgBUC3pDAACOhDEmQtJ5kj4of5+11kqyB3ncDcaYucaYuenp6dVcJQDUPQRCAIBqQW8IAMAROkfSfGttqnM71RiTLEnOZVpFD7LWTrDWplhrUxITE2uoVACoOwiEAAA1gd4QAICDuUz7p4tJ0qeSrnKuXyVpSo1XBAAhgEAIAFAT6A0BADiAMSZW0lmSPgpY/KSks4wxaySd6dwGAFQx77E+0BjTWdL7AYvaSXpY0lvO8jaSNkgaaa3dc+wlAgBqs4DeEPeVv89aa40xB+0NIekGSWrVqlW11ggAcIe1NltSo3LLdsk/shQAUI2OeYQQvSEAAEeI3hAAAABAkKmqKWP0hgAAHAy9IQAAAIAgU1WB0FH3huA0kQBQ99EbAgAAAAhOx9xDqMSx9oaw1k6QNEGSUlJSKlwHAFC70RsCAAAACE5VMULomHpDAAAAAAAAwB1VEQjRGwIAAAAAAKAWqVQgRG8IAAAAAACA2qdSPYToDQEAAAAAAFD7VNVZxgAAAAAAAFBLEAgBAAAAAACEGAIhAAAAAACAEEMgBAAAAAAAEGIIhAAAAAAAAEIMgRAAAAAAAECIIRACAAAAAAAIMQRCAAAAAAAAIYZACAAAAAAAIMQQCAEAAAAAAIQYAiEAAAAAAIAQQyAEAAAAAAAQYgiEAAAAAAAAQgyBEAAAAAAAQIghEAIAAAAAAAgxBEIAAAAAAAAhhkAIAAAAAAAgxBAIAQAAAAAAhBgCIQAAAAAAgBBDIAQAAAAAABBiCIQAAAAAAABCDIEQAPw/e/cdVtWV9n38u+kdQWkqKlYQsGFPNCYmMaZojClqqlHT+7zPTGYm/clMMiVljEkmUVOeRFOM0VRjjCnWKIhGUESwICJFejsHTtnvH4uqaCzAaffnuriA4+GwNsJZ+/z2ve4lhBBCCCGEEC5GAiEhhBBCCCGEEEIIFyOBkBBCCCGEEEIIIYSLkUBICCGEEEIIIYQQwsVIICSEEEIIIYQQQgjhYiQQEkIIIYQQQgghhHAxEggJIYQQQgghhBBCuBgJhIQQQgghhBBCCCFcjARCQgghhBBCCCGEEC5GAiEhhBBCCCGETWia1kXTtM80TdunaVqGpmnjNE0L1TRtnaZplkp8JwAAIABJREFUWQ3vQ2w9TiGEcEYSCAkhhBBCCCFs5T/Ad7quxwJDgQzgcWC9rusDgPUNnwshhGhnEggJIYQQQgghOp2macHARGApgK7r9bqulwPTgfcb7vY+cK1tRiiEEM5NAiEhhBBCCCGELcQAx4F3NU3bqWnaEk3T/IEIXdfzG+5TAETYbIRCCOHEJBASQgjRYaQ3hBBCiNPwAEYAb+q6Phyo4YTlYbqu64De1hdrmnaXpmkpmqalHD9+vMMHK4QQzkYCISGEEB1JekMIIYQ4laPAUV3XtzV8/hkqICrUNC0KoOF9UVtfrOv627quj9R1fWRYWFinDFgIIZyJBEJCCCE6hF30htj2Fhza0GEPL4QQ4tzpul4A5GqaNqjhpsnAXuBL4PaG224HvrDB8IQQwul52HoAQgghnFbL3hBDgR3Aw3RWbwhzHWz7L5QehEFXwmXPQbcBHfKthBBCnLMHgWWapnkBB4G5qIvWn2qaNg/IAW604fiEEMJpSYWQEEKIjmLb3hAe3nDvFpj8FBzaCG+MhW//CLWlZ/9YQgghOoSu67saln0N0XX9Wl3Xy3RdL9F1fbKu6wN0Xb9U13V54hZCiA5wXoGQNAsVQghxGrbvDeHpCxP+AA+lwvBbIXkx/GcYbF6oKoiEEEIIIYRwUedbISTNQoUQQrTJrnpDBITDNa+qiqHo0bDuSVg0CvasAr3NAiUhhBBCCCGc2jkHQnbRLFQIIYS9a+wNsRsYBvwdeBG4TNO0LODShs87R3gc3PIZ3PI5eAXAijvgnSlwNKXThiCEEEIIIYQ9OJ+m0rZtFiqEEMLu6bq+CxjZxj9N7uyxtNJ/MvSdBDs/hB+fhyWTIWEmTH4aQnrbdGhCCCGEEEJ0hvNZMmbbZqFCCCHE+XBzh6TbVX+hif8D+75Vy8jWPQ3GCluPTgghhBBCiA51PoGQ7ZuFCiGEEOfLOxAueQIeTIH4GbD5VVg4ApKXgMVs69EJIYQQQgjRIc45ELKrZqFCCCHE+QruCde9BXf9DGGx8M0f4M3xsH+tNJ4WQgghhBCdTtd1vj74Nf/Y/o8Oefzz6SEEzc1CvYCDwFxUyPSppmnzgBzgxvP8HkIIIUTn6T4c7vga9n0D656C5TeqfkOXPw+RibYenRBCCCGEcAH7SvfxwrYXSC1KJb5rPAazAV8P33b9HucVCNlts1AhhBDifGgaxF0NAy6HlHfglxfhvxNg+M1wyZMQGGnrEQohhBBCCCdUbixn0a5FrNi/gmCvYJ4Z9wwzBszATTufjj9tO98KISGEEMJ5eXjB2Htg6E2w4d+w7S1IXwUXPAzjHwAvf1uPUAghhBBCOAGL1cLKrJUs3LmQqvoqZg2axX3D7iPYO7jDvqdjB0K6rq7iCiGEEB3JNwSm/A1GzVO7kP38d9jxHkx+EobMArf2v2IjhBBCCCFcw86inbyw7QUySjNIikjiz6P/zKDQQb//hefJsQOh758AzQ0u/gt4tu9aOiGEEOIkoX3hpg8gZyus/Qusvhd+fVOFRTETbT06IYQQQgjhQI7XHueVHa/w1cGvCPcL558T/8kVfa5A66TCF8e9pKnrYKqFLQtVX4cj22w9IiGEEK6i9ziYvx6uWwKGMnj/GvhoNhRn2XpkQgghhBDCzpksJt5Lf49rVl/Dd4e/Y37ifL669iumxkzttDAIHDkQ0jS4+hW4dTWY6+CdKfDdX6C+1tYjE0II4Qrc3GDIDfBAMkx+Cg5thDfGwrd/hJoSW49OCCGEEELYoS15W7juy+t4acdLJEUksXr6ah4e8TB+nn6dPhbHDYQa9bsY7tui+jr8+jr89wI4vNnWoxJCCOEqPH1hwh/goZ0w4jZIXgwLh8PmheqChRBCCCGEcHlHq47y8I8Pc/cPd2PRLSy6ZBGvT36dXkG9bDYmxw+EALwD4aqX4PavQbfCe1eqK7T1NbYemRBCCFcREKYqV+/dAtGjYd2TsGgU7FmlljkLIYQQQgiXYzQbeWPXG1z7xbVszd/KQ8MfYtX0VVwUfZGth+YkgVCjmAnqRHzMPbD9bXhjHBzaYOtRCSGEcCXhcXDLZ3DL5+AVACvuUMuac5NtPTIhhL2qKbb1CIQQQrQzXdf5IecHpq+ezpu/vcnF0Rfz5bVfsmDIArzdvW09PMDZAiEAL3+Y+g+YuwbcPFSjz68fhboqW49MCCGEK+k/Ge7ZCNcshNJDsPRS+OxOKMux9ciEEPaivga+fFD1H6susvVohBBCtJOD5Qe5a91dPPrzo/h5+vHOlHf410X/ItI/0tZDa8Wxt50/nd7j4J5N8NPfYOvrkLUOpi2EfpfYemRCCCFchZs7JN0OCdfB5v/AlkWQ8TWMvRcmPAY+wbYeoRDCVo7thJXz0UsOcGzsAnr4dLH1iIQQQpyn6vpq3vztTZZnLMfX05fHRz/OTYNuwsPNPqMX56sQasnLD6b8DeZ9r5p+fjBDXYUxVth6ZEIIIVyJdyBc8gQ8uKMhHHpVNZ7evhgsZluPTgjRmaxW2PQqLLmMVGstc4ddzMzSjZSbZadcIYRwVFbdypcHvuTqVVfzwd4PmN5/Ol/P+Jqb42622zAInD0QahQ9Gu7eCBc8Ajs/VL2FstbZelRCCBdQVFvEwtSFWHWrrYci7EFwD5jxX7jrZwiLg2//H7w5HvavlcbTQriCymPwwXT2bniee2MGcnsXDw7XlfHQ8Idsst2wEEKI87e3ZC+3rbmNv276K90DurP8quU8M/4ZQn1CbT2032W/UVV78/SBy56FwdNg9f2w7HoYOgeu+Dv4hth6dEIIJ6PrOquyV/Hv5H9Tb63n0t6XMrjrYFsPS9iL7sPhjq8h81v4/klYfiPEXKSqWiMTbT06IURHyPiKA988zOv+HqzrEUWwhxuPJj7K7NjZ+Hr42np0QgghzlKZsYyFOxeycv9KQnxCeG78c0zvPx03rQPqbnQdNK3dH9Z1AqFGPZLg7l9gw79g48tw4Ee45lUYNNXWIxMn6qBfeiE6Wm5VLs9ueZZtBdtIikji2fHP0juot62H5ZIsVgvubu62HkbbNA1ir4L+l0HKO/DLi/DfCTD8Zrj4CQiKsvUIhRDtob6G3G8e4c289XzdzR9fDx/uTZjLrYNvJdAr0NajE0IIcZbMVjMr9q9g0c5F1JhquDnuZu4bdl/7P6eb6+Hgz5C+Eirz1MXEduZ6gRCAh7fq5RB7NXxxP3w0CxJvVLuT+dl/WZdT03U49ItaW394kwrw+l0MfS9WH7u75q+scAwWq4Xl+5bz2s7XcNPceHLsk1w/8PqOuUogfpeu69z9w91EB0Zz39D7CPMLs/WQ2ubhBWPvgaE3wYZ/w7a3IP1ztcx5/ANq90whhEMqOPgjb69/lFWeFtwDA7k97mbuHLKAEB+pThedxGqF6gIoPajeKvPBJwh8Q9Xrnsb3fqHgHSQXY4X4HTsKd/DCthfILMtkTOQYHh/9OP1D+rffN7Ba4PBGFQJlfAWGMrUJSdw1YDGBu2f7fS9cNRBq1H0YLPgJNr2sKoYO/gxXvaSWlYnOZbVAxpcqCMrfBQERMOI2tQPHzy/Czy+oSarPhOaAqGs/mbSE3cguy+bpLU+zu3g3E3pM4KlxT9ndtpKuxmw10ze4LysyV/DNwW+4bfBtzE2Yi7+nnQYsviFqydioebDuafj577DjXZj8FAyZBW4SLArhKEpri1ny/YN8Up6G1RNmdp/IXRc+Q7hfuK2HJpyR1aqqBxpDn1Zvh8BsOLPHcfNoOyhq+rjrCf/eFXy7qB01hXByhTWFvLzjZb499C2R/pG8dNFLXNb7MrT2eD1qtULuNtjzOexZDTVF4BUAg66EhJlqp3QPr/P/Pm3QdDtoYjly5Eg9JSXFtoMoSIPV90HBboi/Dq78F/h3s+2YXIHJCL8thy2vqUkrtB9c8DAMnaUquQBqS1XV0IGf4OBPUH5E3R4cDX0nqYAoZhL4d7XRQQhXZrKYWJq+lLd2v0WAZwB/Gv0nroq5qn0mB0DTtB26ro9slwdzYOczTxypPMJ/Uv/D9znfE+oTyt1D7uaGgTfg2c5XWNpdzlb4/q+QtwMih6iwKGairUclhDiNyvpK3ktdxIeZH1OnW7nGPZR7r3iTHmHxHfY9ZZ5Q7OL1REeyWqDiKJQeaA56WoY+lrrm+7p7Q2gMhPZteGv8uB8EdYe6KlV1UFsKtSVgKG3j49Lmjw2lYKk/xcA0Vb1wYmDk11Vd6GgZHrUMlxrP84Wwc/WWej7Y+wFv7X4Li9XC3IS5zEucd/6933RdFT+kr4Q9q1So6+EDA6eoEGjA5Wqn9HZwunlCAqGWLCa1FfDP/1BPbFf+C+JnSBVKRzCUQ8pS+PW/KgHtPgIufEQt4zvdVQZdVxPfwZ9UQHRoI9RVABpEDVGVQ/0uhuixqpG4EB0ovTidp7Y8RVZZFlP7TOVPo/9EV9/2DSblRF9pj3ki7XgaL+94mZTCFKIDo3loxENM6T2l3cK7DmG1qqtFPzwDFbnqStFlz0G3AbYemRCihVpTLcsylvHu7repshiZUlvHfUPvpu+4xzr8PFLmCcVuXk+cD4sZKo40hzwlB5pDn7LDYDU139fDp0Xgc8JbUPf2rdrRdaivbhESlUBt2SmCpJLmsMlUc+rH9ApoCIdC2giSGquQQloHSV7+jv+6zGpV4Z25ToVsrd7XqZ4xrd7Xqdeop/yaFl9rManzg74XQ9QwqSxuB5vyNvHi9hfJqcxhUvQk/jjqj0QHRp/7A+o6FO5R53bpK9XftZsn9L9UhUCDrgDv9u8tJ4HQ2SrcC1/cpxK7uGvgqpchQEp820VlPvz6BqS8C/VV0G+yCoL6TDi3J3iLWf0/NQZER7eD1QwevtB7fPPysoh4x59AhN0wmA28uetN3t/7Pt18uvHE2Ce4uNfFp/4Cq/WcJ2U50Vfaa57QdZ2NeRt5ZccrZJdnk9A1gcdGPsaoyFHtMMoOZDLAr2+qzRDMBhh5J1z0uMtWRlqsFtYfWc++0n2MjhpNUniS/Vd8CadUZ6nj08xPWbJ7MaV1ZVxUa+AB93Bir3u/04JbmScUu3s9cSoWE5TltLG064Cqgream+/r6X9ChU9f1TIhtC8ERNr/C36TsXWVUW1J68qjtm43Vpz68dy9T72cra0qJL9Q9ZrAUn8GocuZhjNtBDKnC2lOfIyW/7/ny81D/Uw8vNR7N3dVZQLqZ9B3klpq1O9iCO7Zft/XBeRW5fLP5H/yc+7P9Anqw59G/4kLe1x47g9YnKX6Q6avhOJM0Nyh70VqZVLc1R2+67kEQufCYoatr8FPL4CXH0z9FyReL6HCuSrOgs3/gd2fqCfC+BlqaVjU0Pb9PnVVcHhzc0BUnKlu9w9vXl7Wd5K6ciLEOUguSOaZLc9wpOoIMwfM5LGRjxHkFdT2nU1GVQmXvBTm/3BOTevlRF9p73nCYrXw5YEvWbRrEUW1RUzsOZFHRjzCgBA7r7ypPt7QW+g98AqEif8Pxtzt3KX3uq5Ork0GTHWVfHV4De9mreRwbX7TXfw8/BjXfRwTe07kwh4XSp8W0eFMVhOrs1fz1m9vUVhbyBizGw8UHWNY0j1wyZMd1uuhLTJPKHb1esJc1xD6HDg5+CnPBd3SfF+vQOjaVqVPP3VB2tVee1jMqsLolNVHpS2qkxqDpLLWP9OOoLmrudbdq/l9y49bvW8R0jS9b+t+Le7v7nn2X9tWFVh1keqLe+BH9VZdqG7vNki9Dup3CfS+ALwDOvbn5aAMZgNL0pbwXvp7uLu5c8/Qe7g17tZzu+hUltNcCVSQBmjqZ58wA+KmQ0DnbXYigdD5OJ6pdiI7mqxK9a9+BQKlUewZO5oCm16Bfd+oJ6/ht8C4B9SVjs5QkaeeFA/+pN7XHFe3h8U2Ly+TJ0VxBqrrq3llxyt8uv9Tegb05JnxzzAmakzbd7aYVW+sn/8BlUdVCHnNfyCkz1l/XznRVzpqnjCajXyY8SHvpL1DjbmGaf2mcf+w++2/IXhRBnz/JGSvgy694bJnYfC1nffCwWJWlUomY8P7hjezscXHDf9uqm24/Qzu2/TvxlZfX6vBZ4EBvB8cSJGHB3F19cwvr2C8wUiynz8bQyPZ4KlRqKseGnEhg5gQfRETekwgsVsi7tLwVLQTi9XCmsNreGPXG+RW5TLEJ5yHcjIY4x4EM/6rnu87mcwTSqe/njAZ1HKPxqCnpEVvn4pcoMVrLO/gFqFPv9bBj3831wt92pvVqlpINIZDLcMjs7EhcPE6w6DlFIGMI84juq7OFxrDoZzN6ufh5gm9xjavpJDlZei6zvc53/PvlH9TUFPAlTFX8ljSY0T4R5zdA1UeU02h01dCXsPzUc9RqhIo/lqbFSVIIHS+rBa1zOnH59UTwhUvwtDZ8uR9KroO2etVP6bDG8GnC4xeAKPv7tQk9CRWKxTtaW5OnbOl+UkxenRzQNR9uGM+6YsOs+HoBp7b+hzHDce5Je4W7h92P36efiffUddh7xfquaIkC3okweSnVUnoOZITfaWj54lyYzlvp73Nx/s+xk1z4+a4m5mXOO/U1V/24sCPsPYJ9dwWPQYufRa69PqdYKYxjKk9IXhpK5g58b4N92vZx+JsaO7g6ad6vHn4qmaJrT72VX0xGj6ucHNjuTGXZdXZVFjrGOXXk/mRFzIuZDCalx/U10D+b5D/G3r+Lvabq9no58tGP192eXtj1aCLuw8XdBvKxL5XcUHvSwj2Dm7f/wPhEnRd58cjP7Jo1yKyy7MZGNyXhypqmXhoO1rs1TDttXOqAm0PMk8o5zpPFNQUEOEX0XY/ufqaE5o3t3hrXJrTyDf05CqfxuVdviHyukHYnskIub82B0QFaep2F19ell2WzYvbX2RbwTYGhQziz2P+TFJE0pk/QE0x7F2tloTlbAF0iExUPYHiZ5zTBeH2JoFQeynOhi8fgCNbVdfvq1+F4B62HpX9sJhVh/TN/4HCNAjsDuMfUNvHd0BzrPPW9KT4U8OT4m51u0+w2smnMSAK7WvbcQqbKTOW8Y/kf/DNwW/oF9yP5y54jiFhQ06+o66r36H1z0H+LlWBdsmTEHvVeZ8Ayom+0lnzRF51Hq/tfI1vDn5DsHcwdyXexazYWXi5d97yj7NmtcDOD+GnvzWXhp8Nj4ZQxtOvOYxpEcqoj1uGOOdx3zMsuS6sKeT/9v4fK/avwGA2MCl6EvMT5zM07DTLjHVdXZXP/w2O7aLiWCpbyvaywd3EZl8fytzdcdNhqEcgE0PimND7cgb2uwLNVwIicWq6rrPl2BZe2/kae0r20CeoD/eHj+fyTW/jZjLAFS9A0h02fbEv84RyLvNEjamGyz+7jBjfSO4KG8MEizta2aHmEKgqv/UX+HVrDnlO3MGrg3uACNHumpaXNbwWqi5Qt3cb2BAOOffysqr6Kt7Y9QYf7fsIf09/Hhz+IDcMvOHMqooNZZDxtVoSdvAXtWSx2yAVAiVcZ3ebf0gg1J6sVtj+ttrxxd1TbQM8/FbXTv3ra9WLka2vqWZ43Qap/kCJN3TqGvrzVlPcvLzswM9qqQ+o5RiNJZUxE212BVB0Hl3X+e7wd7yw7QWq6qtYMGQB8xPntx0K5CbD+mdVNVxwL7j4LzDkxnarMpMTfaWz54mMkgxe2fEKW/O30iOgBw8Mf4ArY67ETbPjkuq6ahXK65YzDG4a3tvR/JVTmcO76e/yxYEv0HWdqTFTuTPhznPv7aTrUJWP5dhO0g//yMbjO9lQX0SGhzrmCLOZCRYvJgT1ZWyPC/DrMUrtWCkv7ASwo3AHC1MXklqUSnf/7tyTcCfXZG3FY8e7EDkEZi6FsIG2HqbMEw3OZZ6oN1ay6vU4lnYJIt/Dg9i6ehYYNS4N6I3biUu7QmPURUMhnNFJy8u2qGrhxuVlfSepgMgJlpdZdStfZH/Bq6mvUmYs4/qB1/Pg8AcJ8fmdub+uCjK/U8vBsn9Q1dIhfRpCoJkQPtiuzqlakkCoI5QehC8ehJxN6o/jmoXQ5Ty2oHNEtaWwfTFsf0ut040eAxc8AgOvcPgnCnQdSrKbl5cd2qh2RdPc1BNhY0AUPcaxQi/xuwprCnl+2/P8nPsz8V3jee6C5xgY0sYJf+Fe+PF/IfNb8A+Dif+jrhK3c3NfOdFXbDVPbDm2hVd2vMK+0n3EhcbxSNIjjO8+vtPH4ewySjJYkraEdTnr8HTzZMaAGdwRfwc9AzumbL2oaA+b969iQ/5WttYepQYrnrrOKIORCQYjEz1C6BU5XG18EDVMvbnojm6uaE/xHl7b+Rqbj22mm2837hpyFzODBuH1+T1qs4rxDzY0jraPZu4yTyjnPE9sewuTXze+qc9nac4aDlcdISY4hvmJ85kaMxVPN9nBULggJ11ell6czgvbXmB38W6Ghg3lL2P+wuCug0/9BSYD7F+rKoH2r1VL54N6qKVgCTNVqxE7DYFakkCoo1itagehdU+roODy5yBprkP8UpyXiqOw9XXY8T6YamDAFLjwUeg9ztYj6zgWE+TtaA6Ijqaoq/Ce/tDngublZWGxzv//76R0XWdl1kpeSnkJk9XEg8Mf5Oa4m/Fw82h9x7LDavfB3Z+opZAXPARj7u2wclo50VdsOU9YdSvfHvqW11Jf41jNMcZFjePRpEeJ6xpnk/E4C13X2VG4gyVpS9h8bDMBngHcNOgmbhl8C918u3XaOEwWE6lFqWw49D0bj/7CIYNadtfbAhOqK5lYayDJWIdXUE/oPqxFSDQUAs+y2aSwa9ll2SzatYj1R9YT7B3MvIR5zBp4I7473lOV4b6hMONN9ULIjsg8obTHPGGxWliXs47FaYvZX7afHgE9uDPhTq7tf619Lx0WJ8kszeSjfR9RUFPA0PChJIUnkRiWiK+Hr62H5piqi9TSqKbdyxxreVmpsZT/pP6HVVmrCPUJ5bGRj3F136vbrvw216tjTF+pLvzWV6uLv/EzVHPo6DEOV/wggVBHK8uBLx+EQ7+oJUXTXrOL5lHtrihD9QdKW6E+T7heLQ2LOE2q6qyMFXB4U3NAVJKtbg+MUql534bt7eXFgkPIrczlma3PsL1gOyMjRvLs+GfpFdSr9Z2qCmHDv9R2327uaqvvCx7p8CWEcqKv2MM8UW+p56N9H7E4bTEVdRVc3fdqHhj+AD0CpJfc2dB1nV+O/sLStKXsOr6LUJ9Qbh18KzcNuolAL9v3m8utymXj0Y1syNtAcn4y9dZ6/DRPxroFMKG6kgnHjxBhadjeOCDy5JAoqLtcGHAwRyqP8MZvb/DtwW/x8/Tj9sG3c+vgWwmoq4bV96oXBoOuhGmL7LJSTOYJpT3nicbnqbd3v01acRrhvuHcHn871w+8vu1NJYRdMFvN/JT7E8sylrGjcAc+7j70DOzJgfID6Oh4uHmQ0DWBEREjSIpIYnj4cLuYdxxOy+VlB3+Cw5ubl5dFj2ne3t4OlpeZrWY+yfyE13e+jsFs4Oa4m7ln6D0EeJ0QXFnMcHiDCoEyvlKv9XxDIG6aqgTqc6FDbzokgVBn0HX1QvH7J0G3qi2AR86z+R9Bu8jZqnYM2/+d6kcx4nYYd7/rLZE7nfLcht5DDdvbG0rV7eHxzcvLeo8HLzmJsCcWq4UPMz5k0c5FuLu584eRf2DmgJmtrxYYylUQuu2/YKlXTdIn/hGCojpljHKir9jTPFFZX8nStKUsy1iGVbcyO3Y2CxIX0MWni62HZtfMVjPfHf6OpWlLyS7Pprt/d+5IuIMZ/Wfg4+Fj6+G1qdZUS3JBMhuObmBD3gYKatQV0UH+PZnoHc5EYz2JRQdwL85Scz+oprMnhkRdeklIZIcKagr472//ZXX2ajzdPJkdN5s74+9Uf8uZ38EX96k+iVP+BiPvtNv/Q5knlI6YJ3Rd59f8X1mctpjkgmRCvEO4dfCtzIqdJUGCHSkzlrEyayWfZH5CQU0BPQJ6MGvQLGYMmEGwdzCV9ZXsKtrFjsId7CjcwZ7iPZh1Mxoag0IHkRSRRFJEEiPCR9DV1/5CX7tnp8vLkguSeWH7C2SVZTEuahyPj36cvl1abBZktarNotJXql2Ca4vBKxDirlaVQH0nOU1rEAmEOlN5Lnz1MBxYD70vhGkL1W4EjsZqhay1sOlV9QfuG6oqIkbfdc4VEXWWOsqMZU1vpXWlzZ/XtbjdWEp5XTkmq4kh3YYwOmo0IyNGEt8t3jHWcVutaseyxoDoyK9gqQN3r+bUvO/F6kWCAyfNji6rLIuntzxNWnEaE3tO5MmxTxLpH9l8h/paFQJtflVdJUi4XjWM7uS/ZznRV+xxniioKeD1Xa/zRfYXBHgGMC9xHjfH3Wy34Yat1FnqWJ21mnf3vEtedR79gvsxL3EeV8Rc4RjP6Q10XSe7PJsNRzewMW8ju4p2YdEtBHsHc0HkGCb69+YCk06Xov1qt8GiDLW0GNRVxqihrUOikBjnuGjkgEoMJSxJW8KnmZ9ixcoNA29gQeICwvzCVL+I75+A5CUQkQjXL4WwQbYe8mk5+jyhadphoAqwAGZd10dqmhYKfAL0AQ4DN+q6Xna6x+noeWJn0U7e3v02m/I2EegZyOy42dwSd8vvN6IVHSajJIPl+5bz7cFvqbfWMyZqDDfH3szEnhNPu1OUwWwg7XiaCoiKdvBb0W8YLUYA+gT1aQqIkiKS6B7QvbMOx3nYeHlZQU0BL6W8xHeHv6O7f3f+OOqPXNLrEjRNU0UceTtUCLRnldpJ0MMXBk1Vu4P1v0xtyuFkJBDqbLqudt1a+1dVUTD5KRWmOMKLf3M9pH+mKiKO71O7Jo1/AIbfAl7+TXfTdZ0aU80pg51S48m31Zpr2/yW7po7wd7BhPqEEuITQoh3SNPkuqNwB9nlajmWr4cvI8JHMCpyFKMiRzG46+CT+7vYo/palT437l5W2Jiah0DMRc3IgG+1AAAgAElEQVQBUUhvmw7TVZgsJpakLeHttLcJ9Azk8dGPMzVmqpokQP0N7Pw/+OWfagvvAVNg8pMQmWiT8Tr6iX57sed5Iqssi1dTX2XD0Q1E+EVw/7D7mdZv2pltW+rEquur+STzEz7Y+wElxhKGdBvCvMR5TIqeZN+7tZ2hiroKtuZvZePRjWzK20SpsRQ3zY0h3YYwoecEJkaOYVCdCa3gN8j/TYVEhXvVriQA3sFqR7OWIVHX/hISdaCKugre3/M+H2Z8SJ2ljmn9pnHP0Hual30WpMPKeer8Z9wD6vzNThpHn46jzxMNgdBIXdeLW9z2T6BU1/UXNU17HAjRdf1Pp3uczpon9pbsbWqC7+vhyw0Db+D2+NsJ9wvv8O8twGQ1sf7Iej7K+IjUolR8PXy5pu81zI6dTf+Q/uf2mBYTe0v3klqYyo7CHaQWpVJVXwVAlH9U0xKzpPAkYoJjms8Zxe874+Vl53+hvN5Sz/t73mdx2mKsupV5CfOYmzAXH3dvVbWUvlI1hy4/oi7UD7hc9QUaeIXd9j5qLxII2UrlMfjqEVVpEz0Gpr8O3c5x69wOZjFUUJGymLLUdyg1FFMe0puyAZdQGtKbsvqKk6p4yurKMDWe1J7A2927KdgJ9Qmli0+Xpo9DfEJahT6hPqEEegWe9sVBqbGUlIIUkguSSS5I5kDFAQD8PPwYEaECotGRo4kNjXWMgKgxNW+sIKo6pm4Pi23ettARq8ocQHpxOk9ufpLs8mymxkzl8dGPE+rTUPFmtaow9Ke/qcbRvcbB5Kdt3izd0U/024sjzBPJBcm8nPIy6SXp9O/Sn0eTHmVCjwkud+JYYihhWcYyPt73MVWmKsZFjWN+4nxGRY5y2p+FVbeyp3gPG/I2sPHoRvaU7AEg3DecCT0nMKHnBMZGjcVf84Sivc0BUf5vKoSw1KkH8gpQ4XPLkKjbQHB3gLnNjtWaavkw40PeS3+PKlMVV/S5gvuG3UdMcIy6g9WqKkJ/eFpdrLn2Teg/2baDPguOPk+cIhDKBCbpup6vaVoU8LOu66ct1erseeJA+QGWpC1hzaE1uGluXDfgOuYmzJW+ch2k1FjKZ/s/45PMTyiqLaJnQE9mx87m2gHXEuQV1K7fy6pbySrLalpillqUSrFB/XqG+oQyInxEU0g0KGSQy18AOiunXV52UXMF0VkuL9twdAMvbn+R3KpcJveazP+M+h96GKoh/XMVBJVkgeauAqiEmRB7FfgEd8AB2icJhGxJ19VuRGv+pLapu/ivqv9OBz9x1Fvqm5ZetazWabytqYrHUEx5TSHlFiP6KU7UAz0DVajjE0Ko98mhTmOw03ibr4dvh570FxuKSSlMIaUghe0F2zlUcQiAAM8AFRBFjGJU1ChiQ2Lt/wla16F4v3pCzPgKcrYAunohkDBTlS462HaO9shgNvD6ztf5IOMDuvl248mxTzIpepL6R11X/bHW/y8U7VFLBCY/BQMus4t+EY5+ot9eHGWe0HWdtTlrWZi6kNyqXEZFjuKxpMdI6JZg66F1uGPVx3hvz3usylpFnaWOS3tfyrzEecR3jbf10DpdsaGYjUc3sjFvI1uPbaXaVI2HmwcjI0YysedEJvSYQJ/gPurOFhMcz2wIiRqCooI0MDVU1Xr4QmSCCof6XKjK2Z38SmZ7qbPU8cm+T1iavpRSYymTek7igeEPMCi0Ra5QVdjQOHo9DJwK0xeBf+ftctceHH2e0DTtEFAG6MBbuq6/rWlaua7rXRr+XQPKGj8/FVvNE7lVubyT/g6rs1eDDlf2vZL5ifObA0dxXvaU7GF5xnLWHFqDyWpiXNQ4bo67mQt7XNhp5/m6rnOk6khTQLSjcAd51XmAev0xNHwoIyNGkhSRRHzXeNmR7mxUH1f9V0+1vKzvxWruO8W8d6TyCP9I/gcbjm4gJjiGx+PuYHzhQbUcrDAd0NTXJ8xUDaLtcGOAziCBkD2oKoCvH4PMb6DHSFUtFB77u19mtpoxmA0YzUYMZkOrMKdVsHNC9U6NqabNx3PT3Oji3YUQT39CDNWEVOYTYjYREtKPkL6XEho1jC7eXVoFPJ7u9t3jodhQ3FQ9lFyQzOHKw4AKspIikhgZOZLRkaMZGDLQ/gOiijz1BJb+GRzbqW7rNU49icXPcLiTVHuQXJDM01ueJrcql+sHXs9jSY81N4I8vAnWPwe52yC0rwps46+zqyUbjn6i314cbZ4wWUys2L+Ct3a/RamxlCl9pvDw8IeJDnK+ZvwHyg/wTvo7fHvwWwCu7nc1cxPm0je47+98pWswWU3sLNzJxryNbDi6gYMVBwHoFdhLLS3rMZGkyCS83VssTbJaoDirdUiUvxvqq8DdW1WvxE2DQVeoihbRislqYlXWKt7a/RZFtUWMiRrDg8MfZGjY0NZ33L8WVt+nthSe8je1GYgdXAg4W44+T2ia1kPX9TxN08KBdcCDwJctAyBN08p0XT/pl13TtLuAuwB69eqVlJOT01nDPklBTQHv73mfz/Z/Rp2ljsv7XM6CxAWtA0hxRkxWEz/k/MCyjGX8dvw3fD18mdZvGnNi57RuCmxDBTUFrZaYNba48Hb3JrFbompSHTGCYWHDZGe6M6XrasluYzjUxvKy2t7jKQgKI7+2iG0F2/hw74d4uXlyb5chzMnLwrPx9VP0GPX6afB0CIw8/fd1ARIIdRCrbsVoNmK0GJtCG6PZSK259qTbDWaD+jh/F4aDP2HUzRgi4jGE9MJoqWt1P6PZiMGi7m+2mk87Bk83z+YKnRbLsLp4d2ldudMQ7gSVHcF980IVOmhuMPQmGP8whA3spJ9axyuqLWqqHkopTCGnUp0cBHoFMjJiZFMPooEhA+27j0XJgYYyx8/Uk6PmrkopE65XZY6+sqPR6VTVV/Hyjpf5bP9nRAdG88y4ZxgdNVr947FdKgg6sB4Co+CiP6k+WXYYfjrBif5hHKBZaEeprq/mvT3v8X97/w+TxcQNg27g7iF3O8UuJmnH01iStoQfc3/E18OXmQNmcnv87a2bs4uTHK062hQOJRckU2epw9fDlzFRY5qqh9r8GVotapOCjC9VRWllHrh5QJ8JEHcNxF4NgRGdf0B2xGK18O2hb3lj1xscrT7K0LChPDT8oebn/kYmg9oVNnmxqgqdueSMLtLZK0efJ1rSNO0ZoBpYgJ0vGTuVEkMJH+z9gI8zP6bGVMNFPS9iwZAFJweS4iTFhmJW7F/BiswVHDccJzowmjmxc5jef7rd7+pWZiwjtSi1KSTKKM3Aqltx19yJC41r3sksYgTB3q6zVOlsmK1mig3FFNQUkF+TT35lLvmFuygozSLfUESBbqLCvfXF/WlWXx45mkWYxdq8wiJ+huyGfQKXDIR0XcdkNTUHMS0Cmla3NYYwFiO1plqMFmPrYKbxvieEO42Pd7Y83DzwdffB11SHj6kWX3cffEL74esbio+HD77uvvh6+uLj7qM+9/BtevPx8CHYK7jVMi0/D7/fX56l63B4o9ox7MB61aMg6Q61dC3I+TvnF9QUkFLY3IMotyoXgCCvIEZGjGzaxWxAyAD7DYgK96j1r2mfQXlOcyO0hOtUibtsZ9/KL7m/8Nyvz1FsKObWuFu5f/j9+Hr4QnE2/PS8CkR9Q+DCR9XOeZ6+th7yKTn6ib6jNQvtKMdrj/Pmb2/yedbn+Hj4MDd+LrcOvtXhrho2bsG8NG0p2wq2EegVyJzYOdwcd7PstHMODGZD07b2G49u5FiN6ik3MGRgUzg0JGzIyf3xdB2OpapgaO+XUHoA0KDX2OZwyIU2KtB1nR+O/MDrO1/nQMUBYkNjeXD4g2338CrcA5/Ng+MZMPZ+uPRph2gcfTqOPE9omuYPuOm6XtXw8TrgOWAyUNJingjVdf2Pp3sse5snKuoq+GjfR3yY8SEVdRWMiRrDXYl3OXU/tXOVXpzOsoxlrD28FpPVxAU9LmBO7Bwu7HGh/Z6b/44aUw2/Ff1GSmEKOwp3kF6cTr21HoD+Xfq32snMFRqS67pOlamK/Or85sCnRn3c+HlRbRGWxt05GwR5BRHlH0WkfySRXl2IMlYTVXaUqPw99KwsIKxrrHo9FH+d9GA9DacNhP6d/G8ySjNaVeU0hjdGs/GkX6jfo6E1BS9NIYy7T1NAc9K/NXzc+G+Nt7W83c/Dr+k2Hw+f1lvs7lkF3/w/taX1RX9UL07bs0LBaoF938CmV9SJo38YjLkHRs1z6RLzgpqCpnBoe8H2pjXAXby7tKog6teln/1NQroOeamqaij9c7XO1tMfYq9UiXi/yeDhuuuWS42lvLj9RdYcWkP/Lv15bvxzJIYlqqV4v7wIO5eBhw+Muw/GP+gQzeQc+UQfHLdZaEc5WHGQhakLWX9kPWG+Ydw77F5m9J9h9w3xrbqVH4/8yJK0Jewp2UOYbxi3Db6NGwbdgL+n/+8/gPhduq5zoPxAU/XQzqKdWHQLQV5BXND9Aib0nEB813hCfUIJ8g5qnp8ad3DJ+Eq9Ne5kGTVMhUNx05yqCrglXdfZlLeJ13a+RkZpBjHBMdw/7H4u633ZyfO3rsO2t2DdU+q5f8ab0P9S2wy8nTnyPKFpWl9gVcOnHsByXdf/pmlaV+BToBeQg6okLT3dY9nrPFFrquXTzE95f+/7FBuKGRY2jAVDFrjkpgMtmSwm1uas5aOMj9hdvBt/T3+m95vOrNhZTtl/qc5SR3pxelMF0c6inU07MEcHRjMiXDWpHhkxkp6BPR3ud8NkMVFQW9Aq4GkKfaoLKKgtOKmliYebB5F+kUQFRDWHPv6RRPk3f37Kcwxdh9pSl+0JdLacNhB6butzHCg/0BzAnCKgaXrvfnJo0/J+Xm5enf/HV1MMa/6oqj8iE2H6G2ob2vNhroPfPoYtC6EkG0L6wPiHYNgcu66EsJVj1cda9SBqvEIb4h3CyMiRTbuY9Q3ua19PzlaLakKd/hns/QIMZeokN24aJF6vlhHYe8+kdqLrOmsOreHF7S9SZarirsS7mJ84H09jJWx6GbYvBnQYeSdM+AMEOM6VGEc+0QfHbxbaUXYW7eTllJfZdXwXMcExPDziYS6JvsS+nmNQfRy+OfgN76S/w6GKQ0QHRjM3YS7T+02XppkdrLK+kq3HtrLh6Iambe0beWgeTZXCoT6hhPqG0tWnq/rYYqFrUSahuSmE5qcRarHi03UgDJ6mAqLIIQ7ZJ+dEKQUpvLbzNVKLUukR0IN7ht7D1X2vbjtcrS5SvYKy16nthae/7lQ9+Rx9nmgv9j5P1FnqWJW1infS3yG/Jp+40DjmJ87n0t6X2t8FyA50vPa4Wha2fwXFhmL6BPVhVuwspvebToCX6zTMN1vNZJZlsqOgeSez8rpyAMJ8w1otMevfpb9Nf0d0Xaesrqwp3GmruqfYUIxO61wh1Ce0Kdhp+T7KP4qogChCfUJd6nfflpw2EHIqGV+pptOGUvWCdcL/O/tKD2MlpLwDv76pKkcih6iqo8HTXSYYaA951Xlsz1f9h7YXbKegRnW7D/UJVdVDDbuYxQTF2M+LN4tJbWGfvhL2fa0aZPqHqzW0CTMherRTvABoS0FNAc//+jy/HP2FxG6JPDv+WQb4RcLW12HLIjDVwNDZMOlx6NLL1sM9a45+ou8szUI7gq7r/Jj7I6/ueJXDlYcZHj6cx5IeY1j4MFsPDYPZwOdZn/PenvcoqClgUMgg5ifO57Lel9l/c34nZNWtZJRkkFOZQ6mxlFJjKSXGEkoNLT42lmIwG9r8en9dI9RsItRiIdTNm67BvQkNTyQ0PJ6uvt2agqWuvl0J9g626xP09OJ0Xtv5GluObSHMN4y7htzFzAEzT70Bxv7v4Yv7oK4KLn8eRs13uvnQ0eeJ9uIorydMFhNfH/yapelLyanMoW9wX+YnzmdqzFS7rxY9V7qus7t4N8szlvN9zveYrWYm9JjAnLg5jO8+3q6fczqLVbdyqOJQ0y5mKYUpFNUWAWrZVGMFUVJEErFdY1uvOjlPBrOhKdgprClsXd3TEPrUWepafY2Pu09zwBPQUN3Totonwi8CHw+fdhujOD8SCDmK2lL47nG1TX14PFz7OnQf/vtfV1WgQqCUd6CuEmIuggsfUdv0OdlJT2fTdZ2j1UebmlRvL9je9OTc1adr0/KyUZGj6BPUxz4CIpNB7ZySvlK9t9RBcC+1vjZhpqpEs4dxnierbmVl1kpeTnkZs9XMA8Mf4Jb+1+Oe+j5s/DfUlqg+Gpc8Kc1C7YQzNAvtCGarmVXZq3hj1xsUG4qZ3GsyD4942CYl8xV1FXy872OWZSyjrK6MEeEjmJc4z+WXNjiKWlNtU2DU8q3EUEJJ9TFKS7MprSmk1FJLmZsb1jb+T900N0K8Qwj1DW0Oiny60tW3a3NFUkN4FOoTqvqzdYKssiwW7VzEj7k/0sW7C/MS5nFT7E2n/v4mo1oetv0tdU51/VIIj+uUsXY2Z5onzoejzRMWq4V1Oet4O+1tssqy6BHQg3mJ85yqArPeUs/aw2tZlrGMPSV7CPAM4Nr+1zIrdha9g1ynz9m50HWdvOo8UotSm0Kixo1yfD18GRo2tCkgSuyWeMrwxapbKTYUt1q+1Rj0NL4vq2u9r4eGRphf2CmreyL9I+ni3UXOCxyIBEKOJvM7+PoRVeJ8wcOqsqGthoclB2Dzf+C3j1SFyODp6v49RnT+mF2EruvkVuU29R9KLkjmuOE4oMo7G7e4HxU5il6BvWz/RGmshMxvVTPqgz+B1QzdBqpgKOF66NbftuM7R0cqj/DM1mdILkhmdORonhnzBNEHN8HPL0LlURWKTn4aeibZeqjnzZFP9J25WWhHqDXV8sHeD3gn/R3qLHVcN+A67h16L2F+YR3+vY/XHueDvR/wSeYn1JprmdhzIvMS5jEiQuYTp2SswJL5HRUZqynN2UipXk+pbxAlkfGUdO1DqU8QpfUVrQKlxl4XJ/L18G0KjVoGRS2XszX+exfvLmddYXak8giv73qdNYfW4O/pz23xt3Fr3K2nX1pSuBdWzoOivTDmXrj0GfB03ivVjjxPtCdHnSesupVfcn9hcdpi0orTCPcL5474O5g5YKbDbTzQqKi2iE8zP2XF/hWUGkuJCY5hduxspvWbJn3nzkOxoVgtL2voQ7S/bD86Oh5uHiR2S2R4+HDcNfdW1T2FNYWY9da7Vgd4Bpy0fCvCL6Lp43C/8HatQBK212GBkKtvJ9yhDGWw9q+waxmExareQo0vbvNSYfOramcRdy8YNlv1CJLO6p1O13VyKnNILkwmOT+Z5MJkig2qd264X3jTErPRkaNt3yCupgQyvlDNqA9vAnS1rDDxetWZ3wG2Z7RYLXyY8SGLdi7Cw82DPyQ9xkyTB9rPf4fi/dB9hNoxpu8kWw+13Tjyib4rNAvtCCWGEt7a/RYrMlfg6e7JbYNvY27C3A45ic6tzOXdPe+yOns1Ft3ClD5TmJcwj0Ghpy3YEs6kvhYO/KiWrmeugboKtRvpgMtVz6EBl4F3IAazgTJjWeuqo4alaqXG0lbL18qMZW1u7KGhtep91NWna6tKpJbVR1bdyrvp6nfT082TOXFzmBs/ly4+p2k3puuw/W21pbxPMFz7JgxwjsbRp+PI80R7cvR5Qtd1tuZvZfHuxaQUphDiHcJt8bdx06Cb7H7LdVDj/+34byzPWM66nHVYdAsTe05kTtwcxkWNs/1FUidUWV/JrqJdTTuZ7S3eC0CEf0SbDZob3zvC75NoXx0dCLn8dsIdKmsdfPUwVOXDyHlQnAmHNoB3kNotbMy9EBhh61GKBrquc7jycKtdzBobgUb4RTRVD42KHEWPgB62mxwrj6ld7tJXQt4OdVv0WBUODZ5ul02Xs8qyeGrzU6SXpDOp50U8EXkxEZsWQv4u6DYILnlCvXhxshMOOdFXXHGeOFJ5hIU7F7L28FpCfUK5e8jd3DDwhlP3SjkLmaWZLE1fytrDa3HX3Lm2/7XMjZ9LdJD9B8OiA5nr4fAGFQ7t+wZqjoO7N/SfrJ5fB14BfqG/+zBW3UplXWVTQNSy31HLQKnx42pTdZuP4+nmyQ0Db2DBkAV08/2dJtDVx1WvoKzvVZg1/Q0I6PjqOnsg84TiTPNEamEqb6e9zea8zQR6BjI7bja3xN1CiI/97RJcZ6ljzaE1LM9YTkZpBoGegVw74FpmD5otc0onq7fU4665S68/cZLODoRcdjvhDmOsUFe7Ut+HgEi1ZXbSXPAJsvXIxO/QdZ1DFYealpelFKY0BURR/lGtehD1COhhm0GWHlRVQ+krVXm95qaWXCXMVC8AfE+7+VOHM1lMLE5bzOK0xQR6BvLn/jdyRfoatMObIDgaJv0Zhs5y2sbpcqKvuPI8kV6czss7Xia5IJnowGgeGvEQU3pPOadAObUwlaXpS9lwdAN+Hn7cNOgmbh18a6csSxMOxmqBI782b2dfeRQ0d4iZoHazjL263S5I1VnqKDOWqfCoISiqrq/mkl6X0D2g++8/QNY6WH2vWiZ9+fMweoHTXRw4HZknFGecJ/aU7GHJ7iX8cOQHfD18uXHgjdwef7tdPGcX1BTwaeanfLb/M8rqyugX3I85cXO4uu/VDrvUTQhn1ZGB0DlvJ+zsu8d0iIo8tU1qW/2EhEPQdZ0D5QfYXqB2MUsuSG7aYjLEO4TuAd3pHtCdKP+opvc9AnoQFRBFkFcnBICFe1UwlP4ZlB1WSxL7X6rCoUFTwatz132nHU/jqS1PkV2ezZVRF/B4cSkh+9eCXzeY+D8wcq7T/z3Iib7ijCf6Z0PXdTbmbeSVHa+QXZ5NQtcEHhv5GKMiR53x1y5NW0pqUSoh3iHcHHczs2JnEewd3AmjFw5P1+FYqgqG9n4JpQcADaLHqO3sY6+GEBs0iDUZ4YenYdt/IXwwzFwKEYM7fxw2JvOE4szzRHZZNkvSl7Dm0Bo8NA9mDJjB3IS5nX4xUdd1UotSWZ6xnPVH1mPVrUyKnsScuDmMiRwjy8KEsFMdGQid83bCLTnzE7gQp2PVrWSXZ5NckEx2eTbHqo9xrPoY+TX5J23vGOAZQFRAFN39VWjU3b97q89DfULbbyJuPPlPWwl7PldLFj39VCiUcL1aPtCBQYzBbGDRzkV8mPEh3bxDeEoL46K968A7EMY/CGPvVR+7ADnRV2SeUCxWC18d/IpFOxdRWFvIxJ4TeWTEIwwIGdDmfb/P+Z6laUvJLMsk0j+SO+LvYEb/GXL1Vpw7XYfj+1QwlPEVFKap26OGqqrSuOkQNrDjx1G4F1bOh6I9MOYeuPRZp24cfToyTyiuME/kVuayNH0pXxz4AnS4qu9VzE+cT5/gPh36fY1mo1oWtm85+0r3EegVyMwBM7lp0E30DOzZod9bCHH+OmWXMdlOWIj2o+s6pcZS8mvym0KiYzXHyK/O51iN+vzEngs+7j5E+ke2qjBqDI66B3QnzDfs3NYUW61wZIuqHNqzGgylqlln3DWqcqjPRHD3aKcjh+3523l6y9McrT7KjT7RPLo/mQDNTS0BuPCxM+pf4UzkRF+ReaI1o9nI8n3LWbJ7CTXmGqb1m8b9w+4n0j+Seks9Xxz4gnfT3yW3KpeY4BjuTLiTq2Kuapf+Q0K0UnqweVnZ0WR1W7dBDeHQNSooas+qAV2H7Yth3ZPqwsC1b6rG1y5M5gnFleaJgpoC3tvzHiv3r6TOUseUPlOYnzi/3TcEyK/O55PMT1iZtZLyunL6d+nPnLg5XBVzlVxYEMKBdEggJNsJC2FblfWVKiBqIyzKr8lv6lXUyEPzIMI/onVg1FBl1MO/B5H+kb//YtFigoO/qCVlGV9DfRX4h0H8DBUO9RwNbm7ndDxV9VW8lPISK7NW0ssjgGeOHWVUbQ2MuBUu+hMEnUEfCSckJ/qKzBNtKzeWszhtMR/t+wg3zY0r+lzBlmNbOG44TnzXeOYnzueSXpfgpp3b36UQZ6XymGpGnfGl2s1St0KXXqrnUNw15zVHAKpx9JcPwP7voP9lcO0bdrkJQmeTeUJxxXmixFDCB3s/4OPMj6kx1TCp5yQWDFnAkLAh5/yYuq6TUpjCR/s+Yv2R9QBcHH0xc2LnMCpylCwLE8IBdVQgJNsJC2HHDGYD+TX55Ffnk1ed11Rt1Pi+qLYInea/fw2NMN+w1svSTuhn1OpqkMmgGnmmfwb714LZqJo8x89Qu5VFDjnjq8I/5/7M/259jmJDMbdXG7m3uAjf+Ovg4r9C137t/aNxKHKir8g8cXp51Xks2rmIbw5+w+jI0cxLnMfYqLFy4i5sp6YEMr9VlUMHfwJLPQREqH5DcddAnwvhbCrWsn+AVfeqjTYu/18YfZdLNY4+HZknFFeeJyrqKli+bznLMpZRUVfB2Kix3DXkLkZGjDzjecBgNvDtwW9Ztm8ZWWVZBHsHc92A65g1aNaZNXcXQtitTlkydj5c+QlcCFsxWUwU1BY0VRa1rDA6Vn2MgtoCzFZzq68J8Q5pCoxaBUdewUTlpRGU8Q3awR/BaoauA1TVUMLMU/aTKDWW8uKvf2dNzloGmK38b2ER8b0ugslPqmUGQk70G8g8cWZMVhOebrIsTNgZY4W6gJDxpXpvqgWfLjDoStWUuu/Fp+7/YzLC+mfh1zcgLA6uXwoR8Z07fjsn84Qi8wTUmGpYkbmC9/a8R4mxhGFhw1gwZAETekw4ZTCUV53HJ/vUsrDK+koGhgxkTuwcrux7Jb4evp18BEKIjiCBkBDirFmsFooNxeTXtK4wagyP8mvyMZgNrb7G39OfKN9weugaUZXH6V6WS5TZTPeg3nQfNJ2uQ+eghfRG13W+PfgNL259jmqzgbvLy5kXGIfnpc9A7/E2OV57JSf6iswTQjgJkwGy16vKocw1UFcBXgGqD1DcNPW+cdOAon2wch4UpquKoMueA095gVXiE+kAAAcbSURBVHoimScUmSeaGc1GVmWv4t30d8mvyScuNI4FQxYwuddk3DQ3dF0nuSCZZRnL+PnozwBM7jWZ2bGzz6qqSAjhGCQQEkK0O13XKasrO6l3UV51XtNtVfVVrb7G22olSvPExzuIffVlDDHW8aweSv9LnoUBl0v5fxvkRF+ReUIIJ2Suh8MbVeXQvm+g5ji4e0O/SyA8TlUFeQWoXkEDp9h6tHZL5glF5omTmSwmvj74NUvTl5JTmUPf4L5c0ecKvs/5nuzybLp4d2naLSwqIMrWwxVCdBAJhIQQNlFdX91UUZR3PI38I5s4VpJJsbmaS3Vf5ox/AveE68+vyaiTkxN9ReYJIZyc1QK525q3s688Cv0vhelvQGCErUdn12SeUGSeODWL1cL3Od/z9u63yS7PJjY0ljmxc5gaMxUfj1Ms1xRCOI3TzRPtt1e0EEKcIMArgIFeAxkYMhCiL4IRD6h/qDymdieTLbCFEEIAuLmrJcO9x8MVL6h5Iqi7VI4K0Q7c3dyZGjOVKX2mUFRbRIRfhCwLE0IAEggJIWzBRbeQF0IIcQY0DYJ72HoUQjgdN82NSP9IWw9DCGFHZJ2GEEIIIYQQQgghhIuRQEgIIYQQQgghhBDCxUggJIQQQgghhBBCCOFiJBASQgghhBBCCCGEcDESCAkhhBBCCCGEEEK4GAmEhBBCCCGEEEIIIVyMBEJCCCGEEEIIIYQQLkYCISGEEEIIIYQQQggXI4GQEEIIIYQQQgghhIuRQEgIIYQQQgghhBDCxWi6rtt6DGiadhzIOccv7wYUt+Nw7J0rHa8rHSvI8Tqz8znW3rquh7XnYByRzBNnxZWO15WOFeR4nZnME+dJ5okz5krHCnK8zsyVjhU6aJ6wi0DofGialqLr+khbj6OzuNLxutKxghyvM3OlY7VHrvbzd6XjdaVjBTleZ+ZKx2qPXOnn70rHCnK8zsyVjhU67nhlyZgQQgghhBBCCCGEi5FASAghhBBCCCGEEMLFOEMg9LatB9DJXOl4XelYQY7XmbnSsdojV/v5u9LxutKxghyvM3OlY7VHrvTzd6VjBTleZ+ZKxwoddLwO30NICCGEEEIIIYQQQpwdZ6gQEkIIIYQQQgghhBBnwWEDIU3TrtA0LVPTtGxN0x639Xg6mqZp72iaVqRpWrqtx9LRNE2L1jTtJ03T9mqatkfTtIf/f3v382r5HMdx/PlqGtFFNtI0V42FbCzQNJuRhSI/JiwpVsqGIgtl6R+QP4CNaCY1lChMmdIUZtxxhxhJmnIndZPEXQlvi/NdzFLT+d6P8/k8H3W759zF7XW6nZ63T99zTutNc0pyZZLTSc5Nj/el1pvmlmRPki+TvNd6y9ySXEjydZLNJF+03jOSkToxUiPATtiJvtiJduxEv0bqxIiNADuxtN+9ii8ZS7IH+B64B9gCzgCPVdW3TYfNKMldwA7welXd2nrPnJLsA/ZV1dkk1wAbwCO9/n2TBFirqp0ke4FTwLNV9VnjabNJ8jxwELi2qo603jOnJBeAg1X1S+stIxmtEyM1AuwEdqIrdqINO9G3kToxYiPATizLql4hdAj4oap+rKo/gWPAw403zaqqPgF+bb1jN1TVz1V1drr9B3Ae2N921XxqYWe6u3f6Wr2T2v8oyTrwIPBq6y3q2lCdGKkRYCewE9Iy2ImOjdSJ0RoBdmKZVvVAaD/w0yX3t+j0CT66JAeA24HP2y6Z13TJ4yawDZyoqp4f7yvAC8A/rYfskgI+SrKR5KnWYwZiJwZhJ7pkJ7Qb7MQgRujEYI0AO7E0q3ogpAEkuRo4DjxXVb+33jOnqvq7qm4D1oFDSbq8lDfJEWC7qjZab9lFd1bVHcD9wNPTJduSlsBO9MdO2AlpmUbpxCiNADvBkjuxqgdCF4EbL7m/Pv1MnZhe/3oceLOq3m69Z7dU1W/ASeC+1ltmchh4aHod7DHg7iRvtJ00r6q6OH3fBt5hcYm65mcnOmcn7EQv7EQzdqJzI3ZigEaAnVhqJ1b1QOgMcHOSm5JcATwKvNt4k5ZkemO014DzVfVy6z1zS3J9kuum21exeHPD79qumkdVvVhV61V1gMXz9uOqerzxrNkkWZveyJAka8C9wBCf7vE/YCc6ZifsRC/sRFN2omMjdWKkRoCdYMmdWMkDoar6C3gG+JDFG4S9VVXftF01ryRHgU+BW5JsJXmy9aYZHQaeYHHauzl9PdB61Iz2ASeTfMXin5MTVdX9xycO4gbgVJJzwGng/ar6oPGmIYzWicEaAXbCTvTDTjRiJ+xER2xE32btxEp+7LwkSZIkSZIu30peISRJkiRJkqTL54GQJEmSJEnSYDwQkiRJkiRJGowHQpIkSZIkSYPxQEiSJEmSJGkwHghJkiRJkiQNxgMhSZIkSZKkwXggJEmSJEmSNJh/AalGZsMwytr7AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3,figsize=(20,5))\n", + "fig.suptitle('Horizontally stacked subplots')\n", + "\n", + "ax1.plot(WB_models_eval_tfr[0,0,:])\n", + "ax1.plot(WB_models_eval_tfr[0,1,:])\n", + "ax1.plot(WB_models_eval_tfr[0,2,:])\n", + "\n", + "ax2.plot(WB_models_eval_tfr[1,0,:])\n", + "ax2.plot(WB_models_eval_tfr[1,1,:])\n", + "ax2.plot(WB_models_eval_tfr[1,2,:])\n", + "\n", + "ax3.plot(WB_models_eval_tfr[2,0,:])\n", + "ax3.plot(WB_models_eval_tfr[2,1,:])\n", + "ax3.plot(WB_models_eval_tfr[2,2,:])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "id": "MnJO5Xak2BiE", + "outputId": "a7a46ec6-0b6f-4cde-bfd4-860c97ed4d76" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# ploting each fig\n", + "plt.plot(test_num, WB_models_eval_ufr[0,0,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_ufr[0,1,:], '-o')\n", + "# plt.grid()\n", + "plt.legend(['TUAP','Random','Orign'], fontsize=12)\n", + "plt.xlabel('Test Set',fontsize=13)\n", + "plt.ylabel('UFR',fontsize=13)\n", + "plt.ylim([0,60])\n", + "\n", + "plt.savefig('ufr-dnn',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "id": "SHCwJ8UD2XJO", + "outputId": "376266be-17e7-41aa-de47-dcde911790f5" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAENCAYAAADpK9mHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXwV9b3/8dcnGwQSsrCFJSEBEVRc0LC4o4i4Xq1tUXABa+H297vVLldb7a9Va+1De21r6/Xe3otihaui1IVqra3UpeptDYtQFQFFWZKwLwkEAoTk8/tjJpCQEALJOSfJeT8fj/M4Z+bMmflOlHnPd5kZc3dERCQ+JcS6ACIiEjsKARGROKYQEBGJYwoBEZE4phAQEYljCgERkTgWtRAws0wze97MlpvZMjM708yyzWyemX0WvmdFqzwiIhLdmsCvgT+5+1DgVGAZcCfwhrsPBt4Ip0VEJEosGheLmVkGsAQY6HU2aGYrgDHuvt7M+gBvu/uQiBdIREQASIrSdgqAzcBvzexUYBHwLaC3u68Pl9kA9G7sx2Y2DZgG0LVr1zOGDh0a+RKLiHQgixYt2uLuPQ+dH62aQCHwPnC2uxeZ2a+BHcCt7p5ZZ7nt7t5kv0BhYaEvXLgwsgUWEelgzGyRuxceOj9afQIlQIm7F4XTzwOnAxvDZiDC901RKo+IiBClEHD3DUCxmdW2948FPgFeBiaH8yYDv49GeUREJBCtPgGAW4GnzSwF+AK4mSCE5pjZLcAaYEIUyyMiEveiFgLuvgRo0B5FUCsQEZEYiGZNQETiTE1NDSUlJezatSvWRenwkpOT6dWrF926dTuq3ykERCRitmzZgpkxZMgQEhJ0l5pIcXcqKyspLS0FOKog0H8VEYmYsrIyevfurQCIMDOjS5cu9OvXj02bjm6Qpf7LiEjEVFdXk5ycHOtixI3U1FSqqqqO6jcKARGJKDOLdRHixrH8rRUCIiJxTCEgIhLHFAIiEnfS0tIOvBISEkhNTT0w/fTTTzNlyhR++MMf1vvN6tWrMTP2799fb/6YMWPIyspi79699eZPmTKFlJQU0tLSyM7OZty4cSxfvjzi+3a0FAIi0ubMXVzK2Q++ScGdr3L2g28yd3Fpq66/oqLiwCsvL49XXnnlwPT111/f7PWsXr2ad999FzPj5ZdfbvD99773PSoqKigpKaFXr15MmTKlFfeidSgERKRNmbu4lLte/IjSskocKC2r5K4XP2r1IGgNs2bNYvTo0UyZMoWZM2cedrkuXbowadIkPv744yiWrnl0sZiIRMWPX1nKJ+t2HHG5xWvL2FddU29eZVU133v+Q2bPX9vkb0/s2417rjypReU8GrNmzeK73/0uo0aNYvTo0WzcuJHevRs+FqWiooKnn36a4cOHR61szaWagIi0KYcGwJHmx8p7773HmjVrmDBhAmeccQaDBg3imWeeqbfMz3/+czIzMznuuOOoqKjgySefjE1hm6CagIhERXPP0M9+8E1KyyobzO+Xmcpz/3xmaxerUUlJSQ0uuqqqqiIhIeHA1c8zZ87k4osvpkePHgBMmjSJmTNn8p3vfOfAb26//Xbuv//+qJT5WCkERKRNuWP8EO568SMqq6oPzEtNTuSO8dF7/HheXh5Lly6tN2/VqlXk5uaSkJBAZWUlc+bMobq6mpycHAD27t1LWVkZ//jHPzj11FOjVtaWUnOQiLQpVw/vxwPXnEy/zFSMoAbwwDUnc/XwflErw5e//GVeffVVXn/9daqrq1m3bh33338/1113HQBz584lMTGRTz75hCVLlrBkyRKWLVvGueeey6xZs6JWztagmoCItDlXD+8X1YP+oU466SRmz57NXXfdxcqVK8nMzGTChAncc889QNAUdPPNN5OXl1fvd9/85je57bbb+NnPfhaLYh+TqDxovjXpQfMi7ceyZcs44YQTYl2MuHK4v3msHzQvIiJtkEJARCSOKQREROKYQkBEJI4pBERE4phCQEQkjikERETimEJARCSOKQRERCLo3nvv5YYbboh1MQ5LISAicSk/P//AYyVzcnKYMmUKFRUVsS5W1EUtBMxstZl9ZGZLzGxhOC/bzOaZ2Wfhe1a0yiMibdiHc+DhYXBvZvD+4ZyIbKb2sZJLlixh8eLFPPDAAxHZTlsW7ZrABe5+Wp37V9wJvOHug4E3wmkRiWcfzoFXboPyYsCD91dui1gQAOTk5DB+/HiWLFkCwIMPPsigQYNIT0/nxBNP5KWXXjqw7JNPPsk555zD7bffTlZWFgUFBbz22msHvl+1ahXnn38+6enpjBs3ji1bttTb1ssvv8xJJ51EZmYmY8aMYdmyZQe+y8/P56GHHuKUU06ha9eu3HLLLWzcuJFLL72U9PR0LrroIrZv396q+x7ru4heBYwJP88E3ga+H6vCdCRzF5fy0J9XsK6skr6ZqdwxfkhM78oowmt3woaPjrxcyQKo3lt/XlUl/P6bsOjwz/EFIOdkuPTBoy5aSUkJr732GhdeeCEAgwYN4t133yUnJ4ff/e533HDDDaxcuZI+ffoAUFRUxOTJk9myZQvTp0/nlltuobS0FDNj0qRJnHnmmbz++usUFRVx+eWXc9VVVwHw6aefMnHiRObOncuYMWN4+OGHufLKK/nkk09ISUkB4IUXXmDevHns37+f4cOHs3jxYmbMmMEJJ5zAZZddxiOPPHLgbqatIZo1AQdeN7NFZjYtnNfb3deHnzcADR/OKUetPT2oW6SBQwPgSPNb4OqrryY9PZ3c3Fx69erFj3/8YwC++tWv0rdvXxISErj22msZPHgw8+fPP/C7AQMGMHXqVBITE5k8eTLr169n48aNrF27lgULFvCTn/yETp06cd5553HllVce+N1zzz3H5Zdfzrhx40hOTub222+nsrKSv/3tbweWufXWW+nduzf9+vXj3HPPZdSoUQwfPpzOnTvzpS99icWLF7fq3yCaNYFz3L3UzHoB88xsed0v3d3NrNH7WoehMQ1ocP9uaejf/rS83lOZIHhQ90N/XqHagMROc8/QHx4WNgUdIiMXbn61VYs0d+5cLrroIv76178yadIktmzZQmZmJrNmzeKXv/wlq1evBoIHxddt1ql9mhhAly5d6i2TlZVF165dD3w/YMAAiouD/Vm3bh0DBgw48F1CQgK5ubmUlh48Qav7oPrU1NQG063deR21moC7l4bvm4CXgJHARjPrAxC+bzrMb6e7e6G7F/bs2TNaRW433J3PN1cw471V3DijiHXlexpdrrSskuqa9vX8CIlDY++G5NT685JTg/kRcv755zNlyhRuv/121qxZw9SpU3n00UfZunUrZWVlDBs2jOY8e6VPnz5s376dXbt2HZi3du3aA5/79u3LmjVrDky7O8XFxfTrF7uTs6iEgJl1NbP02s/AxcDHwMvA5HCxycDvo1GejqByXzVvLt/Ij+Z+zHkPvcXYX/yVn/zhE0rLKunaKfGwvzv3Z2/yq798yvryhg/yFmkTTpkAVz4SnPljwfuVjwTzI+jb3/428+bNo6ysDDOj9oTzt7/9LR9//HGz1jFgwAAKCwu555572LdvH++99x6vvPLKge8nTJjAq6++yhtvvEFVVRW/+MUv6NSpE2eddVZE9qk5otUc1Bt4ycxqt/mMu//JzBYAc8zsFmANENn/yu2Yu/PFll28vWIzb6/YRNGqbezbX0NqciJnDerOtHMHMmZIL3KzuxzoE6jbJNQ5OYGJI3JZuXkXv/rLZzzyxmdcOLQXE0fmcf7xPUlK1CUj0oacMiHiB/1D9ezZk5tuuon77ruPf/3Xf+XMM88kISGBm266ibPPPrvZ63nmmWeYPHky2dnZnHnmmdx0002UlZUBMGTIEJ566iluvfVWSktLOe2003jllVcOdArHgh4v2YZV7qvm719sCQ/8m1m7bTcAA3t2ZczxvbhgaE9G5GfTObnhmX9To4PWbt3NcwvXMmdhCZt37qVPRmcmFOZy7Yhc+mamNliXyLHS4yWj72gfL6kQaEMOd7bfOTmBswf1YMyQngfO9ltDVXUNbyzbxOz5a3nns80YMGZIUDu4YIhqB9JyCoHoO9oQiPV1AnGvqbP9G0YNYMyQnowsaPxsv6WSExO4ZFgOlwzLoXjbbp5bUMychcVMnbWQ3t06cW1hLhNG5NI/q3VCR0TaHoVAlB3pbH/quQWterbfXLnZXbh9/BC+ddFg3lwe1A7+/a2V/PtbKzn/+J5MGpnHhUN7qXYg0sEoBKIglmf7Rys5MYHxJ+Uw/qQcSrbvZs6CYp5bWMy0/1lE726dmFCYy4TC3KiHlDROV4ZLSykEIsDdWbVlF2+1sbP9o9U/qwvfvXgIt40dzFsrNvNM0RoefWslj761kvMG92TiyDzGntCLZNUOYuLQUWC1V4YDbSoI3J1wZKBEWE1NzVH/Rh3DreRII3na0tl+S5SWVQZ9BwuK2bBjDz3TOzGhsD/Xjchr86HWUdQ2KX75P/9GWWVVg+/7Zabyv3deGIOSNbRq1SrS09Pp3r27giCC3J2qqio2btyIuzd6ZwWNDmpltWf7b6/YzFuHnO2fVTuS5/he5HXvmAfG/dU1vL1iM7Pnr+WtFZtw4NzBPZk0MpexJ/RW7aAV7a+uYdn6ncxfvY0Fq7axcM02tlTsO+zyBqx68PLoFbAJVVVVlJSUsGdP41exS+tJSkoiIyODHj16kJDQ8N+fRge1gvbUth9pSYkJXHRiby46sTfryiqZs7CY5xYU842nPqBH2sHaQUcNwUjaU1XNkuIyFqzaxvzV2/hgzXZ27QuafPpnpXLe4J6MKMjm4Xmfsmlnw5uqtaVrPZKTkykoKIh1MaQJqgk0Id7P9o9WdY3z10838UxRMW8u30iNw7mDezBxZB4XndCblCTVDhpTXlnFojXbmL9qOwtWb+PDkjKqqoN/l0N6pzOiIIsR+dmMLMimT8bBA3xjV4YDTD5zAD++alhU90HaPjUHNVO8tO1H2vrySuYsKOG5BWtZV76HHmkpfOWMXCaOzGVA965HXkEHtnHHHuav2saC1duYv2obKzbuxB2SEoyT+2cwMj+bEfnZFOZnkdml6dsJ1B0dlJPRmc7JCazdVsmjE4dz6cl9orRH0h7EdQg0NYxOZ/uRVV3jvPPpZp6Zv5Y3l2+iusY557igdjDuxI5fO6jtxK1t2lm4evuBE4suKYmcnhec5Y8oyGJ4bhapKS07uajYu5/JT8znH8VlPDrpdC4ZlnPkH0lciNsQONzN1G4cPYC9+2t0th9FG8r38LuFxTy7oJjSskq6d03hK4X9mTgij/weHaN20FQnbnbXFAoHZDGyIDjTP6lvt4hcfLdzTxU3PTGfj0rK+c0NZzDuRD2rSeI4BM5+8E1Kyxq/bbLO9mOjusZ557PNzC5ayxth7eCsQd2ZODKPi0/qTaek9hO+h3biLl5bRsXe/UDQiTsyP5sR4UF/UM+uURsmuWNPFTfOmM8n68r5rxvOYOwJCoJ4F7chUHDnqxxuD5f/5BKd7cfYxh1B7WD2/KB2kN01ha+c0Z/rRuQysGdarIvXwKGduB+VlLOvOrhAp6lO3FiV9cYZRSxfv5P/vvEMLhjaK6blkdiK2xA4XE2gLV1QI1BT47y7cguzi9Yyb9lGqmucMwd2Z+KoPMbHsHbQmp24sVC+u4rrZ7zPpxsreOymQs4/Xk/mi1dxGwKN9QmkJifywDUnt6lL6+WgTTv28LtFJTy7YC3F2yrJ6pIc1A5G5jEogrWD2kECwQE/ONOPZCdutJTt3sekx4pYubmCx28q5DwFQVyK2xAA3WSrvaqpcf738y3Mnr+W15duZH+NM6ogm0mj8hh/Uk6Lm/JqO3EXrN524HW4TtwT+3Zr11dBb9+1j0mPF/HF5gpmTB7BOYN7xLpIEmVxHQLS/m3euZffLSrm2fnFrN22m6wuyXz59KB2cFyvoHZwpLBvqhO3X2bqgQP+yIIsBvVM63D3utm2ax+THnuf1Vt38cTkEZx1nIIgnigEpEOoqXH+9vlWZs9fy5+XbmB/jTOyIJvje6fx/KIS9lQdvIti7VDgxISEJjtxR+Rnt6lbLUTS1oq9THzsfdZu282TN49k9MDusS6SRIlCQDqczTv38sIHJcyev5Y1W3cfdrn20okbLZt3BkFQur2SmV8byciC7FgXSaJAISAdVk2NM/AHf2z0OwM+ue+SdtOJGy2bdu5h4vT3WV++h1lfG0lhvoKgoztcCLTfni6RUEKC0e8wzTl9M1MVAI3old6Z2VNHk9OtM5OfmM+iNdtjXSSJEYWAdAh3jB9C6iGjhVKTE7lj/JAYlajt69WtM89MHU3P9E5MfmI+i9cqCOKRQkA6hKuH9+OBa06mX2YqRjDaR9eCHFlORmdmTxtN97QUbpoR3HhO4ov6BESEdWWVXDv975TvruLpr4/m5P4ZsS6StDL1CYjIYfXNTGX21NF0S03mhhlFfFxaHusiSZQoBEQEgP5ZXZg9dTRpnZK4/vEilq5TEMQDhYCIHJCb3YVnp42ma0oiNzxexLL1O2JdJImwqIaAmSWa2WIz+0M4XWBmRWa20syeM7P4vYJHpI3Ize7C7Gmj6ZycyPWPF7Fiw85YF0kiKNo1gW8By+pM/wx42N2PA7YDt0S5PCLSiAHduzJ76miSE41Jj73PpxsVBB1V1ELAzPoDlwOPh9MGXAg8Hy4yE7g6WuURkabl9wiCIDEhCIKVmxQEHVE0awK/Ar4H1N7hqztQ5u77w+kSoNFB3WY2zcwWmtnCzZs3R76kIgLAwJ5pPDN1NGBMfKyIzzdXxLpI0sqiEgJmdgWwyd0XHcvv3X26uxe6e2HPnnoghkg0HdcrjWenjcLdmTj9fb5QEHQo0aoJnA38k5mtBp4laAb6NZBpZknhMv2B0iiVR0SOwnG90nlm6miqa5yJj73P6i27Yl0kaSVRCQF3v8vd+7t7PnAd8Ka7Xw+8BXwlXGwy8PtolEdEjt7xvdN5euooqqqDIFizVUHQEcT6OoHvA981s5UEfQQzYlweEWnC0JxuPHXLKCqrqpk4/X3WNvEcB2kfoh4C7v62u18Rfv7C3Ue6+3Hu/lV33xvt8ojI0Tmxbzee/voodu2rZuJj71O8TUHQnsW6JiAi7dBJfTN4+uuj2LmniomPvU/JdgVBe6UQEJFjMqxfBk9/fTTllUEQrCurjHWR5BgoBETkmJ3cP4OnbhlF2a4gCNaXKwjaG4WAiLTIqbmZzLplJFsr9jHpsSI27tgT6yLJUVAIiEiLDc/LYubXRrBpR/AA+00KgnZDISAireKMAdk8+bWRbNixh4mPvc+mnQqC9kAhICKtZkR+Nr+dMoJ1ZXu4/rEitlRo1HdbpxAQkVY1amB3npgyguLtu5n02PtsVRC0aQoBEWl1Zw7qzhOTR7Bm626uf7yIbbv2xbpIchgKARGJiLOO68GMySNYtWUXkx57n+0KgjZJISAiEXPO4B48dlMhX2zZxfWPF1G2W0HQ1igERCSizju+J9NvPIOVmyq4YUYR5burYl0kqUMhICIRN2ZIL/77xjP4dEMFNz5RRHmlgqCtUAiISFRcMLQXv7nhdJat38FNT8xnxx4FQVugEBCRqBl7Qm/+Y9LpLC0tZ/IT89mpIIg5hYCIRNXFJ+Xw6KTT+aiknCm/XUDF3v2xLlJcUwiISNRdMiyHf584nCXFZdz82/nsUhDEjEJARGLi0pP78OvrTuODtWXc/OQCdu9TEMSCQkBEYuaKU/ry8LWnsXD1Nr725AIq91XHukhxRyEgIjH1T6f25ZcTTmP+qm3cMlNBEG0KARGJuauH9+PnXz2Vv3+xlamzFrKnSkEQLS0OATM7tzUKIiLx7ZrT+/PQV07lfz/foiCIomaFgJmlmdnpZta9zrxTzew1YF7ESiciceUrZ/TnZ9ecwrufbeEbTy1i734FQaQdMQTM7AKgFFgIFJvZZWb2E6AonD80skUUkXgyYUQuD15zMm+v2Mz/eeoDBUGENacmcD8wHRgWvv8PcAFwsrt/3d1XR654IhKPrhuZx0+/NIw3l2/iX57+gH37a2JdpA6rOSEwFPiBu38C/ADIBL7s7p9FtGQiEteuHzWAn1x1En9ZtolvPvMBVdUKgkhIasYyye5eBeDuu82s3N03RrhcIiLceGY+NQ73vLyUW59ZzL9PGk5yYnwNapy7uJSH/ryCdWWV9M1M5Y7xQ7h6eL9WW3+zQsDMJgJ2mGnc/ZmmVmBmnYF3gE7hNp9393vMrAB4FugOLAJudHc9dUJEDph8Vj7VNc59f/iEbz+7hLFDe/KLeZ9F7KDYlsxdXMpdL35EZThSqrSskrte/Aig1fbZ3L3pBcxWA00t5O4+8AjrMKCru1eYWTLwHvAt4LvAi+7+rJn9F/APd/9NU+sqLCz0hQsXNllmEel4Hn/3C+5/dRmJBtV1jkipyYk8cM3JUQmCmhpnX3UNVdU17K92qqprwunw8/7gu6q63+0/ZDqct792Xfs9/E3d74N5r328nsqqhs1g/TJT+d87LzyqspvZIncvPHT+EWsC7p5/VFtqfB0OVISTyeHLgQuBSeH8mcC9QJMhICLx6evnDuSRNz5jx5769xiqrKrm3peXUrZ7H1XVBw/StQfjgwfmmoPfhwfhwx646xyI99X5bXVN0yfNxyoxwUhONJITE0hJTCA5MYHkJGs0AADWlVW22raPGAJmlt8aI4DMLJGgyec44D+Az4Eyd6/9L1oCNBrlZjYNmAaQl5fX0qKISDu1c0/jN5krq6zi3lc+qTcvKSE4qNYeXGsPrPUOtOF3XTsl1ZtOOWT5Q9eTUjudlNBwfUkN15+SlHCgPClJDdeXmGCN7tfZD75JaSMH/L6ZqS3/Y9b+nZqxzIdAt9oJM3vR3a852g25ezVwmpllAi9xFNcXuPt0guGpFBYWRiaKRaTN65uZ2uhBMadbZ1771rnhQdlITkgg4TAH1vbkjvFD6vUJQND8dcf4Ia22jeZ0sx/6lxzTkg26exnwFnAmkGlmtUHUn+DiMxGRRt0xfgipyYn15qUmJ3LnpUPJ6ppCWqckOiUldogAgKDz94FrTqZfZipG0BfQ2v0fzakJtPjM28x6AlXuXmZmqcA44GcEYfAVghFCk4Hft3RbItJx1R78Ijlksq25eni/iO5fc0KgNfQBZob9AgnAHHf/g5l9AjxrZvcDi4EZUSqPiLRTkT4oxpvmhECamdUdu590yDTuntLUCtz9Q2B4I/O/AEY2p6AiItL6mhMCF0S8FCIiEhPNCYHG6l1VwBfAYnfXDT1ERNqp5oTATxuZlwzkAP8ws39yd43qERFph5pzxXBBY/PNLA34NcEonxtauVwiIhIFxzw6KLwP0O0EF5OJiEg71NJ7spYDaa1REBERib6WhsBZwNrWKIiIiERfc24gN6mR2ckEN4KbRvC0MRERaYeOdXRQFbAa+M6RHigjIiJt1zGPDpI27sM58MZ9UF4CGf1h7N1wyoRYl0pE2pho3TtIounDOfDKbVAV3nK3vDiYBgWBiNQTX09s7shqaqC8FFa/B69972AA1KqqDGoGIiJ1qCbQnuzbDWVrYNsq2L46fNV+XgPVe5v+fXkJuIN1jHuti0jLKQTaEneo2NTwAF970K/YUH/5lHTIzoeeQ+H4SyC7ALLyYe7/hZ3rG9sATB8Do74Bw66BpE6R3R8RafMUAtG2fy+UrT14oD9wVh++V+2us7BBt37BgX3wRcF7VkH4yocu2Y2f1Y+7r36fAEBSanDgL10Ec78B834EZ0yBwlugW5+I7a6ItG0KgdbmDpXbg4N6vQN82Iyzo5R6D2tLSj14Bj9wzMEDfHYBZORCcuejL0Nt529jo4PcYdVfoei/4Z2fw3sPw4lXwch/htyRaioSiTPm3r6e215YWOgLFy6MbSGq9wcjbhprstm+GvbuqL98Wu86Z/H5Bw/6WQWQ1it2B95tq2DB4/DB/8DecuhzmpqKRDooM1vk7oUN5sdFCBzLmPk9Oxo5wIfvZcXg1QeXTUyBzAEND/BZ+ZA1AFK6Hl15o21vBXz4XFA72LICuvZUU5FIBxO/IXDomHmA5FS44teQf3bDA3ztdOW2+utJza5zgM+vf1af3gcSElu6a7FXt6loxWvBPqmpSKRDiN8QeHhY0HRzJJYImbmHabbJh84Zx1bg9kpNRSIdSvyGwL2Z1OuIreuKhw8e8DNyIVH95A2oqUikQ4jfEDhcTSAjF77zcesVrKNTU5FIu3a4EOj4t40Ye3fQB1BXcmowX5rPLBjCOnE23LY4aBr67C/wxMXBBWhLZgfXQIhIu9LxawKgO2pGipqKRNqN+G0Oksg7XFPRqG9A/xFqKhJpAw4XAuoJlZarbSoaOKb+qKKPX9CoIpE2TjUBiQw1FYm0KTHtGDazXDN7y8w+MbOlZvatcH62mc0zs8/C96xolEeioFMajLgF/qUIbpwL/QqDexX9ahg8/zUonh80I4lITEWlJmBmfYA+7v6BmaUDi4CrgSnANnd/0MzuBLLc/ftNrUs1gXZMF6CJxEyb6hg2s98Dj4avMe6+PgyKt919SFO/VQh0AGoqEom6NhMCZpYPvAMMA9a6e2Y434DttdOH/GYaMA0gLy/vjDVr1kStvBJB7vDF20EYfPonjSoSiaA2EQJmlgb8Ffipu79oZmV1D/pmtt3dm+wXUE2gg1JTkUhExfyKYTNLBl4Annb3F8PZG8NmoNp+g03RKo+0MdkFMP6n8N1P4PJfBHd9nfsNePgkePN+2NHY4zJFpKWiNTrIgBnAMnf/ZZ2vXgYmh58nA7+PRnmkDeuUBiO+rlFFIlESrdFB5wDvAh8BNeHsHwBFwBwgD1gDTHD3bY2uJKTmoDikpiKRFmsTfQKtQSEQx/ZWwIfPQtH0xkcV6R5RIoelEJCOo7FRRX2Hw/oPobrOnUyTU+HKRxQEIujeQdKRmMGgC4LXti9g/uPw/n/S4OFBVZXw+o9gyKXQKT0mRRVp61QTkI6hqSfIQfB40Iy8oJkoMzd4z8gNXpm50LUXJHT8x2tI/FJNQDq2jP6NP0EutTucfSuUFQd9BWnGo8UAAA0gSURBVGVrYPV7sG9n/eUSU6BbvzAk8uqERDjdrR8kd47OvohEkUJAOoaxd8MrtwVNQLWSU+HSBxvvE9hTfjAYyouDV+3052/Czg00qFl07VWnJpFbJyTCz6lZuspZ2h2FgHQMtQf65o4O6pwBORmQM6zx7/fvgx2ldUKiBMrWBu8bl8Knf4b9e+r/Jrnr4ZubMvpDel9I1D85aVv0f6R0HKdMaL2RQEkpwVXM2QWNf+8Ou7YcDIhDg2LdYti9tf5vLCEIgnohcUjzU6e0oyunhsVKCykERI6FGaT1DF79Tm98mX276zc3lZccbHIqLoKlL0HN/vq/6Zx5+OamjNzg2ojaDuwP59RvAisvDqZBQSDNphAQiZSULtDz+ODVmJrqoO+hsX6J7WEH9t4d9X+TmBLWGvpDyaL6fSAQTL9xn0JAmk0hIBIrCYmQ0S94MarxZZrqwK7a1fhvykuC5ip1UkszKARE2rKmOrAfHtb4sFg8+G7oZTD0chhwNiQmR7yo0j7p6hiR9mrs3cEw2LqSUuH0KdDn1OCGe7OugocGwQtTYelc2Luz0VVJ/FJNQKS9OtKw2H274Yu3YPmrsOI1+GgOJHaCgecHNYTjL4X03rErv7QJum2ESDyo3g/F78PyP8LyPwRXTmOQOxKGXAZDr4Aex8W6lBJBuouoiATcgwveVoSBsP4fwfweQ8J+hCug7+m6l1IHoxAQkcaVFYeB8GowLNWrIS0nuPvq0Cug4Fw9vKcDUAiIyJHt3gafzYMVr8JnfwmGoaakw+BxQT/C4HHBiCVpd3QXURE5si7ZcOq1watqD6z6a9ix/EdY+iIkJAc1gyHh8NNufWNdYmkh1QRE5MhqqqFkYdCHsPxV2PZ5ML/v6UEYDL0ceg7VBWptmJqDRKR1uMOWTw8GQumiYH72wCAMhlwejDpKSIxtOaUehYCIRMaO9Qc7lle9AzVV0KVH2LF8OQwc0/CiNok6hYCIRN6eclj5lyAQPpsX3AAvuQscNzYYaTT44qDfQaJOHcMiEnmdM2DYl4PX/n2w+t2DHcvLXgFLhAFnBYEw9LLgWQoSU6oJiEjk1dTA+sVBICx/FTYvD+bnnBwEwpDLgs/qWI4YNQeJSNux9fODgVBcBDhk5B0caZR3ph7F2coUAiLSNlVsgk//FATC529B9V5IzYLjLwkCYdCFkNL14PJ6pOYxUQiISNu3twI+fzMIhE//BHvKIKkzDLwgCITqffD6/6v/RLXkVLjyEQXBEcQ0BMzsCeAKYJO7DwvnZQPPAfnAamCCu28/0roUAiJxoroK1v79YLNRow/QCWX0h+8sjV7Z2qFYh8B5QAUwq04I/Buwzd0fNLM7gSx3//6R1qUQEIlD7rDhQ/jv8w6/TGo2pOcEr7Sc4FkJjb2ndIleuduQmA4Rdfd3zCz/kNlXAWPCzzOBt4EjhoCIxCGz4GlpGbmN1wg6dYMTr4KKjbBzA2xeEXyu2d/IshlhIPQOA6M3pPep8zl875QeF6OVYtn93tvd14efNwB6xJGING3s3fDKbQ37BC7/RcM+gZoaqNwWhMLODVBR+77x4Hvx/OBz9d6G20ru0nStIr1PEBapWe06LNrEGCx3dzM7bLuUmU0DpgHk5eniEpG4daRHataVkABdewSvnGGHX6d70AG9c2MYFHXed64PwmL9h1AxD/ZVNPx9YqewBlGndnEgPOrULrr0OLYH9UR4NFTURgeFzUF/qNMnsAIY4+7rzawP8La7DznSetQnICIxs7fiYE2iNiAOrV3s3BCEyqEssU5YNFa7CF9dex28RuLDOY3XfI5hNFRbvG3Ey8Bk4MHw/fcxLIuIyJF1Sgte3Qc1vVxVZRgIjdQuKjYE/RolC2D3lkZ+bEHtJS0Htn4G+/c0XPcb97VabSAqIWBmswk6gXuYWQlwD8HBf46Z3QKsATTIV0Q6huRUyMoPXk2prgoulqsXFHX6LjZ+1PjvyktarajRGh008TBfjY3G9kVE2qTEZMjoF7wa8/CwxkdDZfRvtSIcQy+FiIhExdi7Gz6LITk1mN9KFAIiIm3VKROCTuCMXMCC91a+RUabGCIqIiKHccqEiN4XSTUBEZE4phAQEYljCgERkTimEBARiWMKARGROKYQEBGJYwoBEZE4phAQEYljCgERkTimEBARiWMKARGROKYQEBGJYwoBEZE4phAQEYljCgERkTimEBARiWMKARGROKYQEBGJYwoBEZE4phAQEYljCgERkTimEBARiWMKARGROKYQEBGJYwoBEZE4FvMQMLNLzGyFma00sztjXR4RkXgS0xAws0TgP4BLgROBiWZ2YizLJCIST2JdExgJrHT3L9x9H/AscFWMyyQiEjeSYrz9fkBxnekSYNShC5nZNGBaOFlhZiuOcXs9gC3H+Nv2SvscH7TPHV9L93dAYzNjHQLN4u7TgektXY+ZLXT3wlYoUruhfY4P2ueOL1L7G+vmoFIgt850/3CeiIhEQaxDYAEw2MwKzCwFuA54OcZlEhGJGzFtDnL3/Wb2TeDPQCLwhLsvjeAmW9yk1A5pn+OD9rnji8j+mrtHYr0iItIOxLo5SEREYkghICISx9rFENGjZWbdgTfCyRygGtgcTn8AXAFscvdhMSheRDSxz+nAWqA34MB0d/91TArZyprY587AboJ+piTgeXe/JyaFbEVH+P96ZDi9ECh19yuiX8LWd4R97gVsDeft7yjDRY+wzxcD/wkMI/j3/DV3/3uLttfR+wTM7F6gwt1/Hk6fB1QAszpSCNRVd5/NrA/Qx90/MLN0YBFwtbt/EtNCtrJD9tmAru5eYWbJwHvAt9z9/ZgWshUd+v91OO+7QCHQraOEQF2N/FteDRS6e4e9YKyRfZ4JvOvuj4cjKru4e1lLthF3zUHu/g6wLdbliBZ3X+/uH4SfdwLLCK7U7rA8UBFOJoevDn22Y2b9gcuBx2NdFokMM8sAzgNmALj7vpYGAMRhCMQzM8sHhgNFsS1J5JlZopktATYB89y9o+/zr4DvATWxLkgUOfC6mS0Kby3T0RUQNAv91swWm9njZta1pStVCMQJM0sDXgC+7e47Yl2eSHP3anc/jeAq9JFm1iGb/gDMrLaPa1GsyxJl57j76QR3If6XsKm3I0sCTgd+4+7DgV1Ai2+/rxCIA2G7+AvA0+7+YqzLE01hdfkt4JJYlyWCzgb+KWwjfxa40Myeim2RIs/dS8P3TcBLBJ3jHVkJUFKnVvs8QSi0iEKggws7SWcAy9z9l7EuTzSYWU8zyww/pwLjgOWxLVXkuPtd7t7f3fMJbr3yprvfEONiRZSZdQ0HOhA2iVwMfBzbUkWWu28Ais1sSDhrLNDiAR4dcohoU8xsNjAG6GFmJcA97j4jtqWKqLOBG4GPwjZygB+4+x9jWKZI6wPMDB9alADMcfc/xLhM0rp6Ay8F5zgkAc+4+59iW6SouBV4OhwZ9AVwc0tX2OGHiIqIyOGpOUhEJI4pBERE4phCQEQkjikERETimEJARCSOKQREROKYQkA6PDOrqPOqCl8H5h3jOvPNzMMbtzW13EAz+52ZbQi3V2xmL4XjvJuznTFmtv9YyijSHHF3sZjEH3dPq/1sZo8DSe4+JUqb/yPwOjAE2EFwB9crAIvS9kWapJqAxDUzyzOz58Mz9fVmNr3O7QjMzH5qZuvMbKeZrTazW8Of/iN8XxGe4f+okXV3Jzj4/5e7l4e3uC5x9/9y9711lrs6vBNmmZktM7Prw/l9gdeAxDo1l8mR/HtI/FEISNwys87AmwT3XykATiS462jtk9fGAZOBUe6eTnCDsvfC704N34e4e5q7/+TQ9bv7VmAp8LiZ3WRmJ4b3cqpbhnEE93b6NpAdbu9RMzvP3dcR3CGzOtxGmrvPbK39FwGFgMS3KwhunXK3u1e6+3bgR8D14X2H9hE8qvIkM+vs7pvcffFRbmMM8DbBQX4JsNHMflQnDL4F/Nrd33X3GnefDzwF3NTivRNpBoWAxLMCIC9shikzszKCZ7s6kOPubwM/AH4IbDKz183sqJ5j6+5b3P0H4X3vMwke/HI3B2/8VQB8/5AyTAH6tsL+iRyRQkDi2RrgU3fPPOTVuc696qe7+zkED/xeAtQ+j+Gon+Dl7rvd/UngQ+C0OmW495Dtp7v7Zce6HZGjoRCQePYHIMXMfmBm6WFHcD8z+xKAmY00s3PNrBOwF9gJVIe/3UxwgB58uJWbWZaZPWBmw8ws2cySzOzLwDDg3XCxXwHfCbeTaGYpZnZGnRrHBoKO4YJW33sRFAISx9x9N3AhQYfwcqCcoDmo9iw9jaCTeAuwleDBJdeGv60k6D+YHTbj/L9GNrEP6EVQe9hGEBw/BG5z99+F63kdmAo8FG5nPfBwuG3c/VPgN8D8cDs3tuKfQETPExARiWeqCYiIxDGFgIhIHFMIiIjEMYWAiEgcUwiIiMQxhYCISBxTCIiIxDGFgIhIHPv/XMbgyLkGAg0AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# ploting each fig\n", + "plt.plot(test_num, WB_models_eval_ufr[1,0,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_ufr[1,1,:], '-o')\n", + "\n", + "plt.legend(['TUAP','Random','Orign'], fontsize=12)\n", + "plt.xlabel('Test Set',fontsize=13)\n", + "plt.ylabel('UFR',fontsize=13)\n", + "plt.ylim([0,60])\n", + "\n", + "plt.savefig('ufr-cnn',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "id": "KM-oMiJW2XBy", + "outputId": "687e9dd5-7e2b-4d05-ef1d-ed5212b9cc90" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# ploting each fig\n", + "plt.plot(test_num, WB_models_eval_ufr[2,0,:], '-o')\n", + "plt.plot(test_num, WB_models_eval_ufr[2,1,:], '-o')\n", + "\n", + "plt.legend(['TUAP','Random','Orign'], fontsize=12)\n", + "plt.xlabel('Test Set',fontsize=13)\n", + "plt.ylabel('UFR',fontsize=13)\n", + "plt.ylim([0,60])\n", + "\n", + "plt.savefig('ufr-rnn',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 276 + }, + "id": "MhdslFdiNEyh", + "outputId": "c58f9dac-6c7a-4605-f03f-722269c26db4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 16, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3,figsize=(20,5))\n", + "fig.suptitle('Horizontally stacked subplots')\n", + "\n", + "ax1.plot(WB_models_eval_ufr[0,0,:])\n", + "ax1.plot(WB_models_eval_ufr[0,1,:])\n", + "\n", + "ax2.plot(WB_models_eval_ufr[1,0,:])\n", + "ax2.plot(WB_models_eval_ufr[1,1,:])\n", + "\n", + "ax3.plot(WB_models_eval_ufr[2,0,:])\n", + "ax3.plot(WB_models_eval_ufr[2,1,:])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "k7qvHWRVN3zg", + "outputId": "55d0f69c-3e07-4acc-bb53-91f880c2a48c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "for model_res in WB_models_eval_ufr:\n", + " for row in model_res:\n", + " plt.plot(row)\n", + "plt.legend(['dnn_TUAP','dnn_rnd','cnn_TUAP','cnn_rnd','rnn_TUAP','rnn_rnd'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "transferability results on IBM and AAPL symbols" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 268 + }, + "id": "Xw1d13GSOGHQ", + "outputId": "27ecab01-4dbf-4415-ff41-503972693272" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns; sns.set_theme()\n", + "# results from our experiments\n", + "trans_data_IBM = np.array([[94.37,95.04,95],[94.45,95.33,94.75],[94.25,95,94.83]], dtype=np.float16)\n", + "trans_data_AAPL = np.array([[93.87,93.7,93.66],[93.16,93.91,93.45],[93.95,94.62,93.95]])\n", + "\n", + "ax = sns.heatmap(trans_data_IBM, annot=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 269 + }, + "id": "xIgenhozyW0h", + "outputId": "e71d7fd8-5cd7-4035-bb88-751cebcdd12d" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "ax = sns.heatmap(trans_data_AAPL, annot=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "id": "0Ctu4jUD2pMN", + "outputId": "fdbd233e-e755-4ca8-ab5c-bc17e3d464c0" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# visualization for adv retraining:\n", + "adv_retraining = [[69.75,65.66,67.58,61.66,55],[94.37,93.995,88.165,76.165,71.33]]\n", + "adv_portion = ['0','0.1','0.2','0.3','0.4']\n", + "plt.plot(adv_portion, adv_retraining[0], '-o')\n", + "plt.plot(adv_portion, adv_retraining[1], '-o')\n", + "\n", + "plt.legend(['DA','TFR_adv'], fontsize=12)\n", + "plt.xlabel('Adversarial Portion',fontsize=13)\n", + "# plt.ylabel('',fontsize=13)\n", + "plt.ylim([50,100])\n", + "\n", + "plt.savefig('adv_retrain',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oBz2JsFe2pHs" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Pvc9u97FPd9J" + }, + "source": [ + "# Mitigation\n", + "\n", + "___\n", + "\n", + "Implementation and evaluation of two mitigation solutions:\n", + "- adversarial retraining\n", + "- detection of adversarial examples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1f4NvB1LXNJY" + }, + "outputs": [], + "source": [ + "from sklearn.utils import shuffle\n", + "\n", + "#helper functions for our mitigation solutions\n", + "\n", + "# preper data with portion of adv samples\n", + "def getSamples_unlimited(X, nSamples_per_day):\n", + " days_samples = []\n", + " days_data = splitByDays(X[:np.int(X.shape[0]*0.7),:])\n", + " for day in days_data:\n", + " day_samples = sampleUniform(day,nSamples_per_day)\n", + " days_samples.append(day_samples)\n", + " return np.array(days_samples)\n", + "\n", + "def get_adv_samples(days_samples, UAP, aggParam, lookBack):\n", + " UAP = fitUAP(UAP, days_samples[0])\n", + " X_adv, y_real = prep(days_samples, UAP,aggParam, lookBack)\n", + " return X_adv, y_real\n", + "\n", + "def get_portion(x,y,amount):\n", + " indexs = np.random.random_integers(0,x.shape[0]-1,amount)\n", + " return x.take(indexs, axis=0), y.take(indexs, axis=0)\n", + "\n", + "def get_mixed_adv_by_portion(clean_x,clean_y, adv_x_up, adv_y_up, adv_x_down, adv_y_down, adv_portion = 0):\n", + " if adv_portion == 0:\n", + " return clean_x,clean_y\n", + " data_len = clean_x.shape[0]\n", + " clean_amount = int(data_len * (1 - adv_portion))\n", + " adv_amount = (data_len - clean_amount)//2\n", + " clean_x_part, clean_y_part = get_portion(clean_x,clean_y, clean_amount)\n", + " adv_x_part_up, adv_y_part_up = get_portion(adv_x_up, adv_y_up, adv_amount)\n", + " adv_x_part_down, adv_y_part_down = get_portion(adv_x_down, adv_y_down, adv_amount)\n", + " x_mixed = np.concatenate([clean_x_part, adv_x_part_up,adv_x_part_down])\n", + " y_mixed = np.concatenate([clean_y_part, adv_y_part_up,adv_y_part_down])\n", + " x_mixed,y_mixed = shuffle(x_mixed, y_mixed)\n", + " return x_mixed, y_mixed\n", + "\n", + "def getSamples_test(X, nSamples_per_day):\n", + " days_data = splitByDays(X[np.int(X.shape[0]*0.7):,:])\n", + " test_UAP = []\n", + " for i in range(6):\n", + " test_UAP.append(np.concatenate([sampleUniform(days_data[i*5+3+j],nSamples_per_day) for j in range(5)],axis=0))\n", + " return test_UAP\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "em4u0r-rPdPq", + "outputId": "b6ba5881-059e-43b3-e9c3-22160d15d2f5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Symbol: AAPL\n", + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "If using Keras pass *_constraint arguments to layers.\n", + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/math_grad.py:1424: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/keras/backend/tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n", + "\n", + "train done\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From :48: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use `tf.cast` instead.\n", + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/util/tf_should_use.py:198: initialize_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n", + "Instructions for updating:\n", + "Use `tf.variables_initializer` instead.\n", + "WARNING:tensorflow:From :74: Variable.load (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Prefer Variable.assign which has equivalent behavior in 2.X.\n", + "perturb done\n", + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/keras/backend/tensorflow_backend.py:431: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n", + "\n" + ] + } + ], + "source": [ + "# adv retraining pipeline\n", + "# view for white-box scenario\n", + "\n", + "stocks2run = ['AAPL'] # list of symbols to be tested \n", + "aggParam = 5\n", + "lookBack = 5\n", + "nEpochs = 12\n", + "sizes = []\n", + "results = []\n", + "for idx, Symbol in enumerate(stocks2run):\n", + " print('Symbol: '+Symbol)\n", + " sizes = []\n", + " models = []\n", + " evals = []\n", + " #preprocess \n", + " X = readSymbolData(Symbol)\n", + " X = parseTime(X)\n", + " X = np.array(X)\n", + " # preper the data for training:\n", + " X_train, y_train = get_train_data(X, aggParam, lookBack)\n", + " #save the session for later attack\n", + " sess = tf.Session()\n", + " keras.backend.set_session(sess)\n", + " lockSeed()\n", + " #build and train the model\n", + " nFeatures = (lookBack * 3) + 2\n", + " #creating the 3 models to attack then transfer \n", + " DNN_model, history = create_DNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " train_acc = history.history['accuracy'][-1]\n", + " val_acc = history.history['val_accuracy'][-1]\n", + "\n", + " print(\"train done\")\n", + " \n", + " # create UAP for each model\n", + " UAPs = []\n", + " cData, test_UAP = getSamplesByDays(X, 'up')\n", + " target_label_down = getTarget('down')\n", + " target_label_up = getTarget('up')\n", + " for target in [target_label_down, target_label_up]:\n", + " UAPs.append(targeted_batch_UAP(cData, DNN_model,target, isSeries = 0))\n", + "\n", + " sizes.append([relativeSize(cData,uap) for uap in UAPs])\n", + " base_mean_price = np.mean(cData[:,5:30,3],dtype=np.float32)\n", + " max_size = np.max(sizes[0])/100\n", + " print('perturb done')\n", + " # evaluate UAPs\n", + " tData = np.concatenate(test_UAP[:],axis=0)\n", + " scaling = np.mean(tData[:,5:30,3],dtype=np.float32)/base_mean_price\n", + " eval0 = []\n", + "\n", + " # _, _, model0_acc = eval_UAP(DNN_model, UAPs[0], tData, nFeatures)\n", + " evals.append([train_acc, val_acc])\n", + "\n", + " for i in np.arange(6):\n", + " _, _, TFR_down = eval_UAP_targeted(DNN_model, UAPs[0]*scaling, test_UAP[i], target_label_down, aggParam, lookBack, nFeatures)\n", + " _, _, TFR_up = eval_UAP_targeted(DNN_model, UAPs[1]*scaling, test_UAP[i], target_label_up, aggParam, lookBack, nFeatures) \n", + " eval0.append((TFR_down+TFR_up)/2.)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xmZ2_807kmTG", + "outputId": "30eb4bbf-c39e-4c87-a874-eae5a5c2bbf5" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done 0.1\n", + "done 0.2\n", + "done 0.3\n", + "done 0.4\n" + ] + } + ], + "source": [ + "# phase 2 - train robust model with adv learning\n", + "# prep adv data\n", + "days_samples = getSamples_unlimited(X, 60)\n", + "days_samples = days_samples.reshape((days_samples.shape[0]*days_samples.shape[1],days_samples.shape[2],days_samples.shape[3]))\n", + "adv_samples_up, y_real_up = get_adv_samples(days_samples, UAPs[0], 5,5)\n", + "adv_samples_down, y_real_down = get_adv_samples(days_samples, UAPs[1], 5,5)\n", + "\n", + "for portion in [0.1,0.2,0.3,0.4]:\n", + " mixed_adv_train_x, mixed_adv_train_y = get_mixed_adv_by_portion(X_train,y_train,\n", + " adv_samples_up, y_real_up,\n", + " adv_samples_down, y_real_down,\n", + " adv_portion=portion)\n", + " # build new model\n", + " DNN_model, history = create_DNN_clf(mixed_adv_train_x, mixed_adv_train_y, nFeatures, nEpochs)\n", + " # eval model\n", + " _, _, model_adv = eval_UAP(DNN_model, UAPs[0], tData, nFeatures)\n", + " train_acc = history.history['accuracy'][-1]\n", + " val_acc = history.history['val_accuracy'][-1]\n", + " evals.append([train_acc,val_acc])\n", + " for i in np.arange(6):\n", + " _, _, TFR_down = eval_UAP_targeted(DNN_model, UAPs[0]*scaling, test_UAP[i], target_label_down, aggParam, lookBack, nFeatures)\n", + " _, _, TFR_up = eval_UAP_targeted(DNN_model, UAPs[1]*scaling, test_UAP[i], target_label_up, aggParam, lookBack, nFeatures) \n", + " eval0.append((TFR_down+TFR_up)/2.)\n", + " print('done {}'.format(portion))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "o2wOBQFesLUB", + "outputId": "86ac1ba9-f56d-4bb2-8473-efd6aec3d160" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot retrain DA\n", + "ev_train = [evals[i][0]*100 for i in np.arange(0,5)]\n", + "ev_test = [evals[i][1]*100 for i in np.arange(0,5)]\n", + "portions = ['0%','10%','20%', '30%','40%']\n", + "\n", + "plt.plot(portions, ev_train, '-o')\n", + "plt.plot(portions, ev_test, '-o')\n", + "\n", + "plt.legend(['Training set','Test set'], fontsize=12, )\n", + "plt.xlabel('Adversarial Portion',fontsize=13)\n", + "plt.ylabel('Directional Accuracy',fontsize=13)\n", + "plt.ylim([50,105])\n", + "\n", + "\n", + "plt.savefig('adv_train-da',bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ofPB_bGpZY4f" + }, + "outputs": [], + "source": [ + "ev1 = [eval0[i*6]*100 for i in np.arange(5)]\n", + "ev2 = [eval0[1+i*6]*100 for i in np.arange(5)]\n", + "ev3 = [eval0[2+i*6]*100 for i in np.arange(5)]\n", + "ev4 = [eval0[3+i*6]*100 for i in np.arange(5)]\n", + "ev5 = [eval0[4+i*6]*100 for i in np.arange(5)]\n", + "ev6 = [eval0[5+i*6]*100 for i in np.arange(5)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "b4gRImapTyyS", + "outputId": "854cf9db-54bf-4012-a2da-bff8be2443a9" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "portions = ['0%','10%','20%', '30%','40%']\n", + "\n", + "plt.plot(portions, ev1, '-o')\n", + "plt.plot(portions, ev2, '-o')\n", + "plt.plot(portions, ev3, '-o')\n", + "plt.plot(portions, ev4, '-o')\n", + "plt.plot(portions, ev5, '-o')\n", + "plt.plot(portions, ev6, '-o')\n", + "\n", + "plt.legend(['T1','T2','T3','T4','T5','T6'], fontsize=12, bbox_to_anchor=(0.2,0.0), loc=\"lower right\")\n", + "plt.xlabel('Adversarial Portion',fontsize=13)\n", + "plt.ylabel('TFR',fontsize=13)\n", + "plt.ylim([50,105])\n", + "\n", + "\n", + "plt.savefig('adv_train-tfr',bbox_inches='tight')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YbzyMWVIguOm", + "outputId": "aa28ae64-1fcd-4910-ed2a-e3c86eb82d8e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Symbol: AAPL\n", + "train done\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n" + ] + } + ], + "source": [ + "# detection of adv samples with an external detector \n", + "# first we will try to cach anomalies after the preprocess\n", + "\n", + "stocks2run = ['AAPL'] # list of symbols to be tested \n", + "aggParam = 5\n", + "lookBack = 5\n", + "nEpochs = 12\n", + "sizes = []\n", + "results = []\n", + "for idx, Symbol in enumerate(stocks2run):\n", + " print('Symbol: '+Symbol)\n", + " sizes = []\n", + " models = []\n", + " evals = []\n", + " #preprocess \n", + " X = readSymbolData(Symbol)\n", + " X = parseTime(X)\n", + " X = np.array(X)\n", + " # preper the data for training:\n", + " X_train, y_train = get_train_data(X, aggParam, lookBack)\n", + " #save the session for later attack\n", + " sess = tf.Session()\n", + " keras.backend.set_session(sess)\n", + " lockSeed()\n", + " #build and train the model\n", + " nFeatures = (lookBack * 3) + 2\n", + " #creating the 3 models to attack then transfer \n", + " DNN_model, history = create_DNN_clf(X_train, y_train, nFeatures, nEpochs)\n", + " models.append(DNN_model)\n", + "\n", + " print(\"train done\")\n", + "\n", + " # create UAP for each model\n", + " UAPs = []\n", + " cData, test_UAP = getSamplesByDays(X, 'up')\n", + " target_label_down = getTarget('down')\n", + " target_label_up = getTarget('up')\n", + " for target in [target_label_down, target_label_up]:\n", + " UAPs.append(targeted_batch_UAP(cData, models[0],target, isSeries = 0))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LF4Uy1NiELaw" + }, + "outputs": [], + "source": [ + "def get_anomalous_data(x_ben, x_adv_up, x_adv_down, portion, total_nSamples):\n", + " clean_amount = int(total_nSamples * (1 - portion))\n", + " adv_amount = (total_nSamples - clean_amount)//2\n", + " y_ben = np.zeros((x_ben.shape[0]))\n", + " y_adv = np.ones((x_adv_up.shape[0]))\n", + " x_ben_part, y_ben_part = get_portion(x_ben,y_ben, clean_amount)\n", + " adv_x_part_up, adv_y_part_up = get_portion(x_adv_up, y_adv, adv_amount)\n", + " adv_x_part_down, adv_y_part_down = get_portion(x_adv_down, y_adv, adv_amount)\n", + " return np.concatenate([x_ben_part, adv_x_part_up,adv_x_part_down]), np.concatenate([y_ben_part, adv_y_part_up,adv_y_part_down])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OiUxmiji2Nyy", + "outputId": "2c89dce2-64f0-40f9-fb2c-3bdceb099082" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n" + ] + } + ], + "source": [ + "total_nSamples = 20000\n", + "portion = 0.1\n", + "\n", + "# prep train data\n", + "days_samples = getSamples_unlimited(X, 60)\n", + "days_samples = days_samples.reshape((days_samples.shape[0]*days_samples.shape[1],days_samples.shape[2],days_samples.shape[3]))\n", + "adv_samples_up, y_real_up = get_adv_samples(days_samples, UAPs[0], 5,5)\n", + "adv_samples_down, y_real_down = get_adv_samples(days_samples, UAPs[1], 5,5)\n", + "\n", + "x_anomalous, y_anomalous = get_anomalous_data(X_train, adv_samples_up,\n", + " adv_samples_down, portion, total_nSamples)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j0hyp4eV-8Mc", + "outputId": "4b8f1bcd-cdd3-4451-fe21-346fe131c7a7" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n" + ] + } + ], + "source": [ + "# prep test data \n", + "test_anomalous = []\n", + "ben_test = getSamples_test(X, 720) # to get 0.1 precent of adv \n", + "for i in np.arange(6):\n", + " adv_samples_up, _ = get_adv_samples(test_UAP[i], UAPs[0], 5,5)\n", + " adv_samples_down, _ = get_adv_samples(test_UAP[i], UAPs[1], 5,5)\n", + " ben_samples,_ = get_adv_samples(ben_test[i], UAPs[0]*0, 5,5)\n", + " x_anomalous_test = np.concatenate([adv_samples_up,adv_samples_down,ben_samples],axis=0)\n", + " y_anomalous_test = np.zeros((x_anomalous_test.shape[0]))\n", + " y_anomalous_test[0:adv_samples_down.shape[0]*2] = 1\n", + " test_anomalous.append([x_anomalous_test,y_anomalous_test])\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NHza60GwMU_y", + "outputId": "8b8d7330-bde7-43f8-b67f-43787686f96d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n", + " metric_params=None, n_jobs=None, n_neighbors=5, p=2,\n", + " weights='uniform')" + ] + }, + "execution_count": 46, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.neighbors import KNeighborsClassifier\n", + "\n", + "knn = KNeighborsClassifier(n_neighbors=5)\n", + "knn.fit(x_anomalous[:,:nFeatures], y_anomalous)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JE4Sb0JeJt3K" + }, + "outputs": [], + "source": [ + "# test the detector for anomalous data t1-t6:\n", + "results = []\n", + "\n", + "for i in np.arange(6):\n", + " preds = knn.predict(test_anomalous[i][0][:,:17])\n", + " cm = confusion_matrix(test_anomalous[i][1],preds)\n", + " results.append(cm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BrjTU2iA8bkd" + }, + "outputs": [], + "source": [ + "# test the detector for anomalous data t1-t6:\n", + "\n", + "for i in np.arange(6):\n", + " preds = clf.predict(test_anomalous[i][0][:,:17])\n", + " cm = confusion_matrix(test_anomalous[i][1],preds)\n", + " results.append(cm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "id": "q72WGuMtToKx", + "outputId": "ba2a4704-157f-465d-b6f2-d6de487706be" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import plot_confusion_matrix\n", + "\n", + "plot_confusion_matrix(knn, test_anomalous[i][0][:,:17], test_anomalous[i][1], normalize='all') \n", + "\n", + "i+=1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "0hp9mJo9M0Yo", + "jupyter": { + "outputs_hidden": true + }, + "outputId": "cd7253cc-67c9-4e63-ec26-4a10e26b473c", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/12\n", + "20000/20000 [==============================] - 1s 68us/step - loss: 0.4131 - accuracy: 0.8671\n", + "Epoch 2/12\n", + "20000/20000 [==============================] - 1s 56us/step - loss: 0.3245 - accuracy: 0.9000\n", + "Epoch 3/12\n", + "20000/20000 [==============================] - 1s 54us/step - loss: 0.2707 - accuracy: 0.8977\n", + "Epoch 4/12\n", + "20000/20000 [==============================] - 1s 53us/step - loss: 0.2057 - accuracy: 0.9068\n", + "Epoch 5/12\n", + "20000/20000 [==============================] - 1s 55us/step - loss: 0.1751 - accuracy: 0.9233\n", + "Epoch 6/12\n", + "20000/20000 [==============================] - 1s 53us/step - loss: 0.1581 - accuracy: 0.9326\n", + "Epoch 7/12\n", + "20000/20000 [==============================] - 1s 52us/step - loss: 0.1544 - accuracy: 0.9341\n", + "Epoch 8/12\n", + "20000/20000 [==============================] - 1s 53us/step - loss: 0.1502 - accuracy: 0.9360\n", + "Epoch 9/12\n", + "20000/20000 [==============================] - 1s 53us/step - loss: 0.1454 - accuracy: 0.9396\n", + "Epoch 10/12\n", + "20000/20000 [==============================] - 1s 53us/step - loss: 0.1421 - accuracy: 0.9400\n", + "Epoch 11/12\n", + "20000/20000 [==============================] - 1s 52us/step - loss: 0.1361 - accuracy: 0.9428\n", + "Epoch 12/12\n", + "20000/20000 [==============================] - 1s 52us/step - loss: 0.1391 - accuracy: 0.9408\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "# ann\n", + "\n", + "model = Sequential()\n", + "\n", + "model.add(Dense(30, activation='relu', input_shape=(nFeatures,)))\n", + "\n", + "# model.add(Dense(25, activation='relu'))\n", + "model.add(Dense(10, activation='relu'))\n", + "\n", + "model.add(Dense(2, activation='softmax'))\n", + "\n", + "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n", + "model.fit(x_anomalous[:,:nFeatures], keras.utils.to_categorical(y_anomalous, num_classes=2, dtype='float32')\n", + " ,epochs=nEpochs,shuffle=True,verbose=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VFG4FeJt0354" + }, + "outputs": [], + "source": [ + "for i in np.arange(6):\n", + " preds = model.predict(test_anomalous[i][0][:,:17])\n", + " cm = confusion_matrix(test_anomalous[i][1],np.argmax(preds, axis=1))\n", + " results.append(cm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VOjK2uK9WUQ2" + }, + "outputs": [], + "source": [ + "preds = model.predict(test_anomalous[0][0][:,:nFeatures])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 296 + }, + "id": "IPWJV-O-V1fs", + "outputId": "4142366b-6246-46fd-b62e-67307aa20176" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import ConfusionMatrixDisplay\n", + "cm = confusion_matrix(y_anomalous,np.argmax(preds, axis=1), normalize='all')\n", + "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['norm','mal'])\n", + "disp.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "h-SOZxF5Whqb", + "outputId": "e883ec1d-07d9-4bc9-fe5d-226349fc9049" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n" + ] + } + ], + "source": [ + "days_data = splitByDays(X[np.int(X.shape[0]*0.7):,:])\n", + "\n", + "a = np.concatenate([sampleUniform(days_data[3+j],40) for j in range(5)],axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "y259vYnaA5Hw" + }, + "outputs": [], + "source": [ + "# test the detector for anomalous data t1-t6:\n", + "results = []\n", + "mal_labels = np.ones((test_anomalous[0][0].shape[0]))\n", + "for test in test_anomalous:\n", + " preds = model.predict(test[0][:,:17])\n", + " cm_up = confusion_matrix(mal_labels,np.argmax(preds, axis=1))\n", + " preds = model.predict(test[1][:,:17])\n", + " cm_down = confusion_matrix(mal_labels,np.argmax(preds, axis=1))\n", + " results.append([cm_up,cm_down])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WKzmW9h2EwoG" + }, + "outputs": [], + "source": [ + "# prep test data \n", + "test_norm = []\n", + "for test in test_UAP:\n", + " adv_samples_up, _ = get_adv_samples(test, UAPs[0]*0, 5,5)\n", + " test_norm.append([adv_samples_up])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 296 + }, + "id": "Ru4z2VoMHl54", + "outputId": "9ba8c63c-e741-47ba-87d5-69c5c5082e70" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 58, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUwAAAEGCAYAAAAOraxVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAcG0lEQVR4nO3deZhcVZ3/8fcnO4SQEBIgQEIChCBECRIB0ThBUMCfiriw6LAIwzbs4/JTVFBExgeM6IwKEwTBGQREUBCQfXdASCACIYmBECALgWwQICTp7u/8cW9B0aS7TndX9e3q/rye5z7UPXXrnm+lyDfn3HPPPYoIzMyssl5FB2BmVi+cMM3MEjlhmpklcsI0M0vkhGlmlqhP0QHUSr9eA2KDXoOKDsPaYOzOq4oOwdpo+hNrlkbE8PZ+fr+9B8ay5Y2pdd0WEfu3t65q6LYJc4Neg/jw4IOKDsPa4Jbb7ik6BGuj3iOeeb4jn1+2vJFHbhuVWNfcYR2pqxq6bcI0s64vgCaaig4jmROmmRUmCNZFWpe8K3DCNLNCuYVpZpYgCBrraHq2E6aZFaoJJ0wzs4oCaHTCNDNL4xammVmCANb5GqaZWWVBuEtuZpYkoLF+8qUTppkVJ5vpUz+cMM2sQKIRFR1EMidMMytMNujjhGlmVlF2H2Z1Eqaky4BPAy9HxPi87BpgXH7IEGBlREyQNBqYBczJ33s4Ik6oVIcTppkVqql6LczLgV8Avy0VRMQhpdeSpgCvlh3/bERMaEsFTphmVphqtjAj4v685fgekgQcDHy8I3V4iQozK0wgGumVtHXQJGBJRMwtKxsj6XFJ90malHIStzDNrFBt6JIPkzStbH9qRExN/OxhwFVl+4uBURGxTNJuwJ8k7RwRr7V2EidMMytMINZG79TDl0bExLbWIakP8Hlgt7frjVgDrMlfT5f0LLADMG29J8k5YZpZYbIb12t+ZXBfYHZELCgVSBoOLI+IRknbAmOBeZVO5GuYZlaoxvzm9UpbJZKuAh4CxklaIOmY/K1DeXd3HOBjwBOSZgB/AE6IiOWV6nAL08wKEyEaozrttog4rIXyo9ZTdh1wXVvrcMI0s0I1eWqkmVll2aBP/aSh+onUzLqdThr0qRonTDMrVKMfvmFmVllppk+9cMI0s0I1VWmUvDM4YZpZYbKHbzhhmplVFIh16VMjC+eEaWaFiaBqN653BidMMyuQfOO6mVmKwC1MM7NkHvQxM0sQqJpr+tScE6aZFSZbZrd+0lD9RGpm3VDasy67CidMMytM4Jk+ZmbJ3MI0M0sQIbcwzcxSZIM+nhppZpagemv6dIb6idTMup1s0EdJWyWSLpP0sqSnysq+L2mhpBn59qmy974t6RlJcyTtlxKvW5hmVqgqzvS5HPgF8Ntm5RdGxE/KCyTtRLb87s7AlsCdknaIiMbWKnAL08wKU5rpU40WZkTcD1RcWzx3IHB1RKyJiOeAZ4DdK33ICdPMCtVEr6QNGCZpWtl2XGIVJ0t6Iu+yb5KXbQW8WHbMgrysVe6Sm1lhImBdU3K7bWlETGxjFRcBPyS7XPpDYApwdBvP8TYnTDMrTNYlr11HNyKWlF5LugS4Kd9dCIwsO3TrvKxV7pKbWaEa8/nklbb2kDSibPcgoDSCfiNwqKT+ksYAY4FHKp3PLcw6cuA/L2C/Ly5Cglv/MIIb/ntk5Q9Zm005YyR/u3NjhgxrYOo9c97z/qqVvfnpv41k8fP96du/ia/99EVG7/hWh+pcu0ZccOoo5j65IRtv0sCZFz/PFiPXMv2+jbjsvC1pWCf69A2O/d4iJnz09Q7V1ZWUbiuqBklXAZPJrnUuAM4GJkuakFc1HzgeICJmSvo98DTQAJxUaYQc3MKsG9ts/zr7fXERZxy6Gyd9fiK7/9MyRox6s+iwuqVPHrKcH105r8X3r/6Pzdlu59VcfNccvvHzF7jorIpjBW976cV+fOML27+n/LarhrLRkEYu/99ZfP7YV7j03KxhNHhoI+dcMY//ujur6/xTR7X9C3VpWZc8ZaskIg6LiBER0Tcito6ISyPi8Ih4f0R8ICI+GxGLy47/UURsFxHjIuIvKdF2yYQpyS3fZkZu+yZzntiYNW/1pqmxF09NG8JH9l1adFjd0vv3fINBm7Tc2Hhhbn92yVt5o8auYcmL/VjxSva/7F3XbcIpnxrLifuO4+ff3JrGim2WzEO3DeYTX8ruiJn06ZXMeHAQEbD9+1ez6RYNAGwz7i3WvNWLtWvq52EVKZrydX0qbV1BzRKmpNGSZkm6RNJMSbdL2kDSBEkP58P8fywN80u6V9LPJE0DTsv3L8xvH5gl6UOSrpc0V9K5tYq7q3r+mYGM3+1VBg1eR/8BjUyctJxhW6wpOqweacxOb/HXWwYDMPvxDVmyoB9LF/flhbn9ue+GIVx4w1wuunMOvXrD3ddvUuFsmaUv9WX4lusA6N0HBm7cyGvL3z3H+sGbB7P9+NX06x/V/UIFykbJeydtXUGtW3JjgcMi4tj8esEXgG8Cp0TEfZLOIbvOcHp+fL/SbQOSPgOsjYiJkk4DbgB2I7sx9VlJF0bEsvLK8vuyjgMY0GujGn+1zvXivIFce+kozr3k76xZ3Zt5szeiqanoqHqmQ05ewkXf24oT9x3HmPetZvvxq+nVCx5/YBBzn9yQUw4YB8Dat8SQTbPW4Q+OHs1LL/SnYZ14eWFfTtw3O+Zz//IK+x1a+V7r+XMGcOmPtuS8q56t3RcrgJeoeLfnImJG/no6sB0wJCLuy8uuAK4tO/6aZp+/Mf/vk8DM0vUHSfPIbgl4V8KMiKnAVIDBfYZ3n3+Gc7dfP4Lbr8+ubR152jyWLulfcEQ908BBTXz9Z9k9zxFw5B47scU2a3jqbwP5xJeWc/SZi9/zmbMvmw9k1zCnnD6KC6575l3vD9tiHa8sylqZjQ3wxmu92Xho1p9/ZVFfzjlmNN/4+QtsOXptbb9cAbpKdztFra9hlvcZG4EhFY5/o4XPNzU7VxM9cIR/8NDsL8vwEW+x176vcO/NmxUcUc/0+qu9Wbc2+0v+l98NZfyerzNwUBMTJq3igZuHsHJp9r/mayt6s2RB36Rz7vnJ17jj2qEAPHDTEHb56CqkrK7vHbEtR5+5mJ13b/7Xo/5V8+EbnaGzk86rwApJkyLiAeBw4L4Kn7Hcd342k42HrKOhQfzq3B14Y1XaX0Zrm38/cRueeGgjXl3eh6/sthOHf+0lGhqyv7CfPmIZL8ztz09OH4XIBmLOmJK1NrfZYQ1HfnMx3z50OyKgd5/g5PMWsPnW6yrWuf9hyzj/1G04aq/3MWhIA2de9DwAN/5mGIue68eVP92CK3+6RRbf1c8yZFhDbb58AfwA4dYdCVwsaUNgHvDVAmKoS988YteiQ+gRvp0nq5bsNPFNLntw9nrfm3zgSiYfuLLFz24xcu17uuMA/QYE3506/z3lXz59CV8+fcl7yruLCNHghAkRMR8YX7Zf/nilPddz/OSW9iPiXuDelo41s/rVVbrbKXrcdUAz6zqqOdOnMzhhmlmhnDDNzBL4Pkwzszaop/swnTDNrDAR0JD+AOHCOWGaWaHcJTczS+BrmGZmbRBOmGZmaTzoY2aWIMLXMM3MEonGOholr59IzaxbilDSVomkyyS9LOmpsrILJM0uW+FhSF4+WtJqSTPy7eKUWJ0wzawwVX4e5uXA/s3K7gDGR8QHgH8A3y5779mImJBvJ6RU4IRpZsWJ7DpmylbxVBH3ky1hU152e0SUHh76MLB1R8J1wjSzQrVh1chh+aKIpe24NlZ1NFC+nO4YSY9Luk/SpJQTeNDHzAoTbRv0WVpaJLGtJH0HaACuzIsWA6MiYpmk3YA/Sdo5Il5r7TxOmGZWqJTudkdIOgr4NLBPRFZbRKwhXycsIqZLehbYAZjW2rmcMM2sULWc6SNpf7Klvf8pIt4sKx8OLI+IRknbki0JPq/S+Zwwzaww2YBOdRKmpKuAyWTXOhcAZ5ONivcH7pAE8HA+Iv4x4BxJ68hWoT0hIiouEO+EaWaFqtZMn4g4bD3Fl7Zw7HXAdW2twwnTzApV62uY1eSEaWaFCURTHU2NdMI0s0LVUQPTCdPMClTFQZ/O4IRpZsWqoyamE6aZFapbtDAl/Set5P6IOLUmEZlZjxFAU1M3SJhUmCJkZtZhAXSHFmZEXFG+L2nD8qlFZmbVUE/3YVa8AUrShyU9DczO93eR9KuaR2ZmPUMkbl1Ayh2jPwP2A5YBRMTfyeZhmpl1UNryFF1lYChplDwiXswnrpc01iYcM+txukjrMUVKwnxR0l5ASOoLnAbMqm1YZtYjBEQdjZKndMlPAE4CtgIWARPyfTOzKlDiVryKLcyIWAp8pRNiMbOeqI665Cmj5NtK+rOkV/I1f2/In1BsZtZx3WyU/HfA74ERwJbAtcBVtQzKzHqI0o3rKVsXkJIwN4yI/46Ihnz7H2BArQMzs56hWuuSd4bW5pIPzV/+RdK3gKvJ/j04BLilE2Izs56gjkbJWxv0mU6WIEvf5viy94JscSEzsw5RF2k9pmhtLvmYzgzEzHqgKg7oSLqMbP3xlyNifF42FLgGGA3MBw6OiBXKZuL8HPgU8CZwVEQ8VqmOpMU0JI2XdLCkI0pbe76Qmdm7JQ74pA36XA7s36zsW8BdETEWuCvfBziAbC3yscBxwEUpFaTcVnQ28J/5tjdwPvDZlJObmVVUpduKIuJ+oPna4gcCpSevXQF8rqz8t5F5GBgiaUSlOlJamF8E9gFeioivArsAgxM+Z2ZWWVPiBsMkTSvbjks4++YRsTh//RKwef56K+DFsuMW5GWtSplLvjoimiQ1SNoYeBkYmfA5M7PWte0BwksjYmK7q4oIqWNDTCkJc5qkIcAlZCPnrwMPdaRSM7OSGo+SL5E0IiIW513ul/Pyhby74bd1Xtaqil3yiPjXiFgZERcDnwCOzLvmZmYdV9upkTcCR+avjwRuKCs/Qpk9gVfLuu4tau3G9Q+29l7KELyZWWeRdBUwmexa5wLgbODHwO8lHQM8DxycH34L2S1Fz5DdVpTUCGytSz6llfcC+HhKBUWJxkYaV6woOgxrg/22nFB0CNZmz3T4DNXqkkfEYS28tc96jg3a8ZjK1m5c37utJzMza5Og20yNNDOrve4wNdLMrDN0i7nkZmadoo4SZsrUSEn6Z0ln5fujJO1e+9DMrEfoZk9c/xXwYaA0ArUK+GXNIjKzHkORvnUFKV3yPSLig5IeB8gfjdSvxnGZWU/RzUbJ10nqTd4oljSc0lR4M7MO6iqtxxQpXfL/AP4IbCbpR8CDwHk1jcrMeo46uoaZsi75lZKmk90tL+BzETGr5pGZWffXha5PpqiYMCWNIptr+efysoh4oZaBmVkP0Z0SJnAz7yyGNgAYA8wBdq5hXGbWQ6iORkRSuuTvL9/Pn2L0rzWLyMysi2rzTJ+IeEzSHrUIxsx6oO7UJZf0b2W7vYAPAotqFpGZ9RzdbdAHGFT2uoHsmuZ1tQnHzHqc7pIw8xvWB0XE1zspHjPrabpDwpTUJyIaJH2kMwMys55DdJ9R8kfIrlfOkHQjcC3wRunNiLi+xrGZWXfXDa9hDgCWka3hU7ofMwAnTDPruColTEnjgGvKirYFzgKGAMcCr+TlZ0bELe2po7WEuVk+Qv4U7yTKkjr6N8HMurTqLYI2B5gAb4+/LCR7DsZXgQsj4icdraO1hNkb2Ih3J8q3Y+toxWZmULMu+T7AsxHxvFS9x8e1ljAXR8Q5VavJzGx90hPmMEnTyvanRsTUFo49FLiqbP9kSUcA04CvRUS71uBu7fFu9fNUTzOrT5GNkqdswNKImFi2rTdZ5g84/yzZQDXARcB2ZN31xcCU9obbWsJ8z+LnZmZVV/3nYR4APBYRSwAiYklENEZEE3AJ0O41yVpMmBGxvL0nNTNLVYM1fQ6jrDsuaUTZeweRDWS3i5fZNbNiVXHQR9JA4BPA8WXF50uakNc0v9l7beKEaWbFqfLyExHxBrBps7LDq3V+J0wzK4zofjN9zMxqxgnTzCyVE6aZWSInTDOzBN3waUVmZrXjhGlmlqa7PEDYzKzm3CU3M0tR5RvXa80J08yK5YRpZlaZZ/qYmbWBmuonYzphmllxfA3TzCydu+RmZqmcMM3M0riFaWaWygnTzCxBeGqkmVkS34dpZtYWUT8Z0wnTzApVzRampPnAKqARaIiIiZKGAtcAo8lWjTw4Ila05/wtrktuXc/Eya/x6wdm85u/zuLgk5cUHY4l8G9WQbRhS7d3REyIiIn5/reAuyJiLHBXvt8udZcwJU2WdFPRcXS2Xr2Ck85byHe/MoZjJ49j7wNXMmrsW0WHZa3wb5ZGTWlbBxwIXJG/vgL4XHtPVHcJs6cat+ubLJrfj5de6E/Dul7ce8MQPrzfq0WHZa3wb5amDQlzmKRpZdtx6zldALdLml72/uYRsTh//RKweXtjLeQapqTRwK3Aw8BewKPAb4AfAJsBX8kP/TkwAFgNfDUi5nR2rF3Fplus45VF/d7eX7q4Lzt+8M0CI7JK/JslCNoy6LO0rJvdko9GxEJJmwF3SJr9ruoiQmr/VdMiW5jbA1OAHfPty8BHga8DZwKzgUkRsStwFnBepRNKOq70r8861tQscDOrHkXaliIiFub/fRn4I7A7sETSCID8vy+3N9YiE+ZzEfFkRDQBM8kuygbwJNlo1mDgWklPARcCO1c6YURMjYiJETGxL/1rGHrnW/ZSX4Zvufbt/WEj1rF0cd8CI7JK/JslqtKgj6SBkgaVXgOfBJ4CbgSOzA87ErihvaEWmTDLm4BNZftNZJcKfgjcExHjgc+Qdc17rDkzNmSrMWvZfOQa+vRtYvKBK3n49sFFh2Wt8G9WWenG9Sq1MDcHHpT0d+AR4OaIuBX4MfAJSXOBffP9dunK92EOBhbmr48qMI4uoalR/PI7W3He7+bRqzfcfvVQnv9Hj/43pMvzb5YgomoPEI6IecAu6ylfBuxTjTq6csI8H7hC0neBm4sOpit49O6NefTujYsOw9rAv1mC+pnoU0zCjIj5wPiy/aNaeG+Hso99N3//XuDe2kZoZp3Fc8nNzFIE4DV9zMwS1U++dMI0s2K5S25mlsjL7JqZpfAyu2ZmabIb1+snYzphmlmxvKaPmVkatzDNzFL4GqaZWarqzSXvDE6YZlYsd8nNzBJEh9fr6VROmGZWLLcwzcwS1U++dMI0s2KpqX765E6YZlacwDeum5mlEFFXN64XuQiamVk26JOyVSBppKR7JD0taaak0/Ly70taKGlGvn2qvaG6hWlmxapeC7MB+FpEPJYvtztd0h35exdGxE86WoETppkVp4rXMCNiMbA4f71K0ixgq+qcPeMuuZkVSk1NSRswTNK0su24Fs8pjQZ2Bf6WF50s6QlJl0napL2xOmGaWYESr19m3falETGxbJu6vjNK2gi4Djg9Il4DLgK2AyaQtUCntDdad8nNrDhBVWf6SOpLliyvjIjrASJiSdn7lwA3tff8bmGaWbGaErcKJAm4FJgVET8tKx9RdthBwFPtDdUtTDMrVBXvw/wIcDjwpKQZedmZwGGSJpC1Z+cDx7e3AidMMytWlRJmRDxItkxQc7dUpQKcMM2sSBHQWD9zI50wzaxYdTQ10gnTzIrlhGlmliAAr+ljZpYiIHwN08ysssCDPmZmyXwN08wskROmmVmKtIcDdxVOmGZWnAC8CJqZWSK3MM3MUnhqpJlZmoDwfZhmZok808fMLJGvYZqZJYjwKLmZWTK3MM3MUgTR2Fh0EMmcMM2sOH68m5lZG9TRbUVeZtfMChNANEXSlkLS/pLmSHpG0reqHa8TppkVJ/IHCKdsFUjqDfwSOADYiWx53Z2qGa675GZWqCoO+uwOPBMR8wAkXQ0cCDxdrQq6bcJcxYqld8Yfni86jhoZBiwtOghL1p1/r2068uFVrLjtzvjDsMTDB0iaVrY/NSKmlu1vBbxYtr8A2KMj8TXXbRNmRAwvOoZakTQtIiYWHYel8e/VsojYv+gY2sLXMM2su1gIjCzb3zovqxonTDPrLh4FxkoaI6kfcChwYzUr6LZd8m5uauVDrAvx79UJIqJB0snAbUBv4LKImFnNOhR1NI/TzKxI7pKbmSVywjQzS+SEaVYgSZMl3VR0HJbGCbOOSfKgnVkncsIsmKTRkmZJukTSTEm3S9pA0gRJD0t6QtIfJW2SH3+vpJ/lMx5Oy/cvlDQtP8+HJF0vaa6kcwv+ej1C/hvOlnS5pH9IulLSvpL+mv8Ou+fbQ5Iel/S/ksYVHbe1nRNm1zAW+GVE7AysBL4A/Bb4/xHxAeBJ4Oyy4/tFxMSImJLvr81nklwM3ACcBIwHjpK0aWd9iR5ue2AKsGO+fRn4KPB14ExgNjApInYFzgLOKyhO6wB36bqG5yJiRv56OrAdMCQi7svLrgCuLTv+mmafL92c+yQwMyIWA0iaRzbzYVlNorZyz0XEkwCSZgJ3RURIehIYDQwGrpA0luypZn0Li9TazS3MrmFN2etGYEiF499o4fNNzc7VhP9R7CzN/9zLf5M+wA+BeyJiPPAZYEDnhmfV4ITZNb0KrJA0Kd8/HLivleOt6xvMO/OajyowDusAJ8yu60jgAklPABOAcwqOxzrmfODfJT2OW/11y1MjzcwSuYVpZpbICdPMLJETpplZIidMM7NETphmZomcMHswSY2SZkh6StK1kjbswLkul/TF/PWvW1sPOn9Cz17tqGO+pPesMNhSebNjXm9jXd+X9PW2xmjdmxNmz7Y6Iibks0/WAieUv9nepyFFxL9ERGtrQU8G2pwwzYrmhGklDwDb562/ByTdCDwtqbekCyQ9mj856XgAZX4haY6kO4HNSifKn6A0MX+9v6THJP1d0l2SRpMl5jPy1u0kScMlXZfX8aikj+Sf3TR/etNMSb8GVOlLSPqTpOn5Z45r9t6FefldkobnZdtJujX/zAOSdqzGH6Z1T55xYKWW5AHArXnRB4HxEfFcnnRejYgPSeoP/FXS7cCuwDhgJ2Bz4GngsmbnHQ5cAnwsP9fQiFgu6WLg9Yj4SX7c74ALI+JBSaPIFrF6H9kTmh6MiHMk/T/gmISvc3RexwbAo5Kui4hlwEBgWkScIems/Nwnky1QdkJEzJW0B/Ar4OPt+GO0HsAJs2fbQFLpKUkPAJeSdZUfiYjn8vJPAh8oXZ8kmxM9FvgYcFVENAKLJN29nvPvCdxfOldELG8hjn2BnaS3G5AbS9oor+Pz+WdvlrQi4TudKumg/PXIPNZlZA/BKD3l6X+A6/M69gKuLau7f0Id1kM5YfZsqyNiQnlBnjjKn4Yk4JSIuK3ZcZ+qYhy9gD0j4q31xJJM0mSy5PvhiHhT0r20/FSgyOtd2fzPwKwlvoZpldwGnCipL4CkHSQNBO4HDsmvcY4A9l7PZx8GPiZpTP7ZoXn5KmBQ2XG3A6eUdiSVEtj9ZA/iRdIBwCYVYh0MrMiT5Y5kLdySXkCplfxlsq7+a8Bzkr6U1yFJu1Sow3owJ0yr5Ndk1ycfk/QU8F9kPZM/AnPz934LPNT8gxHxCnAcWff377zTJf4zcFBp0Ac4FZiYDyo9zTuj9T8gS7gzybrmL1SI9Vagj6RZwI/JEnbJG8Du+Xf4OO88/ekrwDF5fDOBAxP+TKyH8tOKzMwSuYVpZpbICdPMLJETpplZIidMM7NETphmZomcMM3MEjlhmpkl+j+OWU3EwMbPwwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "disp = ConfusionMatrixDisplay(confusion_matrix=results[0][0], display_labels=['norm','mal'])\n", + "disp.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6Bdbx4ib242Z" + }, + "outputs": [], + "source": [ + "def calc_percision_recall(cm):\n", + " tn, fp = cm[0]\n", + " fn, tp = cm[1] \n", + " recall = tp/(tp+fn)\n", + " percision = tp/(tp+fp)\n", + " return percision, recall" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "CYKznbAu3Eur" + }, + "outputs": [], + "source": [ + "res = []\n", + "for cm in results:\n", + " res.append(calc_percision_recall(cm))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "KNN detection results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "BmP7BWxw4SjG", + "outputId": "9b81d39e-b89b-41fd-a610-6c68c7fbe97c" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "test_num = [\"T'1\",\"T'2\",\"T'3\",\"T'4\",\"T'5\",\"T'6\"]\n", + "per_knn = [res[i][0] for i in np.arange(0,6)]\n", + "rec_knn = [res[i][1] for i in np.arange(0,6)]\n", + "\n", + "plt.plot(test_num, per_knn, '-o')\n", + "plt.plot(test_num, rec_knn, '-o')\n", + "\n", + "plt.legend(['Precision','Recall'], fontsize=12)\n", + "plt.xlabel('Test Set ',fontsize=13)\n", + "plt.ylabel('Percentage',fontsize=13)\n", + "plt.ylim([0,1.1])\n", + "\n", + "\n", + "plt.savefig('knn-detection',bbox_inches='tight')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ANN detection results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "Wd_CVAvg7Q5L", + "outputId": "e9f16f2a-8589-42e1-cdf3-f666b2fb97f1" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light", + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "test_num = [\"T'1\",\"T'2\",\"T'3\",\"T'4\",\"T'5\",\"T'6\"]\n", + "per_knn = [res[i][0] for i in np.arange(12,18)]\n", + "rec_knn = [res[i][1] for i in np.arange(12,18)]\n", + "\n", + "plt.plot(test_num, per_knn, '-o')\n", + "plt.plot(test_num, rec_knn, '-o')\n", + "\n", + "plt.legend(['Precision','Recall'], fontsize=12)\n", + "plt.xlabel('Test Set ',fontsize=13)\n", + "plt.ylabel('Percentage',fontsize=13)\n", + "plt.ylim([0,1.1])\n", + "\n", + "\n", + "plt.savefig('ann-detection',bbox_inches='tight')" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "machine_shape": "hm", + "name": "Attacking_HFT_Systems.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}