2. 程式人生 > >【Python】改進Hopfield網路程式碼實現

【Python】改進Hopfield網路程式碼實現

阿新 • • 發佈：2018-11-01

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神經網路的數字識別

相關推薦

【Python】改進Hopfield網路程式碼實現

Hopfield網路 Hopfield網路由美國加州理工學院物理學教授J. J. Hopfield於1982年提出[1] 網路從輸出到輸入有反饋連線，在輸入的激勵下，會產生不斷的狀態變化，是一種單層反饋神經網路，也可以被視為一種迴圈神經網路 Hopfield神經網路是反饋網路中最

【Python】用生成器generator簡單實現楊輝三角

楊輝三角，又稱賈憲三角形，帕斯卡三角形，是二項式係數在三角形中的一種幾何排列。 def triangles(): L=[1] while(True): yield L L=[1]+[x+y for x,y in zip(L[:-1],L[1:])]+[1] n = 0 max=int(input

【初探】“ 選擇排序 ” ——C++程式碼實現

  選擇排序(Selection sort)是一種簡單直觀的排序演算法。無論什麼資料進去都是 O(n²) 的時間複雜度。所以用到它的時候，資料規模越小越好。唯一的好處可能就是不佔用額外的記憶體空間了吧。   簡單排序處理流程 首先在未排序序列中找到最小

+【CSS3】使用純css程式碼實現圖片輪播效果

 使用純CSS3程式碼實現簡單的圖片輪播。 基本思路： 以5張圖片為例： 1.基本佈局： 將5張圖片左浮動橫向並排放入一個div容器（#photos）內，圖片設定統一尺寸，div寬度設定5個圖片的總尺寸，然後放入相框容器div（#frame），相框設定1個圖片

【Python】使用openCV與dlib實現人臉68特徵點的檢測與手動修改

在使用plib檢測人臉特徵點的過程中由於各種原因難免會遇到特徵點定位不準確的情況。這時，如果能夠手動修改來移動特徵點的位置，後續工作則可以更好地得以完成。 由於openCV的畫圖工具會覆蓋原來的圖片，這裡我通過手動儲存被修改畫素的辦法實現移動定位點而不損害原來

【Python】 簡單網路爬蟲實現

引言 網路爬蟲（英語：web crawler），也叫網路蜘蛛（spider），是一種用來自動瀏覽全球資訊網的網路機器人。其目的一般為編纂網路索引。 --維基百科 網路爬蟲可以將自己所訪問的頁面儲存下來，以便搜尋引擎事後生成索引供使用者搜尋。 一般有兩個步驟：1.獲取網頁內

【Python】決策樹的python實現

uia bmp say 不知道 times otto outlook lru bgm 【Python】決策樹的python實現 2016-12-08 數據分析師Nieson 1. 決策樹是什麽? 簡單地理解，就是根據一些 feature 進行分類，每個節點提一個問

【Python】11、集合與字典的實現

python一、字典的實現dict是在list之上實現的 i（索引） = hash(key) % solt(槽位數)此時i重復了怎麽辦（hash沖突）？1、拉鏈法 每個槽位上拉一個List，就是拉鏈法2、開地址法 使用某個算法重新計算i，就交開地址法 常用，效率更高，i = fn(key, i)【Pyt

【Python】Http Post請求四種請求體的Python實現

article gif 提交 直接 方法 method 根據 encode 文獻 前言 前幾天一個剛接觸Python不深的朋友問我的Python的xml格式Post請求怎麽發送，剛好最近也在看Http請求相關的內容，所以決定總結一下。 Content-Type Conte

【Python】曲線簡化演算法實現

Overview 曲線簡化演算法通常應用於運動捕捉資料的關鍵幀提取，在此基礎上還演化出了更多的演算法 本文對基本的曲線簡化演算法進行了程式碼實現，以關鍵幀個數或線性重建誤差作為迭代終止條件 其中，計算點i到直線n1-n2的距離公式如下[1]： 更多演算法及分析可參考[2]

【springboot】spring boot修改程式碼後無需重啟設定，在開發時實現熱部署

熱部署是什麼 大家都知道在專案開發過程中，常常會改動頁面資料或者修改資料結構，為了顯示改動效果，往往需要重啟應用檢視改變效果，其實就是重新編譯生成了新的Class檔案，這個檔案裡記錄著和程式碼等對應的各種資訊，然後Class檔案將被虛擬機器的ClassLoader載入。 而熱部署正是利用了這

【電腦科學】【2016】【含部分原始碼】深度神經網路及其實現

本文為捷克布拉格查理大學（作者：Bc. Ján Vojt）的碩士論文，共104頁。 深度神經網路是一種有效且通用的模型，能夠完成各種各樣的任務。本文主要研究了三種不同型別的深度神經網路——多層感知器、卷積神經網路和深度置信網路。所有討論的網路模型都是在並行硬體上實現的，並且針對網路

【深度學習】ResNet解讀及程式碼實現

簡介 ResNet是何凱明大神在2015年提出的一種網路結構，獲得了ILSVRC-2015分類任務的第一名，同時在ImageNet detection，ImageNet localization，COCO detection和COCO segmentation等任務中均獲得了第一名，在當

【Python】搭建你的第一個簡單的神經網路_理論篇_NN&DL學習筆記（一）

前言 本文為《Neural Network and Deep Learning》學習筆記（一），可以轉載但請標明原文地址。 本人剛剛入門、筆記簡陋不足、多有謬誤，而原書精妙易懂、不長篇幅常有柳暗花明之處，故推薦閱讀原書。 《Neural Network and Deep Learning

【python】詳解pandas.DataFrame.plot( ) 中引數secondary_y實現雙座標軸使用

首先看官網的DataFrame.plot( )函式 secondary_y : boolean or sequence, default False # 可以是布林值或者是數列 Whether to plot on the secondary y-axis

【python】詳解事件驅動event實現

所有的計算機程式都可以大致分為兩類：指令碼型（單次執行）和連續執行型（直到使用者主動退出）。 指令碼型：指令碼型的程式包括最早的批處理檔案以及使用Python做交易策略回測等等，這類程式的特點是在使用者啟動後會按照程式設計時設計好的步驟一步步執行，所有步驟執行完後自動退出。

Python CNN卷積神經網路程式碼實現

1 # -*- coding: utf-8 -*- 2 """ 3 Created on Wed Nov 21 17:32:28 2018 4 5 @author: zhen 6 """ 7 8 import tensorflow as tf 9 from tensorflow.e

【Python】搭建你的第一個簡單的神經網路_實踐篇_NN&DL學習筆記（三）

前言 本文為《Neural Network and Deep Learning》學習筆記（三），可以轉載但請標明原文地址。 本人剛剛入門、筆記簡陋不足、多有謬誤，而原書精妙易懂、不長篇幅常有柳暗花明之處，故推薦閱讀原書。 《Neural Network and Deep Learning

【Python】搭建你的第一個簡單的神經網路_準備篇_NN&DL學習筆記（二）

前言 本文為《Neural Network and Deep Learning》學習筆記（二），可以轉載但請標明原文地址。 本人剛剛入門、筆記簡陋不足、多有謬誤，而原書精妙易懂、不長篇幅常有柳暗花明之處，故推薦閱讀原書。 《Neural Network and Deep Learning

【Python】TCP網路程式設計

【Python TCP網路使用】 注意： 必須先啟動伺服器！！！不然會報錯 import socket; def LanJian_TcpClient(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM)