Untitled Page

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score
# 1. Load Iris dataset
data = pd.read_csv(r"E:\Kiran\DSI\ML and NN\Lab\Program 11\Iris.csv")
# Input features
X = data.iloc[:, :-1].values
# Target
y = data.iloc[:, -1].values
# Convert class names into numbers
classes = np.unique(y)
y = np.array([np.where(classes == label)[0][0] for label in y])
# 2. One-hot encode target
Y = np.zeros((len(y), 3))
Y[np.arange(len(y)), y] = 1
# 3. Split dataset
X_train, X_test, Y_train, Y_test = train_test_split(
 X, Y,
 test_size=0.3,
 random_state=42,
 stratify=y
)
# 4. Normalize input features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# 5. Initialize network parameters
np.random.seed(42)
input_size = 4
hidden_size = 6 output_size = 3
W1 = np.random.randn(input_size, hidden_size) * 0.1
b1 = np.zeros((1, hidden_size))
W2 = np.random.randn(hidden_size, output_size) * 0.1
b2 = np.zeros((1, output_size))
learning_rate = 0.1
epochs = 1000
# Sigmoid activation
def sigmoid(x):
 return 1 / (1 + np.exp(-x))
# Sigmoid derivative
def sigmoid_derivative(x):
 return x * (1 - x)
# Softmax activation
def softmax(x):
 exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
 return exp_x / np.sum(exp_x, axis=1, keepdims=True)
# 6. Training using Backpropagation
for epoch in range(epochs):
 # ---------- Forward Propagation ----------
 # Input → Hidden
 hidden_input = np.dot(X_train, W1) + b1
 hidden_output = sigmoid(hidden_input)
 # Hidden → Output
 output_input = np.dot(hidden_output, W2) + b2
 output = softmax(output_input)
 # ---------- Backpropagation ----------
 # Output error
 output_error = output - Y_train # Gradients for output layer
 dW2 = np.dot(hidden_output.T, output_error) / len(X_train)
 db2 = np.mean(output_error, axis=0, keepdims=True)
 # Hidden layer error
 hidden_error = np.dot(output_error, W2.T)
 # Hidden layer delta
 hidden_delta = hidden_error * sigmoid_derivative(hidden_output)
 # Gradients for hidden layer
 dW1 = np.dot(X_train.T, hidden_delta) / len(X_train)
 db1 = np.mean(hidden_delta, axis=0, keepdims=True)
 # ---------- Update Weights ----------
 W2 -= learning_rate * dW2
 b2 -= learning_rate * db2
 W1 -= learning_rate * dW1
 b1 -= learning_rate * db1
 # Display loss every 100 epochs
 if (epoch + 1) % 100 == 0:
 loss = -np.mean(
 np.sum(Y_train * np.log(output + 1e-8), axis=1)
 )
 print("Epoch:", epoch + 1,
 "Loss:", round(loss, 4))
# 7. Testing
# Forward propagation on test data
hidden_input = np.dot(X_test, W1) + b1
hidden_output = sigmoid(hidden_input)
output_input = np.dot(hidden_output, W2) + b2
output = softmax(output_input)
# Convert probabilities to class labels
y_pred = np.argmax(output, axis=1)
y_actual = np.argmax(Y_test, axis=1) # 8. Calculate accuracy
accuracy = accuracy_score(y_actual, y_pred)
print("\nPredicted Classes:")
print(y_pred)
print("\nActual Classes:")
print(y_actual)
print("\nTest Accuracy:",
 round(accuracy * 100, 2), "%")