Notes

import numpy as np

def sigmoid(x):
return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
return x * (1 - x)

class LogicGate:
def __init__(self, gate_name, xdata, tdata):
self.name = gate_name
self._xdata = xdata
self._tdata = tdata.reshape(4, 1)

# Network architecture
self._W2 = np.random.rand(2, 6)
self._b2 = np.random.rand(6)
self._W3 = np.random.rand(6, 1)
self._b3 = np.random.rand(1)
self._learning_rate = 1e-2

def feed_forward(self):
z2 = np.dot(self._xdata, self._W2) + self._b2
a2 = sigmoid(z2)
z3 = np.dot(a2, self._W3) + self._b3
a3 = sigmoid(z3)
return a2, a3

def loss_val(self):
delta = 1e-7
_, a3 = self.feed_forward()
return -np.sum(self._tdata * np.log(a3 + delta) + (1 - self._tdata) * np.log(1 - a3 + delta))

def train(self):
for step in range(10001):
a2, a3 = self.feed_forward()
error_output = a3 - self._tdata
dW3 = np.dot(a2.T, error_output * sigmoid_derivative(a3))
db3 = np.sum(error_output * sigmoid_derivative(a3), axis=0)
error_hidden = np.dot(error_output * sigmoid_derivative(a3), self._W3.T)
dW2 = np.dot(self._xdata.T, error_hidden * sigmoid_derivative(a2))
db2 = np.sum(error_hidden * sigmoid_derivative(a2), axis=0)
self._W2 -= self._learning_rate * dW2
self._b2 -= self._learning_rate * db2
self._W3 -= self._learning_rate * dW3
self._b3 -= self._learning_rate * db3

if step % 400 == 0:
print(f"step = {step}, loss value = {self.loss_val()}")

def predict(self, input_data):
z2 = np.dot(input_data, self._W2) + self._b2
a2 = sigmoid(z2)
z3 = np.dot(a2, self._W3) + self._b3
a3 = sigmoid(z3)
result = 1 if a3 > 0.5 else 0
return a3, result
xdata = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
tdata = np.array([0, 0, 0, 1])
AND_obj = LogicGate("AND_GATE", xdata, tdata)
AND_obj.train()
print(AND_obj.name, "Output")
test_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
for data in test_data:
prediction = AND_obj.predict(data)
print(f"Input: {data}, Prediction: {prediction}")