alchemydetect 0.1.0__tar.gz

alchemydetect-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kouya-marino
+
+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.

alchemydetect-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: alchemydetect
+Version: 0.1.0
+Summary: Desktop GUI application for training and running inference with Detectron2 models
+Author-email: Prashant Rawat <prashantrawatmailbox@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/kouya-marino/AlchemyDetect
+Project-URL: Repository, https://github.com/kouya-marino/AlchemyDetect
+Project-URL: Issues, https://github.com/kouya-marino/AlchemyDetect/issues
+Keywords: detectron2,object-detection,instance-segmentation,gui,training
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyQt6>=6.5
+Requires-Dist: pyqtgraph>=0.13
+Requires-Dist: pycocotools>=2.0
+Requires-Dist: opencv-python>=4.8
+Requires-Dist: Pillow>=10.0
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Dynamic: license-file
+
+# AlchemyDetect
+
+A desktop GUI application for training and running inference with Detectron2 models.
+
+![AlchemyDetect](docs/app.jpg)
+
+## Features
+
+- **Train** object detection and instance segmentation models with a visual interface
+- **Live monitoring** — real-time loss plot and training logs
+- **Inference** on single images or entire folders with result visualization
+- **Model management** — save and load trained weights for later use
+
+## Supported Models
+
+| Model | Task |
+|-------|------|
+| Faster R-CNN (R50-FPN, R101-FPN) | Object Detection |
+| RetinaNet (R50-FPN, R101-FPN) | Object Detection |
+| Mask R-CNN (R50-FPN, R101-FPN) | Instance Segmentation |
+
+## Quick Start
+
+```bash
+# Install dependencies (see INSTALL.md for detailed setup)
+pip install -r requirements.txt
+
+# Run the application
+python main.py
+```
+
+## Dataset Format
+
+AlchemyDetect uses **COCO JSON** format for training datasets. You need:
+- A directory containing your training images
+- A COCO-format JSON annotation file
+
+## Usage
+
+### Training
+1. Open the **Train** tab
+2. Select your training images directory and COCO JSON annotation file
+3. Choose a model architecture from the dropdown
+4. Set hyperparameters (learning rate, iterations, batch size)
+5. Choose an output directory
+6. Click **Start Training**
+7. Monitor progress via the log viewer and loss plot
+
+### Inference
+1. Open the **Inference** tab
+2. Click **Load Model** and select a trained `.pth` file (config.yaml will be auto-detected if in the same directory)
+3. Adjust the confidence threshold
+4. Click **Run on Image** or **Run on Folder**
+5. Browse results using the navigation buttons
+
+## Tech Stack
+
+- **Python 3.10 or 3.11**
+- **PyQt6** — Desktop GUI
+- **Detectron2** — Object detection / instance segmentation
+- **PyTorch** — Deep learning backend
+- **pyqtgraph** — Real-time loss plotting
+
+## License
+
+[MIT](LICENSE)

alchemydetect-0.1.0/README.md

@@ -0,0 +1,66 @@
+# AlchemyDetect
+
+A desktop GUI application for training and running inference with Detectron2 models.
+
+![AlchemyDetect](docs/app.jpg)
+
+## Features
+
+- **Train** object detection and instance segmentation models with a visual interface
+- **Live monitoring** — real-time loss plot and training logs
+- **Inference** on single images or entire folders with result visualization
+- **Model management** — save and load trained weights for later use
+
+## Supported Models
+
+| Model | Task |
+|-------|------|
+| Faster R-CNN (R50-FPN, R101-FPN) | Object Detection |
+| RetinaNet (R50-FPN, R101-FPN) | Object Detection |
+| Mask R-CNN (R50-FPN, R101-FPN) | Instance Segmentation |
+
+## Quick Start
+
+```bash
+# Install dependencies (see INSTALL.md for detailed setup)
+pip install -r requirements.txt
+
+# Run the application
+python main.py
+```
+
+## Dataset Format
+
+AlchemyDetect uses **COCO JSON** format for training datasets. You need:
+- A directory containing your training images
+- A COCO-format JSON annotation file
+
+## Usage
+
+### Training
+1. Open the **Train** tab
+2. Select your training images directory and COCO JSON annotation file
+3. Choose a model architecture from the dropdown
+4. Set hyperparameters (learning rate, iterations, batch size)
+5. Choose an output directory
+6. Click **Start Training**
+7. Monitor progress via the log viewer and loss plot
+
+### Inference
+1. Open the **Inference** tab
+2. Click **Load Model** and select a trained `.pth` file (config.yaml will be auto-detected if in the same directory)
+3. Adjust the confidence threshold
+4. Click **Run on Image** or **Run on Folder**
+5. Browse results using the navigation buttons
+
+## Tech Stack
+
+- **Python 3.10 or 3.11**
+- **PyQt6** — Desktop GUI
+- **Detectron2** — Object detection / instance segmentation
+- **PyTorch** — Deep learning backend
+- **pyqtgraph** — Real-time loss plotting
+
+## License
+
+[MIT](LICENSE)

alchemydetect-0.1.0/alchemydetect/app.py

@@ -0,0 +1,23 @@
+"""Entry point for the AlchemyDetect application."""
+
+import multiprocessing
+import sys
+
+from PyQt6.QtWidgets import QApplication
+
+from alchemydetect.gui.main_window import MainWindow
+
+
+def main():
+    app = QApplication(sys.argv)
+    app.setApplicationName("AlchemyDetect")
+
+    window = MainWindow()
+    window.show()
+
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    multiprocessing.freeze_support()
+    main()

alchemydetect-0.1.0/alchemydetect/core/config_builder.py

@@ -0,0 +1,90 @@
+"""Build Detectron2 config from user-specified parameters."""
+
+import torch
+from detectron2 import model_zoo
+from detectron2.config import get_cfg
+
+from .dataset_utils import get_num_classes, register_coco_dataset
+from .model_catalog import get_config_path
+
+
+def build_cfg(
+    model_name,
+    train_images_dir,
+    train_json,
+    output_dir,
+    lr=0.0025,
+    max_iter=1000,
+    batch_size=2,
+    val_images_dir=None,
+    val_json=None,
+    resume=False,
+    weights_path=None,
+):
+    """Build a Detectron2 CfgNode from user selections.
+
+    Args:
+        model_name: Key from MODEL_ZOO (e.g. "Faster R-CNN (R50-FPN)")
+        train_images_dir: Path to training images directory
+        train_json: Path to COCO JSON annotations for training
+        output_dir: Directory to save checkpoints and logs
+        lr: Base learning rate
+        max_iter: Maximum training iterations
+        batch_size: Images per batch
+        val_images_dir: Optional path to validation images directory
+        val_json: Optional path to validation COCO JSON
+        resume: Whether to resume from last checkpoint in output_dir
+        weights_path: Optional path to custom weights (.pth). If None, uses model zoo pretrained.
+
+    Returns:
+        CfgNode ready for training.
+    """
+    config_path = get_config_path(model_name)
+    num_classes = get_num_classes(train_json)
+
+    # Register datasets
+    train_dataset_name = "alchemy_train"
+    register_coco_dataset(train_dataset_name, train_json, train_images_dir)
+
+    val_dataset_name = None
+    if val_json and val_images_dir:
+        val_dataset_name = "alchemy_val"
+        register_coco_dataset(val_dataset_name, val_json, val_images_dir)
+
+    cfg = get_cfg()
+    cfg.merge_from_file(model_zoo.get_config_file(config_path))
+
+    # Datasets
+    cfg.DATASETS.TRAIN = (train_dataset_name,)
+    cfg.DATASETS.TEST = (val_dataset_name,) if val_dataset_name else ()
+
+    # Dataloader
+    cfg.DATALOADER.NUM_WORKERS = 2
+
+    # Model weights
+    if weights_path:
+        cfg.MODEL.WEIGHTS = weights_path
+    else:
+        cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(config_path)
+
+    # Solver
+    cfg.SOLVER.IMS_PER_BATCH = batch_size
+    cfg.SOLVER.BASE_LR = lr
+    cfg.SOLVER.MAX_ITER = max_iter
+    cfg.SOLVER.STEPS = []  # No LR decay for simplicity
+    cfg.SOLVER.CHECKPOINT_PERIOD = max(max_iter // 5, 100)
+
+    # Number of classes
+    if hasattr(cfg.MODEL, "ROI_HEADS"):
+        cfg.MODEL.ROI_HEADS.NUM_CLASSES = num_classes
+    if hasattr(cfg.MODEL, "RETINANET"):
+        cfg.MODEL.RETINANET.NUM_CLASSES = num_classes
+
+    # Device
+    cfg.MODEL.DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # Output
+    cfg.OUTPUT_DIR = output_dir
+
+    cfg.freeze()
+    return cfg

alchemydetect-0.1.0/alchemydetect/core/dataset_utils.py

@@ -0,0 +1,62 @@
+"""COCO dataset registration helpers for Detectron2."""
+
+import json
+from pathlib import Path
+
+from detectron2.data import DatasetCatalog, MetadataCatalog
+from detectron2.data.datasets import register_coco_instances
+
+
+def register_coco_dataset(name, json_path, image_root):
+    """Register a COCO-format dataset, skipping if already registered."""
+    if name in DatasetCatalog.list():
+        DatasetCatalog.remove(name)
+        MetadataCatalog.remove(name)
+    register_coco_instances(name, {}, json_path, image_root)
+
+
+def validate_coco_json(json_path, image_root):
+    """Validate a COCO JSON file. Returns (is_valid, error_message)."""
+    json_path = Path(json_path)
+    image_root = Path(image_root)
+
+    if not json_path.exists():
+        return False, f"Annotation file not found: {json_path}"
+
+    if not image_root.exists():
+        return False, f"Image directory not found: {image_root}"
+
+    try:
+        with open(json_path, "r") as f:
+            data = json.load(f)
+    except json.JSONDecodeError as e:
+        return False, f"Invalid JSON: {e}"
+
+    for key in ("images", "annotations", "categories"):
+        if key not in data:
+            return False, f"Missing required key '{key}' in COCO JSON"
+
+    if len(data["categories"]) == 0:
+        return False, "No categories found in COCO JSON"
+
+    if len(data["images"]) == 0:
+        return False, "No images found in COCO JSON"
+
+    # Check that at least some image files exist
+    found = 0
+    for img_info in data["images"][:10]:
+        img_file = image_root / img_info["file_name"]
+        if img_file.exists():
+            found += 1
+
+    if found == 0:
+        return False, "None of the first 10 image files were found in the image directory"
+
+    return True, f"Valid COCO dataset: {len(data['images'])} images, {len(data['categories'])} categories"
+
+
+def get_num_classes(json_path):
+    """Return the number of categories in a COCO JSON file."""
+    with open(json_path, "r") as f:
+        data = json.load(f)
+    return len(data["categories"])

alchemydetect-0.1.0/alchemydetect/core/inferencer.py

@@ -0,0 +1,67 @@
+"""Inference wrapper around Detectron2's DefaultPredictor."""
+
+import cv2
+from detectron2.config import get_cfg
+from detectron2.data import MetadataCatalog
+from detectron2.engine import DefaultPredictor
+from detectron2.utils.visualizer import ColorMode, Visualizer
+
+
+def load_predictor(config_yaml_path, weights_path, threshold=0.5):
+    """Load a Detectron2 predictor from a saved config + weights pair.
+
+    Args:
+        config_yaml_path: Path to the saved config.yaml file.
+        weights_path: Path to the .pth weights file.
+        threshold: Confidence threshold for predictions.
+
+    Returns:
+        (DefaultPredictor, CfgNode)
+    """
+    cfg = get_cfg()
+    cfg.merge_from_file(config_yaml_path)
+    cfg.MODEL.WEIGHTS = weights_path
+    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold
+    if hasattr(cfg.MODEL, "RETINANET"):
+        cfg.MODEL.RETINANET.SCORE_THRESH_TEST = threshold
+    cfg.freeze()
+
+    predictor = DefaultPredictor(cfg)
+    return predictor, cfg
+
+
+def run_inference_single(predictor, image_path):
+    """Run inference on a single image.
+
+    Args:
+        predictor: A DefaultPredictor instance.
+        image_path: Path to the image file.
+
+    Returns:
+        (original_image_bgr, instances) where instances is the prediction output.
+    """
+    img = cv2.imread(str(image_path))
+    if img is None:
+        raise ValueError(f"Could not read image: {image_path}")
+    outputs = predictor(img)
+    return img, outputs["instances"].to("cpu")
+
+
+def visualize_predictions(image_bgr, instances, metadata=None):
+    """Draw predictions on an image using Detectron2's Visualizer.
+
+    Args:
+        image_bgr: Original image in BGR format (numpy array).
+        instances: Detectron2 Instances object (on CPU).
+        metadata: Optional MetadataCatalog metadata for class names.
+
+    Returns:
+        Annotated image as RGB numpy array.
+    """
+    image_rgb = image_bgr[:, :, ::-1]
+    if metadata is None:
+        metadata = MetadataCatalog.get("__empty")
+
+    v = Visualizer(image_rgb, metadata=metadata, scale=1.0, instance_mode=ColorMode.IMAGE)
+    out = v.draw_instance_predictions(instances)
+    return out.get_image()

alchemydetect-0.1.0/alchemydetect/core/model_catalog.py

@@ -0,0 +1,56 @@
+"""Available Detectron2 model zoo entries."""
+
+# Maps user-friendly name -> (model_zoo config path, task type)
+MODEL_ZOO = {
+    # Object Detection
+    "Faster R-CNN (R50-FPN)": {
+        "config": "COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml",
+        "task": "detection",
+    },
+    "Faster R-CNN (R101-FPN)": {
+        "config": "COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml",
+        "task": "detection",
+    },
+    "RetinaNet (R50-FPN)": {
+        "config": "COCO-Detection/retinanet_R_50_FPN_3x.yaml",
+        "task": "detection",
+    },
+    "RetinaNet (R101-FPN)": {
+        "config": "COCO-Detection/retinanet_R_101_FPN_3x.yaml",
+        "task": "detection",
+    },
+    # Instance Segmentation
+    "Mask R-CNN (R50-FPN)": {
+        "config": "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml",
+        "task": "instance_segmentation",
+    },
+    "Mask R-CNN (R101-FPN)": {
+        "config": "COCO-InstanceSegmentation/mask_rcnn_R_101_FPN_3x.yaml",
+        "task": "instance_segmentation",
+    },
+}
+
+
+def get_model_names():
+    """Return list of all available model names."""
+    return list(MODEL_ZOO.keys())
+
+
+def get_detection_models():
+    """Return names of detection-only models."""
+    return [k for k, v in MODEL_ZOO.items() if v["task"] == "detection"]
+
+
+def get_segmentation_models():
+    """Return names of instance segmentation models."""
+    return [k for k, v in MODEL_ZOO.items() if v["task"] == "instance_segmentation"]
+
+
+def get_config_path(model_name):
+    """Return the model zoo config path for a given model name."""
+    return MODEL_ZOO[model_name]["config"]
+
+
+def get_task(model_name):
+    """Return the task type ('detection' or 'instance_segmentation')."""
+    return MODEL_ZOO[model_name]["task"]

alchemydetect-0.1.0/alchemydetect/core/trainer.py

@@ -0,0 +1,67 @@
+"""Custom Detectron2 trainer with metric emission for the GUI."""
+
+import logging
+import sys
+
+from detectron2.engine import DefaultTrainer, HookBase
+
+
+class MetricEmitterHook(HookBase):
+    """Hook that pushes training metrics to a multiprocessing.Queue."""
+
+    def __init__(self, queue, stop_event, period=20):
+        """
+        Args:
+            queue: multiprocessing.Queue to push metric dicts into.
+            stop_event: multiprocessing.Event; when set, training stops.
+            period: Emit metrics every N iterations.
+        """
+        self._queue = queue
+        self._stop_event = stop_event
+        self._period = period
+
+    def after_step(self):
+        # Check for stop request
+        if self._stop_event.is_set():
+            self._queue.put({"type": "log", "msg": "Training stopped by user."})
+            sys.exit(0)
+
+        iter_num = self.trainer.iter
+        if (iter_num + 1) % self._period == 0:
+            storage = self.trainer.storage
+            metrics = {}
+            for k, v in storage.latest().items():
+                if isinstance(v, tuple):
+                    metrics[k] = v[0]
+            metrics["iter"] = iter_num + 1
+            metrics["type"] = "metrics"
+            self._queue.put(metrics)
+
+
+class QueueLogHandler(logging.Handler):
+    """Logging handler that sends log records to a multiprocessing.Queue."""
+
+    def __init__(self, queue):
+        super().__init__()
+        self._queue = queue
+
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            self._queue.put({"type": "log", "msg": msg})
+        except Exception:
+            pass
+
+
+class AlchemyTrainer(DefaultTrainer):
+    """Detectron2 trainer that emits metrics to a queue for GUI consumption."""
+
+    def __init__(self, cfg, metric_queue, stop_event):
+        self._metric_queue = metric_queue
+        self._stop_event = stop_event
+        super().__init__(cfg)
+
+    def build_hooks(self):
+        hooks = super().build_hooks()
+        hooks.append(MetricEmitterHook(self._metric_queue, self._stop_event))
+        return hooks

alchemydetect-0.1.0/alchemydetect/gui/dialogs.py

@@ -0,0 +1,81 @@
+"""File dialogs for model save/load and dataset selection."""
+
+import shutil
+from pathlib import Path
+
+from PyQt6.QtWidgets import QFileDialog, QMessageBox
+
+
+def browse_directory(parent, title="Select Directory", start_dir=""):
+    """Open a directory picker dialog. Returns path string or empty string."""
+    path = QFileDialog.getExistingDirectory(parent, title, start_dir)
+    return path
+
+
+def browse_file(parent, title="Select File", start_dir="", filter_str="All Files (*)"):
+    """Open a file picker dialog. Returns path string or empty string."""
+    path, _ = QFileDialog.getOpenFileName(parent, title, start_dir, filter_str)
+    return path
+
+
+def save_model_dialog(parent, output_dir):
+    """Save trained model (.pth + config.yaml) to a user-chosen directory.
+
+    Args:
+        parent: Parent widget.
+        output_dir: The training output directory containing model_final.pth and config.yaml.
+
+    Returns:
+        Path to the saved directory, or None if cancelled.
+    """
+    output_path = Path(output_dir)
+    weights_file = output_path / "model_final.pth"
+    config_file = output_path / "config.yaml"
+
+    if not weights_file.exists():
+        QMessageBox.warning(parent, "Save Model", "No model_final.pth found. Train a model first.")
+        return None
+
+    dest_dir = QFileDialog.getExistingDirectory(parent, "Save Model To Directory")
+    if not dest_dir:
+        return None
+
+    dest = Path(dest_dir)
+    try:
+        shutil.copy2(weights_file, dest / "model_final.pth")
+        if config_file.exists():
+            shutil.copy2(config_file, dest / "config.yaml")
+        QMessageBox.information(parent, "Save Model", f"Model saved to:\n{dest}")
+        return str(dest)
+    except Exception as e:
+        QMessageBox.critical(parent, "Save Model Error", str(e))
+        return None
+
+
+def load_model_dialog(parent):
+    """Open dialogs to select a model weights file and its config.
+
+    Returns:
+        (config_yaml_path, weights_path) or (None, None) if cancelled.
+    """
+    weights_path, _ = QFileDialog.getOpenFileName(
+        parent, "Select Model Weights", "", "PyTorch Weights (*.pth);;All Files (*)"
+    )
+    if not weights_path:
+        return None, None
+
+    # Try to auto-find config.yaml in the same directory
+    weights_dir = Path(weights_path).parent
+    auto_config = weights_dir / "config.yaml"
+
+    if auto_config.exists():
+        return str(auto_config), weights_path
+
+    # Ask user to select config manually
+    config_path, _ = QFileDialog.getOpenFileName(
+        parent, "Select Config YAML", str(weights_dir), "YAML Files (*.yaml *.yml);;All Files (*)"
+    )
+    if not config_path:
+        return None, None
+
+    return config_path, weights_path