{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Laden der Rohdaten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "# Laden der 'kirp' Liste aus der Pickle-Datei\n",
    "with open('rick.pickle', 'rb') as f:\n",
    "    data_frame = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aktiviere Cuda Support"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA is available on your system.\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "device = \"cpu\"\n",
    "if torch.cuda.is_available():\n",
    "    print(\"CUDA is available on your system.\")\n",
    "    device = \"cuda\"\n",
    "else:\n",
    "    print(\"CUDA is not available on your system.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PCA Klasse zu Reduktion der Dimensionen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset\n",
    "import torch\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from typing import List, Tuple, Dict\n",
    "\n",
    "\n",
    "class GenomeDataset(Dataset):\n",
    "    \"\"\"\n",
    "    Eine benutzerdefinierte Dataset-Klasse, die für die Handhabung von Genomdaten konzipiert ist.\n",
    "    Diese Klasse wendet eine Principal Component Analysis (PCA) auf die Frequenzen der Genome an\n",
    "    und teilt den Datensatz in Trainings- und Validierungsteile auf.\n",
    "\n",
    "    Attributes:\n",
    "        dataframe (pd.DataFrame): Ein Pandas DataFrame, der die initialen Daten enthält.\n",
    "        train_df (pd.DataFrame): Ein DataFrame, der den Trainingsdatensatz nach der Anwendung von PCA und der Aufteilung enthält.\n",
    "        val_df (pd.DataFrame): Ein DataFrame, der den Validierungsdatensatz nach der Anwendung von PCA und der Aufteilung enthält.\n",
    "\n",
    "    Methods:\n",
    "        __init__(self, dataframe, n_pca_components=1034, train_size=0.8, split_random_state=42):\n",
    "            Konstruktor für die GenomeDataset Klasse.\n",
    "        _do_PCA(self, frequencies, n_components=1034):\n",
    "            Wendet PCA auf die gegebenen Frequenzen an.\n",
    "        _split_dataset(self, train_size=0.8, random_state=42):\n",
    "            Teilt den DataFrame in Trainings- und Validierungsdatensätze auf.\n",
    "        __getitem__(self, index):\n",
    "            Gibt ein Tupel aus transformierten Frequenzen und dem zugehörigen Krebstyp für einen gegebenen Index zurück.\n",
    "        __len__(self):\n",
    "            Gibt die Gesamtlänge der kombinierten Trainings- und Validierungsdatensätze zurück.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, dataframe: pd.DataFrame, n_pca_components: int = 1034, train_size: float = 0.8, split_random_state: int = 42):\n",
    "        \"\"\"\n",
    "        Konstruktor für die GenomeDataset Klasse.\n",
    "\n",
    "        Parameters:\n",
    "            dataframe (pd.DataFrame): Der DataFrame, der die Genome Frequenzen und Krebsarten enthält.\n",
    "            n_pca_components (int): Die Anzahl der PCA-Komponenten, auf die reduziert werden soll. Standardwert ist 1034.\n",
    "            train_size (float): Der Anteil der Daten, der als Trainingsdaten verwendet werden soll. Standardwert ist 0.8.\n",
    "            split_random_state (int): Der Zufalls-Saatwert, der für die Aufteilung des Datensatzes verwendet wird. Standardwert ist 42.\n",
    "        \"\"\"\n",
    "        self.dataframe = dataframe\n",
    "\n",
    "        # Umwandlung der Krebsarten in numerische Werte\n",
    "        self.label_encoder = LabelEncoder()\n",
    "        self.dataframe['encoded_cancer_type'] = self.label_encoder.fit_transform(dataframe['cancer_type'])\n",
    "\n",
    "        # Anwenden der PCA auf die Frequenzen\n",
    "        self.dataframe['pca_frequencies'] = self._do_PCA(self.dataframe['genome_frequencies'].tolist(), n_pca_components)\n",
    "\n",
    "        # Teilen des DataFrame in Trainings- und Validierungsdatensatz\n",
    "        self._split_dataset(train_size=train_size, random_state=split_random_state)\n",
    "\n",
    "    def transform_datapoint(self, datapoint: List[float]) -> List[float]:\n",
    "        \"\"\"\n",
    "        Transformiert einen einzelnen Datenpunkt durch Standardisierung und Anwendung der PCA.\n",
    "\n",
    "        Diese Methode nimmt einen rohen Datenpunkt (eine Liste von Frequenzen), standardisiert ihn mit dem \n",
    "        zuvor angepassten Scaler und wendet dann die PCA-Transformation an, um ihn in den reduzierten \n",
    "        Feature-Raum zu überführen, der für das Training des Modells verwendet wurde.\n",
    "\n",
    "        Parameters:\n",
    "            datapoint (List[float]): Ein roher Datenpunkt, bestehend aus einer Liste von Frequenzen.\n",
    "\n",
    "        Returns:\n",
    "            List[float]: Der transformierte Datenpunkt, nach Anwendung der Standardisierung und der PCA.\n",
    "        \"\"\"\n",
    "        # Standardisierung des Datenpunkts\n",
    "        scaled_data_point = self.scaler.transform([datapoint])\n",
    "\n",
    "        # PCA-Transformation des standardisierten Datenpunkts\n",
    "        pca_transformed_point = self.pca.transform(scaled_data_point)\n",
    "\n",
    "        return pca_transformed_point.tolist()\n",
    "\n",
    "    def _do_PCA(self, frequencies: List[List[float]], n_components: int = 1034) -> List[List[float]]:\n",
    "        \"\"\"\n",
    "        Wendet PCA auf die gegebenen Frequenzen an.\n",
    "\n",
    "        Parameters:\n",
    "            frequencies (List[List[float]]): Die Liste der Frequenzen, auf die die PCA angewendet werden soll.\n",
    "            n_components (int): Die Anzahl der Komponenten für die PCA. Standardwert ist 1034.\n",
    "\n",
    "        Returns:\n",
    "            List[List[float]]: Eine Liste von Listen, die die transformierten Frequenzen nach der PCA darstellt.\n",
    "        \"\"\"\n",
    "\n",
    "        # Standardisieren der Frequenzen\n",
    "        self.scaler = StandardScaler()\n",
    "        scaled_frequencies = self.scaler.fit_transform(frequencies)\n",
    "\n",
    "        # PCA-Instanz erstellen und auf die gewünschte Anzahl von Komponenten reduzieren\n",
    "        self.pca = PCA(n_components=n_components)\n",
    "\n",
    "        # PCA auf die Frequenzen anwenden\n",
    "        pca_result = self.pca.fit_transform(scaled_frequencies)\n",
    "\n",
    "        return pca_result.tolist()\n",
    "\n",
    "    def _split_dataset(self, train_size: float = 0.9, random_state: int = 42):\n",
    "        \"\"\"\n",
    "        Teilt den DataFrame in Trainings- und Validierungsdatensätze auf.\n",
    "\n",
    "        Parameters:\n",
    "            train_size (float): Der Anteil der Daten, der als Trainingsdaten verwendet werden soll.\n",
    "            random_state (int): Der Zufalls-Saatwert, der für die Aufteilung des Datensatzes verwendet wird.\n",
    "        \"\"\"\n",
    "\n",
    "        class SplittedDataset(Dataset):\n",
    "            def __init__(self, dataframe):\n",
    "                self.dataframe = dataframe\n",
    "\n",
    "                # Umwandlung der Genome Frequenzen in Tensoren\n",
    "                self.genome_frequencies = torch.tensor(dataframe['pca_frequencies'].tolist(), dtype=torch.float32)\n",
    "\n",
    "                # Umwandlung der Krebsarten in numerische Werte\n",
    "                self.label_encoder = LabelEncoder()\n",
    "                self.cancer_types = torch.tensor(dataframe['encoded_cancer_type'].tolist(), dtype=torch.long)\n",
    "\n",
    "            def __getitem__(self, index):\n",
    "                # Rückgabe eines Tupels aus Genome Frequenzen und dem entsprechenden Krebstyp\n",
    "                return self.genome_frequencies[index], self.cancer_types[index]\n",
    "\n",
    "            def __len__(self):\n",
    "                return len(self.dataframe)\n",
    "\n",
    "        # Teilen des DataFrame in Trainings- und Validierungsdatensatz\n",
    "        train_df, val_df = train_test_split(self.dataframe, train_size=train_size) #, random_state=random_state)\n",
    "        self.train_df = SplittedDataset(train_df)\n",
    "        self.val_df = SplittedDataset(val_df)\n",
    "\n",
    "\n",
    "    def __getitem__(self, index: int) -> Tuple[torch.Tensor, int]:\n",
    "        \"\"\"\n",
    "        Gibt ein Tupel aus transformierten Frequenzen und dem entsprechenden Krebstyp für einen gegebenen Index zurück.\n",
    "\n",
    "        Parameters:\n",
    "            index (int): Der Index des zu abrufenden Datenelements.\n",
    "\n",
    "        Returns:\n",
    "            Tuple[torch.Tensor, int]: Ein Tupel, bestehend aus einem Tensor der transformierten Frequenzen und dem zugehörigen Krebstyp.\n",
    "        \"\"\"\n",
    "\n",
    "        print(self.train_df.shape)\n",
    "        print(self.val_df.shape)\n",
    "        \n",
    "        if index < len(self.train_df):\n",
    "            row = self.train_df.iloc[index]\n",
    "        else:\n",
    "            row = self.val_df.iloc[len(self.train_df) - index]\n",
    "\n",
    "        pca_frequencies_tensor = torch.tensor(row['pca_frequencies'], dtype=torch.float32)\n",
    "        cancer_type = row['encoded_cancer_type']\n",
    "\n",
    "        return pca_frequencies_tensor, cancer_type\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        \"\"\"\n",
    "        Gibt die Gesamtlänge der kombinierten Trainings- und Validierungsdatensätze zurück.\n",
    "\n",
    "        Returns:\n",
    "            int: Die Länge der kombinierten Datensätze.\n",
    "        \"\"\"\n",
    "        \n",
    "        return len(self.train_df) + len(self.val_df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Definition des neuronalen Netzes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "class CancerClassifierNN(nn.Module):\n",
    "    \"\"\"\n",
    "    Eine benutzerdefinierte neuronale Netzwerkklassifikator-Klasse für die Krebsklassifikation.\n",
    "\n",
    "    Diese Klasse definiert ein mehrschichtiges Perzeptron (MLP), das für die Klassifizierung von Krebsarten\n",
    "    anhand genetischer Frequenzdaten verwendet wird.\n",
    "\n",
    "    Attributes:\n",
    "        fc1 (nn.Linear): Die erste lineare Schicht des Netzwerks.\n",
    "        fc2 (nn.Linear): Die zweite lineare Schicht des Netzwerks.\n",
    "        fc3 (nn.Linear): Die dritte lineare Schicht des Netzwerks.\n",
    "        fc4 (nn.Linear): Die Ausgabeschicht des Netzwerks.\n",
    "        dropout (nn.Dropout): Ein Dropout-Layer zur Vermeidung von Overfitting.\n",
    "\n",
    "    Methods:\n",
    "        __init__(self, input_size: int, num_classes: int):\n",
    "            Konstruktor für die CancerClassifierNN Klasse.\n",
    "        forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "            Definiert den Vorwärtsdurchlauf des Netzwerks.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input_size: int, num_classes: int):\n",
    "        \"\"\"\n",
    "        Konstruktor für die CancerClassifierNN Klasse.\n",
    "\n",
    "        Parameters:\n",
    "            input_size (int): Die Größe des Input-Features.\n",
    "            num_classes (int): Die Anzahl der Zielklassen.\n",
    "        \"\"\"\n",
    "        super(CancerClassifierNN, self).__init__()\n",
    "        # Definieren der Schichten\n",
    "        self.fc1 = nn.Linear(input_size, input_size)  # Eingabeschicht\n",
    "        self.fc2 = nn.Linear(input_size, input_size//2)        # Versteckte Schicht\n",
    "        self.fc3 = nn.Linear(input_size//2, input_size//4)         # Weitere versteckte Schicht\n",
    "        self.fc4 = nn.Linear(input_size//4, num_classes) # Ausgabeschicht\n",
    "        self.dropout = nn.Dropout(p=0.5)       # Dropout\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Definiert den Vorwärtsdurchlauf des Netzwerks.\n",
    "\n",
    "        Parameters:\n",
    "            x (torch.Tensor): Der Input-Tensor für das Netzwerk.\n",
    "\n",
    "        Returns:\n",
    "            torch.Tensor: Der Output-Tensor nach dem Durchlauf durch das Netzwerk.\n",
    "        \"\"\"\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.dropout(x)\n",
    "        x = F.relu(self.fc3(x))\n",
    "        x = self.dropout(x)\n",
    "        x = torch.softmax(self.fc4(x), dim=1)  # Oder F.log_softmax(x, dim=1) für Mehrklassenklassifikation\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import pickle\n",
    "\n",
    "class ExperimentationalExperiments():\n",
    "    \"\"\"\n",
    "    Diese Klasse dient zur Durchführung und Verwaltung von Experimenten im Rahmen\n",
    "    des maschinellen Lernens, insbesondere für die Krebsklassifikation.\n",
    "\n",
    "    Attribute:\n",
    "    results : Dict\n",
    "        Speichert die Ergebnisse der durchgeführten Experimente.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self) -> None:\n",
    "        \"\"\" Konstruktor der Klasse. Initialisiert 'results' als None. \"\"\"\n",
    "        self.results = None\n",
    "\n",
    "    def run_single_experiment(self, train_loader: DataLoader, valid_loader: DataLoader, n_pca_components: int, n_epochs: int = 200, learning_rate: int = 0.0005, verbose: bool = True, experiment_num: int = None) -> Tuple:\n",
    "        \"\"\"\n",
    "        Führt ein einzelnes Experiment mit dem spezifizierten DataLoader, PCA-Komponenten und weiteren Parametern durch.\n",
    "\n",
    "        Parameter:\n",
    "        train_loader : DataLoader\n",
    "            Der DataLoader für den Trainingsdatensatz.\n",
    "        valid_loader : DataLoader\n",
    "            Der DataLoader für den Validierungsdatensatz.\n",
    "        n_pca_components : int\n",
    "            Anzahl der PCA-Komponenten, die im Modell verwendet werden.\n",
    "        n_epochs : int, optional\n",
    "            Anzahl der Epochen für das Training (Standardwert ist 200).\n",
    "        learning_rate : float, optional\n",
    "            Lernrate für den Optimierer (Standardwert ist 0.0005).\n",
    "        verbose : bool, optional\n",
    "            Gibt an, ob der Trainingsfortschritt angezeigt werden soll (Standardwert ist True).\n",
    "        experiment_num : int, optional\n",
    "            Nummer des Experiments.\n",
    "\n",
    "        Rückgabewerte:\n",
    "        Tuple\n",
    "            Ein Tupel bestehend aus Listen der Trainings- und Validierungsverluste sowie der Genauigkeiten.\n",
    "        \"\"\"\n",
    "        if not isinstance(n_pca_components, int):\n",
    "            raise TypeError(\"n_pca_components must be an integers!\")\n",
    "        \n",
    "        plt.ioff()\n",
    "\n",
    "        model = CancerClassifierNN(input_size=n_pca_components, num_classes=3)\n",
    "        model.to(device=device)\n",
    "\n",
    "        # Verlustfunktion\n",
    "        criterion = nn.CrossEntropyLoss()\n",
    "        # Optimierer\n",
    "        optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "        # Listen, um Verluste zu speichern\n",
    "        train_losses = []\n",
    "        valid_losses = []\n",
    "        train_accuracies = []\n",
    "        valid_accuracies = []\n",
    "\n",
    "        for epoch in range(n_epochs):\n",
    "            model.train()\n",
    "            train_loss = 0.0\n",
    "            correct_predictions = 0\n",
    "            total_predictions = 0\n",
    "\n",
    "            for i, (inputs, labels) in enumerate(train_loader):\n",
    "                inputs, labels = inputs.to(device), labels.to(device)\n",
    "                optimizer.zero_grad()\n",
    "                outputs = model(inputs)\n",
    "                loss = criterion(outputs, labels)\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "                train_loss += loss.item()\n",
    "\n",
    "                # Berechnen der Genauigkeit\n",
    "                _, predicted = torch.max(outputs, 1)\n",
    "                correct_predictions += (predicted == labels).sum().item()\n",
    "                total_predictions += labels.size(0)\n",
    "\n",
    "            # Durchschnittlicher Trainingsverlust und Genauigkeit\n",
    "            train_loss /= len(train_loader)\n",
    "            train_accuracy = correct_predictions / total_predictions\n",
    "            train_losses.append(train_loss)\n",
    "            train_accuracies.append(train_accuracy)\n",
    "\n",
    "            # Validierungsverlust und Genauigkeit\n",
    "            model.eval()\n",
    "            valid_loss = 0.0\n",
    "            correct_predictions = 0\n",
    "            total_predictions = 0\n",
    "\n",
    "            with torch.no_grad():\n",
    "                for inputs, labels in valid_loader:\n",
    "                    inputs, labels = inputs.to(device), labels.to(device)\n",
    "                    outputs = model(inputs)\n",
    "                    loss = criterion(outputs, labels)\n",
    "                    valid_loss += loss.item()\n",
    "\n",
    "                    # Berechnen der Genauigkeit\n",
    "                    _, predicted = torch.max(outputs, 1)\n",
    "                    correct_predictions += (predicted == labels).sum().item()\n",
    "                    total_predictions += labels.size(0)\n",
    "\n",
    "            # Durchschnittlicher Validierungsverlust und Genauigkeit\n",
    "            valid_loss /= len(valid_loader)\n",
    "            valid_accuracy = correct_predictions / total_predictions\n",
    "            valid_losses.append(valid_loss)\n",
    "            valid_accuracies.append(valid_accuracy)\n",
    "\n",
    "            # Fortschritt anzeigen, falls angegeben\n",
    "            if verbose:\n",
    "                clear_output(wait=True)\n",
    "                print(f'Experiment #{experiment_num} mit {n_pca_components} PCA components: Epoch [{epoch+1}/{n_epochs}], Trainingsverlust: {train_loss:.4f}, Trainingsgenauigkeit: {train_accuracies[-1]:.4f}, Validierungsverlust: {valid_loss:.4f}, Validierungsgenauigkeit: {valid_accuracies[-1]:.4f}')\n",
    "\n",
    "        # Aktualisieren des Graphen\n",
    "        clear_output(wait=True)\n",
    "        fig, ax1 = plt.subplots()\n",
    "\n",
    "        # Zeichnen der Verlustkurven\n",
    "        ax1.plot(train_losses, label='Trainingsverlust', color='r')\n",
    "        ax1.plot(valid_losses, label='Validierungsverlust', color='b')\n",
    "        ax1.set_xlabel('Epochen')\n",
    "        ax1.set_ylabel('Verlust', color='g')\n",
    "        ax1.tick_params(axis='y', labelcolor='g')\n",
    "\n",
    "        # Zweite y-Achse für die Genauigkeit\n",
    "        ax2 = ax1.twinx()\n",
    "        ax2.plot(train_accuracies, label='Trainingsgenauigkeit', color='r', linestyle='dashed')\n",
    "        ax2.plot(valid_accuracies, label='Validierungsgenauigkeit', color='b', linestyle='dashed')\n",
    "        ax2.set_ylabel('Genauigkeit', color='g')\n",
    "        ax2.tick_params(axis='y', labelcolor='g')\n",
    "\n",
    "        # Titel und Legende\n",
    "        plt.title(f'Experiment #{experiment_num}: Trainings- und Validierungsverlust und -genauigkeit über die Zeit mit \\n{n_pca_components}-Hauptkomponenten, Lernrate: {learning_rate}')\n",
    "        fig.tight_layout()\n",
    "\n",
    "        # Legende außerhalb des Graphen\n",
    "        ax1.legend(loc='upper left', bbox_to_anchor=(1.15, 1))\n",
    "        ax2.legend(loc='upper left', bbox_to_anchor=(1.15, 0.85))\n",
    "\n",
    "        # Plot speichern\n",
    "        if experiment_num > 0:\n",
    "            name = str(experiment_num) + \".png\" if experiment_num is not None else \"single_experiment.png\"\n",
    "            if not os.path.exists(\"Experiments\"):\n",
    "                os.makedirs(\"Experiments\")\n",
    "            if not os.path.exists(f\"Experiments/{str(n_pca_components)}\"):\n",
    "                os.makedirs(f\"Experiments/{str(n_pca_components)}\")\n",
    "            plt.savefig(f\"Experiments/{str(n_pca_components)}/{name}\", bbox_inches='tight')\n",
    "\n",
    "        plt.ion()\n",
    "\n",
    "        return model, (train_losses, valid_losses, train_accuracies, valid_accuracies)\n",
    "\n",
    "    def run_single_pca_experiment(self, train_loader: DataLoader, valid_loader: DataLoader, n_pca_components: int, n_experiments: int, n_epochs: int = 200, learning_rate: int = 0.0005, verbose: bool = True) -> List:\n",
    "        \"\"\"\n",
    "        Führt eine Serie von Experimenten mit verschiedenen Konfigurationen für die PCA-Komponenten durch.\n",
    "\n",
    "        Parameter:\n",
    "        train_loader : DataLoader\n",
    "            Der DataLoader für den Trainingsdatensatz.\n",
    "        valid_loader : DataLoader\n",
    "            Der DataLoader für den Validierungsdatensatz.\n",
    "        n_pca_components : int\n",
    "            Anzahl der PCA-Komponenten, die im Modell verwendet werden.\n",
    "        n_experiments : int\n",
    "            Anzahl der durchzuführenden Experimente.\n",
    "        n_epochs : int, optional\n",
    "            Anzahl der Epochen für das Training (Standardwert ist 200).\n",
    "        learning_rate : float, optional\n",
    "            Lernrate für den Optimierer (Standardwert ist 0.0005).\n",
    "        verbose : bool, optional\n",
    "            Gibt an, ob der Trainingsfortschritt angezeigt werden soll (Standardwert ist True).\n",
    "\n",
    "        Rückgabewerte:\n",
    "        List\n",
    "            Eine Liste von Ergebnissen der einzelnen Experimente.\n",
    "        \"\"\"\n",
    "        if not isinstance(n_pca_components, int):\n",
    "            raise TypeError(\"n_pca_components must be an integers!\")\n",
    "\n",
    "        results = []\n",
    "\n",
    "        for n in range(n_experiments):\n",
    "            _, res = self.run_single_experiment(train_loader, valid_loader, n_pca_components, n_epochs=n_epochs, learning_rate=learning_rate, verbose=verbose, experiment_num=n+1)\n",
    "            results.append(res)\n",
    "\n",
    "        return results\n",
    "            \n",
    "\n",
    "    def run(self, n_pca_components: List[int], n_experiments: int, n_epochs: int = 200, learning_rate: int = 0.0005, batch_size: int = 64, verbose: bool = True) -> Dict:\n",
    "        \"\"\"\n",
    "        Hauptmethode zum Ausführen von Experimenten mit verschiedenen Anzahlen von PCA-Komponenten.\n",
    "\n",
    "        Parameter:\n",
    "        n_pca_components : List[int]\n",
    "            Eine Liste von Anzahlen der PCA-Komponenten, die in den Experimenten verwendet werden sollen.\n",
    "        n_experiments : int\n",
    "            Anzahl der durchzuführenden Experimente pro PCA-Komponentenanzahl.\n",
    "        n_epochs : int, optional\n",
    "            Anzahl der Epochen für das Training (Standardwert ist 200).\n",
    "        learning_rate : float, optional\n",
    "            Lernrate für den Optimierer (Standardwert ist 0.0005).\n",
    "        batch_size : int, optional\n",
    "            Batch-Größe für das Laden der Daten (Standardwert ist 64).\n",
    "        verbose : bool, optional\n",
    "            Gibt an, ob der Trainingsfortschritt angezeigt werden soll (Standardwert ist True).\n",
    "\n",
    "        Rückgabewerte:\n",
    "        Dict\n",
    "            Ein Wörterbuch, das die Ergebnisse der Experimente für jede Anzahl von PCA-Komponenten enthält.\n",
    "        \"\"\"\n",
    "        if not isinstance(n_pca_components, list):\n",
    "            raise TypeError(\"n_pca_components must be a list of integers!\")\n",
    "\n",
    "        plt.ioff()\n",
    "        self.n_pca_components = n_pca_components\n",
    "\n",
    "        results = {}\n",
    "\n",
    "        for n_pca_comps in n_pca_components:\n",
    "            genome_dataset = GenomeDataset(data_frame, n_pca_components=n_pca_comps)\n",
    "            train_dataset = genome_dataset.train_df\n",
    "            valid_dataset = genome_dataset.val_df\n",
    "\n",
    "            train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "            valid_loader = DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "            res = self.run_single_pca_experiment(train_loader, valid_loader, n_pca_comps, n_experiments, n_epochs=n_epochs, learning_rate=learning_rate, verbose=verbose)\n",
    "            results[str(n_pca_comps)] = res\n",
    "\n",
    "            self.plot_and_save_results(res, n_pca_comps)\n",
    "\n",
    "        self.results = results\n",
    "\n",
    "        # Speichern der Daten in einer lokalen Datei\n",
    "        if len(n_pca_components) > 1:\n",
    "            with open('Experiments/results.pickle', 'wb') as f:\n",
    "                pickle.dump(self.results, f)\n",
    "        else:\n",
    "            with open(f'Experiments/{str(n_pca_components[0])}/results_{str(n_pca_components[0])}.pickle', 'wb') as f:\n",
    "                pickle.dump(self.results, f)\n",
    "\n",
    "        plt.ion()\n",
    "\n",
    "        return results\n",
    "\n",
    "    def calculate_confusion_matrix(self, n_pca_components: int, n_epochs: int = 500, batch_size: int = 64, learning_rate: float = 0.0005, verbose: bool = True):\n",
    "        \"\"\"\n",
    "        Trainiert ein Modell und erstellt eine Konfusionsmatrix\n",
    "        \"\"\"\n",
    "        all_preds = []\n",
    "        all_targets = []\n",
    "\n",
    "        genome_dataset = GenomeDataset(data_frame, n_pca_components=n_pca_components)\n",
    "        train_dataset = genome_dataset.train_df\n",
    "        valid_dataset = genome_dataset.val_df\n",
    "\n",
    "        train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "        valid_loader = DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "        # if dataset == \"train\":\n",
    "        #     dataset_loader = train_loader\n",
    "        # elif dataset == \"valid\":\n",
    "        #     dataset_loader = valid_loader\n",
    "        # else:\n",
    "        #     raise Warning(\"Invalid Dataset Type!\")\n",
    "        #     return None\n",
    "\n",
    "        model, _ = self.run_single_experiment(train_loader, valid_loader, n_pca_components, n_epochs, learning_rate, verbose, 0)\n",
    "        \n",
    "        def get_predictions_and_targets(loader, model, device):\n",
    "            all_preds = []\n",
    "            all_targets = []\n",
    "            model.eval()\n",
    "\n",
    "            with torch.no_grad():\n",
    "                for data, target in loader:\n",
    "                    data, target = data.to(device), target.to(device)\n",
    "                    outputs = model(data)\n",
    "                    _, preds = torch.max(outputs, 1)\n",
    "                    all_preds.extend(preds.to('cpu').numpy())\n",
    "                    all_targets.extend(target.to('cpu').numpy())\n",
    "\n",
    "            return all_preds, all_targets\n",
    "\n",
    "        # Sammeln der Vorhersagen und wahren Labels von Trainings- und Validierungsdaten\n",
    "        train_preds, train_targets = get_predictions_and_targets(train_loader, model, device)\n",
    "        valid_preds, valid_targets = get_predictions_and_targets(valid_loader, model, device)\n",
    "\n",
    "        # Kombinieren der Daten\n",
    "        all_preds = train_preds + valid_preds\n",
    "        all_targets = train_targets + valid_targets\n",
    "\n",
    "        # Berechnen der Konfusionsmatrix\n",
    "        conf_matrix = confusion_matrix(all_targets, all_preds)\n",
    "\n",
    "        return conf_matrix\n",
    "\n",
    "    def plot_and_save_results(self, results: List[Tuple], n_pca_components: int) -> None:\n",
    "        \"\"\"\n",
    "        Erstellt und speichert Plots für die Ergebnisse der Experimente.\n",
    "\n",
    "        Parameter:\n",
    "        results : List[Tuple]\n",
    "            Eine Liste von Tupeln mit den Ergebnissen der Experimente.\n",
    "        n_pca_components : int\n",
    "            Anzahl der PCA-Komponenten, für die die Ergebnisse geplottet werden sollen.\n",
    "\n",
    "        Keine Rückgabewerte, da die Methode Plots speichert.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Mittelwerte und Standardabweichungen berechnen\n",
    "        train_losses, valid_losses, train_accuracies, valid_accuracies = zip(*results)\n",
    "\n",
    "        train_losses = np.array(train_losses)\n",
    "        valid_losses = np.array(valid_losses)\n",
    "        train_accuracies = np.array(train_accuracies)\n",
    "        valid_accuracies = np.array(valid_accuracies)\n",
    "\n",
    "        avg_train_losses = np.mean(train_losses, axis=0)\n",
    "        avg_valid_losses = np.mean(valid_losses, axis=0)\n",
    "        avg_train_acc = np.mean(train_accuracies, axis=0)\n",
    "        avg_valid_acc = np.mean(valid_accuracies, axis=0)\n",
    "\n",
    "        std_train_losses = np.std(train_losses, axis=0)\n",
    "        std_valid_losses = np.std(valid_losses, axis=0)\n",
    "        std_train_acc = np.std(train_accuracies, axis=0)\n",
    "        std_valid_acc = np.std(valid_accuracies, axis=0)\n",
    "\n",
    "        # Erstellen von Plots\n",
    "        epochs = range(1, len(avg_train_losses) + 1)\n",
    "\n",
    "        # Plot für Verluste\n",
    "        plt.clf()\n",
    "        plt.plot(epochs, avg_train_losses, label='Mittlerer Trainingsverlust', color='r')\n",
    "        plt.fill_between(epochs, np.subtract(avg_train_losses, std_train_losses), np.add(avg_train_losses, std_train_losses), color='r', alpha=0.2)\n",
    "        plt.plot(epochs, avg_valid_losses, label='Mittlerer Validierungsverlust', color='b')\n",
    "        plt.fill_between(epochs, np.subtract(avg_valid_losses, std_valid_losses), np.add(avg_valid_losses, std_valid_losses), color='b', alpha=0.2)\n",
    "        plt.title(f'Mittelwert und Standardabweichung der Verluste für {n_pca_components} PCA-Komponenten')\n",
    "        plt.xlabel('Experiment Nummer')\n",
    "        plt.ylabel('Verlust')\n",
    "        plt.legend()\n",
    "        plt.savefig(f\"Experiments/{n_pca_components}/average_losses.png\", bbox_inches='tight')\n",
    "        plt.clf()\n",
    "\n",
    "        # Plot für Genauigkeiten\n",
    "        plt.plot(epochs, avg_train_acc, label='Mittlere Trainingsgenauigkeit', color='r')\n",
    "        plt.fill_between(epochs, np.subtract(avg_train_acc, std_train_acc), np.add(avg_train_acc, std_train_acc), color='r', alpha=0.2)\n",
    "        plt.plot(epochs, avg_valid_acc, label='Mittlere Validierungsgenauigkeit', color='b')\n",
    "        plt.fill_between(epochs, np.subtract(avg_valid_acc, std_valid_acc), np.add(avg_valid_acc, std_valid_acc), color='b', alpha=0.2)\n",
    "        plt.title(f'Mittelwert und Standardabweichung der Genauigkeiten für {n_pca_components} PCA-Komponenten')\n",
    "        plt.xlabel('Experiment Nummer')\n",
    "        plt.ylabel('Genauigkeit')\n",
    "        plt.legend()\n",
    "        plt.savefig(f\"Experiments/{n_pca_components}/average_accuracies.png\", bbox_inches='tight')\n",
    "        plt.clf()\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Starten der einzelnen Experimente, da in einer Schleife RAM Probleme auftreten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e1 = ExperimentationalExperiments()\n",
    "results = e1.run([1024], 10, n_epochs=500)\n",
    "del e1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e2 = ExperimentationalExperiments()\n",
    "results = e2.run([512], 10, n_epochs=500)\n",
    "del e2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e3 = ExperimentationalExperiments()\n",
    "results = e3.run([256], 10, n_epochs=500)\n",
    "del e3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e4 = ExperimentationalExperiments()\n",
    "results = e4.run([128], 10, n_epochs=500)\n",
    "del e4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e5 = ExperimentationalExperiments()\n",
    "results = e5.run([64], 10, n_epochs=500)\n",
    "del e5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e6 = ExperimentationalExperiments()\n",
    "results = e6.run([32], 10, n_epochs=500)\n",
    "del e6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e7 = ExperimentationalExperiments()\n",
    "results = e7.run([16], 10, n_epochs=500)\n",
    "del e7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e8 = ExperimentationalExperiments()\n",
    "results = e8.run([1034], 10, n_epochs=500)\n",
    "del e8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Erstellung der Konfusionsmatrix für 512 Hauptkomponenten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Experiment #0 mit 512 PCA components: Epoch [500/500], Trainingsverlust: 0.5583, Trainingsgenauigkeit: 0.9927, Validierungsverlust: 0.5903, Validierungsgenauigkeit: 0.9517\n"
     ]
    }
   ],
   "source": [
    "e = ExperimentationalExperiments()\n",
    "conf_matrix = e.calculate_confusion_matrix(512, n_epochs=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "\n",
    "def plot_confusion_matrix(conf_matrix, classes, title='Konfusionsmatrix', cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    Zeichnet die Konfusionsmatrix.\n",
    "\n",
    "    Parameters:\n",
    "        conf_matrix (np.array): Die Konfusionsmatrix.\n",
    "        classes (List): Eine Liste der Klassennamen.\n",
    "        title (str): Der Titel der Grafik.\n",
    "        cmap (matplotlib.colors.Colormap): Die Farbkarte für die Matrix.\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    sns.heatmap(conf_matrix, annot=True, fmt='d', cmap=cmap, xticklabels=classes, yticklabels=classes)\n",
    "    plt.title(title)\n",
    "    plt.ylabel('Wahre Labels')\n",
    "    plt.xlabel('Vorhergesagte Labels')\n",
    "    plt.show()\n",
    "\n",
    "plot_confusion_matrix(conf_matrix, [\"kich\", \"kirc\", \"kirp\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesen der Daten und Erstellen der Mittelwerte und anschließender Auswertung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pickle\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from typing import List, Dict, Tuple\n",
    "\n",
    "def load_results(path: str) -> Dict:\n",
    "    \"\"\"\n",
    "    Lädt und konvertiert die Ergebnisse aus Pickle-Dateien in den spezifizierten Verzeichnissen.\n",
    "\n",
    "    Argumente:\n",
    "    path (str): Der Pfad zum Basisverzeichnis, das die Ergebnis-Unterverzeichnisse enthält.\n",
    "\n",
    "    Rückgabe:\n",
    "    Dict: Ein Dictionary, in dem jeder Schlüssel einer PCA-Komponentenanzahl entspricht und\n",
    "          dessen Werte Achtertupel aus Durchschnitt und Standardabweichung von Trainingsverlust,\n",
    "          Validierungsverlust, Trainingsgenauigkeit und Validierungsgenauigkeit sind.\n",
    "    \"\"\"\n",
    "\n",
    "    results = {}\n",
    "\n",
    "    # Über alle Ordner im Basispfad iterieren\n",
    "    for directory in os.listdir(path):\n",
    "        full_path = os.path.join(path, directory)\n",
    "\n",
    "        # Überprüfen, ob es sich um einen Ordner handelt\n",
    "        if os.path.isdir(full_path):\n",
    "            pickle_file = f'results_{directory}.pickle'\n",
    "            pickle_path = os.path.join(full_path, pickle_file)\n",
    "\n",
    "            # Überprüfen, ob die Pickle-Datei existiert\n",
    "            if os.path.isfile(pickle_path):\n",
    "                # Pickle-Datei laden\n",
    "                with open(pickle_path, 'rb') as file:\n",
    "                    results[directory] = pickle.load(file)\n",
    "\n",
    "    converted_results = {}\n",
    "    for values in list(results.values()):\n",
    "        key = list(values.keys())[0]\n",
    "        value = list(values.values())[0]\n",
    "        converted_results[key] = value\n",
    "\n",
    "    return converted_results\n",
    "\n",
    "\n",
    "def calculate_means_for_n_last(results: Dict, n_last: int) -> Dict:\n",
    "    \"\"\"\n",
    "    Berechnet Durchschnittswerte und Standardabweichungen für die letzten `n_last` Ergebnisse.\n",
    "\n",
    "    Argumente:\n",
    "    results (Dict): Ein Dictionary von Ergebnissen, wie von `load_results` zurückgegeben.\n",
    "    n_last (int): Anzahl der letzten Ergebnisse, die zur Berechnung verwendet werden sollen.\n",
    "\n",
    "    Rückgabe:\n",
    "    Dict: Ein Dictionary mit Schlüsseln als PCA-Komponentenanzahlen und Werten als Achtertupel,\n",
    "          bestehend aus Durchschnitt und Standardabweichung von Trainingsverlust, \n",
    "          Validierungsverlust, Trainingsgenauigkeit und Validierungsgenauigkeit.\n",
    "    \"\"\"\n",
    "\n",
    "    assert results is not None\n",
    "    assert n_last <= len(list(results.values())[0][0][0])\n",
    "\n",
    "    means_and_stds = {}\n",
    "\n",
    "    for key, value in results.items():\n",
    "        train_losses, valid_losses, train_accuracies, valid_accuracies = zip(*value)\n",
    "        \n",
    "        train_losses = train_losses[:n_last]      \n",
    "        valid_losses = valid_losses[:n_last]\n",
    "        train_accuracies = train_accuracies[:n_last]\n",
    "        valid_accuracies = valid_accuracies[:n_last]\n",
    "\n",
    "        avg_train_loss = np.mean(train_losses)#, axis=0)\n",
    "        avg_valid_loss = np.mean(valid_losses)#, axis=0)\n",
    "        avg_train_acc = np.mean(train_accuracies)#, axis=0)\n",
    "        avg_valid_acc = np.mean(valid_accuracies)#, axis=0)\n",
    "\n",
    "        std_train_loss = np.std(train_losses)#, axis=0)\n",
    "        std_valid_loss = np.std(valid_losses)#, axis=0)\n",
    "        std_train_acc = np.std(train_accuracies)#, axis=0)\n",
    "        std_valid_acc = np.std(valid_accuracies)#, axis=0)\n",
    "\n",
    "        print(f\"### {key} PCA Komponenten ###\")\n",
    "        print(f\"Trainingsverlust:        {avg_train_loss:.3f} \\u00B1 {std_train_loss:.3f}\")\n",
    "        print(f\"Validierungsverlust:     {avg_valid_loss:.3f} \\u00B1 {std_valid_loss:.3f}\")\n",
    "        print(f\"Trainingsgenauigkeit:    {avg_train_acc:.3f} \\u00B1 {std_train_acc:.3f}\")\n",
    "        print(f\"Validierungsgenauigkeit: {avg_valid_acc:.3f} \\u00B1 {std_valid_acc:.3f}\\n\")\n",
    "\n",
    "        means_and_stds[key] = (avg_train_loss, std_train_loss, avg_valid_loss, std_valid_loss, avg_train_acc, std_train_acc, avg_valid_acc, std_valid_acc)\n",
    "\n",
    "    # Initialisierung der Variablen für die Minima und Maxima\n",
    "    min_train_loss = float('inf')\n",
    "    min_valid_loss = float('inf')\n",
    "    max_train_acc = 0\n",
    "    max_valid_acc = 0\n",
    "\n",
    "    # Durchlaufen aller berechneten Mittelwerte und Standardabweichungen\n",
    "    for key, (avg_train_loss, std_train_loss, avg_valid_loss, std_valid_loss, avg_train_acc, std_train_acc, avg_valid_acc, std_valid_acc) in means_and_stds.items():\n",
    "        if avg_train_loss < min_train_loss:\n",
    "            min_train_loss = avg_train_loss\n",
    "            min_train_loss_key = key\n",
    "\n",
    "        if avg_valid_loss < min_valid_loss:\n",
    "            min_valid_loss = avg_valid_loss\n",
    "            min_valid_loss_key = key\n",
    "\n",
    "        if avg_train_acc > max_train_acc:\n",
    "            max_train_acc = avg_train_acc\n",
    "            max_train_acc_key = key\n",
    "\n",
    "        if avg_valid_acc > max_valid_acc:\n",
    "            max_valid_acc = avg_valid_acc\n",
    "            max_valid_acc_key = key\n",
    "\n",
    "    # Drucken der Endresultate\n",
    "    print(f\"### Auswertung ###\")\n",
    "    print(f\"Niedrigster Trainingsverlust:    {min_train_loss:.3f} bei {min_train_loss_key} PCA-Komponenten\")\n",
    "    print(f\"Niedrigster Validierungsverlust: {min_valid_loss:.3f} bei {min_valid_loss_key} PCA-Komponenten\")\n",
    "    print(f\"Höchste Trainingsgenauigkeit:    {max_train_acc:.3f} bei {max_train_acc_key} PCA-Komponenten\")\n",
    "    print(f\"Höchste Validierungsgenauigkeit: {max_valid_acc:.3f} bei {max_valid_acc_key} PCA-Komponenten\")\n",
    "\n",
    "    return means_and_stds\n",
    "\n",
    "\n",
    "def plot_results(results: Dict, show_lines: bool = True) -> None:\n",
    "    \"\"\"\n",
    "    Stellt die Ergebnisse als Fehlerbalkendiagramme dar. Jedes Diagramm zeigt Mittelwert und\n",
    "    Standardabweichung von Trainings- und Validierungsverlust sowie -genauigkeit. \n",
    "    Fügt zusätzlich eine rote Linie für den höchsten Genauigkeitswert und den geringsten Verlustwert hinzu,\n",
    "    mit einer Beschriftung, die den Schlüssel des entsprechenden höchsten bzw. niedrigsten Werts anzeigt.\n",
    "\n",
    "    Argumente:\n",
    "    results (Dict): Ein Dictionary von berechneten Mittelwerten und Standardabweichungen,\n",
    "                    wie von `calculate_means_for_n_last` zurückgegeben.\n",
    "    show_lines (bool): Ein flag, das angibt, ob die Maximal- / Minimallinie gezeichnet werden soll.\n",
    "    \"\"\"\n",
    "    # Schlüssel sortieren\n",
    "    sorted_keys = sorted(results.keys(), key=lambda x: int(x))\n",
    "\n",
    "    # Listen für das Plotten vorbereiten\n",
    "    mean_train_loss = [results[k][0] for k in sorted_keys]\n",
    "    std_train_loss = [results[k][1] for k in sorted_keys]\n",
    "    mean_validation_loss = [results[k][2] for k in sorted_keys]\n",
    "    std_validation_loss = [results[k][3] for k in sorted_keys]\n",
    "    mean_train_accuracy = [results[k][4] for k in sorted_keys]\n",
    "    std_train_accuracy = [results[k][5] for k in sorted_keys]\n",
    "    mean_validation_accuracy = [results[k][6] for k in sorted_keys]\n",
    "    std_validation_accuracy = [results[k][7] for k in sorted_keys]\n",
    "\n",
    "    # Plotten\n",
    "    plt.figure(figsize=(12, 8))\n",
    "\n",
    "    # Verluste\n",
    "    plt.errorbar(sorted_keys, mean_train_loss, yerr=std_train_loss, label='Trainingverlust', fmt='o', linestyle='--', alpha=0.5)\n",
    "    plt.errorbar(sorted_keys, mean_validation_loss, yerr=std_validation_loss, label='Validierungsverlust', fmt='o', linestyle='--', alpha=0.5)\n",
    "\n",
    "    # Genauigkeiten\n",
    "    plt.errorbar(sorted_keys, mean_train_accuracy, yerr=std_train_accuracy, label='Trainingsgenauigkeit', fmt='x', linestyle='--', alpha=0.5)\n",
    "    plt.errorbar(sorted_keys, mean_validation_accuracy, yerr=std_validation_accuracy, label='Validierungsgenauigkeit', fmt='x', linestyle='--', alpha=0.5)\n",
    "\n",
    "    # Gestaltung\n",
    "    plt.xlabel('Anzahl der PCA Komponenten')\n",
    "    plt.ylabel('Werte')\n",
    "    plt.title('Trainings- und Validierungsverlust und -genauigkeit')\n",
    "    plt.grid(True)\n",
    "\n",
    "    # Höchste Genauigkeit und geringster Verlust\n",
    "    highest_accuracy = max(max(mean_train_accuracy), max(mean_validation_accuracy))\n",
    "    lowest_loss = min(min(mean_train_loss), min(mean_validation_loss))\n",
    "\n",
    "    # Schlüssel für höchste Genauigkeit und geringsten Verlust finden\n",
    "    highest_acc_key = sorted_keys[mean_train_accuracy.index(max(mean_train_accuracy))] if max(mean_train_accuracy) > max(mean_validation_accuracy) else sorted_keys[mean_validation_accuracy.index(max(mean_validation_accuracy))]\n",
    "    lowest_loss_key = sorted_keys[mean_train_loss.index(min(mean_train_loss))] if min(mean_train_loss) < min(mean_validation_loss) else sorted_keys[mean_validation_loss.index(min(mean_validation_loss))]\n",
    "\n",
    "    plt.legend()\n",
    "\n",
    "    # Linien und Text für höchste Genauigkeit und geringsten Verlust\n",
    "    if show_lines:\n",
    "        plt.axhline(y=highest_accuracy, color='r', linestyle='-', alpha=0.8)\n",
    "        plt.text(0.95, highest_accuracy, f'Höchste Genauigkeit (PCA: {highest_acc_key})', verticalalignment='bottom', horizontalalignment='right', color='red', fontsize=10, transform=plt.gca().get_yaxis_transform())\n",
    "\n",
    "        plt.axhline(y=lowest_loss, color='r', linestyle='-', alpha=0.8)\n",
    "        plt.text(0.95, lowest_loss, f'Geringster Verlust (PCA: {lowest_loss_key})', verticalalignment='top', horizontalalignment='right', color='red', fontsize=10, transform=plt.gca().get_yaxis_transform())\n",
    "        \n",
    "        plt.savefig('Experiments/Endergebnisse_mit_Linien.png')\n",
    "    else:\n",
    "        plt.savefig('Experiments/Endergebnisse_ohne_Linien.png')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Ergebnisse laden\n",
    "base_path = 'Experiments'\n",
    "loaded_results = load_results(base_path)\n",
    "\n",
    "# Ergebnisse verarbeiten und plotten\n",
    "m_a_s = calculate_means_for_n_last(loaded_results, 50)\n",
    "plot_results(m_a_s, show_lines=False)\n",
    "plot_results(m_a_s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO MNIST datenstaz mit wget ohne tensorflow oder pytorch einlesen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rl",
   "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.18"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}