0
0

从简单逻辑到复杂计算：感知机的进化与其在现代深度学习和人工智能中的应用（上）

文章目录

文章文上下两节

  • 从简单逻辑到复杂计算：感知机的进化与其在现代深度学习和人工智能中的应用（上）
  • 从简单逻辑到复杂计算：感知机的进化与其在现代深度学习和人工智能中的应用（下）

引言

在本章中，我们将深入探讨感知机，这是一个由美国学者Frank Rosenblatt于1957年提出的算法。尽管感知机的概念历史悠久，但它仍然在现代计算和机器学习领域占据着基础性的重要地位。感知机不仅是神经网络和深度学习的原型，而且其设计原理和运作机制为理解更复杂的神经网络模型提供了关键的基础。通过介绍感知机的基本构造和功能，以及如何利用它来解决一些简单的逻辑问题，帮助读者建立对这一经典算法的初步理解。通过学习感知机，我们可以更好地洞察神经网络的核心思想和深度学习的基础结构，为进一步的学习和研究奠定坚实的基础。

第一章：感知机是什么

感知机是一种基本的人工神经网络，被设计成能模拟人类神经元的基本功能。它接收多个输入信号，这些信号可以被想象为具有"流动性"的东西，如电流或数据流。在感知机中，这些输入信号经过加权后，如果加权和超过了某个阈值，则输出一个信号。这种输出通常是二进制的，即"流/不流"（1/0）的形式。

下图展示了一个包含两个输入的基本感知机模型。输入 

  1.       x 
  2.      
  3.     
  4.       1 
  5.      
  6.     
  7.    
  8.   
  9.     x_1 
  10.    
  11.   
  12. x1​ 和  
  13.  
  14.   
  15.    
  16.     
  17.     
  18.       x 
  19.      
  20.     
  21.       2 
  22.      
  23.     
  24.    
  25.   
  26.     x_2 
  27.    
  28.   
  29. x2​ 通过各自的权重  
  30.  
  31.   
  32.    
  33.     
  34.     
  35.       w 
  36.      
  37.     
  38.       1 
  39.      
  40.     
  41.    
  42.   
  43.     w_1 
  44.    
  45.   
  46. w1​ 和  
  47.  
  48.   
  49.    
  50.     
  51.     
  52.       w 
  53.      
  54.     
  55.       2 
  56.      
  57.     
  58.    
  59.   
  60.     w_2 
  61.    
  62.   
  63. w2​ 与输出  
  64.  
  65.   
  66.    
  67.    
  68.      y 
  69.     
  70.    
  71.   
  72.     y 
  73.    
  74.   
  75. y 相连。这些权重决定了各自输入对输出的贡献。在感知机中，这些输入信号被加权和计算，并与一个固定的阈值  
  76.  
  77.   
  78.    
  79.    
  80.      θ 
  81.     
  82.    
  83.   
  84.     \theta 
  85.    
  86.   
  87. θ 比较，这个比较的结果决定输出  
  88.  
  89.   
  90.    
  91.    
  92.      y 
  93.     
  94.    
  95.   
  96.     y 
  97.    
  98.   
  99. y 的状态。

在这里插入图片描述

感知机的行为可以通过以下数学公式来表示：

  1.       y 
  2.      
  3.     
  4.       = 
  5.      
  6.      
  7.      
  8.        { 
  9.       
  10.       
  11.        
  12.         
  13.          
  14.          
  15.            0 
  16.           
  17.          
  18.         
  19.         
  20.          
  21.           
  22.           
  23.             if  
  24.            
  25.           
  26.             ( 
  27.            
  28.            
  29.            
  30.              w 
  31.             
  32.            
  33.              1 
  34.             
  35.            
  36.            
  37.            
  38.              x 
  39.             
  40.            
  41.              1 
  42.             
  43.            
  44.           
  45.             + 
  46.            
  47.            
  48.            
  49.              w 
  50.             
  51.            
  52.              2 
  53.             
  54.            
  55.            
  56.            
  57.              x 
  58.             
  59.            
  60.              2 
  61.             
  62.            
  63.           
  64.             ≤ 
  65.            
  66.           
  67.             θ 
  68.            
  69.           
  70.             ) 
  71.            
  72.           
  73.          
  74.         
  75.        
  76.        
  77.         
  78.          
  79.          
  80.            1 
  81.           
  82.          
  83.         
  84.         
  85.          
  86.           
  87.           
  88.             if  
  89.            
  90.           
  91.             ( 
  92.            
  93.            
  94.            
  95.              w 
  96.             
  97.            
  98.              1 
  99.             
  100.            
  101.            
  102.            
  103.              x 
  104.             
  105.            
  106.              1 
  107.             
  108.            
  109.           
  110.             + 
  111.            
  112.            
  113.            
  114.              w 
  115.             
  116.            
  117.              2 
  118.             
  119.            
  120.            
  121.            
  122.              x 
  123.             
  124.            
  125.              2 
  126.             
  127.            
  128.           
  129.             > 
  130.            
  131.           
  132.             θ 
  133.            
  134.           
  135.             ) 
  136.            
  137.           
  138.          
  139.         
  140.        
  141.       
  142.      
  143.     
  144.    
  145.      y = \begin{cases} 0 & \text{if } (w_1 x_1 + w_2 x_2 \leq \theta) \\ 1 & \text{if } (w_1 x_1 + w_2 x_2 > \theta) \end{cases} 
  146.     
  147.    
  148.  y={01​if (w1​x1​+w2​x2​≤θ)if (w1​x1​+w2​x2​>θ)​

在这个模型中，权重 

  1.       w 
  2.      
  3.     
  4.       1 
  5.      
  6.     
  7.    
  8.   
  9.     w_1 
  10.    
  11.   
  12. w1​ 和  
  13.  
  14.   
  15.    
  16.     
  17.     
  18.       w 
  19.      
  20.     
  21.       2 
  22.      
  23.     
  24.    
  25.   
  26.     w_2 
  27.    
  28.   
  29. w2​ 控制着输入信号的重要性，而阈值  
  30.  
  31.   
  32.    
  33.    
  34.      θ 
  35.     
  36.    
  37.   
  38.     \theta 
  39.    
  40.   
  41. θ 则是决定神经元是否被激活的界限。权重的作用类似于电流中的电阻，它们不仅控制信号的强度，还影响信号是否足以触发输出。这种机制使得感知机能够在给定的输入下做出二进制决策。

第二章：简单逻辑电路

在本章中，我们将探讨如何使用感知机来实现几种基本的逻辑电路：与门（AND gate）、与非门（NAND gate）和或门（OR gate）。这些逻辑电路是数字电子中的基本组件，感知机通过简单的权重和阈值调整，能够模拟这些逻辑操作。

与门

与门是一种基本的逻辑电路，要求所有输入都为1时，输出才为1。

在这里插入图片描述

考虑一个简单的感知机模型，我们可以通过设置适当的权重和阈值来实现与门的功能。例如，设定权重 

  1.       w 
  2.      
  3.     
  4.       1 
  5.      
  6.     
  7.    
  8.   
  9.     w_1 
  10.    
  11.   
  12. w1​ 和  
  13.  
  14.   
  15.    
  16.     
  17.     
  18.       w 
  19.      
  20.     
  21.       2 
  22.      
  23.     
  24.    
  25.   
  26.     w_2 
  27.    
  28.   
  29. w2​ 为0.5，并设置阈值  
  30.  
  31.   
  32.    
  33.    
  34.      θ 
  35.     
  36.    
  37.   
  38.     \theta 
  39.    
  40.   
  41. θ 为0.7。在这种情况下，只有当两个输入  
  42.  
  43.   
  44.    
  45.     
  46.     
  47.       x 
  48.      
  49.     
  50.       1 
  51.      
  52.     
  53.    
  54.   
  55.     x_1 
  56.    
  57.   
  58. x1​ 和  
  59.  
  60.   
  61.    
  62.     
  63.     
  64.       x 
  65.      
  66.     
  67.       2 
  68.      
  69.     
  70.    
  71.   
  72.     x_2 
  73.    
  74.   
  75. x2​ 同时为1时，加权和  
  76.  
  77.   
  78.    
  79.    
  80.      0.5 
  81.     
  82.    
  83.      × 
  84.     
  85.    
  86.      1 
  87.     
  88.    
  89.      + 
  90.     
  91.    
  92.      0.5 
  93.     
  94.    
  95.      × 
  96.     
  97.    
  98.      1 
  99.     
  100.    
  101.      = 
  102.     
  103.    
  104.      1.0 
  105.     
  106.    
  107.   
  108.     0.5 \times 1 + 0.5 \times 1 = 1.0 
  109.    
  110.   
  111. 0.5×1+0.5×1=1.0 才会超过阈值0.7，从而输出1。对于其他任何输入组合，输出将为0。

与非门

与非门（NAND gate）是与门的逻辑相反：只有当所有输入都为1时，输出才为0；其他情况下输出为1。通过简单地取反与门的参数设置，我们可以实现与非门。

在这里插入图片描述

例如，将与门参数的符号取反，设置 

  1.       w 
  2.      
  3.     
  4.       1 
  5.      
  6.     
  7.    
  8.   
  9.     w_1 
  10.    
  11.   
  12. w1​ 和  
  13.  
  14.   
  15.    
  16.     
  17.     
  18.       w 
  19.      
  20.     
  21.       2 
  22.      
  23.     
  24.    
  25.   
  26.     w_2 
  27.    
  28.   
  29. w2​ 为-0.5，阈值  
  30.  
  31.   
  32.    
  33.    
  34.      θ 
  35.     
  36.    
  37.   
  38.     \theta 
  39.    
  40.   
  41. θ 为-0.7。这样，只有当两个输入  
  42.  
  43.   
  44.    
  45.     
  46.     
  47.       x 
  48.      
  49.     
  50.       1 
  51.      
  52.     
  53.    
  54.   
  55.     x_1 
  56.    
  57.   
  58. x1​ 和  
  59.  
  60.   
  61.    
  62.     
  63.     
  64.       x 
  65.      
  66.     
  67.       2 
  68.      
  69.     
  70.    
  71.   
  72.     x_2 
  73.    
  74.   
  75. x2​ 同时为1，加权和  
  76.  
  77.   
  78.    
  79.    
  80.      − 
  81.     
  82.    
  83.      0.5 
  84.     
  85.    
  86.      × 
  87.     
  88.    
  89.      1 
  90.     
  91.    
  92.      − 
  93.     
  94.    
  95.      0.5 
  96.     
  97.    
  98.      × 
  99.     
  100.    
  101.      1 
  102.     
  103.    
  104.      = 
  105.     
  106.    
  107.      − 
  108.     
  109.    
  110.      1.0 
  111.     
  112.    
  113.   
  114.     -0.5 \times 1 - 0.5 \times 1 = -1.0 
  115.    
  116.   
  117. −0.5×1−0.5×1=−1.0 才不超过阈值-0.7，输出为0。在所有其他情况下，输出为1。

或门

或门是另一种基本逻辑电路，要求至少一个输入为1时，输出就为1。

在这里插入图片描述

为了使用感知机实现或门，可以设置较低的阈值，例如 

  1.      θ 
  2.     
  3.    
  4.   
  5.     \theta 
  6.    
  7.   
  8. θ 为0.5，同时提高权重  
  9.  
  10.   
  11.    
  12.     
  13.     
  14.       w 
  15.      
  16.     
  17.       1 
  18.      
  19.     
  20.    
  21.   
  22.     w_1 
  23.    
  24.   
  25. w1​ 和  
  26.  
  27.   
  28.    
  29.     
  30.     
  31.       w 
  32.      
  33.     
  34.       2 
  35.      
  36.     
  37.    
  38.   
  39.     w_2 
  40.    
  41.   
  42. w2​ 至1.0。这样，任何一个输入为1就足以使加权和超过阈值，从而输出为1。

总结

通过适当设置权重和阈值，单个感知机就能模拟基本的逻辑电路功能。这表明感知机不仅仅是一个简单的分类器，还能执行基本的逻辑运算。这种能力使得感知机成为研究人工智能和计算机科学中逻辑处理的有用工具。我们使用的方法展示了如何通过调整参数，让简单的模型执行多种逻辑任务，类似于演员在不同角色间转换。这种灵活性是感知机在实现复杂功能时的重要基础。

第三章：感知机的实现

下面使用Python来实现基本的逻辑门感知机，从而进一步理解感知机的工作原理。我们将首先实现一个简单的与门（AND gate），然后扩展到与非门（NAND gate）和或门（OR gate），展示如何通过修改参数来调整感知机的行为。

3.1 简单的与门实现

让我们开始实现一个基本的与门。我们将定义一个接收两个参数x1和x2的函数，并使用固定的权重和阈值来判断输出：

  1. defAND(x1, x2):
  2.     w1, w2, theta =0.5,0.5,0.7
  3.     tmp = x1 * w1 + x2 * w2
  4.     if tmp <= theta:return0else:return1

这个函数使用了简单的条件判断来模拟感知机的阈值激活特性。下面是测试这个函数的代码，用以确认其表现符合与门的真值表：

  1. print(AND(0,0))# 输出 0print(AND(1,0))# 输出 0print(AND(0,1))# 输出 0print(AND(1,1))# 输出 1

3.2 导入权重和偏置

在之前的实现中，我们使用了阈值 

  1.      θ 
  2.     
  3.    
  4.   
  5.     \theta 
  6.    
  7.   
  8. θ 来控制感知机的激活。为了更接近现代神经网络的实现方式，我们将修改感知机的定义，使用偏置  
  9.  
  10.   
  11.    
  12.    
  13.      b 
  14.     
  15.    
  16.   
  17.     b 
  18.    
  19.   
  20. b 替代阈值，从而采用更通用的形式。这种修改不仅有助于理解感知机的行为，还能更好地与其他机器学习模型进行对比。

将原来的阈值 

  1.      θ 
  2.     
  3.    
  4.   
  5.     \theta 
  6.    
  7.   
  8. θ 转换为偏置  
  9.  
  10.   
  11.    
  12.    
  13.      b 
  14.     
  15.    
  16.   
  17.     b 
  18.    
  19.   
  20. b，感知机的行为可以用下面的数学公式表示：
  22.   
  23.    
  24.     
  25.     
  26.       y 
  27.      
  28.     
  29.       = 
  30.      
  31.      
  32.      
  33.        { 
  34.       
  35.       
  36.        
  37.         
  38.          
  39.          
  40.            0 
  41.           
  42.          
  43.         
  44.         
  45.          
  46.           
  47.           
  48.             if  
  49.            
  50.           
  51.             ( 
  52.            
  53.           
  54.             b 
  55.            
  56.           
  57.             + 
  58.            
  59.            
  60.            
  61.              w 
  62.             
  63.            
  64.              1 
  65.             
  66.            
  67.            
  68.            
  69.              x 
  70.             
  71.            
  72.              1 
  73.             
  74.            
  75.           
  76.             + 
  77.            
  78.            
  79.            
  80.              w 
  81.             
  82.            
  83.              2 
  84.             
  85.            
  86.            
  87.            
  88.              x 
  89.             
  90.            
  91.              2 
  92.             
  93.            
  94.           
  95.             ≤ 
  96.            
  97.           
  98.             0 
  99.            
  100.           
  101.             ) 
  102.            
  103.           
  104.          
  105.         
  106.        
  107.        
  108.         
  109.          
  110.          
  111.            1 
  112.           
  113.          
  114.         
  115.         
  116.          
  117.           
  118.           
  119.             if  
  120.            
  121.           
  122.             ( 
  123.            
  124.           
  125.             b 
  126.            
  127.           
  128.             + 
  129.            
  130.            
  131.            
  132.              w 
  133.             
  134.            
  135.              1 
  136.             
  137.            
  138.            
  139.            
  140.              x 
  141.             
  142.            
  143.              1 
  144.             
  145.            
  146.           
  147.             + 
  148.            
  149.            
  150.            
  151.              w 
  152.             
  153.            
  154.              2 
  155.             
  156.            
  157.            
  158.            
  159.              x 
  160.             
  161.            
  162.              2 
  163.             
  164.            
  165.           
  166.             > 
  167.            
  168.           
  169.             0 
  170.            
  171.           
  172.             ) 
  173.            
  174.           
  175.          
  176.         
  177.        
  178.       
  179.      
  180.     
  181.    
  182.      y = \begin{cases} 0 & \text{if } (b + w_1 x_1 + w_2 x_2 \leq 0) \\ 1 & \text{if } (b + w_1 x_1 + w_2 x_2 > 0) \end{cases} 
  183.     
  184.    
  185.  y={01​if (b+w1​x1​+w2​x2​≤0)if (b+w1​x1​+w2​x2​>0)​

此处， 

  1.      b 
  2.     
  3.    
  4.   
  5.     b 
  6.    
  7.   
  8. b 称为偏置，而  
  9.  
  10.   
  11.    
  12.     
  13.     
  14.       w 
  15.      
  16.     
  17.       1 
  18.      
  19.     
  20.    
  21.   
  22.     w_1 
  23.    
  24.   
  25. w1​ 和  
  26.  
  27.   
  28.    
  29.     
  30.     
  31.       w 
  32.      
  33.     
  34.       2 
  35.      
  36.     
  37.    
  38.   
  39.     w_2 
  40.    
  41.   
  42. w2​ 继续作为权重。感知机将计算输入信号和权重的乘积和，加上偏置后，根据结果是否大于零来确定输出。

接下来，我们将使用 Python 和 NumPy 库来实现这一修改后的感知机模型。首先，我们定义感知机的权重和偏置，然后使用这些参数计算输出：

  1. import numpy as np
  3. # 定义输入
  4. x = np.array([0,1])# 权重和偏置
  5. w = np.array([0.5,0.5])
  6. b =-0.7# 计算加权输入和偏置的总和
  7. weighted_sum = np.sum(w * x)+ b
  9. # 输出结果 -0.2print("Output:",1if weighted_sum >0else0)

在这个例子中，我们首先将权重与输入相乘，然后加上偏置。这个总和决定了感知机的输出。

3.3 使用权重和偏置的实现

实现与门

与门要求所有输入都为1时，输出才为1。通过调整权重和偏置，我们可以如下实现与门：

  1. defAND(x1, x2):
  2.     x = np.array([x1, x2])
  3.     w = np.array([0.5,0.5])
  4.     b =-0.7
  5.     tmp = np.sum(w * x)+ b
  6.     if tmp <=0:return0else:return1

在这里，偏置 

  1.      b 
  2.     
  3.    
  4.   
  5.     b 
  6.    
  7.   
  8. b 被设置为  
  9.  
  10.   
  11.    
  12.    
  13.      − 
  14.     
  15.    
  16.      0.7 
  17.     
  18.    
  19.   
  20.     -0.7 
  21.    
  22.   
  23. −0.7，而权重  
  24.  
  25.   
  26.    
  27.     
  28.     
  29.       w 
  30.      
  31.     
  32.       1 
  33.      
  34.     
  35.    
  36.   
  37.     w_1 
  38.    
  39.   
  40. w1​ 和  
  41.  
  42.   
  43.    
  44.     
  45.     
  46.       w 
  47.      
  48.     
  49.       2 
  50.      
  51.     
  52.    
  53.   
  54.     w_2 
  55.    
  56.   
  57. w2​ 都是  
  58.  
  59.   
  60.    
  61.    
  62.      0.5 
  63.     
  64.    
  65.   
  66.     0.5 
  67.    
  68.   
  69. 0.5。这意味着只有当两个输入都为1时，感知机的输出才为1。偏置  
  70.  
  71.   
  72.    
  73.    
  74.      b 
  75.     
  76.    
  77.   
  78.     b 
  79.    
  80.   
  81. b 和权重  
  82.  
  83.   
  84.    
  85.     
  86.     
  87.       w 
  88.      
  89.     
  90.       1 
  91.      
  92.     
  93.    
  94.   
  95.     w_1 
  96.    
  97.   
  98. w1​,  
  99.  
  100.   
  101.    
  102.     
  103.     
  104.       w 
  105.      
  106.     
  107.       2 
  108.      
  109.     
  110.    
  111.   
  112.     w_2 
  113.    
  114.   
  115. w2​ 的作用是不同的。权重控制输入信号的重要性，而偏置则调节神经元被激活的难易度。例如，如果  
  116.  
  117.   
  118.    
  119.    
  120.      b 
  121.     
  122.    
  123.   
  124.     b 
  125.    
  126.   
  127. b 为  
  128.  
  129.   
  130.    
  131.    
  132.      − 
  133.     
  134.    
  135.      0.1 
  136.     
  137.    
  138.   
  139.     -0.1 
  140.    
  141.   
  142. −0.1，则相对较容易激活神经元；若  
  143.  
  144.   
  145.    
  146.    
  147.      b 
  148.     
  149.    
  150.   
  151.     b 
  152.    
  153.   
  154. b 为  
  155.  
  156.   
  157.    
  158.    
  159.      − 
  160.     
  161.    
  162.      20.0 
  163.     
  164.    
  165.   
  166.     -20.0 
  167.    
  168.   
  169. −20.0，则需要更大的输入信号总和才能激活神经元。

实现与非门和或门

与非门和或门的实现也采用了类似的方法，只是权重和偏置有所不同：

  1. defNAND(x1, x2):
  2.     x = np.array([x1, x2])
  3.     w = np.array([-0.5,-0.5])# 权重与AND门相反
  4.     b =0.7
  5.     tmp = np.sum(w * x)+ b
  6.     if tmp <=0:return0else:return1defOR(x1, x2):
  7.     x = np.array([x1, x2])
  8.     w = np.array([0.5,0.5])
  9.     b =-0.2
  10.     tmp = np.sum(w * x)+ b
  11.     if tmp <=0:return0else:return1

在这些实现中，与门、与非门和或门的构造基本相同，区别仅在于权重和偏置的设置。这种方法展示了如何通过简单的参数调整，让感知机执行不同的逻辑功能。

下一节：从简单逻辑到复杂计算：感知机的进化与其在现代深度学习和人工智能中的应用（下）

标签： 感知机 深度学习 神经网络
本文转载自: https://blog.csdn.net/lph159/article/details/138503850
版权归原作者 努力的派大星星 所有， 如有侵权，请联系我们删除。
登录后发布评论

“从简单逻辑到复杂计算：感知机的进化与其在现代深度学习和人工智能中的应用（上）”的评论:

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

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

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

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

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

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

Kafka学习笔记

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