{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kategorisierung der Ohrbilder\n",
    "\n",
    "Mit diesem Jupyter-Skript werden alle notwendigen Funktionen zur Umsetzung und Auswertung der Kategorisierung von Ohrbildern zusammengefasst.  \n",
    "Das Jupyter-Skript bezieht sich auf die Masterarbeit: \"Verwendung des menschlichen Ohrs zur Personenauthentifizierung an IT-Systemen mittels CNNs\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bibliotheken importieren\n",
    "\n",
    "Zunächst werden alle notwendigen Bibliothken importiert\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Import Libearies ##\n",
    "%matplotlib inline\n",
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import pandas as pd\n",
    "import os\n",
    "\n",
    "# Import TORCHVISION with popular datasets, model architectures, \n",
    "# and common image transformations for computer vision\n",
    "from torchvision import transforms\n",
    "import torchvision\n",
    "import torchvision.utils\n",
    "import torchvision.models as models\n",
    "import torchsummary\n",
    "\n",
    "# Import Debugging method for set_trace\n",
    "from IPython.core.debugger import set_trace\n",
    "import logging\n",
    "\n",
    "# Import Time Features\n",
    "import datetime\n",
    "import time\n",
    "\n",
    "# Import TORCH for Data-Structures for multi-dimensional tensors \n",
    "# and mathematical operations\n",
    "import torch\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.optim as optim\n",
    "import torch_utils\n",
    "#import python_utils\n",
    "#import utils\n",
    "#from ignite.metrics import EpochMetric \n",
    "\n",
    "# Import Winsound to play a *.wav-File\n",
    "# and Counter for counting numbers in an array\n",
    "import winsound\n",
    "from collections import Counter\n",
    "\n",
    "# Import Random Libery\n",
    "import random\n",
    "from random import shuffle\n",
    "\n",
    "# Import IPYWIDGET for interactive HTML widgets for Jupyter notebooks\n",
    "import ipywidgets as wg\n",
    "from IPython.display import display\n",
    "\n",
    "# Import PYTORCH LIGHTNING as a PyTorch research framework\n",
    "from pytorch_lightning.metrics.classification import ROC, F1 \n",
    "from pytorch_lightning.metrics.functional.classification import multiclass_auroc\n",
    "#from pytorch_lightning.metrics import Precision, functional, Recall\n",
    "from pytorch_lightning.metrics.functional.classification import auc, auroc, multiclass_roc, f1_score\n",
    "from  pytorch_lightning.metrics.utils import to_onehot\n",
    "\n",
    "from pytorch_lightning.metrics.functional import roc\n",
    "#from pytorch_lightning.metrics.functional import precision_recall_curve\n",
    "from pytorch_lightning.metrics import Accuracy\n",
    "from pytorch_lightning.metrics.classification import AveragePrecision\n",
    "\n",
    "\n",
    "# Import ScikitLearn for AUC-Score\n",
    "#from sklearn.metrics import roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Festlegung: Prozessor oder Graphikkarte\n",
    "\n",
    "Falls NVIDIA-Graphikkarte und CUDA vorhanden ist, dann wird die GPU für Berechnungen genutzt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# Read Device: Choose CUDA, if NVIDIA GPU is avaiabel\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Voreinstellungen - Hilfsfunktionen\n",
    "\n",
    "* **secs_to_HMS():** Berechnte Sekunden in HH:MM:SS um\n",
    "* **WaitTime_Finished():** Gibt eine Audio-Datei aus, wenn Training und Testen beendet ist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Convert Seconds to Hours, Minutes and Seconds ##\n",
    "def secs_to_HMS(secs):\n",
    "    if (secs < 3600):\n",
    "        return datetime.datetime.fromtimestamp(secs).strftime('%M:%S'), \"[MM:SS]\"\n",
    "    else:\n",
    "        return datetime.datetime.fromtimestamp(secs).strftime('%H:%M:%S'), \"[HH:MM:SS]\"\n",
    "\n",
    "## Acustic Sound if Model-Trainings finished ##\n",
    "def WaitTime_Finished():\n",
    "    for i in range(2):\n",
    "        files=os.listdir(\"Sound/\")\n",
    "        file=random.choice(files)\n",
    "        winsound.PlaySound(\"Sound/\"+str(file), winsound.SND_FILENAME)\n",
    "        time.sleep(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funtionen um Datensätze festzulegen, einzulesen und anzuzeigen\n",
    "\n",
    "* **ChooseDir():**             return: Datensatz-Verzeichnis und Datensatz-String  \n",
    "* **Show_Dataset_Picture():**  Zeigt erstes Bild eines Datensatzes\n",
    "* **Create_Dataset():**        Erzeugt Datensatz-Arrays für Training und Testen\n",
    "* **Create_Dataset():**        Erzeugt erweiterte Datensatz-Arrays für Training und Testen\n",
    "\n",
    "\n",
    "Hinweis: Nur 20 Probanden des AMI-Datensatzes sind in den Datenätzen vorhanden. Mehr konnte bei Git nicht hochgeladen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Indirect Path for Linux and Windows## \n",
    "def ChooseDir(datadir):\n",
    "    if(datadir == 'CP'):\n",
    "        return \"Datensaetze/CP\", \"CP\"\n",
    "    if(datadir == 'AMI'):\n",
    "        return \"Datensaetze/AMI\", \"AMI\"\n",
    "    if(datadir == 'AWE'):\n",
    "        return \"Datensaetze/AWE\", \"AWE\"\n",
    "    if(datadir == 'EarVN'):\n",
    "        return \"Datensaetze/EarVN_1_0\", \"EarVN_1_0\"\n",
    "    if(datadir == 'UERC'):\n",
    "        return \"Datensaetze/UERC\", \"UERC\"\n",
    "\n",
    "## Show first Picture of choosen Dataset    \n",
    "def Show_Dataset_Picture(datadir, categories):\n",
    "    for category in categories:\n",
    "        path = os.path.join(datadir, category)\n",
    "        for img in os.listdir(path):\n",
    "            img_array = cv2.imread(os.path.join(path, img))\n",
    "            plt.imshow(cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB))\n",
    "            plt.show()\n",
    "            break\n",
    "        break   \n",
    "        \n",
    "\n",
    "## Create normal Dataset \n",
    "def Create_Dataset(datadir, categories):\n",
    "    ## Transformer for Images ##\n",
    "    ## For PyTorch Models use: mean = [0.4318, 0.4660, 0.5889], std = [0.1752, 0.1893, 0.2096]\n",
    "    transformer = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "         transforms.Normalize((0.4318, 0.4660, 0.5889), (0.1752, 0.1893, 0.2096))\n",
    "        ])\n",
    "\n",
    "    ## Define Size of Images; \n",
    "    ## For PyTorch Models use: IMG_Size = 224 \n",
    "    IMG_SIZE = 224\n",
    "\n",
    "    ## Create normal dataset for all Databases and Categories \n",
    "    for category in categories:\n",
    "        ## Get path of each Category\n",
    "        path = os.path.join(datadir, category)\n",
    "        \n",
    "        ## Create class numbers for each Category\n",
    "        class_num = categories.index(category)\n",
    "        \n",
    "        ## Calculate train_share for Train- and Testdataset\n",
    "        count_train_share = (len(os.listdir(path)))*train_share\n",
    "        counter = 1\n",
    "        \n",
    "        ## Get all Images of current Category\n",
    "        os_listdir = os.listdir(path)\n",
    "        ## Sort the Pictures-Path of each category randomly\n",
    "        random.shuffle(os_listdir)\n",
    "\n",
    "        for img in os_listdir:\n",
    "            try:\n",
    "                ## Read, Resize, and Transform image\n",
    "                img_array = cv2.imread(os.path.join(path, img))\n",
    "                img_array = cv2.resize(img_array, (IMG_SIZE, IMG_SIZE))\n",
    "                img_array = transformer(img_array)\n",
    "                \n",
    "                ## Split Images to Train- and Test-Dataset-Array\n",
    "                if(counter <= count_train_share):\n",
    "                    dataset_train.append([img_array, class_num])\n",
    "                    counter += 1\n",
    "                else:\n",
    "                    dataset_test.append([img_array, class_num])\n",
    "            except Exception as e:\n",
    "                 pass\n",
    "    \n",
    "    ## Rondomly sortig dataset_train and dataset_test Arrays\n",
    "    random.shuffle(dataset_train)\n",
    "    random.shuffle(dataset_test)\n",
    "\n",
    "\n",
    "\n",
    "## Create expand Dataset    \n",
    "def Create_Dataset_Expand(datadir, categories):\n",
    "    ## Transformer for Images: ToTensor() ad Normalize \n",
    "    ## For PyTorch Models: to Normalize images use: mean = [0.4318, 0.4660, 0.5889], std = [0.1752, 0.1893, 0.2096]\n",
    "    transformer = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "         transforms.Normalize((0.4318, 0.4660, 0.5889), (0.1752, 0.1893, 0.2096)),\n",
    "        ])\n",
    "\n",
    "    ## Define Size of Images; \n",
    "    ## For PyTorch Models use: IMG_Size = 224 \n",
    "    IMG_SIZE = 224\n",
    "\n",
    "    ## Create expand  dataset for all Databases (except for: EarVN1.0 Database)\n",
    "    for i in range(4):\n",
    "        for category in categories:\n",
    "            ## Get path of each Category\n",
    "            path = os.path.join(datadir, category)\n",
    "            \n",
    "            ## Create class numbers for each Category\n",
    "            class_num = categories.index(category)\n",
    "            \n",
    "            ## Calculate train_share for Train- and Testdataset\n",
    "            count_train_share = round((len(os.listdir(path)))*train_share)\n",
    "            counter = 1\n",
    "            \n",
    "            ## Get all Images of current Category\n",
    "            os_listdir = os.listdir(path)\n",
    "            \n",
    "            ## Sort the Pictures-Path of each category randomly\n",
    "            random.shuffle(os_listdir)\n",
    "            \n",
    "            for img in os_listdir:\n",
    "                    ## Read, Resize, and Transform image\n",
    "                    img_array = cv2.imread(os.path.join(path, img))\n",
    "                    img_array = cv2.resize(img_array, (IMG_SIZE, IMG_SIZE))\n",
    "                     \n",
    "                    ## Rotate Image\n",
    "                    rows,cols,ch = img_array.shape\n",
    "                    rotate_numbers = [0, 90, 180, 270]\n",
    "                    rotate_number = rotate_numbers[i]\n",
    "                    M = cv2.getRotationMatrix2D(((cols-1)/2.0,(rows-1)/2.0),rotate_number,1) ## cols-1 and rows-1 are the coordinate limits.\n",
    "                    img_array = cv2.warpAffine(img_array,M,(cols,rows))\n",
    "                    \n",
    "                    ## Transform the img-Array\n",
    "                    img_array = transformer(img_array)\n",
    "                    \n",
    "                    ## Split Images to Train- and Test-Dataset-Array\n",
    "                    if(counter <= count_train_share):\n",
    "                        dataset_train.append([img_array, class_num])\n",
    "                        counter += 1\n",
    "                    else:\n",
    "                        dataset_test.append([img_array, class_num])\n",
    "    \n",
    "    ## Randomly sortig dataset_train and dataset_test Arrays\n",
    "    random.shuffle(dataset_train)\n",
    "    random.shuffle(dataset_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen um vortrainiertes Netzwerk festzulegen\n",
    "\n",
    "* **Network_Choice():** Gibt Netzwerk und Netzwerk-String zurück"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## All pretrained Networks from PyTorch ##\n",
    "\n",
    "network_name = 'nix'\n",
    "\n",
    "# Function to choose network\n",
    "# return: pretrained Network, Name of Network\n",
    "def Network_Choice(netw):    \n",
    "    if(netw == 'vgg11'):\n",
    "        return models.vgg11(pretrained=True).to(DEVICE), \"VGG11\"\n",
    "    if(netw == 'vgg11bn'):\n",
    "        return models.vgg11_bn(pretrained=True).to(DEVICE), \"VGG11bn\"\n",
    "    if(netw == 'resnet18'):\n",
    "        return models.resnet18(pretrained=True).to(DEVICE), \"ResNet18\"\n",
    "    if(netw == 'resnet34'):\n",
    "        return models.resnet34(pretrained=True).to(DEVICE), \"ResNet34\"\n",
    "    if(netw == 'alexnet'):\n",
    "        return models.alexnet(pretrained=True).to(DEVICE), \"AlexNet\"\n",
    "    if(netw == 'squeezenet1_0'):\n",
    "        return models.squeezenet1_0(pretrained=True).to(DEVICE), \"SqueezeNet-1-0\"  \n",
    "    if(netw == 'GoogLeNet'):\n",
    "        return models.googlenet(pretrained=True).to(DEVICE), \"GoogLeNet\" \n",
    "    if(netw == 'shufflenet_v2_x0_5'):\n",
    "        return models.shufflenet_v2_x0_5(pretrained=True).to(DEVICE), \"Shufflenet-v2-x0_5\"  \n",
    "    if(netw == 'resnext101_32x8d'):\n",
    "        return models.resnext101_32x8d(pretrained=True).to(DEVICE), \"Resnext101-32x8d\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen für die Ausgabe von Ohrbildern und dazugehöriger Labels\n",
    "\n",
    "* **imshow():** Zeigt Bild\n",
    "* **matplotlib_imshow():** Ordnet 4 Ohrbilder mit dazugehörigem Label an"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions to show an image\n",
    "\n",
    "# Inverse the transformation of the images\n",
    "invTrans = transforms.Compose([ transforms.Normalize(mean = [ 0., 0., 0. ],\n",
    "                                                     std = [ 1/0.1752, 1/0.1893, 1/0.2096 ]),\n",
    "                                transforms.Normalize(mean = [ -0.4318, -0.4660, -0.5889 ],\n",
    "                                                     std = [ 1., 1., 1. ]),\n",
    "                               ])\n",
    "\n",
    "def imshow(img):\n",
    "    img = invTrans(img)\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()\n",
    "    \n",
    "# helper function to show an image\n",
    "# (used in the `plot_classes_preds` function below)\n",
    "def matplotlib_imshow(img, one_channel=False):\n",
    "    #set_trace()\n",
    "    img = invTrans(img)      # unnormalize\n",
    "    if one_channel:\n",
    "        img = img.mean(dim=0)\n",
    "    npimg = img.numpy()\n",
    "    #set_trace()\n",
    "    if one_channel:\n",
    "        plt.imshow(npimg)        \n",
    "    else:\n",
    "        plt.imshow(np.transpose(npimg, (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Klasse zur Berechnung von Top-1 und Top-5 Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Class of Top-1 and Top-5 Accuracy\n",
    "class AvgrageMeter(object):\n",
    "\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.cnt = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.sum += val * n\n",
    "        self.cnt += n\n",
    "        self.avg = self.sum / self.cnt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accuracy jeder Kategorie in Log-File (TXT-File)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Write Accuracy of every Categorie to Log-Files (TXT-File) ##\n",
    "def Write_Each_Categorie_Acc_To_Editor(database, net, acc_per_categorie):\n",
    "    logfile_path = './Log_Files/' + database + '/' + str(current_time) + '_' + net + '.txt'\n",
    "    datei = open(logfile_path, 'a')\n",
    "    datei.write(acc_per_categorie)\n",
    "    datei.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Konfiguration\n",
    "\n",
    "Auswahl von: \n",
    "* Datensatz\n",
    "* Netzwerk\n",
    "* Normaler/Erweiterter Datensatz\n",
    "* Trainshare\n",
    "* Batch Size Train\n",
    "* Batch Size Test\n",
    "* Learning Rate\n",
    "* Momentum\n",
    "\n",
    "Hinweis: Konfiguration ausführen, Auswahl festlegen und weiter zum nächsten Abschnitt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "03acf4dac0f945c6b10f19c9efda3ed6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Dataset:', index=1, options=('CP', 'AMI', 'AWE', 'EarVN', 'UERC'), value='AMI')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4c28430bc0714174bf0b1de6587f8f3c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Network:', options=('vgg11', 'vgg11bn', 'resnet18', 'resnet34', 'alexnet', 'squeezenet1_…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "33ae1c0ce7ba43948f1a5160cc709d64",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Normal/Exp:', options=('Normal_Network', 'Expand_Network'), value='Normal_Network')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d71b8c9fbc4f42b9849f82d148e22656",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "BoundedFloatText(value=0.8, description='Trainshare:', max=1.0, step=0.1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6792a002f8ff43d794f7833ecbb0eddf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "BoundedIntText(value=4, description='Batch_Train:', min=1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "99ed5d89518c49acb526ea652ffbf8e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "BoundedIntText(value=4, description='Batch_Test:', min=1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "72cfe0750b3f4adcafad0cd48d4ad42d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "BoundedFloatText(value=0.001, description='Learning_Rate', max=1.0, step=0.0001)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "16ffa6aca9b84fb4852949a9b1ba39ad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "BoundedFloatText(value=0.8, description='Momentum: ', max=1.0, step=0.1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Choose Dataset\n",
    "datadir_choose = wg.Dropdown(\n",
    "     options=['CP', 'AMI', 'AWE', 'EarVN', 'UERC'],\n",
    "     value='AMI',\n",
    "     description='Dataset:',\n",
    "     disabled=False,\n",
    "     button_style=''\n",
    ")\n",
    "\n",
    "## Choose Network\n",
    "network_string_choose = wg.Dropdown(\n",
    "     options=['vgg11','vgg11bn','resnet18','resnet34','alexnet','squeezenet1_0','GoogLeNet','shufflenet_v2_x0_5','resnext101_32x8d', 'siamese'],\n",
    "     value='vgg11',\n",
    "     description='Network:',\n",
    "     disabled=False,\n",
    "     button_style=''\n",
    ")\n",
    "\n",
    "## Choose Normal or expand network\n",
    "normal_expand_string_choose = wg.Dropdown(\n",
    "     options=['Normal_Network', 'Expand_Network'],\n",
    "     value='Normal_Network',\n",
    "     description='Normal/Exp:',\n",
    "     disabled=False,\n",
    "     button_style=''\n",
    ")\n",
    "\n",
    "## Choose Trainshare\n",
    "trainshare_choose = wg.BoundedFloatText(\n",
    "     value=0.8,\n",
    "     min=0,\n",
    "     max=1,\n",
    "     step=0.1,\n",
    "     description='Trainshare:',\n",
    "     disabled=False\n",
    ")\n",
    "\n",
    "## Choose Batch_Size for Training\n",
    "batch_train = wg.BoundedIntText(\n",
    "     value=4,\n",
    "     min=1,\n",
    "     max=100,\n",
    "     step=1,\n",
    "     description='Batch_Train:',\n",
    "     disabled=False\n",
    ")\n",
    "\n",
    "## Choose Batch_Size for Testing\n",
    "batch_test = wg.BoundedIntText(\n",
    "     value=4,\n",
    "     min=1,\n",
    "     max=100,\n",
    "     step=1,\n",
    "     description='Batch_Test:',\n",
    "     disabled=False\n",
    ")\n",
    "\n",
    "## Choose Learning-Rate\n",
    "learning_rate_choose = wg.BoundedFloatText(\n",
    "     value=0.001,\n",
    "     min=0,\n",
    "     max=1,\n",
    "     step=0.0001,\n",
    "     description='Learning_Rate',\n",
    "     disabled=False\n",
    ")\n",
    "\n",
    "## Choose \n",
    "momentum_choose = wg.BoundedFloatText(\n",
    "     value=0.8,\n",
    "     min=0,\n",
    "     max=1,\n",
    "     step=0.1,\n",
    "     description='Momentum: ',\n",
    "     disabled=False\n",
    ")\n",
    "\n",
    "\n",
    "display(datadir_choose, network_string_choose, normal_expand_string_choose, trainshare_choose, batch_train, batch_test, learning_rate_choose, momentum_choose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datensatz generieren\n",
    "\n",
    "Mit den bereits beschriebenen Funktionen werden alle Einstellungen ausgelesen und ein Datensatz, sowie die Kategorien eingelesen\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Arrays for Dataset and Categories ##\n",
    "dataset_train = []\n",
    "dataset_test = []\n",
    "CATEGORIES = []\n",
    "img_array = []\n",
    "\n",
    "## Read all choosen \n",
    "datadir = datadir_choose.value\n",
    "network_string = network_string_choose.value\n",
    "normal_expand = normal_expand_string_choose.value\n",
    "train_share = trainshare_choose.value\n",
    "batch_size_train = batch_train.value\n",
    "batch_size_test = batch_test.value\n",
    "learning_rate = learning_rate_choose.value\n",
    "momentum = momentum_choose.value\n",
    "\n",
    "\n",
    "## Choose Datadirectory to the Dataset ##\n",
    "DATADIR, Database = ChooseDir(datadir)\n",
    "\n",
    "## Read and list all Categories of a Dataset \n",
    "CATEGORIES = os.listdir(DATADIR)\n",
    "\n",
    "## Get Length of Categories for chosen Dataset \n",
    "len_classes = len(CATEGORIES)\n",
    "\n",
    "## Create Dataset for Training and Testing\n",
    "if(normal_expand == 'Normal_Network'):\n",
    "    Create_Dataset(DATADIR, CATEGORIES)\n",
    "elif(normal_expand == 'Expand_Network'):\n",
    "    Create_Dataset_Expand(DATADIR, CATEGORIES)\n",
    "else:\n",
    "    print('False: Choosen Normal/Expand')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Einstellungen Anzeigen\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datensatz: AMI\n",
      "\n",
      "Anzahl der Bilder insgesamt:\t 140\n",
      "Anzahl der Trainingsdatensätze:\t 100\n",
      "Anzahl der Testdatensätze:\t 40\n",
      "\n",
      "Kategorien: ['000', '001', '002', '003', '004', '005', '007', '008', '009', '010', '011', '012', '013', '014', '018', '019', '020', '026', '027', '028']\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "## Show first picture of the choosen Dataset\n",
    "Show_Dataset_Picture(DATADIR, CATEGORIES)\n",
    "\n",
    "print(f'Datensatz: {Database}')\n",
    "print(f'\\nAnzahl der Bilder insgesamt:\\t {len(dataset_train)+len(dataset_test)}')\n",
    "print(f\"Anzahl der Trainingsdatensätze:\\t {len(dataset_train)}\")\n",
    "print(f\"Anzahl der Testdatensätze:\\t {len(dataset_test)}\")\n",
    "print(f'\\nKategorien: {CATEGORIES}')\n",
    "print(f'{len(CATEGORIES)}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train- und Testloader festlegen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Create Train-DataLoader\n",
    "train_loader = DataLoader(dataset_train, batch_size=batch_size_train, shuffle=True)\n",
    "\n",
    "## Create Test-DataLoader\n",
    "test_loader = DataLoader(dataset_test, batch_size=batch_size_test, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Netzwerk festlegen\n",
    "\n",
    "Legt Netzwerk fest und zeigt die Übersicht der Netzwerk-Struktur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VGG11\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv2d-1         [-1, 64, 224, 224]           1,792\n",
      "              ReLU-2         [-1, 64, 224, 224]               0\n",
      "         MaxPool2d-3         [-1, 64, 112, 112]               0\n",
      "            Conv2d-4        [-1, 128, 112, 112]          73,856\n",
      "              ReLU-5        [-1, 128, 112, 112]               0\n",
      "         MaxPool2d-6          [-1, 128, 56, 56]               0\n",
      "            Conv2d-7          [-1, 256, 56, 56]         295,168\n",
      "              ReLU-8          [-1, 256, 56, 56]               0\n",
      "            Conv2d-9          [-1, 256, 56, 56]         590,080\n",
      "             ReLU-10          [-1, 256, 56, 56]               0\n",
      "        MaxPool2d-11          [-1, 256, 28, 28]               0\n",
      "           Conv2d-12          [-1, 512, 28, 28]       1,180,160\n",
      "             ReLU-13          [-1, 512, 28, 28]               0\n",
      "           Conv2d-14          [-1, 512, 28, 28]       2,359,808\n",
      "             ReLU-15          [-1, 512, 28, 28]               0\n",
      "        MaxPool2d-16          [-1, 512, 14, 14]               0\n",
      "           Conv2d-17          [-1, 512, 14, 14]       2,359,808\n",
      "             ReLU-18          [-1, 512, 14, 14]               0\n",
      "           Conv2d-19          [-1, 512, 14, 14]       2,359,808\n",
      "             ReLU-20          [-1, 512, 14, 14]               0\n",
      "        MaxPool2d-21            [-1, 512, 7, 7]               0\n",
      "AdaptiveAvgPool2d-22            [-1, 512, 7, 7]               0\n",
      "           Linear-23                 [-1, 4096]     102,764,544\n",
      "             ReLU-24                 [-1, 4096]               0\n",
      "          Dropout-25                 [-1, 4096]               0\n",
      "           Linear-26                 [-1, 4096]      16,781,312\n",
      "             ReLU-27                 [-1, 4096]               0\n",
      "          Dropout-28                 [-1, 4096]               0\n",
      "           Linear-29                 [-1, 1000]       4,097,000\n",
      "================================================================\n",
      "Total params: 132,863,336\n",
      "Trainable params: 132,863,336\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.57\n",
      "Forward/backward pass size (MB): 125.37\n",
      "Params size (MB): 506.83\n",
      "Estimated Total Size (MB): 632.78\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "## Get choosen Network and Network-Name\n",
    "network, network_name = Network_Choice(network_string)\n",
    "print(network_name)\n",
    "\n",
    "## Show Network-Archticture with all Layers and Number of Parameters\n",
    "torchsummary.summary(network, (3, 224, 224), device=DEVICE.type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Festlegung des eindeutigen Stempels\n",
    "\n",
    "Eindeutiger Stempel mit Uhrzeit, um CSV-, TXT- und Log-Files wiederzuerkennen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021_02_27-21_22_49\n"
     ]
    }
   ],
   "source": [
    "## Use actual Time for individual Stamp ##\n",
    "current_time = datetime.datetime.now().strftime(\"%Y_%m_%d-%H_%M_%S\")\n",
    "print(current_time)\n",
    "\n",
    "## Unique Stamp for the identification of networks, graphs, train- and Testdata\n",
    "stamp = current_time + '_' + Database + '_' + network_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Festlegung 'writer' für Tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer = SummaryWriter('runs/' + current_time + '_' + Database + '_' + network_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Festlegung von Optimizer und Loss-Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Choose SGD (Stochastic Gradient Descent) as optimizer\n",
    "optimizer = optim.SGD(network.parameters(), lr=learning_rate, momentum=momentum)\n",
    "## Choose CrossEntropyLoss as Loss\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anzeige von 4 Ohren des gewählten Datensatzes mit jeweiligem Label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  014   009   011   004\n"
     ]
    }
   ],
   "source": [
    "## Get random images from Trainloader\n",
    "dataiter = iter(train_loader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "## show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "## print labels\n",
    "print(' '.join('%5s' % CATEGORIES[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Durchführung des Trainings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start Training um:  21:22:52\n",
      "\n",
      "Epoch 1:\n",
      "[1, 2]: loss: 9.865, \t Running_Correct: 0.000\n",
      "[1, 4]: loss: 7.968, \t Running_Correct: 0.000\n",
      "[1, 6]: loss: 5.690, \t Running_Correct: 0.000\n",
      "[1, 8]: loss: 5.712, \t Running_Correct: 0.000\n",
      "[1, 10]: loss: 5.761, \t Running_Correct: 0.000\n",
      "[1, 12]: loss: 4.737, \t Running_Correct: 0.000\n",
      "[1, 14]: loss: 3.476, \t Running_Correct: 0.500\n",
      "[1, 16]: loss: 5.120, \t Running_Correct: 0.000\n",
      "[1, 18]: loss: 5.714, \t Running_Correct: 0.500\n",
      "[1, 20]: loss: 4.876, \t Running_Correct: 0.000\n",
      "[1, 22]: loss: 3.751, \t Running_Correct: 0.000\n",
      "[1, 24]: loss: 4.292, \t Running_Correct: 1.500\n",
      "\n",
      "Epoch 2:\n",
      "[2, 2]: loss: 4.078, \t Running_Correct: 0.500\n",
      "[2, 4]: loss: 2.458, \t Running_Correct: 1.500\n",
      "[2, 6]: loss: 2.992, \t Running_Correct: 1.500\n",
      "[2, 8]: loss: 2.615, \t Running_Correct: 0.500\n",
      "[2, 10]: loss: 3.510, \t Running_Correct: 1.500\n",
      "[2, 12]: loss: 4.087, \t Running_Correct: 0.000\n",
      "[2, 14]: loss: 2.451, \t Running_Correct: 1.500\n",
      "[2, 16]: loss: 3.023, \t Running_Correct: 0.500\n",
      "[2, 18]: loss: 2.056, \t Running_Correct: 2.000\n",
      "[2, 20]: loss: 3.019, \t Running_Correct: 0.000\n",
      "[2, 22]: loss: 2.386, \t Running_Correct: 1.000\n",
      "[2, 24]: loss: 2.218, \t Running_Correct: 1.000\n",
      "\n",
      "Epoch 3:\n",
      "[3, 2]: loss: 2.589, \t Running_Correct: 1.000\n",
      "[3, 4]: loss: 2.130, \t Running_Correct: 1.500\n",
      "[3, 6]: loss: 1.970, \t Running_Correct: 1.500\n",
      "[3, 8]: loss: 1.701, \t Running_Correct: 1.000\n",
      "[3, 10]: loss: 2.226, \t Running_Correct: 1.500\n",
      "[3, 12]: loss: 2.392, \t Running_Correct: 1.500\n",
      "[3, 14]: loss: 1.832, \t Running_Correct: 1.000\n",
      "[3, 16]: loss: 1.451, \t Running_Correct: 2.000\n",
      "[3, 18]: loss: 1.218, \t Running_Correct: 1.500\n",
      "[3, 20]: loss: 1.221, \t Running_Correct: 2.500\n",
      "[3, 22]: loss: 1.429, \t Running_Correct: 2.500\n",
      "[3, 24]: loss: 1.765, \t Running_Correct: 1.500\n",
      "\n",
      "Epoch 4:\n",
      "[4, 2]: loss: 0.289, \t Running_Correct: 4.000\n",
      "[4, 4]: loss: 0.272, \t Running_Correct: 3.500\n",
      "[4, 6]: loss: 0.624, \t Running_Correct: 3.000\n",
      "[4, 8]: loss: 0.885, \t Running_Correct: 3.000\n",
      "[4, 10]: loss: 0.775, \t Running_Correct: 2.500\n",
      "[4, 12]: loss: 1.037, \t Running_Correct: 2.500\n",
      "[4, 14]: loss: 1.357, \t Running_Correct: 2.500\n",
      "[4, 16]: loss: 0.908, \t Running_Correct: 2.500\n",
      "[4, 18]: loss: 0.882, \t Running_Correct: 3.000\n",
      "[4, 20]: loss: 0.604, \t Running_Correct: 3.500\n",
      "[4, 22]: loss: 0.439, \t Running_Correct: 3.500\n",
      "[4, 24]: loss: 0.416, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 5:\n",
      "[5, 2]: loss: 0.538, \t Running_Correct: 3.500\n",
      "[5, 4]: loss: 0.313, \t Running_Correct: 3.500\n",
      "[5, 6]: loss: 0.286, \t Running_Correct: 4.000\n",
      "[5, 8]: loss: 0.367, \t Running_Correct: 3.500\n",
      "[5, 10]: loss: 0.350, \t Running_Correct: 3.500\n",
      "[5, 12]: loss: 0.999, \t Running_Correct: 2.500\n",
      "[5, 14]: loss: 0.664, \t Running_Correct: 3.000\n",
      "[5, 16]: loss: 0.100, \t Running_Correct: 4.000\n",
      "[5, 18]: loss: 0.754, \t Running_Correct: 3.000\n",
      "[5, 20]: loss: 0.759, \t Running_Correct: 3.000\n",
      "[5, 22]: loss: 0.711, \t Running_Correct: 2.000\n",
      "[5, 24]: loss: 0.471, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 6:\n",
      "[6, 2]: loss: 0.281, \t Running_Correct: 4.000\n",
      "[6, 4]: loss: 0.529, \t Running_Correct: 3.500\n",
      "[6, 6]: loss: 0.416, \t Running_Correct: 3.500\n",
      "[6, 8]: loss: 0.218, \t Running_Correct: 3.500\n",
      "[6, 10]: loss: 0.917, \t Running_Correct: 3.500\n",
      "[6, 12]: loss: 1.952, \t Running_Correct: 2.500\n",
      "[6, 14]: loss: 0.185, \t Running_Correct: 4.000\n",
      "[6, 16]: loss: 0.771, \t Running_Correct: 3.000\n",
      "[6, 18]: loss: 0.558, \t Running_Correct: 3.500\n",
      "[6, 20]: loss: 0.315, \t Running_Correct: 3.500\n",
      "[6, 22]: loss: 0.167, \t Running_Correct: 4.000\n",
      "[6, 24]: loss: 0.531, \t Running_Correct: 3.500\n",
      "\n",
      "Epoch 7:\n",
      "[7, 2]: loss: 0.215, \t Running_Correct: 4.000\n",
      "[7, 4]: loss: 0.131, \t Running_Correct: 4.000\n",
      "[7, 6]: loss: 0.250, \t Running_Correct: 3.500\n",
      "[7, 8]: loss: 0.140, \t Running_Correct: 4.000\n",
      "[7, 10]: loss: 0.141, \t Running_Correct: 4.000\n",
      "[7, 12]: loss: 0.274, \t Running_Correct: 3.500\n",
      "[7, 14]: loss: 0.018, \t Running_Correct: 4.000\n",
      "[7, 16]: loss: 0.213, \t Running_Correct: 3.500\n",
      "[7, 18]: loss: 0.039, \t Running_Correct: 4.000\n",
      "[7, 20]: loss: 0.145, \t Running_Correct: 4.000\n",
      "[7, 22]: loss: 0.024, \t Running_Correct: 4.000\n",
      "[7, 24]: loss: 0.013, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 8:\n",
      "[8, 2]: loss: 0.029, \t Running_Correct: 4.000\n",
      "[8, 4]: loss: 0.537, \t Running_Correct: 3.500\n",
      "[8, 6]: loss: 0.206, \t Running_Correct: 3.500\n",
      "[8, 8]: loss: 0.108, \t Running_Correct: 4.000\n",
      "[8, 10]: loss: 0.076, \t Running_Correct: 4.000\n",
      "[8, 12]: loss: 0.019, \t Running_Correct: 4.000\n",
      "[8, 14]: loss: 0.848, \t Running_Correct: 3.000\n",
      "[8, 16]: loss: 1.830, \t Running_Correct: 2.500\n",
      "[8, 18]: loss: 1.012, \t Running_Correct: 3.500\n",
      "[8, 20]: loss: 0.529, \t Running_Correct: 3.500\n",
      "[8, 22]: loss: 1.194, \t Running_Correct: 2.500\n",
      "[8, 24]: loss: 0.835, \t Running_Correct: 3.500\n",
      "\n",
      "Epoch 9:\n",
      "[9, 2]: loss: 0.199, \t Running_Correct: 4.000\n",
      "[9, 4]: loss: 0.114, \t Running_Correct: 4.000\n",
      "[9, 6]: loss: 0.208, \t Running_Correct: 3.500\n",
      "[9, 8]: loss: 0.101, \t Running_Correct: 4.000\n",
      "[9, 10]: loss: 0.197, \t Running_Correct: 3.500\n",
      "[9, 12]: loss: 0.178, \t Running_Correct: 4.000\n",
      "[9, 14]: loss: 0.021, \t Running_Correct: 4.000\n",
      "[9, 16]: loss: 0.116, \t Running_Correct: 4.000\n",
      "[9, 18]: loss: 0.101, \t Running_Correct: 4.000\n",
      "[9, 20]: loss: 0.032, \t Running_Correct: 4.000\n",
      "[9, 22]: loss: 0.170, \t Running_Correct: 3.500\n",
      "[9, 24]: loss: 0.245, \t Running_Correct: 3.500\n",
      "\n",
      "Epoch 10:\n",
      "[10, 2]: loss: 0.029, \t Running_Correct: 4.000\n",
      "[10, 4]: loss: 0.011, \t Running_Correct: 4.000\n",
      "[10, 6]: loss: 0.048, \t Running_Correct: 4.000\n",
      "[10, 8]: loss: 0.010, \t Running_Correct: 4.000\n",
      "[10, 10]: loss: 0.018, \t Running_Correct: 4.000\n",
      "[10, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[10, 14]: loss: 0.042, \t Running_Correct: 4.000\n",
      "[10, 16]: loss: 0.033, \t Running_Correct: 4.000\n",
      "[10, 18]: loss: 0.009, \t Running_Correct: 4.000\n",
      "[10, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[10, 22]: loss: 0.009, \t Running_Correct: 4.000\n",
      "[10, 24]: loss: 0.002, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 11:\n",
      "[11, 2]: loss: 0.007, \t Running_Correct: 4.000\n",
      "[11, 4]: loss: 0.019, \t Running_Correct: 4.000\n",
      "[11, 6]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[11, 8]: loss: 0.011, \t Running_Correct: 4.000\n",
      "[11, 10]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[11, 12]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[11, 14]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[11, 16]: loss: 0.006, \t Running_Correct: 4.000\n",
      "[11, 18]: loss: 0.032, \t Running_Correct: 4.000\n",
      "[11, 20]: loss: 0.055, \t Running_Correct: 4.000\n",
      "[11, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[11, 24]: loss: 0.016, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 12:\n",
      "[12, 2]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[12, 4]: loss: 0.041, \t Running_Correct: 4.000\n",
      "[12, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[12, 8]: loss: 0.008, \t Running_Correct: 4.000\n",
      "[12, 10]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[12, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[12, 14]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[12, 16]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[12, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[12, 20]: loss: 0.005, \t Running_Correct: 4.000\n",
      "[12, 22]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[12, 24]: loss: 0.002, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 13:\n",
      "[13, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[13, 4]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[13, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[13, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[13, 10]: loss: 0.010, \t Running_Correct: 4.000\n",
      "[13, 12]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[13, 14]: loss: 0.006, \t Running_Correct: 4.000\n",
      "[13, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[13, 18]: loss: 0.007, \t Running_Correct: 4.000\n",
      "[13, 20]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[13, 22]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[13, 24]: loss: 0.008, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 14:\n",
      "[14, 2]: loss: 0.008, \t Running_Correct: 4.000\n",
      "[14, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[14, 6]: loss: 0.009, \t Running_Correct: 4.000\n",
      "[14, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[14, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[14, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[14, 14]: loss: 0.013, \t Running_Correct: 4.000\n",
      "[14, 16]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[14, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[14, 20]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[14, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[14, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 15:\n",
      "[15, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[15, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[15, 6]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[15, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[15, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[15, 12]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[15, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[15, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[15, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[15, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[15, 22]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[15, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 16:\n",
      "[16, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[16, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[16, 6]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[16, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[16, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[16, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[16, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[16, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[16, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[16, 20]: loss: 0.005, \t Running_Correct: 4.000\n",
      "[16, 22]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[16, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 17:\n",
      "[17, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[17, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[17, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[17, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[17, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[17, 12]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[17, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[17, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[17, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[17, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[17, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[17, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 18:\n",
      "[18, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[18, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[18, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[18, 8]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[18, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[18, 12]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[18, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[18, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[18, 18]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[18, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[18, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[18, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 19:\n",
      "[19, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[19, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[19, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[19, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[19, 10]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[19, 12]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[19, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[19, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[19, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[19, 20]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[19, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[19, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 20:\n",
      "[20, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[20, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[20, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[20, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[20, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[20, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[20, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[20, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[20, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[20, 20]: loss: 0.006, \t Running_Correct: 4.000\n",
      "[20, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[20, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 21:\n",
      "[21, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[21, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[21, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[21, 8]: loss: 0.006, \t Running_Correct: 4.000\n",
      "[21, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[21, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[21, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[21, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[21, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[21, 20]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[21, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[21, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 22:\n",
      "[22, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[22, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[22, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[22, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[22, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[22, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[22, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[22, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[22, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[22, 20]: loss: 0.007, \t Running_Correct: 4.000\n",
      "[22, 22]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[22, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 23:\n",
      "[23, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[23, 4]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[23, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[23, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[23, 10]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[23, 12]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[23, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[23, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[23, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[23, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[23, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[23, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 24:\n",
      "[24, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[24, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[24, 6]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[24, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[24, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[24, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[24, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[24, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[24, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[24, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[24, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[24, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 25:\n",
      "[25, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[25, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[25, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[25, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[25, 10]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[25, 12]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[25, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[25, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[25, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[25, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[25, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[25, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 26:\n",
      "[26, 2]: loss: 0.006, \t Running_Correct: 4.000\n",
      "[26, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[26, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[26, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[26, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[26, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[26, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[26, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[26, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[26, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[26, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[26, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 27:\n",
      "[27, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[27, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[27, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[27, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[27, 10]: loss: 0.005, \t Running_Correct: 4.000\n",
      "[27, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[27, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[27, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[27, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[27, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[27, 22]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[27, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 28:\n",
      "[28, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[28, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[28, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 14]: loss: 0.005, \t Running_Correct: 4.000\n",
      "[28, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[28, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 29:\n",
      "[29, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[29, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[29, 6]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[29, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[29, 10]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[29, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[29, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[29, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[29, 18]: loss: 0.006, \t Running_Correct: 4.000\n",
      "[29, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[29, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[29, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 30:\n",
      "[30, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[30, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[30, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[30, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[30, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[30, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[30, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[30, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[30, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[30, 20]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[30, 22]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[30, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 31:\n",
      "[31, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[31, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[31, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[31, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[31, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[31, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[31, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[31, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[31, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[31, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[31, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[31, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 32:\n",
      "[32, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[32, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[32, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[32, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[32, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 33:\n",
      "[33, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[33, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[33, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[33, 8]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[33, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[33, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[33, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[33, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[33, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[33, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[33, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[33, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 34:\n",
      "[34, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[34, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 35:\n",
      "[35, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[35, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[35, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[35, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[35, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[35, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[35, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[35, 16]: loss: 0.005, \t Running_Correct: 4.000\n",
      "[35, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[35, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[35, 22]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[35, 24]: loss: 0.019, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 36:\n",
      "[36, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[36, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[36, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[36, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[36, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[36, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[36, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[36, 16]: loss: 0.003, \t Running_Correct: 4.000\n",
      "[36, 18]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[36, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[36, 22]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[36, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 37:\n",
      "[37, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[37, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[37, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[37, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[37, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[37, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[37, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[37, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[37, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[37, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[37, 22]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[37, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 38:\n",
      "[38, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[38, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[38, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[38, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[38, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 39:\n",
      "[39, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[39, 8]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[39, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[39, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 40:\n",
      "[40, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[40, 4]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[40, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[40, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[40, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[40, 12]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[40, 14]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[40, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[40, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[40, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[40, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[40, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 41:\n",
      "[41, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[41, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 42:\n",
      "[42, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 6]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[42, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[42, 24]: loss: 0.002, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 43:\n",
      "[43, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[43, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[43, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[43, 8]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[43, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[43, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[43, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[43, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[43, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[43, 20]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[43, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[43, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 44:\n",
      "[44, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 8]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[44, 10]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[44, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[44, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[44, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 45:\n",
      "[45, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[45, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[45, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 46:\n",
      "[46, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 16]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[46, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[46, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 47:\n",
      "[47, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[47, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 48:\n",
      "[48, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 8]: loss: 0.004, \t Running_Correct: 4.000\n",
      "[48, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 12]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[48, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[48, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 49:\n",
      "[49, 2]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 10]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[49, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 20]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[49, 24]: loss: 0.000, \t Running_Correct: 4.000\n",
      "\n",
      "Epoch 50:\n",
      "[50, 2]: loss: 0.001, \t Running_Correct: 4.000\n",
      "[50, 4]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 6]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 8]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 10]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 12]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 14]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 16]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 18]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 20]: loss: 0.002, \t Running_Correct: 4.000\n",
      "[50, 22]: loss: 0.000, \t Running_Correct: 4.000\n",
      "[50, 24]: loss: 0.001, \t Running_Correct: 4.000\n",
      "Ende  Training um:  21:23:57\n",
      "Dauer Training:  01:05   [MM:SS]  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "## Number of Epochs for training\n",
    "epoch_range = 50\n",
    "\n",
    "##Start Trainingtime\n",
    "print(\"Start Training um: \", time.strftime(\"%H:%M:%S\"))\n",
    "start_time = time.time()\n",
    "\n",
    "## Variables for Training\n",
    "write_loss_epoch = ''\n",
    "running_correct = 0\n",
    "cancel_train = 0\n",
    "predicted_roc = []\n",
    "\n",
    "## Train Network\n",
    "network.train()\n",
    "for epoch in range(epoch_range):  # loop over the dataset multiple times\n",
    "    \n",
    "    ## Reset for every epoch\n",
    "    running_loss = 0.0\n",
    "    running_correct = 0\n",
    "    print(f'\\nEpoch {epoch+1}:')\n",
    "    \n",
    "    for i, data in enumerate(train_loader):\n",
    "        ## Get the inputs and labels from data; data is a list of [inputs, labels]\n",
    "        inputs, labels = data\n",
    "        inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)\n",
    "\n",
    "        ## Zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        ## Calculate outputs\n",
    "        network.to(DEVICE)\n",
    "        outputs = network(inputs)\n",
    "        \n",
    "        ## Calculate loss,  Backpropagation and Optimize\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        ## Calulate running loss\n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        ## Get predicted value\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        \n",
    "        running_correct += (predicted == labels).sum().item()\n",
    "        mini_batches = round(len(train_loader)/10)\n",
    "        \n",
    "        if i % mini_batches == (mini_batches-1):\n",
    "            print(f'[{epoch + 1}, {i + 1}]: loss: {(running_loss/mini_batches):0.3f}, \\t Running_Correct: {(running_correct/mini_batches):0.3f}')#, \\n\\t\\t Top1-Acc: {top_1.avg}, \\n\\t\\t Top5-Acc: {top_5.avg}')\n",
    "           \n",
    "            ## Collect losses in Array\n",
    "            write_loss_epoch += '['+ str(epoch+1)+ ', ' + str(i+1) + '] \\t loss: ' + str(running_loss/mini_batches) + '\\n'\n",
    "            \n",
    "            \n",
    "            ## Write Training Loss and Training Accuracy log the running loss\n",
    "            writer.add_scalar('training loss', running_loss / (mini_batches), epoch * len(train_loader) + i)\n",
    "            writer.add_scalar('accuracy', (running_correct / mini_batches/4), epoch * len(train_loader) + i)\n",
    "    \n",
    "            ## Reset\n",
    "            running_loss = 0.0\n",
    "            running_correct = 0\n",
    "\n",
    "\n",
    "## Finished Training: Calculate Training Time\n",
    "print(\"Ende  Training um: \",time.strftime(\"%H:%M:%S\"))\n",
    "stop_time = time.time()\n",
    "time_dif, time_format = secs_to_HMS(stop_time-start_time)\n",
    "print(\"Dauer Training: \", time_dif, \" \", time_format, \" \\n\")\n",
    "\n",
    "## Acoustic Sound to call attention for finished Training\n",
    "WaitTime_Finished()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trainiertes Netzwerk speichern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Path for saving trained Network\n",
    "PATH = './Netzwerke/'+ current_time + '_' + Database + '_' + network_name + '_Train' + '.pth'\n",
    "\n",
    "## Save trained Network\n",
    "torch.save({\n",
    "            'epoch_range': epoch_range,\n",
    "            'model_state_dict': network.state_dict(),\n",
    "            'optimizer_state_dict': optimizer.state_dict(),\n",
    "            'running_loss': running_loss,\n",
    "            }, PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataiter = iter(train_loader)\n",
    "images, labels = dataiter.next()\n",
    "img_grid = torchvision.utils.make_grid(images)\n",
    "\n",
    "# write to tensorboard\n",
    "writer.add_image((current_time + '_' + Database + '_' + network_name), img_grid)\n",
    "writer.add_graph(network.cpu(), images)\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Durchführung Testen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset: AMI, \tNetzwerk: VGG11\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\wurhofer\\anaconda3\\envs\\Test\\lib\\site-packages\\pytorch_lightning\\utilities\\distributed.py:49: UserWarning: Metric `AveragePrecision` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n",
      "  warnings.warn(*args, **kwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy    of the network on the 40 test images: 92.50 %\n",
      "Acc_PyLig     of the network on the 40 test images: 92.50 %\n",
      "F1            of the network on the 40 test images: 92.50 \n",
      "F1_PyLig      of the network on the 40 test images: 92.5\n",
      "AUC_PyLig:    of the network on the 40 test images: 96.05\n",
      "Top1          of the network on the 40 test images: 92.50 %\n",
      "Top5          of the network on the 40 test images: 100.00 %\n",
      "\n",
      "Overview: Accuracy of each class:\n",
      "Accuracy of   000 :  0 %\n",
      "Accuracy of   001 : 100 %\n",
      "Accuracy of   002 : 100 %\n",
      "Accuracy of   003 : 100 %\n",
      "Accuracy of   004 : 100 %\n",
      "Accuracy of   005 : 100 %\n",
      "Accuracy of   007 : 100 %\n",
      "Accuracy of   008 : 100 %\n",
      "Accuracy of   009 : 100 %\n",
      "Accuracy of   010 : 100 %\n",
      "Accuracy of   011 : 100 %\n",
      "Accuracy of   012 : 100 %\n",
      "Accuracy of   013 : 100 %\n",
      "Accuracy of   014 :  0 %\n",
      "Accuracy of   018 : 100 %\n",
      "Accuracy of   019 : 50 %\n",
      "Accuracy of   020 : 50 %\n",
      "Accuracy of   026 : 100 %\n",
      "Accuracy of   027 : 100 %\n",
      "Accuracy of   028 : 100 %\n"
     ]
    }
   ],
   "source": [
    "## Define global Varibales\n",
    "correct = 0\n",
    "total = 0\n",
    "running_loss_test = 0\n",
    "class_correct = list(0. for i in range(len(CATEGORIES)))\n",
    "class_total = list(0. for i in range(len(CATEGORIES)))\n",
    "acc_single_categorie = ''\n",
    "class_probs = []\n",
    "class_preds = []\n",
    "pred_all = torch.tensor([], dtype=int)\n",
    "labels_all = torch.tensor([], dtype=int)\n",
    "top_1 = AvgrageMeter()\n",
    "top_5 = AvgrageMeter()\n",
    "precision_sum = 0\n",
    "recall_sum = 0\n",
    "f1_sum = 0\n",
    "top1_sum = 0\n",
    "top5_sum = 0\n",
    "it = 0\n",
    "len_classes = len(CATEGORIES)\n",
    "\n",
    "## Test Network\n",
    "network.eval()\n",
    "with torch.no_grad():\n",
    "    print(f'Dataset: {Database}, \\tNetzwerk: {network_name}')\n",
    "    \n",
    "    for i, data in enumerate(test_loader, 0):\n",
    "        \n",
    "        it += 1\n",
    "        ## Load images from Test-Loader and hand over to DEVICE\n",
    "        images, labels = data\n",
    "        images, labels = images.to(DEVICE), labels.to(DEVICE)\n",
    "        \n",
    "        ## Calculate the predicted outputs\n",
    "        network.to(DEVICE)\n",
    "        outputs = network(images)\n",
    "        class_probs_batch = [F.softmax(el, dim=0) for el in outputs]\n",
    "        \n",
    "        ## Calculate the Test-Loss\n",
    "        loss = criterion(outputs, labels)\n",
    "        running_loss_test += loss.item()\n",
    "        \n",
    "        ## Get predicted values\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        \n",
    "        ## Calculate the Total and Correct Test-Results\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "        c = (predicted == labels).squeeze()\n",
    "        \n",
    "        \n",
    "        ## Create a Tensor-Array with all Predicted-Values\n",
    "        pred_all = torch.cat([pred_all, predicted.cpu()])\n",
    "        ## Create a Tensor with all Label-Values\n",
    "        labels_all = torch.cat([labels_all, labels.cpu()])\n",
    "        \n",
    "        ## Create a Tensor-Array with all Predicted-Values for Tensorboard\n",
    "        class_probs.append(class_probs_batch)\n",
    "        class_preds.append(predicted) \n",
    "        test_probs = torch.cat([torch.stack(batch) for batch in class_probs])\n",
    "        test_preds = torch.cat(class_preds)\n",
    "        \n",
    "        \n",
    "        ## Calculate and update the Top-1 and Top-5 Accuracy\n",
    "        prec1, prec5 = torch_utils.accuracy(output=outputs, target=labels, top_k=(1, 5))\n",
    "        top_1.update(prec1.data, inputs.size(0))\n",
    "        top_5.update(prec5.data, inputs.size(0))\n",
    "\n",
    "        \n",
    "        ## Calculate F1-Score without OneHot \n",
    "        f1_score_t = F1(num_classes=len_classes, average='micro')\n",
    "        f1_score = f1_score_t(predicted.cpu(), labels.cpu())\n",
    "        f1_sum += f1_score \n",
    "        \n",
    "        \n",
    "        for i in range(3):\n",
    "            label = labels[i]\n",
    "            class_correct[label] += c[i].item()\n",
    "            class_total[label] += 1\n",
    "\n",
    "        \n",
    "        ## Write Test-Accuracy and Test-Loss to Tensorboard\n",
    "        writer.add_scalar('Test Accuracy',\n",
    "                          100 * correct / total,\n",
    "                          len(test_loader)+i)\n",
    "        writer.add_scalar('Test Loss',\n",
    "                           running_loss_test,\n",
    "                           len(test_loader) + i)\n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "## Calculate the Test-Acuracy with all Predicted-Values and Labels\n",
    "accuracy = Accuracy()\n",
    "acc_all_b = accuracy(pred_all, labels_all)\n",
    "acc_all = acc_all_b * 100\n",
    "\n",
    "## Calculate the F1-Score\n",
    "## with PyTorch-Lightning\n",
    "f1_score_t = F1(num_classes=len_classes, average='micro')\n",
    "f1_score = f1_score_t(pred_all.cpu(), labels_all.cpu())\n",
    "f1_score_all = 100 * f1_score\n",
    "\n",
    "\n",
    "## OneHot Function for all Predicted-Values\n",
    "preds_onehot = (F.one_hot(pred_all)).float()\n",
    "\n",
    "\n",
    "## Calculate the Mean-Value of the Precision\n",
    "## with PyTorch-Lightning\n",
    "average_precision = AveragePrecision(num_classes=len_classes)\n",
    "prec_avg = average_precision(preds_onehot, labels_all)\n",
    "prec_mean_t = torch.mean(torch.stack(prec_avg))\n",
    "prec_mean = 100 * prec_mean_t\n",
    "\n",
    "## Calculate the AUC-Value\n",
    "## with PyTorch-Lightning\n",
    "auroc = multiclass_auroc(pred=preds_onehot, target=labels_all, num_classes=len_classes)\n",
    "auroc_1 = 100 * auroc\n",
    "\n",
    "\n",
    "# Calculate finale Values without OneHot\n",
    "acc = 100 * correct / total\n",
    "f1_f = 100 * f1_sum /it\n",
    "top_1_f = float((top_1.avg).cpu().numpy())\n",
    "top_5_f = float((top_5.avg).cpu().numpy())\n",
    "acc = 100 * correct / total\n",
    "\n",
    "\n",
    "print(f\"\\nAccuracy    of the network on the {len(dataset_test)} test images: {acc:.2f} %\")\n",
    "print(f'Acc_PyLig     of the network on the {len(dataset_test)} test images: {acc_all:.2f} %')\n",
    "print(f\"F1            of the network on the {len(dataset_test)} test images: {f1_f:.2f} \")\n",
    "print(f'F1_PyLig      of the network on the {len(dataset_test)} test images: {f1_score_all}')\n",
    "print(f'AUC_PyLig:    of the network on the {len(dataset_test)} test images: {auroc_1:.2f}')\n",
    "print(f\"Top1          of the network on the {len(dataset_test)} test images: {top_1_f:.2f} %\")\n",
    "print(f\"Top5          of the network on the {len(dataset_test)} test images: {top_5_f:.2f} %\")\n",
    "\n",
    "\n",
    "## Overview: Accaurcy of every Categorie\n",
    "print(f\"\\nOverview: Accuracy of each class:\")\n",
    "for i in range(len(CATEGORIES)):\n",
    "    if(class_total[i]==0):\n",
    "        class_total[i] = 0.1\n",
    "    print('Accuracy of %5s : %2d %%' % (CATEGORIES[i], 100 * class_correct[i] / class_total[i]))\n",
    "    acc_single_categorie = 'Accuracy of\\t'+ CATEGORIES[i] + ':\\t\\t' + str(100 * class_correct[i] / class_total[i]) + '%\\n'\n",
    "    Write_Each_Categorie_Acc_To_Editor(Database, network_name, acc_single_categorie)\n",
    "    \n",
    "WaitTime_Finished()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktion und Ausführung um weitere Daten und Parameter in Log-File zu schreiben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./Log_Files/AMI/2021_02_27-17_31_53_AlexNet.txt\n"
     ]
    }
   ],
   "source": [
    "## Write to Log-Files (TXT-File) ##\n",
    "def Write_Training_Loss_To_Editor(database, net, train_num, test_num, accuracy, loss_epoch):\n",
    "    logfile_path = './Log_Files/' + database + '/' + str(current_time) + '_' + net   + '.txt'\n",
    "    #logfile_path = './Log_Files/Test.txt'\n",
    "    print(logfile_path)\n",
    "\n",
    "    datei = open(logfile_path, 'a')\n",
    "    datei.write(\"Datensatz: \")\n",
    "    datei.write(Database + \"\\n\\n\")\n",
    "    datei.write(\"Netzwerk: \" + net + \"\\n\\n\")\n",
    "    datei.write(\"Anzahl der Trainingsdatensaetze: \\t\" + str(train_num) + \"\\n\")\n",
    "    datei.write(\"Anzahl der Testdatensaetze: \\t\\t\" + str(test_num) + \"\\n\\n\")\n",
    "    datei.write(\"Accuracy des \" + net + \"-Netzwerks \" + \"bei \" + str(test_num) + \" Testbilder:  \" + str(accuracy) + \"%\\n\\n\")\n",
    "    datei.write(loss_epoch)\n",
    "    datei.close()\n",
    "\n",
    "Write_Training_Loss_To_Editor(Database, network_name, len(dataset_train), len(dataset_test), acc, write_loss_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktion um PR-Kurve für jede Kategorie in Tensorboard zu übertragen\n",
    "\n",
    "Hinweis: Diese Funktion kann ausgeführt werden, wird aber in der Arbeit nicht weiter analysiert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_pr_curve_tensorboard(class_index, test_probs, test_preds, global_step=0):\n",
    "    '''\n",
    "    Takes in a \"class_index\" from 0 to 9 and plots the corresponding\n",
    "    precision-recall curve\n",
    "    '''\n",
    "    tensorboard_preds = test_preds == class_index\n",
    "    tensorboard_probs = test_probs[:, class_index]\n",
    "\n",
    "    writer.add_pr_curve(CATEGORIES[class_index],\n",
    "                        tensorboard_preds,\n",
    "                        tensorboard_probs,\n",
    "                        global_step=global_step)\n",
    "    writer.close()\n",
    "\n",
    "# plot all the pr curves\n",
    "for i in range(len(CATEGORIES)):\n",
    "    add_pr_curve_tensorboard(i, test_probs, test_preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Schreiben der Daten ins Logbuch\n",
    "\n",
    "Schreibt alle gesammelten Daten und berechneten Parameter in ein CSV-File\n",
    "\n",
    "* **Write_Data_To_CSV():** \n",
    "    Schreibt alle Accuracy-Werte aller genutzten Netzwerke in ein CSV-File\n",
    "* **Write_Data_To_CSV_expand():**\n",
    "    Schreibt alle berechnten Parameter (Top1-/Top5-Accuracy, AUC, F1-Score) in ein CSV-File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Function to write Data to CSV-File\n",
    "def Write_Data_To_CSV(database, net, train_num, test_num, batchSize_Train, batchSize_Test, learning_rate, momentum, epoch, running_loss, train_time, time_format, accuracy, stamp):\n",
    "    CSV = pd.read_csv(\"CSV_Files/Logbuch_CSV_corr.csv\", sep=';')\n",
    "    CSV_df = pd.DataFrame(CSV)\n",
    "\n",
    "    Names = [{   \n",
    "                \"Datensatz\":database,\n",
    "                \"Netzwerk\":net,\n",
    "                \"Anzahl Trainingsbilder\": train_num,\n",
    "                \"Anzahl Testbilder\": test_num,\n",
    "                \"Batch_Size Training\": batchSize_Train,\n",
    "                \"Batch_Size Test\": batchSize_Test,\n",
    "                \"Learning Rate\": learning_rate,\n",
    "                \"Momentum\": momentum,\n",
    "                \"Epochen\": epoch+1, \n",
    "                \"Running Loss\": running_loss, \n",
    "                \"Dauer Training\":train_time, \n",
    "                \"Zeitformat\":time_format,\n",
    "                \"Accuracy\": accuracy, \n",
    "                \"Stempel\": stamp\n",
    "             }]\n",
    "    Names_df = pd.DataFrame(Names)\n",
    "    df_neu = CSV_df.append(Names_df, ignore_index=True)\n",
    "    df_neu.to_csv(\"CSV_Files/Logbuch_CSV.csv\", sep=';', index=False, header=True)\n",
    "    return pd.read_csv(\"CSV_Files/Logbuch_CSV.csv\", sep=';')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Write_Data_To_CSV_expand(database, net, train_num, test_num, batchSize_Train, batchSize_Test, learning_rate, momentum, epoch, running_loss, train_time, time_format, accuracy, Acc_all, Top_1_f, Top_5_f, AUC, F1_f, F1_score_all, stamp):\n",
    "    CSV = pd.read_csv(\"CSV_Files/Logbuch_CSV_erweitert.csv\", sep=';')\n",
    "    CSV_df = pd.DataFrame(CSV)\n",
    "\n",
    "    Names = [{   \n",
    "                \"Datensatz\":database,\n",
    "                \"Netzwerk\":net,\n",
    "                \"Anzahl Trainingsbilder\": train_num,\n",
    "                \"Anzahl Testbilder\": test_num,\n",
    "                \"Batch_Size Training\": batchSize_Train,\n",
    "                \"Batch_Size Test\": batchSize_Test,\n",
    "                \"Learning Rate\": learning_rate,\n",
    "                \"Momentum\": momentum,\n",
    "                \"Epochen\": epoch+1, \n",
    "                \"Running Loss\": running_loss, \n",
    "                \"Dauer Training\":train_time, \n",
    "                \"Zeitformat\":time_format,\n",
    "                \"Accuracy\": accuracy, \n",
    "                \"Accuracy_PyLig\": Acc_all.numpy(),\n",
    "                \"Top1\": Top_1_f,\n",
    "                \"Top5\": Top_5_f,\n",
    "                \"AUC\": AUC.numpy(),\n",
    "                \"F1_my\": F1_f.numpy(),\n",
    "                \"F1_PyLig\": F1_score_all.numpy(),\n",
    "                \"Stempel\": stamp\n",
    "             }]\n",
    "    Names_df = pd.DataFrame(Names)\n",
    "    df_neu = CSV_df.append(Names_df, ignore_index=True)\n",
    "    df_neu.to_csv(\"CSV_Files/Logbuch_CSV_erweitert.csv\", sep=';', index=False, header=True)\n",
    "    return pd.read_csv(\"CSV_Files/Logbuch_CSV_erweitert.csv\", sep=';')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Datensatz</th>\n",
       "      <th>Netzwerk</th>\n",
       "      <th>Anzahl Trainingsbilder</th>\n",
       "      <th>Anzahl Testbilder</th>\n",
       "      <th>Batch_Size Training</th>\n",
       "      <th>Batch_Size Test</th>\n",
       "      <th>Learning Rate</th>\n",
       "      <th>Momentum</th>\n",
       "      <th>Epochen</th>\n",
       "      <th>Running Loss</th>\n",
       "      <th>Dauer Training</th>\n",
       "      <th>Zeitformat</th>\n",
       "      <th>Accuracy</th>\n",
       "      <th>Accuracy_PyLig</th>\n",
       "      <th>Top1</th>\n",
       "      <th>Top5</th>\n",
       "      <th>AUC</th>\n",
       "      <th>F1_my</th>\n",
       "      <th>F1_PyLig</th>\n",
       "      <th>Stempel</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Neu</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CP</td>\n",
       "      <td>Resnext101-32x8d</td>\n",
       "      <td>68.0</td>\n",
       "      <td>34.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.005421876907348633</td>\n",
       "      <td>02:51</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>97.06</td>\n",
       "      <td>97.06</td>\n",
       "      <td>97.22</td>\n",
       "      <td>100.0</td>\n",
       "      <td>98.44</td>\n",
       "      <td>97.22</td>\n",
       "      <td>97.06</td>\n",
       "      <td>2021_02_03-18_10_22_CP_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AMI</td>\n",
       "      <td>Resnext101-32x8d</td>\n",
       "      <td>500.0</td>\n",
       "      <td>200.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.026825428009033203</td>\n",
       "      <td>21:03</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>96.0</td>\n",
       "      <td>96.0</td>\n",
       "      <td>96.0</td>\n",
       "      <td>99.0</td>\n",
       "      <td>97.98</td>\n",
       "      <td>96.0</td>\n",
       "      <td>96.0</td>\n",
       "      <td>2021_02_03-20_49_49_AMI_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AWE</td>\n",
       "      <td>Resnext101-32x8d</td>\n",
       "      <td>800.0</td>\n",
       "      <td>200.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>33:36:00</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>51.5</td>\n",
       "      <td>51.5</td>\n",
       "      <td>51.5</td>\n",
       "      <td>73.0</td>\n",
       "      <td>75.51</td>\n",
       "      <td>51.5</td>\n",
       "      <td>51.5</td>\n",
       "      <td>2021_02_03-22_11_34_AWE_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UERC</td>\n",
       "      <td>Resnext101-32x8d</td>\n",
       "      <td>2192.0</td>\n",
       "      <td>548.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.6218500137329102</td>\n",
       "      <td>02:32:02</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>30.29</td>\n",
       "      <td>30.29</td>\n",
       "      <td>30.29</td>\n",
       "      <td>49.63</td>\n",
       "      <td>65.02</td>\n",
       "      <td>30.29</td>\n",
       "      <td>30.29</td>\n",
       "      <td>2021_02_03-22_47_50_UERC_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>CP_e</td>\n",
       "      <td>Resnext101-32x8d_e</td>\n",
       "      <td>340.0</td>\n",
       "      <td>68.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.009591817855834961</td>\n",
       "      <td>14:22</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>2021_02_04-17_32_38_CP_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>AMI_e</td>\n",
       "      <td>Resnext101-32x8d_e</td>\n",
       "      <td>2400.0</td>\n",
       "      <td>400.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02:40:59</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>2021_02_04-17_51_14_AMI_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>AWE_e</td>\n",
       "      <td>Resnext101-32x8d_e</td>\n",
       "      <td>3200.0</td>\n",
       "      <td>800.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>03:14:34</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>98.375</td>\n",
       "      <td>98.375</td>\n",
       "      <td>98.375</td>\n",
       "      <td>99.5</td>\n",
       "      <td>9.917.928</td>\n",
       "      <td>98.375</td>\n",
       "      <td>98.375</td>\n",
       "      <td>2021_02_04-21_54_54_AWE_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>UERC_e</td>\n",
       "      <td>Resnext101-32x8d_e</td>\n",
       "      <td>8768.0</td>\n",
       "      <td>2192.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.004006385803222656</td>\n",
       "      <td>07:07:53</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>9.630.474.452.554.740</td>\n",
       "      <td>9.630.474</td>\n",
       "      <td>9.630.474.090.576.170</td>\n",
       "      <td>9.945.255.279.541.010</td>\n",
       "      <td>9.814.559</td>\n",
       "      <td>9.630.474</td>\n",
       "      <td>9.630.474</td>\n",
       "      <td>2021_02_05-10_11_05_UERC_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>EarVN_1_0</td>\n",
       "      <td>Resnext101-32x8d</td>\n",
       "      <td>22681.0</td>\n",
       "      <td>5731.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>29.751.343.727.111.800</td>\n",
       "      <td>17:26:41</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>92.23</td>\n",
       "      <td>92.235.214</td>\n",
       "      <td>9.223.656.463.623.040</td>\n",
       "      <td>9.738.311.004.638.670</td>\n",
       "      <td>9.600.976</td>\n",
       "      <td>92.236.565</td>\n",
       "      <td>92.235.214</td>\n",
       "      <td>2021_02_05-18_04_07_EarVN_1_0_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>AMI</td>\n",
       "      <td>AlexNet</td>\n",
       "      <td>100.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.00015020370483398438</td>\n",
       "      <td>00:22</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>95.0</td>\n",
       "      <td>95.0</td>\n",
       "      <td>95.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>97.368416</td>\n",
       "      <td>95.0</td>\n",
       "      <td>95.0</td>\n",
       "      <td>2021_02_27-17_31_53_AMI_AlexNet</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Datensatz            Netzwerk  Anzahl Trainingsbilder  Anzahl Testbilder  \\\n",
       "0         Neu                 NaN                     NaN                NaN   \n",
       "1          CP    Resnext101-32x8d                    68.0               34.0   \n",
       "2         AMI    Resnext101-32x8d                   500.0              200.0   \n",
       "3         AWE    Resnext101-32x8d                   800.0              200.0   \n",
       "4        UERC    Resnext101-32x8d                  2192.0              548.0   \n",
       "5        CP_e  Resnext101-32x8d_e                   340.0               68.0   \n",
       "6       AMI_e  Resnext101-32x8d_e                  2400.0              400.0   \n",
       "7       AWE_e  Resnext101-32x8d_e                  3200.0              800.0   \n",
       "8      UERC_e  Resnext101-32x8d_e                  8768.0             2192.0   \n",
       "9   EarVN_1_0    Resnext101-32x8d                 22681.0             5731.0   \n",
       "10        AMI             AlexNet                   100.0               40.0   \n",
       "\n",
       "    Batch_Size Training  Batch_Size Test  Learning Rate  Momentum  Epochen  \\\n",
       "0                   NaN              NaN            NaN       NaN      NaN   \n",
       "1                   4.0              4.0          0.001       0.8     50.0   \n",
       "2                   4.0              4.0          0.001       0.8     50.0   \n",
       "3                   4.0              4.0          0.001       0.8     50.0   \n",
       "4                   4.0              4.0          0.001       0.8     50.0   \n",
       "5                   4.0              4.0          0.001       0.8     50.0   \n",
       "6                   4.0              4.0          0.001       0.8     50.0   \n",
       "7                   4.0              4.0          0.001       0.8     50.0   \n",
       "8                   4.0              4.0          0.001       0.8     50.0   \n",
       "9                   4.0              4.0          0.001       0.8     50.0   \n",
       "10                  4.0              4.0          0.001       0.8     50.0   \n",
       "\n",
       "              Running Loss Dauer Training  Zeitformat               Accuracy  \\\n",
       "0                      NaN            NaN         NaN                    NaN   \n",
       "1     0.005421876907348633          02:51     [MM:SS]                  97.06   \n",
       "2     0.026825428009033203          21:03     [MM:SS]                   96.0   \n",
       "3                      0.0       33:36:00     [MM:SS]                   51.5   \n",
       "4       0.6218500137329102       02:32:02  [HH:MM:SS]                  30.29   \n",
       "5     0.009591817855834961          14:22     [MM:SS]                  100.0   \n",
       "6                      0.0       02:40:59  [HH:MM:SS]                  100.0   \n",
       "7                      0.0       03:14:34  [HH:MM:SS]                 98.375   \n",
       "8     0.004006385803222656       07:07:53  [HH:MM:SS]  9.630.474.452.554.740   \n",
       "9   29.751.343.727.111.800       17:26:41  [HH:MM:SS]                  92.23   \n",
       "10  0.00015020370483398438          00:22     [MM:SS]                   95.0   \n",
       "\n",
       "   Accuracy_PyLig                   Top1                   Top5        AUC  \\\n",
       "0             NaN                    NaN                    NaN        NaN   \n",
       "1           97.06                  97.22                  100.0      98.44   \n",
       "2            96.0                   96.0                   99.0      97.98   \n",
       "3            51.5                   51.5                   73.0      75.51   \n",
       "4           30.29                  30.29                  49.63      65.02   \n",
       "5           100.0                  100.0                  100.0      100.0   \n",
       "6           100.0                  100.0                  100.0      100.0   \n",
       "7          98.375                 98.375                   99.5  9.917.928   \n",
       "8       9.630.474  9.630.474.090.576.170  9.945.255.279.541.010  9.814.559   \n",
       "9      92.235.214  9.223.656.463.623.040  9.738.311.004.638.670  9.600.976   \n",
       "10           95.0                   95.0                  100.0  97.368416   \n",
       "\n",
       "         F1_my    F1_PyLig                                         Stempel  \n",
       "0          NaN         NaN                                             NaN  \n",
       "1        97.22       97.06         2021_02_03-18_10_22_CP_Resnext101-32x8d  \n",
       "2         96.0        96.0        2021_02_03-20_49_49_AMI_Resnext101-32x8d  \n",
       "3         51.5        51.5        2021_02_03-22_11_34_AWE_Resnext101-32x8d  \n",
       "4        30.29       30.29       2021_02_03-22_47_50_UERC_Resnext101-32x8d  \n",
       "5        100.0       100.0         2021_02_04-17_32_38_CP_Resnext101-32x8d  \n",
       "6        100.0       100.0        2021_02_04-17_51_14_AMI_Resnext101-32x8d  \n",
       "7       98.375      98.375        2021_02_04-21_54_54_AWE_Resnext101-32x8d  \n",
       "8    9.630.474   9.630.474       2021_02_05-10_11_05_UERC_Resnext101-32x8d  \n",
       "9   92.236.565  92.235.214  2021_02_05-18_04_07_EarVN_1_0_Resnext101-32x8d  \n",
       "10        95.0        95.0                 2021_02_27-17_31_53_AMI_AlexNet  "
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Write_Data_To_CSV_expand(Database, network_name, len(dataset_train), len(dataset_test), batch_size_train, batch_size_test, learning_rate, momentum, epoch, running_loss, time_dif, time_format, acc, acc_all, top_1_f, top_5_f, auroc_1, f1_f, f1_score_all, stamp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Datensatz</th>\n",
       "      <th>Netzwerk</th>\n",
       "      <th>Anzahl Trainingsbilder</th>\n",
       "      <th>Anzahl Testbilder</th>\n",
       "      <th>Batch_Size Training</th>\n",
       "      <th>Batch_Size Test</th>\n",
       "      <th>Learning Rate</th>\n",
       "      <th>Momentum</th>\n",
       "      <th>Epochen</th>\n",
       "      <th>Running Loss</th>\n",
       "      <th>Dauer Training</th>\n",
       "      <th>Zeitformat</th>\n",
       "      <th>Accuracy</th>\n",
       "      <th>Stempel</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AWE</td>\n",
       "      <td>VGG11</td>\n",
       "      <td>800</td>\n",
       "      <td>200</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>25</td>\n",
       "      <td>0.018202782</td>\n",
       "      <td>04:11</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>24.13</td>\n",
       "      <td>2020_10_13-13_47_08_AWE_VGG11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CP</td>\n",
       "      <td>VGG11</td>\n",
       "      <td>68</td>\n",
       "      <td>34</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>49</td>\n",
       "      <td>0.001134396</td>\n",
       "      <td>00:42</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>94.12</td>\n",
       "      <td>2020_10_13-13_47_08_CP_VGG11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AMI</td>\n",
       "      <td>VGG11</td>\n",
       "      <td>500</td>\n",
       "      <td>200</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>49</td>\n",
       "      <td>0.002470016</td>\n",
       "      <td>05:06</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>78.00</td>\n",
       "      <td>2020_10_13-13_47_08_AMI_VGG11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>EarVN_1_0</td>\n",
       "      <td>VGG11</td>\n",
       "      <td>22681</td>\n",
       "      <td>5731</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>49</td>\n",
       "      <td>0</td>\n",
       "      <td>04:50:23</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>68.14</td>\n",
       "      <td>2020_10_13-13_47_08_EarVN_1_0_VGG11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>EarVN_1_0_e</td>\n",
       "      <td>VGG11_e</td>\n",
       "      <td>22681</td>\n",
       "      <td>5731</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>49</td>\n",
       "      <td>0</td>\n",
       "      <td>04:50:23</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>68.14</td>\n",
       "      <td>2020_10_13-13_47_08_EarVN_1_0_VGG11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>151</th>\n",
       "      <td>WPUT_e_w</td>\n",
       "      <td>GoogLeNet_e_w</td>\n",
       "      <td>9076</td>\n",
       "      <td>2904</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50</td>\n",
       "      <td>4.961.103.916.168.210</td>\n",
       "      <td>03:17:00</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>99.44</td>\n",
       "      <td>2020_11_01-11_07_43_WPUT_GoogLeNet</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>152</th>\n",
       "      <td>WPUT_e_w</td>\n",
       "      <td>Shufflenet-v2-x0_5_e_w</td>\n",
       "      <td>9076</td>\n",
       "      <td>2904</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50</td>\n",
       "      <td>43.149.518.966.674.800</td>\n",
       "      <td>03:09:59</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>99.35</td>\n",
       "      <td>2020_11_01-13_56_51_WPUT_Shufflenet-v2-x0_5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153</th>\n",
       "      <td>WPUT_e_w</td>\n",
       "      <td>Resnext101-32x8d_e_w</td>\n",
       "      <td>9076</td>\n",
       "      <td>2904</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50</td>\n",
       "      <td>0.841792107</td>\n",
       "      <td>07:52:04</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>100.00</td>\n",
       "      <td>2020_11_01-16_10_09_WPUT_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>154</th>\n",
       "      <td>UERC_w</td>\n",
       "      <td>Resnext101-32x8d_w</td>\n",
       "      <td>2192</td>\n",
       "      <td>548</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50</td>\n",
       "      <td>0.597034216</td>\n",
       "      <td>02:36:52</td>\n",
       "      <td>[HH:MM:SS]</td>\n",
       "      <td>44.13</td>\n",
       "      <td>2020_10_23-10_11_30_UERC_Resnext101-32x8d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>155</th>\n",
       "      <td>AMI</td>\n",
       "      <td>AlexNet</td>\n",
       "      <td>100</td>\n",
       "      <td>40</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.8</td>\n",
       "      <td>50</td>\n",
       "      <td>0.00015020370483398438</td>\n",
       "      <td>00:22</td>\n",
       "      <td>[MM:SS]</td>\n",
       "      <td>95.00</td>\n",
       "      <td>2021_02_27-17_31_53_AMI_AlexNet</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>156 rows × 14 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       Datensatz                Netzwerk  Anzahl Trainingsbilder  \\\n",
       "0            AWE                   VGG11                     800   \n",
       "1             CP                   VGG11                      68   \n",
       "2            AMI                   VGG11                     500   \n",
       "3      EarVN_1_0                   VGG11                   22681   \n",
       "4    EarVN_1_0_e                 VGG11_e                   22681   \n",
       "..           ...                     ...                     ...   \n",
       "151     WPUT_e_w           GoogLeNet_e_w                    9076   \n",
       "152     WPUT_e_w  Shufflenet-v2-x0_5_e_w                    9076   \n",
       "153     WPUT_e_w    Resnext101-32x8d_e_w                    9076   \n",
       "154       UERC_w      Resnext101-32x8d_w                    2192   \n",
       "155          AMI                 AlexNet                     100   \n",
       "\n",
       "     Anzahl Testbilder  Batch_Size Training  Batch_Size Test  Learning Rate  \\\n",
       "0                  200                    4                4          0.001   \n",
       "1                   34                    4                4          0.001   \n",
       "2                  200                    4                4          0.001   \n",
       "3                 5731                    4                4          0.001   \n",
       "4                 5731                    4                4          0.001   \n",
       "..                 ...                  ...              ...            ...   \n",
       "151               2904                    4                4          0.001   \n",
       "152               2904                    4                4          0.001   \n",
       "153               2904                    4                4          0.001   \n",
       "154                548                    4                4          0.001   \n",
       "155                 40                    4                4          0.001   \n",
       "\n",
       "     Momentum  Epochen            Running Loss Dauer Training  Zeitformat  \\\n",
       "0         0.8       25             0.018202782          04:11     [MM:SS]   \n",
       "1         0.8       49             0.001134396          00:42     [MM:SS]   \n",
       "2         0.8       49             0.002470016          05:06     [MM:SS]   \n",
       "3         0.8       49                       0       04:50:23  [HH:MM:SS]   \n",
       "4         0.8       49                       0       04:50:23  [HH:MM:SS]   \n",
       "..        ...      ...                     ...            ...         ...   \n",
       "151       0.8       50   4.961.103.916.168.210       03:17:00  [HH:MM:SS]   \n",
       "152       0.8       50  43.149.518.966.674.800       03:09:59  [HH:MM:SS]   \n",
       "153       0.8       50             0.841792107       07:52:04  [HH:MM:SS]   \n",
       "154       0.8       50             0.597034216       02:36:52  [HH:MM:SS]   \n",
       "155       0.8       50  0.00015020370483398438          00:22     [MM:SS]   \n",
       "\n",
       "     Accuracy                                      Stempel  \n",
       "0       24.13                2020_10_13-13_47_08_AWE_VGG11  \n",
       "1       94.12                 2020_10_13-13_47_08_CP_VGG11  \n",
       "2       78.00                2020_10_13-13_47_08_AMI_VGG11  \n",
       "3       68.14          2020_10_13-13_47_08_EarVN_1_0_VGG11  \n",
       "4       68.14          2020_10_13-13_47_08_EarVN_1_0_VGG11  \n",
       "..        ...                                          ...  \n",
       "151     99.44           2020_11_01-11_07_43_WPUT_GoogLeNet  \n",
       "152     99.35  2020_11_01-13_56_51_WPUT_Shufflenet-v2-x0_5  \n",
       "153    100.00    2020_11_01-16_10_09_WPUT_Resnext101-32x8d  \n",
       "154     44.13    2020_10_23-10_11_30_UERC_Resnext101-32x8d  \n",
       "155     95.00              2021_02_27-17_31_53_AMI_AlexNet  \n",
       "\n",
       "[156 rows x 14 columns]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Write_Data_To_CSV(Database, network_name, len(dataset_train), len(dataset_test), batch_size_train, batch_size_test, learning_rate, momentum, epoch, running_loss, time_dif, time_format, acc, stamp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PR-Kurve mit Tensorboard\n",
    "\n",
    "Generiert für alle Kategorien eine PR-Kurve in Tensorboard. Diese Funktion wird schlußendlich nicht zur Bewertung der Datensätze und Netzwerke verwendet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. gets the probability predictions in a test_size x num_classes Tensor\n",
    "# 2. gets the preds in a test_size Tensor\n",
    "# takes ~10 seconds to run\n",
    "\n",
    "class_probs = []\n",
    "class_preds = []\n",
    "with torch.no_grad():\n",
    "    for data in test_loader:\n",
    "        images, labels = data\n",
    "        network.to(DEVICE)\n",
    "        network.cpu()\n",
    "        output = network(images)\n",
    "        class_probs_batch = [F.softmax(el, dim=0) for el in output]\n",
    "        _, class_preds_batch = torch.max(output, 1)\n",
    "\n",
    "        class_probs.append(class_probs_batch)\n",
    "        class_preds.append(class_preds_batch)\n",
    "\n",
    "test_probs = torch.cat([torch.stack(batch) for batch in class_probs])\n",
    "test_preds = torch.cat(class_preds)\n",
    "\n",
    "# helper function\n",
    "def add_pr_curve_tensorboard(class_index, test_probs, test_preds, global_step=0):\n",
    "    '''\n",
    "    Takes in a \"class_index\" from 0 to 9 and plots the corresponding\n",
    "    precision-recall curve\n",
    "    '''\n",
    "    tensorboard_preds = test_preds == class_index\n",
    "    tensorboard_probs = test_probs[:, class_index]\n",
    "\n",
    "    writer.add_pr_curve(CATEGORIES[class_index],\n",
    "                        tensorboard_preds,\n",
    "                        tensorboard_probs,\n",
    "                        global_step=global_step)\n",
    "    writer.close()\n",
    "\n",
    "# plot all the pr curves\n",
    "for i in range(len(CATEGORIES)):\n",
    "    add_pr_curve_tensorboard(i, test_probs, test_preds)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}