Untitled1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/cnmc/anaconda3/lib/python2.7/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from skimage.util.shape import view_as_windows\n",
    "import numpy as np\n",
    "import os, sys, shutil\n",
    "import scipy.ndimage as snd\n",
    "import h5py\n",
    "import SimpleITK as sitk\n",
    "from shutil import copy\n",
    "import nibabel as nib\n",
    "import skimage.morphology as morph\n",
    "from skimage.feature import canny\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "%matplotlib inline\n",
    "\n",
    "data = pd.read_csv(\"./loaders/train_test_split.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(16,)\n"
     ]
    }
   ],
   "source": [
    "window_shape=(4,4)\n",
    "feature=[]\n",
    "target=[]\n",
    "for train_data in data[data['Training']==True]['Slice Path']:\n",
    "    with h5py.File(train_data,'r') as hdf:\n",
    "        image = np.squeeze(np.array(hdf.get('image')))\n",
    "        mask = np.squeeze(np.array(hdf.get('weight_map')))\n",
    "        B = view_as_windows(image, window_shape)\n",
    "        for b in B:\n",
    "            for b_ in b:\n",
    "                feature.append(b_.flatten())\n",
    "        M = view_as_windows(mask, window_shape)\n",
    "        for m in M:\n",
    "            for m_ in m:\n",
    "                if np.sum(m_[:,:]) > 0:\n",
    "                    target.append(1)\n",
    "                else:\n",
    "                    target.append(0)\n",
    "feature=np.array(feature)\n",
    "target=np.array(target)\n",
    "\n",
    "print(feature[0].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(feature, columns=list('ABCDEFGHIJKLMNOP'))\n",
    "df['target']=target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "neigh = KNeighborsClassifier(n_neighbors=5)\n",
    "\n",
    "neigh.fit(df.iloc[:,:16],df.iloc[:,16])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_feature=[]\n",
    "for train_data in data[data['Testing']==True]['Slice Path'][:1]:\n",
    "    with h5py.File(train_data,'r') as hdf:\n",
    "        image = np.squeeze(np.array(hdf.get('image')))\n",
    "        B = view_as_windows(image, window_shape)\n",
    "        for b in B:\n",
    "            for b_ in b:\n",
    "                test_feature.append(b_.flatten())\n",
    "df_test = pd.DataFrame(test_feature, columns=list('ABCDEFGHIJKLMNOP'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1c8a9d7f90>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1067daa10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "res=neigh.predict(df_test.iloc[:,:16])\n",
    "plt.plot(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1d383f5f10>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1c8bdeb190>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(res.reshape(253,253))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_feature=[]\n",
    "for train_data in data[data['Testing']==True]['Slice Path'][:5]:\n",
    "    with h5py.File(train_data,'r') as hdf:\n",
    "        image = np.squeeze(np.array(hdf.get('image')))\n",
    "        B = view_as_windows(image, window_shape)\n",
    "        for b in B:\n",
    "            for b_ in b:\n",
    "                test_feature.append(b_.flatten())\n",
    "df_test = pd.DataFrame(test_feature, columns=list('ABCDEFGHIJKLMNOP'))\n",
    "res=neigh.predict(df_test.iloc[:,:16])\n",
    "plt.imshow(res.reshape(253,253))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}