机器学习

最新推荐文章于 2023-09-04 12:28:46 发布

MMiL258

最新推荐文章于 2023-09-04 12:28:46 发布

阅读量98

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/MMiL258/article/details/115446244

版权

笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

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)