import numpy as np
 
# Parameters
learning_rate = 0.1
max_iterations = 1000
lower_threshold = 0.8  # Lower threshold for activation
upper_threshold = 1.2  # Upper threshold for activation
 
# Threshold activation function with two thresholds
def activation_function(weighted_sum):
    if weighted_sum >= upper_threshold:
        return 1
    else:
        return 0
 
# Generate all 16 possible truth tables for 2 inputs
inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
all_targets = [
    [0, 0, 0, 0],  # 0
    [0, 0, 0, 1],  # 1
    [0, 0, 1, 0],  # 2
    [0, 0, 1, 1],  # 3
    [0, 1, 0, 0],  # 4
    [0, 1, 0, 1],  # 5
    [0, 1, 1, 0],  # 6
    [0, 1, 1, 1],  # 7
    [1, 0, 0, 0],  # 8
    [1, 0, 0, 1],  # 9
    [1, 0, 1, 0],  # 10
    [1, 0, 1, 1],  # 11
    [1, 1, 0, 0],  # 12
    [1, 1, 0, 1],  # 13
    [1, 1, 1, 0],  # 14
    [1, 1, 1, 1],  # 15
]
 
# Initialize weights for the neurons in a smaller range
weights_input_to_hidden = np.random.rand(3) * 0.1  # 2 inputs + 1 bias → 1 hidden neuron
weights_hidden_to_output = np.random.rand(2) * 0.1  # 1 hidden neuron + 1 bias → 1 output neuron
 
# Training loop
network_trained = False
for target in all_targets:  # Train for all possible tables
    epoch = 0
    while epoch < max_iterations:
        epoch += 1
        all_correct = True  # Flag to track if all outputs are correct
 
        for input_vector, expected_target in zip(inputs, target):
            N1, N2 = input_vector
            bias = 1  # Bias input
 
            # Forward pass (hidden layer)
            N3_input = np.dot(np.append(input_vector, bias), weights_input_to_hidden)  # Hidden layer sum
            N3 = activation_function(N3_input)  # Output of the hidden neuron
 
            # Output layer
            N4_input = (N3 * weights_hidden_to_output[0] + bias * weights_hidden_to_output[1])  # Weighted sum to output
            N4 = activation_function(N4_input)  # Output neuron decision
 
            # Error calculation
            error = expected_target - N4
 
            # If there is an error, update the weights
            if error != 0:
                all_correct = False
 
                # Update weights for hidden to output neuron
                weights_hidden_to_output[0] += learning_rate * error * N3
                weights_hidden_to_output[1] += learning_rate * error * bias
 
                # Update weights for input to hidden neuron
                weights_input_to_hidden += learning_rate * error * N3 * np.append(input_vector, bias)
 
        if all_correct:
            network_trained = True
            break
 
# Results
if network_trained:
    print(f"The network learned the truth tables correctly after {epoch} iterations.")
else:
    print(f"The network failed to learn the truth tables after {epoch} iterations.")
 
# Testing the trained network
print("\nTesting the trained network:")
for target_index, target in enumerate(all_targets):
    print(f"Testing Table {target_index}:")
    for input_vector, expected_target in zip(inputs, target):
        N1, N2 = input_vector
        bias = 1
 
        # Forward pass (hidden layer)
        N3_input = np.dot(np.append(input_vector, bias), weights_input_to_hidden)
        N3 = activation_function(N3_input)
 
        # Output layer
        N4_input = (N3 * weights_hidden_to_output[0] + bias * weights_hidden_to_output[1])
        N4 = activation_function(N4_input)
 
        print(f"Input: {input_vector}, Target: {expected_target}, Output: {N4}")
 

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