Outcome based Laboratory Record

-201CS122
 MACHINE LEARNING 18CS504

B.E & COMPUTER SCIENCE ENGINEERING

Vth SEM

Academic Year 2022-2023

Submitted by
ARUNPRASADH C
201CS122

BANNARI AMMAN INSTITUTE OF

TECHNOLOGY
(An Autonomous Institution Affiliated to Anna University, Chennai)

SATHYAMANGALAM - 638 401

1
 BANNARI AMMAN INSTITUTE OF TECHNOLOGY
(An Autonomous Institution Affiliated to Anna University, Chennai)

SATHYAMANGALAM - 638 401

DEPARTMENT OF
COMPUTER SCIENCE ENGINEERING

BONAFIDE CERTIFICATE

This is a Certified Bonafide Record Book of Mr. ARUNPRASADH C, Register number

201CS122 submitted for the MACHINE LEARNING laboratory during the academic year
2022-2023.

Staff in - charge Head of the Department

2
 18CS508 – MACHINE LEARNING LABARATORY

Course Outcomes
1. Consider a set of training data examples and implement algorithms to find the
most specific hypothesis and set of all hypotheses that are consistent with the
training examples.

2. Build computational models consisting of several processing elements to

receive inputs and deliver outputs based on activation functions. Apply decision tree
model, artificial neural networks, bayesian learning, instance based learning and
reinforcement learning for approximation of classification, clustering, prediction
algorithms to get the desired output.

3
 Table of Contents

S. No. Name of the Experiment Page No. Marks Signature

Awarded

1 Implementation of Candidate 4
Elimination Algorithm for the
dataset: Economy Car Dataset
2 Implementation of Random Forest 16
Classification Algorithm for the
dataset: Social networks ads Dataset
3. Implementation of Find S
Algorithm and Decision tree
algorithm
4. Implementation of KNN for the
dataset: Glass Identification
Dataset

4
 Implementation of Candidate Elimination Algorithm for the
dataset: Economy Car Dataset

AIM:

Implement and demonstrate the Candidate Elimination algorithm is a type of

supervised ML algorithm that can be used for the classification and prediction

ALGORITHM:
Step1: Load Data set
Step2: Initialize General Hypothesis and Specific Hypothesis.
Step3: For each training example
Step4: If example is positive example if
attribute_value == hypothesis_value:
Do nothing else:
replace attribute value with '?' (Basically generalizing it)
Step5: If example is Negative example
Make generalize hypothesis more specific
Coding:
import csv

# open the CSVFile and keep all rows as list of tuples with
open('EnjoySport.csv') as csvFile:

examples = [tuple(line) for line in csv.reader(csvFile)]

print(examples)

# To obtain the domain of attribute values defined in the instances X

def get_domains(examples):

5
 # set function returns the unordered collection of items with no
duplicates d = [set() for i in examples[0]] for x in examples:
#Enumerate() function adds a counter to an iterable and returns
it in a form of enumerate object i.e(index,value) for i, xi in
enumerate(x): d[i].add(xi) return [list(sorted(x)) for x in d] # Test the
get_domains function get_domains(examples)
# Repeat the '?' and '0' length of domain no of times
def g_0(n):
return ('?',)*n

def s_0(n):
return ('0',)*n
# Function to check generality between two hypothesis
def more_general(h1, h2): more_general_parts = [] for
x, y in zip(h1, h2):
mg = x == '?' or (x != '0' and (x == y or y == '0'))
more_general_parts.append(mg)
return all(more_general_parts) # Returns true if all elements of list or tuple are
true

# Function to check whether train examples are consistent with hypothesis

def consistent(hypothesis,example):
return more_general(hypothesis, example)

# Function to add min_generalizations

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]):
if h[i] != '0':
h_new[i] = '?'
else:
h_new[i] = x[i]
return [tuple(h_new)]

# Function to generalize Specific

hypto 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)
# Keep only generalizations that have a counterpart in
G S.update([h for h in Splus if any([more_general(g,h)
for g in G])])
# Remove from S any hypothesis more general than any other hypothesis in S
S.difference_update([h for h in S if any([more_general(h, h1) for h1 in S
if h != h1])])
return S
6
# Function to add min_specializations 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] != '0':
h_new = h[:i] + ('0',) + h[i+1:] results.append(h_new)
return results

# Function to specialize General hypotheses

boundary 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)
# Keep only specializations that have a counterpart in
S G.update([h for h in Gminus if any([more_general(h,
s) for s in S])])
# Remove hypothesis less general than any other hypothesis in G
G.difference_update([h for h in G if any([more_general(g1, h)
for g1 in G if h != g1])])
return G
# Function to perform CandidateElimination
def candidate_elimination(examples):
domains = get_domains(examples)[:-1]

G = set([g_0(len(domains))]) S = set([s_0(len(domains))]) i=0

print('All the hypotheses in General and Specific boundary are:\n')
print('\n G[{0}]:'.format(i),G)
print('\n S[{0}]:'.format(i),S) for
xcx in examples:
i=i+1 x, cx = xcx[:-1], xcx[-1] # Splitting data into attributes and
decisions if cx=='Yes': # x is positive example
G = {g for g in G if consistent(g,x)}
S = generalize_S(x, G, S) else:
# x is negative example
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
#import pixiedust # Visual debugger
#%%pixie_debugger candidate_elimination(examples)

7
OUTPUT:

8
RESULT:

Successfully completed Candidate Elimination algorithm implementation using Economy

Car dataset in google-colab.

9
2.Implementation of Random Forest Classification Algorithm for the
dataset: Social Networks Ads Dataset

AIM:
Implement and demonstrate the Random Forest Classification algorithm is a type
of supervised ML algorithm that can be used for the classification and prediction of the
final result

ALGORITHM:

Step-1: Select random K data points from the training set.

Step-2: Build the decision trees associated with the selected data points (Subsets).

Step-3: Choose the number N for decision trees that you want to build.

Step-4: Repeat Step 1 & 2.

Step-5: For new data points, find the predictions of each decision tree, and assign the
new data points to the category that wins the majority votes.

CODING:
# Random Forest Classification # Importing the libraries

import numpy as np import matplotlib.pyplot as plt import

pandas as pd dataset =

pd.read_csv('../input/Social_Network_Ads.csv')

X = dataset.iloc[:, [2, 3]].values y

= dataset.iloc[:, 4].values

# Splitting the dataset into the Training set and Test set from

sklearn.model_selection import train_test_split

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

# Feature Scaling

from sklearn.preprocessing import StandardScaler sc

= StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

# Fitting Random Forest Classification to the Training set from

sklearn.ensemble import RandomForestClassifier

classifier = RandomForestClassifier(n_estimators = 10, criterion =

'entropy', random_state = 0)

classifier.fit(X_train, y_train)

# Predicting the Test set results y_pred

= classifier.predict(X_test)

# Making the Confusion Matrix

from sklearn.metrics import confusion_matrix cm =
confusion_matrix(y_test, y_pred)
#Display the results for Confusion matrix
cm

# Visualising the Training set results

from matplotlib.colors import ListedColormap
X_set, y_set = X_train, y_train
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.55, cmap = ListedColormap(('red', 'green')))
11
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max()) for i, j in
enumerate(np.unique(y_set)):
plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], c
= ListedColormap(('red', 'green'))(i), label = j)
plt.title('Random Forest Classification (Training set)')
plt.xlabel('Age') plt.ylabel('Estimated Salary')
plt.legend() plt.show()

# Visualising the Test set results

from matplotlib.colors import ListedColormap
X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.55, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max()) for i, j in
enumerate(np.unique(y_set)):
plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], c
= ListedColormap(('red', 'green'))(i), label = j)
plt.title('Random Forest Classification (Test set)')
plt.xlabel('Age') plt.ylabel('Estimated Salary')
plt.legend() plt.show()
Dataset:

12
OUTPUT:

13
RESULT:

Successfully completed Random Forest Classification implementation using Social

Networks ads dataset in google-colab.

14