diff --git a/project-cancer-classification-pca-nn.ipynb b/project-cancer-classification-pca-nn.ipynb
index 5002fd8..2db6920 100644
--- a/project-cancer-classification-pca-nn.ipynb
+++ b/project-cancer-classification-pca-nn.ipynb
@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -29,7 +29,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -59,7 +59,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,7 +70,7 @@
     "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\n",
+    "from typing import List, Tuple, Dict\n",
     "\n",
     "\n",
     "class GenomeDataset(Dataset):\n",
@@ -193,7 +193,7 @@
     "                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",
+    "        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",
@@ -242,7 +242,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -310,56 +310,230 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
     "from torch.utils.data import DataLoader\n",
-    "\n",
-    "N_COMPONENTS = 96\n",
-    "\n",
-    "# Erstellen der Dataframe Klasse\n",
-    "genome_dataset = GenomeDataset(data_frame, n_pca_components=N_COMPONENTS)\n",
-    "train_dataset = genome_dataset.train_df\n",
-    "valid_dataset = genome_dataset.val_df\n",
-    "\n",
-    "# Annahme: input_size ist die Länge Ihrer Genome-Frequenzen und num_classes ist die Anzahl der Krebsarten\n",
-    "model = CancerClassifierNN(input_size=N_COMPONENTS, num_classes=3)\n",
-    "model.to(device=device)\n",
-    "\n",
-    "# Daten-Loader\n",
-    "train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n",
-    "valid_loader = DataLoader(dataset=valid_dataset, batch_size=64, shuffle=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 100,
-   "metadata": {},
-   "outputs": [],
-   "source": [
     "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",
-    "# Verlustfunktion\n",
-    "criterion = nn.CrossEntropyLoss()\n",
+    "class ExperimentationalExperiments():\n",
     "\n",
-    "learning_rate = 0.0003\n",
+    "    def __init__(self) -> None:\n",
+    "        self.results = None\n",
     "\n",
-    "# Optimierer\n",
-    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\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",
-    "# Anzahl der Epochen\n",
-    "num_epochs = 1000\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": 101,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -371,112 +545,193 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch [1000/1000], Trainingsverlust: 0.5610, Trainingsgenauigkeit: 0.9915, Validierungsverlust: 0.5992, Validierungsgenauigkeit: 0.9565\n"
+      "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": [
-    "from IPython.display import clear_output\n",
-    "import matplotlib.pyplot as plt\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(num_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'Trainings- und Validierungsverlust und -genauigkeit über die Zeit mit \\n{N_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",
-    "    plt.show()\n",
-    "\n",
-    "    print(f'Epoch [{epoch+1}/{num_epochs}], Trainingsverlust: {train_loss:.4f}, Trainingsgenauigkeit: {train_accuracies[-1]:.4f}, Validierungsverlust: {valid_loss:.4f}, Validierungsgenauigkeit: {valid_accuracies[-1]:.4f}')"
+    "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": []
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -501,7 +756,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13"
+   "version": "3.8.18"
   },
   "orig_nbformat": 4
  },