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

{
 "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": 4,
   "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, 1024)  # Eingabeschicht\n",
    "        self.fc2 = nn.Linear(1024, 512)        # Versteckte Schicht\n",
    "        self.fc3 = nn.Linear(512, 256)         # Weitere versteckte Schicht\n",
    "        self.fc4 = nn.Linear(256, 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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# Erstellen der Dataframe Klasse\n",
    "genome_dataset = GenomeDataset(data_frame)\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=1034, 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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\meiko\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python39\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "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": 7,
   "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.6159, Validierungsverlust: 0.6616\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}')"
   ]
  }
 ],
 "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
}