HINDUSTHAN
COLLEGE OF ENGINEERING
AND TECHNOLOGY
(AUTONOMOUS INSTITUTION)
Coimbatore - 641032
22CS5252/MACHINE LEARNING LABORATORY
REG.NO :
NAME :
COURSE :
YEAR/SEM:
HINDUSTHAN
COLLEGE OF ENGINEERING AND TECHNOLOGY
(AUTONOMOUS INSTITUTION)
Coimbatore-641032.
DEPARTMENT OF COMPUTER
DEPARTMENT SCIENCE
OF COMPUTER SCIENCE AND ENGINEERING
AND ENGINEERING
Certified that this is the bonafide record of work done by
In the 22CS5252 / MACHINE LEARNING LABORATORY of this autonomous
institution, for the FIFTH Semester during the Academic year 2024 –2025.
Place : Coimbatore
Date:
Staff In-charge Head of the Department
Register Number:
Submitted for the 22CS5252 / MACHINE LEARNING LABORATORY practical examination
conducted on .
INTERNALEXAMINER EXTERNALEXAMINER
CONTENTS
PAGE
S.NO DATE EXPERIMENT MARKS SIGN
NO
Implementation of Basic Python Libraries
1 a)
(Math, Numpy, Scipy)
Implementation of Python Libraries for
1 b)
Machine Learning Applications (Pandas,
Matplotlib)
1 c) Creation and Loading of Datasets
2 Find-S Algorithm for Hypothesis Selection
Support Vector Machine (SVM) Decision
3
Boundary
4 Decision Tree Classification using ID3
Algorithm
5 Clustering Using EM (GMM) and k-Means
Algorithms
k-Nearest Neighbor Classification
6
STAFFINCHARGE
Ex.No: 01 a)
Implementation of Basic Python Libraries (Math, Numpy, Scipy)
Date:
Aim:
Algorithm:
Program:
# Importing libraries
import math
import numpy as np
from scipy import integrate
from scipy import linalg
# 1. Using the Math library
print("Math Library Operations:")
print("Square root of 16:", math.sqrt(16))
print("Factorial of 5:", math.factorial(5))
print("Sin(45 degrees):", math.sin(math.radians(45)))
# 2. Using the Numpy library
Print ("\nNumpy Library Operations:")
# Creating a numpy array
array = np.array([1, 2, 3, 4, 5])
print("Original array:", array)
# Array operations
print("Array after adding 10:", array + 10)
print("Mean of array:", np.mean(array))
print("Standard deviation of array:", np.std(array))
print("Dot product of array with itself:", np.dot(array, array))
# Matrix creation and operations
matrix = np.array([[1, 2], [3, 4]])
print("\nOriginal matrix:\n", matrix)
print("Matrix transpose:\n", np.transpose(matrix))
print("Matrix determinant:", np.linalg.det(matrix))
# 3. Using the Scipy library
print("\nScipy Library Operations:")
# Integration using Scipy
result, error = integrate.quad(lambda x: x**2, 0, 1)
print("Integration of x^2 from 0 to 1:", result)
# Solving a linear system Ax = b
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = linalg.solve(A, b)
print("Solution of linear system Ax = b:", x)
Result:
Ex.No: 01 b) Implementation of Python Libraries for Machine Learning
A Applications (Pandas, Matplotlib)
Date:
Aim:
Algorithm:
Program:
# Importing libraries
import pandas as pd
import matplotlib.pyplot as plt
# 1. Using the Pandas Library
print("Pandas Library Operations:")
# Loading a dataset (using a simple dictionary for illustration)
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eva'],
'Age': [24, 27, 22, 32, 29],
'Salary': [50000, 54000, 45000, 62000, 58000]
}
# Creating a DataFrame
df = pd.DataFrame(data)
print("Dataframe:\n", df)
# Data inspection
print("\nBasic Data Information:")
print("Data types:\n", df.dtypes)
print("Summary statistics:\n", df.describe())
# Filtering data
filtered_df = df[df['Age'] > 25]
print("\nFiltered data (Age > 25):\n", filtered_df)
# 2. Using the Matplotlib Library
print("\nMatplotlib Library Operations:")
# Plotting a bar chart for Age vs. Salary
plt.figure(figsize=(8, 5))
plt.bar(df['Name'], df['Salary'], color='skyblue')
plt.xlabel('Name')
plt.ylabel('Salary')
plt.title('Salary by Person')
plt.show()
# Plotting Age vs Salary as a scatter plot
plt.figure(figsize=(8, 5))
plt.scatter(df['Age'], df['Salary'], color='green')
plt.xlabel('Age')
plt.ylabel('Salary')
plt.title('Salary vs Age')
plt.show()
Result:
Ex.No:01 c)
Creation and Loading of Datasets
Date:
Aim:
Algorithm:
Program:
# Importing libraries
import numpy as np
import pandas as pd
from sklearn.datasets import make_classification, load_iris
import seaborn as sns
# 1. Creating a Synthetic Dataset Using Numpy
print("Synthetic Dataset with Numpy:")
# Generating random data with Numpy
np.random.seed(0) # For reproducibility
synthetic_data = np.random.rand(10, 3) # 10 rows, 3 columns
print(synthetic_data)
# 2. Creating a Synthetic Classification Dataset Using Scikit-Learn
print("\nSynthetic Classification Dataset with Scikit-Learn:")
# Generating a classification dataset with Scikit-Learn
X, y = make_classification(n_samples=100, n_features=4, n_classes=2, random_state=0)
print("Features:\n", X[:5])
print("Labels:\n", y[:5])
# 3. Loading a Dataset from a CSV File Using Pandas
print("\nLoading Dataset from CSV:")
# Sample data in dictionary form for example purposes
sample_data = {
'A': np.random.rand(5),
'B': np.random.rand(5),
'C': np.random.rand(5)
}
# Creating a DataFrame and saving it to a CSV
df = pd.DataFrame(sample_data)
df.to_csv('sample_data.csv', index=False)
# Reading the CSV back into a DataFrame
df_loaded = pd.read_csv('sample_data.csv')
print(df_loaded)
# 4. Loading a Built-in Dataset Using Scikit-Learn
print("\nLoading Built-in Dataset with Scikit-Learn:")
# Load the Iris dataset
iris = load_iris()
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)
print(iris_df.head())
# 5. Loading a Built-in Dataset Using Seaborn
print("\nLoading Built-in Dataset with Seaborn:")
# Load the 'tips' dataset from Seaborn
tips = sns.load_dataset('tips')
print(tips.head())
Result:
Ex.No:02
Find-S Algorithm for Hypothesis Selection
Date:
Aim:
Algorithm:
Program:
Let's start by creating a sample CSV file with training data. The CSV file should contain rows with attribute
values and the class label (e.g., "Yes" or "No").
Sample CSV File (training_data.csv)
Outlook Temperature Humidity Wind Water Forcast Play
Sunny Warm Normal Strong Warm Same Yes
Sunny Warm High Strong Warm Same Yes
Rainy Cold High Strong Warm Change No
Sunny Warm High Strong Cool Change Yes
Save this data as training_data.csv.
import csv
# Step 1: Read the CSV file and extract the relevant columns
def read_csv(file_path):
data = []
with open(file_path, mode='r') as file:
reader = csv.reader(file)
for row in reader:
data.append(row)
return data
# Step 2: Find-S Algorithm Implementation
def find_s_algorithm(data):
# Step 2.1: Initialize the hypothesis
# Assuming the first positive instance is the most specific hypothesis
hypothesis = data[0][:-1] # All attributes except the last (target class)
# Step 2.2: Iterate through the training data
for row in data:
if row[-1] == 'Yes': # Only consider positive instances (class 'Yes')
for i in range(len(hypothesis)):
# Generalize the hypothesis if needed
if hypothesis[i] != row[i]:
hypothesis[i] = '?' # Use '?' to denote any value (generalized)
return hypothesis
# Step 3: Main function to run the process
def main():
file_path = r'C:\Users\Hicet\Documents\training_dataa.csv' # Path to your CSV file
data = read_csv(file_path)
# Step 3.1: Apply Find-S algorithm
hypothesis = find_s_algorithm(data)
# Step 3.2: Print the most specific hypothesis
print("Most Specific Hypothesis:", hypothesis)
if __name__ == "__main__":
main()
Output:
Result:
Ex.No:3
Support Vector Machine (SVM) Decision Boundary
Date:
Aim:
Algorithm:
Program:
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# Step 1: Load the Iris dataset
iris = datasets.load_iris()
X = iris.data[:, :2] # Use only the first two features for 2D visualization (sepal length and sepal width)
y = iris.target
# Step 2: Split the dataset into training and testing sets (80% train, 20% test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Step 3: Standardize the data (important for SVM to perform well)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Step 4: Train the SVM classifier (use a linear kernel for simplicity)
svm = SVC(kernel='linear', random_state=42)
svm.fit(X_train, y_train)
# Step 5: Plot the decision boundary
# Create a mesh grid over the feature space
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 500), np.linspace(y_min, y_max, 500))
# Predict the class labels for each point in the grid
Z = svm.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the decision boundary
plt.contourf(xx, yy, Z, alpha=0.75, cmap=plt.cm.coolwarm)
# Step 6: Plot the training points
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k', marker='o', s=100, cmap=plt.cm.coolwarm)
# Plot support vectors
plt.scatter(svm.support_vectors_[:, 0], svm.support_vectors_[:, 1], s=200, facecolors='none', edgecolors='k',
linewidth=2, label='Support Vectors')
# Step 7: Set labels and title
plt.title("SVM Decision Boundary and Support Vectors (Linear Kernel)")
plt.xlabel('Sepal Length')
plt.ylabel('Sepal Width')
plt.legend()
plt.show()
Result:
Ex.No:4
Decision Tree Classification using ID3 Algorithm
Date:
Aim:
Algorithm:
Program:
# Importing necessary libraries
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import pandas as pd
# Define the dataset
data = {
'Weather': ['Sunny', 'Sunny', 'Overcast', 'Rainy', 'Rainy', 'Sunny', 'Overcast', 'Rainy', 'Sunny'],
'Temperature': ['Hot', 'Mild', 'Mild', 'Cool', 'Mild', 'Cool', 'Hot', 'Mild', 'Mild'],
'PlayTennis': ['No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes']
}
# Convert to DataFrame
df = pd.DataFrame(data)
# Encode the categorical variables (Weather, Temperature, PlayTennis)
df_encoded = pd.get_dummies(df)
# Define features and target
X = df_encoded[['Weather_Sunny', 'Weather_Overcast', 'Weather_Rainy', 'Temperature_Hot',
'Temperature_Mild', 'Temperature_Cool']]
y = df_encoded['PlayTennis_Yes']
# Initialize and train the decision tree classifier (ID3)
clf = DecisionTreeClassifier(criterion='entropy')
clf.fit(X, y)
# Visualize the tree (fix the issue with feature_names)
tree.plot_tree(clf, filled=True, feature_names=X.columns.tolist(), class_names=['No', 'Yes'], rounded=True)
# Classify a new sample
new_sample = pd.DataFrame({
'Weather_Sunny': [1], 'Weather_Overcast': [0], 'Weather_Rainy': [0],
'Temperature_Hot': [0], 'Temperature_Mild': [1], 'Temperature_Cool': [0]
})
prediction = clf.predict(new_sample)
print("Predicted class for the new sample:" ,{prediction[0]})
Result:
Ex.No:05
Clustering Using EM (GMM) and k-Means Algorithms
Date:
Aim:
Algorithm:
Program:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
# Generate synthetic data with 2D features
np.random.seed(42)
# Create 3 clusters of data points with different means and covariances
data1 = np.random.randn(300, 2) + [5, 5]
data2 = np.random.randn(300, 2) + [-5, -5]
data3 = np.random.randn(300, 2) + [5, -5]
# Combine the data into a single dataset
X = np.vstack([data1, data2, data3])
# Create K-Means model with 3 clusters
kmeans = KMeans(n_clusters=3, random_state=0)
kmeans_labels = kmeans.fit_predict(X)
# Create Gaussian Mixture Model (GMM) with 3 components
gmm = GaussianMixture(n_components=3, random_state=0)
gmm_labels = gmm.fit_predict(X)
# Plotting the results
fig, axs = plt.subplots(1, 2, figsize=(12, 6))
# Plot K-Means clustering
axs[0].scatter(X[:, 0], X[:, 1], c=kmeans_labels, cmap='viridis', marker='.')
axs[0].scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=200, c='red', marker='X')
axs[0].set_title("K-Means Clustering")
# Plot GMM clustering
axs[1].scatter(X[:, 0], X[:, 1], c=gmm_labels, cmap='viridis', marker='.')
axs[1].set_title("GMM Clustering (EM)")
# Show the plots
plt.tight_layout()
plt.show()
# Optional: print cluster centers for K-Means and GMM component means
print("K-Means Cluster Centers:")
print(kmeans.cluster_centers_)
print("\nGMM Component Means:")
print(gmm.means_)
Result:
Ex.No:06
k-Nearest Neighbor Classification
Date:
Aim:
Algorithm:
Program:
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
# Step 1: Load the Iris dataset
iris = load_iris()
X = iris.data # Features (sepal length, sepal width, petal length, petal width)
y = iris.target # Labels (species of iris)
# Step 2: Split the dataset into training and testing sets (80% train, 20% test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Step 3: Initialize and train the k-NN classifier (k=3 in this case)
k=3
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train, y_train)
# Step 4: Make predictions on the test set
y_pred = knn.predict(X_test)
# Step 5: Compare predictions with actual labels and print results
correct_predictions = []
incorrect_predictions = []
for i in range(len(y_test)):
if y_pred[i] == y_test[i]:
correct_predictions.append((X_test[i], y_test[i], y_pred[i]))
else:
incorrect_predictions.append((X_test[i], y_test[i], y_pred[i]))
# Step 6: Print correct predictions
print("Correct Predictions:")
for x, actual, predicted in correct_predictions:
print(f"Features: {x}, Actual: {iris.target_names[actual]}, Predicted: {iris.target_names[predicted]}")
# Step 7: Print incorrect predictions
print("\nIncorrect Predictions:")
for x, actual, predicted in incorrect_predictions:
print(f"Features: {x}, Actual: {iris.target_names[actual]}, Predicted: {iris.target_names[predicted]}")
# Step 8: Calculate and print the accuracy of the model
accuracy = accuracy_score(y_test, y_pred)
print(f"\nAccuracy: {accuracy * 100:.2f}%")
Result:
