Source code for neurodynex.hopfield_network.hopfield_demo

import hf_plot_tools as hfplot
import hf_pattern_tools as pattern_tools
import hf_network
import matplotlib.pyplot as plt
import numpy as np


[docs]def run_hf_demo(pattern_size=4, nr_random_patterns=3, reference_pattern=0, initially_flipped_pixels=3, nr_iterations=6, random_seed=None): # instantiate a hofpfield network hopfield_net = hf_network.HopfieldNetwork(pattern_size**2) # instantiate a pattern factory factory = pattern_tools.PatternFactory(pattern_size, pattern_size) # create a checkerboard pattern and add it to the pattern list checkerboard = factory.create_checkerboard() pattern_list = [checkerboard] # add random patterns to the list pattern_list.extend(factory.create_random_pattern_list(nr_random_patterns, on_probability=0.5)) hfplot.plot_pattern_list(pattern_list) # let the hopfield network 'learn' the patterns. Note: they are not stored # explicitly but only network weights are updated ! hopfield_net.store_patterns(pattern_list) # how similar are the random patterns? Check the overlaps overlap_matrix = pattern_tools.compute_overlap_matrix(pattern_list) hfplot.plot_overlap_matrix(overlap_matrix) # create a noisy version of a pattern and use that to initialize the network noisy_init_state = pattern_tools.flip_n(pattern_list[reference_pattern], initially_flipped_pixels) hopfield_net.set_state_from_pattern(noisy_init_state) # uncomment the following line to enable a PROBABILISTIC network dynamic # hopfield_net.set_dynamics_probabilistic_sync(2.5) # uncomment the following line to enable an ASYNCHRONOUS network dynamic # hopfield_net.set_dynamics_sign_async() # run the network dynamics and record the network state at every time step states = hopfield_net.run_with_monitoring(nr_iterations) # each network state is a vector. reshape it to the same shape used to create the patterns. states_as_patterns = factory.reshape_patterns(states) # plot the states of the network hfplot.plot_state_sequence_and_overlap(states_as_patterns, pattern_list, reference_pattern) plt.show()
[docs]def run_hf_demo_alphabet(letters, initialization_noise_level=0.2, random_seed=None): import numpy as np # in your code, don't forget to import hf_plot_tools # 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 = hf_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)
[docs]def run_demo(): # Demo2: more neurons, more patterns, more noise run_hf_demo(pattern_size=6, nr_random_patterns=5, initially_flipped_pixels=11, nr_iterations=5) # Demo3: more parameters # run_hf_demo(pattern_size=4, nr_random_patterns=5, # reference_pattern=0, initially_flipped_pixels=4, nr_iterations=6, # random_seed=50) print('recover letter A') letter_list = ['a', 'b', 'c', 's', 'x', 'y', 'z'] run_hf_demo_alphabet(letter_list, initialization_noise_level=0.2, random_seed=76) print('letter A not recovered despite the overlap m = 1 after one iteration') letter_list.append('r') run_hf_demo_alphabet(letter_list, initialization_noise_level=0.2, random_seed=76)
if __name__ == '__main__': run_demo()