SUSEC 1916810

SUS ENGINEERING COLLEGE

AI LAB FILE
SIXTH SEMESTER

SUBMITTED TO:- SUBMITTED BY:

ER. Deepinder Kaur NAME:- Anand Kumar
COURSE: - B. Tech 6th Sem(CSE) Roll no: 1916810
Subject Code: BTCS602-18

PAGE N0. 1
SUSEC 1916810

INDEX
S.NO EXPERIMENTS DATE OF SUB.

1.

2.

3.

4.

5.

6.

7.

PAGE N0. 2
SUSEC 1916810

ARTIFICIAL INTELLIGENCE LAB MANNUAL

EXPERIMENT :- 1

Introduction to Artificial Intelligence

“The science and engineering of making intelligent machines, especially

intelligent computer programs”. -John McCarthy-

Artificial Intelligence is an approach to make a computer, a robot, or a

product to think how smart human think. AI is a study of how human brain
think, learn, decide and work, when it tries to solve problems. And finally
this study outputs intelligent software systems. The aim of AI is to improve
computer functions which are related to human knowledge, for example,
reasoning, learning, and problem-solving.

The intelligence is intangible. It is composed of

 Reasoning

 Learning

 Problem Solving

 Perception

 Linguistic Intelligence

PAGE N0. 3
SUSEC 1916810

The objectives of AI research are reasoning, knowledge representation,

planning, learning, natural language processing, realization, and ability to
move and manipulate objects. There are long-term goals in the general
intelligence sector.

Applications of AI

· Gaming − AI plays important role for machine to think of large number of

possible positions based on deep knowledge in strategic games. for
example, chess,river crossing, N-queens problems and etc.

· Natural Language Processing − Interact with the computer that

understands natural language spoken by humans.

· Expert Systems − Machine or software provide explanation and advice to

the users.

· Vision Systems − Systems understand, explain, and describe visual input

on the computer.

· Speech Recognition − There are some AI based speech recognition

systems have ability to hear and express as sentences and understand
their meanings while a person talks to it. For example Siri and Google
assistant.

PAGE N0. 4
SUSEC 1916810

· Handwriting Recognition − The handwriting recognition software reads the

text written on paper and recognize the shapes of the letters and convert it
into editable text.

· Intelligent Robots − Robots are able to perform the instructions given by a

human.

Major Goals

 Knowledge reasoning

 Planning

 Machine Learning

 Natural Language Processing

 Computer Vision

Robotics

EXPERIMENT :- 2

Introduction of Facts and Rules

PAGE N0. 5
SUSEC 1916810

Facts:-
A fact s a predicate expression that makes a declarative statement about the problem domain. Whenever
a variable occurs in a Prolog expression, it is assumed to be universally quantified. Note that all Prolog
sentences must end with a period.
likes(john, susie). /* John likes Susie */
likes(X, susie). /* Everyone likes Susie */
likes(john, Y). /* John likes everybody */
likes(john, Y), likes(Y, john). /* John likes everybody and everybody likes John */
likes(john, susie); likes(john,mary). /* John likes Susie or John likes Mary */
not(likes(john,pizza)). /* John does not like pizza */
likes(john,susie) :- likes(john,mary)./* John likes Susie if John likes Mary.

Rules:-
A rule is a predicate expression that uses logical implication (:-) to describe a relationship among facts.
Thus a Prolog rule takes the form
left_hand_side :- right_hand_side .

This sentence is interpreted as: eft_hand_side fright_hand_side. The left_hand_side is restricted to a

single, positive, literal, which means it must consist of a positive atomic expression. It cannot be
negated and it cannot contain logical connectives.

This notation is known as a Horn clause. In Horn clause logic, the left hand side of the clause is the
conclusion, and must be a single positive literal. The right hand side contains the premises. The Horn
clause calculus is equivalent to the first-order predicate calculus.

Examples of valid rules:

friends(X,Y) :- likes(X,Y),likes(Y,X). /* X and Y are friends if they like each other */

hates(X,Y) :- not(likes(X,Y)). /* X hates Y if X does not like Y. */
enemies(X,Y) :- not(likes(X,Y)),not(likes(Y,X)). /* X and Y are enemies if they don't like each other */

Examples of invalid rules:

left_of(X,Y) :- right_of(Y,X) /* Missing a period */

likes(X,Y),likes(Y,X) :- friends(X,Y). /* LHS is not a single literal */
not(likes(X,Y)) :- hates(X,Y). /* LHS cannot be negated */

ashish is a boy.

PAGE N0. 6
SUSEC 1916810

Ashish and ashmani are brother.

PAGE N0. 7
SUSEC 1916810

EXPERIMENT :- 3

A.) Write a programme to conduct “BREDTH FIRST SEARCH” .

FROM COLLECTIONS IMPORT DEFAULTDICT

class Graph:
def __init__(self):

self.graph = defaultdict(list)

def addEdge(self,u,v):
self.graph[u].append(v)

# Function to print a BFS of graph

def BFS(self, s):

# Mark all the vertices as not visited

visited = [False] * (max(self.graph) + 1)

# Create a queue for BFS

queue = []

# visited and enqueue it

queue.append(s)
visited[s] = True

while queue:

# Dequeue a vertex from

PAGE N0. 8
SUSEC 1916810

# queue and print it

s = queue.pop(0)
print (s, end = " ")

for i in self.graph[s]:
if visited[i] == False:
queue.append(i)
visited[i] = True

OUTPUT & DRIVER CODE :-

PAGE N0. 9
SUSEC 1916810

B). Write a programme to conduct “DEPTH FIRST SEARCH” .

from collections import defaultdict

lass Graph:

# Constructor
def __init__(self):

# default dictionary to store graph

self.graph = defaultdict(list)

# function to add an edge to graph

def addEdge(self, u, v):
self.graph[u].append(v)

# A function used by DFS

def DFSUtil(self, v, visited):

# Mark the current node as visited

# and print it
visited.add(v)
print(v, end=' ')

# Recur for all the vertices

for neighbour in self.graph[v]:
if neighbour not in visited:
self.DFSUtil(neighbour, visited)

PAGE N0. 10
SUSEC 1916810

# The function to do DFS traversal. It uses

# recursive DFSUtil()
def DFS(self, v):

visited = set()
self.DFSUtil(v, visited)

OUTPUT & DRIVER CODE :-

PAGE N0. 11
SUSEC 1916810

C). Write a programme to conduct “A* ALGORITHM” .

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])
closed_list = set([])
g = {}
g[start_node] = 0
parents = {}
parents[start_node] = start_node

while len(open_list) > 0:

n = None

PAGE N0. 12
SUSEC 1916810

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

PAGE N0. 13
SUSEC 1916810

parents[m] = n

if m in closed_list:
closed_list.remove(m)

open_list.add(m)
open_list.remove(n)
closed_list.add(n)

print('Path does not exist!')

return None

OUTPUT & DRIVER CODE:-

PAGE N0. 14
SUSEC 1916810

D).Write a program to conduct”BEST FIRST SEARCH”.

from queue import PriorityQueue

v = 14
graph = [[] for i in range(v)]

def best_first_search(source, target, n):

visited = [False] * n
visited = True
pq = PriorityQueue()
pq.put((0, source))
while pq.empty() == False:
u = pq.get()[1]
print(u, end=" ")
if u == target:
break

for v, c in graph[u]:
if visited[v] == False:
visited[v] = True
pq.put((c, v))
print()

def addedge(x, y, cost):

graph[x].append((y, cost))
graph[y].append((x, cost))

addedge(0, 1, 3)
addedge(0, 2, 6)
addedge(0, 3, 5)

PAGE N0. 15
SUSEC 1916810

addedge(1, 4, 9)
addedge(1, 5, 8)
addedge(2, 6, 12)
addedge(2, 7, 14)
addedge(3, 8, 7)
addedge(8, 9, 5)
addedge(8, 10, 6)
addedge(9, 11, 1)
addedge(9, 12, 10)
addedge(9, 13, 2)

source = 0
target = 9
best_first_search(source, target, v)

PAGE N0. 16
SUSEC 1916810

EXPERIMENT :- 4
Write a programme to conduct game search

#include <iostream>
#include <iomanip>
#include <array> using namespace std;
void printarray(int num[3][3])
{
for(int i = 0;i < 3; i++)
{
for(int j = 0; j< 3; j++)
{
cout << num[i][j] << " ";
}
cout << "\n";
}
}

void swapValues(int (&array)[3][3], int i1,int j1,int i2,int j2)

{
int temp = array[i1]
[j1]; array[i1][j1] =
array[i2][j2]; array[i2]
[j2] = temp;
}

void moveleft(int (&array)[3][3], int i, int j)

{
if(i==1&&j==1)
{
swapValues(array, i, j, i-
1, j); swapValues(array,
i, j, i+1, j);

PAGE N0. 17
SUSEC 1916810

}
else if(i==1&&j==2)
{
swapValues(array, i, j, i,
j-1); swapValues(array,
i, j, i, j-2);
}
else if(i==0&&j==0)
{
swapValues(array, i, j+2,
i, j); swapValues(array,
i, j+1, i, j);
}
else if(i==0&&j==2)
{
swapValues(array, i, j, i, j);
}
else
swapValues(array, i, j, i-
1, j); swapValues(array,
i, j, i+1, j);
}

void movedown(int (&array)[3][3], int i, int j)

{
if(i==0&&j==0)
{
swapValues(array, i, j,
i+1, j);
swapValues(array, i, j,
i+2, j);
}
else if(i==1&&j==1)
{

PAGE N0. 18
SUSEC 1916810

swapValues(array, i+1, j,
i, j); swapValues(array,
i-1, j, i, j);
}
else if(i==0&&j==2)
{
swapValues(array, i, j, i+1, j);
}
else
swapValues(array, i, j, i-
1, j); swapValues(array,
i, j, i+1, j);
}

void moveright(int (&array)[3][3], int i, int j)

{
if(i==0&&j==0)
{
swapValues(array, i, j+1,
i, j); swapValues(array,
i, j+2, i, j);
}
else if(i==1&&j==1)
{
swapValues(array, i, j+1,
i, j); swapValues(array,
i, j-1, i, j);
}
else if(i==1&&j==2)
{
swapValues(array, i, j-2,
i, j); swapValues(array,
i, j-1, i, j);
}
PAGE N0. 19
SUSEC 1916810

else
swapValues(array, i, j, i-
1, j); swapValues(array,
i, j, i+1, j);
}

void moveup(int (&array)[3][3], int i, int j)

{
if(i==0&&j==0)
{
swapValues(array, i, j,
i+2, j);
swapValues(array, i, j,
i+1, j);
}
else if(i==1&&j==1)
{
swapValues(array, i, j, i-
1, j); swapValues(array,
i, j, i+1, j);
}
else if(i==0&&j==2)
{
swapValues(array, i, j,
i+1, j);
swapValues(array, i, j,
i+2, j);
swapValues(array, i, j,
i+1, j);
}
else

PAGE N0. 20
SUSEC 1916810

swapValues(array, i, j, i-
1, j); swapValues(array,
i, j, i+2, j);
//int coord1d = j * 3 + i;
}
class Puzzle
{
public:
Puzzle();
void swapValues(int num[3][3], int i1, int
j1, int i2, int j2); //void moveleft(int[3][3],
int start1, int start2); void moveup(int
(&array)[3][3], int i, int j);
void moveright(int (&array)[3][3],
int i, int j); void moveleft(int
(&array)[3][3], int i, int j); void
movedown(int (&array)[3][3], int i,
int j); void printarray(int[3][3]);
};

int main()
{
int state1[3][3] = {{2, 8, 3}, {1, 6, 4}, {7, 0, 5}};
int state2[3][3] = {{2, 8, 1}, {4, 6, 3}, {0, 7, 5}};
int gstate[3][3] = {{1, 2, 3}, {8, 0, 4}, {7, 6, 5}};
cout << "this is state 1"
<< endl;
printarray(state1);
cout << "\n\n";
cout << "now this is state 2"
<< endl; printarray(state2);
cout << "\n\n";
cout << "now this is the goal state"
<< endl;; printarray(gstate);
int start1, start2;

PAGE N0. 21
SUSEC 1916810

cout << endl << endl << "please enter your starting point in the states
listed above going up or down" << endl;
cin >> start1;
cout << "now enter the point going left
to right" << endl; cin >> start2;
//moveleft(state1, start1, start2);
cout << "this is moving coordinate (1, 1)
upwards" << endl; moveup(state1, start1,
start2);
printarray(state
1); cout <<
endl;
cout << "this is moving coordinate (1, 1) to
the left" << endl; moveleft(state1, start1,
start2);
printarray(state
1); cout <<
endl;
cout << "this is moving coordinate (1, 1)
downwards" << endl; movedown(state1,
start1, start2);
printarray(state
1); cout <<
endl;
cout << "this is moving coordinate (1, 1) to the
right" << endl; moveright(state1, start1, start2);
printarray(state
1); cout <<
endl; cin.get();
cin.get();
return 0;
}

PAGE N0. 22
SUSEC 1916810

PAGE N0. 23
SUSEC 1916810

EXPERIMENT :- 5

Write a programme to construct a Bayesian network from given data.

import numpy as np
import pandas as pd
import csv
from pgmpy.estimators import MaximumLikelihoodEstimator
from pgmpy.models import BayesianModel
from pgmpy.inference import VariableElimination

heartDisease = pd.read_csv('heart.csv')
heartDisease = heartDisease.replace('?',np.nan)

print('Sample instances from the dataset are given below')

print(heartDisease.head())

print('\n Attributes and datatypes')

print(heartDisease.dtypes)

model= BayesianModel([('age','heartdisease'),('sex','heartdisease'),
('exang','heartdisease'),('cp','heartdisease'),('heartdisease','restecg'),
('heartdisease','chol')])
print('\nLearning CPD using Maximum likelihood estimators')
model.fit(heartDisease,estimator=MaximumLikelihoodEstimator)

print('\n Inferencing with Bayesian Network:')

HeartDiseasetest_infer = VariableElimination(model)

print('\n 1. Probability of HeartDisease given evidence= restecg')

q1=HeartDiseasetest_infer.query(variables=['heartdisease'],evidence={'restec
g':1})
print(q1)

PAGE N0. 24
SUSEC 1916810

print('\n 2. Probability of HeartDisease given evidence= cp ')

q2=HeartDiseasetest_infer.query(variables=['heartdisease'],evidence={'cp':2}
)
print(q2)

OUTPUT:-

PAGE N0. 25
SUSEC 1916810

EXPERIMENT :- 6

.Write a programme to run value and policy iteration in a grid

world.
def play_episodes(environment, n_episodes, policy):
def play_episodes(environment, n_episodes, policy):
wins = 0
total_reward = 0
for episode in range(n_episodes):
terminated = False
state = environment.reset()
while not terminated:
# Select best action to perform in a current state
action = np.argmax(policy[state])
# Perform an action an observe how environment
acted in response
next_state, reward, terminated, info =
environment.step(action)
# Summarize total reward
total_reward += reward
# Update current state
state = next_state
# Calculate number of wins over episodes
if terminated and reward == 1.0:
wins += 1
average_reward = total_reward / n_episodes
return wins, total_reward, average_reward

# Number of episodes to play

n_episodes = 10000
# Functions to find best policy

PAGE N0. 26
SUSEC 1916810

solvers = [('Policy Iteration', policy_iteration),

('Value Iteration', value_iteration)]
for iteration_name, iteration_func in solvers:
# Load a Frozen Lake environment
environment = gym.make('FrozenLake-v0')
# Search for an optimal policy using policy iteration
policy, V = iteration_func(environment.env)
# Apply best policy to the real environment
wins, total_reward, average_reward = play_episodes(environment,
n_episodes, policy)
print(f'{iteration_name} :: number of wins over {n_episodes}
episodes = {wins}')
print(f'{iteration_name} :: average reward over {n_episodes}
episodes = {average_reward} \n\n')

PAGE N0. 27
SUSEC 1916810

EXPERIMENT :- 7

Write a programme to do reinforcement learning in a grid world

def play(self, rounds=10):
i=0
while i < rounds:
# to the end of game back propagate reward
if self.State.isEnd:
# back propagate
reward = self.State.giveReward()
# explicitly assign end state to reward values
self.state_values[self.State.state] = reward # this is optional
print("Game End Reward", reward)
for s in reversed(self.states):
reward = self.state_values[s] + self.lr * (reward -
self.state_values[s])
self.state_values[s] = round(reward, 3)
self.reset()
i += 1
else:
action = self.chooseAction()
# append trace
self.states.append(self.State.nxtPosition(action))
print("current position {} action {}".format(self.State.state, action))
# by taking the action, it reaches the next state
self.State = self.takeAction(action)
# mark is end
self.State.isEndFunc()
print("nxt state", self.State.state)
print("---------------------")
def chooseAction(self):
# choose action with most expected value
mx_nxt_reward = 0

PAGE N0. 28
SUSEC 1916810

action = ""

if np.random.uniform(0, 1) <= self.exp_rate:

action = np.random.choice(self.actions)
else:
# greedy action
for a in self.actions:
# if the action is deterministic
nxt_reward = self.state_values[self.State.nxtPosition(a)]
if nxt_reward >= mx_nxt_reward:
action = a
mx_nxt_reward = nxt_reward
return action

OUTPUT:-

PAGE N0. 29