FACULTY OF ENGINEERING AND TECHNOLOGY

Machine Learning Laboratory

(203105403)

7th SEMESTER

7A10 (CSE)

Name: ............................................................................................
Year/Sem: ....................................................................................
EnrollmentNo: ..................................................................
Course: ........................................................................................
 CERTIFICATE

This is to certify that

Mr./Ms..............................................................................................................
with enrolment no. ..........................................................................................
has successfully completed his/her laboratory experiments in the
Machine Learning Laboratory (203105403)
From the Department of ...............................................................

during the academic year ............................................

Date of Submission: -........................... Staff In charge: -...........................

 INDEX
SR DATE OF DATE OF
PRACTICAL LIST MARKS SIGN
NO START SUBMISSION
1 Write a program to demonstrate the
working of the decision tree-based
ID3 algorithm.
2 Build an Artificial Neural Network
by implementing the
Backpropagation algorithm and test
the same using appropriate
data sets.
3 Write a program to implement the
naïve Bayesian classifier for a
sample training data set stored as a
.CSV file. Compute
the accuracy of the classifier,
considering a few test data sets.
4 Assuming a set of documents that
need to be classified, use the naïve
Bayesian Classifier model to
perform this task.
5 Write a program to construct a
Bayesian network considering
medical data. Use this model to
demonstrate the diagnosis
of heart patients using standard
Heart Disease Data Set.
6 Apply EM algorithm to cluster a set
of data stored in a .CSV file. Use the
same data set for clusteringusing k-
Means
algorithm.
7 Write a program to implement the
K-Nearest Neighbour algorithm to
classify the iris data set.
8 Implement linear regression and
logistic regression.

9 Compare the various supervised

learning algorithm by using
appropriate dataset.
10 Compare the various Unsupervised
learning algorithm by using the
appropriate datasets.
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 1
AIM: Write a program to demonstrate the working of the decision tree
based ID3 algorithm.

1. import seaborn as sns

import [Link] as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from [Link] import DecisionTreeClassifier
from sklearn import metrics

2. dataset = datasets.load_iris()
x = [Link]
y = [Link]
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state =
3)

3. clf = DecisionTreeClassifier()
[Link](x_train, y_train)
y_pred = [Link](x_test)
accuracy = metrics.accuracy_score(y_test, y_pred)

4. confusion_matrix = metrics.confusion_matrix(y_test, y_pred)

print("Accuracy:", accuracy)
print("Confusion Matrix:")
labels = dataset.target_names
[Link](confusion_matrix, annot = True, fmt = "d", xticklabels = labels,
yticklabels = labels, cmap = "Blues", cbar = False)
[Link]("Predicted")
[Link]("True")
[Link]("Confusion Matrix")
[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 2
AIM: Build an Artificial Neural Network by implementing the
Backpropagation algorithm and test the same using appropriate data sets.

1. import pandas as pd
2. url = '[Link]
dbe/bigdatacertification/master/dataset/churn_trasnsformed_new.csv'
df_csv = pd.read_csv(url, sep=',',)
df_csv.head()

3. df = df_csv.drop("Unnamed: 0",axis=1)
[Link]()
[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

4. from [Link] import MinMaxScaler

mm_scaler = MinMaxScaler()
column_names = [Link]()
column_names.remove('Churn')
df[column_names] = mm_scaler.fit_transform(df[column_names])
df.sort_index(inplace=True)
[Link]()

5. feature = ['Churn']
train_feature = [Link](feature, axis=1)
train_target = df["Churn"]
train_feature.head(5)

6. from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(train_feature, train_target, shuffle =
True, test_size=0.3, random_state=1)
X_train.head()

7. from sklearn.neural_network import MLPClassifier

8. mlp = MLPClassifier(hidden_layer_sizes=(5), activation = 'relu', solver = 'adam',max_it

er= 10000, verbose = True)
mlp = [Link](X_train,y_train)
y_predmlp = [Link](X_test)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

9. print('Number of layer =', mlp.n_layers_)

print('Number of Iteration =', mlp.n_iter_)
print('Current loss computed with the loss function = ', mlp.loss_)

• Number of layer = 3
Number of Iteration = 137
Current loss computed with the loss function = 0.41786698381624476

10. from sklearn import metrics

11. cnf_matrixmlp = metrics.confusion_matrix(y_test, y_predmlp)

cnf_matrixmlp

• array([[1393, 192],
[ 217, 311]], dtype=int64)
[16]:
12. acc_mlp = metrics.accuracy_score(y_test, y_predmlp)
prec_mlp = metrics.precision_score(y_test, y_predmlp)
rec_mlp = metrics.recall_score(y_test, y_predmlp)
f1_mlp = metrics.f1_score(y_test, y_predmlp)
kappa_mlp = metrics.cohen_kappa_score(y_test, y_predmlp)
print("Accuracy:",acc_mlp)
print("Precision:",prec_mlp)
print("Recall:",rec_mlp)
print("F1 Score:",f1_mlp)
print("Cohens kappa Score",kappa_mlp)

• Accuracy: 0.8064363464268812
Precision: 0.6182902584493042
Recall: 0.5890151515151515
F1 Score: 0.6032977691561591
Cohens kappa Score 0.4753847881578428

2203051057146(Aayush Vaghela)
5
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

13. import seaborn as sns

import [Link] as plt
from [Link] import confusion_matrix

14. cnf_matrix = confusion_matrix(y_test, y_predmlp)

15. [Link](figsize=(8,6))

[Link](cnf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 3
Aim: Write a program to implement the naïve Bayesian classifier for a
sample training data set stored as a .CSV file. Compute the accuracy of the
classifier, considering a few test data sets.

1. import numpy as np
import pandas as pd
from [Link] import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from [Link] import accuracy_score, classification_report, confusion_matr
ix
import seaborn as sns
import [Link] as plt

2. playgolf_data = pd.read_csv("C:\\Users\\Uditi\\Desktop\\playgolf_data (1) [Link]"

)

3. playgolf_data

4. playgolf_data = pd.get_dummies(playgolf_data, columns=['Outlook'])

temperature_encoder = LabelEncoder()
2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

playgolf_data['Temperature']=temperature_encoder.fit_transform(playgolf_data['Temper ature'])

X= playgolf_data[['Outlook_Overcast', 'Outlook_Rainy', 'Outlook_Sunny','Temperature']]

y = playgolf_data['PlayGolf'].values

X_train, X_test,y_train , y_test = train_test_split(X, y ,test_size=0.25, random_state=0)scaler =

StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = [Link](X_test)

classifier = GaussianNB()
[Link](X_train, y_train)

y_pred =[Link](X_test)

print("accuracy:",accuracy_score(y_test,y_pred)) print("classification
report:\n", classification_report(y_test, y_pred))

confusion = confusion_matrix(y_test,y_pred)
confusion_df= [Link](confusion, index=['Actual No' ,'Actual Yes'],columns=['Actual
Yes','Actual No'])
print("Confusion Matrix:")
print(confusion_df)
[Link](confusion_df,annot=True,fmt='d', cmap='Blues' ,cbar=False)[Link]=('Predicted
label')
[Link]=('True label') [Link]=('Confusion
Matrix')
[Link]

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

Practical : 4

Aim: Assuming a set of documents that need to be classified, use the

naïveBayesian Classifier model to perform this task.

from sklearn.feature_extraction.text import CountVectorizerfrom

sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from [Link] import accuracy_score, classification_report

documents = [
{"text": "The Yankees won the game last night", "label": "sports"},Practical : 4 Aim:-
Assuming a set of documents that need to be classified, use the naïve Bayesian
Classifier model to perform this task.

from sklearn.feature_extraction.text import CountVectorizerfrom

sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from [Link] import accuracy_score, classification_report

documents = [
{"text": "The Yankees won the game last night", "label": "sports"},
{"text": "The president gave a speech today", "label": "politics"},
{"text": "The Lakers are on a winning streak", "label": "sports"},
{"text": "The government announced a new policy", "label": "politics"},
{"text": "The Cowboys lost to the Eagles", "label": "sports"},
{"text": "The economy is growing rapidly", "label": "politics"},
{"text": "The Bulls are on a losing streak", "label": "sports"},
{"text": "The president is visiting a foreign country", "label": "politics"},
{"text": "The Packers won the Super Bowl", "label": "sports"},
{"text": "The government is facing a crisis", "label": "politics"}
]

# Split the data into training and testing sets

train_docs, test_docs, train_labels, test_labels = train_test_split([doc["text"] for doc indocuments],
[doc["label"] for doc in documents], test_size=0.2, random_state=42)

# Create CountVectorizer Objectvectorizer =

CountVectorizer()

# fit the vectorizer to the training data and transform both the training and testing datax_train =
vectorizer.fit_transform(train_docs)
y_train = train_labels
x_test = [Link](test_docs)

# Train a Naive Bayes Classifierclf =

MultinomialNB() [Link](x_train,
y_train)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

y_pred = [Link](x_test)

# Evaluate the classifier

accuracy = accuracy_score(test_labels, y_pred)
print("Accuracy:", accuracy) print("Classification
Report:") print(classification_report(test_labels,
y_pred))

# Use the trained classifier to classify a new documentnew_doc

= "The Red Sox won the World Series" new_doc_vector =
[Link]([new_doc]) prediction =
[Link](new_doc_vector) print("Prediction for new
document:", prediction)

{"text": "The president gave a speech today", "label": "politics"},

{"text": "The Lakers are on a winning streak", "label": "sports"},
{"text": "The government announced a new policy", "label": "politics"},
{"text": "The Cowboys lost to the Eagles", "label": "sports"},
{"text": "The economy is growing rapidly", "label": "politics"},
{"text": "The Bulls are on a losing streak", "label": "sports"},
{"text": "The president is visiting a foreign country", "label": "politics"},
{"text": "The Packers won the Super Bowl", "label": "sports"},
{"text": "The government is facing a crisis", "label": "politics"}
]

# Split the data into training and testing sets

train_docs, test_docs, train_labels, test_labels = train_test_split([doc["text"] for doc indocuments],
[doc["label"] for doc in documents], test_size=0.2, random_state=42)

# Create CountVectorizer Objectvectorizer =

CountVectorizer()

# fit the vectorizer to the training data and transform both the training and testing datax_train =
vectorizer.fit_transform(train_docs)
y_train = train_labels
x_test = [Link](test_docs)

# Train a Naive Bayes Classifierclf =

MultinomialNB() [Link](x_train, y_train)
# Make predictions on the testing datay_pred =

[Link](x_test)

# Evaluate the classifier

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

accuracy = accuracy_score(test_labels, y_pred)

print("Accuracy:", accuracy) print("Classification
Report:") print(classification_report(test_labels,
y_pred))

# Use the trained classifier to classify a new documentnew_doc

= "The Red Sox won the World Series" new_doc_vector =
[Link]([new_doc]) prediction =
[Link](new_doc_vector) print("Prediction for new
document:", prediction)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 5
Aim: Write a program to construct a Bayesian network considering medicaldata.
Use this model to demonstrate the diagnosis of heart patients using standard
Heart Disease Data Set.

!pip install pgmpy

import pandas as pd
from [Link] import MaximumLikelihoodEstimator
from [Link] import BayesianModel
from [Link] import VariableElimination

data = pd.read_csv("/content/[Link]")
heart_disease = [Link](data)
print(heart_disease)

model = BayesianModel([

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester
('age', 'Lifestyle'),
('Gender', 'Lifestyle'),
('Family', 'heartdisease'),
('diet', 'cholestrol'),
('Lifestyle', 'diet'),
('cholestrol', 'heartdisease'),
('diet', 'cholestrol')
])

[Link](heart_disease, estimator=MaximumLikelihoodEstimator)

HeartDisease_infer = VariableElimination(model)

print('For Age SuperSeniorCitizen:0, SeiorCitizen:1, MiddleAged:2,Youth:3, Teen:4')

print('For Gender enter Male:0, Female:1')
print('For Family History enter Yes:1, No:0')
print('For Diet enter High:0,cMedium:1')
print('For Lifestyle enter Athlete:0, Active:1, Moderate:2, Sedentary:3')
print('For Cholesterol enter High:0, BorderLine:1, Normal:2')

q = HeartDisease_infer.query(variables=['heartdisease'], evidence=
{
'age': int(input('Enter Age: ')),
'Gender': int(input('Enter Gender: ')),
'Family': int(input('Enter Family History: ')),
'diet': int(input('Enter Diet: ')),
'Lifestyle': int(input('Enter Lifestyle: ')),
'cholestrol': int(input('Enter Cholesterol: '))
})

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

print(q)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 6
AIM: Apply EM algorithm to cluster a set of data stored in a .CSV file. Use
the same data set for clustering using k-Means algorithm.

1. from [Link] import KMeans

import pandas as pd
from [Link] import MinMaxScaler
from matplotlib import pyplot as plt
%matplotlib inline

2. df = pd.read_csv("C:\\Users\\Uditi\\Desktop\\income [Link]")
[Link]()

3. [Link]([Link],df['Income($)'])
[Link]('Age')
[Link]('Income($)')

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

4. km = KMeans(n_clusters=3)
y_predicted = km.fit_predict(df[['Age','Income($)']])
y_predicted
• array([1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 2])

5. df['cluster']=y_predicted
[Link]()

6. km.cluster_centers_
• array([[3.82857143e+01, 1.50000000e+05],
• [3.40000000e+01, 8.05000000e+04],
• [3.29090909e+01, 5.61363636e+04]])

7. df1 = df[[Link]==0]
df2 = df[[Link]==1]
df3 = df[[Link]==2]
[Link]([Link],df1['Income($)'],color='green')
[Link]([Link],df1['Income($)'],color='red')
[Link]([Link],df1['Income($)'],color='black')
[Link](km.cluster_centers_[:,0],km.cluster_centers_[:,1],color='purple',marker='*',
label='centroid')
[Link]('Age')
[Link]('Income ($)')
[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

8. scaler = MinMaxScaler()
[Link](df[['Income($)']])
df['Income($)'] = [Link](df[['Income($)']])
[Link](df[['Age']])
df['Age'] = [Link](df[['Age']])

9. [Link]()

10. km = KMeans(n_clusters=3)
y_predicted = km.fit_predict(df[['Age','Income($)']])
y_predicted
• array([0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2])

11. df['cluster']=y_predicted
[Link]()

12. km.cluster_centers_
• array([[0.1372549 , 0.11633428],
• [0.72268908, 0.8974359 ],
• [0.85294118, 0.2022792 ]])

13. df1 = df[[Link]==0]

df2 = df[[Link]==1]
df3 = df[[Link]==2]
[Link]([Link],df1['Income($)'],color='green')
[Link]([Link],df1['Income($)'],color='red')
[Link]([Link],df1['Income($)'],color='black')
[Link](km.cluster_centers_[:,0],km.cluster_centers_[:,1],color='purple',marker='*',
label='centroid')
[Link]('Age')
[Link]('Income ($)')
[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

1. sse = []
K_rng = range(1,10)
for K in K_rng:
km = KMeans(n_clusters=K)
[Link](df[['Age','Income($)']])
[Link](km.inertia_)

2. [Link]('K')
[Link]('Sum of squared error')
[Link](k_rng,sse)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 7

Aim: Write a program to implement the K-Nearest Neighbour algori

thm to classify the iris data set.

1. import pandas as pd
from [Link] import load_irisiris =
load_iris()

2. iris.feature_names ['sepal
length (cm)',sepal width
(cm)', 'petal length (cm)',
'petal width (cm)']

3. iris.target_names
array(['setosa', 'versicolor', 'virginica'], dtype='<U10')

[Link] = [Link]([Link],columns = iris.feature_names)[Link]()

[Link]['target'] = [Link]
[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

6. df[[Link]==1].head()

7. df[[Link]==2].head()

8. df['flower_names']=[Link](lambda x: iris.target_names[:x])
[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

9. df[45:55]

10. df0 = df[:50]

df1 = df[50:100]
df2 = df[100:]

11. import [Link] as plt

%matplotlib inline

12. [Link]('Sepal length')

[Link]('Sepal width')
[Link](df0['sepal length (cm)'],df0['sepal width (cm)'],color="green",marker='
+')
[Link](df1['sepal length (cm)'],df1['sepal width (cm)'],color="blue",marker='.')

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

13. [Link]('petal length')

[Link]('petal width')
[Link](df0['petal length (cm)'],df0['sepal width (cm)'],color="green",marker='+
')
[Link](df1['petal length (cm)'],df1['sepal width (cm)'],color="blue",marker='.')

14. from sklearn.model_selection import train_test_split

15. x=[Link](['target','flower_names'],axis='columns')
y=[Link]

16. x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2,random_state=1)

17. len(x_train)
• 120

18. len(x_test)
• 30

19. from [Link] import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=10)

20. [Link](x_train, y_train)

21. [Link](x_test,y_test)
• 0.9666666666666667

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

22. [Link]([[4.8,3.0,1.5,0.3]])
• array([0])

23. from [Link] import confusion_matrix

y_pred = [Link](x_test)
cm = confusion_matrix(y_test,y_pred)
cm
• array([[11, 0, 0],
[ 0, 12, 1],
[ 0, 0, 6]], dtype=int64)

24. %matplotlib inline

import [Link] as plt
import seaborn as sn
[Link](figsize=(7,5))
[Link](cm, annot=True)
[Link]('Predicted')
[Link]('Truth')

25. from [Link] import classification_report

print(classification_report(y_test,y_pred))

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 8

AIM: Implement linear regression and logistic regression.

LINEAR REGRESSION

1. import pandas as pd
import numpy as np
from sklearn import linear_model
import [Link] as plt

2. df = pd.read_csv("C:\\Users\\Uditi\\Desktop\\homeprices [Link]")
df

3. %matplotlib inline
[Link]('area')
[Link]('price')
[Link]([Link],[Link],color='red',marker='+')

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

4. new_df = [Link]('price',axis='columns')
new_df

5. price = [Link]
price

6. reg = linear_model.LinearRegression()
[Link](new_df,price)

7. [Link]([[3300]])
• array([628715.75342466])

8. reg.coef_
• array([135.78767123])

9. reg.intercept_
• 180616.43835616432

10. # Y = m * X + b

11. 3300*135.78767123 + 180616.43835616432

• 628715.7534151643

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

12. [Link]('area')
[Link]('price')
[Link]([Link],[Link],color='red',marker='+')
price=reg.coef_ *new_df + reg.intercept_
[Link](new_df, price, color='red', label='Linear Regression Line')

LOGISTIC REGRESSION
1. import pandas as pd
from matplotlib import pyplot as plt
%matplotlib inline

2. df=pd.read_csv('C:\\Users\\Uditi\\Desktop\\insurance_data [Link]')
[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

3. [Link]([Link],df.bought_insurance,marker='+',color='red')

4. from sklearn.model_selection import train_test_split

5. X_train, X_test, y_train, y_test =

train_test_split(df[['age']],df.bought_insurance,train_size=0.8)

6. X_test

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

7. X_train

8. from sklearn.linear_model import LogisticRegression

model = LogisticRegression()

9. [Link](X_train , y_train)

10. y_predicted = [Link](X_test)

11. model.predict_proba(X_test)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

12. [Link](X_test,y_test)
• 0.6666666666666666

13. y_predicted
• array([1, 1, 0, 1, 1, 0], dtype=int64)

14. model.coef_
• array([[0.33860165]])

15. model.intercept_
• array([-10.45240375])

16. import math

def sigmoid(x):
return 1/(1+[Link](-x))

17. def prediction_function(age):

z = 0.338* age - 10.45#
y = sigmoid(z)
return y

18. age=35
prediction_function(age)
• 0.7989910002494708

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 9
Aim: Compare the various supervised learning algorithm by using
appropriatedataset.

import numpy as np
import pandas as pd
import [Link] as plt
import seaborn as sns

%matplotlib inline

import os
print([Link]())

import warnings
[Link]('ignore'
)

dataset = pd.read_csv("/content/[Link]")
[Link]

[Link](5)

[Link]()

[Link]()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

info = ["age","1: male, 0: female","chest pain type, 1: typical angina, 2: atypical angina, 3: non-
anginal pain, 4: asymptomatic","resting blood pressure"," serum cholestoral in mg/dl","fasting
blood sugar > 120 mg/dl","resting electrocardiographic results (values 0,1,2)"," maximum heart
rate achieved","exercise induced angina","oldpeak = ST depression induced by exercise relative to
rest","the slope of the peak exercise ST segment","number of major vessels (0-3) colored by
flourosopy","thal: 3 = normal; 6 = fixed defect; 7 = reversable defect"]

for i in range(len(info)):
print([Link][i]+":\t\t\t"+info[i])

dataset["target"].describe()

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

dataset["target"].unique()

print([Link]()["target"].abs().sort_values(ascending=False))

EXploratory Data Analysis(EDA)

y = dataset["target"]

[Link](y)
target_temp = [Link].value_counts()
print(target_temp)

print("Percentage of patience without heart problems: "+str(round(target_temp[0]*100/303,2)))

print("Percentage of patience with heart problems: "+str(round(target_temp[1]*100/303,2)))

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

dataset["sex"].unique()

[Link](dataset["sex"])

Train Test Split

from sklearn.model_selection import train_test_split

predictors = [Link]("target", axis=1)

target = dataset["target"]

X_train, X_test, Y_train, Y_test = train_test_split(predictors, target,

test_size=0.20, random_state=0)

X_train.shape

X_test.shape

Y_train.shape

Y_test.shape

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

Model Fitting

from [Link] import accuracy_score

Logistic Regression

from sklearn.linear_model import

LogisticRegression lr = LogisticRegression()
[Link](X_train,Y_train)
Y_pred_lr = [Link](X_test)

Y_pred_lr.shape

score_lr = round(accuracy_score(Y_pred_lr,Y_test)*100,2)
print("The accuracy score achieved using Logistic Regression is: "+str(score_lr)+" %")

from [Link] import classification_report,confusion_matrix,accuracy_score

print(classification_report(Y_pred_lr,Y_test))

Naive Baye's

nb = GaussianNB()
[Link](X_train,Y_train)
Y_pred_nb = [Link](X_test)

Y_pred_nb.shape

score_nb = round(accuracy_score(Y_pred_nb,Y_test)*100,2)
print("The accuracy score achieved using Naive Bayes is: "+str(score_nb)+" %")

print(classification_report(Y_pred_nb,Y_test))

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

Support Vector Machine(SVM)

from sklearn import svm

sv = [Link](kernel='linear')
[Link](X_train, Y_train)
Y_pred_svm = [Link](X_test)

Y_pred_svm.shape

score_svm = round(accuracy_score(Y_pred_svm,Y_test)*100,2)

print("The accuracy score achieved using Linear SVM is: "+str(score_svm)+" %")

print(classification_report(Y_pred_svm,Y_test))

K Nearest Neighbours

knn = KNeighborsClassifier(n_neighbors=7)
[Link](X_train,Y_train)
Y_pred_knn=[Link](X_test)

Y_pred_knn.shape

score_knn = round(accuracy_score(Y_pred_knn,Y_test)*100,2)
print("The accuracy score achieved using KNN is: "+str(score_knn)+"
%")

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

Decision Tree

from [Link] import

DecisionTreeClassifier max_accuracy = 0

for x in range(200):
dt =
DecisionTreeClassifier(random_state=x)
[Link](X_train,Y_train)
Y_pred_dt = [Link](X_test)
current_accuracy = round(accuracy_score(Y_pred_dt,Y_test)*100,2)
if(current_accuracy>max_accuracy):
max_accuracy = current_accuracy
best_x = x

#print(max_accuracy)
#print(best_x)

dt = DecisionTreeClassifier(random_state=best_x)
[Link](X_train,Y_train)
Y_pred_dt = [Link](X_test)

print(Y_pred_dt.shape)

score_dt = round(accuracy_score(Y_pred_dt,Y_test)*100,2)
print("The accuracy score achieved using Decision Tree is: "+str(score_dt)+" %")

Random Forest

from [Link] import RandomForestClassifier

max_accuracy = 0

for x in range(2000):
rf = RandomForestClassifier(random_state=x)
[Link](X_train,Y_train)
Y_pred_rf = [Link](X_test)

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

current_accuracy = round(accuracy_score(Y_pred_rf,Y_test)*100,2)
if(current_accuracy>max_accuracy):
max_accuracy = current_accuracy
best_x = x

#print(max_accuracy)
#print(best_x)

rf = RandomForestClassifier(random_state=best_x)
[Link](X_train,Y_train)
Y_pred_rf = [Link](X_test)

Y_pred_rf.shape

score_rf = round(accuracy_score(Y_pred_rf,Y_test)*100,2)
print("The accuracy score achieved using Random Forest is: "+str(score_rf)+" %")

print(classification_report(Y_pred_rf,Y_test))

import xgboost as xgb

xgb_model = [Link](objective="binary:logistic", random_state=42)

xgb_model.fit(X_train, Y_train)

Y_pred_xgb = xgb_model.predict(X_test)

Y_pred_xgb.shape

score_xgb = round(accuracy_score(Y_pred_xgb,Y_test)*100,2)
print("The accuracy score achieved using XGBoost is: "+str(score_xgb)+" %")

print(classification_report(Y_pred_xgb,Y_test))

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

Output Final Score

scores = [score_lr,score_nb,score_svm,score_knn,score_dt,score_rf,score_xgb]
algorithms = ["Logistic Regression","Naive Bayes","Support Vector Machine","K-
Nearest Neighbors","Decision Tree","Random Forest","XGBoost"]

for i in range(len(algorithms)):
print("The accuracy score achieved using "+algorithms[i]+" is: "+str(scores[i])+" %")

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

PRACTICAL 10
Aim: Compare the various Unsupervised learning algorithm by using the
appropriate datasets.

Using K-Means Cluster:-

from [Link] import load_iris

from [Link] import KMeans
from [Link] import accuracy_score, f1_score, precision_score, recall_score
from [Link] import linear_sum_assignment
import [Link] as plt
import seaborn as sns
import pandas as pd
import numpy as np

# Load the iris dataset

iris = load_iris()
X = [Link]
y = [Link]

# Apply K-Means clustering

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans_labels = kmeans.fit_predict(X)

# Function to match predicted cluster labels to true labels

def cluster_labels_to_true_labels(y_true, y_pred):
D = [Link](([Link](y_pred) + 1, [Link](y_true) + 1), dtype=np.int32)
for i in range(y_pred.size):
D[y_pred[i], y_true[i]] += 1

row_ind, col_ind = linear_sum_assignment([Link]() - D)

return col_ind

# Function to compute evaluation metrics

def compute_metrics(y_true, y_pred):
y_pred_matched = cluster_labels_to_true_labels(y_true, y_pred)[y_pred]
accuracy = accuracy_score(y_true, y_pred_matched)
precision = precision_score(y_true, y_pred_matched, average='weighted')
recall = recall_score(y_true, y_pred_matched, average='weighted')
f1 = f1_score(y_true, y_pred_matched, average='weighted')
return accuracy, precision, recall, f1

# Compute metrics for K-Means clustering

kmeans_metrics = compute_metrics(y, kmeans_labels)

# Plot the results

df = [Link](X, columns=iris.feature_names)
df['Cluster'] = kmeans_labels
df['True Label'] = y
2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

[Link](df, hue='Cluster', palette='viridis')

[Link]('K-Means Clustering')
[Link]()

# Print evaluation metrics

print(f"Accuracy: {kmeans_metrics[0]:.4f}")
print(f"Precision: {kmeans_metrics[1]:.4f}")
print(f"Recall: {kmeans_metrics[2]:.4f}")
print(f"F1 Score: {kmeans_metrics[3]:.4f}")

Using Hierarchical Clustering:-

from [Link] import dendrogram, linkage

from [Link] import AgglomerativeClustering
from [Link] import accuracy_score, f1_score, precision_score, recall_score
from [Link] import linear_sum_assignment
import numpy as np
import [Link] as plt

# Load the iris dataset

from [Link] import load_iris
iris = load_iris()
X = [Link]
2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

# Function to match predicted cluster labels to true labels

def cluster_labels_to_true_labels(y_true, y_pred):
D = [Link](([Link](y_pred) + 1, [Link](y_true) + 1), dtype=np.int32)
for i in range(y_pred.size):
D[y_pred[i], y_true[i]] += 1
row_ind, col_ind = linear_sum_assignment([Link]() - D)
return col_ind

# Function to compute evaluation metrics

def compute_metrics(y_true, y_pred):
y_pred_matched = cluster_labels_to_true_labels(y_true, y_pred)[y_pred]
accuracy = accuracy_score(y_true, y_pred_matched)
precision = precision_score(y_true, y_pred_matched, average='weighted')
recall = recall_score(y_true, y_pred_matched, average='weighted')
f1 = f1_score(y_true, y_pred_matched, average='weighted')
return accuracy, precision, recall, f1
# Apply hierarchical clustering
hierarchical = AgglomerativeClustering(n_clusters=3)
hierarchical_labels = hierarchical.fit_predict(X)

# Compute metrics for hierarchical clustering

hierarchical_metrics = compute_metrics(y, hierarchical_labels)

# Plot the dendrogram

linked = linkage(X, 'ward')
[Link](figsize=(10, 7))
dendrogram(linked, labels=y)
[Link]('Hierarchical Clustering Dendrogram')
[Link]()

# Print evaluation metrics

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

print(f"Accuracy: {hierarchical_metrics[0]:.4f}")
print(f"Precision: {hierarchical_metrics[1]:.4f}")
print(f"Recall: {hierarchical_metrics[2]:.4f}")
print(f"F1 Score: {hierarchical_metrics[3]:.4f}")

Using DBSCAN:-

from [Link] import DBSCAN

from [Link] import accuracy_score, f1_score, precision_score, recall_score
from [Link] import linear_sum_assignment
import [Link] as plt
import seaborn as sns
import pandas as pd
import numpy as np
from [Link] import load_iris

# Load the iris dataset

iris = load_iris()
X = [Link]
y = [Link]

# Apply DBSCAN
dbscan = DBSCAN(eps=0.5, min_samples=5)
dbscan_labels = dbscan.fit_predict(X)

# Function to match predicted cluster labels to true labels

def cluster_labels_to_true_labels(y_true, y_pred):
D = [Link](([Link](y_pred) + 1, [Link](y_true) + 1), dtype=np.int32)
for i in range(y_pred.size):
D[y_pred[i], y_true[i]] += 1
row_ind, col_ind = linear_sum_assignment([Link]() - D)
return col_ind

# Function to compute evaluation metrics

def compute_metrics(y_true, y_pred):
y_pred_matched = cluster_labels_to_true_labels(y_true, y_pred)[y_pred]
accuracy = accuracy_score(y_true, y_pred_matched)
precision = precision_score(y_true, y_pred_matched, average='weighted')
recall = recall_score(y_true, y_pred_matched, average='weighted')
f1 = f1_score(y_true, y_pred_matched, average='weighted')
return accuracy, precision, recall, f1

# Filter out noise points (-1) from DBSCAN labels

valid_labels = dbscan_labels != -1
dbscan_labels_filtered = dbscan_labels[valid_labels]
y_filtered = y[valid_labels]
2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

# Compute metrics for DBSCAN clustering

dbscan_metrics = compute_metrics(y_filtered, dbscan_labels_filtered)

# Plot the results

df = [Link](X, columns=iris.feature_names)
df['Cluster'] = dbscan_labels
df['True Label'] = y
[Link](df, hue='Cluster', palette='viridis')
[Link]('DBSCAN Clustering')
[Link]()

# Print evaluation metrics

print(f"Accuracy: {dbscan_metrics[0]:.4f}")
print(f"Precision: {dbscan_metrics[1]:.4f}")
print(f"Recall: {dbscan_metrics[2]:.4f}")
print(f"F1 Score: {dbscan_metrics[3]:.4f}")

Using Gaussian Mixture Models (GMM):-

from [Link] import GaussianMixture

from [Link] import accuracy_score, f1_score, precision_score, recall_score
from [Link] import linear_sum_assignment
import [Link] as plt
2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

import seaborn as sns

import pandas as pd
import numpy as np

from [Link] import load_iris

# Load the iris dataset
iris = load_iris()
X = [Link]
y = [Link]

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester

# Apply Gaussian Mixture Models (GMM)

gmm = GaussianMixture(n_components=3,
random_state=42)gmm_labels = gmm.fit_predict(X)

# Function to match predicted cluster labels to true

labelsdef cluster_labels_to_true_labels(y_true,
y_pred):
D = [Link](([Link](y_pred) + 1, [Link](y_true) + 1),
dtype=np.int32)for i in range(y_pred.size):
D[y_pred[i], y_true[i]] += 1
row_ind, col_ind = linear_sum_assignment([Link]() -
D)return col_ind

# Function to compute
evaluation metricsdef
compute_metrics(y_true,
y_pred):
y_pred_matched = cluster_labels_to_true_labels(y_true,
y_pred)[y_pred]accuracy = accuracy_score(y_true,
y_pred_matched)
precision = precision_score(y_true, y_pred_matched,
average='weighted')recall = recall_score(y_true, y_pred_matched,
average='weighted')
f1 = f1_score(y_true, y_pred_matched,
average='weighted')return accuracy, precision, recall,
f1
# Compute metrics for GMM clustering
gmm_metrics = compute_metrics(y,
gmm_labels)# Plot the results
df = [Link](X,
columns=iris.feature_names)df['Cluster'] =
gmm_labels
df['True Label'] = y
[Link](df, hue='Cluster',
palette='viridis')[Link]('GMM
Clustering')
[Link]()

# Print evaluation metrics

2203051057146(Aayush Vaghela)
 Faculty of Engineering & Technology
Machine Learning (203105403)
B. Tech CSE 4th Year/ 7th Semester
print(f"Accuracy:
{gmm_metrics[0]:.4f}")
print(f"Precision:
{gmm_metrics[1]:.4f}")print(f"Recall:
{gmm_metrics[2]:.4f}") print(f"F1
Score: {gmm_metrics[3]:.4f}")

2203051057146(Aayush Vaghela)