一、理论知识及其原理

关于原理，可以参照https://blog.csdn.net/u011734144/article/details/79717470和笔记即可
笔记截图：
image.png
image.png

二、线性逻辑回归

1.梯度下降法的应用

  1. import matplotlib.pyplot as plt
  2. import numpy as np
  3. from sklearn.metrics import classification_report
  4. from sklearn import preprocessing
  5. # 数据是否需要标准化
  6. scale = False
  8. # 载入数据
  9. data = np.genfromtxt(r"C:\Users\小新\Desktop\课程pdf\py\机器学习\逻辑回归\LR-testSet.csv", delimiter=",")
  10. x_data = data[:,:-1] #切分除了最后一列的数据都是x
  11. y_data = data[:,-1] #切分最后一列为y,这里的y_data是分类类别（取值0和1）
  13. def plot(): #定义这个函数是用来画出下面的图的
  14.     x0 = [] #分类类别对应的值
  15.     x1 = [] #分类类别对应的值
  16.     y0 = [] #分类类别为0
  17.     y1 = [] #分类类别为1
  18.     # 切分不同类别的数据
  19.     for i in range(len(x_data)): #数据切分
  20.         if y_data[i] == 0: #说明这是第0个类别
  21.             x0.append(x_data[i,0]) #存放第0个特征
  22.             y0.append(x_data[i,1]) #存放第1个特征
  23.         else:
  24.             x1.append(x_data[i,0])
  25.             y1.append(x_data[i,1])
  27.     # 画图
  28.     scatter0 = plt.scatter(x0, y0, c='b', marker='o') #0类别的散点图
  29.     scatter1 = plt.scatter(x1, y1, c='r', marker='x') #1类别的散点图
  30.     #画图例
  31.     plt.legend(handles=[scatter0,scatter1],labels=['label0','label1'],loc='best') #loc是选择最佳位置
  33. plot()
  34. plt.show()
  36. #注：这里可以用以下代码快速画图：
  37. x_data = data[:,:-1]
  38. y_data = data[:,-1]
  39. plt.scatter(x.data[:,0],x_data[:,1],color = y_data) #直接利用y_data来进行颜色赋值（y_data本来是二分类变量）
  40. plt.show()
  42. # 数据处理，添加偏置项
  43. x_data = data[:,:-1]
  44. y_data = data[:,-1,np.newaxis] #增加维度
  46. print(np.mat(x_data).shape) #100行2列
  47. print(np.mat(y_data).shape) #100行1列（相当于列向量）
  48. # 给样本添加偏置项
  49. X_data = np.concatenate((np.ones((100,1)),x_data),axis=1)
  50. print(X_data.shape) #100行3列
  52. #开始进行逻辑回归
  53. def sigmoid(x): #定义sigmoid函数
  54.     return 1.0/(1+np.exp(-x))
  56. def cost(xMat, yMat, ws): #定义损失函数，xmat是训练数据，ymat是标签，ws是权值（都是矩阵形式）
  57.     left = np.multiply(yMat, np.log(sigmoid(xMat*ws))) #损失函数左边的部分，np.multiply是对应位置元素相乘,yMat和np.log(sigmoid(xMat*ws)都是100*1的
  58.     right = np.multiply(1 - yMat, np.log(1 - sigmoid(xMat*ws))) #损失函数的右边部分
  59.     return np.sum(left + right) / -(len(xMat)) #得到最终的损失函数
  61. #注：这里损失函数用矩阵乘法会不会成功？可以试试看
  63. def gradAscent(xArr, yArr):
  65.     if scale == True:
  66.         xArr = preprocessing.scale(xArr) #对数据进行标准化
  67.     xMat = np.mat(xArr)
  68.     yMat = np.mat(yArr)
  70.     lr = 0.001 #定义学习率
  71.     epochs = 10000 #定义迭代次数
  72.     costList = [] #保存cost值，每次迭代都会产生一个新的cost
  73.     # 计算数据行列数
  74.     # 行代表数据个数，列代表权值个数
  75.     m,n = np.shape(xMat) #m代表行，n代表列
  76.     # 初始化权值
  77.     ws = np.mat(np.ones((n,1))) #都初始化为1
  79.     for i in range(epochs+1):             
  80.         # xMat和weights矩阵相乘
  81.         h = sigmoid(xMat*ws)  #损失函数中hθ（x）,100行1列
  82.         # 计算误差
  83.         ws_grad = xMat.T*(h - yMat)/m #计算梯度，矩阵乘法，3行100列乘以100行1列，得到3行1列，即系数值，公式中的求和项相当于在矩阵里进行了
  84.         ws = ws - lr*ws_grad 
  86.         if i % 50 == 0:
  87.             costList.append(cost(xMat,yMat,ws)) #每隔50次保存一次cost值
  88.     return ws,costList
  90. #注：
  91. #1,2
  92. #3,4
  94. #4,3
  95. #2,1
  97. #得到矩阵为
  98. ##4,6
  99. ##6,4
  101. # 训练模型，得到权值和cost值的变化
  102. ws,costList = gradAscent(X_data, y_data)
  103. print(ws)
  105. if scale == False: #非标准化的数据，标准化后的数据数值改变后画图会很奇怪，于是标准化后的图可以不用画
  106.     # 画图决策边界
  107.     plot()
  108.     x_test = [[-4],[3]] #规定x的取值
  109.     y_test = (-ws[0] - x_test*ws[1])/ws[2] #这里令w0+xw1+yw2 = 0（sigmoid分界点→0.5）求解y（边界）
  110.     plt.plot(x_test, y_test, 'k')
  111.     plt.show()
  113. # 画图 loss值的变化
  114. x = np.linspace(0,10000,201) #从0到10000画200个点
  115. plt.plot(x, costList, c='r')
  116. plt.title('Train')
  117. plt.xlabel('Epochs')
  118. plt.ylabel('Cost')
  119. plt.show()
  121. # 预测
  122. def predict(x_data, ws):
  123.     if scale == True:
  124.         x_data = preprocessing.scale(x_data)
  125.     xMat = np.mat(x_data)
  126.     ws = np.mat(ws)
  127.     return [1 if x >= 0.5 else 0 for x in sigmoid(xMat*ws)] #如果x大于等于0.5，返回类别1，小于0.5，返回类别0
  129. predictions = predict(X_data, ws)
  131. print(classification_report(y_data, predictions)) #正确率，召回率的查看情况

2.sklearn库的方法

  1. import matplotlib.pyplot as plt
  2. import numpy as np
  3. from sklearn.metrics import classification_report
  4. from sklearn import preprocessing
  5. from sklearn import linear_model
  6. # 数据是否需要标准化
  7. scale = False
  9. # 载入数据
  10. data = np.genfromtxt(r"C:\Users\小新\Desktop\课程pdf\py\机器学习\逻辑回归\LR-testSet.csv", delimiter=",")
  11. x_data = data[:,:-1]
  12. y_data = data[:,-1]
  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])
  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')
  34. plot()
  35. plt.show()
  37. logistic = linear_model.LogisticRegression() #利用sklearn库进行逻辑回归
  38. logistic.fit(x_data, y_data) 
  39. #其余相关的参数如截距、回归系数的代码跟回归分析类似，在这里不过多赘述
  41. if scale == False:
  42.     # 画图决策边界，注意这里是二维的，多维的情况不宜画图
  43.     plot()
  44.     x_test = np.array([[-4],[3]])
  45.     y_test = (-logistic.intercept_ - x_test*logistic.coef_[0][0])/logistic.coef_[0][1] #logistic.coef_是一个1*2的矩阵形式，这里的[0]是取第一行的两个数，转化成一个向量形式，第二个[0]，[1]就是取这两个数了
  46.     plt.plot(x_test, y_test, 'k')
  47.     plt.show()
  49. predictions = logistic.predict(x_data)
  50. print(classification_report(y_data, predictions)) #计算正确率、召回率和F1值

三、非线性逻辑回归

1.梯度下降法的应用

  1. import matplotlib.pyplot as plt
  2. import numpy as np
  3. from sklearn.metrics import classification_report
  4. from sklearn import preprocessing
  5. from sklearn.preprocessing import PolynomialFeatures
  6. # 数据是否需要标准化
  7. scale = False
  9. # 载入数据
  10. data = np.genfromtxt(r"C:\Users\小新\Desktop\课程pdf\py\机器学习\逻辑回归\LR-testSet2.txt", delimiter=",")
  11. x_data = data[:,:-1]
  12. y_data = data[:,-1,np.newaxis]
  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])
  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')
  34. plot()
  35. plt.show()
  37. # 定义多项式回归,degree的值可以调节多项式的特征,自己可以多次尝试
  38. poly_reg  = PolynomialFeatures(degree=3) #做数据多项式处理
  39. # 特征处理
  40. x_poly = poly_reg.fit_transform(x_data)
  42. ##注：特征处理我们来举个例子：
  43. ##test = [[2,3]]
  44. # 定义多项式回归,degree的值可以调节多项式的特征
  45. #poly_reg  = PolynomialFeatures(degree=3) 
  46. # 特征处理
  47. #x_poly = poly_reg.fit_transform(test) #构造出非线性项，包括交互项
  48. #x_poly #这里给出的第一个是x的偏置项，第二第三个是x1，x2，第四个是x1^2,第五个是x1*x2，第六个是x2^2,第七个是x2^3,第八个是x1^2*x2,第九个是x1*x2^2,第十个是x2^3
  49. #output情况：array([[ 1.,  2.,  3.,  4.,  6.,  9.,  8., 12., 18., 27.]])
  51. def sigmoid(x):
  52.     return 1.0/(1+np.exp(-x))
  54. def cost(xMat, yMat, ws):
  55.     left = np.multiply(yMat, np.log(sigmoid(xMat*ws)))
  56.     right = np.multiply(1 - yMat, np.log(1 - sigmoid(xMat*ws)))
  57.     return np.sum(left + right) / -(len(xMat))
  59. def gradAscent(xArr, yArr):
  61.     if scale == True:
  62.         xArr = preprocessing.scale(xArr)
  63.     xMat = np.mat(xArr)
  64.     yMat = np.mat(yArr)
  66.     lr = 0.03
  67.     epochs = 50000
  68.     costList = []
  69.     # 计算数据列数，有几列就有几个权值
  70.     m,n = np.shape(xMat)
  71.     # 初始化权值
  72.     ws = np.mat(np.ones((n,1)))
  74.     for i in range(epochs+1):             
  75.         # xMat和weights矩阵相乘
  76.         h = sigmoid(xMat*ws)   
  77.         # 计算误差
  78.         ws_grad = xMat.T*(h - yMat)/m
  79.         ws = ws - lr*ws_grad 
  81.         if i % 50 == 0:
  82.             costList.append(cost(xMat,yMat,ws))
  83.     return ws,costList
  85. # 训练模型，得到权值和cost值的变化
  86. ws,costList = gradAscent(x_poly, y_data)
  87. print(ws)
  89. #画决策边界情况（手操较难）
  90. # 获取数据值所在的范围【决定数据下图数据框的大小】
  91. x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
  92. y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
  94. # 生成网格矩阵
  95. xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
  96.                      np.arange(y_min, y_max, 0.02))
  98. # np.r_按row来组合array， 
  99. # np.c_按colunm来组合array
  100. # >>> a = np.array([1,2,3])
  101. # >>> b = np.array([5,2,5])
  102. # >>> np.r_[a,b]
  103. # array([1, 2, 3, 5, 2, 5])
  104. # >>> np.c_[a,b]
  105. # array([[1, 5],
  106. #        [2, 2],
  107. #        [3, 5]])
  108. # >>> np.c_[a,[0,0,0],b]
  109. # array([[1, 0, 5],
  110. #        [2, 0, 2],
  111. #        [3, 0, 5]])
  113. z = sigmoid(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]).dot(np.array(ws)))# ravel与flatten类似，多维数据转一维（使之扁平化）。flatten不会改变原始数据，ravel会改变原始数据
  114. #z函数相当于把网格矩阵的点给做一个预测，是1就是一类，是0就是一类，利用密集点填充的方式来强行构造出一个边界
  115. for i in range(len(z)):
  116.     if z[i] > 0.5:
  117.         z[i] = 1
  118.     else:
  119.         z[i] = 0
  120. z = z.reshape(xx.shape)
  122. # 等高线图
  123. cs = plt.contourf(xx, yy, z)
  124. plot() 
  125. plt.show()
  127. # 预测
  128. def predict(x_data, ws):
  129. #     if scale == True:
  130. #         x_data = preprocessing.scale(x_data)
  131.     xMat = np.mat(x_data)
  132.     ws = np.mat(ws)
  133.     return [1 if x >= 0.5 else 0 for x in sigmoid(xMat*ws)]
  135. predictions = predict(x_poly, ws)
  137. print(classification_report(y_data, predictions))

2.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
  7. # 生成2维正态分布，生成的数据按分位数分为两类，500个样本,2个样本特征
  8. # 可以生成两类或多类数据
  9. x_data, y_data = make_gaussian_quantiles(n_samples=500, n_features=2,n_classes=2)
  11. plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
  12. plt.show()
  14. logistic = linear_model.LogisticRegression()
  15. logistic.fit(x_data, y_data)
  17. # 定义多项式回归,degree的值可以调节多项式的特征
  18. poly_reg  = PolynomialFeatures(degree=5) 
  19. # 特征处理
  20. x_poly = poly_reg.fit_transform(x_data)
  21. # 定义逻辑回归模型
  22. logistic = linear_model.LogisticRegression()
  23. # 训练模型
  24. logistic.fit(x_poly, y_data) #不指定x值会出现线性分类情况，所以需要自己去定义多项式部分！注意！
  26. # 获取数据值所在的范围
  27. x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
  28. y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
  30. # 生成网格矩阵
  31. xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
  32.                      np.arange(y_min, y_max, 0.02))
  34. # np.r_按row来组合array， 
  35. # np.c_按colunm来组合array
  36. # >>> a = np.array([1,2,3])
  37. # >>> b = np.array([5,2,5])
  38. # >>> np.r_[a,b]
  39. # array([1, 2, 3, 5, 2, 5])
  40. # >>> np.c_[a,b]
  41. # array([[1, 5],
  42. #        [2, 2],
  43. #        [3, 5]])
  44. # >>> np.c_[a,[0,0,0],b]
  45. # array([[1, 0, 5],
  46. #        [2, 0, 2],
  47. #        [3, 0, 5]])
  48. z = logistic.predict(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]))# ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据
  49. z = z.reshape(xx.shape)
  50. # 等高线图
  51. cs = plt.contourf(xx, yy, z)
  52. # 样本散点图
  53. plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
  54. plt.show()
  56. print('score:',logistic.score(x_poly,y_data)) #输出R方值