机器学习（2）——逻辑回归

最新推荐文章于 2024-04-19 10:39:43 发布

Yuancccc

最新推荐文章于 2024-04-19 10:39:43 发布

阅读量638

点赞数 1

文章标签：逻辑回归机器学习

本文链接：https://blog.csdn.net/Yuancccc/article/details/85058222

版权

我们将建立一个逻辑回归模型来预测一个学生是否被大学录取。假设你是一个大学系的管理员，你想根据两次考试的结构来决定每个申请人的录取机会。你有以前申请人的历史数据，你可以用它作为逻辑回归的训练集。对于每一个培训的例子，你有两个考试的申请人的分数和录取决定。为了做到这一点，我们将建立一个分类模型，根据考试成绩估计入学概率。
一、可视化数据 visualizing the data

#数据分析三大件
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#从文件中导入数据
data = pd.read_csv('ex2data1.txt', names=['Exam 1', 'Exam 2', 'Admitted'])

#定义画图函数plot_data(X,y)
def plot_data(data):
    positive=data[data['Admitted']==1]
    negative=data[data['Admitted']==0]
    #将数据在画布上查看，直观看下数据的分布
    fig,ax=plt.subplots(figsize=(7,5))#figsize()指定画板的大小
    ax.scatter(positive['Exam 1'],positive['Exam 2'],s=50,c='r',marker='x',label='Admitted')#scatter()画出散点图
    ax.scatter(negative['Exam 1'],negative['Exam 2'],s=50,c='b',marker='o',label='Not Admitted')#s:标记大小。c：标记颜色。marker：标记样式。
    ax.legend()#添加图列就是右上角的点说明
    plt.xlabel('Exam 1 score')
    plt.ylabel('Exam 2 score')
    plt.show()
       
plot_data(data)

运行结果：
在这里插入图片描述
二、数据的处理
目标：建立分类器（求出三个参数theta1,theta2,theta3)
设定阈值，根据阈值判断录取结果。

要完成的模块：
1、sigmoid：映射到概率的函数
2、model：返回预测结果
3、cost：根据参数计算损失
4、gradient：计算每个参数的梯度方向
5、descent：进行参数更新
6、accuracy：计算精度

模块一　 sigmoid：映射到概率的函数

sigmoid函数　　　　 $g(z)=\frac{1}{1+e^{-z}}$

#定义sigmoid函数
def sigmoid(z):
    return 1/(1+np.exp(-z))

x1 = np.arange(-10, 10, 0.1)
plt.plot(x1, sigmoid(x1), c='r')
plt.show()

运行结果：
在这里插入图片描述
模块二　model：返回预测结果
模型函数：　　 $h_\theta=g(z)=\frac{1}{1+e^{-\theta^Tx}}$ 　
其中　　 $\theta_0+\theta_1x_1 +,...,+\theta_nx_n=\sum_{i=1}^n\theta_ix_i=\theta^Tx$

数据处理时需要对Ｘ矩阵添加一列１的原因：
在这里插入图片描述

  #定义预测函数
def model(X,theta):
    h=sigmoid(np.dot(X,theta.T))
    return h

#数据处理
data.insert(0,'ones',1)#添加一列值为1
orig_data=data.as_matrix()
cols=orig_data.shape[1]#1表示数据的列数，0表示数据的行数
X=orig_data[:,0:cols-1]
y=orig_data[:,cols-1:cols]

theta=np.zeros([1,3])#初始化参数

模块三　cost：根据参数计算损失
在这里插入图片描述

#定义损失函数
def cost(X,y,theta):
    left=np.multiply(-y,np.log(model(X,theta)))
    right=np.multiply(1-y,np.log(1-model(X,theta)))
    return np.mean(left-right)
print(cost(X,y,theta))

运行结果：0.69314718056

模块四　gradient：计算每个参数的梯度方向
在这里插入图片描述

 #计算梯度
def gradient(X,y,theta):
    grad=np.zeros(theta.shape)
    error=(model(X,theta)-y).ravel()
    for j in range(len(theta.ravel())):
        term=np.multiply(error,X[:,j])
        grad[0,j]=np.mean(term)
        
    return grad

模块五　descent：进行参数更新
比较三种梯度下降方式：
在这里插入图片描述
设定三种不同的停止策略：

STOP_ITER=0#根据设定的迭代次数停止
STOP_COST=1#根据损失值目标函数的变化，如果没有什么变化了就停止
STOP_GRAG=2#根据梯度，迭代中两次的梯度没什么变化，可以停止

def stopCriterion(type,value,threshold):
    #设定三种不同的停止策略
    if type==STOP_ITER:
        return value>threshold
    elif type==STOP_COST:
        return abs(value[-1]-value[-2])<threshold
    elif type==STOP_GRAD:
        return np.linalg.norm(value)<threshold

import numpy.random#随机模块
#洗牌
def shuffleData(data):
    np.random.shuffle(data)
    cols=data.shape[1]
    X=data[:,0:cols-1]
    y=data[:,cols-1:cols]
    return X,y

设定参数更新函数：

import time

def descent(data,theta,batchSize,stopType,thresh,alpha):
    #梯度下降求解
    init_time=time.time()
    i=0#迭代次数
    k=0#batch
    X,y=shuffleData(data)
    grad=np.zeros(theta.shape)#计算的梯度
    costs=[cost(X,y,theta)]#损失值
      
    while True:
        grad=gradient(X[k:k+batchSize],y[k:k+batchSize],theta)
        k+=batchSize#取batch数量个数据
        if k>=n:
            k=0
            X,y=shuffleData(data)#重新洗牌
        theta=theta-alpha*grad#参数更新
        costs.append(cost(X,y,theta))#计算新的损失
        i+=1
        
        if stopType == STOP_ITER:       value = i
        elif stopType == STOP_COST:     value = costs
        elif stopType == STOP_GRAD:     value = grad
        if stopCriterion(stopType, value, thresh): break

    return theta, i-1, costs, grad, time.time()-init_time

画出损失函数和迭代次数的图像：

def runExpe(data, theta, batchSize, stopType, thresh, alpha):
    #import pdb; pdb.set_trace();
    theta, iter, costs, grad, dur = descent(data, theta, batchSize, stopType, thresh, alpha)
    name = "Original" if (data[:,1]>2).sum() > 1 else "Scaled"
    name += " data - learning rate: {} - ".format(alpha)
    if batchSize==n:
        strDescType = "Gradient"#批量梯度下降
    elif batchSize==1:
        strDescType = "Stochastic"#随机梯度下降
    else:
        strDescType = "Mini-batch ({})".format(batchSize)#小批量梯度下降
    name += strDescType + " descent - Stop: "
    if stopType == STOP_ITER: strStop = "{} iterations".format(thresh)
    elif stopType == STOP_COST: strStop = "costs change < {}".format(thresh)
    else: strStop = "gradient norm < {}".format(thresh)
    name += strStop
    print ("***{}\nTheta: {} - Iter: {} - Last cost: {:03.2f} - Duration: {:03.2f}s".format(
        name, theta, iter, costs[-1], dur))
    fig, ax = plt.subplots(figsize=(12,4))
    ax.plot(np.arange(len(costs)), costs, 'r')
    ax.set_xlabel('Iterations')
    ax.set_ylabel('Cost')
    ax.set_title(name.upper() + ' - Error vs. Iteration')
    return theta

对比１：批量梯度下降方法中不同停止策略的区别
　（１）根据设定的迭代次数停止STOP_ITER=0

n=100
runExpe(orig_data,theta,n,STOP_ITER,thresh=5000,alpha=0.000001)

运行结果：

***Original data - learning rate: 1e-06 - Gradient descent - Stop: 5000 iterations
Theta: [[-0.00027127  0.00705232  0.00376711]] - Iter: 5000 - Last cost: 0.63 - Duration: 1.26s

在这里插入图片描述
（２）根据损失值停止STOP_COST=1
　　　设置阈值1E-6，差不多需要110000次迭代

runExpe(orig_data,theta,n,STOP_COST,thresh=0.000001,alpha=0.001)

运行结果：

***Original data - learning rate: 0.001 - Gradient descent - Stop: costs change < 1e-06
Theta: [[-5.13364014  0.04771429  0.04072397]] - Iter: 109901 - Last cost: 0.38 - Duration: 28.30s

在这里插入图片描述
（３）根据梯度变化停止 STOP_GRAG=2
设定阈值0.05，差不多需要迭代40000次

runExpe(orig_data,theta,n,STOP_GRAD,thresh=0.05,alpha=0.001)

运行结果：

***Original data - learning rate: 0.001 - Gradient descent - Stop: gradient norm < 0.05
Theta: [[-2.37033409  0.02721692  0.01899456]] - Iter: 40045 - Last cost: 0.49 - Duration: 9.90s

在这里插入图片描述
对比二：对比不同的梯度下降方法
（１）批量梯度下降方法如上
（２）随机梯度下降

runExpe(orig_data,theta,1,STOP_ITER,thresh=5000,alpha=0.001)

运行结果：

***Original data - learning rate: 0.001 - Stochastic descent - Stop: 5000 iterations
Theta: [[-0.36916674 -0.02367222 -0.02731772]] - Iter: 5000 - Last cost: 2.52 - Duration: 0.48s

在这里插入图片描述
有点爆炸，很不稳定，再来试试把学习率调小一些：

runExpe(orig_data,theta,1,STOP_ITER,thresh=15000,alpha=0.000002)

运行结果：

***Original data - learning rate: 2e-06 - Stochastic descent - Stop: 15000 iterations
Theta: [[-0.00202109  0.01001772  0.00096959]] - Iter: 15000 - Last cost: 0.63 - Duration: 1.33s

在这里插入图片描述
速度快，但是稳定性差，需要很小的学习率。
（３）小批量梯度下降Min-batch descent

runExpe(orig_data,theta,16,STOP_ITER,thresh=15000,alpha=0.001)

运行结果：

***Original data - learning rate: 0.001 - Mini-batch (16) descent - Stop: 15000 iterations
Theta: [[-1.03541165  0.02003969  0.00943366]] - Iter: 15000 - Last cost: 0.57 - Duration: 1.76s

在这里插入图片描述
浮动仍然比较大，我们来尝试下对数据进行标准化，将数据按其属性（按列进行）减去其均值，然后除以其方差。最后得到的结果是对每个属性、每列来说所有的数据都聚集在0附近，方差值为1。

from sklearn import preprocessing as pp

scaled_data=orig_data.copy()
scaled_data[:,1:3]=pp.scale(orig_data[:,1:3])

runExpe(scaled_data,theta,1,STOP_ITER,thresh=5000,alpha=0.001)

运行结果：

***Scaled data - learning rate: 0.001 - Stochastic descent - Stop: 5000 iterations
Theta: [[ 0.30841324  0.86494224  0.77388235]] - Iter: 5000 - Last cost: 0.38 - Duration: 0.63s

在这里插入图片描述
它好多了！原始数据，只能达到0.61，而我们得到了0.38个在这里！所以对数据做预处理是非常重要的。

增加迭代次数，更多的迭代次数会使损失下降的更多。

runExpe(scaled_data,theta,n,STOP_GRAD,thresh=0.05,alpha=0.001)

运行结果：

***Scaled data - learning rate: 0.001 - Gradient descent - Stop: gradient norm < 0.05
Theta: [[ 0.69713983  1.83198145  1.65469224]] - Iter: 21606 - Last cost: 0.26 - Duration: 5.83s

在这里插入图片描述

用处理过的数据，用较小的迭代次数就可以达到较好的效果，因此要首先对数据进行处理。

runExpe(scaled_data,theta,16,STOP_GRAD,thresh=0.002*2,alpha=0.001)

运行结果：

***Scaled data - learning rate: 0.001 - Mini-batch (16) descent - Stop: gradient norm < 0.004
Theta: [[ 1.02628476  2.53969347  2.32749294]] - Iter: 53226 - Last cost: 0.22 - Duration: 7.53s

在这里插入图片描述
小批量梯度下降对比其他方法，运行次数少，运行结果较好。
模块六　accuracy：计算精度

#设定阈值,设定0.5，预测概率大于等于0.5的值为1，小于0.5的值为0，来进行分类
def predict(X, theta):
    return [1 if x >= 0.5 else 0 for x in model(X, theta)]

scaled_X = scaled_data[:, :3]
y = scaled_data[:, 3]
predictions = predict(scaled_X, theta)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

Yuancccc

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
机器学习（2）——逻辑回归

我们将建立一个逻辑回归模型来预测一个学生是否被大学录取。假设你是一个大学系的管理员，你想根据两次考试的结构来决定每个申请人的录取机会。你有以前申请人的历史数据，你可以用它作为逻辑回归的训练集。对于每一个培训的例子，你有两个考试的申请人的分数和录取决定。为了做到这一点，我们将建立一个分类模型，根据考试成绩估计入学概率。一、可视化数据 visualizing the data#数据分析三大件im...
复制链接

扫一扫