hopfield神经网络_Hopfield | DHNN&CHNN

• Hopfield神经网络：
  • 大规模，非线性，动力学，系统，建模分析
  • 全互联网络：任意两个神经元之间都有连接→网络中存在大量反馈（系统性质有值的变化）

不同于之前的BP神经网络，BP本质无反馈，非线性映射（BP铅球HNN弹弹球）

• • 网络稳定性：
    • 稳定性：某T开始，网络中所有神经元状态不在改变，此刻又叫吸引子（网络的稳定点 ），网络从初始状态开始运动总可以到某个稳定状态，这些稳定状态可以通过改变网络参数计算求之。

（≠）自控理论中：系统的输出不会发散，最后收敛至某个值

• • 工作方式：
    • 初态→（异步/同步）→稳态

稳态并非状态不改变，本质为以前化学学过的平衡状态，即状态达到了一种平衡
栗子：初态（记忆样本中的部分信息）

• • • 异步（串行）：每次只能有一个动作（第i 个神经元动作）

• • • 同步（并行）：大家要变一起变（满足了某种条件变化）

• 离散Hopfield神经网络DHNN：
  • 离散：（非线性）神经元 ，只有2种状态0，1或-1，1

≠控制理论中的离散：系统当中至少有一个地方的信号不是时间T的连续函数

• 连续Hopfield神经网络CHNN:
  • 连续：神经元的非线性函数为连续函数（S型函数）

• 稳定性如何分析：能量函数（目标函数+补偿函数）

• Hopfield神经网络-应用：
  • 联想记忆=>自动分类（数字编码类别属性）
  • 优化=>TSP问题：

TSP 问题，即旅行商问题，是数学领域中著名问题之一。假设一个人要去几个城市，现在要选择路线，路线的限制是每个城市只能去一次，而且最后要回到原来出发的城市，路线的选择目标是最终路线为所有路线之中的距离最短的。

• • • CHNN连续神经网络：循环神经网络；I/O中反馈连接；迭代过程中状态不断变化
    • 实现X5：
      • 将优化问题的每一个可行解用换位矩阵表示
      • 换位矩阵=>神经网络；每个可行解换位矩阵各元素=>神经元稳态输出

换位矩阵≈可达矩阵，自反馈/对角线元素为0，逻辑上来说每列只能有一个1，每行不能没有1（城市的换位矩阵中的1位置≈>数独九宫格里面那样）

• • • • 构造.能量函数（最小值≈最优解+满足约束条件）
      • 罚函数法.构造.目标函数（连接权+偏置参数）

罚函数：（行约束+列约束+全局约束）=>（目标约束）

• • • • 给定初始状态、参数：运行→稳定状态（此时解：[局部]最优解）

• TSP实现：2个网络计算函数（度数+能量）
  • 计算网络度数（约束实现）

def 

• • 计算网络能量

def energy(V,distance):
    a = sum([x*x for x in (np.sum(V,axis=0)-1)])
    b =sum([x*x for x in (np.sum(V,axis=1)-1)])
    c_1 = V[:,1:m]
    c_0 = np.array([[0.0] for i in range(m)])
    c_0[:,0] = V[:,0]
    c = np.concatenate((c_1,c_0),axis=1)
    c = np.sum(np.sum(np.multiply(V,np.dot(distance,c)),axis=0))
    e = 0.5*(A*(a+b) + D*c)
    return e

• 城市网路构建

city= np.array([[0.7000,0.2000],[0.4000,0.3000],[0.5000,0.8000],[0.3000,0.4000],[0.1000,0.9000],[0.9000,0.4000],[0.8000,0.6000],[0.6000,0.9000],[0.3000,0.6000],[0.2000,0.8000]])
m = len(city)
#欧氏距离
distance = np.array([[0.0for i in range(m)] for i in range(m)])
for i in range(m):
    for j in range(m):
        a = sqrt((city[i,0] - city[j,0]) * (city[i,0] - city[j,0]) + (city[i,1] - city[j,1]) * (city[i,1] - city[j,1]))
        distance[i,j] = a
        distance[j,i] = a

• 迭代网络初始化

A,D = 300,200
U0,step = 0.1,0.0001
delta = 2*(np.random.random((m,m))) -1 
U =U0*log(m-1) + delta
V = np.array([[0.0 for i in range(m)] for i in range(m)])
for i in range(m):
    for j in range(m):
        V[i,j] = (1+2/(1+exp(-2*(U[i,j]/U0)))-1)/2
num_iter = 10000
ener = np.array([0.0]for x in range(num_iter))

• 进行迭代

for n in range(num_iter):
    dU = d_u(V,distance,m)
    U = U+dU * step
    for i in range(m):
        for j in range(m):
            V[i,j] = (1+2 / (1+exp(-2*(U[i,j] / U0)))-1)/2
    e = energy(V,distance)
    ener[n] = e

• 判断正确性

(row,col) = V.shape
V_H = np.array([0.0 for i in range(row)])
V_W = np.array([0 for i in range(row)])
for i in range(m):
    for j in range(m):
        if V[i,j] > V_H[i]:
            V_H[i] = V[j,i]
            V_W[i] = j
V_1 = np.array([[0 for i in range(row)] for i in range(col)])
for i in range(col):
    V_1[V_W[i],i] = 1
C = np.sum(V_1,axis=0)
R = np.sum(V_1,axis=1)
test =1 
for i  in range(m):
    if C[i]!=1 or R[i]!=1:
        test = 0

• 结果输出

if test == 1:
    #创建两个数组，一个记录最大值，另一个记录最大值所在的行
    V_1H = np.array([0.0 for i in range(m)]);
    V_1W = np.array([0 for i in range(m)]);
    for i in range(m):
        for j in range(m):
            if V_1[j, i] > V_1H[i]:
                V_1H[i] = V_1[j, i]
                V_1W[i] = j
    #随机一种路径和优化后的路径进行比较
    city_i = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    V_0W = random.sample(list(city_i), 10)
    #创建两个城市矩阵，将他们按照我们所给的初始顺序和最终顺序进行排序
    city_b = np.array([[0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]]);
    city_f = np.array([[0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]]);
    k=np.array([0,1,2,3,4,5,6,7,8,9])
    k=[city[i] for i in V_0W]
    for i in range(m):
        city_b[i]=k[i]
    j=np.array([0,1,2,3,4,5,6,7,8,9])
    j=[city[i] for i in V_1W]
    for i in range(m):
        city_f[i]=j[i]
    #下面将坐标点的X，Y轴数值分别提取进行画图
    X_b=[]
    Y_b=[]
    X_f=[]
    Y_f=[]
    for i in range(m):
        X_b.append(city_b[i][0])
        Y_b.append(city_b[i][1])
        X_f.append(city_f[i][0])
        Y_f.append(city_f[i][1])
    #将第一个点加入，因为要回到初始点
    X_b.append(city_b[0][0])
    Y_b.append(city_b[0][1])
    X_f.append(city_f[0][0])
    Y_f.append(city_f[0][1])
    plt.plot(X_b,Y_b,'r',X_f, Y_f, '-.b')
    plt.scatter(X_f,Y_f)
    plt.show()
else:
    print('No optimal path')

图中，红色：随机路线，蓝色：优化后结果