INDEX

PAGE MARK SIGNA

S.NO. DATE PROGRAM NAME
NO. S TURE

1. UNIFORMED SEARCH ALGORITHMS

2. INFORMED SEARCH ALGORITHMS

3. NAÏVE BAYES MODEL

4. BAYESIAN NETWORK

5. REGRESSION MODELS

DECISION TREES AND RANDOM

6.
FORESTS

7. SVM MODEL

8. ENSEMBLE TECHNIQUES

9. CLUSTERING ALGORITHMS

10. EM FOR BAYESIAN NETWORK

11. NEURAL NETWORK MODEL

DEEP LEARNING NEURAL NETWORK

12.
MODEL
 KIT & KIM TECHNICAL CAMPUS

EX.NO:1
UNIFORMED SEARCH ALGORITHMS
DATE:

AIM:

To implement uniformed search algorithms (BFS, DFS).

1. Implement Breadth First Search (BFS)

ALGORITHM:

1. Create a graph
2. Initialize a starting node
3. Send the graph and initial node as parameters to the bfs function.
4. Mark the initial node as visited and push it into the queue
5. Explore the initial node and add its neighbours to the queue and remove the initial
node from the queue
6. Check if the neighbour node of a neighbouring node is already visited
7. If not, visit the neighbouring node neighbours and mark them as visited
8. Repeat this process until all the nodes in a graph are visited and the queue becomes
empty

PROGRAM:

graph = {
'A' : ['B','C'],
'B' : ['D', 'E'],
'C' : ['F'],
'D' : [],
'E' : ['F'],
'F' : []
}
visited = []
queue = []
def bfs(visited, graph, node):
visited.append(node)
queue.append(node)
while queue:
s = queue.pop(0)
print (s, end = " ")
for neighbour in graph[s]:
if neighbour not in visited:
visited.append(neighbour)
queue.append(neighbour)
bfs(visited, graph, 'A')

2022-2023
 KIT & KIM TECHNICAL CAMPUS

OUTPUT:

2. Implement Depth First Search (DFS)

ALGORITHM:

1. Start by putting any one of the graph's vertices on top of a stack

2. Take the top item of the stack and add it to the visited list
3. Create a list of that vertex's adjacent nodes. Add the ones which aren't in the visited
list to the top of the stack
4. Keep repeating steps 2 and 3 until the stack is empty

PROGRAM:

def recursive_dfs(graph, source,path = []):

if source not in path:
path.append(source)
if source not in graph:
return path
for neighbour in graph[source]:
path = recursive_dfs(graph, neighbour, path)
return path
graph = {"A":["B","C", "D"],
"B":["E"],
"C":["F","G"],
"D":["H"],
"E":["I"],
"F":["J"]}
path = recursive_dfs(graph, "A")
print(" ".join(path))

OUTPUT:

RESULT:

Thus the above programs are executed and the outputs are verified.

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:2
INFORMED SEARCH ALGORITHMS
DATE:

AIM:

To implement informed search algorithms (A*, memory-bounded A*).

1. Implement A* algorithm

ALGORITHM:

1. Firstly, Place the starting node into OPEN and find its f (n) value
2. Then remove the node from OPEN, having the smallest f (n) value. If it is a goal
node, then stop and return to success
3. Else remove the node from OPEN, and find all its successors
4. Find the f (n) value of all the successors, place them into OPEN, and place the
removed node into CLOSE
5. Goto Step-2
6. Exit

PROGRAM:

from collections import deque

class Graph:

def __init__(self, adjacency_list):

self.adjacency_list = adjacency_list

def get_neighbors(self, v):

return self.adjacency_list[v]

def h(self, n):

H={
'A': 1,
'B': 1,
'C': 1,
'D': 1
}

return H[n]

def a_star_algorithm(self, start_node, stop_node):

open_list = set([start_node])

2022-2023
 KIT & KIM TECHNICAL CAMPUS

closed_list = set([])
g = {}

g[start_node] = 0
parents = {}
parents[start_node] = start_node

while len(open_list) > 0:

n = None
for v in open_list:
if n == None or g[v] + self.h(v) < g[n] + self.h(n):
n = v;

if n == None:
print('Path does not exist!')
return None
if n == stop_node:
reconst_path = []

while parents[n] != n:
reconst_path.append(n)
n = parents[n]

reconst_path.append(start_node)
reconst_path.reverse()
print('Path found: {}'.format(reconst_path))
return reconst_path

for (m, weight) in self.get_neighbors(n)

if m not in open_list and m not in closed_list:
open_list.add(m)
parents[m] = n
g[m] = g[n] + weight

else:
if g[m] > g[n] + weight:
g[m] = g[n] + weight
parents[m] = n

if m in closed_list:
closed_list.remove(m)
open_list.add(m)
open_list.remove(n)
closed_list.add(n)

2022-2023
 KIT & KIM TECHNICAL CAMPUS

print('Path does not exist!')

return None

adjacency_list = {
'A': [('B', 1), ('C', 3), ('D', 7)],
'B': [('D', 5)],
'C': [('D', 12)]
}
graph1 = Graph(adjacency_list)
graph1.a_star_algorithm('A', 'D')

OUTPUT:

2. Implement memory-bounded A* algorithm

ALGORITHM:
1. Initialize the CLOSE AND OPEN list
2. Initialize the starting node
3. Find the path with the lowest weight
4. Add previous weight and the current heuristics and weight of the node
5. Find the shortest path with weight for the goal node
6. Exit

PROGRAM:

nodes = {
'A': [['B', 6], ['F', 3]],
'B': [['A', 6], ['C', 3], ['D', 2]],
'C': [['B', 3], ['D', 1], ['E', 5]],
'D': [['B', 2], ['C', 1], ['E', 8]],
'E': [['C', 5], ['D', 8], ['I', 5], ['J', 5]],
'F': [['A', 3], ['G', 1], ['H', 7]],
'G': [['F', 1], ['I', 3]],
'H': [['F', 7], ['I', 2]],
'I': [['G', 3], ['H', 2], ['E', 5], ['J', 3]],
'J': [['E', 5], ['I', 3]]
}
h={
'A' : 10,

2022-2023
 KIT & KIM TECHNICAL CAMPUS

'B' : 8,
'C' : 5,
'D' : 7,
'E' : 3,
'F' : 6,
'G' : 5,
'H' : 3,
'I' : 1,
'J' : 0
}

def astar(start, goal):

opened = []
closed = []
visited = set()
opened.append([start, h[start]])
while opened :
min = 1000
val = ''
for i in opened:
if i[1] < min:
min = i[1]
val = i[0]
closed.append(val)
visited.add(val)
if goal not in closed:
for i in nodes[val]:
if i[0] not in visited:
opened.append([i[0], (min-h[val]+i[1]+h[i[0]])])
else:
break
opened.remove([val, min])

closed = closed[::-1]
min = 1000
for i in opened:
if i[1] < min:
min = i[1]

lens = len(closed)
i=0
while i < lens-1:
nei = []
for j in nodes[closed[i]]:

2022-2023
 KIT & KIM TECHNICAL CAMPUS

nei.append(j[0])
if closed[i+1] not in nei:
del closed[i+1]
lens-=1
i+=1
closed = closed[::-1]
return closed, min

print(astar('A', 'J'))

OUTPUT:

RESULT:

Thus the above programs are executed and the outputs are verified.

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:3
NAÏVE BAYES MODEL
DATE:

AIM:

To implement Gaussian naïve Bayes model

ALGORITHM:

1. Import necessary libraries and packages

2. Load the dataset
3. Split the dataset into train data and test data
4. Load the Gaussian naïve Bayes algorithm
5. Train the algorithm with train data
6. Test the accuracy of the algorithm

PROGRAM:

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn import metrics
iris = load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred = gnb.predict(X_test)
print("Gaussian Naive Bayes model accuracy(in %):", metrics.accuracy_score(y_test, y_pred)
*100)

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:4
BAYESIAN NETWORK
DATE:

AIM:

To implement Bayesian Network.

ALGORITHM:
1. Import necessary packages and modules.
2. Load the Bayesian model
3. Draw the conditional probability table for each node in the Bayesian network
4. Draw the conditional probability table for posterior probability of burglary if john
calls and marry calls and alarm if the burglary happens and earthquake happens

PROGRAM:

import pgmpy.models
import pgmpy.inference
import networkx as nx
import pylab as plt
model = pgmpy.models.BayesianModel([('Burglary', 'Alarm'),
('Earthquake', 'Alarm'),
('Alarm', 'JohnCalls'),
('Alarm', 'MaryCalls')])
cpd_burglary = pgmpy.factors.discrete.TabularCPD('Burglary', 2, [[0.001], [0.999]])
cpd_earthquake = pgmpy.factors.discrete.TabularCPD('Earthquake', 2, [[0.002], [0.998]])
cpd_alarm = pgmpy.factors.discrete.TabularCPD('Alarm', 2, [[0.95, 0.94, 0.29, 0.001],
[0.05, 0.06, 0.71, 0.999]],
evidence=['Burglary', 'Earthquake'],
evidence_card=[2, 2])
cpd_john = pgmpy.factors.discrete.TabularCPD('JohnCalls', 2, [[0.90, 0.05],
[0.10, 0.95]],
evidence=['Alarm'],
evidence_card=[2])
cpd_mary = pgmpy.factors.discrete.TabularCPD('MaryCalls', 2, [[0.70, 0.01],
[0.30, 0.99]],
evidence=['Alarm'],
evidence_card=[2])
model.add_cpds(cpd_burglary, cpd_earthquake, cpd_alarm, cpd_john, cpd_mary)
model.check_model()

print('Probability distribution, P(Burglary)')

print(cpd_burglary)

2022-2023
 KIT & KIM TECHNICAL CAMPUS

print('Probability distribution, P(Earthquake)')

print(cpd_earthquake)

print('Joint probability distribution, P(Alarm | Burglary, Earthquake)')

print(cpd_alarm)

print('Joint probability distribution, P(JohnCalls | Alarm)')

print(cpd_john)

print('Joint probability distribution, P(MaryCalls | Alarm)')

print(cpd_mary)
infer = pgmpy.inference.VariableElimination(model)
posterior_probability = infer.query(['Burglary'], evidence={'JohnCalls': 0, 'MaryCalls': 0})
print('Posterior probability of Burglary if JohnCalls(True) and MaryCalls(True)')
print(posterior_probability)

posterior_probability = infer.query(['Alarm'], evidence={'Burglary': 0, 'Earthquake': 0})

print('Posterior probability of Alarm sounding if Burglary(True) and Earthquake(True)')
print(posterior_probability)

10

2022-2023
 KIT & KIM TECHNICAL CAMPUS

OUTPUT:

RESULT:

Thus the above programs are executed and the output are verified.

11

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:5
REGRESSION MODELS
DATE:

AIM:

To build regression models.

ALGORITHM:

1. Import the necessary packages and modules

2. Create the arrays that represent the values of the x and y axis
3. Create a function that uses the slope and intercept values to return a new value. This
new value represents where on the y-axis the corresponding x value will be placed
4. Run each value of the x array through the function. This will result in a new array
with new values for the y-axis
5. Draw the original scatter plot
6. Draw the line of linear regression
7. Display the diagram

PROGRAM:

import matplotlib.pyplot as plt

from scipy import stats
x = [5,7,8,7,2,17,2,9,4,11,12,9,6]
y = [99,86,87,88,111,86,103,87,94,78,77,85,86]
slope, intercept, r, p, std_err = stats.linregress(x, y)
def myfunc(x):
return slope * x + intercept

mymodel = list(map(myfunc, x))

print(mymodel)
plt.scatter(x, y)
plt.plot(x,mymodel)
plt.show()

12

2022-2023
 KIT & KIM TECHNICAL CAMPUS

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

13

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:6
DECISION TREES AND RANDOM FORESTS
DATE:

AIM:

To build decision trees and random forests

1. Build decision tree

ALGORITHM:

1. Import necessary packages and libraries

2. Load the dataset
3. Load the algorithm decision tree and train the algorithm using the dataset
4. Predict the category of new data
5. Print the graph for the decision tree.

PROGRAM:

from sklearn.datasets import load_iris

from sklearn import tree
import graphviz
iris = load_iris()
X, y = iris.data, iris.target
targets = iris.target_names
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X, y)
X_pred = [6.7, 3.0, 5.2, 2.3]
y_pred = clf.predict([X_pred])
print("Prediction is: {}".format(targets[y_pred]))
dot_data = tree.export_graphviz(clf, out_file=None,feature_names=iris.feature_names,
class_names=iris.target_names,
filled=True, rounded=True,
special_characters=True)
graph = graphviz.Source(dot_data)
graph

14

2022-2023
 KIT & KIM TECHNICAL CAMPUS

OUTPUT:

2. Build random forest

ALGORITHM:

1. Import necessary packages and libraries

2. Load the dataset
3. Load the algorithm Random Forest and train the algorithm using the dataset
4. Predict the category of new data

PROGRAM:

from sklearn.ensemble import RandomForestClassifier

from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target
targets = iris.target_names
clf = RandomForestClassifier(random_state = 100)
clf = clf.fit(X, y)
X_pred = [6.7, 3.0, 5.2, 2.3]
y_pred = clf.predict([X_pred])
print("Prediction is: {}".format(targets[y_pred]))

OUTPUT:

RESULT:

Thus the above programs are executed and the outputs are verified.

15

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:7
SVM MODEL
DATE:

AIM:

To build SVM (Support Vector Machine) models

ALGORITHM:

1. Import necessary packages and libraries

2. Load the dataset
3. Load the algorithm Support Vector Machine and train the algorithm using the dataset
4. Predict the category of new data

PROGRAM:

from sklearn.datasets import load_iris

from sklearn.svm import SVC
iris=load_iris()
X_train = iris.data
y_train = iris.target
targets = iris.target_names
print(targets)
cls = SVC()
cls.fit(X_train, y_train)
X_pred = [5.1, 3.2, 1.5, 0.5]
y_pred = cls.predict([X_pred])
print("Prediction is: {}".format(targets[y_pred]))

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

16

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:8
ENSEMBLE TECHNIQUES
DATE:

AIM:

To implement Max voting ensemble technique.

ALGORITHM:

1. Import the necessary modules and packages

2. Load the dataset
3. Load the models(SVM, Random Forest, Decision tree)
4. Combine the models and train them using dataset
5. Predict the category of the new data point.

PROGRAM:

from sklearn.datasets import load_iris

from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn import tree
from sklearn.ensemble import VotingClassifier
iris=load_iris()
X_train = iris.data
y_train = iris.target
targets = iris.target_names
print(targets)
m1 = tree.DecisionTreeClassifier()
m2 = RandomForestClassifier(random_state = 100)
m3 = SVC()
final_model=VotingClassifier(estimators=[('dt',m1),('rf',m2),('svc',m3)],voting='hard')
final_model.fit(X_train, y_train)
X_pred = [6.7, 3.0, 5.2, 2.3]
y_pred = final_model.predict([X_pred])
print("Prediction is: {}".format(targets[y_pred]))

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

17

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:9
CLUSTERING ALGORITHMS
DATE:

AIM:

To implement K-Nearest Neighbor clustering algorithm.

ALGORITHM:

1. Import necessary packages and libraries

2. Load the dataset
3. Load the algorithm k-Nearest Neighbor and train the algorithm using the dataset
4. Predict the category of new data

PROGRAM:

from sklearn.datasets import load_iris

from sklearn.neighbors import KNeighborsClassifier
iris=load_iris()
X_train = iris.data
y_train = iris.target
targets = iris.target_names
print(targets)
cls = KNeighborsClassifier(n_neighbors=5)
cls.fit(X_train, y_train)
X_pred = [6.7, 3.0, 5.2, 2.3]
y_pred = cls.predict([X_pred])
print("The Prediction is")
print("".join(targets[y_pred]))

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

18

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:10
EM FOR BAYESIAN NETWORK
DATE:

AIM:

To implement EM for Bayesian networks.

ALGORITHM:

1. Import necessary libraries and packages

2. Define the bayesian network
3. Generate the true probability distributions P for each node
4. Randomly initialize the estimated probability distributions P^ for each node
5. Perform the E-step and M-step for 32 epochs
6. Plot the log likelihood for each epoch

PROGRAM:

import numpy as np
import time
graphNodes = ["a", "b", "c", "d", "e", "f", "g", "h"]

graphNodeIndices = {}
for idx, node in enumerate(graphNodes):
graphNodeIndices[node] = idx

graphNodeNumStates = {
"a": 3,
"b": 4,
"c": 5,
"d": 4,
"e": 3,
"f": 4,
"g": 5,
"h": 4
}

nodesToUpdate = ["a", "b", "c", "d", "e", "f", "g", "h"]

nodeParents = {
"a": [],
"b": [],
"c": ["a"],
"d": ["a", "b"],

19

2022-2023
 KIT & KIM TECHNICAL CAMPUS

"e": ["a", "c"],

"f": ["b", "d"],
"g": ["e"],
"h": ["f"]
}

tensorNodeOrder = {}
for node in graphNodes:
tensorNodeOrder[node] = [node] + nodeParents[node]
def randomTensorGenerator(shape):
return np.random.uniform(0.0, 1.0, shape)

def conditionNodeOnParents(probTensor, node, tensorNodeOrder):

assert(node in tensorNodeOrder)
inferredDimension = tensorNodeOrder.index(node)
probTensor = probTensor / np.expand_dims(np.sum(probTensor, inferredDimension), infe
rredDimension)
return probTensor

np.random.seed(0)
p = {}
for node in graphNodes:
tensorDimensions = [graphNodeNumStates[x] for x in tensorNodeOrder[node]]
p[node] = randomTensorGenerator(tensorDimensions)

for node in p:
p[node] = conditionNodeOnParents(p[node], tensorNodeOrder[node][0], tensorNodeOrder
[node])
print("p(" + node + "|" + str(nodeParents[node]) + ") dimensions: " + str(p[node].shape))
np.random.seed(int(time.time()))

phat = {}

for node in p:
phat[node] = randomTensorGenerator(p[node].shape)
phat[node] = conditionNodeOnParents(phat[node], tensorNodeOrder[node][0], tensorNode
Order[node])
print("phat(" + node + "|" + str(nodeParents[node]) + ") dimensions: " + str(phat[node].sha
pe))

20

2022-2023
 KIT & KIM TECHNICAL CAMPUS

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

21

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:11
NEURAL NETWORK MODEL
DATE:

AIM:

To build simple Neural network (NN) models.

ALGORITHM:

1. Import the necessary packages and libraries

2. Use numpy arrays to store inputs x and output y
3. Define the network model and its arguments.
4. Set the number of neurons/nodes for each layer
5. Compile the model and calculate its accuracy
6. Print the summary of the model

PROGRAM:

from keras.models import Sequential

from keras.layers import Dense, Activation
import numpy as np
x = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])
model = Sequential()
model.add(Dense(2, input_shape=(2,)))
model.add(Activation('sigmoid'))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='mean_squared_error', optimizer='sgd', metrics=['accuracy'])
model.summary()

22

2022-2023
 KIT & KIM TECHNICAL CAMPUS

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

23

2022-2023
 KIT & KIM TECHNICAL CAMPUS

EX.NO:12
DEEP LEARNING NEURAL NETWORK MODEL
DATE:

AIM:

To build deep learning NN (Neural Network) models.

ALGORITHM:

1. Load the dataset

2. Split the dataset into input x and output y
3. Define the keras model
4. Compile the keras model
5. Train the keras model with the dataset
6. Make predictions using the model

PROGRAM:

from numpy import loadtxt

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
dataset = loadtxt('https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-
diabetes.data.csv', delimiter=',')
X = dataset[:,0:8]
y = dataset[:,8]
model = Sequential()
model.add(Dense(12, input_shape=(8,), activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, epochs=150, batch_size=10, verbose=0)
predictions = (model.predict(X) > 0.5).astype(int)
for i in range(5):
print('%s => %d (expected %d)' % (X[i].tolist(), predictions[i], y[i]))

OUTPUT:

RESULT:

Thus the above program is executed and the output is verified.

24

2022-2023