高等数学基础(向量矩阵及其创建和特殊的矩阵)

向量

向量是机器学习最底层的组成部分, 也是基础数据的表示形式, 线性代数通过将研究对象拓展到向量, 对多维数据进行统一研究, 而进化出的方法方便我们可以研究和解决真实世界中的问题

标量

标量也称为"无向量", 使用一个单独的数表示数值大小, 可以有正负之分, 可以是实数和负数, 一般用小写变量表示, 比如 s s s表示行走距离, k k k表示直线斜率, n n n表示元素数目, 这些都可以看做标量

向量

向量是为了表达和处理高维空间的问题, 为表示一个整体会用方括号扩起来

向量的定义

将 n n n个有序的数排成一排称为 n n n维向量, 将 n n n个有次序的数排成一列, 称为 n n n维列向量

如, 称为四维列向量
x = $3 4 5 6$ x = \left $\\begin{matrix} 3 \& 4 \& 5 \& 6 \\end{matrix} \\right$ x= $3456$

称为四维行向量
x = $3 4 5 6$ x = \left $\\begin{matrix} 3 \\\\ 4 \\\\ 5 \\\\ 6 \\end{matrix} \\right$ x= 3456

如果没有声明一般为列向量

定位向量的值

y = $3 4 5 6$ T y=\left $\\begin{matrix}3 \& 4 \& 5 \& 6\\end{matrix}\\right$ ^T y= $3456$ T, 向量 y y y的第 i i i个分向量用 y i y_i yi表示, 如 y 2 y_2 y2表示第二个分量, 值为 4 4 4

向量的几何意义

向量既有大小又有方向, 将向量的分量看作坐标轴上的坐标, 以坐标原点为起点, 向量代表的点为重点, 可以形成一条有向线段, 有向线段的长度表示向量的大小, 箭头所指的方向表示向量的方向, 可以将任意一个位置做为起始点进行自由移动, 但一般将原点看作起始点.

python 复制代码

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches



# 设置中文字体
plt.rcParams['font.sans-serif']=['Hiragino Sans GB'] # 修改字体
plt.rcParams['axes.unicode_minus'] = False # 正常显示负号


# 定义向量起点和终点（dx, dy）
x_start, y_start = 0, 0
dx, dy = 3, 4
dx1, dy1 = 4, 3

# 创建图形
plt.figure(figsize=(5, 5))

# 绘制向量
plt.arrow(x_start, y_start, dx, dy,
          head_width=0.1, length_includes_head=True,
          color='blue', lw=2)
plt.text(x_start+dx, y_start+dy, f"({dx}, {dy})")
# 绘制向量
plt.arrow(x_start, y_start, dx1, dy1,
          head_width=0.1, length_includes_head=True,
          color='blue', lw=2)
plt.text(x_start+dx1, y_start+dy1, f"({dx1}, {dy1})")


# 设置坐标轴范围
plt.xlim(-1, 6)
plt.ylim(-1, 6)

# 设置坐标轴比例一致
plt.axis('equal')

# 添加网格和标签
plt.grid(True)
plt.xlabel('x')
plt.ylabel('y')
plt.title('向量的表示')

# 显示图形
plt.show()

通常向量代表一组数, 是由使用者定义, 比如个人信息, 可以用 u s e r = $0 18 173 78789$ user = \left $\\begin{matrix}0 \& 18 \& 173 \& 78789\\end{matrix}\\right$ user= $01817378789$ , 分别代表性别, 年龄, 身高, 和名字

向量的运算

加法

向量加法的值等于两个向量的对应分量之和

以两个二维向量加法为例, 如 r = $3 , 1$ t r= $3,1$ ^t r= $3,1$ t和 s = $2 , 3$ t s= $2,3$ ^t s= $2,3$ t, r + s = $2 + 2 , 1 + 3$ t = $5 , 4$ t r+s= $2+2, 1+3$ ^t= $5,4$ ^t r+s= $2+2,1+3$ t= $5,4$ t

python 复制代码

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches



# 设置中文字体
plt.rcParams['font.sans-serif']=['Hiragino Sans GB'] # 修改字体
plt.rcParams['axes.unicode_minus'] = False # 正常显示负号


# 定义向量起点和终点（dx, dy）
x_start, y_start = 0, 0
dx, dy = 3, 4
dx1, dy1 = 4, 3
# 创建图形
plt.figure(figsize=(5, 5))

# 绘制向量
# 注意, 后面的 dx, dy 分别是以前面两个微基础的向量非坐标
plt.arrow(x_start, y_start, dx, dy,
          head_width=0.1, length_includes_head=True,
          color='blue', lw=2)
plt.arrow(dx, dy, dx1, dy1,
          head_width=0.1, length_includes_head=True,
          color='blue', lw=2, linestyle="-")
plt.text(x_start+dx, y_start+dy, f"({dx}, {dy})")
plt.text(x_start+dx + dx1, y_start+dy + dy1, f"({dx} + {dx1}, {dy} + {dy1})")

# 绘制向量
plt.arrow(x_start, y_start, dx1, dy1,
          head_width=0.1, length_includes_head=True,
          color='blue', lw=2)
plt.arrow(dx1, dy1, dx, dy,
          head_width=0.1, length_includes_head=True,
          color='blue', lw=2, linestyle="-")
plt.text(x_start+dx1, y_start+dy1, f"({dx1} + {dx}, {dy1} + {dy})")


# 设置坐标轴范围
# plt.xlim(-1, 10)
# plt.ylim(-1, 10)

# 设置坐标轴比例一致
plt.axis('equal')

# 添加网格和标签
plt.grid(True)
plt.xlabel('x')
plt.ylabel('y')
plt.title('向量的表示')

# 显示图形
plt.show()

向量的乘法

数乘向量是数量与向量的乘法运算, 一个数 m m m乘以一个向量 r r r, 结果是向量 m r mr mr, 以而为向量数乘为例, m = 3 , r = $2 , 1$ t m=3, r= $2,1$ ^t m=3,r= $2,1$ t, m r = $3 * 2 , 3 * 1$ t = $6 , 3$ t mr= $3 \* 2, 3 \* 1$ ^t= $6, 3$ ^t mr= $3*2,3*1$ t= $6,3$ t

向量与数据

机器学习中, 对一个对象或者事件的描述称为样本, 反映样本某方面的表现或者性质的事项称为特征或属性, 特征的取值称为特征值, 样本组成的集合称为数据集, 向量可以看做样本的特征数

矩阵

标量是一个数, 向量是标量的拓展是一组数, 矩阵是对向量的拓展, 看作一组向量, 矩阵是线性代数最有用的工具

矩阵的定义

A = $120 3 2 2 0.2 600 100 3 1 2 0.2 500 110 3 1 2 0.1 700 90 3 1 1 1 300$ A = \left $\\begin{matrix} 120 \& 3 \& 2 \& 2 \& 0.2 \& 600 \\\\ 100 \& 3 \& 1 \& 2 \& 0.2 \& 500 \\\\ 110 \& 3 \& 1 \& 2 \& 0.1 \& 700 \\\\ 90 \& 3 \& 1 \& 1 \& 1 \& 300 \\end{matrix}\\right$ A= 120100110903333211122210.20.20.11600500700300

这个矩阵由4行6列组成, 就是 4 × 6 4 \times 6 4×6的矩阵

由 m × n m \times n m×n个数 a i j a_{ij} aij, i = 1 , 2 , . . . , m i=1,2,...,m i=1,2,...,m, j = 1 , 2 , . . . , n j=1,2,...,n j=1,2,...,n排成的 m m m行 n n n列的数表, 称为 m m m行 n n n列矩阵
A = $a 11 a 12 \dots a 1 n a 21 a 22 \dots a 2 n ⋮ ⋮ a i j ⋮ a m 1 a m 2 \dots a m n$ A = \left $\\begin{matrix} a_{11} \& a_{12} \& \\cdots \& a_{1n} \\\\ a_{21} \& a_{22} \& \\cdots \& a_{2n} \\\\ \\vdots \& \\vdots \& a_{ij} \& \\vdots \\\\ a_{m1} \& a_{m2} \& \\cdots \& a_{mn} \\end{matrix}\\right$ A= a11a21⋮am1a12a22⋮am2⋯⋯aij⋯a1na2n⋮amn

记做 A = A m × n = ( a i j ) m × n A = A_{m \times n} = (a_{ij})_{m \times n} A=Am×n=(aij)m×n

矩阵和数据

矩阵表示关系

用来表示城市之间是否可以通行, 分别用 0 , 1 0, 1 0,1来表示, 1代表可以通行, 0代表不可以通行

通行关系	A	B	C	D
A		√ \surd √	√ \surd √
B	√ \surd √		√ \surd √
C	√ \surd √			√ \surd √
D		√ \surd √

A = $0 1 1 0 1 0 1 0 1 0 0 1 0 1 0 0$ A = \left $\\begin{matrix} 0 \& 1 \& 1 \& 0 \\\\ 1 \& 0 \& 1 \& 0 \\\\ 1 \& 0 \& 0 \& 1 \\\\ 0 \& 1 \& 0 \& 0 \\end{matrix} \\right$ A= 0110100111000010

矩阵表示直接信息

学生选修了 A , B , C , D A, B, C, D A,B,C,D四门课, 用矩阵表示

通行关系	A	B	C	D
1	80	75	75	78
2	98	70	85	84
3	90	75	90	90
4	88	70	82	80

A = $80 75 75 78 98 70 85 84 90 75 90 90 88 70 82 80$ A = \left $\\begin{matrix} 80 \& 75 \& 75 \& 78 \\\\ 98 \& 70 \& 85 \& 84 \\\\ 90 \& 75 \& 90 \& 90 \\\\ 88 \& 70 \& 82 \& 80 \\end{matrix} \\right$ A= 80989088757075707585908278849080

矩阵表示线性系统

描述参数, 变量和常量先行关系, 设方程组如下
{ a 11 x 1 + a 12 x 2 + . . . + a 1 n x n = b 1 a 21 x 1 + a 22 x 2 + . . . + a 2 n x n = b 2 ⋮ a m 1 x 1 + a m 2 x 2 + . . . + a m n x n = b 2 \begin{cases} a_{11}x_1 + a_{12}x_2 + ... + a_{1n}x_n=b_1 \\ a_{21}x_1 + a_{22}x_2 + ... + a_{2n}x_n=b_2 \\ \vdots \\ a_{m1}x_1 + a_{m2}x_2 + ... + a_{mn}x_n=b_2 \end{cases} ⎩ ⎨ ⎧a11x1+a12x2+...+a1nxn=b1a21x1+a22x2+...+a2nxn=b2⋮am1x1+am2x2+...+amnxn=b2

方程组左侧系数用 m × n m \times n m×n阶矩阵 A A A表示, 每行代表一个方程, 没列代表不同方程中未知数的系数. 方程组右侧用 m × 1 m \times 1 m×1阶矩阵 B B B表示, 每行代表方程右侧的值, 通常 A A A为系数矩阵, X X X为未知数矩阵, B B B为常数项矩阵, 记做 A X = B AX=B AX=B
A = $a 11 a 12 \dots a 1 n a 21 a 22 \dots a 2 n ⋮ ⋮ ⋮ a m 1 a m 2 \dots a m n$ A = \left $\\begin{matrix} a_{11} \& a_{12} \& \\cdots \& a_{1n} \\\\ a_{21} \& a_{22} \& \\cdots \& a_{2n} \\\\ \\vdots \& \\vdots \& \& \\vdots \\\\ a_{m1} \& a_{m2} \& \\cdots \& a_{mn} \\end{matrix} \\right$ A= a11a21⋮am1a12a22⋮am2⋯⋯⋯a1na2n⋮amn
X = $x 1 x 2 ⋮ x n$ X = \left $\\begin{matrix} x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n \\end{matrix} \\right$ X= x1x2⋮xn
B = $b 1 b 2 ⋮ b n$ B = \left $\\begin{matrix} b_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n \\end{matrix} \\right$ B= b1b2⋮bn

使用Numpy很容易求出 X X X的值

矩阵和向量的创建

NumPy是Python开源的数值计算拓展

矩阵的创建

NumPy采用matrix(矩阵)和array(数组表示矩阵, 主要区别如下

matrix 是 array 的分支, matrix 和 array 通用, 但大部分 Python程序中, array 更多, 因为更加灵活更快
array类型为numpy.ndarray, 是相同类型元素组成, 统称为矩阵

python 复制代码

import numpy as np

# 1. 基础矩阵创建
a = np.array([[1,2],[3,4]])
print("np.array:\n", a)  # 通用矩阵创建

b = np.zeros((3,3))
print("\nnp.zeros:\n", b)  # 初始化零矩阵

c = np.ones((2,3), dtype=int)
print("\nnp.ones:\n", c)  # 创建整型全1矩阵

d = np.eye(3)
print("\nnp.eye:\n", d)  # 创建单位矩阵

e = np.diag([1,2,3])
print("\nnp.diag:\n", e)  # 创建对角矩阵

# 2. 数值序列生成
f = np.arange(2,10,2).reshape(2,2)
print("\nnp.arange+reshape:\n", f)  # 生成等差序列矩阵

g = np.linspace(0,1,6).reshape(2,3)
print("\nnp.linspace:\n", g)  # 生成等间隔矩阵

# 3. 随机矩阵
h = np.random.rand(3,2)
print("\nnp.random.rand:\n", h)  # 生成[0,1)均匀分布矩阵

i = np.random.randn(2,3)
print("\nnp.random.randn:\n", i)  # 生成正态分布矩阵

j = np.random.randint(1,10,size=(3,3))
print("\nnp.random.randint:\n", j)  # 生成随机整数矩阵

# 4. 特殊构造方法
k = np.fromfunction(lambda i,j: i+j, (3,3))
print("\nnp.fromfunction:\n", k)  # 通过函数构造矩阵

l = np.tile([1,2], (2,3))
print("\nnp.tile:\n", l)  # 矩阵平铺复制

m = np.repeat([1,2], 3).reshape(2,3)
print("\nnp.repeat:\n", m)  # 元素重复扩展

# 5. 矩阵属性操作
n = np.array([[1,2,3],[4,5,6]], dtype=np.float32)
print("\n矩阵属性:")
print("shape:", n.shape)     # 形状
print("dtype:", n.dtype)     # 数据类型
print("ndim:", n.ndim)      # 维度
print("size:", n.size)       # 元素总数
print("itemsize:", n.itemsize)  # 单元素字节大小


"""
np.array:
 [[1 2]
 [3 4]]

np.zeros:
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

np.ones:
 [[1 1 1]
 [1 1 1]]

np.eye:
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

np.diag:
 [[1 0 0]
 [0 2 0]
 [0 0 3]]

np.arange+reshape:
 [[2 4]
 [6 8]]

np.linspace:
 [[0.  0.2 0.4]
 [0.6 0.8 1. ]]

np.random.rand:
 [[0.88342915 0.31164707]
 [0.149002   0.5399805 ]
 [0.42382287 0.85360373]]

np.random.randn:
 [[ 0.20843083 -1.4405944   1.2375411 ]
 [ 0.36852983  0.5106739  -0.54602658]]

np.random.randint:
 [[3 7 5]
 [8 2 1]
 [4 9 6]]

np.fromfunction:
 [[0. 1. 2.]
 [1. 2. 3.]
 [2. 3. 4.]]

np.tile:
 [[1 2 1 2 1 2]
 [1 2 1 2 1 2]]

np.repeat:
 [[1 1 1]
 [2 2 2]]

矩阵属性:
shape: (2, 3)
dtype: float32
ndim: 2
size: 6
itemsize: 4
"""