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

1.在Jupyter中写下Python矩阵基本运算学习记录

1.1 python矩阵操作

1.1.1 首先打开jupyter，引入numpy

1.1.2 创建一个矩阵a并调用

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

1.1.3 使用 shape可以获得矩阵大小

1.1.4 使用下标读取矩阵中元素

1.1.5 进行行列转换

1.1.6 使用二维数组代替矩阵进行矩阵运算

1.1.7 矩阵加减法

1.1.8 加减失误案例

个人猜测没有添加arrary或者mat，导致程序认为只是一个正常的数组结合

1.1.9 成功案例

1.2 python矩阵乘法

1.2.1 使用二维数组创建两个矩阵A和B

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

1.2.2 矩阵数乘，见识矩阵每一个元素乘以该数

1.2.3 dot函数

矩阵要求如下

• 设A为m×p的矩阵，B为p×n的矩阵，那么称m*n的矩阵C为矩阵A与B的乘积
• 只有在第一个矩阵的列数C和第二个矩阵的行数R相同时才有意义

dot函数用于矩阵乘法，对于二维数组，它计算的是矩阵乘积，对于一维数组，它计算的是内积。注意交换矩阵的前后位置会导致不同的结果

1.2.4 创建一个二维数组C

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

1.2.5 验证矩阵乘法的结合性 (AB)C=A(BC)

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

合理

1.2.6 验证加法分配性 (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) #记得分步写

合理

1.2.7 数乘的结合性

主要对比以下三组代码的值

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

很合理

1.2.8 eye

np.eye(n)能够直接创建n阶单位矩阵

1.2.9 矩阵A乘以一个单位矩阵

np.dot(A,I)

很明显，仍然是本身

1.3 python矩阵转置

矩阵的转置很简单，就是将矩阵的行变为列，将列变为行.

1.3.1 (A’)’=A

顺便验证了一下A的转置的转置为本身

1.3.2 (A±B)’=A’±B’

创建两个矩阵

B=np.mat([[1,4],[2,5],[3,6]])
D=np.mat([[0,3],[1,4],[2,5]])

合理

1.3.3 (KA)’=KA’

1.3.4 (A×B)’= B’×A’

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

1.4 python求方阵的迹

方阵的迹是什么？方阵的迹就是主对角元素之和。下面来用numpy计算一下方阵的迹。
首先创建一个3阶方阵

1.4.1 trace计算方阵的迹

再创键一个方阵F

1.4.2 验证方阵的迹等于方阵的转置的迹

np.trace(E)
np.trace(E.T)

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

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

1.4.4 验证方阵的和的迹等于方阵的迹的和

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

1.5 python方阵的行列式计算方法

如何计算方阵的行列式，用到的是numpy模块的linalg.det方法。下面我们看看如何使用numpy计算矩阵的行列式.
首先要明白二阶矩阵与三阶矩阵的行列式计算方法
二阶

三阶

仍然是使用我们上次的E,F

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

C=np.mat([[1,2],[1,3]])
C
np.linalg.det(C)

1.6 python求逆矩阵/伴随矩阵

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

伴随矩阵定义：

第一步仍然是调用numpy包并创建一个矩阵A

import numpy as np
A=np.mat([[1,-2,1],[0,-2,1],[1,1,-2]])
A

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

利用上文中的det求值

A_abs=np.linalg.det(A)
A_abs

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

在此希望大家能够巩固一下公式

令B为A的逆矩阵

1.6.2 通过线性代数中的公式计算伴随矩阵

在numpy中呈现的具体步骤：
A的伴随矩阵即是A的行列式与逆矩阵相乘

1.7 python解多元一次方程

假如有这样一个多元一次方程

正常算是比较麻烦的，我们选择使用函数linalg.solve()
首先将系数弄成矩阵

将后面的值构成一维数组

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

计算出后将结果带入原方程，结果一致，计算正确

全过程：

2. 解释微分、梯度的含义？ 什么是梯度下降法？

梯度

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

微分

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

梯度下降法

简单来说梯度下降法就是通过迭代找到目标函数的最小值，或者收敛到最小值。

2.1 用梯度下降法手工求解

2.2 在Excel里用梯度下降法求解z=2(x-1)^2+y2 的近似根

首先初始化一下表格，设定学习力度

定一个初始点位

在梯度、位移向量、函数值后方分别设置函数

公式插好后按住一行往下拖

y的值已经超级小了，可近似看成 0 ，通过观察此时 xi与 y 的值可得其近似值为 (1, 0)

2.3 线性回归

2.3.1 最小二乘法

代码：

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)

2.3.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)

	最小二乘法	梯度下降法
斜率k	0.96992481	0.96992163
截距d	0.51578947	0.51583286

3 总结

本次实验，我尝试使用了jupyter中矩阵的基本语句以及做了多元一次方程，并且熟知了梯度下降法