{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "reserved-pursuit",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from library.analysis import testSets, runExerciseForConvGAN\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "sweet-equivalent",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_abalone_17_vs_7_8_9_10\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21932 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 412, 44\n",
      "LR fn, tp: 0, 12\n",
      "LR f1 score: 0.353\n",
      "LR cohens kappa score: 0.324\n",
      "LR average precision score: 0.468\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 439, 17\n",
      "GB fn, tp: 8, 4\n",
      "GB f1 score: 0.242\n",
      "GB cohens kappa score: 0.217\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 423, 33\n",
      "KNN fn, tp: 5, 7\n",
      "KNN f1 score: 0.269\n",
      "KNN cohens kappa score: 0.239\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22692 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 409, 47\n",
      "LR fn, tp: 2, 10\n",
      "LR f1 score: 0.290\n",
      "LR cohens kappa score: 0.258\n",
      "LR average precision score: 0.625\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 442, 14\n",
      "GB fn, tp: 8, 4\n",
      "GB f1 score: 0.267\n",
      "GB cohens kappa score: 0.243\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 413, 43\n",
      "KNN fn, tp: 1, 11\n",
      "KNN f1 score: 0.333\n",
      "KNN cohens kappa score: 0.304\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22436 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 421, 35\n",
      "LR fn, tp: 4, 8\n",
      "LR f1 score: 0.291\n",
      "LR cohens kappa score: 0.261\n",
      "LR average precision score: 0.336\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 444, 12\n",
      "GB fn, tp: 8, 4\n",
      "GB f1 score: 0.286\n",
      "GB cohens kappa score: 0.264\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 428, 28\n",
      "KNN fn, tp: 3, 9\n",
      "KNN f1 score: 0.367\n",
      "KNN cohens kappa score: 0.342\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20264 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 408, 48\n",
      "LR fn, tp: 2, 10\n",
      "LR f1 score: 0.286\n",
      "LR cohens kappa score: 0.254\n",
      "LR average precision score: 0.568\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 444, 12\n",
      "GB fn, tp: 6, 6\n",
      "GB f1 score: 0.400\n",
      "GB cohens kappa score: 0.381\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 418, 38\n",
      "KNN fn, tp: 1, 11\n",
      "KNN f1 score: 0.361\n",
      "KNN cohens kappa score: 0.333\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1776 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27340 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 416, 40\n",
      "LR fn, tp: 3, 7\n",
      "LR f1 score: 0.246\n",
      "LR cohens kappa score: 0.218\n",
      "LR average precision score: 0.295\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 444, 12\n",
      "GB fn, tp: 7, 3\n",
      "GB f1 score: 0.240\n",
      "GB cohens kappa score: 0.220\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 423, 33\n",
      "KNN fn, tp: 5, 5\n",
      "KNN f1 score: 0.208\n",
      "KNN cohens kappa score: 0.180\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25208 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 415, 41\n",
      "LR fn, tp: 1, 11\n",
      "LR f1 score: 0.344\n",
      "LR cohens kappa score: 0.315\n",
      "LR average precision score: 0.676\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 445, 11\n",
      "GB fn, tp: 9, 3\n",
      "GB f1 score: 0.231\n",
      "GB cohens kappa score: 0.209\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 422, 34\n",
      "KNN fn, tp: 3, 9\n",
      "KNN f1 score: 0.327\n",
      "KNN cohens kappa score: 0.299\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22408 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 390, 66\n",
      "LR fn, tp: 0, 12\n",
      "LR f1 score: 0.267\n",
      "LR cohens kappa score: 0.233\n",
      "LR average precision score: 0.492\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 440, 16\n",
      "GB fn, tp: 4, 8\n",
      "GB f1 score: 0.444\n",
      "GB cohens kappa score: 0.425\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 410, 46\n",
      "KNN fn, tp: 2, 10\n",
      "KNN f1 score: 0.294\n",
      "KNN cohens kappa score: 0.263\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25064 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 417, 39\n",
      "LR fn, tp: 3, 9\n",
      "LR f1 score: 0.300\n",
      "LR cohens kappa score: 0.270\n",
      "LR average precision score: 0.251\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 444, 12\n",
      "GB fn, tp: 10, 2\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.130\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 420, 36\n",
      "KNN fn, tp: 5, 7\n",
      "KNN f1 score: 0.255\n",
      "KNN cohens kappa score: 0.223\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23172 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 427, 29\n",
      "LR fn, tp: 3, 9\n",
      "LR f1 score: 0.360\n",
      "LR cohens kappa score: 0.334\n",
      "LR average precision score: 0.519\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 449, 7\n",
      "GB fn, tp: 9, 3\n",
      "GB f1 score: 0.273\n",
      "GB cohens kappa score: 0.255\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 429, 27\n",
      "KNN fn, tp: 4, 8\n",
      "KNN f1 score: 0.340\n",
      "KNN cohens kappa score: 0.314\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1776 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21928 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 412, 44\n",
      "LR fn, tp: 3, 7\n",
      "LR f1 score: 0.230\n",
      "LR cohens kappa score: 0.201\n",
      "LR average precision score: 0.420\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 438, 18\n",
      "GB fn, tp: 6, 4\n",
      "GB f1 score: 0.250\n",
      "GB cohens kappa score: 0.227\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 422, 34\n",
      "KNN fn, tp: 2, 8\n",
      "KNN f1 score: 0.308\n",
      "KNN cohens kappa score: 0.283\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25008 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 416, 40\n",
      "LR fn, tp: 3, 9\n",
      "LR f1 score: 0.295\n",
      "LR cohens kappa score: 0.265\n",
      "LR average precision score: 0.546\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 446, 10\n",
      "GB fn, tp: 10, 2\n",
      "GB f1 score: 0.167\n",
      "GB cohens kappa score: 0.145\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 420, 36\n",
      "KNN fn, tp: 4, 8\n",
      "KNN f1 score: 0.286\n",
      "KNN cohens kappa score: 0.256\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26760 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 417, 39\n",
      "LR fn, tp: 4, 8\n",
      "LR f1 score: 0.271\n",
      "LR cohens kappa score: 0.240\n",
      "LR average precision score: 0.326\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 437, 19\n",
      "GB fn, tp: 9, 3\n",
      "GB f1 score: 0.176\n",
      "GB cohens kappa score: 0.148\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 416, 40\n",
      "KNN fn, tp: 3, 9\n",
      "KNN f1 score: 0.295\n",
      "KNN cohens kappa score: 0.265\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27644 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 419, 37\n",
      "LR fn, tp: 1, 11\n",
      "LR f1 score: 0.367\n",
      "LR cohens kappa score: 0.340\n",
      "LR average precision score: 0.534\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 446, 10\n",
      "GB fn, tp: 5, 7\n",
      "GB f1 score: 0.483\n",
      "GB cohens kappa score: 0.467\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 421, 35\n",
      "KNN fn, tp: 4, 8\n",
      "KNN f1 score: 0.291\n",
      "KNN cohens kappa score: 0.261\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26664 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 412, 44\n",
      "LR fn, tp: 3, 9\n",
      "LR f1 score: 0.277\n",
      "LR cohens kappa score: 0.245\n",
      "LR average precision score: 0.348\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 447, 9\n",
      "GB fn, tp: 8, 4\n",
      "GB f1 score: 0.320\n",
      "GB cohens kappa score: 0.301\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 427, 29\n",
      "KNN fn, tp: 6, 6\n",
      "KNN f1 score: 0.255\n",
      "KNN cohens kappa score: 0.226\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1776 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20584 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 406, 50\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 0.286\n",
      "LR cohens kappa score: 0.258\n",
      "LR average precision score: 0.602\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 443, 13\n",
      "GB fn, tp: 4, 6\n",
      "GB f1 score: 0.414\n",
      "GB cohens kappa score: 0.397\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 416, 40\n",
      "KNN fn, tp: 2, 8\n",
      "KNN f1 score: 0.276\n",
      "KNN cohens kappa score: 0.249\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24408 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 408, 48\n",
      "LR fn, tp: 1, 11\n",
      "LR f1 score: 0.310\n",
      "LR cohens kappa score: 0.279\n",
      "LR average precision score: 0.627\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 438, 18\n",
      "GB fn, tp: 5, 7\n",
      "GB f1 score: 0.378\n",
      "GB cohens kappa score: 0.356\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 415, 41\n",
      "KNN fn, tp: 1, 11\n",
      "KNN f1 score: 0.344\n",
      "KNN cohens kappa score: 0.315\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24304 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 409, 47\n",
      "LR fn, tp: 1, 11\n",
      "LR f1 score: 0.314\n",
      "LR cohens kappa score: 0.284\n",
      "LR average precision score: 0.611\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 437, 19\n",
      "GB fn, tp: 7, 5\n",
      "GB f1 score: 0.278\n",
      "GB cohens kappa score: 0.252\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 413, 43\n",
      "KNN fn, tp: 2, 10\n",
      "KNN f1 score: 0.308\n",
      "KNN cohens kappa score: 0.277\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23292 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 412, 44\n",
      "LR fn, tp: 2, 10\n",
      "LR f1 score: 0.303\n",
      "LR cohens kappa score: 0.273\n",
      "LR average precision score: 0.421\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 446, 10\n",
      "GB fn, tp: 8, 4\n",
      "GB f1 score: 0.308\n",
      "GB cohens kappa score: 0.288\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 423, 33\n",
      "KNN fn, tp: 6, 6\n",
      "KNN f1 score: 0.235\n",
      "KNN cohens kappa score: 0.204\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22384 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 415, 41\n",
      "LR fn, tp: 1, 11\n",
      "LR f1 score: 0.344\n",
      "LR cohens kappa score: 0.315\n",
      "LR average precision score: 0.465\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 444, 12\n",
      "GB fn, tp: 10, 2\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.130\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 421, 35\n",
      "KNN fn, tp: 5, 7\n",
      "KNN f1 score: 0.259\n",
      "KNN cohens kappa score: 0.228\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1776 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20536 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 418, 38\n",
      "LR fn, tp: 3, 7\n",
      "LR f1 score: 0.255\n",
      "LR cohens kappa score: 0.227\n",
      "LR average precision score: 0.352\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 445, 11\n",
      "GB fn, tp: 6, 4\n",
      "GB f1 score: 0.320\n",
      "GB cohens kappa score: 0.302\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 424, 32\n",
      "KNN fn, tp: 4, 6\n",
      "KNN f1 score: 0.250\n",
      "KNN cohens kappa score: 0.224\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25672 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 400, 56\n",
      "LR fn, tp: 3, 9\n",
      "LR f1 score: 0.234\n",
      "LR cohens kappa score: 0.199\n",
      "LR average precision score: 0.380\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 443, 13\n",
      "GB fn, tp: 8, 4\n",
      "GB f1 score: 0.276\n",
      "GB cohens kappa score: 0.253\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 414, 42\n",
      "KNN fn, tp: 6, 6\n",
      "KNN f1 score: 0.200\n",
      "KNN cohens kappa score: 0.166\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20988 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 417, 39\n",
      "LR fn, tp: 3, 9\n",
      "LR f1 score: 0.300\n",
      "LR cohens kappa score: 0.270\n",
      "LR average precision score: 0.345\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 443, 13\n",
      "GB fn, tp: 8, 4\n",
      "GB f1 score: 0.276\n",
      "GB cohens kappa score: 0.253\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 414, 42\n",
      "KNN fn, tp: 3, 9\n",
      "KNN f1 score: 0.286\n",
      "KNN cohens kappa score: 0.255\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24080 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 417, 39\n",
      "LR fn, tp: 2, 10\n",
      "LR f1 score: 0.328\n",
      "LR cohens kappa score: 0.299\n",
      "LR average precision score: 0.360\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 444, 12\n",
      "GB fn, tp: 7, 5\n",
      "GB f1 score: 0.345\n",
      "GB cohens kappa score: 0.325\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 414, 42\n",
      "KNN fn, tp: 1, 11\n",
      "KNN f1 score: 0.338\n",
      "KNN cohens kappa score: 0.310\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1778 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26692 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 403, 53\n",
      "LR fn, tp: 1, 11\n",
      "LR f1 score: 0.289\n",
      "LR cohens kappa score: 0.257\n",
      "LR average precision score: 0.714\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 443, 13\n",
      "GB fn, tp: 7, 5\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.312\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 429, 27\n",
      "KNN fn, tp: 4, 8\n",
      "KNN f1 score: 0.340\n",
      "KNN cohens kappa score: 0.314\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1776 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23956 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 412, 44\n",
      "LR fn, tp: 1, 9\n",
      "LR f1 score: 0.286\n",
      "LR cohens kappa score: 0.259\n",
      "LR average precision score: 0.401\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 441, 15\n",
      "GB fn, tp: 4, 6\n",
      "GB f1 score: 0.387\n",
      "GB cohens kappa score: 0.369\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 417, 39\n",
      "KNN fn, tp: 3, 7\n",
      "KNN f1 score: 0.250\n",
      "KNN cohens kappa score: 0.223\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 427, 66\n",
      "LR fn, tp: 4, 12\n",
      "LR f1 score: 0.367\n",
      "LR cohens kappa score: 0.340\n",
      "LR average precision score: 0.714\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 412.32, 43.68\n",
      "LR fn, tp: 2.0, 9.6\n",
      "LR f1 score: 0.297\n",
      "LR cohens kappa score: 0.267\n",
      "LR average precision score: 0.467\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 390, 29\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.230\n",
      "LR cohens kappa score: 0.199\n",
      "LR average precision score: 0.251\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 449, 19\n",
      "GB fn, tp: 10, 8\n",
      "GB f1 score: 0.483\n",
      "GB cohens kappa score: 0.467\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 442.88, 13.12\n",
      "GB fn, tp: 7.24, 4.36\n",
      "GB f1 score: 0.296\n",
      "GB cohens kappa score: 0.275\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 437, 7\n",
      "GB fn, tp: 4, 2\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.130\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 429, 46\n",
      "KNN fn, tp: 6, 11\n",
      "KNN f1 score: 0.367\n",
      "KNN cohens kappa score: 0.342\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 419.68, 36.32\n",
      "KNN fn, tp: 3.4, 8.2\n",
      "KNN f1 score: 0.291\n",
      "KNN cohens kappa score: 0.262\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 410, 27\n",
      "KNN fn, tp: 1, 5\n",
      "KNN f1 score: 0.200\n",
      "KNN cohens kappa score: 0.166\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_abalone9-18\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22480 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 123, 15\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.545\n",
      "LR cohens kappa score: 0.501\n",
      "LR average precision score: 0.878\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 132, 6\n",
      "GB fn, tp: 5, 4\n",
      "GB f1 score: 0.421\n",
      "GB cohens kappa score: 0.381\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 121, 17\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.424\n",
      "KNN cohens kappa score: 0.368\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21456 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 130, 8\n",
      "LR fn, tp: 3, 6\n",
      "LR f1 score: 0.522\n",
      "LR cohens kappa score: 0.483\n",
      "LR average precision score: 0.566\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 135, 3\n",
      "GB fn, tp: 7, 2\n",
      "GB f1 score: 0.286\n",
      "GB cohens kappa score: 0.253\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 114, 24\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.263\n",
      "KNN cohens kappa score: 0.187\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25144 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 125, 13\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.581\n",
      "LR cohens kappa score: 0.541\n",
      "LR average precision score: 0.801\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 133, 5\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.353\n",
      "GB cohens kappa score: 0.313\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 128, 10\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.480\n",
      "KNN cohens kappa score: 0.436\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24604 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 131, 7\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.609\n",
      "LR cohens kappa score: 0.577\n",
      "LR average precision score: 0.627\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 134, 4\n",
      "GB fn, tp: 5, 4\n",
      "GB f1 score: 0.471\n",
      "GB cohens kappa score: 0.438\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 125, 13\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.483\n",
      "KNN cohens kappa score: 0.435\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 516 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22808 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 129, 8\n",
      "LR fn, tp: 2, 4\n",
      "LR f1 score: 0.444\n",
      "LR cohens kappa score: 0.412\n",
      "LR average precision score: 0.479\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 133, 4\n",
      "GB fn, tp: 4, 2\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.304\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 123, 14\n",
      "KNN fn, tp: 2, 4\n",
      "KNN f1 score: 0.333\n",
      "KNN cohens kappa score: 0.289\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25432 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 121, 17\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.424\n",
      "LR cohens kappa score: 0.368\n",
      "LR average precision score: 0.603\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 133, 5\n",
      "GB fn, tp: 5, 4\n",
      "GB f1 score: 0.444\n",
      "GB cohens kappa score: 0.408\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 125, 13\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.429\n",
      "KNN cohens kappa score: 0.377\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27208 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 131, 7\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.667\n",
      "LR cohens kappa score: 0.639\n",
      "LR average precision score: 0.781\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 130, 8\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.300\n",
      "GB cohens kappa score: 0.249\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 128, 10\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.480\n",
      "KNN cohens kappa score: 0.436\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26460 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 129, 9\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.560\n",
      "LR cohens kappa score: 0.523\n",
      "LR average precision score: 0.673\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 129, 9\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.286\n",
      "GB cohens kappa score: 0.232\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 115, 23\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.270\n",
      "KNN cohens kappa score: 0.196\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27300 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 124, 14\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.562\n",
      "LR cohens kappa score: 0.520\n",
      "LR average precision score: 0.722\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 132, 6\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.290\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 121, 17\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.323\n",
      "KNN cohens kappa score: 0.258\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 516 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23568 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 123, 14\n",
      "LR fn, tp: 1, 5\n",
      "LR f1 score: 0.400\n",
      "LR cohens kappa score: 0.359\n",
      "LR average precision score: 0.570\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 128, 9\n",
      "GB fn, tp: 2, 4\n",
      "GB f1 score: 0.421\n",
      "GB cohens kappa score: 0.386\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 123, 14\n",
      "KNN fn, tp: 2, 4\n",
      "KNN f1 score: 0.333\n",
      "KNN cohens kappa score: 0.289\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23168 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 132, 6\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.500\n",
      "LR cohens kappa score: 0.464\n",
      "LR average precision score: 0.520\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 133, 5\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.133\n",
      "GB cohens kappa score: 0.089\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 118, 20\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.294\n",
      "KNN cohens kappa score: 0.224\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20128 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 132, 6\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.750\n",
      "LR cohens kappa score: 0.729\n",
      "LR average precision score: 0.906\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 134, 4\n",
      "GB fn, tp: 2, 7\n",
      "GB f1 score: 0.700\n",
      "GB cohens kappa score: 0.678\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 117, 21\n",
      "KNN fn, tp: 1, 8\n",
      "KNN f1 score: 0.421\n",
      "KNN cohens kappa score: 0.361\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25192 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 132, 6\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.500\n",
      "LR cohens kappa score: 0.464\n",
      "LR average precision score: 0.638\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 131, 7\n",
      "GB fn, tp: 7, 2\n",
      "GB f1 score: 0.222\n",
      "GB cohens kappa score: 0.171\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 130, 8\n",
      "KNN fn, tp: 5, 4\n",
      "KNN f1 score: 0.381\n",
      "KNN cohens kappa score: 0.334\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26152 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 118, 20\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.432\n",
      "LR cohens kappa score: 0.374\n",
      "LR average precision score: 0.646\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 131, 7\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.316\n",
      "GB cohens kappa score: 0.269\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 120, 18\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.312\n",
      "KNN cohens kappa score: 0.246\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 516 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26476 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 126, 11\n",
      "LR fn, tp: 2, 4\n",
      "LR f1 score: 0.381\n",
      "LR cohens kappa score: 0.341\n",
      "LR average precision score: 0.535\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 130, 7\n",
      "GB fn, tp: 3, 3\n",
      "GB f1 score: 0.375\n",
      "GB cohens kappa score: 0.340\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 121, 16\n",
      "KNN fn, tp: 2, 4\n",
      "KNN f1 score: 0.308\n",
      "KNN cohens kappa score: 0.260\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22872 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 127, 11\n",
      "LR fn, tp: 3, 6\n",
      "LR f1 score: 0.462\n",
      "LR cohens kappa score: 0.415\n",
      "LR average precision score: 0.554\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 136, 2\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.429\n",
      "GB cohens kappa score: 0.402\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 124, 14\n",
      "KNN fn, tp: 5, 4\n",
      "KNN f1 score: 0.296\n",
      "KNN cohens kappa score: 0.234\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23424 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 124, 14\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.467\n",
      "LR cohens kappa score: 0.417\n",
      "LR average precision score: 0.718\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 128, 10\n",
      "GB fn, tp: 4, 5\n",
      "GB f1 score: 0.417\n",
      "GB cohens kappa score: 0.368\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 118, 20\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.389\n",
      "KNN cohens kappa score: 0.327\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23172 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 127, 11\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.571\n",
      "LR cohens kappa score: 0.533\n",
      "LR average precision score: 0.655\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 136, 2\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.429\n",
      "GB cohens kappa score: 0.402\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 125, 13\n",
      "KNN fn, tp: 5, 4\n",
      "KNN f1 score: 0.308\n",
      "KNN cohens kappa score: 0.247\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25768 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 123, 15\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.545\n",
      "LR cohens kappa score: 0.501\n",
      "LR average precision score: 0.906\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 134, 4\n",
      "GB fn, tp: 5, 4\n",
      "GB f1 score: 0.471\n",
      "GB cohens kappa score: 0.438\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 117, 21\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.378\n",
      "KNN cohens kappa score: 0.315\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 516 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23436 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 131, 6\n",
      "LR fn, tp: 1, 5\n",
      "LR f1 score: 0.588\n",
      "LR cohens kappa score: 0.565\n",
      "LR average precision score: 0.519\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 134, 3\n",
      "GB fn, tp: 4, 2\n",
      "GB f1 score: 0.364\n",
      "GB cohens kappa score: 0.338\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 124, 13\n",
      "KNN fn, tp: 1, 5\n",
      "KNN f1 score: 0.417\n",
      "KNN cohens kappa score: 0.377\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25340 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 119, 19\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.400\n",
      "LR cohens kappa score: 0.340\n",
      "LR average precision score: 0.683\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 131, 7\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.118\n",
      "GB cohens kappa score: 0.064\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 114, 24\n",
      "KNN fn, tp: 6, 3\n",
      "KNN f1 score: 0.167\n",
      "KNN cohens kappa score: 0.082\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26124 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 125, 13\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.533\n",
      "LR cohens kappa score: 0.490\n",
      "LR average precision score: 0.678\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 133, 5\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.353\n",
      "GB cohens kappa score: 0.313\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 111, 27\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.244\n",
      "KNN cohens kappa score: 0.164\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27224 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 129, 9\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.435\n",
      "LR cohens kappa score: 0.389\n",
      "LR average precision score: 0.517\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 132, 6\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.290\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 123, 15\n",
      "KNN fn, tp: 5, 4\n",
      "KNN f1 score: 0.286\n",
      "KNN cohens kappa score: 0.221\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 518 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27176 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 130, 8\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.640\n",
      "LR cohens kappa score: 0.609\n",
      "LR average precision score: 0.929\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 131, 7\n",
      "GB fn, tp: 5, 4\n",
      "GB f1 score: 0.400\n",
      "GB cohens kappa score: 0.357\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 127, 11\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.462\n",
      "KNN cohens kappa score: 0.415\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 516 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26060 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 128, 9\n",
      "LR fn, tp: 1, 5\n",
      "LR f1 score: 0.500\n",
      "LR cohens kappa score: 0.469\n",
      "LR average precision score: 0.798\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 133, 4\n",
      "GB fn, tp: 4, 2\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.304\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 129, 8\n",
      "KNN fn, tp: 1, 5\n",
      "KNN f1 score: 0.526\n",
      "KNN cohens kappa score: 0.497\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 132, 20\n",
      "LR fn, tp: 4, 9\n",
      "LR f1 score: 0.750\n",
      "LR cohens kappa score: 0.729\n",
      "LR average precision score: 0.929\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 126.76, 11.04\n",
      "LR fn, tp: 1.6, 6.8\n",
      "LR f1 score: 0.521\n",
      "LR cohens kappa score: 0.481\n",
      "LR average precision score: 0.676\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 118, 6\n",
      "LR fn, tp: 0, 4\n",
      "LR f1 score: 0.381\n",
      "LR cohens kappa score: 0.340\n",
      "LR average precision score: 0.479\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 136, 10\n",
      "GB fn, tp: 8, 7\n",
      "GB f1 score: 0.700\n",
      "GB cohens kappa score: 0.678\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 132.24, 5.56\n",
      "GB fn, tp: 5.28, 3.12\n",
      "GB f1 score: 0.362\n",
      "GB cohens kappa score: 0.323\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 128, 2\n",
      "GB fn, tp: 2, 1\n",
      "GB f1 score: 0.118\n",
      "GB cohens kappa score: 0.064\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 130, 27\n",
      "KNN fn, tp: 6, 8\n",
      "KNN f1 score: 0.526\n",
      "KNN cohens kappa score: 0.497\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 121.64, 16.16\n",
      "KNN fn, tp: 3.16, 5.24\n",
      "KNN f1 score: 0.360\n",
      "KNN cohens kappa score: 0.303\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 111, 8\n",
      "KNN fn, tp: 1, 3\n",
      "KNN f1 score: 0.167\n",
      "KNN cohens kappa score: 0.082\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_car_good\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 31580 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 178, 154\n",
      "LR fn, tp: 6, 8\n",
      "LR f1 score: 0.091\n",
      "LR cohens kappa score: 0.018\n",
      "LR average precision score: 0.059\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 4, 10\n",
      "GB f1 score: 0.769\n",
      "GB cohens kappa score: 0.760\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 299, 33\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.459\n",
      "KNN cohens kappa score: 0.423\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 35420 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 177, 155\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.122\n",
      "LR cohens kappa score: 0.051\n",
      "LR average precision score: 0.079\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 5, 9\n",
      "GB f1 score: 0.720\n",
      "GB cohens kappa score: 0.710\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 315, 17\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.622\n",
      "KNN cohens kappa score: 0.600\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32436 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 177, 155\n",
      "LR fn, tp: 6, 8\n",
      "LR f1 score: 0.090\n",
      "LR cohens kappa score: 0.017\n",
      "LR average precision score: 0.060\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 1\n",
      "GB fn, tp: 6, 8\n",
      "GB f1 score: 0.696\n",
      "GB cohens kappa score: 0.686\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 305, 27\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.509\n",
      "KNN cohens kappa score: 0.478\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 29696 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 197, 135\n",
      "LR fn, tp: 4, 10\n",
      "LR f1 score: 0.126\n",
      "LR cohens kappa score: 0.056\n",
      "LR average precision score: 0.061\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 329, 3\n",
      "GB fn, tp: 6, 8\n",
      "GB f1 score: 0.640\n",
      "GB cohens kappa score: 0.627\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 310, 22\n",
      "KNN fn, tp: 2, 12\n",
      "KNN f1 score: 0.500\n",
      "KNN cohens kappa score: 0.470\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33572 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 177, 154\n",
      "LR fn, tp: 4, 9\n",
      "LR f1 score: 0.102\n",
      "LR cohens kappa score: 0.035\n",
      "LR average precision score: 0.056\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 328, 3\n",
      "GB fn, tp: 3, 10\n",
      "GB f1 score: 0.769\n",
      "GB cohens kappa score: 0.760\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 320, 11\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.667\n",
      "KNN cohens kappa score: 0.650\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33972 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 168, 164\n",
      "LR fn, tp: 4, 10\n",
      "LR f1 score: 0.106\n",
      "LR cohens kappa score: 0.034\n",
      "LR average precision score: 0.068\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 6, 8\n",
      "GB f1 score: 0.667\n",
      "GB cohens kappa score: 0.655\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 322, 10\n",
      "KNN fn, tp: 1, 13\n",
      "KNN f1 score: 0.703\n",
      "KNN cohens kappa score: 0.687\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33180 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 180, 152\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.124\n",
      "LR cohens kappa score: 0.054\n",
      "LR average precision score: 0.068\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 1\n",
      "GB fn, tp: 1, 13\n",
      "GB f1 score: 0.929\n",
      "GB cohens kappa score: 0.926\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 15\n",
      "KNN fn, tp: 2, 12\n",
      "KNN f1 score: 0.585\n",
      "KNN cohens kappa score: 0.562\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 35436 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 198, 134\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.138\n",
      "LR cohens kappa score: 0.070\n",
      "LR average precision score: 0.070\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 332, 0\n",
      "GB fn, tp: 4, 10\n",
      "GB f1 score: 0.833\n",
      "GB cohens kappa score: 0.828\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 315, 17\n",
      "KNN fn, tp: 2, 12\n",
      "KNN f1 score: 0.558\n",
      "KNN cohens kappa score: 0.533\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32220 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 191, 141\n",
      "LR fn, tp: 9, 5\n",
      "LR f1 score: 0.062\n",
      "LR cohens kappa score: -0.012\n",
      "LR average precision score: 0.051\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 1\n",
      "GB fn, tp: 3, 11\n",
      "GB f1 score: 0.846\n",
      "GB cohens kappa score: 0.840\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 303, 29\n",
      "KNN fn, tp: 1, 13\n",
      "KNN f1 score: 0.464\n",
      "KNN cohens kappa score: 0.430\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34096 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 187, 144\n",
      "LR fn, tp: 5, 8\n",
      "LR f1 score: 0.097\n",
      "LR cohens kappa score: 0.029\n",
      "LR average precision score: 0.072\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 328, 3\n",
      "GB fn, tp: 4, 9\n",
      "GB f1 score: 0.720\n",
      "GB cohens kappa score: 0.709\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 305, 26\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.500\n",
      "KNN cohens kappa score: 0.470\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33904 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 169, 163\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.117\n",
      "LR cohens kappa score: 0.046\n",
      "LR average precision score: 0.071\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 1\n",
      "GB fn, tp: 3, 11\n",
      "GB f1 score: 0.846\n",
      "GB cohens kappa score: 0.840\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 311, 21\n",
      "KNN fn, tp: 1, 13\n",
      "KNN f1 score: 0.542\n",
      "KNN cohens kappa score: 0.514\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33392 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 195, 137\n",
      "LR fn, tp: 5, 9\n",
      "LR f1 score: 0.112\n",
      "LR cohens kappa score: 0.042\n",
      "LR average precision score: 0.067\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 3, 11\n",
      "GB f1 score: 0.815\n",
      "GB cohens kappa score: 0.807\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 310, 22\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.560\n",
      "KNN cohens kappa score: 0.533\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34652 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 181, 151\n",
      "LR fn, tp: 6, 8\n",
      "LR f1 score: 0.092\n",
      "LR cohens kappa score: 0.020\n",
      "LR average precision score: 0.056\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 1\n",
      "GB fn, tp: 6, 8\n",
      "GB f1 score: 0.696\n",
      "GB cohens kappa score: 0.686\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 323, 9\n",
      "KNN fn, tp: 1, 13\n",
      "KNN f1 score: 0.722\n",
      "KNN cohens kappa score: 0.708\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33208 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 174, 158\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.120\n",
      "LR cohens kappa score: 0.049\n",
      "LR average precision score: 0.084\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 332, 0\n",
      "GB fn, tp: 6, 8\n",
      "GB f1 score: 0.727\n",
      "GB cohens kappa score: 0.719\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 315, 17\n",
      "KNN fn, tp: 1, 13\n",
      "KNN f1 score: 0.591\n",
      "KNN cohens kappa score: 0.567\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34236 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 174, 157\n",
      "LR fn, tp: 6, 7\n",
      "LR f1 score: 0.079\n",
      "LR cohens kappa score: 0.010\n",
      "LR average precision score: 0.054\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 327, 4\n",
      "GB fn, tp: 4, 9\n",
      "GB f1 score: 0.692\n",
      "GB cohens kappa score: 0.680\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 314, 17\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.605\n",
      "KNN cohens kappa score: 0.583\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33468 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 176, 156\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.122\n",
      "LR cohens kappa score: 0.051\n",
      "LR average precision score: 0.067\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 1, 13\n",
      "GB f1 score: 0.897\n",
      "GB cohens kappa score: 0.892\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 321, 11\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.718\n",
      "KNN cohens kappa score: 0.703\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33264 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 181, 151\n",
      "LR fn, tp: 6, 8\n",
      "LR f1 score: 0.092\n",
      "LR cohens kappa score: 0.020\n",
      "LR average precision score: 0.062\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 8, 6\n",
      "GB f1 score: 0.545\n",
      "GB cohens kappa score: 0.532\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 298, 34\n",
      "KNN fn, tp: 1, 13\n",
      "KNN f1 score: 0.426\n",
      "KNN cohens kappa score: 0.388\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32776 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 174, 158\n",
      "LR fn, tp: 4, 10\n",
      "LR f1 score: 0.110\n",
      "LR cohens kappa score: 0.038\n",
      "LR average precision score: 0.069\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 1\n",
      "GB fn, tp: 6, 8\n",
      "GB f1 score: 0.696\n",
      "GB cohens kappa score: 0.686\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 311, 21\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.571\n",
      "KNN cohens kappa score: 0.545\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32720 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 189, 143\n",
      "LR fn, tp: 7, 7\n",
      "LR f1 score: 0.085\n",
      "LR cohens kappa score: 0.012\n",
      "LR average precision score: 0.056\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 5, 9\n",
      "GB f1 score: 0.720\n",
      "GB cohens kappa score: 0.710\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 309, 23\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.549\n",
      "KNN cohens kappa score: 0.521\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 35192 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 173, 158\n",
      "LR fn, tp: 2, 11\n",
      "LR f1 score: 0.121\n",
      "LR cohens kappa score: 0.055\n",
      "LR average precision score: 0.080\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 328, 3\n",
      "GB fn, tp: 6, 7\n",
      "GB f1 score: 0.609\n",
      "GB cohens kappa score: 0.595\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 310, 21\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.522\n",
      "KNN cohens kappa score: 0.494\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32284 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 189, 143\n",
      "LR fn, tp: 8, 6\n",
      "LR f1 score: 0.074\n",
      "LR cohens kappa score: -0.000\n",
      "LR average precision score: 0.052\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 329, 3\n",
      "GB fn, tp: 10, 4\n",
      "GB f1 score: 0.381\n",
      "GB cohens kappa score: 0.364\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 309, 23\n",
      "KNN fn, tp: 2, 12\n",
      "KNN f1 score: 0.490\n",
      "KNN cohens kappa score: 0.458\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33820 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 189, 143\n",
      "LR fn, tp: 4, 10\n",
      "LR f1 score: 0.120\n",
      "LR cohens kappa score: 0.049\n",
      "LR average precision score: 0.069\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 7, 7\n",
      "GB f1 score: 0.609\n",
      "GB cohens kappa score: 0.596\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 15\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.651\n",
      "KNN cohens kappa score: 0.631\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32864 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 173, 159\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.120\n",
      "LR cohens kappa score: 0.048\n",
      "LR average precision score: 0.070\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 328, 4\n",
      "GB fn, tp: 1, 13\n",
      "GB f1 score: 0.839\n",
      "GB cohens kappa score: 0.831\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 307, 25\n",
      "KNN fn, tp: 0, 14\n",
      "KNN f1 score: 0.528\n",
      "KNN cohens kappa score: 0.498\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32996 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 166, 166\n",
      "LR fn, tp: 3, 11\n",
      "LR f1 score: 0.115\n",
      "LR cohens kappa score: 0.043\n",
      "LR average precision score: 0.066\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 2\n",
      "GB fn, tp: 4, 10\n",
      "GB f1 score: 0.769\n",
      "GB cohens kappa score: 0.760\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 308, 24\n",
      "KNN fn, tp: 1, 13\n",
      "KNN f1 score: 0.510\n",
      "KNN cohens kappa score: 0.479\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1272 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33176 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 180, 151\n",
      "LR fn, tp: 4, 9\n",
      "LR f1 score: 0.104\n",
      "LR cohens kappa score: 0.037\n",
      "LR average precision score: 0.057\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 0\n",
      "GB fn, tp: 4, 9\n",
      "GB f1 score: 0.818\n",
      "GB cohens kappa score: 0.812\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 308, 23\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.531\n",
      "KNN cohens kappa score: 0.503\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 198, 166\n",
      "LR fn, tp: 9, 11\n",
      "LR f1 score: 0.138\n",
      "LR cohens kappa score: 0.070\n",
      "LR average precision score: 0.084\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 180.52, 151.28\n",
      "LR fn, tp: 4.56, 9.24\n",
      "LR f1 score: 0.106\n",
      "LR cohens kappa score: 0.035\n",
      "LR average precision score: 0.065\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 166, 134\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.062\n",
      "LR cohens kappa score: -0.012\n",
      "LR average precision score: 0.051\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 332, 4\n",
      "GB fn, tp: 10, 13\n",
      "GB f1 score: 0.929\n",
      "GB cohens kappa score: 0.926\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 329.92, 1.88\n",
      "GB fn, tp: 4.64, 9.16\n",
      "GB f1 score: 0.730\n",
      "GB cohens kappa score: 0.720\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 327, 0\n",
      "GB fn, tp: 1, 4\n",
      "GB f1 score: 0.381\n",
      "GB cohens kappa score: 0.364\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 323, 34\n",
      "KNN fn, tp: 2, 14\n",
      "KNN f1 score: 0.722\n",
      "KNN cohens kappa score: 0.708\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 311.28, 20.52\n",
      "KNN fn, tp: 0.68, 13.12\n",
      "KNN f1 score: 0.563\n",
      "KNN cohens kappa score: 0.537\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 298, 9\n",
      "KNN fn, tp: 0, 12\n",
      "KNN f1 score: 0.426\n",
      "KNN cohens kappa score: 0.388\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_car-vgood\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 31272 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 287, 46\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.361\n",
      "LR cohens kappa score: 0.319\n",
      "LR average precision score: 0.359\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 2\n",
      "GB fn, tp: 1, 12\n",
      "GB f1 score: 0.889\n",
      "GB cohens kappa score: 0.884\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 321, 12\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.684\n",
      "KNN cohens kappa score: 0.668\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33532 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 294, 39\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.400\n",
      "LR cohens kappa score: 0.362\n",
      "LR average precision score: 0.303\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 332, 1\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.963\n",
      "GB cohens kappa score: 0.961\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 16\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.585\n",
      "KNN cohens kappa score: 0.563\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34100 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 284, 49\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.347\n",
      "LR cohens kappa score: 0.303\n",
      "LR average precision score: 0.377\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 1, 12\n",
      "GB f1 score: 0.960\n",
      "GB cohens kappa score: 0.959\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 324, 9\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.743\n",
      "KNN cohens kappa score: 0.730\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33280 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 292, 41\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.388\n",
      "LR cohens kappa score: 0.349\n",
      "LR average precision score: 0.367\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 323, 10\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.722\n",
      "KNN cohens kappa score: 0.708\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1280 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33868 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 299, 32\n",
      "LR fn, tp: 2, 11\n",
      "LR f1 score: 0.393\n",
      "LR cohens kappa score: 0.355\n",
      "LR average precision score: 0.446\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 329, 2\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.929\n",
      "GB cohens kappa score: 0.926\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 326, 5\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.800\n",
      "KNN cohens kappa score: 0.791\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32780 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 299, 34\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.433\n",
      "LR cohens kappa score: 0.398\n",
      "LR average precision score: 0.286\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 332, 1\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.963\n",
      "GB cohens kappa score: 0.961\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 323, 10\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.722\n",
      "KNN cohens kappa score: 0.708\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32016 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 275, 58\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.310\n",
      "LR cohens kappa score: 0.263\n",
      "LR average precision score: 0.364\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 329, 4\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.867\n",
      "GB cohens kappa score: 0.861\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 314, 19\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.578\n",
      "KNN cohens kappa score: 0.554\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 35056 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 296, 37\n",
      "LR fn, tp: 2, 11\n",
      "LR f1 score: 0.361\n",
      "LR cohens kappa score: 0.320\n",
      "LR average precision score: 0.344\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 327, 6\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.774\n",
      "KNN cohens kappa score: 0.764\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32056 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 295, 38\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.406\n",
      "LR cohens kappa score: 0.368\n",
      "LR average precision score: 0.324\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 2, 11\n",
      "GB f1 score: 0.917\n",
      "GB cohens kappa score: 0.914\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 320, 13\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.667\n",
      "KNN cohens kappa score: 0.649\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1280 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 29184 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 286, 45\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.366\n",
      "LR cohens kappa score: 0.324\n",
      "LR average precision score: 0.478\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 321, 10\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.722\n",
      "KNN cohens kappa score: 0.708\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34352 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 294, 39\n",
      "LR fn, tp: 1, 12\n",
      "LR f1 score: 0.375\n",
      "LR cohens kappa score: 0.335\n",
      "LR average precision score: 0.296\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 332, 1\n",
      "GB fn, tp: 2, 11\n",
      "GB f1 score: 0.880\n",
      "GB cohens kappa score: 0.876\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 325, 8\n",
      "KNN fn, tp: 3, 10\n",
      "KNN f1 score: 0.645\n",
      "KNN cohens kappa score: 0.629\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34100 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 298, 35\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.426\n",
      "LR cohens kappa score: 0.390\n",
      "LR average precision score: 0.431\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 319, 14\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.650\n",
      "KNN cohens kappa score: 0.631\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 30340 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 276, 57\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.313\n",
      "LR cohens kappa score: 0.267\n",
      "LR average precision score: 0.336\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 2\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.929\n",
      "GB cohens kappa score: 0.926\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 316, 17\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.605\n",
      "KNN cohens kappa score: 0.583\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33752 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 297, 36\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.419\n",
      "LR cohens kappa score: 0.383\n",
      "LR average precision score: 0.385\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 325, 8\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.765\n",
      "KNN cohens kappa score: 0.753\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1280 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32712 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 294, 37\n",
      "LR fn, tp: 2, 11\n",
      "LR f1 score: 0.361\n",
      "LR cohens kappa score: 0.320\n",
      "LR average precision score: 0.371\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 323, 8\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.727\n",
      "KNN cohens kappa score: 0.714\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34700 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 299, 34\n",
      "LR fn, tp: 1, 12\n",
      "LR f1 score: 0.407\n",
      "LR cohens kappa score: 0.370\n",
      "LR average precision score: 0.346\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 327, 6\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.774\n",
      "KNN cohens kappa score: 0.764\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33020 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 291, 42\n",
      "LR fn, tp: 1, 12\n",
      "LR f1 score: 0.358\n",
      "LR cohens kappa score: 0.317\n",
      "LR average precision score: 0.534\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 1, 12\n",
      "GB f1 score: 0.960\n",
      "GB cohens kappa score: 0.959\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 320, 13\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.667\n",
      "KNN cohens kappa score: 0.649\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32808 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 282, 51\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.338\n",
      "LR cohens kappa score: 0.294\n",
      "LR average precision score: 0.302\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 327, 6\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.813\n",
      "GB cohens kappa score: 0.804\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 321, 12\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.684\n",
      "KNN cohens kappa score: 0.668\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34408 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 294, 39\n",
      "LR fn, tp: 1, 12\n",
      "LR f1 score: 0.375\n",
      "LR cohens kappa score: 0.335\n",
      "LR average precision score: 0.272\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 2\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.929\n",
      "GB cohens kappa score: 0.926\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 323, 10\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.722\n",
      "KNN cohens kappa score: 0.708\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1280 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33664 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 294, 37\n",
      "LR fn, tp: 1, 12\n",
      "LR f1 score: 0.387\n",
      "LR cohens kappa score: 0.348\n",
      "LR average precision score: 0.350\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 331, 0\n",
      "GB fn, tp: 3, 10\n",
      "GB f1 score: 0.870\n",
      "GB cohens kappa score: 0.865\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 321, 10\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.722\n",
      "KNN cohens kappa score: 0.708\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34268 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 280, 53\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.329\n",
      "LR cohens kappa score: 0.284\n",
      "LR average precision score: 0.298\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 2, 11\n",
      "GB f1 score: 0.917\n",
      "GB cohens kappa score: 0.914\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 319, 14\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.650\n",
      "KNN cohens kappa score: 0.631\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34364 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 303, 30\n",
      "LR fn, tp: 3, 10\n",
      "LR f1 score: 0.377\n",
      "LR cohens kappa score: 0.340\n",
      "LR average precision score: 0.351\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 332, 1\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.963\n",
      "GB cohens kappa score: 0.961\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 325, 8\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.727\n",
      "KNN cohens kappa score: 0.714\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34312 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 306, 27\n",
      "LR fn, tp: 2, 11\n",
      "LR f1 score: 0.431\n",
      "LR cohens kappa score: 0.398\n",
      "LR average precision score: 0.356\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 333, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 325, 8\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.765\n",
      "KNN cohens kappa score: 0.753\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1278 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 35024 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 282, 51\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.338\n",
      "LR cohens kappa score: 0.294\n",
      "LR average precision score: 0.291\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 332, 1\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.963\n",
      "GB cohens kappa score: 0.961\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 325, 8\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.765\n",
      "KNN cohens kappa score: 0.753\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1280 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33328 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 291, 40\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.394\n",
      "LR cohens kappa score: 0.355\n",
      "LR average precision score: 0.483\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 330, 1\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.963\n",
      "GB cohens kappa score: 0.961\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 321, 10\n",
      "KNN fn, tp: 1, 12\n",
      "KNN f1 score: 0.686\n",
      "KNN cohens kappa score: 0.670\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 306, 58\n",
      "LR fn, tp: 3, 13\n",
      "LR f1 score: 0.433\n",
      "LR cohens kappa score: 0.398\n",
      "LR average precision score: 0.534\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 291.52, 41.08\n",
      "LR fn, tp: 0.64, 12.36\n",
      "LR f1 score: 0.376\n",
      "LR cohens kappa score: 0.336\n",
      "LR average precision score: 0.362\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 275, 27\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 0.310\n",
      "LR cohens kappa score: 0.263\n",
      "LR average precision score: 0.272\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 333, 6\n",
      "GB fn, tp: 3, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 331.64, 0.96\n",
      "GB fn, tp: 0.48, 12.52\n",
      "GB f1 score: 0.947\n",
      "GB cohens kappa score: 0.945\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 327, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 0.813\n",
      "GB cohens kappa score: 0.804\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 327, 19\n",
      "KNN fn, tp: 3, 13\n",
      "KNN f1 score: 0.800\n",
      "KNN cohens kappa score: 0.791\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 322.04, 10.56\n",
      "KNN fn, tp: 0.4, 12.6\n",
      "KNN f1 score: 0.702\n",
      "KNN cohens kappa score: 0.687\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 314, 5\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.578\n",
      "KNN cohens kappa score: 0.554\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_flare-F\n",
      "///////////////////////////////////////////\n",
      "\n",
      "non empty cut in data_input/folding_flare-F! (23 points)\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17252 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 172, 33\n",
      "LR fn, tp: 6, 3\n",
      "LR f1 score: 0.133\n",
      "LR cohens kappa score: 0.071\n",
      "LR average precision score: 0.093\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 204, 1\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.008\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 178, 27\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.244\n",
      "KNN cohens kappa score: 0.191\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22252 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 158, 47\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.250\n",
      "LR cohens kappa score: 0.192\n",
      "LR average precision score: 0.370\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 203, 2\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.167\n",
      "GB cohens kappa score: 0.149\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 168, 37\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.231\n",
      "KNN cohens kappa score: 0.173\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16288 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 176, 29\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.233\n",
      "LR cohens kappa score: 0.178\n",
      "LR average precision score: 0.263\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.200\n",
      "GB cohens kappa score: 0.193\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 177, 28\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.238\n",
      "KNN cohens kappa score: 0.184\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20168 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 181, 24\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.429\n",
      "LR cohens kappa score: 0.388\n",
      "LR average precision score: 0.651\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 204, 1\n",
      "GB fn, tp: 7, 2\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.319\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 184, 21\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.333\n",
      "KNN cohens kappa score: 0.288\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22368 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 171, 32\n",
      "LR fn, tp: 3, 4\n",
      "LR f1 score: 0.186\n",
      "LR cohens kappa score: 0.138\n",
      "LR average precision score: 0.201\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 200, 3\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.314\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 173, 30\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.238\n",
      "KNN cohens kappa score: 0.193\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22172 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 167, 38\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.259\n",
      "LR cohens kappa score: 0.203\n",
      "LR average precision score: 0.397\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 202, 3\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.131\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 180, 25\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.341\n",
      "KNN cohens kappa score: 0.295\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17092 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 171, 34\n",
      "LR fn, tp: 3, 6\n",
      "LR f1 score: 0.245\n",
      "LR cohens kappa score: 0.189\n",
      "LR average precision score: 0.431\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 203, 2\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.016\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 173, 32\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.292\n",
      "KNN cohens kappa score: 0.240\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18752 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 175, 30\n",
      "LR fn, tp: 3, 6\n",
      "LR f1 score: 0.267\n",
      "LR cohens kappa score: 0.214\n",
      "LR average precision score: 0.261\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: 0.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 177, 28\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.238\n",
      "KNN cohens kappa score: 0.184\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18004 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 185, 20\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.294\n",
      "LR cohens kappa score: 0.248\n",
      "LR average precision score: 0.310\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.200\n",
      "GB cohens kappa score: 0.193\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 182, 23\n",
      "KNN fn, tp: 5, 4\n",
      "KNN f1 score: 0.222\n",
      "KNN cohens kappa score: 0.170\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 19720 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 172, 31\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.311\n",
      "LR cohens kappa score: 0.270\n",
      "LR average precision score: 0.386\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 201, 2\n",
      "GB fn, tp: 6, 1\n",
      "GB f1 score: 0.200\n",
      "GB cohens kappa score: 0.184\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 171, 32\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.267\n",
      "KNN cohens kappa score: 0.223\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22496 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 186, 19\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.400\n",
      "LR cohens kappa score: 0.360\n",
      "LR average precision score: 0.715\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: 0.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 193, 12\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.444\n",
      "KNN cohens kappa score: 0.411\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21052 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 167, 38\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.259\n",
      "LR cohens kappa score: 0.203\n",
      "LR average precision score: 0.199\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 203, 2\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.429\n",
      "GB cohens kappa score: 0.411\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 164, 41\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.214\n",
      "KNN cohens kappa score: 0.155\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18284 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 171, 34\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.280\n",
      "LR cohens kappa score: 0.227\n",
      "LR average precision score: 0.457\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 203, 2\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.016\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 173, 32\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.292\n",
      "KNN cohens kappa score: 0.240\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22092 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 175, 30\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.227\n",
      "LR cohens kappa score: 0.172\n",
      "LR average precision score: 0.272\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: 0.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 177, 28\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.279\n",
      "KNN cohens kappa score: 0.228\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18412 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 162, 41\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.222\n",
      "LR cohens kappa score: 0.174\n",
      "LR average precision score: 0.239\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 199, 4\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.308\n",
      "GB cohens kappa score: 0.286\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 181, 22\n",
      "KNN fn, tp: 4, 3\n",
      "KNN f1 score: 0.188\n",
      "KNN cohens kappa score: 0.143\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 19388 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 170, 35\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.308\n",
      "LR cohens kappa score: 0.256\n",
      "LR average precision score: 0.208\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 202, 3\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.021\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 184, 21\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.286\n",
      "KNN cohens kappa score: 0.238\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 19032 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 182, 23\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.359\n",
      "LR cohens kappa score: 0.315\n",
      "LR average precision score: 0.548\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.200\n",
      "GB cohens kappa score: 0.193\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 182, 23\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.270\n",
      "KNN cohens kappa score: 0.221\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21052 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 168, 37\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.196\n",
      "LR cohens kappa score: 0.136\n",
      "LR average precision score: 0.203\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.200\n",
      "GB cohens kappa score: 0.193\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 176, 29\n",
      "KNN fn, tp: 4, 5\n",
      "KNN f1 score: 0.233\n",
      "KNN cohens kappa score: 0.178\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18020 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 171, 34\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.346\n",
      "LR cohens kappa score: 0.297\n",
      "LR average precision score: 0.394\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 202, 3\n",
      "GB fn, tp: 7, 2\n",
      "GB f1 score: 0.286\n",
      "GB cohens kappa score: 0.264\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 181, 24\n",
      "KNN fn, tp: 3, 6\n",
      "KNN f1 score: 0.308\n",
      "KNN cohens kappa score: 0.260\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17500 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 176, 27\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.300\n",
      "LR cohens kappa score: 0.259\n",
      "LR average precision score: 0.639\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 203, 0\n",
      "GB fn, tp: 6, 1\n",
      "GB f1 score: 0.250\n",
      "GB cohens kappa score: 0.244\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 170, 33\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.222\n",
      "KNN cohens kappa score: 0.176\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22292 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 178, 27\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.244\n",
      "LR cohens kappa score: 0.191\n",
      "LR average precision score: 0.193\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 204, 1\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.182\n",
      "GB cohens kappa score: 0.169\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 182, 23\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.359\n",
      "KNN cohens kappa score: 0.315\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22776 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 174, 31\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.298\n",
      "LR cohens kappa score: 0.247\n",
      "LR average precision score: 0.512\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 204, 1\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.008\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 172, 33\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.286\n",
      "KNN cohens kappa score: 0.233\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20156 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 175, 30\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.375\n",
      "LR cohens kappa score: 0.329\n",
      "LR average precision score: 0.422\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 205, 0\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.200\n",
      "GB cohens kappa score: 0.193\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 184, 21\n",
      "KNN fn, tp: 2, 7\n",
      "KNN f1 score: 0.378\n",
      "KNN cohens kappa score: 0.336\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16640 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 179, 26\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.250\n",
      "LR cohens kappa score: 0.198\n",
      "LR average precision score: 0.203\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 203, 2\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.016\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 188, 17\n",
      "KNN fn, tp: 6, 3\n",
      "KNN f1 score: 0.207\n",
      "KNN cohens kappa score: 0.158\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 784 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22996 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 163, 40\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.192\n",
      "LR cohens kappa score: 0.143\n",
      "LR average precision score: 0.389\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 199, 4\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.308\n",
      "GB cohens kappa score: 0.286\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 175, 28\n",
      "KNN fn, tp: 3, 4\n",
      "KNN f1 score: 0.205\n",
      "KNN cohens kappa score: 0.159\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 186, 47\n",
      "LR fn, tp: 6, 9\n",
      "LR f1 score: 0.429\n",
      "LR cohens kappa score: 0.388\n",
      "LR average precision score: 0.715\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 173.0, 31.6\n",
      "LR fn, tp: 2.28, 6.32\n",
      "LR f1 score: 0.275\n",
      "LR cohens kappa score: 0.224\n",
      "LR average precision score: 0.358\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 158, 19\n",
      "LR fn, tp: 0, 3\n",
      "LR f1 score: 0.133\n",
      "LR cohens kappa score: 0.071\n",
      "LR average precision score: 0.093\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 205, 4\n",
      "GB fn, tp: 9, 3\n",
      "GB f1 score: 0.429\n",
      "GB cohens kappa score: 0.411\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 203.16, 1.44\n",
      "GB fn, tp: 7.68, 0.92\n",
      "GB f1 score: 0.158\n",
      "GB cohens kappa score: 0.145\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 199, 0\n",
      "GB fn, tp: 5, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.021\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 193, 41\n",
      "KNN fn, tp: 6, 7\n",
      "KNN f1 score: 0.444\n",
      "KNN cohens kappa score: 0.411\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 177.8, 26.8\n",
      "KNN fn, tp: 3.08, 5.52\n",
      "KNN f1 score: 0.273\n",
      "KNN cohens kappa score: 0.224\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 164, 12\n",
      "KNN fn, tp: 1, 3\n",
      "KNN f1 score: 0.188\n",
      "KNN cohens kappa score: 0.143\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_hypothyroid\n",
      "///////////////////////////////////////////\n",
      "\n",
      "non empty cut in data_input/folding_hypothyroid! (1 points)\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 37332 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 525, 78\n",
      "LR fn, tp: 4, 27\n",
      "LR f1 score: 0.397\n",
      "LR cohens kappa score: 0.348\n",
      "LR average precision score: 0.459\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 593, 10\n",
      "GB fn, tp: 4, 27\n",
      "GB f1 score: 0.794\n",
      "GB cohens kappa score: 0.783\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 576, 27\n",
      "KNN fn, tp: 5, 26\n",
      "KNN f1 score: 0.619\n",
      "KNN cohens kappa score: 0.594\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34980 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 510, 93\n",
      "LR fn, tp: 3, 28\n",
      "LR f1 score: 0.368\n",
      "LR cohens kappa score: 0.315\n",
      "LR average precision score: 0.462\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 588, 15\n",
      "GB fn, tp: 2, 29\n",
      "GB f1 score: 0.773\n",
      "GB cohens kappa score: 0.760\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 570, 33\n",
      "KNN fn, tp: 4, 27\n",
      "KNN f1 score: 0.593\n",
      "KNN cohens kappa score: 0.565\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 28680 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 508, 95\n",
      "LR fn, tp: 6, 25\n",
      "LR f1 score: 0.331\n",
      "LR cohens kappa score: 0.275\n",
      "LR average precision score: 0.329\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 592, 11\n",
      "GB fn, tp: 4, 27\n",
      "GB f1 score: 0.783\n",
      "GB cohens kappa score: 0.770\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 575, 28\n",
      "KNN fn, tp: 6, 25\n",
      "KNN f1 score: 0.595\n",
      "KNN cohens kappa score: 0.569\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 36244 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 504, 99\n",
      "LR fn, tp: 3, 28\n",
      "LR f1 score: 0.354\n",
      "LR cohens kappa score: 0.299\n",
      "LR average precision score: 0.426\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 594, 9\n",
      "GB fn, tp: 5, 26\n",
      "GB f1 score: 0.788\n",
      "GB cohens kappa score: 0.776\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 575, 28\n",
      "KNN fn, tp: 11, 20\n",
      "KNN f1 score: 0.506\n",
      "KNN cohens kappa score: 0.475\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2288 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 30764 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 523, 77\n",
      "LR fn, tp: 2, 25\n",
      "LR f1 score: 0.388\n",
      "LR cohens kappa score: 0.343\n",
      "LR average precision score: 0.556\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 594, 6\n",
      "GB fn, tp: 3, 24\n",
      "GB f1 score: 0.842\n",
      "GB cohens kappa score: 0.835\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 570, 30\n",
      "KNN fn, tp: 3, 24\n",
      "KNN f1 score: 0.593\n",
      "KNN cohens kappa score: 0.568\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 35100 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 532, 71\n",
      "LR fn, tp: 8, 23\n",
      "LR f1 score: 0.368\n",
      "LR cohens kappa score: 0.318\n",
      "LR average precision score: 0.493\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 593, 10\n",
      "GB fn, tp: 7, 24\n",
      "GB f1 score: 0.738\n",
      "GB cohens kappa score: 0.724\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 578, 25\n",
      "KNN fn, tp: 6, 25\n",
      "KNN f1 score: 0.617\n",
      "KNN cohens kappa score: 0.593\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 36700 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 526, 77\n",
      "LR fn, tp: 6, 25\n",
      "LR f1 score: 0.376\n",
      "LR cohens kappa score: 0.325\n",
      "LR average precision score: 0.431\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 592, 11\n",
      "GB fn, tp: 3, 28\n",
      "GB f1 score: 0.800\n",
      "GB cohens kappa score: 0.788\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 573, 30\n",
      "KNN fn, tp: 5, 26\n",
      "KNN f1 score: 0.598\n",
      "KNN cohens kappa score: 0.571\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34924 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 515, 88\n",
      "LR fn, tp: 5, 26\n",
      "LR f1 score: 0.359\n",
      "LR cohens kappa score: 0.305\n",
      "LR average precision score: 0.583\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 596, 7\n",
      "GB fn, tp: 9, 22\n",
      "GB f1 score: 0.733\n",
      "GB cohens kappa score: 0.720\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 576, 27\n",
      "KNN fn, tp: 9, 22\n",
      "KNN f1 score: 0.550\n",
      "KNN cohens kappa score: 0.521\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 28384 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 519, 84\n",
      "LR fn, tp: 6, 25\n",
      "LR f1 score: 0.357\n",
      "LR cohens kappa score: 0.304\n",
      "LR average precision score: 0.297\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 591, 12\n",
      "GB fn, tp: 4, 27\n",
      "GB f1 score: 0.771\n",
      "GB cohens kappa score: 0.758\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 577, 26\n",
      "KNN fn, tp: 8, 23\n",
      "KNN f1 score: 0.575\n",
      "KNN cohens kappa score: 0.548\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2288 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 29472 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 501, 99\n",
      "LR fn, tp: 1, 26\n",
      "LR f1 score: 0.342\n",
      "LR cohens kappa score: 0.292\n",
      "LR average precision score: 0.477\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 594, 6\n",
      "GB fn, tp: 2, 25\n",
      "GB f1 score: 0.862\n",
      "GB cohens kappa score: 0.855\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 571, 29\n",
      "KNN fn, tp: 3, 24\n",
      "KNN f1 score: 0.600\n",
      "KNN cohens kappa score: 0.576\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 28320 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 522, 81\n",
      "LR fn, tp: 6, 25\n",
      "LR f1 score: 0.365\n",
      "LR cohens kappa score: 0.313\n",
      "LR average precision score: 0.496\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 603, 0\n",
      "GB fn, tp: 6, 25\n",
      "GB f1 score: 0.893\n",
      "GB cohens kappa score: 0.888\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 580, 23\n",
      "KNN fn, tp: 9, 22\n",
      "KNN f1 score: 0.579\n",
      "KNN cohens kappa score: 0.553\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 28804 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 541, 62\n",
      "LR fn, tp: 11, 20\n",
      "LR f1 score: 0.354\n",
      "LR cohens kappa score: 0.305\n",
      "LR average precision score: 0.298\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 589, 14\n",
      "GB fn, tp: 3, 28\n",
      "GB f1 score: 0.767\n",
      "GB cohens kappa score: 0.753\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 572, 31\n",
      "KNN fn, tp: 7, 24\n",
      "KNN f1 score: 0.558\n",
      "KNN cohens kappa score: 0.529\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34020 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 516, 87\n",
      "LR fn, tp: 1, 30\n",
      "LR f1 score: 0.405\n",
      "LR cohens kappa score: 0.356\n",
      "LR average precision score: 0.562\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 587, 16\n",
      "GB fn, tp: 5, 26\n",
      "GB f1 score: 0.712\n",
      "GB cohens kappa score: 0.695\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 569, 34\n",
      "KNN fn, tp: 6, 25\n",
      "KNN f1 score: 0.556\n",
      "KNN cohens kappa score: 0.525\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 37092 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 509, 94\n",
      "LR fn, tp: 2, 29\n",
      "LR f1 score: 0.377\n",
      "LR cohens kappa score: 0.324\n",
      "LR average precision score: 0.488\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 589, 14\n",
      "GB fn, tp: 6, 25\n",
      "GB f1 score: 0.714\n",
      "GB cohens kappa score: 0.698\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 570, 33\n",
      "KNN fn, tp: 6, 25\n",
      "KNN f1 score: 0.562\n",
      "KNN cohens kappa score: 0.532\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2288 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 36828 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 509, 91\n",
      "LR fn, tp: 4, 23\n",
      "LR f1 score: 0.326\n",
      "LR cohens kappa score: 0.276\n",
      "LR average precision score: 0.297\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 595, 5\n",
      "GB fn, tp: 1, 26\n",
      "GB f1 score: 0.897\n",
      "GB cohens kappa score: 0.892\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 577, 23\n",
      "KNN fn, tp: 3, 24\n",
      "KNN f1 score: 0.649\n",
      "KNN cohens kappa score: 0.628\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33672 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 519, 84\n",
      "LR fn, tp: 3, 28\n",
      "LR f1 score: 0.392\n",
      "LR cohens kappa score: 0.341\n",
      "LR average precision score: 0.379\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 583, 20\n",
      "GB fn, tp: 4, 27\n",
      "GB f1 score: 0.692\n",
      "GB cohens kappa score: 0.673\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 572, 31\n",
      "KNN fn, tp: 7, 24\n",
      "KNN f1 score: 0.558\n",
      "KNN cohens kappa score: 0.529\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 38104 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 532, 71\n",
      "LR fn, tp: 5, 26\n",
      "LR f1 score: 0.406\n",
      "LR cohens kappa score: 0.359\n",
      "LR average precision score: 0.431\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 595, 8\n",
      "GB fn, tp: 3, 28\n",
      "GB f1 score: 0.836\n",
      "GB cohens kappa score: 0.827\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 576, 27\n",
      "KNN fn, tp: 6, 25\n",
      "KNN f1 score: 0.602\n",
      "KNN cohens kappa score: 0.576\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27152 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 517, 86\n",
      "LR fn, tp: 2, 29\n",
      "LR f1 score: 0.397\n",
      "LR cohens kappa score: 0.347\n",
      "LR average precision score: 0.580\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 596, 7\n",
      "GB fn, tp: 5, 26\n",
      "GB f1 score: 0.812\n",
      "GB cohens kappa score: 0.803\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 580, 23\n",
      "KNN fn, tp: 5, 26\n",
      "KNN f1 score: 0.650\n",
      "KNN cohens kappa score: 0.628\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33940 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 495, 108\n",
      "LR fn, tp: 3, 28\n",
      "LR f1 score: 0.335\n",
      "LR cohens kappa score: 0.278\n",
      "LR average precision score: 0.460\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 591, 12\n",
      "GB fn, tp: 1, 30\n",
      "GB f1 score: 0.822\n",
      "GB cohens kappa score: 0.811\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 569, 34\n",
      "KNN fn, tp: 8, 23\n",
      "KNN f1 score: 0.523\n",
      "KNN cohens kappa score: 0.490\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2288 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33364 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 509, 91\n",
      "LR fn, tp: 6, 21\n",
      "LR f1 score: 0.302\n",
      "LR cohens kappa score: 0.250\n",
      "LR average precision score: 0.417\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 586, 14\n",
      "GB fn, tp: 5, 22\n",
      "GB f1 score: 0.698\n",
      "GB cohens kappa score: 0.683\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 568, 32\n",
      "KNN fn, tp: 6, 21\n",
      "KNN f1 score: 0.525\n",
      "KNN cohens kappa score: 0.496\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 38360 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 520, 83\n",
      "LR fn, tp: 4, 27\n",
      "LR f1 score: 0.383\n",
      "LR cohens kappa score: 0.332\n",
      "LR average precision score: 0.446\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 588, 15\n",
      "GB fn, tp: 5, 26\n",
      "GB f1 score: 0.722\n",
      "GB cohens kappa score: 0.706\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 577, 26\n",
      "KNN fn, tp: 6, 25\n",
      "KNN f1 score: 0.610\n",
      "KNN cohens kappa score: 0.584\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 35156 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 519, 84\n",
      "LR fn, tp: 6, 25\n",
      "LR f1 score: 0.357\n",
      "LR cohens kappa score: 0.304\n",
      "LR average precision score: 0.508\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 596, 7\n",
      "GB fn, tp: 6, 25\n",
      "GB f1 score: 0.794\n",
      "GB cohens kappa score: 0.783\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 573, 30\n",
      "KNN fn, tp: 7, 24\n",
      "KNN f1 score: 0.565\n",
      "KNN cohens kappa score: 0.536\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33172 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 504, 99\n",
      "LR fn, tp: 2, 29\n",
      "LR f1 score: 0.365\n",
      "LR cohens kappa score: 0.310\n",
      "LR average precision score: 0.498\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 594, 9\n",
      "GB fn, tp: 6, 25\n",
      "GB f1 score: 0.769\n",
      "GB cohens kappa score: 0.757\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 571, 32\n",
      "KNN fn, tp: 7, 24\n",
      "KNN f1 score: 0.552\n",
      "KNN cohens kappa score: 0.522\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2289 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 27908 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 512, 91\n",
      "LR fn, tp: 4, 27\n",
      "LR f1 score: 0.362\n",
      "LR cohens kappa score: 0.309\n",
      "LR average precision score: 0.564\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 591, 12\n",
      "GB fn, tp: 3, 28\n",
      "GB f1 score: 0.789\n",
      "GB cohens kappa score: 0.776\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 576, 27\n",
      "KNN fn, tp: 7, 24\n",
      "KNN f1 score: 0.585\n",
      "KNN cohens kappa score: 0.559\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2288 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 28648 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 527, 73\n",
      "LR fn, tp: 6, 21\n",
      "LR f1 score: 0.347\n",
      "LR cohens kappa score: 0.300\n",
      "LR average precision score: 0.310\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 590, 10\n",
      "GB fn, tp: 7, 20\n",
      "GB f1 score: 0.702\n",
      "GB cohens kappa score: 0.688\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 571, 29\n",
      "KNN fn, tp: 6, 21\n",
      "KNN f1 score: 0.545\n",
      "KNN cohens kappa score: 0.519\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 541, 108\n",
      "LR fn, tp: 11, 30\n",
      "LR f1 score: 0.406\n",
      "LR cohens kappa score: 0.359\n",
      "LR average precision score: 0.583\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 516.56, 85.84\n",
      "LR fn, tp: 4.36, 25.84\n",
      "LR f1 score: 0.365\n",
      "LR cohens kappa score: 0.313\n",
      "LR average precision score: 0.450\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 495, 62\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.302\n",
      "LR cohens kappa score: 0.250\n",
      "LR average precision score: 0.297\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 603, 20\n",
      "GB fn, tp: 9, 30\n",
      "GB f1 score: 0.897\n",
      "GB cohens kappa score: 0.892\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 592.0, 10.4\n",
      "GB fn, tp: 4.36, 25.84\n",
      "GB f1 score: 0.780\n",
      "GB cohens kappa score: 0.768\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 583, 0\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.692\n",
      "GB cohens kappa score: 0.673\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 580, 34\n",
      "KNN fn, tp: 11, 27\n",
      "KNN f1 score: 0.650\n",
      "KNN cohens kappa score: 0.628\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 573.68, 28.72\n",
      "KNN fn, tp: 6.24, 23.96\n",
      "KNN f1 score: 0.579\n",
      "KNN cohens kappa score: 0.551\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 568, 23\n",
      "KNN fn, tp: 3, 20\n",
      "KNN f1 score: 0.506\n",
      "KNN cohens kappa score: 0.475\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_kddcup-guess_passwd_vs_satan\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18140 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18316 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17752 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 1\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 0.957\n",
      "KNN cohens kappa score: 0.955\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18548 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1228 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18492 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 317, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 317, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 0\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18380 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18452 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 1\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 0.957\n",
      "KNN cohens kappa score: 0.955\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18716 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18176 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1228 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18100 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 317, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 317, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 0\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17812 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 1\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 0.957\n",
      "KNN cohens kappa score: 0.955\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18200 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18644 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18084 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1228 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17720 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 317, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 317, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 0\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18448 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18220 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18496 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16976 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1228 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18544 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 316, 1\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.947\n",
      "LR cohens kappa score: 0.946\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 317, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 316, 1\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.947\n",
      "KNN cohens kappa score: 0.946\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18476 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 1\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 0.957\n",
      "KNN cohens kappa score: 0.955\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18284 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18116 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1229 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18208 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 318, 0\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 318, 0\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1228 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18364 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 317, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 317, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 317, 0\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 318, 1\n",
      "LR fn, tp: 0, 11\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 317.76, 0.04\n",
      "LR fn, tp: 0.0, 10.6\n",
      "LR f1 score: 0.998\n",
      "LR cohens kappa score: 0.998\n",
      "LR average precision score: 1.000\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 316, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.947\n",
      "LR cohens kappa score: 0.946\n",
      "LR average precision score: 1.000\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 318, 0\n",
      "GB fn, tp: 0, 11\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 317.8, 0.0\n",
      "GB fn, tp: 0.0, 10.6\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 317, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 318, 1\n",
      "KNN fn, tp: 0, 11\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 317.6, 0.2\n",
      "KNN fn, tp: 0.0, 10.6\n",
      "KNN f1 score: 0.991\n",
      "KNN cohens kappa score: 0.991\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 316, 0\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.947\n",
      "KNN cohens kappa score: 0.946\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_kr-vs-k-three_vs_eleven\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 37788 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 1\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.971\n",
      "LR cohens kappa score: 0.971\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 567, 4\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.895\n",
      "KNN cohens kappa score: 0.891\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44680 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 571, 0\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 568, 3\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.919\n",
      "KNN cohens kappa score: 0.916\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 46568 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 569, 2\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.944\n",
      "LR cohens kappa score: 0.943\n",
      "LR average precision score: 0.997\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 567, 4\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.895\n",
      "KNN cohens kappa score: 0.891\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 43964 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 569, 2\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.944\n",
      "LR cohens kappa score: 0.943\n",
      "LR average precision score: 0.997\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 565, 6\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.850\n",
      "KNN cohens kappa score: 0.845\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2216 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 46724 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 566, 4\n",
      "LR fn, tp: 1, 12\n",
      "LR f1 score: 0.828\n",
      "LR cohens kappa score: 0.823\n",
      "LR average precision score: 0.911\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 568, 2\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.929\n",
      "GB cohens kappa score: 0.927\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 568, 2\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.929\n",
      "KNN cohens kappa score: 0.927\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44300 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 569, 2\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.944\n",
      "LR cohens kappa score: 0.943\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 570, 1\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.971\n",
      "KNN cohens kappa score: 0.971\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 41812 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 1\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.971\n",
      "LR cohens kappa score: 0.971\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 569, 2\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.944\n",
      "KNN cohens kappa score: 0.943\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44992 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 1\n",
      "LR fn, tp: 2, 15\n",
      "LR f1 score: 0.909\n",
      "LR cohens kappa score: 0.906\n",
      "LR average precision score: 0.979\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 566, 5\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.872\n",
      "KNN cohens kappa score: 0.867\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44932 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 569, 2\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.944\n",
      "LR cohens kappa score: 0.943\n",
      "LR average precision score: 0.993\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 565, 6\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.850\n",
      "KNN cohens kappa score: 0.845\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2216 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45956 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 568, 2\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.929\n",
      "LR cohens kappa score: 0.927\n",
      "LR average precision score: 0.995\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 570, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 563, 7\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.788\n",
      "KNN cohens kappa score: 0.782\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33496 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 569, 2\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.944\n",
      "LR cohens kappa score: 0.943\n",
      "LR average precision score: 0.990\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 568, 3\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.919\n",
      "KNN cohens kappa score: 0.916\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 46872 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 571, 0\n",
      "LR fn, tp: 1, 16\n",
      "LR f1 score: 0.970\n",
      "LR cohens kappa score: 0.969\n",
      "LR average precision score: 0.997\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 567, 4\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.895\n",
      "KNN cohens kappa score: 0.891\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44500 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 571, 0\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 566, 5\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.872\n",
      "KNN cohens kappa score: 0.867\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44300 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 1\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.971\n",
      "LR cohens kappa score: 0.971\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 567, 4\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.895\n",
      "KNN cohens kappa score: 0.891\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2216 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45524 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 568, 2\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 0.929\n",
      "LR cohens kappa score: 0.927\n",
      "LR average precision score: 0.995\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 570, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 568, 2\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.929\n",
      "KNN cohens kappa score: 0.927\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 46332 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 1\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.971\n",
      "LR cohens kappa score: 0.971\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 564, 7\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.829\n",
      "KNN cohens kappa score: 0.823\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 40300 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 571, 0\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 568, 3\n",
      "KNN fn, tp: 1, 16\n",
      "KNN f1 score: 0.889\n",
      "KNN cohens kappa score: 0.885\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45392 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 1\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.971\n",
      "LR cohens kappa score: 0.971\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 565, 6\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.850\n",
      "KNN cohens kappa score: 0.845\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 39660 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 568, 3\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.919\n",
      "LR cohens kappa score: 0.916\n",
      "LR average precision score: 0.887\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 570, 1\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 0.971\n",
      "GB cohens kappa score: 0.971\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 568, 3\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.919\n",
      "KNN cohens kappa score: 0.916\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2216 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 47256 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 0\n",
      "LR fn, tp: 1, 12\n",
      "LR f1 score: 0.960\n",
      "LR cohens kappa score: 0.959\n",
      "LR average precision score: 0.986\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 570, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 567, 3\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.897\n",
      "KNN cohens kappa score: 0.894\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45068 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 566, 5\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.872\n",
      "LR cohens kappa score: 0.867\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 565, 6\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.850\n",
      "KNN cohens kappa score: 0.845\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44244 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 567, 4\n",
      "LR fn, tp: 0, 17\n",
      "LR f1 score: 0.895\n",
      "LR cohens kappa score: 0.891\n",
      "LR average precision score: 0.973\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 571, 0\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 42256 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 571, 0\n",
      "LR fn, tp: 1, 16\n",
      "LR f1 score: 0.970\n",
      "LR cohens kappa score: 0.969\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 565, 6\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.850\n",
      "KNN cohens kappa score: 0.845\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2219 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 43808 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 571, 0\n",
      "LR fn, tp: 1, 16\n",
      "LR f1 score: 0.970\n",
      "LR cohens kappa score: 0.969\n",
      "LR average precision score: 0.997\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 571, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 567, 4\n",
      "KNN fn, tp: 0, 17\n",
      "KNN f1 score: 0.895\n",
      "KNN cohens kappa score: 0.891\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2216 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44408 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 570, 0\n",
      "LR fn, tp: 0, 13\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 570, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 567, 3\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.897\n",
      "KNN cohens kappa score: 0.894\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 571, 5\n",
      "LR fn, tp: 2, 17\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 569.36, 1.44\n",
      "LR fn, tp: 0.28, 15.92\n",
      "LR f1 score: 0.949\n",
      "LR cohens kappa score: 0.948\n",
      "LR average precision score: 0.988\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 566, 0\n",
      "LR fn, tp: 0, 12\n",
      "LR f1 score: 0.828\n",
      "LR cohens kappa score: 0.823\n",
      "LR average precision score: 0.887\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 571, 2\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 570.68, 0.12\n",
      "GB fn, tp: 0.0, 16.2\n",
      "GB f1 score: 0.996\n",
      "GB cohens kappa score: 0.996\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 568, 0\n",
      "GB fn, tp: 0, 13\n",
      "GB f1 score: 0.929\n",
      "GB cohens kappa score: 0.927\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 571, 7\n",
      "KNN fn, tp: 1, 17\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 566.84, 3.96\n",
      "KNN fn, tp: 0.04, 16.16\n",
      "KNN f1 score: 0.892\n",
      "KNN cohens kappa score: 0.888\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 563, 0\n",
      "KNN fn, tp: 0, 13\n",
      "KNN f1 score: 0.788\n",
      "KNN cohens kappa score: 0.782\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_kr-vs-k-zero-one_vs_draw\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45704 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 549, 11\n",
      "LR fn, tp: 2, 19\n",
      "LR f1 score: 0.745\n",
      "LR cohens kappa score: 0.734\n",
      "LR average precision score: 0.846\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 558, 2\n",
      "GB fn, tp: 3, 18\n",
      "GB f1 score: 0.878\n",
      "GB cohens kappa score: 0.874\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 552, 8\n",
      "KNN fn, tp: 2, 19\n",
      "KNN f1 score: 0.792\n",
      "KNN cohens kappa score: 0.783\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45348 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 548, 12\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.778\n",
      "LR cohens kappa score: 0.768\n",
      "LR average precision score: 0.919\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 558, 2\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.955\n",
      "KNN cohens kappa score: 0.953\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 42192 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 538, 22\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.635\n",
      "LR cohens kappa score: 0.616\n",
      "LR average precision score: 0.823\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.976\n",
      "GB cohens kappa score: 0.975\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 554, 6\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.875\n",
      "KNN cohens kappa score: 0.870\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45060 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 541, 19\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.667\n",
      "LR cohens kappa score: 0.650\n",
      "LR average precision score: 0.871\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 559, 1\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 0.977\n",
      "GB cohens kappa score: 0.976\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 551, 9\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.824\n",
      "KNN cohens kappa score: 0.816\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2156 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44992 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 540, 16\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.724\n",
      "LR cohens kappa score: 0.711\n",
      "LR average precision score: 0.986\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 556, 0\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.976\n",
      "GB cohens kappa score: 0.975\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 549, 7\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.857\n",
      "KNN cohens kappa score: 0.851\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 39980 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 544, 16\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.702\n",
      "LR cohens kappa score: 0.687\n",
      "LR average precision score: 0.919\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 558, 2\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 0.955\n",
      "GB cohens kappa score: 0.953\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 550, 10\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.808\n",
      "KNN cohens kappa score: 0.799\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45400 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 552, 8\n",
      "LR fn, tp: 2, 19\n",
      "LR f1 score: 0.792\n",
      "LR cohens kappa score: 0.783\n",
      "LR average precision score: 0.933\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 559, 1\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.952\n",
      "GB cohens kappa score: 0.951\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 555, 5\n",
      "KNN fn, tp: 1, 20\n",
      "KNN f1 score: 0.870\n",
      "KNN cohens kappa score: 0.864\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 42148 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 545, 15\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.737\n",
      "LR cohens kappa score: 0.724\n",
      "LR average precision score: 0.900\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.976\n",
      "GB cohens kappa score: 0.975\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 558, 2\n",
      "KNN fn, tp: 1, 20\n",
      "KNN f1 score: 0.930\n",
      "KNN cohens kappa score: 0.928\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 47172 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 538, 22\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.656\n",
      "LR cohens kappa score: 0.639\n",
      "LR average precision score: 0.872\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 559, 1\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.952\n",
      "GB cohens kappa score: 0.951\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 551, 9\n",
      "KNN fn, tp: 1, 20\n",
      "KNN f1 score: 0.800\n",
      "KNN cohens kappa score: 0.791\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2156 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45232 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 537, 19\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.689\n",
      "LR cohens kappa score: 0.673\n",
      "LR average precision score: 0.864\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 556, 0\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 554, 2\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.955\n",
      "KNN cohens kappa score: 0.953\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 46296 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 548, 12\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.778\n",
      "LR cohens kappa score: 0.768\n",
      "LR average precision score: 0.940\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 559, 1\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.952\n",
      "GB cohens kappa score: 0.951\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 551, 9\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.824\n",
      "KNN cohens kappa score: 0.816\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44708 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 555, 5\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.870\n",
      "LR cohens kappa score: 0.864\n",
      "LR average precision score: 0.889\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.976\n",
      "GB cohens kappa score: 0.975\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 556, 4\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.913\n",
      "KNN cohens kappa score: 0.909\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 40896 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 532, 28\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.580\n",
      "LR cohens kappa score: 0.557\n",
      "LR average precision score: 0.823\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 556, 4\n",
      "GB fn, tp: 2, 19\n",
      "GB f1 score: 0.864\n",
      "GB cohens kappa score: 0.858\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 552, 8\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.840\n",
      "KNN cohens kappa score: 0.833\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 46284 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 545, 15\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.714\n",
      "LR cohens kappa score: 0.701\n",
      "LR average precision score: 0.943\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.976\n",
      "GB cohens kappa score: 0.975\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 557, 3\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.933\n",
      "KNN cohens kappa score: 0.931\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2156 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 44324 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 536, 20\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.677\n",
      "LR cohens kappa score: 0.661\n",
      "LR average precision score: 0.939\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 555, 1\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 0.977\n",
      "GB cohens kappa score: 0.976\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 545, 11\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.792\n",
      "KNN cohens kappa score: 0.783\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 43468 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 545, 15\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.714\n",
      "LR cohens kappa score: 0.701\n",
      "LR average precision score: 0.927\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 558, 2\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 0.955\n",
      "GB cohens kappa score: 0.953\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 552, 8\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.840\n",
      "KNN cohens kappa score: 0.833\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 41068 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 543, 17\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.712\n",
      "LR cohens kappa score: 0.698\n",
      "LR average precision score: 0.956\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 553, 7\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.857\n",
      "KNN cohens kappa score: 0.851\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 40528 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 544, 16\n",
      "LR fn, tp: 3, 18\n",
      "LR f1 score: 0.655\n",
      "LR cohens kappa score: 0.638\n",
      "LR average precision score: 0.808\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 4, 17\n",
      "GB f1 score: 0.895\n",
      "GB cohens kappa score: 0.891\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 553, 7\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.857\n",
      "KNN cohens kappa score: 0.851\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 41608 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 538, 22\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.656\n",
      "LR cohens kappa score: 0.639\n",
      "LR average precision score: 0.881\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 557, 3\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.909\n",
      "GB cohens kappa score: 0.906\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 554, 6\n",
      "KNN fn, tp: 1, 20\n",
      "KNN f1 score: 0.851\n",
      "KNN cohens kappa score: 0.845\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2156 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45812 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 547, 9\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.800\n",
      "LR cohens kappa score: 0.791\n",
      "LR average precision score: 0.928\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 556, 0\n",
      "GB fn, tp: 2, 19\n",
      "GB f1 score: 0.950\n",
      "GB cohens kappa score: 0.948\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 551, 5\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.894\n",
      "KNN cohens kappa score: 0.889\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 42812 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 544, 16\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.724\n",
      "LR cohens kappa score: 0.711\n",
      "LR average precision score: 0.961\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 558, 2\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.930\n",
      "GB cohens kappa score: 0.928\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 555, 5\n",
      "KNN fn, tp: 1, 20\n",
      "KNN f1 score: 0.870\n",
      "KNN cohens kappa score: 0.864\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 42056 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 546, 14\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.727\n",
      "LR cohens kappa score: 0.715\n",
      "LR average precision score: 0.906\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 560, 0\n",
      "GB fn, tp: 3, 18\n",
      "GB f1 score: 0.923\n",
      "GB cohens kappa score: 0.920\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 555, 5\n",
      "KNN fn, tp: 1, 20\n",
      "KNN f1 score: 0.870\n",
      "KNN cohens kappa score: 0.864\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 42508 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 542, 18\n",
      "LR fn, tp: 0, 21\n",
      "LR f1 score: 0.700\n",
      "LR cohens kappa score: 0.685\n",
      "LR average precision score: 0.846\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 559, 1\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 0.977\n",
      "GB cohens kappa score: 0.976\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 552, 8\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.840\n",
      "KNN cohens kappa score: 0.833\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2152 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 45076 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 540, 20\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.656\n",
      "LR cohens kappa score: 0.639\n",
      "LR average precision score: 0.882\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 559, 1\n",
      "GB fn, tp: 1, 20\n",
      "GB f1 score: 0.952\n",
      "GB cohens kappa score: 0.951\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 551, 9\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.824\n",
      "KNN cohens kappa score: 0.816\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2156 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 47384 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 541, 15\n",
      "LR fn, tp: 1, 20\n",
      "LR f1 score: 0.714\n",
      "LR cohens kappa score: 0.701\n",
      "LR average precision score: 0.909\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 555, 1\n",
      "GB fn, tp: 0, 21\n",
      "GB f1 score: 0.977\n",
      "GB cohens kappa score: 0.976\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 549, 7\n",
      "KNN fn, tp: 0, 21\n",
      "KNN f1 score: 0.857\n",
      "KNN cohens kappa score: 0.851\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 555, 28\n",
      "LR fn, tp: 3, 21\n",
      "LR f1 score: 0.870\n",
      "LR cohens kappa score: 0.864\n",
      "LR average precision score: 0.986\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 543.12, 16.08\n",
      "LR fn, tp: 0.72, 20.28\n",
      "LR f1 score: 0.712\n",
      "LR cohens kappa score: 0.698\n",
      "LR average precision score: 0.899\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 532, 5\n",
      "LR fn, tp: 0, 18\n",
      "LR f1 score: 0.580\n",
      "LR cohens kappa score: 0.557\n",
      "LR average precision score: 0.808\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 560, 4\n",
      "GB fn, tp: 4, 21\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 558.28, 0.92\n",
      "GB fn, tp: 1.0, 20.0\n",
      "GB f1 score: 0.954\n",
      "GB cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 555, 0\n",
      "GB fn, tp: 0, 17\n",
      "GB f1 score: 0.864\n",
      "GB cohens kappa score: 0.858\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 558, 11\n",
      "KNN fn, tp: 2, 21\n",
      "KNN f1 score: 0.955\n",
      "KNN cohens kappa score: 0.953\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 552.72, 6.48\n",
      "KNN fn, tp: 0.32, 20.68\n",
      "KNN f1 score: 0.861\n",
      "KNN cohens kappa score: 0.855\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 545, 2\n",
      "KNN fn, tp: 0, 19\n",
      "KNN f1 score: 0.792\n",
      "KNN cohens kappa score: 0.783\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_shuttle-2_vs_5\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13884 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 653, 1\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.952\n",
      "KNN cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 11884 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 653, 1\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.952\n",
      "KNN cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12804 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12752 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 652, 2\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.909\n",
      "KNN cohens kappa score: 0.908\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2576 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12700 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 651, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 651, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 651, 0\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12100 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 653, 1\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.952\n",
      "KNN cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12988 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12468 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 652, 2\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.909\n",
      "KNN cohens kappa score: 0.908\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12248 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2576 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12056 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 651, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 651, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 649, 2\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.900\n",
      "KNN cohens kappa score: 0.898\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12316 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13736 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 653, 1\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.952\n",
      "KNN cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12000 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12056 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 653, 1\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.952\n",
      "KNN cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2576 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13184 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 651, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 651, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 649, 2\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.900\n",
      "KNN cohens kappa score: 0.898\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12116 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12048 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 652, 2\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.909\n",
      "KNN cohens kappa score: 0.908\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 14780 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 653, 1\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 0.952\n",
      "LR cohens kappa score: 0.952\n",
      "LR average precision score: 0.991\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12264 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 653, 1\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.952\n",
      "KNN cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2576 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13480 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 651, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 651, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 650, 1\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.947\n",
      "KNN cohens kappa score: 0.947\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12244 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 653, 1\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.952\n",
      "KNN cohens kappa score: 0.952\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12264 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 653, 1\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 0.952\n",
      "LR cohens kappa score: 0.952\n",
      "LR average precision score: 0.909\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 11512 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 653, 1\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 0.952\n",
      "LR cohens kappa score: 0.952\n",
      "LR average precision score: 0.981\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 651, 3\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 0.870\n",
      "KNN cohens kappa score: 0.867\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2574 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 11840 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 654, 0\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 654, 0\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 2576 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 14912 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 651, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 651, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 650, 1\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.947\n",
      "KNN cohens kappa score: 0.947\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 654, 1\n",
      "LR fn, tp: 0, 10\n",
      "LR f1 score: 1.000\n",
      "LR cohens kappa score: 1.000\n",
      "LR average precision score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 653.28, 0.12\n",
      "LR fn, tp: 0.0, 9.8\n",
      "LR f1 score: 0.994\n",
      "LR cohens kappa score: 0.994\n",
      "LR average precision score: 0.995\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 651, 0\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.952\n",
      "LR cohens kappa score: 0.952\n",
      "LR average precision score: 0.909\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 654, 0\n",
      "GB fn, tp: 0, 10\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 653.4, 0.0\n",
      "GB fn, tp: 0.0, 9.8\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 651, 0\n",
      "GB fn, tp: 0, 9\n",
      "GB f1 score: 1.000\n",
      "GB cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 654, 3\n",
      "KNN fn, tp: 0, 10\n",
      "KNN f1 score: 1.000\n",
      "KNN cohens kappa score: 1.000\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 652.52, 0.88\n",
      "KNN fn, tp: 0.0, 9.8\n",
      "KNN f1 score: 0.958\n",
      "KNN cohens kappa score: 0.958\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 649, 0\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.870\n",
      "KNN cohens kappa score: 0.867\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_winequality-red-4\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20816 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 215, 95\n",
      "LR fn, tp: 4, 7\n",
      "LR f1 score: 0.124\n",
      "LR cohens kappa score: 0.066\n",
      "LR average precision score: 0.136\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 290, 20\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.121\n",
      "GB cohens kappa score: 0.079\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 210, 100\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.070\n",
      "KNN cohens kappa score: 0.008\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21276 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 213, 97\n",
      "LR fn, tp: 4, 7\n",
      "LR f1 score: 0.122\n",
      "LR cohens kappa score: 0.064\n",
      "LR average precision score: 0.094\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 295, 15\n",
      "GB fn, tp: 6, 5\n",
      "GB f1 score: 0.323\n",
      "GB cohens kappa score: 0.291\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 237, 73\n",
      "KNN fn, tp: 6, 5\n",
      "KNN f1 score: 0.112\n",
      "KNN cohens kappa score: 0.056\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33712 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 183, 127\n",
      "LR fn, tp: 1, 10\n",
      "LR f1 score: 0.135\n",
      "LR cohens kappa score: 0.077\n",
      "LR average precision score: 0.229\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 26\n",
      "GB fn, tp: 5, 6\n",
      "GB f1 score: 0.279\n",
      "GB cohens kappa score: 0.240\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 206, 104\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.067\n",
      "KNN cohens kappa score: 0.005\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33088 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 234, 76\n",
      "LR fn, tp: 6, 5\n",
      "LR f1 score: 0.109\n",
      "LR cohens kappa score: 0.051\n",
      "LR average precision score: 0.129\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 298, 12\n",
      "GB fn, tp: 10, 1\n",
      "GB f1 score: 0.083\n",
      "GB cohens kappa score: 0.048\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 227, 83\n",
      "KNN fn, tp: 6, 5\n",
      "KNN f1 score: 0.101\n",
      "KNN cohens kappa score: 0.043\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1196 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20028 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 223, 83\n",
      "LR fn, tp: 4, 5\n",
      "LR f1 score: 0.103\n",
      "LR cohens kappa score: 0.054\n",
      "LR average precision score: 0.221\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 294, 12\n",
      "GB fn, tp: 9, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.034\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 219, 87\n",
      "KNN fn, tp: 5, 4\n",
      "KNN f1 score: 0.080\n",
      "KNN cohens kappa score: 0.030\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 31696 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 203, 107\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.127\n",
      "LR cohens kappa score: 0.069\n",
      "LR average precision score: 0.126\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 290, 20\n",
      "GB fn, tp: 7, 4\n",
      "GB f1 score: 0.229\n",
      "GB cohens kappa score: 0.191\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 213, 97\n",
      "KNN fn, tp: 8, 3\n",
      "KNN f1 score: 0.054\n",
      "KNN cohens kappa score: -0.008\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22428 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 244, 66\n",
      "LR fn, tp: 4, 7\n",
      "LR f1 score: 0.167\n",
      "LR cohens kappa score: 0.114\n",
      "LR average precision score: 0.155\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 301, 9\n",
      "GB fn, tp: 11, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.032\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 232, 78\n",
      "KNN fn, tp: 8, 3\n",
      "KNN f1 score: 0.065\n",
      "KNN cohens kappa score: 0.005\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33556 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 215, 95\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.140\n",
      "LR cohens kappa score: 0.084\n",
      "LR average precision score: 0.165\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 21\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.118\n",
      "GB cohens kappa score: 0.075\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 238, 72\n",
      "KNN fn, tp: 9, 2\n",
      "KNN f1 score: 0.047\n",
      "KNN cohens kappa score: -0.013\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32640 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 219, 91\n",
      "LR fn, tp: 5, 6\n",
      "LR f1 score: 0.111\n",
      "LR cohens kappa score: 0.053\n",
      "LR average precision score: 0.306\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 290, 20\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.176\n",
      "GB cohens kappa score: 0.136\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 223, 87\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.078\n",
      "KNN cohens kappa score: 0.018\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1196 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24116 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 229, 77\n",
      "LR fn, tp: 3, 6\n",
      "LR f1 score: 0.130\n",
      "LR cohens kappa score: 0.083\n",
      "LR average precision score: 0.151\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 293, 13\n",
      "GB fn, tp: 7, 2\n",
      "GB f1 score: 0.167\n",
      "GB cohens kappa score: 0.136\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 222, 84\n",
      "KNN fn, tp: 6, 3\n",
      "KNN f1 score: 0.062\n",
      "KNN cohens kappa score: 0.011\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23032 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 237, 73\n",
      "LR fn, tp: 5, 6\n",
      "LR f1 score: 0.133\n",
      "LR cohens kappa score: 0.078\n",
      "LR average precision score: 0.212\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 300, 10\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.174\n",
      "GB cohens kappa score: 0.143\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 238, 72\n",
      "KNN fn, tp: 9, 2\n",
      "KNN f1 score: 0.047\n",
      "KNN cohens kappa score: -0.013\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33584 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 205, 105\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.129\n",
      "LR cohens kappa score: 0.071\n",
      "LR average precision score: 0.202\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 293, 17\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.194\n",
      "GB cohens kappa score: 0.156\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 243, 67\n",
      "KNN fn, tp: 9, 2\n",
      "KNN f1 score: 0.050\n",
      "KNN cohens kappa score: -0.010\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33436 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 216, 94\n",
      "LR fn, tp: 6, 5\n",
      "LR f1 score: 0.091\n",
      "LR cohens kappa score: 0.031\n",
      "LR average precision score: 0.068\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 285, 25\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.105\n",
      "GB cohens kappa score: 0.059\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 219, 91\n",
      "KNN fn, tp: 6, 5\n",
      "KNN f1 score: 0.093\n",
      "KNN cohens kappa score: 0.034\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21280 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 206, 104\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.145\n",
      "LR cohens kappa score: 0.088\n",
      "LR average precision score: 0.185\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 291, 19\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.182\n",
      "GB cohens kappa score: 0.143\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 240, 70\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.094\n",
      "KNN cohens kappa score: 0.037\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1196 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21120 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 226, 80\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.165\n",
      "LR cohens kappa score: 0.119\n",
      "LR average precision score: 0.094\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 292, 14\n",
      "GB fn, tp: 7, 2\n",
      "GB f1 score: 0.160\n",
      "GB cohens kappa score: 0.128\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 233, 73\n",
      "KNN fn, tp: 6, 3\n",
      "KNN f1 score: 0.071\n",
      "KNN cohens kappa score: 0.021\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33680 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 222, 88\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.150\n",
      "LR cohens kappa score: 0.094\n",
      "LR average precision score: 0.395\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 295, 15\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.143\n",
      "GB cohens kappa score: 0.106\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 237, 73\n",
      "KNN fn, tp: 9, 2\n",
      "KNN f1 score: 0.047\n",
      "KNN cohens kappa score: -0.014\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21940 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 220, 90\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.147\n",
      "LR cohens kappa score: 0.091\n",
      "LR average precision score: 0.187\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 22\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.167\n",
      "GB cohens kappa score: 0.125\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 228, 82\n",
      "KNN fn, tp: 8, 3\n",
      "KNN f1 score: 0.062\n",
      "KNN cohens kappa score: 0.002\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23532 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 229, 81\n",
      "LR fn, tp: 5, 6\n",
      "LR f1 score: 0.122\n",
      "LR cohens kappa score: 0.066\n",
      "LR average precision score: 0.082\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 293, 17\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.133\n",
      "GB cohens kappa score: 0.094\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 229, 81\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.083\n",
      "KNN cohens kappa score: 0.024\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21960 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 212, 98\n",
      "LR fn, tp: 1, 10\n",
      "LR f1 score: 0.168\n",
      "LR cohens kappa score: 0.113\n",
      "LR average precision score: 0.156\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 293, 17\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.133\n",
      "GB cohens kappa score: 0.094\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 225, 85\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.080\n",
      "KNN cohens kappa score: 0.020\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1196 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20956 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 228, 78\n",
      "LR fn, tp: 6, 3\n",
      "LR f1 score: 0.067\n",
      "LR cohens kappa score: 0.016\n",
      "LR average precision score: 0.036\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 278, 28\n",
      "GB fn, tp: 8, 1\n",
      "GB f1 score: 0.053\n",
      "GB cohens kappa score: 0.009\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 229, 77\n",
      "KNN fn, tp: 8, 1\n",
      "KNN f1 score: 0.023\n",
      "KNN cohens kappa score: -0.030\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 33564 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 220, 90\n",
      "LR fn, tp: 5, 6\n",
      "LR f1 score: 0.112\n",
      "LR cohens kappa score: 0.054\n",
      "LR average precision score: 0.079\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 22\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.114\n",
      "GB cohens kappa score: 0.071\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 226, 84\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.081\n",
      "KNN cohens kappa score: 0.021\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23712 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 235, 75\n",
      "LR fn, tp: 5, 6\n",
      "LR f1 score: 0.130\n",
      "LR cohens kappa score: 0.075\n",
      "LR average precision score: 0.093\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 296, 14\n",
      "GB fn, tp: 7, 4\n",
      "GB f1 score: 0.276\n",
      "GB cohens kappa score: 0.244\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 219, 91\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.075\n",
      "KNN cohens kappa score: 0.015\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21880 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 206, 104\n",
      "LR fn, tp: 1, 10\n",
      "LR f1 score: 0.160\n",
      "LR cohens kappa score: 0.104\n",
      "LR average precision score: 0.260\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 27\n",
      "GB fn, tp: 7, 4\n",
      "GB f1 score: 0.190\n",
      "GB cohens kappa score: 0.147\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 229, 81\n",
      "KNN fn, tp: 6, 5\n",
      "KNN f1 score: 0.103\n",
      "KNN cohens kappa score: 0.045\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1194 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 32636 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 211, 99\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.136\n",
      "LR cohens kappa score: 0.078\n",
      "LR average precision score: 0.188\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 293, 17\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.133\n",
      "GB cohens kappa score: 0.094\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 227, 83\n",
      "KNN fn, tp: 7, 4\n",
      "KNN f1 score: 0.082\n",
      "KNN cohens kappa score: 0.022\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1196 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 34124 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 233, 73\n",
      "LR fn, tp: 3, 6\n",
      "LR f1 score: 0.136\n",
      "LR cohens kappa score: 0.090\n",
      "LR average precision score: 0.123\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 19\n",
      "GB fn, tp: 7, 2\n",
      "GB f1 score: 0.133\n",
      "GB cohens kappa score: 0.097\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 228, 78\n",
      "KNN fn, tp: 8, 1\n",
      "KNN f1 score: 0.023\n",
      "KNN cohens kappa score: -0.030\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 244, 127\n",
      "LR fn, tp: 6, 10\n",
      "LR f1 score: 0.168\n",
      "LR cohens kappa score: 0.119\n",
      "LR average precision score: 0.395\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 219.36, 89.84\n",
      "LR fn, tp: 3.56, 7.04\n",
      "LR f1 score: 0.130\n",
      "LR cohens kappa score: 0.075\n",
      "LR average precision score: 0.163\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 183, 66\n",
      "LR fn, tp: 1, 3\n",
      "LR f1 score: 0.067\n",
      "LR cohens kappa score: 0.016\n",
      "LR average precision score: 0.036\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 301, 28\n",
      "GB fn, tp: 11, 6\n",
      "GB f1 score: 0.323\n",
      "GB cohens kappa score: 0.291\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 291.16, 18.04\n",
      "GB fn, tp: 8.16, 2.44\n",
      "GB f1 score: 0.151\n",
      "GB cohens kappa score: 0.114\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 278, 9\n",
      "GB fn, tp: 5, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.034\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 243, 104\n",
      "KNN fn, tp: 9, 5\n",
      "KNN f1 score: 0.112\n",
      "KNN cohens kappa score: 0.056\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 227.08, 82.12\n",
      "KNN fn, tp: 7.2, 3.4\n",
      "KNN f1 score: 0.070\n",
      "KNN cohens kappa score: 0.012\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 206, 67\n",
      "KNN fn, tp: 5, 1\n",
      "KNN f1 score: 0.023\n",
      "KNN cohens kappa score: -0.030\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_yeast4\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13832 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 245, 42\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.290\n",
      "LR cohens kappa score: 0.244\n",
      "LR average precision score: 0.390\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 1\n",
      "GB fn, tp: 10, 1\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.144\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 261, 26\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.391\n",
      "KNN cohens kappa score: 0.355\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13968 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 226, 61\n",
      "LR fn, tp: 1, 10\n",
      "LR f1 score: 0.244\n",
      "LR cohens kappa score: 0.192\n",
      "LR average precision score: 0.619\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 3\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.353\n",
      "GB cohens kappa score: 0.336\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 259, 28\n",
      "KNN fn, tp: 1, 10\n",
      "KNN f1 score: 0.408\n",
      "KNN cohens kappa score: 0.372\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17916 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 235, 52\n",
      "LR fn, tp: 1, 10\n",
      "LR f1 score: 0.274\n",
      "LR cohens kappa score: 0.225\n",
      "LR average precision score: 0.267\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 1\n",
      "GB fn, tp: 10, 1\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.144\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 260, 27\n",
      "KNN fn, tp: 3, 8\n",
      "KNN f1 score: 0.348\n",
      "KNN cohens kappa score: 0.309\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13568 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 250, 37\n",
      "LR fn, tp: 6, 5\n",
      "LR f1 score: 0.189\n",
      "LR cohens kappa score: 0.138\n",
      "LR average precision score: 0.167\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 281, 6\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.300\n",
      "GB cohens kappa score: 0.276\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 257, 30\n",
      "KNN fn, tp: 4, 7\n",
      "KNN f1 score: 0.292\n",
      "KNN cohens kappa score: 0.249\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1104 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13084 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 238, 47\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.200\n",
      "LR cohens kappa score: 0.165\n",
      "LR average precision score: 0.369\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 1\n",
      "GB fn, tp: 6, 1\n",
      "GB f1 score: 0.222\n",
      "GB cohens kappa score: 0.214\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 258, 27\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.300\n",
      "KNN cohens kappa score: 0.271\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16944 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 248, 39\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.305\n",
      "LR cohens kappa score: 0.261\n",
      "LR average precision score: 0.356\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 4\n",
      "GB fn, tp: 10, 1\n",
      "GB f1 score: 0.125\n",
      "GB cohens kappa score: 0.104\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 260, 27\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.383\n",
      "KNN cohens kappa score: 0.346\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18056 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 232, 55\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.216\n",
      "LR cohens kappa score: 0.164\n",
      "LR average precision score: 0.464\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 1\n",
      "GB fn, tp: 7, 4\n",
      "GB f1 score: 0.500\n",
      "GB cohens kappa score: 0.488\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 238, 49\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.261\n",
      "KNN cohens kappa score: 0.212\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17208 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 242, 45\n",
      "LR fn, tp: 4, 7\n",
      "LR f1 score: 0.222\n",
      "LR cohens kappa score: 0.172\n",
      "LR average precision score: 0.364\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 285, 2\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.375\n",
      "GB cohens kappa score: 0.360\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 248, 39\n",
      "KNN fn, tp: 3, 8\n",
      "KNN f1 score: 0.276\n",
      "KNN cohens kappa score: 0.230\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13328 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 248, 39\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.276\n",
      "LR cohens kappa score: 0.230\n",
      "LR average precision score: 0.317\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 285, 2\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.267\n",
      "GB cohens kappa score: 0.252\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 266, 21\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.439\n",
      "KNN cohens kappa score: 0.407\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1104 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13488 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 229, 56\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.174\n",
      "LR cohens kappa score: 0.137\n",
      "LR average precision score: 0.350\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 2\n",
      "GB fn, tp: 6, 1\n",
      "GB f1 score: 0.200\n",
      "GB cohens kappa score: 0.188\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 265, 20\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.364\n",
      "KNN cohens kappa score: 0.339\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12844 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 241, 46\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.246\n",
      "LR cohens kappa score: 0.197\n",
      "LR average precision score: 0.472\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 3\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.250\n",
      "GB cohens kappa score: 0.232\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 268, 19\n",
      "KNN fn, tp: 3, 8\n",
      "KNN f1 score: 0.421\n",
      "KNN cohens kappa score: 0.389\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13724 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 240, 47\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.269\n",
      "LR cohens kappa score: 0.221\n",
      "LR average precision score: 0.380\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 1\n",
      "GB fn, tp: 10, 1\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.144\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 263, 24\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.409\n",
      "KNN cohens kappa score: 0.374\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18164 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 245, 42\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.262\n",
      "LR cohens kappa score: 0.215\n",
      "LR average precision score: 0.229\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 282, 5\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.222\n",
      "GB cohens kappa score: 0.199\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 249, 38\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.310\n",
      "KNN cohens kappa score: 0.266\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17652 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 238, 49\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.261\n",
      "LR cohens kappa score: 0.212\n",
      "LR average precision score: 0.515\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 285, 2\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.375\n",
      "GB cohens kappa score: 0.360\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 261, 26\n",
      "KNN fn, tp: 5, 6\n",
      "KNN f1 score: 0.279\n",
      "KNN cohens kappa score: 0.237\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1104 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18344 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 246, 39\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.196\n",
      "LR cohens kappa score: 0.161\n",
      "LR average precision score: 0.397\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 1\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.545\n",
      "GB cohens kappa score: 0.537\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 255, 30\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.238\n",
      "KNN cohens kappa score: 0.206\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 23300 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 258, 29\n",
      "LR fn, tp: 5, 6\n",
      "LR f1 score: 0.261\n",
      "LR cohens kappa score: 0.217\n",
      "LR average precision score: 0.471\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 1\n",
      "GB fn, tp: 10, 1\n",
      "GB f1 score: 0.154\n",
      "GB cohens kappa score: 0.144\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 267, 20\n",
      "KNN fn, tp: 6, 5\n",
      "KNN f1 score: 0.278\n",
      "KNN cohens kappa score: 0.239\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24192 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 239, 48\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.265\n",
      "LR cohens kappa score: 0.216\n",
      "LR average precision score: 0.329\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 4\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.314\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 260, 27\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.383\n",
      "KNN cohens kappa score: 0.346\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24280 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 233, 54\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.243\n",
      "LR cohens kappa score: 0.192\n",
      "LR average precision score: 0.270\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 4\n",
      "GB fn, tp: 11, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.020\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 257, 30\n",
      "KNN fn, tp: 1, 10\n",
      "KNN f1 score: 0.392\n",
      "KNN cohens kappa score: 0.355\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 28028 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 245, 42\n",
      "LR fn, tp: 4, 7\n",
      "LR f1 score: 0.233\n",
      "LR cohens kappa score: 0.184\n",
      "LR average precision score: 0.285\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 3\n",
      "GB fn, tp: 11, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.016\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 258, 29\n",
      "KNN fn, tp: 3, 8\n",
      "KNN f1 score: 0.333\n",
      "KNN cohens kappa score: 0.293\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1104 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 15704 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 241, 44\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.179\n",
      "LR cohens kappa score: 0.143\n",
      "LR average precision score: 0.529\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 282, 3\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.462\n",
      "GB cohens kappa score: 0.449\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 260, 25\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.270\n",
      "KNN cohens kappa score: 0.241\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21232 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 250, 37\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.286\n",
      "LR cohens kappa score: 0.241\n",
      "LR average precision score: 0.217\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 3\n",
      "GB fn, tp: 11, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.016\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 263, 24\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.409\n",
      "KNN cohens kappa score: 0.374\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13348 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 233, 54\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.243\n",
      "LR cohens kappa score: 0.192\n",
      "LR average precision score: 0.549\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 3\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.353\n",
      "GB cohens kappa score: 0.336\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 257, 30\n",
      "KNN fn, tp: 1, 10\n",
      "KNN f1 score: 0.392\n",
      "KNN cohens kappa score: 0.355\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 14180 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 247, 40\n",
      "LR fn, tp: 3, 8\n",
      "LR f1 score: 0.271\n",
      "LR cohens kappa score: 0.225\n",
      "LR average precision score: 0.523\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 0\n",
      "GB fn, tp: 8, 3\n",
      "GB f1 score: 0.429\n",
      "GB cohens kappa score: 0.419\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 262, 25\n",
      "KNN fn, tp: 5, 6\n",
      "KNN f1 score: 0.286\n",
      "KNN cohens kappa score: 0.245\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1106 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13628 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 236, 51\n",
      "LR fn, tp: 1, 10\n",
      "LR f1 score: 0.278\n",
      "LR cohens kappa score: 0.230\n",
      "LR average precision score: 0.545\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 281, 6\n",
      "GB fn, tp: 9, 2\n",
      "GB f1 score: 0.211\n",
      "GB cohens kappa score: 0.185\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 253, 34\n",
      "KNN fn, tp: 2, 9\n",
      "KNN f1 score: 0.333\n",
      "KNN cohens kappa score: 0.292\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1104 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17732 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 234, 51\n",
      "LR fn, tp: 3, 4\n",
      "LR f1 score: 0.129\n",
      "LR cohens kappa score: 0.090\n",
      "LR average precision score: 0.130\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 281, 4\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.308\n",
      "GB cohens kappa score: 0.292\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 265, 20\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.312\n",
      "KNN cohens kappa score: 0.286\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 258, 61\n",
      "LR fn, tp: 6, 10\n",
      "LR f1 score: 0.305\n",
      "LR cohens kappa score: 0.261\n",
      "LR average precision score: 0.619\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 240.76, 45.84\n",
      "LR fn, tp: 2.52, 7.68\n",
      "LR f1 score: 0.240\n",
      "LR cohens kappa score: 0.195\n",
      "LR average precision score: 0.380\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 226, 29\n",
      "LR fn, tp: 1, 4\n",
      "LR f1 score: 0.129\n",
      "LR cohens kappa score: 0.090\n",
      "LR average precision score: 0.130\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 287, 6\n",
      "GB fn, tp: 11, 4\n",
      "GB f1 score: 0.545\n",
      "GB cohens kappa score: 0.537\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 283.96, 2.64\n",
      "GB fn, tp: 8.28, 1.92\n",
      "GB f1 score: 0.258\n",
      "GB cohens kappa score: 0.243\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 281, 0\n",
      "GB fn, tp: 4, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.020\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 268, 49\n",
      "KNN fn, tp: 6, 10\n",
      "KNN f1 score: 0.439\n",
      "KNN cohens kappa score: 0.407\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 258.8, 27.8\n",
      "KNN fn, tp: 2.44, 7.76\n",
      "KNN f1 score: 0.340\n",
      "KNN cohens kappa score: 0.304\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 238, 19\n",
      "KNN fn, tp: 1, 5\n",
      "KNN f1 score: 0.238\n",
      "KNN cohens kappa score: 0.206\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_yeast5\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13252 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 275, 13\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.581\n",
      "LR cohens kappa score: 0.562\n",
      "LR average precision score: 0.889\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 3, 6\n",
      "GB f1 score: 0.706\n",
      "GB cohens kappa score: 0.697\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 281, 7\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.720\n",
      "KNN cohens kappa score: 0.709\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16864 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 273, 15\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.545\n",
      "LR cohens kappa score: 0.524\n",
      "LR average precision score: 0.653\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 4\n",
      "GB fn, tp: 1, 8\n",
      "GB f1 score: 0.762\n",
      "GB cohens kappa score: 0.753\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 272, 16\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.529\n",
      "KNN cohens kappa score: 0.507\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12004 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 278, 10\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.643\n",
      "LR cohens kappa score: 0.628\n",
      "LR average precision score: 0.592\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 4\n",
      "GB fn, tp: 3, 6\n",
      "GB f1 score: 0.632\n",
      "GB cohens kappa score: 0.619\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 275, 13\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.581\n",
      "KNN cohens kappa score: 0.562\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 15596 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 280, 8\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.692\n",
      "LR cohens kappa score: 0.680\n",
      "LR average precision score: 0.771\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 0\n",
      "GB fn, tp: 4, 5\n",
      "GB f1 score: 0.714\n",
      "GB cohens kappa score: 0.708\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 286, 2\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.900\n",
      "KNN cohens kappa score: 0.897\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1116 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 15620 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 275, 13\n",
      "LR fn, tp: 0, 8\n",
      "LR f1 score: 0.552\n",
      "LR cohens kappa score: 0.533\n",
      "LR average precision score: 0.688\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 2, 6\n",
      "GB f1 score: 0.750\n",
      "GB cohens kappa score: 0.743\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 278, 10\n",
      "KNN fn, tp: 0, 8\n",
      "KNN f1 score: 0.615\n",
      "KNN cohens kappa score: 0.600\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12516 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 275, 13\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.581\n",
      "LR cohens kappa score: 0.562\n",
      "LR average precision score: 0.712\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 1\n",
      "GB fn, tp: 1, 8\n",
      "GB f1 score: 0.889\n",
      "GB cohens kappa score: 0.885\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 281, 7\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.720\n",
      "KNN cohens kappa score: 0.709\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17740 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 272, 16\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.485\n",
      "LR cohens kappa score: 0.461\n",
      "LR average precision score: 0.354\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 5\n",
      "GB fn, tp: 6, 3\n",
      "GB f1 score: 0.353\n",
      "GB cohens kappa score: 0.334\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 275, 13\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.581\n",
      "KNN cohens kappa score: 0.562\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22740 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 280, 8\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.692\n",
      "LR cohens kappa score: 0.680\n",
      "LR average precision score: 0.762\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 1, 8\n",
      "GB f1 score: 0.842\n",
      "GB cohens kappa score: 0.837\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 282, 6\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.750\n",
      "KNN cohens kappa score: 0.740\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26884 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 273, 15\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.545\n",
      "LR cohens kappa score: 0.524\n",
      "LR average precision score: 0.878\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 2, 7\n",
      "GB f1 score: 0.778\n",
      "GB cohens kappa score: 0.771\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 277, 11\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.621\n",
      "KNN cohens kappa score: 0.604\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1116 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 15852 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 277, 11\n",
      "LR fn, tp: 0, 8\n",
      "LR f1 score: 0.593\n",
      "LR cohens kappa score: 0.576\n",
      "LR average precision score: 0.607\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 5, 3\n",
      "GB f1 score: 0.462\n",
      "GB cohens kappa score: 0.450\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 282, 6\n",
      "KNN fn, tp: 0, 8\n",
      "KNN f1 score: 0.727\n",
      "KNN cohens kappa score: 0.718\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17016 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 272, 16\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.529\n",
      "LR cohens kappa score: 0.507\n",
      "LR average precision score: 0.673\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 1\n",
      "GB fn, tp: 3, 6\n",
      "GB f1 score: 0.750\n",
      "GB cohens kappa score: 0.743\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 274, 14\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.562\n",
      "KNN cohens kappa score: 0.543\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 15988 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 273, 15\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.545\n",
      "LR cohens kappa score: 0.524\n",
      "LR average precision score: 0.697\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 285, 3\n",
      "GB fn, tp: 3, 6\n",
      "GB f1 score: 0.667\n",
      "GB cohens kappa score: 0.656\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 277, 11\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.621\n",
      "KNN cohens kappa score: 0.604\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16028 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 281, 7\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.609\n",
      "LR cohens kappa score: 0.594\n",
      "LR average precision score: 0.804\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 1\n",
      "GB fn, tp: 3, 6\n",
      "GB f1 score: 0.750\n",
      "GB cohens kappa score: 0.743\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 284, 4\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.818\n",
      "KNN cohens kappa score: 0.811\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16168 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 278, 10\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.643\n",
      "LR cohens kappa score: 0.628\n",
      "LR average precision score: 0.738\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 0\n",
      "GB fn, tp: 4, 5\n",
      "GB f1 score: 0.714\n",
      "GB cohens kappa score: 0.708\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 280, 8\n",
      "KNN fn, tp: 1, 8\n",
      "KNN f1 score: 0.640\n",
      "KNN cohens kappa score: 0.625\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1116 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26788 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 275, 13\n",
      "LR fn, tp: 0, 8\n",
      "LR f1 score: 0.552\n",
      "LR cohens kappa score: 0.533\n",
      "LR average precision score: 0.351\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 5\n",
      "GB fn, tp: 1, 7\n",
      "GB f1 score: 0.700\n",
      "GB cohens kappa score: 0.690\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 276, 12\n",
      "KNN fn, tp: 0, 8\n",
      "KNN f1 score: 0.571\n",
      "KNN cohens kappa score: 0.554\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 15440 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 275, 13\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.581\n",
      "LR cohens kappa score: 0.562\n",
      "LR average precision score: 0.714\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 1, 8\n",
      "GB f1 score: 0.842\n",
      "GB cohens kappa score: 0.837\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 277, 11\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.621\n",
      "KNN cohens kappa score: 0.604\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 20176 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 271, 17\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.471\n",
      "LR cohens kappa score: 0.446\n",
      "LR average precision score: 0.624\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 1\n",
      "GB fn, tp: 2, 7\n",
      "GB f1 score: 0.824\n",
      "GB cohens kappa score: 0.818\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 281, 7\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.720\n",
      "KNN cohens kappa score: 0.709\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12876 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 279, 9\n",
      "LR fn, tp: 2, 7\n",
      "LR f1 score: 0.560\n",
      "LR cohens kappa score: 0.542\n",
      "LR average precision score: 0.610\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 283, 5\n",
      "GB fn, tp: 4, 5\n",
      "GB f1 score: 0.526\n",
      "GB cohens kappa score: 0.511\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 279, 9\n",
      "KNN fn, tp: 1, 8\n",
      "KNN f1 score: 0.615\n",
      "KNN cohens kappa score: 0.600\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13456 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 280, 8\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.692\n",
      "LR cohens kappa score: 0.680\n",
      "LR average precision score: 0.639\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 3, 6\n",
      "GB f1 score: 0.706\n",
      "GB cohens kappa score: 0.697\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 280, 8\n",
      "KNN fn, tp: 1, 8\n",
      "KNN f1 score: 0.640\n",
      "KNN cohens kappa score: 0.625\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1116 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12976 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 276, 12\n",
      "LR fn, tp: 0, 8\n",
      "LR f1 score: 0.571\n",
      "LR cohens kappa score: 0.554\n",
      "LR average precision score: 0.740\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 2, 6\n",
      "GB f1 score: 0.750\n",
      "GB cohens kappa score: 0.743\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 273, 15\n",
      "KNN fn, tp: 0, 8\n",
      "KNN f1 score: 0.516\n",
      "KNN cohens kappa score: 0.496\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 15648 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 271, 17\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.514\n",
      "LR cohens kappa score: 0.491\n",
      "LR average precision score: 0.716\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 284, 4\n",
      "GB fn, tp: 1, 8\n",
      "GB f1 score: 0.762\n",
      "GB cohens kappa score: 0.753\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 273, 15\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.545\n",
      "KNN cohens kappa score: 0.524\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16016 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 278, 10\n",
      "LR fn, tp: 1, 8\n",
      "LR f1 score: 0.593\n",
      "LR cohens kappa score: 0.575\n",
      "LR average precision score: 0.792\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 0\n",
      "GB fn, tp: 3, 6\n",
      "GB f1 score: 0.800\n",
      "GB cohens kappa score: 0.795\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 283, 5\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.783\n",
      "KNN cohens kappa score: 0.774\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12172 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 277, 11\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.621\n",
      "LR cohens kappa score: 0.604\n",
      "LR average precision score: 0.724\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 2\n",
      "GB fn, tp: 1, 8\n",
      "GB f1 score: 0.842\n",
      "GB cohens kappa score: 0.837\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 282, 6\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.750\n",
      "KNN cohens kappa score: 0.740\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1117 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16320 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 280, 8\n",
      "LR fn, tp: 0, 9\n",
      "LR f1 score: 0.692\n",
      "LR cohens kappa score: 0.680\n",
      "LR average precision score: 0.595\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 1\n",
      "GB fn, tp: 4, 5\n",
      "GB f1 score: 0.667\n",
      "GB cohens kappa score: 0.658\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 283, 5\n",
      "KNN fn, tp: 0, 9\n",
      "KNN f1 score: 0.783\n",
      "KNN cohens kappa score: 0.774\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1116 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12724 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 273, 15\n",
      "LR fn, tp: 1, 7\n",
      "LR f1 score: 0.467\n",
      "LR cohens kappa score: 0.445\n",
      "LR average precision score: 0.372\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 282, 6\n",
      "GB fn, tp: 3, 5\n",
      "GB f1 score: 0.526\n",
      "GB cohens kappa score: 0.511\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 275, 13\n",
      "KNN fn, tp: 1, 7\n",
      "KNN f1 score: 0.500\n",
      "KNN cohens kappa score: 0.480\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 281, 17\n",
      "LR fn, tp: 2, 9\n",
      "LR f1 score: 0.692\n",
      "LR cohens kappa score: 0.680\n",
      "LR average precision score: 0.889\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 275.88, 12.12\n",
      "LR fn, tp: 0.32, 8.48\n",
      "LR f1 score: 0.582\n",
      "LR cohens kappa score: 0.564\n",
      "LR average precision score: 0.668\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 271, 7\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.467\n",
      "LR cohens kappa score: 0.445\n",
      "LR average precision score: 0.351\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 288, 6\n",
      "GB fn, tp: 6, 8\n",
      "GB f1 score: 0.889\n",
      "GB cohens kappa score: 0.885\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 285.64, 2.36\n",
      "GB fn, tp: 2.64, 6.16\n",
      "GB f1 score: 0.709\n",
      "GB cohens kappa score: 0.700\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 282, 0\n",
      "GB fn, tp: 1, 3\n",
      "GB f1 score: 0.353\n",
      "GB cohens kappa score: 0.334\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 286, 16\n",
      "KNN fn, tp: 1, 9\n",
      "KNN f1 score: 0.900\n",
      "KNN cohens kappa score: 0.897\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 278.64, 9.36\n",
      "KNN fn, tp: 0.16, 8.64\n",
      "KNN f1 score: 0.657\n",
      "KNN cohens kappa score: 0.643\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 272, 2\n",
      "KNN fn, tp: 0, 7\n",
      "KNN f1 score: 0.500\n",
      "KNN cohens kappa score: 0.480\n",
      "\n",
      "\n",
      "\n",
      "///////////////////////////////////////////\n",
      "// Running convGAN on folding_yeast6\n",
      "///////////////////////////////////////////\n",
      "\n",
      "-> Shuffling data\n",
      "### Start exercise for synthetic point generator\n",
      "\n",
      "====== Step 1/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 1/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13004 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 265, 25\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.316\n",
      "LR cohens kappa score: 0.288\n",
      "LR average precision score: 0.661\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 3\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.462\n",
      "GB cohens kappa score: 0.450\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 270, 20\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.364\n",
      "KNN cohens kappa score: 0.339\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13384 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 266, 24\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.278\n",
      "LR cohens kappa score: 0.249\n",
      "LR average precision score: 0.432\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 4\n",
      "GB fn, tp: 3, 4\n",
      "GB f1 score: 0.533\n",
      "GB cohens kappa score: 0.521\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 270, 20\n",
      "KNN fn, tp: 3, 4\n",
      "KNN f1 score: 0.258\n",
      "KNN cohens kappa score: 0.230\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21724 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 261, 29\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.286\n",
      "LR cohens kappa score: 0.257\n",
      "LR average precision score: 0.261\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 290, 0\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.444\n",
      "GB cohens kappa score: 0.439\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 270, 20\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.364\n",
      "KNN cohens kappa score: 0.339\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25512 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 270, 20\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.364\n",
      "LR cohens kappa score: 0.339\n",
      "LR average precision score: 0.591\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 4\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.429\n",
      "GB cohens kappa score: 0.415\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 275, 15\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.429\n",
      "KNN cohens kappa score: 0.408\n",
      "\n",
      "\n",
      "------ Step 1/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1132 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17548 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 248, 41\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.255\n",
      "LR cohens kappa score: 0.222\n",
      "LR average precision score: 0.566\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 2\n",
      "GB fn, tp: 3, 4\n",
      "GB f1 score: 0.615\n",
      "GB cohens kappa score: 0.607\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 266, 23\n",
      "KNN fn, tp: 0, 7\n",
      "KNN f1 score: 0.378\n",
      "KNN cohens kappa score: 0.354\n",
      "\n",
      "\n",
      "====== Step 2/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 2/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 18392 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 262, 28\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.333\n",
      "LR cohens kappa score: 0.306\n",
      "LR average precision score: 0.683\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 3\n",
      "GB fn, tp: 3, 4\n",
      "GB f1 score: 0.571\n",
      "GB cohens kappa score: 0.561\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 262, 28\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.293\n",
      "KNN cohens kappa score: 0.264\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17056 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 243, 47\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.230\n",
      "LR cohens kappa score: 0.196\n",
      "LR average precision score: 0.223\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 2\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.500\n",
      "GB cohens kappa score: 0.490\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 257, 33\n",
      "KNN fn, tp: 0, 7\n",
      "KNN f1 score: 0.298\n",
      "KNN cohens kappa score: 0.269\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25700 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 255, 35\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.250\n",
      "LR cohens kappa score: 0.219\n",
      "LR average precision score: 0.538\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 3\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.462\n",
      "GB cohens kappa score: 0.450\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 269, 21\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.353\n",
      "KNN cohens kappa score: 0.328\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13184 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 257, 33\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.222\n",
      "LR cohens kappa score: 0.190\n",
      "LR average precision score: 0.541\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 3\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.333\n",
      "GB cohens kappa score: 0.320\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 266, 24\n",
      "KNN fn, tp: 3, 4\n",
      "KNN f1 score: 0.229\n",
      "KNN cohens kappa score: 0.198\n",
      "\n",
      "\n",
      "------ Step 2/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1132 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 25752 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 271, 18\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.387\n",
      "LR cohens kappa score: 0.364\n",
      "LR average precision score: 0.524\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 0\n",
      "GB fn, tp: 6, 1\n",
      "GB f1 score: 0.250\n",
      "GB cohens kappa score: 0.246\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 277, 12\n",
      "KNN fn, tp: 3, 4\n",
      "KNN f1 score: 0.348\n",
      "KNN cohens kappa score: 0.326\n",
      "\n",
      "\n",
      "====== Step 3/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 3/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13288 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 263, 27\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.300\n",
      "LR cohens kappa score: 0.272\n",
      "LR average precision score: 0.646\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 1\n",
      "GB fn, tp: 3, 4\n",
      "GB f1 score: 0.667\n",
      "GB cohens kappa score: 0.660\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 271, 19\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.375\n",
      "KNN cohens kappa score: 0.351\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 22304 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 250, 40\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.259\n",
      "LR cohens kappa score: 0.228\n",
      "LR average precision score: 0.785\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 1\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.545\n",
      "GB cohens kappa score: 0.538\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 263, 27\n",
      "KNN fn, tp: 0, 7\n",
      "KNN f1 score: 0.341\n",
      "KNN cohens kappa score: 0.315\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17576 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 266, 24\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.278\n",
      "LR cohens kappa score: 0.249\n",
      "LR average precision score: 0.408\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 2\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.500\n",
      "GB cohens kappa score: 0.490\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 268, 22\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.294\n",
      "KNN cohens kappa score: 0.267\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13540 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 258, 32\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.304\n",
      "LR cohens kappa score: 0.275\n",
      "LR average precision score: 0.402\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 285, 5\n",
      "GB fn, tp: 3, 4\n",
      "GB f1 score: 0.500\n",
      "GB cohens kappa score: 0.486\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 261, 29\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.286\n",
      "KNN cohens kappa score: 0.257\n",
      "\n",
      "\n",
      "------ Step 3/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1132 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13140 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 268, 21\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.303\n",
      "LR cohens kappa score: 0.276\n",
      "LR average precision score: 0.345\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 1\n",
      "GB fn, tp: 7, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.006\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 277, 12\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.480\n",
      "KNN cohens kappa score: 0.462\n",
      "\n",
      "\n",
      "====== Step 4/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 4/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 16912 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 274, 16\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.414\n",
      "LR cohens kappa score: 0.392\n",
      "LR average precision score: 0.719\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 1\n",
      "GB fn, tp: 2, 5\n",
      "GB f1 score: 0.769\n",
      "GB cohens kappa score: 0.764\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 276, 14\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.444\n",
      "KNN cohens kappa score: 0.424\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 12696 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 258, 32\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.304\n",
      "LR cohens kappa score: 0.275\n",
      "LR average precision score: 0.265\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 286, 4\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.429\n",
      "GB cohens kappa score: 0.415\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 271, 19\n",
      "KNN fn, tp: 0, 7\n",
      "KNN f1 score: 0.424\n",
      "KNN cohens kappa score: 0.402\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 21256 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 244, 46\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.203\n",
      "LR cohens kappa score: 0.169\n",
      "LR average precision score: 0.533\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 2\n",
      "GB fn, tp: 3, 4\n",
      "GB f1 score: 0.615\n",
      "GB cohens kappa score: 0.607\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 262, 28\n",
      "KNN fn, tp: 0, 7\n",
      "KNN f1 score: 0.333\n",
      "KNN cohens kappa score: 0.306\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 14456 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 268, 22\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.294\n",
      "LR cohens kappa score: 0.267\n",
      "LR average precision score: 0.639\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 2\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.500\n",
      "GB cohens kappa score: 0.490\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 278, 12\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.417\n",
      "KNN cohens kappa score: 0.397\n",
      "\n",
      "\n",
      "------ Step 4/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1132 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 24300 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 266, 23\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.286\n",
      "LR cohens kappa score: 0.258\n",
      "LR average precision score: 0.672\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 288, 1\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.545\n",
      "GB cohens kappa score: 0.537\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 274, 15\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.370\n",
      "KNN cohens kappa score: 0.348\n",
      "\n",
      "\n",
      "====== Step 5/5 =======\n",
      "-> Shuffling data\n",
      "-> Spliting data to slices\n",
      "\n",
      "------ Step 5/5: Slice 1/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 14088 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 250, 40\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.259\n",
      "LR cohens kappa score: 0.228\n",
      "LR average precision score: 0.502\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 3\n",
      "GB fn, tp: 3, 4\n",
      "GB f1 score: 0.571\n",
      "GB cohens kappa score: 0.561\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 262, 28\n",
      "KNN fn, tp: 1, 6\n",
      "KNN f1 score: 0.293\n",
      "KNN cohens kappa score: 0.264\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 2/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17896 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 265, 25\n",
      "LR fn, tp: 3, 4\n",
      "LR f1 score: 0.222\n",
      "LR cohens kappa score: 0.192\n",
      "LR average precision score: 0.216\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 1\n",
      "GB fn, tp: 4, 3\n",
      "GB f1 score: 0.545\n",
      "GB cohens kappa score: 0.538\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 272, 18\n",
      "KNN fn, tp: 3, 4\n",
      "KNN f1 score: 0.276\n",
      "KNN cohens kappa score: 0.249\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 3/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 13860 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 257, 33\n",
      "LR fn, tp: 0, 7\n",
      "LR f1 score: 0.298\n",
      "LR cohens kappa score: 0.269\n",
      "LR average precision score: 0.759\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 1\n",
      "GB fn, tp: 1, 6\n",
      "GB f1 score: 0.857\n",
      "GB cohens kappa score: 0.854\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 271, 19\n",
      "KNN fn, tp: 0, 7\n",
      "KNN f1 score: 0.424\n",
      "KNN cohens kappa score: 0.402\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 4/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1131 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 26148 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 260, 30\n",
      "LR fn, tp: 1, 6\n",
      "LR f1 score: 0.279\n",
      "LR cohens kappa score: 0.249\n",
      "LR average precision score: 0.348\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 289, 1\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.400\n",
      "GB cohens kappa score: 0.391\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 271, 19\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.323\n",
      "KNN cohens kappa score: 0.297\n",
      "\n",
      "\n",
      "------ Step 5/5: Slice 5/5 -------\n",
      "-> Reset the GAN\n",
      "-> Train generator for synthetic samples\n",
      "-> create 1132 synthetic samples\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 17424 characters]\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> test with 'LR'\n",
      "LR tn, fp: 270, 19\n",
      "LR fn, tp: 2, 5\n",
      "LR f1 score: 0.323\n",
      "LR cohens kappa score: 0.297\n",
      "LR average precision score: 0.379\n",
      "\n",
      "-> test with 'GB'\n",
      "GB tn, fp: 287, 2\n",
      "GB fn, tp: 5, 2\n",
      "GB f1 score: 0.364\n",
      "GB cohens kappa score: 0.353\n",
      "\n",
      "-> test with 'KNN'\n",
      "KNN tn, fp: 275, 14\n",
      "KNN fn, tp: 2, 5\n",
      "KNN f1 score: 0.385\n",
      "KNN cohens kappa score: 0.363\n",
      "\n",
      "### Exercise is done.\n",
      "\n",
      "-----[ LR ]-----\n",
      "maximum:\n",
      "LR tn, fp: 274, 47\n",
      "LR fn, tp: 3, 7\n",
      "LR f1 score: 0.414\n",
      "LR cohens kappa score: 0.392\n",
      "LR average precision score: 0.785\n",
      "\n",
      "\n",
      "average:\n",
      "LR tn, fp: 260.6, 29.2\n",
      "LR fn, tp: 1.04, 5.96\n",
      "LR f1 score: 0.290\n",
      "LR cohens kappa score: 0.261\n",
      "LR average precision score: 0.506\n",
      "\n",
      "\n",
      "minimum:\n",
      "LR tn, fp: 243, 16\n",
      "LR fn, tp: 0, 4\n",
      "LR f1 score: 0.203\n",
      "LR cohens kappa score: 0.169\n",
      "LR average precision score: 0.216\n",
      "\n",
      "\n",
      "-----[ GB ]-----\n",
      "maximum:\n",
      "GB tn, fp: 290, 5\n",
      "GB fn, tp: 7, 6\n",
      "GB f1 score: 0.857\n",
      "GB cohens kappa score: 0.854\n",
      "\n",
      "\n",
      "average:\n",
      "GB tn, fp: 287.72, 2.08\n",
      "GB fn, tp: 3.88, 3.12\n",
      "GB f1 score: 0.496\n",
      "GB cohens kappa score: 0.487\n",
      "\n",
      "\n",
      "minimum:\n",
      "GB tn, fp: 285, 0\n",
      "GB fn, tp: 1, 0\n",
      "GB f1 score: 0.000\n",
      "GB cohens kappa score: -0.006\n",
      "\n",
      "\n",
      "-----[ KNN ]-----\n",
      "maximum:\n",
      "KNN tn, fp: 278, 33\n",
      "KNN fn, tp: 3, 7\n",
      "KNN f1 score: 0.480\n",
      "KNN cohens kappa score: 0.462\n",
      "\n",
      "\n",
      "average:\n",
      "KNN tn, fp: 269.36, 20.44\n",
      "KNN fn, tp: 1.28, 5.72\n",
      "KNN f1 score: 0.351\n",
      "KNN cohens kappa score: 0.326\n",
      "\n",
      "\n",
      "minimum:\n",
      "KNN tn, fp: 257, 12\n",
      "KNN fn, tp: 0, 4\n",
      "KNN f1 score: 0.229\n",
      "KNN cohens kappa score: 0.198\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for test in testSets:\n",
    "    runExerciseForConvGAN(test)"
   ]
  }
 ],
 "metadata": {
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
