机器学习——对数几率回归

2023-07-03

# 导入必要的包
import matplotlib
import matplotlib.pyplot as plt
import csv
import numpy as np
import math

# 加载数据集，并且进行一定的处理
def loadDataset():
    data=[]
    labels=[]
    with open('data.txt','r') as f:
        reader = csv.reader(f,delimiter='\t')
        for row in reader:
            data.append([1.0, float(row[0]), float(row[1])])
            labels.append(int(row[2]))
    return data,labels

# 可视化数据和分类边界
def plotBestFit(W):
    # 把训练集数据用坐标的形式画出来
    #dataMat为数据的两个属性，labelMat为数据的分类标签
    dataMat,labelMat=loadDataset()
    dataArr = np.array(dataMat)
    n = np.shape(dataArr)[0] 
    #分类为1的数据，两个列表保存两个属性值
    xcord1 = []
    ycord1 = []
    #分类为2的数据
    xcord2 = []
    ycord2 = []

    #遍历n个数据
    for i in range(n):
        #如果分类标签为1，就将这个数据加到1的列表中
        if int(labelMat[i])== 1:
            xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
        #如果分类标签为2，就将这个数据加到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 = np.arange(-3.0,3.0,0.1)
    y = (-W[0]-W[1]*x)/W[2]
    ax.plot(x,y)
    plt.show()

# 可视化loss
def plotloss(loss_list):
    x = np.arange(0,30,0.01)
    plt.plot(x,np.array(loss_list),label = 'linear')

    plt.xlabel('time')       # 梯度下降的次数
    plt.ylabel('loss')       # 损失值
    plt.title('loss trend')         # 损失值随着W不断更新，不断变化的趋势
    plt.legend()               # 图形图例
    plt.show()

#主函数，对数几率回归
def main():
    # 读取训练集(txt文件)中的数据,
    data, labels = loadDataset()
    # 将数据转换成矩阵的形式，便于后面进行计算
    # 构建特征矩阵X
    X = np.array(data)
    # 构建标签矩阵y
    y = np.array(labels).reshape(-1,1)
    # 随机生成一个w参数(权重)矩阵    .reshape((-1,1))的作用是，不知道有多少行，只想变成一列
    W = 0.001*np.random.randn(3,1).reshape((-1,1))   
    # m表示一共有多少组训练数据
    m = len(X)
    # 定义梯度下降的学习率 0.03
    learn_rate = 0.03

    loss_list = []
    # 实现梯度下降算法，不断更新W,获得最优解，使损失函数的损失值最小
    for i in range(3000):
        # 最重要的就是这里用numpy 矩阵计算，完成假设函数计算，损失函数计算，梯度下降计算
        # 计算假设函数 h(w)x
        g_x = np.dot(X,W)
        h_x = 1/(1+np.exp(-g_x))

        # 计算损失函数 Cost Function 的损失值loss
        loss = np.log(h_x)*y+(1-y)*np.log(1-h_x)
        loss = -np.sum(loss)/m
        loss_list.append(loss)

        # 梯度下降函数更新W权重
        dW = X.T.dot(h_x-y)/m
        W += -learn_rate*dW

    # 得到更新后的W，可视化
    print('W最优解:')
    print(W)
    print('最终得到的分类边界:')
    plotBestFit(W)
    print('损失值随着W不断更新，不断变化的趋势:')
    plotloss(loss_list)



    # 定义一个测试数据，计算他属于那一类别
    test_x = np.array([1,-1.395634,4.662541])
    test_y = 1/(1+np.exp(-np.dot(test_x,W)))
    print(test_y)

#     print(data_arr)
if __name__=='__main__':
    main()

W最优解:
[[ 5.08019887]
 [ 0.55822894]
 [-0.73779162]]
最终得到的分类边界:

output_4_1

损失值随着W不断更新，不断变化的趋势:

output_4_3

[0.70289709]