AryAbhAttA college
University of delhi
DATA MINING I PRACTICAL
SEMESTER IV
sUbMitted by : PriyAnshU KUMAr
ROLL NO : CSC/23/54 45
University roll no : 23059570007
23059570039
sUbMitted to : dr. sonAl lindA
COURSE : B.sc (H) Computer science
INDEX
S.no. Practicals Page
no.
1. Apply data cleaning techniques on any dataset 4-6
(e.g, wine dataset). Techniques may include
handling missing values, outliers, inconsistent
values. A set of validation rules can be prepared
based on the dataset and validations can be
performed.
2. Apply data pre-processing techniques such as 7-14
standardization/normalization, transformation,
aggregation, discretization/binarization,
sampling etc. on any dataset
3. Run Apriori algorithm to find frequent item sets 15-16
and association rules on 2 real datasets and use
appropriate evaluation measures to compute
correctness of obtained patterns
a) Use minimum support as 50% and minimum
confidence as 75%
b) Use minimum support as 60% and minimum
confidence as 60 %
4. Use Naive bayes, K-nearest, and Decision tree 16-20
classification algorithms and build classifiers on
any two datasets. Divide the data set into
training and test set. Compare the accuracy of
the different classifiers under the following
situations:
I.
a) Training set = 75% Test set = 25%
b) Training set = 66.6% (2/3rd of total), Test set =
33.3%
II. Training set is chosen by
a) hold out method
b) Random subsampling
c) Cross-Validation. Compare the
accuracy of the classifiers obtained.
Data needs to be scaled to standard
format.
5. Use Simple K-means algorithm for clustering on 21-26
any dataset. Compare the performance of
clusters by changing the parameters involved in
the algorithm. Plot MSE computed after each
iteration using a line plot for any set of
parameters.
Practical 1
Question :
Apply data cleaning techniques on any dataset
(e.g, wine dataset). Techniques may include
handling missing values, outliers, inconsistent
values. A set of validation rules can be prepared
based on the dataset and validations can be
performed.
CODE :
# Step 1: Import Libraries
import pandas as pd
import numpy as np
from sklearn.datasets import load_wine
import seaborn as sns
import matplotlib.pyplot as plt
# Step 2: Load Dataset
wine = load_wine()
df = pd.DataFrame(wine.data, columns=wine.feature_names)
df['target'] = wine.target
print("Original Dataset:")
print(df.head())
# Step 3: Introduce Some Missing Values for Practice
df.loc[5:10, 'ash'] = np.nan
df.loc[15:18, 'alcalinity_of_ash'] = np.nan
# Step 4: Handling Missing Values
# Option 1: Fill with Mean
df['ash'].fillna(df['ash'].mean(), inplace=True)
df['alcalinity_of_ash'].fillna(df['alcalinity_of_ash'].median(), inplace=True)
# Step 5: Handling Outliers (Using IQR)
def remove_outliers(col):
Q1 = df[col].quantile(0.25)
Q3 = df[col].quantile(0.75)
IQR = Q3 - Q1
lower = Q1 - 1.5 * IQR
upper = Q3 + 1.5 * IQR
df[col] = np.where((df[col] < lower) | (df[col] > upper), df[col].median(), df[col])
# Apply on few numeric columns
for col in ['alcohol', 'malic_acid', 'color_intensity']:
remove_outliers(col)
# Step 6: Inconsistent Values
# Suppose we mistakenly type a wrong value in 'target'
df.loc[0, 'target'] = 5 # Invalid, valid target = 0,1,2
# Fix: Replace with mode or set a rule
df['target'] = df['target'].apply(lambda x: x if x in [0, 1, 2] else df['target'].mode()[0])
# Step 7: Validation Rules
validation_results = {
'no_negative_values': (df.select_dtypes(include=[np.number]) >= 0).all().all(),
'target_in_range': df['target'].isin([0, 1, 2]).all(),
'ash_not_null': df['ash'].isnull().sum() == 0,
print("Validation Results:")
print(validation_results)
# Optional Visualization
sns.boxplot(x=df['alcohol'])
plt.title("Boxplot for Alcohol after Outlier Handling")
plt.show()
Screenshot :
(i)
(ii)
Practical 2
Question :
Apply data pre-processing techniques such as
standardization/normalization, transformation, aggregation,
discretization/binarization, sampling etc. on any dataset
CODE :
import pandas as pd
import numpy as np
from sklearn.datasets import load_wine
from sklearn.preprocessing import StandardScaler, MinMaxScaler, KBinsDiscretizer, Binarizer
from sklearn.model_selection import train_test_split
# Load dataset
wine = load_wine()
df = pd.DataFrame(wine.data, columns=wine.feature_names)
df['target'] = wine.target
print("Original Dataset:")
print(df.head())
# 1. Standardization (mean=0, std=1)
scaler = StandardScaler()
standardized = scaler.fit_transform(df.iloc[:, :-1]) # without target
df_standardized = pd.DataFrame(standardized, columns=wine.feature_names)
print("\nStandardized Data:")
print(df_standardized.head())
# 2. Normalization (min-max scaling)
minmax = MinMaxScaler()
normalized = minmax.fit_transform(df.iloc[:, :-1])
df_normalized = pd.DataFrame(normalized, columns=wine.feature_names)
print("\nNormalized Data:")
print(df_normalized.head())
# 3. Transformation (log transformation on skewed column)
df['log_proline'] = np.log(df['proline'] + 1) # +1 to avoid log(0)
print("\nLog Transformed 'proline':")
print(df[['proline', 'log_proline']].head())
# 4. Aggregation (mean values by class)
aggregated = df.groupby('target').mean()
print("\nAggregated Mean by Target Class:")
print(aggregated)
# 5. Discretization (binning alcohol into 3 categories)
discretizer = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
df['alcohol_bin'] = discretizer.fit_transform(df[['alcohol']])
print("\nDiscretized 'alcohol':")
print(df[['alcohol', 'alcohol_bin']].head())
# 6. Binarization (proline high/low based on threshold)
binarizer = Binarizer(threshold=750)
df['proline_bin'] = binarizer.fit_transform(df[['proline']])
print("\nBinarized 'proline':")
print(df[['proline', 'proline_bin']].head())
# 7. Sampling (random 20% of data)
sampled_df = df.sample(frac=0.2, random_state=42)
print("\nSampled 20% of Dataset:")
print(sampled_df.head())
OUTPUT :-
Original Dataset:
alcohol malic_acid ash alcalinity_of_ash magnesium total_phenols \
0 14.23 1.71 2.43 15.6 127.0 2.80
1 13.20 1.78 2.14 11.2 100.0 2.65
2 13.16 2.36 2.67 18.6 101.0 2.80
3 14.37 1.95 2.50 16.8 113.0 3.85
4 13.24 2.59 2.87 21.0 118.0 2.80
flavanoids nonflavanoid_phenols proanthocyanins color_intensity hue \
0 3.06 0.28 2.29 5.64 1.04
1 2.76 0.26 1.28 4.38 1.05
2 3.24 0.30 2.81 5.68 1.03
3 3.49 0.24 2.18 7.80 0.86
4 2.69 0.39 1.82 4.32 1.04
od280/od315_of_diluted_wines proline target
0 3.92 1065.0 0
1 3.40 1050.0 0
2 3.17 1185.0 0
3 3.45 1480.0 0
4 2.93 735.0 0
Standardized Data:
alcohol malic_acid ash alcalinity_of_ash magnesium \
0 1.518613 -0.562250 0.232053 -1.169593 1.913905
1 0.246290 -0.499413 -0.827996 -2.490847 0.018145
2 0.196879 0.021231 1.109334 -0.268738 0.088358
3 1.691550 -0.346811 0.487926 -0.809251 0.930918
4 0.295700 0.227694 1.840403 0.451946 1.281985
total_phenols flavanoids nonflavanoid_phenols proanthocyanins \
0 0.808997 1.034819 -0.659563 1.224884
1 0.568648 0.733629 -0.820719 -0.544721
2 0.808997 1.215533 -0.498407 2.135968
3 2.491446 1.466525 -0.981875 1.032155
4 0.808997 0.663351 0.226796 0.401404
color_intensity hue od280/od315_of_diluted_wines proline
0 0.251717 0.362177 1.847920 1.013009
1 -0.293321 0.406051 1.113449 0.965242
2 0.269020 0.318304 0.788587 1.395148
3 1.186068 -0.427544 1.184071 2.334574
4 -0.319276 0.362177 0.449601 -0.037874
Normalized Data:
alcohol malic_acid ash alcalinity_of_ash magnesium \
0 0.842105 0.191700 0.572193 0.257732 0.619565
1 0.571053 0.205534 0.417112 0.030928 0.326087
2 0.560526 0.320158 0.700535 0.412371 0.336957
3 0.878947 0.239130 0.609626 0.319588 0.467391
4 0.581579 0.365613 0.807487 0.536082 0.521739
total_phenols flavanoids nonflavanoid_phenols proanthocyanins \
0 0.627586 0.573840 0.283019 0.593060
1 0.575862 0.510549 0.245283 0.274448
2 0.627586 0.611814 0.320755 0.757098
3 0.989655 0.664557 0.207547 0.558360
4 0.627586 0.495781 0.490566 0.444795
color_intensity hue od280/od315_of_diluted_wines proline
0 0.372014 0.455285 0.970696 0.561341
1 0.264505 0.463415 0.780220 0.550642
2 0.375427 0.447154 0.695971 0.646933
3 0.556314 0.308943 0.798535 0.857347
4 0.259386 0.455285 0.608059 0.325963
Log Transformed 'proline':
proline log_proline
0 1065.0 6.971669
1 1050.0 6.957497
2 1185.0 7.078342
3 1480.0 7.300473
4 735.0 6.601230
Aggregated Mean by Target Class:
alcohol malic_acid ash alcalinity_of_ash magnesium \
target
0 13.744746 2.010678 2.455593 17.037288 106.338983
1 12.278732 1.932676 2.244789 20.238028 94.549296
2 13.153750 3.333750 2.437083 21.416667 99.312500
total_phenols flavanoids nonflavanoid_phenols proanthocyanins \
target
0 2.840169 2.982373 0.290000 1.899322
1 2.258873 2.080845 0.363662 1.630282
2 1.678750 0.781458 0.447500 1.153542
color_intensity hue od280/od315_of_diluted_wines proline \
target
0 5.528305 1.062034 3.157797 1115.711864
1 3.086620 1.056282 2.785352 519.507042
2 7.396250 0.682708 1.683542 629.895833
log_proline
target
0 6.998383
1 6.212565
2 6.430818
Discretized 'alcohol':
alcohol alcohol_bin
0 14.23 2.0
1 13.20 1.0
2 13.16 1.0
3 14.37 2.0
4 13.24 1.0
Binarized 'proline':
proline proline_bin
0 1065.0 1.0
1 1050.0 1.0
2 1185.0 1.0
3 1480.0 1.0
4 735.0 0.0
Sampled 20% of Dataset:
alcohol malic_acid ash alcalinity_of_ash magnesium total_phenols \
19 13.64 3.10 2.56 15.2 116.0 2.70
45 14.21 4.04 2.44 18.9 111.0 2.85
140 12.93 2.81 2.70 21.0 96.0 1.54
30 13.73 1.50 2.70 22.5 101.0 3.00
67 12.37 1.17 1.92 19.6 78.0 2.11
flavanoids nonflavanoid_phenols proanthocyanins color_intensity hue \
19 3.03 0.17 1.66 5.10 0.96
45 2.65 0.30 1.25 5.24 0.87
140 0.50 0.53 0.75 4.60 0.77
30 3.25 0.29 2.38 5.70 1.19
67 2.00 0.27 1.04 4.68 1.12
od280/od315_of_diluted_wines proline target log_proline alcohol_bin \
19 3.36 845.0 0 6.740519 2.0
45 3.33 1080.0 0 6.985642 2.0
140 2.31 600.0 2 6.398595 1.0
30 2.71 1285.0 0 7.159292 2.0
67 3.48 510.0 1 6.236370 1.0
proline_bin
19 1.0
45 1.0
140 0.0
30 1.0
67 0.0
Screenshot :
(i)
(ii)
(iii)
Practical 3
QUESTION :
Run Apriori algorithm to find frequent item sets and
association rules on 2 real datasets and use appropriate
evaluation measures to compute correctness of obtained patterns
a) Use minimum support as 50% and minimum confidence as 75%
b) Use minimum support as 60% and minimum confidence as 60 %
CODE :
import pandas as pd
from mlxtend.frequent_patterns import apriori, association_rules
# Dataset 1: Groceries (example style)
data = [['milk', 'bread', 'eggs'],
['milk', 'bread'],
['milk', 'eggs'],
['bread', 'eggs'],
['milk', 'bread', 'eggs', 'butter'],
['bread', 'butter']]
# Convert to dataframe (one-hot encoded format)
from mlxtend.preprocessing import TransactionEncoder
te = TransactionEncoder()
te_data = te.fit(data).transform(data)
df = pd.DataFrame(te_data, columns=te.columns_)
def run_apriori(df, min_support, min_confidence):
print(f"\nRunning Apriori with min_support={min_support}, min_confidence={min_confidence}")
freq_items = apriori(df, min_support=min_support, use_colnames=True)
rules = association_rules(freq_items, metric="confidence", min_threshold=min_confidence)
# Evaluation: Show Lift, Confidence, Support
rules = rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']]
print("\nFrequent Itemsets:\n", freq_items)
print("\nAssociation Rules:\n", rules)
return rules
# a) Support=50%, Confidence=75%
run_apriori(df, min_support=0.5, min_confidence=0.75)
# b) Support=60%, Confidence=60%
run_apriori(df, min_support=0.6, min_confidence=0.6)
Screenshot :
(i)
Practical 4
QUESTION :
Use Naive bayes, K-nearest, and Decision tree
classification algorithms and build classifiers on any two
datasets. Divide the data set into training and test set.
Compare the accuracy of the different classifiers under
the following situations:
I.
a) Training set = 75% Test set = 25%
b) Training set = 66.6% (2/3rd of total), Test set =
33.3%
II. Training set is chosen by
i) hold out method
ii) Random subsampling
iii) Cross-Validation. Compare the accuracy of
the classifiers obtained. Data needs to be
scaled to standard format.
CODE :
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
# Load Dataset 1: Iris
iris = datasets.load_iris()
X1 = pd.DataFrame(iris.data, columns=iris.feature_names)
y1 = pd.Series(iris.target)
# Load Dataset 2: Wine
wine = datasets.load_wine()
X2 = pd.DataFrame(wine.data, columns=wine.feature_names)
y2 = pd.Series(wine.target)
# Standardize the data
scaler = StandardScaler()
X1_scaled = scaler.fit_transform(X1)
X2_scaled = scaler.fit_transform(X2)
# Classifiers
models = {
'Naive Bayes': GaussianNB(),
'KNN': KNeighborsClassifier(),
'Decision Tree': DecisionTreeClassifier(random_state=0)
# Function to evaluate models
def evaluate_models(X, y, dataset_name):
print(f"\n Results for {dataset_name} Dataset:\n")
# I. a) Train 75% / Test 25%
print("I. a) 75% Train / 25% Test:")
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
for name, model in models.items():
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
acc = accuracy_score(y_test, y_pred)
print(f" {name}: {acc:.2f}")
# I. b) Train 66.6% / Test 33.3%
print("\nI. b) 66.6% Train / 33.3% Test:")
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.333, random_state=42)
for name, model in models.items():
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
acc = accuracy_score(y_test, y_pred)
print(f" {name}: {acc:.2f}")
# II. Hold-out (already done above)
# II. Random Subsampling (Repeat holdout multiple times)
print("\nII. Random Subsampling (10 runs):")
for name, model in models.items():
scores = []
for _ in range(10):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
scores.append(accuracy_score(y_test, y_pred))
print(f" {name}: Avg Accuracy: {sum(scores)/len(scores):.2f}")
# II. Cross-validation
print("\nII. Cross Validation (5-fold):")
for name, model in models.items():
scores = cross_val_score(model, X, y, cv=5)
print(f" {name}: Avg Accuracy: {scores.mean():.2f}")
# Run evaluation on both datasets
evaluate_models(X1_scaled, y1, "Iris")
evaluate_models(X2_scaled, y2, "Wine")
Screenshot :
(i)
Practical 5
Question :
Use Simple K-means algorithm for clustering
on any dataset. Compare the performance of clusters by
changing the parameters involved in the algorithm. Plot
MSE computed after each iteration using a line plot for
any set of parameters.
CODE :
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
# Load Iris dataset
iris = datasets.load_iris()
X = iris.data
# Scale the data
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# Try different values of k (clusters)
cluster_range = [2, 3, 4, 5, 6]
print(" Cluster Performance (Silhouette Score):\n")
for k in cluster_range:
kmeans = KMeans(n_clusters=k, init='k-means++', max_iter=300, random_state=42)
kmeans.fit(X_scaled)
labels = kmeans.labels_
silhouette = silhouette_score(X_scaled, labels)
print(f"k = {k} → Silhouette Score = {silhouette:.4f}, Inertia (MSE) =
{kmeans.inertia_:.2f}")
# --------------------------
# MSE vs Iteration Plot for k=3
print("\n Plotting MSE per iteration for k=3")
kmeans = KMeans(n_clusters=3, init='random', max_iter=10, n_init=1, verbose=1,
random_state=42)
kmeans.fit(X_scaled)
# Plot inertia over iterations (Using verbose=True helps print it)
# Note: sklearn doesn't expose inertia per iteration, so we'll do manual tracking
inertias = []
X_input = X_scaled
for i in range(1, 11):
kmeans = KMeans(n_clusters=3, init='random', max_iter=i, n_init=1, random_state=42)
kmeans.fit(X_input)
inertias.append(kmeans.inertia_)
# Plotting the inertia (MSE) after each iteration
plt.figure(figsize=(8, 5))
plt.plot(range(1, 11), inertias, marker='o', linestyle='-')
plt.title("MSE (Inertia) after each iteration (k=3)")
plt.xlabel("Iteration")
plt.ylabel("MSE (Inertia)")
plt.grid(True)
plt.show()
Screenshot:
(i)
(ii)
(iii)
Thank You
