十大机器学习算法（二）

最新推荐文章于 2024-09-09 16:02:23 发布

Mooan

最新推荐文章于 2024-09-09 16:02:23 发布

阅读量2.5k

点赞数

分类专栏：建模文章标签：逻辑回归分类算法

本文链接：https://blog.csdn.net/m0_61260697/article/details/123852016

版权

建模专栏收录该内容

3 篇文章 1 订阅

订阅专栏

三、最近邻居/k-近邻算法

Python—KNN分类算法（详解） - 知乎 (zhihu.com)

KNN原理非常简单，这篇文章写的非常全面，还有算法的特点和对比，一目了然。这篇的代码用的是Python sklearn。（第二段代码有一点小错误，from munpy import *改成import numpy as np）

(1条消息) KNN(K-Nearest Neighbor)算法Matlab实现_SoldierHans的博客-CSDN博客_knn matlab

这一篇使用的是matlab代码。但是matlab代码有点长，而且是循环嵌套算法，效率可能低些，推荐Python实现。

四、逻辑回归算法

1.基本原理

逻辑回归是一种常见的处理二分类问题的线性模型。本质上就是将线性回归模型的结果通过激活函数映射到[0,1]之间，形成分类。激活函数采用的是logistics函数：

$p(y=1|x)=\sigma (\omega ^Tx)=\frac{1}{1+e^{-\omega ^Tx}}$

其中w的确定通过优化函数——梯度下降算法得到：

损失函数采用的是交叉熵函数：

得到以下图像，>0.5取类别1，<0.5取类别0：

2.求解过程

（1）生成数据集——训练集、验证集和测试集（不过大多时候验证集和训练集是一个数据集）

（2）定义激活函数、损失函数和优化函数

（3）训练模型

（4）预测类别

以下是[2]通过torch搭建的logistics模型，代码的搭建过程就是模型的训练过程

import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import time
import sys

#生成数据集
num_inputs =1
num_examples = 1000
#生成features和labels
features1 = torch.randn(num_examples, num_inputs,
                      dtype=torch.float32)-2
features2=torch.randn(num_examples, num_inputs,
                      dtype=torch.float32)+2
features=torch.cat([features1,features2],dim=0)
labels1 = torch.ones_like(features1)
labels2=torch.zeros_like(features2)
labels=torch.cat([labels1,labels2],dim=0) 
print(labels.shape)
plt.scatter(features.numpy(), labels.numpy(), 1);

#读取数据
import torch.utils.data as Data
batch_size = 10
# 将训练数据的特征和标签组合
dataset = Data.TensorDataset(features, labels)

# 把 dataset 放入 DataLoader，专门放置样本数据和标签
# 从DataLoader中每次抽出batch size个样本
data_iter = Data.DataLoader(
    dataset=dataset,      # torch TensorDataset format
    batch_size=batch_size,      # mini batch size
    shuffle=True,               # 要不要打乱数据 (打乱比较好)
    num_workers=2,              # 多线程来读数据
)

#定义激活函数
def logreg(X, w, b):  
    return 1.0/(1+torch.exp(-X*w-b))

#定义交叉熵函数（损失函数）
def crossentropy_loss(y_hat, y): 
    return -torch.nan_to_num(y*torch.log(y_hat)+(1-y)*torch.log(1-y_hat))

#定义优化模型  sgd([w, b], 学习率, 批量大小)
def sgd(params, lr, batch_size):  
    for param in params:
        param.data -= lr * param.grad / batch_size # 注意这里更改param时用的param.data

# 3参数初始化
# 我们将权初始化成均值为0、标准差为0.01的正态随机数，偏差则初始化成0
# 也就是我们要迭代更新的参数
w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, 1)), dtype=torch.float32)
b = torch.zeros(1, dtype=torch.float32)


# 训练模型
# 之后模型训练中，需要对这些参数求梯度来迭代参数的值，所以requires_grad=True
w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True) 
# 输出层不是标量的两种解决办法
lr = 0.05 # 学习率
num_epochs = 3 # 迭代周期个数，一个迭代周期中将遍历所有样本
net = logreg # 简化了函数的名称
loss = crossentropy_loss
for epoch in range(num_epochs):  # 训练模型一共需要num_epochs个迭代周期
    # 在每一个迭代周期中，会使用训练数据集中所有样本一次（假设样本数能够被批量大小整除）。X
    # 和y分别是小批量样本的特征和标签
    for X, y in data_iter:
        l=loss(net(X,w,b),y).sum()
        l.backward()  # 小批量的损失对模型参数求梯度
        sgd([w, b], lr, batch_size)  # 使用小批量随机梯度下降迭代模型参数[w, b]
        
        # 一般在反向传播之前把梯度清零
        w.grad.data.zero_()
        b.grad.data.zero_()
    train_l = loss(net(features, w, b), labels)
    print('epoch %d, loss %f' % (epoch + 1, train_l.mean().item()))

plt.scatter(features.numpy(),net(features, w, b).detach().numpy(), 1);

3.算法实现

（1） Python sklearn库可以非常方便的调用logistics回归模型，不用再写这么长的代码自己定义模型了。

#X为需要导入的数据集，y为对应的标签
from sklearn.linear_model import LogisticRegression as lr
lr_model_1 = lr()              #调用逻辑回归
lr_model_1_y = lr_model_1.fit(X, y)                 #用样本数据训练逻辑回归模型
y_proba_model_1 = lr_model_1_y.predict_proba(X)     #用训练好的模型预测
y_proba_model_1

注意学习其中的lr()函数的参数，参数说明太长了大家自行查阅。

LogisticRegression( solver='lbfgs', penalty='l2', class_weight=None, tol=0.0001,\\
 random_state=None, C=1.0, fit_intercept=True, intercept_scaling=1, dual=False, \\
 max_iter=100, multi_class='auto', verbose=0, warm_start=False, \\
n_jobs=None, l1_ratio=None)

（2）matlab实现