import numpy as np
 
# Define your activation function (you mentioned no sigmoid, likely linear)
def activation_function(x):
    # No transformation (identity function)
    return x
 
# Initialize weights with small random values
def initialize_weights(input_size, output_size):
    # Proper small initialization for faster convergence
    return np.random.randn(input_size, output_size) * 0.1
 
# Forward pass
def forward_pass(input_vector, weights, biases):
    return np.dot(input_vector, weights) + biases
 
# Training function
def train_neural_network(input_data, target_data, learning_rate=0.001, max_epochs=2000, error_threshold=1e-5):
    input_size = len(input_data[0])
    output_size = len(target_data[0])
 
    # Initialize weights and biases
    weights = initialize_weights(input_size, output_size)
    biases = np.zeros(output_size)
 
    # Training loop
    for epoch in range(max_epochs):
        total_error = 0
        for i in range(len(input_data)):
            input_vector = input_data[i]
            target_vector = target_data[i]
 
            # Forward pass
            output = forward_pass(input_vector, weights, biases)
            error = target_vector - output
            total_error += np.sum(error ** 2)
 
            # Backpropagation (gradient descent)
            weight_gradient = np.outer(input_vector, error)  # Gradient w.r.t weights
            bias_gradient = error  # Gradient w.r.t bias
 
            # Gradient clipping to avoid exploding gradients
            weight_gradient = np.clip(weight_gradient, -10, 10)
            bias_gradient = np.clip(bias_gradient, -10, 10)
 
            # Check for NaN in gradients and skip update if found
            if np.isnan(np.sum(weight_gradient)) or np.isnan(np.sum(bias_gradient)):
                print("NaN detected, skipping update.")
                continue
 
            # Update weights and biases
            weights += learning_rate * weight_gradient
            biases += learning_rate * bias_gradient
 
        # Early stopping: check if the error is below the threshold
        if total_error < error_threshold:
            print(f"Converged at epoch {epoch} with error: {total_error}")
            break
 
        # Optional: Print status for every 100 epochs
        if epoch % 100 == 0:
            print(f"Epoch {epoch}, Error: {total_error}")
 
    return weights, biases
 
# Test the network with the provided truth tables
def test_neural_network(weights, biases, input_data):
    predictions = []
    for input_vector in input_data:
        output = forward_pass(input_vector, weights, biases)
        predictions.append(output)
    return predictions
 
# Define the truth tables
input_data = [
    [0, 0, 0, 0],
    [0, 0, 0, 1],
    [0, 0, 1, 0],
    [0, 0, 1, 1],
    [0, 1, 0, 0],
    [0, 1, 0, 1],
    [0, 1, 1, 0],
    [0, 1, 1, 1],
    [1, 0, 0, 0],
    [1, 0, 0, 1],
    [1, 0, 1, 0],
    [1, 0, 1, 1],
    [1, 1, 0, 0],
    [1, 1, 0, 1],
    [1, 1, 1, 0],
    [1, 1, 1, 1]
]
 
# Corresponding targets (for the XOR problem)
target_data = [
    [0, 0, 0, 0],
    [0, 0, 0, 1],
    [0, 0, 1, 0],
    [0, 0, 1, 1],
    [0, 1, 0, 0],
    [0, 1, 0, 1],
    [0, 1, 1, 0],
    [0, 1, 1, 1],
    [1, 0, 0, 0],
    [1, 0, 0, 1],
    [1, 0, 1, 0],
    [1, 0, 1, 1],
    [1, 1, 0, 0],
    [1, 1, 0, 1],
    [1, 1, 1, 0],
    [1, 1, 1, 1]
]
 
# Train the neural network
weights, biases = train_neural_network(input_data, target_data, learning_rate=0.001)
 
# Test the neural network
predictions = test_neural_network(weights, biases, input_data)
 
# Display the results
for i, (input_vector, target_vector, prediction) in enumerate(zip(input_data, target_data, predictions)):
    print(f"Table {i+1}: Input: {input_vector}, Target: {target_vector}, Prediction: {prediction}, Error: {np.abs(np.array(target_vector) - np.array(prediction))}")
 

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