机器学习笔记（二）：矩阵、环境搭建、NumPy

凌云时刻 · 技术

导读：从因为在机器学习中，一些概念、算法都涉及到矩阵的知识，比如训练数据集通常都是以矩阵的方式存在，所以在这里首先介绍一下矩阵的概念。

作者 | 计缘

来源 | 凌云时刻（微信号：linuxpk）

机器学习的定义

矩阵基本概念

在数学概念中，一个的矩阵指的是一个由行列元素排列而成的矩形阵列。用大白话解释就是将一些元素排列成若干行，每行放上相同数量的元素，就是一个矩阵。矩阵里的元素可以是数字、符号或数学式，比如下面这个矩阵就是一个四行两列的矩阵：

一个矩阵从左上角数起的第行第列上的元素称为第，项，通常记为、或者，那么上面的矩阵中。如果我们不知道矩阵的具体元素，通常将其表示为，如果的元素可以写成与行和列有关的统一函数，那么也可以用来表示。

机器学习的定义

矩阵的基本运算

矩阵的最基本运算包括矩阵加（减）法、数乘、转置、矩阵乘法运算。

加减法运算

矩阵和的和（差）也是一个矩阵，其中每个元素是和相应元素的和（差），即，其中，。举个例子：

数乘运算

标量与的矩阵的数乘也是一个的矩阵，它的每个元素是矩阵的相应元素与的乘积，举个例子：

的矩阵的转置是一个的矩阵，记为，其中的第个行向量是原矩阵的第个列向量，或者说转置矩阵第行第列的元素是原矩阵的第行第列，即，举个例子：

矩阵乘法

两个矩阵的乘法仅当第一个矩阵的列数和另一个矩阵的行数相等时才能定义。比如的矩阵与的矩阵的乘积是一个的矩阵，即矩阵的元素为：

举个例子：

环境搭建

目前，Python语言是处理大数据量运算比较好的语言之一，大数据分析、计算，机器学习的主流语言和技术栈基本都是以Python为主，所以我们在搭建机器学习入门编程环境时同样使用Python3。在Python生态圈中，目前有非常丰富和健壮的机器学习的类库和框架，如果我们手动一点点配置，其实是非常繁琐的，而且容易出错。所幸，现在有很多集成工具能傻瓜式的帮我们搭建好机器学习的环境，其中就包括各种需要的类库、框架，以及他们之间的依赖关系等。那么在这里推荐著名的Anaconda。

Anaconda

Anaconda是一个Python包和Python相关工具安装的管理器。它的安装过程非常简单，只需要访问其官方网站下载对应操作系统的安装包既可，这里要注意的是我们需要下载Python 3.6版本的Anaconda。安装好后，运行Anaconda，会显示如图所示的主界面：

在界面左侧就会看到有Home、Environments、Projects等导航。Home中显示的就是由Anaconda提供好的一些工具，可以直接运行或者安装。Environments中就是用来管理各种Python包的地方。我们在机器学习入门阶段会使用名为Jupyter Notebook的工具。

Jupyter Notebook

我们在Anaconda的Home界面就可以看到Jupyter Notebook工具，该工具其实就是一个基于Web的Python编辑器，可以编写Python代码，然后实时编译运行得出结果，相比PyCharm这种完善的IDE工具，Jupyter Notebook显得非常轻量级，但是在进行算法演练和学习Python各种类库时非常方便，另外Jupyter Notebook在编辑器中除了支持Python语言外，还支持基于Markdown语法的文本编写。我们点击Jupyter Notebook工具界面中的Launch，就会由系统默认浏览器自动打开Jupyter Notebook界面：

大家运行Jupyter Notebook，把玩一会后就可以发现，它其实就是使用浏览器通过Web技术，将当前用户下的目录结构展示出来，并且可以新建目录、文件，然后在文件中进行编码的工具，整个运行环境依托于Anaconda。

Jupyter Notebook基本概念和操作方式

Jupyter Notebook中的核心概念是Cell，可以理解为输入最小单元行，每个Cell支持两种模式的输入，一种是Python代码，另一种的Markdown语法的文本。每行Cell编辑完成后按下ctrl+回车或者command+回车，就可以运行Cell里的内容，如果是Python代码就会运行代码，如果是基于Markdown语法的文本，那么就会按照一定格式渲染文本：

Jupyter Notebook还有很多的快捷键操作，这里就不再一一赘述。后续有相当一部分代码我都会在Jupyter Notebook中进行编码，一些使用技巧和知识点在讲述其他内容时一并讲解。所以不论是在学习机器学习的过程中还是学习Python的过程中，Jupyter Notebook都会是一个非常帮的工具。

NumPy

NumPy是Python中的一个类库，它支持高阶维度数组（矩阵）的创建及各种操作、运算，是我们在机器学习中经常会使用的一个类库。这一节主要讲一下如何使用NumPy。

numpy.array

NumPy中的核心数据结构是数组，可以非常方便的创建、操作数组，并支持多维数组，多维数组就可以看作是矩阵。numpy.array与Python中的List的不同之处在于，前者的元素类型是有限定的，而后者的元素类型没有限定。我们先来看看Python的List：

# Python的List
l = [i for i in range(10)]
l
# 结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 取值
l[5]
# 结果
5

# 赋值
l[5] = 100
l
# 结果
[0, 1, 2, 3, 4, 100, 6, 7, 8, 9]

# 赋值其他类型
l[6] = "hello world!"
l
# 结果
[0, 1, 2, 3, 4, 100, 'hello world!', 7, 8, 9]

Python中的List虽然灵活，但是由于每个元素的类型是不限定的，所以性能和效率会比较差。其实Python中也有元素类型限定的数组那就是array，我们来看一下：

# Python中的array
import array
arr = array.array('i', [i for i in range(10)])
arr
# 结果
array('i', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 取值
arr[5]
# 结果
5

# 赋值
arr[6] = "hello world!"
# 结果
TypeError: an integer is required (got type str)

但是Python中的array并没有将一维数组当做向量、多维数组当做矩阵来看，自然也没有提供任何对多维数组的矩阵操作。所以NumPy类库就应运而生了。我们再来看看NumPy中的array：

# NumPy中的array
import numpy as np
nparr = np.array([i for i in range(10)])
nparr
# 结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 取值
nparr[5]
# 结果
5

# 赋值
nparr[6] = 100
nparr
# 结果
array([  0,   1,   2,   3,   4,   5, 100,   7,   8,   9])

# 赋值其他类型
nparr[7] = "hello world!"
# 结果
ValueError: invalid literal for int() with base 10: 'hello world!'

numpy.array中的元素类型

因为numpy.array中的元素类型是限定的，所以这一小节我们来看看和元素类型相关的方法和概念：

# 查看数组中的元素类型
nparr.dtype
# 结果
dtype('int32')

# 给元素类型是int的数组，赋值一个float类型的值，会强制转换为int
nparr[2] = 3.1
nparr
# 结果
array([  0,   1,   3,   3,   4,   5, 100,   7,   8,   9])

# 如果在创建数组时，有一个元素类型为float，那么该数组的所以元素类型会是float
nparr2 = np.array([0, 1, 2, 3.1])
nparr2
# 结果
array([ 0. ,  1. ,  2. ,  3.1])

# 查看nparr2的元素类型
nparr2.dtype
# 结果
dtype('float64')

创建numpy.array的其他方法

NumPy还提供了丰富的能快捷创建数组的方法，我们来看一下：

# 创建元素全部为0的数组，参数为数组元素的个数
nparr3 = np.zeros(10)
nparr3
# 结果
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

# 用np.zeros创建的数组，元素类型默认为float
nparr3.dtype
# 结果
dtype('float64')

# 如果想指定元素的类型，可以设置第二个参数
nparr4 = np.zeros(10, dtype=int)
nparr4.dtype
# 结果
dtype('int32')

# 创建元素全部为1的数组
nparr5 = np.ones(10)
nparr5
# 结果
array([ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])

使用numpy创建矩阵

NumPy会把二维数组看作一个矩阵来处理，我们来看看如何创建二维数组：

# 传入二元元组参数，给定行数和列数
nparr6 = np.zeros((2, 3))
nparr6
# 结果
array([[ 0.,  0.,  0.],
	   [ 0.,  0.,  0.]])

# 如果要指定类型的话，需要显示使用shape这个参数，传入二元元组，给定行数和列数
nparr6 = np.zeros(shape=(3, 4), dtype=int)
nparr6
# 结果
array([[0, 0, 0, 0],
	   [0, 0, 0, 0],
	   [0, 0, 0, 0]])

# 创建两行四列，元素全部为1的矩阵
nparr7 = np.ones((2,4))
nparr7
# 结果
array([[ 1.,  1.,  1.,  1.],
	   [ 1.,  1.,  1.,  1.]])

# 创建三行五列，元素为指定值的矩阵
nparr8 = np.full(shape=(3, 5), fill_value=100)
nparr8
# 结果
array([[100, 100, 100, 100, 100],
	   [100, 100, 100, 100, 100],
	   [100, 100, 100, 100, 100]])

numpy.arange

在上文中，我们使用了[i for i in range(0, 20, 2)]这种方式创建了Python的List，其中用到了range()这个方法，该方法有三个参数，用大白话解释就是通过range()创建一个池子，这个池子里的第一个元素大于等于第一个参数的值，最后一个元素小于等于第二个参数的值，元素之间的关系由第三个参数的值决定，第三个参数也称为步长：

# 创建一个数组，其中的元素大于等于0，小于等于20，每个元素相差为2
[i for i in range(0, 20, 2)]
# 结果
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

NumPy也提供了类似的方法arange()，它的优势是步长支持浮点型：

# 创建范围从0到1，步长为0.2的数组
np.arange(0, 1, 0.2)
# 结果
array([ 0. ,  0.2,  0.4,  0.6,  0.8])

# 如果只传入一个参数，那么表示默认元素从0开始，传入的参数为数组的大小
np.arange(10)
# 结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

numpy.linspace

NumPy中的linspace()方法可以让我们不用考虑步长，只考虑希望从起始值到终止值的范围内，创建多少个元素，步长会自动进行计算，这里要注意的是linspace方法是包含起始值和终止值的。

# 第一个参数是起始值，第二个参数是终止值，第三参数是数组大小
np.linspace(0, 20, 10)
# 结果
array([  0.        ,   2.22222222,   4.44444444,   6.66666667,
		 8.88888889,  11.11111111,  13.33333333,  15.55555556,
		17.77777778,  20.        ])

numpy.random

NumPy也提供了生成随机数和随机元素数组的方法，我们来看一下：

# 生成从0到10之间的随机数
np.random.randint(0, 10)
# 结果
3

# 生成元素从0到10，一共4个随机元素的数组
np.random.randint(0, 10, size=4)
# 结果
array([4, 7, 8, 1])

# 生成元素随机从0到10，3行5列的矩阵
np.random.randint(0, 10, size=(3, 5))
# 结果
array([[6, 9, 7, 0, 9],
	   [7, 4, 8, 7, 8],
	   [4, 4, 9, 7, 2]])

如果我们希望每次使用随机方法生成的结果都是一样的，一般调试时候有这个需求，此时NumPy的random()方法也提供了方便简单的方式，既随机种子的概念：

# 生成随机矩阵前给定一个种子
np.random.seed(123)
# 然后生成随机矩阵
np.random.randint(0, 10, size=(4, 5))
# 结果
array([[2, 2, 6, 1, 3],
	   [9, 6, 1, 0, 1],
	   [9, 0, 0, 9, 3],
	   [4, 0, 0, 4, 1]])

# 再次生成随机矩阵时，只要传入相同的种子，就可以得到相同结果的矩阵
np.random.seed(123)
np.random.randint(0, 10, size=(4, 5))
# 结果
array([[2, 2, 6, 1, 3],
	   [9, 6, 1, 0, 1],
	   [9, 0, 0, 9, 3],
	   [4, 0, 0, 4, 1]])

# 默认范围是从0.0到1.0，返回值为float型
np.random.random()
# 结果
0.18249173045349998

# 传入的参数是数组的大小
np.random.random(10)
# 结果
array([ 0.17545176,  0.53155137,  0.53182759,  0.63440096,  0.84943179,
		0.72445532,  0.61102351,  0.72244338,  0.32295891,  0.36178866])

# 创建4行5列，元素值的范围从0.0到1.0的矩阵
np.random.random((4, 5))
# 结果
array([[ 0.22826323,  0.29371405,  0.63097612,  0.09210494,  0.43370117],
	   [ 0.43086276,  0.4936851 ,  0.42583029,  0.31226122,  0.42635131],
	   [ 0.89338916,  0.94416002,  0.50183668,  0.62395295,  0.1156184 ],
	   [ 0.31728548,  0.41482621,  0.86630916,  0.25045537,  0.48303426]])

总结

这篇笔记回顾了机器学习中会大量使用的矩阵的知识，以及在本地学习机器学习算法的最佳环境配置，最后介绍了Python中对矩阵封装最好的库NumPy的用法。下篇笔记会继续学习NumPy的用法以及绘图库Matplotlib库，以及机器学习的第一个算法KNN。

END