Final Python File.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gathering info about images at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\images\\train'...\n",
      "Done!\n",
      "Writing images labels info to file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\training_images_labels.txt'...\n",
      "Done!\n",
      "Gathering info about images at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\images\\test'...\n",
      "Done!\n",
      "Writing images labels info to file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\testing_images_labels.txt'...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "from common.generate_images_labels import get_images_labels_list\n",
    "from common.generate_images_labels import write_images_labels_to_file\n",
    "\n",
    "\n",
    "def main():\n",
    "    images_source = 'train'\n",
    "    if images_source not in ['train', 'test']:\n",
    "        print(\"Invalid image-source '{}'!\".format(images_source))\n",
    "        return\n",
    "\n",
    "    images_dir_path = get_config('{}ing_images_dir_path'.format(images_source))\n",
    "    images_labels_path = get_config(\n",
    "        '{}ing_images_labels_path'.format(images_source))\n",
    "\n",
    "    print(\"Gathering info about images at path '{}'...\".format(images_dir_path))\n",
    "    images_labels_list = get_images_labels_list(images_dir_path)\n",
    "    print(\"Done!\")\n",
    "\n",
    "    print(\"Writing images labels info to file at path '{}'...\".format(\n",
    "        images_labels_path))\n",
    "    write_images_labels_to_file(images_labels_list, images_labels_path)\n",
    "    print(\"Done!\")\n",
    "    \n",
    "    images_source = 'test'\n",
    "    if images_source not in ['train', 'test']:\n",
    "        print(\"Invalid image-source '{}'!\".format(images_source))\n",
    "        return\n",
    "\n",
    "    images_dir_path = get_config('{}ing_images_dir_path'.format(images_source))\n",
    "    images_labels_path = get_config(\n",
    "        '{}ing_images_labels_path'.format(images_source))\n",
    "\n",
    "    print(\"Gathering info about images at path '{}'...\".format(images_dir_path))\n",
    "    images_labels_list = get_images_labels_list(images_dir_path)\n",
    "    print(\"Done!\")\n",
    "\n",
    "    print(\"Writing images labels info to file at path '{}'...\".format(\n",
    "        images_labels_path))\n",
    "    write_images_labels_to_file(images_labels_list, images_labels_path)\n",
    "    print(\"Done!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The program completed successfully !!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Takes a set of images as inputs, transforms them using multiple algorithms to\n",
    "make it suitable for ingestion into ML routines, then finally outputs them\n",
    "to disk.\n",
    "\"\"\"\n",
    "import csv\n",
    "import traceback\n",
    "\n",
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "\n",
    "\n",
    "def write_frame_to_file(frame, frame_label, writer):\n",
    "    \"\"\"\n",
    "    Convert the multi-dimensonal array of the image to a one-dimensional one\n",
    "    and write it to a file, along with its label.\n",
    "    \"\"\"\n",
    "   # print(\"Writing frame to file...\")\n",
    "\n",
    "    flattened_frame = frame.flatten()\n",
    "    output_line = [frame_label] + np.array(flattened_frame).tolist()\n",
    "    writer.writerow(output_line)\n",
    "\n",
    "    #print(\"Done!\")\n",
    "\n",
    "\n",
    "def main():\n",
    "    images_transformed_path = get_config('images_transformed_path')\n",
    "    with open(images_transformed_path, 'w') as output_file:\n",
    "        writer = csv.writer(output_file, delimiter=',')\n",
    "\n",
    "        training_images_labels_path = get_config('training_images_labels_path')\n",
    "        with open(training_images_labels_path, 'r') as file:\n",
    "            lines = file.readlines()\n",
    "\n",
    "        for line in lines:\n",
    "            #print(\"\\n\\n\" + line.strip())\n",
    "            image_path, image_label = line.split()\n",
    "\n",
    "            # Read the input image.\n",
    "            frame = cv2.imread(image_path)\n",
    "            # `frame` is a HxW numpy ndarray of triplets (pixels), where H and W are\n",
    "            # the dimensions of the input image.\n",
    "            # cv2.imshow(\"Original\", frame)\n",
    "            try:\n",
    "                frame = apply_image_transformation(frame)\n",
    "                write_frame_to_file(frame, image_label, writer)\n",
    "            except Exception:\n",
    "                exception_traceback = traceback.format_exc()\n",
    "                print(\"Error while applying image transformation on image path '{}' with the following exception trace:\\n{}\".format(\n",
    "                    image_path, exception_traceback))\n",
    "                continue\n",
    "            # cv2.waitKey(1000)\n",
    "    cv2.destroyAllWindows()\n",
    "    print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The program completed successfully !!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Takes a set of images as inputs, transforms them using multiple algorithms to\n",
    "make it suitable for ingestion into ML routines, then finally outputs them\n",
    "to disk.\n",
    "\"\"\"\n",
    "import csv\n",
    "import traceback\n",
    "\n",
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "\n",
    "\n",
    "def write_frame_to_file(frame, frame_label, writer):\n",
    "    \"\"\"\n",
    "    Convert the multi-dimensonal array of the image to a one-dimensional one\n",
    "    and write it to a file, along with its label.\n",
    "    \"\"\"\n",
    "   # print(\"Writing frame to file...\")\n",
    "\n",
    "    flattened_frame = frame.flatten()\n",
    "    output_line = [frame_label] + np.array(flattened_frame).tolist()\n",
    "    writer.writerow(output_line)\n",
    "\n",
    "    #print(\"Done!\")\n",
    "\n",
    "\n",
    "def main():\n",
    "    images_transformed_path = get_config('images_transformed_path')\n",
    "    with open(images_transformed_path, 'w') as output_file:\n",
    "        writer = csv.writer(output_file, delimiter=',')\n",
    "\n",
    "        testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "        with open(testing_images_labels_path, 'r') as file:\n",
    "            lines = file.readlines()\n",
    "\n",
    "        for line in lines:\n",
    "            #print(\"\\n\\n\" + line.strip())\n",
    "            image_path, image_label = line.split()\n",
    "\n",
    "            # Read the input image.\n",
    "            frame = cv2.imread(image_path)\n",
    "            # `frame` is a HxW numpy ndarray of triplets (pixels), where H and W are\n",
    "            # the dimensions of the input image.\n",
    "            # cv2.imshow(\"Original\", frame)\n",
    "            try:\n",
    "                frame = apply_image_transformation(frame)\n",
    "                write_frame_to_file(frame, image_label, writer)\n",
    "            except Exception:\n",
    "                exception_traceback = traceback.format_exc()\n",
    "                print(\"Error while applying image transformation on image path '{}' with the following exception trace:\\n{}\".format(\n",
    "                    image_path, exception_traceback))\n",
    "                continue\n",
    "            # cv2.waitKey(1000)\n",
    "    cv2.destroyAllWindows()\n",
    "    print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "test_input=pd.read_csv('C:\\\\Users\\\\Subham\\\\Documents\\\\Indian-Sign-Language\\\\data\\\\generated\\\\images_transformed.csv',header=None)\n",
    "target=test_input[0]\n",
    "test_input=test_input.drop(0,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(450, 900)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_input.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\GaussianNB\\stats-GaussianNB.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating GaussianNB model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\GaussianNB\\model-serialized-GaussianNB.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'GaussianNB'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "434 450\n",
      "Accuracy of GaussianNB Classification on Test Data is: 0.035555555555555556\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'GaussianNB'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\knn\\stats-knn.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating KNN model with number of neighbours = '10'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\knn\\model-serialized-knn.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'knn'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "363 450\n",
      "Accuracy of knn Classification on Test Data is: 0.19333333333333333\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'knn'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\svm\\stats-svm.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating SVM model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\svm\\model-serialized-svm.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'svm'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "349 450\n",
      "Accuracy of svm Classification on Test Data is: 0.22444444444444445\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'svm'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logisitic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\logistic\\stats-logistic.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating Logistic-regression model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\logistic\\model-serialized-logistic.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'logistic'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "391 450\n",
      "Accuracy of logistic Classification on Test Data is: 0.13111111111111112\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'logistic'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\LinearDiscriminantAnalysis\\stats-LinearDiscriminantAnalysis.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating LinearDiscriminantAnalysis model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\LinearDiscriminantAnalysis\\model-serialized-LinearDiscriminantAnalysis.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'LinearDiscriminantAnalysis'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "423 450\n",
      "Accuracy of LinearDiscriminantAnalysis Classification on Test Data is: 0.06\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'LinearDiscriminantAnalysis'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\RandomForest\\stats-RandomForest.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating RandomForest model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\RandomForest\\model-serialized-RandomForest.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'RandomForest'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "345 450\n",
      "Accuracy of RandomForest Classification on Test Data is: 0.23333333333333334\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'RandomForest'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\ExtraTrees\\stats-ExtraTrees.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating ExtraTree Classifier model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\ExtraTrees\\model-serialized-ExtraTrees.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'ExtraTrees'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "367 450\n",
      "Accuracy of ExtraTrees Classification on Test Data is: 0.18444444444444444\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'ExtraTrees'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\DecisionTree\\stats-DecisionTree.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating DecisionTree model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\DecisionTree\\model-serialized-DecisionTree.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'DecisionTree'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "377 450\n",
      "Accuracy of DecisionTree Classification on Test Data is: 0.1622222222222222\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'DecisionTree'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\AdaBoost\\stats-AdaBoost.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating AdaBoosting Classifier model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\AdaBoost\\model-serialized-AdaBoost.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'AdaBoost'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "370 450\n",
      "Accuracy of AdaBoost Classification on Test Data is: 0.17777777777777778\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'AdaBoost'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\GradientBoosting\\stats-GradientBoosting.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating GradientBoosting model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\GradientBoosting\\model-serialized-GradientBoosting.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'GradientBoosting'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "386 450\n",
      "Accuracy of GradientBoosting Classification on Test Data is: 0.14222222222222222\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'GradientBoosting'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\Bagging\\stats-Bagging.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating Bagging Classifier model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\Bagging\\model-serialized-Bagging.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'Bagging'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "332 450\n",
      "Accuracy of Bagging Classification on Test Data is: 0.26222222222222225\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'Bagging'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\Voting\\stats-Voting.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating VotingClassifier model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dumping the trained model to disk at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\Voting\\model-serialized-Voting.pkl'...\n",
      "Dumped\n",
      "\n",
      "\n",
      "Writing model stats to file...\n",
      "Done!\n",
      "\n",
      "\n",
      "Finished!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    estimators = []\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'Voting'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "347 450\n",
      "Accuracy of Voting Classification on Test Data is: 0.2288888888888889\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import traceback\n",
    "\n",
    "import cv2\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "import warnings\n",
    "\n",
    "def main():\n",
    "    warnings.filterwarnings('ignore')\n",
    "    model_name = 'Voting'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting','GradientBoosting']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    #print(\"Using model '{}'...\".format(model_name))\n",
    "\n",
    "    model_serialized_path = get_config(\n",
    "        'model_{}_serialized_path'.format(model_name))\n",
    "    #print(\"Model deserialized from path '{}'\".format(model_serialized_path))\n",
    "\n",
    "    testing_images_labels_path = get_config('testing_images_labels_path')\n",
    "    total=len(target)\n",
    "    cnt=0\n",
    "    classifier_model = joblib.load(model_serialized_path)\n",
    "    predicted_labels = classifier_model.predict(test_input)\n",
    "#     predicted_label = predicted_labels[0]\n",
    "    #print(predicted_labels)\n",
    "    for i in range(total):\n",
    "        if target[i] != predicted_labels[i]:\n",
    "                    cnt += 1\n",
    "    print(str(cnt)+\" \"+str(total))\n",
    "    print(\"Accuracy of \"+model_name+\" Classification on Test Data is: \"+str((total-cnt)/total))\n",
    "    cv2.destroyAllWindows()\n",
    "    #print (\"The program completed successfully !!\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model stats will be written to the file at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\output\\MLP\\stats-MLP.txt'.\n",
      "\n",
      "Reading the transformed images file located at path 'C:\\Users\\Subham\\Documents\\Indian-Sign-Language\\data\\generated\\images_transformed.csv'...\n",
      "Done!\n",
      "\n",
      "\n",
      "Generating MLP model ...\n",
      "Done!\n",
      "\n",
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "\n",
      "Training the model...\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Error when checking model input: the list of Numpy arrays that you are passing to your model is not the size the model expected. Expected to see 1 array(s), but instead got the following list of 360 arrays: [array([  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,\n        26,  26, 186,  48,   0,   0,   0,   0,   0,   0...",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-41-69d3cfc65efc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m    234\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    235\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'__main__'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 236\u001b[1;33m     \u001b[0mmain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-41-69d3cfc65efc>\u001b[0m in \u001b[0;36mmain\u001b[1;34m()\u001b[0m\n\u001b[0;32m    209\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"\\nTraining the model...\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    210\u001b[0m         classifier_model = classifier_model.fit(\n\u001b[1;32m--> 211\u001b[1;33m             training_images, training_labels)\n\u001b[0m\u001b[0;32m    212\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Done!\\n\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    213\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Users\\Subham\\Anaconda3\\lib\\site-packages\\keras\\models.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, **kwargs)\u001b[0m\n\u001b[0;32m    958\u001b[0m                               \u001b[0minitial_epoch\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minitial_epoch\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    959\u001b[0m                               \u001b[0msteps_per_epoch\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msteps_per_epoch\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 960\u001b[1;33m                               validation_steps=validation_steps)\n\u001b[0m\u001b[0;32m    961\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    962\u001b[0m     def evaluate(self, x, y, batch_size=32, verbose=1,\n",
      "\u001b[1;32mC:\\Users\\Subham\\Anaconda3\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, **kwargs)\u001b[0m\n\u001b[0;32m   1579\u001b[0m             \u001b[0mclass_weight\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mclass_weight\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1580\u001b[0m             \u001b[0mcheck_batch_axis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1581\u001b[1;33m             batch_size=batch_size)\n\u001b[0m\u001b[0;32m   1582\u001b[0m         \u001b[1;31m# Prepare validation data.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1583\u001b[0m         \u001b[0mdo_validation\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Users\\Subham\\Anaconda3\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36m_standardize_user_data\u001b[1;34m(self, x, y, sample_weight, class_weight, check_batch_axis, batch_size)\u001b[0m\n\u001b[0;32m   1412\u001b[0m                                     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_feed_input_shapes\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1413\u001b[0m                                     \u001b[0mcheck_batch_axis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1414\u001b[1;33m                                     exception_prefix='input')\n\u001b[0m\u001b[0;32m   1415\u001b[0m         y = _standardize_input_data(y, self._feed_output_names,\n\u001b[0;32m   1416\u001b[0m                                     \u001b[0moutput_shapes\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Users\\Subham\\Anaconda3\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36m_standardize_input_data\u001b[1;34m(data, names, shapes, check_batch_axis, exception_prefix)\u001b[0m\n\u001b[0;32m     86\u001b[0m                                  \u001b[1;34m'the following list of '\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     87\u001b[0m                                  \u001b[1;34m' arrays: '\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m200\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m+\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 88\u001b[1;33m                                  '...')\n\u001b[0m\u001b[0;32m     89\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     90\u001b[0m                 \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnames\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Error when checking model input: the list of Numpy arrays that you are passing to your model is not the size the model expected. Expected to see 1 array(s), but instead got the following list of 360 arrays: [array([  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,\n        26,  26, 186,  48,   0,   0,   0,   0,   0,   0..."
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv\n",
    "from pandas import set_option\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn import linear_model\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "import keras\n",
    "from keras.layers import Dense\n",
    "from keras.models import Sequential\n",
    "from common.config import get_config\n",
    "\n",
    "\n",
    "def print_with_precision(num):\n",
    "    return \"%0.5f\" % num\n",
    "\n",
    "def generate_MLP_classifier():\n",
    "    print(\"\\nGenerating MLP model ...\")\n",
    "    # Save the number of columns in predictors: n_cols\n",
    "    n_cols = 900\n",
    "\n",
    "    # Set up the model: model\n",
    "    model = Sequential()\n",
    "\n",
    "    # Add the first layer\n",
    "    model.add(Dense(32,activation='relu',input_shape=(n_cols,)))\n",
    "\n",
    "    # Add the output layer\n",
    "    model.add(Dense(26,activation='softmax'))\n",
    "\n",
    "    # Compile the model\n",
    "    model.compile(optimizer='sgd',loss='categorical_crossentropy',metrics=['accuracy'])\n",
    "    print(\"Done!\\n\")\n",
    "    return model\n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "\n",
    "def generate_knn_classifier():\n",
    "    num_neighbours = 10\n",
    "    print(\"\\nGenerating KNN model with number of neighbours = '{}'...\".format(\n",
    "        num_neighbours))\n",
    "    classifier_model = KNeighborsClassifier(n_neighbors=num_neighbours)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_logistic_classifier():\n",
    "    print(\"\\nGenerating Logistic-regression model...\")\n",
    "    classifier_model = linear_model.LogisticRegression()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "\n",
    "def generate_GaussianNB_classifier():\n",
    "    print(\"\\nGenerating GaussianNB model...\")\n",
    "    classifier_model = GaussianNB()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_DecisionTree_classifier():\n",
    "    print(\"\\nGenerating DecisionTree model...\")\n",
    "    classifier_model = DecisionTreeClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_RandomForest_classifier():\n",
    "    print(\"\\nGenerating RandomForest model...\")\n",
    "    classifier_model = RandomForestClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_svm_classifier():\n",
    "    print(\"\\nGenerating SVM model...\")\n",
    "    classifier_model = svm.SVC(kernel='poly', degree = 1)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_LinearDiscriminantAnalysis_classifier():\n",
    "    print(\"\\nGenerating LinearDiscriminantAnalysis model...\")\n",
    "    classifier_model = LinearDiscriminantAnalysis()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Bagging_classifier():\n",
    "    print(\"\\nGenerating Bagging Classifier model...\")\n",
    "    classifier_model = BaggingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_ExtraTrees_classifier():\n",
    "    print(\"\\nGenerating ExtraTree Classifier model...\")\n",
    "    classifier_model = ExtraTreesClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_AdaBoost_classifier():\n",
    "    print(\"\\nGenerating AdaBoosting Classifier model...\")\n",
    "    classifier_model =AdaBoostClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_GradientBoosting_classifier():\n",
    "    print(\"\\nGenerating GradientBoosting model...\")\n",
    "    classifier_model = GradientBoostingClassifier()\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_Voting_classifier():\n",
    "    print(\"\\nGenerating VotingClassifier model...\")\n",
    "    model1 = BaggingClassifier()\n",
    "    estimators.append(('baggingclassifier', model1))\n",
    "    model2 = DecisionTreeClassifier()\n",
    "    estimators.append(('cart', model2))\n",
    "    model3 = ExtraTreesClassifier()\n",
    "    estimators.append(('ETC', model3))\n",
    "    # create the ensemble model\n",
    "    classifier_model = VotingClassifier(estimators)\n",
    "    print(\"Done!\\n\")\n",
    "    return classifier_model\n",
    "\n",
    "def generate_classifier(model_name):\n",
    "    classifier_generator_function_name = \"generate_{}_classifier\".format(\n",
    "        model_name)\n",
    "    return globals()[classifier_generator_function_name]()\n",
    "\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "\n",
    "def main():\n",
    "    model_name = 'MLP'\n",
    "    if model_name not in ['svm', 'logistic', 'knn','DecisionTree','RandomForest','GaussianNB','LinearDiscriminantAnalysis', \n",
    "                      'Bagging' , 'ExtraTrees', 'AdaBoost' , 'Voting', 'MLP']:\n",
    "        print(\"Invalid model-name '{}'!\".format(model_name))\n",
    "        return\n",
    "\n",
    "    model_output_dir_path = get_config(\n",
    "        'model_{}_output_dir_path'.format(model_name))\n",
    "    model_stats_file_path = os.path.join(\n",
    "        model_output_dir_path, \"stats-{}.txt\".format(model_name))\n",
    "    print(\"Model stats will be written to the file at path '{}'.\".format(\n",
    "        model_stats_file_path))\n",
    "\n",
    "    with open(model_stats_file_path, \"w\") as model_stats_file:\n",
    "        images_transformed_path = get_config('images_transformed_path')\n",
    "        images, labels = read_images_transformed(images_transformed_path)\n",
    "        classifier_model = generate_classifier(model_name)\n",
    "\n",
    "        model_stats_file.write(\"Model used = '{}'\".format(model_name))\n",
    "        model_stats_file.write(\n",
    "            \"Classifier model details:\\n{}\\n\\n\".format(classifier_model))\n",
    "        training_images, testing_images, training_labels, testing_labels = divide_data_train_test(\n",
    "            images, labels, 0.2)\n",
    "        \n",
    "        print(\"\\nTraining the model...\")\n",
    "        classifier_model = classifier_model.fit(\n",
    "            training_images, training_labels)\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        model_serialized_path = get_config(\n",
    "            'model_{}_serialized_path'.format(model_name))\n",
    "        print(\"\\nDumping the trained model to disk at path '{}'...\".format(\n",
    "            model_serialized_path))\n",
    "        joblib.dump(classifier_model, model_serialized_path)\n",
    "        print(\"Dumped\\n\")\n",
    "\n",
    "        print(\"\\nWriting model stats to file...\")\n",
    "        score = classifier_model.score(testing_images, testing_labels)\n",
    "        model_stats_file.write(\n",
    "            \"Model score:\\n{}\\n\\n\".format(print_with_precision(score)))\n",
    "\n",
    "        predicted = classifier_model.predict(testing_images)\n",
    "        report = metrics.classification_report(testing_labels, predicted)\n",
    "        model_stats_file.write(\n",
    "            \"Classification report:\\n{}\\n\\n\".format(report))\n",
    "        print(\"Done!\\n\")\n",
    "\n",
    "        print(\"\\nFinished!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Dividing dataset in the ratio '0.2' using `train_test_split()`:\n",
      "Done!\n",
      "\n",
      "Cost after epoch 0: 0.005013\n",
      "Cost after epoch 5: 0.004841\n",
      "Cost after epoch 10: 0.004805\n",
      "Cost after epoch 15: 0.004765\n",
      "Cost after epoch 20: 0.004703\n",
      "Cost after epoch 25: 0.004595\n",
      "Cost after epoch 30: 0.004410\n",
      "Cost after epoch 35: 0.004130\n",
      "Cost after epoch 40: 0.003781\n",
      "Cost after epoch 45: 0.004388\n",
      "Cost after epoch 50: 0.003874\n",
      "Cost after epoch 55: 0.003404\n",
      "Cost after epoch 60: 0.003075\n",
      "Cost after epoch 65: 0.004729\n",
      "Cost after epoch 70: 0.002942\n",
      "Cost after epoch 75: 0.002403\n",
      "Cost after epoch 80: 0.005223\n",
      "Cost after epoch 85: 0.003046\n",
      "Cost after epoch 90: 0.002142\n",
      "Cost after epoch 95: 0.001693\n",
      "Cost after epoch 100: 0.001660\n",
      "Cost after epoch 105: 0.001942\n",
      "Cost after epoch 110: 0.001516\n",
      "Cost after epoch 115: 0.001160\n",
      "Cost after epoch 120: 0.001039\n",
      "Cost after epoch 125: 0.000970\n",
      "Cost after epoch 130: 0.001171\n",
      "Cost after epoch 135: 0.000958\n",
      "Cost after epoch 140: 0.000914\n",
      "Cost after epoch 145: 0.000826\n",
      "Cost after epoch 150: 0.000813\n",
      "Cost after epoch 155: 0.003695\n",
      "Cost after epoch 160: 0.003133\n",
      "Cost after epoch 165: 0.001365\n",
      "Cost after epoch 170: 0.000978\n",
      "Cost after epoch 175: 0.000812\n",
      "Cost after epoch 180: 0.000715\n",
      "Cost after epoch 185: 0.000653\n",
      "Cost after epoch 190: 0.000606\n",
      "Cost after epoch 195: 0.000567\n",
      "Cost after epoch 200: 0.000531\n",
      "Cost after epoch 205: 0.000498\n",
      "Cost after epoch 210: 0.000542\n",
      "Cost after epoch 215: 0.000475\n",
      "Cost after epoch 220: 0.000410\n",
      "Cost after epoch 225: 0.000438\n",
      "Cost after epoch 230: 0.000502\n",
      "Cost after epoch 235: 0.000350\n",
      "Cost after epoch 240: 0.000342\n",
      "Cost after epoch 245: 0.000415\n",
      "Cost after epoch 250: 0.000335\n",
      "Cost after epoch 255: 0.000294\n",
      "Cost after epoch 260: 0.000317\n",
      "Cost after epoch 265: 0.000387\n",
      "Cost after epoch 270: 0.000265\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ncfn/NSgF9UfVAmMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1dd8de180f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Mean_1:0\", shape=(), dtype=float32)\n",
      "Train Accuracy: 0.957586\n",
      "Test Accuracy: 0.844156\n",
      "Done!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\"\"\"\n",
    "Created on Mon Nov 20 02:26:11 2017\n",
    "\n",
    "@author: Sanghai\n",
    "\"\"\"\n",
    "import sys\n",
    "\n",
    "from common.config import get_config\n",
    "import os\n",
    "import sys\n",
    "import csv\n",
    "from sklearn.model_selection import train_test_split\n",
    "import csv\n",
    "import traceback\n",
    "\n",
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "from common.config import get_config\n",
    "from common.image_transformation import apply_image_transformation\n",
    "from common.generate_images_labels import get_images_labels_list\n",
    "from common.generate_images_labels import write_images_labels_to_file\n",
    "import math\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy\n",
    "from scipy import ndimage\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "import cv2\n",
    "\n",
    "    \n",
    "def create_placeholders(n_H0, n_W0, n_C0, n_y):\n",
    "    \"\"\"\n",
    "    Creates the placeholders for the tensorflow session.\n",
    "    \n",
    "    Arguments:\n",
    "    n_H0 -- scalar, height of an input image\n",
    "    n_W0 -- scalar, width of an input image\n",
    "    n_C0 -- scalar, number of channels of the input\n",
    "    n_y -- scalar, number of classes\n",
    "        \n",
    "    Returns:\n",
    "    X -- placeholder for the data input, of shape [None, n_H0, n_W0, n_C0] and dtype \"float\"\n",
    "    Y -- placeholder for the input labels, of shape [None, n_y] and dtype \"float\"\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE ### (≈2 lines)\n",
    "    X = tf.placeholder(tf.float32,shape=(None,n_H0,n_W0,n_C0))\n",
    "    Y = tf.placeholder(tf.float32,shape=(None,n_y))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return X, Y\n",
    "\n",
    "\n",
    "def vec_translate(a):\n",
    "    my_dict = {'a':0,'b':1,'d':2,'e':3,'f':4,'g':5,'h':6,'j':7,'k':8,'m':9,\n",
    "               'n':10,'o':11,'p':12,'q':13,'r':14,'s':15,'t':16,'x':17,'y':18,\n",
    "               'z':19}\n",
    "    return np.vectorize(my_dict.__getitem__)(a)\n",
    "\n",
    "def divide_data_train_test(images, labels, ratio):\n",
    "    print(\"\\nDividing dataset in the ratio '{}' using `train_test_split()`:\".format(ratio))\n",
    "    ret = train_test_split(images, labels, test_size=ratio, random_state=0)\n",
    "    print(\"Done!\\n\")\n",
    "    return ret\n",
    "\n",
    "def convert_to_one_hot(Y, C):\n",
    "    Y = np.eye(C)[Y.reshape(-1)].T\n",
    "    return Y\n",
    "\n",
    "# GRADED FUNCTION: initialize_parameters\n",
    "\n",
    "def initialize_parameters():\n",
    "    \"\"\"\n",
    "    Initializes weight parameters to build a neural network with tensorflow. The shapes are:\n",
    "                        W1 : [4, 4, 3, 8]\n",
    "                        W2 : [2, 2, 8, 16]\n",
    "    Returns:\n",
    "    parameters -- a dictionary of tensors containing W1, W2\n",
    "    \"\"\"\n",
    "    \n",
    "    tf.set_random_seed(1)                              # so that your \"random\" numbers match ours\n",
    "        \n",
    "    ### START CODE HERE ### (approx. 2 lines of code)\n",
    "    W1 = tf.get_variable(\"W1\",[4,4,1,8],initializer = tf.contrib.layers.xavier_initializer(seed = 0))\n",
    "    W2 = tf.get_variable(\"W2\",[2,2,8,16],initializer = tf.contrib.layers.xavier_initializer(seed = 0))\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"W2\": W2}\n",
    "    \n",
    "    return parameters\n",
    "\n",
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"W2\"\n",
    "                  the shapes are given in initialize_parameters\n",
    "\n",
    "    Returns:\n",
    "    Z3 -- the output of the last LINEAR unit\n",
    "    \"\"\"\n",
    "    \n",
    "    # Retrieve the parameters from the dictionary \"parameters\" \n",
    "    W1 = parameters['W1']\n",
    "    W2 = parameters['W2']\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    # CONV2D: stride of 1, padding 'SAME'\n",
    "    Z1 = tf.nn.conv2d(X,W1, strides = [1,1,1,1], padding = 'SAME')\n",
    "    # RELU\n",
    "    A1 = tf.nn.relu(Z1)\n",
    "    # MAXPOOL: window 8x8, sride 8, padding 'SAME'\n",
    "    P1 = tf.nn.max_pool(A1, ksize = [1,8,8,1], strides = [1,8,8,1], padding = 'SAME')\n",
    "    # CONV2D: filters W2, stride 1, padding 'SAME'\n",
    "    Z2 = tf.nn.conv2d(P1,W2, strides = [1,1,1,1], padding = 'SAME')\n",
    "    # RELU\n",
    "    A2 = tf.nn.relu(Z2)\n",
    "    # MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    P2 = tf.nn.max_pool(A2, ksize = [1,4,4,1], strides = [1,4,4,1], padding = 'SAME')\n",
    "    # FLATTEN\n",
    "    P2 = tf.contrib.layers.flatten(P2)\n",
    "    # FULLY-CONNECTED without non-linear activation function (not not call softmax).\n",
    "    # 6 neurons in output layer. Hint: one of the arguments should be \"activation_fn=None\" \n",
    "    Z3 = tf.contrib.layers.fully_connected(P2, 20, activation_fn=None)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    return Z3\n",
    "\n",
    "# GRADED FUNCTION: compute_cost \n",
    "\n",
    "def compute_cost(Z3, Y):\n",
    "    \"\"\"\n",
    "    Computes the cost\n",
    "    \n",
    "    Arguments:\n",
    "    Z3 -- output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)\n",
    "    Y -- \"true\" labels vector placeholder, same shape as Z3\n",
    "    \n",
    "    Returns:\n",
    "    cost - Tensor of the cost function\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### (1 line of code)\n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = Z3, labels = Y))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return cost\n",
    "\n",
    "# GRADED FUNCTION: model\n",
    "\n",
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.3,\n",
    "          num_epochs = 275, minibatch_size = 64, print_cost = True):\n",
    "    \"\"\"\n",
    "    Implements a three-layer ConvNet in Tensorflow:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set, of shape (None, 64, 64, 3)\n",
    "    Y_train -- test set, of shape (None, n_y = 6)\n",
    "    X_test -- training set, of shape (None, 64, 64, 3)\n",
    "    Y_test -- test set, of shape (None, n_y = 6)\n",
    "    learning_rate -- learning rate of the optimization\n",
    "    num_epochs -- number of epochs of the optimization loop\n",
    "    minibatch_size -- size of a minibatch\n",
    "    print_cost -- True to print the cost every 100 epochs\n",
    "    \n",
    "    Returns:\n",
    "    train_accuracy -- real number, accuracy on the train set (X_train)\n",
    "    test_accuracy -- real number, testing accuracy on the test set (X_test)\n",
    "    parameters -- parameters learnt by the model. They can then be used to predict.\n",
    "    \"\"\"\n",
    "    \n",
    "    ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables\n",
    "    tf.set_random_seed(1)                             # to keep results consistent (tensorflow seed)\n",
    "    seed = 3\n",
    "    X_train = np.reshape(X_train,[-1,30,30,1])\n",
    "    X_test = np.reshape(X_test,[-1,30,30,1])                                      # to keep results consistent (numpy seed)\n",
    "    (m, n_H0, n_W0,n_C0) = X_train.shape             \n",
    "    n_y = Y_train.shape[1]                            \n",
    "    costs = []                                        # To keep track of the cost\n",
    "    \n",
    "    # Create Placeholders of the correct shape\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    \n",
    "    X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Initialize parameters\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    parameters = initialize_parameters()\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    Z3 = forward_propagation(X,parameters)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Cost function: Add cost function to tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    optimizer = tf.train.MomentumOptimizer(0.3,0.5).minimize(cost)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Initialize all the variables globally\n",
    "    init = tf.global_variables_initializer()\n",
    "     \n",
    "    # Start the session to compute the tensorflow graph\n",
    "    with tf.Session() as sess:\n",
    "        \n",
    "        # Run the initialization\n",
    "        sess.run(init)\n",
    "        \n",
    "        # Do the training loop\n",
    "        for epoch in range(num_epochs):\n",
    "\n",
    "            minibatch_cost = 0.\n",
    "            #print(type(X_train))\n",
    "            #print(type(Y_train))\n",
    "            #num_minibatches = int(int(m) / int(minibatch_size)) # number of minibatches of size minibatch_size in the train set\n",
    "            #seed = seed + 1\n",
    "            #minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
    "\n",
    "            #for minibatch in minibatches:\n",
    "\n",
    "                # Select a minibatch\n",
    "                #(minibatch_X, minibatch_Y) = minibatch\n",
    "                # IMPORTANT: The line that runs the graph on a minibatch.\n",
    "                # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y).\n",
    "                ### START CODE HERE ### (1 line)\n",
    "            _ , temp_cost = sess.run([optimizer,cost],feed_dict={X: X_train, Y: Y_train})\n",
    "                ### END CODE HERE ###\n",
    "                \n",
    "            minibatch_cost += temp_cost / X_train.shape[0]\n",
    "                \n",
    "\n",
    "            # Print the cost every epoch\n",
    "            if print_cost == True and epoch % 5 == 0:\n",
    "                print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost))\n",
    "            if print_cost == True and epoch % 1 == 0:\n",
    "                costs.append(minibatch_cost)\n",
    "        \n",
    "        \n",
    "        # plot the cost\n",
    "        plt.plot(np.squeeze(costs))\n",
    "        plt.ylabel('cost')\n",
    "        plt.xlabel('iterations (per tens)')\n",
    "        plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "        plt.show()\n",
    "\n",
    "        # Calculate the correct predictions\n",
    "        predict_op = tf.argmax(Z3, 1)\n",
    "        correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\n",
    "        \n",
    "        # Calculate accuracy on the test set\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "        print(accuracy)\n",
    "        train_accuracy = accuracy.eval({X: X_train, Y: Y_train})\n",
    "        test_accuracy = accuracy.eval({X: X_test, Y: Y_test})\n",
    "        print(\"Train Accuracy:\", train_accuracy)\n",
    "        print(\"Test Accuracy:\", test_accuracy)\n",
    "                \n",
    "        return train_accuracy, test_accuracy, parameters\n",
    "    \n",
    "\n",
    "def read_images_transformed(images_transformed_path):\n",
    "    print(\"\\nReading the transformed images file located at path '{}'...\".format(\n",
    "        images_transformed_path))\n",
    "\n",
    "    images = []\n",
    "    labels = []\n",
    "    with open(images_transformed_path) as images_transformed_file:\n",
    "        reader = csv.reader(images_transformed_file, delimiter=',')\n",
    "        cnt = 0\n",
    "        for line in reader:\n",
    "            if len(line)==0:\n",
    "                continue\n",
    "            cnt = cnt + 1\n",
    "            label = line[0]\n",
    "            labels.append(label)\n",
    "            image = line[1:]\n",
    "            image_int = [int(pixel) for pixel in image]\n",
    "            image = np.array(image_int)\n",
    "            images.append(image)\n",
    "    print(\"Done!\\n\")\n",
    "    return images, labels\n",
    "\n",
    "def main():\n",
    "    images_transformed_path = get_config('images_transformed_path')\n",
    "    images_transformed_path = get_config('images_transformed_path')\n",
    "    with open(images_transformed_path, 'w') as output_file:\n",
    "        writer = csv.writer(output_file, delimiter=',')\n",
    "\n",
    "        training_images_labels_path = get_config('training_images_labels_path')\n",
    "        with open(training_images_labels_path, 'r') as file:\n",
    "            lines = file.readlines()\n",
    "        images = []\n",
    "        labels = []\n",
    "        for line in lines:\n",
    "            #print(\"\\n\\n\" + line.strip())\n",
    "            image_path, image_label = line.split()\n",
    "\n",
    "            # Read the input image.\n",
    "            frame = cv2.imread(image_path)\n",
    "            # `frame` is a HxW numpy ndarray of triplets (pixels), where H and W are\n",
    "            # the dimensions of the input image.\n",
    "            # cv2.imshow(\"Original\", frame)\n",
    "            frame = apply_image_transformation(frame)\n",
    "            images.append(frame)\n",
    "            labels.append(image_label)\n",
    "            \n",
    "                \n",
    "        X_train, X_test, Y_train, Y_test = divide_data_train_test(\n",
    "                images, labels, 0.2)\n",
    "        X_train = np.array(X_train)\n",
    "        Y_train = np.array(Y_train)\n",
    "        Y_train = vec_translate(Y_train)\n",
    "        X_test=np.array(X_test)\n",
    "        Y_test=vec_translate(Y_test)\n",
    "        Y_test=np.array(Y_test)\n",
    "        X_train = X_train/255.\n",
    "        X_test = X_test/255.\n",
    "        \n",
    "        Y_train = convert_to_one_hot(Y_train, 20).T\n",
    "        Y_test = convert_to_one_hot(Y_test, 20).T\n",
    "        #print(X_train.shape)\n",
    "    _, _, parameters = model(X_train, Y_train, X_test, Y_test)\n",
    "        \n",
    "        \n",
    "        \n",
    "    print(\"Done!\\n\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}