protein-DNA_binding_prediction_protein_sequence.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Import modules\n",
    "\n",
    "from __future__ import print_function\n",
    "import numpy as np\n",
    "import math\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from six.moves import cPickle as pickle\n",
    "from six.moves import range\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Load training and test file\n",
    "flank_len = 9\n",
    "\n",
    "train_file = 'train_f' + str(flank_len) + '.pickle'\n",
    "\n",
    "with open(train_file, 'rb') as train:\n",
    "    save = pickle.load(train)\n",
    "    dataset = save['seq']  # data type : numpy.ndarray // 'list' can't be dealt with 'shape' and 'reshape' \n",
    "    labels = save['label']\n",
    "\n",
    "    del save\n",
    "\n",
    "test_file = 'test_f' + str(flank_len) + '.pickle'\n",
    "\n",
    "with open(test_file, 'rb') as test:\n",
    "    save = pickle.load(test)\n",
    "    test_dataset = save['seq']\n",
    "  \n",
    "    del save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training set (58148, 119, 4) (58148, 2)\n",
      "validation set (19383, 119, 4) (19383, 2)\n",
      "test set (19383, 119, 4)\n"
     ]
    }
   ],
   "source": [
    "# Determine how many folds\n",
    "fold = 4\n",
    "num = int(dataset.shape[0])\n",
    "        \n",
    "# Split data into several parts\n",
    "dataset_array = np.split(dataset, np.arange(int(np.ceil(num/fold)), num, int(np.ceil(num/fold))), axis = 0)\n",
    "labels_array = np.split(labels, np.arange(int(np.ceil(num/fold)), num, int(np.ceil(num/fold))), axis = 0)\n",
    "\n",
    "train_dataset = np.empty([1, 101+(2*flank_len), 4])\n",
    "train_labels = np.empty([1,2])\n",
    "for i in range(0, fold):\n",
    "    if i == 0:  # (i+1)th partition\n",
    "        valid_dataset = dataset_array[i]\n",
    "        valid_labels = labels_array[i]\n",
    "    else:\n",
    "        train_dataset = np.concatenate((train_dataset, dataset_array[i]), axis = 0)\n",
    "        train_labels = np.concatenate((train_labels, labels_array[i]), axis = 0)\n",
    "train_dataset = np.delete(train_dataset,0,0)\n",
    "train_labels = np.delete(train_labels,0,0)\n",
    "print('training set', train_dataset.shape, train_labels.shape)\n",
    "print('validation set', valid_dataset.shape, valid_labels.shape)\n",
    "print('test set', test_dataset.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set (58148, 119, 4, 1) (58148, 2)\n",
      "Validation set (19383, 119, 4, 1) (19383, 2)\n",
      "Test set (19383, 119, 4, 1)\n"
     ]
    }
   ],
   "source": [
    "dataset_row = train_dataset.shape[1]\n",
    "dataset_column = train_dataset.shape[2]\n",
    "num_channels = 1\n",
    "\n",
    "def reformat(dataset, labels):\n",
    "    dataset = dataset.reshape(\n",
    "        (-1, dataset_row, dataset_column, num_channels)).astype(np.float32)\n",
    "    return dataset, labels\n",
    "def test_reformat(dataset):\n",
    "    dataset = dataset.reshape(\n",
    "        (-1, dataset_row, dataset_column, num_channels)).astype(np.float32)\n",
    "    return dataset\n",
    "\n",
    "train_dataset, train_labels = reformat(train_dataset, train_labels)\n",
    "valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)\n",
    "test_dataset = test_reformat(test_dataset)\n",
    "print('Training set', train_dataset.shape, train_labels.shape)\n",
    "print('Validation set', valid_dataset.shape, valid_labels.shape)\n",
    "print('Test set', test_dataset.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "num_labels = 2\n",
    "batch_size = train_dataset.shape[0] // 200\n",
    "depth = 16\n",
    "num_hidden = 128\n",
    "num_hidden2 = 64\n",
    "beta_regul = 8e-5\n",
    "stride_1 = 2\n",
    "stride_2 = 2\n",
    "\n",
    "graph = tf.Graph()\n",
    "\n",
    "with graph.as_default():\n",
    "\n",
    "    # Input data.\n",
    "    tf_train_dataset = tf.placeholder(\n",
    "        tf.float32, shape=(batch_size, dataset_row, dataset_column, num_channels))\n",
    "    tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))\n",
    "    tf_valid_dataset = tf.constant(valid_dataset)\n",
    "    tf_test_dataset = tf.constant(test_dataset)\n",
    "\n",
    "    # Variables.\n",
    "    layer1_weights = tf.Variable(tf.truncated_normal(\n",
    "        [21, 4, num_channels, depth], stddev=0.1))\n",
    "    layer1_biases = tf.Variable(tf.zeros([depth]))\n",
    "    layer2_weights = tf.Variable(tf.truncated_normal(\n",
    "        [9, 2, depth, depth], stddev=0.1))\n",
    "    layer2_biases = tf.Variable(tf.constant(1.0, shape=[depth]))\n",
    "    layer3_weights = tf.Variable(tf.truncated_normal(\n",
    "        [math.ceil(math.ceil(train_dataset.shape[1]/stride_1)/stride_1)*depth, num_hidden], stddev=0.1))\n",
    "    layer3_biases = tf.Variable(tf.constant(1.0, shape=[num_hidden]))\n",
    "    layer4_weights = tf.Variable(tf.truncated_normal(\n",
    "        [num_hidden, num_hidden2], stddev=0.1))\n",
    "    layer4_biases = tf.Variable(tf.constant(1.0, shape=[num_hidden2]))\n",
    "    layer5_weights = tf.Variable(tf.truncated_normal(\n",
    "        [num_hidden2, num_labels], stddev=0.1))\n",
    "    layer5_biases = tf.Variable(tf.constant(1.0, shape=[num_labels]))\n",
    "\n",
    "  # Model.\n",
    "    def model_train(data):\n",
    "        conv = tf.nn.conv2d(data, layer1_weights, [1, stride_1, stride_1, 1], padding='SAME')\n",
    "        hidden = tf.nn.relu(conv + layer1_biases)\n",
    "        drop = tf.nn.dropout(hidden, 0.75)\n",
    "        conv = tf.nn.conv2d(drop, layer2_weights, [1, stride_2, stride_2, 1], padding='SAME')\n",
    "        hidden = tf.nn.relu(conv + layer2_biases)\n",
    "        drop = tf.nn.dropout(hidden, 0.75)\n",
    "        shape = hidden.get_shape().as_list()\n",
    "        reshape = tf.reshape(hidden, [shape[0], shape[1] * shape[2] * shape[3]])\n",
    "        hidden = tf.nn.relu(tf.matmul(reshape, layer3_weights) + layer3_biases)\n",
    "        drop = tf.nn.dropout(hidden, 0.75)\n",
    "        hidden = tf.nn.relu(tf.matmul(drop, layer4_weights) + layer4_biases)\n",
    "        return tf.matmul(hidden, layer5_weights) + layer5_biases\n",
    "\n",
    "    def model(data):\n",
    "        conv = tf.nn.conv2d(data, layer1_weights, [1, stride_1, stride_1, 1], padding='SAME')\n",
    "        hidden = tf.nn.relu(conv + layer1_biases)\n",
    "        conv = tf.nn.conv2d(hidden, layer2_weights, [1, stride_2, stride_2, 1], padding='SAME')\n",
    "        hidden = tf.nn.relu(conv + layer2_biases)\n",
    "        shape = hidden.get_shape().as_list()\n",
    "        reshape = tf.reshape(hidden, [shape[0], shape[1] * shape[2] * shape[3]])\n",
    "        hidden = tf.nn.relu(tf.matmul(reshape, layer3_weights) + layer3_biases)\n",
    "        hidden = tf.nn.relu(tf.matmul(hidden, layer4_weights) + layer4_biases)\n",
    "        return tf.matmul(hidden, layer5_weights) + layer5_biases\n",
    "\n",
    "  # Training computation.\n",
    "    logits = model_train(tf_train_dataset)\n",
    "    loss = tf.reduce_mean(\n",
    "        tf.nn.sigmoid_cross_entropy_with_logits(logits, tf_train_labels) + \\\n",
    "        beta_regul *(\n",
    "            1 * tf.nn.l2_loss(layer1_weights) + \\\n",
    "            1 * tf.nn.l2_loss(layer2_weights) + \\\n",
    "            1 * tf.nn.l2_loss(layer3_weights) + \\\n",
    "            1 * tf.nn.l2_loss(layer4_weights) + \\\n",
    "            1 * tf.nn.l2_loss(layer5_weights)))\n",
    "     \n",
    "  # Optimizer.\n",
    "    global_step = tf.Variable(0)\n",
    "    learning_rate = tf.train.exponential_decay(0.25, global_step, 5000, 0.96)\n",
    "    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)\n",
    "  \n",
    "    # Predictions for the training, validation, and test data.\n",
    "    train_prediction = tf.sigmoid(logits)\n",
    "    valid_prediction = tf.sigmoid(model(tf_valid_dataset))\n",
    "    test_prediction = tf.sigmoid(model(tf_test_dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t minibatch\t minibatch\t validation\n",
      "Steps\t loss     \t accuracy \t accuracy\n",
      "---------------------------------------------------\n",
      "0\t 1.036431\t 52.759 %\t 50.663 %\t\n",
      "500\t 0.683988\t 62.069 %\t 60.486 %\t\n",
      "1000\t 0.624465\t 65.862 %\t 71.129 %\t\n",
      "1500\t 0.633703\t 68.276 %\t 78.105 %\t\n",
      "2000\t 0.470493\t 78.621 %\t 84.543 %\t\n",
      "2500\t 0.467052\t 81.724 %\t 80.426 %\t\n",
      "3000\t 0.340815\t 85.517 %\t 87.535 %\t\n",
      "3500\t 0.343168\t 87.241 %\t 88.155 %\t\n",
      "4000\t 0.281665\t 90.000 %\t 88.222 %\t\n",
      "4500\t 0.316459\t 89.310 %\t 89.223 %\t\n",
      "5000\t 0.306602\t 88.621 %\t 89.651 %\t\n",
      "5500\t 0.323350\t 85.517 %\t 89.656 %\t\n",
      "6000\t 0.370277\t 84.828 %\t 88.278 %\t\n",
      "6500\t 0.326758\t 86.897 %\t 89.764 %\t\n",
      "7000\t 0.319943\t 87.586 %\t 90.069 %\t\n",
      "7500\t 0.260177\t 90.345 %\t 90.058 %\t\n",
      "8000\t 0.330911\t 87.931 %\t 89.795 %\t\n",
      "8500\t 0.266430\t 91.034 %\t 90.378 %\t\n",
      "9000\t 0.265763\t 90.000 %\t 90.528 %\t\n",
      "9500\t 0.285275\t 91.724 %\t 90.358 %\t\n",
      "10000\t 0.260739\t 90.690 %\t 90.487 %\t\n",
      "10500\t 0.273746\t 89.655 %\t 89.919 %\t\n",
      "11000\t 0.281265\t 91.034 %\t 90.590 %\t\n",
      "11500\t 0.278727\t 91.034 %\t 90.512 %\t\n",
      "12000\t 0.310407\t 88.621 %\t 90.595 %\t\n",
      "12500\t 0.282559\t 87.586 %\t 90.523 %\t\n",
      "13000\t 0.295398\t 89.310 %\t 90.812 %\t\n",
      "13500\t 0.254486\t 90.000 %\t 90.636 %\t\n",
      "14000\t 0.266505\t 89.655 %\t 90.672 %\t\n",
      "14500\t 0.257149\t 90.690 %\t 90.579 %\t\n",
      "15000\t 0.259550\t 88.966 %\t 90.559 %\t\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfoAAAEPCAYAAACqSgbjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6f8010e128>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test accuracy : 90.517 %\n"
     ]
    }
   ],
   "source": [
    "num_steps = 15001\n",
    "interval = 100\n",
    "y = []\n",
    "z = []\n",
    "\n",
    "def accuracy(predictions, labels):\n",
    "    return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])\n",
    "\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "\n",
    "with tf.Session(graph=graph, config=config) as session:\n",
    "    tf.initialize_all_variables().run()\n",
    "    print('\\t', 'minibatch\\t', 'minibatch\\t', 'validation')\n",
    "    print('Steps\\t', 'loss     \\t', 'accuracy \\t', 'accuracy')\n",
    "    print('---------------------------------------------------')\n",
    "    for step in range(num_steps):\n",
    "        offset = (step * batch_size) % (train_labels.shape[0] - batch_size)\n",
    "        batch_data = train_dataset[offset:(offset + batch_size), :, :, :]\n",
    "        batch_labels = train_labels[offset:(offset + batch_size), :]\n",
    "        feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels}\n",
    "        _, l, predictions = session.run(\n",
    "            [optimizer, loss, train_prediction], feed_dict=feed_dict)\n",
    "        if (step % 500 == 0):\n",
    "            print('%d\\t %f\\t %.3f %%\\t %.3f %%\\t' % (\n",
    "                step,\n",
    "                l,\n",
    "                accuracy(predictions, batch_labels),\n",
    "                accuracy(valid_prediction.eval(), valid_labels)\n",
    "                ))\n",
    "        if (step % interval == 0):\n",
    "            y.append(accuracy(predictions, batch_labels))\n",
    "            z.append(accuracy(valid_prediction.eval(), valid_labels))\n",
    "    \n",
    "    x = np.arange(0, num_steps, interval)\n",
    "    plt.plot(x, y, 'r', label='train')\n",
    "    plt.plot(x, z, 'b', label='validation')\n",
    "    plt.xlabel(\"step\")\n",
    "    plt.ylabel(\"accuracy (%)\")\n",
    "    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0)\n",
    "    plt.show()\n",
    "    \n",
    "    # Prediction\n",
    "\n",
    "    with open('test_ans.data.txt', 'r') as f:\n",
    "        i = 0\n",
    "        count = 0\n",
    "        result = np.argmax(test_prediction.eval(), 1)\n",
    "        for line in f:\n",
    "            ans = line.split(\" \")[-1].split(\"\\n\")[0]\n",
    "            if result[i] == int(ans):\n",
    "                count += 1\n",
    "            i += 1\n",
    "    print(\"test accuracy : %.3f %%\"%(100*count/len(result)))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [tensorflow]",
   "language": "python",
   "name": "Python [tensorflow]"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}