BP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-06-05T02:34:52.108613Z",
     "start_time": "2019-06-05T02:34:51.425118Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import string\n",
    "\n",
    "def rand(a,b):\n",
    "    return (b-a)*np.random.random_sample() + a\n",
    "\n",
    "def sigmoid(x):\n",
    "    return np.tanh(x)\n",
    "    # return 1./(1.+np.exp(-x)) # range 0 to 1\n",
    "\n",
    "vsigmoid = np.vectorize(sigmoid)\n",
    "\n",
    "def dsigmoid(y):\n",
    "    return 1.0 - y**2\n",
    "\n",
    "vdsigmoid = np.vectorize(dsigmoid)\n",
    "\n",
    "class BPNN:\n",
    "    def __init__(self, input_n, hidden_n, output_n):\n",
    "        # 输入层、隐藏层、输出层的节点（数）\n",
    "        self.input_n = input_n + 1 \n",
    "        self.hidden_n = hidden_n\n",
    "        self.output_n = output_n\n",
    "\n",
    "        # 激活神经网络的所有节点（向量）\n",
    "        self.input_cells = np.ones((self.input_n,1), dtype=float)\n",
    "        self.hidden_cells = np.ones((self.hidden_n,1), dtype=float)\n",
    "        self.output_cells = np.ones((self.output_n,1), dtype=float)\n",
    "\n",
    "        # 建立权重（矩阵）\n",
    "        # 输入层权重在 [-0.2, 0.2)\n",
    "        self.input_weights = (np.random.random_sample((self.input_n, self.hidden_n)) - 0.5) * 0.4\n",
    "        # 输出层权重在 [-2., 2.)\n",
    "        self.output_weights = (np.random.random_sample((self.hidden_n, self.output_n)) - 0.5) * 4.\n",
    "        \n",
    "        # 最后一次权重改变的记录\n",
    "        self.input_correction = np.zeros((self.input_n, self.hidden_n))\n",
    "        self.output_correction = np.zeros((self.hidden_n, self.output_n))\n",
    "\n",
    "    def update(self, inputs):\n",
    "        if len(inputs) != self.input_n - 1:\n",
    "            raise ValueError(\"Wrong number of inputs\")\n",
    "\n",
    "        # 激活输入层\n",
    "        for i in range(self.input_n-1):\n",
    "            self.input_cells[i,0] = inputs[i]\n",
    "\n",
    "        # 激活隐藏层\n",
    "        # shapes: (hidden_n,1) = (hidden_n,sinput_n) x (sinput_n,1)\n",
    "        self.hidden_cells = vsigmoid( self.input_weights.T.dot(self.input_cells) )\n",
    "\n",
    "        # 激活输出层\n",
    "        # shapes: (output_n,1) = (output_n,hidden_n) x (hidden_n,1)\n",
    "        self.output_cells = vsigmoid( self.output_weights.T.dot(self.hidden_cells) )\n",
    "\n",
    "        return self.output_cells\n",
    "\n",
    "    def backPropagate(self, targets, learning_rate, momentum_factor):\n",
    "        ''' 反向传播 '''\n",
    "        if len(targets) != self.output_n:\n",
    "            raise ValueError('Wrong number of target values')\n",
    "\n",
    "        # 计算输出层的误差 (output_n,1)\n",
    "        error = targets - self.output_cells\n",
    "        # (output_n,1) * error:\n",
    "        output_deltas = vdsigmoid(self.output_cells) * error\n",
    "\n",
    "        # 计算隐藏层的误差\n",
    "        error = self.output_weights.dot(output_deltas)\n",
    "        # (hidden_n,1) * error:\n",
    "        hidden_deltas = vdsigmoid(self.hidden_cells) * error\n",
    "\n",
    "        # 更新输出层权重\n",
    "        change = self.hidden_cells.dot(output_deltas.T)\n",
    "        self.output_weights += learning_rate*change + momentum_factor*self.output_correction\n",
    "        self.output_correction = change\n",
    "\n",
    "        # 更新输入层权重\n",
    "        change = self.input_cells.dot(hidden_deltas.T)\n",
    "        self.input_weights += learning_rate*change + momentum_factor*self.input_correction\n",
    "        self.input_correction = change\n",
    "\n",
    "        # 计算误差\n",
    "        error = np.sum(0.5*(targets - self.output_cells)**2)\n",
    "        return error\n",
    "\n",
    "    def test(self, patterns):\n",
    "        #y = []\n",
    "        true = 0\n",
    "        for p in patterns:\n",
    "            a = p[1]\n",
    "            b = self.update(p[0])\n",
    "            print(p[1], '->', b)\n",
    "            y_pred = []\n",
    "            for n in b:\n",
    "                if n==max(b):\n",
    "                    y_pred.append(1)\n",
    "                else:\n",
    "                    y_pred.append(0)\n",
    "            if a.index(1)==y_pred.index(1):\n",
    "                true+=1\n",
    "        print('accuracy:', true/len(patterns)*100, '%')\n",
    "            \n",
    "    def predict(self, patterns):\n",
    "        y = []\n",
    "        for p in patterns:\n",
    "            b = self.update(p)\n",
    "            y_pred = []\n",
    "            for n in b:\n",
    "                if n==max(b):\n",
    "                    y_pred.append(1)\n",
    "                else:\n",
    "                    y_pred.append(0)\n",
    "            y.append(y_pred)\n",
    "        return y\n",
    "    \n",
    "    def weights(self):\n",
    "        print('Input weights:')\n",
    "        for i in range(self.input_n):\n",
    "            print(self.input_weights[i])\n",
    "\n",
    "        print()\n",
    "        print('Output weights:')\n",
    "        for j in range(self.hidden_n):\n",
    "            print(self.output_weights[j])\n",
    "\n",
    "    def train(self, patterns, iterations=1000, learning_rate=1, momentum_factor=0.1):\n",
    "        # learning_rate: 学习率\n",
    "        # momentum_factor: 动量因子\n",
    "        errs = []\n",
    "        for i in range(iterations):\n",
    "            error = 0.0\n",
    "            for p in patterns:\n",
    "                inputs = p[0]\n",
    "                if type(p[1]) == list:\n",
    "                    targets = p[1]\n",
    "                else: targets = list([p[1]])\n",
    "                self.update(inputs)\n",
    "                error = error + self.backPropagate(np.array(targets).reshape((len(targets),1)), learning_rate, momentum_factor) \n",
    "            errs.append(error)\n",
    "            if i % 100 == 0:\n",
    "                print('error %-0.5f' % error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-06-05T02:34:52.285805Z",
     "start_time": "2019-06-05T02:34:52.261873Z"
    }
   },
   "outputs": [],
   "source": [
    "pat = [\n",
    "        [[0,0], [0,1]],\n",
    "        [[0,1], [1,0]],\n",
    "        [[1,0], [1,0]],\n",
    "        [[1,1], [0,1]]\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-06-05T02:35:41.769038Z",
     "start_time": "2019-06-05T02:35:40.958522Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error 2.10085\n",
      "error 1.51797\n",
      "error 0.62868\n",
      "error 0.51877\n",
      "error 0.32017\n",
      "error 0.29426\n",
      "error 0.45111\n",
      "error 0.22669\n",
      "error 0.37975\n",
      "error 0.18346\n",
      "[0, 1] -> [[0.40042398]\n",
      " [0.9880083 ]]\n",
      "[1, 0] -> [[0.96167765]\n",
      " [0.09262052]]\n",
      "[1, 0] -> [[0.95832677]\n",
      " [0.32582805]]\n",
      "[0, 1] -> [[0.49223469]\n",
      " [0.9922584 ]]\n",
      "accuracy: 100.0 %\n"
     ]
    }
   ],
   "source": [
    "nn = BPNN(2,5,2)\n",
    "nn.train(pat)\n",
    "nn.test(pat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-06-05T02:35:42.571733Z",
     "start_time": "2019-06-05T02:35:42.560209Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1], [1, 0], [1, 0], [0, 1]]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn.predict([[0,0],[1,0],[0,1],[1,1]])"
   ]
  }
 ],
 "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.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}