1st Pgm: (A *)
def aStarAlgo(start_node, stop_node):
open_set=set(start_node)
closed_set=set()
g={}
parents={}
g[start_node]=0
parents[start_node]=start_node
while len(open_set)>0:
n=None
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_neighbours(n):
if m not in open_set and m not in closed_set:
open_set.add(m)
parents[m]=n
g[m]=g[n]+weight
else:
if g[m]>g[n]+weight:
g[m]=g[n]+weight
parents[m]=n
if m in closed_set:
closed_set.remove(m)
open_set.add(m)
if n==None:
print('Path does not exists!')
return None
if n==stop_node:
path=[]
while parents[n]!=n:
[Link](n)
n=parents[n]
[Link](start_node)
[Link]()
print('Path found : {}'.format(path))
return path
open_set.remove(n)
closed_set.add(n)
print('Path does not exists!')
return None
def get_neighbours(v):
if v in Graph_nodes:
return Graph_nodes[v]
else:
return None
def heuristic(n):
H_dist={
'S':14,
'B':12,
'C':11,
'D':6,
'F':11,
'E':4,
'G':0,
}
return H_dist[n]
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)],
}
aStarAlgo('A','G')
2nd Pgm: (AO *)
class graph:
def __init__(self,graph, heuristicNodeList,startNode):
[Link] = graph
self.H= heuristicNodeList
[Link]=startNode
[Link]={}
[Link]={}
[Link]={}
def applyAOStar(self):
[Link]([Link], False)
def getNeighbors(self, v):
return [Link](v ,'')
def getStatus(self, v):
return [Link](v,0)
def setStatus(self,v,val):
[Link][v]=val
def getHeuristicNodeValue(self, n):
return [Link](n,0)
def setHeuristicNodeValue(self, n, value):
self.H[n]=value
def printSolution(self):
print('FOR GRAPH SOLUTION, TRAVERSE THE GRAPH FROM THE
STARTNODE:',[Link])
print('--------------------------------------------------------------------')
print([Link])
print('--------------------------------------------------------------------')
def computeMinimumCostChildNodes(self, v):
minimumCost=0
costToChildNodeListDict={}
costToChildNodeListDict[minimumCost]=[]
flag = True
for nodeInfoTupleList in [Link](v):
cost =0
nodeList=[]
for c, weight in nodeInfoTupleList:
cost=cost+[Link](c) + weight
[Link](c)
if flag ==True:
minimumCost=cost
costToChildNodeListDict[minimumCost]=nodeList
flag=False
else:
if minimumCost>cost:
minimumCost =cost
costToChildNodeListDict[minimumCost]=nodeList
return minimumCost, costToChildNodeListDict[minimumCost]
def aoStar(self, v, backTracking):
print('HEURISTIC VALUES:',self.H)
print('SOLUTION GRAPH:',[Link])
print('PROCESSINGT NODE:', v)
print('-------------------------------------------------------')
if [Link](v) >=0:
minimumCost, childNodeList = [Link](v)
[Link](v, minimumCost)
[Link](v, len(childNodeList))
solved = True
for childNode in childNodeList:
[Link][childNode]=v
if [Link](childNode)!=-1:
solved=solved & False
if solved==True:
[Link](v,-1)
[Link][v]=childNodeList
if v!=[Link]:
[Link]([Link][v], True)
if backTracking == False:
for childNode in childNodeList:
[Link](childNode, 0)
[Link](childNode, False)
h1= {'A':1, 'B':6, 'C':2, 'D':12, 'E':2, 'F':1, 'G':5, 'H':7, 'I':7, 'J':1}
graph1= {'A':[[('B',1), ('C',1)],[('D',1)]],
'B':[[('G',1)], [('H',1)]],
'C':[[('J',1)]],
'D':[[('E',1),('F',1)]],
'G':[[('I',1)]]
}
G1 = graph(graph1,h1,'A')
[Link]()
[Link]()
3rd Pgm:(Candidate elimination)
import numpy as np
import pandas as pd
data=[Link](data=pd.read_csv('[Link]'))
concepts=[Link]([Link][:,0:-1])
target=[Link]([Link][:,-1])
def learn(concepts,target):
print("initialization of specific_h and general_h")
l=len(concepts[0])
specific_h=['0']*l
print(specific_h)
general_h=['?']*l
print(general_h,"\n")
specific_h=concepts[0].copy()
general_h=[["?" for i in range(len(specific_h))] for i in
range(len(specific_h))]
for i, h in enumerate(concepts):
if target[i]=="Yes":
for x in range(len(specific_h)):
if h[x] != specific_h[x]:
specific_h[x]='?'
general_h[x][x]='?'
if target[i]=="No":
for x in range(len(specific_h)):
if h[x] != specific_h[x]:
general_h[x][x]=specific_h[x]
else:
general_h[x][x]='?'
print("Steps ",i+1," of Candidate Elimination Algorithm")
print(specific_h)
print(general_h)
indices=[i for i, val in enumerate(general_h) if val ==
['?','?','?','?','?','?']]
for i in indices:
general_h.remove(['?','?','?','?','?','?'])
return specific_h,general_h
s_final, g_final = learn(concepts,target)
print("\nFinal Specific_h : ",s_final,sep="\n")
print("Final General_h : ",g_final,sep="\n")
4th Pgm:(DT)
import pandas as pd
import math
import numpy as np
data= pd.read_csv("[Link]")
features=[feat for feat in data]
[Link]("answer")
class Node:
def __init__ (self):
[Link]=[]
[Link]=""
[Link]= False
[Link]=""
def entropy(examples):
pos=0.0
neg=0.0
for _, row in [Link]():
if row["answer"]=="yes":
pos+=1
else:
neg+=1
if pos==0.0 or neg==0.0:
return 0.0
else:
p=pos/(pos+neg)
n= neg/(pos+neg)
return -(p * [Link](p,2)+ n * [Link](n,2))
def info_gain(examples,attr):
uniq= [Link](examples[attr])
gain=entropy(examples)
for u in uniq:
subdata= examples[examples[attr]==u]
sub_e =entropy(subdata)
gain -=(float(len(subdata))/ float(len(examples))) * sub_e
return gain
def ID3(examples,attrs):
root=Node()
max_gain=0
max_feat=""
for feature in attrs:
gain = info_gain(examples,feature)
if gain > max_gain:
max_gain=gain
max_feat=feature
[Link]=max_feat
uniq=[Link](examples[max_feat])
for u in uniq:
subdata=examples[examples[max_feat]==u]
if entropy(subdata)==0.0:
newnode=Node()
[Link]=True
[Link]=u
[Link] = [Link](subdata["answer"])
[Link](newnode)
else:
dummynode=Node()
[Link]=u
new_attrs=[Link]()
new_attrs.remove(max_feat)
child=ID3(subdata,new_attrs)
[Link](child)
[Link](dummynode)
return root
def printtree(root:Node,depth=0):
for i in range(depth):
print("\t", end="")
print([Link],end="")
if [Link]:
print("->",[Link])
print()
for child in [Link]:
printtree(child,depth+1)
def classify(root:Node,new):
for child in [Link]:
if [Link]==new[[Link]]:
if [Link]:
print("predicted lable for new example",new,"is:",[Link])
exit
else:
classify([Link][0],new)
root=ID3(data,features)
print("decision tree is:")
printtree(root)
print("------------------")
new={"outlook":"sunny","temperature":"hot","humidity":"high","wind":"strong"}
classify(root,new)
new1={"outlook":"overcast","temperature":"hot","humidity":"high","wind":"strong"}
classify(root,new1)
5th Pgm:(Back propagation)
import numpy as np
x=[Link](([2,9],[1,5],[3,6]),dtype=float)
y=[Link](([92],[86],[89]),dtype=float)
x=x/[Link](x,axis=0)
y=y/100
def sigmoid(x):
return 1/(1+[Link](-x))
def derivatives_sigmoid(x):
return x*(1-x)
epoch=5000
lr=0.1
inputlayer_neurons=2
hiddenlayer_neurons=3
output_neurons=1
wh=[Link](size=(inputlayer_neurons,hiddenlayer_neurons))
bh=[Link](size=(1,hiddenlayer_neurons))
wout=[Link](size=(hiddenlayer_neurons,output_neurons))
bout=[Link](size=(1,output_neurons))
for i in range(epoch):
hinp1=[Link](x,wh)
hinp=hinp1+bh
hlayer_act=sigmoid(hinp)
outinp1=[Link](hlayer_act,wout)
outinp=outinp1+bout
output=sigmoid(outinp)
EO=y-output
outgrad=derivatives_sigmoid(output)
d_output=EO*outgrad
EH=d_output.dot(wout.T)
hiddengrad=derivatives_sigmoid(hlayer_act)
d_hiddenlayer=EH*hiddengrad
wout+=hlayer_act.[Link](d_output)*lr
wh+=[Link](d_hiddenlayer)*lr
print("Input : \n"+str(x))
print("Output : \n"+str(y))
print("Predicted Output : \n",output)
6th Pgm:(Neive Basian)
import csv
import random
import math
def loadcsv(filename):
reader = [Link](open(filename,"r"))
dataset = []
for row in reader:
inlist = []
for i in range(len(row)):
[Link](float(row[i]))
[Link](inlist)
return dataset
def splitDataset(dataset,splitratio):
trainSize = int(len(dataset) * splitratio)
trainSet = []
copy = list(dataset)
while len(trainSet) < trainSize:
index = [Link](len(copy))
[Link]([Link](index))
return [trainSet, copy]
def separateByClass(dataset):
separated = {}
for i in range(len(dataset)):
vector = dataset[i]
if (vector[-1] not in separated):
separated[vector[-1]] = []
separated[vector[-1]].append(vector)
#print(separated)
return separated
def mean(numbers):
return sum(numbers)/float(len(numbers))
def stdev(numbers):
if len(numbers)==0:
return 0
avg = mean(numbers)
variance = sum([pow(x-avg,2) for x in numbers]) / float(len(numbers)-1)
return [Link](variance)
def summarize(dataset):
summaries = [ (mean(attribute), stdev(attribute)) for attribute in
zip(*dataset)]
del summaries[-1]
return summaries
def summarizeByClass(dataset):
separated = separateByClass(dataset)
#print(separated)
summaries = {}
for classValue, instances in [Link]():
summaries[classValue] = summarize(instances)
return summaries
def calculateProbability(x, mean, stdev):
exponent = [Link]( -([Link](x-mean, 2)/(2*[Link](stdev,2))))
return (1 / ([Link](2*[Link]) * stdev)) * exponent
def calculateClassProbabilities(summaries, inputVector):
probabilities = {}
for classValue, classSummaries in [Link]():
probabilities[classValue] = 1
for i in range(len(classSummaries)):
mean, stdev = classSummaries[i]
x = inputVector[i]
probabilities[classValue] *= calculateProbability(x, mean, stdev)
return probabilities
def predict(summaries, inputVector):
probabilities = calculateClassProbabilities(summaries, inputVector)
bestLabel, bestprob = None, -1
for classValue, probability in [Link]():
if bestLabel is None or probability > bestprob:
bestprob = probability
bestLabel = classValue
return bestLabel
def getpredictions(summaries, testset):
predictions = []
for i in range(len(testSet)):
result = predict(summaries, testSet[i])
[Link](result)
return predictions
def getAccuracy(testSet, predictions):
correct = 0
for i in range(len(testSet)):
if testSet[i][-1] == predictions[i]:
correct +=1
return (correct / float(len(testSet))) * 100.0
filename = 'PI_Diabetes.csv'
splitRatio = 0.9
dataset = loadcsv(filename)
print("\n The length of the Data Set: ",len(dataset))
print("\n The Data Set Splitting into Training and Testing \n")
trainingset, testSet = splitDataset(dataset, splitRatio)
print("\n Number of Rows in Training Set:{0} rows".format(len(trainingset)))
print("\n Number of Rows in Testining Set:{0} rows".format(len(testSet)))
summaries = summarizeByClass(trainingset)
print("\n Model summaries:\n",summaries)
predictions = getpredictions(summaries, testSet)
print("\n Predictions:\n",predictions)
accuracy = getAccuracy(testSet, predictions)
print("\n Accuracy:{0}%".format(accuracy))
7th pgm:(KMeans & GMM)
import [Link] as plt
from [Link] import KMeans
from sklearn import preprocessing
from [Link] import GaussianMixture
import [Link] as sm
import pandas as pd
import numpy as np
iris_dataset = pd.read_csv('iris(1).csv')
iris_dataset['Targets'] = iris_dataset.[Link]({'Iris-setosa':0, 'Iris-
versicolor':1, 'Iris-virginica':2})
x = iris_dataset[['Sepal_Length','Sepal_Width','Petal_Length','Petal_Width']]
y = iris_dataset[['Targets']]
model = KMeans(n_clusters = 3)
[Link](x)
print('Model Labels:\n',model.labels_)
scaler = [Link]()
[Link](x)
xs = [Link](x)
gmm = GaussianMixture(n_components = 3)
[Link](xs)
y_gmm = [Link](xs)
print('GMM Labels:\n',y_gmm)
[Link](figsize = (10,10))
colormap = [Link](['red','lime','black'])
[Link](2,2,1)
[Link](x.Petal_Length,x.Petal_Width,c=colormap[[Link]], s=40)
[Link]('Real Classification')
[Link]('Petal Length')
[Link]('Petal Width')
[Link](2,2,2)
[Link](x.Petal_Length,x.Petal_Width,c=colormap[model.labels_], s=40)
[Link]('K Means Clustering')
[Link]('Petal Length')
[Link]('Petal Width')
[Link](2,2,3)
[Link](x.Petal_Length,x.Petal_Width,c=colormap[y_gmm], s=40)
[Link]('GMM Based Clustering')
[Link]('Petal Length')
[Link]('Petal Width')
print('Evaluation of K-Means with ground truth classification of Iris Dataset')
print('Rand Index:%f' % sm.adjusted_rand_score([Link], model.labels_))
print('Homogenity Score:%f' % sm.homogeneity_score([Link],model.labels_))
print('Completeness Score:%f' % sm.completeness_score([Link], model.labels_))
print('V-Measure:%f' %sm.v_measure_score([Link],model.labels_))
print('Evaluation of GMM with ground truth classification of Iris dataset')
print('Rand Index:%f ' % sm.adjusted_rand_score([Link], y_gmm))
print('Homogenity Score:%f' % sm.homogeneity_score([Link],y_gmm))
print('Completeness Score:%f' % sm.completeness_score([Link],y_gmm))
print('V-Measure:%f' %sm.v_measure_score([Link],y_gmm))
8th Pgm:(KNN)
from sklearn.model_selection import train_test_split
from [Link] import KNeighborsClassifier
from sklearn import datasets
iris = datasets.load_iris()
print("Iris Dataset Loaded....")
x_train,x_test,y_train,y_test = train_test_split([Link],[Link],test_size =
0.1)
print("Dataset is split into training and testing samples...")
print("Size of training data and its label:",x_train.shape,y_train.shape)
print("Size of testing data and its label:",x_test.shape,y_test.shape)
for i in range(len(iris.target_names)):
print("Label1 ", i,"-",str(iris.target_names[i]))
classifier = KNeighborsClassifier(n_neighbors=1)
[Link](x_train,y_train)
y_pred = [Link](x_test)
print("Results of classssification using K-nn with K=1")
for r in range(0,len(x_test)):
print("Sample:",str(x_test[r]),"Actual_label:",str(y_test[r]),"Predicted_label:",st
r(y_pred[r]))
print("Classification accuracy:",[Link](x_test,y_test))
9th Pgm : (weighted regression)
import [Link] as plt
import pandas as pd
import numpy as np
def kernel(point,xmat,k):
m,n = [Link](xmat)
weights = [Link]([Link]((m)))
for j in range(m):
diff = point-X[j]
weights[j,j] = [Link](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 = [Link](xmat)
ypred = [Link](m)
for i in range(m):
ypred[i] = xmat[i]*localWeight(xmat[i],xmat,ymat,k)
return ypred
def grapPlot(X,ypred):
sortindex = X[:,1].argsort(0)
xsort = X[sortindex][:,0]
fig = [Link]()
ax = fig.add_subplot(1,1,1)
[Link](bill,tip,color='green')
[Link](xsort[:,1],ypred[sortindex],color = 'red',linewidth=5)
[Link]('Total bill')
[Link]('Tip')
[Link]()
data = pd.read_csv('[Link]')
bill = [Link](data.total_bill)
tip = [Link]([Link])
mbill = [Link](bill)
mtip = [Link](tip)
m = [Link](mbill)[1]
one = [Link]([Link](m))
X = [Link]((one.T,mbill.T))
print('\n ypred for k=3')
ypred = localWeightRegression(X,mtip,3)
grapPlot(X,ypred)
print('\n ypred for k=9')
ypred = localWeightRegression(X,mtip,9)
grapPlot(X,ypred)
