DELHI TECHNOLOGICAL UNIVERSITY

DEPARTMENT OF COMPUTER ENGINEERING

ASSIGNMENT

Information and Network Security

CO429

Submitted by:
MOHAMED AHMED
2K20/CO/270
➢ implementation of a neural network with at least two layers, where you have the activation
function defined as the sigmoid function in Python using numpy.

❖ The Code:

import numpy as np

def sigmoid(x):
"""Sigmoid activation function"""
return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
"""Derivative of sigmoid function"""
return x * (1 - x)

# Define the network architecture

input_nodes = 2
hidden_nodes = 2
output_nodes = 2

# Initialize weights and biases with random values

input_to_hidden_weights = np.random.rand(input_nodes, hidden_nodes)
hidden_biases = np.random.rand(1, hidden_nodes)

hidden_to_output_weights = np.random.rand(hidden_nodes, output_nodes)

output_biases = np.random.rand(1, output_nodes)

# Define the learning rate

lr = 0.01

def forward_pass(inputs):
 """Compute the forward pass of the network"""
hidden_layer_input = np.dot(inputs, input_to_hidden_weights) + hidden_biases
hidden_layer_output = sigmoid(hidden_layer_input)

output_layer_input = np.dot(hidden_layer_output, hidden_to_output_weights) + output_biases

final_output = sigmoid(output_layer_input)

return hidden_layer_output, final_output

def backpropagation(inputs, target, hidden_output, final_output):

"""Backpropagation to adjust weights and biases"""

output_error = target - final_output

output_delta = output_error * sigmoid_derivative(final_output)

hidden_layer_error = output_delta.dot(hidden_to_output_weights.T)
hidden_layer_delta = hidden_layer_error * sigmoid_derivative(hidden_output)

# Update the weights and biases

global input_to_hidden_weights, hidden_biases, hidden_to_output_weights, output_biases

input_to_hidden_weights += lr * inputs.T.dot(hidden_layer_delta)
hidden_biases += np.sum(hidden_layer_delta, axis=0, keepdims=True)

hidden_to_output_weights += lr * hidden_output.T.dot(output_delta)
output_biases += np.sum(output_delta, axis=0, keepdims=True)

# Train the neural network

epochs = 10000
for epoch in range(epochs):
inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) # Example inputs
target = np.array([[0, 1], [1, 0], [1, 0], [0, 1]]) # Example targets for demonstration
 for i in range(len(inputs)):
hidden_output, final_output = forward_pass(inputs[i])
backpropagation(np.array([inputs[i]]), np.array([target[i]]), hidden_output, final_output)

if epoch % 1000 == 0:
print(f"Epoch {epoch}, Loss: {np.mean(np.square(target - forward_pass(inputs)[1]))}")

# Test
hidden_output, final_output = forward_pass(np.array([0, 1]))
print(final_output)

➢ The given code creates a simple feedforward neural network and trains it on XOR-like
data for demonstration purposes.