0
0

【机器学习】决策边界的基本概念以及如何在逻辑回归中找到决策边界

引言

在机器学习中，决策边界是分类算法用来区分不同类别数据点的线、面或超平面。这些边界通常是模型的预测规则，用于将特征空间中的点分配到不同的类别。决策边界可以是线性的，也可以是非线性的，取决于数据的分布和所使用的分类算法

文章目录

一、决策边界的例子

1.1 线性分类器

如线性回归、逻辑回归、支持向量机（SVM）等，它们使用线性边界。例如，在二维空间中，线性边界是一条直线；在三维空间中，它是一个平面。

1.1 非线性分类器

如决策树、随机森林、神经网络等，它们可以学习到复杂的非线性边界。在二维空间中，这可能是一个曲线；在三维空间中，可能是一个曲面。

二、决策边界的作用

决策边界是模型解释性和可视化的重要组成部分。通过绘制决策边界，我们可以直观地看到模型是如何将数据分为不同类别的。这对于理解模型的行为、发现潜在的错误分类模式以及验证模型的假设都是非常有帮助的

三、绘制决策边界

在绘制决策边界时，通常需要考虑以下几个步骤：

3.1 选择特征

确定哪些特征对分类至关重要

3.2 选择或计算边界

对于线性分类器，这通常是简单计算得到的；对于非线性分类器，可能需要使用训练数据来估计

3.3 绘制边界

在特征空间中绘制决策边界，通常在二维或三维空间中进行

3.4 标记数据点

将不同类别的数据点用不同的符号或颜色标记

四、决策边界的优缺点

4.1 优点

决策边界直观地展示了模型的分类能力，有助于理解和验证模型的假设

4.2 缺点

决策边界可能过于简化，无法准确反映数据的复杂性。此外，决策边界可能不是唯一的，不同的特征选择或参数设置可能导致不同的边界

五、决策边界的应用

决策边界在许多领域都有应用，例如图像识别、文本分类、医学诊断等。通过绘制决策边界，可以更好地理解模型的工作原理，并指导模型的改进和优化

六、逻辑回归中的决策边界

6.1 目标

绘制逻辑回归模型的决策边界。这将帮助更好地理解模型正在预测什么

6.2 导入numpy、matplotlib库

  1. import numpy as np
  2. %matplotlib widget
  3. import matplotlib.pyplot as plt
  4. from lab_utils_common import plot_data, sigmoid, draw_vthresh
  5. plt.style.use('./deeplearning.mplstyle')

6.3 数据集

假设有以下训练数据集

  • 输入变量 X X X是一个NumPy数组，包含6个训练示例，每个示例都有两个特征
  • 输出变量 y y y也是一个NumPy数组，包含6个示例，y要么是0要么是1
  1. X = np.array([[0.5,1.5],[1,1],[1.5,0.5],[3,0.5],[2,2],[1,2.5]])
  2. y = np.array([0,0,0,1,1,1]).reshape(-1,1)

6.4 绘制数据

使用辅助函数来绘制这些数据。标签为𝑦=1的数据点用红色十字表示，而标签为𝑦=0的数据点用蓝色圆圈表示。

  1. fig,ax = plt.subplots(1,1,figsize=(4,4))
  2. plot_data(X, y, ax)
  3. ax.axis([0,4,0,3.5])
  4. ax.set_ylabel('$x_1$')
  5. ax.set_xlabel('$x_0$')
  6. plt.show()

输出结果：
在这里插入图片描述

6.5 逻辑回归模型

  • 假设想在这个数据上训练一个逻辑回归模型，该模型具有以下形式 f ( x ) = g ( w 0 x 0 + w 1 x 1 + b ) f(x) = g(w_0x_0+w_1x_1 + b) f(x)=g(w0​x0​+w1​x1​+b) 其中 g ( z ) = 1 1 + e − z g(z) = \frac{1}{1+e^{-z}} g(z)=1+e−z1​，这是Sigmoid函数
  • 假设已经训练了模型，并得到了参数 b = − 3 , w 0 = 1 , w 1 = 1 b = -3, w_0 = 1, w_1 = 1 b=−3,w0​=1,w1​=1。也就是说， f ( x ) = g ( x 0 + x 1 − 3 ) f(x) = g(x_0+x_1-3) f(x)=g(x0​+x1​−3) 让我们通过绘制其决策边界来尝试理解这个训练好的模型正在预测什么

6.6 复习逻辑回归和决策边界

回想一下，对于逻辑回归，模型可以表示为

  1.           f 
  2.          
  3.          
  4.          
  5.            w 
  6.           
  7.          
  8.            , 
  9.           
  10.          
  11.            b 
  12.           
  13.          
  14.         
  15.        
  16.          ( 
  17.         
  18.         
  19.         
  20.           x 
  21.          
  22.          
  23.          
  24.            ( 
  25.           
  26.          
  27.            i 
  28.           
  29.          
  30.            ) 
  31.           
  32.          
  33.         
  34.        
  35.          ) 
  36.         
  37.        
  38.          = 
  39.         
  40.        
  41.          g 
  42.         
  43.        
  44.          ( 
  45.         
  46.        
  47.          w 
  48.         
  49.        
  50.          ⋅ 
  51.         
  52.         
  53.         
  54.           x 
  55.          
  56.          
  57.          
  58.            ( 
  59.           
  60.          
  61.            i 
  62.           
  63.          
  64.            ) 
  65.           
  66.          
  67.         
  68.        
  69.          + 
  70.         
  71.        
  72.          b 
  73.         
  74.        
  75.          ) 
  76.         
  77.        
  78.       
  79.       
  80.       
  81.       
  82.         (1) 
  83.        
  84.       
  85.      
  86.     
  87.    
  88.      f_{\mathbf{w},b}(\mathbf{x}^{(i)}) = g(\mathbf{w} \cdot \mathbf{x}^{(i)} + b) \tag{1} 
  89.     
  90.    
  91.  fw,b​(x(i))=g(w⋅x(i)+b)(1)

其中 

  1.      g 
  2.     
  3.    
  4.      ( 
  5.     
  6.    
  7.      z 
  8.     
  9.    
  10.      ) 
  11.     
  12.    
  13.   
  14.     g(z) 
  15.    
  16.   
  17. g(z)称为
  1. Sigmoid

函数，它将所有输入值映射到0和1之间： 

  1.      g 
  2.     
  3.    
  4.      ( 
  5.     
  6.    
  7.      z 
  8.     
  9.    
  10.      ) 
  11.     
  12.    
  13.      = 
  14.     
  15.     
  16.     
  17.       1 
  18.      
  19.      
  20.      
  21.        1 
  22.       
  23.      
  24.        + 
  25.       
  26.       
  27.       
  28.         e 
  29.        
  30.        
  31.        
  32.          − 
  33.         
  34.        
  35.          z 
  36.         
  37.        
  38.       
  39.      
  40.     
  41.    
  42.   
  43.     g(z) = \frac{1}{1+e^{-z}} 
  44.    
  45.   
  46. g(z)=1+e−z1​

并且 

  1.      w 
  2.     
  3.    
  4.      ⋅ 
  5.     
  6.    
  7.      x 
  8.     
  9.    
  10.   
  11.     \mathbf{w} \cdot \mathbf{x} 
  12.    
  13.   
  14. w⋅x是向量点积：
  16.   
  17.    
  18.     
  19.     
  20.       w 
  21.      
  22.     
  23.       ⋅ 
  24.      
  25.     
  26.       x 
  27.      
  28.     
  29.       = 
  30.      
  31.      
  32.      
  33.        w 
  34.       
  35.      
  36.        0 
  37.       
  38.      
  39.      
  40.      
  41.        x 
  42.       
  43.      
  44.        0 
  45.       
  46.      
  47.     
  48.       + 
  49.      
  50.      
  51.      
  52.        w 
  53.       
  54.      
  55.        1 
  56.       
  57.      
  58.      
  59.      
  60.        x 
  61.       
  62.      
  63.        1 
  64.       
  65.      
  66.     
  67.    
  68.      \mathbf{w} \cdot \mathbf{x} = w_0 x_0 + w_1 x_1 
  69.     
  70.    
  71.  w⋅x=w0​x0​+w1​x1​

我们将模型的输出（ 

  1.       f 
  2.      
  3.      
  4.      
  5.        w 
  6.       
  7.      
  8.        , 
  9.       
  10.      
  11.        b 
  12.       
  13.      
  14.     
  15.    
  16.      ( 
  17.     
  18.    
  19.      x 
  20.     
  21.    
  22.      ) 
  23.     
  24.    
  25.   
  26.     f_{\mathbf{w},b}(x) 
  27.    
  28.   
  29. fw,b​(x)）解释为给定𝑥和参数𝑤、𝑏时，𝑦=1的概率

因此，要从逻辑回归模型中得到最终的预测（𝑦=0或𝑦=1），我们可以使用以下启发式方法：

  • 如果 𝑓𝐰,𝑏(𝑥)>=0.5，预测𝑦=1
  • 如果 𝑓𝐰,𝑏(𝑥)<0.5，预测𝑦=0 让我们绘制Sigmoid函数，看看𝑔(𝑧)>=0.5的地方在哪里
  1. # 在-10到10的范围内绘制Sigmoid(z)
  2. z = np.arange(-10,11)
  4. fig,ax = plt.subplots(1,1,figsize=(5,3))# 绘制z vs sigmoid(z)
  5. ax.plot(z, sigmoid(z), c="b")
  7. ax.set_title("Sigmoid function")
  8. ax.set_ylabel('sigmoid(z)')
  9. ax.set_xlabel('z')
  10. draw_vthresh(ax,0)

输出结果：
在这里插入图片描述

  1.      g 
  2.     
  3.    
  4.      ( 
  5.     
  6.    
  7.      z 
  8.     
  9.    
  10.      ) 
  11.     
  12.    
  13.      > 
  14.     
  15.    
  16.      = 
  17.     
  18.    
  19.      0.5 
  20.     
  21.    
  22.   
  23.     g(z) >= 0.5 
  24.    
  25.   
  26. g(z)>=0.5的时候， 
  27.  
  28.   
  29.    
  30.    
  31.      z 
  32.     
  33.    
  34.      > 
  35.     
  36.    
  37.      = 
  38.     
  39.    
  40.      0 
  41.     
  42.    
  43.   
  44.     z >=0 
  45.    
  46.   
  47. z>=0

对于逻辑回归模型， 

  1.      z 
  2.     
  3.    
  4.      = 
  5.     
  6.    
  7.      w 
  8.     
  9.    
  10.      ⋅ 
  11.     
  12.    
  13.      x 
  14.     
  15.    
  16.      + 
  17.     
  18.    
  19.      b 
  20.     
  21.    
  22.   
  23.     z = \mathbf{w} \cdot \mathbf{x} + b 
  24.    
  25.   
  26. z=w⋅x+b
  • 如果 𝐰⋅𝐱+𝑏>=0，模型预测 𝑦=1
  • 如果 𝐰⋅𝐱+𝑏<0，模型预测 𝑦=0

6.7 绘制决策边界

现在，让我们回到我们的例子，以了解逻辑回归模型是如何做出预测的
我们的逻辑回归模型具有以下形式 

  1.      f 
  2.     
  3.    
  4.      ( 
  5.     
  6.    
  7.      x 
  8.     
  9.    
  10.      ) 
  11.     
  12.    
  13.      = 
  14.     
  15.    
  16.      g 
  17.     
  18.    
  19.      ( 
  20.     
  21.    
  22.      − 
  23.     
  24.    
  25.      3 
  26.     
  27.    
  28.      + 
  29.     
  30.     
  31.     
  32.       x 
  33.      
  34.     
  35.       0 
  36.      
  37.     
  38.    
  39.      + 
  40.     
  41.     
  42.     
  43.       x 
  44.      
  45.     
  46.       1 
  47.      
  48.     
  49.    
  50.      ) 
  51.     
  52.    
  53.   
  54.     f(x) = g(-3 + x_0+x_1) 
  55.    
  56.   
  57. f(x)=g(−3+x0​+x1​)

从您刚才学到的知识中，您可以看到，这个模型预测 𝑦=1，如果 

  1.      − 
  2.     
  3.    
  4.      3 
  5.     
  6.    
  7.      + 
  8.     
  9.     
  10.     
  11.       x 
  12.      
  13.     
  14.       0 
  15.      
  16.     
  17.    
  18.      + 
  19.     
  20.     
  21.     
  22.       x 
  23.      
  24.     
  25.       1 
  26.      
  27.     
  28.    
  29.      > 
  30.     
  31.    
  32.      = 
  33.     
  34.    
  35.      0 
  36.     
  37.    
  38.   
  39.     -3 + x_0+x_1 >= 0 
  40.    
  41.   
  42. −3+x0​+x1​>=0

让我们看看这图形上是什么样子。我们将开始绘制 

  1.      − 
  2.     
  3.    
  4.      3 
  5.     
  6.    
  7.      + 
  8.     
  9.     
  10.     
  11.       x 
  12.      
  13.     
  14.       0 
  15.      
  16.     
  17.    
  18.      + 
  19.     
  20.     
  21.     
  22.       x 
  23.      
  24.     
  25.       1 
  26.      
  27.     
  28.    
  29.      = 
  30.     
  31.    
  32.      0 
  33.     
  34.    
  35.   
  36.     -3 + x_0+x_1 = 0 
  37.    
  38.   
  39. −3+x0​+x1​=0，这相当于 
  40.  
  41.   
  42.    
  43.     
  44.     
  45.       x 
  46.      
  47.     
  48.       1 
  49.      
  50.     
  51.    
  52.      = 
  53.     
  54.    
  55.      3 
  56.     
  57.    
  58.      − 
  59.     
  60.     
  61.     
  62.       x 
  63.      
  64.     
  65.       0 
  66.      
  67.     
  68.    
  69.   
  70.     x_1 = 3 - x_0 
  71.    
  72.   
  73. x1​=3−x0​
  1. # 在0到6之间选择值
  2. x0 = np.arange(0,6)
  3. x1 =3- x0
  4. fig,ax = plt.subplots(1,1,figsize=(5,4))# 绘制决策边界
  5. ax.plot(x0,x1, c="b")
  6. ax.axis([0,4,0,3.5])# 填充线的下方区域
  7. ax.fill_between(x0,x1, alpha=0.2)# 绘制原始数据
  8. plot_data(X,y,ax)
  9. ax.set_ylabel(r'$x_1$')
  10. ax.set_xlabel(r'$x_0$')
  11. plt.show()

输出结果：
在这里插入图片描述

在上面的图中，蓝色线代表 

  1.       x 
  2.      
  3.     
  4.       0 
  5.      
  6.     
  7.    
  8.      + 
  9.     
  10.     
  11.     
  12.       x 
  13.      
  14.     
  15.       1 
  16.      
  17.     
  18.    
  19.      − 
  20.     
  21.    
  22.      3 
  23.     
  24.    
  25.      = 
  26.     
  27.    
  28.      0 
  29.     
  30.    
  31.   
  32.     x_0 + x_1 - 3 = 0 
  33.    
  34.   
  35. x0​+x1​−3=0，它应该在 
  36.  
  37.   
  38.    
  39.    
  40.      x 
  41.     
  42.    
  43.      1 
  44.     
  45.    
  46.   
  47.     x1 
  48.    
  49.   
  50. x1轴上与3相交（如果我们设置 
  51.  
  52.   
  53.    
  54.    
  55.      x 
  56.     
  57.    
  58.      1 
  59.     
  60.    
  61.   
  62.     x1 
  63.    
  64.   
  65. x1= 3，  
  66.  
  67.   
  68.    
  69.    
  70.      x 
  71.     
  72.    
  73.      0 
  74.     
  75.    
  76.   
  77.     x0 
  78.    
  79.   
  80. x0= 0），在 
  81.  
  82.   
  83.    
  84.    
  85.      x 
  86.     
  87.    
  88.      0 
  89.     
  90.    
  91.   
  92.     x0 
  93.    
  94.   
  95. x0轴上与3相交

阴影区域代表 

  1.      − 
  2.     
  3.    
  4.      3 
  5.     
  6.    
  7.      + 
  8.     
  9.     
  10.     
  11.       x 
  12.      
  13.     
  14.       0 
  15.      
  16.     
  17.    
  18.      + 
  19.     
  20.     
  21.     
  22.       x 
  23.      
  24.     
  25.       1 
  26.      
  27.     
  28.    
  29.      < 
  30.     
  31.    
  32.      0 
  33.     
  34.    
  35.   
  36.     -3 + x_0+x_1 < 0 
  37.    
  38.   
  39. −3+x0​+x1​<0，线上面的区域是 
  40.  
  41.   
  42.    
  43.    
  44.      − 
  45.     
  46.    
  47.      3 
  48.     
  49.    
  50.      + 
  51.     
  52.     
  53.     
  54.       x 
  55.      
  56.     
  57.       0 
  58.      
  59.     
  60.    
  61.      + 
  62.     
  63.     
  64.     
  65.       x 
  66.      
  67.     
  68.       1 
  69.      
  70.     
  71.    
  72.      > 
  73.     
  74.    
  75.      0 
  76.     
  77.    
  78.   
  79.     −3 +x_0+x_1>0 
  80.    
  81.   
  82. −3+x0​+x1​>0，任何位于阴影区域（在线之下）的点都被分类为 𝑦=0，任何位于或高于线的点都被分类为 𝑦=1，这条线被称为“决策边界”

通过使用更高阶的多项式项（例如：𝑓(𝑥)=𝑔(𝑥20+𝑥1−1)，我们可以得到更复杂的非线性边界

6.8 总结

  • 探索逻辑回归中的决策边界
  • 学习如何在逻辑回归中找到决策边界
标签： 机器学习 逻辑回归 人工智能
本文转载自: https://blog.csdn.net/m0_49243785/article/details/140802010
版权归原作者 Lossya 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【机器学习】决策边界的基本概念以及如何在逻辑回归中找到决策边界”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？