Experiment No.

04

Name of the Experiment: (a) Design and implementation of Kohonen Self-organizing Neural
Networks algorithm.
Dataset:

Output Node Initial Weight

0 [1, 1, 1]
1 [1, 0, 1]
2 [ 0, 1, 1]
3 [1, 1, 1]

Implementation:

At first all the dependencies are loaded.

Code:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

1. the network is initialized

class Kohonen:
def __init__(self, inputs, iterations, X):
self.iterations = iterations
self.learning_rate = 0.5
self.inputs = inputs
# initialize weights
self.X = X

2 .Present input
inputs = [[1, 1, 1],[1, 0, 1], [0, 1, 1],[1, 1, 1]] weights
iterations = 1
X = [1,0,1] //pattern

obj = Kohonen(inputs,iterations,X)

3. Calculate distance and select node with minium distance

def find_winner_next(self,Y):
self.X = Y
for j in range(self.iterations):
# initialize shortest distance to 0
shortest_distance = 10000 # a large number
delta = [0,0,0] # to store update factor of weights

for i in range(len(self.inputs)):
distance = self.euclidean(self.inputs[i],
self.X)
print("Distance: " + str(distance))
if distance < shortest_distance:
shortest_distance = distance
winner = i # stores which one is nearest

4. Update Weights
# winner'th neuron is nearest so we need to update weights of
Wi, ie. inputs[i]
print("Shortest distance node: " +str(winner) + " --
- distance: "+ str(shortest_distance))
winning_node = self.inputs[winner]
delta[0] = self.learning_rate * (self.X[0] -
winning_node[0]) # delta_w_1_i
delta[1] = self.learning_rate * (self.X[1] -
winning_node[1]) # delta_w_2_i
delta[2] = self.learning_rate * (self.X[2] -
winning_node[2]) # delta_w_3_i
print("delta: " + str(delta))
print("--------------------")
# update weights of winner'th node
self.inputs[winner] = np.add(self.inputs[winner],
delta)
return self.inputs

Now train the network iteratively

def train(self,Y,epochs=5,lr=0.5):
self.learning_rate = lr
for epoch in range(epochs):
for inp_itr in range(len(Y)):
data = Y[inp_itr]
print("pattern: ", data)

self.X = data
for j in range(self.iterations):
# initialize shortest distance to 0
shortest_distance = 10000 # a large number
delta = [0,0,0] # to store update factor of weights

for i in range(len(self.inputs)):
distance = self.euclidean(self.inputs[i], self.X)
print("Distance: " + str(distance))
if distance < shortest_distance:
shortest_distance = distance
winner = i # stores which one is nearest
 # winner'th neuron is nearest so we need to update
weights of Wi, ie. inputs[i]
print("Shortest distance node: " +str(winner) + " ---
distance: "+ str(shortest_distance))
winning_node = self.inputs[winner]
delta[0] = self.learning_rate * (self.X[0] -
winning_node[0]) # delta_w_1_i
delta[1] = self.learning_rate * (self.X[1] -
winning_node[1]) # delta_w_2_i
delta[2] = self.learning_rate * (self.X[2] -
winning_node[2]) # delta_w_3_i
print("delta: " + str(delta))

print("--------------------")
# update weights of winner'th node
self.inputs[winner] = np.add(self.inputs[winner],
delta)

print("epoch:",epoch+1,"--:",self.inputs)

return self.inputs

model = Kohonen(inputs,iterations,X)
epochs = 10
lr = 0.5
X = [[1,0,1],[1,1,0],[0,1,1],[1,1,1]]
len(X)

model.train(X,epochs=5,lr=0.5)
 Table 4.1 :Evaluation the correctness and the accuracy
Input pattern Epoch(learning rate=0.5) Updated Weight
[[1,0,1], [1., 1.,0.25],
[1,1,0], [1., 0., 1.],
[0,1,1], 1 [0., 1., 1.],
[1,1,1]] [1., 1., 1.]
[[1,0,1], [1., 1.,0.125],
[1,1,0], [1., 0., 1.],
[0,1,1], 2 [0., 1., 1.],
[1,1,1]] [1., 1., 1.]
[[1,0,1], [1., 1.,0.0625],
[1,1,0], [1., 0., 1.],
[0,1,1], 3 [0., 1., 1.],
[1,1,1]] [1., 1., 1.]

Name of the Experiment: (b) Design and implementation of Hopfield Neural Networks
algorithm.

Dataset:

Fig 4.1: Three given pattern

From the above figure, we see that dataset is not linearly separable. So, multi layer perceptron
learning algorithm will be applied to see if the model can classify the data set

Characteristics of Dataset:
● Every pattern dimension is 5*5
● Total 3 given pattern
● The values of the pattern either a +1 or -1

Implementation:

At first all the dependencies are loaded.

Code:

import numpy as np
import pandas as pd
import statistics
from statistics import mode

import matplotlib.pyplot as plt

import numpy as np
import pandas as pd
import seaborn as sns

from sklearn import datasets

from sklearn import manifold

%matplotlib inline
import cv2

The given patterns are collected from MNIST dataset

def ld_data(path):
with np.load(path) as f:
x_train, y_train = f['x_train'], f['y_train']
x_test, y_test = f['x_test'], f['y_test']
return (x_train, y_train), (x_test, y_test)
(x_train, y_train), (x_test, y_test) = ld_data('./mnist.npz')

x_train = x_train.reshape(x_train.shape[0],784)
y_train = y_train.reshape(y_train.shape[0],1)
x_test = x_test.reshape(x_test.shape[0],784)
y_test = y_test.reshape(y_test.shape[0],1)
MNIST_image = np.vstack( (x_train,x_test) )
MNIST_label = np.vstack( (y_train,y_test) )

This dataset contains values other than +1 or -1, a preprocessing is required

def preprocess(img):
single_image = img.reshape(28,28)

plt.imshow(single_image, cmap = 'gray')

single_image = single_image * ((single_image > 40))
single_image=cv2.resize(single_image, (5,5),interpolation=
cv2.INTER_LINEAR)
single_image = 255 * ((single_image > 40))
plt.imshow(single_image, cmap = 'gray')
single_image = 255 * (~(single_image > 40))
plt.imshow(single_image, cmap = 'gray')

single_image = (single_image > 40) + (-1*(single_image < 40))

plt.imshow(single_image, cmap = 'gray')

return single_image.flatten()

After that three patterns are chosen and connection weights are assigned

class Hopfield:
def __init__(self, y):
self.y = y
self.memory = 3 # number of states to be memorised by the network
 self.I = np.identity(25)
self.W = np.zeros((25,25))

def train(self):
sum = np.zeros((25,25))

for i in range(self.memory):
y = np.array(self.y[i]).reshape(1,25) # flatten
transpose = np.array(y).T.reshape(25,1) # transpose of 1*3
reshaping into 3*1
sum = np.add(sum, np.multiply(transpose,y))

# calculate memory*I (multiply all elements by M)

arr = self.I
for i in range(len(arr)):
arr[i] = [self.memory * x for x in arr[i]]

result = np.subtract(sum,arr)
self.W = result

print(result)

y = [preprocess(x_train[1, :]),preprocess(x_train[2,
:]),preprocess(x_train[3, :])] # input for network [y1,y2]

model = Hopfield(y)
model.train()

Then an unknown pattern is picked up

l=preprocess(x_train[89, :])

After that, iterate over the network until convergence

def evaluate(self,val,epochs):

out1 = val
out1=np.array(out1).reshape(1,25)
for epoch in range(epochs):

out2 = np.matmul(out1, self.W)

out3 = out2.flatten()
out4 = out1.flatten()
for i in range(out2.shape[1]):
x = out3[i]
y = out4[i]
out2[0,i] = fh(x,y)

# out2 = np.array([fh(x,y) for (x,y) in zip(out2,out1)])

# print(out2)
if np.sum((out1 - out2)*(out1 - out2)) == 0:
img = out2.reshape(5,5)
plt.imshow(img, cmap = 'gray')
break

out1[0, :]=out2[0, :]
if epoch == epochs-1:
img = out2.reshape(5,5)
plt.imshow(img, cmap = 'gray')
return out2

img = model.evaluate(l,3)
 Table 4.2 :Evaluation the correctness and the accuracy
Unseen pattern Matched pattern

Conclusion:
In conclusion, Kohonen self-organizing creates a topological network in which output nodes
belongs to same group are neighbors. The orientation of the classes may change with the placing
order of input patterns to network.

We examined that Hopfield network successfully transformed the unseen pattern to seen pattern.
This indicates that the network is able to store the given patterns