Practical 1 - 1.

Singular Value Decomposition (SVD)

Concept:

SVD is a matrix factorization technique that decomposes a matrix into three matrices: .
It is widely used in dimensionality reduction, noise reduction, and image compression.

Mathematics:

Given a matrix of size m x n , it is decomposed into:

U : An m x m orthogonal matrix

∑: An m x n diagonal matrix with singular values

VT : Transpose of an n x n orthogonal matrix

A = U∑VT

Python Program:

import numpy as np

A = np.array([[3, 2, 2], [2, 3, -2]])

U, S, VT = np.linalg.svd(A)

print("Matrix A:\n", A)

print("U:\n", U)

print("Sigma:\n", S)

print("V^T:\n", VT)
 Practical 2 - Principal Component Analysis (PCA)

Concept:

PCA is used to reduce the dimensionality of datasets while preserving variance. It transforms
data into a new coordinate system such that the greatest variance lies on the first principal
component.

Steps:

1. Standardize the data

2. Calculate covariance matrix
3. Compute eigenvalues and eigenvectors
4. Choose k largest eigenvectors
5. Transform original data

Python Program:

from sklearn.decomposition import PCA

from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2], [3.1, 3.0]])
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
pca = PCA(n_components=1)
X_pca = pca.fit_transform(X_scaled)

print("Original Data:\n", X)
print("PCA Result:\n", X_pca)
 Practical 3 - K-Means Clustering

Concept:

K-Means is an unsupervised learning algorithm used to partition a dataset into a set of distinct,
non-overlapping subgroups (clusters). The algorithm works by minimizing the sum of squared
distances between each point and the centroid of its cluster. The number of clusters (k) is a
hyperparameter.

Working:

1. Choose the number of clusters (k).

2. Initialize k centroids randomly.
3. Assign each data point to the nearest centroid.
4. Compute new centroids by averaging all points in each cluster.
5. Repeat steps 3 and 4 until convergence (i.e., centroids do not change significantly).

Advantages:

 Simple to implement.
 Efficient for large datasets.

Limitations:

 Requires specifying the number of clusters.

 Sensitive to outliers and initial centroid placement.

Python Program

from sklearn.cluster import KMeans

import matplotlib.pyplot as plt

import numpy as np

X = np.array([[1,2],[1.5,1.8],[5,8],[8,8],[1,0.6],[9,11]])

kmeans = KMeans(n_clusters=2)

kmeans.fit(X)

y_kmeans = kmeans.predict(X)

plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=100, cmap='viridis')

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=200, c='red')

plt.title('K-Means Clustering')

plt.xlabel('X1')

plt.ylabel('X2')

plt.grid(True)

plt.show()
 Practical 4 - Branch and Bound

Concept:

Branch and Bound is an algorithmic paradigm used for solving combinatorial and optimization problems
such as the Traveling Salesman Problem (TSP) and 0/1 Knapsack Problem. It systematically explores
branches of a decision tree, which represent subsets of the solution space.

Working Steps for 0/1 Knapsack:

1. Sort items by decreasing value-to-weight ratio.

2. At each node in the decision tree, make a decision to either include or exclude an item.

3. Calculate an upper bound of the maximum profit possible from that node.

4. If the bound is less than the best solution found so far, prune the branch.

Use Case:

Useful in solving problems where brute-force is infeasible due to time complexity but optimal solution is
still desired.

Python Program:

class Item:

def __init__(self, value, weight):

self.value = value

self.weight = weight

def knapsack(items, W):

n = len(items)

items.sort(key=lambda x: x.value/x.weight, reverse=True)

def bound(i, weight, value):

if weight >= W:

return 0

profit_bound = value

total_weight = weight

while i < n and total_weight + items[i].weight <= W:

total_weight += items[i].weight

profit_bound += items[i].value

i += 1
 if i < n:

profit_bound += (W - total_weight) * (items[i].value / items[i].weight)

return profit_bound

maxProfit = 0

def dfs(i, weight, value):

nonlocal maxProfit

if i == n:

if value > maxProfit:

maxProfit = value

return

if weight + items[i].weight <= W:

dfs(i + 1, weight + items[i].weight, value + items[i].value)

if bound(i + 1, weight, value) > maxProfit:

dfs(i + 1, weight, value)

dfs(0, 0, 0)

return maxProfit

items = [Item(60, 10), Item(100, 20), Item(120, 30)]

capacity = 50

print("Maximum Profit: ", knapsack(items, capacity))

 Practical 5 - Data Visualization
Concept:

Data visualization involves representing data in a graphical or pictorial format to discover patterns, trends,
and insights. It makes complex data more accessible and understandable.

Common Types of Charts:

 Bar Plot

 Line Plot

 Histogram

 Heatmaps

Python Program:

import matplotlib.pyplot as plt

import seaborn as sns

import pandas as pd

# Sample data

data = pd.DataFrame({

'Subject': ['Math', 'Science', 'English', 'History'],

'Marks': [88, 92, 84, 76]

})

# Bar Plot

sns.barplot(x='Subject', y='Marks', data=data)

plt.title('Student Marks in Subjects')

plt.xlabel('Subject')

plt.ylabel('Marks')

plt.grid(True)

plt.show()
 Practical 6 - Feature Selection

Concept:

Feature selection is the process of selecting the most relevant features from the dataset to
improve the model's accuracy, reduce overfitting, and decrease computation time.
Types of Feature Selection Techniques:
1. Filter Methods: Use statistical measures like chi-square, correlation, and mutual
information.
2. Wrapper Methods: Use predictive models to evaluate feature subsets (e.g., Recursive
Feature Elimination).
3. Embedded Methods: Features are selected during model training (e.g., Lasso regression).

Python Program using Filter Method:

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
X_new = SelectKBest(chi2, k=2).fit_transform(X, y)
print("Original shape:", X.shape)
print("Reduced shape:", X_new.shape)
 Practical 7 - Image Classification

Concept:
Image classification refers to assigning a label to an image based on its visual content. It is
commonly performed using Convolutional Neural Networks (CNNs) or transfer learning from
pre-trained models.

Workflow:
1. Preprocess the image (resize, normalize)
2. Load a pre-trained model (e.g., MobileNetV2)
3. Pass the image to the model
4. Interpret the top predictions

Python Program using Pre-trained Model:

from tensorflow.keras.applications import MobileNetV2

from tensorflow.keras.preprocessing import image

from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions

import numpy as np

model = MobileNetV2(weights='imagenet')

img_path = 'elephant.jpg'

img = image.load_img(img_path, target_size=(224, 224))

x = image.img_to_array(img)

x = np.expand_dims(x, axis=0)

x = preprocess_input(x)

preds = model.predict(x)

print("Predicted:", decode_predictions(preds, top=3)[0])