【Python】改进Hopfield网络代码实现

最新推荐文章于 2023-09-15 21:45:10 发布
最新推荐文章于 2023-09-15 21:45:10 发布
阅读量5.3k 收藏 31
点赞数 3
分类专栏： Python Algorithm 文章标签： python 神经网络 hopfield
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jkwwwwwwwwww/article/details/65654613
版权

Hopfield网络

Hopfield网络由美国加州理工学院物理学教授J. J. Hopfield于1982年提出[1]
网络从输出到输入有反馈连接，在输入的激励下，会产生不断的状态变化，是一种单层反馈神经网络，也可以被视为一种循环神经网络
Hopfield神经网络是反馈网络中最简单且应用广泛的模型，它具有联想记忆的功能，是神经网络发展历史上的一个重要的里程碑
根据网络的输出是离散量或是连续量，Hopfield神经网络大致分为两种：离散Hopfield网络（Discrete Hopfield Neural Network, DHNN）和连续Hopfield网络（Continuous Hopfield Neural Network, CHNN）

网络大致结构如下图所示：
Hopfield

离散Hopfield网络可以视为一个类脑模型，主要是因为其可用于联想记忆，即联想存储器，这是类人智能的特点之一
人类的所谓“触景生情”就是见到一些类同于过去接触的景物，容易产生对过去情景的回味和思忆
对于Hopfield 网络，用它作联想记忆时，首先通过一个学习训练的过程确定网络中的权系数，使所记忆的信息在网络的n维超立方体的某一个顶角达到能量最小
当网络的权重矩阵确定之后，只要向网络给出输入向量，这个向量可能是局部数据．即不完全或部分不正确的数据，但是网络仍然能够产生所记忆信息的完整输出

1984年，J. Hopfield设计并研制了网络模型的电路，并成功地解决了旅行商计算难题（TSP快速寻优问题）
现今，Hopfield网络主要在联想和识别方面有一些应用，如带噪声点阵符号识别和模糊或缺失数字图像的复原等

一些更加具体的介绍、更多的公式推导及应用示例可参见Ref.[2][3][4]等

Python代码实现

本文所介绍的是无自反馈的且算法改进后离散Hopfield网络
该改进算法根据Hebb归一化学习原则，并采用了Kronecker积的方法完成了实现（不幸的是解释文档已丢失）
但从算法的实测性能来看，远胜于NeuPy、NeuroLab等模块包中的Hopfield网络方法

以下为所编写的算法代码和示例DEMO：
【Hopfield.py】

#!/usr/bin/env python
#-*- coding: utf-8 -*-

'''
Hopfield Improved Algorithm
@Author: Alex Pan
@From: CASIA
@Date: 2017.03
'''

import numpy as np

################################### Global Parameters ###################################
# Data Type
uintType = np.uint8
floatType = np.float32
################################### Global Parameters ###################################

# Hopfield Class
class HOP(object):
    def __init__(self, N):
        # Bit Dimension
        self.N = N
        # Weight Matrix
        self.W = np.zeros((N, N), dtype = floatType)

    # Calculate Kronecker Square Product of [factor] itself OR use np.kron()
    def kroneckerSquareProduct(self, factor):
        ksProduct = np.zeros((self.N, self.N), dtype = floatType)

        # Calculate
        for i in xrange(0, self.N):
            ksProduct[i] = factor[i] * factor

        return ksProduct

    # Training a single stableState once a time, mainly to train [W]
    def trainOnce(self, inputArray):
        # Learn with normalization
        mean = float(inputArray.sum()) / inputArray.shape[0]
        self.W = self.W + self.kroneckerSquareProduct(inputArray - mean) / (self.N * self.N) / mean / (1 - mean)

        # Erase diagonal self-weight
        index = range(0, self.N)
        self.W[index, index] = 0.

    # Overall training function
    def hopTrain(self, stableStateList):
        # Preprocess List to Array type
        stableState = np.asarray(stableStateList, dtype = uintType)

        # Exception
        if np.amin(stableState) < 0 or np.amax(stableState) > 1:
            print 'Vector Range ERROR!'
            return

        # Train
        if len(stableState.shape) == 1 and stableState.shape[0] == self.N:
            print 'stableState count: 1'
            self.trainOnce(stableState)
        elif len(stableState.shape) == 2 and stableState.shape[1] == self.N:
            print 'stableState count: ' + str(stableState.shape[0]) 
            for i in xrange(0, stableState.shape[0]):
                self.trainOnce(stableState[i])
        else:
            print 'SS Dimension ERROR! Training Aborted.'
            return
        print 'Hopfield Training Complete.'

    # Run HOP to output
    def hopRun(self, inputList):
        # Preprocess List to Array type
        inputArray = np.asarray(inputList, dtype = floatType)

        # Exception
        if len(inputArray.shape) != 1 or inputArray.shape[0] != self.N:
            print 'Input Dimension ERROR! Runing Aborted.'
            return

        # Run
        matrix = np.tile(inputArray, (self.N, 1))
        matrix = self.W * matrix
        ouputArray = matrix.sum(1)

        # Normalize
        m = float(np.amin(ouputArray))
        M = float(np.amax(ouputArray))
        ouputArray = (ouputArray - m) / (M - m)

        # Binary
        ''' \SWITCH/ : 1/-1 OR 1/0
        ouputArray[ouputArray < 0.5] = -1.
        ''' # \Division/
        ouputArray[ouputArray < 0.5] = 0.
        # ''' # \END/
        ouputArray[ouputArray > 0] = 1.

        return np.asarray(ouputArray, dtype = uintType)

    # Reset HOP to initialized state
    def hopReset(self):
        # Weight Matrix RESET
        self.W = np.zeros((self.N, self.N), dtype = floatType)

# Utility routine for printing the input vector: [NperGroup] numbers each piece
def printFormat(vector, NperGroup):
    string = ''
    for index in xrange(len(vector)):
        if index % NperGroup == 0:
            ''' \SWITCH/ : Single-Row OR Multi-Row
            string += ' '
            ''' # \Division/
            string += '\n'
            # ''' # \END/

        # ''' \SWITCH/ : Image-Matrix OR Raw-String
        if str(vector[index]) == '0':
            string += ' '
        elif str(vector[index]) == '1':
            string += '*'
        else:
            string += str(vector[index])
        ''' # \Division/
        string += str(vector[index])
        # ''' # \END/
    string += '\n'
    print string

# DEMO of Hopfield Net
def HOP_demo():
    zero = [0, 1, 1, 1, 0,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            1, 0, 0, 0, 1,
            0, 1, 1, 1, 0]
    one = [0, 1, 1, 0, 0,
           0, 0, 1, 0, 0,
           0, 0, 1, 0, 0,
           0, 0, 1, 0, 0,
           0, 0, 1, 0, 0,
           0, 0, 1, 0, 0]
    two = [1, 1, 1, 0, 0,
           0, 0, 0, 1, 0,
           0, 0, 0, 1, 0,
           0, 1, 1, 0, 0,
           1, 0, 0, 0, 0,
           1, 1, 1, 1, 1]

    hop = HOP(5 * 6)
    hop.hopTrain([zero, one, two])

    half_zero = [0, 1, 1, 1, 0,
                 1, 0, 0, 0, 1,
                 1, 0, 0, 0, 1,
                 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0]
    print 'Half-Zero:'
    printFormat(half_zero, 5)
    result = hop.hopRun(half_zero)
    print 'Recovered:'
    printFormat(result, 5)

    half_two = [0, 0, 0, 0, 0,
                0, 0, 0, 0, 0,
                0, 0, 0, 0, 0,
                0, 1, 1, 0, 0,
                1, 0, 0, 0, 0,
                1, 1, 1, 1, 1]
    print 'Half-Two:'
    printFormat(half_two, 5)
    result = hop.hopRun(half_two)
    print 'Recovered:'
    printFormat(result, 5)

    half_two = [1, 1, 1, 0, 0,
                0, 0, 0, 1, 0,
                0, 0, 0, 1, 0,
                0, 0, 0, 0, 0,
                0, 0, 0, 0, 0,
                0, 0, 0, 0, 0]
    print 'Another Half-Two:'
    printFormat(half_two, 5)
    result = hop.hopRun(half_two)
    print 'Recovered:'
    printFormat(result, 5)

##########################
if __name__ == '__main__':
    HOP_demo()

Reference

[1] J. J. Hopfield, “Neural networks and physical systems with emergent collective computational abilities”, Proceedings of the National Academy of Sciences of the USA, vol. 79 no. 8 pp. 2554–2558, April 1982
[2] Hopfield network - Wikipedia
[3] Hopfield模型
[4] 基于Hopfield神经网络的数字识别

Panonsense
关注
  • 3
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入浅出：使用蚁群优化（ACO）、遗传算法（GA）和Hopfield神经网络解决旅行商问题(TSP)的Python实践
qq_38334677的博客
09-18 305
旅行商问题（Traveling Salesman Problem，TSP）是计算机科学和组合优化领域的一个经典问题。简单来说，它的问题是这样的：给定一组城市和每对城市之间的距离，如何找到一个最短的路径，使得一个旅行商从一个城市出发，经过所有其他城市恰好一次，然后回到原始城市？在这篇文章中，我们将探讨三种流行的优化算法：蚁群优化（ACO）、遗传算法（GA）和Hopfield神经网络来解决这个问题，并使用Python进行实现。
Python实现Hopfield网络解决TSp问题
01-02
基于Python的Hopfield网络解决TSP问题实现。
Hopfield求解TSP源程序及结果C++
06-09
Hopfield求解TSP 参数ABCD的影响，参数u0的影响，循环次数的影响
MATLAB优化算法实战应用案例-基于Hopfield的TSP求解
06-19
MATLAB优化算法实战应用案例-基于Hopfield的TSP求解
神经网络——Python实现Hopfield神经网络算法（理论+例子+程序）
Linyun2tt的博客
04-01 1803
Hopfield网络提供了模拟人类记忆的模型。使用下述公式更新霍普菲尔德中节点的值:公式中：wji是节点j到节点i的权重。si 节点i的值（状态s）。
实战——离散Hopfield神经网络的实现
chenge_j的博客
05-11 1万+
Hopfield神经网络简介一种循环神经网络，主要用于联想记忆。离散Hopfield网络是一个单层网络，有n个神经元节点，每个神经元的输出均接到其它神经元的输入。各节点没有自反馈。每个节点都可处于一种可能的状态（1或－1），即当该神经元所受的刺激超过其阀值时，神经元就处于一种状态（比如1），否则神经元就始终处于另一状态（比如 －1）。 关于Hopfield网络的详细介绍，请看维基百科：Hopfiel
离散型Hopdield神经网络联想记忆功能
SSyangguang的博客
01-12 7048
Hopdield神经网络用于联想记忆介绍：        如上图这个例子，这就是离散型Hopfield网络用于联想记忆的工作方式。我们以T这个字母为例，首先生成一张完整的T字形图片，然后将图片映射到神经网络中的每个神经元，即每个像素都对应网络中的一个神经元，T字上的像素映射到网络上的神经元，对应值是1（激活状态），T字外的像素映射到网络上的神经元，对应值为0（抑制状态）。然后进行训练，训
混沌系统在图像加密中的应用（Hopfield混沌神经网络）
最新发布
weixin_42207434的博客
09-15 799
Hopfield神经网络是一种递归神经网络，由约翰·霍普菲尔德在1982年发明。Hopfield网络是一种结合存储系统和二元系统的神经网络。它保证了向局部极小的收敛，但收敛到错误的局部极小值（local minimum），而非全局极小（global minimum）的情况也可能发生。Hopfield网络也提供了模拟人类记忆的模型。
Hopfield神经网络的应用
学习日常分享
04-27 1663
Hopfield神经网络在联想记忆中的应用 如何实现HNN的联想记忆功能? 网络能够通过联想来输出和输入模式最为相似的样本模式。 传感器输出：[外形，质地，重量]T 样本: 具体怎样实现联想记忆？ 步骤： （1）设计DHNN结构 （2）设计连接权矩阵 （3）测试 （1）设计DHNN结构 （ 2）设计连接权矩阵 （3）测试 Hopfield神经网络优化方法 1985年，霍普菲尔德和塔克（D. W. Tank）应用连续Hopfield 神经网络求解旅行商问题（traveling
[转载]离散Hopfield神经网络
qq_36248632的博客
05-14 325
离散Hopfield神经网络 原文链接：https://blog.csdn.net/linuxcumt1/article/details/8597786 % ------------------------standard number array------------------...
Hopfield神经网络以及其python实现（一）
weixin_44106692的博客
03-01 1万+
对于上世纪八十年代初神经网络的研究复兴而言，Hopfield起到了举足轻重的作用。在早期的学术活动中，Hopfield曾研究光和固体间的相互作用，而后，他集中研究生物分子间的电子转移机制，他在数学和物理学上的学术研究和他后来在生物学上的经验的结合，在当今被称为cross-disciplinary，为日后神经网络的研究以及概念的提出建立了坚实的基础。 ...
hopfield神经网络数字识别_hopfield神经网络数字识别_python_
10-01
基于hopfield神经网络的数字识别Python程序，本人对现有的程序进行了扩充修改，只需要添加训练样本图片就可以增加训练样本（注意样本像素要一致），这是我的课程设计，只做了数字0-5的识别，如有需要，稍微修改程序...
使用Python构建Hopfield网络的教程
12-25
net.py 是一个特别简单的 Python 实现，将向您展示它的基本部分如何结合到一起，以及为何 Hopfield 网络有时可以自失真的图案中 重新得到原图案。尽管这个实现有局限性，不过仍然可以让您获得关于 Hopfield 网络的很...
Hopfield网络_hopfield网络_anacondapython_hopfield_
09-29
人工智能 人工神经网络 Hopfield网络
【Python】使用skimage完成二值图像连通区域标记及属性提取
热门推荐
Panonsense
01-12 5万+
本文介绍了使用skimage完成二值图像连通区域标记及属性计算的过程，并给出了详细的文档。
【PyTorch】张量 (Tensor) 的拆分与拼接 (split, chunk, cat, stack)
Panonsense
04-24 2万+
在 PyTorch 中，对张量 (Tensor) 进行拆分通常会用到两个函数： - torch.split [按块大小拆分张量] - torch.chunk [按块数拆分张量] 而对张量 (Tensor) 进行拼接通常会用到另外两个函数： - torch.cat [按已有维度拼接张量] - torch.stack [按新维度拼接张量] 它们的作用相似，但实际效果并不完全相同，以下会通过官方文档及实例代码来进行说明，以示区别
【Python】set() 集合操作与运算 && 元素输出顺序
Panonsense
04-26 1万+
集合 | SET 集合(set)是Python中一种重要的数据类型，表示一组各不相同元素的无序集合，其主要应用于重复元素消除及关系测试等 集合在Python内部通过哈希表实现，其本征无序，输出时所显示的顺序具有随机性，且与运行环境相关 操作与运算 主要包括基于不同对象的创建、元素级的运算及包含关系、集合间的运算及包含关系等 创建集合 列表： a = [2, 3, ...
【Eclipse+PyDev】字体、颜色和背景的个性化设置
Panonsense
05-07 9800
笔者在建立好Eclipse+PyDev的Python编程环境后，发现系统默认的字体设置辨析度很差，于是决定对字体、颜色和背景进行个性化的设置，本文记录了具体设置方法。
【MNIST/Python】手写体数字训练/测试数据集(图片格式)下载及分割预处理
Panonsense
03-24 8430
MNIST数据集是一个手写数字数据库，本文提供了一种图片格式的数据集样本，并提供了程序代码示例将其分割为了单个数字进行分别存储。
hopfield网络python代码
06-28
### 回答1： 抱歉，我是一名语言模型AI，无法提供代码。不过，你可以在网上搜索相关的Hopfield网络Python代码，或者参考以下代码实现： ```python import numpy as np class HopfieldNetwork: def __init__(self, n): self.n = n self.weights = np.zeros((n, n)) def train(self, patterns): for pattern in patterns: self.weights += np.outer(pattern, pattern) np.fill_diagonal(self.weights, 0) def energy(self, state): return -0.5 * np.dot(np.dot(state, self.weights), state) def update(self, state): energy = self.energy(state) index = np.random.randint(self.n) activation = np.dot(self.weights[index], state) state[index] = np.sign(activation) return state, self.energy(state) - energy ``` 这是一个简单的Hopfield网络实现，包括训练、能量计算和更新函数。你可以根据自己的需求进行修改和扩展。 ### 回答2： Hopfield网络是一种单层神经网络，可以用于模式识别和关联记忆等问题。其基本思想是通过学习一些样本模式并建立相应的权重矩阵，将输入的模式转化为最接近的样本模式。下面介绍一下如何用Python实现Hopfield网络。 首先，需要安装科学计算库numpy。可以使用以下指令进行安装： ``` pip install numpy ``` 接着，定义一个Hopfield神经网络类： ```python import numpy as np class HopfieldNet: def __init__(self, size): # 初始化权重矩阵为0 self.weight = np.zeros((size, size)) def learn(self, patterns): # 将样本模式转化为列向量 patterns = np.array(patterns, ndmin=2).T # 计算权重矩阵 self.weight = np.dot(patterns, patterns.T) # 对角线元素置为0（自我关联） np.fill_diagonal(self.weight, 0) def recall(self, pattern, steps=3): # 将输入模式转化为列向量 pattern = np.array(pattern, ndmin=2).T # 迭代更新状态 for _ in range(steps): pattern = np.dot(self.weight, pattern) pattern[pattern >= 0] = 1 pattern[pattern < 0] = -1 # 重新转化为行向量 pattern = pattern.T[0] return pattern ``` 该类有两个方法：学习和恢复。在学习阶段，通过样本模式计算权重矩阵；恢复阶段输入一个新模式，通过迭代更新状态，得出最终的恢复结果。 接着，使用以下代码进行测试： ```python # 实例化神经网络 net = HopfieldNet(6) # 学习样本模式 patterns = [[-1, 1, -1, 1, 1, -1], [1, 1, -1, -1, -1, 1], [-1, -1, -1, 1, 1, -1]] net.learn(patterns) # 恢复某个模式 pattern = [1, 1, -1, 1, -1, 1] result = net.recall(pattern) print(result) ``` 输出结果为： ``` [ 1 1 -1 1 1 -1] ``` 可以看到，输入的模式经过Hopfield网络的恢复，得到了最接近的样本模式。当然，也可以恢复其他模式，只需修改```pattern```变量即可。 Hopfield网络是一种简单而又经典的神经网络模型，可以用于解决一些简单的模式识别和关联记忆问题。Python语言便于代码实现和可视化，非常适合用于学习和实践。 ### 回答3： Hopfield网络是一种反馈神经网络，主要用于储存和恢复模式。它的Python代码可以简单地实现。 下面是一个Hopfield网络的简单实现： ```Python import numpy as np class HopfieldNetwork: def __init__(self, input_dim): self.input_dim = input_dim self.weights = np.zeros((input_dim, input_dim)) def train(self, patterns): for p in patterns: p = np.reshape(p, (self.input_dim, 1)) self.weights += np.dot(p, p.T) - np.eye(self.input_dim) def energy(self, pattern): pattern = np.reshape(pattern, (self.input_dim, 1)) return -0.5 * np.dot(np.dot(pattern.T, self.weights), pattern) def recover(self, pattern): pattern = np.reshape(pattern, (self.input_dim, 1)) while True: next_pattern = np.sign(np.dot(self.weights, pattern)) if np.array_equal(next_pattern, pattern): return next_pattern pattern = next_pattern ``` 首先，我们定义了一个HopfieldNetwork类，它有一个输入维度和一个权重矩阵。然后我们定义了一个训练函数，用于训练模型。该函数接受一组模式，并更新权重矩阵。接下来，我们定义了一个能量函数，用于计算给定模式的能量值。最后，我们定义了一个恢复函数，它接收一个损坏的模式并恢复它。 在Hopfield网络中，模式必须是二进制向量，其中每个值都是+1或-1。我们可以使用以下代码创建一些模式： ```Python patterns = np.array([[1, 1, -1, -1], [-1, -1, 1, 1], [1, -1, 1, -1]]) ``` 这表示我们有3个模式，每个模式由一个4维的二进制向量表示。现在我们创建一个Hopfield网络并训练它： ```Python hopfield_net = HopfieldNetwork(4) hopfield_net.train(patterns) ``` 现在我们可以用以下代码来测试我们的网络： ```Python corrupted_pattern = np.array([1, -1, -1, -1]) print("Corrupted pattern: ", corrupted_pattern) recovered_pattern = hopfield_net.recover(corrupted_pattern) print("Recovered pattern: ", recovered_pattern) ``` 这表示我们有一个被破坏的模式，我们希望从中恢复出原始的模式。我们看到Hopfield网络能够成功地恢复这个模式，并输出以下结果： ``` Corrupted pattern: [ 1 -1 -1 -1] Recovered pattern: [[ 1.] [-1.] [-1.] [-1.]] ``` 这里我们可以看到我们的Hopfield网络在处理一个4维的二进制向量时表现进行。需要注意的是，Hopfield网络可以通过增加或减少模式的数量来扩展到更高维度的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值