1)import csv

num_attributes=6
a = []
print("\n The given training data set\n")

with open('[Link]','r') as csvfile:

reader = [Link](csvfile)
for row in reader:
[Link](row)
print(row)

print("\n The initial value of hypothesis: ")

hypothesis = ['0'] * num_attributes
print(hypothesis)

for j in range(0,num_attributes):
hypothesis[j]=a[0][j]

print(" Find S: Finding a maximally specific Hypothesis")

for i in range(0,len(a)):
if a[i][num_attributes] == 'yes':
for j in range(0,num_attributes):
if a[i][j] != hypothesis[j]:
hypothesis[j] ='?'
else:
hypothesis[j]= a[i][j]
print("for training instance no:{0} the hypothesis is:",format(i),hypothesis)

print("\n The Maximally Specific Hypothesis for a given training Example:\n")

print(hypothesis)

2)import pandas as pd
import numpy as np
df=pd.read_csv("[Link]")
df=[Link](['slno'],axis=1)

concepts=[Link][:,:-1]
target=[Link][:,-1]
[Link]()

def learn(concepts,target):
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]='?'
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(f"Final S: {s_final}")
print(f"Final G: {g_final}")

3)import pandas as pd
from pandas import DataFrame
from math import log
from collections import Counter
from pprint import pprint

df_tennis=pd.read_csv('[Link]')
df_tennis.keys()[0]
def entropy(probs):
return sum([-prob*log(prob,2) for prob in probs])
def entropy_of_list(a_list):
cnt=Counter(x for x in a_list)
num_instances=len(a_list)*1.0
probs=[x/num_instances for x in [Link]()]
return entropy(probs)
def information_gain(df,split_attribute_name, target_attribute_name):
df_split=[Link](split_attribute_name)
nobs=len([Link])*1.0
df_agg_ent=df_split.agg({target_attribute_name:[entropy_of_list, lambda x:
len(x)/nobs]})[target_attribute_name]
df_agg_ent.columns=['Entropy','PropObservations']
new_entropy=sum(df_agg_ent['Entropy']*df_agg_ent['PropObservations'])
old_entropy=entropy_of_list(df[target_attribute_name])
return old_entropy-new_entropy

def id3(df,target_attribute_name,attribute_names,default_class=None):
cnt=Counter(x for x in df[target_attribute_name])
if len(cnt)==1:
return next(iter(cnt))
elif [Link] or (not attribute_names):
return default_class
else:
default_class=max([Link]())
gainz=[information_gain(df,attr,target_attribute_name) for attr in attribute_names]
index_of_max= [Link](max(gainz))
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 [Link](best_attr):

subtree=id3(data_subset,target_attribute_name,remaining_attribute_names, default_class)
tree[best_attr][attr_val]=subtree
return tree

attribute_names=list(df_tennis.columns)
#Print("List of attributes:",attribute_names)
attribute_names.remove("PlayTennis")
#Print("List of attributes:",attribute_names)
tree=id3(df_tennis,'PlayTennis',attribute_names)
print("\n\n The Resultant Decision Tree is:\n")
pprint(tree)

4)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=1000
learning_rate=0.6
inputlayer_neurons=2
hiddenlayer_neurons=3
output_neurons=1
wh=[Link](size=(inputlayer_neurons, hiddenlayer_neurons))
bh=[Link](size=(1,hiddenlayer_neurons))
wo=[Link](size=(hiddenlayer_neurons,output_neurons))
bo=[Link](size=(1,output_neurons))
for i in range(epoch):
net_h=[Link](X,wh)+bh
sigma_h=sigmoid(net_h)
net_o=[Link](sigma_h,wo)+bo
output=sigmoid(net_o)
deltaK=(y-output)*derivatives_sigmoid(output)
deltaH=[Link](wo.T)*derivatives_sigmoid(sigma_h)
wo=wo+sigma_h.[Link](deltaK)*learning_rate
wh=wh+[Link](deltaH)*learning_rate

print(f"Input:\n{X}*")
print(f"Actual Ouput:\n{y}*")
print(f"Predicted Output:\n{output}")

5)from sklearn.model_selection import train_test_split

from [Link] import KNeighborsClassifier
from sklearn import datasets
iris=datasets.load_iris()
print("Iris Data set loaded...")
x_train, x_test, y_train, y_test= train_test_split([Link], [Link], test_size=0.1)
#randomstate = 0
for i in range(len(iris.target_names)):
print("Label",i,"-",str(iris.target_names[i]))
classifier=KNeighborsClassifier(n_neighbors=2)
[Link](x_train, y_train)
y_pred=[Link](x_test)
print("Results of Classification 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:",str(y_pred[r]))
print("Classification Accuracy:", [Link](x_test, y_test));

6)def probAttr(data,attr,val):
Total=[Link][0]
cnt=len(data[data[attr]==val])
return cnt,cnt/Total

def train(data,Attr,conceptVals,concept):
conceptProbs={}
countConcept={}

for cVal in conceptVals:

countConcept[cVal],conceptProbs[cVal]=probAttr(data,concept,cVal)

AttrConcept={}
probability_list={}

for att in Attr:

probability_list[att]={}
AttrConcept[att]={}

for val in Attr[att]:

AttrConcept[att][val]={}
a,probability_list[att][val]=probAttr(data,att,val)

for cVal in conceptVals:

dataTemp=data[data[att]==val]

AttrConcept[att][val][cVal]=len(dataTemp[dataTemp[concept]==cVal])/countConcept[cVal]

print(f"P(A):{conceptProbs}\n")
print(f"P(X/A):{AttrConcept}\n")
print(f"P(X):{probability_list}\n")

return conceptProbs,AttrConcept,probability_list

def test(examples,Attr,concept_list,conceptProbs,AttrConcept,probablity_list):
misclassification_count=0
Total=len(examples)
for ex in examples:
px={}
for a in Attr:
 for x in ex:
for c in concept_list:
if x in AttrConcept[a]:
if c not in px:
px[c]=conceptProbs[c]*AttrConcept[a][x][c]/probability_list[a][x]
else:
px[c]=px[c]*AttrConcept[a][x][c]/probability_list[a][x]
print(px)
classification=max(px,key=[Link])
print(f"Classification:{classification} Expected:{ex[-1]}")

if(classification!=ex[-1]):
misclassification_count+=1
misclassification_rate=misclassification_count*100/Total
accuracy=100-misclassification_rate

print(f"Misclassification Count={misclassification_count}")
print(f"Misclassification Rate={misclassification_rate}%")
print(f"Accuracy={accuracy}%")

import pandas as pd
df=pd.read_csv('[Link]')
concept=str(list(df)[-1])
concept_list=set(df[concept])
Attr={}

for a in [Link][:-1]:
Attr[a]=set(df[a])
print(f"{a}:{Attr[a]}")

conceptProbs,AttrConcept,probability_list=train(df,Attr,concept_list,concept)
examples=pd.read_csv('[Link]')
test([Link],Attr,concept_list,conceptProbs,AttrConcept,probability_list)

7)import numpy as np
import [Link] as plt

def local_regression(x0,X,Y,tau):
x0=[1,x0]
X=[[1,l] for l in X]
X=[Link](X)
xw=(X.T)*[Link]([Link]((X-x0)**2, axis=1)/(-2*tau))
beta=[Link](xw@X)@xw@Y@x0
return beta

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

X=[Link](-3,3,num=1000)
domain=X
Y=[Link]([Link](X**2-1)+.5)

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

8)import [Link] as plt

import numpy as np
import pandas as pd
from sklearn import preprocessing
from [Link] import KMeans
from [Link] import load_iris
from [Link] import GaussianMixture

iris=load_iris()
df = [Link](iris['data'],columns=iris['feature_names'])
df['target']= iris['target']

X=[Link][:,:-1]
y=df['target']

from sklearn import preprocessing

scaler=[Link]()
[Link](X)
X_scaled_array=[Link](X)
X_scaled=[Link](X_scaled_array,columns=[Link])

[Link](figsize=(14,7))
colormap=[Link](['red','green','blue'])
#REAL PLOT
[Link](1,3,1)
[Link](X_scaled['petal length (cm)'],X_scaled['petal width (cm)'],c=colormap[y],s=40)
[Link]('Real')
#K-PLOT
[Link](1,3,2)
model=KMeans(n_clusters=3,random_state=0)
pred_y=model.fit_predict(X)
pred_y=[Link](pred_y,[1,0,2]).astype(np.int64)
[Link](X_scaled['petal length (cm)'],X_scaled['petal width (cm)'],c=colormap[pred_y],s=40)
[Link]('KMeans')
#GMM PLOT
gmm=GaussianMixture(n_components=3,max_iter=200)
y_cluster_gmm=gmm.fit_predict(X_scaled)
y_cluster_gmm=[Link](y_cluster_gmm,[2,0,1]).astype(np.int64)
[Link](1,3,3)
[Link](X['petal length (cm)'],X['petal width (cm)'],c=colormap[y_cluster_gmm],s=40)
[Link]('GMM Classification')