chokkhu 0.2.0__tar.gz

chokkhu-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tamim Hossain 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chokkhu-0.2.0/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: chokkhu
+Version: 0.2.0
+Summary: A small python image classification package
+Home-page: https://github.com/tamimystic/Chokkhu-PyPi-Package
+Author: tamimystic
+Author-email: hossainsmtamim@gamil.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/tamimystic/Chokkhu-PyPi-Package/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tensorflow>=2.12
+Requires-Dist: numpy>=1.23
+Requires-Dist: Pillow>=9.0
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: seaborn>=0.12
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: tqdm>=4.65.0
+Provides-Extra: testing
+Requires-Dist: pytest<9.0,>=7.2; extra == "testing"
+Requires-Dist: tox<5.0,>=3.28; extra == "testing"
+Requires-Dist: flake8<8.0,>=6.1; extra == "testing"
+Requires-Dist: mypy<2.0,>=1.5; extra == "testing"
+Provides-Extra: dev
+Requires-Dist: black<25.0,>=23.3; extra == "dev"
+Requires-Dist: isort<7.0,>=5.12; extra == "dev"
+Requires-Dist: build<2.0,>=1.0; extra == "dev"
+Requires-Dist: twine<6.0,>=4.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: summary
+
+# Chokkhu
+
+Chokkhu is a deep learning image dataset EDA and preprocessing toolkit designed to
+prepare train-ready image data for TensorFlow / Keras–based image classification.
+It helps users analyze datasets, preprocess images, handle class imbalance, and
+train deep learning models using a clean and reproducible pipeline. The package
+follows industry-grade Python packaging standards, supports CI/CD pipelines, and
+works seamlessly in Google Colab and Jupyter Notebook environments.
+
+INSTALLATION (IMPORTANT – FIRST STEP)
+
+>>> pip install Chokkhu <<<
+
+TensorFlow is installed automatically as a runtime dependency.
+
+Chokkhu’s main responsibility is data preparation. It performs image exploratory
+data analysis (EDA), class-wise distribution visualization, image size, aspect
+ratio, RGB intensity and blur analysis, standard preprocessing (resize to 224×224
+and normalization), stratified train/validation/test splitting, and automatic
+class balancing using data augmentation. After this step, the dataset is fully
+ready to be used for training any deep learning model.
+
+Complete usage example showing the full workflow in one place:
+
+```python
+
+from Chokkhu import ImageEDA, ImagePreProcessor
+
+
+# Dataset EDA
+eda = ImageEDA(dataset_path="your_dataset_path")
+
+# Dataset preprocessing
+processor = ImagePreProcessor(datapath="your_dataset_path")
+(train_X, train_y), (val_X, val_y), (test_X, test_y) = processor.get_data()
+
+
+
+
+After excecuting this, You can train your model like this.
+
+
+
+
+
+
+
+import tensorflow as tf
+# Example 1: Custom CNN (from scratch)
+custom_model = tf.keras.Sequential([
+    tf.keras.layers.Conv2D(32, 3, activation="relu", input_shape=(224,224,3)),
+    tf.keras.layers.MaxPooling2D(),
+    tf.keras.layers.Conv2D(64, 3, activation="relu"),
+    tf.keras.layers.MaxPooling2D(),
+    tf.keras.layers.Flatten(),
+    tf.keras.layers.Dense(128, activation="relu"),
+    tf.keras.layers.Dense(num_classes, activation="softmax")
+])
+
+custom_model.compile(
+    optimizer="adam",
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"]
+)
+
+custom_model.fit(
+    train_X,
+    train_y,
+    validation_data=(val_X, val_y),
+    epochs=10
+)
+
+
+
+
+# Example 2: Transfer Learning with ConvNeXt-Tiny (frozen backbone)
+import tensorflow as tf
+base_model = tf.keras.applications.ConvNeXtTiny(
+    weights="imagenet",
+    include_top=False,
+    input_shape=(224,224,3)
+)
+
+base_model.trainable = False
+
+transfer_model = tf.keras.Sequential([
+    base_model,
+    tf.keras.layers.GlobalAveragePooling2D(),
+    tf.keras.layers.Dense(256, activation="relu"),
+    tf.keras.layers.Dense(num_classes, activation="softmax")
+])
+
+transfer_model.compile(
+    optimizer="adam",
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"]
+)
+
+transfer_model.fit(
+    train_X,
+    train_y,
+    validation_data=(val_X, val_y),
+    epochs=5
+)
+
+
+
+
+# Example 3: Fine-tuning ConvNeXt-Tiny (unfrozen backbone)
+import tensorflow as tf
+base_model.trainable = True
+
+transfer_model.compile(
+    optimizer=tf.keras.optimizers.Adam(1e-5),
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"]
+)
+
+transfer_model.fit(
+    train_X,
+    train_y,
+    validation_data=(val_X, val_y),
+    epochs=5
+)

chokkhu-0.2.0/README.md

@@ -0,0 +1,124 @@
+# Chokkhu
+
+Chokkhu is a deep learning image dataset EDA and preprocessing toolkit designed to
+prepare train-ready image data for TensorFlow / Keras–based image classification.
+It helps users analyze datasets, preprocess images, handle class imbalance, and
+train deep learning models using a clean and reproducible pipeline. The package
+follows industry-grade Python packaging standards, supports CI/CD pipelines, and
+works seamlessly in Google Colab and Jupyter Notebook environments.
+
+INSTALLATION (IMPORTANT – FIRST STEP)
+
+>>> pip install Chokkhu <<<
+
+TensorFlow is installed automatically as a runtime dependency.
+
+Chokkhu’s main responsibility is data preparation. It performs image exploratory
+data analysis (EDA), class-wise distribution visualization, image size, aspect
+ratio, RGB intensity and blur analysis, standard preprocessing (resize to 224×224
+and normalization), stratified train/validation/test splitting, and automatic
+class balancing using data augmentation. After this step, the dataset is fully
+ready to be used for training any deep learning model.
+
+Complete usage example showing the full workflow in one place:
+
+```python
+
+from Chokkhu import ImageEDA, ImagePreProcessor
+
+
+# Dataset EDA
+eda = ImageEDA(dataset_path="your_dataset_path")
+
+# Dataset preprocessing
+processor = ImagePreProcessor(datapath="your_dataset_path")
+(train_X, train_y), (val_X, val_y), (test_X, test_y) = processor.get_data()
+
+
+
+
+After excecuting this, You can train your model like this.
+
+
+
+
+
+
+
+import tensorflow as tf
+# Example 1: Custom CNN (from scratch)
+custom_model = tf.keras.Sequential([
+    tf.keras.layers.Conv2D(32, 3, activation="relu", input_shape=(224,224,3)),
+    tf.keras.layers.MaxPooling2D(),
+    tf.keras.layers.Conv2D(64, 3, activation="relu"),
+    tf.keras.layers.MaxPooling2D(),
+    tf.keras.layers.Flatten(),
+    tf.keras.layers.Dense(128, activation="relu"),
+    tf.keras.layers.Dense(num_classes, activation="softmax")
+])
+
+custom_model.compile(
+    optimizer="adam",
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"]
+)
+
+custom_model.fit(
+    train_X,
+    train_y,
+    validation_data=(val_X, val_y),
+    epochs=10
+)
+
+
+
+
+# Example 2: Transfer Learning with ConvNeXt-Tiny (frozen backbone)
+import tensorflow as tf
+base_model = tf.keras.applications.ConvNeXtTiny(
+    weights="imagenet",
+    include_top=False,
+    input_shape=(224,224,3)
+)
+
+base_model.trainable = False
+
+transfer_model = tf.keras.Sequential([
+    base_model,
+    tf.keras.layers.GlobalAveragePooling2D(),
+    tf.keras.layers.Dense(256, activation="relu"),
+    tf.keras.layers.Dense(num_classes, activation="softmax")
+])
+
+transfer_model.compile(
+    optimizer="adam",
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"]
+)
+
+transfer_model.fit(
+    train_X,
+    train_y,
+    validation_data=(val_X, val_y),
+    epochs=5
+)
+
+
+
+
+# Example 3: Fine-tuning ConvNeXt-Tiny (unfrozen backbone)
+import tensorflow as tf
+base_model.trainable = True
+
+transfer_model.compile(
+    optimizer=tf.keras.optimizers.Adam(1e-5),
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"]
+)
+
+transfer_model.fit(
+    train_X,
+    train_y,
+    validation_data=(val_X, val_y),
+    epochs=5
+)

chokkhu-0.2.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=42.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra -q"
+
+
+[tool.mypy]
+mypy_path = "src"
+ignore_missing_imports = true
+strict_optional = false
+disallow_untyped_defs = false
+check_untyped_defs = true
+
+
+[tool.isort]
+profile = "black"
+line_length = 88
+known_first_party = ["Chokkhu"]
+src_paths = ["src"]
+
+
+[tool.black]
+line-length = 88
+target-version = ["py38", "py39", "py310", "py311"]

chokkhu-0.2.0/setup.cfg

@@ -0,0 +1,65 @@
+[metadata]
+license = MIT
+license_file = LICENSE
+url = https://github.com/tamimystic/Chokkhu-PyPi-Package
+project_urls = 
+	Bug Tracker = https://github.com/tamimystic/Chokkhu-PyPi-Package/issues
+	Source Code = https://github.com/tamimystic/Chokkhu-PyPi-Package
+classifiers = 
+	Development Status :: 2 - Pre-Alpha
+	Intended Audience :: Developers
+	Intended Audience :: Science/Research
+	License :: OSI Approved :: MIT License
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Operating System :: OS Independent
+	Topic :: Scientific/Engineering :: Artificial Intelligence
+
+[options]
+package_dir = 
+	= src
+packages = find:
+python_requires = >=3.8
+install_requires = 
+	tensorflow>=2.12
+	numpy>=1.23
+	Pillow>=9.0
+	matplotlib>=3.7
+	seaborn>=0.12
+	scikit-learn>=1.2
+	pandas>=2.0.0
+	opencv-python>=4.8.0
+	tqdm>=4.65.0
+
+[options.packages.find]
+where = src
+
+[options.extras_require]
+testing = 
+	pytest>=7.2,<9.0
+	tox>=3.28,<5.0
+	flake8>=6.1,<8.0
+	mypy>=1.5,<2.0
+dev = 
+	black>=23.3,<25.0
+	isort>=5.12,<7.0
+	build>=1.0,<2.0
+	twine>=4.0,<6.0
+
+[options.package_data]
+chokkhu = py.typed
+
+[flake8]
+max-line-length = 160
+exclude = 
+	__init__.py
+	build
+	dist
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

chokkhu-0.2.0/setup.py

@@ -0,0 +1,27 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description=f.read()
+
+__version__="0.2.0"
+
+REPO_NAME="Chokkhu-PyPi-Package"
+AUTHOR_USER_NAME="tamimystic"
+AUTHOR_EMAIL="hossainsmtamim@gamil.com"
+SRC_REPO="chokkhu"
+
+setuptools.setup(
+    name=SRC_REPO,
+    version=__version__,
+    author=AUTHOR_USER_NAME,
+    author_email=AUTHOR_EMAIL,
+    description="A small python image classification package",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url=f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}",
+    project_urls={
+        "Bug Tracker": f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}/issues",
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src")
+)

chokkhu-0.2.0/src/chokkhu/__init__.py

@@ -0,0 +1,22 @@
+from .eda.image import ImageEDA
+from .eda.tabular import TabularEDA
+from .preprocessing.image import ImagePreProcessor
+
+class EDAWrapper:
+    @staticmethod
+    def image(dataset_path: str, save_reports: bool = True, save_dir: str = "chokkhu_outputs/EDA_Reports") -> ImageEDA:
+        """
+        Runs the full Exploratory Data Analysis on the image dataset.
+        """
+        return ImageEDA(dataset_path=dataset_path, save_reports=save_reports, save_dir=save_dir)
+
+    @staticmethod
+    def tabular(dataset_path: str, save_reports: bool = True, save_dir: str = "chokkhu_outputs/EDA_Reports") -> TabularEDA:
+        """
+        Runs the full Exploratory Data Analysis on the tabular dataset.
+        """
+        return TabularEDA(dataset_path=dataset_path, save_reports=save_reports, save_dir=save_dir)
+
+eda = EDAWrapper()
+
+__all__ = ["ImageEDA", "TabularEDA", "ImagePreProcessor", "eda"]

chokkhu-0.2.0/src/chokkhu/eda/__init__.py

@@ -0,0 +1,4 @@
+from .image import ImageEDA
+from .tabular import TabularEDA
+
+__all__ = ["ImageEDA", "TabularEDA"]

chokkhu-0.2.0/src/chokkhu/eda/image.py

@@ -0,0 +1,213 @@
+import os
+import warnings
+from typing import Any, Dict, List
+
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from PIL import Image
+from tqdm import tqdm
+from sklearn.decomposition import PCA
+
+from .visualizer import PlotVisualizer
+
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+class ImageEDA:
+    def __init__(
+        self,
+        dataset_path: str,
+        save_reports: bool = True,
+        save_dir: str = "chokkhu_outputs/EDA_Reports",
+    ):
+        """
+        Initializes the Ultra Pro Max ImageEDA class and triggers the analysis pipeline.
+        """
+        self.dataset_path: str = dataset_path
+        self.save_reports: bool = save_reports
+        self.save_dir: str = save_dir
+        self.results: Dict[str, Any] = {}
+        self.class_paths: List[str] = []
+
+        if self.save_reports:
+            os.makedirs(self.save_dir, exist_ok=True)
+
+        PlotVisualizer.setup_theme()
+        self._perform_eda()
+
+    def _perform_eda(self) -> None:
+        print(f"--- Executing Ultra Pro Max EDA for: {self.dataset_path} ---")
+        self._collect_paths()
+        if not self.class_paths:
+            print("Error: No valid images found in the specified path.")
+            return
+        self.results = self._analyze_data()
+        self._visual_reports()
+
+    def _collect_paths(self) -> None:
+        for root, _, files in os.walk(self.dataset_path):
+            if any(f.lower().endswith((".png", ".jpg", ".jpeg")) for f in files):
+                self.class_paths.append(root)
+
+    def _analyze_data(self) -> Dict[str, Any]:
+        exts = (".png", ".jpg", ".jpeg")
+        metrics_list = []
+        total_rgb_hist = np.zeros((256, 3))
+        processed_count = 0
+        pca_samples = []
+        pca_labels = []
+        
+        # Max samples for PCA per class to avoid memory overload
+        MAX_PCA_SAMPLES = 200 
+        
+        for path in self.class_paths:
+            class_name = os.path.basename(path)
+            files = [f for f in os.listdir(path) if f.lower().endswith(exts)]
+            
+            pca_sampled = 0
+            for img_name in tqdm(files, desc=f"Processing {class_name}"):
+                img_path = os.path.join(path, img_name)
+                img_bgr = cv2.imread(img_path)
+                if img_bgr is None:
+                    continue
+
+                img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+                gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+                
+                h, w, _ = img_rgb.shape
+                
+                # Metrics Extraction
+                brightness = gray.mean()
+                contrast = gray.std()
+                blur = cv2.Laplacian(gray, cv2.CV_64F).var()
+                edges = cv2.Canny(gray, 100, 200).mean()
+                
+                metrics_list.append({
+                    "Class": class_name,
+                    "Image": img_name,
+                    "Width": w,
+                    "Height": h,
+                    "Aspect_Ratio": w / h if h > 0 else 0,
+                    "Brightness": brightness,
+                    "Contrast": contrast,
+                    "Blur_Score": blur,
+                    "Edge_Intensity": edges
+                })
+
+                # RGB Distribution
+                for i in range(3):
+                    hist = cv2.calcHist([img_rgb], [i], None, [256], [0, 256])
+                    total_rgb_hist[:, i] += hist.flatten()  # type: ignore
+                
+                # Sampling for PCA (Downscale to 32x32 for memory efficiency)
+                if pca_sampled < MAX_PCA_SAMPLES:
+                    resized_for_pca = cv2.resize(gray, (32, 32)).flatten()
+                    pca_samples.append(resized_for_pca)
+                    pca_labels.append(class_name)
+                    pca_sampled += 1
+
+                processed_count += 1
+
+        df_metrics = pd.DataFrame(metrics_list)
+        avg_hist = total_rgb_hist / processed_count if processed_count > 0 else total_rgb_hist
+        
+        # PCA Computation
+        df_pca = None
+        if pca_samples:
+            pca = PCA(n_components=2)
+            pca_result = pca.fit_transform(np.array(pca_samples))
+            df_pca = pd.DataFrame({
+                "PCA1": pca_result[:, 0],
+                "PCA2": pca_result[:, 1],
+                "Class": pca_labels
+            })
+
+        return {
+            "df_metrics": df_metrics,
+            "avg_rgb_hist": avg_hist,
+            "df_pca": df_pca,
+            "total_classes": len(self.class_paths),
+            "total_images": processed_count,
+        }
+
+    def _visual_reports(self) -> None:
+        df = self.results["df_metrics"]
+        
+        # 1. Class Distribution
+        fig, ax = plt.subplots(figsize=(10, 5))
+        class_counts = df["Class"].value_counts().reset_index()
+        class_counts.columns = ["Class", "Count"]
+        sns.barplot(data=class_counts, x="Class", y="Count", palette="viridis", ax=ax)
+        for p in ax.patches:
+            ax.annotate(f"{int(p.get_height())}", (p.get_x() + p.get_width() / 2., p.get_height()), ha='center', va='center', xytext=(0, 8), textcoords='offset points')
+        ax.set_title("Class-wise Image Distribution")
+        ax.tick_params(axis='x', rotation=45)
+        PlotVisualizer.save_and_show(fig, "1_class_distribution.png", self.save_dir, self.save_reports)
+
+        # 2. Dimensions & Aspect Ratio
+        fig, axes = plt.subplots(1, 3, figsize=(18, 5))
+        sns.histplot(data=df, x="Width", hue="Class", kde=False, element="step", ax=axes[0], palette="Set2")
+        axes[0].set_title("Width Distribution by Class")
+        sns.histplot(data=df, x="Height", hue="Class", kde=False, element="step", ax=axes[1], palette="Set2")
+        axes[1].set_title("Height Distribution by Class")
+        sns.boxplot(data=df, x="Class", y="Aspect_Ratio", ax=axes[2], palette="Set2")
+        axes[2].set_title("Aspect Ratio by Class")
+        axes[2].tick_params(axis='x', rotation=45)
+        PlotVisualizer.save_and_show(fig, "2_dimension_analysis.png", self.save_dir, self.save_reports)
+
+        # 3. Quality Metrics (Brightness, Contrast, Blur, Edges)
+        fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+        sns.violinplot(data=df, x="Class", y="Brightness", palette="coolwarm", ax=axes[0, 0])
+        axes[0, 0].set_title("Brightness Distribution")
+        axes[0, 0].tick_params(axis='x', rotation=45)
+        
+        sns.violinplot(data=df, x="Class", y="Contrast", palette="coolwarm", ax=axes[0, 1])
+        axes[0, 1].set_title("Contrast Distribution")
+        axes[0, 1].tick_params(axis='x', rotation=45)
+
+        sns.boxplot(data=df, x="Class", y="Blur_Score", palette="crest", ax=axes[1, 0])
+        axes[1, 0].set_title("Blur Score (Laplacian Variance)")
+        axes[1, 0].set_yscale('log')
+        axes[1, 0].tick_params(axis='x', rotation=45)
+
+        sns.boxplot(data=df, x="Class", y="Edge_Intensity", palette="crest", ax=axes[1, 1])
+        axes[1, 1].set_title("Edge Intensity (Canny)")
+        axes[1, 1].tick_params(axis='x', rotation=45)
+        PlotVisualizer.save_and_show(fig, "3_quality_metrics.png", self.save_dir, self.save_reports)
+
+        # 4. RGB Intensity Distribution
+        fig, ax = plt.subplots(figsize=(10, 6))
+        for i, col in enumerate(["red", "green", "blue"]):
+            ax.plot(self.results["avg_rgb_hist"][:, i], color=col, label=f"{col.upper()} Channel", linewidth=2)
+            ax.fill_between(range(256), self.results["avg_rgb_hist"][:, i], color=col, alpha=0.15)
+        ax.set_title("Global Average RGB Intensity Distribution")
+        ax.legend()
+        PlotVisualizer.save_and_show(fig, "4_rgb_intensity.png", self.save_dir, self.save_reports)
+
+        # 5. PCA Feature Space
+        df_pca = self.results.get("df_pca")
+        if df_pca is not None:
+            fig, ax = plt.subplots(figsize=(10, 8))
+            sns.scatterplot(data=df_pca, x="PCA1", y="PCA2", hue="Class", palette="tab10", alpha=0.7, ax=ax)
+            ax.set_title("PCA Feature Space (2D) - Are classes separable?")
+            PlotVisualizer.save_and_show(fig, "5_pca_feature_space.png", self.save_dir, self.save_reports)
+
+        # 6. Sample Grid
+        fig = plt.figure(figsize=(15, 10))
+        for i, path in enumerate(self.class_paths[:9]):
+            files = [f for f in os.listdir(path) if f.lower().endswith((".png", ".jpg", ".jpeg"))]
+            if files:
+                img = Image.open(os.path.join(path, files[0]))
+                ax = fig.add_subplot(3, 3, i + 1)
+                ax.imshow(img)
+                ax.set_title(os.path.basename(path))
+                ax.axis("off")
+        fig.suptitle("Sample Images per Class", fontsize=20)
+        PlotVisualizer.save_and_show(fig, "6_sample_grid.png", self.save_dir, self.save_reports)
+
+        # Save CSV Metrics
+        if self.save_reports:
+            df.to_csv(os.path.join(self.save_dir, "detailed_image_metrics.csv"), index=False)
+            print(f"\n[INFO] All reports and visualizations have been saved in: {self.save_dir}")