NN_homebrew.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Trains neural network using GSE63990_series_matrix.txt and homebrew code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importing Jupyter notebook from data_cleaner.ipynb\n",
      "importing data_cleaner modules...\n",
      "done\n",
      "importing Jupyter notebook from MLP_Clean.ipynb\n",
      "importing Jupyter notebook from gene_selection.ipynb\n"
     ]
    }
   ],
   "source": [
    "#imports all needed modules \n",
    "import NotebookFinder\n",
    "import data_cleaner as dclean\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import MLP_Clean as NN\n",
    "import gene_selection as gs\n",
    "\n",
    "#import feature selection modules\n",
    "import sklearn.feature_selection \n",
    "\n",
    "\n",
    "#lets try mnist\n",
    "\n",
    "from sklearn.datasets import fetch_openml\n",
    "from sklearn.utils import check_random_state\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import LabelEncoder, OneHotEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reading file...\n",
      "Dropping Series_title\n",
      "Dropping Series_geo_accession\n",
      "Dropping Series_status\n",
      "Dropping Series_submission_date\n",
      "Dropping Series_last_update_date\n",
      "Dropping Series_pubmed_id\n",
      "Dropping Series_summary\n",
      "Dropping Series_overall_design\n",
      "Dropping Series_type\n",
      "Dropping Series_contributor\n",
      "Dropping Series_sample_id\n",
      "Dropping Series_contact_name\n",
      "Dropping Series_contact_email\n",
      "Dropping Series_contact_department\n",
      "Dropping Series_contact_institute\n",
      "Dropping Series_contact_address\n",
      "Dropping Series_contact_city\n",
      "Dropping Series_contact_state\n",
      "Dropping Series_contact_zip/postal_code\n",
      "Dropping Series_contact_country\n",
      "Dropping Series_supplementary_file\n",
      "Dropping Series_platform_id\n",
      "Dropping Series_platform_taxid\n",
      "Dropping Series_sample_taxid\n",
      "Dropping Series_relation\n",
      "Converting Sample_characteristics_ch1\n"
     ]
    }
   ],
   "source": [
    "#data organization/reformatting of GSE63990_series_matrix.txt \n",
    "\n",
    "#returns characteristics = X\n",
    "        #expression = Y\n",
    "        # 'non-infectious illness': 0, 'bacterial': 1, 'viral': 2\n",
    "\n",
    "#call on data_cleaner to open and formate GSE63990_series_matrix\n",
    "data = dclean.clean_GSE_series_matrix('GSE63990_series_matrix.txt')\n",
    "# X_train, Y_train, X_test, Y_test = gs.select(data, 10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def round_param(parameters):\n",
    "    #rounding to nearest integer doesn't work\n",
    "    #round to 1 decimal place does work\n",
    "    W1=np.round(parameters['W1'],1)\n",
    "    W2=np.round(parameters['W2'],1)\n",
    "    b1=np.round(parameters['b1'],1)\n",
    "    b2=np.round(parameters['b2'],1)   \n",
    "    \n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2}\n",
    "    \n",
    "    return(parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#mnist test to make sure my model isn't trash \n",
    "#spoiler it's not\n",
    "def MNIST_get(train_size, test_size):\n",
    "    train_samples = train_size\n",
    "\n",
    "    X, y = fetch_openml('mnist_784', version=1, return_X_y=True)\n",
    "\n",
    "    random_state = check_random_state(0)\n",
    "    permutation = random_state.permutation(X.shape[0])\n",
    "    X = X[permutation]\n",
    "    y = y[permutation]\n",
    "    X = X.reshape((X.shape[0], -1))\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y, train_size=train_samples, test_size=test_size)\n",
    "    scaler = StandardScaler()\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "\n",
    "    #transpose since shape is wrong\n",
    "    X_train, X_test, Y_train, Y_test = X_train.T, X_test.T, y_train.T, y_test.T\n",
    "\n",
    "    #onehotencode the Y for mnist\n",
    "    ohe = OneHotEncoder()\n",
    "\n",
    "    Y_train = Y_train.reshape(-1, 1)\n",
    "    Y_train = ohe.fit_transform(Y_train).toarray()\n",
    "\n",
    "    Y_test= Y_test.reshape(-1, 1)\n",
    "    Y_test = ohe.fit_transform(Y_test).toarray()\n",
    "    \n",
    "    return X_train, Y_train, X_test, Y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "with 2 gene(s)\n",
      "Accuracy for 4 hidden units: 65.87301587301587 / 75.0 %\n",
      "with 2 gene(s)\n",
      "Accuracy for 6 hidden units: 66.26984126984127 / 75.0 %\n",
      "with 2 gene(s)\n",
      "Accuracy for 8 hidden units: 68.65079365079364 / 71.42857142857143 %\n",
      "with 2 gene(s)\n",
      "Accuracy for 9 hidden units: 67.46031746031747 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "with 3 gene(s)\n",
      "Accuracy for 6 hidden units: 66.66666666666666 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "with 4 gene(s)\n",
      "Accuracy for 1 hidden units: 56.74603174603175 / 71.42857142857143 %\n",
      "with 4 gene(s)\n",
      "Accuracy for 3 hidden units: 67.06349206349206 / 71.42857142857143 %\n",
      "with 4 gene(s)\n",
      "Accuracy for 6 hidden units: 66.26984126984127 / 71.42857142857143 %\n",
      "with 4 gene(s)\n",
      "Accuracy for 7 hidden units: 67.46031746031747 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "with 5 gene(s)\n",
      "Accuracy for 2 hidden units: 70.23809523809523 / 75.0 %\n",
      "with 5 gene(s)\n",
      "Accuracy for 3 hidden units: 69.44444444444444 / 71.42857142857143 %\n",
      "with 5 gene(s)\n",
      "Accuracy for 5 hidden units: 65.87301587301587 / 71.42857142857143 %\n",
      "with 5 gene(s)\n",
      "Accuracy for 7 hidden units: 67.85714285714286 / 71.42857142857143 %\n",
      "with 5 gene(s)\n",
      "Accuracy for 8 hidden units: 71.03174603174604 / 75.0 %\n",
      "with 5 gene(s)\n",
      "Accuracy for 9 hidden units: 70.23809523809523 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "with 6 gene(s)\n",
      "Accuracy for 4 hidden units: 70.63492063492063 / 71.42857142857143 %\n",
      "with 6 gene(s)\n",
      "Accuracy for 7 hidden units: 70.63492063492063 / 67.85714285714286 %\n",
      "with 6 gene(s)\n",
      "Accuracy for 8 hidden units: 64.68253968253968 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "with 7 gene(s)\n",
      "Accuracy for 3 hidden units: 68.65079365079364 / 71.42857142857143 %\n",
      "with 7 gene(s)\n",
      "Accuracy for 5 hidden units: 69.44444444444444 / 75.0 %\n",
      "with 7 gene(s)\n",
      "Accuracy for 6 hidden units: 67.46031746031747 / 71.42857142857143 %\n",
      "with 7 gene(s)\n",
      "Accuracy for 7 hidden units: 68.25396825396825 / 71.42857142857143 %\n",
      "with 7 gene(s)\n",
      "Accuracy for 9 hidden units: 71.03174603174604 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "with 8 gene(s)\n",
      "Accuracy for 5 hidden units: 69.84126984126983 / 71.42857142857143 %\n",
      "with 8 gene(s)\n",
      "Accuracy for 6 hidden units: 69.44444444444444 / 71.42857142857143 %\n",
      "with 8 gene(s)\n",
      "Accuracy for 8 hidden units: 70.63492063492063 / 67.85714285714286 %\n",
      "with 8 gene(s)\n",
      "Accuracy for 9 hidden units: 67.85714285714286 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "with 9 gene(s)\n",
      "Accuracy for 4 hidden units: 67.06349206349206 / 75.0 %\n",
      "with 9 gene(s)\n",
      "Accuracy for 5 hidden units: 69.04761904761905 / 75.0 %\n",
      "with 9 gene(s)\n",
      "Accuracy for 7 hidden units: 70.63492063492063 / 71.42857142857143 %\n",
      "with 9 gene(s)\n",
      "Accuracy for 9 hidden units: 67.06349206349206 / 75.0 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "with 10 gene(s)\n",
      "Accuracy for 1 hidden units: 68.25396825396825 / 71.42857142857143 %\n",
      "with 10 gene(s)\n",
      "Accuracy for 3 hidden units: 68.25396825396825 / 71.42857142857143 %\n",
      "with 10 gene(s)\n",
      "Accuracy for 5 hidden units: 68.25396825396825 / 71.42857142857143 %\n",
      "with 10 gene(s)\n",
      "Accuracy for 6 hidden units: 68.25396825396825 / 71.42857142857143 %\n",
      "with 10 gene(s)\n",
      "Accuracy for 7 hidden units: 70.23809523809523 / 71.42857142857143 %\n",
      "with 10 gene(s)\n",
      "Accuracy for 8 hidden units: 71.82539682539682 / 67.85714285714286 %\n",
      "with 10 gene(s)\n",
      "Accuracy for 9 hidden units: 69.04761904761905 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "with 11 gene(s)\n",
      "Accuracy for 2 hidden units: 68.65079365079364 / 75.0 %\n",
      "with 11 gene(s)\n",
      "Accuracy for 3 hidden units: 70.23809523809523 / 75.0 %\n",
      "with 11 gene(s)\n",
      "Accuracy for 7 hidden units: 71.03174603174604 / 71.42857142857143 %\n",
      "with 11 gene(s)\n",
      "Accuracy for 8 hidden units: 62.301587301587304 / 75.0 %\n",
      "with 11 gene(s)\n",
      "Accuracy for 9 hidden units: 68.65079365079364 / 75.0 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "with 12 gene(s)\n",
      "Accuracy for 6 hidden units: 69.44444444444444 / 75.0 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "with 13 gene(s)\n",
      "Accuracy for 7 hidden units: 63.49206349206349 / 78.57142857142857 %\n",
      "with 13 gene(s)\n",
      "Accuracy for 9 hidden units: 70.23809523809523 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "with 14 gene(s)\n",
      "Accuracy for 2 hidden units: 69.04761904761905 / 71.42857142857143 %\n",
      "with 14 gene(s)\n",
      "Accuracy for 7 hidden units: 71.82539682539682 / 78.57142857142857 %\n",
      "with 14 gene(s)\n",
      "Accuracy for 8 hidden units: 69.04761904761905 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "16040              216671_x_at\"  31.861675\n",
      "with 15 gene(s)\n",
      "Accuracy for 3 hidden units: 68.25396825396825 / 71.42857142857143 %\n",
      "with 15 gene(s)\n",
      "Accuracy for 6 hidden units: 70.63492063492063 / 71.42857142857143 %\n",
      "with 15 gene(s)\n",
      "Accuracy for 8 hidden units: 68.25396825396825 / 75.0 %\n",
      "with 15 gene(s)\n",
      "Accuracy for 9 hidden units: 72.22222222222221 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "16040              216671_x_at\"  31.861675\n",
      "9445                 209960_at\"  28.876673\n",
      "with 16 gene(s)\n",
      "Accuracy for 1 hidden units: 70.23809523809523 / 67.85714285714286 %\n",
      "with 16 gene(s)\n",
      "Accuracy for 2 hidden units: 70.23809523809523 / 67.85714285714286 %\n",
      "with 16 gene(s)\n",
      "Accuracy for 4 hidden units: 70.23809523809523 / 67.85714285714286 %\n",
      "with 16 gene(s)\n",
      "Accuracy for 5 hidden units: 66.66666666666666 / 71.42857142857143 %\n",
      "with 16 gene(s)\n",
      "Accuracy for 7 hidden units: 69.84126984126983 / 71.42857142857143 %\n",
      "with 16 gene(s)\n",
      "Accuracy for 8 hidden units: 71.82539682539682 / 71.42857142857143 %\n",
      "with 16 gene(s)\n",
      "Accuracy for 9 hidden units: 71.03174603174604 / 71.42857142857143 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "16040              216671_x_at\"  31.861675\n",
      "9445                 209960_at\"  28.876673\n",
      "16806                217442_at\"  28.460255\n",
      "with 17 gene(s)\n",
      "Accuracy for 2 hidden units: 70.23809523809523 / 67.85714285714286 %\n",
      "with 17 gene(s)\n",
      "Accuracy for 3 hidden units: 69.04761904761905 / 75.0 %\n",
      "with 17 gene(s)\n",
      "Accuracy for 8 hidden units: 72.61904761904762 / 75.0 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "16040              216671_x_at\"  31.861675\n",
      "9445                 209960_at\"  28.876673\n",
      "16806                217442_at\"  28.460255\n",
      "2680                 203153_at\"  27.864647\n",
      "with 18 gene(s)\n",
      "Accuracy for 7 hidden units: 68.65079365079364 / 75.0 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "16040              216671_x_at\"  31.861675\n",
      "9445                 209960_at\"  28.876673\n",
      "16806                217442_at\"  28.460255\n",
      "2680                 203153_at\"  27.864647\n",
      "5975                 206450_at\"  27.230384\n",
      "with 19 gene(s)\n",
      "Accuracy for 8 hidden units: 70.23809523809523 / 78.57142857142857 %\n"
     ]
    }
   ],
   "source": [
    "#find the best models with rounding\n",
    "hidden_layer_sizes = np.arange(1,10)\n",
    "gene_list = np.arange(1,20)\n",
    "for gene_number in gene_list:\n",
    "    X_train, Y_train, X_test, Y_test = gs.select(data, gene_number)\n",
    "    #lets log2 this\n",
    "    X_train = np.log2(X_train)\n",
    "    X_test = np.log2(X_test)\n",
    "    for n_h in hidden_layer_sizes:\n",
    "        parameters = NN.nn_model(X_train, Y_train, n_h, num_iterations =10000, seed=42)\n",
    "        #round the weights after training\n",
    "        parameters = round_param(parameters)\n",
    "        test_predictions = NN.predict(parameters, X_test)\n",
    "        test_labels = np.argmax(Y_test, axis = 0)\n",
    "        test_t = (test_labels-test_predictions)\n",
    "        test_accuracy = np.sum(np.where(test_t == 0, 1, 0))/Y_test.shape[1]*100\n",
    "        train_predictions = NN.predict(parameters, X_train)\n",
    "        train_labels = np.argmax(Y_train, axis = 0)\n",
    "        train_t = (train_labels-train_predictions)\n",
    "        train_accuracy = np.sum(np.where(train_t == 0, 1, 0))/Y_train.shape[1]*100\n",
    "        if test_accuracy > 70 or train_accuracy > 70:\n",
    "            print (\"with {} gene(s)\".format(gene_number))\n",
    "            print (\"Accuracy for {} hidden units: {} / {} %\".format(n_h, train_accuracy, test_accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "16040              216671_x_at\"  31.861675\n",
      "9445                 209960_at\"  28.876673\n",
      "16806                217442_at\"  28.460255\n",
      "2680                 203153_at\"  27.864647\n",
      "5975                 206450_at\"  27.230384\n",
      "Cost after iteration 0: 279.409897\n",
      "Cost after iteration 1000: 204.469750\n",
      "Cost after iteration 2000: 194.210618\n",
      "Cost after iteration 3000: 191.284108\n",
      "Cost after iteration 4000: 188.777271\n",
      "Cost after iteration 5000: 187.466016\n",
      "train accuracy: 71.82539682539682 %\n",
      "test accuracy: 78.57142857142857 %\n"
     ]
    }
   ],
   "source": [
    "# try select models with rounding\n",
    "randomseed = 42\n",
    "number_hidden = 8\n",
    "gene_number = 19\n",
    "\n",
    "# X_train, Y_train, X_test, Y_test = MNIST_get(5000,10000)\n",
    "X_train, Y_train, X_test, Y_test = gs.select(data, gene_number)\n",
    "#lets log2 this\n",
    "X_train = np.log2(X_train)\n",
    "X_test = np.log2(X_test)\n",
    "parameters = NN.nn_model(X_train, Y_train, n_h = number_hidden, num_iterations = 6000, print_cost=True, seed=randomseed)\n",
    "parameters = round_param(parameters)\n",
    "predictions = NN.predict(parameters, X_train)\n",
    "labels = np.argmax(Y_train, axis = 0)\n",
    "t = (labels-predictions)      \n",
    "accuracy = np.sum(np.where(t == 0, 1, 0))/Y_train.shape[1]*100\n",
    "print('train accuracy:', accuracy,'%')\n",
    "predictions = NN.predict(parameters, X_test)\n",
    "labels = np.argmax(Y_test, axis = 0)\n",
    "t = (labels-predictions)      \n",
    "accuracy = np.sum(np.where(t == 0, 1, 0))/Y_test.shape[1]*100\n",
    "print('test accuracy:', accuracy,'%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ray/.local/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Gene      Score\n",
      "22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
      "6852                 207329_at\"  51.908816\n",
      "21443              222084_s_at\"  45.796933\n",
      "12152              212768_s_at\"  45.511495\n",
      "10952              211548_s_at\"  39.885743\n",
      "3439               203913_s_at\"  39.213689\n",
      "19338              219975_x_at\"  38.786768\n",
      "9477                 209992_at\"  36.792002\n",
      "5370                 205844_at\"  36.757702\n",
      "5702               206177_s_at\"  35.538623\n",
      "19032                219669_at\"  35.401498\n",
      "3440               203914_x_at\"  35.133532\n",
      "8786               209293_x_at\"  34.937390\n",
      "22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
      "16040              216671_x_at\"  31.861675\n",
      "9445                 209960_at\"  28.876673\n",
      "16806                217442_at\"  28.460255\n",
      "2680                 203153_at\"  27.864647\n",
      "5975                 206450_at\"  27.230384\n",
      "train accuracy: 72.61904761904762 %\n",
      "test accuracy: 71.42857142857143 %\n"
     ]
    }
   ],
   "source": [
    "#try with other random splits of the dataset\n",
    "X_train, Y_train, X_test, Y_test = gs.select(data, gene_number, seed=100)\n",
    "#lets log2 this\n",
    "X_train = np.log2(X_train)\n",
    "X_test = np.log2(X_test)\n",
    "predictions = NN.predict(parameters, X_train)\n",
    "labels = np.argmax(Y_train, axis = 0)\n",
    "t = (labels-predictions)      \n",
    "accuracy = np.sum(np.where(t == 0, 1, 0))/Y_train.shape[1]*100\n",
    "print('train accuracy:', accuracy,'%')\n",
    "predictions = NN.predict(parameters, X_test)\n",
    "labels = np.argmax(Y_test, axis = 0)\n",
    "t = (labels-predictions)      \n",
    "accuracy = np.sum(np.where(t == 0, 1, 0))/Y_test.shape[1]*100\n",
    "print('test accuracy:', accuracy,'%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gene      Score\n",
    "# 22239  AFFX-HUMRGE/M10098_5_at\"  62.413376\n",
    "# 6852                 207329_at\"  51.908816\n",
    "# 21443              222084_s_at\"  45.796933\n",
    "# 12152              212768_s_at\"  45.511495\n",
    "# 10952              211548_s_at\"  39.885743\n",
    "# 3439               203913_s_at\"  39.213689\n",
    "# 19338              219975_x_at\"  38.786768\n",
    "# 9477                 209992_at\"  36.792002\n",
    "# 5370                 205844_at\"  36.757702\n",
    "# 5702               206177_s_at\"  35.538623\n",
    "# 19032                219669_at\"  35.401498\n",
    "# 3440               203914_x_at\"  35.133532\n",
    "# 8786               209293_x_at\"  34.937390\n",
    "# 22240  AFFX-HUMRGE/M10098_M_at\"  34.897467\n",
    "# 16040              216671_x_at\"  31.861675\n",
    "# 9445                 209960_at\"  28.876673\n",
    "# 16806                217442_at\"  28.460255\n",
    "# 2680                 203153_at\"  27.864647\n",
    "# 5975                 206450_at\"  27.230384"
   ]
  }
 ],
 "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
}