Galaxy classification (classifiers).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Headers and libraries that we're gonna use\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#print(__doc__)\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.misc as scp_misc\n",
    "\n",
    "#Regressor algorithms\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import csv\n",
    "photos = []\n",
    "labels = []\n",
    "\n",
    "with open('training_solutions_rev1.csv', 'r') as csvfile:\n",
    "    reader = csv.reader(csvfile)\n",
    "    \n",
    "    i = 0\n",
    "    restrictor = 10000\n",
    "    for row in reader:\n",
    "        if i >1:\n",
    "            \n",
    "            a = float(row[1])\n",
    "            b = float(row[2])\n",
    "            c = float(row[3])\n",
    "            suma = a+b+c\n",
    "                \n",
    "            a = float(a)/float(suma)\n",
    "            b = float(b)/float(suma)\n",
    "            c = float(c)/float(suma)\n",
    "                \n",
    "            maxim = np.max([a, b, c])\n",
    "            \n",
    "            if (restrictor > 0):\n",
    "                \n",
    "                if (maxim == a):\n",
    "                    tag = \"smooth\"\n",
    "                elif (maxim == b):\n",
    "                    tag = \"features\"\n",
    "                else:\n",
    "                    tag = \"point\"\n",
    "                labels.append([tag, row[0]])\n",
    "\n",
    "\n",
    "                img = scp_misc.imread(\"images_training_rev1/\"+row[0]+\".jpg\", mode=\"L\")\n",
    "                img = scp_misc.imresize(img, 25)\n",
    "                photos.append(img)\n",
    "                \n",
    "                restrictor -= 1\n",
    "            \n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 0\n",
    "while (a < len(photos)):\n",
    "    photos[a] = np.reshape(photos[a], -1)\n",
    "    a += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's divide the samples into training and test samples. *Comment*: maybe we should massage the y sample.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def load_data():\n",
    "    global X, y, X_train, X_test, y_train, y_test, y_test_id, y_test_v, y_train_id, y_train_v\n",
    "    \n",
    "    X = photos\n",
    "    y = labels\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
    "\n",
    "    y_test_id = []\n",
    "    y_test_v = []\n",
    "    y_train_id = []\n",
    "    y_train_v = []\n",
    "\n",
    "    for value in range(len(y_test)):\n",
    "        y_test_id.append(y_test[value][1])\n",
    "        y_test_v.append(y_test[value][0])\n",
    "    for value in range(len(y_train)):\n",
    "        y_train_id.append(y_train[value][1])\n",
    "        y_train_v.append(y_train[value][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3164\n",
      "0.3164\n",
      "0.3144\n",
      "0.3284\n",
      "0.3204\n",
      "0.3192\n",
      "0.3232\n",
      "0.3192\n",
      "0.3136\n",
      "0.3004\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "\n",
    "while (i < 10):\n",
    "    load_data()\n",
    "    \n",
    "    y_test_predict = dict()\n",
    "    clf = KNeighborsClassifier(n_jobs = -1)\n",
    "    clf.fit(X_train, y_train_v)\n",
    "    y_test_predict = clf.predict(X_test)\n",
    "\n",
    "    a = 0\n",
    "    num_err = 0\n",
    "    while (a < len(y_test_predict)):\n",
    "        if (y_test_predict[a] != y_test_v[a]):\n",
    "            num_err += 1\n",
    "        a += 1\n",
    "\n",
    "    print(float(num_err)/len(y_test_predict))\n",
    "    \n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3344\n",
      "0.356\n",
      "0.3472\n",
      "0.3564\n",
      "0.3484\n",
      "0.3496\n",
      "0.3412\n",
      "0.3324\n",
      "0.3348\n",
      "0.3396\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "\n",
    "while (i < 10):\n",
    "    load_data()\n",
    "    \n",
    "    y_test_predict = dict()\n",
    "    clf = DecisionTreeClassifier()\n",
    "    clf.fit(X_train, y_train_v)\n",
    "    y_test_predict = clf.predict(X_test)\n",
    "\n",
    "    a = 0\n",
    "    num_err = 0\n",
    "    while (a < len(y_test_predict)):\n",
    "        if (y_test_predict[a] != y_test_v[a]):\n",
    "            num_err += 1\n",
    "        a += 1\n",
    "\n",
    "    print(float(num_err)/len(y_test_predict))\n",
    "    \n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2664\n",
      "0.2916\n",
      "0.2972\n",
      "0.2816\n",
      "0.284\n",
      "0.2836\n",
      "0.2736\n",
      "0.2832\n",
      "0.282\n",
      "0.284\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "\n",
    "while (i < 10):\n",
    "    load_data()\n",
    "    \n",
    "    y_test_predict = dict()\n",
    "    clf = RandomForestClassifier(n_jobs = -1)\n",
    "    clf.fit(X_train, y_train_v)\n",
    "    y_test_predict = clf.predict(X_test)\n",
    "\n",
    "    a = 0\n",
    "    num_err = 0\n",
    "    while (a < len(y_test_predict)):\n",
    "        if (y_test_predict[a] != y_test_v[a]):\n",
    "            num_err += 1\n",
    "        a += 1\n",
    "\n",
    "    print(float(num_err)/len(y_test_predict))\n",
    "    \n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2576\n",
      "0.2536\n",
      "0.2404\n",
      "0.2628\n",
      "0.2616\n",
      "0.2472\n",
      "0.2376\n",
      "0.2444\n",
      "0.2548\n",
      "0.2436\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "\n",
    "while (i < 10):\n",
    "    load_data()\n",
    "    \n",
    "    y_test_predict = dict()\n",
    "    clf = RandomForestClassifier(n_estimators=25, n_jobs = -1)\n",
    "    clf.fit(X_train, y_train_v)\n",
    "    y_test_predict = clf.predict(X_test)\n",
    "\n",
    "    a = 0\n",
    "    num_err = 0\n",
    "    while (a < len(y_test_predict)):\n",
    "        if (y_test_predict[a] != y_test_v[a]):\n",
    "            num_err += 1\n",
    "        a += 1\n",
    "\n",
    "    print(float(num_err)/len(y_test_predict))\n",
    "    \n",
    "    i += 1"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}