Breaking News: Grepper is joining You.com. Read the official announcement!

Backpropagation and the sigmoid activation function

TRIDEEP SAHA answered on April 27, 2024 Popularity 1/10 Helpfulness 1/10

answer Backpropagation and the sigmoid activation function

Backpropagation and the sigmoid activation function

Comment

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)

Popularity 1/10 Helpfulness 1/10 Language python

Source: chat.openai.com

Tags: activation-function backpropagation python sigmoid

Link to this answer
Share Copy Link

Contributed on Apr 27 2024

TRIDEEP SAHA

0 Answers Avg Quality 2/10

Backpropagation and the sigmoid activation function

Contents

More Related Answers

Backpropagation and the sigmoid activation function

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.