2024-01-04 14:47:29 +01:00
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Laden der Rohdaten"
]
},
{
"cell_type": "code",
2024-01-04 15:06:10 +01:00
"execution_count": 1,
2024-01-04 14:47:29 +01:00
"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)"
]
},
2024-01-04 15:06:10 +01:00
{
"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.\")"
]
},
2024-01-04 14:47:29 +01:00
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# PCA Klasse zu Reduktion der Dimensionen"
]
},
{
"cell_type": "code",
2024-01-04 15:06:10 +01:00
"execution_count": 3,
2024-01-04 14:47:29 +01:00
"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",
2024-01-04 15:06:10 +01:00
"execution_count": 4,
2024-01-04 14:47:29 +01:00
"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",
2024-01-04 15:06:10 +01:00
"execution_count": 5,
2024-01-04 14:47:29 +01:00
"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",
2024-01-04 15:06:10 +01:00
"model.to(device=device)\n",
2024-01-04 14:47:29 +01:00
"\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",
2024-01-04 15:06:10 +01:00
"execution_count": 6,
2024-01-04 14:47:29 +01:00
"metadata": {},
2024-01-04 15:06:10 +01:00
"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"
]
}
],
2024-01-04 14:47:29 +01:00
"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",
2024-01-04 15:06:10 +01:00
"num_epochs = 200\n"
2024-01-04 14:47:29 +01:00
]
},
{
"cell_type": "code",
2024-01-04 15:06:10 +01:00
"execution_count": 7,
2024-01-04 14:47:29 +01:00
"metadata": {},
"outputs": [
2024-01-04 15:06:10 +01:00
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 640x480 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
2024-01-04 14:47:29 +01:00
{
"name": "stdout",
"output_type": "stream",
"text": [
2024-01-04 15:06:10 +01:00
"Epoch [200/200], Trainingsverlust: 0.6159, Validierungsverlust: 0.6616\n"
2024-01-04 14:47:29 +01:00
]
}
],
"source": [
2024-01-04 15:06:10 +01:00
"from IPython.display import clear_output\n",
"import matplotlib.pyplot as plt\n",
"\n",
2024-01-04 14:47:29 +01:00
"# Listen, um Verluste zu speichern\n",
"train_losses = []\n",
"valid_losses = []\n",
2024-01-04 15:06:10 +01:00
"train_accuracies = []\n",
"valid_accuracies = []\n",
2024-01-04 14:47:29 +01:00
"\n",
"for epoch in range(num_epochs):\n",
" model.train()\n",
" train_loss = 0.0\n",
2024-01-04 15:06:10 +01:00
" correct_predictions = 0\n",
" total_predictions = 0\n",
"\n",
2024-01-04 14:47:29 +01:00
" for i, (inputs, labels) in enumerate(train_loader):\n",
2024-01-04 15:06:10 +01:00
" inputs, labels = inputs.to(device), labels.to(device)\n",
2024-01-04 14:47:29 +01:00
" 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",
2024-01-04 15:06:10 +01:00
" # 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",
2024-01-04 14:47:29 +01:00
" train_loss /= len(train_loader)\n",
2024-01-04 15:06:10 +01:00
" train_accuracy = correct_predictions / total_predictions\n",
2024-01-04 14:47:29 +01:00
" train_losses.append(train_loss)\n",
2024-01-04 15:06:10 +01:00
" train_accuracies.append(train_accuracy)\n",
2024-01-04 14:47:29 +01:00
"\n",
2024-01-04 15:06:10 +01:00
" # Validierungsverlust und Genauigkeit\n",
2024-01-04 14:47:29 +01:00
" model.eval()\n",
" valid_loss = 0.0\n",
2024-01-04 15:06:10 +01:00
" correct_predictions = 0\n",
" total_predictions = 0\n",
"\n",
2024-01-04 14:47:29 +01:00
" with torch.no_grad():\n",
" for inputs, labels in valid_loader:\n",
2024-01-04 15:06:10 +01:00
" inputs, labels = inputs.to(device), labels.to(device)\n",
2024-01-04 14:47:29 +01:00
" outputs = model(inputs)\n",
" loss = criterion(outputs, labels)\n",
" valid_loss += loss.item()\n",
"\n",
2024-01-04 15:06:10 +01:00
" # 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",
2024-01-04 14:47:29 +01:00
" valid_loss /= len(valid_loader)\n",
2024-01-04 15:06:10 +01:00
" valid_accuracy = correct_predictions / total_predictions\n",
2024-01-04 14:47:29 +01:00
" valid_losses.append(valid_loss)\n",
2024-01-04 15:06:10 +01:00
" 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",
2024-01-04 14:47:29 +01:00
"\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",
2024-01-04 15:06:10 +01:00
"version": "3.9.13"
2024-01-04 14:47:29 +01:00
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
