python-lab-toolkit 1.0.0__py3-none-any.whl

pylab/templates/q47/preprocess_data.py

@@ -0,0 +1,54 @@
+import os
+import sys
+
+def run_preprocessing():
+    try:
+        import pandas as pd
+        import numpy as np
+        from sklearn.impute import SimpleImputer
+        from sklearn.compose import ColumnTransformer
+        from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
+    except ImportError:
+        print("Error: pandas and scikit-learn are required for Q47.")
+        print("Install with: pip install pandas scikit-learn")
+        return
+
+    csv_path = "Data.csv"
+    if not os.path.exists(csv_path):
+        print(f"Error: {csv_path} was not found.")
+        return
+
+    print("=== Data.csv Machine Learning Preprocessing Pipeline ===")
+    dataset = pd.read_csv(csv_path)
+    print("1. Raw Dataset (with missing entries):")
+    print(dataset.to_string(index=False))
+
+    X = dataset.iloc[:, :-1].values
+    y = dataset.iloc[:, -1].values
+
+    imputer = SimpleImputer(missing_values=np.nan, strategy="mean")
+    imputer.fit(X[:, 1:3])
+    X[:, 1:3] = imputer.transform(X[:, 1:3])
+    print("\n2. Features after Mean Imputation on Age & Salary:")
+    print(X)
+
+    ct = ColumnTransformer(transformers=[("encoder", OneHotEncoder(), [0])], remainder="passthrough")
+    X_encoded = np.array(ct.fit_transform(X))
+    print("\n3. Features after One-Hot Encoding Country Column:")
+    print(X_encoded)
+
+    le = LabelEncoder()
+    y_encoded = le.fit_transform(y)
+    print(f"\n4. Target Vector after Label Encoding (Classes: {list(le.classes_)}):")
+    print(y_encoded)
+
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X_encoded)
+    print("\n5. Final Feature Matrix after Standard Scaling (mean=0, variance=1):")
+    print(np.round(X_scaled, 4))
+
+def main():
+    run_preprocessing()
+
+if __name__ == "__main__":
+    main()

pylab/templates/q48/clean_dirtydata.py

@@ -0,0 +1,62 @@
+import os
+import sys
+
+def run_dirtydata_cleaning():
+    try:
+        import pandas as pd
+    except ImportError:
+        print("Error: pandas is required for Q48. Install with: pip install pandas")
+        return
+
+    csv_path = "dirtydata.csv"
+    if not os.path.exists(csv_path):
+        print(f"Error: {csv_path} not found.")
+        return
+
+    print("=== dirtydata.csv Cleaning and Standardization ===")
+    df = pd.read_csv(csv_path)
+    print(f"Original Dataset Shape: {df.shape}")
+    print("Original Records Sample:")
+    print(df.head(10).to_string(index=False))
+
+    initial_nulls = df.isnull().sum()
+    print("\nMissing Values Count per Column:")
+    print(initial_nulls.to_string())
+
+    initial_duplicates = df.duplicated().sum()
+    print(f"\nDuplicate Rows Detected: {initial_duplicates}")
+
+    clean_df = df.copy()
+
+    clean_df["Date"] = pd.to_datetime(clean_df["Date"], errors="coerce")
+    clean_df = clean_df.dropna(subset=["Date"])
+
+    calories_median = clean_df["Calories"].median()
+    clean_df["Calories"] = clean_df["Calories"].fillna(calories_median)
+    print(f"\nFilled missing Calories values with median: {calories_median:.1f}")
+
+    outlier_mask = clean_df["Duration"] > 120
+    outliers_count = outlier_mask.sum()
+    if outliers_count > 0:
+        clean_df.loc[outlier_mask, "Duration"] = 45
+        print(f"Corrected {outliers_count} Duration outlier values (> 120) to standard 45.")
+
+    duplicates_removed = clean_df.duplicated().sum()
+    clean_df = clean_df.drop_duplicates()
+    print(f"Removed {duplicates_removed} duplicate records.")
+
+    clean_df["Date"] = clean_df["Date"].dt.strftime("%Y-%m-%d")
+
+    print(f"\nFinal Cleaned Dataset Shape: {clean_df.shape}")
+    print("Sample Cleaned Records:")
+    print(clean_df.head(10).to_string(index=False))
+
+    out_file = "cleaned_dirtydata.csv"
+    clean_df.to_csv(out_file, index=False)
+    print(f"\nExported normalized dataset to: {out_file}")
+
+def main():
+    run_dirtydata_cleaning()
+
+if __name__ == "__main__":
+    main()

pylab/templates/q49/wine_regression.py

@@ -0,0 +1,169 @@
+import os
+import sys
+
+def run_wine_quality_pipeline():
+    try:
+        import pandas as pd
+        import numpy as np
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        import seaborn as sns
+        from sklearn.model_selection import train_test_split
+        from sklearn.preprocessing import StandardScaler
+        from sklearn.linear_model import LinearRegression
+        from sklearn.tree import DecisionTreeRegressor
+        from sklearn.ensemble import RandomForestRegressor
+        from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error
+    except ImportError:
+        print("Error: pandas, numpy, matplotlib, seaborn, and scikit-learn are required for Q49.")
+        print("Install with: pip install pandas numpy matplotlib seaborn scikit-learn")
+        return
+
+    red_csv = "winequality-red.csv"
+    white_csv = "winequality-white.csv"
+    if not os.path.exists(red_csv) or not os.path.exists(white_csv):
+        print(f"Error: Required datasets '{red_csv}' or '{white_csv}' are missing.")
+        return
+
+    print("=== Wine Quality 22-Step Regression Pipeline ===")
+    os.makedirs("results", exist_ok=True)
+
+    df_red = pd.read_csv(red_csv, sep=";")
+    df_white = pd.read_csv(white_csv, sep=";")
+
+    print(f"1. Red Wine Dataset Shape   : {df_red.shape}")
+    print(f"2. White Wine Dataset Shape : {df_white.shape}")
+    print("\nRed Wine Columns:")
+    print(list(df_red.columns))
+
+    df_red["wine_type"] = "red"
+    df_white["wine_type"] = "white"
+
+    feature_cols_red = [c for c in df_red.columns if c != "wine_type"]
+    feature_cols_white = [c for c in df_white.columns if c != "wine_type"]
+    if feature_cols_red != feature_cols_white:
+        raise ValueError("Column schemas do not match between red and white datasets.")
+    print("\nVerified column schemas match perfectly.")
+
+    df_combined = pd.concat([df_red, df_white], ignore_index=True)
+    integrated_file = os.path.join("results", "winequality_integrated.csv")
+    df_combined.to_csv(integrated_file, index=False)
+    print(f"Integrated dataset saved to: {integrated_file} (Shape: {df_combined.shape})")
+
+    missing_cnt = df_combined.isnull().sum().sum()
+    duplicate_cnt = df_combined.duplicated().sum()
+    print(f"Missing Values Count : {missing_cnt}")
+    print(f"Duplicate Rows Count : {duplicate_cnt}")
+
+    df_cleaned = df_combined.drop_duplicates().copy()
+    print(f"Shape after removing duplicates: {df_cleaned.shape}")
+
+    X = df_cleaned.drop("quality", axis=1)
+    y = df_cleaned["quality"].values
+
+    X["wine_type"] = X["wine_type"].map({"red": 0, "white": 1})
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.20, random_state=42
+    )
+    print(f"Train Set: {X_train.shape}, Test Set: {X_test.shape}")
+
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    df_cleaned["quality"].value_counts().sort_index().plot(kind="bar", color="#5c6bc0", ax=ax)
+    ax.set_title("Overall Wine Quality Rating Distribution", fontweight="bold")
+    ax.set_xlabel("Quality Score (3 - 9)")
+    ax.set_ylabel("Frequency")
+    ax.grid(axis="y", linestyle="--", alpha=0.5)
+    plt.tight_layout()
+    plot_overall_qual = os.path.join("results", "quality_distribution_overall.png")
+    plt.savefig(plot_overall_qual, dpi=150)
+    plt.close()
+
+    fig, ax = plt.subplots(figsize=(9, 5))
+    sns.countplot(data=df_cleaned, x="quality", hue="wine_type", palette=["#b71c1c", "#fff9c4"], edgecolor="black", ax=ax)
+    ax.set_title("Wine Quality Distribution by Wine Type", fontweight="bold")
+    ax.set_xlabel("Quality Score")
+    ax.set_ylabel("Count")
+    ax.legend(title="Type")
+    plt.tight_layout()
+    plot_qual_type = os.path.join("results", "quality_distribution_by_type.png")
+    plt.savefig(plot_qual_type, dpi=150)
+    plt.close()
+
+    avg_qual_by_type = df_cleaned.groupby("wine_type")["quality"].mean()
+    print("\nAverage Quality by Wine Type:")
+    for w_type, avg_q in avg_qual_by_type.items():
+        print(f"  {w_type.capitalize()} Wine Average Quality: {avg_q:.3f}")
+
+    numeric_cols = [c for c in df_cleaned.columns if c != "wine_type"]
+    corr_matrix = df_cleaned[numeric_cols].corr()
+
+    fig, ax = plt.subplots(figsize=(10, 8))
+    sns.heatmap(corr_matrix, annot=True, fmt=".2f", cmap="coolwarm", cbar=True, ax=ax)
+    ax.set_title("Physicochemical Features Correlation Heatmap", fontweight="bold")
+    plt.tight_layout()
+    plot_heatmap = os.path.join("results", "correlation_heatmap.png")
+    plt.savefig(plot_heatmap, dpi=150)
+    plt.close()
+
+    top_correlated = corr_matrix["quality"].abs().drop("quality").nlargest(3)
+    print("\nTop 3 Features Most Correlated with Quality:")
+    for feat, corr_val in top_correlated.items():
+        actual_corr = corr_matrix.loc[feat, "quality"]
+        print(f"  {feat:<22} : {actual_corr:+.3f} (Absolute: {corr_val:.3f})")
+
+    fig, ax = plt.subplots(figsize=(9, 5.5))
+    sns.boxplot(data=df_cleaned, x="quality", y="alcohol", hue="wine_type", palette=["#c62828", "#fbc02d"], ax=ax)
+    ax.set_title("Alcohol Content vs Wine Quality by Wine Type", fontweight="bold")
+    ax.set_xlabel("Quality Score")
+    ax.set_ylabel("Alcohol (% vol)")
+    ax.legend(title="Wine Type")
+    plt.tight_layout()
+    plot_alcohol = os.path.join("results", "alcohol_vs_quality_by_type.png")
+    plt.savefig(plot_alcohol, dpi=150)
+    plt.close()
+
+    models = {
+        "Linear Regression": LinearRegression(),
+        "Decision Tree Regressor": DecisionTreeRegressor(max_depth=6, random_state=42),
+        "Random Forest Regressor": RandomForestRegressor(n_estimators=100, max_depth=12, random_state=42),
+    }
+
+    metrics_records = []
+    print("\n=== Model Training and Evaluation Metrics ===")
+    print(f"{'Model Name':<26} | {'R²':<8} | {'MAE':<8} | {'MSE':<8} | {'RMSE':<8}")
+    print("-" * 66)
+
+    for name, model in models.items():
+        model.fit(X_train_scaled, y_train)
+        y_pred = model.predict(X_test_scaled)
+        
+        r2 = r2_score(y_test, y_pred)
+        mae = mean_absolute_error(y_test, y_pred)
+        mse = mean_squared_error(y_test, y_pred)
+        rmse = np.sqrt(mse)
+        
+        metrics_records.append({
+            "Model": name,
+            "R2": round(r2, 4),
+            "MAE": round(mae, 4),
+            "MSE": round(mse, 4),
+            "RMSE": round(rmse, 4),
+        })
+        print(f"{name:<26} | {r2:<8.4f} | {mae:<8.4f} | {mse:<8.4f} | {rmse:<8.4f}")
+
+    metrics_df = pd.DataFrame(metrics_records)
+    metrics_csv = os.path.join("results", "model_evaluation_metrics.csv")
+    metrics_df.to_csv(metrics_csv, index=False)
+    print(f"\nEvaluation summary exported to: {metrics_csv}")
+
+def main():
+    run_wine_quality_pipeline()
+
+if __name__ == "__main__":
+    main()

pylab/templates/q5/phonebook.py

@@ -0,0 +1,105 @@
+import sys
+
+class Phonebook:
+    def __init__(self):
+        self.contacts = {}
+
+    def add_contact(self, name, phone):
+        name_key = name.strip()
+        if not name_key:
+            return False, "Contact name cannot be blank."
+        if name_key in self.contacts:
+            return False, f"Contact '{name_key}' already exists. Use update."
+        self.contacts[name_key] = phone.strip()
+        return True, f"Contact '{name_key}' added successfully."
+
+    def update_contact(self, name, new_phone):
+        name_key = name.strip()
+        if name_key not in self.contacts:
+            return False, f"Contact '{name_key}' was not found."
+        self.contacts[name_key] = new_phone.strip()
+        return True, f"Contact '{name_key}' phone number updated."
+
+    def search_contact(self, name):
+        name_key = name.strip()
+        if name_key in self.contacts:
+            return True, self.contacts[name_key]
+        return False, f"Contact '{name_key}' not found."
+
+    def delete_contact(self, name):
+        name_key = name.strip()
+        if name_key in self.contacts:
+            del self.contacts[name_key]
+            return True, f"Contact '{name_key}' deleted."
+        return False, f"Contact '{name_key}' does not exist."
+
+    def display_all(self):
+        return dict(sorted(self.contacts.items()))
+
+def main():
+    print("=== Dictionary-Based Phonebook Manager ===")
+    book = Phonebook()
+    book.add_contact("Alice Smith", "9876543210")
+    book.add_contact("Bob Jones", "9123456780")
+    book.add_contact("Charlie Brown", "9988776655")
+    
+    if len(sys.argv) > 1 and sys.argv[1] == "--demo":
+        print("Initial Contacts:")
+        for name, phone in book.display_all().items():
+            print(f"  {name:<16} : {phone}")
+        print("\nUpdating Bob Jones...")
+        book.update_contact("Bob Jones", "9000000000")
+        print("Searching Alice Smith:", book.search_contact("Alice Smith"))
+        print("Deleting Charlie Brown:", book.delete_contact("Charlie Brown"))
+        print("\nFinal Contacts:")
+        for name, phone in book.display_all().items():
+            print(f"  {name:<16} : {phone}")
+        return
+
+    while True:
+        print("\nPhonebook Menu:")
+        print("1. Add Contact")
+        print("2. Update Contact")
+        print("3. Search Contact")
+        print("4. Delete Contact")
+        print("5. View All Contacts")
+        print("6. Exit")
+        
+        choice = input("\nEnter choice (1-6): ").strip()
+        if choice == "1":
+            name = input("Enter contact name: ")
+            phone = input("Enter phone number: ")
+            _, msg = book.add_contact(name, phone)
+            print(msg)
+        elif choice == "2":
+            name = input("Enter contact name to update: ")
+            phone = input("Enter new phone number: ")
+            _, msg = book.update_contact(name, phone)
+            print(msg)
+        elif choice == "3":
+            name = input("Enter contact name to search: ")
+            found, result = book.search_contact(name)
+            if found:
+                print(f"Phone Number: {result}")
+            else:
+                print(result)
+        elif choice == "4":
+            name = input("Enter contact name to delete: ")
+            _, msg = book.delete_contact(name)
+            print(msg)
+        elif choice == "5":
+            all_c = book.display_all()
+            if not all_c:
+                print("Phonebook is currently empty.")
+            else:
+                print("\n--- Contact List ---")
+                for n, p in all_c.items():
+                    print(f"  {n:<20} : {p}")
+        elif choice == "6":
+            print("Exiting Phonebook application.")
+            break
+        else:
+            print("Invalid selection.")
+
+if __name__ == "__main__":
+    main()

pylab/templates/q50/breast_cancer_classifier.py

@@ -0,0 +1,147 @@
+import os
+import sys
+
+def run_breast_cancer_classification():
+    try:
+        import pandas as pd
+        import numpy as np
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        import seaborn as sns
+        from sklearn.model_selection import train_test_split
+        from sklearn.preprocessing import StandardScaler
+        from sklearn.tree import DecisionTreeClassifier
+        from sklearn.ensemble import RandomForestClassifier
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.metrics import accuracy_score, recall_score, confusion_matrix, classification_report
+    except ImportError:
+        print("Error: pandas, numpy, matplotlib, seaborn, and scikit-learn are required for Q50.")
+        print("Install with: pip install pandas numpy matplotlib seaborn scikit-learn")
+        return
+
+    csv_path = "breast-cancer.csv"
+    if not os.path.exists(csv_path):
+        print(f"Error: {csv_path} not found.")
+        return
+
+    print("=== Breast Cancer Diagnosis Classification Pipeline ===")
+    os.makedirs("results", exist_ok=True)
+
+    df = pd.read_csv(csv_path)
+    print(f"1. Dataset Shape: {df.shape}")
+    print(f"Target Column: 'diagnosis' | Identifier: 'id'")
+
+    if "id" in df.columns:
+        df = df.drop("id", axis=1)
+
+    print("\n2. Class Distribution (M = Malignant, B = Benign):")
+    class_counts = df["diagnosis"].value_counts()
+    for diag, cnt in class_counts.items():
+        pct = (cnt / len(df)) * 100
+        print(f"  {diag} ({'Malignant' if diag == 'M' else 'Benign'}): {cnt} ({pct:.1f}%)")
+
+    y = df["diagnosis"].map({"B": 0, "M": 1}).values
+    feature_names = [c for c in df.columns if c != "diagnosis"]
+    X = df[feature_names].values
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.20, random_state=42, stratify=y
+    )
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    rf_selector = RandomForestClassifier(n_estimators=100, random_state=42)
+    rf_selector.fit(X_train_scaled, y_train)
+    importances = rf_selector.feature_importances_
+    
+    ranking_indices = np.argsort(importances)[::-1]
+    top_k = 5
+    top_indices = ranking_indices[:top_k]
+    top_feature_names = [feature_names[i] for i in top_indices]
+
+    print(f"\n3. Top {top_k} Features Ranked by Random Forest:")
+    for rank, idx in enumerate(top_indices, start=1):
+        print(f"  {rank}. {feature_names[idx]:<28} (Importance: {importances[idx]:.4f})")
+
+    fig, ax = plt.subplots(figsize=(10, 5))
+    top_10_indices = ranking_indices[:10]
+    ax.barh([feature_names[i] for i in reversed(top_10_indices)], importances[top_10_indices][::-1], color="#0288d1")
+    ax.set_title("Top 10 Random Forest Feature Importances", fontweight="bold")
+    ax.set_xlabel("Relative Importance")
+    plt.tight_layout()
+    plot_rf_feat = os.path.join("results", "feature_importances.png")
+    plt.savefig(plot_rf_feat, dpi=150)
+    plt.close()
+
+    classifiers = {
+        "Decision Tree": DecisionTreeClassifier(max_depth=4, random_state=42),
+        "Random Forest": RandomForestClassifier(n_estimators=100, random_state=42),
+        "Logistic Regression": LogisticRegression(max_iter=500, random_state=42),
+    }
+
+    print("\n4. Model Comparison (All Features vs Top Reduced Features):")
+    print(f"{'Model':<22} | {'Features':<10} | {'Accuracy':<10} | {'Recall':<8} | {'False Negatives':<16}")
+    print("-" * 76)
+
+    X_train_top = X_train_scaled[:, top_indices]
+    X_test_top = X_test_scaled[:, top_indices]
+
+    comparison_records = []
+
+    for name, clf in classifiers.items():
+        clf.fit(X_train_scaled, y_train)
+        preds_all = clf.predict(X_test_scaled)
+        acc_all = accuracy_score(y_test, preds_all)
+        rec_all = recall_score(y_test, preds_all)
+        cm_all = confusion_matrix(y_test, preds_all)
+        fn_all = cm_all[1, 0]
+
+        print(f"{name:<22} | All ({len(feature_names)})   | {acc_all:<10.4f} | {rec_all:<8.4f} | {fn_all:<16}")
+        comparison_records.append({"Model": name, "Feature_Set": "All", "Accuracy": acc_all, "Recall": rec_all, "False_Negatives": fn_all})
+
+        clf.fit(X_train_top, y_train)
+        preds_top = clf.predict(X_test_top)
+        acc_top = accuracy_score(y_test, preds_top)
+        rec_top = recall_score(y_test, preds_top)
+        cm_top = confusion_matrix(y_test, preds_top)
+        fn_top = cm_top[1, 0]
+
+        print(f"{name:<22} | Top ({top_k})     | {acc_top:<10.4f} | {rec_top:<8.4f} | {fn_top:<16}")
+        comparison_records.append({"Model": name, "Feature_Set": f"Top_{top_k}", "Accuracy": acc_top, "Recall": rec_top, "False_Negatives": fn_top})
+
+    comp_df = pd.DataFrame(comparison_records)
+    comp_df.to_csv(os.path.join("results", "classification_comparison.csv"), index=False)
+
+    best_clf = RandomForestClassifier(n_estimators=100, random_state=42)
+    best_clf.fit(X_train_scaled, y_train)
+    best_preds = best_clf.predict(X_test_scaled)
+    final_cm = confusion_matrix(y_test, best_preds)
+
+    fig, ax = plt.subplots(figsize=(6, 5))
+    sns.heatmap(final_cm, annot=True, fmt="d", cmap="Blues", xticklabels=["Benign", "Malignant"], yticklabels=["Benign", "Malignant"], ax=ax)
+    ax.set_title("Confusion Matrix (Random Forest)", fontweight="bold")
+    ax.set_xlabel("Predicted Diagnosis")
+    ax.set_ylabel("True Diagnosis")
+    plt.tight_layout()
+    plot_cm = os.path.join("results", "confusion_matrix.png")
+    plt.savefig(plot_cm, dpi=150)
+    plt.close()
+
+    print(f"\nConfusion Matrix saved to: {plot_cm}")
+    print(f"False Negatives (Critical in oncology screening): {final_cm[1, 0]} cases")
+
+    print("\n5. Predictions on Unseen Sample Biopsies:")
+    sample_tests = X_test[:3]
+    sample_scaled = scaler.transform(sample_tests)
+    sample_preds = best_clf.predict(sample_scaled)
+    for i, pred in enumerate(sample_preds, start=1):
+        status = "Malignant (M)" if pred == 1 else "Benign (B)"
+        print(f"  Sample #{i} Predicted Diagnosis: {status}")
+
+def main():
+    run_breast_cancer_classification()
+
+if __name__ == "__main__":
+    main()

pylab/templates/q51/iris_clustering.py

@@ -0,0 +1,95 @@
+import os
+import sys
+
+def run_iris_clustering():
+    try:
+        import pandas as pd
+        import numpy as np
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        from sklearn.preprocessing import StandardScaler
+        from sklearn.cluster import KMeans
+        from sklearn.decomposition import PCA
+        from sklearn.metrics import silhouette_score
+    except ImportError:
+        print("Error: pandas, numpy, matplotlib, and scikit-learn are required for Q51.")
+        print("Install with: pip install pandas numpy matplotlib scikit-learn")
+        return
+
+    csv_path = "iris.csv"
+    if not os.path.exists(csv_path):
+        print(f"Error: {csv_path} not found.")
+        return
+
+    print("=== Iris Unsupervised K-Means and PCA Clustering ===")
+    os.makedirs("results", exist_ok=True)
+
+    df = pd.read_csv(csv_path)
+    feature_columns = ["sepal_length", "sepal_width", "petal_length", "petal_width"]
+    X_features = df[feature_columns].values
+
+    print(f"Dataset Loaded: {len(df)} samples, Features: {feature_columns}")
+    print("Note: True class labels are withheld to perform true unsupervised clustering.")
+
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X_features)
+
+    inertias = []
+    k_range = range(1, 11)
+    for k in k_range:
+        km = KMeans(n_clusters=k, random_state=42, n_init=10)
+        km.fit(X_scaled)
+        inertias.append(km.inertia_)
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    ax.plot(k_range, inertias, marker="o", color="#d81b60", linewidth=2)
+    ax.set_title("Elbow Method for Optimal Clusters (k)", fontweight="bold")
+    ax.set_xlabel("Number of Clusters (k)")
+    ax.set_ylabel("Inertia (Within-Cluster Sum of Squares)")
+    ax.grid(True, linestyle="--", alpha=0.5)
+    plt.tight_layout()
+    elbow_plot = os.path.join("results", "elbow_method.png")
+    plt.savefig(elbow_plot, dpi=150)
+    plt.close()
+    print(f"\n1. Elbow curve plot saved to: {elbow_plot}")
+
+    pca = PCA(n_components=2)
+    X_pca = pca.fit_transform(X_scaled)
+    var_exp = pca.explained_variance_ratio_
+    print(f"\n2. PCA 2D Projection: Explained Variance = {var_exp[0]*100:.1f}% + {var_exp[1]*100:.1f}% = {sum(var_exp)*100:.1f}%")
+
+    print("\n3. K-Means Evaluation for k = 2, 3, and 4:")
+    fig, axes = plt.subplots(1, 3, figsize=(16, 5))
+    test_k_values = [2, 3, 4]
+
+    for idx, k in enumerate(test_k_values):
+        km = KMeans(n_clusters=k, random_state=42, n_init=10)
+        cluster_labels = km.fit_predict(X_scaled)
+        sil_score = silhouette_score(X_scaled, cluster_labels)
+        print(f"  k = {k} -> Inertia: {km.inertia_:.2f} | Silhouette Score: {sil_score:.4f}")
+
+        ax = axes[idx]
+        scatter = ax.scatter(X_pca[:, 0], X_pca[:, 1], c=cluster_labels, cmap="viridis", alpha=0.85, edgecolors="k")
+        ax.set_title(f"K-Means (k={k})\nSilhouette: {sil_score:.3f}", fontweight="bold")
+        ax.set_xlabel("PCA Component 1")
+        ax.set_ylabel("PCA Component 2")
+        ax.grid(True, linestyle="--", alpha=0.5)
+
+    plt.tight_layout()
+    clusters_plot = os.path.join("results", "kmeans_pca_clusters.png")
+    plt.savefig(clusters_plot, dpi=150)
+    plt.close()
+    print(f"\nCluster visualization grid saved to: {clusters_plot}")
+
+    final_kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
+    df["Cluster_Assignment"] = final_kmeans.fit_predict(X_scaled)
+    clustered_file = os.path.join("results", "iris_clustered_output.csv")
+    df.to_csv(clustered_file, index=False)
+    print(f"Clustered records saved to: {clustered_file}")
+
+def main():
+    run_iris_clustering()
+
+if __name__ == "__main__":
+    main()