{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 1.3 机器学习常用的包" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.3.1 `NumPy`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`NumPy（Numerical Python）`是一个开源的 **Python** 科学计算库，用于快速处理任意维度的数组。\n", "\n", "`NumPy` 支持常见的数组和矩阵操作。\n", "\n", "对于同样的数值计算任务，使用 `NumPy` 比直接使用 **Python** 要简洁的多。\n", "\n", "`NumPy` 使用 `ndarray` 对象来处理多维数组，该对象是一个快速而灵活的大数据容器。\n" ] }, { "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.itemsize|\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", "# 创建不同形状的数组\n", "a = np.array([[1,2,3],[4,5,6]])\n", "b = np.array([1,2,3,4])\n", "c = np.array([\n", " [\n", " [1,2,3],[4,5,6]\n", " ],\n", " [\n", " [1,2,3],[4,5,6]\n", " ]\n", "])\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]]])\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]]])\n", "\n", "# 分别打印出数组元素数量\n", "print(a.size)\n", "print(b.size)\n", "print(c.size)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "+ `itemsize`：数组元素的长度" ] }, { "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,60]]])\n", "\n", "# 分别打印出数组元素数量\n", "print(a.itemsize)\n", "print(b.itemsize)\n", "print(c.itemsize)\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": [ "### `ndarray` 的类型\n", "\n", "|名称|\t描述|\t简写|\n", "|--|--|--|\n", "|np.bool|\t用一个字节存储的布尔类型（True或False）|\t'b'|\n", "|np.int8|\t一个字节大小，-128 至 127|\t'i'|\n", "|np.int16|\t整数，-32768 至 32767|\t'i2'|\n", "|np.int32|\t整数，$-2^{31}$ 至 $2^{32} -1$\t|'i4'|\n", "|np.int64|\t整数，$-2^{63}$ 至 $2^{63} - 1$\t|'i8'|\n", "|np.uint8|\t无符号整数，0 至 255|\t'u'|\n", "|np.uint16\t|无符号整数，0 至 65535|\t'u2'|\n", "|np.uint32|\t无符号整数，0 至 $2^{32} - 1$\t|'u4'|\n", "|np.uint64|\t无符号整数，0 至 $2^{64} - 1$ |'u8'|\n", "|np.float16\t|半精度浮点数：16位，正负号1位，指数5位，精度10位\t|'f2'|\n", "|np.float32\t|单精度浮点数：32位，正负号1位，指数8位，精度23位\t|'f4'|\n", "|np.float64\t|双精度浮点数：64位，正负号1位，指数11位，精度52位\t|'f8'|\n", "|np.complex64\t|复数，分别用两个32位浮点数表示实部和虚部\t|'c8'|\n", "|np.complex128\t|复数，分别用两个64位浮点数表示实部和虚部\t|'c16'|\n", "|np.object_\t|python对象\t|'O'|\n", "|np.string_\t|字符串\t|'S'|\n", "|np.unicode_\t|unicode类型\t|'U'|\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": {}, "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（）输入数据相等则是方阵\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": [ "#### 数组去重" ] }, { "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", "使用 `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": [ "### 统计函数" ] }, { "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": [ "### 比较和逻辑函数" ] }, { "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:4,1:3] > 20)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "比如判断数组某个区间的元素是否存在大于 `20`的元素:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "np.any(a[1:4,1:3] > 20)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### `IO` 操作" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`savetxt` 可以将数组写入文件，默认使用科学计数法的形式保存：" ] }, { "cell_type": "code", "execution_count": 2, "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" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.3.2 `Pandas`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "+ `Pandas` 是基于 `NumPy` 的一种工具,该工具是为了解决数据分析任务而创建的\n", "+ `Pandas` 纳入了大量库及一些标准的数据模型，提供了高效的操作大型数据集所需要的工具\n", "+ `Pandas` 提供了大量能使我们快速便捷地处理数据的函数与方法\n", "+ 是 **Python** 成为强大而高效的数据分析环境的重要因素之一\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 产生 `Pandas` 对象" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`pandas` 主要有两种基本的数据结构：\n", "\n", "- `Series`\n", " - `Series` 是带索引的一维数组，可存储整数、浮点数、字符串、**Python** 对象等类型的数据。\n", "- `DataFrame`\n", " - `DataFrame` 是由多种类型的列构成的二维标签数据结构，类似于 `Excel` 、`SQL` 表，或 `Series` 对象构成的字典。`DataFrame` 是最常用的 `Pandas` 对象。\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 生成 series\n", "s = pd.Series([1,3,5,np.nan,6,8])\n", "\n", "print(s)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 生成 dataframe \n", "dates = pd.date_range('20200101', periods=15)\n", "\n", "df = pd.DataFrame(np.random.randn(15,4), index=dates, columns=list('ABCD'))\n", "\n", "df" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "默认情况下，如果不指定 `index` 参数和 `columns`，那么他们的值将用从 `0` 开始的数字替代。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "写入 `csv` 文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df.to_csv('foo.csv')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "读取 `csv` 文件：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df1 = pd.read_csv('foo.csv',index_col=0)\n", "df1.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`head` 和 `tail` 方法可以分别查看最前面几行和最后面几行的数据（默认为 `5`）：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "df1.tail(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "了解更多`Pandas`内容，可以参考：https://pandas.pydata.org/pandas-docs/stable/getting_started/index.html" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.3.3 `Matplotlib`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "简单来说，`Matplotlib` 是 **Python** 的一个绘图库。它包含了大量的工具，你可以使用这些工具创建各种图形，包括简单的散点图，正弦曲线，甚至是三维图形。\n", "\n", "**Python** 科学计算社区经常使用它完成数据可视化的工作。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 画一个简单的图形" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 简单的绘图\n", "x = np.linspace(0, 2 * np.pi, 50)\n", "\n", "# 如果没有第一个参数 x，图形的 x 坐标默认为数组的索引\n", "plt.plot(x, np.sin(x)) \n", "\n", "# 显示图形\n", "plt.show() \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 在一张图上绘制两条曲线" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.linspace(0, 2 * np.pi, 50)\n", "plt.plot(x, np.sin(x),\n", " x, np.cos(x))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 自定义曲线的外观" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.linspace(0, 2 * np.pi, 50)\n", "plt.plot(x, np.sin(x), 'r-^',\n", " x, np.cos(x), 'g--')\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- **颜色**： \n", " - 蓝色 - 'b' \n", " - 绿色 - 'g' \n", " - 红色 - 'r' \n", " - 青色 - 'c' \n", " - 品红 - 'm' \n", " - 黄色 - 'y' \n", " - 黑色 - 'k'（'b'代表蓝色，所以这里用黑色的最后一个字母） \n", " - 白色 - 'w'\n", "\n", "- 线： \n", " - 直线 - '-' \n", " - 虚线 - '--' \n", " - 点线 - ':' \n", " - 点划线 - '-.'\n", "\n", "- 常用点标记:\n", " - 点 - '.' \n", " - 像素 - ',' \n", " - 圆 - 'o' \n", " - 方形 - 's' \n", " - 三角形 - '^' \n", " \n", "可以在[这里](http://matplotlib.org/api/markers_api.html)查看更多的样式" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 使用子图" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "使用子图可以在一个窗口绘制多张图。在调用 `plot()` 函数之前需要先调用 `subplot()` 函数。该函数的第一个参数代表子图的总行数，第二个参数代表子图的总列数，第三个参数代表活跃区域。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.linspace(0, 2 * np.pi, 50)\n", "plt.subplot(2, 1, 1) # （行，列，活跃区）\n", "plt.plot(x, np.sin(x), 'r')\n", "plt.subplot(2, 1, 2)\n", "plt.plot(x, np.cos(x), 'g')\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 散点图" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "散点图是一堆离散点的集合。用 `Matplotlib` 画散点图也同样非常简单。只需要调用 `scatter()` 函数并传入两个分别代表 `x` 坐标和 `y` 坐标的数组即可。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 简单的散点图\n", "x = np.linspace(0, 2 * np.pi, 50)\n", "y = np.sin(x)\n", "plt.scatter(x,y)\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 调整点的大小和颜色" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以给每个点赋予不同的大小" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.random.rand(100)\n", "y = np.random.rand(100)\n", "size = np.random.rand(100) * 50\n", "plt.scatter(x, y, size)\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "也可以给每个点赋予不同颜色。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.random.rand(100)\n", "y = np.random.rand(100)\n", "size = np.random.rand(100) * 50\n", "color = np.random.rand(100)\n", "plt.scatter(x, y, size, color)\n", "plt.colorbar()\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 直方图" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "使用 `hist()` 函数可以非常方便的创建直方图。第二个参数代表分段的个数。分段越多，图形上的数据条就越多。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.random.randn(1000)\n", "plt.hist(x, 50)\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 标题，标签和图例" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "当需要快速创建图形时，你可能不需要为图形添加标签。但是当构建需要展示的图形时，你就需要添加标题，标签和图例。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.linspace(0, 2 * np.pi, 50)\n", "plt.plot(x, np.sin(x), 'r-x', label='Sin(x)')\n", "plt.plot(x, np.cos(x), 'g-^', label='Cos(x)')\n", "\n", "# 展示图例\n", "plt.legend()\n", "\n", "# 给 x 轴添加标签\n", "plt.xlabel('Rads')\n", "\n", "# 给 y 轴添加标签\n", "plt.ylabel('Amplitude')\n", "\n", "# 添加图形标题\n", "plt.title('Sin and Cos Waves')\n", "\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 图片保存" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fruits = ['apple', 'orange', 'pear']\n", "sales = [100,250,300]\n", "plt.pie(sales, labels=fruits)\n", "plt.savefig('pie.png')\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以在这里查看更多的[图例](https://matplotlib.org/gallery.html)。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Seaborn" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`Seaborn` 基于 `matplotlib`， 可以快速的绘制一些统计图表。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import seaborn as sns\n", "import pandas as pd\n", "sns.set()\n", "iris = pd.read_csv(\"iris.csv\")\n", "sns.jointplot(x=\"sepal_length\", y=\"petal_length\", data=iris)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sns.pairplot(data=iris, hue=\"species\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以在这里查看更多的[示例](https://seaborn.pydata.org/tutorial.html)。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.3.4 `Scikit-learn`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "+ **Python** 语言的机器学习工具\n", "+ `Scikit-learn` 包括大量常用的机器学习算法\n", "+ `Scikit-learn` 文档完善，容易上手" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 机器学习算法" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**机器学习算法是一类从数据中自动分析获得规律，并利用规律对未知数据进行预测的算法**。\n" ] }, { "cell_type": "markdown", "metadata": {}, "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": {}, "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": {}, "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": {}, "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": {}, "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": {}, "source": [ "另一种是Z-score标准化（对象名为StandardScaler），该方法使数据满足标准正态分布：\n", "\n", "$x^{'}=\\frac{x-\\overline {X}}{S}$" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "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": {}, "source": [ "归一化（对象名为Normalizer，默认为L2归一化）：\n", "\n", "$x^{'}=\\frac{x}{\\sqrt{\\sum_{j}^{m}x_{j}^2}}$" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "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": {}, "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": {}, "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": {}, "outputs": [], "source": [ "# 独热编码\n", "from sklearn.preprocessing import OneHotEncoder\n", "\n", "results = OneHotEncoder().fit_transform(y.reshape(-1,1)).toarray()\n", "\n", "print(\"处理前：\",X[1])\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", "`sklearn.model_selection.train_test_split(x, y, test_size, random_state )`\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": {}, "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": {}, "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": {}, "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": {}, "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": {}, "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": {}, "source": [ "注意：由于之前采用了 `train_test_split` 分割数据集，它默认对数据进行了洗牌，所以这里可以直接使用 `cv=10` 来进行 `10` 折交叉验证（`cross_val_score` 不会对数据进行洗牌）。如果之前未对数据进行洗牌，则要搭配使用 `KFold` 模块：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "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": {}, "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", "`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": {}, "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": {}, "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": {}, "outputs": [], "source": [ "# 取出特征值\n", "X = iris.data\n", "y = iris.target" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 2.数据划分" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 2.数据划分\n", "from sklearn.model_selection import train_test_split\n", "X_train,X_test,Y_train,Y_test = train_test_split(X, y, test_size=0.1, random_state=0)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.数据标准化" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "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": {}, "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": {}, "outputs": [], "source": [ "# 5.模型评估\n", "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": {}, "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": {}, "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.5.2" } }, "nbformat": 4, "nbformat_minor": 2 }