protein_fcn_prelim7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying to make a FCN to predict dihedral angles. Some of the code adapted from Jeppe's openprotein https://github.com/biolib/openprotein. The data is from https://github.com/aqlaboratory/proteinnet casp7, text based."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import imp\n",
    "import re\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa_id_dict = {'A': 0, 'C': 1, 'D': 2, 'E': 3, 'F': 4, 'G': 5, 'H': 6, 'I': 7,\n",
    "              'K': 8, 'L': 9, 'M': 10, 'N': 11, 'P': 12, 'Q': 13, 'R': 14, \n",
    "              'S': 15, 'T': 16, 'V': 17, 'W': 18, 'Y': 19}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First define some helper functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aa_to_onehot(aa_str, aa_to_nr, mask=None):\n",
    "    \"\"\"\n",
    "    Onehot encode an amino acid string using a letter to number dictionary.\n",
    "    The mask (from proteinnet files) is used to remove residues missing atoms from the primary sequence.\n",
    "    \"\"\"\n",
    "    if mask!=None:\n",
    "        mask_ind = np.asarray([x=='+' for x in mask])*1\n",
    "        mask_ind = np.nonzero(mask_ind)\n",
    "        aa_str = \"\".join([aa_str[x] for x in mask_ind[0]]) # the mask indices are a list in a list\n",
    "    init_array = np.zeros( (len(aa_to_nr.keys()), len(aa_str)) )\n",
    "    for i,j in enumerate(aa_str):\n",
    "        init_array[aa_to_nr[j], i] = 1\n",
    "    return(init_array)\n",
    "\n",
    "def filter_primary(aa_str, mask):\n",
    "    '''\n",
    "    Need this later on for writing pdb files, but should probably just use it at the start...\n",
    "    '''\n",
    "    mask_ind = np.asarray([x=='+' for x in mask])*1\n",
    "    mask_ind = np.nonzero(mask_ind)\n",
    "    aa_str = \"\".join([aa_str[x] for x in mask_ind[0]]) # the mask indices are a list in a list\n",
    "    return(aa_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_proteinnet_file(file, stop_at=1000, verbose=True):\n",
    "    \"\"\"\n",
    "    Read a proteinnet file. Will also filter the 3D coordinates using the mask\n",
    "    and remove proteins with chainbreaks and missing structures. \n",
    "    A certain number of proteins are loaded.\n",
    "    \"\"\"\n",
    "    protein_dict = {}\n",
    "    with open(file) as input:\n",
    "        lines = input.readlines()\n",
    "        curr_id = None\n",
    "        for i, line in enumerate(lines):\n",
    "            line = line.strip()\n",
    "            if line == '[ID]':\n",
    "                curr_id = lines[i+1].strip()\n",
    "                protein_dict[curr_id] = {}\n",
    "                protein_dict[curr_id]['primary'] = lines[i+3].strip()\n",
    "            if line == '[TERTIARY]':\n",
    "                coords = []\n",
    "                for j in range(3):\n",
    "                    coords.append(np.fromstring(lines[i+j+1], sep='\\t'))\n",
    "                protein_dict[curr_id]['tertiary'] = np.array(coords)\n",
    "            if line == '[MASK]':\n",
    "                protein_dict[curr_id]['mask'] = lines[i+1].strip()\n",
    "            if len(protein_dict.keys()) >= stop_at:\n",
    "                break\n",
    "    filter_seqs(protein_dict, verbose)\n",
    "    return(protein_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_coords(coords, mask):\n",
    "    \"\"\"\n",
    "    Filter atomic coordinates (for residues missing some) using the mask.\n",
    "    coords = 3*(N*3) array, since each residue has N, CA and C\n",
    "    \"\"\"\n",
    "    mask = np.array([x=='+' for x in mask])\n",
    "    mask_stretched = np.repeat(mask, 3)\n",
    "    coords_filt = coords[:, mask_stretched]\n",
    "    return(coords_filt)\n",
    "\n",
    "def filter_seqs(protein_dict, verbose):\n",
    "    re_chainbreak = re.compile(\"\\-*\\+*\\+\\-+\\+\\+*\\-*\") # match for a mask with internal chainbreaks\n",
    "    keys_to_remove = {}\n",
    "    for key in protein_dict.keys():\n",
    "        if len(protein_dict[key].keys()) < 3:\n",
    "            keys_to_remove[key] = ' missing structure, removing...'\n",
    "            continue\n",
    "        mask = protein_dict[key]['mask']\n",
    "        if re_chainbreak.search(mask):\n",
    "            keys_to_remove[key] = \" has a chainbreak, removing...\"\n",
    "        else:\n",
    "            coords = protein_dict[key]['tertiary']\n",
    "            coords_filt = filter_coords(coords, mask)\n",
    "            protein_dict[key]['tertiary'] = coords_filt\n",
    "    for key in keys_to_remove.keys():\n",
    "        if verbose:\n",
    "            print(key, keys_to_remove[key])\n",
    "        del protein_dict[key]\n",
    "\n",
    "def new_dihedral(p0, p1, p2, p3):\n",
    "    \"\"\"Praxeolitic formula\n",
    "    1 sqrt, 1 cross product\n",
    "    \n",
    "    copied from \n",
    "    https://stackoverflow.com/questions/20305272/\n",
    "    dihedral-torsion-angle-from-four-points-in-cartesian-coordinates-in-python\"\"\"\n",
    "\n",
    "    b0 = -1.0*(p1 - p0)\n",
    "    b1 = p2 - p1\n",
    "    b2 = p3 - p2\n",
    "\n",
    "    # normalize b1 so that it does not influence magnitude of vector\n",
    "    # rejections that come next\n",
    "    b1 /= np.linalg.norm(b1)\n",
    "\n",
    "    # vector rejections\n",
    "    # v = projection of b0 onto plane perpendicular to b1\n",
    "    #   = b0 minus component that aligns with b1\n",
    "    # w = projection of b2 onto plane perpendicular to b1\n",
    "    #   = b2 minus component that aligns with b1\n",
    "    v = b0 - np.dot(b0, b1)*b1\n",
    "    w = b2 - np.dot(b2, b1)*b1\n",
    "\n",
    "    # angle between v and w in a plane is the torsion angle\n",
    "    # v and w may not be normalized but that's fine since tan is y/x\n",
    "    x = np.dot(v, w)\n",
    "    y = np.dot(np.cross(b1, v), w)\n",
    "    #return np.degrees(np.arctan2(y, x))\n",
    "    return np.arctan2(y, x)\n",
    "\n",
    "def calc_angles(coords):\n",
    "    '''\n",
    "    Basically loops over the coordinates and calculates the dihedral angles.\n",
    "    There should be ways to do this with vectorized computations but I don't know how.\n",
    "    '''\n",
    "    N = coords.shape[1]\n",
    "    angles_all = []\n",
    "    for i in range(0, N-3, 3):\n",
    "        psi = new_dihedral(*[coords[:, x] for x in range(i, i+4)])\n",
    "        omega = new_dihedral(*[coords[:, x] for x in range(i+1, i+5)])\n",
    "        phi = new_dihedral(*[coords[:, x] for x in range(i+2, i+6)])\n",
    "        angles = [psi, omega, phi]\n",
    "        angles_all.append(angles)\n",
    "    return(np.array(angles_all))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load some proteins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_proteins = read_proteinnet_file('/Users/Deathvoodoo/big_folders_docs/data/casp7/training_70', 3000, verbose=False)\n",
    "val_proteins = read_proteinnet_file('/Users/Deathvoodoo/big_folders_docs/data/casp7/validation', 200, verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the function below to transform the sequences and coordinates into one-hot encoding and dihedral angles. The easiest thing to do would be to pad everything to the length of the longest protein and put it in one tensor, but this has consequences for the output of the network later (nonzero outputs at places that should be zero).\n",
    "<br>\n",
    "<br>\n",
    "Note that since I don't have access to powerful compute resources I'm only running with a small number of proteins for training and validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_onehot_angles(protein_dict, pad, max_length=1500):\n",
    "    \"\"\"\n",
    "    Get onehot sequence and calculate angles from 3d coords for the protein dictionary.\n",
    "    Sometimes the angle calculation will produce nans, we remove those sequences.\n",
    "    If pad==True we will numbers as tensors, otherwise lists, along with remaining ids.\n",
    "    \"\"\"\n",
    "    remaining_ids = list(protein_dict.keys())\n",
    "    sequence_list = []\n",
    "    angle_list = []\n",
    "    for key in protein_dict.keys():\n",
    "        sequence = aa_to_onehot(protein_dict[key]['primary'], aa_id_dict, protein_dict[key]['mask'])\n",
    "        coords = protein_dict[key]['tertiary']\n",
    "        angles = calc_angles(coords).T\n",
    "        if pad:\n",
    "            if max_length-sequence.shape[0] < 0:\n",
    "                print(key, ' exceeds max length: ', max_length, ' , skipping...')\n",
    "                continue\n",
    "            else:\n",
    "                # pad the width, current shape is C*W\n",
    "                sequence_padded = np.pad(\n",
    "                    sequence, pad_width = ((0,0), (0, max_length-sequence.shape[1])), \n",
    "                    constant_values = 0)\n",
    "                sequence_list.append(sequence_padded)\n",
    "                angles_padded = np.pad(\n",
    "                    angles, pad_width = ((0,0), (0, max_length-sequence.shape[1])),\n",
    "                    constant_values = 0)\n",
    "                angle_list.append(angles_padded)\n",
    "        else: \n",
    "            angle_list.append(angles)\n",
    "            sequence_list.append(sequence)\n",
    "    N = len(sequence_list)\n",
    "    have_nans = []\n",
    "    for i,j in enumerate(angle_list):\n",
    "        if np.isnan(j).any():\n",
    "            have_nans.append(i)\n",
    "    inds_to_keep = np.arange(N)[np.logical_not(np.isin(np.arange(N), have_nans))].tolist()\n",
    "    \n",
    "    sequence_list = [sequence_list[i] for i in inds_to_keep]\n",
    "    angle_list = [angle_list[i] for i in inds_to_keep]\n",
    "    remaining_ids = [remaining_ids[i] for i in inds_to_keep]\n",
    "    if pad:\n",
    "        sequence_tensor = torch.tensor(sequence_list).float()\n",
    "        sequence_tensor = sequence_tensor #.unsqueeze(1)\n",
    "        angle_tensor = torch.tensor(angle_list).float()\n",
    "        angle_tensor = angle_tensor #.unsqueeze(1)\n",
    "        return([sequence_tensor, angle_tensor, remaining_ids])\n",
    "    else:\n",
    "        for i in range(len(sequence_list)):\n",
    "            ith_seq = (torch.tensor(sequence_list[i]).float()).unsqueeze(0)\n",
    "            sequence_list[i] = ith_seq #.unsqueeze(0)\n",
    "            ith_angles = (torch.tensor(angle_list[i]).float()).unsqueeze(0)\n",
    "            angle_list[i] = ith_angles #.unsqueeze(0)\n",
    "        return([sequence_list, angle_list, remaining_ids])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:44: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "train_seqs, train_angles, train_ids_remain = get_onehot_angles(train_proteins, pad=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:44: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "val_seqs, val_angles, val_ids_remain = get_onehot_angles(val_proteins, pad=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also calculate sin and cos to transform the angles into better values for the squared loss error function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sin_cos(array, as_torch_tensor=True):\n",
    "    sin = np.sin(array)\n",
    "    cos = np.cos(array)\n",
    "    sin_cos = np.concatenate([sin, cos], axis=1)\n",
    "    if as_torch_tensor:\n",
    "        sin_cos = torch.tensor(sin_cos)\n",
    "    return(sin_cos)\n",
    "\n",
    "def back_to_angle(sin_cos_array, n_angles=3):\n",
    "    angles = []\n",
    "    for i in range(n_angles):\n",
    "        angles_i = np.arctan2(sin_cos_array[:, i, :], sin_cos_array[:, n_angles+i, :])\n",
    "        # remember that we input sin first due to atan2 definition\n",
    "        angles_i = angles_i[:, np.newaxis, :]\n",
    "        angles.append(angles_i)\n",
    "    angles_arr = np.concatenate(angles, 1)\n",
    "    return(angles_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_angles_sin_cos = [get_sin_cos(i) for i in train_angles]\n",
    "val_angles_sin_cos = [get_sin_cos(i) for i in val_angles]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We write a dataset class for the torch DataLoader. Since we also want to pad the minibatches instead of everything, we also need a custom collate function to deal with this. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset\n",
    "class proteindataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, seqs, angles):\n",
    "        self.sequences = seqs\n",
    "        self.angles = angles\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.sequences)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return [self.sequences[idx], self.angles[idx]]\n",
    "\n",
    "def protein_collate(batch):\n",
    "    seqs = [item[0] for item in batch]\n",
    "    angles = [item[1] for item in batch]\n",
    "    max_len = max([x.shape[2] for x in seqs])\n",
    "    for i in range(len(batch)):\n",
    "        curr_len = seqs[i].shape[2]\n",
    "        seq_padded = np.pad(seqs[i], ((0,0 ), (0,0), (0,max_len-curr_len)), constant_values = 0)\n",
    "        angles_padded = np.pad(angles[i], ((0,0 ), (0,0), (0,max_len-curr_len)), constant_values = 0)\n",
    "        seqs[i] = torch.tensor(seq_padded)\n",
    "        angles[i] = torch.tensor(angles_padded)\n",
    "    seq_tensor = torch.cat(seqs, 0)\n",
    "    angle_tensor = torch.cat(angles, 0)\n",
    "    return([seq_tensor, angle_tensor])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = proteindataset(train_seqs, train_angles_sin_cos)\n",
    "val_dataset = proteindataset(val_seqs, val_angles_sin_cos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=4,\n",
    "                                          shuffle=True, num_workers=2, collate_fn=protein_collate)\n",
    "valloader = torch.utils.data.DataLoader(val_dataset, batch_size=100,\n",
    "                                         shuffle=False, num_workers=2, collate_fn=protein_collate)\n",
    "#testloader = torch.utils.data.DataLoader(test_dataset, batch_size=100,\n",
    "                                         #shuffle=False, num_workers=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define and run a FCN with mean squared error as loss function. Angles are transformed to sin/cos and will be backtransformed with arctan 2 after training\n",
    "<br>\n",
    "First half of the network does convolution and the second half does up-convolution. It also has some skip connections like the U-NET architecture (but simpler).\n",
    "<br>\n",
    "<br>\n",
    "The proteins are encoded as $N*C*L$ where $C$ = 20 (number of amino acids) and $L$ = length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv0 = nn.Conv1d(20, 20, kernel_size=1)\n",
    "        self.conv0_bn = torch.nn.BatchNorm1d(20)\n",
    "        self.conv1 = nn.Conv1d(20, 15, kernel_size=4) # down\n",
    "        self.conv1_bn = torch.nn.BatchNorm1d(15)\n",
    "        self.conv2 = nn.Conv1d(15, 30, kernel_size=4) # down \n",
    "        self.conv2_bn = torch.nn.BatchNorm1d(30)\n",
    "        self.conv3 = nn.Conv1d(30, 24, kernel_size=6) # down, valley\n",
    "        self.conv3_bn = torch.nn.BatchNorm1d(24)\n",
    "        self.conv4 = nn.Conv1d(24, 24, kernel_size=1)\n",
    "        self.conv4_bn = torch.nn.BatchNorm1d(24)\n",
    "        \n",
    "        self.deconv1 = nn.ConvTranspose1d(in_channels=24, out_channels=30, kernel_size=6) # up\n",
    "        self.deconv1_bn = torch.nn.BatchNorm1d(30)\n",
    "        self.conv5 = nn.Conv1d(30, 30, 1)\n",
    "        self.conv5_bn = torch.nn.BatchNorm1d(30)\n",
    "        \n",
    "        self.deconv2 = nn.ConvTranspose1d(in_channels=60, out_channels=15, kernel_size=4) # up\n",
    "        self.deconv2_bn = torch.nn.BatchNorm1d(15)\n",
    "        self.conv6 = nn.Conv1d(15, 15, 1)\n",
    "        self.conv6_bn = torch.nn.BatchNorm1d(15)\n",
    "        \n",
    "        self.deconv3 = nn.ConvTranspose1d(in_channels=30, out_channels=15, kernel_size=3) # up\n",
    "        self.deconv3_bn = torch.nn.BatchNorm1d(15)\n",
    "        self.conv7 = nn.Conv1d(15, 6, (1))\n",
    "        self.conv7_bn = torch.nn.BatchNorm1d(6)\n",
    "        self.conv8 = nn.Conv1d(6, 6, 1)\n",
    "        self.conv8_bn = torch.nn.BatchNorm1d(6)\n",
    "        self.conv9 = nn.Conv1d(6, 6, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        conv0_out = F.relu(self.conv0_bn(self.conv0(x)))\n",
    "        conv1_out = F.relu(self.conv1_bn(self.conv1(conv0_out)))\n",
    "        conv2_out = F.relu(self.conv2_bn(self.conv2(conv1_out)))\n",
    "        conv3_out = F.relu(self.conv3_bn(self.conv3(conv2_out)))\n",
    "        conv4_out = F.relu(self.conv4_bn(self.conv4(conv3_out)))\n",
    "\n",
    "        deconv1_out = F.relu(self.deconv1_bn(self.deconv1(conv4_out)))\n",
    "        conv5_out = F.relu(self.conv5_bn(self.conv5(deconv1_out)))\n",
    "        \n",
    "        deconv2_input = torch.cat((conv2_out, deconv1_out), 1)  \n",
    "        deconv2_out = F.relu(self.deconv2_bn(self.deconv2(deconv2_input)))\n",
    "        conv6_out = F.relu(self.conv6_bn(self.conv6(deconv2_out)))\n",
    "        \n",
    "        deconv3_input = torch.cat((conv1_out, deconv2_out), 1)\n",
    "        deconv3_out = F.relu(self.deconv3_bn(self.deconv3(deconv3_input)))\n",
    "        conv7_out = F.relu(self.conv7_bn(self.conv7(deconv3_out)))\n",
    "        conv8_out = F.relu(self.conv8_bn(self.conv8(conv7_out)))\n",
    "        conv9_out = self.conv9(conv8_out)\n",
    "        return conv9_out\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, iteration: 118] training loss: 0.3886937973629527, validation_loss: 0.46820328157881036\n",
      "epoch: 0, iteration: 237] training loss: 0.2324230488107986, validation_loss: 0.2792795018194625\n",
      "new best validation loss, saving..\n",
      "epoch: 0, iteration: 356] training loss: 0.15351772408525483, validation_loss: 0.23280459401770412\n",
      "new best validation loss, saving..\n",
      "epoch: 0, iteration: 475] training loss: 0.13537751758048513, validation_loss: 0.21611089037256945\n",
      "new best validation loss, saving..\n",
      "epoch: 0, iteration: 594] training loss: 0.13168821702985203, validation_loss: 0.20830925313397225\n",
      "new best validation loss, saving..\n",
      "epoch: 1, iteration: 118] training loss: 0.12634562056104676, validation_loss: 0.20258381363490366\n",
      "new best validation loss, saving..\n",
      "epoch: 1, iteration: 237] training loss: 0.12478696016453895, validation_loss: 0.19833944548175944\n",
      "new best validation loss, saving..\n",
      "epoch: 1, iteration: 356] training loss: 0.11848319359436757, validation_loss: 0.1954507358279658\n",
      "new best validation loss, saving..\n",
      "epoch: 1, iteration: 475] training loss: 0.1112000838923855, validation_loss: 0.19351953980715383\n",
      "new best validation loss, saving..\n",
      "epoch: 1, iteration: 594] training loss: 0.11789320158858259, validation_loss: 0.19020950824299968\n",
      "new best validation loss, saving..\n",
      "epoch: 2, iteration: 118] training loss: 0.11288132599922789, validation_loss: 0.1888885110940621\n",
      "new best validation loss, saving..\n",
      "epoch: 2, iteration: 237] training loss: 0.11131666757228996, validation_loss: 0.19415384854959403\n",
      "epoch: 2, iteration: 356] training loss: 0.11461553948015726, validation_loss: 0.1888787902151205\n",
      "new best validation loss, saving..\n",
      "epoch: 2, iteration: 475] training loss: 0.10947295879366017, validation_loss: 0.18737777102715475\n",
      "new best validation loss, saving..\n",
      "epoch: 2, iteration: 594] training loss: 0.11313699480114865, validation_loss: 0.1860005676468707\n",
      "new best validation loss, saving..\n",
      "epoch: 3, iteration: 118] training loss: 0.10831697416656158, validation_loss: 0.18695916496911394\n",
      "epoch: 3, iteration: 237] training loss: 0.10638814482117902, validation_loss: 0.1848433503175374\n",
      "new best validation loss, saving..\n",
      "epoch: 3, iteration: 356] training loss: 0.10808718242064244, validation_loss: 0.18585021784586936\n",
      "epoch: 3, iteration: 475] training loss: 0.11377518029273057, validation_loss: 0.18428389586924782\n",
      "new best validation loss, saving..\n",
      "epoch: 3, iteration: 594] training loss: 0.10989515339376546, validation_loss: 0.186526003368893\n",
      "epoch: 4, iteration: 118] training loss: 0.11222216123793305, validation_loss: 0.18330795808423372\n",
      "new best validation loss, saving..\n",
      "epoch: 4, iteration: 237] training loss: 0.1063478038716717, validation_loss: 0.18547306040891953\n",
      "epoch: 4, iteration: 356] training loss: 0.10673065048431148, validation_loss: 0.18361889781511345\n",
      "epoch: 4, iteration: 475] training loss: 0.10830633608358246, validation_loss: 0.18440704301045918\n",
      "epoch: 4, iteration: 594] training loss: 0.10772999764240089, validation_loss: 0.1829838498917795\n",
      "new best validation loss, saving..\n",
      "epoch: 5, iteration: 118] training loss: 0.10247368387439672, validation_loss: 0.1840322276820308\n",
      "epoch: 5, iteration: 237] training loss: 0.108881789502226, validation_loss: 0.18260928014328026\n",
      "new best validation loss, saving..\n",
      "epoch: 5, iteration: 356] training loss: 0.10602221237260755, validation_loss: 0.18307739153782032\n",
      "epoch: 5, iteration: 475] training loss: 0.10814184682960269, validation_loss: 0.18261093553734117\n",
      "epoch: 5, iteration: 594] training loss: 0.10556721918973602, validation_loss: 0.18121034547871684\n",
      "new best validation loss, saving..\n",
      "epoch: 6, iteration: 118] training loss: 0.10400761056597493, validation_loss: 0.1824842524708983\n",
      "epoch: 6, iteration: 237] training loss: 0.10657978010903887, validation_loss: 0.18884541272469196\n",
      "epoch: 6, iteration: 356] training loss: 0.10734365417175934, validation_loss: 0.18111809671665563\n",
      "new best validation loss, saving..\n",
      "epoch: 6, iteration: 475] training loss: 0.10236871430352956, validation_loss: 0.1808881900325325\n",
      "new best validation loss, saving..\n",
      "epoch: 6, iteration: 594] training loss: 0.1103788700048663, validation_loss: 0.1877692841595004\n",
      "epoch: 7, iteration: 118] training loss: 0.10392501580865443, validation_loss: 0.18233932219214313\n",
      "epoch: 7, iteration: 237] training loss: 0.10720533176380045, validation_loss: 0.18058062458167898\n",
      "new best validation loss, saving..\n",
      "epoch: 7, iteration: 356] training loss: 0.1055326896930943, validation_loss: 0.18067393711079713\n",
      "epoch: 7, iteration: 475] training loss: 0.10507314135672666, validation_loss: 0.18315645427622412\n",
      "epoch: 7, iteration: 594] training loss: 0.10795411220242997, validation_loss: 0.1802914188654156\n",
      "new best validation loss, saving..\n",
      "epoch: 8, iteration: 118] training loss: 0.10227693285511322, validation_loss: 0.183884079689565\n",
      "epoch: 8, iteration: 237] training loss: 0.10352416208186069, validation_loss: 0.18120450528789747\n",
      "epoch: 8, iteration: 356] training loss: 0.10501397081783839, validation_loss: 0.183567581108268\n",
      "epoch: 8, iteration: 475] training loss: 0.1065501249825754, validation_loss: 0.18093374646876165\n",
      "epoch: 8, iteration: 594] training loss: 0.10715287454238459, validation_loss: 0.18422499745621446\n",
      "epoch: 9, iteration: 118] training loss: 0.09918434057040375, validation_loss: 0.18153073286973173\n",
      "epoch: 9, iteration: 237] training loss: 0.10206811771798535, validation_loss: 0.17951888954324743\n",
      "new best validation loss, saving..\n",
      "epoch: 9, iteration: 356] training loss: 0.10890051503391827, validation_loss: 0.18030395858591403\n",
      "epoch: 9, iteration: 475] training loss: 0.10499178502364319, validation_loss: 0.18237210340473975\n",
      "epoch: 9, iteration: 594] training loss: 0.10725130444439519, validation_loss: 0.1804661893326303\n",
      "epoch: 10, iteration: 118] training loss: 0.10426087117119998, validation_loss: 0.1796718058610184\n",
      "epoch: 10, iteration: 237] training loss: 0.10848352694962204, validation_loss: 0.18277511403242255\n",
      "epoch: 10, iteration: 356] training loss: 0.10492841849307052, validation_loss: 0.18115459287666386\n",
      "epoch: 10, iteration: 475] training loss: 0.10226715208978213, validation_loss: 0.17965021229678801\n",
      "epoch: 10, iteration: 594] training loss: 0.10386796996873968, validation_loss: 0.17979206602951017\n",
      "epoch: 11, iteration: 118] training loss: 0.10254347515331597, validation_loss: 0.1830254007153999\n",
      "epoch: 11, iteration: 237] training loss: 0.1036443443608885, validation_loss: 0.17947297818634822\n",
      "new best validation loss, saving..\n",
      "epoch: 11, iteration: 356] training loss: 0.10710126462102938, validation_loss: 0.1806834599477535\n",
      "epoch: 11, iteration: 475] training loss: 0.10306564370999817, validation_loss: 0.18035492865565406\n",
      "epoch: 11, iteration: 594] training loss: 0.10449430515535739, validation_loss: 0.17982004835091026\n",
      "epoch: 12, iteration: 118] training loss: 0.10470073695192818, validation_loss: 0.17996403234808336\n",
      "epoch: 12, iteration: 237] training loss: 0.10661614119630902, validation_loss: 0.17899686648793836\n",
      "new best validation loss, saving..\n",
      "epoch: 12, iteration: 356] training loss: 0.10062590235171198, validation_loss: 0.180112236798365\n",
      "epoch: 12, iteration: 475] training loss: 0.1075811692270912, validation_loss: 0.18225501889582746\n",
      "epoch: 12, iteration: 594] training loss: 0.09834025280565775, validation_loss: 0.18020243554011642\n",
      "epoch: 13, iteration: 118] training loss: 0.09977973884895068, validation_loss: 0.17869289746936048\n",
      "new best validation loss, saving..\n",
      "epoch: 13, iteration: 237] training loss: 0.10101215641538636, validation_loss: 0.17867876573101338\n",
      "new best validation loss, saving..\n",
      "epoch: 13, iteration: 356] training loss: 0.10217105872741267, validation_loss: 0.18543959686659872\n",
      "epoch: 13, iteration: 475] training loss: 0.10561645669596535, validation_loss: 0.1815511845746396\n",
      "epoch: 13, iteration: 594] training loss: 0.10461604275873729, validation_loss: 0.1798061896925387\n",
      "epoch: 14, iteration: 118] training loss: 0.10324647218114187, validation_loss: 0.18038003070291528\n",
      "epoch: 14, iteration: 237] training loss: 0.10058863692674316, validation_loss: 0.1804875481341566\n",
      "epoch: 14, iteration: 356] training loss: 0.10173436798969236, validation_loss: 0.18081346846052576\n",
      "epoch: 14, iteration: 475] training loss: 0.1045764336879013, validation_loss: 0.18404031086782494\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 14, iteration: 594] training loss: 0.09873566488508417, validation_loss: 0.17874623724022262\n",
      "epoch: 15, iteration: 118] training loss: 0.09886539912148684, validation_loss: 0.17888176182042004\n",
      "epoch: 15, iteration: 237] training loss: 0.10109624748720843, validation_loss: 0.1813052863067722\n",
      "epoch: 15, iteration: 356] training loss: 0.09968566628439086, validation_loss: 0.17943687924409496\n",
      "epoch: 15, iteration: 475] training loss: 0.1040238587170088, validation_loss: 0.17924762517213827\n",
      "epoch: 15, iteration: 594] training loss: 0.10321016136963829, validation_loss: 0.18325060235787619\n",
      "epoch: 16, iteration: 118] training loss: 0.09723991609546316, validation_loss: 0.18258730099993453\n",
      "epoch: 16, iteration: 237] training loss: 0.1025719756902266, validation_loss: 0.17904570087883043\n",
      "epoch: 16, iteration: 356] training loss: 0.10020888537293722, validation_loss: 0.17911090257560228\n",
      "epoch: 16, iteration: 475] training loss: 0.10323832716260638, validation_loss: 0.18102109948207876\n",
      "epoch: 16, iteration: 594] training loss: 0.09960449252183698, validation_loss: 0.17964406933936272\n",
      "epoch: 17, iteration: 118] training loss: 0.09795272622664436, validation_loss: 0.18132226428259962\n",
      "epoch: 17, iteration: 237] training loss: 0.09965601525887721, validation_loss: 0.18087532695220862\n",
      "epoch: 17, iteration: 356] training loss: 0.09976153792578633, validation_loss: 0.17974146841938446\n",
      "epoch: 17, iteration: 475] training loss: 0.10356235494758903, validation_loss: 0.18046934724501937\n",
      "epoch: 17, iteration: 594] training loss: 0.10405950639553431, validation_loss: 0.1809839183082861\n",
      "epoch: 18, iteration: 118] training loss: 0.09959653007383105, validation_loss: 0.18048656363942608\n",
      "epoch: 18, iteration: 237] training loss: 0.10144311258522402, validation_loss: 0.1792354793143198\n",
      "epoch: 18, iteration: 356] training loss: 0.1008305964099259, validation_loss: 0.1789763154265303\n",
      "epoch: 18, iteration: 475] training loss: 0.09833208336925306, validation_loss: 0.18028739171091068\n",
      "epoch: 18, iteration: 594] training loss: 0.09985604343794975, validation_loss: 0.17921233387744953\n",
      "epoch: 19, iteration: 118] training loss: 0.09939558606813936, validation_loss: 0.17922242747052866\n",
      "epoch: 19, iteration: 237] training loss: 0.09763998926437202, validation_loss: 0.1795690011302507\n",
      "epoch: 19, iteration: 356] training loss: 0.09945186891225206, validation_loss: 0.17899799469557617\n",
      "epoch: 19, iteration: 475] training loss: 0.09457458928227425, validation_loss: 0.17897191197142845\n",
      "epoch: 19, iteration: 594] training loss: 0.10520408033322887, validation_loss: 0.17960166109737405\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "net = Net()\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(net.parameters(), lr=1e-3)\n",
    "\n",
    "prints_per_epoch = 5\n",
    "\n",
    "verbose_k = np.floor(len(trainloader)/prints_per_epoch)\n",
    "\n",
    "\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "iterations = []\n",
    "best_loss = None\n",
    "\n",
    "for epoch in range(20):\n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader):\n",
    "        sequence, true_angles = data\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        predicted_angles = net(sequence)\n",
    "\n",
    "        loss = criterion(predicted_angles, true_angles)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        # adding to running loss, we will output this at every verbose_k\n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        if (i+1) % verbose_k == 0:   \n",
    "            train_losses.append(running_loss/verbose_k)\n",
    "            true_iter = len(trainloader)*epoch + i\n",
    "            iterations.append(true_iter)\n",
    "            net.eval()\n",
    "            validation_loss = 0\n",
    "            for k,j in enumerate(val_seqs):\n",
    "                pred_k = net(j)\n",
    "                loss_k = criterion(pred_k, val_angles_sin_cos[k]).item()\n",
    "                validation_loss += loss_k/len(val_seqs)\n",
    "            val_losses.append(validation_loss)\n",
    "            net.train()\n",
    "            print('epoch: {}, iteration: {}] training loss: {}, validation_loss: {}'.format(\n",
    "                epoch, i, running_loss/verbose_k, validation_loss))\n",
    "            \n",
    "            if best_loss == None:\n",
    "                best_loss = validation_loss\n",
    "            else:\n",
    "                if validation_loss <= min(val_losses):\n",
    "                    print('new best validation loss, saving..')\n",
    "                    best_loss = validation_loss\n",
    "                    torch.save(net.state_dict(), 'best_fcn_parameters.pt')\n",
    "\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.load_state_dict(torch.load('/Users/Deathvoodoo/big_folders_docs/random/best_fcn_parameters.pt'))\n",
    "\n",
    "net.eval()\n",
    "\n",
    "validation_preds = [net(i) for i in val_seqs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(iterations, train_losses, label='train loss')\n",
    "plt.scatter(iterations, val_losses, label='validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's transform the predicted values back to angles and compare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "validation_preds_angles = [back_to_angle(i.detach().numpy()) for i in validation_preds] # np instead of torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import PeptideBuilder\n",
    "test_protein = val_ids_remain[49]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_angles_real = val_angles[49].numpy()\n",
    "test_angles_pred = validation_preds_angles[49]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Need to filter the primary sequences to write pdb files. Could do this at the beginning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in val_proteins.keys():\n",
    "    val_proteins[key]['primary'] = filter_primary(val_proteins[key]['primary'], val_proteins[key]['mask'])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_pb_structure(seq_str, angles):\n",
    "    psi = np.degrees(angles[0, :].tolist())\n",
    "    omega = np.degrees(angles[1, :].tolist())\n",
    "    phi = np.degrees(angles[2, :].tolist())\n",
    "    structure = PeptideBuilder.make_structure(seq_str, phi, psi, omega)\n",
    "    return(structure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_structure_real = make_pb_structure(val_proteins[test_protein]['primary'], test_angles_real[0, :, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_structure_pred = make_pb_structure(val_proteins[test_protein]['primary'], test_angles_pred[0, :, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Bio.PDB\n",
    "def write_to_pdb(structure, prot_id, identifier):\n",
    "    out = Bio.PDB.PDBIO()\n",
    "    out.set_structure(structure)\n",
    "    out.save(prot_id + identifier + \".pdb\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "write_to_pdb(test_structure_real, test_protein, '_real')\n",
    "write_to_pdb(test_structure_pred, test_protein, '_pred')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can open the saved pdb files in pymol, align them and save the image. Cyan = predicte, green = true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image \n",
    "im = Image(filename=\"/Users/Deathvoodoo/big_folders_docs/random/90#1J2P_1_A.png\")\n",
    "display(im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, at least it sort of looks like a protein.\n",
    "<br>\n",
    "<br>\n",
    "Checking distribution of angles for the test protein."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141512\n",
      "3.1413598\n"
     ]
    }
   ],
   "source": [
    "print(test_angles_pred.max())\n",
    "print(test_angles_real.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1, 2, sharey=True, tight_layout=True)\n",
    "n_bins=20\n",
    "axs[0].hist(test_angles_real.flatten(), bins=n_bins)\n",
    "axs[1].hist(test_angles_pred.flatten(), bins=n_bins)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking more like angles than previous iterations"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}