--- a
+++ b/transfer-learning-plus-descriptors.ipynb
@@ -0,0 +1,367 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d3426c73-9556-4223-a0f4-afdd5edbd911",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "import xgboost as xgb\n",
+    "from scipy.stats import spearmanr\n",
+    "from sklearn.model_selection import train_test_split, GridSearchCV, KFold\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "from transformers import AutoTokenizer, AutoModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cc1849cc-efb9-4eb9-946e-3ce2a0480fee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of examples is: 560\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Index(['XLogP', 'LipinskiFailures', 'nRotB', 'MLogP', 'nAtomLAC', 'nAtomP',\n",
+       "       'nAtomLC', 'nBase', 'naAromAtom', 'ALogP', 'ALogp2', 'nSmallRings',\n",
+       "       'nRingBlocks', 'nAromBlocks', 'nRings6', 'WPATH', 'WTPT.2', 'WTPT.4',\n",
+       "       'WTPT.5', 'MDEC.11', 'MDEC.12', 'MDEC.13', 'MDEC.22', 'MDEC.23',\n",
+       "       'MDEC.33', 'MDEO.11', 'MDEO.22', 'MDEN.11', 'MDEN.12', 'MDEN.13',\n",
+       "       'MDEN.22', 'khs.ssCH2', 'khs.dsCH', 'khs.aaCH', 'khs.sssCH', 'khs.tsC',\n",
+       "       'khs.dssC', 'khs.aasC', 'khs.aaaC', 'khs.ssssC', 'khs.sNH2', 'khs.ssNH',\n",
+       "       'khs.aaNH', 'khs.aaN', 'khs.sssN', 'khs.aasN', 'khs.sOH', 'khs.ssO',\n",
+       "       'khs.aaO', 'khs.ssS', 'khs.aaS', 'khs.sCl', 'HybRatio', 'FMF', 'ECCEN',\n",
+       "       'SP.7', 'VP.7', 'SPC.6', 'VPC.6', 'SC.3', 'SC.5', 'VC.3', 'VC.5',\n",
+       "       'SCH.5', 'SCH.6', 'SCH.7', 'VCH.5', 'VCH.6', 'C1SP2', 'C2SP2', 'C3SP2',\n",
+       "       'C1SP3', 'C2SP3', 'C3SP3', 'ATSp5', 'ATSm1', 'tpsaEfficiency.1',\n",
+       "       'nHBDon', 'bpol', 'topoShape.1', 'pIC50', 'CANONICAL_SMILES'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load the the dataset, including molecular descriptors\n",
+    "df = pd.read_csv(\"data/hDHFR_pIC50_data.csv\")\n",
+    "print(f'Number of examples is: {len(df)}')\n",
+    "df.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ff644daa-469a-42d8-98e9-41cdc060e3e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Specify the column names of the descriptors\n",
+    "descriptors = ['XLogP', 'LipinskiFailures', 'nRotB', 'MLogP', 'nAtomLAC', 'nAtomP',\n",
+    "               'nAtomLC', 'nBase', 'naAromAtom', 'ALogP', 'ALogp2', 'nSmallRings',\n",
+    "               'nRingBlocks', 'nAromBlocks', 'nRings6', 'WPATH', 'WTPT.2', 'WTPT.4',\n",
+    "               'WTPT.5', 'MDEC.11', 'MDEC.12', 'MDEC.13', 'MDEC.22', 'MDEC.23',\n",
+    "               'MDEC.33', 'MDEO.11', 'MDEO.22', 'MDEN.11', 'MDEN.12', 'MDEN.13',\n",
+    "               'MDEN.22', 'khs.ssCH2', 'khs.dsCH', 'khs.aaCH', 'khs.sssCH', 'khs.tsC',\n",
+    "               'khs.dssC', 'khs.aasC', 'khs.aaaC', 'khs.ssssC', 'khs.sNH2', 'khs.ssNH',\n",
+    "               'khs.aaNH', 'khs.aaN', 'khs.sssN', 'khs.aasN', 'khs.sOH', 'khs.ssO',\n",
+    "               'khs.aaO', 'khs.ssS', 'khs.aaS', 'khs.sCl', 'HybRatio', 'FMF', 'ECCEN',\n",
+    "               'SP.7', 'VP.7', 'SPC.6', 'VPC.6', 'SC.3', 'SC.5', 'VC.3', 'VC.5',\n",
+    "               'SCH.5', 'SCH.6', 'SCH.7', 'VCH.5', 'VCH.6', 'C1SP2', 'C2SP2', 'C3SP2',\n",
+    "               'C1SP3', 'C2SP3', 'C3SP3', 'ATSp5', 'ATSm1', 'tpsaEfficiency.1',\n",
+    "               'nHBDon', 'bpol', 'topoShape.1']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "005b3f00-7291-4ea0-9726-18a8217d5a22",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaModel were not initialized from the model checkpoint at DeepChem/ChemBERTa-77M-MLM and are newly initialized: ['roberta.pooler.dense.weight', 'roberta.pooler.dense.bias']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load pre-trained model and tokenizer\n",
+    "model_name = 'DeepChem/ChemBERTa-77M-MLM'\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModel.from_pretrained(model_name)\n",
+    "\n",
+    "# Tokenize your input data\n",
+    "input_texts = list(df[\"CANONICAL_SMILES\"])\n",
+    "input_ids = tokenizer(input_texts, padding=True, truncation=True, return_tensors=\"pt\")\n",
+    "\n",
+    "# Pass tokenized input through the model to obtain embeddings\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**input_ids)\n",
+    "    embeddings = outputs.last_hidden_state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2157c60e-ff96-44c8-8938-8b2e1773d55d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([560, 166, 384])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# (number_of_examples, max_length, hidden_dimentions)\n",
+    "embeddings.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f2f0def2-3c37-46c1-a335-90c70eb7a1a9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([560, 384])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Flatten embeddings by pooling across the sequence dimension\n",
+    "pooled_embeddings = torch.mean(embeddings, dim=1)  # use mean; other pooling methods can be used\n",
+    "pooled_embeddings.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "8250d5d7-fe14-40a5-ad50-0368ab2b39d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Concatenate the embeddings with the dataset\n",
+    "column_names = ['x' + str(i) for i in range(pooled_embeddings.shape[1])]\n",
+    "pooled_embeddings_df = pd.DataFrame(data=pooled_embeddings, columns=column_names)\n",
+    "data = pd.concat([df, pooled_embeddings_df], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d9efd79f-ddbc-4941-86c1-c782203fa850",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "There are 448 molecules in Train df.\n",
+      "There are 56 molecules in Val df.\n",
+      "There are 56 molecules in Test df.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Split the dataset into train, validation, and test sets\n",
+    "train_df, temp_df = train_test_split(data, test_size=0.2, random_state=21)\n",
+    "val_df, test_df = train_test_split(temp_df, test_size=0.5, random_state=21)\n",
+    "print(f\"There are {len(train_df)} molecules in Train df.\")\n",
+    "print(f\"There are {len(val_df)} molecules in Val df.\")\n",
+    "print(f\"There are {len(test_df)} molecules in Test df.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8681a83d-124f-48a2-a904-403bb18785e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>XGBRegressor(base_score=None, booster=None, callbacks=None,\n",
+       "             colsample_bylevel=None, colsample_bynode=None,\n",
+       "             colsample_bytree=0.9, device=None, early_stopping_rounds=None,\n",
+       "             enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "             gamma=None, grow_policy=None, importance_type=None,\n",
+       "             interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
+       "             max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "             max_delta_step=None, max_depth=4, max_leaves=None,\n",
+       "             min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "             multi_strategy=None, n_estimators=200, n_jobs=None,\n",
+       "             num_parallel_tree=None, random_state=42, ...)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">XGBRegressor</label><div class=\"sk-toggleable__content\"><pre>XGBRegressor(base_score=None, booster=None, callbacks=None,\n",
+       "             colsample_bylevel=None, colsample_bynode=None,\n",
+       "             colsample_bytree=0.9, device=None, early_stopping_rounds=None,\n",
+       "             enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "             gamma=None, grow_policy=None, importance_type=None,\n",
+       "             interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
+       "             max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "             max_delta_step=None, max_depth=4, max_leaves=None,\n",
+       "             min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "             multi_strategy=None, n_estimators=200, n_jobs=None,\n",
+       "             num_parallel_tree=None, random_state=42, ...)</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "XGBRegressor(base_score=None, booster=None, callbacks=None,\n",
+       "             colsample_bylevel=None, colsample_bynode=None,\n",
+       "             colsample_bytree=0.9, device=None, early_stopping_rounds=None,\n",
+       "             enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "             gamma=None, grow_policy=None, importance_type=None,\n",
+       "             interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
+       "             max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "             max_delta_step=None, max_depth=4, max_leaves=None,\n",
+       "             min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "             multi_strategy=None, n_estimators=200, n_jobs=None,\n",
+       "             num_parallel_tree=None, random_state=42, ...)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create an XGBoost regressor with the specified parameters; TODO: hyperparameter-tuning\n",
+    "xgb_model = xgb.XGBRegressor(\n",
+    "    objective='reg:squarederror',\n",
+    "    colsample_bytree=0.9,\n",
+    "    learning_rate=0.1,\n",
+    "    max_depth=4,\n",
+    "    n_estimators=200,\n",
+    "    subsample=0.8,\n",
+    "    random_state=42  \n",
+    ")\n",
+    "\n",
+    "# Fit the model to the data\n",
+    "xgb_model.fit(train_df[column_names + descriptors], train_df[\"pIC50\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "4086aff3-6eea-4c1e-8698-5cf7383f24bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Mean Squared Error: 0.0011\n",
+      "Train Spearman Correlation: 0.9995\n",
+      "Val Mean Squared Error: 0.5704\n",
+      "Val Spearman Correlation: 0.7104\n",
+      "Test Mean Squared Error: 0.61\n",
+      "Test Spearman Correlation: 0.7555\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculate and print Mean Squared Error (MSE) and Spearman Correlation\n",
+    "def get_metrics(X_, y_, model, option='Train'):\n",
+    "    # Get training predictions\n",
+    "    y_pred = xgb_model.predict(X_)\n",
+    "    \n",
+    "    # Calculate Mean Squared Error\n",
+    "    mse = np.round(mean_squared_error(y_, y_pred), 4)\n",
+    "    print(f\"{option} Mean Squared Error:\", mse)\n",
+    "\n",
+    "    # Calculate Spearman Correlation\n",
+    "    spearman_corr, _ = np.round(spearmanr(y_, y_pred), 4)\n",
+    "    print(f\"{option} Spearman Correlation:\", spearman_corr)\n",
+    "\n",
+    "# Get metrics for train, validation, and test sets\n",
+    "get_metrics(train_df[column_names + descriptors], train_df[\"pIC50\"], xgb_model, option='Train')\n",
+    "get_metrics(val_df[column_names + descriptors], val_df[\"pIC50\"], xgb_model, option='Val')\n",
+    "get_metrics(test_df[column_names + descriptors], test_df[\"pIC50\"], xgb_model, option='Test')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "8332903c-8d23-4517-9177-940025fd7ae3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculate the predictions for the test set\n",
+    "pred = xgb_model.predict(test_df[column_names + descriptors])\n",
+    "actual = test_df['pIC50']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "117d1b8e-bd88-49ea-8545-7f6e0ff2e997",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Scatterplot of predicted vs. actual values \n",
+    "plt.scatter(pred, actual)\n",
+    "plt.plot([min(actual), max(actual)], [min(actual), max(actual)], 'k--')\n",
+    "plt.xlabel('Predicted')\n",
+    "plt.ylabel('Actual')\n",
+    "plt.grid();"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}