机器学习—LogisticRegression

本是古典何须时尚 2022-10-06 12:46 156阅读 0赞

数据集是从别人那里下载的，代码二也是别人写的，但发现一点小瑕疵改动了下，代码一是本人写的，思想是根据吴恩达机器学习学习来的，强烈推荐，第一次学习，不正确请各位大佬指出。

## 1.数据集 ##

-0.017612	14.053064	0
    -1.395634	4.662541	1
    -0.752157	6.538620	0
    -1.322371	7.152853	0
    0.423363	11.054677	0
    0.406704	7.067335	1
    0.667394	12.741452	0
    -2.460150	6.866805	1
    0.569411	9.548755	0
    -0.026632	10.427743	0
    0.850433	6.920334	1
    1.347183	13.175500	0
    1.176813	3.167020	1
    -1.781871	9.097953	0
    -0.566606	5.749003	1
    0.931635	1.589505	1
    -0.024205	6.151823	1
    -0.036453	2.690988	1
    -0.196949	0.444165	1
    1.014459	5.754399	1
    1.985298	3.230619	1
    -1.693453	-0.557540	1
    -0.576525	11.778922	0
    -0.346811	-1.678730	1
    -2.124484	2.672471	1
    1.217916	9.597015	0
    -0.733928	9.098687	0
    -3.642001	-1.618087	1
    0.315985	3.523953	1
    1.416614	9.619232	0
    -0.386323	3.989286	1
    0.556921	8.294984	1
    1.224863	11.587360	0
    -1.347803	-2.406051	1
    1.196604	4.951851	1
    0.275221	9.543647	0
    0.470575	9.332488	0
    -1.889567	9.542662	0
    -1.527893	12.150579	0
    -1.185247	11.309318	0
    -0.445678	3.297303	1
    1.042222	6.105155	1
    -0.618787	10.320986	0
    1.152083	0.548467	1
    0.828534	2.676045	1
    -1.237728	10.549033	0
    -0.683565	-2.166125	1
    0.229456	5.921938	1
    -0.959885	11.555336	0
    0.492911	10.993324	0
    0.184992	8.721488	0
    -0.355715	10.325976	0
    -0.397822	8.058397	0
    0.824839	13.730343	0
    1.507278	5.027866	1
    0.099671	6.835839	1
    -0.344008	10.717485	0
    1.785928	7.718645	1
    -0.918801	11.560217	0
    -0.364009	4.747300	1
    -0.841722	4.119083	1
    0.490426	1.960539	1
    -0.007194	9.075792	0
    0.356107	12.447863	0
    0.342578	12.281162	0
    -0.810823	-1.466018	1
    2.530777	6.476801	1
    1.296683	11.607559	0
    0.475487	12.040035	0
    -0.783277	11.009725	0
    0.074798	11.023650	0
    -1.337472	0.468339	1
    -0.102781	13.763651	0
    -0.147324	2.874846	1
    0.518389	9.887035	0
    1.015399	7.571882	0
    -1.658086	-0.027255	1
    1.319944	2.171228	1
    2.056216	5.019981	1
    -0.851633	4.375691	1
    -1.510047	6.061992	0
    -1.076637	-3.181888	1
    1.821096	10.283990	0
    3.010150	8.401766	1
    -1.099458	1.688274	1
    -0.834872	-1.733869	1
    -0.846637	3.849075	1
    1.400102	12.628781	0
    1.752842	5.468166	1
    0.078557	0.059736	1
    0.089392	-0.715300	1
    1.825662	12.693808	0
    0.197445	9.744638	0
    0.126117	0.922311	1
    -0.679797	1.220530	1
    0.677983	2.556666	1
    0.761349	10.693862	0
    -2.168791	0.143632	1
    1.388610	9.341997	0
    0.317029	14.739025	0

## 2.代码-1 最普通的numpy数学方式解决 ##

这里记得把上面的数据集的空格换成 , 哦

import numpy as np
    import matplotlib.pyplot as plt
    
    data=np.genfromtxt('csv/LogisticData.csv', delimiter=',')
    x_data=data[:,0]
    y_data=data[:,1]
    label_data=data[:,2]
    plt.scatter(x_data,y_data)
    plt.show()
    # 学习率learning rate（步长）、截距、斜率、最大迭代次数
    lr=0.0001
    b=1
    k1=0
    k2=0
    epochs=100000
    
    def sigmoid(z):
        return 1/(1 + np.exp(-z))
    
    # 2. 代价函数（最小二乘法）:该函数只返回一个值
    def compute_error(b,k1,k2,x_data,y_data,label_data):
        totalError=0
        for i in range(0,len(x_data)):
            totalError+=-(label_data[i]*np.log(sigmoid(x_data[i]*k1+y_data[i]*k2+b))+
                          (1-label_data[i])*np.log(1-sigmoid(x_data[i]*k1+y_data[i]*k2+b)))
        return totalError/float(len(x_data))
    
    
    # 3. 梯度降低算法函数
    def gradient_descent_runner(x_data,y_data,label_data,b,k1,k2,lr,epochs):
        # 总数据量
        m=float(len(x_data))
        # 迭代epochs次
        for i in range(epochs):
            b_grad=0
            k1_grad=0
            k2_grad=0
            for j in range(0,len(x_data)):
                h= sigmoid(x_data[j]*k1+y_data[j]*k2+b)
                b_grad+=(1/m)*(h-label_data[j])
                k1_grad+=(1/m)*(h-label_data[j])*x_data[j]
                k2_grad+=(1/m)*(h-label_data[j])*y_data[j]
            # 更新b和k
            b= b-(lr*b_grad)
            k1= k1-(lr*k1_grad)
            k2 =k2 - (lr * k2_grad)
            # 每迭代500次，输出一次图像和数据
            if i%20000 ==0:
                print('epochs：',i)
                print('b:',b,'k1:',k1,'k2:',k2)
                print('error:',compute_error(b,k1,k2,x_data,y_data,label_data),)
                plt.scatter(x_data,y_data)
                plt.plot(x_data,(-k1*x_data-b)/(float)(k2),'r')
                plt.show()
        return b,k1
    gradient_descent_runner(x_data,y_data,label_data,b,k1,k2,lr,epochs)

## 3.代码-2 用矩阵的方法解决 ##

from numpy import *
    filename='csv/LogisticData2.txt' #文件目录
    def loadDataSet():   #读取数据（这里只有两个特征）
        dataMat = []
        labelMat = []
        fr = open(filename)
        for line in fr.readlines():
            lineArr = line.strip().split()
            dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])   #前面的1，表示方程的常量。比如两个特征X1,X2，共需要三个参数，W1+W2*X1+W3*X2
            labelMat.append(int(lineArr[2]))
        return dataMat,labelMat
    
    def sigmoid(inX):  #sigmoid函数
        return 1.0/(1+exp(-inX))
    
    def gradAscent(dataMat, labelMat): #梯度上升求最优参数
        dataMatrix=mat(dataMat) #将读取的数据转换为矩阵
        # print(dataMatrix)
        classLabels=mat(labelMat).transpose() #将读取的数据转换为矩阵
        # print(classLabels)
        m,n = shape(dataMatrix)
        # print(m)
        # print(n)
        alpha = 0.001  #设置梯度的阀值，该值越大梯度上升幅度越大
        maxCycles = 10000 #设置迭代的次数，一般看实际数据进行设定，有些可能200次就够了
        weights = ones((n,1)) #设置初始的参数，并都赋默认值为1。注意这里权重以矩阵形式表示三个参数。
        # print(weights)
        for k in range(maxCycles):
            h = sigmoid(dataMatrix*weights)
            error = (classLabels - h)     #求导后差值
            weights = weights + alpha * dataMatrix.transpose()* error *(1/m) #迭代更新权重 #transpose = T
        return weights
    
    
    def plotBestFit(weights):  #画出最终分类的图
        import matplotlib.pyplot as plt
        dataMat,labelMat=loadDataSet()
        dataArr = array(dataMat)
        n = shape(dataArr)[0]
        xcord1 = []; ycord1 = []
        xcord2 = []; ycord2 = []
        for i in range(n):
            if int(labelMat[i])== 1:
                xcord1.append(dataArr[i,1])
                ycord1.append(dataArr[i,2])
            else:
                xcord2.append(dataArr[i,1])
                ycord2.append(dataArr[i,2])
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
        ax.scatter(xcord2, ycord2, s=30, c='green')
        x = arange(-4.0, 3.0,0.1)
        y = (-weights[0]-weights[1]*x)/weights[2]
        print("b")
        print(-weights[0]/weights[2])
        print("w")
        print(-weights[1]/weights[2])
        ax.plot(x, y)
        plt.xlabel('X1')
        plt.ylabel('X2')
        plt.show()
    
    def main():
        dataMat, labelMat = loadDataSet()
        weights=gradAscent(dataMat, labelMat).getA()
        print(weights)
        plotBestFit(weights)
    
    if __name__=='__main__':
        main()
    
    # def stocGradAscent0(dataMat, labelMat): #随机梯度上升，当数据量比较大时，每次迭代都选择全量数据进行计算，计算量会非常大。所以采用每次迭代中一次只选择其中的一行数据进行更新权重。
    # dataMatrix=mat(dataMat)
    # classLabels=labelMat
    # m,n=shape(dataMatrix)
    # alpha=0.01
    # maxCycles = 500
    # weights=ones((n,1))
    # for k in range(maxCycles):
    # for i in range(m): #遍历计算每一行
    # h = sigmoid(sum(dataMatrix[i] * weights))
    # error = classLabels[i] - h
    # weights = weights + alpha * error * dataMatrix[i].transpose()
    # return weights
    
    # def stocGradAscent1(dataMat, labelMat): #改进版随机梯度上升，在每次迭代中随机选择样本来更新权重，并且随迭代次数增加，权重变化越小。
    # dataMatrix=mat(dataMat)
    # classLabels=labelMat
    # m,n=shape(dataMatrix)
    # weights=ones((n,1))
    # maxCycles=500
    # for j in range(maxCycles): #迭代
    # dataIndex=[i for i in range(m)]
    # for i in range(m): #随机遍历每一行
    # alpha=4/(1+j+i)+0.0001 #随迭代次数增加，权重变化越小。
    # randIndex=int(random.uniform(0,len(dataIndex))) #随机抽样
    # h=sigmoid(sum(dataMatrix[randIndex]*weights))
    # error=classLabels[randIndex]-h
    # weights=weights+alpha*error*dataMatrix[randIndex].transpose()
    # del(dataIndex[randIndex]) #去除已经抽取的样本
    # return weights

LogisticRegression的主要思想和线性回归差不多  
线性回归的主要算式是下面两个，看过sigmoid函数图像知道他是一种(0,1)区间的值，所以比较适合应用于二分类问题，如果多分类，就要多次LogisticRegression了，我们这里的g（z）是三个特征值的  
g（z）=k1 x+ k2 y +c 其中c为常量  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDcxNDgwOA_size_16_color_FFFFFF_t_70]

代价函数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDcxNDgwOA_size_16_color_FFFFFF_t_70 1]  
这个代价函数原本应该是下面的样子，但可以合并成上面的，不用if else 了  
![在这里插入图片描述][20210613174522301.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDcxNDgwOA_size_16_color_FFFFFF_t_70]: /images/20221005/2b9013907da3482c9ff125a1c1c4dbfb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDcxNDgwOA_size_16_color_FFFFFF_t_70 1]: /images/20221005/aaa612d5a89c47eaa9a3f84884ab67f8.png
[20210613174522301.png]: /images/20221005/89f2d1d542034b20a1685f4d1c21befb.png