21ECE305J – Machine Learning Algorithms
A Laboratory Record
Submitted by
Register No.:
Name:
in partial fulfillment for the award of the degree of
BACHELOR OF TECHNOLOGY
IN
ELECTRONICS AND COMMUNICATION ENGINEERING
DEPARTMENT OF ELECTRONICS AND COMMUNICATION
ENGINEERING FACULTY OF ENGINEERING AND TECHNOLOGY
SRM INSTITUTE OF SCIENCE AND TECHNOLOGY
VADAPALANI CAMPUS, CHENNAI – 26
OCTOBER 2024
BONAFIDE CERTIFICATE
Register No: Date:
Certified that this laboratory manual is the Bonafide record of _________, of
III Year, B.Tech Electronics and Communication Engineering who
carried out the laboratory work of Subject Code/Title: 21ECE305J –
MACHINE LEARNING ALGORITHMS under my supervision in the
academic year 2024-2025.
Date: Faculty-in-Charge Head of the Department
Submitted for University Examination held in of
SRM INSTITUTE OF SCIENCE AND TECHNOLOGY
Date: Examiner -I Examiner -II
Index
Ex No Date Experiment Sign
1 Linear Regression
2 Logistic Regression
3 K-Fold
4 Support Vector Machine
5 K-Nearest Neighbor
6 K-Means Clustering
7 Hierarchical Clustering
8 Principal Component Analysis
EX NO: 1
Implementation of Linear Regression
DATE:
Aim: To perform linear regression using dataset samples..
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
A) Linear regression using random data sample
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)
m = 50 # creating 50 samples
X = np.linspace(0,10,m).reshape(m,1)
y = X + np.random.randn(m,1)
print(X)
len(X)
len(y)
plt.scatter(X,y)
from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(X,y)
model.score(X,y)
Prediction = model.predict(X)
plt.scatter(X,y)
plt.plot(X,Prediction,'r')
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
mae = mean_absolute_error(X, Prediction)
mse = mean_squared_error(X, Prediction)
rmse = np.sqrt(mse)
r_squared = r2_score(X, Prediction)
print("Mean Absolute Error (MAE)=", mae)
print("Mean Squared Error (MSE)=", mse)
print("R-squared (R-squ)=", r_squared)
print("Root Mean Squared Error (RMSE)=", rmse)
Output:
Accuracy: 0.8539729126652087
Mean Absolute Error (MAE)= 0.37381532213368635
Mean Squared Error (MSE)= 0.19259123079935717
R-squared (R-squ)= 0.977795363978427
Root Mean Squared Error (RMSE)= 0.4388521741991911
B) Linear regression on salary dataset
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
data=pd.read_csv("Salary_Data.csv")
print(data)
data=data.dropna() #Remove NAN whole row
print(data)
len(data)
x=data[["YearsExperience"]]
y=data[["Salary"]]
plt.scatter(x,y) #plotting experience & salary data
from sklearn.model_selection import train_test_split
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2) #splitting training data
& testing data
print(len(y_train)) #training dataset (80%)
len(x_train)
print(len(x_test)) #testing dataset(20%)
len(x_test)
from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(x_train,y_train) #training experience & salary
predict=model.predict(x_test) #predicting salary by giving testset of experience
print(predict) #predicted value
y_test #original value
plt.scatter(x_test,y_test)
plt.plot(x_test,predict,'r')#plotting graph btw predicted and original value
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
mae=mean_absolute_error(y_test, predict)
mse=mean_squared_error(y_test, predict)
rmse=np.sqrt(mse)
r2=r2_score(y_test, predict)
print("MAE:",mae)
print("MSE:",mse)
print("RMSE:",rmse)
print("R2:",r2)
Result: Thus the linear regression using dataset sample evaluated successfully
Output:
MAE: 5950.500000000003
MSE: 47645779.63765114
RMSE: 6902.592240430485
R2: 0.9124538165906179
EX NO: 2 Implementation of Logistic Regression
DATE:
Aim: To perform Logistic Regression and predict digit from digits dataset
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
digits=load_digits()
dir(digits)
len(digits.data[1])
plt.gray()
plt.matshow(digits.images[3])
digits.target[3]
x_train,x_test,y_train,y_test=train_test_split(digits.data,digits.target,test_size=0.2)
LGR=LogisticRegression(max_iter=30)
LGR.fit(x_train,y_train)
from sklearn.metrics import confusion_matrix
prediction=LGR.predict(x_test)
cm=confusion_matrix(y_test,prediction)
import seaborn as sn
plt.figure(figsize=(5,5))
sn.heatmap(cm,annot=True)
plt.xlabel(‘prediction’)
plt.ylabel(‘Actual’)
import numpy as np
correct_pred=np.trace(cm)
total_pred=np.sum(cm)
accuracy=correct_pred/total_pred
print(accuracy)
Result: Thus the Logistic Regression and predict digit from digits dataset
implemented successfully
Output:
accuracy=0.9611111111111111
EX NO: 3 Implementation of K-FOLD
DATE:
Aim: To perform K-Fold on Sample Dataset
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
A) K-Fold sample program
from sklearn.model_selection import KFold
import numpy as np
data=np.arange(1,21)
data
k=5
kf=KFold(n_splits=5,shuffle=True,random_state=42)
for folds,(train_index,test_index) in enumerate(kf.split(data),1):
train_index,test_index=data[train_index],data[test_index]
print(f"fold:{fold}")
print(f"Train index:{train_index}")
print(f"Test index:{test_index}")
Output:
Fold:1
Train index: [ 3 4 5 6 7 8 9 10 11 12 13 14 15 17 19 20]
Test index: [ 1 2 16 18]
Fold:2
Train index: [ 1 2 3 5 7 8 10 11 13 14 15 16 17 18 19 20]
Test index: [ 4 6 9 12]
Fold:3
Train index: [ 1 2 4 5 6 7 8 9 10 11 12 13 15 16 18 20]
Test index: [ 3 14 17 19]
Fold:4
Train index: [ 1 2 3 4 6 7 8 9 11 12 14 15 16 17 18 19]
Test index: [ 5 10 13 20]
Fold:5
Train index: [ 1 2 3 4 5 6 9 10 12 13 14 16 17 18 19 20]
Test index: [ 7 8 11 15]
B) K-Fold on Linear Regression Using Random Dataset
from sklearn.model_selection import KFold
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import numpy as np
np.random.seed(42)
x=2*np.random.randn(100,1)
y=4+3*x+np.random.randn(100,1)
model=LinearRegression()
kf=KFold(n_splits=5,shuffle=True,random_state=42)
mse_scores=[]
fold_index=1
for train_index,test_index in kf.split(x):
print(f"fold:{fold_index}")
print(f"Train index:{train_index}")
print(f"Test index:{test_index}")
X_train,X_test=x[train_index],x[test_index]
Y_train,Y_test=y[train_index],y[test_index]
model.fit(X_train,Y_train)
y_pred=model.predict(X_test)
mse=mean_squared_error(Y_test,y_pred)
mse_scores.append(mse)
fold_index +=1
mean_mse=np.mean(mse_scores)
std_mse=np.std(mse_scores)
print(f"MSE SCORE:{mse_scores}")
print(f"MEAN MASE:{mean_mse}")
print(f"Standard deviation:{std_mse}")
Output:
MSE SCORE:[]
MEAN MASE:0.7479020958894542
Standard Deviation:0.0
C) K-Fold on Logistic Regression Using Digits Dataset
from sklearn.model_selection import KFold, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
from sklearn.metrics import accuracy_score
import numpy as np
digits = load_digits()
X = digits.data
Y = digits.target
model = LogisticRegression(max_iter=10000)
kf = KFold(n_splits=5, shuffle=True, random_state=42)
accuracy_scores = []
for train_index, test_index in kf.split(X):
print(f"Train Index: {train_index}")
print(f"Test Index: {test_index}")
X_train, X_test = X[train_index], X[test_index]
Y_train, Y_test = Y[train_index], Y[test_index]
model.fit(X_train,Y_train)
Y_pred=model.predict(X_test)
# Calculate accuracy
accuracy = accuracy_score(Y_test, Y_pred)
accuracy_scores.append(accuracy)
mean_accuracy=np.mean(accuracy_scores)
std_accuracy=np.std(accuracy_scores)
print(f"Accuracy Scores for each fold: {accuracy_scores}")
print(f"Mean Accuracy: {mean_accuracy}")
print(f"Standard Deviation of Accuracy: {std_accuracy}")
Result: Thus the K-Fold on linear and logistic regression has been evaluated
successfully
Output:
Accuracy Scores for each fold: [0.9526462395543176]
Mean Accuracy: 0.9526462395543176
Standard Deviation of Accuracy: 0.0
EX NO: 4 Implementation of Support Vector Machine(SVM)
DATE:
Aim: To perform SVM on Digits Dataset
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
digits=load_digits()
dir(digits)
len(digits.data[1])
plt.gray()
plt.matshow(digits.images[3])
digits.target[3]
x_train,x_test,y_train,y_test=train_test_split(digits.data,digits.target,test_size=0.2)
svm=SVC()
svm.fit(x_train,y_train)
from sklearn.metrics import confusion_matrix
prediction=svm.predict(x_test)
cm=confusion_matrix(y_test,prediction)
import seaborn as sn
plt.figure(figsize=(5,5))
sn.heatmap(cm,annot=True)
plt.xlabel('prediction')
plt.ylabel('Actual')
import numpy as np
correct_pred=np.trace(cm)
total_pred=np.sum(cm)
accuracy=correct_pred/total_pred
print(accuracy)
Result:
Thus the SVM on Digit Dataset has been implemented successfully
Output:
Accuracy=0.9805555555555555
EX NO: 5 Implementation of K-Nearest Neighbor (KNN) on
DATE: Random Dataset
Aim: To perform KNN on random dataset
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
ship = sns.load_dataset('titanic')
ship.shape
ship = ship[['survived','pclass','sex','age']]
ship.dropna(axis=0,inplace=True)
ship['sex'].replace(['male','female'],[0,1],inplace=True)
ship.head()
knn = KNeighborsClassifier()
y = ship['survived']
X = ship.drop('survived',axis=1)
knn.fit(X,y)
knn.score(X,y)
def survivedPerson(knn,pclass=3,sex=1,age=30):
x = np.array([pclass,sex,age]).reshape(1,3)
print(knn.predict(x))
survivedPerson(knn)
Result: Thus the KNN on a Random Dataset has been implemented
Output:
Accuracy = 0.8305322128851541
SurvivedPerson = [0]
EX NO: 6 Implementation of KMeans on Make Blobs Dataset
DATE:
Aim: To perform KMeans on blobs dataset
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
# 1. Generate synthetic data (or use your own dataset)
X, y = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)
# 2. Apply KMeans Clustering
kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
# 3. Get the cluster labels and centroids
labels = kmeans.labels_
centroids = kmeans.cluster_centers_
# 4. Plot the clusters
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', s=50)
plt.scatter(centroids[:, 0], centroids[:, 1], c='red', s=200, marker='X')
plt.title('K-Means Clustering (K=4)')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()
Result: KMeans on Make Blobs Dataset has been implemented successfully
Output:
EX NO: 7 Implementation of Hierarchical Clustering
DATE:
Aim: To perform Hierarchical Clustering on blobs dataset
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
import numpy as np
import pandas as pd
from sklearn.datasets import make_blobs
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt
X, y = make_blobs(n_samples=200, centers=4, cluster_std=0.60, random_state=0)
model = AgglomerativeClustering(n_clusters=4,linkage='ward')
labels = model.fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='rainbow')
plt.title('Hierarchical Clustering')
plt.show()
Z = linkage(X, method='ward')
plt.figure(figsize=(10, 7))
plt.title("Dendrogram for Hierarchical Clustering")
dendrogram(Z)
plt.show()
Result: Hierarchical Clustering on Blobs Dataset has been implemented
successfully
Output:
EX NO: 8 Implementation of Principal Component Analysis
(PCA)
DATE:
Aim: To perform Principal Component Analysis on Wholesale Customer dataset.
Software Required: Google Colab, Python IDE, Jupyter Notebook
Program:
import pandas as pd
fromsklearn.preprocessingimportStandardScale
from sklearn.decomposition import PCA
file_path = '/content/Wholesale customers data.csv'
data = pd.read_csv(file_path)
data features = data.drop(columns=['Channel', 'Region'])
scaler = StandardScaler()
scaled_features = scaler.fit_transform(features)
pca = PCA(n_components=2)
pca_transformed = pca.fit_transform(scaled_features)
explained_variance = pca.explained_variance_ratio_
df = pd.DataFrame(pca_transformed, columns=['PC1', 'PC2']) pca_df['Channel'] =
data['Channel'] print("PCA Results:")
print(pca_df.head())
print(f"PC1: {explained_variance[0]:.2f}, PC2: {explained_variance[1]:.2f}")
Import matplotlib.pyplot as plt
plt.figure(figsize=(8, 6)) colors = {1: 'red', 2: 'blue'}
plt.scatter(pca_df['PC1'], pca_df['PC2'], c=pca_df['Channel'].map(colors), alpha=0.5)
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.title('PCA of Wholesale Customers Data')
plt.show()
Result: Principal Component Analysis on Customer dataset been implemented
Output:
PCA Results:
PC1 PC2 Channel
0 0.193291 -0.305100 2
1 0.434420 -0.328413 2
2 0.811143 0.815096 2
3 -0.778648 0.652754 1
4 0.166287 1.271434 2
Explained Variance:
PC1: 0.44, PC2: 0.28
