目录

  • Python矩阵基本运算
  • Python矩阵操作
  • Python矩阵乘法
  • Python矩阵转置
  • Python求方阵的迹
  • Python方针的行列式计算方法
  • Python求逆矩阵/伴随矩阵
  • Python解多元一次方程
  • 微分、梯度的含义
  • 微分
  • 梯度
  • 梯度下降法
  • 梯度下降法求解回归方程的python代码
  • 参考引用


Python矩阵基本运算

Python矩阵操作

gpu python 矩阵 python处理矩阵运算_Python


创建矩阵与行列转换的功能函数,而在Python中也较多使用二维数组替代矩阵来进行运算

Python矩阵乘法

gpu python 矩阵 python处理矩阵运算_梯度下降法_02


gpu python 矩阵 python处理矩阵运算_Python_03


矩阵乘法的定律检验,要区分数乘与矩阵相乘的情况,后者将前后次序调转也会影响结果

Python矩阵转置

gpu python 矩阵 python处理矩阵运算_逆矩阵_04


gpu python 矩阵 python处理矩阵运算_逆矩阵_05


矩阵转置即为行变为列、列变为行,对于转置还有一些叠加定律值得注意

Python求方阵的迹

gpu python 矩阵 python处理矩阵运算_gpu python 矩阵_06


方阵的迹就是主对角元素之和,也只有方阵才有迹的概念,方阵之和的迹等于方阵之迹的和

Python方针的行列式计算方法

首先引入行列式的计算概念

gpu python 矩阵 python处理矩阵运算_Python_07


gpu python 矩阵 python处理矩阵运算_Python_08


手工计算比较困难,但在Python中只需要运用linalg.det()函数便可简便运算

gpu python 矩阵 python处理矩阵运算_gpu python 矩阵_09


在对e方阵求行列式时本机出现一定问题,不知为何显示的结果为0,而方阵f则没有问题

Python求逆矩阵/伴随矩阵

设A是数域上的一个n阶方阵,若在相同数域上存在另一个n阶矩阵B,使得: AB=BA=E。 则我们称B是A的逆矩阵,而A则被称为可逆矩阵。当矩阵A的行列式|A|不等于0时才存在可逆矩阵。

而伴随矩阵的定义为:

gpu python 矩阵 python处理矩阵运算_gpu python 矩阵_10

gpu python 矩阵 python处理矩阵运算_gpu python 矩阵_11

Python解多元一次方程

gpu python 矩阵 python处理矩阵运算_Python_12


使用Python求解多元一次方程的原理也是将多元方程组代入矩阵后求解,主要运用的方法还是换元

微分、梯度的含义

微分

由函数B=f(A),得到A、B两个数集,在A中当dx靠近自己时,函数在dx处的极限叫作函数在dx处的微分,微分的中心思想是无穷分割。通常把自变量x的增量 Δx称为自变量的微分,记作dx,即dx = Δx。于是函数y = f(x)的微分又可记作dy = f’(x)dx。函数因变量的微分与自变量的微分之商等于该函数的导数。因此,导数也叫做微商。
几何意义:当Δx很小时,切线纵坐标的增量。

梯度

梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。

梯度下降法

在机器学习算法中,对于很多监督学习模型,需要对原始的模型构建损失函数,接下来便是通过优化算法对损失函数进行优化,以便寻找到最优的参数。在求解机器学习参数的优化算法中,使用较多的是基于梯度下降的优化算法(Gradient Descent, GD)。

梯度下降法求解回归方程的python代码

gpu python 矩阵 python处理矩阵运算_Python_13


为上图的点用梯度下降法求解拟合直线,具体代码如下

from numpy import *

# 数据集大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量,也就是x0,全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量,也就是x1,从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组,其实就是样本数据
# 对应的y坐标
Y = array([
    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
    11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1)
# 学习率
alpha = 0.01


# 定义代价函数
def cost_function(theta, X, Y):
    diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘,就需要用到dot()
    return (1/(2*m)) * dot(diff.transpose(), diff)


# 定义代价函数对应的梯度函数
def gradient_function(theta, X, Y):
    diff = dot(X, theta) - Y
    return (1/m) * dot(X.transpose(), diff)


# 梯度下降迭代
def gradient_descent(X, Y, alpha):
    theta = array([1, 1]).reshape(2, 1)
    gradient = gradient_function(theta, X, Y)
    while not all(abs(gradient) <= 1e-5):
        theta = theta - alpha * gradient
        gradient = gradient_function(theta, X, Y)
    return theta


optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])


# 根据数据画出对应的图像
def plot(X, Y, theta):
    import matplotlib.pyplot as plt
    ax = plt.subplot(111)  # 这是我改的
    ax.scatter(X, Y, s=30, c="red", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y = theta[0] + theta[1]*x
    ax.plot(x, y)
    plt.show()


plot(X1, Y, optimal)

gpu python 矩阵 python处理矩阵运算_Python_14


拟合结果如上