Problem 1: Extract the data from the database using Python.

1. Objective
Retrieve data from a database using Python.

2. Data Overview
The dataset utilized for this task will be analyzed, with key statistical summaries and descriptive
metrics presented to provide insights into the data structure and content.
3. Techniques used (Algorithm)
● Python Database Connectivity: Using Python libraries like sqlite3 or MySQL connector to
establish a connection to a database and extract data.

Input

● Database connection details (e.g., database file for SQLite, or host, user, password for
other databases).
● SQL query : A query string to select and retrieve the necessary data.
● Optional : Any query parameters to customize the SQL command safely.

Output

A Pandas DataFrame containing the queried data, ready for analysis.

Steps

1. Import Required Libraries:

○ Import sqlite3 for SQLite or the other corresponding libraries for other databases
(e.g., mysql.connector, psycopg2).
○ Import pandas for handling the data.
2. Establish Database Connection:
○ Create a connection object using the appropriate connector and credentials
depending on the database type.
3. Create a Cursor Object:
 Use the connection object to initialize a cursor.
 The cursor is responsible for executing SQL commands.
 4. Execute SQL Query:
○ Write the SQL query to extract the desired data.
○ If there are parameters, use parameterized queries to prevent SQL
injection.
2. Fetch Data:
○ Use the cursor to fetch the data from the executed query.
○ Convert the fetched data into a Pandas DataFrame for easier
manipulation and analysis.
3. Close the Connection:
○ Close the cursor and the database connection to free up resources.
4. Return the DataFrame:
○ Return the DataFrame containing the extracted data.

4. Results
Data extraction successful. The data has been loaded into a pandas DataFrame.
Problem 2: Write a program to implement Linear and Logistic
Regression
1. Objective
This program performs both Linear and Logistic Regression on a given dataset, splitting it into
training and testing sets for evaluation.

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used for this problem.
3. Techniques used (Algorithm)
● Linear Regression: Linear regression is used to predict a continuous
variable based on one or more independent variables.
● Logistic Regression: Logistic regression is used for classification
problems where the dependent variable is categorical.

Algorithm for Linear Regression:

Input:
● A dataset containing features (independent variables) and a target
variable (dependent variable). For example, a dataset of house prices
where features include square footage, bedrooms, and bathrooms, and
the target is price.

Output:
● Predicted values for the target variable on the test set.
● Evaluation metrics such as Mean Squared Error (MSE) and R-
squared (R²) score.
● (Optional) A scatter plot showing the actual vs predicted values.
Steps:

1. Load the Dataset:

○ Input: Dataset containing both features and the target.
○ Action: Import the dataset using pandas.
2. Preprocess the Data:
○ Input: Raw data with missing values.
○ Action: Fill missing values with appropriate replacements
(mean/median for numerical data).
○ Output: Cleaned dataset.
3. Define Features (X) and Target (y):
○ Input: Cleaned dataset.
○ Action: Separate the features (independent variables) and the
target (dependent variable).
○ Output: X (features), y (target).
4. Split the Data into Training and Test Sets:
○ Input: X (features) and y (target).
○ Action: Use train_test_split to divide the dataset into training
and testing sets (e.g., 70% training, 30% testing).
○ Output: X_train, X_test, y_train, y_test.
5. Initialize the Linear Regression Model:
○ Action: Create an instance of the LinearRegression model from
the sklearn library.
6. Train the Linear Regression Model:
○ Input: X_train, y_train.
○ Action: Fit the model to the training data using the .fit()
method.
○ Output: Trained linear regression model.
7. Make Predictions:
○ Input: Trained model and X_test (features of the test set).
○ Action: Use the .predict() method to make predictions on the
test set.
○ Output: Predicted values (y_pred).
8. Evaluate the Model:
 ○ Input: Actual target values (y_test) and predicted values
(y_pred).
○ Action: Calculate evaluation metrics such as Mean Squared
Error (MSE) and R-squared using mean_squared_error and
r2_score.
○ Output: Evaluation metrics.
9. Visualize the Results :
○ Action: Plot the predicted vs actual values using matplotlib for
visualization.
○ Output: Scatter plot of actual vs predicted values.

Algorithm for Logistic Regression:

Input:
● A dataset containing features (independent variables) and a binary
target variable (0 or 1). For example, a dataset where features include
age, gender, fare, etc., and the target is whether the person survived
(1) or not (0) on the Titanic.

Output:
● Predicted binary class labels on the test set (e.g., survived or not
survived).
● Evaluation metrics such as Accuracy, Precision, Recall, F1-score,
and a Confusion Matrix.
● (Optional) Visualization of the confusion matrix.

Steps:

1. Load the Dataset:

○ Input: Dataset containing both features and the binary target
variable.
○ Action: Import the dataset using pandas.
2. Preprocess the Data (Data Cleaning):
 ○ Input: Raw data with missing values.
○ Action: Fill missing values and encode categorical variables if
necessary.
○ Output: Cleaned dataset.
3. Define Features (X) and Target (y):
○ Input: Cleaned dataset.
○ Action: Separate the features (independent variables) and the
target (dependent variable).
○ Output: X (features), y (target).
4. Split the Data into Training and Test Sets:
○ Input: X (features) and y (target).
○ Action: Use train_test_split to divide the dataset into training
and testing sets (e.g., 70% training, 30% testing).
○ Output: X_train, X_test, y_train, y_test.
5. Initialize the Logistic Regression Model:
○ Action: Create an instance of the LogisticRegression model
from the sklearn library.
6. Train the Logistic Regression Model:
○ Input: X_train, y_train.
○ Action: Fit the model to the training data using the .fit()
method.
○ Output: Trained logistic regression model.
7. Make Predictions:
○ Input: Trained model and X_test (features of the test set).
○ Action: Use the .predict() method to make predictions on the
test set.
○ Output: Predicted values (y_pred).
8. Evaluate the Model:
○ Input: Actual target values (y_test) and predicted values
(y_pred).
○ Action: Calculate evaluation metrics such as Accuracy,
Precision, Recall, F1-score, and Confusion Matrix.
○ Output: Evaluation metrics.
9. Visualize the Confusion Matrix :
 ○ Action: Use seaborn to plot a heatmap of the confusion matrix.
○ Output: Heatmap of the confusion matrix.

4. Results
The Linear Regression and Logistic Regression models have been trained.
Confusion matrix and evaluation metrics are provided for Logistic
Regression.

Output screenshots (such as confusion matrix or visual output) will be

provided along with results.
Problem 3: Implement the Naive Bayesian classifier for a
sample training dataset stored as a CSV file.
1. Problem Statement
Implement the Naive Bayesian classifier for a sample training dataset stored
as a CSV file.

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques used (Algorithm)
● Naive Bayes Classifier: Naive Bayes is a simple probabilistic classifier
based on applying Bayes' theorem with strong independence
assumptions.
Input:
● A dataset stored in a CSV file containing features (independent
variables) and a target variable (dependent variable).

Output:
● Classification results (predicted class labels).
● Performance metrics such as accuracy, precision, recall, F1-score,
and Confusion Matrix.

Steps:

1. Load the Dataset:

○ Input: Load the dataset from the CSV file using pandas.
○ Action: Read the CSV file and create a DataFrame to hold the
data.
○ Output: A pandas DataFrame.
2. Preprocess the Data:
○ Input: Raw data containing categorical and/or numerical values.
○ Action: Handle missing values, encode categorical variables if
necessary (using LabelEncoder or OneHotEncoder).
○ Output: Cleaned dataset with no missing values and numeric
encoding for categorical variables.
3. Define Features (X) and Target (y):
○ Input: The cleaned dataset.
○ Action: Separate the dataset into features (X) and target (y).
○ Output: X (features) and y (target).
4. Split the Data into Training and Testing Sets:
○ Input: Features (X) and target (y).
○ Action: Use train_test_split to divide the data into training and
testing sets (typically, 70% training and 30% testing).
○ Output: X_train, X_test, y_train, y_test.
 5. Initialize the Naive Bayes Classifier:
○ Action: Choose the appropriate Naive Bayes classifier (e.g.,
GaussianNB, MultinomialNB, or BernoulliNB) depending on
the nature of the dataset (continuous or categorical data).
○ Output: Initialized Naive Bayes model.
6. Train the Model:
○ Input: Training data (X_train, y_train).
○ Action: Use the .fit() method to train the model on the training
data.
○ Output: Trained Naive Bayes classifier.
7. Make Predictions:
○ Input: Test features (X_test).
○ Action: Use the .predict() method to make predictions on the
test set.
○ Output: Predicted class labels (y_pred).
8. Evaluate the Model:
○ Input: Actual test labels (y_test) and predicted labels (y_pred).
○ Action: Calculate evaluation metrics such as accuracy,
precision, recall, F1-score, and Confusion Matrix using
sklearn.metrics.
○ Output: Evaluation metrics.
9. Visualize the Results (Optional):
○ Action: Use seaborn or matplotlib to plot the confusion matrix.
○ Output: A heatmap representing the confusion matrix.

4. Results
Naive Bayes classifier has been implemented. Accuracy metrics and
confusion matrix are provided.

Output screenshots (such as confusion matrix or visual output) will be

provided along with results.
Problem 4: Implement k-Nearest Neighbors (KNN) and
Support Vector Machine (SVM) Algorithm for classification
1. Problem Statement
Implement k-Nearest Neighbors (KNN) and Support Vector Machine
(SVM) Algorithm for classification

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques used (Algorithm)
● K-Nearest Neighbors (KNN): KNN is a simple, instance-based learning
algorithm where the class of a new sample is predicted based on the
majority vote of its k-nearest neighbors.
● Support Vector Machine (SVM): SVM is a supervised learning algorithm
that finds the optimal hyperplane which maximizes the margin between
different classes.

Input:
● A dataset containing features (independent variables) and a target
variable (dependent variable).

Output:
● Classification results (predicted class labels).
● Performance metrics such as accuracy, precision, recall, F1-score,
and Confusion Matrix for both KNN and SVM.

Algorithm for k-Nearest Neighbors (KNN)

1. Load the Dataset:

○ Input: Load the dataset from a CSV file using pandas.
○ Action: Read the CSV file and create a DataFrame to hold the
data.
○ Output: A pandas DataFrame.
2. Preprocess the Data:
○ Input: Raw data containing categorical and/or numerical
values.
○ Action: Handle missing values, encode categorical variables if
necessary (using LabelEncoder or OneHotEncoder), and
standardize/normalize the data (scaling).
 ○ Output: Cleaned dataset with no missing values and numeric
encoding for categorical variables.
3. Define Features (X) and Target (y):
○ Input: The cleaned dataset.
○ Action: Separate the dataset into features (X) and target (y).
○ Output: X (features) and y (target).

4. Split the Data into Training and Testing Sets:

○ Input: Features (X) and target (y).
○ Action: Use train_test_split to divide the data into training and
testing sets (typically 70% training, 30% testing).
○ Output: X_train, X_test, y_train, y_test.

5. Initialize the k-Nearest Neighbors Classifier:

○ Action: Create an instance of KNeighborsClassifier from
sklearn, and specify the number of neighbors (k). Typically,
start with k=5.

6. Train the KNN Model:

○ Input: Training data (X_train, y_train).
○ Action: Fit the KNN model using .fit() on the training data.

7. Make Predictions Using KNN:

○ Input: Test features (X_test).
○ Action: Predict the class labels for the test set using .predict().

8. Evaluate the KNN Model:

○ Input: Actual test labels (y_test) and predicted labels (y_pred
from KNN).
○ Action: Calculate evaluation metrics like accuracy, precision,
recall, F1-score, and Confusion Matrix using sklearn.metrics.
Algorithm for Support Vector Machine (SVM)

1. Load and Preprocess the Dataset:

○ Use the same dataset and preprocessing steps as in the KNN
algorithm.

2. Initialize the SVM Classifier:

○ Action: Create an instance of SVC from sklearn. Specify the
kernel (e.g., linear, rbf, poly). Typically, start with the default
rbf (Radial Basis Function) kernel.

3. Train the SVM Model:

○ Input: Training data (X_train, y_train).
○ Action: Fit the SVM model using .fit() on the training data.

4. Make Predictions Using SVM:

○ Input: Test features (X_test).
○ Action: Predict the class labels for the test set using .predict().

5. Evaluate the SVM Model:

○ Input: Actual test labels (y_test) and predicted labels (y_pred
from SVM).
○ Action: Calculate evaluation metrics like accuracy, precision,
recall, F1-score, and Confusion Matrix using sklearn.metrics.

4. Results
Both KNN and SVM models have been trained on the dataset. Confusion
matrix and classification report are provided for both.
Problem 5: Implement classification of a given dataset using
random forest
1. Problem Statement

Implement classification of a given dataset using random forest.

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques
used (Algorithm)
Random Forest is a popular and powerful ensemble learning method
used for classification and regression tasks. It builds multiple decision trees
during training and merges their outputs to improve the overall performance
and control overfitting.

Steps:
1. Load the Dataset:
● Input: Load the dataset from a CSV file using pandas.
● Output: DataFrame holding the dataset.
2. Preprocess the Data:
● Handle missing values, encode categorical variables using
LabelEncoder, and optionally scale the data.
3. Define Features (X) and Target (y):
● Separate the features (X) and the target variable (y).
4. Split the Data:
● Use train_test_split to divide the dataset into training and testing sets.
5. Initialize the Random Forest Classifier:
● Initialize RandomForestClassifier from sklearn and specify the
number of decision trees (n_estimators).
6. Train the Model:
● Fit the Random Forest model on the training data using .fit().
7. Make Predictions:
● Predict class labels for the test set using .predict().
 8. Evaluate the Model:
● Calculate accuracy, precision, recall, F1-score, and the confusion
matrix using sklearn.metrics. Visualize the confusion matrix using a
heatmap if needed.

4. Results
Problem 6: Build an Artificial Neural Network (ANN) by
implementing the Back propagation algorithm and test the
same using appropriate data sets.
1. Problem Statement
Build an Artificial Neural Network (ANN) by implementing the Back
propagation algorithm and test the same using appropriate data sets.

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques used (Algorithm)
Artificial Neural Network (ANN)

An Artificial Neural Network (ANN) is a computational model inspired by

the way biological neural networks in the human brain work. ANNs are a
key component of machine learning and deep learning, particularly for tasks
such as pattern recognition, classification, regression, and data processing.

Input:
● A dataset with features and target labels (for classification or
regression).
Output:
● Trained ANN model and performance metrics (like accuracy or mean
squared error).

Algorithm Steps:

1. Load the Dataset:

○ Input: Load the dataset using a library like pandas.
○ Output: A DataFrame containing the data.
2. Preprocess the Data:
○ Handle missing values, normalize or standardize numerical
features, and encode categorical variables if necessary.
○ Split the dataset into training and testing sets.
3. Initialize Parameters:
○ Define the architecture of the ANN (number of input neurons,
hidden neurons, output neurons).
○ Initialize weights and biases for each layer, typically using
small random values.
4. Define Activation Function:
○ Choose an activation function (e.g., Sigmoid, ReLU, or Tanh)
for the neurons in the hidden and output layers.
○ Define the derivative of the activation function for use in
backpropagation.
5. Forward Propagation:
○ For each training sample:
■ Calculate the input for the hidden layer and apply the
activation function to get hidden layer outputs.
■ Calculate the input for the output layer using hidden layer
outputs and apply the activation function to get the
predicted output.
6. Compute Loss:
○ Use an appropriate loss function (e.g., Mean Squared Error for
regression or Cross-Entropy for classification) to compute the
difference between the predicted output and the actual target
value.

7. Backpropagation:
○ Compute gradients of the loss with respect to the output layer's
weights and biases using the chain rule.
○ Propagate the gradients backward through the network:
■ Calculate gradients for the hidden layer weights and
biases.
○ Update the weights and biases using an optimization algorithm
(e.g., Gradient Descent).

8. Repeat Training:
○ Repeat steps 5 to 7 for a specified number of epochs or until
convergence (i.e., the loss is minimized).

9. Evaluate the Model:

○ Use the testing dataset to evaluate the trained model's
performance.
○ Calculate metrics such as accuracy, precision, recall, or mean
squared error.

10. Visualize Results:

○ Optionally, visualize the training loss and metrics over epochs
to analyze the model's performance.
4. Results
Problem 7: Apply K-Means algorithm K-Means algorithm to
cluster a set of data stored in a .CSV file. Use the same data set
for clustering using the K-Means algorithm. Compare the
results of these two algorithms and comment on the quality of
clustering. You can add Python ML library classes in the
program.

1. Problem Statement
Apply K-Means algorithm K-Means algorithm to cluster a set of data stored
in a .CSV file. Use the same set for clustering using the K-Means algorithm.
Compare the results of these two algorithms and comment on the quality of
clustering. You can add Python ML library classes in the program.

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques used (Algorithms)

Input

1. Dataset:
a. A CSV file (laptop.csv) containing structured data. The
dataset should ideally have a mix of numerical and
categorical features, such as:
i. Numerical Columns: E.g., Price, RAM, Storage, etc.
ii. Categorical Columns: E.g., Brand, Model, etc.
Output

Cluster Distribution:
○ Output of the distribution of clusters formed by both K-
Means and Hierarchical clustering.

Steps:

1. Load the Dataset:

● Input: Load the dataset from a specified CSV file path.
● Output: DataFrame containing the data.

2. Preprocess the Data:

● Handle missing values by filling them with a placeholder (e.g.,
'Unknown' for categorical variables).
● Encode categorical variables into numerical values using
LabelEncoder.
● Standardize numerical features using StandardScaler for better
performance in clustering algorithms.

3. Apply K-Means Clustering:

● Initialize the K-Means algorithm with a specified number of clusters
(e.g., 3).
● Fit the K-Means model on the standardized data and predict cluster
labels.

4. Apply Hierarchical Clustering:

● Initialize the Hierarchical Clustering algorithm with the same number
of clusters (e.g., 3).
● Fit the Hierarchical model on the standardized data and predict cluster
labels.
 5. Visualize Clustering Results:
● Create scatter plots to visualize the results of K-Means clustering and
Hierarchical clustering side by side.

6. Compare Clustering Results:

● Count the number of points in each cluster for both algorithms and
print the results.

7. Calculate Clustering Evaluation Metrics:

● Compute the Adjusted Rand Index (ARI) to compare the similarity
between the two clustering results.
● Compute the Adjusted Mutual Information (AMI) to measure the
agreement of the two clusterings.
● Calculate the Silhouette Score for both clustering algorithms to
evaluate the quality of the clustering.

8. Comment on the Quality of Clustering:

● Analyze the evaluation metrics and visualize the results to comment
on the effectiveness and quality of the clustering produced by each
algorithm.

4. Results
Problem 8: Write a program to implement Self - Organizing
Map (SOM).
1. Problem Statement
Write a program to implement Self - Organizing Map (SOM).

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques used (Algorithms)

Self-Organizing Map (SOM)

A Self-Organizing Map (SOM) is a type of artificial neural network that is
used for unsupervised learning. It transforms high-dimensional data into
lower-dimensional (typically two-dimensional) representations, allowing for
the visualization and clustering of complex datasets. SOMs are particularly
useful for exploratory data analysis, feature extraction, and data
compression.

Input

● Dataset: The input to the SOM implementation in this example is

the Iris dataset, which contains 150 samples of iris flowers with the
following features:
○ Sepal length
○ Sepal width
○ Petal length
○ Petal width
● Each sample is labeled as one of three classes (Setosa, Versicolor,
Virginica).
Output

1. Visualization of the SOM:

○ The first output is a scatter plot showing the self-organizing
map. Each point represents a sample from the Iris dataset, and
colors indicate the different classes. The location of each point
on the grid shows how the SOM has organized the data.

2. Neuron Weights Visualization:

○ The second output visualizes the weights of the neurons in the
SOM grid, illustrating the organization of the clusters in the
feature space.

1. Import Libraries:
● Import necessary libraries like NumPy, Matplotlib, and MiniSom for
creating and visualizing the SOM.

2. Load the Dataset:

● Load the dataset into a Pandas DataFrame (e.g., the Iris dataset for
simplicity).

3. Preprocess the Data:

● Normalize the data for better performance of the SOM.

4. Initialize the SOM:

● Create a SOM instance, specifying the size of the grid (number of
rows and columns).

5. Train the SOM:

● Iterate through the input data multiple times to adjust the weights of
the nodes based on the input data.
6. Visualize the Results:
● Create a visualization of the trained SOM, showing the distribution of
data points in the SOM grid.

7. Map Input Data to SOM:

● Optionally, assign each data point to the closest neuron (node) in the
SOM and visualize it.

3. Results
Problem 9: Write a Program for empirical comparison of
different supervised learning algorithms.
1. Problem Statement
Write a program for empirical comparison of different supervised learning
algorithms.

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques used (Algorithms)

Empirical Comparison
Empirical comparison refers to the process of systematically evaluating and
contrasting the performance of different algorithms, models, or methods
based on actual observed data rather than theoretical predictions. This
approach is widely used in fields like machine learning, statistics, and
experimental sciences to derive insights and conclusions based on real-world
performance.

Supervised Learning
Definition: Supervised learning is a type of machine learning in which a
model is trained on labeled data. In this context, labeled data consists of
input-output pairs, where each input (feature) is associated with a known
output (target or label). The objective is to learn a mapping from inputs to
outputs so that the model can make accurate predictions on unseen data.

Input
● Dataset: In this example, the program uses the Iris dataset, which
consists of:
○ Features: Sepal length, Sepal width, Petal length, Petal width.
 ○ Target: Iris species (Setosa, Versicolor, Virginica).

Output

1. Evaluation Results:
○ The program outputs a DataFrame containing evaluation
metrics for each model.

1. Import Libraries:
● Import necessary libraries (e.g., pandas, numpy, sklearn, matplotlib).

2. Load the Dataset:

● Load the dataset from a CSV file into a Pandas DataFrame.

3. Preprocess the Data:

● Handle missing values, if any.
● Encode categorical variables.
● Split the dataset into features (X) and the target variable (y).

4. Split the Data:

● Split the dataset into training and test sets (e.g., 70% training and 30%
testing).

5. Initialize Models:
● Create a list or dictionary of supervised learning models to compare
(e.g., Logistic Regression, Decision Tree, Random Forest, SVM, k-
NN).

6. Train and Evaluate Each Model:

● For each model:
○ Fit the model on the training data.
○ Predict the target variable on the test data.
○ Calculate evaluation metrics (e.g., accuracy, precision, recall,
F1-score).
 ○ Store the results for comparison.
7. Display Results:
● Create a DataFrame to display the accuracy and other metrics for each
model.
● Print the results.

8. Visualize Results:
● Create bar plots or other visualizations to compare the performance of
different models.

4. Results
Problem 10: Write a Program for empirical comparison of
different unsupervised learning algorithms.
1. Problem Statement
Write a program for empirical comparison of different unsupervised learning
algorithms.

2. Data Statistics
Data statistics and descriptions will be presented based on the dataset used
for this problem.
3. Techniques used (Algorithms)

Empirical Comparison
Empirical comparison refers to the process of systematically evaluating and
contrasting the performance of different algorithms, models, or methods
based on actual observed data rather than theoretical predictions. This
approach is widely used in fields like machine learning, statistics, and
experimental sciences to derive insights and conclusions based on real-world
performance.

Unsupervised Learning
Unsupervised learning is a type of machine learning where models are
trained on data without labeled outputs. In this context, the algorithm
attempts to identify patterns, groupings, or structures within the data without
any explicit guidance on what to look for. The primary objective is to
uncover hidden patterns or intrinsic structures in the input data.

Input
● A dataset in a CSV file containing features for clustering.
 ● The number of clusters (for algorithms that require this parameter,
such as K-Means).

Output
● Visual comparison of clustering results.
● Evaluation metrics (Silhouette Score, Davies-Bouldin Index) for each
algorithm.

Steps
1. Load the Dataset:
○ Import the necessary libraries (pandas, numpy, sklearn,
matplotlib, seaborn).
○ Load the dataset using pd.read_csv().

2. Preprocess the Data:

○ Handle missing values by filling them with appropriate values
(e.g., mean for numerical features).
○ Normalize or standardize the data if necessary.

3. Define Clustering Algorithms:

○ Specify the clustering algorithms to compare (e.g., K-Means,
Hierarchical).

4. Apply Clustering Algorithms:

○ For each algorithm:
■ Fit the model to the data.
■ Predict the clusters.

5. Evaluate Clustering Performance:

○ Calculate evaluation metrics (Silhouette Score, Davies-Bouldin
Index) for each clustering algorithm.

6. Visualize Clustering Results:

○ Create scatter plots of the clustered data for each algorithm.
 ○ Use a pair of subplots to visualize the clustering outcomes.

7. Display Results:
○ Print the evaluation metrics for each algorithm.

4. Results