基于python的numpy和pandas模块实现机器学习算法-逻辑回归

stonejianbu

逻辑回归算法实现

逻辑回归属于分类方法，主要用于解决二分类问题。
本篇文章不对数学概念进行分析，使用代码结合注释的方式，代码部分抽象以下

• 1.数据准备：pandas读取.data文件和随机划分数据集
• 2.数据预处理：标准化处理（x -mean）/ 标准差
• 3.模型：p = f(z) = 1 / (1+ e^-z), 且z=XW+b, p~(0,1) (sigmoid函数)
• 4.策略：对数似然损失L=-ylog(p)-(1-y)log(1-p)  (极大似然估计)
• 5.算法：随机梯度下降  (梯度和方向导数)
• 6.避免过拟合，模型优化：l2正则化  (多项式、范数)
• 7.数据预测和评估：使用由算法（随机梯度下降优化）得到的权重系数和偏置，计算损失，计算正确率（暂未计算召回率）
  

1. import pandas as pd
   
2. import numpy as np
   
3. import random
   
4. 
   
5. 
   
6. class LogisticRegression:
   
7.     """
   
8.     逻辑回归：
   
9.     1.随机生成梯度
   
10.     2.计算损失值: z=X.W+b-->p_array=1/(1+e^-z)-->loss=-ylog(p)-(1-y)log(1-p)+regular_item
    
11.     3.梯度优化
    
12.     """
    
13.     def __init__(self, alpha=1, C=1.0, diff=1e-4):
    
14.         self.alpha = alpha  # 学习率
    
15.         self.C = C          # 正则化系数
    
16.         self.diff = diff    # 前后损失差（决定是否终止梯度下降）
    
17.         self.mean_cost = None
    
18.         self.weight_bias = None
    
19.         self.coef = None
    
20.         self.intercept = None
    
21.         self.m = None
    
22.         self.n = None
    
23. 
    
24.     def preprocess_data(self, X, y, test_size=0.35):
    
25.         """
    
26.         1.划分数据为训练集和测试集
    
27.         2.对数据进行标准化处理
    
28.         :param X: 特征值
    
29.         :param y: 目标值
    
30.         :param test_size: 测试占总数据集的比例
    
31.         :return: 返回X_train, X_test, y_train, y_test
    
32.         """
    
33.         # 1.划分数据集
    
34.         X_train, X_test, y_train, y_test = self.train_test_split(X, y, test_size=test_size)
    
35. 
    
36.         # 2.对输入空间进行标准化处理
    
37.         X_train, X_test = self.standardization([X_train, X_test])
    
38.         return X_train, X_test, y_train, y_test
    
39. 
    
40.     def standardization(self, two_arrays):
    
41.         """
    
42.         std_result = x - mean / std
    
43.         :param two_arrays: 可以是一个或者多个二维数组
    
44.         :return: 返回标准化后结果数组列表
    
45.         """
    
46.         arrays = [two_arrays] if isinstance(two_arrays, np.ndarray) else two_arrays
    
47.         return [(array - np.mean(array, axis=0)) * (1 / np.std(array, axis=0)) for array in arrays]
    
48. 
    
49.     def train_test_split(self, X, y, test_size=0.2):
    
50.         # 根据指定的test_size占比划分数据集
    
51.         m, n = X.shape
    
52.         x_test_number = int(m * test_size)
    
53. 
    
54.         # 根据x_test个数随机生成
    
55.         test_index = random.sample(range(m), x_test_number)
    
56.         train_index = list(set(range(m)) - set(test_index))
    
57. 
    
58.         # 划分训练集和测试集
    
59.         return X[train_index], X[test_index], y[train_index], y[test_index]
    
60. 
    
61.     def transform_X(self, X):
    
62.         """X添加一列且值都为1，方便矩阵相乘，X*W+b--->[X,1]*[W,b]"""
    
63.         m = X.shape[0]
    
64.         bias_array = np.array([1] * m).reshape((-1, 1))
    
65.         X = np.concatenate((X, bias_array), axis=1)
    
66.         return X
    
67. 
    
68.     def fit(self, X, y):
    
69.         """
    
70.         1.对X,y进一步处理(1.1 给X添加一列且值都为1，为方便矩阵相乘，该列对应偏置 1.2.将X,y数组转为矩阵)
    
71.         2.梯度下降求解(2.1 随机生成系数计算损失值 2.2 计算梯度 2.3 更新系数计算损失值 2.4.循环第二、三步 2.5.当达到终止条件停止)
    
72.         :param X: 预处理过的特征值
    
73.         :param y: 预处理过的目标值
    
74.         :return: 返回类实例本身self
    
75.         """
    
76.         # 1.对X, y转换处理(X-->(m,n), y-->(m,1))
    
77.         X = self.transform_X(X)
    
78.         y = np.array(y).reshape(-1, 1)
    
79.         self.m, self.n = X.shape
    
80. 
    
81.         # 2.梯度下降求解最小损失值--->最优系数（权重和偏置）
    
82.         self.gradient_descent_optimization(X, y)
    
83.         return self
    
84. 
    
85.     def gradient_descent_optimization(self, X, y):
    
86.         """
    
87.         1.更新权重和偏置(1.1 计算梯度grad 1.2 更新权重偏置weight_bias = weight_bias - alpha*grad)
    
88.         2.计算损失函数值（2.1.求出预测值 2.2.计算sigmoid可能性 2.3.计算损失）
    
89.         3.梯度下降优化(3.1 计算梯度 3.2.更新系数 3.3 计算损失 3.4.循环(当达到终于条件停止))
    
90.         4.更新实例属性值（coef,intercept,,mean_cost）
    
91.         :param X: 预处理过的特征值
    
92.         :param y: 预处理过的目标值
    
93.         :return: 返回类实例本身self
    
94.         """
    
95.         # 1.随机生成系数（权重和偏置）(weight_bias-->(n,1))
    
96.         weight_bias = np.random.randn(self.n, 1)
    
97. 
    
98.         # 2.计算损失函数值（2.1.求出预测值 2.2.计算sigmoid可能性大小 2.3.计算对数似然损失值）
    
99.         mean_cost = self.calc_cost(X, y, weight_bias)
    
100. 
     
101.         # 3.梯度下降优化系数使得损失函数变小，循环迭代直到满足终止条件
     
102.         pre_mean_cost = 0
     
103.         cur_mean_cost = mean_cost
     
104.         while abs(pre_mean_cost - cur_mean_cost) > self.diff:
     
105.             # 3.1 计算梯度grad = <W1,...,Wn,b>, 即关于损失函数对系数w1,w2...求偏导
     
106.             grad = self.calc_gradient(X, y, weight_bias)
     
107.             # print(grad)
     
108. 
     
109.             # 3.2 更新系数(权重和偏置)
     
110.             weight_bias = weight_bias*(1-self.C*self.alpha/self.m) - self.alpha * grad
     
111.             # print('第%s次迭代,weight_bias:%s' % (n, weight_bias))
     
112. 
     
113.             # 3.3计算损失函数值（2.1.求出预测值 2.2.计算sigmoid可能性 2.3.计算对数似然损失）
     
114.             mean_cost = self.calc_cost(X, y, weight_bias)
     
115. 
     
116.             # 3.4 更新损失值：过去=现在 现在=当下（查看前后损失值的变化来决定是否停止迭代）
     
117.             pre_mean_cost = cur_mean_cost
     
118.             cur_mean_cost = mean_cost
     
119. 
     
120.         # 4.更新实例属性值
     
121.         self.weight_bias = weight_bias
     
122.         self.coef, self.intercept = self.weight_bias[:-1].flatten(), self.weight_bias[-1].flatten()
     
123.         self.mean_cost = mean_cost
     
124.         return self
     
125. 
     
126.     def calc_cost(self, X, y, weight_bias):
     
127.         # 1.计算sigmoid: p = 1 / (1 + e^(-z))
     
128.         p_array = self.calc_sigmoid(X, weight_bias)
     
129. 
     
130.         # 2.计算损失值: -ylog(p)-(1-y)log(1-p) + regular_item
     
131.         # 2.1.添加正则化项，减轻过拟合问题
     
132.         regular_item = (self.C / 2 * self.m) * np.dot(weight_bias[:-1].T, weight_bias[:-1])
     
133. 
     
134.         # 2.2确保y，p_array转换为1维数组，方便使用索引获取值
     
135.         y_array, p_array = y.flatten(), p_array.flatten()
     
136. 
     
137.         # 2.3.计算平均损失值cost = 1/m * (-y*log(p) - (1-y)*log(1-p)),避免p或1-p为零，添加1e-5
     
138.         cost = lambda y, p: -y * np.log(p + 1e-5) - (1 - y) * np.log(1 - p + 1e-5)
     
139.         mean_cost = 1 / self.m * sum([cost(y_array[i], p_array[i]) for i in range(self.m)]) + float(regular_item)
     
140.         return mean_cost
     
141. 
     
142.     def calc_sigmoid(self, X, weight_bias):
     
143.         # 1.矩阵相乘：特征值(m,n) * 特征系数(n,1) = z ~(m,1)
     
144.         z_array = np.dot(X, weight_bias)
     
145. 
     
146.         # 2.计算sigmoid
     
147.         p_array = [1 / (1 + np.e ** (-i)) for i in z_array.flatten()]
     
148.         return np.array(p_array).reshape(-1, 1)
     
149. 
     
150.     def calc_gradient(self, X, y, weight_bias):
     
151.         """计算梯度W = X.T*(p_array-y)--->(m,n).T* (m, 1)"""
     
152.         # 1. 计算sigmoid= 1 / (1 + e^-z)
     
153.         p_array = self.calc_sigmoid(X, weight_bias)
     
154. 
     
155.         # 2.计算梯度grad = (n,m) * (m, 1)--->(n, 1)
     
156.         grad = np.dot(X.T, p_array-y) * (1/self.m)
     
157.         return grad
     
158. 
     
159.     def predict(self, X):
     
160.         """
     
161.         1. 计算y = X*weight_bias
     
162.         2. 计算sigmoid（如果概率大于0.5则标记为1，否则标记为0）
     
163.         :param X: 测试集的特征值
     
164.         :return: 返回预测的分类结果
     
165.         """
     
166.         X = self.transform_X(X)
     
167.         p_array = self.calc_sigmoid(X, self.weight_bias)
     
168.         y_predict = list(map(lambda x: 1 if x >= 0.5 else 0, p_array))
     
169.         return np.array(y_predict).reshape(-1, 1)
     
170. 
     
171.     def score(self, X, y):
     
172.         """
     
173.         计算模型的准确率：正确个数/总个数
     
174.         1. 计算预测的分类结果
     
175.         2. 实际分类结果和预测分类结果进行对比计算
     
176.         :param X: 特征值
     
177.         :param y: 目标值
     
178.         :return: 准确率
     
179.         """
     
180.         # 1.计算预测分类的结果
     
181.         y_predict = self.predict(X)
     
182. 
     
183.         # 2.计算预测正确的分类数（循环判断，相同增加1，得到correct_number）
     
184.         y, y_predict = y.flatten(), y_predict.flatten()
     
185.         m = y_predict.shape[0]
     
186.         correct_number = sum([True for i in range(m) if y[i] == y_predict[i]])
     
187. 
     
188.         # 3.计算正确率：正确个数/总个数（保留小数点后两位）
     
189.         possiblity = round(correct_number/m, ndigits=4)
     
190.         return possiblity
     
191. 
     
192. 
     
193. if __name__ == '__main__':
     
194.     # data = pd.read_csv('./data/iris_data.csv')
     
195.     # X, y = data.iloc[:, 0:-1].values, data.iloc[:, -1:].values
     
196. 
     
197.     # 癌症数据集https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/
     
198.     data = pd.read_csv('./data/wdbc.data')
     
199.     X, y = data.iloc[:, 2:].values, data.iloc[:, 1]
     
200.     y = y.replace('M', 1)
     
201.     y = y.replace('B', 0).values
     
202.     # 确保X, y输入为(m,n) (m,1)
     
203. 
     
204.     # 实例化LogisticRegression
     
205.     logistic = LogisticRegression()
     
206. 
     
207.     # 对输入的数据进行预处理：划分数据集和标准化处理
     
208.     X_train, X_test, y_train, y_test = logistic.preprocess_data(X, y)
     
209.     # X_train, X_test, y_train, y_test = logistic.train_test_split(X, y)
     
210.     # X_train, X_test = logistic.standardization([X_train, X_test])
     
211.     # print(X_train)
     
212.     # print(X_test)
     
213. 
     
214.     # 训练模型
     
215.     logistic.fit(X_train, y_train)
     
216. 
     
217.     # # 查看对数似然损失
     
218.     print(logistic.mean_cost)
     
219.     print(logistic.coef)
     
220.     print(logistic.intercept)
     
221. 
     
222.     y_predict = logistic.predict(X_test)
     
223.     print('预测分类结果为：', y_predict.flatten())
     
224.     print('实际分类结果为：', y_test.flatten())
     
225.     print('预测准确率为：', logistic.score(X_test, y_test))

复制代码

代码部分的注释较为详细，如代码部分有疑问，可评论交流共同进步。如有鱼油难以理解，可能需要先了解数学概念（如线性代数部分的矩阵和行列式运算，导数和方向导数以及范数和最大似然估计值的基本概念），这里不做解释。推荐阅读相应经典数据--教科书！