import numpy as np
class NeuralNetwork:
def __init__(self, input_size, hidden_size, output_size, learning_rate):
"""
Initialize the neural network with given parameters.
Parameters:
- input_size: Number of input neurons
- hidden_size: Number of neurons in the hidden layer
- output_size: Number of output neurons
- learning_rate: Learning rate for weight updates
"""
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.learning_rate = learning_rate
# Initialize weights with random values
self.w1 = np.random.rand(self.input_size, self.hidden_size)
self.w2 = np.random.rand(self.hidden_size, self.output_size)
def sigmoid(self, x):
"""
Sigmoid activation function.
Parameters:
- x: Input
Returns:
- Output of the sigmoid function
"""
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(self, x):
"""
Derivative of the sigmoid activation function.
Parameters:
- x: Input
Returns:
- Derivative of the sigmoid function
"""
return self.sigmoid(x) * (1 - self.sigmoid(x))
def forward_pass(self, X):
"""
Perform forward pass through the network.
Parameters:
- X: Input data
Returns:
- h: Activation in hidden layer
- y: Activation in output layer
"""
# Forward propagation
h = self.sigmoid(np.dot(X, self.w1)) # Activation in hidden layer
y = self.sigmoid(np.dot(h, self.w2)) # Activation in output layer
return h, y
def backward_pass(self, X, y, d):
"""
Perform backward pass through the network and update weights.
Parameters:
- X: Input data
- y: Predicted output
- d: Desired output
"""
# Backpropagation
# Calculate output layer error term
output_error = d - y
delta_output = output_error * self.sigmoid_derivative(y)
# Calculate hidden layer error term
hidden_error = np.dot(delta_output, self.w2.T) * self.sigmoid_derivative(h)
# Update weights
self.w2 += self.learning_rate * np.dot(h.T, delta_output)
self.w1 += self.learning_rate * np.dot(X.T, hidden_error)
def train(self, X, d, epochs):
"""
Train the neural network.
Parameters:
- X: Input data
- d: Desired output
- epochs: Number of training epochs
"""
for _ in range(epochs):
# Forward pass
h, y = self.forward_pass(X)
# Backward pass and weight update
self.backward_pass(X, y, d)
def predict(self, X):
"""
Make predictions on new data.
Parameters:
- X: Input data
Returns:
- Predicted output
"""
# Forward pass for prediction
_, y = self.forward_pass(X)
return y
# Example usage
np.random.seed(1) # Set random seed for reproducibility
# Define network parameters
input_size = 2
hidden_size = 3
output_size = 1
learning_rate = 0.1
# Training data
X = np.array([[0.05, 0.10], [0.80, 0.20]])
d = np.array([[0.01], [0.99]])
# Create neural network
model = NeuralNetwork(input_size, hidden_size, output_size, learning_rate)
# Train the network
model.train(X, d, 1000) # Train for 1000 epochs
# Make predictions on new data
X_new = np.array([[0.15, 0.30]])
y_predicted = model.predict(X_new)
print("Predicted output:", y_predicted)