1.

Graph_nodes = {
'A': [('B', 6), ('F', 3)],
'B': [('C', 3), ('D', 2)],
'C': [('D', 1), ('E', 5)],
'D': [('C', 1), ('E', 8)],
'E': [('I', 5), ('J', 5)],
'F': [('G', 1),('H', 7)] ,
'G': [('I', 3)],
'H': [('I', 2)],
'I': [('E', 5), ('J', 3)],

def get_neighbors(v):
if v in Graph_nodes:
return Graph_nodes[v]
else:
return None

def h(n):
H_dist = {
'A': 10,
'B': 8,
'C': 5,
'D': 7,
'E': 3,
 'F': 6,
'G': 5,
'H': 3,
'I': 1,
'J': 0
}
return H_dist[n]

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] + h(v) < g[n] + h(n):
n=v

if n == stop_node or Graph_nodes[n] == None:

pass
else:
 for (m, weight) in get_neighbors(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 exist!')
return None
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
open_set.remove(n)
closed_set.add(n)

print('Path does not exist!')

return None

aStarAlgo('A', 'J')

2.
class Graph:
def __init__(self, graph, heuristicNodeList, startNode):

self.graph = graph
self.H=heuristicNodeList
self.start=startNode
self.parent={}
self.status={}
self.solutionGraph={}

def applyAOStar(self):
self.aoStar(self.start, False)

def getNeighbors(self, v):

return self.graph.get(v,'')
 def getStatus(self,v):
return self.status.get(v,0)

def setStatus(self,v, val):

self.status[v]=val

def getHeuristicNodeValue(self, n):

return self.H.get(n,0)

def setHeuristicNodeValue(self, n, value):

self.H[n]=value

def printSolution(self):
print("FOR GRAPH SOLUTION, TRAVERSE THE GRAPH FROM THE
START NODE:",self.start)
print("------------------------------------------------------------")
print(self.solutionGraph)
print("------------------------------------------------------------")

def computeMinimumCostChildNodes(self, v):

minimumCost=0
costToChildNodeListDict={}
costToChildNodeListDict[minimumCost]=[]
flag=True
for nodeInfoTupleList in self.getNeighbors(v):
 cost=0
nodeList=[]
for c, weight in nodeInfoTupleList:
cost=cost+self.getHeuristicNodeValue(c)+weight
nodeList.append(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 :", self.solutionGraph)
print("PROCESSING NODE :", v)
print("--------------------------------------------------------------------------------------
---")
 if self.getStatus(v) >= 0:
minimumCost, childNodeList = self.computeMinimumCostChildNodes(v)
self.setHeuristicNodeValue(v, minimumCost)
self.setStatus(v,len(childNodeList))

solved=True
for childNode in childNodeList:
self.parent[childNode]=v
if self.getStatus(childNode)!=-1:
solved=solved & False

if solved==True:
self.setStatus(v,-1)
self.solutionGraph[v]=childNodeList

if v!=self.start:
self.aoStar(self.parent[v], True)

if backTracking==False:
for childNode in childNodeList:
self.setStatus(childNode,0)
self.aoStar(childNode, False)

h2 = {'A': 1, 'B': 6, 'C': 12, 'D': 10, 'E': 4, 'F': 4, 'G': 5, 'H': 7}
graph2 = {
'A': [[('B', 1), ('C', 1)], [('D', 1)]],
 'B': [[('G', 1)], [('H', 1)]],
'D': [[('E', 1), ('F', 1)]]
}

G2 = Graph(graph2, h2, 'A')

G2.applyAOStar()
G2.printSolution()

3.
import random
import csv as csv
with open("trainingexamples.csv") as csvfile:
examples=[tuple(line) for line in csv.reader(csvfile)]
def get_domains(examples):
d=[set() for i in examples[0]]
#print(d)
for x in examples:
for i,xi in enumerate(x):
d[i].add(xi)
return [list(sorted(x)) for x in d]

def consistent(h1,h2):
mgp=[]
for x,y in zip(h1,h2):
mg= x=="?" or(x!="ɸ" and (x==y or y=="ɸ"))
mgp.append(mg)
return all(mgp)
def min_generalizations(h,x):
h_new=list(h)
for i in range(len(h)):
if not consistent(h[i:i+1],x[i:i+1]):
h_new[i]="?" if h[i]!="ɸ" else x[i]
return [tuple(h_new)]

def min_specializations(h,domains,x):
results=[]
for i in range(len(h)):
if h[i]=="?":
for val in domains[i]:
if x[i]!=val:
h_new=h[:i]+(val,)+h[i+1:]
results.append(h_new)
elif h[i]!="ɸ":
h_new=h[:i]+("ɸ",)+h[i+1:] #IF IT IS ɸ, NOTHING TO DO, JUST COPY
AS IT IS
results.append(h_new)
return results

def generalize_S(x,G,S):
S_prev=list(S)
for s in S_prev:
if s not in S:
continue
 if not consistent(s,x):
S.remove(s)
Splus=min_generalizations(s,x)

S.update([h for h in Splus if any([consistent(g,h) for g in G])])

S.difference_update([h for h in S if any([consistent(h,h1) for h1 in S if
h!=h1])])
return S

def specialize_G(x,domains,G,S):
G_prev=list(G)
for g in G_prev:
if g not in G:
continue
if consistent(g,x):
G.remove(g)
Gminus=min_specializations(g,domains,x)

G.update([h for h in Gminus if any([consistent(h,s) for s in S])])

G.difference_update([h for h in G if any([consistent(h,g1) for g1 in G if
h!=g1])])
return G

def candidate_elimination(examples):
domains=get_domains(examples)[:-1]
G = set([("?",)*len(domains)])
S = set([("ɸ",)*len(domains)])
 i=0
print("\n G[{0}]:".format(i),G)
print("\n S[{0}]:".format(i),S)

for xcx in examples: #EXAMINE ALL ROWS

i=i+1
x,cx=xcx[:-1],xcx[-1]
if cx=="Y":
G={g for g in G if consistent(g,x)}
S=generalize_S(x,G,S)
else:
S={s for s in S if not consistent(s,x)}
G=specialize_G(x,domains,G,S)
print("\n G[{0}]:".format(i),G)
print("\n S[{0}]:".format(i),S)
return
candidate_elimination(examples)

4.
import math
import csv

def load_csv(filename):
lines=csv.reader(open(filename,"r"))
dataset = list(lines)
headers = dataset.pop(0)
 return dataset,headers

class Node:
def __init__ (self,attribute):
self.attribute=attribute
self.children=[]
self.answer=""

def subtables(data,col,delete):
dic={}
coldata=[row[col] for row in data]

attr=list(set(coldata))
counts=[0]*len(attr)
r=len(data)
c=len(data[0])
for x in range(len(attr)):
for y in range(r):
if data[y][col]==attr[x]:
counts[x]+=1
for x in range(len(attr)):
dic[attr[x]]=[[0 for i in range(c)] for j in range(counts[x])
pos=0
for y in range(r):
if data[y][col]==attr[x]:
if delete:
 del data[y][col]
dic[attr[x]][pos]=data[y]
pos+=1
return attr,dic

def entropy(S):
attr=list(set(S))
if len(attr)==1:
return 0
counts=[0,0]
for i in range(2):
counts[i]=sum([1 for x in S if attr[i]==x])/(len(S)*1.0)
sums=0
for cnt in counts:
sums+=-1*cnt*math.log(cnt,2)
return sums

def compute_gain(data,col):
attr,dic = subtables(data,col,delete=False)
total_size=len(data)
entropies=[0]*len(attr)
ratio=[0]*len(attr)
total_entropy=entropy([row[-1] for row in data])

for x in range(len(attr)):
ratio[x]=len(dic[attr[x]])/(total_size*1.0)
entropies[x]=entropy([row[-1] for row in dic[attr[x]]])
 total_entropy-=ratio[x]*entropies[x]
return total_entropy

def build_tree(data,features):
lastcol=[row[-1] for row in data]
if(len(set(lastcol)))==1:
node=Node("")
node.answer=lastcol[0]
return node
n=len(data[0])-1
gains=[0]*n
for col in range(n):
gains[col]=compute_gain(data,col)

split=gains.index(max(gains))
node=Node(features[split])

fea = features[:split]+features[split+1:]
attr,dic=subtables(data,split,delete=True)

for x in range(len(attr)):
child=build_tree(dic[attr[x]],fea)
node.children.append((attr[x],child))
return node

def print_tree(node,level):
 if node.answer!="":
print(" "*level,node.answer)
return
print(" "*level,node.attribute)
for value,n in node.children:
print(" "*(level+1),value)
print_tree(n,level+2)

def classify(node,x_test,features):
if node.answer!="":
print(node.answer)
return
pos=features.index(node.attribute)
for value, n in node.children:
if x_test[pos]==value:
classify(n,x_test,features)

dataset,features=load_csv("traintennis.csv")
node1=build_tree(dataset,features)
print("The decision tree for the dataset using ID3 algorithm is")
print_tree(node1,0)

testdata,features=load_csv("testtennis.csv")
for xtest in testdata:
print("The test instance:",xtest)
print("The label for test instance:",end=" ")
 classify(node1,xtest,features)

4 train.
import pandas as pd
from pprint import pprint
from sklearn.feature_selection import mutual_info_classif
from collections import Counter

def id3(df, target_attribute, attribute_names, default_class=None):

cnt=Counter(x for x in df[target_attribute])
if len(cnt)==1:
return next(iter(cnt))

elif df.empty or (not attribute_names):

return default_class

else:
gains =
mutual_info_classif(df[attribute_names],df[target_attribute],discrete_features=Tru
e)
index_of_max=gains.tolist().index(max(gains))
best_attr=attribute_names[index_of_max]
tree={best_attr:{}}
remaining_attribute_names=[i for i in attribute_names if i!=best_attr]
 for attr_val, data_subset in df.groupby(best_attr):
subtree=id3(data_subset, target_attribute,
remaining_attribute_names,default_class)
tree[best_attr][attr_val]=subtree

return tree

df=pd.read_csv("traintennis.csv")

attribute_names=df.columns.tolist()
print("List of attribute name")

attribute_names.remove("PlayTennis")

for colname in df.select_dtypes("object"):

df[colname], _ = df[colname].factorize()

print(df)

tree= id3(df,"PlayTennis", attribute_names)

print("The tree structure")
pprint(tree)
5.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)
y = y/100

def sigmoid (x):

return 1/(1 + np.exp(-x))

def derivatives_sigmoid(x):
return x * (1 - x)

epoch=5000
lr=0.1
inputlayer_neurons = 2
hiddenlayer_neurons = 3
output_neurons = 1

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))

for i in range(epoch):
hinp=np.dot(X,wh)+ bh
hlayer_act = sigmoid(hinp)
outinp=np.dot(hlayer_act,wout)+ bout
 output = sigmoid(outinp)

outgrad = derivatives_sigmoid(output)
hiddengrad = derivatives_sigmoid(hlayer_act)

EO = y-output
d_output = EO* outgrad

EH = d_output.dot(wout.T)
d_hiddenlayer = EH * hiddengrad

wout += hlayer_act.T.dot(d_output) *lr

wh += X.T.dot(d_hiddenlayer) *lr

print("Input: \n" + str(X))

print("Actual Output: \n" + str(y))
print("Predicted Output: \n" ,output)

6.
import csv
import random
import math

def loadcsv(filename):
dataset = list(csv.reader(open(filename,"r")))
for i in range(len(dataset)):
dataset[i] = [float(x) for x in dataset[i]]
 return dataset

def splitDataset(dataset, splitRatio):

trainSize = int(len(dataset) * splitRatio)
trainSet = []
trainSet,testSet = dataset[:trainSize],dataset[trainSize:]
return [trainSet, testSet]

def mean(numbers):
return sum(numbers)/(len(numbers))

def stdev(numbers):
avg = mean(numbers)
v=0
for x in numbers:
v += (x-avg)**2
return math.sqrt(v/(len(numbers)-1))

def summarizeByClass(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)
summaries = {}
for classValue, instances in separated.items():
 summaries[classValue] = [(mean(attribute), stdev(attribute)) for attribute in
zip(*instances)][:-1]
return summaries

def calculateProbability(x, mean, stdev):

exponent = math.exp((-(x-mean)**2)/(2*(stdev**2)))
return (1 / math.sqrt(2*math.pi*(stdev**2))) * exponent

def predict(summaries, inputVector):

probabilities = {}
for classValue, classSummaries in summaries.items():
probabilities[classValue] = 1
for i in range(len(classSummaries)):
mean, stdev = classSummaries[i]
x = inputVector[i]
probabilities[classValue] *= calculateProbability(x, mean, stdev)
bestLabel, bestProb = None, -1
for classValue, probability in probabilities.items():
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])
 predictions.append(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/(len(testSet))) * 100.0

filename = 'diabetes2.csv'
splitRatio = 0.9
dataset = loadcsv(filename)
actual = []
trainingSet, testSet = splitDataset(dataset, splitRatio)
for i in range(len(testSet)):
vector = testSet[i]
actual.append(vector[-1])
print('Split {0} rows into train={1} and test={2} rows'.format(len(dataset),
len(trainingSet), len(testSet)))
summaries = summarizeByClass(trainingSet) #will have (mean,sd) for all
attributes.(for class 1 & 0 separately)
predictions = getPredictions(summaries, testSet)
print('\nActual values:\n',actual)
print("\nPredictions:\n",predictions)
accuracy = getAccuracy(testSet, predictions)
print("Accuracy",accuracy)
7.
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
import sklearn.metrics as sm
import pandas as pd
import numpy as np

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']

print(X)
print(Y)
colormap = np.array(['red', 'lime', 'black'])

plt.subplot(1,2,1)
plt.scatter(X.Petal_Length, X.Petal_Width, c=colormap[Y.Targets], s=40)
plt.title('Real Clustering')

model1 = KMeans(n_clusters=3)
model1.fit(X)
plt.subplot(1,2,2)
plt.scatter(X.Petal_Length, X.Petal_Width, c=colormap[model1.labels_], s=40)
plt.title('K Mean Clustering')
plt.show()

model2 = GaussianMixture(n_components=3)
model2.fit(X)

plt.subplot(1,2,1)
plt.scatter(X.Petal_Length, X.Petal_Width, c=colormap[model2.predict(X)], s=40)
plt.title('EM Clustering')
plt.show()

print("Actual Target is:\n", iris.target)

print("K Means:\n",model1.labels_)
print("EM:\n",model2.predict(X))
print("Accuracy of KMeans is ",sm.accuracy_score(Y,model1.labels_))
print("Accuracy of EM is ",sm.accuracy_score(Y, model2.predict(X)))

8.
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
from sklearn.model_selection import train_test_split

iris_dataset=load_iris()
print("\n IRIS FEATURES \ TARGET NAMES: \n ", iris_dataset.target_names)
for i in range(len(iris_dataset.target_names)):
print("\n[{0}]:[{1}]".format(i,iris_dataset.target_names[i]))

print("\n IRIS DATA :\n",iris_dataset["data"])

X_train, X_test, y_train, y_test = train_test_split(iris_dataset["data"],

iris_dataset["target"], random_state=0)

print("\n Target :\n",iris_dataset["target"])

print("\n X TRAIN \n", X_train)
print("\n X TEST \n", X_test)
print("\n Y TRAIN \n", y_train)
print("\n Y TEST \n", y_test)

kn = KNeighborsClassifier(n_neighbors=5)
kn.fit(X_train, y_train)

x_new = np.array([[5, 2.9, 1, 0.2]])

print("\n XNEW \n",x_new)
prediction = kn.predict(x_new)
print("\n Predicted target value: {}\n".format(prediction))
print("\n Predicted feature name:
{}\n".format(iris_dataset["target_names"][prediction]))

i=1
x= X_test[i]
x_new = np.array([x])
print("\n XNEW \n",x_new)

for i in range(len(X_test)):
x = X_test[i]
x_new = np.array([x])
prediction = kn.predict(x_new)
print("\n Actual : {0} {1}, Predicted
:{2}{3}".format(y_test[i],iris_dataset["target_names"][y_test[i]],prediction,iris_dat
aset["target_names"][ prediction]))
print("\n TEST SCORE[ACCURACY]: {:.2f}\n".format(kn.score(X_test, y_test)))

9.
import numpy as np
import matplotlib.pyplot as plt

def local_regression(x0, X, Y, tau):

x0 = [1, x0]
X = [[1, i] for i in X]
X = np.asarray(X)
xw = (X.T) * np.exp(np.sum((X - x0) ** 2, axis=1) / (-2 * (tau**2)))
beta = (np.linalg.pinv(xw @ X)) @ (xw @ Y)
return (beta @ x0)

def draw(tau):
prediction = [local_regression(x0, X, Y, tau) for x0 in domain]
 plt.plot(X, Y, 'o', color='black')
plt.plot(domain, prediction, color='red')
plt.show()

X = np.linspace(-3, 3, num=1000)
domain = X
Y = np.log(np.abs((X ** 2) - 1) + .5)

draw(10)
draw(0.1)
draw(0.01)
draw(0.001)