python 标准化矩阵 python中矩阵

文章目录

• 一、Python矩阵运算

• 1、矩阵基本运算
• 2、矩阵乘法
• 3、矩阵转置
• 4、求方阵的迹
• 5、方阵的行列式计算方法
• 6、求逆矩阵 / 伴随矩阵

• 二、梯度下降法

• 一、用梯度下降法手工求解
• 二、在Excel里用牛顿法、或者梯度下降法求解

• 三、用代码线性回归问题求解

• 一、最小二乘法
• 二、梯度下降法

• 四、总结
• 五、参考资料

一、Python矩阵运算

1、矩阵基本运算

1.引入 numpy 库

import numpy as np

2.使用 mat 函数创建一个 2X3矩阵

a = np.mat([[1, 2, 3], [4, 5, 6]])
 
a

3.使用 shape 可以获取矩阵的大小

a.shape

4.使用下表读取矩阵中的元素

5.进行行列转换

a.transpose()

a.T

6

b=np.array([[1,2,3],[4,5,6]])
b

b.T

7.加减法

a+a

b+b

8.列表是不能这么尽兴加减

c=[[1,2,3],[4,5,6]]
c+c

2、矩阵乘法

1.使用二维数组创建两个矩阵 A 和 B。

A=np.array([[1,2,3],[4,5,6]])
B=A.T

A

B

2.先来一个矩阵的数乘，其实是矩阵的每一个元素乘以该数。

2*A

2*B

3.dot 函数用于矩阵乘法，对于二维数组，它计算的是矩阵乘积，对于一维数组，它计算的是内积。

A*B

np.dot(A,B)

np.dot(B,A)

再创建一个二维数组

C=np.array([[1,2],[1,3]])
C

我们验证一个矩阵乘法的

结合性：(AB)C=A(BC)。

np.dot(np.dot(A,B),C)

np.dot(A,np.dot(B,C))

接着看一下对加法的分配性：(A+B)C=AC+BC、C(A+B)=CA+CB。

D=B-1
D

np.dot(A,B+D)

np.dot(A,B)+np.dot(A,D)

数乘的结合性，也是一样的。

2*(np.dot(A,B))

np.dot(A,2*B)

np.dot(2*A,B)

np.dot(A,2*B)

接着我们用到一个新知识，使用 eye 创建一个单位矩阵。

I=np.eye(3)
I

一个矩阵 A 乘以一个单位矩阵，还是它本身。

np.dot(A,I)

3、矩阵转置

A

A.T

A.T.T

创建两个尺寸相同的矩阵（前面已经创建过了）。

B

D

验证矩阵转置的第二个性质：(A±B)’=A’±B’。

(B+D).T

B.T+D.T

验证矩阵转置的第三个性质：(KA)’=KA’

10*A.T

(10*A).T

验证矩阵转置的第四个性质：(A×B)’=B’×A’

np.dot(A,B).T

np.dot(A.T,B.T)

np.dot(B,T,A.T)

4、求方阵的迹

方阵的迹就是主对角元素之和。
创建一个方阵（行数等于列数的矩阵）。

E=np.array([[1,2,3],[4,5,6],[7,8,9]])
E

用 trace 计算方阵的迹。

np.trace(E)

再创建一个方阵 F。

F=E-2
F

验证一下方阵的迹等于方阵的转置的迹。

np.trace(E)

np.trace(E.T)

验证一下方阵的乘积的迹。

np.trace(np.dot(E,F))

np.trace(np.dot(F,E))

验证一下方阵的和的迹等于方阵的迹的和。

np.trace(E+F)

np.trace(E)+np.trace(F)

5、方阵的行列式计算方法

创建两个方阵（上面已经创建过了）。

E

F

使用 det 方法求得方阵 E 和方阵 F 的行列式。

np.linalg.det(E)

np.linalg.det(F)

C

np.linalg.det(C)

6、求逆矩阵 / 伴随矩阵

创建一个方阵。

A=np.array([[1,-2,1],[0,2,-1],[1,1,-2]])
A

使用 linalg.det 求得方阵的行列式。

A_abs=np.linalg.det(A)
A_abs

使用 linalg.inv 求得方阵 A 的逆矩阵。

B=np.linalg.inv(A)
B

接着我们利用公式

A_bansui=B*A_abs
A_bansui

#3 七、python 解多元一次方程

首先看一下我们要解的方程

a=[[1,2,1],[2,-1,3],[3,1,2]]
a=np.array(a)
a

常数项构成一个一维数组（向量）。

b=[7,7,18]
b=np.array(b)
b

使用linalg.solve 方法解方程，参数 a 指的是系数矩阵，参数 b 指的是常数项矩阵。

x=np.linalg.solve(a,b)
x

使用点乘的方法可以验证一下，系数乘以未知数可以得到常数项。

np.dot(a,x)

二、梯度下降法

什么是微分？

• 微分在数学中的定义：由函数B=f(A)，得到A、B两个数集，在A中当dx靠近自己时，函数在dx处的极限叫作函数在dx处的微分，微分的中心思想是无穷分割。

什么是梯度？

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

什么是梯度下降法？

• 梯度下降是迭代法的一种,可以用于求解最小二乘问题(线性和非线性都可以)。在求解机器学习算法的模型参数，即无约束优化问题时，梯度下降（Gradient Descent）是最常采用的方法之一，另一种常用的方法是最小二乘法。在求解损失函数的最小值时，可以通过梯度下降法来一步步的迭代求解，得到最小化的损失函数和模型参数值。反过来，如果我们需要求解损失函数的最大值，这时就需要用梯度上升法来迭代了。在机器学习中，基于基本的梯度下降法发展了两种梯度下降方法，分别为随机梯度下降法和批量梯度下降法。

一、用梯度下降法手工求解

任务要求

二、在Excel里用牛顿法、或者梯度下降法求解

任务要求
求解 z=2(x-1)^2+y2 的近似根

dz/dx=4*(x-1);

dz/dy=2*y;

△x=ηdz/dx;

△y=ηdz/dy;

这里迭代1000次

三、用代码线性回归问题求解

一、最小二乘法

import numpy as np
from scipy.optimize import leastsq
from sklearn import linear_model

#可以调用sklearn中的linear_model模块进行线性回归
import seaborn as sns

# 定义数据集的大小 即20个数据点
m = 20

# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，其值全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据

# 对应的y坐标
Y = np.array([3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,11, 13, 13, 16, 17, 18, 17, 19, 21]).reshape(m, 1)

#进行线性回归的求解
model = linear_model.LinearRegression()
model.fit(X1,Y) 
print("斜率=",model.coef_[0])
print("截距为=",model.intercept_)

# 根据数据画出对应的图像
def plot(X, Y, theta):
    ax = plt.subplot(111)  # 将画布分为1行1列，取第一个
    ax.scatter(X, Y, s=30, c="blue", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y =  model.intercept_+ model.coef_[0]*x
    ax.plot(x, y)
    plt.show()

plot(X1, Y, model.coef_[0])

二、梯度下降法

from numpy import *

# 定义数据集的大小 即20个数据点
m = 20

# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，其值全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据

# 对应的y坐标
Y = np.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
import matplotlib.pyplot as plt

#绘制出数据集
plt.scatter(X1,Y,color='red')
plt.show()

# 定义代价函数
#损失函数（loss function）或代价函数（cost function）是将随机事件或其有关随机变量的取值映射为非负实数以表示该随机事件的“风险”或“损失”的函数
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):
    #将[1,1]变为2行1列的形式
    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):
    ax = plt.subplot(111)  # 将画布分为1行1列，取第一个
    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)

四、总结

总的来说，两种方法的误差都相对较小，但是梯度下降所花时间较少。