竞争型学习是神经网络中一种常用的无监督学习策略，在使用该策略时，网络的输出神经元相互竞争，每一时刻仅有一个竞争获胜的神经元被激活，其他神经元的状态被抑制，这种机制亦称为“胜者通吃”原则。

ART（Adaptive Resonance Theory，自适应谐振理论）网络是竞争型学习的重要代表。该网络由比较层、识别层、识别阈值和重置模块构成。其中，比较层负责接收输入样本，并将其传递给识别层；识别层每个神经元对应一个模式类，神经元数目可在训练过程中动态增长以增加新的模式类。

在接收到比较层的输入信号后，识别层神经元之间相互竞争以产生获胜神经元。

竞争方式：计算输入向量与每个识别层神经元所对应的模式类的代表向量之间的距离，距离最小者胜利。

获胜神经元将向其他识别层神经元发送信号，抑制其激活。

若输入向量与获胜神经元所对应的代表向量之间的相似度大于识别阈值时，则当前输入样本将被归为该代表向量所属类别。同时，网络连接权将会更新，使得以后在接收相似输入样本时该模式类会计算出更大的相似度，从而使得该获胜神经元有更大可能获胜。

若相似度不大于识别阈值，则重置模块将在识别层增设一个新的神经元，其代表向量就设置为当前输入向量。

则，识别阈值对ART网络的性能有重要影响。当识别阈值较高时，输入样本将会被分成比较多、比较精细的模式类，而如果识别阈值较低，则会产生比较少、比较粗略的模式类。

ART网络可以较好地缓解竞争型学习中的“可塑性-稳定性窘境”，可塑性是指神经网络要有学习新知识的能力，稳定性是指神经网络在学习新知识时要保持对旧知识的记忆。

这就使得ART网络具有一个很重要的优点：可进行增量学习或在线学习。

经过多年的研究和不断发展，ART网络已有3种形式：

  • ART1（处理双极型或二进制信号）

ART1网络结构由两层神经元构成两个子系统，分别为比较层C和识别层R，包含三种控制信号：复位信号Reset，逻辑控制信号G1和G2。

比较层C的结构为：

 

 C层有n个神经元，每个接收来自三方面的信号：外界输入信号、R层获胜神经元的外星权向量的返回信号和控制信号G1。C层神经元的输出是根据2/3的多数表决原则产生的，输出值与三个信号中的多数信号值相同。

例如，网络开始运行时，G1=1，识别层尚未产生竞争获胜神经元，因此反馈信号为0。由2/3规则，C层输出应取决于输入信号，即C=X。当网络识别层出现反馈信号时，G1=0，由2/3规则，C层输出取决于输入信号与反馈信号的比较结果（c_{i} = x_{i} \cap t_{ij}），两者同时为1，则Ci为1,否则为0。可以看出控制信号G1的作用是使得比较层能够区分网络运行的不同阶段。网络开始运行阶段G1的作用使得C层对输入信号直接输出，之后G1的作用是使C层行使比较功能。

总之，R层的反馈信号对C的输出有调节作用。

比较层R的结构为：

 R层有m个神经元，代表m个输入模式类，m可以动态增长，以设立新的模式类。

C层的输出向量c沿着R层神经元的内星权向量到达R层神经元，经过竞争在产生获胜神经元处指示本此输入模式的所属类别。获胜神经元输出为1,其余为0。R层每个神经元都对应两个权向量，一个是将C层前馈信号汇聚到R层的内星权向量，另一个则是将R层反馈信号散发到C层的外星权向量。

控制信号

信号G2检测输入模式X是否为0，它等于X各分量的逻辑或，如果xi全为0,则G2=0，否则G2=1。

G_1 =G_2 \cap \overline{R_0}，R0为R层输出向量各分量的逻辑"或"。当R层的输出向量的各分量全为0时且输入向量X不是0向量时， G1=1,否则等于0。

Reset信号的作用是使得R层竞争获取神经元无效。如果根据事先设定的测量表尊，Tj（外星权向量）与X未达到设定的相似度，表明两者未充分接近，于是系统发出Reset信号，使得竞争获胜神经元无效。

对于每一个输入，模式网络运行过程可归纳为四个阶段：

（1）匹配阶段

网络在没有输入之前处于等待状态，此时输入端X=0,因此G2=0，R0=0.

当输入不全为0的模式X时，G2=1，R0=0，使得G1= 1

G1=1时，允许输入模式直接从C层输出，并向前传至R层，与R层节点所对应的所有内星权向量Bj进行匹配计算：

net_{j} = B_j^T X = \sum_{i=1}^{n}b_{ij}x_i, j=1,2,...,m

选择具有最大匹配度（即具有最大点积）的竞争获胜节点：

net_j = \underset{j}{max} \{net_j\}

使得获胜节点输出r_j=1，其他节点输出为0.

(2) 比较阶段

R层输出信息通过外星权向量返回到C层。R层获胜节点所连接的外星权向量激活，从节点j^{*}发出n个权值信号返回到C层的n个节点。此时R层输出不全为0，R0=1。则G1=0.。所以C层最新输出状态C取决于R层返回的外星权向量和网络输入模式X的比较结果。即 c_{i} = t_{ij^{*}} \cap x_{i}, i=1,2,...,n。比较结果C反映了在匹配阶段R层竞争排名第一的模式类的典型向量与当前输入模式X的相似程度，相似程度的大小用相似度N0反映，定义为：

N_0 = X^T t_{j^*} = \sum_{i=1}^{n} t_{ij^*} x_i = \sum_{i=1}^{n} c_i

设输入模式样本中的非零分量数为：

N_1 = \sum_{i=1}^{n} x_i

用于比较的参考门限为\rho，在0-1范围内取值。

检查输入模式与模式类典型向量之间的相似性是否低于参考门限，

如果有\frac{N_0}{N_1} \leq \rho,则X与C的相似度不满足要求，网络发出Reset信号使第一阶段的匹配失败，竞争获胜节点无效，网络进入搜索阶段。

如果有\frac{N_0}{N_1} > \rho，则X与获胜节点对应的类别模式非常接近，称X与Tj发生“共振”，第一阶段的匹配结果有效，网络进入学习阶段。

（3）搜索阶段

网络发出Reset重置信号后即进入搜索阶段，重置信号的作用是使前面通过竞争获胜的神经元受到抑制，并且在后续过程中受到持续的抑制，直到输入一个新的模式为止。由于R层中的竞争获胜的神经元被抑制，从而再度出现R0=0，G1=1，因此网络又回到起始的匹配状态。

由于上次获胜的节点受到持续的抑制，此次获胜的必然是上次匹配程度排在第二的节点，将该节点对应的外星权向量与输入模式进行匹配。如果对R层所有的模式类，在比较阶段的相似度检查中都不满足要求，说明当前输入模式无类可归，需要在网络输出层增加一个节点来代表并存储该模式类，为此将内星权向量B_j设计成当前输入模式向量，外星权向量Tj各分量全设为1.

（4）学习阶段

在学习阶段要对发生共振的获胜节点对应的模式类加强学习，使以后出现与该模式相似的输入样本时能获得更大的共振。

ART1网络可以用学习算法实现，也可以使用硬件实现。训练按照以下步骤进行：

（1）网络初始化

从C层向R层的内星权向量Bj赋予相同的较小数值，如

b_{ij}(0) = \frac{1}{n+1}, i=1,2,...,n,j=1,2,...,m

从R层向C层的外星权向量Tj各分量均赋1

t_{ij}=1, i=1,2,...,n, j=1,2,...,m

(2)接受输入 

给定一个输入模式，X=(x_1,x_2,...,x_n), x_i \in (0,1)

(3)匹配度计算

对R层所有内星权向量Bj计算与输入模式的匹配度：

net_{j} = B_j^T X = \sum_{i=1}^{n}b_{ij}x_i, j=1,2,...,m

（4）选择最佳匹配节点

在R层有效输出节点集合j*内选择竞争获胜的最佳匹配节点j*，使得

r_j = \left\{\begin{matrix} 1, j = j*\\ 0, j \not\equiv j* \end{matrix}\right.

(5) 相似度计算

R层获胜节点j*通过外星权向量送回获胜模式类的典型向量，C层输出信号给出对典型向量和X的比较结果，由此结果可计算出两向量的相似度：

N_0 = X^T t_{j^*} = \sum_{i=1}^{n} t_{ij^*} x_i = \sum_{i=1}^{n} c_i

N_1 = \sum_{i=1}^{n} x_i

 （6）参考门限检验

如果有\frac{N_0}{N_1} \leq \rho,则X与C的相似度不满足要求，本此竞争获胜节点无效，因此从R层有效输出节点j*中取消该节点，并使r_{j*} = 0，训练转入步骤（7）.

如果有\frac{N_0}{N_1} > \rho，则X与应归为代表的模式类，转向步骤（8）调整权值。

（7）搜索匹配模式类

若有效输出节点集合j*不为空，转向步骤（4）重选匹配模式类；

若j*为空，需要在R层增加一个节点。设新增节点的序号为n_c，应使B=X, t_{in_c}=1,i=1,2,...,n

此时有效输出节点集合为j^*=\{1,2,...,m,m+1,...,m+n_c\}，转向步骤（2）输入新模式。

（8）调整网络权值

修改R层节点j*对应的权向量，网络的学习采用两种规则，

外星权向量的调整按以下规则：

t_{ij^*} (t+1) = t_{ij^*} (t)x_i,i=1,2,..,n

内星权向量的调整按以下规则：

b_{ij^*}(t+1) = \frac{t_{ij^*}(t)x_i}{0.5+\sum_{i=1}^{n} t_{ij^*}(t)x_i} = \frac{t_{ij^*}(t+1)}{0.5+\sum_{i=1}^{n} t_{ij^*}(t+1)}

ART1 网络的实际应用--模式分类：

按照M=4，N=25设计网络，如下图A、B、C、D所示。

X^A=(1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1)^T

X^B = (1,0,0,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,1)^T

X^C=(1,0,0,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,0,0,1)^T

X^D=(1,0,0,0,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,0,0,0,1)^T

设\rho =0.7,取初始权值

bij=1/(1+n)=1/26,tij=1

第一步，输入模式X^A，将R层的4个节点输出最大的一个命名为节点1，得到j*=1，有N0/N1=1，大于参考门限\rho，故第一个模式被命名为第一类模式，修改节点1的外星权向量，得到

 T_1=(1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1)^T

 内星权向量为：

b1,1=b7,1=b13,1=b19,1=b25,1=2/11

其余仍为初始值1/26。对应输入模式X^A，可以看出，以上调整结果将模式X^A存储在神经元1的内外星权向量中。

第二步，输入模式X^B时，R层只有一个已存储模式，故不存在类别归属的竞争，只需判断该模式与已存储模式T_1 = X^A的相似度，得N0/N1=5/9<0.7，则相似度不满足要求。由于R层已经没有其他已存储模式类可供选择，需动用一个新节点，命名为节点2，用以代表新模式X^B。

节点2的外星权向量为T_2=X^B,内星权向量为 

b1,2=b5,2=b7,2=b9,2=b13,2=b17,2=b19,2=b21,2=b25,2=2/19

其余仍为初始值1/26。

第3步，输入模式X^C时，节点1和节点2进行竞争

节点1净输入为1.217 > 节点2净输入为1.101

节点1获胜。计算T1与Xc的相似度，N0/N1=5/13<0.7

节点1失效。网络应在其余的存储模式类节点中搜索，对于本例，只能取节点2作为获胜节点，于是计算T2与Xc的相似度，则N0/N1= 9/13<0.7

该结果仍不能满足要求，只能把模式视为第三类模式，并修改节点3的内外星权向量。

外星权向量T3=X^C

X^C=(1,0,0,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,0,0,1)^T 

内星权向量

b1,3=b5,3=b7,3=b9,3=b11,3=b12,3=b13,3=b14,3=b15,3=b17,3=b19,3=b21,3=b25,3=2/27

第四步，输入模式X^D后，节点1、节点2和节点3参加竞争，

节点1的净输入为：1.371

节点2的净输入为：1.255

节点3的净输入为：1.117

节点1获胜，则计算N0/N1= 5/17<0.7，不符合相似度要求。节点1失效。

计算节点2，N0/N1=9/17<0.7，也不符合要求，节点2失效。

计算节点3，N0/N1=13/17>0.7，符合要求，于是将X^D归入已属于第三类模式，并修改节点3的内外星权向量。

上述例子用代码实现：

import numpy as np

class ART_1():
    #初始化内星权向量矩阵B（C层向R层传入R的权值）和外星权向量矩阵T（R层反馈给C层）
    def set_B0_T0(self, n):
        b = 1 / (1 + n)
        B = []
        T = []
        for i in range(n):
            B.append(b)
            T.append(1)
        #numpy的mat函数将向量转化为矩阵
        B = np.mat(B)
        T = np.mat(T)
        #然后转置
        B = B.T
        T = T.T
        return B, T

    #竞争函数,选取R层竞争获胜的向量
    def Competitor(self, B, x):
        x = np.mat(x)#x(1,25)
        J = B.shape[1] #B(25,1)
        competition = []
        for j in range(J):
            compe = x * B[:, j]#x(1,25) B(25,1) compe(1,1)
            competition.append(compe[0, 0])
        competition = np.array(competition)
        j_order = np.argsort(-competition) #按大小排序,返回索引值
        j_order = list(j_order) #后面要用j_order循环所以又转回List类型
        return j_order

    #匹配，竞争成功的R层节点，通过外星权向量和x匹配，ruo0是阈值
    def Match(self, T, x, j, rou0):
        N0 = sum(x)
        x = np.mat(x)
        N = x * T[:, j]
        N = N[0, 0]
        rou = N/N0
        if rou >= rou0:
            matchBOOL = True
        else:
            matchBOOL = False
        return matchBOOL

    #增加新节点
    def ADD_BT(self, B, T, x, n):
        b = x
        b = np.mat(b).T
        B = np.hstack((B,b))
        L=[]
        for i in range(len(x)):
            L.append(1)
        L = np.mat(L).T
        T = np.hstack((T, L))
        return B, T

    #分组
    def Group(self, B, T, x, j_order, Groups, rou0):
        success = 0
        n =len(x)
        jj = B.shape[1]
        for j in j_order:
            matchBooL = self.Match(T, x, j, rou0)#第一组True
            if matchBooL:
                B, T = self.AdjustBT(B, T, x, j)
                jj = j + 1
                if jj not in Groups:
                    Groups[jj] = [x]
                else:
                    Groups[jj].append(x)
                print(x, '分组成功，分在{}组'.format(jj))
                success = 1
                break
        if success == 0:
            B, T = self.ADD_BT(B, T, x, jj-1)
            jj = B.shape[1]
            B, T = self.AdjustBT(B, T, x, jj-1)
            Groups[jj] = [x]
            print(x, '分组成功，分在{}组'.format(jj))
        return B, T, Groups


    #匹配成功后，更新内外星向量权值
    def AdjustBT(self, B, T, x, j):
        m = len(x)
        x = np.mat(x)
        xigama_TX = x * T[:, j] #x(1,25) T(25,1) ,xigama(1,1)
        xigama_TX = xigama_TX[0, 0]
        new_b = 1 / (0.5 + xigama_TX)
        for i in range(m):
            if B[i, j].any() == 1:
                B[i, j] = new_b #更新内星权向量
        T[:, j] = np.multiply(T[:,j], x.T)#更新外星权向量
        return B, T

主函数为：

if __name__ == '__main__':
    rou0 = 0.7
    X = [[1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
         [1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
        [1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
        [1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1]]
    n = len(X) #输入四类模式
    m = len(X[0]) #取模式的维数
    art = ART_1()
    #初始化分组
    Groups = {}
    #初始化B，T
    B, T = art.set_B0_T0(m)
    #对每一个x进行判断归类
    for x in X:
        j_order = art.Competitor(B,x)
        B, T, Groups = art.Group(B, T, x, j_order, Groups, rou0)

rho=0.7的结果为：

剩下两种形式为ART2网络和ART3网络，后续将继续介绍。

# 机器学习 # 神经网络 # 算法
Logo
腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

avatar 腾讯云开发者社区

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

avatar 腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git

avatar 腾讯云开发者社区