{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Laden der Rohdaten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "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": 10,
   "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": 11,
   "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, 512)  # Eingabeschicht\n",
    "        self.fc2 = nn.Linear(512, 256)        # Versteckte Schicht\n",
    "        self.fc3 = nn.Linear(256, 128)         # Weitere versteckte Schicht\n",
    "        self.fc4 = nn.Linear(128, 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 = torch.sigmoid(self.fc4(x))  # Oder F.log_softmax(x, dim=1) für Mehrklassenklassifikation\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "\n",
    "N_COMPONENTS = 512\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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "# Verlustfunktion\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Optimierer\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# Anzahl der Epochen\n",
    "num_epochs = 200\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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 [200/200], Trainingsverlust: 0.5581, Validierungsverlust: 0.5943\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",
    "\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('Trainings- und Validierungsverlust und -genauigkeit über die Zeit')\n",
    "    fig.tight_layout()\n",
    "    ax1.legend(loc='lower left')\n",
    "    ax2.legend(loc='lower right')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Trainingsverlust: {train_loss:.4f}, Validierungsverlust: {valid_loss:.4f}')"
   ]
  },
  {
   "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
}