pickel-cancer-rick/project-cancer-classification-pca-nn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Laden der Rohdaten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 8,
   "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": 9,
   "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.8, 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": 10,
   "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",
    "\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": 11,
   "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",
    "\n",
    "class ExperimentationalExperiments():\n",
    "\n",
    "    def __init__(self) -> 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",
    "        if not isinstance(n_pca_components, int):\n",
    "            raise TypeError(\"n_pca_components must be an integers!\")\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",
    "            if valid_accuracy >= 0.999:\n",
    "                break\n",
    "\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",
    "            # Fortschritt anzeigen, falls angegeben\n",
    "            if verbose:\n",
    "                # Plot speichern\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}\")\n",
    "\n",
    "                plt.show()\n",
    "                print(f'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",
    "        return 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",
    "        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",
    "        if not isinstance(n_pca_components, list):\n",
    "            raise TypeError(\"n_pca_components must be a list of integers!\")\n",
    "\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",
    "        return results\n",
    "\n",
    "    def plot_and_save_results(self, results: List[Tuple], n_pca_components: int) -> None:\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.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\")\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\")\n",
    "        plt.clf()\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [10/10], Trainingsverlust: 0.8922, Trainingsgenauigkeit: 0.6554, Validierungsverlust: 0.7765, Validierungsgenauigkeit: 0.8213\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'128': [([1.1048660278320312,\n",
       "    1.0021918095075166,\n",
       "    0.9533032820774958,\n",
       "    0.9180488632275507,\n",
       "    0.8890538536585294,\n",
       "    0.8560153337625357,\n",
       "    0.8325601586928735,\n",
       "    0.7921991394116328,\n",
       "    0.7684880128273597,\n",
       "    0.7482978334793677],\n",
       "   [1.0328907370567322,\n",
       "    0.9768994599580765,\n",
       "    0.9316655248403549,\n",
       "    0.8864333480596542,\n",
       "    0.8357236087322235,\n",
       "    0.7867822349071503,\n",
       "    0.7491058260202408,\n",
       "    0.7292499840259552,\n",
       "    0.7173636108636856,\n",
       "    0.7077213227748871],\n",
       "   [0.3808948004836759,\n",
       "    0.5646916565900847,\n",
       "    0.6178960096735188,\n",
       "    0.6360338573155986,\n",
       "    0.660217654171705,\n",
       "    0.6856106408706167,\n",
       "    0.7267230955259976,\n",
       "    0.7678355501813785,\n",
       "    0.7980652962515115,\n",
       "    0.8089480048367593],\n",
       "   [0.5603864734299517,\n",
       "    0.5603864734299517,\n",
       "    0.5700483091787439,\n",
       "    0.6280193236714976,\n",
       "    0.7342995169082126,\n",
       "    0.7874396135265701,\n",
       "    0.7971014492753623,\n",
       "    0.8115942028985508,\n",
       "    0.8309178743961353,\n",
       "    0.8454106280193237]),\n",
       "  ([1.07738203727282,\n",
       "    0.974720102090102,\n",
       "    0.8973770370850196,\n",
       "    0.8750206277920649,\n",
       "    0.828568004644834,\n",
       "    0.7929298465068524,\n",
       "    0.776282012462616,\n",
       "    0.7521205315223107,\n",
       "    0.7466858258614173,\n",
       "    0.7324622090046222],\n",
       "   [0.9812372475862503,\n",
       "    0.8927455991506577,\n",
       "    0.8332259058952332,\n",
       "    0.780693456530571,\n",
       "    0.7470725178718567,\n",
       "    0.7277732938528061,\n",
       "    0.7195615023374557,\n",
       "    0.7130803763866425,\n",
       "    0.7097116559743881,\n",
       "    0.7066716551780701],\n",
       "   [0.4183796856106409,\n",
       "    0.585247883917775,\n",
       "    0.6650544135429263,\n",
       "    0.6747279322853688,\n",
       "    0.7291414752116082,\n",
       "    0.7690447400241838,\n",
       "    0.7847642079806529,\n",
       "    0.8077388149939541,\n",
       "    0.8077388149939541,\n",
       "    0.8174123337363967],\n",
       "   [0.7777777777777778,\n",
       "    0.7632850241545893,\n",
       "    0.7729468599033816,\n",
       "    0.8067632850241546,\n",
       "    0.8309178743961353,\n",
       "    0.8309178743961353,\n",
       "    0.8357487922705314,\n",
       "    0.8405797101449275,\n",
       "    0.8357487922705314,\n",
       "    0.8357487922705314])],\n",
       " '64': [([1.1704304309991689,\n",
       "    1.123612798177279,\n",
       "    1.0620490037477934,\n",
       "    1.0275296935668359,\n",
       "    1.0067202678093543,\n",
       "    0.9626164573889512,\n",
       "    0.9474408672406123,\n",
       "    0.9108310204285842,\n",
       "    0.8937133229695834,\n",
       "    0.8762712020140427],\n",
       "   [1.1392732560634613,\n",
       "    1.0526379346847534,\n",
       "    0.9852658659219742,\n",
       "    0.935427650809288,\n",
       "    0.8939110040664673,\n",
       "    0.8603413552045822,\n",
       "    0.8327844738960266,\n",
       "    0.8083746880292892,\n",
       "    0.7864409983158112,\n",
       "    0.7707570642232895],\n",
       "   [0.2720677146311971,\n",
       "    0.3422007255139057,\n",
       "    0.4607013301088271,\n",
       "    0.4703748488512696,\n",
       "    0.5054413542926239,\n",
       "    0.5804111245465539,\n",
       "    0.5949214026602176,\n",
       "    0.6348246674727932,\n",
       "    0.6517533252720678,\n",
       "    0.6771463119709794],\n",
       "   [0.2463768115942029,\n",
       "    0.4927536231884058,\n",
       "    0.6280193236714976,\n",
       "    0.6714975845410628,\n",
       "    0.6956521739130435,\n",
       "    0.7198067632850241,\n",
       "    0.7342995169082126,\n",
       "    0.748792270531401,\n",
       "    0.7584541062801933,\n",
       "    0.7632850241545893]),\n",
       "  ([1.2071779507857103,\n",
       "    1.1123931407928467,\n",
       "    1.0899395575890174,\n",
       "    1.0431747711621797,\n",
       "    0.99530978844716,\n",
       "    0.986173152923584,\n",
       "    0.9467862248420715,\n",
       "    0.9212788801926833,\n",
       "    0.9122511377701392,\n",
       "    0.8921931798641498],\n",
       "   [1.1124519407749176,\n",
       "    1.0438154637813568,\n",
       "    0.9916806370019913,\n",
       "    0.9486012309789658,\n",
       "    0.9076720178127289,\n",
       "    0.8729775846004486,\n",
       "    0.8453357666730881,\n",
       "    0.819965660572052,\n",
       "    0.7980590611696243,\n",
       "    0.7765364795923233],\n",
       "   [0.2551390568319226,\n",
       "    0.36638452237001207,\n",
       "    0.4159613059250302,\n",
       "    0.48972188633615477,\n",
       "    0.5538089480048367,\n",
       "    0.5767835550181378,\n",
       "    0.6021765417170496,\n",
       "    0.6432889963724304,\n",
       "    0.6348246674727932,\n",
       "    0.6553808948004837],\n",
       "   [0.4057971014492754,\n",
       "    0.6183574879227053,\n",
       "    0.6763285024154589,\n",
       "    0.6956521739130435,\n",
       "    0.6956521739130435,\n",
       "    0.7101449275362319,\n",
       "    0.7294685990338164,\n",
       "    0.7584541062801933,\n",
       "    0.7777777777777778,\n",
       "    0.821256038647343])]}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "e = ExperimentationalExperiments()\n",
    "e.run([1024, 512, 256, 128, 64, 32, 16], 10, n_epochs=500)"
   ]
  },
  {
   "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
}