def test_load_alphabet():
"""Test if the alphabet patterns can be loaded"""
import neurodynex.hopfield_network.pattern_tools as pattern_tools
abc_dictionary = pattern_tools.load_alphabet()
assert 'A' in abc_dictionary, \
"Alphabet dict not correctly loaded. Key not accessible"
assert abc_dictionary['A'].shape == (10, 10), \
"Letter is not of shape (10,10)"
def run_hf_demo_alphabet(letters,
initialization_noise_level=0.2,
random_seed=None):
"""
Simple demo
Args:
letters:
initialization_noise_level:
random_seed:
Returns:
"""
# fixed size 10 for the alphabet.
pattern_size = 10
# pick some letters we want to store in the network
if letters is None:
letters = ['A', 'B', 'C', 'R', 'S', 'X', 'Y', 'Z']
reference_pattern = 0
# instantiate a hofpfield network
hopfield_net = network.HopfieldNetwork(pattern_size**2)
# for the demo, use a seed to get a reproducible pattern
np.random.seed(random_seed)
# load the dictionary
abc_dict = pattern_tools.load_alphabet()
# for each key in letters, append the pattern to the list
pattern_list = [abc_dict[key] for key in letters]
hfplot.plot_pattern_list(pattern_list)
hopfield_net.store_patterns(pattern_list)
hopfield_net.set_state_from_pattern(
pattern_tools.get_noisy_copy(abc_dict[letters[reference_pattern]],
initialization_noise_level))
states = hopfield_net.run_with_monitoring(6)
state_patterns = pattern_tools.reshape_patterns(states,
pattern_list[0].shape)
hfplot.plot_state_sequence_and_overlap(state_patterns, pattern_list,
reference_pattern)
plt.show()
def run_hf_demo_alphabet(letters, initialization_noise_level=0.2, random_seed=None):
"""
Simple demo
Args:
letters:
initialization_noise_level:
random_seed:
Returns:
"""
# fixed size 10 for the alphabet.
pattern_size = 10
# pick some letters we want to store in the network
if letters is None:
letters = ['A', 'B', 'C', 'R', 'S', 'X', 'Y', 'Z']
reference_pattern = 0
# instantiate a hofpfield network
hopfield_net = network.HopfieldNetwork(pattern_size**2)
# for the demo, use a seed to get a reproducible pattern
np.random.seed(random_seed)
# load the dictionary
abc_dict = pattern_tools.load_alphabet()
# for each key in letters, append the pattern to the list
pattern_list = [abc_dict[key] for key in letters]
hfplot.plot_pattern_list(pattern_list)
hopfield_net.store_patterns(pattern_list)
hopfield_net.set_state_from_pattern(
pattern_tools.get_noisy_copy(abc_dict[letters[reference_pattern]], initialization_noise_level))
states = hopfield_net.run_with_monitoring(6)
state_patterns = pattern_tools.reshape_patterns(states, pattern_list[0].shape)
hfplot.plot_state_sequence_and_overlap(state_patterns, pattern_list, reference_pattern)
plt.show()
from scipy import * from lec import * #nr_neurons N = 100 # the letters we want to store in the hopfield network #letter_list = ['A', 'B', 'C', 'D'] #letter_list = ['E', 'F', 'G', 'H', 'I'] #letter_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'] letter_list = ['A', 'B', 'E', 'H', 'I'] # set a seed to reproduce the same noise in the next run # np.random.seed(123) abc_dictionary = pattern_tools.load_alphabet() # create an instance of the class HopfieldNetwork hopfield_net = network.HopfieldNetwork(nr_neurons=N) #hopfield_net = network.HopfieldNetwork(nr_neurons= pattern_shape[0]*pattern_shape[1]) # create a list using Pythons List Comprehension syntax: pattern_list = [abc_dictionary[key] for key in letter_list] plot_tools.plot_pattern_list(pattern_list) # how similar are the letter patterns overlap_matrix = pattern_tools.compute_overlap_matrix(pattern_list) plot_tools.plot_overlap_matrix(overlap_matrix) # store the patterns hopfield_net.store_patterns(pattern_list)
import numpy as np
import random
import matplotlib.pyplot as plt
from neurodynex.hopfield_network import network, pattern_tools, plot_tools
add_extra = False
# the letters we want to store in the hopfield network
letter_list = ['N', 'C', 'B', 'S', 'X', 'Y' ]
extra = [ 'P', 'Q' ]
if add_extra == True:
letter_list += extra
nRows, maxCols = 4, len(letter_list)
abc_dictionary = pattern_tools.load_alphabet()
def add_noise( letter, noise_level = 0.2 ):
pat = abc_dictionary[letter]
print( "[INFO ] Adding noise (level=%f) to %s" % (noise_level, letter))
# input( "Press any key to continue" )
# print( " to %s" % letter )
for (i, j), v in np.ndenumerate(pat):
if random.random() < noise_level:
pat[i, j] = random.choice( [-1, 1] )
return pat
def main( plot = True ):
# set a seed to reproduce the same noise in the next run
# numpy.random.seed(123)
# access the first element and get it's size (they are all of same size)
