文章目录
一、Python矩阵基本运算
1.1 Python中的矩阵基本操作
导入numpy包,用 mat()
函数创建一个2*3的矩阵 a
import numpy as np
a=np.mat([[1,2,3],[4,5,6]])
a
结果
用 a.shape
获取矩阵大小
用 a.T
转置该矩阵
用 a.transpose
行列转换
用二维数组 b 代替矩阵 a b=np.array([[1,2,1],[4,5,6]])
加法运算
1.2 Python中的矩阵乘法
创建二维数组矩阵
a=np.array([[1,2,1],[4,5,6]])
b=np.array([[1,2],[3,4],[5,6]])
用普通 *
符号进行矩阵数乘
2*a
2*b
用 dot()
行数进行矩阵相乘
np.dot(a,b)
np.dot(b,a)
使用三个矩阵验证:矩阵相乘结合律 (ab)c=a(bc)
a=np.array([[1,2,1],[4,5,6]])
b=np.array([[1,2],[3,4],[5,6]])
c=np.array([[1,2],[1,3]])
np.dot(np.dot(a,b),c)
#np.dot(a,np.dot(b,c))
用以上三个矩阵验证:矩阵加法分配律 (a+b)c=ac+bc 和 c(a+b)=ca+cb
a=np.array([[1,2,1],[4,5,6]])
b=np.array([[1,2],[3,4],[5,6]])
c=np.array([[1,2],[1,3]])
d=b-1
np.dot(a,b+d)
#np.dot(a,b)+np.dot(a,d)
矩阵的相乘和数乘结合
a=np.array([[1,2,1],[4,5,6]])
b=np.array([[1,2],[3,4],[5,6]])
2*(np.dot(a,b))
#np.dot(a,2*b)
#np.dot(2*a,b)
#np.dot(a,2*b)
用eye(n)函数创建单位矩阵,n为矩阵行列
I=np.eye(3)
I
验证单位矩阵性质
np.dot(a,I)
验证转置性质(A’)’=A
验证转置性质(A±B)’=A’±B’
验证转置性质(nA)’=nA’
验证转置性质(A×B)’=B’×A’
1.3 Python中求方阵的迹
新建一个方阵
E=np.array([[1,2,3],[4,5,6],[7,8,9]])
E
用 trace
计算方阵的迹
np.trace(E)
验证方阵的迹 = 方阵的转置的迹
验证交换方阵的乘积的迹相等,随便得另一个方阵F
验证方阵的和的迹 = 方阵的迹的和
1.4 Python方阵的行列式计算方法
用linalg.det()
函数求方阵 E 、方阵 F 的行列式运算结果
验证 linalg.det()
函数
1.5 Python求逆矩阵和伴随矩阵
新建一个矩阵A
用 linalg.det()
求得方阵的行列式
用 linalg.inv(A)
求A的逆矩阵
利用公式法计算结果
1.6 Python求多元一次方程
根据线性代数知识
未知数的系数排列成矩阵 a
常数项构成一维数组
用 linalg.solve(a,b)
方法即可解出方程组
二、梯度下降法基础
2.1 简介
微分
是指函数在某一点处(趋近于无穷小)的变化量,是一种变化的量。
梯度
梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。
梯度下降法
梯度下降法是一个一阶最优化算法。 要使用梯度下降法找到一个函数的局部极小值,必须向函数上当前点对应梯度(或者是近似梯度)的反方向的规定步长距离点进行迭代搜索
2.2 手动求解
例:求解以下函数的极小值点
2.3 用Excel求解
对z = 2(x - 1)^2 + y^2求解近似根
设置 xi、yi 的初始值为(2, 1)
公式如下
ðz/ðx=4 * (x - 1)
ðz/ðy=2 * y
Δx=ŋ * (ðz / ðx)
Δy=ŋ * (ðz / ðy)
z=2(x - 1)2 + y2
结果
三、Python梯度下降法求解线性回归
3.1 最小二乘法
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])
3.2 梯度下降法
import numpy as np
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)