How saeedahmadicp/teeth_segmentation works
Project type and purpose
• This is a research‐oriented machine‐learning codebase for performing teeth segmentation using UNet and its variants (UNet, UNet++, ResUNet, Attention UNet, etc.).
• The main goal is to load dental image data, train one of several UNet‐based architectures, compute segmentation metrics (accuracy, dice score), and save model checkpoints and results.
File structure
Top‐level files and directories:
• train.py – the entry point for training and evaluation
• dataset.py – data loading and preprocessing
• lookahead.py – custom optimizer wrapper (Lookahead)
• utils.py – logging, checkpoint saving, metric computation
• models/ – implementations of UNet variants and shared modules
– model.py (base UNet class & training wrapper)
– modules.py (building blocks: conv blocks, up/down samples)
– dense_unet.py, unetplusplus.py (specific architectures)
• attentions/ – custom attention modules (CBAM, custom spatial attention)
• losses/ – loss functions (DiceLoss, FocalLoss)
• configuration files: .gitignore, CITATION.cff, CONTRIBUTING.md, LICENSE, etc.
README for additional insights
• No external services; data must be provided manually.
• You run python train.py after pointing to your local dataset.
• The code reports test accuracy & dice score for each variant.
• Intended for learning—no production concerns like scaling or APIs.
a. Main components:
1. Data Source
– Raw dental images (external).
2. Data Loader & Preprocessor (dataset.py)
– Reads images, applies augmentations, resizes to desired resolution.
3. Model Architectures (models/ + attentions/)
– Base UNet, UNet++, Dense UNet, Attention modules (CBAM, custom).
4. Loss & Optimization (losses/, lookahead.py)
– FocalLoss, DiceLoss, optimizers (Adam + Lookahead).
5. Training Loop (train.py)
– Orchestrates data ingestion, forward/backward pass, logging.
6. Utilities (utils.py)
– Checkpointing, metric computation, visualization, logging to console/files.
7. Evaluation & Reporting
– Computes final metrics on test set; produces summary table.
b. Relationships and interactions:
c. Architectural patterns and design principles:
• Modularity: separate directories for models, losses, attentions.
• Dependency injection: train.py selects model variant, loss, and optimizer at runtime.
• Reusability: core UNet building blocks in modules.py; attention modules decoupled.
• Extensibility: plug new models or losses by dropping files into models/ or losses/.
d. Key technologies and libraries:
• PyTorch (implied by model definitions and training loops)
• Python scripting for orchestration
• NumPy, OpenCV or PIL for image I/O (in dataset.py)
• (Optional) CUDA/CuDNN for GPU acceleration
6. Offshoots from the training loop to “Logging & Checkpointing” (utils.py) and “Evaluation” (test metric computation).