Hopfield神经网络与受限波尔兹曼机-Toy模板网

这篇具有很好参考价值的文章主要介绍了Hopfield神经网络与受限波尔兹曼机。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

神经网络可分为两大类：

一类是多层神经网络、卷积神经网络：可用于模式识别
另一类是相互连接型网络：可通过联想记忆去除输入数据中的噪声。

深度学习目录：

自适应线性单元 (Widrow and Hoff, 1960)
神经认知机 (Fukushima, 1980)
GPU-加速卷积网络 (Chellapilla et al., 2006)
深度玻尔兹曼机 (Salakhutdinov and Hinton, 2009a)
无监督卷积网络 (Jarrett et al., 2009b)
GPU-加速多层感知机 (Ciresan et al., 2010)
分布式自编码器 (Le et al., 2012)
Multi-GPU 卷积网络 (Krizhevsky et al., 2012a)
COTS HPC 无监督卷积网络 (Coates et al., 2013)
GoogLeNet (Szegedy et al., 2014a)

Hopfield神经网络 HNN(Hopfield Neural Network)

1982年Hopfield 提出了Hopfield神经网络，是最典型的相互连接型神经网络。

首先我们来看看脑部神经元结构图
Hopfield神经网络与受限波尔兹曼机
生物神经元和人工神经元的对照关系

Hopfield神经网络与受限波尔兹曼机
Hopfield神经网络是一种递归神经网络，从输出到输入均有反馈连接，每一个神经元跟所有其他神经元相互连接，又称为全互联网络。
我们根据如上形式，将所有神经元之间两两连接，形成了全互联网络

Hopfield神经网络与受限波尔兹曼机
Hopfield最早提出的网络是二值神经网络，各神经元的激励函数为阶跃函数或双极值函数,神经元的输入、输出只取 ${(0，1)}$ 或者 ${( -1，1)}$ ，所以也称为离散型Hopfield神经网络DHNN（Discrete Hopfiled Neural Network）

离散Hopfield神经网络DHNN是一个单层网络，有n个神经元节点，每个神经元的输出均接到其它神经元的输入。各节点没有自反馈。每个节点都可处于一种可能的状态（1或－1），即当该神经元所受的刺激超过其阀值时，神经元就处于一种状态（比如1），否则神经元就始终处于另一状态（比如－1）。

构建Hopfield神经网络

首先，构建Hopfield神经网络需要提供要求记忆的二进制网络，如：

a=np.array([[0,0,1,1,0,0],
            [0,0,1,1,0,0],
            [1,1,1,1,1,1],
            [1,1,1,1,1,1],
            [0,0,1,1,0,0],
            [0,0,1,1,0,0]])

Hopfield神经网络与受限波尔兹曼机

设置神经网络的网络权值

因为网络共有 $6 * 6 = 36$ 个结点。故神经网络连接需要 $35 * 35$ 个（自身与自身不连接）。

我们首先将二维图像展开成为一层

array_a=a.flatten()

Hopfield神经网络与受限波尔兹曼机

其次，设置连接权值。

我们已知Hopfield神经网络为二值神经网络，值为0或1。

设：
$a[i]为0，a[j]为1时,权值w_{ij}为-1\\ \quad\\ 当 a[i]为0，a[j]为0时,权值w_{ij}为1\\ \quad\\ 且w_{ji} = w_{ij}\\ 即：俩结点值相同权值为1，结点不同权值为0$

w=np.zeros((36,36))
for i in range(36):
     for j in range(36):
         if i==j:
             w[i,j]=0
         else:
             w[i,j]=(2*s[i]-1)*(2*s[j]-1)

生成网络权值图如下
Hopfield神经网络与受限波尔兹曼机

输入联想图，开始联想

联想图

c=np.array([[0,0,1,1,0,0],
            [0,0,1,1,0,0],
            [1,1,1,1,1,1],
            [1,1,1,1,1,1],
            [1,0,0,1,0,0],
            [0,0,1,1,0,0]])

Hopfield神经网络与受限波尔兹曼机

开始联想

设输入值为 $x_i(t)$ ，输出值为 $x_i(t+1)$ ， $t$ 为迭代次数，有如下公式
$u_i(t) = \sum_{j=1}^n w_{ij}x_j(t) - b_i(t)\\ \quad\\ x_i(t+1) = \left\{\begin{matrix} 1 & u_i(t)>0 \\ x_i(t)(不变) & u_i(t)==0 \\ 0& u_i(t)<0 \end{matrix}\right.$

在此模型中，我们设 $b_i(t)$ 都为0.

依据以上公式，代码如下：

c=c.flatten()
x=c
Y=np.zeros(36)
for t in range(10):
    u = np.zeros(36)
    for j in range(36):
        for i in range(36):
            if i==j:
                u[j]+=0
            else:
                u[j]+=w[i,j]*x[i]
        if u[j]<0:
            Y[j]=0
        else if u[j]==0:
			Y[j] = Y[j];
		else:
            Y[j]=1
    x=Y

输出 $x$

Hopfield神经网络与受限波尔兹曼机

多联想记忆网络

即，一个网络存储多个记忆

将多个记忆的网络权值相加即可。

input_array=[array_a,array_b]
w=np.zeros((36,36))
for s in input_array:
    w0=np.zeros((36,36))
    for i in range(36):
        for j in range(36):
            if i==j:
                w0[i,j]=0
            else:
                w0[i,j]=(2*s[i]-1)*(2*s[j]-1)
    w+=w0

array_b图像
Hopfield神经网络与受限波尔兹曼机
多记忆权值网络：

联想记忆测试a

联想结果a

联想记忆测试b

联想结果b

结果显示，一个网络可以存储多个记忆图。

全部代码

引自：Hopfield神经网络（HNN）详解

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
a=np.array([[0,0,1,1,0,0],
            [0,0,1,1,0,0],
            [1,1,1,1,1,1],
            [1,1,1,1,1,1],
            [0,0,1,1,0,0],
            [0,0,1,1,0,0]])
b=np.array([[0,0,1,1,0,0],
            [0,1,0,0,1,0],
            [1,0,0,0,0,1],
            [1,0,0,0,0,1],
            [0,1,0,0,1,0],
            [0,0,1,1,0,0]])
c=np.array([[0,0,1,1,0,0],
            [0,0,1,1,0,0],
            [1,1,1,1,1,1],
            [1,1,1,1,1,1],
            [1,0,0,1,0,0],
            [0,0,1,1,0,0]])
array_a=a.flatten()
array_b=b.flatten()
input_array=[array_a,array_b]
w=np.zeros((36,36))
for s in input_array:
    w0=np.zeros((36,36))
    for i in range(36):
        for j in range(36):
            if i==j:
                w0[i,j]=0
            else:
                w0[i,j]=(2*s[i]-1)*(2*s[j]-1)
    w+=w0
c=c.flatten()
v0=c
Y=np.zeros(36)
for t in range(10):
    v1 = np.zeros(36)
    for j in range(36):
        for i in range(36):
            if i==j:
                v1[j]+=0
            else:
                v1[j]+=w[i,j]*v0[i]
        if v1[j]<0:
            Y[j]=0
        else:
            Y[j]=1
    v0=Y
result=np.array(v0).reshape(6,6)
p=Image.fromarray(result*600)
plt.imshow(p)
plt.show()