diff --git a/1Numpy 基础.ipynb b/1Numpy 基础.ipynb new file mode 100644 index 0000000..8179a6f --- /dev/null +++ b/1Numpy 基础.ipynb @@ -0,0 +1,1169 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Numpy 基础" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "在这节课中，我们将会学习到 Numpy 的相关内容。\n", + "\n", + "`NumPy（Numerical Python）`是一个开源的 **Python** 科学计算库，用于快速处理任意维度的数组。\n", + "\n", + "对于同样的数值计算任务，使用 `NumPy` 比直接使用 **Python** 要简洁的多。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `ndarray` 介绍" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`NumPy` 提供了一个`N` 维数组类型 `ndarray`，它描述了**相同类型**的 `items` 的集合。\n", + " \n", + "|语文|数学|英语|政治|体育|\n", + "|--|--|--|--|--|\n", + "|80|89|86|67|79|\n", + "|78|97|89|76|81|\n", + "\n", + "用 `ndarray` 进行存储：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# 创建ndarray\n", + "score = np.array([[80, 89, 86, 67, 79],[78, 97, 89, 67, 81]])\n", + "\n", + "# 打印结果\n", + "score\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `ndarray` 的属性 \n", + "数组属性反映了数组本身固有的信息。\n", + "\n", + "|属性名字|\t属性解释|\n", + "|--|--|\n", + "|ndarray.shape|\t数组维度的元组|\n", + "|ndarray.ndim|\t数组维数|\n", + "|ndarray.size|\t数组中的元素数量|\n", + "|ndarray.dtype|\t数组元素的类型|\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ `shape`：数组形状" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# 创建不同形状的数组\n", + "a = np.array([[1, 2, 3],[4, 5, 6]])\n", + "b = np.array([1, 2, 3, 4])\n", + "c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n", + "\n", + "# 分别打印出形状\n", + "print(a.shape)\n", + "print(b.shape)\n", + "print(c.shape)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ `ndim`:数组维数" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# 创建不同形状的数组\n", + "a = np.array([[1, 2, 3],[4, 5, 6]])\n", + "b = np.array([1, 2, 3, 4])\n", + "c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n", + "\n", + "# 分别打印出维数\n", + "print(a.ndim)\n", + "print(b.ndim)\n", + "print(c.ndim)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ `size`：数组元素数量" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# 创建不同形状的数组\n", + "a = np.array([[1, 2, 3],[4, 5, 6]])\n", + "b = np.array([1, 2, 3, 4])\n", + "c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n", + "\n", + "# 分别打印出数组元素数量\n", + "print(a.size)\n", + "print(b.size)\n", + "print(c.size)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ `dtype`：数组元素的类型" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# 创建不同形状的数组\n", + "a = np.array([[1, 2, 3],[4, 5, 6]])\n", + "b = np.array([1, 2, 3, 4])\n", + "c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n", + "\n", + "# 分别打印出数组元素数量\n", + "print(a.dtype)\n", + "print(b.dtype)\n", + "print(c.dtype)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：把二维数组 [[1, 2, 3],[4, 5, 6],[7,8,9]] 转为 ndarray 格式。并查看其形状、维数和元素数量。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "a = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])\n", + "print(a)\n", + "print(a.shape)\n", + "print(a.ndim)\n", + "print(a.size)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `ndarray` 的类型\n", + "\n", + "|名称|描述|\n", + "|--|--|\n", + "|np.bool|用一个字节存储的布尔类型（True或False）|\n", + "|np.int8|一个字节大小，-128 至 127|\n", + "|np.int16|整数，-32768 至 32767|\n", + "|np.int32|整数，$-2^{31}$ 至 $2^{32} -1$|\n", + "|np.int64|整数，$-2^{63}$ 至 $2^{63} - 1$|\n", + "|np.uint8|无符号整数，0 至 255|\n", + "|np.uint16|无符号整数，0 至 65535|\n", + "|np.uint32|\t无符号整数，0 至 $2^{32} - 1$|\n", + "|np.uint64|\t无符号整数，0 至 $2^{64} - 1$ |\n", + "|np.float16\t|半精度浮点数：16位，正负号1位，指数5位，精度10位|\n", + "|np.float32\t|单精度浮点数：32位，正负号1位，指数8位，精度23位|\n", + "|np.float64\t|双精度浮点数：64位，正负号1位，指数11位，精度52位|\n", + "|np.complex64|复数，分别用两个32位浮点数表示实部和虚部|\n", + "|np.complex128|复数，分别用两个64位浮点数表示实部和虚部|\n", + "|np.object_|python对象|\n", + "|np.string_|字符串|\n", + "|np.unicode_|unicode类型| \n", + "\n", + "\n", + "**注意：创建数组的时候指定类型**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# 创建数组时指定类型为 np.float32\n", + "a = np.array([[1, 2, 3],[4, 5, 6]], dtype=np.float32)\n", + "\n", + "# 创建数组时未指定类型\n", + "b = np.array([[1, 2, 3],[4, 5, 6]])\n", + "\n", + "# 打印结果\n", + "print(\"数组a：\\n%s,\\n数据类型：%s\"%(a,a.dtype))\n", + "print(\"数组b：\\n%s,\\n数据类型：%s\"%(b,b.dtype))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": true + }, + "source": [ + "### 基本操作" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 生成元素值为 `0 ` 和 `1` 的数组的方法 \n", + "\n", + "+ 生成全部元素值为 `0` 的数组" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "zero = np.zeros([3, 4])\n", + "zero\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ 生成全部元素值为 `1` 的数组" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "one = np.ones([3, 4])\n", + "one\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ 生成对角数组(对角线的地方是 `1`，其余地方是 `0`)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eyes = np.eye(10, 5)\n", + "eyes\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ 创建方阵对角矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# np.eye(5, 5) 可简写为 (5)\n", + "eyes1 = np.eye(5)\n", + "eyes1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 从现有数组生成" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = [[1, 2, 3], [4, 5, 6]]\n", + "\n", + "# 从现有的数组中创建\n", + "a1 = np.array(a)\n", + "a\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 生成固定范围的数组" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 生成等间隔的数组\n", + "a = np.linspace(0, 90, 10)\n", + "a\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 生成等间隔的数组\n", + "b = np.arange(0, 90, 10)\n", + "b\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 形状修改" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import array\n", + "a = array([[ 0, 1, 2, 3, 4, 5],\n", + " [10,11,12,13,14,15],\n", + " [20,21,22,23,24,25],\n", + " [30,31,32,33,34,35]])\n", + "a.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 在转换形状的时候，一定要注意数组的元素匹配\n", + "# 只是将形状进行了修改，但并没有将行列进行转换\n", + "b = a.reshape([3, 8])\n", + "b\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 数组的形状被修改为: (2, 12), -1: 表示同过自动计算得到此处的值\n", + "c = a.reshape([-1, 12])\n", + "c\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "d = a.T\n", + "d.shape\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 类型修改" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[12, 3, 34], [5, 6, 7]]])\n", + "arr.dtype\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "arr.astype(np.float32)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：创建一个 3x3 并且值从0到8的矩阵\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "Z = np.arange(9).reshape(3,3)\n", + "print(Z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数组去重" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "arr = np.array([[1, 2, 3, 4],[3, 4, 5, 6]])\n", + "np.unique(arr)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数组运算\n", + "\n", + "数组的算术运算是元素级别的操作，新的数组被创建并且被结果填充。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "运算|函数\n", + "--- | --- \n", + "`a + b` | `add(a,b)`\n", + "`a - b` | `subtract(a,b)`\n", + "`a * b` | `multiply(a,b)`\n", + "`a / b` | `divide(a,b)`\n", + "`a ** b` | `power(a,b)`\n", + "`a % b` | `remainder(a,b)`\n", + "\n", + "以乘法为例，数组与标量相乘，相当于数组的每个元素乘以这个标量：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "a = np.array([1, 2, 3, 4])\n", + "a * 3\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "数组按元素相乘：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1, 2])\n", + "b = np.array([3, 4])\n", + "a * b\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用函数" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.multiply(a, b)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "函数还可以接受第三个参数，表示将结果存入第三个参数中：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.multiply(a, b, a)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：把二维数组 [[1, 2, 3],[4, 5, 6],[7,8,9]] 转为 ndarray 格式。并对每个元素 +1。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "a = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])\n", + "print(a+1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 矩阵 \n", + "使用 `mat` 方法将 `2` 维数组转化为矩阵：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "a = np.array([[1, 2, 4],\n", + " [2, 5, 3],\n", + " [7, 8, 9]])\n", + "A = np.mat(a)\n", + "A\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 也可以使用 **Matlab** 的语法传入一个字符串来生成矩阵：\n", + "A = np.mat('1,2,4;2,5,3;7,8,9')\n", + "A\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "矩阵与向量的乘法：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.array([[1], [2], [3]])\n", + "x\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A*x\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "b = np.array([[1, 2],\n", + " [3, 4],\n", + " [5, 6]])\n", + "B = np.mat(b)\n", + "A*B\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`A.I` 表示 `A` 矩阵的逆矩阵：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A.I\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "矩阵指数表示矩阵连乘：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A ** 4\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：分别把二维数组 [[1, 2] ,[3, 4]] 和 [5, 6] ,[7, 8]]转为 matrix 格式。并计算矩阵的乘积。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "a = np.mat([[1, 2],[4, 5]])\n", + "b = np.mat([[5, 6],[7, 8]])\n", + "print(a*b)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 统计函数" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "|方法|作用|\n", + "|--|--|\n", + "|`a.sum(axis=None)`|求和|\n", + "|`a.prod(axis=None)`|求积|\n", + "|`a.min(axis=None)`|最小值|\n", + "|`a.max(axis=None)`|最大值|\n", + "|`a.argmin(axis=None)`|最小值索引|\n", + "|`a.argmax(axis=None)`|最大值索引|\n", + "|`a.ptp(axis=None)`|最大值减最小值|\n", + "|`a.mean(axis=None)`|平均值|\n", + "|`a.std(axis=None)`|标准差|\n", + "|`a.var(axis=None)`|方差|" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "from numpy import array\n", + "a = array([[1, 2, 3],\n", + " [4, 5, 6]])\n", + "a\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "求所有元素的和：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sum(a)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a.sum()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**指定求和的维度**：\n", + "沿着第一维求和" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.sum(a, axis=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a.sum(axis=0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "沿着第二维求和：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.sum(a, axis=1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a.sum(axis=1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "沿着最后一维求和：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.sum(a, axis=-1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a.sum(axis=-1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：创建一个长度为30的随机向量并找到它的平均值\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "Z = np.random.random(30)\n", + "m = Z.mean()\n", + "print(m)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 比较和逻辑函数" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "运算符|函数|\n", + ":---: | :---: \n", + "`==` | `equal`\n", + "`!=` | `not_equal`\n", + "`>` | `greater`\n", + "`>=` | `greater_equal`\n", + "`<` | `less`\n", + "`<=` | `less_equal`\n", + "\n", + "数组元素的比对，我们可以直接使用运算符进行比较，比如判断数组中元素是否大于某个数：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import array\n", + "a = array([[ 0, 1, 2, 3, 4, 5],\n", + " [10,11,12,13,14,15],\n", + " [20,21,22,23,24,25],\n", + " [30,31,32,33,34,35]])\n", + "\n", + "a > 10\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 判断数组中元素大于10的元素赋值为 -10 \n", + "a[a > 10] = -10\n", + "a\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "但是当数组元素较多时，查看输出结果便变得很麻烦，这时我们可以使用`all()`方法，直接比对矩阵的所有对应的元素是否满足条件。假如判断某个区间的值是否全是大于 `20`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import array\n", + "a = array([[ 0, 1, 2, 3, 4, 5],\n", + " [10,11,12,13,14,15],\n", + " [20,21,22,23,24,25],\n", + " [30,31,32,33,34,35]])\n", + "\n", + "a[1:3,1:3]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.all(a[1:3,1:3] > 20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用 `any()` 来判断数组某个区间的元素是否存在大于 `20`的元素:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.any(a[1:3,1:3] > 20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：把二维数组 [[1, 2, 3],[4, 5, 6],[7,8,9]] 转为 ndarray 格式。判断是否全部大于 0。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "a = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])\n", + "print(np.all(a > 0))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `IO` 操作" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`savetxt` 可以将数组写入文件，默认使用科学计数法的形式保存：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "data = np.array([[1, 2],\n", + " [3, 4]])\n", + "\n", + "# 保存文件\n", + "np.savetxt('out.txt', data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 读取文件\n", + "with open('out.txt') as f:\n", + " for line in f:\n", + " print(line)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 读取文件\n", + "np.loadtxt('out.txt')\n" + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/2Matplotlib 基础.ipynb b/2Matplotlib 基础.ipynb new file mode 100644 index 0000000..aecee34 --- /dev/null +++ b/2Matplotlib 基础.ipynb @@ -0,0 +1,832 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matplotlib 基础" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在这节课中，我们将会学习到 Matplotlib 的相关内容。\n", + "\n", + "通过 Matplotlib，我们可以仅编写几行代码，就生成直方图，折现图，散点图等，高效美观的展示我们的数据。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "导入 `matplotlib` 和 `numpy`：" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from numpy import *\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## plot 二维图" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "plt.plot(y)\n", + "plt.plot(x, y)\n", + "plt.plot(x, y, format_string)\n", + "```\n", + "\n", + "只给定 `y` 值，默认以下标为 `x` 轴：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = linspace(0, 2 * pi, 50)\n", + "plt.plot(sin(x));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "给定 `x` 和 `y` 值：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD6CAYAAABOIFvoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XlclWXex/HPj30TEMUNERRUTE1NNHOXRrOy1SmdMsumzLJlxqmpeWZ6mmaaxaZVbbOZlrF9MmfUyg210twwRRFFQFERFRAFEWS9nj84+jiECHjgPsvv/Xqd19zc3Dd8j6+J77nOfe7rEmMMSimlFICH1QGUUko5Di0FpZRS52gpKKWUOkdLQSml1DlaCkoppc7RUlBKKXWOloJSSqlztBSUUkqdo6WglFLqHC+rAzRW27ZtTXR0tNUxlFLKqWzdujXfGBN+seOcrhSio6NJSkqyOoZSSjkVETnQkOP07SOllFLnaCkopZQ6R0tBKaXUOVoKSimlztFSUEopdY5dS0FEvEVkST3f9xORpSKSLCILpMaP9tkzk1JKqYazWymIiD+wFRhbz2FTgGxjTD+gte3YuvYppZSygN3uUzDGlAKXi0hGPYclAAtt26uBMUBUHftW2CuXarjiskpSc4pIOVxIaUUVwf7ehNgewX5ehPh70z7Yj0Bfp7u9RSnVQC39X3cboNC2XQT0vMC+/yIi04HpAF26dGn+lG7AGMMPB0+SlFVASk4Ruw4Xsv/4aS62ZLe3pzA8ti3X9unI2Mva0zrQp2UCK6VaREuXQj4QYtsOsX0dVMe+/2KMmQ/MB4iPj7/Iny1Vn4qqar7aeYS3v9tHyuEiACJC/endKZibB0TQJyKYPp1CCPb3pqi0gqIzFRSWVlBUWklhaQW7cgr5OuUoaxbuwHORMKRbGOP7dOSa3u1p18rP4menlLpUYi720rCxP1AkwxgTe4Hv3QtcaYx5QES+BF4GutTeZ4xZdaGfHx8fb3Sai8YrLqvkk80HeXd9FodPltItPJD7hndjfJ8OhDXy1b4xhl05RXy18wjLUo6yL/803p7CPUOjeeTq7gT7eTfTs1BKNZWIbDXGxF/0uOYqBRHpCsw0xjx+3vd8qbl+0AVIBqYCPrX3mXpCaSk0TnFZJa+tyeCDjQc4daaSwV3DmD6iGwlx7fDwuPQPehlj2HusmHfW7eezrYdoE+jDE9f05LaBkXb5+Uop+7CsFJqblkLDbT1wgl9+up1DJ0q4rk9H7h/Zjf6Roc32+3ZmF/L7JbvYeuAEfSNCeOaGy4iPDmu236eUajgtBTdWUVXN3NUZzFudTqdQf16Z1L/F/jgbY1icnMNfvtrD0aIz3NS/E8/c0LvRb1EppeyroaWgny10MVn5p/nFp9vZfugkt14RwbM39qZVC77HLyLc1D+CsZe15421mbz1zT5+OHiCv08dRM8OrVosh1KqaXSaCxdhjOGTzQe5bs537M8/zbw7BvDS7f1btBDOF+Djxa/G9eSzGVdRVlHNra+vZ2XqMUuyKKUaTkvBBVRVG/5nUQpPfbGTAV1CWfaLEUy4vJPVsQDoHxnK4oeHE9MuiOkLknh9bQbO9palUu5ES8HJVVRV84tPt/Px5oM8NDqGBfdeSccQf6tj/ZcOIX589sBVTLi8E88vS+OXn27nTEWV1bGUUnXQawpO7ExFFTM//IHEPbk8dW0cM0bFWB3pgvy8PZkzuT892wfxwoq97M8/zdtT42kXrDe8KeVIdKTgpIrLKpn27hZWp+Xy3M19HLoQzhIRHk7ozlt3DSQ9t5ifvb2R/OIyq2Mppc6jpeCETpaUM+Xvm9icVcDLt/dnypAoqyM1yjW9O/DetMEcPlnK1H9sprC0wupISikbLQUnk3vqDJPnbyQ1p4g37ryCmwdEWB2pSQZ3DePNKQNJzz3FtHc3c7qs0upISim0FJxKcVklU/+xmQPHS3jnnkGM693B6kiXZHTPdsyZPIDth04yfUGSXnxWygFoKTiJyqpqHv7oB9Jzi3nrroEM797W6kh2cW3fjjz/036szzjOIx9vo6Kq2upISrk1LQUnYIzh2SWprE3L44839WFkj3CrI9nVTwd25g839WZl6jEe/1cy1dV6H4NSVtGPpDqBd9ZnsWDjAaaP7MYdV7rmIkNTr4qmuKyS55elEervzbM39bE6klJuSUvBwa3YdZTnvkxlfO8OPDU+zuo4zeqh0bGcOF3O29/tp3dECLfHR1odSSm3o28fObCd2YU89sl2Lo8I4eVJ/d1ifYInx8cxLLYNv/t3CjuzCy9+glLKrrQUHFTOyVJ+/v4WwgJ9ePvuePx9PK2O1CK8PD2YM3kA4UG+zPhgKwWny62OpJRb0VJwQGcqqrj/n0mUlFfxzj2D3G7t4zZBvrwx5Qryist49ONtVOmFZ6VajF1KQUT8RGSpiCSLyAIR+dH7HCIyWkTW2R6HRORuERkvItnn7e9pjzzO7q9f72FXThEvT+rvtmsQXN45lD/e1Jt1Gfm8uCLN6jhKuQ17jRSmANnGmH5Aa2Bs7QOMMWuNMcONMcOBHcA227feOLvfGOP2//WvSj3Ge99ncc/QaMZe1t7qOJaaNKgLPxvchdfXZrIs5ajVcZRyC/YqhQRgpW17NTDmQgeKSAAQa4zZYds1UUQ2i8jCukYY7uRo4Rme+DyZyzoG85vrXPuTRg31+xsvo19kKI//K5mM3GKr4yjl8uxVCm2Asx8VKQLqWxB4LJBo284EnjbGDAY6AqPqOkFEpotIkogk5eXl2SmyY6mqNjz2yTbKKquZe8cAfL3c48Lyxfh6efLGnVfg6+XBgx9s1akwlGpm9iqFfCDEth1i+/pCbgCW2rYLgFW27SygXV0nGGPmG2PijTHx4eGudTfvWa+vyWDT/gKevbE3MeFBVsdxKJ1C/Xllcn/Sc4t5fpnbv8OoVLOyVykkAuNs2wnAmroOsr09NIaat5gAZgGTRcQD6AOk2CmPU0nKKuCVxHRu7NeJnw7sbHUchzSiezhTr4rinfX72ZB53Oo4Srkse5XCh0CEiOyg5tV/poi8UMdxg4Bdxpgztq/nAdOATcAiY0yqnfI4jcKSCh77ZDsRof786ZY+uPlllXo9dW0c0W0CePxfyRTrVNtKNQtxtkXU4+PjTVJSktUx7MIYw8yPfmDFrmN8/uBQ+keGWh3J4W09UMBtb27g9vhI/jrxcqvjKOU0RGSrMSb+YsfpzWsWWpycw1c7j/L4NT21EBpoYFQY00fG8MmWQ6zec8zqOEq5HC0FixScLufZJan0iwzl/hHdrI7jVH45tjtxHVrx5MKdnNBpMJSyKy0Fizy3NJWi0gpmT+yLpxtMdGdPvl6evHh7P06WlPO/i3dZHUcpl6KlYIG1abl8se0wD42OIa5DsNVxnFLvTiE8dnV3liTnsHRHjtVxlHIZWgot7HRZJb9dlEJMeCAzE2KtjuPUZoyKoV9kKL/7dwp5p8qsjqOUS9BSaGF/W55GTmEpsydernctXyIvTw9evK0fJWVV/OWr3VbHUcolaCm0oB8OnuD9DVncNSSK+Oj6ZgJRDRXbLogHRnXji22H9aY2pexAS6GFlFdW89TCHXQM9uPXLr6sZkubOSaWyDB/nv5PCuWV1VbHUcqpaSm0kNfXZrD3WDF/uqUvQb66NLY9+Xl78ocb+5CRW8zf1+2zOo5STk1LoQVk5J7itTUZ3NS/E2Pi6pzzT12iMXHtuKZ3e+YkpnOooMTqOEo5LS2FZmaM4feLU/H39uTpCZdZHcelPXNDbzxEeHaJ3rugVFNpKTSzFanHWJeRz6yxPWgb5Gt1HJfWKdSfx67uzqrduaxM1SkwlGoKLYVmdKaiiue+TKVH+yCmDImyOo5buHd4V3q0D+L3i3dRUq4zqSrVWFoKzejv3+3jUEEpv7+hN16e+k/dErw9PXju5r4cPlnK3NUZVsdRyunoX6pmknOylNfWZHJtnw4MjW1rdRy3MrhrGD8d2Jm3v91H+rFTVsdRyqloKTSTv3y9h2pj+J/relkdxS395to4Anw8ee5LvdNZqcawSymIiJ+ILBWRZBFZIHUsHyYi40UkW0TW2R49G3KeM9q8v4AlyTk8MCqGyLAAq+O4pTZBvjx6dXe+2ZvH2rRcq+Mo5TTsNVKYAmQbY/oBrYGxFzjuDWPMcNsjrRHnOY2qasMzi3fRKcSPB0fFWB3Hrd11VRRRbQL481e7qazSO52Vagh7lUICsNK2vRoYc4HjJorIZhFZaBsVNPQ8p/Hx5oPsPlLEb6+/DH8fnfDOSr5envzm2jj2Hivm06RDVsdRyinYqxTaAIW27SKgrtneMoGnjTGDgY7AqAae5zROlpTzwoo0ruwaxnV9O1gdRwHX9O7A4OgwXlqxl1NnKqyOo5TDs1cp5AMhtu0Q29e1FQCrbNtZQLsGnoeITBeRJBFJysvLs1Nk+3s1MZ2i0gp+f2NvXOTyiNMTEX43oRfHT5fz+tpMq+Mo5fDsVQqJwDjbdgKwpo5jZgGTRcQD6AOkNPA8jDHzjTHxxpj48PBwO0W2r4PHS/hg4wEmDYqkV0ddTc2RXN45lFsHRPCPdft1XiSlLsJepfAhECEiO6gZEWSKyAu1jpkHTAM2AYuMMal1nJdopzwt7m8r0vD0EH7xkx5WR1F1ePyanngIPL88zeooSjk0u8zhbIwpAybU2v14rWOOAKMbcJ7T2ZF9kiXJOTw8Jpb2wX5Wx1F16BTqz/QR3ZizOoN7hkYzMKq11ZGUckh689olMsbwl6/2EBbowwOjulkdR9XjgVExhLfy5bkvUzHGWB1HKYekpXCJ1u7NY8O+4zyaEEsrP2+r46h6BPp68cS4nmw7eJIlO45YHUcph6SlcAmqqg2zv95DVJsA7rhSZ0F1BhMHdiauQyteWJ6mS3cqVQcthUuwaNth9hw9xRPX9MTHS/8pnYGnh/Dk+DgOFpToDW1K1UH/kjXRmYoqXlqRRr/OIVzft6PVcVQjjO4ZzqDo1sxJTKe0vMrqOEo5FC2FJnrv+yxyCs/w1LW99EY1JyMi/Hp8HHmnynj3+/1Wx1HKoWgpNMHJknJeX5NBQlw7roppY3Uc1QSDosNIiGvHm2szKSzR6S+UOktLoQleX5tJcVklT46PszqKugSPj+tJ0ZlK3vpWp79Q6iwthUY6WniG97/P4pYBnenZoZXVcdQluKxTMDf178Q76/eTW3TG6jhKOQQthUZ6bU0GVdWGX/yku9VRlB3MGtuDyiqj6zkrZaOl0AiHCkr4ZMtBJg2K1BXVXERUm0AmDYrk480HOXD8tNVxlLKclkIjzElMR0R4JEFHCa7k0au74+UpvLxyr9VRlLKclkID7csrZuEP2dw1JIoOITrpnStpH+zHPUO78p/kHHYfKbI6jlKW0lJooFdWpePr5cmDo3XdZVf04KgYWvl68YJOra3cnJZCA+w5WsSSHTlMGxZN2yBfq+OoZhAS4M0Do2JI3JPL9kMnrY6jlGW0FBrgpRV7CfLxYvpInRrbld09NJrWAd68skqvLSj3paVwETuyT7Ii9Rj3jehGaICP1XFUMwry9WL6yBjWpuWx9cAJq+MoZQm7lIKI+InIUhFJFpEFUsdkQFLjfRHZKCKLRcRLRMaLSLaIrLM9etojjz29uGIvrQO8uXd4tNVRVAuYelUUbQJ9dLSg3Ja9RgpTgGxjTD+gNTC2jmOGAV7GmCFAMDDOtv8NY8xw28OhrvJtySrgm715zBgVowvouIlAXy9mjIrhu/R8tmQVWB1HqRZnr1JIAFbatlcDY+o45hjwqm27/Lz9E0Vks4gsrGuEYaUXlqfRNsiXqVdFWx1FtaApQ6JoG+Sr9y0ot2SvUmgDFNq2i4Cw2gcYY9KNMZtF5BbAB1gOZAJPG2MGAx2BUXX9cBGZLiJJIpKUl5dnp8j125B5nE37C3hodAz+Pp4t8juVY/D3qfno8feZx9mQedzqOEq1KHuVQj4QYtsOsX39IyJyI/AYcIMxpgooAFbZvp0FtKvrPGPMfGNMvDEmPjw83E6R6/fKqr20a+XLHVd2aZHfpxzLnVd2oV0rX15etRdjjNVxlGox9iqFRP7/GkECsKb2ASLSAXgCuN4Yc8q2exYwWUQ8gD5Aip3yXJKzo4QHR8fg562jBHfk5+3JzDGxbN5foKMF5VbsVQofAhEisoOaV/+ZIvJCrWPupuYtouW2TxrdC8wDpgGbgEXGmFQ75bkkZ0cJPxusowR3NmlQJB1D/HhppY4WlPvwsscPMcaUARNq7X681jGzgdl1nD7aHhns5ewo4ZkbLtNRgpvz8/bkoTGxPP3vFL5Lz2dkj5Z561IpK+nNa7XoKEGd7/b4zkSE+utoQbkNLYXz6LUEVZuvV821he2HTvJtep2fn1DKpWgpnOfVRB0lqB/76cCa0cKr+kkk5Qa0FGw2ZB5n4z4dJagf8/Hy4MHRMfxw8CTrM/STSMq1aSnY6ChB1ee2+M50DPHj1UQdLSjXpqWAjhLUxZ1dYGlL1gk27NPRgnJdWgroKEE1zO3xkbQP9uXVVelWR1Gq2bh9KWzaVzNKmDFKRwmqfn7enswYFcOm/QVs1NGCclFuXwpzV2fQNkjnOFIN87PBXQhv5cucRB0tKNfk1qWw9UAB6zLyeWBkNx0lqAbx8/bkgZHd+D7zuK63oFySW5fCnMQMwgJ9uHOIjhJUw915ZRRtg3x0tKBcktuWwvZDJ/lmbx73j+hGgI9dpoBSbsLfx5PpI7vxXXq+ruWsXI7blsK81emEBnhz11VRVkdRTmjKkCjCAnW0oFyPW5ZCyuFCVu3O5efDuhLkq6ME1XgBPl7cP6Ib3+zNY/uhk1bHUcpu3LIU5q5Op5WfF3cPi7Y6inJid10VRWiAN3N1tKBciNuVwu4jRSzfdYx7h3Ul2M/b6jjKiQX5evHzYV1J3JNLyuHCi5+glBNwu1KYtyaDIF8v7h3W1eooygXcPSyaVn5ezF2towXlGuxSCiLiJyJLRSRZRBaIiDTkmIacZ0/px07x1c4j3D00ipAAHSWoSxfs5820YV1ZvusYe44WWR1HqUtmr5HCFCDbGNMPaA2MbeAxDTnPbuatycDf25OfD+/WnL9GuZl7h0UT5OvF3NUZVkdR6pLZqxQSgJW27dXAmAYe05Dz7GJfXjFLknO4y/ZRQqXsJTTAh6lXRfHVziNk5J6yOo5yQcYYHv7oBxYn5zT777JXKbQBzl5pKwLCGnhMQ85DRKaLSJKIJOXl5TUp4IHjJXQM8ee+ETpKUPZ334hu+Ht7Mk9HC6oZrM84ztIdRygsrWj232WvUsgHQmzbIbavG3JMQ87DGDPfGBNvjIkPDw9vUsAxce349tdjCG/l26TzlapPWKAPU4ZEsTg5h/35p62Oo1zMnMR0OgT7cXt852b/XfYqhURgnG07AVjTwGMacp7deHo063Vs5ebuG9EVb08PXlujowVlPxv3HWdzVgEzRnXD16v5J+60Vyl8CESIyA6gAMgUkRcuckziBfYp5ZTatfLjjiu7sGjbYQ4VlFgdR7mIOYnptA3yZXILLQJmlzkejDFlwIRaux9vwDF17VPKaT0wMoYPNx7k9bUZ/OXWy62Oo5xcUlYB32ce53fX92qx6f3d7uY1pZpThxA/Jg2K5POt2Rw+WWp1HOXk5qzOoE2gT4suAqaloJSdzRgdA8Aba/Xagmq6bQdP8O3ePO4f2bLT+2spKGVnEaH+/HRgJJ9tyeZIoY4WVNPMXZ1BaIA3U4a07PT+WgpKNYOHRsdQbQxvfbPP6ijKCe3MLmT1nlzuG97y0/trKSjVDCLDAph4RWc+2nyQY0VnrI6jnMzc1ekE+3kxdWh0i/9uLQWlmsnMMbFUVetoQTVOak4RK1KPce9wa6b311JQqpl0aRPALQMi+HDTAXJP6WhBNcy8NekE+Xoxbag10/trKSjVjGaOiaWiqpr5OlpQDbD32Cm+TjnKPUOjLZveX0tBqWbUtW0gN/eP4INNB8gvLrM6jnJwcxLTCfD25OfDrVsETEtBqWY2MyGW8spq3v5WRwvqwvYeO8WXO49wz7BoWls4vb+WglLNLCY8iBv6deKfGw5wXEcL6gLOjhLus3gRMC0FpVrAIwmxnKms4u/r9lsdRTmgs6OEu4daO0oALQWlWkRsu1Zc37cj//w+ixOny62OoxzMuVGCAywCpqWgVAt5JKE7p8ur+IeOFtR50s8bJTjCUsFaCkq1kJ4dakYL767fr6MFdc6c1RkOM0oALQWlWtRjP+lOSUUV87/TTyKpmlHC0h05DjNKAC0FpVpUj/atmHB5J97/Pks/iaQcbpQAdioFEfETkaUikiwiC0SkzsWQpcb7IrJRRBaLiJeIjBeRbBFZZ3v0tEcmpRzVY1d350xFFfP1vgW3dnaUMNWBRglgv5HCFCDbGNMPaA2MvcBxwwAvY8wQIBgYZ9v/hjFmuO2RZqdMSjmk2HZB3NQ/gvc3ZJF3SkcL7mru6gz8vT2534FGCWC/UkgAVtq2VwNjLnDcMeBV2/b5V9omishmEVl4oVGGUq7kEdtdzm99k2l1FGWBjNxTLHGwawln2asU2gCFtu0iIKyug4wx6caYzSJyC+ADLAcygaeNMYOBjsCo2ueJyHQRSRKRpLy8PDtFVso63cKDuGVAZxZsPECurrfgdl5eVXNfgqONEsB+pZAPhNi2Q2xf10lEbgQeA24wxlQBBcAq27ezgHa1zzHGzDfGxBtj4sPDw+0UWSlrPXp1LJXVhtfX6mjBnaTmFPHljiPcO7yrw40SwH6lkMj/Xx9IANbUdZCIdACeAK43xpyy7Z4FTBYRD6APkGKnTEo5tKg2gUy8IoKPNh/kaKGOFtzFSyvTCPbzcqhPHJ3PXqXwIRAhIjuoeeWfKCJdReSFWsfdTc1bRMttnzS6F5gHTAM2AYuMMal2yqSUw3skoTvV1YbX12ZYHUW1gG0HT7Bqdy4PjIohxN+a9RIuxi4rQhtjyoAJtXbvBx6vddxsYHYdP2K0PXIo5WwiwwK4LT6STzYf4oFRMUSE+lsdSTWjl1buJSzQh3ssWHu5ofTmNaUs9nBCLAbDa2t0tODKNu47znfp+Tw0OoZAX7u8Hm8WWgpKWSwi1J/Jg7rw2ZZDHDh+2uo4qhkYY3hxRRrtg32ZMiTK6jj10lJQygE8khCLl6fw8sq9VkdRzeDb9Hy2ZJ3g4YTu+Hl7Wh2nXloKSjmAdsF+TBvWlf8k57D7SJHVcZQdnR0lRIT6Myk+0uo4F6WloJSDmDEyhla+XrywXGd6cSUrUo+xI7uQx37SHR8vx/+T6/gJlXITIQHezBgdQ+KeXJKyCqyOo+ygutrw0oq9dGsbyK0DIqyO0yBaCko5kGlDuxLeypfZy/ZgjLE6jrpES3ceIe3YKX4xtgdens7x59Y5UirlJvx9PHn06u5syTrB2jSd58uZlVdW8+KKNOI6tGJC345Wx2kwLQWlHMyk+Ei6hAXw/PI0qqt1tOCsPtp0gAPHS3jy2jg8PJxn8mctBaUcjI+XB7PG9mD3kSKW7jxidRzVBKfOVDBndQZXdWvD6B7ONYmnloJSDujGfp2I69CKF1ekUVFVbXUc1Ujzv91HwelyfnNdHM62RIyWglIOyMNDeOKanhw4XsJnSYesjqMa4VjRGf7+3X5u6NeJyzuHWh2n0bQUlHJQCXHtiI9qzaur0iktr7I6jmqgV1btpbK6mifGOedy81oKSjkoEeGpa+PIPVXG29/tszqOaoCM3FN8uuUQd14ZRZc2AVbHaRItBaUcWHx0GNf17cAbazM5pst2OrzZy9II8PHikYRYq6M0mZaCUg7uyfFxVFXXzJ+jHNeWrAJWph7jwdExtAnytTpOk9mlFETET0SWikiyiCyQC1xuF5HxIpJtW3VtnYj0bOi5SrmrqDaB3DMsmn9tzWZXTqHVcVQdjDH8+avdtA/25d5hXa2Oc0nsNVKYAmQbY/oBrYGx9Rz7hjFmuO2R1shzlXJLM8fEEurvzZ++3K3TXzig5buOsu3gSX75kx74+zj21NgXY69SSABW2rZXA2PqOXaiiGwWkYW2UUFjzlXKLYX4e/PLsT34PvM4ibtzrY6jzlNWWcXsZWnEtgvipwM7Wx3nktmrFNoAZ8e1RUDYBY7LBJ42xgwGOgKjGnGuUm7tZ4O7EBMeyJ+/2q03tDmQd9dnsT//NL+7vpfTTHpXH3s9g3wgxLYdYvu6LgXAKtt2FtCuIeeKyHQRSRKRpLw8nSRMuSdvTw9+e30v9uWf5sONB6yOo4DcojPMTUznJ73aMbpnO6vj2IW9SiERGGfbTgDWXOC4WcBkEfEA+gApDTnXGDPfGBNvjIkPD3eueUSUsqcxPdsxPLYtrySmU1hSYXUct/fXZXuoqDL87vrLrI5iN/YqhQ+BCBHZQc1oIFFEuorIC7WOmwdMAzYBi4wxqXWda6dMSrkcEeG31/eisLSCuavTrY7j1n44eIIvfjjMfSO6Et020Oo4duNljx9ijCkDJtTavR94vNZxR4DRDThXKXUBvToGMyk+kvc3ZHHnkCi6utAfJGdRXW34/eJdtA/2ZeYY571RrS7Of1VEKTc0a1wP/Lw8eWbxLv2IqgU+35rNjuxCfnNtLwJ97fLa2mFoKSjlhNq18mPWuB58uzePr3YetTqOWyksrWD2sj0MjGrNTf07WR3H7rQUlHJSdw2JonenYP6wdBfFZZVWx3EbcxLTKSgp59kbezvdWgkNoaWglJPy8vTguZv7kHuqjJdX7rU6jlvIyD3F+99nMXlQJH0iQi5+ghPSUlDKiQ3o0pqfDe7Ce99nkZpTZHUcl2aM4dklqfj7ePK4k66V0BBaCko5uSeviSPU35vf/Xsn1dV60bm5LE7O4bv0fGaN7eHUs6BejJaCUk4uJMCb31zXix8OntSlO5tJwelynl2SSr/IUKZeFW11nGalpaCUC5h4RQSDo8P467I9FJwutzqOy/nj0lSKSiuYPbEvnh6ud3H5fFoKSrkAEeG5W/pQfKaSv3692+o4LmVtWi6Lth3modExxHUItjpOs9NSUMpF9Gjfip+P6MpnSdmS/mzDAAAL10lEQVRsySqwOo5LOF1WyW8XpRDbLoiZTrzEZmNoKSjlQh67ujsRof78+vMdlJTrvQuX6m/L08gpLGX2xL74ejn34jkNpaWglAsJ8PHib7ddzv780zy/TNd0vhRbD5zg/Q1Z3DUkioFR7rPMi5aCUi5maExb7hkazXvfZ7E+40JLm6j6lFVW8dTCHXQM9uPX4+OsjtOitBSUckFPjo+jW9tAfv35DorO6LoLjfXG2kzSc4v50y19CXKxCe8uRktBKRfk7+PJi7f340hhKX9ckmp1HKey+0gRr63J4Kb+nRgT5xqrqTWGloJSLmpAl9Y8ODqGf23NZlXqMavjOIWS8koe+XgboQE+/O8E11lNrTG0FJRyYY9d3YNeHYN56oudelNbA/xhSSqZecW8Mqm/S09lUR+7lIKI+InIUhFJFpEFcoH5ZEVktIissz0OicjdIjJeRLLP2++6M00p1cJ8vDx46fZ+FJaW8/S/U3RBnnosSc7hky2HmDEqhmGxba2OYxl7jRSmANnGmH5Aa2BsXQcZY9YaY4YbY4YDO4Bttm+9cXa/MUY/R6eUHfXqGMwvx/bgy51HWJycY3Uch3SooIT/+WInA7qEMmtsD6vjWMpepZAArLRtrwbG1HewiAQAscaYHbZdE0Vks4gsvNAoQynVdA+MjGFgVGt+uyiFjNxiq+M4lIqqah79pOb16ZzJA/D2dO931e317NsAhbbtIuBid3qMBRJt25nA08aYwUBHYFTtg0VkuogkiUhSXl6enSIr5T48PYR5dwzA18uDGR9s1ZXazvPyyr1sO3iSP9/al8iwAKvjWM5epZAPnF2GKMT2dX1uAJbatguAVbbtLOBHnwEzxsw3xsQbY+LDw8MvPa1SbqhjiD9z7xjAvrxifv15sl5fANZn5PPGN5lMio/khn6ut95yU9irFBKBcbbtBGDNhQ60vT00hpq3mQBmAZNFxAPoA6TYKZNSqpahMW156to4vtp5lPnf7rM6jqWOF5fxi0+3061tIM/c6J4fP62LvUrhQyBCRHZQ88o/UUS6isgLdRw7CNhljDlj+3oeMA3YBCwyxuidNko1o/tHdOP6vh2ZvWwP37vpNBhllVXM+GArhaUVzP3ZFQT4uNddy/URZxtCxsfHm6SkJKtjKOXUissqueW19Rw/Xc7SR4bTKdTf6kgtxhjDrM+SWbTtMK9O7s9N/SOsjtQiRGSrMSb+Yse592V2pdxUkK8Xb941kPLKah78YCtnKqqsjtRiXk1MZ9G2w/xqbA+3KYTG0FJQyk3FhAfx4u39SM4u5Jn/7HKLC8+LtmXzyqp0Jl7RmYfdZNGcxtJSUMqNXdO7Aw+PieXTpEO8tHKv1XGa1eb9BTz5+U6GdAvjL7f2RW+JqpteXVHKzf1qXA/yi8uYuzqDQF8vZoyKsTqS3e3PP830BUl0bu3Pm1MG4uOlr4cvREtBKTcnIvzplr6cLq/ir1/vIdDHk7uuirY6lt2cOF3Ove9twUOEd6cNIjTAx+pIDk1LQSmFp4fw0u39KC2v5On/7CLQ14tbr+hsdaxLdrKknHve28LhE6V8dP+VRLUJtDqSw9MxlFIKAG9PD+bdcQVDY9rwxOc7WJZy1OpIlyT31BkmvbWR3UeKeP3OK4iPdp91li+FloJS6hw/b0/enhrP5Z1DePTjbXy71znnGss+UcLtb27g0IkS3r1nED+5rL3VkZyGloJS6r8E+nrx3j2D6RYeyPQFSU43YsjMK+a2NzdQcLqcBT+/0q3XRmgKLQWl1I+EBHjzwX1XEtchmBkfbGVuYrpT3MeQmlPE7W9uoLyymo+nD2FgVGurIzkdLQWlVJ3aBvnyyfQh3DogghdX7uXRT7ZTWu64dz5vPXCCyfM34OPlwWczrqJ3p5CLn6R+RD99pJS6ID9vT168vR89OrRi9rI9ZOWf5u2p8XQI8bM62jnV1YZ31u/n+WVpdAr144P7rqRza10Xoal0pKCUqpeIMGNUDH+fGs++vGJumLeObQdPWB0LgCOFpUz5xyae+3I3o3qG88VDw7QQLpGWglKqQa7u1Z5FM4fh7+3JpPkbeX1tBmWV1r2d9OWOI4x/5Tu2HzrJ7Il9mX/XQMIC9ca0S6WloJRqsB7tW/GfmcMY3SOc55elMe7lb1mx62iLXoQ+daaCWZ9tZ+ZHPxDdNpAvHx3BpEFddC4jO9H1FJRSTfJdeh5/WJJKem4xI7q35X8nXEb39q2a7feVlFfy+dZs3vpmH0cKS3kkoTsPJ8Ti7amvbRuioespaCkopZqsoqqaDzYe4OWVezldXsVdQ6J4aEwM7VrZ70J03qkyFmzI4p8bD3CypIL+kaE8PeEy/bhpI7V4KYiIN/CFMeaGeo7xAz4HIoEdwFTAt/Y+U08oLQWlHE/B6XJeXJHGx5sPYoBB0WFc26cD4/t0oGNI01Z1y8gt5h/r9rHwh8NUVFUztld7po/sxsCo1vpWURO0aCmIiD81ayz3MMZc8CWCiNwHxBtjZojIUmAO0KX2PmPMigv9DC0FpRxXZl4xS5JzWJZylD1HTwEwoEso1/bpwKDoMEL8vQnx9ybY3/u/3vbJLTpDSk4hKYeLSDlcyK6cIg6fLMXXy4OJAztz3/CudAsPsuppuQRL3j4SkQxjzAWXMxKRj4CFxpiFIjILCAeiau8zxvzmQj9DS0Ep57Avr5ivU46yLOUoOw8X/uj7AT6ehPh7U1FlyC8uA0AEurYNpE+nEC7vHMLNAyJoG+Tb0tFdUkNLoaVvXmsDnP1/RxHQ8wL7/ouITAemA3Tp0qX5UyqlLlm38CBmjoll5phYDhWUkJ57iqLSSgpLKygsraDI9r8AvToG0ycihMs6BRPkq/fUWqml//XzgbP3nofYvg6qY99/McbMB+ZDzUih+WMqpewpMiyAyDC9qcwZtPRnuRKBcbbtBGDNBfYppZSyQLOVgoh0FZEXau3+EIgQkR1AATWFUNc+pZRSFrDr20fnX2Q2xuwHHq/1/TJgQq3T6tqnlFLKAnoroFJKqXO0FJRSSp2jpaCUUuocLQWllFLnaCkopZQ6x+lmSRWRPOBAE09vSx03xzkZZ38Ozp4fnP85OHt+cP7nYEX+KGNM+MUOcrpSuBQiktSQuT8cmbM/B2fPD87/HJw9Pzj/c3Dk/Pr2kVJKqXO0FJRSSp3jbqUw3+oAduDsz8HZ84PzPwdnzw/O/xwcNr9bXVNQSilVP3cbKSillKqHW5SCiPiJyFIRSRaRBeKkC7yKiLeILLE6R1NIjfdFZKOILBYRp1tJRUS8RORfIrJeRN6xOk9TicgvRWSV1TkaS0TGi0i2iKyzPX60IJczEJFfi8h3IvK1iPhYnac2tygFYAqQbYzpB7QGxlqcp9Fs62BvxQmz2wwDvIwxQ4Bg/n8NDWdyM5BsjBkGdBSR/lYHaiwRiQLusTrHJXjDGDPc9kizOkxjiUg3oLcxZgTwNdDZ4kg/4i6lkACstG2vBsZYmKVJjDGlxpjLgWyrszTRMeBV23a5lUEuwTLgJdsoJ5Sa5WOdzavABddAdwITRWSziCx00hH/1UBrEfkWGAHstzjPj7hLKdReBzrMwixuyRiTbozZLCK3AD7AcqszNZYxptgYUwKsB44ZY/ZZnakxROQOIBlItTpLE2UCTxtjBgMdgVEW52mKcCDPGDOSmlHCcIvz/Ii7lEJda0OrFiYiNwKPATcYY6qsztNYItJGRHyBodS82nO2EecEal6pfgIMFJGHLc7TWAXA2WshWUA766I0WRFw9m2vfUCEhVnq5C6loOtAW0xEOgBPANcbY05ZnaeJfgXcZiu0EsDf4jyNYoy5wxgzHJgMbDXGzLM6UyPNAiaLiAfQB0ixOE9TbAUG2bZjqSkGh+IupaDrQFvvbmqG/Mttnxy51+pATfAacK+IbACO44RvgTm5ecA0YBOwyBjjdG+DGWM2APkisgVIM8ZstjpTbXrzmlJKqXPcZaSglFKqAbQUlFJKnaOloJRS6hwtBaWUUudoKSillDpHS0EppdQ5WgpKKaXO+T8DVY+KibvijAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sin(x));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "多条数据线：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sin(x),\n", + " x, sin(2 * x));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用字符串，给定线条参数：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sin(x), 'r-^');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "多线条：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sin(x), 'b-o',\n", + " x, sin(2 * x), 'r-^');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "在同一幅图中绘制 sin(x), sin(2\\*x), sin(3\\*x) 三条曲线。颜色分别为蓝色，红色，黄色。\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from numpy import *\n", + "%matplotlib inline\n", + "x = linspace(0, 2 * pi, 50)\n", + "plt.plot(x, sin(x), 'b', x, sin(2 * x), 'r', x, sin(3 * x), 'y');\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## scatter 散点图" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "scatter(x, y)\n", + "scatter(x, y, size)\n", + "scatter(x, y, size, color)\n", + "```\n", + "\n", + "假设我们想画二维散点图：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sin(x), 'bo');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "可以使用 `scatter` 达到同样的效果：" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(x, sin(x));" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = random.rand(200)\n", + "y = random.rand(200)\n", + "size = random.rand(200) * 30\n", + "color = random.rand(200)\n", + "plt.scatter(x, y, size, color)\n", + "# 显示颜色条\n", + "plt.colorbar();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：使用 scatter 绘制 sin(x)的二维散点图，把颜色设置为红色，散点形式设置为三角形." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "x = linspace(0, 10, 30)\n", + "plt.scatter(x, sin(x), marker='^', color='r');\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 多图" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用figure()命令产生新的图像：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD6CAYAAABOIFvoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XlYV3Xe//Hnmx1UVsGVRUBwS0xxSS0F02yxfXHK1ilbpppGW37N3DVzT7M0LdNmOVkzU2PdrWqLTbmgpumY4gKuCBgquIEooMj++f3BVzMGFfXA+S7vx3VxXYfDOfg60cWLz1k+R4wxKKWUUgBedgdQSinlPLQUlFJKHaeloJRS6jgtBaWUUsdpKSillDpOS0EppdRxWgpKKaWO01JQSil1nJaCUkqp43zsDnCmOnbsaOLi4uyOoZRSLmXNmjUlxpjI023ncqUQFxdHZmam3TGUUsqliMiOlmynp4+UUkodp6WglFLqOC0FpZRSx2kpKKWUOk5LQSml1HGWloKI+IrIl6f4eoCIzBWRLBGZKY3+a52VmZRSSrWcZaUgIoHAGmDsKTabBBQaY1KAMMe2za1TSillA8ueUzDGHAX6i0jeKTZLB2Y5lhcBaUBsM+vmW5XrmLz9FXyRtYfosEBiwoOIDg+iU3AA3l46MFFKOR9jDAeO1LCztJJdjo+U6FAu7Hna58/OSVs/vBYBlDmWy4Hkk6z7CRGZDEwGiImJOat/eMueCl5blMuJr6T28/aim6MkLu4dxZUDuhES6HtW318ppc5FdV09CzbvY27WHn4oOcKug5VU1tT/ZJv7Rye4XSmUACGO5RDH5+2bWfcTxpgZwAyA1NRU0/TrLTEhpSuX9O3M7kNHG5v3YCU7SyspLD3K1r3lPPX5Jv7w1RYuP68LE4fEMDguDL28oZRqbdv2VfDR6l3MXlvIwcpaOgcH0K9bCCMSOxId/uOZje5hgQT5tf6v7LYuhQxgHI2ni9KBl4CYZta1Cj8fL+I6tiOuY7ufrDfGsLGonA9X7+Tz9buZva6I+I7tuHFwNBMHRxMa5NdakZRSHqi6rp7P1+3mw9U7WbvzEL7ewtg+nbhpcAwjEzvaelpbjDmrP7xP/g1F8owxiSLSA/iFMebRE77mT+Mv/xggC7gN8Gu6zpwiVGpqqmnNuY8qa+r494a9fLR6J6sLDhLRzo+nJ/ThypSuOnJQSp2zzIJSnpiVTX7xERIi2zFxcAzXDOxGx/b+rfrvisgaY0zqabezuhRaW2uXwok27S7j13M2krXrEOm9ovjD1f3oGhrYJv+2Usq9HK6u47lvtjJz5Q66hgTyzNV9SUuOarM/NrUULFLfYHhnRQEvzMvBS+CJS3sxaWgsXnrXklKqhRZt3cdv5mxkb3kVt18Qx6OXJNPev23P3mspWGxXaSW/nrOBZbklDIoN4y/X9Scxqn2b51BKuY7SIzX87otNfJG1m55R7Xn2uv4Mig2zJYuWQiswxjB7bRHPfLWZunrD9EkDW/32MKWUa8ovPswd/1zF3rIqfpGWyAOjE/HzsW9moZaWgs59dAZEhOsGdefrX15I97BA7vznamavLbQ7llLKyazZUcr101dQWV3PJ/cN55GLk2wthDPhGimdTJeQQD6+7wKG9AhnysdZvL44D1cbcSmlWsc3G/dy81vfExLoy+wHhjMgOtTuSGdES+EsBQf48s6dQ7hqQFeen5fD/3y2kbr6BrtjKaVs9K//FHD/+2vo3SWYWfcPJzai3Wn3cTYu945mZ+Ln48VLNw6ga2gg05fks6+8itd+NpBAP2+7oyml2lBDg+G5eTn87dt8Lu4d5dK/B3SkcI68vIQnxvfi91f1JWPrfm5+eyWHq+vsjqWUaiMNDYbHZ2Xzt2/zuWVoDH+bNMhlCwG0FCxz2wVxTL9lINmFZdz/3hpq6vRUklKe4M9fb+HTNYX8ckxP/nB1P3y8XfvXqmundzLj+3Xhz9eex7LcEh7/NIuGBr34rJQ7e2vpdt5a9gN3DI/jkYt7usVUOHpNwWI3pkZTXFHN8/Ny6BQcwJOX9bY7klKqFXy+vog//nsLl53Xmaeu6OMWhQBaCq3igdEJ7Cuv4s2l24kKDuDnI3vYHUkpZaHvckt49JMshvYI5683DnCrl3VpKbQCEeG3E/pSXFHNM3M3E9nBnytTutodSyllgY1FZdw7M5OEyPbMuC2VAF/XvajcHL2m0Eq8vYSXbhrAkB7hTP14PSvy/uvdQUopF7PzQCV3/HM1oUF+vHPnELd8U6OWQisK8PXmrdtSie/Ynskz15C7r8LuSEqps1R2tJbb/7mKuoYG3r1rMJ1DAuyO1Cq0FFpZSKAv7941hABfbx54fy2VNfoMg1KuxhjD459msau0krduSyUxqoPdkVqNlkIb6BwSwCsTB5BXfJj/mbNR50lSysX8c3kB8zbt44nxvRgcF253nFZlSSmISICIzBWRLBGZKc3cmyUio0XkO8fHLhG5XUTGi0jhCeuTrcjjjEYkduSRMUnMXlfEx5m77I6jlGqhtTsP8qd/b2Fsn07cfaH730lo1UhhElBojEkBwoCxTTcwxiwxxow0xowEsoF1ji9NP7beGJNjUR6n9GB6IiMTO/L055vYsqfc7jhKqdM4VFnDQ/+3js4hAbxwfYrbPItwKlaVQjqwwLG8CEg72YYiEgQkGmOyHauuE5FVIjKruRGGO/H2El6eOICQQF8eeH8tFVW1dkdSSp1EQ4Nh6sdZ7K+o4vWbBxIS5H53GjXHqlKIAMocy+XAqU66jQUyHMv5wFPGmCFAF2BUczuIyGQRyRSRzOLiYosi26Nje39e+9n57DhwhCdnb9DrC0o5qRnLtpOxdT+/uaw3KS72ToRzYVUplAAhjuUQx+cnMwGY61guBRY6lguAqOZ2MMbMMMakGmNSIyNd//WXQ+MjmDoumbnZe3jv+512x1FKNbG6oJTn5+Vw2XmduX14nN1x2pRVpZABjHMspwOLm9vIcXoojcZTTABTgIki4gX0AzZalMfp3T8qgdHJkTzz5WY2FpWdfgelVJsoPdJ4HaF7WCDPXtffI64jnMiqUngf6CYi2TT+9Z8vIi80s91gYJMxpsrx+TTgTuB7YI4xZrNFeZyel5fw0o0DCGvny9SPs3SqbaWcxO++2MSBI9W8fvNAggM84zrCiSwpBWNMtTHmCmNMf2PMrcaYH4wxjzaz3SpjzJUnfL7HGDPaGDPYGPNbK7K4krB2fvzpmvPI2VfBtEW5dsdRyuPN27SXL7J282BaT/p1Czn9Dm5IH16z2Zjenbj2/G68sSRfTyMpZaNDlTX8Zs5G+nQJ5oG0BLvj2EZLwQk8PaEPYe38eOzTbD2NpJRNfv/lZg5V1vD8Df3xdfG3p50Lzz1yJxIa5Mcfr+7Hlj3lTF+Sb3ccpTxOxpZ9zF5XxAOjE+jb1TNPGx2jpeAkxvXtzJUpXXltUa4+7axUGyqrrOXXczbQq3MHHkzvaXcc22kpOJHfXdmX0CBfHvs0i9p6PY2kVFt45qvNlByu4fnrU/Dz0V+J+l/AiYS38+OZq/qxsaicN7/V00hKtbbFOfv5dE0h942K57zunn3a6BgtBSdz6XlduLx/F17JyCVnr76UR6nWUl5Vy69nb6BnVHseHqOnjY7RUnBCv7+yLx0CfHlydjYNDTo3klKt4YV5Oewrr+L5G1Lw93Gv9yyfCy0FJxTR3p8nL+3F2p2HmLW20O44SrmdTbvLeG/lDm4dFssAD5rsriW0FJzUdQO7MzAmlGe/3krZUZ1iWymrNDQYnv58E2FBfkwZ57bv9TprWgpOystL+P1V/SitrOGlBdvsjqOU25i9rog1Ow7yxKW9CAn0vLmNTkdLwYn16xbCLUNj+Nd/Cti8W59dUOpclR2t5dmvt3B+TCjXD+xudxynpKXg5B4dl0xIoC+//WKjvpBHqXP00oJtHDhSwzNX9cPLy7OmxG4pLQUnFxrkxxPje7G64CCfrS+yO45SLmvLnnL+9Z8Cbhka47EzoLaEloILuDE1mpToUP707636XmelzoIxht9+vomQQF8e1YvLp6Sl4AK8vIRnrupLyeFqXl6o711Q6kx9vn43qwpKeWJ8L0KD/OyO49S0FFxE/+6hTBwcwzsrCvRJZ6XOQEVVLX/89xZSokO5MTXa7jhOz5JSEJEAEZkrIlkiMlOaeampiIwXkUIR+c7xkdyS/dSPHr8kmQ4BPnrRWakz8NqiPEoOV/PMVX314nILWDVSmAQUGmNSgDBg7Em2m26MGen4yDmD/RSNr++cOjaJldtLydiy3+44Sjm9nQcqeWd5ATcM6k7/7vrkcktYVQrpwALH8iIg7STbXSciq0RklmNU0NL9lMPEITHER7bjz19voU6n11bqlJ6btxVvL2GqXlxuMatKIQI49oLhciC8mW3ygaeMMUOALsCoFu6HiEwWkUwRySwuLrYosmvy9fbi/43vRX7xET5cvcvuOEo5rXU7DzI3ew/3XBRPp+AAu+O4DKtKoQQ4duNviOPzpkqBhY7lAiCqhfthjJlhjEk1xqRGRkZaFNl1je3TiSE9wnl54TYOV9fZHUcpp2OM4U//3kLH9v7ce1G83XFcilWlkAGMcyynA4ub2WYKMFFEvIB+wMYW7qeaEBF+c1lvSg7X6Mt4lGrG/M37WF1wkCljk2jn72N3HJdiVSm8D3QTkWwaRwT5IvJCk22mAXcC3wNzjDGbm9kvw6I8bi8lOpQJKV15a9l29pZV2R1HKadRW9/As19vJTGqPTem6vxGZ8qSCjXGVANXNFn9aJNt9gCjW7CfaqHHL0lm3sa9vDg/h+dvSLE7jlJO4YNVO/mh5Aj/uCMVH299FOtM6X8xFxYdHsTtw2P5dG2hzqKqFI2v2Hx5YS4XxEeQlhxldxyXpKXg4h5M60lwgC9//nqL3VGUst30JfmUHqnhN5f3Rp+FPTtaCi4uJMiXh9ITWZZbwrfbPPt2XeXZig4d5R/f/cA153fTWVDPgZaCG7j1gliiwwP501dbqG/Q6S+UZ3pxfg4GmDouye4oLk1LwQ34+3jz+CW9yNlXwRdZ+s4F5Xly9lYwZ10Rdw6Po3tYkN1xXJqWgpu4/Lwu9OkSzEsLcqnV6S+Uh3lxfg7t/Xy4f3SC3VFcnpaCm/DyEh69JImdpZV8nKnTXyjPsX7XIeZv3sc9F8XruxIsoKXgRtKSoxgUG8arGblU1dbbHUepNvHi/BzC2/lx18gedkdxC1oKbkREeOySZPaVVzPzPzvsjqNUq1uRX8Ky3BIeGJ1Ae53OwhJaCm5mWHwEF/bsyBtL8vR9zsqtGWN4YV4OnYMDmDQs1u44bkNLwQ09Oi6Zg5W1/OO7ArujKNVqFufsZ+3OQzw8picBvt52x3EbWgpuKCU6lEv6duLtZds5eKTG7jhKWa6hwfD8vG3ERgRxg056ZyktBTc1dVwyh2vq+NtSnVpbuZ+vNuxhy55yfnVxEr466Z2l9L+mm0rq1IGrB3Tj3RUF7C/XqbWV+6irb+ClBdtI7tSBCSld7Y7jdrQU3NgjF/ekrt4wbXGe3VGUsszstUVsLznClHFJeHvppHdW01JwY7ER7bhpcDQfrNrJrtJKu+Modc6q6+p5JSOXlO4hjOvTye44bsmSUhCRABGZKyJZIjJTmpmzVhq9KyIrReQLEfERkfEiUigi3zk+kq3Io370UHpPRITXdbSg3MDHmYUUHTrK1HHJOjV2K7FqpDAJKDTGpABhwNhmthkB+BhjhgHB/Phu5unGmJGOjxyL8iiHziEB3Dwkhk/XFOpoQbm06rp63licx6DYMC7s2dHuOG7LqlJIBxY4lhcBac1ssw94xbF84n2S14nIKhGZ1dwIQ527+0cn4O0lvLYo1+4oSp21j1bvYk9ZFb+6OElHCa3IqlKIAMocy+VAeNMNjDG5xphVInIN4AfMA/KBp4wxQ4AuwKjmvrmITBaRTBHJLC7WF8mcqU7BAdw8NIZZa4vYeUBHC8r1VNXW88bifAbHhTEiMcLuOG7NqlIoAY696ijE8fl/EZErgV8CE4wx9UApsNDx5QKg2ZeqGmNmGGNSjTGpkZGRFkX2LPePSsBHRwvKRX20ehd7y6t4REcJrc6qUsjgx2sE6cDiphuISGfgMeByY0yFY/UUYKKIeAH9gI0W5VFNRAUHcMvQWGavK6Kg5IjdcZRqsaraet5YkseQuHCGJ+goobVZVQrvA91EJJvGv/7zReSFJtvcTuMponmOO43uAqYBdwLfA3OMMZstyqOacd+oeMdoQe9EUq7jw1U72VdezSNje+oooQ1YMtesMaYauKLJ6kebbPMX4C/N7D7aigzq9KIcs0m+s6KAh9ITievYzu5ISp1S4yghn6E9whmeoHcctQV9eM3D3DsqHl9v4VW9tqBcwAerdrK/oppHLk6yO4rH0FLwMFEdApg0NJbP1hWxvfiw3XGUOqljo4Rh8eFcoNcS2oyWgge6d1QCfj5eTNNrC8qJ/d/3OynWUUKb01LwQJEd/Ll1WCyfrS8iX0cLyglV1dYz/dt8LoiPYFi8jhLakpaCh7p3VAL+Pt46WlBO6cdRQk+7o3gcLQUP1bG9P5OGxfD5en1uQTmXqtp6/uYYJQzVUUKb01LwYPdcFI+vt5fOoKqcyseZu9hfUc3DY3SUYActBQ8W1aFxTqTZ64p0BlXlFKrr6pm+JJ8hceEMi/+vKdRUG9BS8HD3jWqcQfWNJTpaUPb7dE0he8qqeHiMPr1sFy0FD9cpOICJg6P5dE0hhQd1tKDsU1PXwBuL8xkYE6ozodpIS0Fx36gEAP72bb7NSZQnm7228a1qOkqwl5aComtoIDekRvPx6kL2lB21O47yQLX1Dby+JI+U7iGMStLp8e2kpaCAxvctNBjDm99utzuK8kCfrStiV6mOEpyBloICIDo8iOsGduf/Vu1kf3mV3XGUB6mrb+D1xXn07RpMeq9m37Ol2pCWgjrugbQE6hsMby7V0YJqO19m76bgQKWOEpyEloI6LjaiHVcP6Mb73++guKLa7jjKA9Q3GF5blEevzh0Y27uT3XEUWgqqiV+kJVBT18Bby3S0oFrfVxv2sL34CA+P6YmXl44SnIElpSAiASIyV0SyRGSmNDMGbG6bluyn2lZ8ZHsmpHTlvZU7KD1SY3cc5cYaGgzTFuXSM6o94/t2tjuOcrBqpDAJKDTGpABhwNgWbtOS/VQbezAtkaO19fz9Ox0tqNYzb9Netu07zIPpiTpKcCJWlUI6sMCxvAhIa+E2LdlPtbGenTpwWb8uvLtiB4cqdbSgrGeM4dVFecR3bMcV/bvaHUedwKpSiADKHMvlQHMzWTW3TUv2Q0Qmi0imiGQWFxdbFFmdyoPpiRyuruOfywvsjqLc0MIt+9myp5xfpCXiraMEp2JVKZQAIY7lEMfnLdmmJfthjJlhjEk1xqRGRurTjm2hd5dgxvXpxD+W/0B5Va3dcZQbMcbwakYuMeFBXDVARwnOxqpSyADGOZbTgcUt3KYl+ymbPDymJxVVdfxrRYHdUZQbWbKtmA1FZfwiLQEfb70B0tlY9RN5H+gmItlAKZAvIi+cZpuMk6xTTqJftxDSe0Xx9nc/cLi6zu44yg0cGyV0Cw3kmvO72x1HNcPHim9ijKkGrmiy+tEWbNPcOuVEHkpP5Jo3VvDeyh3HZ1NV6mwtzzvAup2H+MPV/fDz0VGCM9Kfijql82PCuLBnR95aup2jNfV2x1Eu7tVFuXQODuCGVB0lOCstBXVavxzTkwNHanj/+x12R1EubOX2A6z6oZT7RsXj7+Ntdxx1EloK6rRS48IZnhDBm0u3U1WrowV1dl5blEtkB38mDomxO4o6BS0F1SIPpfekuKKaj1bvsjuKckFrdpSyPO8A914UT4CvjhKcmZaCapFh8eEMiQtn+pJ8qut0tKDOzCsZeUS08+PmoTpKcHZaCqpFRISHx/Rkb3kVH2cW2h1HuZB1Ow+ydFsx91wUT5CfJTc8qlakpaBabERiBINiw5i+OE9HC6rFXsnIJbydH7cOi7U7imoBLQXVYiLCL8f0ZHdZFZ+u0dGCOr31uw6xJKeYuy/sQTt/HSW4Ai0FdUYu7NmR82NCeWNxPjV1DXbHUU7u1YxcQoN8ue2COLujqBbSUlBn5NhooejQUWat1dGCOrnswkMs2rqfey6Mp72OElyGloI6Y6OSIkmJDmXaojwdLaiTejUjl5BAX267QK8luBItBXXGRIRHHKOF2TpaUM3YWFTGwi37uXtkDzoE+NodR50BLQV1VkYnR9K/ewjTFudRW6+jBfVTr2TkEhzgw+0j4uyOos6QloI6K8euLRQePMqctUV2x1FOZNPuMhZs3sfPR8YTrKMEl6OloM5aeq8ozuumowX1U69m5NIhwIc7dJTgkrQU1Fk79pTzztJKPlunowUFW/aUM2/TPu4a0YOQQB0luCItBXVOLu4dRd+uwUxbnEedjhY83qsZuXTw9+GuET3sjqLOkiWlICIBIjJXRLJEZKaIyEm2ExF5V0RWisgXIuIjIuNFpFBEvnN8JFuRSbWNY9cWdhyoZLaOFjzapt1lfL1xL3eOiCMkSEcJrsqqkcIkoNAYkwKEAWNPst0IwMcYMwwIBsY51k83xox0fORYlEm1kbF9OnFetxBezcjVawse7KUFjdcSfj4y3u4o6hxYVQrpwALH8iIg7STb7QNecSzXnLD+OhFZJSKzTjbKUM5LRJgyNonCg0f5RGdQ9UjZhYdYuGUf91wYr6MEF2dVKUQAZY7lciC8uY2MMbnGmFUicg3gB8wD8oGnjDFDgC7AqKb7ichkEckUkczi4mKLIisrjU6O5PyYUKYtytUZVD3QXxdsIzTIlzv1jiOXZ1UplAAhjuUQx+fNEpErgV8CE4wx9UApsNDx5QIgquk+xpgZxphUY0xqZGSkRZGVlUSEqWOT2V1WxYer9O1snmTNjoMsySnm3osS9OllN2BVKWTw4/WBdGBxcxuJSGfgMeByY0yFY/UUYKKIeAH9gI0WZVJtbERiBEPiwnl9cZ6+y9mD/HVBDh3b+3H7cJ3jyB1YVQrvA91EJJvGv/wzRKSHiLzQZLvbaTxFNM9xp9FdwDTgTuB7YI4xZrNFmVQbExGmjEtif0U1763cYXcc1QZWbj/A8rwD3DcqQd+q5ibEGGN3hjOSmppqMjMz7Y6hTuGWt1eSs7eCpY+n6S8KN2aM4aY3V1Jw4AhLH08jwNfb7kjqFERkjTEm9XTb6cNrynJTxiZTcriGd1foaMGdLc87wKqCUn6RlqiF4Ea0FJTlBsWGMTo5kjeX5lNRVWt3HNUKjDG8uCCHriEBTBwSbXccZSEtBdUqfnVxEocqa3lneYHdUVQrWJJTzLqdh3gwvSf+PjpKcCdaCqpVpESHcnHvTry1bDtlR3W04E6MMfx1wTaiwwO5IbW73XGUxbQUVKuZMjaJ8qo6ZizNtzuKstA3G/eyoaiMh9N74uutv0Lcjf5EVavp0zWYK1O68vfvfmB/eZXdcZQF6uobeH5+Dj2j2nPtQB0luCMtBdWqpo5Loq7e8EpGrt1RlAU+WVPI9uIjPHZJMt5eOk2ZO9JSUK0qNqIdNw+N4cPVu9hefNjuOOocHK2p5+WF2xgUG8bYPp3sjqNaiZaCanUPpffE38eLF+dvszuKOgf/XPED+8qreWJ8L3QyY/elpaBaXWQHf+4e2YOvNuwhu/CQ3XHUWThUWcP0Jfmk94piSI9mJ0FWbkJLQbWJey6KJ7ydH3/5ZqvdUdRZmL4kn8PVdTw+Xl+M6O60FFSb6BDgy4NpiSzPO8CyXH0nhivZU3aUd1YUcM353ejVOdjuOKqVaSmoNnPLsBi6hwXyl2+20tDgWhMxerKXF+RiTONzJ8r9aSmoNuPv482UsUlsLCrnqw177I6jWiBvfwWfrNnFpGGxdA8LsjuOagNaCqpNXTWgG706d+CF+TnU1DXYHUedxnPf5BDk58OD6Yl2R1FtREtBtSlvL+Hx8cnsOFDJh6t32h1HncKaHQeZv3kfkx03CSjPYEkpiEiAiMwVkSwRmSknuYlZRMaLSKHjrWvfiUhyS/dV7iMtOYph8eG8tGAbZZU6WZ4zamgw/H7uZqI6+PPzkT3sjqPakFUjhUlAoTEmBQgDxp5i2+nGmJGOj5wz3Fe5ARHhqSv6cOhoLa8u0ukvnNHnWUVk7TrE4+N70c5f357nSawqhXRggWN5EZB2im2vE5FVIjLLMSo4k32Vm+jbNYSJg6N5d0UB+Tr9hVOprKnjL1/n0L97CNee383uOKqNWVUKEUCZY7kcONkjj/nAU8aYIUAXYNQZ7KvczJSxyQT4evPHr7bYHUWd4G9L8tlbXsXTV/TBSye98zhWlUIJEOJYDnF83pxSYKFjuQCIasm+IjJZRDJFJLO4WB98cheRHfx5KD2RRVv38+02/bk6g6JDR3lz6XYmpHQlNU7/PvNEVpVCBjDOsZwOLD7JdlOAiSLiBfQDNrZkX2PMDGNMqjEmNTIy0qLIyhncMSKO2Igg/jB3M3X1eouq3Z79eisi8P8u7WV3FGUTq0rhfaCbiGTTOBrIEJEeIvJCk+2mAXcC3wNzjDGbm9vXokzKBfj7ePOby3qTu/8w73+vt6jaKbOglC+zdjP5ogS6hQbaHUfZxJLbCowx1cAVTVb/ADzaZLs9wOgW7Ks8yNg+nRieEMFLC7dx1YCuhAbpPfFtraHB8L9fbqZzcAD3jYq3O46ykT68pmwnIjw9oQ/lR2t5eaHeomqH2euK2FBUxhOXJhPkp7egejItBeUUenUO5mdDYpi5cgd5+yvsjuNRjlTX8dw3WxkQHcpVKXoLqqfTUlBOY8rYJIL8vPnfLzdjjM6i2lamLc5jf0U1T0/QW1CVloJyIhHt/Zk6NolluSV8kbXb7jgeIWdvBW8t3c51A7szMCbM7jjKCWgpKKdy6wVxpHQP4Zm5m3VepFbW0GD49ZwNdAjw4TeX97Y7jnISWgrKqXh7CX+69jwOVtbyrL66s1V9sHona3Yc5H8u76OzoKrjtBSU0+nbNYS7RsTxwaqdrC4otTuOW9qbfk49AAALjElEQVRfUcWzX29leEIE1w7Ui8vqR1oKyin9amwS3UID+fXsDfoynlbw+y83U13XwB+u7ofOVq9OpKWgnFKQnw/PXN2X3P2HmbE03+44bmVxzn7mZu/hwbRE4iPb2x1HORktBeW00nt14vLzuvDqojwKSo7YHcctVNbU8dRnG0mMas+9+uSyaoaWgnJqT0/og7+3F7/5bIM+u2CBVzJyKTx4lD9e3Q9/H2+74ygnpKWgnFqn4AAeH5/M8rwDfLa+yO44Lm3LnnLeXvYDN6VGMzQ+wu44yklpKSind8vQWAZEh/LM3C3sr6iyO45Lqq1v4IlZ2YQG+vLkZTottjo5LQXl9Ly8hOev78+R6jqe+DRbTyOdhVczcskuLOOZq/vpLLTqlLQUlEvo2akDT17ai8U5xby3cofdcVxKZkEpry/O4/pB3bnsvC52x1FOTktBuYzbh8cxKimSP3y1RWdSbaGKqlp+9fF6uocF8bsr+9odR7kALQXlMkQaTyMF+XnzyEfr9aG2FvjdF5spOniUl25Kob2/vidBnZ4lpSAiASIyV0SyRGSmnOQRSREZLSLfOT52icjtIjJeRApPWJ9sRSblnqKCA/jztf3ZWFTOywu32R3HqX2VvYdZawt5MC2RQbHhdsdRLsKqkcIkoNAYkwKEAWOb28gYs8QYM9IYMxLIBtY5vjT92HpjTI5FmZSbGt+vMzelRjP923y+337A7jhOaW9ZFb+es4GU6FAeGtPT7jjKhVhVCunAAsfyIiDtVBuLSBCQaIzJdqy6TkRWicisk40ylDrR0xP6EBMexJSPsyiv0im2T9TQYJj6SePptZdvGoCvt54lVi1n1f8tEUCZY7kcON1YdSyQ4VjOB54yxgwBugCjmm4sIpNFJFNEMouLiy2KrFxZO38fXrppAHvLq/jt55vsjuNU/rH8B5bnHeDpCX3o0bGd3XGUi7GqFEqAEMdyiOPzU5kAzHUslwILHcsFQFTTjY0xM4wxqcaY1MjIyHNPq9zCwJgwHkpPZM66Ij5YtdPuOE5hzY5Snvsmh4t7d2Li4Gi74ygXZFUpZADjHMvpwOKTbeg4PZRG42kmgCnARBHxAvoBGy3KpDzAg2mJXJQUydOfb2TVD5797oXdh45y78y1dAkN4IUb+uuU2OqsWFUK7wPdRCSbxr/8M0Skh4i80My2g4FNxphj8xVMA+4EvgfmGGM2W5RJeQAfby9e+9n5RIcFcf97ayg8WGl3JFscraln8sxMqmrrefu2VH1qWZ01cbUpA1JTU01mZqbdMZSTyS8+zNXTlhMdHsSn919AkJ/n3JNvjOHhD9czN3s3b9+WypjeneyOpJyQiKwxxqSebju9LUG5hYTI9rx68/ls2VvOY5941vxIbyzJ58us3Tx2SbIWgjpnWgrKbaQlR/Hkpb34asMepi3KsztOm1i4eR8vzM/hypSu3D8qwe44yg14zhhbeYR7Loxny54KXlywjaTOHbikb2e7I7Wa3H0VPPLRevp1DeG56/XCsrKGjhSUWxER/nzteaREh/Krj9azaXfZ6XdyQSWHq7n7X5kE+Hoz47ZBBPjqW9SUNbQUlNsJ8PVmxq2DCA30ZdLb37N5d7ndkSxVcriaW976nn3lVbx56yC6hATaHUm5ES0F5ZY6BQfwweRhBPp6c8vbK92mGI4Vwo7SI/zjjsEMig2zO5JyM1oKym3FRrTjg8nDCHCTYjjQpBCGJ3S0O5JyQ1oKyq3FRrTjwxOKYcse1yyGA4eruflYIdyuhaBaj5aCcnsnFsPNb7leMfxXISRqIajWo6WgPEJsRDs+uOfHYnCVu5KKK34shL9rIag2oKWgPEZcxx+L4brpK5i1ptDuSKe0uqCUK15bdrwQRmghqDagpaA8SlzHdnz+4AgGRIcy9ZMsnpydTVVtvd2xfsIYw1tLtzNxxkoCfb2Zff8ILQTVZvSJZuVxojoE8N7Ph/Ligm1MX5JPdmEZ028ZRExEkN3RKDtay2OfZDF/8z7G9+3Mczf0JzjA1+5YyoPoSEF5JB9vL54Y34u3b0tlV2kll7+2jPmb9tqaadPuMq6c9h2Ltu7nfy7vzfRJA7UQVJvTUlAe7eI+nfjq4QuJi2jH5Jlr+O3nGyk9UtOmGapq63lr6XaufWMF1bUNfDh5GHdfGK9zGSlb6PsUlKLxF/Of/72FmSt3EOjrzV0je3D3hfGEBLbeX+o1dQ18nLmLaYvy2FteRVpyJM/fkELH9v6t9m8qz9XS9yloKSh1grz9Fby0IJevNuwhOMCHe0clcMfwONr5W3f5ra6+gc/W7+aVjG3sKj1KamwYU8clc0FChGX/hlJNtXkpiIgvMNsYM+EU2wQAnwLRQDZwG+DfdJ05RSgtBdUWNu0u46/zt5GxdT8R7fz4+YU9uLh3J3pGtT/r0zq7Dx1l6bZiZizbzvbiI5zXLYSp45IYlRSpp4pUq2vTUhCRQBrfsZxkjAk4xXZ3A6nGmPtEZC7wKhDTdJ0xZv7JvoeWgmpLa3ce5MX5OSzPOwBAZAd/hidEMCKhI8MTI+gedvI7lkqP1PCf/AOsyC9hRf4Bfig5AkBSp/ZMGZvEJX07axmoNtPSUrBkTGyMOQr0F5HTve4qHZjlWF4EpAGxzaw7aSko1ZYGxoTx/t3D2FVayYr8EpbnHWB53gE+X78bgG6hgQT5/fe7DGrrG9hRWokx0N7fh6E9wpk0LJYRiREkRXXAy0vLQDmntn5OIQI4Nr9AOZB8knU/ISKTgckAMTExrZ9SqSaiw4O4KTyGmwbHYIwhd/9hlueVsH7XIWrrG/5re0G4flB3LkjoSEr3EHy89UY/5RrauhRKgBDHcojj8/bNrPsJY8wMYAY0nj5q/ZhKnZyIkNSpA0mdOtgdRSnLtfWfLxnAOMdyOrD4JOuUUkrZoNVKQUR6iMgLTVa/D3QTkWyglMZCaG6dUkopG1h6+sgYk3jC8g/Ao02+Xg1c0WS35tYppZSygV79UkopdZyWglJKqeO0FJRSSh2npaCUUuo4LQWllFLHudwsqSJSDOw4y9070szDcR7CU49dj9uz6HGfXKwxJvJ038jlSuFciEhmSyaEckeeeux63J5Fj/vc6ekjpZRSx2kpKKWUOs7TSmGG3QFs5KnHrsftWfS4z5FHXVNQSil1ap42UlBKKXUKHlEKIhIgInNFJEtEZooHvANRRHxF5EvHskccvzR6V0RWisgXItLeQ47bR0Q+EZHlIvIPT/l5HyMivxKRhSLSUUSWicgGEXnW7lytRUTGi0ihiHzn+Eix8uftEaUATAIKjTEpQBgw1uY8rcrxzuw1/HicnnL8IwAfY8wwIBi4C8847quBLGPMCKAL8CCecdyISCxwh+PTR4CvgBTgUhFJsitXG5hujBlpjBkJDMbCn7enlEI6sMCxfOw90G7LGHPUGNMfKHSs8pTj3we84liuAX6HZxz3N8BfRcQHCAUG4hnHDY0/7ycdy+nAAmNMA/At7n3c14nIKhGZBYzBwp+3p5RC0/dAh9uYxQ4ecfzGmFxjzCoRuQbwo3G05AnHfdgYUwksp7EYPeLnLSI3A1nAZscqjzhuIB94yhgzhMaR4bVYeNyeUgrNvRvak3jM8YvIlcAvgQnAfjzguEUkQkT8geE0nj7ohwccN40v5xoDfAgMonGqB0847lJgoWO5AGjAwuP2lFLw9PdAe8Txi0hn4DHgcmNMBR5y3MBU4AZjTD1QCfwRDzhuY8zNjnPqE2kcFb4OjBMRL2AUbnrcwBRgouM4+9H487fs5+0ppeDp74H2lOO/ncbh9DwR+Q7wxTOO+3XgLhH5D3AA+DuecdxNvQpcBmQDXxlj8mzO01qmAXcC3wNzsPjnrQ+vKaWUOs5TRgpKKaVaQEtBKaXUcVoKSimljtNSUEopdZyWglJKqeO0FJRSSh2npaCUUuq4/w+FENYmOkBVcAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "t = linspace(0, 2*pi, 50)\n", + "x = sin(t)\n", + "y = cos(t)\n", + "plt.figure()\n", + "plt.plot(x)\n", + "plt.figure()\n", + "plt.plot(y);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "或者使用 `subplot` 在一幅图中画多幅子图：\n", + "\n", + " subplot(row, column, index)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.subplot(1, 2, 1)\n", + "plt.plot(x)\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(y);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：在上下排布的2个子图中，显示sin(x)和cos(x)的图像，请编写代码实现。" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(x)\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(y);\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 向图中添加数据" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "默认多次 `plot` 会叠加：" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x)\n", + "plt.plot(y);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 标签" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "可以在 `plot` 中加入 `label` ，使用 `legend` 加上图例：" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, label='sin')\n", + "plt.plot(y, label='cos')\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "或者直接在 `legend`中加入：" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x)\n", + "plt.plot(y)\n", + "plt.legend(['sin', 'cos']);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 坐标轴，标题，网格" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "可以设置坐标轴的标签和标题：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = linspace(0, 2 * pi, 50)\n", + "plt.plot(x, sin(x))\n", + "plt.xlabel('radians')\n", + "# 可以设置字体大小\n", + "plt.ylabel('amplitude', fontsize='large')\n", + "plt.title('Sin(x)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "用 'grid()' 来显示网格：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sin(x))\n", + "plt.xlabel('radians')\n", + "plt.ylabel('amplitude', fontsize='large')\n", + "plt.title('Sin(x)')\n", + "plt.grid();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：绘制 cos(x) 的图，包含坐标轴、标题和网格。" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(x, cos(x))\n", + "plt.xlabel('radians')\n", + "plt.ylabel('amplitude', fontsize='large')\n", + "plt.title('Cos(x)')\n", + "plt.grid();\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 直方图" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "从高斯分布随机生成1000个点得到的直方图：" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(np.random.randn(1000));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "更多例子请参考下列网站：\n", + "\n", + "http://matplotlib.org/gallery.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求： 已知某商店出售 3 种水果，当天的营业额分别为苹果：100，香蕉：200，葡萄：250，请绘制饼图，显示三种水果的占比。" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "labels = [u'苹果',u'香蕉',u'葡萄'] #定义标签\n", + "sizes = [100,200,300,] #每块值\n", + "plt.pie(sizes, labels=labels, autopct = '%3.2f%%');\n" + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/3Pandas 基础.ipynb b/3Pandas 基础.ipynb new file mode 100644 index 0000000..b7dce12 --- /dev/null +++ b/3Pandas 基础.ipynb @@ -0,0 +1,2106 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pandas 基础" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在这节课中，我们将会学习到 Pandas 的相关内容。\n", + "\n", + "\n", + "`Pandas` 基于 `NumPy` 创建，并纳入了大量库及一些标准的数据模型， \n", + "提供了大量能使我们快速便捷地处理数据的函数与方法，可以高效的操作大型数据集。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": true + }, + "source": [ + "## 产生 Pandas 对象" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`pandas` 中有三种基本结构：\n", + "\n", + "- `Series`\n", + " - 1D labeled homogeneously-typed array\n", + "- `DataFrame`\n", + " - General 2D labeled, size-mutable tabular structure with potentially heterogeneously-typed columns\n", + "- `Panel`\n", + " - General 3D labeled, also size-mutable array" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Series" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "一维 `Series` 可以用一维列表初始化：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s = pd.Series([1,3,5,np.nan,6,8])\n", + "print(s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "默认情况下，`Series` 的下标都是数字（可以使用额外参数指定），类型是统一的。\n", + "\n", + "### DataFrame\n", + "\n", + "`DataFrame` 则是个二维结构，这里首先构造一组时间序列，作为我们第一维的下标：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "dates = pd.date_range('20130101', periods=6)\n", + "print(dates)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "然后创建一个 `DataFrame` 结构：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "默认情况下，如果不指定 `index` 参数和 `columns`，那么他们的值将用从 `0` 开始的数字替代。\n", + "\n", + "除了向 `DataFrame` 中传入二维数组，我们也可以使用字典传入数据：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df2 = pd.DataFrame({'A' : 1.,\n", + " 'B' : pd.Timestamp('20130102'),\n", + " 'C' : pd.Series(1,index=list(range(4)),dtype='float32'),\n", + " 'D' : np.array([3] * 4,dtype='int32'),\n", + " 'E' : pd.Categorical([\"test\",\"train\",\"test\",\"train\"]),\n", + " 'F' : 'foo' })\n", + "\n", + "df2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "字典的每个 `key` 代表一列，其 `value` 可以是各种能够转化为 `Series` 的对象。\n", + "\n", + "与 `Series` 要求所有的类型都一致不同，`DataFrame` 值要求每一列数据的格式相同：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df2.dtypes" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": true + }, + "source": [ + "## 查看数据" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 头尾数据" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`head` 和 `tail` 方法可以分别查看最前面几行和最后面几行的数据（默认为 5）：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "最后 3 行：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.tail(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：查看df 的前 2 行数据。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.head(2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 下标，列标，数据" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下标使用 `index` 属性查看：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.index" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "列标使用 `columns` 属性查看：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "数据值使用 `values` 查看：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 统计数据" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "查看简单的统计数据：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 转置" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 排序" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`sort_index(axis=0, ascending=True)` 方法按照下标大小进行排序，`axis=0` 表示按第 0 维进行排序。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.sort_index(ascending=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.sort_index(axis=1, ascending=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`sort_values(by, axis=0, ascending=True)` 方法按照 `by` 的值的大小进行排序，例如按照 `B` 列的大小：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.sort_values(by=\"B\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：将 df 的按 A 列由大到小排序。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.sort_values(by='A', ascending=False)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": false + }, + "source": [ + "## 索引" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "虽然 `DataFrame` 支持 `Python/Numpy` 的索引语法，但是推荐使用 `.at, .iat, .loc, .iloc 和 .ix` 方法进行索引。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 读取数据" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "选择单列数据：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[\"A\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "也可以用 `df.A`：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.A" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用切片读取多行：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[0:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`index` 名字也可以进行切片：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[\"20130101\":\"20130103\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 使用 `label` 索引" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`loc` 可以方便的使用 `label` 进行索引：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.loc[dates[0]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "多列数据：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.loc[:,['A','B']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "选择多行多列：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.loc['20130102':'20130104',['A','B']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "数据降维：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.loc['20130102',['A','B']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "得到标量值：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.loc[dates[0],'B']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "不过得到标量值可以用 `at`，速度更快：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%timeit -n100 df.loc[dates[0],'B']\n", + "%timeit -n100 df.at[dates[0],'B']\n", + "\n", + "print(df.at[dates[0],'B'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 使用位置索引" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`iloc` 使用位置进行索引：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.iloc[3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "连续切片：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.iloc[3:5,0:2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "索引不连续的部分：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.iloc[[1,2,4],[0,2]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "索引整行：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.iloc[1:3,:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "整列：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.iloc[:, 1:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "标量值：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.iloc[1,1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "当然，使用 `iat` 索引标量值更快：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%timeit -n100 df.iloc[1,1]\n", + "%timeit -n100 df.iat[1,1]\n", + "\n", + "df.iat[1,1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 布尔型索引" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "所有 `A` 列大于 0 的行：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[df.A > 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "只留下所有大于 0 的数值：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[df > 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用 `isin` 方法做 `filter` 过滤：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df2 = df.copy()\n", + "df2['E'] = ['one', 'one','two','three','four','three']\n", + "\n", + "df2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df2[df2['E'].isin(['two','four'])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：删选 df A 列大于 -1 的数据，并只展示 B 列的数据。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df[df.A > -1].B\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 设定数据的值" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s1 = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102', periods=6))\n", + "\n", + "s1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "像字典一样，直接指定 `F` 列的值为 `s1`，此时以 `df` 已有的 `index` 为标准将二者进行合并，`s1` 中没有的 `index` 项设为 `NaN`，多余的项舍去：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df['F'] = s1\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "或者使用 `at` 或 `iat` 修改单个值：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.at[dates[0],'A'] = 0\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.iat[0, 1] = 0\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "设定一整列：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.loc[:,'D'] = np.array([5] * len(df))\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "设定满足条件的数值：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df2 = df.copy()\n", + "\n", + "df2[df2 > 0] = -df2\n", + "\n", + "df2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 缺失数据" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])\n", + "df1.loc[dates[0]:dates[1],'E'] = 1\n", + "\n", + "df1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "丢弃所有缺失数据的行得到的新数据：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df1.dropna(how='any')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "填充缺失数据：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df1.fillna(value=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "检查缺失数据的位置：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pd.isnull(df1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": false + }, + "source": [ + "## 计算操作" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 统计信息" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "每一列的均值：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "每一行的均值：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.mean(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "多个对象之间的操作，如果维度不对，`pandas` 会自动调用 `broadcasting` 机制：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s = pd.Series([1,3,5,np.nan,6,8], index=dates).shift(2)\n", + "\n", + "s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "相减 `df - s`：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.sub(s, axis='index')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "要求：计算 df B 列的和。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df['B'].sum()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### apply 操作" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "与 `R` 中的 `apply` 操作类似，接收一个函数，默认是对将函数作用到每一列上：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.apply(np.cumsum)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "求每列最大最小值之差：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.apply(lambda x: x.max() - x.min())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 直方图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s = pd.Series(np.random.randint(0, 7, size=10))\n", + "\n", + "s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "直方图信息：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s.value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "绘制直方图信息：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "h = s.hist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 字符串方法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "当 `Series` 或者 `DataFrame` 的某一列是字符串时，我们可以用 `.str` 对这个字符串数组进行字符串的基本操作： " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])\n", + "\n", + "s.str.lower()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": false + }, + "source": [ + "## 合并" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 连接" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df = pd.DataFrame(np.random.randn(10, 4))\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "可以使用 `pd.concat` 函数将多个 `pandas` 对象进行连接：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [], + "source": [ + "pieces = [df[:2], df[4:5], df[7:]]\n", + "\n", + "pd.concat(pieces)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据库中的 Join" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`merge` 可以实现数据库中的 `join` 操作：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})\n", + "right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})\n", + "\n", + "print(left)\n", + "print(right)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pd.merge(left, right, on='key')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### append" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "向 `DataFrame` 中添加行：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "将第三行的值添加到最后：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s = df.iloc[3]\n", + "\n", + "df.append(s, ignore_index=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grouping" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',\n", + " 'foo', 'bar', 'foo', 'foo'],\n", + " 'B' : ['one', 'one', 'two', 'three',\n", + " 'two', 'two', 'one', 'three'],\n", + " 'C' : np.random.randn(8),\n", + " 'D' : np.random.randn(8)})\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "按照 `A` 的值进行分类：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.groupby('A').sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "按照 `A, B` 的值进行分类：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.groupby(['A', 'B']).sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": false + }, + "source": [ + "## 改变形状" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stack" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "产生一个多 `index` 的 `DataFrame`：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',\n", + " 'foo', 'foo', 'qux', 'qux'],\n", + " ['one', 'two', 'one', 'two',\n", + " 'one', 'two', 'one', 'two']]))\n", + "\n", + "index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])\n", + "df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`stack` 方法将 `columns` 变成一个新的 `index` 部分：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df2 = df[:4]\n", + "\n", + "stacked = df2.stack()\n", + "\n", + "stacked" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "可以使用 `unstack()` 将最后一级 `index` 放回 `column`：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "stacked.unstack()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "也可以指定其他的级别：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "stacked.unstack(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 时间序列" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "金融分析中常用到时间序列数据：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "rng = pd.date_range('3/6/2012 00:00', periods=5, freq='D')\n", + "ts = pd.Series(np.random.randn(len(rng)), rng)\n", + "\n", + "ts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "标准时间表示：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ts_utc = ts.tz_localize('UTC')\n", + "\n", + "ts_utc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "改变时区表示：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [], + "source": [ + "ts_utc.tz_convert('US/Eastern')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Categoricals" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df = pd.DataFrame({\"id\":[1,2,3,4,5,6], \"raw_grade\":['a', 'b', 'b', 'a', 'a', 'e']})\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "可以将 `grade` 变成类别：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[\"grade\"] = df[\"raw_grade\"].astype(\"category\")\n", + "\n", + "df[\"grade\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "将类别的表示转化为有意义的字符：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[\"grade\"].cat.categories = [\"very good\", \"good\", \"very bad\"]\n", + "\n", + "df[\"grade\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "添加缺失的类别：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df[\"grade\"] = df[\"grade\"].cat.set_categories([\"very bad\", \"bad\", \"medium\", \"good\", \"very good\"])\n", + "df[\"grade\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用 `grade` 分组：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.groupby(\"grade\").size()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 绘图" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用 `ggplot` 风格：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "plt.style.use('ggplot')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Series` 绘图：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))\n", + "\n", + "p = ts.cumsum().plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`DataFrame` 按照 `columns` 绘图：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,\n", + " columns=['A', 'B', 'C', 'D'])\n", + "\n", + "df.cumsum().plot()\n", + "p = plt.legend(loc=\"best\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": false + }, + "source": [ + "## 文件读写" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "写入文件：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "df.to_csv('foo.csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "从文件中读取：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pd.read_csv('foo.csv').head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### excel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "写入文件：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "df.to_excel('foo.xlsx', sheet_name='Sheet1')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "读取文件：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA']).head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "清理生成的临时文件：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import glob\n", + "import os\n", + "\n", + "for f in glob.glob(\"foo*\"):\n", + " os.remove(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **编程练习**\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "data = {'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],\n", + " 'age': [2.5, 5, 0.5, np.nan, 5, 2, 4.5, np.nan, 5, 3],\n", + " 'visits': [1, 4, 2, 3, 2, 3, 1, 2, 2, 1],\n", + " 'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}\n", + "\n", + "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n", + "df_test = pd.DataFrame(data, index=labels)\n", + "df_test" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. 要求： 取出 age 值大于3的行" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_test[df_test['age'] > 3]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. 要求： 使用 iloc 方法展示前三行" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_test.iloc[:3]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. 要求： 计算 visits 的总和。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 请编写你的答案\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_test['visits'].sum()\n" + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/4Sklearn 基础.ipynb b/4Sklearn 基础.ipynb new file mode 100644 index 0000000..5453d05 --- /dev/null +++ b/4Sklearn 基础.ipynb @@ -0,0 +1,809 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scikit-learn基础" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "\n", + "\n", + "+ **Python** 语言的机器学习工具\n", + "+ `Scikit-learn` 包括大量常用的机器学习算法\n", + "+ `Scikit-learn` 文档完善，容易上手" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 机器学习算法" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "**机器学习算法是一类从数据中自动分析获得规律，并利用规律对未知数据进行预测的算法**。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "\n", + "\n", + "由图中，可以看到机器学习 `sklearn` 库的算法主要有四类：分类，回归，聚类，降维。其中：\n", + "\n", + "+ 常用的回归：线性、决策树、`SVM`、`KNN` ； \n", + " 集成回归：随机森林、`Adaboost`、`GradientBoosting`、`Bagging`、`ExtraTrees` \n", + "+ 常用的分类：线性、决策树、`SVM`、`KNN`、朴素贝叶斯； \n", + " 集成分类：随机森林、`Adaboost`、`GradientBoosting`、`Bagging`、`ExtraTrees` \n", + "+ 常用聚类：`k` 均值（`K-means`）、层次聚类（`Hierarchical clustering`）、`DBSCAN` \n", + "+ 常用降维：`LinearDiscriminantAnalysis`、`PCA` 　　\n", + "\n", + "这个流程图代表：蓝色圆圈是判断条件，绿色方框是可以选择的算法，我们可以根据自己的数据特征和任务目标去找一条自己的操作路线。 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `sklearn` 数据集" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "+ `sklearn.datasets.load_*()`\n", + " + 获取小规模数据集，数据包含在 `datasets` 里\n", + "+ `sklearn.datasets.fetch_*(data_home=None)`\n", + " + 获取大规模数据集，需要从网络上下载，函数的第一个参数是 `data_home`，表示数据集下载的目录,默认是 `/scikit_learn_data/`\n", + " \n", + "`sklearn` 常见的数据集如下：\n", + "\n", + "||数据集名称|调用方式|适用算法|数据规模|\n", + "|--|--|--|--|--|\n", + "|小数据集|波士顿房价|load_boston()|回归|506\\*13|\n", + "|小数据集|鸢尾花数据集|load_iris()|分类|150\\*4|\n", + "|小数据集|糖尿病数据集|\tload_diabetes()|\t回归\t|442\\*10|\n", + "|大数据集|手写数字数据集|\tload_digits()|\t分类|\t5620\\*64|\n", + "|大数据集|Olivetti脸部图像数据集|\tfetch_olivetti_facecs|\t降维|\t400\\*64\\*64|\n", + "|大数据集|新闻分类数据集|\tfetch_20newsgroups()|\t分类|-|\t \n", + "|大数据集|带标签的人脸数据集|\tfetch_lfw_people()|\t分类、降维|-|\t \n", + "|大数据集|路透社新闻语料数据集|\tfetch_rcv1()|\t分类|\t804414\\*47236|" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.datasets import load_iris\n", + "# 获取鸢尾花数据集\n", + "iris = load_iris()\n", + "print(\"鸢尾花数据集的返回值：\\n\", iris.keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据预处理\n", + "\n", + "通过**一些转换函数**将特征数据转换成**更加适合算法模型**的特征数据过程。常见的有数据标准化、数据二值化、标签编码、独热编码等。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 导入内建数据集\n", + "from sklearn.datasets import load_iris\n", + "\n", + "# 获取鸢尾花数据集\n", + "iris = load_iris()\n", + "\n", + "# 获得 ndarray 格式的变量 X 和标签 y\n", + "X = iris.data\n", + "y = iris.target\n", + "\n", + "# 获得数据维度\n", + "n_samples, n_features = iris.data.shape\n", + "\n", + "print(n_samples, n_features)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 数据标准化\n", + "\n", + "数据标准化和归一化是将数据映射到一个小的浮点数范围内，以便模型能快速收敛。\n", + "\n", + "标准化有多种方式，常用的一种是min-max标准化（对象名为MinMaxScaler），该方法使数据落到[0,1]区间：\n", + "\n", + "$x^{'}=\\frac{x-x_{min}}{x_{max} - x_{min}}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# min-max标准化\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "sc = MinMaxScaler()\n", + "sc.fit(X)\n", + "results = sc.transform(X)\n", + "print(\"放缩前：\", X[1])\n", + "print(\"放缩后：\", results[1])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "另一种是Z-score标准化（对象名为StandardScaler），该方法使数据满足标准正态分布：\n", + "\n", + "$x^{'}=\\frac{x-\\overline {X}}{S}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# Z-score标准化\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "#将fit和transform组合执行\n", + "results = StandardScaler().fit_transform(X) \n", + "\n", + "print(\"放缩前：\", X[1])\n", + "print(\"放缩后：\", results[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "归一化（对象名为Normalizer，默认为L2归一化）：\n", + "\n", + "$x^{'}=\\frac{x}{\\sqrt{\\sum_{j}^{m}x_{j}^2}}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 归一化\n", + "from sklearn.preprocessing import Normalizer\n", + "\n", + "results = Normalizer().fit_transform(X) \n", + "\n", + "print(\"放缩前：\", X[1])\n", + "print(\"放缩后：\", results[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 数据二值化\n", + "\n", + "使用阈值过滤器将数据转化为布尔值，即为二值化。使用Binarizer对象实现数据的二值化：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 二值化，阈值设置为3\n", + "from sklearn.preprocessing import Binarizer\n", + "\n", + "results = Binarizer(threshold=3).fit_transform(X)\n", + "\n", + "print(\"处理前：\", X[1])\n", + "print(\"处理后：\", results[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 标签编码\n", + "\n", + "使用 LabelEncoder 将不连续的数值或文本变量转化为有序的数值型变量：\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 标签编码\n", + "from sklearn.preprocessing import LabelEncoder\n", + "LabelEncoder().fit_transform(['apple', 'pear', 'orange', 'banana'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 独热编码\n", + "\n", + "对于无序的离散型特征，其数值大小并没有意义，需要对其进行one-hot编码，将其特征的m个可能值转化为m个二值化特征。可以利用OneHotEncoder对象实现：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 独热编码\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "\n", + "results = OneHotEncoder().fit_transform(y.reshape(-1,1)).toarray()\n", + "\n", + "print(\"处理前：\", y)\n", + "print(\"处理后：\", results[1])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据集的划分\n", + "\n", + "机器学习一般的数据集会划分为两个部分：\n", + "+ 训练数据：用于训练，构建模型\n", + "+ 测试数据：在模型检验时使用，用于评估模型是否有效\n", + "\n", + "
\n", + "\n", + "划分比例：\n", + "+ 训练集：70% 80% 75%\n", + "+ 测试集：30% 20% 25%\n", + "\n", + "
\n", + "\n", + "`sklearn.model_selection.train_test_split(x, y, test_size, random_state )`\n", + "\n", + " + `x`：数据集的特征值\n", + " + `y`： 数据集的标签值\n", + " + `test_size`： 如果是浮点数，表示测试集样本占比；如果是整数，表示测试集样本的数量。\n", + " + `random_state`： 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。\n", + " + `return` 训练集的特征值 `x_train` 测试集的特征值 `x_test` 训练集的目标值 `y_train` 测试集的目标值 `y_test`。\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# 加载数据集\n", + "iris = load_iris()\n", + "\n", + "# 对数据集进行分割\n", + "# 训练集的特征值x_train 测试集的特征值x_test 训练集的目标值y_train 测试集的目标值y_test\n", + "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target,test_size=0.3, random_state=22)\n", + "\n", + "print(\"x_train:\", X_train.shape)\n", + "print(\"y_train:\", y_train.shape) \n", + "print(\"x_test:\", X_test.shape)\n", + "print(\"y_test:\", y_test.shape)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 定义模型" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "#### 估计器（`Estimator`）\n", + "估计器，很多时候可以直接理解成分类器，主要包含两个函数：\n", + "\n", + "+ `fit()`：训练算法，设置内部参数。接收训练集和类别两个参数。\n", + "+ `predict()`：预测测试集类别，参数为测试集。\n", + "\n", + "大多数 `scikit-learn` 估计器接收和输出的数据格式均为 `NumPy`数组或类似格式。\n", + "\n", + "
\n", + "\n", + "#### 转换器（`Transformer`） \n", + "转换器用于数据预处理和数据转换，主要是三个方法：\n", + "\n", + "+ `fit()`：训练算法，设置内部参数。\n", + "+ `transform()`：数据转换。\n", + "+ `fit_transform()`：合并 `fit` 和 `transform` 两个方法。\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在 `scikit-learn` 中，所有模型都有同样的接口供调用。监督学习模型都具有以下的方法：\n", + "+ `fit`：对数据进行拟合。\n", + "+ `set_params`：设定模型参数。\n", + "+ `get_params`：返回模型参数。\n", + "+ `predict`：在指定的数据集上预测。\n", + "+ `score`：返回预测器的得分。\n", + "\n", + "鸢尾花数据集是一个分类任务，故以决策树模型为例，采用默认参数拟合模型，并对验证集预测。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 决策树分类器\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "# 定义模型\n", + "model = DecisionTreeClassifier()\n", + "\n", + "# 训练模型\n", + "model.fit(X_train, y_train)\n", + "\n", + "# 在测试集上预测\n", + "model.predict(X_test)\n", + "\n", + "# 测试集上的得分（默认为准确率）\n", + "model.score(X_test, y_test)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "`scikit-learn` 中所有模型的调用方式都类似。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 模型评估\n", + "\n", + "评估模型的常用方法为 `K` 折交叉验证，它将数据集划分为 `K` 个大小相近的子集（`K` 通常取 `10`），每次选择其中(`K-1`)个子集的并集做为训练集，余下的做为测试集，总共得到 `K` 组训练集&测试集，最终返回这 `K` 次测试结果的得分，取其均值可作为选定最终模型的指标。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 交叉验证\n", + "from sklearn.model_selection import cross_val_score\n", + "cross_val_score(model, X, y, scoring=None, cv=10)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "注意：由于之前采用了 `train_test_split` 分割数据集，它默认对数据进行了洗牌，所以这里可以直接使用 `cv=10` 来进行 `10` 折交叉验证（`cross_val_score` 不会对数据进行洗牌）。如果之前未对数据进行洗牌，则要搭配使用 `KFold` 模块：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import KFold\n", + "n_folds = 10\n", + "kf = KFold(n_folds, shuffle=True).get_n_splits(X)\n", + "cross_val_score(model, X, y, scoring=None, cv = kf)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 保存与加载模型\n", + "\n", + "在训练模型后可将模型保存，以免下次重复训练。保存与加载模型使用 `sklearn` 的 `joblib`：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.externals import joblib\n", + "\n", + "# 保存模型\n", + "joblib.dump(model,'myModel.pkl')\n", + "\n", + "# 加载模型\n", + "model=joblib.load('myModel.pkl')\n", + "print(model)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下面我们用一个小例子来展示如何使用 `sklearn` 工具包快速完成一个机器学习项目。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 采用逻辑回归模型实现鸢尾花分类\n", + "\n", + "\n", + "**线性回归**\n", + "\n", + "在介绍逻辑回归之前先介绍一下线性回归，线性回归的主要思想是通过历史数据拟合出一条直线，因变量与自变量是线性关系，对新的数据用这条直线进行预测。 线性回归的公式如下：\n", + "\n", + "$y = w_{0}+w_{1}x_{1}+...+w_{n}x_{n}=w^{T}x+b$\n", + "\n", + "**逻辑回归**\n", + "\n", + "逻辑回归是一种广义的线性回归分析模型，是一种预测分析。虽然它名字里带回归，但实际上是一种分类学习方法。它不是仅预测出“类别”， 而是可以得到近似概率预测，这对于许多需要利用概率辅助决策的任务很有用。普遍应用于预测一个实例是否属于一个特定类别的概率，比如一封 `email` 是垃圾邮件的概率是多少。 因变量可以是二分类的，也可以是多分类的。因为结果是概率的，除了分类外还可以做 `ranking model`。逻辑的应用场景很多，如点击率预测（`CTR`）、天气预测、一些电商的购物搭配推荐、一些电商的搜索排序基线等。\n", + "\n", + "`sigmoid` **函数**\n", + "\n", + "`Sigmoid` 函数，呈现S型曲线，它将值转化为一个接近 `0` 或 `1` 的 `y` 值。 \n", + "$y = g(z)=\\frac{1}{1+e^{-z}}$ 其中:$z = w^{T}x+b$ \n", + "\n", + "\n", + "**鸢尾花数据集**\n", + "\n", + "
\n", + "\n", + "`sklearn.datasets.load_iris()`:加载并返回鸢尾花数据集\n", + "\n", + "`Iris` 鸢尾花卉数据集,是常用的分类实验数据集，由 `R.A. Fisher` 于 `1936` 年收集整理的。其中包含 `3` 种植物种类，分别是山鸢尾（`setosa`）变色鸢尾（`versicolor`）和维吉尼亚鸢尾（`virginica`），每类 `50` 个样本，共 `150` 个样本。 \n", + "\n", + "|变量名|\t变量解释|\t数据类型|\n", + "|--|--|--|\n", + "|sepal_length|\t花萼长度（单位cm)|\tnumeric|\n", + "|sepal_width|\t花萼宽度（单位cm）|\tnumeric|\n", + "|petal_length\t|花瓣长度（单位cm）|\tnumeric|\n", + "|petal_width|\t花瓣宽度（单位cm）|\tnumeric|\n", + "|species\t|种类\t|categorical|" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.获取数据集及其信息" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.datasets import load_iris\n", + "# 获取鸢尾花数据集\n", + "iris = load_iris()\n", + "print(\"鸢尾花数据集的返回值：\\n\", iris.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "print(\"鸢尾花的特征值:\\n\", iris[\"data\"][1])\n", + "print(\"鸢尾花的目标值：\\n\", iris.target)\n", + "print(\"鸢尾花特征的名字：\\n\", iris.feature_names)\n", + "print(\"鸢尾花目标值的名字：\\n\", iris.target_names)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 取出特征值\n", + "X = iris.data\n", + "y = iris.target" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.数据划分" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "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.1, random_state=0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.数据标准化" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "transfer = StandardScaler()\n", + "X_train = transfer.fit_transform(X_train)\n", + "X_test = transfer.transform(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.模型构建" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "estimator = LogisticRegression(penalty='l2',solver='newton-cg',multi_class='multinomial')\n", + "estimator.fit(X_train,Y_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.模型评估" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "print(\"\\n得出来的权重：\", estimator.coef_)\n", + "print(\"\\nLogistic Regression模型训练集的准确率：%.1f%%\" %(estimator.score(X_train, Y_train)*100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 6. 模型预测" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn import metrics\n", + "y_predict = estimator.predict(X_test)\n", + "print(\"\\n预测结果为:\\n\", y_predict)\n", + "print(\"\\n比对真实值和预测值：\\n\", y_predict == Y_test)\n", + "\n", + "# 预测的准确率\n", + "accuracy = metrics.accuracy_score(Y_test, y_predict)\n", + "print(\"\\nLogistic Regression 模型测试集的正确率：%.1f%%\" %(accuracy*100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 7.交叉验证" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import cross_val_score\n", + "import numpy as np\n", + "scores = cross_val_score(estimator, X, y, scoring=None, cv=10) #cv为迭代次数。\n", + "print(\"\\n交叉验证的准确率:\",np.round(scores,2)) # 打印输出每次迭代的度量值（准确度）\n", + "print(\"\\n交叉验证结果的置信区间: %0.2f%%(+/- %0.2f)\" % (scores.mean()*100, scores.std() * 2)) # 获取置信区间。（也就是均值和方差）\n" + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/5决策树.ipynb b/5决策树.ipynb new file mode 100644 index 0000000..650ff3f --- /dev/null +++ b/5决策树.ipynb @@ -0,0 +1,1469 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 决策树" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1.什么是决策树" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "决策树是一种通过树形结构进行分类的方法。在决策树中，树形结构中每个节点表示对分类目标在属性上的一个判断，每个分支代表基于该属性做出的一个判断，最后树形结构中每个叶子节点代表一种分类结果。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "src = 'http://files.momodel.cn/%E5%86%B3%E7%AD%96%E6%A0%911.pptx'\n", + "IFrame('https://view.officeapps.live.com/op/view.aspx?src='+src, width=1200, height=900)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2.构建决策树" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**数据**: 游乐场经营者提供**天气情况**（如晴、雨、多云）、**温度高低**、**湿度大小**、**风力强弱**等气象特点以及游客当天是否前往游乐场。\n", + "\n", + "**目标**: 预测游客是否来游乐场游玩。\n", + "\n", + "\n", + "|序号|天气|温度（℃）|湿度|是否有风|是（1）否（0）前往游乐场|\n", + "|:--:|:--:|:--:|:--:|:--:|:--:|\n", + "|1|晴|29|85|否|0|\n", + "|2|晴|26|88|是|0|\n", + "|3|多云|28|78|否|1\n", + "|4|雨|21|96|否|1|\n", + "|5|雨|20|80|否|1|\n", + "|6|雨|18|70|是|0|\n", + "|7|多云|18|65|是|1|\n", + "|8|晴|22|90|否|0|\n", + "|9|晴|21|68|否|1|\n", + "|10|雨|24|80|否|1|\n", + "|11|晴|24|63|是|1|\n", + "|12|多云|22|90|是|1|\n", + "|13|多云|27|75|否|1|\n", + "|14|雨|21|80|是|0|" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下面，我们创建数据并进行一些预处理" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import math\n", + "from math import log\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
天气温度湿度是否有风是否前往游乐场
0晴>26>75否0
1晴<=26>75是0
2多云>26>75否1
3雨<=26>75否1
4雨<=26>75否1
5雨<=26<=75是0
6多云<=26<=75是1
7晴<=26>75否0
8晴<=26<=75否1
9雨<=26>75否1
10晴<=26<=75是1
11多云<=26>75是1
12多云>26<=75否1
13雨<=26>75是0
\n", + "
" + ], + "text/plain": [ + " 天气 温度 湿度 是否有风 是否前往游乐场\n", + "0 晴 >26 >75 否 0\n", + "1 晴 <=26 >75 是 0\n", + "2 多云 >26 >75 否 1\n", + "3 雨 <=26 >75 否 1\n", + "4 雨 <=26 >75 否 1\n", + "5 雨 <=26 <=75 是 0\n", + "6 多云 <=26 <=75 是 1\n", + "7 晴 <=26 >75 否 0\n", + "8 晴 <=26 <=75 否 1\n", + "9 雨 <=26 >75 否 1\n", + "10 晴 <=26 <=75 是 1\n", + "11 多云 <=26 >75 是 1\n", + "12 多云 >26 <=75 否 1\n", + "13 雨 <=26 >75 是 0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 原始数据\n", + "datasets = [\n", + " ['晴', 29, 85, '否', '0'],\n", + " ['晴', 26, 88, '是', '0'],\n", + " ['多云', 28, 78, '否', '1'],\n", + " ['雨', 21, 96, '否', '1'],\n", + " ['雨', 20, 80, '否', '1'],\n", + " ['雨', 18, 70, '是', '0'],\n", + " ['多云', 18, 65, '是', '1'],\n", + " ['晴', 22, 90, '否', '0'],\n", + " ['晴', 21, 68, '否', '1'],\n", + " ['雨', 24, 80, '否', '1'],\n", + " ['晴', 24, 63, '是', '1'],\n", + " ['多云', 22, 90, '是', '1'],\n", + " ['多云', 27, 75, '否', '1'],\n", + " ['雨', 21, 80, '是', '0']\n", + "]\n", + "# 数据的列名\n", + "labels = ['天气', '温度', '湿度', '是否有风', '是否前往游乐场']\n", + "# 将湿度大小分为大于 75 和小于等于 75 这两个属性值，\n", + "# 将温度大小分为大于 26 和小于等于 26 这两个属性值\n", + "for i in range(len(datasets)):\n", + " if datasets[i][2] > 75:\n", + " datasets[i][2] = '>75'\n", + " else:\n", + " datasets[i][2] = '<=75'\n", + " if datasets[i][1] > 26:\n", + " datasets[i][1] = '>26'\n", + " else:\n", + " datasets[i][1] = '<=26'\n", + "# 构建 dataframe 并查看数据\n", + "df = pd.DataFrame(datasets, columns=labels)\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "src = 'http://files.momodel.cn/%E5%86%B3%E7%AD%96%E6%A0%9121.pptx'\n", + "IFrame('https://view.officeapps.live.com/op/view.aspx?src='+src, width=1200, height=900) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 信息熵" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "**信息熵**用来度量信息量的大小。从信息论的角度来看，对信息的度量等于计算信息不确定性的多少。 " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "src = 'http://files.momodel.cn/%E5%86%B3%E7%AD%96%E6%A0%9123.pptx'\n", + "IFrame('https://view.officeapps.live.com/op/view.aspx?src='+src, width=1200, height=900)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "假设有 $K$ 个信息，其组成了集合样本 $D$ ，记第 $k$ 个信息发生的概率为 $p_k(1≤k≤K)$。 \n", + "这 $K$ 个信息的信息熵： \n", + "$$E(D)=-\\sum_{k=1}^{K}p_k log_{2} p_k$$\n", + "\n", + "$E(D)$ 的值越小，表示$ D $ 包含的信息越确定，也称$ D $的纯度越高。\n", + "\n", + "需要指出：**所有 $p_k$ 累加起来的和为1**。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "当只有两个信息时，熵随概率变化的曲线如图所示\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "我们来动手实现一下信息熵的计算。\n", + "$$E(D)=-\\sum_{k=1}^{K}p_k log_{2} p_k$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def calc_entropy(total_num, count_dict):\n", + " \"\"\"\n", + " 计算信息熵\n", + " :param total_num: 总样本数, 例如总的样本数是 14\n", + " :param count_dict: 每类样本及其对应数目的字典，例如：{'前往游乐场': 9, '不前往游乐场': 5}\n", + " :return: 信息熵\n", + " \"\"\"\n", + " \n", + " #初始化 ent 为 0\n", + " \n", + " # 对于每一个类别\n", + " \n", + " # 如果属于该类别的样本数大于 0\n", + " \n", + " # 计算概率\n", + " \n", + " # 计算信息熵\n", + " \n", + " # 返回信息熵，精确到小数点后 3 位\n", + " return round(ent, 3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def calc_entropy(total_num, count_dict):\n", + " \"\"\"\n", + " 计算信息熵\n", + " :param total_num: 总样本数, 例如总的样本数是 14\n", + " :param count_dict: 每类样本及其对应数目的字典，例如：{'前往游乐场': 9, '不前往游乐场': 5}\n", + " :return: 信息熵\n", + " \"\"\"\n", + " \n", + " #初始化 ent 为 0\n", + " ent = 0\n", + " # 对于每一个类别\n", + " for n in count_dict.values():\n", + " # 如果属于该类别的样本数大于 0\n", + " if n > 0:\n", + " # 计算概率\n", + " p = n / total_num\n", + " # 计算信息熵\n", + " ent += - p * log(p, 2)\n", + " # 返回信息熵，精确到小数点后 3 位\n", + " return round(ent, 3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "数据中 14 个样本分为 “游客来游乐场（ 9 个样本）” 和 “游客不来游乐场（ 5 个样本）” 两个类别，即 K = 2。\n", + "\n", + "记 “游客来游乐场” 和 “游客不来游乐场” 的概率分别为 $p_1$ 和 $p_2$ ，显然 $p_1=\\frac{9}{14}$，$p_1=\\frac{5}{14}$ ，则这 14 个样本所蕴含的信息熵：\n", + "\n", + "$$E(D)=-\\sum_{k=1}^{2}p_{k}log_{2}{p_k}=-(\\frac{9}{14}×log_{2}{\\frac{9}{14}}+\\frac{5}{14}×log_{2}{\\frac{5}{14}})=0.940$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 样本总数\n", + "total_num = 14\n", + "# 每类样本的数量\n", + "count_dict = {'去游乐场': 9, '不去游乐场': 5}\n", + "\n", + "calc_entropy(total_num, count_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "上面我们是一行行数出来的，如何使用代码得到 total_num 和 count_dict ？" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "我们可以用下面这种方式对 dataframe 的数据按条件进行筛选。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 例如：按是否前往游乐场==0 进行筛选\n", + "df[df['是否前往游乐场']=='0']\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们可以用下面这种方式对查看数据的行数和列数。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用上面的方法，可以得到计算信息熵所需的总样本数，以及每类样本及其对应数目的字典，然后计算信息熵。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 总样本数\n", + "total_num = df.shape[0]\n", + "\n", + "# 前往游乐场的样本数目\n", + "num_go_to_play = df[df['是否前往游乐场']=='1'].shape[0]\n", + "\n", + "# 不前往游乐场的样本数目\n", + "num_not_go_to_play = df[df['是否前往游乐场']=='0'].shape[0]\n", + "\n", + "# 每类样本及其对应数目的字典\n", + "count_dict = {'前往': num_go_to_play,\n", + " '不前往': num_not_go_to_play}\n", + "\n", + "# 计算信息熵\n", + "entropy = calc_entropy(total_num, count_dict)\n", + "entropy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**计算天气状况所对应的信息熵**： \n", + "天气状况的三个属性记为 $a_0=“晴”$ ，$a_1=“多云”$ ，$a_2=“雨”$ ， \n", + "属性取值为 $a_i$ 对应分支节点所包含子样本集记为 $D_i$ ，该子样本集包含样本数量记为 $|D_i|$ 。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "|天气属性取值$a_i$|“晴”|“多云”|“雨”|\n", + "|:--:|:--:|:--:|:--:|\n", + "|对应样本数$|D_i|$|5|4|5|\n", + "|正负样本数量|（2+，3-）|（4+，0-）|（3+，2-）|\n", + "\n", + "计算天气状况每个属性值的信息熵：\n", + "\n", + "$“晴”：E(D_0)=-(\\frac{2}{5}×log_{2}{\\frac{2}{5}}+\\frac{3}{5}×log_{2}{\\frac{3}{5}})=0.971$\n", + "\n", + "$“多云”：E(D_1)=-(\\frac{4}{4}×log_{2}{\\frac{4}{4}})=0$\n", + "\n", + "$“雨”：E(D_2)=-(\\frac{3}{5}×log_{2}{\\frac{3}{5}}+\\frac{2}{5}×log_{2}{\\frac{2}{5}})=0.971$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "现在，我们来编写代码进行完成上面的计算。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "首先，我们可以使用下面的写法，对 Dataframe 进行多个条件的筛选。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 筛选出 天气为晴并且去游乐场的样本数据\n", + "df[(df['天气']=='晴') & (df['是否前往游乐场']=='1')]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "然后，我们是使用上面的筛选方法，分别计算不同天气下的信息熵。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 天气为晴的总天数\n", + "total_num_sun = df[df['天气']=='晴'].shape[0]\n", + "\n", + "# 前往游乐场的样本数目\n", + "num_go_to_play = df[(df['天气']=='晴') & (df['是否前往游乐场']=='1')].shape[0]\n", + "\n", + "# 不前往游乐场的样本数目\n", + "num_not_go_to_play = df[(df['天气']=='晴') & (df['是否前往游乐场']=='0')].shape[0]\n", + "\n", + "\n", + "# 天气为晴时，去游乐场和不去游乐场的人数\n", + "count_dict_sun = {'前往': num_go_to_play ,\n", + " '不前往': num_not_go_to_play}\n", + "print(count_dict_sun)\n", + "\n", + "# 计算天气-晴 的信息熵\n", + "ent_sun = calc_entropy(total_num_sun, count_dict_sun)\n", + "print('天气-晴 的信息熵为：%s' % ent_sun)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 天气为多云的总天数\n", + "total_num_cloud = df[df['天气']=='多云'].shape[0]\n", + "\n", + "# 天气为多云时，去游乐场和不去游乐场的人数\n", + "count_dict_cloud = {'前往':df[(df['天气']=='多云') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['天气']=='多云') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_cloud)\n", + "\n", + "# 计算天气-多云 的信息熵\n", + "ent_cloud = calc_entropy(total_num_cloud, count_dict_cloud)\n", + "print('天气-多云 的信息熵为：%s' % ent_cloud)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 天气为雨的总天数\n", + "total_num_rain = df[df['天气']=='雨'].shape[0]\n", + "\n", + "# 天气为雨时，去游乐场和不去游乐场的人数\n", + "count_dict_rain = {'前往':df[(df['天气']=='雨') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['天气']=='雨') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_rain)\n", + "\n", + "# 计算天气-雨 的信息熵\n", + "ent_rain = calc_entropy(total_num_rain, count_dict_rain)\n", + "print('天气-雨 的信息熵为：%s' % ent_rain)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 信息增益" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "**信息增益**用来衡量样本集合复杂度（不确定性）所减少的程度。 " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import IFrame\n", + "src = 'http://files.momodel.cn/%E5%86%B3%E7%AD%96%E6%A0%913.pptx'\n", + "IFrame('https://view.officeapps.live.com/op/view.aspx?src='+src, width=1200, height=900)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "得到不同天气下的信息熵后，我们可以计算天气状况的信息增益: \n", + "$$Gain(D,A)=E(D)-\\sum_{i}^{n}\\frac{|D_i|}{D}E(D)$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "其中，$A=“天气状况”$。于是天气状况这一气象特点的信息增益为：\n", + "$$Gain(D,天气)=0.940-（\\frac{5}{14}×0.971+\\frac{4}{14}×0+\\frac{5}{14}×0.971）=0.246$$\n", + "\n", + "通常情况下，某个分支的信息增益越大，则该分支对样本集划分所获得的“纯度”越大，信息不确定性减少的程度越大。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们来编写代码，使用上面的公式计算信息增益。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 信息增益\n", + "gain = entropy - (total_num_sun / total_num*ent_sun +\n", + " total_num_cloud / total_num*ent_cloud +\n", + " total_num_rain / total_num*ent_rain)\n", + "round(gain, 3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "同理可以计算温度高低、湿度大小、风力强弱三个气象特点的信息增益。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "计算按温度高低进行切分的信息增益。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 温度 >26 的信息熵\n", + "total_num_temp_high = df[df['温度']=='>26'].shape[0]\n", + "count_dict_temp_high = {'前往':df[(df['温度']=='>26') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['温度']=='>26') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_temp_high)\n", + "ent_temp_high = calc_entropy(total_num_temp_high, count_dict_temp_high)\n", + "print('温度 >26 的信息熵为：%s' % ent_temp_high)\n", + "\n", + "# 温度 <=26 的信息熵\n", + "total_num_temp_low = df[df['温度']=='<=26'].shape[0]\n", + "count_dict_temp_low = {'前往':df[(df['温度']=='<=26') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['温度']=='<=26') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_temp_low)\n", + "ent_temp_low = calc_entropy(total_num_temp_low, count_dict_temp_low)\n", + "print('温度 <=26 的信息熵为：%s' % ent_temp_low)\n", + "\n", + "# 如果按照温度高低进行划分，则对应的信息增益为\n", + "gain = entropy - (total_num_temp_high/total_num*ent_temp_high +\n", + " total_num_temp_low/total_num*ent_temp_low)\n", + "print('按照温度高低进行划分的信息增益为：%s' % gain)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "计算按湿度高低进行切分的信息增益。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 湿度 >75 的信息熵\n", + "total_num_hum_high = df[df['湿度']=='>75'].shape[0]\n", + "count_dict_hum_high = {'前往':df[(df['湿度']=='>75') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['湿度']=='>75') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_hum_high)\n", + "ent_hum_high = calc_entropy(total_num_hum_high, count_dict_hum_high)\n", + "print('湿度 >75 的信息熵为：%s' % ent_hum_high)\n", + "\n", + "# 湿度 <=75 的信息熵\n", + "total_num_hum_low = df[df['湿度']=='<=75'].shape[0]\n", + "count_dict_hum_low = {'前往':df[(df['湿度']=='<=75') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['湿度']=='<=75') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_hum_low)\n", + "ent_hum_low = calc_entropy(total_num_hum_low, count_dict_hum_low)\n", + "print('湿度 <=75 的信息熵为：%s' % ent_hum_low)\n", + "\n", + "# 如果按照湿度高低进行划分，则对应的信息增益为\n", + "gain = entropy - (total_num_hum_high/total_num*ent_hum_high +\n", + " total_num_hum_low/total_num*ent_hum_low)\n", + "print('按照湿度高低进行划分的信息增益为：%s' % gain)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "计算按风力强弱进行切分的信息增益。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 有风 的信息熵\n", + "total_num_wind = df[df['是否有风']=='是'].shape[0]\n", + "count_dict_wind = {'前往':df[(df['是否有风']=='是') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['是否有风']=='是') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_wind)\n", + "ent_wind = calc_entropy(total_num_wind, count_dict_wind)\n", + "print('有风 的信息熵为：%s' % ent_wind)\n", + "\n", + "# 无风 的信息熵\n", + "total_num_nowind = df[df['是否有风']=='否'].shape[0]\n", + "count_dict_nowind = {'前往':df[(df['是否有风']=='否') & (df['是否前往游乐场']=='1')].shape[0],\n", + " '不前往':df[(df['是否有风']=='否') & (df['是否前往游乐场']=='0')].shape[0]}\n", + "print(count_dict_nowind)\n", + "ent_nowind = calc_entropy(total_num_nowind, count_dict_nowind)\n", + "print('无风 的信息熵为：%s' % ent_nowind)\n", + "\n", + "# 如果按照是否有风进行划分，则对应的信息增益为\n", + "gain = entropy - (total_num_wind/total_num*ent_wind +\n", + " total_num_nowind/total_num*ent_nowind)\n", + "print('按照是否有风进行划分的信息增益为：%s' % gain)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import IFrame\n", + "src = 'http://files.momodel.cn/%E5%86%B3%E7%AD%96%E6%A0%914.pptx'\n", + "IFrame('https://view.officeapps.live.com/op/view.aspx?src='+src, width=1200, height=900)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 使用 Sklearn 工具包构建和训练决策树模型 " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "每朵鸢尾花有**萼片长度**、**萼片宽度**、**花瓣长度**、**花瓣宽度**四个特征。现在需要根据这四个特征将鸢尾花分为**杂色鸢尾花（versicolor）**、**维吉尼亚鸢尾（virginica）**和**山鸢尾（setosa）**三类，试构造决策树进行分类。\n", + "\n", + "|序号|萼片长度（sepal length）|萼片宽度（sepal width）|花瓣长度（petal length）|花瓣宽度 （petal width）|种类|\n", + "|:--:|:--:|:--:|:--:|:--:|:--:|\n", + "|1|5.0|2.0|3.5|1.0|杂色鸢尾|\n", + "|2|6.0|2.2|5.0|1.5|维吉尼亚鸢尾|\n", + "|3|6.0|2.2|4.0|1.0|杂色鸢尾|\n", + "|4|6.2|2.2|4.5|1.5|杂色鸢尾|\n", + "|5|4.5|2.3|1.3|0.3|山鸢尾|" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "观察上表中的五笔数据，我们可以看到 **杂色鸢尾** 和 **维吉尼亚鸢尾** 的花瓣宽度明显大于 **山鸢尾**，所以可以通过判断花瓣宽度是否大于 0.7，来将 **山鸢尾** 从其他两种鸢尾中区分出来。\n", + "\n", + "然后我们观察到 **维吉尼亚鸢尾** 的花瓣长度明显大于 **杂色鸢尾**，所以可以通过判断花瓣长度是否大于 4.75，来将 **杂色鸢尾** 和 **维吉尼亚鸢尾**区分出来。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "上面的表格只是 Iris 数据集的一小部分，完整的数据集包含 150 个数据样本，分为 3 类，每类 50 个数据，每个数据包含 4 个属性。即**花萼长度**，**花萼宽度**，**花瓣长度**，**花瓣宽度**4个属性。\n", + "\n", + "我们使用 sklearn 工具包来构建决策树模型，先导入数据集。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.datasets import load_iris\n", + "# 加载数据集\n", + "iris = load_iris()\n", + "# 查看 label\n", + "print(list(iris.target_names))\n", + "# 查看 feature\n", + "print(iris.feature_names)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "setosa 是**山鸢尾**，versicolor是**杂色鸢尾**，virginica是**维吉尼亚鸢尾**。\n", + "\n", + "sepal length， sepal width，petal length，petal width 分别是**萼片长度**，**萼片宽度**，**花瓣长度**，**花瓣宽度**。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "然后进行训练集和测试集的切分。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "# 按属性和标签载入数据\n", + "X, y = load_iris(return_X_y=True)\n", + "# 切分训练集合测试集\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接下来，我们在训练集数据上训练决策树模型。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn import tree\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "# 初始化模型，可以调整 max_depth 来观察模型的表现， \n", + "# 也可以调整 criterion 为 gini 来使用 gini 指数构建决策树\n", + "clf = tree.DecisionTreeClassifier()\n", + "# 训练模型\n", + "clf = clf.fit(X_train, y_train)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们可以使用 graphviz 包来展示构建好的决策树。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import graphviz\n", + "feature_names = ['萼片长度','萼片宽度','花瓣长度','花瓣宽度']\n", + "target_names = ['山鸢尾', '杂色鸢尾', '维吉尼亚鸢尾']\n", + "# 可视化生成的决策树\n", + "dot_data = tree.export_graphviz(clf, out_file=None,\n", + " feature_names=feature_names,\n", + " class_names=target_names,\n", + " filled=True, rounded=True,\n", + " special_characters=True)\n", + "graph = graphviz.Source(dot_data)\n", + "graph\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们看模型在测试集上的表现" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "y_test_predict = clf.predict(X_test)\n", + "accuracy_score(y_test,y_test_predict)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. 扩展内容" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1 基尼指数" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "除了使用信息增益以外，我们也可以使用基尼指数来构建决策树。\n", + "\n", + "分类问题中，假设有 $K$ 个类，样本点属于第 $k$ 类的概率为 $p_{k}$，则概率分布的基尼指数定义为：\n", + "\n", + "$$\\operatorname{Gini}(p)=\\sum_{k=1}^{K} p_{k}\\left(1-p_{k}\\right)=1-\\sum_{k=1}^{K} p_{k}^{2}$$\n", + "\n", + "\n", + "对于给定的样本集合 $D$，其基尼指数为\n", + "\n", + "$$\\operatorname{Gini}(D)=1-\\sum_{k=1}^{K}\\left(\\frac{\\left|C_{k}\\right|}{|D|}\\right)^{2}$$\n", + "\n", + "这里，$C_{k}$ 是 $D$ 中属于第 $k$ 类的样本子集，$K$ 是类的个数。\n", + "\n", + "如果样本集合 $D$ 根据特征 $A$ 是否取某一可能值 $a$ 被分割为 $D_{1}$ 和 $D_{2}$ 两部分，即\n", + "\n", + "$$D_{1}=\\{(x, y) \\in D | A(x)=a\\}, \\quad D_{2}=D-D_{1}$$\n", + "\n", + "则在特征 $A$ 的条件下，集合 $D$ 的基尼指数定义为\n", + "\n", + "$$\\operatorname{Gini}(D, A)=\\frac{\\left|D_{1}\\right|}{|D|}\n", + "\\operatorname{Gini}\\left(D_{1}\\right)+\\frac{\\left|D_{2}\\right|}{|D|} \\operatorname{Gini}\\left(D_{2}\\right)$$\n", + "\n", + "基尼指数 $Gini(D)$ 表示集合 $D$ 的不确定性，基尼指数 $Gini(D, A)$ 表示经过分割后集合 $D$ 的不确定性。基尼指数值越大，样本集合的不确定性也就越大，这一点与信息熵相似。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**想一想**：" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "对于二分类问题，若样本点属于第 1 个类的概率是 $p$，则概率分布的基尼指数是多少？\n", + "\n", + "$$\\text { Gini }(p)=2 p(1-p)$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.2 **计算文章的信息熵**\n", + "\n", + "收集中英文对照的短文，在计算短文内中文单词和英文单词出现概率基础上，计算该两篇短文的信息熵，比较中文短文信息熵和英文短文信息熵的大小。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "首先定义一个方法来辅助读取文件的内容。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def read_file(path):\n", + " \"\"\"\n", + " 读取某文件的内容\n", + " :param path: 文件的路径\n", + " :return: 文件的内容\n", + " \"\"\"\n", + " contents = \"\"\n", + " with open(path) as f:\n", + " # 读取每一行的内容\n", + " for line in f.readlines():\n", + " contents += line\n", + " return contents\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用上面定义的方法读取英文短文及其对应的中文短文。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 读取英文短文\n", + "en_essay = read_file('essay1_en.txt')\n", + "# 读取中文短文\n", + "ch_essay = read_file('essay1_ch.txt')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "en_essay" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "ch_essay" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "处理文本，统计单词出现的概率，并计算信息熵。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import Counter\n", + "import re\n", + "\n", + "\n", + "def cal_essay_entropy(essay, split_by=None):\n", + " \"\"\"\n", + " 计算文章的信息熵\n", + " :param essay: 文章内容\n", + " :param split_by: 切分方式，对于中文文章，不需传入，按字符切分，\n", + " 对于英文文章，需传入空格字符来进行切分\n", + " :return: 文章的信息熵\n", + " \"\"\"\n", + " # 把英文全部转为小写\n", + " essay = essay.lower()\n", + " # 去除标点符号\n", + " essay = re.sub(\n", + " \"[\\f+\\n+\\r+\\t+\\v+\\?\\.\\!\\/_,$%^*(+\\\"\\']+|[+——！，。？、~@#《》￥%……&*（）]\", \"\",\n", + " essay)\n", + " # print(essay)\n", + " # 把文本分割为词\n", + " if split_by:\n", + " word_list = essay.split(split_by)\n", + " else:\n", + " word_list = list(essay)\n", + " # 统计总的单词数\n", + " word_number = len(word_list)\n", + " print('此文章共有 %s 个单词' % word_number)\n", + " # 得到每个单词出现的次数\n", + " word_counter = Counter(word_list)\n", + " # print('每个单词出现的次数为：%s' % word_counter)\n", + " # 使用信息熵公式计算信息熵\n", + " ent = -sum([(p / word_number) * log(p / word_number, 2) for p in\n", + " word_counter.values()])\n", + " print('信息熵为：%.2f' % ent)\n", + " return ent\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ent = cal_essay_entropy(ch_essay)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "ent = cal_essay_entropy(en_essay, split_by = ' ')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.扩展阅读\n", + "\n", + "1. [决策树与随机森林](https://www.bilibili.com/video/av26086646?from=search&seid=6716049859412037731)\n", + "2. [从决策树到随机森林：树型算法的原理与实现](https://www.jiqizhixin.com/articles/2017-07-31-3)\n", + "3. [sklearn 决策树](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html)" + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/6神经网络学习.ipynb b/6神经网络学习.ipynb new file mode 100644 index 0000000..82203d6 --- /dev/null +++ b/6神经网络学习.ipynb @@ -0,0 +1,1611 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 神经网络学习" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 人工智能是什么呢？" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "人工智能被分为强人工智能和弱人工智能：\n", + "+ 强人工智能：在各方面都能够和人类比肩的人工智能，“一种宽泛的心理能力，能够进行思考、计划、解决问题、抽象思理解复杂理念、快速学习和从经验中学习等”\n", + "+ 弱人工智能：擅长于单个方面的人工智能，比如AlphaGo。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "弱人工智能，本质上还是人类为计算机设计的算法，一系列定义良好的计算过程，能够将输入数据转化成输出数据。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "神经网络模拟人脑神经元的连接来达到学习功能，通过逐层抽象将输入数据逐层映射为概念等高等语义。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "
\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 人脑神经机制" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "首先，人脑神经元的活动和学习机制是怎样的呢？" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "src = 'https://files.momodel.cn/nn_brain_3.pptx'\n", + "IFrame('https://view.officeapps.live.com/op/view.aspx?src='+src, width=800, height=600)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "神经学假说认为：" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "高层的特征是低层特征的组合，从低层到高层的特征表示越来越抽象，越来越能表现语义。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "人工智能中神经网络正是体现“逐层抽象、渐进学习”机制的学习模型。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "人眼在辨识图片时，会先提取边缘特征，再识别部件，最后再得到最高层的模式。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "神经元的功能：\n", + "+ 物理反应：将前序神经元所传递过来的信息按联结权重累加\n", + "\n", + "$ 神经元i获得信息 = 神经元k信息 \\times 联结权重k + 神经元l信息 \\times 联结权重l + 神经元m信息 \\times 联结权重m $\n", + "\n", + "+ 化学反应：对神经元i获得的信息施以一个非线性变换（通过激活函数），激活若干信息、而非“来者不拒”\n", + "+ 信息流通：将神经元非线性变换后所得的信息继续向后传递" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 感知机模型" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### 2.1 感知机模型：\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "**输入项**：3个，$x_1,x_2,x_3$ \n", + "**神经元**：1个，用圆圈表示 \n", + "**权重**：每个输入项均通过权重与神经元相连（比如 $w_i$ 是 $x_i$ 与神经元相连的权重） \n", + "**输出**：1个\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "**工作方法**：\n", + "+ 计算输入项传递给神经元的信息加权总和，即：$y_{sum} = w_1x_1+w_2x_2+w_3x_3$\n", + "+ 如果 $y_{sum}$ 大于某个预定阀值（比如 0.5），则输出为 1，否则为 0 。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 激活函数" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "在输出的判断上，其实不仅可以简单的按照阈值来判断，可以通过一个函数来进行计算，这个函数称为**激活函数**。\n", + "\n", + "常见的激活函数有： sigmoid，tanh，relu 等。\n", + "\n", + "下面我们看看这些激活函数的曲线图。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "\n", + "def plot_activation_function(activation_function):\n", + " \"\"\"\n", + " 绘制激活函数\n", + " :param activation_function: 激活函数名\n", + " :return:\n", + " \"\"\"\n", + " x = np.arange(-10, 10, 0.1)\n", + " y_activation_function = activation_function(x)\n", + "\n", + " # 绘制坐标轴\n", + " ax = plt.gca()\n", + " ax.spines['right'].set_color('none')\n", + " ax.spines['top'].set_color('none')\n", + " ax.xaxis.set_ticks_position('bottom')\n", + " ax.yaxis.set_ticks_position('left')\n", + " ax.spines['bottom'].set_position(('data', 0))\n", + " ax.spines['left'].set_position(('data', 0))\n", + "\n", + " # 绘制曲线图\n", + " plt.plot(x, y_activation_function)\n", + " \n", + " # 展示函数图像\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.sigmoid函数\n", + "\n", + "Sigmoid函数是一个在生物学中常见的S型函数，也称为S型生长曲线。在信息科学中，由于其单增以及反函数单增等性质，Sigmoid函数常被用作神经网络的阈值函数，将变量映射到0,1之间。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "$$ f(x) = \\frac{1}{1+e^{-x}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def sigmoid(x):\n", + " \"\"\"\n", + " sigmoid函数\n", + " :param x: np.array 格式数据\n", + " :return: sigmoid 函数\n", + " \"\"\"\n", + " y = \n", + " \n", + " return y\n", + "\n", + "# 绘制 sigmoid 函数图像\n", + "plot_activation_function(sigmoid)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def sigmoid(x):\n", + " \"\"\"\n", + " sigmoid函数\n", + " :param x: np.array 格式数据\n", + " :return: sigmoid 函数\n", + " \"\"\"\n", + " y = 1/(1+np.exp(-x))\n", + " \n", + " return y\n", + "\n", + "# 绘制 sigmoid 函数图像\n", + "plot_activation_function(sigmoid)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "优点：\n", + "+ Sigmoid 函数的输出映射在(0,1)之间，单调连续，输出范围有限，优化稳定，可以用作输出层。它在物理意义上最为接近生物神经元。\n", + "+ 求导容易。\n", + "\n", + "缺点：\n", + "+ 由于其软饱和性，容易产生梯度消失，导致训练出现问题。\n", + "+ 其输出并不是以0为中心的。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.tanh函数\n", + "tanh是双曲函数中的一个，$Tanh()$为双曲正切。在数学中，双曲正切“Tanh”是由基本双曲函数双曲正弦和双曲余弦推导而来。\n", + "\n", + "公式如下:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "$$ f(x) = \\frac{1-e^{-2x}}{1+e^{-2x}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def tanh(x):\n", + " \"\"\"\n", + " tanh函数\n", + " :param x: np.array 格式数据\n", + " :return: tanh 函数\n", + " \"\"\"\n", + " y = \n", + " return y\n", + "\n", + "# 绘制 tanh 函数图像\n", + "plot_activation_function(tanh)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWQAAADuCAYAAAAOR30qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3X9YU+fdP/B3IALiDwQUpIm/QiICEmkNFbc9TkGKtms6V1vx6yqbbbGte7rZPVaerbq675x07bpuZet3rLal1zZpa1vhai0qtbadtWKotJuiRQQKGJBAEFBJSHJ//7CmIkEDkp+8X9flBTnnPjmfnJy+e7jPfc6RCCFARESeF+DpAoiI6BIGMhGRl2AgExF5CQYyEZGXYCATEXkJBjIRkZdgIBMReQkGMhGRl2AgExF5Cekg2/OyPvJaS5YsQWlpqafLIHJE4kwjHiGT3zAYDJ4ugeiGMJCJiLwEA5mIyEswkImIvAQDmYjISzCQiYi8BAOZXGbNmjWIiorC7NmzHc4XQuDRRx+FUqmEWq3GZ599Zp9XWFgIlUoFlUqFwsJCd5VM5FGDHYdM5LQf/ehH+MlPfoLVq1c7nP/ee++huroa1dXVOHz4MB5++GEcPnwY7e3t2LJlC3Q6HSQSCebOnQutVovw8HA3fwL/541PDPLCkgAAEgkgkTg1nHjIGMjkMgsWLEBdXd2A84uLi7F69WpIJBKkpqaio6MDer0eBw4cQEZGBiIiIgAAGRkZKC0txcqVK91UuWuYLFac7TShubMHzed60NZtQrfJgi6TBd09FnSbLDhvsuC8yYpeqw29NoFeiw0Wmw0Wq0Dv5Z9WGyw2AZtNXLpSS1y6YksI8fVPQEB8/fPy/G9eCyFg89LQ82Yn/u8ShIwKdOk6GMjkMU1NTZgyZYr9tVwuR1NT04DTHSkoKEBBQQEAoLW11bUFO0kIgbq2CyivbUOVvgtftnThy5ZuGLpNDtsHSQMwLliKsSFSjAmSYkxwIIKkAQgNDEBQoATSgABIAyUYFRiAUYESSAMDIA2QIODrozWJBJBA8vXPb47kJADgYF6AfZ7EPs3bSJy7sM2tpAGur4mBTD4tJycHOTk5AACNRuOxOqw2gY+rW1Hy+Rl8cqoNzZ09AIDQoEDMjB6HtFmTIA8PxeTxIYgOC8Hk8SGYODYIY0OkCJa69qiLfAcDmTxGJpOhoaHB/rqxsREymQwymQwHDhzoM33hwoXuL9AJZzt7UHioDm9WNKG5swcTQkfh28qJ+FZsJFIVkZgROQYBbjiyIv/AQCaP0Wq1yM/PR1ZWFg4fPoywsDDExMQgMzMTv/jFL2A0GgEAe/fuxbZt2zxcbV/dJgv+9H41Cj+pQ6/Vhu/OnIRf3ZmAtPgoHvHSkDGQyWVWrlyJAwcOwGAwQC6XY8uWLejt7QUAPPTQQ7j99tuxe/duKJVKhIaG4uWXXwYAREREYNOmTUhJSQEAbN682X6Czxt8+GUrHt/5Oc52mfCDm+V4NF2JaZFjPF0W+QHJIIe98NwseS2NRgOdTuey97fZBJ7ZexJ/OVCDuOhxyLs7CTdP5VA8copT/VY8QiZygslixWOvf453v9Bj5a1T8Ks7E10+BIpGHgYy0XX0Wm1Y94+jKKtqwS9un4UH/0vh8gsEaGRiIBNdgxACG3d+gbKqFvz6rkSsnj/d0yWRH+O9LIiuYfu/avHW0SasXzyTYUwux0AmGkB5bTu2vXcCSxIn49F0pafLoRGAgUzkwAWzBf/zxueQh4/G0/eo2WdMbsE+ZCIHfr/3S3zVfgFFOakYFzLK0+XQCMEjZKKrnGzuwssHa7Fq3lSkKiI9XQ6NIAxkoqtse68KY4Ol2JAZ5+lSaIRhIBNd4eApAw6cbMV/p6kwITTI0+XQCMNAJrrCH8uqcVNYCFZ/a5qnS6ERiIFM9LWK+naU17XjwQUK3rGNPIKBTPS1Fw6cRnjoKKxImXL9xkQuwEAmAlBnOI+yqhbcN386QoM4GpQ8g4FMBGDHka8QGCDBqnlTPV0KjWAMZHKZ0tJSxMXFQalUIi8vr9/89evXIzk5GcnJyZg5cyYmTJhgnxcYGGifp9VqXVqn2WLDmxWNSJ8VhejxIS5dF9G18G8zcgmr1Yp169Zh3759kMvlSElJgVarRUJCgr3NH/7wB/vvzz//PI4ePWp/PXr0aFRWVrql1rKqFhi6zVjJo2PyMB4hk0uUl5dDqVRCoVAgKCgIWVlZKC4uHrD9jh07sHLlSjdW+I03KxoRExaCBapJHlk/0WUMZHKJpqYmTJnyzWgFuVyOpqYmh23r6+tRW1uLtLQ0+7Senh5oNBqkpqZi165dA66noKAAGo0GGo0Gra2tg66z44IZH1W34s45NyGQT4cmD2OXBXlcUVERli9fjsDAb8b+1tfXQyaT4fTp00hLS0NSUhJiY2P7LZuTk4OcnBwAl56pN1h7jjWj1yrwPXXM0D8A0TDhETK5hEwmQ0NDg/11Y2MjZDKZw7ZFRUX9uisut1UoFFi4cGGf/uXh9M4XekyLDEWSLMwl7080GAxkcomUlBRUV1ejtrYWZrMZRUVFDkdLnDhxAkajEfPnz7dPMxqNMJlMAACDwYCDBw/2ORk4XNq6TTh4yoDvqWN4v2PyCuyyIJeQSqXIz89HZmYmrFYr1qxZg8TERGzevBkajcYezkVFRcjKyuoTiFVVVVi7di0CAgJgs9mQm5vrkkA+cLIVNgEsSWR3BXkHiRBiMO0H1ZjInTQaDXQ6ndPt1/3jMxypa8en/5uOAJ7QI9dyagdjlwWNSL1WGz76shVps6IYxuQ1GMg0Ih2pa0eXyYK0WVGeLoXIjoFMI9L+qrMICgzAt5UTPV0KkR0DmUakf50yIGVGOMYE87w2eQ8GMo04hm4TTjR34VuxPDom78JAphHn09NtAIBvxfKJ0uRdGMg04hw81YZxwVJenUdeh4FMI86hGgPmKSIgDeTuT96FeySNKGc6LqKu7QL7j8krMZBpRDlS1w4AuHVGhIcrIeqPgUwjiq7OiDFBgZg1eZynSyHqh4FMI4qu3oibp4az/5i8EvdKGjG6enpxsrkTc6eFe7oUIocYyDRiHP2qAzYBaKYzkMk7MZBpxKioNyJAAtw8lYFM3omBTCPGZ18ZETd5PMby/hXkpRjI5DKlpaWIi4uDUqlEXl5ev/mvvPIKJk2ahOTkZCQnJ+PFF1+0zyssLIRKpYJKpUJhYeEN1yKEwBeN55A8hVfnkffioQK5hNVqxbp167Bv3z7I5XKkpKRAq9X2exTTihUrkJ+f32dae3s7tmzZAp1OB4lEgrlz50Kr1SI8fOhdDfVtF3DuYi/U8glDfg8iV+MRMrlEeXk5lEolFAoFgoKCkJWVheLiYqeW3bNnDzIyMhAREYHw8HBkZGSgtLT0hur5vLEDAKCW8wiZvBcDmVyiqakJU6ZMsb+Wy+Voamrq1+7NN9+EWq3G8uXL0dDQMKhlAaCgoAAajQYajQatra0D1vNF4zkESwMwM5oXhJD3YiCTx9x5552oq6vDF198gYyMDGRnZw/6PXJycqDT6aDT6TBp0qQB2/278RwSbxqPUbwghLwY905yCZlMZj/iBYDGxkbIZLI+bSIjIxEcHAwAeOCBB1BRUeH0soNhtQn858w59h+T12Mgk0ukpKSguroatbW1MJvNKCoqglar7dNGr9fbfy8pKUF8fDwAIDMzE3v37oXRaITRaMTevXuRmZk55FpOne3GBbOV/cfk9TjKglxCKpUiPz8fmZmZsFqtWLNmDRITE7F582ZoNBpotVr86U9/QklJCaRSKSIiIvDKK68AACIiIrBp0yakpKQAADZv3oyIiKHfne24/hwAYDZvSE9eTiKEGEz7QTUmcieNRgOdTtdv+rbdVXj5YB2O/zqTNxUiT5E404h7J/m94/pOqKLHMozJ63EPJb93orkL8THjPV0G0XUxkMmvGbpNaO0y8Yb05BMYyOTXTui7AIBHyOQTGMjk1040dwIAj5DJJzCQya8d13cialwwIscGe7oUoutiIJNfO6HnCT3yHQxk8lu9VhtOne3GrBh2V5BvYCCT3zrdeh5mqw0JPEImH8FAJr/1zQk9BjL5BgYy+a3j+k4EBQZAMWmMp0shcgoDmfzWCX0XlFFjeQ9k8hncU8lvnWju5Ak98ikMZPJL7efNaOk08YQe+RQGMvmlE/pLJ/TieIUe+RAGMvml6rPdAIA4PtSUfAgDmVymtLQUcXFxUCqVyMvL6zf/2WefRUJCAtRqNdLT01FfX2+fFxgYiOTkZCQnJ/d79JMzalq7MS5EiknjeMk0+Q4+wolcwmq1Yt26ddi3bx/kcjlSUlKg1WqRkJBgb3PzzTdDp9MhNDQUL7zwAh5//HG89tprAIDRo0ejsrJyyOs/dbYbsZPGQiJx6kENRF6BR8jkEuXl5VAqlVAoFAgKCkJWVhaKi4v7tFm0aBFCQ0MBAKmpqWhsbBy29de0dkMZNXbY3o/IHRjI5BJNTU2YMmWK/bVcLkdTU9OA7bdv346lS5faX/f09ECj0SA1NRW7du0acLmCggJoNBpoNBq0trYCADp7etHSaULsJAYy+RZ2WZDH/f3vf4dOp8OHH35on1ZfXw+ZTIbTp08jLS0NSUlJiI2N7bdsTk4OcnJyAFx6yClw6R4WAHiETD6HR8jkEjKZDA0NDfbXjY2NkMlk/dqVlZVh69atKCkpQXBwcJ/lAUChUGDhwoU4evSo0+s+9fUIi1heMk0+hoFMLpGSkoLq6mrU1tbCbDajqKio32iJo0ePYu3atSgpKUFUVJR9utFohMlkAgAYDAYcPHiwz8nA66lp7caoQAmmRoQOz4chchN2WZBLSKVS5OfnIzMzE1arFWvWrEFiYiI2b94MjUYDrVaLDRs2oLu7G/fccw8AYOrUqSgpKUFVVRXWrl2LgIAA2Gw25ObmDiqQT53txvTIMZDyHhbkYyRCiMG0H1RjInfSaDTQ6XRI+/0BxEWPwws/nOvpkoguc2r8JQ8hyK+YLTbUt13gCAvySQxk8iv1bedhtQmOsCCfxEAmv1LTenmEBQOZfA8DmfzK5SFvfEoI+SIGMvmVmtbzuCksBGOCOYCIfA8DmfzKqbPdiGX/MfkoBjL5lZrWbvYfk89iIJPf6LXacMFs5QgL8lkMZPIbJosNAEdYkO9iIJPf6Om1AuBd3sh3MZDJb5gsNowPkWLi2CBPl0I0JAxk8humXhuUUXxsE/kuBjL5DZPFyv5j8mkMZPIL5y72wsJ7WJCPYyCTX/jmKSEMZPJdDGRymdLSUsTFxUGpVCIvL6/ffJPJhBUrVkCpVGLevHmoq6uzz9u2bRuUSiXi4uKwZ8+e667r8k2FeIRMvoyBTC5htVqxbt06vPfeezh+/Dh27NiB48eP92mzfft2hIeH49SpU1i/fj02btwIADh+/DiKiopw7NgxlJaW4pFHHoHVar3m+mrOdkMCYAof20Q+jIFMLlFeXg6lUgmFQoGgoCBkZWWhuLi4T5vi4mJkZ2cDAJYvX473338fQggUFxcjKysLwcHBmDFjBpRKJcrLy6+5vprWbgRLAxEYwBEW5LsYyOQSTU1NmDJliv21XC5HU1PTgG2kUinCwsLQ1tbm1LJXO3W2G8GjuDuTbxvUM/WWLFkiDAbDkFbU2tqKSZMmDWlZV2Jdg+dMbUajEZ2dnZg2bRoAoK2tDefPn8fUqVPtbY4dOwaVSoWgoEsXcvz73/9GfHw8zpw5g7FjxyIiIgIAUFdXh7CwMISHhzusxWAwwDLuJlja6nHzHPVwfcxh463fpbfWBXhvbUOtq6KiYo8QYsl1GwohBvNvyObOnXsji7sM6xo8Z2r75JNPxG233WZ//dvf/lb89re/7dPmtttuE5988okQQoje3l4RGRkpbDZbv7ZXtnPkhL5TTNv4jggZHznYj+IW3vpdemtdQnhvbTdQl1MZy7/xyCVSUlJQXV2N2tpamM1mFBUVQavV9mmj1WpRWFgIANi5cyfS0tIgkUig1WpRVFQEk8mE2tpaVFdX49Zbbx1wXZdHWEhsFtd9ICI34GMVyCWkUiny8/ORmZkJq9WKNWvWIDExEZs3b4ZGo4FWq8X999+P++67D0qlEhERESgqKgIAJCYm4t5770VCQgKkUin+/Oc/IzAwcMB1XR6DzEAmn+fsobS4wS6Lv/71rzeyuMuwrsHzttoe3fGZ+Na298XUqVM9XYpD3ra9LvPWuoTw3tpuoC6nMnZQJ/UADKoxkTvc8aePMXFsMI795RHodDpPl0PkiFPjMdmHTD7NZhM43Xqel0yTXxjWQH7jjTeQmJiIgICAfkcqzlwKW1tbi3nz5kGpVGLFihUwm83DWR4AYMWKFUhOTkZycjKmT5+O5ORkh+2mT5+OpKQkJCcnQ6PRDHsdV3vyySchk8nste3evdthu+tdjuwKGzZswKxZs6BWq7Fs2TJ0dHQ4bOeubXblNtiU9ywu9vZ9bNO1Lsl2lYaGBixatAgJCQlITEzEH//4x35tDhw4gLCwMPt3/Otf/9rldQHX/16EEHj00UehVCqhVqvx2WefubymkydP2rdDcnIyxo8fj+eee65PG3durzVr1iAqKgqzZ8+2T2tvb0dGRgZUKhUyMjJgNBodLltYWAiVSgWVSmU/ST1kzvZtCCf6kI8fPy5OnDghvvvd74ojR47Ypx87dkyo1WrR09MjTp8+LRQKhbBYLP2Wv+eee8SOHTuEEEKsXbtW/OUvfxlSZ42zHnvsMbFlyxaH86ZNmyZaW1tduv4r/epXvxJPP/30NdtYLBahUChETU2NMJlMQq1Wi2PHjrm8tj179oje3l4hhBCPP/64ePzxxx22c8c2u3obxKfdLaZtfEd8WmOwD0n685//LNauXSuEEGLHjh3i3nvvdWlNQghx5swZUVFRIYQQorOzU6hUqn7fzQcffCDuuOMOl9dytet9L++++65YsmSJsNls4tChQ+LWW291Y3WXvtPo6GhRV1fXZ7o7t9eHH34oKioqRGJion3ahg0bxLZt24QQQmzbts3hft/W1iZmzJgh2traRHt7u5gxY4Zob293tAr3D3uLj49HXFxcv+nOXAorhMD+/fuxfPlyAEB2djZ27do1nOX1W9/rr7+OlStXumwdw82Zy5Fd4bbbboNUemlATmpqKhobG12+zoFcvQ3m/FcmgL43FRrokmxXiomJwS233AIAGDduHOLj4697daG3KC4uxurVqyGRSJCamoqOjg7o9Xq3rf/9999HbGys/SIiT1iwYIH9QqTLrtyPBsqjPXv2ICMjAxEREQgPD0dGRgZKS0uHXIdb+pCduRS2ra0NEyZMsP+H78zlsjfi448/RnR0NFQqlcP5EokEt912G+bOnYuCggKX1XGl/Px8qNVqrFmzxuGfR0O5pHi4vfTSS1i6dKnDee7YZldvg97RERglzIgYE+SwzZWXZLtLXV0djh49innz5vWbd+jQIcyZMwdLly7FsWPH3FLP9b4XT+9XRUVFAx4YeWJ7XdbS0oKYmBgAwOTJk9HS0tKvzXBvu0GPQ168eDGam5v7Td+6dSvuuuuuIRcynJypcceOHdc8Ov7Xv/4FmUyGs2fPIiMjA7NmzcKCBQtcVtfDDz+MTZs2QSKRYNOmTfj5z3+Ol1566YbWN1y1Xd5mW7duhVQqxapVqxy+hyu22fUYTIEYa+vymsc2dXd34+6778Zzzz2H8ePH95l3yy23oL6+HmPHjsXu3bvx/e9/H9XV1S6vyRPfi7PMZjNKSkqwbdu2fvM8tb0ckUgkbtnHBh3IZWVlg16JTCZDQ0OD/XVjYyNkMlmfNpGRkejo6IDFYoFUKnXYZrhqtFgseOutt1BRUXHNmgEgKioKy5YtQ3l5+Q3vxM5uuwcffBDf+973HNZ0ve3oqtpeeeUVvPPOO3j//fcH3DFdsc0crePKbdB8UYLpIY7byOVyWCwWnDt3DpGRkcNahyO9vb24++67sWrVKvzgBz/oN//KgL799tvxyCOPwGAwYOLEiS6t63rfiyv3q+t57733cMsttyA6OrrfPE9tr8uio6Oh1+sRExMDvV6PqKiofm1kMhkOHDhgf93Y2IiFCxcOeZ1u6bJw5lJYiUSCRYsWYefOnQAunbl01RF3WVkZZs2aBblc7nD++fPn0dXVZf997969fc6+usKVfXZvv/22w/U5czmyK5SWluJ3v/sdSkpKEBrq+H7D7tpmV26Dlo5u9Agpvq2O7dNmoEuyXUkIgfvvvx/x8fF47LHHHLZpbm6292WXl5fDZrO5/H8UznwvWq0Wr776KoQQ+PTTTxEWFmb/U93VrvWXqie215Wu3I8GyqPMzEzs3bsXRqMRRqMRe/fuRWZm5tBX6uzZP+HEKIu33npLyGQyERQUJKKiovrcXOY3v/mNUCgUYubMmWL37t326UuXLhVNTU1CCCFqampESkqKiI2NFcuXLxc9PT3XW+WQZGdnixdeeKHPtKamJrF06VJ7HWq1WqjVapGQkCB+85vfuKSOK/3whz8Us2fPFklJSeLOO+8UZ86c6VeXEJfOiKtUKqFQKNxSlxBCxMbGCrlcLubMmSPmzJljH8HgqW12eRvMSEkX0za+I96vahabNm0SsbGxQgghLl68KJYvXy5iY2NFSkqKqKmpcVktl3388ccCgEhKSrJvp3fffVe88MIL9n3t+eefFwkJCUKtVot58+aJgwcPuryugb6XK+uy2WzikUceEQqFQsyePbvPCClX6u7uFhEREaKjo8M+zVPbKysrS0yePFlIpVIhk8nEiy++KAwGg0hLSxNKpVKkp6eLtrY2IYQQR44cEffff7992e3bt4vY2FgRGxsrXnrppYFWwSv1yL+9duQrbHzz3/howyJMjQyFRqPhlXrkrXilHvm3U2e7ESQNgCx8tKdLIRoWDGTyWTWt56GYOIaPbSK/wUAmn3XqbDdi+ZRp8iMMZPJJF81WNBgvQMmbCpEfYSCTT6pp7YYQQNzkcZ4uhWjYMJBp2Dlzl6zKykrMnz8fiYmJUKvVeO211+zzfvSjH2HGjBn2u3xVVlb2W/5k86WxtTOjGcjkPxjINOzy8vKQnp6O6upqpKenO7xNaGhoKF599VUcO3YMpaWl+NnPftbntp5PP/00KisrUVlZ6fAWqV+e7UJQYACmRzq+UIXIFzGQadg5c5esmTNn2m/sdNNNNyEqKgqtra1Or+PL5i4oJo2BNJC7MPkP7s007Jy5S9aVysvLYTabERv7zSXQv/zlL6FWq7F+/XqYTKZ+y3zZ0o2Z0eNQUFAAjUYDjUYzqEAn8kYMZBqSxYsXY/bs2f3+XX1/5uvdJUuv1+O+++7Dyy+/jICAS7vjtm3bcOLECRw5cgTt7e146qmn+izTbbKgqeMiZkaPRU5ODnQ6HXQ6HSZNmjT8H5TIjQZ9tzci4Np3h3PmLlkA0NnZiTvuuANbt25Famqqffrlo+vg4GD8+Mc/xjPPPNNnueoWntAj/8QjZBp2ztwly2w2Y9myZVi9erX9KTGXXb7znRACu3bt6nd3suqWbgAMZPI/DGQadrm5udi3bx9UKhXKysqQm5sLANDpdHjggQcAAK+//jo++ugjvPLKK/2Gt61atQpJSUlISkqCwWDAE0880ef9T7Z0IWRUAKZEcIQF+Rfe7Y18zn3bD8N4wYx3/vu/+kzn3d7Ii/Fub+SfvmzpwswodleQ/2Egk085d7EXLZ0mzOQl0+SHGMjkU74ZYcGbCpH/YSCTTznJIW/kxxjI5FOqW7oxJigQsgl8Sgj5HwYy+ZSTzV1QRY9z+VOkiTyBgUw+pfpsF/uPyW8xkMlntHaZYOg2s/+Y/BYDmXzGcX0nACDxpjAPV0LkGgxk8hnHz1wK5ISY8R6uhMg1GMjkM47rOyGbMBphoaM8XQqRSzCQyWccO3MOCTfx6Jj8FwOZfMIFswW1hvNIZCCTH2Mgk0840dwFIdh/TP6NgUw+wX5Cj0fI5McYyOQTjp05h7DRo3jJNPk1BjINu/b2dmRkZEClUiEjIwNGo9Fhu8DAQPvTQrRarX16bW0t5s2bB6VSiRUrVsBsNuPzhnNQy8N4yTT5NQYyDbu8vDykp6ejuroa6enpyMvLc9hu9OjRqKysRGVlJUpKSuzTN27ciPXr1+PUqVMIDw/H//vbSzjZ0gW1nBeEkH9jINOwKy4uRnZ2NgAgOzsbu3btcnpZIQT2799vf/BpdnY2dpYdgtUmoJZPcEm9RN6CgUzDrqWlBTExMQCAyZMno6WlxWG7np4eaDQapKam2kO7ra0NEyZMgFQqBQDI5XI09wYDAOY4COSCggJoNBpoNBq0tra64uMQuY3U0wWQb1q8eDGam5v7Td+6dWuf1xKJZMB+3/r6eshkMpw+fRppaWlISkpCWFj/bgnbBDmixgVjclhIv3k5OTnIyckBcOkhp0S+jIFMQ1JWVjbgvOjoaOj1esTExECv1yMqKsphO5lMBgBQKBRYuHAhjh49irvvvhsdHR2wWCyQSqVobGxEwMQZ7D+mEYFdFjTstFotCgsLAQCFhYW46667+rUxGo0wmUwAAIPBgIMHDyIhIQESiQSLFi3Czp07AQAvFv4D5pBw9h/TiMBApmGXm5uLffv2QaVSoaysDLm5uQAAnU6HBx54AABQVVUFjUaDOXPmYNGiRcjNzUVCQgIA4KmnnsKzzz4LpVKJhguBACS4ZWq4pz4OkdtIhBCDaT+oxkQ36tm9J5H/wSl88WQmxgZfu4dNo9FAp9O5qTKiQXFqAD2PkMmr6eqNiI8Zf90wJvIHDGTyWharDZUNHdBMY3cFjQwMZPJaVfouXDBbMXd6hKdLIXILBjJ5rYr6dgDgETKNGAxk8lrlde24KSwEN/EObzRCMJDJK9lsAodq2jA/dqKnSyFyGwYyeaWq5k4YL/Ti28pIT5dC5DYMZPJKh2raAADzYxnINHIwkMkrfVLTBsXEMYgJY/8xjRwMZPI6vVYbDp9uw7fYXUEjDAOZvM5n9UacN1vxbZ7QoxGGgUxeZ//JsxgVKMF3VAxkGlkYyOR19ledxbwZkRgXMsqrF8o7AAAHUElEQVTTpRC5FQOZvMpXbRdQfbYbabMc39SeyJ8xkMmr7D9x6fl76fEMZBp5GMjkVfYeb0HspDGYFjnG06UQuR0DmYZde3s7MjIyoFKpkJGRAaPR2K/NBx98gOTkZPu/kJAQvPr6Lnx6ug2W2iOYMWOGfV5lZaUHPgWR+zGQadjl5eUhPT0d1dXVSE9PR15eXr82ixYtQmVlJSorK7F//36EhobCFJUAmwCiLn6Fp59+2j4/OTnZA5+CyP0YyDTsiouLkZ2dDQDIzs7Grl27rtl+586dWLp0KfaeMCAuehzGWLvcUSaR12Eg07BraWlBTEwMAGDy5MloaWm5ZvuioiJkLluJI3VG3Dnn0nK//OUvoVarsX79evvTqR0pKCiARqOBRqNBa2vr8H0IIg/gQ05pSBYvXozm5uZ+07du3Yrs7Gx0dHTYp4WHhzvsRwYAvV4PtVqN//37x3j+QA0+2rAIUtM5TJ48GWazGTk5OYiNjcXmzZuvWxMfckpezKmHnPLJkTQkZWVlA86Ljo6GXq9HTEwM9Ho9oqIGHsL2+uuv4/vLluGNz5rwHeVETIkIBRAKAAgODsaPf/xjPPPMM8NdPpFXYpcFDTutVovCwkIAQGFhIe66664B2+7YsQOJi++F/lwP/s+tUwFcOmoGACEEdu3ahdmzZ7u+aCIvwECmYZebm4t9+/ZBpVKhrKwMubm5AACdTocHHnjA3q6urg4NDQ34/Px4TBwbhMUJ0QCAVatWISkpCUlJSTAYDHjiiSc88jmI3I19yORRJ5u7kPncR1i/eCZ+ulh1Q+/FPmTyYk71IfMImTzqrx/VYPSoQKyeP83TpRB5HAOZPKbReAEllWew8tapCB8T5OlyiDyOgUwe8/u9XyIwQIIHF8zwdClEXoGBTB7xn6ZzePtoE9Z8Zwafm0f0NQYyuZ3NJvDrd44jYkwQHl4Y6+lyiLwGA5nc7p/lX6G8th0bl8RhPJ8KQmTHQCa3ami/gG27q/Ad5UTcq5ni6XKIvAoDmdymp9eKR/7xGQIkEmz7QRIkEqeGZhKNGLyXBbmFEAJP7PoP/t10Dn9brfn6nhVEdCUeIZPLCSGQ994J7KxoxE/TVcj4+hJpIuqLR8jkUjabwFOlJ/DXj07jvtRp+NkNXh5N5M8YyOQy3SYLct/8Au98ocd9qdOwRZvIfmOia2Agk0tU1BvxP298jvq289i4ZBYe+q6CYUx0HQxkGlaNxgv4Y1k13qhoRExYCP75YCpSFZGeLovIJzCQ6YZZbQIHTxnwRkUjSv+jhwQS5CxQ4KfpKowJ5i5G5CyOsqAh6bhgRul/9PhV8X/wnaf2Y/VL5fjoy1asmjcNGxLO4x8blmPc6KBr3p+4tLQUcXFxUCqVyMvLs0+vra3FvHnzoFQqsWLFCpjNZnd8JCKP4+ELDain1wpDtwlnOnpwpuMiag3n8WVLF062dKHWcB5CAKNHBWJ+bCSeuCMBixOiECwNRFVVABa89RbWrl074HtbrVasW7cO+/btg1wuR0pKCrRaLRISErBx40asX78eWVlZeOihh7B9+3Y8/PDDbvzkRJ7hlkA+cPIsuk0WAMDVDyi5+hEk13qCSf9lxcDzrrGeq9fRb43iyl+vanvN9x24vuste/XM/tvlyt8H0RaAxWpDr9UGs1XAbLn0e6/VBrPFBrPVhl6rwHmTBecu9uLcxV50fv3TZLH1ed8ACTA9cgxmRo/DsmQZ5sdGQi2fgCBp3z+04uPjcT3l5eVQKpVQKBQAgKysLBQXFyM+Ph779+/HP//5TwBAdnY2nnzySQYyjQhuCeSt71ah+my3O1ZF1xEUGIAgaQBGBUq+/hmAoMAAhAYHImz0KESPH4vxIaMQNnoUxo8ehcgxQZCFj0ZM2GjIw0cjZFTgsNTR1NSEKVO+uZeFXC7H4cOH0dbWhgkTJkAqldqnNzU1Dfg+BQUFKCgoAAC0trYOS21EnuKWQP7bag16rd8cbfUf/dR3wpXzr2569dApSZ95V7/rwO/br4Krl71iQv8aBl5P/3lXLzz0ZYdakzRQglGBl0J4uIaeLV68GM3Nzf2mb9269ZpPmR5uOTk5yMnJAXDpmXpEvswtgTx94hh3rIbcqKys7IaWl8lkaGhosL9ubGyETCZDZGQkOjo6YLFYIJVK7dOJRgKOsiCPSElJQXV1NWpra2E2m1FUVAStVguJRIJFixZh586dAIDCwkK3HnETeRIDmYbd22+/DblcjkOHDuGOO+5AZmYmAODMmTO4/fbbAQBSqRT5+fnIzMxEfHw87r33XiQmJgIAnnrqKTz77LNQKpVoa2vD/fff77HPQuROkmuNanBgUI2J3Emj0Vxz3DORBzl18oZHyEREXoKBTETkJRjIRERegoFMROQlBntSj8hrSSSSUiHEEk/XQTRUDGQiIi/BLgsiIi/BQCYi8hIMZCIiL8FAJiLyEgxkIiIvwUAmIvISDGQiIi/BQCYi8hIMZCIiL/H/AQGRDwgIKcptAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def tanh(x):\n", + " \"\"\"\n", + " tanh函数\n", + " :param x: np.array 格式数据\n", + " :return: tanh 函数\n", + " \"\"\"\n", + " y = (1-np.exp(-2*x))/(1+np.exp(-2*x))\n", + " return y\n", + "\n", + "# 绘制 tanh 函数图像\n", + "plot_activation_function(tanh)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "优点：\n", + "+ 比Sigmoid函数收敛速度更快。\n", + "+ 相比Sigmoid函数，其输出以0为中心。\n", + "\n", + "缺点：\n", + "+ 还是没有改变Sigmoid函数的最大问题——由于饱和性产生的梯度消失。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.ReLU函数\n", + "\n", + "Relu激活函数（The Rectified Linear Unit），用于隐层神经元输出。公式如下：" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "$$ f(x) = max(0, x)$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def relu(x):\n", + " \"\"\"\n", + " relu 函数\n", + " :param x: np.array 格式数据\n", + " :return: relu 函数\n", + " \"\"\"\n", + " \n", + " y = \n", + "\n", + " return y\n", + "\n", + "# 绘制 relu 函数\n", + "plot_activation_function(relu)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def relu(x):\n", + " \"\"\"\n", + " relu 函数\n", + " :param x: np.array 格式数据\n", + " :return: relu 函数\n", + " \"\"\"\n", + " \n", + " y = np.maximum(0,x)\n", + "\n", + " return y\n", + "\n", + "# 绘制 relu 函数\n", + "plot_activation_function(relu)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "优点：\n", + "+ 因为它线性、非饱和的形式，ReLU在SGD中能够快速收敛。\n", + "+ 有效缓解了梯度消失的问题。\n", + "+ 提供了神经网络的稀疏表达能力。\n", + "\n", + "缺点：\n", + "+ 随着训练的进行，可能会出现神经元死亡，权重无法更新的情况。如果发生这种情况，那么流经神经元的梯度从这一点开始将永远是0。也就是说，ReLU神经元在训练中不可逆地死亡了。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 单层感知机实例" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们根据上面的定义可以编写一个简单的感知机模型。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def perceptron(x, w, threshold):\n", + " \"\"\"\n", + " 感知机模型\n", + " :param x: 输入数据 np.array 格式\n", + " :param w: 权重 np.array 格式，需要与 x 一一对应\n", + " :param threshold: 阀值\n", + " :return: 0或者1\n", + " \"\"\"\n", + " x = np.array(x)\n", + " w = np.array(w)\n", + " \n", + " #计算信息加权总和\n", + " y_sum = \n", + " \n", + " # 计算输出大于阀值返回 1，否则返回 0\n", + " output = \n", + " return output\n", + "\n", + "\n", + "# 输入数据\n", + "x = np.array([1, 1, 4])\n", + "# 输入权重\n", + "w = np.array([0.5, 0.2, 0.3])\n", + "# 返回结果\n", + "perceptron(x, w, 0.8)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def perceptron(x, w, threshold):\n", + " \"\"\"\n", + " 感知机模型\n", + " :param x: 输入数据 np.array 格式\n", + " :param w: 权重 np.array 格式，需要与 x 一一对应\n", + " :param threshold: 阀值\n", + " :return: 0或者1\n", + " \"\"\"\n", + " x = np.array(x)\n", + " w = np.array(w)\n", + " \n", + " #计算信息加权总和\n", + " y_sum = np.sum(w * x)\n", + " \n", + " # 计算输出大于阀值返回 1，否则返回 0\n", + " output = 1 if y_sum > threshold else 0\n", + " return output\n", + "\n", + "\n", + "# 输入数据\n", + "x = np.array([1, 1, 4])\n", + "# 输入权重\n", + "w = np.array([0.5, 0.2, 0.3])\n", + "# 返回结果\n", + "perceptron(x, w, 0.8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3 神经网络" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.1 神经网络的结构" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "神经网络：相互连接形成一个无环图的神经元集合。\n", + "\n", + "神经网络通常由不同的神经元层组织而成，常见的层类型有：\n", + "+ 全连接层\n", + "+ 卷积层\n", + "+ 池化层\n", + "+ Dropout层\n", + "+ RNN层\n", + "+ ......" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "首先，我们来看一个完全由全连接层联结起来的神经网络，也被称为多层感知器(Multilayer Perceptrons, MLP)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "神经网络架构示意图如下：\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "与感知机的不同，神经网络：\n", + "+ 输入层和输出层之间存在若干隐藏层。\n", + "+ 每个隐藏层中包含若干神经元。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 补充材料：梯度下降与误差反向传播" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 正向传播 与 反向传播" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "+ 前馈神经网络接收一个输入 $x$ ，并产生一个输出 $\\hat{y}$ 信息正向流过网络，称为**正向传播(forward propagation)**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "+ 训练过程中：正向传播可以一直继续下去直到产生一个标量代价\n", + "$J(\\theta)$ ." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "+ 反向传播：允许信息从代价出发，反向流过网络" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 误差反向传播" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "+ **核心问题**：给定某个函数 ，计算f在点x处的梯度$\\epsilon{f(x)}$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "+ 在神经网络中， 对应于**损失函数**，而输入x 则是由**训练数据**和神经网络**权重参数**构成" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "+ 反向传播：通过递归地应用链式法则来计算表达式梯度的一种方法" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "反向传播指的仅仅是计算梯度的方法，并不是多层神经网络的整个学习算法！" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "简单表达式与梯度解释：\n", + "\n", + "梯度：是一个向量，表示函数在该点处沿着该方向变化最快，变化率最大\n", + "\n", + "而对于单变量的情况下，梯度也就等同于它的导数。\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "复合表达式和链式法则：\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "反向直播的直观理解：\n", + "$f(x,y,z) = (x+y)z， q=x+y， f=qz$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3 神经网络实现MNIST手写数字分类" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "好，我们接下来，依旧使用MNIST手写数字数据集来实现一个神经网络的分类方法。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "采用 **keras** 框架搭建一个神经网络解决手写体数字识别问题。 \n", + "1. 导入相关包" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 数据集 mnist\n", + "from tensorflow.keras.datasets import mnist\n", + "# 序列模型 Sequential\n", + "from tensorflow.keras.models import Sequential\n", + "# 神经网络层 Dense,Activation,Dropout\n", + "from tensorflow.keras.layers import Dense, Activation, Dropout\n", + "# 工具 np_utils\n", + "from tensorflow.python.keras.utils.np_utils import to_categorical\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "!mkdir -p ~/.keras/datasets\n", + "!cp ./mnist.npz ~/.keras/datasets/mnist.npz" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. 下载 **MNIST** 数据集并将它们转换为模型所能使用的格式。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 获取数据\n", + "(X_train, y_train),(X_test,y_test) = mnist.load_data()\n", + "\n", + "# 将训练集数据形状从（60000,28,28）修改为（60000,784）\n", + "X_train = X_train.reshape(len(X_train), -1)\n", + "X_test = X_test.reshape(len(X_test), -1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "通过plot查看数据集情况" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAToAAAEyCAYAAABqERwxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xm0FMX1B/DvlQCiiAKaJ24sCkFUFNwQOUAUN1xwiagBBUPE4woeNeISl7iBJp7gLiqCygkhQQGNBAmCuCARDf4iiwIq8pRF3FhUCFq/P6bnvvseM8zW3dPd8/2c8867r2bpGq9TdHVVV4lzDkRESbZduStARBQ0NnRElHhs6Igo8djQEVHisaEjosRjQ0dEiceGjogSr6SGTkROFJEPRGSpiAzzq1JUOOYiGpiHaJJiJwyLSD0AHwI4DkA1gLcBnOecW+hf9SgfzEU0MA/R9bMSXnsEgKXOuY8AQETGA+gDIGtSRYS3YZRmrXNutwzlBeWCeSiZL3nwnsNclCZbLmoppeu6J4AV5u9qr6wWERksIvNEZF4Jx6KU5VnKc+aCefBV0XkAmAufZctFLaWc0eXFOTcKwCiA/3qVE/MQHcxF+Eo5o/sMwN7m7728MgofcxENzENEldLQvQ2grYi0FpEGAM4FMMWfalGBmItoYB4iquiuq3Nui4hcDmAagHoARjvnFvhWM8obcxENzEN0FT29pKiD8XpEqd5xzh1W6pswDyXzJQ8Ac+GDvHLBOyOIKPHY0BFR4rGhI6LEY0NHRIkX+IRholIceuihGl9++eUaX3DBBQCAp59+WsseeOABjd99990QakdxwTM6Iko8NnRElHgVOY+uXr16Gu+88845n2+7TDvssAMA4Be/+IWWXXbZZRr/8Y9/1Pi8887T+IcfftB4+PDhGt922235VhuokHl0hxxyiMavvPKKxk2aNNnm67799luNmzdv7n/FanAeXQGOPfZYjceNG6dxjx49NP7ggw+KfXvOoyMiAtjQEVEFSMyo6z777KNxgwYNNO7atSsAoFu3blq2yy67aHzWWWcVdbzq6mqN77//fo3POOMMjdevX6/xe++9p/Grr75a1DGT7IgjjtB44sSJGttLC/YyS/q/7ebNm7XMdle7dOmisR2Btc+Pm+7du2tsP+vzzz9fjurk7fDDD9f47bffLksdeEZHRInHho6IEi/WXddso3P5jKQW66effgIA3HTTTVq2YcMGje2o0sqVKzX++uuvNS5hhCn20qPWANC5c2eNn332WY1btGiR832WLFkCALjnnnu0bPz48Rq/8cYbGttc3X333QXWODp69uypcdu2bTWOYtd1u+1qzqFat26tccuWLTUWkfDqE9qRiIjKhA0dESVerLuun376qcZffvmlxsV2XefOnavxN998o/Evf/lLjdOjds8880xRx6h0jz32mMZ2QnWh0t3exo0ba5kdzbbdvI4dOxZ9nChJ398LAHPmzCljTXKzlx8uuugije0lisWLF4dWH57REVHisaEjosSLddf1q6++0vjaa6/V+JRTTtH4P//5D4Dak3qt+fPna3zcccdpvHHjRo0POOAAjYcMGVJCjStXermlk08+WcuyjbrZLugLL7ygsb2P+PPPPwdQk1+g9sj2Mccck/M4cWNHMqPuiSeeyFieHi0PW87/ciIyWkTWiMj7pqyZiEwXkSXe76bBVpM8rZiLSGAeYiaffyLGADixTtkwADOcc20BzPD+puCtBXMRBcxDzOTsujrnZotIqzrFfQD09OKxAGYBuM7HehVs0qRJGtvJw+l7Ig8++GAtGzRokMa2O2S7q9aCBTVbcw4ePLj0yhZvA4Cv6pRFLhdpdkL39OnTAdReasneuzp16lSN7WisXcrHTvxNd42++OILLbP3E6cndgO1u8t2knIJqxCHmof0qHFVVZUfbxeKbDMf0v8fhK3Ya3RVzrn0tP9VALJmQEQGAyhr65BweeWCeQgcvxMRVvJghHPObWvxQOfcKACjgPAWGVy3bt1WZXZRRsvO8fnrX/+qsT0jiItt5SKsPLRr105jO0CU/hd+7dq1WmZvkRs7dqzG9pa6f/zjHxnjQjRq1Ejjq6++WuN+/foV9X65+P2d6N27N4DanyOK7Bmnve3L+uyzz8KqTi3FDuOsFpEWAOD9XuNflahAzEU0MA8RVmxDNwXAAC8eAGCyP9WhIjAX0cA8RFjOrquI/AWpi6y7ikg1gFsADAcwQUQGAVgOoG+QlfTDrbfeqrHdQs9e7O7Vq5fGL7/8cij1KlBrAHMQsVw0bNhQYzu4k+5yATWDQvY2pnnz5mkcVrfMLtBaglDzYPcnSbMDZFFhc2+7sR9++KHGdjHaMOUz6prthsRjs5RTcD7OshEIcxEu5iFm4jPVmoioSLG+BawQdo6cHWm1c6kef/xxjWfOnKmx7WI99NBDAGrPAat0nTp10th2V60+ffoA4H4ZfinH3gt2DuSJJ9bMl+7fvz8A4Pjjj8/4uttvv11juypQmHhGR0SJx4aOiBKvYrqu1rJlyzQeOHCgxk899ZTG559/fsZ4xx13BAA8/fTTWmYnvlai++67T2O7UojtpobdZbUrfcRx8ncuzZo1K+j59hbIdI7sLIO99tpLY7tdqJ1Ubf+bfv/99xqnF6zdtGmTlv3sZzVNyzvvvFNQXYPAMzoiSjw2dESUeBXZdbXsVnF2UUDbHTv22JrpUXfddReA2tu23XnnnRqX616+sNnFTe0qJXY0esqUKaHWybLdVVsnu9BqXKS7ifZzPProoxrfcMMNOd/D7puR7rpu2bJFy7777juNFy5cqPHo0aM1trMP7KWI1atXAwCqq6u1zE4AD3NviGx4RkdEiceGjogSr+K7rtb77+vK2Ojbt+ZWxVNPPVXj9MjsxRdfrGV213S770SS2a6JHaVbs6Zm0Q677FVQ7H229n5myy7Eev311wddJd9deumlAIDly5drWdeuXQt6D7s1aHqR2kWLFmnZW2+9VXT90ovR7rbbblr20UcfFf1+QeAZHRElHhs6Iko8dl2zsPfkPfPMMxqn9yqwEyK7d++usd0hftasWcFVMKLspNEgJ1Knu6x2Hwm7orEdAfzTn/6ksV29OG5GjBhR7ipkZGclpE2cOLEMNcmOZ3RElHg8ozPsXKNf/epXGh9++OEa2zO5NDvvaPbs2QHVLh6CnDtn5+ulz97OOeccLZs8uWZR37POOiuwelBudn5qFPCMjogSjw0dESVeRXZd7Rr8l19+ucZnnnmmxrvvvvs23+PHH3/U2F50T+JKGZnYVUpsfPrpp2s8ZMiQko9z1VVXafz73/9e4/T2iePGjdMyux8FkZXzjE5E9haRmSKyUEQWiMgQr7yZiEwXkSXe76bBV7fitWMeIqE+vxPxkk/XdQuAq51zHQB0AXCZiHQAMAzADOdcWwAzvL8pWNXMQ2TwOxEj+ewCthLASi9eLyKLAOwJoA9S2yACwFgAswBcF0gtS5Dugp53Xs1mZra72qpVq4LeL72Cg12xJMRVOr4DopEHu5KGjW2X//7779c4vQrGl19+qWVdunTR2C5uaheJtAtC2tuYpk2bBgB4+OGHi/sApfmfc+5dIBq5iAp7CaNdu3Yal3J7mV8KGowQkVYAOgGYC6DKawQBYBWAqiwvI58xD9HBXMRD3oMRItIYwEQAQ51z62zr7ZxzIpJxWywRGQxgcKkVpRTmITqYi/jIq6ETkfpIJXScc+45r3i1iLRwzq0UkRYA1mR6rXNuFIBR3vsEtkeg3Rm8Q4cOGj/44IMAgPbt2xf0ful18AHg3nvv1Tg9KbVMo6uCiOehXr16GqdX3QBqJvCuW7dOy+yqL9m8+eabGtstKG+++eaS6lmqOHwnwmYvYdj9JaIgn1FXAfAkgEXOufvMQ1MADPDiAQAm130t+a4lmIeo4HciRvI5ozsawPkA/isi6XWobwAwHMAEERkEYDmAvlleT/5pDuAY5qHsGoPfiVjJZ9T1daS6TJlsvWxBwOw2b4899pjG9j7INm3a5P1+tmtkV7lIj+oBtbd2K7N3nHOHZSgPPQ9z5szR2O4ab+8LttKjsfYSg2VHY8ePH6+xH5OOA7DBOReZ70QUHXXUURqPGTOmfBXxRKsjTUQUADZ0RJR4kb3X9cgjj9TYLqh4xBFHaLznnnvm/X52Ozc7kTW9fSEAbNy4seB6Viq7sKW9R9jupWEXxcxk5MiRGj/yyCMaL1261I8qUsjs9Jqo4RkdESUeGzoiSrzIdl3POOOMjHE2dpXfF198UeP0buR2RNXuB0Gls8tU2S0Hs20/SMkydepUAMDZZ59d5ppkxzM6Iko8sbdtBH6wBN3uUibZ5tEVhHkomS95AJgLH+SVC57REVHisaEjosRjQ0dEiceGjogSjw0dESUeGzoiSjw2dESUeGzoiCjxwr4FbC2Ajd7vJNsVwXzGlj69z1qkVsANqp5REsRn9CsPAL8TpcorF6HeGQEAIjLPr1nlURWXzxiXepYiDp8xDnUsVbk/I7uuRJR4bOiIKPHK0dCNKsMxwxaXzxiXepYiDp8xDnUsVVk/Y+jX6IiIwsauKxElHhs6Ikq8UBs6ETlRRD4QkaUiMizMYwdFRPYWkZkislBEFojIEK+8mYhMF5El3u+m5a5rGvMQHcxFSJxzofwAqAdgGYA2ABoAeA9Ah7COH+DnagGgsxfvBOBDAB0A3ANgmFc+DMCIcteVeYhOHpiLcHMR5hndEQCWOuc+cs5tBjAeQJ8Qjx8I59xK59y7XrwewCIAeyL12cZ6TxsL4PTy1HArzEN0MBchCbOh2xPACvN3tVeWGCLSCkAnAHMBVDnn0ttjrQJQVaZq1cU8RAdzERIORvhERBoDmAhgqHNunX3Mpc7VOY8nBMxDdEQpF2E2dJ8B2Nv8vZdXFnsiUh+phI5zzj3nFa8WkRbe4y0ArClX/epgHqKDuQhJSQ1dgSNGbwNoKyKtRaQBgHMBTCnl+FEgIgLgSQCLnHP3mYemABjgxQMATA64HvnmgnkIth78TkQkF7WEOWIEoDdSIzDLANxY7tEhP34AdEPqFPz/AMz3fnoDaA5gBoAlAP4FoFmAdSgoF8xDNPLAXASXi63qVMKHOQrANPP39QCuz/Eax5+Sfr7wIxcR+Bxx//ElD8xFcLmo+1NK1zWvESMRGSwi80RkXgnHopTlWcpz5oJ58FXReQCYC59ly0Utga8w7JwbBW/lAhFxQR+PMmMeooO5CF8pZ3SJHTGKIeYiGpiHiCqloUvkiFFMMRfRwDxEVNFdV+fcFhG5HMA0pEabRjvnFvhWM8obcxENzEN0hbrwJq9HlOwd58MGI8xDyXzJA8Bc+CCvXPAWMCJKPDZ0RJR4bOiIKPHY0BFR4rGhI6LEY0NHRInHho6IEi/we12T6qabbtL4tttu03i77Wr+7ejZs6fGr776aij1IgrKTjvtpHHjxo01PvnkkwEAu+22m5bdd1/NMnSbNm0KoXbbxjM6Iko8NnRElHjsuhZo4MCBAIDrrrtOy3766aeMzw3z9joiv7Rq1Upj+//5UUcdpfGBBx64zfdo0aKFxldeeaV/lSsSz+iIKPHY0BFR4rHrWqCWLVsCALbffvsy1yT+jjzySI379++vcY8ePTQ+4IADMr72mmuuAQB8/vnnWtatWzeNn332WY3nzp1bemUTqH379hoPHTpU4379+mncqFEjjVObe6WsWFGzYvz69esBAPvvv7+W9e3bV+OHH35Y48WLF5da7aLwjI6IEo8NHRElHruueejVq5fGV1xxxVaP29PxU045RePVq1cHW7EYOuecczQeOXKkxrvuuqvGtos0a9Ysje2E1HvvvXer97avs88999xzi69wQuy8884ajxgxAkDtXNjJwNksWbJE4xNOOEHj+vXrA6j9PbD5tHG58IyOiBKPDR0RJR67rlnYEbynnnpKY9sFSLPdqOXL89pPtyL87Gc1/3sddlhqWf/HH39cy3bYYQeNZ8+erfHtt9+u8euvv65xw4YNNZ4wYQIA4Pjjj8947HnzuDe0dcYZZ2j829/+Nu/XLVu2TOPjjjtOYzvqut9++5VYu+DlPKMTkdEiskZE3jdlzURkuogs8X43Dbaa5GnFXEQC8xAz+XRdxwA4sU7ZMAAznHNtAczw/qbgrQVzEQXMQ8zk7Lo652aLSKs6xX0A9PTisQBmAbgOCTJgwACN99hjj60et6OBTz/9dBhVAoANAL6qUxbZXNhJwE888cRWj0+fPl1jOwK4bt26jO9nn5Opy1pdXa3x2LFjC6tsYWKVBwA4++yzt/n4J598ovHbb7+tsb3X1XZXLTtROKqKvUZX5Zxb6cWrAFRle6KIDAYwuMjjUG555YJ5CBy/ExFW8mCEc85taxNe59woAKOA6G/Wa+f7/OY3v9HYrk7yzTffAADuuOOO8CqWp23lIqw82IGEG264wR4fQO3bgezipdnO4qwbb7xxm4/bVTK++OKL3JUNSBS/ExdddJHGgwen2tiXX35Zy5YuXarxmjVrCnrvqqqsbXpkFDu9ZLWItAAA73dh/2XIT8xFNDAPEVZsQzcFQPoi1gAAk/2pDhWBuYgG5iHCcnZdReQvSF1k3VVEqgHcAmA4gAkiMgjAcgB9s79DtNlFBidOnJjz+Q888AAAYObMmUFVaVtaA5iDiOXi5ptv1th2Vzdv3qzxtGnTANS+uP39999nfD+7MowddNhnn300Tt/uZS8hTJ4cWtsSyTxsi13l5dZbb/X1ve2CnFGVz6jreVkeOtbnulBuHzvnDstQzlyEi3mIGd4CRkSJV/G3gJ14Ys28z44dO2Z8zowZMzS2K25Usl122UXjSy+9VGO7T0a6uwoAp59++jbfz95GNG7cOI0PPfTQjM//+9//DgC455578qwx5cuOXu+44445n3/QQQdtVfbmm29qPGfOHH8qVgKe0RFR4rGhI6LEq8iuq+1GDR8+PONz7KoZ9nawb7/9NriKxUiDBg00zrawou0C/fznPwcAXHjhhVp22mmnaWy3z7O7wNuusI3Te0Js3Lix4LpXuvSqMR06dNCyW265RePevXtnfN1229WcF2Xa4tOO7No8//jjj8VX1ic8oyOixGNDR0SJVzFd10InBn/00Ucac++HrdnJwPa+UrtXw8cff6yx7XZmYrs99r5Xu+P72rVrNX7hhRcKrHHlSe/lAACdOnXSOP3/v/1vaydv21zYEVM7Q8EumppmF1o988wzNbYzFez/N2HiGR0RJR4bOiJKvIrputp7LDONGNWVbTSWUtLLVQG1R7FffPFFjZs1a6Zxeu8Bez/qmDFjNP7qq5p1LMePH6+x7V7ZcsrMjobbruZzzz231XNvu+02jV955RWN33jjDY1tDu1z7Ch5mr1scffdd2v86aefajxp0iSNN23alOVT+I9ndESUeGzoiCjxEt91PeSQQwBk3xbPst2qDz74ILA6Jc3cuXM1tt2XQnTv3l3jHj16aGwvM9iRcKphR1dtd/Taa6/N+PypU6cCqFlyDKh9KcLm8KWXXtLY3tNqR0/T9xvb7myfPn00tvcu/+tf/9J4xIgRGn/99ddb1XP+/PkZ618MntERUeIl/owuvS5+06aZt9l86623NB44cGAYVaIMGjVqpLE9i7Pz7zgYUaNevXoa2306rrnmGo3t7XHDhtXsvpj+72jP4tIbjAPAgw8+qLGdf7dkyRKNL7nkEo3Ti9A2adJEy7p27apxv379NLa3/dld4Kz0bmOtW7fO+HgxeEZHRInHho6IEi/xXdfmzZsDyD53zm6/t2HDhlDqRFuzi3RSbuktC4Ha3dXvvvtO44svvlhju7Vhly5dANReYeSkk07S2F5G+MMf/qDxU089pXGmzaztrXv//Oc/M8bnnVezM8Ovf/3rrd4DAK666qqM5aXIeUYnInuLyEwRWSgiC0RkiFfeTESmi8gS73fmi2Dkp3bMQyTU53ciXvLpum4BcLVzrgOALgAuE5EOAIYBmOGcawtghvc3BauaeYgMfidiRHKtKrHVC0QmA3jQ++npnFvpbdg7yzn3ixyvDWVXcnuKnR5JzdZ1bdOmjcbLly8PtF4+eCe9+1Qc8lCIE044QWM7d8v+/2lvB7MrppTBO3YXsHLkYuXKlRrbeW/2tqrFixdrbPd+sPtzZGK3Q7S3ckVhAc0M3smyI1stBV2jE5FWADoBmAugyjmX/q+9CkBVltcMBjA402NUHOYhOpiLeMh71FVEGgOYCGCoc26dfcyl/tnN+C+Tc26Uc+6wfFpdyo15iA7mIj7yOqMTkfpIJXSccy69DMJqEWlhTtPXBFXJfKRv9QKAXr16aZzustpbVh566CGNY7aopiDieSiWvYQQB+X+TqxatUpj23Vt2LChxgcffHDG16YvDcyePVvL7Koin3zyicYR7a4WLJ9RVwHwJIBFzrn7zENTAKR3jRkAYHLd15LvWoJ5iAp+J2IknzO6owGcD+C/IpK+y/YGAMMBTBCRQQCWA+gbTBXJaA7gGOah7BqD34lYydnQOedeR6rLlMmx/laneHbn+N13332rxz/77DON7QTLmMk2whSZPBTrtdde0zjXtnoRsME5V9bvhF3txS582rlzZ43XrKnpOY8ePVrj9Eoh5dq/oRx4CxgRJR4bOiJKvMTf60rx8P7772tslwOyo7H77ruvxmWeMFx269ev1/iZZ57JGFMNntERUeKxoSOixEtM19Xe1/fmm29q3K1bt3JUh0pw1113afzEE09ofOedd2p8xRVXAAAWLlwYXsUotnhGR0SJV/DqJSUdLIKrZsRMXis15BL1PNi9ByZMmKCxvbUvvSGzXTzS7pEQMF/yAEQ/FzGQVy54RkdEiceGjogSj13XeKmIrqtlu7F2MCK93V7Hjh21LMSBCXZdo4NdVyIigA0dEVUAdl3jpeK6rhHFrmt0sOtKRASwoSOiChD2LWBrAWz0fifZrgjmM7b06X3WIrUCblD1jJIgPqNfeQD4nShVXrkI9RodAIjIvKTvfhSXzxiXepYiDp8xDnUsVbk/I7uuRJR4bOiIKPHK0dCNKsMxwxaXzxiXepYiDp8xDnUsVVk/Y+jX6IiIwsauKxElHhs6Ikq8UBs6ETlRRD4QkaUiMizMYwdFRPYWkZkislBEFojIEK+8mYhMF5El3u+m5a5rGvMQHcxFSJxzofwAqAdgGYA2ABoAeA9Ah7COH+DnagGgsxfvBOBDAB0A3ANgmFc+DMCIcteVeYhOHpiLcHMR5hndEQCWOuc+cs5tBjAeQJ8Qjx8I59xK59y7XrwewCIAeyL12cZ6TxsL4PTy1HArzEN0MBchCbOh2xPACvN3tVeWGCLSCkAnAHMBVDnnVnoPrQJQVaZq1cU8RAdzERIORvhERBoDmAhgqHNunX3Mpc7VOY8nBMxDdEQpF2E2dJ8B2Nv8vZdXFnsiUh+phI5zzj3nFa8WkRbe4y0ArClX/epgHqKDuQhJSQ1dgSNGbwNoKyKtRaQBgHMBTCnl+FEgIgLgSQCLnHP3mYemABjgxQMATA64HvnmgnkIth78TkQkF7WEOWIEoDdSIzDLANxY7tEhP34AdEPqFPz/AMz3fnoDaA5gBoAlAP4FoFmAdSgoF8xDNPLAXASXi63qVMKHOQrANPP39QCuz/Eax5+Sfr7wIxcR+Bxx//ElD8xFcLmo+1NK1zWvESMRGSwi80RkXgnHopTlWcpz5oJ58FXReQCYC59ly0Utga8w7JwbBW/lAm4EUj7MQ3QwF+Er5YwusSNGMcRcRAPzEFGlNHSJHDGKKeYiGpiHiCq66+qc2yIilwOYhtRo02jn3ALfakZ5Yy6igXmILm5gHS/cwDoauIF1dHADayIigA0dEVUANnRElHhs6Igo8QKfMBxFI0eO1PjKK6/U+P3339f4lFNO0Xj58rwmXxNRRPGMjogSjw0dESVexXRdW7VqpXH//v01/umnnzTef//9NW7fvr3G7Lr6p127dhrXr19f4+7du2v88MMPa2zzU4jJk2uWOjv33HM13rx5c1Hvl3Q2F127dtX4rrvu0vjoo48OtU5+4hkdESUeGzoiSryK6bp+8cUXGs+ePVvj0047rRzVqQgHHHCAxgMHDgQAnH322Vq23XY1/87uscceGtvuarG3KNq8PvrooxoPHTpU43Xrau3XUtF23nlnjWfOnKnxqlWrNN59990zlscBz+iIKPHY0BFR4lVM13Xjxo0acxQ1HHfffbfGvXv3Lls9LrjgAo2ffPJJjd94441yVCdWbHeVXVcioghjQ0dEiVcxXddddtlF44MPPriMNakc06dP1zhT13XNmpqN2m2X0o7GZpswnJ7U2qNHj5LrSdml9qKOP57REVHisaEjosSrmK7rDjvsoPE+++yT8/mHH364xosXL9aYI7b5e+SRRzSeNGnSVo//73//07jQUbwmTZoAqL20lp10bNljz5vHPaMLYSdsb7/99mWsSWlyntGJyGgRWSMi75uyZiIyXUSWeL+bBltN8rRiLiKBeYiZfLquYwCcWKdsGIAZzrm2AGZ4f1Pw1oK5iALmIWZydl2dc7NFpFWd4j4AenrxWACzAFznY7189/nnn2s8ZswYjW+99daMz7fl33zzjcYPPvig31UrxAYAX9Upi2wutmzZovGKFSt8fe8TTjgBANC0ae4Tp+rqao03bdrkx+FjlQe/HHZYza6Cb731VhlrUrhir9FVOedWevEqAFXZnigigwEMLvI4lFteuWAeAsfvRISVPBjhnHPb2oTXOTcKwCggOpv13n777RpnO6OLo23lIop5KJRdQPOiiy4CADRq1Cjn626++ebA6pRJHL8T9uz722+/1diuarLvvvuGWic/FTu9ZLWItAAA7/eaHM+n4DAX0cA8RFixDd0UAAO8eACAydt4LgWLuYgG5iHCcnZdReQvSF1k3VVEqgHcAmA4gAkiMgjAcgB9g6xkkPK53ShCWgOYg4TmIq1fv34aDxtWM3i53377aWz3OMhk/vz5Gtv5ej5JXB7sgNtrr72msd32M87yGXU9L8tDx/pcF8rtY+fcYRnKmYtwMQ9c6VTeAAAG9UlEQVQxw1vAiCjxKuYWsGz82J+AMrNbTJ5//vkAgF69euV8Xbdu3TTOlRO774Pt5r700ksaf//99zmPScnGMzoiSjw2dESUeBXfdSV/HXjggRpPmTJF43xWjCmGHSEcNWpUIMeglObNm5e7CkXjGR0RJR4bOiJKPHZdKTB2v4FC9h4oZBK3ndB60kknaTx16tS8j0f5Oe2008pdhaLxjI6IEo8NHRElXsV3XfPpJnXv3l3jMi+8GXl2D4eePXtq3L9/fwDAtGnTtOyHH34o6L0HDRqk8RVXXFFkDSmXmTNnapyUe115RkdEiceGjogST8K8vzMqq6laP/74o8b5/Lfo2LEjAGDhwoWB1Wkb3smyakZBopiHfNjVbr/88sutHj/11FM1DnjU1Zc8ANHMxVlnnaXx3/72N43tPcMdOnTQuMxbgOaVC57REVHiVfxgxKOPPqrxxRdfnPP5gwen9jQZOnRoYHWizNI7f1Gw7P4Rlp0L2bBhw7Cq4wue0RFR4rGhI6LEq/iu6+LFi8tdhViyezYcf/zxGr/yyisa+7Hg5YUXXqjxyJEjS34/ym3y5Jp9fez3o3379hrbSzeXXnppOBUrQc4zOhHZW0RmishCEVkgIkO88mYiMl1Elni/c2+ZTqVqxzxEQn1+J+Iln67rFgBXO+c6AOgC4DIR6QBgGIAZzrm2AGZ4f1OwqpmHyOB3IkYKnkcnIpMBPOj99HTOrfQ27J3lnPtFjtdGbs6Q9eGHH2qcbVfy9C1jduu9ZcuWBVuxGjpnqBx5sHs53HjjjRofd9xxGrdu3VrjFStW5P3ezZo107h3794aP/DAAxrvtNNOW73Odo/t6hr2NqYA1Jq7leTvxJ///GeN7WWEqqoqjQu9lc9nec2jK+ganYi0AtAJwFwAVc65ld5DqwBUZXnNYACDCzkObRvzEB3MRTzkPeoqIo0BTAQw1Dm3zj7mUqeFGf9lcs6Ncs4d5tdM8krHPEQHcxEfeZ3RiUh9pBI6zjn3nFe8WkRamNP0NUFVMiwLFizQuE2bNhmfk2shyIAJypgHu3KL3RvC+t3vfqfx+vXr835v2/3t3LmzxtkurcyaNQsA8Mgjj2hZwN3VWirlO2HZXGzevLmMNSlcPqOuAuBJAIucc/eZh6YAGODFAwBMrvta8l1LMA9Rwe9EjORzRnc0gPMB/FdE5ntlNwAYDmCCiAwCsBxA32CqSEZzAMcwD2XXGPxOxErOhs459zpSXaZMjvW3OuVlt8uzK2FESLYRpsjk4ZJLLvH1/dasqen9vfDCCxoPGTIEQNlG/DY45yriO2E1adJE4z59+mj8/PPPl6M6BeEtYESUeGzoiCjxKv5eV8suprlo0SKN999//3JUJ3IGDhyosd2zYcCAARmenZudaP3dd99p/Nprr2lsLyfY/SgoHH371lxm3LRpk8b2+xEHPKMjosRjQ0dEiceuq2HXvj/ooIPKWJNomj9/vsZ2aZ5///vfGt9xxx0aN21as3jHpEmTAADTp0/XMrsc0KpVq/ytLPli9uzZGttLOH4swRUmntERUeJV/C5gMVPRu4BFSKJ3AYsZ7gJGRASwoSOiCsCGjogSjw0dESUeGzoiSjw2dESUeGzoiCjx2NARUeKFfQvYWgAbvd9JtiuC+YwtfXqftUitgBtUPaMkiM/oVx4AfidKlVcuQr0zAgBEZF7Sdz+Ky2eMSz1LEYfPGIc6lqrcn5FdVyJKPDZ0RJR45WjoRuV+SuzF5TPGpZ6liMNnjEMdS1XWzxj6NToiorCx60pEiceGjogSL9SGTkROFJEPRGSpiAwL89hBEZG9RWSmiCwUkQUiMsQrbyYi00Vkife7aa73CgvzEB3MRUicc6H8AKgHYBmANgAaAHgPQIewjh/g52oBoLMX7wTgQwAdANwDYJhXPgzAiHLXlXmITh6Yi3BzEeYZ3REAljrnPnLObQYwHkCfEI8fCOfcSufcu168HsAiAHsi9dnGek8bC+D08tRwK8xDdDAXIQmzodsTwArzd7VXlhgi0gpAJwBzAVQ551Z6D60CUFWmatXFPEQHcxESDkb4REQaA5gIYKhzbp19zKXO1TmPJwTMQ3REKRdhNnSfAdjb/L2XVxZ7IlIfqYSOc8495xWvFpEW3uMtAKwpV/3qYB6ig7kISZgN3dsA2opIaxFpAOBcAFNCPH4gREQAPAlgkXPuPvPQFAADvHgAgMl1X1smzEN0MBdh1ckbAQnnYCK9AfwZqdGm0c65O0M7eEBEpBuA1wD8F8BPXvENSF2TmABgH6SWROrrnPuqLJWsg3mIRh4A5iKsXPAWMCJKPA5GEFHisaEjosRjQ0dEiceGjogSjw0dESUeGzoiSjw2dESUeP8PgT8jcWwmkVIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "# 查看一些图片\n", + "def plot_images(imgs):\n", + " \"\"\"绘制几个样本图片\n", + " :param show: 是否显示绘图\n", + " :return:\n", + " \"\"\"\n", + " sample_num = min(9, len(imgs))\n", + " img_figure = plt.figure(1)\n", + " img_figure.set_figwidth(5)\n", + " img_figure.set_figheight(5)\n", + " for index in range(0, sample_num):\n", + " ax = plt.subplot(3, 3, index + 1)\n", + " ax.imshow(imgs[index].reshape(28, 28), cmap='gray')\n", + " ax.grid(False)\n", + " plt.margins(0, 0)\n", + " plt.show()\n", + "\n", + "\n", + "plot_images(X_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "对图像数据进行数据处理。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# 将数据集图像像素点的数据类型从 uint8 修改为 float32\n", + "X_train = X_train.astype('float32')\n", + "X_test = X_test.astype('float32')\n", + "\n", + "# 把数据集图像的像素值从 0-255 放缩到[-1,1]之间\n", + "X_train = (X_train - 127) / 127\n", + "X_test = (X_test - 127) / 127\n", + "\n", + "# 数据集类别个数\n", + "nb_classes = 10\n", + "\n", + "# 把 y_train 和 y_test 变成了 one-hot 的形式，即之前是 0-9 的一个数值， \n", + "# 现在是一个大小为 10 的向量，它属于哪个数字，就在哪个位置为 1，其他位置都是 0。\n", + "y_train = to_categorical(y_train, nb_classes)\n", + "y_test = to_categorical(y_test, nb_classes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. 搭建神经网络模型" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def create_model():\n", + " \"\"\"\n", + " 采用 keras 搭建神经网络模型\n", + " :return: 神经网络模型\n", + " \"\"\"\n", + " # 选择模型，选择序贯模型（Sequential())\n", + " model = Sequential()\n", + " # 添加全连接层，共 512 个神经元\n", + " model.add(Dense(512, input_shape=(784,)))\n", + " # 添加激活层，激活函数选择 relu \n", + " model.add(Activation('relu'))\n", + " # 添加全连接层，共 512 个神经元\n", + " model.add(Dense(512))\n", + " # 添加激活层，激活函数选择 relu \n", + " model.add(Activation('relu'))\n", + " # 添加全连接层，共 10 个神经元\n", + " model.add(Dense(10))\n", + " # 添加激活层，激活函数选择 softmax\n", + " model.add(Activation('softmax'))\n", + " return model\n", + "\n", + "# 实例化模型\n", + "model = create_model()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. 训练和测试神经网络模型" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/5\n", + "938/938 [==============================] - 42s 45ms/step - loss: 0.2597 - accuracy: 0.9200\n", + "Epoch 2/5\n", + "938/938 [==============================] - 41s 43ms/step - loss: 0.1255 - accuracy: 0.9614\n", + "Epoch 3/5\n", + "938/938 [==============================] - 42s 45ms/step - loss: 0.0952 - accuracy: 0.9702\n", + "Epoch 4/5\n", + "938/938 [==============================] - 41s 44ms/step - loss: 0.0805 - accuracy: 0.9748\n", + "Epoch 5/5\n", + "938/938 [==============================] - 41s 44ms/step - loss: 0.0691 - accuracy: 0.9777\n", + "313/313 [==============================] - 1s 2ms/step - loss: 0.0867 - accuracy: 0.9732\n", + "Test loss: 0.08665528893470764\n", + "Accuracy: 0.9732000231742859\n" + ] + } + ], + "source": [ + "def fit_and_predict(model, model_path):\n", + " \"\"\"\n", + " 训练模型、模型评估、保存模型\n", + " :param model: 搭建好的模型\n", + " :param model_path:保存模型路径\n", + " :return:\n", + " \"\"\"\n", + " # 编译模型\n", + " model.compile(optimizer='Adam',\n", + " loss='categorical_crossentropy', \n", + " metrics=['accuracy'])\n", + " # 模型训练\n", + " model.fit(X_train, y_train, epochs=5, batch_size=64)\n", + " # 保存模型\n", + " model.save(model_path)\n", + " # 模型评估，获取测试集的损失值和准确率\n", + " loss, accuracy = model.evaluate(X_test, y_test)\n", + " # 打印结果\n", + " print('Test loss:', loss)\n", + " print(\"Accuracy:\", accuracy)\n", + " \n", + "# 训练模型和评估模型\n", + "fit_and_predict(model, model_path='./model.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "那么，神经网络模型，是如何识别这一张张图片的呢？以下，我们使用通过下面几个小视频，你会更好的理解神经网络：" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "神经网络的整体模型" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "通过激活函数，神经元将每一层的“化学状态”传递到下一层。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "对于MNIST的图像分类，这里需要传递的信息就是图形信息：" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "图像信息在神经网络中的传递：" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "具体表述成函数的形式，一个第二层的神经元的值就应该是这样获得的：" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "全连接网络中的参数设置。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 实践与体验\n", + "#### 调节神经网络结构和参数\n", + "\n", + "1. 将两层隐藏层改为一层，训练模型并在测试集上测试，得出准确率。\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def create_model1():\n", + " \"\"\"\n", + " 搭建神经网络模型 model1，比 model 少一层隐藏层\n", + " :return: 模型 model1\n", + " \"\"\"\n", + " # 选择模型，选择序贯模型（Sequential())\n", + " model = \n", + " # 添加全连接层，共 512 个神经元\n", + " model.add()\n", + " # 添加激活层，激活函数选择 relu\n", + " model.add()\n", + " # 添加全连接层，共 10 个神经元\n", + " model.add()\n", + " # 添加激活层，激活函数选择 softmax\n", + " model.add()\n", + " return model\n", + "\n", + "# 搭建神经网络\n", + "model1 = create_model1()\n", + "# 训练神经网络模型，保存模型和评估模型\n", + "fit_and_predict(model1, model_path='./model1.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. 修改两层隐藏层神经元的数量，然后训练模型得出准确率。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def create_model2():\n", + " \"\"\"\n", + " 搭建神经网络模型 model2，隐藏层的神经元数目比 model 少一半\n", + " :return: 神经网络模型 model2\n", + " \"\"\"\n", + " # 选择模型，选择序贯模型（Sequential())\n", + " model = Sequential()\n", + " # 添加全连接层，共 256 个神经元\n", + " model.add()\n", + " # 添加激活层，激活函数选择 relu\n", + " model.add()\n", + " # 添加全连接层，共 256 个神经元\n", + " model.add()\n", + " # 添加激活层，激活函数选择 relu\n", + " model.add()\n", + " # 添加全连接层，共 10 个神经元\n", + " model.add()\n", + " # 添加激活层，激活函数选择 softmax\n", + " model.add()\n", + " return model\n", + "\n", + "# 搭建神经网络模型\n", + "model2 = create_model2()\n", + "# 训练神经网络模型，保存模型并评估模型\n", + "fit_and_predict(model2,model_path='./model2.h5')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. 输入一个手写数字，比较三种模型输出结果的差异，对其差异进行分析解释。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.set_printoptions(suppress=True)\n", + "from tensorflow.keras.models import load_model\n", + "\n", + "# 加载模型\n", + "model = load_model('./model.h5')\n", + "model1 = load_model('./model1.h5')\n", + "model2 = load_model('./model2.h5') " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原始模型\n", + "其各类别预测概率:[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]，预测值: 7，真实值:7\n", + "\n" + ] + } + ], + "source": [ + "# 预测结果\n", + "predict_results = np.round(model.predict(X_test)[0],3)\n", + "# predict_results1 = np.round(model1.predict(X_test)[0],3)\n", + "# predict_results2 = np.round(model2.predict(X_test)[0],3)\n", + "\n", + "# 打印预测结果\n", + "print('原始模型\\n其各类别预测概率:%s，预测值: %s，真实值:%s\\n' % (predict_results,np.argmax(predict_results),np.argmax(y_test[0])))\n", + "print('只有一个隐藏层的模型\\n其各类别各类别预测概率:%s，预测值: %s，真实值:%s\\n' % (predict_results1,np.argmax(predict_results1),np.argmax(y_test[0])))\n", + "print('隐藏神经元数量更改后的模型\\n其各类别预测概率:%s，预测值: %s，真实值:%s' % (predict_results2,np.argmax(predict_results2),np.argmax(y_test[0])))" + ] + } + ], + "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.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Pokemon.csv b/Pokemon.csv new file mode 100644 index 0000000..67617cf --- /dev/null +++ b/Pokemon.csv @@ -0,0 +1,801 @@ +Name,Type 1,Type 2,Total,HP,Attack,Defense,Sp. Atk,Sp. Def,Speed,Generation,Legendary +Bulbasaur,Grass,Poison,318,45,49,49,65,65,45,1,FALSE +Ivysaur,Grass,Poison,405,60,62,63,80,80,60,1,FALSE +Venusaur,Grass,Poison,525,80,82,83,100,100,80,1,FALSE +VenusaurMega Venusaur,Grass,Poison,625,80,100,123,122,120,80,1,FALSE +Charmander,Fire,,309,39,52,43,60,50,65,1,FALSE +Charmeleon,Fire,,405,58,64,58,80,65,80,1,FALSE +Charizard,Fire,Flying,534,78,84,78,109,85,100,1,FALSE +CharizardMega Charizard X,Fire,Dragon,634,78,130,111,130,85,100,1,FALSE +CharizardMega Charizard Y,Fire,Flying,634,78,104,78,159,115,100,1,FALSE +Squirtle,Water,,314,44,48,65,50,64,43,1,FALSE +Wartortle,Water,,405,59,63,80,65,80,58,1,FALSE +Blastoise,Water,,530,79,83,100,85,105,78,1,FALSE +BlastoiseMega Blastoise,Water,,630,79,103,120,135,115,78,1,FALSE +Caterpie,Bug,,195,45,30,35,20,20,45,1,FALSE +Metapod,Bug,,205,50,20,55,25,25,30,1,FALSE +Butterfree,Bug,Flying,395,60,45,50,90,80,70,1,FALSE +Weedle,Bug,Poison,195,40,35,30,20,20,50,1,FALSE +Kakuna,Bug,Poison,205,45,25,50,25,25,35,1,FALSE +Beedrill,Bug,Poison,395,65,90,40,45,80,75,1,FALSE +BeedrillMega Beedrill,Bug,Poison,495,65,150,40,15,80,145,1,FALSE +Pidgey,Normal,Flying,251,40,45,40,35,35,56,1,FALSE +Pidgeotto,Normal,Flying,349,63,60,55,50,50,71,1,FALSE +Pidgeot,Normal,Flying,479,83,80,75,70,70,101,1,FALSE +PidgeotMega Pidgeot,Normal,Flying,579,83,80,80,135,80,121,1,FALSE +Rattata,Normal,,253,30,56,35,25,35,72,1,FALSE +Raticate,Normal,,413,55,81,60,50,70,97,1,FALSE +Spearow,Normal,Flying,262,40,60,30,31,31,70,1,FALSE +Fearow,Normal,Flying,442,65,90,65,61,61,100,1,FALSE +Ekans,Poison,,288,35,60,44,40,54,55,1,FALSE +Arbok,Poison,,438,60,85,69,65,79,80,1,FALSE +Pikachu,Electric,,320,35,55,40,50,50,90,1,FALSE +Raichu,Electric,,485,60,90,55,90,80,110,1,FALSE +Sandshrew,Ground,,300,50,75,85,20,30,40,1,FALSE +Sandslash,Ground,,450,75,100,110,45,55,65,1,FALSE +Nidoran_,Poison,,275,55,47,52,40,40,41,1,FALSE +Nidorina,Poison,,365,70,62,67,55,55,56,1,FALSE +Nidoqueen,Poison,Ground,505,90,92,87,75,85,76,1,FALSE +Nidoran_,Poison,,273,46,57,40,40,40,50,1,FALSE +Nidorino,Poison,,365,61,72,57,55,55,65,1,FALSE +Nidoking,Poison,Ground,505,81,102,77,85,75,85,1,FALSE +Clefairy,Fairy,,323,70,45,48,60,65,35,1,FALSE +Clefable,Fairy,,483,95,70,73,95,90,60,1,FALSE +Vulpix,Fire,,299,38,41,40,50,65,65,1,FALSE +Ninetales,Fire,,505,73,76,75,81,100,100,1,FALSE +Jigglypuff,Normal,Fairy,270,115,45,20,45,25,20,1,FALSE +Wigglytuff,Normal,Fairy,435,140,70,45,85,50,45,1,FALSE +Zubat,Poison,Flying,245,40,45,35,30,40,55,1,FALSE +Golbat,Poison,Flying,455,75,80,70,65,75,90,1,FALSE +Oddish,Grass,Poison,320,45,50,55,75,65,30,1,FALSE +Gloom,Grass,Poison,395,60,65,70,85,75,40,1,FALSE +Vileplume,Grass,Poison,490,75,80,85,110,90,50,1,FALSE +Paras,Bug,Grass,285,35,70,55,45,55,25,1,FALSE +Parasect,Bug,Grass,405,60,95,80,60,80,30,1,FALSE +Venonat,Bug,Poison,305,60,55,50,40,55,45,1,FALSE +Venomoth,Bug,Poison,450,70,65,60,90,75,90,1,FALSE +Diglett,Ground,,265,10,55,25,35,45,95,1,FALSE +Dugtrio,Ground,,405,35,80,50,50,70,120,1,FALSE +Meowth,Normal,,290,40,45,35,40,40,90,1,FALSE +Persian,Normal,,440,65,70,60,65,65,115,1,FALSE +Psyduck,Water,,320,50,52,48,65,50,55,1,FALSE +Golduck,Water,,500,80,82,78,95,80,85,1,FALSE +Mankey,Fighting,,305,40,80,35,35,45,70,1,FALSE +Primeape,Fighting,,455,65,105,60,60,70,95,1,FALSE +Growlithe,Fire,,350,55,70,45,70,50,60,1,FALSE +Arcanine,Fire,,555,90,110,80,100,80,95,1,FALSE +Poliwag,Water,,300,40,50,40,40,40,90,1,FALSE +Poliwhirl,Water,,385,65,65,65,50,50,90,1,FALSE +Poliwrath,Water,Fighting,510,90,95,95,70,90,70,1,FALSE +Abra,Psychic,,310,25,20,15,105,55,90,1,FALSE +Kadabra,Psychic,,400,40,35,30,120,70,105,1,FALSE +Alakazam,Psychic,,500,55,50,45,135,95,120,1,FALSE +AlakazamMega Alakazam,Psychic,,590,55,50,65,175,95,150,1,FALSE +Machop,Fighting,,305,70,80,50,35,35,35,1,FALSE +Machoke,Fighting,,405,80,100,70,50,60,45,1,FALSE +Machamp,Fighting,,505,90,130,80,65,85,55,1,FALSE +Bellsprout,Grass,Poison,300,50,75,35,70,30,40,1,FALSE +Weepinbell,Grass,Poison,390,65,90,50,85,45,55,1,FALSE +Victreebel,Grass,Poison,490,80,105,65,100,70,70,1,FALSE +Tentacool,Water,Poison,335,40,40,35,50,100,70,1,FALSE +Tentacruel,Water,Poison,515,80,70,65,80,120,100,1,FALSE +Geodude,Rock,Ground,300,40,80,100,30,30,20,1,FALSE +Graveler,Rock,Ground,390,55,95,115,45,45,35,1,FALSE +Golem,Rock,Ground,495,80,120,130,55,65,45,1,FALSE +Ponyta,Fire,,410,50,85,55,65,65,90,1,FALSE +Rapidash,Fire,,500,65,100,70,80,80,105,1,FALSE +Slowpoke,Water,Psychic,315,90,65,65,40,40,15,1,FALSE +Slowbro,Water,Psychic,490,95,75,110,100,80,30,1,FALSE +SlowbroMega Slowbro,Water,Psychic,590,95,75,180,130,80,30,1,FALSE +Magnemite,Electric,Steel,325,25,35,70,95,55,45,1,FALSE +Magneton,Electric,Steel,465,50,60,95,120,70,70,1,FALSE +Farfetch'd,Normal,Flying,352,52,65,55,58,62,60,1,FALSE +Doduo,Normal,Flying,310,35,85,45,35,35,75,1,FALSE +Dodrio,Normal,Flying,460,60,110,70,60,60,100,1,FALSE +Seel,Water,,325,65,45,55,45,70,45,1,FALSE +Dewgong,Water,Ice,475,90,70,80,70,95,70,1,FALSE +Grimer,Poison,,325,80,80,50,40,50,25,1,FALSE +Muk,Poison,,500,105,105,75,65,100,50,1,FALSE +Shellder,Water,,305,30,65,100,45,25,40,1,FALSE +Cloyster,Water,Ice,525,50,95,180,85,45,70,1,FALSE +Gastly,Ghost,Poison,310,30,35,30,100,35,80,1,FALSE +Haunter,Ghost,Poison,405,45,50,45,115,55,95,1,FALSE +Gengar,Ghost,Poison,500,60,65,60,130,75,110,1,FALSE +GengarMega Gengar,Ghost,Poison,600,60,65,80,170,95,130,1,FALSE +Onix,Rock,Ground,385,35,45,160,30,45,70,1,FALSE +Drowzee,Psychic,,328,60,48,45,43,90,42,1,FALSE +Hypno,Psychic,,483,85,73,70,73,115,67,1,FALSE +Krabby,Water,,325,30,105,90,25,25,50,1,FALSE +Kingler,Water,,475,55,130,115,50,50,75,1,FALSE +Voltorb,Electric,,330,40,30,50,55,55,100,1,FALSE +Electrode,Electric,,480,60,50,70,80,80,140,1,FALSE +Exeggcute,Grass,Psychic,325,60,40,80,60,45,40,1,FALSE +Exeggutor,Grass,Psychic,520,95,95,85,125,65,55,1,FALSE +Cubone,Ground,,320,50,50,95,40,50,35,1,FALSE +Marowak,Ground,,425,60,80,110,50,80,45,1,FALSE +Hitmonlee,Fighting,,455,50,120,53,35,110,87,1,FALSE +Hitmonchan,Fighting,,455,50,105,79,35,110,76,1,FALSE +Lickitung,Normal,,385,90,55,75,60,75,30,1,FALSE +Koffing,Poison,,340,40,65,95,60,45,35,1,FALSE +Weezing,Poison,,490,65,90,120,85,70,60,1,FALSE +Rhyhorn,Ground,Rock,345,80,85,95,30,30,25,1,FALSE +Rhydon,Ground,Rock,485,105,130,120,45,45,40,1,FALSE +Chansey,Normal,,450,250,5,5,35,105,50,1,FALSE +Tangela,Grass,,435,65,55,115,100,40,60,1,FALSE +Kangaskhan,Normal,,490,105,95,80,40,80,90,1,FALSE +KangaskhanMega Kangaskhan,Normal,,590,105,125,100,60,100,100,1,FALSE +Horsea,Water,,295,30,40,70,70,25,60,1,FALSE +Seadra,Water,,440,55,65,95,95,45,85,1,FALSE +Goldeen,Water,,320,45,67,60,35,50,63,1,FALSE +Seaking,Water,,450,80,92,65,65,80,68,1,FALSE +Staryu,Water,,340,30,45,55,70,55,85,1,FALSE +Starmie,Water,Psychic,520,60,75,85,100,85,115,1,FALSE +Mr. Mime,Psychic,Fairy,460,40,45,65,100,120,90,1,FALSE +Scyther,Bug,Flying,500,70,110,80,55,80,105,1,FALSE +Jynx,Ice,Psychic,455,65,50,35,115,95,95,1,FALSE +Electabuzz,Electric,,490,65,83,57,95,85,105,1,FALSE +Magmar,Fire,,495,65,95,57,100,85,93,1,FALSE +Pinsir,Bug,,500,65,125,100,55,70,85,1,FALSE +PinsirMega Pinsir,Bug,Flying,600,65,155,120,65,90,105,1,FALSE +Tauros,Normal,,490,75,100,95,40,70,110,1,FALSE +Magikarp,Water,,200,20,10,55,15,20,80,1,FALSE +Gyarados,Water,Flying,540,95,125,79,60,100,81,1,FALSE +GyaradosMega Gyarados,Water,Dark,640,95,155,109,70,130,81,1,FALSE +Lapras,Water,Ice,535,130,85,80,85,95,60,1,FALSE +Ditto,Normal,,288,48,48,48,48,48,48,1,FALSE +Eevee,Normal,,325,55,55,50,45,65,55,1,FALSE +Vaporeon,Water,,525,130,65,60,110,95,65,1,FALSE +Jolteon,Electric,,525,65,65,60,110,95,130,1,FALSE +Flareon,Fire,,525,65,130,60,95,110,65,1,FALSE +Porygon,Normal,,395,65,60,70,85,75,40,1,FALSE +Omanyte,Rock,Water,355,35,40,100,90,55,35,1,FALSE +Omastar,Rock,Water,495,70,60,125,115,70,55,1,FALSE +Kabuto,Rock,Water,355,30,80,90,55,45,55,1,FALSE +Kabutops,Rock,Water,495,60,115,105,65,70,80,1,FALSE +Aerodactyl,Rock,Flying,515,80,105,65,60,75,130,1,FALSE +AerodactylMega Aerodactyl,Rock,Flying,615,80,135,85,70,95,150,1,FALSE +Snorlax,Normal,,540,160,110,65,65,110,30,1,FALSE +Articuno,Ice,Flying,580,90,85,100,95,125,85,1,TRUE +Zapdos,Electric,Flying,580,90,90,85,125,90,100,1,TRUE +Moltres,Fire,Flying,580,90,100,90,125,85,90,1,TRUE +Dratini,Dragon,,300,41,64,45,50,50,50,1,FALSE +Dragonair,Dragon,,420,61,84,65,70,70,70,1,FALSE +Dragonite,Dragon,Flying,600,91,134,95,100,100,80,1,FALSE +Mewtwo,Psychic,,680,106,110,90,154,90,130,1,TRUE +MewtwoMega Mewtwo X,Psychic,Fighting,780,106,190,100,154,100,130,1,TRUE +MewtwoMega Mewtwo Y,Psychic,,780,106,150,70,194,120,140,1,TRUE +Mew,Psychic,,600,100,100,100,100,100,100,1,FALSE +Chikorita,Grass,,318,45,49,65,49,65,45,2,FALSE +Bayleef,Grass,,405,60,62,80,63,80,60,2,FALSE +Meganium,Grass,,525,80,82,100,83,100,80,2,FALSE +Cyndaquil,Fire,,309,39,52,43,60,50,65,2,FALSE +Quilava,Fire,,405,58,64,58,80,65,80,2,FALSE +Typhlosion,Fire,,534,78,84,78,109,85,100,2,FALSE +Totodile,Water,,314,50,65,64,44,48,43,2,FALSE +Croconaw,Water,,405,65,80,80,59,63,58,2,FALSE +Feraligatr,Water,,530,85,105,100,79,83,78,2,FALSE +Sentret,Normal,,215,35,46,34,35,45,20,2,FALSE +Furret,Normal,,415,85,76,64,45,55,90,2,FALSE +Hoothoot,Normal,Flying,262,60,30,30,36,56,50,2,FALSE +Noctowl,Normal,Flying,442,100,50,50,76,96,70,2,FALSE +Ledyba,Bug,Flying,265,40,20,30,40,80,55,2,FALSE +Ledian,Bug,Flying,390,55,35,50,55,110,85,2,FALSE +Spinarak,Bug,Poison,250,40,60,40,40,40,30,2,FALSE +Ariados,Bug,Poison,390,70,90,70,60,60,40,2,FALSE +Crobat,Poison,Flying,535,85,90,80,70,80,130,2,FALSE +Chinchou,Water,Electric,330,75,38,38,56,56,67,2,FALSE +Lanturn,Water,Electric,460,125,58,58,76,76,67,2,FALSE +Pichu,Electric,,205,20,40,15,35,35,60,2,FALSE +Cleffa,Fairy,,218,50,25,28,45,55,15,2,FALSE +Igglybuff,Normal,Fairy,210,90,30,15,40,20,15,2,FALSE +Togepi,Fairy,,245,35,20,65,40,65,20,2,FALSE +Togetic,Fairy,Flying,405,55,40,85,80,105,40,2,FALSE +Natu,Psychic,Flying,320,40,50,45,70,45,70,2,FALSE +Xatu,Psychic,Flying,470,65,75,70,95,70,95,2,FALSE +Mareep,Electric,,280,55,40,40,65,45,35,2,FALSE +Flaaffy,Electric,,365,70,55,55,80,60,45,2,FALSE +Ampharos,Electric,,510,90,75,85,115,90,55,2,FALSE +AmpharosMega Ampharos,Electric,Dragon,610,90,95,105,165,110,45,2,FALSE +Bellossom,Grass,,490,75,80,95,90,100,50,2,FALSE +Marill,Water,Fairy,250,70,20,50,20,50,40,2,FALSE +Azumarill,Water,Fairy,420,100,50,80,60,80,50,2,FALSE +Sudowoodo,Rock,,410,70,100,115,30,65,30,2,FALSE +Politoed,Water,,500,90,75,75,90,100,70,2,FALSE +Hoppip,Grass,Flying,250,35,35,40,35,55,50,2,FALSE +Skiploom,Grass,Flying,340,55,45,50,45,65,80,2,FALSE +Jumpluff,Grass,Flying,460,75,55,70,55,95,110,2,FALSE +Aipom,Normal,,360,55,70,55,40,55,85,2,FALSE +Sunkern,Grass,,180,30,30,30,30,30,30,2,FALSE +Sunflora,Grass,,425,75,75,55,105,85,30,2,FALSE +Yanma,Bug,Flying,390,65,65,45,75,45,95,2,FALSE +Wooper,Water,Ground,210,55,45,45,25,25,15,2,FALSE +Quagsire,Water,Ground,430,95,85,85,65,65,35,2,FALSE +Espeon,Psychic,,525,65,65,60,130,95,110,2,FALSE +Umbreon,Dark,,525,95,65,110,60,130,65,2,FALSE +Murkrow,Dark,Flying,405,60,85,42,85,42,91,2,FALSE +Slowking,Water,Psychic,490,95,75,80,100,110,30,2,FALSE +Misdreavus,Ghost,,435,60,60,60,85,85,85,2,FALSE +Unown,Psychic,,336,48,72,48,72,48,48,2,FALSE +Wobbuffet,Psychic,,405,190,33,58,33,58,33,2,FALSE +Girafarig,Normal,Psychic,455,70,80,65,90,65,85,2,FALSE +Pineco,Bug,,290,50,65,90,35,35,15,2,FALSE +Forretress,Bug,Steel,465,75,90,140,60,60,40,2,FALSE +Dunsparce,Normal,,415,100,70,70,65,65,45,2,FALSE +Gligar,Ground,Flying,430,65,75,105,35,65,85,2,FALSE +Steelix,Steel,Ground,510,75,85,200,55,65,30,2,FALSE +SteelixMega Steelix,Steel,Ground,610,75,125,230,55,95,30,2,FALSE +Snubbull,Fairy,,300,60,80,50,40,40,30,2,FALSE +Granbull,Fairy,,450,90,120,75,60,60,45,2,FALSE +Qwilfish,Water,Poison,430,65,95,75,55,55,85,2,FALSE +Scizor,Bug,Steel,500,70,130,100,55,80,65,2,FALSE +ScizorMega Scizor,Bug,Steel,600,70,150,140,65,100,75,2,FALSE +Shuckle,Bug,Rock,505,20,10,230,10,230,5,2,FALSE +Heracross,Bug,Fighting,500,80,125,75,40,95,85,2,FALSE +HeracrossMega Heracross,Bug,Fighting,600,80,185,115,40,105,75,2,FALSE +Sneasel,Dark,Ice,430,55,95,55,35,75,115,2,FALSE +Teddiursa,Normal,,330,60,80,50,50,50,40,2,FALSE +Ursaring,Normal,,500,90,130,75,75,75,55,2,FALSE +Slugma,Fire,,250,40,40,40,70,40,20,2,FALSE +Magcargo,Fire,Rock,410,50,50,120,80,80,30,2,FALSE +Swinub,Ice,Ground,250,50,50,40,30,30,50,2,FALSE +Piloswine,Ice,Ground,450,100,100,80,60,60,50,2,FALSE +Corsola,Water,Rock,380,55,55,85,65,85,35,2,FALSE +Remoraid,Water,,300,35,65,35,65,35,65,2,FALSE +Octillery,Water,,480,75,105,75,105,75,45,2,FALSE +Delibird,Ice,Flying,330,45,55,45,65,45,75,2,FALSE +Mantine,Water,Flying,465,65,40,70,80,140,70,2,FALSE +Skarmory,Steel,Flying,465,65,80,140,40,70,70,2,FALSE +Houndour,Dark,Fire,330,45,60,30,80,50,65,2,FALSE +Houndoom,Dark,Fire,500,75,90,50,110,80,95,2,FALSE +HoundoomMega Houndoom,Dark,Fire,600,75,90,90,140,90,115,2,FALSE +Kingdra,Water,Dragon,540,75,95,95,95,95,85,2,FALSE +Phanpy,Ground,,330,90,60,60,40,40,40,2,FALSE +Donphan,Ground,,500,90,120,120,60,60,50,2,FALSE +Porygon2,Normal,,515,85,80,90,105,95,60,2,FALSE +Stantler,Normal,,465,73,95,62,85,65,85,2,FALSE +Smeargle,Normal,,250,55,20,35,20,45,75,2,FALSE +Tyrogue,Fighting,,210,35,35,35,35,35,35,2,FALSE +Hitmontop,Fighting,,455,50,95,95,35,110,70,2,FALSE +Smoochum,Ice,Psychic,305,45,30,15,85,65,65,2,FALSE +Elekid,Electric,,360,45,63,37,65,55,95,2,FALSE +Magby,Fire,,365,45,75,37,70,55,83,2,FALSE +Miltank,Normal,,490,95,80,105,40,70,100,2,FALSE +Blissey,Normal,,540,255,10,10,75,135,55,2,FALSE +Raikou,Electric,,580,90,85,75,115,100,115,2,TRUE +Entei,Fire,,580,115,115,85,90,75,100,2,TRUE +Suicune,Water,,580,100,75,115,90,115,85,2,TRUE +Larvitar,Rock,Ground,300,50,64,50,45,50,41,2,FALSE +Pupitar,Rock,Ground,410,70,84,70,65,70,51,2,FALSE +Tyranitar,Rock,Dark,600,100,134,110,95,100,61,2,FALSE +TyranitarMega Tyranitar,Rock,Dark,700,100,164,150,95,120,71,2,FALSE +Lugia,Psychic,Flying,680,106,90,130,90,154,110,2,TRUE +Ho-oh,Fire,Flying,680,106,130,90,110,154,90,2,TRUE +Celebi,Psychic,Grass,600,100,100,100,100,100,100,2,FALSE +Treecko,Grass,,310,40,45,35,65,55,70,3,FALSE +Grovyle,Grass,,405,50,65,45,85,65,95,3,FALSE +Sceptile,Grass,,530,70,85,65,105,85,120,3,FALSE +SceptileMega Sceptile,Grass,Dragon,630,70,110,75,145,85,145,3,FALSE +Torchic,Fire,,310,45,60,40,70,50,45,3,FALSE +Combusken,Fire,Fighting,405,60,85,60,85,60,55,3,FALSE +Blaziken,Fire,Fighting,530,80,120,70,110,70,80,3,FALSE +BlazikenMega Blaziken,Fire,Fighting,630,80,160,80,130,80,100,3,FALSE +Mudkip,Water,,310,50,70,50,50,50,40,3,FALSE +Marshtomp,Water,Ground,405,70,85,70,60,70,50,3,FALSE +Swampert,Water,Ground,535,100,110,90,85,90,60,3,FALSE +SwampertMega Swampert,Water,Ground,635,100,150,110,95,110,70,3,FALSE +Poochyena,Dark,,220,35,55,35,30,30,35,3,FALSE +Mightyena,Dark,,420,70,90,70,60,60,70,3,FALSE +Zigzagoon,Normal,,240,38,30,41,30,41,60,3,FALSE +Linoone,Normal,,420,78,70,61,50,61,100,3,FALSE +Wurmple,Bug,,195,45,45,35,20,30,20,3,FALSE +Silcoon,Bug,,205,50,35,55,25,25,15,3,FALSE +Beautifly,Bug,Flying,395,60,70,50,100,50,65,3,FALSE +Cascoon,Bug,,205,50,35,55,25,25,15,3,FALSE +Dustox,Bug,Poison,385,60,50,70,50,90,65,3,FALSE +Lotad,Water,Grass,220,40,30,30,40,50,30,3,FALSE +Lombre,Water,Grass,340,60,50,50,60,70,50,3,FALSE +Ludicolo,Water,Grass,480,80,70,70,90,100,70,3,FALSE +Seedot,Grass,,220,40,40,50,30,30,30,3,FALSE +Nuzleaf,Grass,Dark,340,70,70,40,60,40,60,3,FALSE +Shiftry,Grass,Dark,480,90,100,60,90,60,80,3,FALSE +Taillow,Normal,Flying,270,40,55,30,30,30,85,3,FALSE +Swellow,Normal,Flying,430,60,85,60,50,50,125,3,FALSE +Wingull,Water,Flying,270,40,30,30,55,30,85,3,FALSE +Pelipper,Water,Flying,430,60,50,100,85,70,65,3,FALSE +Ralts,Psychic,Fairy,198,28,25,25,45,35,40,3,FALSE +Kirlia,Psychic,Fairy,278,38,35,35,65,55,50,3,FALSE +Gardevoir,Psychic,Fairy,518,68,65,65,125,115,80,3,FALSE +GardevoirMega Gardevoir,Psychic,Fairy,618,68,85,65,165,135,100,3,FALSE +Surskit,Bug,Water,269,40,30,32,50,52,65,3,FALSE +Masquerain,Bug,Flying,414,70,60,62,80,82,60,3,FALSE +Shroomish,Grass,,295,60,40,60,40,60,35,3,FALSE +Breloom,Grass,Fighting,460,60,130,80,60,60,70,3,FALSE +Slakoth,Normal,,280,60,60,60,35,35,30,3,FALSE +Vigoroth,Normal,,440,80,80,80,55,55,90,3,FALSE +Slaking,Normal,,670,150,160,100,95,65,100,3,FALSE +Nincada,Bug,Ground,266,31,45,90,30,30,40,3,FALSE +Ninjask,Bug,Flying,456,61,90,45,50,50,160,3,FALSE +Shedinja,Bug,Ghost,236,1,90,45,30,30,40,3,FALSE +Whismur,Normal,,240,64,51,23,51,23,28,3,FALSE +Loudred,Normal,,360,84,71,43,71,43,48,3,FALSE +Exploud,Normal,,490,104,91,63,91,73,68,3,FALSE +Makuhita,Fighting,,237,72,60,30,20,30,25,3,FALSE +Hariyama,Fighting,,474,144,120,60,40,60,50,3,FALSE +Azurill,Normal,Fairy,190,50,20,40,20,40,20,3,FALSE +Nosepass,Rock,,375,30,45,135,45,90,30,3,FALSE +Skitty,Normal,,260,50,45,45,35,35,50,3,FALSE +Delcatty,Normal,,380,70,65,65,55,55,70,3,FALSE +Sableye,Dark,Ghost,380,50,75,75,65,65,50,3,FALSE +SableyeMega Sableye,Dark,Ghost,480,50,85,125,85,115,20,3,FALSE +Mawile,Steel,Fairy,380,50,85,85,55,55,50,3,FALSE +MawileMega Mawile,Steel,Fairy,480,50,105,125,55,95,50,3,FALSE +Aron,Steel,Rock,330,50,70,100,40,40,30,3,FALSE +Lairon,Steel,Rock,430,60,90,140,50,50,40,3,FALSE +Aggron,Steel,Rock,530,70,110,180,60,60,50,3,FALSE +AggronMega Aggron,Steel,,630,70,140,230,60,80,50,3,FALSE +Meditite,Fighting,Psychic,280,30,40,55,40,55,60,3,FALSE +Medicham,Fighting,Psychic,410,60,60,75,60,75,80,3,FALSE +MedichamMega Medicham,Fighting,Psychic,510,60,100,85,80,85,100,3,FALSE +Electrike,Electric,,295,40,45,40,65,40,65,3,FALSE +Manectric,Electric,,475,70,75,60,105,60,105,3,FALSE +ManectricMega Manectric,Electric,,575,70,75,80,135,80,135,3,FALSE +Plusle,Electric,,405,60,50,40,85,75,95,3,FALSE +Minun,Electric,,405,60,40,50,75,85,95,3,FALSE +Volbeat,Bug,,400,65,73,55,47,75,85,3,FALSE +Illumise,Bug,,400,65,47,55,73,75,85,3,FALSE +Roselia,Grass,Poison,400,50,60,45,100,80,65,3,FALSE +Gulpin,Poison,,302,70,43,53,43,53,40,3,FALSE +Swalot,Poison,,467,100,73,83,73,83,55,3,FALSE +Carvanha,Water,Dark,305,45,90,20,65,20,65,3,FALSE +Sharpedo,Water,Dark,460,70,120,40,95,40,95,3,FALSE +SharpedoMega Sharpedo,Water,Dark,560,70,140,70,110,65,105,3,FALSE +Wailmer,Water,,400,130,70,35,70,35,60,3,FALSE +Wailord,Water,,500,170,90,45,90,45,60,3,FALSE +Numel,Fire,Ground,305,60,60,40,65,45,35,3,FALSE +Camerupt,Fire,Ground,460,70,100,70,105,75,40,3,FALSE +CameruptMega Camerupt,Fire,Ground,560,70,120,100,145,105,20,3,FALSE +Torkoal,Fire,,470,70,85,140,85,70,20,3,FALSE +Spoink,Psychic,,330,60,25,35,70,80,60,3,FALSE +Grumpig,Psychic,,470,80,45,65,90,110,80,3,FALSE +Spinda,Normal,,360,60,60,60,60,60,60,3,FALSE +Trapinch,Ground,,290,45,100,45,45,45,10,3,FALSE +Vibrava,Ground,Dragon,340,50,70,50,50,50,70,3,FALSE +Flygon,Ground,Dragon,520,80,100,80,80,80,100,3,FALSE +Cacnea,Grass,,335,50,85,40,85,40,35,3,FALSE +Cacturne,Grass,Dark,475,70,115,60,115,60,55,3,FALSE +Swablu,Normal,Flying,310,45,40,60,40,75,50,3,FALSE +Altaria,Dragon,Flying,490,75,70,90,70,105,80,3,FALSE +AltariaMega Altaria,Dragon,Fairy,590,75,110,110,110,105,80,3,FALSE +Zangoose,Normal,,458,73,115,60,60,60,90,3,FALSE +Seviper,Poison,,458,73,100,60,100,60,65,3,FALSE +Lunatone,Rock,Psychic,440,70,55,65,95,85,70,3,FALSE +Solrock,Rock,Psychic,440,70,95,85,55,65,70,3,FALSE +Barboach,Water,Ground,288,50,48,43,46,41,60,3,FALSE +Whiscash,Water,Ground,468,110,78,73,76,71,60,3,FALSE +Corphish,Water,,308,43,80,65,50,35,35,3,FALSE +Crawdaunt,Water,Dark,468,63,120,85,90,55,55,3,FALSE +Baltoy,Ground,Psychic,300,40,40,55,40,70,55,3,FALSE +Claydol,Ground,Psychic,500,60,70,105,70,120,75,3,FALSE +Lileep,Rock,Grass,355,66,41,77,61,87,23,3,FALSE +Cradily,Rock,Grass,495,86,81,97,81,107,43,3,FALSE +Anorith,Rock,Bug,355,45,95,50,40,50,75,3,FALSE +Armaldo,Rock,Bug,495,75,125,100,70,80,45,3,FALSE +Feebas,Water,,200,20,15,20,10,55,80,3,FALSE +Milotic,Water,,540,95,60,79,100,125,81,3,FALSE +Castform,Normal,,420,70,70,70,70,70,70,3,FALSE +Kecleon,Normal,,440,60,90,70,60,120,40,3,FALSE +Shuppet,Ghost,,295,44,75,35,63,33,45,3,FALSE +Banette,Ghost,,455,64,115,65,83,63,65,3,FALSE +BanetteMega Banette,Ghost,,555,64,165,75,93,83,75,3,FALSE +Duskull,Ghost,,295,20,40,90,30,90,25,3,FALSE +Dusclops,Ghost,,455,40,70,130,60,130,25,3,FALSE +Tropius,Grass,Flying,460,99,68,83,72,87,51,3,FALSE +Chimecho,Psychic,,425,65,50,70,95,80,65,3,FALSE +Absol,Dark,,465,65,130,60,75,60,75,3,FALSE +AbsolMega Absol,Dark,,565,65,150,60,115,60,115,3,FALSE +Wynaut,Psychic,,260,95,23,48,23,48,23,3,FALSE +Snorunt,Ice,,300,50,50,50,50,50,50,3,FALSE +Glalie,Ice,,480,80,80,80,80,80,80,3,FALSE +GlalieMega Glalie,Ice,,580,80,120,80,120,80,100,3,FALSE +Spheal,Ice,Water,290,70,40,50,55,50,25,3,FALSE +Sealeo,Ice,Water,410,90,60,70,75,70,45,3,FALSE +Walrein,Ice,Water,530,110,80,90,95,90,65,3,FALSE +Clamperl,Water,,345,35,64,85,74,55,32,3,FALSE +Huntail,Water,,485,55,104,105,94,75,52,3,FALSE +Gorebyss,Water,,485,55,84,105,114,75,52,3,FALSE +Relicanth,Water,Rock,485,100,90,130,45,65,55,3,FALSE +Luvdisc,Water,,330,43,30,55,40,65,97,3,FALSE +Bagon,Dragon,,300,45,75,60,40,30,50,3,FALSE +Shelgon,Dragon,,420,65,95,100,60,50,50,3,FALSE +Salamence,Dragon,Flying,600,95,135,80,110,80,100,3,FALSE +SalamenceMega Salamence,Dragon,Flying,700,95,145,130,120,90,120,3,FALSE +Beldum,Steel,Psychic,300,40,55,80,35,60,30,3,FALSE +Metang,Steel,Psychic,420,60,75,100,55,80,50,3,FALSE +Metagross,Steel,Psychic,600,80,135,130,95,90,70,3,FALSE +MetagrossMega Metagross,Steel,Psychic,700,80,145,150,105,110,110,3,FALSE +Regirock,Rock,,580,80,100,200,50,100,50,3,TRUE +Regice,Ice,,580,80,50,100,100,200,50,3,TRUE +Registeel,Steel,,580,80,75,150,75,150,50,3,TRUE +Latias,Dragon,Psychic,600,80,80,90,110,130,110,3,TRUE +LatiasMega Latias,Dragon,Psychic,700,80,100,120,140,150,110,3,TRUE +Latios,Dragon,Psychic,600,80,90,80,130,110,110,3,TRUE +LatiosMega Latios,Dragon,Psychic,700,80,130,100,160,120,110,3,TRUE +Kyogre,Water,,670,100,100,90,150,140,90,3,TRUE +KyogrePrimal Kyogre,Water,,770,100,150,90,180,160,90,3,TRUE +Groudon,Ground,,670,100,150,140,100,90,90,3,TRUE +GroudonPrimal Groudon,Ground,Fire,770,100,180,160,150,90,90,3,TRUE +Rayquaza,Dragon,Flying,680,105,150,90,150,90,95,3,TRUE +RayquazaMega Rayquaza,Dragon,Flying,780,105,180,100,180,100,115,3,TRUE +Jirachi,Steel,Psychic,600,100,100,100,100,100,100,3,TRUE +DeoxysNormal Forme,Psychic,,600,50,150,50,150,50,150,3,TRUE +DeoxysAttack Forme,Psychic,,600,50,180,20,180,20,150,3,TRUE +DeoxysDefense Forme,Psychic,,600,50,70,160,70,160,90,3,TRUE +DeoxysSpeed Forme,Psychic,,600,50,95,90,95,90,180,3,TRUE +Turtwig,Grass,,318,55,68,64,45,55,31,4,FALSE +Grotle,Grass,,405,75,89,85,55,65,36,4,FALSE +Torterra,Grass,Ground,525,95,109,105,75,85,56,4,FALSE +Chimchar,Fire,,309,44,58,44,58,44,61,4,FALSE +Monferno,Fire,Fighting,405,64,78,52,78,52,81,4,FALSE +Infernape,Fire,Fighting,534,76,104,71,104,71,108,4,FALSE +Piplup,Water,,314,53,51,53,61,56,40,4,FALSE +Prinplup,Water,,405,64,66,68,81,76,50,4,FALSE +Empoleon,Water,Steel,530,84,86,88,111,101,60,4,FALSE +Starly,Normal,Flying,245,40,55,30,30,30,60,4,FALSE +Staravia,Normal,Flying,340,55,75,50,40,40,80,4,FALSE +Staraptor,Normal,Flying,485,85,120,70,50,60,100,4,FALSE +Bidoof,Normal,,250,59,45,40,35,40,31,4,FALSE +Bibarel,Normal,Water,410,79,85,60,55,60,71,4,FALSE +Kricketot,Bug,,194,37,25,41,25,41,25,4,FALSE +Kricketune,Bug,,384,77,85,51,55,51,65,4,FALSE +Shinx,Electric,,263,45,65,34,40,34,45,4,FALSE +Luxio,Electric,,363,60,85,49,60,49,60,4,FALSE +Luxray,Electric,,523,80,120,79,95,79,70,4,FALSE +Budew,Grass,Poison,280,40,30,35,50,70,55,4,FALSE +Roserade,Grass,Poison,515,60,70,65,125,105,90,4,FALSE +Cranidos,Rock,,350,67,125,40,30,30,58,4,FALSE +Rampardos,Rock,,495,97,165,60,65,50,58,4,FALSE +Shieldon,Rock,Steel,350,30,42,118,42,88,30,4,FALSE +Bastiodon,Rock,Steel,495,60,52,168,47,138,30,4,FALSE +Burmy,Bug,,224,40,29,45,29,45,36,4,FALSE +WormadamPlant Cloak,Bug,Grass,424,60,59,85,79,105,36,4,FALSE +WormadamSandy Cloak,Bug,Ground,424,60,79,105,59,85,36,4,FALSE +WormadamTrash Cloak,Bug,Steel,424,60,69,95,69,95,36,4,FALSE +Mothim,Bug,Flying,424,70,94,50,94,50,66,4,FALSE +Combee,Bug,Flying,244,30,30,42,30,42,70,4,FALSE +Vespiquen,Bug,Flying,474,70,80,102,80,102,40,4,FALSE +Pachirisu,Electric,,405,60,45,70,45,90,95,4,FALSE +Buizel,Water,,330,55,65,35,60,30,85,4,FALSE +Floatzel,Water,,495,85,105,55,85,50,115,4,FALSE +Cherubi,Grass,,275,45,35,45,62,53,35,4,FALSE +Cherrim,Grass,,450,70,60,70,87,78,85,4,FALSE +Shellos,Water,,325,76,48,48,57,62,34,4,FALSE +Gastrodon,Water,Ground,475,111,83,68,92,82,39,4,FALSE +Ambipom,Normal,,482,75,100,66,60,66,115,4,FALSE +Drifloon,Ghost,Flying,348,90,50,34,60,44,70,4,FALSE +Drifblim,Ghost,Flying,498,150,80,44,90,54,80,4,FALSE +Buneary,Normal,,350,55,66,44,44,56,85,4,FALSE +Lopunny,Normal,,480,65,76,84,54,96,105,4,FALSE +LopunnyMega Lopunny,Normal,Fighting,580,65,136,94,54,96,135,4,FALSE +Mismagius,Ghost,,495,60,60,60,105,105,105,4,FALSE +Honchkrow,Dark,Flying,505,100,125,52,105,52,71,4,FALSE +Glameow,Normal,,310,49,55,42,42,37,85,4,FALSE +Purugly,Normal,,452,71,82,64,64,59,112,4,FALSE +Chingling,Psychic,,285,45,30,50,65,50,45,4,FALSE +Stunky,Poison,Dark,329,63,63,47,41,41,74,4,FALSE +Skuntank,Poison,Dark,479,103,93,67,71,61,84,4,FALSE +Bronzor,Steel,Psychic,300,57,24,86,24,86,23,4,FALSE +Bronzong,Steel,Psychic,500,67,89,116,79,116,33,4,FALSE +Bonsly,Rock,,290,50,80,95,10,45,10,4,FALSE +Mime Jr.,Psychic,Fairy,310,20,25,45,70,90,60,4,FALSE +Happiny,Normal,,220,100,5,5,15,65,30,4,FALSE +Chatot,Normal,Flying,411,76,65,45,92,42,91,4,FALSE +Spiritomb,Ghost,Dark,485,50,92,108,92,108,35,4,FALSE +Gible,Dragon,Ground,300,58,70,45,40,45,42,4,FALSE +Gabite,Dragon,Ground,410,68,90,65,50,55,82,4,FALSE +Garchomp,Dragon,Ground,600,108,130,95,80,85,102,4,FALSE +GarchompMega Garchomp,Dragon,Ground,700,108,170,115,120,95,92,4,FALSE +Munchlax,Normal,,390,135,85,40,40,85,5,4,FALSE +Riolu,Fighting,,285,40,70,40,35,40,60,4,FALSE +Lucario,Fighting,Steel,525,70,110,70,115,70,90,4,FALSE +LucarioMega Lucario,Fighting,Steel,625,70,145,88,140,70,112,4,FALSE +Hippopotas,Ground,,330,68,72,78,38,42,32,4,FALSE +Hippowdon,Ground,,525,108,112,118,68,72,47,4,FALSE +Skorupi,Poison,Bug,330,40,50,90,30,55,65,4,FALSE +Drapion,Poison,Dark,500,70,90,110,60,75,95,4,FALSE +Croagunk,Poison,Fighting,300,48,61,40,61,40,50,4,FALSE +Toxicroak,Poison,Fighting,490,83,106,65,86,65,85,4,FALSE +Carnivine,Grass,,454,74,100,72,90,72,46,4,FALSE +Finneon,Water,,330,49,49,56,49,61,66,4,FALSE +Lumineon,Water,,460,69,69,76,69,86,91,4,FALSE +Mantyke,Water,Flying,345,45,20,50,60,120,50,4,FALSE +Snover,Grass,Ice,334,60,62,50,62,60,40,4,FALSE +Abomasnow,Grass,Ice,494,90,92,75,92,85,60,4,FALSE +AbomasnowMega Abomasnow,Grass,Ice,594,90,132,105,132,105,30,4,FALSE +Weavile,Dark,Ice,510,70,120,65,45,85,125,4,FALSE +Magnezone,Electric,Steel,535,70,70,115,130,90,60,4,FALSE +Lickilicky,Normal,,515,110,85,95,80,95,50,4,FALSE +Rhyperior,Ground,Rock,535,115,140,130,55,55,40,4,FALSE +Tangrowth,Grass,,535,100,100,125,110,50,50,4,FALSE +Electivire,Electric,,540,75,123,67,95,85,95,4,FALSE +Magmortar,Fire,,540,75,95,67,125,95,83,4,FALSE +Togekiss,Fairy,Flying,545,85,50,95,120,115,80,4,FALSE +Yanmega,Bug,Flying,515,86,76,86,116,56,95,4,FALSE +Leafeon,Grass,,525,65,110,130,60,65,95,4,FALSE +Glaceon,Ice,,525,65,60,110,130,95,65,4,FALSE +Gliscor,Ground,Flying,510,75,95,125,45,75,95,4,FALSE +Mamoswine,Ice,Ground,530,110,130,80,70,60,80,4,FALSE +Porygon-Z,Normal,,535,85,80,70,135,75,90,4,FALSE +Gallade,Psychic,Fighting,518,68,125,65,65,115,80,4,FALSE +GalladeMega Gallade,Psychic,Fighting,618,68,165,95,65,115,110,4,FALSE +Probopass,Rock,Steel,525,60,55,145,75,150,40,4,FALSE +Dusknoir,Ghost,,525,45,100,135,65,135,45,4,FALSE +Froslass,Ice,Ghost,480,70,80,70,80,70,110,4,FALSE +Rotom,Electric,Ghost,440,50,50,77,95,77,91,4,FALSE +RotomHeat Rotom,Electric,Fire,520,50,65,107,105,107,86,4,FALSE +RotomWash Rotom,Electric,Water,520,50,65,107,105,107,86,4,FALSE +RotomFrost Rotom,Electric,Ice,520,50,65,107,105,107,86,4,FALSE +RotomFan Rotom,Electric,Flying,520,50,65,107,105,107,86,4,FALSE +RotomMow Rotom,Electric,Grass,520,50,65,107,105,107,86,4,FALSE +Uxie,Psychic,,580,75,75,130,75,130,95,4,TRUE +Mesprit,Psychic,,580,80,105,105,105,105,80,4,TRUE +Azelf,Psychic,,580,75,125,70,125,70,115,4,TRUE +Dialga,Steel,Dragon,680,100,120,120,150,100,90,4,TRUE +Palkia,Water,Dragon,680,90,120,100,150,120,100,4,TRUE +Heatran,Fire,Steel,600,91,90,106,130,106,77,4,TRUE +Regigigas,Normal,,670,110,160,110,80,110,100,4,TRUE +GiratinaAltered Forme,Ghost,Dragon,680,150,100,120,100,120,90,4,TRUE +GiratinaOrigin Forme,Ghost,Dragon,680,150,120,100,120,100,90,4,TRUE +Cresselia,Psychic,,600,120,70,120,75,130,85,4,FALSE +Phione,Water,,480,80,80,80,80,80,80,4,FALSE +Manaphy,Water,,600,100,100,100,100,100,100,4,FALSE +Darkrai,Dark,,600,70,90,90,135,90,125,4,TRUE +ShayminLand Forme,Grass,,600,100,100,100,100,100,100,4,TRUE +ShayminSky Forme,Grass,Flying,600,100,103,75,120,75,127,4,TRUE +Arceus,Normal,,720,120,120,120,120,120,120,4,TRUE +Victini,Psychic,Fire,600,100,100,100,100,100,100,5,TRUE +Snivy,Grass,,308,45,45,55,45,55,63,5,FALSE +Servine,Grass,,413,60,60,75,60,75,83,5,FALSE +Serperior,Grass,,528,75,75,95,75,95,113,5,FALSE +Tepig,Fire,,308,65,63,45,45,45,45,5,FALSE +Pignite,Fire,Fighting,418,90,93,55,70,55,55,5,FALSE +Emboar,Fire,Fighting,528,110,123,65,100,65,65,5,FALSE +Oshawott,Water,,308,55,55,45,63,45,45,5,FALSE +Dewott,Water,,413,75,75,60,83,60,60,5,FALSE +Samurott,Water,,528,95,100,85,108,70,70,5,FALSE +Patrat,Normal,,255,45,55,39,35,39,42,5,FALSE +Watchog,Normal,,420,60,85,69,60,69,77,5,FALSE +Lillipup,Normal,,275,45,60,45,25,45,55,5,FALSE +Herdier,Normal,,370,65,80,65,35,65,60,5,FALSE +Stoutland,Normal,,500,85,110,90,45,90,80,5,FALSE +Purrloin,Dark,,281,41,50,37,50,37,66,5,FALSE +Liepard,Dark,,446,64,88,50,88,50,106,5,FALSE +Pansage,Grass,,316,50,53,48,53,48,64,5,FALSE +Simisage,Grass,,498,75,98,63,98,63,101,5,FALSE +Pansear,Fire,,316,50,53,48,53,48,64,5,FALSE +Simisear,Fire,,498,75,98,63,98,63,101,5,FALSE +Panpour,Water,,316,50,53,48,53,48,64,5,FALSE +Simipour,Water,,498,75,98,63,98,63,101,5,FALSE +Munna,Psychic,,292,76,25,45,67,55,24,5,FALSE +Musharna,Psychic,,487,116,55,85,107,95,29,5,FALSE +Pidove,Normal,Flying,264,50,55,50,36,30,43,5,FALSE +Tranquill,Normal,Flying,358,62,77,62,50,42,65,5,FALSE +Unfezant,Normal,Flying,488,80,115,80,65,55,93,5,FALSE +Blitzle,Electric,,295,45,60,32,50,32,76,5,FALSE +Zebstrika,Electric,,497,75,100,63,80,63,116,5,FALSE +Roggenrola,Rock,,280,55,75,85,25,25,15,5,FALSE +Boldore,Rock,,390,70,105,105,50,40,20,5,FALSE +Gigalith,Rock,,515,85,135,130,60,80,25,5,FALSE +Woobat,Psychic,Flying,313,55,45,43,55,43,72,5,FALSE +Swoobat,Psychic,Flying,425,67,57,55,77,55,114,5,FALSE +Drilbur,Ground,,328,60,85,40,30,45,68,5,FALSE +Excadrill,Ground,Steel,508,110,135,60,50,65,88,5,FALSE +Audino,Normal,,445,103,60,86,60,86,50,5,FALSE +AudinoMega Audino,Normal,Fairy,545,103,60,126,80,126,50,5,FALSE +Timburr,Fighting,,305,75,80,55,25,35,35,5,FALSE +Gurdurr,Fighting,,405,85,105,85,40,50,40,5,FALSE +Conkeldurr,Fighting,,505,105,140,95,55,65,45,5,FALSE +Tympole,Water,,294,50,50,40,50,40,64,5,FALSE +Palpitoad,Water,Ground,384,75,65,55,65,55,69,5,FALSE +Seismitoad,Water,Ground,509,105,95,75,85,75,74,5,FALSE +Throh,Fighting,,465,120,100,85,30,85,45,5,FALSE +Sawk,Fighting,,465,75,125,75,30,75,85,5,FALSE +Sewaddle,Bug,Grass,310,45,53,70,40,60,42,5,FALSE +Swadloon,Bug,Grass,380,55,63,90,50,80,42,5,FALSE +Leavanny,Bug,Grass,500,75,103,80,70,80,92,5,FALSE +Venipede,Bug,Poison,260,30,45,59,30,39,57,5,FALSE +Whirlipede,Bug,Poison,360,40,55,99,40,79,47,5,FALSE +Scolipede,Bug,Poison,485,60,100,89,55,69,112,5,FALSE +Cottonee,Grass,Fairy,280,40,27,60,37,50,66,5,FALSE +Whimsicott,Grass,Fairy,480,60,67,85,77,75,116,5,FALSE +Petilil,Grass,,280,45,35,50,70,50,30,5,FALSE +Lilligant,Grass,,480,70,60,75,110,75,90,5,FALSE +Basculin,Water,,460,70,92,65,80,55,98,5,FALSE +Sandile,Ground,Dark,292,50,72,35,35,35,65,5,FALSE +Krokorok,Ground,Dark,351,60,82,45,45,45,74,5,FALSE +Krookodile,Ground,Dark,519,95,117,80,65,70,92,5,FALSE +Darumaka,Fire,,315,70,90,45,15,45,50,5,FALSE +DarmanitanStandard Mode,Fire,,480,105,140,55,30,55,95,5,FALSE +DarmanitanZen Mode,Fire,Psychic,540,105,30,105,140,105,55,5,FALSE +Maractus,Grass,,461,75,86,67,106,67,60,5,FALSE +Dwebble,Bug,Rock,325,50,65,85,35,35,55,5,FALSE +Crustle,Bug,Rock,475,70,95,125,65,75,45,5,FALSE +Scraggy,Dark,Fighting,348,50,75,70,35,70,48,5,FALSE +Scrafty,Dark,Fighting,488,65,90,115,45,115,58,5,FALSE +Sigilyph,Psychic,Flying,490,72,58,80,103,80,97,5,FALSE +Yamask,Ghost,,303,38,30,85,55,65,30,5,FALSE +Cofagrigus,Ghost,,483,58,50,145,95,105,30,5,FALSE +Tirtouga,Water,Rock,355,54,78,103,53,45,22,5,FALSE +Carracosta,Water,Rock,495,74,108,133,83,65,32,5,FALSE +Archen,Rock,Flying,401,55,112,45,74,45,70,5,FALSE +Archeops,Rock,Flying,567,75,140,65,112,65,110,5,FALSE +Trubbish,Poison,,329,50,50,62,40,62,65,5,FALSE +Garbodor,Poison,,474,80,95,82,60,82,75,5,FALSE +Zorua,Dark,,330,40,65,40,80,40,65,5,FALSE +Zoroark,Dark,,510,60,105,60,120,60,105,5,FALSE +Minccino,Normal,,300,55,50,40,40,40,75,5,FALSE +Cinccino,Normal,,470,75,95,60,65,60,115,5,FALSE +Gothita,Psychic,,290,45,30,50,55,65,45,5,FALSE +Gothorita,Psychic,,390,60,45,70,75,85,55,5,FALSE +Gothitelle,Psychic,,490,70,55,95,95,110,65,5,FALSE +Solosis,Psychic,,290,45,30,40,105,50,20,5,FALSE +Duosion,Psychic,,370,65,40,50,125,60,30,5,FALSE +Reuniclus,Psychic,,490,110,65,75,125,85,30,5,FALSE +Ducklett,Water,Flying,305,62,44,50,44,50,55,5,FALSE +Swanna,Water,Flying,473,75,87,63,87,63,98,5,FALSE +Vanillite,Ice,,305,36,50,50,65,60,44,5,FALSE +Vanillish,Ice,,395,51,65,65,80,75,59,5,FALSE +Vanilluxe,Ice,,535,71,95,85,110,95,79,5,FALSE +Deerling,Normal,Grass,335,60,60,50,40,50,75,5,FALSE +Sawsbuck,Normal,Grass,475,80,100,70,60,70,95,5,FALSE +Emolga,Electric,Flying,428,55,75,60,75,60,103,5,FALSE +Karrablast,Bug,,315,50,75,45,40,45,60,5,FALSE +Escavalier,Bug,Steel,495,70,135,105,60,105,20,5,FALSE +Foongus,Grass,Poison,294,69,55,45,55,55,15,5,FALSE +Amoonguss,Grass,Poison,464,114,85,70,85,80,30,5,FALSE +Frillish,Water,Ghost,335,55,40,50,65,85,40,5,FALSE +Jellicent,Water,Ghost,480,100,60,70,85,105,60,5,FALSE +Alomomola,Water,,470,165,75,80,40,45,65,5,FALSE +Joltik,Bug,Electric,319,50,47,50,57,50,65,5,FALSE +Galvantula,Bug,Electric,472,70,77,60,97,60,108,5,FALSE +Ferroseed,Grass,Steel,305,44,50,91,24,86,10,5,FALSE +Ferrothorn,Grass,Steel,489,74,94,131,54,116,20,5,FALSE +Klink,Steel,,300,40,55,70,45,60,30,5,FALSE +Klang,Steel,,440,60,80,95,70,85,50,5,FALSE +Klinklang,Steel,,520,60,100,115,70,85,90,5,FALSE +Tynamo,Electric,,275,35,55,40,45,40,60,5,FALSE +Eelektrik,Electric,,405,65,85,70,75,70,40,5,FALSE +Eelektross,Electric,,515,85,115,80,105,80,50,5,FALSE +Elgyem,Psychic,,335,55,55,55,85,55,30,5,FALSE +Beheeyem,Psychic,,485,75,75,75,125,95,40,5,FALSE +Litwick,Ghost,Fire,275,50,30,55,65,55,20,5,FALSE +Lampent,Ghost,Fire,370,60,40,60,95,60,55,5,FALSE +Chandelure,Ghost,Fire,520,60,55,90,145,90,80,5,FALSE +Axew,Dragon,,320,46,87,60,30,40,57,5,FALSE +Fraxure,Dragon,,410,66,117,70,40,50,67,5,FALSE +Haxorus,Dragon,,540,76,147,90,60,70,97,5,FALSE +Cubchoo,Ice,,305,55,70,40,60,40,40,5,FALSE +Beartic,Ice,,485,95,110,80,70,80,50,5,FALSE +Cryogonal,Ice,,485,70,50,30,95,135,105,5,FALSE +Shelmet,Bug,,305,50,40,85,40,65,25,5,FALSE +Accelgor,Bug,,495,80,70,40,100,60,145,5,FALSE +Stunfisk,Ground,Electric,471,109,66,84,81,99,32,5,FALSE +Mienfoo,Fighting,,350,45,85,50,55,50,65,5,FALSE +Mienshao,Fighting,,510,65,125,60,95,60,105,5,FALSE +Druddigon,Dragon,,485,77,120,90,60,90,48,5,FALSE +Golett,Ground,Ghost,303,59,74,50,35,50,35,5,FALSE +Golurk,Ground,Ghost,483,89,124,80,55,80,55,5,FALSE +Pawniard,Dark,Steel,340,45,85,70,40,40,60,5,FALSE +Bisharp,Dark,Steel,490,65,125,100,60,70,70,5,FALSE +Bouffalant,Normal,,490,95,110,95,40,95,55,5,FALSE +Rufflet,Normal,Flying,350,70,83,50,37,50,60,5,FALSE +Braviary,Normal,Flying,510,100,123,75,57,75,80,5,FALSE +Vullaby,Dark,Flying,370,70,55,75,45,65,60,5,FALSE +Mandibuzz,Dark,Flying,510,110,65,105,55,95,80,5,FALSE +Heatmor,Fire,,484,85,97,66,105,66,65,5,FALSE +Durant,Bug,Steel,484,58,109,112,48,48,109,5,FALSE +Deino,Dark,Dragon,300,52,65,50,45,50,38,5,FALSE +Zweilous,Dark,Dragon,420,72,85,70,65,70,58,5,FALSE +Hydreigon,Dark,Dragon,600,92,105,90,125,90,98,5,FALSE +Larvesta,Bug,Fire,360,55,85,55,50,55,60,5,FALSE +Volcarona,Bug,Fire,550,85,60,65,135,105,100,5,FALSE +Cobalion,Steel,Fighting,580,91,90,129,90,72,108,5,TRUE +Terrakion,Rock,Fighting,580,91,129,90,72,90,108,5,TRUE +Virizion,Grass,Fighting,580,91,90,72,90,129,108,5,TRUE +TornadusIncarnate Forme,Flying,,580,79,115,70,125,80,111,5,TRUE +TornadusTherian Forme,Flying,,580,79,100,80,110,90,121,5,TRUE +ThundurusIncarnate Forme,Electric,Flying,580,79,115,70,125,80,111,5,TRUE +ThundurusTherian Forme,Electric,Flying,580,79,105,70,145,80,101,5,TRUE +Reshiram,Dragon,Fire,680,100,120,100,150,120,90,5,TRUE +Zekrom,Dragon,Electric,680,100,150,120,120,100,90,5,TRUE +LandorusIncarnate Forme,Ground,Flying,600,89,125,90,115,80,101,5,TRUE +LandorusTherian Forme,Ground,Flying,600,89,145,90,105,80,91,5,TRUE +Kyurem,Dragon,Ice,660,125,130,90,130,90,95,5,TRUE +KyuremBlack Kyurem,Dragon,Ice,700,125,170,100,120,90,95,5,TRUE +KyuremWhite Kyurem,Dragon,Ice,700,125,120,90,170,100,95,5,TRUE +KeldeoOrdinary Forme,Water,Fighting,580,91,72,90,129,90,108,5,FALSE +KeldeoResolute Forme,Water,Fighting,580,91,72,90,129,90,108,5,FALSE +MeloettaAria Forme,Normal,Psychic,600,100,77,77,128,128,90,5,FALSE +MeloettaPirouette Forme,Normal,Fighting,600,100,128,90,77,77,128,5,FALSE +Genesect,Bug,Steel,600,71,120,95,120,95,99,5,FALSE +Chespin,Grass,,313,56,61,65,48,45,38,6,FALSE +Quilladin,Grass,,405,61,78,95,56,58,57,6,FALSE +Chesnaught,Grass,Fighting,530,88,107,122,74,75,64,6,FALSE +Fennekin,Fire,,307,40,45,40,62,60,60,6,FALSE +Braixen,Fire,,409,59,59,58,90,70,73,6,FALSE +Delphox,Fire,Psychic,534,75,69,72,114,100,104,6,FALSE +Froakie,Water,,314,41,56,40,62,44,71,6,FALSE +Frogadier,Water,,405,54,63,52,83,56,97,6,FALSE +Greninja,Water,Dark,530,72,95,67,103,71,122,6,FALSE +Bunnelby,Normal,,237,38,36,38,32,36,57,6,FALSE +Diggersby,Normal,Ground,423,85,56,77,50,77,78,6,FALSE +Fletchling,Normal,Flying,278,45,50,43,40,38,62,6,FALSE +Fletchinder,Fire,Flying,382,62,73,55,56,52,84,6,FALSE +Talonflame,Fire,Flying,499,78,81,71,74,69,126,6,FALSE +Scatterbug,Bug,,200,38,35,40,27,25,35,6,FALSE +Spewpa,Bug,,213,45,22,60,27,30,29,6,FALSE +Vivillon,Bug,Flying,411,80,52,50,90,50,89,6,FALSE +Litleo,Fire,Normal,369,62,50,58,73,54,72,6,FALSE +Pyroar,Fire,Normal,507,86,68,72,109,66,106,6,FALSE +Flabébé,Fairy,,303,44,38,39,61,79,42,6,FALSE +Floette,Fairy,,371,54,45,47,75,98,52,6,FALSE +Florges,Fairy,,552,78,65,68,112,154,75,6,FALSE +Skiddo,Grass,,350,66,65,48,62,57,52,6,FALSE +Gogoat,Grass,,531,123,100,62,97,81,68,6,FALSE +Pancham,Fighting,,348,67,82,62,46,48,43,6,FALSE +Pangoro,Fighting,Dark,495,95,124,78,69,71,58,6,FALSE +Furfrou,Normal,,472,75,80,60,65,90,102,6,FALSE +Espurr,Psychic,,355,62,48,54,63,60,68,6,FALSE +MeowsticMale,Psychic,,466,74,48,76,83,81,104,6,FALSE +MeowsticFemale,Psychic,,466,74,48,76,83,81,104,6,FALSE +Honedge,Steel,Ghost,325,45,80,100,35,37,28,6,FALSE +Doublade,Steel,Ghost,448,59,110,150,45,49,35,6,FALSE +AegislashBlade Forme,Steel,Ghost,520,60,150,50,150,50,60,6,FALSE +AegislashShield Forme,Steel,Ghost,520,60,50,150,50,150,60,6,FALSE +Spritzee,Fairy,,341,78,52,60,63,65,23,6,FALSE +Aromatisse,Fairy,,462,101,72,72,99,89,29,6,FALSE +Swirlix,Fairy,,341,62,48,66,59,57,49,6,FALSE +Slurpuff,Fairy,,480,82,80,86,85,75,72,6,FALSE +Inkay,Dark,Psychic,288,53,54,53,37,46,45,6,FALSE +Malamar,Dark,Psychic,482,86,92,88,68,75,73,6,FALSE +Binacle,Rock,Water,306,42,52,67,39,56,50,6,FALSE +Barbaracle,Rock,Water,500,72,105,115,54,86,68,6,FALSE +Skrelp,Poison,Water,320,50,60,60,60,60,30,6,FALSE +Dragalge,Poison,Dragon,494,65,75,90,97,123,44,6,FALSE +Clauncher,Water,,330,50,53,62,58,63,44,6,FALSE +Clawitzer,Water,,500,71,73,88,120,89,59,6,FALSE +Helioptile,Electric,Normal,289,44,38,33,61,43,70,6,FALSE +Heliolisk,Electric,Normal,481,62,55,52,109,94,109,6,FALSE +Tyrunt,Rock,Dragon,362,58,89,77,45,45,48,6,FALSE +Tyrantrum,Rock,Dragon,521,82,121,119,69,59,71,6,FALSE +Amaura,Rock,Ice,362,77,59,50,67,63,46,6,FALSE +Aurorus,Rock,Ice,521,123,77,72,99,92,58,6,FALSE +Sylveon,Fairy,,525,95,65,65,110,130,60,6,FALSE +Hawlucha,Fighting,Flying,500,78,92,75,74,63,118,6,FALSE +Dedenne,Electric,Fairy,431,67,58,57,81,67,101,6,FALSE +Carbink,Rock,Fairy,500,50,50,150,50,150,50,6,FALSE +Goomy,Dragon,,300,45,50,35,55,75,40,6,FALSE +Sliggoo,Dragon,,452,68,75,53,83,113,60,6,FALSE +Goodra,Dragon,,600,90,100,70,110,150,80,6,FALSE +Klefki,Steel,Fairy,470,57,80,91,80,87,75,6,FALSE +Phantump,Ghost,Grass,309,43,70,48,50,60,38,6,FALSE +Trevenant,Ghost,Grass,474,85,110,76,65,82,56,6,FALSE +PumpkabooAverage Size,Ghost,Grass,335,49,66,70,44,55,51,6,FALSE +PumpkabooSmall Size,Ghost,Grass,335,44,66,70,44,55,56,6,FALSE +PumpkabooLarge Size,Ghost,Grass,335,54,66,70,44,55,46,6,FALSE +PumpkabooSuper Size,Ghost,Grass,335,59,66,70,44,55,41,6,FALSE +GourgeistAverage Size,Ghost,Grass,494,65,90,122,58,75,84,6,FALSE +GourgeistSmall Size,Ghost,Grass,494,55,85,122,58,75,99,6,FALSE +GourgeistLarge Size,Ghost,Grass,494,75,95,122,58,75,69,6,FALSE +GourgeistSuper Size,Ghost,Grass,494,85,100,122,58,75,54,6,FALSE +Bergmite,Ice,,304,55,69,85,32,35,28,6,FALSE +Avalugg,Ice,,514,95,117,184,44,46,28,6,FALSE +Noibat,Flying,Dragon,245,40,30,35,45,40,55,6,FALSE +Noivern,Flying,Dragon,535,85,70,80,97,80,123,6,FALSE +Xerneas,Fairy,,680,126,131,95,131,98,99,6,TRUE +Yveltal,Dark,Flying,680,126,131,95,131,98,99,6,TRUE +Zygarde50% Forme,Dragon,Ground,600,108,100,121,81,95,95,6,TRUE +Diancie,Rock,Fairy,600,50,100,150,100,150,50,6,TRUE +DiancieMega Diancie,Rock,Fairy,700,50,160,110,160,110,110,6,TRUE +HoopaHoopa Confined,Psychic,Ghost,600,80,110,60,150,130,70,6,TRUE +HoopaHoopa Unbound,Psychic,Dark,680,80,160,60,170,130,80,6,TRUE +Volcanion,Fire,Water,600,80,110,120,130,90,70,6,TRUE \ No newline at end of file diff --git a/_README.ipynb b/_README.ipynb index 5e49851..529abed 100644 --- a/_README.ipynb +++ b/_README.ipynb @@ -133,17 +133,17 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" - }, + "version": "3.7.5" + }, "pycharm": { "stem_cell": { "cell_type": "raw", - "source": [], "metadata": { "collapsed": false - } - } - } + }, + "source": [] + } + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/essay1_ch.txt b/essay1_ch.txt new file mode 100644 index 0000000..68e1fc8 --- /dev/null +++ b/essay1_ch.txt @@ -0,0 +1,14 @@ +为什么鲸鱼的体型如此庞大？有一个答案很简单，它们就是能长到这么大。 +陆地动物体型受限的部分原因是因为它们需要依靠自身对抗地心引力。 +海洋生物可以通过它们生活的环境为媒介免费获得这种支持。 +即便如此，可能的事情并不总是明智的。投入生长的资源无法再生产。 +鉴于鲸鱼可以且确实庞大，第二个问题就来了：如果有的话，有什么可以阻止它们变得更大？ +斯坦福大学的Jeremy Goldbogen和他的同事怀疑两个问题的答案和动物的食物供应有关。 +正如他们在《Science》杂志中发表的一篇论文所述，他们收集了数据，阐明了可能的运作方式。 +总的来说，大鲸鱼有两种。齿鲸，如抹香鲸，捕食单个猎物。 +须鲸，用纤维状的口腔过滤器吸入大量的水，并从磷虾等小生物中吸取营养。 +所有鲸鱼中最大的鲸类（蓝鲸、座头鲸等）是须鲸。 +这或许被认为是很矛盾的，因为在陆地上，捕食者越大，它们的猎物也越大。 +齿鲸和须鲸通常都潜入深海捕食，因为深海里的猎物更多。 +为了去深海捕食，它们会屏住呼吸，这就限制了它们在深水中停留的时间。 +鲸鱼巨大体型的解释之一是因为体型越大，屏息时间越长，这样它们就能花更长时间在深海捕食。 \ No newline at end of file diff --git a/essay1_en.txt b/essay1_en.txt new file mode 100644 index 0000000..9ec33de --- /dev/null +++ b/essay1_en.txt @@ -0,0 +1,14 @@ +Why are whales so big? One answer is simply that they can be. +The size of land animals is constrained in part by their need to support themselves against the force of gravity. +Marine creatures have that support provided free, by the medium they live in. +Even so, what is possible is not always sensible. Resources put into growth are unavailable for reproduction. +Given that whales can and do become big, however, a second question arises: what, if anything, stops them being even bigger? +Jeremy Goldbogen of Stanford University and his colleagues suspect that the answers to both questions are related to the animals' food supply. +And, as they describe in a paper in Science, they have gathered data that illuminate how this might work. +Broadly, big whales come in two varieties. Toothed whales, such as sperm whales, hunt individual prey. +Baleen whales suck in mouthfuls of water and extract small organisms such as krill, using fibrous buccal filters. +The biggest whales of all (blue, humpback and so on) are baleen whales. +This might be viewed as paradoxical, because on land, as predators get bigger, so do their individual prey. +Both toothed and baleen whales often hunt by diving deep—prey being more abundant at depth. +To do this they have to hold their breath, which limits how long they can stay underwater. +One explanation of giantism in whales is that because bigger whales can hold their breath longer, they can spend more time hunting. \ No newline at end of file diff --git a/essay2_ch.txt b/essay2_ch.txt new file mode 100644 index 0000000..bac7a4e --- /dev/null +++ b/essay2_ch.txt @@ -0,0 +1,7 @@ +人类所到之处都是一片狼藉，太空也不例外。 +现在人类要为超过500000个绕地球高速飞行的垃圾负责，如果我们再不积极行动起来清理大型垃圾，碰撞的危险只会越来越大。 +欧洲航天局局长Jan Wörner说：“想象一下如果曾经失踪的所有船只都漂浮在水面上，在公海航行会有多危险。” +“目前轨道上就是这种情况，不能再任其继续发展了。” +就好像我们需要一辆拖车把成千上万颗失灵的卫星拖离轨道。顺便说一句，这正是欧洲航天局正在研究的。 +该机构计划到2025年发射世界上第一个轨道垃圾收集器，这个4条手臂的机器人就像迷宫里的吃豆子的人一样追踪太空垃圾。 +第一次这样的任务被称为清理太空-1，先执行小任务，只收集单件的太空垃圾来证明这一概念的可行性。这一任务的目标是Vespa，是欧洲航天局2013年发射织女星火箭留下的残骸。这件垃圾的重量几乎相当于一颗小型卫星，形状简单，机器人的四只手臂应该能很容易地抓取。一旦被垃圾收集器安全抓取，就会被拖出轨道，在大气层中烧毁。 \ No newline at end of file diff --git a/essay2_en.txt b/essay2_en.txt new file mode 100644 index 0000000..92a94d3 --- /dev/null +++ b/essay2_en.txt @@ -0,0 +1,8 @@ +Wherever we humans go, we leave behind a mess. That goes for space, too. +Today, our species is responsible for more than 500,000 pieces of junk hurtling around Earth at phenomenal speeds, and if we don't start actively removing the largest pieces, the risk of collisions will only grow worse. +"Imagine how dangerous sailing the high seas would be if all the ships ever lost in history were still drifting on top of the water," says Jan Wörner, European Space Agency (ESA) director general. +"That is the current situation in orbit, and it cannot be allowed to continue." +It's almost as if we need a tow truck to remove all the thousands of failed satellites from our orbit; incidentally, that's exactly what the ESA is working on. +By 2025, the agency plans on launching the world's first orbiting junk collector, a four-armed robot that tracks down space waste like Pac-Man in a maze. +The first-of-its-kind mission, known as ClearSpace-1, will start out small, collecting only a single piece of space junk to prove the concept works. The target in this case is called Vespa, a leftover remnant from ESA's Vega rocket launch in 2013. +This piece of junk weighs roughly the same as a small satellite and has a simple shape that should make it easy to grab with four robotic arms. Once it's safely in the arms of the garbage collector, it will then be dragged out of orbit and allowed to burn up in the atmosphere. \ No newline at end of file diff --git a/essay3_ch.txt b/essay3_ch.txt new file mode 100644 index 0000000..3ebd8eb --- /dev/null +++ b/essay3_ch.txt @@ -0,0 +1,29 @@ +澳大利亚当局表示，势无可挡的森林大火已经将一些房屋夷为平地，并迅速蔓延到悉尼郊区。新南威尔士州仍有数十处大火在燃烧，气温达到35摄氏度，风速达到每小时80公里。风向确如人们担心的那样转为了南风，不过大家所惧怕的“灾难性”一天基本上得以避免。 +本周二（11月12日）没有人员死亡报告，但消防官员警告称，目前的情况意味着该州面临的危险远未结束。 +大约有600万人居住在新南威尔士州。 +据澳大利亚媒体报道，新南威尔士州目前仍有100至300起火灾。 +消防人员一直在新南威尔士州北部绵延1000公里的前线作战，有关官员表示，几场大火“单是着火面积就超过10万公顷”。 +一些森林大火蔓延至距市中心15公里以内地区，消防人员不得不在悉尼北部郊区投放阻燃剂。 +大火距离布莱克·海门和肖恩·墨菲家所在的郊区富人区只有几米远。 +大火从居民家门前马路对面的茂密丛林蔓延开来，居民们被迫用游泳池的水灭火。 +海门告诉《悉尼先驱晨报》说：“实际情况是，我们的水压不够了，所以不得不用游泳池的水。肖恩用其中一个水桶接水扑灭了一处着火点。” +当地政府表示，一名消防员手臂骨折，肋骨可能也出现骨折。 +农业消防局局长谢恩·菲茨西蒙斯说：“我们还有很长的路要走。在下一轮恶劣天气来临之前，我们肯定无法扑灭所有这些火灾。” +“不幸的是，情况没有任何缓解的迹象。没有降雨，在未来几天至几周内，天气仍将炎热干燥。” +菲茨西蒙斯说，本周二（11月12日）有多达12座房屋被损坏或摧毁。 +新南威尔士州受影响社区的人们被敦促远离丛林地带。全州有600多所学校停课。 +澳大利亚保守派政府拒绝透露气候变化是否可能导致了火灾，这一回应招致了批评。 +自上周五（11月8日）新南威尔士州的火灾紧急情况加剧以来，已有3人死亡，170多座房屋被毁。 +当地政府表示，他们面临的可能是“本国有史以来最危险的森林大火周”。 +菲茨西蒙斯表示，前线有3000名消防员，还有来自其他州、新西兰以及澳大利亚国防军的支援。 +专家们称这一情况堪比2009年维多利亚州“黑色星期六”的森林大火，那次火灾造成173人死亡。 +有报告称，新南威尔士州猎人区北罗斯伯里的一场火灾以及至少另外两场火灾可能是蓄意纵火，警方正在对此进行调查。 +消防部门表示，自9月份火灾季节开始以来，新南威尔士州已有100万公顷土地遭遇火情。 +北部的昆士兰州也宣布进入紧急状态，该州有55起森林大火。 +尽管本周二（11月12日）昆州没有遭遇如此恶劣的天气，但官员们警告称，本周晚些时候情况可能会恶化。 +南澳大利亚州的消防人员正在扑灭十几起大火，而西澳大利亚州的森林大火也引发了紧急警报。 +科学家和专家警告说，由于气候变化，澳大利亚的火灾季节变得更长、更严重。 +官员们已经证实，2018年和2017年分别是澳大利亚有记录以来第三和第四最热的年份，去年澳大利亚经历了有记录以来最热的夏天。 +气象局发布的《2018年气候状况报告》称，气候变化导致极端高温事件增加，干旱等其他自然灾害的严重程度也随之提高。 +2015年，188个国家签署了具有里程碑意义的《巴黎协定》，规定与前工业化时期相比，全球气温升幅不得超过2摄氏度。即便如此，科学家们仍认为，澳大利亚正面临危险的新常态。 +去年，一份联合国报告称，澳大利亚在减少二氧化碳排放方面做得不够。 \ No newline at end of file diff --git a/essay3_en.txt b/essay3_en.txt new file mode 100644 index 0000000..7e8c40a --- /dev/null +++ b/essay3_en.txt @@ -0,0 +1,35 @@ +Raging bushfires have razed properties in Australia and briefly spread to suburbs of Sydney, officials say. + +Scores of fires are still burning in New South Wales amid temperatures of 35C and winds of 80km/h. +A feared southerly wind change has now occurred but the "catastrophic" day feared has largely been avoided. +No deaths were reported on Tuesday but fire chiefs warned that conditions meant the dangers facing the state were far from over. +About six million people live in New South Wales (NSW) state. +The number of fires still afflicting NSW ranged from 100 to 300 in Australian media reports. +Crews have been battling a front spanning 1,000km along the north coast of NSW, with several blazes "exceeding 100,000 hectares alone", officials have said. +Flame retardant had to be dropped in Sydney's northern suburbs as some bushfires approached within 15km of the city centre. +Flames came within metres of engulfing the homes of Blake Haymen and Sean Murphy in the affluent suburb. +The residents were forced to use pool water to tackle a blaze that had spread from dense bushland across the road from their homes. +"We actually ran out of water pressure, so we had to go to the pool. Sean put out a spot-fire with one of these buckets," Mr Haymen told the Sydney Morning Herald. +Authorities said one firefighter had suffered a broken arm and suspected fractured ribs. +Rural Fire Service Commissioner Shane Fitzsimmons said: "We've really got a long way to go. You can guarantee we're not going to be able to get around all of these fires before the next wave of bad weather. +"Unfortunately there's no meaningful reprieve. There's no rainfall in this change and we're going to continue to have warm dry conditions dominating in the days and weeks ahead." +Commissioner Fitzsimmons said up to a dozen homes were believed to have been damaged or destroyed on Tuesday. +People in vulnerable NSW communities have been urged to stay away from bushland. More than 600 schools are closed across the state. +Australia's conservative government has refused to be drawn on whether climate change could have contributed to the fires, in a response that has drawn criticism. + + +Three people have died and more than 170 properties have been destroyed since the fire emergency intensified in NSW on Friday. + +Authorities had said they were facing what could be "the most dangerous bushfire week this nation has ever seen". +Mr Fitzsimmons said 3,000 firefighters were on the front lines, boosted by crews from other states and New Zealand, as well as the Australian Defence Force. +Experts have compared the situation to the 2009 Black Saturday bushfires in Victoria, when 173 people died. +Police are investigating reports that a fire in North Rothbury, in the Hunter Region of NSW, and at least two others, may have been started deliberately. +Fire authorities say a million hectares of land have burned in NSW since the fire season began in September. +To the north, Queensland has also declared a state of emergency as 55 bushfires rage in the state. +Though it was not facing such severe weather on Tuesday, officials warned conditions could deteriorate later in the week. +Fire crews in South Australia were tacking about a dozen blazes, while bushfires in Western Australia also sparked emergency warnings. +Scientists and experts warn that Australia's fire season has grown longer and more intense due to climate change. +Officials have confirmed that 2018 and 2017 were Australia's third and fourth-hottest years on record respectively, and last year the nation experienced its warmest summer on record. +The Bureau of Meteorology's State of the Climate 2018 report said climate change had led to an increase in extreme heat events and raised the severity of other natural disasters, such as drought. +Even if global temperatures are contained to a 2C rise above pre-industrial levels - a limit set out in the landmark Paris accord, agreed by 188 nations in 2015 - scientists believe the country is facing a dangerous new normal. +Last year, a UN report said Australia was falling short in efforts to cut its CO2 emissions. \ No newline at end of file diff --git a/iris.csv b/iris.csv new file mode 100644 index 0000000..20bd6ee --- /dev/null +++ b/iris.csv @@ -0,0 +1,151 @@ +sepal_length,sepal_width,petal_length,petal_width,species +5.1,3.5,1.4,0.2,setosa +4.9,3.0,1.4,0.2,setosa +4.7,3.2,1.3,0.2,setosa +4.6,3.1,1.5,0.2,setosa +5.0,3.6,1.4,0.2,setosa +5.4,3.9,1.7,0.4,setosa +4.6,3.4,1.4,0.3,setosa +5.0,3.4,1.5,0.2,setosa +4.4,2.9,1.4,0.2,setosa +4.9,3.1,1.5,0.1,setosa +5.4,3.7,1.5,0.2,setosa +4.8,3.4,1.6,0.2,setosa +4.8,3.0,1.4,0.1,setosa +4.3,3.0,1.1,0.1,setosa +5.8,4.0,1.2,0.2,setosa +5.7,4.4,1.5,0.4,setosa +5.4,3.9,1.3,0.4,setosa +5.1,3.5,1.4,0.3,setosa +5.7,3.8,1.7,0.3,setosa +5.1,3.8,1.5,0.3,setosa +5.4,3.4,1.7,0.2,setosa +5.1,3.7,1.5,0.4,setosa +4.6,3.6,1.0,0.2,setosa +5.1,3.3,1.7,0.5,setosa +4.8,3.4,1.9,0.2,setosa +5.0,3.0,1.6,0.2,setosa +5.0,3.4,1.6,0.4,setosa +5.2,3.5,1.5,0.2,setosa +5.2,3.4,1.4,0.2,setosa +4.7,3.2,1.6,0.2,setosa +4.8,3.1,1.6,0.2,setosa +5.4,3.4,1.5,0.4,setosa +5.2,4.1,1.5,0.1,setosa +5.5,4.2,1.4,0.2,setosa +4.9,3.1,1.5,0.2,setosa +5.0,3.2,1.2,0.2,setosa +5.5,3.5,1.3,0.2,setosa +4.9,3.6,1.4,0.1,setosa +4.4,3.0,1.3,0.2,setosa +5.1,3.4,1.5,0.2,setosa +5.0,3.5,1.3,0.3,setosa +4.5,2.3,1.3,0.3,setosa +4.4,3.2,1.3,0.2,setosa +5.0,3.5,1.6,0.6,setosa +5.1,3.8,1.9,0.4,setosa +4.8,3.0,1.4,0.3,setosa +5.1,3.8,1.6,0.2,setosa +4.6,3.2,1.4,0.2,setosa +5.3,3.7,1.5,0.2,setosa +5.0,3.3,1.4,0.2,setosa +7.0,3.2,4.7,1.4,versicolor +6.4,3.2,4.5,1.5,versicolor +6.9,3.1,4.9,1.5,versicolor +5.5,2.3,4.0,1.3,versicolor +6.5,2.8,4.6,1.5,versicolor +5.7,2.8,4.5,1.3,versicolor +6.3,3.3,4.7,1.6,versicolor +4.9,2.4,3.3,1.0,versicolor +6.6,2.9,4.6,1.3,versicolor +5.2,2.7,3.9,1.4,versicolor +5.0,2.0,3.5,1.0,versicolor +5.9,3.0,4.2,1.5,versicolor +6.0,2.2,4.0,1.0,versicolor +6.1,2.9,4.7,1.4,versicolor +5.6,2.9,3.6,1.3,versicolor +6.7,3.1,4.4,1.4,versicolor +5.6,3.0,4.5,1.5,versicolor +5.8,2.7,4.1,1.0,versicolor +6.2,2.2,4.5,1.5,versicolor +5.6,2.5,3.9,1.1,versicolor +5.9,3.2,4.8,1.8,versicolor +6.1,2.8,4.0,1.3,versicolor +6.3,2.5,4.9,1.5,versicolor +6.1,2.8,4.7,1.2,versicolor +6.4,2.9,4.3,1.3,versicolor +6.6,3.0,4.4,1.4,versicolor +6.8,2.8,4.8,1.4,versicolor +6.7,3.0,5.0,1.7,versicolor +6.0,2.9,4.5,1.5,versicolor +5.7,2.6,3.5,1.0,versicolor +5.5,2.4,3.8,1.1,versicolor +5.5,2.4,3.7,1.0,versicolor +5.8,2.7,3.9,1.2,versicolor +6.0,2.7,5.1,1.6,versicolor +5.4,3.0,4.5,1.5,versicolor +6.0,3.4,4.5,1.6,versicolor +6.7,3.1,4.7,1.5,versicolor +6.3,2.3,4.4,1.3,versicolor +5.6,3.0,4.1,1.3,versicolor +5.5,2.5,4.0,1.3,versicolor +5.5,2.6,4.4,1.2,versicolor +6.1,3.0,4.6,1.4,versicolor +5.8,2.6,4.0,1.2,versicolor +5.0,2.3,3.3,1.0,versicolor +5.6,2.7,4.2,1.3,versicolor +5.7,3.0,4.2,1.2,versicolor +5.7,2.9,4.2,1.3,versicolor +6.2,2.9,4.3,1.3,versicolor +5.1,2.5,3.0,1.1,versicolor +5.7,2.8,4.1,1.3,versicolor +6.3,3.3,6.0,2.5,virginica +5.8,2.7,5.1,1.9,virginica +7.1,3.0,5.9,2.1,virginica +6.3,2.9,5.6,1.8,virginica +6.5,3.0,5.8,2.2,virginica +7.6,3.0,6.6,2.1,virginica +4.9,2.5,4.5,1.7,virginica +7.3,2.9,6.3,1.8,virginica +6.7,2.5,5.8,1.8,virginica +7.2,3.6,6.1,2.5,virginica +6.5,3.2,5.1,2.0,virginica +6.4,2.7,5.3,1.9,virginica +6.8,3.0,5.5,2.1,virginica +5.7,2.5,5.0,2.0,virginica +5.8,2.8,5.1,2.4,virginica +6.4,3.2,5.3,2.3,virginica +6.5,3.0,5.5,1.8,virginica +7.7,3.8,6.7,2.2,virginica +7.7,2.6,6.9,2.3,virginica +6.0,2.2,5.0,1.5,virginica +6.9,3.2,5.7,2.3,virginica +5.6,2.8,4.9,2.0,virginica +7.7,2.8,6.7,2.0,virginica +6.3,2.7,4.9,1.8,virginica +6.7,3.3,5.7,2.1,virginica +7.2,3.2,6.0,1.8,virginica +6.2,2.8,4.8,1.8,virginica +6.1,3.0,4.9,1.8,virginica +6.4,2.8,5.6,2.1,virginica +7.2,3.0,5.8,1.6,virginica +7.4,2.8,6.1,1.9,virginica +7.9,3.8,6.4,2.0,virginica +6.4,2.8,5.6,2.2,virginica +6.3,2.8,5.1,1.5,virginica +6.1,2.6,5.6,1.4,virginica +7.7,3.0,6.1,2.3,virginica +6.3,3.4,5.6,2.4,virginica +6.4,3.1,5.5,1.8,virginica +6.0,3.0,4.8,1.8,virginica +6.9,3.1,5.4,2.1,virginica +6.7,3.1,5.6,2.4,virginica +6.9,3.1,5.1,2.3,virginica +5.8,2.7,5.1,1.9,virginica +6.8,3.2,5.9,2.3,virginica +6.7,3.3,5.7,2.5,virginica +6.7,3.0,5.2,2.3,virginica +6.3,2.5,5.0,1.9,virginica +6.5,3.0,5.2,2.0,virginica +6.2,3.4,5.4,2.3,virginica +5.9,3.0,5.1,1.8,virginica diff --git a/mnist.npz b/mnist.npz new file mode 100644 index 0000000..e7baa20 Binary files /dev/null and b/mnist.npz differ diff --git a/mnist.py b/mnist.py new file mode 100644 index 0000000..fa930f5 --- /dev/null +++ b/mnist.py @@ -0,0 +1,29 @@ +import tensorflow as tf +import datetime +import os + +def create_model(): + return tf.keras.models.Sequential([ + tf.keras.layers.Flatten(input_shape=(28, 28)), + tf.keras.layers.Dense(512, activation='relu'), + tf.keras.layers.Dropout(0.2), + tf.keras.layers.Dense(10, activation='softmax') + ]) + +if __name__ == '__main__': + (x_train, y_train),(x_test, y_test) = tf.keras.datasets.mnist.load_data(path=os.getcwd()+'/mnist.npz') + x_train, x_test = x_train / 255.0, x_test / 255.0 + + model = create_model() + model.compile(optimizer='adam', + loss='sparse_categorical_crossentropy', + metrics=['accuracy']) + + log_dir="./results/tb_results/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1) + + model.fit(x=x_train, + y=y_train, + epochs=5, + validation_data=(x_test, y_test), + callbacks=[tensorboard_callback]) \ No newline at end of file diff --git a/model.h5 b/model.h5 new file mode 100644 index 0000000..27c2854 Binary files /dev/null and b/model.h5 differ diff --git a/myModel.pkl b/myModel.pkl new file mode 100644 index 0000000..be23a7a Binary files /dev/null and b/myModel.pkl differ diff --git a/out.txt b/out.txt new file mode 100644 index 0000000..f0176d3 --- /dev/null +++ b/out.txt @@ -0,0 +1,2 @@ +1.000000000000000000e+00 2.000000000000000000e+00 +3.000000000000000000e+00 4.000000000000000000e+00 diff --git a/pie.png b/pie.png new file mode 100644 index 0000000..4041c87 Binary files /dev/null and b/pie.png differ diff --git a/search.py b/search.py new file mode 100644 index 0000000..97552f9 --- /dev/null +++ b/search.py @@ -0,0 +1,655 @@ +import matplotlib.pyplot as plt +import collections +from IPython import display +import networkx as nx +import numpy as np +import time + + +class Color: + # 绘图配色 + # 基本的节点配色 + basic_node_color = '#6CB6FF' + # 初始节点配色 + start_node_color = 'y' + # 目标节点配色 + target_node_color = 'r' + # 已访问的节点配色 + visited_node_color = 'g' + # 基本边的配色 + basic_edge_color = 'b' + # 已访问的边的配色 + visited_edge_color = 'g' + # 抵达目标节点时的配色 + success_color = 'r' + + +class Graph(nx.Graph): + def __init__(self, + start_node=None, + target_node=None): + + # 初始化父类 + nx.Graph.__init__(self) + # 绘制 graph 时各个节点的坐标值 + self.nodes_pos = {} + # 搜索起点 + self.start_node = start_node + # 搜搜目标点 + self.target_node = target_node + # 搜索的最大深度 + self.max_depth = None + # bfs 的历史查找路径，例如 ['A','AB', 'AD', 'ABC'] + self.bfs_paths = [] + # dfs 的历史查找路径，例如 ['A','AB', 'ABC', 'AD'] + self.dfs_paths = [] + # 每条历史路径的分数（历史距离） + self.path_score = {} + # 绘制搜索数时每个节点的坐标值 + self.tree_node_position = {} + # 额外的辅助信息值，用于进行启发式搜索（贪婪或 A-star 搜索） + self.help_info = {} + # 额外辅助信息的权重 + self.help_info_weight = 1 + # 原始信息的权重 + self.origin_info_weight = 1 + # a_star 算法的历史查找路径 + self.a_star_search_paths = [] + # a_star 算法的中路径的得分 + self.a_star_search_scores = {} + # + self.changed = True + + def set_start_node(self, start_node): + """ + 设置起点 + :param start_node: 起点 + :return: + """ + if start_node not in self.nodes: + print('起点不在图中，请输入正确的起点') + return + self.start_node = start_node + self.path_score = {self.start_node: 0} + self.changed = True + + def set_target_node(self, target_node): + """ + 设置目标点 + :param target_node: 目标点 + :return: + """ + if target_node not in self.nodes: + print('目标点不在图中，请输入正确的目标点') + return + self.target_node = target_node + self.path_score = {self.start_node: 0} + self.changed = True + + def set_nodes_pos(self, nodes_pos): + """ + 设置 graph 内各个节点的坐标，绘图用，与搜索无关 + :param nodes_pos: 字典，节点的坐标， + 例如 {"A": (1, 1), "B": (3, 3), "C": (5, 0)} + :return: + """ + self.nodes_pos = nodes_pos + + def set_max_depth(self, max_depth): + """ + 设置最大搜索深度 + :param max_depth: 整数，大于 0 + :return: + """ + max_depth = min(max_depth, len(self.nodes)) + self.max_depth = max_depth + self.changed = True + + def set_help_info(self, help_info): + """ + 设置辅助信息，用于进行启发式搜索（贪婪或 A-star 搜索） + :param help_info: 字典， + 例如 {'A': 30, 'B': 20, 'C': 19 }，为各个点到目标点的距离 + :return: + """ + self.help_info = help_info + + def show_graph(self, this_path=''): + """ + 绘制 graph + :param this_path: 设置一条图中的路径 + :return: + """ + # 当不传入路径时，默认在初始节点 + this_path = this_path or self.start_node + # 根据当前你路径，处理节点和边的颜色 + # 根据路径得到已访问的边，例如 'ABC' 得到 ['AB', 'BC'] + visited_edges = [] + for i in range(1, len(this_path)): + visited_edges.append( + frozenset([this_path[i], this_path[i - 1]])) + # 节点和边以及其显示的标签 + node_labels = dict(zip(self.nodes(), self.nodes())) + edge_labels = dict( + [((u, v,), d['weight']) for u, v, d in self.edges(data=True)]) + + # 处理节点的颜色 + node_color_map = {e_node: Color.visited_node_color for e_node in + this_path} + node_color_map[self.start_node] = Color.start_node_color + node_color_map[self.target_node] = Color.target_node_color + node_color = [node_color_map.get(node, Color.basic_node_color) + for node in self.nodes()] + + # 处理每条边的颜色 + edge_color = [] + for edge in self.edges(): + if frozenset(edge) in visited_edges: + edge_color.append(Color.visited_edge_color) + else: + edge_color.append(Color.basic_edge_color) + + # 创建绘图 + fig, ax = plt.subplots() + # 定义绘图的宽和高，并关闭坐标轴的显示 + fig.set_figwidth(6) + fig.set_figheight(8) + plt.axis('off') + + # 绘制节点及其标签 + nx.draw_networkx_nodes(self, self.nodes_pos, node_size=800, + node_color=node_color) + nx.draw_networkx_labels(self, self.nodes_pos, node_labels, + font_size=20) + # 绘制边及其标签 + nx.draw_networkx_edges(self, self.nodes_pos, edge_color=edge_color, + width=2.0, alpha=1.0) + nx.draw_networkx_edge_labels(self, self.nodes_pos, + edge_labels=edge_labels, font_size=18) + # 清除绘图区，显示新绘图 + display.clear_output(wait=True) + plt.show() + + def bfs_search(self): + """ + 使用迭代法进行广度优先搜索 + :return: + """ + # 待访问的路径 + to_search = [self.start_node] + # 存储所有的已访问的路径 + bfs_paths = [] + # 当还有待访问的路径时 + while to_search: + # 从待访问的路径中取第一个待访问路径 + this_search = to_search.pop(0) + # 如果待访问的路径超过最大搜索深度，跳出循环 + if len(this_search) > self.max_depth + 1: + break + # 把刚取出的路径存入已访问的路径中 + bfs_paths.append(this_search) + # 如果路径的最后一个节点是目标节点，路径 AC 的最后一个节点是 C + if this_search[-1] == self.target_node: + # 其为一条正确的路径，将存入正确的路径列表中， + # 并不再继续往其子节点进行探索 + continue + # 找到路径最后一个节点的相邻节点 + else: + for ne in sorted(self.neighbors(this_search[-1])): + # 如果相邻节点不在路径中，即不存在回路 + if ne not in this_search: + # 则加入到待访问的路径中 + to_search.append(this_search + ne) + self.bfs_paths = bfs_paths + + def _dfs_helper(self, node, target_node, level, dfs_paths, path): + """ + 深度优先搜索的辅助函数 + :param node: 当前节点 + :param target_node: 目标点 + :param level: 搜索深度 + :param dfs_paths: dfs 的历史搜索路径 + :param path: 从哪一个路径来到当前节点 + :return: + """ + path += str(node) + # 更新路径的分数（距离） + if len(path) > 1: + self.path_score[path] = self.path_score[path[:-1]] + \ + self.edges[path[-2], path[-1]]['weight'] + # 存储 dfs 的历史搜索路径 + dfs_paths.append(path) + # 找到目标，停止搜索 + if node == target_node: + return + # 未达到最大搜索深度时，继续下一层搜索 + if level < self.max_depth: + # 对当前节点的每一个相邻节点 + for neighbor in sorted(self.neighbors(node)): + # 如果该相邻节点不在路径中，即没有出现回环，则递归调用，继续往下搜索 + if str(neighbor) not in path: + self._dfs_helper(neighbor, target_node, level + 1, + dfs_paths, path) + + def dfs_search(self): + """ + 使用递归法进行深度优先搜索 + :return: + """ + # dfs 的历史搜索路径 + dfs_paths = [] + this_path = '' + if self.start_node and self.target_node: + self._dfs_helper(self.start_node, self.target_node, + 0, dfs_paths, this_path) + else: + print('请设置起点和目标点') + self.dfs_paths = dfs_paths + # 完成搜索后，可得到搜索树中各个节点的坐标 + self.get_search_tree_node_position() + + def dfs_bfs_search(self): + """ + 如果对起始点，目标点或搜索深度进行了设置，需要重新绘制搜索树 + :return: + """ + self.dfs_search() + self.bfs_search() + self.changed = False + + def get_search_tree_node_position(self): + """得到绘图时各个节点的坐标 + """ + # 得到 dfs 的搜索路径图 + paths = self.dfs_paths + # 得到每条路径的子路径 + path_children = {} + for path in paths: + father = path[:-1] + if father in paths: + if father in path_children: + path_children[father].append(path) + else: + path_children[father] = [path] + # 对每条子路径排序 + o_path_children = collections.OrderedDict( + sorted(path_children.items())) + # 计算每个树图中每个节点的位置 + tree_node_position = {self.start_node: (1, 0, 2)} + for path, sub_paths in o_path_children.items(): + y_pos = -1.0 / self.max_depth * len(path) + dx = tree_node_position[path][2] / len(sub_paths) + sub_paths.sort() + for index, e_s in enumerate(sub_paths): + x_pos = tree_node_position[path][0] - tree_node_position[path][ + 2] / 2 + dx / 2 + dx * index + tree_node_position[e_s] = (x_pos, y_pos, dx) + self.tree_node_position = tree_node_position + + def a_star_search(self, help_info_weight=1, origin_info_weight=0): + """ + a-star 搜索， 当 origin_info_weight 为 0 时，则退化为贪婪搜索 + :param help_info_weight: 辅助信息的比重 + :param origin_info_weight: 原始信息的比重 + :return: + """ + if not self.help_info: + print('缺少额外的辅助信息') + return + # 存到类属性中，便于绘图时使用 + self.help_info_weight = help_info_weight + self.origin_info_weight = origin_info_weight + # 初始路径为起点 + search_path = self.start_node + # 存储每一步的可选项及其分数，用来在动态演示时显示出来 + search_scores = {} + # 当搜索路径未超过最大搜索深度 + while len(search_path) <= self.max_depth: + # 当前的节点 + this_node = search_path[-1] + # 当前节点的子节点 + neighbour_nodes = [e_n for e_n in sorted(self.neighbors(this_node)) + if e_n not in search_path] + # 如果没有子节点，则跳出循环，结束搜索 + if len(neighbour_nodes) == 0: + search_scores[search_path] = {} + break + # 计算每个子节点的得分并存储 + scores = {e_n: help_info_weight * self.help_info[ + e_n] + origin_info_weight * self.edges[this_node, e_n][ + 'weight'] for e_n in + neighbour_nodes} + search_scores[search_path] = scores + # 挑选最佳的子节点，并添加到路径中 + nearest_node = min(scores, key=scores.get) + search_path += nearest_node + # 如果最佳的子节点是目标节点，跳出循环，结束搜索 + if nearest_node == self.target_node: + break + # 把最终路径切分为每一步，便于动态展示，例如 ABCD 变为 [A, AB, ABC, ABCD ] + self.a_star_search_paths = [search_path[0:index + 1] for index in + range(len(search_path))] + self.a_star_search_scores = search_scores + + def greedy_search(self): + """ + 贪婪搜索，就是 origin_info_weight权重为 0 时的 a-star 搜索 + :return: + """ + self.a_star_search(help_info_weight=1, origin_info_weight=0) + + @staticmethod + def show_edge_labels(ax, pos1, pos2, label): + """ + 绘制搜索树的边 + :param ax: 子图 + :param pos1: 点 1 的坐标 + :param pos2: 点 2 的坐标 + :param label: 连接点 1 和点 2 的边上的文字 + :return: + """ + # 点1 + (x1, y1) = pos1 + # 点2 + (x2, y2) = pos2 + # 文字的位置 + (x, y) = (x1 * 0.5 + x2 * 0.5, y1 * 0.5 + y2 * 0.5) + # 文字的角度 + angle = np.arctan2(y2 - y1, x2 - x1) / (2.0 * np.pi) * 360 + if angle > 90: + angle -= 180 + if angle < - 90: + angle += 180 + xy = np.array((x, y)) + trans_angle = ax.transData.transform_angles(np.array((angle,)), + xy.reshape((1, 2)))[0] + # 绘制文字框和文字 + bbox = dict(boxstyle='round', + ec=(1.0, 1.0, 1.0), + fc=(1.0, 1.0, 1.0), + ) + label = str(label) + ax.text(x, y, + label, + size=16, + color='k', + alpha=1, + horizontalalignment='center', + verticalalignment='center', + rotation=trans_angle, + transform=ax.transData, + bbox=bbox, + zorder=1, + clip_on=True, + ) + + def show_search_tree(self, + animation_type='bfs', + top_text='', + bottom_text='', + this_path=None, + show_success_color=False, + ): + """ + 展示搜索树，动态展示搜索过程时，会调用此方法 + :param animation_type: 动态演示的类型，如果是启发式搜索，边的权重需要变化 + :param top_text: 上方的文字展示 + :param bottom_text: 下方的文字展示 + :param this_path: 当前路径 + :param show_success_color: 成功找到目标点后，路径颜色的变换 + :return: + """ + # 如果对起始点，目标点或搜索深度进行了设置，需要重新绘制搜索树 + if self.changed is True: + self.dfs_bfs_search() + + # 创建子图 + fig, ax = plt.subplots() + # 定义绘图的宽度 + fig.set_figwidth(15) + # 定义绘图的高度 + fig.set_figheight(self.max_depth * 1.5) + # 关闭绘图中坐标轴的显示 + plt.axis('off') + + # 对每条路径 + for path, pos in self.tree_node_position.items(): + # 如果是初始点 + if path[-1] == self.start_node: + node_color = Color.start_node_color + edge_color = Color.basic_edge_color + # 把当前路径的节点和边的颜色变为已访问的颜色 + elif this_path and path in this_path: + # 是否显示成功找到目标点 + if show_success_color: + node_color = Color.success_color + edge_color = Color.success_color + else: + node_color = Color.visited_node_color + edge_color = Color.visited_edge_color + # 如果路径的终点是目标点，改变目标点的颜色 + elif path[-1] == self.target_node: + node_color = Color.target_node_color + edge_color = Color.basic_edge_color + # 其他的情况下，节点和边的颜色是正常色 + else: + node_color = Color.basic_node_color + edge_color = Color.basic_edge_color + # 绘制节点 + ax.scatter(pos[0], pos[1], c=node_color, s=1000, zorder=1) + # 绘制节点的标注 + plt.annotate( + path[-1], + xy=(pos[0], pos[1]), + xytext=(0, 0), + textcoords='offset points', + ha='center', + va='center', + size=15, ) + if len(path) > 1: + # 绘制边 + plt.plot([self.tree_node_position[path[:-1]][0], pos[0]], + [self.tree_node_position[path[:-1]][1], pos[1]], + color=edge_color, + zorder=0) + # 绘制边的标注 + label = self.edges[path[-2], path[-1]]['weight'] + + if animation_type in ['greedy', 'a_star']: + label = self.help_info_weight * self.help_info[ + path[-1]] + self.origin_info_weight * label + self.show_edge_labels(ax, + self.tree_node_position[path[:-1]][ + 0:2], pos[0:2], label) + + # 绘制上方文字 + plt.text(0, + 0, + top_text, + fontsize=18, + horizontalalignment='left', + verticalalignment='top', ) + # 绘制下方文字 + plt.text(0, + -1.1, + bottom_text, + fontsize=18, + horizontalalignment='left', + verticalalignment='top', ) + + # 刷新绘图 + display.clear_output(wait=True) + plt.show() + + def _generate_bottom_text(self, show_correct_path): + """ + 生成目前找到的最佳路径的信息的文字 + :param show_correct_path: 当前找到的正确的路径 + :return: + """ + # 默认不展示文字 + bottom_text = "" + # 对每一条找到的正确路径，增加一条展示文本s + for path in show_correct_path: + bottom_text += '找到一条路径: %-7s' % path + '。距离为:' + str( + self.path_score[path]) + '\n' + return bottom_text + + def _generate_a_star_help_text(self, path): + """ + 生成贪婪搜索和 a-star 动态展示时的文字 + :param path: 当前路径 + :return: + """ + # 如果到达目标节点 + if path[-1] == self.target_node: + return '抵达目标节点' + str(self.target_node) + # 如果未抵达目标节点并且抵达了最大搜索深度 + elif path not in self.a_star_search_scores: + return '未找到目标节点， 结束搜索' + # 其他情况，展示当前节点可选节点的信息，以及挑选的原因 + else: + base_text = '当前可选的子节点及其信息值为 \n' + \ + str(self.a_star_search_scores[path]) + '\n' + if self.target_node in self.a_star_search_scores[path]: + return base_text + '当前可选的子节点包含了目标节点，\n所以选择目标节点' + elif len(self.a_star_search_scores[path]) == 1: + return base_text + '因为只有一个子节点，所以选择此节点' + else: + return base_text + '因为' + \ + str(min(self.a_star_search_scores[path], + key=self.a_star_search_scores[path].get)) + \ + '的值最小，所以选择此节点' + + def _generate_top_text(self, + animation_type, + this_path, + best_path=None, + finish=False): + """ + 生成展示当前路径的信息文字 + :param animation_type: + :param this_path: + :param best_path: + :param finish: + :return: + """ + # 如果结束搜索，展示最终的最短路径 + if finish: + if this_path: + top_text = '最终最短路径为: %-7s' % this_path + '。距离为:' + str( + self.path_score[this_path]) + '\n' + else: + top_text = '未找到正确路径' + # 如果是其他路径，并且是展示 dfs 或 bfs 的搜索过程，展示当前路径的信息 + elif this_path and animation_type in ['dfs', 'bfs']: + top_text = '当前路径: %-7s' % this_path + '。距离为:' + str( + self.path_score[this_path]) + '\n' + if best_path: + top_text += '当前最短路径为: %-7s' % best_path + '。距离为:' + \ + str(self.path_score[best_path]) + '\n' + # 如果是其他路径，并且是展示 贪婪搜索 或 A-star 算法的搜索过程，展示当前路径的信息 + elif this_path and animation_type in ['greedy', 'a_star']: + top_text = self._generate_a_star_help_text(this_path) + # 其他情况，不展示文字 + else: + top_text = '' + return top_text + + def animate_search_tree(self, + animation_type='dfs', + help_info_weight=1, + origin_info_weight=1, + sleep_time=0): + """ + 动态演示搜索过程 + :param animation_type: 可选项为 ['bfs', 'dfs', 'greedy', 'a_star'] + :param help_info_weight: 附加信息的权重值 + :param origin_info_weight: 原始信息的权重值 + :param sleep_time: 设置每一步的等待时间 + :return: + """ + + # 如果对起始点，目标点或搜索深度进行了设置，需要重新绘制搜索树 + if self.changed is True: + self.dfs_bfs_search() + + # 根据展示的搜索方式，获取展示的路径列表 + if animation_type == 'bfs': + paths = self.bfs_paths + elif animation_type == 'dfs': + paths = self.dfs_paths + elif animation_type == 'greedy': + self.greedy_search() + paths = self.a_star_search_paths + elif animation_type == 'a_star': + self.a_star_search(help_info_weight=help_info_weight, + origin_info_weight=origin_info_weight) + paths = self.a_star_search_paths + else: + print('animation_type 参数错误，请从 dfs、bfs、 greedy 或 a_star 中挑选一个') + return + + if animation_type in ['bfs', 'dfs']: + show_correct_path = [] + # 动态演示过程中找到的最佳路径 + best_path = None + # 对路径列表中的每一个路径，绘图 + for e_path in paths: + top_text = self._generate_top_text(animation_type, + e_path, + best_path=best_path, + finish=False) + bottom_text = self._generate_bottom_text(show_correct_path) + self.show_search_tree(top_text=top_text, + bottom_text=bottom_text, + this_path=e_path) + # 设置等待时间，避免切换过快 + time.sleep(sleep_time) + # 如果该路径是正确路径 + if e_path[-1] == self.target_node: + # 如果是第一个正确路径，则其为当前最佳路径 + if not best_path: + best_path = e_path + # 如果不是，与当前最佳路径比较， + elif self.path_score[e_path] < self.path_score[best_path]: + best_path = e_path + # 增加一条最佳路径的展示 + show_correct_path.append(e_path) + bottom_text = self._generate_bottom_text(show_correct_path) + self.show_search_tree(top_text=top_text, + bottom_text=bottom_text, + this_path=e_path, + show_success_color=True) + # 设置等待时间，避免切换过快 + time.sleep(sleep_time) + # 搜索结束后，展示最佳路径 + top_text = self._generate_top_text(animation_type, + best_path, + best_path=best_path, + finish=True + ) + bottom_text = self._generate_bottom_text(show_correct_path) + self.show_search_tree(top_text=top_text, + bottom_text=bottom_text, + this_path=best_path, + show_success_color=True) + + else: + # 对路径列表中的每一个路径，绘图 + for e_path in paths: + top_text = self._generate_top_text(animation_type, + e_path, + best_path=False) + self.show_search_tree(top_text=top_text, + this_path=e_path) + # 设置等待时间，避免切换过快 + time.sleep(sleep_time) + # 如果抵达目标点 + if e_path[-1] == self.target_node: + top_text = self._generate_top_text(animation_type, + e_path, + best_path=True) + self.show_search_tree(top_text=top_text, + this_path=e_path, + show_success_color=True) diff --git a/练习题-Numpy.ipynb b/练习题-Numpy.ipynb new file mode 100644 index 0000000..fbc1e96 --- /dev/null +++ b/练习题-Numpy.ipynb @@ -0,0 +1,4299 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "A69AC7A8D039456492A58F4670474397", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "Numpy是Python做数据分析所必须要掌握的基础库之一。\n", + "\n", + "\n", + "---\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D3EA769E89C04B1C98D7EEC27B000CF7", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 1. 导入```numpy```库并简写为 `np` (★☆☆) \n", + "(**提示**: ```import … as …```)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true, + "id": "9D78D931517E432FA973C0DFF57BC78B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "20AFD585027B441186903FB6F16CAA77", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 2. 打印```numpy```的版本和配置说明 (★☆☆) \n", + "(**提示**: ```np.__version__, np.show_config```)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true, + "id": "D705477270FF47D69C42E337B57DFC10", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.__version__)\n", + "# np.show_config()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1E6BD3752DEF4E698704E50AA0EBE92C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 3. 创建一个长度为10的空向量 (★☆☆) \n", + "(**提示**: ```np.zeros```)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true, + "id": "41292630A6F64C3391CF4AC90606EB62", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.zeros(10)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C8C4597CD9F1403BAD09C3601BFB771B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 4. 如何找到任何一个数组的内存大小？ (★☆☆)\n", + "(**提示**: ```size, itemsize```)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true, + "id": "42640A317E3544118E6C4E76DED8525C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.zeros((10,10))\n", + "# print(\"%d bytes\" % (Z.size * Z.itemsize))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "04C04BB115BD4AF687192E229581A9C1", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 5. 如何从命令行得到```numpy```中```add```函数的说明文档? (★☆☆) \n", + "(**提示**: ```np.info```)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true, + "id": "9138EB4B567942018EF386A8DB116F60", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# numpy.info(numpy.add)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7BEAD42C1F124A88851E1D4766DC2FDC", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 6. 创建一个长度为10并且除了第五个值为1的空向量 (★☆☆) \n", + "(**提示**: ```array[4]```)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true, + "id": "C28FC474E3124C97AA0E95DE2AE6DDED", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.zeros(10)\n", + "# Z[4] = 1\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CA86859BD5FE44888383B564D3281A88", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 7. 创建一个值域范围从10到49的向量(★☆☆) \n", + "(**提示**: ```np.arange```)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true, + "id": "3C0F52C0DD8B42C0908DA28387686BF5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(10,50)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8E233C2183494F5185095C23FD390953", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 8. 反转一个向量(第一个元素变为最后一个) (★☆☆) \n", + "(**提示**: ```array[::-1]```)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true, + "id": "AE86CCAF12044CED8445E5476F0EC695", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(50)\n", + "# Z = Z[::-1]\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9ABF19E9BDDF41E6BDD0EC15890B452B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 9. 创建一个 ```3x3``` 并且值从0到8的矩阵(★☆☆) \n", + "(**提示**: ```reshape```)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true, + "id": "FE30B2979C01496681E90910A011A276", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(9).reshape(3,3)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8FF7AF19C2344E37BFDE905F618E47E9", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 10. 找到数组```[1,2,0,0,4,0]```中非0元素的位置索引 (★☆☆) \n", + "(**提示**: ```np.nonzero```)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true, + "id": "CF6B96A0E8FA4FB588249E6E6DB89657", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# nz = np.nonzero([1,2,0,0,4,0])\n", + "# print(nz)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B431E1E8247640A58BDAACA967F5E104", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 11. 创建一个 ```3x3``` 的单位矩阵 (★☆☆) \n", + "(**提示**: ```np.eye```)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true, + "id": "B09137867EFA48C4AA58DBCB0F3AE455", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.eye(3)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8C4D8FCF233D43B28DC51B81879D4EA3", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 12. 创建一个 ```3x3x3```的随机数组 (★☆☆) \n", + "(**提示**: ```np.random.random```)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true, + "id": "7B99B6FBF2594BF7862AC75134813F8C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random((3,3,3))\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F566B47F9E574BE1876B8AF746BB1410", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 13. 创建一个 ```10x10``` 的随机数组并找到它的最大值和最小值 (★☆☆) \n", + "(**提示**: ```min, max```)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true, + "id": "69474CA4E1B144DB9DFEC144DED5EA34", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random((10,10))\n", + "# Zmin, Zmax = Z.min(), Z.max()\n", + "# print(Zmin, Zmax)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1C91060ECCFD4CCB8DC6849C4DA5F6B1", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 14. 创建一个长度为30的随机向量并找到它的平均值 (★☆☆) \n", + "(**提示**: ```mean```)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true, + "id": "4CC6FD8D2EE94C5CB9C016F753FECA6F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random(30)\n", + "# m = Z.mean()\n", + "# print(m)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3BB48A32125C46FF8595C4BD8496BDF2", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 15. 创建一个二维数组，其中边界值为1，其余值为0 (★☆☆) \n", + "(**提示**: ```array[1:-1, 1:-1]```)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true, + "id": "DD81EF89D40347959726C00E6D4960FB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.ones((10,10))\n", + "# Z[1:-1,1:-1] = 0\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3E757B4834EC47038E1BE151D9216D24", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 16. 对于一个存在在数组，如何添加一个用0填充的边界? (★☆☆) \n", + "(**提示**: ```np.pad```)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true, + "id": "50C827FEF7494D648C5851A1892D781E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.ones((5,5))\n", + "# Z = np.pad(Z, pad_width=1, mode='constant', constant_values=0)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "91F10E5D65C245C28315A74D340DE25E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 17. 以下表达式运行的结果分别是什么? (★☆☆) \n", + "(**提示**: ```NaN = not a number, inf = infinity```)\n", + "```python\n", + "0 * np.nan\n", + "np.nan == np.nan\n", + "np.inf > np.nan\n", + "np.nan - np.nan\n", + "0.3 == 3 * 0.1\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true, + "id": "5099C44330384C148B6C75BB8F8B0C1C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(0 * np.nan)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": true, + "id": "6B26448558014F8E811F947E38EA0CC3", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.nan == np.nan)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": true, + "id": "2250DCFDAF35421782B8468BAD931692", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.inf > np.nan)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true, + "id": "FDB7272792FA413FB8E610D62DE2645F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.nan - np.nan)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": true, + "id": "B991F0C2294442B38127DA786ACFAA8E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(0.3 == 3 * 0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4019417908674DE49895DAF9E9806F2E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 18. 创建一个 ```5x5```的矩阵，并设置值1,2,3,4落在其对角线下方位置 (★☆☆) \n", + "(**提示**: ```np.diag```)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true, + "id": "712527DF95664A3A8C6568BB2A5D08C6", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.diag(1+np.arange(4),k=-1)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4B0E4200FE8A48D1852A71D9120E6003", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 19. 创建一个``` 8x8``` 的矩阵，并且设置成棋盘样式 (★☆☆) \n", + "(**提示**: ```array[::2]```)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": true, + "id": "2C5E5A07FD84446780749AC3E09D72F6", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.zeros((8,8),dtype=int)\n", + "# Z[1::2,::2] = 1\n", + "# Z[::2,1::2] = 1\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C161AAFC72C74F98999DA7C3326DFC07", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 20. 考虑一个 (6,7,8) 形状的数组，其第100个元素的索引(x,y,z)是什么? \n", + "(**提示**: ```np.unravel_index```)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true, + "id": "35A916EDE9F34778949694347D7EED5F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.unravel_index(100,(6,7,8)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DBC41AC1D41E43F98B4D0A270F1E6987", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 21. 用```tile```函数去创建一个 ```8x8```的棋盘样式矩阵(★☆☆) \n", + "(**提示**: ```np.tile```)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": true, + "id": "44FFB3BC499C4CE3AFD4B81B2EBADD1E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.tile( np.array([[0,1],[1,0]]), (4,4))\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "92086F95E7ED4E8091C40BECE2606018", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 22. 对一个```5x5```的随机矩阵做归一化(★☆☆) \n", + "(**提示**: ```(x - min) / (max - min)```)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": true, + "id": "44305FE5FF3545C1B4E80254CE276D30", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random((5,5))\n", + "# Zmax, Zmin = Z.max(), Z.min()\n", + "# Z = (Z - Zmin)/(Zmax - Zmin)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "31DDD5EC850B456C8ED766880CB032B1", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 23. 创建一个将颜色描述为(RGBA)四个无符号字节的自定义```dtype```？(★☆☆) \n", + "(**提示**: ```np.dtype```)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": true, + "id": "F5033802C2EC41768FA02565B2116391", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# color = np.dtype([(\"r\", np.ubyte, 1),\n", + "# (\"g\", np.ubyte, 1),\n", + "# (\"b\", np.ubyte, 1),\n", + "# (\"a\", np.ubyte, 1)])\n", + "# color" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "90D1829F563F4B338D9C333B0A5E6F06", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 24. 一个```5x3```的矩阵与一个```3x2```的矩阵相乘，实矩阵乘积是什么？ (★☆☆) \n", + "(**提示**: ```np.dot | @```)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": true, + "id": "E5F4646106CD449DB590BE25CD6FBF27", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.dot(np.ones((5,3)), np.ones((3,2)))\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2BC071A5CE5448D28C1A9FDEE2D02F4E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 25. 给定一个一维数组，对其在3到8之间的所有元素取反 (★☆☆) \n", + "(**提示**: ```>, <=```)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true, + "id": "23E937FDBAE043FAB0192B316A6D6F3E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(11)\n", + "# Z[(3 < Z) & (Z <= 8)] *= -1\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A72EC713523C4CEF97ADA412621678D5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 26. 下面脚本运行后的结果是什么? (★☆☆) \n", + "(**提示**: np.sum)\n", + "```python\n", + "print(sum(range(5),-1))\n", + "from numpy import *\n", + "print(sum(range(5),-1))\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true, + "id": "519A129944AC4CF58C6985F559BC3881", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(sum(range(5),-1))" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": true, + "id": "EDD3AF4393074CF98A5B2754552443BE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# from numpy import *\n", + "# print(sum(range(5),-1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "42932F8259944D7E80D5C79D8B38A320", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 27. 考虑一个整数向量Z,下列表达合法的是哪个? (★☆☆)\n", + "```python\n", + "Z**Z\n", + "2 << Z >> 2\n", + "Z <- Z\n", + "1j*Z\n", + "Z/1/1\n", + "ZZ\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": true, + "id": "E99C3DCEB8FB4200AA60D4DCF22EB2A8", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(5)\n", + "# Z ** Z # legal" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": true, + "id": "D81A330CCEA2479E8E781EA468D3C68A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(5)\n", + "# 2 << Z >> 2 # false" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": true, + "id": "E1E168B997BE48ED8ED1AA507D5BC20C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(5)\n", + "# Z <- Z # legal" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": true, + "id": "A72D8CF7DBA14202830DDE74AC0FDFAF", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(5)\n", + "# 1j*Z # legal" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": true, + "id": "BB7023C33FA6455C89362695EACC78F4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(5)\n", + "# Z/1/1 # legal" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": true, + "id": "90BF25CACF044F6F8937CC226A1E781A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(5)\n", + "# ZZ # false" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AFDD8E04D3C2492CA81547489A2FB3FD", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 28. 下列表达式的结果分别是什么?(★☆☆) \n", + "```python\n", + "np.array(0) / np.array(0)\n", + "np.array(0) // np.array(0)\n", + "np.array([np.nan]).astype(int).astype(float)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": true, + "id": "A719B41935824F908DFE6CD47FF24B9F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.array(0) / np.array(0))" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": true, + "id": "E4EE66660AF2480B9C83C147878295E5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.array(0) // np.array(0))" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": true, + "id": "B42B92AB0C6D4F948AF26CBE383CCC67", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print(np.array([np.nan]).astype(int).astype(float))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D021C8ACC0D940DA994E073486BE2C9C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 29. 如何从零位对浮点数组做舍入 ? (★☆☆) \n", + "(**提示**: ```np.uniform, np.copysign, np.ceil, np.abs```)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": true, + "id": "D9EE837214154F149529C76396C2EE79", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.uniform(-10,+10,10)\n", + "# print (np.copysign(np.ceil(np.abs(Z)), Z))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "06D7AFD7163D49BC8C20348EA26C54C9", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 30. 如何找到两个数组中的共同元素? (★☆☆) \n", + "(**提示**: ```np.intersect1d```)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": true, + "id": "D2A344B9FCC94DDCBB82EC94CE3DD668", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z1 = np.random.randint(0,10,10)\n", + "# Z2 = np.random.randint(0,10,10)\n", + "# print(np.intersect1d(Z1,Z2))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1573CCEE2F754648879030F4866898B9", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 31. 如何忽略所有的 ```numpy``` 警告(尽管不建议这么做)? (★☆☆) \n", + "(**提示**: ```np.seterr, np.errstate```)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9D273F962459416BB206C0F93F2F8D08", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "```python\n", + "# Suicide mode on\n", + "defaults = np.seterr(all=\"ignore\")\n", + "Z = np.ones(1) / 0\n", + "\n", + "# Back to sanity\n", + "_ = np.seterr(**defaults)\n", + "\n", + "An equivalent way, with a context manager:\n", + "\n", + "with np.errstate(divide='ignore'):\n", + " Z = np.ones(1) / 0\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C513CAD2620F417FAD6D8859C3AF1883", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 32. 下面的表达式是正确的吗? (★☆☆) \n", + "(**提示**: imaginary number)\n", + "```python\n", + "np.sqrt(-1) == np.emath.sqrt(-1)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": true, + "id": "7B70B61A32D04CF68CDD1D44A0C2C19B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# np.sqrt(-1) == np.emath.sqrt(-1) # False" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A45D7F283E0B456E81829DDEF2E13FE5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 33. 如何得到昨天，今天，明天的日期? (★☆☆) \n", + "(**提示**: ```np.datetime64, np.timedelta64```)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": true, + "id": "031F2BA107374ED6837FCAC6F96884E5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')\n", + "# today = np.datetime64('today', 'D')\n", + "# tomorrow = np.datetime64('today', 'D') + np.timedelta64(1, 'D')\n", + "# print (\"Yesterday is \" + str(yesterday))\n", + "# print (\"Today is \" + str(today))\n", + "# print (\"Tomorrow is \"+ str(tomorrow))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9DDDA7EE921A4674B754BB8E40F1CCAE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 34. 如何得到所有与2016年7月对应的日期？ (★★☆) \n", + "(**提示**: ```np.arange(dtype=datetime64['D'])```)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": true, + "id": "B937D12F01784CFE84E214718F9A3CBC", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange('2016-07', '2016-08', dtype='datetime64[D]')\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AAC83583B8EC400687E5505ECAE0E435", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 35. 如何直接在位计算```(A+B)\\*(-A/2)```(不建立副本)? (★★☆) \n", + "(**提示**: ```np.add(out=), np.negative(out=), np.multiply(out=), np.divide(out=)```)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": true, + "id": "E686188C9965478DBCA16C3FF4853052", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.ones(3)*1\n", + "# B = np.ones(3)*2\n", + "# C = np.ones(3)*3\n", + "# np.add(A,B,out=B)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": true, + "id": "AA936812BA394FA187A4B3B17581AB23", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# np.divide(A,2,out=A)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "collapsed": true, + "id": "929DE1B8AA494C76B855CC88ACBAAF48", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# np.negative(A,out=A)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "collapsed": true, + "id": "FDA87EC072CD4B9A907321B926C41407", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# np.multiply(A,B,out=A)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "502537DCE0AA46E387883CF90133D718", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 36. 用五种不同的方法去提取一个随机数组的整数部分(★★☆) \n", + "(**提示**: ```%, np.floor, np.ceil, astype, np.trunc```)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "collapsed": true, + "id": "A58464DF10D34B8A8BFA134D44C9CF56", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.uniform(0,10,10)\n", + "\n", + "# print (Z - Z%1)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "collapsed": true, + "id": "6B2201271C154961B7928E1EFF540CBB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print (np.floor(Z))" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "collapsed": true, + "id": "58363BA8D19D4BC2A578159905B71B46", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print (np.ceil(Z)-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "collapsed": true, + "id": "6745FA7466464D18BE4FDBAC96EEA98D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print (Z.astype(int))" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "collapsed": true, + "id": "5543995A0FD14D378AD7CA4F84D621E6", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print (np.trunc(Z))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E9BC7D19D7214712BEBECE1FBA90C5B4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 37. 创建一个```5x5```的矩阵，其中每行的数值范围从0到4 (★★☆) \n", + "(**提示**: ```np.arange```)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": true, + "id": "F046ACCD114749428AD0A7AD10DF76E8", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.zeros((5,5))\n", + "# Z += np.arange(5)\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "011C9D30472C49438273D09B10DE1257", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 38. 通过考虑一个可生成10个整数的函数，来构建一个数组(★☆☆) \n", + "(**提示**: ```np.fromiter```)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "collapsed": true, + "id": "B19FAA5F434E4770B56B36D8EACEF3ED", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# def generate():\n", + "# for x in range(10):\n", + "# yield x\n", + "# Z = np.fromiter(generate(),dtype=float,count=-1)\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "29274F560F6244E2832804107CD1BDD5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 39. 创建一个长度为10的随机向量，其值域范围从0到1，但是不包括0和1 (★★☆) \n", + "(**提示**: ```np.linspace```)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "collapsed": true, + "id": "EE10F710B4F844FC81A16EF7777F229B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.linspace(0,1,11,endpoint=False)[1:]\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F8583210BCF048B9B313B36BEEC4DE67", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 40. 创建一个长度为10的随机向量，并将其排序 (★★☆) \n", + "(**提示**: ```sort```)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "collapsed": true, + "id": "CBFC87DACC404D6289933C746DFC0735", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random(10)\n", + "# Z.sort()\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C19BB964416F4F7586F1996ABC00373E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 41.对于一个小数组，如何用比 ```np.sum```更快的方式对其求和？(★★☆) \n", + "(**提示**: ```np.add.reduce```)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "collapsed": true, + "id": "47573260DA734DA7A9C654D6DC754C49", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(10)\n", + "# np.add.reduce(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0AA3A2F5B19F47A19318A13D5888FC99", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 42. 对于两个随机数组A和B，检查它们是否相等(★★☆) \n", + "(**提示**: ```np.allclose, np.array_equal```)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "collapsed": true, + "id": "1448EB4CCEF54A9BB5C6CDECCBC556B5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.random.randint(0,2,5)\n", + "# B = np.random.randint(0,2,5)\n", + "# # Assuming identical shape of the arrays and a tolerance for the comparison of values\n", + "# equal = np.allclose(A,B)\n", + "# print(equal)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "collapsed": true, + "id": "A9479E221501459597EA782EA19CB7C2", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# # Checking both the shape and the element values, no tolerance (values have to be exactly equal)\n", + "# equal = np.array_equal(A,B)\n", + "# print(equal)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "19B0C351B16F4FE6A88CAA9F8845EA8A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 43. 创建一个只读数组(read-only) (★★☆) \n", + "(**提示**: ```flags.writeable```)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B7E6E1870CAB44BC8209B4C5501FE767", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "```python\n", + "# 使用如下过程实现\n", + "Z = np.zeros(10)\n", + "Z.flags.writeable = False\n", + "Z[0] = 1\n", + "---------------------------------------------------------------------------\n", + "ValueError Traceback (most recent call last)\n", + " in ()\n", + " 1 Z = np.zeros(10)\n", + " 2 Z.flags.writeable = False\n", + "----> 3 Z[0] = 1\n", + "\n", + "ValueError: assignment destination is read-only\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "98DFC2521652463589FF8DDAF36B08FE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 44. 将笛卡尔坐标下的一个```10x2```的矩阵转换为极坐标形式(★★☆) \n", + "(**hint**: ```np.sqrt, np.arctan2```)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "collapsed": true, + "id": "CF88855CE1504CC1BC1C867605DA8BB7", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random((10,2))\n", + "# X,Y = Z[:,0], Z[:,1]\n", + "# R = np.sqrt(X**2+Y**2)\n", + "# T = np.arctan2(Y,X)\n", + "# print (R)\n", + "# print (T)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D07B13CEE9B24B9B88165ADF6CBA7401", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 45. 创建一个长度为10的向量，并将向量中最大值替换为1 (★★☆) \n", + "(**提示**: ```argmax```)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "collapsed": true, + "id": "3AE6B7B7914149238A6A28CD0A8DAA9E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random(10)\n", + "# Z[Z.argmax()] = 0\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0F820B0DF2E14655890CD971AE0272D3", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 46. 创建一个结构化数组，并实现 `x` 和 `y` 坐标覆盖 ```[0,1]x[0,1]``` 区域 (★★☆) \n", + "(**提示**: ```np.meshgrid```)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "collapsed": true, + "id": "7BD9ED6C246544858EB94CB9F785A150", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.zeros((5,5), [('x',float),('y',float)])\n", + "# Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5),\n", + "# np.linspace(0,1,5))\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "73EEF9858D8E4A828272CCC7BCE20A43", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 47. 给定两个数组```X```和```Y```，构造Cauchy矩阵C ```(Cij =1/(xi - yj))```\n", + "(**提示**: ```np.subtract.outer```)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": true, + "id": "C9BCA7FFCB8544838CE8DD8524844817", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# X = np.arange(8)\n", + "# Y = X + 0.5\n", + "# C = 1.0 / np.subtract.outer(X, Y)\n", + "# print(np.linalg.det(C))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FC59A059DD094F4BB5CDC4E229958AED", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 48. 打印每个numpy标量类型的最小值和最大值？ (★★☆) \n", + "(**提示**: ```np.iinfo, np.finfo, eps```)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "collapsed": true, + "id": "F4575981070D41FA8983FB07431CB87A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# for dtype in [np.int8, np.int32, np.int64]:\n", + "# print(np.iinfo(dtype).min)\n", + "# print(np.iinfo(dtype).max)\n", + "\n", + "# for dtype in [np.float32, np.float64]:\n", + "# print(np.finfo(dtype).min)\n", + "# print(np.finfo(dtype).max)\n", + "# print(np.finfo(dtype).eps)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DF957A2129FB4636A8F47A765DF0F96F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 49. 如何打印一个数组中的所有数值? (★★☆) \n", + "(**提示**: ```np.set_printoptions```)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "collapsed": true, + "id": "56EA8BE07DE04A0D847D4FC7FD545A76", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# np.set_printoptions(threshold=np.nan)\n", + "# Z = np.zeros((16,16))\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4CDD8B8C9AB94302813674249668C14C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 50. 给定标量时，如何找到数组中最接近标量的值？(★★☆) \n", + "(**提示**: ```argmin```)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "collapsed": true, + "id": "04BC778A88C14ABF83B1C9B99F9D32BF", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(100)\n", + "# v = np.random.uniform(0,100)\n", + "# index = (np.abs(Z-v)).argmin()\n", + "# print (Z[index])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B8BDE1CC85E749D4B1F5AAFDC6969810", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 51. 创建一个表示位置```(x,y)```和颜色```(r,g,b)```的结构化数组(★★☆) \n", + "(**提示**: ```dtype```)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "collapsed": true, + "id": "46DA786D707840318F1B9FDFE16644C1", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.zeros(10, [ ('position', [ ('x', float, 1),\n", + "# ('y', float, 1)]),\n", + "# ('color', [ ('r', float, 1),\n", + "# ('g', float, 1),\n", + "# ('b', float, 1)])])\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DC2A897ACBBE4659BF4490F0BD2A35C3", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 52. 对一个表示坐标形状为(100,2)的随机向量，找到点与点的距离(★★☆) \n", + "(**提示**: ```np.atleast_2d, T, np.sqrt)```" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "collapsed": true, + "id": "0595F131624F49E6859D0BA252FEA44D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.random((10,2))\n", + "# X,Y = np.atleast_2d(Z[:,0], Z[:,1])\n", + "# D = np.sqrt( (X-X.T)**2 + (Y-Y.T)**2)\n", + "# print (D)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "collapsed": true, + "id": "AF5E882D646C46148A8E8FF0AA90A0B7", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# # Much faster with scipy\n", + "# import scipy\n", + "# # Thanks Gavin Heverly-Coulson (#issue 1)\n", + "# import scipy.spatial\n", + "# D = scipy.spatial.distance.cdist(Z,Z)\n", + "# print (D)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6E021C635941407CB99EF6A4460868D8", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 53. 如何将32位的浮点数(```float```)转换为对应的整数(```integer```)?\n", + "(**提示**: ```astype(copy=False)```)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "collapsed": true, + "id": "F3A776074F42411588D1B8840BD6CE57", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(10, dtype=np.int32)\n", + "# Z = Z.astype(np.float32, copy=False)\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A89E8C46EA4C4E0C8C27BEB4B808A7F9", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 54. 如何读取以下文件? (★★☆) \n", + "(**提示**: ```np.genfromtxt```)\n", + "```\n", + "1, 2, 3, 4, 5\n", + "6, , , 7, 8\n", + " , , 9,10,11\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "00C8C0828A6B4DE2A052A818919776B2", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "[参考链接](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.genfromtxt.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3662D893F84D4B858513A1F791715312", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 55. 对于```numpy```数组，```enumerate```的等价操作是什么？(★★☆) \n", + "(**提示**: ```np.ndenumerate, np.ndindex```)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "collapsed": true, + "id": "36A349A837E64D2381C729EDB4E4A1BB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(9).reshape(3,3)\n", + "# for index, value in np.ndenumerate(Z):\n", + "# print (index, value)\n", + "# for index in np.ndindex(Z.shape):\n", + "# print (index, Z[index])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1D801ED8F53849EE81F60F1A5776D82E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 56. 生成一个通用的二维Gaussian-like数组 (★★☆) \n", + "(**提示**: ```np.meshgrid, np.exp```)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "collapsed": true, + "id": "E1271CD7CDF34116B788E66270DA72C6", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# X, Y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))\n", + "# D = np.sqrt(X*X+Y*Y)\n", + "# sigma, mu = 1.0, 0.0\n", + "# G = np.exp(-( (D-mu)**2 / ( 2.0 * sigma**2 ) ) )\n", + "# print (G)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5C1DE8E188344B098F39502676745D7D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 57. 对一个二维数组，如何在其内部随机放置p个元素? (★★☆) \n", + "(**提示**: ```np.put, np.random.choice```)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "collapsed": true, + "id": "9E8F022F3F3A421480674F7EAF8C1107", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# n = 10\n", + "# p = 3\n", + "# Z = np.zeros((n,n))\n", + "# np.put(Z, np.random.choice(range(n*n), p, replace=False),1)\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A42E45EE8E304C1D85385AA71201FBC4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 58. 减去一个矩阵中的每一行的平均值 (★★☆) \n", + "(**提示**: ```mean(axis=,keepdims=)```)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "collapsed": true, + "id": "210C23C0A0D143EE85BF270AB24F4DD4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# X = np.random.rand(5, 10)\n", + "# # Recent versions of numpy\n", + "# Y = X - X.mean(axis=1, keepdims=True)\n", + "# print(Y)" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "collapsed": true, + "id": "3371E9CC8B774089B2260A1C7FFDF5BE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# # Older versions of numpy\n", + "# Y = X - X.mean(axis=1).reshape(-1, 1)\n", + "# print (Y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BFA3974BCF20453E8E00E5BF14BC518C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 59. 如何通过第n列对一个数组进行排序? (★★☆) \n", + "(**提示**: ```argsort```)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "collapsed": true, + "id": "B7D468144A3A416183BB1D6B14A610B2", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,10,(3,3))\n", + "# print (Z)\n", + "# print (Z[Z[:,1].argsort()])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "713E4E4CBCD44A5D83B206C137D9298A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 60. 如何检查一个二维数组是否有空列？(★★☆) \n", + "(**提示**: ```any, ~```)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "collapsed": true, + "id": "D0E560F6FC584924887B5C25A0B9E8C5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,3,(3,10))\n", + "# print ((~Z.any(axis=0)).any())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FC3FB413C733428F85D2AB6442725294", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 61. 从数组中的给定值中找出最近的值 (★★☆) \n", + "(**提示**: ```np.abs, argmin, flat```)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "collapsed": true, + "id": "6E66FB7429FF4362800B4FB1841A32B9", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.uniform(0,1,10)\n", + "# z = 0.5\n", + "# m = Z.flat[np.abs(Z - z).argmin()]\n", + "# print (m)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "02011498C99B4AF79D366C5CCCCFB38F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 62. 如何用迭代器(```iterator```)计算两个分别具有形状(1,3)和(3,1)的数组? (★★☆) \n", + "(**提示**: ```np.nditer```)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "collapsed": true, + "id": "85402397D0104B8A9EDC13F937E5D11B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.arange(3).reshape(3,1)\n", + "# B = np.arange(3).reshape(1,3)\n", + "# it = np.nditer([A,B,None])\n", + "# for x,y,z in it: \n", + "# z[...] = x + y\n", + "# print (it.operands[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4E73DA4B7DD9411497461196A53C90DE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 63. 创建一个具有```name```属性的数组类(★★☆) \n", + "(**提示**: ```class```方法)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "collapsed": true, + "id": "A4FAF12305F14E559772A9AB42221E18", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# class NamedArray(np.ndarray):\n", + "# def __new__(cls, array, name=\"no name\"):\n", + "# obj = np.asarray(array).view(cls)\n", + "# obj.name = name\n", + "# return obj\n", + "# def __array_finalize__(self, obj):\n", + "# if obj is None: return\n", + "# self.info = getattr(obj, 'name', \"no name\")\n", + "\n", + "# Z = NamedArray(np.arange(10), \"range_10\")\n", + "# print (Z.name)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "56B6FBD96064483F83863B10A1630960", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 64. 考虑一个给定的向量，如何对由第二个向量索引的每个元素加1(小心重复的索引)? (★★★) \n", + "(**提示**: ```np.bincount | np.add.at```)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "collapsed": true, + "id": "B99FB5DF5268466F8E8EED615084EB09", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.ones(10)\n", + "# I = np.random.randint(0,len(Z),20)\n", + "# Z += np.bincount(I, minlength=len(Z))\n", + "# print(Z)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "collapsed": true, + "id": "A7E8FD80E3A443358EF5C0E6CF945660", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# np.add.at(Z, I, 1)\n", + "# print(Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "630A718A56DF45C68AC2219FE95D19BB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 65. 根据索引列表(```I```)，如何将向量(```X```)的元素累加到数组(```F```)? (★★★) \n", + "(**提示**: ```np.bincount```)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "collapsed": true, + "id": "D5017E1D87B3474482F376AB7CE2DFCA", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# X = [1,2,3,4,5,6]\n", + "# I = [1,3,9,3,4,1]\n", + "# F = np.bincount(I,X)\n", + "# print (F)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4A2A3596690B402E80C41EA04CD710AE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 66. 考虑一个```(dtype=ubyte)``` 的 ```(w,h,3)```图像，计算其唯一颜色的数量(★★★) \n", + "(**提示**: ```np.unique```)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "collapsed": true, + "id": "95A3B6B3C68A42188EB76A502A3C510F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# w,h = 16,16\n", + "# I = np.random.randint(0,2,(h,w,3)).astype(np.ubyte)\n", + "# #Note that we should compute 256*256 first. \n", + "# #Otherwise numpy will only promote F.dtype to 'uint16' and overfolw will occur\n", + "# F = I[...,0]*(256*256) + I[...,1]*256 +I[...,2]\n", + "# n = len(np.unique(F))\n", + "# print (n)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FEF1B9D441DC416B868659E8ABB02D98", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 67. 考虑一个四维数组，如何一次性计算出最后两个轴(```axis```)的和？ (★★★) \n", + "(**提示**: ```sum(axis=(-2,-1))```)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "collapsed": true, + "id": "C2F3794A1772409EAD83C123C5DDFEEC", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.random.randint(0,10,(3,4,3,4))\n", + "# # solution by passing a tuple of axes (introduced in numpy 1.7.0)\n", + "# sum = A.sum(axis=(-2,-1))\n", + "# print (sum)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "collapsed": true, + "id": "A7F12DAF75C240ED91C7FD7BD21EC923", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# sum = A.reshape(A.shape[:-2] + (-1,)).sum(axis=-1)\n", + "# print (sum)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "22DA1FE2380649F5897037716C3C3FDB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 68. 考虑一个一维向量```D```，如何使用相同大小的向量```S```来计算```D```子集的均值？(★★★) \n", + "(**提示**: ```np.bincount```)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "collapsed": true, + "id": "BEDF3326F7694F1A89F62E88C6A56A76", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# D = np.random.uniform(0,1,100)\n", + "# S = np.random.randint(0,10,100)\n", + "# D_sums = np.bincount(S, weights=D)\n", + "# D_counts = np.bincount(S)\n", + "# D_means = D_sums / D_counts\n", + "# print (D_means)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "collapsed": true, + "id": "4A7CB0F23BCB41E8828E483652E1A8F0", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# import pandas as pd\n", + "# print(pd.Series(D).groupby(S).mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F53232053DF742718EF3063B7A0FD0EB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 69. 如何获得点积 ```dot prodcut```的对角线? (★★★) \n", + "(**提示**: ```np.diag```)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "collapsed": true, + "id": "EBBAFF692F744180A99B6E6F301A8E0D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.random.uniform(0,1,(5,5))\n", + "# B = np.random.uniform(0,1,(5,5))\n", + "# # slow version\n", + "# np.diag(np.dot(A, B))" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "collapsed": true, + "id": "084693AF2B1C4F3DAC05E4D0D0343958", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## 方法2\n", + "# # Fast version\n", + "# np.sum(A * B.T, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": { + "collapsed": true, + "id": "1A9C15379DF9405FB6328AD66511C088", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## 方法3\n", + "# # Faster version\n", + "# np.einsum(\"ij,ji->i\", A, B)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "48EE054F54744FEC9300AD56BC62C8D7", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 70. 考虑一个向量```[1,2,3,4,5]```,如何建立一个新的向量，在这个新向量中每个值之间有3个连续的零？(★★★) \n", + "(**提示**: ```array[::4]```)" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "collapsed": true, + "id": "1CBB573916834CD18073236E24383F47", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.array([1,2,3,4,5])\n", + "# nz = 3\n", + "# Z0 = np.zeros(len(Z) + (len(Z)-1)*(nz))\n", + "# Z0[::nz+1] = Z\n", + "# print (Z0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "56D0343C2EFA4AA79407D5D219AE9C34", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 71. 考虑一个维度(5,5,3)的数组，如何将其与一个(5,5)的数组相乘？(★★★) \n", + "(**提示**: ```array[:, :, None]```)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "collapsed": true, + "id": "9D21F03160F041B9A9CFDAC5BFA8283A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.ones((5,5,3))\n", + "# B = 2*np.ones((5,5))\n", + "# print (A * B[:,:,None])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FF1121B68753430CB7BE9B0C30EE1D32", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 72. 如何对一个数组中任意两行做交换? (★★★) \n", + "(**提示**: ```array[[]] = array[[]]```)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": { + "collapsed": true, + "id": "3DB1AC9EFA7D4FB48D3E104C567AB7D3", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.arange(25).reshape(5,5)\n", + "# A[[0,1]] = A[[1,0]]\n", + "# print (A)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2E7011A162D342FF892C94E5B2C82AF0", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 73. 考虑一个可以描述10个三角形的triplets，找到可以分割全部三角形的line segment \n", + "Consider a set of 10 triplets describing 10 triangles (with shared vertices), find the set of unique line segments composing all the triangles (★★★) \n", + "(**提示**: ```repeat, np.roll, np.sort, view, np.unique```)" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "collapsed": true, + "id": "1F68365590154613B7E8011A52625300", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# faces = np.random.randint(0,100,(10,3))\n", + "# F = np.roll(faces.repeat(2,axis=1),-1,axis=1)\n", + "# F = F.reshape(len(F)*3,2)\n", + "# F = np.sort(F,axis=1)\n", + "# G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )\n", + "# G = np.unique(G)\n", + "# print (G)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C4A2F864E6B24BA8A70FF32ED8CEF305", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 74. 给定一个二进制的数组```C```，如何产生一个数组```A```满足```np.bincount(A)==C```(★★★) \n", + "(**提示**: ```np.repeat```)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": { + "collapsed": true, + "id": "C3DA4B9685B24058A7DC2E670A1CADCF", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# C = np.bincount([1,1,2,3,4,4,6])\n", + "# A = np.repeat(np.arange(len(C)), C)\n", + "# print (A)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B12FD13D314349848DCC7E6C8D86DF0F", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 75. 如何通过滑动窗口计算一个数组的平均数? (★★★) \n", + "(**提示**: ```np.cumsum```)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": { + "collapsed": true, + "id": "BE7A3F46F37B43C9BE869FB5E1AE7C8D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# def moving_average(a, n=3) :\n", + "# ret = np.cumsum(a, dtype=float)\n", + "# ret[n:] = ret[n:] - ret[:-n]\n", + "# return ret[n - 1:] / n\n", + "# Z = np.arange(20)\n", + "\n", + "# print(moving_average(Z, n=3))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AFB78198A1D4414E8632CB88C305AD8A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 76. Consider a one-dimensional array Z, build a two-dimensional array whose first row is (Z\\[0\\],Z\\[1\\],Z\\[2\\]) and each subsequent row is shifted by 1 (last row should be (Z\\[-3\\],Z\\[-2\\],Z\\[-1\\]) (★★★) \n", + "(**提示**: ```from numpy.lib import stride_tricks```)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "collapsed": true, + "id": "24F51BFDF35845C6B71FEF2F66A63FFE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# from numpy.lib import stride_tricks\n", + "\n", + "# def rolling(a, window):\n", + "# shape = (a.size - window + 1, window)\n", + "# strides = (a.itemsize, a.itemsize)\n", + "# return stride_tricks.as_strided(a, shape=shape, strides=strides)\n", + "# Z = rolling(np.arange(10), 3)\n", + "\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "07D09F00B9274F09B1A1A2438EF502E4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 77. 如何对布尔值取反，或者原位(```in-place```)改变浮点数的符号(```sign```)？(★★★) \n", + "(**提示**: ```np.logical_not, np.negative```)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "collapsed": true, + "id": "1FF18DB3A6CD407983035E26C7DDC642", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,2,100)\n", + "# np.logical_not(Z, out=Z)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": { + "collapsed": true, + "id": "F2A7772989C9479A84D3281A9BDA4250", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.uniform(-1.0,1.0,100)\n", + "# np.negative(Z, out=Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F7238C25E1324E59B49A8246E0E1803D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 78. 考虑两组点集```P0```和```P1```去描述一组线(二维)和一个点```p```,如何计算点```p```到每一条线 i ```(P0[i],P1[i])```的距离？(★★★)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": { + "collapsed": true, + "id": "2BE011F6ABE94E589F06CD32FD642C78", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# def distance(P0, P1, p):\n", + "# T = P1 - P0\n", + "# L = (T**2).sum(axis=1)\n", + "# U = -((P0[:,0]-p[...,0])*T[:,0] + (P0[:,1]-p[...,1])*T[:,1]) / L\n", + "# U = U.reshape(len(U),1)\n", + "# D = P0 + U*T - p\n", + "# return np.sqrt((D**2).sum(axis=1))\n", + "\n", + "# P0 = np.random.uniform(-10,10,(10,2))\n", + "# P1 = np.random.uniform(-10,10,(10,2))\n", + "# p = np.random.uniform(-10,10,( 1,2))\n", + "\n", + "# print (distance(P0, P1, p))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "313AF7F2B08D483F8DCAA199F0B647E3", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 79.考虑两组点集```P0```和```P1```去描述一组线(二维)和一组点集```P```，如何计算每一个点 ```j(P[j])``` 到每一条线 i ```(P0[i],P1[i]) ```的距离？(★★★)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": { + "collapsed": true, + "id": "7C553C37C29C4080A48701D6042FDA31", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # based on distance function from previous question\n", + "# P0 = np.random.uniform(-10, 10, (10,2))\n", + "# P1 = np.random.uniform(-10,10,(10,2))\n", + "# p = np.random.uniform(-10, 10, (10,2))\n", + "# print (np.array([distance(P0,P1,p_i) for p_i in p]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "405F07374A264727A590D94970B97AE5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 80.Consider an arbitrary array, write a function that extract a subpart with a fixed shape and centered on a given element (pad with a `fill` value when necessary) (★★★) \n", + "(**hint**: minimum, maximum)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": { + "collapsed": true, + "id": "BAC016239FC347B486DD5AC4DA506AAE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,10,(10,10))\n", + "# shape = (5,5)\n", + "# fill = 0\n", + "# position = (1,1)\n", + "\n", + "# R = np.ones(shape, dtype=Z.dtype)*fill\n", + "# P = np.array(list(position)).astype(int)\n", + "# Rs = np.array(list(R.shape)).astype(int)\n", + "# Zs = np.array(list(Z.shape)).astype(int)\n", + "\n", + "# R_start = np.zeros((len(shape),)).astype(int)\n", + "# R_stop = np.array(list(shape)).astype(int)\n", + "# Z_start = (P-Rs//2)\n", + "# Z_stop = (P+Rs//2)+Rs%2\n", + "\n", + "# R_start = (R_start - np.minimum(Z_start,0)).tolist()\n", + "# Z_start = (np.maximum(Z_start,0)).tolist()\n", + "# R_stop = np.maximum(R_start, (R_stop - np.maximum(Z_stop-Zs,0))).tolist()\n", + "# Z_stop = (np.minimum(Z_stop,Zs)).tolist()\n", + "\n", + "# r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]\n", + "# z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]\n", + "# R[r] = Z[z]\n", + "# print (Z)\n", + "# print (R)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C9E524EE9063410582419C615ED27AA0", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 81. 考虑一个数组```Z = [1,2,3,4,5,6,7,8,9,10,11,12,13,14]```,如何生成一个数组```R = [[1,2,3,4], [2,3,4,5], [3,4,5,6], ...,[11,12,13,14]]```? (★★★) \n", + "(**提示**: ```stride_tricks.as_strided```)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": { + "collapsed": true, + "id": "43CDF04FE2394915A059DD1BB4C901EE", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(1,15,dtype=np.uint32)\n", + "# R = stride_tricks.as_strided(Z,(11,4),(4,4))\n", + "# print (R)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E2D036A1A89743EF9AD4C674B94FAD85", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 82. 计算一个矩阵的秩(★★★) \n", + "(**提示**: ```np.linalg.svd```)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": { + "collapsed": true, + "id": "BCA339C5EA214E1E8E2CD7E83EC987DB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.uniform(0,1,(10,10))\n", + "# U, S, V = np.linalg.svd(Z) # Singular Value Decomposition\n", + "# rank = np.sum(S > 1e-10)\n", + "# print (rank)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E25CC326657644A080330F9C5D37FC86", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 83. 如何找到一个数组中出现频率最高的值？ \n", + "(**提示**: ```np.bincount, argmax```)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": { + "collapsed": true, + "id": "733C7593D0AF41938CA9CC3B456AE6F5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,10,50)\n", + "# print (np.bincount(Z).argmax())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A07EC615196149998A779CC23A664A7D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 84. 从一个```10x10```的矩阵中提取出连续的```3x3```区块(★★★) \n", + "(**提示**: ```stride_tricks.as_strided```)" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": { + "collapsed": true, + "id": "C6FF080800EF4CCA86BA7C46C2A0A4CF", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,5,(10,10))\n", + "# n = 3\n", + "# i = 1 + (Z.shape[0]-3)\n", + "# j = 1 + (Z.shape[1]-3)\n", + "# C = stride_tricks.as_strided(Z, shape=(i, j, n, n), strides=Z.strides + Z.strides)\n", + "# print (C)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "943C8A7CF29E4CBB98951A553E84EAE4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 85. 创建一个满足 ```Z[i,j] == Z[j,i]```的子类 (★★★) \n", + "(**提示**: ```class``` 方法)" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": { + "collapsed": true, + "id": "FB5B4EE1E960470485E204AB682E507E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# class Symetric(np.ndarray):\n", + "# def __setitem__(self, index, value):\n", + "# i,j = index\n", + "# super(Symetric, self).__setitem__((i,j), value)\n", + "# super(Symetric, self).__setitem__((j,i), value)\n", + "\n", + "# def symetric(Z):\n", + "# return np.asarray(Z + Z.T - np.diag(Z.diagonal())).view(Symetric)\n", + "\n", + "# S = symetric(np.random.randint(0,10,(5,5)))\n", + "# S[2,3] = 42\n", + "# print (S)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "60BB1B061FDA489D85A87463BB7A7B8D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 86. 考虑p个 ```nxn``` 矩阵和一组形状为```(n,1)```的向量，如何直接计算p个矩阵的乘积```(n,1)```？(★★★) \n", + "(**提示**: ```np.tensordot```)" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": { + "collapsed": true, + "id": "D6E9B8A3B69E41698447586FCF1E3B76", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# p, n = 10, 20\n", + "# M = np.ones((p,n,n))\n", + "# V = np.ones((p,n,1))\n", + "# S = np.tensordot(M, V, axes=[[0, 2], [0, 1]])\n", + "# print (S)\n", + "# It works, because:\n", + "# M is (p,n,n)\n", + "# V is (p,n,1)\n", + "# Thus, summing over the paired axes 0 and 0 (of M and V independently),\n", + "# and 2 and 1, to remain with a (n,1) vector." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E298E26CA8FC4D0A87CE17B3C8ED448A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 87. 对于一个```16x16```的数组，如何得到一个区域(```block-sum```)的和(区域大小为```4x4```)? (★★★) \n", + "(**提示**: ```np.add.reduceat```)" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "collapsed": true, + "id": "B2B86B64BD1D4BA081132EFF55494EEF", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.ones((16,16))\n", + "# k = 4\n", + "# S = np.add.reduceat(np.add.reduceat(Z, np.arange(0, Z.shape[0], k), axis=0),\n", + "# np.arange(0, Z.shape[1], k), axis=1)\n", + "# print (S)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9733DB33A4FE41FA9B7A28BA6D9BA323", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 88. 如何利用```numpy```数组实现Game of Life? (★★★)\n", + "(**提示**: [Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life))" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": { + "collapsed": true, + "id": "B2F6FEF7398549F68F4281BC20B41165", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# def iterate(Z):\n", + "# # Count neighbours\n", + "# N = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +\n", + "# Z[1:-1,0:-2] + Z[1:-1,2:] +\n", + "# Z[2: ,0:-2] + Z[2: ,1:-1] + Z[2: ,2:])\n", + "\n", + "# # Apply rules\n", + "# birth = (N==3) & (Z[1:-1,1:-1]==0)\n", + "# survive = ((N==2) | (N==3)) & (Z[1:-1,1:-1]==1)\n", + "# Z[...] = 0\n", + "# Z[1:-1,1:-1][birth | survive] = 1\n", + "# return Z\n", + "\n", + "# Z = np.random.randint(0,2,(50,50))\n", + "# for i in range(100): Z = iterate(Z)\n", + "# print (Z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "05F350A2ECBF46928879CD5EC729C4C7", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 89. 如何找到一个数组的第n个最大值? (★★★) \n", + "(**提示**: ```np.argsort | np.argpartition```)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "collapsed": true, + "id": "AD514F23AA6A499D8FA7065841F72613", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.arange(10000)\n", + "# np.random.shuffle(Z)\n", + "# n = 5\n", + "\n", + "# # Slow\n", + "# print (Z[np.argsort(Z)[-n:]])" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": { + "collapsed": true, + "id": "203F24EA60A44E2580965FCFE02C757D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# # Fast\n", + "# print (Z[np.argpartition(-Z,n)[:n]])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A6B0BF5FA1EC4CAF9F77C9C2F503107A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 90. 给定任意个数向量，创建笛卡尔积(每一个元素的每一种组合)(★★★) \n", + "(**提示**: ```np.indices```)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "collapsed": true, + "id": "46D4E9E4169541228B2C40FF1CDBFA12", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# def cartesian(arrays):\n", + "# arrays = [np.asarray(a) for a in arrays]\n", + "# shape = (len(x) for x in arrays)\n", + "\n", + "# ix = np.indices(shape, dtype=int)\n", + "# ix = ix.reshape(len(arrays), -1).T\n", + "\n", + "# for n, arr in enumerate(arrays):\n", + "# ix[:, n] = arrays[n][ix[:, n]]\n", + "\n", + "# return ix\n", + "\n", + "# print (cartesian(([1, 2, 3], [4, 5], [6, 7])))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3D5B5652447848408AE38668828F97C9", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 91. 如何从一个正常数组创建记录数组(```record array```)? (★★★) \n", + "(**提示**: ```np.core.records.fromarrays```)" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": { + "collapsed": true, + "id": "82BEB0A109B149429DDC53232F28D63A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.array([(\"Hello\", 2.5, 3),\n", + "# (\"World\", 3.6, 2)])\n", + "# R = np.core.records.fromarrays(Z.T, \n", + "# names='col1, col2, col3',\n", + "# formats = 'S8, f8, i8')\n", + "# print (R)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D60D5195C1CA4ACE87B2B82D8C21D606", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 92. 考虑一个大向量```Z```, 用三种不同的方法计算它的立方(★★★) \n", + "(**提示**: ```np.power, \\*, np.einsum```)" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": { + "collapsed": true, + "id": "8519DE17751C4C6B859AEB7A94616D4C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# x = np.random.rand()\n", + "# np.power(x,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": { + "collapsed": true, + "id": "023FFA04A61143878DC019D3475C847B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## 方法2\n", + "# x*x*x" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": { + "collapsed": true, + "id": "7F81104DAA2144368256477522F8E454", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## 方法3\n", + "# np.einsum('i,i,i->i',x,x,x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4D83EC574DF24D0F8DE19E9A91F096A4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 93. 考虑两个形状分别为```(8,3)``` 和```(2,2)```的数组```A```和```B```. 如何在数组```A```中找到满足包含```B```中元素的行？(不考虑```B```中每行元素顺序)？ (★★★) \n", + "(**提示**: ```np.where```)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": { + "collapsed": true, + "id": "06950269DCDF40E384834AE6F7D9D57E", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.random.randint(0,5,(8,3))\n", + "# B = np.random.randint(0,5,(2,2))\n", + "\n", + "# C = (A[..., np.newaxis, np.newaxis] == B)\n", + "# rows = np.where(C.any((3,1)).all(1))[0]\n", + "# print (rows)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "50B173E09BE44D7B93B901D9915605C5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 94. 考虑一个```10x3```的矩阵，分解出有不全相同值的行 (如 ```[2,2,3]```) (★★★)" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": { + "collapsed": true, + "id": "67B07B2780C84116B8B3E114AA3F5D92", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,5,(10,3))\n", + "# print (Z)\n", + "\n", + "# # solution for arrays of all dtypes (including string arrays and record arrays)\n", + "# E = np.all(Z[:,1:] == Z[:,:-1], axis=1)\n", + "# U = Z[~E]\n", + "# print (U)" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": { + "collapsed": true, + "id": "839AFE04281D430F84C10A037AEF405C", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# # soluiton for numerical arrays only, will work for any number of columns in Z\n", + "# U = Z[Z.max(axis=1) != Z.min(axis=1),:]\n", + "# print (U)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3C438C79FF2442C18959B015D50B0382", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 95. 将一个整数向量转换为matrix binary的表现形式 (★★★) \n", + "(**提示**: ```np.unpackbits```)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": { + "collapsed": true, + "id": "646F659946404BDA9AFFE725EA9E4018", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128])\n", + "# B = ((I.reshape(-1,1) & (2**np.arange(8))) != 0).astype(int)\n", + "# print(B[:,::-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": { + "collapsed": true, + "id": "067120D1D7034D9F817F06128D79E9E9", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# # 方法2\n", + "# print (np.unpackbits(I[:, np.newaxis], axis=1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6B62627DE43347D29A80C9B864A53DDA", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 96. 给定一个二维数组，如何提取出唯一的(```unique```)行?(★★★) \n", + "(**提示**: ```np.ascontiguousarray```)" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": { + "collapsed": true, + "id": "9924218AF0644D8F93B01208B6807F03", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Z = np.random.randint(0,2,(6,3))\n", + "# T = np.ascontiguousarray(Z).view(np.dtype((np.void, Z.dtype.itemsize * Z.shape[1])))\n", + "# _, idx = np.unique(T, return_index=True)\n", + "# uZ = Z[idx]\n", + "# print (uZ)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5A3738CBA4A349508E7C9F22B5F7166A", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 97. 考虑两个向量```A```和```B```，写出用```einsum```等式对应的```inner, outer, sum, mul```函数(★★★) \n", + "(**提示**: [```np.einsum```](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.einsum.html))" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": { + "collapsed": true, + "id": "8E01F6B983C2426D9217504C83EEE486", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# A = np.random.uniform(0,1,10)\n", + "# B = np.random.uniform(0,1,10)\n", + "# print ('sum')\n", + "# print (np.einsum('i->', A))# np.sum(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": { + "collapsed": true, + "id": "69115798B9A044258DF261C172A4458B", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print ('A * B')\n", + "# print (np.einsum('i,i->i', A, B)) # A * B" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": { + "collapsed": true, + "id": "02C2196DF276469E82B5F6EA24340250", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print ('inner')\n", + "# print (np.einsum('i,i', A, B)) # np.inner(A, B)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "collapsed": true, + "id": "DB99E8D722E442A89B4D782003EE53F6", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# print ('outer')\n", + "# print (np.einsum('i,j->ij', A, B)) # np.outer(A, B)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "85C64AA83A824194816B708D36AB7E69", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 98. 考虑一个由两个向量描述的路径```(X,Y)```，如何用等距样例(```equidistant samples```)对其进行采样(```sample```)? (★★★) \n", + "Considering a path described by two vectors (X,Y), how to sample it using equidistant samples \n", + "(**提示**: ```np.cumsum, np.interp```)" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": { + "collapsed": true, + "id": "B2CEA801F0164EEA854FBD8F684CA507", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# phi = np.arange(0, 10*np.pi, 0.1)\n", + "# a = 1\n", + "# x = a*phi*np.cos(phi)\n", + "# y = a*phi*np.sin(phi)\n", + "\n", + "# dr = (np.diff(x)**2 + np.diff(y)**2)**.5 # segment lengths\n", + "# r = np.zeros_like(x)\n", + "# r[1:] = np.cumsum(dr) # integrate path\n", + "# r_int = np.linspace(0, r.max(), 200) # regular spaced path\n", + "# x_int = np.interp(r_int, r, x) # integrate path\n", + "# y_int = np.interp(r_int, r, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D5D0E40627A4435184C3813B775A14E5", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 99. Given an integer n and a 2D array X, select from X the rows which can be interpreted as draws from a multinomial distribution with n degrees, i.e., the rows which only contain integers and which sum to n. (★★★) \n", + "(**提示**: ```np.logical_and.reduce, np.mod```)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": { + "collapsed": true, + "id": "1C245E3CFF7D4EFF9913B886A0E8F7DB", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# X = np.asarray([[1.0, 0.0, 3.0, 8.0],\n", + "# [2.0, 0.0, 1.0, 1.0],\n", + "# [1.5, 2.5, 1.0, 0.0]])\n", + "# n = 4\n", + "# M = np.logical_and.reduce(np.mod(X, 1) == 0, axis=-1)\n", + "# M &= (X.sum(axis=-1) == n)\n", + "# print (X[M])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4A31C1F39DE44234BAF2F12720FEE07D", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "#### 100. 对于一个一维数组```X```，计算它boostrapped之后的95%置信区间的平均值。\n", + "(Compute bootstrapped 95% confidence intervals for the mean of a 1D array X，i.e. resample the elements of an array with replacement N times, compute the mean of each sample, and then compute percentiles over the means). (★★★) \n", + "(**提示**: ```np.percentile```)" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "collapsed": true, + "id": "DFF4185E7EF1432D87EE695C4A972C39", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# X = np.random.randn(100) # random 1D array\n", + "# N = 1000 # number of bootstrap samples\n", + "# idx = np.random.randint(0, X.size, (N, X.size))\n", + "# means = X[idx].mean(axis=1)\n", + "# confint = np.percentile(means, [2.5, 97.5])\n", + "# print (confint)" + ] + } + ], + "metadata": { + "hide_input": false, + "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.5.2" + }, + "toc": { + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "toc_cell": false, + "toc_position": {}, + "toc_section_display": "block", + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/练习题-Pandas.ipynb b/练习题-Pandas.ipynb new file mode 100644 index 0000000..e7da1d8 --- /dev/null +++ b/练习题-Pandas.ipynb @@ -0,0 +1,4328 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "B37A5E9D1472412A8A2348BCCD338B86", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "Pandas 是基于 NumPy 的一种数据处理工具，该工具为了解决数据分析任务而创建。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的函数和方法。\n", + "这些练习着重DataFrame和Series对象的基本操作，包括数据的索引、分组、统计和清洗。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "408E7D614FB54B1D84A7B0A848C4C6F6", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 基本操作" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EBBA275C49F24BAC8D5369F0674D34C6", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "1. 导入 Pandas 库并简写为 `pd`，并输出版本号" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "id": "DC71C3CB19FA450D9A22B0501097C7D9", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.24.2'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "pd.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4BDAA047C88D4A7284FBB11C93331AF5", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "2.从列表创建 Series" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "id": "A3CE42AFF0F846F4831E88F2E4C5459B", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0\n", + "1 1\n", + "2 2\n", + "3 3\n", + "4 4\n", + "dtype: int64" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr = [0, 1, 2, 3, 4]\r\n", + "df = pd.Series(arr) # 如果不指定索引，则默认从 0 开始\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "042776A6C0144F8785E71383B58BEBAC", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "3.从字典创建 Series" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "id": "F910769AB5F64648A25447A3785E82BF", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "a 1\n", + "b 2\n", + "c 3\n", + "d 4\n", + "e 5\n", + "dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d = {'a':1,'b':2,'c':3,'d':4,'e':5}\r\n", + "df = pd.Series(d)\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "36D50B633631470282A0E6323A76D2ED", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "4.从 NumPy 数组创建 DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "id": "43B11711239D40A6843D5CD1D3880030", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABCD
2020-11-25 19:52:19.649803-2.030876-1.268538-0.558541-0.900418
2020-11-26 19:52:19.649803-1.527629-0.7034450.1017520.847650
2020-11-27 19:52:19.6498031.778669-0.7268400.1798890.900710
2020-11-28 19:52:19.6498030.6321840.1564820.865383-1.155356
2020-11-29 19:52:19.6498030.0928940.157272-1.733493-1.259203
2020-11-30 19:52:19.649803-1.9374390.120771-1.964980-1.700180
\n", + "
" + ], + "text/plain": [ + " A B C D\n", + "2020-11-25 19:52:19.649803 -2.030876 -1.268538 -0.558541 -0.900418\n", + "2020-11-26 19:52:19.649803 -1.527629 -0.703445 0.101752 0.847650\n", + "2020-11-27 19:52:19.649803 1.778669 -0.726840 0.179889 0.900710\n", + "2020-11-28 19:52:19.649803 0.632184 0.156482 0.865383 -1.155356\n", + "2020-11-29 19:52:19.649803 0.092894 0.157272 -1.733493 -1.259203\n", + "2020-11-30 19:52:19.649803 -1.937439 0.120771 -1.964980 -1.700180" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dates = pd.date_range('today',periods=6) # 定义时间序列作为 index\r\n", + "num_arr = np.random.randn(6,4) # 传入 numpy 随机数组\r\n", + "columns = ['A','B','C','D'] # 将列表作为列名\r\n", + "df1 = pd.DataFrame(num_arr, index = dates, columns = columns)\r\n", + "df1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D7D785E5CA3C497C8C4765D984432CD8", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "5.从CSV中创建 DataFrame，分隔符为`;`，编码格式为`gbk`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "id": "4F16DA0868BF484A85F9E690ADD9E4AD", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# df = pd.read_csv('test.csv', encoding='gbk, sep=';')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2E270529EBA14E9583C308DFBED813F0", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "6.从字典对象`data`创建DataFrame，设置索引为`labels`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "id": "4C7745E1545D40A4B1DF01B9FACAB322", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\r\n", + "\r\n", + "data = {'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],\r\n", + " 'age': [2.5, 3, 0.5, np.nan, 5, 2, 4.5, np.nan, 7, 3],\r\n", + " 'visits': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\r\n", + " 'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}\r\n", + "\r\n", + "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "id": "E2097C5B292B484A97D18AE44387A1A2", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
a2.5catyes1
b3.0catyes3
c0.5snakeno2
dNaNdogyes3
e5.0dogno2
f2.0catno3
g4.5snakeno1
hNaNcatyes1
i7.0dogno2
j3.0dogno1
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "a 2.5 cat yes 1\n", + "b 3.0 cat yes 3\n", + "c 0.5 snake no 2\n", + "d NaN dog yes 3\n", + "e 5.0 dog no 2\n", + "f 2.0 cat no 3\n", + "g 4.5 snake no 1\n", + "h NaN cat yes 1\n", + "i 7.0 dog no 2\n", + "j 3.0 dog no 1" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(data, index=labels)\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D1973CA623394A5F8C3F356AD4D5F98B", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "7.显示DataFrame的基础信息，包括行的数量；列名；每一列值的数量、类型" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "id": "704A3A9393CA4C3BBFC4382B2AC013ED", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Index: 10 entries, a to j\n", + "Data columns (total 4 columns):\n", + "age 8 non-null float64\n", + "animal 10 non-null object\n", + "priority 10 non-null object\n", + "visits 10 non-null int64\n", + "dtypes: float64(1), int64(1), object(2)\n", + "memory usage: 400.0+ bytes\n" + ] + } + ], + "source": [ + "df.info()\r\n", + "# 方法二\r\n", + "# df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ABD97C9AF1AF4F808D803BC99DDB42A0", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "8.展示`df`的前3行" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "id": "174EEA3F312E492B8194DB974137AC9F", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
a2.5catyes1
b3.0catyes3
c0.5snakeno2
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "a 2.5 cat yes 1\n", + "b 3.0 cat yes 3\n", + "c 0.5 snake no 2" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.iloc[:3]\r\n", + "# 方法二\r\n", + "#df.head(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C746F0B208A544F8869B7BEA45C0D604", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "9.取出`df`的`animal`和`age`列" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "id": "5C0327B056874AB3A61AA67A0700D026", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
animalage
acat2.5
bcat3.0
csnake0.5
ddogNaN
edog5.0
fcat2.0
gsnake4.5
hcatNaN
idog7.0
jdog3.0
\n", + "
" + ], + "text/plain": [ + " animal age\n", + "a cat 2.5\n", + "b cat 3.0\n", + "c snake 0.5\n", + "d dog NaN\n", + "e dog 5.0\n", + "f cat 2.0\n", + "g snake 4.5\n", + "h cat NaN\n", + "i dog 7.0\n", + "j dog 3.0" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[:, ['animal', 'age']]\r\n", + "# 方法二\r\n", + "# df[['animal', 'age']]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A7C3AECC6B4C418683E826866F2A00BF", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "10.取出索引为`[3, 4, 8]`行的`animal`和`age`列" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "id": "28628128E7AD42A28F2235E36E81DC82", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
animalage
ddogNaN
edog5.0
idog7.0
\n", + "
" + ], + "text/plain": [ + " animal age\n", + "d dog NaN\n", + "e dog 5.0\n", + "i dog 7.0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df.index[[3, 4, 8]], ['animal', 'age']]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0DC73A3BAEE1471488F497ADAAECE9A4", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "11.取出`age`值大于3的行" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "id": "5F6C4EBC5CAB46868AB9B6752AFE51B1", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
e5.0dogno2
g4.5snakeno1
i7.0dogno2
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "e 5.0 dog no 2\n", + "g 4.5 snake no 1\n", + "i 7.0 dog no 2" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df['age'] > 3]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B58686B7272F471A8C3CA3BBABF8CFDB", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "12.取出`age`值缺失的行" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "id": "88C1B731BFB646EAA76E284E472AA440", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
dNaNdogyes3
hNaNcatyes1
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "d NaN dog yes 3\n", + "h NaN cat yes 1" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df['age'].isnull()]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4F4812626E7F491CAF83EB425A452595", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "13.取出`age`在2,4间的行（不含）" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false, + "id": "C8CEA4CE37984E0783711C683257CCBA", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
a2.5catyes1
b3.0catyes3
j3.0dogno1
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "a 2.5 cat yes 1\n", + "b 3.0 cat yes 3\n", + "j 3.0 dog no 1" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[(df['age']>2) & (df['age']<4)]\n", + "# 方法二\n", + "#df[df['age'].between(2, 4)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EC4A3E47A9F94C94BC1EA9BD25CB2AC3", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "14.`f`行的`age`改为1.5" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "id": "749484D2F77E4F6A8C03820E772432DE", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "df.loc['f', 'age'] = 1.5" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4785E429ACA04385835A814AFF4F59A0", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "15.计算`visits`的总和" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false, + "id": "37AD6C06B30947428FF7DDD1F7C39838", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "19" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['visits'].sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "512DCEC2028848C89E03A41E555A167E", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "16.计算每个不同种类`animal`的`age`的平均数" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "id": "31E587F50D69457ABC853375B8CBE1AF", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "animal\n", + "cat 2.333333\n", + "dog 5.000000\n", + "snake 2.500000\n", + "Name: age, dtype: float64" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby('animal')['age'].mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F1C3C328E8624CE5B6B93BAFE03652D8", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "17.计算`df`中每个种类`animal`的数量" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false, + "id": "E085A0DFC1F94C749D3234D0F86ABCBA", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "cat 4\n", + "dog 4\n", + "snake 2\n", + "Name: animal, dtype: int64" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['animal'].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C242DEBB812846F592335C1CEDD7DBE7", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "18.先按`age`降序排列，后按`visits`升序排列" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false, + "id": "1743410F4F2E4AA48DA1BAD60AAEFFB6", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
i7.0dogno2
e5.0dogno2
g4.5snakeno1
j3.0dogno1
b3.0catyes3
a2.5catyes1
f1.5catno3
c0.5snakeno2
hNaNcatyes1
dNaNdogyes3
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "i 7.0 dog no 2\n", + "e 5.0 dog no 2\n", + "g 4.5 snake no 1\n", + "j 3.0 dog no 1\n", + "b 3.0 cat yes 3\n", + "a 2.5 cat yes 1\n", + "f 1.5 cat no 3\n", + "c 0.5 snake no 2\n", + "h NaN cat yes 1\n", + "d NaN dog yes 3" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sort_values(by=['age', 'visits'], ascending=[False, True])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8DAC0489BCF345D18722936760521D10", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "19.将`priority`列中的`yes, no`替换为布尔值`True, False`" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false, + "id": "7AC076FE991A4A7C86C270465AEEC2A5", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
a2.5catTrue1
b3.0catTrue3
c0.5snakeFalse2
dNaNdogTrue3
e5.0dogFalse2
f1.5catFalse3
g4.5snakeFalse1
hNaNcatTrue1
i7.0dogFalse2
j3.0dogFalse1
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "a 2.5 cat True 1\n", + "b 3.0 cat True 3\n", + "c 0.5 snake False 2\n", + "d NaN dog True 3\n", + "e 5.0 dog False 2\n", + "f 1.5 cat False 3\n", + "g 4.5 snake False 1\n", + "h NaN cat True 1\n", + "i 7.0 dog False 2\n", + "j 3.0 dog False 1" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['priority'] = df['priority'].map({'yes': True, 'no': False})\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "011AD6B2DB3F4FF68B6BF78C17606F13", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "20.将`animal`列中的`snake`替换为`python`" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false, + "id": "BB3E112D297445688FF0BBD9A7EE7E27", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
a2.5catTrue1
b3.0catTrue3
c0.5pythonFalse2
dNaNdogTrue3
e5.0dogFalse2
f1.5catFalse3
g4.5pythonFalse1
hNaNcatTrue1
i7.0dogFalse2
j3.0dogFalse1
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "a 2.5 cat True 1\n", + "b 3.0 cat True 3\n", + "c 0.5 python False 2\n", + "d NaN dog True 3\n", + "e 5.0 dog False 2\n", + "f 1.5 cat False 3\n", + "g 4.5 python False 1\n", + "h NaN cat True 1\n", + "i 7.0 dog False 2\n", + "j 3.0 dog False 1" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['animal'] = df['animal'].replace('snake', 'python')\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3BA3F97990E346A5836836864EB4FFB8", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "21.对每种`animal`的每种不同数量`visits`，计算平均`age`，即，返回一个表格，行是`aniaml`种类，列是`visits`数量，表格值是行动物种类列访客数量的平均年龄" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false, + "id": "AF5A8AAAB4884450B89A9544B40DD4ED", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "age float64\n", + "animal object\n", + "priority bool\n", + "visits int64\n", + "dtype: object" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.dtypes" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false, + "id": "83C7501AF44F47AA8E5258652FDF9988", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "df.age=df.age.astype(float)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false, + "id": "E784D19B88B3426498F0B41FCC4290C6", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
visits123
animal
cat2.5NaN2.25
dog3.06.0NaN
python4.50.5NaN
\n", + "
" + ], + "text/plain": [ + "visits 1 2 3\n", + "animal \n", + "cat 2.5 NaN 2.25\n", + "dog 3.0 6.0 NaN\n", + "python 4.5 0.5 NaN" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.pivot_table(index='animal', columns='visits', values='age', aggfunc='mean')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "54EC83F0A5AC41D88DEB3D986A9F608C", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "22.在`df`中插入新行`k`，然后删除该行" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false, + "id": "8CCB1591219B4CA983EEF993924C726C", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageanimalpriorityvisits
a2.5catTrue1
b3.0catTrue3
c0.5pythonFalse2
dNaNdogTrue3
e5.0dogFalse2
f1.5catFalse3
g4.5pythonFalse1
hNaNcatTrue1
i7.0dogFalse2
j3.0dogFalse1
\n", + "
" + ], + "text/plain": [ + " age animal priority visits\n", + "a 2.5 cat True 1\n", + "b 3.0 cat True 3\n", + "c 0.5 python False 2\n", + "d NaN dog True 3\n", + "e 5.0 dog False 2\n", + "f 1.5 cat False 3\n", + "g 4.5 python False 1\n", + "h NaN cat True 1\n", + "i 7.0 dog False 2\n", + "j 3.0 dog False 1" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#插入\r\n", + "df.loc['k'] = [5.5, 'dog', 'no', 2]\r\n", + "# 删除\r\n", + "df = df.drop('k')\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E4BF6769090045D9BBAA73B83A6D0304", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 进阶操作" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EC5E11D6D5E745CA888128DC64E933B9", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "23.有一列整数列`A`的DatraFrame，删除数值重复的行" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false, + "id": "E64946439A524AF8817063EF7C3B9AC3", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " A\n", + "0 1\n", + "1 2\n", + "2 2\n", + "3 3\n", + "4 4\n", + "5 5\n", + "6 5\n", + "7 5\n", + "8 6\n", + "9 7\n", + "10 7\n", + " A\n", + "0 1\n", + "1 2\n", + "3 3\n", + "4 4\n", + "5 5\n", + "8 6\n", + "9 7\n" + ] + } + ], + "source": [ + "df = pd.DataFrame({'A': [1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7]})\n", + "print(df)\n", + "df1 = df.loc[df['A'].shift() != df['A']]\n", + "# 方法二\n", + "# df1 = df.drop_duplicates(subset='A')\n", + "print(df1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "52EF04D119B045D29071C0635CBF854D", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "24.一个全数值DatraFrame，每个数字减去该行的平均数" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false, + "id": "50FEE2500BC64CBA8EB44425860DAA9C", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1 2\n", + "0 0.414453 0.332157 0.856186\n", + "1 0.163896 0.089443 0.593890\n", + "2 0.526212 0.781033 0.299327\n", + "3 0.405021 0.890150 0.575210\n", + "4 0.516062 0.485737 0.584763\n", + " 0 1 2\n", + "0 -0.119812 -0.202108 0.321921\n", + "1 -0.118514 -0.192967 0.311480\n", + "2 -0.009312 0.245509 -0.236198\n", + "3 -0.218440 0.266689 -0.048250\n", + "4 -0.012792 -0.043117 0.055909\n" + ] + } + ], + "source": [ + "df = pd.DataFrame(np.random.random(size=(5, 3)))\n", + "print(df)\n", + "df1 = df.sub(df.mean(axis=1), axis=0)\n", + "print(df1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "935456754362412684F8A7DB2BB264DE", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "25.一个有5列的DataFrame，求哪一列的和最小" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false, + "id": "81B9F18E6DD94167B6D304E54DBBE7BD", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " a b c d e\n", + "0 0.497311 0.702727 0.317818 0.246678 0.761391\n", + "1 0.757598 0.135243 0.023186 0.181558 0.360602\n", + "2 0.002264 0.116232 0.221348 0.717638 0.289913\n", + "3 0.048115 0.909258 0.013615 0.080099 0.722705\n", + "4 0.138972 0.687775 0.540898 0.306161 0.444953\n" + ] + }, + { + "data": { + "text/plain": [ + "'c'" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(np.random.random(size=(5, 5)), columns=list('abcde'))\n", + "print(df)\n", + "df.sum().idxmin()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7418298827EF4DE18D88D79ABEE3389C", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "26.给定DataFrame，求`A`列每个值的前3大的`B`的和" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false, + "id": "E3316FCA37B04ECF94808EACA6702994", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " A B\n", + "0 a 12\n", + "1 a 345\n", + "2 a 3\n", + "3 b 1\n", + "4 b 45\n", + "5 c 14\n", + "6 a 4\n", + "7 a 52\n", + "8 b 54\n", + "9 c 23\n", + "10 c 235\n", + "11 c 21\n", + "12 b 57\n", + "13 b 3\n", + "14 c 87\n", + "A\n", + "a 409\n", + "b 156\n", + "c 345\n", + "Name: B, dtype: int64\n" + ] + } + ], + "source": [ + "df = pd.DataFrame({'A': list('aaabbcaabcccbbc'), \r\n", + " 'B': [12,345,3,1,45,14,4,52,54,23,235,21,57,3,87]})\r\n", + "print(df)\r\n", + "df1 = df.groupby('A')['B'].nlargest(3).sum(level=0)\r\n", + "print(df1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "42417D37787F4199A3A7B4E35F691433", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "27.给定DataFrame，有列`A, B`，`A`的值在1-100（含），对`A`列每10步长，求对应的`B`的和" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false, + "id": "226877047B334FC7A3F075152E048FF6", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " A B\n", + "0 1 1\n", + "1 2 2\n", + "2 11 11\n", + "3 11 11\n", + "4 33 33\n", + "5 34 34\n", + "6 35 35\n", + "7 40 40\n", + "8 79 79\n", + "9 99 99\n", + "A\n", + "(0, 10] 3\n", + "(10, 20] 22\n", + "(20, 30] 0\n", + "(30, 40] 142\n", + "(40, 50] 0\n", + "(50, 60] 0\n", + "(60, 70] 0\n", + "(70, 80] 79\n", + "(80, 90] 0\n", + "(90, 100] 99\n", + "Name: B, dtype: int64\n" + ] + } + ], + "source": [ + "df = pd.DataFrame({'A': [1,2,11,11,33,34,35,40,79,99], \r\n", + " 'B': [1,2,11,11,33,34,35,40,79,99]})\r\n", + "print(df)\r\n", + "df1 = df.groupby(pd.cut(df['A'], np.arange(0, 101, 10)))['B'].sum()\r\n", + "print(df1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4A41563F4E83421E99DC691CDCBF1B5F", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "28.给定DataFrame，计算每个元素至左边最近的`0`（或者至开头）的距离，生成新列`y`" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false, + "id": "83E7FDD067C546ED8FC7260C12CB49D4", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " X Y\n", + "0 7 1\n", + "1 2 2\n", + "2 0 0\n", + "3 3 1\n", + "4 4 2\n", + "5 2 3\n", + "6 5 4\n", + "7 0 0\n", + "8 3 1\n", + "9 4 2\n" + ] + } + ], + "source": [ + "df = pd.DataFrame({'X': [7, 2, 0, 3, 4, 2, 5, 0, 3, 4]})\n", + "\n", + "izero = np.r_[-1, (df['X'] == 0).to_numpy().nonzero()[0]] # 标记0的位置\n", + "idx = np.arange(len(df))\n", + "df['Y'] = idx - izero[np.searchsorted(izero - 1, idx) - 1]\n", + "print(df)\n", + "\n", + "# 方法二\n", + "# x = (df['X'] != 0).cumsum()\n", + "# y = x != x.shift()\n", + "# df['Y'] = y.groupby((y != y.shift()).cumsum()).cumsum()\n", + "\n", + "# 方法三\n", + "# df['Y'] = df.groupby((df['X'] == 0).cumsum()).cumcount()\n", + "#first_zero_idx = (df['X'] == 0).idxmax()\n", + "# df['Y'].iloc[0:first_zero_idx] += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C6EFAC00D81F4F629784CC2C59AAC6AB", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "29.一个全数值的DataFrame，返回最大3值的坐标" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false, + "id": "5C3C6B1686744DAD89695A3071E6F68B", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1 2\n", + "0 0.357183 0.569268 0.115802\n", + "1 0.605917 0.881550 0.593334\n", + "2 0.830468 0.072343 0.661204\n", + "3 0.811008 0.985117 0.550789\n", + "4 0.091020 0.296938 0.421596\n" + ] + }, + { + "data": { + "text/plain": [ + "[(0, 2), (1, 1), (1, 3)]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(np.random.random(size=(5, 3)))\n", + "print(df)\n", + "df.unstack().sort_values()[-3:].index.tolist()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "175D476BB4A24A74A99286D21B6BA1A2", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "30.给定DataFrame，将负值代替为同组的平均值" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false, + "id": "553E4F00BFB44D968D1D87C4479B90D1", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " grps vals\n", + "0 a -12\n", + "1 a 345\n", + "2 a 3\n", + "3 b 1\n", + "4 b 45\n", + "5 c 14\n", + "6 a 4\n", + "7 a -52\n", + "8 b 54\n", + "9 c 23\n", + "10 c -235\n", + "11 c 21\n", + "12 b 57\n", + "13 b 3\n", + "14 c 87\n", + " grps vals\n", + "0 a 117.333333\n", + "1 a 345.000000\n", + "2 a 3.000000\n", + "3 b 1.000000\n", + "4 b 45.000000\n", + "5 c 14.000000\n", + "6 a 4.000000\n", + "7 a 117.333333\n", + "8 b 54.000000\n", + "9 c 23.000000\n", + "10 c 36.250000\n", + "11 c 21.000000\n", + "12 b 57.000000\n", + "13 b 3.000000\n", + "14 c 87.000000\n" + ] + } + ], + "source": [ + "df = pd.DataFrame({'grps': list('aaabbcaabcccbbc'), \r\n", + " 'vals': [-12,345,3,1,45,14,4,-52,54,23,-235,21,57,3,87]})\r\n", + "print(df)\r\n", + "\r\n", + "def replace(group):\r\n", + " mask = group<0\r\n", + " group[mask] = group[~mask].mean()\r\n", + " return group\r\n", + "\r\n", + "df['vals'] = df.groupby(['grps'])['vals'].transform(replace)\r\n", + "print(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "531D55E9C6104DD68D133D310A9C6ADF", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "31.计算3位滑动窗口的平均值，忽略NAN" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false, + "id": "FB5B855534524B3185737D4B9840F377", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " group value\n", + "0 a 1.0\n", + "1 a 2.0\n", + "2 b 3.0\n", + "3 b NaN\n", + "4 a 2.0\n", + "5 b 3.0\n", + "6 b NaN\n", + "7 b 1.0\n", + "8 a 7.0\n", + "9 b 3.0\n", + "10 a NaN\n", + "11 b 8.0\n" + ] + }, + { + "data": { + "text/plain": [ + "0 1.000000\n", + "1 1.500000\n", + "2 3.000000\n", + "3 3.000000\n", + "4 1.666667\n", + "5 3.000000\n", + "6 3.000000\n", + "7 2.000000\n", + "8 3.666667\n", + "9 2.000000\n", + "10 4.500000\n", + "11 4.000000\n", + "Name: value, dtype: float64" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame({'group': list('aabbabbbabab'),\r\n", + " 'value': [1, 2, 3, np.nan, 2, 3, np.nan, 1, 7, 3, np.nan, 8]})\r\n", + "print(df)\r\n", + "\r\n", + "g1 = df.groupby(['group'])['value']\r\n", + "g2 = df.fillna(0).groupby(['group'])['value'] \r\n", + "\r\n", + "s = g2.rolling(3, min_periods=1).sum() / g1.rolling(3, min_periods=1).count()\r\n", + "\r\n", + "s.reset_index(level=0, drop=True).sort_index() " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0F3BEA0769BA46EE9663284836B66CBC", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## Series 和 Datetime索引" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C2D533ADDA924DCA8D6F0738301A925C", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "32.创建Series `s`，将2015所有工作日作为随机值的索引" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false, + "id": "D0C59B606E07405280B76B7BAA0D4DDA", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2015-01-01 0.896401\n", + "2015-01-02 0.789480\n", + "2015-01-05 0.271381\n", + "2015-01-06 0.740503\n", + "2015-01-07 0.241424\n", + "2015-01-08 0.644122\n", + "2015-01-09 0.599708\n", + "2015-01-12 0.714903\n", + "2015-01-13 0.285152\n", + "2015-01-14 0.574001\n", + "Freq: B, dtype: float64" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dti = pd.date_range(start='2015-01-01', end='2015-12-31', freq='B') \r\n", + "s = pd.Series(np.random.rand(len(dti)), index=dti)\r\n", + "\r\n", + "s.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5EE211F6B1384974BB98801E9D7F4FE7", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "33.所有礼拜三的值求和" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false, + "id": "2608EBB1A445402E823F8DB819B99022", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "27.08213095254659" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s[s.index.weekday == 2].sum() " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "358A1965800B4B4D8A018A4C70B70FB5", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "34.求每个自然月的平均数" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false, + "id": "DE356545760A481E8E164FF508569B1F", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2015-01-31 0.474092\n", + "2015-02-28 0.421380\n", + "2015-03-31 0.676973\n", + "2015-04-30 0.427968\n", + "2015-05-31 0.638426\n", + "2015-06-30 0.561239\n", + "2015-07-31 0.536794\n", + "2015-08-31 0.500563\n", + "2015-09-30 0.548050\n", + "2015-10-31 0.592157\n", + "2015-11-30 0.467826\n", + "2015-12-31 0.548842\n", + "Freq: M, dtype: float64" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.resample('M').mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5FDC751CEE534FDE9854536036EB49F5", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "35.每连续4个月为一组，求最大值所在的日期" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false, + "id": "93F635653DD14D29B7166D896B7F02E9", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2015-01-31 2015-01-01\n", + "2015-05-31 2015-03-11\n", + "2015-09-30 2015-07-03\n", + "2016-01-31 2015-11-23\n", + "Freq: 4M, dtype: datetime64[ns]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.groupby(pd.Grouper(freq='4M')).idxmax()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "521B75EA73834A02AD0C21929A503AB3", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "36.创建2015-2016每月第三个星期四的序列" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false, + "id": "06CC1162D5BC4D348F579609DDA184DC", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "DatetimeIndex(['2015-01-15', '2015-02-19', '2015-03-19', '2015-04-16',\n", + " '2015-05-21', '2015-06-18', '2015-07-16', '2015-08-20',\n", + " '2015-09-17', '2015-10-15', '2015-11-19', '2015-12-17',\n", + " '2016-01-21', '2016-02-18', '2016-03-17', '2016-04-21',\n", + " '2016-05-19', '2016-06-16', '2016-07-21', '2016-08-18',\n", + " '2016-09-15', '2016-10-20', '2016-11-17', '2016-12-15'],\n", + " dtype='datetime64[ns]', freq='WOM-3THU')" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.date_range('2015-01-01', '2016-12-31', freq='WOM-3THU')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0A6698CC0BE34C849855C4A507E38C17", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 数据清洗" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false, + "id": "781F1B8BEA8F43D59E5E6F31923398F9", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightNumberFrom_ToRecentDelays
0KLM(!)10045.0LoNDon_paris[23, 47]
1<Air France> (12)NaNMAdrid_miLAN[]
2(British Airways. )10065.0londON_StockhOlm[24, 43, 87]
312. Air FranceNaNBudapest_PaRis[13]
4\"Swiss Air\"10085.0Brussels_londOn[67, 32]
\n", + "
" + ], + "text/plain": [ + " Airline FlightNumber From_To RecentDelays\n", + "0 KLM(!) 10045.0 LoNDon_paris [23, 47]\n", + "1 (12) NaN MAdrid_miLAN []\n", + "2 (British Airways. ) 10065.0 londON_StockhOlm [24, 43, 87]\n", + "3 12. Air France NaN Budapest_PaRis [13]\n", + "4 \"Swiss Air\" 10085.0 Brussels_londOn [67, 32]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame({'From_To': ['LoNDon_paris', 'MAdrid_miLAN', 'londON_StockhOlm', \r\n", + " 'Budapest_PaRis', 'Brussels_londOn'],\r\n", + " 'FlightNumber': [10045, np.nan, 10065, np.nan, 10085],\r\n", + " 'RecentDelays': [[23, 47], [], [24, 43, 87], [13], [67, 32]],\r\n", + " 'Airline': ['KLM(!)', ' (12)', '(British Airways. )', \r\n", + " '12. Air France', '\"Swiss Air\"']})\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A5514B83AF294CEA9A91F4EBD70829CF", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "37.`FlightNumber`列中有些值缺失了，他们本来应该是每一行增加10，填充缺失的数值，并且令数据类型为整数" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false, + "id": "C966348861274DED830F3D0A78E72273", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightNumberFrom_ToRecentDelays
0KLM(!)10045LoNDon_paris[23, 47]
1<Air France> (12)10055MAdrid_miLAN[]
2(British Airways. )10065londON_StockhOlm[24, 43, 87]
312. Air France10075Budapest_PaRis[13]
4\"Swiss Air\"10085Brussels_londOn[67, 32]
\n", + "
" + ], + "text/plain": [ + " Airline FlightNumber From_To RecentDelays\n", + "0 KLM(!) 10045 LoNDon_paris [23, 47]\n", + "1 (12) 10055 MAdrid_miLAN []\n", + "2 (British Airways. ) 10065 londON_StockhOlm [24, 43, 87]\n", + "3 12. Air France 10075 Budapest_PaRis [13]\n", + "4 \"Swiss Air\" 10085 Brussels_londOn [67, 32]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['FlightNumber'] = df['FlightNumber'].interpolate().astype(int)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DF2998C5B9FB4C838CC6B9E8C3D69739", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "38.将`From_To`列从`_`分开，分成`From, To`两列，并删除原始列" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": false, + "id": "9C6E47AB6E4746ABAFF4A5AE4BB15C5B", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightNumberRecentDelaysFromTo
0KLM(!)10045[23, 47]LoNDonparis
1<Air France> (12)10055[]MAdridmiLAN
2(British Airways. )10065[24, 43, 87]londONStockhOlm
312. Air France10075[13]BudapestPaRis
4\"Swiss Air\"10085[67, 32]BrusselslondOn
\n", + "
" + ], + "text/plain": [ + " Airline FlightNumber RecentDelays From To\n", + "0 KLM(!) 10045 [23, 47] LoNDon paris\n", + "1 (12) 10055 [] MAdrid miLAN\n", + "2 (British Airways. ) 10065 [24, 43, 87] londON StockhOlm\n", + "3 12. Air France 10075 [13] Budapest PaRis\n", + "4 \"Swiss Air\" 10085 [67, 32] Brussels londOn" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "temp = df.From_To.str.split('_', expand=True)\r\n", + "temp.columns = ['From', 'To']\r\n", + "df = df.join(temp)\r\n", + "df = df.drop('From_To', axis=1)\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6158CB82BEFF471186E695AFCF141578", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "39.将`From, To`大小写统一" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": false, + "id": "723B7E56837A4D1AB35FB629F4EA27F7", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightNumberRecentDelaysFromTo
0KLM(!)10045[23, 47]LondonParis
1<Air France> (12)10055[]MadridMilan
2(British Airways. )10065[24, 43, 87]LondonStockholm
312. Air France10075[13]BudapestParis
4\"Swiss Air\"10085[67, 32]BrusselsLondon
\n", + "
" + ], + "text/plain": [ + " Airline FlightNumber RecentDelays From To\n", + "0 KLM(!) 10045 [23, 47] London Paris\n", + "1 (12) 10055 [] Madrid Milan\n", + "2 (British Airways. ) 10065 [24, 43, 87] London Stockholm\n", + "3 12. Air France 10075 [13] Budapest Paris\n", + "4 \"Swiss Air\" 10085 [67, 32] Brussels London" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['From'] = df['From'].str.capitalize()\r\n", + "df['To'] = df['To'].str.capitalize()\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4E3A3DA70FC34F01ACA10F535844B079", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "40.`Airline`列，有一些多余的标点符号，需要提取出正确的航司名称。举例：`'(British Airways. )'` 应该改为 `'British Airways'`." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": false, + "id": "9F9F0D09D80F4B8E837F4ABB09DBC76C", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightNumberRecentDelaysFromTo
0KLM10045[23, 47]LondonParis
1Air France10055[]MadridMilan
2British Airways10065[24, 43, 87]LondonStockholm
3Air France10075[13]BudapestParis
4Swiss Air10085[67, 32]BrusselsLondon
\n", + "
" + ], + "text/plain": [ + " Airline FlightNumber RecentDelays From To\n", + "0 KLM 10045 [23, 47] London Paris\n", + "1 Air France 10055 [] Madrid Milan\n", + "2 British Airways 10065 [24, 43, 87] London Stockholm\n", + "3 Air France 10075 [13] Budapest Paris\n", + "4 Swiss Air 10085 [67, 32] Brussels London" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['Airline'] = df['Airline'].str.extract('([a-zA-Z\\s]+)', expand=False).str.strip()\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2433A20C6E6D47E381B6EB1B738F8577", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "41.`Airline`列，数据被以列表的形式录入，但是我们希望每个数字被录入成单独一列，`delay_1, delay_2, ...`没有的用NAN替代。" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": false, + "id": "F779D702D1BD4C4082DBDF2D31BA7D57", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AirlineFlightNumberFromTodelay_1delay_2delay_3
0KLM10045LondonParis23.047.0NaN
1Air France10055MadridMilanNaNNaNNaN
2British Airways10065LondonStockholm24.043.087.0
3Air France10075BudapestParis13.0NaNNaN
4Swiss Air10085BrusselsLondon67.032.0NaN
\n", + "
" + ], + "text/plain": [ + " Airline FlightNumber From To delay_1 delay_2 \\\n", + "0 KLM 10045 London Paris 23.0 47.0 \n", + "1 Air France 10055 Madrid Milan NaN NaN \n", + "2 British Airways 10065 London Stockholm 24.0 43.0 \n", + "3 Air France 10075 Budapest Paris 13.0 NaN \n", + "4 Swiss Air 10085 Brussels London 67.0 32.0 \n", + "\n", + " delay_3 \n", + "0 NaN \n", + "1 NaN \n", + "2 87.0 \n", + "3 NaN \n", + "4 NaN " + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "delays = df['RecentDelays'].apply(pd.Series)\r\n", + "delays.columns = ['delay_{}'.format(n) for n in range(1, len(delays.columns)+1)]\r\n", + "df = df.drop('RecentDelays', axis=1).join(delays)\r\n", + "\r\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EBEC4771C87D4E94837A07FBC3D2FB86", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 层次化索引" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "365219BB0A2142F789CD512EC8DD8DA0", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "42.用 `letters = ['A', 'B', 'C']` 和 `numbers = list(range(10))`的组合作为系列随机值的层次化索引" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": false, + "id": "3941AB87138449D4839163AAA610B79B", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "A 0 0.950249\n", + " 1 0.726566\n", + " 2 0.495760\n", + " 3 0.905605\n", + "B 0 0.004121\n", + " 1 0.626741\n", + " 2 0.121265\n", + " 3 0.241187\n", + "C 0 0.595867\n", + " 1 0.840930\n", + " 2 0.102324\n", + " 3 0.354690\n", + "dtype: float64" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "letters = ['A', 'B', 'C']\r\n", + "numbers = list(range(4))\r\n", + "\r\n", + "mi = pd.MultiIndex.from_product([letters, numbers])\r\n", + "s = pd.Series(np.random.rand(12), index=mi)\r\n", + "s" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1C32A5A6E21B46438E6C74362326396E", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "43.检查`s`是否是字典顺序排序的" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": false, + "id": "A5E45FD54216448494C431702C75F220", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.index.is_lexsorted()\n", + "# 方法二\n", + "# s.index.lexsort_depth == s.index.nlevels" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "65DB246948F54D33AD898EE03C6F4194", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "44.选择二级索引为`1, 3`的行" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "collapsed": false, + "id": "DA5943E1C5774D999FA32D3DDA7C7BAD", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "A 1 0.726566\n", + " 3 0.905605\n", + "B 1 0.626741\n", + " 3 0.241187\n", + "C 1 0.840930\n", + " 3 0.354690\n", + "dtype: float64" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.loc[:, [1, 3]]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E3B271B10E514224A23D471B5B7C5F61", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "45.对`s`进行切片操作，取一级索引从头至`B`，二级索引从`2`开始到最后" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "collapsed": false, + "id": "6B626EA066FA41098A837850832D0F66", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "A 2 0.495760\n", + " 3 0.905605\n", + "B 2 0.121265\n", + " 3 0.241187\n", + "dtype: float64" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.loc[pd.IndexSlice[:'B', 2:]]\r\n", + "# 方法二\r\n", + "# s.loc[slice(None, 'B'), slice(2, None)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "63258D8A886649D899C95A837D72349C", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "46.计算每个一级索引的和（A, B, C每一个的和）" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "collapsed": false, + "id": "4942734127674CE39FBFE078DA51DF74", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "A 3.078180\n", + "B 0.993314\n", + "C 1.893810\n", + "dtype: float64" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.sum(level=0)\n", + "#方法二\n", + "#s.unstack().sum(axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3EAA26B0B98D4A078B457986919EC070", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "47.交换索引等级，新的Series是字典顺序吗？不是的话请排序" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "collapsed": false, + "id": "BA78AE9AB69240AC8B3C9E143C41A5DC", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 A 0.950249\n", + "1 A 0.726566\n", + "2 A 0.495760\n", + "3 A 0.905605\n", + "0 B 0.004121\n", + "1 B 0.626741\n", + "2 B 0.121265\n", + "3 B 0.241187\n", + "0 C 0.595867\n", + "1 C 0.840930\n", + "2 C 0.102324\n", + "3 C 0.354690\n", + "dtype: float64\n", + "False\n", + "0 A 0.950249\n", + " B 0.004121\n", + " C 0.595867\n", + "1 A 0.726566\n", + " B 0.626741\n", + " C 0.840930\n", + "2 A 0.495760\n", + " B 0.121265\n", + " C 0.102324\n", + "3 A 0.905605\n", + " B 0.241187\n", + " C 0.354690\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "new_s = s.swaplevel(0, 1)\n", + "print(new_s)\n", + "print(new_s.index.is_lexsorted())\n", + "new_s = new_s.sort_index()\n", + "print(new_s)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5947FCF045F643D58DCF2330FEFFECE2", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 可视化" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "collapsed": false, + "id": "E257843110B542A08DD732237CEB62EF", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "df = pd.DataFrame({\"xs\":[1,5,2,8,1], \"ys\":[4,2,1,9,6]})\n", + "plt.style.use('ggplot')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ABA878EB9825499883EAB997A8B0F10A", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "48.画出`df`的散点图" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "collapsed": false, + "id": "EE673BF23AAA4CAE8506223454716FAA", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.plot.scatter(\"xs\", \"ys\", color = \"black\", marker = \"x\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3571FCD0673346158D19B701FF540CD4", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "49.可视化指定4维DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "collapsed": false, + "id": "763CECD47B954A6F804898FBAFFE9BC2", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.DataFrame({\"productivity\":[5,2,3,1,4,5,6,7,8,3,4,8,9],\r\n", + " \"hours_in\" :[1,9,6,5,3,9,2,9,1,7,4,2,2],\r\n", + " \"happiness\" :[2,1,3,2,3,1,2,3,1,2,2,1,3],\r\n", + " \"caffienated\" :[0,0,1,1,0,0,0,0,1,1,0,1,0]})\r\n", + "\r\n", + "df.plot.scatter(\"hours_in\", \"productivity\", s = df.happiness * 100, c = df.caffienated)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3A18A9AE34D8418A863948333844BB7D", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "50.在同一个图中可视化2组数据，共用X轴，但y轴不同" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": false, + "id": "9089C025DDC44A74836D5A1ADB6AD5EC", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEJCAYAAACUk1DVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl4VNX9x/H3nSwkIGsihCCrihtqW8VaNwQVURZF4WjBBbRgXeqGttKfKNZ9RcCtoNXaonLAqlVUZJHaChVU6i4uCIGwJaAsCYEkc39/zEwIIXtm5s7yeT2Pj5Pkzj3fITCf+d5zz72O67qIiIj4vC5ARERigwJBREQABYKIiAQpEEREBFAgiIhIkAJBREQABYKIiAQpEEREBFAgiIhIUGoUxtBSaBGRxnGiOVg0AoF169ZFYxgRkYSRm5sb9TF1yEhERAAFgoiIBCkQREQEiNIcgojsy3VdSkpK8Pv9OE5U5w4lRriui8/nIyMjIyb+DigQRDxSUlJCWloaqan6Z5jMysrKKCkpITMz0+tSdMhIxCt+v19hIKSmpuL3+70uA1AgiHgmFg4RSGyIlb8L+ngiEeV+9yWkpOF0P9jrUmJep+mdwrq//DH5Yd2fJD51CBIxbvEO/FPuxP/wrbgb1npdjojUQR2CRIw7/5+wswgyW+D/8wP4xj+Ik96sSftszKdofVIWqR91CBIRbvEO3Pmvw8+PxzfmJli7Cnfm016XJVUMGzaMe++9l5EjRwJQUFDAyJEjGTRoEFOnTgVg9OjRFZefGTNmDPn5+Xz//fcMGzaMs846i1mzZlXs68knn2TgwIGMGjUKgOuvv541a9YA8PDDD7N48eJqx5DYoECQiAh1B75BF+IceQzOWefjvjcX/wf/8ro0qWT58uUcffTRzJgxA4CpU6cyZMgQ3njjDebOncuWLVs4++yzWbRoEaWlpWzfvp1OnTpx9913c+ONN/Laa6/xxBNP4LqBa1g2a9aMOXPmUFZWxoYNG6ods7oxJDbokJGEXeXuwOnSAwDnnItwv/0S929P4HY9CCcnvBOo0jg9e/bk7LPPrvh65cqVfPzxx8yaNYvi4mI2btxI//79GT9+PF27duWUU06p2O7hhx/GcRzKy8vZunUrABdccAEA2dnZlJaW7jVWSUlJjWO0a9cuGi9X6qAOQcLOnf96RXcQ4qSkBA4dpaXi//MDuLt3eVihhLRo0WKvr3v06MH48eOZPXs2V1xxBa1bt6Z169YAzJs3j4EDB1ZsN2nSJGbPns3FF19Menp6tftLT0+nqKiI8vJy3nvvvRrHkNigDkHCKtAd/HOv7iDEabc/vstuwD/lT7gzn8G5+CqPqoxNsTD5fc011zBu3Djuvfdeunfvzvnnnw/AKaecwosvvsjEiRMB+OMf/8i4cePYsWMHxx9/PM2bN692f0OGDGHChAl0796dbt261TqG1J8xJhV4EcgFVlhrL6tmmwHA08Cq4Lcut9auqG2/TujYXwS5uh9C8vD/80Xc11/EN+HRfQKhYpuX/4r79ss4Y27Cd9wpDdp/Ip1lVFxcXOMbqSSX6v4uBO+HUO2KNWPMMOBQa+1dxpi3gPHW2v9V2WYAcIy19u761qEOQcKmojv42b7dQWXOOSNxv/0C9/nHA/MJHaJ/IxCROPc28GawU2gDbKthu/ONMecAa4Bh1tpaO4CoBEJ2dnY0hhGP7Zj5GkU7i2h38RWk1fE7L7/lXjbfcCm+px+m3f3T6r0+YdmYZQ2uK1b//vn9fnw+TeNJzX8XjDEfVvpymrV2GoC1dkfw5x8A6621K6vZ7ffABGvtHGPMYqAPsKi2OqISCIWFhdEYRjzkFu/A/9pL8LPj2doqC+r8nafgjL6Osql3UvDE/fguqt98Qu/pvRtcmw4ZSayr6ZCRtfbY6rY3xmQBO4ATgIXGmL7W2nerbLYFmB98vApoX1cd+ngiYeEueCNwZtHgC+r9HOeo3jhnnof7r7fxL/t3BKsTSTjjgOHW2nKgGKju2tk3AhcaY3xAL+DzunaqQJAmC8wdvBacOziwQc91zr0IDjwU9/nHcDfq5AOJjrVr17Jz586ojPXNN99EYrePA5cZY5YAm4EVxpiHqmzzGDAa+AB4xVr7ZV071VlG0mT+11/C/ecL+CZManAgALhbCvD/6Xpolx243lFaeo3b6iwjaaqdO3dyzTXX8Mgjj0RlDcS4ceMYO3YshxxySI3bNPQso0hRhyBN0pTuIMRptz++0dfDmh9w7TNhrlAaq/J1iJpi5syZ+3xv4cKFLFy4sM7n1ne7hpg+fTpXXnllrWFQn3GHDRtW7fervt6JEyfGzTWbFAjSJO6CN6C4YXMH1XGO7o1z5lDcRW9pPiHBhC5+V1m/fv3o169fnc+t73YNsWLFCo49ttq52rCMW/X1tmzZktzcXPLzY7NTrUzrEKTR9nQHv2x0d1CZc+7FuN99FZhP6HogTvvkWZ/gf2k67pofwrpPp3N3fBeOqfHnxcXFXHHFFRQVFdG1a1cmTZrE2rVrueqqq2jWrFnFMfbRo0dz9913k5uby5gxY5g4cSIlJSX84Q9/oKioiMsuu4zhw4czc+ZMNmzYwAcffED//v056aSTuOmmm/j6668599xzGTlyJMOHDwf2fIoOXfvozTff5LHHHsPv9/OHP/yBvn37VrvdsGHDOPLII3n//fc59thjueeee1iyZAl33HEHzZs3p1OnTowaNYpjjjmm2te8bds2srKyKr6uWnPoKq1Vxw1dxK9Nmza0adOGW2+9FYA77rijopZbbrmFSy65pOL1nnHGGVx99dUA/PznP+eLL76gU6fYvoaXOgRptD3dwYV1b1wPTmoqvjE3Q0rwekelu8OyX6ne+vXrufjii3nhhRfIy8ujoKCAxx9/nCuvvJIXXniBbdsCa50acrXT1157jSlTpjBq1CgOOuggXn31VXr16sWrr75aEQbVmTlzJvfdd1+1h5cqW7t2Lb/61a945513WLp0KQBvvfUWd955JxdddBFHHHFEjWEAVHsz+8o11+TVV1/lueee44QTTmDIkCF07tx5n1patWq11+sNhQFAZmZm1Caxm0IdgjSKW1wU1u4gxMkKzCf4H7sT1/4FZ+Rvw7bvWFbbJ/lIycjIYPbs2cyePZutW7dSUlJCXl4ehx9+OGlpafTq1QugQVc7vfjiixu1EPDGG29k6tSplJaW8tvf1vw7b9u2Lf379wegTZs2AHTv3p377ruPZs2a8eCDD9Y6TlZWFps2bdrre/Wp+bDDDuOqq66ibdu2jB49usZaapKXl8dhhx1W6zaxQIEgjeIufD2s3UFlztG9cfoPxX3nFfw9e+HrfVLYxxCYMWMGAwYMYPDgwRUXmOvUqRMrVqygU6dOfPXVVwB7Xe009GbYo0cPJk6cSJcuXZg+fXrF1U6rO2uqvLwcANd1a7yZ/KJFi3jyySfJy8tj3LhxvPLKK9VuV/VqqgCLFy9m1qxZ9Vr1nZKSguu6FBUVVeyrPmd6rVixYp+aqqsFAkFbXFxMZmZmxetdsmQJI0aMqHMcr+mQkTSYW1yEOy/83UFlztCLocchuM9Pxd2k05Yj4ZRTTmHKlClccMEFOI7Dhg0buPLKKyu+16xZs722Xb58OV27dgX2XO30rLPOYt26dbW+qZ5zzjkMHjyY6667rsZtOnTowKBBgxgzZkzFcfv66tKlC2eccQbGGCZOnFgRQDX5zW9+wwMPPNCgMVJSUjj77LO58MILmTx5cq3bjhw5EmMMv/71r4HA/Ejv3r1JTY39z991rkMwxrQAXgCygfeBB4BXCFxQaY619pY6xtA6hATjf+Ml3NdewHfrJJyukQkEAHdzAf4/XQfZ7fHd8gBOWrrWIcg+Lr30UoqKisjMzCQzM5OpU6fuFWbVmTFjBqeffjodOnSoc/8lJSWMGDECn89HixYtyMrK4pFHHql3fZMmTeL666+vsTuC2FmHUJ9AGAtkWWvvNcbMAUqAZQSCYTmB5dO1LcVTICQQt7gI//jfwMFHkHLNrZEf75Ol+B+7C6fv2fhG/FaBIAkpVgKhPoeMdgHNjTEOkEHgYkrzrLV+4F9A3wjWJzFmz9zBr6MynnP0cTj9z8V9903cD/8TlTFFklV9Dmq9ACwBhgMLgAOArcGfbQP2uRlqsKsYC2CtDUuh4r3A3ME/4ejjInqoqCpn6CW4332F/69T6dqzGaszIn/7zWh0IlG4bIzEiVj5u1CfDmE88JS19lACb/49gdCa79bAPtc5ttZOs9YeW9OlWyU+uQvfgOIdUesOQpzUVHxjbwZfCk981510f1S76Ijx+XyUlZV5XYZ4rKysLGbui1GfDqElgXkDCBw+WgL0N8YsJ3DDhdqn3CUhVJxZFOXuIMTJao/vsus58rG7+L+8A7i9W9OvseO1jIwMSkpK2LVrV60TjpK4XNfF5/ORkZHhdSlA/QLhcWCGMeZqIA8YCswGRgKvW2u/i2B9EiO86g4qc44+jmk5Gxm7oQMftNrOm+1+8qyWcHAcZ59VsyJeqjMQrLWrgBOrfPvkiFQjMcnr7qCy+w/I59jtLXjgh2580fxLVmfo8hYi4RIbB64kpu3pDsK/KrmhSn0uVx/0Ay4uT3zXI2HmE0RigQJBauXuLK7UHRzkdTkA5DfbzY09VnFkcQv+b80BXpcjkjAUCFKrWOoOKpvXdivTcjYyemN7ztpS+4XFRKR+FAhSI3dnMe47r8ZUd1DZ/Qfks7xFEQ/+0I0uJTXfdlNE6keBIDWK1e4gJDCfsFLzCSJhokCQasV6dxCyNjifcFRxC67P7+h1OSJxTYEg1Yr17qCyeW23Miu7kLEbOtBjZ+1XuRSRmikQZB8V3cFRvWO6O6js3s757PT5uWN1Z4iNy8KIxB0FguwjnrqDkMK0Mh7utI4+21pz1o8660ikMRQIspeKdQdH9cbpdrDX5TTI3zoU8GVmMbfldSazXH+1RRpK/2pkL+7CN6Boe1x1ByHlDkzolken3en8bl2O1+WIxB0FglSI5+4gZFnLImZnbWbshg501wSzSIMoEKRCPHcHld3TZS0lPpc/aYJZpEHqc/lrSQIV3cGRx9LY7qChdxmL1L2OAxPM+dyR14UBmmAWqTd1CAJU7g68u99BOD1fMcF8AO6ukrqfICLqEJJBXZ/cW5T7WPy/I/m49Q5Gzz8ViNyn92gpd+C2bmuY/dUhuG/Owhl6sdclicQ8dQjCqI3taVueyqRO670uJayWttzBy1mbcd95BXdDfAecSDQoEJJci3IfY9d3YEHrn/h0v2Kvywm7ezqvhbR0/C9Nw3U1wyxSGwVCkkvU7iCkIL0MZ8gI+GI5LP+v1+WIxDQFQhLb0x1sTcjuIMTpOxA6dcU/82ncXbu8LkckZmlSOYmFuoNHO63zupSIclJS8I24Av+DfwxOMF/kdUkiTWKMSQVeBHKBFdbay6rZJgOYDXQGPgUusdbWetxUHUKSqtwdfJLA3UGI07MXzvGn4r7zD9yNiR2AkhTOBT6x1p4IdDTG/KyabS4C1lprjwbaAmfUtVN1CNVo6AIriLPTNF34/dpOSdEdVOacPwr3fx/gf2kavmtvx3F0hzWJW28DbwY7hTbAtmq26Qe8HHy8EOgLvFPbTqMSCNnZ2dEYJmyWjVnW4OfE8mvc6/W4Lvu9/Aotlr1Dcb++PP3rp6p9TmNeT0P/3KIxxl7jZGdTNGIsO/4ymZYrvyTjl30iM45ImBhjPqz05TRr7TQAa+2O4M8/ANZba1dW8/QsYGvw8TbgkLrGi0ogFBYWRmOYsOk9vXeDnxPLHULF63Fh/NpOXLk+h+fbb+LW7Q/B9IeqfU5jXk9D/9yiMUbVcdzjToW5r7J12iNsP+AgnGbVXwAv0f4OSPzJzc3FWntsdT8zxmQBO4ATgIXGmL7W2nerbFYItA4+bh38ulaaQ0gWVcOg6xpIwiMmoQlmthTgvjXL63JEGmscMNxaWw4UA5nVbLMA6B983A+oGhj7UCAkA4XBXpyevXB+2Qd37j9wNyXPHIoklMeBy4wxS4DNwApjTNV2fwbQyRjzKbCFQEDUSpPKCc51XW5RGOzDGTYa95Ol+F+cju/a2zTBLHHFWptP4FN/ZTdV2WYXMKgh+1WHkMBc18X9x/NcFQyDCQqDCk6bdoEVzJ9/BJ984HU5IjFBgZCgQmHgvv1yRRi4CoO9OH0HQm4X/C9pBbMIKBASkuu6uK8EwsDpM0BhUAMnNRXfiN/C5k24b8/2uhwRzykQEkxFGLwVCANnxG8VBrVwDumFc1wf3Ldf1gSzJD0FQgKpLgwcn37FdXGGj4KUtMChI10iW5KY3i0ShMKg8Zw2WThDfg2ffQifLPW6HBHP6LRTD4XrmkmBMPhbIAxOURg0htNvEO778/G/NB3f4dVdJ0wk8eldI87tCYPZgTAYqTBojMAE8xWBCea3Xq77CSIJSB1CHFMYhJdzyJE4x52C+/bLdD08ndUZuyM+ZsJfWVfiit494pTCIDKc4aMhJZWJqzt7XYpI1NWrQzDG/B4YTODqepcSuMZ2G2COtfaWyJUn1XFdF/fVvwfD4EyFQRgFJpgv5LRZz3L6j62Z33Zr3U8SSRB1vosYY3oAR1hrTwbeAh4F5gBHA2cZY3pGtkSprCIM3pwVDIMrFQZh5vQbzDeZO5m4ujPN/FrEIcmjPu8kpwFtjTHvAScD3YF51lo/8C8Cd+GRaHBRGESBk5rKhK55dNndjKvW5XhdjkjU1OfdZH+gwFp7CnAAcBx734WnXdUnGGPGGmM+rHK3H2kKF27Kzw2Ewcn9FQYRtqTVDl5rt4Ur1+fQtSTd63JEoqI+cwjbgBXBxyuB9ux9F57VVZ8QvM3btOCXWvrZVMEwuHZdx0AYXHSVwiAK7uqyltN+as3teZ25rOf3XpcjEnH1CYSPgBuDjw8iEA79jTHLgT7A5AjVJrBXGLywfwEXKQyiZmN6KY92Ws+taw6I+wnmhp7eqlNbk1Od7yzW2iVAoTFmGYEwuAQ4G/iUwFlG30W2xCRWJQzGd8tTGETZXzps5NuMnUzM0wSzJL56nXZqrb2yyrdOjkAtUpkL44Jh8GIwDHTV0ugr88GEbmt46eueXLk+h0c7rfe6JJGI0cfNWBQMg+uCYXCLwsBTi1tt55/ttnDVuhy6aIJZEpgCIdYoDGLSXV3WUu643J6nFcySuOLuWkaJPjnWb2srhUEM2hCcYP6/NQcwZn17pnfc5HVJImEXd4GQ6C4syGZTWil/VBjEnKdzNvKzHS2YsKYzLvC0QkESjAIhhrQrTeW0n9rwTIeNlCsMYk65A787cCV834Pb1gQOHSkUJJEoEGLIOZvbkuY6zM7e7HUpUoMy396h4DrwTI5CQRKDAiGGDCvM5tPmRXzTvMTrUqQWoVBwvu9RMcmsUJBEoECIEYcVZ3JkcXMmdM3zuhSphzIfXHPgSh6rFAoi8U6nncaIYQVZ7Hb8vNZui9elSD2FQuHNtj9ye15n/PNe87okkSZRIMSAVD8M3dyO+W228lNaudflSANUDgXXPoN/vkJB4pcCIQb03dqa7LI0ZmkyOS6FQoFfnIA7U6Eg8UuBEAOGFWaxKa2Uf7WO36tpJrsyH/jG3AS/+JVCQeKWAsFjbUtTOO2n1ryStZky/TbimpOaim/MzZVC4Z9elyTSIDrLyGPnbG5HuuvT2oMEEQoF//QHcWc+jR/wnT7E67KkERp6mRyIv0vlVKXPpB4bXpjFZ82LWKG1Bwlj707haXUKEjfUIXjo0OJMjixuwW1dtPYg0VR0CtMeCISC4+A7bbDXZUVUMn6iTjTqEDw0rDC49iBLaw8SkZOaim/s7+Hnx+O+NB3/gte9LkmkVuoQPOKWlTG0MLD24EetPUhYoVDwT3sgEAqQ8J2CRJ4xxgGeAw4BNgHnWWvLqmwzAHgaWBX81uXW2hW17VeB4JUvPmb/sjRNJieBQCjcjH/agwoFCZcTgVRr7fHGmEVAf+DNarZ70lp7d313qkDwiH/xAgpSS1mktQdJwUlNqxIKDr7TBnldlsSvjcDk4OPdtWx3vjHmHGANMMxa69a206gEQnZ2dtj2tWzMsoiP3dAxGjqOf9tPFHy6jOZ9z2KJeSZi44RE+vU0dpxEei31Hccdfz9bH76NXS9No/l+LWL29cTSn5lXYuH1GGM+rPTlNGvtNABr7bfBnw8F0oG51Tz9e2CCtXaOMWYx0AdYVNt4UQmEwsLCsO2r9/TeDdq+MWcxNHSMho7jX/AGlJUxdP0Uvp5+f8TGCYn062nsOIn0WhoyjjvqWti1i+1PT+Lxd/J4LqcgIuNUlki/m2jx+vXk5uZirT22pp8bY4YA1wGDrbXVTURuAeYHH68C2tc1ps4y8oC7eAF06cHXzXd6XYp4wElNw3fFzfCz4/lTXhcu3bi/1yVJnDHG5AA3AwOttdtr2OxG4EJjjA/oBXxe134VCFHmrl0Fed/jnHCa16WIh0Kh8HbbH7lztUJBGuxSoCMw1xjzH2PM5caYh6ps8xgwGvgAeMVa+2VdO9WkcpS5SxZCSirOcX1gpdfViJec1DSuPvAHHv8e7lzdBYC/dmjY4SNJTtba+4Fajzdba9cDpzZkvwqEKHLLynD/uwiOOhanZSuvy5EYUOpzufrAH3jiO4c7V3fBBZ5XKNRKK6IjR4eMoumL5bDtJ3w6XCSVlPpcrjpoJXPb/MRdq7twiQ4fiUcUCFHkX7wAWraGXsd4XYrEGIWCxAIFQpS4O7bBJ0txfnkqTqqO1Mm+QqEwr81P3LG6M91KmnldkiQZBUKUuEvfg/IynBP7eV2KxLBSn8st3Vaz2+dybX5Hr8uRJKNAiBJ38ULo3B3ngO5elyIxriC9jL+1L2Do5nbqEiSqFAhR4OavhtXfae2B1NufczaoS5CoUyBEgbt4IaSk4Pyyj9elSJwIdQnnbm5HV3UJEiUKhAhzy8tx//suHNkbp2Vrr8uROPLnnA2U+lyuXZfjdSmSJBQIkfbFx4G1B5pMlgaqmEsozFKXIFGhQIiwPWsParxooUiN/pyzgTJHXYJEhwIhgvasPeijtQfSKOoSJJoUCBHkLvs3lJXp7CJpkqc6qkuQ6Kj3x1ZjzA3AQOBC4BWgDTDHWntLhGqLe+77C+CA7jidtfZAGi/UJYze2J4puRu8LkcSWL06BGNMV2BU8MvrgTnA0cBZxpiekSktvlWsPdBksoRBqEv4nboEiaD6HjKaDIwPPu4HzLPW+oF/AX0jUVi8q1h7cJzWHkjThbqE8wqzcDet87ocSVB1BoIxZgTwCRC6204WsDX4eBvQrprnjDXGfFjlBtFJwy0vx/1gERx5LE6rNl6XIwki1CW4c2Z5XYokqPrMIQwCugBnAocAfiC0wqo1sLrqE6y104BpwS/dppcZZ75cDlt/1H0PJKwK0sv4e/sCfvPfd3EHDsdpn+t1SZJg6uwQrLUjrLUnEZhM/gh4HOgfvHFzH+DdyJYYf9z3F8B+reBI3fdAwuupjhsgJVVdgkREY047nQKcDXxK4Cyj78JbUnxzi7bjfvJBcO1BmtflSILZlF6G02cA7n/f1VyChF29Tzu11q4CTg9+eXJEqkkA7lKtPZDIcs48D/dfb+POmYUz+jqvy5EEooVpYeYuDq496NLD61IkQTlt2lXqEtZ7XY4kEAVCGLn5ebDqW5wTtPZAIss587zAXMKb1utSJIEoEMLIXbJA9z2QqKjoEpaoS5DwUSCESeC+B4ug1zFaeyBRoS5Bwk2BEC5aeyBR5rRph3PKmeoSJGwUCGHiLl4I+7WEo3TfA4keZ8D56hIkbBQIYdC6LAX3f//F+eWpWnsgUaUuQcIpIQLhynUdGF6Q5dlFMgZvbhtce6CziyT69nQJWr0sTRP3geBz4eRtrXj4h248+81BdNgd/U/owwuz4YBu0FlrDyT69nQJC3ELdL8Eaby4DwS/AyMP+ZbbuuTxq+37Mf+zwxkWxW7h4J0Z/LyoBc6v+uE4TnQGFamiokuYo7kEaby4DwQA14Hncgo4s9eXfN18J49EsVsYVphFGS7O8Vp7IN5RlyDhkBCBELI6Yzfm0G+4vUseJ2xvyfzPDse/eAGuG5l2IcWF8wrb8W6brTit2kZkDJH6cgacB74UdQnSaAkVCBDoFp7NKaB/sFtwn52Mf+qduD9uDvtYJ29tRYfSdGZlh3/fIg3ltMkKrl5WlyCNk3CBELI6Yxfm0G9wLhwDKz7Ff/s1Ye8WhhdmsSW1jAVttta9sUgUVHQJOuNIGqHel7+OR64DvtMG4x55DP7npuA+Oxn3w/fxXXI1TpusJu27dVkKZ/zYhhfbF1LqS76bwklsqugSFr2Je/ZwnP1zvC5JIsAY4wDPEbiL5SbgPGttWZVtMoDZQGcC96+5xFpb65tVwnYIlTntc/HddA/OBb8JW7cweEtbMlwfs7ILw1ipSNM5A84Dx6cuIbGdCKRaa48HWgH9q9nmImCttfZooC1wRl07TYpAAHB8PnynD8F32xTI7RqYW3jsLtyfGnf8f1hBFl9lFvN5851hrlSkaTSXkBQ2ApODj3fXsE0/YF7w8UKgb107jcoho+zs7LDta9mYZU0bOzsb9/5pFM+ZxY6/P4U78Vr2u/x6Mk4dULGOoK4xUtavJ3vpHWwfPoxl/U+vfpx6aOhrSbRxEum1xNo45SN+Q+F7c0lf+Dqtrx6v300Mj1MbY8yHlb6cZq2dBmCt/Tb486FAOjC3mqdnAaEJzm0EDi/VKiqBUFgYvsMqvaf3btD2+WPyq//Br07D1+Mw/M9NZtuUO9m26G18F1+F0yarzjFuWdOJsXSgz3cTKFw9vvZxatHQ15Jo4yTSa4m9cRyck/tT8u6b7O43mN6v6ncTq+PUJDc3F2ttjVfLNMYMAa4DBltry6vZpBBoHXzcOvh1rZLmkFF1nA65+G6+B+eCy+HrTwJzC0verXWVsy+49mBRm60UppXVvKGIx5wB52suIUEZY3KAm4GB1trtNWy2gD1zC/2Ad+vab1IHAoDjS8F3+jnBuYUuuH+ZxF++PbDGVc4nb21FjtYeSBxw2mZVrF5QVulBAAAOn0lEQVTuvCvd63IkvC4FOgJzjTH/McZcbox5qMo2M4BOxphPgS0EAqJWCX3aaUOEugV3wRucNGs68z87nNu7ruEfWVug0iWKhhdm8WOK1h5IfHAGnI/73lyuWZfDH7rneV2OhIm19n7g/jq22QUMash+k75DqMzxpeA74xz6H/kl32SW8OjK7jzz7YG03x3IzdZlKfT/sQ2vZm1ht9YeSBwIdQnDCrPVJUidFAjVWJWxi+GHreCOLms4eWsr5n92BEML21WsPZi9vw4XSfxwBpyPH5dr1mmRmtROgVADvwPP5GzizF5f8l1mCZNXdue21Z35OnMnnzUv9ro8kXpz2mbxwv6F6hLCoGdxBucVtiMlQQ8QKBDq8EPmLoYdtoI/dV6D68BfO2zaa05BJB48kbtBXUIY3JCfy52rurBfeYrXpUSEAqEe/A483XETR/xiOTPa61IVEn82ppdWdAkHqEtolEOKMxj4Y1v+krOJranVnfYf/xQIDVCmPy2JY+oSmub6/Fy2+8p5Omej16VEjN7iRJJEqEsYri6hwZKhOwAFgkhSUZfQOMnQHYACQSSpbEwv5UV1CQ2SLN0BKBBEko66hIZJlu4AFAgiSWeDuoR66xnsDp5Ngu4AFAgiSSnUJdy5qgutyhLznPpwuH5dx0B30CHxuwNQIIgkpQ3ppdzXOZ9Tt7Zi3meHc+pPrbwuKeb0LM5g0JZ2PJuziZ/SEr87AAWCSNJ6JmcT5xz+NdtTy3n+m4N5YGVXWmqxTYVk6w5AgSCS1D7dr5iBR3zF4x3XM7wwi3mfH0EfdQu4+auTrjsABYJI0tvlc7m/8zrOOfxrdqSU87dvDsb/3BTc4iKvS/OM+/pLSdcdQD1ukGOMcYDnCNygeRMwAngJ6Ax8ClxirU3Qa/+JJI9Qt3B9fkeuXrwQ98v/4bvkGpxev/C6tKhy81fjfvQ+z+YmV3cA9esQTgRSrbXHA62Ay4C11tqjgbbAGRGsT0SiKNQt+MY/ABmZ+CdPxP/XqUnVLbivvwTNMpOuO4D6BcJGYHLw8W5gIjAv+PVCoG/4yxIRLznde+KbMClwC873F+Cf+Dvczz/2uqyIc/NX4368GOe0QUnXHUA9DhlZa78FMMYMBdKBj4DQDYW3ETiUtBdjzFhgbPD54apVRKLISUvHOf9S3J8fj/+5KfgnT8Q5uT/OsNE4zVt4XV5EuG/MhPQMnDPOgRdv8bqcqKszEACMMUOA64DBwFNA6+CPWgP73CDAWjsNmBb8UvMLInHM6XEIvgmTcP/5Iu7cV3A//zgh5xZCcwfOWcNw9kvOM63qPGRkjMkBbgYGWmu3AwuA/sEf9wPejVx5IhILnLR0fOdfiu+W+6FZRmBu4fnHcHcmzu1k9+oOklR95hAuBToCc40x/wHSgE7GmE+BLQQCQkSSgNPjEHy3PYpz5nm4/5mPf+I1uF8s97qsJqvoDk4blLTdAdRvDuF+4P4q3/5zZMoRkVjnpKXjDBuF+4tf4X92Mv5Hb8c5uT/7lfvYkeL3urxGUXcQoIVpItIoVbuFeZ8dwclbW3pdVoO5+XnqDoIUCCLSaE5aOr5ho/D94T6KfeXMWNGT+37own7l8fPW4s5RdxASP781EYlZzoGHcnavr3gqZwMXFGTHTbfg5ufhfvgfnH4Dk747AAWCiITJLp/LPV3yOe/wFez0+Zmxoif3xni3sKc7ONfrUmJC7P6mRCQuLd+viLN6fclTORu4sCCbdz47nJ/taO51WfvYqztoqe4AFAgiEgGhbuH8w1ZQ7sCMr3vyi+2xtbpZ3cG+FAgiEjEftyxi2GErKEwr5W8rDo6ZUFB3UD0FgohE1Mb0Usxh38RUKKg7qJ4CQUQirmoo/HyHd6Hgrgt1B2erO6hCgSAiUbExvZQLgqHw96+9C4XAquRmOGcM9WT8WKZAEJGo2VAlFNzvv47q+Hu6A80dVKdel78WEQmXUCjM/KonLSdPxHfdRJwDD43K2InWHRhj0oB/WGsH1/DzAcDTwKrgty631q6oaX8KBBGJulAoLM3vjz9KoVDRHQw4LyG6A2NMJvAB0LOOTZ+01t5dn33qkJGIeGJDeim+m+6B/VrhnzwRd2WNH1zDItG6A2vtTmvtUcDaOjY93xiz1BjzsjHGqW3DqHQI2dnZYdvXsjHLIj52Q8fQOI0bJ5FeS6KNE63Xsn/2oZTf8xQ/Trga/+SJtLn9UdJ6HhH2cdrs3M7mD/9D86EX0bJ7j3o9J1q/m9oYYz6s9OW04N0oG+J7YIK1do4xZjHQB1hU08ZRCYTCwn3ustlovaf3btD2+WPyIz6GxmncOIn0WhJtnOi+Fh/uDXfiPvRHtky8Dt/1d+D02OdW7U0aZw03QHozSk46k131fD+K1u+mJrm5uVhrj23ibrYA84OPVwHta9tYh4xExHNOu2x8N90dOHz06O1hPXx00M4M3GX/xumblGcW3QhcaIzxAb2Az2vbWIEgIjHBabd/RELh2vyOgbmD/om9KtkY090Y81CVbz8GjCYw+fyKtfbL2vahs4xEJGaEQsH/0P/hf/R2fDf8Cad7XSfR1OygnRkM2dIWZ8BAnJatw1hp7LDWHhT8/w/ATVV+th44tb77UocgIjFlr05h0m24P3zT6H1dm9+RnT5/wncH4aJAEJGYE45QCHUHf+1QkLDdQbgpEEQkJu0dCrc3OBRC3cG0nI0RqjDxKBBEJGY57fbHN+5u2K9lg0KhcnewJa0swlUmDgWCiMQ0J2vvUDiqHrfj/N26HErUHTSYAkFEYl7lUJix4uBaQ+HAnc04Z3M7dQeNoEAQkbgQCoWtqeW1hsK16zpS4vPzZ3UHDaZAEJG44WTtjzl0RY2hoO6gaRQIIhJX1jUrrTEU1B00jQJBROJOdaGg7qDpFAgiEpfWNSvlgkO/qQiFe1d1VXfQRAoEEYlb+c12V4TC8dtbqjtoIl3cTkTiWn6z3ZhDVzBqY3ue6LjB63LimgJBROLeumal3NMlfDenSVY6ZCQiIoACQUREghQIIiICKBBERCRIgSAiIkAjzjIyxmQAs4HOwKfAJdZaN9yFiYhIdDWmQ7gIWGutPRpoC5wR3pJERMQLjQmEfsC84OOFQN/wlSMiIl5xXLdhR3uMMXOBB621840xvwF6W2uvqLLNWGAsgLX2mHAVKyKSZJxoDtaYDqEQaB183Dr49V6stdOstcdaa48l8IIi/p8x5qNEGSeRXkuijZNIryXRxkmk11Lpv6hqTCAsAPoHH/cD3g1fOSIi4pXGBMIMoJMx5lNgC4GAEBGRONfg006ttbuAQRGopammJdA4ifRaEm2cRHotiTZOIr0WTzR4UllERBKTViqLiAiQAPdDiObKaWNMGvAPa+3gCO3fAZ4DDgE2AedZa8N++ydjTCrwIpALrLDWXhbuMaqMdwMw0Fp7eoT2PwB4GlgV/Nbl1toVERrr98BgYAdwjrV2d5j3fypwV/DLrsCt1tq/hnOM4DgtgBeAbOB9a+3vwz1GcJy2wCtAGvC2tfbOMO+/4t9kJN8Lqv7bj/R7gVcSoUOIysppY0wm8FGk9h90IpBqrT0eaMWes7nC7VzgE2vtiUBHY8zPIjQOxpiuwKhI7b+SJ621JwX/i1QY9ACOsNaeDLwFHBDuMay1i0Kvg8Cb2vJwjxE0Evhv8O/AEcaYwyI0zgjgi+A4Jxpjuodrx9X8m4zIe0HVcaL0XuCJRAiEqKycttbutNYeBayNxP6DNgKTg4/D+smzireBR4KdQhtgWwTHmgyMj+D+Q843xiw1xrwc7LQi4TSgrTHmPeBk4IcIjYMxpjlwkLX20wgNsQtoHvyzyiCyf99aBsdxgLB9+Kjm32RE3guqjhOl9wJPJEIgZAFbg4+3Ae08rKVJrLXfWmuXGmOGAunA3AiNs8NaWwy8D2y01q6MxDjGmBHAJ8CXkdh/Jd8DE6y1xwEdgT4RGmd/oMBaewqB7uCkCI0DgU+fkTyl+wXgLOAr4Gtr7fcRGmcGgQ8dLxMIocwIjQMJ9F7glUQIhDpXTscTY8wQ4DpgsLW2PEJjZBljmgEnEPjEG5GuisDpyacBLwHHGGOuidA4W4D5wcergPYRGmcbEDoctRLoFKFxIDBP8UYE9z8eeMpaeyjQzhhzQgTHutxaex6BQNgUwXES6r3AC4kQCAmzctoYkwPcTGACdnsEhxoHDA8GTjER+tRmrR0RPBZ+IfCRtfaxSIwD3AhcaIzxAb2AzyM0zkdA7+DjgwiEQtgFD6/0JXDYI1JaAiXBx7uA/SI0zinAU8EPIEcD/43QOJBA7wVeSYRASKSV05cSOOQx1xjzH2NMpM7+eRy4zBizBNhMhA5NRdFjwGjgA+AVa21EDlFZa5cAhcaYZQTOzloaiXEIhM4X1tqSOrdsvMeBK4N/BzKJ3L+btwjMUfwbuMtauyNC40BivRd4QgvTREQESIwOQUREwkCBICIigAJBRESCFAgiIgIoEETqZIzRmReSFBQIIpUYY1YZY7p5XYeIFxQIIiICaB2CJABjzCIClyk4EXiWwCK1xwlcxuIuAhdVu91a+1zw8tITCaw6vgz4DDgTGAPcRuAqmVsBP9DVWlsUPGQ0AniIwKrewdbaL6Lz6kSiJ+7vhyAStBRYTeBqmmOBGwjcV+IEAm/ui40xHwW3PR54FcgBlgFnWWunAFOMMauAU621q6rsfyDQjcCq6CuAayP4WkQ8oUNGkiiWAdsr/f9o4HVr7Wpr7RrgH+y5zk0BMDl4f/DlBO49UZc7rLWlBK7FU5/tReKOAkEShVvl/9X9PHSfhB8q3UmrvsdMQ5eH1jFWSVg6ZCSJqgwYZIzpApQD5xE47JNF4BBSTQqB7saYPKCttXYzgLW2tueIJAR1CJKovgJuAd4DFgO3WWs/q8fzbiNwX+vNRO4WpiIxSWcZiYgIoA5BRESCFAgiIgIoEEREJEiBICIigAJBRESCFAgiIgIoEEREJEiBICIiAPw/V0pWDB1yIXAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.DataFrame({\"revenue\":[57,68,63,71,72,90,80,62,59,51,47,52],\r\n", + " \"advertising\":[2.1,1.9,2.7,3.0,3.6,3.2,2.7,2.4,1.8,1.6,1.3,1.9],\r\n", + " \"month\":range(12)})\r\n", + "\r\n", + "ax = df.plot.bar(\"month\", \"revenue\", color = \"green\")\r\n", + "df.plot.line(\"month\", \"advertising\", secondary_y = True, ax = ax)\r\n", + "ax.set_xlim((-1,12));" + ] + } + ], + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/练习题-matplotlib.ipynb b/练习题-matplotlib.ipynb new file mode 100644 index 0000000..ac5f471 --- /dev/null +++ b/练习题-matplotlib.ipynb @@ -0,0 +1,2009 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "63C1DBF82CD746099782739244B67E7C", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案，也可以和图形工具包一起使用。\n", + "\n", + "------\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B92E8770D93C43A69DEF21EB72E6E418", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 一、导入\n", + "1.导入matplotlib库简写为plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "C1C27426C46446E98C8086547ED6AB91", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "32583C823FED4A179EC8640A195F3D56", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 二、基本图表\n", + "2.用plot方法画出x=(0,10)间sin的图像" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "FE6254DA8B2B4971970C4952A04C8CAE", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0, 10, 30)\r\n", + "plt.plot(x, np.sin(x));" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0D93F2D62A1B4CB18E7329710674AB3B", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "3.用点加线的方式画出x=(0,10)间sin的图像" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "465DC813859F433AB0E8ACEA991109C3", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(x, np.sin(x), '-o');" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CB2AB6597C6149FC807E3D21E1A41DA6", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "4.用scatter方法画出x=(0,10)间sin的点图像" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "544B52B75A4E40AB8701BAF29F6C76A9", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.scatter(x, np.sin(x));" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7303231ADDB44F7A81557AD049714AF8", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "5.用饼图的面积及颜色展示一组4维数据" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "E67D1E05A9404579A603BC6738B7BF5E", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "rng = np.random.RandomState(0)\r\n", + "x = rng.randn(100)\r\n", + "y = rng.randn(100)\r\n", + "colors = rng.rand(100)\r\n", + "sizes = 1000 * rng.rand(100)\r\n", + "\r\n", + "plt.scatter(x, y, c=colors, s=sizes, alpha=0.3,\r\n", + " cmap='viridis')\r\n", + "plt.colorbar(); # 展示色阶" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4D33CABD132D4A6095C6E2D53473A1C4", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "6.绘制一组误差为±0.8的数据的误差条图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "EFE17F2619B4404881FBCA8046DC6027", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0, 10, 50)\r\n", + "dy = 0.8\r\n", + "y = np.sin(x) + dy * np.random.randn(50)\r\n", + "\r\n", + "plt.errorbar(x, y, yerr=dy, fmt='.k')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "031206548B3D4EA3885876E6FCAC9AB5", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "7.绘制一个柱状图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "0E8A3F01CED5432C9DCBF340A31F95AB", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = [1,2,3,4,5,6,7,8]\r\n", + "y = [3,1,4,5,8,9,7,2]\r\n", + "label=['A','B','C','D','E','F','G','H']\r\n", + "\r\n", + "plt.bar(x,y,tick_label = label);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F04E8C2D902C49D1852EEE3BA2CEF4FD", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "8.绘制一个水平方向柱状图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "41E75E7D3A074437ABE1753070B4B5AB", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = [1,2,3,4,5,6,7,8]\r\n", + "y = [3,1,4,5,8,9,7,2]\r\n", + "label=['A','B','C','D','E','F','G','H']\r\n", + "\r\n", + "plt.barh(x,y,tick_label = label);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "637E2824542E45D6B291900368BC5809", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "9.绘制1000个随机值的直方图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "B620FFF40CCA4EA18EE34465CDAA68E3", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "data = np.random.randn(1000)\r\n", + "plt.hist(data);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "98B073D0DF92435C89CCE9EA1B7563C9", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "10.设置直方图分30个bins，并设置为频率分布" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "C0DC8DDD8C704BED9AD895A640B1E25D", + "jupyter": {}, + "mdEditEnable": false, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.hist(data, bins=30,histtype='stepfilled', density=True)\r\n", + "plt.show();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FA1EAEBA238147E78FECCCE44275E543", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "11.在一张图中绘制3组不同的直方图，并设置透明度" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "753E2A3E4CC54EB8970314CDD38E6BAA", + "jupyter": {}, + "mdEditEnable": false, + "scrolled": true, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x1 = np.random.normal(0, 0.8, 1000)\r\n", + "x2 = np.random.normal(-2, 1, 1000)\r\n", + "x3 = np.random.normal(3, 2, 1000)\r\n", + "\r\n", + "kwargs = dict(alpha=0.3, bins=40, density = True)\r\n", + "\r\n", + "plt.hist(x1, **kwargs);\r\n", + "plt.hist(x2, **kwargs);\r\n", + "plt.hist(x3, **kwargs);\r\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "99972BC9C0FF46709A34085EB4F33AB1", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "12.绘制一张二维直方图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "508E4096CCD044279CA7C03D037696C7", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "mean = [0, 0]\r\n", + "cov = [[1, 1], [1, 2]]\r\n", + "x, y = np.random.multivariate_normal(mean, cov, 10000).T\r\n", + "plt.hist2d(x, y, bins=30);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D329FDF4DFEC45EA802A5A5FA22AEFEB", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "13.绘制一张设置网格大小为30的六角形直方图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "1C135E782C474A558A456B9E6C5E08FB", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.hexbin(x, y, gridsize=30);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1FABCC9EA26F4A1889445617965D24D9", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 三、自定义图表元素\n", + "14.绘制x=(0,10)间sin的图像，设置线性为虚线" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "6DF02E3ACED94177927FE9F71B20AEC1", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0,10,100)\r\n", + "plt.plot(x,np.sin(x),'--');" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0126190DC66D4711853622259AD65D08", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "15.设置y轴显示范围为(-1.5,1.5) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "7F00C68E804A43F8B56A34D64A916BB3", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0,10,100)\r\n", + "plt.plot(x,np.sin(x))\r\n", + "plt.ylim(-1.5,1.5);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7A85F7DAF87F401F83CEEF71D30E59E6", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "16.设置x,y轴标签variable x，value y" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "ACEE41A4F61C41DA8CFE6BFBFB2E96CE", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0.05, 10, 100)\r\n", + "y = np.sin(x)\r\n", + "plt.plot(x, y, label='sin(x)')\r\n", + "plt.xlabel('variable x');\r\n", + "plt.ylabel('value y');\r\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "09D4622BE48E4B2B81BAFA4EAFB6B5A4", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "17.设置图表标题“三角函数”" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "CF85FF7D8D8C4F0E985896A2EB123BF3", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0.05, 10, 100)\r\n", + "y = np.sin(x)\r\n", + "plt.plot(x, y, label='sin(x)')\r\n", + "plt.title('三角函数');" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0BB29E2AA96044B4805F08EF64D2BD77", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "18.显示网格" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "3E18420438AC4DA689D70A36876AE01D", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0.05, 10, 100)\n", + "y = np.sin(x)\n", + "plt.plot(x, y)\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E7CA9FADFFF043348665612A9B29D3F9", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "19.绘制平行于x轴y=0.8的水平参考线" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "379B3F9A570F48D58FDF4D9085B78BA1", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0.05, 10, 100)\r\n", + "y = np.sin(x)\r\n", + "plt.plot(x, y)\r\n", + "plt.axhline(y=0.8, ls='--', c='r')\r\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AD0268B993224BF6850F558D7EDD5D12", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "20.绘制垂直于x轴x<4 and x>6的参考区域，以及y轴y<0.2 and y>-0.2的参考区域" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "270C1A8864194203912C218307715CE0", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0.05, 10, 100)\n", + "y = np.sin(x)\n", + "plt.plot(x, y)\n", + "plt.axvspan(xmin=4, xmax=6, facecolor='r', alpha=0.3) # 垂直x轴\n", + "plt.axhspan(ymin=-0.2, ymax=0.2, facecolor='y', alpha=0.3); # 垂直y轴" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8EF93EE2EB8F490C99C255DD99A3F1A7", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "21.添加注释文字sin(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "54ECB9E9A3474126993B4BE32A83F644", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0.05, 10, 100)\n", + "y = np.sin(x)\n", + "plt.plot(x, y)\n", + "plt.text(3.2, 0, 'sin(x)', weight='bold', color='r');\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "62D56E2FE4754C258EFC26771CC868F3", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "22.用箭头标出第一个峰值" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "E20671BC86304E988241076DA4D3DCE5", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0.05, 10, 100)\n", + "y = np.sin(x)\n", + "plt.plot(x, y)\n", + "plt.annotate('maximum',xy=(np.pi/2, 1),xytext=(np.pi/2+1, 1),\n", + " weight='bold',\n", + " color='r',\n", + " arrowprops=dict(arrowstyle='->', connectionstyle='arc3', color='r'));" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "62B327ECDA9C41AB92BD1D6ED0085557", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 四、自定义图例\n", + "23.在一张图里绘制sin,cos的图形，并展示图例" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "1556CD999FEA4EDAA51AC935ECB78D30", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0, 10, 1000)\r\n", + "fig, ax = plt.subplots()\r\n", + "\r\n", + "ax.plot(x, np.sin(x), label='sin')\r\n", + "ax.plot(x, np.cos(x), '--', label='cos')\r\n", + "ax.legend();\r\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7452E5EDA4134AA28F7E2231EDEA0CE5", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "24.调整图例在左上角展示，且不显示边框" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "D1564F66B2F7432688394DC03ADD75E6", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ax.legend(loc='upper left', frameon=False);\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "35EF0B0E1E5D404F82781C908A02E644", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "25.调整图例在画面下方居中展示，且分成2列" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "D8041B84218E4AF8959F03EF10407AE1", + "jupyter": {}, + "scrolled": true, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ax.legend(frameon=False, loc='lower center', ncol=2)\r\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AE251699DC51481E84E8312B96B7B980", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "26.绘制的图像$sin(x),sin(x+\\pi /2),sin(x+\\pi)$的图像，并只显示前2者的图例" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "E39E8B1A3C9F4DD8B7DFCEC7FAFAC40C", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "y = np.sin(x[:, np.newaxis] + np.pi * np.arange(0, 2, 0.5))\r\n", + "lines = plt.plot(x, y)\r\n", + "\r\n", + "# lines 是 plt.Line2D 类型的实例的列表\r\n", + "plt.legend(lines[:2], ['first', 'second']);\r\n", + "\r\n", + "# 第二个方法\r\n", + "#plt.plot(x, y[:, 0], label='first')\r\n", + "#plt.plot(x, y[:, 1], label='second')\r\n", + "#plt.plot(x, y[:, 2:])\r\n", + "#plt.legend(framealpha=1, frameon=True);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B473C113D2E8421BBF5CA2275C9E544A", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "27.将图例分不同的区域展示" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "503CB6BEAC3943B981F18CFD65FA05CD", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "lines = []\n", + "styles = ['-', '--', '-.', ':']\n", + "x = np.linspace(0, 10, 1000)\n", + "\n", + "for i in range(4):\n", + " lines += ax.plot(x, np.sin(x - i * np.pi / 2),styles[i], color='black')\n", + "ax.axis('equal')\n", + "\n", + "# 设置第一组标签\n", + "ax.legend(lines[:2], ['line A', 'line B'],\n", + " loc='upper right', frameon=False)\n", + "\n", + "# 创建第二组标签\n", + "from matplotlib.legend import Legend\n", + "leg = Legend(ax, lines[2:], ['line C', 'line D'],\n", + " loc='lower right', frameon=False)\n", + "ax.add_artist(leg);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FB25F1D29A6D486F87D2983F383B2951", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 五、自定义色阶\n", + "28.展示色阶" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "0D10C6B5EAC2482DA3AED4C3DEBA7525", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.linspace(0, 10, 1000)\r\n", + "I = np.sin(x) * np.cos(x[:, np.newaxis])\r\n", + "\r\n", + "plt.imshow(I)\r\n", + "plt.colorbar();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DB6A203070D744319E092006C13EE15A", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "29.改变配色为`'gray'`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "5E46D6F2CB0B455E8C4DFB51FDCD266D", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.imshow(I, cmap='gray');" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "585BE54B25534CF1A376A269D37DBCEE", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "30.将色阶分成6个离散值显示" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "E967DB8F54FE4F848A6A4D36DCA96885", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.imshow(I, cmap=plt.cm.get_cmap('Blues', 6))\r\n", + "plt.colorbar()\r\n", + "plt.clim(-1, 1);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1DACC0BC5778443A944F32F404CBE809", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 六、多子图\n", + "31.在一个10\\*10的画布中，(0.65,0.65)的位置创建一个0.2\\*0.2的子图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "4AD309B16FEA4C9FB1D0C8A3C05F69B2", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ax1 = plt.axes()\r\n", + "ax2 = plt.axes([0.65, 0.65, 0.2, 0.2])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C3224B6E11F3427FA6202E610CAA090A", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "32.在2个子图中，显示sin(x)和cos(x)的图像" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "EF78AB2FA4DF49CD825D71D0EC8A84F7", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "fig = plt.figure()\r\n", + "ax1 = fig.add_axes([0.1, 0.5, 0.8, 0.4], ylim=(-1.2, 1.2))\r\n", + "ax2 = fig.add_axes([0.1, 0.1, 0.8, 0.4], ylim=(-1.2, 1.2))\r\n", + "\r\n", + "x = np.linspace(0, 10)\r\n", + "ax1.plot(np.sin(x));\r\n", + "ax2.plot(np.cos(x));\r\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FC60C071EDF0497289C37BDA0BAA956D", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "33.用`for`创建6个子图，并且在图中标识出对应的子图坐标" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "5B7BAAFC08B5483CBB23267F8F4DF238", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "for i in range(1, 7):\r\n", + " plt.subplot(2, 3, i)\r\n", + " plt.text(0.5, 0.5, str((2, 3, i)),fontsize=18, ha='center')\r\n", + " \r\n", + "# 方法二\r\n", + "# fig = plt.figure()\r\n", + "# fig.subplots_adjust(hspace=0.4, wspace=0.4)\r\n", + "# for i in range(1, 7):\r\n", + "# ax = fig.add_subplot(2, 3, i)\r\n", + "# ax.text(0.5, 0.5, str((2, 3, i)),fontsize=18, ha='center')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D3193A54E3AC4FB2891D40869B351D68", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "34.设置相同行和列共享x,y轴" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "01847EFA5B564C4189E1EBC547514236", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(2, 3, sharex='col', sharey='row')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F6129FE0C9EA4FF59009B5B70EC31513", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "35.用`[]`的方式取出每个子图，并添加子图座标文字" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "C06A141D25B7444B8D28B59E713AF837", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "for i in range(2):\r\n", + " for j in range(3):\r\n", + " ax[i, j].text(0.5, 0.5, str((i, j)),fontsize=18, ha='center')\r\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BE371B33A8A04CB688B5148319DD560D", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "36.组合绘制大小不同的子图，样式如下\n", + "\n", + "![Image Name](https://cdn.kesci.com/upload/image/q2adbzizer.png?imageView2/0/w/960/h/960)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "403892DB5D994FDE98D83C372272EF44", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "grid = plt.GridSpec(2, 3, wspace=0.4, hspace=0.3)\r\n", + "plt.subplot(grid[0, 0])\r\n", + "plt.subplot(grid[0, 1:])\r\n", + "plt.subplot(grid[1, :2])\r\n", + "plt.subplot(grid[1, 2]);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C6C2FE66D6CC41EB85D89D5D520AAEE9", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "37.显示一组二维数据的频度分布，并分别在x,y轴上，显示该维度的数据的频度分布" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "FD5FD4186BF5465581770F8680520FC6", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "mean = [0, 0]\r\n", + "cov = [[1, 1], [1, 2]]\r\n", + "x, y = np.random.multivariate_normal(mean, cov, 3000).T\r\n", + "\r\n", + "# Set up the axes with gridspec\r\n", + "fig = plt.figure(figsize=(6, 6))\r\n", + "grid = plt.GridSpec(4, 4, hspace=0.2, wspace=0.2)\r\n", + "main_ax = fig.add_subplot(grid[:-1, 1:])\r\n", + "y_hist = fig.add_subplot(grid[:-1, 0], xticklabels=[], sharey=main_ax)\r\n", + "x_hist = fig.add_subplot(grid[-1, 1:], yticklabels=[], sharex=main_ax)\r\n", + "\r\n", + "# scatter points on the main axes\r\n", + "main_ax.scatter(x, y,s=3,alpha=0.2)\r\n", + "\r\n", + "# histogram on the attached axes\r\n", + "x_hist.hist(x, 40, histtype='stepfilled',\r\n", + " orientation='vertical')\r\n", + "x_hist.invert_yaxis()\r\n", + "\r\n", + "y_hist.hist(y, 40, histtype='stepfilled',\r\n", + " orientation='horizontal')\r\n", + "y_hist.invert_xaxis()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F9D94228A31D461BB0EEFA18836E02B4", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 七、三维图像\n", + "38.创建一个三维画布" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "971935355E9541119A24FB646B674157", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from mpl_toolkits import mplot3d\r\n", + "fig = plt.figure()\r\n", + "ax = plt.axes(projection='3d')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "08E58FD685F94F9CB6752134EBA9B9AA", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "39.绘制一个三维螺旋线" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "16D5DEC385374959842B552150C227F3", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ax = plt.axes(projection='3d')\r\n", + "\r\n", + "# Data for a three-dimensional line\r\n", + "zline = np.linspace(0, 15, 1000)\r\n", + "xline = np.sin(zline)\r\n", + "yline = np.cos(zline)\r\n", + "ax.plot3D(xline, yline, zline);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "936285ADF58649308D21F348838797C1", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "40.绘制一组三维点" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "2ADFD2B400E647E78E0B81DD5D7EAC9A", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ax = plt.axes(projection='3d')\r\n", + "zdata = 15 * np.random.random(100)\r\n", + "xdata = np.sin(zdata) + 0.1 * np.random.randn(100)\r\n", + "ydata = np.cos(zdata) + 0.1 * np.random.randn(100)\r\n", + "ax.scatter3D(xdata, ydata, zdata, c=zdata, cmap='Greens');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "8486E6E999B04E249534A02CD140E712", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "df = pd.read_csv('Pokemon.csv')\n", + "df.head()\n", + "\n", + "plt.style.use('ggplot')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1AD3BC70D06145908EDCDCFE20963A7F", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "41.展示前5个宝可梦的`Defense,Attack,HP`的堆积条形图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "01D3EE0E2AFE4F659555D3B7916E6EA8", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "pokemon = df['Name'][:5]\r\n", + "hp = df['HP'][:5]\r\n", + "attack = df['Attack'][:5]\r\n", + "defense = df['Defense'][:5]\r\n", + "ind = [x for x, _ in enumerate(pokemon)]\r\n", + "\r\n", + "plt.figure(figsize=(10,10))\r\n", + "plt.bar(ind, defense, width=0.8, label='Defense', color='blue', bottom=attack+hp)\r\n", + "plt.bar(ind, attack, width=0.8, label='Attack', color='gold', bottom=hp)\r\n", + "plt.bar(ind, hp, width=0.8, label='Hp', color='red')\r\n", + "\r\n", + "plt.xticks(ind, pokemon)\r\n", + "plt.ylabel(\"Value\")\r\n", + "plt.xlabel(\"Pokemon\")\r\n", + "plt.legend(loc=\"upper right\")\r\n", + "plt.title(\"5 Pokemon Defense & Attack & Hp\")\r\n", + "\r\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3057D1FAD8A24A1C9B2CDA0E437C34AB", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "42.展示前5个宝可梦的`Attack,HP`的簇状条形图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "C53D0272339F46C084247E2F5BECF81E", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "N = 5\r\n", + "pokemon_hp = df['HP'][:5]\r\n", + "pokemon_attack = df['Attack'][:5]\r\n", + "\r\n", + "ind = np.arange(N) \r\n", + "width = 0.35 \r\n", + "plt.bar(ind, pokemon_hp, width, label='HP')\r\n", + "plt.bar(ind + width, pokemon_attack, width,label='Attack')\r\n", + "\r\n", + "plt.ylabel('Values')\r\n", + "plt.title('Pokemon Hp & Attack')\r\n", + "\r\n", + "plt.xticks(ind + width / 2, (df['Name'][:5]),rotation=45)\r\n", + "plt.legend(loc='best')\r\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B9BA406B4813420ABB8E0F443DDECB05", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "43.展示前5个宝可梦的`Defense,Attack,HP`的堆积图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "A042FEC242C14205853A61FDBB5D234A", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = df['Name'][:4]\r\n", + "y1 = df['HP'][:4]\r\n", + "y2 = df['Attack'][:4]\r\n", + "y3 = df['Defense'][:4]\r\n", + "\r\n", + "labels = [\"HP \", \"Attack\", \"Defense\"]\r\n", + "\r\n", + "fig, ax = plt.subplots()\r\n", + "ax.stackplot(x, y1, y2, y3)\r\n", + "ax.legend(loc='upper left', labels=labels)\r\n", + "plt.xticks(rotation=90)\r\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "276678D3B96D419D8CC5D86465CA4242", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "44.公用x轴，展示前5个宝可梦的`Defense,Attack,HP`的折线图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "9670132591CC48679498823E46424ABB", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = df['Name'][:5]\r\n", + "y1 = df['HP'][:5]\r\n", + "y2 = df['Attack'][:5]\r\n", + "y3 = df['Defense'][:5]\r\n", + "\r\n", + "# Create two subplots sharing y axis\r\n", + "fig, (ax1, ax2,ax3) = plt.subplots(3, sharey=True)\r\n", + "\r\n", + "ax1.plot(x, y1, 'ko-')\r\n", + "ax1.set(title='3 subplots', ylabel='HP')\r\n", + "\r\n", + "ax2.plot(x, y2, 'r.-')\r\n", + "ax2.set(xlabel='Pokemon', ylabel='Attack')\r\n", + "\r\n", + "ax3.plot(x, y3, ':')\r\n", + "ax3.set(xlabel='Pokemon', ylabel='Defense')\r\n", + "\r\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D9F126979B124B599A42BCC9016C8B6C", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "45.展示前15个宝可梦的Attack,HP的折线图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "26E32604016944158BC602F8C3EBFE99", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(df['HP'][:15], '-r',label='HP')\r\n", + "plt.plot(df['Attack'][:15], ':g',label='Attack')\r\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5C75152B180643B48AC3B16EBE10890F", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "46.用scatter的x,y,c属性，展示所有宝可梦的Defense,Attack,HP数据" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "3C4C0CEFB62B49F88EED5E9D295E6D8C", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = df['Attack']\n", + "y = df['Defense']\n", + "colors = df['HP']\n", + "\n", + "plt.scatter(x, y, c=colors, alpha=0.5)\n", + "plt.title('Scatter plot')\n", + "plt.xlabel('Attack')\n", + "plt.ylabel('Defense')\n", + "plt.colorbar(); " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "17F92C93781E497E8230064B5FDEA32A", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "47.展示所有宝可梦的攻击力的分布，bins=10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "3F4FC2D4903C44848557F8D1D8AF111A", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "x = df['Attack']\r\n", + "num_bins = 10\r\n", + "n, bins, patches = plt.hist(x, num_bins, facecolor='blue', alpha=0.5)\r\n", + "plt.title('Histogram')\r\n", + "plt.xlabel('Attack')\r\n", + "plt.ylabel('Value')\r\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "59079D33B0C04FAB8C81689AF9098BBA", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "48.展示所有宝可梦Type 1的饼图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "B7E1CE8DB07D476D998BC0F6D27320D9", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "plt.figure(1, figsize=(8,8))\r\n", + "df['Type 1'].value_counts().plot.pie(autopct=\"%1.1f%%\")\r\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "93031233A69B41DE8B1300BC29C1637B", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "49.展示所有宝可梦Type 1的柱状图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "93AA7B2C057E4FA793133EB05C634911", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "\r\n", + "ax = df['Type 1'].value_counts().plot.bar(figsize = (12,6),fontsize = 14)\r\n", + "ax.set_title(\"Pokemon Type 1 Count\", fontsize = 20)\r\n", + "ax.set_xlabel(\"Pokemon Type 1\", fontsize = 20)\r\n", + "ax.set_ylabel(\"Value\", fontsize = 20)\r\n", + "\r\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1DC97A890E8B434EB2CE278A806A2495", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "top_10_pokemon=df.sort_values(by='Total',ascending=False).head(10)\n", + "corr=top_10_pokemon.corr()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CF2E596DCEF544D18AAA510FE9D00FD2", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "50.展示综合评分最高的10只宝可梦的系数间的相关系数矩阵" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "603D2E40950E466B885FBAD3549F8580", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## “宝可梦数据集”可视化\n", + "展示综合评分最高的10只宝可梦的系数间的相关系数矩阵\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "id": "FDB996FCEAA84BCF9A3B90EF172E4002", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "\n", + "fig, ax=plt.subplots(figsize=(10, 6))\n", + "sns.heatmap(corr,annot=True)\n", + "ax.set_ylim(9, 0)\n", + "plt.show()" + ] + } + ], + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/练习题-scikit-learn.ipynb b/练习题-scikit-learn.ipynb new file mode 100644 index 0000000..cc5707f --- /dev/null +++ b/练习题-scikit-learn.ipynb @@ -0,0 +1,1448 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "E333D1B1D4604A1B9579241D78188A1A", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "scikit-learn 是基于 Python 语言的机器学习工具简单高效的数据挖掘和数据分析工具。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8706D955DC1B4FCF8375BC1211F3B00B", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 一、获取数据\n", + "\n", + "1.导入sklearn的数据集模块 \n", + "2.导入预置的手写数字数据集 \n", + "3.生成数据用于聚类，100个样本，2个特征，5个类 " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "id": "9889EC4A0B56451B8F68CDCA1AA94DFE", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn import datasets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "id": "5245D3AD5A5940918F5EB4CAC6020006", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "digits = datasets.load_digits()\n", + "\n", + "plt.matshow(digits.images[0])\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "id": "8ABF44102D694501A3A158F72B923C4C", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data, label = datasets.make_blobs(n_samples=100, n_features=2, centers=5)\n", + "\n", + "plt.scatter(data[:, 0], data[:, 1], c=label)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "500852AD3E8441E9891E9702B65D7EA5", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 二、数据预处理\n", + "\n", + "4.导入sklearn的预处理模块 \n", + "5.计算一组数据的平均值和标准差（scaler） \n", + "6.使用上一题的scaler标准化现有数据 \n", + "7.用最小最大规范化对数据进行线性变换，变换到[0,1]区间 \n", + "8.用L2正则化对数据进行变换 \n", + "9.对现有数据进行one-hot编码 \n", + "10.给定阈值，将特征转换为0/1 \n", + "11.对现有数据进行标签编码 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "id": "B240AFA95F954E3BBB56BC07B931C3C8", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn import preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "id": "1E0AF8E831F545DF8CC4A38FE210FB81", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.25 0.75]\n", + "[0.6875 0.6875]\n" + ] + } + ], + "source": [ + "data = [[0, 0], [1, 0], [-1, 1], [1, 2]]\n", + "\n", + "scalerstd = preprocessing.StandardScaler().fit(data)\n", + "\n", + "print(scalerstd.mean_)\n", + "print(scalerstd.var_)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "id": "FFFE0C9C32394F6484807454DB82FCCC", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.30151134, -0.90453403],\n", + " [ 0.90453403, -0.90453403],\n", + " [-1.50755672, 0.30151134],\n", + " [ 0.90453403, 1.50755672]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scalerstd.transform(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "id": "861EE07038D148DE81E35C95FEABDF71", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.5, 0. ],\n", + " [1. , 0. ],\n", + " [0. , 0.5],\n", + " [1. , 1. ]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scalermm = preprocessing.MinMaxScaler(feature_range=(0, 1)).fit(data)\n", + "scalermm.transform(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "id": "622480736EDA4C408994B73658561E2B", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.40824829, -0.40824829, 0.81649658],\n", + " [ 1. , 0. , 0. ],\n", + " [ 0. , 0.70710678, -0.70710678]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X = [[ 1., -1., 2.],\r\n", + " [ 2., 0., 0.],\r\n", + " [ 0., 1., -1.]]\r\n", + " \r\n", + "scalernorm = preprocessing.Normalizer(norm='l2').fit(X)\r\n", + "scalernorm.transform(X)\r\n", + "\r\n", + "# 方法二\r\n", + "# preprocessing.normalize(X, norm='l2')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "id": "CB791245CDC34331831B65766D6E92BC", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 1., 0., 0., 0., 0., 0., 1.],\n", + " [0., 1., 0., 1., 0., 1., 0., 0., 0.],\n", + " [1., 0., 0., 0., 1., 0., 1., 0., 0.],\n", + " [0., 1., 1., 0., 0., 0., 0., 1., 0.]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = [[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]\r\n", + "\r\n", + "scaleronehot = preprocessing.OneHotEncoder().fit(data)\r\n", + "scaleronehot.transform(data).toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "id": "5D94FE6955324B80986A17DA71963F5F", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 0],\n", + " [1, 0],\n", + " [0, 1],\n", + " [1, 1]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = [[0, 0], [1, 0], [-1, 1], [1, 2]]\r\n", + "\r\n", + "scalerbin = preprocessing.Binarizer(threshold=0.5)\r\n", + "scalerbin.transform(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "id": "11FA1765E2B14178866C9463154125D4", + "jupyter": {}, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 2, 1])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scalerlabel = preprocessing.LabelEncoder()\r\n", + "scalerlabel.fit([\"paris\", \"paris\", \"tokyo\", \"amsterdam\"])\r\n", + "scalerlabel.transform([\"tokyo\", \"tokyo\", \"paris\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F062FBAA818444A5B623219CD627A093", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 三、数据及拆分\n", + "12.将现有数据划分为训练集和测试集，测试集数量占比为30% \n", + "13.将现有数据划分为3折" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false, + "id": "E29143D0ECCA47A99E8850A4D90C9C90", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(506, 13)\n", + "(354, 13) (152, 13) (354,) (152,)\n" + ] + } + ], + "source": [ + "from sklearn import model_selection\n", + "\n", + "dataset = datasets.load_boston()\n", + "print(dataset.data.shape)\n", + "\n", + "X_train, X_test, y_train, y_test = model_selection.train_test_split(\n", + " dataset['data'], dataset['target'], test_size=0.3)\n", + "\n", + "print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "id": "5AC25FD3A46541D78235DFAA55F78764", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['c' 'd' 'e' 'f'] ['a' 'b']\n", + "['a' 'b' 'e' 'f'] ['c' 'd']\n", + "['a' 'b' 'c' 'd'] ['e' 'f']\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "X = np.array(['a', 'b', 'c', 'd','e','f'])\n", + "\n", + "kfold = model_selection.KFold(n_splits=3)\n", + "\n", + "for train, test in kfold.split(X):\n", + " print(\"%s %s\" % (X[train], X[test]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "885CA26CAD8F48598D4E0C170780F47C", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 四、使用模型\n", + "14.定义一个线性回归模型 \n", + "15.导入预置的波士顿房价数据集 \n", + "16.设置房价为Y，剩余参数为X，30%为测试集 \n", + "17.用线性回归模型拟合波士顿房价数据集 \n", + "18.用训练完的模型进行预测 \n", + "19.输出线性回归模型的斜率和截距 \n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false, + "id": "077D9C2AD9C844C18DB5A26A54D75E2F", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LinearRegression\r\n", + "model = LinearRegression(fit_intercept=True, normalize=False,\r\n", + " copy_X=True, n_jobs=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "id": "C04B3C81C8CF477E92CBDA50BF7720E3", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "X, y = datasets.load_boston(return_X_y=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false, + "id": "99ABDB9E01704C5F8A65A03034CAC3F7", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false, + "id": "4801CCD8008B4B1082FF6F3BEA74C7F1", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false, + "id": "4A5A4DC52B4D441EB6B9BA502F42B750", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([26.25992442, 9.33883098, 21.75140576, 22.37604127, 20.35694029,\n", + " 33.60313065, 32.74481597, 22.42294065, 19.77760437, -1.16132012,\n", + " 17.42166101, 23.90283624, 22.91482041, 33.33912062, 24.90583361,\n", + " 27.07570535, 22.50942758, 24.27950142, 23.14308679, 20.4519883 ,\n", + " 21.18500858, 22.71856646, 28.96456539, 15.1816301 , 16.11395526,\n", + " 4.45492848, 7.63407352, 23.21888697, 30.06713783, 15.66697326,\n", + " 1.91385942, 19.5744595 , 18.36044805, 14.97085203, 33.07583387,\n", + " 28.99710169, 17.08602777, 17.68206796, 24.38433921, 31.84395163,\n", + " 27.17738463, 14.21843726, 19.80308011, 28.59901009, 24.97776751,\n", + " 26.02398851, 16.91294041, 17.42587988, 0.55902561, 25.3388113 ,\n", + " 36.41874456, 23.59401747, 17.72416277, 16.14813729, 28.00989384,\n", + " 17.35799279, 36.41708025, 29.18561542, 23.79300249, 6.29263901,\n", + " 17.60820019, 19.95362871, 31.42198875, 9.8463655 , 19.82505449,\n", + " 17.07264779, 12.38176939, 12.07088755, 42.85010741, 13.27478279,\n", + " 20.85344993, 9.39413037, 19.5308154 , 23.65314683, 32.08224811,\n", + " 12.20150518, 19.13611999, 16.6004374 , 18.60276918, 28.50904817,\n", + " 31.17134321, 14.49184249, 27.78355914, 21.24917749, 11.6699463 ,\n", + " 24.73315594, 40.34475157, 33.52395684, 33.1660618 , 17.62539932,\n", + " 10.1149138 , 7.79037579, 33.96163483, 16.47708501, 15.76467167,\n", + " 11.54067456, 16.43648691, 18.23904667, 16.19126795, 23.06735198,\n", + " 19.08841561, 25.01201027, 24.98775488, 32.97720347, 41.44918068,\n", + " 18.26663105, 22.87562075, 21.57163237, 4.03271866, 25.31185036,\n", + " 12.13010727, 11.04373587, 24.544449 , 21.49494578, 28.42720974,\n", + " 18.51370177, 24.11617214, 28.86911973, 21.84982351, 12.08741406,\n", + " 29.43700453, 21.69498476, 18.06102892, 36.21763431, 14.22686119,\n", + " 21.24394032, 17.04974228, 31.65802364, 26.97624501, 30.14965158,\n", + " 39.8483785 , 14.42263502, 40.58493873, 18.32148322, 1.91991319,\n", + " 29.94117969, 38.72774404, 19.90188405, 32.37801611, 32.66018266,\n", + " 13.80732092, 31.3866927 , 34.15759749, 21.36491441, 17.51973851,\n", + " 33.93425209, 11.09472335, 7.96496583, 21.28349987, 20.00715547,\n", + " 30.40979304, 25.68242696])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false, + "id": "A93B3F93D495430ABDF41FA407561204", + "jupyter": {}, + "scrolled": true, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-5.00288043e-02 3.56568764e-02 6.93465436e-02 2.16769447e+00\n", + " -1.52079455e+01 4.15011712e+00 -2.37994210e-03 -1.13384381e+00\n", + " 2.83383718e-01 -1.69703242e-02 -8.63184202e-01 7.58941210e-03\n", + " -5.24753110e-01]\n", + "31.871833311681854\n" + ] + } + ], + "source": [ + "print(model.coef_)\n", + "print(model.intercept_)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "37B27817E12741BDB1AA639CC07B8088", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 五、评估\n", + "20.使用随机森林对鸢尾花数据集进行预测，`n_estimators=100` \n", + "21.给产生的随机森林模型打分 \n", + "22.输出模型的recision_score、recall_score、f1_score" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false, + "id": "016B68FB4EF7412C8456F4D522CB6F1E", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 2, 0, 1, 2, 2, 2, 1, 1, 0, 1, 0, 0, 0, 1, 2, 0, 0, 1, 0, 0, 0,\n", + " 2, 2, 1, 0, 0, 2, 2, 0, 1, 2, 1, 0, 2, 0, 1, 2, 2, 0, 0, 0, 2, 0,\n", + " 2])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import RandomForestClassifier\n", + "X,y = datasets.load_iris(return_X_y=True)\n", + "X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.3)\n", + "\n", + "clf = RandomForestClassifier(n_estimators=100)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "y_pred = clf.predict(X_test)\n", + "y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false, + "id": "2CB5AA05EC6348D88A363DDD34D2B176", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9866666666666667" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf.score(X,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false, + "id": "7CCF270A009F471581177C46E68E4FCD", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 20\n", + " 1 0.90 0.90 0.90 10\n", + " 2 0.93 0.93 0.93 15\n", + "\n", + " accuracy 0.96 45\n", + " macro avg 0.94 0.94 0.94 45\n", + "weighted avg 0.96 0.96 0.96 45\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.metrics import classification_report\n", + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8023E1F89F43481980E3B333503C76B2", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "23.使用手写数字数据集，随机森林算法进行分类，画出学习曲线 \n", + "24.使用手写数字数据集，随机森林算法进行分类，参数n_estimators选择范围为`[10,20,40,80,160,250]`，画出验证曲线 " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false, + "id": "046D87F540BE48778048ED45828E2D25", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.model_selection import learning_curve\n", + "\n", + "X,y = datasets.load_digits(return_X_y=True)\n", + "\n", + "train_sizes,train_score,test_score = learning_curve(RandomForestClassifier(n_estimators = 10),X,y,train_sizes=[0.1,0.2,0.4,0.6,0.8,1],scoring='accuracy')\n", + "\n", + "train_error = 1- np.mean(train_score,axis=1)\n", + "test_error = 1- np.mean(test_score,axis=1)\n", + "\n", + "plt.plot(train_sizes,train_error,'o-',color = 'r',label = 'training')\n", + "plt.plot(train_sizes,test_error,'o-',color = 'g',label = 'testing')\n", + "plt.legend(loc='best')\n", + "plt.xlabel('traing examples')\n", + "plt.ylabel('error')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false, + "id": "A8E8F1E69E36407D8365E0A5CE732DE9", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.model_selection import validation_curve\n", + "\n", + "X,y = datasets.load_digits(return_X_y=True)\n", + "param_range = [10,20,40,80,160,250]\n", + "\n", + "train_score,test_score = validation_curve(RandomForestClassifier(),X,y,param_name='n_estimators',param_range=param_range,cv=10,scoring='accuracy')\n", + "\n", + "train_score = np.mean(train_score,axis=1)\n", + "test_score = np.mean(test_score,axis=1)\n", + "\n", + "plt.plot(param_range,train_score,'o-',color = 'r',label = 'training')\n", + "plt.plot(param_range,test_score,'o-',color = 'g',label = 'testing')\n", + "plt.legend(loc='best')\n", + "plt.xlabel('number of tree')\n", + "plt.ylabel('accuracy')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EDA1626B8090472AB76AFE0CBB545DB7", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "25.使用网格搜索，得手写数字数据集+随机森林算法的最优参数" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false, + "id": "DB020D40C8574D308949F89EE66663DC", + "jupyter": {}, + "scrolled": true, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n", + " criterion='gini', max_depth=None, max_features='auto',\n", + " max_leaf_nodes=None, max_samples=None,\n", + " min_impurity_decrease=0.0, min_impurity_split=None,\n", + " min_samples_leaf=1, min_samples_split=3,\n", + " min_weight_fraction_leaf=0.0, n_estimators=50,\n", + " n_jobs=None, oob_score=False, random_state=None,\n", + " verbose=0, warm_start=False),\n", + " 0.9360290931600124,\n", + " {'min_samples_split': 3, 'n_estimators': 50})" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.model_selection import GridSearchCV\n", + "X,y = datasets.load_digits(return_X_y=True)\n", + "# 随机森林的参数\n", + "tree_param_grid={'min_samples_split':[3,6,9],'n_estimators':[10,50,100]}\n", + "grid=GridSearchCV(RandomForestClassifier(),param_grid=tree_param_grid,cv=5)\n", + "grid.fit(X,y)\n", + "grid.best_estimator_,grid.best_score_,grid.best_params_" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CB2F58C77FA44AFDA2F7D7E045B516F4", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "26.取鸢尾花数据集中，类型=0,1的数据，变成一个二分类问题，使用线性内核的SVM进行拟合 \n", + "27.计算出对应的ROC曲线 \n", + "28.计算出对应的AUC " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false, + "id": "0A9E96C860CE40068C4938E14F53BF78", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n", + " decision_function_shape='ovr', degree=3, gamma='scale', kernel='linear',\n", + " max_iter=-1, probability=True, random_state=None, shrinking=True, tol=0.001,\n", + " verbose=False)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import svm\n", + "X,y = datasets.load_iris(return_X_y=True)\n", + "X, y = X[y != 2], y[y != 2]\n", + "\n", + "# 加一些噪音，不然模型太准了\n", + "random_state = np.random.RandomState(0)\n", + "n_samples, n_features = X.shape\n", + "X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]\n", + "\n", + "X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=.3,random_state=0)\n", + "\n", + "svm = svm.SVC(kernel='linear', probability=True)\n", + "\n", + "svm.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false, + "id": "098C8F50FDA8465FA08E43D5526DDC6A", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD6CAYAAAC1W2xyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAHnNJREFUeJzt3XmczWX/x/HXZRkzGIMx9i25yaAhQ9bJTlEhbUaWyNp+a1ERpUW5k71Gi1/FTYQs2SMkivtGRSq06G6ZsY1t9uv3x0zdNfcwxzjnfM/yfv7Td8Y157y/jznznm/XnPM5xlqLiIgEjkJOBxAREfdSsYuIBBgVu4hIgFGxi4gEGBW7iEiAUbGLiAQYFbuISIBRsYuIBBgVu4hIgCnixJ2WK1fO1qxZ04m7FhHxW7t27Uqy1kblt86RYq9ZsyY7d+504q5FRPyWMeZ7V9ZpK0ZEJMCo2EVEAoyKXUQkwKjYRUQCjIpdRCTAuFTsxpiixpjlF/j3UGPMCmPMHmPM28YY476IIiJyMfItdmNMGLAL6HSBZX2BI9baGKBMPmtFRMSD8n0eu7X2HHClMebbCyxrD7yXc/wh0A5Ye+nxRILE3gTYP8/pFOJB6RmGw7+FUqdRXWj3skfvy1177JHAyZzjZKBs7gXGmCHGmJ3GmJ2JiYluuluRALF/HiTudjqFeMi/D5ek2RNNaPd0Y86c8/z9ueuVp0lARM5xRM7Hf2GtTQASAGJjY/UO2iK5RTWCWzc5nULcKCUlg/HjN/Hii9soV644M1/rRonr6nn8ft1V7BuAzmRvx7QHJrvpdkVE/FaPHvNZs+YgAwc24h//6EyZMmFeud+L3ooxxlxmjJmU69NzgSrGmL3AMbKLXkQk6Jw6lUpKSgYAjz7amrVr+/LGGzd6rdThIq7YrbW1c/57GBiV699Sge7ujSYi4l/WrPmWIUNW0LdvQ555pgNt29Z0JIdeoCQicomOHTvHgAFL6dp1LsWLF6VbtzqO5nFkbK+ISKDYsOEQ8fGLOXr0HI8/3oYnnogjNNTZalWxi4hcgvLlS3DZZWVYvbovjRpVdDoOoK0YEZGLYq1lzpzd3HvvKgAaNqzAtm13+kypg4pdRMRlhw8fp0uXdxg48H127/6Fc+fSAfC18VjaihERyUdmZhYzZnzG6NEbKFTIMHPmdQwdGkuhQr5V6L9TsYuI5CMp6Sxjx27kmmtq8Mor3alePSL/L3KQil0Cnz8M2ErcnT1SQHxGenomc+d+Tr9+MVSoUJJ//Wsol11W2ue2XfKiPXYJfP4wYCuqEdTr43QKybFr13+IjZ3NwIHvs27dQQBq1SrjF6UOumKXYKEBW+KCc+fSGT/+IyZN2kb58iVYsuRWunSp7XSsi6ZiFxHJ0aPHAtauPcjgwY158cXOlC4d6nSkAlGxi0hQS05OJSSkMKGhRXjssdY8/HBLOnSo5XSsS6I9dhEJWh988A0NGszkqac+AuCaa2r6famDil1EglBS0lnuuGMJ3brNIzy8GDfcUNfpSG6lrRgRCSrr1h0kPn4xx4+nMHZsHI891oZixQKrCgPrbERE8lGpUjh16kQya1Y3Gjas4HQcj9BWjIgENGstr732L0aOXAlAgwbl2bJlYMCWOqjYRSSAHTp0nI4d3+auu5azb1+Szw7tcjdtxYhIwMnMzGLq1B08/viHFClSiFdf7c7gwVf57NAud1Oxi0jASUo6y/jxH9GhQy1mzepG1aqlnI7kVSp2EQkIaWmZvPPOXgYMaESFCiXZvXsYNWpEBPy2S15U7CLi9z777CfuvHMZX3zxG1WrlqJz58upWbO007Ecoz+eiojfOns2nVGj1tK8+escP36OZctuo3Pny52O5ThdsYuI37rxxvmsX3+IIUOu4oUXOhER4Z9Du9xNxS4ifuXkyRSKFStCaGgRxoyJ47HHWtOu3WVOx/Ip2ooREb+xYsXX1K8/k/HjNwEQF1dDpZ4HFbuI+LzExDP06fMe11//T8qWDaNXr3pOR/Jp2ooREZ+2dm320K6TJ1MYP74tjz7ampCQwk7H8mkqdhHxaVWqhFOvXjlmzepG/frlnY7jF7QVIyI+JSvLkpCwi+HDVwBQv355Nm8eqFK/CCp2EfEZ3357jA4d3mLo0BUcOHD0j6FdcnG0FSMijsvMzOLll7czZsxGihYtzOzZ1zNoUOOgHAfgDvkWuzEmFFgEVAP2Av2stTbXmhLAPKAc8LG19mEPZBWRAJWUdJYJE7bQqdPlzJx5HVWqBNfQLndzZSumL3DEWhsDlAE65bEmHthurW0F1DfG6LlIInJBqakZzJ69i6wsmzO0ayhLl96qUncDV7Zi2gPv5Rx/CLQD1uZakwoUN9n/3xQKpLktoQSfvQmwf577bi9xN0Q1ct/tySXbseMIgwYt48svE6lRozSdO19OjRrBO7TL3Vy5Yo8ETuYcJwNl81gzD7gW2A98Za09mHuBMWaIMWanMWZnYmJiQfNKMNg/L7uM3SWqEdTr477bkwI7cyaNBx9cQ4sWr3PyZCorV/bR0C4PcOWKPQmIyDmOyPk4t9HAK9ba14wx/zTGtLTWbvvzAmttApAAEBsba/O4DZH/imoEt25yOoW4WY8eC1i//hDDh8fy/PMdKVWqmNORApIrV+wbgM45x+2BjXmsCQdSco5TgZKXHk1EAsGJEyl/PG1x7Ng4PvpoADNndlOpe5ArxT4XqGKM2QscAw4aYyblWjMDGG6M+QQII/uXgYgEuWXLDuQM7foIgDZtahAXV8PhVIEv360Ya20q0D3Xp0flWvMd0Mp9sUTEn/322xnuvXcVCxZ8yZVXVqB372inIwUVvUBJRNxq9epviY9fzOnTaTz9dDseeaQVRYtqaJc3qdhFxK2qVStFw4blmTmzG9HRUU7HCUqaFSMilyQryzJr1mcMHbocyB7atWnTAJW6g1TsIlJgX399lLZt5zBixAccPnyClJQMpyMJKnYRKYCMjCwmTtzKlVfO4vPPf+PNN29kzZq+hIZqd9cX6LsgIhft6NGzTJz4Mddd9zdmzLiOSpXCnY4kf6JiFxGXpKZmMGfObu66qwkVKpRkz55hVKsWkf8Xitep2IORu4dsuZuGdvmcTz75kUGDlrF/fxKXX16Wjh1rqdR9mPbYg5G7h2y5m4Z2+YzTp9O4//7VtGr1BmfOpLN6dTwdO9ZyOpbkQ1fswUpDtsQFPXrMZ8OGw9x9d1OefbYD4eGa7+IPVOwi8hfHj58jNLQIYWFFGTeuLePGtaV16+pOx5KLoK0YEfnD4sX7iY6eybhxmwBo3bq6St0PqdhFhF9+OU3v3u9y003vUrFiSW67rYHTkeQSaCtGJMitWvUN8fGLOXs2nWefbc+oUS01tMvPqdhFglyNGqVp3LgSM2ZcxxVXlHM6jriBtmJEgkxWlmX69E+5665lAERHR7FhQz+VegBRsYsEkQMHkoiLe5N77lnFjz8ma2hXgFKxiwSB9PRMnntuCzExr7BvXyJz5tzIqlXxGtoVoPRdFQkCx4+n8OKL27j++rpMm3YtFSvq/eYDmYpdJEClpGTwxhv/ZtiwWMqXL8HevcOpWrWU07HEC1Tsvs4TA7s0ZCvgbd36A4MGLePrr49Sp04kHTvWUqkHEe2x+zpPDOzSkK2AdepUKnff/QFt2rxJWloma9f21dCuIKQrdn+ggV3ioh49FrBx42Huu+9qJkxoT8mSIU5HEgeo2EX83LFj2UO7ihcvytNPt8OYdrRoUc3pWOIgbcWI+LFFi/ZRr96MP4Z2tWxZTaUuKnYRf/Tzz6fo1WsBN9+8kGrVShEf39DpSOJDtBUj4mdWrvyavn2XkJKSwcSJHXnwwRYUKaJrNPkvFbuIn6lVqwxNm1Zm+vTrqFMn0uk44oP0a17Ex2VmZjFlynYGDXofgHr1oli79g6VupyXil3Eh+3bl0ibNm9y//1r+OWXMxraJS5RsYv4oLS0TCZM2Ezjxq/y9ddHeeednqxYcbuGdolL8n2UGGNCgUVANWAv0M9aa/NY9zBwPXAauNFam+bmrCJB48SJFCZP3k7Pnlcwdeq1lC9fwulI4kdcuWLvCxyx1sYAZYBOuRcYY2oB9a21bYBVQFW3phQJAufOpTN9+qdkZVnKly/B558PZ/783ip1uWiuFHt7YF3O8YdAuzzWdADKGGM2A22Aw+6JJxIcNm/+npiYV7jnnlVs3Jj941O5crjDqcRfuVLskcDJnONkoGwea6KARGttHNlX661zLzDGDDHG7DTG7ExMTCxoXpGAkpycyogRK7nmmjlkZGSxfv0ddOigoV1yaVz5S0wSEJFzHJHzcW7JwIGc40NAldwLrLUJQAJAbGzs/+zRiwSjHj3ms2nTdzzwQHOefrodJUpoaJdcOleKfQPQGXiP7G2ZyXms2QU8mHNcm+xyF5E8JCWdpXjxohQvXpRnnmmPMYbmzfVnKXEfV7Zi5gJVjDF7gWPAQWPMpD8vsNZ+AiQZYz4DDlhrP3V/VBH/Zq1l/vwvqFdvBk8+uRGAFi2qqdTF7fK9YrfWpgLdc316VB7rhrsrlEig+emnZEaM+IBlyw7QtGll+vWLcTqSBDC92kHEw1as+Jr4+MWkp2cyaVIn7r+/OYUL67WB4jkqdhEPq127LC1bVmPatGupXTuvJ5WJuJcuG0TcLDMzi8mTP2HAgKUAXHFFOVatilepi9eo2EXc6Msvf6NVqzd48MG1JCWd1dAucYSKXcQN0tIyeeqpj2jc+FUOHjzOvHm9WL5cQ7vEGXrUibjBiRMpTJ26g5tvrs/LL3chKkrzXcQ5KnaRAjp7Np3Zs3dx993N/hjaVamS5ruI81TsIgWwceNhBg9ezqFDx2nQoDwdOtRSqYvP0B67yEU4eTKFoUOX0779WxgDGzf219Au8Tm6Yhe5CD16LGDz5u956KGWjBvXluLFizodSeR/qNhF8pGYeIYSJUIoXrwozz3XgcKFDU2b/s8AUxGfoa0YkfOw1jJv3ud/GdrVvHlVlbr4PBW7SB6OHEnmhhvmEx+/mNq1yzJgQCOnI4m4TFsxIrksW3aAvn0Xk5lpmTy5C/fc00xDu8SvqNhFcqlTJ5LWraszffp11KpVxuk4IhdNlyES9DIyspg0aRv9+i0Bsod2ffBBvEpd/JaKXYLa3r2/0qLF6zz00DqSk1M1tEsCgopdglJqagZPPrmRJk0S+OGHk7z7bm+WLLlVQ7skIOhRLEEpOTmVmTN3cvvtDZg8uQuRkcWdjiTiNip2CRpnzqSRkLCLe++9mqioEnzxxXAqVCjpdCwRt1OxS1DYsOEQd921nMOHTxATU5H27S9TqUvA8q9i35sA++c5ncK7EndDlF4cU1AnTqQwatRaXn/93/ztb2X56KMBxMXVcDqWiEf5V7Hvnxd8RRfVCOr1cTqF3+rZcwFbtnzPI4+04sknryEsTEO7JPD5V7FDdtHdusnpFOLDfv31NCVLhlCiRAjPP9+BIkUK0aRJZadjiXiNnu4oAcNay9tv7yE6eiZPPrkJgKuvrqpSl6CjYpeA8MMPJ+nWbR79+i2lbt1IBg1q7HQkEcf431aMSC7vv/8VffsuwVrL1KldGTGiqYZ2SVBTsYvfstZijOGKK8rRtm1Npk27lpo1SzsdS8RxuqwRv5ORkcXEiVu5447soV1165Zj+fLbVeoiOVTs4lf27PmFq69+jUcf3cDZs+ka2iWSBxW7+IWUlAyeeOJDYmNn89NPySxadDOLF2tol0he9FMhfuHUqVRefXUX8fENeemlLpQtG+Z0JBGfle8VuzEm1BizwhizxxjztjHGXGDtA8aY9e6NKMHq9Ok0Jk3aRmZmFlFRJdi3bwRz5vRQqYvkw5WtmL7AEWttDFAG6JTXImNMDWCA+6JJMFu79iANGszk4YfXsXnz9wBERZVwOJWIf3Cl2NsD63KOPwTanWfdFGC0O0JJ8Dp27BwDB75Ply7vEBpahC1bBtKu3WVOxxLxK67ssUcCJ3OOk4G6uRcYY/oAe4B957sRY8wQYAhA9erVLzqoBIeePRfw8cc/8NhjrRkz5hr9cVSkAFz5qUkCInKOI3I+zq07UB3oAtQ1xtxtrZ3+5wXW2gQgASA2NtYWOLEEnF9+OU14ePbQrhdf7ERISGEaNarodCwRv+XKVswGoHPOcXtgY+4F1to+1trWwG3ArtylLpIXay1z5uwmOnoGY8dmP6yaNauiUhe5RK4U+1ygijFmL3AMOGiMmeTZWBLovvvuBF27zmXgwPepX788Q4Y0cTqSSMDIdyvGWptK9lbLn406z9rvgI6XHksC2ZIl+7njjiUYY5g+/VqGD29KoULnfRatiFwk/WVKvOb3oV3165enY8daTJnSlRo1NN9FxN00UkA8Lj09k2ef3UJ8/GIA6tSJZOnS21TqIh6iYheP+te/fqZZs9d4/PEPycy0pKZqaJeIp6nYxSPOnUtn9Oj1NGs2m19+Oc2SJbeyYEFvihXT7p+Ip+mnTDzizJl0Xn/93/TvH8OkSZ0pU0bzXUS8RcUubnPqVCqzZu3k739vQblyxdm3byTlyhV3OpZI0FGxi1usXv0tQ4eu4McfT9KsWRXatq2pUhdxiPbY5ZIcPXqW/v2Xcu21cylRoigff3wnbdvWdDqWSFDTFbtckl693mXbth8ZMyaOxx9voz+OivgA/RTKRfv551OEhxejZMkQJk3KHtoVE6P5LiK+Qlsx4jJrLW+88W/q1fvv0K6mTauo1EV8jK7YxSWHDh1n6NAVrF9/iLi4GgwbFut0JBE5DxW75Gvx4uyhXYULG2bN6saQIU00tEvEh6nY5bx+H9rVsGF5unatzcsvd6FatYj8v1BEHKU9dvkfaWmZTJiwmT59FmOt5W9/i+S9925RqYv4CRW7/MXOnf+hadPZjBmT/cfRtLRMhxOJyMVSsQuQPbTr4YfXcfXVr5GUdJb337+Nf/7zJj0vXcQP6adWgOyhXXPm7GbQoMa88EInSpcOdTqSiBSQij2IJSenMnPmZzz0UEvKlSvO/v0jiYzUfBcRf6diD1IrV37NsGEr+c9/TtG8eVXatq2pUhcJENpjDzKJiWeIj19M9+7/JCKiGNu2aWiXSKDRFXuQuemmd9m+/Qjjxl3D6NFtCAkp7HQkEXEzFXsQ+OmnZCIiQilZMoTJk7tQrFgRGjQo73QsEfEQbcUEMGsts2fvIjp65h9Du5o0qaxSFwlwumIPUAcPHuOuu5azceN3tGtXk5EjmzodSUS8RMUegBYt2ke/fksoWrQwCQndGTz4KozR0C6RYKFiDyC/D+2KialAt251mDy5C1WrlnI6loh4mfbYA0BaWibjx2/ittve+2No18KFN6vURYKUit3PffrpTzRpksC4cR9RpEghDe0SERW7vzp7Np1Ro9bSosXrHD9+juXLb2fu3F4a2iUi2mP3V+fOpfPOO3sZMuQqJk7sRKlSxZyOJCI+4oJX7MaYUGPMCmPMHmPM2yaPp1aYbP9njNlujFlmjNEvCw85eTKFZ57ZTEZGFpGR2UO7Zs3qrlIXkb/IbyumL3DEWhsDlAE65bGmFVDEWtscKAV0dm9EAVi+/EDOC402sXXrDwCUKRPmcCoR8UX5FXt7YF3O8YdAuzzW/ApMyTlOc1MuyZGYeIbbb3+PG26YT2RkGDt2DNbQLhG5oPy2TSKBkznHyUDd3Austd8AGGN6AiHAmrxuyBgzBBgCUL169QLGDT6/D+166qm2PPJIaw3tEpF85VfsScDv72AckfPx/zDG3ADcB1xvrc3z+XbW2gQgASA2NtYWKG2QOHIkmdKls4d2vfxyV4oVK0z9+prvIiKuyW8rZgP/3TNvD2zMvcAYUxF4COhmrT3l3njBJSvL8uqrO4mOnsGYMR8CcNVVlVTqInJR8iv2uUAVY8xe4Bhw0BgzKdea/kAlYI0xZqsx5k4P5Ax433xzlPbt/49hw1bSrFkV7rnnaqcjiYifuuBWjLU2Feie69Ojcq2ZCEx0c66gsnDhl/Trt5RixQrz+us3MHBgIw3tEpEC03POHfT70K7GjStx4411eemlLlSuHO50LBHxcxop4IDU1AzGjt3ILbcswlpL7dplmT+/t0pdRNxCxe5l27cf4aqrEnj66c2EhRXR0C4RcTsVu5ecOZPGAw+spmXL1zl1KpUPPujDW2/11NAuEXE7tYqXpKRkMH/+l4wY0ZTnnutAeLjmu4iIZ6jYPejEiRSmTdvB6NFt/hjaVbp0qNOxRCTAaSvGQ5Yu/Yro6BmMH/8R27b9CKBSFxGvULG72a+/nuaWWxbSs+cCypcvwY4dg4mLq+F0LBEJItqKcbPevRfy6ac/MWFCOx5+uBVFi2pol4h4l4rdDX744SRlyoQSHl6MqVO7UqxYEaKjo5yOJSJBSlsxlyAryzJjxqfUrz+TsWOz56M1blxJpS4ijtIVewEdOJDE4MHL2br1Bzp1qsV99zV3OpKICKBiL5B33/2Sfv2WEBZWlDffvJH+/WM0tEtEfIaK/SL8PrSrSZNK9OpVj5de6kLFiiWdjiUi8hfaY3dBSkoGjz++gd69F2Kt5fLLyzJv3k0qdRHxSSr2fGzb9iONG7/Ks89uJTw8REO7RMTnqdjP4/TpNO69dxWtW7/B2bPprF4dz5w5PTS0S0R8nlrqPNLSMlm0aB8jRzbl2Wc1tEtE/IeK/U+OHTvH1Kk7eOKJOMqWDWP//pFERGi+i4j4F23F5HjvvX1ER89gwoTNfwztUqmLiD8K+mL/+edT3HTTu/TuvZDKlcPZuXOIhnaJiF8L+q2YW25ZxGef/cTzz3fg739vSZEiQf+7TkT8XFAW+/ffn6Bs2TDCw4sxbdq1hIUVoW7dck7HEhFxi6C6PM3KskybtoP69WcyZkz20K5GjSqq1EUkoATNFftXXyUxePAyPv74R7p2rc0DD2hol4gEpqAo9vnzv6B//6WULBnCW2/1oG/fKzW0S0QCVkAXe1aWpVAhQ9Omlbn55mj+8Y/OVKig+S4iEtgCco/93Ll0Hn10PTfd9O4fQ7veeaeXSl1EgkLAFfuWLd/TqNGrTJz4MZGRYaSnZzkdSUTEqwKm2E+dSmXkyJXExc0hPT2Tdevu4LXXbiAkRG8mLSLBJWD22NPTs1i69AD33381Eya0p0SJEKcjiYg4wq+L/ejRs0yZsoOxY6+hbNkwvvpqpKYwikjQu+BWjDEm1BizwhizxxjztsnjOYKurHE3ay0LF35JdPRMnntuK598kj20S6UuIpL/Hntf4Ii1NgYoA3Qq4Bq3+c+xEHr1epdbbllEtWql2LnzLtq00dAuEZHf5Vfs7YF1OccfAu0KuMZtbplSn9Wrv+WFFzqyfftgYmIqevLuRET8Tn577JHAyZzjZKBuAddgjBkCDAGoXr36RQcFoHwjZowqRFjcMOrUiSzYbYiIBLj8ij0JiMg5jsj5uCBrsNYmAAkAsbGx9qKTArR7mRiP/v+AiIj/y28rZgPQOee4PbCxgGtERMRL8iv2uUAVY8xe4Bhw0BgzKZ81G9wfU0REXHXBrRhrbSrQPdenR7mwRkREHBIwIwVERCSbil1EJMCo2EVEAoyKXUQkwKjYRUQCjLG2YK8VuqQ7NSYR+L6AX16O87wIKoDpnIODzjk4XMo517DWRuW3yJFivxTGmJ3W2linc3iTzjk46JyDgzfOWVsxIiIBRsUuIhJg/LHYE5wO4ACdc3DQOQcHj5+z3+2xi4jIhfnjFbuIiFyATxa7r77Xqie5eM7GGPN/xpjtxphlxhi/fjPyi/keGmMeMMas92Y+T3D1nI0xDxtjthhjVhljQryd051cfGyXMMa8b4z52BjzghM53c0YU9QYs/wC/+6xDvPJYscH32vVC1w5n1ZAEWttc6AU/52D769c+h4aY2oAA7yYy5PyPWdjTC2gvrW2DbAKqOrdiG7nyvc5HthurW0F1DfG1PNmQHczxoQBu7hwL3msw3y12H3uvVa9wJXz+RWYknOc5o1QHubq93AKMNoriTzPlXPuAJQxxmwG2gCHvZTNU1w551SgeM5Vayh+/vi21p6z1l4JHLnAMo91mK8We+73US1bwDX+JN/zsdZ+Y6391BjTEwgB1ngxnyfke87GmD7AHmCfF3N5kiuP2ygg0VobR/bVemsvZfMUV855HnAtsB/4ylp70EvZnOSxDvPVYnfbe636EZfOxxhzA3AfcL21NtNL2TzFlXPuTvYV7HygiTHmbi9l8xRXzjkZOJBzfAio4oVcnuTKOY8GXrHWXgGUNca09FY4B3msw3y12IPxvVbzPR9jTEXgIaCbtfaUF7N5Sr7nbK3tY61tDdwG7LLWTvdiPk9w5XG7C2iac1yb7HL3Z66ccziQknOcCpT0Qi6neazDfLXYg/G9Vl055/5AJWCNMWarMeZOb4d0M1fOOdDke87W2k+AJGPMZ8ABa+2nDuR0J1e+zzOA4caYT4Aw/P/n+S+MMZd5s8P0AiURkQDjq1fsIiJSQCp2EZEAo2IXEQkwKnYRkQCjYhcRCTAqdhGRAKNiFxEJMP8P78sSLn/zBeIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import roc_curve, auc\n", + "\n", + "y_score = svm.decision_function(X_test)\n", + "\n", + "fpr,tpr,threshold = roc_curve(y_test, y_score)\n", + "\n", + "plt.plot(fpr, tpr, color='darkorange')\n", + "plt.plot([0, 1], [0, 1], color='navy', linestyle='--')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false, + "id": "5D0D8247535B4D3584C84CD003433EB1", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8133333333333334" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "roc_auc = auc(fpr,tpr) \n", + "roc_auc" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F810D46A536D4579B0E014FFBDB860AB", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "## 六、降维\n", + "\n", + "29.生成一组数据，10000个样本，3个特征，4个簇 \n", + "30.对数据进行pca同纬度数量的投影，展示投影后的三个维度的分布 \n", + "31.将3维数据降到2维 \n", + "32.指定降维后主成分方差的比例（99%）进行降维 \n", + "33.使用MLE算法，自动选择降维维度" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false, + "id": "B7661C237D0C4B468F61D7F0E3E6A7B8", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/matplotlib/collections.py:874: RuntimeWarning: invalid value encountered in sqrt\n", + " scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from mpl_toolkits.mplot3d import Axes3D\r\n", + "from sklearn.decomposition import PCA\r\n", + "\r\n", + "X, y = datasets.make_blobs(n_samples=10000, n_features=3, centers=[[3,3, 3], [0,0,0], [1,1,1], [2,2,2]], cluster_std=[0.2, 0.1, 0.2, 0.2], \r\n", + " random_state =9)\r\n", + "\r\n", + "fig = plt.figure()\r\n", + "ax = Axes3D(fig, rect=[0, 0, 1, 1], elev=30, azim=20)\r\n", + "plt.scatter(X[:, 0], X[:, 1], X[:, 2],marker='o')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false, + "id": "3B348279CBB841EC8ECB0737A577446D", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.98318212 0.00850037 0.00831751]\n", + "[3.78521638 0.03272613 0.03202212]\n" + ] + } + ], + "source": [ + "pca = PCA(n_components=3)\r\n", + "pca.fit(X)\r\n", + "print (pca.explained_variance_ratio_)\r\n", + "print (pca.explained_variance_)\r\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false, + "id": "EFE74CE1C3154A739946A32603F71D0A", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.98318212 0.00850037]\n", + "[3.78521638 0.03272613]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pca = PCA(n_components=2)\r\n", + "pca.fit(X)\r\n", + "print (pca.explained_variance_ratio_)\r\n", + "print (pca.explained_variance_)\r\n", + "\r\n", + "X_new = pca.transform(X)\r\n", + "plt.scatter(X_new[:, 0], X_new[:, 1],marker='o')\r\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false, + "id": "605CED38E1F047CA84D407BBD2CB4CCF", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.98318212 0.00850037]\n", + "[3.78521638 0.03272613]\n", + "2\n" + ] + } + ], + "source": [ + "pca = PCA(n_components=0.99)\r\n", + "pca.fit(X)\r\n", + "print (pca.explained_variance_ratio_)\r\n", + "print (pca.explained_variance_)\r\n", + "print (pca.n_components_)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false, + "id": "C800591C85FB419E9A0DCE6B5E4E6EE5", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.98318212]\n", + "[3.78521638]\n", + "1\n" + ] + } + ], + "source": [ + "pca = PCA(n_components='mle')\r\n", + "pca.fit(X)\r\n", + "print (pca.explained_variance_ratio_)\r\n", + "print (pca.explained_variance_)\r\n", + "print (pca.n_components_)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C321EB214D264FFB86F7BB344670E540", + "jupyter": {}, + "mdEditEnable": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "34.生成一组数据，10000个样本，3个特征，4个类别 \n", + "35.对数据进行LDA降维" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false, + "id": "BCBD89AAF2C4476387C7A821FEDA1A26", + "jupyter": {}, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X2, y2 = datasets.make_classification(n_samples=1000, n_features=3, n_redundant=0, n_classes=3, n_informative=2,\r\n", + " n_clusters_per_class=1,class_sep =0.5, random_state =10)\r\n", + "fig = plt.figure()\r\n", + "ax = Axes3D(fig, rect=[0, 0, 1, 1], elev=30, azim=20)\r\n", + "ax.scatter(X2[:, 0], X2[:, 1], X2[:, 2],marker='o',c=y2)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD6CAYAAABOIFvoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnXecFOX9x9/PzO7eHQccvUqRIiiIqGAXe0ussWuMXZNoevcXYzQaU4xGY2LvGjv2KIqAgnSkSm8HJwcccFzdMuX5/TFlp+3dgRSR+bxeB7vPPPPMM7O738/zrY+QUhIjRowYMWIAKLt7AjFixIgR4+uDmBRixIgRI4aLmBRixIgRI4aLmBRixIgRI4aLmBRixIgRI4aLmBRixIgRI4aLmBRixIgRI4aLmBRixIgRI4aLmBRixIgRI4aLxO6ewLaiU6dOsm/fvrt7GjFixIixR2HWrFmbpJSdm+u3x5FC3759mTlz5u6eRowYMWLsURBClLekX2w+ihEjRowYLmJSiBEjRowYLmJSiBEjRowYLmJSiBEjRowYLmJSiBEjRowYLmJSiBEjRowYLva4kNQ9EYZhMvXjhUz6cAGlrYs47YKRDBy6z+6eVowYMWKEEJPCToZhmPzh+qdYOLucTGMORRGMfeNzrv7l6ZxzxdG7e3oxYsSI4UNsPtrJmPzRFy4hAJimJJvReOJv71Nb3bCbZxcjRowYfsSaQjOQUvL+sxN5/d8fUVvdwLCj9uPqW89lnwHdWnT+pDHzXULwIplUmTttJYOH98LQTbr2bI8QArC0i8qKLZS0KqJj5zY79H5ixIgRoynEpNAMnrhjNO8++QlZW7BPeX8ucyYu5j8Tfk/X3p2aPb9VaRFCEUhT+tpNJI/fN4bqTXUIRdC+U2t+97eLqa5u5N473iKbyWEYJoOG7MP//eVCOnSKySFGjBg7H7H5qAnUbW3gnccmuIQAluaQTWu8+uCHLRrj9IsOI5Xyc68EMprBxsqt5HI62YzG+opqfn3NE9z1m1eoqW4gk9bQcgaL5q3llpufQ0oZfYEYMWLE2IGISaEJVCzfQCIVVqYM3WDR9JUtGmPQsF5c8dNTSRUlKCktoqRViqLSFMmiREjQazkdLeM3NTmmpOWLK7f/RmLEiBGjhYhJoQl02acDWk4LtQsh6Dmga4vHOf/qY3lmwm855fxDUZIqRs5Aa8iBYYKHGExThsxMAIqisLmqbvtuIkaMGDG2ATEpNIGO3dox4sQhpIqSvnahCHr26xzpQC6E8mUbGPPaTBrqMhiGaTVKwEMCiaQaqZloms6Awd1ZV7GF9eu2bte9xIgRI0ZLIPY0W/WIESPkrtxPIdOY49+/eZEJr09H1wywAoQoLi2irFMbHhjzW9p2aE3Fig2899xkNny5hUOOHcTJF4ykuFWRO85vr36cuVNXhMaXAIogVZKkR++O1Dbm2FrdgKFbxJFKJTjqhP1ZtHgd1ZvrkUC3Hu249c8X0mdf/34ZtbVpJk9ehpYzOPyI/nTp0nYnPZUYMWLsaRBCzJJSjmi2X0wKzUNKyTWH/4H1q6usBjt0NJFU+daVozj0pKH8+ftPoesGhm5SVJKiQ5e2PPDuz2ld1gqAq07+Gxu+rM4Pao8BkCxOcOF1o7jwqlFsXF/Dz697grqaNIoirMilhJrXLuxT27Qt4YW3fkpRsaXFTJq4hD/f9TZCCKSUSAlXXzOKiy4+fCc/nRgxYuwJaCkpxOajAkjXZ/js3c+Z9PYsKlZsYPP6rZY09ghzXTOY9O7n3PvzF8hmNHd1n03n2LR+K68/Mt7tO/ig3m4egncMAFUIDhrZj6mfLuGHlzxEXXUaTDB1iW6YPkIAyw2haQaTJy4BoK4uzZ/veptsVieT0chmdXI5naef+pSVKzfujMcTI0aMbyjiPIUITPtgLn++9hEURUEAum6gF1Co1IRKY0PYGa1ldSa9P5crf/1tAC6/6UQ++2gBum6E+mbSGv97ZTqTJy5D0wLHzVB3a/yc4Tqfp0xejqKIcB/NYOxHX3DDjV0K32yMGDFieBBrCgHUbK7jz9c8QrYxR7o+Q2N9hlxGQ2o6IiB4i0pSnHThEZhGtORu1abYfd2rXxcu+8GJKEr4kSeLEiyaX0E2o1lqgNekJwEzPL6UkpnTVzLpk8XkNJ0oK6CUMpKEYsSIEaMQYlIIYNJbsyLb1YRK6zbFlLQuori0iFRxkhEnHsB3f/kt+g7ugaL6CaO4VYpzrhrlazv7iqMoKvFHMgEgJRsra/KEECQGsDQG50+CYZrMmr6Sv/7pLcZ9MB8zgjiKipKMGjV4G+4+RowYezti81EAmcYsRsTq2tANzrp6FMOO3Z+qddUMPKgPfQZ1B+DHf7mIX13wL9INWQAURTDqrIM54bxDfWOUti7mjoev4o4fPY+uGQgB0pRoUiJ10wlssiKSpLT+T6i4IU/OcYcvhCCT1li2uJITTh7ChAmL0HUD05QUFSU55dShDBnac0c9mhgxYuwFiEkhgBEnH8izf37TCj/1IFWU5PDTh7PfwX197VpO564bn7JMPzaEIlg4cxWmKVEDGsTQQ/vy4qe/Y9GcNZimZMaU5bzx7GRfH4FFDEIRiISCGZHQ5iWKTFoj15DloUeu5uOxX5DL6Rw7ahBDhsR7NsSIEWPbEJNCAH0G9+BbVx/P+09/QjadQ0ooblXE8RccFiIEgKkfLWDr5nqfX8HQTTavr2HGuIUMOrgPH7w8nfLl6xl8UG9OOX8EpW1KGDpiXwDGvjc30u4vBKipBFokIWCrE05nyGQ1+vTpxDXXHvdVbj9GjBh7OXYoKQghksBoKeVZBY4L4GlgELAR+A5wMvA4sNrudq2UcsmOnNe24oY7L+KIMw5i3MtTMU2TEy44nIOPPyCyb/mSStds5EU2k2P2pKX8/dcvo2kGWlZn6scLefnh8dz9zPV07FpGm3at6L1vgUqrEjTdCIXBuhD42ufMKqexMUsrT8JcjBgxYmwrdhgpCCFKgGnAfk10OxpISCmPEEJMAE7Fcp0+JKW8a0fN5atCCMFBxwzmoGOad9Lu078LJaVFIWIoKk4x7ZMlNNbn27NpjWxa44fn/BM1laRX/85UVBQoWxEQ+iEEIqEURfDZJ0s45YxhAKzfUMNLL09lwYIKevZsz2WXHMkg2weyp8I0JaurqilJJejePs7WjhFjZ2CHkYKUMg0ME0Isb6LbBuB++7W3cND5QohzgLXABXIPSrM+6rRhPH7n22QzOUzDmrZQFUykP4PZA2lINM1g5XI7sSwiqU2S9y14I5ESqQSalCHC0A2TuroMABUVW/jBzc+QyWgYhsmq1VVMn7GSP/z+XI48YsCOuO1djilLy7nlhQ9oyGqYpkm/rh257+oz6dmhbHdPLUaMbxR2aUiqlHKZlHK6EOI8IAWMAVYAt0opDwO6AyGjuBDiBiHETCHEzKqqql055WaRKk5y39s/Y9Dw3laDIpACshk9HFbqhXel74SgesNKpdUe1BUuvfoYiktTEcMJDj2sHwCPPfkJjY05NxNaSshmde67f8weuS9DxeYafvzE22yqaySd08jqBkvWVXHNv18r4ISPESPG9mKX5ykIIc4GfgKcJaU0gC3AWPvwaiCUfiulfFRKOUJKOaJz587Bw7sdUz+cz4ovvrQEvRB+J3CEEJZQ2DTkzVGwXwvnDzjnwpEcfGhfiovz+Q7FxUlOOWMYffpa/om5c9dECv+amkaqtzZu303uRrw6ZT56IA/DlJKaxjQzVqzdTbOKEeObiV0afSSE6Ab8CjhdSunsWv9zYKkQ4jlgKHDnrpxTczBNMzIL2UFDbZrH73qbXEb3r/4VxRLqQoSJIaGSNxAFICVSUUANO5j79OuEphl8++xDGDa8N7NnlZNIKJz+7YM44uiBbr+ytiXU1qat4QLDtyoJaxlfd1RW16JHZI1LoKq2IXxCjBgxths7jRSEEPsCN0kpf+lpvhLLRDTGLg73JPAg8CJwM/CGlHLhzppTS2GaJq/8831ee2AM9TWN9Ozfhe/ffSkjTzkw1Hfx7NUkkiq5TLj+UZOO4gKQYBFCgIgksGZtNVdc8CCpZAJNN9h/SE9u+etFlJb6I44uvuhw/vXvj8hkdd9cOnRoHVkj6euOIwb2ZsIXK0kHNjwyDJOD+uzZzvMYMb5u2OHmIynlAPv/VQFCQEr5VynlACnlMfbfk1LKSinl8VLKkVLK23b0fLYHT9/xBi/e8x71NZap5csVG7nzyodYMHlpqG+rNiX+3dJaYrM3zKYJI+KYVASGlGg5g4aGLLmszsL5Fdx397uhvmecPoyDhvXKh7Pa423Z2sAD/x4b6v91x7cOGUzXstakEqrbVpxMcMYhg+nVqd1unFmMGN88xLWPAsimc7z16Mdk07lQ+7N3v+W+d2oNDRrem9I2xX5LUDPEIABRqE/QVOUIdVUJkYVVPnspmYCWIoTgy/U1oaFzOYOPxi4gl9NDx77OKE4l+O9PL+XqEw6lb5f2HLBPF245/0Ruv+iUrzy2lJKt6Qw5fc96JjFi7CzEGc0BVFfVFlzEr11ayX0/fY7xo2eg5XRatSnmil+fybFnDeeNJz71d3aEfmTimQBD2uyA66CWwuOoFp5xmtAqDMMkm9F8jmeAmq3pyP4SqFxfQ699OuxRpqQ2JUXcfMbR3HzG0TtszHFLV3DH++PY1NCIIgTnDjuA/zvteIoS8c8ixt6LWFMIoEOXMiIdwEBjVufDl6ag2SvtxroMj90+moXTIlIzCmUiJxJI76pfYhGEKf1tXkgJuhFZQts0JZoWXuUeOHSfyMtrmsG1Nz3FeZc+yAdjF0Te596AORWV/Oz1/1FZW49mmGR1g7fmLeKWdz7c3VOLEWO3IiaFAFLFSS748WkUtfJH6SSKU2jZsPA1dZMV89bkBXYhMrAhke4ObI6iAOT9EgWIQUgs4giEqyaSCrNnrg5d5/prj6O4OBXSBqQCum5SU5vmvgc/ZMr08L7RewMenjSNbMBklNF1Ply0nC2N0VpWjBh7A2JSiMDlvz6La247nw7d2qEmVfoP68WBx+xX0FWg5wzLeWyYFjk0QQotMtgo4Y4CEKa0ruEhBl03eeRfH1Gxdouvf98+nXjsP1dx6slD6bVPB2uvZwXf3LJZnWde+AwpJW+Pmcv51z3M8ef/gyt/8hTTZ69qyUz3WKzesjWkkAGkEiobaut2+XxixPi6QOxpGa4jRoyQM2fO3OXXffS213jjkXGFO6hq3kmcSOQT2aL6qeFwUwmQSljnBIS3r583XFXY/whoVVbM4CE9GTiwG+ecN4LOndu4522squOK6x8jG6HptCtrxWWXHcFjL0z0hbAWpRL87dbzOeTA3oXveQ/Gb98ew9vzFmEEvv/FiQSf/fxGWhftefkcMWI0BSHELCnliOb6xZpCCyClpFvvjs11yr82Cm+BKQOy3t0vRxGWltEcSfvCTIVTDYP6ugwzZ6zitVenc82Vj7By5Ub3lA4dSkl6wjm9GDigK0+9PNmf0wBkczqPPj+x6bnswfj+0YdRnEz4FLKSZIKrjjgkJoQYezXiMIsIVK6u4r9/f4d5k5bQuWcHStuVMmvCosKRQI6Qdu33TqmLwKYHinD9CZ5Wu+wF+fpHQglpCxIrVyEYsur2MEEKK49Byxk88M8x/POBKwBIqArXXTWKhx8f7xP+xUUJLr5gJJ/fNTryOZRXbG7qMe12zC2v5K/vfMLidRtpX1rCNceN4LKjh4eecRT6dmzPy1dfwt8+nsjstZV0aFXCdUeN4MKDh+6CmceI8fVFTAoBVK6u4ubj7iDdkME0JBvW2IJREYioUEVHADkrcSEsoQ7h0FIlnGvgH0rkucSUoOTrJElByOwUOl9KK6wVWDB/LVLmndrnnnkw7cpKeOaFyVRtrmPQgG5cf/UoBvTvSiKhktPC2k3Pbl/fxLBFX27k2kdfI2NHXm2oqee+9yexpSHNj047qkVjDOzSiccuPW9nTjNGjD0OMSkE8MJf33YJwQdTWkIWwqWuVQ8hBD3E3mEMM9+3KZimRSBOBKoiw0ltBeAQQzKZCK2Yjz92MMcfG94j4vLvHMZzr00N+RSu/+6xLbrmtmBrfZqXxs9hxuI19OhYxuUnH8Lg3qEaiM3iPx9NcQnBQUbTeebTWVx3wkhyhkFtOkOPdm1RW/jsYsSIEZNCCPMnLw0TQhDSI6S9Dubm4DgAAmahghvqePs2GeaKr4+QklGjwsI/m9Wo+LKa9u1L6dC+1G2/4oIjSCUTPP/6NGrq0nTvWsbNVx/P4Qfv27L7aiE21TRw6Z3PU9eYJacbzF1RycefL+POa0/nxIMHNj+ABwsqNkS2Z3Wdix58gfItNSRUQXEqya1nncgZwwbtiFuIEeMbj72OFHRN5/k7R/POwx+Srs8w5Kj9+OG9V7GvHWXTqUf7vMmoELzOXl9egR1HJApoA3bFVF/pbK9ZSAir/IUQVulr5z32+0IBrUEFRQh+ePNJvi6vvTmTJ57+FCEEum5w6CF9ufU3Z9GqVRFCCC45dySXnDsSwzBRmzFTbS8e/980ahoybsVTU0oyms6dz3/McQf1D63o3/98CY99OI2NNfUM7d2Nn5x1DPvvY2kVSgGSNCWs3FiNFFa+X0Yz+L/RH9KtrA0H9+mxU+5rd2J13RaeXz6L1XVbOLJLHy7qN5w2qeLdPa0YezD2Or36nmsf4vX73qVuSz16TmfuhIX89Lg/sKHc2rzn4p99K5y4lkogVCUvdyP2PLBe23+GEY4kcgS3KRGGaXVUhY8QvP8LZ2znEzIjxvJlv+UPH3/C/pS1K2XFyo3cftdbXHjZv3no4XGk0xqN6Rw5zWDGrFX8+e/vhZ7PziIEgEnzV0WWwK5tzDB5wWr3/dqqrfzjjQn88cUxrFi/mbp0lilLyrn0nhd4aeIcAEpTydA4eY3Jw5ESsprOExN3fRjzV8H6xjpeXT6f91YvJq1HVOAFJm9YzZljHue5ZTMZX7mcexd8wukfPMqmTFxOPMb2Y6/SFKoqNjPpjemhMtdaRuf1+9/j7B+cRs9+Xbju9gt48vbRdnKYwSEnDmHOZ8vIpXN5Qe8kqRVyHjt+gahidorIl7dINJ0BbUk4gQKYugFJlSiNQToJbxKmTV/B/96fywP/GevmJsjAkLpuMmX6CrbWNNKurFWzz25HoKy0mHWba0Ptpin5zePvce8Pzuafb09k1YZqspqeN63ZPGUCfxk9gb5d2jOwe2dWVuW3O82b4fLjOpFdUsKX1eECgWCZm1Zv3krH0hI6tS6N7LOr8eC8yfxr/mRUobga0ZMnXsBhXXu5faSU/HraO6SN/Hc5Y+hszjTw74WTuO2Q03b5vGN8M7BXkcLaJetIFiVDpKBrOu899jEfPDcJJHTs0Z6/vvULSloX065zG351zr3WOV7hLaWlETTlOHZMQ97zVMUKSrLbZJTfIKhhOP0CZOAIQqn4JWFjY45//PU9zKR17WAQFACKwDAlS5at5/AR/Qrfww7E5Scfwp3PjyUTUaU1q+n84pF3aDS1fC1BZ74moDiKluSB/33G784/gTHzPKXMPeQRhKoKRu67T6j9hRlzuGfcJASgGSaH99mHwd07887CJZhS8u399+PmY4+gdVFReNCdhFlVX/Lv+VPIGgaQjwi7dtzrzLzoZopU6ydb2VhLdS68i54mTT6qWBKTQoztxl5lPuo5oBtaNloV13IG2cYc2XSOdSs28Luz/krbDq0Z+/JUypdUhk9wqpk2uQ+zE5pq97GFt0sI3mNe4nBCUz0+CyGEJdhN8n4JBaTT7g7ogUe4ukM77fZ1Z8zadeUszjhsMN8+fP/IY1JCOqNFP06HGGyUV23lwN7dOXq/Pnnfgpvw4YcAWqWSXHvsSF/7J8tX8fePJ9KY02jIaWQNg4nl5Tw+dSaVtXVsqKvn+VlzufiZl9GaSEbc0Xhl2TwyRpg0JZLPKsvd9yWJZCgb20FpcteRWIxvHvYqUujapzMjThtOqiRsjw6u+DXN4KpDbuGJP77exGb30u9TCB0ObL7j1QSk45SONh0JkTeMS6xMaKmI/LkB5SKSGJqyStn9qjbVYZqSWXPLefP92cxbWNHE/W4/pJQsXrORo4fuS0IN2Hic+4zKC/SNYf3f295Y58GrzuGq4w6lTXFRuLMNVRHcc9G36VrW2tf+2GczSAdCWqX0cQ85w+DL2lrGLVvZ/A3uIKR1LbImE0DGYypqX9SKEZ16kRD+n3CJmuR7A5qtZBAjRkHsVeYjgFue/xGP3/Jf3n9iPLl0lvbd27NlY10opj+nmaBnrDdBZzAUzm5WAn103SIcZ69mr5bQBJzjUuTHFM57J9IpIBC8i+WWiPVkQmHIAT258kdPstEmB0UR7Nu7E/fecdEO28+5omorN//zDTbVNKAqAmlYwtq70hUCzKio3MD/xakEP/720fb8VX7+rWO5/sTDOPpPD2GY4btWFYXhEVt2bqwPOGMLEGhjTmPOukpOG7xtIbPbizP77s/YiuU0BpzLmmlydLe+vrZ/HnkO35vwX9Y2bEVBoJkG3+59AJcOOGSXzDXGNxN7HSmkilP88N6r+ME/rsQ0JXPGf8Edlz1ApiEb6OmREqZEqvlw0bw5KMKBXMhpHJXL4JCN47QOmpAUERrTywlNQQDSkKASyIuwPQzCcvA++dJkGgO7zC1btZFHn/uUn95wctMXaQGklNz8zzeoqKrxaSAqgkRCIaEoqKpCxtAxpOnLAne72+87t2vFjacczj4dy9xs7cacxq2vfYTh5JYEHv/BvXvkNQkbmmEwondPvtxag+4QSYGI35Jkgt7tyr7SM9gWnNxrAMd078ukytU06hqqECQVldtGnkxZkT/UtFNxa9477Xrmb6mkMl3L0Pbd6Vm66+Ya45uJvY4UHAghUFXBwScOYcBBfVg2e7W7BWeqOEXO9JpkJBimvTMaVvE6B46zubldzAR+LUH1E4AX0vm3QFKc5VuQSCUiES44kCn9RkKPuUY3TLQAIYDlX/lwwsIdQgqL12xkU01DyCRlmpIThvTnF5ccz8QvVvKPNz5Fy/nDVb2aj6pCVV0jd74+noQqKGvditsuPIl7P5jEqqot4Zu373Fk/7yDuT6b40//G8d785dgSBNpl5gyPecEXRNJVeXMA8KJgDsLihA8fPx5fLpuFWPWLKVNsogLBgxlv3adI/sLIRjWsQfD2LU5GFJKvqhZxerG9fRq1YVhZf1bVHMqxtcfey0pOFAUhbvf+TXvPPoxHz43EaEITr3iWB79w+v+jo4tP5kIr+oNI3IP5dD5DqJyAYLagAR0E1Lh6CaffJUuhdjzyo/nOJWlHb0DIKQdvgpWGe4C0PQd41ytbcigRhCmBNZtrqVtqyL6dfdUoA16xe35Gti3KkAzJZtqG/jRk2/bvhbPeZ5no6jw0CfTeHDcFDq1bkXb1iWs2LzZTfmQhnVep9YldG7bmpG99+HzdetYvKEKhKB/xw7cc/bpIU1jZ0MRguN79uP4nrsmKmxb0aBn+PWc/7AmvQEpJYoQ9CjuzD3Db6J1smR3Ty/GV8QOJQUhRBIYLaU8q8DxYuA1oBcwD/geUBRsk7t4k4dUcYrhxx1AaVkruvTqyPDjD2DiO7NZNCPgYAxmMXsRZQJy4CS1ObflNek0tVNbU09BEQgz30UAMpkfK+RvNvNk4D8QjWEHhEM4tweDenUmXSDia0XlJk765SNceuJwWpcUhWoZARaZ2UI/Qu7nI5Mc7vQ45w0Ti1gFVNU3srG+EamSJ0i7X1VjmkZDZ011DZpp8KNjj+Si4UPpULpr8jf2NDyy4i1WNVSiyfznVd64nn8vH81v9r98N84sxo7ADiMFIUQJMA3Yr4lu3wUqpJRnCiHeBU4Beke07bKNcrWczh2X3s/cTxZZYZ+KoF2XtvzqsRu57bIHaahN2ytUS+AWVJF124wU5YAOrZQLGLADEIDUTEgqnhbnP+EGL0nPofAgEaYpiS/ZLerc73/vuGbn1xL8543P8tnZznykRArI6iaoJk+NnZk3awXm4tMCbPh87Y42gf98l0AcLckhFcOT3yHyRNmQyxPXfyZO44g+vUKkUNXQwEvz5rF802aG9+jBBUOH0GYX5jA0BVNKPtuwkjX11exX1oURnXrtNHPO+A2f+wgBQJcGn2ycw68HXxabkfZw7DBSkFKmgWFCiIhd7F2cCDh2mXHACUCfiLZdRgqvP/A+cz9Z5PoTADKNWZ689WX67t+DxTNXWaGKElq1LSGT0TAjolwQwlqaKopfiDmRR14Y0rLjeJ3WUb4BR+LrElRhOYmDeyp4icGUrq8iLzgDJOX0VSMksH3Jww/dl4H9tr1yaRD1jVnenbwQw1vawr5fIUEmAs1RJNVS+bKtcqiJ0N2srvPirLm0LSni+c/n8mVtLf07duD5uXPQTZOsYfDxipU8PG06b15xOd3btGF3YnOmgUsnPMvGdB26aaIKwcCyzjxz3HcpTez4DYN0GW1a1KSOKU3UQrW/YuwR2NV5Ch0Bp95ALdChQJsPQogbhBAzhRAzq6qqduiE/vfEeB8hAEhTsmDyUhbNXIWuGRi6gTQMtHTWIoQo65Y3UU1R8n+RpiZpEYN7Qasst2NlAtzzXP+0R1sJQYLAMidFwRlXkOcioQSS3uy/Th1a88dfnR090DZiU00DCdt/IgJ/Lrwre2f+3sdrBt4H4DtUiBi20RgpgeVbqjn76Rd4YfZcPl6+ksemzaQho5G1fS1pXac6neavn3y6bYPvBPx+1nusra+mQc+RNXUaDY1FWzdw7/zxO+V6I9pHV5xVEHxSNXenXDPGrsOuJoVNgBMzV2a/j2rzQUr5qJRyhJRyROfO0VEY24L6rQ3868dPcUH3G9iwagNSNyITtvSslncwS0kuqyPNCMkb1AZk8M8/tmXGKCDBo/wWzj4OBUJerUtIt28hOGaTZFKlqCiZn4sHQ/brscPyE7p1aIMZMR+JnW8ReGTuC5sIfKG3nshRt8nxH6j+PqHrCc+w3m98gf7FSZUVW7eQ0XU3l8Lt6vnYDCkZv3JV9CC7CLppMqFyObo/EUROAAAgAElEQVT0f59ypsFb5fMLnmdKk4kbl3LHvDe5b9EHrKjbWLBvEGd0PyJ6TCQfVE5r8Tgxvp7Y1aTwMXCq/fpEYHyBtp0GQzf46ag/8sGT46ndXI90Vv5eYhACVNXKS/BWO02oeXupUwwvSAiOX8H5cxzQUXBMO86fo1kE+7fERqvYAs8OQw3IUt8nrQCKx8/hXcFPmrGc/46e3vz1WoDioiRXnj6S4pTfSinwzJU8WeUjpzwOdEdL8vy5pOL8LwiRh5tsLjzjObUEvdY0ExJCIOyxixMqfTq0jywhISJUkaKo3fh2IUwkZgF2CxKFA0Oa/HTmf/n15y8zeu0snl85mcsmPcwba2ZF9pdSkjZymPZ47VJtKFGjfSkmBRY7MfYY7DRSEELsK4S4J9D8AtBTCDEP2IJFCFFtOw1T3/ucqorNaBFF2bymHxFYqUcK6qgCdmE1wR+Z5HVYa2aePFqCpvraY+blqrQuJbH/cTtyzlmH8Jdbv0NxcTI0Y90weerFz1ixuuUrx0LYXNNA53atOfnQ/ejWsQ0lRUlGDOrF/115srXbWlDGethJOBPzNGN6bkXgOpB9ZicvcaiePoHoJDxkohtuSh8JofCHU0/AjNIII9A6laQuG0x83HVIKSqHduwVepQJoXBSj3DMx+KaSr4z4UE+3bCEtGGZTQ0kWVPj7gXvUKulff0/2biACz67m9PG38rpE27j0eUfMKBNTxIRfoNiJcVp3Q7bYfcWY/dghy9zpJQD7P9XAb8MHMsCZwZOiWrbaVgxt5x0faZwh4IRRh7zTKRdX3ryD0S43IWnoqq0r0PCsyQ2TesvIhHOraTqZigTnoPHyWy9J9/XE4GDgGRKpWf3dtx07fE88Ni4/P7M9umabvDhhEX84KrtdzaPnjCPf7w43s5REJim5PdXn0q/nh157L2p1NRlrHk5wr0Q7LlLTz/h1QK8/TyC3tUgPI+4UBST91E25DRufOlN9u/RmfmVG8IaQ2CMdXV1/Ojdd3n6/PObfiDbiAWb1/P8ktlszjZySq+BnLPvAW6F1CD+POJMLhj3FDlDJ21otFKTtE0V89uD/MmHFY3VXPXZE6TNbORXWJMGYyu/4Du9rdpJs7Ys544FL5I1rcisRiPLK2smkjU1fj/kSm6b/wQmJjlTp1hJcVC7AZzYxV9iw5AGn1ZN45ONUxBCcGKXozm600gUsauNFDFair0uea37vl0oKS0iHShrIRSBkkwUVn59ykDEat2rOThCPahtmCZSUSzyUCC/JPZGC5l4d26zzB6K3VXkI4o84wunydmtLTBdAtN45bUZvDp6Jocc0sfKzg4ICCkl+leoDFqxcSv3vjg+TzY27nhyDDIpyBmGW9PPjToqZCFTAv4GkRf43lOk5/hXRUNO49z996eippZNDfny1NJ1dNgQVk2i6WsrqKyro2vr1kypWEN5TQ37d+rM8K7dtis88+Vl87ht+kfkTMMKNa0s59nFn/Pa6ZdTnAgXc+zbpgPjv3UTb5XPZ3ntJoa27863ew2hJND32RWfkTXt/TUi1jYSeGn1NJcUnlz5kUsIDjKmxpsVU7m+/2k8e8TvmbBxNltz9RzSfj+GtfNnNUsp+fvih1hYu5SsaWklK+pXM7N6Hj/b7/ptfi4xdg32OlI49vzDeey3/yWTzln+BBuJpMqI04cz/aP5vnYXSsCi7Kz8RZAAIgjBge+XGBbGAsLXtgkhRACF3BROJ6/d3LNiFlKi5QxQBVOnrbSK0Cl4iAyKUkmOP2r79zQeO2NJZHE6TTcsF41Ho3HMQjJgjXB8AN6VvCv4m8hdkBK/hmRzdbCOkjteBEzgsakz2VxnE4JbD9E6WZoyb47CKoWxbPNmvvvmq2xoqLed64IDu3TlmXO+EynIC6FBy/HH6R/5ymc36horarbw+ooFXD7o4Mjz2iSL+e6AkZHHHCysWWfVl6Kwm2p53QbSeo6SRIqKxlDMh3UugupcPd1LOnDePqMKX692KQtrl7mEAJA1c8yuns/y+tUMaN23yfnG2D3Y63S44lZF3D/xdgaP7O9r1zST6WPm5h3PDtws5KDUsn0FkJc6TdmhvTWuW7h6zAt4f39LkIZFmgSPmUg0HYkppaUVBQSsAE45bn+GDt7+Wjq6YUbmchScj6MB4IkuiuBWEXoRAU+imuuXcAeNeB/4BThktK6uLn+pZsJiDdPkibmzWFNbQ4OmkdZ10rrG3A2V3D9tShOTDWPOpnWhvaoB0obGu6sXh9rnb1nH9RNf5vj3/sX1E19m/pZ1Bcce3LY7qohgVA9MJDlbmxjQJvo7IISgU1HbZu4EvqhZStYM+1t002BhzdKIM2J8HbDXkQJA935dGXL0YBLFKcuprKoIReRzEIIRQYoSFgrOMS8khYnBIZdCeQ54fA3bCFeIqp5543fQhiBEpH8ioSq0Li36Slmpo4YPIJmMTmAKltqQgRctuqpXqAcRoUEgbQe1iT/c1dFApIcrIibgI5cAShIJvn/YYUyuWIMe+OyzhsGrixa05I5clCZTBfezCFZJnbaxnEvHP8uEymVUNNQwoXIZl45/lmkby1lVt5nfzHyT0z/8N9+f/CJztlRwZf+jKVKaNg4IBHV2yfjr+59KkeLXcoqVJFf2PZFkM+MAtE22JiXCWlJCUWmT/HpsfRojjL2SFABmfjgPQzPyws8r4AORQgDouj9k1dvPC9MTURSVO+AIjsCK1e2iiiZXpc6pzkmWdiCQUUX2Cp0rPEIxMH9NN3nvo20TZEHs17szF544nFQi71h3BW6U1mO/EMG2iLm7oaxR1rmmfBM2MQhnDHvB7CUH8JBHM5+BAIZ06cI/vnUG14w4tKAgzxXKR/HAME0+LF/GbVPG8llFOW1SxaHbKEkkuSJgOvrT7DFkDN2nBGUMnd/Pepfzxz/GO2vns7p+MxPWL+Oqic+yrLaKJ466mgPbFa5rpQpBW7uo3YKta2z/j7C/zoKzex7OpX1GuWaopnBUp5GRiwuB4PAO8Z4PX1fsdT4FBx26t6d80Ze+NtFUcTrADVltbhWt6ZBK5s/xEI8QAmmYlq/AFW4iX6rCkO6nIiDf15pgPhLJEbDO66YcDXj4x9mjoQnkogrTbSN+ctEo9u3RgT89aVUskSLsN2gS9oR9PoXmWKMpXvT4VZz3DiE4w7luB4mvZlLUUEVC5cz9BnHaQGvznaFdujJvw3oflyQUhVP79Q8P4EFG17n0g5dYvKWKRl2jSFVBQLuiEnKGgRDWDnA3DT2Co7v39Z27pCY6bLi8YbP79XKvY+jcMed9xp/+E54/5nr++sV7vFQeTjQb2bEfbZMlfLx+Lv9Y/Lbnnq3v6KtrP+XNLz9FIumQasPV+57OmT2jk9naJlvzm8E3cd/SR9GkAVJSpKb45aAfUKwWMX7jeCZsnIAmNQ7rcBindTuNEjWusrq7sdeSwgU/PYOFU5eSbbSdYM72mDRBDNtqUlHywtz7v+VQtnMXJFZoqjdqyDAhqebbnHBLbELw1D/ymoessE1/WIlvle7RJlweQYbu6/CD9922+wygriHDlro0OU13zUXuvcnw/AoJXmmH1XoFua9v0FTkKGdBZ7LnPLdPxBAior8b3up2tk7OGgbr6mrdc/920mlc+NpL5EyDjK5TkkhSVlzEb44q7IgFeGHJHBZu3ug6lrN21FepmuKxE79DrZZlZJd96Fgcrthaliphay4dao+ydgJszjZQo2W4fe6bjFu/KE+CzrMBtuTqmb+1nD/Me8n3VCz/voEq8omRW3J1PLjsTRBwZo9oYhhSNohHRvyNlfVrEELQr7Q3ilB4eMXDzN46m5zthP5f5f+YWT2TPx7wRxItME3F2HnYa5/+iFOGcc0dF/PUH15BURW0nEaiOEUmrYUE1w5B0GxiC2QphL+QneMgNkxr5zVXExAe4VRgbm7wvvT5JxzikEre/CXtNhLhsb51ytDtusVsTufupz9i7PSl1m5qmuYXyE75bqd0hBPN48ludibs8zVIfNE+BeGYfpoiEu9lmviIIyOePGiVTHJ4r17u+/06duKTK6/ltUVfsKJ6Cwd16cbZg/anVbLpyKM3ln/hizRykDUM2qaKOap7n4LnXrPf4Ty06DPSRqA0eQGlUUHw8JJxfLx+Ed4H7m4oCKyqr+LuL163s6S9bCgxpYIQ/jDjrKnx9MoxBUkBQBUqA9vkFxpfpr/k8+rP0WR+3prU2JTdxIzqGRzZ8ciCY8XY+dhrSQHg3JtO5fSrj6N84Ze069yW9l3LGP3gGJ69+y1MI1CeomBSWwFourUhT1SVVM+YgM9GIoXwJGnZwtNRYLzEEEFczkLWzQHwClKJVW3VtqdLVfiT3WwUpRKkktv3tfjbsx/z8Yxl5HTDKhsSEMguOTlvImz6zlwdIeWs3p1n4LZ5SMS3krdPEE57hNnIuYbvvRdBDQQPOdjPvG/7dpw8wG8aaldcwnUHj4gYsDCSSgGHPJJUgWMOvr//0VTnGnlqqb8siWEKFEWGIrdO6jGQV8pneFo8V/NYJVc3RJmloqLZrJpcm3M1mNJscULaivoVVt/AgFkzy6LaRTEp7GbstY5mB8Wtihg0oh9d+3QiVZzk9KuOo12XtqgFomcAv0Rqqk8LuvmSfTyE4PgLfA5M1wlaQJMJ+P5cgaoIUEEoeeIoFAVlSskBg8Ib3TeHxkyOMVMXk/X6IyLu3+UJZ/qKv93LeYXgCmhPWSrnZO84QoLw7J/gJY2WlujxPWXPnF685GKSwTDl7cDlg4eHkswAOpW0YmC7jhFn5KGbJnM2f+mLaXC+FqYp/PENwPj1i5v9SnYpKiOlFNZuHJOjIkxUIVGEJKFI/rrovxhmyxIey5JlRNWRSogEHVNN33OMnY+9WlOIwqv3v0/tlgYMPSA17PLWrhCXEnTd+hUW0gZMg7xRvRktw1mmBfq65iRvuy4h6ScGdzVrTS7vTHYjbQJahbNi99oOBHz/ylGUFG97ldS6hqyvyJ53Ku4EvXNswn3jEkNERVPffYrAn/dkb1/p7+O2G0T/AjxjeKfvjFWUUCkt2v5Ksp99Wc6dU8ezbOtmOpeUMqisE4uqN4KwwjVTisJjJ32noGZaUb8VzTT5y9yP+HxTPi8hTwzWeaaJqzEIIGPqJB01KgKtEkn+cNA5jKmcxf/WfY70UYhEIDERJDDdOAf3njbN4/WKHpy3zyiW168hKRL0a71PpPYwtGwoxWoxWTPru4YqVEZ1btoHE2PnY68mBcMw+XL5ekpKi+i8j7VCmfbBXPSoYnkQvfJ3yCFoO3Z8Bd5+3l+Rtwy2CJwXeW3pdvUJOu/UbLuKb5oREVWu0LX3KEZIFFXhonNHcOHZ22b+cNCxXSnJhErG8+wElrPYt5mOd14F7iPS7OSMFax06nt20XNzTUnBtsD1g4QVaZsX8P0jms4cbgrTKtdy7ZjRrh+hsqGOrdk0Vww+hN5lZXQqKeWkXv0pjqi+urJ2Mz+cOJo19dVIJDmpB9QuGfqaed9L26cTuiUBbVNJNFPnB9OfQBUmQjjfN2lrYBLV9klFVXDPmhqvrh3P6IoPMLEWUKWJEm4dcgP9W/fy9VWFyu8G/44Hlz/I+sx6FKFQopZwY78baZ9qvx1PNcaOxF5LCjM+nMs91z1MpiGLoZv0G9abW1/8CW07toHlG8InOFE/UXB+wE2VtohKzfWs0t1Q06ac3N5jpr3iE/aObPag3igjKcibmyL8B075C4DjjhzINZceHX3dFiChKtxw3pH844UJ+el679XReDzC3CENr5D3+gF8KOA8jerjJ0X7f4PoEFMPAbjk4RlASNz9GACuO+xQbjqqsFO1OdwzY2LIsZzWdV5eMo/Z37u5oI8ha+hc/NFzbMk22s9Rus/QM1uCxOCaloRJQpEEoQgTRZE0Gk7msUSXggRYxCCkZSZqgaG5RqunSM3fWyaX5ffzH+SZw+8MmaS6FHfhjqF3sCm7Cc3U6FrcNS6S9zXBXvkpVCyr5E8X/5OtG2vJNGTRshrLPl/Fj0bdxsr5a6JPSqiFZVJT+Q2FjONS+jQJYXgM5FGb8jjtrsB0dmrzE4JU83syCMdyK8Nj5s0uVt+JU5fz0/97qWASVktw0ckH07lDazdgyJmTz27juyEbhnWCz/YfgHsfDpyLBBLNfKYlp+SF89g8fUOO5+B1AmO2LU5x3eGHcM4B+6N8hci0ZVs3R7Zrpkl1Jhxe6mDcl8t9iWqFTG952Ct9IRHCLLA/kyX0/e3WG91m5+Dur/mR/RCAKsJHDGkwY3PhZMhORZ3oXtI9JoSvEfaaT6J6Yw0zPpjNynnlvPvoWPRABU/TlGzd1ECmLh0tyJtLbCuEqCWWI3S8wznZRpLI6+Tty9LX5gp+Z46FYN+ulDLSB24YJqvXbGb2vAKk2AIIIbj7h2dSUpwkmbCSsIrUgL0iSgiD32nc0uvhEfYRTmfvn+86zmuv5iA8XOAlJgXUpCBrGDw1czYXPv8St48dt93k2bcs2jySUATtiwsnblWl6/1lNGRTz8ulZFRV+r66QQIwTSWiMou9yJAeTcNzTDdVX7uKQkpJoIqwo9mQJrV6Q8H7ivH1wzfefCSl5PHfPs+b/3qfZFESQzdQEip6TsMXZhpMNPMiuOlO+CIB265zXstJRJoSoSoewVb4XDf7eRvzKaRDOI6GYGAlu9nzzGkG8xZWMGxoL3dv5W3FsAE9eOWuq3h9/BzK11dz8H77MG3JGibOWxVxI/n/JLapptDcwc1VCHKMBEtjSBLuEL5cfrzgxQLmJWm3mVJi2Ellhq7z4pz59O/YgcuHH7RtYcrALw49hhs+fIO0x4RUkkhww7CRBU1HAAd37unXUBxTme8rYNGam+geQQT5/tI9Jon+KhkShFRQMfwmKSBnKiSEaT9/k6Gte7OsYUXkLnBDywY0+1xifH0gvoq5YHdgxIgRcubMmS3uP+6/E7nvxkfIOPsnOETgFeKKgkgmEU7xu6D9XwhIJAoLAEXJ+xW8SCascwuVxrB1emnPCzsM1spM9msm7qeUUPLvPbq946CVyfC1JJaD0fUrODkR7pj5/kpSIZlSufjsEVx9ydHREUXbCCklz304i3++PtG+PpGCWwJmIvq46alXVPBchxQ8ex0F+wBu/oZLNCJPAJFO71BZb4kqBEft25vHzjuXpKqysnoL7y1bQs4wOLX/QA7s0jU8SRsfrl7GnVPHs6auhnZFxfzgoMO5YVh0nSAvrv/kVSavX+1JVsubExUBvUvbsVmrs49L23SUJwlVMV1C8F/KejKqEm5P2E7nhGK6Y1mPynRfW74KSUoxUFwHtYViJcV1/c/nlK5HIYSgXm+gKruJLkWdKU2Es7Rj7DwIIWZJKZuNJPnGk8JNh/2WpTNXWG8cW3vwxycEIpHIC/4oU1FCtUgjatnlxKs7xxXFJ7ALkoJnNS4FFongEfgCN+vX6i/8Al3g380NMD1JaS7Z4CGFCMKwBKPIk4eA4qIEl553GNdcsv3O5yDWbKzmsrteoDGjFRbszhaaHpgCS6f1mHoiz/VqChHk4Qp5Jf/eJYUCdY4k0kr0E/42gOJUgp8fcxTJpMrdkz7FkCamaZJSVS44YCh3nHByeEAPDNOMLJNtmCabMg2UpYp9ezHopskLyz7n7tkfkzPzu+V5g9hO2qcfEzYscz1O3o87qRr2VzIo/PN3licGmyiEiWKTS0IxA34Dq10R0lY2TYpVk+A3LKmonN3jeDRZz6RNU0kIFV0anNDlWK7oc3HsT9hFaCkpfOPNR/XVHntmFCGA32hayCSjG1ZopedHLBwCcGCa+UJ4QfLwtgW323T/sbthmZNs7531f5SnUCh21JJzFgjTCgdEVfJmpkLnO9eStpbhEYyZrM7Lb83gyguPRN1OU1IQvTq34/QRgxg9aUE4dNKZj20Pclf1jobg9cEE/DGusA8O5n3r1QaCXZpbF3l9FeRfZ3Sdv3wyEVSJIaQ7h7Rh8NyCuSzevIlHvn0O7Uv8vgIpJStrqpFS0r9dB9938tVl87hr1njSug5ILhowjFtHnkRKVdmQrmNWVUWeEELTlHxSuQJU6XwbfEdNKRCy6UgiX/1GQEqBUKwchTwhBB6+/SUK7Afl9tWlwfvrP6JEFWhSc8tbTKiaRPtkGWf3/FbhCcXY5fjGU/QRZx1KItUC7lMUkNK/Mg/C2UfZu7kOeDxuSpgAvMddAZ5v9627pLO+Iy/IpSxoSpJ4x8ubEizrmCUYFG+UU4RWWFyUJFGs5uP/PcjlDNIZLXTO9uKzBat5f8aSiPuw/7eFv1vSwhs95OyF4DlZes5FcW8/P2gw2shbHZ08ATVNCvZnYCcvBrJAMKW0qqUb+e7OJGZVruN7b73mc0p/sWkDo156jDNHP8vZbzzH0S8+wuyNVgLa+IoV/GHaR2zNZsgaurUfw/L53D59LFuzac794Cn+t2ZRU5O1qpEWuA/DVKL2ZvJB2oUhfcJd4gln9TOjxMqcNsEtlmdKJ2FeOj0Q6OSk/7uUM3O8v35s0xOKscvxjSeFS393HmWd25JqIks3WZxX0Zssn+145LxC3tk/oVBpSgemJaEcrcAKHxWejGNnAljagVsMT4RKUgQWYvly2N4xQl5D056yf5Lt27diQP9o+3ebNsWUttqO7ObGDI+/NYUr/vg8P753NFMXrAbgrc++IJ3VfPeQJ0DPlH3k5rktf/CN29clNOk73RX4EYFbYfNSRPRTXnux193OqjjK1BTxSzKRrKiuZkGVVUuoQctx6bsvs7auhrSu0ahrrKuv44r3XqUmm+GBuZ/5HNBglbx+bcUCnls6iwY953fk+ubQMjNwc9Zi5+voVWZdF1whDz6QVExPH2s38YSSNy3lZALNDD+kBqMx1BZj92KHkIIQolgI8a4QYq4Q4jkRYaMRQhwvhJhk/60VQlwphDhdCFHhad/+jYELoF3nMh6b9w++e+v5DDioD4qajyRSFEFRqyIu+e25FLVKWatB0ywcbujclTcaSVX9W3U6pGEYfo3CdmILIWyTiEfoC1uom6ZHAnp+YhIrFCS4zIsqXwH5Utrkha4QItQugU3V9Zx76nCKAtpUUSrBD7533DZH19Q3Zrn8D8/z1HvTWVy+kSnzV/Orf73Nc+/PQDMCq1hJiBRdS1jQUua8MAONwdW+/dr9CBWLgF3B5mgh+IlF+E/P/ykejUwJHPROLGLOYG1aU1FbA8AHq5aGdmcDK2zz7eWLKK/bGh7AxrSNa/xJb56vjncihXMobBNQRAKbc1wRZuCrbGkMphnUj/wQSBK+fAeLEPzuOYEhFcxAavm+rfo0MXKM3YEdpSl8F6iQUh4EtAdOCXaQUk6QUh4jpTwGmAfMtg895LRLKZcEz9sRaNO+NZf+7js8NOtvPDTjLxx51qG07diGsi5ljDr/CE797ijOuPI4q7O98o8khigns/BIHE/imNvHyDsEXRSw77vX98Cyl3v6t2BXMHe63kHs95YZJt+g6ybzFqzl3tsv5MDBPWldWkT/vp257RdncsaJ215C+7Vxc9lS20DOkweSyek88sZkjhvWr8AEC008Ah6BHHoMQYGtEqqg6pCmiHqOIv/n+jKQvqin0McWZJMANNPkgM5dAKhqbCAXJEasjOa/zfyUrdlM5C1nDZ02iaIW/FiFm4cSRtNfGlWYJAJfX6fulmmHX4XHla5G4DUbNQXddBY7giIlxff6XtLMPcXY1dhRjuYTgdft1+OAE4APozoKIVoBA6SU84QQPYDzhRDnAGuBC+RODodKlaSYN3EJ2XQWLasz/uUpTHxjOtLrfTMMfy2jYFimaeaL4AWDwaOEfaGIpmA3sMo+2BLGMi9F5E/k7RqhMVxzTNS4an617GRCm6ZkXeVWhu2/D//5y2VNzq8lmDRvJVktLPhUVaF7+zaoqoJhmKE5+j70ZnY9c7UB7+Z10qMsOOfZ9xw1hnse5JP5ghpA0KwXON+dh7CupSQESOkqM8WJBCfv258+Ze0AGNGtJylVRQ8WWwRqtaydM2JfI3DvU9etbUFhVxMlsjajdAPdTKmAafp3n0UWTKkRtuNFuHOSvvPCmoegMAFZzNox1QGBJGemeXTlY5zW9VRO6LLtWmmMnYMdRQodgRr7dS3QlBnoFOBj+/UK4FYp5XtCiMnAccCEHTSnSDz8q+doqGl0NQFd09E1HaEqfjMQ5MkgIoTVheNPaA6OFGmOGOx55YVO+Bzpe+Gs+j3VVFuSW+CRir17dWi+f3PD2fPu1K7UL3FtGdGQ1XhnykISCAzhO+Q6ln1zI3/rXjOPTzgbIBMBESTAiXD0nVdo3k4/4e/a3MrEZ7WSlvA8unsfupaVMm7VSkqSSb43bDjXDD/UPefQrj05rPs+TKtca0cXQUpR0TExXIdFdLho2jRQhcBoqZrogSO4HTOOKRUUm2KEAGWbxhSowvCtcRTh/wCDJiIHUkK7VDs0s4G00QiYpI16nlvzDJM3f8Z1/a7h8+rp5Mwsw8oOYd/S/jFR7AbsKFLYBJTZr8vs94VwFjDafr0FcMIPVgNdok4QQtwA3ADQu3fvrzTROeMXRpqGpGH6fQVOSIUgL/ib0gb8M/a/NYy8ZuGMG+EPAECxf6Jex7HjpwhoG8KUloZjz1EgkInmNZL8TVtjfj53Dfc9MpbBA7px4jGDKCpqercwL6prG7nn2XFMmLkcCXTt2Dr8COzXH0xfnDe1OY/ZWc0HV+IGBXdQK6hVBEnDGT/Q7o4R7O/p29R6NzQHe6y5Gyq5uMuBTLrqekoidlwTQvDYaefx0qJ5vLR4HqaUDOzQkQ/XLiNtNK0H5AwdEp6ruppRXuCLiNpD3uPeyeqGgqrYwQeBNY5/zWP5GvLkJ4NfwwjOFeimcCOWnK+9IgQj2g9kavVU8JASwIqG5fx+/i0UKRIDk+kqtZ4AACAASURBVHEbxzCi/ZFc0efamBh2MXZI8poQ4hrgcCnljUKI94D7pJShWDPbAb0cGCKlzAgh7gKWAs8Bc4BLpJQLm7rWtiavBXFhjxup2VQXfTDpyVpOJNxvrLCP2feQ7+8IeidRTXiWqSHtAjfr2c1YDmoitkO6yYxmJ4PZIRVPP4m9cg78aqWw21R7Io7pRZCPdAJKipO0bVPCI/d8lw7tSws/RBuGaXLxb56msqoW3Ylucq4ZWG64GclgbzOav6+ocFh33oFx3PGVfB/LnxM9hgn5pY/I28WlkyTnFYDOC8UzL8enAIRIyb62BNdMlVAEB3XrxisXXtIiYbamdisnv/GEuzezW/3U+zUT1k4GUjUj+N7SV5SEdBPTfEQnZESmcv7chGplIauhwnjWcctEZOTzMzFJKn7zU9LWHIIQmCRV0yXYhw/5Ew+t/A+rG1bacwtfL+UZK6UU8cP+P2Nw2yFRk4+xjWhp8tqOcjS/APQUQszDWv2vEELcE9FvJPCFlNLxqD0IXA1MA95ojhB2BM688WSKSvxhlsmiJIMPH+CPKMKzkLTzBUI/cueH7NhAonIUHEisZasjD72rf7BW/G4GdHi1776zHdGFxI1b3ygIh0S8q+NApm46o7FpSz0PP/tJgdH9mDJ3NZu3NriE4MwruMwwnes7F2+pszyijzu+Z0UvPI8+dLrnG+7rE+GzcN/aclUY4NTNdj9ib+egNiRAl5I569cze31lC24Qerdtx8X7DaOVk7ksISGsIoetkylaJZIUJxKYSiFNwl64CN9bF00VzctXTxWYOOZH6f45PgNFEUhbnTBR0OyCeA4MKSKuI20FVmBKwcDSfela0pFuxV398408y0LOzDJjy5RCNxBjJ2GHmI+klFngzEDzLyP6TQfO9ryvBI7fEXNoKS6/5TzKF37J9Pdnk0glMDSDwYcN4KATh7ByYSVaNgcikPksAcO0ZHhUdq9j+JayaZr1mqAcMxKmr35RU2tLn8B1x/GfJIIb17vXjtL3ZV6zsWEYJhOnLIOfNDERG6vWbfZFGbkIOncDz8Q16xRwJtszs+D087ZHCEBh5rUHgYeIlMA52wpTuolxrpml0HxsGFIyqbycQ7r3aHLo8tpqZm1Yxym9BnB4t178d/FcGnWNc/rtz0m9+7N06ya6tWrDTRNfp7EhOjIJpM+H4tFtrWMIT2S0tHM0pa1k+vdecG/PNRFJ97W3h4m1D3RClfZ7a9Gkevwhwr6e8zn+fsgPATij2+lM3zIdUxbSLvzf3FqtJtwpxk7FN77MRRCJZII/vPxTVi5Yw+dj59N/WB8OPnEo9//4acvh7AvLCHxrTROpFCiV0RwCq39nDBnwL7i+4yYuIZ1yoraglzJQn8eUeZ+E8+fVStz7Eba5wn+xlpa16NezI8mE6tMUgmSUF5phzcd1MEcQRF4zcsxfgYED53iJJspf4B/UM9Go5+xtCxbh8zBzFEk4qMvl2JJupDSVokj1/8yklPx20hjeWL6QhLAWCm1TKV7+9iX0aZsvrd27jRW1NLJLbypW1WLaqWuhKYuoN941tzVpKa1oM0XJm5Ss9Y4VneRkJTcfNyHQpYLqSePWUUgqesAimp/Bhswm2iZL6VPamyv7fI+ny58KjClRIpzsrRLNmzFj7FjsdaQA8Op97/Hs7a+iJlT0nM7Qowdx7AVHUlxalK+mWgim9FcbjTIpRe3Z3JSg9dZTAqvuUUQEkYy4pimkWzk1L/Q9pGGbIizhapOH3VcRIA2Qap4YUkmV005omQ136IDu5PSmN2svEIjiIz9XoAv8AtY513Y649EEpH1PPq3E61SOIgUvETjneqSsjOjqhUtk3oYCZqhXFy/g2QWzEQJO7z+Qnxx2JH3L2iOEYPTyL3hrxWKyhkHW3ugirWlc/9GbfHj+1aHr/ujAoxlTsYQGLUehNLKg5dLlsMAq3yqLJV2hLfCSQL5Pc+ueMN9aZiKnSqp0nNL28QeWPcP9B/+eL9PrOaDtAdwy+BaeXv00lZlKFKEgpIES2I9BQWHf0v5NTyTGDsdeRwpT3pnFs7e/RrYx57bNn7gYJaHQuWcH1q+uQtOMJoyeHntG5AY6gV+Ua8cvIOQ98C1GA8SQJwSvUJRuuW2fFkLYxivsQaQnhNbpo5igFqskVIW+vTpy3XePib73AEZ/PBdVuPv3eOZZ+Jz8cUsaOxE/ToSKlIRX3rZCIz1C3X0GEtfZ7LWoRV/YM6RNiI5QD/oKXAKQwhet5guRLaDRSaAmm7E0OgFvLl/E2ysW07esHf869SyeXTiHtO6vA2QiKa/dSnlttU9bWFJdxfQNa/nZgaN4Z80XzNm8LmD+s1/Zvg9DgqKEI4R818pbLN1NeNxjUkERhfwX+es6kUvCMxfN3nvBOz3sMhfrMuv53rSfkFSsDO6eJd34+X4/o12qDEPq3DL/ZzQGSnyklBQjOxzZzFxi7GjsdaTwyj/eIdvo1wa0nM7cCQt5dPbfGPPcRMa+NJktVfXRA9iF83y+AQj/Ah0iEAGJ5/m1CqcAn/MrDYabSmyzkN3uMTO5QrFQaCtEC62Ivsmkyv6DerB09UYWrljPZTc9QSKpUteQZUCfznz/ilEMHRS2j0+cvZJcIBFLIV+JwkcQ7r1HzMP7CD2+AQnu3gcuMTg37iWAQHRQXqDjCnjfpbznR638Q1O098H2EoJzHVvjUIQgqagoiqDRyLmE4MCUkpVbq7nkzZfpUha9j4AqhJu/YErJLz57l/fLl9jHFLLkvHyK/41zgzKc9xFCftEQVa3W9LjGTHcN4d9LIWzqEaQUI7D+scux26astKlh2L6E8sa13LHwHu4/+M8klSS/GPR/PLzifmq0agBKE224od/NlCZaN3UjMXYC9jpS2LI+2nGVSCbQczrX3H4h19x+IQ/f8hIfPDuRjEej8Al5sIR5cHOdpgQ05KWVI2AUAaZVlz50rrSXfqmwOcq3WqWAvt+MCcB7mS+WfklOt2zWVVvq3fHmLKzgJ398hfv/eFGIGNq3KbBJikeZcskL8mW+C0VnBW9fafo44CcEr4ImmzABecZz+7nkFXEdr/YSOKZI2L9jZ+446STKiku45t3RlNd4vzP+/rppsG+bDqytryUbWBkXJRIMbNcRgLdXLeSDNUs99Y4kwruqt59l2L8lkLapEIKP2tl0J3+zuqEGQkoFhlQxpVX2QiIwTdN1Kiu2lhAVThod1iowJSSEQVIx3DlJKanWtvBF7WIOLDuAniW9uGPI39mY3YDEpGtR9+3z3cX4yvjGV0kN4pCTh6ImwrUPFFWh58Bu7vsb77qYP/73ZpJFCXsFqdh7FPhXZW6VVNP0E0YzcENHHT+AXYzPPW7/LxSbPTxLWveVqhCl6edNIX7zU7Q1GjTNIKcZHget/x6yWZ2Hn/s0dN4lpx9CcaCQnvr/7J13vB1F+fC/s7un3Jubm94rIRBCJwRCEQJI703pLwqKoGIFGxZ+dhSVpigKFqSjAgZCFSEQegklhJCEhPRe772n7O68f8zO7mw7uUkugh/z5HNyz5mdmZ2ZnX2eebolQuvTUL6dd+OMcUthjDUDOeu+TFFSFrHY6FMwD/IGVxH+jtXVrExGNxJmr1zF43PeZVSvXuw2YGCDoHQqztHoHr0Z3r2VpkABXbAsmhyHqw46Jky6c+vMtIgpNrlNIPh6gumwFKqTVLwiaeZjUB8LnaNJZMY32thwClbcC1qJ4STPrHgeUOandy+4lStmXM6P3/ouv59zHatqKzs3ya3QpfA/RxTO+uZJNLc24RQiwlBqLnLhL87BKTjUKnUWzV7K6mXrWLN8PfsdMw7hOIgkQcgDnQMhgcgzQV+2AmWwjtKqr2vRkS9DfUDYZRB8T0Bg9y/D+0YRE3QOgOB2+mnLOGa1itZGidk7c5enyvbaaTgXfmx/SkWHbk1FSkVHWS6ZNNc8sYt8bJYaY3CkF/rTaHAaqfvRp5N0KIIs7iB3tHGoeh5/n65cbL6w176UHSe3XbPj8MLSBcxdvYZa3aN/uRunj9mVh0/5JBOHbhP057K4fV1qMNIPEHgjCm9o06XhP2AJH8fJcWIL6oU6HbGxSClxnZS6a96AZMMwGnPb5wNw7TtX8uTyx2j32qj5VV5Z8yI/eeu7QTiMrfCfhP858VHfIb254eUruOuXk3j5X2/Qf1gfPv7V49jlgB24/ReTuP3KSbiuh+sG7Lf2Vt6YnV4YbgJCragUjcmuNiMNBLuRaEMShqxEVfG1UlmZj8SQuCVRVkTBDxnaGsrIUgpD1g6YWMX3ZGbgOBMG9O2eWX76EePYfnh/Xn9nEQ88M535y9You3h926TZqL61qROAWEIdqduZEBAGrVMQgQllrrK3AVIT5vVGp24ZiWHyQF+tBbqAbXv15u+nnskVU5/kiQVz8WVE5Eu2jWv5TFu+BFdFPmRVRzsPzXmHyyYcBEDd9zjj4dtY0r4hMbBgoj5IKxAB+TLyzQj1C0rRHLXRokm9zdLzySrzpMARqr1EESO95QopJTOAoOYLijHv6eAdakAUylaReW1zmNf+bpiRTbX0qfoVnlkxhUMGHJHbfit0PfzPEQWAPoN7ceGV58TKHvzLk9z2838qqyRD6St9Cb6HKCR431T00vB4TkwOkWffJ4j7LoQy7iito8bgEiKT1hziFIwWiVCsuQDsyKdCghI1WWo8pvjFsSxq+HGiZIy5XHI4//T9UvdcunI9F//0bpavVkr5jkpduT7oMBFZAzWWybTzN33opMhftoxJ51/Lua7FVDrXQliY1ackMl01r0ui8NoCVtcqfOyO2/nd8Scwpk9fbjruZKqeyx+nvcydM15HStht4EAeee8d2uoR8vOkpK1eY9Lst/nYmJ2ZPO9tZqxeTj0WQj2+R2TwHDVhMFkpKxHSwoqJi6LvERFJlqn7SWSgS1AlPspSzBIS3xfqPrGFUroI13cp2EafRCLB5NKWrCIf6bsvf1/wNzo8F4lQCuxgLDW/xrz2d9kK/1n4nxMf5cEdv5gUM1NNgqy7SB3WIoxzZGzzvEDynpcSI4VIPma6mrhG6lK8fkLHYCI31Ud8fOHBOIFrLEvQ0lJKDC7qv1tzkS+cdwgT99k+NbVLf3kPC5auoaNSD9N2BofLXJwsjDoIYv4H4e0TS5vZCTT0iG4E0rivaRCVpGLRugqEFFF4Dk3QjPt7UjJt6RI+O+mfYfuS7XDhuL3515nn8/hZ57NTv/6Z+RTa3Tqz1qgYko8tmE17ni4hOTiCsaGQdNK8FMxtKmJlioNQOgKJ8jFISjslVlBHKZHtwLxUolJ7en568T3s8LwTnXksqp4TE1EVhEPvQg9um/9H3lz/puZx8LFCo9aCKDC4aejG12IrdCn8T3IKWbB6WSDDbYSNfB9ZKGzE2i/jquvG8zM4Vr7QVh+TksWej9SERJ8YVehJA+NrypItU9GcgHnZ9yXr2ypYngpaJwxmp2/Pbtz5uwsoFNKypflLVjNv8Wol1krcwzQrjQ8jkDzrm/iisfgmAQYejApyxEcNr2VFKtH9h2sbFMbEbwFhEDIziJ/r+0xbspiF69YxpLU1dY/te/WlaNsJLgCanQJje6sAwX3KzSpEdhcEqkxCRCCSfgzqizJFzSAsJLelUV9Kg+tQkLXsEkHdt0PnNhvJ6vqicFzxu6m97dgF9u87cfMmuxU2G7ZyCgGM3n1E9oWYGaqIC1c3CQKxjZ1/vNUS2I0qqHVl820NPkITjQYQvsNCgAWeF5zTfGhuKtBULjCoXw+u/sFpmQQBoK2jFlrK5EG5YFPWJruCePRWfURPBMfLkGqE04W4rqChj1WjNegMIdrYMua0L9g2qysdmdcOGDqSoS09KBjr5giLnuUyR26jOLEzttuNgpVc84yRZDONDduFErAGczdbRHkYkgsdPaDIusk4m2T2qjasLwUWPjVZaziWfqWBfG3Md2lxsnVZW+H9g61EIYBP/+A0lac5hqEydqyfFgeFYEZKTV2DUNObsP6JgQhOo15GX56faE+QAzH+0oan9SyxlTDqECdwzU1FzjllH6754enc8btPM3xIfvKdbYf1zWR2HMdi2+F92W27wZx/wr7svv2Q6N76xrExEHeJzvgdEoSs+EhevE54rRFGz1V4xPvW65g5mpxIr1KqHAlZYAnBncefwYmjd1TRT22Ho0Ztzz0nnh0Sz+169uWn+x5Jk1NQcZEyKWZiawqB71sx89Os87r0s6KZ5oHMUBCnF86XwjibRG30WCx8bFSwvEDwhC1MS4QsEJwy9HQGNQ3p7GC3QhfCVvFRAGPGj+KXD1/GzT/+B2+9MJu1q7NPe3g+soDKkJZyNsvrXSiELoSKsipEFOtHNxJCBeMzFMOpbmXUHSKiMer9j8YjhEB6SrSUGpJp5RQoLGXQruZ69GxtZofRA5OtUlBwbL5x/mH88IaHqLkevi8pFR369erGDd8+jZZmpae45csvNewnJrYxy7QkTF/KY7CSBCaapgpj4UT9ZN1LQ1hkejQHF0xxW1gvcNCzhMAPMG2T43DZgQdRSjo0GtBSKHLp3gfywwMOSwXK0zCipSc2UI3IoTEoGZ+sZr6kwPfAdqKxprdnMFYjzEUSTGGZEjVK5b8sfIRUimDdVllAK85WBMZ3FlD3LWzhUYw50KnVl9jUfIui5YXPIuvsNaJ5ZPYAt8L7DluJArBozlL+ePndTHtiOt17tXDut09i6uTXeOmxN1OnbYSICEIs7rD5N0Q/RG+tumZKfUKEA1BIhLmAeF5lIaKEMsl6oDgLJ5LHxnwCQr4+g+AE1SRQ9zx+9uuHuP2eF/jJt09m2OBeNIJD9xnDiEG9ueuRV1i6cj377bYNxx20M83lKF/FwN7dWb2+Q58fIROzx5crVtX8JKqHnE+ybVDBlKSZSyCkYvi0GW6jaKfxe2oCrvopIjhu7I68vmwpQ7u38qk992TC0GG57W+dPo2fPT+FDreOJQT/b6c9+NreB8TEcMvbN3DKg7fgx0YeydniYv24d3Js7VB7y7fikVCktPCkD0IG5dFuEAl9gucL7DDbm4VEKiWw9EMlsnK6FxTxYyI3K9OjOnpYnhS4vq28nMP9GogxEVw36yq+s+P3O+cb9CGDjtp02qpTsa2etDYdhW39d0V67ZLMa/9J2NLMa0lYvnAVn9nrW3Ss7wiVpqXmIgefth/PPPg61Y4a1Q7DKqngROG1s6yQjIxtKSg66foEr4Jjp5TPqjwiFr4tcqOtSgBbhIpcCVAQKstZUBarixLHyGJ2f+VygZuvO48B/dIK002BR154m+/8YTJ1zzeUzxlS56RJaqDIlTaZPgdSt0mcmmOCbQG+kXUtq50022WoT0LiY8tYXd1HMbDZnDhyJL888ii6FYvpToDJc2bylccfCGMbgeIszt15HN+YcGBYduZDtzF16XuJ1r5BBDDOGREyFZZMmaPq0SurpGSSKFWmQ1bE8yao6wXLy8naJnFEFOrCwqfo+LHrZctVbTNXQ+VpKAiPouUqAmJUtFBZ176+w7cZ1rxl6Xf/kyClz4JVX2ZtxwMgPYQoABbb9LuF5tK4D3p4/Kczr/1XwowXZvO1I39M29r2mBVNtb3Gv257mqsf/RbnXnYih3x8H4rNRXDs6MXKQ/w67EUSgmOV9KUSJSXrZUmiEmal6kI+EZcxzgXFPQTe0FoXoU+7pbLDgQeMwckgMhKoVOvcds/zuffqDKxrq/Drvz+Fp9c2NOmUqbknDrmxU2eeDkD4CSYiUUcCuPFrKb1EwDkgA84sFwwlvnGIr3keNc/jiblzueShB3NbX/Xi1BhBABXy4i9vvELdMFN9YdmCxMT9+NxiW0KPRyBSSD24jg5LkbwogvwKIpMg2AHS96XAa6CLkDIZOkP1XZd5qEXpHRyh0oB6WHjSQsgwJxKgwmavCYLj/bfA2o5JrO2YjJQdSGr4sg1frmfeivORjTfXhwr+Z4nClH88z9eO+CGLZi/NvC4lrFy0ipM/exinfO5whGXHT1oZJ34gUPoGGEb6EWscWB3FEJgOQWEFN/TjeY6TILzsKxG+iAhCKHXxg3YBMnMKNiNH9uGyS49lwl6jsHJMY6WE199alDOSzsGfH3yBpavXhzJ3IZRNfZg1x8h/EOA25VCW0K/qOWX+lNm/Y+GKPCJRXXK6GYTE/JidS2Sk20gQqprn8fi777K6I1sXtbgtOy+46/tsqNeQUnL/uzOUJ70fjbkhmBLChlKWRhcDkaIW8OPjWH7AtEY3SPoxaLquuYwkeJrQmm2Cv0XLNYLnqVSgNRlP8elKlxHN2zSa1IcOVm24DSnTYTl82U5HbdoHMKLNg/9JnYLn+Vx78U2R93KG0rherfPd06+l/7A+rFiylpoWIQnZOHy2nexPph3VMJpZxLV+Ooy25hJM/YW+bsflHOGdfJmrcxBSUig6PHDvV7Fti7b2KvdNfjWWNS3Wp2CjOoWNwb9eeoe6Dq2dGBPBuJABjTD8GgToIKAbxYu5IKJP2I8RuVVDTOdg+lckBqtDZ5tqmmRKUceyWNXRQa+mptRwduzTn2cXz0+Vdy8W6VEqc+XLU7hp+kvBeASR2ZOxbuaJPik2S4GMbcE8iPIiRHdObCHiTyKuK4hHWFVg4VOwJDpdhbnINj6JJIRh/z4CG0lBFDi4/6G0FrZMdPmfBzenXCBTJnYfXvifJArL5q2Iey/nHLPa1nUwd/rCsI6wg+THgSVRiphkyO83Cll1pSQe90EGJ2nROAaToVlVp24RQxifPn8itm0xe+5yvvC1W3FdD7/uhw5aJu4olhzOPHnvzs8jA5pLhY1X0mOFuFgHDMsq428SQqRt/DaRoRWvmxaiZODMlChPkmv9ZGR/s4VgWI8e0SUpeXL+XB6eM4tBzd0pWjY1P0IOTY7DNyZMZE21gz+8+QJV09tZZI4sN/yH71lYdjqktT6NR7pDIy9CmHpThE5rjeIU6UdgB98kElfa2Ik0S4UwtLZlWPRKbOlj2Xn9Kx8GOyBO+/bpXKKnDxP0bD6V9tqrSBnnFgU2zcXdPqBRbTr8TxKFbj2b8TLCDTSEQB4vhIjnUEhaIOUi+c4TCqF1D8GRyjzlZg4tbGh8whzN6r6WJXjq6Xc46cTxfP+K+9gQpB0VgHSlipNkqfzMfXp145KLDmf7UQM6PeYsOGz89rz9no6umr0GWQQhBoZZadhGf0kShGRCHn1xE2h0FuRxLGZ5k+PwzQMnUgy4OF9KPjP5Xp5eMI92tx6EfbAY2tLK+nqVod178KXx+3HYyNE8ufBdHGGFqTnzQPoCkYNUowinUewgc7mltJCB97FSLpu6ABmuVaNtaqH8DSK1ldJXmNvbFnGFswqiYfySGZQ5uKrFUHVZ5/dzfs2uPXdiYHkIe/bal5JdbrAyHw4QoiWhKiuCsBnW9zeB0vm/A/4niUJr7xb2PHQXXnzkddyam8p6BijOIOsNSQXC6wR4XuotVYg+h4hAwI1YMYWzEllII+GLca4zLWo0IjT69n3Jm9MXcNEX/sL8hXEFngDwJAXL5q6bLqJna9MmmQLWXY9JT77BA0+/RcGxOGHiLixf18bv7nkmkexGGnMn9I8IC5OPQJcHIiZdJ0TGJgeRDKuh62mRUM50kgTGTBAUK28A4wcP4eJ99uGAESPCskfencXTC+eFcYx8Cb70WbB+HWP79OPmY06ld5NKUtS/qSXGQYQDS91bqOdvAzJhjhrWaCR0U3oBHSRPheGWocRTCqU7KAiZOMeo+tlJdEyioJ3U4t9NKasrhUI6Gf2bIbYXVRaxctl7FK0S/1x0J18d83/0LfXPmdcHD0vW/IKl664iFK8hsahQFD1YtupSat3OpnfrhQiRbZ32YYIuUTQLIcpCiElCiGlCiJtFBkYRQhwphFgghHgq+IzpTLv3Cy698SJ22m97iuWCSqQD2E6QM8Gy0hnV1CTSv82yPMsjiL3gIUJzGpiXQiRYT3Zj5FdQAxchYRNCKGuajAB9nieZOXMJXo4eoV73WLeuY5MIgu9Lvvjzv3PVrU/w2juLeOmtBfzwpke49u4pob7CQgVnjSHwYOkENA5XARlexUa7kACycQSuFc7BzxRB0F+l8YG01VFiHDeddFKMIABMmvU27UY0VHN8M1et4EuPPRBe2qF3PwY0J9NOCnMjRJ/YGKJBWbZvSBYbLYSMGX/ZxgEDlI+AH7BvUQA7gS3yuRgrMN+yiLIqiBhBCK4HiT4qnoPADgmYQGboJlT7ml+lzV3P7e/d2GBOHxx01GczZ8U3WLT2qmBN1SQKSGzAl2txvQWsXH8VC1d86oMcaqehqziFs4EFUspjhRCTgMOAhzPqXS+l/JH+IYT4VCfbdTm09OzGzx68jMVzlrFy8WqG7TCYerXOWy++y5UX3hjzTRCBZ7AwFb5ZoDOgJO3x7cDoPskZhPKNoG7SpDTEmvGXXEBkfppltopCmDJhdx+drrPlBIWCzYLFqxkxLDtMQxY8+/pcps9ZQqUWKdkqrps6bsS4gwQC10PK0xlkIe9Yx8nTfUYfoUgpcFrbaD4Fs0yC8NLrqet85YEHuOHEE2OXdKIdA0+E4EnJswvns7ZaoUdJiUVuPeI0Dvr7H/BN00UplOTeXKtgDFlcgjmutDgoOsHKkO2Kb4XIyU0TBpPHswA/bl+hkTl6GSNdQ7RtI/GRMBZk+5ZRzGybiY2nVHHCNEaT2DFthGTm+jfxpIctNpL4owvA86ssanuU9bU5dC+Oond5F5a2PUzdX0Pfpo/QuzwBIQRrO6Ywc/kF+LJCEUKDOifBIQFIWaG9+jSV2puUizu973PYEugqonAI8Lfg+7+Ag8lG7qcIIU4A5gOnbkK79w0GjerPoFERW3rA8b2ptFX4w3fuon1DFcsS9BrUkyXzV0WNGukIfF/FGtBchCmanAvzwgAAIABJREFUkoH0Vl8zT88yOAXaBO2iNorYJLBog8Ng+O5ljVMQRvpMBS8SsM3wvvkdZ8Dzb75HR3XjoZ5zzdb1rZOWPyLnexaYJqyN6gotKgNZSNQNljjyGjcvyUgclbyPgClz57GivZ2+zVHO6tPG7sKkWTNSvgnhUISgvV4PicLw1l787Ziz+OSjd1N13VAHsUv/fjwTOrOlkY1+2nr7mD4M0uAs1JbyjfwKqqIOf+3YfsbaRYRHSoGLpfoIxXjKMS7axiI4E0l8EflH2EgjuJ460Lyx/h2abY/ooajFVXmpZKhw1ve3gGdXPEy/8mBGt+yCJbpEyJGCirucJxeeTc1fjyfbsUQJKauUAESN+etup1d5L8b0+jKzll+CLysIfJVvIqDErlA8U0mmFf+V6nOUCmMQ4sMrue+qkfUB1gbf1wFjMurMBr4jpbxfCDEVmNjJdgghLgAuABg+/P33cDzsjP055OP7sm7lehbMWspfrriPZQvXROIabTaaBTodp20bxMDc4CL98oViFePUL0Qgc09juehUnY0BpXFL06FNBkfBELnJiDAUiw777LUtgwf2zJ5XDvRubaZYsKnVI/FCXI9gwMbEUkboCY3PGukDYhAS1+CnXvpEiOtwXOa9kn0kCYJllCceJUDBtliZIArjBw3hwj325uoXp2ZJv+jT1MTAbnGR0R79BvPSaZ/n1RWLqPs+4/oN4e7Zr/Hi8oXUfa/BOgikLyClhA7D04WWRqZNhIn0PV9g51oGydBk1ZcWUkgcPBxL4vkWvpBY0leiS2H6OCjwAHwz6qrAD04AsS0R/HCEiHE4JcvFFoL7F/8VW1i0Fnpz0bbfp6XQg66G11b8lIq3Am1C6ssqIKnhU0TiyTZWdPybdZWnKNKGjcSJ6VpEOOcqglKg3LeQOHSwZu13Wbvuh3Tvdg69enz7Q6mA7ipyuwLQT6hH8DsJq4BHg+9zgf6dbIeU8gYp5Xgp5fh+/fp10ZAbg21bvPLkDL592jW8MXUmvmGtVCwVGLF9wjJHmXU0Nhk1HNTiNxNRVpJMyC4XKvCMKfyNV/CVPDj0A0j4CrS2lCmWCrS2NnPaSXvx3UuOzR97Dhy1/9h0onqpQkKXA12NJQROIB4LJAox5BoTD8nEpxNK4vCyEbl0YwRFSKO+Xro8MZJBKGJqJBn9HdkzTUy/uNd+3HvK2XQvFsNw2Y4QNDkOPz/4yEzdjW1Z7Nl/KPsMHE6HV6dsF1SIkBydRjSQgPCn6gQ6BxEh9gyNn9onGe0t4VGwk1F4FUGI1kKooHmSsDzZv5dY3EZ0vsnuTskq4wiHsqU8riU+rqxR9SusrC7l7gW/bdDD5sPS9idJ+xQoGyodjUMArqxiIxvmsvawqKNEgA6aRHtI2cH6tptZueay92UOWwpdxSk8BhyOEgUdAvwqo85XgJlCiJuBnYEfAi2daPeBgFt3+fXXbjV0CxLpediOzcQTxtF3eF/mXW1IuhpZEkH4tglh2Iw30Ang+VBoEEdJs/C+9opWHEj4TmuuQBhy/AT069Odm64/L3/MnYB+vVr42ZdO4Nu/vh/X85FS0tJc4mdfPJ71HVUef/kdCrbNzAXLeWHWAjVtDE6mwfRkUixkfA/naSdwZeIkH5eBB2BFMvewrySiN8RDjTCYLQS7Dx7IovXr2aaXcvbbUKsxf91aBrW0sEv/gTx19gXcNv01nln4HiN79OLcXfZgVM/8sOQAd7zzGt97/pFgrQKET14sIZT9v56PhHigu2BqDaSeoILU2cJHhDRGZsY+ktj40iV+zlCEQTQwqzWtlKwc6wIbm48PO4cehRYWVebz2NJbqSWq+njMWPcKnnSxu0gMU3FX0eYuJuthC3zKBJkF1UwAC0+KTG/u+FgDzjnhOCllB21td9Kr9TJsu+s5ni2BriIKtwAnCyFeA6YBs4UQV0opLzHqXAfcBnwe+IeUcroQYnai3WNdNJ4thgWzl+FnWOl4rse0p2ey+v7AbT3PNyFPxGQrC6dQ5p+5CQ3xjr5H4jpJROdLpJ1A/toCyTYaBFBwbCaMH5Ue32bAhJ1HMPm6C5kxdym2ZTFmRP8wfMb8Zau59m9PUXO9AGkFqE0oghCbmgwMjfQJ33iRYojbKEsuYYjTBUhl1RsnGiLRPon0sziUjMekn4GL5NmFCznmrzfziyOO5PUVS7np1ZcpWBY13+OEMWP50UGHcuEee3PhHp1zBpy1ZgXfe/4RKp6pj1DsnvT9QNkcycsiT2dh7BmDroko9abWP2RZ+kgfLMewJmqA8FxphXkSOm2sFnpNq/41YY4Z8OEzqDyYYd2GM6Z1Z/619LaczmQgGu3kvXPAk3WeX/J93mt7GJA4oh6q9TQUA0/luIhIUqGAQyW3bwefcjBnTSotIqQrqbJk8ViaSvvR2utnOE7XvI9bCl1CFKSUVSApe7gkUWcxcFAn2n0ooHuPZlw3+9RTqdRxK/V8ggCkrIkS5TGOYZMgA0PFFLTqmjBqFiwLaVvUg/k4jkVL9zIfP2WvzDtsaFMK9uamzttUO7bFztsOipU99docrrrrydAySUBMkZu1dJZUWTpjczJP7wnCEOpSE8g+/K4tk/IssUyOwGyvPZX9dFvdXs/F9X1c3+fLD05GOJKq51ENts4/Z86gtVji2wcclO4kB+6a/brSIcRHm/gaPGchiSdqC86yvoqcqrZoep9F0VMCmbfOvxxur8iKKBvUFU8SIwx1KSgkCEXIuUjlOGcJP1duLZHcseA2LhnzdQB2bB3PtDVT8Q0ORCAY3m17HGvL5fHTVlwbEAR1AHSljSXccJ2FkJkpShX/AEjwRGByDZGFlVBWSGr76UREEj1ijR58JNXaVFYuO5Z+A6diWZum03s/4MOrAv+Aoc+gnuy417a8+dwsXFOJ6jisW90WvZw6FpEZbbSBg5t0vXhdGYgFMqyEFMeQQTgCvl1CwB2k3sDopyWoe5Lmkk2/vi10VOq4nk9zc5HJj7zBqSfsSbGotsHc+Sv50TUPMOtd5YW869ghfOuLRzGg7+bFoPnTA8/HTFUjsZGyMhEJlBMi5KwYRTlinDzxk0bmIviug+2lbpi8kSCmKM8i3mrd0+Ope57Kg2CUV1yXW9+Yxjf3PzA3fakvJb97/Tn+8OaLrKtVaC2VjBzNyeevkulYdsQdaMQeH2HE5sRDV0RkUx+0kyIitYUEUlrkOZFY+ArRCRncTd3HlxZ1/JAwaKsoKUVAEGQodhJkHwzeXj8jmJPg2MHnMKdtOh3eBmp+lYIo4VgFTh16Yea4NgWk9Jm99u/EHWEENelEGeMacEsiYHOkITQTUoUVL+GH5T4SIaFJNYor+yV4SARVOtrupFv3C7Z4XlsK/7NRUjsDl930GbbbfQSlpiJN3csI7dBm7pNQyYuJSfI5CIjyPFsW+DJE/roLhRgjZ7Qk6ADYUiuoE32H/RjipLb2GouXrGXNugrrN1RZuGgNf/7r01xy2Z1IKdnQVuWz37qVt2cvxfV8XM9n2vQFfPabt+UGzdsYLFu9IVVmSTKd0TDnnvceyoyfGcpkkfUj+ZiylNBJIqFPf9oA3dSDhPInozxn2DXPi8c1SsD3n/sX17w6lZWVduq+z8oOHWkzEgVFXI2I7zVEzM5AxoiJDJF2eqJqkskcDFYoZlL1dHTUKIpqkGLTkiF3oYmOtjrypZK3Kx/L4D74ASHYOHfsiEI4hu6FXly6w9WcMOR89ulzOEcPOotvjL2O/uUtT9Xp4+JTy7gi8JUHBTaeJqGJOpJuohbW1x+JwA71hyE/h0SFyzOlwrqpkqp2UK9O3eI5dQVsJQoNoLV3C7+a/A1+8+/vcMH3P065OUeckvRkzrIECkAk64SnBlMuErIJYRvzoCxtC+mkCUJ4BkwircBCSUXzjjBytebyzqylvDLtPR6Z8hb1uhcbtucrYvHsS3Oy570RGDdmaNoyyZxHRps8f4asA2teXQmg01IG9FnIoA9B4AuSbBD9laTraBt8CWHqyeThvGhnO1YN6d5KcyFb1LG2WuG2ma/S4SX8GRriTpUHISQA0gqitMv4KTQgGEJEMYpM4pHMtJYFUlrK7FQq1OYIFVrbPOWLwHTaM8JrR/tIE5HIU1q388l+TaT0WNSxMPxdtErs1ftgTh76afbvdxRNdtdkMrNFkW7OoJyrEhXUO0uE5lMWNaI8inGoY0UK9fAD9ZBzUIcjLdXU9hRu9d9sWPPNzRQrdx1sJQqdgCHbDmCbnYZEGdfyQHujZop8rLgjmy8VMdFvqwbzuu5LGmcVEf6Xvj1EmdqEiCGuMLlV4k2sVl2mz1jEgkWrqVTTjlZ112PJsnWN550Dnz5uX5rLBSwt6tIfEUeyMSYrNpkE+InKsQYGZMVB0qe2ZPv4wTopSUhVM8vNsoJl8fMjjqCpUAgJoUB5Nn//oI9mDFLB/PVrKFgZrtL6+ech7WAhNV8oLBm6xpgEQRMQ3xd4frSdfEmQkS13aPHbGRFMN8YII8ERfuiEZllqLPWAgwjdfaQVnpwjwwqJh8vN8/7YuYFtIezV/zvkLXJRuAZno05ZAh8Ht4GCPTBfDQhB7B0EkFBAmWkrXYMwfC9r1NtvpWP9T5AyLwz3+w9biUInYfQuw7FzYhXFbB6TSB7iOoZAJKQ2S3Cc10jEROSSuE9DeAQzkVvnThRh/bCv6GuhaNOrZzdeef09ssCxLUZvs3m+IUP69eCW757DhJ1GICyBFRJFzTMbwxFAcAJPWjWGr6VuI4zfWUuQ55+gkX6CEiU5MWGMTUOI5hOJ0DTUpU9rqcS9p53FMaPHMLJHTw4ZOYpbT/o4E0dskzEYBUO790golY075iJelXpTSXQUC5RGUEmHKqUj8KU++2ZlUxO4qSxr6kfB6lxUYS1mSp6B9HOv+Rae1MyrwJMWrtQcTfTo3t0wG9d//xHjgObxHDLk9zTbA/VAEQhKohYqmVWpInKWgEJwwsp++1SIjiQnaQUfD2KHhggP6DAfPrUNN9C26hN8UNnatiqac8BzPVYtXUtr7xZKTUWcgs03rj+PH5x3A27dxTOTx5gchDIpSFusZB0rpERhwvTRS0BkOaPLpIwii+r9YmsuQmw0lEQW+L5k4fI1zFuwMiIyIZGCbUf2Y7cdh256xwH0bm3m1dmLAnl+9BqZsYcEmnuIaIU0Qmbrqn6SAwg7yyjLAmOZzaVPVIkcxXL6lGZlAz59zz08c8FnuObIYzoxGAU9S02ctO1O3Dt7ekyEVHYcatSz1S9B7spQfCEFvicN5XOcYzBmhpTK6xjU+SW5ZSQCz5c44f4VWLgxL2U/iMmUZdaqt37Nsygm8jvo5DsSFZbVE2pPl8NMb8YUc/RpXQV1v4NXV17PnHWT8aXL0G4f4aA+F+L7FZ5YeFJAEEAKhcpj4rLgf2WdZW6UiN3UaxtLsRK8Xx1SUkRHtIkIRPSsPdzaC7jVJymUD3rf1iAPthKFDJj85ye58fK7qVddpJQcftb+XPiT09nz4B35/dPf49E7n2X5glU8ePtzhlzXQKibIhPchH0vAWlFmwgALzDhLOR3JGMN4t8PPWgsDz7+ZixMRTR+wU++eeIWvZxTXpvT6SnGpEIiIIqCXMujXEhkRAMiU8uk70OjwaTERzJOuRLgSsnd09/kM+OzTX3z4If7Hk6vUhN/mfEK7fUa2/Xsy/f3PZQvTLmHZZVkekcfy04i/GCMoU4hb2Zq8GFYLWnh+37KnUYkpFeWEbFFtROk1dcKPaqQDyJgmoVhvWMm34nGLrGo+ZKy4TVtC4c9eo5LBb+TUjKn7U1WVBcxoDyMEc07bNbelFLy2MIvsLL6Nr5UyuJ5G/7F0o5XaLF8PETELcq013LADIV+H+G48YNgeBZ1JA5+3MEv+OIhqaMUz6VA2JQeZDv16hNbicKHAZ554FV++83bY1FSH7n1aYQQfO7nZ9FvcC/O+NJRSCmZ+uibrF2RsLCREuHYIRvdCU1edjGkEI+0rZRyWUKE6ISI7qsKYqfasM9gTKWSw8nH78mTr8zOHINtiVwzys5CR7Ue5mg2xxu+TiaCzUD+MskdGGKf3AQ9PhkIPXEtGIAk5xFlPrbAQzyU4aVh5vLMSC0peH7xAq595RnmrlvN7v0G8cVx+/G1PQ/ElzJc82pWSJQEIjLHJn2BDEQbjXadOV/PV9FPQ8Wo6QgXoH7PF4lcCgJP2gipTExDcV5iZL4UYU6FRqG3vUCrX7IUOupX6s9ZI86N1Wl313PD7O+xqr4MKX2EsOhfGsKnR11OyU6nP20EKypvsLo6KyQIauYeFW81nlehYCmNgC9lKPF3wvH74Ra0jc2jQlnE1ygvWIG6qj51CcWgTlK44FaeQrZmmKu/z7BVp2CAW3f51cV/ihEEgGpHnYf++lSsvNpRo9KWZc4Ge310JwpFO+IacvIsSEtEOZ2TCmWIEQBf/86y5tG4Q0oVDykUfyiTRKdgKcWWDcVyAcexKBYdzjh1AtuNHsBH9hqNbae3wohhfejesmUZrybsOALPM+ZuDl8afzPwnIn0w8uRaiWKX2SCSViC7ynpnMZeRl9m91mcSUpSknMYnzB0KAvXr+Oyxx/ho3/9I//v3ruZuiCur3nw3Zmc++BdTFk4l/nr13L/u29z/D03M2PV8hgRLmwWQTatZZIzU1FSo60WnNaDaraQgQtNHL170spQlcnUwUWIpKWObrRxJ7gmqzenDz+bL2x3Cd/Z8Qd0c+LBAu9d+AeWVxdR8yvUZY2aX2FJ5T0eWHxzbs95sLo2O4PTUYTBj7GYSv/ihjHT1QmmjoNLpCQHEilJVV1DYpQ5a30XNxiLk0DH0ptBvTJ5U6bWJbCVKBhw0/fuZt2qtG09KKRiXps6+bUwlIMJTtFh93235bYX/o8f3Hi+cmzLyOwmBZGlEES7Rwu09ZORjd35M6UFUiqbtwAbekFMoqJlc/jBY9lmZD/69G1h9rzlzJy1hAvOOYBePZrDAHbFokNzU5FvXnxU7lp1Fgb27s6Zh+2RuVbxSeSUJ5G5iH8NCaJI1M8iGBA6pulgeVpZrfG8yXnlQs6L3uw47DN8GEff9hfunP46c9asYsr8eXxq0j+4+603VFMp+d7Ux2IhtX0paXfrXPH8k7H+jhu5Y6fvHV0Qof4m4hoVMdDbMJyrSauFxEdbKMnYcgoEdT/yPfBltLTaac0KLZNSJNbIxpY/7g1uG/v3PZDtum+fOhlLKXlj3XN4xBXPrqzz6pr4mnUGuheGBhxAeiwi45Rh4eNiUZc2rlRSABtUGRZ1aSXiQAVe3qReezSx0NfiDLD2QAIbgY1Fbd0vN3l+WwpbiUIAnudz/03/jp3YTSiUCvQeEAWuWrtqQ8zTWYNbc1m9bD3dupcZP3EHttvZUNIKomioWUjStBcMHMZC4pGDVLPETEAmQqzXPR58+HVmvbuMRYvXMGXqTD5/6a3MnbeSW359PhedO5HDDhzLOadM4NbfnM+YbbcsR7OakuT5t+ZHL0dMcZD4mjyBNziRZ4ImGCK7v5ALSF4LOSvjk7ivuc6WJMzipj9lx+G+s87mmheeYUO9hmvsoQ7X5QdP/Zu657G2WmFVSk+g4OVli2K/v7Dr/hQtOzHQiPGMnNUChBy+zUqUFPdZSId3VlOWqZDZWioScViSgq1ERREyU1b8eisLCDKvKf8JW/hYQvkuuFKE5qfxdyv63t1p4e11b7GqtjK1LhIZTz5kgCc3Mdc6MLBpHN0KA7Bi0nM1o0LCIcahTtHygxp6NFbgc6G0AdrBzZNqW3iQCI0RO3JQIE0sJFALrhexsbGwEFj+HOrrfrHJc9wS2EoUAqhX6tRrbuLEHsH5l5+KHZlksMs+ozPlheVuJXbbb7vw91kXH0qpqZDbbz4IpWi1Dc/mHIIlbZFoSfooiEIgruvjB1pEKZWfwq9+/TDNTUVOPnoc3/3KsXzitP3o0yuZHnLz4K15S3l30aq4CEmf4jUi1uMOyrUETL9HnVqxjYhdJYQOaTEGRGZ8N9xNYnTFYMtCwqCb+pKhPXrw7ML5MR2KBtf3eW35Uq584Snqrsz0uejb1Bxr06vUxE/3OcKcQSASNLaCCMosUxegPtrMU32SC6Qon+MECE8TAKHO/n5IbCSO5Sk/F91X0IMVrJHZVg9TEQsfR+h6AtcPkGlI0VQHJeFS8Vfym9lX853Xv871s66h7keiWUtYbNuyU0ohK7AY031caq03BkJYHD70eoa2HIDAQWDRt7QzzVYyJahHUUQEQZMBiaCOjZRKmexoQiKinVXBJgoEoPiSAlAicb4z1hOghBNaXikTdYnbdiN+7ZVNnufmwlaiEECpuUi/IUE4YxOBS8mIHQZx1LkHxurPm7lYEREDhBBsv+sw9jgwyhU04eCxfOprx9DUrYRlm+anDU7+EIicSNcz9A8SVAyeRqKZZP8ZdRcuXkO1E9nTNgau6zF30SpWr4tOwvOXrY2JjsyZC58UR2PmQNA4OE9HGeOScihHiHsiMXFsLFmgiVNMEpIQEGsTWv1xLIuXFi6kXyrXsoK67/GZh+/hjhmvRx0aRKHJKfDZ3Sak2p00ahcGdmtRXtSWVH+NU3wyeU5sHhvZFpHIJ33N9D72sXBlPNysIikivYhC4GGFXIW5SFo+r/2EJcrJzRYSH48Or4O6rPPG2te4e/4dsW5PHHIBTXYLBVECoChKdHNaOW7wJxtPMgfKdk8mDvoJZ47+N2eMfoJde5+GHfStQBErU9yTmCh1nNB0Na20Up7NGhpljNXELv9xVXE77u3ErLoGthKFAIQQfO4XZ1PSkUED875yU4FLro8n3K60V7n60ttTh3YpJaN2GqKctIwyCXTrXg6yahobwEsgeN1Itw+Py4Rt1MEwaBeeztIYUQCWbYV7tVwu4BTtzJ1XKNgUCltmiDbpqTc5/OLfcu7lt3Dcl3/Pl3/5Dza0V9luaN8wOmuuTkDTYEiPT5IdIE9/MXMumNezREKbAFrXkBkPzjwq669CYAnBRXvuRZMTD2lRsm1G9OrJ+lqVesyiSA2sbNt8bvcJnLL9zulbCcHndtovTqAMaMRFmdsivUVk1rYxxmXiOc09pBdRZpSFNzTonvoEpqq+CH8XrbTjXV3WeWrFk5jhHvqWBvG1Ha7jyEFnsXfvQzl60LlcOuZaehY3LX1sEizhYIsCi9uexpVRGGw7S/6aAD/Fu5ggVKwjg82skQ7tYSLgAhYePq70iIe6kMB/zsN5q0mqAXsfvis/ue8Sbvv5JBbMXMx2e4zkzK8fz8ix8eBbb74wB7ee/ZAevPUZPnP5KeHvG3/+AJNueYZqpZ5SOAtAegFy1/ZrBkEJD6cZ8sdMoWRQVCzafPXSYxg4uCcPTJ5GR0edgw/agUXL1vPHv06JhbMolRyOP3r3xorgjcDLM+bzsz8/FouI+vyb8/jmrydx7aWnsOeYoTwzfV5+B8HYk4lIgNASKO44FFzTymLSSE8E3TbK3GbePgsMaUjYq22hIpgm+rUti3GDB1Owbb48YS2/em4qthDUfY+PDBvJGq+D6to0y9OtUOCqQ47hsJGjM8fw9prl/OSVx3PHKGVelNT4902zaszKKKb0A3ai73ScHoX6PWnhSD9xY4mOKGSFJCIb6rKGJz0cI4lO2e7G/n2P3pSJdApWVd7i3Q33BQhaczgClwISl6LMyl+tdSh5oPUrZomgDjQJGYjjRGhEUkZgGyvi4mNJgS0soIxdPq6LZrtx2EoUErDj3qP5wV1falinUCrknrJMs9UN6zr4581TqWXEFEpBhlczAHWfYksRy7ao1z28UFAp4wl7giIsqLk+V1wxiQMn7sCXv3wkLYFZqe9LVq5azz33v0rBUf1N3H8Mn/nExI2PrwHc/MCLMYIAUHd9Xnl7AUtXreeKzxzDQV+6PlPWrsetr6RWYGNIPSAowlS36DYyg6gav2P31AQggwgjoVRw2H3wQK485kiufPopHnznHTzfpxAEwbv+uOPC75/eYzxn77wb765dTb/mbvRr7salj0/m5aWLUmvgS8nw1vzMW9e8NoWKW0+NPRqbQIauyaZHc1boCxMUtY1bICnO1hKRaGlj4EmBLaMIqJEyWmbsZ/VQQmQpIkKTrCqAP879Ledv81ks8f4KNJ5bqtJiaqY04uWVUtlFqgB2ocmtxMajgI8rRSopTwQRt2SU0AGUCTh+lK7BxkrpfVTIbYnTdARWsXMJmroCthKFzYCd9hqV67jc2juSKS+cuyL+oDXWSe4g24pOtjJ+vViwOef8ifzlxidCBXHYV/KNNuzifF/yxL/fYtnStVx73bkAWJbgc58+hP93xn4sWryGAf1b6dkjrtzcHFiycl36uC1UdreVa9sY0Ls7h4wbzaMvvROrklq+zWVWTOxu6iSE0keEDnAaqZo3zsiLkFKAAwO7dePGU0+kXCjwi6OO4rw99+TpefPoUS5z1HbbUbBtHp79Dq7vs/+wEfQol9mxb/+wj/N2Hc+kOW/HTFEdy2L7Xn0Z0zs/ttRrK5dsVNEupYX0fGwnWoxQApmFm4NJmk5quq7Ke5BUuKr6thUfSRSpS4YmmDpRjyctpC9xrPzRC6Dm2zTZ5oFChn9fX/sqL6x6hgl99t/ICmw+uH47G9z5wR1NM1KJoy0JhIUnlcmug0s5LFcRkTqwKPl1xewHhMAK1qROkHQonJUMVzxQXdGcQRAI69sUun/lP+rAtlWnsBlg2xYnnH9Qutyx+MQ3okRy0196V4mNNAS2hGbuhPgpVkZ/pYou+YVvH8ff73wuCGsdiAKC6sLMc2AlO1PdzJq1lFmzlsbKu7eUGbPdwC4hCABNxUIan0tl5rvN4D4AXP6JIyiXnJiM2aiaTxAMnUOsfvp2ndMdmDe34sUxSPSzoq2d5+dH4Zx36t+fC/bai9N22YVpy5aw9x8TTXCWAAAgAElEQVSu55JHHuTrjz7MPjf+jrunvxFrP7ZPP6756LH0KTfR5BQo2jZ7DxrKH486ueFwR3bvlT+o5IAlgUI6fTXrAGOF8vxI8SKEshIy/SmljEJAx+8oKdpKheqpCElhqhCIcjEEv3CES0F4OAEXIwMUWfOt8ASu+xUCan6Vp1c80XB9thR8WUcHpjSXzcGLMe8aKTtE1lp6ZgA1CngoB0AHiR1QF4kKmW3WdoL2+gzTCARF3LXfwmu/AymznWW7GrZyCpsJF3zvJFp6NnPXdY/g1j1KzUXO/upRHHH6vgD4vs/t1z8evY3C2PZxA/IQ1AElyGRlCf58/5eoVl062tObQUAYqTuiEulxep5k4cLVjB695T4HWfD0tDnMmr8idnuJOjF+8rgJYVlTqcDgPj2YvciwQw8uWgSxdiShlZA+TQlJLDCgvp4ZDylj/qG+IVFfE5FGetLwuoA2t85n7/knR43Zji8fsB+DW1U2unXVKhdNuo92N2699d1/P8aeg4ewTc8IqR82cjSHDB/Fe+vX0r1YpG/TxvMCXLzrR3hu2fwokmogass6OIbTFPq7Grzvy9CTWYMl0kHoon6M3AdBvyU7yT1ICrEy9cWVFgUi0ZUvlYWRNtuM96F6VzPLHo/shMJ3S6Bo96B7YSTr6yYXm6tlSoSyiMplIGJKS4EF2iUt5KKI0qYLCXV8bARZamtBO7L2NG79ZUT7XRT63IYQW56GtBFs5RQ2E4QQnPWlI/nbjJ9xyys/5M43fspJnzo4PFFsWNtBR5uR1Ft7Jmtls7lzPBlFIEO9KoWCzb8nv05TUzEuNjLAshNYLqOa7/uMGrV5oa87A3c8/ArVWlpnIi343b1TOeiz1/HJH9zKu4tWsnDlWvNQGgOhncF0+/BC8New62/IWSQlbBCF2JZReaa4O4vQGEHxK67LfdNncPyfbmFFWxsAj82ZnYmgXd/nnremp8pty2KbHr06RRAA9u4/jO/uqfMxRMqXCMGriQkrGdhOxL77vhXkVdAipY0JpdSktUGm68flbo10Dr5xbynBDjiDNEHQo89GQ0WrxL59Dsy81pWwV//LA5QsUlLZTYEoblQawvObSKjXhXJa84i8mcP+UIcSDx8p25HuDPzKQ5s3uE2ArURhC8F2bHr0bknFDmpuKWPnZOLKBM13B596zWPO20vo27+VbbcfECcAQLHkYBWC/lOymOCrhFKpgONswjg2EdZtqMR+SxRB8FGZ2zxf8uacJZz/o9sZ0DPfIS4U4+svOgC9MNCbZrpMAphE5klioz9agCsC8YrIIDyJhqlgfCjLo7ZajZteeJnJ78xkyry5uBmB6zzfp62ez+7PXrOKqYveY02lI7cOKEX0kvYNobxfBoplYSxCkiA0NjVtwFaq1hm/pfJMDglDY8uhuMVNY6GXJjoV30FKQmujklViu5Yx76s+QUPv8o6UrT6hvJ9c4iCpY2WWh4G0c5YlNEWVMnT60yBQSmUr4BXCrR9KFwJxs2zDrzy2BTPtHHQJURBClIUQk4QQ04QQN4sMrYhQ8GchxLNCiPuEEI4Q4kghxAIhxFPBZ0xW//+N4BRsTjh3f+XNbELeUSJRXCoXGL3jYAC+8+OPMXhIL5qaijQ1F3EcmwMP2ZHBw/tETcOIZYHOIngbKzWXT573B+5/YFpXTi+Eg8dvR2kjPg4SlcFtj1GDKSQD7wV4SmQg4GS1rL8x4pDTJtD9xQmB2TaroQx8AlMcmKTme9zw8ot87aGHmDzzncz8y02FAoeNSpuZrq50cPK9t3DM3/7MZx6+hwm3XM+VL0zJMO1UcMHjd3PdG88Qo37SCp+vdmZLzUlmTdD8rVN6JrkOUsnqBQQhK2zqvkJ/OcxrUD8KupeVjjXZN4CUFq5s4thBJ3PUwBO4cNsv8dH+h/Hy6qmsrC5v2EdXwNCWw6O9JXQGBcJ3Sq9NPUihI8P1VeUOkjBPW0YoD4ESG+nl8IJqmgAgZbjO+bkkbLB6d8V0G0JXcQpnAwuklLsBvYDDMursDzhSyn2AVuDwoPx6KeVHgs/bXTSeDxSqlToP3/U8a1duYOxuwymVCxSKDj16NbPTHsMpleNIVFgCu6iIhwSkENRdj0qlTqWjRt/+rdxwy0XssucIajWXQtHhiX9NZ8TQ3kpOqTvypTJP1MdroTZvreZy7bUPs2pVW5fP9dRDd2dAn+6Ui2pOec7alZpL0bY594jx0eUEhhcZSuVcMN5VnXeh4ZFUtzEgt7o0rqf6DU5vnqStXlcEwTevQLNT4KPbbMveQ9LJiS5+7J+8vnwJFc9lfa1K1fO48fWX+OfsGam6r61YzKMLs8OaS089+DQtEaGUKY64ImqhRUe+DALgATpns50SgQTpJUW0FLZQUtD4aVrlYtYchOYngCCbWx6BipDm7j1348hBx7Fvn/259b3f8Ke513Dn/Jv48Vtf5a75N+USzi2FZR0vsbo2Dy9kDZVbmp6NCBTt2sKqGri2BQG2sfBVThMEtZipmwxP/pr7MK8WgAIq0IYPeSmVDLCwm0/vqmnnQlcpmg8B/hZ8/xdwMPBwos5S4Orgu8lXnyKEOAGYD5wqP+is1VsIa1Zu4IsnXs261W1U2msUywUKBZvLbzyfsXuOxPd8fvvT+3nknpcBKDcVOfeLhzFvznIe+NuL1IOMbp4nueOmKTz58Jtc+9cLuP0vTzPtxbl4nqQj8IV4YeosBg3sycKlawwbfSskCCZYlsVzz83iqKN269L5dmsq8pcfnM19T7zB06/OwXYsXpgxn2rCua+pVGDHkQM59iM78cDzM1i0cl0M2epDuY5impQ7mCjEDIURXpf5TJjuyzz4awQXrltGWy9USMQvChJITgrwJINaW5kwbCjHbb8DE0eMTJ32VnS08fziBQmvZuhw6/zh9Rc5fvRYAGatWcGFT9zD7LUrc8ZmnGKlOkQIIY01ECiDBYE0FLgibKYVycpk1ArkdjmR2aO7ClOXoCKmCsARXiwtdjTvIB8DVmC1k+ZAdKIaIQSnDzsNKSU3zPk56+trYjL251c9yeiWsezRa9/8AW4GzFn3T15e/jM8WUHvkOgcIPCxAR9LKhJhCWWqWhCm5Zaaq0eUczlHIhkDF3CMBXelIjJOwnxMK6DtlkuxCtvxfkNXcQp9gLXB93VAiseRUr4jpXxeCHESUAQeAmYD35FS7g0MAiZmdS6EuEAI8aIQ4sXly99/VnJL4E9XPsDKZWupBBZDtUqd9g0VbvjRfdi2RaHocPF3T+Cuqd/mjw9+ldue/CbHfHxvzvj0RJIpsGpVlyULV/PopFe59+4XqCac4KpVlzUrNlBuKiJMb+lcEdXGjtKbB+vaKpQKNkfuN5b/u+BIdhjZn2Ih0mPYtkVrtzKHTxiDZQnOO3LvTA9qQYJbkBES1xViBEGLnpLtkiDjfQRFEfFJfox62d3JKLxG2EYwqmcvfnH4URw0cptM9n9dtYqTkyNhdaBbqLh1PvbQrcxau5J8f9moXOh0rCHXEAxIAEImxBHpMalwXFEilyx5ualUzlIWa/eYLP9LxVnI2G8lJgnqBqfwIU2D6Vfuy9LKQtbWV6XmXvOrTFn+SM56bB54ss6rK34ZEAQ1Ok8mZYxB7CdlpEoBLwqAF4Ng/RB4mboFGWRliyApWpNIXPxA/CuDx6hWzCofTaH7pzd3qpsEXcUprAC0W2aP4HcKhBDHA18EjpNSekKIVcCjweW5QP+sdlLKG4AbAMaPH/+h5iSmPvQGXj2+aaSEOW8tom19hW7dlXdxqVygVI70DdOnzadQsFNB9qqVOs9NmUl7WzXzfpWOGr+78UL+8qcpTJ++iNYeTcybv4p6Iqy370v22zc7lMKWwM2TXuCGv08Nkc8VUvK9C4/kjTlL+OfTb+K6PhPHbcvFHzuAcknNd1CfVppKBdoqcUVsgFtxLIFr5oNMKRJyvqcP9bEqElKpOsPqSc4kOD0j4hclEuyoRG/Gsm1z4tiM/AcGDG/tSdG2U+arjmVx8PBRADw0/x2qYa7m4A4Z8xKWHxIEXVd7JIdB8xqshAqNEaeAemki7inwTzCQuudb2Ha0t+xMBAkEfIoQ2vpI2/aYHIv6XhQO5448G4CarJKd6wBqfiWzfHNhVWU6bthnY+W5evLaGivfykgCVSxKeNiScI1t0jZWSeQrhOK+qsKnjB2EuFACKEv0Dp7Z+3OwM6GrOIXHiHQEhwCPJysIIQYClwLHSCnXB8VfAU4XQljAzsAbyXb/beAU8i19bCd/uVt7NqdlphZgCV58djY9e2WbMA4a0ouVy9fzrW+fwO13fp4bfn8+J54wjkLBxnEsSiWHYtHhkq8eRY8uclbT8PbcZfz+H89Qq3tUai4d1TqVmsv//fZBzjt+Ao9ccxGP/+ZzXP6pI+nTIxr/+DFDKeZYRFkW/PicI+nWXIgh7xjHkAECMnNIpCCDK0j227O5TCn1HIMGgSzdjMUkgJZiiePGNLaTcCyLHx9wOGXHQbtrlWybnqUyn99jHwCWtq83iELWuGUYLVWPIDqhB9TD0DU0wiERsjdEQhj+ghIcO54XQIjIkibiTLJBJL4ZU9CSLywkHh5XzbyWxR1LGNI0IjOsRUEUGddrv/zJbCK4foUpSy7HlzoSqnEICUer/lp4FPCwkdSC6E95Qm4tdtICtQKSEpJCgotS3FKCU9BBLiGwRAo9TfA77sJbczGy4/733Ymtq4jCLcAQIcRrwCpgthDiykSdc1EioocCS6PzgOuATwLPAf+QUqYNu//L4PBT96JYip8BbNti9/22o6wjsGbATrsPo3uP5ugkEPLkyjN4w+oN2LYVmqbqeitXtfH9y/7Gx4+/ipdffJdvfetO7rv3JRxbmS7uvttw/nrzZzj00J26fK6Tn56e4khAhdN4+tV3c9sVbJtvnH4IkJba+D7c+eRrfOqwCfncQAaEuoZEWawtoVSFGPaT8XGs7qjg1X0KCeSkOZksRFup18PYR43g6FFjuOu4Mzhu9A6M6z+YC3bbm4c/9kn6ByG39+g7hKIVT/4Sm7wgRhD0LOMHiogw5CEvS/ihsji+pup+Qa9ESXyi/M2eL/B8pYptlGhTop5n3ddmnLrv6EyuDCUk7V4Hf5z7Z2zhcPaIz1IQKtUMKH+F/qVBfKRflv3K5sHc9Y9Q9dbEELxy+jOfuYpxpGMzJV/NLNAzs5H4In6AUNcVOBCJifQ1o2Laka2GX5mMXPdt5PLDkN5S3i/oEvGRlLIKHJsoviRR5wrgiozmB3XFGD4scMbFhzH95bm88/oCfF9i2xY9+7bwlZ+f1rCdZVlc8btz+c4XbmHRglWpwGn1qodTgP0P25FZby9l0cLV+JJYxNNvffV2ZMnCdX10BpjXpr3HtGnv8dGPdj1RqLvJEL8KpFS5FRpBj5YyzeUCbWYYkOA9eHX2ImavXBX1l7geFpqEwo6/fEk8JyHmBS2M8piWNADPl+w4oD9vrVquoqLqHn3SGdahUwRBwy79BnL1IcnXRcH4/kPYte9Anls63yg1ZmOIcqLoqHGkpSeTjp6q+1LZ1lSUTkEYTTAD0Xm+FXouK/FUkMs5yOcshCINsRBHWs8jFOchfUspUC0tPlJ/zSxnEsnM9e/g+i479xjH18dewTMr/sWa+irGtu7GHj33wbG6zpN3acfLuLIDsIIAFXockWzLEn4GAYiivGaBhaRIpISuYoH0KaifIYn3gKqU2ELgJMRCFspvwU48EIkE2Qayglx3OaLX9Vu2CDmwNcxFF0OpXOCKWy/i7WnvMWf6IgYM680e+28Xy7GQB4OH9eYPf/88555wNUsXrUldLxYdPnbmvjzx+Azuvv058OLyEs/z8WsylnSnUqlzx+3Pvi9E4ZC9t2fSlOlUEgl6PN9nn11HNmw7dlh/5fSVhYikZPWGjrguwUDmoQlqABrhJ09kISo3dYeamIhEeWIcEnhj5TKjJIiQo+UeRv2ibXPKjo31CZ0FIQTHjtiBl5YtwM1IQZlQcWwELHzfT6XbBJXTwAoiq6q1MymsQvp6G3nSCpCkTrMJthURHCVgiSKIIsExxDCO5WEF8nJAiWIyEgNZwgpFR/1KAzl+yJmdmeRmQUthCCogRx0Xm6KRr6CKTXODKLM16WBTjx9CpKQgfEqWYj9N/s5DIdokBvAAW0o158QzreFRkiImYrLMHqv/ft90DFs9mt8HEEKww+4jOPrMfdnzgDGdIghm2x13GZppnePWPQYN6UXbhooRQjsBGQeY1au73j8BYNwOQzlswvaUSwWlULQEpaLDF844MKZDyILuzWUuOHofbCuOyUMpg8yXVmsRkAiyo+UpVc0XM3x3rPiFEMlmNM593YyQHI5lsdvAgXx5/67zvF1Vbc8kCBpkQAU3jg4ixW70kTi2wkBKvGQhwzhHSniizVQj7iOQbEsr5BZcP/BxMKiqJguKcCghkROk5BQG4XFxUmItW9iM67nH+x4mW8Po1uOxAu/ptMWQSPyNg4dFXSaCBiIo4UWHBhltM4nAzenLxky9qf4psiKpE+e2rf8Qut5KFD6EcMb5B1Isxpm4UrnA0SfvSUv3JvbZfzvKSU9pDYknalmCPcaNZO26Dp57YTZvv7Oky5yAhBBc9qnDufrSkzntiHGcc+xe/On7Z/Gxw/boVPvzjtibAb1a4kha/03EQop9N7F98lpWseYsMsREoY4h2YeAQiNiHuglCsLito9/nKZC14k2xvUbQrOT7E9mRnWNn1bTfVlWfBFtKyIUeiE9X3ECSuRjho82QaCjGmkrHE9ahr5AkYWi5Yf5opRS2lJmnuF4FfJ1pRU64RetIgPLA9ixdTR/fPe3/HPR31hVW5kcQJdCt0J/PjrkKro5g7BFCZ8yjigCfoxrgNwzA34gSvJRUVXVoUaVeQjcMEpsMgub0U/OSV9tL4mwBmBTwME26tpQOvh94RJgq/joQwkjRvXnZ7/7BL/95YPMnL6I7q1lTjpzXz52jrK+2Guf0ey623Bem/YelQ7FxpZKBcbvM4rnXnqXWs1Vsl/boqmpQI9ezXzszF9TLNh4vqR/v+78/Men0b9/6xaPVQjB7mOGsPuYIRuvnIC657HCyOcc9omhAE3ue1PkoyOnBv/pvMkbhU6IX/qUm1iXZ+VhtK3W3S5/OfcfNJKdeg/g9ZXK8xkkwlRZaPk+qBOpiPQHUfwedTFraFllnm9hO43Nt+LezpG4qe5bFG0/NE9NyuBdaWHLKKKqCgqnCJIlbA7tdwhvrHuOexbdQc2v4giHR5ZO5uLRl7Bd9x0ajmlLoH/Tbpw08u+0u0uxRJEH5x2BjcTDwpeCIh4e2korWtdCeO4PdyplkZBpop6FudWy1FEix+tS73HZdDJW9WHwV4DsANEEogei9fItnH0+iP82B+Lx48fLF1988YMexgcOnufz1BNv8/ijb1IqOxx97B7sNm4Eb765gNtve5bFS9aw667D2W7MIK759SMxub9lCbYZ2Y8/XP/JD2z802Yv4ou/uYe1HQn/i1BODb5NPGS21gNkcPdSgsw6rAfIUzpkEpiUElrALoMGcN2px/HY7Nn89N9TqHsenjSiWBqcimNZvP2Vxpn6NgdeWLaALz55H4vaA+ttK0C4sZO+TP0GqXQF+rROFKFUiMiCKAlC+Di2H/olpJkkSdF2c8JtKzFR2cm/XrQ845ryf3CCOdlYNDt1/MQJvXexDz/a+Vf/Edt8gHtm74tPB4QoX2KLOiUjFHioN0FSQiXWsfEo5+gglAhN1S+TTnPaTVi58aFsbMrdL6HUchFUHwd3FjjbQOmjbE74bCHES1LK8Rurt5VT+IBg/doOJv/teV5/cS5Dt+nL8afvy6BhnQ92ZdsWEw8Zy8RDxsbKd9ppKD/44anh70u/eUdKEez7kgULVzF/wSqGDe3aAFvr2ipYQtDy/9s77zi7yjLxf59zzm3TJ5NkMqmkdyAQAoEESEIgFBNBZMFlfyIKrottRVzZ1UVX18rquj+wUGQVUVdWRQQBSUACCIRQEkIgpBdSJ2UmmXLLOe/+ccqtM5mEO3NnJu/387nJuafd9z137vu871PLIh2e0xZPctP//x0t8WT+QO3N+JWv7pG8wy45+wWy6i74OxWg/OlZ7grBt1tI+tiAaJQHr78GQ4RrTzuVWSOG87s1a7nn5ZUFVc3dMana2LSfDy/9TUaQW+bAT9Zs3TW6e8c9SSCSNuArDPwiOUqBUdBJyncS9eIUlGA5Tl71tk6H5swVXOHDWX3JDHqzcWi3FeGcth1JHqYxsY9BkYIxrUUl5bSiSOa0VIJ8R9l9T9tGLEnmHc1H+SFH+UeUt5qQ/E8QDKzIRYhYEF1I4ZRyxUcLhRKwf28zn7zqTlqOtJOIp3jthQ089uDLfO2HH2b6zNFF/aym5sKpmU3T4PCR4kWIbt65n6/85HHWb3fTkEwf18BXbryYhoH5KqrlqzeR6MxlVWUM5AWOdWhVzohWzlUxBefk3Co4JO6p1WVRbntsGdfNOo2xAwcwYdBAvjjvXJ7fvpW1e/NTrJw6tKHjfhwnP1nzUuEANq/RimzBgPLUR6YTGIIDkwGusPB120q5zz0zIA0yM6y4EtJRabdL34W0s4A4wVVBpau5pe8fRD1keDDl3qOQQHFQhI2OY3uKSVtqL4ZY2Cr77zLUgQoO3AA1pcRLhlcIFRjvwzk9FNyEeI6kazH7Rmf/qzCA1KGPYtTeixGa8B56d2xoQ3MJ+PkdS2luaiXhxRikUg7tbUm+9+XfFX3mOfecCXlGawAUjBtTnBnYkbY4H/v6r3l7yx5StkPKdli1ficf+/qvC8YrHDjcStIu7I5qiGCG8qelgXakE4I/5kyX+04mccE9fSEiwuaDh/jf19dw+b0P8PCbb7H9UBNKKb6yYAExy8L0RghDhLJQiC/Pm9d5o46DNQf2eLERHZN9WBUYjPGWSWkruog72LsvfwWgsMzcayWrUE6m7jzzs/36AJb32Q5GYFzNfIGXKZW0ITuz/ZZYRHOWMAYGw2MjqQ7VdPocikXMGox9HJHC/hqt3Yt0zrAGBP9apMvv+kfDZEc0K8AmHZvg/muj7B3E91+FUtmr/e5EC4US8NLyddipfKNe494mDu0vrvvo5UtOZ2BdBZGIn9paiEQsPv3JhYWFxXHw5Ivr3BrSGfscR9HSFufZ1zflnR8OFygOlME1555KNGTljkXZnkIdXBsxDWJhd/BeNG0cr375Jr7yvvkF02ooCH4B7kzXvWlKKdpSKW7+w+Ms/Ml9LPjxfVSEwvz+2r9l8eTJTB40iCumTuHhv7uW6UOKX+Z06oD6QPgErQtyT0jQ/yDNhDjpfEfeEkGpoCQ4rsFZZRwTzxU1O96gM8ycbLGBYCDbNdZWhuuuqgTbUzuFDJuwaQf3sP0k28otpjO9egqn1c4gJCEiRoSIEaU2PIAbx37yOJ/gsWMZZRSaQaQKFtVxSauVXPWcrQi8kdyMqa49IRGo5dxXZ4tgR7lpu9NV4BSoJpLN33zPfewqWn1UAmJlYQ4V8LhTCsLR4n4lFeUR7v7hdTz62GpeXLGRgQMruGLJ6UycUDy1x469h2gvUJIzkbTZ1dict39ITSWmIcEgnIkhwqcXz+Hq82fwq+Wvcf/y19wfZY4tICBjf3kkRFVVjMYjLRiG8Nw7W3n/f/2C+2+8ikfXrGP1u3uIp1J5twjeS7agQFxBsb2piavu/xUvfOrvuf2SRUd9Hu+Vj087k4e3rMXOKN4TMUPMaRjFwLIyXtizle0th9K+/5IjPb3GZwXzFTAwpy0J+Q84t9ymkSFUcu+Se7UIQZyC4SXVy/1swWRsxUguabiQMwachiEGu9reZUvrJmpCtUysnNJjMQs+MbOeNntX1r64MgtkRXWfTViSntrRq7UgmSn1XC+mkOd15QoLd5Vkkm9DSJO933+2dusDqKpbEIm9ly52Cb1SKAGLrzkrK0MqgGWZnDZ7HOUV0aJ/XllZhA9+4Az+49tXc+stlxVVIABMGTOEWCTfGyJkmUwcla+imjlxBBErY7WQMfP/9PvnEA5ZDK+r5pbLz+eS0yYSzilFGszQcn5XrXaSvYePEE/ZJG2HlkSSXYea+cpDS7nn767ghjkzaaiuTF+Wa8jOtCjm/N+aTPHoWz1TA+rlPTvyxnhRwtdmXci3z7qUJaOnkJkpHVV4gPFv4ajMd9mkSzukvwjXxp95vspSBXWEa8tQhAwnSIMBbgRw7rUODg3RoZxZNzMY/Btiw5hdN5fJVdN6XCAATB7wcUyJeHYAT5gFCa/9pZo7vEdIYnrPxaSQ51FaQGQe8stsdvQoM8+1ModnCeEk3zj+zh0DWiiUgMUfms3chdMIhy3KKiJEY2FOmlDP5//9yqNf3As5b8ZY6gdUEspQ0YRDJuNGDOS0SfnVxyIhi9s/vphY2CIaMjENIWQaXHnOdK5dcFrWuSMH1bpqCNyXZQj/9P7zAnVY5j3FNFxbRQYpR7H8nS20J5Ncedo0PjBjKudPHE1lWZiySIiKSJiIZRIOGekP6WAS98au3cfxdI6NuJ3i6688RdzJtsXYONy99mUAqsLRjJQHaXIH3sxhSanc6meegTlHukrGMVcQeOuJgs9FBdf4tw5JriHb3Ug62UoTQTALu0KVjOHlFxEyolnR3CKQIOLN8N3APENAiRuglh+dkE3u4G8W2Jd5LCspnmSo5pSNyHuPK+oKWn1UAkzT4PPfuJJrb1rAhrd2Uj+0hvFTjj34q7dgWSb3fvlq7vr9Czz50jpMQ7h0zhSuX3xWh8vk2VNG8dg3buCp19bT0p5g9pRRjB06MOucFeu3c/eTL2UlB7Qdxe0PLecHH13Cf/xpOVv2HSRkGlx+xlT+sGotqUSGUPA+2lGK8759N7Y4KENIOQ5Ry6SuopyvXDqfM0aP4Gq0QvoAABwzSURBVOtPPM0f3niLBHaHGbgn1Xe/a+TGpgMF9ycdh+U7NwMwr2Ec//nGci+wDUBwbAPDdHKS4KUT5aWzlKaPC9lqnUzR4HgLB3e27xefVMF1PpZhB/bsdJK83NZLkG7bPxYyQpw7qLhV1N4r24/8kZRzOGevg+P3N+iYaxcJeQmybQQpmHwwf9Yd2Akk06AMFpKVAM8X+umsydWI1TMl7LVQKCFDhtUyZFhtqZtRFCrLo9x87Txuvrbr3jjV5VEunzO9w+P3P/NKQbuDoxQvrtvCw7d8mPZkipBpYBoGLakEj6xah52ZaM/7P2F7g5ehwID2lM2e5iO8tn0Xs8eO4t8uuYBPnTubB15dxY9fWJE3mwuZBn9zyrQu9+14qYvGSNmF3XX99Nrjqgfy4Qln8PN3VtJmJ/Hnno4tXhyCtwrwjejBakChlAT2AsmyG6QHff8OpmfVVwiO8n3t3X1+dLOftkJEdVCRLI0lVuBxc8mQC5hYWfyiT8eLUoq1B+5EUejZe9HMwWCuCHtRzSJuLiQT27X5Z7jJRQqqldKfh7iCIJQhAJRnujdzxIkROb/Hgvi0UND0WvYcOtLhsdVbXVVONJT+E/78xefy8uYdHGxpoy2VKuzW6hDUXUg5Dvf8dSU/+usKd3UzdSJfuuh8Glta+P2at1zhAoQtk1986IOYx5DY8HipL6tk5uDhrNi7PauWc8wMcePUWcH7L5wyj4XDJvCdVU/xyv7tOBnpml3DfOGUE6BwHCmYOTXrgamsSzANJ2slYSs8nbtbo9nyoqADh6iMW5kYnF47lbMHnkzciXNKzVTqo92/6joWGttXklItWasZn5AfaR3M7nPzQwkJTAwcTD8dtleHIVNZZOGro1xVkYXrhgoKSwwUysu2auQIgBhmqDhZeLuCFgqaXsvcKaN5+93CNbknDh+Yt6+uooxH//E6fvb8q9zx1Atuau6jkEjZKBMcW/GnN99h8/6D/M9HruajZ87kpW3bqY3FmDd2TJbw6W7uPG8Jn/jLQ7zauJOQYWArxedPncu8YWOzzjulbiijKmtYeWBrjr3cNRUXLkWXXhH4yfJyB0KVKRDINYr6nk6CgRAxXQOsH63rKMEUlZEkDwbHBvIP4/+W6lBl1p2UUuxu341C0RBt6LGZcCGaE5uCbLHZz8N1Ky2sZstEcDABBxOHFAY2DhWB4Z6sqHBXnaaCpIuZDt1OzhNHLMzY+99jD7uOFgqaXsvHF57Jz59+hXhOAJxlCH933ukFr4mELK6bczr3PPsyR+KFa0Bn7sh03EnYNu/s3c+aXXuYPnQIY+uKmwKkq9REYvzqomt490gzje0tTKgZSCwvayr8cuMrPLL9zSwDs4ii3IoQJ0G25k0VHPj9ATDfs8i1K7iupW5cg2Hg+d6bmIaNjU3CUW5WVNJqKt8xwJ8lL25YkCcQtrRs4c4Nd9Kccl2WK61K/mHsPzCmYsyxPq6iUBkahSEhUirh1an21GOu8ixLUDgdiAU/XsHFtcwrPAMy+cIkCYQK1ERw37kVGMQ6iXDN9xGjZ4zMoL2PNCVix75D3PHQc/zrfY/z2Iq3SRaIfA6HLB764nWMHFiNiFuvoTIW4QcfXcLowR0P2GHL5NZLzydWYHav/ImuKiAkcH/4W/bnFzgqBcMqqjhlYENBgQDwX29mGpvBjxloseOkHH8V4LmZ+sZlSZ/nlmzoxN3Koz5aw/ILvs1fFnyHR8/7OjeOuwgVrEIE28tJkl1bwQtsE+G/tz5E0km3s81u4zvrvkNjopGEkyDhJNif2M93132X1lR+1tyeYFBsFjGrAXHrpgVJwi1Jlw9Kk1t/AXwBaAZCQXmeRr69oPDnZkau+zWakzgkcU3cEp6DWN2XKbYQeqWg6XGeX7OZW+56JEiJsez1Dfz8zyv56Rf+hlg4ewAcVlfFI/9yPXsOHaE1nmDkoJou6fYvP20qI2qr+elzK9nddAQHxeYDB4l7RlzL8CJPc4K0HEcxfnBd0fraXWw9cpAD8QIDqPJSQIkXPZsV6ezip9p2xMAMZsHucsHMqb+glMORZAuXPfNVEipF1LRoTTXn1GkQ4o6JJbbnVpl2VfXv8+rBtZxZdzIAKw+sxClQRMjBYcWBFZw/+Pzjfi7Hi4jBecPu5fV93+LdlmWATV30HIaWncmGg990n2nGAJ7AJESKkNdXA0Uox7Ac8gSn753VmdFZ8AvtuOo/R7Vhikmq9QHEHES44u+7pd+F0EJB06OkbIcv3fd4VgR0WzzJ5t0H+P7vlgfzrEvOmMSMsWk33fqaimP+rJmjhzNztBsnoZTi6XWb+O1rb5JyHBZOHsd3ly2nOZ4IXF4jlsmM4Q1Mqh90/B3sIR7f/haQO9h4G0qlB/oOvOLTXkP+lU52QJynNjENRZtqp81LvdNmxwGTqCRz1B5CSpnYShGzsld9SimOZKwAmpJNJJ38XD4JJ0FTsqmrj6DohM1qZg35Js3xTbxz6G4OJdayo6UJIYQ7f/dRCIZXclR16mUEbqG+Qq6pglukieA7SN8k/VltJFvu1kJB039Z/+6+gqqidsfmwedXB7+WP65YywfnnMzNV5xXlM8VEeZPGsv8SWlj7ZmjR/CNP/+F5zdtJWJZfODUqXz2/OKV1exOOivXCYJycgrzFD4r2DZyVhOGV4s5e+B3XVpFFCnHIGRmryogNxLaxVYO06rT7qcTKicQMkLEnexaGhEjwvjK8Z03uptpir/Nszs/gq3igEOLN3ePgGc7URg4hHHTV3T2iFMIYc/JNIXCyglxVrju1WYH0dtBDWanZ9WZWihoepRIyMoKRoOMvENpdSztiRS/eXY1S2ZPZVxDvqdRMRhRW82P/mZJt9y7u7lg6ATuePNZEqqTFOSksxrlqy8UhuGvKHIHcpUnJPz7+VLbVoKpnCzXTMHNmJqZYjskFgvqZ1MfTX+H4yvGM65iHOuPrCfhuM4AYSPMmPIxTK7Mrg/S06zZ/z1slZlu3u1vgggx4pjYWNidrgwyr/RxEBKenSGzKmyhamyZx0QprPDU4+nKcVMUQ7OIREXkERFZJSL3SwHfskLndOU6Tf9i9JAB1Ndm5B+CDm2dKdvh2TWbe6hlfYuJNYO5bsKsDganwP0HxzECLyQ/bUU6FR7YjmDbx/KzU1iSImQoL9OqH/2svMI5EtzddfF0eGrvcyzb80JwBxHhs+M/y1XDr2Jk2UhGxkZy5fAr+dyEz5XULRXgYLxwfiGFUG6Nw5JhmEZFFzyR8LImpV+5hXbcaGg3NiE3Zb4f0awQwlW3HXd/jodieR9dC+xQSp0C1FK4RFChc7pynaYfISJ8/xOLqasqozwaIhaxMM3CPyzLFCI9GB/Q1/inUxbwqSlzsbLUD360sv9eOKl8MJ+YMNdVfYjjvgz3mD+IpxxyvGkKYxlOVm4g7x8vFXZ2ZlbTsHFIYSubH268n++tuxfbU3tZhsWC+gV8depX+eq0r7KwfiGWUfrvOmwUrt9gSoTZwx9ifN0nUcQzUodnkhYApieYbdyiOSYErrthIAKuTUIg6UUx+/EMVvDOxQidUuRedk6xhMJ84Elv+ylgXhfP6cp1mn7GSUMG8Kdv3sC3PnYpX7x6PrOnnFTwvJStWDijtDrm3s5npp3HjZNmY/rJ04SgtgJA1Axxy7QFPLd3PYaBZ0wu4GLpGNjKX024hXjyhYQTpLfIvd510zSwvcAPU9KqJf/8lw68zsPvLi1e57uBcTX/D1NyMxUb1Jedi4jJtqY7cFTaScLMEgt+hIHjeSW5zyVJup5C2N8rftUEQRHCMhqwMDAxsDCxMNz3EgaVm4+peymWUKgDfLeBZqCQE3mhc7pyHSJyo4isFJGV+/YVjnDV9C0s0+CcaaO5eNZkXnpnW8FzYmGLQdXH7nV0IrH6wE7uW/+SGwUr2fWE6yLl/NuMS1gwdCKNcTdliOogzbYbrOaqmkTAUe4AHxTyQWF2mCowTcpx7Q6FbBIpZfP47meOq589xeiqqxkUPct758/8bfa2PM2B9tdJpPaSXhn552Til+nMtpHZCCHvyykklFX4DJAolqc4EvFLczrEG69CdepYUFyKJRQagWpvu9p735VzunIdSqm7lFIzlVIzBw3q/e6Cmq7jxyoUPNaFNBUnOr/Y8DKJIIGepw5SEJUwPzzrKt4/yo0NOHlAfgrzXAzSNRDAFSBeCByWOEihyvPe8czP7/gcRWuqcM3w3kRz4k1/2MevreAQZ+3+71Ee9mslS0aQWzYK8aqtKQylsMS1LzjuwQIkwBxAOLoIPGGQxkE5u3ASzxe9nx1RLKGwDLjQ254PPN3Fc7pynaYfEw1bjGnIXyCKwKwJI0rQor7FvvaW/Fw5CKYYHEqmB+CbJs4nZrqBgb6x2cXfdnMYlZkRIoZFmRnGzLAf+Kmvs1cP6f99s6jheetkK1UcTE/PnlRt/HTTr0k5+ZX6egO2aiNuNwbiLXN4bk68zejaL2IE6iU3NsN/Npk2BV+cGOJmlDWko4gRECknEj4DwxhQWKSqFCq1sTgd7ALFEgoPAMNEZDVwANgoIrcf5ZxlHezTnGD86zUL3brK3kw0ZBqUR8PcfHlxYhT6MwuGjidqZkaBu4NSm52gKpTWjY+rGsz9cz7GnMHjMwrGe14xhoNlgmEIccdh9qBJfGbSIiJGuiSM8mfGyiCVIxgEMEUoM6PMHDCBCqsMx3G9kpRSiErbFhSKp/c9z12bHuj2Z3M8mBLBkEjBYxFzEDWxs5hW/9+Uh9wVQ3Z4oGS9QmLj+1D4T9xPhOejANMcSjR2MUZoClCW/8FiIdaE/P3dhOS6QvV2Zs6cqVauXFnqZmiKzLZ9h3jg6VfZsLOR6aMb+NB5Mxh8HFHMJxptqSSXL72Xd1sP0W67UcJ+Ns6IaXHT5HP5+KTsgLw9bc0s+ct/0mYnEXHy9P8CjCofSGNiL7ayczRCbj4g95p0CunxFcP58tTraIjVcf/mh/jdzifJHC4NVJaROiQWP575bSqs8m54Ku+Ntw/cwaamn2Or9mCfKVGm132JEVWLAdjV/FO2H/w2igQGTl4dahObmDiBx1EmJn6VNRCpYciQFRhGJUq10b53HjiNENR1CCHWOCIDH33P7roi8opSaubRztMJ8TS9gpGDarj1qvnc+9mr+OySuVogdJGYFeK3F1zPtWNnYkjaJVQB7XaKO9YuZ9uR7Gpu9bEqll/4z9w67VLKrVCeQVgBW1oaSTq5AsHFVka6dgOup9K21n3UhatoTbXxx12+Fjg9a3ZyVEqmYXIwUbqUFp0xsfYTnFR1NaZEMSWKJeVMqL2J4ZXvC86JWich4q7Qcu0KBoqInwqvwJzbxq2p4GAxYMCPMQw3g6xIjOjAhzCiC4EwSBlm7Aoidb/u0fiN0jsGazSa90S5FaY6EsUQycq6Ca66ZunOd7h+wllZ+8OmxdUnncUP1/+5cNmFjjXgHRwT9sQPsr11B5aYJFW+zcDJqPrmKIdBkd6ZeFDEZErd55hYexMJ5yARsw5DshM11sTOI2QOJJ6KAylsBNN79n6d6k4/A6it/i7RaLaKVMwhRGp/VKyuHBd6paDR9ANMMQr+mAXJCW7LZkbtSZ3E5BYiP5E0QMpJ8cSu5/jhhgc5kkpidxIMFzHCLB56EVGzsO6+t2AaEWLWkDyBAK7gmDrkQWpi5+P6Flk4hDAljGB49pP0K+/ewKGmWzl85Ofd2ofjQa8UNJp+wEXDJvNfbz7jF0nI4sJh2fn4m5NtrDqwnapQlE9NvJBXD2yh1faT0/mJ7bxkGFkF6d1jubWYw4ZFZUjxp13PZqwQXEOzGaSWNoiZBnWRapYMXcS8wWcXodelJWQOYuLgu1Eq5fkbQUt8Jc0tv+FI60Mo2vM8mAzSVdgU7Rxq+lfKYpdimr1n1aSFgkbTDxhZUcsXT76Ab61eGkQ2KwW3zVjEkLJ01a4HNr3Af771JCHDxFGK6nCM7874EHdtWMbqQ9tQpAct2zFQYns1GdzB3cQr5ul5FFliMr16JJtbNueojLxkfEoImSYX1p/D9aOvLHluo+5AxAoG/orobGLhybTFnyFlH8AmjqncFBeFsrmIWLTHn6G87IoebXNnaKGg0fRhdrU289VXH+eZ3RsxRZjXMIEZdUOJWWEWDJ3A4Fi6DOar+7fyg7eXEndSxL04gba2BLetepg/zf8M31r7Bx7b+Tphw3KNzDiYhpBUKcwM7xqF4bpVKhhfOZyR5XW8dXhdXtssMZk1YBrXjLqEUeVDe+Jx9ApMo4ZR9U9y4PCdHDp8DzZJr8Rn4cyz0oELbKnQQkGj6aO0pZJ8YOlPafQC2JLA0nfXselwI3+88MaMeASXX29ZQdzOLm6jgKZEK2uadvIv067ghnEL2HB4N0NiNdRHa/j99hdYuvt1trW+mxMk5957b/wQ9dFJhMTKMy6HDIsLhsw+oQSCj2XWURaeQYsRRqn8gkJpFNFI70r5poWCpt+hlGLp2g08+PIbJG2b9506hfedOomQeZSqM32MR7a9yZFkPGuwTiqHHS1NvLh3C2fXj846vynRWtDoaYhwONnOU7vXcNf6ZexuP8S4yiF8auIirh19PlePmstlz3yJ9pxqaQJMqhrBBfWz+c22J7OEgoFQbsaYUduz9YV7E8nUOyjVAqRjxv0qpiJhRCwGDrgPwygQsFZCtFDQ9Dtue2gZj656m7akO4it3r6bR1e9zd3XXYHRYf6evsdbTXtotfNnoSnHZn3TvjyhML9hMq8d3OYFuaXFQ8JO8eqBDfxi83O+xYBVB7dyw4s/IWqZNMSqabPdmIXMpxcyLK4fs4jacBVfm34Tt7/9Mw4mm1FKMbp8GF+Y/BHMo5V/68eErHGIlAeCwcGvnx2mqvw6aqpuwTB6XzyOFgqafsXGvfv54+tvEU9l1IBOpli1fRfPb9jK3Aknla5xRWZS9WDKrBCtqWzBYBkmY6vyq9UtGTGDB7e8zMYje7D9Ojzi1q24f/OzeecroC2VYltrIyCYRraxtCE2kHGVrmpoUtVo7j7jNvbFDxIyLGrDVXn3O9Eoj13M/qavYdvtpCOULQxjCLXVXwqC33obOk5B0694adN2CnmGtyaSPLd+S4+3pzu5bORUysxwlu0gZBg0lFXlrRLAra1w6fCTMcTwa+MA0GYnulBgR3Ac00v05r52tmVHSosIg6MDtEDwEAkzbPCjlMUW4c6/Q5THLmbo4Ed6rUAAvVLQ9DNqymKYhlvoMJOQaTCgPFaaRnUTZVaY311wPbe9+hjLd2/CEGHR8EncNmNRnpHZ5w87XiPVaV3njsmVG3URPfgfDcusZ0jdPUESvL7gkquFgqZfMW/SGE8oZGMaBotPnVKCFnUvQ8uruXvu1V0edJIFU1YLtkonaUujMIzCS4ioEeK6ky44rjafiPQFYeCj1UeafkUsHOKej1zBwIoyysMhyiNhKqNhvn/NZTTUVB79Bn0Uv1LX0Vg0dDphI9/4q1RunWeFeHUA/H2GOIQNiworyg1jL2bR0KMm3NT0QfRKQdPvmD58CE//0w2s2bGHpGNz8vAGwtaJ6wWTyfXjzuXp3W+zs+0QbXaCiGFhisGnJy3gt9tfZFtLY1AmJ9tRSzCwuO/Mm2mI1mIVECya/oEWCpp+iWkYnDKyodTN6HWUWxH+59xPsHTXWl7Zv4WhZTUsGXEadZEKrhl9NnE7yU/WP8Fvd7xIwsmOOzi5ZjQjyvK9mjT9Cy0UNJoTjJBhcfGwk7l42Ml5xyJmiI+NW8hrhzaztWUfSSdF2AhRbkX40rQPlqC1mp5GCwWNRpNFmRXh3jNvYuWBjaw/vIuGaC1zB08mZOjh4kRAf8sajSYPQwxm1Y1nVt34UjdF08No7yONRqPRBGihoNFoNJqAoggFEYmKyCMiskpE7pcOHKbF5Wci8qKIPCwilogsEpEdIvKc95pYjDZpNCc6cTvF2kO72NPWXOqmaPoQxbIpXAvsUEpdJiKPAAuBPxc47xzAUkqdJSJ/AS7ETRz4I6XUvxepLRrNCc8vN73M7W8sQwRSjsPpA0fy/VkfoDrcv1J9aIpPsdRH84Enve2ngI6qRuwBfuBtJzL2f0BEVojIbztaZWg0mq7x3J6NfOeNpbTaCVpSCeJOipcbt/DZl/631E3T9AGKJRTqgCZvuxkYUOgkpdR6pdQKEbkcCANPABuBLyulZgENwHm514nIjSKyUkRW7tu3r0hN1mj6J/e+81evZkKapOPwyv5tWpWkOSrFEgqNQLW3Xe29L4iILAY+A7xPKWUDB4Cl3uEtwODca5RSdymlZiqlZg4aNKhITdZo+id72w8X3B8yTPbHW3q4NZq+RrGEwjJc+wC4qqSnC50kIkOAW4BLlVL+X+7ngKtFxACmAWuK1CaN5oTk7MFjsCT/p62UYkylTlOh6ZxiCYUHgGEishp35r9MREaLyO05530YV0X0hOdpdD1wB/AR4CXg90qptUVqk0ZzQnLDhHOoDEWzBEPMDHHztAuImr23uIumdyDq6CWXehUzZ85UK1euLHUzNJpezd62w9zzzl95bu9G6qOVfHTC2cypH1vqZmlKiIi8opQ6ar5zneZCo+mHDI5V8s+nXFTqZmj6IDqiWaPRaDQBWihoNBqNJkALBY1Go9EEaKGg0Wg0mgAtFDQajUYToIWCRqPRaAK0UNBoNBpNQJ8LXhORfcDWLp4+kE7yMPUjdD/7F7qf/Yve0s9RSqmjJo/rc0LhWBCRlV2J4Ovr6H72L3Q/+xd9rZ9afaTRaDSaAC0UNBqNRhPQ34XCXaVuQA+h+9m/0P3sX/SpfvZrm4JGo9Fojo3+vlLQaDQazTHQ74WCiIRE5I8Z76Mi8oiIrBKR+0VEStm+YiIi5SLyBxF5XkS+U+r2dCci8gUReVZEHhORcKnb052IyD+KyNKjn9k3EZeficiLIvKwiPSLlP59dazp10JBRGLAK8DCjN3XAjuUUqcAtTnH+jp/C7yolDoHmCoik0vdoO5ARMYAU5VSc4HHgOElblK3ISKjgOtK3Y5u5hzAUkqdBVSRLu3b1+mTY02/FgpKqTal1MnAjozd84Enve2ngHk93rDuIw6UeTOSKJAocXu6iwVArYgsB+YCm0vcnu7kB8CtpW5EN7MHt5/Qv/5m++RY06+FQgfUAU3edjMwoIRtKTa/BC4G3gLeVkptLHF7uotBwD6l1Lm4q4Q5JW5PtyAiHwJWAf26brlSar1SaoWIXA6EgSdK3aYi0SfHmhNRKDQC1d52Nb0j/LxY3Ar8WCk1CRggImeXukHdRDOwztveBAwrYVu6k8twV0W/Bk4XkU+WuD3dhogsBj4DvE8pZZe6PUWiT441J6JQWEZaZzkfeLqEbSk2lUC7tx0HKkrYlu7kFeAMb3scrmDodyilPqSUmgNcDbyilLqj1G3qDkRkCHALcKlS6nCp21NE+uRYcyIKhQeAYSKyGjiA+8X1F+4EPiEiLwAx+lffApRSLwCNIvIysE4ptaLUbdK8Jz4MNABPiMhzInJ9qRtUJPrkWKOD1zQajUYTcCKuFDQajUbTAVooaDQajSZACwWNRqPRBGihoNFoNJoALRQ0Go1GE6CFgkaj0WgCtFDQaDQaTcD/AdyZlw4pZ0biAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n", + "lda = LinearDiscriminantAnalysis(n_components=2)\n", + "lda.fit(X2,y2)\n", + "X2_new = lda.transform(X)\n", + "plt.scatter(X2_new[:, 0], X2_new[:, 1],marker='o',c=X2_new[:, 0])\n", + "plt.show()" + ] + }, + { + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}