机械学习数学基础之Python矩阵运算

Python矩阵基本运算

Python矩阵操作

1. 创建一个2×3的矩阵

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

2. 获取矩阵大小

a.shape

3. 转置矩阵

a.T

4. 进行行列转换

a.transpose

5. 使用二维数组代替矩阵

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

6. 矩阵、数组加减法
   

矩阵乘法

矩阵的转置

1. 验证 (A’)’=A

A.T.T

2. 验证转置第二性质 (A±B)’=A’±b’

(B+D).T
B.T+D.T

3. 验证矩阵转置第三性质 (KA)’=KA’

10*A.T
(10*A.T)

4. 验证矩阵转置第四性质 (A×B)’=B’×A’

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

Python求方阵的迹

1. 创建方阵E

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

2. 计算方阵的迹

np.trace(E)

3. 验证方阵的迹等于转置的迹

np.trace(E.T)

4. 创建方阵F

F=E-2
F

5. 方阵乘积的迹

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

6. 验证方阵的和的迹等于方阵的迹的和

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

Python方阵行列式计算方法

1. 创建矩阵E、F

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

2. 求其行列式

np.linalg.det(E)
np.linalg.det(F)

Python求逆矩阵/伴随矩阵

1. 创建方阵A

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

2. 求A行列式

A_abs=np.linalg.det(A)
A_abs

3. 求A逆矩阵

B=np.linalg.inv(A)
B

4. A-1 = A"/|A| ==> A"=A-1|A|

A_abs=np.linalg.det(A)
B=np.linalg.inv(A)
A_bansui=B*A_abs
A_bansui

Python解多元一次方程

1. 创建方程组

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

2. 解方程

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

3. 验证解

np.dot(a,x)

梯度下降法

1. 微分
   是指函数在某一点处（趋近于无穷小）的变化量，是一种变化的量。

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

3. 梯度下降法
   梯度下降法是一个一阶最优化算法。 要使用梯度下降法找到一个函数的局部极小值，必须向函数上当前点对应梯度（或者是近似梯度）的反方向的规定步长距离点进行迭代搜索

4. 梯度下降法的手工求解
   求解以下函数的极小值点
   
   

5. Excle中的梯度下降法
   求解以下方程近似根
   z = 2(x - 1)2 + y2
   表格初始设置如下
   
   设置 xi yi 的初始值为 (2, 1)，i 为 0 且逐行递增
   
   函数设置
   
   
   第三步为第一次迭代，用同样的方式继续迭代
   当迭代到1000次的时候
   
   yi 的值已经极小了，可近似看成 0 ，通过观察此时 xi 与 yi 的值可得其近似值为 (1, 0)

Python中实现梯度下降法求回归方程

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])

2. 梯度下降法

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)

结果