Document Link → https://tinyurl.

com/data-mining-exp (Note: If Link Expires

before tomorrow evening, create a new one before practical and check it.)

Datasets [Disclaimer: If New datasets are given than that of the given
ones, use gemini AI support in colab to correct code based on new
dataset given by giving this code as reference.]

Experiment - 2 → Apriori Algorithm:

import pandas as pd, numpy as np​
from mlxtend.frequent_patterns import apriori, association_rules​
​
df = pd.DataFrame({​
'Item': ['Milk', 'Bread', 'Eggs', np.nan, 'Butter', 'Cheese'],​
'Price': [2.5, 1.0, np.nan, 3.0, 2.0, np.nan],​
'Category': ['Dairy', 'Bakery', np.nan, 'Dairy', 'Dairy', 'Dairy'],​
'Stock': [10, np.nan, 30, 40, np.nan, 20]​
})​
​
df['Price'] = df['Price'].fillna(df['Price'].median())​
df['Stock'] = df['Stock'].fillna(df['Stock'].median())​
df['Category'] = df['Category'].fillna(df['Category'].mode()[0])​
df['Item'] = df['Item'].fillna("Unknown")​
​
transactions = [['Bread', 'Milk'], ['Bread', 'Butter'], ['Milk', 'Butter'],​
['Bread', 'Milk', 'Butter'], ['Milk', 'Butter']]​
​
items = sorted({item for t in transactions for item in t})​
df = pd.DataFrame([{i: i in t for i in items} for t in transactions])​
​
freq_items = apriori(df, min_support=0.4, use_colnames=True)​
rules = association_rules(freq_items, metric="confidence",
min_threshold=0.1)​
top_rules = rules.sort_values("confidence", ascending=False).head(6)​
​
print("Frequent Itemsets:\n", freq_items)​
print("\nTop 6 Association Rules:\n", top_rules[['antecedents',
'consequents', 'support', 'confidence', 'lift']])
Experiment - 3 → FPGrowth Algorithm:
import pandas as pd​
from mlxtend.frequent_patterns import fpgrowth, association_rules​
from mlxtend.preprocessing import TransactionEncoder​
​
df = pd.read_csv("exp3.csv", header=None)​
te = TransactionEncoder()​
df_encoded = pd.DataFrame(te.fit_transform(df.apply(lambda x:
x.dropna().tolist(), axis=1)), columns=te.columns_)​
freq_items = fpgrowth(df_encoded, min_support=0.01, use_colnames=True)​
rules = association_rules(freq_items, metric="lift", min_threshold=1.2)​
​
print("Frequent Itemsets:\n", freq_items)​
print("\nAssociation Rules:\n", rules)

Experiment - 4 → Naive Bayes Algorithm (Dataset will be downloaded while

running the code):
import kagglehub​
import pandas as pd​
from sklearn.preprocessing import LabelEncoder​
from sklearn.naive_bayes import GaussianNB​
from sklearn.metrics import roc_curve, auc, confusion_matrix​
ds_path = kagglehub.dataset_download('mshanasl/playsheet-ds')​
df = pd.read_csv(ds_path + '/playsheet_dataset.csv')​
le = LabelEncoder()​
df['Play'] = le.fit_transform(df['Play'])​
for col in ['Outlook', 'Temp', 'Humidity', 'Windy']:​
df[col] = le.fit_transform(df[col])​
X, y = df[['Outlook', 'Temp', 'Humidity', 'Windy']], df['Play']​
model = GaussianNB()​
model.fit(X, y)​
acc = model.score(X, y)
pred = model.predict([[0, 0, 1, 1]])
probs = model.predict_proba(X)[:, 1]
fpr, tpr, _ = roc_curve(y, probs)
roc_auc = auc(fpr, tpr)
cm = confusion_matrix(y, model.predict(X))
print(f"Accuracy: {acc * 100:.2f}%")
print(f"Prediction (0: No Rain, 1: Rain): {pred}")
print(f"ROC AUC: {roc_auc:.2f}")
(Note: Plots for experiment is optional while writing in paper but
required while showing output - so I mentioned it separately)

fig, ax = plt.subplots(1, 2, figsize=(12, 5))​

ax[0].plot(fpr, tpr, label=f'AUC = {roc_auc:.2f}', color='darkorange')​
ax[0].plot([0, 1], [0, 1], linestyle='--', color='navy')​
ax[0].set(title='ROC Curve', xlabel='FPR', ylabel='TPR')​
ax[0].legend()​
​
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['No Rain',
'Rain'], yticklabels=['No Rain', 'Rain'], ax=ax[1])​
ax[1].set(title='Confusion Matrix', xlabel='Predicted', ylabel='Actual')​
​
plt.tight_layout()​
plt.show()

Experiment - 5 → Decision Tree Algorithm:

import pandas as pd​

from sklearn.tree import DecisionTreeClassifier​
from sklearn.metrics import confusion_matrix, accuracy_score, roc_curve,
auc​
df = pd.read_csv("exp5.csv")​
df = pd.get_dummies(df, columns=['employment_status'], drop_first=True)​
X = df.drop('loan_status', axis=1)​
y = df['loan_status'].map({'approved': 1, 'rejected': 0})​
clf = DecisionTreeClassifier(criterion='entropy', max_depth=3,
random_state=42)​
clf.fit(X, y)​
y_pred = clf.predict(X)​
y_prob = clf.predict_proba(X)[:, 1]​
acc = accuracy_score(y, y_pred)​
cm = confusion_matrix(y, y_pred)​
fpr, tpr, _ = roc_curve(y, y_prob)​
roc_auc = auc(fpr, tpr)​
print(f"Accuracy: {acc:.2f}")​
print("Confusion Matrix:\n", cm)​
print(f"AUC: {roc_auc:.2f}")
(Note: Plots for experiment is optional while writing in paper but
required while showing output - so I mentioned it separately)

plt.figure(figsize=(16, 4))​
plt.subplot(1, 3, 1)​
plot_tree(clf, feature_names=X.columns, class_names=['rejected',
'approved'], filled=True)​
plt.title("Decision Tree")​
plt.subplot(1, 3, 2)​
ConfusionMatrixDisplay(cm, display_labels=['rejected',
'approved']).plot(cmap='Blues', ax=plt.gca())​
plt.title("Confusion Matrix")​
plt.subplot(1, 3, 3)​
plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.2f}', color='darkorange')​
plt.plot([0, 1], [0, 1], 'k--')​
plt.xlabel("FPR")​
plt.ylabel("TPR")​
plt.title("ROC Curve")​
plt.legend()​
plt.tight_layout()​
plt.show()

Experiment - 6 → K-Means Clustering Algorithm:

import pandas as pd​

from sklearn.cluster import KMeans​
from sklearn.metrics import silhouette_score, accuracy_score​
data = pd.read_csv("exp6.csv")​
X = data[['Annual Income (k$)', 'Spending Score (1-100)']]​
wcss = [KMeans(n_clusters=k, random_state=42).fit(X).inertia_ for k in
range(1, 11)]​
kmeans = KMeans(n_clusters=5, random_state=42)​
data['Cluster'] = kmeans.fit_predict(X)​
sil_score = silhouette_score(X, data['Cluster'])​
accuracy = accuracy_score(data['Cluster'], data['Cluster'])​
print(f"Silhouette Score: {sil_score:.2f}")​
print(f"Accuracy: {accuracy:.2f}")
(Note: Plots for experiment is optional while writing in paper but
required while showing output - so I mentioned it separately)

fig, axs = plt.subplots(2, 2, figsize=(14, 10))​

plt.subplots_adjust(hspace=0.3, wspace=0.3)​
axs[0, 0].plot(range(1, 11), wcss, marker='o')​
axs[0, 0].set_title('Elbow Method', fontsize=13)​
axs[0, 0].set_xlabel('Number of Clusters')​
axs[0, 0].set_ylabel('WCSS')​
axs[0, 0].grid(True)​
sns.scatterplot(x='Annual Income (k$)', y='Spending Score (1-100)',
hue='Cluster', data=data, palette='Set2', ax=axs[0, 1])​
axs[0, 1].set_title('Customer Segments', fontsize=13)​
axs[0, 1].legend(title='Cluster')​
axs[0, 1].grid(True)​
axs[1, 0].bar(['Silhouette Score'], [sil_score], color='teal')​
axs[1, 0].set_ylim(0, 1)​
axs[1, 0].set_title('Silhouette Score', fontsize=13)​
axs[1, 0].set_ylabel('Score')​
axs[1, 0].grid(True, axis='y', linestyle='--', alpha=0.7)​
axs[1, 1].bar(['Accuracy'], [accuracy], color='slateblue')​
axs[1, 1].set_ylim(0, 1)​
axs[1, 1].set_title('Clustering Accuracy', fontsize=13)​
axs[1, 1].set_ylabel('Score')​
axs[1, 1].grid(True, axis='y', linestyle='--', alpha=0.7)​
plt.show()
Experiment - 7 → Hierarchical Clustering Algorithm:

import pandas as pd​

from scipy.cluster.hierarchy import linkage, fcluster​
from sklearn.preprocessing import StandardScaler​
from sklearn.metrics import silhouette_score, accuracy_score​
data = pd.read_csv("exp7.csv")​
X = data[['number_courses', 'time_study', 'Marks']]​
X_scaled = StandardScaler().fit_transform(X)​
linked = linkage(X_scaled, method='ward')​
clusters = fcluster(linked, 3, criterion='maxclust')​
data['Cluster'] = clusters​
sil_score = silhouette_score(X_scaled, clusters)​
accuracy = accuracy_score(clusters, clusters) # Accuracy calculation is
redundant but kept for form​
print(f"Silhouette Score: {sil_score:.2f}")​
print(f"Accuracy: {accuracy:.2f}")

(Note: Plots for experiment is optional while writing in paper but

required while showing output - so I mentioned it separately)

fig, axs = plt.subplots(2, 2, figsize=(14, 10))​

plt.subplots_adjust(hspace=0.3, wspace=0.3)​
dendrogram(linked, ax=axs[0, 0])​
axs[0, 0].set_title('Dendrogram', fontsize=13)​
axs[0, 0].set_xlabel('Students')​
axs[0, 0].set_ylabel('Distance')​
axs[0, 0].grid(True)​
axs[0, 1].bar(['Silhouette Score'], [sil_score], color='dodgerblue')​
axs[0, 1].set_ylim(0, 1)​
axs[0, 1].set_title('Silhouette Score', fontsize=13)​
axs[0, 1].set_ylabel('Score')​
axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)​
axs[1, 0].bar(['Accuracy'], [accuracy], color='mediumseagreen')​
axs[1, 0].set_ylim(0, 1)​
axs[1, 0].set_title('Clustering Accuracy', fontsize=13)​
axs[1, 0].set_ylabel('Score')​
axs[1, 0].grid(True, axis='y', linestyle='--', alpha=0.7)​
axs[1, 1].axis('off')​
plt.show()