### Experiment 8 Clustering Data by K Means Clustering Algorithm

```bash 
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn import preprocessing
from sklearn.mixture import GaussianMixture

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

dataset = load_iris()

X = pd.DataFrame(dataset.data)
X.columns = [
    'Sepal_Length', 'Sepal_Width',
    'Petal_Length', 'Petal_Width'
]

y = pd.DataFrame(dataset.target)
y.columns = ['Targets']

plt.figure(figsize=(14, 7))
colormap = np.array(['red', 'lime', 'black'])

# Real plot
plt.subplot(1, 3, 1)
plt.scatter(
    X.Petal_Length, X.Petal_Width,
    c=colormap[y.Targets], s=40
)
plt.title('Real')

# K-Means plot
plt.subplot(1, 3, 2)
model = KMeans(n_clusters=3, random_state=42, n_init=10)
model.fit(X)

predY = np.choose(
    model.labels_, [0, 1, 2]
).astype(np.int64)

plt.scatter(
    X.Petal_Length, X.Petal_Width,
    c=colormap[predY], s=40
)
plt.title('KMeans')

# GMM plot
scaler = preprocessing.StandardScaler()
scaler.fit(X)

xsa = scaler.transform(X)
xs = pd.DataFrame(xsa, columns=X.columns)

gmm = GaussianMixture(n_components=3, random_state=42)
gmm.fit(xs)

y_cluster_gmm = gmm.predict(xs)

plt.subplot(1, 3, 3)
plt.scatter(
    X.Petal_Length, X.Petal_Width,
    c=colormap[y_cluster_gmm], s=40
)
plt.title('GMM Classification')

plt.show()
```

---

### Experiment 9 Implementing Ensembling Techniques

```bash 
import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import (
    VotingClassifier,
    BaggingClassifier,
    AdaBoostClassifier
)

iris = load_iris()
X = iris.data
y = iris.target

print("Features:")
print(X[:5])

print("\nTarget:")
print(y[:5])

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

model1 = DecisionTreeClassifier(max_depth=3, random_state=42)
model2 = DecisionTreeClassifier(max_depth=5, random_state=42)
model3 = DecisionTreeClassifier(max_depth=7, random_state=42)

# Voting Classifier
voting_model = VotingClassifier(
    estimators=[
        ('tree1', model1),
        ('tree2', model2),
        ('tree3', model3)
    ],
    voting='hard'
)

voting_model.fit(X_train, y_train)
y_pred_voting = voting_model.predict(X_test)

print("Voting Accuracy:",
      accuracy_score(y_test, y_pred_voting))

# Bagging Classifier
bagging_model = BaggingClassifier(
    estimator=DecisionTreeClassifier(random_state=42),
    n_estimators=50,
    random_state=42
)

bagging_model.fit(X_train, y_train)
y_pred_bagging = bagging_model.predict(X_test)

print("Bagging Accuracy:",
      accuracy_score(y_test, y_pred_bagging))

# Boosting Classifier
boosting_model = AdaBoostClassifier(
    estimator=DecisionTreeClassifier(max_depth=1),
    n_estimators=50,
    random_state=42
)

boosting_model.fit(X_train, y_train)
y_pred_boosting = boosting_model.predict(X_test)

print("Boosting Accuracy:",
      accuracy_score(y_test, y_pred_boosting))

print("Voting Accuracy :", accuracy_score(y_test, y_pred_voting))
print("Bagging Accuracy :", accuracy_score(y_test, y_pred_bagging))
print("Boosting Accuracy:", accuracy_score(y_test, y_pred_boosting))
```

---
### Experiment 10 Build SVM Models

```bash
# Import Python library packages
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn import svm, metrics
from sklearn.preprocessing import LabelEncoder, label_binarize
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve, auc, roc_auc_score

# Read the dataset directly from URL
url = "https://raw.githubusercontent.com/fejiso/Coronavirus-Dataset/master/patient.csv"

data = pd.read_csv(url)

# Create Label column if it does not exist
if 'Label' not in data.columns:
    label_map = {
        'isolated': 0,
        'released': 1,
        'deceased': 2
    }
    data['Label'] = data['state'].str.lower().map(label_map)

# Display the first 5 rows
print("The first 5 rows of data:")
print(data.head())

# Check unique values of each column
print("\nUnique values of each column:")
for i in data.columns:
    print(i, ":", data[i].unique(), "\t", data[i].nunique())

# Display dataset information
print("\nDataset Information:")
data.info()

# Encode categorical data for correlation heatmap
data_encoded = data.copy()

for col in data_encoded.columns:
    if data_encoded[col].dtype == 'object':
        le = LabelEncoder()
        data_encoded[col] = le.fit_transform(
            data_encoded[col].astype(str)
        )

# First heatmap
plt.figure(figsize=(10, 6))
sns.heatmap(
    data_encoded.corr(),
    annot=True,
    cmap='coolwarm'
)
plt.title("Correlation Heatmap Before Preprocessing")
plt.show()

# Encode categorical columns in original dataset
categorical_columns = data.select_dtypes(
    include=['object']
).columns

for col in categorical_columns:
    le = LabelEncoder()
    data[col] = le.fit_transform(data[col].astype(str))

# Second heatmap
plt.figure(figsize=(10, 6))
sns.heatmap(
    data.corr(),
    annot=True,
    cmap='coolwarm'
)
plt.title("Correlation Heatmap After Encoding")
plt.show()

# Features and target
X = data.drop('Label', axis=1)
y = data['Label']

print("\nFirst 2 rows of X:")
print(X.head(2))

# Check missing values
print("\nMissing Values Before Handling:")
print(data.isnull().sum())

# Fill missing values with mode
for col in data.columns:
    if data[col].isnull().any():
        data[col] = data[col].fillna(data[col].mode()[0])

# Check missing values again
print("\nMissing Values After Handling:")
print(data.isnull().sum())

# Update features and target
X = data.drop('Label', axis=1)
y = data['Label']

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.33,
    random_state=42,
    stratify=y
)

# Create SVM model
clf = svm.SVC(
    kernel='linear',
    probability=True,
    random_state=42
)

# Train the model
clf.fit(X_train, y_train)

# Predict
y_pred = clf.predict(X_test)

# Accuracy
print("\nAccuracy for SVM:",
      metrics.accuracy_score(y_test, y_pred))

# Confusion Matrix
print("\nConfusion Matrix:")
cm = confusion_matrix(y_test, y_pred)
print(cm)

# Classification Report
print("\nClassification Report:")
print(classification_report(
    y_test,
    y_pred,
    zero_division=0
))

# Confusion Matrix Heatmap
plt.figure(figsize=(7, 5))
sns.heatmap(
    cm,
    annot=True,
    fmt='d',
    cmap='Blues'
)
plt.title('SVM Confusion Matrix')
plt.xlabel('Predicted Values')
plt.ylabel('Actual Values')
plt.show()

# Multiclass ROC-AUC
classes = np.unique(y_test)

y_test_bin = label_binarize(
    y_test,
    classes=classes
)

# Get SVM probability predictions
svm_probs = clf.predict_proba(X_test)

# Calculate multiclass ROC-AUC
svm_auc = roc_auc_score(
    y_test_bin,
    svm_probs,
    multi_class='ovr',
    average='weighted'
)

print("\nSVM Multiclass ROC AUC = %.3f" % svm_auc)

# Print number of classes
print("\nNumber of classes:", y.nunique())
print("Classes:", sorted(y.unique()))

# Multiclass ROC Curve
plt.figure(figsize=(8, 6))

# Plot ROC curve for each class
for i, class_name in enumerate(classes):

    fpr, tpr, thresholds = roc_curve(
        y_test_bin[:, i],
        svm_probs[:, i]
    )

    roc_auc = auc(fpr, tpr)

    plt.plot(
        fpr,
        tpr,
        linewidth=2,
        label=f'Class {class_name} (AUC = {roc_auc:.3f})'
    )

# No-skill reference line
plt.plot(
    [0, 1],
    [0, 1],
    'k--',
    linewidth=1.5,
    label='No Skill'
)

# Labels and title
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Multiclass ROC Curve - SVM')

# Legend
plt.legend(loc='lower right')

# Grid
plt.grid(alpha=0.3)

# Display
plt.show()

# Overall AUC
overall_auc = roc_auc_score(
    y_test_bin,
    svm_probs,
    multi_class='ovr',
    average='weighted'
)

print("\nOverall SVM Multiclass ROC AUC = %.3f" % overall_auc)

print("\nSVM Experiment Completed Successfully!")
```