IrisClassifer/IrisClassifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This data sets consists of 3 different types of irises’ (Setosa, Versicolour, and Virginica) \n",
    "#petal and sepal length, stored in a 150x4 numpy.ndarray\n",
    "#The rows being the samples and the columns being: Sepal Length, Sepal Width, Petal Length and Petal Width."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import datasets\n",
    "\n",
    "iris = datasets.load_iris()\n",
    "X = iris.data\n",
    "Y = iris.target\n",
    "\n",
    "# 获取数据集大小\n",
    "len(X)\n",
    "\n",
    "# 随机将数据集划分成成70%训练集，30%测试集。\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#rocky实现的KNN算法\n",
    "\n",
    "from sklearn import metrics\n",
    "from collections import Counter\n",
    "from scipy.spatial import distance\n",
    "\n",
    "class KNN:\n",
    "    def __init__(self):\n",
    "        self.x_train = None\n",
    "        self.y_train = None\n",
    "\n",
    "    def fit(self, x_train, y_train):\n",
    "        self.x_train = x_train\n",
    "        self.y_train = y_train\n",
    "\n",
    "    def predict(self, x_test, k=3):\n",
    "        predictions = []\n",
    "        for element in x_test:\n",
    "            # 无投票，简单找到离训练集最近的点，返回其label最为预测x的label\n",
    "            label = self.closet(element)\n",
    "\n",
    "            # 投票法\n",
    "            # label = self.vote(element, k)\n",
    "\n",
    "            predictions.append(label)\n",
    "\n",
    "        return predictions\n",
    "\n",
    "    def score(self, x_test, y_test):\n",
    "        return metrics.accuracy_score(y_test, self.predict(x_test))\n",
    "\n",
    "    def closet(self, element):\n",
    "        def enc(a, b):\n",
    "            return distance.euclidean(a, b)\n",
    "\n",
    "        best_dist = enc(element, self.x_train[0])\n",
    "        best_index = 0\n",
    "\n",
    "        for index in range(1, len(self.x_train)):\n",
    "            dist = enc(element, self.x_train[index])\n",
    "            if dist < best_dist:\n",
    "                best_dist = dist\n",
    "                best_index = index\n",
    "\n",
    "        return self.y_train[best_index]\n",
    "\n",
    "    def vote(self, element, k):\n",
    "        def enc(a, b):\n",
    "            return distance.euclidean(a, b)\n",
    "\n",
    "        k_list = []\n",
    "        for index in range(k):\n",
    "            best_dist = enc(element, self.x_train[index])\n",
    "            k_list.append([index, best_dist])\n",
    "\n",
    "        for index in range(k, len(self.x_train)):\n",
    "            dist = enc(element, self.x_train[index])\n",
    "            for i in range(k):\n",
    "                if dist < k_list[i][1]:\n",
    "                    k_list.pop(i)\n",
    "                    k_list.insert(i, [index, dist])\n",
    "\n",
    "        index_list = []\n",
    "        for index in range(k):\n",
    "            index_list.append(k_list[index][0])\n",
    "\n",
    "        # list with one element, it's a tuple (index, times)\n",
    "        counter = Counter(index_list)\n",
    "        index = counter.most_common(1)[0][0]\n",
    "\n",
    "        return self.y_train[index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 选择算法：分别选用KNeighborsClassifier、rocky实现的KNN、DecisionTreeClassifier算法\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "cls_dict = {'Sklearn-KNN': KNeighborsClassifier(),\n",
    "            'Rocky-KNN': KNN(),\n",
    "            'DecisionTree': DecisionTreeClassifier(),\n",
    "            }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练并测试算法：并序列化，若算法需要调优，可手动删除序列化文件\n",
    "import pickle\n",
    "\n",
    "for name, cls in cls_dict.items():\n",
    "    # 训练算法：并序列化，若算法需要调优，可手动删除序列化文件\n",
    "    try:\n",
    "        with open('%s.pickle' % name, 'rb') as f:\n",
    "            cls = pickle.load(f)\n",
    "    except Exception, e:\n",
    "        # 训练算法\n",
    "        cls.fit(X_train, Y_train)\n",
    "        print e\n",
    "\n",
    "        # 序列化算法\n",
    "        with open('%s.pickle' % name, 'wb') as f:\n",
    "            pickle.dump(cls, f)\n",
    "\n",
    "    # 测试算法\n",
    "    print \"%s Algorithm Accuracy: %s\" % (name, cls.score(X_test, Y_test))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}