PCA Image classification algo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(240, 240)\n",
      "(240, 220)\n",
      "(10304, 220)\n",
      "> Initializing ended\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import cv2\n",
    "import sys\n",
    "import shutil\n",
    "import random\n",
    "import numpy as np\n",
    "faces_dir = 'att_faces'\n",
    "faces_dir\n",
    "faces_count=40\n",
    "energy = 0.85\n",
    "train_faces_count = 6                                                       # number of faces used for training\n",
    "test_faces_count = 4\n",
    "l=train_faces_count*faces_count\n",
    "m=92\n",
    "n=112\n",
    "mn=m*n\n",
    "L=np.empty(shape=(mn,l),dtype='float64')\n",
    "cur_img=0\n",
    "for face_id in range(1,faces_count+1):\n",
    "    training_ids=random.sample(range(1,11),train_faces_count)\n",
    "    #training_ids.append(training_ids)\n",
    "    for training_id in training_ids:\n",
    "        path_to_img = os.path.join(faces_dir,'s' + str(face_id), str(training_id) + '.pgm')\n",
    "        img=cv2.imread(path_to_img,0)\n",
    "        img_col=np.array(img,dtype='float64').flatten()\n",
    "        L[:, cur_img] = img_col[:]\n",
    "        \n",
    "        cur_img+=1\n",
    "        \n",
    "        #print(l)\n",
    "mean_img_col = np.sum(L, axis=1) / l\n",
    "for j in range(0, l):                                             # subtract from all training images\n",
    "    L[:, j] -= mean_img_col[:]\n",
    "    \n",
    "\n",
    "C = np.matrix(L.transpose()) * np.matrix(L)                             # instead of computing the covariance matrix as\n",
    "C /= l  \n",
    "\n",
    "evalues, evectors = np.linalg.eig(C)                          # eigenvectors/values of the covariance matrix\n",
    "sort_indices = evalues.argsort()[::-1]                             # getting their correct order - decreasing\n",
    "evalues = evalues[sort_indices]                               # puttin the evalues in that order\n",
    "evectors = evectors[sort_indices] \n",
    "print(evectors.shape)\n",
    "# same for the evectors\n",
    "\n",
    "\n",
    "evalues_sum = sum(evalues[:])\n",
    "evalues_count = 0\n",
    "evalues_energy = 0.0\n",
    "for evalue in evalues:\n",
    "    evalues_count += 1\n",
    "    evalues_energy += evalue / evalues_sum\n",
    "    if evalues_count >= 220:\n",
    "        break\n",
    "        \n",
    "evalues = evalues[0:evalues_count]\n",
    "evectors = evectors[0:evalues_count]\n",
    "evectors = evectors.transpose()\n",
    "print(evectors.shape)\n",
    "evectors = L *evectors\n",
    "print(evectors.shape)\n",
    "norms = np.linalg.norm(evectors, axis=0) \n",
    "evectors = evectors / norms \n",
    "W = evectors.transpose() * L \n",
    "print ('> Initializing ended')\n",
    "#print(path_to_img)        \n",
    "#print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "W.shape\n",
    "M=evectors.dot(W)\n",
    "M.shape\n",
    "ig=M[:,0]\n",
    "\n",
    "v=ig.reshape(112,92)\n",
    "v.shape\n",
    "img = Image.fromarray(v)\n",
    "img.show()\n",
    "if img.mode != 'RGB':\n",
    "    img = img.convert('RGB')\n",
    "    \n",
    "img.save('my.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 68.56666667]\n",
      " [ 67.61666667]\n",
      " [ 67.0625    ]\n",
      " ..., \n",
      " [ 35.15416667]\n",
      " [ 33.54583333]\n",
      " [ 40.3625    ]]\n",
      "6.33333333333\n"
     ]
    }
   ],
   "source": [
    "path_to_img\n",
    "img=cv2.imread(\"att_faces/s5/5.pgm\",0)\n",
    "img\n",
    "img_col=np.array(img,dtype='float64').flatten()\n",
    "img_col -= mean_img_col \n",
    "img_col = np.reshape(img_col, (mn, 1))\n",
    "print(img_col)\n",
    "S = evectors.transpose() * img_col\n",
    "diff = W - S                                                       # finding the min ||W_j - S||\n",
    "norms = np.linalg.norm(diff, axis=0)\n",
    "closest_face_id = np.argmin(norms)\n",
    "print (closest_face_id/train_faces_count +1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(112, 92)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path_to_img = os.path.join(faces_dir,'s' + str(face_id), str(training_id) + '.pgm')\n",
    "img=cv2.imread(path_to_img,0)\n",
    "img.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}