Ex No: 1
Date :
IMPLEMENTATION OF UNINFORMED
SEARCH ALGORITHMS
Aim : To Implement the uninformed search algorithms using the python program.
A) BFS:
Algorithm :
Step 1 : Start.
Step 2 : Initialize an empty queue and mark all vertices as unvisited.
Step 3 : Add the starting vertex to the queue and mark it as visited.
Step 4 : While the queue is not empty:
Dequeue the next vertex from the queue.
For each adjacent vertex that is not visited, mark it as visited
and add it to the queue.
Step 5 : Repeat step 3 until the queue is empty.
Step 6 : Exit.
Program :
class Graph:
def _init_(self, vertices):
self.V = vertices
self.adj = [[] for i in range(vertices)]
def add_edge(self, u, v):
self.adj[u].append(v)
def bfs(self, start):
visited = [False] * self.V
queue = []
queue.append(start)
visited[start] = True
while queue:
node = queue.pop(0)
print(node, end=" ")
for neighbor in self.adj[node]:
if not visited[neighbor]:
visited[neighbor] = True
queue.append(neighbor)
g = Graph(6)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 3)
g.add_edge(1, 4)
g.add_edge(2, 4)
g.add_edge(3, 4)
g.add_edge(3, 5)
g.add_edge(4, 5)
print("BFS:")
g.bfs(0)
Output :
BFS:
012345
B) DFS :
Algorithm :
Step 1 : Start.
Step 2 : Initialize an empty stack and mark all vertices as unvisited.
Step 3 : Add the starting vertex to the stack and mark it as visited.
Step 4 : While the stack is not empty :
Pop the next vertex from the stack.
For each adjacent vertex that is not visited, mark it as visited
and push it onto the stack.
Step 5 : Repeat step 3 until the stack is empty.
Step 6 : Exit.
Program :
class Graph:
def _init_(self, vertices):
self.V = vertices
self.adj = [[] for i in range(vertices)]
def add_edge(self, u, v):
self.adj[u].append(v)
def dfs(self, start):
visited = [False] * self.V
stack = []
stack.append(start)
visited[start] = True
while stack:
node = stack.pop()
print(node, end=" ")
for neighbor in self.adj[node]:
if not visited[neighbor]:
visited[neighbor] = True
stack.append(neighbor)
g = Graph(6)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 3)
g.add_edge(1, 4)
g.add_edge(2, 4)
g.add_edge(3, 4)
g.add_edge(3, 5)
g.add_edge(4, 5)
print("DFS:")
g.dfs(0)
Output :
DFS:
024513
Result :
The program has been executed successfully and the output is verified.
Ex No : 2
Date :
IMPLEMENTATION OF INFORMED SEARCH
ALGORITHMS (A*, memory-bounded A)
Aim : To implement the informed search algorithms using python program.
A) A*:
Algorithm:
Step 1 : Start
Step 2 : Initialize the start and goal nodes.
Step 3 : Create an empty open list and a closed list.
Step 4 : Add the start node to the open list.
Step 5 : While the open list is not empty:
Find the node with the lowest f score in the open list.
If this node is the goal, return the path.
Otherwise, move the node to the closed list and consider its neighbors.
For each neighbor, calculate its g score (the cost to move to this node from the
start) and h score (the heuristic estimate of the cost to move from this node to the goal).
If the neighbor is not in the open list or its new g score is lower than its old
g score, update the neighbor's f, g, and h scores and set its parent to the current node.
Add the neighbor to the open list if it is not already there.
Step 6 : If the goal node is not reached, there is no path.
Step 7 : Exit
Program :
import heapq
class Node:
def _init_(self, state, parent=None, g=0, h=0):
self.state = state
self.parent = parent
self.g = g
self.h = h
def f_score(self):
return self.g + self.h
class Graph:
def _init_(self, vertices, edges):
self.vertices = vertices
self.edges = edges
def neighbors(self, node):
return [Node(state) for state in self.edges.get(node.state,
[])] def astar_search(graph, start, goal, heuristic):
start_node = Node(start)
goal_node = Node(goal)
open_list = []
closed_list = set()
heapq.heappush(open_list, (start_node.f_score(), start_node))
while open_list:
current_node = heapq.heappop(open_list)[1]
if current_node.state == goal_node.state:
path = []
while current_node:
path.append(current_node.state)
current_node = current_node.parent
return list(reversed(path))
closed_list.add(current_node.state)
for neighbor in graph.neighbors(current_node):
if neighbor.state in closed_list:
continue
new_g = current_node.g + 1
new_h = heuristic(neighbor.state, goal)
new_f = new_g + new_h
if (new_f, neighbor) in open_list:
if new_g < neighbor.g:
neighbor.g = new_g
neighbor.parent = current_node
else:
neighbor.g = new_g
neighbor.h = new_h
neighbor.parent = current_node
heapq.heappush(open_list, (new_f, neighbor))
return None
vertices = ['A', 'B', 'C', 'D', 'E']
edges = {'A': ['B', 'C'],
'B': ['A', 'D'],
'C': ['A', 'D', 'E'],
'D': ['B', 'C', 'E'],
'E': ['C', 'D']}
graph = Graph(vertices, edges)
start = 'A'
goal = 'E'
heuristic = lambda n, goal: 0
print("A* Search:")
print(astar_search(graph, start, goal, heuristic))
Output :
A* Search:
['A', 'C', 'E']
B) Memory-Bounded A :
Algorithm:
Step 1 : Start.
Step 2 : Initialize the open list with the start node.
Step 3 : While the open list is not empty:
Pop the node with the lowest f-value from the open list.
If the node is the goal, return the path.
Expand the node and add its successors to the open list.
If the open list size exceeds the memory limit, remove the node(s) with the highest
f-value.
Step 4 : If the open list is empty and the goal node has not been found, return failure.
Step 5 : Exit.
Program :
import heapq
# Define the Node class
class Node:
def _init_(self, state, g_value, h_value, parent):
self.state = state
self.g_value = g_value
self.h_value = h_value
self.parent = parent
def _lt_(self, other):
return (self.g_value + self.h_value) < (other.g_value + other.h_value)
# Define the heuristic function
def heuristic(state, goal):
return abs(state[0] - goal[0]) + abs(state[1] - goal[1])
# Define the MA* search function
def ma_star_search(start, goal, memory_limit):
open_list = []
closed_set = set()
heapq.heappush(open_list, Node(start, 0, heuristic(start, goal), None))
while open_list:
current = heapq.heappop(open_list)
if current.state == goal:
path = []
while current:
path.append(current.state)
current = current.parent
return list(reversed(path))
closed_set.add(current.state)
for successor in get_successors(current.state):
if successor in closed_set:
continue
g_value = current.g_value + 1
h_value = heuristic(successor, goal)
new_node = Node(successor, g_value, h_value, current)
if len(open_list) < memory_limit:
heapq.heappush(open_list, new_node)
else:
max_node = max(open_list)
if new_node < max_node:
heapq.heappush(open_list, new_node)
open_list.remove(max_node)
closed_set.remove(max_node.state)
return None
# Define the get_successors
function def get_successors(state):
successors = []
x, y = state
if x > 0:
successors.append((x-1, y))
if x < 2:
successors.append((x+1, y))
if y > 0:
successors.append((x, y-1))
if y < 2: successors.append((x,
y+1))
return successors
# Define the start and goal
states start = (0, 0)
goal = (2, 2)
# Run the MA* search algorithm path
= ma_star_search(start, goal, 3)
# Print the path
print("MA* Search Path:", path)
Output :
MA* Search Path: [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)]
Result :
The program has been executed successfully and the output has been verified.
Ex No : 3
Date :
Implement naïve Bayes models
Aim : To write a python program to implement naïve Bayes models.
Algorithm:
Step 1: Start
Step 2: import the dataset and necessary dependencies
Step 3: Calculate Prior Probability of Classes P(y)
Step 4: Calculate the Likelihood Table for all features
Step 5: Calculate Posterior Probability for each class using the Naive
Bayesian equation
Step 6: End
Program :
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import math
def accuracy_score(y_true, y_pred):
"""
score = (y_true - y_pred) / len(y_true) """
return round(float(sum(y_pred == y_true))/float(len(y_true)) * 100 ,2)
def pre_processing(df):
""" partioning data into features and target """
X = df.drop([df.columns[-1]], axis =
1) y = df[df.columns[-1]]
return X, y
class NaiveBayes:
def _init_(self):
self.features = list
self.likelihoods = {}
self.class_priors = {}
self.pred_priors = {}
self.X_train = np.array
self.y_train = np.array
self.train_size = int
self.num_feats = int
def fit(self, X, y):
self.features = list(X.columns)
self.X_train = X
self.y_train = y
self.train_size = X.shape[0]
self.num_feats = X.shape[1]
for feature in self.features:
self.likelihoods[feature] = {}
self.pred_priors[feature] = {}
for feat_val in np.unique(self.X_train[feature]):
self.pred_priors[feature].update({feat_val: 0})
for outcome in np.unique(self.y_train):
self.likelihoods[feature].update({feat_val+'_'+outcome:0})
self.class_priors.update({outcome: 0})
self._calc_class_prior()
self._calc_likelihoods()
self._calc_predictor_prior()
def _calc_class_prior(self):
""" P(c) - Prior Class Probability """
for outcome in np.unique(self.y_train):
outcome_count = sum(self.y_train == outcome)
self.class_priors[outcome] = outcome_count / self.train_size
def _calc_likelihoods(self):
""" P(x|c) - Likelihood """
for feature in self.features:
for outcome in np.unique(self.y_train):
outcome_count = sum(self.y_train == outcome)
feat_likelihood = self.X_train[feature][self.y_train[self.y_train
==outcome].index.values.tolist()].value_counts().to_dict()
for feat_val, count in feat_likelihood.items():
self.likelihoods[feature][feat_val + '_' + outcome] =
count/outcome_count
def _calc_predictor_prior(self):
""" P(x) - Evidence """
for feature in self.features:
feat_vals = self.X_train[feature].value_counts().to_dict()
for feat_val, count in feat_vals.items():
self.pred_priors[feature][feat_val] = count/self.train_size
def predict(self, X):
""" Calculates Posterior probability P(c|x) """
results = []
X = np.array(X)
for query in X:
probs_outcome = {}
for outcome in np.unique(self.y_train):
prior = self.class_priors[outcome]
likelihood = 1
evidence = 1
for feat, feat_val in zip(self.features, query):
likelihood *= self.likelihoods[feat][feat_val + '_' +outcome]
evidence *= self.pred_priors[feat][feat_val]
posterior = (likelihood * prior) / (evidence)
probs_outcome[outcome] = posterior
result = max(probs_outcome, key = lambda x: probs_outcome[x])
results.append(result)
return np.array(results)
if _name_ == "_main_":
#Weather Dataset
print("\nWeather Dataset:")
df = pd.read_table("E:/tennisdata.csv")
#print(df)
#Split fearures and target
X,y = pre_processing(df)
nb_clf = NaiveBayes()
nb_clf.fit(X, y)
print("Train Accuracy: {}".format(accuracy_score(y, nb_clf.predict(X))))
#Query 1:
query = np.array([['Rainy','Mild', 'Normal', 't']])
print("Query 1:- {} ---> {}".format(query, nb_clf.predict(query)))
#Query 2:
query = np.array([['Overcast','Cool', 'Normal', 't']])
print("Query 2:- {} ---> {}".format(query, nb_clf.predict(query)))
#Query 3:
query = np.array([['Sunny','Hot', 'High', 't']])
print("Query 3:- {} ---> {}".format(query, nb_clf.predict(query)))
Output :
Weather Dataset:
Train Accuracy: 7.14
Query 1:- [['Rainy' 'Mild' 'Normal' 't']] ---> ['D1,Sunny,Hot,High,Weak,No']
Query 2:- [['Overcast' 'Cool' 'Normal' 't']] ---> ['D1,Sunny,Hot,High,Weak,No']
Query 3:- [['Sunny' 'Hot' 'High' 't']] ---> ['D1,Sunny,Hot,High,Weak,No']
Result :
The program has been executed successfully and the output has been verified.
Ex No: 4
Date :
IMPLEMENT BAYESIAN NETWORKS
Aim : To write a python program to implement Bayesian networks.
Algorithm :
Step 1: start
Step 2: Construct the Bayesian network by specifying the nodes and their
conditional probability distributions.
Step 3: Identify the set of observed variables (i.e., the evidence).
Step 4: For each unobserved variable, compute its posterior probability given
the evidence using the Bayes' rule and the conditional probability distributions
of the variable and its parents.
Step 5: Return the posterior probabilities of interest.
Step 6: stop
Program :
from pgmpy.models import BayesianModel from
pgmpy.factors.discrete import TabularCPD
# Defining the model structure. We can define the network by just passing a list
of edges.
model = BayesianModel([('D', 'G'), ('I', 'G'), ('G', 'L'), ('I', 'S')])
# Defining individual CPDs.
cpd_d = TabularCPD(variable='D', variable_card=2, values=[[0.6], [0.4]])
cpd_i = TabularCPD(variable='I', variable_card=2, values=[[0.7], [0.3]])
#representes P(grade|diff, intel)
cpd_g = TabularCPD(variable='G', variable_card=3,
values=[[0.3, 0.05, 0.9, 0.5],
[0.4, 0.25, 0.08, 0.3],
[0.3, 0.7, 0.02, 0.2]],
evidence=['I', 'D'],
evidence_card=[2, 2])
cpd_l = TabularCPD(variable='L', variable_card=2,
values=[[0.1, 0.4, 0.99],
[0.9, 0.6, 0.01]],
evidence=['G'],
evidence_card=[3])
cpd_s = TabularCPD(variable='S', variable_card=2,
values=[[0.95, 0.2],
[0.05, 0.8]],
evidence=['I'],
evidence_card=[2])
# Associating the CPDs with the network
model.add_cpds(cpd_d, cpd_i, cpd_g, cpd_l, cpd_s)
# check_model checks for the network structure and CPDs and verifies that the
CPDs are correctly. defined and sum to 1.
model.check_model()
Output :
True
Result :
The program has been executed successfully and the output is verified.
Ex No: 5(a)
Date :
BUILDING REGRESSION MODELS
(LINEAR REGRESSION)
Aim : To write Linear regression algorithms using python.
.
Algorithm :
Step 1: Start the program.
Step 2: Import the necessary modules.
Step 3: Create two arrays namely x and y.
Step 4: Using plot() function display the output of the code .
Step 5: Display the result.
Step 6: Stop the program.
Program :
import matplotlib.pyplot as plt
from scipy import stats
x = [89,43,36,36,95,10,66,34,38,20,26,29,48,64,6,5,36,66,72,40]
y = [21,46,3,35,67,95,53,72,58,10,26,34,90,33,38,20,56,2,47,15]
slope, intercept, r, p, std_err = stats.linregress(x, y)
def myfunc(x):
return slope * x + intercept
mymodel = list(map(myfunc, x))
plt.scatter(x, y)
plt.plot(x, mymodel)
plt.show()
Output :
Result :
The program has been executed successfully and the output is verified.
Ex No: 5(b)
Date :
BUILDING REGRESSION MODELS
(POLYNOMIAL REGRESSION)
Aim : To write Polynomial regression algorithms using python.
.
Algorithm :
Step 1: Start the program.
Step 2:Import the necessary modules.
Step 3: Use polyfit() function to show the polynomial regression.
Step 4: display the data and compute EM for Bayesian network.
Step 5:Stop the program.
.
Program :
import numpy
import matplotlib.pyplot as plt
x = [1,2,3,5,6,7,8,9,10,12,13,14,15,16,18,19,21,22]
y = [100,90,80,60,60,55,60,65,70,70,75,76,78,79,90,99,99,100]
mymodel = numpy.poly1d(numpy.polyfit(x, y, 3))
myline = numpy.linspace(1, 22, 100)
plt.scatter(x, y)
plt.plot(myline, mymodel(myline))
plt.show()
Output :
Result :
The program has been executed successfully and the output is verified.
Ex No: 5(c)
Date :
BUILDING REGRESSION MODELS
(MULTIPLE REGRESSION)
Aim : To write Multiple regression algorithms using python.
.
Algorithm :
Step 1: Start the program.
Step 2: Import the necessary modules.
Step 3: Use LinearRegression() function to show the Multiple regression.
Step 4: display the data and compute EM for Bayesian network.
Step 5: Stop the program.
Program :
import pandas
from sklearn import linear_model
df = pandas.read_csv("data.csv")
X = df[['Weight',
'Volume']] y = df['CO2']
regr = linear_model.LinearRegression()
regr.fit(X, y)
#predict the CO2 emission of a car where the weight is 2300kg,
and the volume is 1300cm3:
predictedCO2 = regr.predict([[2300, 1300]])
print(predictedCO2)
Output :
[107.2087328]
Result :
The program has been executed successfully and the output is verified.
Ex No: 6
Date :
DECESION TREE
Aim : To implement Decesion Tree using python.
.
Algorithm :
Step 1: Start the program.
Step 2: Import the necessary modules.
Step 3: Use matplotlib package to display the result
Step 4:display the data and compute EM for Bayesian network.
Step 5: Stop the program.
Program :
#Three lines to make our compiler able to draw:
import sys
import matplotlib
matplotlib.use('Agg')
import pandas
from sklearn import tree
from sklearn.tree import
DecisionTreeClassifier import
matplotlib.pyplot as plt
df = pandas.read_csv("data.csv")
d = {'UK': 0, 'USA': 1, 'N': 2}
df['Nationality'] =
df['Nationality'].map(d) d = {'YES': 1,
'NO': 0} df['Go'] = df['Go'].map(d)
features = ['Age', 'Experience', 'Rank', 'Nationality']
X = df[features]
y = df['Go']
dtree = DecisionTreeClassifier()
dtree = dtree.fit(X, y)
tree.plot_tree(dtree, feature_names=features)
#Two lines to make our compiler able to
draw: plt.savefig(sys.stdout.buffer)
sys.stdout.flush()
Output :
Result :
The program has been executed successfully and the output is verified.
Ex No : 7
Date :
Build svm model
Aim : To build a svm model using python program.
Algorithm:
Step 1: Start
Step 2: Load the dataset you want to use for training the model.
Step 3: preprocess the data to make it ready for training the model.
Step 4:split the data into two sets - one for training the model and the other for
testing the model.
Step 5: splitting it into training and testing sets.
Step 6: Once the SVM model is defined, you can train it using the training set.
Step 7: use cross-validation techniques like grid search to find the optimal values
for the hyperparameters.
Step 8: Stop.
Program :
# Step 1: Load the dataset
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
# Step 2: Preprocess the data
from sklearn.preprocessing import
StandardScaler scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# Step 3: Split the data into training and testing sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)
# Step 4: Define the SVM model
from sklearn.svm import SVC
svm_model = SVC(kernel='linear', C=1.0)
# Step 5: Train the SVM model
svm_model.fit(X_train, y_train)
# Step 6: Test the SVM model
y_pred = svm_model.predict(X_test)
from sklearn.metrics import accuracy_score
print("Accuracy: ", accuracy_score(y_test,
y_pred)) # Step 7: Tune the hyperparameters
from sklearn.model_selection import GridSearchCV
param_grid = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}
grid_search = GridSearchCV(SVC(), param_grid,
cv=5) grid_search.fit(X_train, y_train)
print("Best parameters: ", grid_search.best_params_)
Output :
Accuracy: 0.9777777777777777
Best parameters: {'C': 10, 'kernel': 'linear'}
Result :
The program has been executed successfully and the output has been verified.
Ex No : 8
Date :
Ensemble techniques implementation
Aim : To build a Ensemble techniques implementation using python program.
Algorithm:
Step 1: In bagging, multiple models are trained to make the final prediction.
Step 2: In boosting, multiple weak models are trained to correct the errors of
the previous model.
Step 3: In stacking, multiple models are trained to combine the predictions of the
base models to make the final prediction.
Step 4: In averaging, multiple models are trained independently to make the
final prediction.
Step 5: In blending, multiple models are trained independently and their
predictions are combined using a weighted average.
Step 6: In ensemble of ensembles, multiple ensembles are created using
different techniques and combined to create a final prediction.
Program :
from sklearn.ensemble import VotingClassifier from
sklearn.ensemble import BaggingClassifier from
sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Load the iris dataset
data = load_iris()
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target,
test_size=0.3, random_state=42)
# Define the base models
model1 = DecisionTreeClassifier(random_state=42)
model2 = LogisticRegression(random_state=42)
model3 = KNeighborsClassifier()
# Define the ensemble models
ensemble1 = BaggingClassifier(base_estimator=model1, n_estimators=10, random_state=42)
ensemble2 = AdaBoostClassifier(base_estimator=model2, n_estimators=10,
random_state=42)
ensemble3 = GradientBoostingClassifier(n_estimators=10, random_state=42)
# Define the voting classifier
voting_clf = VotingClassifier(estimators=[('bagging', ensemble1), ('adaboost',
ensemble2), ('gradient_boosting', ensemble3)], voting='hard')
# Train the voting classifier
voting_clf.fit(X_train, y_train)
# Make predictions on the test set
y_pred = voting_clf.predict(X_test)
# Calculate the accuracy of the ensemble model
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy: %.2f' % accuracy)
Output :
Accuracy: 1.00
Result :
The program has been executed successfully and the output has been verified.
Ex No : 9
Date :
IMPLEMENT CLUSTERING ALGORITHMS –
KMEANS CLUSTERING
Aim : To implement kmeans clustering algorithms using python..
Algorithm:
Step 1:- Start the program.
Step 2:- Import the necessary modules.
Step 3:- Create two arrays namely x and y.
Step 4:- construct kmeans cluster using Kmeans().
Step 5:- Display the result.
Step 6:- Stop the program.
Program :
import matplotlib.pyplot as plt
x = [4, 5, 10, 4, 3, 11, 14 , 6, 10, 12]
y = [21, 19, 24, 17, 16, 25, 24, 22, 21, 21]
from sklearn.cluster import KMeans
data = list(zip(x, y))
inertias = []
for i in range(1,11):
kmeans = KMeans(n_clusters=i)
kmeans.fit(data)
inertias.append(kmeans.inertia_)
plt.plot(range(1,11), inertias, marker='o')
plt.title('Elbow method')
plt.xlabel('Number of clusters')
plt.ylabel('Inertia')
plt.show()
Output :
Result :
The program has been executed successfully and the output has been verified.
Ex No : 10
Date :
IMPLEMENT EM FOR BAYESIAN NETRWORK
Aim : To implement EM for Bayesian network using python.
Algorithm:
Step 1:- Start the program.
Step 2:- Import the necessary modules.
Step 3:- Read the csv file containing data.
Step 4:- display the data and compute EM for Bayesian network.
Step 5:- Stop the program
Program :
import numpy as np
import csv
import pandas as pd
from pgmpy.models import BayesianModel
from pgmpy.estimators import
MaximumLikelihoodEstimator from pgmpy.inference import
VariableElimination heartDisease = pd.read_csv('heart.csv')
heartDisease = heartDisease.replace('?',np.nan)
print('Few examples from the dataset are given below') print(heartDisease.head())
Model=BayesianModel([('age','trestbps'),('age','fbs'),('sex','trestbps'),('exang','trestbps'),('trestb
ps','heartdise
ase'),('fbs','heartdisease'),('heartdisease','restecg'),('heartdisease','thalach'),('heartdisease','ch
ol')])
print('\n Learning CPD using Maximum likelihood estimators') model.fit
(heartDisease, estimator =MaximumLikelihoodEstimator)
print('\n Inferencing with Bayesian Network:')
HeartDisease_infer = VariableElimination(model)
print('\n 1. Probability of HeartDisease given Age=30')
q=HeartDisease_infer.query(variables=['heartdisease'],evidence ={'age':28})
print(q['heartdisease'])
print('\n 2. Probability of HeartDisease given cholesterol=100') q=HeartDisease_infer
.query(variables=['heartdisease'],evidence ={'chol':100})
print(q['heartdisease'])
Output :
Few examples from the dataset are given below
age sex cp trestbps ...slope ca thal heartdisease 0 63 1 1 145 ... 3 0 6 0 1 67 1 4 160 ... 2 3
3 226714120...227133713130...303044102130...1030 [5 rows x 14 columns]
Learning CPD using Maximum likelihood estimators Inferencing with Bayesian Network:
1. Probability of HeartDisease given Age=28
╒════════════════╤═════════════════════╕ │
heartdisease │ phi(heartdisease) │
╞════════════════╪═════════════════════╡ │
heartdisease_0 │ 0.6791 │
├────────────────┼─────────────────────┤ │
heartdisease_1 │ 0.1212 │
├────────────────┼─────────────────────┤ │
heartdisease_2 │ 0.0810 │
├────────────────┼─────────────────────┤ │
heartdisease_3 │ 0.0939 │
├────────────────┼─────────────────────┤ │
heartdisease_4 │ 0.0247 │
╘════════════════╧═════════════════════╛
2. Probability of HeartDisease given cholesterol=100
╒════════════════╤═════════════════════╕ │
heartdisease │ phi(heartdisease) │
╞════════════════╪═════════════════════╡ │
heartdisease_0 │ 0.5400 │
├────────────────┼─────────────────────┤ │
heartdisease_1 │ 0.1533 │
├────────────────┼─────────────────────┤ │
heartdisease_2 │ 0.1303 │
├────────────────┼─────────────────────┤ │
heartdisease_3 │ 0.1259 │
├────────────────┼─────────────────────┤ │
heartdisease_4 │ 0.0506 │
╘════════════════╧═════════════════════╛
Result :
The program has been executed successfully and the output has been verified.
Ex No : 11
Date :
BUILD A SIMPLE NN MODELS
Aim : To develop or build a simple nueral network (NN) model using python.
Algorithm:
Step 1 : Start
Step 2 : Create a sigmoid function
Step 3 : Initialize the requires parameters weight and bias.
Step 4 : Create forword propagation function which takes x ,the initialized
parameters input and returns a2 , cache .
Step 5 : Create a calculate_cost function which takes a2 , y as input parameters
and return the cost.
Step 6 : Now create a backword_propagation function which takes x , y , cache ,
and parameters as input parameters and returns grads.
Step 7 : Create a update_parameters function which takes parameters ,
grads , learning_rate as input parameters and returns the updated values.
Step 8 : Now create model which takes the input parameters x , y , n_x , n_h ,
n_y , num_of_iters , learning_rate and returns the parameters as output.
Step 9 : Create a predict function which takes x and parameters as input
parameters and returns the prediction as output.
Step 10 : Stop
Program :
import numpy as np
def sigmoid(z):
return 1/(1+np.exp(-z))
def initialize_parameters(n_x,n_h,n_y):
w1 = np.random.randn(n_h,n_x)
b1 = np.zeros((n_h,1))
w2 = np.random.randn(n_y,n_h)
b2 = np.zeros(( n_y , 1))
parameters = {
"w1" : w1,
"b1" : b1,
"w2" : w2,
"b2" : b2,
}
return parameters
def forward_prop(x,parameters):
w1 = parameters["w1"]
b1 = parameters["b1"]
w2 = parameters["w2"]
b2 = parameters["b2"]
z1 = np.dot(w1 , x) + b1
a1 = np.tanh(z1)
z2 = np.dot(w2 , a1) + b2
a2 = sigmoid(z2)
cache = {
"a1" : a1,
"a2" : a2,
}
return a2 , cache
def calculate_cost(a2 , y):
cost = -np.sum(np.multiply( y, np.log(a2)) + np.multiply(1-y,np.log(1a2)))/m cost = np.squeeze(cost)
return cost
def backword_prop(x,y,cache , parameters):
a1 = cache["a1"]
a2 = cache["a2"]
w2 = parameters["w2"]
dz2 = a2 - y
dw2 = np.dot(dz2,a1.T)/m
db2 = np.sum(dz2,axis=1 , keepdims=True)/m
dz1 = np.multiply(np.dot(w2.T,dz2) , 1-np.power(a1,2))
dw1 = np.dot(dz1,x.T)/m
db1 = np.sum(dz1,axis=1,keepdims=True)/m
grads = {
"dw1" : dw1,
"db1" : db1,
"dw2" : dw2,
"db2" : db2
}
return grads
def update_parameters(parameters , grads , learning_rate):
w1 = parameters["w1"]
b1 = parameters["b1"]
w2 = parameters["w2"]
b2 = parameters["b2"]
dw1 = grads["dw1"]
db1 = grads["db1"]
dw2 = grads["dw2"]
db2 = grads["db2"]
w1 = w1 - learning_rate * dw1
b1 = b1 - learning_rate * db1
w2 = w2 - learning_rate * dw2
b2 = b2 - learning_rate * db2
new_parameters = {
"w1" : w1,
"b1" : b1,
"w2" : w2,
"b2" : b2,
}
return new_parameters
def model(x, y , n_x , n_h , n_y , num_of_iters , learning_rate):
parameters = initialize_parameters(n_x,n_h,n_y)
for i in range(0, num_of_iters+1):
a2 , cache = forward_prop(x,parameters)
cost = calculate_cost(a2,y)
grads = backword_prop(x,y,cache,parameters)
parameters = update_parameters(parameters , grads , learning_rate)
if (i%100 == 0):
print('Cost after iteration {:d}: {:f}'.format(i,cost))
return parameters
def predict(x,parameters):
a2 , cache = forward_prop(x,parameters)
yhat = a2
yhat = np.squeeze(yhat)
if yhat >= 0.5:
y_predict = 1
else:
y_predict = 0
return y_predict
np.random.seed(2)
x = np.array([[0,0,1,1],[0,1,0,1]])
y = np.array([[0,1,1,0]])
m = x.shape[1]
n_x = 2
n_h = 2
n_y = 1
num_of_iters = 1000
learning_rate = 0.3
trained_parameters = model(x,y,n_x,n_h,n_y,num_of_iters,learning_rate)
x_test = np.array([[1],[0]])
y_predict = predict(x_test , trained_parameters)
print("Neural Network prediction for example ( {:d}, {:d} is {:d} )".format(
x_test[0][0],x_test[1][0] , y_predict))
Output :
Cost after iteration 0: 0.856267
Cost after iteration 100: 0.347426
Cost after iteration 200: 0.101195
Cost after iteration 300: 0.053631
Cost after iteration 400: 0.036031
Cost after iteration 500: 0.027002
Cost after iteration 600: 0.021543
Cost after iteration 700: 0.017896
Cost after iteration 800: 0.015293
Cost after iteration 900: 0.013344
Cost after iteration 1000: 0.011831
Neural Network prediction for example ( 1, 0 is 1 )
Result :
The program has been executed successfully and the output has been verified.
Ex No : 12
Date :
Build deep learning NN models
Aim : To write a python program to build a deep learning neural networks model
Algorithm:
Step 1: Start
Step 2: Import the necessary libraries
Step 3: Set the random seed for reproducibility
Step 4: Define the model architecture
Step 5: Initialize the weights and biases for the input and hidden layers
Step 6: Initialize the weights and biases for the hidden and output layers
Step 7: Define the input data, labels and hyperparameters
Step 8: Define the Tensorflow variables for the weights and biases
Step 9: Define the forward propagation and backpropagation algorithms
Step 10: Train the model and make some predictions with the trained model
Step 11: End
Program :
import tensorflow as tf
from tensorflow import keras
# Load the data
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# Preprocess the data
x_train = x_train.reshape((x_train.shape[0], 28 * 28)).astype('float32') /
255 x_test = x_test.reshape((x_test.shape[0], 28 * 28)).astype('float32') /
255 y_train = keras.utils.to_categorical(y_train) y_test =
keras.utils.to_categorical(y_test)
# Define the model architecture
model = keras.models.Sequential([
keras.layers.Dense(128, activation='relu', input_shape=(28 *
28,)), keras.layers.Dropout(0.5),
keras.layers.Dense(10, activation='softmax')
])
# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Train the model
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))
# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)
Output :
Result :
The program has been executed successfully and the output has been verified.