{
 "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": 3,
   "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\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": 40,
   "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": 99,
   "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",
    "\n",
    "# Verlustfunktion\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "learning_rate = 0.0003\n",
    "\n",
    "# Optimierer\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "# Anzahl der Epochen\n",
    "num_epochs = 1000\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "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 [1000/1000], Trainingsverlust: 0.5610, Trainingsgenauigkeit: 0.9915, Validierungsverlust: 0.5992, Validierungsgenauigkeit: 0.9565\n"
     ]
    }
   ],
   "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}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.9.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}