{
"cells": [
{
"cell_type": "markdown",
"id": "c1d7ea96-5551-4bfe-885c-cc70bdeee9b9",
"metadata": {},
"source": [
"Книга для обучения GCAEC классификатора с использованием Tensorflow из статьи https://gitlab.com/protsenkovi/efd_nn/"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "c32ace82-fff8-4b9f-8eb9-0945079f3776",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Num GPUs Available: 1\n",
"1 Physical GPUs, 1 Logical GPUs\n",
"2.12.0\n"
]
}
],
"source": [
"import os\n",
"os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' \n",
"import random\n",
"import tensorflow as tf\n",
"# tf.autograph.set_verbosity(1)\n",
"# tf.get_logger().setLevel('INFO')\n",
"import tensorflow_addons as tfa\n",
"from IPython.display import display, clear_output\n",
"import seaborn as sns\n",
"import pandas as pd\n",
"import numpy as np\n",
"import warnings\n",
"\n",
"from tensorflow.keras import regularizers\n",
"from tensorflow.keras.callbacks import LearningRateScheduler\n",
"# os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"-1\"\n",
"from tensorflow.keras.models import Sequential\n",
"from tensorflow.keras.layers import Dense, Dropout, Reshape, SimpleRNN, GRU, LSTM, PReLU, MaxPooling1D, Flatten, AveragePooling1D, \\\n",
" GaussianNoise\n",
"from tensorflow.keras.layers import Conv1D, BatchNormalization\n",
"from tensorflow.keras.optimizers import Adam, Adamax, SGD\n",
"from tensorflow.keras import losses \n",
"from tensorflow.keras import metrics as kmetrics\n",
"from tensorflow.keras.saving import load_model\n",
"from tensorflow.keras.utils import plot_model\n",
"from sklearn.neural_network import MLPClassifier\n",
"\n",
"warnings.filterwarnings('ignore')\n",
"from sklearn.metrics import confusion_matrix\n",
"import matplotlib.pyplot as plt\n",
"from sklearn.model_selection import train_test_split, StratifiedKFold\n",
"from time import time\n",
"\n",
"np.random.seed(42)\n",
"random.seed(42)\n",
"clear_output()\n",
"\n",
"tf.keras.utils.set_random_seed(42)\n",
"tf.config.experimental.enable_op_determinism()\n",
"print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))\n",
"\n",
"gpus = tf.config.list_physical_devices('GPU')\n",
"if gpus:\n",
" try:\n",
" # Currently, memory growth needs to be the same across GPUs\n",
" for gpu in gpus:\n",
" tf.config.experimental.set_memory_growth(gpu, True)\n",
" logical_gpus = tf.config.list_logical_devices('GPU')\n",
" print(len(gpus), \"Physical GPUs,\", len(logical_gpus), \"Logical GPUs\")\n",
" except RuntimeError as e:\n",
" # Memory growth must be set before GPUs have been initialized\n",
" print(e)\n",
" \n",
"print(tf.__version__)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "050e0c0a-629f-41d1-8c9f-9fcf72720bca",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"((116600, 24, 6), (29150, 24, 6), (11054, 24, 6))"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"window = 24\n",
"\n",
"X_train = np.load(f\"../assets/X_train_{window}.npy\")\n",
"y_train = np.load(f\"../assets/y_train_{window}.npy\")\n",
"X_val = np.load(f\"../assets/X_val_{window}.npy\")\n",
"y_val = np.load(f\"../assets/y_val_{window}.npy\")\n",
"X_test = np.load(f\"../assets/X_test_{window}.npy\")\n",
"y_test = np.load(f\"../assets/y_test_{window}.npy\")\n",
"\n",
"shuffled_index = np.arange(X_train.shape[0])\n",
"np.random.shuffle(shuffled_index)\n",
"X_train = X_train[shuffled_index]\n",
"y_train = y_train[shuffled_index]\n",
"\n",
"shuffled_index = np.arange(X_val.shape[0])\n",
"np.random.shuffle(shuffled_index)\n",
"X_val = X_val[shuffled_index]\n",
"y_val = y_val[shuffled_index]\n",
"\n",
"shuffled_index = np.arange(X_test.shape[0])\n",
"np.random.shuffle(shuffled_index)\n",
"X_test = X_test[shuffled_index]\n",
"y_test = y_test[shuffled_index]\n",
"\n",
"X_train.shape, X_val.shape, X_test.shape"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "89fef4d0-bc58-4aa1-847a-26278045e8a5",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"import tensorflow.keras.layers as kl\n",
"import tensorflow.keras as k\n",
"\n",
"def new_pred(predict):\n",
" pred = []\n",
" for i in predict:\n",
" if i < 0.5:\n",
" pred.append(0)\n",
" else:\n",
" pred.append(1)\n",
" return pred\n",
"\n",
"conv_num = -1\n",
"def conv_block_name():\n",
" global conv_num\n",
" conv_num = conv_num + 1\n",
" return 'cb_{}'.format(conv_num)\n",
"\n",
"def conv_block(output_timesteps, output_channels, kernel_size, name, activity_regu=None):\n",
" def f(preceding_layer):\n",
" input_timesteps, input_channels = preceding_layer.get_shape().as_list()[1:]\n",
" \n",
" inputs = k.Input(shape=(input_timesteps, input_channels))\n",
" \n",
" act = kl.Conv1D(output_channels, kernel_size=kernel_size, activation='linear', padding='same', name=name+'_conv_features1', activity_regularizer=activity_regu)(inputs)\n",
" gate = kl.Conv1D(output_channels, kernel_size=kernel_size, activation='sigmoid', padding='same', name=name+'_conv_memory')(inputs)\n",
" gated_act = kl.Multiply()([tfa.layers.InstanceNormalization()(kl.PReLU()(act)), gate]) \n",
" \n",
" a = kl.Permute((2,1))(gated_act)\n",
" b = kl.Dense(output_timesteps, use_bias=False)(a)\n",
" c = kl.Permute((2,1))(b)\n",
" \n",
" m = k.Model(inputs=inputs, outputs=c, name=name)\n",
"# m.summary()\n",
" return m(preceding_layer)\n",
" return f\n",
"\n",
"def model_1D(input_shape):\n",
" inputs = k.Input(shape=input_shape)\n",
" e = conv_block(output_timesteps=window//2, output_channels=128, kernel_size=3, name=conv_block_name())(inputs)\n",
" e = conv_block(output_timesteps=2, output_channels=128, kernel_size=3, name=conv_block_name(), activity_regu=regularizers.l1(1e-3))(e)\n",
" c = kl.Flatten()(e)\n",
" c = Dense(1, activation='sigmoid', name='sigmoid_layer')(c)\n",
" d = conv_block(output_timesteps=window//2, output_channels=128, kernel_size=3, name=conv_block_name())(e)\n",
" d = conv_block(output_timesteps=input_shape[0], output_channels=input_shape[1], kernel_size=3, name=conv_block_name())(d)\n",
" decoder_output = kl.GaussianNoise(1e-2, name='decoder_output')(d)\n",
" \n",
" classifier_model = k.Model(inputs=inputs, outputs=c, name='classifier')\n",
" model = k.Model(inputs=inputs, outputs=[decoder_output, c], name='autoencoder')\n",
" return model, classifier_model\n",
"\n",
"class ProgressCallback(k.callbacks.Callback):\n",
" def on_epoch_end(self, epoch, logs={}):\n",
" results = pd.DataFrame(data=np.array([v for k,v in logs.items()]).reshape(2,4), \n",
" columns=['loss', 'ae_loss', 'classifier_loss', 'accuracy'],\n",
" index=['train','val'])\n",
" results = results.style.set_caption(f\"{epoch}\")\n",
" clear_output(wait=True)\n",
" display(results)\n",
"\n",
"\n",
"def train(X_train, y_train, X_val, y_val, model, epochs=50, lr=1e-2):\n",
" model.compile(loss={\n",
" 'decoder_output':losses.MSE,\n",
" 'sigmoid_layer':losses.BinaryCrossentropy()\n",
" }, \n",
" optimizer=Adam(learning_rate=lr), \n",
" metrics={\n",
" 'sigmoid_layer': kmetrics.BinaryAccuracy(),\n",
" })\n",
" try:\n",
" history = model.fit(X_train, \n",
" [X_train, y_train], \n",
" epochs=epochs,\n",
" batch_size=4096, \n",
" verbose=0,\n",
" validation_data=(X_val, (X_val, y_val)),\n",
" callbacks=[ProgressCallback()])\n",
" except KeyboardInterrupt as e:\n",
" history = []\n",
" return history"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "650486b7-542b-4fc1-a38f-028b74d61e42",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"autoencoder\"\n",
"__________________________________________________________________________________________________\n",
" Layer (type) Output Shape Param # Connected to \n",
"==================================================================================================\n",
" input_1 (InputLayer) [(None, 24, 6)] 0 [] \n",
" \n",
" cb_0 (Functional) (None, 12, 128) 8480 ['input_1[0][0]'] \n",
" \n",
" cb_1 (Functional) (None, 2, 128) 100376 ['cb_0[0][0]'] \n",
" \n",
" cb_2 (Functional) (None, 12, 128) 99096 ['cb_1[0][0]'] \n",
" \n",
" cb_3 (Functional) (None, 24, 6) 4992 ['cb_2[0][0]'] \n",
" \n",
" flatten (Flatten) (None, 256) 0 ['cb_1[0][0]'] \n",
" \n",
" decoder_output (GaussianNoise) (None, 24, 6) 0 ['cb_3[0][0]'] \n",
" \n",
" sigmoid_layer (Dense) (None, 1) 257 ['flatten[0][0]'] \n",
" \n",
"==================================================================================================\n",
"Total params: 213,201\n",
"Trainable params: 213,201\n",
"Non-trainable params: 0\n",
"__________________________________________________________________________________________________\n"
]
}
],
"source": [
"gcaec, classifier = model_1D(input_shape=X_train.shape[1:])\n",
"gcaec.summary()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "d59ed374-3085-4a36-94dd-cc8670d9d6e3",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
" 999\n",
" \n",
" \n",
" | | \n",
" loss | \n",
" ae_loss | \n",
" classifier_loss | \n",
" accuracy | \n",
"
\n",
" \n",
" \n",
" \n",
" | train | \n",
" 0.003677 | \n",
" 0.002197 | \n",
" 0.000171 | \n",
" 1.000000 | \n",
"
\n",
" \n",
" | val | \n",
" 4.735565 | \n",
" 0.002891 | \n",
" 4.731774 | \n",
" 0.619776 | \n",
"
\n",
" \n",
"
\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Training time = 11.216969986756643\n"
]
}
],
"source": [
"start = time()\n",
"\n",
"history = train(X_train=X_train, y_train=y_train, X_val=X_test, y_val=y_test, model=gcaec, lr=1e-4, epochs=1000)\n",
"\n",
"print(\"\\nTraining time = \", (time() - start) / 60)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "8a019554-3ea7-4713-a0ae-e95c31d83822",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"f, [a1,a2] = plt.subplots(2,1)\n",
"a1.plot(history.history['loss'], label='loss')\n",
"a1.plot(history.history['val_loss'], label='val_loss')\n",
"a1.set_yscale('log')\n",
"a1.legend()\n",
"a2.plot(history.history['sigmoid_layer_binary_accuracy'], label='accuracy')\n",
"a2.plot(history.history['val_sigmoid_layer_binary_accuracy'], label='val_accuracy')\n",
"a2.set_yscale('log')\n",
"a2.legend()"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "255de68d-e904-4b25-b9cc-aca0a4c18e35",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"threshold = 0.5"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "6ceac140-7f0f-4061-92cb-c290f7376a36",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3644/3644 [==============================] - 8s 2ms/step\n",
"Train Accuracy: 1.0\n",
"F1: 1.0\n"
]
}
],
"source": [
"pred_train = classifier.predict(X_train) > threshold\n",
"conf_train = confusion_matrix(y_train, pred_train)\n",
"acc_train = (conf_train[0][0] + conf_train[1][1]) / (conf_train[0][0] + conf_train[1][1] + conf_train[0][1] + conf_train[1][0])\n",
"f1_train = (2 * conf_train[1][1]) / (2 * conf_train[1][1] + conf_train[0][1] + conf_train[1][0])\n",
"print('Train Accuracy: ', acc_train)\n",
"print('F1: ', f1_train)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "5d66fa98-4ce0-4084-8271-997bc7af6335",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"911/911 [==============================] - 2s 2ms/step\n",
"Val Accuracy: 0.9884734133790738\n",
"F1: 0.9885464957731115\n"
]
}
],
"source": [
"pred_val = classifier.predict(X_val) > threshold\n",
"conf_val = confusion_matrix(y_val, pred_val)\n",
"acc_val = (conf_val[0][0] + conf_val[1][1]) / (conf_val[0][0] + conf_val[1][1] + conf_val[0][1] + conf_val[1][0])\n",
"f1_val = (2 * conf_val[1][1]) / (2 * conf_val[1][1] + conf_val[0][1] + conf_val[1][0])\n",
"print('Val Accuracy: ', acc_val)\n",
"print('F1: ', f1_val)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "18b0ba57-d083-4c52-b797-af034c726810",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"346/346 [==============================] - 1s 2ms/step\n",
"Test Accuracy: 0.6197756468246789\n",
"F1: 0.45969919012726573\n"
]
}
],
"source": [
"predict_cnn = classifier.predict(X_test) > threshold\n",
"conf_test = confusion_matrix(y_test, predict_cnn)\n",
"acc_test = (conf_test[0][0] + conf_test[1][1]) / (\n",
" conf_test[0][0] + conf_test[1][1] + conf_test[0][1] + conf_test[1][0])\n",
"f1_test = (2 * conf_test[1][1]) / (2 * conf_test[1][1] + conf_test[0][1] + conf_test[1][0])\n",
"print('Test Accuracy: ', acc_test)\n",
"print('F1: ', f1_test)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "b621e097-30f1-4910-894c-cadd370f00ae",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"aa = pd.DataFrame(data=conf_test, columns=['Norm', 'Anom'], index=['Norm', 'Anom'])\n",
"sns.heatmap(aa, annot=True, cmap=sns.blend_palette(['#f5f0f0','#e8a7a8'], as_cmap=True));"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "e164894d-c7f3-45a6-87a7-07a5ac13a9b6",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
]
}
],
"source": [
"model_file_path = f\"../results/gcaec_{window}.h5\"\n",
"classifier.save(model_file_path, save_format=\"h5\")\n",
"pd.DataFrame(\n",
" data=[[model_file_path, acc_train, f1_train, acc_val, f1_val, acc_test, f1_test]], \n",
" columns=['model', 'acc_train', 'f1_train', 'acc_val', 'f1_val', 'acc_test', 'f1_test']\n",
").to_csv(f\"{model_file_path}_stats.csv\", index=False)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f6ed0f38-3ac6-4a8b-855d-5959bfdbcf20",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.6"
}
},
"nbformat": 4,
"nbformat_minor": 5
}