Lab 1: Write a program to implement K-Nearest Neighbour algorithm to classify the iris data
set. Print both correct and wrong predictions.
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn import datasets
iris=datasets.load_iris()
print("Iris Data set loaded...")
x_train, x_test, y_train, y_test = train_test_split(iris.data,iris.target,test_size=0.1)
#random_state=0
for i in range(len(iris.target_names)):
print("Label", i , "-",str(iris.target_names[i]))
classifier = KNeighborsClassifier(n_neighbors=2)
classifier.fit(x_train, y_train)
y_pred=classifier.predict(x_test)
print("Results of Classification using K-nn with K=1 ")
for r in range(0,len(x_test)):
print(" Sample:", str(x_test[r]), " Actual-label:", str(y_test[r])," Predicted-label:", str(y_pred[r]))
print("Classification Accuracy :" , classifier.score(x_test,y_test));
OUTPUT:
Iris Data set loaded...
Label 0 - setosa
Label 1 - versicolor
Label 2 - virginica
Results of Classification using K-nn with K=1
Sample: [5. 3.6 1.4 0.2] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [4.5 2.3 1.3 0.3] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [5.1 3.5 1.4 0.3] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [6.1 2.6 5.6 1.4] Actual-label: 2 Predicted-label: 1
Classification Accuracy : 0.9333333333333333
Sample: [4.4 2.9 1.4 0.2] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [5.2 3.5 1.5 0.2] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [6.2 3.4 5.4 2.3] Actual-label: 2 Predicted-label: 2
Classification Accuracy : 0.9333333333333333
Sample: [4.8 3.4 1.9 0.2] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [6.9 3.1 5.4 2.1] Actual-label: 2 Predicted-label: 2
Classification Accuracy : 0.9333333333333333
Sample: [5.6 3. 4.1 1.3] Actual-label: 1 Predicted-label: 1
Classification Accuracy : 0.9333333333333333
Sample: [4.7 3.2 1.6 0.2] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [6.3 2.3 4.4 1.3] Actual-label: 1 Predicted-label: 1
Classification Accuracy : 0.9333333333333333
Sample: [5.1 3.4 1.5 0.2] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Sample: [6. 2.9 4.5 1.5] Actual-label: 1 Predicted-label: 1
Classification Accuracy : 0.9333333333333333
Sample: [5.4 3.9 1.3 0.4] Actual-label: 0 Predicted-label: 0
Classification Accuracy : 0.9333333333333333
Lab. 2 Develop a program to apply K-means algorithm to cluster a set of data stored in .CSV
file. Use the same data set for clustering using EM algorithm. Compare the results of these
two algorithms and comment on the quality of clustering. import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
# Load data from CSV
data = pd.read_csv("C:\\Users\\Ravi\\Downloads\\iris.csv")
# Select features for clustering
features = data[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
# Apply K-means clustering
kmeans = KMeans(n_clusters=3) # Adjust the number of clusters as needed
kmeans_labels = kmeans.fit_predict(features)
# Apply EM algorithm (Gaussian Mixture Model)
em = GaussianMixture(n_components=3) # Adjust the number of clusters as needed
em_labels = em.fit_predict(features)
# Visualize clustering results
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.scatter(data['SepalLengthCm'], data['SepalWidthCm'], c=kmeans_labels, cmap='viridis',
edgecolor='k')
plt.title('K-means Clustering')
plt.xlabel('Sepal Length (cm)')
plt.ylabel('Sepal Width (cm)')
plt.colorbar()
plt.subplot(1, 2, 2)
plt.scatter(data['SepalLengthCm'], data['SepalWidthCm'], c=em_labels, cmap='viridis', edgecolor='k')
plt.title('EM Clustering')
plt.xlabel('Sepal Length (cm)')
plt.ylabel('Sepal Width (cm)')
plt.colorbar()
plt.tight_layout()
plt.show()
# Comment on the quality of clustering
# Calculate inertia (for K-means) as an indicator of clustering quality
kmeans_inertia = kmeans.inertia_
print(f"K-means inertia: {kmeans_inertia}")
OUTPUT:
K-means inertia: 78.94084142614602
Lab.3 Implement the non-parametric Locally Weighted Regression algorithm in order to fit
data points. Select appropriate data set for your experiment and draw graphs.
import numpy as np
import matplotlib.pyplot as plt
def local_regression(x0, X, Y, tau):
x0 = [1, x0]
X = [[1, i] for i in X]
X = np.asarray(X)
xw = (X.T) * np.exp(np.sum((X - x0) ** 2, axis=1) / (-2 * tau))
beta = np.linalg.pinv(xw @ X) @ xw @ Y @ x0
return beta
def draw(tau):
prediction = [local_regression(x0, X, Y, tau) for x0 in domain]
plt.plot(X, Y, 'o', color='black')
plt.plot(domain, prediction, color='red')
plt.show()
X = np.linspace(-3, 3, num=1000)
domain = X
Y = np.log(np.abs(X ** 2 - 1) + .5)
draw(10)
draw(0.1)
draw(0.01)
draw(0.001)
OUTPUT:
Lab 4 : Build an Artificial Neural Network by implementing the Backpropagation algorithm
and test the same using appropriate data sets.
import numpy as np
X = np.array(([2, 9], [1, 5], [3, 6]), dtype=float)
y = np.array(([92], [86], [89]), dtype=float)
X = X/np.amax(X,axis=0) # maximum of X array longitudinally
y = y/100
#Sigmoid Function
def sigmoid (x):
return 1/(1 + np.exp(-x))
#Derivative of Sigmoid Function
def derivatives_sigmoid(x):
return x * (1 - x)
#Variable initialization
epoch=5000 #Setting training iterations
lr=0.1 #Setting learning rate
inputlayer_neurons = 2 #number of features in data set
hiddenlayer_neurons = 3 #number of hidden layers neurons
output_neurons = 1 #number of neurons at output layer
#weight and bias initialization
wh=np.random.uniform(size=(inputlayer_neurons,hiddenlayer_neurons))
bh=np.random.uniform(size=(1,hiddenlayer_neurons))
wout=np.random.uniform(size=(hiddenlayer_neurons,output_neurons))
bout=np.random.uniform(size=(1,output_neurons))
#draws a random range of numbers uniformly of dim x*y
for i in range(epoch):
#Forward Propogation
hinp1=np.dot(X,wh)
hinp=hinp1 + bh
hlayer_act = sigmoid(hinp)
outinp1=np.dot(hlayer_act,wout)
outinp= outinp1+ bout
output = sigmoid(outinp)
#Backpropagation
EO = y-output
outgrad = derivatives_sigmoid(output)
d_output = EO* outgrad
EH = d_output.dot(wout.T)
#how much hidden layer wts contributed to error
hiddengrad = derivatives_sigmoid(hlayer_act)
d_hiddenlayer = EH * hiddengrad
# dotproduct of nextlayererror and currentlayerop
wout += hlayer_act.T.dot(d_output) *lr
wh += X.T.dot(d_hiddenlayer) *lr
print("Input: \n" + str(X))
print("Actual Output: \n" + str(y))
print("Predicted Output: \n" ,output)
OUTPUT:
Input:
[[0.66666667 1. ]
[0.33333333 0.55555556]
[1. 0.66666667]]
Actual Output:
[[0.92]
[0.86]
[0.89]]
Predicted Output:
[[0.89571283]
[0.88239245]
[0.89153673]]
Lab .5 Demonstrate Genetic algorithm by taking a suitable data for any simple application
import random
import numpy as np
import matplotlib.pyplot as plt
from deap import base, creator, tools, algorithms # Add 'algorithms' import here
# Create city coordinates (for demonstration purposes, generate random coordinates)
num_cities = 10
city_coords = np.array([[random.random(), random.random()] for _ in range(num_cities)])
# Define the evaluation function for the TSP
def tsp_distance(individual):
distance = 0
for i in range(len(individual)):
city_start = individual[i]
city_end = individual[(i + 1) % len(individual)]
distance += np.linalg.norm(city_coords[city_start] - city_coords[city_end])
return distance,
# Genetic Algorithm parameters
population_size = 100
num_generations = 50
mutation_rate = 0.1
crossover_rate = 0.8
# Create a fitness class maximizing 1 / distance
creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("indices", random.sample, range(num_cities), num_cities)
toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.indices)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", tsp_distance)
toolbox.register("mate", tools.cxOrdered)
toolbox.register("mutate", tools.mutShuffleIndexes, indpb=mutation_rate)
toolbox.register("select", tools.selTournament, tournsize=3)
population = toolbox.population(n=population_size)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("min", np.min)
stats.register("avg", np.mean)
best = tools.HallOfFame(1)
# Perform the evolution using DEAP's algorithms
population, logbook = algorithms.eaSimple(population, toolbox, cxpb=crossover_rate,
mutpb=mutation_rate,
ngen=num_generations, stats=stats, halloffame=best, verbose=True)
best_route = best[0]
best_distance = tsp_distance(best_route)[0]
print("Best Route:", best_route)
print("Best Distance:", best_distance)
# Plotting the best route
plt.figure(figsize=(6, 6))
plt.scatter(city_coords[:, 0], city_coords[:, 1], c='red', label='Cities')
best_route_coords = city_coords[best_route]
plt.plot(best_route_coords[:, 0], best_route_coords[:, 1], linestyle='-', marker='o', color='blue')
plt.title('Best Route for TSP')
plt.xlabel('X-coordinate')
plt.ylabel('Y-coordinate')
plt.legend()
plt.show()
OUTPUT:
gen nevals min avg
0 100 3.81172 5.17113
1 80 3.76127 4.83071
2 79 3.47536 4.61412
3 73 3.51989 4.28437
4 86 3.02821 4.26991
5 77 3.02821 4.04814
6 82 3.02821 4.00813
7 79 3.02821 3.90292
8 81 3.02821 3.62867
9 88 3.02413 3.54711
10 89 3.02413 3.34065
11 89 2.98027 3.29947
12 81 2.98027 3.32863
13 70 2.98027 3.23967
14 84 2.98027 3.22032
15 89 2.94328 3.20574
16 80 2.94328 3.13206
17 86 2.94328 3.23517
18 86 2.94328 3.12063
19 84 2.94328 3.04038
20 89 2.94328 2.9881
21 86 2.94328 3.10516
22 88 2.94328 2.99199
23 81 2.94328 3.00683
24 89 2.94328 3.02777
25 83 2.94328 3.07333
26 82 2.94328 2.98078
27 80 2.94328 3.018
28 77 2.94328 3.01378
29 77 2.94328 2.9868
30 83 2.94328 3.03777
31 83 2.94328 2.96961
32 79 2.94328 2.99216
33 86 2.94328 3.04676
34 82 2.94328 2.9895
35 75 2.94328 3.01428
36 94 2.94328 3.06898
37 83 2.94328 3.06695
38 78 2.94328 2.99384
39 80 2.94328 3.03937
40 82 2.94328 2.99927
41 81 2.94328 3.09511
42 79 2.94328 3.01924
43 85 2.94328 3.07283
44 72 2.94328 2.97081
45 95 2.94328 3.01278
46 76 2.94328 3.01039
47 75 2.94328 3.0094
48 79 2.94328 2.97696
49 82 2.94328 3.01004
50 86 2.94328 3.02898
Best Route: [5, 9, 6, 1, 3, 2, 8, 0, 4, 7]
Best Distance: 2.94328198065275
Lab.6 Demonstrate Q learning algorithm with suitable assumption for a problem statement
# Importing Required Libraries
import numpy as np
import random
# Setting up the Environment
# Defining the Reward Matrix
R = np.array([[-1, -1, -1, -1, 0, -1],
[-1, -1, -1, 0, -1, 100],
[-1, -1, -1, 0, -1, -1],
[-1, 0, 0, -1, 0, -1],
[0, -1, -1, 0, -1, 100],
[-1, 0, -1, -1, 0, 100]])
# Defining the Q-Table
Q = np.zeros_like(R)
# Defining the Hyperparameters
gamma = 0.8
alpha = 0.1
epsilon = 0.1
# Training the Agent
for episode in range(1000):
state = random.randint(0, 5)
while state != 5:
if random.uniform(0, 1) < epsilon:
action = random.randint(0, 5)
else:
action = np.argmax(Q[state])
next_state = action
reward = R[state, action]
Q[state, action] = Q[state, action] + alpha * (reward + gamma * np.max(Q[next_state]) - Q[state,
action])
state = next_state
# Testing the Agent
state = 2
steps = [state]
while state != 5:
action = np.argmax(Q[state])
state = action
steps.append(state)
# Printing the Optimal Path
print("Optimal Path: ", steps)
OUTPUT:
Optimal Path: [2, 0, 1, 5]
