高等数学基础(向量矩阵及其创建和特殊的矩阵)_csdn高等数学基础向量矩阵
向量
向量是机器学习最底层的组成部分, 也是基础数据的表示形式, 线性代数通过将研究对象拓展到向量, 对多维数据进行统一研究, 而进化出的方法方便我们可以研究和解决真实世界中的问题
标量
标量也称为\"无向量\", 使用一个单独的数表示数值大小, 可以有正负之分, 可以是实数和负数, 一般用小写变量表示, 比如sss表示行走距离, kkk表示直线斜率, nnn表示元素数目, 这些都可以看做标量
向量
向量是为了表达和处理高维空间的问题, 为表示一个整体会用方括号扩起来
向量的定义
将nnn个有序的数排成一排称为nnn维向量, 将nnn个有次序的数排成一列, 称为nnn维列向量
如, 称为四维列向量
x=[3456]x = \\left[\\begin{matrix}3 & 4 & 5 & 6\\end{matrix}\\right]x=[3456]
称为四维行向量
x=[3456]x = \\left[\\begin{matrix}3 \\\\4 \\\\5 \\\\6\\end{matrix}\\right]x=3456
如果没有声明一般为列向量
定位向量的值
y=[3456]Ty=\\left[\\begin{matrix}3 & 4 & 5 & 6\\end{matrix}\\right] ^Ty=[3456]T, 向量yyy的第iii个分向量用yiy_iyi表示, 如y2y_2y2表示第二个分量, 值为444
向量的几何意义
向量既有大小又有方向, 将向量的分量看作坐标轴上的坐标, 以坐标原点为起点, 向量代表的点为重点, 可以形成一条有向线段, 有向线段的长度表示向量的大小, 箭头所指的方向表示向量的方向, 可以将任意一个位置做为起始点进行自由移动, 但一般将原点看作起始点.
import numpy as npimport matplotlib.pyplot as pltimport 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, 0dx, dy = 3, 4dx1, 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()
通常向量代表一组数, 是由使用者定义, 比如个人信息, 可以用user=[01817378789]user = \\left[\\begin{matrix}0 & 18 & 173 & 78789\\end{matrix}\\right]user=[01817378789], 分别代表性别, 年龄, 身高, 和名字
向量的运算
加法
向量加法的值等于两个向量的对应分量之和
以两个二维向量加法为例, 如r=[3,1]tr=[3,1]^tr=[3,1]t和s=[2,3]ts=[2,3]^ts=[2,3]t, r+s=[2+2,1+3]t=[5,4]tr+s=[2+2, 1+3]^t=[5,4]^tr+s=[2+2,1+3]t=[5,4]t
import numpy as npimport matplotlib.pyplot as pltimport 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, 0dx, dy = 3, 4dx1, 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()
向量的乘法
数乘向量是数量与向量的乘法运算, 一个数mmm乘以一个向量rrr, 结果是向量mrmrmr, 以而为向量数乘为例, m=3,r=[2,1]tm=3, r=[2,1]^tm=3,r=[2,1]t, mr=[3∗2,3∗1]t=[6,3]tmr=[3 * 2, 3 * 1]^t=[6, 3]^tmr=[3∗2,3∗1]t=[6,3]t
向量与数据
机器学习中, 对一个对象或者事件的描述称为样本, 反映样本某方面的表现或者性质的事项称为特征或属性, 特征的取值称为特征值, 样本组成的集合称为数据集, 向量可以看做样本的特征数
矩阵
标量是一个数, 向量是标量的拓展是一组数, 矩阵是对向量的拓展, 看作一组向量, 矩阵是线性代数最有用的工具
矩阵的定义
A=[1203220.26001003120.25001103120.1700903111300]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×64 \\times 64×6的矩阵
由m×nm \\times nm×n个数aija_{ij}aij, i=1,2,...,mi=1,2,...,mi=1,2,...,m, j=1,2,...,nj=1,2,...,nj=1,2,...,n排成的mmm行nnn列的数表, 称为mmm行nnn列矩阵
A=[a11a12⋯a1na21a22⋯a2n⋮⋮aij⋮am1am2⋯amn]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=Am×n=(aij)m×nA = A_{m \\times n} = (a_{ij})_{m \\times n}A=Am×n=(aij)m×n
矩阵和数据
矩阵表示关系
用来表示城市之间是否可以通行, 分别用0,10, 10,1来表示, 1代表可以通行, 0代表不可以通行
A=[0110101010010100]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,DA, B, C, DA,B,C,D四门课, 用矩阵表示
A=[80757578987085849075909088708280]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
矩阵表示线性系统
描述参数, 变量和常量先行关系, 设方程组如下
{a11x1+a12x2+...+a1nxn=b1a21x1+a22x2+...+a2nxn=b2⋮am1x1+am2x2+...+amnxn=b2\\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×nm \\times nm×n阶矩阵AAA表示, 每行代表一个方程, 没列代表不同方程中未知数的系数. 方程组右侧用m×1m \\times 1m×1阶矩阵BBB表示, 每行代表方程右侧的值, 通常AAA为系数矩阵, XXX为未知数矩阵, BBB为常数项矩阵, 记做AX=BAX=BAX=B
A=[a11a12⋯a1na21a22⋯a2n⋮⋮⋮am1am2⋯amn]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=[x1x2⋮xn]X = \\left[\\begin{matrix}x_1 \\\\x_2 \\\\\\vdots \\\\x_n\\end{matrix}\\right]X=x1x2⋮xn
B=[b1b2⋮bn]B = \\left[\\begin{matrix}b_1 \\\\b_2 \\\\\\vdots \\\\b_n\\end{matrix}\\right]B=b1b2⋮bn
使用Numpy很容易求出XXX的值
矩阵和向量的创建
NumPy是Python开源的数值计算拓展
矩阵的创建
NumPy采用matrix(矩阵)和array(数组表示矩阵, 主要区别如下
- matrix 是 array 的分支, matrix 和 array 通用, 但大部分 Python程序中, array 更多, 因为更加灵活更快
- array类型为numpy.ndarray, 是相同类型元素组成, 统称为矩阵
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: float32ndim: 2size: 6itemsize: 4\"\"\"
特殊的矩阵
具有一定规律的矩阵称为特殊的矩阵. 在机器学习中一些特殊类型的矩阵和向量有特别的用处
零矩阵
说明
元素全部为0的矩阵,称为零矩阵, 记作OOO
O=[000000000000]O= \\left[\\begin{matrix}0 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 \\end{matrix}\\right]O=000000000000表示3×43 \\times 43×4阶的零矩阵
代码实现
在Numpy
中, 可以通过np.zeros
函数来创建零矩阵
import numpy as npprint(\"np.zeros(10) :\", np.zeros(10))print(\"np.zeros((3, 4)) :\", np.zeros((3, 4)))print(\"np.array(np.zeros((3, 4))) :\", np.array(np.zeros((3, 4))))\"\"\"output:np.zeros(10) : [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]np.zeros((3, 4)) : [[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]]np.array(np.zeros((3, 4))) : [[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]] \"\"\"
方阵
说明
行列数相等的矩阵称为nnn阶方阵, 记作AnA_nAn
A4=[80757578987085849075909088708289]A_4 = \\left[\\begin{matrix} 80 & 75 & 75 & 78 \\\\ 98 & 70 & 85 & 84 \\\\ 90 & 75 & 90 & 90 \\\\ 88 & 70 & 82 & 89 \\end{matrix}\\right]A4=80989088757075707585908278849089表示四阶方阵
代码实现
import numpy as npprint(\"np.random.randint(1, 10, size=(5, 5)) :\", np.random.randint(1, 10, size=(5, 5)))\"\"\"output:np.random.randint(1, 10, size=(5, 5)) : [[6 5 6 3 1] [1 4 1 5 9] [6 6 2 1 1] [4 6 8 9 7] [6 5 3 2 7]] \"\"\"
单位矩阵
说明
主对角线为1, 其他位置都是0的矩阵称为单位矩阵, 通常记作EEE或者III
比如: E=[10⋯001⋯0⋮⋮⋮00⋯1]m×nE = \\left[\\begin{matrix} 1 & 0 & \\cdots & 0 \\\\ 0 & 1 & \\cdots & 0 \\\\ \\vdots & \\vdots & & \\vdots \\\\ 0 & 0 & \\cdots & 1\\end{matrix}\\right]_{m \\times n}E=10⋮001⋮0⋯⋯⋯00⋮1m×n
单位矩阵与矩阵的乘积满足: Am×n×Em×n=Am×n,Em×m×Am×n=Am×nA_{m \\times n} \\times E_{m \\times n} = A_{m \\times n}, E_{m \\times m} \\times A_{m \\times n} = A_{m \\times n}Am×n×Em×n=Am×n,Em×m×Am×n=Am×n单位矩阵在矩阵的乘法中具有特殊作用, 如同乘法中的1
代码实现
import numpy as npprint(\"np.eye(4): \\n\", np.eye(4))print(\"np.identity(4): \\n\", np.identity(4))\"\"\"output:np.eye(4): [[1. 0. 0. 0.] [0. 1. 0. 0.] [0. 0. 1. 0.] [0. 0. 0. 1.]]np.identity(4): [[1. 0. 0. 0.] [0. 1. 0. 0.] [0. 0. 1. 0.] [0. 0. 0. 1.]] \"\"\"
对角矩阵
说明
只在对角线上含有非零元素, 其他位置都是0的方阵, 比如
E=[a110⋯00a22⋯0⋮⋮⋮00⋯ann]n×nE = \\left[\\begin{matrix} a_{11} & 0 & \\cdots & 0 \\\\ 0 & a_{22} & \\cdots & 0 \\\\ \\vdots & \\vdots & & \\vdots \\\\ 0 & 0 & \\cdots & a_{nn}\\end{matrix}\\right]_{n \\times n}E=a110⋮00a22⋮0⋯⋯⋯00⋮annn×n
对角矩阵常用于矩阵分解
代码实现
import numpy as npprint(\"np.diag([1,2,3,4,5,6]): \\n\", np.diag([1,2,3,4,5,6]))\"\"\"output:np.diag([1,2,3,4,5,6]): [[1 0 0 0 0 0] [0 2 0 0 0 0] [0 0 3 0 0 0] [0 0 0 4 0 0] [0 0 0 0 5 0] [0 0 0 0 0 6]] \"\"\"# 从已有的矩阵创建对角矩阵arr = np.array([[1,2,3], [4,5,6], [7,8,9]])diag_arr = np.diag(arr)print(\"np.diag(np.diag(arr)): \\n\", np.diag(diag_arr))\"\"\"output:np.diag(np.diag(arr)): [[1 0 0] [0 5 0] [0 0 9]] \"\"\"
上三角和下三角矩阵
说明
主对角线非0, 主对角线上或者下为0的称为上三角或者下三角矩阵
上三角矩阵
A=[a11a12⋯a1n0a22⋯a2n⋮⋮⋮00⋯ann]n×nA = \\left[\\begin{matrix} a_{11} & a_{12} & \\cdots & a_{1n} \\\\ 0 & a_{22} & \\cdots & a_{2n} \\\\ \\vdots & \\vdots & & \\vdots \\\\ 0 & 0 & \\cdots & a_{nn}\\end{matrix}\\right]_{n \\times n}A=a110⋮0a12a22⋮0⋯⋯⋯a1na2n⋮annn×n
下三角矩阵
A=[a110⋯0a21a22⋯0⋮⋮⋮an1an2⋯ann]n×nA = \\left[\\begin{matrix} a_{11} & 0 & \\cdots & 0 \\\\ a_{21} & a_{22} & \\cdots & 0 \\\\ \\vdots & \\vdots & & \\vdots \\\\ a_{n1} & a_{n2} & \\cdots & a_{nn}\\end{matrix}\\right]_{n \\times n}A=a11a21⋮an10a22⋮an2⋯⋯⋯00⋮annn×n
代码实现
import numpy as nparr = np.array([[1,2,3], [4,5,6], [7,8,9]])print(\"上三角矩阵 保留对角线, np.triu(arr): \\n\", np.triu(arr, k=0))print(\"上三角矩阵 右偏移1, np.triu(arr): \\n\", np.triu(arr, k=1))print(\"下三角矩阵 保留对角线, np.triu(arr): \\n\", np.tril(arr, k=0))print(\"下三角矩阵 左偏移1, np.triu(arr): \\n\", np.tril(arr, k=-1))\"\"\"output:k代表对角线偏移量是否保留上三角矩阵 保留对角线, np.triu(arr): [[1 2 3] [0 5 6] [0 0 9]]上三角矩阵 不保留对角线, np.triu(arr): [[0 2 3] [0 0 6] [0 0 0]]下三角矩阵 保留对角线, np.triu(arr): [[1 0 0] [4 5 0] [7 8 9]]下三角矩阵 不保留对角线, np.triu(arr): [[1 2 0] [4 5 6] [7 8 9]] \"\"\"
对称矩阵
说明
满足aij=ajia_{ij}=a_{ji}aij=aji的方阵称为对称矩阵, 元素关于对角线对称
A=[123456223456333456444456555556666666]6×6A = \\left[\\begin{matrix}1 & 2 & 3 & 4 & 5 & 6 \\\\2 & 2 & 3 & 4 & 5 & 6 \\\\3 & 3 & 3 & 4 & 5 & 6 \\\\4 & 4 & 4 & 4 & 5 & 6 \\\\5 & 5 & 5 & 5 & 5 & 6 \\\\6 & 6 & 6 & 6 & 6 & 6 \\\\\\end{matrix}\\right]_{6 \\times 6}A=1234562234563334564444565555566666666×6
代码实现
import numpy as npA = np.random.rand(4, 4) # 生成一个随机 n x n 矩阵symmetric_matrix = A + A.T # 确保对称print(\"对称矩阵, A + A.T: \\n\", symmetric_matrix)print(\"是否对称:\", np.array_equal(symmetric_matrix, symmetric_matrix.T))\"\"\"output:对称矩阵, A + A.T: [[1.42988171 1.32752313 0.34052907 0.8294304 ] [1.32752313 1.94935488 0.8594118 0.37471058] [0.34052907 0.8594118 0.66978847 1.0584849 ] [0.8294304 0.37471058 1.0584849 0.02921428]]是否对称: True \"\"\"
同型矩阵
说明
列数相同的两个矩阵称为同型矩阵
A=[122233445566]2×6A = \\left[\\begin{matrix}1 & 2 \\\\2 & 2 \\\\3 & 3 \\\\4 & 4 \\\\5 & 5 \\\\6 & 6 \\\\\\end{matrix}\\right]_{2 \\times 6}A=1234562234562×6
B=[625243342566]2×6B = \\left[\\begin{matrix}6 & 2 \\\\5 & 2 \\\\4 & 3 \\\\3 & 4 \\\\2 & 5 \\\\6 & 6 \\\\\\end{matrix}\\right]_{2 \\times 6}B=6543262234562×6