一文读懂什么是逻辑回归

逻辑回归介绍

逻辑回归（Logistic Regression）是一种经典的分类算法，尽管名字中带有 “回归”，但它本质上用于解决二分类问题（也可扩展到多分类）。逻辑回归的本质是 “在线性回归的基础上，通过一个映射函数将输出转化为概率（从而实现对类别概率的预测）”，这个映射函数就是Sigmoid函数。
逻辑回归是机器学习中最基础的分类算法之一，核心是通过 Sigmoid 函数将线性输出转化为概率，结合交叉熵损失和梯度下降求解参数。
它虽简单，但在实际业务中（尤其是需要可解释性的场景）仍被广泛使用，也是理解更复杂分类模型（如神经网络）的基础。

sigmoid函数

1. def sigmoid(z):
2.     """
3.     Compute the sigmoid of z
5.     Args:
6.         z (ndarray): A scalar, numpy array of any size.
8.     Returns:
9.         g (ndarray): sigmoid(z), with the same shape as z
10.          
11.     """
13.     g = 1 / (1 + np.exp(-z))
14.    
15.     return g

复制代码

逻辑回归模型

逻辑回归的决策边界

线性逻辑回归

根据sigmoid函数图象：z=0是中间位置，视为决策边界；那么为了得到决策边界的特征情况，我们假设：

• 线性模型 z = w1 * x1 + w2 * x2 + b
  
• 参数 w1=w2=1, b=03，那么x2 = -x1 + 3这条直线就是决策边界
  

如果特征x在这条线的右边，那么此逻辑回归则预测为1，反之则预测为0；（分为两类）

多项式逻辑回归

多项式回归决策边界，我们假设：

• 多项式模型：z = w1 * x1**2 + w2 * x2**2 + b
  
• 参数：w1=w2=1, b=-1
  

如果特征x在圆的外面，那么此逻辑回归则预测为1，反之则预测为0；（分为两类）

扩展：随着多项式的复杂度增加，还可以拟合更更多非线性的复杂情况

逻辑回归的损失函数

平方损失和交叉熵损失

回顾下线性回归的损失函数（平方损失）：

平方误差损失函数不适用于逻辑回归模型：平方损失在逻辑回归中是 “非凸函数”（存在多个局部最优解），难以优化；

所以我们需要一个新的损失函数，即交叉熵损失；交叉熵损失是 “凸函数”，可通过梯度下降高效找到全局最优。
交叉熵源于信息论，我们暂时不做深入介绍，直接给出交叉熵损失函数公式：

对数回顾

复习下对数函数的性质，以便理解为什么 交叉熵损失是 “凸函数”？

简化交叉熵损失函数

为什么要用这个函数来表示？来源自 最大释然估计（Maximum Likelihood），这里不做过多介绍。

简化结果：

逻辑回归的梯度计算

自然对数求导公式：

 链式求导法则：

⚠️注意：

过拟合问题

线性回归过拟合

逻辑回归过拟合

• 欠拟合（underfit），存在高偏差（bias）
  
• 泛化（generalization）：希望我们的学习算法在训练集之外的数据上也能表现良好（预测准确）
  
• 过拟合（overfit），存在高方差（variance） 
  

解决过拟合的办法

• 特征选择：只选择部分最相关的特征（基于直觉intuition）进行训练；缺点是丢掉了部分可能有用的信息
  
• 正则化：正则化是一种更温和的减少某些特征的影响，而无需做像测地消除它那样苛刻的事：
  
  
  
  • 鼓励学习算法缩小参数，而不是直接将参数设置为0（保留所有特征的同时避免让部分特征产生过大的影响）
    
  • 鼓励把 w1 ~ wn 变小，b不用变小 
    
  
  

正则化模型

It turns out that regularization is a way
to more gently reduce ths impacts of some of the features without doing something as harsh as eliminating it outright.

关于正则化项的说明：

带正则化项的损失函数

正则化线性回归

损失函数：

梯度计算：

 
分析梯度计算公式，由于alpha和lambda通常是很小的值，所以相当于在每次迭代之前把参数w缩小了一点点，这也就是正则化的工作原理，如下所示：

正则化逻辑回归

损失函数：

梯度计算：

线性回归和逻辑回归正则化总结

 
逻辑回归实战

模型选择

可视化训练数据，基于此数据选择线性逻辑回归模型

关键代码实现

1. def sigmoid(z):
2.         g = 1 / (1 + np.exp(-z))
3.         return g
5. def compute_cost(X, y, w, b, lambda_= 1):
6.         """
7.     Computes the cost over all examples
8.     Args:
9.       X : (ndarray Shape (m,n)) data, m examples by n features
10.       y : (array_like Shape (m,)) target value
11.       w : (array_like Shape (n,)) Values of parameters of the model      
12.       b : scalar Values of bias parameter of the model
13.       lambda_: unused placeholder
14.     Returns:
15.       total_cost: (scalar)         cost
16.     """
18.         m, n = X.shape
19.         total_cost = 0
20.         for i in range(m):
21.                 f_wb_i = sigmoid(np.dot(X[i], w) + b)
22.                 loss = -y[i] * np.log(f_wb_i) - (1 - y[i]) * np.log(1 - f_wb_i)
23.                 total_cost += loss
25.         total_cost = total_cost / m
26.         return total_cost
28. def compute_gradient(X, y, w, b, lambda_=None):
29.     """
30.     Computes the gradient for logistic regression
32.     Args:
33.       X : (ndarray Shape (m,n)) variable such as house size
34.       y : (array_like Shape (m,1)) actual value
35.       w : (array_like Shape (n,1)) values of parameters of the model      
36.       b : (scalar)                 value of parameter of the model
37.       lambda_: unused placeholder.
38.     Returns
39.       dj_dw: (array_like Shape (n,1)) The gradient of the cost w.r.t. the parameters w.
40.       dj_db: (scalar)                The gradient of the cost w.r.t. the parameter b.
41.     """
42.     m, n = X.shape
43.     dj_dw = np.zeros(n)
44.     dj_db = 0.
46.     for i in range(m):
47.         f_wb_i = sigmoid(np.dot(X[i], w) + b)
48.         diff = f_wb_i - y[i]
49.         dj_db += diff
50.         for j in range(n):
51.             dj_dw[j] = dj_dw[j] + diff * X[i][j]
52.    
53.     dj_db = dj_db / m
54.     dj_dw = dj_dw / m
55.         
56.     return dj_db, dj_dw
58. def gradient_descent(X, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters, lambda_):
59.     """
60.     Performs batch gradient descent to learn theta. Updates theta by taking
61.     num_iters gradient steps with learning rate alpha
62.    
63.     Args:
64.       X :    (array_like Shape (m, n)
65.       y :    (array_like Shape (m,))
66.       w_in : (array_like Shape (n,))  Initial values of parameters of the model
67.       b_in : (scalar)                 Initial value of parameter of the model
68.       cost_function:                  function to compute cost
69.       alpha : (float)                 Learning rate
70.       num_iters : (int)               number of iterations to run gradient descent
71.       lambda_ (scalar, float)         regularization constant
72.       
73.     Returns:
74.       w : (array_like Shape (n,)) Updated values of parameters of the model after
75.           running gradient descent
76.       b : (scalar)                Updated value of parameter of the model after
77.           running gradient descent
78.     """
79.    
80.     # number of training examples
81.     m = len(X)
82.    
83.     # An array to store cost J and w's at each iteration primarily for graphing later
84.     J_history = []
85.     w_history = []
87.     w = copy.deepcopy(w_in)
88.     b = b_in
89.    
90.     for i in range(num_iters):
91.         dj_db, dj_dw = gradient_function(X, y, w, b, lambda_)
92.         w = w - alpha * dj_dw
93.         b = b - alpha * dj_db
94.         cost = cost_function(X, y, w, b, lambda_)
95.         J_history.append(cost)
96.         w_history.append(w)
97.         if i % math.ceil(num_iters / 10) == 0:
98.             print(f"{i:4d} cost: {cost:6f}, w: {w}, b: {b}")
99.         
100.     return w, b, J_history, w_history #return w and J,w history for graphing
103. def predict(X, w, b):
104.     m, n = X.shape   
105.     p = np.zeros(m)
106.     for i in range(m):
107.         f_wb = sigmoid(np.dot(X[i], w) + b)
108.         p[i] = f_wb >= 0.5
109.     return p

复制代码

结果展示

1. import numpy as np
2. import matplotlib.pyplot as plt
3. import matplotlib.font_manager as fm
4. # 支持显示中文
5. font_path = '/System/Library/Fonts/STHeiti Light.ttc'
6. custom_font = fm.FontProperties(fname=font_path)
7. plt.rcParams["font.family"] = custom_font.get_name()
9. # 载入训练集
10. X_train, y_train = load_data("data/ex2data1.txt")
11. # 训练模型
12. np.random.seed(1)
13. intial_w = 0.01 * (np.random.rand(2).reshape(-1,1) - 0.5)
14. initial_b = -8
15. iterations = 10000
16. alpha = 0.001
17. w_out, b_out, J_history,_ = gradient_descent(X_train ,y_train, initial_w, initial_b, compute_cost, compute_gradient, alpha, iterations, 0)
19. # 根据训练结果（w_out和b_out）计算决策边界
20. #f = w0*x0 + w1*x1 + b
21. # x1 = -1 * (w0*x0 + b) / w1
22. plot_x = np.array([min(X_train[:, 0]), max(X_train[:, 0])])
23. plot_y = (-1. / w_out[1]) * (w_out[0] * plot_x + b_out)
24. # 将训练数据分类
25. x0s_pos = []
26. x1s_pos = []
27. x0s_neg = []
28. x1s_neg = []
29. for i in range(len(X_train)):
30.     x = X_train[i]
31.     # print(x)
32.     y_i = y_train[i]
33.     if y_i == 1:
34.         x0s_pos.append(x[0])
35.         x1s_pos.append(x[1])
36.     else:
37.         x0s_neg.append(x[0])
38.         x1s_neg.append(x[1])
40. # 绘图
41. plt.figure(figsize=(8, 6))
42. plt.scatter(x0s_pos, x1s_pos, marker='o', c='green', label="Admitted")
43. plt.scatter(x0s_neg, x1s_neg, marker='x', c='red', label="Not admitted")
44. plt.plot(plot_x, plot_y, lw=1, label="决策边界")
45. plt.xlabel('Exam 1 score', fontsize=12)
46. plt.ylabel('Exam 2 score', fontsize=12)
47. plt.title('在二维平面上可视化分类模型的决策边界', fontsize=14)
48. plt.legend(fontsize=12, loc='upper center')
49. plt.grid(True)
50. plt.show()
53. # 使用训练集计算预测准确率
54. p = predict(X_train, w_out, b_out)
55. print('Train Accuracy: %f'%(np.mean(p == y_train) * 100))
56. # Train Accuracy: 92.000000

复制代码

正则化逻辑回归实战

模型选择

可视化训练数据，基于此数据选择多项式逻辑回归模型
 

关键代码实现

由于要拟合非线性决策边界，所以要增加特征的复杂度（训练数据里只有2个特征）。
特征映射函数

1. # 将输入特征 X1 和 X2 转换为六次多项式特征
2. # 这个函数常用于逻辑回归或支持向量机等模型中，通过增加特征的复杂度来拟合非线性决策边界。
3. def map_feature(X1, X2):
4.     """
5.     Feature mapping function to polynomial features   
6.     """
7.     X1 = np.atleast_1d(X1)
8.     X2 = np.atleast_1d(X2)
9.     degree = 6
10.     out = []
11.     for i in range(1, degree+1):
12.         for j in range(i + 1):
13.             out.append((X1**(i-j) * (X2**j)))
14.     return np.stack(out, axis=1)

复制代码

正则化后的损失函数和梯度计算函数

1. def compute_cost_reg(X, y, w, b, lambda_ = 1):
2.     """
3.     Computes the cost over all examples
4.     Args:
5.       X : (array_like Shape (m,n)) data, m examples by n features
6.       y : (array_like Shape (m,)) target value
7.       w : (array_like Shape (n,)) Values of parameters of the model      
8.       b : (array_like Shape (n,)) Values of bias parameter of the model
9.       lambda_ : (scalar, float)    Controls amount of regularization
10.     Returns:
11.       total_cost: (scalar)         cost
12.     """
13.     m, n = X.shape
14.     # Calls the compute_cost function that you implemented above
15.     cost_without_reg = compute_cost(X, y, w, b)
16.    
17.     reg_cost = 0.
18.     for j in range(n):
19.         reg_cost += w[j]**2
20.    
21.     # Add the regularization cost to get the total cost
22.     total_cost = cost_without_reg + (lambda_/(2 * m)) * reg_cost
24.     return total_cost
26. def compute_gradient_reg(X, y, w, b, lambda_ = 1):
27.     """
28.     Computes the gradient for linear regression
30.     Args:
31.       X : (ndarray Shape (m,n))   variable such as house size
32.       y : (ndarray Shape (m,))    actual value
33.       w : (ndarray Shape (n,))    values of parameters of the model      
34.       b : (scalar)                value of parameter of the model  
35.       lambda_ : (scalar,float)    regularization constant
36.     Returns
37.       dj_db: (scalar)             The gradient of the cost w.r.t. the parameter b.
38.       dj_dw: (ndarray Shape (n,)) The gradient of the cost w.r.t. the parameters w.
40.     """
41.     m, n = X.shape
42.    
43.     dj_db, dj_dw = compute_gradient(X, y, w, b)
45.     # Add the regularization
46.     for j in range(n):
47.         dj_dw[j] += (lambda_ / m) * w[j]
48.         
49.     return dj_db, dj_dw

复制代码

结果展示

1. import numpy as np
2. import matplotlib.pyplot as plt
3. import matplotlib.font_manager as fm
4. # 支持显示中文
5. font_path = '/System/Library/Fonts/STHeiti Light.ttc'
6. custom_font = fm.FontProperties(fname=font_path)
7. plt.rcParams["font.family"] = custom_font.get_name()
9. # 载入训练集
10. X_train, y_train = load_data("data/ex2data2.txt")
11. # 通过增加特征的复杂度来拟合非线性决策边界
12. X_mapped = map_feature(X_train[:, 0], X_train[:, 1])
13. print("Original shape of data:", X_train.shape)
14. print("Shape after feature mapping:", X_mapped.shape)
16. # 训练模型
17. np.random.seed(1)
18. initial_w = np.random.rand(X_mapped.shape[1])-0.5
19. initial_b = 1.
20. # Set regularization parameter lambda_ to 1 (you can try varying this)
21. lambda_ = 0.5
22. iterations = 10000
23. alpha = 0.01
24. w_out, b_out, J_history, _ = gradient_descent(X_mapped, y_train, initial_w, initial_b, compute_cost_reg, compute_gradient_reg, alpha, iterations, lambda_)
26. # 根据训练结果（w_out和b_out）计算决策边界
27. # - 创建网格点 u 和 v 覆盖特征空间
28. u = np.linspace(-1, 1.5, 50)
29. v = np.linspace(-1, 1.5, 50)
30. # - 计算每个网格点处的预测概率 z
31. z = np.zeros((len(u), len(v)))
32. # Evaluate z = theta*x over the grid
33. for i in range(len(u)):
34.     for j in range(len(v)):
35.         z[i,j] = sig(np.dot(map_feature(u[i], v[j]), w_out) + b_out)
36. # - 转置 z 是必要的，因为contour函数期望的输入格式与我们的计算顺序不一致      
37. z = z.T
39. # 分类
40. x0s_pos = []
41. x1s_pos = []
42. x0s_neg = []
43. x1s_neg = []
44. for i in range(len(X_train)):
45.     x = X_train[i]
46.     # print(x)
47.     y_i = y_train[i]
48.     if y_i == 1:
49.         x0s_pos.append(x[0])
50.         x1s_pos.append(x[1])
51.     else:
52.         x0s_neg.append(x[0])
53.         x1s_neg.append(x[1])
55. # 绘图
56. plt.figure(figsize=(8, 6))
57. plt.scatter(x0s_pos, x1s_pos, marker='o', c='black', label="y=1")
58. plt.scatter(x0s_neg, x1s_neg, marker='x', c='orange', label="y=0")
59. # 绘制决策边界（等高线）
60. plt.contour(u,v,z, levels = [0.5], colors="green")
61. # 创建虚拟线条用于图例（颜色和线型需与等高线一致）
62. plt.plot([], [], color='green', label="决策边界")
64. plt.xlabel('Test 1', fontsize=12)
65. plt.ylabel('Test 2', fontsize=12)
66. plt.title('正则化逻辑回归模型分类效果可视化（lambda=0.5）', fontsize=14)
67. # plt.legend(fontsize=12, loc='upper center')
68. plt.legend(fontsize=12)
69. plt.grid(True)
70. plt.show()
73. #Compute accuracy on the training set
74. p = predict(X_mapped, w_out, b_out)
75. print('Train Accuracy: %f'%(np.mean(p == y_train) * 100))
76. # Train Accuracy: 83.050847

复制代码

正则化效果对比

正则化对损失和决策边界的影响

正则化项lambda参数大小对决策边界的影响

 
参考

吴恩达团队在Coursera开设的机器学习课程：https://www.coursera.org/specializations/machine-learning-introduction
在B站学习：https://www.bilibili.com/video/BV1Pa411X76s 
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！