• 机器学习的逻辑回归

    Sigmoid函数

    逻辑回归的预测函数 

     梯度下降法-逻辑回归

    1. import matplotlib.pyplot as plt
    2. import numpy as np
    3. # 生成一个关于分类器性能的详细报告。
    4. # 这个报告包含了每个类别的精度、召回率、F1分数，以及所有类别的平均精度、召回率和F1分数
    5. from sklearn.metrics import classification_report
    6. # 用于数据预处理的，比如标准化、归一化、正则化
    7. from sklearn import preprocessing
    8. # 数据是否需要标准化
    9. scale = False
    1. # 载入数据
    2. data = np.genfromtxt("LR-testSet.csv", delimiter=",")
    3. x_data = data[:,:-1]
    4. y_data = data[:,-1]
    5.  
    6. def plot():
    7.     x0 = []
    8.     x1 = []
    9.     y0 = []
    10.     y1 = []
    11.     # 切分不同类别的数据
    12.     for i in range(len(x_data)):
    13.         if y_data[i]==0:
    14.             x0.append(x_data[i,0])
    15.             y0.append(x_data[i,1])
    16.         else:
    17.             x1.append(x_data[i,0])
    18.             y1.append(x_data[i,1])
    19.  
    20.     # 画图
    21.     scatter0 = plt.scatter(x0, y0, c='b', marker='o')
    22.     scatter1 = plt.scatter(x1, y1, c='r', marker='x')
    23.     # 画图例
    24.     plt.legend(handles=[scatter0,scatter1],labels=['label0','label1'],loc='best')
    25.  
    26. plot()
    27. plt.show()

     给样本添加配置项

    1. # 数据处理，添加偏置项
    2. x_data = data[:,:-1]
    3. y_data = data[:,-1,np.newaxis]
    4.  
    5. print(np.mat(x_data).shape)
    6. print(np.mat(y_data).shape)
    7. # 给样本添加偏置项
    8. X_data = np.concatenate((np.ones((100,1)),x_data),axis=1)
    9. print(X_data.shape)

     逻辑回归的激活函数

    1. def sigmoid(x):
    2.     return 1.0/(1+np.exp(-x))

    逻辑回归的代价函数 

    1. def cost(xMat, yMat, ws):
    2.     # 这种乘法是按照位置相乘，对应位置直接乘
    3.     # sigmoid(xMat*ws)指的就是预测值
    4.     left = np.multiply(yMat, np.log(sigmoid(xMat*ws)))
    5.     right = np.multiply(1-yMat, np.log(1 - sigmoid(xMat*ws)))
    6.     # 返回的是逻辑回归的代价函数
    7.     return np.sum(left + right) / -(len(xMat))

     代价函数求偏导，但是要记得是以e为底，不是以10为底

     梯度下降算法

    1. def gradAscent(xArr, yArr):
    2.  
    3.     if scale == True:
    4.         xArr = preprocessing.scale(xArr)
    5.     xMat = np.mat(xArr)
    6.     yMat = np.mat(yArr)
    7.  
    8.     lr = 0.001
    9.     epochs = 10000
    10.     costList = []
    11.     # 计算数据行列数
    12.     # 行代表数据个数，列代表权值个数
    13.     m,n = np.shape(xMat)
    14.     # 初始化权值
    15.     ws = np.mat(np.ones((n,1)))
    16.  
    17.     for i in range(epochs+1):
    18.         # xMat和weights矩阵相乘
    19.         h = sigmoid(xMat*ws)
    20.         # 计算误差
    21.         # 因为100行三列没法进行运算，所以需要进行转置,而且由于是矩阵，最后的乘积就是最后相加之后得值
    22.         ws_grad = xMat.T*(h - yMat)/m
    23.         ws = ws -lr*ws_grad
    24.  
    25.         if i % 50 == 0:
    26.             # 每迭代五十次，就保存一下值
    27.             costList.append(cost(xMat,yMat,ws))
    28.     return ws,costList

     测试集

    1. if scale == False:
    2.     # 画图决策边界
    3.     plot()
    4.     # 以下的内容就是画边界线的
    5.     x_test = [[-4],[3]]
    6.     # sigmoid函数0左边和右边是进行分类的
    7.     # w0+x1w1+x2w2 这个方程就是相当于sigmoid函数中g(θT*x)中的θT*x
    8.     y_test = (-ws[0] - x_test*ws[1])/ws[2]
    9.     plt.plot(x_test, y_test, 'k')
    10.     plt.show()

    loss值的变化

    1. x = np.linspace(0,10000,201)
    2. plt.plot(x, costList, c='r')
    3. plt.title('Train')
    4. plt.xlabel('Epochs')
    5. plt.ylabel('Cost')
    6. plt.show()

    sklearn-逻辑回归

    1. import matplotlib.pyplot as plt
    2. import numpy as np
    3. from sklearn.metrics import classification_report
    4. from sklearn import linear_model
    5. from sklearn import preprocessing
    6. # 数据是否需要标准化
    7. scale = False
    8.  
    9. # 载入数据
    10. data = np.genfromtxt("LR-testSet.csv", delimiter=",")
    11. x_data = data[:,:-1]
    12. y_data = data[:,-1]
    13.  
    14. def plot():
    15.     x0 = []
    16.     x1 = []
    17.     y0 = []
    18.     y1 = []
    19.     # 切分不同类别的数据
    20.     for i in range(len(x_data)):
    21.         if y_data[i]==0:
    22.             x0.append(x_data[i,0])
    23.             y0.append(x_data[i,1])
    24.         else:
    25.             x1.append(x_data[i,0])
    26.             y1.append(x_data[i,1])
    27.  
    28.     # 画图
    29.     scatter0 = plt.scatter(x0, y0, c='b', marker='o')
    30.     scatter1 = plt.scatter(x1, y1, c='r', marker='x')
    31.     # 画图例
    32.     plt.legend(handles=[scatter0,scatter1],labels=['label0','label1'],loc='best')
    33.  
    34. plot()
    35. plt.show()

     构建并拟合模型

    1. logistic = linear_model.LogisticRegression()
    2. logistic.fit(x_data, y_data)

     测试集

    1. if scale == False:
    2.     # 画图决策边界
    3.     plot()
    4.     # 以下的内容就是画边界线的
    5.     x_test = np.array([[-4],[3]])
    6.     # intercept_代表模型的偏置    coef_[0][0]代表模型的权值
    7.     y_test = (-logistic.intercept_ - x_test*logistic.coef_[0][0])/logistic.coef_[0][1]
    8.     plt.plot(x_test, y_test, 'k')
    9.     plt.show()

    梯度下降法-非线性逻辑回归

    1. import matplotlib.pyplot as plt
    2. import numpy as np
    3. from sklearn.metrics import classification_report
    4. from sklearn.preprocessing import PolynomialFeatures
    5. from sklearn import preprocessing
    6. # 数据是否需要标准化
    7. scale = False
    1. # 载入数据
    2. data = np.genfromtxt("LR-testSet2.txt", delimiter=",")
    3. x_data = data[:,:-1]
    4. y_data = data[:,-1,np.newaxis]
    5.  
    6. def plot():
    7.     x0 = []
    8.     x1 = []
    9.     y0 = []
    10.     y1 = []
    11.     # 切分不同类别的数据
    12.     for i in range(len(x_data)):
    13.         if y_data[i]==0:
    14.             x0.append(x_data[i,0])
    15.             y0.append(x_data[i,1])
    16.         else:
    17.             x1.append(x_data[i,0])
    18.             y1.append(x_data[i,1])
    19.  
    20.     # 画图
    21.     scatter0 = plt.scatter(x0, y0, c='b', marker='o')
    22.     scatter1 = plt.scatter(x1, y1, c='r', marker='x')
    23.     # 画图例
    24.     plt.legend(handles=[scatter0,scatter1],labels=['label0','label1'],loc='best')
    25.  
    26. plot()
    27. plt.show()

    定义多项式回归

    1. # 定义多项式回归，degree的值可以调节多项式的特征
    2. poly_reg = PolynomialFeatures(degree=3)
    3. # 特征处理
    4. x_poly = poly_reg.fit_transform(x_data)
    5. # fit()：首先，它使用输入的x_data来“训练”或“适应”模型
    6. # transform(x_data)：然后，它使用已经训练好的模型来转换输入的数据。
    7.     # 在这种情况下，它将把x_data中的每个特征转化为多项式特征。结果会是一个新的数据集，其中包含了原始数据的所有多项式特征

    degree的数字越大，模型的拟合程度越好。但是也要保证不要过拟合 

    1. def sigmoid(x):
    2.     return 1.0/(1+np.exp(-x))
    3.  
    4. def cost(xMat, yMat, ws):
    5.     left = np.multiply(yMat, np.log(sigmoid(xMat*ws)))
    6.     right = np.multiply(1 - yMat, np.log(1 - sigmoid(xMat*ws)))
    7.     return np.sum(left + right) / -(len(xMat))
    8.  
    9. def gradAscent(xArr, yArr):
    10.     
    11.     if scale == True:
    12.         xArr = preprocessing.scale(xArr)
    13.     xMat = np.mat(xArr)
    14.     yMat = np.mat(yArr)
    15.  
    16.     lr = 0.03
    17.     epochs = 50000
    18.     costList = []
    19.     # 计算数据列数，有几列就有几个权值
    20.     m,n = np.shape(xMat)
    21.     # 初始化权值
    22.     ws = np.mat(np.ones((n,1)))
    23.  
    24.     for i in range(epochs+1):
    25.         # xMat和weights矩阵相乘
    26.         h = sigmoid(xMat*ws)
    27.         # 计算误差
    28.         ws_grad = xMat.T*(h - yMat) / m
    29.         ws = ws - lr*ws_grad
    30.  
    31.         if i % 50 == 0:
    32.             costList.append(cost(xMat,yMat,ws))
    33.     return ws,costList

     ravel()函数

    1. [[1,1],[2,2]]
    2. # ravel之后变为一维
    3. [1,1,2,2]

     生成等高线图

    1. # 获取数据值所在的范围
    2. x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
    3. y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    4.  
    5. # 生成网格矩阵
    6. # 步长是0.02
    7. xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
    8.                      np.arange(y_min, y_max, 0.02))
    9.  
    10. # np.r_按row来组合array
    11. # np.c_按colunm来组合array
    12. # >>> a = np.array([1,2,3])
    13. # >>> b = np.array([5,2,5])
    14. # >>> np.r_[a,b]
    15. # array([1, 2, 3, 5, 2, 5])
    16. # >>> np.c_[a,b]
    17. # array([[1, 5],
    18. #        [2, 2],
    19. #        [3, 5]])
    20. # >>> np.c_[a,[0,0,0],b]
    21. # array([[1, 0, 5],
    22. #        [2, 0, 2],
    23. #        [3, 0, 5]])
    24.  
    25. # dot表示向量的内积，即对应位置元素相乘相加
    26. z = sigmoid(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]).dot(np.array(ws)))
    27. # ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据
    28. # sigmoid函数可以将任何实数映射到介于0和1之间的值
    29. for i in range(len(z)):
    30.     if z[i] > 0.5:
    31.         z[i] = 1
    32.     else:
    33.         z[i] = 0
    34.  
    35. # 将我们修改后的z重新塑形为与xx相同的形状。这意味着我们原先的一维数组z现在变成了二维数组，形状与xx和yy相同
    36. z = z.reshape(xx.shape)
    37.  
    38. # 等高线图
    39. cs = plt.contourf(xx, yy, z)
    40. plot() 
    41. plt.show()

     sklearn-非线性逻辑回归

    1. import numpy as np
    2. import matplotlib.pyplot as plt
    3. from sklearn import linear_model
    4. from sklearn.datasets import make_gaussian_quantiles
    5. from sklearn.preprocessing import PolynomialFeatures
    6.

    生成数据 

    1. # 生成2维正态分布，生成的数据按分位数分为两类，500个样本,2个样本特征
    2. # 可以生成两类或多类数据
    3. # 该函数由 sklearn.datasets 提供，用于生成高斯分布的样本数据。这个函数可以产生指定数量（n_samples）的样本，
    4. # 每个样本都有指定数量（n_features）的特征，并且每个特征都服从高斯分布（正态分布）。n_classes 参数指定了生成的样本应属于的类别数量
    5. x_data, y_data = make_gaussian_quantiles(n_samples=500, n_features=2,n_classes=2)
    6.  
    7. plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
    8. plt.show()

     创建并拟合模型

    1. logistic = linear_model.LogisticRegression()
    2. logistic.fit(x_data, y_data)
    1. # 获取数据值所在的范围
    2. x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
    3. y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    4.  
    5. # 生成网格矩阵
    6. xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
    7.                      np.arange(y_min, y_max, 0.02))
    8.  
    9.  
    10. z = logistic.predict(np.c_[xx.ravel(), yy.ravel()])# ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据
    11. z = z.reshape(xx.shape)
    12. # 等高线图
    13. cs = plt.contourf(xx, yy, z)
    14. # 样本散点图
    15. plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
    16. plt.show()
    17.  
    18. # 使用逻辑回归模型来对给定的数据集进行预测，并计算模型的准确率得分
    19. print('score:',logistic.score(x_data,y_data))

     此时生成的模型进行逻辑回归的准确率太低，需要再次定义逻辑回归模型

    1. # 定义多项式回归,degree的值可以调节多项式的特征
    2. poly_reg  = PolynomialFeatures(degree=5) 
    3. # 特征处理
    4. x_poly = poly_reg.fit_transform(x_data)
    5. # 定义逻辑回归模型
    6. logistic = linear_model.LogisticRegression()
    7. # 训练模型
    8. logistic.fit(x_poly, y_data)
    9.  
    10. # 获取数据值所在的范围
    11. x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
    12. y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    13.  
    14. # 生成网格矩阵
    15. xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
    16.                      np.arange(y_min, y_max, 0.02))
    17.  
    18.  
    19. z = logistic.predict(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]))# ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据
    20. z = z.reshape(xx.shape)
    21. # 等高线图
    22. cs = plt.contourf(xx, yy, z)
    23. # 样本散点图
    24. plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
    25. plt.show()
    26.  
    27. print('score:',logistic.score(x_poly,y_data))

    非凸函数和凸函数

     线性回归的代价函数是凸函数

    逻辑回归正则化

    正确率与召回率

    正确率与召回率是广泛应用于信息检索和统计学分类领域的两个度量值，用来评价结果的质量

     一般来说，正确率就是检索出来的条目有多少是正确的，召回率就是所有正确的条目有多少被检索出来了

    F1值=2*（正确率*召回率）/ （正确率+召回率），用于综合反映整体的指标。

    这几个指标的取值都在0-1之间，数值越接近1，效果越好

  • 相关阅读:
    Django-中间件(切面编程AOP)
    学生网页设计作品 dreamweaver作业静态HTML网页设计模板 美食文化网页作业制作
    nginx的三种安装方式
    mybatis小记
    智慧公厕的原理与优势，了解一种更智能的卫生设施
    day03_基础语法
    【c语言】详解结构体
    华为数通HCIA-华为VRP系统基础
    线性表操作的实现--顺序表
    头歌实践--实验八 回溯法
  • 原文地址：https://blog.csdn.net/qq_47896523/article/details/134348934