| """Custom YOLOv8 Training & Export Script for E-Waste Cannibalization Index. |
| |
| Supports training on local splits (`splits/data.yaml`), Hugging Face dataset structures, |
| and exporting quantized TFLite INT8 models. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import logging |
| import os |
| import sys |
| from pathlib import Path |
|
|
| import yaml |
| from ultralytics import YOLO |
|
|
| |
| workspace_dir = Path(__file__).resolve().parent.parent |
| cache_dir = (workspace_dir / "data" / "cache").resolve() |
| cache_dir.mkdir(parents=True, exist_ok=True) |
| runs_dir = (workspace_dir / "data" / "runs").resolve() |
| runs_dir.mkdir(parents=True, exist_ok=True) |
|
|
| os.environ["TORCH_HOME"] = str(cache_dir) |
| os.environ["HF_HOME"] = str(cache_dir) |
| os.environ["ULTRALYTICS_CONFIG_DIR"] = str(cache_dir) |
|
|
| logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s") |
| log = logging.getLogger(__name__) |
|
|
| CONFIG_PATH = workspace_dir / "training" / "train_config.yaml" |
|
|
|
|
| def load_train_config(config_file: Path = CONFIG_PATH) -> dict: |
| if config_file.exists(): |
| with open(config_file, "r", encoding="utf-8") as f: |
| return yaml.safe_load(f) |
| return { |
| "data": "splits/data.yaml", |
| "model": "yolov8n.pt", |
| "imgsz": 960, |
| "epochs": 50, |
| "batch": 8, |
| "copy_paste": 0.8, |
| "cls": 2.5, |
| } |
|
|
|
|
| def run_training(config_override: dict | None = None, push_model_repo: str | None = None) -> dict: |
| cfg = load_train_config() |
| if config_override: |
| cfg.update(config_override) |
|
|
| log.info("Loaded training configuration: %s", cfg) |
|
|
| model_name = cfg.get("model", "yolov8n.pt") |
| |
| |
| raw_data_path = cfg.get("data", "splits/data.yaml") |
| data_path_obj = Path(raw_data_path) |
| if not data_path_obj.is_absolute(): |
| data_path_obj = (workspace_dir / raw_data_path).resolve() |
| |
| if not data_path_obj.exists(): |
| hf_dataset_yaml = workspace_dir / "huggingface_dataset" / "data.yaml" |
| if hf_dataset_yaml.exists(): |
| data_path_obj = hf_dataset_yaml.resolve() |
|
|
| data_yaml = str(data_path_obj) |
| epochs = int(cfg.get("epochs", 50)) |
| imgsz = int(cfg.get("imgsz", 960)) |
| batch_size = int(cfg.get("batch", 8)) |
|
|
| log.info("Initializing YOLO model backbone: %s", model_name) |
| model = YOLO(model_name) |
|
|
| |
| log.info("Starting YOLOv8 fine-tuning on %s (%d epochs, imgsz=%d)...", data_yaml, epochs, imgsz) |
| results = model.train( |
| data=data_yaml, |
| epochs=epochs, |
| imgsz=imgsz, |
| batch=batch_size, |
| copy_paste=float(cfg.get("copy_paste", 0.8)), |
| mosaic=float(cfg.get("mosaic", 1.0)), |
| mixup=float(cfg.get("mixup", 0.15)), |
| box=float(cfg.get("box", 7.5)), |
| cls=float(cfg.get("cls", 2.5)), |
| dfl=float(cfg.get("dfl", 1.5)), |
| project=str(runs_dir), |
| name="ewaste_purity_v1", |
| exist_ok=True, |
| verbose=True, |
| ) |
|
|
| |
| log.info("Validating trained model on test split...") |
| metrics = model.val(data=data_yaml, split="test", imgsz=imgsz) |
|
|
| maps_per_class = metrics.box.maps.tolist() if hasattr(metrics.box, "maps") else [] |
| mp = float(metrics.box.mp) if hasattr(metrics.box, "mp") else 0.0 |
| mr = float(metrics.box.mr) if hasattr(metrics.box, "mr") else 0.0 |
| map50 = float(metrics.box.map50) if hasattr(metrics.box, "map50") else 0.0 |
| map95 = float(metrics.box.map) if hasattr(metrics.box, "map") else 0.0 |
|
|
| eval_summary = { |
| "mean_precision": round(mp, 4), |
| "mean_recall": round(mr, 4), |
| "mAP_50": round(map50, 4), |
| "mAP_50_95": round(map95, 4), |
| "maps_per_class": maps_per_class, |
| } |
|
|
| eval_file = workspace_dir / "reports" / "model_eval_summary.json" |
| eval_file.parent.mkdir(parents=True, exist_ok=True) |
| eval_file.write_text(json.dumps(eval_summary, indent=2), encoding="utf-8") |
| log.info("Saved evaluation summary to %s", eval_file) |
|
|
| |
| try: |
| log.info("Exporting trained model to TFLite format...") |
| model.export(format="tflite", int8=True, imgsz=imgsz) |
| log.info("TFLite export successful!") |
| except Exception as exc: |
| log.warning("TFLite export deferred: %s", exc) |
|
|
| |
| if push_model_repo: |
| try: |
| from huggingface_hub import HfApi |
| api = HfApi() |
| api.create_repo(repo_id=push_model_repo, repo_type="model", exist_ok=True) |
| best_weights = runs_dir / "ewaste_purity_v1" / "weights" / "best.pt" |
| if best_weights.exists(): |
| api.upload_file( |
| path_or_fileobj=str(best_weights), |
| path_in_repo="model.pt", |
| repo_id=push_model_repo, |
| repo_type="model", |
| ) |
| log.info("Uploaded best model weights to Hugging Face Hub: %s", push_model_repo) |
| except Exception as exc: |
| log.warning("Could not upload model to Hugging Face Hub: %s", exc) |
|
|
| return eval_summary |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Custom YOLOv8 Training Script for E-Waste Cannibalization Index") |
| parser.add_argument("-e", "--epochs", type=int, default=50, help="Number of training epochs") |
| parser.add_argument("-b", "--batch", type=int, default=8, help="Training batch size") |
| parser.add_argument("-i", "--imgsz", type=int, default=960, help="Input image size") |
| parser.add_argument("-m", "--model", type=str, default="yolov8n.pt", help="YOLOv8 backbone model") |
| parser.add_argument("-d", "--data", type=str, default="splits/data.yaml", help="Path to data.yaml specification") |
| parser.add_argument("--push-model-to-hf", type=str, help="HF Hub model repository ID to upload trained weights") |
|
|
| args = parser.parse_args() |
| override = { |
| "epochs": args.epochs, |
| "batch": args.batch, |
| "imgsz": args.imgsz, |
| "model": args.model, |
| "data": args.data, |
| } |
| run_training(override, push_model_repo=args.push_model_to_hf) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
