目录
Python矩阵基本运算
矩阵操作
引入库
创建一个 2X3矩阵并调用
a=np.mat([[1,2,3,],[4,5,6]])
a
获取矩阵的大小
a.shape
进行行列转换
a.T
二维数组代替矩阵来进行矩阵运算
b = np.array([[1, 2, 3], [4, 5, 6]])
矩阵加减法
a + b
a - b
python矩阵乘法
使用二维数组创建两个矩阵A和B
A=np.mat([[1,2,3],[4,5,6]])
B=np.mat([[1,4],[2,5],[3,6]])
矩阵的数乘
2 * A
计算
A*B
np.dot(A, B)
创建一个二维数组C
C=np.mat([[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)
创建一个单位矩阵
D = np.eye(2)
矩阵单位矩阵
一个矩阵乘以一个单位矩阵,还是它本身
np.dot(C, D)
python矩阵转置
矩阵转置的转置(A’)’=A
A = np.array([[1, 2, 3], [4, 5, 6]])
A.T.T
(A±B)’=A’±B’
创建两个矩阵
B = C.T
D = B - 1
验证
(B + D).T
B.T + D.T
(KA) ′ =KA ′
(2 * A).T
2 * A.T
(A×B) ′ =B′ ×A ′
np.dot(A, B).T
np.dot(B.T, A.T)
python求方阵的迹
方阵的迹是什么?方阵的迹就是主对角元素之和。下面来用numpy计算一下方阵的迹。
首先创建一个3阶方阵
E = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
计算方阵的迹
np.trace(E)
验证一下方阵的迹与方阵的转置的迹的关系
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)
方阵的行列式计算方法
创建两个方阵
E = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
F = np.array([[1, 2], [1, 3]])
求得方阵E和方阵F的行列式
np.linalg.det(E)
np.linalg.det(F)
求逆矩阵/伴随矩阵
创建
A = np.array([[1, -2, 1], [0, 2, -1], [1, 1, -2]])
求方阵的行列式
A_abs = np.linalg.det(A)
求方阵A的逆矩阵
B = np.linalg.inv(A)
求伴随矩阵
A_bansui = B * A_abs
解释微分、梯度的含义? 什么是梯度下降法?
梯度
梯度是一个向量,梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。计算时候,对每一维的方向求偏导。
微分
微分是指函数在某一点处(趋近于无穷小)的变化量,是一种变化的量。
梯度下降法
简单来说梯度下降法就是通过迭代找到目标函数的最小值,或者收敛到最小值。
手工求解
Excel中求解
设定
计算
反复更新
线性回归
最小二乘法
代码
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)
结果
梯度下降法
代码
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)
结果