def ex_3_4():
dataset = np.loadtxt('pict.dat', delimiter=",",
dtype=int).reshape(-1, 1024)
train_patterns = dataset[0:3].copy()
hopfield = Hopfield(train_patterns)
hopfield.train()
for idx, pattern in enumerate(train_patterns):
for percentage in range(100):
percentage = percentage / 100 + 0.01
dist_pic = Utils.distort_data(pattern, percentage)
recalled, energy, iter = hopfield.recall(dist_pic,
number_of_dataset=1,
method='Batch')
images = [
np.reshape(dist_pic, (32, 32)),
np.reshape(recalled, (32, 32))
]
titles = [
"Distorted with {}% noise".format(percentage),
"Recalled picture"
]
fname = 'pattern_{0}_percent_{1}'.format(idx + 1,
round(percentage, 3))
save_dir = 'pictures/3_4/{0}.png'.format(fname)
Utils.show_images(images, save_dir=save_dir, rows=1, titles=titles)
def ex_3_5_4():
random_patterns = np.array(Utils.generate_random_pattern(N=(300, 100)))
# for j, pattern in enumerate(random_patterns):
# random_patterns[j,:] = Utils.distort_data(pattern, 0.1)
stable_patterns = []
for i in range(1, 250):
print(i)
training_data = random_patterns[0:i]
hopfield = Hopfield(training_data)
hopfield.train()
count = 0
for j, pattern in enumerate(training_data):
# value, _, iteration_finished = hopfield.recall(pattern, n_iterations=3)
# if iteration_finished == 1:
if hopfield.is_stable(hopfield.weight_matrix, pattern):
count += 1
print('number of correct {0} , {1}'.format(count,
count / len(training_data)))
stable_patterns.append(count / len(training_data))
Utils.plot_stable_patterns(
np.array(stable_patterns),
'Stability of patterns no noise, diagonal zero, biased patterns')
def ex_3_3_4():
dataset = np.loadtxt('pict.dat', delimiter=",",
dtype=int).reshape(-1, 1024)
train_patterns = dataset[0:3].copy()
dim = 1024
start_state = np.random.randn(dim)
method = ['Random', 'Async']
for m in method:
hopfield = Hopfield(start_state,
random_weights=True,
method=m,
make_weights_symmetric=True)
hopfield.train()
# hopfield.weight_matrix = np.random.randn(dim, dim)
pattern = Utils.generate_random_pattern(train_patterns.shape[1])
recalled, energy, iter = hopfield.recall(pattern,
1,
calculate_energy=True,
n_iterations=50)
# print(energy)
# Utils.display_image(recalled, '')
# recalled, energy = hopfield.recall(dataset[10], n_iterations=100, method='Random', calculate_energy=True)
Utils.plot_energy_line(
energy, 'Energy',
'Energy using {} update using symmetric weights'.format(m))
def ex_3_1_1():
memory_patterns = np.array([[-1., -1., 1., -1., 1., -1., -1., 1.],
[-1., -1., -1., -1., -1., 1., -1., -1.],
[-1., 1., 1., -1., -1., 1., -1., 1.]])
hopfield = Hopfield(memory_patterns)
hopfield.train()
distorted = np.array([[1, -1, 1, -1, 1, -1, -1, 1],
[1, 1, -1, -1, -1, 1, -1, -1],
[1, 1, 1, -1, 1, 1, -1, 1]])
print(check_stability(hopfield, distorted, memory_patterns))
def ex_3_1_3():
memory_patterns = np.array([[-1., -1., 1., -1., 1., -1., -1., 1.],
[-1., -1., -1., -1., -1., 1., -1., -1.],
[-1., 1., 1., -1., -1., 1., -1., 1.]])
hopfield = Hopfield(memory_patterns)
hopfield.train()
distorted = np.array([[-1, -1, 1, 1, -1, 1, 1, 1]])
# distorted = np.repeat(distorted, 3, axis=0)
_, recalled = check_stability(hopfield, distorted, memory_patterns)
print(recalled)
def ex_3_3_5():
dataset = np.loadtxt('pict.dat', delimiter=",",
dtype=int).reshape(-1, 1024)
train_patterns = dataset[0:3].copy()
hopfield = Hopfield(train_patterns, make_weights_symmetric=True)
start_state = np.random.normal(0, 1, len(dataset[0]))
recalled, energy, iter = hopfield.recall(dataset[10],
n_iterations=100,
method='Random',
calculate_energy=True)
Utils.plot_energy_line(
energy, 'Energy',
'Energy random asynchronous update using symmetric weights')
def ex_3_1_2():
memory_patterns = np.array([[-1., -1., 1., -1., 1., -1., -1., 1.],
[-1., -1., -1., -1., -1., 1., -1., -1.],
[-1., 1., 1., -1., -1., 1., -1., 1.]])
hopfield = Hopfield(memory_patterns)
hopfield.train()
lst = [list(i) for i in itertools.product([-1., 1.], repeat=8)]
lst = np.array(lst)
attractors = []
for i in range(len(lst)):
pattern = lst[i]
value, _, iter = hopfield.recall(pattern)
if value is not None:
attractors.append(value)
uniques = np.unique(np.array(attractors), axis=0)
print("The number of attractors is {}".format(len(uniques)))
def ex_3_3__1_until_3():
dataset = np.loadtxt('pict.dat', delimiter=",",
dtype=int).reshape(-1, 1024)
train_patterns = dataset[0:3].copy()
hopfield = Hopfield(train_patterns)
hopfield.train()
# 3.3.3 Follow how the energy changes from iteration to iteration
# when you use the sequential update rule to approach an attractor.
for i in range(len(dataset)):
recalled, energy, iter = (hopfield.recall(dataset[i],
number_of_dataset=i,
n_iterations=10,
method='Random',
calculate_energy=True,
plot=True))
print("Energy for pattern {} is {}".format(i + 1, energy))
Utils.plot_energy_line(
np.array(energy), 'Energy',
'Energy random asynchronous update to approach a test point.')
def ex_3_2():
test_3_1 = False
test_3_2 = True
dataset = np.loadtxt('pict.dat', delimiter=",",
dtype=int).reshape(-1, 1024)
train_patterns = dataset[0:3].copy()
#
# hopfield = Hopfield(train_patterns)
# hopfield.train()
# stability = check_stability(hopfield, train_patterns, train_patterns)
if test_3_1:
hopfield = Hopfield(train_patterns)
hopfield.train()
p10 = dataset[9].copy()
recall_p10, _, iter = hopfield.recall(p10)
Utils.display_image(p10, title='actual picture p10')
Utils.display_image(recall_p10, title='recalled picture p10')
p2 = dataset[1].copy()
p1 = dataset[0].copy()
p3 = dataset[2].copy()
p11 = dataset[10].copy()
recall_p11, _, iter = hopfield.recall(p11)
Utils.display_image(p2, title='actual picture p2')
Utils.display_image(p1, title='actual picture p1')
Utils.display_image(p3, title='actual picture p3')
Utils.display_image(p11,
title='actual picture p11 (Mixture p2 and p3)')
Utils.display_image(recall_p11, title='recalled picture p11')
# print(np.all(check_stability(hopfield, recall_p10, train_patterns)))
# print(np.all(check_stability(hopfield, recall_p11, train_patterns)))
if test_3_2:
hopfield = Hopfield(train_patterns, method='Async')
hopfield.train()
p10 = dataset[9].copy()
# Utils.display_image(p10, title='actual picture p10')
recalled, _, iter = hopfield.recall(p10, n_iterations=500, plot=True)
Utils.display_image(
recalled,
'Asynchronous random update. closest to first training example')
def ex_3_6():
N = 200
fire_neuros_percentage = 0.
num = int(N * fire_neuros_percentage)
memory_patterns = np.zeros(shape=(N, N))
for i in range(N):
indices = np.random.randint(0, N, num)
memory_patterns[i][indices] = 1
accuracy1 = []
accuracy2 = []
accuracy4 = []
accuracy6 = []
for i in range(1, N + 1):
temp = memory_patterns[0:i]
hopfield = Hopfield(temp,
fire_neuros_percentage,
sparse_weight=True,
theta=0)
hopfield.train()
local_accuracy = []
for j, pattern in enumerate(temp):
value, _, iter = hopfield.recall(pattern, 0)
local_accuracy.append(Utils.check_performance(pattern, value))
accuracy1.append(np.mean(local_accuracy))
hopfield = Hopfield(temp,
fire_neuros_percentage,
sparse_weight=True,
theta=0.01)
hopfield.train()
local_accuracy = []
for j, pattern in enumerate(temp):
value, _, iter = hopfield.recall(pattern, 0)
local_accuracy.append(Utils.check_performance(pattern, value))
accuracy2.append(np.mean(local_accuracy))
hopfield = Hopfield(temp,
fire_neuros_percentage,
sparse_weight=True,
theta=0.1)
hopfield.train()
local_accuracy = []
for j, pattern in enumerate(temp):
value, _, iter = hopfield.recall(pattern, 0)
local_accuracy.append(Utils.check_performance(pattern, value))
accuracy4.append(np.mean(local_accuracy))
hopfield = Hopfield(temp,
fire_neuros_percentage,
sparse_weight=True,
theta=-0.05)
hopfield.train()
local_accuracy = []
for j, pattern in enumerate(temp):
value, _, iter = hopfield.recall(pattern, 0)
local_accuracy.append(Utils.check_performance(pattern, value))
accuracy6.append(np.mean(local_accuracy))
accuracy = [accuracy1, accuracy2, accuracy4, accuracy6]
legend_names = [
'theta = 0', 'theta = 0.01', 'theta = 0.1', 'theta = -0.05'
]
Utils.plot_multiple_accuracy(accuracy, N, legend_names,
'Accuracy with 5% activity')
def ex_3_5():
dataset = np.loadtxt('pict.dat', delimiter=",",
dtype=int).reshape(-1, 1024)
test_1 = False
test_2 = True
if test_1:
accuracy = []
for i in range(3, 8):
train_patterns = dataset[0:i].copy()
hopfield = Hopfield(train_patterns)
hopfield.train()
local_accuracy = []
for j, pattern in enumerate(train_patterns):
dist_pattern = Utils.distort_data(pattern, 0.1)
value, _, iter = hopfield.recall(dist_pattern, n_iterations=50)
# Utils.display_image(value, "{} pattern".format(j+1))
# Utils.display_image(pattern,"Actual {}".format(j+1))
local_accuracy.append(Utils.check_performance(pattern, value))
print("Accuracy {0} for {1} training patterns ".format(
local_accuracy, i))
accuracy.append(np.mean(local_accuracy))
Utils.plot_accuracy(np.array(accuracy),
'Accuracy on recalled patterns')
if test_2:
# train_patterns = dataset[0:3].copy()
randoms = []
values = []
# for pt in train_patterns:
# randoms.append(pt)
for i in range(30):
print(i)
for j in range(10):
randoms.append(Utils.generate_random_pattern())
local_accuracy = []
hopfield = Hopfield(np.array(randoms))
hopfield.train()
for j, pattern in enumerate(randoms):
dist_pattern = Utils.distort_data(pattern, 0.05)
value, _, iter = hopfield.recall(dist_pattern, n_iterations=15)
# print(iter)
# Utils.display_image(value, "{} pattern".format(j+1))
# Utils.display_image(pattern,"Actual {}".format(j+1))
local_accuracy.append(Utils.check_performance(pattern, value))
print("Accuracy {0} for {1} training patterns ".format(
local_accuracy, i))
value = np.mean(np.array(local_accuracy))
values.append(value)
Utils.plot_accuracy(np.array(values),
'Accuracy on recalled random patterns')