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

{
 "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
}