Experiment 8

Bidirectional Associative Memory (BAM) Algorithm

AIM:

Implement Bidirectional Associative Memory (BAM) Algorithm for the given dataset using Python.

LABORATORY OUTCOMES:

THEORY:

The architecture of BAM network consists of two layers of neurons which are connected by directed weighted pare interconnections. The network dynamics involve two layers of interaction. The BAM network iterates by sending the signals back and forth between the two layers until all the neurons reach equilibrium. The weights associated with the network are bidirectional. Thus, BAM can respond to the inputs in either layer.

The weight matrix to store a set of input and target vectors can be determined by Hebb rule training algorithm. When the input vectors are binary, the weight matrix is calculated differently than when they are bipolar.

The testing algorithm involves initializing the weights and activations, and then iterating through the layers until convergence is reached.

PROGRAM:


        # Import Python Libraries 
        import numpy as np 
        
        # Take two sets of patterns: 
        # Set A: Input Pattern 
        x1 = np.array([1, 1, 1, 1, 1, 1]).reshape(6, 1) 
        x2 = np.array([-1, -1, -1, -1, -1, -1]).reshape(6, 1) 
        x3 = np.array([1, 1, -1, -1, 1, 1]).reshape(6, 1) 
        x4 = np.array([-1, -1, 1, 1, -1, -1]).reshape(6, 1) 
        
        # Set B: Target Pattern 
        y1 = np.array([1, 1, 1]).reshape(3, 1) 
        y2 = np.array([-1, -1, -1]).reshape(3, 1) 
        y3 = np.array([1, -1, 1]).reshape(3, 1) 
        y4 = np.array([-1, 1, -1]).reshape(3, 1) 
        
        # Calculate weight Matrix: W 
        inputSet = np.concatenate((x1, x2, x3, x4), axis = 1) 
        targetSet = np.concatenate((y1.T, y2.T, y3.T, y4.T), axis = 0) 
        print("\nWeight matrix:") 
        weight = np.dot(inputSet, targetSet) 
        print(weight) 
        
        # Testing Phase 
        # Test for Input Patterns: Set A 
        print("\nTesting for input patterns: Set A") 
        def testInputs(x, weight): 
            # Multiply the input pattern with the weight matrix 
            # (weight.T X x) 
            y = np.dot(weight.T, x) 
            y[y < 0] = -1 
            y[y >= 0] = 1 
            return np.array(y) 
        
        print("\nOutput of input pattern 1") 
        print(testInputs(x1, weight)) 
        print("\nOutput of input pattern 2") 
        print(testInputs(x2, weight)) 
        print("\nOutput of input pattern 3") 
        print(testInputs(x3, weight)) 
        print("\nOutput of input pattern 4") 
        print(testInputs(x4, weight)) 
        
        # Test for Target Patterns: Set B 
        print("\nTesting for target patterns: Set B") 
        def testTargets(y, weight): 
            # Multiply the target pattern with the weight matrix 
            # (weight X y) 
            x = np.dot(weight, y) 
            x[x <= 0] = -1 
            x[x > 0] = 1 
            return np.array(x) 
        
        print("\nOutput of target pattern 1") 
        print(testTargets(y1, weight)) 
        print("\nOutput of target pattern 2") 
        print(testTargets(y2, weight)) 
        print("\nOutput of target pattern 3") 
        print(testTargets(y3, weight)) 
        print("\nOutput of target pattern 4") 
        print(testTargets(y4, weight))

OUTPUTS:

Weight matrix: [[4 0 4] [4 0 4] [0 4 0] [0 4 0] [4 0 4] [4 0 4]]

CONCLUSION:

Bidirectional Associative Memories (BAM) is a system that allows associating pairs of patterns. BAMs have many applications in pattern recognition and image processing. The implementation computes the weight matrix and tests the BAM model for the input patterns.

TEXT/REFERENCE BOOKS:

WEB ADDRESS (URLS):