protein_fcn_prelim6.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",
    "from torch.nn.utils.rnn import pad_sequence"
   ]
  },
  {
   "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)"
   ]
  },
  {
   "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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_proteins = read_proteinnet_file('/Users/Deathvoodoo/big_folders_docs/data/casp7/training_70', 5000, verbose=False)\n",
    "val_proteins = read_proteinnet_file('/Users/Deathvoodoo/big_folders_docs/data/casp7/validation', 500, 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": 17,
   "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",
    "                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": 18,
   "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": 19,
   "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 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": 20,
   "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[3] for x in seqs])\n",
    "    for i in range(len(batch)):\n",
    "        curr_len = seqs[i].shape[3]\n",
    "        seq_padded = np.pad(seqs[i], ((0,0), (0,0 ), (0,0), (0,max_len-curr_len)), constant_values = 0)\n",
    "        angles_padded = np.pad(angles[i], ((0,0), (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": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = proteindataset(train_seqs, train_angles)\n",
    "val_dataset = proteindataset(val_seqs, val_angles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": [
    "Running a FCN with squared loss for training. Squared loss is probably not ideal (i.e. pi and -pi are not 2pi apart) but I'll use it for now. \n",
    "<br>\n",
    "First half of the network does convolution and the second half does up-convolution. It also has some skip connections a the U-NET architecture.\n",
    "<br>\n",
    "<br>\n",
    "Note that I encoded the proteins as $N*C*N_{aa}*L$ where $C$ = 1 and $N_{aa}$ = 20, but actually it makes a lot more sense to just use the number of amino acids as channels and just do 1D convolution, since they provide no spatial information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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.Conv2d(1, 3, (20, 1))\n",
    "        self.conv0_bn = torch.nn.BatchNorm2d(3)\n",
    "        self.conv1 = nn.Conv2d(3, 6, (1, 4))\n",
    "        self.conv1_bn = torch.nn.BatchNorm2d(6)\n",
    "        self.conv2 = nn.Conv2d(6, 12, (1, 4))\n",
    "        self.conv2_bn = torch.nn.BatchNorm2d(12)\n",
    "        self.conv3 = nn.Conv2d(12, 24, (1, 6))\n",
    "        self.conv3_bn = torch.nn.BatchNorm2d(24)\n",
    "        self.conv4 = nn.Conv2d(24, 24, (1, 1))\n",
    "        self.conv4_bn = torch.nn.BatchNorm2d(24)\n",
    "        \n",
    "        self.deconv1 = nn.ConvTranspose2d(in_channels=24, out_channels=12, kernel_size=(1, 6))\n",
    "        self.deconv1_bn = torch.nn.BatchNorm2d(12)\n",
    "        self.conv5 = nn.Conv2d(24, 24, (1,1))\n",
    "        self.conv5_bn = torch.nn.BatchNorm2d(24)\n",
    "        self.deconv2 = nn.ConvTranspose2d(in_channels=24, out_channels=6, kernel_size=(1, 4))\n",
    "        self.deconv2_bn = torch.nn.BatchNorm2d(6)\n",
    "        self.conv6 = nn.Conv2d(12, 12, (1,1))\n",
    "        self.conv6_bn = torch.nn.BatchNorm2d(12)\n",
    "        self.deconv3 = nn.ConvTranspose2d(in_channels=12, out_channels=6, kernel_size=(3, 3))\n",
    "        self.deconv3_bn = torch.nn.BatchNorm2d(6)\n",
    "        self.conv7 = nn.Conv2d(6, 1, (1,1))\n",
    "        self.conv7_bn = torch.nn.BatchNorm2d(1)\n",
    "        self.conv8 = nn.Conv2d(1, 1, (1,1))\n",
    "        self.conv8_bn = torch.nn.BatchNorm2d(1)\n",
    "        self.conv9 = nn.Conv2d(1, 1, (1,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",
    "        deconv2_input = torch.cat((conv2_out, deconv1_out), 1)\n",
    "        conv5_out = F.relu(self.conv5_bn(self.conv5(deconv2_input)))\n",
    "        \n",
    "        deconv2_out = F.relu(self.deconv2_bn(self.deconv2(conv5_out)))\n",
    "        deconv3_input = torch.cat((conv1_out, deconv2_out), 1)\n",
    "        conv6_out = F.relu(self.conv6_bn(self.conv6(deconv3_input)))\n",
    "        \n",
    "        deconv3_out = F.relu(self.deconv3_bn(self.deconv3(conv6_out)))\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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, iteration: 197] training loss: 2.783103596080433, validation_loss: 4.302130959604097\n",
      "epoch: 0, iteration: 395] training loss: 2.5267526964948637, validation_loss: 4.289084224597265\n",
      "new best validation loss, saving..\n",
      "epoch: 0, iteration: 593] training loss: 2.4757866155017507, validation_loss: 4.2954955010310485\n",
      "epoch: 0, iteration: 791] training loss: 2.4966613752673372, validation_loss: 4.2756686081057\n",
      "new best validation loss, saving..\n",
      "epoch: 0, iteration: 989] training loss: 2.529940300517612, validation_loss: 4.27451377718345\n",
      "new best validation loss, saving..\n",
      "epoch: 1, iteration: 197] training loss: 2.5080334201003565, validation_loss: 4.280141868021175\n",
      "epoch: 1, iteration: 395] training loss: 2.572692923473589, validation_loss: 4.286817585644516\n",
      "epoch: 1, iteration: 593] training loss: 2.541397589023667, validation_loss: 4.264641249957291\n",
      "new best validation loss, saving..\n",
      "epoch: 1, iteration: 791] training loss: 2.493474284205774, validation_loss: 4.268356919288636\n",
      "epoch: 1, iteration: 989] training loss: 2.4989839936747695, validation_loss: 4.262478805106618\n",
      "new best validation loss, saving..\n",
      "epoch: 2, iteration: 197] training loss: 2.537966726404248, validation_loss: 4.264427172101063\n",
      "epoch: 2, iteration: 395] training loss: 2.489988411917831, validation_loss: 4.266916990280151\n",
      "epoch: 2, iteration: 593] training loss: 2.510250327563045, validation_loss: 4.267100785089575\n",
      "epoch: 2, iteration: 791] training loss: 2.506495322843995, validation_loss: 4.262126388757124\n",
      "new best validation loss, saving..\n",
      "epoch: 2, iteration: 989] training loss: 2.4746211514328467, validation_loss: 4.2668999290984635\n",
      "epoch: 3, iteration: 197] training loss: 2.5121523111757607, validation_loss: 4.2761220284130275\n",
      "epoch: 3, iteration: 395] training loss: 2.442089988727762, validation_loss: 4.350811302661896\n",
      "epoch: 3, iteration: 593] training loss: 2.441954090137674, validation_loss: 4.282491427400838\n",
      "epoch: 3, iteration: 791] training loss: 2.5213732033064873, validation_loss: 4.263226947058804\n",
      "epoch: 3, iteration: 989] training loss: 2.5030950488466206, validation_loss: 4.263427295114681\n",
      "epoch: 4, iteration: 197] training loss: 2.433634187838044, validation_loss: 4.30139806607495\n",
      "epoch: 4, iteration: 395] training loss: 2.522833971062092, validation_loss: 4.261553970368011\n",
      "new best validation loss, saving..\n",
      "epoch: 4, iteration: 593] training loss: 2.4986564751827354, validation_loss: 4.2653065155381755\n",
      "epoch: 4, iteration: 791] training loss: 2.5141025703362745, validation_loss: 4.26658088746278\n",
      "epoch: 4, iteration: 989] training loss: 2.509493782062723, validation_loss: 4.2777249631674374\n",
      "epoch: 5, iteration: 197] training loss: 2.47169165960466, validation_loss: 4.264446763888647\n",
      "epoch: 5, iteration: 395] training loss: 2.463094352471708, validation_loss: 4.261251573977264\n",
      "new best validation loss, saving..\n",
      "epoch: 5, iteration: 593] training loss: 2.4520391298062876, validation_loss: 4.2702923132025665\n",
      "epoch: 5, iteration: 791] training loss: 2.5585572882132097, validation_loss: 4.26179916832758\n",
      "epoch: 5, iteration: 989] training loss: 2.4896044472251275, validation_loss: 4.261063464309857\n",
      "new best validation loss, saving..\n",
      "epoch: 6, iteration: 197] training loss: 2.50588807553956, validation_loss: 4.223197978475821\n",
      "new best validation loss, saving..\n",
      "epoch: 6, iteration: 395] training loss: 2.5028008884853787, validation_loss: 4.2244839085185015\n",
      "epoch: 6, iteration: 593] training loss: 2.4952205714553295, validation_loss: 4.225566213545591\n",
      "epoch: 6, iteration: 791] training loss: 2.4759050716053355, validation_loss: 4.2146074707093435\n",
      "new best validation loss, saving..\n",
      "epoch: 6, iteration: 989] training loss: 2.4545916385120816, validation_loss: 4.205903667470684\n",
      "new best validation loss, saving..\n",
      "epoch: 7, iteration: 197] training loss: 2.502744755359611, validation_loss: 4.210819249567779\n",
      "epoch: 7, iteration: 395] training loss: 2.471079773373074, validation_loss: 4.24672245979309\n",
      "epoch: 7, iteration: 593] training loss: 2.5553628513307283, validation_loss: 4.202356935843176\n",
      "new best validation loss, saving..\n",
      "epoch: 7, iteration: 791] training loss: 2.47541041988315, validation_loss: 4.20390201262806\n",
      "epoch: 7, iteration: 989] training loss: 2.4988449107516897, validation_loss: 4.220725953578949\n",
      "epoch: 8, iteration: 197] training loss: 2.4904896978176003, validation_loss: 4.20157244801521\n",
      "new best validation loss, saving..\n",
      "epoch: 8, iteration: 395] training loss: 2.447486313906583, validation_loss: 4.2253709603910865\n",
      "epoch: 8, iteration: 593] training loss: 2.4712484948562854, validation_loss: 4.216950718475424\n",
      "epoch: 8, iteration: 791] training loss: 2.4787643690301913, validation_loss: 4.2064929850723445\n",
      "epoch: 8, iteration: 989] training loss: 2.4761706939851393, validation_loss: 4.200260698795318\n",
      "new best validation loss, saving..\n",
      "epoch: 9, iteration: 197] training loss: 2.4420543812742137, validation_loss: 4.200452461190846\n",
      "epoch: 9, iteration: 395] training loss: 2.4238269389277756, validation_loss: 4.173720953257187\n",
      "new best validation loss, saving..\n",
      "epoch: 9, iteration: 593] training loss: 2.3477654077790002, validation_loss: 4.786877860193669\n",
      "epoch: 9, iteration: 791] training loss: 2.3210290857035702, validation_loss: 4.06324179146601\n",
      "new best validation loss, saving..\n",
      "epoch: 9, iteration: 989] training loss: 2.3898141932005834, validation_loss: 4.062968344792076\n",
      "new best validation loss, saving..\n",
      "epoch: 10, iteration: 197] training loss: 2.3354284823542892, validation_loss: 4.0641381585079674\n",
      "epoch: 10, iteration: 395] training loss: 2.3031292979163354, validation_loss: 4.126535423423936\n",
      "epoch: 10, iteration: 593] training loss: 2.3485167574400854, validation_loss: 4.057635592377704\n",
      "new best validation loss, saving..\n",
      "epoch: 10, iteration: 791] training loss: 2.3120558027065163, validation_loss: 4.168691677891692\n",
      "epoch: 10, iteration: 989] training loss: 2.343945778981604, validation_loss: 4.094045159609419\n",
      "epoch: 11, iteration: 197] training loss: 2.3179091775056087, validation_loss: 4.062478154897688\n",
      "epoch: 11, iteration: 395] training loss: 2.3169563623389813, validation_loss: 4.0823920498723565\n",
      "epoch: 11, iteration: 593] training loss: 2.348136007785797, validation_loss: 4.048944081949151\n",
      "new best validation loss, saving..\n",
      "epoch: 11, iteration: 791] training loss: 2.304881482413321, validation_loss: 4.0933017393817055\n",
      "epoch: 11, iteration: 989] training loss: 2.321006528054825, validation_loss: 4.0788875183333495\n",
      "epoch: 12, iteration: 197] training loss: 2.321584611228018, validation_loss: 4.192394007807193\n",
      "epoch: 12, iteration: 395] training loss: 2.3477808495964667, validation_loss: 4.14693151867908\n",
      "epoch: 12, iteration: 593] training loss: 2.2847353478874823, validation_loss: 4.1613169753033175\n",
      "epoch: 12, iteration: 791] training loss: 2.359800202677948, validation_loss: 4.037373726782591\n",
      "new best validation loss, saving..\n",
      "epoch: 12, iteration: 989] training loss: 2.2882483866479664, validation_loss: 4.0536837163178845\n",
      "epoch: 13, iteration: 197] training loss: 2.285924878987399, validation_loss: 4.040433193030564\n",
      "epoch: 13, iteration: 395] training loss: 2.3453215192062684, validation_loss: 4.028041452169417\n",
      "new best validation loss, saving..\n",
      "epoch: 13, iteration: 593] training loss: 2.321005985592351, validation_loss: 4.062175314063614\n",
      "epoch: 13, iteration: 791] training loss: 2.2978860290363583, validation_loss: 4.029372810021691\n",
      "epoch: 13, iteration: 989] training loss: 2.2719581512489704, validation_loss: 4.018125673998958\n",
      "new best validation loss, saving..\n",
      "epoch: 14, iteration: 197] training loss: 2.328316441088012, validation_loss: 4.0384339094162\n",
      "epoch: 14, iteration: 395] training loss: 2.335954719721669, validation_loss: 4.034142422935237\n",
      "epoch: 14, iteration: 593] training loss: 2.3311530453990206, validation_loss: 4.048851962970648\n",
      "epoch: 14, iteration: 791] training loss: 2.2988230592072614, validation_loss: 4.03577673694362\n",
      "epoch: 14, iteration: 989] training loss: 2.29899174155611, validation_loss: 4.022368462189382\n",
      "epoch: 15, iteration: 197] training loss: 2.3379785514841176, validation_loss: 4.0241751411686755\n",
      "epoch: 15, iteration: 395] training loss: 2.3311447194128325, validation_loss: 4.019187546294669\n",
      "epoch: 15, iteration: 593] training loss: 2.270416669171266, validation_loss: 4.019098402365393\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 15, iteration: 791] training loss: 2.3103434539804555, validation_loss: 4.070637432129489\n",
      "epoch: 15, iteration: 989] training loss: 2.298347909041125, validation_loss: 4.035386019426845\n",
      "epoch: 16, iteration: 197] training loss: 2.284666816393534, validation_loss: 4.027629703283309\n",
      "epoch: 16, iteration: 395] training loss: 2.369631744996466, validation_loss: 4.014045720515045\n",
      "new best validation loss, saving..\n",
      "epoch: 16, iteration: 593] training loss: 2.281357097505319, validation_loss: 4.022340217362282\n",
      "epoch: 16, iteration: 791] training loss: 2.3762808893666123, validation_loss: 4.022471799798632\n",
      "epoch: 16, iteration: 989] training loss: 2.3130472910524618, validation_loss: 4.008514681588049\n",
      "new best validation loss, saving..\n",
      "epoch: 17, iteration: 197] training loss: 2.2833146753937306, validation_loss: 4.019167550232097\n",
      "epoch: 17, iteration: 395] training loss: 2.2829354477651194, validation_loss: 4.0137819621873945\n",
      "epoch: 17, iteration: 593] training loss: 2.26941177519885, validation_loss: 4.028597148864166\n",
      "epoch: 17, iteration: 791] training loss: 2.3107423890720713, validation_loss: 4.019892885633137\n",
      "epoch: 17, iteration: 989] training loss: 2.256362924070069, validation_loss: 5.591919004917144\n",
      "epoch: 18, iteration: 197] training loss: 2.280573779284352, validation_loss: 4.012638180152228\n",
      "epoch: 18, iteration: 395] training loss: 2.3190740160267764, validation_loss: 4.012138572723968\n",
      "epoch: 18, iteration: 593] training loss: 2.3433896730644532, validation_loss: 4.013104326051215\n",
      "epoch: 18, iteration: 791] training loss: 2.329326507419047, validation_loss: 4.025039219337961\n",
      "epoch: 18, iteration: 989] training loss: 2.287612841586874, validation_loss: 4.006826317828633\n",
      "new best validation loss, saving..\n",
      "epoch: 19, iteration: 197] training loss: 2.2914550027461966, validation_loss: 4.007650160271191\n",
      "epoch: 19, iteration: 395] training loss: 2.2989351701254797, validation_loss: 4.0154204135355736\n",
      "epoch: 19, iteration: 593] training loss: 2.2854094047739046, validation_loss: 4.005386977092078\n",
      "new best validation loss, saving..\n",
      "epoch: 19, iteration: 791] training loss: 2.314821116249971, validation_loss: 4.020453633173653\n",
      "epoch: 19, iteration: 989] training loss: 2.337994154053505, validation_loss: 4.005482734545417\n",
      "epoch: 20, iteration: 197] training loss: 2.3281275431315103, validation_loss: 4.0347458150075814\n",
      "epoch: 20, iteration: 395] training loss: 2.3182803482720344, validation_loss: 4.013438518928443\n",
      "epoch: 20, iteration: 593] training loss: 2.244202645138057, validation_loss: 4.015063660300297\n",
      "epoch: 20, iteration: 791] training loss: 2.344843418309183, validation_loss: 4.009570678938989\n",
      "epoch: 20, iteration: 989] training loss: 2.2766432756125323, validation_loss: 4.005213960357335\n",
      "new best validation loss, saving..\n",
      "epoch: 21, iteration: 197] training loss: 2.290585882133908, validation_loss: 4.015854988409124\n",
      "epoch: 21, iteration: 395] training loss: 2.325425624847412, validation_loss: 4.008359026649725\n",
      "epoch: 21, iteration: 593] training loss: 2.303321539753615, validation_loss: 4.0113965959652615\n",
      "epoch: 21, iteration: 791] training loss: 2.3129900206219065, validation_loss: 4.044786454542821\n",
      "epoch: 21, iteration: 989] training loss: 2.316258914542921, validation_loss: 4.011090515748312\n",
      "epoch: 22, iteration: 197] training loss: 2.317160821924306, validation_loss: 4.009215357510941\n",
      "epoch: 22, iteration: 395] training loss: 2.2889003127512306, validation_loss: 4.03755026537439\n",
      "epoch: 22, iteration: 593] training loss: 2.295097798410088, validation_loss: 4.01873230934143\n",
      "epoch: 22, iteration: 791] training loss: 2.28802684160194, validation_loss: 4.006725915100264\n",
      "epoch: 22, iteration: 989] training loss: 2.3076149381772435, validation_loss: 4.067488057457882\n",
      "epoch: 23, iteration: 197] training loss: 2.2917011873890654, validation_loss: 4.160514043725055\n",
      "epoch: 23, iteration: 395] training loss: 2.351570375639983, validation_loss: 4.0065803696279945\n",
      "epoch: 23, iteration: 593] training loss: 2.318661432675641, validation_loss: 4.008193277794382\n",
      "epoch: 23, iteration: 791] training loss: 2.3093430905631096, validation_loss: 4.0309963381808736\n",
      "epoch: 23, iteration: 989] training loss: 2.2393260399500527, validation_loss: 4.025931807963745\n",
      "epoch: 24, iteration: 197] training loss: 2.299475680095981, validation_loss: 4.012383612601656\n",
      "epoch: 24, iteration: 395] training loss: 2.293349665824813, validation_loss: 4.154931632073029\n",
      "epoch: 24, iteration: 593] training loss: 2.3281635888899217, validation_loss: 4.022320782360825\n",
      "epoch: 24, iteration: 791] training loss: 2.3239898157842234, validation_loss: 4.004426028417503\n",
      "new best validation loss, saving..\n",
      "epoch: 24, iteration: 989] training loss: 2.277429836567002, validation_loss: 4.070055011821829\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "net = Net()\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(net.parameters(), lr=1e-2)\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(25):\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",
    "        # print statistics, should add validation loss\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[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": 25,
   "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": 38,
   "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": [
    "import matplotlib.pyplot as plt\n",
    "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": [
    "Well, the loss IS decreasing at least a little bit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import PeptideBuilder\n",
    "test_protein = val_ids_remain[13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_angles_real = val_angles[13]\n",
    "test_angles_pred = validation_preds[13].detach()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1, 3, 431])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_angles_real.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_structure_real = make_pb_structure(val_proteins[test_protein]['primary'], test_angles_real[0, 0, :, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_structure_pred = make_pb_structure(val_proteins[test_protein]['primary'], test_angles_pred[0, 0, :, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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": 34,
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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/pred_real_aligned.png\")\n",
    "display(im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking distribution of angles for the test protein."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.9369)\n",
      "tensor(3.1415)\n"
     ]
    }
   ],
   "source": [
    "print(test_angles_pred.max())\n",
    "print(test_angles_real.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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.numpy().flatten(), bins=n_bins)\n",
    "axs[1].hist(test_angles_pred.numpy().flatten(), bins=n_bins)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They're being squished too much inside a narrow interval."
   ]
  }
 ],
 "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
}