Software Laboratory II Code

Software Laboratory - II
Assignment No. 1
Code:
import numpy as np
import matplotlib.pyplot as plt
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def relu(x):
return np.maximum(0, x)
def tanh(x):
return np.tanh(x)
def softmax(x):
return np.exp(x) / np.sum(np.exp(x))
# Create x values
x = np.linspace(-10, 10, 100)
# Create plots for each activation function

fig, axs = plt.subplots(2, 2, figsize=(8, 8))
axs[0, 0].plot(x, sigmoid(x))
axs[0, 0].set_title('Sigmoid')
axs[0, 1].plot(x, relu(x))
axs[0, 1].set_title('ReLU')
axs[1, 0].plot(x, tanh(x))
axs[1, 0].set_title('Tanh')
axs[1, 1].plot(x, softmax(x))
axs[1, 1].set_title('Softmax')
# Add common axis labels and titles

fig.suptitle('Common Activation Functions')
for ax in axs.flat:
ax.set(xlabel='x', ylabel='y')
# Adjust spacing between subplots

plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9, wspace=0.4, hspace=0.4)
# Show the plot

plt.show()
Output:
Assignment No. 2
Code:
# importing libraries
import numpy as np
# function of checking thresold value

def linear_threshold_gate(dot, T):
'''Returns the binary threshold output'''
if dot >= T:
return 1
else:
return 0
# matrix of inputs
input_table = np.array([
[0,0], # both no
[0,1], # one no, one yes
[1,0], # one yes, one no
[1,1] # bot yes
])
print(f'input table:\n{input_table}')
weights = np.array([1,-1])
dot_products = input_table @ weights
T=1
for i in range(0,4):
activation = linear_threshold_gate(dot_products[i], T)
print(f'Activation: {activation}')
Output:
input table:
[[0 0]
[0 1]
[1 0]
[1 1]]
Activation: 0
Activation: 0
Activation: 1
Activation: 0
Assignment No.3
Code:
import numpy as np
# Define the perceptron class

class Perceptron:
def init (self, input_size, lr=0.1):
self.W = np.zeros(input_size + 1)
self.lr = lr
def activation_fn(self, x):

return 1 if x >= 0 else 0
def predict(self, x):

x = np.insert(x, 0, 1)
z = self.W.T.dot(x)
a = self.activation_fn(z)
return a
def train(self, X, Y, epochs):

for _ in range(epochs):
for i in range(Y.shape[0]):
x = X[i]
y = self.predict(x)
e = Y[i] - y
self.W = self.W + self.lr * e * np.insert(x, 0, 1)
# Define the input data and labels

X = np.array([
[0,0,0,0,0,0,1,0,0,0], # 0
[0,0,0,0,0,0,0,1,0,0], # 1
[0,0,0,0,0,0,0,0,1,0], # 2
[0,0,0,0,0,0,0,0,0,1], # 3
[0,0,0,0,0,0,1,1,0,0], # 4
[0,0,0,0,0,0,1,0,1,0], # 5
[0,0,0,0,0,0,1,1,1,0], # 6
[0,0,0,0,0,0,1,1,1,1], # 7
[0,0,0,0,0,0,1,0,1,1], # 8
[0,0,0,0,0,0,0,1,1,1], # 9
])
Y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
# Create the perceptron and train it

perceptron = Perceptron(input_size=10)
perceptron.train(X, Y, epochs=100)
# Test the perceptron on some input data

test_X = np.array([
[0,0,0,0,0,0,1,0,0,0], # 0
[0,0,0,0,0,0,0,1,0,0], # 1
[0,0,0,0,0,0,0,0,1,0], # 2
[0,0,0,0,0,0,0,0,0,1], # 3
[0,0,0,0,0,0,1,1,0,0], # 4
[0,0,0,0,0,0,1,0,1,0], # 5
[0,0,0,0,0,0,1,1,1,0], # 6
[0,0,0,0,0,0,1,1,1,1], # 7
[0,0,0,0,0,0,1,0,1,1], # 8
[0,0,0,0,0,0,0,1,1,1], # 9
])
for i in range(test_X.shape[0]):
x = test_X[i]
y = perceptron.predict(x)
print(f'{x} is {"even" if y == 0 else "odd"}')
Output:
[0 0 0 0 0 0 1 0 0 0] is even
[0 0 0 0 0 0 0 1 0 0] is odd
[0 0 0 0 0 0 0 0 1 0] is even
[0 0 0 0 0 0 0 0 0 1] is odd
[0 0 0 0 0 0 1 1 0 0] is even
[0 0 0 0 0 0 1 0 1 0] is even
[0 0 0 0 0 0 1 1 1 0] is even
[0 0 0 0 0 0 1 1 1 1] is even
[0 0 0 0 0 0 1 0 1 1] is even
[0 0 0 0 0 0 0 1 1 1] is odd
Assignment No. 4
Code:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
# load iris dataset

iris = load_iris()
# extract sepal length and petal length features

X = iris.data[:, [0, 2]]
y = iris.target
# setosa is class 0, versicolor is class 1

y = np.where(y == 0, 0, 1)
# initialize weights and bias

w = np.zeros(2)
b=0
# set learning rate and number of epochs

lr = 0.1
epochs = 50
# define perceptron function

def perceptron(x, w, b):
# calculate weighted sum of inputs
z = np.dot(x, w) + b
# apply step function
return np.where(z >= 0, 1, 0)
# train the perceptron

for epoch in range(epochs):
for i in range(len(X)):
x = X[i]
target = y[i]
output = perceptron(x, w, b)
error = target - output
w += lr * error * x
b += lr * error
# plot decision boundary

x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
np.arange(y_min, y_max, 0.02))
Z = perceptron(np.c_[xx.ravel(), yy.ravel()], w, b)
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
# plot data points

plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired)
plt.xlabel('Sepal length')
plt.ylabel('Petal length')
plt.title('Perceptron decision regions')
plt.show()
Output:
Assignment No. 5
Code:
import numpy as np
# define two pairs of vectors

x1 = np.array([1, 1, 1, -1])
y1 = np.array([1, -1])
x2 = np.array([-1, -1, 1, 1])
y2 = np.array([-1, 1])
# compute weight matrix W

W = np.outer(y1, x1) + np.outer(y2, x2)
# define BAM function

def bam(x):
y = np.dot(W, x)
y = np.where(y >= 0, 1, -1)
return y
# test BAM with inputs

x_test = np.array([1, -1, -1, -1])
y_test = bam(x_test)
# print output
print("Input x: ", x_test)
print("Output y: ", y_test)
Output:
Input x: [ 1 -1 -1 -1]
Output y: [ 1 -1]
Assignment No.6
Code:
import numpy as np
class NeuralNetwork:
def init (self, input_size, hidden_size, output_size):

self.W1 = np.random.randn(input_size, hidden_size)
self.b1 = np.zeros((1, hidden_size))
self.W2 = np.random.randn(hidden_size, output_size)
self.b2 = np.zeros((1, output_size))
def sigmoid(self, x):

def sigmoid_derivative(self, x):

return x * (1 - x)
def forward_propagation(self, X):

self.z1 = np.dot(X, self.W1) + self.b1
self.a1 = self.sigmoid(self.z1)
self.z2 = np.dot(self.a1, self.W2) + self.b2
self.y_hat = self.sigmoid(self.z2)
return self.y_hat
def backward_propagation(self, X, y, y_hat):

self.error = y - y_hat
self.delta2 = self.error * self.sigmoid_derivative(y_hat)
self.a1_error = self.delta2.dot(self.W2.T)
self.delta1 = self.a1_error * self.sigmoid_derivative(self.a1)
self.W2 += self.a1.T.dot(self.delta2)
self.b2 += np.sum(self.delta2, axis=0, keepdims=True)
self.W1 += X.T.dot(self.delta1)
self.b1 += np.sum(self.delta1, axis=0)
def train(self, X, y, epochs, learning_rate):

for i in range(epochs):
y_hat = self.forward_propagation(X)
self.backward_propagation(X, y, y_hat)
if i % 100 == 0:
print("Error at epoch", i, ":", np.mean(np.abs(self.error)))
# Define the input and output datasets

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
# Create a neural network with 2 input neurons, 4 neurons in the hidden layer, and 1
output neuron
nn = NeuralNetwork([2, 4, 1], activation='relu')
# Train the neural network on the input and output datasets for 10000 epochs with a learning rate
of 0.1
nn.train(X, y, lr=0.1, epochs=10000)
# Use the trained neural network to make predictions on the same input dataset
predictions = nn.predict(X)
# Print the predictions

print(predictions)
Output:
[[5.55111512e-16]
[6.66666667e-01]
[6.66666667e-01]
[6.66666667e-01]]
Assignment No. 7
Code:
import numpy as np
class XORNetwork:
def init (self):
# Initialize the weights and biases randomly
self.W1 = np.random.randn(2, 2)
self.b1 = np.random.randn(2)
self.W2 = np.random.randn(2, 1)
self.b2 = np.random.randn(1)
def sigmoid(self, x):

def sigmoid_derivative(self, x):

return x * (1 - x)
def forward(self, X):

# Perform the forward pass
self.z1 = np.dot(X, self.W1) + self.b1
self.z2 = np.dot(self.a1, self.W2) + self.b2
return self.a2
def backward(self, X, y, output):

# Perform the backward pass
self.output_error = y - output
self.output_delta = self.output_error * self.sigmoid_derivative(output)
self.z1_error = self.output_delta.dot(self.W2.T)
self.z1_delta = self.z1_error * self.sigmoid_derivative(self.a1)
self.W1 += X.T.dot(self.z1_delta)
self.b1 += np.sum(self.z1_delta, axis=0)
self.W2 += self.a1.T.dot(self.output_delta)
self.b2 += np.sum(self.output_delta, axis=0)
def train(self, X, y, epochs):

# Train the network for a given number of
epochs for i in range(epochs):
output = self.forward(X)
self.backward(X, y, output)
def predict(self, X):

# Make predictions for a given set of inputs
return self.forward(X)
# Create a new XORNetwork instance

xor_nn = XORNetwork()
# Define the input and output datasets for XOR

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
# Train the network for 10000 epochs

xor_nn.train(X, y, epochs=10000)
# Make predictions on the input dataset

predictions = xor_nn.predict(X)
# Print the predictions

print(predictions)
Output:
[[0.01063456]
[0.98893162]
[0.98893279]
[0.01358006]]
Assignment No. 8
Code:
import numpy as np
# Define sigmoid activation function

def sigmoid(x):
# Define derivative of sigmoid function

def sigmoid_derivative(x):
return x * (1 - x)
# Define input dataset

X = np.array([[0,0], [0,1], [1,0], [1,1]])
# Define output dataset

y = np.array([[0], [1], [1], [0]])
# Define hyperparameters
learning_rate = 0.1
num_epochs = 100000
# Initialize weights randomly with mean 0

hidden_weights = 2*np.random.random((2,2)) - 1
output_weights = 2*np.random.random((2,1)) - 1
# Train the neural network

for i in range(num_epochs):
# Forward propagation
hidden_layer = sigmoid(np.dot(X, hidden_weights))
output_layer = sigmoid(np.dot(hidden_layer, output_weights))
# Backpropagation
output_error = y - output_layer
output_delta = output_error * sigmoid_derivative(output_layer)
hidden_error = output_delta.dot(output_weights.T)
hidden_delta = hidden_error * sigmoid_derivative(hidden_layer)
output_weights += hidden_layer.T.dot(output_delta) * learning_rate

hidden_weights += X.T.dot(hidden_delta) * learning_rate
# Display input and output

print("Input:")
print(X)
print("Output:")
print(output_layer)
Output:
Input:
[[0 0]
[0 1]
[1 0]
[1 1]]
Output:
[[0.61385986]
[0.63944088]
[0.8569871 ]
[0.11295854]]
Assignment No. 9
Code:
import numpy as np
class HopfieldNetwork:
def init (self, n_neurons):
self.n_neurons = n_neurons
self.weights = np.zeros((n_neurons, n_neurons))
def train(self, patterns):

for pattern in patterns:
self.weights += np.outer(pattern, pattern)
np.fill_diagonal(self.weights, 0)
def predict(self, pattern):

energy = -0.5 * np.dot(np.dot(pattern, self.weights), pattern)
return np.sign(np.dot(pattern, self.weights) + energy)
if name == ' main ':

patterns = np.array([
[1, 1, -1, -1],
[-1, -1, 1, 1],
[1, -1, 1, -1],
[-1, 1, -1, 1]
])
n_neurons = patterns.shape[1]
network = HopfieldNetwork(n_neurons)
network.train(patterns)
for pattern in patterns:

prediction = network.predict(pattern)
print('Input pattern:', pattern)
print('Predicted pattern:', prediction)
Output:
Input pattern: [ 1 1 -1 -1]

Predicted pattern: [-1. -1. -1. -1.]
Input pattern: [-1 -1 1 1]
Input pattern: [ 1 -1 1 -1]
Input pattern: [-1 1 -1 1]
Assignment No. 10
Code:
import keras
from keras.datasets import cifar10
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import SGD
from keras.preprocessing.image import ImageDataGenerator
# Load CIFAR-10 dataset

(X_train, y_train), (X_test, y_test) = cifar10.load_data()
# Define the model

model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(10, activation='softmax'))
# Define data generators

train_datagen = ImageDataGenerator(rescale=1./255, shear_range=0.2, zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1./255)
# Prepare the data

train_set = train_datagen.flow(X_train, y_train, batch_size=32)
test_set = test_datagen.flow(X_test, y_test, batch_size=32)
# Compile the model

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
# Train the model

model.fit_generator(train_set, steps_per_epoch=len(X_train)//32, epochs=100,
validation_data=test_set, validation_steps=len(X_test)//32)
# Evaluate the model

score = model.evaluate(test_set, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
Output:
Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz

170498071/170498071 [==============================] - 3s 0us/step
Epoch 1/100
/usr/local/lib/python3.10/dist-packages/keras/optimizers/legacy/gradient_descent.py:114:
UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
super(). init (name, **kwargs)
<ipython-input-15-75bb0166727e>:40: UserWarning: `Model.fit_generator` is deprecated and
will be removed in a future version. Please use `Model.fit`, which supports generators.
model.fit_generator(train_set, steps_per_epoch=len(X_train)//32, epochs=100,
validation_data=test_set, validation_steps=len(X_test)//32)
1562/1562 [==============================] - 270s 172ms/step - loss: nan - accuracy:
0.9977 - val_loss: nan - val_accuracy: 1.0000
Epoch 2/100
Epoch 3/100
Epoch 4/100
Epoch 5/100
Epoch 6/100

Epoch 7/100
Epoch 8/100
Epoch 9/100
Epoch 10/100
Epoch 11/100
Epoch 12/100
Epoch 13/100
Epoch 14/100
Epoch 15/100
Epoch 16/100
Assignment No. 11
Code:
import tensorflow as tf
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_breast_cancer
df=load_breast_cancer()
X_train,X_test,y_train,y_test=train_test_split(df.data,df.target,test_size=0.20,random_state=42)
sc=StandardScaler()
X_train=sc.fit_transform(X_train)
X_test=sc.transform(X_test)
model=tf.keras.models.Sequential([tf.keras.layers.Dense(1,activation='sigmoid',input_shape=(X
_train.shape[1],))])
model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
model.fit(X_train,y_train,epochs=5)
y_pred=model.predict(X_test)
test_loss,test_accuracy=model.evaluate(X_test,y_test)
print("accuracy is",test_accuracy)
Output:
Epoch 1/5
15/15 [==============================] - 1s 2ms/step - loss: 0.5449 - accuracy: 0.7385
Epoch 2/5
Epoch 3/5
Epoch 4/5
Epoch 5/5
4/4 [==============================] - 0s 5ms/step
accuracy is 0.9298245906829834
Assignment No. 12
Code:
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.utils import to_categorical
(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation='relu'),
Flatten(),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=64, epochs=10, verbose=1)
loss, accuracy = model.evaluate(X_test, y_test)

print(f"Test Loss: {loss}")
print(f"Test Accuracy: {accuracy}")
Output:
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz

11490434/11490434 [==============================] - 0s 0us/step
Epoch 1/10
938/938 [==============================] - 59s 60ms/step - loss: 0.1783 - accuracy:
0.9448
Epoch 2/10
0.9835
Epoch 3/10
0.9878
Epoch 4/10
0.9908
Epoch 5/10
0.9926
Epoch 6/10
0.9936
Epoch 7/10
0.9950
Epoch 8/10
0.9957
Epoch 9/10
0.9961
Epoch 10/10
0.9971
0.9921
Test Loss: 0.028454650193452835
Test Accuracy: 0.9921000003814697
Assignment No. 13
Code:
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import Adam
# Load and preprocess the MNIST dataset

(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train / 255.0
X_test = X_test / 255.0
# Define the model architecture

model = Sequential([
Flatten(input_shape=(28, 28)),
Dense(128, activation='relu'),
Dense(10, activation='softmax')
])
# Compile the model

model.compile(optimizer=Adam(learning_rate=0.001),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Train the model

model.fit(X_train, y_train, batch_size=64, epochs=10, verbose=1)
# Evaluate the model

loss, accuracy = model.evaluate(X_test, y_test)
print(f"Test Loss: {loss}")
print(f"Test Accuracy: {accuracy}")
Output:
Epoch 1/10
0.9153
Epoch 2/10
0.9612
Epoch 3/10
0.9723
Epoch 4/10
0.9783
Epoch 5/10
0.9833
Epoch 6/10
0.9864
Epoch 7/10
0.9892
Epoch 8/10
0.9913
Epoch 9/10
0.9927
Epoch 10/10
0.9944
0.9804
Test Loss: 0.06786014884710312
Test Accuracy: 0.980400025844574
317533 Software Laboratory - II

Software Laboratory II Code

Uploaded by

Copyright:

Available Formats

Software Laboratory II Code

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Software Laboratory II Code

Uploaded by

Copyright:

Available Formats

Software Laboratory - II

# Create plots for each activation function

# Add common axis labels and titles

# Adjust spacing between subplots

# Show the plot

# function of checking thresold value

dot_products = input_table @ weights

# Define the perceptron class

def activation_fn(self, x):

def predict(self, x):

def train(self, X, Y, epochs):

# Define the input data and labels

# Create the perceptron and train it

# Test the perceptron on some input data

# load iris dataset

# extract sepal length and petal length features

# setosa is class 0, versicolor is class 1

# initialize weights and bias

# set learning rate and number of epochs

# define perceptron function

# train the perceptron

# plot decision boundary

# plot data points

# define two pairs of vectors

# compute weight matrix W

# define BAM function

# test BAM with inputs

def init (self, input_size, hidden_size, output_size):

def sigmoid(self, x):

def sigmoid_derivative(self, x):

def forward_propagation(self, X):

def backward_propagation(self, X, y, y_hat):

def train(self, X, y, epochs, learning_rate):

# Define the input and output datasets

# Print the predictions

def sigmoid(self, x):

def sigmoid_derivative(self, x):

def forward(self, X):

def backward(self, X, y, output):

def train(self, X, y, epochs):

def predict(self, X):

# Create a new XORNetwork instance

# Define the input and output datasets for XOR

# Train the network for 10000 epochs

# Make predictions on the input dataset

# Print the predictions

# Define sigmoid activation function

# Define derivative of sigmoid function

# Define input dataset

# Define output dataset

# Initialize weights randomly with mean 0

# Train the neural network

hidden_delta = hidden_error * sigmoid_derivative(hidden_layer)

output_weights += hidden_layer.T.dot(output_delta) * learning_rate

# Display input and output

def train(self, patterns):

def predict(self, pattern):

if name == ' main ':