11/13/24, 7:15 PM Assignment-2_AI

Sindhuja_Suresh_0817685_AI_Assignment-2

Part (a) Implementing the Softmax Function and Testing It

In [15]: import numpy as np

def softmax(x):
# Stabilize the inputs by subtracting the maximum value to avoid large expon
e_x = np.exp(x - np.max(x))
return e_x / e_x.sum()

In [16]: # Testing Softmax with Randomly Generated Data

if __name__ == "__main__":
test_scenarios = [
np.random.randint(1, 20, size=5),
np.random.randint(5, 25, size=7),
np.random.randint(10, 50, size=10)
]

for i, scenario in enumerate(test_scenarios, 1):

print(f"\nScenario {i}")
for j in range(3): # Repeat each scenario 3 times
print(f"Test {j+1}: Input: {scenario} -> Softmax: {softmax(scenario)

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 1/22

11/13/24, 7:15 PM Assignment-2_AI

Scenario 1
Test 1: Input: [ 7 5 17 1 11] -> Softmax: [4.52853393e-05 6.12870423e-06 9.9747
5978e-01 1.12251133e-07
2.47249575e-03]
Test 2: Input: [ 7 5 17 1 11] -> Softmax: [4.52853393e-05 6.12870423e-06 9.9747
5978e-01 1.12251133e-07
2.47249575e-03]
Test 3: Input: [ 7 5 17 1 11] -> Softmax: [4.52853393e-05 6.12870423e-06 9.9747
5978e-01 1.12251133e-07
2.47249575e-03]

Scenario 2
Test 1: Input: [15 20 19 23 8 7 21] -> Softmax: [2.78675784e-04 4.13591535e-02
1.52151823e-02 8.30720805e-01
2.54119422e-07 9.34853110e-08 1.12425835e-01]
Test 2: Input: [15 20 19 23 8 7 21] -> Softmax: [2.78675784e-04 4.13591535e-02
1.52151823e-02 8.30720805e-01
2.54119422e-07 9.34853110e-08 1.12425835e-01]
Test 3: Input: [15 20 19 23 8 7 21] -> Softmax: [2.78675784e-04 4.13591535e-02
1.52151823e-02 8.30720805e-01
2.54119422e-07 9.34853110e-08 1.12425835e-01]

Scenario 3
Test 1: Input: [19 27 22 10 10 18 38 13 45 23] -> Softmax: [5.10443431e-12 1.5216
1042e-08 1.02525304e-10 6.29937238e-16
6.29937238e-16 1.87781644e-12 9.11051180e-04 1.26526276e-14
9.99088933e-01 2.78692670e-10]
Test 2: Input: [19 27 22 10 10 18 38 13 45 23] -> Softmax: [5.10443431e-12 1.5216
1042e-08 1.02525304e-10 6.29937238e-16
6.29937238e-16 1.87781644e-12 9.11051180e-04 1.26526276e-14
9.99088933e-01 2.78692670e-10]
Test 3: Input: [19 27 22 10 10 18 38 13 45 23] -> Softmax: [5.10443431e-12 1.5216
1042e-08 1.02525304e-10 6.29937238e-16
6.29937238e-16 1.87781644e-12 9.11051180e-04 1.26526276e-14
9.99088933e-01 2.78692670e-10]

Part (b) Implementing the Multilay with AND,OR,XOR gateser Neural Network with
Additional Outputs with AND,OR,XOR gates

In [1]: import numpy as np

import pandas as pd
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
import random

# Set random seed for reproducibility

np.random.seed(828967)
random.seed(828967)

# Load data from CSV file

data = pd.read_csv('F:\\Logic gates random data.csv')

# Extract input features (x, y) and target (OR, AND, XOR)

X = data[['x', 'y']].values
y_xor = data['Label: XOR'].values

# Generate AND and OR outputs based on the XOR data

y_and = np.logical_and(X[:, 0] > 0, X[:, 1] > 0).astype(int)

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 2/22

11/13/24, 7:15 PM Assignment-2_AI

y_or = np.logical_or(X[:, 0] > 0, X[:, 1] > 0).astype(int)

# Stack the targets together into a 3-column array

y = np.column_stack([y_xor, y_and, y_or])

class NeuralNetwork:
def __init__(self, input_size, hidden_size, output_size, init_method='xavier
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.init_method = init_method

# Initialize weights and biases

if init_method == 'xavier':
self.weights_input_hidden = np.random.randn(self.input_size, self.hi
self.weights_hidden_output = np.random.randn(self.hidden_size, self.
else:
self.weights_input_hidden = np.random.randn(self.input_size, self.hi
self.weights_hidden_output = np.random.randn(self.hidden_size, self.

self.bias_hidden = np.zeros(self.hidden_size)
self.bias_output = np.zeros(self.output_size)

def sigmoid(self, x):

return 1 / (1 + np.exp(-x))

def sigmoid_derivative(self, x):

return x * (1 - x)

def forward(self, X):

self.hidden_input = np.dot(X, self.weights_input_hidden) + self.bias_hid
self.hidden_output = self.sigmoid(self.hidden_input)

self.final_input = np.dot(self.hidden_output, self.weights_hidden_output

self.final_output = self.sigmoid(self.final_input)
return self.final_output

def backward(self, X, y, learning_rate=0.1):

output_error = y - self.final_output
output_delta = output_error * self.sigmoid_derivative(self.final_output)

hidden_error = output_delta.dot(self.weights_hidden_output.T)
hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden_output

self.weights_hidden_output += self.hidden_output.T.dot(output_delta) * l
self.weights_input_hidden += X.T.dot(hidden_delta) * learning_rate

self.bias_output += np.sum(output_delta, axis=0) * learning_rate

self.bias_hidden += np.sum(hidden_delta, axis=0) * learning_rate

def train(self, X, y, epochs=10000, learning_rate=0.1):

for epoch in range(epochs):
self.forward(X)
self.backward(X, y, learning_rate)
if epoch % 1000 == 0:
loss = np.mean(np.square(y - self.final_output)) # Mean squared
print(f"Epoch {epoch}, Loss: {loss}")

def predict(self, X):

return self.forward(X)

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 3/22

11/13/24, 7:15 PM Assignment-2_AI

# Experiment with different network configurations

def experiment(hidden_size, learning_rate):
nn = NeuralNetwork(input_size=2, hidden_size=hidden_size, output_size=3)
nn.train(X, y, epochs=10000, learning_rate=learning_rate)
predictions = nn.predict(X)
predictions = np.round(predictions) # Round to nearest integer for classifi

# Prepare to plot confusion matrices in a compact 1x3 grid (one row, three c
fig, axes = plt.subplots(1, 3, figsize=(18, 6)) # Create a 1x3 grid of subp
axes = axes.ravel() # Flatten the grid to make it easier to iterate

# Confusion matrix for each gate operation

for i, operation in enumerate(["XOR", "AND", "OR"]):
cm = confusion_matrix(y[:, i], predictions[:, i])
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=["0", "1"
axes[i].set_title(f"Confusion Matrix for {operation} Gate")
axes[i].set_xlabel("Predicted")
axes[i].set_ylabel("True")

plt.tight_layout() # Adjust the layout for better spacing

plt.show()

# Run experiments with different configurations

print("Experiment 1: 4 hidden neurons, learning rate 0.1")
experiment(hidden_size=4, learning_rate=0.1)

print("Experiment 2: 6 hidden neurons, learning rate 0.01")

experiment(hidden_size=6, learning_rate=0.01)

print("Experiment 3: 8 hidden neurons, learning rate 0.05")

experiment(hidden_size=8, learning_rate=0.05)

Experiment 1: 4 hidden neurons, learning rate 0.1

Epoch 0, Loss: 0.2793942227108188
Epoch 1000, Loss: 0.15756478602285318
Epoch 2000, Loss: 0.15719856746061647
Epoch 3000, Loss: 0.15704659470142465
Epoch 4000, Loss: 0.15695605021364786
Epoch 5000, Loss: 0.1568926302339849
Epoch 6000, Loss: 0.15684404967270502
Epoch 7000, Loss: 0.15680480276420103
Epoch 8000, Loss: 0.15677197735003442
Epoch 9000, Loss: 0.15674384302574845

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 4/22

11/13/24, 7:15 PM Assignment-2_AI

Experiment 2: 6 hidden neurons, learning rate 0.01

Epoch 0, Loss: 0.2877635167445881
Epoch 1000, Loss: 0.015985662853869993
Epoch 2000, Loss: 0.010615244948812374
Epoch 3000, Loss: 0.008243619984823983
Epoch 4000, Loss: 0.0069262931537108895
Epoch 5000, Loss: 0.006071075249899509
Epoch 6000, Loss: 0.005459116792525534
Epoch 7000, Loss: 0.004998590188461029
Epoch 8000, Loss: 0.004642402693993645
Epoch 9000, Loss: 0.0043577337731462995

Experiment 3: 8 hidden neurons, learning rate 0.05

Epoch 0, Loss: 0.26950122416126926
Epoch 1000, Loss: 0.03040078284448532
Epoch 2000, Loss: 0.02651800625015735
Epoch 3000, Loss: 0.025281944674081017
Epoch 4000, Loss: 0.02470574138555958
Epoch 5000, Loss: 0.024334906410539692
Epoch 6000, Loss: 0.024051370548227473
Epoch 7000, Loss: 0.02381532328878226
Epoch 8000, Loss: 0.023609366242466612
Epoch 9000, Loss: 0.02342436835837076

2)Perceptrons and Backpropagation

Import Necessary Libraries

In [18]: import numpy as np

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPRegressor
from sklearn.metrics import mean_squared_error

# Load the data

# Assuming data is stored in a CSV file with x values as columns, y values as ro
data = pd.read_csv('F:/A2 interesting function.csv', header=None).values # Adju

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 5/22

11/13/24, 7:15 PM Assignment-2_AI

# Generate x, y input coordinates based on the data's shape

x_values = np.linspace(1, 7, data.shape[1]) # Corresponding x values
y_values = np.linspace(1, 7, data.shape[0]) # Corresponding y values
X, Y = np.meshgrid(x_values, y_values)

# Flatten the data to create pairs of (x, y) -> z

X_inputs = np.vstack([X.ravel(), Y.ravel()]).T # Input (x, y) pairs
Z_outputs = data.ravel() # Flattened target values (z values)

# Split the data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X_inputs, Z_outputs, test_si

Part (a): Single-Layer Perceptron

In [6]: from sklearn.linear_model import Perceptron

from sklearn.metrics import accuracy_score, mean_squared_error
import numpy as np

# Check and handle NaN values in y_train and y_test if necessary

y_train = np.nan_to_num(y_train, nan=np.nanmean(y_train))
y_test = np.nan_to_num(y_test, nan=np.nanmean(y_train))

# Round y values for binary classification if not already binary

y_train_binary = np.round(y_train)
y_test_binary = np.round(y_test)

# Initialize the Perceptron model

single_layer_model = Perceptron(max_iter=1000, tol=1e-3, random_state=42)

# Train the model

single_layer_model.fit(X_train, y_train_binary)

# Make predictions
y_pred_train = single_layer_model.predict(X_train)
y_pred_test = single_layer_model.predict(X_test)

# Calculate accuracy
train_accuracy = accuracy_score(y_train_binary, y_pred_train)
test_accuracy = accuracy_score(y_test_binary, y_pred_test)

# Calculate Mean Squared Error if still needed

train_error = mean_squared_error(y_train_binary, y_pred_train)
test_error = mean_squared_error(y_test_binary, y_pred_test)

print(f"Single-Layer Perceptron Training Accuracy: {train_accuracy}")

print(f"Single-Layer Perceptron Test Accuracy: {test_accuracy}")
print(f"Single-Layer Perceptron Training MSE: {train_error}")
print(f"Single-Layer Perceptron Test MSE: {test_error}")

Single-Layer Perceptron Training Accuracy: 0.7861904761904762

Single-Layer Perceptron Test Accuracy: 0.7984790874524715
Single-Layer Perceptron Training MSE: 9.365238095238094
Single-Layer Perceptron Test MSE: 7.608365019011407

Part (b): Multilayer Perceptron for Complex Function

In [7]: # Initialize the MLP Regressor with a deep architecture

mlp_model = MLPRegressor(hidden_layer_sizes=(100, 50, 25), activation='relu', ma

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 6/22

11/13/24, 7:15 PM Assignment-2_AI

# Train the model on the training data

mlp_model.fit(X_train, y_train)

# Make predictions and evaluate

y_train_pred = mlp_model.predict(X_train)
y_test_pred = mlp_model.predict(X_test)

# Calculate MSE for evaluation

train_mse = mean_squared_error(y_train, y_train_pred)
test_mse = mean_squared_error(y_test, y_test_pred)

print(f"Multilayer Perceptron Training MSE: {train_mse}")

print(f"Multilayer Perceptron Test MSE: {test_mse}")

Multilayer Perceptron Training MSE: 0.10987052146995327

Multilayer Perceptron Test MSE: 0.06719153913754096

Part (c): Applying Stochastic Gradient Descent (SGD)

In [8]: # Initialize MLP with small batch size to simulate SGD

sgd_model = MLPRegressor(hidden_layer_sizes=(100, 50, 25), activation='relu', ma
solver='sgd', batch_size=32, random_state=42)

# Train with SGD on the training data

sgd_model.fit(X_train, y_train)

# Predictions and evaluation for SGD-based model

y_train_pred_sgd = sgd_model.predict(X_train)
y_test_pred_sgd = sgd_model.predict(X_test)

# Calculate and print MSE

train_mse_sgd = mean_squared_error(y_train, y_train_pred_sgd)
test_mse_sgd = mean_squared_error(y_test, y_test_pred_sgd)

print(f"SGD Multilayer Perceptron Training MSE: {train_mse_sgd}")

print(f"SGD Multilayer Perceptron Test MSE: {test_mse_sgd}")

SGD Multilayer Perceptron Training MSE: 0.882578114905113

SGD Multilayer Perceptron Test MSE: 0.7247175279035392

3.Convolution filters and convolution networks

Part (a): Manually Applying Horizontal and Vertical Filters

In [9]: import numpy as np

import cv2 # OpenCV for image processing
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import cifar10

# Load CIFAR-10 dataset

(X_train, y_train), (_, _) = cifar10.load_data()
image = X_train[0] # Pick any image for testing

# Define vertical and horizontal filters

vertical_filter = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])
horizontal_filter = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]])

# Apply filters using OpenCV

vertical_edges = cv2.filter2D(image, -1, vertical_filter)

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 7/22

11/13/24, 7:15 PM Assignment-2_AI

horizontal_edges = cv2.filter2D(image, -1, horizontal_filter)

# Plot original and filtered images

plt.figure(figsize=(10, 4))
plt.subplot(1, 3, 1)
plt.title("Original Image")
plt.imshow(image)
plt.subplot(1, 3, 2)
plt.title("Vertical Edges")
plt.imshow(vertical_edges)
plt.subplot(1, 3, 3)
plt.title("Horizontal Edges")
plt.imshow(horizontal_edges)
plt.show()

In [2]: import pickle

import numpy as np
import matplotlib.pyplot as plt
import cv2 # OpenCV for applying the filters

# Load CIFAR-10 batch

def unpickle(file):
with open(file, 'rb') as fo:
dict = pickle.load(fo, encoding='bytes')
return dict

# Load the CIFAR-10 batch file (change path accordingly)

batch = unpickle('C:/Users/sindhuja/Downloads/cifar-10-python/cifar-10-batches-p

# Image data (a 10000 x 3072 array)

data = batch[b'data']
# Image labels (a list of 10000 labels)
labels = batch[b'labels']

# List of CIFAR-10 class names

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', '

# Get one image (for example, index 3)

image_index = 12
image = data[image_index].reshape(3, 32, 32).transpose(1, 2, 0) # Reshape and t

# Get the label of the image

image_label = labels[image_index]
image_name = class_names[image_label] # Map label to class name

# Display the original image with its name

plt.imshow(image)

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 8/22

11/13/24, 7:15 PM Assignment-2_AI

plt.title(f'Class: {image_name}') # Show the class name as the title

plt.axis('off') # Hide axes for better visualization
plt.show()

# Select a specific row from the image (e.g., row 10)

row = image[10, :, :] # Select row 10, which is 32 pixels with 3 RGB values

# Convert the row to grayscale by averaging the RGB values

grayscale_row = np.mean(row, axis=1).astype(np.uint8)

# Reshape grayscale_row to 2D (1 row and 32 columns)

grayscale_row = grayscale_row.reshape(1, 32)

# Define a simple 3x3 vertical filter (emphasizes vertical edges)

vertical_filter = np.array([
[1, 0, -1],
[1, 0, -1],
[1, 0, -1]
])

# Define a simple 3x3 horizontal filter (emphasizes horizontal edges)

horizontal_filter = np.array([
[1, 1, 1],
[0, 0, 0],
[-1, -1, -1]
])

# Apply the vertical filter to the row (using filter2D from OpenCV)
vertical_result = cv2.filter2D(grayscale_row, -1, vertical_filter)

# Apply the horizontal filter to the row (using filter2D from OpenCV)
horizontal_result = cv2.filter2D(grayscale_row, -1, horizontal_filter)

# Plot the results

plt.figure(figsize=(12, 6))

# Display the original grayscale row

plt.subplot(1, 3, 1)
plt.imshow(grayscale_row, cmap='gray', aspect='auto')
plt.title('Original Row (Grayscale)')

# Display the result after applying the vertical filter

plt.subplot(1, 3, 2)
plt.imshow(vertical_result, cmap='gray', aspect='auto')
plt.title('Vertical Filter Applied')

# Display the result after applying the horizontal filter

plt.subplot(1, 3, 3)
plt.imshow(horizontal_result, cmap='gray', aspect='auto')
plt.title('Horizontal Filter Applied')

plt.show()

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 9/22

11/13/24, 7:15 PM Assignment-2_AI

In [3]: import numpy as np

import matplotlib.pyplot as plt
from keras.datasets import cifar10

# Load CIFAR-10 dataset

(trainX, trainy), (testX, testy) = cifar10.load_data()

# Select a random image from the dataset (for example, the first image in the tr
image = trainX[0] # Shape is (32, 32, 3) for CIFAR-10 images (32x32 RGB image)

# Select a row from the image (for example, row 16)

row = image[16] # A row from the image (shape: (32, 3))

# Define horizontal and vertical filters (3x3)

horizontal_filter = np.array([[ 1, 1, 1],
[ 0, 0, 0],

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 10/22

11/13/24, 7:15 PM Assignment-2_AI

[-1, -1, -1]])

vertical_filter = np.array([[ 1, 0, -1],

[ 1, 0, -1],
[ 1, 0, -1]])

# Function to apply a filter to an image row (simple convolution)

def apply_filter(image_row, filter):
# For simplicity, apply filter directly to the row (not full convolution for
row_len = image_row.shape[0]
filtered_row = np.zeros_like(image_row)

# Slide the filter across the row (since it's a row, we can only apply it ho
for i in range(1, row_len - 1):
filtered_row[i] = np.sum(image_row[i - 1:i + 2] * filter, axis=0)

return filtered_row

# Apply filters to the row

horizontal_filtered_row = apply_filter(row, horizontal_filter)
vertical_filtered_row = apply_filter(row, vertical_filter)

# Plot the original image and filtered rows

fig, axes = plt.subplots(1, 4, figsize=(16, 4))

# Display original full image

axes[0].imshow(image) # Display the full image
axes[0].set_title('Original Image')
axes[0].axis('off')

# Display original row

axes[1].imshow([row], cmap='gray', aspect='auto') # Display the single row of t
axes[1].set_title('Original Row')
axes[1].axis('off')

# Display horizontal filter result

axes[2].imshow([horizontal_filtered_row], cmap='gray', aspect='auto') # Display
axes[2].set_title('Horizontal Filter Applied')
axes[2].axis('off')

# Display vertical filter result

axes[3].imshow([vertical_filtered_row], cmap='gray', aspect='auto') # Display t
axes[3].set_title('Vertical Filter Applied')
axes[3].axis('off')

plt.show()

In [ ]: Part (b): Applying Gabor Filters and Using a CNN

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 11/22

11/13/24, 7:15 PM Assignment-2_AI

In [4]: import numpy as np

import matplotlib.pyplot as plt
from keras.datasets import cifar10
from skimage.filters import gabor
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split

# Load CIFAR-10 dataset

(trainX, trainy), (testX, testy) = cifar10.load_data()

# Filter the dataset for two classes (e.g., class 1: Automobile, class 9: Truck)
class_1, class_2 = 1, 9 # Automobile and Truck classes in CIFAR-10
class_1_images = trainX[trainy.flatten() == class_1]
class_2_images = trainX[trainy.flatten() == class_2]

# Combine and label the data

data = np.concatenate([class_1_images, class_2_images], axis=0)
labels = np.concatenate([np.zeros(len(class_1_images)), np.ones(len(class_2_imag

# Apply Gabor filters to each image

def apply_gabor_filter(image, frequency=0.6, theta=0):
"""Apply Gabor filter to all color channels of an image."""
filtered_channels = []
for c in range(image.shape[2]): # Loop over each channel (R, G, B)
filtered, _ = gabor(image[:, :, c], frequency=frequency, theta=theta)
filtered_channels.append(filtered)
return np.stack(filtered_channels, axis=-1) # Stack along the last axis (co

# Select frequency and orientation parameters for Gabor filter

frequency = 0.6
theta = np.pi / 4 # 45 degrees orientation

# Process images with the Gabor filter

filtered_data = np.array([apply_gabor_filter(image, frequency=frequency, theta=t
filtered_data = filtered_data.reshape(filtered_data.shape[0], 32, 32, 3) # Resh

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(filtered_data, labels, test_

# Convert labels to categorical (one-hot encoding)

y_train = to_categorical(y_train, 2)
y_test = to_categorical(y_test, 2)

# Build a simple CNN model

model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D((2, 2)),
Flatten(),
Dense(64, activation='relu'),
Dense(2, activation='softmax') # Output layer for 2 classes
])

# Compile the model

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accur

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 12/22

11/13/24, 7:15 PM Assignment-2_AI

# Train the model

history = model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=

# Evaluate the model

loss, accuracy = model.evaluate(X_test, y_test)
print(f"Test Accuracy: {accuracy * 100:.2f}%")

# Display original and Gabor-filtered image for one sample of each class
fig, axes = plt.subplots(2, 2, figsize=(8, 8))

# Original and filtered for class 1 (Automobile)

axes[0, 0].imshow(class_1_images[0])
axes[0, 0].set_title("Original (Class: Automobile)")
axes[0, 1].imshow(filtered_data[0].squeeze(), cmap='gray') # Filtered image
axes[0, 1].set_title("Gabor Filtered")

# Original and filtered for class 2 (Truck)

axes[1, 0].imshow(class_2_images[0])
axes[1, 0].set_title("Original (Class: Truck)")
axes[1, 1].imshow(filtered_data[len(class_1_images)].squeeze(), cmap='gray') #
axes[1, 1].set_title("Gabor Filtered")

for ax in axes.flat:
ax.axis('off')
plt.show()

C:\Users\sindhuja\anaconda3\Lib\site-packages\keras\src\layers\convolutional\base
_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a
layer. When using Sequential models, prefer using an `Input(shape)` object as the
first layer in the model instead.
super().__init__(activity_regularizer=activity_regularizer, **kwargs)

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 13/22

11/13/24, 7:15 PM Assignment-2_AI

Epoch 1/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 6s 13ms/step - accuracy: 0.5383 - loss: 7.6274 - val
_accuracy: 0.6185 - val_loss: 0.6477
Epoch 2/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.6573 - loss: 0.6180 - val
_accuracy: 0.7180 - val_loss: 0.5646
Epoch 3/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.7367 - loss: 0.5262 - val
_accuracy: 0.7425 - val_loss: 0.5146
Epoch 4/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.7817 - loss: 0.4496 - val
_accuracy: 0.7685 - val_loss: 0.4829
Epoch 5/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.8197 - loss: 0.3996 - val
_accuracy: 0.7220 - val_loss: 0.5916
Epoch 6/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 10ms/step - accuracy: 0.8396 - loss: 0.3574 - val
_accuracy: 0.7620 - val_loss: 0.5028
Epoch 7/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 11ms/step - accuracy: 0.8648 - loss: 0.3104 - val
_accuracy: 0.7755 - val_loss: 0.5291
Epoch 8/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.8869 - loss: 0.2624 - val
_accuracy: 0.7665 - val_loss: 0.5338
Epoch 9/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 11ms/step - accuracy: 0.9151 - loss: 0.2042 - val
_accuracy: 0.7435 - val_loss: 0.7290
Epoch 10/10
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 11ms/step - accuracy: 0.9258 - loss: 0.1799 - val
_accuracy: 0.7510 - val_loss: 0.7770
63/63 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - accuracy: 0.7393 - loss: 0.7797
Test Accuracy: 75.10%

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 14/22

11/13/24, 7:15 PM Assignment-2_AI

In [5]: import numpy as np

import matplotlib.pyplot as plt
from keras.datasets import cifar10
from skimage.filters import gabor
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split

# Load CIFAR-10 dataset

(trainX, trainy), (testX, testy) = cifar10.load_data()

# Filter the dataset for two classes (e.g., class 1: Automobile, class 9: Truck)
class_1, class_2 = 1, 9 # Automobile and Truck classes in CIFAR-10
class_1_images = trainX[trainy.flatten() == class_1]
class_2_images = trainX[trainy.flatten() == class_2]

# Combine and label the data

data = np.concatenate([class_1_images, class_2_images], axis=0)
labels = np.concatenate([np.zeros(len(class_1_images)), np.ones(len(class_2_imag

# Apply Gabor filters to each image

def apply_gabor_filter(image, frequency=0.6, theta=0):

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 15/22

11/13/24, 7:15 PM Assignment-2_AI

"""Apply Gabor filter to an image."""

filtered, _ = gabor(image[:, :, 0], frequency=frequency, theta=theta) # App
return filtered

# Select frequency and orientation parameters for Gabor filter

frequency = 0.6
theta = np.pi / 4

# Process images with the Gabor filter

filtered_data = np.array([apply_gabor_filter(image, frequency=frequency, theta=t
filtered_data = filtered_data.reshape(filtered_data.shape[0], 32, 32, 1) # Resh

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(filtered_data, labels, test_

# Convert labels to categorical

y_train = to_categorical(y_train, 2)
y_test = to_categorical(y_test, 2)

# Build a simple CNN model

model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 1)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D((2, 2)),
Flatten(),
Dense(64, activation='relu'),
Dense(2, activation='softmax')
])

# Compile the model

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accur

# Train the model

history = model.fit(X_train, y_train, epochs=5, batch_size=32, validation_data=(

# Evaluate the model

loss, accuracy = model.evaluate(X_test, y_test)
print(f"Test Accuracy: {accuracy * 100:.2f}%")

# Display original and Gabor-filtered image for one sample of each class
fig, axes = plt.subplots(2, 2, figsize=(8, 8))

# Original and filtered for class 1

axes[0, 0].imshow(class_1_images[0])
axes[0, 0].set_title("Original (Class: Automobile)")
axes[0, 1].imshow(filtered_data[0].squeeze(), cmap='gray')
axes[0, 1].set_title("Gabor Filtered")

# Original and filtered for class 2

axes[1, 0].imshow(class_2_images[0])
axes[1, 0].set_title("Original (Class: Truck)")
axes[1, 1].imshow(filtered_data[len(class_1_images)].squeeze(), cmap='gray')
axes[1, 1].set_title("Gabor Filtered")

for ax in axes.flat:
ax.axis('off')
plt.show()

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 16/22

11/13/24, 7:15 PM Assignment-2_AI

Epoch 1/5
250/250 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - accuracy: 0.5601 - loss: 4.3308 - val
_accuracy: 0.6895 - val_loss: 0.5777
Epoch 2/5
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 11ms/step - accuracy: 0.7114 - loss: 0.5511 - val
_accuracy: 0.7360 - val_loss: 0.5256
Epoch 3/5
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 11ms/step - accuracy: 0.7697 - loss: 0.4830 - val
_accuracy: 0.7540 - val_loss: 0.5201
Epoch 4/5
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 11ms/step - accuracy: 0.8119 - loss: 0.4137 - val
_accuracy: 0.7570 - val_loss: 0.5037
Epoch 5/5
250/250 ━━━━━━━━━━━━━━━━━━━━ 3s 11ms/step - accuracy: 0.8488 - loss: 0.3492 - val
_accuracy: 0.7640 - val_loss: 0.5165
63/63 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - accuracy: 0.7792 - loss: 0.5020
Test Accuracy: 76.40%

4. Recurrent network

a) Convert FFNN to RNN

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 17/22

11/13/24, 7:15 PM Assignment-2_AI

In [1]: import numpy as np

class SimpleRNN:
def __init__(self, input_size, hidden_size, output_size):
self.hidden_size = hidden_size
self.W_xh = np.random.randn(hidden_size, input_size) * 0.01
self.W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
self.W_hy = np.random.randn(output_size, hidden_size) * 0.01
self.b_h = np.zeros((hidden_size, 1))
self.b_y = np.zeros((output_size, 1))

def forward(self, inputs):

h = np.zeros((self.hidden_size, 1))
outputs = []
for x in inputs:
h = np.tanh(np.dot(self.W_xh, x) + np.dot(self.W_hh, h) + self.b_h)
y = np.dot(self.W_hy, h) + self.b_y
outputs.append(y)
return outputs

# Test the RNN

rnn = SimpleRNN(input_size=1, hidden_size=10, output_size=1)
test_input = [np.random.randn(1, 1) for _ in range(5)]
output = rnn.forward(test_input)
print("Output:", output)

Output: [array([[0.00014617]]), array([[0.00035498]]), array([[-0.00035866]]), ar

ray([[2.4095945e-05]]), array([[0.00012321]])]

b) Simple Dataset - Predicting the Next Character in "abcdefghij"

In [6]: import numpy as np

# Hyperparameters
input_size = 27 # Size of the alphabet + 1 for a space (for simplicity)
hidden_size = 50 # Number of hidden units
output_size = 27 # Same as input_size for character prediction
learning_rate = 0.01

# Initialize weights and biases

Wxh = np.random.randn(hidden_size, input_size) * 0.01 # input to hidden
Whh = np.random.randn(hidden_size, hidden_size) * 0.01 # hidden to hidden
Why = np.random.randn(output_size, hidden_size) * 0.01 # hidden to output
bh = np.zeros((hidden_size, 1)) # hidden bias
by = np.zeros((output_size, 1)) # output bias

# Helper functions
def softmax(x):
e_x = np.exp(x - np.max(x))
return e_x / e_x.sum(axis=0)

def one_hot_encode(char, char_to_index):

one_hot = np.zeros((len(char_to_index), 1))
one_hot[char_to_index[char]] = 1
return one_hot

def forward(inputs, hidden_prev):

xs, hs, ys, ps = {}, {}, {}, {}
hs[-1] = np.copy(hidden_prev)

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 18/22

11/13/24, 7:15 PM Assignment-2_AI

for t in range(len(inputs)):
xs[t] = one_hot_encode(inputs[t], char_to_index)
hs[t] = np.tanh(np.dot(Wxh, xs[t]) + np.dot(Whh, hs[t - 1]) + bh)
ys[t] = np.dot(Why, hs[t]) + by
ps[t] = softmax(ys[t])
return xs, hs, ys, ps

def loss_and_gradients(inputs, targets, hidden_prev):

xs, hs, ys, ps = forward(inputs, hidden_prev)
loss = 0
for t in range(len(inputs)):
loss += -np.log(ps[t][char_to_index[targets[t]], 0])

# Backpropagation through time (BPTT)

dWxh, dWhh, dWhy = np.zeros_like(Wxh), np.zeros_like(Whh), np.zeros_like(Why
dbh, dby = np.zeros_like(bh), np.zeros_like(by)
dhnext = np.zeros_like(hs[0])

for t in reversed(range(len(inputs))):
dy = np.copy(ps[t])
dy[char_to_index[targets[t]]] -= 1
dWhy += np.dot(dy, hs[t].T)
dby += dy
dh = np.dot(Why.T, dy) + dhnext
dhraw = (1 - hs[t] * hs[t]) * dh
dbh += dhraw
dWxh += np.dot(dhraw, xs[t].T)
dWhh += np.dot(dhraw, hs[t - 1].T)
dhnext = np.dot(Whh.T, dhraw)

for dparam in [dWxh, dWhh, dWhy, dbh, dby]:

np.clip(dparam, -5, 5, out=dparam) # Clip to mitigate exploding gradien

return loss, dWxh, dWhh, dWhy, dbh, dby, hs[len(inputs) - 1]

def train_RNN(data, epochs=100):

global Wxh, Whh, Why, bh, by
n = 0
smooth_loss = -np.log(1.0 / len(char_to_index)) * len(data)

for epoch in range(epochs):

hidden_prev = np.zeros((hidden_size, 1))
inputs = data[:-1]
targets = data[1:]

loss, dWxh, dWhh, dWhy, dbh, dby, hidden_prev = loss_and_gradients(input

smooth_loss = smooth_loss * 0.999 + loss * 0.001

for param, dparam in zip([Wxh, Whh, Why, bh, by],

[dWxh, dWhh, dWhy, dbh, dby]):
param -= learning_rate * dparam

if epoch % 10 == 0:
print(f'Epoch {epoch}, Loss: {smooth_loss}')

def predict(input_seq, char_to_index, index_to_char):

hidden_prev = np.zeros((hidden_size, 1))
for char in input_seq:
xs, hs, _, ps = forward(input_seq, hidden_prev)
pred_index = np.argmax(ps[len(input_seq) - 1])

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 19/22

11/13/24, 7:15 PM Assignment-2_AI

pred_char = index_to_char[pred_index]
return pred_char

# Example Data
char_to_index = {char: index for index, char in enumerate(' abcdefghijklmnopqrst
index_to_char = {index: char for char, index in char_to_index.items()}

# Training data for 'abcdefghij'

data = ' abcdefghij' * 100

train_RNN(data, epochs=100)
test_seq = 'abc'
print(f"Next character after '{test_seq}': {predict(test_seq, char_to_index, ind

Epoch 0, Loss: 3625.4171772964037

Epoch 10, Loss: 3618.376371851605
Epoch 20, Loss: 3590.401336673658
Epoch 30, Loss: 3554.686090191355
Epoch 40, Loss: 3519.3076496882636
Epoch 50, Loss: 3484.2789370862656
Epoch 60, Loss: 3449.5976194904497
Epoch 70, Loss: 3415.260714619771
Epoch 80, Loss: 3381.265044920851
Epoch 90, Loss: 3347.607364218161
Next character after 'abc': d

c) Training on the Shakespeare Dataset

In [ ]: import numpy as np
import requests

# Download the Shakespeare dataset

url = "https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.t
response = requests.get(url)
text = response.text

# Preprocess the text (remove newlines and spaces, and create mappings)
chars = sorted(set(text)) # Unique characters in the text
char_to_int = {ch: i for i, ch in enumerate(chars)} # Map characters to integer
int_to_char = {i: ch for i, ch in enumerate(chars)} # Reverse map to get charac

# Vectorize the text

text_int = [char_to_int[ch] for ch in text]

# Function to create sequences for training

def create_sequences(data, seq_length=100):
X, y = [], []
for i in range(len(data) - seq_length):
X.append(data[i:i + seq_length])
y.append(data[i + seq_length]) # Next character is the target
return np.array(X), np.array(y)

# Create sequences
seq_length = 100 # Length of each input sequence
X, y = create_sequences(text_int, seq_length)

# Define the RNN model (similar to the previous one)

class RNN(object):
RNG = np.random.default_rng()

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 20/22

11/13/24, 7:15 PM Assignment-2_AI

def __init__(self, topology: list[int] = []):

self.topology = topology
self.weight_mats = []
self.recurrent_weights = []
self._init_matrices()

def _init_matrices(self):
if len(self.topology) > 1:
j = 1
for i in range(len(self.topology) - 1):
num_rows = self.topology[i]
num_cols = self.topology[j]
mat = self.RNG.uniform(-0.1, 0.1, size=(num_rows, num_cols))
self.weight_mats.append(mat)
j += 1
self.recurrent_weights = self.RNG.uniform(-0.1, 0.1, size=(self.topo

def feedforward(self, input_vector, hidden_state):

I = np.dot(input_vector, self.weight_mats[0]) + np.dot(hidden_state, sel
hidden_state = np.tanh(I)
output = np.dot(hidden_state, self.weight_mats[1])
return output, hidden_state

def train(self, X, y, epochs=1000, learning_rate=0.001):

for epoch in range(epochs):
total_loss = 0
hidden_state = np.zeros(self.topology[1])
for i in range(len(X)):
input_data = X[i]
target = y[i]

output, hidden_state = self.feedforward(input_data, hidden_state

loss = np.mean((output - target) ** 2)

total_loss += loss

output_error = output - target

hidden_error = output_error.dot(self.weight_mats[1].T) * (1 - hi

self.weight_mats[1] -= learning_rate * np.outer(hidden_state, ou

self.weight_mats[0] -= learning_rate * np.outer(input_data, hidd
self.recurrent_weights -= learning_rate * np.outer(hidden_state,

if epoch % 100 == 0:
print(f"Epoch {epoch}, Loss: {total_loss / len(X)}")

# Define the RNN topology

topology = [100, 256, len(chars)] # Input size = 100, hidden layer size = 256,
rnn = RNN(topology)

# Train the model on the Shakespeare dataset

rnn.train(X, y, epochs=1000)

# Generate text after training

seed_input = "To be or not to be"
input_seq = [char_to_int[ch] for ch in seed_input]
hidden_state = np.zeros(topology[1])

# Generate text based on the seed input

generated_text = seed_input

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 21/22

11/13/24, 7:15 PM Assignment-2_AI

for _ in range(500): # Generate 500 characters

input_data = np.array(input_seq[-seq_length:]).reshape(1, -1)
output, hidden_state = rnn.feedforward(input_data, hidden_state)

predicted_char_idx = np.argmax(output)
predicted_char = int_to_char[predicted_char_idx]

generated_text += predicted_char
input_seq.append(predicted_char_idx)

print(f"Generated text: {generated_text}")

Epoch 0, Loss: 527.2239487776425

file:///C:/Users/sindhuja/Downloads/Assignment-2_AI (4).html 22/22