{ "cells": [ { "cell_type": "markdown", "id": "e9ccf545", "metadata": {}, "source": [ "# Train a neural network to predict MHC class II ligands\n", "The notebook consists of the following sections:\n", "\n", "0. Introduction\n", "1. Module imports\n", "2. Functions\n", "3. Model (**TODO:** fill out the 'XXX')\n", "4. Load and encode data\n", "5. Train and validate model\n", "6. Evaluate on test data\n", "7. Hyperparameter tuning\n", "8. Create a python script" ] }, { "cell_type": "markdown", "id": "15ceca85", "metadata": {}, "source": [ "# 0 Introduction" ] }, { "cell_type": "markdown", "id": "9a325a11", "metadata": {}, "source": [ "## Exercise\n", "\n", "The exercise is to create a Feed-Forward Neural Network (FFNN) with PyTorch to perform its forward and backward loop. Then, optimize the model given in this notebook by selecting hyper-parameters that improve performance. First run the notebook as is and take notes of the performance (AUC). Then start a manual hyper-parameter search by following the instructions below. If your first run results in poor fitting (the model doesn't learn anything during training) do not dispair! Hopefully you will see a rapid improvement when you start testing other hyper-parameters.\n", "\n", "\n", "### Number of hidden units\n", "Try increasing the number of model parameters (weights), eg. 16, 32, or 64.\n", "\n", "### Parameter initialization\n", "Parameter initialization can be extremely important.\n", "Here you can find some [initializers](http://pytorch.org/docs/master/nn.html#torch-nn-init), the most often used initializers are listed below. Have a look at how they're implemented.\n", "1. Kaming He\n", "2. Uniform or Normal with small scale (0.1 - 0.01)\n", "\n", "Bias is nearly always initialized to zero\n", "\n", "### Nonlinearity\n", "Non-linearity is what makes neural networks universal predictors. Not everything in our universe is related by linearity and therefore we must implement non-linear activations to cope with that. [The most commonly used nonliearities](http://pytorch.org/docs/master/nn.html#non-linear-activations) are listed below. \n", "1. ReLU\n", "2. Sigmoid squash the output [0, 1], and are used if your output is binary.\n", "3. Tanh is similar to sigmoid, but squashes in [-1, 1]. It is rarely used any more.\n", "5. Softmax normalizes the the output to 1, and is used as output if you have a classification problem.\n", "\n", "Change the current function to another. To do so, you must modify self.hidden_act or self.out_act in the SimpleFFNN()-class. \n", "\n", "### Mix of peptide lengths\n", "\n", "Now you have hopefully found an architecture that yields a pretty good performance. But of course, it is not that simple... One of the issues that occurs when working with real data is that ligands can have lengths of 12–21 amino acids.\n", "\n", "So far, the DRB1_0101_cores data provided to you contained the same DRB1_0101 peptides, but only their previously identified binding cores. These cores were identified and annotated beforehand using other methods, meaning that all input sequences had the same length and were already aligned. In contrast, the DRB1_0101 data contain the original full-length peptide ligands of variable length, where the location of the binding core is not provided to the model.\n", "\n", "In order to accommodate different lengths, you need to pad your sequences so they still fit into the expected tensor. This, however, may interfere with the weights learned for the anchor positions.\n", "\n", "Try to include 12–21mers and take a look at how this affects performance using the DRB1_0101 allele data." ] }, { "cell_type": "markdown", "id": "753cf020", "metadata": {}, "source": [ "# 1 IMPORTS" ] }, { "cell_type": "code", "execution_count": 151, "id": "96cc409e", "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "import pandas as pd\n", "import numpy as np\n", "import math\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import roc_auc_score, roc_curve" ] }, { "cell_type": "markdown", "id": "2bae42c3", "metadata": {}, "source": [ "# 2 FUNCTIONS" ] }, { "cell_type": "code", "execution_count": 152, "id": "f850625b", "metadata": {}, "outputs": [], "source": [ "def load_blosum(filename):\n", " \"\"\"\n", " Load the BLOSUM matrix used for peptide encoding.\n", " \"\"\"\n", "\n", " aa = ['A', 'R', 'N' ,'D', 'C', 'Q', 'E', 'G', 'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V', 'X']\n", " df = pd.read_csv(filename, sep='\\s+', comment='#', index_col=0)\n", "\n", " blosum_matrix = torch.tensor(df.loc[aa, aa].to_numpy(), dtype=torch.float32)\n", "\n", " aa_to_idx = {aa:i for i, aa in enumerate(aa)}\n", "\n", " return blosum_matrix, aa_to_idx\n", "\n", "\n", "def load_peptide_target(filename):\n", " \"\"\"\n", " Read amino acid sequence of peptides and corresponding target values from text file.\n", " \"\"\"\n", " df = pd.read_csv(filename, sep='\\s+', usecols=[0,1], names=['peptide','target'])\n", " return df.sort_values(by='target', ascending=False).reset_index(drop=True)\n", "\n", "\n", "def encode_peptides(X_in, blosum_file, max_pep_len=9):\n", " \"\"\"\n", " Encode AA seq of peptides using BLOSUM 50.\n", " Returns a tensor of encoded peptides of shape (1, max_pep_len, n_features) for a single batch\n", " \"\"\"\n", "\n", " blosum50, aa_to_idx = load_blosum(blosum_file)\n", "\n", " X_idx = []\n", " for peptide in X_in[\"peptide\"]:\n", " peptide = peptide + (\"X\" * max(0, max_pep_len-len(peptide)))\n", " peptide = peptide[:max_pep_len]\n", " X_idx.append([aa_to_idx.get(aa, -1) for aa in peptide])\n", "\n", " X_idx = torch.tensor(X_idx, dtype=torch.long)\n", "\n", " X_out = blosum50[X_idx]\n", "\n", " return X_out, torch.tensor(X_in[\"target\"].to_numpy(), dtype=torch.float32).reshape(-1, 1)\n" ] }, { "cell_type": "code", "execution_count": 153, "id": "e11cecd3", "metadata": {}, "outputs": [], "source": [ "def plot_losses(train_losses, valid_losses, n_epochs):\n", " # Plotting the losses \n", " fig,ax = plt.subplots(1,1, figsize=(9,5))\n", " ax.plot(range(n_epochs), train_losses, label='Train loss', c='b')\n", " ax.plot(range(n_epochs), valid_losses, label='Valid loss', c='m')\n", " ax.legend()\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 154, "id": "8a9043c5", "metadata": {}, "outputs": [], "source": [ "def xavier_initialization_normal_numpy(input_dim, output_dim):\n", " shape = (input_dim, output_dim)\n", " stddev = np.sqrt(2 / (input_dim + output_dim))\n", " return np.random.normal(0, stddev, size=shape) * 0.1\n", "\n", "def random_initialization_normal_numpy(input_dim, output_dim):\n", " return np.random.randn(input_dim, output_dim) * 0.1\n", "\n", "def xavier_initialization_normal_pytorch(layer_weights):\n", " return nn.init.xavier_normal_(layer_weights)\n", "\n", "def random_initialization_normal_pytorch(layer_weights):\n", " return nn.init.normal_(layer_weights)" ] }, { "cell_type": "code", "execution_count": 155, "id": "a7a692d1", "metadata": {}, "outputs": [], "source": [ "def train_network_numpy(net, x_train, y_train, learning_rate):\n", " \"\"\"\n", " Trains the network for a single epoch, running the forward and backward pass, and compute and return the loss.\n", " \"\"\"\n", " # Forward pass\n", " z1, a1, z2, a2 = net.forward(x_train)\n", " # backward pass\n", " backward(net, x_train, y_train, z1, a1, z2, a2, learning_rate)\n", " loss = np.mean((a2 - y_train) ** 2)\n", " return loss\n", "\n", "\n", "def eval_network_numpy(net, x_valid, y_valid):\n", " \"\"\"\n", " Evaluates the network ; Note that we do not update weights (no backward pass)\n", " \"\"\"\n", " z1, a1, z2, a2 = net.forward(x_valid)\n", " loss = np.mean((a2-y_valid)**2)\n", " return loss\n", "\n", "\n", "def train_network_pytorch(net, x_train, y_train, optimizer):\n", " \"\"\"\n", " Trains the network for a single epoch, running the forward and backward pass, and compute and return the loss.\n", " \"\"\"\n", "\n", " net.train()\n", "\n", " loss_fn = nn.MSELoss()\n", " \n", " # Forward pass\n", " a2 = net(x_train)\n", "\n", " # backward pass\n", " loss = loss_fn(a2, y_train)\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " return loss.item()\n", "\n", "\n", "def eval_network_pytorch(net, x_valid, y_valid):\n", " \"\"\"\n", " Evaluates the network ; Note that we do not update weights (no backward pass)\n", " \"\"\"\n", "\n", " net.eval()\n", "\n", " loss_fn = nn.MSELoss()\n", "\n", " with torch.no_grad():\n", " a2 = net(x_valid)\n", " loss = loss_fn(a2, y_valid)\n", "\n", " return loss.item()" ] }, { "cell_type": "code", "execution_count": 156, "id": "65ce6675", "metadata": {}, "outputs": [], "source": [ "def save_ffnn_model(filepath, model):\n", " \"\"\"\n", " Save PyTorch FFNN model weights and architecture metadata.\n", " \"\"\"\n", "\n", " if not filepath.endswith(\".pt\"):\n", " filepath = filepath + \".pt\"\n", "\n", " dict_to_save = {\n", " \"input_size\": model.in_layer.in_features,\n", " \"hidden_size\": model.in_layer.out_features,\n", " \"output_size\": model.out_layer.out_features,\n", " \"state_dict\": model.state_dict()\n", " }\n", "\n", " torch.save(dict_to_save, filepath)\n", "\n", " print(f\"Saved FFNN model at {filepath}\")\n", "\n", "\n", "def load_ffnn_model(filepath, model=None):\n", " \"\"\"\n", " Load PyTorch FFNN model weights and architecture metadata.\n", " \"\"\"\n", "\n", " loaded_dict = torch.load(filepath, map_location=\"cpu\")\n", "\n", " if model is None:\n", " model = SimpleFFNN(\n", " input_size=loaded_dict[\"input_size\"],\n", " hidden_size=loaded_dict[\"hidden_size\"],\n", " output_size=loaded_dict[\"output_size\"]\n", " )\n", "\n", " assert model.in_layer.in_features == loaded_dict[\"input_size\"], \\\n", " f\"Input size mismatch. Model: {model.in_layer.in_features}, loaded: {loaded_dict['input_size']}\"\n", "\n", " assert model.in_layer.out_features == loaded_dict[\"hidden_size\"], \\\n", " f\"Hidden size mismatch. Model: {model.in_layer.out_features}, loaded: {loaded_dict['hidden_size']}\"\n", "\n", " assert model.out_layer.out_features == loaded_dict[\"output_size\"], \\\n", " f\"Output size mismatch. Model: {model.out_layer.out_features}, loaded: {loaded_dict['output_size']}\"\n", "\n", " model.load_state_dict(loaded_dict[\"state_dict\"])\n", "\n", " print(\n", " f\"Model loaded successfully from {filepath}\\n\"\n", " f\"with architecture: \"\n", " f\"input_size={loaded_dict['input_size']}, \"\n", " f\"hidden_size={loaded_dict['hidden_size']}, \"\n", " f\"output_size={loaded_dict['output_size']}\"\n", " )\n", "\n", " return model" ] }, { "cell_type": "markdown", "id": "1f544ffb", "metadata": {}, "source": [ "# 3 MODEL" ] }, { "cell_type": "markdown", "id": "269dc845", "metadata": {}, "source": [ "## Model definition\n", "\n", "Now it's your turn. We are using a class structure, where a class contains `methods` needed for the forward pass (that just means functions that belong to a class) and you will code the derivatives and backpropagation separately.\n", "\n", "For the forward pass, you will need to define the shape of your weight and bias matrices, as well as the actual `forward` pass in terms of matrix multiplications. Additionally, as we are using neural networks, you will also need to code the activation functions (ReLU and Sigmoid)." ] }, { "cell_type": "markdown", "id": "9c25d92a", "metadata": {}, "source": [ "### First from scratch using Numpy matrix multiplications\n", "To get the intuition of how PyTorch's backend works" ] }, { "cell_type": "code", "execution_count": 157, "id": "0e9f2cb1", "metadata": {}, "outputs": [], "source": [ "class SimpleFFNN_numpy:\n", " def __init__(self, input_size, hidden_size, output_size, initialization_function=xavier_initialization_normal_numpy):\n", " # Initialize weights and biases with small random values\n", " # initialization_function(input_dim, output_dim) -> np.array of shape (input_dim, output_dim)\n", " self.W1 = initialization_function(input_size, hidden_size) # XX\n", " self.b1 = np.zeros(hidden_size) # XX\n", " self.W2 = initialization_function(hidden_size, output_size) # XX\n", " self.b2 = np.zeros(output_size) # XX\n", " print(f'Input -> Hidden Layer Weight Matrix Shape: {self.W1.shape}',\n", " f'First Layer Bias Weights Vector Shape: {self.b1.shape}',\n", " f'Hidden -> Output layer Weight Matrix Shape: {self.W2.shape}',\n", " f'Second Layer Bias Weights Vector Shape: {self.b2.shape}', sep=\"\\n\")\n", " \n", " def relu(self, x):\n", " return np.maximum(0, x)\n", "\n", " def sigmoid(self, x): \n", " \"\"\"\n", " The normal version of sigmoid 1 / (1 + np.exp(-x)) is NOT numerically stable\n", " Here we split the case into two for positive and negative inputs\n", " because np.exp(-x) for something negative will quickly overflow if x is a large negative number\n", " \"\"\"\n", " # This is equivalent to : \n", " # if x>=0, then compute (1/(1+np.exp(-x)))\n", " # if x<0: compute (np.exp(x)/(1+np.exp(x))))\n", " return np.where(x >= 0, 1 / (1 + np.exp(-x)), \n", " np.exp(x) / (1 + np.exp(x)))\n", "\n", " def forward(self, x):\n", " \"\"\"\n", " x:\n", " zi denotes the output of a hidden layer i\n", " ai denotes the output of an activation function (non-linearity) at layer i\n", " (activations are relu, sigmoid, tanh, etc.)\n", " Use self.function to call a method. for example: self.relu(XX)\n", " \"\"\"\n", "\n", " # First layer : Use a relu here for the activation \n", " z1 = np.dot(x, self.W1) + self.b1 #XX\n", " a1 = self.relu(z1) #XX\n", " \n", " # Output layer : Use a sigmoid here for the activation\n", " z2 = np.dot(a1, self.W2) + self.b2 #XX\n", " a2 = self.sigmoid(z2) #XX\n", " \n", " # Return all the intermediate outputs as well because we need them for backpropagation (see slides)\n", " return z1, a1, z2, a2\n", "\n", "def relu_derivative(a):\n", " return (a > 0).astype(float) #XX\n", "\n", "def sigmoid_derivative(a):\n", " \"\"\"\n", " For this derivative, it is not necessary to find a numerically stable version.\n", " Just take the base formula and derive it. \n", " \"\"\"\n", " derivative = (1 - a) * a #XX\n", " return derivative\n", "\n", "\n", "def backward(net, x, y, z1, a1, z2, a2, learning_rate=0.01):\n", " \"\"\"\n", " Function to backpropagate the gradients from the output to update the weights.\n", " Apply the chain rule and slowly work out the chain derivatives from the output back to the input\n", " Reminder that np.dot(array_1, array_2) and array.T exists to transpose an array for matrix multiplication\n", " \"\"\"\n", " # This assumes that we are computing a MSE as the loss function.\n", " # Look at your slides to compute the gradient backpropagation for a mean-squared error using the chain rule.\n", " n = x.shape[0]\n", "\n", " # Output layer error ; We used a sigmoid in this layer\n", " dE_dO = 2 * (a2 - y) / n #XX\n", " dO_do = sigmoid_derivative(a2) #XX\n", " dE_do = dE_dO * dO_do #XX\n", "\n", " ### (REMEMBER for np.dot(A,B) columns of A MUST equal rows in B) ###\n", " \n", " # Backpropagate to hidden layer \n", " dE_dW2 = np.dot(a1.T, dE_do) #XX\n", " dE_db2 = np.sum(dE_do, axis=0, keepdims=True)\n", " dE_db2 = dE_db2.squeeze() # Squeeze is needed here to make the dimensions fit\n", "\n", " # Hidden layer error ; We used a ReLU in this layer!\n", " dE_dH = np.dot(dE_do, net.W2.T) #XX\n", " dE_dh = dE_dH * relu_derivative(a1) #XX\n", "\n", " # Backpropagate to input layer\n", " dE_dW1 = np.dot(x.T, dE_dh) #XX\n", " dE_db1 = np.sum(dE_dh, axis=0, keepdims=True) \n", " dE_db1 = dE_db1.squeeze() # Squeeze is needed here to make the dimensions fit\n", "\n", " # Update weights and biases using gradient descent\n", " net.W1 -= learning_rate * dE_dW1 #XX\n", " net.b1 -= learning_rate * dE_db1 #XX\n", " net.W2 -= learning_rate * dE_dW2 #XX\n", " net.b2 -= learning_rate * dE_db2 #XX" ] }, { "cell_type": "markdown", "id": "f610d3a7", "metadata": {}, "source": [ "### Now in a higher level using PyTorch" ] }, { "cell_type": "markdown", "id": "d16ec57f", "metadata": {}, "source": [ "This allow us to take advantage of PyTorch automatic differentiation implementation (Autograd) to compute the backward pass automatically." ] }, { "cell_type": "code", "execution_count": 158, "id": "2ff868b8", "metadata": {}, "outputs": [], "source": [ "class SimpleFFNN_pytorch(nn.Module):\n", "\n", "\n", " def __init__(self, input_size, hidden_size, output_size, initialization_function=xavier_initialization_normal_pytorch):\n", "\n", " super().__init__()\n", "\n", " self.in_layer = nn.Linear(input_size, hidden_size)\n", " self.out_layer = nn.Linear(hidden_size, output_size)\n", " self.hidden_act = nn.ReLU()\n", " self.out_act = nn.Sigmoid()\n", "\n", " initialization_function(self.in_layer.weight)\n", " initialization_function(self.out_layer.weight)\n", "\n", " print(f'Input -> Hidden Layer Weight Matrix Shape: {self.in_layer.weight.shape}',\n", " f'First Layer Bias Weights Vector Shape: {self.in_layer.bias.shape}',\n", " f'Hidden -> Output layer Weight Matrix Shape: {self.out_layer.weight.shape}',\n", " f'Second Layer Bias Weights Vector Shape: {self.out_layer.bias.shape}', sep=\"\\n\")\n", "\n", " \n", " def forward(self, x):\n", "\n", " z1 = self.in_layer(x)\n", " a1 = self.hidden_act(z1)\n", " z2 = self.out_layer(a1)\n", " a2 = self.out_act(z2)\n", "\n", " return a2\n", " " ] }, { "cell_type": "markdown", "id": "9167b806", "metadata": {}, "source": [ "# 4 Load and Encode Data " ] }, { "cell_type": "code", "execution_count": 186, "id": "7f823dba", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Preview of the dataframe ; Peptides have to be *encoded* to BLOSUM matrices\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", "
peptidetarget
0MVKVLDAVRGSPA1.0
1KRFLYKKLPSVEGLHA1.0
2AERLFKAMKGLGTRDN1.0
3AEIEYAMAYSKAAFER1.0
4APPVRHLIATQLLS1.0
\n", "
" ], "text/plain": [ " peptide target\n", "0 MVKVLDAVRGSPA 1.0\n", "1 KRFLYKKLPSVEGLHA 1.0\n", "2 AERLFKAMKGLGTRDN 1.0\n", "3 AEIEYAMAYSKAAFER 1.0\n", "4 APPVRHLIATQLLS 1.0" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "N_datapoints:\n", "Train data:\t 4000\n", "Valid data:\t 1500\n", "Test data:\t 1500\n", "Maximum peptide length of each data set:\n", "Train:\t 21\n", "Valid:\t 21\n", "Test:\t 21\n" ] } ], "source": [ "torch.manual_seed(42)\n", "np.random.seed(42)\n", "\n", "# Replace your data paths with the actual paths and desired alleles\n", "ALLELE = 'DRB1_0101' #'DRB1_0101_cores', 'DRB1_0101' \n", "DATAPATH = \"/Users/pablovf_22/Documents/TA/algorithms_in_bioinformatics_2026/data/\"\n", "blosum_file = f'{DATAPATH}NNDeep/BLOSUM50'\n", "train_data = f'{DATAPATH}NNDeep/{ALLELE}/train_EL'\n", "valid_data = f'{DATAPATH}NNDeep/{ALLELE}/valid_EL'\n", "test_data = f'{DATAPATH}NNDeep/{ALLELE}/test_EL'\n", "\n", "# Loading the peptides.\n", "train_raw = load_peptide_target(train_data)\n", "valid_raw = load_peptide_target(valid_data)\n", "test_raw = load_peptide_target(test_data)\n", "\n", "print('Preview of the dataframe ; Peptides have to be *encoded* to BLOSUM matrices')\n", "display(train_raw.head())\n", "\n", "print('N_datapoints:')\n", "print('Train data:\\t', train_raw.shape[0])\n", "print('Valid data:\\t', valid_raw.shape[0])\n", "print('Test data:\\t', test_raw.shape[0])\n", "\n", "print('Maximum peptide length of each data set:')\n", "print('Train:\\t', train_raw['peptide'].apply(len).max())\n", "print('Valid:\\t', valid_raw['peptide'].apply(len).max())\n", "print('Test:\\t', test_raw['peptide'].apply(len).max())" ] }, { "cell_type": "code", "execution_count": 187, "id": "fe46f7d7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Peptide length counts in the train data\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", "
count
len
12348
13358
14363
15430
16406
17424
18418
19431
20404
21418
\n", "
" ], "text/plain": [ " count\n", "len \n", "12 348\n", "13 358\n", "14 363\n", "15 430\n", "16 406\n", "17 424\n", "18 418\n", "19 431\n", "20 404\n", "21 418" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "train_raw['len']=train_raw['peptide'].apply(len)\n", "print('Peptide length counts in the train data')\n", "display(train_raw.groupby('len').agg(count=('peptide','count')))" ] }, { "cell_type": "markdown", "id": "aac1eeb8", "metadata": {}, "source": [ "### Peptide Encoding" ] }, { "cell_type": "markdown", "id": "d41a01bf", "metadata": {}, "source": [ "We need to ensure that every peptide shorter than the maximum length `max_len_pep` are *padded* to that length when building the matrices, in order for the dimensions to fit. For example, if our `max_pep_len` is 11, then every peptide of length shorter than 11 must be padded to 11. \n", "\n", "For example, for a peptide \"GILGFVFTL\", of size 9, and a `max_pep_len` of 11, this effectively means that the peptide is first padded to 11 : \"GILGFVFTLXX\", where \"x\" means a pad, and then converted to a matrix." ] }, { "cell_type": "code", "execution_count": 188, "id": "3a894d8c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([4000, 21, 21])\n" ] } ], "source": [ "max_pep_len = train_raw.peptide.apply(len).max()\n", "x_train_, y_train_ = encode_peptides(train_raw, blosum_file, max_pep_len)\n", "x_valid_, y_valid_ = encode_peptides(valid_raw, blosum_file, max_pep_len)\n", "x_test_, y_test_ = encode_peptides(test_raw, blosum_file, max_pep_len)\n", "# We now have matrices of shape (N_datapoints, max_pep_len, n_features)\n", "print(x_train_.shape)" ] }, { "cell_type": "markdown", "id": "c5989227", "metadata": {}, "source": [ "# 5 Train and Validate Model\n", "\n", "Play around with the hyperparameters (number of epochs, learning rate, hidden size) and see what the changes do!" ] }, { "cell_type": "code", "execution_count": 189, "id": "076efb30", "metadata": {}, "outputs": [], "source": [ "# Reshaping the matrices so they're flat because feed-forward networks are \"one-dimensional\"\n", "x_train_ = x_train_.reshape(x_train_.shape[0], -1)\n", "x_valid_ = x_valid_.reshape(x_valid_.shape[0], -1)\n", "x_test_ = x_test_.reshape(x_test_.shape[0], -1)\n", "# Define sizes\n", "input_size = x_train_.shape[1] # also known as \"n_features\"\n", "# Model and training hyperparameters\n", "learning_rate = 0.01\n", "hidden_units = 50\n", "n_epochs = 2000\n", "output_size = 1" ] }, { "cell_type": "markdown", "id": "08cfadd7", "metadata": {}, "source": [ "## Numpy" ] }, { "cell_type": "code", "execution_count": 190, "id": "04f96204", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Input -> Hidden Layer Weight Matrix Shape: (441, 50)\n", "First Layer Bias Weights Vector Shape: (50,)\n", "Hidden -> Output layer Weight Matrix Shape: (50, 1)\n", "Second Layer Bias Weights Vector Shape: (1,)\n" ] } ], "source": [ "# Creating a model instance \n", "# You can use either `xavier_initialization_normal` or `random_initialization_normal`\n", "network = SimpleFFNN_numpy(input_size, hidden_units, output_size)" ] }, { "cell_type": "code", "execution_count": 191, "id": "7aac1b17", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 0: Train Loss: 0.2529\tValid Loss: 0.2504\n", "Epoch 100: Train Loss: 0.0846\tValid Loss: 0.0898\n", "Epoch 200: Train Loss: 0.0828\tValid Loss: 0.0881\n", "Epoch 300: Train Loss: 0.0814\tValid Loss: 0.0865\n", "Epoch 400: Train Loss: 0.0800\tValid Loss: 0.0847\n", "Epoch 500: Train Loss: 0.0783\tValid Loss: 0.0827\n", "Epoch 600: Train Loss: 0.0766\tValid Loss: 0.0805\n", "Epoch 700: Train Loss: 0.0748\tValid Loss: 0.0783\n", "Epoch 800: Train Loss: 0.0732\tValid Loss: 0.0764\n", "Epoch 900: Train Loss: 0.0718\tValid Loss: 0.0749\n", "Epoch 1000: Train Loss: 0.0707\tValid Loss: 0.0737\n", "Epoch 1100: Train Loss: 0.0697\tValid Loss: 0.0729\n", "Epoch 1200: Train Loss: 0.0689\tValid Loss: 0.0722\n", "Epoch 1300: Train Loss: 0.0681\tValid Loss: 0.0716\n", "Epoch 1400: Train Loss: 0.0673\tValid Loss: 0.0712\n", "Epoch 1500: Train Loss: 0.0666\tValid Loss: 0.0707\n", "Epoch 1600: Train Loss: 0.0659\tValid Loss: 0.0703\n", "Epoch 1700: Train Loss: 0.0652\tValid Loss: 0.0700\n", "Epoch 1800: Train Loss: 0.0645\tValid Loss: 0.0696\n", "Epoch 1900: Train Loss: 0.0639\tValid Loss: 0.0693\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x_train_numpy_ = x_train_.detach().numpy()\n", "y_train_numpy_ = y_train_.detach().numpy()\n", "x_valid_numpy_ = x_valid_.detach().numpy()\n", "y_valid_numpy_ = y_valid_.detach().numpy()\n", "\n", "# Training loops\n", "train_losses = []\n", "valid_losses = []\n", "\n", "# Run n_epochs of training\n", "for epoch in range(n_epochs):\n", " train_loss = train_network_numpy(network, x_train_numpy_, y_train_numpy_, learning_rate)\n", " valid_loss = eval_network_numpy(network, x_valid_numpy_, y_valid_numpy_)\n", " train_losses.append(train_loss)\n", " valid_losses.append(valid_loss)\n", " # For the first, every 5% of the epochs and last epoch, we print the loss \n", " # to check that the model is properly training. (loss going down)\n", " if (n_epochs >= 10 and epoch % math.ceil(0.05 * n_epochs) == 0) or epoch == 0 or epoch == n_epochs:\n", " print(f\"Epoch {epoch}: Train Loss: {train_loss:.4f}\\tValid Loss: {valid_loss:.4f}\")\n", "\n", "# plotting the losses \n", "plot_losses(train_losses, valid_losses, n_epochs)" ] }, { "cell_type": "markdown", "id": "7a53eb90", "metadata": {}, "source": [ "## PyTorch" ] }, { "cell_type": "code", "execution_count": 192, "id": "9f94aa63", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Input -> Hidden Layer Weight Matrix Shape: torch.Size([50, 441])\n", "First Layer Bias Weights Vector Shape: torch.Size([50])\n", "Hidden -> Output layer Weight Matrix Shape: torch.Size([1, 50])\n", "Second Layer Bias Weights Vector Shape: torch.Size([1])\n" ] } ], "source": [ "# Creating a model instance \n", "# You can use either `xavier_initialization_normal` or `random_initialization_normal`\n", "network = SimpleFFNN_pytorch(input_size, hidden_units, output_size)\n", "optimizer = torch.optim.SGD(network.parameters(), lr=learning_rate)" ] }, { "cell_type": "code", "execution_count": 193, "id": "a6109c61", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 0: Train Loss: 0.8187\tValid Loss: 0.7970\n", "Epoch 100: Train Loss: 0.0950\tValid Loss: 0.1043\n", "Epoch 200: Train Loss: 0.0937\tValid Loss: 0.1031\n", "Epoch 300: Train Loss: 0.0933\tValid Loss: 0.1027\n", "Epoch 400: Train Loss: 0.0931\tValid Loss: 0.1026\n", "Epoch 500: Train Loss: 0.0929\tValid Loss: 0.1025\n", "Epoch 600: Train Loss: 0.0928\tValid Loss: 0.1025\n", "Epoch 700: Train Loss: 0.0927\tValid Loss: 0.1025\n", "Epoch 800: Train Loss: 0.0926\tValid Loss: 0.1024\n", "Epoch 900: Train Loss: 0.0925\tValid Loss: 0.1024\n", "Epoch 1000: Train Loss: 0.0923\tValid Loss: 0.1024\n", "Epoch 1100: Train Loss: 0.0922\tValid Loss: 0.1024\n", "Epoch 1200: Train Loss: 0.0921\tValid Loss: 0.1023\n", "Epoch 1300: Train Loss: 0.0919\tValid Loss: 0.1023\n", "Epoch 1400: Train Loss: 0.0917\tValid Loss: 0.1022\n", "Epoch 1500: Train Loss: 0.0915\tValid Loss: 0.1022\n", "Epoch 1600: Train Loss: 0.0912\tValid Loss: 0.1021\n", "Epoch 1700: Train Loss: 0.0908\tValid Loss: 0.1021\n", "Epoch 1800: Train Loss: 0.0903\tValid Loss: 0.1020\n", "Epoch 1900: Train Loss: 0.0897\tValid Loss: 0.1019\n", "Saved FFNN model at /Users/pablovf_22/Documents/TA/algorithms_in_bioinformatics_2026/data//NNDeep/some_ffnn_model.pt\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Training loops\n", "train_losses = []\n", "valid_losses = []\n", "\n", "# Run n_epochs of training\n", "for epoch in range(n_epochs):\n", " train_loss = train_network_pytorch(network, x_train_, y_train_, optimizer)\n", " valid_loss = eval_network_pytorch(network, x_valid_, y_valid_)\n", " train_losses.append(train_loss)\n", " valid_losses.append(valid_loss)\n", " # For the first, every 5% of the epochs and last epoch, we print the loss \n", " # to check that the model is properly training. (loss going down)\n", " if (n_epochs >= 10 and epoch % math.ceil(0.05 * n_epochs) == 0) or epoch == 0 or epoch == n_epochs:\n", " print(f\"Epoch {epoch}: Train Loss: {train_loss:.4f}\\tValid Loss: {valid_loss:.4f}\")\n", "\n", "# save model + plot losses (put your own savename to be used for the model and predictions)\n", "model_savepath = f'{DATAPATH}/NNDeep/some_ffnn_model.pt' # /path/to/your/stuff/filename.pt\n", "save_ffnn_model(model_savepath, model=network)\n", "\n", "# plotting the losses \n", "plot_losses(train_losses, valid_losses, n_epochs)" ] }, { "cell_type": "markdown", "id": "0a8c8411", "metadata": {}, "source": [ "# 6 Evaluate on Test Data\n", "\n", "In this part, you will reload a trained model and use it for evaluation.\n", "\n", "Have a look at how the predictions scores are obtained. The predictions scores are the output of the network after a sigmoid function." ] }, { "cell_type": "code", "execution_count": 194, "id": "18d5bbc6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model loaded successfully from /Users/pablovf_22/Documents/TA/algorithms_in_bioinformatics_2026/data//NNDeep/some_ffnn_model.pt\n", "with architecture: input_size=441, hidden_size=50, output_size=1\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 194, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Reload the model and evaluate it\n", "#model_savepath = \n", "reloaded_network = load_ffnn_model(model_savepath, model=network)\n", "\n", "reloaded_network.eval()\n", "\n", "with torch.no_grad():\n", " test_prediction_scores = reloaded_network(x_test_)\n", "\n", "# Convert to numpy for sklearn\n", "y_test_np = y_test_.squeeze().numpy()\n", "test_scores_np = test_prediction_scores.squeeze().numpy()\n", "\n", "test_auc = roc_auc_score(y_test_np, test_scores_np)\n", "test_fpr, test_tpr, _ = roc_curve(y_test_np, test_scores_np)\n", "\n", "f, a = plt.subplots(1, 1, figsize=(9, 9))\n", "\n", "a.plot([0, 1], [0, 1], ls=':', lw=0.5, label='Random prediction: AUC=0.500', c='k')\n", "a.plot(test_fpr, test_tpr, ls='--', lw=1, label=f'Neural Network: AUC={test_auc:.3f}', c='b')\n", "a.legend()" ] }, { "cell_type": "code", "execution_count": 195, "id": "9f376d5b", "metadata": {}, "outputs": [], "source": [ "#type(test_predictions_scores)\n", "np.shape(test_prediction_scores)\n", "test_raw[\"predictions\"] = test_prediction_scores\n", "#np.shape(x_test_)" ] }, { "cell_type": "code", "execution_count": 196, "id": "217571b7", "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", "
peptidetargetpredictions
0KVDKVIQAQTAFSANPAN1.00.021417
1VQKWLLAAGAQKCHS1.00.003778
2TPTQREVIQALHPETLIS1.00.000292
3DTRTYTWLGALPVLH1.00.692177
4VIEYARLRGIRVLPE1.00.003541
............
1495LTVTRLYFSAEEGGE0.00.005695
1496LSAIFLGGLFLVLIH0.00.000679
1497QLLDVFRELEEQNLSLI0.00.000702
1498LPETLENWRAQTGLDIRES0.00.005924
1499LVTEFQETESQDAKEQVLANL0.00.000173
\n", "

1500 rows × 3 columns

\n", "
" ], "text/plain": [ " peptide target predictions\n", "0 KVDKVIQAQTAFSANPAN 1.0 0.021417\n", "1 VQKWLLAAGAQKCHS 1.0 0.003778\n", "2 TPTQREVIQALHPETLIS 1.0 0.000292\n", "3 DTRTYTWLGALPVLH 1.0 0.692177\n", "4 VIEYARLRGIRVLPE 1.0 0.003541\n", "... ... ... ...\n", "1495 LTVTRLYFSAEEGGE 0.0 0.005695\n", "1496 LSAIFLGGLFLVLIH 0.0 0.000679\n", "1497 QLLDVFRELEEQNLSLI 0.0 0.000702\n", "1498 LPETLENWRAQTGLDIRES 0.0 0.005924\n", "1499 LVTEFQETESQDAKEQVLANL 0.0 0.000173\n", "\n", "[1500 rows x 3 columns]" ] }, "execution_count": 196, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_raw" ] }, { "cell_type": "code", "execution_count": 197, "id": "f05708d0", "metadata": {}, "outputs": [], "source": [ "# Saving the predictions\n", "test_evalpath = DATAPATH + 'NNDeep/test_eval_ffnn_predictions.txt'\n", "test_raw['predictions'] = test_prediction_scores\n", "test_raw[['peptide','predictions','target']].to_csv(test_evalpath, index=False, header=False, float_format=\"%.6f\")" ] }, { "cell_type": "markdown", "id": "b67af931", "metadata": {}, "source": [ "# 7 Hyperparameter tuning" ] }, { "cell_type": "code", "execution_count": 198, "id": "822aeacb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training model with hidden size : 10, learning_rate : 0.01\n", "Input -> Hidden Layer Weight Matrix Shape: torch.Size([10, 441])\n", "First Layer Bias Weights Vector Shape: torch.Size([10])\n", "Hidden -> Output layer Weight Matrix Shape: torch.Size([1, 10])\n", "Second Layer Bias Weights Vector Shape: torch.Size([1])\n", "Training model with hidden size : 20, learning_rate : 0.01\n", "Input -> Hidden Layer Weight Matrix Shape: torch.Size([20, 441])\n", "First Layer Bias Weights Vector Shape: torch.Size([20])\n", "Hidden -> Output layer Weight Matrix Shape: torch.Size([1, 20])\n", "Second Layer Bias Weights Vector Shape: torch.Size([1])\n", "Training model with hidden size : 64, learning_rate : 0.01\n", "Input -> Hidden Layer Weight Matrix Shape: torch.Size([64, 441])\n", "First Layer Bias Weights Vector Shape: torch.Size([64])\n", "Hidden -> Output layer Weight Matrix Shape: torch.Size([1, 64])\n", "Second Layer Bias Weights Vector Shape: torch.Size([1])\n", "Training model with hidden size : 10, learning_rate : 0.0001\n", "Input -> Hidden Layer Weight Matrix Shape: torch.Size([10, 441])\n", "First Layer Bias Weights Vector Shape: torch.Size([10])\n", "Hidden -> Output layer Weight Matrix Shape: torch.Size([1, 10])\n", "Second Layer Bias Weights Vector Shape: torch.Size([1])\n", "Training model with hidden size : 20, learning_rate : 0.0001\n", "Input -> Hidden Layer Weight Matrix Shape: torch.Size([20, 441])\n", "First Layer Bias Weights Vector Shape: torch.Size([20])\n", "Hidden -> Output layer Weight Matrix Shape: torch.Size([1, 20])\n", "Second Layer Bias Weights Vector Shape: torch.Size([1])\n", "Training model with hidden size : 64, learning_rate : 0.0001\n", "Input -> Hidden Layer Weight Matrix Shape: torch.Size([64, 441])\n", "First Layer Bias Weights Vector Shape: torch.Size([64])\n", "Hidden -> Output layer Weight Matrix Shape: torch.Size([1, 64])\n", "Second Layer Bias Weights Vector Shape: torch.Size([1])\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/cq/zm9k9s5s2td0fyh4lb2dz1m40000gn/T/ipykernel_73333/3617201930.py:21: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", " f.show()\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Training loops\n", "results={}\n", "n_epochs = 2000\n", "\n", "f,a = plt.subplots(1,1, figsize=(9,9))\n", "a.plot([0,1],[0,1],ls=':', c='k', lw=0.5, label='Random prediction: AUC=0.500')\n", "\n", "# Tuning hyperparameters by looking at which one performs best\n", "for learning_rate in [0.01, 0.0001]:\n", " for hidden_size in [10, 20, 64]:\n", " print(f'Training model with hidden size : {hidden_size}, learning_rate : {learning_rate}')\n", " model = SimpleFFNN(input_size, hidden_size, output_size)\n", " optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n", " for _ in range(n_epochs):\n", " train_network(model, x_train_, y_train_, optimizer)\n", " test_predictions_scores = model(x_test_)\n", " test_auc = roc_auc_score(y_test_.squeeze().numpy(), test_predictions_scores.squeeze().detach().numpy())\n", " test_fpr, test_tpr, _ = roc_curve(y_test_.squeeze().numpy(), test_predictions_scores.squeeze().detach().numpy())\n", " a.plot(test_fpr, test_tpr, ls='--', lw=1, label=f'Model {hidden_size} ; lr={learning_rate}: AUC={test_auc:.3f}')\n", "a.legend()\n", "f.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "733a1a54", "metadata": {}, "outputs": [], "source": [ "from argparse import ArgumentParser\n", "\n", "parser = ArgumentParser(description=\"Train a feed-forward neural network for peptide binding prediction\")\n", "\n", "parser.add_argument(\n", " \"-train\",\n", " \"--train_data\",\n", " action=\"store\",\n", " dest=\"train_data\",\n", " type=str,\n", " required=True,\n", " help=\"Path to the training data file\"\n", ")\n", "\n", "parser.add_argument(\n", " \"-valid\",\n", " \"--valid_data\",\n", " action=\"store\",\n", " dest=\"valid_data\",\n", " type=str,\n", " required=True,\n", " help=\"Path to the validation data file\"\n", ")\n", "\n", "parser.add_argument(\n", " \"-nh\",\n", " \"--n_hidden\",\n", " action=\"store\",\n", " dest=\"n_hidden\",\n", " type=int,\n", " required=True,\n", " help=\"Number of neurons in the hidden layer\"\n", ")\n", "\n", "parser.add_argument(\n", " \"-lr\",\n", " \"--learning_rate\",\n", " action=\"store\",\n", " dest=\"learning_rate\",\n", " type=float,\n", " required=True,\n", " help=\"Learning rate\"\n", ")\n", "\n", "parser.add_argument(\n", " \"-o\",\n", " \"--output_dir\",\n", " action=\"store\",\n", " dest=\"output_dir\",\n", " type=str,\n", " required=True,\n", " help=\"Path to the output directory\"\n", ")\n", "\n", "args = parser.parse_args()\n", "\n", "train_data = args.train_data\n", "valid_data = args.valid_data\n", "hidden_size = args.n_hidden\n", "learning_rate = args.learning_rate\n", "output_dir = args.output_dir" ] }, { "cell_type": "code", "execution_count": null, "id": "5068e4a0", "metadata": {}, "outputs": [], "source": [ "from argparse import ArgumentParser\n", "\n", "parser = ArgumentParser(description=\"Run inference with a trained feed-forward neural network\")\n", "\n", "parser.add_argument(\n", " \"-i\",\n", " \"--inference_data\",\n", " action=\"store\",\n", " dest=\"inference_data\",\n", " type=str,\n", " required=True,\n", " help=\"Path to the inference data file\"\n", ")\n", "\n", "parser.add_argument(\n", " \"-p\",\n", " \"--parameter_file\",\n", " action=\"store\",\n", " dest=\"parameter_file\",\n", " type=str,\n", " required=True,\n", " help=\"Path to the trained model parameter file\"\n", ")\n", "\n", "parser.add_argument(\n", " \"-o\",\n", " \"--output_dir\",\n", " action=\"store\",\n", " dest=\"output_dir\",\n", " type=str,\n", " required=True,\n", " help=\"Path to the output directory\"\n", ")\n", "\n", "args = parser.parse_args()\n", "\n", "inference_data = args.inference_data\n", "parameter_file = args.parameter_file\n", "output_dir = args.output_dir" ] } ], "metadata": { "kernelspec": { "display_name": "algorithms_2026", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.20" } }, "nbformat": 4, "nbformat_minor": 5 }