ch07-逻辑回归/Z1-使用Logistic回归在简单数据集上的分类.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import*\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotBestFit(dataArr, labelMat, weights):\n",
    "    '''\n",
    "    Desc:            将我们得到的数据可视化展示出来\n",
    "    Args:\n",
    "        dataArr:样本数据的特征\n",
    "        labelMat:样本数据的类别标签，即目标变量\n",
    "        weights:回归系数\n",
    "    Returns:            None\n",
    "    '''\n",
    "    n = shape(dataArr)[0]\n",
    "    xcord1 = []; ycord1 = []\n",
    "    xcord2 = []; ycord2 = []\n",
    "    for i in range(n):\n",
    "        if int(labelMat[i])== 1:\n",
    "            xcord1.append(dataArr[i,1]) \n",
    "            ycord1.append(dataArr[i,2])\n",
    "        else:\n",
    "            xcord2.append(dataArr[i,1]) \n",
    "            ycord2.append(dataArr[i,2])\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')\n",
    "    ax.scatter(xcord2, ycord2, s=30, c='green')\n",
    "    x = arange(-3.0, 3.0, 0.1)\n",
    "            \n",
    "    \"\"\"\n",
    "    y的由来，卧槽，是不是没看懂？    首先理论上是这个样子的。\n",
    "    dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])\n",
    "    w0*x0+w1*x1+w2*x2=f(x)    x0最开始就设置为1叻， x2就是我们画图的y值，而f(x)被我们磨合误差给算到w0,w1,w2身上去了\n",
    "    所以： w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2\n",
    "    \"\"\"\n",
    "    y = (-weights[0]-weights[1]*x)/weights[2]\n",
    "    ax.plot(x, y)\n",
    "    plt.xlabel('X'); plt.ylabel('Y')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 解析数据\n",
    "def loadDataSet(file_name):\n",
    "    '''\n",
    "    Desc: \n",
    "        加载并解析数据\n",
    "    Args:\n",
    "        file_name -- 文件名称，要解析的文件所在磁盘位置\n",
    "    Returns:\n",
    "        dataMat -- 原始数据的特征\n",
    "        labelMat -- 原始数据的标签，也就是每条样本对应的类别\n",
    "    '''\n",
    "    # dataMat为原始数据， labelMat为原始数据的标签\n",
    "    dataMat = []\n",
    "    labelMat = []\n",
    "    fr = open(file_name)\n",
    "    for line in fr.readlines():\n",
    "        lineArr = line.strip().split()\n",
    "        if len(lineArr) == 1:\n",
    "            continue    # 这里如果就一个空的元素，则跳过本次循环\n",
    "        # 为了方便计算，我们将 X0 的值设为 1.0 ，也就是在每一行的开头添加一个 1.0 作为 X0\n",
    "        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])\n",
    "        labelMat.append(int(lineArr[2]))\n",
    "    return dataMat, labelMat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    # 这里其实非常有必要解释一下，会出现的错误 RuntimeWarning: overflow encountered in exp\n",
    "    # 这个错误在学习阶段虽然可以忽略，但是我们至少应该知道为什么\n",
    "    # 这里是因为我们输入的有的 x 实在是太小了，比如 -6000之类的，那么计算一个数字 np.exp(6000)这个结果太大了，没法表示，所以就溢出了\n",
    "    # 如果是计算 np.exp（-6000），这样虽然也会溢出，但是这是下溢，就是表示成零\n",
    "    # 去网上搜了很多方法，比如 使用bigfloat这个库（我竟然没有安装成功，就不尝试了，反正应该是有用的\n",
    "    return 1.0 / (1 + np.exp(-x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 梯度上升"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 正常的处理方案\n",
    "# 两个参数：第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。\n",
    "# 第二个参数==> classLabels 是类别标签，它是一个 1*100 的行向量。为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给labelMat。\n",
    "def gradAscent(dataMatIn, classLabels):\n",
    "    # 转化为矩阵[[1,1,2],[1,1,2]....]\n",
    "    dataMatrix = np.mat(dataMatIn)\n",
    "    # 转换为 NumPy 矩阵\n",
    "    # 转化为矩阵[[0,1,0,1,0,1.....]]，并转制[[0],[1],[0].....]\n",
    "    # transpose() 行列转置函数\n",
    "    # 将行向量转化为列向量   =>  矩阵的转置\n",
    "    labelMat = np.mat(classLabels).transpose() # 首先将数组转换为 NumPy 矩阵，然后再将行向量转置为列向量\n",
    "    # m->数据量，样本数 n->特征数\n",
    "    m,n = shape(dataMatrix)\n",
    "    # print m, n, '__'*10, shape(dataMatrix.transpose()), '__'*100\n",
    "    # alpha代表向目标移动的步长\n",
    "    alpha = 0.001\n",
    "    # 迭代次数\n",
    "    maxCycles = 500\n",
    "    # 生成一个长度和特征数相同的矩阵，此处n为3 -> [[1],[1],[1]]\n",
    "    # weights 代表回归系数， 此处的 ones((n,1)) 创建一个长度和特征数相同的矩阵，其中的数全部都是 1\n",
    "    weights = ones((n,1))\n",
    "    for k in range(maxCycles):\n",
    "        # heavy on matrix operations\n",
    "        # m*3 的矩阵 * 3*1 的单位矩阵 ＝ m*1的矩阵\n",
    "        # 那么乘上单位矩阵的意义，就代表：通过公式得到的理论值\n",
    "        # 参考地址： 矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145\n",
    "        # print 'dataMatrix====', dataMatrix\n",
    "        # print 'weights====', weights\n",
    "        # n*3   *  3*1  = n*1\n",
    "        h = sigmoid(dataMatrix*weights)\n",
    "        # 矩阵乘法\n",
    "        # print 'hhhhhhh====', h\n",
    "        # labelMat是实际值\n",
    "        error = (labelMat - h)\n",
    "        # 向量相减\n",
    "        # 0.001* (3*n)*(n*1) 表示在每一个列上的一个误差情况，最后得出 x0,x1,x2的系数的偏移量\n",
    "        weights = weights + alpha * dataMatrix.transpose() * error \n",
    "        # 矩阵乘法，最后得到回归系数\n",
    "    return array(weights)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机梯度上升\n",
    "# 梯度上升优化算法在每次更新数据集时都需要遍历整个数据集，计算复杂都较高\n",
    "# 随机梯度上升一次只用一个样本点来更新回归系数\n",
    "def stocGradAscent0(dataMatrix, classLabels):\n",
    "    m,n = shape(dataMatrix)\n",
    "    alpha = 0.01\n",
    "    # n*1的矩阵\n",
    "    # 函数ones创建一个全1的数组\n",
    "    weights = ones(n)\n",
    "    # 初始化长度为n的数组，元素全部为 1\n",
    "    for i in range(m):\n",
    "        # sum(dataMatrix[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn,此处求出的 h 是一个具体的数值，而不是一个矩阵\n",
    "        h = sigmoid(sum(dataMatrix[i]*weights))\n",
    "        # print 'dataMatrix[i]===', dataMatrix[i]\n",
    "        # 计算真实类别与预测类别之间的差值，然后按照该差值调整回归系数\n",
    "        error = classLabels[i] - h\n",
    "        # 0.01*(1*1)*(1*n)\n",
    "        # print(weights, \"*\"*10 , dataMatrix[i], \"*\"*10 , error)\n",
    "        weights = weights + alpha * error * dataMatrix[i]\n",
    "\n",
    "    return weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机梯度上升算法（随机化）\n",
    "def stocGradAscent1(dataMatrix, classLabels, numIter=150):\n",
    "    m,n = shape(dataMatrix)\n",
    "    weights = ones(n)   # 创建与列数相同的矩阵的系数矩阵，所有的元素都是1\n",
    "    # 随机梯度, 循环150,观察是否收敛\n",
    "    for j in range(numIter):\n",
    "        # [0, 1, 2 .. m-1]\n",
    "        dataIndex = list(range(m))\n",
    "        for i in range(m):\n",
    "            # i和j的不断增大，导致alpha的值不断减少，但是不为0\n",
    "            alpha = 4/(1.0+j+i)+0.0001\n",
    "            # alpha 会随着迭代不断减小，但永远不会减小到0，因为后边还有一个常数项0.0001\n",
    "            # 随机产生一个 0～len()之间的一个值\n",
    "            # random.uniform(x, y) 方法将随机生成下一个实数，它在[x,y]范围内,x是这个范围内的最小值，y是这个范围内的最大值。\n",
    "            randIndex = int(random.uniform(0,len(dataIndex)))\n",
    "            # sum(dataMatrix[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn\n",
    "            h = sigmoid(sum(dataMatrix[randIndex]*weights))\n",
    "            error = classLabels[randIndex] - h\n",
    "            # print weights, '__h=%s' % h, '__'*20, alpha, '__'*20, error, '__'*20, dataMatrix[randIndex]\n",
    "            weights = weights + alpha * error * dataMatrix[randIndex]\n",
    "            del(dataIndex[randIndex])\n",
    "\n",
    "    return weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def testLR():\n",
    "    # 1.收集并准备数据\n",
    "    dataMat, labelMat = loadDataSet(\"5.Logistic/TestSet.txt\")\n",
    "    # print(dataMat, '\\t---\\t', labelMat)\n",
    "    # [1.0, -0.017612, 14.053064]   0\n",
    "    # 2.训练模型，  f(x)=a1*x1+b2*x2+..+nn*xn中 (a1,b2, .., nn).T的矩阵值\n",
    "    # 因为数组没有是复制n份， array的乘法就是乘法\n",
    "    dataArr = array(dataMat)\n",
    "    # print dataArr\n",
    "    weights = gradAscent(dataArr, labelMat)\n",
    "    # weights = stocGradAscent0(dataArr, labelMat)\n",
    "    # weights = stocGradAscent1(dataArr, labelMat)\n",
    "    # print '*'*30, weights\n",
    "    # 数据可视化\n",
    "    plotBestFit(dataArr, labelMat, weights)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataMat, labelMat = loadDataSet(\"5.Logistic/TestSet.txt\")\n",
    "dataArr = np.array(dataMat)\n",
    "weights = gradAscent(dataArr, labelMat)\n",
    "plotBestFit(dataArr, labelMat, weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl4lPW1wPHvCQlhC2FJ2EJiEEIQERBiUBHcQanWpe5LXVoR616V297e3va2t8+twV1UwN2KWxet16tsKiKKCFEQFQJhDWENSAgEkkxy7h8ZaAhZZpKZed935nyeJw+Zd97JnGSG35n3d36LqCrGGGNMoOKcDsAYY4y3WOIwxhgTFEscxhhjgmKJwxhjTFAscRhjjAmKJQ5jjDFBscRhjDEmKJY4jDHGBMUShzHGmKDEOx1AOKSkpGhmZqbTYRhjjGfk5+eXqGpqIOdGZeLIzMxk6dKlTodhjDGeISIbAz3XuqqMMcYExRKHMcaYoFjiMMYYExRLHMYYY4IS9sQhIi+IyA4R+bbOsd+LSLGILPN/TWjkseeJSIGIFIrIr8IdqzHGmOZF4orjJeC8Bo4/qqrD/V/v179TRNoATwHnA4OBq0VkcFgjNcYY06ywJw5VXQDsbsFDc4FCVV2nqpXAG8BFIQ3OGGNM0JyscdwhIt/4u7K6NnB/GlBU5/Zm/7EGichEEVkqIkt37twZ6liN8Zyi0iLufP9Ocp/N5c7376SotKj5BxkTAKcSxzNAf2A4sBV4uLU/UFVnqGqOquakpgY0+dGYqFVUWsSwacOYnj+dJVuWMD1/OsOmDbPkYULCkcShqttVtVpVa4Bnqe2Wqq8YSK9zu6//mDGmGXmf5bGvch9VNVUAVNVUsa9yH3mf5TkcmYkGjiQOEeld5+YlwLcNnLYEyBKRfiLSFrgKeDcS8RnjdYuLFx9OGodU1VTxZfGXDkVkokkkhuO+DiwCskVks4j8DMgTkRUi8g1wJnCv/9w+IvI+gKr6gDuA2cBK4C1V/S7c8RoTDUaljSIhLuGIYwlxCeSmNXRxb0xwRFWdjiHkcnJy1BY5NLHsUI3jUHdVQlwCndp2Yvmk5aQnpzf/A0zMEZF8Vc0J5FybOW5MFEpPTmf5pOXcOvJWcvvkcuvIWy1pmJCJymXVjYkWRaVF5H2Wx+LixYxKG8Xk0ZMDbvzTk9N5csKTYY7QxCJLHMa4VP3upmXbljFzxUy7cjCOs64qY1zKhtQat7IrDmNcpG7X1MY9G107pLY1XWjG+yxxGOMS9bum4hroEHDDkFrrQjPWVWWMS9TvmqqhBgBBAA4PqZ08erJjMYJ1oRm74jDGNRqa7Q2Q2jGVzORMctNyXdElZLPSjSUOY1xiVNoolm1bdkSjnBCXwBWDr3DVsNrG4nS6C81EjnVVGeMSk0dPplPbToeXCnFL11R9XonThI8lDmNcwiuzvSMRp+0l4m62VpUxxlVsnS1n2FpVxhjPslFb7meJwxjjKjZqy/0scRhjXMX2EnE/SxzGmAY5VaAO56gtK7qHRtiL4yLyAnABsENVh/iPTQEuBCqBtcBNqrqngcduAMqAasAXaOHGiuPGtI7TBepDa2F9uulTarSGOIljTMaYVk2AdPp3cju3FcdfAs6rd2wuMERVhwKrgV838fgzVXV4oL+QMab1nC5QpyenM3n0ZDaVbmJVySqWb1/O9PzpDJs2rMVXCU7/TtEk7IlDVRcAu+sdm+PfUxzgC6BvuOMwJla1pHvGDQXqUDf0bvidooUbahw3Ax80cp8Cc0QkX0QmRjAmY6LC4s2LyXoyi6lLprJkyxKmLZ0W0Kd2NxSoQ93Qu+F3ihaOJg4R+Q3gA2Y2csppqjoCOB+4XUTGNvGzJorIUhFZunPnzjBEa4y3FJUWcfpLp1NRXXH4mE99lFWUNfup3Q3LioS6oXfD7xQtHEscInIjtUXza7WRCr2qFvv/3QG8DTT6jlHVGaqao6o5qampYYjYhJuNeAmtvM/yjkgah/jU1+yndjcsfxLqht4Nv1O0iMiSIyKSCbxXZ1TVecAjwOmq2uDlgYh0BOJUtcz//VzgD6o6q7nns1FV3mMjXkIv99lclmxZ0uB9Nwy9gaTEJNfv4HdodNWXxV+6Zln5aBXMqKqwL6suIq8DZwApIrIZ+B21o6gSgbkiAvCFqk4SkT7Ac6o6AegJvO2/Px54LZCkYbypqUKom5YU95JRaaP4etvX+Gp8RxxvG9eWdwreobyq3PU7+KUnp9vr70KRGFV1tar2VtUEVe2rqs+r6gBVTfcPsx2uqpP8527xJw1UdZ2qDvN/Ha+qfwp3rMY5Xhvx4oVutcmjJ5PUNon4uH99Pkxsk8iPs398OGmADUs1wXPDqCpjPDXi5VC32vT86SzZsqTV8wvC5VCf/qSRk8jtk8sdJ93BmjvXsLF0o6eStHEf2wHQuMLk0ZOZuWLmUTUON4548VK3WkNdPW7awe9QDeNQreW6odfx6jevur72EutsPw7jGpEqhBaVFvHbj37LB4UfgMD5A87nj2f+MeDnaqzonNsnl8W3LA51uCHnloEI9eOIl3iqtZo2cW3w1fhsgESEuao4bkygIlEILSot4oRnTqC0ovTwsZeXv8w7q95hxW0rAmqg3PSJvSUOdWE5PVqp/pWbz7+YxKFivpuv5GKd1ThMVAi0WJ33WR57K/YedTyQSXGHRMNEskNJevEti3lywpOOfKJvaEBEfVZ7cSe74jCeV7/Lo6nhpYuLF6Mc3T1bQ03ADZRbPrF7XUNXbvV56UoultgVh/G8YBbDG5U2CkGOOh5HXFANlBs+sXtd/Su3eIlHkMPDh714JRcrLHEYzwtmDsjk0ZPpnNj5qONJiUmHGyg3z9FobWxu+t3qLwEyKWcSi3626PDwYVsSxL1sVJXxvDvfv5Pp+dOPKlbfOvLWBouqTY2qcsuIo4a0NraGRjG1iWvDoJRBrd4kyXif2zZyMiasgi1Wpyen89IlL7H9ge1sv387L1380uEG082b/bQ2toZGMVVUV4RkkyQTWyxxGM8L5aqn4Vj6JFTdQ62NralRTG5KkMb9bFSViQqhmgMS6jkawYz4CndszY1iai4J1Z/lbV1bscuuOIynhbrYG+o5GqHs+mptbPUfX19TScgr63OZyLDEYTwrHI1ZqDf7aU33Uv2kCLQqtrq/27Cew0hskxjw0Fc3135M5FlXlfGscC022FS3V7DdNYNTB5O/JZ8aag4fC6R7qakurlD9bsGsDea1Ze9NeFniMJ4V6cYs2HpFUWkR76x654ikAdAhoUOz3UuRWIE3mLqQ19fnOsTqNKFhXVXGsyK9h0ew3TV5n+VRXlV+xDFBuDj74mYbK7d9wo+G9bmsThM6EUkcIvKCiOwQkW/rHOsmInNFZI3/366NPPYG/zlrROSGSMRrvCHSjVmwjXlD5yvKypKVzT6X2za2CnXtxwlWpwmdSF1xvAScV+/Yr4APVTUL+NB/+wgi0o3aPcpHAbnA7xpLMCb2RLoxC7Yxb03j78ZP+F5fn8ttV3FeFpHEoaoLgN31Dl8EvOz//mXg4gYeOh6Yq6q7VfUHYC5HJyATwyLZmAXbmLem8Y9UUnTT2lXh5rarOC+L2FpVIpIJvKeqQ/y396hqF//3Avxw6Hadx9wPtFPV//bf/i1wQFUfauq5bK0qEy7B7lIYiV0NW1rwdfO6XOEQa79vsIJZq8oVicN/+wdV7VrvMQEnDhGZCEwEyMjIGLlx48Zw/SrGuEZrGsNgF4eMBpHantiLvLLI4XYR6Q3g/3dHA+cUA3Vf1b7+Y0dR1RmqmqOqOampqSEP1jQtlro83KSxgu+PXvtRs69FY33+b33/VsRev0DeN6F8b3m9TuMWTl5xTAF2qeqfReRXQDdVnVzvMd2AfGCE/9BXwEhVrV8vOYJ1VUWWdQE4J/fZXJZsWdLo/U29Fg1dcUDtkOEu7bqE/fUL5H1j763GqSq1vfyh4borDhF5HVgEZIvIZhH5GfBn4FwRWQOc47+NiOSIyHMA/gTxR2CJ/+sPzSUNE3k2zNE5DRV862rqtThUvI+r1wwoGpHXL5D3jb23jrZicynXP7+Y977Z6lgMEZk5rqpXN3LX2Q2cuxT4eZ3bLwAvhCk0EwI2zNE5k0dPZuaKmUc0rvU19Foc6utPT07ngO8AB30Hm31MqAXyvlmwaYG9t/zW7dzHw3NX83/fbKVrhwQuHp7mWCy25IhptWhZjsKLDg3bPVTwPeA7wMqdK/Gp7/A59V+L+t0/9a84GnpMODT3vikqLaKgpOCox8VLfEy9t7aVHuTxD9fw1tIiEuPjuOusAfx87LF0btf4lWa42daxptUa64f+4NoPePWbVz27LpAb1jUKNoZAagJN1TYUjVgdoblY73z/TqblT8NX4zvicYltEllz5xpPvZdaYk95Jc/MX8tLn2+gRpVrRx3D7WcOIDUpMSzP58rhuJFkiSPy6g9zvG7odZw/83zPFjXdUJRtaQzNDTltrKDeo2MPMpMzIzpMtalYG4tzWM9hLJu0LOyxOaW80seLn21g2idr2Vfh45IT07j3nIGkd+sQ1ucNJnFYV5UJiforrd75/p1hX901nCKxOm24Ymhu1dvGuoiuGHxFxF+bpmJtLM4xGWMiFV5EVfpqeHPJJh7/sJCSfRWcc1xPHhifTXavJKdDO4qtjmvCwusFczfEH64Y3LgOVkO8Emdr1dQo73xdzDmPfMJv//kdx6Z05O+3ncJzN+S4MmmAJQ4TJl5fF8gN8QcaQ7AT5Lyy0q1X4mwpVeWjVduZ8MSn3PPmMjomxvPiTSfx5q0nM/KYbk6H1ySrcZiwcEONoDXcEL9NkIteSzbsJm/WKpZs+IGMbh24b9xALhzah7i40E3oC5YVxy1xuILX1wVyQ/zNxRCL60152apte5kyq4APV+0gNSmRu87O4sqcdNrGO9/5Y4nDEoeJEY2NPMrtk8viWxY7EJFpyKZd5Tw6bzXvLCumU2I8t53RnxtPzaRD2xCMT+rcGcrKjj6elAR79wb8Y2xUlTExIiSTL0PU8Jij7SyrYOpHa3jty03EiTBx7LHcdnp/unRoG7onaei1a+p4CFjiMMbD6i850qKRRw40PNFu78EqZnyyjucXrqeyuoYrT0rnrrOy6JXczunQQsIShzEeVn/JES/WkqLJwapqXlm0gafnr2VPeRUXDO3NfeOy6ZfS0enQQsoShzFhEMnlSpqb8GfCz1ddw9/yN/PYvDVs23uQ0wem8sD4bIakJTsdWlhY4jAmxOoPkV22bRkzV8y0IbJRSFX54NttPDS7gHUl+zkxowuPXjmcU/p3dzq0sLLEYUyIuWG5EhNeqsrCwhLyZhWworiUrB6dmH79SMYN7hnSzZUCkpTU+OCGMLHEYUyIuWG5kqA40PBEVIhHjS0r2kPerFV8vnYXaV3a89Dlw7jkxDTaODV5z4GRb5Y4jAkxz+1PEu1DbkM0aqxwRxkPzV7NrO+20b1jW/7zgsFce3IGifFtQhCktzg2XVFEskVkWZ2vvSJyT71zzhCR0jrn/KdT8RoTqFhZnK85wa6h5VbFew7wwF+XM+7RBSwsLOHecwbyyeQzufm0fjGZNMAlM8dFpA1QDIxS1Y11jp8B3K+qFwTz82zmuHGaG5YrcZKr1tBqqubQRPu3e38lT31cyF8WbQSBn558DL84cwDdOoZw8p6LeHHm+NnA2rpJwxgvi/Uhsl4eILCvwsfzn67n2U/XUV7p47KRfbn7nIGkdWnvdGiu4ZbEcRXweiP3nSIiy4Et1F59fBe5sIwxLeG5AQJAha+a1xZvYupHhezaX8l5x/fi/vEDGdAjSgYJhJDjiUNE2gI/Bn7dwN1fAceo6j4RmQC8A2Q18nMmAhMBMjIywhStcZob9gE3zXPVAIFmRo1V1yhvf13Mo3NXU7znAKcc251/O38Qw9O7RDhQ73C8xiEiFwG3q+q4AM7dAOSoaklT51mNIzq5qt/cayK8kKEXXitVZe7325kyu4A1O/ZxQloyk8/L5rQBKZGfi+ECXqtxXE0j3VQi0gvYrqoqIrnUjgLbFcngjHt4ud/ccRFeyNDta2gtWruLvNmr+HrTHvqldOSpa0Zw/pBejm6k5CWOJg4R6QicC9xa59gkAFWdBlwG3CYiPuAAcJU6fYnkJVG2XLYX+81Dzi2vaQBxuHGAwLfFpeTNLmDB6p306tyOP196ApeN7Et8G+c3UvISRxOHqu4Hutc7Nq3O91OBqZGOK2pE2XLZruo3d4pbXlO3xBGg9SX7eXhOAe99s5Xk9gn8+4RB/PSUTNolxOY8jNZyQ1eVMQEJyd4TJqZs33uQxz9cw5tLimjbJo7bz+zPxLH9SW6f4HRonmaJw3hGJPvNbfSWt5WWV/HMJ2t56fP1VNco147K4I6zBtAjKTo2UnKa46OqwsFGVfm1cMZsrHP1iKCWvqahro249L11oLKaFz9fz7T5aymr8HHRsD788txsMrp3cCymw9xSn2qE10ZVGeMqUTl6ywUNUzhVVdfw5pIinvhwDTvKKjh7UA/uH5/Ncb07Ox3av3isLtQUSxzRLNqXyw4TV4/ecstr6pI4amqU//1mC4/MXc3GXeWclNmVp68dQU5mt4jGEWsscUSzKP+UGS6uGL3VVLeGG7oZHX5vqSrzV+8kb1YBK7fuZVCvJF64MYczs3vE5OS9SLPEYVzDLQVpV4zeioZujTD16edv3M2Dswr4cv1uMrp14PGrhnPh0D42eS+CrDhuXMFtBWnHl0V3afE5KCH+HQq2lTFldgHzVm4npVMid509gKtOyqBtvEcm77n8NbXiuPEctxWk3TjruUkuH7HTGkW7y3l03mre/rqYTonxPDA+m5tGZ9KhrceaL5fUhULBY395E61cXZD2gmjo2qpnZ1kFT31cyMzFG4kTYeLYY7nt9P506eDRjZQ8nsDrssRhXMEVBelgRPEn/JDo3PJhsHsPVvHcgnU8t3A9Fb4arshJ5+6zs+iVbJP33MISh3EFVxSkgxHuT/he79Zowd/hYFU1f1m0kafnF/JDeRUXDO3NL88dyLGpncIQoGkNSxzGFdy+DHfERfNVS73k56uu4e9fbeaxeWvYWnqQMVkpTB4/iBP6JjsUoGmOJQ7jGp4rSJuW8SdFVWXWt9uYMqeAdTv3Mzy9Cw9fMYxT+6eE5nmsOzFsGk0cIvI+8AtV3RC5cIwxLeKxrq3PCkt4cNYqvtlcyoAenZh+/UjGDe4Z2sl7UThgwC2auuJ4EZgjIi8Deapa1cS5xhgneeQT9PJeWUx5bjELC0tI69KeKZcN5dIRfWljk/c8pdHEoap/FZEPgN8CS0XkL0BNnfsfiUB8xriTxz7hR1y9v09ht748PPZ6PsgeTbete/ntBYO5dlSGbaTkUc3VOCqB/UAikESdxBEqIrIBKAOqAV/9mYtSe+36ODABKAduVNWvQh2HMUHxyCd8x/j/Plv2HODxeWv4a34R7RPacNeYY7llTD+S2rVwI6VI1C2sNtKspmoc5wGPAO8CI1S1PIxxnKmqJY3cdz6Q5f8aBTzj/9cY41I/7K/k6fmFvLxoIyjceGo/bj+zP907Jdae0NLGORJ1C6uNNKupK47fAJer6neRCqYRFwGvaO2iWl+ISBcR6a2qWx2OyxhTz/4KHy8sXM+MBevYX+njkhP7cu+5WfTtWm8jpUg0ztadGDZN1TjGRCgGpbYIr8B0VZ1R7/40oKjO7c3+Y0ckDhGZCEwEyMjICF+0xgQqhro8Kn01vP7lJp78aA0l+yoZN7gn94/PZmBPBxvpKPsbu4kb5nGcpqrFItIDmCsiq1R1QbA/xJ9wZkDt6rihDtI4xMuNbwx0eVTXKP9cVswjc1ez+YcDnHxsN2b8dBAjMro6HZoJI8cTh6oW+//dISJvA7lA3cRRDNSdPtzXf8zEghhofL1IVflw5Q6mzC6gYHsZx/fpzJ8uOYGxWSm2kVIMcDRxiEhHIE5Vy/zfjwP+UO+0d4E7ROQNaovipVbfMMY5i9ftIm92Afkbf6BfSkemXnMiE4b0jsxGSpGoW1htpFlOX3H0BN72f0KJB15T1VkiMglAVacB71M7FLeQ2uG4NzkUq4lWXu4Oi6DvtpQyZXYB8wt20rNzIn+6ZAhX5KST0KYFGym1tHGOxOthr3mzHE0cqroOGNbA8Wl1vlfg9kjGZWKMdYc1aeOu/Tw8ZzXvLt9CcvsEfn3+IG44NbN1k/escfY0p684jIleHu/y2LH3IE98tIY3viwivo1w+5n9mTi2P8ntWzh5z0QNSxzG3bzc+Hr0U3XpgSqmf7KWFz5bj69auTo3gzvPGkCPzraRkqllicO4m0cbXy/WTQ5UVvPS5xuY9sla9h6s4qJhfbj33IEc072j06EZl7HEYUw4eKhuUlVdw1tLi3h83hp2lFVwZnYqD4wfxOA+Ld/+1UQ3SxzGxKiaGuW9FVt5ZE4BG3aVk3NMV6ZeM4Lcft2cDs24nCUOY2KMqvLJ6p3kzSrg+617GdQriedvyOGsQT1s8p4JiCUOY2JI/sYfyJu1isXrd5PerT2PXTmcC4f1sY2UTFAscRgTjeoV51enZDBlzPXMHXgKKZ3a8l8/Pp6rczNoG9+CyXsm5lniMCYcnB5G7H/uzZ1TefS0a/nHkLPoVHmA+xb8hZs/fpWOifZf37ScvXuMCVUj76IhuCUdknnqlCuYOXwCoNzy5dvc9sXf6HqwDBLfiGgsJvpY4jAmVI26C4bglh2s4rlP1/PcxGc5kJDI5Svmcfdnr9OnrLENNh3gogR7mBtjcjFLHMZEgYNV1cxcvImnPi5k9/5KJqz/il9++ioDdm92OrSjuSDBBvzcLpx34waWOIzxMF91Df/4upjH5q5mS+lBxmSl8MD4bIamX+B0aCaKWeIwxmkt6CZRVWZ/t52H5hRQuGMfw/omM+XyYYwekPKvx3p1jS/jepY4jHFakN0kn68t4cFZBSwv2kP/1I5Mu24E44/vdeTkPeuXN2FkicM0zIqFwQvHp/w6yWBFz/7knf0zPk0fSp/kduT9ZCiXjkgjviUbKbWGvTdinmOJQ0TSgVeo3QVQgRmq+ni9c84A/gms9x/6h6rW31rWhIMVC4MXpkZzbbc0HhlzHf83aAxdy0v5jx8dx3UnH9O6jZRao7XvDTd2o7kxJhdz8orDB9ynql+JSBKQLyJzVfX7eud9qqpW6TMxZ1un7jw++mreGnouib5K7vrsNW758m2SnigP/5M3dVXRWm68KnFjTC7mWOJQ1a3AVv/3ZSKyEkgD6icOY2LKD+2SmHbyZbw04gJq4uK4/qv/445Fb5JSXhq5IOyK0zTBFTUOEckETgQWN3D3KSKyHNgC3K+q30UwNGPCz99Nsj+hHS/m/Jjpo37CvrbtufTbj7hn4Wuk793hdITGHMHxxCEinYC/A/eoav3rxa+AY1R1n4hMAN4Bshr5OROBiQAZGRlhjNiY0KrcvYc3lmziiQ8LKdlXwbmDe3L/fZeRXbLR6dCMaZCoqnNPLpIAvAfMVtVHAjh/A5Cjqk2un5CTk6NLly4NTZCxykbOhF1NjfLu8i08PLeAot0HGNWvG5PPG8TIY7o6//dval+OpgrJrY3N6d87holIvqrmBHKuk6OqBHgeWNlY0hCRXsB2VVURyQXigF0RDDN22X/SsFFVPlq1gymzC1i1rYzBvTvz8s0nMDYr5V9zMdz89w9nbFZb8QQnu6pGA9cDK0Rkmf/YvwMZAKo6DbgMuE1EfMAB4Cp18hLJmFZasmE3D36wiqUbfyCzeweevPpEfnRCb+IivZFSc5/sbXiqaYKTo6oWAk3+b1HVqcDUyERkTPis3LqXKbML+GjVDlKTEvnvi4dw5UnpJER68t4hzX2yd/MVj3Gc48VxY6LZpl3lPDK3gH8u30JSYjyTz8vmxlMz6dDW/usZ77J3r4k+Liiw7ig7yJMfFvL6l5uIbyNMOr0/k8b2J7lDQkSe35hwssRhoo+DBdbSA1XMWLCWFxZuoKq6hqty07nrrCx6dG4X9ud2VKiStdVWPMEShzEhcLCqmpc/38DT89dSeqCKC4f14b5zB5KZ0tHp0CIjVMnaaiueYInDmFbwVdfw1/zNPD5vDdv2HuSM7FTuH5fNkLRkp0Nrmn2yN61gicOYpjTSBVOT1JkPFq7i4TkFrCvZz4iMLjx21XBOPra7A0G2gH2yN61gicOYptRLGgp8mnkiU8b+lBWvfUV2zySe/WkO5xzX48iNlIyJYpY4TPQJUzfM170Hknf6DSw6Zhh992zj4cuHcfGJabSJ9OQ9YxxmicNEnxB3w6zpns5DY65ndvapdN+/h9/PncbVy2eROK0qpM8TMBcMN27wua1mEjMscRjTiOI9B3js/Lv5+5Cz6FBVwS8/fZWbl/6TTpUHnA3Mjes5Wc0kpljiMKaeXfsqeHr+Wv6yaCMMPp2bl77LL774K90OWONoDFjiMOawfRU+nvt0Hc99up7ySh+Xj0zn7rt+TJ+tDeyLYV0wJoZZ4jAxr8JXzcwvNjH140J276/k/CG9uG/cQAb0SILLNjgdXnRxY33GBM0Sh/GGMDQ41TXKP77azGPz1lC85wCjB3TngfGDGJ7epZXBBiBWG1A31mdM0CxxGG8IYYOjqsz5fjsPzS5gzY59DO2bzIM/GcppWSmtDDIIrfl9bASTcZglDhNTFq3dxYOzVrGsaA/HpnTk6WtHcP6QXt6avBfNVyTGEyxxmCNFaRfKt8Wl5M0uYMHqnfTq3I4Hf3ICPxnRl3inNlIyxsMcTRwich7wONAGeE5V/1zv/kTgFWAktXuNX6mqGyIdZ0yJsj7o9SX7eXhOAe99s5UuHRL4zYTjuP6UY2iX0Mbp0IIXpUndeI9jiUNE2gBPAecCm4ElIvKuqn5f57SfAT+o6gARuQp4ELgy8tGakIlQ47et9CCPf7iGt5YW0bZNHHeeNYBbxh5L53Ye3kgpGpK61WeigpNXHLlAoaquAxCRN4CLgLqJ4yLg9/7v/wZMFRFRVY1koCaEWtr4Bdjg7Cmv5JlP1vLSZxuoUeXaURnceVYWqUmMU3JtAAANbklEQVSJLQw4TGK1AbUro6jgZOJIA4rq3N4MjGrsHFX1iUgp0B0oiUiExj2aaXAOVFbz4ufrmTZ/LWUVPi4Znsa95w4kvVuHCAUYJGtAjYdFTXFcRCYCEwEyMjIcjsZESlV1DW8sKeKJD9ews6yCc47rwf3jsxnUq7PToRkTtZxMHMVAep3bff3HGjpns4jEA8nUFsmPoqozgBkAOTk51pXVUh7pQqmpUf73my08Mnc1G3eVc1JmV565dgQ5md2cDs2YqOdk4lgCZIlIP2oTxFXANfXOeRe4AVgEXAZ8ZPWNMHN5F4qqMr9gJ3mzC1i5dS+DeiXx4o0ncUZ2qrfmYrSER5K6iX6OJQ5/zeIOYDa1w3FfUNXvROQPwFJVfRd4HviLiBQCu6lNLsaLGhtNdUgAjd/SDbvJm1XAlxt2k9GtA49fNZwLh/YhLlY2UnJ5UjexQ6LxA3xOTo4uXbrU6TBMXU1dDTTzHly1bS8PzS5g3sodpCYlctfZWVyZk07b+BibvGfzOEwYiUi+quYEcm7UFMdN9Nm0q5xH563mnWXFdEqM54Hx2dw0OpMObWP0bRsN8zhMVIjR/4HGzXaWVTD1ozW89uUm4kS4dWx/Jp1+LF06tHU6NGMMljiMi+w9WMWzC9bx/ML1VPhquCInnbvPzqJXcjunQzPG1GGJwzjuYFU1ryzawNPz17KnvIoLhvbmvnHZ9Evp6HRoxpgGWOIwkdHAUFKfxPG3ky7gsSnz2bb3IGMHpjJ5fDZD0pIdCtIYEwhLHCYy6oz6UVU++HYbD80pYN3O/ZzYpR2PXjmcU/p3dzBAD7B5HMYlLHGYiFq4poQHZ61iRXEpWT06MeP6kZw7uGf0T94LBRtya1zCEoeJiOVFe8ibvYrPCneR1qU9D10+jEtOTKONWybv2RwJYwJmicOEVeGOMh6avZpZ322je8e2/O7CwVwzKoPEeJdtpGRzJIwJmCUOsE+bYbBlzwEem7eav+VvpkPbeO45J4ufjzmWTokx9paz95aJQjH2v7gR9mkzZHbvr+Tpjwt55YuNoHDT6H784oz+dO/kso2U6uocxiXY7b1lopAlDhMS+yt8PL9wPTMWrKO80selI/py77kDSevS3unQmmeNuDFBscRhWqXCV83rizcx9eNCSvZVMv74ntw/LpusnjZE1JhoZYnDtEh1jfLPZcU8Mnc1m384wCnHdufZn2ZzYkZXp0MLLZsjYcxRLHGYoKgq81buYMrsVazevo8haZ35n0tP4LQBKdE7F6Oh38uK2yaGWeIAm5EboMXrdvHgrFV8tWkP/VI6MvWaE5kwpHd0b6TU2uK2vbdMFLLEAfbJsRnfbSllyuwC5hfspGfnRP7n0hO4bGRfEtpEyUZKTTXurS2c23vLRCFHEoeITAEuBCqBtcBNqrqngfM2AGVANeALdHcqExobSvbz8NzV/O/yLSS3T+DX5w/ihlMzaZfgwOS9cM6HaOrx0dr9ZkwrOHXFMRf4tX/f8QeBXwP/1si5Z6pqSeRCM9v3HuSJD9fw5pIiEtrEcfuZ/Zk4tj/J7ROcC8rmQxjjGo4kDlWdU+fmF8BlTsRhjlRaXsW0BWt58bP1+KqVa0ZlcMdZA+iRZBspGWP+xQ01jpuBNxu5T4E5IqLAdFWdEbmwYseBympe+nwDz8wvpKzCx8XD07j3nIFkdO/gdGjOs+K2MUcJW+IQkXlArwbu+o2q/tN/zm8AHzCzkR9zmqoWi0gPYK6IrFLVBY0830RgIkBGRkar448FVdU1vLmkiCc+XMOOsgrOHtSD+8dnc1zvMC7B4TVW3DbmKGFLHKp6TlP3i8iNwAXA2aqqjfyMYv+/O0TkbSAXaDBx+K9GZgDk5OQ0+PNMrZoa5b0VW3lkTgEbdpVzUmZXnrp2BCdldnM6NGOMBzg1quo8YDJwuqqWN3JORyBOVcv8348D/hDBMKOOqvLJ6p3kzSrg+617GdQriRdvPIkzslPdP3nPuoyMcQ2nahxTgURqu58AvlDVSSLSB3hOVScAPYG3/ffHA6+p6iyH4vW8/I27eXBWAV+u301Gtw48ftVwLhzaxzuT96zLyBjXcGpU1YBGjm8BJvi/XwcMi2Rc0ahgWxlTZhcwb+V2Ujol8oeLjueqkzJoGx8lk/caY/tgGBM2bhhVZcKgaHc5j85bzdtfF9OpbTwPjM/mptGZdGgbIy+5zfswJmxipBWJHTvLKnjq40JmLt5InAi3jDmW207vT9eObZ0OzRgTJSxxRImyg1U8u2Adzy1cT4Wvhity+nLX2Vn0TvbARkrGGE+xxOFxB6uqefWLjTz1cSE/lFcx4YRe3Dcum/6pnZwOzRgTpSxxeJSvuoZ/fFXMY/NWs6X0IGOyUnhgfDZD+3ZxOjRjTJSzxOExqsrs77YxZXYBa3fuZ1h6Fx66fBinDkhxOjR3sXkfxoSNJQ4P+bywhAdnF7C8aA8DenRi2nUjGH98L/dP3nOCDbk1JmwscXjAN5v3MGV2AZ+uKaFPcjvyLhvKpSemER8tGykZYzzFEoeLrd25j4fnFPD+im107ZDAf/zoOK47+RhnNlIyxhg/SxwutLX0AI/PW8Nf8zfTLj6Ou8/O4udj+pHUzsGNlIwxxs8Sh4v8sL+Sp+cX8vKijaDw01OO4fYzB5DSKdHp0Iwx5jBLHC6wv8LHCwvXM2PBOvZX+rh0RF/uOSeLvl1tIyVjjPtY4nDY54Ul3PXG15Tsq2Tc4J7cPz6bgT1tyKgxxr0scTisX2pHBvdJ5p5zshiR0dXpcIwxplmWOBzWO7k9r9yc63QYxhgTMJsIYIwxJiiWOIwxxgTFkcQhIr8XkWIRWeb/mtDIeeeJSIGIFIrIryIdpzHGmKM5WeN4VFUfauxOEWkDPAWcC2wGlojIu6r6faQCNMYYczQ3d1XlAoWquk5VK4E3gIscjskYY2Kek4njDhH5RkReEJGGxqGmAUV1bm/2H2uQiEwUkaUisnTnzp2hjtUYY4xf2BKHiMwTkW8b+LoIeAboDwwHtgIPt/b5VHWGquaoak5qamprf5wxxphGhK3GoarnBHKeiDwLvNfAXcVAep3bff3HjDHGOMiR4riI9FbVrf6blwDfNnDaEiBLRPpRmzCuAq4J5Ofn5+eXiMjGkAQbGSlAidNBtIDFHTlejBks7khqbczHBHqiU6Oq8kRkOKDABuBWABHpAzynqhNU1ScidwCzgTbAC6r6XSA/XFU91VclIktVNcfpOIJlcUeOF2MGizuSIhmzI4lDVa9v5PgWYEKd2+8D70cqLmOMMc1z83BcY4wxLmSJwx1mOB1AC1nckePFmMHijqSIxSyqGqnnMsYYEwXsisMYY0xQLHG4hIj80T+TfpmIzPGPMHM9EZkiIqv8sb8tIl2cjqk5InK5iHwnIjUi4vqRM15c7NO/IsQOEWloqL0riUi6iHwsIt/73x93Ox1TIESknYh8KSLL/XH/V9if07qq3EFEOqvqXv/3dwGDVXWSw2E1S0TGAR/5h08/CKCq/+ZwWE0SkeOAGmA6cL+qLnU4pEb5F/tcTZ3FPoGr3b7Yp4iMBfYBr6jqEKfjCYSI9AZ6q+pXIpIE5AMXe+BvLUBHVd0nIgnAQuBuVf0iXM9pVxwucShp+HWkdo6L66nqHFX1+W9+Qe0Mf1dT1ZWqWuB0HAHy5GKfqroA2O10HMFQ1a2q+pX/+zJgJU2sj+cWWmuf/2aC/yus7YclDhcRkT+JSBFwLfCfTsfTAjcDHzgdRJQJarFPExoikgmcCCx2NpLAiEgbEVkG7ADmqmpY47bEEUHNLPyIqv5GVdOBmcAdzkb7L83F7T/nN4CP2tgdF0jMxjRERDoBfwfuqdcT4FqqWq2qw6m94s8VkbB2Dzq5kVPMCXThR2ob3/eB34UxnIA1F7eI3AhcAJytLimaBfG3djtb7DOC/DWCvwMzVfUfTscTLFXdIyIfA+fR8BqAIWFXHC4hIll1bl4ErHIqlmCIyHnAZODHqlrudDxR6PBinyLSltrFPt91OKao5C8yPw+sVNVHnI4nUCKSemg0o4i0p3YgRVjbDxtV5RIi8ncgm9rRPhuBSarq+k+WIlIIJAK7/Ie+cPtoMBG5BHgSSAX2AMtUdbyzUTVORCYAj/GvxT7/5HBIzRKR14EzqF2xdTvwO1V93tGgmiEipwGfAiuo/X8I8O/+NfNcS0SGAi9T+/6IA95S1T+E9TktcRhjjAmGdVUZY4wJiiUOY4wxQbHEYYwxJiiWOIwxxgTFEocxxpigWOIwJsz8q66uF5Fu/ttd/bcznY3MmJaxxGFMmKlqEfAM8Gf/oT8DM1R1g2NBGdMKNo/DmAjwL2WRD7wA3AIMV9UqZ6MypmVsrSpjIkBVq0TkAWAWMM6ShvEy66oyJnLOB7YCntjYyJjGWOIwJgJEZDi1i8+dDNzr323OGE+yxGFMmPlXXX2G2v0dNgFTgIecjcqYlrPEYUz43QJsUtW5/ttPA8eJyOkOxmRMi9moKmOMMUGxKw5jjDFBscRhjDEmKJY4jDHGBMUShzHGmKBY4jDGGBMUSxzGGGOCYonDGGNMUCxxGGOMCcr/A37YV5aDpE94AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weights0 = stocGradAscent0(dataArr, labelMat)\n",
    "plotBestFit(dataArr, labelMat, weights0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weights1 = stocGradAscent1(dataArr, labelMat)\n",
    "plotBestFit(dataArr, labelMat, weights1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.],\n",
       "       [1.],\n",
       "       [1.]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones((3,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.4rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}