本文侧重代码实现，不讨论原理。
github图床出了一点问题，就不插图了。
文章目录
距离计算
欧氏距离:d(x,y)=∑k=1N(xk−yk)2欧氏距离:d(x,y)=\sqrt{\sum_{k=1}^{N}(x_k-y_k)^2}欧氏距离:d(x,y)=k=1∑N(xk−yk)2曼哈顿距离:d(x,y)=∑k=1N∣xk−yk∣曼哈顿距离:d(x,y)=\sum_{k=1}^N|x_k-y_k|曼哈顿距离:d(x,y)=k=1∑N∣xk−yk∣切比雪夫距离:d(x,y)=max(∣xk−yk∣)切比雪夫距离:d(x,y)=\max(|x_k-y_k|)切比雪夫距离:d(x,y)=max(∣xk−yk∣)余弦距离:cosθ=x1x2+y1y2x12+x22y12+y22余弦距离:cos\theta=\frac{x_1x_2+y_1y_2}{\sqrt{x_1^2+x_2^2}\sqrt{y_1^2+y_2^2}}余弦距离:cosθ=x12+x22y12+y22x1x2+y1y2
import numpy as npdot1 = np.array([1,2])# 第一个点的坐标（1,2)dot2 = np.array([4,5])# 第二个点的坐标（4,5)d1 = np.sqrt(np.sum((dot1-dot2)**2))# 欧氏距离d2 = np.sum(np.abs(dot1-dot2))# 曼哈顿距离d3 = np.max(np.abs(dot1-dot2))# 切比雪夫距离d4 = np.dot(dot1,dot2)/ np.sqrt(np.dot(dot1,dot1)*np.dot(dot2,dot2))# 余弦距离
模型选择
留出法
将数据分为训练集和测试集，使用训练集生成模型，使用测试集检验模型准确率。
# 核心代码train_test_split(data,data_lable,test_size=0.6)
# 完整代码from sklearn.model_selection import train_test_splitimport numpy as npdata = np.array([10,21,23,53,63])# 需要划分的数据data_lable =[0,1,2,3,4]# 上述数据的标签"""训练集数据, 测试集数据, 训练集标签, 测试集标签 =train_test_split(数据列表,数据列表标签,test_size=训练集/总数)"""data_train, data_test, lable_train, lable_test = train_test_split(data,data_lable,test_size=0.6)
交叉验证法
相当于多次
train_test_split
操作。将数据集划分为k个大小相似的子集，每次选取其中一个子集作为测试集，其他数据作为训练集。如[10,20,30,40]，我们设k=4，则生成如下4种数据集：
训练集：[10,20,30]，测试集：[40]训练集：[10,20,40]，测试集：[30]训练集：[10,30,40]，测试集：[20]训练集：[20,30,40]，测试集：[10]
代码如下：
# 核心代码"""将data数组分成3折 : KFold(n_splits=3).split(data)train_index:训练集索引 使用data[train_index]获取训练集test_index:测试集索引 使用data[test_index]获取测试集"""for train_index, test_index in KFold(n_splits=3).split(data):...略...
# 完整代码import numpy as npfrom sklearn.model_selection import KFolddata = np.array([10,21,23,53,63,25])# 需要划分的数据for train_index, test_index in KFold(n_splits=3).split(data):print("————————————————————————————————")print("训练集索引:",train_index,"训练集:",data[train_index])print("测试集索引:",test_index,"测试集:",data[test_index])
# 输出————————————————————————————————训练集索引:[2345] 训练集:[23536325]测试集索引:[01] 测试集:[1021]————————————————————————————————训练集索引:[0145] 训练集:[10216325]测试集索引:[23] 测试集:[2353]————————————————————————————————训练集索引:[0123] 训练集:[10212353]测试集索引:[45] 测试集:[6325]
留一法
交叉验证的变种，每次只留一个数据作为测试集。例如有n个数需要被划分，则留一法就相当于k=n的交叉验证。
# 核心代码for train_index, test_index in LeaveOneOut().split(data):...略...
# 完整代码from sklearn.model_selection import LeaveOneOutimport numpy as npdata = np.array([10,20,30,40])for train_index, test_index in LeaveOneOut().split(data):print("————————————————————————————————")print("训练集索引:",train_index,"训练集:",data[train_index])print("测试集索引:",test_index,"测试集:",data[test_index])
# 输出————————————————————————————————训练集索引:[123] 训练集:[203040]测试集索引:[0] 测试集:[10]————————————————————————————————训练集索引:[023] 训练集:[103040]测试集索引:[1] 测试集:[20]————————————————————————————————训练集索引:[013] 训练集:[102040]测试集索引:[2] 测试集:[30]————————————————————————————————训练集索引:[012] 训练集:[102030]测试集索引:[3] 测试集:[40]
性能度量
均方误差MSE
MSE=1n∑i=1n(f(xi)−yi)2MSE = \frac{1}{n}\sum_{i=1}^{n}(f(x_i)-y_i)^2MSE=n1i=1∑n(f(xi)−yi)2
实现如下：
# 核心代码"""均方误差 = mean_squared_error(真值列表,预测值列表)"""result = mean_squared_error(y_true, y_pred)
import numpy as npfrom sklearn.metrics import mean_squared_errory_true = np.array([1,2,3,4,5,6])# 正确数据y_pred = np.array([0,2,2,4,5,7])# 预测数据result = mean_squared_error(y_true, y_pred)# result结果为0.5
均方根误差RMSE
RMSE=1n∑i=1n(f(xi)−yi)2RMSE = \sqrt{\frac{1}{n}\sum_{i=1}^{n}(f(x_i)-y_i)^2}RMSE=n1i=1∑n(f(xi)−yi)2
# 实现(MSE套一层根号即可)result = np.sqrt( mean_squared_error(y_true, y_pred))
平均绝对误差MAE
MAE=1n∑i=1m∣f(xi)−yi∣MAE = \frac{1}{n}\sum_{i=1}^{m}|f(x_i)-y_i|MAE=n1i=1∑m∣f(xi)−yi∣
实现起来非常简单，就是将MSE中的
mean_squared_error
替换成
mean_absolute_error
。
# 实现import numpy as npfrom sklearn.metrics import mean_absolute_erroy_true = np.array([1,2,3,4,5,6])# 正确数据y_pred = np.array([0,2,2,4,5,7])# 预测数据result = mean_absolute_error(y_true, y_pred)
准确率
预测对的 / 所有
acc=1n∑i=1n(f(xi)=yi)acc=\frac{1}{n}\sum_{i=1}^{n}(f(x_i)=y_i)acc=n1i=1∑n(f(xi)=yi)
# 核心代码"""准确率 = accuracy_score(正确数据列表,预测数据列表)"""result = accuracy_score(y_true,y_pred)
# 完整代码import numpy as npfrom sklearn.metrics import accuracy_scorey_true = np.array([1,2,3,4,5,6])# 正确y_pred = np.array([0,2,2,4,5,7])# 预测result = accuracy_score(y_true,y_pred)
混淆矩阵
真实情况\预测结果正例反例正例TP（真正例）FN（假反例）反例FP（假正例）TN（真反例）
- 查准率：预测为正中，预测正确的概率 P = T P T P + F P P=\frac{TP}{TP+FP} P=TP+FPTP
- 查全率：真实情况为正中，预测正确的概率 R = T P T P + F N R = \frac{TP}{TP+FN} R=TP+FNTP
- 准确率 A C C = T P + T N T P + F P + T N + F N ACC = \frac{TP+TN}{TP+FP+TN+FN} ACC=TP+FP+TN+FNTP+TN
通过生成真实数据与预测数据的混淆矩阵，可以更好的看出预测的情况。
# 核心代码"""混淆矩阵 = confusion_matrix(真实数据集,预测数据集,labels=标签集)此处的标签集不好理解，看下面的样例就懂了"""result = confusion_matrix(y_true,y_pred,labels=[0,1])
# 完整代码import numpy as npfrom sklearn.metrics import confusion_matrixy_pred = np.array([0,1,0,1])# 预测数据y_true = np.array([1,0,1,1])# 正确数据result = confusion_matrix(y_true,y_pred,labels=[0,1])
# 输出[[01][21]]
上述输出可以用如下表格来解释
此处假设0为正例，1为反例
真实情况\预测结果01001121
以上表格蕴含了以下信息：
真实情况预测结果预测次数结果000真正例TP = 0011假反例FN = 1，预测错误1次102假正例FP = 2，预测错误2次111真反例TN = 1，预测成功1次
查准率=TPTP+FP=00+2=0查准率 = \frac{TP}{TP+FP}=\frac{0}{0+2}=0查准率=TP+FPTP=0+20=0查全率=TPTP+FN=00+1=0查全率 = \frac{TP}{TP+FN}=\frac{0}{0+1}=0查全率=TP+FNTP=0+10=0准确率=TP+TNTP+FP+TN+FN=0+10+2+1+1=14准确率=\frac{TP+TN}{TP+FP+TN+FN}=\frac{0+1}{0+2+1+1} = \frac{1}{4}准确率=TP+FP+TN+FNTP+TN=0+2+1+10+1=41
实际上，sklearn也提供了直接计算查准率的函数
precision_score
# 查准率import numpy as npfrom sklearn.metrics import precision_scorey_pred = np.array([0,1,0,1])# 预测数据y_true = np.array([1,0,1,1])# 正确数据accu = precision_score(y_true,y_pred,average='macro')# accu结果为0.25
ROC曲线
真实情况\预测结果正例反例正例TP（真正例）FN（假反例）反例FP（假正例）TN（真反例）
ROC曲线X轴：fpr=FPFP+TN=真实情况中：反例预测错误的真实情况中：反例总和ROC曲线X轴：fpr=\frac{FP}{FP+TN}=\frac{真实情况中：反例预测错误的}{真实情况中：反例总和}ROC曲线X轴：fpr=FP+TNFP=真实情况中：反例总和真实情况中：反例预测错误的ROC曲线Y轴：tpr(查全率)=TPTP+FN=真实情况中：正例中预测正确的真实情况中：正例总和ROC曲线Y轴：tpr(查全率)=\frac{TP}{TP+FN}=\frac{真实情况中：正例中预测正确的}{真实情况中：正例总和}ROC曲线Y轴：tpr(查全率)=TP+FNTP=真实情况中：正例总和真实情况中：正例中预测正确的
在ROC曲线中，AUC（曲线下的面积）值越大，说明该模型性能越好。
# 核心代码"""x轴列表, y轴列表, _ = roc_curve(真实数据,预测数据)曲线下面积 = auc(x轴列表, y轴列表)"""fpr_x, tpr_y, _ = roc_curve(y_true, y_pred)# 生成ROC曲线的x、y值列表auc = auc(fpr_x, tpr_y)# 计算曲线下的面积
# 完整代码import numpy as npfrom sklearn.metrics import roc_curve, aucy_pred = np.array([0.1,0.8,0.2,0.5,0.5,0.7,0.3,0.1])# 预测数据y_true = np.array([0,1,0,1,1,1,0,1])# 正确数据fpr_x, tpr_y, _ = roc_curve(y_true, y_pred)# 生成ROC曲线的x、y值列表auc = auc(fpr_x, tpr_y)# 计算曲线下的面积# auc结果为0.8333333333333334
协方差Cov
Cov(X,Y)=∑i=1n(xi−x‾)(yi−y‾)n−1Cov(X,Y)=\frac{\sum_{i=1}^{n}(x_i-\overline{x})(y_i-\overline{y})}{n-1}Cov(X,Y)=n−1∑i=1n(xi−x)(yi−y)
通过一个实例来计算：
为方便计算，我们只定义两个点，每个点(样本)有两个特征：x与y
dot1=(1,3)dot2=(5,7)(n=2)dot_1 = (1,3)\\dot_2=(5,7)\\(n=2)
dot1=(1,3)dot2=(5,7)(n=2)
用两个变量空间x，y分别表示特征对应的向量 x = [ 1 5 ] , y = [ 3 7 ] x=\begin{bmatrix} 1\5 \end{bmatrix} , y=\begin{bmatrix} 3\7 \end{bmatrix} x=[15],y=[37]
计算特征的均值 x ‾ = 3 , y ‾ = 5 \overline{x}=3,\overline{y}=5 x=3,y=5
计算协方差 C o v ( x , x ) = ( 1 − 3 ) 2 + ( 5 − 3 ) 2 2 − 1 = 8 C o v ( x , y ) = ( 1 − 3 ) ( 3 − 5 ) + ( 5 − 3 ) ( 7 − 5 ) 2 − 1 = 8 C o v ( y , x ) = C o v ( x , y ) = 8 C o v ( y , y ) = ( 3 − 5 ) 2 + ( 7 − 5 ) 2 2 − 1 = 8 Cov(x,x) = \frac{(1-3)^2+(5-3)^2}{2-1}=8\ Cov(x,y) = \frac{(1-3)(3-5)+(5-3)(7-5)}{2-1}=8\ Cov(y,x)=Cov(x,y)=8\ Cov(y,y) = \frac{(3-5)^2+(7-5)^2}{2-1}=8 Cov(x,x)=2−1(1−3)2+(5−3)2=8Cov(x,y)=2−1(1−3)(3−5)+(5−3)(7−5)=8Cov(y,x)=Cov(x,y)=8Cov(y,y)=2−1(3−5)2+(7−5)2=8
生成协方差矩阵 C o v ( z ) = [ C o v ( x , x ) C o v ( x , y ) C o v ( y , x ) C o v ( y , y ) ] = [ 8 8 8 8 ] Cov(z)= \begin{bmatrix} Cov(x,x) & Cov(x,y)\ Cov(y,x) & Cov(y,y) \end{bmatrix} = \begin{bmatrix} 8 & 8\ 8 & 8 \end{bmatrix} Cov(z)=[Cov(x,x)Cov(y,x)Cov(x,y)Cov(y,y)]=[8888]
下面用代码实现上述过程：
import numpy as npx = np.array([1,5])y = np.array([3,7])z = np.stack([x,y])# z=[[1,5],[3,7]]result = np.cov(z)# 生成协方差矩阵
result的值[[8.8.][8.8.]]
意义：协方差用来描述X和Y的相关程度
值范围意义Cov( X , Y ) < 0X与Y负相关Cov( X , Y ) > 0X与Y正相关Cov( X , Y ) = 0X与Y不相关
Sklearn线性模型
线性回归
给一些点
(xi,yi)
，用线性回归找出一条线
y=wx+b
，该线能够最大程度的与点拟合。
通过这条回归线，我们能根据
xi
预测出
yi
的大概值。代码实现如下：
# 核心代码model = LinearRegression()# 定义线性模型model.fit(x, y)# 根据(x,y)点集生成线性模型x_test =[[4],[5],[6]]# 测试数据y_test = model.predict(x_test)# 模型预测结果
# 完整代码import numpy as npfrom sklearn.linear_model import LinearRegression# 准备自变量与因变量# 这部分不用看，只知道生成了(x,y)散点即可x = np.array([0,1,2,3,4])# 自变量xy =3* x +2# 因变量y: [ 2 5 8 11 14]x = x + np.random.rand(5)# 将点用随机数打乱x =[[i]for i in x]# 行变列，如[1,2,3]会变成[[1],[2],[3]]y =[[i]for i in y]# 行变列，这是sklearn包要求的格式# 建立线性模型model = LinearRegression()# 定义线性模型model.fit(x, y)# 根据(x,y)点集生成线性模型# 准备测试数据x_test =[[4],[5],[6]]# 打印预测结果y_test = model.predict(x_test)print(y_test)print("w值:", model.coef_)print("b截距值为:", model.intercept_)
# 输出[[12.79914287][15.74000827][18.68087368]]w值:[[2.9408654]]b截距值为:[1.03568125]
上述代码生成了以下线性模型
y=wx+b=2.9408654x+1.03568125y=wx+b=2.9408654x+1.03568125y=wx+b=2.9408654x+1.03568125
将测试数据x代入该公式即可得到预测值y。
后面的pytorch部分将会通过梯度下降的方法来生成线性模型。
逻辑回归
以鸢尾花数据集为例。与上述线性回归极其相似，因此不作过多解释。
# 完整代码from sklearn import datasetsfrom sklearn.linear_model import LogisticRegressionfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 获取数据集iris = datasets.load_iris()iris_x = iris.datairis_y = iris.target# 留出法划分数据集x_train, x_test, y_train, y_test = train_test_split(iris_x, iris_y, test_size=0.1)# 生成逻辑回归模型model = LogisticRegression()model.fit(x_train, y_train)# 检验模型y_pred = model.predict(x_test)accu = accuracy_score(y_test, y_pred)
Pytorch简介
偏导数计算
计算
y=(x+w)(w+1)y=(x+w)(w+1)y=(x+w)(w+1)对xxx的偏导数，公式可以分解为下图：
#mermaid-svg-hVivz7Xc8LqeDbUO {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-hVivz7Xc8LqeDbUO .error-icon{fill:#552222;}#mermaid-svg-hVivz7Xc8LqeDbUO .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-hVivz7Xc8LqeDbUO .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-hVivz7Xc8LqeDbUO .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-hVivz7Xc8LqeDbUO .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-hVivz7Xc8LqeDbUO .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-hVivz7Xc8LqeDbUO .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-hVivz7Xc8LqeDbUO .marker{fill:#333333;stroke:#333333;}#mermaid-svg-hVivz7Xc8LqeDbUO .marker.cross{stroke:#333333;}#mermaid-svg-hVivz7Xc8LqeDbUO svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-hVivz7Xc8LqeDbUO .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-hVivz7Xc8LqeDbUO .cluster-label text{fill:#333;}#mermaid-svg-hVivz7Xc8LqeDbUO .cluster-label span{color:#333;}#mermaid-svg-hVivz7Xc8LqeDbUO .label text,#mermaid-svg-hVivz7Xc8LqeDbUO span{fill:#333;color:#333;}#mermaid-svg-hVivz7Xc8LqeDbUO .node rect,#mermaid-svg-hVivz7Xc8LqeDbUO .node circle,#mermaid-svg-hVivz7Xc8LqeDbUO .node ellipse,#mermaid-svg-hVivz7Xc8LqeDbUO .node polygon,#mermaid-svg-hVivz7Xc8LqeDbUO .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-hVivz7Xc8LqeDbUO .node .label{text-align:center;}#mermaid-svg-hVivz7Xc8LqeDbUO .node.clickable{cursor:pointer;}#mermaid-svg-hVivz7Xc8LqeDbUO .arrowheadPath{fill:#333333;}#mermaid-svg-hVivz7Xc8LqeDbUO .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-hVivz7Xc8LqeDbUO .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-hVivz7Xc8LqeDbUO .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-hVivz7Xc8LqeDbUO .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-hVivz7Xc8LqeDbUO .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-hVivz7Xc8LqeDbUO .cluster text{fill:#333;}#mermaid-svg-hVivz7Xc8LqeDbUO .cluster span{color:#333;}#mermaid-svg-hVivz7Xc8LqeDbUO div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-hVivz7Xc8LqeDbUO :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}
1y*ab+xw+w
用pytorch构建上述公式，可以很容易的求出偏导数，代码如下：
import torch# 生成公式 y=(x+w)*(w+1)x = torch.tensor([2.0], requires_grad=True)# 求x的偏导数，必须使requires_grad=True,否则报错w = torch.tensor([1.0])a = torch.add(x, w)# a = x+wb = torch.add(w,1)# b = w+1y = torch.mul(a, b)# y = a*b# 反向传播，计算所有requires_grad=True张量(tensor)的导数y.backward()print(x.grad)# x的偏导数
# 结果tensor([2.])
多次求导
backward(retain_graph=True)
可以保留计算图，再调用一次
backward()
即可实现二阶求导。代码修改如下：
# 核心代码y.backward(retain_graph=True)# 计算保留图，用于二次求导print(x.grad)# x的一阶导y.backward()# 二次求导print(x.grad)# x的二阶导
# 完整代码import torch# 构建公式 y=(x+w)*(w+1)x = torch.tensor([2.0], requires_grad=True)# 求x的偏导数，必须使requires_grad=True,否则报错w = torch.tensor([1.0])a = torch.add(x, w)# a = x+wb = torch.add(w,1)# b = w+1y = torch.mul(a, b)# y = a*b# 反向传播，计算所有requires_grad=True的导数y.backward(retain_graph=True)# 计算保留图，用于二次求导print(x.grad)# x的一阶导y.backward()print(x.grad)# x的二阶导
非标量输出
使用
torch.cat()
函数我们可以将不同的函数结合到一起，实现下图计算：
#mermaid-svg-eCsndn90A4qvwq96 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-eCsndn90A4qvwq96 .error-icon{fill:#552222;}#mermaid-svg-eCsndn90A4qvwq96 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-eCsndn90A4qvwq96 .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-eCsndn90A4qvwq96 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-eCsndn90A4qvwq96 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-eCsndn90A4qvwq96 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-eCsndn90A4qvwq96 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-eCsndn90A4qvwq96 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-eCsndn90A4qvwq96 .marker.cross{stroke:#333333;}#mermaid-svg-eCsndn90A4qvwq96 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-eCsndn90A4qvwq96 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-eCsndn90A4qvwq96 .cluster-label text{fill:#333;}#mermaid-svg-eCsndn90A4qvwq96 .cluster-label span{color:#333;}#mermaid-svg-eCsndn90A4qvwq96 .label text,#mermaid-svg-eCsndn90A4qvwq96 span{fill:#333;color:#333;}#mermaid-svg-eCsndn90A4qvwq96 .node rect,#mermaid-svg-eCsndn90A4qvwq96 .node circle,#mermaid-svg-eCsndn90A4qvwq96 .node ellipse,#mermaid-svg-eCsndn90A4qvwq96 .node polygon,#mermaid-svg-eCsndn90A4qvwq96 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-eCsndn90A4qvwq96 .node .label{text-align:center;}#mermaid-svg-eCsndn90A4qvwq96 .node.clickable{cursor:pointer;}#mermaid-svg-eCsndn90A4qvwq96 .arrowheadPath{fill:#333333;}#mermaid-svg-eCsndn90A4qvwq96 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-eCsndn90A4qvwq96 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-eCsndn90A4qvwq96 .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-eCsndn90A4qvwq96 .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-eCsndn90A4qvwq96 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-eCsndn90A4qvwq96 .cluster text{fill:#333;}#mermaid-svg-eCsndn90A4qvwq96 .cluster span{color:#333;}#mermaid-svg-eCsndn90A4qvwq96 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-eCsndn90A4qvwq96 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}
y0=(x+w)(w+3)∂(y0)/∂w = 7∂loss/∂w = ∂(y0)/∂w * 1 + ∂(y1)/∂w * 2= 7 * 1 + 2 * 2 = 11y1=(x+w)+(w+3)∂(y1)/∂w = 2
代码实现如下
# 核心代码loss = torch.cat([y0, y1], dim=0)# dim=0代表横向拼接loss_w = torch.tensor([1.,2.])# 设置权重，y0为1，y1为2loss.backward(gradient=loss_w)# 反向传播
# 完整代码import torch# 构建两个公式w = torch.tensor([1.], requires_grad=True)x = torch.tensor([2.],)a = torch.add(w, x)b = torch.add(w,3)y0 = torch.mul(a, b)# y0 = (x+w)(w+3)y1 = torch.add(a, b)# y1 = (x+w)+(w+3)# 合并公式loss = torch.cat([y0, y1], dim=0)# dim=0代表横向拼接loss_w = torch.tensor([1.,2.])# 设置权重，y0为1，y1为2loss.backward(gradient=loss_w)# 反向传播print(w.grad)# w的偏导数
# 输出tensor([11.])
线性回归
问题：给定若干
(x,y)(x,y)(x,y)点集，找出一条直线y=wx+by=wx+by=wx+b，使所有点到直线的距离之和最小。
目标：找到合适的
www与bbb，使损失函数L=1N∑i=1N(wxi+b−ytrue)2L=\frac{1}{N}\sum_{i=1}^{N}(wx_i+b-y_{true})^2L=N1∑i=1N(wxi+b−ytrue)2 的值最小。
方法：我们需要对损失函数关于
www和bbb求导:∂L∂w\frac{\partial{L}}{\partial{w}}∂w∂L,∂L∂b\frac{\partial{L}}{\partial{b}}∂b∂L,然后使用公式wt+1=wt−μ∂L∂wbt+1=bt−μ∂L∂b(μ:学习率，梯度下降的跨度)w_{t+1}=w_t-\mu\frac{\partial{L}}{\partial{w}} \\ b_{t+1}=b_t-\mu\frac{\partial{L}}{\partial{b}} \\(\mu:学习率，梯度下降的跨度)wt+1=wt−μ∂w∂Lbt+1=bt−μ∂b∂L(μ:学习率，梯度下降的跨度)
不断调整
www与bbb的值，直到得到合适的线性模型。
import matplotlib.pyplot as pltimport torch# 准备自变量与因变量# 这部分不用看，只知道生成了(x,y)散点即可x = torch.rand(20,1)*10# [20*1]的0-1的随机数 * 10y =2* x +(5+ torch.randn(20,1))# y = 2x + 5# 学习率mu =0.05# 构建线性回归参数 y_pred = wx + bw = torch.tensor(5.0, requires_grad=True)# 初始化wb = torch.tensor(10.0, requires_grad=True)# 初始化b# 迭代训练1000次for i inrange(1000):"""向前传播，计算预测值 y_pred = wx + b"""wx = torch.mul(w, x)# wx = w * xy_pred = torch.add(wx, b)# y_pred = w * x + b# 计算MSE loss# 目的是为了使loss尽可能小loss =(0.5*(y - y_pred)**2).mean()# 反向传播,求b与w的偏导数loss.backward()# 更新参数# 此处等同于 w = w.sub(w,lr*w.grad)# 后面带下划线的都是in-place的,会将调用者改变w.data.sub_(mu * w.grad)# 调整w的值b.data.sub_(mu * b.grad)# 调整b的值# 更新参数后一定要清零梯度if i !=999:w.grad.zero_()b.grad.zero_()# 每隔50次循环输出一次图像if i %50==0:plt.scatter(x.data.numpy(), y.data.numpy())# 散点plt.plot(x.data.numpy(), y_pred.data.numpy())# 回归直线plt.show()
SVM
版权归原作者 阿腾木 所有， 如有侵权，请联系我们删除。