Perception.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150\n",
      "147\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Iris-versicolor    50\n",
       "Iris-virginica     49\n",
       "Iris-setosa        48\n",
       "Name: class, dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv(r\"dataset/iris.arff.csv\", header=0)\n",
    "# data.head(10)\n",
    "# data.tail(10)\n",
    "# print(data.sample(10))\n",
    "# data = data.drop(\"Id\",axis=1)  # 删除列\n",
    "print(len(data))\n",
    "if data.duplicated().any(): # 重复值\n",
    "    data.drop_duplicates(inplace=True) #删除重复值\n",
    "    print(len(data))\n",
    "display(data[\"class\"].value_counts()) # 计算每个类别的数量\n",
    "# 因为感知器映射结果为1和-1，所以这里这也处理\n",
    "data[\"class\"] = data[\"class\"].map({\"Iris-versicolor\":0,\"Iris-setosa\":-1,\"Iris-virginica\":1}) # 类别名称映射为数字\n",
    "data = data[data[\"class\"]!=0]\n",
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Perception:\n",
    "    '''感知器算法实现。二分类'''\n",
    "    def __init__(self, learning_rate, times):\n",
    "        '''初始化\n",
    "        \n",
    "        Parameters\n",
    "        -----\n",
    "        learning_rate: float 学习率\n",
    "        times: int 迭代次数\n",
    "        '''\n",
    "        self.learning_rate = learning_rate\n",
    "        self.times =  times\n",
    "    def step(self, z):\n",
    "        '''阶跃函数\n",
    "        \n",
    "        Paraammeters\n",
    "        -----\n",
    "        z: 数组类型(或者是标量) 阶跃函数参数。将z映射为1或者-1\n",
    "        \n",
    "        Return\n",
    "        -----\n",
    "        value: int z>0返回1.z<0返回1\n",
    "        '''\n",
    "        return np.where(z>0, 1,-1) # 一步实现对数值或者数组的计算返回\n",
    "    def fit(self, X, y):\n",
    "        '''训练\n",
    "        \n",
    "        Parameters\n",
    "        -----\n",
    "        X: 特征矩阵，可以是List也可以是Ndarray，形状为： [样本数量,特征数量]\n",
    "        y: 标签数组\n",
    "        '''\n",
    "        X = np.asarray(X)\n",
    "        y = np.asarray(y)\n",
    "        # 创建权重向量。初始值为0。长度比特征多1.多出的是截距\n",
    "        self.w_ = np.zeros(1 + X.shape[1])\n",
    "        # 创建损失列表，用来保存每次迭代后的损失值\n",
    "        self.loss_ = []\n",
    "        for i in range(self.times):\n",
    "            # 感知器与逻辑回归的区别：逻辑回归中。使用所有样本计算梯度来更新权重。\n",
    "            # 而感知器是使用单个样本，依次计算梯度更新权重\n",
    "            loss = 0\n",
    "            for x,target in zip(X,y):\n",
    "                # 计算预测值\n",
    "                y_hat = self.step(np.dot(x, self.w_[1:]) + self.w_[0])\n",
    "                # 如果预测值不等于目标值，返回1，loss+1，否则loss不增加\n",
    "                loss += y_hat != target\n",
    "                # 更新权重\n",
    "                # w(j) = w(j) + 学习率 * (真实值-预测值)*x(j)\n",
    "                self.w_[0] += self.learning_rate * (target - y_hat)\n",
    "                self.w_[1:] +=  self.learning_rate * (target - y_hat) * x\n",
    "            # 将循环累计误差值增加到误差列表中\n",
    "            self.loss_.append(loss)\n",
    "    def predit(self, X):\n",
    "        '''根据参数预测\n",
    "        \n",
    "        Parametres:\n",
    "        X: 特征矩阵，可以是List也可以是Ndarray，形状为： [样本数量,特征数量]\n",
    "        \n",
    "        Return\n",
    "        -----\n",
    "        value: 数组类型， 分类值[1或-1]\n",
    "        '''\n",
    "        return self.step(np.dot(X, self.w_[1:]) + self.w_[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  1,  1,  1,  1,  1,  1,  1,  1, -1, -1, -1, -1, -1, -1, -1, -1])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([ 1,  1,  1,  1,  1,  1,  1,  1,  1, -1, -1, -1, -1, -1, -1, -1, -1],\n",
       "      dtype=int64)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([-0.2 , -0.5 , -0.68,  1.56,  0.88])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[3, 2, 0, 0, 0, 0, 0, 0, 0, 0]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t1 = data[data[\"class\"]==1]\n",
    "t2 = data[data[\"class\"]==-1]\n",
    "t1.sample(len(t1), random_state=0)\n",
    "t2.sample(len(t2), random_state=0)\n",
    "train_X = pd.concat([t1.iloc[:40,:-1], t2.iloc[:40, :-1]], axis=0)\n",
    "train_y = pd.concat([t1.iloc[:40,-1], t2.iloc[:40, -1]], axis=0)\n",
    "test_X = pd.concat([t1.iloc[40:,:-1], t2.iloc[40:, :-1]], axis=0)\n",
    "test_y = pd.concat([t1.iloc[40:,-1], t2.iloc[40:, -1]], axis=0)\n",
    "\n",
    "p = Perception(0.1, 10)\n",
    "p.fit(train_X,train_y)\n",
    "result = p.predit(test_X)\n",
    "# result\n",
    "display(result)\n",
    "display(test_y.values)\n",
    "display(p.w_)\n",
    "display(p.loss_) # 可以看出每次迭代后损失值就下降了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "mpl.rcParams[\"font.family\"] = \"SimHei\"\n",
    "mpl.rcParams[\"axes.unicode_minus\"] = False # 显示负号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制真实值\n",
    "plt.plot(test_y.values, \"go\", ms=15, label=\"真实值\")\n",
    "plt.plot(result, \"rx\", ms=15, label=\"预测值\")\n",
    "plt.title(\"感知器二分类\")\n",
    "plt.xlabel(\"样本序号\")\n",
    "plt.xlabel(\"类别\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22730e15ac8>]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制目标函数损失值\n",
    "plt.plot(range(1, p.times+1), p.loss_, \"o-\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}