import math import random # ========================================== # 1. CONFIGURATION # ========================================== INPUT_SIZE = 2 HIDDEN_SIZE = 8 EPOCHS = 15000 LEARNING_RATE = 0.05 random.seed(42) # ========================================== # 2. ACTIVATION FUNCTION # ========================================== def sigmoid(x): return 1 / (1 + math.exp(-x)) # ========================================== # 3. GENERATE TRAINING DATA # ========================================== training_data = [] for a in range(1, 11): for b in range(1, 11): # Normalize inputs and output inputs = [a / 10, b / 10] expected = (a * b) / 100 # Hold back some examples for testing if (a * 10 + b) % 5 != 0: training_data.append((inputs, expected)) # ========================================== # 4. INITIALIZE NETWORK # ========================================== hidden_weights = [ [random.uniform(-1, 1) for _ in range(INPUT_SIZE)] for _ in range(HIDDEN_SIZE) ] hidden_biases = [0.0] * HIDDEN_SIZE output_weights = [ random.uniform(-1, 1) for _ in range(HIDDEN_SIZE) ] output_bias = 0.0 # ========================================== # 5. FORWARD PASS # ========================================== def forward(inputs): hidden = [] # Hidden layer for i in range(HIDDEN_SIZE): total = 0 for j in range(INPUT_SIZE): total += inputs[j] * hidden_weights[i][j] total += hidden_biases[i] hidden.append(sigmoid(total)) # Output layer output = 0 for i in range(HIDDEN_SIZE): output += hidden[i] * output_weights[i] output += output_bias return output, hidden # ========================================== # 6. LOSS FUNCTION # ========================================== def loss_function(expected, predicted): return (expected - predicted) ** 2 # ========================================== # 7. BACKPROPAGATION # ========================================== def train_one(inputs, expected): global output_bias # Forward pass prediction, hidden = forward(inputs) # Output gradient output_delta = 2 * (prediction - expected) # Save old output weights old_output_weights = output_weights[:] # Output weight gradients output_gradients = [ output_delta * hidden[i] for i in range(HIDDEN_SIZE) ] # Hidden layer gradients hidden_deltas = [] for i in range(HIDDEN_SIZE): sigmoid_derivative = hidden[i] * (1 - hidden[i]) delta = ( output_delta * old_output_weights[i] * sigmoid_derivative ) hidden_deltas.append(delta) # Update output layer for i in range(HIDDEN_SIZE): output_weights[i] -= ( LEARNING_RATE * output_gradients[i] ) output_bias -= LEARNING_RATE * output_delta # Update hidden layer for i in range(HIDDEN_SIZE): for j in range(INPUT_SIZE): gradient = hidden_deltas[i] * inputs[j] hidden_weights[i][j] -= ( LEARNING_RATE * gradient ) hidden_biases[i] -= ( LEARNING_RATE * hidden_deltas[i] ) return loss_function(expected, prediction) # ========================================== # 8. TRAINING LOOP # ========================================== print("Starting training...") print("Training examples:", len(training_data)) print("Hidden neurons:", HIDDEN_SIZE) print("Epochs:", EPOCHS) print() for epoch in range(EPOCHS): random.shuffle(training_data) total_loss = 0 for inputs, expected in training_data: current_loss = train_one(inputs, expected) total_loss += current_loss average_loss = total_loss / len(training_data) if epoch % 1000 == 0: print( f"Epoch: {epoch:5}", f"Loss: {average_loss:.8f}" ) # ========================================== # 9. PREDICTION FUNCTION # ========================================== def multiply(a, b): inputs = [a / 10, b / 10] prediction, _ = forward(inputs) return prediction * 100 # ========================================== # 10. AUTOMATED TESTING # ========================================== def run_test_suite(name, min_number, max_number, samples=100): print("\n" + "=" * 55) print(name) print("=" * 55) total_error = 0 squared_error = 0 best_error = float("inf") worst_error = 0 successful = 0 results = [] for _ in range(samples): a = random.randint(min_number, max_number) b = random.randint(min_number, max_number) expected = a * b prediction = multiply(a, b) error = abs(expected - prediction) total_error += error squared_error += error ** 2 best_error = min(best_error, error) worst_error = max(worst_error, error) if error <= 2: successful += 1 results.append( (a, b, expected, prediction, error) ) # Show some predictions print("\nSample predictions:") for a, b, expected, prediction, error in results[:10]: print( f"{a:3} x {b:3} = " f"{prediction:9.2f} " f"(actual: {expected:5}, error: {error:.2f})" ) # Calculate statistics average_error = total_error / samples rmse = math.sqrt(squared_error / samples) accuracy = (successful / samples) * 100 print("\nSTATISTICS") print("-" * 35) print("Samples:", samples) print("Average error:", round(average_error, 4)) print("RMSE:", round(rmse, 4)) print("Best error:", round(best_error, 4)) print("Worst error:", round(worst_error, 4)) print("Within 2 units:", round(accuracy, 2), "%") # ========================================== # 11. RUN ALL TESTS # ========================================== # Unseen combinations within the training range run_test_suite( "TEST 1: Numbers from 1 to 10", 1, 10, 100 ) # Outside the training range run_test_suite( "TEST 2: Numbers from 11 to 20", 11, 20, 100 ) # Larger numbers run_test_suite( "TEST 3: Numbers from 21 to 50", 21, 50, 100 ) # Small numbers run_test_suite( "TEST 4: Numbers from 1 to 5", 1, 5, 100 ) # ========================================== # 12. FINAL SUMMARY # ========================================== print("\n" + "=" * 55) print("NEURAL NETWORK EXPERIMENT FINISHED") print("=" * 55) print("Training examples:", len(training_data)) print("Hidden neurons:", HIDDEN_SIZE) print("Training epochs:", EPOCHS) print("\nOur neural network has learned multiplication!")