multiple.py

try:
    import numpy as np
except ImportError:
    print "Install numpy - pip install numpy"
"""
This program is a basic 2 layer neural network
input -> input layer -> hidden layer -> output

There are 4 different examples, simulating AND, OR, XOR and NAND gates with the same code.
"""

# DATA
# Binary AND operator
X1 = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y1 = np.array([[0, 0, 0, 1]]).T
# Binary OR operator
X2= np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y2 = np.array([[0, 1, 1, 1]]).T
# Binary XOR operator
X3= np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y3 = np.array([[0, 1, 1, 0]]).T
# Binary NAND operator
X4= np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y4 = np.array([[1, 1, 1, 0]]).T


# LEARNING CODE

def learn(X,y,n,h=16):
	"""
	Training phase of a neural network
	Accepts an 
	X - input, 
	y - output
	n - number of training iterations, 		
	h - number of hidden neurons
	"""
	# initialized 2 layers with random weights from -1 to 1
	layer1_weights = 2 * np.random.random((X.shape[1], h)) - 1
	layer2_weights = 2 * np.random.random((h, 1)) - 1
	# train the network for n iterations
	for i in xrange(n):
		# Find the results of the existing network with current weights and input - Sigmoid function
	    l1 = 1/(1+np.exp(-(np.dot(X,layer1_weights))))
	    l2 = 1/(1+np.exp(-(np.dot(l1,layer2_weights))))
	    # Calculate the error - derivative of the Sigmoid function
	    l2_delta = (y - l2)*(l2*(1-l2))
	    l1_delta = l2_delta.dot(layer2_weights.T) * (l1 * (1-l1))
	    # Correct the weights for next pass
	    layer2_weights += l1.T.dot(l2_delta)
	    layer1_weights += X.T.dot(l1_delta)
	return (layer1_weights, layer2_weights)  # return a tuple for all the weights associated for both layers

# PREDICTION CODE

def predict(X, weights):
	l1 = 1/(1+np.exp(-(np.dot(X, weights[0]))))
	l2 = 1/(1+np.exp(-(np.dot(l1, weights[1]))))
	return l2

# Same neural network code used to learn about different gates


and_weights = learn(X1, y1, 10000)
# print and_weights
or_weights = learn(X2,y2, 10000)
# print or_weights
xor_weights = learn(X3,y3, 10000)
# print xor_weights
nand_weights = learn(X4,y4, 10000)
# print xor_weights
test_set = [[0, 0], [0, 1], [1, 0], [1, 1]]
print "ITEM\tAND\tOR\tXOR\tNAND"
for test_item in test_set:
	and_prediction = predict(test_item, and_weights)
	or_prediction = predict(test_item, or_weights)
	xor_prediction = predict(test_item, xor_weights)
	nand_prediction = predict(test_item, nand_weights)
	# round will round off the floting point results to the nearest number (in this case, 0 or 1)
	print str(test_item)+"\t"+str(round(and_prediction))+"\t"+str(round(or_prediction))+ \
		"\t"+str(round(xor_prediction))+"\t"+str(round(nand_prediction))