1

SSM COLLEGE OF ENGINEERING

KOMARAPALAYAM- 638 183

DEPARTMENT OF TEXTILE TECHNOLOGY

OCS351- ARTIFICIAL INTELLIGENCE AND MACHINE LEARNING

LABORATORY

(Regulations 2021)

SEMESTER VI
(ACADEMIC YEAR 2023-24)

RECORD NOTE BOOK

REGISTER NUMBER

NAME OF THE STUDENT

 2

SSM COLLEGE OF ENGINEERING

KOMARAPALAYAM- 638 183

Department of Textile Technology Laboratory Record NAME :

COURSE : B.TECH
(TT) REGISTER NO: YEAR : IV Year VII
Sem

Certified that this is bonafide record of work done by the above

student of the OCS351 – Artificial Intelligence and Machine Learning
Laboratory during the year 2023-2024.

Signature of Lab in Charge Signature of Head of the Department

Submitted for the Practical examination held on

Internal Examiner External Examiner

 3

INDEX
S.No Date Name Of The Experiment Page Marks Signature
No
1.a) 05
Implementation of Uninformed
search algorithms-BFS

1.b) 08

Implementation of Uninformed
search algorithms-DFS

2.a) 11
Implementation of Informed
search algorithms -A*

2.b) 15
Implementation of Informed
search Algorithms Memory
bounded A*
3 21

Implement naïve Bayes models

4 23

Implement Bayesian Networks

5 31

Build Regression models

6.a) 36
Build decision trees

6.b) 42
Build random forests

7 46
Build SVM models
 4

8 50
Implement Ensembling Techniques

9 55
Implement Clustering Algorithms

10 59
Implement EM for Bayesian networks

11 Build Simple NN models 65

12 72
Build deep learning NN models
 5

Ex. No : 1(a) Implementation of Uninformed search algorithms-BFS

Date:

AIM:
To Implementation of Uninformed search algorithms-BFS by using Python algorithm.

ALGORITHMS:

 Start by putting any one of the graph’s vertices at the back of the queue.
 Now take the front item of the queue and add it to the visited list.
 Create a list of that vertex's adjacent nodes. Add those which are not within the visited
list to the rear of the queue.
 Keep continuing steps two and three till the queue is empty.

PROGRAM:

# Python3 Program to print BFS traversal

# from a given source vertex. BFS(int s)
# traverses vertices reachable from s.
from collections import defaultdict

# This class represents a directed

graph # using adjacency list
representation class 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)

# Function to print a BFS of

graph def BFS(self, s):

# Mark all the vertices as not

visited visited = [False] *
(len(self.graph))

# Create a queue for

BFS queue = []
# Mark the source node
as # visited and enqueue
it queue.append(s)
 6
visited[s] = True
 7

while queue:

# Dequeue a vertex
from # queue and print
it
s = queue.pop(0)
print (s, end = "
")

# Get all adjacent vertices of the

# dequeued vertex s. If a
adjacent
# has not been visited, then mark
it # visited and enqueue it
for i in self.graph[s]:
if visited[i] == False:
queue.append(i)
visited[i] =
True

# Driver code

# Create a graph given

in # the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)

print ("Following is Breadth First Traversal"

" (starting from vertex 2)")
g.BFS(2)
 8

OUTPUT:

Following is Breadth First Traversal (starting from vertex 2)

>3
20313
>

RESULT

Thus the Implementation of Uninformed search algorithms-BFS by using Python algorithm is executed
successfully.
 9

Ex. No : 1(b) Date: Implementation of Uninformed search algorithms-DFS

AIM:
To implement a program to Uninformed search algorithms-DFS using Python.

ALGORITHM:

 We will start by putting any one of the graph's vertex on top of the stack.
 After that take the top item of the stack and add it to the visited list of the vertex.
 Next, create a list of that adjacent node of the vertex. Add the ones which aren't in
the visited list of vertexes to the top of the stack.
 Lastly, keep repeating steps 2 and 3 until the stack is empty.

PROGRAM:

# Python program to print DFS traversal for complete

graph from collections import defaultdict

# This class represents a directed graph using

adjacency # list representation
class 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[v]= True
print v,

# Recur for all the vertices adjacent

to # this vertex
for i in self.graph[v]:
 10

if visited[i] == False:
self.DFSUtil(i, visited)

# The function to do DFS traversal. It

uses # recursive DFSUtil()
def DFS(self):
V = len(self.graph) #total vertices

# Mark all the vertices as not

visited visited =[False]*(V)

# Call the recursive helper function to print

# DFS traversal starting from all vertices
one # by one
for i in range(V):
if visited[i] == False:
self.DFSUtil(i, visited)

# Driver code
# Create a graph given in the above
diagram g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)

print "Following is Depth First

Traversal" g.DFS()
 11

OUTPUT:

Following is Depth First Traversal (starting from vertex 2) 2 0 1 9 3

RESULT

Thus the implementation of Uninformed search algorithms-DFS using Python is executed suc
 12

Ex. No : 2(a) Implementation of Informed search algorithms -A*

Date:

AIM :

To implement Informed search algorithm –A* using python

ALGORITHM:

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

def aStarAlgo(start_node, stop_node):

open_set = set(start_node)
closed_set = set()
g = {} #store distance from starting node
parents = {} # parents contains an adjacency map of all
nodes #distance of starting node from itself is zero
g[start_node] = 0
#start_node is root node i.e it has no parent
nodes #so start_node is set to its own parent
node parents[start_node] = start_node
while len(open_set) >
0: n = None
#node with lowest f() is
found for v in open_set:
if n == None or g[v] + heuristic(v) < g[n] +
heuristic(n): n = v
if n == stop_node or Graph_nodes[n] ==
None: pass
else:
for (m, weight) in get_neighbors(n):
#nodes 'm' not in first and last set are added to first
#n is set its parent
if m not in open_set and m not in
closed_set: open_set.add(m)
parents[m] = n
g[m] = g[n] + weight
#for each node m,compare its distance from start i.e g(m) to the
#from start through n node
else:
 13

if g[m] > g[n] +

weight: #update
g(m)
g[m] = g[n] + weight
#change parent of m to n
parents[m] = n
#if m in closed set,remove and add to
open if m in closed_set:
closed_set.remove(m)
open_set.add(m)
if n == None:
print('Path does not
exist!') return None

# if the current node is the stop_node

# then we begin reconstructin the path from it to the
start_node if n == stop_node:
path = []
while parents[n] != n:
path.append(n)
n = parents[n]
path.append(start_node)
path.reverse()
print('Path found:
{}'.format(path)) return path
# remove n from the open_list, and add it to closed_list
# because all of his neighbors were inspected
open_set.remove(n)
closed_set.add(n)
print('Path does not
exist!') return None

#define fuction to return neighbor and its distance

#from the passed node
def get_neighbors(v):
if v in
Graph_nodes:
return Graph_nodes[v]
else:
return None
A star example 1
#for simplicity we ll consider heuristic distances given
#and this function returns heuristic distance for all
nodes def heuristic(n):
H_dist = {
'A': 11,
'B': 6,
'C': 5,
 14

'D': 7,
'E': 3,
'F': 6,
'G': 5,
'H': 3,
'I': 1,
'J': 0
}
return H_dist[n]

#Describe your graph here

Graph_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': [('E', 5), ('G', 3), ('H', 2), ('J', 3)],
}

aStarAlgo('A', 'J')

#for simplicity we ll consider heuristic distances given

#and this function returns heuristic distance for all
nodes def heuristic(n):
H_dist = {
'A': 11,
'B': 6,
'C': 99,
'D': 1,
'E': 7,
'G': 0,
}
return H_dist[n]

#Describe your graph here

Graph_nodes = {
'A': [('B', 2), ('E', 3)],
'B': [('A', 2), ('C', 1), ('G', 9)],
'C': [('B', 1)],
'D': [('E', 6), ('G', 1)],
'E': [('A', 3), ('D', 6)],
'G': [('B', 9), ('D', 1)]
 15

aStarAlgo('A', 'G')

OUTPUT:

Path found: ['A', 'F', 'G', 'I', 'J']

Path found: ['A', 'E', 'D', 'G']

RESULT :

Thus the implementation of Informed search algorithm –A* using python is executed successfully.
 16

Ex. No : 2(b) Implementation of Informed search algorithms - memory-bounded

Date: A*

AIM :
To implement Informed search algorithms - memory-bounded A* using python

ALGORITHM:

Default values for g, h and f are same as 0; because this is just a cell
Inserting some walls, starting and goal positions
Convert the grid to a string
Printing the maze with the solution path

PROGRAM:

import random
from typing import Tuple, List, Generator, Union, Optional

# The below constants are used to represent the

different # types of cells in the maze. (Except space,
which is ' ') START_SIGNS = '$Ss'
GOAL_SIGNS = '*XxEeGg'
WALL_SIGNS = '#&;'

class Cell:
"""Cell class represents a cell in the
maze. Attributes:
value: The character stored in the cell.
position: Vertical and horizontal position of the cell in the maze.
parent: Cell which has been visited before this cell.
g: Cost from start to this cell.
h: Estimated cost from this cell to the goal.
f: Sum of the cost of this cell and the estimated cost to the goal.
"""

def init (self, value: str, position: Tuple[int, int]) -> None:
self.value = value
self.position =
position self.parent =
None

# Default values for g, h and f are same as 0; because this is just a

cell # and has no brain to calculate the values.
 17

self.g = 0
self.h = 0
self.f = 0

def eq (self, other: 'Cell') -> bool:

return self.value == other.value and self.position == other.position

def str (self) -> str:

return f'Cell(value={repr(self.value)}, position={self.position}, parent={self.parent},
g={self.g}, h={self.h}, f={self.f})'

def repr (self) -> str:

return str(self)

class Maze:
"""The place that represents a 2D grid of
cells. Attributes:
grid: A list of cells with their specific position.
horizontal_limit: The horizontal limit of the maze (x-axis).
vertical_limit: The vertical limit that we can go (y-axis).
start: The starting position of the maze.
goals: The goals positions that we want to
reach. """

def init (self, maze: str) -> None:

lines = maze.splitlines()
rows, cols = len(lines), max(map(len, lines))
grid = [[Cell(' ', (i, j)) for j in range(cols)] for i in range(rows)] # Generate a matrix based
on the max length of rows
start = None
goals = []

for i, line in enumerate(lines):

for j, char in
enumerate(line):
if char not in f'{START_SIGNS}{GOAL_SIGNS}{WALL_SIGNS} ':
raise ValueError(f'Invalid character {repr(char)} at position ({i}, {j})')
elif char in START_SIGNS:
if start is not None:
raise ValueError('Multiple start positions found!')
start = (i, j)
elif char in
GOAL_SIGNS:
goals.append((i, j))
grid[i][j].value =

char self.grid = grid

 18

self.horizontal_limit = rows
self.vertical_limit = cols
self.start = start
self.goals = goals

def eq (self, other: 'Maze') -> bool:

return self.grid == other.grid and self.start == other.start and self.goals == other.goals

def str (self) -> str:

return f'Maze(grid={self.grid}, horizontal_limit={self.horizontal_limit},
vertical_limit={self.vertical_limit}, start={self.start}, goals={self.goals})'

def repr (self) -> str:

return str(self)

def neighbors(self, cell: Tuple[int, int]) -> Generator[Tuple[int, int], None, None]:
"""Yields all the neighbors that are not walls."""
current_x, current_y = cell
coords = [(-1, -1), (-1, 0), (-1, 1), (0, 1), (0, -1), (1, -1), (1, 0), (1, 1)]

for next_x, next_y in

coords: x = current_x +
next_x
y = current_y + next_y
if 0 <= x < self.horizontal_limit and 0 <= y < self.vertical_limit and \
self.grid[x][y].value not in WALL_SIGNS:
yield x, y

def _generate_maze(min_size: Tuple[int, int], max_size: Tuple[int, int],

save_to_file: Optional[bool] = False) -> Maze:
"""Generates a random maze with the given size."""
rows, cols = random.randint(*min_size), random.randint(*max_size)
grid = [[' ' for _ in range(cols)] for _ in range(rows)]
# Inserting some walls, starting and goal positions
for _ in range(random.randint(0, rows*cols//5)):
grid[random.randint(0, rows-1)][random.randint(0, cols-1)] = '#'
grid[random.randint(0, rows-1)][random.randint(0, cols-1)] = '$'
grid[random.randint(0, rows-1)][random.randint(0, cols-1)] = 'X'
grid = '\n'.join([''.join(row) for row in grid]) # Convert the grid to a string

if save_to_file:
with open('genmaze.txt', 'w') as
f: f.write(grid)
return Maze(grid)
 19

def _reconstruct_path(current: Cell) -> List[Tuple[int, int]]:

"""Reconstructs the path from the start to the goal."""
path = [current.position]
while current.parent is not None:
current = current.parent
path.insert(0, current.position)
return path

def _manhattan_distance(current: Tuple[int, int], goal: Tuple[int, int]) -> int:

"""Calculates the Manhattan distance between two points."""
return abs(current[0] - goal[0]) + abs(current[1] - goal[1])

def sma_star(maze: Union[Maze, str], bound: Optional[int] = None, forcely: Optional[bool] =

False) -> List[Tuple[int, int]]:
"""SMA* searches for the shortest path from the start to the
goal(s).""" if not isinstance(maze, (Maze, str)):
raise TypeError('The maze must be a Maze object or a string.')
elif isinstance(maze, str):
maze = Maze(maze)

opened = [maze.grid[maze.start[0]][maze.start[1]]] # The list initiallized with the starting cell

closed = [] # No cells have been visited yet

while opened:
# print('
'
) lowest_f = min(opened, key=lambda cell: cell.f)
current = opened.pop(opened.index(lowest_f))
# print(f'Current position is
{current.position}') closed.append(current)

if current.position in maze.goals:
# print(f'Goal found after {len(closed)} steps!')
# print(f'The maximum required bound in this case is {int(bound) if bound is not None
else "not specified"}')
# print(' ')
return _reconstruct_path(current) # Return the path at the first goal found

for neighbor_x, neighbor_y in maze.neighbors(current.position):

neighbor_cell = maze.grid[neighbor_x][neighbor_y]
if neighbor_cell in closed:
# print(f'Cell {neighbor_cell.position} is already visited')
continue

neighbor_cell.parent = current # We need to trace back to the start

 20

neighbor_cell.g = current.g + 1 # The path cost from the start to the node n increases by
1
neighbor_cell.h = _manhattan_distance(current.position, neighbor_cell.position)
neighbor_cell.f = neighbor_cell.g + neighbor_cell.h
# print(f'Neighbor(position={neighbor_cell.position}, g={neighbor_cell.g},
h={neighbor_cell.h}, f={neighbor_cell.f})')

if neighbor_cell not in opened:

opened.append(neighbor_cell)
# print(f'Cell {neighbor_cell.position} added to the opened list')
closed.append(neighbor_cell) # The cell is now visited

if bound is not None and len(closed) >

bound: # print(f'The bound of {bound} is
reached') if not forcely:
return _reconstruct_path(current)
bound *= 1.05 # Increase the bound by just 5%

return None

if name == ' main ':

import sys
import argparse

parser = argparse.ArgumentParser(description='Simplified Memory Bounded A* (SMA*)

path finding algorithm.')
parser.add_argument('-m', '--maze', type=str, help='the path to the maze file')
parser.add_argument('-g', '--generate', action='store_true', help='generate a new maze and
save
it to a file')
parser.add_argument('-b', '--bound', type=int, help='the maximum number of nodes to be
expanded')
parser.add_argument('-f', '--forcely', action='store_true', help='search the maze even if the
bound is reached')
args = parser.parse_args()

if args.generate:
maze = _generate_maze(min_size=(5, 5), max_size=(100, 100), save_to_file=True)
print('Maze generated successfully!\n')
elif args.maze is not None:
with open(args.maze, 'r') as
f:
maze = Maze(f.read())
print('Maze loaded from file...\
n')
else:
print('No maze specified! Please read the help for more information.')
sys.exit(1)
 21

solution = sma_star(maze, args.bound, args.forcely)

if solution is None:
print('No solution
found!') sys.exit(1)
print(f'The solution steps in order is: {" -> ".join(map(lambda pos: f"({pos[0]}, {pos[1]})",
solution))}\n')

# Printing the maze with the solution

path for row in maze.grid:
for cell in row:
if cell.position in solution[1:-
1]: cell.value = '·'
print(cell.value, end='')
print()

Output:

RESULT

Thus the implementation of Informed search algorithms - memory-bounded A* using python is

executed successfully.
 22

Ex. No : 3 Implement naïve Bayes models

Date:

AIM :

To implement naïve bayes model

ALGORITHM:

Step 1: Separate By Class.

Step 2: Summarize Dataset.
Step 3: Summarize Data By Class.
Step 4: Gaussian Probability Density
Function. Step 5: Class Probabilities.

PROGRAM:

import numpy as np

class NaiveBayes:

def fit(self, X, y):

n_samples, n_features =
X.shape self._classes =
np.unique(y) n_classes =
len(self._classes)

# calculate mean, var, and prior for each class

self._mean = np.zeros((n_classes, n_features), dtype=np.float64)
self._var = np.zeros((n_classes, n_features), dtype=np.float64)
self._priors = np.zeros(n_classes, dtype=np.float64)

for idx, c in enumerate(self._classes):

X_c = X[y == c]
self._mean[idx, :] = X_c.mean(axis=0)
self._var[idx, :] = X_c.var(axis=0)
self._priors[idx] = X_c.shape[0] /
float(n_samples)

def predict(self, X):

y_pred = [self._predict(x) for x in
X] return np.array(y_pred)

def _predict(self,
x): posteriors = []

# calculate posterior probability for each

 23
class for idx, c in enumerate(self._classes):
prior = np.log(self._priors[idx])
 24

posterior = np.sum(np.log(self._pdf(idx, x)))

posterior = posterior + prior
posteriors.append(posterior)

# return class with the highest posterior

return self._classes[np.argmax(posteriors)]

def _pdf(self, class_idx, x):

mean =
self._mean[class_idx] var =
self._var[class_idx]
numerator = np.exp(-((x - mean) ** 2) / (2 *
var)) denominator = np.sqrt(2 * np.pi * var)
return numerator / denominator

# Testing
if name == " main ":
# Imports
from sklearn.model_selection import train_test_split
from sklearn import datasets

def accuracy(y_true, y_pred):

accuracy = np.sum(y_true == y_pred) /
len(y_true) return accuracy

X, y = datasets.make_classification(
n_samples=1000, n_features=10, n_classes=2, random_state=123
)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=123
)

nb = NaiveBayes()
nb.fit(X_train, y_train)
predictions =
nb.predict(X_test)

print("Naive Bayes classification accuracy", accuracy(y_test, predictions))

OUTPUT:

RESULT :
Thus the implementation of Naïve Bayes model is executed successfully.
 25

Ex. No : 4 Implement Bayesian Networks

Date:

AIM :

To implement Bayesian networks

ALGORITHM:

1. First, identify which are the main variable in the problem to solve. ...
2. Second, define structure of the network, that is, the causal relationships between all
the variables (nodes).
3. Third, define the probability rules governing the relationships between the variables.

PROGRAM:

#!/usr/bin/env python
""" generated source for module BayesianNetwork
""" from Assignment4 import *
import random
#
# * A bayesian network
# * @author Panqu
#
class BayesianNetwork(object):
""" generated source for class BayesianNetwork
""" #
# * Mapping of random variables to nodes in the
network #
varMap = None

#
# * Edges in this
network #
edges = None

#
# * Nodes in the network with no
parents #
rootNodes = None

#
# * Default constructor initializes empty
network #
def init (self):
""" generated source for method init """
self.varMap = {}
 26

self.edges = []
self.rootNodes = []

#
# * Add a random variable to this
network # * @param variable Variable to
add
#
def addVariable(self, variable):
""" generated source for method addVariable
""" node = Node(variable)
self.varMap[variable]=node
self.rootNodes.append(node)

#
# * Add a new edge between two random variables already in this
network # * @param cause Parent/source node
# * @param effect Child/destination
node #
def addEdge(self, cause, effect):
""" generated source for method addEdge
""" source = self.varMap.get(cause)
dest = self.varMap.get(effect)
self.edges.append(Edge(source, dest))
source.addChild(dest)
dest.addParent(source)
if dest in self.rootNodes:
self.rootNodes.remove(dest)

#
# * Sets the CPT variable in the bayesian network (probability
of # * this variable given its parents)
# * @param variable Variable whose CPT we are setting
# * @param probabilities List of probabilities P(V=true|P1,P2...), that must be ordered as
follows.
# Write out the cpt by hand, with each column representing one of the parents
(in alphabetical order).
# Then assign these parent variables true/false based on the following order: ...tt, ...tf, ...ft,
...ff.
# The assignments in the right most column, P(V=true|P1,P2,...), will be the values you
should pass in as probabilities here.
#
def setProbabilities(self, variable, probabilities):
""" generated source for method setProbabilities """
probList = []
for probability in probabilities:
probList.append(probability)
self.varMap.get(variable).setProbabilities(probList)
 27

def normalize(self, toReturn):

SUM = toReturn[0] + toReturn[1]

if SUM is 0:
return 0, 0
else:
return float(toReturn[0])/SUM

#
# * Returns an estimate of P(queryVal=true|givenVars) using rejection
sampling # * @param queryVar Query variable in probability query
# * @param givenVars A list of assignments to variables that represent our given evidence
variables
# * @param numSamples Number of rejection samples to
perform #
def performRejectionSampling(self, queryVar, givenVars, numSamples):
""" generated source for method performRejectionSampling """
# TODO
toReturn = [0, 0]
for j in range(1,
numSamples): # start prior
sampling
x = {}
sortVar =
sorted(self.varMap) for
variable in sortVar:
ran = random.random()
if ran <= self.varMap[variable].getProbability(x, True):
x[variable.getName()] = True
else:
x[variable.getName()] =
False # end prior sampling

for e in givenVars:
if x[e.getName()] == givenVars[e]:
if x[queryVar.getName()] is
True:
toReturn[0] += 1
else:
toReturn[1] += 1

return self.normalize(toReturn)

#
# * Returns an estimate of P(queryVal=true|givenVars) using weighted
sampling # * @param queryVar Query variable in probability query
# * @param givenVars A list of assignments to variables that represent our given evidence
variables
 28

# * @param numSamples Number of weighted samples to

perform #
def performWeightedSampling(self, queryVar, givenVars, numSamples):
""" generated source for method performWeightedSampling """
# TODO
toReturn = [0, 0]
for j in range(1,
numSamples): #
weightedSample
(x, w) = self.weightedSample(self.varMap, givenVars)

if x[queryVar.getName()] is
True: toReturn[0] += w
else:
toReturn[1] += w

return self.normalize(toReturn)

def weightedSample(self, bn, e):

x = Sample()
for event in e:
x.setAssignment(event.getName(), e[event])

sortVar = sorted(bn.keys())
for xi in sortVar:
if x.getValue(xi.getName()) is not
None: w = x.getWeight()
w = w * bn[xi].getProbability(x.assignments, x.assignments.get(xi.getName()))
x.setWeight(w)
else:
ran = random.random()
if ran <= bn[xi].getProbability(x.assignments, True):
x.assignments[xi.getName()] = True
else:
x.assignments[xi.getName()] = False

return x.assignments, x.getWeight()

#
# * Returns an estimate of P(queryVal=true|givenVars) using Gibbs sampling
# * @param queryVar Query variable in probability query
# * @param givenVars A list of assignments to variables that represent our given evidence
variables
# * @param numTrials Number of Gibbs trials to perform, where a single trial consists
of assignments to ALL
 29

# non-evidence variables (ie. not a single state change, but a state change of all non-
evidence variables)
#
def performGibbsSampling(self, queryVar, givenVars, numTrials):
""" generated source for method performGibbsSampling """
# TODO
counter = [0, 0]

nonEviVar = []
givenVarsSort = sorted(givenVars)

newvarMap = {}

# set all needed variable field

for variable in
self.varMap.keys(): if variable
in givenVarsSort:
newvarMap[variable.getName()] =
givenVars[variable] continue
else:
nonEviVar.append(variable)
randomprob =
random.random() if
randomprob < 0.5:
newvarMap[variable.getName()] = False
else:
newvarMap[variable.getName()] = True

# gibbs sampling
# idea from book page 537
for j in range(1,
numTrials):
for z in nonEviVar:
markovList = self.markovBlanket(self.varMap.get(z))
markovMap = {}

for mark in markovList:

markovMap[mark.getVariable().getName()] =
newvarMap[mark.getVariable().getName()]
probCom = self.gibbsProb(markovMap,
z) if probCom[0] is 0:
alpha = 0
else:
alpha = 1.0/probCom[0]
val = alpha * probCom[1]

randomprob2 = random.random()
if val < randomprob2:
newvarMap[self.varMap[z].getVariable().getName()] = False
 30

else:
newvarMap[self.varMap[z].getVariable().getName()] = True

if newvarMap[queryVar.getName()] is
False: counter[1] += 1
else:
counter[0] += 1

return self.normalize(counter)

def gibbsProb(self, markMap,

Z_i): query = {}
probC_true = 1.0
probC_false = 1.0

for par in self.varMap[Z_i].getParents():

query[par.getVariable().getName()] = markMap[par.getVariable().getName()]

prob_true = self.varMap[Z_i].getProbability(query, True)

prob_false = self.varMap[Z_i].getProbability(query, False)

for child in self.varMap[Z_i].getChildren():

childP = {}
for childp in child.getParents():
if childp.getVariable().equals(self.varMap[Z_i].getVariable()) is False:
childP[childp.getVariable().getName()] =
markMap[childp.getVariable().getName()]
else:
childP[childp.getVariable().getName()] = True

probC_true = prob_true *
child.getProbability(childP,
markMap[child.getVariable().getName()])
for child in self.varMap[Z_i].getChildren():
childP = {}
for childp in child.getParents():
if childp.getVariable().equals(self.varMap[Z_i].getVariable()) is False:
childP[childp.getVariable().getName()] =
markMap[childp.getVariable().getName()]
else:
childP[childp.getVariable().getName()] = False

probC_false = prob_false * child.getProbability(childP,

markMap[child.getVariable().getName()])
toReturn = prob_true * probC_true + prob_false * probC_false
return toReturn, prob_true * probC_true
 31

# markovBlanket method that provides a list that we need to use for Gibbs
Sampling # idea from slide 19_20 page 18
def markovBlanket(self,
node): markovList = []
for parentN in
node.getParents():
markovList.append(parentN)

for childrenN in
node.getChildren():
markovList.append(childrenN)

for parentC in childrenN.getParents():

if parentC is node or parentC in
markovList: continue
markovList.append(parentC)

return markovList
 32

Output:

RESULT :

Thus the implementation of Bayesian Networks is executed successfully.

 33

Ex. No : 5 Build Regression models

Date:

AIM :

To implement build regression models .

ALGORITHM:

1. Initialize the parameters.

2.Predict the value of a dependent variable by given an independent variable.
3. Calculate the error in prediction for all data
points. 4.Calculate partial derivative w.r.t a0 and a1.
5.Calculate the cost for each number and add them.
6.Update the values of a0 and a1.

PROGRAM:

import matplotlib.pyplot as
plt import pandas as pd
import numpy as np

def kernel(point,xmat, k):

m,n = np.shape(xmat)
weights = np.mat(np.eye((m))) # eye - identity matrix

for j in range(m):
diff = point - X[j]
weights[j,j] = np.exp(diff*diff.T/(-2.0*k**2))
return weights

def localWeight(point,xmat,ymat,k):
wei = kernel(point,xmat,k)
W = (X.T*(wei*X)).I*(X.T*(wei*ymat.T))
return W
def localWeightRegression(xmat,ymat,k):
m,n = np.shape(xmat)
ypred = np.zeros(m)
for i in range(m):
ypred[i] = xmat[i]*localWeight(xmat[i],xmat,ymat,k)
return ypred

def graphPlot(X,ypred):
sortindex = X[:,1].argsort(0) #argsort - index of the smallest
xsort = X[sortindex][:,0]
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(bill,tip, color='green')
 34

ax.plot(xsort[:,1],ypred[sortindex], color = 'red', linewidth=5)

plt.xlabel('Total bill')
plt.ylabel('Tip')
plt.show();
# load data points
data = pd.read_csv('10data_tips.csv')
bill = np.array(data.total_bill)
# We use only Bill amount and Tips data tip = np.array(data.tip)
mbill = np.mat(bill) # .mat will convert nd array is converted in 2D array
mtip = np.mat(tip)
m= np.shape(mbill)[1]
one =
np.mat(np.ones(m))
X = np.hstack((one.T,mbill.T)) # 244 rows, 2 cols
ypred = localWeightRegression(X,mtip,8) # increase k to get smooth curves
graphPlot(X,ypred)
 35

OUTPUT:
 36

Type 2 :

import numpy as np
import matplotlib.pyplot as plt

def estimate_coef(x, y):

# number of
observations/points n =
np.size(x)

# mean of x and
y vector m_x =
np.mean(x)
m_y = np.mean(y)

# calculating cross-deviation and deviation

about x SS_xy = np.sum(y*x) -
n*m_y*m_x SS_xx = np.sum(x*x) -
n*m_x*m_x

# calculating regression
coefficients b_1 = SS_xy / SS_xx
b_0 = m_y -

b_1*m_x return (b_0,

b_1)

def plot_regression_line(x, y, b):

# plotting the actual points as scatter
plot plt.scatter(x, y, color = "m",
marker = "o", s = 30)

# predicted response vector

y_pred = b[0] + b[1]*x

# plotting the regression line

plt.plot(x, y_pred, color =
"g")

# putting labels
plt.xlabel('x')
plt.ylabel('y')

# function to show
plot plt.show()
 37

def main():
# observations / data
x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12])

# estimating
coefficients b =
estimate_coef(x, y)
print("Estimated coefficients:\nb_0 = {} \
\nb_1 = {}".format(b[0],
b[1])) # plotting regression line
plot_regression_line(x, y, b)

if name == " main

": main()

output

RESULT :

Thus the implementation of build regression models is been executed successfully.

 38

Ex. No : 6 a) Date: Build decision trees

AIM :

To implement decision trees using python

ALGORITHM:

1. Importing Required Libraries. Let's first load the required libraries. ...
2.Loading Data. ...
3.Feature Selection. ...
4.Splitting Data. ...
5.Building Decision Tree Model. ...
6.Evaluating Model. ...

PROGRAM:

Main.py

import numpy as np
from collections import Counter

class Node:
def init (self, feature=None, threshold=None, left=None, right=None,*,value=None):
self.feature = feature
self.threshold =
threshold self.left = left
self.right = right
self.value =
value

def is_leaf_node(self):
return self.value is not None

class DecisionTree:
def init (self, min_samples_split=2, max_depth=100, n_features=None):
self.min_samples_split=min_samples_split
self.max_depth=max_depth
self.n_features=n_features
self.root=None
 39

def fit(self, X, y):

self.n_features = X.shape[1] if not self.n_features else min(X.shape[1],self.n_features)
self.root = self._grow_tree(X, y)

def _grow_tree(self, X, y,
depth=0): n_samples, n_feats =
X.shape
 40

n_labels =

len(np.unique(y)) # check

the stopping criteria

if (depth>=self.max_depth or n_labels==1 or n_samples<self.min_samples_split):
leaf_value =
self._most_common_label(y) return
Node(value=leaf_value)

feat_idxs = np.random.choice(n_feats, self.n_features, replace=False)

# find the best split

best_feature, best_thresh = self._best_split(X, y, feat_idxs)

# create child nodes

left_idxs, right_idxs = self._split(X[:, best_feature], best_thresh)
left = self._grow_tree(X[left_idxs, :], y[left_idxs], depth+1)
right = self._grow_tree(X[right_idxs, :], y[right_idxs], depth+1)
return Node(best_feature, best_thresh, left, right)

def _best_split(self, X, y,
feat_idxs): best_gain = -1
split_idx, split_threshold = None, None

for feat_idx in feat_idxs:

X_column = X[:,
feat_idx]
thresholds = np.unique(X_column)

for thr in thresholds:

# calculate the information gain
gain = self._information_gain(y, X_column, thr)

if gain > best_gain:

best_gain = gain
split_idx = feat_idx
split_threshold =
thr

return split_idx, split_threshold

def _information_gain(self, y, X_column, threshold):

# parent entropy
parent_entropy = self._entropy(y)

# create children
left_idxs, right_idxs = self._split(X_column, threshold)
 41

if len(left_idxs) == 0 or len(right_idxs) == 0:
return 0

# calculate the weighted avg. entropy of

children n = len(y)
n_l, n_r = len(left_idxs), len(right_idxs)
e_l, e_r = self._entropy(y[left_idxs]), self._entropy(y[right_idxs])
child_entropy = (n_l/n) * e_l + (n_r/n) * e_r

# calculate the IG
information_gain = parent_entropy -
child_entropy return information_gain

def _split(self, X_column, split_thresh):

left_idxs = np.argwhere(X_column <=
split_thresh).flatten() right_idxs = np.argwhere(X_column >
split_thresh).flatten() return left_idxs, right_idxs

def _entropy(self, y):

hist = np.bincount(y)
ps = hist / len(y)
return -np.sum([p * np.log(p) for p in ps if p>0])

def _most_common_label(self, y):

counter = Counter(y)
value = counter.most_common(1)[0][0]
return value

def predict(self, X):

return np.array([self._traverse_tree(x, self.root) for x in X])

def _traverse_tree(self, x,
node): if
node.is_leaf_node():
return node.value

if x[node.feature] <= node.threshold:

return self._traverse_tree(x, node.left)
return self._traverse_tree(x, node.right)
 42

Train data.py

from sklearn import datasets

from sklearn.model_selection import train_test_split
import numpy as np
from DecisionTree import DecisionTree

data = datasets.load_breast_cancer()
X, y = data.data, data.target

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=1234
)

clf =
DecisionTree(max_depth=10)
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)

def accuracy(y_test, y_pred):

return np.sum(y_test == y_pred) / len(y_test)

acc = accuracy(y_test,
predictions) print(acc)
 43

OUTPUT:

RESULT :

Thus the implementation of decision trees using python is executed successfully

 44

Ex. No : 6 b) Date: Build random forests

AIM :

To implement random forests using python

ALGORITHM:
 Importing the libraries
 Importing the datasets
 Splitting the dataset into the Training set and Test set
 Feature Scaling
 Fitting the classifier into the Training set
 Predicting the test set results
 Making the Confusion Matrix
 Visualising the Training set results

PROGRAM:

# Random Forest

Classifier # Importing the

libraries import numpy as

np
import matplotlib.pyplot as plt
import pandas as pd

# Importing the datasets

datasets = pd.read_csv('Social_Network_Ads.csv')
X = datasets.iloc[:, [2,3]].values
Y = datasets.iloc[:, 4].values

# Splitting the dataset into the Training set and Test set

from sklearn.model_selection import train_test_split

X_Train, X_Test, Y_Train, Y_Test = train_test_split(X, Y, test_size = 0.25, random_state = 0)

# Feature Scaling

from sklearn.preprocessing import

StandardScaler sc_X = StandardScaler()
X_Train = sc_X.fit_transform(X_Train)
X_Test = sc_X.transform(X_Test)

# Fitting the classifier into the Training set

from sklearn.ensemble import RandomForestClassifier

 45
classifier = RandomForestClassifier(n_estimators = 200, criterion = 'entropy', random_state = 0)
 46

classifier.fit(X_Train,Y_Train)

# Predicting the test set results

Y_Pred = classifier.predict(X_Test)

# Making the Confusion Matrix

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(Y_Test, Y_Pred)

# Visualising the Training set results

from matplotlib.colors import ListedColormap

X_Set, Y_Set = X_Train, Y_Train
X1, X2 = np.meshgrid(np.arange(start = X_Set[:, 0].min() - 1, stop = X_Set[:, 0].max() + 1, step
= 0.01),
np.arange(start = X_Set[:, 1].min() - 1, stop = X_Set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(Y_Set)):
plt.scatter(X_Set[Y_Set == j, 0], X_Set[Y_Set == j,
1],
c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('Random Forest Classifier (Training set)')
plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()

# Visualising the Test set results

from matplotlib.colors import ListedColormap

X_Set, Y_Set = X_Test, Y_Test
X1, X2 = np.meshgrid(np.arange(start = X_Set[:, 0].min() - 1, stop = X_Set[:, 0].max() + 1, step
= 0.01),
np.arange(start = X_Set[:, 1].min() - 1, stop = X_Set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(Y_Set)):
plt.scatter(X_Set[Y_Set == j, 0], X_Set[Y_Set == j,
1],
c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('Random Forest Classifier (Test set)')
 47

plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()
 48

OUTPUT:

RESULT :

Thus the implementation of random forest using python is executed successfully

 49

Ex. No : 7 Build SVM models

Date:

AIM :

To implement SVM models using python

ALGORITHM:
 Importing the libraries
 Importing the datasets
 Splitting the dataset into the Training set and Test set
 Fitting the classifier into the Training set
 Predicting the test set results
 Making the Confusion Matrix
 Visualising the Training set results

PROGRAM:

# Support Vector Machine

# Importing the libraries

import numpy as np
import matplotlib.pyplot as
plt import pandas as pd

# Importing the datasets

datasets = pd.read_csv('Social_Network_Ads.csv')
X = datasets.iloc[:, [2,3]].values
Y = datasets.iloc[:, 4].values

# Splitting the dataset into the Training set and Test set

from sklearn.model_selection import train_test_split

X_Train, X_Test, Y_Train, Y_Test = train_test_split(X, Y, test_size = 0.25, random_state = 0)

# Feature Scaling

from sklearn.preprocessing import

StandardScaler sc_X = StandardScaler()
X_Train = sc_X.fit_transform(X_Train)
X_Test = sc_X.transform(X_Test)

# Fitting the classifier into the Training set

 50

from sklearn.svm import SVC

classifier = SVC(kernel = 'linear', random_state = 0)
classifier.fit(X_Train, Y_Train)

# Predicting the test set results

Y_Pred = classifier.predict(X_Test)

# Making the Confusion Matrix

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(Y_Test, Y_Pred)

# Visualising the Training set results

from matplotlib.colors import ListedColormap

X_Set, Y_Set = X_Train, Y_Train
X1, X2 = np.meshgrid(np.arange(start = X_Set[:, 0].min() - 1, stop = X_Set[:, 0].max() + 1, step
= 0.01),
np.arange(start = X_Set[:, 1].min() - 1, stop = X_Set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(Y_Set)):
plt.scatter(X_Set[Y_Set == j, 0], X_Set[Y_Set == j,
1],
c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('Support Vector Machine (Training set)')
plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()

# Visualising the Test set results

from matplotlib.colors import ListedColormap

X_Set, Y_Set = X_Test, Y_Test
X1, X2 = np.meshgrid(np.arange(start = X_Set[:, 0].min() - 1, stop = X_Set[:, 0].max() + 1, step
= 0.01),
np.arange(start = X_Set[:, 1].min() - 1, stop = X_Set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(Y_Set)):
 51

plt.scatter(X_Set[Y_Set == j, 0], X_Set[Y_Set == j,

1], c = ListedColormap(('red', 'green'))(i), label
= j)
plt.title('Support Vector Machine (Test
set)') plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()
 52

OUTPUT:

RESULT :

Thus the implementation of SVM models using python is executed successfully

 53

Ex. No : 8 Implement ensembling techniques

Date:

AIM :

To implement ensembling techniques using python

ALGORITHM:
 importing utility modules
 importing machine learning models for prediction importing train test split
 loading train data set in dataframe from train_data.csv file getting target data from
the dataframe
 target = df["target"] getting train data from the dataframe
 Splitting between train data into training and validation dataset performing the
train test and validation split
 performing train test split performing test validation split
 initializing all the base model objects with default parameters training all the model on
the train dataset
 training first model converting to dataframe training second model converting to
dataframe training third model converting to dataframe
 concatenating validation dataset along with all the predicted validation data (meta
features) making the final model using the meta features
 getting the final output
 printing the mean squared error

PROGRAM:

Type : Blending

# importing utility
modules import pandas as
pd
from sklearn.metrics import mean_squared_error

# importing machine learning models for prediction

from sklearn.ensemble import RandomForestRegressor
import xgboost as xgb
from sklearn.linear_model import LinearRegression

# importing train test split

from sklearn.model_selection import train_test_split

# loading train data set in dataframe from train_data.csv

file df = pd.read_csv("train_data.csv")

# getting target data from the

dataframe target = df["target"]
 54

# getting train data from the

dataframe train = df.drop("target")

#Splitting between train data into training and validation dataset

X_train, X_test, y_train, y_test = train_test_split(train, target, test_size=0.20)

# performing the train test and validation

split train_ratio = 0.70
validation_ratio = 0.20
test_ratio = 0.10

# performing train test split

x_train, x_test, y_train, y_test = train_test_split(
train, target, test_size=1 - train_ratio)

# performing test validation split

x_val, x_test, y_val, y_test = train_test_split(
x_test, y_test, test_size=test_ratio/(test_ratio + validation_ratio))

# initializing all the base model objects with default parameters

model_1 = LinearRegression()
model_2 = xgb.XGBRegressor()
model_3 = RandomForestRegressor()

# training all the model on the train

dataset # training first model

model_1.fit(x_train, y_train)
val_pred_1 = model_1.predict(x_val)
test_pred_1 = model_1.predict(x_test)

# converting to dataframe
val_pred_1 = pd.DataFrame(val_pred_1)
test_pred_1 =
pd.DataFrame(test_pred_1)
# training second model
model_2.fit(x_train, y_train)
val_pred_2 = model_2.predict(x_val)
test_pred_2 = model_2.predict(x_test)

# converting to dataframe
val_pred_2 = pd.DataFrame(val_pred_2)
test_pred_2 = pd.DataFrame(test_pred_2)

# training third model

model_3.fit(x_train, y_train)
val_pred_3 = model_1.predict(x_val)
test_pred_3 = model_1.predict(x_test)
 55

# converting to dataframe
val_pred_3 = pd.DataFrame(val_pred_3)
test_pred_3 =
pd.DataFrame(test_pred_3)

# concatenating validation dataset along with all the predicted validation data (meta features)
df_val = pd.concat([x_val, val_pred_1, val_pred_2, val_pred_3], axis=1)
df_test = pd.concat([x_test, test_pred_1, test_pred_2, test_pred_3], axis=1)

# making the final model using the meta

features final_model = LinearRegression()
final_model.fit(df_val, y_val)

# getting the final output

final_pred = final_model.predict(df_test)

#printing the mean squared error between real value and predicted value
print(mean_squared_error(y_test, pred_final))

OUTPUT :

4790

Type : Stacking

# importing utility
modules import pandas as
pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# importing machine learning models for prediction

from sklearn.ensemble import RandomForestRegressor
import xgboost as xgb
from sklearn.linear_model import LinearRegression

# importing stacking lib

from vecstack import stacking

# loading train data set in dataframe from train_data.csv

file df = pd.read_csv("train_data.csv")

# getting target data from the

dataframe target = df["target"]

# getting train data from the

dataframe train = df.drop("target")

# Splitting between train data into training and validation dataset

X_train, X_test, y_train, y_test = train_test_split(
 56
train, target, test_size=0.20)
 57

# initializing all the base model objects with default parameters

model_1 = LinearRegression()
model_2 = xgb.XGBRegressor()
model_3 = RandomForestRegressor()

# putting all base model objects in one list

all_models = [model_1, model_2,
model_3]

# computing the stack features

s_train, s_test = stacking(all_models, X_train, X_test,
y_train, regression=True, n_folds=4)

# initializing the second-level

model final_model = model_1

# fitting the second level model with stack features

final_model = final_model.fit(s_train, y_train)

# predicting the final output using

stacking pred_final =
final_model.predict(X_test)

# printing the mean squared error between real value and predicted
value print(mean_squared_error(y_test, pred_final))
 58

OUTPUT :
4510

RESULT :

Thus the implementation ensembling techniques using python is executed successfully

 59

Ex. No : 9 Implement clustering algorithms

Date:

AIM :

To implement clustering algorithms using python

ALGORITHM:

 Randomly select 'c' cluster centers.

 Calculate the distance between each data point and cluster centers.
 Assign the data point to the cluster center whose distance from the cluster center
is minimum of all the cluster centers.

PROGRAM:

Type 1:

from sklearn.cluster import

KMeans import numpy as np
X = np.array([[1.713,1.586], [0.180,1.786], [0.353,1.240],
[0.940,1.566], [1.486,0.759], [1.266,1.106],[1.540,0.419],[0.459,1.799],
[0.773,0.186]]) y=np.array([0,1,1,0,1,0,1,1,1])
kmeans = KMeans(n_clusters=3, random_state=0).fit(X,y)
print("The input data is ")
print("VAR1 \t VAR2 \t
CLASS") i=0
for val in X: print(val[0],"\
t",val[1],"\t",y[i]) i+=1
print("="*20)
# To get test data from the user
print("The Test data to predict
") test_data = []
VAR1 = float(input("Enter Value for VAR1
:")) VAR2 = float(input("Enter Value for
VAR2 :")) test_data.append(VAR1)
test_data.append(VAR2)
print("="*20)
print("The predicted Class is : ",kmeans.predict([test_data]))
 60

TYPE 2:

import matplotlib.pyplot as
plt from sklearn import
datasets
from sklearn.cluster import
KMeans import pandas as pd
import numpy as np
# import some data to play with iris = datasets.load_iris()
X = pd.DataFrame(iris.data)
X.columns = ['Sepal_Length','Sepal_Width','Petal_Length','Petal_Width']
y = pd.DataFrame(iris.target)
y.columns = ['Targets']
# Build the K Means Model model = KMeans(n_clusters=3)
model.fit(X) # model.labels_ : Gives cluster no for which samples belongs to

# # Visualise the clustering results plt.figure(figsize=(14,14))

colormap = np.array(['red', 'lime', 'black'])
# Plot the Original Classifications using Petal features plt.subplot(2, 2, 1)
plt.scatter(X.Petal_Length, X.Petal_Width, c=colormap[y.Targets],
 61
s=40) plt.title('Real Clusters')
 62

plt.xlabel('Petal Length')
plt.ylabel('Petal Width')
# Plot the Models Classifications plt.subplot(2, 2, 2)
plt.scatter(X.Petal_Length, X.Petal_Width, c=colormap[model.labels_],
s=40) plt.title('K-Means Clustering')
plt.xlabel('Petal Length')
plt.ylabel('Petal Width')
# General EM for
GMM
from sklearn import preprocessing
# transform your data such that its distribution will have a # mean value 0 and standard deviation
of 1.
scaler = preprocessing.StandardScaler()
scaler.fit(X)
xsa = scaler.transform(X)
xs = pd.DataFrame(xsa, columns =
X.columns) from sklearn.mixture import
GaussianMixture gmm =
GaussianMixture(n_components=3)
gmm.fit(xs)
gmm_y =
gmm.predict(xs)
plt.subplot(2, 2, 3)
plt.scatter(X.Petal_Length, X.Petal_Width, c=colormap[gmm_y], s=40)
plt.title('GMM Clustering')
plt.xlabel('Petal Length')
plt.ylabel('Petal Width')
print('Observation: The GMM using EM algorithm based clustering matched the true labels more
closely than the Kmeans.')
 63

OUTPUT:

RESULT :

Thus the implementation of clustering algorithms using python is executed successfully

 64

Ex. No : 10 Implement EM for Bayesian networks

Date:

AIM :

To implement EM for Bayesian networks using python

ALGORITHM:

 load and display an image with Matplotlib

 calculate f(e^f) in order to use logsumexp trick and avoid
underflow/overflow find max of all fk(trick[k]) for each
example

 counter in order to count iterations and stop after some in order our program doesn't run
for an eternity
 check if algorithm is correct
 check if the convergence criterion is met
 update 'safety valve' in order to not loop for
an eternity calculate error
 load image as pixel array
summarize shape of the
pixel array
 display the array of pixels as
an image normalize data

PROGRAM:

from PIL import

Image import numpy
as np
# load and display an image with
Matplotlib from matplotlib import image
from matplotlib import
pyplot import time

# calculate f(e^f) in order to use logsumexp trick and avoid

underflow/overflow def f_logsumexp(x, mean, var, pi):
N = x.shape[0]
K = mean.shape[0]
trick = np.zeros((N,
K)) for k in range(K):
 65

subtraction = np.subtract(x, mean[k])

arg1 = -1.0 / (2 * var[k]) * np.power(subtraction,
2) arg2 = -0.5*np.log(2*np.pi*var[k])
arg3 = np.sum(arg2 + arg1, axis=1) # before sum 1xD -> 1x1
arithmitis = np.log(pi[k]) + arg3
trick[:, k] = arithmitis
# find max of all fk(trick[k]) for each
example m = trick.max(axis=1) # Nx1
m = m.reshape((m.shape[0],
1)) return trick, m

# N -> number of
examples # K -> number
of clusters def
update_gamma(f, m):
f = f-m
f = np.exp(f) # NxK
par = np.sum(f, axis=1) # Nx1
par = par.reshape((par.shape[0],1))
result = np.divide(f, par) # NxK
return result

# return matrix with dimensions

KxD def update_mean(gamma, x):
arith = np.dot(np.transpose(gamma), x) # (KxN)*(NxD)-> KxD
paran = np.sum(gamma, axis=0) # Kx1
paran = paran.reshape((paran.shape[0], 1))
result = arith/paran # KxD
return result

# return vector with dimensions 1xK

def update_variance(gamma, x,
mean):
D = x.shape[1]
K = mean.shape[0]
arith = np.zeros((K, 1))
for k in range(K):
gamma_k = gamma[:, k]
gamma_k = gamma_k.reshape((gamma_k.shape[0], 1))
subtraction = np.subtract(x, mean[k]) # NxD
# ((Nx1).*(NxD)-> NxD->sum row wise -> 1xN -> sum -> 1x1
sub = np.sum(np.sum(np.multiply(np.power(subtraction, 2), gamma_k), axis=1))
arith[k] = sub
paran = D * np.sum(gamma, axis=0) # Kx1
paran = paran.reshape((K, 1)) # Kx1
 66

return arith/paran

def update_loglikehood(f,
m): f = f - m # NxK
arg1 = np.sum(np.exp(f), axis=1) #
Nx1 arg1 = np.log(arg1) # Nx1
arg1 = arg1.reshape((arg1.shape[0], 1))
arg2 = arg1+m
return np.sum(arg2, axis=0) # 1x1

def init_parameters(D, K):

mean = np.random.rand(K, D)
var = np.random.uniform(low=0.1, high=1, size=K) # Kx1
val = 1/K
pi = np.full(K, val) #
Kx1 return mean, var, pi

# pi is not np.pi = 3.14.....is a different variable

def EM(x, K, tol):
# counter in order to count iterations and stop after some in order our program doesn't run for
an eternity
counter = 1
# num of examples(Here
pixels) N = x.shape[0]
# num of dimensions of each examples(Here RGB
canals) D = x.shape[1]
# init parameters
mean, var, pi = init_parameters(D,
K) # logsumexp trick
f, m = f_logsumexp(x, mean, var, pi)
loglikehood = update_loglikehood(f,
m) while counter <= 400:
print('Iteration: ', counter)
# E-step
gamma = update_gamma(f, m) #
NxK # M-step
# update pi
pi = (np.sum(gamma,
axis=0))/N # update mean
mean = update_mean(gamma,
x) # update variance(var)
var = update_variance(gamma, x,
mean) old_loglikehood = loglikehood
 67

# logsumexp trick
f, m = f_logsumexp(x, mean, var, pi)
loglikehood = update_loglikehood(f,
m) # check if algorithm is correct
if loglikehood-old_loglikehood < 0:
print('Error found in EM algorithm')
print('Number of iterations: ',
counter) exit()
# check if the convergence criterion is
met if abs(loglikehood-old_loglikehood)
< tol: print('Convergence criterion is
met')
print('Total iterations: ',
counter) return mean, gamma
# update 'safety valve' in order to not loop for an eternity
counter += 1
return mean, gamma

def error_reconstruction(x,
means_of_data): N = x.shape[0]
x = x*255
x = x.astype(np.uint8)
diff = x-means_of_data
sum1 = np.sqrt(np.sum(np.power(diff,
2))) error = sum1/N
return error

def reconstruct_image(x, mean, gamma,

K): D = mean.shape[1]
# denormalize values
mean = mean * 255
# set data-type uint8 so every data is in set
[0,255] mean = mean.astype(np.uint8)
max_likelihood = np.argmax(gamma, axis=1) # 1xN
# matrix that has for each example(pixel) the means of dimensions(R,G,B) of k(=cluster) with
highest
# a posteriori probability gamma. This matrix is our new data(pixels)
means_of_data = np.array([mean[i] for i in max_likelihood]) # NxD
# set data-type uint8 so every data is in set [0,255]
means_of_data = means_of_data.astype(np.uint8)
# calculate error
error = error_reconstruction(x, means_of_data)
print('Error of reconstruction:', error)
means_of_data = means_of_data.reshape((height, width, D))
segmented_image = Image.fromarray(means_of_data, mode='RGB')
 68

name = 'Segmented_Images\segmented_image_'+str(K)+'.jpg'
segmented_image.save(name)

def run(x, cluster,

tol): for K in
cluster:
print('------ Cluster: '+str(K)+'------')
start_time = time.time()
mean, gamma = EM(x, K,
tol) end_time = time.time()
em_time = end_time-start_time
print("Time of execution of EM for clusters/k = %s is %s seconds " % (K, em_time))
reconstruct_image(x, mean, gamma, K)
tolerance = 1e-6
clusters = [1, 2, 4, 8, 16, 32, 64]
path = 'Image\im.jpg'
# load image as pixel array
data = image.imread(path)
data = np.asarray(data)
# summarize shape of the pixel array
print("Dimensions of image: ",
data.shape) (height, width, d) =
data.shape
max_value = np.amax(data)
# display the array of pixels as an
image pyplot.imshow(data)
pyplot.show()
# N = number of data set (Here height*width of
image) # D = dimensions of each data (Here R,G,B)
dataset = data.reshape((height*width, d)) # NxD
# normalize data
dataset = dataset/max_value
run(dataset, clusters,
tolerance)
 69

Input: Output:

RESULT :

Thus the implementation of EM for Bayesian networks using python is executed successfully
 70

Ex. No : 11 Build simple NN models

Date:

AIM :

To implement NN models using python

ALGORITHM:

 Create an approximation model.

 Configure data set.
 Set network architecture.
 Train neural network.
 Improve generalization performance.
 Test results.

PROGRAM:

import numpy as np

class NeuralNetwork():

def init (self):

# seeding for random number generation
np.random.seed(1)

#converting weights to a 3 by 1 matrix with values from -1 to 1 and mean of 0

self.synaptic_weights = 2 * np.random.random((3, 1)) - 1

def sigmoid(self, x):

#applying the sigmoid
function return 1 / (1 +
np.exp(-x))

def sigmoid_derivative(self, x):

#computing derivative to the Sigmoid
function return x * (1 - x)

def train(self, training_inputs, training_outputs, training_iterations):

#training the model to make accurate predictions while adjusting weights continually
for iteration in range(training_iterations):
#siphon the training data via the neuron
output = self.think(training_inputs)
 71

#computing error rate for back-

propagation error = training_outputs -
output
 72

#performing weight adjustments

adjustments = np.dot(training_inputs.T, error * self.sigmoid_derivative(output))

self.synaptic_weights += adjustments

def think(self, inputs):

#passing the inputs via the neuron to get
output #converting values to floats

inputs = inputs.astype(float)
output = self.sigmoid(np.dot(inputs, self.synaptic_weights))
return output

if name == " main ":

#initializing the neuron class

neural_network =
NeuralNetwork()

print("Beginning Randomly Generated Weights:

") print(neural_network.synaptic_weights)

#training data consisting of 4 examples--3 input values and 1 output

training_inputs = np.array([[0,0,1],
[1,1,1],
[1,0,1],
[0,1,1]])

training_outputs =

np.array([[0,1,1,0]]).T #training taking

place
neural_network.train(training_inputs, training_outputs, 15000)

print("Ending Weights After Training:

")
print(neural_network.synaptic_weights)

user_input_one = str(input("User Input One: "))

user_input_two = str(input("User Input Two: "))
user_input_three = str(input("User Input Three:
"))

print("Considering New Situation: ", user_input_one, user_input_two, user_input_three)

print("New Output data: ")
print(neural_network.think(np.array([user_input_one, user_input_two, user_input_three])))
print("Wow, we did it!")
 73

output

Type 2:

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=7000 #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 #Forward Propagation
for i in range(epoch):
hinp1=np.dot(X,wh)
 74

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)
hiddengrad = derivatives_sigmoid(hlayer_act) #how much hidden layer wts contributed to error
d_hiddenlayer = EH * hiddengrad
wout += hlayer_act.T.dot(d_output) *lr
# dotproduct of nextlayererror and currentlayerop
bout += np.sum(d_output, axis=0,keepdims=True)
*lr wh += X.T.dot(d_hiddenlayer) *lr
#bh += np.sum(d_hiddenlayer, axis=0,keepdims=True) *lr
print("Input: \n" + str(X))
print("Actual Output: \n" + str(y))
print("Predicted Output: \n"
,output)
 75

output
 76

RESULT :

Thus the implementation of NN models using python is executed successfully

 77

Ex. No : 12 Build deep learning NN models

Date:

AIM :

To implement deep learning NN models using python

Algorithm:

Step 1: Initialize the weights and

biases Step 2: Forward propagation
module Step 3: Define the cost
function
Step 4: Set Back propagation
Step 5: Update parameters with gradient descent

Program:
import time
import numpy as
np import h5py
import matplotlib.pyplot as plt import
scipy
from PIL import Image from
scipy import ndimage
def initialize_parameters_deep(layer_dims):
# 0th layer is the input layer with number # of
columns stored in layer_dims. parameters = {}

# number of layers in the network L =

len(layer_dims)

for l in range(1, L):

parameters['W' + str(l)] = np.random.randn(layer_dims[l],
layer_dims[l - 1])*0.01 parameters['b' +
str(l)] = np.zeros((layer_dims[l], 1))

return parameters
def linear_forward(A_prev, W, b):

# cache is stored to be used in backward propagation module Z

= np.dot(W, A_prev) + b
cache = (A, W, b)
return Z, cache
def sigmoid(Z):

A = 1/(1 + np.exp(-Z))
return A, {'Z' : Z} def

tanh(Z):
 78

A = np.tanh(Z) return A,
{'Z' : Z}

def linear_activation_forward(A_prev, W, b, activation):

# cache is stored to be used in backward propagation module if activation
== "sigmoid":
Z, linear_cache = linear_forward(A_prev, W, b) A,
activation_cache = sigmoid(Z)
elif activation == "tanh":
Z, linear_cache = linear_forward(A_prev, W, b) A,
activation_cache = tanh(Z)
cache = (linear_cache, activation_cache)

return A, cache
def L_model_forward(X, parameters):
""" Arguments:
X -- data, numpy array of shape (input size, number of examples) parameters --
output of initialize_parameters_deep()

Returns:
AL -- last post-activation value caches --
list of caches containing:
every cache of linear_activation_forward() (there
are L-1 of them, indexed from 0 to L-1)
"""

caches = []
A=X

# number of layers in the neural network L =

len(parameters) // 2

# Implement [LINEAR -> TANH]*(L-1). Add "cache" to the "caches" list. for l in
range(1, L):
A_prev = A
A, cache = linear_activation_forward(A_prev,
parameters['W' + str(l)],
parameters['b' + str(l)], 'tanh')

caches.append(cache)

# Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list. AL, cache =
linear_activation_forward(A, parameters['W' + str(L)],
parameters['b' + str(L)], 'sigmoid')
caches.append(cache)

return AL, caches def

compute_cost(AL, Y):
"""
Implement the cost function defined by the equation. m =
 79

Y.shape[1]
cost = (-1 / m)*(np.dot(np.log(AL), Y.T)+np.dot(np.log((1-AL)), (1 - Y).T))

# To make sure your cost's shape is what we #

expect (e.g. this turns [[20]] into 20).
cost = np.squeeze(cost)

return cost
def linear_backward(dZ, cache):

A_prev, W, b = cache m
= A_prev.shape[1]
dW = (1 / m)*np.dot(dZ, A_prev.T)
db = (1 / m)*np.sum(dZ, axis = 1, keepdims = True) dA_prev
= np.dot(W.T, dZ)

return dA_prev, dW, db

def sigmoid_backward(dA, activation_cache):

Z = activation_cache['Z'] A =
sigmoid(Z)
return dA * (A*(1 - A)) # A*(1 - A) is the derivative of sigmoid

function def tanh_backward(dA, activation_cache): Z =

activation_cache['Z']
A = sigmoid(Z)
return dA * (1 -np.power(A, 2)) #
A*(1 -
def L_model_backward(AL, Y, caches): """
AL -- probability vector, output of the forward propagation (L_model_forward())
Y -- true "label" vector (containing 0 if non-cat, 1 if cat) caches -- list of
caches containing:
every cache of linear_activation_forward() with "tanh" (it's caches[l],
for l in range(L-1) i.e l = 0...L-2) the cache of
linear_activation_forward() with "sigmoid"
(it's caches[L-1])

Returns:
grads -- A dictionary with the gradients
grads["dA" + str(l)] = ...
grads["dW" + str(l)] = ...
grads["db" + str(l)] = ...
"""
grads = {}
L = len(caches) # the number of layers m
= AL.shape[1]
Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL

# Initializing the backpropagation

# derivative of cost with respect to AL
 80

dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))

# Lth layer (SIGMOID -> LINEAR) gradients. Inputs: "dAL, current_cache". #

Outputs: "grads["dAL-1"], grads["dWL"], grads["dbL"]
current_cache = caches[L - 1]
grads["dA" + str(L-1)], grads["dW" + str(L)], grads["db" + str(L)] = \
linear_activation_backward(dAL, current_cache,
'sigmoid')

# Loop from l = L-2 to l = 0 for l

in reversed(range(L-1)):
current_cache = caches[l]
dA_prev_temp, dW_temp, db_temp = linear_activation_backward( grads['dA' + str(l
+ 1)], current_cache, 'tanh')
grads["dA" + str(l)] = dA_prev_temp
grads["dW" + str(l + 1)] = dW_temp
grads["db" + str(l + 1)] = db_temp

return grads
def update_parameters(parameters, grads, learning_rate):
L = len(parameters) // 2 # number of layers in the neural network

# Update rule for each parameter. Use a for loop. for l

in range(L):
parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate *
grads['dW' + str(l + 1)]
parameters["b" + str(l + 1)] = parameters['b' + str(l + 1)] - learning_rate * grads['db'
+ str(l + 1)]

return parameters
def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations
= 3000, print_cost = False): """
Arguments:
X -- data, numpy array of shape (num_px * num_px * 3, number of examples)
Y -- true "label" vector (containing 0 if cat, 1 if non-cat),
of shape (1, number of examples) layers_dims --
list containing the input size and each layer size,
of length (number of layers + 1). learning_rate
-- learning rate of the gradient descent update rule num_iterations -- number of iterations
of the optimization loop print_cost -- if True, it prints the cost every 100 steps

Returns:
parameters -- parameters learned by the model. They can then be used to predict.
"""

np.random.seed(1)
costs = [] # keep track of cost

parameters = initialize_parameters_deep(layers_dims)

# Loop (gradient descent)

 81

for i in range(0, num_iterations):

# Forward propagation: [LINEAR -> TANH]*(L-1) -> LINEAR -> SIGMOID. AL,
caches = L_model_forward(X, parameters)
# Compute cost.
cost = compute_cost(AL, Y)

# Backward propagation.
grads = L_model_backward(AL, Y, caches)

# Update parameters.
parameters = update_parameters(parameters, grads, learning_rate)

# Print the cost every 100 training example

if print_cost and i % 100 == 0:
print ("Cost after iteration % i: % f" %(i, cost)) if print_cost and
i % 100 == 0:
costs.append(cost)

# plot the cost

plt.plot(np.squeeze(costs))
plt.ylabel('cost') plt.xlabel('iterations (per
hundreds)')
plt.title("Learning rate =" + str(learning_rate)) plt.show()

return parameters
def predict(parameters, path_image):

my_image = path_image
image = np.array(ndimage.imread(my_image, flatten = False)) my_image =
scipy.misc.imresize(image,
size =(num_px, num_px)).reshape(( num_px
* num_px * 3, 1))

my_image = my_image / 255.

output, cache = L_model_forward(my_image, parameters) output =
np.squeeze(output)
prediction = round(output)
if(prediction == 1):
label = "Cat picture" else:
label = "Non-Cat picture" # If the model is trained to recognize a cat
image. print ("y = " + str(prediction) + ", your L-layer model predicts a \"" + label)

#Provided layers_dims = [12288, 20, 7, 5, 1] when this model is trained with an appropriate
amount of training dataset it is up to 80% accurate on test data.
The parameters are found after training with an appropriate amount of training dataset. #

{'W1': array([[ 0.01672799, -0.00641608, -0.00338875, ..., -0.00685887,

-0.00593783, 0.01060475],
[ 0.01395808, 0.00407498, -0.0049068, ..., 0.01317046,
0.00221326, 0.00930175],
 82
[-0.00123843, -0.00597204, 0.00472214, ..., 0.00101904,
 83

-0.00862638, -0.00505112],
...,
[ 0.00140823, -0.00137711, 0.0163992, ..., -0.00846451,
-0.00761603, -0.00149162],
[-0.00168698, -0.00618577, -0.01023935, ..., 0.02050705,
-0.00428185, 0.00149319],
[-0.01770891, -0.0067836, 0.00756873, ..., 0.01730701,
0.01297081, -0.00322241]]), 'b1': array([[ 3.85542520e-03], [
8.18087056e-03],
[ 6.52138546e-03], [
2.85633678e-03], [
6.01081275e-03], [
8.17122684e-04], [
3.72986493e-04], [
7.05992009e-04], [
4.36344692e-04], [
1.90827285e-03], [ -
6.51686461e-03], [
6.97258125e-03], [ -
1.08988113e-03], [
5.40858776e-03], [
8.16752511e-03], [ -
1.05298871e-02],
[ -9.05267219e-05],
[ -5.13240993e-04], [
1.42355924e-03],
[ -2.40912130e-03]]), 'W2': array([[ 2.02109232e-01, -3.08645240e- 01, -
3.77620591e-01,
-4.02563039e-02, 5.90753267e-02, 1.23345558e-01,
3.08047246e-01, 4.71201576e-02, 5.29892230e-02,
1.34732883e-01, 2.15804697e-01, -6.34295948e-01,
-1.56081006e-01, 1.01905466e-01, -1.50584386e-01,
5.31219819e-02, 1.14257132e-01, 4.20697960e-01,
1.08551174e-01, -2.18735332e-01],
[ 3.57091131e-01, -1.40997155e-01, 3.70857247e-01,
2.53207014e-01, -1.12596978e-01, -3.15179195e-01,
-2.48100731e-01, 4.72723584e-01, -7.71870940e-02,
5.39834663e-01, -1.17927181e-02, 6.45463019e-02,
2.73704423e-02, 4.30157714e-01, 1.59318390e-01,
-6.48089126e-01, -1.71894333e-01, 1.77933527e-01,
1.54736463e-01, -7.26815274e-02],
[ 2.96501527e-01, 2.43056424e-01, -1.22400000e-02,
2.69275366e-02, 3.76041647e-01, -1.70245407e-01,
-2.95343754e-02, -7.35716150e-02, -1.80179693e-01,
-5.77515859e-03, -6.38323383e-01, 6.94950669e-02,
7.66137263e-02, 3.66599261e-01, 5.40904716e-02,
-1.51814996e-01, -2.61672559e-01, 1.35946854e-01,
4.21086332e-01, -2.71073484e-01],
[ 1.42186042e-01, -2.66789439e-01, 4.57188131e-01,
2.84732743e-02, -5.49143391e-02, -3.96786581e-02,
-1.68668726e-01, -1.46525541e-01, 3.25325993e-03,
-1.13045329e-01, 4.03935681e-01, -3.92214264e-01,
5.25325051e-04, -3.69642647e-01, -1.15812921e-01,
 84

1.32695899e-01, 3.20810624e-01, 1.88127350e-01,

-4.82784806e-02, -1.48816756e-01],
[ -1.65469406e-01, 4.24741323e-01, -5.76900900e-01,
1.58084434e-01, -2.90965849e-01, 3.40124014e-02,
-2.62189635e-01, 2.66917709e-01, 4.77530579e-01,
-1.73491365e-01, -1.48434710e-01, -6.91270097e-02,
5.42923817e-03, -2.85173244e-01, 6.40701002e-02,
-7.33126171e-02, 1.43543481e-01, 7.82250247e-02,
-1.47535352e-01, -3.99073661e-01],
[ -2.05468389e-01, 1.66914752e-01, 2.15918881e-01,
2.21774761e-01, 2.52527888e-01, 2.64464223e-01,
-3.07796263e-02, 3.45835418e-01,
-3.47687682e-01, 9.13383273e-02,
1.05973413e-01, 2.22363710e-01,
3.97150339e-02, -3.03701358e-01,
-9.70224337e-02,
-3.93921988e-01,
1.40075127e-01, -2.39537245e-01, -4.06133490e-01,
2.06819296e-01, 8.95374287e-02, -3.27700300e-01,
[ 5.92692802e-02,
-6.13447906e-01, 1.89927573e-01,
-6.89856027e-02,
-1.42814095e-01, 1.77958823e-03, -1.34407806e-01,
9.34036862e-02, -2.00549616e-02, 9.01789763e-02,
3.81627943e-01, -1.76566228e-02,
9.28388267e-02, -1.16167106e-01]]), 'b2': array([[-0.00088887],
[ 0.02357712],
[ 0.01858614],
[-0.00567557],
[ 0.00636179],
[ 0.02362429],
[-0.00173074]]), 'W3': array([[ 0.20939786, 0.21977478, 0.77135171,
-1.07520777, -0.64307173,
-0.24097649, -0.15626735],
[-0.57997618, 0.30851841, -0.03802324, -0.13489975, 0.23488207,
0.76248961, -0.34515092],
[ 0.15990295, 0.5163969, 0.15284381, 0.42790606, -0.05980168,
0.87865156, -0.01031899],
[ 0.52908282, 0.93882471, 1.23044256, -0.01481286, 0.41024244,
0.18731983, -0.01414658],
[-0.96753783, -0.30492002, 0.54060558, -0.18776932, -0.39245146,
0.20654634, -0.58863038]]), 'b3': array([[ 0.8623361 ],
[-0.00826002],
[-0.01151116],
[-0.06844291],
[-0.00833715]]), 'W4': array([[-0.83045967, 0.18418824,
0.85885352, 1.41024115, 0.12713131]]), 'b4': array([[-1.73123633]])}

my_image = "https://www.pexels.com / photo / adorable-animal-blur-cat- 617278/"

predict(parameters, my_image)
 85

Output with learnt parameters:

y = 1, your L-layer model predicts a Cat picture.

RESULT :

Thus the implementation of deep learning NN models using python is executed successfully.