Notes

PROGRAM 1:
import csv
def read_data(filename):
with open(filename,'r') as csvfile:
datareader=csv.reader(csvfile,delimiter=',')
traindata=[]
for row in datareader:
traindata.append(row)
return(traindata)
def findS():
dataarr=read_data('data.csv')
'''print(dataarr)'''
h=dataarr[0]
rows=len(dataarr)
columns=7
for x in range(1,rows):
t=dataarr[x]
if t[columns-1]=='0':
pass
elif t[columns-1]=='1':
for y in range (columns):
if h[y]==t[y]:
pass
else:
h[y]='?'
print("maximally specific set hypothesis is:")
print('<',end='')
for i in range(0,len(h)-1):
print(h[i],end=',')
print('>')
findS()

PROGRAM 4:
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)
def sigmoid (x):
return (1/(1 + np.exp(-x)))
def derivatives_sigmoid(x):
return x * (1 - x)
epoch=7000
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):
hinp1=np.dot(X,wh)
hinp=hinp1 + bh
hlayer_act = sigmoid(hinp)
outinp1=np.dot(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.T.dot(d_output) *lr
bout += np.sum(d_output, axis=0,keepdims=True) *lr
wh += X.T.dot(d_hiddenlayer) *lr
print("Input: n" + str(X))
print("Actual Output: n" + str(y))
print("Predicted Output: n" ,output)


PROGRAM 5:
import csv
import random
import math
def loadcsv(filename):
lines = csv.reader(open(filename, "r"))
dataset = list(lines)
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 = []
copy = list(dataset)
while len(trainSet) < trainSize:
index = random.randrange(len(copy))
trainSet.append(copy.pop(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)
return separated
def mean(numbers):
return sum(numbers)/float(len(numbers))
def stdev(numbers):
avg = mean(numbers)
variance = sum([pow(x-avg,2) for x in numbers])/float(len(numbers)-1)
return math.sqrt(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)
summaries = {}
for classValue, instances in separated.items():
summaries[classValue] = summarize(instances)
return summaries
def calculateProbability(x, mean, stdev):
exponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))
return (1 / (math.sqrt(2*math.pi) * stdev)) * exponent
def calculateClassProbabilities(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)
return probabilities
def predict(summaries, inputVector):
probabilities = calculateClassProbabilities(summaries, inputVector)
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/float(len(testSet))) * 100.0
def main():
filename = 'C:\Users\MCA\Desktop\pima-indians-diabetes.csv'
splitRatio = 0.67
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 Testing Set:{0}
rows'.format(len(testSet)))
print("n First Five Rows of Training Set:n")
for i in range(0,5):
print(trainingSet[i],"n")
print("n First Five Rows of Testing Set:n")
for i in range(0,5):
print(testSet[i],"n")
summaries = summarizeByClass(trainingSet)
print("n Model Summaries:n",summaries)
predictions = getPredictions(summaries, testSet)
print("nPredictions:n",predictions)
accuracy = getAccuracy(testSet, predictions)
print('n Accuracy: {0}%'.format(accuracy))
main()


PROGRAM 6:
import pandas as pd
msg=pd.read_csv('naivetext1.csv',names=['message','label'])
print('The dimensions of the dataset',msg.shape)
msg['labelnum']=msg.label.map({'pos':1,'neg':0})
X=msg.message
y=msg.labelnum
print(X)
print(y)
from sklearn.model_selection import train_test_split
xtrain,xtest,ytrain,ytest=train_test_split(X,y)
print(xtest.shape)
print(xtrain.shape)
print(ytest.shape)
print(ytrain.shape)
from sklearn.feature_extraction.text import CountVectorizer
count_vect = CountVectorizer()
xtrain_dtm = count_vect.fit_transform(xtrain)
xtest_dtm=count_vect.transform(xtest)
from sklearn.naive_bayes import MultinomialNB
clf = MultinomialNB().fit(xtrain_dtm,ytrain)
predicted = clf.predict(xtest_dtm)
from sklearn import metrics
print('Accuracy metrics')
print('Accuracy of the classifer
is',metrics.accuracy_score(ytest,predicted))
print('Confusion matrix')
print(metrics.confusion_matrix(ytest,predicted))
print('Recall and Precison ')
print(metrics.recall_score(ytest,predicted))
print(metrics.precision_score(ytest,predicted))
6th program.txt
Displaying 5th program.txt.


PROGRAM 7:
from pomegranate import*
asia = DiscreteDistribution ({'True':0.5,'False':0.5})
tuberculosis=ConditionalProbabilityTable(
[['True', 'True', 0.2],
['True', 'False', 0.8],
['False', 'True', 0.01],
['False', 'False', 0.98]], [asia])
smoking = DiscreteDistribution({ 'True':0.5, 'False':0.5 })
lung = ConditionalProbabilityTable(
[[ 'True', 'True', 0.75],
['True', 'False',0.25],
[ 'False', 'True', 0.02],
[ 'False', 'False', 0.98]], [smoking])
bronchitis = ConditionalProbabilityTable(
[[ 'True', 'True', 0.92],
['True', 'False',0.08],
[ 'False', 'True',0.03],
[ 'False', 'False', 0.98]], [smoking])
tuberculosis_or_cancer = ConditionalProbabilityTable( [[ 'True', 'True',
'True', 1.0], ['True', 'True', 'False', 0.0],
['True', 'False', 'True', 1.0],
['True', 'False', 'False', 0.0],
['False', 'True', 'True', 1.0],
['False', 'True', 'False', 0.0],
['False', 'False' 'True', 1.0],
['False', 'False', 'False', 0.0]], [tuberculosis, lung])
Xray = ConditionalProbabilityTable( [[ 'True', 'True', 0.885], ['True',
'False', 0.115],
[ 'False', 'True', 0.04], [ 'False', 'False', 0.96]],
[tuberculosis_or_cancer])
dyspnea = ConditionalProbabilityTable( [[ 'True', 'True', 'True', 0.96],
['True', 'True', 'False', 0.04], ['True', 'False', 'True', 0.89],
['True', 'False', 'False', 0.11], ['False', 'True', 'True', 0.96],
['False', 'True', 'False', 0.04], ['False', 'False' ,'True', 0.89],
['False', 'False', 'False', 0.11 ]], [tuberculosis_or_cancer, bronchitis])
s0 = State(asia, name="asia")
s1 = State(tuberculosis, name="tuberculosis")
s2 = State(smoking, name="smoker")
network = BayesianNetwork("asia")
network.add_nodes(s0,s1,s2)
network.add_edge(s0,s1)
network.add_edge(s1,s2)
network.bake()
print(network.predict_proba({'tuberculosis': 'True'}))



PROGRAM 8:
from sklearn.cluster import KMeans
from sklearn import preprocessing
from sklearn.mixture import GaussianMixture
from sklearn.datasets import load_iris
import sklearn.metrics as sm
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
dataset=load_iris()
X=pd.DataFrame(dataset.data)
X.columns=['Sepal_Length','Sepal_Width','Petal_Length','Petal_Width']
y=pd.DataFrame(dataset.target)
y.columns=['Targets']
plt.figure(figsize=(14,7))
colormap=np.array(['red','lime','black'])
plt.subplot(1,3,1)
plt.scatter(X.Petal_Length,X.Petal_Width,c=colormap[y.Targets],s=40)
plt.title('Real')
plt.subplot(1,3,2)
model=KMeans(n_clusters=3).fit(X)
predY=np.choose(model.labels_,[0,1,2]).astype(np.int64)
plt.scatter(X.Petal_Length,X.Petal_Width,c=colormap[predY],s=40)
plt.title('KMeans')
scaler=preprocessing.StandardScaler().fit(X)
gmm=GaussianMixture(n_components=3).fit(X)
y_cluster_gmm=gmm.predict(X)
plt.subplot(1,3,3)
plt.scatter(X.Petal_Length,X.Petal_Width,c=colormap[y_cluster_gmm],s=40)
plt.title('GMM Classification')
sm.accuracy_score(y, predY)
sm.confusion_matrix(y,predY)


PROGRAM 9:
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, confusion_matrix
from sklearn import datasets
import pandas as pd
import numpy as np
iris=datasets.load_iris()
iris_data=iris.data
iris_labels=iris.target
#print(iris_data)
#print(iris_labels)
x_train,x_test,y_train,y_test=train_test_split(iris_data,iris_labels)
classifier=KNeighborsClassifier(n_neighbors=5)
classifier.fit(x_train,y_train)
y_pred=classifier.predict(x_test)
print('Confusion matrix is as follows')
print(confusion_matrix(y_test,y_pred))
print('Accuracy Metrics')
print(classification_report(y_test,y_pred))


PROGRAM 10:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_boston
%matplotlib inline
boston=load_boston()
features=pd.DataFrame(boston.data,columns=boston.feature_names)
target=pd.DataFrame(boston.target,columns=['target'])
data=pd.concat([features,target],axis=1)
data.head(10)
x=data["RM"]
y=data["target"]
X=np.array(x/x.mean())
Y=np.array(y/y.mean())
n=int(0.5*len(X))
x_train=X[:n]
y_train=Y[:n]
x_test=X[n:]
y_test=Y[n:]
len(y_test)
plt.plot(x_train,y_train,'r.')
def h(x,a,b):
return a*x+b
def error(a,x,b,y):
e=0
m=len(x)
for i in range(m):
e+=np.power(h(x[i],a,b)-y[i],2)
return (1/(2*m))*e
def step_gradient(a,x,b,y,learning_rate):
grad_a=0
grad_b=0
m=len(x)
for i in range(m):
grad_a+=(2/m)*((h(x[i],a,b)-y[i])*x[i])
grad_b+=(2/m)*(h(x[i],a,b)-y[i])
a=a-(grad_a*learning_rate)
b=b-(grad_b*learning_rate)
return a,b
def descent(initial_a,initial_b,x,y,learning_rate,iterations):
a=initial_a
b=initial_b
for i in range(iterations):
e=error(a,x,b,y)
if i%1000==0:
print(f"{e}---a:{a}, b:{b}")
a,b=step_gradient(a,x,b,y,learning_rate)
return a,b
a=0
b=1

ia=2.4042710103368203
ib=-1.348320315336314
learning_rate=0.01
iterations=10000
final_a,final_b=descent(a,b,x_train,y_train,learning_rate,iterations)
plt.plot(x_train,y_train,'r.',x_train,h(x_train,final_a,final_b),'b',)
print(error(a,x_test,b,y_test))
print(error(final_a,x_test,final_b,y_test))
plt.plot(x_test,y_test,'r.',x_train,y_train,'b.')