Machine Learning Lab Programs

Program 1: Data Exploration

import pandas as pd
import seaborn as sns
import [Link] as plt
from [Link] import load_iris

# 1. Load the Iris dataset

iris = load_iris()
df_iris = [Link](data=[Link], columns=iris.feature_names)
df_iris['species'] = iris.target_names[[Link]]
print("Dataset loaded successfully.")

# 2. Perform basic data exploration

print("\n--- Basic Data Exploration ---")
print("\nMissing values:")
print(df_iris.isnull().sum())
print("\nData types:")
print(df_iris.dtypes)
print("\nSummary statistics:")
print(df_iris.describe())

# 3. Create visualizations
print("\n--- Visualizations ---")
# Histograms for numerical features
[Link](figsize=(12, 8))
for i, feature in enumerate(iris.feature_names):
[Link](2, 2, i + 1)
[Link](df_iris[feature], kde=True)
[Link](f'Histogram of {feature}')
plt.tight_layout()
[Link]()

# Scatter plot for relationships between features (e.g., sepal length vs. sepal
width)
[Link](figsize=(8, 6))
[Link](x='sepal length (cm)', y='sepal width (cm)', hue='species',
data=df_iris)
[Link]('Scatter Plot of Sepal Length vs. Sepal Width')
[Link]()
# Box plots to understand distribution across species
[Link](figsize=(12, 8))
for i, feature in enumerate(iris.feature_names):
[Link](2, 2, i + 1)
[Link](x='species', y=feature, data=df_iris)
[Link](f'Box Plot of {feature} by Species')
plt.tight_layout()
[Link]()
Program 2: Linear Regression
# ===========================================
# Simple Linear Regression on Boston Housing
# ===========================================

import pandas as pd
import numpy as np
import [Link] as plt
from sklearn.linear_model import LinearRegression
from [Link] import mean_squared_error, r2_score

# ----------------------------
#[1]Load the dataset
# ----------------------------
url = "[Link]
df = pd.read_csv(url)

print("\n--- First 5 rows ---")

print([Link]())
print("\n--- Data Info ---")
print([Link]())
print("\n--- Summary Statistics ---")
print([Link]())

# We will predict MEDV (Median value of owner-occupied homes)

# using RM (average number of rooms per dwelling)
X = df[['rm']] # Feature must be 2D
y = df['medv'] # Target

# ----------------------------
# [2]Train the Linear Regression model
# ----------------------------
model = LinearRegression()
[Link](X, y)
print("\nIntercept (b0):", model.intercept_)
print("Slope (b1):", model.coef_[0])
# Predictions
y_pred = [Link](X)
# Model performance
print("\nMean Squared Error:", mean_squared_error(y, y_pred))
print("R² Score:", r2_score(y, y_pred))

# ----------------------------
#[3]Visualization
# ----------------------------
# Regression Line Plot
[Link](figsize=(8,6))
[Link](X, y, color='blue', alpha=0.6, label='Actual')
[Link](X, y_pred, color='red', linewidth=2, label='Regression line')
[Link]("Average number of rooms per dwelling (RM)")
[Link]("Median home value (MEDV)")
[Link]("Simple Linear Regression: RM vs MEDV")
[Link]()
[Link]()

# Residuals Plot
residuals = y - y_pred
[Link](figsize=(8,6))
[Link](y_pred, residuals, color='purple', alpha=0.6)
[Link](y=0, color='black', linestyle='--')
[Link]("Predicted MEDV")
[Link]("Residuals (Actual - Predicted)")
[Link]("Residuals Plot")
[Link]()

Program 3: Logistic Regression

import numpy as np
import pandas as pd
import [Link] as plt
import seaborn as sns
from [Link] import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from [Link] import accuracy_score, precision_score, recall_score,
confusion_matrix, classification_report

# Load dataset
data = load_breast_cancer()
X = [Link]
y = [Link]

# Split dataset into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y)

# Create and train Logistic Regression model

model = LogisticRegression(max_iter=10000)
[Link](X_train, y_train)
# Make predictions
y_pred = [Link](X_test)

# Evaluate the model

accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)

# Print results
print("Logistic Regression Model Evaluation:")
print(f"Accuracy: {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print("\nConfusion Matrix (as text):")
print(conf_matrix)
print("\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=data.target_names))

# Plot Confusion Matrix

[Link](figsize=(6, 4))
[Link](conf_matrix, annot=True, fmt="d", cmap="Blues",
xticklabels=data.target_names, yticklabels=data.target_names)
[Link]("Predicted")
[Link]("Actual")
[Link]("Confusion Matrix - Logistic Regression")
[Link]()

Program 4: k-NN Classifier

import numpy as np
import [Link] as plt
from [Link] import ListedColormap
from sklearn import datasets
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
from [Link] import KNeighborsClassifier
from [Link] import accuracy_score

#[1] Load the Iris dataset

iris = datasets.load_iris()
X = [Link][:, :2] # Take only the first 2 features for 2D visualization
y = [Link]

#[2] Split into training and test sets

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42, stratify=y
)

#[3] Standardize the features for better k-NN performance

sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = [Link](X_test)

#[4] Function to plot decision boundaries for different k values

def plot_decision_boundaries(k_values):
h = 0.02 # step size in the mesh
cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])
cmap_bold = ['red', 'green', 'blue']

# Define mesh grid limits

 x_min, x_max = X_train[:, 0].min() - 1, X_train[:, 0].max() + 1
y_min, y_max = X_train[:, 1].min() - 1, X_train[:, 1].max() + 1
xx, yy = [Link](
[Link](x_min, x_max, h),
[Link](y_min, y_max, h)
)

# Create subplots for all k values

[Link](figsize=(15, 4))

for i, k in enumerate(k_values):
# Train classifier
clf = KNeighborsClassifier(n_neighbors=k)
[Link](X_train, y_train)

# Predict over mesh grid

Z = [Link](np.c_[[Link](), [Link]()])
Z = [Link]([Link])

# Plot decision boundary

[Link](1, len(k_values), i + 1)
[Link](xx, yy, Z, alpha=0.4, cmap=cmap_light)
[Link](
X_train[:, 0],
X_train[:, 1],
c=y_train,
edgecolor='k',
s=40,
cmap=ListedColormap(cmap_bold)
)
[Link](f"k = {k}")

[Link]("k-NN Decision Boundaries for Different k Values")

[Link]()

#[5] Experiment with different k values and visualize

k_values = [1, 5, 15]
plot_decision_boundaries(k_values)

#[6] Evaluate accuracy for different k values

print("Accuracy on Test Set:")
for k in k_values:
knn = KNeighborsClassifier(n_neighbors=k)
[Link](X_train, y_train)
y_pred = [Link](X_test)
acc = accuracy_score(y_test, y_pred)
print(f"k = {k}: {acc:.2f}")
Program 5: Decision Tree Classifier
# Decision Tree Classifier using Iris Dataset
# Step 1: Import required libraries
import pandas as pd
from [Link] import load_iris
from [Link] import DecisionTreeClassifier, plot_tree, export_text
from sklearn.model_selection import train_test_split
from [Link] import accuracy_score, classification_report
import [Link] as plt

# Step 2: Load the dataset

iris = load_iris()
X = [Link]([Link], columns=iris.feature_names)
y = [Link]([Link], name='target')

# Step 3: Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)

# Step 4: Initialize and train the Decision Tree model

model = DecisionTreeClassifier(criterion='entropy', max_depth=3, random_state=42)
[Link](X_train, y_train)

# Step 5: Make predictions

y_pred = [Link](X_test)

# Step 6: Evaluate model performance

print("Decision Tree Classifier Accuracy:", accuracy_score(y_test, y_pred))
print("\nClassification Report:\n", classification_report(y_test, y_pred,
target_names=iris.target_names))

# Step 7: Visualize the Decision Tree

[Link](figsize=(12, 8))
plot_tree(model,
feature_names=iris.feature_names,
class_names=iris.target_names,
filled=True,
rounded=True,
fontsize=10)
[Link]("Decision Tree Visualization - Iris Dataset")
[Link]()

# Step 8: Display Decision Rules (Text Format)

print("\nDecision Rules:\n")
rules = export_text(model, feature_names=iris.feature_names)
print(rules)
Program 6: k-Means Clustering
# K-Means Clustering on Iris Dataset (without labels)
# Step 1: Import required libraries
import pandas as pd
import numpy as np
from sklearn import datasets
from [Link] import KMeans
import [Link] as plt
from [Link] import StandardScaler

# Step 2: Load the Iris dataset (without labels)

iris = datasets.load_iris()
X = [Link] # Only features, no target labels

# Step 3: Standardize the features

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 4: Apply K-Means clustering

kmeans = KMeans(n_clusters=3, random_state=42)
[Link](X_scaled)

# Step 5: Get cluster labels and centroids

labels = kmeans.labels_
centroids = kmeans.cluster_centers_

# Step 6: Visualize the clusters

[Link](figsize=(8, 6))
[Link](X_scaled[:, 0], X_scaled[:, 1], c=labels, cmap='viridis', s=50)
[Link](centroids[:, 0], centroids[:, 1], c='red', s=200, marker='X',
label='Centroids')
[Link]("K-Means Clustering on Iris Dataset")
[Link]("Feature 1 (standardized)")
[Link]("Feature 2 (standardized)")
[Link]()
[Link]()

# Step 7: Print cluster centers

print("Cluster Centers (Standardized Feature Space):\n", centroids)

# Step 8: Compare predicted clusters with actual labels (optional, just to check
accuracy)
y_true = [Link]
print("\nActual Labels (0=setosa, 1=versicolor, 2=virginica):")
print(y_true[:10])
print("Predicted Cluster Labels:")
print(labels[:10])
Program 7: Support Vector Machine
# Support Vector Machine (SVM) for MNIST handwritten digit classification
from sklearn import datasets
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
from [Link] import SVC
from [Link] import accuracy_score, classification_report, confusion_matrix
import [Link] as plt

# Step 1: Load MNIST dataset

digits = datasets.load_digits()
# Display basic info
print("Image Data Shape:", [Link])
print("Label Data Shape:", [Link])

# Step 2: Visualize some samples

[Link](figsize=(8, 4))
for index, (image, label) in enumerate(zip([Link][0:8], [Link][0:8])):
[Link](2, 4, index + 1)
[Link]([Link](8, 8), cmap=[Link])
[Link](f'Target: {label}')
[Link]()

# Step 3: Split dataset into train and test sets

X_train, X_test, y_train, y_test = train_test_split(
[Link], [Link], test_size=0.3, random_state=42
)

# Step 4: Feature scaling

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = [Link](X_test)

# Step 5: Train SVM classifier

svm_clf = SVC(kernel='rbf', gamma=0.05, C=10)
svm_clf.fit(X_train, y_train)

# Step 6: Predict test data

y_pred = svm_clf.predict(X_test)

# Step 7: Evaluate performance

print("\nConfusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("\nClassification Report:\n", classification_report(y_test, y_pred))
print("Accuracy:", accuracy_score(y_test, y_pred))

# Step 8: Visualize some predictions

[Link](figsize=(8, 4))
for i in range(8):
[Link](2, 4, i + 1)
[Link](X_test[i].reshape(8, 8), cmap=[Link])
 [Link](f'Pred: {y_pred[i]} | True: {y_test[i]}')
[Link]()

Program 8: Principal Component Analysis

# Principal Component Analysis (PCA) on MNIST Dataset
import numpy as np
import [Link] as plt
from [Link] import fetch_openml
from [Link] import PCA
from [Link] import StandardScaler

# Step 1: Load MNIST dataset

print("Loading MNIST dataset...")
mnist = fetch_openml('mnist_784', version=1)
X = [Link]
y = [Link](int)
print("Dataset shape:", [Link])

# Step 2: Standardize the data

print("Standardizing data...")
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 3: Apply PCA

pca = PCA(n_components=50) # Reduce to 50 dimensions for visualization
X_pca = pca.fit_transform(X_scaled)
print("Reduced dataset shape:", X_pca.shape)

# Step 4: Plot explained variance ratio

[Link](figsize=(8, 5))
[Link]([Link](pca.explained_variance_ratio_), marker='o')
[Link]('Explained Variance by Principal Components')
[Link]('Number of Components')
[Link]('Cumulative Explained Variance')
[Link](True)
[Link]()

# Step 5: Visualize first 2 principal components

[Link](figsize=(8, 6))
[Link](X_pca[:10000, 0], X_pca[:10000, 1], c=y[:10000], cmap='tab10', s=10)
[Link](label='Digit Label')
[Link]('MNIST data projected onto first 2 Principal Components')
[Link]('Principal Component 1')
[Link]('Principal Component 2')
[Link]()
Quick Study
Machine Learning Lab Programs - Tabulated Format

PROGRAM 1: DATA EXPLORATION

Component Code/Implementation Purpose

Objective Explore Iris dataset with visualizations Understand data

distribution, relationships,
and basic statistics

Libraries import pandas as pd Data handling, visualization,

import seaborn as sns dataset loading
import [Link] as plt
from [Link] import load_iris
Load Dataset iris = load_iris() Load Iris dataset into pandas
df = [Link](data=[Link], DataFrame
columns=iris.feature_names)
df['species'] = iris.target_names[[Link]]
Basic print([Link]()) Check shape, null values,
Exploration print([Link]().sum()) data types, summary
print([Link]) statistics
print([Link]())
Histogram for i, feature in Visualize distribution of each
enumerate(iris.feature_names): feature
[Link](2, 2, i+1)
[Link](df[feature], kde=True)
Scatter Plot [Link](x='sepal length (cm)', Show relationship between
y='sepal width (cm)', hue='species', data=df) features by species

Box Plot for i, feature in Understand distribution

enumerate(iris.feature_names): across species
[Link](x='species', y=feature, data=df)
PROGRAM 2: LINEAR REGRESSION

Compone Code/Implementation Purpose

nt

Objective Predict median home value (MEDV) using average rooms (RM) Simple
linear
regression
on Boston
Housing
dataset

Libraries import pandas as pd Regressio

import numpy as np n model,
from sklearn.linear_model import LinearRegression evaluation
from [Link] import mean_squared_error, r2_score metrics
Load Data url = Load
'[Link] Boston
[Link]' Housing
df = pd.read_csv(url) dataset
Data X = df[['rm']].[Link](-1, 1) Feature
Preparati y = df['medv'] (RM) and
on target
(MEDV)
separatio
n
Model model = LinearRegression() Train
Training [Link](X, y) linear
print('Intercept:', model.intercept_) regression
print('Slope:', model.coef_[0]) model
Prediction y_pred = [Link](X) Generate
prediction
s
Evaluatio print('MSE:', mean_squared_error(y, y_pred)) Measure
n print('R² Score:', r2_score(y, y_pred)) model
performan
ce
Visualizati [Link](X, y, color='blue', alpha=0.6, label='Actual') Plot
on 1 [Link](X, y_pred, color='red', linewidth=2, actual vs
label='Regression line') predicted
Visualizati residuals = y - y_pred Residual
on 2 [Link](y_pred, residuals, color='purple') plot to
check
errors
PROGRAM 3: LOGISTIC REGRESSION

Component Code/Implementation Purpose

Objective Binary classification on Breast Cancer dataset Classify tumors as

malignant or
benign

Libraries from [Link] import load_breast_cancer Classification

from sklearn.model_selection import train_test_split model and metrics
from sklearn.linear_model import LogisticRegression
from [Link] import accuracy_score,
precision_score, recall_score, confusion_matrix
Load Data data = load_breast_cancer() Load breast cancer
X = [Link] features and labels
y = [Link]
Train-Test X_train, X_test, y_train, y_test = 80-20 split with
Split train_test_split(X, y, test_size=0.2, stratification
random_state=42, stratify=y)
Model model = LogisticRegression(max_iter=10000) Train logistic
Training [Link](X_train, y_train) regression

Prediction y_pred = [Link](X_test) Predict test set

labels

Evaluation accuracy = accuracy_score(y_test, y_pred) Calculate

precision = precision_score(y_test, y_pred) performance
recall = recall_score(y_test, y_pred) metrics
conf_matrix = confusion_matrix(y_test, y_pred)
Confusion [Link](conf_matrix, annot=True, fmt='d', Visualize
Matrix cmap='Blues', xticklabels=data.target_names, classification
yticklabels=data.target_names) results
PROGRAM 4: K-NN CLASSIFIER

Component Code/Implementation Purpose

Objective Classify Iris species using k-Nearest Neighbors Visualize decision

boundaries for
different k values

Libraries from [Link] import k-NN classifier,

KNeighborsClassifier feature scaling
from [Link] import StandardScaler
from [Link] import ListedColormap
Load & Select iris = datasets.load_iris() Use only first 2
X = [Link][:, :2] features for 2D
y = [Link] visualization

Train-Test Split X_train, X_test, y_train, y_test = 70-30 split with

train_test_split(X, y, test_size=0.3, stratification
random_state=42, stratify=y)
Standardization sc = StandardScaler() Scale features for
X_train = sc.fit_transform(X_train) better k-NN
X_test = [Link](X_test) performance

Decision def plot_decision_boundaries(k_values): Create meshgrid and

Boundary xx, yy = [Link](...) predict for
Z = [Link](np.c_[[Link](), [Link]()]) visualization
[Link](xx, yy, Z, alpha=0.4)
Visualization k_values = [1, 5, 15] Show how decision
plot_decision_boundaries(k_values) boundaries change
with k

Accuracy Eval for k in k_values: Compare accuracy

knn = KNeighborsClassifier(n_neighbors=k) for different k
[Link](X_train, y_train)
acc = accuracy_score(y_test,
[Link](X_test))
PROGRAM 5: DECISION TREE CLASSIFIER

Component Code/Implementation Purpose

Objective Build interpretable Decision Tree on Iris dataset Classify species

with visualized tree
structure

Libraries from [Link] import DecisionTreeClassifier, Decision tree

plot_tree, export_text model and
from [Link] import accuracy_score, visualization
classification_report
Load Data iris = load_iris() Load as DataFrame
X = [Link]([Link], for clarity
columns=iris.feature_names)
y = [Link]([Link], name='target')
Train-Test X_train, X_test, y_train, y_test = 70-30 split
Split train_test_split(X, y, test_size=0.3,
random_state=42)
Model model = DecisionTreeClassifier(criterion='entropy', Train with entropy
Training max_depth=3, random_state=42) criterion, limited
[Link](X_train, y_train) depth

Prediction y_pred = [Link](X_test) Classify test

samples

Evaluation print('Accuracy:', accuracy_score(y_test, y_pred)) Performance

print(classification_report(y_test, y_pred, metrics
target_names=iris.target_names))
Tree plot_tree(model, feature_names=iris.feature_names, Visual
Visualization class_names=iris.target_names, filled=True, representation of
rounded=True) tree

Text Rules rules = export_text(model, Text-based

feature_names=iris.feature_names) decision rules
print(rules)
PROGRAM 6: K-MEANS CLUSTERING

Component Code/Implementation Purpose

Objective Unsupervised clustering on Iris features Group similar samples

without using labels

Libraries from [Link] import KMeans k-Means algorithm,

from [Link] import StandardScaler feature scaling

Load Data iris = datasets.load_iris() Load features only (no

X = [Link] labels)

scaler = StandardScaler()
Standardization Normalize features for
X_scaled = scaler.fit_transform(X)
clustering

Clustering kmeans = KMeans(n_clusters=3, random_state=42) Apply k-Means with k=3

[Link](X_scaled)
labels = kmeans.labels_
centroids = kmeans.cluster_centers_
Visualization [Link](X_scaled[:, 0], X_scaled[:, 1], Plot first 2 features with
c=labels, cmap='viridis') cluster assignments
[Link](centroids[:, 0], centroids[:, 1],
c='red', s=200, marker='X', label='Centroids')
Cluster Centers print('Cluster Centers:', centroids) Display centroid
coordinates

Comparison y_true = [Link] Optional: Compare with

print('True labels:', y_true[:10]) actual species
print('Predicted labels:', labels[:10])
PROGRAM 7: SUPPORT VECTOR MACHINE

Component Code/Implementation Purpose

Objective Handwritten digit classification using SVM Classify MNIST

digits (0-9) with
RBF kernel

Libraries from [Link] import SVC SVM classifier and

from [Link] import StandardScaler metrics
from [Link] import accuracy_score,
confusion_matrix, classification_report
Load Data digits = datasets.load_digits() Load digits dataset
print('Image shape:', [Link]) (8x8 images)
print('Label shape:', [Link])
Visualize for i in range(8): Display sample
Samples [Link](2, 4, i+1) images
[Link]([Link][i].reshape(8, 8),
cmap=[Link])
Train-Test X_train, X_test, y_train, y_test = 70-30 split
Split train_test_split([Link], [Link],
test_size=0.3, random_state=42)
Feature scaler = StandardScaler() Standardize pixel
Scaling X_train = scaler.fit_transform(X_train) values
X_test = [Link](X_test)
Model svm_clf = SVC(kernel='rbf', gamma=0.05, C=10) Train SVM with
Training svm_clf.fit(X_train, y_train) RBF kernel

Prediction y_pred = svm_clf.predict(X_test) Classify test digits

Evaluation print('Accuracy:', accuracy_score(y_test, y_pred)) Performance

print('Confusion Matrix:', confusion_matrix(y_test, metrics
y_pred))
print(classification_report(y_test, y_pred))
Visualization for i in range(8): Show predictions
[Link](X_test[i].reshape(8, 8), vs actual
cmap=[Link])
[Link](f'Pred: {y_pred[i]} True: {y_test[i]}')
PROGRAM 8: PRINCIPAL COMPONENT ANALYSIS

Component Code/Implementation Purpose

Objective Dimensionality reduction on MNIST dataset Reduce 784

dimensions to
50 while
preserving
variance

Libraries from [Link] import PCA PCA algorithm,

from [Link] import StandardScaler MNIST loader
from [Link] import fetch_openml
Load MNIST mnist = fetch_openml('mnist_784', version=1) Load full MNIST
X = [Link] (70,000 images)
y = [Link](int)
print('Dataset shape:', [Link])
Standardization scaler = StandardScaler() Normalize pixel
X_scaled = scaler.fit_transform(X) values

Apply PCA pca = PCA(n_components=50) Reduce to 50

X_pca = pca.fit_transform(X_scaled) principal
print('Reduced shape:', X_pca.shape) components

Explained [Link]([Link](pca.explained_variance_ratio_), Plot variance

Variance marker='o') retention curve
[Link]('Number of Components')
[Link]('Cumulative Explained Variance')
2D Visualization [Link](X_pca[:10000, 0], X_pca[:10000, 1], Visualize first 2
c=y[:10000], cmap='tab10', s=10) components
[Link](label='Digit Label')
[Link]('PC1')
[Link]('PC2')