Datasets
Models
Diff of
/SessionIII_MultiOmics/SingleCellML.ipynb
[000000]
..
[b798eb]
Switch to side-by-side view
--- a +++ b/SessionIII_MultiOmics/SingleCellML.ipynb @@ -0,0 +1,1018 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single-cell RNA data on Minimal Residual disease for melanoma!\n", + "![MRD](mrd.png \"Minimal residual Disease for melanoma\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Outcome\n", + "\n", + "After this session you will be able to load and pre-process your multi-omics data to generate lower-dimensional embeddings. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quality Control\n", + "![qc](mrd1.png \"Quality Control for MRD\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate lower-dimensional embeddings\n", + "\n", + "We will perform dimensionality reduction and generate lower-dimensional embeddings of the single-cell RNAseq data using two methods:\n", + "* PCA (https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html)\n", + "* Neural Networks (https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns \n", + "sns.set_style('dark')\n", + "\n", + "# ====== Scikit-learn imports ======\n", + "\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import (\n", + " auc,\n", + " roc_curve,\n", + " ConfusionMatrixDisplay,\n", + " f1_score,\n", + " balanced_accuracy_score,\n", + ")\n", + "from sklearn.preprocessing import StandardScaler, LabelBinarizer\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.decomposition import PCA\n", + "\n", + "## ====== Torch imports ======\n", + "import torch\n", + "import torch.nn as nn \n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from lightning.pytorch.utilities.types import OptimizerLRScheduler\n", + "import torch.utils.data\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "\n", + "import lightning, lightning.pytorch.loggers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(369, 2002)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3025929/715312502.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " labels_filtered['Labels'] = [x.split(' ')[1] for x in labels_filtered['Labels']]\n" + ] + } + ], + "source": [ + "df = pd.read_csv(\"../data/GSE116237_forQ.csv\")\n", + "print(df.shape)\n", + "labels = pd.read_csv(\"../data/GSE116237 filtered labels.csv\")\n", + "labels.drop('Unnamed: 0', axis=1, inplace=True)\n", + "labels.columns = ['Cells', 'Labels']\n", + "labels_filtered = labels[labels['Cells'].isin(list(df['Cells']))]\n", + "labels_filtered['Labels'] = [x.split(' ')[1] for x in labels_filtered['Labels']]\n", + "df = pd.merge(df, labels_filtered, on='Cells', how='inner')\n", + "df['Labels'] = df['Labels'].map({'T0': 0, 'phase2': 1})\n", + "y = np.array(df['Labels'])\n", + "X = df[df.columns[1:-1]].values\n", + "\n", + "num_samples = X.shape[0]\n", + "num_feats = X.shape[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Split into training and testing" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X_working, X_held_out, y_working, y_held_out = train_test_split(X,\n", + " y,\n", + " train_size=0.8,\n", + " shuffle=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### PCA" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data dimensions: (295, 2001)\n", + "Embedded train dimensions: (295, 5)\n", + "Testing data dimensions: (74, 2001)\n", + "Embedded test dimensions: (74, 5)\n" + ] + } + ], + "source": [ + "output_dim = 5\n", + "pca = PCA(n_components=output_dim)\n", + "scaler = StandardScaler()\n", + "X_train_scaled = scaler.fit_transform(X_working)\n", + "embedding_train = pca.fit_transform(X_train_scaled)\n", + "X_test_scaled = scaler.fit_transform(X_held_out)\n", + "embedding_test = pca.fit_transform(X_test_scaled)\n", + "print(\"Training data dimensions: \", X_working.shape)\n", + "print(\"Embedded train dimensions: \", embedding_train.shape)\n", + "print(\"Testing data dimensions: \", X_held_out.shape)\n", + "print(\"Embedded test dimensions: \", embedding_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Neural Networks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the network in Pytorch lightning" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "embedder = torch.nn.Sequential(\n", + " nn.Linear(num_feats,256),\n", + " nn.LeakyReLU(),\n", + " nn.Linear(256,64),\n", + " nn.LeakyReLU(),\n", + " nn.Linear(64,32), \n", + " nn.LeakyReLU(),\n", + " nn.Linear(32,16), \n", + " nn.LeakyReLU(),\n", + " nn.Linear(16,output_dim),\n", + " nn.LeakyReLU(), \n", + " ) \n", + "\n", + "classifier = torch.nn.Sequential(\n", + " nn.Linear(output_dim,1),\n", + " nn.Softmax(dim=1)\n", + " )\n", + "class BinaryClassifierModel(lightning.LightningModule):\n", + " def __init__(self, embedder, classifier, input_dim,learning_rate=1e-3):\n", + " super().__init__()\n", + " self.input_dim = input_dim\n", + " self.embedder = embedder\n", + " self.classifier = classifier\n", + " self.learning_rate = learning_rate\n", + " self.loss_fun = nn.BCELoss()\n", + " \n", + " def train_dataloader(self):\n", + " return DataLoader(self.train_data, batch_size=32, shuffle=True)\n", + "\n", + " def val_dataloader(self):\n", + " return DataLoader(self.val_data, batch_size=32) # No shuffling for validation\n", + " \n", + " def forward(self, X): \n", + " x = self.embedder(X)\n", + " x = self.classifier(x) \n", + " return x \n", + " \n", + " def training_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y = y.unsqueeze(1)\n", + " y_float = y.float()\n", + " x_embedder = self.embedder(x)\n", + " y_hat = self.classifier(x_embedder)\n", + " #y_hat = torch.argmax(y_hat, dim=1)\n", + " loss = self.loss_fun(y_hat, y_float)\n", + " self.log(\"train_loss\", loss, \n", + " prog_bar=True, \n", + " logger=True)\n", + " return loss\n", + " \n", + " def validation_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y = y.unsqueeze(1)\n", + " y_float = y.float()\n", + " x_embedder = self.embedder(x)\n", + " y_hat = self.classifier(x_embedder)\n", + " val_loss = self.loss_fun(y_hat, y_float)\n", + " f1score = f1_score(y_hat, y)\n", + " #print(f1score)\n", + " #print(val_loss)\n", + " self.log(\"val_loss\", val_loss, prog_bar=False, logger=True) # Log on epoch end\n", + " return val_loss\n", + "\n", + " \n", + " def configure_optimizers(self):\n", + " return torch.optim.Adam(self.classifier.parameters(), lr=self.learning_rate)\n", + " \n", + "def prepare_data(X_train, y_train, X_val, y_val):\n", + " # Assuming X and y are NumPy arrays\n", + "\n", + " train_data = TensorDataset(torch.tensor(X_train, dtype=torch.float32), \n", + " torch.tensor(y_train, dtype=torch.float32))\n", + " val_data = TensorDataset(torch.tensor(X_val, dtype=torch.float32), \n", + " torch.tensor(y_val, dtype=torch.float32))\n", + " \n", + " return train_data, val_data " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compute the embeddings using the network and get lower dimension embeddings in the form of matrices for downstream QML tasks" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "2024-07-12 13:12:26.638257: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-07-12 13:12:26.651571: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:479] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-07-12 13:12:26.671424: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:10575] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-07-12 13:12:26.671449: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1442] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-07-12 13:12:26.684350: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-07-12 13:12:27.415951: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "\n", + " | Name | Type | Params | Mode \n", + "--------------------------------------------------\n", + "0 | embedder | Sequential | 531 K | train\n", + "1 | classifier | Sequential | 6 | train\n", + "2 | loss_fun | BCELoss | 0 | train\n", + "--------------------------------------------------\n", + "531 K Trainable params\n", + "0 Non-trainable params\n", + "531 K Total params\n", + "2.127 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "afd281a3a6ac4be6ae161d27f15c8e56", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/abose/QMLOmics/SessionIII_MultiOmics/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:424: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=191` in the `DataLoader` to improve performance.\n", + "/home/abose/QMLOmics/SessionIII_MultiOmics/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:424: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=191` in the `DataLoader` to improve performance.\n", + "/home/abose/QMLOmics/SessionIII_MultiOmics/.venv/lib/python3.10/site-packages/lightning/pytorch/loops/fit_loop.py:298: The number of training batches (9) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2feb697f40ce4fe1a7d2f98f2e328f92", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1866594d0bde4a43aa631377b0d8df6b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "50fbcc83f53f442cbad46e38913a218b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41d8b1ed01d2431696fce99afae9dc71", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "902026fc5c1347b1b4f150d49313c067", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "26bfff9443aa4a2697c707c06b246e2a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eaa3399fcdf147bf84b357300828c816", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1fbaed0d8f4f4575ad03ad4dd78fcd9e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d38ac2789784e20a612a71e38fda98f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3ed88b70b68e4421b9be0774799d7a11", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "410e31b0fc8b4947b617d00d181ed5fe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3c809906d16c4181adbf366e46774a23", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9a2c0a33fb524a599cb094dc3a690484", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0cb0d96880a64b4d94c86ab36f4029cd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae97bce46fbe4f128928d3d06ce481b0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b35824fd78e843dd9cd332a139636f4c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5da6734d8a90481a9463bfce99e5f786", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6b36092d92594a59967e21f0ff258005", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9f9bd47d5d64909916996ee563c55ce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a309af8ebdb043f686d7fca5002b7fc5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5916500305484ddba658d94c139f0ce2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "29397c5350bd4fcca1e3e6ec15289f16", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0b973052d23d4633b7ad8c857ecab896", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "800621fcc3d447c9bb9aae4612469fe3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "589ab988ed3a4a9191e91ceeffd95bbb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8ab7fdd5b30a4d78a61037b76843c883", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6953b322b6bb48989d80fcd563914d96", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b9695946233d4e1d9f67e68bf459b2a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "667a451df9eb49ceaece4de0780fca12", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a938f5b709934ed6a3c46843276d9d19", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "21272ee9f2934f699b97b3cc84f90eef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "949bd80e3bb9469e8496eb333c4efa79", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8f06b68975cb4cdea69328626b62d0ce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2d4486c1d5094d419cea9b4249ee67ba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "43f06e9af03549d48c56074332d1b0ce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4680640dc1904e7d87c1d02cb817b8bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "92ef38a4c8314805a3c27ed94929b46f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5b65eb5da1ad451fb01235fc22d83478", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "46cf08a04d00430cb780c555189c56aa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "19dc01567a744838a98b2ae6ea833c11", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d4e9d6f7d8214b47ad0beb604847d952", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=40` reached.\n" + ] + } + ], + "source": [ + "f1s = []\n", + "embeddings_train = []\n", + "embeddings_test = []\n", + "train_labels = []\n", + "test_labels = [] \n", + "\n", + "num_iter = 1\n", + "for i in range(num_iter): \n", + "\n", + " X_train, X_test, y_train, y_test = train_test_split(X_working,\n", + " y_working,\n", + " train_size=0.9,\n", + " shuffle=True)\n", + "\n", + " num_epochs = 40\n", + " model = BinaryClassifierModel(embedder, classifier, input_dim=num_feats)\n", + " model.train_data, model.val_data = prepare_data(X_train, y_train, X_test, y_test) # Prepare data for training\n", + " logger = lightning.pytorch.loggers.TensorBoardLogger(save_dir=\".\",name=\"original_classifier\")\n", + " # Train the model\n", + " trainer = lightning.Trainer(max_epochs=num_epochs, \n", + " logger=logger) # Adjust progress bar refresh rate as needed\n", + " trainer.fit(model)\n", + " model.eval()\n", + " embedded_test = model.embedder(torch.tensor(X_test, dtype=torch.float32))\n", + " y_pred = model.classifier(embedded_test)\n", + " y_pred_proba = y_pred.detach().cpu().numpy()\n", + " y_pred_class = np.round(y_pred_proba)\n", + "\n", + " f1 = f1_score(y_test, y_pred_class)\n", + " f1s.append(f1)\n", + " \n", + " embedded_train = model.embedder(torch.tensor(X_train, dtype=torch.float32)).detach().numpy()\n", + " embeddings_train.append(embedded_train)\n", + " embeddings_test.append(embedded_test.detach().numpy())\n", + " train_labels.append(y_train)\n", + " test_labels.append(y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Save the embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "fname = \"MRD\"\n", + "\n", + "for i,x in enumerate(embeddings_train): \n", + " fname_train = fname + \"_iter\" + str(i) + \"_train_embedding\"\n", + " np.save(f\"checkpoints/{fname}/{fname_train}\", x)\n", + "\n", + "for i,x in enumerate(train_labels): \n", + " fname_train_y = fname + \"_iter\" + str(i) + \"_train_labels\"\n", + " np.save(f\"checkpoints/{fname}/{fname_train_y}\", x)\n", + "\n", + "for i,x in enumerate(embeddings_test): \n", + " fname_test = fname + \"_iter\" + str(i) + \"_test_embedding\"\n", + " np.save(f\"checkpoints/{fname}/{fname_test}\", x)\n", + " \n", + "for i,x in enumerate(test_labels): \n", + " fname_test_y = fname + \"_iter\" + str(i) + \"_test_labels\"\n", + " np.save(f\"checkpoints/{fname}/{fname_test_y}\", x)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}