{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# PROTAC-Degradation-Predictor" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Compound IDUniprotSmilesE3 LigaseInChIInChI KeyMolecular WeightHeavy Atom CountRing CountRotatable Bond Count...PDBNameAssay (DC50/Dmax)Exact MassXLogP3Target (Parsed)POI SequenceE3 Ligase UniprotE3 Ligase SequenceCell Line Identifier
01Q07817Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...VHLInChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(...SXPDUCVNMGMWBJ-FMZBIETASA-N1486.2821011024...NaNNaNNaNNaNNaNNaNMSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...P40337MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...MOLT-4
12Q07817Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...VHLInChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(...HQKUMELJMUNTTF-NMKDNUEVSA-N1500.3091021025...NaNNaNNaNNaNNaNNaNMSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...P40337MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...MOLT-4
23Q07817Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...VHLInChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(...ATQCEJKUPSBDMA-QARNUTPLSA-N1514.3361031026...NaNNaNNaNNaNNaNNaNMSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...P40337MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...MOLT-4
34Q07817Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...VHLInChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(...FNKQAGMHNFFSEI-DTTPTBRMSA-N1528.3631041027...NaNNaNNaNNaNNaNNaNMSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...P40337MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...MOLT-4
45Q07817Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...VHLInChI=1S/C77H96ClF3N10O10S4/c1-51(53-18-20-55(...PXVFFBGSTYQHRO-REQIQPEASA-N1542.3901051028...NaNNaNNaNNaNNaNNaNMSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...P40337MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...MOLT-4
\n", "

5 rows × 34 columns

\n", "
" ], "text/plain": [ " Compound ID Uniprot Smiles \\\n", "0 1 Q07817 Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)... \n", "1 2 Q07817 Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)... \n", "2 3 Q07817 Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)... \n", "3 4 Q07817 Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)... \n", "4 5 Q07817 Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)... \n", "\n", " E3 Ligase InChI \\\n", "0 VHL InChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(... \n", "1 VHL InChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(... \n", "2 VHL InChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(... \n", "3 VHL InChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(... \n", "4 VHL InChI=1S/C77H96ClF3N10O10S4/c1-51(53-18-20-55(... \n", "\n", " InChI Key Molecular Weight Heavy Atom Count \\\n", "0 SXPDUCVNMGMWBJ-FMZBIETASA-N 1486.282 101 \n", "1 HQKUMELJMUNTTF-NMKDNUEVSA-N 1500.309 102 \n", "2 ATQCEJKUPSBDMA-QARNUTPLSA-N 1514.336 103 \n", "3 FNKQAGMHNFFSEI-DTTPTBRMSA-N 1528.363 104 \n", "4 PXVFFBGSTYQHRO-REQIQPEASA-N 1542.390 105 \n", "\n", " Ring Count Rotatable Bond Count ... PDB Name Assay (DC50/Dmax) \\\n", "0 10 24 ... NaN NaN NaN \n", "1 10 25 ... NaN NaN NaN \n", "2 10 26 ... NaN NaN NaN \n", "3 10 27 ... NaN NaN NaN \n", "4 10 28 ... NaN NaN NaN \n", "\n", " Exact Mass XLogP3 Target (Parsed) \\\n", "0 NaN NaN NaN \n", "1 NaN NaN NaN \n", "2 NaN NaN NaN \n", "3 NaN NaN NaN \n", "4 NaN NaN NaN \n", "\n", " POI Sequence E3 Ligase Uniprot \\\n", "0 MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME... P40337 \n", "1 MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME... P40337 \n", "2 MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME... P40337 \n", "3 MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME... P40337 \n", "4 MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME... P40337 \n", "\n", " E3 Ligase Sequence Cell Line Identifier \n", "0 MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE... MOLT-4 \n", "1 MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE... MOLT-4 \n", "2 MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE... MOLT-4 \n", "3 MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE... MOLT-4 \n", "4 MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE... MOLT-4 \n", "\n", "[5 rows x 34 columns]" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "protac_df = pd.read_csv('../data/PROTAC-Degradation-DB.csv')\n", "protac_df.head()" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Index(['Compound ID', 'Uniprot', 'Smiles', 'E3 Ligase', 'InChI', 'InChI Key',\n", " 'Molecular Weight', 'Heavy Atom Count', 'Ring Count',\n", " 'Rotatable Bond Count', 'Topological Polar Surface Area',\n", " 'Hydrogen Bond Acceptor Count', 'Hydrogen Bond Donor Count',\n", " 'Cell Type', 'Treatment Time (h)', 'DC50 (nM)', 'Dmax (%)', 'Active',\n", " 'Article DOI', 'Comments', 'Database', 'Molecular Formula', 'cLogP',\n", " 'Target', 'PDB', 'Name', 'Assay (DC50/Dmax)', 'Exact Mass', 'XLogP3',\n", " 'Target (Parsed)', 'POI Sequence', 'E3 Ligase Uniprot',\n", " 'E3 Ligase Sequence', 'Cell Line Identifier'],\n", " dtype='object')" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "protac_df.columns" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of non-cleaned cell lines: 180\n" ] } ], "source": [ "cells = sorted(protac_df['Cell Type'].dropna().unique().tolist())\n", "print(f'Number of non-cleaned cell lines: {len(cells)}')" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of cleaned cell lines: 138\n" ] } ], "source": [ "cells = sorted(protac_df['Cell Line Identifier'].dropna().unique().tolist())\n", "print(f'Number of cleaned cell lines: {len(cells)}')" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of compounds in test set: 1054\n" ] } ], "source": [ "test_df = protac_df[protac_df['Active'].isna()]\n", "print(f'Number of compounds in test set: {len(test_df)}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Protein Embeddings" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Protein embeddings downloaded from [Uniprot](https://www.uniprot.org/help/embeddings).\n", "\n", "Please note that running the following cell the first time might take a while." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os\n", "\n", "download_link = \"https://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/embeddings/UP000005640_9606/per-protein.h5\"\n", "embeddings_path = \"../data/uniprot2embedding.h5\"\n", "if not os.path.exists(embeddings_path):\n", " !wget {download_link} {embeddings_path}" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "number of entries: 570,820\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b708ae2eeb03462dab453593a9e42c5b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Loading protein embeddings: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\tid: Q07817, \tembeddings shape: (1024,), \tembeddings mean: -0.0005669593811035156\n", "\tid: P00533, \tembeddings shape: (1024,), \tembeddings mean: 0.001171112060546875\n", "\tid: Q9NWZ3, \tembeddings shape: (1024,), \tembeddings mean: 0.00041985511779785156\n", "\tid: P00519, \tembeddings shape: (1024,), \tembeddings mean: 0.0009608268737792969\n", "\tid: P11474, \tembeddings shape: (1024,), \tembeddings mean: -0.0018215179443359375\n", "\tid: Q16288, \tembeddings shape: (1024,), \tembeddings mean: 0.0010204315185546875\n", "\tid: O60674, \tembeddings shape: (1024,), \tembeddings mean: 0.0015687942504882812\n", "\tid: Q06187, \tembeddings shape: (1024,), \tembeddings mean: 0.0006914138793945312\n", "\tid: Q9UHD2, \tembeddings shape: (1024,), \tembeddings mean: 0.0012235641479492188\n", "\tid: Q8IXJ6, \tembeddings shape: (1024,), \tembeddings mean: -0.00042366981506347656\n", "KeyError for A8DG50\n" ] } ], "source": [ "import h5py\n", "import numpy as np\n", "from tqdm.auto import tqdm\n", "\n", "protein_embeddings = {}\n", "with h5py.File(\"../data/uniprot2embedding.h5\", \"r\") as file:\n", " print(f\"number of entries: {len(file.items()):,}\")\n", " uniprots = protac_df['Uniprot'].unique().tolist()\n", " uniprots += protac_df['E3 Ligase Uniprot'].unique().tolist()\n", " for i, sequence_id in tqdm(enumerate(uniprots), desc='Loading protein embeddings'):\n", " try:\n", " embedding = file[sequence_id][:]\n", " protein_embeddings[sequence_id] = np.array(embedding)\n", " if i < 10:\n", " print(\n", " f\"\\tid: {sequence_id}, \"\n", " f\"\\tembeddings shape: {embedding.shape}, \"\n", " f\"\\tembeddings mean: {np.array(embedding).mean()}\"\n", " )\n", " except KeyError:\n", " print(f'KeyError for {sequence_id}')\n", " protein_embeddings[sequence_id] = np.zeros((1024,))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Cell Embeddings" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded 1138 cell lines\n" ] } ], "source": [ "import pickle\n", "\n", "cell2embedding_filepath = '../data/processed/cell2embedding.pkl'\n", "with open(cell2embedding_filepath, 'rb') as f:\n", " cell2embedding = pickle.load(f)\n", "print(f'Loaded {len(cell2embedding)} cell lines')" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "emb_shape = cell2embedding[list(cell2embedding.keys())[0]].shape\n", "# Assign all-zero vectors to cell lines that are not in the embedding file\n", "for cell_line in protac_df['Cell Line Identifier'].unique():\n", " if cell_line not in cell2embedding:\n", " cell2embedding[cell_line] = np.zeros(emb_shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Precompute Molecular Fingerprints" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2b98bb8cb1864e84ae16fdef1edd0cf0", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Precomputing fingerprints: 0%| | 0/1467 [00:00\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
UMAP 1UMAP 2Active
0-2.0638280.469916True
1-2.1120800.532322True
23.7703362.801539False
32.6617491.402914False
42.8531181.610319True
\n", "" ], "text/plain": [ " UMAP 1 UMAP 2 Active\n", "0 -2.063828 0.469916 True\n", "1 -2.112080 0.532322 True\n", "2 3.770336 2.801539 False\n", "3 2.661749 1.402914 False\n", "4 2.853118 1.610319 True" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define UMAP and Scaler\n", "umap_reducer = umap.UMAP(\n", " n_neighbors=50, # Good value: 50\n", " min_dist=0.5, # Good value: 0.5\n", " # spread=1.0, # Good value: (not set, default)\n", " metric='euclidean',\n", " random_state=42,\n", " unique=True,\n", " # n_epochs=100,\n", " init='spectral', # Default: 'spectral'\n", " learning_rate=0.8, # Default: 1.0\n", " verbose=False,\n", ")\n", "scaler = StandardScaler()\n", "\n", "# Get the embeddings as a numpy array\n", "data = scaler.fit_transform(protac_data)\n", "data = umap_reducer.fit_transform(data)\n", "\n", "# Get the UMAP embedding coordinates\n", "umap_embeddings = {\n", " 'UMAP 1': [],\n", " 'UMAP 2': [],\n", " 'Active': [],\n", "}\n", "umap_embeddings['UMAP 1'] = data[:, 0].tolist()\n", "umap_embeddings['UMAP 2'] = data[:, 1].tolist()\n", "umap_embeddings['Active'] = protac_labels\n", "\n", "# Transform to dataframe and drop duplicates\n", "umap_embeddings = pd.DataFrame(umap_embeddings).drop_duplicates()\n", "umap_embeddings.head()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "import warnings\n", "\n", "with warnings.catch_warnings():\n", " warnings.simplefilter(\"ignore\")\n", " sns.scatterplot(data=umap_embeddings, x='UMAP 1', y='UMAP 2',\n", " hue='Active', palette=sns.color_palette('tab10'))\n", " # Make the legend external\n", " plt.legend(title='Active:')\n", " plt.title('UMAP embedding of PROTAC data input features')\n", " plt.grid(axis='both', alpha=0.5)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## PCA (TODO)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define Torch Dataset" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "from imblearn.over_sampling import SMOTE\n", "from sklearn.preprocessing import LabelEncoder\n", "from torch.utils.data import Dataset\n", "import pandas as pd\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Loaded 1614 PROTACs\n" ] } ], "source": [ "from torch.utils.data import Dataset, DataLoader\n", "\n", "\n", "class PROTAC_Dataset(Dataset):\n", " def __init__(\n", " self,\n", " protac_df,\n", " protein_embeddings,\n", " cell2embedding,\n", " smiles2fp,\n", " use_smote=False,\n", " ):\n", " # Filter out examples with NaN in 'Active' column\n", " self.data = protac_df # [~protac_df['Active'].isna()]\n", " self.protein_embeddings = protein_embeddings\n", " self.cell2embedding = cell2embedding\n", " self.smiles2fp = smiles2fp\n", "\n", " self.smiles_emb_dim = smiles2fp[list(smiles2fp.keys())[0]].shape[0]\n", " self.protein_emb_dim = protein_embeddings[list(\n", " protein_embeddings.keys())[0]].shape[0]\n", " self.cell_emb_dim = cell2embedding[list(\n", " cell2embedding.keys())[0]].shape[0]\n", "\n", " # print(f'SMILES embedding dimension: {self.smiles_emb_dim}')\n", " # print(f'Protein embedding dimension: {self.protein_emb_dim}')\n", " # print(f'Cell embedding dimension: {self.cell_emb_dim}')\n", "\n", " self.use_smote = use_smote\n", " # Apply SMOTE\n", " if self.use_smote:\n", " self.apply_smote()\n", "\n", " def apply_smote(self):\n", " # Prepare the dataset for SMOTE\n", " features = []\n", " labels = []\n", " for idx, row in self.data.iterrows():\n", " smiles_emb = smiles2fp[row['Smiles']]\n", " poi_emb = protein_embeddings[row['Uniprot']]\n", " e3_emb = protein_embeddings[row['E3 Ligase Uniprot']]\n", " cell_emb = cell2embedding[row['Cell Line Identifier']]\n", " features.append(np.hstack([\n", " smiles_emb.astype(np.float32),\n", " poi_emb.astype(np.float32),\n", " e3_emb.astype(np.float32),\n", " cell_emb.astype(np.float32),\n", " ]))\n", " labels.append(row['Active'])\n", "\n", " # Convert to numpy array\n", " features = np.array(features).astype(np.float32)\n", " labels = np.array(labels).astype(np.float32)\n", "\n", " # Initialize SMOTE and fit\n", " smote = SMOTE(random_state=42, n_jobs=-1)\n", " features_smote, labels_smote = smote.fit_resample(features, labels)\n", "\n", " # Separate the features back into their respective embeddings\n", " smiles_embs = features_smote[:, :self.smiles_emb_dim]\n", " poi_embs = features_smote[:,\n", " self.smiles_emb_dim:self.smiles_emb_dim+self.protein_emb_dim]\n", " e3_embs = features_smote[:, self.smiles_emb_dim +\n", " self.protein_emb_dim:self.smiles_emb_dim+2*self.protein_emb_dim]\n", " cell_embs = features_smote[:, -self.cell_emb_dim:]\n", "\n", " # Reconstruct the dataframe with oversampled data\n", " df_smote = pd.DataFrame({\n", " 'Smiles': list(smiles_embs),\n", " 'Uniprot': list(poi_embs),\n", " 'E3 Ligase Uniprot': list(e3_embs),\n", " 'Cell Line Identifier': list(cell_embs),\n", " 'Active': labels_smote\n", " })\n", " self.data = df_smote\n", "\n", " def __len__(self):\n", " return len(self.data)\n", "\n", " def __getitem__(self, idx):\n", " if self.use_smote:\n", " # NOTE: We do not need to look up the embeddings anymore\n", " elem = {\n", " 'smiles_emb': self.data['Smiles'].iloc[idx],\n", " 'poi_emb': self.data['Uniprot'].iloc[idx],\n", " 'e3_emb': self.data['E3 Ligase Uniprot'].iloc[idx],\n", " 'cell_emb': self.data['Cell Line Identifier'].iloc[idx],\n", " 'active': 1. if self.data['Active'].iloc[idx] else 0.,\n", " }\n", " else:\n", " elem = {\n", " 'smiles_emb': self.smiles2fp[self.data['Smiles'].iloc[idx]].astype(np.float32),\n", " 'poi_emb': self.protein_embeddings[self.data['Uniprot'].iloc[idx]].astype(np.float32),\n", " 'e3_emb': self.protein_embeddings[self.data['E3 Ligase Uniprot'].iloc[idx]].astype(np.float32),\n", " 'cell_emb': self.cell2embedding[self.data['Cell Line Identifier'].iloc[idx]].astype(np.float32),\n", " 'active': 1. if self.data['Active'].iloc[idx] else 0.,\n", " }\n", " return elem\n", "\n", "\n", "protac_ds = PROTAC_Dataset(\n", " protac_df[protac_df['Active'].notna()], protein_embeddings, cell2embedding, smiles2fp, use_smote=True)\n", "print(f'Loaded {len(protac_ds)} PROTACs')" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded 1614 PROTACs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n" ] } ], "source": [ "protac_ds = PROTAC_Dataset(\n", " protac_df[~protac_df['Active'].isna()], protein_embeddings, cell2embedding, smiles2fp, use_smote=True)\n", "print(f'Loaded {len(protac_ds)} PROTACs')" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'smiles_emb': array([0., 1., 1., ..., 0., 0., 0.], dtype=float32),\n", " 'poi_emb': array([ 0.00964355, 0.00894928, 0.00073957, ..., -0.03030396,\n", " -0.00224686, -0.02049255], dtype=float32),\n", " 'e3_emb': array([ 0.00413132, 0.03634644, 0.09191895, ..., -0.04534912,\n", " 0.08526611, 0.03466797], dtype=float32),\n", " 'cell_emb': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0.], dtype=float32),\n", " 'active': 0.0}" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "protac_ds[42]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Example batch: {'smiles_emb': tensor([[0.0000, 0.0000, 0.0000, ..., 0.0000, 1.0000, 0.0000],\n", " [0.0000, 1.0000, 0.8655, ..., 0.0000, 0.0000, 0.0000],\n", " [0.0000, 1.0000, 0.0000, ..., 0.0000, 1.0000, 0.0000],\n", " ...,\n", " [0.0000, 1.0000, 0.0000, ..., 0.0000, 1.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000, ..., 0.0000, 1.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000, ..., 1.0000, 1.0000, 0.0000]]), 'poi_emb': tensor([[ 0.0132, 0.0703, 0.0471, ..., -0.0115, -0.0242, -0.0089],\n", " [ 0.0133, 0.0191, 0.0097, ..., -0.0234, -0.0029, -0.0141],\n", " [ 0.0132, 0.0703, 0.0471, ..., -0.0115, -0.0242, -0.0089],\n", " ...,\n", " [ 0.0427, 0.0529, 0.0352, ..., -0.0147, -0.0024, 0.0115],\n", " [ 0.0132, 0.0703, 0.0471, ..., -0.0115, -0.0242, -0.0089],\n", " [ 0.0132, 0.0703, 0.0471, ..., -0.0115, -0.0242, -0.0089]]), 'e3_emb': tensor([[ 0.0331, 0.0391, 0.0448, ..., -0.0251, -0.0331, 0.0293],\n", " [ 0.0041, 0.0363, 0.0919, ..., -0.0453, 0.0853, 0.0347],\n", " [ 0.0331, 0.0391, 0.0448, ..., -0.0251, -0.0331, 0.0293],\n", " ...,\n", " [ 0.0331, 0.0391, 0.0448, ..., -0.0251, -0.0331, 0.0293],\n", " [ 0.0331, 0.0391, 0.0448, ..., -0.0251, -0.0331, 0.0293],\n", " [ 0.0331, 0.0391, 0.0448, ..., -0.0251, -0.0331, 0.0293]]), 'cell_emb': tensor([[ 0.0250, -0.0381, 0.0179, ..., -0.0377, -0.0437, -0.0098],\n", " [ 0.0029, -0.0044, -0.0010, ..., -0.0038, -0.0042, -0.0063],\n", " [ 0.0175, -0.0510, 0.0276, ..., -0.0256, -0.0164, -0.0377],\n", " ...,\n", " [ 0.0183, -0.1246, -0.0029, ..., -0.0201, -0.0358, -0.0183],\n", " [ 0.0176, -0.0511, 0.0318, ..., -0.0374, -0.0538, -0.0043],\n", " [ 0.0471, -0.0592, 0.0272, ..., -0.0299, -0.0569, 0.0260]]), 'active': tensor([0., 1., 1., 1., 1., 1., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 0., 0.,\n", " 1., 0., 1., 0., 0., 0., 1., 0., 1., 0., 1., 0., 1., 1.],\n", " dtype=torch.float64)}\n" ] } ], "source": [ "protac_dl = DataLoader(protac_ds, batch_size=32, shuffle=True)\n", "print(f'Example batch: {next(iter(protac_dl))}')" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([[0., 1., 1., ..., 0., 0., 1.],\n", " [0., 1., 1., ..., 0., 1., 0.],\n", " [0., 1., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 1., 1., 0.],\n", " [0., 1., 0., ..., 0., 1., 0.],\n", " [0., 1., 0., ..., 0., 1., 0.]])\n", "torch.Size([32, 1024])\n" ] } ], "source": [ "batch = next(iter(protac_dl))\n", "print(batch['smiles_emb'])\n", "print(batch['smiles_emb'].size())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define PyTorch Lightning Model" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "import torch.optim as optim\n", "import pytorch_lightning as pl\n", "from torchmetrics import (\n", " Accuracy,\n", " AUROC,\n", " Precision,\n", " Recall,\n", " F1Score,\n", ")\n", "from torchmetrics import MetricCollection\n", "\n", "\n", "class PROTAC_Model(pl.LightningModule):\n", "\n", " def __init__(\n", " self,\n", " hidden_dim,\n", " smiles_emb_dim=1024,\n", " poi_emb_dim=1024,\n", " e3_emb_dim=1024,\n", " cell_emb_dim=768,\n", " batch_size=32,\n", " learning_rate=1e-3,\n", " dropout=0.2,\n", " train_dataset=None,\n", " val_dataset=None,\n", " test_dataset=None,\n", " disabled_embeddings=[],\n", " ):\n", " super().__init__()\n", " self.poi_emb_dim = poi_emb_dim\n", " self.e3_emb_dim = e3_emb_dim\n", " self.cell_emb_dim = cell_emb_dim\n", " self.smiles_emb_dim = smiles_emb_dim\n", " self.hidden_dim = hidden_dim\n", " self.batch_size = batch_size\n", " self.learning_rate = learning_rate\n", " self.train_dataset = train_dataset\n", " self.val_dataset = val_dataset\n", " self.test_dataset = test_dataset\n", " self.disabled_embeddings = disabled_embeddings\n", " # Set our init args as class attributes\n", " self.__dict__.update(locals()) # Add arguments as attributes\n", " # Save the arguments passed to init\n", " ignore_args_as_hyperparams = [\n", " 'train_dataset',\n", " 'test_dataset',\n", " 'val_dataset',\n", " ]\n", " self.save_hyperparameters(ignore=ignore_args_as_hyperparams)\n", "\n", " if 'poi' not in self.disabled_embeddings:\n", " self.poi_emb = nn.Linear(poi_emb_dim, hidden_dim)\n", " if 'e3' not in self.disabled_embeddings:\n", " self.e3_emb = nn.Linear(e3_emb_dim, hidden_dim)\n", " if 'cell' not in self.disabled_embeddings:\n", " self.cell_emb = nn.Linear(cell_emb_dim, hidden_dim)\n", " if 'smiles' not in self.disabled_embeddings:\n", " self.smiles_emb = nn.Linear(smiles_emb_dim, hidden_dim)\n", "\n", " self.fc1 = nn.Linear(\n", " hidden_dim * (4 - len(self.disabled_embeddings)), hidden_dim)\n", " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n", " self.fc3 = nn.Linear(hidden_dim, 1)\n", "\n", " self.dropout = nn.Dropout(p=dropout)\n", "\n", " stages = ['train_metrics', 'val_metrics', 'test_metrics']\n", " self.metrics = nn.ModuleDict({s: MetricCollection({\n", " 'acc': Accuracy(task='binary'),\n", " 'roc_auc': AUROC(task='binary'),\n", " 'precision': Precision(task='binary'),\n", " 'recall': Recall(task='binary'),\n", " 'f1_score': F1Score(task='binary'),\n", " 'opt_score': Accuracy(task='binary') + F1Score(task='binary'),\n", " 'hp_metric': Accuracy(task='binary'),\n", " }, prefix=s.replace('metrics', '')) for s in stages})\n", "\n", " # Misc settings\n", " self.missing_dataset_error = \\\n", " '''Class variable `{0}` is None. If the model was loaded from a checkpoint, the dataset must be set manually:\n", " \n", " model = {1}.load_from_checkpoint('checkpoint.ckpt')\n", " model.{0} = my_{0}\n", " '''\n", "\n", " def forward(self, poi_emb, e3_emb, cell_emb, smiles_emb):\n", " embeddings = []\n", " if 'poi' not in self.disabled_embeddings:\n", " embeddings.append(self.dropout(self.poi_emb(poi_emb)))\n", " if 'e3' not in self.disabled_embeddings:\n", " embeddings.append(self.dropout(self.e3_emb(e3_emb)))\n", " if 'cell' not in self.disabled_embeddings:\n", " embeddings.append(self.dropout(self.cell_emb(cell_emb)))\n", " if 'smiles' not in self.disabled_embeddings:\n", " embeddings.append(self.dropout(self.smiles_emb(smiles_emb)))\n", " x = torch.cat(embeddings, dim=1)\n", " x = self.dropout(F.relu(self.fc1(x)))\n", " x = self.dropout(F.relu(self.fc2(x)))\n", " x = self.fc3(x)\n", " return x\n", "\n", " def step(self, batch, batch_idx, stage):\n", " poi_emb = batch['poi_emb']\n", " e3_emb = batch['e3_emb']\n", " cell_emb = batch['cell_emb']\n", " smiles_emb = batch['smiles_emb']\n", " y = batch['active'].float().unsqueeze(1)\n", "\n", " y_hat = self.forward(poi_emb, e3_emb, cell_emb, smiles_emb)\n", " loss = F.binary_cross_entropy_with_logits(y_hat, y)\n", "\n", " self.metrics[f'{stage}_metrics'].update(y_hat, y)\n", " self.log(f'{stage}_loss', loss, on_epoch=True, prog_bar=True)\n", " self.log_dict(self.metrics[f'{stage}_metrics'], on_epoch=True)\n", "\n", " return loss\n", "\n", " def training_step(self, batch, batch_idx):\n", " return self.step(batch, batch_idx, 'train')\n", "\n", " def validation_step(self, batch, batch_idx):\n", " return self.step(batch, batch_idx, 'val')\n", "\n", " def test_step(self, batch, batch_idx):\n", " return self.step(batch, batch_idx, 'test')\n", "\n", " def configure_optimizers(self):\n", " return optim.Adam(self.parameters(), lr=self.learning_rate)\n", "\n", " def predict_step(self, batch, batch_idx):\n", " poi_emb = batch['poi_emb']\n", " e3_emb = batch['e3_emb']\n", " cell_emb = batch['cell_emb']\n", " smiles_emb = batch['smiles_emb']\n", "\n", " y_hat = self.forward(poi_emb, e3_emb, cell_emb, smiles_emb)\n", " return torch.sigmoid(y_hat)\n", "\n", " def train_dataloader(self):\n", " if self.train_dataset is None:\n", " format = 'train_dataset', self.__class__.__name__\n", " raise ValueError(self.missing_dataset_error.format(*format))\n", " return DataLoader(\n", " self.train_dataset,\n", " batch_size=self.batch_size,\n", " shuffle=True,\n", " drop_last=True,\n", " )\n", "\n", " def val_dataloader(self):\n", " if self.val_dataset is None:\n", " format = 'val_dataset', self.__class__.__name__\n", " raise ValueError(self.missing_dataset_error.format(*format))\n", " return DataLoader(\n", " self.val_dataset,\n", " batch_size=self.batch_size,\n", " shuffle=False,\n", " )\n", "\n", " def test_dataloader(self):\n", " if self.test_dataset is None:\n", " format = 'test_dataset', self.__class__.__name__\n", " raise ValueError(self.missing_dataset_error.format(*format))\n", " return DataLoader(\n", " self.test_dataset,\n", " batch_size=self.batch_size,\n", " shuffle=False,\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Train Model" ] }, { "cell_type": "code", "execution_count": 106, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "protac_df.shape: (2141, 34)\n", "train_df.shape: (869, 34)\n", "val_df.shape: (218, 34)\n" ] } ], "source": [ "# Split the dataset into train, val, and test\n", "from sklearn.model_selection import train_test_split\n", "\n", "\n", "train_df, val_df = train_test_split(\n", " protac_df[protac_df['Active'].notna()], test_size=0.2, random_state=42)\n", "print(f\"protac_df.shape: {protac_df.shape}\")\n", "print(f\"train_df.shape: {train_df.shape}\")\n", "print(f\"val_df.shape: {val_df.shape}\")" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "train_ds = PROTAC_Dataset(\n", " train_df,\n", " protein_embeddings,\n", " cell2embedding,\n", " smiles2fp,\n", " use_smote=True,\n", ")\n", "val_ds = PROTAC_Dataset(\n", " val_df,\n", " protein_embeddings,\n", " cell2embedding,\n", " smiles2fp,\n", ")" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n" ] } ], "source": [ "logger = pl.loggers.TensorBoardLogger(\n", " save_dir='../logs',\n", " name='protac',\n", ")\n", "\n", "callbacks = [\n", " pl.callbacks.EarlyStopping(\n", " monitor='train_loss',\n", " patience=10,\n", " mode='max',\n", " verbose=True,\n", " ),\n", " pl.callbacks.ModelCheckpoint(\n", " monitor='val_acc',\n", " mode='max',\n", " verbose=True,\n", " filename='{epoch}-{val_metrics_opt_score:.4f}',\n", " ),\n", "]\n", "# Define Trainer\n", "trainer = pl.Trainer(\n", " logger=logger,\n", " callbacks=callbacks,\n", " max_epochs=50,)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of parameters: 5,903,617\n" ] } ], "source": [ "model = PROTAC_Model(\n", " hidden_dim=768,\n", " smiles_emb_dim=1024,\n", " poi_emb_dim=1024,\n", " e3_emb_dim=1024,\n", " cell_emb_dim=768,\n", " batch_size=8,\n", " learning_rate=2e-5,\n", " train_dataset=train_ds,\n", " val_dataset=val_ds,\n", ")\n", "# Get model parameters size\n", "print(f\"Number of parameters: {sum(p.numel() for p in model.parameters()):,}\")" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9da3df50598d465b9a3fd79291e5cb20", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "48143d471ab842a79677860a169f1f0e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "eddb398c939941e1a9c49ad1fa0cee30", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.681\n", "Epoch 0, global step 162: 'val_acc' reached 0.66055 (best 0.66055), saving model to '../logs\\\\protac\\\\version_12\\\\checkpoints\\\\epoch=0-val_metrics_opt_score=0.0000.ckpt' as top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e21ede149d9d40229652bf80df17451e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 1, global step 324: 'val_acc' reached 0.82569 (best 0.82569), saving model to '../logs\\\\protac\\\\version_12\\\\checkpoints\\\\epoch=1-val_metrics_opt_score=0.0000.ckpt' as top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "91b6e241a36f4169937c6ba03d477332", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 2, global step 486: 'val_acc' was not in top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9ec4807a605b4cef973d645274c2ed8f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 3, global step 648: 'val_acc' was not in top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3906c27b214d44a0b6ccfbcd3ea2b010", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 4, global step 810: 'val_acc' reached 0.83028 (best 0.83028), saving model to '../logs\\\\protac\\\\version_12\\\\checkpoints\\\\epoch=4-val_metrics_opt_score=0.0000.ckpt' as top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "08f332f49bfa4572a53c3f32d14a1403", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 5, global step 972: 'val_acc' was not in top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5a63bfed8db44098a81b6f2033347d18", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 6, global step 1134: 'val_acc' was not in top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5cadca41e610481aa2d633062281cc35", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 7, global step 1296: 'val_acc' was not in top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f246e39c30d041a5a0cea6471ecc733d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 8, global step 1458: 'val_acc' was not in top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "612fbd7aa7854d09830718c396baadb6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 9, global step 1620: 'val_acc' was not in top 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "98000498f4134fcd9899d07094f13f60", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.681. Signaling Trainer to stop.\n", "Epoch 10, global step 1782: 'val_acc' reached 0.85321 (best 0.85321), saving model to '../logs\\\\protac\\\\version_12\\\\checkpoints\\\\epoch=10-val_metrics_opt_score=0.0000.ckpt' as top 1\n" ] } ], "source": [ "trainer.fit(model)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Open tensorboard\n", "%load_ext tensorboard" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Evaluate Model" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, predict_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d3bddcbf97534a9eac8c8d2c593ec9ae", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "eeac3e8961644a6a8f745dcb49ab9ceb", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Get model predictions on the validation set using the trainer\n", "val_dl = DataLoader(val_ds, batch_size=32, shuffle=False)\n", "val_preds = trainer.predict(model, val_dl)\n", "val_preds = torch.vstack(val_preds).numpy().flatten()\n", "\n", "train_dl = DataLoader(train_ds, batch_size=32, shuffle=False)\n", "train_preds = trainer.predict(model, train_dl)\n", "train_preds = torch.vstack(train_preds).numpy().flatten()" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1908cb07cac04a2c894d7e3bdd9a4e33", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc               0.853210985660553     │\n",
       "│       val_f1_score            0.7288135886192322     │\n",
       "│       val_hp_metric            0.853210985660553     │\n",
       "│         val_loss              0.39718419313430786    │\n",
       "│       val_opt_score           1.5820245742797852     │\n",
       "│       val_precision           0.7413793206214905     │\n",
       "│        val_recall             0.7166666388511658     │\n",
       "│        val_roc_auc            0.9084388017654419     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.853210985660553 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7288135886192322 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.853210985660553 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.39718419313430786 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5820245742797852 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7413793206214905 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7166666388511658 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9084388017654419 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[{'val_loss': 0.39718419313430786,\n", " 'val_acc': 0.853210985660553,\n", " 'val_f1_score': 0.7288135886192322,\n", " 'val_hp_metric': 0.853210985660553,\n", " 'val_opt_score': 1.5820245742797852,\n", " 'val_precision': 0.7413793206214905,\n", " 'val_recall': 0.7166666388511658,\n", " 'val_roc_auc': 0.9084388017654419}]" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "val_dl = DataLoader(val_ds, batch_size=32, shuffle=False)\n", "trainer.validate(model, val_dl)" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7bf15f34fdba4de1bc5322371c7fa9ca", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "test_df['Active'] = False\n", "test_ds = PROTAC_Dataset(\n", " test_df,\n", " protein_embeddings,\n", " cell2embedding,\n", " smiles2fp,\n", ")\n", "test_dl = DataLoader(test_ds, batch_size=32, shuffle=False)\n", "test_preds = trainer.predict(model, test_dl)\n", "test_preds = torch.vstack(test_preds).numpy().flatten()" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# Plot histogram of predictions\n", "plt.hist(train_preds, bins=20)\n", "plt.title('Train predictions')\n", "plt.grid(axis='y', alpha=0.5)\n", "plt.show()\n", "\n", "plt.hist(val_preds, bins=20)\n", "plt.title('Validation predictions')\n", "plt.grid(axis='y', alpha=0.5)\n", "plt.show()\n", "\n", "plt.hist(test_preds, bins=20)\n", "plt.title('Test predictions')\n", "plt.grid(axis='y', alpha=0.5)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TODO: Which data are in the most unsure middle region?" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False 130\n", "True 65\n", "Name: Active, dtype: int64" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the test set predictions which are very confident\n", "def is_active(p, pos_threshold=0.90, neg_threshold=0.005):\n", " if p > pos_threshold:\n", " return True\n", " elif p < neg_threshold:\n", " return False\n", " else:\n", " return np.nan\n", "\n", "\n", "test_df['Active'] = [\n", " is_active(p, pos_threshold=0.97, neg_threshold=0.001) for p in test_preds]\n", "test_df[~test_df['Active'].isna()]['Active'].value_counts()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Cross-Validation Training" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TODO: Cross-Val\n", "\n", "* Random split\n", "* Least Tanimoto dist PROTAC-wise\n", "* POI-wise: some POIs never in both splits\n", "\n", "TODO: Separate test set??" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Global seed set to 42\n" ] } ], "source": [ "# Seed everything in pytorch lightning\n", "pl.seed_everything(42)\n", "\n", "\n", "def train_model(train_df, val_df, disabled_embeddings=[]):\n", " train_ds = PROTAC_Dataset(\n", " train_df,\n", " protein_embeddings,\n", " cell2embedding,\n", " smiles2fp,\n", " use_smote=True,\n", " )\n", " val_ds = PROTAC_Dataset(\n", " val_df,\n", " protein_embeddings,\n", " cell2embedding,\n", " smiles2fp,\n", " )\n", " logger = pl.loggers.TensorBoardLogger(\n", " save_dir='../logs',\n", " name='protac',\n", " )\n", " callbacks = [\n", " pl.callbacks.EarlyStopping(\n", " monitor='train_loss',\n", " patience=10,\n", " mode='max',\n", " verbose=True,\n", " ),\n", " # pl.callbacks.ModelCheckpoint(\n", " # monitor='val_acc',\n", " # mode='max',\n", " # verbose=True,\n", " # filename='{epoch}-{val_metrics_opt_score:.4f}',\n", " # ),\n", " ]\n", " # Define Trainer\n", " trainer = pl.Trainer(\n", " logger=logger,\n", " callbacks=callbacks,\n", " max_epochs=50,\n", " enable_checkpointing=False,\n", " )\n", " model = PROTAC_Model(\n", " hidden_dim=768,\n", " smiles_emb_dim=1024,\n", " poi_emb_dim=1024,\n", " e3_emb_dim=1024,\n", " cell_emb_dim=768,\n", " batch_size=8,\n", " learning_rate=2e-5,\n", " train_dataset=train_ds,\n", " val_dataset=val_ds,\n", " disabled_embeddings=disabled_embeddings,\n", " )\n", " trainer.fit(model)\n", " val_dl = DataLoader(val_ds, batch_size=32, shuffle=False)\n", " return model, trainer, trainer.validate(model, val_dl)[0]" ] }, { "cell_type": "code", "execution_count": 130, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7bad4f7bc2f641bdb5387ae2bbb95222", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8f412941c8884751bf5dff29683d5d4c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "054ad46139c74d1cbaf9cb92b6ed312c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.678\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "53c8e1d6d23c45b5aee636c8c65f780f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9be4ed2a0b6e42978f36defb5cfc7d4b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c1e90209b8624bb3aa551ee4be1ac28e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e1cc66975cb04cafbe498732146240c6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8f18056dcfc74b65994c6dd7896c3922", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8a6a032f2c824e0097cb6a184ab01c05", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "53b46cb12bad482bbb7069027d97d7ef", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d95edcb4257c4ce0b89901cc219511ee", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1444787b48a04c97999f0ee6a918fdaf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "84e125446343491cb221985ff5556838", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.678. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2e33e9834aa042ec8e1fdb7ad1741023", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8623853325843811     │\n",
       "│       val_f1_score            0.7368420958518982     │\n",
       "│       val_hp_metric           0.8623853325843811     │\n",
       "│         val_loss              0.3256032466888428     │\n",
       "│       val_opt_score           1.5992274284362793     │\n",
       "│       val_precision           0.8399999737739563     │\n",
       "│        val_recall                   0.65625          │\n",
       "│        val_roc_auc            0.9358766078948975     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8623853325843811 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7368420958518982 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8623853325843811 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.3256032466888428 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5992274284362793 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8399999737739563 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.65625 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9358766078948975 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e0bc584883de471faa2f05dfd7d9cbcd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bfe4ea0982404048a16c4e42399565d5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c2f54315a0cd465db5497fa0c976c43c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.681\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "28915d5ad1764d5e9c95479f759ae42f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d1e2da9f2cad45b1a5df171a37147abe", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5def76e6dbbc4cccb184890412bf68b5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "10f84836acf046d8a1c099f3a2560ef9", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c899c0afd6164f3cbe91b6f886f1d842", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b1f5699bcff045c8bfda04d618670094", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "080d55d9b2c3473da2a7e1ef8538f8af", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bdcf21d1be6c450cb0626ba0d36897fa", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3fe4cddc678b49bcae2d193c9a409d5f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8b043af809a44d289cd5e34dbe4b051a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.681. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "513f417ab6464668be9fe305507ba3d6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8440366983413696     │\n",
       "│       val_f1_score            0.7301587462425232     │\n",
       "│       val_hp_metric           0.8440366983413696     │\n",
       "│         val_loss              0.4012793004512787     │\n",
       "│       val_opt_score            1.574195384979248     │\n",
       "│       val_precision           0.6571428775787354     │\n",
       "│        val_recall             0.8214285969734192     │\n",
       "│        val_roc_auc            0.9135802388191223     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8440366983413696 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7301587462425232 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8440366983413696 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4012793004512787 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.574195384979248 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6571428775787354 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8214285969734192 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9135802388191223 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4a2456436b8943f2af3af61adeab3a22", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6c507902997f4d5494533234785a3065", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "96541b344e84483ca99ff16494e3f77c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.678\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f12c58aed8e94865b2873ca0dbb9a5ce", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "523d9c533ff54d7dbb7b7df49e492880", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7893269cb24a4f918b7d76d54e76aa43", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "96632302871840a6bf8b8677b39c52e4", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0ee7de4ab69b4e7e9ebf94fa048973a1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6a98c7f38c074a05982dea7af9fb1e5a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3188161e3de34a79acea0688c8873eea", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a2fbb1e75b444de3b72d97e71424c5a2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6fa8350fe63240fb8e718a1c3597b630", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0d5ca18adae94cba9d8407ff0d988fc8", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.678. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "827d4d9de83943628ac753c34af0ed82", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8256880640983582     │\n",
       "│       val_f1_score            0.6779661178588867     │\n",
       "│       val_hp_metric           0.8256880640983582     │\n",
       "│         val_loss              0.46647822856903076    │\n",
       "│       val_opt_score           1.5036542415618896     │\n",
       "│       val_precision           0.7142857313156128     │\n",
       "│        val_recall             0.6451612710952759     │\n",
       "│        val_roc_auc            0.8873035907745361     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8256880640983582 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6779661178588867 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8256880640983582 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.46647822856903076 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5036542415618896 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7142857313156128 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6451612710952759 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8873035907745361 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "327f63966297483a863a97ced1835d45", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d234afb327b84bc3adbcfd1b1a235eb2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "14b0ffa369c94482b776a4017ad6349e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.679\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3e7f13a804c44f1b8a1454b479f99d26", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ac6a9ba1af0f44f3a990cec17ef90c23", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "79272ce2d6af40648573b8d3893384aa", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e8cf9c4cbf2445fd976a78e815147867", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7f585792db9242abbc25bb3e51424b77", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "760a8c615b924c3183633db97d0e39b2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0f0bb6ccab7a41afbe69fa4900dea4e6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1664e40c11f9446094e837a85c64b00e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "24db82b937ad4eb6a9ddb5bec9ee88fd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "adb60706c5c44d55816d34cc1e963450", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.679. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4c534a708f5e40d9b11a7278531856f3", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8623853325843811     │\n",
       "│       val_f1_score            0.7368420958518982     │\n",
       "│       val_hp_metric           0.8623853325843811     │\n",
       "│         val_loss              0.4182129204273224     │\n",
       "│       val_opt_score           1.5992274284362793     │\n",
       "│       val_precision           0.6176470518112183     │\n",
       "│        val_recall             0.9130434989929199     │\n",
       "│        val_roc_auc            0.9155712723731995     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8623853325843811 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7368420958518982 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8623853325843811 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4182129204273224 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5992274284362793 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6176470518112183 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9130434989929199 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9155712723731995 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b66dae7a34384a15a05aafced6d20f45", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ec2922e3ffc3425aad4477559ebd9c82", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f01a30977b6840c8959a8d04a6ccd391", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.677\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cc5e4ca4a6ed4509ac665190195a5bb5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c938ba47ca8d412384202d36dafc424f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9b462160087a47039bb22bbff87f8e31", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "95c4c6d08f6a4693b25099aa44b23937", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "90e0e49a4d4243fc8281b732adf23c35", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d01aa404fec14656a5512e93d821b116", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "36605d552b18480ab3e27b4e7bf864d1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "36f6b6dfd6cb4d68b711f25ab0326c2d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bc0069acbbbf473dbde3b0e9298e50d0", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3cb34e255b9645f79cf79efcf87bc849", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.677. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "60eba19b79e5474ca92358cef6569759", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8348624110221863     │\n",
       "│       val_f1_score            0.7272727489471436     │\n",
       "│       val_hp_metric           0.8348624110221863     │\n",
       "│         val_loss              0.40080317854881287    │\n",
       "│       val_opt_score           1.5621352195739746     │\n",
       "│       val_precision           0.6486486196517944     │\n",
       "│        val_recall             0.8275862336158752     │\n",
       "│        val_roc_auc            0.9105603098869324     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8348624110221863 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7272727489471436 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8348624110221863 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.40080317854881287 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5621352195739746 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6486486196517944 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8275862336158752 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9105603098869324 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d3736fc2b7ff42e390db860d403b3422", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "96672514a47645b58153a27ee954dbcd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c41c5959d6b243e98dfdece816744c12", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.678\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6064c50640db40d7867e0da35c46cef1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "316aa12385634593a7fbaa68a6237aa0", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4b1ef6614bda47c28dada91a20e32c87", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7ae30a51bb1244dcbef64a72b126bd9b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "16714eb2f3404282a90c70a0572d60d3", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "865878509cd74f1baeafc651352b7a70", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f26a9a5869454698998f214fdd5e8c70", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9bb292f1c669465d848fd7d1fcfc0ea8", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ba3bb9a4ad414143a6b87fce0f359015", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "422e166a069445a68e0cd3d383a4ee08", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.678. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cd1ba74db7884e55916ce19f79400044", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8256880640983582     │\n",
       "│       val_f1_score            0.7076923251152039     │\n",
       "│       val_hp_metric           0.8256880640983582     │\n",
       "│         val_loss              0.4778938293457031     │\n",
       "│       val_opt_score            1.533380389213562     │\n",
       "│       val_precision           0.6216216087341309     │\n",
       "│        val_recall             0.8214285969734192     │\n",
       "│        val_roc_auc             0.899470865726471     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8256880640983582 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7076923251152039 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8256880640983582 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4778938293457031 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.533380389213562 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6216216087341309 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8214285969734192 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.899470865726471 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5de1eb41278b42a6a9118e96c198afab", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c94aaf2fa0d14733b91f74b257edd937", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b27e85fcb645490ba448118900ea9fb9", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.676\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "96ba2f587e45407dbc20184f2b76203c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "130e5cee4dab470dac266c0eb4c41d54", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4bb720631b2c4c3998d206e8552988da", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "35a889e035264d8d83888b996562a61b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "babc66a7a39446f692388c42bed63348", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6b35fcc6fad04c90a5b6af19a2e3b48e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "642cd2f6b427475a97f5993eec4bfd2e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "88830f42809742e9a4a8410a0d0db20f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0c98728e2a42495fab3259e4c31051dc", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "20b45ac3e75c4f159b1d316418d354cc", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.676. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9ec6b599ec4c49aab8246eeaa7a0680e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8165137767791748     │\n",
       "│       val_f1_score            0.6969696879386902     │\n",
       "│       val_hp_metric           0.8165137767791748     │\n",
       "│         val_loss              0.5011997222900391     │\n",
       "│       val_opt_score           1.5134835243225098     │\n",
       "│       val_precision           0.6388888955116272     │\n",
       "│        val_recall             0.7666666507720947     │\n",
       "│        val_roc_auc            0.8742616176605225     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8165137767791748 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6969696879386902 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8165137767791748 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.5011997222900391 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5134835243225098 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6388888955116272 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7666666507720947 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8742616176605225 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6b66c9888c7c432ba437b770b9880269", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7e150636c9f34a119c42252d7d0be036", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4d4b4d556adb44349013e9eec5270942", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.679\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c3812ba392834b1aa498b96d88a9146d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "746c720b0bfa4f518d203660616b403e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3f573dfa97934c46be4fee5793acae7c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b703b204cb6d44c2accf3d13cfff1e2f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "dbedf9893f304161969b2b849fa267ad", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4f6a4f1ec73145ecb99c1e2c113c51f6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "33db1aaf25a449dbba205039fb9efba9", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8e98390f334c4fc58f7400fb28a0ea06", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c9fd3333ba8643b4a2ae086072f3487d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d78bc24fd3a545249f8111337f2767a2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.679. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d2b152723ff842059542ac61f5fa208c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8148148059844971     │\n",
       "│       val_f1_score            0.6296296119689941     │\n",
       "│       val_hp_metric           0.8148148059844971     │\n",
       "│         val_loss              0.4128589630126953     │\n",
       "│       val_opt_score           1.4444444179534912     │\n",
       "│       val_precision           0.48571428656578064    │\n",
       "│        val_recall             0.8947368264198303     │\n",
       "│        val_roc_auc             0.932584285736084     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8148148059844971 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6296296119689941 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8148148059844971 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4128589630126953 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.4444444179534912 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.48571428656578064 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8947368264198303 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.932584285736084 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8ebac9304e7046dcad2e58ffc71fa88e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "73c0044211a7435b9e0174af4d259b4e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "fa53da9ef81d4a85b7c63f778f50656f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.678\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "938ff958ed174cb090ccdf6359092057", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "80884a1d5479431aa2acab43072d2df7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "429fac92c0af43b68031e1ea3252b39e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2bbcc4eafe8b4d8ab5eb9ed5f22a4c5a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "986aa77e2a6e42c18d6ecd93e1eefcf9", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3c48726787834adbbc9530381d61eaac", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f3042e08db6c438ea66b16f1b1a0d579", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c16a681c6aa24ef2a5e608d5bd874766", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9f66b22ea70e401f960b730a932fda71", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c8103c35b4b44ab0b8f3f1dac0de93c4", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.678. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c760034a955649088011bb70e5d0ebad", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8703703880310059     │\n",
       "│       val_f1_score            0.7941176295280457     │\n",
       "│       val_hp_metric           0.8703703880310059     │\n",
       "│         val_loss              0.3084067702293396     │\n",
       "│       val_opt_score           1.6644880771636963     │\n",
       "│       val_precision            0.692307710647583     │\n",
       "│        val_recall              0.931034505367279     │\n",
       "│        val_roc_auc            0.9456568956375122     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8703703880310059 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7941176295280457 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8703703880310059 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.3084067702293396 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.6644880771636963 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.692307710647583 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.931034505367279 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9456568956375122 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bef2da9ca4bc425cb89aaa5a0a5a7d4a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a2d6d9ddf1c248f4bb9590fef4726bcc", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e4e5db39c3514142b773133df7e081bd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.676\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a183ec05417444f1888b88e9f9f2e521", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "528376f5cc5847deaf32c7df090737a2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9c5602cc72ec477e8f7d3c77460af50e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "08e2769e80824629bac808c4050ac22a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0f0ae8922ef64eac9ac192f3b9d4cb37", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8e4bfe586a474f68ad58e7d98a3cb27b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cfc728dad560420685887369ec6c23e5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9719c095361c4b74955707fd870b9493", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "28a80e6a7cf44ef5a43bc80a23959477", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0006c9b7d49f4ce0a9385f112bad560d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.676. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5606d80cfeba4289a3c096afe26cbb22", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.7962962985038757     │\n",
       "│       val_f1_score            0.6764705777168274     │\n",
       "│       val_hp_metric           0.7962962985038757     │\n",
       "│         val_loss              0.45846864581108093    │\n",
       "│       val_opt_score           1.4727668762207031     │\n",
       "│       val_precision           0.6216216087341309     │\n",
       "│        val_recall             0.7419354915618896     │\n",
       "│        val_roc_auc            0.8856305480003357     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7962962985038757 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6764705777168274 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7962962985038757 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.45846864581108093 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.4727668762207031 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6216216087341309 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7419354915618896 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8856305480003357 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
val_lossval_accval_f1_scoreval_hp_metricval_opt_scoreval_precisionval_recallval_roc_aucfold
mean0.4171200.8353040.7113960.8353041.54670.6537880.8019270.9100504.50000
std0.0629280.0241580.0447050.0241580.06620.0892580.0998260.0235523.02765
\n", "
" ], "text/plain": [ " val_loss val_acc val_f1_score val_hp_metric val_opt_score \\\n", "mean 0.417120 0.835304 0.711396 0.835304 1.5467 \n", "std 0.062928 0.024158 0.044705 0.024158 0.0662 \n", "\n", " val_precision val_recall val_roc_auc fold \n", "mean 0.653788 0.801927 0.910050 4.50000 \n", "std 0.089258 0.099826 0.023552 3.02765 " ] }, "execution_count": 130, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# K-fold cross-validation loop\n", "from sklearn.model_selection import KFold\n", "\n", "n_splits = 5\n", "kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)\n", "val_metrics = []\n", "tmp = protac_df[protac_df['Active'].notna()]\n", "for k, (train_index, val_index) in enumerate(kf.split(tmp)):\n", " train_df = tmp.iloc[train_index]\n", " val_df = tmp.iloc[val_index]\n", " model, trainer, val_metric = train_model(train_df, val_df)\n", " val_metric['fold'] = k\n", " val_metrics.append(val_metric)\n", "val_metrics = pd.DataFrame(val_metrics)\n", "val_metrics.to_csv(\n", " f'../data/results/val_metrics_{n_splits}-splits.csv', index=False)\n", "val_metrics.aggregate(['mean', 'std'])" ] }, { "cell_type": "code", "execution_count": 131, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot aggregated results\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", "for n_splits in [5, 10]:\n", " val_metrics = pd.read_csv(\n", " f'../data/results/val_metrics_{n_splits}-splits_ablation.csv'\n", " )\n", "\n", " tmp = val_metrics.copy()[['fold', 'val_acc', 'val_roc_auc',\n", " 'val_precision', 'val_recall', 'val_f1_score']]\n", " # Rename columns\n", " tmp.columns = ['fold', 'Accuracy', 'ROC AUC',\n", " 'Precision', 'Recall', 'F1 score']\n", " # Plot aggregated mean value of all metrics in one bar plot\n", " tmp = tmp.melt(id_vars='fold', var_name='Metric', value_name='Score')\n", "\n", " sns.barplot(data=tmp, x='Metric', y='Score')\n", "\n", " num_data = len(protac_df[protac_df['Active'].notna()])\n", " plt.title(\n", " f'Validation metrics ({n_splits}-fold cross-validation on {num_data} samples)')\n", " plt.grid(axis='y', alpha=0.5)\n", " # Set y-axis to end at 1.0\n", " plt.ylim(0, 1.0)\n", " # Make the y-axis as percentage\n", " plt.gca().yaxis.set_major_formatter(\n", " plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 126, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot aggregated results\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", "n_splits = 5\n", "val_metrics = pd.read_csv(\n", " f'../data/results/val_metrics_{n_splits}-splits_ablation.csv'\n", ")\n", "\n", "tmp = val_metrics.copy()[['fold', 'val_acc', 'val_roc_auc',\n", " 'val_precision', 'val_recall', 'val_f1_score']]\n", "# Rename columns\n", "tmp.columns = ['fold', 'Accuracy', 'ROC AUC',\n", " 'Precision', 'Recall', 'F1 score']\n", "# Plot aggregated mean value of all metrics in one bar plot\n", "tmp = tmp.melt(id_vars='fold', var_name='Metric', value_name='Score')\n", "\n", "sns.barplot(data=tmp, x='Metric', y='Score')\n", "\n", "\n", "num_data = len(protac_df[protac_df['Active'].notna()])\n", "plt.title(\n", " f'Validation metrics ({n_splits}-fold cross-validation on {num_data} samples)')\n", "plt.grid(axis='y', alpha=0.5)\n", "# Set y-axis to end at 1.0\n", "plt.ylim(0, 1.0)\n", "# Make the y-axis as percentage\n", "plt.gca().yaxis.set_major_formatter(\n", " plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Ablation Studies" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | smiles_emb | Linear | 787 K \n", "1 | fc1 | Linear | 590 K \n", "2 | fc2 | Linear | 590 K \n", "3 | fc3 | Linear | 769 \n", "4 | dropout | Dropout | 0 \n", "5 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "2.0 M Trainable params\n", "0 Non-trainable params\n", "2.0 M Total params\n", "7.877 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "50dbc6fade944436be04b6bcd2a79e91", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c515836678af4c2786cc0857ac2a89d9", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f5a8e06b6f3e488bbb95135d5869b821", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.679\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cffd92ecff6b4e26ab07eff9bd96f520", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b4206cc9119848d7bc2fc72206f67fc7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3911809e2a5d4562aa378cf7e19ce420", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "382ca9b39e6149c88019e09c0d2eaa0e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "83804e7a6df449e286d1719a8fea697e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a05b21e45d00417e80b3d0502828b07c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1c450f427d444b1c88351773896ddc78", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bcff7aadc1d44a6fa4267b4e4d8c6859", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b9796bc1e5344695adf3103d12ad3fd7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "720f5c893557434aa0cd1360cce94c11", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.679. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f2ad945fe02b472787fc02cb2608fc51", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8894008994102478     │\n",
       "│       val_f1_score            0.8285714387893677     │\n",
       "│       val_hp_metric           0.8894008994102478     │\n",
       "│         val_loss              0.22978010773658752    │\n",
       "│       val_opt_score           1.7179722785949707     │\n",
       "│       val_precision           0.7250000238418579     │\n",
       "│        val_recall             0.9666666388511658     │\n",
       "│        val_roc_auc            0.9700636863708496     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8894008994102478 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8285714387893677 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8894008994102478 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.22978010773658752 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.7179722785949707 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7250000238418579 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9666666388511658 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9700636863708496 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "{'val_loss': 0.22978010773658752,\n", " 'val_acc': 0.8894008994102478,\n", " 'val_f1_score': 0.8285714387893677,\n", " 'val_hp_metric': 0.8894008994102478,\n", " 'val_opt_score': 1.7179722785949707,\n", " 'val_precision': 0.7250000238418579,\n", " 'val_recall': 0.9666666388511658,\n", " 'val_roc_auc': 0.9700636863708496}" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Random split the data into train and test\n", "from sklearn.model_selection import train_test_split\n", "\n", "train_df, test_df = train_test_split(\n", " protac_df[protac_df['Active'].notna()], test_size=0.2, random_state=42,\n", ")\n", "model, trainer, val_metric = train_model(\n", " train_df, val_df, disabled_embeddings=['poi', 'e3', 'cell'],\n", ")\n", "val_metric" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fold 0, disabled embeddings: ['poi', 'e3', 'cell']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | smiles_emb | Linear | 787 K \n", "1 | fc1 | Linear | 590 K \n", "2 | fc2 | Linear | 590 K \n", "3 | fc3 | Linear | 769 \n", "4 | dropout | Dropout | 0 \n", "5 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "2.0 M Trainable params\n", "0 Non-trainable params\n", "2.0 M Total params\n", "7.877 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6d2003ac853140d4be07094f870d01e7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c5dc5bc109154647a91eba389ddfd0d5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "717bab699d8e469ebfab4c4d165dbea2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.681\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a05d22e6bf7048d2be4fc36bb0da2564", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7b747e15ea954c39b327caffc09ff866", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "68cd758182654515ba18d86dbee435c8", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "773de468100e493fa4190a263cf2d407", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6f83c8642a7e4f598f7ee3d47a6ce363", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b11a9156d5dc4883978bf3680c4dd17b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1cf15595d32d43b5a34887cbdbc1ff60", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5eea4f1426664a7794cb229e4fc2b697", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "854eca19c354476c8134eb6758b9fe3e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "56219f060834490f90e0597caa0ef4df", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.681. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5c1cc664f09f488f92b1f98cf61fdee2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8256880640983582     │\n",
       "│       val_f1_score            0.6984127163887024     │\n",
       "│       val_hp_metric           0.8256880640983582     │\n",
       "│         val_loss              0.43253543972969055    │\n",
       "│       val_opt_score           1.5241007804870605     │\n",
       "│       val_precision           0.6666666865348816     │\n",
       "│        val_recall             0.7333333492279053     │\n",
       "│        val_roc_auc            0.8918248414993286     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8256880640983582 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6984127163887024 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8256880640983582 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.43253543972969055 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5241007804870605 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6666666865348816 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7333333492279053 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8918248414993286 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Fold 1, disabled embeddings: ['poi', 'e3', 'cell']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | smiles_emb | Linear | 787 K \n", "1 | fc1 | Linear | 590 K \n", "2 | fc2 | Linear | 590 K \n", "3 | fc3 | Linear | 769 \n", "4 | dropout | Dropout | 0 \n", "5 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "2.0 M Trainable params\n", "0 Non-trainable params\n", "2.0 M Total params\n", "7.877 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d19d15ddd9b941129b8fbcf5269061de", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9a8bbd54d38a4abba80e21b1a1a05a48", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bd431510337a400a991c561a505e09fa", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.681\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2d819e2db2c5490f84d950ffa65c3c21", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "88a9d28bdbda4cccbc172e0ec5d72e5b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6147bbb29d544d51a657aeb8ce5216a8", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "62c442218b7242cc9e13d4392935d8ab", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a9380f8439ff4f2f969a9a9020d9d454", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "628ec57e41404628be9cffb1f11a18bf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4e26d4f2cf4e474790d45d1011a7fcc5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "459b040053fc4454b1d7fc60b1d0a243", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c443ace858774c38bc911277817931cb", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6d46e4b8f5514cc5ab33c02fd32555b2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.681. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d98851e6b9a04e95bacb89e54fda1e6c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8302752375602722     │\n",
       "│       val_f1_score             0.678260862827301     │\n",
       "│       val_hp_metric           0.8302752375602722     │\n",
       "│         val_loss              0.42626988887786865    │\n",
       "│       val_opt_score           1.5085361003875732     │\n",
       "│       val_precision           0.6393442749977112     │\n",
       "│        val_recall             0.7222222089767456     │\n",
       "│        val_roc_auc             0.878669798374176     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8302752375602722 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.678260862827301 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8302752375602722 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.42626988887786865 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5085361003875732 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6393442749977112 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7222222089767456 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.878669798374176 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Fold 2, disabled embeddings: ['poi', 'e3', 'cell']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | smiles_emb | Linear | 787 K \n", "1 | fc1 | Linear | 590 K \n", "2 | fc2 | Linear | 590 K \n", "3 | fc3 | Linear | 769 \n", "4 | dropout | Dropout | 0 \n", "5 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "2.0 M Trainable params\n", "0 Non-trainable params\n", "2.0 M Total params\n", "7.877 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b34dbf29083d470faaa27389eec33307", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c9f0b66f5f904854b19f39f6577f78ff", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1242edb426bd4fe7a586d40b5a03bc78", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.681\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8ac5b3a3c37c47a6989698e3381f7f64", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3891c114903a4a98a84ea80337f11862", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7eb7a538328a4322bfeead1e4870af47", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "471b041184324116bae3f3dab334ab11", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "055eced85ba14e1689e93d92f8632d83", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b17ec92dc032401db16a412cf20f1446", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d7751a12e9484eea8314c9077178e41c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d1750a5a165d459e8dbd7c4b55cc9107", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "df6a7fab18224e8ead414f5f9c21116a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b4d0e7ee279e4a1b9a256335c0402a57", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.681. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "38dfcd5784fe42309b022c4b3fb3643c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8018433451652527     │\n",
       "│       val_f1_score            0.6814814805984497     │\n",
       "│       val_hp_metric           0.8018433451652527     │\n",
       "│         val_loss              0.44118818640708923    │\n",
       "│       val_opt_score           1.4833247661590576     │\n",
       "│       val_precision           0.5822784900665283     │\n",
       "│        val_recall             0.8214285969734192     │\n",
       "│        val_roc_auc            0.8986246585845947     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8018433451652527 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6814814805984497 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8018433451652527 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.44118818640708923 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.4833247661590576 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.5822784900665283 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8214285969734192 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8986246585845947 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Fold 3, disabled embeddings: ['poi', 'e3', 'cell']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | smiles_emb | Linear | 787 K \n", "1 | fc1 | Linear | 590 K \n", "2 | fc2 | Linear | 590 K \n", "3 | fc3 | Linear | 769 \n", "4 | dropout | Dropout | 0 \n", "5 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "2.0 M Trainable params\n", "0 Non-trainable params\n", "2.0 M Total params\n", "7.877 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2dd06a2b45e84e8c8a993f61660ba6ad", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "06c4442f48b74b4d88cf345db745a8ff", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "944d17ee72ff40a7ab71e7a8f5b233bf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.681\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5c90f09634e2419b90518c10de844d15", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7439a86f21db4e2b9828e8d31689ee12", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "085cf04c66c14c419dd06b7a10d78921", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f0760a28b97b42c1b97e9bf42de5904b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3e347c35a768467fa371bd4857e4c18b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "79607567baae44258cad8d96c93185dd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "71c052c5a3464a01b3382b77eada459b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a8a0518f250e44fb9cd39173b1795b9e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "445027abe12444cc81dfd315e6d0b13f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f931a407d4f64fd28f53e4e89408d4fb", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.681. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "70ea178af7b04737bb6a92552ff39f94", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.7972350120544434     │\n",
       "│       val_f1_score            0.6271186470985413     │\n",
       "│       val_hp_metric           0.7972350120544434     │\n",
       "│         val_loss              0.4882689416408539     │\n",
       "│       val_opt_score           1.4243535995483398     │\n",
       "│       val_precision           0.5441176295280457     │\n",
       "│        val_recall             0.7400000095367432     │\n",
       "│        val_roc_auc            0.8674850463867188     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7972350120544434 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6271186470985413 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7972350120544434 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4882689416408539 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.4243535995483398 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.5441176295280457 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7400000095367432 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8674850463867188 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Fold 4, disabled embeddings: ['poi', 'e3', 'cell']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\imblearn\\over_sampling\\_smote\\base.py:345: FutureWarning: The parameter `n_jobs` has been deprecated in 0.10 and will be removed in 0.12. You can pass an nearest neighbors estimator where `n_jobs` is already set instead.\n", " warnings.warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | smiles_emb | Linear | 787 K \n", "1 | fc1 | Linear | 590 K \n", "2 | fc2 | Linear | 590 K \n", "3 | fc3 | Linear | 769 \n", "4 | dropout | Dropout | 0 \n", "5 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "2.0 M Trainable params\n", "0 Non-trainable params\n", "2.0 M Total params\n", "7.877 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "887bda9f44ba4f43b5cb33fe3e850f0d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "c:\\Users\\ste\\Anaconda2\\envs\\env-thesis\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:432: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "d86c1f414c6d4bf4836c9c9df7befef1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "13e4cea9ba2d4e2cad9fb7ffb04e734e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.679\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9024ec21c159467e99cf0e53100bcb08", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "135764bbe2c743868055ed007a2da585", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c97d0e9b0a514c71b9ecabf2c4742a91", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "eccc6b5f67c447a7b67baa201a7370be", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "893ce33822b54e4e92b0c8e697d71e55", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "32bd15f2da724b45ac7500a88613306d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cb3c0d29d38c4197940c727bf47b315a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "efd8ec6f393d487c96d68d1d69bb6073", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "75d471ac44a743f1bddff068c4b7c3c8", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4218ae5c129f49c7a168c26bd92df42d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Monitored metric train_loss did not improve in the last 10 records. Best score: 0.679. Signaling Trainer to stop.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a0824ee73ebd4e18bc55bf3923b1ebed", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8018433451652527     │\n",
       "│       val_f1_score            0.6861313581466675     │\n",
       "│       val_hp_metric           0.8018433451652527     │\n",
       "│         val_loss              0.46606215834617615    │\n",
       "│       val_opt_score           1.4879746437072754     │\n",
       "│       val_precision           0.6103895902633667     │\n",
       "│        val_recall             0.7833333611488342     │\n",
       "│        val_roc_auc            0.8800424337387085     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8018433451652527 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6861313581466675 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8018433451652527 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.46606215834617615 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.4879746437072754 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6103895902633667 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7833333611488342 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8800424337387085 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\ste\\AppData\\Local\\Temp\\ipykernel_9048\\4021510138.py:42: FutureWarning: ['Uniprot', 'Smiles', 'E3 Ligase', 'InChI', 'InChI Key', 'Cell Type', 'Article DOI', 'Comments', 'Database', 'Molecular Formula', 'Target', 'PDB', 'Name', 'Assay (DC50/Dmax)', 'Target (Parsed)', 'POI Sequence', 'E3 Ligase Uniprot', 'E3 Ligase Sequence', 'Cell Line Identifier', 'disabled_embeddings'] did not aggregate successfully. If any error is raised this will raise in a future version of pandas. Drop these columns/ops to avoid this warning.\n", " val_metrics.aggregate(['mean', 'std'])\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Compound IDMolecular WeightHeavy Atom CountRing CountRotatable Bond CountTopological Polar Surface AreaHydrogen Bond Acceptor CountHydrogen Bond Donor CountTreatment Time (h)DC50 (nM)...XLogP3val_lossval_accval_f1_scoreval_hp_metricval_opt_scoreval_precisionval_recallval_roc_aucfold
mean1309.798528984.39334370.0294397.38546520.139834220.73228213.6513344.46734118.1547742396.467627...5.2608860.4508650.8113770.6742810.8113771.4856580.6085590.7600640.8833292.000000
std931.846640165.93637311.2942831.3683786.37955038.6922082.8724991.42930110.4105938579.934090...2.4185670.0258100.0153600.0274530.0153600.0379810.0478830.0414010.0121421.581139
\n", "

2 rows × 24 columns

\n", "
" ], "text/plain": [ " Compound ID Molecular Weight Heavy Atom Count Ring Count \\\n", "mean 1309.798528 984.393343 70.029439 7.385465 \n", "std 931.846640 165.936373 11.294283 1.368378 \n", "\n", " Rotatable Bond Count Topological Polar Surface Area \\\n", "mean 20.139834 220.732282 \n", "std 6.379550 38.692208 \n", "\n", " Hydrogen Bond Acceptor Count Hydrogen Bond Donor Count \\\n", "mean 13.651334 4.467341 \n", "std 2.872499 1.429301 \n", "\n", " Treatment Time (h) DC50 (nM) ... XLogP3 val_loss val_acc \\\n", "mean 18.154774 2396.467627 ... 5.260886 0.450865 0.811377 \n", "std 10.410593 8579.934090 ... 2.418567 0.025810 0.015360 \n", "\n", " val_f1_score val_hp_metric val_opt_score val_precision val_recall \\\n", "mean 0.674281 0.811377 1.485658 0.608559 0.760064 \n", "std 0.027453 0.015360 0.037981 0.047883 0.041401 \n", "\n", " val_roc_auc fold \n", "mean 0.883329 2.000000 \n", "std 0.012142 1.581139 \n", "\n", "[2 rows x 24 columns]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# K-fold cross-validation loop\n", "import os\n", "from sklearn.model_selection import KFold\n", "\n", "n_splits = 5\n", "embeddings_to_disable = [\n", " # ['poi'],\n", " # ['e3'],\n", " # ['cell'],\n", " # ['smiles'],\n", " ['poi', 'e3', 'cell'],\n", "]\n", "\n", "csv_filepath = f'../data/results/val_metrics_{n_splits}-splits_ablation.csv'\n", "if os.path.exists(csv_filepath):\n", " tmp = pd.read_csv(csv_filepath)\n", "else:\n", " tmp = pd.DataFrame()\n", "\n", "kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)\n", "val_metrics = []\n", "tmp = protac_df[protac_df['Active'].notna()]\n", "for k, (train_index, val_index) in enumerate(kf.split(tmp)):\n", " train_df = tmp.iloc[train_index]\n", " val_df = tmp.iloc[val_index]\n", " for disabled_embeddings in embeddings_to_disable:\n", " print(f'Fold {k}, disabled embeddings: {disabled_embeddings}')\n", " model, trainer, val_metric = train_model(\n", " train_df, val_df, disabled_embeddings,\n", " )\n", " val_metric['fold'] = k\n", " val_metric['disabled_embeddings'] = ' '.join(disabled_embeddings)\n", " val_metrics.append(val_metric)\n", "val_metrics = pd.DataFrame(val_metrics)\n", "\n", "val_metrics = pd.concat([tmp, val_metrics])\n", "\n", "val_metrics.to_csv(\n", " f'../data/results/val_metrics_{n_splits}-splits_ablation.csv',\n", " index=False\n", ")\n", "val_metrics.aggregate(['mean', 'std'])" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot aggregated results\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", "val_metrics = pd.read_csv(\n", " f'../data/results/val_metrics_{n_splits}-splits_ablation.csv'\n", ")\n", "\n", "for disabled_embeddings in embeddings_to_disable:\n", " tmp = val_metrics[val_metrics['disabled_embeddings']\n", " == ' '.join(disabled_embeddings)].copy()\n", " tmp = tmp[['fold', 'val_acc', 'val_roc_auc',\n", " 'val_precision', 'val_recall', 'val_f1_score']]\n", " # Rename columns\n", " tmp.columns = ['fold', 'Accuracy', 'ROC AUC',\n", " 'Precision', 'Recall', 'F1 score']\n", " # Plot aggregated mean value of all metrics in one bar plot\n", " tmp = tmp.melt(id_vars='fold', var_name='Metric', value_name='Score')\n", " sns.barplot(data=tmp, x='Metric', y='Score')\n", "\n", " num_data = len(protac_df[protac_df['Active'].notna()])\n", " plt.title(\n", " f'Val metrics ({n_splits}-fold cross-validation on {num_data} samples, disabled embeddings: {disabled_embeddings[0].upper()})')\n", " plt.grid(axis='y', alpha=0.5)\n", " # Set y-axis to end at 1.0\n", " plt.ylim(0, 1.0)\n", " # Make the y-axis as percentage\n", " plt.gca().yaxis.set_major_formatter(\n", " plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Psuedo-Label Training" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of parameters: 5,903,617\n" ] } ], "source": [ "from copy import copy\n", "\n", "oracle_model = copy(model)\n", "print(\n", " f'Number of parameters: {sum(p.numel() for p in oracle_model.parameters()):,}')" ] }, { "cell_type": "code", "execution_count": 107, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Oracle iteration 0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "461d8a19ef004f79a2e1015175be35bd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a972efecb6e64b28bee1223d9b460f22", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b0ed4cf70d424bfba05a38940719985c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.681\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6afd0cc025374a2fad9a03acafe19814", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e490e100850f4388b396e94ff14fad8d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ca60d1ae8f924ab9b31ff3e4f8f0cbd1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bb3f13aeb0c642e289edded6e5dc8ab9", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=5` reached.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5ce24886429c4947beb2a29d189b5d55", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8119266033172607     │\n",
       "│       val_f1_score            0.6611570119857788     │\n",
       "│       val_hp_metric           0.8119266033172607     │\n",
       "│         val_loss              0.36858928203582764    │\n",
       "│       val_opt_score           1.4730836153030396     │\n",
       "│       val_precision           0.6557376980781555     │\n",
       "│        val_recall             0.6666666865348816     │\n",
       "│        val_roc_auc            0.8914557695388794     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8119266033172607 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6611570119857788 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8119266033172607 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.36858928203582764 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.4730836153030396 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6557376980781555 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6666666865348816 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8914557695388794 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b20cd9147ce2493d876d1704fc8d82bf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[{'val_loss': 0.36858928203582764,\n", " 'val_acc': 0.8119266033172607,\n", " 'val_f1_score': 0.6611570119857788,\n", " 'val_hp_metric': 0.8119266033172607,\n", " 'val_opt_score': 1.4730836153030396,\n", " 'val_precision': 0.6557376980781555,\n", " 'val_recall': 0.6666666865348816,\n", " 'val_roc_auc': 0.8914557695388794}]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Oracle iteration 1\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3ed1d6be59d14ff6be46e16b266751cf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "98660bb9f10f4e4497cf935c2d145869", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c8b5685f0f2643d7b0403dd210c80048", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.680\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c3f6a0cf84f54e6aa11d85dde291108f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ae9f8760aa8e449886cd1658283c8de4", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "49e9339fa3634dd3937a7c00dd79a51b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0e36317bc6fb41c4b9d2ef87e913b95f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=5` reached.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5bc6623e98a94a61b5fe3be9424f637a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8119266033172607     │\n",
       "│       val_f1_score            0.7284768223762512     │\n",
       "│       val_hp_metric           0.8119266033172607     │\n",
       "│         val_loss              0.4363510012626648     │\n",
       "│       val_opt_score           1.5404033660888672     │\n",
       "│       val_precision           0.6043956279754639     │\n",
       "│        val_recall             0.9166666865348816     │\n",
       "│        val_roc_auc            0.8967299461364746     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8119266033172607 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7284768223762512 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8119266033172607 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4363510012626648 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5404033660888672 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6043956279754639 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9166666865348816 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8967299461364746 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c5ac531089ef4db19f115739821d2f2a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[{'val_loss': 0.4363510012626648,\n", " 'val_acc': 0.8119266033172607,\n", " 'val_f1_score': 0.7284768223762512,\n", " 'val_hp_metric': 0.8119266033172607,\n", " 'val_opt_score': 1.5404033660888672,\n", " 'val_precision': 0.6043956279754639,\n", " 'val_recall': 0.9166666865348816,\n", " 'val_roc_auc': 0.8967299461364746}]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Oracle iteration 2\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "52f2dee9fd5145bc8281ec9baf04d759", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "52d8b6bab5c84103b77281a06c552103", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5b64908b21c14682aef60fd5348a317b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.678\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a4d55544d779490d830147bd4adb9cc7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4f6ece7c4eb049f3910719f758a2e84d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b6455efe0cc94ca68cb2e16be011e738", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ae3c2e527d504dcf94ff1937655863b8", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=5` reached.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9d73120c6f324920acbd2e092689c270", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8486238718032837     │\n",
       "│       val_f1_score            0.7441860437393188     │\n",
       "│       val_hp_metric           0.8486238718032837     │\n",
       "│         val_loss              0.3814685344696045     │\n",
       "│       val_opt_score           1.5928099155426025     │\n",
       "│       val_precision            0.695652186870575     │\n",
       "│        val_recall              0.800000011920929     │\n",
       "│        val_roc_auc            0.9017932415008545     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8486238718032837 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7441860437393188 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8486238718032837 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.3814685344696045 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.5928099155426025 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.695652186870575 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.800000011920929 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9017932415008545 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "05e87ec2e35d4b7c990a69c77cfd9ff2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[{'val_loss': 0.3814685344696045,\n", " 'val_acc': 0.8486238718032837,\n", " 'val_f1_score': 0.7441860437393188,\n", " 'val_hp_metric': 0.8486238718032837,\n", " 'val_opt_score': 1.5928099155426025,\n", " 'val_precision': 0.695652186870575,\n", " 'val_recall': 0.800000011920929,\n", " 'val_roc_auc': 0.9017932415008545}]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Oracle iteration 3\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "10cee0bb09e54342b5667cc310c3b0db", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "412395eb2826440dbc6ddf6ef9cfaee6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6341b540c19e483a8fb161552062c49e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.665\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "372085f35ee94e909997b58bb74cf411", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7aa5b829a3134f41ae08bd03523dd0bf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "469991d3dcef48a39d462d92e321f6d4", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "049a245540a041209a17c8cdf9d4c249", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=5` reached.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cbf64814d8a349d1bdf785e3c2003bda", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8486238718032837     │\n",
       "│       val_f1_score            0.7591241002082825     │\n",
       "│       val_hp_metric           0.8486238718032837     │\n",
       "│         val_loss              0.3775690495967865     │\n",
       "│       val_opt_score            1.607748031616211     │\n",
       "│       val_precision           0.6753246784210205     │\n",
       "│        val_recall             0.8666666746139526     │\n",
       "│        val_roc_auc            0.8989450931549072     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8486238718032837 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7591241002082825 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8486238718032837 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.3775690495967865 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.607748031616211 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6753246784210205 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8666666746139526 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8989450931549072 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f142c9af8e7749969f88cf54ab742e86", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[{'val_loss': 0.3775690495967865,\n", " 'val_acc': 0.8486238718032837,\n", " 'val_f1_score': 0.7591241002082825,\n", " 'val_hp_metric': 0.8486238718032837,\n", " 'val_opt_score': 1.607748031616211,\n", " 'val_precision': 0.6753246784210205,\n", " 'val_recall': 0.8666666746139526,\n", " 'val_roc_auc': 0.8989450931549072}]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Oracle iteration 4\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------\n", "0 | poi_emb | Linear | 787 K \n", "1 | e3_emb | Linear | 787 K \n", "2 | cell_emb | Linear | 590 K \n", "3 | smiles_emb | Linear | 787 K \n", "4 | fc1 | Linear | 2.4 M \n", "5 | fc2 | Linear | 590 K \n", "6 | fc3 | Linear | 769 \n", "7 | dropout | Dropout | 0 \n", "8 | metrics | ModuleDict | 0 \n", "------------------------------------------\n", "5.9 M Trainable params\n", "0 Non-trainable params\n", "5.9 M Total params\n", "23.614 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b46c159286f94c4292a76e773b10ecbd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c3ee612bf9db4755b0c0d562c79d3935", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "305decdb9ec048b4bb3e2c16bc6304dc", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Metric train_loss improved. New best score: 0.665\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "91b59e48a2d541429d9902caf07f2546", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e170c32c520a4619a96b9c0f400a2d68", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "db12c97c83dc4a77a904325ab83dec48", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a11d8f8aa45640aab06ce829dc760e3c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=5` reached.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "53d56161558244359526ba0ad3a88930", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃  Runningstage.validating                             ┃\n",
       "┃          metric                  DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│          val_acc              0.8348624110221863     │\n",
       "│       val_f1_score                  0.71875          │\n",
       "│       val_hp_metric           0.8348624110221863     │\n",
       "│         val_loss              0.38852933049201965    │\n",
       "│       val_opt_score            1.553612470626831     │\n",
       "│       val_precision           0.6764705777168274     │\n",
       "│        val_recall             0.7666666507720947     │\n",
       "│        val_roc_auc            0.8900843858718872     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Runningstage.validating \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m┃\n", "┃\u001b[1m \u001b[0m\u001b[1m metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m val_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8348624110221863 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_f1_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.71875 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_hp_metric \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8348624110221863 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.38852933049201965 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_opt_score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.553612470626831 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_precision \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6764705777168274 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_recall \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7666666507720947 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m val_roc_auc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.8900843858718872 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2a1d290c9a5940aea897f8c0412646f5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[{'val_loss': 0.38852933049201965,\n", " 'val_acc': 0.8348624110221863,\n", " 'val_f1_score': 0.71875,\n", " 'val_hp_metric': 0.8348624110221863,\n", " 'val_opt_score': 1.553612470626831,\n", " 'val_precision': 0.6764705777168274,\n", " 'val_recall': 0.7666666507720947,\n", " 'val_roc_auc': 0.8900843858718872}]" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def get_oracle_predictions(model, trainer, test_df):\n", " test_ds = PROTAC_Dataset(\n", " test_df,\n", " protein_embeddings,\n", " cell2embedding,\n", " smiles2fp,\n", " )\n", " test_dl = DataLoader(test_ds, batch_size=32, shuffle=False)\n", " test_preds = trainer.predict(model, test_dl)\n", " test_preds = torch.vstack(test_preds).numpy().flatten()\n", " test_df['Active'] = [\n", " is_active(p, pos_threshold=0.97, neg_threshold=0.001) for p in test_preds]\n", " return test_df\n", "\n", "\n", "train_df, val_df = train_test_split(\n", " protac_df[protac_df['Active'].notna()], test_size=0.2, random_state=42)\n", "test_df = protac_df[protac_df['Active'].isna()]\n", "\n", "val_metrics = []\n", "for i in range(5):\n", " print(f'Oracle iteration {i}')\n", " model, trainer, metrics = train_model(train_df, val_df)\n", " val_metrics.append(metrics)\n", " test_df = get_oracle_predictions(model, trainer, test_df)\n", " # Update the training set\n", " train_df = pd.concat([\n", " train_df,\n", " test_df[test_df['Active'].notna()]], axis=0).drop_duplicates()\n", " display(metrics)" ] }, { "cell_type": "code", "execution_count": 108, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5aede109a90c428e900696220d318335", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Predicting: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "val_dl = DataLoader(val_ds, batch_size=32, shuffle=False)\n", "val_preds = trainer.predict(model, val_dl)\n", "val_preds = torch.vstack(val_preds).numpy().flatten()\n", "\n", "# Plot histogram of predictions\n", "plt.hist(val_preds, bins=20)\n", "plt.title('Validation predictions')\n", "plt.grid(axis='y', alpha=0.5)\n", "plt.show()" ] } ], "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.11.0" } }, "nbformat": 4, "nbformat_minor": 2 }